RTEMS 4.11Annotated Report
Sat Mar 19 21:07:44 2011
0010e550 <IMFS_Set_handlers>:
#define MAXSYMLINK 5
int IMFS_Set_handlers(
rtems_filesystem_location_info_t *loc
)
{
10e550: 55 push %ebp
10e551: 89 e5 mov %esp,%ebp
10e553: 8b 45 08 mov 0x8(%ebp),%eax
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
10e556: 8b 50 10 mov 0x10(%eax),%edx
10e559: 8b 4a 34 mov 0x34(%edx),%ecx
switch( node->type ) {
10e55c: 8b 10 mov (%eax),%edx
10e55e: 83 7a 4c 07 cmpl $0x7,0x4c(%edx)
10e562: 77 12 ja 10e576 <IMFS_Set_handlers+0x26><== NEVER TAKEN
10e564: 8b 52 4c mov 0x4c(%edx),%edx
10e567: ff 24 95 30 02 12 00 jmp *0x120230(,%edx,4)
10e56e: 66 90 xchg %ax,%ax
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
10e570: 8b 51 0c mov 0xc(%ecx),%edx
10e573: 89 50 08 mov %edx,0x8(%eax)
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
10e576: 31 c0 xor %eax,%eax
10e578: c9 leave
10e579: c3 ret
10e57a: 66 90 xchg %ax,%ax
break;
case IMFS_LINEAR_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
10e57c: 8b 51 08 mov 0x8(%ecx),%edx
10e57f: 89 50 08 mov %edx,0x8(%eax)
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
10e582: 31 c0 xor %eax,%eax
10e584: c9 leave
10e585: c3 ret
10e586: 66 90 xchg %ax,%ax
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
break;
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
10e588: c7 40 08 e0 02 12 00 movl $0x1202e0,0x8(%eax)
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
10e58f: 31 c0 xor %eax,%eax
10e591: c9 leave
10e592: c3 ret
10e593: 90 nop
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_FIFO:
loc->handlers = fs_info->fifo_handlers;
10e594: 8b 51 10 mov 0x10(%ecx),%edx
10e597: 89 50 08 mov %edx,0x8(%eax)
break;
}
return 0;
}
10e59a: 31 c0 xor %eax,%eax
10e59c: c9 leave
10e59d: c3 ret
10e59e: 66 90 xchg %ax,%ax
switch( node->type ) {
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
10e5a0: c7 40 08 60 02 12 00 movl $0x120260,0x8(%eax)
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
10e5a7: 31 c0 xor %eax,%eax
10e5a9: c9 leave
10e5aa: c3 ret
0010ee98 <IMFS_check_node_remove>:
void IMFS_check_node_remove( IMFS_jnode_t *jnode )
{
10ee98: 55 push %ebp
10ee99: 89 e5 mov %esp,%ebp
10ee9b: 53 push %ebx
10ee9c: 83 ec 10 sub $0x10,%esp
10ee9f: 8b 5d 08 mov 0x8(%ebp),%ebx
if ( !rtems_libio_is_file_open( jnode ) && jnode->st_nlink < 1 ) {
10eea2: 53 push %ebx
10eea3: e8 2c 05 00 00 call 10f3d4 <rtems_libio_is_file_open>
10eea8: 83 c4 10 add $0x10,%esp
10eeab: 85 c0 test %eax,%eax
10eead: 75 2d jne 10eedc <IMFS_check_node_remove+0x44>
10eeaf: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx)
10eeb4: 75 26 jne 10eedc <IMFS_check_node_remove+0x44>
if ( rtems_filesystem_current.node_access == jnode )
10eeb6: a1 b0 41 12 00 mov 0x1241b0,%eax
10eebb: 39 58 04 cmp %ebx,0x4(%eax)
10eebe: 74 58 je 10ef18 <IMFS_check_node_remove+0x80><== NEVER TAKEN
rtems_filesystem_current.node_access = NULL;
switch ( jnode->type ) {
10eec0: 8b 43 4c mov 0x4c(%ebx),%eax
10eec3: 83 f8 04 cmp $0x4,%eax
10eec6: 74 34 je 10eefc <IMFS_check_node_remove+0x64>
10eec8: 83 f8 05 cmp $0x5,%eax
10eecb: 74 17 je 10eee4 <IMFS_check_node_remove+0x4c>
break;
default:
break;
}
free( jnode );
10eecd: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
10eed0: 8b 5d fc mov -0x4(%ebp),%ebx
10eed3: c9 leave
break;
default:
break;
}
free( jnode );
10eed4: e9 5b 87 ff ff jmp 107634 <free>
10eed9: 8d 76 00 lea 0x0(%esi),%esi
}
}
10eedc: 8b 5d fc mov -0x4(%ebp),%ebx
10eedf: c9 leave
10eee0: c3 ret
10eee1: 8d 76 00 lea 0x0(%esi),%esi
if ( rtems_filesystem_current.node_access == jnode )
rtems_filesystem_current.node_access = NULL;
switch ( jnode->type ) {
case IMFS_MEMORY_FILE:
IMFS_memfile_remove( jnode );
10eee4: 83 ec 0c sub $0xc,%esp
10eee7: 53 push %ebx
10eee8: e8 7b 1e 00 00 call 110d68 <IMFS_memfile_remove>
break;
10eeed: 83 c4 10 add $0x10,%esp
break;
default:
break;
}
free( jnode );
10eef0: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
10eef3: 8b 5d fc mov -0x4(%ebp),%ebx
10eef6: c9 leave
break;
default:
break;
}
free( jnode );
10eef7: e9 38 87 ff ff jmp 107634 <free>
switch ( jnode->type ) {
case IMFS_MEMORY_FILE:
IMFS_memfile_remove( jnode );
break;
case IMFS_SYM_LINK:
free( jnode->info.sym_link.name );
10eefc: 83 ec 0c sub $0xc,%esp
10eeff: ff 73 50 pushl 0x50(%ebx)
10ef02: e8 2d 87 ff ff call 107634 <free>
break;
10ef07: 83 c4 10 add $0x10,%esp
default:
break;
}
free( jnode );
10ef0a: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
10ef0d: 8b 5d fc mov -0x4(%ebp),%ebx
10ef10: c9 leave
break;
default:
break;
}
free( jnode );
10ef11: e9 1e 87 ff ff jmp 107634 <free>
10ef16: 66 90 xchg %ax,%ax
void IMFS_check_node_remove( IMFS_jnode_t *jnode )
{
if ( !rtems_libio_is_file_open( jnode ) && jnode->st_nlink < 1 ) {
if ( rtems_filesystem_current.node_access == jnode )
rtems_filesystem_current.node_access = NULL;
10ef18: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
10ef1f: eb 9f jmp 10eec0 <IMFS_check_node_remove+0x28>
0010e3e4 <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
10e3e4: 55 push %ebp
10e3e5: 89 e5 mov %esp,%ebp
10e3e7: 57 push %edi
10e3e8: 56 push %esi
10e3e9: 53 push %ebx
10e3ea: 83 ec 1c sub $0x1c,%esp
10e3ed: 8b 45 08 mov 0x8(%ebp),%eax
10e3f0: 8b 5d 0c mov 0xc(%ebp),%ebx
IMFS_fs_info_t *fs_info;
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
10e3f3: 85 c0 test %eax,%eax
10e3f5: 0f 84 ba 00 00 00 je 10e4b5 <IMFS_create_node+0xd1> <== NEVER TAKEN
return NULL;
parent = parent_loc->node_access;
10e3fb: 8b 38 mov (%eax),%edi
fs_info = parent_loc->mt_entry->fs_info;
10e3fd: 8b 40 10 mov 0x10(%eax),%eax
10e400: 8b 70 34 mov 0x34(%eax),%esi
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
10e403: 83 fb 07 cmp $0x7,%ebx
10e406: 0f 84 9c 00 00 00 je 10e4a8 <IMFS_create_node+0xc4>
return NULL;
/*
* Allocate filesystem node and fill in basic information
*/
node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
10e40c: 50 push %eax
10e40d: a1 b0 41 12 00 mov 0x1241b0,%eax
10e412: 8b 40 2c mov 0x2c(%eax),%eax
10e415: f7 d0 not %eax
10e417: 23 45 14 and 0x14(%ebp),%eax
10e41a: 50 push %eax
10e41b: ff 75 10 pushl 0x10(%ebp)
10e41e: 53 push %ebx
10e41f: e8 54 ff ff ff call 10e378 <IMFS_allocate_node>
if ( !node )
10e424: 83 c4 10 add $0x10,%esp
10e427: 85 c0 test %eax,%eax
10e429: 74 73 je 10e49e <IMFS_create_node+0xba>
return NULL;
/*
* Set the type specific information
*/
if ( type == IMFS_DIRECTORY ) {
10e42b: 83 fb 01 cmp $0x1,%ebx
10e42e: 74 38 je 10e468 <IMFS_create_node+0x84>
rtems_chain_initialize_empty(&node->info.directory.Entries);
} else if ( type == IMFS_HARD_LINK ) {
10e430: 83 fb 03 cmp $0x3,%ebx
10e433: 0f 84 97 00 00 00 je 10e4d0 <IMFS_create_node+0xec>
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
10e439: 83 fb 04 cmp $0x4,%ebx
10e43c: 0f 84 8e 00 00 00 je 10e4d0 <IMFS_create_node+0xec>
node->info.sym_link.name = info->sym_link.name;
} else if ( type == IMFS_DEVICE ) {
10e442: 83 fb 02 cmp $0x2,%ebx
10e445: 74 79 je 10e4c0 <IMFS_create_node+0xdc>
node->info.device.major = info->device.major;
node->info.device.minor = info->device.minor;
} else if ( type == IMFS_LINEAR_FILE ) {
10e447: 83 fb 06 cmp $0x6,%ebx
10e44a: 0f 84 8c 00 00 00 je 10e4dc <IMFS_create_node+0xf8>
node->info.linearfile.size = 0;
node->info.linearfile.direct = 0;
} else if ( type == IMFS_MEMORY_FILE ) {
10e450: 83 fb 05 cmp $0x5,%ebx
10e453: 0f 84 9b 00 00 00 je 10e4f4 <IMFS_create_node+0x110>
node->info.file.size = 0;
node->info.file.indirect = 0;
node->info.file.doubly_indirect = 0;
node->info.file.triply_indirect = 0;
} else if ( type == IMFS_FIFO ) {
10e459: 83 fb 07 cmp $0x7,%ebx
10e45c: 75 1d jne 10e47b <IMFS_create_node+0x97> <== NEVER TAKEN
node->info.fifo.pipe = NULL;
10e45e: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
10e465: eb 14 jmp 10e47b <IMFS_create_node+0x97>
10e467: 90 nop
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
10e468: 8d 50 54 lea 0x54(%eax),%edx
10e46b: 89 50 50 mov %edx,0x50(%eax)
head->next = tail;
head->previous = NULL;
10e46e: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
10e475: 8d 50 50 lea 0x50(%eax),%edx
10e478: 89 50 58 mov %edx,0x58(%eax)
}
/*
* This node MUST have a parent, so put it in that directory list.
*/
node->Parent = parent;
10e47b: 89 78 08 mov %edi,0x8(%eax)
node->st_ino = ++fs_info->ino_count;
10e47e: 8b 56 04 mov 0x4(%esi),%edx
10e481: 42 inc %edx
10e482: 89 56 04 mov %edx,0x4(%esi)
10e485: 89 50 38 mov %edx,0x38(%eax)
10e488: 83 ec 08 sub $0x8,%esp
10e48b: 50 push %eax
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
10e48c: 83 c7 50 add $0x50,%edi
10e48f: 57 push %edi
10e490: 89 45 e4 mov %eax,-0x1c(%ebp)
10e493: e8 ec cf ff ff call 10b484 <_Chain_Append>
return node;
10e498: 83 c4 10 add $0x10,%esp
10e49b: 8b 45 e4 mov -0x1c(%ebp),%eax
}
10e49e: 8d 65 f4 lea -0xc(%ebp),%esp
10e4a1: 5b pop %ebx
10e4a2: 5e pop %esi
10e4a3: 5f pop %edi
10e4a4: c9 leave
10e4a5: c3 ret
10e4a6: 66 90 xchg %ax,%ax
fs_info = parent_loc->mt_entry->fs_info;
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
10e4a8: 81 7e 10 c0 01 12 00 cmpl $0x1201c0,0x10(%esi)
10e4af: 0f 85 57 ff ff ff jne 10e40c <IMFS_create_node+0x28>
fs_info->fifo_handlers == &rtems_filesystem_handlers_default )
return NULL;
10e4b5: 31 c0 xor %eax,%eax
node->st_ino = ++fs_info->ino_count;
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
return node;
}
10e4b7: 8d 65 f4 lea -0xc(%ebp),%esp
10e4ba: 5b pop %ebx
10e4bb: 5e pop %esi
10e4bc: 5f pop %edi
10e4bd: c9 leave
10e4be: c3 ret
10e4bf: 90 nop
} else if ( type == IMFS_HARD_LINK ) {
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
node->info.sym_link.name = info->sym_link.name;
} else if ( type == IMFS_DEVICE ) {
node->info.device.major = info->device.major;
10e4c0: 8b 4d 18 mov 0x18(%ebp),%ecx
10e4c3: 8b 11 mov (%ecx),%edx
10e4c5: 89 50 50 mov %edx,0x50(%eax)
node->info.device.minor = info->device.minor;
10e4c8: 8b 51 04 mov 0x4(%ecx),%edx
10e4cb: 89 50 54 mov %edx,0x54(%eax)
10e4ce: eb ab jmp 10e47b <IMFS_create_node+0x97>
if ( type == IMFS_DIRECTORY ) {
rtems_chain_initialize_empty(&node->info.directory.Entries);
} else if ( type == IMFS_HARD_LINK ) {
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
node->info.sym_link.name = info->sym_link.name;
10e4d0: 8b 4d 18 mov 0x18(%ebp),%ecx
10e4d3: 8b 11 mov (%ecx),%edx
10e4d5: 89 50 50 mov %edx,0x50(%eax)
10e4d8: eb a1 jmp 10e47b <IMFS_create_node+0x97>
10e4da: 66 90 xchg %ax,%ax
} else if ( type == IMFS_DEVICE ) {
node->info.device.major = info->device.major;
node->info.device.minor = info->device.minor;
} else if ( type == IMFS_LINEAR_FILE ) {
node->info.linearfile.size = 0;
10e4dc: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
10e4e3: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.linearfile.direct = 0;
10e4ea: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
10e4f1: eb 88 jmp 10e47b <IMFS_create_node+0x97>
10e4f3: 90 nop
} else if ( type == IMFS_MEMORY_FILE ) {
node->info.file.size = 0;
10e4f4: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
10e4fb: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.file.indirect = 0;
10e502: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
node->info.file.doubly_indirect = 0;
10e509: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
node->info.file.triply_indirect = 0;
10e510: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
10e517: e9 5f ff ff ff jmp 10e47b <IMFS_create_node+0x97>
00109a58 <IMFS_dump_directory>:
*/
void IMFS_dump_directory(
IMFS_jnode_t *the_directory,
int level
)
{
109a58: 55 push %ebp
109a59: 89 e5 mov %esp,%ebp
109a5b: 57 push %edi
109a5c: 56 push %esi
109a5d: 53 push %ebx
109a5e: 83 ec 1c sub $0x1c,%esp
109a61: 8b 45 08 mov 0x8(%ebp),%eax
109a64: 8b 75 0c mov 0xc(%ebp),%esi
*
*/
int IMFS_memfile_maximum_size( void )
{
return IMFS_MEMFILE_MAXIMUM_SIZE;
}
109a67: 8b 78 50 mov 0x50(%eax),%edi
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
109a6a: 83 c0 54 add $0x54,%eax
109a6d: 89 45 e4 mov %eax,-0x1c(%ebp)
IMFS_assert( level >= 0 );
IMFS_assert( the_directory->type == IMFS_DIRECTORY );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
109a70: 39 c7 cmp %eax,%edi
109a72: 74 47 je 109abb <IMFS_dump_directory+0x63>
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( the_jnode->type == IMFS_DIRECTORY )
IMFS_dump_directory( the_jnode, level + 1 );
109a74: 8d 46 01 lea 0x1(%esi),%eax
109a77: 89 45 e0 mov %eax,-0x20(%ebp)
109a7a: 66 90 xchg %ax,%ax
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
109a7c: 85 f6 test %esi,%esi
109a7e: 78 22 js 109aa2 <IMFS_dump_directory+0x4a><== NEVER TAKEN
109a80: 31 db xor %ebx,%ebx
109a82: 66 90 xchg %ax,%ax
fprintf(stdout, "...." );
109a84: a1 00 ab 12 00 mov 0x12ab00,%eax
109a89: ff 70 08 pushl 0x8(%eax)
109a8c: 6a 04 push $0x4
109a8e: 6a 01 push $0x1
109a90: 68 12 5b 12 00 push $0x125b12
109a95: e8 be d5 00 00 call 117058 <fwrite>
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
109a9a: 43 inc %ebx
109a9b: 83 c4 10 add $0x10,%esp
109a9e: 39 de cmp %ebx,%esi
109aa0: 7d e2 jge 109a84 <IMFS_dump_directory+0x2c>
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
109aa2: 83 ec 0c sub $0xc,%esp
109aa5: 57 push %edi
109aa6: e8 75 fe ff ff call 109920 <IMFS_print_jnode>
if ( the_jnode->type == IMFS_DIRECTORY )
109aab: 83 c4 10 add $0x10,%esp
109aae: 83 7f 4c 01 cmpl $0x1,0x4c(%edi)
109ab2: 74 10 je 109ac4 <IMFS_dump_directory+0x6c>
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
109ab4: 8b 3f mov (%edi),%edi
IMFS_assert( level >= 0 );
IMFS_assert( the_directory->type == IMFS_DIRECTORY );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
109ab6: 3b 7d e4 cmp -0x1c(%ebp),%edi
109ab9: 75 c1 jne 109a7c <IMFS_dump_directory+0x24>
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( the_jnode->type == IMFS_DIRECTORY )
IMFS_dump_directory( the_jnode, level + 1 );
}
}
109abb: 8d 65 f4 lea -0xc(%ebp),%esp
109abe: 5b pop %ebx
109abf: 5e pop %esi
109ac0: 5f pop %edi
109ac1: c9 leave
109ac2: c3 ret
109ac3: 90 nop
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( the_jnode->type == IMFS_DIRECTORY )
IMFS_dump_directory( the_jnode, level + 1 );
109ac4: 83 ec 08 sub $0x8,%esp
109ac7: ff 75 e0 pushl -0x20(%ebp)
109aca: 57 push %edi
109acb: e8 88 ff ff ff call 109a58 <IMFS_dump_directory>
109ad0: 83 c4 10 add $0x10,%esp
109ad3: eb df jmp 109ab4 <IMFS_dump_directory+0x5c>
0010e62c <IMFS_eval_path>:
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
10e62c: 55 push %ebp
10e62d: 89 e5 mov %esp,%ebp
10e62f: 57 push %edi
10e630: 56 push %esi
10e631: 53 push %ebx
10e632: 83 ec 5c sub $0x5c,%esp
char token[ IMFS_NAME_MAX + 1 ];
rtems_filesystem_location_info_t newloc;
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
10e635: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp)
10e63c: 0f 85 ee 01 00 00 jne 10e830 <IMFS_eval_path+0x204> <== NEVER TAKEN
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
10e642: 8b 45 14 mov 0x14(%ebp),%eax
10e645: 8b 38 mov (%eax),%edi
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
int i = 0;
10e647: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp)
10e64e: 8d 75 af lea -0x51(%ebp),%esi
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
10e651: 8d 55 e4 lea -0x1c(%ebp),%edx
10e654: 52 push %edx
10e655: 56 push %esi
10e656: ff 75 0c pushl 0xc(%ebp)
10e659: 8b 45 08 mov 0x8(%ebp),%eax
10e65c: 03 45 a4 add -0x5c(%ebp),%eax
10e65f: 50 push %eax
10e660: e8 17 07 00 00 call 10ed7c <IMFS_get_token>
10e665: 89 c3 mov %eax,%ebx
pathnamelen -= len;
10e667: 8b 55 e4 mov -0x1c(%ebp),%edx
i += len;
if ( !pathloc->node_access )
10e66a: 8b 4d 14 mov 0x14(%ebp),%ecx
10e66d: 8b 01 mov (%ecx),%eax
10e66f: 83 c4 10 add $0x10,%esp
10e672: 85 c0 test %eax,%eax
10e674: 0f 84 e6 00 00 00 je 10e760 <IMFS_eval_path+0x134> <== NEVER TAKEN
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
10e67a: 29 55 0c sub %edx,0xc(%ebp)
i += len;
10e67d: 01 55 a4 add %edx,-0x5c(%ebp)
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
10e680: 85 db test %ebx,%ebx
10e682: 75 44 jne 10e6c8 <IMFS_eval_path+0x9c>
* new fs root node and let let the mounted filesystem set the handlers.
*
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
10e684: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
10e688: 0f 84 26 01 00 00 je 10e7b4 <IMFS_eval_path+0x188>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
10e68e: 83 ec 0c sub $0xc,%esp
10e691: ff 75 14 pushl 0x14(%ebp)
10e694: e8 b7 fe ff ff call 10e550 <IMFS_Set_handlers>
10e699: 89 c3 mov %eax,%ebx
10e69b: 5a pop %edx
10e69c: 59 pop %ecx
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
10e69d: ff 75 10 pushl 0x10(%ebp)
10e6a0: ff 75 14 pushl 0x14(%ebp)
10e6a3: e8 04 ff ff ff call 10e5ac <IMFS_evaluate_permission>
10e6a8: 83 c4 10 add $0x10,%esp
10e6ab: 85 c0 test %eax,%eax
10e6ad: 0f 85 d1 00 00 00 jne 10e784 <IMFS_eval_path+0x158>
rtems_set_errno_and_return_minus_one( EACCES );
10e6b3: e8 24 37 00 00 call 111ddc <__errno>
10e6b8: c7 00 0d 00 00 00 movl $0xd,(%eax)
10e6be: bb ff ff ff ff mov $0xffffffff,%ebx
10e6c3: e9 bc 00 00 00 jmp 10e784 <IMFS_eval_path+0x158>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
10e6c8: 83 7f 4c 01 cmpl $0x1,0x4c(%edi)
10e6cc: 0f 84 be 00 00 00 je 10e790 <IMFS_eval_path+0x164>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
10e6d2: 89 c7 mov %eax,%edi
switch( type ) {
10e6d4: 83 fb 03 cmp $0x3,%ebx
10e6d7: 74 1b je 10e6f4 <IMFS_eval_path+0xc8>
10e6d9: 83 fb 04 cmp $0x4,%ebx
10e6dc: 0f 84 92 00 00 00 je 10e774 <IMFS_eval_path+0x148>
10e6e2: 83 fb 02 cmp $0x2,%ebx
10e6e5: 74 51 je 10e738 <IMFS_eval_path+0x10c>
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
10e6e7: 83 fb 04 cmp $0x4,%ebx
10e6ea: 0f 85 61 ff ff ff jne 10e651 <IMFS_eval_path+0x25> <== ALWAYS TAKEN
10e6f0: eb 92 jmp 10e684 <IMFS_eval_path+0x58> <== NOT EXECUTED
10e6f2: 66 90 xchg %ax,%ax <== NOT EXECUTED
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
10e6f4: 8b 40 4c mov 0x4c(%eax),%eax
10e6f7: 83 f8 03 cmp $0x3,%eax
10e6fa: 0f 84 08 01 00 00 je 10e808 <IMFS_eval_path+0x1dc>
* It would be a design error if we evaluated the link and
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
10e700: 83 f8 04 cmp $0x4,%eax
10e703: 0f 84 51 01 00 00 je 10e85a <IMFS_eval_path+0x22e>
}
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10e709: 48 dec %eax
10e70a: 0f 85 35 01 00 00 jne 10e845 <IMFS_eval_path+0x219>
/*
* If we are at a node that is a mount point. Set loc to the
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
10e710: 8b 47 5c mov 0x5c(%edi),%eax
10e713: 85 c0 test %eax,%eax
10e715: 0f 85 a4 00 00 00 jne 10e7bf <IMFS_eval_path+0x193>
}
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10e71b: 83 ec 08 sub $0x8,%esp
10e71e: 56 push %esi
10e71f: 57 push %edi
10e720: e8 eb 05 00 00 call 10ed10 <IMFS_find_match_in_dir>
10e725: 89 c7 mov %eax,%edi
if ( !node )
10e727: 83 c4 10 add $0x10,%esp
10e72a: 85 c0 test %eax,%eax
10e72c: 74 32 je 10e760 <IMFS_eval_path+0x134>
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
10e72e: 8b 45 14 mov 0x14(%ebp),%eax
10e731: 89 38 mov %edi,(%eax)
10e733: e9 19 ff ff ff jmp 10e651 <IMFS_eval_path+0x25>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
10e738: 8b 15 b0 41 12 00 mov 0x1241b0,%edx
10e73e: 39 42 18 cmp %eax,0x18(%edx)
10e741: 0f 84 0a ff ff ff je 10e651 <IMFS_eval_path+0x25>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
pathloc->mt_entry->mt_fs_root.node_access) {
10e747: 8b 4d 14 mov 0x14(%ebp),%ecx
10e74a: 8b 51 10 mov 0x10(%ecx),%edx
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
10e74d: 39 42 1c cmp %eax,0x1c(%edx)
10e750: 0f 84 d2 00 00 00 je 10e828 <IMFS_eval_path+0x1fc>
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
10e756: 8b 78 08 mov 0x8(%eax),%edi
10e759: 85 ff test %edi,%edi
10e75b: 75 d1 jne 10e72e <IMFS_eval_path+0x102>
10e75d: 8d 76 00 lea 0x0(%esi),%esi
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
if ( !node )
rtems_set_errno_and_return_minus_one( ENOENT );
10e760: e8 77 36 00 00 call 111ddc <__errno>
10e765: c7 00 02 00 00 00 movl $0x2,(%eax)
10e76b: bb ff ff ff ff mov $0xffffffff,%ebx
10e770: eb 12 jmp 10e784 <IMFS_eval_path+0x158>
10e772: 66 90 xchg %ax,%ax
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
10e774: e8 63 36 00 00 call 111ddc <__errno>
10e779: c7 00 5b 00 00 00 movl $0x5b,(%eax)
10e77f: bb ff ff ff ff mov $0xffffffff,%ebx
if ( !IMFS_evaluate_permission( pathloc, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10e784: 89 d8 mov %ebx,%eax
10e786: 8d 65 f4 lea -0xc(%ebp),%esp
10e789: 5b pop %ebx
10e78a: 5e pop %esi
10e78b: 5f pop %edi
10e78c: c9 leave
10e78d: c3 ret
10e78e: 66 90 xchg %ax,%ax
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
10e790: 83 ec 08 sub $0x8,%esp
10e793: 6a 01 push $0x1
10e795: ff 75 14 pushl 0x14(%ebp)
10e798: e8 0f fe ff ff call 10e5ac <IMFS_evaluate_permission>
10e79d: 83 c4 10 add $0x10,%esp
10e7a0: 85 c0 test %eax,%eax
10e7a2: 0f 84 0b ff ff ff je 10e6b3 <IMFS_eval_path+0x87>
10e7a8: 8b 55 14 mov 0x14(%ebp),%edx
10e7ab: 8b 02 mov (%edx),%eax
10e7ad: e9 20 ff ff ff jmp 10e6d2 <IMFS_eval_path+0xa6>
10e7b2: 66 90 xchg %ax,%ax
*
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
10e7b4: 8b 40 5c mov 0x5c(%eax),%eax
10e7b7: 85 c0 test %eax,%eax
10e7b9: 0f 84 cf fe ff ff je 10e68e <IMFS_eval_path+0x62>
newloc = node->info.directory.mt_fs->mt_fs_root;
10e7bf: 8d 7d d0 lea -0x30(%ebp),%edi
10e7c2: 8d 70 1c lea 0x1c(%eax),%esi
10e7c5: b9 05 00 00 00 mov $0x5,%ecx
10e7ca: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*pathloc = newloc;
10e7cc: 8d 75 d0 lea -0x30(%ebp),%esi
10e7cf: b1 05 mov $0x5,%cl
10e7d1: 8b 7d 14 mov 0x14(%ebp),%edi
10e7d4: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
10e7d6: 8b 55 e4 mov -0x1c(%ebp),%edx
10e7d9: 8b 4d 14 mov 0x14(%ebp),%ecx
10e7dc: 8b 41 0c mov 0xc(%ecx),%eax
10e7df: 51 push %ecx
10e7e0: ff 75 10 pushl 0x10(%ebp)
10e7e3: 8b 4d 0c mov 0xc(%ebp),%ecx
10e7e6: 01 d1 add %edx,%ecx
10e7e8: 51 push %ecx
10e7e9: 8b 4d a4 mov -0x5c(%ebp),%ecx
10e7ec: 29 d1 sub %edx,%ecx
10e7ee: 8b 55 08 mov 0x8(%ebp),%edx
10e7f1: 01 ca add %ecx,%edx
10e7f3: 52 push %edx
10e7f4: ff 10 call *(%eax)
10e7f6: 89 c3 mov %eax,%ebx
10e7f8: 83 c4 10 add $0x10,%esp
if ( !IMFS_evaluate_permission( pathloc, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10e7fb: 89 d8 mov %ebx,%eax
10e7fd: 8d 65 f4 lea -0xc(%ebp),%esp
10e800: 5b pop %ebx
10e801: 5e pop %esi
10e802: 5f pop %edi
10e803: c9 leave
10e804: c3 ret
10e805: 8d 76 00 lea 0x0(%esi),%esi
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
IMFS_evaluate_hard_link( pathloc, 0 );
10e808: 83 ec 08 sub $0x8,%esp
10e80b: 6a 00 push $0x0
10e80d: ff 75 14 pushl 0x14(%ebp)
10e810: e8 d3 fd ff ff call 10e5e8 <IMFS_evaluate_hard_link>
node = pathloc->node_access;
10e815: 8b 55 14 mov 0x14(%ebp),%edx
10e818: 8b 3a mov (%edx),%edi
10e81a: 8b 47 4c mov 0x4c(%edi),%eax
10e81d: 83 c4 10 add $0x10,%esp
10e820: e9 e4 fe ff ff jmp 10e709 <IMFS_eval_path+0xdd>
10e825: 8d 76 00 lea 0x0(%esi),%esi
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
newloc = pathloc->mt_entry->mt_point_node;
10e828: 8d 7d d0 lea -0x30(%ebp),%edi
10e82b: 8d 72 08 lea 0x8(%edx),%esi
10e82e: eb 95 jmp 10e7c5 <IMFS_eval_path+0x199>
rtems_filesystem_location_info_t newloc;
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
rtems_set_errno_and_return_minus_one( EIO );
10e830: e8 a7 35 00 00 call 111ddc <__errno> <== NOT EXECUTED
10e835: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
10e83b: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
10e840: e9 3f ff ff ff jmp 10e784 <IMFS_eval_path+0x158> <== NOT EXECUTED
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
10e845: e8 92 35 00 00 call 111ddc <__errno>
10e84a: c7 00 14 00 00 00 movl $0x14,(%eax)
10e850: bb ff ff ff ff mov $0xffffffff,%ebx
10e855: e9 2a ff ff ff jmp 10e784 <IMFS_eval_path+0x158>
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
10e85a: 83 ec 08 sub $0x8,%esp
10e85d: 6a 00 push $0x0
10e85f: ff 75 14 pushl 0x14(%ebp)
10e862: e8 1d 00 00 00 call 10e884 <IMFS_evaluate_sym_link>
10e867: 89 c3 mov %eax,%ebx
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
10e869: 8b 4d 14 mov 0x14(%ebp),%ecx
10e86c: 8b 39 mov (%ecx),%edi
if ( result == -1 )
10e86e: 83 c4 10 add $0x10,%esp
10e871: 83 f8 ff cmp $0xffffffff,%eax
10e874: 0f 84 0a ff ff ff je 10e784 <IMFS_eval_path+0x158> <== NEVER TAKEN
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
10e87a: 8b 47 4c mov 0x4c(%edi),%eax
10e87d: e9 87 fe ff ff jmp 10e709 <IMFS_eval_path+0xdd>
0010e9ac <IMFS_evaluate_for_make>:
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
10e9ac: 55 push %ebp
10e9ad: 89 e5 mov %esp,%ebp
10e9af: 57 push %edi
10e9b0: 56 push %esi
10e9b1: 53 push %ebx
10e9b2: 83 ec 5c sub $0x5c,%esp
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
10e9b5: 8b 45 0c mov 0xc(%ebp),%eax
10e9b8: 8b 18 mov (%eax),%ebx
/*
* Get the path length.
*/
pathlen = strlen( path );
10e9ba: 31 c0 xor %eax,%eax
10e9bc: b9 ff ff ff ff mov $0xffffffff,%ecx
10e9c1: 8b 7d 08 mov 0x8(%ebp),%edi
10e9c4: f2 ae repnz scas %es:(%edi),%al
10e9c6: f7 d1 not %ecx
10e9c8: 8d 71 ff lea -0x1(%ecx),%esi
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
int i = 0;
10e9cb: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp)
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
10e9d2: 8d 55 e4 lea -0x1c(%ebp),%edx
10e9d5: 52 push %edx
10e9d6: 8d 4d af lea -0x51(%ebp),%ecx
10e9d9: 51 push %ecx
10e9da: 56 push %esi
10e9db: 8b 45 08 mov 0x8(%ebp),%eax
10e9de: 03 45 a4 add -0x5c(%ebp),%eax
10e9e1: 50 push %eax
10e9e2: e8 95 03 00 00 call 10ed7c <IMFS_get_token>
10e9e7: 89 c7 mov %eax,%edi
pathlen -= len;
10e9e9: 8b 55 e4 mov -0x1c(%ebp),%edx
10e9ec: 29 d6 sub %edx,%esi
i += len;
if ( !pathloc->node_access )
10e9ee: 8b 4d 0c mov 0xc(%ebp),%ecx
10e9f1: 8b 01 mov (%ecx),%eax
10e9f3: 83 c4 10 add $0x10,%esp
10e9f6: 85 c0 test %eax,%eax
10e9f8: 0f 84 55 01 00 00 je 10eb53 <IMFS_evaluate_for_make+0x1a7><== NEVER TAKEN
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
10e9fe: 85 ff test %edi,%edi
10ea00: 75 1a jne 10ea1c <IMFS_evaluate_for_make+0x70>
pathloc->node_access = node;
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
10ea02: e8 d5 33 00 00 call 111ddc <__errno>
10ea07: c7 00 11 00 00 00 movl $0x11,(%eax)
10ea0d: bb ff ff ff ff mov $0xffffffff,%ebx
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10ea12: 89 d8 mov %ebx,%eax
10ea14: 8d 65 f4 lea -0xc(%ebp),%esp
10ea17: 5b pop %ebx
10ea18: 5e pop %esi
10ea19: 5f pop %edi
10ea1a: c9 leave
10ea1b: c3 ret
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
10ea1c: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10ea20: 0f 84 c6 00 00 00 je 10eaec <IMFS_evaluate_for_make+0x140>
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
i += len;
10ea26: 01 55 a4 add %edx,-0x5c(%ebp)
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
10ea29: 89 c3 mov %eax,%ebx
switch( type ) {
10ea2b: 83 ff 02 cmp $0x2,%edi
10ea2e: 0f 84 88 00 00 00 je 10eabc <IMFS_evaluate_for_make+0x110>
10ea34: 76 26 jbe 10ea5c <IMFS_evaluate_for_make+0xb0>
10ea36: 83 ff 03 cmp $0x3,%edi
10ea39: 74 2d je 10ea68 <IMFS_evaluate_for_make+0xbc>
10ea3b: 83 ff 04 cmp $0x4,%edi
10ea3e: 75 92 jne 10e9d2 <IMFS_evaluate_for_make+0x26><== NEVER TAKEN
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
10ea40: e8 97 33 00 00 call 111ddc <__errno>
10ea45: c7 00 5b 00 00 00 movl $0x5b,(%eax)
10ea4b: bb ff ff ff ff mov $0xffffffff,%ebx
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10ea50: 89 d8 mov %ebx,%eax
10ea52: 8d 65 f4 lea -0xc(%ebp),%esp
10ea55: 5b pop %ebx
10ea56: 5e pop %esi
10ea57: 5f pop %edi
10ea58: c9 leave
10ea59: c3 ret
10ea5a: 66 90 xchg %ax,%ax
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
10ea5c: 85 ff test %edi,%edi
10ea5e: 74 a2 je 10ea02 <IMFS_evaluate_for_make+0x56><== NEVER TAKEN
10ea60: e9 6d ff ff ff jmp 10e9d2 <IMFS_evaluate_for_make+0x26>
10ea65: 8d 76 00 lea 0x0(%esi),%esi
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
10ea68: 8b 40 4c mov 0x4c(%eax),%eax
10ea6b: 83 f8 03 cmp $0x3,%eax
10ea6e: 0f 84 b4 01 00 00 je 10ec28 <IMFS_evaluate_for_make+0x27c>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
10ea74: 83 f8 04 cmp $0x4,%eax
10ea77: 0f 84 ca 01 00 00 je 10ec47 <IMFS_evaluate_for_make+0x29b>
if ( result == -1 )
return -1;
}
node = pathloc->node_access;
if ( !node )
10ea7d: 85 db test %ebx,%ebx
10ea7f: 0f 84 67 01 00 00 je 10ebec <IMFS_evaluate_for_make+0x240><== NEVER TAKEN
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10ea85: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10ea89: 0f 85 5d 01 00 00 jne 10ebec <IMFS_evaluate_for_make+0x240>
/*
* If we are at a node that is a mount point. Set loc to the
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
10ea8f: 8b 43 5c mov 0x5c(%ebx),%eax
10ea92: 85 c0 test %eax,%eax
10ea94: 0f 85 67 01 00 00 jne 10ec01 <IMFS_evaluate_for_make+0x255>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10ea9a: 83 ec 08 sub $0x8,%esp
10ea9d: 8d 45 af lea -0x51(%ebp),%eax
10eaa0: 50 push %eax
10eaa1: 53 push %ebx
10eaa2: e8 69 02 00 00 call 10ed10 <IMFS_find_match_in_dir>
10eaa7: 89 c3 mov %eax,%ebx
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
10eaa9: 83 c4 10 add $0x10,%esp
10eaac: 85 c0 test %eax,%eax
10eaae: 74 64 je 10eb14 <IMFS_evaluate_for_make+0x168>
done = true;
else
pathloc->node_access = node;
10eab0: 8b 55 0c mov 0xc(%ebp),%edx
10eab3: 89 02 mov %eax,(%edx)
10eab5: e9 18 ff ff ff jmp 10e9d2 <IMFS_evaluate_for_make+0x26>
10eaba: 66 90 xchg %ax,%ax
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
10eabc: 8b 15 b0 41 12 00 mov 0x1241b0,%edx
10eac2: 3b 42 18 cmp 0x18(%edx),%eax
10eac5: 0f 84 07 ff ff ff je 10e9d2 <IMFS_evaluate_for_make+0x26>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){
10eacb: 8b 4d 0c mov 0xc(%ebp),%ecx
10eace: 8b 51 10 mov 0x10(%ecx),%edx
10ead1: 3b 42 1c cmp 0x1c(%edx),%eax
10ead4: 0f 84 8e 00 00 00 je 10eb68 <IMFS_evaluate_for_make+0x1bc>
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
10eada: 8b 58 08 mov 0x8(%eax),%ebx
10eadd: 85 db test %ebx,%ebx
10eadf: 74 72 je 10eb53 <IMFS_evaluate_for_make+0x1a7>
rtems_set_errno_and_return_minus_one( ENOENT );
node = node->Parent;
}
pathloc->node_access = node;
10eae1: 8b 4d 0c mov 0xc(%ebp),%ecx
10eae4: 89 19 mov %ebx,(%ecx)
break;
10eae6: e9 e7 fe ff ff jmp 10e9d2 <IMFS_evaluate_for_make+0x26>
10eaeb: 90 nop
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
10eaec: 83 ec 08 sub $0x8,%esp
10eaef: 6a 01 push $0x1
10eaf1: ff 75 0c pushl 0xc(%ebp)
10eaf4: 89 55 a0 mov %edx,-0x60(%ebp)
10eaf7: e8 b0 fa ff ff call 10e5ac <IMFS_evaluate_permission>
10eafc: 83 c4 10 add $0x10,%esp
10eaff: 85 c0 test %eax,%eax
10eb01: 8b 55 a0 mov -0x60(%ebp),%edx
10eb04: 0f 84 cd 00 00 00 je 10ebd7 <IMFS_evaluate_for_make+0x22b>
10eb0a: 8b 4d 0c mov 0xc(%ebp),%ecx
10eb0d: 8b 01 mov (%ecx),%eax
10eb0f: e9 12 ff ff ff jmp 10ea26 <IMFS_evaluate_for_make+0x7a>
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
10eb14: 8b 45 a4 mov -0x5c(%ebp),%eax
10eb17: 2b 45 e4 sub -0x1c(%ebp),%eax
10eb1a: 03 45 08 add 0x8(%ebp),%eax
10eb1d: 8b 4d 10 mov 0x10(%ebp),%ecx
10eb20: 89 01 mov %eax,(%ecx)
/*
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++) {
10eb22: 8b 4d 08 mov 0x8(%ebp),%ecx
10eb25: 8b 55 a4 mov -0x5c(%ebp),%edx
10eb28: 8a 04 11 mov (%ecx,%edx,1),%al
10eb2b: 84 c0 test %al,%al
10eb2d: 74 75 je 10eba4 <IMFS_evaluate_for_make+0x1f8>
10eb2f: 89 d3 mov %edx,%ebx
10eb31: 89 ce mov %ecx,%esi
10eb33: eb 0b jmp 10eb40 <IMFS_evaluate_for_make+0x194>
10eb35: 8d 76 00 lea 0x0(%esi),%esi
10eb38: 43 inc %ebx
10eb39: 8a 04 1e mov (%esi,%ebx,1),%al
10eb3c: 84 c0 test %al,%al
10eb3e: 74 64 je 10eba4 <IMFS_evaluate_for_make+0x1f8>
if ( !IMFS_is_separator( path[ i ] ) )
10eb40: 83 ec 0c sub $0xc,%esp
10eb43: 0f be c0 movsbl %al,%eax
10eb46: 50 push %eax
10eb47: e8 74 99 ff ff call 1084c0 <rtems_filesystem_is_separator>
10eb4c: 83 c4 10 add $0x10,%esp
10eb4f: 85 c0 test %eax,%eax
10eb51: 75 e5 jne 10eb38 <IMFS_evaluate_for_make+0x18c>
rtems_set_errno_and_return_minus_one( ENOENT );
10eb53: e8 84 32 00 00 call 111ddc <__errno>
10eb58: c7 00 02 00 00 00 movl $0x2,(%eax)
10eb5e: bb ff ff ff ff mov $0xffffffff,%ebx
10eb63: e9 aa fe ff ff jmp 10ea12 <IMFS_evaluate_for_make+0x66>
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
10eb68: 8d 7d d0 lea -0x30(%ebp),%edi
10eb6b: 8d 72 08 lea 0x8(%edx),%esi
10eb6e: b9 05 00 00 00 mov $0x5,%ecx
10eb73: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*pathloc = newloc;
10eb75: 8d 75 d0 lea -0x30(%ebp),%esi
10eb78: b1 05 mov $0x5,%cl
10eb7a: 8b 7d 0c mov 0xc(%ebp),%edi
10eb7d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
10eb7f: 53 push %ebx
10eb80: 8b 55 0c mov 0xc(%ebp),%edx
10eb83: 8b 42 0c mov 0xc(%edx),%eax
10eb86: ff 75 10 pushl 0x10(%ebp)
10eb89: 52 push %edx
*/
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
10eb8a: 8b 55 a4 mov -0x5c(%ebp),%edx
10eb8d: 2b 55 e4 sub -0x1c(%ebp),%edx
10eb90: 03 55 08 add 0x8(%ebp),%edx
10eb93: 52 push %edx
10eb94: ff 50 04 call *0x4(%eax)
10eb97: 89 c3 mov %eax,%ebx
10eb99: 83 c4 10 add $0x10,%esp
10eb9c: e9 71 fe ff ff jmp 10ea12 <IMFS_evaluate_for_make+0x66>
10eba1: 8d 76 00 lea 0x0(%esi),%esi
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
10eba4: 83 ec 0c sub $0xc,%esp
10eba7: ff 75 0c pushl 0xc(%ebp)
10ebaa: e8 a1 f9 ff ff call 10e550 <IMFS_Set_handlers>
10ebaf: 89 c3 mov %eax,%ebx
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
10ebb1: 8b 55 0c mov 0xc(%ebp),%edx
10ebb4: 8b 02 mov (%edx),%eax
10ebb6: 83 c4 10 add $0x10,%esp
10ebb9: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
10ebbd: 75 2d jne 10ebec <IMFS_evaluate_for_make+0x240><== NEVER TAKEN
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
10ebbf: 83 ec 08 sub $0x8,%esp
10ebc2: 6a 03 push $0x3
10ebc4: ff 75 0c pushl 0xc(%ebp)
10ebc7: e8 e0 f9 ff ff call 10e5ac <IMFS_evaluate_permission>
10ebcc: 83 c4 10 add $0x10,%esp
10ebcf: 85 c0 test %eax,%eax
10ebd1: 0f 85 3b fe ff ff jne 10ea12 <IMFS_evaluate_for_make+0x66>
rtems_set_errno_and_return_minus_one( EACCES );
10ebd7: e8 00 32 00 00 call 111ddc <__errno>
10ebdc: c7 00 0d 00 00 00 movl $0xd,(%eax)
10ebe2: bb ff ff ff ff mov $0xffffffff,%ebx
10ebe7: e9 26 fe ff ff jmp 10ea12 <IMFS_evaluate_for_make+0x66>
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
10ebec: e8 eb 31 00 00 call 111ddc <__errno>
10ebf1: c7 00 14 00 00 00 movl $0x14,(%eax)
10ebf7: bb ff ff ff ff mov $0xffffffff,%ebx
10ebfc: e9 11 fe ff ff jmp 10ea12 <IMFS_evaluate_for_make+0x66>
* If we are at a node that is a mount point. Set loc to the
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
10ec01: 8d 7d d0 lea -0x30(%ebp),%edi
10ec04: 8d 70 1c lea 0x1c(%eax),%esi
10ec07: b9 05 00 00 00 mov $0x5,%ecx
10ec0c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*pathloc = newloc;
10ec0e: 8d 75 d0 lea -0x30(%ebp),%esi
10ec11: b1 05 mov $0x5,%cl
10ec13: 8b 7d 0c mov 0xc(%ebp),%edi
10ec16: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
10ec18: 51 push %ecx
10ec19: 8b 4d 0c mov 0xc(%ebp),%ecx
10ec1c: 8b 41 0c mov 0xc(%ecx),%eax
10ec1f: ff 75 10 pushl 0x10(%ebp)
10ec22: 51 push %ecx
10ec23: e9 62 ff ff ff jmp 10eb8a <IMFS_evaluate_for_make+0x1de>
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
10ec28: 83 ec 08 sub $0x8,%esp
10ec2b: 6a 00 push $0x0
10ec2d: ff 75 0c pushl 0xc(%ebp)
10ec30: e8 cb fc ff ff call 10e900 <IMFS_evaluate_link>
if ( result == -1 )
10ec35: 83 c4 10 add $0x10,%esp
10ec38: 83 f8 ff cmp $0xffffffff,%eax
10ec3b: 74 29 je 10ec66 <IMFS_evaluate_for_make+0x2ba><== NEVER TAKEN
10ec3d: 8b 45 0c mov 0xc(%ebp),%eax
10ec40: 8b 18 mov (%eax),%ebx
10ec42: e9 36 fe ff ff jmp 10ea7d <IMFS_evaluate_for_make+0xd1>
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
10ec47: 83 ec 08 sub $0x8,%esp
10ec4a: 6a 00 push $0x0
10ec4c: ff 75 0c pushl 0xc(%ebp)
10ec4f: e8 ac fc ff ff call 10e900 <IMFS_evaluate_link>
if ( result == -1 )
10ec54: 83 c4 10 add $0x10,%esp
10ec57: 83 f8 ff cmp $0xffffffff,%eax
10ec5a: 74 0a je 10ec66 <IMFS_evaluate_for_make+0x2ba><== NEVER TAKEN
10ec5c: 8b 55 0c mov 0xc(%ebp),%edx
10ec5f: 8b 1a mov (%edx),%ebx
10ec61: e9 17 fe ff ff jmp 10ea7d <IMFS_evaluate_for_make+0xd1>
10ec66: 89 c3 mov %eax,%ebx <== NOT EXECUTED
10ec68: e9 a5 fd ff ff jmp 10ea12 <IMFS_evaluate_for_make+0x66><== NOT EXECUTED
0010e900 <IMFS_evaluate_link>:
*/
int IMFS_evaluate_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
10e900: 55 push %ebp
10e901: 89 e5 mov %esp,%ebp
10e903: 57 push %edi
10e904: 56 push %esi
10e905: 53 push %ebx
10e906: 83 ec 0c sub $0xc,%esp
10e909: 8b 75 08 mov 0x8(%ebp),%esi
10e90c: 8b 7d 0c mov 0xc(%ebp),%edi
*/
rtems_filesystem_link_counts ++;
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
rtems_filesystem_link_counts = 0;
rtems_set_errno_and_return_minus_one( ELOOP );
10e90f: 8b 15 b0 41 12 00 mov 0x1241b0,%edx
10e915: eb 0e jmp 10e925 <IMFS_evaluate_link+0x25>
10e917: 90 nop
*/
if ( jnode->type == IMFS_HARD_LINK )
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
10e918: 83 f8 04 cmp $0x4,%eax
10e91b: 74 53 je 10e970 <IMFS_evaluate_link+0x70>
result = IMFS_evaluate_sym_link( node, flags );
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
10e91d: 83 e8 03 sub $0x3,%eax
10e920: 83 f8 01 cmp $0x1,%eax
10e923: 77 3a ja 10e95f <IMFS_evaluate_link+0x5f><== ALWAYS TAKEN
{
IMFS_jnode_t *jnode;
int result = 0;
do {
jnode = node->node_access;
10e925: 8b 1e mov (%esi),%ebx
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
10e927: 8b 42 30 mov 0x30(%edx),%eax
10e92a: 40 inc %eax
10e92b: 66 89 42 30 mov %ax,0x30(%edx)
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
10e92f: 66 83 f8 05 cmp $0x5,%ax
10e933: 77 57 ja 10e98c <IMFS_evaluate_link+0x8c>
/*
* Follow the Link node.
*/
if ( jnode->type == IMFS_HARD_LINK )
10e935: 8b 43 4c mov 0x4c(%ebx),%eax
10e938: 83 f8 03 cmp $0x3,%eax
10e93b: 75 db jne 10e918 <IMFS_evaluate_link+0x18>
result = IMFS_evaluate_hard_link( node, flags );
10e93d: 83 ec 08 sub $0x8,%esp
10e940: 57 push %edi
10e941: 56 push %esi
10e942: e8 a1 fc ff ff call 10e5e8 <IMFS_evaluate_hard_link>
10e947: 83 c4 10 add $0x10,%esp
else if (jnode->type == IMFS_SYM_LINK )
result = IMFS_evaluate_sym_link( node, flags );
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
( jnode->type == IMFS_HARD_LINK ) ) );
10e94a: 85 c0 test %eax,%eax
10e94c: 75 33 jne 10e981 <IMFS_evaluate_link+0x81>
10e94e: 8b 43 4c mov 0x4c(%ebx),%eax
10e951: 8b 15 b0 41 12 00 mov 0x1241b0,%edx
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
result = IMFS_evaluate_sym_link( node, flags );
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
10e957: 83 e8 03 sub $0x3,%eax
10e95a: 83 f8 01 cmp $0x1,%eax
10e95d: 76 c6 jbe 10e925 <IMFS_evaluate_link+0x25><== ALWAYS TAKEN
10e95f: 31 c0 xor %eax,%eax
/*
* Clear link counter.
*/
rtems_filesystem_link_counts = 0;
10e961: 66 c7 42 30 00 00 movw $0x0,0x30(%edx)
return result;
}
10e967: 8d 65 f4 lea -0xc(%ebp),%esp
10e96a: 5b pop %ebx
10e96b: 5e pop %esi
10e96c: 5f pop %edi
10e96d: c9 leave
10e96e: c3 ret
10e96f: 90 nop
if ( jnode->type == IMFS_HARD_LINK )
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
result = IMFS_evaluate_sym_link( node, flags );
10e970: 83 ec 08 sub $0x8,%esp
10e973: 57 push %edi
10e974: 56 push %esi
10e975: e8 0a ff ff ff call 10e884 <IMFS_evaluate_sym_link>
10e97a: 83 c4 10 add $0x10,%esp
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
( jnode->type == IMFS_HARD_LINK ) ) );
10e97d: 85 c0 test %eax,%eax
10e97f: 74 cd je 10e94e <IMFS_evaluate_link+0x4e>
10e981: 8b 15 b0 41 12 00 mov 0x1241b0,%edx
10e987: eb d8 jmp 10e961 <IMFS_evaluate_link+0x61>
10e989: 8d 76 00 lea 0x0(%esi),%esi
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
rtems_filesystem_link_counts = 0;
10e98c: 66 c7 42 30 00 00 movw $0x0,0x30(%edx)
rtems_set_errno_and_return_minus_one( ELOOP );
10e992: e8 45 34 00 00 call 111ddc <__errno>
10e997: c7 00 5c 00 00 00 movl $0x5c,(%eax)
10e99d: b8 ff ff ff ff mov $0xffffffff,%eax
*/
rtems_filesystem_link_counts = 0;
return result;
}
10e9a2: 8d 65 f4 lea -0xc(%ebp),%esp
10e9a5: 5b pop %ebx
10e9a6: 5e pop %esi
10e9a7: 5f pop %edi
10e9a8: c9 leave
10e9a9: c3 ret
0010e5ac <IMFS_evaluate_permission>:
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
10e5ac: 55 push %ebp
10e5ad: 89 e5 mov %esp,%ebp
10e5af: 83 ec 08 sub $0x8,%esp
10e5b2: 8b 45 0c mov 0xc(%ebp),%eax
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
10e5b5: a9 f8 ff ff ff test $0xfffffff8,%eax
10e5ba: 75 18 jne 10e5d4 <IMFS_evaluate_permission+0x28><== NEVER TAKEN
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
flags_to_test <<= 6;
10e5bc: c1 e0 06 shl $0x6,%eax
/*
* If all of the flags are set we have permission
* to do this.
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
10e5bf: 8b 55 08 mov 0x8(%ebp),%edx
10e5c2: 8b 12 mov (%edx),%edx
10e5c4: 8b 52 30 mov 0x30(%edx),%edx
10e5c7: 21 c2 and %eax,%edx
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
10e5c9: 39 d0 cmp %edx,%eax
10e5cb: 0f 94 c0 sete %al
10e5ce: 0f b6 c0 movzbl %al,%eax
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
return 1;
return 0;
}
10e5d1: c9 leave
10e5d2: c3 ret
10e5d3: 90 nop
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
10e5d4: e8 03 38 00 00 call 111ddc <__errno> <== NOT EXECUTED
10e5d9: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
10e5df: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
return 1;
return 0;
}
10e5e4: c9 leave <== NOT EXECUTED
10e5e5: c3 ret <== NOT EXECUTED
0010e884 <IMFS_evaluate_sym_link>:
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
10e884: 55 push %ebp
10e885: 89 e5 mov %esp,%ebp
10e887: 57 push %edi
10e888: 56 push %esi
10e889: 53 push %ebx
10e88a: 83 ec 20 sub $0x20,%esp
10e88d: 8b 5d 08 mov 0x8(%ebp),%ebx
10e890: 8b 75 0c mov 0xc(%ebp),%esi
IMFS_jnode_t *jnode = node->node_access;
10e893: 8b 3b mov (%ebx),%edi
/*
* Move the node_access to either the symbolic links parent or
* root depending on the symbolic links path.
*/
node->node_access = jnode->Parent;
10e895: 8b 47 08 mov 0x8(%edi),%eax
10e898: 89 03 mov %eax,(%ebx)
rtems_filesystem_get_sym_start_loc(
10e89a: 53 push %ebx
10e89b: 8d 45 e4 lea -0x1c(%ebp),%eax
10e89e: 50 push %eax
10e89f: ff 77 50 pushl 0x50(%edi)
10e8a2: e8 2d 0e 00 00 call 10f6d4 <rtems_filesystem_get_sym_start_loc>
);
/*
* Use eval path to evaluate the path of the symbolic link.
*/
result = IMFS_eval_path(
10e8a7: 8b 57 50 mov 0x50(%edi),%edx
10e8aa: 03 55 e4 add -0x1c(%ebp),%edx
10e8ad: 31 c0 xor %eax,%eax
10e8af: b9 ff ff ff ff mov $0xffffffff,%ecx
10e8b4: 89 d7 mov %edx,%edi
10e8b6: f2 ae repnz scas %es:(%edi),%al
10e8b8: f7 d1 not %ecx
10e8ba: 49 dec %ecx
10e8bb: 53 push %ebx
10e8bc: 56 push %esi
10e8bd: 51 push %ecx
10e8be: 52 push %edx
10e8bf: e8 68 fd ff ff call 10e62c <IMFS_eval_path>
10e8c4: 89 c7 mov %eax,%edi
strlen( &jnode->info.sym_link.name[i] ),
flags,
node
);
IMFS_Set_handlers( node );
10e8c6: 83 c4 14 add $0x14,%esp
10e8c9: 53 push %ebx
10e8ca: e8 81 fc ff ff call 10e550 <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
10e8cf: 58 pop %eax
10e8d0: 5a pop %edx
10e8d1: 56 push %esi
10e8d2: 53 push %ebx
10e8d3: e8 d4 fc ff ff call 10e5ac <IMFS_evaluate_permission>
10e8d8: 83 c4 10 add $0x10,%esp
10e8db: 85 c0 test %eax,%eax
10e8dd: 74 0d je 10e8ec <IMFS_evaluate_sym_link+0x68>
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10e8df: 89 f8 mov %edi,%eax
10e8e1: 8d 65 f4 lea -0xc(%ebp),%esp
10e8e4: 5b pop %ebx
10e8e5: 5e pop %esi
10e8e6: 5f pop %edi
10e8e7: c9 leave
10e8e8: c3 ret
10e8e9: 8d 76 00 lea 0x0(%esi),%esi
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
10e8ec: e8 eb 34 00 00 call 111ddc <__errno>
10e8f1: c7 00 0d 00 00 00 movl $0xd,(%eax)
10e8f7: bf ff ff ff ff mov $0xffffffff,%edi
10e8fc: eb e1 jmp 10e8df <IMFS_evaluate_sym_link+0x5b>
00107f14 <IMFS_fifo_ioctl>:
int IMFS_fifo_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
107f14: 55 push %ebp
107f15: 89 e5 mov %esp,%ebp
107f17: 53 push %ebx
107f18: 83 ec 04 sub $0x4,%esp
107f1b: 8b 45 08 mov 0x8(%ebp),%eax
107f1e: 8b 55 0c mov 0xc(%ebp),%edx
107f21: 8b 4d 10 mov 0x10(%ebp),%ecx
int err;
if (command == FIONBIO) {
107f24: 81 fa 7e 66 04 80 cmp $0x8004667e,%edx
107f2a: 74 1c je 107f48 <IMFS_fifo_ioctl+0x34>
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
return 0;
}
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
107f2c: 50 push %eax
107f2d: 51 push %ecx
107f2e: 52 push %edx
107f2f: 8b 40 18 mov 0x18(%eax),%eax
107f32: ff 70 50 pushl 0x50(%eax)
107f35: e8 56 96 00 00 call 111590 <pipe_ioctl>
IMFS_FIFO_RETURN(err);
107f3a: 83 c4 10 add $0x10,%esp
107f3d: 85 c0 test %eax,%eax
107f3f: 78 3e js 107f7f <IMFS_fifo_ioctl+0x6b>
}
107f41: 8b 5d fc mov -0x4(%ebp),%ebx
107f44: c9 leave
107f45: c3 ret
107f46: 66 90 xchg %ax,%ax
)
{
int err;
if (command == FIONBIO) {
if (buffer == NULL)
107f48: 85 c9 test %ecx,%ecx
107f4a: 74 20 je 107f6c <IMFS_fifo_ioctl+0x58>
err = -EFAULT;
else {
if (*(int *)buffer)
107f4c: 8b 11 mov (%ecx),%edx
107f4e: 85 d2 test %edx,%edx
107f50: 74 0e je 107f60 <IMFS_fifo_ioctl+0x4c>
iop->flags |= LIBIO_FLAGS_NO_DELAY;
107f52: 83 48 14 01 orl $0x1,0x14(%eax)
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
return 0;
107f56: 31 c0 xor %eax,%eax
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
IMFS_FIFO_RETURN(err);
}
107f58: 8b 5d fc mov -0x4(%ebp),%ebx
107f5b: c9 leave
107f5c: c3 ret
107f5d: 8d 76 00 lea 0x0(%esi),%esi
err = -EFAULT;
else {
if (*(int *)buffer)
iop->flags |= LIBIO_FLAGS_NO_DELAY;
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
107f60: 83 60 14 fe andl $0xfffffffe,0x14(%eax)
return 0;
107f64: 31 c0 xor %eax,%eax
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
IMFS_FIFO_RETURN(err);
}
107f66: 8b 5d fc mov -0x4(%ebp),%ebx
107f69: c9 leave
107f6a: c3 ret
107f6b: 90 nop
)
{
int err;
if (command == FIONBIO) {
if (buffer == NULL)
107f6c: bb 0e 00 00 00 mov $0xe,%ebx
}
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
IMFS_FIFO_RETURN(err);
107f71: e8 2e ba 00 00 call 1139a4 <__errno>
107f76: 89 18 mov %ebx,(%eax)
107f78: b8 ff ff ff ff mov $0xffffffff,%eax
107f7d: eb c2 jmp 107f41 <IMFS_fifo_ioctl+0x2d>
107f7f: 89 c3 mov %eax,%ebx
107f81: f7 db neg %ebx
107f83: eb ec jmp 107f71 <IMFS_fifo_ioctl+0x5d>
00107ed0 <IMFS_fifo_lseek>:
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
107ed0: 55 push %ebp
107ed1: 89 e5 mov %esp,%ebp
107ed3: 53 push %ebx
107ed4: 83 ec 10 sub $0x10,%esp
107ed7: 8b 45 08 mov 0x8(%ebp),%eax
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
107eda: 50 push %eax
107edb: ff 75 14 pushl 0x14(%ebp)
107ede: ff 75 10 pushl 0x10(%ebp)
107ee1: ff 75 0c pushl 0xc(%ebp)
107ee4: 8b 40 18 mov 0x18(%eax),%eax
107ee7: ff 70 50 pushl 0x50(%eax)
107eea: e8 01 97 00 00 call 1115f0 <pipe_lseek>
107eef: 89 c3 mov %eax,%ebx
107ef1: 99 cltd
IMFS_FIFO_RETURN(err);
107ef2: 83 c4 20 add $0x20,%esp
107ef5: 85 d2 test %edx,%edx
107ef7: 78 05 js 107efe <IMFS_fifo_lseek+0x2e> <== ALWAYS TAKEN
}
107ef9: 8b 5d fc mov -0x4(%ebp),%ebx
107efc: c9 leave
107efd: c3 ret
rtems_off64_t offset,
int whence
)
{
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
IMFS_FIFO_RETURN(err);
107efe: e8 a1 ba 00 00 call 1139a4 <__errno>
107f03: f7 db neg %ebx
107f05: 89 18 mov %ebx,(%eax)
107f07: b8 ff ff ff ff mov $0xffffffff,%eax
107f0c: ba ff ff ff ff mov $0xffffffff,%edx
107f11: eb e6 jmp 107ef9 <IMFS_fifo_lseek+0x29>
00107f88 <IMFS_fifo_write>:
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
107f88: 55 push %ebp
107f89: 89 e5 mov %esp,%ebp
107f8b: 56 push %esi
107f8c: 53 push %ebx
107f8d: 83 ec 10 sub $0x10,%esp
107f90: 8b 45 08 mov 0x8(%ebp),%eax
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
107f93: 8b 58 18 mov 0x18(%eax),%ebx
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
107f96: 50 push %eax
107f97: ff 75 10 pushl 0x10(%ebp)
107f9a: ff 75 0c pushl 0xc(%ebp)
107f9d: ff 73 50 pushl 0x50(%ebx)
107fa0: e8 07 94 00 00 call 1113ac <pipe_write>
107fa5: 89 c6 mov %eax,%esi
if (err > 0) {
107fa7: 83 c4 10 add $0x10,%esp
107faa: 83 f8 00 cmp $0x0,%eax
107fad: 7e 25 jle 107fd4 <IMFS_fifo_write+0x4c>
IMFS_mtime_ctime_update(jnode);
107faf: 83 ec 08 sub $0x8,%esp
107fb2: 6a 00 push $0x0
107fb4: 8d 45 f0 lea -0x10(%ebp),%eax
107fb7: 50 push %eax
107fb8: e8 1f 0f 00 00 call 108edc <gettimeofday>
107fbd: 8b 45 f0 mov -0x10(%ebp),%eax
107fc0: 89 43 44 mov %eax,0x44(%ebx)
107fc3: 89 43 48 mov %eax,0x48(%ebx)
107fc6: 83 c4 10 add $0x10,%esp
107fc9: 89 f0 mov %esi,%eax
}
IMFS_FIFO_RETURN(err);
}
107fcb: 8d 65 f8 lea -0x8(%ebp),%esp
107fce: 5b pop %ebx
107fcf: 5e pop %esi
107fd0: c9 leave
107fd1: c3 ret
107fd2: 66 90 xchg %ax,%ax
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
if (err > 0) {
IMFS_mtime_ctime_update(jnode);
}
IMFS_FIFO_RETURN(err);
107fd4: 75 09 jne 107fdf <IMFS_fifo_write+0x57> <== ALWAYS TAKEN
107fd6: 31 c0 xor %eax,%eax
}
107fd8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
107fdb: 5b pop %ebx <== NOT EXECUTED
107fdc: 5e pop %esi <== NOT EXECUTED
107fdd: c9 leave <== NOT EXECUTED
107fde: c3 ret <== NOT EXECUTED
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
if (err > 0) {
IMFS_mtime_ctime_update(jnode);
}
IMFS_FIFO_RETURN(err);
107fdf: e8 c0 b9 00 00 call 1139a4 <__errno>
107fe4: f7 de neg %esi
107fe6: 89 30 mov %esi,(%eax)
107fe8: b8 ff ff ff ff mov $0xffffffff,%eax
107fed: eb dc jmp 107fcb <IMFS_fifo_write+0x43>
0010ed10 <IMFS_find_match_in_dir>:
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
10ed10: 55 push %ebp
10ed11: 89 e5 mov %esp,%ebp
10ed13: 57 push %edi
10ed14: 56 push %esi
10ed15: 53 push %ebx
10ed16: 83 ec 0c sub $0xc,%esp
10ed19: 8b 45 08 mov 0x8(%ebp),%eax
10ed1c: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
10ed1f: bf 50 02 12 00 mov $0x120250,%edi
10ed24: b9 02 00 00 00 mov $0x2,%ecx
10ed29: 89 de mov %ebx,%esi
10ed2b: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10ed2d: 74 13 je 10ed42 <IMFS_find_match_in_dir+0x32><== NEVER TAKEN
return directory;
if ( !strcmp( name, dotdotname ) )
10ed2f: bf 52 02 12 00 mov $0x120252,%edi
10ed34: b9 03 00 00 00 mov $0x3,%ecx
10ed39: 89 de mov %ebx,%esi
10ed3b: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10ed3d: 75 0d jne 10ed4c <IMFS_find_match_in_dir+0x3c><== ALWAYS TAKEN
return directory->Parent;
10ed3f: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
10ed42: 8d 65 f4 lea -0xc(%ebp),%esp
10ed45: 5b pop %ebx
10ed46: 5e pop %esi
10ed47: 5f pop %edi
10ed48: c9 leave
10ed49: c3 ret
10ed4a: 66 90 xchg %ax,%ax
10ed4c: 8b 70 50 mov 0x50(%eax),%esi
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
10ed4f: 8d 78 54 lea 0x54(%eax),%edi
if ( !strcmp( name, dotdotname ) )
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
10ed52: 39 fe cmp %edi,%esi
10ed54: 75 08 jne 10ed5e <IMFS_find_match_in_dir+0x4e>
10ed56: eb 20 jmp 10ed78 <IMFS_find_match_in_dir+0x68>
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
10ed58: 8b 36 mov (%esi),%esi
if ( !strcmp( name, dotdotname ) )
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
10ed5a: 39 fe cmp %edi,%esi
10ed5c: 74 1a je 10ed78 <IMFS_find_match_in_dir+0x68>
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
if ( !strcmp( name, the_jnode->name ) )
10ed5e: 8d 46 0c lea 0xc(%esi),%eax
10ed61: 83 ec 08 sub $0x8,%esp
10ed64: 50 push %eax
10ed65: 53 push %ebx
10ed66: e8 e1 3c 00 00 call 112a4c <strcmp>
10ed6b: 83 c4 10 add $0x10,%esp
10ed6e: 85 c0 test %eax,%eax
10ed70: 75 e6 jne 10ed58 <IMFS_find_match_in_dir+0x48>
for ( the_node = rtems_chain_first( the_chain );
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
10ed72: 89 f0 mov %esi,%eax
10ed74: eb cc jmp 10ed42 <IMFS_find_match_in_dir+0x32>
10ed76: 66 90 xchg %ax,%ax
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
10ed78: 31 c0 xor %eax,%eax
10ed7a: eb c6 jmp 10ed42 <IMFS_find_match_in_dir+0x32>
0010ec70 <IMFS_fsunmount>:
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
int IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
10ec70: 55 push %ebp
10ec71: 89 e5 mov %esp,%ebp
10ec73: 57 push %edi
10ec74: 56 push %esi
10ec75: 53 push %ebx
10ec76: 83 ec 3c sub $0x3c,%esp
10ec79: 8b 45 08 mov 0x8(%ebp),%eax
/*
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;
10ec7c: 8b 58 1c mov 0x1c(%eax),%ebx
loc = temp_mt_entry->mt_fs_root;
10ec7f: 8d 55 d4 lea -0x2c(%ebp),%edx
10ec82: 89 55 c4 mov %edx,-0x3c(%ebp)
10ec85: 8d 70 1c lea 0x1c(%eax),%esi
10ec88: b9 05 00 00 00 mov $0x5,%ecx
10ec8d: 89 d7 mov %edx,%edi
10ec8f: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
10ec91: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
do {
next = jnode->Parent;
10ec98: 8b 73 08 mov 0x8(%ebx),%esi
loc.node_access = (void *)jnode;
10ec9b: 89 5d d4 mov %ebx,-0x2c(%ebp)
IMFS_Set_handlers( &loc );
10ec9e: 83 ec 0c sub $0xc,%esp
10eca1: 8d 45 d4 lea -0x2c(%ebp),%eax
10eca4: 50 push %eax
10eca5: e8 a6 f8 ff ff call 10e550 <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
10ecaa: 83 c4 10 add $0x10,%esp
10ecad: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10ecb1: 75 31 jne 10ece4 <IMFS_fsunmount+0x74>
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10ecb3: 8d 43 54 lea 0x54(%ebx),%eax
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
10ecb6: 39 43 50 cmp %eax,0x50(%ebx)
10ecb9: 74 42 je 10ecfd <IMFS_fsunmount+0x8d>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
}
if ( jnode != NULL ) {
10ecbb: 85 db test %ebx,%ebx
10ecbd: 74 19 je 10ecd8 <IMFS_fsunmount+0x68>
if ( jnode->type == IMFS_DIRECTORY ) {
10ecbf: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10ecc3: 75 d3 jne 10ec98 <IMFS_fsunmount+0x28> <== NEVER TAKEN
}
}
} while (jnode != NULL);
return 0;
}
10ecc5: 8b 43 50 mov 0x50(%ebx),%eax
10ecc8: 8d 53 54 lea 0x54(%ebx),%edx
return -1;
jnode = next;
}
if ( jnode != NULL ) {
if ( jnode->type == IMFS_DIRECTORY ) {
if ( jnode_has_children( jnode ) )
10eccb: 39 d0 cmp %edx,%eax
10eccd: 74 c9 je 10ec98 <IMFS_fsunmount+0x28>
jnode = jnode_get_first_child( jnode );
10eccf: 89 c3 mov %eax,%ebx
}
}
} while (jnode != NULL);
10ecd1: 85 c0 test %eax,%eax
10ecd3: 75 c3 jne 10ec98 <IMFS_fsunmount+0x28> <== ALWAYS TAKEN
10ecd5: 8d 76 00 lea 0x0(%esi),%esi
return 0;
10ecd8: 31 c0 xor %eax,%eax
}
10ecda: 8d 65 f4 lea -0xc(%ebp),%esp
10ecdd: 5b pop %ebx
10ecde: 5e pop %esi
10ecdf: 5f pop %edi
10ece0: c9 leave
10ece1: c3 ret
10ece2: 66 90 xchg %ax,%ax
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
if ( jnode->type != IMFS_DIRECTORY ) {
result = IMFS_unlink( NULL, &loc );
10ece4: 83 ec 08 sub $0x8,%esp
10ece7: 8d 55 d4 lea -0x2c(%ebp),%edx
10ecea: 52 push %edx
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
10eceb: 6a 00 push $0x0
10eced: e8 8a 84 ff ff call 10717c <IMFS_unlink>
if (result != 0)
10ecf2: 83 c4 10 add $0x10,%esp
10ecf5: 85 c0 test %eax,%eax
10ecf7: 75 0d jne 10ed06 <IMFS_fsunmount+0x96> <== NEVER TAKEN
return -1;
jnode = next;
10ecf9: 89 f3 mov %esi,%ebx
10ecfb: eb be jmp 10ecbb <IMFS_fsunmount+0x4b>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
10ecfd: 83 ec 08 sub $0x8,%esp
10ed00: 8d 45 d4 lea -0x2c(%ebp),%eax
10ed03: 50 push %eax
10ed04: eb e5 jmp 10eceb <IMFS_fsunmount+0x7b>
if (result != 0)
return -1;
10ed06: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10ed0b: eb cd jmp 10ecda <IMFS_fsunmount+0x6a> <== NOT EXECUTED
0010ed7c <IMFS_get_token>:
const char *path,
int pathlen,
char *token,
int *token_len
)
{
10ed7c: 55 push %ebp
10ed7d: 89 e5 mov %esp,%ebp
10ed7f: 57 push %edi
10ed80: 56 push %esi
10ed81: 53 push %ebx
10ed82: 83 ec 1c sub $0x1c,%esp
10ed85: 8b 7d 08 mov 0x8(%ebp),%edi
10ed88: 8b 5d 10 mov 0x10(%ebp),%ebx
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
10ed8b: 8a 17 mov (%edi),%dl
int pathlen,
char *token,
int *token_len
)
{
register int i = 0;
10ed8d: 31 f6 xor %esi,%esi
10ed8f: 89 7d e4 mov %edi,-0x1c(%ebp)
10ed92: 89 df mov %ebx,%edi
10ed94: 88 d3 mov %dl,%bl
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
10ed96: eb 07 jmp 10ed9f <IMFS_get_token+0x23>
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
10ed98: 46 inc %esi
10ed99: 8b 45 e4 mov -0x1c(%ebp),%eax
10ed9c: 8a 1c 30 mov (%eax,%esi,1),%bl
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
10ed9f: 83 ec 0c sub $0xc,%esp
10eda2: 0f be c3 movsbl %bl,%eax
10eda5: 50 push %eax
10eda6: e8 15 97 ff ff call 1084c0 <rtems_filesystem_is_separator>
10edab: 83 c4 10 add $0x10,%esp
10edae: 85 c0 test %eax,%eax
10edb0: 75 1a jne 10edcc <IMFS_get_token+0x50>
10edb2: 3b 75 0c cmp 0xc(%ebp),%esi
10edb5: 7d 15 jge 10edcc <IMFS_get_token+0x50>
token[i] = c;
10edb7: 88 1c 37 mov %bl,(%edi,%esi,1)
if ( i == IMFS_NAME_MAX )
10edba: 83 fe 20 cmp $0x20,%esi
10edbd: 75 d9 jne 10ed98 <IMFS_get_token+0x1c>
return IMFS_INVALID_TOKEN;
10edbf: b8 04 00 00 00 mov $0x4,%eax
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
}
return type;
}
10edc4: 8d 65 f4 lea -0xc(%ebp),%esp
10edc7: 5b pop %ebx
10edc8: 5e pop %esi
10edc9: 5f pop %edi
10edca: c9 leave
10edcb: c3 ret
10edcc: 88 da mov %bl,%dl
10edce: 89 fb mov %edi,%ebx
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
10edd0: 85 f6 test %esi,%esi
10edd2: 75 25 jne 10edf9 <IMFS_get_token+0x7d>
token[i] = c;
10edd4: 88 17 mov %dl,(%edi)
if ( (token[i] != '\0') && pathlen ) {
10edd6: 84 d2 test %dl,%dl
10edd8: 74 16 je 10edf0 <IMFS_get_token+0x74>
10edda: 8b 45 0c mov 0xc(%ebp),%eax
10eddd: 85 c0 test %eax,%eax
10eddf: 74 0f je 10edf0 <IMFS_get_token+0x74>
i++;
type = IMFS_CURRENT_DIR;
10ede1: b8 01 00 00 00 mov $0x1,%eax
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
10ede6: be 01 00 00 00 mov $0x1,%esi
10edeb: eb 05 jmp 10edf2 <IMFS_get_token+0x76>
10eded: 8d 76 00 lea 0x0(%esi),%esi
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
10edf0: 31 c0 xor %eax,%eax
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
10edf2: 8b 55 14 mov 0x14(%ebp),%edx
10edf5: 89 32 mov %esi,(%edx)
10edf7: eb cb jmp 10edc4 <IMFS_get_token+0x48>
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
10edf9: 80 7c 37 ff 00 cmpb $0x0,-0x1(%edi,%esi,1)
10edfe: 74 04 je 10ee04 <IMFS_get_token+0x88> <== NEVER TAKEN
token[i] = '\0';
10ee00: c6 04 37 00 movb $0x0,(%edi,%esi,1)
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
10ee04: 8b 45 14 mov 0x14(%ebp),%eax
10ee07: 89 30 mov %esi,(%eax)
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
10ee09: bf 55 02 12 00 mov $0x120255,%edi
10ee0e: b9 03 00 00 00 mov $0x3,%ecx
10ee13: 89 de mov %ebx,%esi
10ee15: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10ee17: 75 0f jne 10ee28 <IMFS_get_token+0xac>
type = IMFS_UP_DIR;
10ee19: b8 02 00 00 00 mov $0x2,%eax
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
}
return type;
}
10ee1e: 8d 65 f4 lea -0xc(%ebp),%esp
10ee21: 5b pop %ebx
10ee22: 5e pop %esi
10ee23: 5f pop %edi
10ee24: c9 leave
10ee25: c3 ret
10ee26: 66 90 xchg %ax,%ax
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
10ee28: bf 56 02 12 00 mov $0x120256,%edi
10ee2d: b9 02 00 00 00 mov $0x2,%ecx
10ee32: 89 de mov %ebx,%esi
10ee34: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10ee36: 0f 97 c0 seta %al
10ee39: 0f 92 c2 setb %dl
10ee3c: 28 d0 sub %dl,%al
10ee3e: 0f be c0 movsbl %al,%eax
10ee41: 83 f8 01 cmp $0x1,%eax
10ee44: 19 c0 sbb %eax,%eax
10ee46: 83 e0 fe and $0xfffffffe,%eax
10ee49: 83 c0 03 add $0x3,%eax
type = IMFS_CURRENT_DIR;
}
return type;
}
10ee4c: 8d 65 f4 lea -0xc(%ebp),%esp
10ee4f: 5b pop %ebx
10ee50: 5e pop %esi
10ee51: 5f pop %edi
10ee52: c9 leave
10ee53: c3 ret
00106dc4 <IMFS_initialize_support>:
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *memfile_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers,
const rtems_filesystem_file_handlers_r *fifo_handlers
)
{
106dc4: 55 push %ebp
106dc5: 89 e5 mov %esp,%ebp
106dc7: 57 push %edi
106dc8: 56 push %esi
106dc9: 53 push %ebx
106dca: 83 ec 1c sub $0x1c,%esp
106dcd: 8b 5d 08 mov 0x8(%ebp),%ebx
IMFS_jnode_t *jnode;
/*
* determine/check value for imfs_memfile_bytes_per_block
*/
IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
106dd0: 8b 0d f0 21 12 00 mov 0x1221f0,%ecx
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
106dd6: 83 f9 10 cmp $0x10,%ecx
106dd9: 74 1f je 106dfa <IMFS_initialize_support+0x36>
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
106ddb: 83 f9 0f cmp $0xf,%ecx
106dde: 7e 15 jle 106df5 <IMFS_initialize_support+0x31>
106de0: ba 05 00 00 00 mov $0x5,%edx
106de5: b8 20 00 00 00 mov $0x20,%eax
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
106dea: 39 c1 cmp %eax,%ecx
106dec: 74 0c je 106dfa <IMFS_initialize_support+0x36>
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
106dee: 7c 05 jl 106df5 <IMFS_initialize_support+0x31><== NEVER TAKEN
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
106df0: d1 e0 shl %eax
106df2: 4a dec %edx
106df3: 75 f5 jne 106dea <IMFS_initialize_support+0x26><== ALWAYS TAKEN
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
? requested_bytes_per_block
: default_bytes_per_block);
106df5: b9 80 00 00 00 mov $0x80,%ecx
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
106dfa: 89 0d 20 60 12 00 mov %ecx,0x126020
/*
* Create the root node
*
* NOTE: UNIX root is 755 and owned by root/root (0/0).
*/
temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node();
106e00: e8 17 77 00 00 call 10e51c <IMFS_create_root_node>
106e05: 89 c2 mov %eax,%edx
106e07: 89 43 1c mov %eax,0x1c(%ebx)
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
106e0a: 8b 45 14 mov 0x14(%ebp),%eax
106e0d: 89 43 24 mov %eax,0x24(%ebx)
temp_mt_entry->mt_fs_root.ops = op_table;
106e10: 8b 45 0c mov 0xc(%ebp),%eax
106e13: 89 43 28 mov %eax,0x28(%ebx)
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
106e16: 8d 7b 38 lea 0x38(%ebx),%edi
106e19: be 00 02 12 00 mov $0x120200,%esi
106e1e: b9 0c 00 00 00 mov $0xc,%ecx
106e23: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
106e25: 83 ec 08 sub $0x8,%esp
106e28: 6a 14 push $0x14
106e2a: 6a 01 push $0x1
106e2c: 89 55 e4 mov %edx,-0x1c(%ebp)
106e2f: e8 70 06 00 00 call 1074a4 <calloc>
if ( !fs_info ) {
106e34: 83 c4 10 add $0x10,%esp
106e37: 85 c0 test %eax,%eax
106e39: 8b 55 e4 mov -0x1c(%ebp),%edx
106e3c: 74 3c je 106e7a <IMFS_initialize_support+0xb6>
free(temp_mt_entry->mt_fs_root.node_access);
rtems_set_errno_and_return_minus_one(ENOMEM);
}
temp_mt_entry->fs_info = fs_info;
106e3e: 89 43 34 mov %eax,0x34(%ebx)
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
106e41: 8b 0d 24 60 12 00 mov 0x126024,%ecx
106e47: 89 08 mov %ecx,(%eax)
106e49: 41 inc %ecx
106e4a: 89 0d 24 60 12 00 mov %ecx,0x126024
fs_info->ino_count = 1;
106e50: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
fs_info->memfile_handlers = memfile_handlers;
106e57: 8b 4d 10 mov 0x10(%ebp),%ecx
106e5a: 89 48 08 mov %ecx,0x8(%eax)
fs_info->directory_handlers = directory_handlers;
106e5d: 8b 4d 14 mov 0x14(%ebp),%ecx
106e60: 89 48 0c mov %ecx,0xc(%eax)
fs_info->fifo_handlers = fifo_handlers;
106e63: 8b 4d 18 mov 0x18(%ebp),%ecx
106e66: 89 48 10 mov %ecx,0x10(%eax)
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
106e69: c7 42 38 01 00 00 00 movl $0x1,0x38(%edx)
return 0;
106e70: 31 c0 xor %eax,%eax
}
106e72: 8d 65 f4 lea -0xc(%ebp),%esp
106e75: 5b pop %ebx
106e76: 5e pop %esi
106e77: 5f pop %edi
106e78: c9 leave
106e79: c3 ret
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
if ( !fs_info ) {
free(temp_mt_entry->mt_fs_root.node_access);
106e7a: 83 ec 0c sub $0xc,%esp
106e7d: 52 push %edx
106e7e: e8 b1 07 00 00 call 107634 <free>
rtems_set_errno_and_return_minus_one(ENOMEM);
106e83: e8 54 af 00 00 call 111ddc <__errno>
106e88: c7 00 0c 00 00 00 movl $0xc,(%eax)
106e8e: 83 c4 10 add $0x10,%esp
106e91: 83 c8 ff or $0xffffffff,%eax
106e94: eb dc jmp 106e72 <IMFS_initialize_support+0xae>
00106e98 <IMFS_link>:
int IMFS_link(
rtems_filesystem_location_info_t *to_loc, /* IN */
rtems_filesystem_location_info_t *parent_loc, /* IN */
const char *token /* IN */
)
{
106e98: 55 push %ebp
106e99: 89 e5 mov %esp,%ebp
106e9b: 57 push %edi
106e9c: 53 push %ebx
106e9d: 83 ec 50 sub $0x50,%esp
106ea0: 8b 55 10 mov 0x10(%ebp),%edx
int i;
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
106ea3: 8b 45 08 mov 0x8(%ebp),%eax
106ea6: 8b 00 mov (%eax),%eax
106ea8: 89 45 d8 mov %eax,-0x28(%ebp)
if ( info.hard_link.link_node->st_nlink >= LINK_MAX )
106eab: 66 83 78 34 07 cmpw $0x7,0x34(%eax)
106eb0: 77 66 ja 106f18 <IMFS_link+0x80>
rtems_set_errno_and_return_minus_one( EMLINK );
/*
* Remove any separators at the end of the string.
*/
IMFS_get_token( token, strlen( token ), new_name, &i );
106eb2: 31 c0 xor %eax,%eax
106eb4: b9 ff ff ff ff mov $0xffffffff,%ecx
106eb9: 89 d7 mov %edx,%edi
106ebb: f2 ae repnz scas %es:(%edi),%al
106ebd: f7 d1 not %ecx
106ebf: 49 dec %ecx
106ec0: 8d 45 f4 lea -0xc(%ebp),%eax
106ec3: 50 push %eax
106ec4: 8d 5d b7 lea -0x49(%ebp),%ebx
106ec7: 53 push %ebx
106ec8: 51 push %ecx
106ec9: 52 push %edx
106eca: e8 ad 7e 00 00 call 10ed7c <IMFS_get_token>
new_node = IMFS_create_node(
parent_loc,
IMFS_HARD_LINK,
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
106ecf: 8d 45 d8 lea -0x28(%ebp),%eax
* was ONLY passed a NULL when we created the root node. We
* added a new IMFS_create_root_node() so this path no longer
* existed. The result was simpler code which should not have
* this path.
*/
new_node = IMFS_create_node(
106ed2: 89 04 24 mov %eax,(%esp)
106ed5: 68 ff a1 00 00 push $0xa1ff
106eda: 53 push %ebx
106edb: 6a 03 push $0x3
106edd: ff 75 0c pushl 0xc(%ebp)
106ee0: e8 ff 74 00 00 call 10e3e4 <IMFS_create_node>
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if ( !new_node )
106ee5: 83 c4 20 add $0x20,%esp
106ee8: 85 c0 test %eax,%eax
106eea: 74 3e je 106f2a <IMFS_link+0x92>
rtems_set_errno_and_return_minus_one( ENOMEM );
/*
* Increment the link count of the node being pointed to.
*/
info.hard_link.link_node->st_nlink++;
106eec: 8b 45 d8 mov -0x28(%ebp),%eax
106eef: 66 ff 40 34 incw 0x34(%eax)
IMFS_update_ctime( info.hard_link.link_node );
106ef3: 83 ec 08 sub $0x8,%esp
106ef6: 6a 00 push $0x0
106ef8: 8d 45 ec lea -0x14(%ebp),%eax
106efb: 50 push %eax
106efc: e8 af 07 00 00 call 1076b0 <gettimeofday>
106f01: 8b 55 ec mov -0x14(%ebp),%edx
106f04: 8b 45 d8 mov -0x28(%ebp),%eax
106f07: 89 50 48 mov %edx,0x48(%eax)
return 0;
106f0a: 83 c4 10 add $0x10,%esp
106f0d: 31 c0 xor %eax,%eax
}
106f0f: 8d 65 f8 lea -0x8(%ebp),%esp
106f12: 5b pop %ebx
106f13: 5f pop %edi
106f14: c9 leave
106f15: c3 ret
106f16: 66 90 xchg %ax,%ax
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
if ( info.hard_link.link_node->st_nlink >= LINK_MAX )
rtems_set_errno_and_return_minus_one( EMLINK );
106f18: e8 bf ae 00 00 call 111ddc <__errno>
106f1d: c7 00 1f 00 00 00 movl $0x1f,(%eax)
106f23: b8 ff ff ff ff mov $0xffffffff,%eax
106f28: eb e5 jmp 106f0f <IMFS_link+0x77>
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if ( !new_node )
rtems_set_errno_and_return_minus_one( ENOMEM );
106f2a: e8 ad ae 00 00 call 111ddc <__errno>
106f2f: c7 00 0c 00 00 00 movl $0xc,(%eax)
106f35: b8 ff ff ff ff mov $0xffffffff,%eax
106f3a: eb d3 jmp 106f0f <IMFS_link+0x77>
00110cb0 <IMFS_memfile_addblock>:
*/
MEMFILE_STATIC int IMFS_memfile_addblock(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
110cb0: 55 push %ebp
110cb1: 89 e5 mov %esp,%ebp
110cb3: 53 push %ebx
110cb4: 83 ec 08 sub $0x8,%esp
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Obtain the pointer for the specified block number
*/
block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 );
110cb7: 6a 01 push $0x1
110cb9: ff 75 0c pushl 0xc(%ebp)
110cbc: ff 75 08 pushl 0x8(%ebp)
110cbf: e8 28 fc ff ff call 1108ec <IMFS_memfile_get_block_pointer>
110cc4: 89 c3 mov %eax,%ebx
if ( *block_entry_ptr )
110cc6: 83 c4 10 add $0x10,%esp
110cc9: 8b 00 mov (%eax),%eax
110ccb: 85 c0 test %eax,%eax
110ccd: 74 09 je 110cd8 <IMFS_memfile_addblock+0x28>
return 0;
110ccf: 31 c0 xor %eax,%eax
if ( !memory )
return 1;
*block_entry_ptr = memory;
return 0;
}
110cd1: 8b 5d fc mov -0x4(%ebp),%ebx
110cd4: c9 leave
110cd5: c3 ret
110cd6: 66 90 xchg %ax,%ax
return 0;
/*
* There is no memory for this block number so allocate it.
*/
memory = memfile_alloc_block();
110cd8: e8 eb fb ff ff call 1108c8 <memfile_alloc_block>
if ( !memory )
110cdd: 85 c0 test %eax,%eax
110cdf: 74 07 je 110ce8 <IMFS_memfile_addblock+0x38>
return 1;
*block_entry_ptr = memory;
110ce1: 89 03 mov %eax,(%ebx)
return 0;
110ce3: 31 c0 xor %eax,%eax
110ce5: eb ea jmp 110cd1 <IMFS_memfile_addblock+0x21>
110ce7: 90 nop
/*
* There is no memory for this block number so allocate it.
*/
memory = memfile_alloc_block();
if ( !memory )
return 1;
110ce8: b8 01 00 00 00 mov $0x1,%eax
110ced: eb e2 jmp 110cd1 <IMFS_memfile_addblock+0x21>
00110ef0 <IMFS_memfile_extend>:
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
110ef0: 55 push %ebp
110ef1: 89 e5 mov %esp,%ebp
110ef3: 57 push %edi
110ef4: 56 push %esi
110ef5: 53 push %ebx
110ef6: 83 ec 2c sub $0x2c,%esp
110ef9: 8b 5d 08 mov 0x8(%ebp),%ebx
110efc: 8b 45 0c mov 0xc(%ebp),%eax
110eff: 8b 55 10 mov 0x10(%ebp),%edx
110f02: 89 45 d8 mov %eax,-0x28(%ebp)
110f05: 89 55 dc mov %edx,-0x24(%ebp)
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
110f08: a1 20 60 12 00 mov 0x126020,%eax
110f0d: 89 c1 mov %eax,%ecx
110f0f: c1 e9 02 shr $0x2,%ecx
110f12: 8d 51 01 lea 0x1(%ecx),%edx
110f15: 0f af d1 imul %ecx,%edx
110f18: 42 inc %edx
110f19: 0f af d1 imul %ecx,%edx
110f1c: 4a dec %edx
110f1d: 0f af d0 imul %eax,%edx
110f20: 31 c9 xor %ecx,%ecx
110f22: 3b 4d dc cmp -0x24(%ebp),%ecx
110f25: 7f 1a jg 110f41 <IMFS_memfile_extend+0x51><== NEVER TAKEN
110f27: 7d 13 jge 110f3c <IMFS_memfile_extend+0x4c><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
110f29: e8 ae 0e 00 00 call 111ddc <__errno>
110f2e: c7 00 16 00 00 00 movl $0x16,(%eax)
110f34: b8 ff ff ff ff mov $0xffffffff,%eax
110f39: eb 19 jmp 110f54 <IMFS_memfile_extend+0x64>
110f3b: 90 nop
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
110f3c: 3b 55 d8 cmp -0x28(%ebp),%edx
110f3f: 76 e8 jbe 110f29 <IMFS_memfile_extend+0x39>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
110f41: 8b 53 50 mov 0x50(%ebx),%edx
110f44: 8b 4b 54 mov 0x54(%ebx),%ecx
110f47: 89 55 e0 mov %edx,-0x20(%ebp)
110f4a: 89 4d e4 mov %ecx,-0x1c(%ebp)
110f4d: 39 4d dc cmp %ecx,-0x24(%ebp)
110f50: 7d 0a jge 110f5c <IMFS_memfile_extend+0x6c><== ALWAYS TAKEN
return 0;
110f52: 31 c0 xor %eax,%eax
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
return 0;
}
110f54: 8d 65 f4 lea -0xc(%ebp),%esp
110f57: 5b pop %ebx
110f58: 5e pop %esi
110f59: 5f pop %edi
110f5a: c9 leave
110f5b: c3 ret
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
110f5c: 7f 05 jg 110f63 <IMFS_memfile_extend+0x73><== NEVER TAKEN
110f5e: 39 55 d8 cmp %edx,-0x28(%ebp)
110f61: 76 ef jbe 110f52 <IMFS_memfile_extend+0x62>
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
110f63: 89 45 d0 mov %eax,-0x30(%ebp)
110f66: 89 c1 mov %eax,%ecx
110f68: c1 f9 1f sar $0x1f,%ecx
110f6b: 89 4d d4 mov %ecx,-0x2c(%ebp)
110f6e: ff 75 d4 pushl -0x2c(%ebp)
110f71: ff 75 d0 pushl -0x30(%ebp)
110f74: ff 75 dc pushl -0x24(%ebp)
110f77: ff 75 d8 pushl -0x28(%ebp)
110f7a: e8 61 c6 00 00 call 11d5e0 <__divdi3>
110f7f: 83 c4 10 add $0x10,%esp
110f82: 89 c6 mov %eax,%esi
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
110f84: ff 75 d4 pushl -0x2c(%ebp)
110f87: ff 75 d0 pushl -0x30(%ebp)
110f8a: ff 75 e4 pushl -0x1c(%ebp)
110f8d: ff 75 e0 pushl -0x20(%ebp)
110f90: e8 4b c6 00 00 call 11d5e0 <__divdi3>
110f95: 83 c4 10 add $0x10,%esp
110f98: 89 45 e0 mov %eax,-0x20(%ebp)
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
110f9b: 39 c6 cmp %eax,%esi
110f9d: 72 51 jb 110ff0 <IMFS_memfile_extend+0x100><== NEVER TAKEN
110f9f: 89 c7 mov %eax,%edi
110fa1: eb 06 jmp 110fa9 <IMFS_memfile_extend+0xb9>
110fa3: 90 nop
110fa4: 47 inc %edi
110fa5: 39 fe cmp %edi,%esi
110fa7: 72 47 jb 110ff0 <IMFS_memfile_extend+0x100>
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
110fa9: 83 ec 08 sub $0x8,%esp
110fac: 57 push %edi
110fad: 53 push %ebx
110fae: e8 fd fc ff ff call 110cb0 <IMFS_memfile_addblock>
110fb3: 83 c4 10 add $0x10,%esp
110fb6: 85 c0 test %eax,%eax
110fb8: 74 ea je 110fa4 <IMFS_memfile_extend+0xb4>
for ( ; block>=old_blocks ; block-- ) {
110fba: 39 7d e0 cmp %edi,-0x20(%ebp)
110fbd: 77 17 ja 110fd6 <IMFS_memfile_extend+0xe6><== NEVER TAKEN
110fbf: 8b 75 e0 mov -0x20(%ebp),%esi
110fc2: 66 90 xchg %ax,%ax
IMFS_memfile_remove_block( the_jnode, block );
110fc4: 83 ec 08 sub $0x8,%esp
110fc7: 57 push %edi
110fc8: 53 push %ebx
110fc9: e8 f6 fe ff ff call 110ec4 <IMFS_memfile_remove_block>
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
for ( ; block>=old_blocks ; block-- ) {
110fce: 4f dec %edi
110fcf: 83 c4 10 add $0x10,%esp
110fd2: 39 fe cmp %edi,%esi
110fd4: 76 ee jbe 110fc4 <IMFS_memfile_extend+0xd4>
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
110fd6: e8 01 0e 00 00 call 111ddc <__errno>
110fdb: c7 00 1c 00 00 00 movl $0x1c,(%eax)
110fe1: b8 ff ff ff ff mov $0xffffffff,%eax
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
return 0;
}
110fe6: 8d 65 f4 lea -0xc(%ebp),%esp
110fe9: 5b pop %ebx
110fea: 5e pop %esi
110feb: 5f pop %edi
110fec: c9 leave
110fed: c3 ret
110fee: 66 90 xchg %ax,%ax
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
110ff0: 8b 45 d8 mov -0x28(%ebp),%eax
110ff3: 8b 55 dc mov -0x24(%ebp),%edx
110ff6: 89 43 50 mov %eax,0x50(%ebx)
110ff9: 89 53 54 mov %edx,0x54(%ebx)
return 0;
110ffc: 31 c0 xor %eax,%eax
}
110ffe: 8d 65 f4 lea -0xc(%ebp),%esp
111001: 5b pop %ebx
111002: 5e pop %esi
111003: 5f pop %edi
111004: c9 leave
111005: c3 ret
001108ec <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
1108ec: 55 push %ebp
1108ed: 89 e5 mov %esp,%ebp
1108ef: 57 push %edi
1108f0: 56 push %esi
1108f1: 53 push %ebx
1108f2: 83 ec 1c sub $0x1c,%esp
1108f5: 8b 5d 08 mov 0x8(%ebp),%ebx
1108f8: 8b 75 0c mov 0xc(%ebp),%esi
1108fb: 8b 7d 10 mov 0x10(%ebp),%edi
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
1108fe: 8b 0d 20 60 12 00 mov 0x126020,%ecx
110904: c1 e9 02 shr $0x2,%ecx
110907: 8d 41 ff lea -0x1(%ecx),%eax
11090a: 39 c6 cmp %eax,%esi
11090c: 77 1a ja 110928 <IMFS_memfile_get_block_pointer+0x3c>
p = info->indirect;
11090e: 8b 43 58 mov 0x58(%ebx),%eax
if ( malloc_it ) {
110911: 85 ff test %edi,%edi
110913: 74 53 je 110968 <IMFS_memfile_get_block_pointer+0x7c>
if ( !p ) {
110915: 85 c0 test %eax,%eax
110917: 0f 84 b6 00 00 00 je 1109d3 <IMFS_memfile_get_block_pointer+0xe7>
}
if ( !p )
return 0;
return &info->indirect[ my_block ];
11091d: 8d 04 b0 lea (%eax,%esi,4),%eax
/*
* This means the requested block number is out of range.
*/
return 0;
}
110920: 83 c4 1c add $0x1c,%esp
110923: 5b pop %ebx
110924: 5e pop %esi
110925: 5f pop %edi
110926: c9 leave
110927: c3 ret
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
110928: 8d 41 01 lea 0x1(%ecx),%eax
11092b: 0f af c1 imul %ecx,%eax
11092e: 8d 50 ff lea -0x1(%eax),%edx
110931: 39 d6 cmp %edx,%esi
110933: 77 3b ja 110970 <IMFS_memfile_get_block_pointer+0x84>
my_block -= FIRST_DOUBLY_INDIRECT;
110935: 29 ce sub %ecx,%esi
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
110937: 89 f0 mov %esi,%eax
110939: 31 d2 xor %edx,%edx
11093b: f7 f1 div %ecx
11093d: 89 c6 mov %eax,%esi
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
p = info->doubly_indirect;
11093f: 8b 43 5c mov 0x5c(%ebx),%eax
if ( malloc_it ) {
110942: 85 ff test %edi,%edi
110944: 74 7e je 1109c4 <IMFS_memfile_get_block_pointer+0xd8>
if ( !p ) {
110946: 85 c0 test %eax,%eax
110948: 0f 84 96 00 00 00 je 1109e4 <IMFS_memfile_get_block_pointer+0xf8>
if ( !p )
return 0;
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
11094e: 8d 1c b0 lea (%eax,%esi,4),%ebx
110951: 8b 03 mov (%ebx),%eax
if ( !p1 ) {
110953: 85 c0 test %eax,%eax
110955: 0f 84 a4 00 00 00 je 1109ff <IMFS_memfile_get_block_pointer+0x113>
p = (block_p *)p[ doubly ];
if ( !p )
return 0;
return (block_p *)&p[ singly ];
11095b: 8d 04 90 lea (%eax,%edx,4),%eax
/*
* This means the requested block number is out of range.
*/
return 0;
}
11095e: 83 c4 1c add $0x1c,%esp
110961: 5b pop %ebx
110962: 5e pop %esi
110963: 5f pop %edi
110964: c9 leave
110965: c3 ret
110966: 66 90 xchg %ax,%ax
info->indirect = p;
}
return &info->indirect[ my_block ];
}
if ( !p )
110968: 85 c0 test %eax,%eax
11096a: 75 b1 jne 11091d <IMFS_memfile_get_block_pointer+0x31><== ALWAYS TAKEN
if ( !p )
return 0;
p1 = (block_p *) p[ triply ];
if ( !p1 )
return 0;
11096c: 31 c0 xor %eax,%eax
11096e: eb ee jmp 11095e <IMFS_memfile_get_block_pointer+0x72><== NOT EXECUTED
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
110970: 8d 50 01 lea 0x1(%eax),%edx
110973: 0f af d1 imul %ecx,%edx
110976: 4a dec %edx
110977: 39 d6 cmp %edx,%esi
110979: 77 f1 ja 11096c <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
my_block -= FIRST_TRIPLY_INDIRECT;
11097b: 29 c6 sub %eax,%esi
11097d: 89 f0 mov %esi,%eax
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
11097f: 31 d2 xor %edx,%edx
110981: f7 f1 div %ecx
110983: 89 55 e4 mov %edx,-0x1c(%ebp)
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
110986: 31 d2 xor %edx,%edx
110988: f7 f1 div %ecx
11098a: 89 c6 mov %eax,%esi
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
p = info->triply_indirect;
11098c: 8b 4b 60 mov 0x60(%ebx),%ecx
if ( malloc_it ) {
11098f: 85 ff test %edi,%edi
110991: 0f 84 82 00 00 00 je 110a19 <IMFS_memfile_get_block_pointer+0x12d>
if ( !p ) {
110997: 85 c9 test %ecx,%ecx
110999: 0f 84 9b 00 00 00 je 110a3a <IMFS_memfile_get_block_pointer+0x14e>
if ( !p )
return 0;
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
11099f: 8d 1c b1 lea (%ecx,%esi,4),%ebx
1109a2: 8b 0b mov (%ebx),%ecx
if ( !p1 ) {
1109a4: 85 c9 test %ecx,%ecx
1109a6: 0f 84 c5 00 00 00 je 110a71 <IMFS_memfile_get_block_pointer+0x185>
if ( !p1 )
return 0;
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
1109ac: 8d 1c 91 lea (%ecx,%edx,4),%ebx
1109af: 8b 13 mov (%ebx),%edx
if ( !p2 ) {
1109b1: 85 d2 test %edx,%edx
1109b3: 0f 84 a0 00 00 00 je 110a59 <IMFS_memfile_get_block_pointer+0x16d>
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
return 0;
return (block_p *)&p2[ singly ];
1109b9: 8b 4d e4 mov -0x1c(%ebp),%ecx
1109bc: 8d 04 8a lea (%edx,%ecx,4),%eax
1109bf: eb 9d jmp 11095e <IMFS_memfile_get_block_pointer+0x72>
1109c1: 8d 76 00 lea 0x0(%esi),%esi
}
return (block_p *)&p1[ singly ];
}
if ( !p )
1109c4: 85 c0 test %eax,%eax
1109c6: 74 a4 je 11096c <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
return 0;
p = (block_p *)p[ doubly ];
1109c8: 8b 04 b0 mov (%eax,%esi,4),%eax
if ( !p )
1109cb: 85 c0 test %eax,%eax
1109cd: 75 8c jne 11095b <IMFS_memfile_get_block_pointer+0x6f><== ALWAYS TAKEN
if ( !p )
return 0;
p1 = (block_p *) p[ triply ];
if ( !p1 )
return 0;
1109cf: 31 c0 xor %eax,%eax
1109d1: eb 8b jmp 11095e <IMFS_memfile_get_block_pointer+0x72><== NOT EXECUTED
p = info->indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
1109d3: e8 f0 fe ff ff call 1108c8 <memfile_alloc_block>
if ( !p )
1109d8: 85 c0 test %eax,%eax
1109da: 74 90 je 11096c <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
return 0;
info->indirect = p;
1109dc: 89 43 58 mov %eax,0x58(%ebx)
1109df: e9 39 ff ff ff jmp 11091d <IMFS_memfile_get_block_pointer+0x31>
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
1109e4: 89 55 e0 mov %edx,-0x20(%ebp)
1109e7: e8 dc fe ff ff call 1108c8 <memfile_alloc_block>
if ( !p )
1109ec: 85 c0 test %eax,%eax
1109ee: 8b 55 e0 mov -0x20(%ebp),%edx
1109f1: 0f 84 75 ff ff ff je 11096c <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
return 0;
info->doubly_indirect = p;
1109f7: 89 43 5c mov %eax,0x5c(%ebx)
1109fa: e9 4f ff ff ff jmp 11094e <IMFS_memfile_get_block_pointer+0x62>
}
p1 = (block_p *)p[ doubly ];
if ( !p1 ) {
p1 = memfile_alloc_block();
1109ff: 89 55 e0 mov %edx,-0x20(%ebp)
110a02: e8 c1 fe ff ff call 1108c8 <memfile_alloc_block>
if ( !p1 )
110a07: 85 c0 test %eax,%eax
110a09: 8b 55 e0 mov -0x20(%ebp),%edx
110a0c: 0f 84 5a ff ff ff je 11096c <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
return 0;
p[ doubly ] = (block_p) p1;
110a12: 89 03 mov %eax,(%ebx)
110a14: e9 42 ff ff ff jmp 11095b <IMFS_memfile_get_block_pointer+0x6f>
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
}
if ( !p )
110a19: 85 c9 test %ecx,%ecx
110a1b: 0f 84 4b ff ff ff je 11096c <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
return 0;
p1 = (block_p *) p[ triply ];
110a21: 8b 04 81 mov (%ecx,%eax,4),%eax
if ( !p1 )
110a24: 85 c0 test %eax,%eax
110a26: 0f 84 40 ff ff ff je 11096c <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
return 0;
p2 = (block_p *)p1[ doubly ];
110a2c: 8b 14 90 mov (%eax,%edx,4),%edx
if ( !p2 )
return 0;
110a2f: 31 c0 xor %eax,%eax
p1 = (block_p *) p[ triply ];
if ( !p1 )
return 0;
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
110a31: 85 d2 test %edx,%edx
110a33: 75 84 jne 1109b9 <IMFS_memfile_get_block_pointer+0xcd><== ALWAYS TAKEN
110a35: e9 24 ff ff ff jmp 11095e <IMFS_memfile_get_block_pointer+0x72><== NOT EXECUTED
p = info->triply_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
110a3a: 89 55 e0 mov %edx,-0x20(%ebp)
110a3d: e8 86 fe ff ff call 1108c8 <memfile_alloc_block>
110a42: 89 c1 mov %eax,%ecx
if ( !p )
return 0;
110a44: 31 c0 xor %eax,%eax
p = info->triply_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
110a46: 85 c9 test %ecx,%ecx
110a48: 8b 55 e0 mov -0x20(%ebp),%edx
110a4b: 0f 84 0d ff ff ff je 11095e <IMFS_memfile_get_block_pointer+0x72><== NEVER TAKEN
return 0;
info->triply_indirect = p;
110a51: 89 4b 60 mov %ecx,0x60(%ebx)
110a54: e9 46 ff ff ff jmp 11099f <IMFS_memfile_get_block_pointer+0xb3>
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
110a59: e8 6a fe ff ff call 1108c8 <memfile_alloc_block>
110a5e: 89 c2 mov %eax,%edx
if ( !p2 )
return 0;
110a60: 31 c0 xor %eax,%eax
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
if ( !p2 )
110a62: 85 d2 test %edx,%edx
110a64: 0f 84 f4 fe ff ff je 11095e <IMFS_memfile_get_block_pointer+0x72><== NEVER TAKEN
return 0;
p1[ doubly ] = (block_p) p2;
110a6a: 89 13 mov %edx,(%ebx)
110a6c: e9 48 ff ff ff jmp 1109b9 <IMFS_memfile_get_block_pointer+0xcd>
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
110a71: 89 55 e0 mov %edx,-0x20(%ebp)
110a74: e8 4f fe ff ff call 1108c8 <memfile_alloc_block>
110a79: 89 c1 mov %eax,%ecx
if ( !p1 )
return 0;
110a7b: 31 c0 xor %eax,%eax
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
110a7d: 85 c9 test %ecx,%ecx
110a7f: 8b 55 e0 mov -0x20(%ebp),%edx
110a82: 0f 84 d6 fe ff ff je 11095e <IMFS_memfile_get_block_pointer+0x72><== NEVER TAKEN
return 0;
p[ triply ] = (block_p) p1;
110a88: 89 0b mov %ecx,(%ebx)
110a8a: e9 1d ff ff ff jmp 1109ac <IMFS_memfile_get_block_pointer+0xc0>
00110a90 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
110a90: 55 push %ebp
110a91: 89 e5 mov %esp,%ebp
110a93: 57 push %edi
110a94: 56 push %esi
110a95: 53 push %ebx
110a96: 83 ec 3c sub $0x3c,%esp
110a99: 8b 75 0c mov 0xc(%ebp),%esi
110a9c: 8b 7d 10 mov 0x10(%ebp),%edi
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
110a9f: 8b 45 08 mov 0x8(%ebp),%eax
110aa2: 83 78 4c 06 cmpl $0x6,0x4c(%eax)
110aa6: 0f 84 60 01 00 00 je 110c0c <IMFS_memfile_read+0x17c>
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
110aac: 89 f0 mov %esi,%eax
if ( last_byte > the_jnode->info.file.size )
110aae: 8b 55 08 mov 0x8(%ebp),%edx
110ab1: 8b 4a 50 mov 0x50(%edx),%ecx
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
110ab4: 8b 5d 18 mov 0x18(%ebp),%ebx
110ab7: 01 f3 add %esi,%ebx
110ab9: 89 5d d0 mov %ebx,-0x30(%ebp)
if ( last_byte > the_jnode->info.file.size )
110abc: 31 d2 xor %edx,%edx
110abe: 8b 5d 08 mov 0x8(%ebp),%ebx
110ac1: 3b 53 54 cmp 0x54(%ebx),%edx
110ac4: 0f 8d d2 00 00 00 jge 110b9c <IMFS_memfile_read+0x10c><== ALWAYS TAKEN
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
110aca: 8b 45 18 mov 0x18(%ebp),%eax
110acd: 89 45 cc mov %eax,-0x34(%ebp)
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
110ad0: 8b 15 20 60 12 00 mov 0x126020,%edx
110ad6: 89 55 d0 mov %edx,-0x30(%ebp)
110ad9: 89 d0 mov %edx,%eax
110adb: 99 cltd
110adc: 89 d3 mov %edx,%ebx
110ade: 52 push %edx
110adf: 50 push %eax
110ae0: 57 push %edi
110ae1: 56 push %esi
110ae2: 89 45 c0 mov %eax,-0x40(%ebp)
110ae5: e8 42 cc 00 00 call 11d72c <__moddi3>
110aea: 83 c4 10 add $0x10,%esp
110aed: 89 45 c8 mov %eax,-0x38(%ebp)
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
110af0: 8b 4d c0 mov -0x40(%ebp),%ecx
110af3: 53 push %ebx
110af4: 51 push %ecx
110af5: 57 push %edi
110af6: 56 push %esi
110af7: e8 e4 ca 00 00 call 11d5e0 <__divdi3>
110afc: 83 c4 10 add $0x10,%esp
110aff: 89 c3 mov %eax,%ebx
if ( start_offset ) {
110b01: 8b 7d c8 mov -0x38(%ebp),%edi
110b04: 85 ff test %edi,%edi
110b06: 0f 84 a0 00 00 00 je 110bac <IMFS_memfile_read+0x11c>
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
110b0c: 56 push %esi
110b0d: 6a 00 push $0x0
110b0f: 50 push %eax
110b10: ff 75 08 pushl 0x8(%ebp)
110b13: e8 d4 fd ff ff call 1108ec <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
110b18: 83 c4 10 add $0x10,%esp
110b1b: 85 c0 test %eax,%eax
110b1d: 0f 84 65 01 00 00 je 110c88 <IMFS_memfile_read+0x1f8><== NEVER TAKEN
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
110b23: 8b 4d d0 mov -0x30(%ebp),%ecx
110b26: 2b 4d c8 sub -0x38(%ebp),%ecx
110b29: 8b 55 cc mov -0x34(%ebp),%edx
110b2c: 39 ca cmp %ecx,%edx
110b2e: 0f 87 3c 01 00 00 ja 110c70 <IMFS_memfile_read+0x1e0>
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
110b34: 8b 75 c8 mov -0x38(%ebp),%esi
110b37: 03 30 add (%eax),%esi
dest += to_copy;
110b39: 8b 7d 14 mov 0x14(%ebp),%edi
110b3c: 89 d1 mov %edx,%ecx
110b3e: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
110b40: 89 7d c8 mov %edi,-0x38(%ebp)
block++;
110b43: 43 inc %ebx
my_length -= to_copy;
110b44: 29 55 cc sub %edx,-0x34(%ebp)
110b47: a1 20 60 12 00 mov 0x126020,%eax
110b4c: 89 45 d0 mov %eax,-0x30(%ebp)
copied += to_copy;
110b4f: 89 55 c4 mov %edx,-0x3c(%ebp)
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
110b52: 8b 4d d0 mov -0x30(%ebp),%ecx
110b55: 39 4d cc cmp %ecx,-0x34(%ebp)
110b58: 73 24 jae 110b7e <IMFS_memfile_read+0xee>
110b5a: eb 60 jmp 110bbc <IMFS_memfile_read+0x12c>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
110b5c: 8b 30 mov (%eax),%esi
110b5e: 8b 7d c8 mov -0x38(%ebp),%edi
110b61: 8b 4d d0 mov -0x30(%ebp),%ecx
110b64: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
dest += to_copy;
110b66: 89 7d c8 mov %edi,-0x38(%ebp)
block++;
110b69: 43 inc %ebx
my_length -= to_copy;
110b6a: 8b 7d d0 mov -0x30(%ebp),%edi
110b6d: 29 7d cc sub %edi,-0x34(%ebp)
copied += to_copy;
110b70: 01 7d c4 add %edi,-0x3c(%ebp)
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
110b73: 8b 45 cc mov -0x34(%ebp),%eax
110b76: 39 05 20 60 12 00 cmp %eax,0x126020
110b7c: 77 3e ja 110bbc <IMFS_memfile_read+0x12c>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
110b7e: 51 push %ecx
110b7f: 6a 00 push $0x0
110b81: 53 push %ebx
110b82: ff 75 08 pushl 0x8(%ebp)
110b85: e8 62 fd ff ff call 1108ec <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
110b8a: 83 c4 10 add $0x10,%esp
110b8d: 85 c0 test %eax,%eax
110b8f: 75 cb jne 110b5c <IMFS_memfile_read+0xcc><== ALWAYS TAKEN
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
110b91: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED
}
IMFS_update_atime( the_jnode );
return copied;
}
110b94: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
110b97: 5b pop %ebx <== NOT EXECUTED
110b98: 5e pop %esi <== NOT EXECUTED
110b99: 5f pop %edi <== NOT EXECUTED
110b9a: c9 leave <== NOT EXECUTED
110b9b: c3 ret <== NOT EXECUTED
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
110b9c: 0f 8e be 00 00 00 jle 110c60 <IMFS_memfile_read+0x1d0><== ALWAYS TAKEN
my_length = the_jnode->info.file.size - start;
110ba2: 29 c1 sub %eax,%ecx
110ba4: 89 4d cc mov %ecx,-0x34(%ebp)
110ba7: e9 24 ff ff ff jmp 110ad0 <IMFS_memfile_read+0x40>
unsigned int last_byte;
unsigned int copied;
unsigned int start_offset;
unsigned char *dest;
dest = destination;
110bac: 8b 55 14 mov 0x14(%ebp),%edx
110baf: 89 55 c8 mov %edx,-0x38(%ebp)
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
my_length = the_jnode->info.file.size - start;
copied = 0;
110bb2: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
110bb9: eb 97 jmp 110b52 <IMFS_memfile_read+0xc2>
110bbb: 90 nop
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
110bbc: 8b 55 cc mov -0x34(%ebp),%edx
110bbf: 85 d2 test %edx,%edx
110bc1: 74 23 je 110be6 <IMFS_memfile_read+0x156>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
110bc3: 50 push %eax
110bc4: 6a 00 push $0x0
110bc6: 53 push %ebx
110bc7: ff 75 08 pushl 0x8(%ebp)
110bca: e8 1d fd ff ff call 1108ec <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
110bcf: 83 c4 10 add $0x10,%esp
110bd2: 85 c0 test %eax,%eax
110bd4: 74 bb je 110b91 <IMFS_memfile_read+0x101><== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
110bd6: 8b 30 mov (%eax),%esi
110bd8: 8b 7d c8 mov -0x38(%ebp),%edi
110bdb: 8b 4d cc mov -0x34(%ebp),%ecx
110bde: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
copied += my_length;
110be0: 8b 55 cc mov -0x34(%ebp),%edx
110be3: 01 55 c4 add %edx,-0x3c(%ebp)
}
IMFS_update_atime( the_jnode );
110be6: 83 ec 08 sub $0x8,%esp
110be9: 6a 00 push $0x0
110beb: 8d 45 e0 lea -0x20(%ebp),%eax
110bee: 50 push %eax
110bef: e8 bc 6a ff ff call 1076b0 <gettimeofday>
110bf4: 8b 45 e0 mov -0x20(%ebp),%eax
110bf7: 8b 4d 08 mov 0x8(%ebp),%ecx
110bfa: 89 41 40 mov %eax,0x40(%ecx)
return copied;
110bfd: 8b 45 c4 mov -0x3c(%ebp),%eax
110c00: 83 c4 10 add $0x10,%esp
}
110c03: 8d 65 f4 lea -0xc(%ebp),%esp
110c06: 5b pop %ebx
110c07: 5e pop %esi
110c08: 5f pop %edi
110c09: c9 leave
110c0a: c3 ret
110c0b: 90 nop
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
110c0c: 8b 50 58 mov 0x58(%eax),%edx
110c0f: 89 55 cc mov %edx,-0x34(%ebp)
if (my_length > (the_jnode->info.linearfile.size - start))
110c12: 89 c1 mov %eax,%ecx
110c14: 8b 40 50 mov 0x50(%eax),%eax
110c17: 8b 51 54 mov 0x54(%ecx),%edx
110c1a: 89 c1 mov %eax,%ecx
110c1c: 89 d3 mov %edx,%ebx
110c1e: 29 f1 sub %esi,%ecx
110c20: 19 fb sbb %edi,%ebx
110c22: 89 4d d0 mov %ecx,-0x30(%ebp)
110c25: 89 5d d4 mov %ebx,-0x2c(%ebp)
110c28: 31 c9 xor %ecx,%ecx
110c2a: 39 d9 cmp %ebx,%ecx
110c2c: 7d 4a jge 110c78 <IMFS_memfile_read+0x1e8><== ALWAYS TAKEN
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
110c2e: 8b 5d 18 mov 0x18(%ebp),%ebx <== NOT EXECUTED
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
my_length = the_jnode->info.linearfile.size - start;
memcpy(dest, &file_ptr[start], my_length);
110c31: 03 75 cc add -0x34(%ebp),%esi
110c34: 8b 7d 14 mov 0x14(%ebp),%edi
110c37: 89 d9 mov %ebx,%ecx
110c39: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
IMFS_update_atime( the_jnode );
110c3b: 83 ec 08 sub $0x8,%esp
110c3e: 6a 00 push $0x0
110c40: 8d 45 e0 lea -0x20(%ebp),%eax
110c43: 50 push %eax
110c44: e8 67 6a ff ff call 1076b0 <gettimeofday>
110c49: 8b 45 e0 mov -0x20(%ebp),%eax
110c4c: 8b 7d 08 mov 0x8(%ebp),%edi
110c4f: 89 47 40 mov %eax,0x40(%edi)
return my_length;
110c52: 89 d8 mov %ebx,%eax
110c54: 83 c4 10 add $0x10,%esp
}
IMFS_update_atime( the_jnode );
return copied;
}
110c57: 8d 65 f4 lea -0xc(%ebp),%esp
110c5a: 5b pop %ebx
110c5b: 5e pop %esi
110c5c: 5f pop %edi
110c5d: c9 leave
110c5e: c3 ret
110c5f: 90 nop
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
110c60: 39 4d d0 cmp %ecx,-0x30(%ebp)
110c63: 0f 86 61 fe ff ff jbe 110aca <IMFS_memfile_read+0x3a>
110c69: e9 34 ff ff ff jmp 110ba2 <IMFS_memfile_read+0x112>
110c6e: 66 90 xchg %ax,%ax
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
110c70: 89 ca mov %ecx,%edx
110c72: e9 bd fe ff ff jmp 110b34 <IMFS_memfile_read+0xa4>
110c77: 90 nop
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
110c78: 7f 08 jg 110c82 <IMFS_memfile_read+0x1f2><== NEVER TAKEN
110c7a: 8b 5d d0 mov -0x30(%ebp),%ebx
110c7d: 39 5d 18 cmp %ebx,0x18(%ebp)
110c80: 76 ac jbe 110c2e <IMFS_memfile_read+0x19e><== NEVER TAKEN
my_length = the_jnode->info.linearfile.size - start;
110c82: 89 c3 mov %eax,%ebx
110c84: 29 f3 sub %esi,%ebx
110c86: eb a9 jmp 110c31 <IMFS_memfile_read+0x1a1>
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
110c88: 31 c0 xor %eax,%eax
110c8a: e9 05 ff ff ff jmp 110b94 <IMFS_memfile_read+0x104><== NOT EXECUTED
00110d68 <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
110d68: 55 push %ebp
110d69: 89 e5 mov %esp,%ebp
110d6b: 57 push %edi
110d6c: 56 push %esi
110d6d: 53 push %ebx
110d6e: 83 ec 1c sub $0x1c,%esp
/*
* Eventually this could be set smarter at each call to
* memfile_free_blocks_in_table to greatly speed this up.
*/
to_free = IMFS_MEMFILE_BLOCK_SLOTS;
110d71: 8b 3d 20 60 12 00 mov 0x126020,%edi
110d77: c1 ef 02 shr $0x2,%edi
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
110d7a: 8b 45 08 mov 0x8(%ebp),%eax
110d7d: 8b 50 58 mov 0x58(%eax),%edx
110d80: 85 d2 test %edx,%edx
110d82: 74 10 je 110d94 <IMFS_memfile_remove+0x2c>
memfile_free_blocks_in_table( &info->indirect, to_free );
110d84: 83 ec 08 sub $0x8,%esp
110d87: 57 push %edi
110d88: 83 c0 58 add $0x58,%eax
110d8b: 50 push %eax
110d8c: e8 7b ff ff ff call 110d0c <memfile_free_blocks_in_table>
110d91: 83 c4 10 add $0x10,%esp
}
if ( info->doubly_indirect ) {
110d94: 8b 4d 08 mov 0x8(%ebp),%ecx
110d97: 8b 51 5c mov 0x5c(%ecx),%edx
110d9a: 85 d2 test %edx,%edx
110d9c: 74 55 je 110df3 <IMFS_memfile_remove+0x8b>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
110d9e: a1 20 60 12 00 mov 0x126020,%eax
110da3: 89 c1 mov %eax,%ecx
110da5: c1 e9 02 shr $0x2,%ecx
110da8: 74 36 je 110de0 <IMFS_memfile_remove+0x78><== NEVER TAKEN
110daa: 31 c9 xor %ecx,%ecx
110dac: 31 db xor %ebx,%ebx
110dae: 8b 75 08 mov 0x8(%ebp),%esi
110db1: eb 04 jmp 110db7 <IMFS_memfile_remove+0x4f>
110db3: 90 nop
110db4: 8b 56 5c mov 0x5c(%esi),%edx
if ( info->doubly_indirect[i] ) {
110db7: c1 e1 02 shl $0x2,%ecx
110dba: 83 3c 0a 00 cmpl $0x0,(%edx,%ecx,1)
110dbe: 74 14 je 110dd4 <IMFS_memfile_remove+0x6c><== NEVER TAKEN
memfile_free_blocks_in_table(
110dc0: 83 ec 08 sub $0x8,%esp
110dc3: 57 push %edi
110dc4: 01 ca add %ecx,%edx
110dc6: 52 push %edx
110dc7: e8 40 ff ff ff call 110d0c <memfile_free_blocks_in_table>
110dcc: 83 c4 10 add $0x10,%esp
110dcf: a1 20 60 12 00 mov 0x126020,%eax
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
110dd4: 43 inc %ebx
110dd5: 89 d9 mov %ebx,%ecx
110dd7: 89 c2 mov %eax,%edx
110dd9: c1 ea 02 shr $0x2,%edx
110ddc: 39 da cmp %ebx,%edx
110dde: 77 d4 ja 110db4 <IMFS_memfile_remove+0x4c>
if ( info->doubly_indirect[i] ) {
memfile_free_blocks_in_table(
(block_p **)&info->doubly_indirect[i], to_free );
}
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
110de0: 83 ec 08 sub $0x8,%esp
110de3: 57 push %edi
110de4: 8b 45 08 mov 0x8(%ebp),%eax
110de7: 83 c0 5c add $0x5c,%eax
110dea: 50 push %eax
110deb: e8 1c ff ff ff call 110d0c <memfile_free_blocks_in_table>
110df0: 83 c4 10 add $0x10,%esp
}
if ( info->triply_indirect ) {
110df3: 8b 45 08 mov 0x8(%ebp),%eax
110df6: 8b 50 60 mov 0x60(%eax),%edx
110df9: 85 d2 test %edx,%edx
110dfb: 0f 84 b6 00 00 00 je 110eb7 <IMFS_memfile_remove+0x14f>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
110e01: a1 20 60 12 00 mov 0x126020,%eax
110e06: 89 c1 mov %eax,%ecx
110e08: c1 e9 02 shr $0x2,%ecx
110e0b: 0f 84 93 00 00 00 je 110ea4 <IMFS_memfile_remove+0x13c><== NEVER TAKEN
p = (block_p *) info->triply_indirect[i];
110e11: 8b 32 mov (%edx),%esi
if ( !p ) /* ensure we have a valid pointer */
110e13: 85 f6 test %esi,%esi
110e15: 0f 84 89 00 00 00 je 110ea4 <IMFS_memfile_remove+0x13c><== NEVER TAKEN
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
110e1b: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
if ( !p ) /* ensure we have a valid pointer */
110e22: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
110e29: 8d 76 00 lea 0x0(%esi),%esi
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
110e2c: 89 c2 mov %eax,%edx
110e2e: c1 ea 02 shr $0x2,%edx
110e31: 74 30 je 110e63 <IMFS_memfile_remove+0xfb><== NEVER TAKEN
110e33: 31 d2 xor %edx,%edx
110e35: 31 db xor %ebx,%ebx
110e37: 90 nop
if ( p[j] ) {
110e38: c1 e2 02 shl $0x2,%edx
110e3b: 8b 0c 16 mov (%esi,%edx,1),%ecx
110e3e: 85 c9 test %ecx,%ecx
110e40: 74 15 je 110e57 <IMFS_memfile_remove+0xef><== NEVER TAKEN
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
110e42: 83 ec 08 sub $0x8,%esp
110e45: 57 push %edi
110e46: 8d 14 16 lea (%esi,%edx,1),%edx
110e49: 52 push %edx
110e4a: e8 bd fe ff ff call 110d0c <memfile_free_blocks_in_table>
110e4f: 83 c4 10 add $0x10,%esp
110e52: a1 20 60 12 00 mov 0x126020,%eax
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
if ( !p ) /* ensure we have a valid pointer */
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
110e57: 43 inc %ebx
110e58: 89 da mov %ebx,%edx
110e5a: 89 c1 mov %eax,%ecx
110e5c: c1 e9 02 shr $0x2,%ecx
110e5f: 39 cb cmp %ecx,%ebx
110e61: 72 d5 jb 110e38 <IMFS_memfile_remove+0xd0>
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
110e63: 83 ec 08 sub $0x8,%esp
110e66: 57 push %edi
110e67: 8b 45 e0 mov -0x20(%ebp),%eax
110e6a: 8b 4d 08 mov 0x8(%ebp),%ecx
110e6d: 03 41 60 add 0x60(%ecx),%eax
110e70: 50 push %eax
110e71: e8 96 fe ff ff call 110d0c <memfile_free_blocks_in_table>
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
110e76: ff 45 e4 incl -0x1c(%ebp)
110e79: a1 20 60 12 00 mov 0x126020,%eax
110e7e: 89 c2 mov %eax,%edx
110e80: c1 ea 02 shr $0x2,%edx
110e83: 83 c4 10 add $0x10,%esp
110e86: 3b 55 e4 cmp -0x1c(%ebp),%edx
110e89: 76 19 jbe 110ea4 <IMFS_memfile_remove+0x13c>
p = (block_p *) info->triply_indirect[i];
if ( !p ) /* ensure we have a valid pointer */
110e8b: 8b 55 e4 mov -0x1c(%ebp),%edx
110e8e: c1 e2 02 shl $0x2,%edx
110e91: 89 55 e0 mov %edx,-0x20(%ebp)
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
110e94: 8b 4d 08 mov 0x8(%ebp),%ecx
110e97: 8b 51 60 mov 0x60(%ecx),%edx
110e9a: 8b 4d e0 mov -0x20(%ebp),%ecx
110e9d: 8b 34 0a mov (%edx,%ecx,1),%esi
if ( !p ) /* ensure we have a valid pointer */
110ea0: 85 f6 test %esi,%esi
110ea2: 75 88 jne 110e2c <IMFS_memfile_remove+0xc4><== ALWAYS TAKEN
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
110ea4: 83 ec 08 sub $0x8,%esp
110ea7: 57 push %edi
(block_p **)&info->triply_indirect, to_free );
110ea8: 8b 45 08 mov 0x8(%ebp),%eax
110eab: 83 c0 60 add $0x60,%eax
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
110eae: 50 push %eax
110eaf: e8 58 fe ff ff call 110d0c <memfile_free_blocks_in_table>
110eb4: 83 c4 10 add $0x10,%esp
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
110eb7: 31 c0 xor %eax,%eax
110eb9: 8d 65 f4 lea -0xc(%ebp),%esp
110ebc: 5b pop %ebx
110ebd: 5e pop %esi
110ebe: 5f pop %edi
110ebf: c9 leave
110ec0: c3 ret
00111008 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
111008: 55 push %ebp
111009: 89 e5 mov %esp,%ebp
11100b: 57 push %edi
11100c: 56 push %esi
11100d: 53 push %ebx
11100e: 83 ec 3c sub $0x3c,%esp
111011: 8b 5d 0c mov 0xc(%ebp),%ebx
111014: 8b 75 10 mov 0x10(%ebp),%esi
/*
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
111017: 8b 4d 18 mov 0x18(%ebp),%ecx
11101a: 01 d9 add %ebx,%ecx
if ( last_byte > the_jnode->info.file.size ) {
11101c: 89 c8 mov %ecx,%eax
11101e: 31 d2 xor %edx,%edx
111020: 8b 7d 08 mov 0x8(%ebp),%edi
111023: 3b 57 54 cmp 0x54(%edi),%edx
111026: 7c 1c jl 111044 <IMFS_memfile_write+0x3c><== NEVER TAKEN
111028: 0f 8e f2 00 00 00 jle 111120 <IMFS_memfile_write+0x118><== ALWAYS TAKEN
status = IMFS_memfile_extend( the_jnode, last_byte );
11102e: 51 push %ecx
11102f: 52 push %edx
111030: 50 push %eax
111031: ff 75 08 pushl 0x8(%ebp)
111034: e8 b7 fe ff ff call 110ef0 <IMFS_memfile_extend>
if ( status )
111039: 83 c4 10 add $0x10,%esp
11103c: 85 c0 test %eax,%eax
11103e: 0f 85 52 01 00 00 jne 111196 <IMFS_memfile_write+0x18e>
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
111044: a1 20 60 12 00 mov 0x126020,%eax
111049: 89 45 d4 mov %eax,-0x2c(%ebp)
11104c: 99 cltd
11104d: 89 45 c8 mov %eax,-0x38(%ebp)
111050: 89 55 cc mov %edx,-0x34(%ebp)
111053: 52 push %edx
111054: 50 push %eax
111055: 56 push %esi
111056: 53 push %ebx
111057: e8 d0 c6 00 00 call 11d72c <__moddi3>
11105c: 83 c4 10 add $0x10,%esp
11105f: 89 c7 mov %eax,%edi
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
111061: ff 75 cc pushl -0x34(%ebp)
111064: ff 75 c8 pushl -0x38(%ebp)
111067: 56 push %esi
111068: 53 push %ebx
111069: e8 72 c5 00 00 call 11d5e0 <__divdi3>
11106e: 83 c4 10 add $0x10,%esp
111071: 89 c3 mov %eax,%ebx
if ( start_offset ) {
111073: 85 ff test %edi,%edi
111075: 75 5d jne 1110d4 <IMFS_memfile_write+0xcc>
unsigned int last_byte;
unsigned int start_offset;
int copied;
const unsigned char *src;
src = source;
111077: 8b 75 14 mov 0x14(%ebp),%esi
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
11107a: 8b 55 18 mov 0x18(%ebp),%edx
status = IMFS_memfile_extend( the_jnode, last_byte );
if ( status )
rtems_set_errno_and_return_minus_one( ENOSPC );
}
copied = 0;
11107d: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp)
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
111084: 3b 55 d4 cmp -0x2c(%ebp),%edx
111087: 73 26 jae 1110af <IMFS_memfile_write+0xa7>
111089: e9 a2 00 00 00 jmp 111130 <IMFS_memfile_write+0x128>
11108e: 66 90 xchg %ax,%ax
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
111090: 8b 00 mov (%eax),%eax
src += to_copy;
111092: 89 c7 mov %eax,%edi
111094: 8b 4d d4 mov -0x2c(%ebp),%ecx
111097: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
block++;
111099: 43 inc %ebx
my_length -= to_copy;
11109a: 2b 55 d4 sub -0x2c(%ebp),%edx
* IMFS_memfile_write
*
* This routine writes the specified data buffer into the in memory
* file pointed to by the_jnode. The file is extended as needed.
*/
MEMFILE_STATIC ssize_t IMFS_memfile_write(
11109d: 8b 45 d4 mov -0x2c(%ebp),%eax
1110a0: 01 45 c8 add %eax,-0x38(%ebp)
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
1110a3: 39 15 20 60 12 00 cmp %edx,0x126020
1110a9: 0f 87 81 00 00 00 ja 111130 <IMFS_memfile_write+0x128>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
1110af: 57 push %edi
1110b0: 6a 00 push $0x0
1110b2: 53 push %ebx
1110b3: ff 75 08 pushl 0x8(%ebp)
1110b6: 89 55 c4 mov %edx,-0x3c(%ebp)
1110b9: e8 2e f8 ff ff call 1108ec <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
1110be: 83 c4 10 add $0x10,%esp
1110c1: 85 c0 test %eax,%eax
1110c3: 8b 55 c4 mov -0x3c(%ebp),%edx
1110c6: 75 c8 jne 111090 <IMFS_memfile_write+0x88><== ALWAYS TAKEN
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
1110c8: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
1110cb: 8d 65 f4 lea -0xc(%ebp),%esp
1110ce: 5b pop %ebx
1110cf: 5e pop %esi
1110d0: 5f pop %edi
1110d1: c9 leave
1110d2: c3 ret
1110d3: 90 nop
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
1110d4: 50 push %eax
1110d5: 6a 00 push $0x0
1110d7: 53 push %ebx
1110d8: ff 75 08 pushl 0x8(%ebp)
1110db: e8 0c f8 ff ff call 1108ec <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
1110e0: 83 c4 10 add $0x10,%esp
1110e3: 85 c0 test %eax,%eax
1110e5: 0f 84 a1 00 00 00 je 11118c <IMFS_memfile_write+0x184><== NEVER TAKEN
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
1110eb: 8b 55 d4 mov -0x2c(%ebp),%edx
1110ee: 29 fa sub %edi,%edx
1110f0: 89 55 c8 mov %edx,-0x38(%ebp)
1110f3: 8b 55 18 mov 0x18(%ebp),%edx
1110f6: 39 55 c8 cmp %edx,-0x38(%ebp)
1110f9: 0f 87 85 00 00 00 ja 111184 <IMFS_memfile_write+0x17c>
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
1110ff: 03 38 add (%eax),%edi
src += to_copy;
111101: 8b 75 14 mov 0x14(%ebp),%esi
111104: 8b 4d c8 mov -0x38(%ebp),%ecx
111107: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
block++;
111109: 43 inc %ebx
my_length -= to_copy;
11110a: 8b 55 18 mov 0x18(%ebp),%edx
11110d: 2b 55 c8 sub -0x38(%ebp),%edx
copied += to_copy;
111110: 8b 3d 20 60 12 00 mov 0x126020,%edi
111116: 89 7d d4 mov %edi,-0x2c(%ebp)
111119: e9 66 ff ff ff jmp 111084 <IMFS_memfile_write+0x7c>
11111e: 66 90 xchg %ax,%ax
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
111120: 3b 4f 50 cmp 0x50(%edi),%ecx
111123: 0f 86 1b ff ff ff jbe 111044 <IMFS_memfile_write+0x3c><== NEVER TAKEN
111129: e9 00 ff ff ff jmp 11102e <IMFS_memfile_write+0x26>
11112e: 66 90 xchg %ax,%ax
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
111130: 85 d2 test %edx,%edx
111132: 74 28 je 11115c <IMFS_memfile_write+0x154>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
111134: 51 push %ecx
111135: 6a 00 push $0x0
111137: 53 push %ebx
111138: ff 75 08 pushl 0x8(%ebp)
11113b: 89 55 c4 mov %edx,-0x3c(%ebp)
11113e: e8 a9 f7 ff ff call 1108ec <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
111143: 83 c4 10 add $0x10,%esp
111146: 85 c0 test %eax,%eax
111148: 8b 55 c4 mov -0x3c(%ebp),%edx
11114b: 0f 84 77 ff ff ff je 1110c8 <IMFS_memfile_write+0xc0><== NEVER TAKEN
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, my_length );
111151: 8b 00 mov (%eax),%eax
111153: 89 c7 mov %eax,%edi
111155: 89 d1 mov %edx,%ecx
111157: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
my_length = 0;
copied += to_copy;
111159: 01 55 c8 add %edx,-0x38(%ebp)
}
IMFS_mtime_ctime_update( the_jnode );
11115c: 83 ec 08 sub $0x8,%esp
11115f: 6a 00 push $0x0
111161: 8d 45 e0 lea -0x20(%ebp),%eax
111164: 50 push %eax
111165: e8 46 65 ff ff call 1076b0 <gettimeofday>
11116a: 8b 45 e0 mov -0x20(%ebp),%eax
11116d: 8b 55 08 mov 0x8(%ebp),%edx
111170: 89 42 44 mov %eax,0x44(%edx)
111173: 89 42 48 mov %eax,0x48(%edx)
return copied;
111176: 83 c4 10 add $0x10,%esp
111179: 8b 45 c8 mov -0x38(%ebp),%eax
}
11117c: 8d 65 f4 lea -0xc(%ebp),%esp
11117f: 5b pop %ebx
111180: 5e pop %esi
111181: 5f pop %edi
111182: c9 leave
111183: c3 ret
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
111184: 89 55 c8 mov %edx,-0x38(%ebp)
111187: e9 73 ff ff ff jmp 1110ff <IMFS_memfile_write+0xf7>
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
11118c: 31 c0 xor %eax,%eax
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
11118e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
111191: 5b pop %ebx <== NOT EXECUTED
111192: 5e pop %esi <== NOT EXECUTED
111193: 5f pop %edi <== NOT EXECUTED
111194: c9 leave <== NOT EXECUTED
111195: c3 ret <== NOT EXECUTED
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
status = IMFS_memfile_extend( the_jnode, last_byte );
if ( status )
rtems_set_errno_and_return_minus_one( ENOSPC );
111196: e8 41 0c 00 00 call 111ddc <__errno>
11119b: c7 00 1c 00 00 00 movl $0x1c,(%eax)
1111a1: 83 c8 ff or $0xffffffff,%eax
1111a4: e9 22 ff ff ff jmp 1110cb <IMFS_memfile_write+0xc3>
00106f3c <IMFS_mknod>:
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
106f3c: 55 push %ebp
106f3d: 89 e5 mov %esp,%ebp
106f3f: 57 push %edi
106f40: 56 push %esi
106f41: 53 push %ebx
106f42: 83 ec 5c sub $0x5c,%esp
106f45: 8b 55 08 mov 0x8(%ebp),%edx
106f48: 8b 5d 0c mov 0xc(%ebp),%ebx
106f4b: 8b 75 10 mov 0x10(%ebp),%esi
106f4e: 8b 45 14 mov 0x14(%ebp),%eax
106f51: 89 45 a4 mov %eax,-0x5c(%ebp)
IMFS_jnode_t *new_node;
int result;
char new_name[ IMFS_NAME_MAX + 1 ];
IMFS_types_union info;
IMFS_get_token( token, strlen( token ), new_name, &result );
106f54: 31 c0 xor %eax,%eax
106f56: b9 ff ff ff ff mov $0xffffffff,%ecx
106f5b: 89 d7 mov %edx,%edi
106f5d: f2 ae repnz scas %es:(%edi),%al
106f5f: f7 d1 not %ecx
106f61: 49 dec %ecx
106f62: 8d 45 e4 lea -0x1c(%ebp),%eax
106f65: 50 push %eax
106f66: 8d 7d af lea -0x51(%ebp),%edi
106f69: 57 push %edi
106f6a: 51 push %ecx
106f6b: 52 push %edx
106f6c: e8 0b 7e 00 00 call 10ed7c <IMFS_get_token>
/*
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
106f71: 89 d8 mov %ebx,%eax
106f73: 25 00 f0 00 00 and $0xf000,%eax
106f78: 83 c4 10 add $0x10,%esp
106f7b: 3d 00 40 00 00 cmp $0x4000,%eax
106f80: 74 56 je 106fd8 <IMFS_mknod+0x9c>
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
106f82: 3d 00 80 00 00 cmp $0x8000,%eax
106f87: 74 57 je 106fe0 <IMFS_mknod+0xa4>
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
106f89: 3d 00 60 00 00 cmp $0x6000,%eax
106f8e: 74 14 je 106fa4 <IMFS_mknod+0x68>
106f90: 3d 00 20 00 00 cmp $0x2000,%eax
106f95: 74 0d je 106fa4 <IMFS_mknod+0x68>
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
} else if (S_ISFIFO(mode))
106f97: 3d 00 10 00 00 cmp $0x1000,%eax
106f9c: 74 4a je 106fe8 <IMFS_mknod+0xac> <== ALWAYS TAKEN
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
IMFS_token_types type = 0;
106f9e: 31 d2 xor %edx,%edx <== NOT EXECUTED
106fa0: eb 10 jmp 106fb2 <IMFS_mknod+0x76> <== NOT EXECUTED
106fa2: 66 90 xchg %ax,%ax <== NOT EXECUTED
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
106fa4: 89 75 d0 mov %esi,-0x30(%ebp)
dev_t device
)
{
union __rtems_dev_t temp;
temp.device = device;
106fa7: 8b 45 a4 mov -0x5c(%ebp),%eax
106faa: 89 45 d4 mov %eax,-0x2c(%ebp)
if ( S_ISDIR(mode) )
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
type = IMFS_DEVICE;
106fad: ba 02 00 00 00 mov $0x2,%edx
* was ONLY passed a NULL when we created the root node. We
* added a new IMFS_create_root_node() so this path no longer
* existed. The result was simpler code which should not have
* this path.
*/
new_node = IMFS_create_node( pathloc, type, new_name, mode, &info );
106fb2: 83 ec 0c sub $0xc,%esp
106fb5: 8d 45 d0 lea -0x30(%ebp),%eax
106fb8: 50 push %eax
106fb9: 53 push %ebx
106fba: 57 push %edi
106fbb: 52 push %edx
106fbc: ff 75 18 pushl 0x18(%ebp)
106fbf: e8 20 74 00 00 call 10e3e4 <IMFS_create_node>
if ( !new_node )
106fc4: 83 c4 20 add $0x20,%esp
106fc7: 85 c0 test %eax,%eax
106fc9: 74 24 je 106fef <IMFS_mknod+0xb3>
rtems_set_errno_and_return_minus_one( ENOMEM );
return 0;
106fcb: 31 c0 xor %eax,%eax
}
106fcd: 8d 65 f4 lea -0xc(%ebp),%esp
106fd0: 5b pop %ebx
106fd1: 5e pop %esi
106fd2: 5f pop %edi
106fd3: c9 leave
106fd4: c3 ret
106fd5: 8d 76 00 lea 0x0(%esi),%esi
/*
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
type = IMFS_DIRECTORY;
106fd8: ba 01 00 00 00 mov $0x1,%edx
106fdd: eb d3 jmp 106fb2 <IMFS_mknod+0x76>
106fdf: 90 nop
else if ( S_ISREG(mode) )
type = IMFS_MEMORY_FILE;
106fe0: ba 05 00 00 00 mov $0x5,%edx
106fe5: eb cb jmp 106fb2 <IMFS_mknod+0x76>
106fe7: 90 nop
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
} else if (S_ISFIFO(mode))
type = IMFS_FIFO;
106fe8: ba 07 00 00 00 mov $0x7,%edx
106fed: eb c3 jmp 106fb2 <IMFS_mknod+0x76>
* existed. The result was simpler code which should not have
* this path.
*/
new_node = IMFS_create_node( pathloc, type, new_name, mode, &info );
if ( !new_node )
rtems_set_errno_and_return_minus_one( ENOMEM );
106fef: e8 e8 ad 00 00 call 111ddc <__errno>
106ff4: c7 00 0c 00 00 00 movl $0xc,(%eax)
106ffa: b8 ff ff ff ff mov $0xffffffff,%eax
106fff: eb cc jmp 106fcd <IMFS_mknod+0x91>
00107004 <IMFS_mount>:
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
107004: 55 push %ebp
107005: 89 e5 mov %esp,%ebp
107007: 83 ec 08 sub $0x8,%esp
10700a: 8b 55 08 mov 0x8(%ebp),%edx
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
10700d: 8b 42 08 mov 0x8(%edx),%eax
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
107010: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
107014: 75 0a jne 107020 <IMFS_mount+0x1c> <== NEVER TAKEN
/*
* Set mt_fs pointer to point to the mount table entry for
* the mounted file system.
*/
node->info.directory.mt_fs = mt_entry;
107016: 89 50 5c mov %edx,0x5c(%eax)
return 0;
107019: 31 c0 xor %eax,%eax
}
10701b: c9 leave
10701c: c3 ret
10701d: 8d 76 00 lea 0x0(%esi),%esi
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
107020: e8 b7 ad 00 00 call 111ddc <__errno> <== NOT EXECUTED
107025: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
10702b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
* the mounted file system.
*/
node->info.directory.mt_fs = mt_entry;
return 0;
}
107030: c9 leave <== NOT EXECUTED
107031: c3 ret <== NOT EXECUTED
00109920 <IMFS_print_jnode>:
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
109920: 55 push %ebp
109921: 89 e5 mov %esp,%ebp
109923: 53 push %ebx
109924: 83 ec 0c sub $0xc,%esp
109927: 8b 5d 08 mov 0x8(%ebp),%ebx
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
10992a: a1 00 ab 12 00 mov 0x12ab00,%eax
10992f: ff 70 08 pushl 0x8(%eax)
109932: 8d 43 0c lea 0xc(%ebx),%eax
109935: 50 push %eax
109936: e8 f9 ca 00 00 call 116434 <fputs>
switch( the_jnode->type ) {
10993b: 8b 43 4c mov 0x4c(%ebx),%eax
10993e: 83 c4 10 add $0x10,%esp
109941: 83 f8 07 cmp $0x7,%eax
109944: 76 1e jbe 109964 <IMFS_print_jnode+0x44> <== ALWAYS TAKEN
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
109946: 52 push %edx <== NOT EXECUTED
109947: 50 push %eax <== NOT EXECUTED
109948: 68 04 5b 12 00 push $0x125b04 <== NOT EXECUTED
10994d: a1 00 ab 12 00 mov 0x12ab00,%eax <== NOT EXECUTED
109952: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
109955: e8 ce c9 00 00 call 116328 <fprintf> <== NOT EXECUTED
return;
10995a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
puts("");
}
10995d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
109960: c9 leave <== NOT EXECUTED
109961: c3 ret <== NOT EXECUTED
109962: 66 90 xchg %ax,%ax <== NOT EXECUTED
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
switch( the_jnode->type ) {
109964: ff 24 85 1c 5b 12 00 jmp *0x125b1c(,%eax,4)
10996b: 90 nop
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
10996c: a1 00 ab 12 00 mov 0x12ab00,%eax
109971: ff 70 08 pushl 0x8(%eax)
109974: 6a 13 push $0x13
109976: 6a 01 push $0x1
109978: 68 dd 5a 12 00 push $0x125add
10997d: e8 d6 d6 00 00 call 117058 <fwrite>
return;
109982: 83 c4 10 add $0x10,%esp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
}
109985: 8b 5d fc mov -0x4(%ebp),%ebx
109988: c9 leave
109989: c3 ret
10998a: 66 90 xchg %ax,%ax
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
10998c: a1 00 ab 12 00 mov 0x12ab00,%eax
109991: ff 70 08 pushl 0x8(%eax)
109994: 6a 12 push $0x12
109996: 6a 01 push $0x1
109998: 68 f1 5a 12 00 push $0x125af1
10999d: e8 b6 d6 00 00 call 117058 <fwrite>
return;
1099a2: 83 c4 10 add $0x10,%esp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
}
1099a5: 8b 5d fc mov -0x4(%ebp),%ebx
1099a8: c9 leave
1099a9: c3 ret
1099aa: 66 90 xchg %ax,%ax
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
1099ac: 51 push %ecx
1099ad: ff 73 50 pushl 0x50(%ebx)
1099b0: 68 d1 5a 12 00 push $0x125ad1
1099b5: a1 00 ab 12 00 mov 0x12ab00,%eax
1099ba: ff 70 08 pushl 0x8(%eax)
1099bd: e8 66 c9 00 00 call 116328 <fprintf>
(uint32_t)the_jnode->info.file.size );
#endif
break;
1099c2: 83 c4 10 add $0x10,%esp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
1099c5: c7 45 08 09 5e 12 00 movl $0x125e09,0x8(%ebp)
}
1099cc: 8b 5d fc mov -0x4(%ebp),%ebx
1099cf: c9 leave
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
1099d0: e9 83 e2 00 00 jmp 117c58 <puts>
1099d5: 8d 76 00 lea 0x0(%esi),%esi
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
1099d8: ff 73 58 pushl 0x58(%ebx)
1099db: ff 73 50 pushl 0x50(%ebx)
1099de: 68 c2 5a 12 00 push $0x125ac2
1099e3: a1 00 ab 12 00 mov 0x12ab00,%eax
1099e8: ff 70 08 pushl 0x8(%eax)
1099eb: e8 38 c9 00 00 call 116328 <fprintf>
(uint32_t)the_jnode->info.linearfile.size,
the_jnode->info.linearfile.direct
);
break;
1099f0: 83 c4 10 add $0x10,%esp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
1099f3: c7 45 08 09 5e 12 00 movl $0x125e09,0x8(%ebp)
}
1099fa: 8b 5d fc mov -0x4(%ebp),%ebx
1099fd: c9 leave
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
1099fe: e9 55 e2 00 00 jmp 117c58 <puts>
109a03: 90 nop
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
switch( the_jnode->type ) {
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
109a04: 83 ec 08 sub $0x8,%esp
109a07: a1 00 ab 12 00 mov 0x12ab00,%eax
109a0c: ff 70 08 pushl 0x8(%eax)
109a0f: 6a 2f push $0x2f
109a11: e8 72 c9 00 00 call 116388 <fputc>
break;
109a16: 83 c4 10 add $0x10,%esp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
109a19: c7 45 08 09 5e 12 00 movl $0x125e09,0x8(%ebp)
}
109a20: 8b 5d fc mov -0x4(%ebp),%ebx
109a23: c9 leave
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
109a24: e9 2f e2 00 00 jmp 117c58 <puts>
109a29: 8d 76 00 lea 0x0(%esi),%esi
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
break;
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
109a2c: ff 73 54 pushl 0x54(%ebx)
109a2f: ff 73 50 pushl 0x50(%ebx)
109a32: 68 af 5a 12 00 push $0x125aaf
109a37: a1 00 ab 12 00 mov 0x12ab00,%eax
109a3c: ff 70 08 pushl 0x8(%eax)
109a3f: e8 e4 c8 00 00 call 116328 <fprintf>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
109a44: 83 c4 10 add $0x10,%esp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
109a47: c7 45 08 09 5e 12 00 movl $0x125e09,0x8(%ebp)
}
109a4e: 8b 5d fc mov -0x4(%ebp),%ebx
109a51: c9 leave
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
109a52: e9 01 e2 00 00 jmp 117c58 <puts>
00107044 <IMFS_readlink>:
ssize_t IMFS_readlink(
rtems_filesystem_location_info_t *loc,
char *buf, /* OUT */
size_t bufsize
)
{
107044: 55 push %ebp
107045: 89 e5 mov %esp,%ebp
107047: 57 push %edi
107048: 56 push %esi
107049: 53 push %ebx
10704a: 8b 7d 0c mov 0xc(%ebp),%edi
10704d: 8b 5d 10 mov 0x10(%ebp),%ebx
IMFS_jnode_t *node;
ssize_t i;
node = loc->node_access;
107050: 8b 45 08 mov 0x8(%ebp),%eax
107053: 8b 30 mov (%eax),%esi
IMFS_assert( node->type == IMFS_SYM_LINK );
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
107055: 85 db test %ebx,%ebx
107057: 74 28 je 107081 <IMFS_readlink+0x3d> <== NEVER TAKEN
107059: 8b 46 50 mov 0x50(%esi),%eax
10705c: 8a 10 mov (%eax),%dl
10705e: 84 d2 test %dl,%dl
107060: 74 1f je 107081 <IMFS_readlink+0x3d> <== NEVER TAKEN
107062: 31 c9 xor %ecx,%ecx
107064: 31 c0 xor %eax,%eax
107066: eb 0a jmp 107072 <IMFS_readlink+0x2e>
107068: 8b 56 50 mov 0x50(%esi),%edx
10706b: 8a 14 02 mov (%edx,%eax,1),%dl
10706e: 84 d2 test %dl,%dl
107070: 74 0a je 10707c <IMFS_readlink+0x38>
buf[i] = node->info.sym_link.name[i];
107072: 88 14 0f mov %dl,(%edi,%ecx,1)
node = loc->node_access;
IMFS_assert( node->type == IMFS_SYM_LINK );
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
107075: 40 inc %eax
107076: 89 c1 mov %eax,%ecx
107078: 39 d8 cmp %ebx,%eax
10707a: 72 ec jb 107068 <IMFS_readlink+0x24>
buf[i] = node->info.sym_link.name[i];
return i;
}
10707c: 5b pop %ebx
10707d: 5e pop %esi
10707e: 5f pop %edi
10707f: c9 leave
107080: c3 ret
node = loc->node_access;
IMFS_assert( node->type == IMFS_SYM_LINK );
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
107081: 31 c0 xor %eax,%eax
107083: eb f7 jmp 10707c <IMFS_readlink+0x38> <== NOT EXECUTED
00107088 <IMFS_rename>:
rtems_filesystem_location_info_t *old_parent_loc, /* IN */
rtems_filesystem_location_info_t *old_loc, /* IN */
rtems_filesystem_location_info_t *new_parent_loc, /* IN */
const char *new_name /* IN */
)
{
107088: 55 push %ebp
107089: 89 e5 mov %esp,%ebp
10708b: 53 push %ebx
10708c: 83 ec 18 sub $0x18,%esp
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
10708f: 8b 45 0c mov 0xc(%ebp),%eax
107092: 8b 18 mov (%eax),%ebx
strncpy( the_jnode->name, new_name, IMFS_NAME_MAX );
107094: 6a 20 push $0x20
107096: ff 75 14 pushl 0x14(%ebp)
107099: 8d 43 0c lea 0xc(%ebx),%eax
10709c: 50 push %eax
10709d: e8 2a bb 00 00 call 112bcc <strncpy>
if ( the_jnode->Parent != NULL )
1070a2: 83 c4 10 add $0x10,%esp
1070a5: 8b 4b 08 mov 0x8(%ebx),%ecx
1070a8: 85 c9 test %ecx,%ecx
1070aa: 74 0c je 1070b8 <IMFS_rename+0x30> <== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
1070ac: 83 ec 0c sub $0xc,%esp
1070af: 53 push %ebx
1070b0: e8 f3 43 00 00 call 10b4a8 <_Chain_Extract>
1070b5: 83 c4 10 add $0x10,%esp
rtems_chain_extract( (rtems_chain_node *) the_jnode );
new_parent = new_parent_loc->node_access;
1070b8: 8b 45 10 mov 0x10(%ebp),%eax
1070bb: 8b 00 mov (%eax),%eax
the_jnode->Parent = new_parent;
1070bd: 89 43 08 mov %eax,0x8(%ebx)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
1070c0: 83 ec 08 sub $0x8,%esp
1070c3: 53 push %ebx
rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
1070c4: 83 c0 50 add $0x50,%eax
1070c7: 50 push %eax
1070c8: e8 b7 43 00 00 call 10b484 <_Chain_Append>
/*
* Update the time.
*/
IMFS_update_ctime( the_jnode );
1070cd: 58 pop %eax
1070ce: 5a pop %edx
1070cf: 6a 00 push $0x0
1070d1: 8d 45 f0 lea -0x10(%ebp),%eax
1070d4: 50 push %eax
1070d5: e8 d6 05 00 00 call 1076b0 <gettimeofday>
1070da: 8b 45 f0 mov -0x10(%ebp),%eax
1070dd: 89 43 48 mov %eax,0x48(%ebx)
return 0;
}
1070e0: 31 c0 xor %eax,%eax
1070e2: 8b 5d fc mov -0x4(%ebp),%ebx
1070e5: c9 leave
1070e6: c3 ret
0010ef48 <IMFS_stat>:
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
10ef48: 55 push %ebp
10ef49: 89 e5 mov %esp,%ebp
10ef4b: 56 push %esi
10ef4c: 53 push %ebx
10ef4d: 8b 4d 08 mov 0x8(%ebp),%ecx
10ef50: 8b 45 0c mov 0xc(%ebp),%eax
IMFS_fs_info_t *fs_info;
IMFS_jnode_t *the_jnode;
IMFS_device_t *io;
the_jnode = loc->node_access;
10ef53: 8b 11 mov (%ecx),%edx
switch ( the_jnode->type ) {
10ef55: 83 7a 4c 07 cmpl $0x7,0x4c(%edx)
10ef59: 76 15 jbe 10ef70 <IMFS_stat+0x28> <== ALWAYS TAKEN
case IMFS_FIFO:
buf->st_size = 0;
break;
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
10ef5b: e8 7c 2e 00 00 call 111ddc <__errno>
10ef60: c7 00 86 00 00 00 movl $0x86,(%eax)
10ef66: b8 ff ff ff ff mov $0xffffffff,%eax
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
return 0;
}
10ef6b: 5b pop %ebx
10ef6c: 5e pop %esi
10ef6d: c9 leave
10ef6e: c3 ret
10ef6f: 90 nop
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
10ef70: 8b 5a 4c mov 0x4c(%edx),%ebx
10ef73: ff 24 9d 58 03 12 00 jmp *0x120358(,%ebx,4)
10ef7a: 66 90 xchg %ax,%ax
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
10ef7c: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax)
10ef83: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
/*
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
10ef8a: 8b 49 10 mov 0x10(%ecx),%ecx
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
10ef8d: 8b 49 34 mov 0x34(%ecx),%ecx
10ef90: 8b 09 mov (%ecx),%ecx
/*
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
10ef92: c7 00 fe ff 00 00 movl $0xfffe,(%eax)
10ef98: 89 48 04 mov %ecx,0x4(%eax)
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
10ef9b: 8b 4a 30 mov 0x30(%edx),%ecx
10ef9e: 89 48 0c mov %ecx,0xc(%eax)
buf->st_nlink = the_jnode->st_nlink;
10efa1: 8b 4a 34 mov 0x34(%edx),%ecx
10efa4: 66 89 48 10 mov %cx,0x10(%eax)
buf->st_ino = the_jnode->st_ino;
10efa8: 8b 4a 38 mov 0x38(%edx),%ecx
10efab: 89 48 08 mov %ecx,0x8(%eax)
buf->st_uid = the_jnode->st_uid;
10efae: 8b 4a 3c mov 0x3c(%edx),%ecx
10efb1: 66 89 48 12 mov %cx,0x12(%eax)
buf->st_gid = the_jnode->st_gid;
10efb5: 66 8b 4a 3e mov 0x3e(%edx),%cx
10efb9: 66 89 48 14 mov %cx,0x14(%eax)
buf->st_atime = the_jnode->stat_atime;
10efbd: 8b 4a 40 mov 0x40(%edx),%ecx
10efc0: 89 48 28 mov %ecx,0x28(%eax)
buf->st_mtime = the_jnode->stat_mtime;
10efc3: 8b 4a 44 mov 0x44(%edx),%ecx
10efc6: 89 48 30 mov %ecx,0x30(%eax)
buf->st_ctime = the_jnode->stat_ctime;
10efc9: 8b 52 48 mov 0x48(%edx),%edx
10efcc: 89 50 38 mov %edx,0x38(%eax)
return 0;
10efcf: 31 c0 xor %eax,%eax
}
10efd1: 5b pop %ebx
10efd2: 5e pop %esi
10efd3: c9 leave
10efd4: c3 ret
10efd5: 8d 76 00 lea 0x0(%esi),%esi
switch ( the_jnode->type ) {
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
10efd8: 8b 5a 54 mov 0x54(%edx),%ebx
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
10efdb: 8b 72 50 mov 0x50(%edx),%esi
10efde: 89 70 18 mov %esi,0x18(%eax)
10efe1: 89 58 1c mov %ebx,0x1c(%eax)
break;
10efe4: eb a4 jmp 10ef8a <IMFS_stat+0x42>
10efe6: 66 90 xchg %ax,%ax
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
10efe8: 8b 5a 50 mov 0x50(%edx),%ebx
10efeb: 8b 72 54 mov 0x54(%edx),%esi
10efee: 89 58 20 mov %ebx,0x20(%eax)
10eff1: 89 70 24 mov %esi,0x24(%eax)
break;
10eff4: eb 94 jmp 10ef8a <IMFS_stat+0x42>
0010717c <IMFS_unlink>:
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
10717c: 55 push %ebp
10717d: 89 e5 mov %esp,%ebp
10717f: 57 push %edi
107180: 56 push %esi
107181: 53 push %ebx
107182: 83 ec 3c sub $0x3c,%esp
107185: 8b 5d 0c mov 0xc(%ebp),%ebx
IMFS_jnode_t *node;
rtems_filesystem_location_info_t the_link;
int result = 0;
node = loc->node_access;
107188: 8b 13 mov (%ebx),%edx
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
10718a: 83 7a 4c 03 cmpl $0x3,0x4c(%edx)
10718e: 74 18 je 1071a8 <IMFS_unlink+0x2c>
/*
* Now actually free the node we were asked to free.
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
107190: 83 ec 08 sub $0x8,%esp
107193: 8b 43 08 mov 0x8(%ebx),%eax
107196: 53 push %ebx
107197: ff 75 08 pushl 0x8(%ebp)
10719a: ff 50 34 call *0x34(%eax)
return result;
10719d: 83 c4 10 add $0x10,%esp
}
1071a0: 8d 65 f4 lea -0xc(%ebp),%esp
1071a3: 5b pop %ebx
1071a4: 5e pop %esi
1071a5: 5f pop %edi
1071a6: c9 leave
1071a7: c3 ret
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
1071a8: 8b 42 50 mov 0x50(%edx),%eax
1071ab: 85 c0 test %eax,%eax
1071ad: 74 79 je 107228 <IMFS_unlink+0xac> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
1071af: 8d 7d cc lea -0x34(%ebp),%edi
1071b2: b9 05 00 00 00 mov $0x5,%ecx
1071b7: 89 de mov %ebx,%esi
1071b9: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_link.node_access = node->info.hard_link.link_node;
1071bb: 89 45 cc mov %eax,-0x34(%ebp)
IMFS_Set_handlers( &the_link );
1071be: 83 ec 0c sub $0xc,%esp
1071c1: 8d 75 cc lea -0x34(%ebp),%esi
1071c4: 56 push %esi
1071c5: 89 55 c4 mov %edx,-0x3c(%ebp)
1071c8: e8 83 73 00 00 call 10e550 <IMFS_Set_handlers>
/*
* If removing the last hard link to a node, then we need
* to remove the node that is a link and the node itself.
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
1071cd: 8b 55 c4 mov -0x3c(%ebp),%edx
1071d0: 8b 42 50 mov 0x50(%edx),%eax
1071d3: 8b 48 34 mov 0x34(%eax),%ecx
1071d6: 83 c4 10 add $0x10,%esp
1071d9: 66 83 f9 01 cmp $0x1,%cx
1071dd: 74 27 je 107206 <IMFS_unlink+0x8a>
if ( result != 0 )
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
1071df: 49 dec %ecx
1071e0: 66 89 48 34 mov %cx,0x34(%eax)
IMFS_update_ctime( node->info.hard_link.link_node );
1071e4: 83 ec 08 sub $0x8,%esp
1071e7: 6a 00 push $0x0
1071e9: 8d 45 e0 lea -0x20(%ebp),%eax
1071ec: 50 push %eax
1071ed: 89 55 c4 mov %edx,-0x3c(%ebp)
1071f0: e8 bb 04 00 00 call 1076b0 <gettimeofday>
1071f5: 8b 55 c4 mov -0x3c(%ebp),%edx
1071f8: 8b 42 50 mov 0x50(%edx),%eax
1071fb: 8b 55 e0 mov -0x20(%ebp),%edx
1071fe: 89 50 48 mov %edx,0x48(%eax)
107201: 83 c4 10 add $0x10,%esp
107204: eb 8a jmp 107190 <IMFS_unlink+0x14>
* to remove the node that is a link and the node itself.
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
107206: 83 ec 08 sub $0x8,%esp
107209: 56 push %esi
10720a: ff 75 08 pushl 0x8(%ebp)
10720d: 8b 45 d4 mov -0x2c(%ebp),%eax
107210: ff 50 34 call *0x34(%eax)
if ( result != 0 )
107213: 83 c4 10 add $0x10,%esp
107216: 85 c0 test %eax,%eax
107218: 0f 84 72 ff ff ff je 107190 <IMFS_unlink+0x14>
return -1;
10721e: b8 ff ff ff ff mov $0xffffffff,%eax
107223: e9 78 ff ff ff jmp 1071a0 <IMFS_unlink+0x24>
*/
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
107228: e8 af ab 00 00 call 111ddc <__errno> <== NOT EXECUTED
10722d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
107233: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
107238: e9 63 ff ff ff jmp 1071a0 <IMFS_unlink+0x24> <== NOT EXECUTED
00107240 <IMFS_unmount>:
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
107240: 55 push %ebp
107241: 89 e5 mov %esp,%ebp
107243: 83 ec 08 sub $0x8,%esp
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
107246: 8b 45 08 mov 0x8(%ebp),%eax
107249: 8b 40 08 mov 0x8(%eax),%eax
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
10724c: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
107250: 75 12 jne 107264 <IMFS_unmount+0x24> <== NEVER TAKEN
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
107252: 8b 50 5c mov 0x5c(%eax),%edx
107255: 85 d2 test %edx,%edx
107257: 74 1d je 107276 <IMFS_unmount+0x36> <== NEVER TAKEN
/*
* Set the mt_fs pointer to indicate that there is no longer
* a file system mounted to this point.
*/
node->info.directory.mt_fs = NULL;
107259: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
return 0;
107260: 31 c0 xor %eax,%eax
}
107262: c9 leave
107263: c3 ret
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
107264: e8 73 ab 00 00 call 111ddc <__errno> <== NOT EXECUTED
107269: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
10726f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
*/
node->info.directory.mt_fs = NULL;
return 0;
}
107274: c9 leave <== NOT EXECUTED
107275: c3 ret <== NOT EXECUTED
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */
107276: e8 61 ab 00 00 call 111ddc <__errno> <== NOT EXECUTED
10727b: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
107281: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
*/
node->info.directory.mt_fs = NULL;
return 0;
}
107286: c9 leave <== NOT EXECUTED
107287: c3 ret <== NOT EXECUTED
0010785c <RTEMS_Malloc_Initialize>:
void RTEMS_Malloc_Initialize(
void *heap_begin,
uintptr_t heap_size,
size_t sbrk_amount
)
{
10785c: 55 push %ebp
10785d: 89 e5 mov %esp,%ebp
10785f: 57 push %edi
107860: 56 push %esi
107861: 53 push %ebx
107862: 83 ec 0c sub $0xc,%esp
107865: 8b 5d 08 mov 0x8(%ebp),%ebx
107868: 8b 75 0c mov 0xc(%ebp),%esi
10786b: 8b 7d 10 mov 0x10(%ebp),%edi
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
10786e: a1 a8 47 12 00 mov 0x1247a8,%eax
107873: 85 c0 test %eax,%eax
107875: 74 02 je 107879 <RTEMS_Malloc_Initialize+0x1d>
(*rtems_malloc_statistics_helpers->initialize)();
107877: ff 10 call *(%eax)
}
/*
* Initialize the garbage collection list to start with nothing on it.
*/
malloc_deferred_frees_initialize();
107879: e8 76 ff ff ff call 1077f4 <malloc_deferred_frees_initialize>
/*
* Initialize the optional sbrk support for extending the heap
*/
if ( rtems_malloc_sbrk_helpers != NULL ) {
10787e: a1 ac 47 12 00 mov 0x1247ac,%eax
107883: 85 c0 test %eax,%eax
107885: 74 0e je 107895 <RTEMS_Malloc_Initialize+0x39>
heap_begin = (*rtems_malloc_sbrk_helpers->initialize)(
107887: 83 ec 08 sub $0x8,%esp
10788a: 57 push %edi
10788b: 53 push %ebx
10788c: ff 10 call *(%eax)
10788e: 89 c3 mov %eax,%ebx
107890: 83 c4 10 add $0x10,%esp
heap_begin,
sbrk_amount
);
heap_size = (uintptr_t) sbrk_amount;
107893: 89 fe mov %edi,%esi
* of the time under UNIX because zero'ing memory when it is first
* given to a process eliminates the chance of a process seeing data
* left over from another process. This would be a security violation.
*/
if (
107895: 80 3d a4 47 12 00 00 cmpb $0x0,0x1247a4
10789c: 75 1f jne 1078bd <RTEMS_Malloc_Initialize+0x61>
!rtems_unified_work_area
&& rtems_configuration_get_do_zero_of_workspace()
10789e: 80 3d 28 23 12 00 00 cmpb $0x0,0x122328
1078a5: 75 41 jne 1078e8 <RTEMS_Malloc_Initialize+0x8c>
void *area_begin,
uintptr_t area_size,
uintptr_t page_size
)
{
return _Heap_Initialize( heap, area_begin, area_size, page_size );
1078a7: 6a 04 push $0x4
1078a9: 56 push %esi
1078aa: 53 push %ebx
1078ab: ff 35 30 22 12 00 pushl 0x122230
1078b1: e8 aa 41 00 00 call 10ba60 <_Heap_Initialize>
RTEMS_Malloc_Heap,
heap_begin,
heap_size,
CPU_HEAP_ALIGNMENT
);
if ( status == 0 ) {
1078b6: 83 c4 10 add $0x10,%esp
1078b9: 85 c0 test %eax,%eax
1078bb: 74 3e je 1078fb <RTEMS_Malloc_Initialize+0x9f>
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
}
}
MSBUMP( space_available, _Protected_heap_Get_size(RTEMS_Malloc_Heap) );
1078bd: 8b 1d a0 63 12 00 mov 0x1263a0,%ebx
1078c3: 83 ec 0c sub $0xc,%esp
1078c6: ff 35 30 22 12 00 pushl 0x122230
1078cc: e8 d3 4b 00 00 call 10c4a4 <_Protected_heap_Get_size>
1078d1: 8d 1c 18 lea (%eax,%ebx,1),%ebx
1078d4: 89 1d a0 63 12 00 mov %ebx,0x1263a0
1078da: 83 c4 10 add $0x10,%esp
}
1078dd: 8d 65 f4 lea -0xc(%ebp),%esp
1078e0: 5b pop %ebx
1078e1: 5e pop %esi
1078e2: 5f pop %edi
1078e3: c9 leave
1078e4: c3 ret
1078e5: 8d 76 00 lea 0x0(%esi),%esi
if (
!rtems_unified_work_area
&& rtems_configuration_get_do_zero_of_workspace()
) {
memset( heap_begin, 0, heap_size );
1078e8: 31 c0 xor %eax,%eax
1078ea: 89 df mov %ebx,%edi
1078ec: 89 f1 mov %esi,%ecx
1078ee: f3 aa rep stos %al,%es:(%edi)
* Unfortunately we cannot use assert if this fails because if this
* has failed we do not have a heap and if we do not have a heap
* STDIO cannot work because there will be no buffers.
*/
if ( !rtems_unified_work_area ) {
1078f0: 80 3d a4 47 12 00 00 cmpb $0x0,0x1247a4
1078f7: 74 ae je 1078a7 <RTEMS_Malloc_Initialize+0x4b><== ALWAYS TAKEN
1078f9: eb c2 jmp 1078bd <RTEMS_Malloc_Initialize+0x61><== NOT EXECUTED
heap_begin,
heap_size,
CPU_HEAP_ALIGNMENT
);
if ( status == 0 ) {
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
1078fb: 83 ec 0c sub $0xc,%esp
1078fe: 6a 1a push $0x1a
107900: e8 e3 38 00 00 call 10b1e8 <rtems_fatal_error_occurred>
00106d90 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
106d90: 55 push %ebp <== NOT EXECUTED
106d91: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106d93: 57 push %edi <== NOT EXECUTED
106d94: 56 push %esi <== NOT EXECUTED
106d95: 53 push %ebx <== NOT EXECUTED
106d96: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED
106d99: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
106d9c: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED
106d9f: 0f 84 37 01 00 00 je 106edc <Stack_check_Dump_threads_usage+0x14c><== NOT EXECUTED
the_thread = 0;
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
106da5: 8d b3 b4 00 00 00 lea 0xb4(%ebx),%esi <== NOT EXECUTED
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
106dab: 8b 83 c8 00 00 00 mov 0xc8(%ebx),%eax <== NOT EXECUTED
106db1: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED
106db4: 8b 8b b8 00 00 00 mov 0xb8(%ebx),%ecx <== NOT EXECUTED
}
low = Stack_check_usable_stack_start(stack);
106dba: 8d 51 10 lea 0x10(%ecx),%edx <== NOT EXECUTED
106dbd: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
106dc0: 8b 3e mov (%esi),%edi <== NOT EXECUTED
106dc2: 83 ef 10 sub $0x10,%edi <== NOT EXECUTED
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
106dc5: 8d 41 20 lea 0x20(%ecx),%eax <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
106dc8: 89 fa mov %edi,%edx <== NOT EXECUTED
106dca: 83 e2 fc and $0xfffffffc,%edx <== NOT EXECUTED
106dcd: 8d 14 10 lea (%eax,%edx,1),%edx <== NOT EXECUTED
106dd0: 39 d0 cmp %edx,%eax <== NOT EXECUTED
106dd2: 73 23 jae 106df7 <Stack_check_Dump_threads_usage+0x67><== NOT EXECUTED
if (*base != U32_PATTERN)
106dd4: 81 79 20 a5 a5 a5 a5 cmpl $0xa5a5a5a5,0x20(%ecx) <== NOT EXECUTED
106ddb: 74 13 je 106df0 <Stack_check_Dump_threads_usage+0x60><== NOT EXECUTED
106ddd: e9 a2 00 00 00 jmp 106e84 <Stack_check_Dump_threads_usage+0xf4><== NOT EXECUTED
106de2: 66 90 xchg %ax,%ax <== NOT EXECUTED
106de4: 81 38 a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%eax) <== NOT EXECUTED
106dea: 0f 85 94 00 00 00 jne 106e84 <Stack_check_Dump_threads_usage+0xf4><== NOT EXECUTED
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
106df0: 83 c0 04 add $0x4,%eax <== NOT EXECUTED
106df3: 39 c2 cmp %eax,%edx <== NOT EXECUTED
106df5: 77 ed ja 106de4 <Stack_check_Dump_threads_usage+0x54><== NOT EXECUTED
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
used = Stack_check_Calculate_used( low, size, high_water_mark );
else
used = 0;
106df7: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
106dfe: 85 db test %ebx,%ebx <== NOT EXECUTED
106e00: 0f 84 98 00 00 00 je 106e9e <Stack_check_Dump_threads_usage+0x10e><== NOT EXECUTED
#endif
{
(*print_handler)(
106e06: a1 cc 65 12 00 mov 0x1265cc,%eax <== NOT EXECUTED
106e0b: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED
106e0e: 50 push %eax <== NOT EXECUTED
106e0f: 8d 45 e3 lea -0x1d(%ebp),%eax <== NOT EXECUTED
106e12: 50 push %eax <== NOT EXECUTED
106e13: 6a 05 push $0x5 <== NOT EXECUTED
106e15: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
106e18: e8 47 3f 00 00 call 10ad64 <rtems_object_get_name> <== NOT EXECUTED
106e1d: 50 push %eax <== NOT EXECUTED
106e1e: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
106e21: 68 d7 00 12 00 push $0x1200d7 <== NOT EXECUTED
106e26: ff 35 c8 65 12 00 pushl 0x1265c8 <== NOT EXECUTED
106e2c: ff 55 cc call *-0x34(%ebp) <== NOT EXECUTED
106e2f: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
106e32: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
106e35: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
106e38: 57 push %edi <== NOT EXECUTED
106e39: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
106e3c: 8b 16 mov (%esi),%edx <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
106e3e: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED
106e42: 52 push %edx <== NOT EXECUTED
106e43: 50 push %eax <== NOT EXECUTED
106e44: 68 f2 00 12 00 push $0x1200f2 <== NOT EXECUTED
106e49: ff 35 c8 65 12 00 pushl 0x1265c8 <== NOT EXECUTED
106e4f: ff 15 cc 65 12 00 call *0x1265cc <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
106e55: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
106e58: 8b 15 d0 65 12 00 mov 0x1265d0,%edx <== NOT EXECUTED
106e5e: 85 d2 test %edx,%edx <== NOT EXECUTED
106e60: 74 5a je 106ebc <Stack_check_Dump_threads_usage+0x12c><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
106e62: 50 push %eax <== NOT EXECUTED
106e63: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED
106e66: 68 1d 01 12 00 push $0x12011d <== NOT EXECUTED
106e6b: ff 35 c8 65 12 00 pushl 0x1265c8 <== NOT EXECUTED
106e71: ff 15 cc 65 12 00 call *0x1265cc <== NOT EXECUTED
106e77: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
106e7a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
106e7d: 5b pop %ebx <== NOT EXECUTED
106e7e: 5e pop %esi <== NOT EXECUTED
106e7f: 5f pop %edi <== NOT EXECUTED
106e80: c9 leave <== NOT EXECUTED
106e81: c3 ret <== NOT EXECUTED
106e82: 66 90 xchg %ax,%ax <== NOT EXECUTED
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
106e84: 85 c0 test %eax,%eax <== NOT EXECUTED
106e86: 0f 84 6b ff ff ff je 106df7 <Stack_check_Dump_threads_usage+0x67><== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
106e8c: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED
106e8f: 01 fa add %edi,%edx <== NOT EXECUTED
106e91: 29 c2 sub %eax,%edx <== NOT EXECUTED
106e93: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
106e96: 85 db test %ebx,%ebx <== NOT EXECUTED
106e98: 0f 85 68 ff ff ff jne 106e06 <Stack_check_Dump_threads_usage+0x76><== NOT EXECUTED
rtems_object_get_name( the_thread->Object.id, sizeof(name), name )
);
}
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
106e9e: 51 push %ecx <== NOT EXECUTED
106e9f: 6a ff push $0xffffffff <== NOT EXECUTED
106ea1: 68 e4 00 12 00 push $0x1200e4 <== NOT EXECUTED
106ea6: ff 35 c8 65 12 00 pushl 0x1265c8 <== NOT EXECUTED
106eac: ff 15 cc 65 12 00 call *0x1265cc <== NOT EXECUTED
106eb2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106eb5: e9 78 ff ff ff jmp 106e32 <Stack_check_Dump_threads_usage+0xa2><== NOT EXECUTED
106eba: 66 90 xchg %ax,%ax <== NOT EXECUTED
current,
size
);
if (Stack_check_Initialized == 0) {
(*print_handler)( print_context, "Unavailable\n" );
106ebc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
106ebf: 68 10 01 12 00 push $0x120110 <== NOT EXECUTED
106ec4: ff 35 c8 65 12 00 pushl 0x1265c8 <== NOT EXECUTED
106eca: ff 15 cc 65 12 00 call *0x1265cc <== NOT EXECUTED
106ed0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
}
}
106ed3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
106ed6: 5b pop %ebx <== NOT EXECUTED
106ed7: 5e pop %esi <== NOT EXECUTED
106ed8: 5f pop %edi <== NOT EXECUTED
106ed9: c9 leave <== NOT EXECUTED
106eda: c3 ret <== NOT EXECUTED
106edb: 90 nop <== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
if (!Stack_check_Interrupt_stack.area)
106edc: 8b 0d 34 69 12 00 mov 0x126934,%ecx <== NOT EXECUTED
106ee2: 85 c9 test %ecx,%ecx <== NOT EXECUTED
106ee4: 74 94 je 106e7a <Stack_check_Dump_threads_usage+0xea><== NOT EXECUTED
return;
stack = &Stack_check_Interrupt_stack;
106ee6: be 30 69 12 00 mov $0x126930,%esi <== NOT EXECUTED
the_thread = 0;
current = 0;
106eeb: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
if (!Stack_check_Interrupt_stack.area)
return;
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
106ef2: 31 db xor %ebx,%ebx <== NOT EXECUTED
106ef4: e9 c1 fe ff ff jmp 106dba <Stack_check_Dump_threads_usage+0x2a><== NOT EXECUTED
00106efc <Stack_check_Initialize>:
/*
* Stack_check_Initialize
*/
void Stack_check_Initialize( void )
{
106efc: 55 push %ebp
106efd: 89 e5 mov %esp,%ebp
106eff: 57 push %edi
static uint32_t pattern[ 4 ] = {
0xFEEDF00D, 0x0BAD0D06, /* FEED FOOD to BAD DOG */
0xDEADF00D, 0x600D0D06 /* DEAD FOOD but GOOD DOG */
};
if ( Stack_check_Initialized )
106f00: 8b 15 d0 65 12 00 mov 0x1265d0,%edx
106f06: 85 d2 test %edx,%edx
106f08: 75 5a jne 106f64 <Stack_check_Initialize+0x68>
/*
* Dope the pattern and fill areas
*/
p = Stack_check_Pattern.pattern;
for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {
p[i] = pattern[ i%4 ];
106f0a: c7 05 20 69 12 00 0d movl $0xfeedf00d,0x126920
106f11: f0 ed fe
106f14: c7 05 24 69 12 00 06 movl $0xbad0d06,0x126924
106f1b: 0d ad 0b
106f1e: c7 05 28 69 12 00 0d movl $0xdeadf00d,0x126928
106f25: f0 ad de
106f28: c7 05 2c 69 12 00 06 movl $0x600d0d06,0x12692c
106f2f: 0d 0d 60
/*
* If appropriate, setup the interrupt stack for high water testing
* also.
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {
106f32: 8b 15 2c 6d 12 00 mov 0x126d2c,%edx
106f38: 85 d2 test %edx,%edx
106f3a: 74 1e je 106f5a <Stack_check_Initialize+0x5e><== NEVER TAKEN
106f3c: 8b 0d 30 6d 12 00 mov 0x126d30,%ecx
106f42: 85 c9 test %ecx,%ecx
106f44: 74 14 je 106f5a <Stack_check_Initialize+0x5e><== NEVER TAKEN
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
106f46: 89 15 34 69 12 00 mov %edx,0x126934
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
106f4c: 29 d1 sub %edx,%ecx
106f4e: 89 0d 30 69 12 00 mov %ecx,0x126930
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
106f54: b0 a5 mov $0xa5,%al
106f56: 89 d7 mov %edx,%edi
106f58: f3 aa rep stos %al,%es:(%edi)
}
#endif
Stack_check_Initialized = 1;
106f5a: c7 05 d0 65 12 00 01 movl $0x1,0x1265d0
106f61: 00 00 00
}
106f64: 5f pop %edi
106f65: c9 leave
106f66: c3 ret
00106fb8 <Stack_check_report_blown_task>:
Thread_Control *running,
bool pattern_ok
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
106fb8: 55 push %ebp <== NOT EXECUTED
106fb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106fbb: 56 push %esi <== NOT EXECUTED
106fbc: 53 push %ebx <== NOT EXECUTED
106fbd: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED
106fc0: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
106fc3: 8a 55 0c mov 0xc(%ebp),%dl <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
106fc6: 8b b3 b8 00 00 00 mov 0xb8(%ebx),%esi <== NOT EXECUTED
char name[32];
printk("BLOWN STACK!!!\n");
106fcc: 68 23 01 12 00 push $0x120123 <== NOT EXECUTED
106fd1: 88 55 d4 mov %dl,-0x2c(%ebp) <== NOT EXECUTED
106fd4: e8 8b 18 00 00 call 108864 <printk> <== NOT EXECUTED
printk("task control block: 0x%08" PRIxPTR "\n", running);
106fd9: 5a pop %edx <== NOT EXECUTED
106fda: 59 pop %ecx <== NOT EXECUTED
106fdb: 53 push %ebx <== NOT EXECUTED
106fdc: 68 33 01 12 00 push $0x120133 <== NOT EXECUTED
106fe1: e8 7e 18 00 00 call 108864 <printk> <== NOT EXECUTED
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
106fe6: 59 pop %ecx <== NOT EXECUTED
106fe7: 58 pop %eax <== NOT EXECUTED
106fe8: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
106feb: 68 50 01 12 00 push $0x120150 <== NOT EXECUTED
106ff0: e8 6f 18 00 00 call 108864 <printk> <== NOT EXECUTED
printk(
106ff5: 58 pop %eax <== NOT EXECUTED
106ff6: 5a pop %edx <== NOT EXECUTED
106ff7: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED
106ffa: 68 62 01 12 00 push $0x120162 <== NOT EXECUTED
106fff: e8 60 18 00 00 call 108864 <printk> <== NOT EXECUTED
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
107004: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
107007: 8d 45 d8 lea -0x28(%ebp),%eax <== NOT EXECUTED
10700a: 50 push %eax <== NOT EXECUTED
10700b: 6a 20 push $0x20 <== NOT EXECUTED
10700d: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
107010: e8 4f 3d 00 00 call 10ad64 <rtems_object_get_name> <== NOT EXECUTED
107015: 5a pop %edx <== NOT EXECUTED
107016: 59 pop %ecx <== NOT EXECUTED
107017: 50 push %eax <== NOT EXECUTED
107018: 68 76 01 12 00 push $0x120176 <== NOT EXECUTED
10701d: e8 42 18 00 00 call 108864 <printk> <== NOT EXECUTED
);
printk(
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
107022: 8b 8b b8 00 00 00 mov 0xb8(%ebx),%ecx <== NOT EXECUTED
107028: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax <== NOT EXECUTED
);
printk(
"task name string: %s\n",
rtems_object_get_name(running->Object.id, sizeof(name), name)
);
printk(
10702e: 8d 1c 01 lea (%ecx,%eax,1),%ebx <== NOT EXECUTED
107031: 53 push %ebx <== NOT EXECUTED
107032: 51 push %ecx <== NOT EXECUTED
107033: 50 push %eax <== NOT EXECUTED
107034: 68 a4 01 12 00 push $0x1201a4 <== NOT EXECUTED
107039: e8 26 18 00 00 call 108864 <printk> <== NOT EXECUTED
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
10703e: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
107041: 8a 55 d4 mov -0x2c(%ebp),%dl <== NOT EXECUTED
107044: 84 d2 test %dl,%dl <== NOT EXECUTED
107046: 74 10 je 107058 <Stack_check_report_blown_task+0xa0><== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
107048: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10704b: 68 81 00 00 00 push $0x81 <== NOT EXECUTED
107050: e8 8f 45 00 00 call 10b5e4 <rtems_fatal_error_occurred><== NOT EXECUTED
107055: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
107058: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
printk(
10705b: 83 c6 18 add $0x18,%esi <== NOT EXECUTED
10705e: 56 push %esi <== NOT EXECUTED
10705f: 50 push %eax <== NOT EXECUTED
107060: 6a 10 push $0x10 <== NOT EXECUTED
107062: 68 d8 01 12 00 push $0x1201d8 <== NOT EXECUTED
107067: e8 f8 17 00 00 call 108864 <printk> <== NOT EXECUTED
10706c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10706f: eb d7 jmp 107048 <Stack_check_report_blown_task+0x90><== NOT EXECUTED
0010b348 <_API_extensions_Run_postdriver>:
*
* _API_extensions_Run_postdriver
*/
void _API_extensions_Run_postdriver( void )
{
10b348: 55 push %ebp
10b349: 89 e5 mov %esp,%ebp
10b34b: 53 push %ebx
10b34c: 83 ec 04 sub $0x4,%esp
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10b34f: 8b 1d 18 67 12 00 mov 0x126718,%ebx
void _API_extensions_Run_postdriver( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
10b355: 81 fb 1c 67 12 00 cmp $0x12671c,%ebx
10b35b: 74 10 je 10b36d <_API_extensions_Run_postdriver+0x25><== NEVER TAKEN
10b35d: 8d 76 00 lea 0x0(%esi),%esi
* Currently all APIs configure this hook so it is always non-NULL.
*/
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
if ( the_extension->postdriver_hook )
#endif
(*the_extension->postdriver_hook)();
10b360: ff 53 08 call *0x8(%ebx)
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
10b363: 8b 1b mov (%ebx),%ebx
void _API_extensions_Run_postdriver( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
10b365: 81 fb 1c 67 12 00 cmp $0x12671c,%ebx
10b36b: 75 f3 jne 10b360 <_API_extensions_Run_postdriver+0x18><== NEVER TAKEN
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
if ( the_extension->postdriver_hook )
#endif
(*the_extension->postdriver_hook)();
}
}
10b36d: 58 pop %eax
10b36e: 5b pop %ebx
10b36f: c9 leave
10b370: c3 ret
0010b374 <_API_extensions_Run_postswitch>:
*
* _API_extensions_Run_postswitch
*/
void _API_extensions_Run_postswitch( void )
{
10b374: 55 push %ebp
10b375: 89 e5 mov %esp,%ebp
10b377: 53 push %ebx
10b378: 83 ec 04 sub $0x4,%esp
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10b37b: 8b 1d 18 67 12 00 mov 0x126718,%ebx
void _API_extensions_Run_postswitch( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
10b381: 81 fb 1c 67 12 00 cmp $0x12671c,%ebx
10b387: 74 1c je 10b3a5 <_API_extensions_Run_postswitch+0x31><== NEVER TAKEN
10b389: 8d 76 00 lea 0x0(%esi),%esi
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
10b38c: 83 ec 0c sub $0xc,%esp
10b38f: ff 35 78 67 12 00 pushl 0x126778
10b395: ff 53 0c call *0xc(%ebx)
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
10b398: 8b 1b mov (%ebx),%ebx
void _API_extensions_Run_postswitch( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
10b39a: 83 c4 10 add $0x10,%esp
10b39d: 81 fb 1c 67 12 00 cmp $0x12671c,%ebx
10b3a3: 75 e7 jne 10b38c <_API_extensions_Run_postswitch+0x18><== NEVER TAKEN
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10b3a5: 8b 5d fc mov -0x4(%ebp),%ebx
10b3a8: c9 leave
10b3a9: c3 ret
0010ff0c <_CORE_message_queue_Initialize>:
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
10ff0c: 55 push %ebp
10ff0d: 89 e5 mov %esp,%ebp
10ff0f: 57 push %edi
10ff10: 56 push %esi
10ff11: 53 push %ebx
10ff12: 83 ec 0c sub $0xc,%esp
10ff15: 8b 5d 08 mov 0x8(%ebp),%ebx
10ff18: 8b 75 10 mov 0x10(%ebp),%esi
10ff1b: 8b 45 14 mov 0x14(%ebp),%eax
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
10ff1e: 89 73 44 mov %esi,0x44(%ebx)
the_message_queue->number_of_pending_messages = 0;
10ff21: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
the_message_queue->maximum_message_size = maximum_message_size;
10ff28: 89 43 4c mov %eax,0x4c(%ebx)
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
10ff2b: a8 03 test $0x3,%al
10ff2d: 74 15 je 10ff44 <_CORE_message_queue_Initialize+0x38>
allocated_message_size += sizeof(uint32_t);
10ff2f: 8d 50 04 lea 0x4(%eax),%edx
allocated_message_size &= ~(sizeof(uint32_t) - 1);
10ff32: 83 e2 fc and $0xfffffffc,%edx
}
if (allocated_message_size < maximum_message_size)
10ff35: 39 d0 cmp %edx,%eax
10ff37: 76 0d jbe 10ff46 <_CORE_message_queue_Initialize+0x3a><== ALWAYS TAKEN
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
return false;
10ff39: 31 c0 xor %eax,%eax
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
}
10ff3b: 8d 65 f4 lea -0xc(%ebp),%esp
10ff3e: 5b pop %ebx
10ff3f: 5e pop %esi
10ff40: 5f pop %edi
10ff41: c9 leave
10ff42: c3 ret
10ff43: 90 nop
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
10ff44: 89 c2 mov %eax,%edx
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
10ff46: 8d 7a 10 lea 0x10(%edx),%edi
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
10ff49: 89 f8 mov %edi,%eax
10ff4b: 0f af c6 imul %esi,%eax
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
10ff4e: 39 d0 cmp %edx,%eax
10ff50: 72 e7 jb 10ff39 <_CORE_message_queue_Initialize+0x2d><== NEVER TAKEN
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
10ff52: 83 ec 0c sub $0xc,%esp
10ff55: 50 push %eax
10ff56: e8 15 dd ff ff call 10dc70 <_Workspace_Allocate>
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
10ff5b: 89 43 5c mov %eax,0x5c(%ebx)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
10ff5e: 83 c4 10 add $0x10,%esp
10ff61: 85 c0 test %eax,%eax
10ff63: 74 d4 je 10ff39 <_CORE_message_queue_Initialize+0x2d>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
10ff65: 57 push %edi
10ff66: 56 push %esi
10ff67: 50 push %eax
10ff68: 8d 43 60 lea 0x60(%ebx),%eax
10ff6b: 50 push %eax
10ff6c: e8 bb fe ff ff call 10fe2c <_Chain_Initialize>
Chain_Node *tail = _Chain_Tail( the_chain );
10ff71: 8d 43 54 lea 0x54(%ebx),%eax
10ff74: 89 43 50 mov %eax,0x50(%ebx)
head->next = tail;
head->previous = NULL;
10ff77: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
10ff7e: 8d 43 50 lea 0x50(%ebx),%eax
10ff81: 89 43 58 mov %eax,0x58(%ebx)
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
_Thread_queue_Initialize(
10ff84: 6a 06 push $0x6
10ff86: 68 80 00 00 00 push $0x80
10ff8b: 8b 45 0c mov 0xc(%ebp),%eax
10ff8e: 83 38 01 cmpl $0x1,(%eax)
10ff91: 0f 94 c0 sete %al
10ff94: 0f b6 c0 movzbl %al,%eax
10ff97: 50 push %eax
10ff98: 53 push %ebx
10ff99: e8 3e d4 ff ff call 10d3dc <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
10ff9e: 83 c4 20 add $0x20,%esp
10ffa1: b0 01 mov $0x1,%al
}
10ffa3: 8d 65 f4 lea -0xc(%ebp),%esp
10ffa6: 5b pop %ebx
10ffa7: 5e pop %esi
10ffa8: 5f pop %edi
10ffa9: c9 leave
10ffaa: c3 ret
00111c20 <_CORE_message_queue_Insert_message>:
void _CORE_message_queue_Insert_message(
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Buffer_control *the_message,
CORE_message_queue_Submit_types submit_type
)
{
111c20: 55 push %ebp
111c21: 89 e5 mov %esp,%ebp
111c23: 56 push %esi
111c24: 53 push %ebx
111c25: 8b 45 08 mov 0x8(%ebp),%eax
111c28: 8b 55 0c mov 0xc(%ebp),%edx
#endif
_CORE_message_queue_Set_message_priority( the_message, submit_type );
#if !defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
_ISR_Disable( level );
111c2b: 9c pushf
111c2c: fa cli
111c2d: 5b pop %ebx
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
111c2e: ff 40 48 incl 0x48(%eax)
if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST )
111c31: 81 7d 10 ff ff ff 7f cmpl $0x7fffffff,0x10(%ebp)
111c38: 74 1a je 111c54 <_CORE_message_queue_Insert_message+0x34>
RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert_unprotected(_Chain_Head(the_chain), the_node);
111c3a: 8d 48 50 lea 0x50(%eax),%ecx
111c3d: 89 4a 04 mov %ecx,0x4(%edx)
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
111c40: 8b 48 50 mov 0x50(%eax),%ecx
after_node->next = the_node;
111c43: 89 50 50 mov %edx,0x50(%eax)
the_node->next = before_node;
111c46: 89 0a mov %ecx,(%edx)
before_node->previous = the_node;
111c48: 89 51 04 mov %edx,0x4(%ecx)
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
else
_CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
111c4b: 53 push %ebx
111c4c: 9d popf
* the message is actually in the queue at this point.
*/
if ( notify && the_message_queue->notify_handler )
(*the_message_queue->notify_handler)(the_message_queue->notify_argument);
#endif
}
111c4d: 5b pop %ebx
111c4e: 5e pop %esi
111c4f: c9 leave
111c50: c3 ret
111c51: 8d 76 00 lea 0x0(%esi),%esi
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
111c54: 8b 48 58 mov 0x58(%eax),%ecx
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
111c57: 8d 70 54 lea 0x54(%eax),%esi
111c5a: 89 32 mov %esi,(%edx)
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
111c5c: 89 50 58 mov %edx,0x58(%eax)
old_last->next = the_node;
111c5f: 89 11 mov %edx,(%ecx)
the_node->previous = old_last;
111c61: 89 4a 04 mov %ecx,0x4(%edx)
111c64: eb e5 jmp 111c4b <_CORE_message_queue_Insert_message+0x2b>
00110084 <_CORE_message_queue_Submit>:
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
110084: 55 push %ebp
110085: 89 e5 mov %esp,%ebp
110087: 57 push %edi
110088: 56 push %esi
110089: 53 push %ebx
11008a: 83 ec 0c sub $0xc,%esp
11008d: 8b 5d 08 mov 0x8(%ebp),%ebx
110090: 8b 75 0c mov 0xc(%ebp),%esi
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
110093: 8b 45 10 mov 0x10(%ebp),%eax
110096: 39 43 4c cmp %eax,0x4c(%ebx)
110099: 72 51 jb 1100ec <_CORE_message_queue_Submit+0x68>
}
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
11009b: 8b 43 48 mov 0x48(%ebx),%eax
11009e: 85 c0 test %eax,%eax
1100a0: 74 5a je 1100fc <_CORE_message_queue_Submit+0x78>
/*
* No one waiting on the message queue at this time, so attempt to
* queue the message up for a future receive.
*/
if ( the_message_queue->number_of_pending_messages <
1100a2: 39 43 44 cmp %eax,0x44(%ebx)
1100a5: 77 0d ja 1100b4 <_CORE_message_queue_Submit+0x30>
);
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
#if !defined(RTEMS_SCORE_COREMSG_ENABLE_BLOCKING_SEND)
return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY;
1100a7: b8 02 00 00 00 mov $0x2,%eax
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
#endif
}
1100ac: 8d 65 f4 lea -0xc(%ebp),%esp
1100af: 5b pop %ebx
1100b0: 5e pop %esi
1100b1: 5f pop %edi
1100b2: c9 leave
1100b3: c3 ret
_CORE_message_queue_Allocate_message_buffer (
CORE_message_queue_Control *the_message_queue
)
{
return (CORE_message_queue_Buffer_control *)
_Chain_Get( &the_message_queue->Inactive_messages );
1100b4: 83 ec 0c sub $0xc,%esp
1100b7: 8d 43 60 lea 0x60(%ebx),%eax
1100ba: 50 push %eax
1100bb: e8 00 b4 ff ff call 10b4c0 <_Chain_Get>
1100c0: 89 c2 mov %eax,%edx
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED;
#endif
_CORE_message_queue_Copy_buffer(
buffer,
the_message->Contents.buffer,
1100c2: 8d 40 0c lea 0xc(%eax),%eax
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
1100c5: 89 c7 mov %eax,%edi
1100c7: 8b 4d 10 mov 0x10(%ebp),%ecx
1100ca: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
size
);
the_message->Contents.size = size;
1100cc: 8b 4d 10 mov 0x10(%ebp),%ecx
1100cf: 89 4a 08 mov %ecx,0x8(%edx)
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
1100d2: 83 c4 0c add $0xc,%esp
1100d5: ff 75 1c pushl 0x1c(%ebp)
1100d8: 52 push %edx
1100d9: 53 push %ebx
1100da: e8 41 1b 00 00 call 111c20 <_CORE_message_queue_Insert_message>
the_message_queue,
the_message,
submit_type
);
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
1100df: 83 c4 10 add $0x10,%esp
1100e2: 31 c0 xor %eax,%eax
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
#endif
}
1100e4: 8d 65 f4 lea -0xc(%ebp),%esp
1100e7: 5b pop %ebx
1100e8: 5e pop %esi
1100e9: 5f pop %edi
1100ea: c9 leave
1100eb: c3 ret
{
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
1100ec: b8 01 00 00 00 mov $0x1,%eax
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
#endif
}
1100f1: 8d 65 f4 lea -0xc(%ebp),%esp
1100f4: 5b pop %ebx
1100f5: 5e pop %esi
1100f6: 5f pop %edi
1100f7: c9 leave
1100f8: c3 ret
1100f9: 8d 76 00 lea 0x0(%esi),%esi
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
1100fc: 83 ec 0c sub $0xc,%esp
1100ff: 53 push %ebx
110100: e8 47 cf ff ff call 10d04c <_Thread_queue_Dequeue>
110105: 89 c2 mov %eax,%edx
if ( the_thread ) {
110107: 83 c4 10 add $0x10,%esp
11010a: 85 c0 test %eax,%eax
11010c: 74 1e je 11012c <_CORE_message_queue_Submit+0xa8>
11010e: 8b 40 2c mov 0x2c(%eax),%eax
110111: 89 c7 mov %eax,%edi
110113: 8b 4d 10 mov 0x10(%ebp),%ecx
110116: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
_CORE_message_queue_Copy_buffer(
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
110118: 8b 42 28 mov 0x28(%edx),%eax
11011b: 8b 4d 10 mov 0x10(%ebp),%ecx
11011e: 89 08 mov %ecx,(%eax)
the_thread->Wait.count = (uint32_t) submit_type;
110120: 8b 45 1c mov 0x1c(%ebp),%eax
110123: 89 42 24 mov %eax,0x24(%edx)
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
110126: 31 c0 xor %eax,%eax
110128: eb 82 jmp 1100ac <_CORE_message_queue_Submit+0x28>
11012a: 66 90 xchg %ax,%ax
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
if ( the_thread ) {
11012c: 8b 43 48 mov 0x48(%ebx),%eax
11012f: e9 6e ff ff ff jmp 1100a2 <_CORE_message_queue_Submit+0x1e>
0010b4f0 <_CORE_mutex_Initialize>:
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
10b4f0: 55 push %ebp
10b4f1: 89 e5 mov %esp,%ebp
10b4f3: 57 push %edi
10b4f4: 56 push %esi
10b4f5: 53 push %ebx
10b4f6: 83 ec 0c sub $0xc,%esp
10b4f9: 8b 45 08 mov 0x8(%ebp),%eax
10b4fc: 8b 5d 0c mov 0xc(%ebp),%ebx
10b4ff: 8b 55 10 mov 0x10(%ebp),%edx
/* Add this to the RTEMS environment later ?????????
rtems_assert( initial_lock == CORE_MUTEX_LOCKED ||
initial_lock == CORE_MUTEX_UNLOCKED );
*/
the_mutex->Attributes = *the_mutex_attributes;
10b502: 8d 78 40 lea 0x40(%eax),%edi
10b505: b9 04 00 00 00 mov $0x4,%ecx
10b50a: 89 de mov %ebx,%esi
10b50c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_mutex->lock = initial_lock;
10b50e: 89 50 50 mov %edx,0x50(%eax)
the_mutex->blocked_count = 0;
10b511: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
if ( initial_lock == CORE_MUTEX_LOCKED ) {
10b518: 85 d2 test %edx,%edx
10b51a: 75 30 jne 10b54c <_CORE_mutex_Initialize+0x5c>
the_mutex->nest_count = 1;
10b51c: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax)
the_mutex->holder = _Thread_Executing;
10b523: 8b 15 78 67 12 00 mov 0x126778,%edx
10b529: 89 50 5c mov %edx,0x5c(%eax)
the_mutex->holder_id = _Thread_Executing->Object.id;
10b52c: 8b 4a 08 mov 0x8(%edx),%ecx
10b52f: 89 48 60 mov %ecx,0x60(%eax)
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10b532: 8b 48 48 mov 0x48(%eax),%ecx
if ( initial_lock == CORE_MUTEX_LOCKED ) {
the_mutex->nest_count = 1;
the_mutex->holder = _Thread_Executing;
the_mutex->holder_id = _Thread_Executing->Object.id;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
10b535: 83 f9 02 cmp $0x2,%ecx
10b538: 74 05 je 10b53f <_CORE_mutex_Initialize+0x4f>
10b53a: 83 f9 03 cmp $0x3,%ecx
10b53d: 75 22 jne 10b561 <_CORE_mutex_Initialize+0x71>
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
10b53f: 8b 48 4c mov 0x4c(%eax),%ecx
10b542: 39 4a 14 cmp %ecx,0x14(%edx)
10b545: 72 41 jb 10b588 <_CORE_mutex_Initialize+0x98>
_Chain_Prepend_unprotected( &_Thread_Executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = _Thread_Executing->current_priority;
#endif
_Thread_Executing->resource_count++;
10b547: ff 42 1c incl 0x1c(%edx)
10b54a: eb 15 jmp 10b561 <_CORE_mutex_Initialize+0x71>
}
} else {
the_mutex->nest_count = 0;
10b54c: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
the_mutex->holder = NULL;
10b553: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
the_mutex->holder_id = 0;
10b55a: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
}
_Thread_queue_Initialize(
10b561: 6a 04 push $0x4
10b563: 68 00 04 00 00 push $0x400
10b568: 31 d2 xor %edx,%edx
10b56a: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10b56e: 0f 95 c2 setne %dl
10b571: 52 push %edx
10b572: 50 push %eax
10b573: e8 64 1e 00 00 call 10d3dc <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_FIFO : THREAD_QUEUE_DISCIPLINE_PRIORITY,
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
10b578: 83 c4 10 add $0x10,%esp
10b57b: 31 c0 xor %eax,%eax
}
10b57d: 8d 65 f4 lea -0xc(%ebp),%esp
10b580: 5b pop %ebx
10b581: 5e pop %esi
10b582: 5f pop %edi
10b583: c9 leave
10b584: c3 ret
10b585: 8d 76 00 lea 0x0(%esi),%esi
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
the_mutex->Attributes.priority_ceiling )
return CORE_MUTEX_STATUS_CEILING_VIOLATED;
10b588: b8 05 00 00 00 mov $0x5,%eax
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10b58d: 8d 65 f4 lea -0xc(%ebp),%esp
10b590: 5b pop %ebx
10b591: 5e pop %esi
10b592: 5f pop %edi
10b593: c9 leave
10b594: c3 ret
0010b5e8 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
10b5e8: 55 push %ebp
10b5e9: 89 e5 mov %esp,%ebp
10b5eb: 53 push %ebx
10b5ec: 83 ec 14 sub $0x14,%esp
10b5ef: 8b 5d 08 mov 0x8(%ebp),%ebx
10b5f2: 8a 55 10 mov 0x10(%ebp),%dl
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10b5f5: a1 ec 64 12 00 mov 0x1264ec,%eax
10b5fa: 85 c0 test %eax,%eax
10b5fc: 74 04 je 10b602 <_CORE_mutex_Seize+0x1a>
10b5fe: 84 d2 test %dl,%dl
10b600: 75 36 jne 10b638 <_CORE_mutex_Seize+0x50><== ALWAYS TAKEN
10b602: 83 ec 08 sub $0x8,%esp
10b605: 8d 45 18 lea 0x18(%ebp),%eax
10b608: 50 push %eax
10b609: 53 push %ebx
10b60a: 88 55 f4 mov %dl,-0xc(%ebp)
10b60d: e8 22 4b 00 00 call 110134 <_CORE_mutex_Seize_interrupt_trylock>
10b612: 83 c4 10 add $0x10,%esp
10b615: 85 c0 test %eax,%eax
10b617: 8a 55 f4 mov -0xc(%ebp),%dl
10b61a: 74 14 je 10b630 <_CORE_mutex_Seize+0x48>
10b61c: 84 d2 test %dl,%dl
10b61e: 75 30 jne 10b650 <_CORE_mutex_Seize+0x68>
10b620: ff 75 18 pushl 0x18(%ebp)
10b623: 9d popf
10b624: a1 78 67 12 00 mov 0x126778,%eax
10b629: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax)
}
10b630: 8b 5d fc mov -0x4(%ebp),%ebx
10b633: c9 leave
10b634: c3 ret
10b635: 8d 76 00 lea 0x0(%esi),%esi
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10b638: 83 3d 80 66 12 00 01 cmpl $0x1,0x126680
10b63f: 76 c1 jbe 10b602 <_CORE_mutex_Seize+0x1a>
10b641: 53 push %ebx
10b642: 6a 12 push $0x12
10b644: 6a 00 push $0x0
10b646: 6a 00 push $0x0
10b648: e8 1b 06 00 00 call 10bc68 <_Internal_error_Occurred>
10b64d: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10b650: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx)
10b657: a1 78 67 12 00 mov 0x126778,%eax
10b65c: 89 58 44 mov %ebx,0x44(%eax)
10b65f: 8b 55 0c mov 0xc(%ebp),%edx
10b662: 89 50 20 mov %edx,0x20(%eax)
10b665: a1 ec 64 12 00 mov 0x1264ec,%eax
10b66a: 40 inc %eax
10b66b: a3 ec 64 12 00 mov %eax,0x1264ec
10b670: ff 75 18 pushl 0x18(%ebp)
10b673: 9d popf
10b674: 83 ec 08 sub $0x8,%esp
10b677: ff 75 14 pushl 0x14(%ebp)
10b67a: 53 push %ebx
10b67b: e8 18 ff ff ff call 10b598 <_CORE_mutex_Seize_interrupt_blocking>
10b680: 83 c4 10 add $0x10,%esp
}
10b683: 8b 5d fc mov -0x4(%ebp),%ebx
10b686: c9 leave
10b687: c3 ret
00110134 <_CORE_mutex_Seize_interrupt_trylock>:
#if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__)
int _CORE_mutex_Seize_interrupt_trylock(
CORE_mutex_Control *the_mutex,
ISR_Level *level_p
)
{
110134: 55 push %ebp
110135: 89 e5 mov %esp,%ebp
110137: 56 push %esi
110138: 53 push %ebx
110139: 8b 45 08 mov 0x8(%ebp),%eax
11013c: 8b 4d 0c mov 0xc(%ebp),%ecx
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
11013f: 8b 15 78 67 12 00 mov 0x126778,%edx
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
110145: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
11014c: 8b 58 50 mov 0x50(%eax),%ebx
11014f: 85 db test %ebx,%ebx
110151: 74 31 je 110184 <_CORE_mutex_Seize_interrupt_trylock+0x50>
the_mutex->lock = CORE_MUTEX_LOCKED;
110153: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
the_mutex->holder = executing;
11015a: 89 50 5c mov %edx,0x5c(%eax)
the_mutex->holder_id = executing->Object.id;
11015d: 8b 5a 08 mov 0x8(%edx),%ebx
110160: 89 58 60 mov %ebx,0x60(%eax)
the_mutex->nest_count = 1;
110163: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax)
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}
11016a: 8b 58 48 mov 0x48(%eax),%ebx
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
11016d: 83 fb 02 cmp $0x2,%ebx
110170: 74 26 je 110198 <_CORE_mutex_Seize_interrupt_trylock+0x64>
110172: 83 fb 03 cmp $0x3,%ebx
110175: 74 3d je 1101b4 <_CORE_mutex_Seize_interrupt_trylock+0x80>
executing->resource_count++;
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
_ISR_Enable( *level_p );
110177: ff 31 pushl (%ecx)
110179: 9d popf
return 0;
11017a: 31 c0 xor %eax,%eax
11017c: 8d 65 f8 lea -0x8(%ebp),%esp
11017f: 5b pop %ebx
110180: 5e pop %esi
110181: c9 leave
110182: c3 ret
110183: 90 nop
/*
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
110184: 3b 50 5c cmp 0x5c(%eax),%edx
110187: 74 17 je 1101a0 <_CORE_mutex_Seize_interrupt_trylock+0x6c>
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
110189: b8 01 00 00 00 mov $0x1,%eax
11018e: 8d 65 f8 lea -0x8(%ebp),%esp
110191: 5b pop %ebx
110192: 5e pop %esi
110193: c9 leave
110194: c3 ret
110195: 8d 76 00 lea 0x0(%esi),%esi
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
110198: ff 42 1c incl 0x1c(%edx)
11019b: eb da jmp 110177 <_CORE_mutex_Seize_interrupt_trylock+0x43>
11019d: 8d 76 00 lea 0x0(%esi),%esi
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
1101a0: 8b 50 40 mov 0x40(%eax),%edx
1101a3: 85 d2 test %edx,%edx
1101a5: 75 e2 jne 110189 <_CORE_mutex_Seize_interrupt_trylock+0x55>
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
1101a7: ff 40 54 incl 0x54(%eax)
_ISR_Enable( *level_p );
1101aa: ff 31 pushl (%ecx)
1101ac: 9d popf
return 0;
1101ad: 31 c0 xor %eax,%eax
1101af: eb dd jmp 11018e <_CORE_mutex_Seize_interrupt_trylock+0x5a>
1101b1: 8d 76 00 lea 0x0(%esi),%esi
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
1101b4: 8b 5a 1c mov 0x1c(%edx),%ebx
1101b7: 8d 73 01 lea 0x1(%ebx),%esi
1101ba: 89 72 1c mov %esi,0x1c(%edx)
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
current = executing->current_priority;
if ( current == ceiling ) {
1101bd: 8b 72 14 mov 0x14(%edx),%esi
1101c0: 39 70 4c cmp %esi,0x4c(%eax)
1101c3: 74 57 je 11021c <_CORE_mutex_Seize_interrupt_trylock+0xe8>
_ISR_Enable( *level_p );
return 0;
}
if ( current > ceiling ) {
1101c5: 72 25 jb 1101ec <_CORE_mutex_Seize_interrupt_trylock+0xb8>
);
_Thread_Enable_dispatch();
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
1101c7: c7 42 34 05 00 00 00 movl $0x5,0x34(%edx)
the_mutex->lock = CORE_MUTEX_UNLOCKED;
1101ce: c7 40 50 01 00 00 00 movl $0x1,0x50(%eax)
the_mutex->nest_count = 0; /* undo locking above */
1101d5: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
executing->resource_count--; /* undo locking above */
1101dc: 89 5a 1c mov %ebx,0x1c(%edx)
_ISR_Enable( *level_p );
1101df: ff 31 pushl (%ecx)
1101e1: 9d popf
return 0;
1101e2: 31 c0 xor %eax,%eax
1101e4: 8d 65 f8 lea -0x8(%ebp),%esp
1101e7: 5b pop %ebx
1101e8: 5e pop %esi
1101e9: c9 leave
1101ea: c3 ret
1101eb: 90 nop
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
1101ec: 8b 15 ec 64 12 00 mov 0x1264ec,%edx
1101f2: 42 inc %edx
1101f3: 89 15 ec 64 12 00 mov %edx,0x1264ec
return 0;
}
if ( current > ceiling ) {
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
1101f9: ff 31 pushl (%ecx)
1101fb: 9d popf
_Thread_Change_priority(
1101fc: 51 push %ecx
1101fd: 6a 00 push $0x0
1101ff: ff 70 4c pushl 0x4c(%eax)
110202: ff 70 5c pushl 0x5c(%eax)
110205: e8 ba c6 ff ff call 10c8c4 <_Thread_Change_priority>
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
11020a: e8 ed ca ff ff call 10ccfc <_Thread_Enable_dispatch>
11020f: 83 c4 10 add $0x10,%esp
return 0;
110212: 31 c0 xor %eax,%eax
110214: e9 75 ff ff ff jmp 11018e <_CORE_mutex_Seize_interrupt_trylock+0x5a>
110219: 8d 76 00 lea 0x0(%esi),%esi
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
current = executing->current_priority;
if ( current == ceiling ) {
_ISR_Enable( *level_p );
11021c: ff 31 pushl (%ecx)
11021e: 9d popf
return 0;
11021f: 31 c0 xor %eax,%eax
110221: e9 68 ff ff ff jmp 11018e <_CORE_mutex_Seize_interrupt_trylock+0x5a>
0010b688 <_CORE_mutex_Surrender>:
#else
Objects_Id id __attribute__((unused)),
CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused))
#endif
)
{
10b688: 55 push %ebp
10b689: 89 e5 mov %esp,%ebp
10b68b: 53 push %ebx
10b68c: 83 ec 04 sub $0x4,%esp
10b68f: 8b 5d 08 mov 0x8(%ebp),%ebx
Thread_Control *the_thread;
Thread_Control *holder;
holder = the_mutex->holder;
10b692: 8b 43 5c mov 0x5c(%ebx),%eax
* allowed when the mutex in quetion is FIFO or simple Priority
* discipline. But Priority Ceiling or Priority Inheritance mutexes
* must be released by the thread which acquired them.
*/
if ( the_mutex->Attributes.only_owner_release ) {
10b695: 80 7b 44 00 cmpb $0x0,0x44(%ebx)
10b699: 74 15 je 10b6b0 <_CORE_mutex_Surrender+0x28>
if ( !_Thread_Is_executing( holder ) )
10b69b: 3b 05 78 67 12 00 cmp 0x126778,%eax
10b6a1: 74 0d je 10b6b0 <_CORE_mutex_Surrender+0x28>
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
10b6a3: b8 02 00 00 00 mov $0x2,%eax
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10b6a8: 8b 5d fc mov -0x4(%ebp),%ebx
10b6ab: c9 leave
10b6ac: c3 ret
10b6ad: 8d 76 00 lea 0x0(%esi),%esi
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
}
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
10b6b0: 8b 53 54 mov 0x54(%ebx),%edx
10b6b3: 85 d2 test %edx,%edx
10b6b5: 74 51 je 10b708 <_CORE_mutex_Surrender+0x80>
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
10b6b7: 4a dec %edx
10b6b8: 89 53 54 mov %edx,0x54(%ebx)
if ( the_mutex->nest_count != 0 ) {
10b6bb: 85 d2 test %edx,%edx
10b6bd: 75 49 jne 10b708 <_CORE_mutex_Surrender+0x80>
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10b6bf: 8b 53 48 mov 0x48(%ebx),%edx
/*
* Formally release the mutex before possibly transferring it to a
* blocked thread.
*/
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
10b6c2: 83 fa 02 cmp $0x2,%edx
10b6c5: 74 69 je 10b730 <_CORE_mutex_Surrender+0xa8>
10b6c7: 83 fa 03 cmp $0x3,%edx
10b6ca: 74 64 je 10b730 <_CORE_mutex_Surrender+0xa8>
if ( holder->resource_count == 0 &&
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, true );
}
}
the_mutex->holder = NULL;
10b6cc: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
the_mutex->holder_id = 0;
10b6d3: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
/*
* Now we check if another thread was waiting for this mutex. If so,
* transfer the mutex to that thread.
*/
if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) {
10b6da: 83 ec 0c sub $0xc,%esp
10b6dd: 53 push %ebx
10b6de: e8 69 19 00 00 call 10d04c <_Thread_queue_Dequeue>
10b6e3: 83 c4 10 add $0x10,%esp
10b6e6: 85 c0 test %eax,%eax
10b6e8: 74 7a je 10b764 <_CORE_mutex_Surrender+0xdc>
} else
#endif
{
the_mutex->holder = the_thread;
10b6ea: 89 43 5c mov %eax,0x5c(%ebx)
the_mutex->holder_id = the_thread->Object.id;
10b6ed: 8b 50 08 mov 0x8(%eax),%edx
10b6f0: 89 53 60 mov %edx,0x60(%ebx)
the_mutex->nest_count = 1;
10b6f3: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx)
switch ( the_mutex->Attributes.discipline ) {
10b6fa: 8b 53 48 mov 0x48(%ebx),%edx
10b6fd: 83 fa 02 cmp $0x2,%edx
10b700: 74 56 je 10b758 <_CORE_mutex_Surrender+0xd0>
10b702: 83 fa 03 cmp $0x3,%edx
10b705: 74 09 je 10b710 <_CORE_mutex_Surrender+0x88>
10b707: 90 nop
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
10b708: 31 c0 xor %eax,%eax
}
10b70a: 8b 5d fc mov -0x4(%ebp),%ebx
10b70d: c9 leave
10b70e: c3 ret
10b70f: 90 nop
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
10b710: ff 40 1c incl 0x1c(%eax)
if (the_mutex->Attributes.priority_ceiling <
10b713: 8b 53 4c mov 0x4c(%ebx),%edx
10b716: 3b 50 14 cmp 0x14(%eax),%edx
10b719: 73 ed jae 10b708 <_CORE_mutex_Surrender+0x80>
the_thread->current_priority){
_Thread_Change_priority(
10b71b: 51 push %ecx
10b71c: 6a 00 push $0x0
10b71e: 52 push %edx
10b71f: 50 push %eax
10b720: e8 9f 11 00 00 call 10c8c4 <_Thread_Change_priority>
10b725: 83 c4 10 add $0x10,%esp
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
10b728: 31 c0 xor %eax,%eax
10b72a: e9 79 ff ff ff jmp 10b6a8 <_CORE_mutex_Surrender+0x20>
10b72f: 90 nop
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
10b730: 8b 50 1c mov 0x1c(%eax),%edx
10b733: 4a dec %edx
10b734: 89 50 1c mov %edx,0x1c(%eax)
/*
* Whether or not someone is waiting for the mutex, an
* inherited priority must be lowered if this is the last
* mutex (i.e. resource) this task has.
*/
if ( holder->resource_count == 0 &&
10b737: 85 d2 test %edx,%edx
10b739: 75 91 jne 10b6cc <_CORE_mutex_Surrender+0x44>
holder->real_priority != holder->current_priority ) {
10b73b: 8b 50 18 mov 0x18(%eax),%edx
/*
* Whether or not someone is waiting for the mutex, an
* inherited priority must be lowered if this is the last
* mutex (i.e. resource) this task has.
*/
if ( holder->resource_count == 0 &&
10b73e: 3b 50 14 cmp 0x14(%eax),%edx
10b741: 74 89 je 10b6cc <_CORE_mutex_Surrender+0x44>
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, true );
10b743: 51 push %ecx
10b744: 6a 01 push $0x1
10b746: 52 push %edx
10b747: 50 push %eax
10b748: e8 77 11 00 00 call 10c8c4 <_Thread_Change_priority>
10b74d: 83 c4 10 add $0x10,%esp
10b750: e9 77 ff ff ff jmp 10b6cc <_CORE_mutex_Surrender+0x44>
10b755: 8d 76 00 lea 0x0(%esi),%esi
case CORE_MUTEX_DISCIPLINES_FIFO:
case CORE_MUTEX_DISCIPLINES_PRIORITY:
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
10b758: ff 40 1c incl 0x1c(%eax)
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
10b75b: 31 c0 xor %eax,%eax
case CORE_MUTEX_DISCIPLINES_PRIORITY:
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
break;
10b75d: e9 46 ff ff ff jmp 10b6a8 <_CORE_mutex_Surrender+0x20>
10b762: 66 90 xchg %ax,%ax
}
break;
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
10b764: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx)
return CORE_MUTEX_STATUS_SUCCESSFUL;
10b76b: 31 c0 xor %eax,%eax
10b76d: e9 36 ff ff ff jmp 10b6a8 <_CORE_mutex_Surrender+0x20>
0010b7c0 <_CORE_semaphore_Surrender>:
CORE_semaphore_Status _CORE_semaphore_Surrender(
CORE_semaphore_Control *the_semaphore,
Objects_Id id,
CORE_semaphore_API_mp_support_callout api_semaphore_mp_support
)
{
10b7c0: 55 push %ebp
10b7c1: 89 e5 mov %esp,%ebp
10b7c3: 53 push %ebx
10b7c4: 83 ec 10 sub $0x10,%esp
10b7c7: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
10b7ca: 53 push %ebx
10b7cb: e8 7c 18 00 00 call 10d04c <_Thread_queue_Dequeue>
10b7d0: 83 c4 10 add $0x10,%esp
10b7d3: 85 c0 test %eax,%eax
10b7d5: 74 09 je 10b7e0 <_CORE_semaphore_Surrender+0x20>
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10b7d7: 31 c0 xor %eax,%eax
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
10b7d9: 8b 5d fc mov -0x4(%ebp),%ebx
10b7dc: c9 leave
10b7dd: c3 ret
10b7de: 66 90 xchg %ax,%ax
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
10b7e0: 9c pushf
10b7e1: fa cli
10b7e2: 5a pop %edx
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
10b7e3: 8b 43 48 mov 0x48(%ebx),%eax
10b7e6: 3b 43 40 cmp 0x40(%ebx),%eax
10b7e9: 72 0d jb 10b7f8 <_CORE_semaphore_Surrender+0x38><== ALWAYS TAKEN
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
10b7eb: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED
_ISR_Enable( level );
10b7f0: 52 push %edx
10b7f1: 9d popf
}
return status;
}
10b7f2: 8b 5d fc mov -0x4(%ebp),%ebx
10b7f5: c9 leave
10b7f6: c3 ret
10b7f7: 90 nop
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
10b7f8: 40 inc %eax
10b7f9: 89 43 48 mov %eax,0x48(%ebx)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10b7fc: 31 c0 xor %eax,%eax
10b7fe: eb f0 jmp 10b7f0 <_CORE_semaphore_Surrender+0x30>
0010bc28 <_Chain_Get_with_empty_check>:
bool _Chain_Get_with_empty_check(
Chain_Control *chain,
Chain_Node **node
)
{
10bc28: 55 push %ebp
10bc29: 89 e5 mov %esp,%ebp
10bc2b: 57 push %edi
10bc2c: 56 push %esi
10bc2d: 53 push %ebx
10bc2e: 8b 45 08 mov 0x8(%ebp),%eax
10bc31: 8b 7d 0c mov 0xc(%ebp),%edi
ISR_Level level;
bool is_empty_now;
_ISR_Disable( level );
10bc34: 9c pushf
10bc35: fa cli
10bc36: 5e pop %esi
Chain_Node **the_node
)
{
bool is_empty_now = true;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
10bc37: 8d 58 04 lea 0x4(%eax),%ebx
Chain_Node *old_first = head->next;
10bc3a: 8b 10 mov (%eax),%edx
if ( old_first != tail ) {
10bc3c: 39 d3 cmp %edx,%ebx
10bc3e: 74 18 je 10bc58 <_Chain_Get_with_empty_check+0x30>
Chain_Node *new_first = old_first->next;
10bc40: 8b 0a mov (%edx),%ecx
head->next = new_first;
10bc42: 89 08 mov %ecx,(%eax)
new_first->previous = head;
10bc44: 89 41 04 mov %eax,0x4(%ecx)
*the_node = old_first;
10bc47: 89 17 mov %edx,(%edi)
is_empty_now = new_first == tail;
10bc49: 39 cb cmp %ecx,%ebx
10bc4b: 0f 94 c0 sete %al
is_empty_now = _Chain_Get_with_empty_check_unprotected( chain, node );
_ISR_Enable( level );
10bc4e: 56 push %esi
10bc4f: 9d popf
return is_empty_now;
}
10bc50: 5b pop %ebx
10bc51: 5e pop %esi
10bc52: 5f pop %edi
10bc53: c9 leave
10bc54: c3 ret
10bc55: 8d 76 00 lea 0x0(%esi),%esi
} else
*the_node = NULL;
10bc58: c7 07 00 00 00 00 movl $0x0,(%edi)
RTEMS_INLINE_ROUTINE bool _Chain_Get_with_empty_check_unprotected(
Chain_Control *the_chain,
Chain_Node **the_node
)
{
bool is_empty_now = true;
10bc5e: b0 01 mov $0x1,%al
10bc60: eb ec jmp 10bc4e <_Chain_Get_with_empty_check+0x26>
0010fe2c <_Chain_Initialize>:
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
10fe2c: 55 push %ebp
10fe2d: 89 e5 mov %esp,%ebp
10fe2f: 57 push %edi
10fe30: 56 push %esi
10fe31: 53 push %ebx
10fe32: 83 ec 08 sub $0x8,%esp
10fe35: 8b 7d 08 mov 0x8(%ebp),%edi
10fe38: 8b 4d 10 mov 0x10(%ebp),%ecx
10fe3b: 8b 75 14 mov 0x14(%ebp),%esi
size_t count = number_nodes;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
10fe3e: 8d 47 04 lea 0x4(%edi),%eax
10fe41: 89 45 f0 mov %eax,-0x10(%ebp)
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
10fe44: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
while ( count-- ) {
10fe4b: 85 c9 test %ecx,%ecx
10fe4d: 74 35 je 10fe84 <_Chain_Initialize+0x58><== NEVER TAKEN
10fe4f: 49 dec %ecx
10fe50: 89 4d ec mov %ecx,-0x14(%ebp)
{
size_t count = number_nodes;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *current = head;
Chain_Node *next = starting_address;
10fe53: 8b 45 0c mov 0xc(%ebp),%eax
)
{
size_t count = number_nodes;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *current = head;
10fe56: 89 fa mov %edi,%edx
10fe58: eb 07 jmp 10fe61 <_Chain_Initialize+0x35>
10fe5a: 66 90 xchg %ax,%ax
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
10fe5c: 89 c2 mov %eax,%edx
current->next = next;
next->previous = current;
current = next;
next = (Chain_Node *)
10fe5e: 89 d8 mov %ebx,%eax
10fe60: 49 dec %ecx
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
current->next = next;
10fe61: 89 02 mov %eax,(%edx)
next->previous = current;
10fe63: 89 50 04 mov %edx,0x4(%eax)
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _Chain_Initialize(
10fe66: 8d 1c 30 lea (%eax,%esi,1),%ebx
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
10fe69: 85 c9 test %ecx,%ecx
10fe6b: 75 ef jne 10fe5c <_Chain_Initialize+0x30>
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _Chain_Initialize(
10fe6d: 0f af 75 ec imul -0x14(%ebp),%esi
10fe71: 03 75 0c add 0xc(%ebp),%esi
current = next;
next = (Chain_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
current->next = tail;
10fe74: 8b 45 f0 mov -0x10(%ebp),%eax
10fe77: 89 06 mov %eax,(%esi)
tail->previous = current;
10fe79: 89 77 08 mov %esi,0x8(%edi)
}
10fe7c: 83 c4 08 add $0x8,%esp
10fe7f: 5b pop %ebx
10fe80: 5e pop %esi
10fe81: 5f pop %edi
10fe82: c9 leave
10fe83: c3 ret
)
{
size_t count = number_nodes;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *current = head;
10fe84: 89 fe mov %edi,%esi <== NOT EXECUTED
10fe86: eb ec jmp 10fe74 <_Chain_Initialize+0x48><== NOT EXECUTED
0010a618 <_Event_Seize>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
10a618: 55 push %ebp
10a619: 89 e5 mov %esp,%ebp
10a61b: 57 push %edi
10a61c: 56 push %esi
10a61d: 53 push %ebx
10a61e: 83 ec 2c sub $0x2c,%esp
10a621: 8b 45 08 mov 0x8(%ebp),%eax
10a624: 8b 4d 0c mov 0xc(%ebp),%ecx
10a627: 8b 55 10 mov 0x10(%ebp),%edx
10a62a: 89 55 dc mov %edx,-0x24(%ebp)
10a62d: 8b 7d 14 mov 0x14(%ebp),%edi
rtems_event_set pending_events;
ISR_Level level;
RTEMS_API_Control *api;
Thread_blocking_operation_States sync_state;
executing = _Thread_Executing;
10a630: 8b 1d 78 67 12 00 mov 0x126778,%ebx
executing->Wait.return_code = RTEMS_SUCCESSFUL;
10a636: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx)
api = executing->API_Extensions[ THREAD_API_RTEMS ];
10a63d: 8b b3 e4 00 00 00 mov 0xe4(%ebx),%esi
_ISR_Disable( level );
10a643: 9c pushf
10a644: fa cli
10a645: 8f 45 e0 popl -0x20(%ebp)
pending_events = api->pending_events;
10a648: 8b 16 mov (%esi),%edx
10a64a: 89 55 d4 mov %edx,-0x2c(%ebp)
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
10a64d: 21 c2 and %eax,%edx
10a64f: 89 55 e4 mov %edx,-0x1c(%ebp)
10a652: 74 0d je 10a661 <_Event_Seize+0x49>
10a654: 39 d0 cmp %edx,%eax
10a656: 0f 84 84 00 00 00 je 10a6e0 <_Event_Seize+0xc8>
(seized_events == event_in || _Options_Is_any( option_set )) ) {
10a65c: f6 c1 02 test $0x2,%cl
10a65f: 75 7f jne 10a6e0 <_Event_Seize+0xc8>
_ISR_Enable( level );
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
10a661: f6 c1 01 test $0x1,%cl
10a664: 75 62 jne 10a6c8 <_Event_Seize+0xb0>
* set properly when we are marked as in the event critical section.
*
* NOTE: Since interrupts are disabled, this isn't that much of an
* issue but better safe than sorry.
*/
executing->Wait.option = (uint32_t) option_set;
10a666: 89 4b 30 mov %ecx,0x30(%ebx)
executing->Wait.count = (uint32_t) event_in;
10a669: 89 43 24 mov %eax,0x24(%ebx)
executing->Wait.return_argument = event_out;
10a66c: 89 7b 28 mov %edi,0x28(%ebx)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10a66f: c7 05 e0 67 12 00 01 movl $0x1,0x1267e0
10a676: 00 00 00
_ISR_Enable( level );
10a679: ff 75 e0 pushl -0x20(%ebp)
10a67c: 9d popf
if ( ticks ) {
10a67d: 8b 45 dc mov -0x24(%ebp),%eax
10a680: 85 c0 test %eax,%eax
10a682: 0f 85 80 00 00 00 jne 10a708 <_Event_Seize+0xf0>
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
}
_Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
10a688: 83 ec 08 sub $0x8,%esp
10a68b: 68 00 01 00 00 push $0x100
10a690: 53 push %ebx
10a691: e8 5a 2e 00 00 call 10d4f0 <_Thread_Set_state>
_ISR_Disable( level );
10a696: 9c pushf
10a697: fa cli
10a698: 5a pop %edx
sync_state = _Event_Sync_state;
10a699: a1 e0 67 12 00 mov 0x1267e0,%eax
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10a69e: c7 05 e0 67 12 00 00 movl $0x0,0x1267e0
10a6a5: 00 00 00
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
10a6a8: 83 c4 10 add $0x10,%esp
10a6ab: 83 f8 01 cmp $0x1,%eax
10a6ae: 74 4c je 10a6fc <_Event_Seize+0xe4>
* An interrupt completed the thread's blocking request.
* The blocking thread was satisfied by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
_Thread_blocking_operation_Cancel( sync_state, executing, level );
10a6b0: 89 55 10 mov %edx,0x10(%ebp)
10a6b3: 89 5d 0c mov %ebx,0xc(%ebp)
10a6b6: 89 45 08 mov %eax,0x8(%ebp)
}
10a6b9: 8d 65 f4 lea -0xc(%ebp),%esp
10a6bc: 5b pop %ebx
10a6bd: 5e pop %esi
10a6be: 5f pop %edi
10a6bf: c9 leave
* An interrupt completed the thread's blocking request.
* The blocking thread was satisfied by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
_Thread_blocking_operation_Cancel( sync_state, executing, level );
10a6c0: e9 b3 21 00 00 jmp 10c878 <_Thread_blocking_operation_Cancel>
10a6c5: 8d 76 00 lea 0x0(%esi),%esi
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
_ISR_Enable( level );
10a6c8: ff 75 e0 pushl -0x20(%ebp)
10a6cb: 9d popf
executing->Wait.return_code = RTEMS_UNSATISFIED;
10a6cc: c7 43 34 0d 00 00 00 movl $0xd,0x34(%ebx)
*event_out = seized_events;
10a6d3: 8b 55 e4 mov -0x1c(%ebp),%edx
10a6d6: 89 17 mov %edx,(%edi)
* The blocking thread was satisfied by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
_Thread_blocking_operation_Cancel( sync_state, executing, level );
}
10a6d8: 8d 65 f4 lea -0xc(%ebp),%esp
10a6db: 5b pop %ebx
10a6dc: 5e pop %esi
10a6dd: 5f pop %edi
10a6de: c9 leave
10a6df: c3 ret
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
10a6e0: 8b 45 e4 mov -0x1c(%ebp),%eax
10a6e3: f7 d0 not %eax
10a6e5: 23 45 d4 and -0x2c(%ebp),%eax
10a6e8: 89 06 mov %eax,(%esi)
if ( !_Event_sets_Is_empty( seized_events ) &&
(seized_events == event_in || _Options_Is_any( option_set )) ) {
api->pending_events =
_Event_sets_Clear( pending_events, seized_events );
_ISR_Enable( level );
10a6ea: ff 75 e0 pushl -0x20(%ebp)
10a6ed: 9d popf
*event_out = seized_events;
10a6ee: 8b 45 e4 mov -0x1c(%ebp),%eax
10a6f1: 89 07 mov %eax,(%edi)
* The blocking thread was satisfied by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
_Thread_blocking_operation_Cancel( sync_state, executing, level );
}
10a6f3: 8d 65 f4 lea -0xc(%ebp),%esp
10a6f6: 5b pop %ebx
10a6f7: 5e pop %esi
10a6f8: 5f pop %edi
10a6f9: c9 leave
10a6fa: c3 ret
10a6fb: 90 nop
_ISR_Disable( level );
sync_state = _Event_Sync_state;
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
_ISR_Enable( level );
10a6fc: 52 push %edx
10a6fd: 9d popf
* The blocking thread was satisfied by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
_Thread_blocking_operation_Cancel( sync_state, executing, level );
}
10a6fe: 8d 65 f4 lea -0xc(%ebp),%esp
10a701: 5b pop %ebx
10a702: 5e pop %esi
10a703: 5f pop %edi
10a704: c9 leave
10a705: c3 ret
10a706: 66 90 xchg %ax,%ax
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
_ISR_Enable( level );
if ( ticks ) {
_Watchdog_Initialize(
10a708: 8b 43 08 mov 0x8(%ebx),%eax
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10a70b: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10a712: c7 43 64 bc a8 10 00 movl $0x10a8bc,0x64(%ebx)
the_watchdog->id = id;
10a719: 89 43 68 mov %eax,0x68(%ebx)
the_watchdog->user_data = user_data;
10a71c: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10a723: 8b 45 dc mov -0x24(%ebp),%eax
10a726: 89 43 54 mov %eax,0x54(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10a729: 83 ec 08 sub $0x8,%esp
&executing->Timer,
_Event_Timeout,
executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
10a72c: 8d 43 48 lea 0x48(%ebx),%eax
10a72f: 50 push %eax
10a730: 68 c0 65 12 00 push $0x1265c0
10a735: e8 ce 32 00 00 call 10da08 <_Watchdog_Insert>
10a73a: 83 c4 10 add $0x10,%esp
10a73d: e9 46 ff ff ff jmp 10a688 <_Event_Seize+0x70>
0010a798 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
10a798: 55 push %ebp
10a799: 89 e5 mov %esp,%ebp
10a79b: 57 push %edi
10a79c: 56 push %esi
10a79d: 53 push %ebx
10a79e: 83 ec 2c sub $0x2c,%esp
10a7a1: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_event_set event_condition;
rtems_event_set seized_events;
rtems_option option_set;
RTEMS_API_Control *api;
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
10a7a4: 8b 8b e4 00 00 00 mov 0xe4(%ebx),%ecx
option_set = (rtems_option) the_thread->Wait.option;
10a7aa: 8b 7b 30 mov 0x30(%ebx),%edi
_ISR_Disable( level );
10a7ad: 9c pushf
10a7ae: fa cli
10a7af: 8f 45 d4 popl -0x2c(%ebp)
pending_events = api->pending_events;
10a7b2: 8b 11 mov (%ecx),%edx
event_condition = (rtems_event_set) the_thread->Wait.count;
10a7b4: 8b 43 24 mov 0x24(%ebx),%eax
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
10a7b7: 89 c6 mov %eax,%esi
10a7b9: 21 d6 and %edx,%esi
10a7bb: 89 75 e4 mov %esi,-0x1c(%ebp)
10a7be: 74 74 je 10a834 <_Event_Surrender+0x9c>
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
10a7c0: 8b 35 74 67 12 00 mov 0x126774,%esi
10a7c6: 85 f6 test %esi,%esi
10a7c8: 74 0c je 10a7d6 <_Event_Surrender+0x3e>
10a7ca: 3b 1d 78 67 12 00 cmp 0x126778,%ebx
10a7d0: 0f 84 96 00 00 00 je 10a86c <_Event_Surrender+0xd4>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
10a7d6: f6 43 11 01 testb $0x1,0x11(%ebx)
10a7da: 74 4c je 10a828 <_Event_Surrender+0x90>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
10a7dc: 3b 45 e4 cmp -0x1c(%ebp),%eax
10a7df: 74 05 je 10a7e6 <_Event_Surrender+0x4e>
10a7e1: 83 e7 02 and $0x2,%edi
10a7e4: 74 42 je 10a828 <_Event_Surrender+0x90> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
10a7e6: 8b 45 e4 mov -0x1c(%ebp),%eax
10a7e9: f7 d0 not %eax
10a7eb: 21 d0 and %edx,%eax
10a7ed: 89 01 mov %eax,(%ecx)
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
10a7ef: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
10a7f6: 8b 43 28 mov 0x28(%ebx),%eax
10a7f9: 8b 75 e4 mov -0x1c(%ebp),%esi
10a7fc: 89 30 mov %esi,(%eax)
_ISR_Flash( level );
10a7fe: ff 75 d4 pushl -0x2c(%ebp)
10a801: 9d popf
10a802: fa cli
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10a803: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10a807: 74 37 je 10a840 <_Event_Surrender+0xa8>
_ISR_Enable( level );
10a809: ff 75 d4 pushl -0x2c(%ebp)
10a80c: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10a80d: 83 ec 08 sub $0x8,%esp
10a810: 68 f8 ff 03 10 push $0x1003fff8
10a815: 53 push %ebx
10a816: e8 7d 21 00 00 call 10c998 <_Thread_Clear_state>
10a81b: 83 c4 10 add $0x10,%esp
}
return;
}
}
_ISR_Enable( level );
}
10a81e: 8d 65 f4 lea -0xc(%ebp),%esp
10a821: 5b pop %ebx
10a822: 5e pop %esi
10a823: 5f pop %edi
10a824: c9 leave
10a825: c3 ret
10a826: 66 90 xchg %ax,%ax
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
10a828: ff 75 d4 pushl -0x2c(%ebp)
10a82b: 9d popf
}
10a82c: 8d 65 f4 lea -0xc(%ebp),%esp
10a82f: 5b pop %ebx
10a830: 5e pop %esi
10a831: 5f pop %edi
10a832: c9 leave
10a833: c3 ret
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
_ISR_Enable( level );
10a834: ff 75 d4 pushl -0x2c(%ebp)
10a837: 9d popf
}
return;
}
}
_ISR_Enable( level );
}
10a838: 8d 65 f4 lea -0xc(%ebp),%esp
10a83b: 5b pop %ebx
10a83c: 5e pop %esi
10a83d: 5f pop %edi
10a83e: c9 leave
10a83f: c3 ret
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
10a840: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
10a847: ff 75 d4 pushl -0x2c(%ebp)
10a84a: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
10a84b: 83 ec 0c sub $0xc,%esp
10a84e: 8d 43 48 lea 0x48(%ebx),%eax
10a851: 50 push %eax
10a852: e8 f1 32 00 00 call 10db48 <_Watchdog_Remove>
10a857: 58 pop %eax
10a858: 5a pop %edx
10a859: 68 f8 ff 03 10 push $0x1003fff8
10a85e: 53 push %ebx
10a85f: e8 34 21 00 00 call 10c998 <_Thread_Clear_state>
10a864: 83 c4 10 add $0x10,%esp
10a867: eb c3 jmp 10a82c <_Event_Surrender+0x94>
10a869: 8d 76 00 lea 0x0(%esi),%esi
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
10a86c: 8b 35 e0 67 12 00 mov 0x1267e0,%esi
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
10a872: 83 fe 02 cmp $0x2,%esi
10a875: 74 0d je 10a884 <_Event_Surrender+0xec> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
10a877: 8b 35 e0 67 12 00 mov 0x1267e0,%esi
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
10a87d: 4e dec %esi
10a87e: 0f 85 52 ff ff ff jne 10a7d6 <_Event_Surrender+0x3e>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
10a884: 3b 45 e4 cmp -0x1c(%ebp),%eax
10a887: 74 05 je 10a88e <_Event_Surrender+0xf6>
10a889: 83 e7 02 and $0x2,%edi
10a88c: 74 22 je 10a8b0 <_Event_Surrender+0x118><== NEVER TAKEN
10a88e: 8b 45 e4 mov -0x1c(%ebp),%eax
10a891: f7 d0 not %eax
10a893: 21 d0 and %edx,%eax
10a895: 89 01 mov %eax,(%ecx)
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
10a897: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
10a89e: 8b 43 28 mov 0x28(%ebx),%eax
10a8a1: 8b 55 e4 mov -0x1c(%ebp),%edx
10a8a4: 89 10 mov %edx,(%eax)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
10a8a6: c7 05 e0 67 12 00 03 movl $0x3,0x1267e0
10a8ad: 00 00 00
}
_ISR_Enable( level );
10a8b0: ff 75 d4 pushl -0x2c(%ebp)
10a8b3: 9d popf
return;
10a8b4: e9 73 ff ff ff jmp 10a82c <_Event_Surrender+0x94>
0010a8bc <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
10a8bc: 55 push %ebp
10a8bd: 89 e5 mov %esp,%ebp
10a8bf: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
10a8c2: 8d 45 f4 lea -0xc(%ebp),%eax
10a8c5: 50 push %eax
10a8c6: ff 75 08 pushl 0x8(%ebp)
10a8c9: e8 52 24 00 00 call 10cd20 <_Thread_Get>
switch ( location ) {
10a8ce: 83 c4 10 add $0x10,%esp
10a8d1: 8b 55 f4 mov -0xc(%ebp),%edx
10a8d4: 85 d2 test %edx,%edx
10a8d6: 75 37 jne 10a90f <_Event_Timeout+0x53> <== NEVER TAKEN
*
* If it is not satisfied, then it is "nothing happened" and
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
_ISR_Disable( level );
10a8d8: 9c pushf
10a8d9: fa cli
10a8da: 5a pop %edx
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
10a8db: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
if ( _Thread_Is_executing( the_thread ) ) {
10a8e2: 3b 05 78 67 12 00 cmp 0x126778,%eax
10a8e8: 74 2a je 10a914 <_Event_Timeout+0x58>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
10a8ea: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax)
_ISR_Enable( level );
10a8f1: 52 push %edx
10a8f2: 9d popf
10a8f3: 83 ec 08 sub $0x8,%esp
10a8f6: 68 f8 ff 03 10 push $0x1003fff8
10a8fb: 50 push %eax
10a8fc: e8 97 20 00 00 call 10c998 <_Thread_Clear_state>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10a901: a1 ec 64 12 00 mov 0x1264ec,%eax
10a906: 48 dec %eax
10a907: a3 ec 64 12 00 mov %eax,0x1264ec
_Thread_Unblock( the_thread );
_Thread_Unnest_dispatch();
break;
10a90c: 83 c4 10 add $0x10,%esp
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10a90f: c9 leave
10a910: c3 ret
10a911: 8d 76 00 lea 0x0(%esi),%esi
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
10a914: 8b 0d e0 67 12 00 mov 0x1267e0,%ecx
10a91a: 49 dec %ecx
10a91b: 75 cd jne 10a8ea <_Event_Timeout+0x2e>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
10a91d: c7 05 e0 67 12 00 02 movl $0x2,0x1267e0
10a924: 00 00 00
10a927: eb c1 jmp 10a8ea <_Event_Timeout+0x2e>
0011027c <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
11027c: 55 push %ebp
11027d: 89 e5 mov %esp,%ebp
11027f: 57 push %edi
110280: 56 push %esi
110281: 53 push %ebx
110282: 83 ec 2c sub $0x2c,%esp
110285: 8b 7d 0c mov 0xc(%ebp),%edi
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
110288: 8d 47 04 lea 0x4(%edi),%eax
11028b: 89 45 dc mov %eax,-0x24(%ebp)
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
11028e: 8b 55 08 mov 0x8(%ebp),%edx
110291: 8b 52 10 mov 0x10(%edx),%edx
110294: 89 55 cc mov %edx,-0x34(%ebp)
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
110297: 39 c7 cmp %eax,%edi
110299: 0f 87 69 01 00 00 ja 110408 <_Heap_Allocate_aligned_with_boundary+0x18c>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
11029f: 8b 5d 14 mov 0x14(%ebp),%ebx
1102a2: 85 db test %ebx,%ebx
1102a4: 0f 85 56 01 00 00 jne 110400 <_Heap_Allocate_aligned_with_boundary+0x184>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
1102aa: 8b 45 08 mov 0x8(%ebp),%eax
1102ad: 8b 48 08 mov 0x8(%eax),%ecx
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
1102b0: 39 c8 cmp %ecx,%eax
1102b2: 0f 84 50 01 00 00 je 110408 <_Heap_Allocate_aligned_with_boundary+0x18c>
1102b8: c7 45 e4 01 00 00 00 movl $0x1,-0x1c(%ebp)
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
1102bf: 8b 55 cc mov -0x34(%ebp),%edx
1102c2: 83 c2 07 add $0x7,%edx
1102c5: 89 55 c8 mov %edx,-0x38(%ebp)
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
1102c8: c7 45 d0 04 00 00 00 movl $0x4,-0x30(%ebp)
1102cf: 29 7d d0 sub %edi,-0x30(%ebp)
1102d2: eb 1e jmp 1102f2 <_Heap_Allocate_aligned_with_boundary+0x76>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
1102d4: 8d 59 08 lea 0x8(%ecx),%ebx
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
1102d7: 85 db test %ebx,%ebx
1102d9: 0f 85 f1 00 00 00 jne 1103d0 <_Heap_Allocate_aligned_with_boundary+0x154><== ALWAYS TAKEN
break;
}
block = block->next;
1102df: 8b 49 08 mov 0x8(%ecx),%ecx
1102e2: 8b 45 e4 mov -0x1c(%ebp),%eax
1102e5: 40 inc %eax
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
1102e6: 39 4d 08 cmp %ecx,0x8(%ebp)
1102e9: 0f 84 25 01 00 00 je 110414 <_Heap_Allocate_aligned_with_boundary+0x198>
1102ef: 89 45 e4 mov %eax,-0x1c(%ebp)
/*
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
1102f2: 8b 59 04 mov 0x4(%ecx),%ebx
1102f5: 39 5d dc cmp %ebx,-0x24(%ebp)
1102f8: 73 e5 jae 1102df <_Heap_Allocate_aligned_with_boundary+0x63>
if ( alignment == 0 ) {
1102fa: 8b 55 10 mov 0x10(%ebp),%edx
1102fd: 85 d2 test %edx,%edx
1102ff: 74 d3 je 1102d4 <_Heap_Allocate_aligned_with_boundary+0x58>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
110301: 8b 45 08 mov 0x8(%ebp),%eax
110304: 8b 40 14 mov 0x14(%eax),%eax
110307: 89 45 d8 mov %eax,-0x28(%ebp)
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
11030a: 83 e3 fe and $0xfffffffe,%ebx
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
11030d: 8d 1c 19 lea (%ecx,%ebx,1),%ebx
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
110310: 8d 51 08 lea 0x8(%ecx),%edx
110313: 89 55 d4 mov %edx,-0x2c(%ebp)
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
110316: 8b 75 c8 mov -0x38(%ebp),%esi
110319: 29 c6 sub %eax,%esi
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
11031b: 01 de add %ebx,%esi
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
11031d: 03 5d d0 add -0x30(%ebp),%ebx
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
110320: 89 d8 mov %ebx,%eax
110322: 31 d2 xor %edx,%edx
110324: f7 75 10 divl 0x10(%ebp)
110327: 29 d3 sub %edx,%ebx
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
110329: 39 de cmp %ebx,%esi
11032b: 73 0b jae 110338 <_Heap_Allocate_aligned_with_boundary+0xbc>
11032d: 89 f0 mov %esi,%eax
11032f: 31 d2 xor %edx,%edx
110331: f7 75 10 divl 0x10(%ebp)
110334: 89 f3 mov %esi,%ebx
110336: 29 d3 sub %edx,%ebx
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
110338: 8b 45 14 mov 0x14(%ebp),%eax
11033b: 85 c0 test %eax,%eax
11033d: 74 5b je 11039a <_Heap_Allocate_aligned_with_boundary+0x11e>
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment );
}
alloc_end = alloc_begin + alloc_size;
11033f: 8d 34 3b lea (%ebx,%edi,1),%esi
110342: 89 f0 mov %esi,%eax
110344: 31 d2 xor %edx,%edx
110346: f7 75 14 divl 0x14(%ebp)
110349: 89 f0 mov %esi,%eax
11034b: 29 d0 sub %edx,%eax
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
11034d: 39 c3 cmp %eax,%ebx
11034f: 73 49 jae 11039a <_Heap_Allocate_aligned_with_boundary+0x11e>
110351: 39 c6 cmp %eax,%esi
110353: 76 45 jbe 11039a <_Heap_Allocate_aligned_with_boundary+0x11e>
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
110355: 8b 55 d4 mov -0x2c(%ebp),%edx
110358: 01 fa add %edi,%edx
11035a: 89 55 e0 mov %edx,-0x20(%ebp)
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
if ( boundary_line < boundary_floor ) {
11035d: 39 c2 cmp %eax,%edx
11035f: 0f 87 7a ff ff ff ja 1102df <_Heap_Allocate_aligned_with_boundary+0x63>
110365: 89 ce mov %ecx,%esi
110367: eb 10 jmp 110379 <_Heap_Allocate_aligned_with_boundary+0xfd>
110369: 8d 76 00 lea 0x0(%esi),%esi
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
11036c: 39 c1 cmp %eax,%ecx
11036e: 76 28 jbe 110398 <_Heap_Allocate_aligned_with_boundary+0x11c>
if ( boundary_line < boundary_floor ) {
110370: 39 45 e0 cmp %eax,-0x20(%ebp)
110373: 0f 87 9f 00 00 00 ja 110418 <_Heap_Allocate_aligned_with_boundary+0x19c><== NEVER TAKEN
return 0;
}
alloc_begin = boundary_line - alloc_size;
110379: 89 c3 mov %eax,%ebx
11037b: 29 fb sub %edi,%ebx
11037d: 89 d8 mov %ebx,%eax
11037f: 31 d2 xor %edx,%edx
110381: f7 75 10 divl 0x10(%ebp)
110384: 29 d3 sub %edx,%ebx
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
110386: 8d 0c 3b lea (%ebx,%edi,1),%ecx
110389: 89 c8 mov %ecx,%eax
11038b: 31 d2 xor %edx,%edx
11038d: f7 75 14 divl 0x14(%ebp)
110390: 89 c8 mov %ecx,%eax
110392: 29 d0 sub %edx,%eax
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
110394: 39 c3 cmp %eax,%ebx
110396: 72 d4 jb 11036c <_Heap_Allocate_aligned_with_boundary+0xf0>
110398: 89 f1 mov %esi,%ecx
boundary_line = _Heap_Align_down( alloc_end, boundary );
}
}
/* Ensure that the we have a valid new block at the beginning */
if ( alloc_begin >= alloc_begin_floor ) {
11039a: 39 5d d4 cmp %ebx,-0x2c(%ebp)
11039d: 0f 87 3c ff ff ff ja 1102df <_Heap_Allocate_aligned_with_boundary+0x63>
1103a3: be f8 ff ff ff mov $0xfffffff8,%esi
1103a8: 29 ce sub %ecx,%esi
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
1103aa: 01 de add %ebx,%esi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
1103ac: 89 d8 mov %ebx,%eax
1103ae: 31 d2 xor %edx,%edx
1103b0: f7 75 cc divl -0x34(%ebp)
uintptr_t const alloc_block_begin =
(uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size );
uintptr_t const free_size = alloc_block_begin - block_begin;
1103b3: 29 d6 sub %edx,%esi
if ( free_size >= min_block_size || free_size == 0 ) {
1103b5: 39 75 d8 cmp %esi,-0x28(%ebp)
1103b8: 0f 86 19 ff ff ff jbe 1102d7 <_Heap_Allocate_aligned_with_boundary+0x5b>
1103be: 85 f6 test %esi,%esi
1103c0: 0f 85 19 ff ff ff jne 1102df <_Heap_Allocate_aligned_with_boundary+0x63>
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
1103c6: 85 db test %ebx,%ebx
1103c8: 0f 84 11 ff ff ff je 1102df <_Heap_Allocate_aligned_with_boundary+0x63><== NEVER TAKEN
1103ce: 66 90 xchg %ax,%ax
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
1103d0: 8b 45 08 mov 0x8(%ebp),%eax
1103d3: ff 40 48 incl 0x48(%eax)
stats->searches += search_count;
1103d6: 8b 55 e4 mov -0x1c(%ebp),%edx
1103d9: 01 50 4c add %edx,0x4c(%eax)
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
1103dc: 57 push %edi
1103dd: 53 push %ebx
1103de: 51 push %ecx
1103df: 50 push %eax
1103e0: e8 8f b7 ff ff call 10bb74 <_Heap_Block_allocate>
1103e5: 89 d8 mov %ebx,%eax
1103e7: 83 c4 10 add $0x10,%esp
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
1103ea: 8b 55 e4 mov -0x1c(%ebp),%edx
1103ed: 8b 4d 08 mov 0x8(%ebp),%ecx
1103f0: 39 51 44 cmp %edx,0x44(%ecx)
1103f3: 73 15 jae 11040a <_Heap_Allocate_aligned_with_boundary+0x18e>
stats->max_search = search_count;
1103f5: 89 51 44 mov %edx,0x44(%ecx)
}
return (void *) alloc_begin;
}
1103f8: 8d 65 f4 lea -0xc(%ebp),%esp
1103fb: 5b pop %ebx
1103fc: 5e pop %esi
1103fd: 5f pop %edi
1103fe: c9 leave
1103ff: c3 ret
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
110400: 3b 7d 14 cmp 0x14(%ebp),%edi
110403: 76 1a jbe 11041f <_Heap_Allocate_aligned_with_boundary+0x1a3>
110405: 8d 76 00 lea 0x0(%esi),%esi
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
110408: 31 c0 xor %eax,%eax
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
11040a: 8d 65 f4 lea -0xc(%ebp),%esp
11040d: 5b pop %ebx
11040e: 5e pop %esi
11040f: 5f pop %edi
110410: c9 leave
110411: c3 ret
110412: 66 90 xchg %ax,%ax
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
110414: 31 c0 xor %eax,%eax
110416: eb d2 jmp 1103ea <_Heap_Allocate_aligned_with_boundary+0x16e>
110418: 89 f1 mov %esi,%ecx <== NOT EXECUTED
11041a: e9 c0 fe ff ff jmp 1102df <_Heap_Allocate_aligned_with_boundary+0x63><== NOT EXECUTED
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
return NULL;
}
if ( alignment == 0 ) {
11041f: 8b 4d 10 mov 0x10(%ebp),%ecx
110422: 85 c9 test %ecx,%ecx
110424: 0f 85 80 fe ff ff jne 1102aa <_Heap_Allocate_aligned_with_boundary+0x2e>
alignment = page_size;
11042a: 89 55 10 mov %edx,0x10(%ebp)
11042d: e9 78 fe ff ff jmp 1102aa <_Heap_Allocate_aligned_with_boundary+0x2e>
00110790 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
110790: 55 push %ebp
110791: 89 e5 mov %esp,%ebp
110793: 57 push %edi
110794: 56 push %esi
110795: 53 push %ebx
110796: 83 ec 4c sub $0x4c,%esp
110799: 8b 5d 08 mov 0x8(%ebp),%ebx
11079c: 8b 4d 10 mov 0x10(%ebp),%ecx
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
11079f: 8b 43 20 mov 0x20(%ebx),%eax
1107a2: 89 45 d0 mov %eax,-0x30(%ebp)
Heap_Block *start_block = first_block;
Heap_Block *merge_below_block = NULL;
Heap_Block *merge_above_block = NULL;
Heap_Block *link_below_block = NULL;
Heap_Block *link_above_block = NULL;
Heap_Block *extend_first_block = NULL;
1107a5: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
Heap_Block *extend_last_block = NULL;
1107ac: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
uintptr_t const page_size = heap->page_size;
1107b3: 8b 53 10 mov 0x10(%ebx),%edx
1107b6: 89 55 d4 mov %edx,-0x2c(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
1107b9: 8b 43 14 mov 0x14(%ebx),%eax
uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr;
uintptr_t const extend_area_end = extend_area_begin + extend_area_size;
uintptr_t const free_size = stats->free_size;
1107bc: 8b 73 30 mov 0x30(%ebx),%esi
1107bf: 89 75 c0 mov %esi,-0x40(%ebp)
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
1107c2: 8b 55 0c mov 0xc(%ebp),%edx
1107c5: 01 ca add %ecx,%edx
1107c7: 89 55 cc mov %edx,-0x34(%ebp)
1107ca: 73 0c jae 1107d8 <_Heap_Extend+0x48>
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
1107cc: 31 c0 xor %eax,%eax
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
1107ce: 8d 65 f4 lea -0xc(%ebp),%esp
1107d1: 5b pop %ebx
1107d2: 5e pop %esi
1107d3: 5f pop %edi
1107d4: c9 leave
1107d5: c3 ret
1107d6: 66 90 xchg %ax,%ax
if ( extend_area_end < extend_area_begin ) {
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
1107d8: 83 ec 08 sub $0x8,%esp
1107db: 8d 55 e0 lea -0x20(%ebp),%edx
1107de: 52 push %edx
1107df: 8d 55 e4 lea -0x1c(%ebp),%edx
1107e2: 52 push %edx
1107e3: 50 push %eax
1107e4: ff 75 d4 pushl -0x2c(%ebp)
1107e7: 51 push %ecx
1107e8: ff 75 0c pushl 0xc(%ebp)
1107eb: e8 90 b5 ff ff call 10bd80 <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
1107f0: 83 c4 20 add $0x20,%esp
1107f3: 84 c0 test %al,%al
1107f5: 74 d5 je 1107cc <_Heap_Extend+0x3c>
1107f7: 8b 7d d0 mov -0x30(%ebp),%edi
1107fa: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%ebp)
110801: c7 45 b8 00 00 00 00 movl $0x0,-0x48(%ebp)
110808: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp)
11080f: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
110816: 8b 75 cc mov -0x34(%ebp),%esi
110819: 89 5d b4 mov %ebx,-0x4c(%ebp)
11081c: eb 30 jmp 11084e <_Heap_Extend+0xbe>
11081e: 66 90 xchg %ax,%ax
return false;
}
if ( extend_area_end == sub_area_begin ) {
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
110820: 39 ce cmp %ecx,%esi
110822: 73 03 jae 110827 <_Heap_Extend+0x97>
110824: 89 7d b8 mov %edi,-0x48(%ebp)
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
110827: 8d 59 f8 lea -0x8(%ecx),%ebx
11082a: 89 c8 mov %ecx,%eax
11082c: 31 d2 xor %edx,%edx
11082e: f7 75 d4 divl -0x2c(%ebp)
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
110831: 29 d3 sub %edx,%ebx
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
110833: 3b 4d 0c cmp 0xc(%ebp),%ecx
110836: 74 3c je 110874 <_Heap_Extend+0xe4> <== NEVER TAKEN
start_block->prev_size = extend_area_end;
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
110838: 39 4d 0c cmp %ecx,0xc(%ebp)
11083b: 76 03 jbe 110840 <_Heap_Extend+0xb0>
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area(
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
11083d: 89 5d bc mov %ebx,-0x44(%ebp)
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
110840: 8b 7b 04 mov 0x4(%ebx),%edi
110843: 83 e7 fe and $0xfffffffe,%edi
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
110846: 8d 3c 3b lea (%ebx,%edi,1),%edi
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
110849: 39 7d d0 cmp %edi,-0x30(%ebp)
11084c: 74 39 je 110887 <_Heap_Extend+0xf7>
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
11084e: 3b 7d d0 cmp -0x30(%ebp),%edi
110851: 0f 84 39 01 00 00 je 110990 <_Heap_Extend+0x200>
110857: 89 f8 mov %edi,%eax
uintptr_t const sub_area_end = start_block->prev_size;
110859: 8b 0f mov (%edi),%ecx
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
11085b: 39 4d 0c cmp %ecx,0xc(%ebp)
11085e: 73 08 jae 110868 <_Heap_Extend+0xd8>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
110860: 39 f0 cmp %esi,%eax
110862: 0f 82 64 ff ff ff jb 1107cc <_Heap_Extend+0x3c>
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
110868: 39 f0 cmp %esi,%eax
11086a: 75 b4 jne 110820 <_Heap_Extend+0x90>
11086c: 89 7d c4 mov %edi,-0x3c(%ebp)
11086f: eb b6 jmp 110827 <_Heap_Extend+0x97>
110871: 8d 76 00 lea 0x0(%esi),%esi
} else if ( extend_area_end < sub_area_end ) {
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
start_block->prev_size = extend_area_end;
110874: 89 37 mov %esi,(%edi)
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area(
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
110876: 89 5d c8 mov %ebx,-0x38(%ebp)
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
110879: 8b 7b 04 mov 0x4(%ebx),%edi
11087c: 83 e7 fe and $0xfffffffe,%edi
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
11087f: 8d 3c 3b lea (%ebx,%edi,1),%edi
} else if ( sub_area_end < extend_area_begin ) {
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
110882: 39 7d d0 cmp %edi,-0x30(%ebp)
110885: 75 c7 jne 11084e <_Heap_Extend+0xbe> <== NEVER TAKEN
110887: 8b 5d b4 mov -0x4c(%ebp),%ebx
if ( extend_area_begin < heap->area_begin ) {
11088a: 8b 75 0c mov 0xc(%ebp),%esi
11088d: 3b 73 18 cmp 0x18(%ebx),%esi
110890: 0f 82 06 01 00 00 jb 11099c <_Heap_Extend+0x20c>
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
110896: 8b 45 cc mov -0x34(%ebp),%eax
110899: 3b 43 1c cmp 0x1c(%ebx),%eax
11089c: 76 03 jbe 1108a1 <_Heap_Extend+0x111>
heap->area_end = extend_area_end;
11089e: 89 43 1c mov %eax,0x1c(%ebx)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
1108a1: 8b 55 e0 mov -0x20(%ebp),%edx
1108a4: 8b 45 e4 mov -0x1c(%ebp),%eax
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
1108a7: 89 d1 mov %edx,%ecx
1108a9: 29 c1 sub %eax,%ecx
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
1108ab: 8b 75 cc mov -0x34(%ebp),%esi
1108ae: 89 30 mov %esi,(%eax)
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
1108b0: 89 ce mov %ecx,%esi
1108b2: 83 ce 01 or $0x1,%esi
1108b5: 89 70 04 mov %esi,0x4(%eax)
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
1108b8: 89 0a mov %ecx,(%edx)
extend_last_block->size_and_flag = 0;
1108ba: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
1108c1: 39 43 20 cmp %eax,0x20(%ebx)
1108c4: 0f 86 da 00 00 00 jbe 1109a4 <_Heap_Extend+0x214>
heap->first_block = extend_first_block;
1108ca: 89 43 20 mov %eax,0x20(%ebx)
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
1108cd: 8b 75 c4 mov -0x3c(%ebp),%esi
1108d0: 85 f6 test %esi,%esi
1108d2: 0f 84 10 01 00 00 je 1109e8 <_Heap_Extend+0x258>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
1108d8: 8b 73 10 mov 0x10(%ebx),%esi
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
1108db: 8b 4d 0c mov 0xc(%ebp),%ecx
1108de: 83 c1 08 add $0x8,%ecx
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
1108e1: 89 c8 mov %ecx,%eax
1108e3: 31 d2 xor %edx,%edx
1108e5: f7 f6 div %esi
if ( remainder != 0 ) {
1108e7: 85 d2 test %edx,%edx
1108e9: 0f 84 c9 00 00 00 je 1109b8 <_Heap_Extend+0x228>
return value - remainder + alignment;
1108ef: 8d 04 31 lea (%ecx,%esi,1),%eax
1108f2: 29 d0 sub %edx,%eax
uintptr_t const new_first_block_begin =
1108f4: 8d 50 f8 lea -0x8(%eax),%edx
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
1108f7: 8b 75 c4 mov -0x3c(%ebp),%esi
1108fa: 8b 0e mov (%esi),%ecx
1108fc: 89 48 f8 mov %ecx,-0x8(%eax)
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const new_first_block_begin =
new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
1108ff: 89 f0 mov %esi,%eax
110901: 29 d0 sub %edx,%eax
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
110903: 83 c8 01 or $0x1,%eax
110906: 89 42 04 mov %eax,0x4(%edx)
_Heap_Free_block( heap, new_first_block );
110909: 89 d8 mov %ebx,%eax
11090b: e8 64 fe ff ff call 110774 <_Heap_Free_block>
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
110910: 8b 45 c8 mov -0x38(%ebp),%eax
110913: 85 c0 test %eax,%eax
110915: 0f 84 a5 00 00 00 je 1109c0 <_Heap_Extend+0x230>
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
extend_area_end - last_block_begin - HEAP_BLOCK_HEADER_SIZE,
11091b: 8b 4d cc mov -0x34(%ebp),%ecx
11091e: 83 e9 08 sub $0x8,%ecx
uintptr_t extend_area_end
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
110921: 2b 4d c8 sub -0x38(%ebp),%ecx
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
110924: 89 c8 mov %ecx,%eax
110926: 31 d2 xor %edx,%edx
110928: f7 73 10 divl 0x10(%ebx)
11092b: 29 d1 sub %edx,%ecx
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
(last_block->size_and_flag - last_block_new_size)
11092d: 8b 55 c8 mov -0x38(%ebp),%edx
110930: 8b 42 04 mov 0x4(%edx),%eax
110933: 29 c8 sub %ecx,%eax
| HEAP_PREV_BLOCK_USED;
110935: 83 c8 01 or $0x1,%eax
110938: 89 44 11 04 mov %eax,0x4(%ecx,%edx,1)
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
11093c: 8b 42 04 mov 0x4(%edx),%eax
11093f: 83 e0 01 and $0x1,%eax
block->size_and_flag = size | flag;
110942: 09 c8 or %ecx,%eax
110944: 89 42 04 mov %eax,0x4(%edx)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
110947: 89 d8 mov %ebx,%eax
110949: e8 26 fe ff ff call 110774 <_Heap_Free_block>
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
11094e: 8b 75 c4 mov -0x3c(%ebp),%esi
110951: 85 f6 test %esi,%esi
110953: 0f 84 ab 00 00 00 je 110a04 <_Heap_Extend+0x274>
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
110959: 8b 53 24 mov 0x24(%ebx),%edx
* This feature will be used to terminate the scattered heap area list. See
* also _Heap_Extend().
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
11095c: 8b 43 20 mov 0x20(%ebx),%eax
11095f: 29 d0 sub %edx,%eax
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
110961: 8b 4a 04 mov 0x4(%edx),%ecx
110964: 83 e1 01 and $0x1,%ecx
block->size_and_flag = size | flag;
110967: 09 c8 or %ecx,%eax
110969: 89 42 04 mov %eax,0x4(%edx)
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
11096c: 8b 43 30 mov 0x30(%ebx),%eax
11096f: 2b 45 c0 sub -0x40(%ebp),%eax
/* Statistics */
stats->size += extended_size;
110972: 01 43 2c add %eax,0x2c(%ebx)
if ( extended_size_ptr != NULL )
110975: 8b 55 14 mov 0x14(%ebp),%edx
110978: 85 d2 test %edx,%edx
11097a: 0f 84 a0 00 00 00 je 110a20 <_Heap_Extend+0x290> <== NEVER TAKEN
*extended_size_ptr = extended_size;
110980: 8b 55 14 mov 0x14(%ebp),%edx
110983: 89 02 mov %eax,(%edx)
return true;
110985: b0 01 mov $0x1,%al
}
110987: 8d 65 f4 lea -0xc(%ebp),%esp
11098a: 5b pop %ebx
11098b: 5e pop %esi
11098c: 5f pop %edi
11098d: c9 leave
11098e: c3 ret
11098f: 90 nop
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
110990: 8b 55 b4 mov -0x4c(%ebp),%edx
110993: 8b 42 18 mov 0x18(%edx),%eax
110996: e9 be fe ff ff jmp 110859 <_Heap_Extend+0xc9>
11099b: 90 nop
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
if ( extend_area_begin < heap->area_begin ) {
heap->area_begin = extend_area_begin;
11099c: 89 73 18 mov %esi,0x18(%ebx)
11099f: e9 fd fe ff ff jmp 1108a1 <_Heap_Extend+0x111>
extend_last_block->size_and_flag = 0;
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
heap->first_block = extend_first_block;
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
1109a4: 39 53 24 cmp %edx,0x24(%ebx)
1109a7: 0f 83 20 ff ff ff jae 1108cd <_Heap_Extend+0x13d>
heap->last_block = extend_last_block;
1109ad: 89 53 24 mov %edx,0x24(%ebx)
1109b0: e9 18 ff ff ff jmp 1108cd <_Heap_Extend+0x13d>
1109b5: 8d 76 00 lea 0x0(%esi),%esi
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
return value - remainder + alignment;
} else {
return value;
1109b8: 89 c8 mov %ecx,%eax
1109ba: e9 35 ff ff ff jmp 1108f4 <_Heap_Extend+0x164>
1109bf: 90 nop
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
1109c0: 8b 7d bc mov -0x44(%ebp),%edi
1109c3: 85 ff test %edi,%edi
1109c5: 74 87 je 11094e <_Heap_Extend+0x1be>
_Heap_Link_above(
1109c7: 8b 4d e0 mov -0x20(%ebp),%ecx
)
{
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
1109ca: 8b 45 e4 mov -0x1c(%ebp),%eax
1109cd: 2b 45 bc sub -0x44(%ebp),%eax
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
1109d0: 8b 75 bc mov -0x44(%ebp),%esi
1109d3: 8b 56 04 mov 0x4(%esi),%edx
1109d6: 83 e2 01 and $0x1,%edx
block->size_and_flag = size | flag;
1109d9: 09 d0 or %edx,%eax
1109db: 89 46 04 mov %eax,0x4(%esi)
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
1109de: 83 49 04 01 orl $0x1,0x4(%ecx)
1109e2: e9 67 ff ff ff jmp 11094e <_Heap_Extend+0x1be>
1109e7: 90 nop
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
_Heap_Merge_below( heap, extend_area_begin, merge_below_block );
} else if ( link_below_block != NULL ) {
1109e8: 8b 4d b8 mov -0x48(%ebp),%ecx
1109eb: 85 c9 test %ecx,%ecx
1109ed: 0f 84 1d ff ff ff je 110910 <_Heap_Extend+0x180>
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
(link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;
1109f3: 8b 45 b8 mov -0x48(%ebp),%eax
1109f6: 29 d0 sub %edx,%eax
1109f8: 83 c8 01 or $0x1,%eax
1109fb: 89 42 04 mov %eax,0x4(%edx)
1109fe: e9 0d ff ff ff jmp 110910 <_Heap_Extend+0x180>
110a03: 90 nop
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
110a04: 8b 4d c8 mov -0x38(%ebp),%ecx
110a07: 85 c9 test %ecx,%ecx
110a09: 0f 85 4a ff ff ff jne 110959 <_Heap_Extend+0x1c9>
_Heap_Free_block( heap, extend_first_block );
110a0f: 8b 55 e4 mov -0x1c(%ebp),%edx
110a12: 89 d8 mov %ebx,%eax
110a14: e8 5b fd ff ff call 110774 <_Heap_Free_block>
110a19: e9 3b ff ff ff jmp 110959 <_Heap_Extend+0x1c9>
110a1e: 66 90 xchg %ax,%ax
stats->size += extended_size;
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
110a20: b0 01 mov $0x1,%al <== NOT EXECUTED
110a22: e9 a7 fd ff ff jmp 1107ce <_Heap_Extend+0x3e> <== NOT EXECUTED
00110434 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
110434: 55 push %ebp
110435: 89 e5 mov %esp,%ebp
110437: 57 push %edi
110438: 56 push %esi
110439: 53 push %ebx
11043a: 83 ec 10 sub $0x10,%esp
11043d: 8b 4d 08 mov 0x8(%ebp),%ecx
110440: 8b 45 0c mov 0xc(%ebp),%eax
/*
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
110443: 85 c0 test %eax,%eax
110445: 0f 84 e9 00 00 00 je 110534 <_Heap_Free+0x100>
11044b: 8d 58 f8 lea -0x8(%eax),%ebx
11044e: 31 d2 xor %edx,%edx
110450: f7 71 10 divl 0x10(%ecx)
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
110453: 29 d3 sub %edx,%ebx
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
110455: 8b 41 20 mov 0x20(%ecx),%eax
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
110458: 39 c3 cmp %eax,%ebx
11045a: 72 1c jb 110478 <_Heap_Free+0x44>
11045c: 8b 71 24 mov 0x24(%ecx),%esi
11045f: 39 f3 cmp %esi,%ebx
110461: 77 15 ja 110478 <_Heap_Free+0x44>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
110463: 8b 53 04 mov 0x4(%ebx),%edx
110466: 89 55 f0 mov %edx,-0x10(%ebp)
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
110469: 83 e2 fe and $0xfffffffe,%edx
11046c: 89 55 ec mov %edx,-0x14(%ebp)
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
11046f: 8d 14 13 lea (%ebx,%edx,1),%edx
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
110472: 39 d0 cmp %edx,%eax
110474: 76 0e jbe 110484 <_Heap_Free+0x50> <== ALWAYS TAKEN
110476: 66 90 xchg %ax,%ax
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
_HAssert( false );
return( false );
110478: 31 c0 xor %eax,%eax
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
11047a: 83 c4 10 add $0x10,%esp
11047d: 5b pop %ebx
11047e: 5e pop %esi
11047f: 5f pop %edi
110480: c9 leave
110481: c3 ret
110482: 66 90 xchg %ax,%ax
110484: 39 d6 cmp %edx,%esi
110486: 72 f0 jb 110478 <_Heap_Free+0x44> <== NEVER TAKEN
110488: 8b 7a 04 mov 0x4(%edx),%edi
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
11048b: f7 c7 01 00 00 00 test $0x1,%edi
110491: 74 e5 je 110478 <_Heap_Free+0x44> <== NEVER TAKEN
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
110493: 83 e7 fe and $0xfffffffe,%edi
110496: 89 7d e4 mov %edi,-0x1c(%ebp)
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
110499: 39 d6 cmp %edx,%esi
11049b: 0f 84 d3 00 00 00 je 110574 <_Heap_Free+0x140>
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
1104a1: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1)
1104a6: 0f 94 45 eb sete -0x15(%ebp)
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
1104aa: f6 45 f0 01 testb $0x1,-0x10(%ebp)
1104ae: 75 44 jne 1104f4 <_Heap_Free+0xc0>
uintptr_t const prev_size = block->prev_size;
1104b0: 8b 3b mov (%ebx),%edi
1104b2: 89 7d f0 mov %edi,-0x10(%ebp)
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
1104b5: 29 fb sub %edi,%ebx
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
1104b7: 39 d8 cmp %ebx,%eax
1104b9: 77 bd ja 110478 <_Heap_Free+0x44> <== NEVER TAKEN
1104bb: 39 de cmp %ebx,%esi
1104bd: 72 b9 jb 110478 <_Heap_Free+0x44> <== NEVER TAKEN
return( false );
}
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
1104bf: f6 43 04 01 testb $0x1,0x4(%ebx)
1104c3: 74 b3 je 110478 <_Heap_Free+0x44> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
1104c5: 80 7d eb 00 cmpb $0x0,-0x15(%ebp)
1104c9: 0f 84 b1 00 00 00 je 110580 <_Heap_Free+0x14c>
uintptr_t const size = block_size + prev_size + next_block_size;
1104cf: 8b 7d e4 mov -0x1c(%ebp),%edi
1104d2: 03 7d ec add -0x14(%ebp),%edi
1104d5: 03 7d f0 add -0x10(%ebp),%edi
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
1104d8: 8b 42 08 mov 0x8(%edx),%eax
1104db: 8b 52 0c mov 0xc(%edx),%edx
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
1104de: 89 42 08 mov %eax,0x8(%edx)
next->prev = prev;
1104e1: 89 50 0c mov %edx,0xc(%eax)
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
1104e4: ff 49 38 decl 0x38(%ecx)
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
1104e7: 89 f8 mov %edi,%eax
1104e9: 83 c8 01 or $0x1,%eax
1104ec: 89 43 04 mov %eax,0x4(%ebx)
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
1104ef: 89 3c 3b mov %edi,(%ebx,%edi,1)
1104f2: eb 29 jmp 11051d <_Heap_Free+0xe9>
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
1104f4: 80 7d eb 00 cmpb $0x0,-0x15(%ebp)
1104f8: 74 46 je 110540 <_Heap_Free+0x10c>
uintptr_t const size = block_size + next_block_size;
1104fa: 8b 7d e4 mov -0x1c(%ebp),%edi
1104fd: 03 7d ec add -0x14(%ebp),%edi
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
110500: 8b 42 08 mov 0x8(%edx),%eax
110503: 8b 52 0c mov 0xc(%edx),%edx
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
110506: 89 43 08 mov %eax,0x8(%ebx)
new_block->prev = prev;
110509: 89 53 0c mov %edx,0xc(%ebx)
next->prev = new_block;
11050c: 89 58 0c mov %ebx,0xc(%eax)
prev->next = new_block;
11050f: 89 5a 08 mov %ebx,0x8(%edx)
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
110512: 89 f8 mov %edi,%eax
110514: 83 c8 01 or $0x1,%eax
110517: 89 43 04 mov %eax,0x4(%ebx)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
11051a: 89 3c 3b mov %edi,(%ebx,%edi,1)
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
11051d: ff 49 40 decl 0x40(%ecx)
++stats->frees;
110520: ff 41 50 incl 0x50(%ecx)
stats->free_size += block_size;
110523: 8b 55 ec mov -0x14(%ebp),%edx
110526: 01 51 30 add %edx,0x30(%ecx)
return( true );
110529: b0 01 mov $0x1,%al
}
11052b: 83 c4 10 add $0x10,%esp
11052e: 5b pop %ebx
11052f: 5e pop %esi
110530: 5f pop %edi
110531: c9 leave
110532: c3 ret
110533: 90 nop
* If NULL return true so a free on NULL is considered a valid release. This
* is a special case that could be handled by the in heap check how-ever that
* would result in false being returned which is wrong.
*/
if ( alloc_begin_ptr == NULL ) {
return true;
110534: b0 01 mov $0x1,%al
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
110536: 83 c4 10 add $0x10,%esp
110539: 5b pop %ebx
11053a: 5e pop %esi
11053b: 5f pop %edi
11053c: c9 leave
11053d: c3 ret
11053e: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
110540: 8b 41 08 mov 0x8(%ecx),%eax
new_block->next = next;
110543: 89 43 08 mov %eax,0x8(%ebx)
new_block->prev = block_before;
110546: 89 4b 0c mov %ecx,0xc(%ebx)
block_before->next = new_block;
110549: 89 59 08 mov %ebx,0x8(%ecx)
next->prev = new_block;
11054c: 89 58 0c mov %ebx,0xc(%eax)
next_block->prev_size = size;
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
11054f: 8b 45 ec mov -0x14(%ebp),%eax
110552: 83 c8 01 or $0x1,%eax
110555: 89 43 04 mov %eax,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
110558: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = block_size;
11055c: 8b 45 ec mov -0x14(%ebp),%eax
11055f: 89 02 mov %eax,(%edx)
/* Statistics */
++stats->free_blocks;
110561: 8b 41 38 mov 0x38(%ecx),%eax
110564: 40 inc %eax
110565: 89 41 38 mov %eax,0x38(%ecx)
if ( stats->max_free_blocks < stats->free_blocks ) {
110568: 3b 41 3c cmp 0x3c(%ecx),%eax
11056b: 76 b0 jbe 11051d <_Heap_Free+0xe9>
stats->max_free_blocks = stats->free_blocks;
11056d: 89 41 3c mov %eax,0x3c(%ecx)
110570: eb ab jmp 11051d <_Heap_Free+0xe9>
110572: 66 90 xchg %ax,%ax
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
110574: c6 45 eb 00 movb $0x0,-0x15(%ebp)
110578: e9 2d ff ff ff jmp 1104aa <_Heap_Free+0x76>
11057d: 8d 76 00 lea 0x0(%esi),%esi
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
110580: 8b 45 ec mov -0x14(%ebp),%eax
110583: 03 45 f0 add -0x10(%ebp),%eax
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
110586: 89 c6 mov %eax,%esi
110588: 83 ce 01 or $0x1,%esi
11058b: 89 73 04 mov %esi,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
11058e: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = size;
110592: 89 02 mov %eax,(%edx)
110594: eb 87 jmp 11051d <_Heap_Free+0xe9>
0010ba04 <_Heap_Get_first_and_last_block>:
uintptr_t page_size,
uintptr_t min_block_size,
Heap_Block **first_block_ptr,
Heap_Block **last_block_ptr
)
{
10ba04: 55 push %ebp
10ba05: 89 e5 mov %esp,%ebp
10ba07: 57 push %edi
10ba08: 56 push %esi
10ba09: 53 push %ebx
10ba0a: 8b 4d 08 mov 0x8(%ebp),%ecx
10ba0d: 8b 7d 0c mov 0xc(%ebp),%edi
uintptr_t const heap_area_end = heap_area_begin + heap_area_size;
10ba10: 8d 34 0f lea (%edi,%ecx,1),%esi
uintptr_t const alloc_area_begin =
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
10ba13: 8d 59 08 lea 0x8(%ecx),%ebx
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
10ba16: 89 d8 mov %ebx,%eax
10ba18: 31 d2 xor %edx,%edx
10ba1a: f7 75 10 divl 0x10(%ebp)
if ( remainder != 0 ) {
10ba1d: 85 d2 test %edx,%edx
10ba1f: 74 05 je 10ba26 <_Heap_Get_first_and_last_block+0x22>
return value - remainder + alignment;
10ba21: 03 5d 10 add 0x10(%ebp),%ebx
10ba24: 29 d3 sub %edx,%ebx
_Heap_Align_down( heap_area_size - overhead, page_size );
Heap_Block *const first_block = (Heap_Block *) first_block_begin;
Heap_Block *const last_block =
_Heap_Block_at( first_block, first_block_size );
if (
10ba26: 39 f1 cmp %esi,%ecx
10ba28: 77 2e ja 10ba58 <_Heap_Get_first_and_last_block+0x54>
uintptr_t const alloc_area_begin =
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const first_block_begin =
alloc_area_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const overhead =
HEAP_BLOCK_HEADER_SIZE + (first_block_begin - heap_area_begin);
10ba2a: 8d 73 f8 lea -0x8(%ebx),%esi
uintptr_t const heap_area_end = heap_area_begin + heap_area_size;
uintptr_t const alloc_area_begin =
_Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const first_block_begin =
alloc_area_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const overhead =
10ba2d: 29 cb sub %ecx,%ebx
Heap_Block *const last_block =
_Heap_Block_at( first_block, first_block_size );
if (
heap_area_end < heap_area_begin
|| heap_area_size <= overhead
10ba2f: 39 df cmp %ebx,%edi
10ba31: 76 25 jbe 10ba58 <_Heap_Get_first_and_last_block+0x54>
uintptr_t const first_block_begin =
alloc_area_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const overhead =
HEAP_BLOCK_HEADER_SIZE + (first_block_begin - heap_area_begin);
uintptr_t const first_block_size =
_Heap_Align_down( heap_area_size - overhead, page_size );
10ba33: 29 df sub %ebx,%edi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
10ba35: 89 f8 mov %edi,%eax
10ba37: 31 d2 xor %edx,%edx
10ba39: f7 75 10 divl 0x10(%ebp)
10ba3c: 29 d7 sub %edx,%edi
_Heap_Block_at( first_block, first_block_size );
if (
heap_area_end < heap_area_begin
|| heap_area_size <= overhead
|| first_block_size < min_block_size
10ba3e: 39 7d 14 cmp %edi,0x14(%ebp)
10ba41: 77 15 ja 10ba58 <_Heap_Get_first_and_last_block+0x54>
) {
/* Invalid area or area too small */
return false;
}
*first_block_ptr = first_block;
10ba43: 8b 45 18 mov 0x18(%ebp),%eax
10ba46: 89 30 mov %esi,(%eax)
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
10ba48: 01 f7 add %esi,%edi
10ba4a: 8b 45 1c mov 0x1c(%ebp),%eax
10ba4d: 89 38 mov %edi,(%eax)
*last_block_ptr = last_block;
return true;
10ba4f: b0 01 mov $0x1,%al
}
10ba51: 5b pop %ebx
10ba52: 5e pop %esi
10ba53: 5f pop %edi
10ba54: c9 leave
10ba55: c3 ret
10ba56: 66 90 xchg %ax,%ax
heap_area_end < heap_area_begin
|| heap_area_size <= overhead
|| first_block_size < min_block_size
) {
/* Invalid area or area too small */
return false;
10ba58: 31 c0 xor %eax,%eax
*first_block_ptr = first_block;
*last_block_ptr = last_block;
return true;
}
10ba5a: 5b pop %ebx
10ba5b: 5e pop %esi
10ba5c: 5f pop %edi
10ba5d: c9 leave
10ba5e: c3 ret
001141b8 <_Heap_Get_free_information>:
void _Heap_Get_free_information(
Heap_Control *the_heap,
Heap_Information *info
)
{
1141b8: 55 push %ebp
1141b9: 89 e5 mov %esp,%ebp
1141bb: 57 push %edi
1141bc: 56 push %esi
1141bd: 53 push %ebx
1141be: 8b 7d 0c mov 0xc(%ebp),%edi
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Free_list_tail(the_heap);
info->number = 0;
1141c1: c7 07 00 00 00 00 movl $0x0,(%edi)
info->largest = 0;
1141c7: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
info->total = 0;
1141ce: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
info->number++;
info->total += the_size;
if ( info->largest < the_size )
info->largest = the_size;
}
}
1141d5: 8b 45 08 mov 0x8(%ebp),%eax
1141d8: 8b 50 08 mov 0x8(%eax),%edx
info->number = 0;
info->largest = 0;
info->total = 0;
for(the_block = _Heap_Free_list_first(the_heap);
1141db: 39 d0 cmp %edx,%eax
1141dd: 74 31 je 114210 <_Heap_Get_free_information+0x58>
1141df: b9 01 00 00 00 mov $0x1,%ecx
1141e4: 31 f6 xor %esi,%esi
1141e6: 31 db xor %ebx,%ebx
1141e8: eb 07 jmp 1141f1 <_Heap_Get_free_information+0x39>
1141ea: 66 90 xchg %ax,%ax
1141ec: 8b 77 04 mov 0x4(%edi),%esi
1141ef: 89 c1 mov %eax,%ecx
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
1141f1: 8b 42 04 mov 0x4(%edx),%eax
1141f4: 83 e0 fe and $0xfffffffe,%eax
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
info->number++;
info->total += the_size;
1141f7: 01 c3 add %eax,%ebx
if ( info->largest < the_size )
1141f9: 39 f0 cmp %esi,%eax
1141fb: 76 03 jbe 114200 <_Heap_Get_free_information+0x48>
info->largest = the_size;
1141fd: 89 47 04 mov %eax,0x4(%edi)
info->largest = 0;
info->total = 0;
for(the_block = _Heap_Free_list_first(the_heap);
the_block != tail;
the_block = the_block->next)
114200: 8b 52 08 mov 0x8(%edx),%edx
114203: 8d 41 01 lea 0x1(%ecx),%eax
info->number = 0;
info->largest = 0;
info->total = 0;
for(the_block = _Heap_Free_list_first(the_heap);
114206: 39 55 08 cmp %edx,0x8(%ebp)
114209: 75 e1 jne 1141ec <_Heap_Get_free_information+0x34>
11420b: 89 0f mov %ecx,(%edi)
11420d: 89 5f 08 mov %ebx,0x8(%edi)
info->number++;
info->total += the_size;
if ( info->largest < the_size )
info->largest = the_size;
}
}
114210: 5b pop %ebx
114211: 5e pop %esi
114212: 5f pop %edi
114213: c9 leave
114214: c3 ret
00110f50 <_Heap_Get_information>:
void _Heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
110f50: 55 push %ebp
110f51: 89 e5 mov %esp,%ebp
110f53: 57 push %edi
110f54: 56 push %esi
110f55: 53 push %ebx
110f56: 83 ec 04 sub $0x4,%esp
110f59: 8b 45 08 mov 0x8(%ebp),%eax
110f5c: 8b 5d 0c mov 0xc(%ebp),%ebx
Heap_Block *the_block = the_heap->first_block;
110f5f: 8b 50 20 mov 0x20(%eax),%edx
Heap_Block *const end = the_heap->last_block;
110f62: 8b 40 24 mov 0x24(%eax),%eax
110f65: 89 45 f0 mov %eax,-0x10(%ebp)
memset(the_info, 0, sizeof(*the_info));
110f68: b9 18 00 00 00 mov $0x18,%ecx
110f6d: 31 c0 xor %eax,%eax
110f6f: 89 df mov %ebx,%edi
110f71: f3 aa rep stos %al,%es:(%edi)
while ( the_block != end ) {
110f73: 3b 55 f0 cmp -0x10(%ebp),%edx
110f76: 74 38 je 110fb0 <_Heap_Get_information+0x60><== NEVER TAKEN
110f78: 8b 7a 04 mov 0x4(%edx),%edi
110f7b: eb 18 jmp 110f95 <_Heap_Get_information+0x45>
110f7d: 8d 76 00 lea 0x0(%esi),%esi
uintptr_t const the_size = _Heap_Block_size(the_block);
Heap_Block *const next_block = _Heap_Block_at(the_block, the_size);
Heap_Information *info;
if ( _Heap_Is_prev_used(next_block) )
info = &the_info->Used;
110f80: 8d 43 0c lea 0xc(%ebx),%eax
else
info = &the_info->Free;
info->number++;
110f83: ff 00 incl (%eax)
info->total += the_size;
110f85: 01 48 08 add %ecx,0x8(%eax)
if ( info->largest < the_size )
110f88: 39 48 04 cmp %ecx,0x4(%eax)
110f8b: 73 03 jae 110f90 <_Heap_Get_information+0x40>
info->largest = the_size;
110f8d: 89 48 04 mov %ecx,0x4(%eax)
Heap_Block *the_block = the_heap->first_block;
Heap_Block *const end = the_heap->last_block;
memset(the_info, 0, sizeof(*the_info));
while ( the_block != end ) {
110f90: 39 75 f0 cmp %esi,-0x10(%ebp)
110f93: 74 1b je 110fb0 <_Heap_Get_information+0x60>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
110f95: 89 f9 mov %edi,%ecx
110f97: 83 e1 fe and $0xfffffffe,%ecx
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
110f9a: 8d 34 0a lea (%edx,%ecx,1),%esi
110f9d: 89 f2 mov %esi,%edx
if ( info->largest < the_size )
info->largest = the_size;
the_block = next_block;
}
}
110f9f: 8b 7e 04 mov 0x4(%esi),%edi
while ( the_block != end ) {
uintptr_t const the_size = _Heap_Block_size(the_block);
Heap_Block *const next_block = _Heap_Block_at(the_block, the_size);
Heap_Information *info;
if ( _Heap_Is_prev_used(next_block) )
110fa2: f7 c7 01 00 00 00 test $0x1,%edi
110fa8: 75 d6 jne 110f80 <_Heap_Get_information+0x30>
info = &the_info->Used;
else
info = &the_info->Free;
110faa: 89 d8 mov %ebx,%eax
110fac: eb d5 jmp 110f83 <_Heap_Get_information+0x33>
110fae: 66 90 xchg %ax,%ax
if ( info->largest < the_size )
info->largest = the_size;
the_block = next_block;
}
}
110fb0: 58 pop %eax
110fb1: 5b pop %ebx
110fb2: 5e pop %esi
110fb3: 5f pop %edi
110fb4: c9 leave
110fb5: c3 ret
0011e098 <_Heap_Resize_block>:
void *alloc_begin_ptr,
uintptr_t new_alloc_size,
uintptr_t *old_size,
uintptr_t *new_size
)
{
11e098: 55 push %ebp
11e099: 89 e5 mov %esp,%ebp
11e09b: 57 push %edi
11e09c: 56 push %esi
11e09d: 53 push %ebx
11e09e: 83 ec 2c sub $0x2c,%esp
11e0a1: 8b 5d 08 mov 0x8(%ebp),%ebx
11e0a4: 8b 75 0c mov 0xc(%ebp),%esi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
11e0a7: 8d 4e f8 lea -0x8(%esi),%ecx
11e0aa: 89 f0 mov %esi,%eax
11e0ac: 31 d2 xor %edx,%edx
11e0ae: f7 73 10 divl 0x10(%ebx)
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
11e0b1: 29 d1 sub %edx,%ecx
uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;
Heap_Block *const block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
*old_size = 0;
11e0b3: 8b 45 14 mov 0x14(%ebp),%eax
11e0b6: c7 00 00 00 00 00 movl $0x0,(%eax)
*new_size = 0;
11e0bc: 8b 55 18 mov 0x18(%ebp),%edx
11e0bf: c7 02 00 00 00 00 movl $0x0,(%edx)
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11e0c5: 39 4b 20 cmp %ecx,0x20(%ebx)
11e0c8: 77 05 ja 11e0cf <_Heap_Resize_block+0x37>
11e0ca: 39 4b 24 cmp %ecx,0x24(%ebx)
11e0cd: 73 0d jae 11e0dc <_Heap_Resize_block+0x44>
new_alloc_size,
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
11e0cf: b8 02 00 00 00 mov $0x2,%eax
}
11e0d4: 8d 65 f4 lea -0xc(%ebp),%esp
11e0d7: 5b pop %ebx
11e0d8: 5e pop %esi
11e0d9: 5f pop %edi
11e0da: c9 leave
11e0db: c3 ret
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
11e0dc: 8b 41 04 mov 0x4(%ecx),%eax
11e0df: 83 e0 fe and $0xfffffffe,%eax
{
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t block_size = _Heap_Block_size( block );
uintptr_t block_end = block_begin + block_size;
11e0e2: 8d 3c 01 lea (%ecx,%eax,1),%edi
11e0e5: 89 7d d4 mov %edi,-0x2c(%ebp)
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
11e0e8: 89 fa mov %edi,%edx
11e0ea: 29 f2 sub %esi,%edx
11e0ec: 83 c2 04 add $0x4,%edx
11e0ef: 89 55 e0 mov %edx,-0x20(%ebp)
11e0f2: 8b 57 04 mov 0x4(%edi),%edx
11e0f5: 83 e2 fe and $0xfffffffe,%edx
11e0f8: 89 55 d0 mov %edx,-0x30(%ebp)
RTEMS_INLINE_ROUTINE bool _Heap_Is_free(
const Heap_Block *block
)
{
return !_Heap_Is_used( block );
11e0fb: f6 44 17 04 01 testb $0x1,0x4(%edi,%edx,1)
11e100: 0f 94 45 df sete -0x21(%ebp)
bool next_block_is_free = _Heap_Is_free( next_block );;
_HAssert( _Heap_Is_block_in_heap( heap, next_block ) );
_HAssert( _Heap_Is_prev_used( next_block ) );
*old_size = alloc_size;
11e104: 8b 55 e0 mov -0x20(%ebp),%edx
11e107: 8b 7d 14 mov 0x14(%ebp),%edi
11e10a: 89 17 mov %edx,(%edi)
if ( next_block_is_free ) {
11e10c: 80 7d df 00 cmpb $0x0,-0x21(%ebp)
11e110: 75 6e jne 11e180 <_Heap_Resize_block+0xe8>
block_size += next_block_size;
alloc_size += next_block_size;
}
if ( new_alloc_size > alloc_size ) {
11e112: 8b 55 e0 mov -0x20(%ebp),%edx
11e115: 39 55 10 cmp %edx,0x10(%ebp)
11e118: 77 79 ja 11e193 <_Heap_Resize_block+0xfb>
return HEAP_RESIZE_UNSATISFIED;
}
if ( next_block_is_free ) {
11e11a: 80 7d df 00 cmpb $0x0,-0x21(%ebp)
11e11e: 74 31 je 11e151 <_Heap_Resize_block+0xb9>
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
11e120: 8b 79 04 mov 0x4(%ecx),%edi
11e123: 83 e7 01 and $0x1,%edi
block->size_and_flag = size | flag;
11e126: 09 c7 or %eax,%edi
11e128: 89 79 04 mov %edi,0x4(%ecx)
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
}
11e12b: 8b 7d d4 mov -0x2c(%ebp),%edi
11e12e: 8b 7f 08 mov 0x8(%edi),%edi
11e131: 89 7d e4 mov %edi,-0x1c(%ebp)
11e134: 8b 55 d4 mov -0x2c(%ebp),%edx
11e137: 8b 7a 0c mov 0xc(%edx),%edi
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
11e13a: 8b 55 e4 mov -0x1c(%ebp),%edx
11e13d: 89 57 08 mov %edx,0x8(%edi)
next->prev = prev;
11e140: 89 7a 0c mov %edi,0xc(%edx)
_Heap_Block_set_size( block, block_size );
_Heap_Free_list_remove( next_block );
next_block = _Heap_Block_at( block, block_size );
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
11e143: 83 4c 01 04 01 orl $0x1,0x4(%ecx,%eax,1)
/* Statistics */
--stats->free_blocks;
11e148: ff 4b 38 decl 0x38(%ebx)
stats->free_size -= next_block_size;
11e14b: 8b 7d d0 mov -0x30(%ebp),%edi
11e14e: 29 7b 30 sub %edi,0x30(%ebx)
}
block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size );
11e151: ff 75 10 pushl 0x10(%ebp)
11e154: 56 push %esi
11e155: 51 push %ecx
11e156: 53 push %ebx
11e157: e8 18 da fe ff call 10bb74 <_Heap_Block_allocate>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
11e15c: 8b 50 04 mov 0x4(%eax),%edx
11e15f: 83 e2 fe and $0xfffffffe,%edx
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
*new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS;
11e162: 29 f0 sub %esi,%eax
11e164: 8d 44 10 04 lea 0x4(%eax,%edx,1),%eax
11e168: 8b 55 18 mov 0x18(%ebp),%edx
11e16b: 89 02 mov %eax,(%edx)
/* Statistics */
++stats->resizes;
11e16d: ff 43 54 incl 0x54(%ebx)
11e170: 83 c4 10 add $0x10,%esp
return HEAP_RESIZE_SUCCESSFUL;
11e173: 31 c0 xor %eax,%eax
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
}
11e175: 8d 65 f4 lea -0xc(%ebp),%esp
11e178: 5b pop %ebx
11e179: 5e pop %esi
11e17a: 5f pop %edi
11e17b: c9 leave
11e17c: c3 ret
11e17d: 8d 76 00 lea 0x0(%esi),%esi
_HAssert( _Heap_Is_prev_used( next_block ) );
*old_size = alloc_size;
if ( next_block_is_free ) {
block_size += next_block_size;
11e180: 03 45 d0 add -0x30(%ebp),%eax
alloc_size += next_block_size;
11e183: 8b 7d d0 mov -0x30(%ebp),%edi
11e186: 01 fa add %edi,%edx
11e188: 89 55 e0 mov %edx,-0x20(%ebp)
}
if ( new_alloc_size > alloc_size ) {
11e18b: 8b 55 e0 mov -0x20(%ebp),%edx
11e18e: 39 55 10 cmp %edx,0x10(%ebp)
11e191: 76 87 jbe 11e11a <_Heap_Resize_block+0x82>
return HEAP_RESIZE_UNSATISFIED;
11e193: b8 01 00 00 00 mov $0x1,%eax
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
}
11e198: 8d 65 f4 lea -0xc(%ebp),%esp
11e19b: 5b pop %ebx
11e19c: 5e pop %esi
11e19d: 5f pop %edi
11e19e: c9 leave
11e19f: c3 ret
0011e1a0 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
11e1a0: 55 push %ebp
11e1a1: 89 e5 mov %esp,%ebp
11e1a3: 56 push %esi
11e1a4: 53 push %ebx
11e1a5: 8b 5d 08 mov 0x8(%ebp),%ebx
11e1a8: 8b 75 0c mov 0xc(%ebp),%esi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
11e1ab: 8d 4e f8 lea -0x8(%esi),%ecx
11e1ae: 89 f0 mov %esi,%eax
11e1b0: 31 d2 xor %edx,%edx
11e1b2: f7 73 10 divl 0x10(%ebx)
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
11e1b5: 29 d1 sub %edx,%ecx
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
11e1b7: 8b 43 20 mov 0x20(%ebx),%eax
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11e1ba: 39 c1 cmp %eax,%ecx
11e1bc: 72 07 jb 11e1c5 <_Heap_Size_of_alloc_area+0x25>
11e1be: 8b 53 24 mov 0x24(%ebx),%edx
11e1c1: 39 d1 cmp %edx,%ecx
11e1c3: 76 07 jbe 11e1cc <_Heap_Size_of_alloc_area+0x2c><== ALWAYS TAKEN
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
11e1c5: 31 c0 xor %eax,%eax
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
11e1c7: 5b pop %ebx
11e1c8: 5e pop %esi
11e1c9: c9 leave
11e1ca: c3 ret
11e1cb: 90 nop
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
11e1cc: 8b 59 04 mov 0x4(%ecx),%ebx
11e1cf: 83 e3 fe and $0xfffffffe,%ebx
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
11e1d2: 01 d9 add %ebx,%ecx
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11e1d4: 39 c8 cmp %ecx,%eax
11e1d6: 77 ed ja 11e1c5 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN
11e1d8: 39 ca cmp %ecx,%edx
11e1da: 72 e9 jb 11e1c5 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
11e1dc: f6 41 04 01 testb $0x1,0x4(%ecx)
11e1e0: 74 e3 je 11e1c5 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
11e1e2: 29 f1 sub %esi,%ecx
11e1e4: 8d 51 04 lea 0x4(%ecx),%edx
11e1e7: 8b 45 10 mov 0x10(%ebp),%eax
11e1ea: 89 10 mov %edx,(%eax)
return true;
11e1ec: b0 01 mov $0x1,%al
}
11e1ee: 5b pop %ebx
11e1ef: 5e pop %esi
11e1f0: c9 leave
11e1f1: c3 ret
0010c6dc <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
10c6dc: 55 push %ebp
10c6dd: 89 e5 mov %esp,%ebp
10c6df: 57 push %edi
10c6e0: 56 push %esi
10c6e1: 53 push %ebx
10c6e2: 83 ec 4c sub $0x4c,%esp
10c6e5: 8b 5d 08 mov 0x8(%ebp),%ebx
uintptr_t const page_size = heap->page_size;
10c6e8: 8b 43 10 mov 0x10(%ebx),%eax
10c6eb: 89 45 e0 mov %eax,-0x20(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10c6ee: 8b 53 14 mov 0x14(%ebx),%edx
10c6f1: 89 55 d0 mov %edx,-0x30(%ebp)
Heap_Block *const first_block = heap->first_block;
10c6f4: 8b 43 20 mov 0x20(%ebx),%eax
10c6f7: 89 45 dc mov %eax,-0x24(%ebp)
Heap_Block *const last_block = heap->last_block;
10c6fa: 8b 53 24 mov 0x24(%ebx),%edx
10c6fd: 89 55 cc mov %edx,-0x34(%ebp)
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
10c700: 80 7d 10 00 cmpb $0x0,0x10(%ebp)
10c704: 74 1a je 10c720 <_Heap_Walk+0x44>
10c706: c7 45 d8 94 c6 10 00 movl $0x10c694,-0x28(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
10c70d: 83 3d 40 8b 12 00 03 cmpl $0x3,0x128b40
10c714: 74 1a je 10c730 <_Heap_Walk+0x54> <== ALWAYS TAKEN
}
block = next_block;
} while ( block != first_block );
return true;
10c716: b0 01 mov $0x1,%al
}
10c718: 8d 65 f4 lea -0xc(%ebp),%esp
10c71b: 5b pop %ebx
10c71c: 5e pop %esi
10c71d: 5f pop %edi
10c71e: c9 leave
10c71f: c3 ret
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
10c720: c7 45 d8 8c c6 10 00 movl $0x10c68c,-0x28(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
10c727: 83 3d 40 8b 12 00 03 cmpl $0x3,0x128b40
10c72e: 75 e6 jne 10c716 <_Heap_Walk+0x3a>
Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
(*printer)(
10c730: 52 push %edx
10c731: ff 73 0c pushl 0xc(%ebx)
10c734: ff 73 08 pushl 0x8(%ebx)
10c737: ff 75 cc pushl -0x34(%ebp)
10c73a: ff 75 dc pushl -0x24(%ebp)
10c73d: ff 73 1c pushl 0x1c(%ebx)
10c740: ff 73 18 pushl 0x18(%ebx)
10c743: ff 75 d0 pushl -0x30(%ebp)
10c746: ff 75 e0 pushl -0x20(%ebp)
10c749: 68 c4 0f 12 00 push $0x120fc4
10c74e: 6a 00 push $0x0
10c750: ff 75 0c pushl 0xc(%ebp)
10c753: ff 55 d8 call *-0x28(%ebp)
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
10c756: 83 c4 30 add $0x30,%esp
10c759: 8b 45 e0 mov -0x20(%ebp),%eax
10c75c: 85 c0 test %eax,%eax
10c75e: 74 70 je 10c7d0 <_Heap_Walk+0xf4>
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
10c760: f6 45 e0 03 testb $0x3,-0x20(%ebp)
10c764: 75 72 jne 10c7d8 <_Heap_Walk+0xfc>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10c766: 8b 45 d0 mov -0x30(%ebp),%eax
10c769: 31 d2 xor %edx,%edx
10c76b: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
10c76e: 85 d2 test %edx,%edx
10c770: 75 72 jne 10c7e4 <_Heap_Walk+0x108>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
10c772: 8b 45 dc mov -0x24(%ebp),%eax
10c775: 83 c0 08 add $0x8,%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10c778: 31 d2 xor %edx,%edx
10c77a: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if (
10c77d: 85 d2 test %edx,%edx
10c77f: 75 6f jne 10c7f0 <_Heap_Walk+0x114>
block = next_block;
} while ( block != first_block );
return true;
}
10c781: 8b 45 dc mov -0x24(%ebp),%eax
10c784: 8b 40 04 mov 0x4(%eax),%eax
10c787: 89 45 e4 mov %eax,-0x1c(%ebp)
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
10c78a: a8 01 test $0x1,%al
10c78c: 0f 84 ce 02 00 00 je 10ca60 <_Heap_Walk+0x384>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10c792: 8b 55 cc mov -0x34(%ebp),%edx
10c795: 8b 42 04 mov 0x4(%edx),%eax
10c798: 83 e0 fe and $0xfffffffe,%eax
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
10c79b: 01 d0 add %edx,%eax
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
10c79d: f6 40 04 01 testb $0x1,0x4(%eax)
10c7a1: 74 25 je 10c7c8 <_Heap_Walk+0xec>
);
return false;
}
if (
10c7a3: 39 45 dc cmp %eax,-0x24(%ebp)
10c7a6: 74 54 je 10c7fc <_Heap_Walk+0x120>
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
10c7a8: 51 push %ecx
10c7a9: 68 e0 10 12 00 push $0x1210e0
10c7ae: 66 90 xchg %ax,%ax
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10c7b0: 6a 01 push $0x1
10c7b2: ff 75 0c pushl 0xc(%ebp)
10c7b5: ff 55 d8 call *-0x28(%ebp)
10c7b8: 83 c4 10 add $0x10,%esp
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
10c7bb: 31 c0 xor %eax,%eax
block = next_block;
} while ( block != first_block );
return true;
}
10c7bd: 8d 65 f4 lea -0xc(%ebp),%esp
10c7c0: 5b pop %ebx
10c7c1: 5e pop %esi
10c7c2: 5f pop %edi
10c7c3: c9 leave
10c7c4: c3 ret
10c7c5: 8d 76 00 lea 0x0(%esi),%esi
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
10c7c8: 53 push %ebx
10c7c9: 68 7a 0f 12 00 push $0x120f7a
10c7ce: eb e0 jmp 10c7b0 <_Heap_Walk+0xd4>
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
(*printer)( source, true, "page size is zero\n" );
10c7d0: 57 push %edi
10c7d1: 68 49 0f 12 00 push $0x120f49
10c7d6: eb d8 jmp 10c7b0 <_Heap_Walk+0xd4>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
10c7d8: ff 75 e0 pushl -0x20(%ebp)
10c7db: 68 5c 0f 12 00 push $0x120f5c
10c7e0: eb ce jmp 10c7b0 <_Heap_Walk+0xd4>
10c7e2: 66 90 xchg %ax,%ax
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
10c7e4: ff 75 d0 pushl -0x30(%ebp)
10c7e7: 68 58 10 12 00 push $0x121058
10c7ec: eb c2 jmp 10c7b0 <_Heap_Walk+0xd4>
10c7ee: 66 90 xchg %ax,%ax
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
10c7f0: ff 75 dc pushl -0x24(%ebp)
10c7f3: 68 7c 10 12 00 push $0x12107c
10c7f8: eb b6 jmp 10c7b0 <_Heap_Walk+0xd4>
10c7fa: 66 90 xchg %ax,%ax
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
10c7fc: 8b 43 10 mov 0x10(%ebx),%eax
10c7ff: 89 45 c8 mov %eax,-0x38(%ebp)
block = next_block;
} while ( block != first_block );
return true;
}
10c802: 8b 73 08 mov 0x8(%ebx),%esi
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
10c805: 39 f3 cmp %esi,%ebx
10c807: 74 65 je 10c86e <_Heap_Walk+0x192>
block = next_block;
} while ( block != first_block );
return true;
}
10c809: 8b 43 20 mov 0x20(%ebx),%eax
10c80c: 89 45 d4 mov %eax,-0x2c(%ebp)
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10c80f: 39 f0 cmp %esi,%eax
10c811: 0f 87 55 02 00 00 ja 10ca6c <_Heap_Walk+0x390> <== NEVER TAKEN
10c817: 8b 7b 24 mov 0x24(%ebx),%edi
10c81a: 39 f7 cmp %esi,%edi
10c81c: 0f 82 4a 02 00 00 jb 10ca6c <_Heap_Walk+0x390> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
10c822: 8d 46 08 lea 0x8(%esi),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10c825: 31 d2 xor %edx,%edx
10c827: f7 75 c8 divl -0x38(%ebp)
);
return false;
}
if (
10c82a: 85 d2 test %edx,%edx
10c82c: 0f 85 71 02 00 00 jne 10caa3 <_Heap_Walk+0x3c7> <== NEVER TAKEN
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10c832: 8b 46 04 mov 0x4(%esi),%eax
10c835: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10c838: f6 44 06 04 01 testb $0x1,0x4(%esi,%eax,1)
10c83d: 0f 85 6d 02 00 00 jne 10cab0 <_Heap_Walk+0x3d4> <== NEVER TAKEN
10c843: 89 da mov %ebx,%edx
10c845: 8d 76 00 lea 0x0(%esi),%esi
);
return false;
}
if ( free_block->prev != prev_block ) {
10c848: 8b 46 0c mov 0xc(%esi),%eax
10c84b: 39 d0 cmp %edx,%eax
10c84d: 0f 85 6a 02 00 00 jne 10cabd <_Heap_Walk+0x3e1>
return false;
}
prev_block = free_block;
free_block = free_block->next;
10c853: 8b 4e 08 mov 0x8(%esi),%ecx
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
10c856: 39 cb cmp %ecx,%ebx
10c858: 74 1a je 10c874 <_Heap_Walk+0x198>
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10c85a: 39 4d d4 cmp %ecx,-0x2c(%ebp)
10c85d: 0f 86 7d 01 00 00 jbe 10c9e0 <_Heap_Walk+0x304>
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
(*printer)(
10c863: 51 push %ecx
10c864: 68 10 11 12 00 push $0x121110
10c869: e9 42 ff ff ff jmp 10c7b0 <_Heap_Walk+0xd4>
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
10c86e: 8b 53 20 mov 0x20(%ebx),%edx
10c871: 89 55 d4 mov %edx,-0x2c(%ebp)
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10c874: 8b 7d dc mov -0x24(%ebp),%edi
10c877: 8b 45 d4 mov -0x2c(%ebp),%eax
10c87a: 66 90 xchg %ax,%ax
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10c87c: 8b 4d e4 mov -0x1c(%ebp),%ecx
10c87f: 83 e1 fe and $0xfffffffe,%ecx
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
10c882: 8d 34 39 lea (%ecx,%edi,1),%esi
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10c885: 39 f0 cmp %esi,%eax
10c887: 76 23 jbe 10c8ac <_Heap_Walk+0x1d0> <== ALWAYS TAKEN
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
(*printer)(
10c889: 83 ec 0c sub $0xc,%esp
10c88c: 56 push %esi
10c88d: 57 push %edi
10c88e: 68 94 11 12 00 push $0x121194
10c893: 90 nop
10c894: 6a 01 push $0x1
10c896: ff 75 0c pushl 0xc(%ebp)
10c899: ff 55 d8 call *-0x28(%ebp)
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
10c89c: 83 c4 20 add $0x20,%esp
10c89f: 31 c0 xor %eax,%eax
block = next_block;
} while ( block != first_block );
return true;
}
10c8a1: 8d 65 f4 lea -0xc(%ebp),%esp
10c8a4: 5b pop %ebx
10c8a5: 5e pop %esi
10c8a6: 5f pop %edi
10c8a7: c9 leave
10c8a8: c3 ret
10c8a9: 8d 76 00 lea 0x0(%esi),%esi
10c8ac: 39 73 24 cmp %esi,0x24(%ebx)
10c8af: 72 d8 jb 10c889 <_Heap_Walk+0x1ad>
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
10c8b1: 3b 7d cc cmp -0x34(%ebp),%edi
10c8b4: 0f 95 45 d4 setne -0x2c(%ebp)
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10c8b8: 89 c8 mov %ecx,%eax
10c8ba: 31 d2 xor %edx,%edx
10c8bc: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
10c8bf: 85 d2 test %edx,%edx
10c8c1: 74 0a je 10c8cd <_Heap_Walk+0x1f1>
10c8c3: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp)
10c8c7: 0f 85 a6 01 00 00 jne 10ca73 <_Heap_Walk+0x397>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
10c8cd: 39 4d d0 cmp %ecx,-0x30(%ebp)
10c8d0: 76 0a jbe 10c8dc <_Heap_Walk+0x200>
10c8d2: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp)
10c8d6: 0f 85 a6 01 00 00 jne 10ca82 <_Heap_Walk+0x3a6> <== ALWAYS TAKEN
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
10c8dc: 39 f7 cmp %esi,%edi
10c8de: 72 0a jb 10c8ea <_Heap_Walk+0x20e>
10c8e0: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp)
10c8e4: 0f 85 aa 01 00 00 jne 10ca94 <_Heap_Walk+0x3b8>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
10c8ea: 8b 55 e4 mov -0x1c(%ebp),%edx
10c8ed: 83 e2 01 and $0x1,%edx
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10c8f0: f6 46 04 01 testb $0x1,0x4(%esi)
10c8f4: 74 4e je 10c944 <_Heap_Walk+0x268>
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
10c8f6: 85 d2 test %edx,%edx
10c8f8: 74 2e je 10c928 <_Heap_Walk+0x24c>
(*printer)(
10c8fa: 83 ec 0c sub $0xc,%esp
10c8fd: 51 push %ecx
10c8fe: 57 push %edi
10c8ff: 68 ab 0f 12 00 push $0x120fab
10c904: 6a 00 push $0x0
10c906: ff 75 0c pushl 0xc(%ebp)
10c909: ff 55 d8 call *-0x28(%ebp)
10c90c: 83 c4 20 add $0x20,%esp
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10c90f: 39 75 dc cmp %esi,-0x24(%ebp)
10c912: 0f 84 fe fd ff ff je 10c716 <_Heap_Walk+0x3a>
10c918: 8b 56 04 mov 0x4(%esi),%edx
10c91b: 89 55 e4 mov %edx,-0x1c(%ebp)
10c91e: 8b 43 20 mov 0x20(%ebx),%eax
10c921: 89 f7 mov %esi,%edi
10c923: e9 54 ff ff ff jmp 10c87c <_Heap_Walk+0x1a0>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
10c928: 83 ec 08 sub $0x8,%esp
10c92b: ff 37 pushl (%edi)
10c92d: 51 push %ecx
10c92e: 57 push %edi
10c92f: 68 f8 12 12 00 push $0x1212f8
10c934: 6a 00 push $0x0
10c936: ff 75 0c pushl 0xc(%ebp)
10c939: ff 55 d8 call *-0x28(%ebp)
10c93c: 83 c4 20 add $0x20,%esp
10c93f: eb ce jmp 10c90f <_Heap_Walk+0x233>
10c941: 8d 76 00 lea 0x0(%esi),%esi
block = next_block;
} while ( block != first_block );
return true;
}
10c944: 8b 43 08 mov 0x8(%ebx),%eax
10c947: 89 45 b4 mov %eax,-0x4c(%ebp)
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
10c94a: 8b 47 08 mov 0x8(%edi),%eax
10c94d: 89 45 e4 mov %eax,-0x1c(%ebp)
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
10c950: 39 43 0c cmp %eax,0xc(%ebx)
10c953: 0f 84 cb 00 00 00 je 10ca24 <_Heap_Walk+0x348>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
10c959: 39 c3 cmp %eax,%ebx
10c95b: 0f 84 db 00 00 00 je 10ca3c <_Heap_Walk+0x360>
10c961: c7 45 c8 49 0e 12 00 movl $0x120e49,-0x38(%ebp)
false,
"block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n",
block,
block_size,
block->prev,
block->prev == first_free_block ?
10c968: 8b 47 0c mov 0xc(%edi),%eax
10c96b: 89 45 d4 mov %eax,-0x2c(%ebp)
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
10c96e: 39 45 b4 cmp %eax,-0x4c(%ebp)
10c971: 0f 84 b9 00 00 00 je 10ca30 <_Heap_Walk+0x354>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10c977: 39 c3 cmp %eax,%ebx
10c979: 0f 84 c9 00 00 00 je 10ca48 <_Heap_Walk+0x36c>
10c97f: b8 49 0e 12 00 mov $0x120e49,%eax
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
10c984: 83 ec 0c sub $0xc,%esp
10c987: ff 75 c8 pushl -0x38(%ebp)
10c98a: ff 75 e4 pushl -0x1c(%ebp)
10c98d: 50 push %eax
10c98e: ff 75 d4 pushl -0x2c(%ebp)
10c991: 51 push %ecx
10c992: 57 push %edi
10c993: 68 54 12 12 00 push $0x121254
10c998: 6a 00 push $0x0
10c99a: ff 75 0c pushl 0xc(%ebp)
10c99d: 89 55 c4 mov %edx,-0x3c(%ebp)
10c9a0: 89 4d c0 mov %ecx,-0x40(%ebp)
10c9a3: ff 55 d8 call *-0x28(%ebp)
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
10c9a6: 8b 06 mov (%esi),%eax
10c9a8: 83 c4 30 add $0x30,%esp
10c9ab: 8b 4d c0 mov -0x40(%ebp),%ecx
10c9ae: 39 c1 cmp %eax,%ecx
10c9b0: 8b 55 c4 mov -0x3c(%ebp),%edx
10c9b3: 75 5f jne 10ca14 <_Heap_Walk+0x338>
);
return false;
}
if ( !prev_used ) {
10c9b5: 85 d2 test %edx,%edx
10c9b7: 0f 84 97 00 00 00 je 10ca54 <_Heap_Walk+0x378>
block = next_block;
} while ( block != first_block );
return true;
}
10c9bd: 8b 43 08 mov 0x8(%ebx),%eax
)
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
10c9c0: 39 c3 cmp %eax,%ebx
10c9c2: 74 0f je 10c9d3 <_Heap_Walk+0x2f7> <== NEVER TAKEN
if ( free_block == block ) {
10c9c4: 39 c7 cmp %eax,%edi
10c9c6: 0f 84 43 ff ff ff je 10c90f <_Heap_Walk+0x233>
return true;
}
free_block = free_block->next;
10c9cc: 8b 40 08 mov 0x8(%eax),%eax
)
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
10c9cf: 39 c3 cmp %eax,%ebx
10c9d1: 75 f1 jne 10c9c4 <_Heap_Walk+0x2e8>
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10c9d3: 57 push %edi
10c9d4: 68 20 13 12 00 push $0x121320
10c9d9: e9 d2 fd ff ff jmp 10c7b0 <_Heap_Walk+0xd4>
10c9de: 66 90 xchg %ax,%ax
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10c9e0: 39 f9 cmp %edi,%ecx
10c9e2: 0f 87 7b fe ff ff ja 10c863 <_Heap_Walk+0x187> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
10c9e8: 8d 41 08 lea 0x8(%ecx),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10c9eb: 31 d2 xor %edx,%edx
10c9ed: f7 75 c8 divl -0x38(%ebp)
);
return false;
}
if (
10c9f0: 85 d2 test %edx,%edx
10c9f2: 0f 85 ad 00 00 00 jne 10caa5 <_Heap_Walk+0x3c9>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10c9f8: 8b 41 04 mov 0x4(%ecx),%eax
10c9fb: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10c9fe: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1)
10ca03: 0f 85 a9 00 00 00 jne 10cab2 <_Heap_Walk+0x3d6>
10ca09: 89 f2 mov %esi,%edx
10ca0b: 89 ce mov %ecx,%esi
10ca0d: e9 36 fe ff ff jmp 10c848 <_Heap_Walk+0x16c>
10ca12: 66 90 xchg %ax,%ax
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
10ca14: 52 push %edx
10ca15: 56 push %esi
10ca16: 50 push %eax
10ca17: 51 push %ecx
10ca18: 57 push %edi
10ca19: 68 8c 12 12 00 push $0x12128c
10ca1e: e9 71 fe ff ff jmp 10c894 <_Heap_Walk+0x1b8>
10ca23: 90 nop
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
10ca24: c7 45 c8 16 0f 12 00 movl $0x120f16,-0x38(%ebp)
10ca2b: e9 38 ff ff ff jmp 10c968 <_Heap_Walk+0x28c>
10ca30: b8 2f 0f 12 00 mov $0x120f2f,%eax
10ca35: e9 4a ff ff ff jmp 10c984 <_Heap_Walk+0x2a8>
10ca3a: 66 90 xchg %ax,%ax
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
10ca3c: c7 45 c8 25 0f 12 00 movl $0x120f25,-0x38(%ebp)
10ca43: e9 20 ff ff ff jmp 10c968 <_Heap_Walk+0x28c>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10ca48: b8 3f 0f 12 00 mov $0x120f3f,%eax
10ca4d: e9 32 ff ff ff jmp 10c984 <_Heap_Walk+0x2a8>
10ca52: 66 90 xchg %ax,%ax
return false;
}
if ( !prev_used ) {
(*printer)(
10ca54: 57 push %edi
10ca55: 68 c8 12 12 00 push $0x1212c8
10ca5a: e9 51 fd ff ff jmp 10c7b0 <_Heap_Walk+0xd4>
10ca5f: 90 nop
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
10ca60: 56 push %esi
10ca61: 68 b0 10 12 00 push $0x1210b0
10ca66: e9 45 fd ff ff jmp 10c7b0 <_Heap_Walk+0xd4>
10ca6b: 90 nop
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10ca6c: 89 f1 mov %esi,%ecx <== NOT EXECUTED
10ca6e: e9 f0 fd ff ff jmp 10c863 <_Heap_Walk+0x187> <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
10ca73: 83 ec 0c sub $0xc,%esp
10ca76: 51 push %ecx
10ca77: 57 push %edi
10ca78: 68 c4 11 12 00 push $0x1211c4
10ca7d: e9 12 fe ff ff jmp 10c894 <_Heap_Walk+0x1b8>
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
(*printer)(
10ca82: 83 ec 08 sub $0x8,%esp
10ca85: ff 75 d0 pushl -0x30(%ebp)
10ca88: 51 push %ecx
10ca89: 57 push %edi
10ca8a: 68 f4 11 12 00 push $0x1211f4
10ca8f: e9 00 fe ff ff jmp 10c894 <_Heap_Walk+0x1b8>
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
(*printer)(
10ca94: 83 ec 0c sub $0xc,%esp
10ca97: 56 push %esi
10ca98: 57 push %edi
10ca99: 68 20 12 12 00 push $0x121220
10ca9e: e9 f1 fd ff ff jmp 10c894 <_Heap_Walk+0x1b8>
);
return false;
}
if (
10caa3: 89 f1 mov %esi,%ecx <== NOT EXECUTED
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
10caa5: 51 push %ecx
10caa6: 68 30 11 12 00 push $0x121130
10caab: e9 00 fd ff ff jmp 10c7b0 <_Heap_Walk+0xd4>
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10cab0: 89 f1 mov %esi,%ecx <== NOT EXECUTED
(*printer)(
10cab2: 51 push %ecx
10cab3: 68 8f 0f 12 00 push $0x120f8f
10cab8: e9 f3 fc ff ff jmp 10c7b0 <_Heap_Walk+0xd4>
return false;
}
if ( free_block->prev != prev_block ) {
(*printer)(
10cabd: 83 ec 0c sub $0xc,%esp
10cac0: 50 push %eax
10cac1: 56 push %esi
10cac2: 68 60 11 12 00 push $0x121160
10cac7: e9 c8 fd ff ff jmp 10c894 <_Heap_Walk+0x1b8>
0010b294 <_IO_Initialize_all_drivers>:
*
* Output Parameters: NONE
*/
void _IO_Initialize_all_drivers( void )
{
10b294: 55 push %ebp
10b295: 89 e5 mov %esp,%ebp
10b297: 53 push %ebx
10b298: 83 ec 04 sub $0x4,%esp
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
10b29b: 8b 0d 40 68 12 00 mov 0x126840,%ecx
10b2a1: 85 c9 test %ecx,%ecx
10b2a3: 74 1a je 10b2bf <_IO_Initialize_all_drivers+0x2b><== NEVER TAKEN
10b2a5: 31 db xor %ebx,%ebx
10b2a7: 90 nop
(void) rtems_io_initialize( major, 0, NULL );
10b2a8: 52 push %edx
10b2a9: 6a 00 push $0x0
10b2ab: 6a 00 push $0x0
10b2ad: 53 push %ebx
10b2ae: e8 39 4b 00 00 call 10fdec <rtems_io_initialize>
void _IO_Initialize_all_drivers( void )
{
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
10b2b3: 43 inc %ebx
10b2b4: 83 c4 10 add $0x10,%esp
10b2b7: 39 1d 40 68 12 00 cmp %ebx,0x126840
10b2bd: 77 e9 ja 10b2a8 <_IO_Initialize_all_drivers+0x14>
(void) rtems_io_initialize( major, 0, NULL );
}
10b2bf: 8b 5d fc mov -0x4(%ebp),%ebx
10b2c2: c9 leave
10b2c3: c3 ret
0010b1fc <_IO_Manager_initialization>:
* workspace.
*
*/
void _IO_Manager_initialization(void)
{
10b1fc: 55 push %ebp
10b1fd: 89 e5 mov %esp,%ebp
10b1ff: 57 push %edi
10b200: 56 push %esi
10b201: 53 push %ebx
10b202: 83 ec 1c sub $0x1c,%esp
uint32_t index;
rtems_driver_address_table *driver_table;
uint32_t drivers_in_table;
uint32_t number_of_drivers;
driver_table = Configuration.Device_driver_table;
10b205: 8b 1d 34 23 12 00 mov 0x122334,%ebx
drivers_in_table = Configuration.number_of_device_drivers;
10b20b: a1 30 23 12 00 mov 0x122330,%eax
10b210: 89 45 e4 mov %eax,-0x1c(%ebp)
number_of_drivers = Configuration.maximum_drivers;
10b213: 8b 35 2c 23 12 00 mov 0x12232c,%esi
/*
* If the user claims there are less drivers than are actually in
* the table, then let's just go with the table's count.
*/
if ( number_of_drivers <= drivers_in_table )
10b219: 39 f0 cmp %esi,%eax
10b21b: 73 5f jae 10b27c <_IO_Manager_initialization+0x80>
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
_Workspace_Allocate_or_fatal_error(
10b21d: 8d 0c 76 lea (%esi,%esi,2),%ecx
10b220: c1 e1 03 shl $0x3,%ecx
10b223: 83 ec 0c sub $0xc,%esp
10b226: 51 push %ecx
10b227: 89 4d dc mov %ecx,-0x24(%ebp)
10b22a: e8 75 2a 00 00 call 10dca4 <_Workspace_Allocate_or_fatal_error>
10b22f: 89 c2 mov %eax,%edx
/*
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
10b231: a3 44 68 12 00 mov %eax,0x126844
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
10b236: 89 35 40 68 12 00 mov %esi,0x126840
memset(
10b23c: 31 c0 xor %eax,%eax
10b23e: 8b 4d dc mov -0x24(%ebp),%ecx
10b241: 89 d7 mov %edx,%edi
10b243: f3 aa rep stos %al,%es:(%edi)
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
10b245: 83 c4 10 add $0x10,%esp
10b248: 8b 45 e4 mov -0x1c(%ebp),%eax
10b24b: 85 c0 test %eax,%eax
10b24d: 74 25 je 10b274 <_IO_Manager_initialization+0x78><== NEVER TAKEN
10b24f: a1 44 68 12 00 mov 0x126844,%eax
10b254: 89 45 e0 mov %eax,-0x20(%ebp)
10b257: 31 c0 xor %eax,%eax
10b259: 31 d2 xor %edx,%edx
10b25b: 90 nop
_IO_Driver_address_table[index] = driver_table[index];
10b25c: 8b 7d e0 mov -0x20(%ebp),%edi
10b25f: 01 c7 add %eax,%edi
10b261: 8d 34 03 lea (%ebx,%eax,1),%esi
10b264: b9 06 00 00 00 mov $0x6,%ecx
10b269: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
memset(
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
10b26b: 42 inc %edx
10b26c: 83 c0 18 add $0x18,%eax
10b26f: 39 55 e4 cmp %edx,-0x1c(%ebp)
10b272: 77 e8 ja 10b25c <_IO_Manager_initialization+0x60>
_IO_Driver_address_table[index] = driver_table[index];
}
10b274: 8d 65 f4 lea -0xc(%ebp),%esp
10b277: 5b pop %ebx
10b278: 5e pop %esi
10b279: 5f pop %edi
10b27a: c9 leave
10b27b: c3 ret
* If the maximum number of driver is the same as the number in the
* table, then we do not have to copy the driver table. They can't
* register any dynamically.
*/
if ( number_of_drivers == drivers_in_table ) {
_IO_Driver_address_table = driver_table;
10b27c: 89 1d 44 68 12 00 mov %ebx,0x126844
_IO_Number_of_drivers = number_of_drivers;
10b282: 8b 45 e4 mov -0x1c(%ebp),%eax
10b285: a3 40 68 12 00 mov %eax,0x126840
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
_IO_Driver_address_table[index] = driver_table[index];
}
10b28a: 8d 65 f4 lea -0xc(%ebp),%esp
10b28d: 5b pop %ebx
10b28e: 5e pop %esi
10b28f: 5f pop %edi
10b290: c9 leave
10b291: c3 ret
0010bc68 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10bc68: 55 push %ebp
10bc69: 89 e5 mov %esp,%ebp
10bc6b: 53 push %ebx
10bc6c: 83 ec 08 sub $0x8,%esp
10bc6f: 8b 45 08 mov 0x8(%ebp),%eax
10bc72: 8b 55 0c mov 0xc(%ebp),%edx
10bc75: 8b 5d 10 mov 0x10(%ebp),%ebx
_Internal_errors_What_happened.the_source = the_source;
10bc78: a3 94 65 12 00 mov %eax,0x126594
_Internal_errors_What_happened.is_internal = is_internal;
10bc7d: 88 15 98 65 12 00 mov %dl,0x126598
_Internal_errors_What_happened.the_error = the_error;
10bc83: 89 1d 9c 65 12 00 mov %ebx,0x12659c
_User_extensions_Fatal( the_source, is_internal, the_error );
10bc89: 53 push %ebx
10bc8a: 0f b6 d2 movzbl %dl,%edx
10bc8d: 52 push %edx
10bc8e: 50 push %eax
10bc8f: e8 10 1c 00 00 call 10d8a4 <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
10bc94: c7 05 80 66 12 00 05 movl $0x5,0x126680 <== NOT EXECUTED
10bc9b: 00 00 00
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
10bc9e: fa cli <== NOT EXECUTED
10bc9f: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10bca1: f4 hlt <== NOT EXECUTED
10bca2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10bca5: eb fe jmp 10bca5 <_Internal_error_Occurred+0x3d><== NOT EXECUTED
00110598 <_Objects_API_maximum_class>:
#include <rtems/score/object.h>
unsigned int _Objects_API_maximum_class(
uint32_t api
)
{
110598: 55 push %ebp
110599: 89 e5 mov %esp,%ebp
11059b: 8b 45 08 mov 0x8(%ebp),%eax
11059e: 48 dec %eax
11059f: 83 f8 02 cmp $0x2,%eax
1105a2: 77 0c ja 1105b0 <_Objects_API_maximum_class+0x18>
1105a4: 8b 04 85 30 04 12 00 mov 0x120430(,%eax,4),%eax
case OBJECTS_NO_API:
default:
break;
}
return 0;
}
1105ab: c9 leave
1105ac: c3 ret
1105ad: 8d 76 00 lea 0x0(%esi),%esi
#include <rtems/score/object.h>
unsigned int _Objects_API_maximum_class(
uint32_t api
)
{
1105b0: 31 c0 xor %eax,%eax
case OBJECTS_NO_API:
default:
break;
}
return 0;
}
1105b2: c9 leave
1105b3: c3 ret
0010bcf8 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
10bcf8: 55 push %ebp
10bcf9: 89 e5 mov %esp,%ebp
10bcfb: 56 push %esi
10bcfc: 53 push %ebx
10bcfd: 8b 5d 08 mov 0x8(%ebp),%ebx
* If the application is using the optional manager stubs and
* still attempts to create the object, the information block
* should be all zeroed out because it is in the BSS. So let's
* check that code for this manager is even present.
*/
if ( information->size == 0 )
10bd00: 8b 43 18 mov 0x18(%ebx),%eax
10bd03: 85 c0 test %eax,%eax
10bd05: 75 0d jne 10bd14 <_Objects_Allocate+0x1c><== ALWAYS TAKEN
return NULL;
10bd07: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
);
}
#endif
return the_object;
}
10bd09: 89 c8 mov %ecx,%eax
10bd0b: 8d 65 f8 lea -0x8(%ebp),%esp
10bd0e: 5b pop %ebx
10bd0f: 5e pop %esi
10bd10: c9 leave
10bd11: c3 ret
10bd12: 66 90 xchg %ax,%ax
/*
* OK. The manager should be initialized and configured to have objects.
* With any luck, it is safe to attempt to allocate an object.
*/
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10bd14: 8d 73 20 lea 0x20(%ebx),%esi
10bd17: 83 ec 0c sub $0xc,%esp
10bd1a: 56 push %esi
10bd1b: e8 a0 f7 ff ff call 10b4c0 <_Chain_Get>
10bd20: 89 c1 mov %eax,%ecx
if ( information->auto_extend ) {
10bd22: 83 c4 10 add $0x10,%esp
10bd25: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10bd29: 74 de je 10bd09 <_Objects_Allocate+0x11>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
10bd2b: 85 c0 test %eax,%eax
10bd2d: 74 29 je 10bd58 <_Objects_Allocate+0x60>
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
10bd2f: 0f b7 41 08 movzwl 0x8(%ecx),%eax
10bd33: 0f b7 53 08 movzwl 0x8(%ebx),%edx
10bd37: 29 d0 sub %edx,%eax
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
10bd39: 0f b7 73 14 movzwl 0x14(%ebx),%esi
10bd3d: 31 d2 xor %edx,%edx
10bd3f: f7 f6 div %esi
information->inactive_per_block[ block ]--;
10bd41: c1 e0 02 shl $0x2,%eax
10bd44: 03 43 30 add 0x30(%ebx),%eax
10bd47: ff 08 decl (%eax)
information->inactive--;
10bd49: 66 ff 4b 2c decw 0x2c(%ebx)
);
}
#endif
return the_object;
}
10bd4d: 89 c8 mov %ecx,%eax
10bd4f: 8d 65 f8 lea -0x8(%ebp),%esp
10bd52: 5b pop %ebx
10bd53: 5e pop %esi
10bd54: c9 leave
10bd55: c3 ret
10bd56: 66 90 xchg %ax,%ax
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
_Objects_Extend_information( information );
10bd58: 83 ec 0c sub $0xc,%esp
10bd5b: 53 push %ebx
10bd5c: e8 3b 00 00 00 call 10bd9c <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10bd61: 89 34 24 mov %esi,(%esp)
10bd64: e8 57 f7 ff ff call 10b4c0 <_Chain_Get>
10bd69: 89 c1 mov %eax,%ecx
}
if ( the_object ) {
10bd6b: 83 c4 10 add $0x10,%esp
10bd6e: 85 c0 test %eax,%eax
10bd70: 74 97 je 10bd09 <_Objects_Allocate+0x11>
10bd72: eb bb jmp 10bd2f <_Objects_Allocate+0x37>
0010bd9c <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
10bd9c: 55 push %ebp
10bd9d: 89 e5 mov %esp,%ebp
10bd9f: 57 push %edi
10bda0: 56 push %esi
10bda1: 53 push %ebx
10bda2: 83 ec 4c sub $0x4c,%esp
10bda5: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
10bda8: 0f b7 43 08 movzwl 0x8(%ebx),%eax
10bdac: 89 45 cc mov %eax,-0x34(%ebp)
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
10bdaf: 8b 4b 34 mov 0x34(%ebx),%ecx
10bdb2: 85 c9 test %ecx,%ecx
10bdb4: 0f 84 62 02 00 00 je 10c01c <_Objects_Extend_information+0x280>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
10bdba: 8b 73 10 mov 0x10(%ebx),%esi
10bdbd: 66 89 75 d0 mov %si,-0x30(%ebp)
10bdc1: 8b 7b 14 mov 0x14(%ebx),%edi
10bdc4: 89 f0 mov %esi,%eax
10bdc6: 31 d2 xor %edx,%edx
10bdc8: 66 f7 f7 div %di
10bdcb: 0f b7 f0 movzwl %ax,%esi
for ( ; block < block_count; block++ ) {
10bdce: 85 f6 test %esi,%esi
10bdd0: 0f 84 5f 02 00 00 je 10c035 <_Objects_Extend_information+0x299><== NEVER TAKEN
if ( information->object_blocks[ block ] == NULL ) {
10bdd6: 8b 01 mov (%ecx),%eax
10bdd8: 85 c0 test %eax,%eax
10bdda: 0f 84 67 02 00 00 je 10c047 <_Objects_Extend_information+0x2ab><== NEVER TAKEN
10bde0: 0f b7 ff movzwl %di,%edi
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
10bde3: 8b 55 cc mov -0x34(%ebp),%edx
10bde6: 89 55 d4 mov %edx,-0x2c(%ebp)
index_base = minimum_index;
block = 0;
10bde9: 31 d2 xor %edx,%edx
10bdeb: 8b 45 d4 mov -0x2c(%ebp),%eax
10bdee: eb 0a jmp 10bdfa <_Objects_Extend_information+0x5e>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
10bdf0: 83 3c 91 00 cmpl $0x0,(%ecx,%edx,4)
10bdf4: 0f 84 c2 01 00 00 je 10bfbc <_Objects_Extend_information+0x220>
do_extend = false;
break;
} else
index_base += information->allocation_size;
10bdfa: 01 f8 add %edi,%eax
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
10bdfc: 42 inc %edx
10bdfd: 39 d6 cmp %edx,%esi
10bdff: 77 ef ja 10bdf0 <_Objects_Extend_information+0x54>
10be01: 89 45 d4 mov %eax,-0x2c(%ebp)
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
10be04: b1 01 mov $0x1,%cl
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
10be06: 0f b7 45 d0 movzwl -0x30(%ebp),%eax
10be0a: 01 f8 add %edi,%eax
10be0c: 89 45 d0 mov %eax,-0x30(%ebp)
/*
* We need to limit the number of objects to the maximum number
* representable in the index portion of the object Id. In the
* case of 16-bit Ids, this is only 256 object instances.
*/
if ( maximum > OBJECTS_ID_FINAL_INDEX ) {
10be0f: 3d ff ff 00 00 cmp $0xffff,%eax
10be14: 0f 87 9a 01 00 00 ja 10bfb4 <_Objects_Extend_information+0x218>
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
10be1a: 0f af 7b 18 imul 0x18(%ebx),%edi
if ( information->auto_extend ) {
10be1e: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10be22: 0f 84 a0 01 00 00 je 10bfc8 <_Objects_Extend_information+0x22c>
new_object_block = _Workspace_Allocate( block_size );
10be28: 83 ec 0c sub $0xc,%esp
10be2b: 57 push %edi
10be2c: 89 55 b8 mov %edx,-0x48(%ebp)
10be2f: 88 4d b4 mov %cl,-0x4c(%ebp)
10be32: e8 39 1e 00 00 call 10dc70 <_Workspace_Allocate>
10be37: 89 45 c8 mov %eax,-0x38(%ebp)
if ( !new_object_block )
10be3a: 83 c4 10 add $0x10,%esp
10be3d: 85 c0 test %eax,%eax
10be3f: 8b 55 b8 mov -0x48(%ebp),%edx
10be42: 8a 4d b4 mov -0x4c(%ebp),%cl
10be45: 0f 84 69 01 00 00 je 10bfb4 <_Objects_Extend_information+0x218>
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
10be4b: 84 c9 test %cl,%cl
10be4d: 0f 84 e6 00 00 00 je 10bf39 <_Objects_Extend_information+0x19d>
*/
/*
* Up the block count and maximum
*/
block_count++;
10be53: 8d 7e 01 lea 0x1(%esi),%edi
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
10be56: 83 ec 0c sub $0xc,%esp
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
10be59: 8d 04 7f lea (%edi,%edi,2),%eax
((maximum + minimum_index) * sizeof(Objects_Control *));
10be5c: 03 45 d0 add -0x30(%ebp),%eax
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
10be5f: 03 45 cc add -0x34(%ebp),%eax
block_count++;
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
10be62: c1 e0 02 shl $0x2,%eax
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
10be65: 50 push %eax
10be66: 89 55 b8 mov %edx,-0x48(%ebp)
10be69: e8 02 1e 00 00 call 10dc70 <_Workspace_Allocate>
10be6e: 89 45 c4 mov %eax,-0x3c(%ebp)
if ( !object_blocks ) {
10be71: 83 c4 10 add $0x10,%esp
10be74: 85 c0 test %eax,%eax
10be76: 8b 55 b8 mov -0x48(%ebp),%edx
10be79: 0f 84 da 01 00 00 je 10c059 <_Objects_Extend_information+0x2bd>
10be7f: 8b 45 c4 mov -0x3c(%ebp),%eax
10be82: 8d 04 b8 lea (%eax,%edi,4),%eax
10be85: 89 45 bc mov %eax,-0x44(%ebp)
10be88: 8b 4d c4 mov -0x3c(%ebp),%ecx
10be8b: 8d 04 f9 lea (%ecx,%edi,8),%eax
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
10be8e: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx
10be92: 39 4d cc cmp %ecx,-0x34(%ebp)
10be95: 0f 82 4d 01 00 00 jb 10bfe8 <_Objects_Extend_information+0x24c>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
10be9b: 8b 4d cc mov -0x34(%ebp),%ecx
10be9e: 85 c9 test %ecx,%ecx
10bea0: 74 12 je 10beb4 <_Objects_Extend_information+0x118><== NEVER TAKEN
10bea2: 31 c9 xor %ecx,%ecx
10bea4: 8b 7d cc mov -0x34(%ebp),%edi
10bea7: 90 nop
local_table[ index ] = NULL;
10bea8: c7 04 88 00 00 00 00 movl $0x0,(%eax,%ecx,4)
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
10beaf: 41 inc %ecx
10beb0: 39 cf cmp %ecx,%edi
10beb2: 77 f4 ja 10bea8 <_Objects_Extend_information+0x10c><== NEVER TAKEN
10beb4: c1 e6 02 shl $0x2,%esi
10beb7: 89 75 c0 mov %esi,-0x40(%ebp)
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
10beba: 8b 4d c4 mov -0x3c(%ebp),%ecx
10bebd: 8b 75 c0 mov -0x40(%ebp),%esi
10bec0: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1)
inactive_per_block[block_count] = 0;
10bec7: 8b 4d bc mov -0x44(%ebp),%ecx
10beca: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1)
for ( index=index_base ;
index < ( information->allocation_size + index_base );
10bed1: 0f b7 73 14 movzwl 0x14(%ebx),%esi
10bed5: 03 75 d4 add -0x2c(%ebp),%esi
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
10bed8: 39 75 d4 cmp %esi,-0x2c(%ebp)
10bedb: 73 0f jae 10beec <_Objects_Extend_information+0x150><== NEVER TAKEN
10bedd: 8b 4d d4 mov -0x2c(%ebp),%ecx
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
10bee0: c7 04 88 00 00 00 00 movl $0x0,(%eax,%ecx,4)
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
10bee7: 41 inc %ecx
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
10bee8: 39 f1 cmp %esi,%ecx
10beea: 72 f4 jb 10bee0 <_Objects_Extend_information+0x144>
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
}
_ISR_Disable( level );
10beec: 9c pushf
10beed: fa cli
10beee: 5f pop %edi
old_tables = information->object_blocks;
10beef: 8b 73 34 mov 0x34(%ebx),%esi
information->object_blocks = object_blocks;
10bef2: 8b 4d c4 mov -0x3c(%ebp),%ecx
10bef5: 89 4b 34 mov %ecx,0x34(%ebx)
information->inactive_per_block = inactive_per_block;
10bef8: 8b 4d bc mov -0x44(%ebp),%ecx
10befb: 89 4b 30 mov %ecx,0x30(%ebx)
information->local_table = local_table;
10befe: 89 43 1c mov %eax,0x1c(%ebx)
information->maximum = (Objects_Maximum) maximum;
10bf01: 8b 45 d0 mov -0x30(%ebp),%eax
10bf04: 66 89 43 10 mov %ax,0x10(%ebx)
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10bf08: 8b 0b mov (%ebx),%ecx
10bf0a: c1 e1 18 shl $0x18,%ecx
10bf0d: 81 c9 00 00 01 00 or $0x10000,%ecx
information->maximum_id = _Objects_Build_id(
10bf13: 0f b7 43 04 movzwl 0x4(%ebx),%eax
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10bf17: c1 e0 1b shl $0x1b,%eax
10bf1a: 09 c1 or %eax,%ecx
10bf1c: 0f b7 45 d0 movzwl -0x30(%ebp),%eax
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10bf20: 09 c1 or %eax,%ecx
10bf22: 89 4b 0c mov %ecx,0xc(%ebx)
information->the_class,
_Objects_Local_node,
information->maximum
);
_ISR_Enable( level );
10bf25: 57 push %edi
10bf26: 9d popf
_Workspace_Free( old_tables );
10bf27: 83 ec 0c sub $0xc,%esp
10bf2a: 56 push %esi
10bf2b: 89 55 b8 mov %edx,-0x48(%ebp)
10bf2e: e8 59 1d 00 00 call 10dc8c <_Workspace_Free>
10bf33: 83 c4 10 add $0x10,%esp
10bf36: 8b 55 b8 mov -0x48(%ebp),%edx
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
10bf39: c1 e2 02 shl $0x2,%edx
10bf3c: 89 55 d0 mov %edx,-0x30(%ebp)
10bf3f: 8b 43 34 mov 0x34(%ebx),%eax
10bf42: 8b 4d c8 mov -0x38(%ebp),%ecx
10bf45: 89 0c 10 mov %ecx,(%eax,%edx,1)
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
10bf48: ff 73 18 pushl 0x18(%ebx)
10bf4b: 0f b7 43 14 movzwl 0x14(%ebx),%eax
10bf4f: 50 push %eax
10bf50: 51 push %ecx
10bf51: 8d 7d dc lea -0x24(%ebp),%edi
10bf54: 57 push %edi
10bf55: e8 d2 3e 00 00 call 10fe2c <_Chain_Initialize>
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
10bf5a: 83 c4 10 add $0x10,%esp
10bf5d: 8b 75 d4 mov -0x2c(%ebp),%esi
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10bf60: 8d 43 20 lea 0x20(%ebx),%eax
10bf63: 89 45 d4 mov %eax,-0x2c(%ebp)
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
10bf66: eb 29 jmp 10bf91 <_Objects_Extend_information+0x1f5>
10bf68: 8b 13 mov (%ebx),%edx
10bf6a: c1 e2 18 shl $0x18,%edx
10bf6d: 81 ca 00 00 01 00 or $0x10000,%edx
the_object->id = _Objects_Build_id(
10bf73: 0f b7 4b 04 movzwl 0x4(%ebx),%ecx
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10bf77: c1 e1 1b shl $0x1b,%ecx
10bf7a: 09 ca or %ecx,%edx
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10bf7c: 09 f2 or %esi,%edx
10bf7e: 89 50 08 mov %edx,0x8(%eax)
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10bf81: 83 ec 08 sub $0x8,%esp
10bf84: 50 push %eax
10bf85: ff 75 d4 pushl -0x2c(%ebp)
10bf88: e8 f7 f4 ff ff call 10b484 <_Chain_Append>
index++;
10bf8d: 46 inc %esi
10bf8e: 83 c4 10 add $0x10,%esp
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
10bf91: 83 ec 0c sub $0xc,%esp
10bf94: 57 push %edi
10bf95: e8 26 f5 ff ff call 10b4c0 <_Chain_Get>
10bf9a: 83 c4 10 add $0x10,%esp
10bf9d: 85 c0 test %eax,%eax
10bf9f: 75 c7 jne 10bf68 <_Objects_Extend_information+0x1cc>
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
10bfa1: 8b 43 14 mov 0x14(%ebx),%eax
10bfa4: 8b 53 30 mov 0x30(%ebx),%edx
10bfa7: 0f b7 c8 movzwl %ax,%ecx
10bfaa: 8b 75 d0 mov -0x30(%ebp),%esi
10bfad: 89 0c 32 mov %ecx,(%edx,%esi,1)
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
10bfb0: 66 01 43 2c add %ax,0x2c(%ebx)
}
10bfb4: 8d 65 f4 lea -0xc(%ebp),%esp
10bfb7: 5b pop %ebx
10bfb8: 5e pop %esi
10bfb9: 5f pop %edi
10bfba: c9 leave
10bfbb: c3 ret
10bfbc: 89 45 d4 mov %eax,-0x2c(%ebp)
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
10bfbf: 31 c9 xor %ecx,%ecx
10bfc1: e9 40 fe ff ff jmp 10be06 <_Objects_Extend_information+0x6a>
10bfc6: 66 90 xchg %ax,%ax
if ( information->auto_extend ) {
new_object_block = _Workspace_Allocate( block_size );
if ( !new_object_block )
return;
} else {
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
10bfc8: 83 ec 0c sub $0xc,%esp
10bfcb: 57 push %edi
10bfcc: 89 55 b8 mov %edx,-0x48(%ebp)
10bfcf: 88 4d b4 mov %cl,-0x4c(%ebp)
10bfd2: e8 cd 1c 00 00 call 10dca4 <_Workspace_Allocate_or_fatal_error>
10bfd7: 89 45 c8 mov %eax,-0x38(%ebp)
10bfda: 83 c4 10 add $0x10,%esp
10bfdd: 8a 4d b4 mov -0x4c(%ebp),%cl
10bfe0: 8b 55 b8 mov -0x48(%ebp),%edx
10bfe3: e9 63 fe ff ff jmp 10be4b <_Objects_Extend_information+0xaf>
/*
* Copy each section of the table over. This has to be performed as
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
10bfe8: c1 e6 02 shl $0x2,%esi
10bfeb: 89 75 c0 mov %esi,-0x40(%ebp)
10bfee: 8b 73 34 mov 0x34(%ebx),%esi
10bff1: 8b 7d c4 mov -0x3c(%ebp),%edi
10bff4: 8b 4d c0 mov -0x40(%ebp),%ecx
10bff7: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
10bff9: 8b 73 30 mov 0x30(%ebx),%esi
10bffc: 8b 7d bc mov -0x44(%ebp),%edi
10bfff: 8b 4d c0 mov -0x40(%ebp),%ecx
10c002: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
10c004: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx
10c008: 03 4d cc add -0x34(%ebp),%ecx
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
10c00b: c1 e1 02 shl $0x2,%ecx
10c00e: 8b 73 1c mov 0x1c(%ebx),%esi
10c011: 89 c7 mov %eax,%edi
10c013: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
10c015: e9 a0 fe ff ff jmp 10beba <_Objects_Extend_information+0x11e>
10c01a: 66 90 xchg %ax,%ax
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
10c01c: 8b 53 10 mov 0x10(%ebx),%edx
10c01f: 66 89 55 d0 mov %dx,-0x30(%ebp)
10c023: 0f b7 7b 14 movzwl 0x14(%ebx),%edi
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
10c027: 89 45 d4 mov %eax,-0x2c(%ebp)
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
10c02a: b1 01 mov $0x1,%cl
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
10c02c: 31 d2 xor %edx,%edx
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
10c02e: 31 f6 xor %esi,%esi
10c030: e9 d1 fd ff ff jmp 10be06 <_Objects_Extend_information+0x6a>
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
10c035: 0f b7 ff movzwl %di,%edi <== NOT EXECUTED
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
10c038: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED
10c03b: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
10c03e: b1 01 mov $0x1,%cl <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
10c040: 31 d2 xor %edx,%edx <== NOT EXECUTED
10c042: e9 bf fd ff ff jmp 10be06 <_Objects_Extend_information+0x6a><== NOT EXECUTED
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
10c047: 0f b7 ff movzwl %di,%edi <== NOT EXECUTED
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
10c04a: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED
10c04d: 89 4d d4 mov %ecx,-0x2c(%ebp) <== NOT EXECUTED
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
10c050: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
10c052: 31 d2 xor %edx,%edx <== NOT EXECUTED
10c054: e9 ad fd ff ff jmp 10be06 <_Objects_Extend_information+0x6a><== NOT EXECUTED
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
10c059: 83 ec 0c sub $0xc,%esp
10c05c: ff 75 c8 pushl -0x38(%ebp)
10c05f: e8 28 1c 00 00 call 10dc8c <_Workspace_Free>
return;
10c064: 83 c4 10 add $0x10,%esp
10c067: e9 48 ff ff ff jmp 10bfb4 <_Objects_Extend_information+0x218>
0010c0fc <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
10c0fc: 55 push %ebp
10c0fd: 89 e5 mov %esp,%ebp
10c0ff: 56 push %esi
10c100: 53 push %ebx
10c101: 8b 75 08 mov 0x8(%ebp),%esi
10c104: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
10c107: 66 85 db test %bx,%bx
10c10a: 75 0c jne 10c118 <_Objects_Get_information+0x1c>
the_class_api_maximum = _Objects_API_maximum_class( the_api );
if ( the_class_api_maximum == 0 )
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
return NULL;
10c10c: 31 c0 xor %eax,%eax
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
10c10e: 8d 65 f8 lea -0x8(%ebp),%esp
10c111: 5b pop %ebx
10c112: 5e pop %esi
10c113: c9 leave
10c114: c3 ret
10c115: 8d 76 00 lea 0x0(%esi),%esi
/*
* This call implicitly validates the_api so we do not call
* _Objects_Is_api_valid above here.
*/
the_class_api_maximum = _Objects_API_maximum_class( the_api );
10c118: 83 ec 0c sub $0xc,%esp
10c11b: 56 push %esi
10c11c: e8 77 44 00 00 call 110598 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
10c121: 83 c4 10 add $0x10,%esp
10c124: 85 c0 test %eax,%eax
10c126: 74 e4 je 10c10c <_Objects_Get_information+0x10>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
10c128: 0f b7 db movzwl %bx,%ebx
10c12b: 39 d8 cmp %ebx,%eax
10c12d: 72 dd jb 10c10c <_Objects_Get_information+0x10>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10c12f: 8b 14 b5 c4 64 12 00 mov 0x1264c4(,%esi,4),%edx
return NULL;
10c136: 31 c0 xor %eax,%eax
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10c138: 85 d2 test %edx,%edx
10c13a: 74 d2 je 10c10e <_Objects_Get_information+0x12><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
10c13c: 8b 04 9a mov (%edx,%ebx,4),%eax
if ( !info )
10c13f: 85 c0 test %eax,%eax
10c141: 74 cb je 10c10e <_Objects_Get_information+0x12><== NEVER TAKEN
* Thus we may have 0 local instances and still have a valid object
* pointer.
*/
#if !defined(RTEMS_MULTIPROCESSING)
if ( info->maximum == 0 )
return NULL;
10c143: 31 d2 xor %edx,%edx
10c145: 66 83 78 10 00 cmpw $0x0,0x10(%eax)
10c14a: 0f 95 c2 setne %dl
10c14d: f7 da neg %edx
10c14f: 21 d0 and %edx,%eax
10c151: eb bb jmp 10c10e <_Objects_Get_information+0x12>
0010c154 <_Objects_Get_isr_disable>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location,
ISR_Level *level_p
)
{
10c154: 55 push %ebp
10c155: 89 e5 mov %esp,%ebp
10c157: 56 push %esi
10c158: 53 push %ebx
10c159: 8b 55 08 mov 0x8(%ebp),%edx
10c15c: 8b 5d 10 mov 0x10(%ebp),%ebx
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
10c15f: b8 01 00 00 00 mov $0x1,%eax
10c164: 2b 42 08 sub 0x8(%edx),%eax
10c167: 03 45 0c add 0xc(%ebp),%eax
_ISR_Disable( level );
10c16a: 9c pushf
10c16b: fa cli
10c16c: 5e pop %esi
if ( information->maximum >= index ) {
10c16d: 0f b7 4a 10 movzwl 0x10(%edx),%ecx
10c171: 39 c8 cmp %ecx,%eax
10c173: 77 1b ja 10c190 <_Objects_Get_isr_disable+0x3c>
if ( (the_object = information->local_table[ index ]) != NULL ) {
10c175: 8b 52 1c mov 0x1c(%edx),%edx
10c178: 8b 04 82 mov (%edx,%eax,4),%eax
10c17b: 85 c0 test %eax,%eax
10c17d: 74 21 je 10c1a0 <_Objects_Get_isr_disable+0x4c><== NEVER TAKEN
*location = OBJECTS_LOCAL;
10c17f: c7 03 00 00 00 00 movl $0x0,(%ebx)
*level_p = level;
10c185: 8b 55 14 mov 0x14(%ebp),%edx
10c188: 89 32 mov %esi,(%edx)
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
#endif
}
10c18a: 5b pop %ebx
10c18b: 5e pop %esi
10c18c: c9 leave
10c18d: c3 ret
10c18e: 66 90 xchg %ax,%ax
}
_ISR_Enable( level );
*location = OBJECTS_ERROR;
return NULL;
}
_ISR_Enable( level );
10c190: 56 push %esi
10c191: 9d popf
*location = OBJECTS_ERROR;
10c192: c7 03 01 00 00 00 movl $0x1,(%ebx)
#if defined(RTEMS_MULTIPROCESSING)
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
10c198: 31 c0 xor %eax,%eax
#endif
}
10c19a: 5b pop %ebx
10c19b: 5e pop %esi
10c19c: c9 leave
10c19d: c3 ret
10c19e: 66 90 xchg %ax,%ax
if ( (the_object = information->local_table[ index ]) != NULL ) {
*location = OBJECTS_LOCAL;
*level_p = level;
return the_object;
}
_ISR_Enable( level );
10c1a0: 56 push %esi
10c1a1: 9d popf
*location = OBJECTS_ERROR;
10c1a2: c7 03 01 00 00 00 movl $0x1,(%ebx)
return NULL;
10c1a8: eb e0 jmp 10c18a <_Objects_Get_isr_disable+0x36>
0010d874 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
10d874: 55 push %ebp
10d875: 89 e5 mov %esp,%ebp
10d877: 57 push %edi
10d878: 56 push %esi
10d879: 53 push %ebx
10d87a: 83 ec 3c sub $0x3c,%esp
10d87d: 8b 7d 08 mov 0x8(%ebp),%edi
10d880: 8b 75 0c mov 0xc(%ebp),%esi
10d883: 8b 5d 10 mov 0x10(%ebp),%ebx
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
10d886: 85 f6 test %esi,%esi
10d888: 75 0e jne 10d898 <_Objects_Get_name_as_string+0x24>
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
10d88a: 31 db xor %ebx,%ebx
_Thread_Enable_dispatch();
return name;
}
return NULL; /* unreachable path */
}
10d88c: 89 d8 mov %ebx,%eax
10d88e: 8d 65 f4 lea -0xc(%ebp),%esp
10d891: 5b pop %ebx
10d892: 5e pop %esi
10d893: 5f pop %edi
10d894: c9 leave
10d895: c3 ret
10d896: 66 90 xchg %ax,%ax
Objects_Id tmpId;
if ( length == 0 )
return NULL;
if ( name == NULL )
10d898: 85 db test %ebx,%ebx
10d89a: 74 f0 je 10d88c <_Objects_Get_name_as_string+0x18>
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10d89c: 85 ff test %edi,%edi
10d89e: 75 08 jne 10d8a8 <_Objects_Get_name_as_string+0x34>
10d8a0: a1 98 9b 12 00 mov 0x129b98,%eax
10d8a5: 8b 78 08 mov 0x8(%eax),%edi
information = _Objects_Get_information_id( tmpId );
10d8a8: 83 ec 0c sub $0xc,%esp
10d8ab: 57 push %edi
10d8ac: e8 f3 fe ff ff call 10d7a4 <_Objects_Get_information_id>
if ( !information )
10d8b1: 83 c4 10 add $0x10,%esp
10d8b4: 85 c0 test %eax,%eax
10d8b6: 74 d2 je 10d88a <_Objects_Get_name_as_string+0x16>
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
10d8b8: 51 push %ecx
10d8b9: 8d 55 e4 lea -0x1c(%ebp),%edx
10d8bc: 52 push %edx
10d8bd: 57 push %edi
10d8be: 50 push %eax
10d8bf: e8 80 00 00 00 call 10d944 <_Objects_Get>
switch ( location ) {
10d8c4: 83 c4 10 add $0x10,%esp
10d8c7: 8b 55 e4 mov -0x1c(%ebp),%edx
10d8ca: 85 d2 test %edx,%edx
10d8cc: 75 bc jne 10d88a <_Objects_Get_name_as_string+0x16>
if ( information->is_string ) {
s = the_object->name.name_p;
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
10d8ce: 8b 40 0c mov 0xc(%eax),%eax
lname[ 0 ] = (u32_name >> 24) & 0xff;
10d8d1: 89 c2 mov %eax,%edx
10d8d3: c1 ea 18 shr $0x18,%edx
10d8d6: 88 55 c7 mov %dl,-0x39(%ebp)
10d8d9: 88 55 df mov %dl,-0x21(%ebp)
lname[ 1 ] = (u32_name >> 16) & 0xff;
10d8dc: 89 c7 mov %eax,%edi
10d8de: c1 ef 10 shr $0x10,%edi
10d8e1: 89 f9 mov %edi,%ecx
10d8e3: 88 4d e0 mov %cl,-0x20(%ebp)
lname[ 2 ] = (u32_name >> 8) & 0xff;
10d8e6: 89 c7 mov %eax,%edi
10d8e8: c1 ef 08 shr $0x8,%edi
10d8eb: 89 f9 mov %edi,%ecx
10d8ed: 88 4d e1 mov %cl,-0x1f(%ebp)
lname[ 3 ] = (u32_name >> 0) & 0xff;
10d8f0: 88 45 e2 mov %al,-0x1e(%ebp)
lname[ 4 ] = '\0';
10d8f3: c6 45 e3 00 movb $0x0,-0x1d(%ebp)
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10d8f7: 4e dec %esi
10d8f8: 89 75 d4 mov %esi,-0x2c(%ebp)
10d8fb: 74 41 je 10d93e <_Objects_Get_name_as_string+0xca><== NEVER TAKEN
10d8fd: 84 d2 test %dl,%dl
10d8ff: 74 3d je 10d93e <_Objects_Get_name_as_string+0xca>
10d901: 89 d9 mov %ebx,%ecx
10d903: 31 c0 xor %eax,%eax
10d905: eb 09 jmp 10d910 <_Objects_Get_name_as_string+0x9c>
10d907: 90 nop
10d908: 8a 54 05 df mov -0x21(%ebp,%eax,1),%dl
10d90c: 84 d2 test %dl,%dl
10d90e: 74 21 je 10d931 <_Objects_Get_name_as_string+0xbd>
*d = (isprint((unsigned char)*s)) ? *s : '*';
10d910: 0f b6 f2 movzbl %dl,%esi
10d913: 8b 3d 28 72 12 00 mov 0x127228,%edi
10d919: 0f be 74 37 01 movsbl 0x1(%edi,%esi,1),%esi
10d91e: 81 e6 97 00 00 00 and $0x97,%esi
10d924: 75 02 jne 10d928 <_Objects_Get_name_as_string+0xb4>
10d926: b2 2a mov $0x2a,%dl
10d928: 88 11 mov %dl,(%ecx)
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10d92a: 40 inc %eax
10d92b: 41 inc %ecx
10d92c: 3b 45 d4 cmp -0x2c(%ebp),%eax
10d92f: 72 d7 jb 10d908 <_Objects_Get_name_as_string+0x94>
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
10d931: c6 01 00 movb $0x0,(%ecx)
_Thread_Enable_dispatch();
10d934: e8 e3 0a 00 00 call 10e41c <_Thread_Enable_dispatch>
return name;
10d939: e9 4e ff ff ff jmp 10d88c <_Objects_Get_name_as_string+0x18>
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10d93e: 89 d9 mov %ebx,%ecx
10d940: eb ef jmp 10d931 <_Objects_Get_name_as_string+0xbd>
0010c2f4 <_Objects_Get_next>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
10c2f4: 55 push %ebp
10c2f5: 89 e5 mov %esp,%ebp
10c2f7: 57 push %edi
10c2f8: 56 push %esi
10c2f9: 53 push %ebx
10c2fa: 83 ec 0c sub $0xc,%esp
10c2fd: 8b 5d 08 mov 0x8(%ebp),%ebx
10c300: 8b 75 0c mov 0xc(%ebp),%esi
10c303: 8b 7d 10 mov 0x10(%ebp),%edi
Objects_Control *object;
Objects_Id next_id;
if ( !information )
10c306: 85 db test %ebx,%ebx
10c308: 75 0a jne 10c314 <_Objects_Get_next+0x20>
if ( !location_p )
return NULL;
if ( !next_id_p )
return NULL;
10c30a: 31 c0 xor %eax,%eax
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
10c30c: 8d 65 f4 lea -0xc(%ebp),%esp
10c30f: 5b pop %ebx
10c310: 5e pop %esi
10c311: 5f pop %edi
10c312: c9 leave
10c313: c3 ret
Objects_Id next_id;
if ( !information )
return NULL;
if ( !location_p )
10c314: 85 ff test %edi,%edi
10c316: 74 f2 je 10c30a <_Objects_Get_next+0x16>
return NULL;
if ( !next_id_p )
10c318: 8b 45 14 mov 0x14(%ebp),%eax
10c31b: 85 c0 test %eax,%eax
10c31d: 74 eb je 10c30a <_Objects_Get_next+0x16>
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
10c31f: 66 85 f6 test %si,%si
10c322: 75 04 jne 10c328 <_Objects_Get_next+0x34>
next_id = information->minimum_id;
10c324: 8b 73 08 mov 0x8(%ebx),%esi
10c327: 90 nop
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
10c328: 66 39 73 10 cmp %si,0x10(%ebx)
10c32c: 72 22 jb 10c350 <_Objects_Get_next+0x5c>
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
10c32e: 51 push %ecx
10c32f: 57 push %edi
10c330: 56 push %esi
10c331: 53 push %ebx
10c332: e8 2d 00 00 00 call 10c364 <_Objects_Get>
next_id++;
10c337: 46 inc %esi
} while (*location_p != OBJECTS_LOCAL);
10c338: 83 c4 10 add $0x10,%esp
10c33b: 8b 17 mov (%edi),%edx
10c33d: 85 d2 test %edx,%edx
10c33f: 75 e7 jne 10c328 <_Objects_Get_next+0x34>
*next_id_p = next_id;
10c341: 8b 55 14 mov 0x14(%ebp),%edx
10c344: 89 32 mov %esi,(%edx)
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
10c346: 8d 65 f4 lea -0xc(%ebp),%esp
10c349: 5b pop %ebx
10c34a: 5e pop %esi
10c34b: 5f pop %edi
10c34c: c9 leave
10c34d: c3 ret
10c34e: 66 90 xchg %ax,%ax
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
{
*location_p = OBJECTS_ERROR;
10c350: c7 07 01 00 00 00 movl $0x1,(%edi)
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
10c356: 8b 45 14 mov 0x14(%ebp),%eax
10c359: c7 00 ff ff ff ff movl $0xffffffff,(%eax)
return 0;
10c35f: 31 c0 xor %eax,%eax
10c361: eb a9 jmp 10c30c <_Objects_Get_next+0x18>
0011a788 <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
11a788: 55 push %ebp
11a789: 89 e5 mov %esp,%ebp
11a78b: 53 push %ebx
11a78c: 8b 55 08 mov 0x8(%ebp),%edx
11a78f: 8b 5d 10 mov 0x10(%ebp),%ebx
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
11a792: b8 01 00 00 00 mov $0x1,%eax
11a797: 2b 42 08 sub 0x8(%edx),%eax
11a79a: 03 45 0c add 0xc(%ebp),%eax
if ( information->maximum >= index ) {
11a79d: 0f b7 4a 10 movzwl 0x10(%edx),%ecx
11a7a1: 39 c8 cmp %ecx,%eax
11a7a3: 77 13 ja 11a7b8 <_Objects_Get_no_protection+0x30>
if ( (the_object = information->local_table[ index ]) != NULL ) {
11a7a5: 8b 52 1c mov 0x1c(%edx),%edx
11a7a8: 8b 04 82 mov (%edx,%eax,4),%eax
11a7ab: 85 c0 test %eax,%eax
11a7ad: 74 09 je 11a7b8 <_Objects_Get_no_protection+0x30><== NEVER TAKEN
*location = OBJECTS_LOCAL;
11a7af: c7 03 00 00 00 00 movl $0x0,(%ebx)
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
*location = OBJECTS_ERROR;
return NULL;
}
11a7b5: 5b pop %ebx
11a7b6: c9 leave
11a7b7: c3 ret
/*
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
*location = OBJECTS_ERROR;
11a7b8: c7 03 01 00 00 00 movl $0x1,(%ebx)
return NULL;
11a7be: 31 c0 xor %eax,%eax
}
11a7c0: 5b pop %ebx
11a7c1: c9 leave
11a7c2: c3 ret
0010d458 <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
10d458: 55 push %ebp
10d459: 89 e5 mov %esp,%ebp
10d45b: 83 ec 18 sub $0x18,%esp
10d45e: 8b 55 08 mov 0x8(%ebp),%edx
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10d461: 85 d2 test %edx,%edx
10d463: 75 08 jne 10d46d <_Objects_Id_to_name+0x15>
10d465: a1 58 87 12 00 mov 0x128758,%eax
10d46a: 8b 50 08 mov 0x8(%eax),%edx
10d46d: 89 d0 mov %edx,%eax
10d46f: c1 e8 18 shr $0x18,%eax
10d472: 83 e0 07 and $0x7,%eax
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
10d475: 8d 48 ff lea -0x1(%eax),%ecx
10d478: 83 f9 02 cmp $0x2,%ecx
10d47b: 77 3b ja 10d4b8 <_Objects_Id_to_name+0x60>
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
10d47d: 8b 04 85 a4 84 12 00 mov 0x1284a4(,%eax,4),%eax
10d484: 85 c0 test %eax,%eax
10d486: 74 30 je 10d4b8 <_Objects_Id_to_name+0x60>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10d488: 89 d1 mov %edx,%ecx
10d48a: c1 e9 1b shr $0x1b,%ecx
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
10d48d: 8b 04 88 mov (%eax,%ecx,4),%eax
if ( !information )
10d490: 85 c0 test %eax,%eax
10d492: 74 24 je 10d4b8 <_Objects_Id_to_name+0x60><== NEVER TAKEN
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
10d494: 51 push %ecx
10d495: 8d 4d f4 lea -0xc(%ebp),%ecx
10d498: 51 push %ecx
10d499: 52 push %edx
10d49a: 50 push %eax
10d49b: e8 50 ff ff ff call 10d3f0 <_Objects_Get>
if ( !the_object )
10d4a0: 83 c4 10 add $0x10,%esp
10d4a3: 85 c0 test %eax,%eax
10d4a5: 74 11 je 10d4b8 <_Objects_Id_to_name+0x60>
return OBJECTS_INVALID_ID;
*name = the_object->name;
10d4a7: 8b 50 0c mov 0xc(%eax),%edx
10d4aa: 8b 45 0c mov 0xc(%ebp),%eax
10d4ad: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10d4af: e8 f4 0a 00 00 call 10dfa8 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10d4b4: 31 c0 xor %eax,%eax
}
10d4b6: c9 leave
10d4b7: c3 ret
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
10d4b8: b8 03 00 00 00 mov $0x3,%eax
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
10d4bd: c9 leave
10d4be: c3 ret
0010c2f4 <_Objects_Name_to_id_u32>:
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
10c2f4: 55 push %ebp
10c2f5: 89 e5 mov %esp,%ebp
10c2f7: 57 push %edi
10c2f8: 56 push %esi
10c2f9: 53 push %ebx
10c2fa: 8b 45 08 mov 0x8(%ebp),%eax
10c2fd: 8b 4d 0c mov 0xc(%ebp),%ecx
10c300: 8b 55 10 mov 0x10(%ebp),%edx
10c303: 8b 7d 14 mov 0x14(%ebp),%edi
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
10c306: 85 ff test %edi,%edi
10c308: 74 56 je 10c360 <_Objects_Name_to_id_u32+0x6c>
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
10c30a: 85 c9 test %ecx,%ecx
10c30c: 74 08 je 10c316 <_Objects_Name_to_id_u32+0x22>
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
10c30e: 8b 70 10 mov 0x10(%eax),%esi
10c311: 66 85 f6 test %si,%si
10c314: 75 0a jne 10c320 <_Objects_Name_to_id_u32+0x2c>
return OBJECTS_INVALID_NAME;
name_for_mp.name_u32 = name;
return _Objects_MP_Global_name_search( information, name_for_mp, node, id );
#else
return OBJECTS_INVALID_NAME;
10c316: b8 01 00 00 00 mov $0x1,%eax
#endif
}
10c31b: 5b pop %ebx
10c31c: 5e pop %esi
10c31d: 5f pop %edi
10c31e: c9 leave
10c31f: c3 ret
if ( name == 0 )
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
10c320: 85 d2 test %edx,%edx
10c322: 75 20 jne 10c344 <_Objects_Name_to_id_u32+0x50>
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
10c324: 0f b7 f6 movzwl %si,%esi
10c327: 8b 58 1c mov 0x1c(%eax),%ebx
10c32a: b8 01 00 00 00 mov $0x1,%eax
10c32f: 90 nop
the_object = information->local_table[ index ];
10c330: 8b 14 83 mov (%ebx,%eax,4),%edx
if ( !the_object )
10c333: 85 d2 test %edx,%edx
10c335: 74 05 je 10c33c <_Objects_Name_to_id_u32+0x48>
continue;
if ( name == the_object->name.name_u32 ) {
10c337: 39 4a 0c cmp %ecx,0xc(%edx)
10c33a: 74 18 je 10c354 <_Objects_Name_to_id_u32+0x60>
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
10c33c: 40 inc %eax
10c33d: 39 c6 cmp %eax,%esi
10c33f: 73 ef jae 10c330 <_Objects_Name_to_id_u32+0x3c>
10c341: eb d3 jmp 10c316 <_Objects_Name_to_id_u32+0x22>
10c343: 90 nop
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
(node == OBJECTS_SEARCH_ALL_NODES ||
10c344: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx
10c34a: 74 d8 je 10c324 <_Objects_Name_to_id_u32+0x30>
node == OBJECTS_SEARCH_LOCAL_NODE ||
10c34c: 4a dec %edx
10c34d: 75 c7 jne 10c316 <_Objects_Name_to_id_u32+0x22>
10c34f: eb d3 jmp 10c324 <_Objects_Name_to_id_u32+0x30>
10c351: 8d 76 00 lea 0x0(%esi),%esi
the_object = information->local_table[ index ];
if ( !the_object )
continue;
if ( name == the_object->name.name_u32 ) {
*id = the_object->id;
10c354: 8b 42 08 mov 0x8(%edx),%eax
10c357: 89 07 mov %eax,(%edi)
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10c359: 31 c0 xor %eax,%eax
name_for_mp.name_u32 = name;
return _Objects_MP_Global_name_search( information, name_for_mp, node, id );
#else
return OBJECTS_INVALID_NAME;
#endif
}
10c35b: 5b pop %ebx
10c35c: 5e pop %esi
10c35d: 5f pop %edi
10c35e: c9 leave
10c35f: c3 ret
#endif
/* ASSERT: information->is_string == false */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
10c360: b8 02 00 00 00 mov $0x2,%eax
name_for_mp.name_u32 = name;
return _Objects_MP_Global_name_search( information, name_for_mp, node, id );
#else
return OBJECTS_INVALID_NAME;
#endif
}
10c365: 5b pop %ebx
10c366: 5e pop %esi
10c367: 5f pop %edi
10c368: c9 leave
10c369: c3 ret
0010e294 <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
10e294: 55 push %ebp
10e295: 89 e5 mov %esp,%ebp
10e297: 53 push %ebx
10e298: 83 ec 0c sub $0xc,%esp
10e29b: 8b 5d 10 mov 0x10(%ebp),%ebx
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
10e29e: 8b 45 08 mov 0x8(%ebp),%eax
10e2a1: 0f b7 40 38 movzwl 0x38(%eax),%eax
10e2a5: 50 push %eax
10e2a6: 53 push %ebx
10e2a7: e8 3c 6d 00 00 call 114fe8 <strnlen>
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
10e2ac: 0f be 0b movsbl (%ebx),%ecx
10e2af: c1 e1 18 shl $0x18,%ecx
10e2b2: 83 c4 10 add $0x10,%esp
10e2b5: 83 f8 01 cmp $0x1,%eax
10e2b8: 76 32 jbe 10e2ec <_Objects_Set_name+0x58>
10e2ba: 0f be 53 01 movsbl 0x1(%ebx),%edx
10e2be: c1 e2 10 shl $0x10,%edx
10e2c1: 09 ca or %ecx,%edx
10e2c3: 83 f8 02 cmp $0x2,%eax
10e2c6: 74 2c je 10e2f4 <_Objects_Set_name+0x60>
10e2c8: 0f be 4b 02 movsbl 0x2(%ebx),%ecx
10e2cc: c1 e1 08 shl $0x8,%ecx
10e2cf: 09 d1 or %edx,%ecx
10e2d1: 83 f8 03 cmp $0x3,%eax
10e2d4: 74 37 je 10e30d <_Objects_Set_name+0x79>
10e2d6: 0f be 43 03 movsbl 0x3(%ebx),%eax
10e2da: 09 c1 or %eax,%ecx
10e2dc: 8b 55 0c mov 0xc(%ebp),%edx
10e2df: 89 4a 0c mov %ecx,0xc(%edx)
);
}
return true;
}
10e2e2: b0 01 mov $0x1,%al
10e2e4: 8b 5d fc mov -0x4(%ebp),%ebx
10e2e7: c9 leave
10e2e8: c3 ret
10e2e9: 8d 76 00 lea 0x0(%esi),%esi
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
10e2ec: 89 ca mov %ecx,%edx
10e2ee: 81 ca 00 00 20 00 or $0x200000,%edx
10e2f4: 89 d1 mov %edx,%ecx
10e2f6: 80 cd 20 or $0x20,%ch
10e2f9: b8 20 00 00 00 mov $0x20,%eax
10e2fe: 09 c1 or %eax,%ecx
10e300: 8b 55 0c mov 0xc(%ebp),%edx
10e303: 89 4a 0c mov %ecx,0xc(%edx)
);
}
return true;
}
10e306: b0 01 mov $0x1,%al
10e308: 8b 5d fc mov -0x4(%ebp),%ebx
10e30b: c9 leave
10e30c: c3 ret
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
10e30d: b8 20 00 00 00 mov $0x20,%eax
10e312: eb c6 jmp 10e2da <_Objects_Set_name+0x46>
0010c36c <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
10c36c: 55 push %ebp
10c36d: 89 e5 mov %esp,%ebp
10c36f: 57 push %edi
10c370: 56 push %esi
10c371: 53 push %ebx
10c372: 83 ec 1c sub $0x1c,%esp
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
10c375: 8b 45 08 mov 0x8(%ebp),%eax
10c378: 0f b7 58 08 movzwl 0x8(%eax),%ebx
block_count = (information->maximum - index_base) /
10c37c: 0f b7 48 14 movzwl 0x14(%eax),%ecx
10c380: 0f b7 40 10 movzwl 0x10(%eax),%eax
10c384: 29 d8 sub %ebx,%eax
10c386: 31 d2 xor %edx,%edx
10c388: f7 f1 div %ecx
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
10c38a: 85 c0 test %eax,%eax
10c38c: 74 21 je 10c3af <_Objects_Shrink_information+0x43><== NEVER TAKEN
if ( information->inactive_per_block[ block ] ==
10c38e: 8b 55 08 mov 0x8(%ebp),%edx
10c391: 8b 72 30 mov 0x30(%edx),%esi
10c394: 3b 0e cmp (%esi),%ecx
10c396: 74 1f je 10c3b7 <_Objects_Shrink_information+0x4b><== NEVER TAKEN
10c398: 31 d2 xor %edx,%edx
10c39a: eb 0e jmp 10c3aa <_Objects_Shrink_information+0x3e>
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
10c39c: 01 cb add %ecx,%ebx
10c39e: 8d 3c 95 00 00 00 00 lea 0x0(,%edx,4),%edi
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] ==
10c3a5: 3b 0c 96 cmp (%esi,%edx,4),%ecx
10c3a8: 74 12 je 10c3bc <_Objects_Shrink_information+0x50>
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
10c3aa: 42 inc %edx
10c3ab: 39 d0 cmp %edx,%eax
10c3ad: 77 ed ja 10c39c <_Objects_Shrink_information+0x30>
return;
}
index_base += information->allocation_size;
}
}
10c3af: 8d 65 f4 lea -0xc(%ebp),%esp
10c3b2: 5b pop %ebx
10c3b3: 5e pop %esi
10c3b4: 5f pop %edi
10c3b5: c9 leave
10c3b6: c3 ret
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] ==
10c3b7: 31 ff xor %edi,%edi <== NOT EXECUTED
10c3b9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
information->allocation_size ) {
/*
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
10c3bc: 8b 55 08 mov 0x8(%ebp),%edx
10c3bf: 8b 42 20 mov 0x20(%edx),%eax
10c3c2: 89 7d e4 mov %edi,-0x1c(%ebp)
10c3c5: eb 07 jmp 10c3ce <_Objects_Shrink_information+0x62>
10c3c7: 90 nop
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
10c3c8: 85 f6 test %esi,%esi
10c3ca: 74 2c je 10c3f8 <_Objects_Shrink_information+0x8c>
index = _Objects_Get_index( the_object->id );
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
10c3cc: 89 f0 mov %esi,%eax
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
do {
index = _Objects_Get_index( the_object->id );
10c3ce: 0f b7 50 08 movzwl 0x8(%eax),%edx
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
10c3d2: 8b 30 mov (%eax),%esi
if ((index >= index_base) &&
10c3d4: 39 da cmp %ebx,%edx
10c3d6: 72 f0 jb 10c3c8 <_Objects_Shrink_information+0x5c>
(index < (index_base + information->allocation_size))) {
10c3d8: 8b 7d 08 mov 0x8(%ebp),%edi
10c3db: 0f b7 4f 14 movzwl 0x14(%edi),%ecx
10c3df: 8d 0c 0b lea (%ebx,%ecx,1),%ecx
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
if ((index >= index_base) &&
10c3e2: 39 ca cmp %ecx,%edx
10c3e4: 73 e2 jae 10c3c8 <_Objects_Shrink_information+0x5c>
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
10c3e6: 83 ec 0c sub $0xc,%esp
10c3e9: 50 push %eax
10c3ea: e8 b9 f0 ff ff call 10b4a8 <_Chain_Extract>
10c3ef: 83 c4 10 add $0x10,%esp
}
}
while ( the_object );
10c3f2: 85 f6 test %esi,%esi
10c3f4: 75 d6 jne 10c3cc <_Objects_Shrink_information+0x60>
10c3f6: 66 90 xchg %ax,%ax
10c3f8: 8b 7d e4 mov -0x1c(%ebp),%edi
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
10c3fb: 83 ec 0c sub $0xc,%esp
10c3fe: 8b 55 08 mov 0x8(%ebp),%edx
10c401: 8b 42 34 mov 0x34(%edx),%eax
10c404: ff 34 38 pushl (%eax,%edi,1)
10c407: e8 80 18 00 00 call 10dc8c <_Workspace_Free>
information->object_blocks[ block ] = NULL;
10c40c: 8b 55 08 mov 0x8(%ebp),%edx
10c40f: 8b 42 34 mov 0x34(%edx),%eax
10c412: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1)
information->inactive_per_block[ block ] = 0;
10c419: 8b 42 30 mov 0x30(%edx),%eax
10c41c: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1)
information->inactive -= information->allocation_size;
10c423: 8b 42 14 mov 0x14(%edx),%eax
10c426: 66 29 42 2c sub %ax,0x2c(%edx)
return;
10c42a: 83 c4 10 add $0x10,%esp
}
index_base += information->allocation_size;
}
}
10c42d: 8d 65 f4 lea -0xc(%ebp),%esp
10c430: 5b pop %ebx
10c431: 5e pop %esi
10c432: 5f pop %edi
10c433: c9 leave
10c434: c3 ret
0010cb1c <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
10cb1c: 55 push %ebp
10cb1d: 89 e5 mov %esp,%ebp
10cb1f: 56 push %esi
10cb20: 53 push %ebx
10cb21: 8b 5d 08 mov 0x8(%ebp),%ebx
10cb24: 8b 75 0c mov 0xc(%ebp),%esi
if ( !the_heap )
10cb27: 85 db test %ebx,%ebx
10cb29: 74 35 je 10cb60 <_Protected_heap_Get_information+0x44>
return false;
if ( !the_info )
10cb2b: 85 f6 test %esi,%esi
10cb2d: 74 31 je 10cb60 <_Protected_heap_Get_information+0x44>
return false;
_RTEMS_Lock_allocator();
10cb2f: 83 ec 0c sub $0xc,%esp
10cb32: ff 35 c0 65 12 00 pushl 0x1265c0
10cb38: e8 bf ef ff ff call 10bafc <_API_Mutex_Lock>
_Heap_Get_information( the_heap, the_info );
10cb3d: 5a pop %edx
10cb3e: 59 pop %ecx
10cb3f: 56 push %esi
10cb40: 53 push %ebx
10cb41: e8 0a 44 00 00 call 110f50 <_Heap_Get_information>
_RTEMS_Unlock_allocator();
10cb46: 58 pop %eax
10cb47: ff 35 c0 65 12 00 pushl 0x1265c0
10cb4d: e8 f2 ef ff ff call 10bb44 <_API_Mutex_Unlock>
return true;
10cb52: 83 c4 10 add $0x10,%esp
10cb55: b0 01 mov $0x1,%al
}
10cb57: 8d 65 f8 lea -0x8(%ebp),%esp
10cb5a: 5b pop %ebx
10cb5b: 5e pop %esi
10cb5c: c9 leave
10cb5d: c3 ret
10cb5e: 66 90 xchg %ax,%ax
{
if ( !the_heap )
return false;
if ( !the_info )
return false;
10cb60: 31 c0 xor %eax,%eax
_RTEMS_Lock_allocator();
_Heap_Get_information( the_heap, the_info );
_RTEMS_Unlock_allocator();
return true;
}
10cb62: 8d 65 f8 lea -0x8(%ebp),%esp
10cb65: 5b pop %ebx
10cb66: 5e pop %esi
10cb67: c9 leave
10cb68: c3 ret
0010ffc4 <_Protected_heap_Walk>:
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
10ffc4: 55 push %ebp
10ffc5: 89 e5 mov %esp,%ebp
10ffc7: 56 push %esi
10ffc8: 53 push %ebx
10ffc9: 83 ec 10 sub $0x10,%esp
10ffcc: 8b 5d 08 mov 0x8(%ebp),%ebx
10ffcf: 8b 75 0c mov 0xc(%ebp),%esi
10ffd2: 8a 45 10 mov 0x10(%ebp),%al
* then it is forbidden to lock a mutex. But since we are inside
* a critical section, it should be safe to walk it unlocked.
*
* NOTE: Dispatching is also disabled during initialization.
*/
if ( !_Thread_Dispatch_disable_level ) {
10ffd5: 8b 15 cc d5 12 00 mov 0x12d5cc,%edx
10ffdb: 85 d2 test %edx,%edx
10ffdd: 74 19 je 10fff8 <_Protected_heap_Walk+0x34>
_RTEMS_Lock_allocator();
status = _Heap_Walk( the_heap, source, do_dump );
_RTEMS_Unlock_allocator();
} else {
status = _Heap_Walk( the_heap, source, do_dump );
10ffdf: 0f b6 c0 movzbl %al,%eax
10ffe2: 89 45 10 mov %eax,0x10(%ebp)
10ffe5: 89 75 0c mov %esi,0xc(%ebp)
10ffe8: 89 5d 08 mov %ebx,0x8(%ebp)
}
return status;
}
10ffeb: 8d 65 f8 lea -0x8(%ebp),%esp
10ffee: 5b pop %ebx
10ffef: 5e pop %esi
10fff0: c9 leave
if ( !_Thread_Dispatch_disable_level ) {
_RTEMS_Lock_allocator();
status = _Heap_Walk( the_heap, source, do_dump );
_RTEMS_Unlock_allocator();
} else {
status = _Heap_Walk( the_heap, source, do_dump );
10fff1: e9 5a f2 ff ff jmp 10f250 <_Heap_Walk>
10fff6: 66 90 xchg %ax,%ax
* a critical section, it should be safe to walk it unlocked.
*
* NOTE: Dispatching is also disabled during initialization.
*/
if ( !_Thread_Dispatch_disable_level ) {
_RTEMS_Lock_allocator();
10fff8: 83 ec 0c sub $0xc,%esp
10fffb: ff 35 80 d6 12 00 pushl 0x12d680
110001: 88 45 f4 mov %al,-0xc(%ebp)
110004: e8 0b e5 ff ff call 10e514 <_API_Mutex_Lock>
status = _Heap_Walk( the_heap, source, do_dump );
110009: 83 c4 0c add $0xc,%esp
11000c: 8a 45 f4 mov -0xc(%ebp),%al
11000f: 0f b6 c0 movzbl %al,%eax
110012: 50 push %eax
110013: 56 push %esi
110014: 53 push %ebx
110015: e8 36 f2 ff ff call 10f250 <_Heap_Walk>
_RTEMS_Unlock_allocator();
11001a: 5a pop %edx
11001b: ff 35 80 d6 12 00 pushl 0x12d680
110021: 88 45 f4 mov %al,-0xc(%ebp)
110024: e8 33 e5 ff ff call 10e55c <_API_Mutex_Unlock>
110029: 83 c4 10 add $0x10,%esp
} else {
status = _Heap_Walk( the_heap, source, do_dump );
}
return status;
}
11002c: 8a 45 f4 mov -0xc(%ebp),%al
11002f: 8d 65 f8 lea -0x8(%ebp),%esp
110032: 5b pop %ebx
110033: 5e pop %esi
110034: c9 leave
110035: c3 ret
0010fc3c <_RTEMS_tasks_Create_extension>:
bool _RTEMS_tasks_Create_extension(
Thread_Control *executing,
Thread_Control *created
)
{
10fc3c: 55 push %ebp
10fc3d: 89 e5 mov %esp,%ebp
10fc3f: 53 push %ebx
10fc40: 83 ec 10 sub $0x10,%esp
10fc43: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Notepads must be the last entry in the structure and they
* can be left off if disabled in the configuration.
*/
to_allocate = sizeof( RTEMS_API_Control );
10fc46: 80 3d c4 22 12 00 01 cmpb $0x1,0x1222c4
10fc4d: 19 c0 sbb %eax,%eax
10fc4f: 83 e0 c0 and $0xffffffc0,%eax
10fc52: 83 c0 60 add $0x60,%eax
if ( !rtems_configuration_get_notepads_enabled() )
to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));
api = _Workspace_Allocate( to_allocate );
10fc55: 50 push %eax
10fc56: e8 15 e0 ff ff call 10dc70 <_Workspace_Allocate>
if ( !api )
10fc5b: 83 c4 10 add $0x10,%esp
10fc5e: 85 c0 test %eax,%eax
10fc60: 74 6a je 10fccc <_RTEMS_tasks_Create_extension+0x90>
return false;
created->API_Extensions[ THREAD_API_RTEMS ] = api;
10fc62: 89 83 e4 00 00 00 mov %eax,0xe4(%ebx)
api->pending_events = EVENT_SETS_NONE_PENDING;
10fc68: c7 00 00 00 00 00 movl $0x0,(%eax)
api->event_condition = 0;
10fc6e: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
*/
RTEMS_INLINE_ROUTINE void _ASR_Initialize (
ASR_Information *information
)
{
information->is_enabled = false;
10fc75: c6 40 08 00 movb $0x0,0x8(%eax)
information->handler = NULL;
10fc79: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
information->mode_set = RTEMS_DEFAULT_MODES;
10fc80: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
information->signals_posted = 0;
10fc87: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax)
information->signals_pending = 0;
10fc8e: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
information->nest_level = 0;
10fc95: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
_ASR_Initialize( &api->Signal );
created->task_variables = NULL;
10fc9c: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx)
10fca3: 00 00 00
if ( rtems_configuration_get_notepads_enabled() ) {
10fca6: 80 3d c4 22 12 00 00 cmpb $0x0,0x1222c4
10fcad: 74 13 je 10fcc2 <_RTEMS_tasks_Create_extension+0x86>
10fcaf: 31 d2 xor %edx,%edx
10fcb1: 8d 76 00 lea 0x0(%esi),%esi
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
api->Notepads[i] = 0;
10fcb4: c7 44 90 20 00 00 00 movl $0x0,0x20(%eax,%edx,4)
10fcbb: 00
api->event_condition = 0;
_ASR_Initialize( &api->Signal );
created->task_variables = NULL;
if ( rtems_configuration_get_notepads_enabled() ) {
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
10fcbc: 42 inc %edx
10fcbd: 83 fa 10 cmp $0x10,%edx
10fcc0: 75 f2 jne 10fcb4 <_RTEMS_tasks_Create_extension+0x78>
api->Notepads[i] = 0;
}
return true;
10fcc2: b0 01 mov $0x1,%al
}
10fcc4: 8b 5d fc mov -0x4(%ebp),%ebx
10fcc7: c9 leave
10fcc8: c3 ret
10fcc9: 8d 76 00 lea 0x0(%esi),%esi
to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));
api = _Workspace_Allocate( to_allocate );
if ( !api )
return false;
10fccc: 31 c0 xor %eax,%eax
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
api->Notepads[i] = 0;
}
return true;
}
10fcce: 8b 5d fc mov -0x4(%ebp),%ebx
10fcd1: c9 leave
10fcd2: c3 ret
0010fbe4 <_RTEMS_tasks_Delete_extension>:
void _RTEMS_tasks_Delete_extension(
Thread_Control *executing,
Thread_Control *deleted
)
{
10fbe4: 55 push %ebp
10fbe5: 89 e5 mov %esp,%ebp
10fbe7: 56 push %esi
10fbe8: 53 push %ebx
10fbe9: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
10fbec: 8b 86 f0 00 00 00 mov 0xf0(%esi),%eax
deleted->task_variables = NULL;
10fbf2: c7 86 f0 00 00 00 00 movl $0x0,0xf0(%esi)
10fbf9: 00 00 00
while (tvp) {
10fbfc: 85 c0 test %eax,%eax
10fbfe: 75 06 jne 10fc06 <_RTEMS_tasks_Delete_extension+0x22>
10fc00: eb 17 jmp 10fc19 <_RTEMS_tasks_Delete_extension+0x35>
10fc02: 66 90 xchg %ax,%ax
next = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
tvp = next;
10fc04: 89 d8 mov %ebx,%eax
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
next = (rtems_task_variable_t *)tvp->next;
10fc06: 8b 18 mov (%eax),%ebx
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
10fc08: 83 ec 08 sub $0x8,%esp
10fc0b: 50 push %eax
10fc0c: 56 push %esi
10fc0d: e8 56 01 00 00 call 10fd68 <_RTEMS_Tasks_Invoke_task_variable_dtor>
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
10fc12: 83 c4 10 add $0x10,%esp
10fc15: 85 db test %ebx,%ebx
10fc17: 75 eb jne 10fc04 <_RTEMS_tasks_Delete_extension+0x20>
/*
* Free API specific memory
*/
(void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] );
10fc19: 83 ec 0c sub $0xc,%esp
10fc1c: ff b6 e4 00 00 00 pushl 0xe4(%esi)
10fc22: e8 65 e0 ff ff call 10dc8c <_Workspace_Free>
deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL;
10fc27: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi)
10fc2e: 00 00 00
10fc31: 83 c4 10 add $0x10,%esp
}
10fc34: 8d 65 f8 lea -0x8(%ebp),%esp
10fc37: 5b pop %ebx
10fc38: 5e pop %esi
10fc39: c9 leave
10fc3a: c3 ret
0010fb68 <_RTEMS_tasks_Initialize_user_tasks>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks( void )
{
10fb68: 55 push %ebp
10fb69: 89 e5 mov %esp,%ebp
10fb6b: 83 ec 08 sub $0x8,%esp
if ( _RTEMS_tasks_Initialize_user_tasks_p )
10fb6e: a1 40 23 12 00 mov 0x122340,%eax
10fb73: 85 c0 test %eax,%eax
10fb75: 74 05 je 10fb7c <_RTEMS_tasks_Initialize_user_tasks+0x14>
(*_RTEMS_tasks_Initialize_user_tasks_p)();
}
10fb77: c9 leave
*/
void _RTEMS_tasks_Initialize_user_tasks( void )
{
if ( _RTEMS_tasks_Initialize_user_tasks_p )
(*_RTEMS_tasks_Initialize_user_tasks_p)();
10fb78: ff e0 jmp *%eax
10fb7a: 66 90 xchg %ax,%ax
}
10fb7c: c9 leave
10fb7d: c3 ret
0010af78 <_RTEMS_tasks_Initialize_user_tasks_body>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
10af78: 55 push %ebp
10af79: 89 e5 mov %esp,%ebp
10af7b: 57 push %edi
10af7c: 56 push %esi
10af7d: 53 push %ebx
10af7e: 83 ec 1c sub $0x1c,%esp
rtems_initialization_tasks_table *user_tasks;
/*
* Move information into local variables
*/
user_tasks = Configuration_RTEMS_API.User_initialization_tasks_table;
10af81: 8b 1d ec 22 12 00 mov 0x1222ec,%ebx
maximum = Configuration_RTEMS_API.number_of_initialization_tasks;
10af87: 8b 3d e8 22 12 00 mov 0x1222e8,%edi
/*
* Verify that we have a set of user tasks to iterate
*/
if ( !user_tasks )
10af8d: 85 db test %ebx,%ebx
10af8f: 74 46 je 10afd7 <_RTEMS_tasks_Initialize_user_tasks_body+0x5f>
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
10af91: 85 ff test %edi,%edi
10af93: 74 42 je 10afd7 <_RTEMS_tasks_Initialize_user_tasks_body+0x5f><== NEVER TAKEN
10af95: 31 f6 xor %esi,%esi
10af97: 90 nop
return_value = rtems_task_create(
10af98: 83 ec 08 sub $0x8,%esp
10af9b: 8d 45 e4 lea -0x1c(%ebp),%eax
10af9e: 50 push %eax
10af9f: ff 73 0c pushl 0xc(%ebx)
10afa2: ff 73 14 pushl 0x14(%ebx)
10afa5: ff 73 04 pushl 0x4(%ebx)
10afa8: ff 73 08 pushl 0x8(%ebx)
10afab: ff 33 pushl (%ebx)
10afad: e8 92 fd ff ff call 10ad44 <rtems_task_create>
user_tasks[ index ].stack_size,
user_tasks[ index ].mode_set,
user_tasks[ index ].attribute_set,
&id
);
if ( !rtems_is_status_successful( return_value ) )
10afb2: 83 c4 20 add $0x20,%esp
10afb5: 85 c0 test %eax,%eax
10afb7: 75 26 jne 10afdf <_RTEMS_tasks_Initialize_user_tasks_body+0x67>
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
return_value = rtems_task_start(
10afb9: 51 push %ecx
10afba: ff 73 18 pushl 0x18(%ebx)
10afbd: ff 73 10 pushl 0x10(%ebx)
10afc0: ff 75 e4 pushl -0x1c(%ebp)
10afc3: e8 24 00 00 00 call 10afec <rtems_task_start>
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
10afc8: 83 c4 10 add $0x10,%esp
10afcb: 85 c0 test %eax,%eax
10afcd: 75 10 jne 10afdf <_RTEMS_tasks_Initialize_user_tasks_body+0x67>
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
10afcf: 46 inc %esi
10afd0: 83 c3 1c add $0x1c,%ebx
10afd3: 39 f7 cmp %esi,%edi
10afd5: 77 c1 ja 10af98 <_RTEMS_tasks_Initialize_user_tasks_body+0x20><== NEVER TAKEN
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
}
}
10afd7: 8d 65 f4 lea -0xc(%ebp),%esp
10afda: 5b pop %ebx
10afdb: 5e pop %esi
10afdc: 5f pop %edi
10afdd: c9 leave
10afde: c3 ret
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
10afdf: 52 push %edx
10afe0: 50 push %eax
10afe1: 6a 01 push $0x1
10afe3: 6a 01 push $0x1
10afe5: e8 7e 0c 00 00 call 10bc68 <_Internal_error_Occurred>
0010fb80 <_RTEMS_tasks_Post_switch_extension>:
*/
void _RTEMS_tasks_Post_switch_extension(
Thread_Control *executing
)
{
10fb80: 55 push %ebp
10fb81: 89 e5 mov %esp,%ebp
10fb83: 57 push %edi
10fb84: 56 push %esi
10fb85: 53 push %ebx
10fb86: 83 ec 1c sub $0x1c,%esp
RTEMS_API_Control *api;
ASR_Information *asr;
rtems_signal_set signal_set;
Modes_Control prev_mode;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
10fb89: 8b 45 08 mov 0x8(%ebp),%eax
10fb8c: 8b 98 e4 00 00 00 mov 0xe4(%eax),%ebx
if ( !api )
10fb92: 85 db test %ebx,%ebx
10fb94: 74 45 je 10fbdb <_RTEMS_tasks_Post_switch_extension+0x5b><== NEVER TAKEN
* Signal Processing
*/
asr = &api->Signal;
_ISR_Disable( level );
10fb96: 9c pushf
10fb97: fa cli
10fb98: 58 pop %eax
signal_set = asr->signals_posted;
10fb99: 8b 73 14 mov 0x14(%ebx),%esi
asr->signals_posted = 0;
10fb9c: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
_ISR_Enable( level );
10fba3: 50 push %eax
10fba4: 9d popf
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
10fba5: 85 f6 test %esi,%esi
10fba7: 74 32 je 10fbdb <_RTEMS_tasks_Post_switch_extension+0x5b>
return;
asr->nest_level += 1;
10fba9: ff 43 1c incl 0x1c(%ebx)
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
10fbac: 50 push %eax
10fbad: 8d 7d e4 lea -0x1c(%ebp),%edi
10fbb0: 57 push %edi
10fbb1: 68 ff ff 00 00 push $0xffff
10fbb6: ff 73 10 pushl 0x10(%ebx)
10fbb9: e8 be 1d 00 00 call 11197c <rtems_task_mode>
(*asr->handler)( signal_set );
10fbbe: 89 34 24 mov %esi,(%esp)
10fbc1: ff 53 0c call *0xc(%ebx)
asr->nest_level -= 1;
10fbc4: ff 4b 1c decl 0x1c(%ebx)
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
10fbc7: 83 c4 0c add $0xc,%esp
10fbca: 57 push %edi
10fbcb: 68 ff ff 00 00 push $0xffff
10fbd0: ff 75 e4 pushl -0x1c(%ebp)
10fbd3: e8 a4 1d 00 00 call 11197c <rtems_task_mode>
10fbd8: 83 c4 10 add $0x10,%esp
}
10fbdb: 8d 65 f4 lea -0xc(%ebp),%esp
10fbde: 5b pop %ebx
10fbdf: 5e pop %esi
10fbe0: 5f pop %edi
10fbe1: c9 leave
10fbe2: c3 ret
0010fb20 <_RTEMS_tasks_Switch_extension>:
void _RTEMS_tasks_Switch_extension(
Thread_Control *executing,
Thread_Control *heir
)
{
10fb20: 55 push %ebp
10fb21: 89 e5 mov %esp,%ebp
/*
* Per Task Variables
*/
tvp = executing->task_variables;
10fb23: 8b 45 08 mov 0x8(%ebp),%eax
10fb26: 8b 80 f0 00 00 00 mov 0xf0(%eax),%eax
while (tvp) {
10fb2c: 85 c0 test %eax,%eax
10fb2e: 74 13 je 10fb43 <_RTEMS_tasks_Switch_extension+0x23>
tvp->tval = *tvp->ptr;
10fb30: 8b 50 04 mov 0x4(%eax),%edx
10fb33: 8b 0a mov (%edx),%ecx
10fb35: 89 48 0c mov %ecx,0xc(%eax)
*tvp->ptr = tvp->gval;
10fb38: 8b 48 08 mov 0x8(%eax),%ecx
10fb3b: 89 0a mov %ecx,(%edx)
tvp = (rtems_task_variable_t *)tvp->next;
10fb3d: 8b 00 mov (%eax),%eax
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
10fb3f: 85 c0 test %eax,%eax
10fb41: 75 ed jne 10fb30 <_RTEMS_tasks_Switch_extension+0x10><== NEVER TAKEN
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
10fb43: 8b 45 0c mov 0xc(%ebp),%eax
10fb46: 8b 80 f0 00 00 00 mov 0xf0(%eax),%eax
while (tvp) {
10fb4c: 85 c0 test %eax,%eax
10fb4e: 74 13 je 10fb63 <_RTEMS_tasks_Switch_extension+0x43>
tvp->gval = *tvp->ptr;
10fb50: 8b 50 04 mov 0x4(%eax),%edx
10fb53: 8b 0a mov (%edx),%ecx
10fb55: 89 48 08 mov %ecx,0x8(%eax)
*tvp->ptr = tvp->tval;
10fb58: 8b 48 0c mov 0xc(%eax),%ecx
10fb5b: 89 0a mov %ecx,(%edx)
tvp = (rtems_task_variable_t *)tvp->next;
10fb5d: 8b 00 mov (%eax),%eax
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
10fb5f: 85 c0 test %eax,%eax
10fb61: 75 ed jne 10fb50 <_RTEMS_tasks_Switch_extension+0x30><== NEVER TAKEN
tvp->gval = *tvp->ptr;
*tvp->ptr = tvp->tval;
tvp = (rtems_task_variable_t *)tvp->next;
}
}
10fb63: c9 leave
10fb64: c3 ret
0010b9d8 <_Rate_monotonic_Initiate_statistics>:
}
void _Rate_monotonic_Initiate_statistics(
Rate_monotonic_Control *the_period
)
{
10b9d8: 55 push %ebp
10b9d9: 89 e5 mov %esp,%ebp
10b9db: 57 push %edi
10b9dc: 56 push %esi
10b9dd: 53 push %ebx
10b9de: 83 ec 28 sub $0x28,%esp
10b9e1: 8b 5d 08 mov 0x8(%ebp),%ebx
Thread_Control *owning_thread = the_period->owner;
10b9e4: 8b 73 40 mov 0x40(%ebx),%esi
* If using nanosecond statistics, we need to obtain the uptime.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
Timestamp_Control uptime;
_TOD_Get_uptime( &uptime );
10b9e7: 8d 7d e0 lea -0x20(%ebp),%edi
10b9ea: 57 push %edi
10b9eb: e8 14 17 00 00 call 10d104 <_TOD_Get_uptime>
/*
* Set the starting point and the CPU time used for the statistics.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
the_period->time_period_initiated = uptime;
10b9f0: 8b 45 e0 mov -0x20(%ebp),%eax
10b9f3: 8b 55 e4 mov -0x1c(%ebp),%edx
10b9f6: 89 43 4c mov %eax,0x4c(%ebx)
10b9f9: 89 53 50 mov %edx,0x50(%ebx)
#else
the_period->time_period_initiated = _Watchdog_Ticks_since_boot;
#endif
the_period->cpu_usage_period_initiated = owning_thread->cpu_time_used;
10b9fc: 8b 86 84 00 00 00 mov 0x84(%esi),%eax
10ba02: 8b 96 88 00 00 00 mov 0x88(%esi),%edx
10ba08: 89 43 44 mov %eax,0x44(%ebx)
10ba0b: 89 53 48 mov %edx,0x48(%ebx)
* routine is invoked from rtems_rate_monotonic_period, the owner will
* be the executing thread. When this routine is invoked from
* _Rate_monotonic_Timeout, it will not.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
if (owning_thread == _Thread_Executing) {
10ba0e: 83 c4 10 add $0x10,%esp
10ba11: 39 35 18 88 12 00 cmp %esi,0x128818
10ba17: 74 0b je 10ba24 <_Rate_monotonic_Initiate_statistics+0x4c>
);
_Timespec_Add_to( &the_period->cpu_usage_period_initiated, &ran );
}
#endif
}
10ba19: 8d 65 f4 lea -0xc(%ebp),%esp
10ba1c: 5b pop %ebx
10ba1d: 5e pop %esi
10ba1e: 5f pop %edi
10ba1f: c9 leave
10ba20: c3 ret
10ba21: 8d 76 00 lea 0x0(%esi),%esi
/*
* Adjust the CPU time used to account for the time since last
* context switch.
*/
_Timespec_Subtract(
10ba24: 50 push %eax
&_Thread_Time_of_last_context_switch, &uptime, &ran
10ba25: 8d 75 d8 lea -0x28(%ebp),%esi
/*
* Adjust the CPU time used to account for the time since last
* context switch.
*/
_Timespec_Subtract(
10ba28: 56 push %esi
10ba29: 57 push %edi
10ba2a: 68 4c 86 12 00 push $0x12864c
10ba2f: e8 88 37 00 00 call 10f1bc <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch, &uptime, &ran
);
_Timespec_Add_to( &the_period->cpu_usage_period_initiated, &ran );
10ba34: 59 pop %ecx
10ba35: 5f pop %edi
10ba36: 56 push %esi
10ba37: 83 c3 44 add $0x44,%ebx
10ba3a: 53 push %ebx
10ba3b: e8 80 36 00 00 call 10f0c0 <_Timespec_Add_to>
10ba40: 83 c4 10 add $0x10,%esp
}
#endif
}
10ba43: 8d 65 f4 lea -0xc(%ebp),%esp
10ba46: 5b pop %ebx
10ba47: 5e pop %esi
10ba48: 5f pop %edi
10ba49: c9 leave
10ba4a: c3 ret
0010bf94 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
10bf94: 55 push %ebp
10bf95: 89 e5 mov %esp,%ebp
10bf97: 83 ec 2c sub $0x2c,%esp
/*
* When we get here, the Timer is already off the chain so we do not
* have to worry about that -- hence no _Watchdog_Remove().
*/
the_period = _Rate_monotonic_Get( id, &location );
10bf9a: 8d 45 f4 lea -0xc(%ebp),%eax
10bf9d: 50 push %eax
10bf9e: ff 75 08 pushl 0x8(%ebp)
10bfa1: 68 a0 84 12 00 push $0x1284a0
10bfa6: e8 d5 1b 00 00 call 10db80 <_Objects_Get>
switch ( location ) {
10bfab: 83 c4 10 add $0x10,%esp
10bfae: 8b 55 f4 mov -0xc(%ebp),%edx
10bfb1: 85 d2 test %edx,%edx
10bfb3: 75 29 jne 10bfde <_Rate_monotonic_Timeout+0x4a><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
10bfb5: 8b 50 40 mov 0x40(%eax),%edx
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
10bfb8: f6 42 11 40 testb $0x40,0x11(%edx)
10bfbc: 74 08 je 10bfc6 <_Rate_monotonic_Timeout+0x32>
10bfbe: 8b 48 08 mov 0x8(%eax),%ecx
10bfc1: 39 4a 20 cmp %ecx,0x20(%edx)
10bfc4: 74 4e je 10c014 <_Rate_monotonic_Timeout+0x80>
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
10bfc6: 83 78 38 01 cmpl $0x1,0x38(%eax)
10bfca: 74 14 je 10bfe0 <_Rate_monotonic_Timeout+0x4c>
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
10bfcc: c7 40 38 04 00 00 00 movl $0x4,0x38(%eax)
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10bfd3: a1 8c 85 12 00 mov 0x12858c,%eax
10bfd8: 48 dec %eax
10bfd9: a3 8c 85 12 00 mov %eax,0x12858c
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10bfde: c9 leave
10bfdf: c3 ret
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
10bfe0: c7 40 38 03 00 00 00 movl $0x3,0x38(%eax)
_Rate_monotonic_Initiate_statistics( the_period );
10bfe7: 83 ec 0c sub $0xc,%esp
10bfea: 50 push %eax
10bfeb: 89 45 e4 mov %eax,-0x1c(%ebp)
10bfee: e8 e5 f9 ff ff call 10b9d8 <_Rate_monotonic_Initiate_statistics>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10bff3: 8b 45 e4 mov -0x1c(%ebp),%eax
10bff6: 8b 50 3c mov 0x3c(%eax),%edx
10bff9: 89 50 1c mov %edx,0x1c(%eax)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10bffc: 5a pop %edx
10bffd: 59 pop %ecx
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
10bffe: 83 c0 10 add $0x10,%eax
10c001: 50 push %eax
10c002: 68 60 86 12 00 push $0x128660
10c007: e8 90 34 00 00 call 10f49c <_Watchdog_Insert>
10c00c: 83 c4 10 add $0x10,%esp
10c00f: eb c2 jmp 10bfd3 <_Rate_monotonic_Timeout+0x3f>
10c011: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10c014: 83 ec 08 sub $0x8,%esp
10c017: 68 f8 ff 03 10 push $0x1003fff8
10c01c: 52 push %edx
10c01d: 89 45 e4 mov %eax,-0x1c(%ebp)
10c020: e8 47 23 00 00 call 10e36c <_Thread_Clear_state>
the_thread = the_period->owner;
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
10c025: 8b 45 e4 mov -0x1c(%ebp),%eax
10c028: 89 04 24 mov %eax,(%esp)
10c02b: eb c1 jmp 10bfee <_Rate_monotonic_Timeout+0x5a>
0010ba4c <_Rate_monotonic_Update_statistics>:
void _Rate_monotonic_Update_statistics(
Rate_monotonic_Control *the_period
)
{
10ba4c: 55 push %ebp
10ba4d: 89 e5 mov %esp,%ebp
10ba4f: 57 push %edi
10ba50: 56 push %esi
10ba51: 53 push %ebx
10ba52: 83 ec 1c sub $0x1c,%esp
10ba55: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
10ba58: ff 43 54 incl 0x54(%ebx)
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
10ba5b: 83 7b 38 04 cmpl $0x4,0x38(%ebx)
10ba5f: 0f 84 bf 00 00 00 je 10bb24 <_Rate_monotonic_Update_statistics+0xd8>
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
10ba65: 51 push %ecx
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
10ba66: 8d 7d e0 lea -0x20(%ebp),%edi
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
10ba69: 57 push %edi
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
10ba6a: 8d 75 d8 lea -0x28(%ebp),%esi
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
10ba6d: 56 push %esi
10ba6e: 53 push %ebx
10ba6f: e8 cc fe ff ff call 10b940 <_Rate_monotonic_Get_status>
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
if (!valid_status)
10ba74: 83 c4 10 add $0x10,%esp
10ba77: 84 c0 test %al,%al
10ba79: 75 09 jne 10ba84 <_Rate_monotonic_Update_statistics+0x38>
stats->min_wall_time = since_last_period;
if ( since_last_period > stats->max_wall_time )
stats->max_wall_time = since_last_period;
#endif
}
10ba7b: 8d 65 f4 lea -0xc(%ebp),%esp
10ba7e: 5b pop %ebx
10ba7f: 5e pop %esi
10ba80: 5f pop %edi
10ba81: c9 leave
10ba82: c3 ret
10ba83: 90 nop
/*
* Update CPU time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_cpu_time, &executed );
10ba84: 83 ec 08 sub $0x8,%esp
10ba87: 57 push %edi
10ba88: 8d 43 6c lea 0x6c(%ebx),%eax
10ba8b: 50 push %eax
10ba8c: e8 2f 36 00 00 call 10f0c0 <_Timespec_Add_to>
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
10ba91: 58 pop %eax
10ba92: 5a pop %edx
10ba93: 8d 43 5c lea 0x5c(%ebx),%eax
10ba96: 50 push %eax
10ba97: 57 push %edi
10ba98: e8 fb 36 00 00 call 10f198 <_Timespec_Less_than>
10ba9d: 83 c4 10 add $0x10,%esp
10baa0: 84 c0 test %al,%al
10baa2: 74 0c je 10bab0 <_Rate_monotonic_Update_statistics+0x64>
stats->min_cpu_time = executed;
10baa4: 8b 45 e0 mov -0x20(%ebp),%eax
10baa7: 8b 55 e4 mov -0x1c(%ebp),%edx
10baaa: 89 43 5c mov %eax,0x5c(%ebx)
10baad: 89 53 60 mov %edx,0x60(%ebx)
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
10bab0: 83 ec 08 sub $0x8,%esp
10bab3: 8d 43 64 lea 0x64(%ebx),%eax
10bab6: 50 push %eax
10bab7: 57 push %edi
10bab8: e8 b7 36 00 00 call 10f174 <_Timespec_Greater_than>
10babd: 83 c4 10 add $0x10,%esp
10bac0: 84 c0 test %al,%al
10bac2: 74 0c je 10bad0 <_Rate_monotonic_Update_statistics+0x84>
stats->max_cpu_time = executed;
10bac4: 8b 45 e0 mov -0x20(%ebp),%eax
10bac7: 8b 55 e4 mov -0x1c(%ebp),%edx
10baca: 89 43 64 mov %eax,0x64(%ebx)
10bacd: 89 53 68 mov %edx,0x68(%ebx)
/*
* Update Wall time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
10bad0: 83 ec 08 sub $0x8,%esp
10bad3: 56 push %esi
10bad4: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax
10bada: 50 push %eax
10badb: e8 e0 35 00 00 call 10f0c0 <_Timespec_Add_to>
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
10bae0: 5a pop %edx
10bae1: 59 pop %ecx
10bae2: 8d 43 74 lea 0x74(%ebx),%eax
10bae5: 50 push %eax
10bae6: 56 push %esi
10bae7: e8 ac 36 00 00 call 10f198 <_Timespec_Less_than>
10baec: 83 c4 10 add $0x10,%esp
10baef: 84 c0 test %al,%al
10baf1: 75 39 jne 10bb2c <_Rate_monotonic_Update_statistics+0xe0>
stats->min_wall_time = since_last_period;
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
10baf3: 83 ec 08 sub $0x8,%esp
10baf6: 8d 43 7c lea 0x7c(%ebx),%eax
10baf9: 50 push %eax
10bafa: 56 push %esi
10bafb: e8 74 36 00 00 call 10f174 <_Timespec_Greater_than>
10bb00: 83 c4 10 add $0x10,%esp
10bb03: 84 c0 test %al,%al
10bb05: 0f 84 70 ff ff ff je 10ba7b <_Rate_monotonic_Update_statistics+0x2f>
stats->max_wall_time = since_last_period;
10bb0b: 8b 45 d8 mov -0x28(%ebp),%eax
10bb0e: 8b 55 dc mov -0x24(%ebp),%edx
10bb11: 89 43 7c mov %eax,0x7c(%ebx)
10bb14: 89 93 80 00 00 00 mov %edx,0x80(%ebx)
stats->min_wall_time = since_last_period;
if ( since_last_period > stats->max_wall_time )
stats->max_wall_time = since_last_period;
#endif
}
10bb1a: 8d 65 f4 lea -0xc(%ebp),%esp
10bb1d: 5b pop %ebx
10bb1e: 5e pop %esi
10bb1f: 5f pop %edi
10bb20: c9 leave
10bb21: c3 ret
10bb22: 66 90 xchg %ax,%ax
*/
stats = &the_period->Statistics;
stats->count++;
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
stats->missed_count++;
10bb24: ff 43 58 incl 0x58(%ebx)
10bb27: e9 39 ff ff ff jmp 10ba65 <_Rate_monotonic_Update_statistics+0x19>
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
stats->min_wall_time = since_last_period;
10bb2c: 8b 45 d8 mov -0x28(%ebp),%eax
10bb2f: 8b 55 dc mov -0x24(%ebp),%edx
10bb32: 89 43 74 mov %eax,0x74(%ebx)
10bb35: 89 53 78 mov %edx,0x78(%ebx)
10bb38: eb b9 jmp 10baf3 <_Rate_monotonic_Update_statistics+0xa7>
0010c4d8 <_Scheduler_priority_Block>:
#include <rtems/score/thread.h>
void _Scheduler_priority_Block(
Thread_Control *the_thread
)
{
10c4d8: 55 push %ebp
10c4d9: 89 e5 mov %esp,%ebp
10c4db: 53 push %ebx
10c4dc: 8b 45 08 mov 0x8(%ebp),%eax
)
{
Scheduler_priority_Per_thread *sched_info;
Chain_Control *ready;
sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info;
10c4df: 8b 88 8c 00 00 00 mov 0x8c(%eax),%ecx
ready = sched_info->ready_chain;
10c4e5: 8b 11 mov (%ecx),%edx
if ( _Chain_Has_only_one_node( ready ) ) {
10c4e7: 8b 5a 08 mov 0x8(%edx),%ebx
10c4ea: 39 1a cmp %ebx,(%edx)
10c4ec: 74 6e je 10c55c <_Scheduler_priority_Block+0x84>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10c4ee: 8b 08 mov (%eax),%ecx
previous = the_node->previous;
10c4f0: 8b 50 04 mov 0x4(%eax),%edx
next->previous = previous;
10c4f3: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
10c4f6: 89 0a mov %ecx,(%edx)
_Scheduler_priority_Ready_queue_extract( the_thread );
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
10c4f8: 3b 05 7c 67 12 00 cmp 0x12677c,%eax
10c4fe: 74 18 je 10c518 <_Scheduler_priority_Block+0x40>
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
10c500: 3b 05 78 67 12 00 cmp 0x126778,%eax
10c506: 74 04 je 10c50c <_Scheduler_priority_Block+0x34>
_Thread_Dispatch_necessary = true;
}
10c508: 5b pop %ebx
10c509: c9 leave
10c50a: c3 ret
10c50b: 90 nop
if ( _Thread_Is_heir( the_thread ) )
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
10c50c: c6 05 84 67 12 00 01 movb $0x1,0x126784
}
10c513: 5b pop %ebx
10c514: c9 leave
10c515: c3 ret
10c516: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{
Priority_bit_map_Control minor;
Priority_bit_map_Control major;
_Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
10c518: 66 8b 1d a0 67 12 00 mov 0x1267a0,%bx
10c51f: 31 d2 xor %edx,%edx
10c521: 89 d1 mov %edx,%ecx
10c523: 66 0f bc cb bsf %bx,%cx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10c527: 0f b7 c9 movzwl %cx,%ecx
10c52a: 66 8b 9c 09 c0 67 12 mov 0x1267c0(%ecx,%ecx,1),%bx
10c531: 00
10c532: 66 0f bc d3 bsf %bx,%dx
return (_Priority_Bits_index( major ) << 4) +
10c536: c1 e1 04 shl $0x4,%ecx
10c539: 0f b7 d2 movzwl %dx,%edx
10c53c: 8d 14 11 lea (%ecx,%edx,1),%edx
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
10c53f: 8d 14 52 lea (%edx,%edx,2),%edx
10c542: c1 e2 02 shl $0x2,%edx
10c545: 03 15 00 22 12 00 add 0x122200,%edx
10c54b: 8b 0a mov (%edx),%ecx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10c54d: 83 c2 04 add $0x4,%edx
10c550: 39 d1 cmp %edx,%ecx
10c552: 74 44 je 10c598 <_Scheduler_priority_Block+0xc0><== NEVER TAKEN
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10c554: 89 0d 7c 67 12 00 mov %ecx,0x12677c
10c55a: eb a4 jmp 10c500 <_Scheduler_priority_Block+0x28>
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
10c55c: 8d 5a 04 lea 0x4(%edx),%ebx
10c55f: 89 1a mov %ebx,(%edx)
head->next = tail;
head->previous = NULL;
10c561: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
tail->previous = head;
10c568: 89 52 08 mov %edx,0x8(%edx)
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor &= the_priority_map->block_minor;
10c56b: 8b 59 04 mov 0x4(%ecx),%ebx
10c56e: 66 8b 13 mov (%ebx),%dx
10c571: 66 23 51 0e and 0xe(%ecx),%dx
10c575: 66 89 13 mov %dx,(%ebx)
if ( *the_priority_map->minor == 0 )
10c578: 66 85 d2 test %dx,%dx
10c57b: 0f 85 77 ff ff ff jne 10c4f8 <_Scheduler_priority_Block+0x20>
_Priority_Major_bit_map &= the_priority_map->block_major;
10c581: 66 8b 15 a0 67 12 00 mov 0x1267a0,%dx
10c588: 23 51 0c and 0xc(%ecx),%edx
10c58b: 66 89 15 a0 67 12 00 mov %dx,0x1267a0
10c592: e9 61 ff ff ff jmp 10c4f8 <_Scheduler_priority_Block+0x20>
10c597: 90 nop
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
10c598: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
10c59a: eb b8 jmp 10c554 <_Scheduler_priority_Block+0x7c><== NOT EXECUTED
0010c6ec <_Scheduler_priority_Schedule>:
#include <rtems/system.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Schedule(void)
{
10c6ec: 55 push %ebp
10c6ed: 89 e5 mov %esp,%ebp
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{
Priority_bit_map_Control minor;
Priority_bit_map_Control major;
_Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
10c6ef: 66 8b 0d a0 67 12 00 mov 0x1267a0,%cx
10c6f6: 31 c0 xor %eax,%eax
10c6f8: 89 c2 mov %eax,%edx
10c6fa: 66 0f bc d1 bsf %cx,%dx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10c6fe: 0f b7 d2 movzwl %dx,%edx
10c701: 66 8b 8c 12 c0 67 12 mov 0x1267c0(%edx,%edx,1),%cx
10c708: 00
10c709: 66 0f bc c1 bsf %cx,%ax
return (_Priority_Bits_index( major ) << 4) +
10c70d: c1 e2 04 shl $0x4,%edx
10c710: 0f b7 c0 movzwl %ax,%eax
10c713: 8d 04 02 lea (%edx,%eax,1),%eax
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
10c716: 8d 04 40 lea (%eax,%eax,2),%eax
10c719: c1 e0 02 shl $0x2,%eax
10c71c: 03 05 00 22 12 00 add 0x122200,%eax
_Scheduler_priority_Schedule_body();
}
10c722: 8b 10 mov (%eax),%edx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10c724: 83 c0 04 add $0x4,%eax
10c727: 39 c2 cmp %eax,%edx
10c729: 74 09 je 10c734 <_Scheduler_priority_Schedule+0x48><== NEVER TAKEN
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10c72b: 89 15 7c 67 12 00 mov %edx,0x12677c
10c731: c9 leave
10c732: c3 ret
10c733: 90 nop
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
10c734: 31 d2 xor %edx,%edx <== NOT EXECUTED
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10c736: 89 15 7c 67 12 00 mov %edx,0x12677c <== NOT EXECUTED
10c73c: c9 leave <== NOT EXECUTED
10c73d: c3 ret <== NOT EXECUTED
0010c810 <_Scheduler_priority_Yield>:
* ready chain
* select heir
*/
void _Scheduler_priority_Yield(void)
{
10c810: 55 push %ebp
10c811: 89 e5 mov %esp,%ebp
10c813: 56 push %esi
10c814: 53 push %ebx
Scheduler_priority_Per_thread *sched_info;
ISR_Level level;
Thread_Control *executing;
Chain_Control *ready;
executing = _Thread_Executing;
10c815: a1 78 67 12 00 mov 0x126778,%eax
sched_info = (Scheduler_priority_Per_thread *) executing->scheduler_info;
ready = sched_info->ready_chain;
10c81a: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx
10c820: 8b 12 mov (%edx),%edx
_ISR_Disable( level );
10c822: 9c pushf
10c823: fa cli
10c824: 59 pop %ecx
if ( !_Chain_Has_only_one_node( ready ) ) {
10c825: 8b 5a 08 mov 0x8(%edx),%ebx
10c828: 39 1a cmp %ebx,(%edx)
10c82a: 74 40 je 10c86c <_Scheduler_priority_Yield+0x5c>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10c82c: 8b 30 mov (%eax),%esi
previous = the_node->previous;
10c82e: 8b 58 04 mov 0x4(%eax),%ebx
next->previous = previous;
10c831: 89 5e 04 mov %ebx,0x4(%esi)
previous->next = next;
10c834: 89 33 mov %esi,(%ebx)
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
10c836: 8b 5a 08 mov 0x8(%edx),%ebx
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
10c839: 8d 72 04 lea 0x4(%edx),%esi
10c83c: 89 30 mov %esi,(%eax)
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
10c83e: 89 42 08 mov %eax,0x8(%edx)
old_last->next = the_node;
10c841: 89 03 mov %eax,(%ebx)
the_node->previous = old_last;
10c843: 89 58 04 mov %ebx,0x4(%eax)
_Chain_Extract_unprotected( &executing->Object.Node );
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
10c846: 51 push %ecx
10c847: 9d popf
10c848: fa cli
if ( _Thread_Is_heir( executing ) )
10c849: 3b 05 7c 67 12 00 cmp 0x12677c,%eax
10c84f: 74 0f je 10c860 <_Scheduler_priority_Yield+0x50><== ALWAYS TAKEN
_Thread_Heir = (Thread_Control *) _Chain_First( ready );
_Thread_Dispatch_necessary = true;
}
else if ( !_Thread_Is_heir( executing ) )
_Thread_Dispatch_necessary = true;
10c851: c6 05 84 67 12 00 01 movb $0x1,0x126784
_ISR_Enable( level );
10c858: 51 push %ecx
10c859: 9d popf
}
10c85a: 5b pop %ebx
10c85b: 5e pop %esi
10c85c: c9 leave
10c85d: c3 ret
10c85e: 66 90 xchg %ax,%ax
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
if ( _Thread_Is_heir( executing ) )
_Thread_Heir = (Thread_Control *) _Chain_First( ready );
10c860: 8b 02 mov (%edx),%eax
10c862: a3 7c 67 12 00 mov %eax,0x12677c
10c867: eb e8 jmp 10c851 <_Scheduler_priority_Yield+0x41>
10c869: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Dispatch_necessary = true;
}
else if ( !_Thread_Is_heir( executing ) )
10c86c: 3b 05 7c 67 12 00 cmp 0x12677c,%eax
10c872: 75 dd jne 10c851 <_Scheduler_priority_Yield+0x41><== NEVER TAKEN
10c874: eb e2 jmp 10c858 <_Scheduler_priority_Yield+0x48>
0010caa4 <_Scheduler_simple_Ready_queue_Enqueue>:
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Ready_queue_Enqueue(
Thread_Control *the_thread
)
{
10caa4: 55 push %ebp
10caa5: 89 e5 mov %esp,%ebp
10caa7: 56 push %esi
10caa8: 53 push %ebx
10caa9: 8b 75 08 mov 0x8(%ebp),%esi
Chain_Control *ready;
Chain_Node *the_node;
Thread_Control *current;
ready = (Chain_Control *)_Scheduler.information;
10caac: 8b 15 60 21 12 00 mov 0x122160,%edx
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
10cab2: 8b 02 mov (%edx),%eax
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
10cab4: 8d 4a 04 lea 0x4(%edx),%ecx
ready = (Chain_Control *)_Scheduler.information;
the_node = _Chain_First( ready );
current = (Thread_Control *)ready;
for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
10cab7: 39 c8 cmp %ecx,%eax
10cab9: 74 1a je 10cad5 <_Scheduler_simple_Ready_queue_Enqueue+0x31>
current = (Thread_Control *) the_node;
10cabb: 89 c2 mov %eax,%edx
/* break when AT END OR PAST our priority */
if ( the_thread->current_priority < current->current_priority ) {
10cabd: 8b 5e 14 mov 0x14(%esi),%ebx
10cac0: 3b 58 14 cmp 0x14(%eax),%ebx
10cac3: 73 0a jae 10cacf <_Scheduler_simple_Ready_queue_Enqueue+0x2b>
10cac5: eb 21 jmp 10cae8 <_Scheduler_simple_Ready_queue_Enqueue+0x44>
10cac7: 90 nop
ready = (Chain_Control *)_Scheduler.information;
the_node = _Chain_First( ready );
current = (Thread_Control *)ready;
for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
current = (Thread_Control *) the_node;
10cac8: 89 c2 mov %eax,%edx
/* break when AT END OR PAST our priority */
if ( the_thread->current_priority < current->current_priority ) {
10caca: 39 58 14 cmp %ebx,0x14(%eax)
10cacd: 77 19 ja 10cae8 <_Scheduler_simple_Ready_queue_Enqueue+0x44>
ready = (Chain_Control *)_Scheduler.information;
the_node = _Chain_First( ready );
current = (Thread_Control *)ready;
for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
10cacf: 8b 00 mov (%eax),%eax
10cad1: 39 c8 cmp %ecx,%eax
10cad3: 75 f3 jne 10cac8 <_Scheduler_simple_Ready_queue_Enqueue+0x24>
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10cad5: 89 56 04 mov %edx,0x4(%esi)
before_node = after_node->next;
10cad8: 8b 02 mov (%edx),%eax
after_node->next = the_node;
10cada: 89 32 mov %esi,(%edx)
the_node->next = before_node;
10cadc: 89 06 mov %eax,(%esi)
before_node->previous = the_node;
10cade: 89 70 04 mov %esi,0x4(%eax)
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
10cae1: 5b pop %ebx
10cae2: 5e pop %esi
10cae3: c9 leave
10cae4: c3 ret
10cae5: 8d 76 00 lea 0x0(%esi),%esi
for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) {
current = (Thread_Control *) the_node;
/* break when AT END OR PAST our priority */
if ( the_thread->current_priority < current->current_priority ) {
current = (Thread_Control *)current->Object.Node.previous;
10cae8: 8b 50 04 mov 0x4(%eax),%edx
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10caeb: 89 56 04 mov %edx,0x4(%esi)
before_node = after_node->next;
10caee: 8b 02 mov (%edx),%eax
after_node->next = the_node;
10caf0: 89 32 mov %esi,(%edx)
the_node->next = before_node;
10caf2: 89 06 mov %eax,(%esi)
before_node->previous = the_node;
10caf4: 89 70 04 mov %esi,0x4(%eax)
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
10caf7: 5b pop %ebx
10caf8: 5e pop %esi
10caf9: c9 leave
10cafa: c3 ret
0010ca74 <_Scheduler_simple_Ready_queue_Enqueue_first>:
#include <rtems/score/schedulersimple.h>
void _Scheduler_simple_Ready_queue_Enqueue_first(
Thread_Control *the_thread
)
{
10ca74: 55 push %ebp
10ca75: 89 e5 mov %esp,%ebp
10ca77: 8b 4d 08 mov 0x8(%ebp),%ecx
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
10ca7a: a1 60 21 12 00 mov 0x122160,%eax
10ca7f: 8b 00 mov (%eax),%eax
*/
for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
current = (Thread_Control *) the_node;
/* break when AT HEAD OF (or PAST) our priority */
if ( the_thread->current_priority <= current->current_priority ) {
10ca81: 8b 51 14 mov 0x14(%ecx),%edx
10ca84: 3b 50 14 cmp 0x14(%eax),%edx
10ca87: 76 0a jbe 10ca93 <_Scheduler_simple_Ready_queue_Enqueue_first+0x1f>
10ca89: 8d 76 00 lea 0x0(%esi),%esi
* Do NOT need to check for end of chain because there is always
* at least one task on the ready chain -- the IDLE task. It can
* never block, should never attempt to obtain a semaphore or mutex,
* and thus will always be there.
*/
for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) {
10ca8c: 8b 00 mov (%eax),%eax
current = (Thread_Control *) the_node;
/* break when AT HEAD OF (or PAST) our priority */
if ( the_thread->current_priority <= current->current_priority ) {
10ca8e: 39 50 14 cmp %edx,0x14(%eax)
10ca91: 72 f9 jb 10ca8c <_Scheduler_simple_Ready_queue_Enqueue_first+0x18><== NEVER TAKEN
current = (Thread_Control *)current->Object.Node.previous;
10ca93: 8b 40 04 mov 0x4(%eax),%eax
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10ca96: 89 41 04 mov %eax,0x4(%ecx)
before_node = after_node->next;
10ca99: 8b 10 mov (%eax),%edx
after_node->next = the_node;
10ca9b: 89 08 mov %ecx,(%eax)
the_node->next = before_node;
10ca9d: 89 11 mov %edx,(%ecx)
before_node->previous = the_node;
10ca9f: 89 4a 04 mov %ecx,0x4(%edx)
}
}
/* enqueue */
_Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node );
}
10caa2: c9 leave
10caa3: c3 ret
0010ce7c <_TOD_Set>:
*/
void _TOD_Set(
const struct timespec *time
)
{
10ce7c: 55 push %ebp
10ce7d: 89 e5 mov %esp,%ebp
10ce7f: 53 push %ebx
10ce80: 83 ec 04 sub $0x4,%esp
10ce83: 8b 5d 08 mov 0x8(%ebp),%ebx
10ce86: a1 cc 98 12 00 mov 0x1298cc,%eax
10ce8b: 40 inc %eax
10ce8c: a3 cc 98 12 00 mov %eax,0x1298cc
long seconds;
_Thread_Disable_dispatch();
_TOD_Deactivate();
seconds = _TOD_Seconds_since_epoch();
10ce91: a1 68 99 12 00 mov 0x129968,%eax
if ( time->tv_sec < seconds )
10ce96: 8b 13 mov (%ebx),%edx
10ce98: 39 d0 cmp %edx,%eax
10ce9a: 7f 34 jg 10ced0 <_TOD_Set+0x54>
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
_Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units );
10ce9c: 51 push %ecx
_Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec );
else
_Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - seconds );
10ce9d: 29 c2 sub %eax,%edx
10ce9f: 52 push %edx
10cea0: 6a 00 push $0x0
10cea2: 68 94 99 12 00 push $0x129994
10cea7: e8 7c 23 00 00 call 10f228 <_Watchdog_Adjust>
10ceac: 83 c4 10 add $0x10,%esp
/* POSIX format TOD (timespec) */
_Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );
10ceaf: 8b 03 mov (%ebx),%eax
10ceb1: a3 68 99 12 00 mov %eax,0x129968
10ceb6: 8b 43 04 mov 0x4(%ebx),%eax
10ceb9: a3 6c 99 12 00 mov %eax,0x12996c
_TOD_Is_set = true;
10cebe: c6 05 dc 98 12 00 01 movb $0x1,0x1298dc
_TOD_Activate();
_Thread_Enable_dispatch();
}
10cec5: 8b 5d fc mov -0x4(%ebp),%ebx
10cec8: c9 leave
_Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );
_TOD_Is_set = true;
_TOD_Activate();
_Thread_Enable_dispatch();
10cec9: e9 4e 15 00 00 jmp 10e41c <_Thread_Enable_dispatch>
10cece: 66 90 xchg %ax,%ax
10ced0: 51 push %ecx
_TOD_Deactivate();
seconds = _TOD_Seconds_since_epoch();
if ( time->tv_sec < seconds )
_Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec );
10ced1: 29 d0 sub %edx,%eax
10ced3: 50 push %eax
10ced4: 6a 01 push $0x1
10ced6: 68 94 99 12 00 push $0x129994
10cedb: e8 48 23 00 00 call 10f228 <_Watchdog_Adjust>
10cee0: 83 c4 10 add $0x10,%esp
10cee3: eb ca jmp 10ceaf <_TOD_Set+0x33>
0010b888 <_TOD_Tickle_ticks>:
*
* Output parameters: NONE
*/
void _TOD_Tickle_ticks( void )
{
10b888: 55 push %ebp
10b889: 89 e5 mov %esp,%ebp
10b88b: 53 push %ebx
10b88c: 83 ec 1c sub $0x1c,%esp
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
10b88f: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
10b896: a1 0c 23 12 00 mov 0x12230c,%eax
10b89b: 8d 04 80 lea (%eax,%eax,4),%eax
10b89e: 8d 04 80 lea (%eax,%eax,4),%eax
10b8a1: 8d 04 80 lea (%eax,%eax,4),%eax
10b8a4: c1 e0 03 shl $0x3,%eax
10b8a7: 89 45 f4 mov %eax,-0xc(%ebp)
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
10b8aa: a1 24 66 12 00 mov 0x126624,%eax
10b8af: 40 inc %eax
10b8b0: a3 24 66 12 00 mov %eax,0x126624
/* Update the timespec format uptime */
_Timestamp_Add_to( &_TOD_Uptime, &tick );
10b8b5: 8d 5d f0 lea -0x10(%ebp),%ebx
10b8b8: 53 push %ebx
10b8b9: 68 78 65 12 00 push $0x126578
10b8be: e8 29 1e 00 00 call 10d6ec <_Timespec_Add_to>
/* we do not care how much the uptime changed */
/* Update the timespec format TOD */
seconds = _Timestamp_Add_to_at_tick( &_TOD_Now, &tick );
10b8c3: 58 pop %eax
10b8c4: 5a pop %edx
10b8c5: 53 push %ebx
10b8c6: 68 88 65 12 00 push $0x126588
10b8cb: e8 1c 1e 00 00 call 10d6ec <_Timespec_Add_to>
10b8d0: 89 c3 mov %eax,%ebx
while ( seconds ) {
10b8d2: 83 c4 10 add $0x10,%esp
10b8d5: 85 c0 test %eax,%eax
10b8d7: 74 16 je 10b8ef <_TOD_Tickle_ticks+0x67>
10b8d9: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void )
{
_Watchdog_Tickle( &_Watchdog_Seconds_chain );
10b8dc: 83 ec 0c sub $0xc,%esp
10b8df: 68 b4 65 12 00 push $0x1265b4
10b8e4: e8 cb 22 00 00 call 10dbb4 <_Watchdog_Tickle>
10b8e9: 83 c4 10 add $0x10,%esp
10b8ec: 4b dec %ebx
10b8ed: 75 ed jne 10b8dc <_TOD_Tickle_ticks+0x54><== NEVER TAKEN
_Watchdog_Tickle_seconds();
seconds--;
}
}
10b8ef: 8b 5d fc mov -0x4(%ebp),%ebx
10b8f2: c9 leave
10b8f3: c3 ret
0010b7bc <_TOD_To_seconds>:
*/
uint32_t _TOD_To_seconds(
const rtems_time_of_day *the_tod
)
{
10b7bc: 55 push %ebp
10b7bd: 89 e5 mov %esp,%ebp
10b7bf: 56 push %esi
10b7c0: 53 push %ebx
10b7c1: 8b 55 08 mov 0x8(%ebp),%edx
uint32_t time;
uint32_t year_mod_4;
time = the_tod->day - 1;
10b7c4: 8b 72 08 mov 0x8(%edx),%esi
10b7c7: 4e dec %esi
year_mod_4 = the_tod->year & 3;
10b7c8: 8b 02 mov (%edx),%eax
if ( year_mod_4 == 0 )
10b7ca: 89 c3 mov %eax,%ebx
10b7cc: 83 e3 03 and $0x3,%ebx
10b7cf: 74 67 je 10b838 <_TOD_To_seconds+0x7c>
time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
else
time += _TOD_Days_to_date[ 0 ][ the_tod->month ];
10b7d1: 8b 4a 04 mov 0x4(%edx),%ecx
10b7d4: 0f b7 8c 09 c0 27 12 movzwl 0x1227c0(%ecx,%ecx,1),%ecx
10b7db: 00
10b7dc: 8d 34 31 lea (%ecx,%esi,1),%esi
time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
( (TOD_DAYS_PER_YEAR * 4) + 1);
time += _TOD_Days_since_last_leap_year[ year_mod_4 ];
10b7df: 0f b7 8c 1b f4 27 12 movzwl 0x1227f4(%ebx,%ebx,1),%ecx
10b7e6: 00
if ( year_mod_4 == 0 )
time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
else
time += _TOD_Days_to_date[ 0 ][ the_tod->month ];
time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
10b7e7: 2d c4 07 00 00 sub $0x7c4,%eax
10b7ec: c1 e8 02 shr $0x2,%eax
10b7ef: 8d 1c c0 lea (%eax,%eax,8),%ebx
10b7f2: 8d 1c d8 lea (%eax,%ebx,8),%ebx
10b7f5: 8d 1c 9b lea (%ebx,%ebx,4),%ebx
10b7f8: 8d 04 98 lea (%eax,%ebx,4),%eax
10b7fb: 01 c1 add %eax,%ecx
( (TOD_DAYS_PER_YEAR * 4) + 1);
time += _TOD_Days_since_last_leap_year[ year_mod_4 ];
10b7fd: 01 f1 add %esi,%ecx
time *= TOD_SECONDS_PER_DAY;
10b7ff: 8d 04 89 lea (%ecx,%ecx,4),%eax
10b802: 8d 04 81 lea (%ecx,%eax,4),%eax
10b805: 8d 04 c1 lea (%ecx,%eax,8),%eax
10b808: c1 e0 02 shl $0x2,%eax
10b80b: 29 c8 sub %ecx,%eax
10b80d: c1 e0 07 shl $0x7,%eax
time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
10b810: 8b 5a 14 mov 0x14(%edx),%ebx
10b813: 8b 4a 0c mov 0xc(%edx),%ecx
10b816: 8d 0c 49 lea (%ecx,%ecx,2),%ecx
10b819: 8d 0c 89 lea (%ecx,%ecx,4),%ecx
10b81c: c1 e1 02 shl $0x2,%ecx
10b81f: 03 4a 10 add 0x10(%edx),%ecx
* TOD_SECONDS_PER_MINUTE;
10b822: 8d 14 49 lea (%ecx,%ecx,2),%edx
10b825: 8d 14 92 lea (%edx,%edx,4),%edx
time += the_tod->second;
10b828: 8d 94 93 00 e5 da 21 lea 0x21dae500(%ebx,%edx,4),%edx
time += TOD_SECONDS_1970_THROUGH_1988;
10b82f: 8d 04 02 lea (%edx,%eax,1),%eax
return( time );
}
10b832: 5b pop %ebx
10b833: 5e pop %esi
10b834: c9 leave
10b835: c3 ret
10b836: 66 90 xchg %ax,%ax
time = the_tod->day - 1;
year_mod_4 = the_tod->year & 3;
if ( year_mod_4 == 0 )
time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
10b838: 8b 4a 04 mov 0x4(%edx),%ecx
10b83b: 0f b7 8c 09 da 27 12 movzwl 0x1227da(%ecx,%ecx,1),%ecx
10b842: 00
10b843: 8d 34 31 lea (%ecx,%esi,1),%esi
10b846: eb 97 jmp 10b7df <_TOD_To_seconds+0x23>
0010b848 <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
10b848: 55 push %ebp
10b849: 89 e5 mov %esp,%ebp
10b84b: 53 push %ebx
10b84c: 8b 4d 08 mov 0x8(%ebp),%ecx
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
10b84f: 8b 1d 6c 52 12 00 mov 0x12526c,%ebx
if ((!the_tod) ||
10b855: 85 c9 test %ecx,%ecx
10b857: 74 53 je 10b8ac <_TOD_Validate+0x64> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
10b859: b8 40 42 0f 00 mov $0xf4240,%eax
10b85e: 31 d2 xor %edx,%edx
10b860: f7 f3 div %ebx
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
10b862: 3b 41 18 cmp 0x18(%ecx),%eax
10b865: 76 45 jbe 10b8ac <_TOD_Validate+0x64>
(the_tod->ticks >= ticks_per_second) ||
10b867: 83 79 14 3b cmpl $0x3b,0x14(%ecx)
10b86b: 77 3f ja 10b8ac <_TOD_Validate+0x64>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
10b86d: 83 79 10 3b cmpl $0x3b,0x10(%ecx)
10b871: 77 39 ja 10b8ac <_TOD_Validate+0x64>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
10b873: 83 79 0c 17 cmpl $0x17,0xc(%ecx)
10b877: 77 33 ja 10b8ac <_TOD_Validate+0x64>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
10b879: 8b 41 04 mov 0x4(%ecx),%eax
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
10b87c: 85 c0 test %eax,%eax
10b87e: 74 2c je 10b8ac <_TOD_Validate+0x64> <== NEVER TAKEN
(the_tod->month == 0) ||
10b880: 83 f8 0c cmp $0xc,%eax
10b883: 77 27 ja 10b8ac <_TOD_Validate+0x64>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10b885: 8b 11 mov (%ecx),%edx
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
10b887: 81 fa c3 07 00 00 cmp $0x7c3,%edx
10b88d: 76 1d jbe 10b8ac <_TOD_Validate+0x64>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
10b88f: 8b 49 08 mov 0x8(%ecx),%ecx
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10b892: 85 c9 test %ecx,%ecx
10b894: 74 16 je 10b8ac <_TOD_Validate+0x64> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
10b896: 83 e2 03 and $0x3,%edx
10b899: 75 16 jne 10b8b1 <_TOD_Validate+0x69>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
10b89b: 8b 04 85 34 28 12 00 mov 0x122834(,%eax,4),%eax
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
10b8a2: 39 c8 cmp %ecx,%eax
10b8a4: 0f 93 c0 setae %al
10b8a7: eb 05 jmp 10b8ae <_TOD_Validate+0x66>
10b8a9: 8d 76 00 lea 0x0(%esi),%esi
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
10b8ac: 31 c0 xor %eax,%eax
if ( the_tod->day > days_in_month )
return false;
return true;
}
10b8ae: 5b pop %ebx
10b8af: c9 leave
10b8b0: c3 ret
return false;
if ( (the_tod->year % 4) == 0 )
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
10b8b1: 8b 04 85 00 28 12 00 mov 0x122800(,%eax,4),%eax
10b8b8: eb e8 jmp 10b8a2 <_TOD_Validate+0x5a>
0010c8c4 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
10c8c4: 55 push %ebp
10c8c5: 89 e5 mov %esp,%ebp
10c8c7: 57 push %edi
10c8c8: 56 push %esi
10c8c9: 53 push %ebx
10c8ca: 83 ec 28 sub $0x28,%esp
10c8cd: 8b 5d 08 mov 0x8(%ebp),%ebx
10c8d0: 8b 75 0c mov 0xc(%ebp),%esi
10c8d3: 8a 45 10 mov 0x10(%ebp),%al
10c8d6: 88 45 e7 mov %al,-0x19(%ebp)
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
10c8d9: 8b 7b 10 mov 0x10(%ebx),%edi
/*
* Set a transient state for the thread so it is pulled off the Ready chains.
* This will prevent it from being scheduled no matter what happens in an
* ISR.
*/
_Thread_Set_transient( the_thread );
10c8dc: 53 push %ebx
10c8dd: e8 4a 0c 00 00 call 10d52c <_Thread_Set_transient>
/*
* Do not bother recomputing all the priority related information if
* we are not REALLY changing priority.
*/
if ( the_thread->current_priority != new_priority )
10c8e2: 83 c4 10 add $0x10,%esp
10c8e5: 39 73 14 cmp %esi,0x14(%ebx)
10c8e8: 74 0d je 10c8f7 <_Thread_Change_priority+0x33>
_Thread_Set_priority( the_thread, new_priority );
10c8ea: 83 ec 08 sub $0x8,%esp
10c8ed: 56 push %esi
10c8ee: 53 push %ebx
10c8ef: e8 e4 0b 00 00 call 10d4d8 <_Thread_Set_priority>
10c8f4: 83 c4 10 add $0x10,%esp
_ISR_Disable( level );
10c8f7: 9c pushf
10c8f8: fa cli
10c8f9: 5e pop %esi
/*
* If the thread has more than STATES_TRANSIENT set, then it is blocked,
* If it is blocked on a thread queue, then we need to requeue it.
*/
state = the_thread->current_state;
10c8fa: 8b 43 10 mov 0x10(%ebx),%eax
if ( state != STATES_TRANSIENT ) {
10c8fd: 83 f8 04 cmp $0x4,%eax
10c900: 74 22 je 10c924 <_Thread_Change_priority+0x60>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
10c902: 83 e7 04 and $0x4,%edi
10c905: 74 11 je 10c918 <_Thread_Change_priority+0x54><== ALWAYS TAKEN
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
10c907: 56 push %esi
10c908: 9d popf
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10c909: a9 e0 be 03 00 test $0x3bee0,%eax
10c90e: 75 60 jne 10c970 <_Thread_Change_priority+0xac>
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
10c910: 8d 65 f4 lea -0xc(%ebp),%esp
10c913: 5b pop %ebx
10c914: 5e pop %esi
10c915: 5f pop %edi
10c916: c9 leave
10c917: c3 ret
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
10c918: 89 c2 mov %eax,%edx
10c91a: 83 e2 fb and $0xfffffffb,%edx
10c91d: 89 53 10 mov %edx,0x10(%ebx)
10c920: eb e5 jmp 10c907 <_Thread_Change_priority+0x43>
10c922: 66 90 xchg %ax,%ax
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
10c924: 83 e7 04 and $0x4,%edi
10c927: 75 1a jne 10c943 <_Thread_Change_priority+0x7f><== NEVER TAKEN
* Interrupts are STILL disabled.
* We now know the thread will be in the READY state when we remove
* the TRANSIENT state. So we have to place it on the appropriate
* Ready Queue with interrupts off.
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
10c929: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
if ( prepend_it )
10c930: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
10c934: 74 52 je 10c988 <_Thread_Change_priority+0xc4>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
10c936: 83 ec 0c sub $0xc,%esp
10c939: 53 push %ebx
10c93a: ff 15 28 22 12 00 call *0x122228
10c940: 83 c4 10 add $0x10,%esp
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
10c943: 56 push %esi
10c944: 9d popf
10c945: fa cli
* This kernel routine implements the scheduling decision logic for
* the scheduler. It does NOT dispatch.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void )
{
_Scheduler.Operations.schedule();
10c946: ff 15 08 22 12 00 call *0x122208
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
10c94c: a1 78 67 12 00 mov 0x126778,%eax
* We altered the set of thread priorities. So let's figure out
* who is the heir and if we need to switch to them.
*/
_Scheduler_Schedule();
if ( !_Thread_Is_executing_also_the_heir() &&
10c951: 3b 05 7c 67 12 00 cmp 0x12677c,%eax
10c957: 74 0d je 10c966 <_Thread_Change_priority+0xa2>
10c959: 80 78 74 00 cmpb $0x0,0x74(%eax)
10c95d: 74 07 je 10c966 <_Thread_Change_priority+0xa2>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
10c95f: c6 05 84 67 12 00 01 movb $0x1,0x126784
_ISR_Enable( level );
10c966: 56 push %esi
10c967: 9d popf
}
10c968: 8d 65 f4 lea -0xc(%ebp),%esp
10c96b: 5b pop %ebx
10c96c: 5e pop %esi
10c96d: 5f pop %edi
10c96e: c9 leave
10c96f: c3 ret
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
if ( _States_Is_waiting_on_thread_queue( state ) ) {
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
10c970: 89 5d 0c mov %ebx,0xc(%ebp)
10c973: 8b 43 44 mov 0x44(%ebx),%eax
10c976: 89 45 08 mov %eax,0x8(%ebp)
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
10c979: 8d 65 f4 lea -0xc(%ebp),%esp
10c97c: 5b pop %ebx
10c97d: 5e pop %esi
10c97e: 5f pop %edi
10c97f: c9 leave
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
if ( _States_Is_waiting_on_thread_queue( state ) ) {
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
10c980: e9 bb 0a 00 00 jmp 10d440 <_Thread_queue_Requeue>
10c985: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
10c988: 83 ec 0c sub $0xc,%esp
10c98b: 53 push %ebx
10c98c: ff 15 24 22 12 00 call *0x122224
10c992: 83 c4 10 add $0x10,%esp
10c995: eb ac jmp 10c943 <_Thread_Change_priority+0x7f>
0010c998 <_Thread_Clear_state>:
*/
void _Thread_Clear_state(
Thread_Control *the_thread,
States_Control state
)
{
10c998: 55 push %ebp
10c999: 89 e5 mov %esp,%ebp
10c99b: 53 push %ebx
10c99c: 83 ec 04 sub $0x4,%esp
10c99f: 8b 55 08 mov 0x8(%ebp),%edx
10c9a2: 8b 45 0c mov 0xc(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10c9a5: 9c pushf
10c9a6: fa cli
10c9a7: 5b pop %ebx
current_state = the_thread->current_state;
10c9a8: 8b 4a 10 mov 0x10(%edx),%ecx
if ( current_state & state ) {
10c9ab: 85 c8 test %ecx,%eax
10c9ad: 74 0b je 10c9ba <_Thread_Clear_state+0x22>
10c9af: f7 d0 not %eax
10c9b1: 21 c8 and %ecx,%eax
current_state =
the_thread->current_state = _States_Clear( state, current_state );
10c9b3: 89 42 10 mov %eax,0x10(%edx)
if ( _States_Is_ready( current_state ) ) {
10c9b6: 85 c0 test %eax,%eax
10c9b8: 74 0a je 10c9c4 <_Thread_Clear_state+0x2c>
_Scheduler_Unblock( the_thread );
}
}
_ISR_Enable( level );
10c9ba: 53 push %ebx
10c9bb: 9d popf
}
10c9bc: 8b 5d fc mov -0x4(%ebp),%ebx
10c9bf: c9 leave
10c9c0: c3 ret
10c9c1: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(
Thread_Control *the_thread
)
{
_Scheduler.Operations.unblock( the_thread );
10c9c4: 83 ec 0c sub $0xc,%esp
10c9c7: 52 push %edx
10c9c8: ff 15 14 22 12 00 call *0x122214
10c9ce: 83 c4 10 add $0x10,%esp
10c9d1: eb e7 jmp 10c9ba <_Thread_Clear_state+0x22>
0010cb48 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10cb48: 55 push %ebp
10cb49: 89 e5 mov %esp,%ebp
10cb4b: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10cb4e: 8d 45 f4 lea -0xc(%ebp),%eax
10cb51: 50 push %eax
10cb52: ff 75 08 pushl 0x8(%ebp)
10cb55: e8 c6 01 00 00 call 10cd20 <_Thread_Get>
switch ( location ) {
10cb5a: 83 c4 10 add $0x10,%esp
10cb5d: 8b 55 f4 mov -0xc(%ebp),%edx
10cb60: 85 d2 test %edx,%edx
10cb62: 75 1c jne 10cb80 <_Thread_Delay_ended+0x38><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
10cb64: 83 ec 08 sub $0x8,%esp
10cb67: 68 18 00 00 10 push $0x10000018
10cb6c: 50 push %eax
10cb6d: e8 26 fe ff ff call 10c998 <_Thread_Clear_state>
10cb72: a1 ec 64 12 00 mov 0x1264ec,%eax
10cb77: 48 dec %eax
10cb78: a3 ec 64 12 00 mov %eax,0x1264ec
10cb7d: 83 c4 10 add $0x10,%esp
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
10cb80: c9 leave
10cb81: c3 ret
0010cb84 <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
10cb84: 55 push %ebp
10cb85: 89 e5 mov %esp,%ebp
10cb87: 57 push %edi
10cb88: 56 push %esi
10cb89: 53 push %ebx
10cb8a: 83 ec 1c sub $0x1c,%esp
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
10cb8d: 8b 1d 78 67 12 00 mov 0x126778,%ebx
_ISR_Disable( level );
10cb93: 9c pushf
10cb94: fa cli
10cb95: 58 pop %eax
while ( _Thread_Dispatch_necessary == true ) {
10cb96: 8a 15 84 67 12 00 mov 0x126784,%dl
10cb9c: 84 d2 test %dl,%dl
10cb9e: 0f 84 3c 01 00 00 je 10cce0 <_Thread_Dispatch+0x15c>
heir = _Thread_Heir;
10cba4: 8b 35 7c 67 12 00 mov 0x12677c,%esi
_Thread_Dispatch_disable_level = 1;
10cbaa: c7 05 ec 64 12 00 01 movl $0x1,0x1264ec
10cbb1: 00 00 00
_Thread_Dispatch_necessary = false;
10cbb4: c6 05 84 67 12 00 00 movb $0x0,0x126784
_Thread_Executing = heir;
10cbbb: 89 35 78 67 12 00 mov %esi,0x126778
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
10cbc1: 39 f3 cmp %esi,%ebx
10cbc3: 0f 84 17 01 00 00 je 10cce0 <_Thread_Dispatch+0x15c>
10cbc9: 8d 7d d8 lea -0x28(%ebp),%edi
10cbcc: e9 f5 00 00 00 jmp 10ccc6 <_Thread_Dispatch+0x142>
10cbd1: 8d 76 00 lea 0x0(%esi),%esi
rtems_ada_self = heir->rtems_ada_self;
#endif
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
_ISR_Enable( level );
10cbd4: 50 push %eax
10cbd5: 9d popf
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
10cbd6: 83 ec 0c sub $0xc,%esp
10cbd9: 8d 45 e0 lea -0x20(%ebp),%eax
10cbdc: 50 push %eax
10cbdd: e8 46 36 00 00 call 110228 <_TOD_Get_uptime>
_Timestamp_Subtract(
10cbe2: 83 c4 0c add $0xc,%esp
10cbe5: 57 push %edi
10cbe6: 8d 45 e0 lea -0x20(%ebp),%eax
10cbe9: 50 push %eax
10cbea: 68 ac 65 12 00 push $0x1265ac
10cbef: e8 34 0b 00 00 call 10d728 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
10cbf4: 58 pop %eax
10cbf5: 5a pop %edx
10cbf6: 57 push %edi
10cbf7: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax
10cbfd: 50 push %eax
10cbfe: e8 e9 0a 00 00 call 10d6ec <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
10cc03: 8b 45 e0 mov -0x20(%ebp),%eax
10cc06: 8b 55 e4 mov -0x1c(%ebp),%edx
10cc09: a3 ac 65 12 00 mov %eax,0x1265ac
10cc0e: 89 15 b0 65 12 00 mov %edx,0x1265b0
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
10cc14: a1 84 65 12 00 mov 0x126584,%eax
10cc19: 83 c4 10 add $0x10,%esp
10cc1c: 85 c0 test %eax,%eax
10cc1e: 74 10 je 10cc30 <_Thread_Dispatch+0xac> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
10cc20: 8b 10 mov (%eax),%edx
10cc22: 89 93 e0 00 00 00 mov %edx,0xe0(%ebx)
*_Thread_libc_reent = heir->libc_reent;
10cc28: 8b 96 e0 00 00 00 mov 0xe0(%esi),%edx
10cc2e: 89 10 mov %edx,(%eax)
}
_User_extensions_Thread_switch( executing, heir );
10cc30: 83 ec 08 sub $0x8,%esp
10cc33: 56 push %esi
10cc34: 53 push %ebx
10cc35: e8 8e 0d 00 00 call 10d9c8 <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
10cc3a: 5a pop %edx
10cc3b: 59 pop %ecx
10cc3c: 81 c6 c4 00 00 00 add $0xc4,%esi
10cc42: 56 push %esi
10cc43: 8d 83 c4 00 00 00 lea 0xc4(%ebx),%eax
10cc49: 50 push %eax
10cc4a: e8 81 10 00 00 call 10dcd0 <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
10cc4f: 83 c4 10 add $0x10,%esp
10cc52: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax
10cc58: 85 c0 test %eax,%eax
10cc5a: 74 36 je 10cc92 <_Thread_Dispatch+0x10e>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
10cc5c: a1 80 65 12 00 mov 0x126580,%eax
10cc61: 39 c3 cmp %eax,%ebx
10cc63: 74 2d je 10cc92 <_Thread_Dispatch+0x10e>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
10cc65: 85 c0 test %eax,%eax
10cc67: 74 11 je 10cc7a <_Thread_Dispatch+0xf6>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10cc69: 83 ec 0c sub $0xc,%esp
10cc6c: 05 dc 00 00 00 add $0xdc,%eax
10cc71: 50 push %eax
10cc72: e8 8d 10 00 00 call 10dd04 <_CPU_Context_save_fp>
10cc77: 83 c4 10 add $0x10,%esp
_Context_Restore_fp( &executing->fp_context );
10cc7a: 83 ec 0c sub $0xc,%esp
10cc7d: 8d 83 dc 00 00 00 lea 0xdc(%ebx),%eax
10cc83: 50 push %eax
10cc84: e8 85 10 00 00 call 10dd0e <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
10cc89: 89 1d 80 65 12 00 mov %ebx,0x126580
10cc8f: 83 c4 10 add $0x10,%esp
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
10cc92: 8b 1d 78 67 12 00 mov 0x126778,%ebx
_ISR_Disable( level );
10cc98: 9c pushf
10cc99: fa cli
10cc9a: 58 pop %eax
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10cc9b: 8a 15 84 67 12 00 mov 0x126784,%dl
10cca1: 84 d2 test %dl,%dl
10cca3: 74 3b je 10cce0 <_Thread_Dispatch+0x15c>
heir = _Thread_Heir;
10cca5: 8b 35 7c 67 12 00 mov 0x12677c,%esi
_Thread_Dispatch_disable_level = 1;
10ccab: c7 05 ec 64 12 00 01 movl $0x1,0x1264ec
10ccb2: 00 00 00
_Thread_Dispatch_necessary = false;
10ccb5: c6 05 84 67 12 00 00 movb $0x0,0x126784
_Thread_Executing = heir;
10ccbc: 89 35 78 67 12 00 mov %esi,0x126778
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
10ccc2: 39 de cmp %ebx,%esi
10ccc4: 74 1a je 10cce0 <_Thread_Dispatch+0x15c><== NEVER TAKEN
*/
#if __RTEMS_ADA__
executing->rtems_ada_self = rtems_ada_self;
rtems_ada_self = heir->rtems_ada_self;
#endif
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
10ccc6: 83 7e 7c 01 cmpl $0x1,0x7c(%esi)
10ccca: 0f 85 04 ff ff ff jne 10cbd4 <_Thread_Dispatch+0x50>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
10ccd0: 8b 15 c0 64 12 00 mov 0x1264c0,%edx
10ccd6: 89 56 78 mov %edx,0x78(%esi)
10ccd9: e9 f6 fe ff ff jmp 10cbd4 <_Thread_Dispatch+0x50>
10ccde: 66 90 xchg %ax,%ax
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
10cce0: c7 05 ec 64 12 00 00 movl $0x0,0x1264ec
10cce7: 00 00 00
_ISR_Enable( level );
10ccea: 50 push %eax
10cceb: 9d popf
_API_extensions_Run_postswitch();
10ccec: e8 83 e6 ff ff call 10b374 <_API_extensions_Run_postswitch>
}
10ccf1: 8d 65 f4 lea -0xc(%ebp),%esp
10ccf4: 5b pop %ebx
10ccf5: 5e pop %esi
10ccf6: 5f pop %edi
10ccf7: c9 leave
10ccf8: c3 ret
0010cd20 <_Thread_Get>:
*/
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
10cd20: 55 push %ebp
10cd21: 89 e5 mov %esp,%ebp
10cd23: 53 push %ebx
10cd24: 83 ec 04 sub $0x4,%esp
10cd27: 8b 45 08 mov 0x8(%ebp),%eax
10cd2a: 8b 4d 0c mov 0xc(%ebp),%ecx
uint32_t the_class;
Objects_Information **api_information;
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
10cd2d: 85 c0 test %eax,%eax
10cd2f: 74 4b je 10cd7c <_Thread_Get+0x5c>
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
10cd31: 89 c2 mov %eax,%edx
10cd33: c1 ea 18 shr $0x18,%edx
10cd36: 83 e2 07 and $0x7,%edx
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
10cd39: 8d 5a ff lea -0x1(%edx),%ebx
10cd3c: 83 fb 02 cmp $0x2,%ebx
10cd3f: 77 2b ja 10cd6c <_Thread_Get+0x4c>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10cd41: 89 c3 mov %eax,%ebx
10cd43: c1 eb 1b shr $0x1b,%ebx
*location = OBJECTS_ERROR;
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
10cd46: 4b dec %ebx
10cd47: 75 23 jne 10cd6c <_Thread_Get+0x4c>
*location = OBJECTS_ERROR;
goto done;
}
api_information = _Objects_Information_table[ the_api ];
10cd49: 8b 14 95 c4 64 12 00 mov 0x1264c4(,%edx,4),%edx
* There is no way for this to happen if POSIX is enabled. But there
* is actually a test case in sp43 for this which trips it whether or
* not POSIX is enabled. So in the interest of safety, this is left
* on in all configurations.
*/
if ( !api_information ) {
10cd50: 85 d2 test %edx,%edx
10cd52: 74 18 je 10cd6c <_Thread_Get+0x4c>
*location = OBJECTS_ERROR;
goto done;
}
information = api_information[ the_class ];
10cd54: 8b 52 04 mov 0x4(%edx),%edx
if ( !information ) {
10cd57: 85 d2 test %edx,%edx
10cd59: 74 11 je 10cd6c <_Thread_Get+0x4c>
*location = OBJECTS_ERROR;
goto done;
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
10cd5b: 53 push %ebx
10cd5c: 51 push %ecx
10cd5d: 50 push %eax
10cd5e: 52 push %edx
10cd5f: e8 48 f4 ff ff call 10c1ac <_Objects_Get>
10cd64: 83 c4 10 add $0x10,%esp
done:
return tp;
}
10cd67: 8b 5d fc mov -0x4(%ebp),%ebx
10cd6a: c9 leave
10cd6b: c3 ret
goto done;
}
information = api_information[ the_class ];
if ( !information ) {
*location = OBJECTS_ERROR;
10cd6c: c7 01 01 00 00 00 movl $0x1,(%ecx)
{
uint32_t the_api;
uint32_t the_class;
Objects_Information **api_information;
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
10cd72: 31 c0 xor %eax,%eax
tp = (Thread_Control *) _Objects_Get( information, id, location );
done:
return tp;
}
10cd74: 8b 5d fc mov -0x4(%ebp),%ebx
10cd77: c9 leave
10cd78: c3 ret
10cd79: 8d 76 00 lea 0x0(%esi),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10cd7c: a1 ec 64 12 00 mov 0x1264ec,%eax
10cd81: 40 inc %eax
10cd82: a3 ec 64 12 00 mov %eax,0x1264ec
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
_Thread_Disable_dispatch();
*location = OBJECTS_LOCAL;
10cd87: c7 01 00 00 00 00 movl $0x0,(%ecx)
tp = _Thread_Executing;
10cd8d: a1 78 67 12 00 mov 0x126778,%eax
tp = (Thread_Control *) _Objects_Get( information, id, location );
done:
return tp;
}
10cd92: 8b 5d fc mov -0x4(%ebp),%ebx
10cd95: c9 leave
10cd96: c3 ret
00111c68 <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
111c68: 55 push %ebp
111c69: 89 e5 mov %esp,%ebp
111c6b: 53 push %ebx
111c6c: 83 ec 14 sub $0x14,%esp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
111c6f: 8b 1d 78 67 12 00 mov 0x126778,%ebx
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
111c75: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax
_ISR_Set_level(level);
111c7b: 85 c0 test %eax,%eax
111c7d: 74 79 je 111cf8 <_Thread_Handler+0x90>
111c7f: fa cli
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
111c80: a0 54 61 12 00 mov 0x126154,%al
111c85: 88 45 f7 mov %al,-0x9(%ebp)
doneConstructors = 1;
111c88: c6 05 54 61 12 00 01 movb $0x1,0x126154
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
111c8f: 8b 93 dc 00 00 00 mov 0xdc(%ebx),%edx
111c95: 85 d2 test %edx,%edx
111c97: 74 24 je 111cbd <_Thread_Handler+0x55>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
111c99: a1 80 65 12 00 mov 0x126580,%eax
111c9e: 39 c3 cmp %eax,%ebx
111ca0: 74 1b je 111cbd <_Thread_Handler+0x55>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
111ca2: 85 c0 test %eax,%eax
111ca4: 74 11 je 111cb7 <_Thread_Handler+0x4f>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
111ca6: 83 ec 0c sub $0xc,%esp
111ca9: 05 dc 00 00 00 add $0xdc,%eax
111cae: 50 push %eax
111caf: e8 50 c0 ff ff call 10dd04 <_CPU_Context_save_fp>
111cb4: 83 c4 10 add $0x10,%esp
_Thread_Allocated_fp = executing;
111cb7: 89 1d 80 65 12 00 mov %ebx,0x126580
/*
* Take care that 'begin' extensions get to complete before
* 'switch' extensions can run. This means must keep dispatch
* disabled until all 'begin' extensions complete.
*/
_User_extensions_Thread_begin( executing );
111cbd: 83 ec 0c sub $0xc,%esp
111cc0: 53 push %ebx
111cc1: e8 66 bb ff ff call 10d82c <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
111cc6: e8 31 b0 ff ff call 10ccfc <_Thread_Enable_dispatch>
/*
* _init could be a weak symbol and we SHOULD test it but it isn't
* in any configuration I know of and it generates a warning on every
* RTEMS target configuration. --joel (12 May 2007)
*/
if (!doneCons) /* && (volatile void *)_init) */ {
111ccb: 83 c4 10 add $0x10,%esp
111cce: 80 7d f7 00 cmpb $0x0,-0x9(%ebp)
111cd2: 74 28 je 111cfc <_Thread_Handler+0x94>
INIT_NAME ();
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
111cd4: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax
111cda: 85 c0 test %eax,%eax
111cdc: 74 2d je 111d0b <_Thread_Handler+0xa3> <== ALWAYS TAKEN
* was placed in return_argument. This assumed that if it returned
* anything (which is not supporting in all APIs), then it would be
* able to fit in a (void *).
*/
_User_extensions_Thread_exitted( executing );
111cde: 83 ec 0c sub $0xc,%esp
111ce1: 53 push %ebx
111ce2: e8 81 bb ff ff call 10d868 <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
111ce7: 83 c4 0c add $0xc,%esp
111cea: 6a 05 push $0x5
111cec: 6a 01 push $0x1
111cee: 6a 00 push $0x0
111cf0: e8 73 9f ff ff call 10bc68 <_Internal_error_Occurred>
111cf5: 8d 76 00 lea 0x0(%esi),%esi
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
_ISR_Set_level(level);
111cf8: fb sti
111cf9: eb 85 jmp 111c80 <_Thread_Handler+0x18>
111cfb: 90 nop
* _init could be a weak symbol and we SHOULD test it but it isn't
* in any configuration I know of and it generates a warning on every
* RTEMS target configuration. --joel (12 May 2007)
*/
if (!doneCons) /* && (volatile void *)_init) */ {
INIT_NAME ();
111cfc: e8 ef c6 00 00 call 11e3f0 <__start_set_sysctl_set>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
111d01: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax
111d07: 85 c0 test %eax,%eax
111d09: 75 d3 jne 111cde <_Thread_Handler+0x76> <== NEVER TAKEN
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
111d0b: 83 ec 0c sub $0xc,%esp
111d0e: ff b3 9c 00 00 00 pushl 0x9c(%ebx)
111d14: ff 93 90 00 00 00 call *0x90(%ebx)
INIT_NAME ();
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
executing->Wait.return_argument =
111d1a: 89 43 28 mov %eax,0x28(%ebx)
111d1d: 83 c4 10 add $0x10,%esp
111d20: eb bc jmp 111cde <_Thread_Handler+0x76>
0010cd98 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
10cd98: 55 push %ebp
10cd99: 89 e5 mov %esp,%ebp
10cd9b: 57 push %edi
10cd9c: 56 push %esi
10cd9d: 53 push %ebx
10cd9e: 83 ec 24 sub $0x24,%esp
10cda1: 8b 5d 0c mov 0xc(%ebp),%ebx
10cda4: 8b 75 14 mov 0x14(%ebp),%esi
10cda7: 0f b6 7d 18 movzbl 0x18(%ebp),%edi
10cdab: 8a 45 20 mov 0x20(%ebp),%al
10cdae: 88 45 e4 mov %al,-0x1c(%ebp)
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
10cdb1: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10cdb8: 00 00 00
10cdbb: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx)
10cdc2: 00 00 00
extensions_area = NULL;
the_thread->libc_reent = NULL;
10cdc5: c7 83 e0 00 00 00 00 movl $0x0,0xe0(%ebx)
10cdcc: 00 00 00
/*
* Allocate and Initialize the stack for this thread.
*/
#if !defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API)
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
10cdcf: 56 push %esi
10cdd0: 53 push %ebx
10cdd1: e8 86 07 00 00 call 10d55c <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
10cdd6: 83 c4 10 add $0x10,%esp
10cdd9: 85 c0 test %eax,%eax
10cddb: 0f 84 5b 01 00 00 je 10cf3c <_Thread_Initialize+0x1a4>
10cde1: 39 c6 cmp %eax,%esi
10cde3: 0f 87 53 01 00 00 ja 10cf3c <_Thread_Initialize+0x1a4><== NEVER TAKEN
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
10cde9: 8b 93 c0 00 00 00 mov 0xc0(%ebx),%edx
10cdef: 89 93 b8 00 00 00 mov %edx,0xb8(%ebx)
the_stack->size = size;
10cdf5: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx)
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
10cdfb: 89 f8 mov %edi,%eax
10cdfd: 84 c0 test %al,%al
10cdff: 0f 85 47 01 00 00 jne 10cf4c <_Thread_Initialize+0x1b4>
10ce05: 31 c0 xor %eax,%eax
extensions_area = NULL;
the_thread->libc_reent = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
fp_area = NULL;
10ce07: 31 ff xor %edi,%edi
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
if ( !fp_area )
goto failed;
fp_area = _Context_Fp_start( fp_area, 0 );
}
the_thread->fp_context = fp_area;
10ce09: 89 83 dc 00 00 00 mov %eax,0xdc(%ebx)
the_thread->Start.fp_context = fp_area;
10ce0f: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10ce15: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10ce1c: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
the_watchdog->id = id;
10ce23: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
the_watchdog->user_data = user_data;
10ce2a: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10ce31: a1 90 65 12 00 mov 0x126590,%eax
10ce36: 85 c0 test %eax,%eax
10ce38: 0f 85 36 01 00 00 jne 10cf74 <_Thread_Initialize+0x1dc>
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10ce3e: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx)
10ce45: 00 00 00
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
10ce48: 31 f6 xor %esi,%esi
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
10ce4a: 8a 45 e4 mov -0x1c(%ebp),%al
10ce4d: 88 83 a0 00 00 00 mov %al,0xa0(%ebx)
the_thread->Start.budget_algorithm = budget_algorithm;
10ce53: 8b 45 24 mov 0x24(%ebp),%eax
10ce56: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
the_thread->Start.budget_callout = budget_callout;
10ce5c: 8b 45 28 mov 0x28(%ebp),%eax
10ce5f: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
10ce65: 8b 45 2c mov 0x2c(%ebp),%eax
10ce68: 89 83 ac 00 00 00 mov %eax,0xac(%ebx)
the_thread->current_state = STATES_DORMANT;
10ce6e: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
the_thread->Wait.queue = NULL;
10ce75: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
the_thread->resource_count = 0;
10ce7c: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->real_priority = priority;
10ce83: 8b 45 1c mov 0x1c(%ebp),%eax
10ce86: 89 43 18 mov %eax,0x18(%ebx)
the_thread->Start.initial_priority = priority;
10ce89: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx)
*/
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.allocate( the_thread );
10ce8f: 83 ec 0c sub $0xc,%esp
10ce92: 53 push %ebx
10ce93: ff 15 18 22 12 00 call *0x122218
10ce99: 89 45 e4 mov %eax,-0x1c(%ebp)
sched =_Scheduler_Allocate( the_thread );
if ( !sched )
10ce9c: 83 c4 10 add $0x10,%esp
10ce9f: 85 c0 test %eax,%eax
10cea1: 74 42 je 10cee5 <_Thread_Initialize+0x14d>
goto failed;
_Thread_Set_priority( the_thread, priority );
10cea3: 83 ec 08 sub $0x8,%esp
10cea6: ff 75 1c pushl 0x1c(%ebp)
10cea9: 53 push %ebx
10ceaa: e8 29 06 00 00 call 10d4d8 <_Thread_Set_priority>
/*
* Initialize the CPU usage statistics
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
10ceaf: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx)
10ceb6: 00 00 00
10ceb9: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx)
10cec0: 00 00 00
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
10cec3: 8b 45 08 mov 0x8(%ebp),%eax
10cec6: 8b 40 1c mov 0x1c(%eax),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10cec9: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10cecd: 89 1c 90 mov %ebx,(%eax,%edx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10ced0: 8b 45 30 mov 0x30(%ebp),%eax
10ced3: 89 43 0c mov %eax,0xc(%ebx)
* enabled when we get here. We want to be able to run the
* user extensions with dispatching enabled. The Allocator
* Mutex provides sufficient protection to let the user extensions
* run safely.
*/
extension_status = _User_extensions_Thread_create( the_thread );
10ced6: 89 1c 24 mov %ebx,(%esp)
10ced9: e8 16 0a 00 00 call 10d8f4 <_User_extensions_Thread_create>
if ( extension_status )
10cede: 83 c4 10 add $0x10,%esp
10cee1: 84 c0 test %al,%al
10cee3: 75 63 jne 10cf48 <_Thread_Initialize+0x1b0>
return true;
failed:
_Workspace_Free( the_thread->libc_reent );
10cee5: 83 ec 0c sub $0xc,%esp
10cee8: ff b3 e0 00 00 00 pushl 0xe0(%ebx)
10ceee: e8 99 0d 00 00 call 10dc8c <_Workspace_Free>
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
10cef3: 59 pop %ecx
10cef4: ff b3 e4 00 00 00 pushl 0xe4(%ebx)
10cefa: e8 8d 0d 00 00 call 10dc8c <_Workspace_Free>
10ceff: 5a pop %edx
10cf00: ff b3 e8 00 00 00 pushl 0xe8(%ebx)
10cf06: e8 81 0d 00 00 call 10dc8c <_Workspace_Free>
_Workspace_Free( extensions_area );
10cf0b: 89 34 24 mov %esi,(%esp)
10cf0e: e8 79 0d 00 00 call 10dc8c <_Workspace_Free>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
10cf13: 89 3c 24 mov %edi,(%esp)
10cf16: e8 71 0d 00 00 call 10dc8c <_Workspace_Free>
#endif
_Workspace_Free( sched );
10cf1b: 58 pop %eax
10cf1c: ff 75 e4 pushl -0x1c(%ebp)
10cf1f: e8 68 0d 00 00 call 10dc8c <_Workspace_Free>
_Thread_Stack_Free( the_thread );
10cf24: 89 1c 24 mov %ebx,(%esp)
10cf27: e8 94 06 00 00 call 10d5c0 <_Thread_Stack_Free>
return false;
10cf2c: 83 c4 10 add $0x10,%esp
10cf2f: 31 c0 xor %eax,%eax
}
10cf31: 8d 65 f4 lea -0xc(%ebp),%esp
10cf34: 5b pop %ebx
10cf35: 5e pop %esi
10cf36: 5f pop %edi
10cf37: c9 leave
10cf38: c3 ret
10cf39: 8d 76 00 lea 0x0(%esi),%esi
* Allocate and Initialize the stack for this thread.
*/
#if !defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API)
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
10cf3c: 31 c0 xor %eax,%eax
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
10cf3e: 8d 65 f4 lea -0xc(%ebp),%esp
10cf41: 5b pop %ebx
10cf42: 5e pop %esi
10cf43: 5f pop %edi
10cf44: c9 leave
10cf45: c3 ret
10cf46: 66 90 xchg %ax,%ax
* Mutex provides sufficient protection to let the user extensions
* run safely.
*/
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
return true;
10cf48: b0 01 mov $0x1,%al
10cf4a: eb f2 jmp 10cf3e <_Thread_Initialize+0x1a6>
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
10cf4c: 83 ec 0c sub $0xc,%esp
10cf4f: 6a 6c push $0x6c
10cf51: e8 1a 0d 00 00 call 10dc70 <_Workspace_Allocate>
10cf56: 89 c7 mov %eax,%edi
if ( !fp_area )
10cf58: 83 c4 10 add $0x10,%esp
10cf5b: 85 c0 test %eax,%eax
10cf5d: 0f 85 a6 fe ff ff jne 10ce09 <_Thread_Initialize+0x71>
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
10cf63: 31 f6 xor %esi,%esi
size_t actual_stack_size = 0;
void *stack = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
void *fp_area;
#endif
void *sched = NULL;
10cf65: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
10cf6c: e9 74 ff ff ff jmp 10cee5 <_Thread_Initialize+0x14d>
10cf71: 8d 76 00 lea 0x0(%esi),%esi
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
extensions_area = _Workspace_Allocate(
10cf74: 83 ec 0c sub $0xc,%esp
10cf77: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax
10cf7e: 50 push %eax
10cf7f: e8 ec 0c 00 00 call 10dc70 <_Workspace_Allocate>
10cf84: 89 c6 mov %eax,%esi
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
10cf86: 83 c4 10 add $0x10,%esp
10cf89: 85 c0 test %eax,%eax
10cf8b: 74 26 je 10cfb3 <_Thread_Initialize+0x21b>
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10cf8d: 89 83 ec 00 00 00 mov %eax,0xec(%ebx)
10cf93: 8b 0d 90 65 12 00 mov 0x126590,%ecx
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
10cf99: 31 d2 xor %edx,%edx
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10cf9b: 31 c0 xor %eax,%eax
10cf9d: 8d 76 00 lea 0x0(%esi),%esi
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
the_thread->extensions[i] = NULL;
10cfa0: c7 04 96 00 00 00 00 movl $0x0,(%esi,%edx,4)
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
10cfa7: 40 inc %eax
10cfa8: 89 c2 mov %eax,%edx
10cfaa: 39 c1 cmp %eax,%ecx
10cfac: 73 f2 jae 10cfa0 <_Thread_Initialize+0x208>
10cfae: e9 97 fe ff ff jmp 10ce4a <_Thread_Initialize+0xb2>
size_t actual_stack_size = 0;
void *stack = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
void *fp_area;
#endif
void *sched = NULL;
10cfb3: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
10cfba: e9 26 ff ff ff jmp 10cee5 <_Thread_Initialize+0x14d>
0011146c <_Thread_Reset>:
void _Thread_Reset(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
11146c: 55 push %ebp
11146d: 89 e5 mov %esp,%ebp
11146f: 53 push %ebx
111470: 83 ec 10 sub $0x10,%esp
111473: 8b 5d 08 mov 0x8(%ebp),%ebx
the_thread->resource_count = 0;
111476: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->is_preemptible = the_thread->Start.is_preemptible;
11147d: 8a 83 a0 00 00 00 mov 0xa0(%ebx),%al
111483: 88 43 74 mov %al,0x74(%ebx)
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
111486: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax
11148c: 89 43 7c mov %eax,0x7c(%ebx)
the_thread->budget_callout = the_thread->Start.budget_callout;
11148f: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax
111495: 89 83 80 00 00 00 mov %eax,0x80(%ebx)
the_thread->Start.pointer_argument = pointer_argument;
11149b: 8b 45 0c mov 0xc(%ebp),%eax
11149e: 89 83 98 00 00 00 mov %eax,0x98(%ebx)
the_thread->Start.numeric_argument = numeric_argument;
1114a4: 8b 45 10 mov 0x10(%ebp),%eax
1114a7: 89 83 9c 00 00 00 mov %eax,0x9c(%ebx)
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
1114ad: 53 push %ebx
1114ae: e8 95 c9 ff ff call 10de48 <_Thread_queue_Extract_with_proxy>
1114b3: 83 c4 10 add $0x10,%esp
1114b6: 84 c0 test %al,%al
1114b8: 75 06 jne 1114c0 <_Thread_Reset+0x54>
if ( _Watchdog_Is_active( &the_thread->Timer ) )
1114ba: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
1114be: 74 28 je 1114e8 <_Thread_Reset+0x7c>
(void) _Watchdog_Remove( &the_thread->Timer );
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
1114c0: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax
1114c6: 39 43 14 cmp %eax,0x14(%ebx)
1114c9: 74 15 je 1114e0 <_Thread_Reset+0x74>
the_thread->real_priority = the_thread->Start.initial_priority;
1114cb: 89 43 18 mov %eax,0x18(%ebx)
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
1114ce: 89 45 0c mov %eax,0xc(%ebp)
1114d1: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
1114d4: 8b 5d fc mov -0x4(%ebp),%ebx
1114d7: c9 leave
(void) _Watchdog_Remove( &the_thread->Timer );
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
the_thread->real_priority = the_thread->Start.initial_priority;
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
1114d8: e9 47 cb ff ff jmp 10e024 <_Thread_Set_priority>
1114dd: 8d 76 00 lea 0x0(%esi),%esi
}
}
1114e0: 8b 5d fc mov -0x4(%ebp),%ebx
1114e3: c9 leave
1114e4: c3 ret
1114e5: 8d 76 00 lea 0x0(%esi),%esi
the_thread->Start.numeric_argument = numeric_argument;
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
if ( _Watchdog_Is_active( &the_thread->Timer ) )
(void) _Watchdog_Remove( &the_thread->Timer );
1114e8: 83 ec 0c sub $0xc,%esp
1114eb: 8d 43 48 lea 0x48(%ebx),%eax
1114ee: 50 push %eax
1114ef: e8 e0 d1 ff ff call 10e6d4 <_Watchdog_Remove>
1114f4: 83 c4 10 add $0x10,%esp
1114f7: eb c7 jmp 1114c0 <_Thread_Reset+0x54>
0010d55c <_Thread_Stack_Allocate>:
size_t _Thread_Stack_Allocate(
Thread_Control *the_thread,
size_t stack_size
)
{
10d55c: 55 push %ebp
10d55d: 89 e5 mov %esp,%ebp
10d55f: 53 push %ebx
10d560: 83 ec 04 sub $0x4,%esp
the_stack_size = _Stack_Adjust_size( the_stack_size );
stack_addr = _Workspace_Allocate( the_stack_size );
}
if ( !stack_addr )
the_stack_size = 0;
10d563: a1 f0 22 12 00 mov 0x1222f0,%eax
10d568: 8b 5d 0c mov 0xc(%ebp),%ebx
10d56b: 39 c3 cmp %eax,%ebx
10d56d: 73 02 jae 10d571 <_Thread_Stack_Allocate+0x15>
10d56f: 89 c3 mov %eax,%ebx
* Call ONLY the CPU table stack allocate hook, _or_ the
* the RTEMS workspace allocate. This is so the stack free
* routine can call the correct deallocation routine.
*/
if ( Configuration.stack_allocate_hook ) {
10d571: a1 20 23 12 00 mov 0x122320,%eax
10d576: 85 c0 test %eax,%eax
10d578: 74 32 je 10d5ac <_Thread_Stack_Allocate+0x50>
stack_addr = (*Configuration.stack_allocate_hook)( the_stack_size );
10d57a: 83 ec 0c sub $0xc,%esp
10d57d: 53 push %ebx
10d57e: ff d0 call *%eax
10d580: 83 c4 10 add $0x10,%esp
the_stack_size = _Stack_Adjust_size( the_stack_size );
stack_addr = _Workspace_Allocate( the_stack_size );
}
if ( !stack_addr )
10d583: 85 c0 test %eax,%eax
10d585: 74 11 je 10d598 <_Thread_Stack_Allocate+0x3c>
the_stack_size = 0;
the_thread->Start.stack = stack_addr;
10d587: 8b 55 08 mov 0x8(%ebp),%edx
10d58a: 89 82 c0 00 00 00 mov %eax,0xc0(%edx)
return the_stack_size;
}
10d590: 89 d8 mov %ebx,%eax
10d592: 8b 5d fc mov -0x4(%ebp),%ebx
10d595: c9 leave
10d596: c3 ret
10d597: 90 nop
the_stack_size = _Stack_Adjust_size( the_stack_size );
stack_addr = _Workspace_Allocate( the_stack_size );
}
if ( !stack_addr )
the_stack_size = 0;
10d598: 31 db xor %ebx,%ebx
the_thread->Start.stack = stack_addr;
10d59a: 8b 55 08 mov 0x8(%ebp),%edx
10d59d: 89 82 c0 00 00 00 mov %eax,0xc0(%edx)
return the_stack_size;
}
10d5a3: 89 d8 mov %ebx,%eax
10d5a5: 8b 5d fc mov -0x4(%ebp),%ebx
10d5a8: c9 leave
10d5a9: c3 ret
10d5aa: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE uint32_t _Stack_Adjust_size (
size_t size
)
{
return size + CPU_STACK_ALIGNMENT;
10d5ac: 83 c3 10 add $0x10,%ebx
* get and keep the stack adjust factor, the stack alignment, and
* the context initialization sequence in sync.
*/
the_stack_size = _Stack_Adjust_size( the_stack_size );
stack_addr = _Workspace_Allocate( the_stack_size );
10d5af: 83 ec 0c sub $0xc,%esp
10d5b2: 53 push %ebx
10d5b3: e8 b8 06 00 00 call 10dc70 <_Workspace_Allocate>
10d5b8: 83 c4 10 add $0x10,%esp
10d5bb: eb c6 jmp 10d583 <_Thread_Stack_Allocate+0x27>
0010d5c0 <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
10d5c0: 55 push %ebp
10d5c1: 89 e5 mov %esp,%ebp
10d5c3: 83 ec 08 sub $0x8,%esp
10d5c6: 8b 55 08 mov 0x8(%ebp),%edx
* Call ONLY the CPU table stack free hook, or the
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
if ( Configuration.stack_free_hook )
10d5c9: a1 24 23 12 00 mov 0x122324,%eax
10d5ce: 85 c0 test %eax,%eax
10d5d0: 74 0e je 10d5e0 <_Thread_Stack_Free+0x20>
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
10d5d2: 8b 92 b8 00 00 00 mov 0xb8(%edx),%edx
10d5d8: 89 55 08 mov %edx,0x8(%ebp)
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
10d5db: c9 leave
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
if ( Configuration.stack_free_hook )
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
10d5dc: ff e0 jmp *%eax
10d5de: 66 90 xchg %ax,%ax
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
10d5e0: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax
10d5e6: 89 45 08 mov %eax,0x8(%ebp)
}
10d5e9: c9 leave
*/
if ( Configuration.stack_free_hook )
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
10d5ea: e9 9d 06 00 00 jmp 10dc8c <_Workspace_Free>
0010d098 <_Thread_queue_Dequeue_priority>:
*/
Thread_Control *_Thread_queue_Dequeue_priority(
Thread_queue_Control *the_thread_queue
)
{
10d098: 55 push %ebp
10d099: 89 e5 mov %esp,%ebp
10d09b: 57 push %edi
10d09c: 56 push %esi
10d09d: 53 push %ebx
10d09e: 83 ec 2c sub $0x2c,%esp
10d0a1: 8b 7d 08 mov 0x8(%ebp),%edi
Chain_Node *new_second_node;
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
10d0a4: 9c pushf
10d0a5: fa cli
10d0a6: 58 pop %eax
10d0a7: 89 f9 mov %edi,%ecx
for( index=0 ;
10d0a9: 31 d2 xor %edx,%edx
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
10d0ab: 8b 19 mov (%ecx),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10d0ad: 8d 34 52 lea (%edx,%edx,2),%esi
10d0b0: 8d 74 b7 04 lea 0x4(%edi,%esi,4),%esi
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
10d0b4: 39 f3 cmp %esi,%ebx
10d0b6: 75 18 jne 10d0d0 <_Thread_queue_Dequeue_priority+0x38>
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
10d0b8: 42 inc %edx
10d0b9: 83 c1 0c add $0xc,%ecx
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
10d0bc: 83 fa 04 cmp $0x4,%edx
10d0bf: 75 ea jne 10d0ab <_Thread_queue_Dequeue_priority+0x13>
}
/*
* We did not find a thread to unblock.
*/
_ISR_Enable( level );
10d0c1: 50 push %eax
10d0c2: 9d popf
return NULL;
10d0c3: 31 f6 xor %esi,%esi
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
10d0c5: 89 f0 mov %esi,%eax
10d0c7: 8d 65 f4 lea -0xc(%ebp),%esp
10d0ca: 5b pop %ebx
10d0cb: 5e pop %esi
10d0cc: 5f pop %edi
10d0cd: c9 leave
10d0ce: c3 ret
10d0cf: 90 nop
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
the_thread = (Thread_Control *) _Chain_First(
10d0d0: 89 de mov %ebx,%esi
*/
_ISR_Enable( level );
return NULL;
dequeue:
the_thread->Wait.queue = NULL;
10d0d2: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
10d0d9: 8b 53 38 mov 0x38(%ebx),%edx
dequeue:
the_thread->Wait.queue = NULL;
new_first_node = _Chain_First( &the_thread->Wait.Block2n );
new_first_thread = (Thread_Control *) new_first_node;
next_node = the_thread->Object.Node.next;
10d0dc: 8b 0b mov (%ebx),%ecx
previous_node = the_thread->Object.Node.previous;
10d0de: 8b 7b 04 mov 0x4(%ebx),%edi
10d0e1: 89 7d d4 mov %edi,-0x2c(%ebp)
10d0e4: 8d 7b 3c lea 0x3c(%ebx),%edi
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
10d0e7: 39 fa cmp %edi,%edx
10d0e9: 74 7f je 10d16a <_Thread_queue_Dequeue_priority+0xd2>
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
10d0eb: 8b 7b 40 mov 0x40(%ebx),%edi
10d0ee: 89 7d e4 mov %edi,-0x1c(%ebp)
next_node = the_thread->Object.Node.next;
previous_node = the_thread->Object.Node.previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
10d0f1: 8b 3a mov (%edx),%edi
10d0f3: 89 7d e0 mov %edi,-0x20(%ebp)
previous_node->next = new_first_node;
10d0f6: 8b 7d d4 mov -0x2c(%ebp),%edi
10d0f9: 89 17 mov %edx,(%edi)
next_node->previous = new_first_node;
10d0fb: 89 51 04 mov %edx,0x4(%ecx)
new_first_node->next = next_node;
10d0fe: 89 0a mov %ecx,(%edx)
new_first_node->previous = previous_node;
10d100: 89 7a 04 mov %edi,0x4(%edx)
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
10d103: 8b 4b 40 mov 0x40(%ebx),%ecx
10d106: 39 4b 38 cmp %ecx,0x38(%ebx)
10d109: 74 17 je 10d122 <_Thread_queue_Dequeue_priority+0x8a>
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
10d10b: 8d 4a 38 lea 0x38(%edx),%ecx
10d10e: 8b 7d e0 mov -0x20(%ebp),%edi
10d111: 89 4f 04 mov %ecx,0x4(%edi)
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
new_second_node->previous = head;
head->next = new_second_node;
10d114: 89 7a 38 mov %edi,0x38(%edx)
tail->previous = last_node;
10d117: 8b 4d e4 mov -0x1c(%ebp),%ecx
10d11a: 89 4a 40 mov %ecx,0x40(%edx)
new_first_node->previous = previous_node;
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
10d11d: 83 c2 3c add $0x3c,%edx
10d120: 89 11 mov %edx,(%ecx)
} else {
previous_node->next = next_node;
next_node->previous = previous_node;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10d122: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10d126: 74 18 je 10d140 <_Thread_queue_Dequeue_priority+0xa8>
_ISR_Enable( level );
10d128: 50 push %eax
10d129: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10d12a: 83 ec 08 sub $0x8,%esp
10d12d: 68 f8 ff 03 10 push $0x1003fff8
10d132: 53 push %ebx
10d133: e8 60 f8 ff ff call 10c998 <_Thread_Clear_state>
10d138: 83 c4 10 add $0x10,%esp
10d13b: eb 88 jmp 10d0c5 <_Thread_queue_Dequeue_priority+0x2d>
10d13d: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
10d140: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
10d147: 50 push %eax
10d148: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
10d149: 83 ec 0c sub $0xc,%esp
10d14c: 8d 43 48 lea 0x48(%ebx),%eax
10d14f: 50 push %eax
10d150: e8 f3 09 00 00 call 10db48 <_Watchdog_Remove>
10d155: 58 pop %eax
10d156: 5a pop %edx
10d157: 68 f8 ff 03 10 push $0x1003fff8
10d15c: 53 push %ebx
10d15d: e8 36 f8 ff ff call 10c998 <_Thread_Clear_state>
10d162: 83 c4 10 add $0x10,%esp
10d165: e9 5b ff ff ff jmp 10d0c5 <_Thread_queue_Dequeue_priority+0x2d>
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
10d16a: 8b 7d d4 mov -0x2c(%ebp),%edi
10d16d: 89 0f mov %ecx,(%edi)
next_node->previous = previous_node;
10d16f: 89 79 04 mov %edi,0x4(%ecx)
10d172: eb ae jmp 10d122 <_Thread_queue_Dequeue_priority+0x8a>
001106fc <_Thread_queue_Extract>:
void _Thread_queue_Extract(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
1106fc: 55 push %ebp
1106fd: 89 e5 mov %esp,%ebp
1106ff: 83 ec 08 sub $0x8,%esp
110702: 8b 45 08 mov 0x8(%ebp),%eax
110705: 8b 55 0c mov 0xc(%ebp),%edx
/*
* Can not use indirect function pointer here since Extract priority
* is a macro and the underlying methods do not have the same signature.
*/
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
110708: 83 78 34 01 cmpl $0x1,0x34(%eax)
11070c: 74 0e je 11071c <_Thread_queue_Extract+0x20>
_Thread_queue_Extract_priority( the_thread_queue, the_thread );
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
_Thread_queue_Extract_fifo( the_thread_queue, the_thread );
11070e: 89 55 0c mov %edx,0xc(%ebp)
110711: 89 45 08 mov %eax,0x8(%ebp)
}
110714: c9 leave
* is a macro and the underlying methods do not have the same signature.
*/
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
_Thread_queue_Extract_priority( the_thread_queue, the_thread );
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
_Thread_queue_Extract_fifo( the_thread_queue, the_thread );
110715: e9 0a 16 00 00 jmp 111d24 <_Thread_queue_Extract_fifo>
11071a: 66 90 xchg %ax,%ax
/*
* Can not use indirect function pointer here since Extract priority
* is a macro and the underlying methods do not have the same signature.
*/
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
_Thread_queue_Extract_priority( the_thread_queue, the_thread );
11071c: 51 push %ecx
11071d: 6a 00 push $0x0
11071f: 52 push %edx
110720: 50 push %eax
110721: e8 06 00 00 00 call 11072c <_Thread_queue_Extract_priority_helper>
110726: 83 c4 10 add $0x10,%esp
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
_Thread_queue_Extract_fifo( the_thread_queue, the_thread );
}
110729: c9 leave
11072a: c3 ret
00111d24 <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
111d24: 55 push %ebp
111d25: 89 e5 mov %esp,%ebp
111d27: 53 push %ebx
111d28: 83 ec 04 sub $0x4,%esp
111d2b: 8b 5d 0c mov 0xc(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
111d2e: 9c pushf
111d2f: fa cli
111d30: 58 pop %eax
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
111d31: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx)
111d38: 74 2e je 111d68 <_Thread_queue_Extract_fifo+0x44>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
111d3a: 8b 0b mov (%ebx),%ecx
previous = the_node->previous;
111d3c: 8b 53 04 mov 0x4(%ebx),%edx
next->previous = previous;
111d3f: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
111d42: 89 0a mov %ecx,(%edx)
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
111d44: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
111d4b: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
111d4f: 74 1f je 111d70 <_Thread_queue_Extract_fifo+0x4c>
_ISR_Enable( level );
111d51: 50 push %eax
111d52: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
111d53: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp)
111d5a: 89 5d 08 mov %ebx,0x8(%ebp)
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
111d5d: 8b 5d fc mov -0x4(%ebp),%ebx
111d60: c9 leave
111d61: e9 32 ac ff ff jmp 10c998 <_Thread_Clear_state>
111d66: 66 90 xchg %ax,%ax
ISR_Level level;
_ISR_Disable( level );
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
_ISR_Enable( level );
111d68: 50 push %eax
111d69: 9d popf
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
111d6a: 8b 5d fc mov -0x4(%ebp),%ebx
111d6d: c9 leave
111d6e: c3 ret
111d6f: 90 nop
111d70: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
111d77: 50 push %eax
111d78: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
111d79: 83 ec 0c sub $0xc,%esp
111d7c: 8d 43 48 lea 0x48(%ebx),%eax
111d7f: 50 push %eax
111d80: e8 c3 bd ff ff call 10db48 <_Watchdog_Remove>
111d85: 83 c4 10 add $0x10,%esp
111d88: eb c9 jmp 111d53 <_Thread_queue_Extract_fifo+0x2f>
0011072c <_Thread_queue_Extract_priority_helper>:
void _Thread_queue_Extract_priority_helper(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread,
bool requeuing
)
{
11072c: 55 push %ebp
11072d: 89 e5 mov %esp,%ebp
11072f: 57 push %edi
110730: 56 push %esi
110731: 53 push %ebx
110732: 83 ec 1c sub $0x1c,%esp
110735: 8b 5d 0c mov 0xc(%ebp),%ebx
110738: 8a 45 10 mov 0x10(%ebp),%al
11073b: 88 45 e3 mov %al,-0x1d(%ebp)
Chain_Node *new_first_node;
Chain_Node *new_second_node;
Chain_Node *last_node;
the_node = (Chain_Node *) the_thread;
_ISR_Disable( level );
11073e: 9c pushf
11073f: fa cli
110740: 8f 45 e4 popl -0x1c(%ebp)
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
110743: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx)
11074a: 74 6c je 1107b8 <_Thread_queue_Extract_priority_helper+0x8c>
/*
* The thread was actually waiting on a thread queue so let's remove it.
*/
next_node = the_node->next;
11074c: 8b 13 mov (%ebx),%edx
previous_node = the_node->previous;
11074e: 8b 4b 04 mov 0x4(%ebx),%ecx
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
110751: 8b 43 38 mov 0x38(%ebx),%eax
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
110754: 8d 73 3c lea 0x3c(%ebx),%esi
*/
next_node = the_node->next;
previous_node = the_node->previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
110757: 39 f0 cmp %esi,%eax
110759: 74 69 je 1107c4 <_Thread_queue_Extract_priority_helper+0x98>
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
11075b: 8b 7b 40 mov 0x40(%ebx),%edi
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
new_first_node = _Chain_First( &the_thread->Wait.Block2n );
new_first_thread = (Thread_Control *) new_first_node;
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
11075e: 8b 30 mov (%eax),%esi
previous_node->next = new_first_node;
110760: 89 01 mov %eax,(%ecx)
next_node->previous = new_first_node;
110762: 89 42 04 mov %eax,0x4(%edx)
new_first_node->next = next_node;
110765: 89 10 mov %edx,(%eax)
new_first_node->previous = previous_node;
110767: 89 48 04 mov %ecx,0x4(%eax)
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
11076a: 8b 53 40 mov 0x40(%ebx),%edx
11076d: 39 53 38 cmp %edx,0x38(%ebx)
110770: 74 11 je 110783 <_Thread_queue_Extract_priority_helper+0x57>
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
110772: 8d 50 38 lea 0x38(%eax),%edx
110775: 89 56 04 mov %edx,0x4(%esi)
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
new_second_node->previous = head;
head->next = new_second_node;
110778: 89 70 38 mov %esi,0x38(%eax)
tail->previous = last_node;
11077b: 89 78 40 mov %edi,0x40(%eax)
new_first_node->previous = previous_node;
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
11077e: 83 c0 3c add $0x3c,%eax
110781: 89 07 mov %eax,(%edi)
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
110783: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
110787: 75 23 jne 1107ac <_Thread_queue_Extract_priority_helper+0x80>
_ISR_Enable( level );
return;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
110789: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
11078d: 74 3d je 1107cc <_Thread_queue_Extract_priority_helper+0xa0>
_ISR_Enable( level );
11078f: ff 75 e4 pushl -0x1c(%ebp)
110792: 9d popf
110793: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp)
11079a: 89 5d 08 mov %ebx,0x8(%ebp)
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
11079d: 8d 65 f4 lea -0xc(%ebp),%esp
1107a0: 5b pop %ebx
1107a1: 5e pop %esi
1107a2: 5f pop %edi
1107a3: c9 leave
1107a4: e9 ef c1 ff ff jmp 10c998 <_Thread_Clear_state>
1107a9: 8d 76 00 lea 0x0(%esi),%esi
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
_ISR_Enable( level );
1107ac: ff 75 e4 pushl -0x1c(%ebp)
1107af: 9d popf
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
1107b0: 8d 65 f4 lea -0xc(%ebp),%esp
1107b3: 5b pop %ebx
1107b4: 5e pop %esi
1107b5: 5f pop %edi
1107b6: c9 leave
1107b7: c3 ret
Chain_Node *last_node;
the_node = (Chain_Node *) the_thread;
_ISR_Disable( level );
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
_ISR_Enable( level );
1107b8: ff 75 e4 pushl -0x1c(%ebp)
1107bb: 9d popf
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
1107bc: 8d 65 f4 lea -0xc(%ebp),%esp
1107bf: 5b pop %ebx
1107c0: 5e pop %esi
1107c1: 5f pop %edi
1107c2: c9 leave
1107c3: c3 ret
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
1107c4: 89 11 mov %edx,(%ecx)
next_node->previous = previous_node;
1107c6: 89 4a 04 mov %ecx,0x4(%edx)
1107c9: eb b8 jmp 110783 <_Thread_queue_Extract_priority_helper+0x57>
1107cb: 90 nop
1107cc: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
1107d3: ff 75 e4 pushl -0x1c(%ebp)
1107d6: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
1107d7: 83 ec 0c sub $0xc,%esp
1107da: 8d 43 48 lea 0x48(%ebx),%eax
1107dd: 50 push %eax
1107de: e8 65 d3 ff ff call 10db48 <_Watchdog_Remove>
1107e3: 83 c4 10 add $0x10,%esp
1107e6: eb ab jmp 110793 <_Thread_queue_Extract_priority_helper+0x67>
0010d384 <_Thread_queue_Extract_with_proxy>:
*/
bool _Thread_queue_Extract_with_proxy(
Thread_Control *the_thread
)
{
10d384: 55 push %ebp
10d385: 89 e5 mov %esp,%ebp
10d387: 83 ec 08 sub $0x8,%esp
10d38a: 8b 45 08 mov 0x8(%ebp),%eax
States_Control state;
state = the_thread->current_state;
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10d38d: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax)
10d394: 75 06 jne 10d39c <_Thread_queue_Extract_with_proxy+0x18>
#endif
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
return true;
}
return false;
10d396: 31 c0 xor %eax,%eax
}
10d398: c9 leave
10d399: c3 ret
10d39a: 66 90 xchg %ax,%ax
if ( proxy_extract_callout )
(*proxy_extract_callout)( the_thread );
}
#endif
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
10d39c: 83 ec 08 sub $0x8,%esp
10d39f: 50 push %eax
10d3a0: ff 70 44 pushl 0x44(%eax)
10d3a3: e8 54 33 00 00 call 1106fc <_Thread_queue_Extract>
return true;
10d3a8: 83 c4 10 add $0x10,%esp
10d3ab: b0 01 mov $0x1,%al
}
return false;
}
10d3ad: c9 leave
10d3ae: c3 ret
0011e7ac <_Thread_queue_First>:
*/
Thread_Control *_Thread_queue_First(
Thread_queue_Control *the_thread_queue
)
{
11e7ac: 55 push %ebp
11e7ad: 89 e5 mov %esp,%ebp
11e7af: 83 ec 08 sub $0x8,%esp
11e7b2: 8b 45 08 mov 0x8(%ebp),%eax
Thread_Control * (*first_p)(Thread_queue_Control *);
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
11e7b5: 83 78 34 01 cmpl $0x1,0x34(%eax)
11e7b9: 74 0d je 11e7c8 <_Thread_queue_First+0x1c>
first_p = _Thread_queue_First_priority;
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
first_p = _Thread_queue_First_fifo;
11e7bb: ba 3c fb 11 00 mov $0x11fb3c,%edx
return (*first_p)( the_thread_queue );
11e7c0: 89 45 08 mov %eax,0x8(%ebp)
}
11e7c3: c9 leave
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
first_p = _Thread_queue_First_priority;
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
first_p = _Thread_queue_First_fifo;
return (*first_p)( the_thread_queue );
11e7c4: ff e2 jmp *%edx
11e7c6: 66 90 xchg %ax,%ax
)
{
Thread_Control * (*first_p)(Thread_queue_Control *);
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
first_p = _Thread_queue_First_priority;
11e7c8: ba d4 e7 11 00 mov $0x11e7d4,%edx
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
first_p = _Thread_queue_First_fifo;
return (*first_p)( the_thread_queue );
11e7cd: 89 45 08 mov %eax,0x8(%ebp)
}
11e7d0: c9 leave
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
first_p = _Thread_queue_First_priority;
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
first_p = _Thread_queue_First_fifo;
return (*first_p)( the_thread_queue );
11e7d1: ff e2 jmp *%edx
0011fb3c <_Thread_queue_First_fifo>:
*/
Thread_Control *_Thread_queue_First_fifo(
Thread_queue_Control *the_thread_queue
)
{
11fb3c: 55 push %ebp
11fb3d: 89 e5 mov %esp,%ebp
11fb3f: 8b 55 08 mov 0x8(%ebp),%edx
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) )
return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Fifo );
return NULL;
}
11fb42: 8b 02 mov (%edx),%eax
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
11fb44: 83 c2 04 add $0x4,%edx
Thread_Control *_Thread_queue_First_fifo(
Thread_queue_Control *the_thread_queue
)
{
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) )
11fb47: 39 d0 cmp %edx,%eax
11fb49: 74 05 je 11fb50 <_Thread_queue_First_fifo+0x14>
return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Fifo );
return NULL;
}
11fb4b: c9 leave
11fb4c: c3 ret
11fb4d: 8d 76 00 lea 0x0(%esi),%esi
)
{
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) )
return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Fifo );
return NULL;
11fb50: 31 c0 xor %eax,%eax
}
11fb52: c9 leave
11fb53: c3 ret
0010d3b0 <_Thread_queue_Flush>:
#else
Thread_queue_Flush_callout remote_extract_callout __attribute__((unused)),
#endif
uint32_t status
)
{
10d3b0: 55 push %ebp
10d3b1: 89 e5 mov %esp,%ebp
10d3b3: 56 push %esi
10d3b4: 53 push %ebx
10d3b5: 8b 5d 08 mov 0x8(%ebp),%ebx
10d3b8: 8b 75 10 mov 0x10(%ebp),%esi
Thread_Control *the_thread;
while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) {
10d3bb: eb 06 jmp 10d3c3 <_Thread_queue_Flush+0x13>
10d3bd: 8d 76 00 lea 0x0(%esi),%esi
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
( *remote_extract_callout )( the_thread );
else
#endif
the_thread->Wait.return_code = status;
10d3c0: 89 70 34 mov %esi,0x34(%eax)
uint32_t status
)
{
Thread_Control *the_thread;
while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) {
10d3c3: 83 ec 0c sub $0xc,%esp
10d3c6: 53 push %ebx
10d3c7: e8 80 fc ff ff call 10d04c <_Thread_queue_Dequeue>
10d3cc: 83 c4 10 add $0x10,%esp
10d3cf: 85 c0 test %eax,%eax
10d3d1: 75 ed jne 10d3c0 <_Thread_queue_Flush+0x10>
( *remote_extract_callout )( the_thread );
else
#endif
the_thread->Wait.return_code = status;
}
}
10d3d3: 8d 65 f8 lea -0x8(%ebp),%esp
10d3d6: 5b pop %ebx
10d3d7: 5e pop %esi
10d3d8: c9 leave
10d3d9: c3 ret
0010d3dc <_Thread_queue_Initialize>:
Thread_queue_Control *the_thread_queue,
Thread_queue_Disciplines the_discipline,
States_Control state,
uint32_t timeout_status
)
{
10d3dc: 55 push %ebp
10d3dd: 89 e5 mov %esp,%ebp
10d3df: 56 push %esi
10d3e0: 53 push %ebx
10d3e1: 8b 45 08 mov 0x8(%ebp),%eax
10d3e4: 8b 55 0c mov 0xc(%ebp),%edx
the_thread_queue->state = state;
10d3e7: 8b 4d 10 mov 0x10(%ebp),%ecx
10d3ea: 89 48 38 mov %ecx,0x38(%eax)
the_thread_queue->discipline = the_discipline;
10d3ed: 89 50 34 mov %edx,0x34(%eax)
the_thread_queue->timeout_status = timeout_status;
10d3f0: 8b 4d 14 mov 0x14(%ebp),%ecx
10d3f3: 89 48 3c mov %ecx,0x3c(%eax)
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10d3f6: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
10d3fd: 83 fa 01 cmp $0x1,%edx
10d400: 74 16 je 10d418 <_Thread_queue_Initialize+0x3c>
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
10d402: 8d 50 04 lea 0x4(%eax),%edx
10d405: 89 10 mov %edx,(%eax)
head->next = tail;
head->previous = NULL;
10d407: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
tail->previous = head;
10d40e: 89 40 08 mov %eax,0x8(%eax)
_Chain_Initialize_empty( &the_thread_queue->Queues.Priority[index] );
} else { /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
_Chain_Initialize_empty( &the_thread_queue->Queues.Fifo );
}
}
10d411: 5b pop %ebx
10d412: 5e pop %esi
10d413: c9 leave
10d414: c3 ret
10d415: 8d 76 00 lea 0x0(%esi),%esi
the_thread_queue->state = state;
the_thread_queue->discipline = the_discipline;
the_thread_queue->timeout_status = timeout_status;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
10d418: 89 c1 mov %eax,%ecx
10d41a: 30 d2 xor %dl,%dl
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
10d41c: 8d 1c 52 lea (%edx,%edx,2),%ebx
10d41f: 8d 1c 98 lea (%eax,%ebx,4),%ebx
10d422: 8d 73 04 lea 0x4(%ebx),%esi
10d425: 89 31 mov %esi,(%ecx)
head->next = tail;
head->previous = NULL;
10d427: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
10d42e: 89 59 08 mov %ebx,0x8(%ecx)
uint32_t index;
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++)
10d431: 42 inc %edx
10d432: 83 c1 0c add $0xc,%ecx
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
uint32_t index;
for( index=0 ;
10d435: 83 fa 04 cmp $0x4,%edx
10d438: 75 e2 jne 10d41c <_Thread_queue_Initialize+0x40>
_Chain_Initialize_empty( &the_thread_queue->Queues.Priority[index] );
} else { /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
_Chain_Initialize_empty( &the_thread_queue->Queues.Fifo );
}
}
10d43a: 5b pop %ebx
10d43b: 5e pop %esi
10d43c: c9 leave
10d43d: c3 ret
0010d440 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10d440: 55 push %ebp
10d441: 89 e5 mov %esp,%ebp
10d443: 57 push %edi
10d444: 56 push %esi
10d445: 53 push %ebx
10d446: 83 ec 1c sub $0x1c,%esp
10d449: 8b 75 08 mov 0x8(%ebp),%esi
10d44c: 8b 7d 0c mov 0xc(%ebp),%edi
/*
* Just in case the thread really wasn't blocked on a thread queue
* when we get here.
*/
if ( !the_thread_queue )
10d44f: 85 f6 test %esi,%esi
10d451: 74 06 je 10d459 <_Thread_queue_Requeue+0x19><== NEVER TAKEN
/*
* If queueing by FIFO, there is nothing to do. This only applies to
* priority blocking discipline.
*/
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
10d453: 83 7e 34 01 cmpl $0x1,0x34(%esi)
10d457: 74 0b je 10d464 <_Thread_queue_Requeue+0x24><== ALWAYS TAKEN
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
}
_ISR_Enable( level );
}
}
10d459: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10d45c: 5b pop %ebx <== NOT EXECUTED
10d45d: 5e pop %esi <== NOT EXECUTED
10d45e: 5f pop %edi <== NOT EXECUTED
10d45f: c9 leave <== NOT EXECUTED
10d460: c3 ret <== NOT EXECUTED
10d461: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
10d464: 9c pushf
10d465: fa cli
10d466: 5b pop %ebx
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10d467: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi)
10d46e: 75 0c jne 10d47c <_Thread_queue_Requeue+0x3c><== ALWAYS TAKEN
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
}
_ISR_Enable( level );
10d470: 53 push %ebx
10d471: 9d popf
}
}
10d472: 8d 65 f4 lea -0xc(%ebp),%esp
10d475: 5b pop %ebx
10d476: 5e pop %esi
10d477: 5f pop %edi
10d478: c9 leave
10d479: c3 ret
10d47a: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10d47c: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi)
ISR_Level level_ignored;
_ISR_Disable( level );
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
10d483: 50 push %eax
10d484: 6a 01 push $0x1
10d486: 57 push %edi
10d487: 56 push %esi
10d488: e8 9f 32 00 00 call 11072c <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
10d48d: 83 c4 0c add $0xc,%esp
10d490: 8d 45 e4 lea -0x1c(%ebp),%eax
10d493: 50 push %eax
10d494: 57 push %edi
10d495: 56 push %esi
10d496: e8 71 fd ff ff call 10d20c <_Thread_queue_Enqueue_priority>
10d49b: 83 c4 10 add $0x10,%esp
10d49e: eb d0 jmp 10d470 <_Thread_queue_Requeue+0x30>
0010d4a0 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10d4a0: 55 push %ebp
10d4a1: 89 e5 mov %esp,%ebp
10d4a3: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10d4a6: 8d 45 f4 lea -0xc(%ebp),%eax
10d4a9: 50 push %eax
10d4aa: ff 75 08 pushl 0x8(%ebp)
10d4ad: e8 6e f8 ff ff call 10cd20 <_Thread_Get>
switch ( location ) {
10d4b2: 83 c4 10 add $0x10,%esp
10d4b5: 8b 55 f4 mov -0xc(%ebp),%edx
10d4b8: 85 d2 test %edx,%edx
10d4ba: 75 17 jne 10d4d3 <_Thread_queue_Timeout+0x33><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
10d4bc: 83 ec 0c sub $0xc,%esp
10d4bf: 50 push %eax
10d4c0: e8 23 33 00 00 call 1107e8 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10d4c5: a1 ec 64 12 00 mov 0x1264ec,%eax
10d4ca: 48 dec %eax
10d4cb: a3 ec 64 12 00 mov %eax,0x1264ec
10d4d0: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10d4d3: c9 leave
10d4d4: c3 ret
001183e0 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
1183e0: 55 push %ebp
1183e1: 89 e5 mov %esp,%ebp
1183e3: 57 push %edi
1183e4: 56 push %esi
1183e5: 53 push %ebx
1183e6: 83 ec 4c sub $0x4c,%esp
1183e9: 8b 5d 08 mov 0x8(%ebp),%ebx
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
1183ec: 8d 45 e0 lea -0x20(%ebp),%eax
1183ef: 89 45 b4 mov %eax,-0x4c(%ebp)
1183f2: 89 45 dc mov %eax,-0x24(%ebp)
head->previous = NULL;
1183f5: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
tail->previous = head;
1183fc: 8d 4d dc lea -0x24(%ebp),%ecx
1183ff: 89 4d e4 mov %ecx,-0x1c(%ebp)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
118402: 8d 7d d0 lea -0x30(%ebp),%edi
118405: 8d 45 d4 lea -0x2c(%ebp),%eax
118408: 89 45 b0 mov %eax,-0x50(%ebp)
11840b: 89 45 d0 mov %eax,-0x30(%ebp)
head->previous = NULL;
11840e: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
tail->previous = head;
118415: 89 7d d8 mov %edi,-0x28(%ebp)
118418: 8d 73 30 lea 0x30(%ebx),%esi
11841b: 8d 4b 68 lea 0x68(%ebx),%ecx
11841e: 89 4d c4 mov %ecx,-0x3c(%ebp)
118421: 8d 43 08 lea 0x8(%ebx),%eax
118424: 89 45 c0 mov %eax,-0x40(%ebp)
118427: 8d 53 40 lea 0x40(%ebx),%edx
11842a: 89 55 bc mov %edx,-0x44(%ebp)
11842d: 8d 76 00 lea 0x0(%esi),%esi
{
/*
* Afterwards all timer inserts are directed to this chain and the interval
* and TOD chains will be no more modified by other parties.
*/
ts->insert_chain = insert_chain;
118430: 8d 4d dc lea -0x24(%ebp),%ecx
118433: 89 4b 78 mov %ecx,0x78(%ebx)
118436: 66 90 xchg %ax,%ax
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
118438: a1 24 0a 14 00 mov 0x140a24,%eax
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
11843d: 8b 53 3c mov 0x3c(%ebx),%edx
watchdogs->last_snapshot = snapshot;
118440: 89 43 3c mov %eax,0x3c(%ebx)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
118443: 51 push %ecx
118444: 57 push %edi
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
118445: 29 d0 sub %edx,%eax
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
118447: 50 push %eax
118448: 56 push %esi
118449: e8 5a 3d 00 00 call 11c1a8 <_Watchdog_Adjust_to_chain>
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
11844e: a1 88 09 14 00 mov 0x140988,%eax
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
118453: 8b 53 74 mov 0x74(%ebx),%edx
/*
* Process the seconds chain. Start by checking that the Time
* of Day (TOD) has not been set backwards. If it has then
* we want to adjust the watchdogs->Chain to indicate this.
*/
if ( snapshot > last_snapshot ) {
118456: 83 c4 10 add $0x10,%esp
118459: 39 d0 cmp %edx,%eax
11845b: 77 63 ja 1184c0 <_Timer_server_Body+0xe0>
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
11845d: 72 7d jb 1184dc <_Timer_server_Body+0xfc>
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
11845f: 89 43 74 mov %eax,0x74(%ebx)
118462: 66 90 xchg %ax,%ax
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
118464: 8b 43 78 mov 0x78(%ebx),%eax
118467: 83 ec 0c sub $0xc,%esp
11846a: 50 push %eax
11846b: e8 ac 09 00 00 call 118e1c <_Chain_Get>
if ( timer == NULL ) {
118470: 83 c4 10 add $0x10,%esp
118473: 85 c0 test %eax,%eax
118475: 74 35 je 1184ac <_Timer_server_Body+0xcc><== ALWAYS TAKEN
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
118477: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED
11847a: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED
11847d: 74 19 je 118498 <_Timer_server_Body+0xb8><== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
11847f: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED
118482: 75 e0 jne 118464 <_Timer_server_Body+0x84><== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
118484: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
118487: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
11848a: 50 push %eax <== NOT EXECUTED
11848b: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED
11848e: e8 a1 3d 00 00 call 11c234 <_Watchdog_Insert> <== NOT EXECUTED
118493: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
118496: eb cc jmp 118464 <_Timer_server_Body+0x84><== NOT EXECUTED
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
118498: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
11849b: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
11849e: 50 push %eax <== NOT EXECUTED
11849f: 56 push %esi <== NOT EXECUTED
1184a0: e8 8f 3d 00 00 call 11c234 <_Watchdog_Insert> <== NOT EXECUTED
1184a5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1184a8: eb ba jmp 118464 <_Timer_server_Body+0x84><== NOT EXECUTED
1184aa: 66 90 xchg %ax,%ax <== NOT EXECUTED
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
1184ac: 9c pushf
1184ad: fa cli
1184ae: 58 pop %eax
if ( _Chain_Is_empty( insert_chain ) ) {
1184af: 8b 55 b4 mov -0x4c(%ebp),%edx
1184b2: 39 55 dc cmp %edx,-0x24(%ebp)
1184b5: 74 41 je 1184f8 <_Timer_server_Body+0x118><== ALWAYS TAKEN
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
1184b7: 50 push %eax <== NOT EXECUTED
1184b8: 9d popf <== NOT EXECUTED
1184b9: e9 7a ff ff ff jmp 118438 <_Timer_server_Body+0x58><== NOT EXECUTED
1184be: 66 90 xchg %ax,%ax <== NOT EXECUTED
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1184c0: 51 push %ecx
1184c1: 57 push %edi
if ( snapshot > last_snapshot ) {
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
1184c2: 89 c1 mov %eax,%ecx
1184c4: 29 d1 sub %edx,%ecx
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1184c6: 51 push %ecx
1184c7: ff 75 c4 pushl -0x3c(%ebp)
1184ca: 89 45 b8 mov %eax,-0x48(%ebp)
1184cd: e8 d6 3c 00 00 call 11c1a8 <_Watchdog_Adjust_to_chain>
1184d2: 83 c4 10 add $0x10,%esp
1184d5: 8b 45 b8 mov -0x48(%ebp),%eax
1184d8: eb 85 jmp 11845f <_Timer_server_Body+0x7f>
1184da: 66 90 xchg %ax,%ax
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
1184dc: 51 push %ecx
} else if ( snapshot < last_snapshot ) {
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
1184dd: 29 c2 sub %eax,%edx
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
1184df: 52 push %edx
1184e0: 6a 01 push $0x1
1184e2: ff 75 c4 pushl -0x3c(%ebp)
1184e5: 89 45 b8 mov %eax,-0x48(%ebp)
1184e8: e8 43 3c 00 00 call 11c130 <_Watchdog_Adjust>
1184ed: 83 c4 10 add $0x10,%esp
1184f0: 8b 45 b8 mov -0x48(%ebp),%eax
1184f3: e9 67 ff ff ff jmp 11845f <_Timer_server_Body+0x7f>
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
ts->insert_chain = NULL;
1184f8: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx)
_ISR_Enable( level );
1184ff: 50 push %eax
118500: 9d popf
_Chain_Initialize_empty( &fire_chain );
while ( true ) {
_Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
if ( !_Chain_Is_empty( &fire_chain ) ) {
118501: 8b 4d b0 mov -0x50(%ebp),%ecx
118504: 39 4d d0 cmp %ecx,-0x30(%ebp)
118507: 75 23 jne 11852c <_Timer_server_Body+0x14c>
118509: eb 33 jmp 11853e <_Timer_server_Body+0x15e>
11850b: 90 nop
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
11850c: 8b 10 mov (%eax),%edx
head->next = new_first;
11850e: 89 55 d0 mov %edx,-0x30(%ebp)
new_first->previous = head;
118511: 89 7a 04 mov %edi,0x4(%edx)
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
118514: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
_ISR_Enable( level );
11851b: 51 push %ecx
11851c: 9d popf
/*
* The timer server may block here and wait for resources or time.
* The system watchdogs are inactive and will remain inactive since
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
11851d: 83 ec 08 sub $0x8,%esp
118520: ff 70 24 pushl 0x24(%eax)
118523: ff 70 20 pushl 0x20(%eax)
118526: ff 50 1c call *0x1c(%eax)
}
118529: 83 c4 10 add $0x10,%esp
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
11852c: 9c pushf
11852d: fa cli
11852e: 59 pop %ecx
initialized = false;
}
#endif
return status;
}
11852f: 8b 45 d0 mov -0x30(%ebp),%eax
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
118532: 3b 45 b0 cmp -0x50(%ebp),%eax
118535: 75 d5 jne 11850c <_Timer_server_Body+0x12c>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
118537: 51 push %ecx
118538: 9d popf
118539: e9 f2 fe ff ff jmp 118430 <_Timer_server_Body+0x50>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
11853e: c6 43 7c 00 movb $0x0,0x7c(%ebx)
118542: a1 ec 08 14 00 mov 0x1408ec,%eax
118547: 40 inc %eax
118548: a3 ec 08 14 00 mov %eax,0x1408ec
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
11854d: 83 ec 08 sub $0x8,%esp
118550: 6a 08 push $0x8
118552: ff 33 pushl (%ebx)
118554: e8 37 36 00 00 call 11bb90 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
118559: 89 d8 mov %ebx,%eax
11855b: e8 e0 fd ff ff call 118340 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
118560: 89 d8 mov %ebx,%eax
118562: e8 29 fe ff ff call 118390 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
118567: e8 a8 2d 00 00 call 11b314 <_Thread_Enable_dispatch>
ts->active = true;
11856c: c6 43 7c 01 movb $0x1,0x7c(%ebx)
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
118570: 5a pop %edx
118571: ff 75 c0 pushl -0x40(%ebp)
118574: e8 fb 3d 00 00 call 11c374 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
118579: 58 pop %eax
11857a: ff 75 bc pushl -0x44(%ebp)
11857d: e8 f2 3d 00 00 call 11c374 <_Watchdog_Remove>
118582: 83 c4 10 add $0x10,%esp
118585: e9 a6 fe ff ff jmp 118430 <_Timer_server_Body+0x50>
0011858c <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
11858c: 55 push %ebp
11858d: 89 e5 mov %esp,%ebp
11858f: 57 push %edi
118590: 56 push %esi
118591: 53 push %ebx
118592: 83 ec 2c sub $0x2c,%esp
118595: 8b 5d 08 mov 0x8(%ebp),%ebx
118598: 8b 45 0c mov 0xc(%ebp),%eax
if ( ts->insert_chain == NULL ) {
11859b: 8b 53 78 mov 0x78(%ebx),%edx
11859e: 85 d2 test %edx,%edx
1185a0: 74 16 je 1185b8 <_Timer_server_Schedule_operation_method+0x2c><== ALWAYS TAKEN
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
1185a2: 8b 53 78 mov 0x78(%ebx),%edx <== NOT EXECUTED
1185a5: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED
1185a8: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED
}
}
1185ab: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1185ae: 5b pop %ebx <== NOT EXECUTED
1185af: 5e pop %esi <== NOT EXECUTED
1185b0: 5f pop %edi <== NOT EXECUTED
1185b1: c9 leave <== NOT EXECUTED
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
1185b2: e9 29 08 00 00 jmp 118de0 <_Chain_Append> <== NOT EXECUTED
1185b7: 90 nop <== NOT EXECUTED
1185b8: 8b 15 ec 08 14 00 mov 0x1408ec,%edx
1185be: 42 inc %edx
1185bf: 89 15 ec 08 14 00 mov %edx,0x1408ec
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
1185c5: 8b 50 38 mov 0x38(%eax),%edx
1185c8: 83 fa 01 cmp $0x1,%edx
1185cb: 74 7b je 118648 <_Timer_server_Schedule_operation_method+0xbc>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
if ( !ts->active ) {
_Timer_server_Reset_interval_system_watchdog( ts );
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
1185cd: 83 fa 03 cmp $0x3,%edx
1185d0: 74 0e je 1185e0 <_Timer_server_Schedule_operation_method+0x54>
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
}
}
1185d2: 8d 65 f4 lea -0xc(%ebp),%esp
1185d5: 5b pop %ebx
1185d6: 5e pop %esi
1185d7: 5f pop %edi
1185d8: c9 leave
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
1185d9: e9 36 2d 00 00 jmp 11b314 <_Thread_Enable_dispatch>
1185de: 66 90 xchg %ax,%ax
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
1185e0: 9c pushf
1185e1: fa cli
1185e2: 8f 45 e4 popl -0x1c(%ebp)
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
1185e5: 8b 0d 88 09 14 00 mov 0x140988,%ecx
last_snapshot = ts->TOD_watchdogs.last_snapshot;
1185eb: 8b 53 74 mov 0x74(%ebx),%edx
1185ee: 89 55 d4 mov %edx,-0x2c(%ebp)
initialized = false;
}
#endif
return status;
}
1185f1: 8b 53 68 mov 0x68(%ebx),%edx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
1185f4: 8d 7b 6c lea 0x6c(%ebx),%edi
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
1185f7: 39 fa cmp %edi,%edx
1185f9: 74 21 je 11861c <_Timer_server_Schedule_operation_method+0x90>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
1185fb: 8b 7a 10 mov 0x10(%edx),%edi
if ( snapshot > last_snapshot ) {
1185fe: 3b 4d d4 cmp -0x2c(%ebp),%ecx
118601: 0f 86 a1 00 00 00 jbe 1186a8 <_Timer_server_Schedule_operation_method+0x11c>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
118607: 89 ce mov %ecx,%esi
118609: 2b 75 d4 sub -0x2c(%ebp),%esi
11860c: 89 75 d4 mov %esi,-0x2c(%ebp)
if (delta_interval > delta) {
11860f: 39 f7 cmp %esi,%edi
118611: 0f 86 9b 00 00 00 jbe 1186b2 <_Timer_server_Schedule_operation_method+0x126><== NEVER TAKEN
delta_interval -= delta;
118617: 29 f7 sub %esi,%edi
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
118619: 89 7a 10 mov %edi,0x10(%edx)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
11861c: 89 4b 74 mov %ecx,0x74(%ebx)
_ISR_Enable( level );
11861f: ff 75 e4 pushl -0x1c(%ebp)
118622: 9d popf
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
118623: 83 ec 08 sub $0x8,%esp
118626: 83 c0 10 add $0x10,%eax
118629: 50 push %eax
11862a: 8d 43 68 lea 0x68(%ebx),%eax
11862d: 50 push %eax
11862e: e8 01 3c 00 00 call 11c234 <_Watchdog_Insert>
if ( !ts->active ) {
118633: 8a 43 7c mov 0x7c(%ebx),%al
118636: 83 c4 10 add $0x10,%esp
118639: 84 c0 test %al,%al
11863b: 75 95 jne 1185d2 <_Timer_server_Schedule_operation_method+0x46>
_Timer_server_Reset_tod_system_watchdog( ts );
11863d: 89 d8 mov %ebx,%eax
11863f: e8 4c fd ff ff call 118390 <_Timer_server_Reset_tod_system_watchdog>
118644: eb 8c jmp 1185d2 <_Timer_server_Schedule_operation_method+0x46>
118646: 66 90 xchg %ax,%ax
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
118648: 9c pushf
118649: fa cli
11864a: 8f 45 e4 popl -0x1c(%ebp)
snapshot = _Watchdog_Ticks_since_boot;
11864d: 8b 0d 24 0a 14 00 mov 0x140a24,%ecx
last_snapshot = ts->Interval_watchdogs.last_snapshot;
118653: 8b 7b 3c mov 0x3c(%ebx),%edi
initialized = false;
}
#endif
return status;
}
118656: 8b 53 30 mov 0x30(%ebx),%edx
118659: 8d 73 34 lea 0x34(%ebx),%esi
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = _Watchdog_Ticks_since_boot;
last_snapshot = ts->Interval_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
11865c: 39 f2 cmp %esi,%edx
11865e: 74 10 je 118670 <_Timer_server_Schedule_operation_method+0xe4>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
118660: 89 ce mov %ecx,%esi
118662: 29 fe sub %edi,%esi
delta_interval = first_watchdog->delta_interval;
118664: 8b 7a 10 mov 0x10(%edx),%edi
if (delta_interval > delta) {
118667: 39 fe cmp %edi,%esi
118669: 73 39 jae 1186a4 <_Timer_server_Schedule_operation_method+0x118>
delta_interval -= delta;
11866b: 29 f7 sub %esi,%edi
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
11866d: 89 7a 10 mov %edi,0x10(%edx)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
118670: 89 4b 3c mov %ecx,0x3c(%ebx)
_ISR_Enable( level );
118673: ff 75 e4 pushl -0x1c(%ebp)
118676: 9d popf
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
118677: 83 ec 08 sub $0x8,%esp
11867a: 83 c0 10 add $0x10,%eax
11867d: 50 push %eax
11867e: 8d 43 30 lea 0x30(%ebx),%eax
118681: 50 push %eax
118682: e8 ad 3b 00 00 call 11c234 <_Watchdog_Insert>
if ( !ts->active ) {
118687: 8a 43 7c mov 0x7c(%ebx),%al
11868a: 83 c4 10 add $0x10,%esp
11868d: 84 c0 test %al,%al
11868f: 0f 85 3d ff ff ff jne 1185d2 <_Timer_server_Schedule_operation_method+0x46>
_Timer_server_Reset_interval_system_watchdog( ts );
118695: 89 d8 mov %ebx,%eax
118697: e8 a4 fc ff ff call 118340 <_Timer_server_Reset_interval_system_watchdog>
11869c: e9 31 ff ff ff jmp 1185d2 <_Timer_server_Schedule_operation_method+0x46>
1186a1: 8d 76 00 lea 0x0(%esi),%esi
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
1186a4: 31 ff xor %edi,%edi
1186a6: eb c5 jmp 11866d <_Timer_server_Schedule_operation_method+0xe1>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
1186a8: 03 7d d4 add -0x2c(%ebp),%edi
delta_interval += delta;
1186ab: 29 cf sub %ecx,%edi
1186ad: e9 67 ff ff ff jmp 118619 <_Timer_server_Schedule_operation_method+0x8d>
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
1186b2: 31 ff xor %edi,%edi <== NOT EXECUTED
1186b4: e9 60 ff ff ff jmp 118619 <_Timer_server_Schedule_operation_method+0x8d><== NOT EXECUTED
0010ee48 <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
10ee48: 55 push %ebp
10ee49: 89 e5 mov %esp,%ebp
10ee4b: 57 push %edi
10ee4c: 56 push %esi
10ee4d: 53 push %ebx
10ee4e: 83 ec 2c sub $0x2c,%esp
10ee51: 8b 45 08 mov 0x8(%ebp),%eax
10ee54: 8b 4d 0c mov 0xc(%ebp),%ecx
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
10ee57: 8b 38 mov (%eax),%edi
left += lhs->tv_nsec;
10ee59: 8b 70 04 mov 0x4(%eax),%esi
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
10ee5c: bb 00 ca 9a 3b mov $0x3b9aca00,%ebx
10ee61: 8b 01 mov (%ecx),%eax
10ee63: f7 eb imul %ebx
10ee65: 89 45 e0 mov %eax,-0x20(%ebp)
10ee68: 89 55 e4 mov %edx,-0x1c(%ebp)
right += rhs->tv_nsec;
10ee6b: 8b 41 04 mov 0x4(%ecx),%eax
10ee6e: 99 cltd
10ee6f: 01 45 e0 add %eax,-0x20(%ebp)
10ee72: 11 55 e4 adc %edx,-0x1c(%ebp)
if ( right == 0 ) {
10ee75: 8b 55 e4 mov -0x1c(%ebp),%edx
10ee78: 0b 55 e0 or -0x20(%ebp),%edx
10ee7b: 74 73 je 10eef0 <_Timespec_Divide+0xa8>
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
10ee7d: 89 f8 mov %edi,%eax
10ee7f: f7 eb imul %ebx
10ee81: 89 45 d0 mov %eax,-0x30(%ebp)
10ee84: 89 55 d4 mov %edx,-0x2c(%ebp)
left += lhs->tv_nsec;
10ee87: 89 f7 mov %esi,%edi
10ee89: c1 ff 1f sar $0x1f,%edi
10ee8c: 01 75 d0 add %esi,-0x30(%ebp)
10ee8f: 11 7d d4 adc %edi,-0x2c(%ebp)
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
10ee92: 69 4d d4 a0 86 01 00 imul $0x186a0,-0x2c(%ebp),%ecx
10ee99: bb a0 86 01 00 mov $0x186a0,%ebx
10ee9e: 8b 45 d0 mov -0x30(%ebp),%eax
10eea1: f7 e3 mul %ebx
10eea3: 8d 34 11 lea (%ecx,%edx,1),%esi
10eea6: ff 75 e4 pushl -0x1c(%ebp)
10eea9: ff 75 e0 pushl -0x20(%ebp)
10eeac: 56 push %esi
10eead: 50 push %eax
10eeae: e8 e9 0a 01 00 call 11f99c <__udivdi3>
10eeb3: 83 c4 10 add $0x10,%esp
10eeb6: 89 c3 mov %eax,%ebx
10eeb8: 89 d6 mov %edx,%esi
*ival_percentage = answer / 1000;
10eeba: 6a 00 push $0x0
10eebc: 68 e8 03 00 00 push $0x3e8
10eec1: 52 push %edx
10eec2: 50 push %eax
10eec3: e8 d4 0a 01 00 call 11f99c <__udivdi3>
10eec8: 83 c4 10 add $0x10,%esp
10eecb: 8b 55 10 mov 0x10(%ebp),%edx
10eece: 89 02 mov %eax,(%edx)
*fval_percentage = answer % 1000;
10eed0: 6a 00 push $0x0
10eed2: 68 e8 03 00 00 push $0x3e8
10eed7: 56 push %esi
10eed8: 53 push %ebx
10eed9: e8 ce 0b 01 00 call 11faac <__umoddi3>
10eede: 83 c4 10 add $0x10,%esp
10eee1: 8b 55 14 mov 0x14(%ebp),%edx
10eee4: 89 02 mov %eax,(%edx)
}
10eee6: 8d 65 f4 lea -0xc(%ebp),%esp
10eee9: 5b pop %ebx
10eeea: 5e pop %esi
10eeeb: 5f pop %edi
10eeec: c9 leave
10eeed: c3 ret
10eeee: 66 90 xchg %ax,%ax
left += lhs->tv_nsec;
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
right += rhs->tv_nsec;
if ( right == 0 ) {
*ival_percentage = 0;
10eef0: 8b 45 10 mov 0x10(%ebp),%eax
10eef3: c7 00 00 00 00 00 movl $0x0,(%eax)
*fval_percentage = 0;
10eef9: 8b 55 14 mov 0x14(%ebp),%edx
10eefc: c7 02 00 00 00 00 movl $0x0,(%edx)
answer = (left * 100000) / right;
*ival_percentage = answer / 1000;
*fval_percentage = answer % 1000;
}
10ef02: 8d 65 f4 lea -0xc(%ebp),%esp
10ef05: 5b pop %ebx
10ef06: 5e pop %esi
10ef07: 5f pop %edi
10ef08: c9 leave
10ef09: c3 ret
0011f1d0 <_Timespec_Is_valid>:
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
const struct timespec *time
)
{
11f1d0: 55 push %ebp
11f1d1: 89 e5 mov %esp,%ebp
11f1d3: 8b 45 08 mov 0x8(%ebp),%eax
if ( !time )
11f1d6: 85 c0 test %eax,%eax
11f1d8: 74 1a je 11f1f4 <_Timespec_Is_valid+0x24>
return false;
if ( time->tv_sec < 0 )
11f1da: 8b 10 mov (%eax),%edx
11f1dc: 85 d2 test %edx,%edx
11f1de: 78 14 js 11f1f4 <_Timespec_Is_valid+0x24>
return false;
if ( time->tv_nsec < 0 )
11f1e0: 8b 40 04 mov 0x4(%eax),%eax
11f1e3: 85 c0 test %eax,%eax
11f1e5: 78 0d js 11f1f4 <_Timespec_Is_valid+0x24>
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
11f1e7: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax
11f1ec: 0f 96 c0 setbe %al
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
11f1ef: c9 leave
11f1f0: c3 ret
11f1f1: 8d 76 00 lea 0x0(%esi),%esi
if ( time->tv_sec < 0 )
return false;
if ( time->tv_nsec < 0 )
return false;
11f1f4: 31 c0 xor %eax,%eax
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
11f1f6: c9 leave
11f1f7: c3 ret
0011f1f8 <_Timespec_To_ticks>:
*/
uint32_t _Timespec_To_ticks(
const struct timespec *time
)
{
11f1f8: 55 push %ebp
11f1f9: 89 e5 mov %esp,%ebp
11f1fb: 56 push %esi
11f1fc: 53 push %ebx
11f1fd: 8b 5d 08 mov 0x8(%ebp),%ebx
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
11f200: 8b 33 mov (%ebx),%esi
11f202: 85 f6 test %esi,%esi
11f204: 75 07 jne 11f20d <_Timespec_To_ticks+0x15>
11f206: 8b 43 04 mov 0x4(%ebx),%eax
11f209: 85 c0 test %eax,%eax
11f20b: 74 37 je 11f244 <_Timespec_To_ticks+0x4c>
return 0;
ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
11f20d: e8 ba 01 00 00 call 11f3cc <TOD_TICKS_PER_SECOND_method>
11f212: 89 c1 mov %eax,%ecx
11f214: 0f af ce imul %esi,%ecx
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
11f217: a1 8c 32 12 00 mov 0x12328c,%eax
11f21c: 8d 04 80 lea (%eax,%eax,4),%eax
11f21f: 8d 04 80 lea (%eax,%eax,4),%eax
11f222: 8d 34 80 lea (%eax,%eax,4),%esi
11f225: c1 e6 03 shl $0x3,%esi
11f228: 8b 43 04 mov 0x4(%ebx),%eax
11f22b: 31 d2 xor %edx,%edx
11f22d: f7 f6 div %esi
if (ticks)
11f22f: 01 c8 add %ecx,%eax
11f231: 74 05 je 11f238 <_Timespec_To_ticks+0x40>
return ticks;
return 1;
}
11f233: 5b pop %ebx
11f234: 5e pop %esi
11f235: c9 leave
11f236: c3 ret
11f237: 90 nop
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
if (ticks)
return ticks;
return 1;
11f238: b8 01 00 00 00 mov $0x1,%eax
}
11f23d: 5b pop %ebx
11f23e: 5e pop %esi
11f23f: c9 leave
11f240: c3 ret
11f241: 8d 76 00 lea 0x0(%esi),%esi
)
{
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
return 0;
11f244: 31 c0 xor %eax,%eax
if (ticks)
return ticks;
return 1;
}
11f246: 5b pop %ebx
11f247: 5e pop %esi
11f248: c9 leave
11f249: c3 ret
0010d8a4 <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10d8a4: 55 push %ebp
10d8a5: 89 e5 mov %esp,%ebp
10d8a7: 57 push %edi
10d8a8: 56 push %esi
10d8a9: 53 push %ebx
10d8aa: 83 ec 1c sub $0x1c,%esp
10d8ad: 8b 75 08 mov 0x8(%ebp),%esi
10d8b0: 8b 7d 10 mov 0x10(%ebp),%edi
10d8b3: 8a 45 0c mov 0xc(%ebp),%al
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
10d8b6: 8b 1d 14 67 12 00 mov 0x126714,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10d8bc: 81 fb 0c 67 12 00 cmp $0x12670c,%ebx
10d8c2: 74 25 je 10d8e9 <_User_extensions_Fatal+0x45><== NEVER TAKEN
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10d8c4: 0f b6 c0 movzbl %al,%eax
10d8c7: 89 45 e4 mov %eax,-0x1c(%ebp)
10d8ca: 66 90 xchg %ax,%ax
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
10d8cc: 8b 43 30 mov 0x30(%ebx),%eax
10d8cf: 85 c0 test %eax,%eax
10d8d1: 74 0b je 10d8de <_User_extensions_Fatal+0x3a>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10d8d3: 52 push %edx
10d8d4: 57 push %edi
10d8d5: ff 75 e4 pushl -0x1c(%ebp)
10d8d8: 56 push %esi
10d8d9: ff d0 call *%eax
10d8db: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
10d8de: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10d8e1: 81 fb 0c 67 12 00 cmp $0x12670c,%ebx
10d8e7: 75 e3 jne 10d8cc <_User_extensions_Fatal+0x28><== ALWAYS TAKEN
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
10d8e9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10d8ec: 5b pop %ebx <== NOT EXECUTED
10d8ed: 5e pop %esi <== NOT EXECUTED
10d8ee: 5f pop %edi <== NOT EXECUTED
10d8ef: c9 leave <== NOT EXECUTED
10d8f0: c3 ret <== NOT EXECUTED
0010d768 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
10d768: 55 push %ebp
10d769: 89 e5 mov %esp,%ebp
10d76b: 57 push %edi
10d76c: 56 push %esi
10d76d: 53 push %ebx
10d76e: 83 ec 1c sub $0x1c,%esp
User_extensions_Control *extension;
uint32_t i;
uint32_t number_of_extensions;
User_extensions_Table *initial_extensions;
number_of_extensions = Configuration.number_of_initial_extensions;
10d771: a1 38 23 12 00 mov 0x122338,%eax
10d776: 89 45 dc mov %eax,-0x24(%ebp)
initial_extensions = Configuration.User_extension_table;
10d779: 8b 35 3c 23 12 00 mov 0x12233c,%esi
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10d77f: c7 05 0c 67 12 00 10 movl $0x126710,0x12670c
10d786: 67 12 00
head->previous = NULL;
10d789: c7 05 10 67 12 00 00 movl $0x0,0x126710
10d790: 00 00 00
tail->previous = head;
10d793: c7 05 14 67 12 00 0c movl $0x12670c,0x126714
10d79a: 67 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10d79d: c7 05 f0 64 12 00 f4 movl $0x1264f4,0x1264f0
10d7a4: 64 12 00
head->previous = NULL;
10d7a7: c7 05 f4 64 12 00 00 movl $0x0,0x1264f4
10d7ae: 00 00 00
tail->previous = head;
10d7b1: c7 05 f8 64 12 00 f0 movl $0x1264f0,0x1264f8
10d7b8: 64 12 00
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
10d7bb: 85 f6 test %esi,%esi
10d7bd: 74 64 je 10d823 <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
10d7bf: 89 c2 mov %eax,%edx
10d7c1: 8d 04 40 lea (%eax,%eax,2),%eax
10d7c4: 8d 0c 82 lea (%edx,%eax,4),%ecx
10d7c7: c1 e1 02 shl $0x2,%ecx
10d7ca: 83 ec 0c sub $0xc,%esp
10d7cd: 51 push %ecx
10d7ce: 89 4d d8 mov %ecx,-0x28(%ebp)
10d7d1: e8 ce 04 00 00 call 10dca4 <_Workspace_Allocate_or_fatal_error>
10d7d6: 89 c3 mov %eax,%ebx
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
10d7d8: 31 c0 xor %eax,%eax
10d7da: 8b 4d d8 mov -0x28(%ebp),%ecx
10d7dd: 89 df mov %ebx,%edi
10d7df: f3 aa rep stos %al,%es:(%edi)
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10d7e1: 83 c4 10 add $0x10,%esp
10d7e4: 8b 45 dc mov -0x24(%ebp),%eax
10d7e7: 85 c0 test %eax,%eax
10d7e9: 74 38 je 10d823 <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN
10d7eb: 89 75 e4 mov %esi,-0x1c(%ebp)
10d7ee: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
10d7f5: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
10d7f8: 8d 7b 14 lea 0x14(%ebx),%edi
10d7fb: 8b 75 e4 mov -0x1c(%ebp),%esi
10d7fe: b9 08 00 00 00 mov $0x8,%ecx
10d803: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_User_extensions_Add_set( extension );
10d805: 83 ec 0c sub $0xc,%esp
10d808: 53 push %ebx
10d809: e8 46 30 00 00 call 110854 <_User_extensions_Add_set>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
10d80e: 83 c3 34 add $0x34,%ebx
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10d811: ff 45 e0 incl -0x20(%ebp)
10d814: 83 45 e4 20 addl $0x20,-0x1c(%ebp)
10d818: 83 c4 10 add $0x10,%esp
10d81b: 8b 45 e0 mov -0x20(%ebp),%eax
10d81e: 39 45 dc cmp %eax,-0x24(%ebp)
10d821: 77 d5 ja 10d7f8 <_User_extensions_Handler_initialization+0x90>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
10d823: 8d 65 f4 lea -0xc(%ebp),%esp
10d826: 5b pop %ebx
10d827: 5e pop %esi
10d828: 5f pop %edi
10d829: c9 leave
10d82a: c3 ret
0010ebf8 <_User_extensions_Remove_set>:
#include <rtems/score/userext.h>
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
10ebf8: 55 push %ebp
10ebf9: 89 e5 mov %esp,%ebp
10ebfb: 53 push %ebx
10ebfc: 83 ec 10 sub $0x10,%esp
10ebff: 8b 5d 08 mov 0x8(%ebp),%ebx
_Chain_Extract( &the_extension->Node );
10ec02: 53 push %ebx
10ec03: e8 3c dc ff ff call 10c844 <_Chain_Extract>
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
10ec08: 83 c4 10 add $0x10,%esp
10ec0b: 8b 43 24 mov 0x24(%ebx),%eax
10ec0e: 85 c0 test %eax,%eax
10ec10: 74 12 je 10ec24 <_User_extensions_Remove_set+0x2c>
_Chain_Extract( &the_extension->Switch.Node );
10ec12: 83 c3 08 add $0x8,%ebx
10ec15: 89 5d 08 mov %ebx,0x8(%ebp)
}
10ec18: 8b 5d fc mov -0x4(%ebp),%ebx
10ec1b: c9 leave
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
_Chain_Extract( &the_extension->Switch.Node );
10ec1c: e9 23 dc ff ff jmp 10c844 <_Chain_Extract>
10ec21: 8d 76 00 lea 0x0(%esi),%esi
}
10ec24: 8b 5d fc mov -0x4(%ebp),%ebx
10ec27: c9 leave
10ec28: c3 ret
0010d82c <_User_extensions_Thread_begin>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_begin (
Thread_Control *executing
)
{
10d82c: 55 push %ebp
10d82d: 89 e5 mov %esp,%ebp
10d82f: 56 push %esi
10d830: 53 push %ebx
10d831: 8b 75 08 mov 0x8(%ebp),%esi
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
10d834: 8b 1d 0c 67 12 00 mov 0x12670c,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10d83a: 81 fb 10 67 12 00 cmp $0x126710,%ebx
10d840: 74 1c je 10d85e <_User_extensions_Thread_begin+0x32><== NEVER TAKEN
10d842: 66 90 xchg %ax,%ax
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_begin != NULL )
10d844: 8b 43 28 mov 0x28(%ebx),%eax
10d847: 85 c0 test %eax,%eax
10d849: 74 09 je 10d854 <_User_extensions_Thread_begin+0x28>
(*the_extension->Callouts.thread_begin)( executing );
10d84b: 83 ec 0c sub $0xc,%esp
10d84e: 56 push %esi
10d84f: ff d0 call *%eax
10d851: 83 c4 10 add $0x10,%esp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
10d854: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10d856: 81 fb 10 67 12 00 cmp $0x126710,%ebx
10d85c: 75 e6 jne 10d844 <_User_extensions_Thread_begin+0x18>
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_begin != NULL )
(*the_extension->Callouts.thread_begin)( executing );
}
}
10d85e: 8d 65 f8 lea -0x8(%ebp),%esp
10d861: 5b pop %ebx
10d862: 5e pop %esi
10d863: c9 leave
10d864: c3 ret
0010d8f4 <_User_extensions_Thread_create>:
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
10d8f4: 55 push %ebp
10d8f5: 89 e5 mov %esp,%ebp
10d8f7: 56 push %esi
10d8f8: 53 push %ebx
10d8f9: 8b 75 08 mov 0x8(%ebp),%esi
return false;
}
}
return true;
}
10d8fc: 8b 1d 0c 67 12 00 mov 0x12670c,%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
10d902: 81 fb 10 67 12 00 cmp $0x126710,%ebx
10d908: 74 26 je 10d930 <_User_extensions_Thread_create+0x3c><== NEVER TAKEN
10d90a: 66 90 xchg %ax,%ax
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
10d90c: 8b 43 14 mov 0x14(%ebx),%eax
10d90f: 85 c0 test %eax,%eax
10d911: 74 13 je 10d926 <_User_extensions_Thread_create+0x32>
status = (*the_extension->Callouts.thread_create)(
10d913: 83 ec 08 sub $0x8,%esp
10d916: 56 push %esi
10d917: ff 35 78 67 12 00 pushl 0x126778
10d91d: ff d0 call *%eax
_Thread_Executing,
the_thread
);
if ( !status )
10d91f: 83 c4 10 add $0x10,%esp
10d922: 84 c0 test %al,%al
10d924: 74 16 je 10d93c <_User_extensions_Thread_create+0x48>
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
10d926: 8b 1b mov (%ebx),%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
10d928: 81 fb 10 67 12 00 cmp $0x126710,%ebx
10d92e: 75 dc jne 10d90c <_User_extensions_Thread_create+0x18>
if ( !status )
return false;
}
}
return true;
10d930: b0 01 mov $0x1,%al
}
10d932: 8d 65 f8 lea -0x8(%ebp),%esp
10d935: 5b pop %ebx
10d936: 5e pop %esi
10d937: c9 leave
10d938: c3 ret
10d939: 8d 76 00 lea 0x0(%esi),%esi
status = (*the_extension->Callouts.thread_create)(
_Thread_Executing,
the_thread
);
if ( !status )
return false;
10d93c: 31 c0 xor %eax,%eax
}
}
return true;
}
10d93e: 8d 65 f8 lea -0x8(%ebp),%esp
10d941: 5b pop %ebx
10d942: 5e pop %esi
10d943: c9 leave
10d944: c3 ret
0010d948 <_User_extensions_Thread_delete>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_delete (
Thread_Control *the_thread
)
{
10d948: 55 push %ebp
10d949: 89 e5 mov %esp,%ebp
10d94b: 56 push %esi
10d94c: 53 push %ebx
10d94d: 8b 75 08 mov 0x8(%ebp),%esi
(*the_extension->Callouts.thread_delete)(
_Thread_Executing,
the_thread
);
}
}
10d950: 8b 1d 14 67 12 00 mov 0x126714,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10d956: 81 fb 0c 67 12 00 cmp $0x12670c,%ebx
10d95c: 74 23 je 10d981 <_User_extensions_Thread_delete+0x39><== NEVER TAKEN
10d95e: 66 90 xchg %ax,%ax
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_delete != NULL )
10d960: 8b 43 20 mov 0x20(%ebx),%eax
10d963: 85 c0 test %eax,%eax
10d965: 74 0f je 10d976 <_User_extensions_Thread_delete+0x2e>
(*the_extension->Callouts.thread_delete)(
10d967: 83 ec 08 sub $0x8,%esp
10d96a: 56 push %esi
10d96b: ff 35 78 67 12 00 pushl 0x126778
10d971: ff d0 call *%eax
10d973: 83 c4 10 add $0x10,%esp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
10d976: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10d979: 81 fb 0c 67 12 00 cmp $0x12670c,%ebx
10d97f: 75 df jne 10d960 <_User_extensions_Thread_delete+0x18>
(*the_extension->Callouts.thread_delete)(
_Thread_Executing,
the_thread
);
}
}
10d981: 8d 65 f8 lea -0x8(%ebp),%esp
10d984: 5b pop %ebx
10d985: 5e pop %esi
10d986: c9 leave
10d987: c3 ret
0010d868 <_User_extensions_Thread_exitted>:
void _User_extensions_Thread_exitted (
Thread_Control *executing
)
{
10d868: 55 push %ebp
10d869: 89 e5 mov %esp,%ebp
10d86b: 56 push %esi
10d86c: 53 push %ebx
10d86d: 8b 75 08 mov 0x8(%ebp),%esi
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
10d870: 8b 1d 14 67 12 00 mov 0x126714,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10d876: 81 fb 0c 67 12 00 cmp $0x12670c,%ebx
10d87c: 74 1d je 10d89b <_User_extensions_Thread_exitted+0x33><== NEVER TAKEN
10d87e: 66 90 xchg %ax,%ax
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_exitted != NULL )
10d880: 8b 43 2c mov 0x2c(%ebx),%eax
10d883: 85 c0 test %eax,%eax
10d885: 74 09 je 10d890 <_User_extensions_Thread_exitted+0x28>
(*the_extension->Callouts.thread_exitted)( executing );
10d887: 83 ec 0c sub $0xc,%esp
10d88a: 56 push %esi
10d88b: ff d0 call *%eax
10d88d: 83 c4 10 add $0x10,%esp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
10d890: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10d893: 81 fb 0c 67 12 00 cmp $0x12670c,%ebx
10d899: 75 e5 jne 10d880 <_User_extensions_Thread_exitted+0x18>
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_exitted != NULL )
(*the_extension->Callouts.thread_exitted)( executing );
}
}
10d89b: 8d 65 f8 lea -0x8(%ebp),%esp
10d89e: 5b pop %ebx
10d89f: 5e pop %esi
10d8a0: c9 leave
10d8a1: c3 ret
0010e4d4 <_User_extensions_Thread_restart>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_restart (
Thread_Control *the_thread
)
{
10e4d4: 55 push %ebp
10e4d5: 89 e5 mov %esp,%ebp
10e4d7: 56 push %esi
10e4d8: 53 push %ebx
10e4d9: 8b 75 08 mov 0x8(%ebp),%esi
(*the_extension->Callouts.thread_restart)(
_Thread_Executing,
the_thread
);
}
}
10e4dc: 8b 1d ec 76 12 00 mov 0x1276ec,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e4e2: 81 fb f0 76 12 00 cmp $0x1276f0,%ebx
10e4e8: 74 22 je 10e50c <_User_extensions_Thread_restart+0x38><== NEVER TAKEN
10e4ea: 66 90 xchg %ax,%ax
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_restart != NULL )
10e4ec: 8b 43 1c mov 0x1c(%ebx),%eax
10e4ef: 85 c0 test %eax,%eax
10e4f1: 74 0f je 10e502 <_User_extensions_Thread_restart+0x2e>
(*the_extension->Callouts.thread_restart)(
10e4f3: 83 ec 08 sub $0x8,%esp
10e4f6: 56 push %esi
10e4f7: ff 35 58 77 12 00 pushl 0x127758
10e4fd: ff d0 call *%eax
10e4ff: 83 c4 10 add $0x10,%esp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
10e502: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e504: 81 fb f0 76 12 00 cmp $0x1276f0,%ebx
10e50a: 75 e0 jne 10e4ec <_User_extensions_Thread_restart+0x18>
(*the_extension->Callouts.thread_restart)(
_Thread_Executing,
the_thread
);
}
}
10e50c: 8d 65 f8 lea -0x8(%ebp),%esp
10e50f: 5b pop %ebx
10e510: 5e pop %esi
10e511: c9 leave
10e512: c3 ret
0010d988 <_User_extensions_Thread_start>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_start (
Thread_Control *the_thread
)
{
10d988: 55 push %ebp
10d989: 89 e5 mov %esp,%ebp
10d98b: 56 push %esi
10d98c: 53 push %ebx
10d98d: 8b 75 08 mov 0x8(%ebp),%esi
(*the_extension->Callouts.thread_start)(
_Thread_Executing,
the_thread
);
}
}
10d990: 8b 1d 0c 67 12 00 mov 0x12670c,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10d996: 81 fb 10 67 12 00 cmp $0x126710,%ebx
10d99c: 74 22 je 10d9c0 <_User_extensions_Thread_start+0x38><== NEVER TAKEN
10d99e: 66 90 xchg %ax,%ax
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_start != NULL )
10d9a0: 8b 43 18 mov 0x18(%ebx),%eax
10d9a3: 85 c0 test %eax,%eax
10d9a5: 74 0f je 10d9b6 <_User_extensions_Thread_start+0x2e>
(*the_extension->Callouts.thread_start)(
10d9a7: 83 ec 08 sub $0x8,%esp
10d9aa: 56 push %esi
10d9ab: ff 35 78 67 12 00 pushl 0x126778
10d9b1: ff d0 call *%eax
10d9b3: 83 c4 10 add $0x10,%esp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
10d9b6: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10d9b8: 81 fb 10 67 12 00 cmp $0x126710,%ebx
10d9be: 75 e0 jne 10d9a0 <_User_extensions_Thread_start+0x18>
(*the_extension->Callouts.thread_start)(
_Thread_Executing,
the_thread
);
}
}
10d9c0: 8d 65 f8 lea -0x8(%ebp),%esp
10d9c3: 5b pop %ebx
10d9c4: 5e pop %esi
10d9c5: c9 leave
10d9c6: c3 ret
0010d9c8 <_User_extensions_Thread_switch>:
void _User_extensions_Thread_switch (
Thread_Control *executing,
Thread_Control *heir
)
{
10d9c8: 55 push %ebp
10d9c9: 89 e5 mov %esp,%ebp
10d9cb: 57 push %edi
10d9cc: 56 push %esi
10d9cd: 53 push %ebx
10d9ce: 83 ec 0c sub $0xc,%esp
10d9d1: 8b 7d 08 mov 0x8(%ebp),%edi
10d9d4: 8b 75 0c mov 0xc(%ebp),%esi
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
}
}
10d9d7: 8b 1d f0 64 12 00 mov 0x1264f0,%ebx
)
{
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
10d9dd: 81 fb f4 64 12 00 cmp $0x1264f4,%ebx
10d9e3: 74 18 je 10d9fd <_User_extensions_Thread_switch+0x35><== NEVER TAKEN
10d9e5: 8d 76 00 lea 0x0(%esi),%esi
!_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
the_node = the_node->next ) {
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
10d9e8: 83 ec 08 sub $0x8,%esp
10d9eb: 56 push %esi
10d9ec: 57 push %edi
10d9ed: ff 53 08 call *0x8(%ebx)
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
!_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
the_node = the_node->next ) {
10d9f0: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
10d9f2: 83 c4 10 add $0x10,%esp
10d9f5: 81 fb f4 64 12 00 cmp $0x1264f4,%ebx
10d9fb: 75 eb jne 10d9e8 <_User_extensions_Thread_switch+0x20>
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
}
}
10d9fd: 8d 65 f4 lea -0xc(%ebp),%esp
10da00: 5b pop %ebx
10da01: 5e pop %esi
10da02: 5f pop %edi
10da03: c9 leave
10da04: c3 ret
0010f228 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
10f228: 55 push %ebp
10f229: 89 e5 mov %esp,%ebp
10f22b: 57 push %edi
10f22c: 56 push %esi
10f22d: 53 push %ebx
10f22e: 83 ec 1c sub $0x1c,%esp
10f231: 8b 75 08 mov 0x8(%ebp),%esi
10f234: 8b 4d 0c mov 0xc(%ebp),%ecx
10f237: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
10f23a: 9c pushf
10f23b: fa cli
10f23c: 58 pop %eax
}
}
_ISR_Enable( level );
}
10f23d: 8b 16 mov (%esi),%edx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10f23f: 8d 7e 04 lea 0x4(%esi),%edi
10f242: 89 7d e4 mov %edi,-0x1c(%ebp)
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
10f245: 39 fa cmp %edi,%edx
10f247: 74 3d je 10f286 <_Watchdog_Adjust+0x5e>
switch ( direction ) {
10f249: 85 c9 test %ecx,%ecx
10f24b: 75 43 jne 10f290 <_Watchdog_Adjust+0x68>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
10f24d: 85 db test %ebx,%ebx
10f24f: 74 35 je 10f286 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
10f251: 8b 7a 10 mov 0x10(%edx),%edi
10f254: 39 fb cmp %edi,%ebx
10f256: 73 0f jae 10f267 <_Watchdog_Adjust+0x3f> <== ALWAYS TAKEN
10f258: eb 3e jmp 10f298 <_Watchdog_Adjust+0x70> <== NOT EXECUTED
10f25a: 66 90 xchg %ax,%ax <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
10f25c: 29 fb sub %edi,%ebx
10f25e: 74 26 je 10f286 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
10f260: 8b 7a 10 mov 0x10(%edx),%edi
10f263: 39 df cmp %ebx,%edi
10f265: 77 31 ja 10f298 <_Watchdog_Adjust+0x70>
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
10f267: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx)
_ISR_Enable( level );
10f26e: 50 push %eax
10f26f: 9d popf
_Watchdog_Tickle( header );
10f270: 83 ec 0c sub $0xc,%esp
10f273: 56 push %esi
10f274: e8 d3 01 00 00 call 10f44c <_Watchdog_Tickle>
_ISR_Disable( level );
10f279: 9c pushf
10f27a: fa cli
10f27b: 58 pop %eax
}
}
_ISR_Enable( level );
}
10f27c: 8b 16 mov (%esi),%edx
_Watchdog_Tickle( header );
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
10f27e: 83 c4 10 add $0x10,%esp
10f281: 39 55 e4 cmp %edx,-0x1c(%ebp)
10f284: 75 d6 jne 10f25c <_Watchdog_Adjust+0x34>
}
break;
}
}
_ISR_Enable( level );
10f286: 50 push %eax
10f287: 9d popf
}
10f288: 8d 65 f4 lea -0xc(%ebp),%esp
10f28b: 5b pop %ebx
10f28c: 5e pop %esi
10f28d: 5f pop %edi
10f28e: c9 leave
10f28f: c3 ret
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
10f290: 49 dec %ecx
10f291: 75 f3 jne 10f286 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
10f293: 01 5a 10 add %ebx,0x10(%edx)
break;
10f296: eb ee jmp 10f286 <_Watchdog_Adjust+0x5e>
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
10f298: 29 df sub %ebx,%edi
10f29a: 89 7a 10 mov %edi,0x10(%edx)
break;
10f29d: eb e7 jmp 10f286 <_Watchdog_Adjust+0x5e>
0010da08 <_Watchdog_Insert>:
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
10da08: 55 push %ebp
10da09: 89 e5 mov %esp,%ebp
10da0b: 57 push %edi
10da0c: 56 push %esi
10da0d: 53 push %ebx
10da0e: 83 ec 04 sub $0x4,%esp
10da11: 8b 5d 0c mov 0xc(%ebp),%ebx
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
10da14: 8b 3d 74 67 12 00 mov 0x126774,%edi
_ISR_Disable( level );
10da1a: 9c pushf
10da1b: fa cli
10da1c: 8f 45 f0 popl -0x10(%ebp)
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
10da1f: 8b 43 08 mov 0x8(%ebx),%eax
10da22: 85 c0 test %eax,%eax
10da24: 0f 85 9e 00 00 00 jne 10dac8 <_Watchdog_Insert+0xc0>
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
10da2a: c7 43 08 01 00 00 00 movl $0x1,0x8(%ebx)
_Watchdog_Sync_count++;
10da31: a1 20 66 12 00 mov 0x126620,%eax
10da36: 40 inc %eax
10da37: a3 20 66 12 00 mov %eax,0x126620
restart:
delta_interval = the_watchdog->initial;
10da3c: 8b 43 0c mov 0xc(%ebx),%eax
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
10da3f: 8b 4d 08 mov 0x8(%ebp),%ecx
10da42: 8b 11 mov (%ecx),%edx
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
10da44: 85 c0 test %eax,%eax
10da46: 74 5d je 10daa5 <_Watchdog_Insert+0x9d>
10da48: 8b 32 mov (%edx),%esi
10da4a: 85 f6 test %esi,%esi
10da4c: 74 57 je 10daa5 <_Watchdog_Insert+0x9d>
break;
if ( delta_interval < after->delta_interval ) {
10da4e: 8b 4a 10 mov 0x10(%edx),%ecx
10da51: 39 c8 cmp %ecx,%eax
10da53: 73 22 jae 10da77 <_Watchdog_Insert+0x6f>
10da55: eb 49 jmp 10daa0 <_Watchdog_Insert+0x98>
10da57: 90 nop
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
10da58: 8b 35 a4 65 12 00 mov 0x1265a4,%esi
10da5e: 39 f7 cmp %esi,%edi
10da60: 72 72 jb 10dad4 <_Watchdog_Insert+0xcc>
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
10da62: 29 c8 sub %ecx,%eax
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
10da64: 8b 12 mov (%edx),%edx
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
10da66: 85 c0 test %eax,%eax
10da68: 74 3b je 10daa5 <_Watchdog_Insert+0x9d>
10da6a: 8b 0a mov (%edx),%ecx
10da6c: 85 c9 test %ecx,%ecx
10da6e: 74 35 je 10daa5 <_Watchdog_Insert+0x9d>
break;
if ( delta_interval < after->delta_interval ) {
10da70: 8b 4a 10 mov 0x10(%edx),%ecx
10da73: 39 c1 cmp %eax,%ecx
10da75: 77 29 ja 10daa0 <_Watchdog_Insert+0x98>
break;
}
delta_interval -= after->delta_interval;
_ISR_Flash( level );
10da77: ff 75 f0 pushl -0x10(%ebp)
10da7a: 9d popf
10da7b: fa cli
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
10da7c: 83 7b 08 01 cmpl $0x1,0x8(%ebx)
10da80: 74 d6 je 10da58 <_Watchdog_Insert+0x50>
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
10da82: 89 3d a4 65 12 00 mov %edi,0x1265a4
_Watchdog_Sync_count--;
10da88: a1 20 66 12 00 mov 0x126620,%eax
10da8d: 48 dec %eax
10da8e: a3 20 66 12 00 mov %eax,0x126620
_ISR_Enable( level );
10da93: ff 75 f0 pushl -0x10(%ebp)
10da96: 9d popf
}
10da97: 58 pop %eax
10da98: 5b pop %ebx
10da99: 5e pop %esi
10da9a: 5f pop %edi
10da9b: c9 leave
10da9c: c3 ret
10da9d: 8d 76 00 lea 0x0(%esi),%esi
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
break;
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
10daa0: 29 c1 sub %eax,%ecx
10daa2: 89 4a 10 mov %ecx,0x10(%edx)
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_ACTIVE;
10daa5: c7 43 08 02 00 00 00 movl $0x2,0x8(%ebx)
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
10daac: 89 43 10 mov %eax,0x10(%ebx)
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
10daaf: 8b 42 04 mov 0x4(%edx),%eax
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10dab2: 89 43 04 mov %eax,0x4(%ebx)
before_node = after_node->next;
10dab5: 8b 10 mov (%eax),%edx
after_node->next = the_node;
10dab7: 89 18 mov %ebx,(%eax)
the_node->next = before_node;
10dab9: 89 13 mov %edx,(%ebx)
before_node->previous = the_node;
10dabb: 89 5a 04 mov %ebx,0x4(%edx)
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
10dabe: a1 24 66 12 00 mov 0x126624,%eax
10dac3: 89 43 14 mov %eax,0x14(%ebx)
10dac6: eb ba jmp 10da82 <_Watchdog_Insert+0x7a>
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
10dac8: ff 75 f0 pushl -0x10(%ebp)
10dacb: 9d popf
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
10dacc: 58 pop %eax
10dacd: 5b pop %ebx
10dace: 5e pop %esi
10dacf: 5f pop %edi
10dad0: c9 leave
10dad1: c3 ret
10dad2: 66 90 xchg %ax,%ax
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
_Watchdog_Sync_level = insert_isr_nest_level;
10dad4: 89 3d a4 65 12 00 mov %edi,0x1265a4
goto restart;
10dada: e9 5d ff ff ff jmp 10da3c <_Watchdog_Insert+0x34>
0010db48 <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
10db48: 55 push %ebp
10db49: 89 e5 mov %esp,%ebp
10db4b: 56 push %esi
10db4c: 53 push %ebx
10db4d: 8b 55 08 mov 0x8(%ebp),%edx
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
10db50: 9c pushf
10db51: fa cli
10db52: 59 pop %ecx
previous_state = the_watchdog->state;
10db53: 8b 42 08 mov 0x8(%edx),%eax
switch ( previous_state ) {
10db56: 83 f8 01 cmp $0x1,%eax
10db59: 74 4d je 10dba8 <_Watchdog_Remove+0x60>
10db5b: 73 0f jae 10db6c <_Watchdog_Remove+0x24>
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
10db5d: 8b 1d 24 66 12 00 mov 0x126624,%ebx
10db63: 89 5a 18 mov %ebx,0x18(%edx)
_ISR_Enable( level );
10db66: 51 push %ecx
10db67: 9d popf
return( previous_state );
}
10db68: 5b pop %ebx
10db69: 5e pop %esi
10db6a: c9 leave
10db6b: c3 ret
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
previous_state = the_watchdog->state;
switch ( previous_state ) {
10db6c: 83 f8 03 cmp $0x3,%eax
10db6f: 77 ec ja 10db5d <_Watchdog_Remove+0x15> <== NEVER TAKEN
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
10db71: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
_ISR_Enable( level );
return( previous_state );
}
10db78: 8b 1a mov (%edx),%ebx
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
10db7a: 8b 33 mov (%ebx),%esi
10db7c: 85 f6 test %esi,%esi
10db7e: 74 06 je 10db86 <_Watchdog_Remove+0x3e>
next_watchdog->delta_interval += the_watchdog->delta_interval;
10db80: 8b 72 10 mov 0x10(%edx),%esi
10db83: 01 73 10 add %esi,0x10(%ebx)
if ( _Watchdog_Sync_count )
10db86: 8b 35 20 66 12 00 mov 0x126620,%esi
10db8c: 85 f6 test %esi,%esi
10db8e: 74 0c je 10db9c <_Watchdog_Remove+0x54>
_Watchdog_Sync_level = _ISR_Nest_level;
10db90: 8b 35 74 67 12 00 mov 0x126774,%esi
10db96: 89 35 a4 65 12 00 mov %esi,0x1265a4
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
10db9c: 8b 72 04 mov 0x4(%edx),%esi
next->previous = previous;
10db9f: 89 73 04 mov %esi,0x4(%ebx)
previous->next = next;
10dba2: 89 1e mov %ebx,(%esi)
10dba4: eb b7 jmp 10db5d <_Watchdog_Remove+0x15>
10dba6: 66 90 xchg %ax,%ax
/*
* It is not actually on the chain so just change the state and
* the Insert operation we interrupted will be aborted.
*/
the_watchdog->state = WATCHDOG_INACTIVE;
10dba8: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
break;
10dbaf: eb ac jmp 10db5d <_Watchdog_Remove+0x15>
0010ee6c <_Watchdog_Report>:
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
10ee6c: 55 push %ebp
10ee6d: 89 e5 mov %esp,%ebp
10ee6f: 57 push %edi
10ee70: 56 push %esi
10ee71: 53 push %ebx
10ee72: 83 ec 2c sub $0x2c,%esp
10ee75: 8b 55 08 mov 0x8(%ebp),%edx
10ee78: 8b 45 0c mov 0xc(%ebp),%eax
printk(
10ee7b: 8b 78 24 mov 0x24(%eax),%edi
10ee7e: 8b 70 20 mov 0x20(%eax),%esi
10ee81: 8b 58 1c mov 0x1c(%eax),%ebx
10ee84: 8b 48 0c mov 0xc(%eax),%ecx
10ee87: 89 4d d4 mov %ecx,-0x2c(%ebp)
10ee8a: 8b 48 10 mov 0x10(%eax),%ecx
10ee8d: 89 4d e4 mov %ecx,-0x1c(%ebp)
10ee90: 85 d2 test %edx,%edx
10ee92: 74 2c je 10eec0 <_Watchdog_Report+0x54>
10ee94: b9 e3 19 12 00 mov $0x1219e3,%ecx
10ee99: 83 ec 0c sub $0xc,%esp
10ee9c: 57 push %edi
10ee9d: 56 push %esi
10ee9e: 53 push %ebx
10ee9f: 50 push %eax
10eea0: ff 75 d4 pushl -0x2c(%ebp)
10eea3: ff 75 e4 pushl -0x1c(%ebp)
10eea6: 51 push %ecx
10eea7: 52 push %edx
10eea8: 68 36 24 12 00 push $0x122436
10eead: e8 7e a1 ff ff call 109030 <printk>
10eeb2: 83 c4 30 add $0x30,%esp
watch,
watch->routine,
watch->id,
watch->user_data
);
}
10eeb5: 8d 65 f4 lea -0xc(%ebp),%esp
10eeb8: 5b pop %ebx
10eeb9: 5e pop %esi
10eeba: 5f pop %edi
10eebb: c9 leave
10eebc: c3 ret
10eebd: 8d 76 00 lea 0x0(%esi),%esi
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
printk(
10eec0: b9 a9 22 12 00 mov $0x1222a9,%ecx
10eec5: 89 ca mov %ecx,%edx
10eec7: eb d0 jmp 10ee99 <_Watchdog_Report+0x2d>
0010edfc <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
10edfc: 55 push %ebp
10edfd: 89 e5 mov %esp,%ebp
10edff: 57 push %edi
10ee00: 56 push %esi
10ee01: 53 push %ebx
10ee02: 83 ec 20 sub $0x20,%esp
10ee05: 8b 7d 08 mov 0x8(%ebp),%edi
10ee08: 8b 75 0c mov 0xc(%ebp),%esi
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
10ee0b: 9c pushf
10ee0c: fa cli
10ee0d: 8f 45 e4 popl -0x1c(%ebp)
printk( "Watchdog Chain: %s %p\n", name, header );
10ee10: 56 push %esi
10ee11: 57 push %edi
10ee12: 68 00 24 12 00 push $0x122400
10ee17: e8 14 a2 ff ff call 109030 <printk>
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
10ee1c: 8b 1e mov (%esi),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10ee1e: 83 c6 04 add $0x4,%esi
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
10ee21: 83 c4 10 add $0x10,%esp
10ee24: 39 f3 cmp %esi,%ebx
10ee26: 74 31 je 10ee59 <_Watchdog_Report_chain+0x5d>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
10ee28: 83 ec 08 sub $0x8,%esp
10ee2b: 53 push %ebx
10ee2c: 6a 00 push $0x0
10ee2e: e8 39 00 00 00 call 10ee6c <_Watchdog_Report>
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
node != _Chain_Tail(header) ;
node = node->next )
10ee33: 8b 1b mov (%ebx),%ebx
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
10ee35: 83 c4 10 add $0x10,%esp
10ee38: 39 f3 cmp %esi,%ebx
10ee3a: 75 ec jne 10ee28 <_Watchdog_Report_chain+0x2c><== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
10ee3c: 83 ec 08 sub $0x8,%esp
10ee3f: 57 push %edi
10ee40: 68 17 24 12 00 push $0x122417
10ee45: e8 e6 a1 ff ff call 109030 <printk>
10ee4a: 83 c4 10 add $0x10,%esp
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
10ee4d: ff 75 e4 pushl -0x1c(%ebp)
10ee50: 9d popf
}
10ee51: 8d 65 f4 lea -0xc(%ebp),%esp
10ee54: 5b pop %ebx
10ee55: 5e pop %esi
10ee56: 5f pop %edi
10ee57: c9 leave
10ee58: c3 ret
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
10ee59: 83 ec 0c sub $0xc,%esp
10ee5c: 68 26 24 12 00 push $0x122426
10ee61: e8 ca a1 ff ff call 109030 <printk>
10ee66: 83 c4 10 add $0x10,%esp
10ee69: eb e2 jmp 10ee4d <_Watchdog_Report_chain+0x51>
0010dbb4 <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
10dbb4: 55 push %ebp
10dbb5: 89 e5 mov %esp,%ebp
10dbb7: 57 push %edi
10dbb8: 56 push %esi
10dbb9: 53 push %ebx
10dbba: 83 ec 1c sub $0x1c,%esp
10dbbd: 8b 7d 08 mov 0x8(%ebp),%edi
* See the comment in watchdoginsert.c and watchdogadjust.c
* about why it's safe not to declare header a pointer to
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
10dbc0: 9c pushf
10dbc1: fa cli
10dbc2: 5e pop %esi
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
10dbc3: 8b 1f mov (%edi),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10dbc5: 8d 47 04 lea 0x4(%edi),%eax
10dbc8: 89 45 e4 mov %eax,-0x1c(%ebp)
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
10dbcb: 39 c3 cmp %eax,%ebx
10dbcd: 74 11 je 10dbe0 <_Watchdog_Tickle+0x2c>
* to be inserted has already had its delta_interval adjusted to 0, and
* so is added to the head of the chain with a delta_interval of 0.
*
* Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc)
*/
if (the_watchdog->delta_interval != 0) {
10dbcf: 8b 43 10 mov 0x10(%ebx),%eax
10dbd2: 85 c0 test %eax,%eax
10dbd4: 74 34 je 10dc0a <_Watchdog_Tickle+0x56>
the_watchdog->delta_interval--;
10dbd6: 48 dec %eax
10dbd7: 89 43 10 mov %eax,0x10(%ebx)
if ( the_watchdog->delta_interval != 0 )
10dbda: 85 c0 test %eax,%eax
10dbdc: 74 2c je 10dc0a <_Watchdog_Tickle+0x56>
10dbde: 66 90 xchg %ax,%ax
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
10dbe0: 56 push %esi
10dbe1: 9d popf
}
10dbe2: 8d 65 f4 lea -0xc(%ebp),%esp
10dbe5: 5b pop %ebx
10dbe6: 5e pop %esi
10dbe7: 5f pop %edi
10dbe8: c9 leave
10dbe9: c3 ret
_ISR_Enable( level );
switch( watchdog_state ) {
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
10dbea: 83 ec 08 sub $0x8,%esp
10dbed: ff 73 24 pushl 0x24(%ebx)
10dbf0: ff 73 20 pushl 0x20(%ebx)
10dbf3: ff 53 1c call *0x1c(%ebx)
the_watchdog->id,
the_watchdog->user_data
);
break;
10dbf6: 83 c4 10 add $0x10,%esp
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
10dbf9: 9c pushf
10dbfa: fa cli
10dbfb: 5e pop %esi
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
10dbfc: 8b 1f mov (%edi),%ebx
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
10dbfe: 3b 5d e4 cmp -0x1c(%ebp),%ebx
10dc01: 74 dd je 10dbe0 <_Watchdog_Tickle+0x2c>
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
10dc03: 8b 43 10 mov 0x10(%ebx),%eax
10dc06: 85 c0 test %eax,%eax
10dc08: 75 d6 jne 10dbe0 <_Watchdog_Tickle+0x2c>
if ( the_watchdog->delta_interval != 0 )
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
10dc0a: 83 ec 0c sub $0xc,%esp
10dc0d: 53 push %ebx
10dc0e: e8 35 ff ff ff call 10db48 <_Watchdog_Remove>
_ISR_Enable( level );
10dc13: 56 push %esi
10dc14: 9d popf
switch( watchdog_state ) {
10dc15: 83 c4 10 add $0x10,%esp
10dc18: 83 f8 02 cmp $0x2,%eax
10dc1b: 75 dc jne 10dbf9 <_Watchdog_Tickle+0x45> <== NEVER TAKEN
10dc1d: eb cb jmp 10dbea <_Watchdog_Tickle+0x36>
0010dc20 <_Workspace_Handler_initialization>:
/*
* _Workspace_Handler_initialization
*/
void _Workspace_Handler_initialization(void)
{
10dc20: 55 push %ebp
10dc21: 89 e5 mov %esp,%ebp
10dc23: 57 push %edi
10dc24: 53 push %ebx
uintptr_t memory_available = 0;
void *starting_address = Configuration.work_space_start;
10dc25: 8b 1d 00 23 12 00 mov 0x122300,%ebx
uintptr_t size = Configuration.work_space_size;
10dc2b: 8b 15 04 23 12 00 mov 0x122304,%edx
if ( Configuration.do_zero_of_workspace )
10dc31: 80 3d 28 23 12 00 00 cmpb $0x0,0x122328
10dc38: 75 1e jne 10dc58 <_Workspace_Handler_initialization+0x38>
memset( starting_address, 0, size );
memory_available = _Heap_Initialize(
10dc3a: 6a 04 push $0x4
10dc3c: 52 push %edx
10dc3d: 53 push %ebx
10dc3e: 68 20 65 12 00 push $0x126520
10dc43: e8 18 de ff ff call 10ba60 <_Heap_Initialize>
starting_address,
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
10dc48: 83 c4 10 add $0x10,%esp
10dc4b: 85 c0 test %eax,%eax
10dc4d: 74 13 je 10dc62 <_Workspace_Handler_initialization+0x42>
_Internal_error_Occurred(
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_TOO_LITTLE_WORKSPACE
);
}
10dc4f: 8d 65 f8 lea -0x8(%ebp),%esp
10dc52: 5b pop %ebx
10dc53: 5f pop %edi
10dc54: c9 leave
10dc55: c3 ret
10dc56: 66 90 xchg %ax,%ax
uintptr_t memory_available = 0;
void *starting_address = Configuration.work_space_start;
uintptr_t size = Configuration.work_space_size;
if ( Configuration.do_zero_of_workspace )
memset( starting_address, 0, size );
10dc58: 31 c0 xor %eax,%eax
10dc5a: 89 df mov %ebx,%edi
10dc5c: 89 d1 mov %edx,%ecx
10dc5e: f3 aa rep stos %al,%es:(%edi)
10dc60: eb d8 jmp 10dc3a <_Workspace_Handler_initialization+0x1a>
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
_Internal_error_Occurred(
10dc62: 50 push %eax
10dc63: 6a 02 push $0x2
10dc65: 6a 01 push $0x1
10dc67: 6a 00 push $0x0
10dc69: e8 fa df ff ff call 10bc68 <_Internal_error_Occurred>
001231e8 <__kill>:
#endif
int __kill( pid_t pid, int sig )
{
1231e8: 55 push %ebp <== NOT EXECUTED
1231e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return 0;
}
1231eb: 31 c0 xor %eax,%eax <== NOT EXECUTED
1231ed: c9 leave <== NOT EXECUTED
1231ee: c3 ret <== NOT EXECUTED
00107724 <_gettimeofday>:
int _gettimeofday(
struct timeval *tp,
struct timezone *tzp
)
{
107724: 55 push %ebp <== NOT EXECUTED
107725: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107727: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
return gettimeofday( tp, tzp );
}
10772a: c9 leave <== NOT EXECUTED
int _gettimeofday(
struct timeval *tp,
struct timezone *tzp
)
{
return gettimeofday( tp, tzp );
10772b: e9 80 ff ff ff jmp 1076b0 <gettimeofday> <== NOT EXECUTED
0010ba44 <_rename_r>:
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
10ba44: 55 push %ebp
10ba45: 89 e5 mov %esp,%ebp
10ba47: 57 push %edi
10ba48: 56 push %esi
10ba49: 53 push %ebx
10ba4a: 83 ec 78 sub $0x78,%esp
10ba4d: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Get the parent node of the old path to be renamed. Find the parent path.
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
10ba50: 53 push %ebx
10ba51: e8 2a ea ff ff call 10a480 <rtems_filesystem_dirname>
if ( old_parent_pathlen == 0 )
10ba56: 83 c4 10 add $0x10,%esp
10ba59: 85 c0 test %eax,%eax
10ba5b: 0f 85 57 01 00 00 jne 10bbb8 <_rename_r+0x174>
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
10ba61: 52 push %edx
10ba62: 8d 45 b8 lea -0x48(%ebp),%eax
10ba65: 89 45 94 mov %eax,-0x6c(%ebp)
10ba68: 50 push %eax
10ba69: 8d 45 e4 lea -0x1c(%ebp),%eax
10ba6c: 50 push %eax
10ba6d: 53 push %ebx
10ba6e: e8 e1 03 00 00 call 10be54 <rtems_filesystem_get_start_loc>
10ba73: 83 c4 10 add $0x10,%esp
10ba76: 31 d2 xor %edx,%edx
rtems_filesystem_location_info_t old_parent_loc;
rtems_filesystem_location_info_t new_parent_loc;
int i;
int result;
const char *name;
bool free_old_parentloc = false;
10ba78: c6 45 93 00 movb $0x0,-0x6d(%ebp)
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
10ba7c: 8d 7d cc lea -0x34(%ebp),%edi
10ba7f: b9 05 00 00 00 mov $0x5,%ecx
10ba84: 8b 75 94 mov -0x6c(%ebp),%esi
10ba87: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
name = old + old_parent_pathlen;
10ba89: 01 d3 add %edx,%ebx
10ba8b: 89 5d e0 mov %ebx,-0x20(%ebp)
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
10ba8e: be ff ff ff ff mov $0xffffffff,%esi
10ba93: 89 f1 mov %esi,%ecx
10ba95: 89 df mov %ebx,%edi
10ba97: 31 c0 xor %eax,%eax
10ba99: f2 ae repnz scas %es:(%edi),%al
10ba9b: f7 d1 not %ecx
10ba9d: 49 dec %ecx
10ba9e: 83 ec 08 sub $0x8,%esp
10baa1: 51 push %ecx
10baa2: 53 push %ebx
10baa3: e8 1c ea ff ff call 10a4c4 <rtems_filesystem_prefix_separators>
10baa8: 01 c3 add %eax,%ebx
10baaa: 89 5d e0 mov %ebx,-0x20(%ebp)
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
10baad: 89 f1 mov %esi,%ecx
10baaf: 89 df mov %ebx,%edi
10bab1: 31 c0 xor %eax,%eax
10bab3: f2 ae repnz scas %es:(%edi),%al
10bab5: f7 d1 not %ecx
10bab7: 49 dec %ecx
10bab8: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10babf: 8d 75 cc lea -0x34(%ebp),%esi
10bac2: 56 push %esi
10bac3: 6a 00 push $0x0
10bac5: 51 push %ecx
10bac6: 53 push %ebx
10bac7: e8 08 e9 ff ff call 10a3d4 <rtems_filesystem_evaluate_relative_path>
0, &old_loc, false );
if ( result != 0 ) {
10bacc: 83 c4 20 add $0x20,%esp
10bacf: 85 c0 test %eax,%eax
10bad1: 0f 85 c9 00 00 00 jne 10bba0 <_rename_r+0x15c>
/*
* Get the parent of the new node we are renaming to.
*/
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
10bad7: 50 push %eax
10bad8: 8d 5d a4 lea -0x5c(%ebp),%ebx
10badb: 53 push %ebx
10badc: 8d 45 e4 lea -0x1c(%ebp),%eax
10badf: 50 push %eax
10bae0: ff 75 10 pushl 0x10(%ebp)
10bae3: e8 6c 03 00 00 call 10be54 <rtems_filesystem_get_start_loc>
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
10bae8: 83 c4 0c add $0xc,%esp
10baeb: 8d 45 e0 lea -0x20(%ebp),%eax
10baee: 50 push %eax
10baef: 53 push %ebx
10baf0: 8b 45 10 mov 0x10(%ebp),%eax
10baf3: 03 45 e4 add -0x1c(%ebp),%eax
10baf6: 50 push %eax
10baf7: 8b 45 b0 mov -0x50(%ebp),%eax
10bafa: ff 50 04 call *0x4(%eax)
if ( result != 0 ) {
10bafd: 83 c4 10 add $0x10,%esp
10bb00: 85 c0 test %eax,%eax
10bb02: 0f 85 e0 00 00 00 jne 10bbe8 <_rename_r+0x1a4>
/*
* Check to see if the caller is trying to rename across file system
* boundaries.
*/
if ( old_parent_loc.mt_entry != new_parent_loc.mt_entry ) {
10bb08: 8b 45 b4 mov -0x4c(%ebp),%eax
10bb0b: 39 45 c8 cmp %eax,-0x38(%ebp)
10bb0e: 75 48 jne 10bb58 <_rename_r+0x114>
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
rtems_set_errno_and_return_minus_one( EXDEV );
}
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
10bb10: ff 75 e0 pushl -0x20(%ebp)
10bb13: 53 push %ebx
10bb14: 56 push %esi
10bb15: ff 75 94 pushl -0x6c(%ebp)
10bb18: 8b 45 b0 mov -0x50(%ebp),%eax
10bb1b: ff 50 40 call *0x40(%eax)
10bb1e: 89 c7 mov %eax,%edi
rtems_filesystem_freenode( &new_parent_loc );
10bb20: 89 1c 24 mov %ebx,(%esp)
10bb23: e8 c8 eb ff ff call 10a6f0 <rtems_filesystem_freenode>
if ( free_old_parentloc )
10bb28: 83 c4 10 add $0x10,%esp
10bb2b: 80 7d 93 00 cmpb $0x0,-0x6d(%ebp)
10bb2f: 75 17 jne 10bb48 <_rename_r+0x104>
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
10bb31: 83 ec 0c sub $0xc,%esp
10bb34: 56 push %esi
10bb35: e8 b6 eb ff ff call 10a6f0 <rtems_filesystem_freenode>
return result;
10bb3a: 83 c4 10 add $0x10,%esp
}
10bb3d: 89 f8 mov %edi,%eax
10bb3f: 8d 65 f4 lea -0xc(%ebp),%esp
10bb42: 5b pop %ebx
10bb43: 5e pop %esi
10bb44: 5f pop %edi
10bb45: c9 leave
10bb46: c3 ret
10bb47: 90 nop
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
rtems_filesystem_freenode( &new_parent_loc );
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
10bb48: 83 ec 0c sub $0xc,%esp
10bb4b: ff 75 94 pushl -0x6c(%ebp)
10bb4e: e8 9d eb ff ff call 10a6f0 <rtems_filesystem_freenode>
10bb53: 83 c4 10 add $0x10,%esp
10bb56: eb d9 jmp 10bb31 <_rename_r+0xed>
* Check to see if the caller is trying to rename across file system
* boundaries.
*/
if ( old_parent_loc.mt_entry != new_parent_loc.mt_entry ) {
rtems_filesystem_freenode( &new_parent_loc );
10bb58: 83 ec 0c sub $0xc,%esp
10bb5b: 53 push %ebx
10bb5c: e8 8f eb ff ff call 10a6f0 <rtems_filesystem_freenode>
if ( free_old_parentloc )
10bb61: 83 c4 10 add $0x10,%esp
10bb64: 80 7d 93 00 cmpb $0x0,-0x6d(%ebp)
10bb68: 74 0e je 10bb78 <_rename_r+0x134>
rtems_filesystem_freenode( &old_parent_loc );
10bb6a: 83 ec 0c sub $0xc,%esp
10bb6d: ff 75 94 pushl -0x6c(%ebp)
10bb70: e8 7b eb ff ff call 10a6f0 <rtems_filesystem_freenode>
10bb75: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( &old_loc );
10bb78: 83 ec 0c sub $0xc,%esp
10bb7b: 56 push %esi
10bb7c: e8 6f eb ff ff call 10a6f0 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EXDEV );
10bb81: e8 d2 9d 00 00 call 115958 <__errno>
10bb86: c7 00 12 00 00 00 movl $0x12,(%eax)
10bb8c: 83 c4 10 add $0x10,%esp
10bb8f: bf ff ff ff ff mov $0xffffffff,%edi
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
return result;
}
10bb94: 89 f8 mov %edi,%eax
10bb96: 8d 65 f4 lea -0xc(%ebp),%esp
10bb99: 5b pop %ebx
10bb9a: 5e pop %esi
10bb9b: 5f pop %edi
10bb9c: c9 leave
10bb9d: c3 ret
10bb9e: 66 90 xchg %ax,%ax
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &old_loc, false );
if ( result != 0 ) {
if ( free_old_parentloc )
10bba0: 80 7d 93 00 cmpb $0x0,-0x6d(%ebp)
10bba4: 75 78 jne 10bc1e <_rename_r+0x1da> <== ALWAYS TAKEN
rtems_filesystem_freenode( &old_parent_loc );
return -1;
10bba6: bf ff ff ff ff mov $0xffffffff,%edi <== NOT EXECUTED
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
return result;
}
10bbab: 89 f8 mov %edi,%eax <== NOT EXECUTED
10bbad: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10bbb0: 5b pop %ebx <== NOT EXECUTED
10bbb1: 5e pop %esi <== NOT EXECUTED
10bbb2: 5f pop %edi <== NOT EXECUTED
10bbb3: c9 leave <== NOT EXECUTED
10bbb4: c3 ret <== NOT EXECUTED
10bbb5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
old_parent_pathlen = rtems_filesystem_dirname ( old );
if ( old_parent_pathlen == 0 )
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
else {
result = rtems_filesystem_evaluate_path( old, old_parent_pathlen,
10bbb8: 89 c2 mov %eax,%edx
10bbba: 83 ec 0c sub $0xc,%esp
10bbbd: 6a 00 push $0x0
10bbbf: 8d 45 b8 lea -0x48(%ebp),%eax
10bbc2: 89 45 94 mov %eax,-0x6c(%ebp)
10bbc5: 50 push %eax
10bbc6: 6a 02 push $0x2
10bbc8: 52 push %edx
10bbc9: 53 push %ebx
10bbca: 89 55 8c mov %edx,-0x74(%ebp)
10bbcd: e8 6a e8 ff ff call 10a43c <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
10bbd2: 83 c4 20 add $0x20,%esp
10bbd5: 85 c0 test %eax,%eax
10bbd7: 8b 55 8c mov -0x74(%ebp),%edx
10bbda: 75 ca jne 10bba6 <_rename_r+0x162> <== NEVER TAKEN
return -1;
free_old_parentloc = true;
10bbdc: c6 45 93 01 movb $0x1,-0x6d(%ebp)
10bbe0: e9 97 fe ff ff jmp 10ba7c <_rename_r+0x38>
10bbe5: 8d 76 00 lea 0x0(%esi),%esi
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
if ( result != 0 ) {
rtems_filesystem_freenode( &new_parent_loc );
10bbe8: 83 ec 0c sub $0xc,%esp
10bbeb: 53 push %ebx
10bbec: e8 ff ea ff ff call 10a6f0 <rtems_filesystem_freenode>
if ( free_old_parentloc )
10bbf1: 83 c4 10 add $0x10,%esp
10bbf4: 80 7d 93 00 cmpb $0x0,-0x6d(%ebp)
10bbf8: 74 0e je 10bc08 <_rename_r+0x1c4> <== NEVER TAKEN
rtems_filesystem_freenode( &old_parent_loc );
10bbfa: 83 ec 0c sub $0xc,%esp
10bbfd: ff 75 94 pushl -0x6c(%ebp)
10bc00: e8 eb ea ff ff call 10a6f0 <rtems_filesystem_freenode>
10bc05: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( &old_loc );
10bc08: 83 ec 0c sub $0xc,%esp
10bc0b: 56 push %esi
10bc0c: e8 df ea ff ff call 10a6f0 <rtems_filesystem_freenode>
return -1;
10bc11: 83 c4 10 add $0x10,%esp
10bc14: bf ff ff ff ff mov $0xffffffff,%edi
10bc19: e9 1f ff ff ff jmp 10bb3d <_rename_r+0xf9>
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &old_loc, false );
if ( result != 0 ) {
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
10bc1e: 83 ec 0c sub $0xc,%esp
10bc21: ff 75 94 pushl -0x6c(%ebp)
10bc24: e8 c7 ea ff ff call 10a6f0 <rtems_filesystem_freenode>
10bc29: 83 c4 10 add $0x10,%esp
return -1;
10bc2c: bf ff ff ff ff mov $0xffffffff,%edi
10bc31: e9 07 ff ff ff jmp 10bb3d <_rename_r+0xf9>
0010a314 <_times>:
#endif
clock_t _times(
struct tms *ptms
)
{
10a314: 55 push %ebp
10a315: 89 e5 mov %esp,%ebp
10a317: 56 push %esi
10a318: 53 push %ebx
10a319: 83 ec 10 sub $0x10,%esp
10a31c: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_interval ticks;
if ( !ptms )
10a31f: 85 db test %ebx,%ebx
10a321: 74 75 je 10a398 <_times+0x84>
/*
* This call does not depend on TOD being initialized and can't fail.
*/
ticks = rtems_clock_get_ticks_since_boot();
10a323: e8 84 04 00 00 call 10a7ac <rtems_clock_get_ticks_since_boot>
10a328: 89 c6 mov %eax,%esi
{
Timestamp_Control per_tick;
uint32_t ticks;
uint32_t fractional_ticks;
_Timestamp_Set(
10a32a: 8b 0d ac 25 12 00 mov 0x1225ac,%ecx
10a330: ba 83 de 1b 43 mov $0x431bde83,%edx
10a335: 89 c8 mov %ecx,%eax
10a337: f7 e2 mul %edx
10a339: c1 ea 12 shr $0x12,%edx
10a33c: 89 55 e8 mov %edx,-0x18(%ebp)
10a33f: 8d 04 89 lea (%ecx,%ecx,4),%eax
10a342: 8d 04 80 lea (%eax,%eax,4),%eax
10a345: 8d 04 80 lea (%eax,%eax,4),%eax
10a348: c1 e0 03 shl $0x3,%eax
10a34b: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx
10a350: 31 d2 xor %edx,%edx
10a352: f7 f1 div %ecx
10a354: 89 55 ec mov %edx,-0x14(%ebp)
TOD_MICROSECONDS_PER_SECOND,
(rtems_configuration_get_nanoseconds_per_tick() %
TOD_NANOSECONDS_PER_SECOND)
);
_Timestamp_Divide(
10a357: 8d 45 f0 lea -0x10(%ebp),%eax
10a35a: 50 push %eax
10a35b: 8d 45 f4 lea -0xc(%ebp),%eax
10a35e: 50 push %eax
10a35f: 8d 45 e8 lea -0x18(%ebp),%eax
10a362: 50 push %eax
10a363: a1 18 6a 12 00 mov 0x126a18,%eax
10a368: 05 84 00 00 00 add $0x84,%eax
10a36d: 50 push %eax
10a36e: e8 51 35 00 00 call 10d8c4 <_Timespec_Divide>
&_Thread_Executing->cpu_time_used,
&per_tick,
&ticks,
&fractional_ticks
);
ptms->tms_utime = ticks;
10a373: 8b 45 f4 mov -0xc(%ebp),%eax
10a376: 89 03 mov %eax,(%ebx)
}
#else
ptms->tms_utime = _Thread_Executing->cpu_time_used;
#endif
ptms->tms_stime = ticks;
10a378: 89 73 04 mov %esi,0x4(%ebx)
ptms->tms_cutime = 0;
10a37b: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
ptms->tms_cstime = 0;
10a382: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
return ticks;
10a389: 83 c4 10 add $0x10,%esp
10a38c: 89 f0 mov %esi,%eax
}
10a38e: 8d 65 f8 lea -0x8(%ebp),%esp
10a391: 5b pop %ebx
10a392: 5e pop %esi
10a393: c9 leave
10a394: c3 ret
10a395: 8d 76 00 lea 0x0(%esi),%esi
)
{
rtems_interval ticks;
if ( !ptms )
rtems_set_errno_and_return_minus_one( EFAULT );
10a398: e8 9f 7c 00 00 call 11203c <__errno>
10a39d: c7 00 0e 00 00 00 movl $0xe,(%eax)
10a3a3: b8 ff ff ff ff mov $0xffffffff,%eax
ptms->tms_stime = ticks;
ptms->tms_cutime = 0;
ptms->tms_cstime = 0;
return ticks;
}
10a3a8: 8d 65 f8 lea -0x8(%ebp),%esp
10a3ab: 5b pop %ebx
10a3ac: 5e pop %esi
10a3ad: c9 leave
10a3ae: c3 ret
001090ac <access>:
int access(
const char *path,
int amode
)
{
1090ac: 55 push %ebp
1090ad: 89 e5 mov %esp,%ebp
1090af: 53 push %ebx
1090b0: 83 ec 5c sub $0x5c,%esp
1090b3: 8b 5d 0c mov 0xc(%ebp),%ebx
struct stat statbuf;
if ( stat(path, &statbuf) )
1090b6: 8d 45 b0 lea -0x50(%ebp),%eax
1090b9: 50 push %eax
1090ba: ff 75 08 pushl 0x8(%ebp)
1090bd: e8 6a 17 00 00 call 10a82c <stat>
1090c2: 83 c4 10 add $0x10,%esp
1090c5: 85 c0 test %eax,%eax
1090c7: 75 1f jne 1090e8 <access+0x3c>
return -1;
if ( amode & R_OK ) {
1090c9: f6 c3 04 test $0x4,%bl
1090cc: 75 26 jne 1090f4 <access+0x48>
if (!( statbuf.st_mode & S_IREAD ))
return -1;
}
if ( amode & W_OK ) {
1090ce: f6 c3 02 test $0x2,%bl
1090d1: 75 0d jne 1090e0 <access+0x34>
if ( !( statbuf.st_mode & S_IWRITE ) )
return -1;
}
if ( amode & X_OK ) {
1090d3: 83 e3 01 and $0x1,%ebx
1090d6: 75 24 jne 1090fc <access+0x50>
if ( !( statbuf.st_mode & S_IEXEC ) )
return -1;
}
return 0;
1090d8: 31 c0 xor %eax,%eax
}
1090da: 8b 5d fc mov -0x4(%ebp),%ebx
1090dd: c9 leave
1090de: c3 ret
1090df: 90 nop
if (!( statbuf.st_mode & S_IREAD ))
return -1;
}
if ( amode & W_OK ) {
if ( !( statbuf.st_mode & S_IWRITE ) )
1090e0: f6 45 bc 80 testb $0x80,-0x44(%ebp)
1090e4: 75 ed jne 1090d3 <access+0x27>
1090e6: 66 90 xchg %ax,%ax
return -1;
1090e8: b8 ff ff ff ff mov $0xffffffff,%eax
if ( !( statbuf.st_mode & S_IEXEC ) )
return -1;
}
return 0;
}
1090ed: 8b 5d fc mov -0x4(%ebp),%ebx
1090f0: c9 leave
1090f1: c3 ret
1090f2: 66 90 xchg %ax,%ax
if ( stat(path, &statbuf) )
return -1;
if ( amode & R_OK ) {
if (!( statbuf.st_mode & S_IREAD ))
1090f4: f6 45 bd 01 testb $0x1,-0x43(%ebp)
1090f8: 75 d4 jne 1090ce <access+0x22>
1090fa: eb ec jmp 1090e8 <access+0x3c>
if ( !( statbuf.st_mode & S_IWRITE ) )
return -1;
}
if ( amode & X_OK ) {
if ( !( statbuf.st_mode & S_IEXEC ) )
1090fc: 8b 45 bc mov -0x44(%ebp),%eax
1090ff: 83 e0 40 and $0x40,%eax
return -1;
}
return 0;
109102: 83 f8 01 cmp $0x1,%eax
109105: 19 c0 sbb %eax,%eax
109107: eb d1 jmp 1090da <access+0x2e>
00108870 <cfsetospeed>:
int cfsetospeed(
struct termios *tp,
speed_t speed
)
{
108870: 55 push %ebp
108871: 89 e5 mov %esp,%ebp
108873: 83 ec 08 sub $0x8,%esp
108876: 8b 4d 08 mov 0x8(%ebp),%ecx
108879: 8b 55 0c mov 0xc(%ebp),%edx
if ( speed & ~CBAUD )
10887c: f7 c2 f0 ef ff ff test $0xffffeff0,%edx
108882: 75 14 jne 108898 <cfsetospeed+0x28>
rtems_set_errno_and_return_minus_one( EINVAL );
tp->c_cflag = (tp->c_cflag & ~CBAUD) | speed;
108884: 8b 41 08 mov 0x8(%ecx),%eax
108887: 25 f0 ef ff ff and $0xffffeff0,%eax
10888c: 09 d0 or %edx,%eax
10888e: 89 41 08 mov %eax,0x8(%ecx)
return 0;
108891: 31 c0 xor %eax,%eax
}
108893: c9 leave
108894: c3 ret
108895: 8d 76 00 lea 0x0(%esi),%esi
struct termios *tp,
speed_t speed
)
{
if ( speed & ~CBAUD )
rtems_set_errno_and_return_minus_one( EINVAL );
108898: e8 f3 af 00 00 call 113890 <__errno>
10889d: c7 00 16 00 00 00 movl $0x16,(%eax)
1088a3: b8 ff ff ff ff mov $0xffffffff,%eax
tp->c_cflag = (tp->c_cflag & ~CBAUD) | speed;
return 0;
}
1088a8: c9 leave
1088a9: c3 ret
0010fa90 <chdir>:
#include <rtems/seterr.h>
int chdir(
const char *pathname
)
{
10fa90: 55 push %ebp
10fa91: 89 e5 mov %esp,%ebp
10fa93: 57 push %edi
10fa94: 56 push %esi
10fa95: 83 ec 20 sub $0x20,%esp
10fa98: 8b 55 08 mov 0x8(%ebp),%edx
rtems_filesystem_location_info_t loc;
int result;
if ( !pathname )
10fa9b: 85 d2 test %edx,%edx
10fa9d: 74 75 je 10fb14 <chdir+0x84>
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Get the node where we wish to go.
*/
result = rtems_filesystem_evaluate_path(
10fa9f: 31 c0 xor %eax,%eax
10faa1: b9 ff ff ff ff mov $0xffffffff,%ecx
10faa6: 89 d7 mov %edx,%edi
10faa8: f2 ae repnz scas %es:(%edi),%al
10faaa: f7 d1 not %ecx
10faac: 49 dec %ecx
10faad: 83 ec 0c sub $0xc,%esp
10fab0: 6a 01 push $0x1
10fab2: 8d 75 e4 lea -0x1c(%ebp),%esi
10fab5: 56 push %esi
10fab6: 6a 01 push $0x1
10fab8: 51 push %ecx
10fab9: 52 push %edx
10faba: e8 c9 7e ff ff call 107988 <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), RTEMS_LIBIO_PERMS_SEARCH, &loc, true );
if ( result != 0 )
10fabf: 83 c4 20 add $0x20,%esp
10fac2: 85 c0 test %eax,%eax
10fac4: 74 0e je 10fad4 <chdir+0x44>
return -1;
10fac6: b8 ff ff ff ff mov $0xffffffff,%eax
rtems_filesystem_freenode( &rtems_filesystem_current );
rtems_filesystem_current = loc;
return 0;
}
10facb: 8d 65 f8 lea -0x8(%ebp),%esp
10face: 5e pop %esi
10facf: 5f pop %edi
10fad0: c9 leave
10fad1: c3 ret
10fad2: 66 90 xchg %ax,%ax
return -1;
/*
* Verify you can change directory into this node.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
10fad4: 83 ec 0c sub $0xc,%esp
10fad7: 56 push %esi
10fad8: 8b 45 f0 mov -0x10(%ebp),%eax
10fadb: ff 50 10 call *0x10(%eax)
10fade: 83 c4 10 add $0x10,%esp
10fae1: 48 dec %eax
10fae2: 75 48 jne 10fb2c <chdir+0x9c>
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTDIR );
}
rtems_filesystem_freenode( &rtems_filesystem_current );
10fae4: 83 ec 0c sub $0xc,%esp
10fae7: a1 10 41 12 00 mov 0x124110,%eax
10faec: 83 c0 04 add $0x4,%eax
10faef: 50 push %eax
10faf0: e8 6b 7f ff ff call 107a60 <rtems_filesystem_freenode>
rtems_filesystem_current = loc;
10faf5: 8b 3d 10 41 12 00 mov 0x124110,%edi
10fafb: 83 c7 04 add $0x4,%edi
10fafe: b9 05 00 00 00 mov $0x5,%ecx
10fb03: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return 0;
10fb05: 83 c4 10 add $0x10,%esp
10fb08: 31 c0 xor %eax,%eax
}
10fb0a: 8d 65 f8 lea -0x8(%ebp),%esp
10fb0d: 5e pop %esi
10fb0e: 5f pop %edi
10fb0f: c9 leave
10fb10: c3 ret
10fb11: 8d 76 00 lea 0x0(%esi),%esi
{
rtems_filesystem_location_info_t loc;
int result;
if ( !pathname )
rtems_set_errno_and_return_minus_one( EFAULT );
10fb14: e8 ef 2a 00 00 call 112608 <__errno>
10fb19: c7 00 0e 00 00 00 movl $0xe,(%eax)
10fb1f: b8 ff ff ff ff mov $0xffffffff,%eax
rtems_filesystem_freenode( &rtems_filesystem_current );
rtems_filesystem_current = loc;
return 0;
}
10fb24: 8d 65 f8 lea -0x8(%ebp),%esp
10fb27: 5e pop %esi
10fb28: 5f pop %edi
10fb29: c9 leave
10fb2a: c3 ret
10fb2b: 90 nop
/*
* Verify you can change directory into this node.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_filesystem_freenode( &loc );
10fb2c: 83 ec 0c sub $0xc,%esp
10fb2f: 56 push %esi
10fb30: e8 2b 7f ff ff call 107a60 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( ENOTDIR );
10fb35: e8 ce 2a 00 00 call 112608 <__errno>
10fb3a: c7 00 14 00 00 00 movl $0x14,(%eax)
10fb40: 83 c4 10 add $0x10,%esp
10fb43: b8 ff ff ff ff mov $0xffffffff,%eax
10fb48: eb 81 jmp 10facb <chdir+0x3b>
001077f0 <chroot>:
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
1077f0: 55 push %ebp
1077f1: 89 e5 mov %esp,%ebp
1077f3: 57 push %edi
1077f4: 56 push %esi
1077f5: 83 ec 20 sub $0x20,%esp
int result;
rtems_filesystem_location_info_t loc;
/* an automatic call to new private env the first time */
if (rtems_current_user_env == &rtems_global_user_env) {
1077f8: 81 3d 10 41 12 00 40 cmpl $0x126340,0x124110
1077ff: 63 12 00
107802: 74 60 je 107864 <chroot+0x74>
rtems_libio_set_private_env(); /* try to set a new private env*/
if (rtems_current_user_env == &rtems_global_user_env) /* not ok */
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = chdir(pathname);
107804: 83 ec 0c sub $0xc,%esp
107807: ff 75 08 pushl 0x8(%ebp)
10780a: e8 81 82 00 00 call 10fa90 <chdir>
if (result) {
10780f: 83 c4 10 add $0x10,%esp
107812: 85 c0 test %eax,%eax
107814: 75 72 jne 107888 <chroot+0x98>
rtems_set_errno_and_return_minus_one( errno );
}
/* clone the new root location */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
107816: 83 ec 0c sub $0xc,%esp
107819: 6a 00 push $0x0
10781b: 8d 75 e4 lea -0x1c(%ebp),%esi
10781e: 56 push %esi
10781f: 6a 00 push $0x0
107821: 6a 01 push $0x1
107823: 68 b6 0b 12 00 push $0x120bb6
107828: e8 5b 01 00 00 call 107988 <rtems_filesystem_evaluate_path>
10782d: 83 c4 20 add $0x20,%esp
107830: 85 c0 test %eax,%eax
107832: 75 54 jne 107888 <chroot+0x98> <== NEVER TAKEN
/* our cwd has changed, though - but there is no easy way of return :-( */
rtems_set_errno_and_return_minus_one( errno );
}
rtems_filesystem_freenode(&rtems_filesystem_root);
107834: 83 ec 0c sub $0xc,%esp
107837: a1 10 41 12 00 mov 0x124110,%eax
10783c: 83 c0 18 add $0x18,%eax
10783f: 50 push %eax
107840: e8 1b 02 00 00 call 107a60 <rtems_filesystem_freenode>
rtems_filesystem_root = loc;
107845: 8b 3d 10 41 12 00 mov 0x124110,%edi
10784b: 83 c7 18 add $0x18,%edi
10784e: b9 05 00 00 00 mov $0x5,%ecx
107853: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return 0;
107855: 83 c4 10 add $0x10,%esp
107858: 31 c0 xor %eax,%eax
}
10785a: 8d 65 f8 lea -0x8(%ebp),%esp
10785d: 5e pop %esi
10785e: 5f pop %edi
10785f: c9 leave
107860: c3 ret
107861: 8d 76 00 lea 0x0(%esi),%esi
int result;
rtems_filesystem_location_info_t loc;
/* an automatic call to new private env the first time */
if (rtems_current_user_env == &rtems_global_user_env) {
rtems_libio_set_private_env(); /* try to set a new private env*/
107864: e8 cf 12 00 00 call 108b38 <rtems_libio_set_private_env>
if (rtems_current_user_env == &rtems_global_user_env) /* not ok */
107869: 81 3d 10 41 12 00 40 cmpl $0x126340,0x124110
107870: 63 12 00
107873: 75 8f jne 107804 <chroot+0x14>
rtems_set_errno_and_return_minus_one( ENOTSUP );
107875: e8 8e ad 00 00 call 112608 <__errno>
10787a: c7 00 86 00 00 00 movl $0x86,(%eax)
107880: 83 c8 ff or $0xffffffff,%eax
107883: eb d5 jmp 10785a <chroot+0x6a>
107885: 8d 76 00 lea 0x0(%esi),%esi
}
/* clone the new root location */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
/* our cwd has changed, though - but there is no easy way of return :-( */
rtems_set_errno_and_return_minus_one( errno );
107888: e8 7b ad 00 00 call 112608 <__errno>
10788d: 89 c6 mov %eax,%esi
10788f: e8 74 ad 00 00 call 112608 <__errno>
107894: 8b 00 mov (%eax),%eax
107896: 89 06 mov %eax,(%esi)
107898: b8 ff ff ff ff mov $0xffffffff,%eax
10789d: eb bb jmp 10785a <chroot+0x6a>
0010f074 <close>:
#include <rtems/libio_.h>
int close(
int fd
)
{
10f074: 55 push %ebp
10f075: 89 e5 mov %esp,%ebp
10f077: 53 push %ebx
10f078: 83 ec 14 sub $0x14,%esp
10f07b: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_t *iop;
rtems_status_code rc;
rtems_libio_check_fd(fd);
10f07e: 3b 05 ec 21 12 00 cmp 0x1221ec,%eax
10f084: 73 46 jae 10f0cc <close+0x58>
iop = rtems_libio_iop(fd);
10f086: c1 e0 03 shl $0x3,%eax
10f089: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx
10f090: 29 c3 sub %eax,%ebx
10f092: 03 1d 80 63 12 00 add 0x126380,%ebx
rtems_libio_check_is_open(iop);
10f098: f6 43 15 01 testb $0x1,0x15(%ebx)
10f09c: 74 2e je 10f0cc <close+0x58>
rc = RTEMS_SUCCESSFUL;
rc = (*iop->pathinfo.handlers->close_h)( iop );
10f09e: 83 ec 0c sub $0xc,%esp
10f0a1: 8b 43 20 mov 0x20(%ebx),%eax
10f0a4: 53 push %ebx
10f0a5: ff 50 04 call *0x4(%eax)
rtems_filesystem_freenode( &iop->pathinfo );
10f0a8: 8d 53 18 lea 0x18(%ebx),%edx
10f0ab: 89 14 24 mov %edx,(%esp)
10f0ae: 89 45 f4 mov %eax,-0xc(%ebp)
10f0b1: e8 6a 85 ff ff call 107620 <rtems_filesystem_freenode>
rtems_libio_free( iop );
10f0b6: 89 1c 24 mov %ebx,(%esp)
10f0b9: e8 5a 02 00 00 call 10f318 <rtems_libio_free>
return rc;
10f0be: 83 c4 10 add $0x10,%esp
10f0c1: 8b 45 f4 mov -0xc(%ebp),%eax
}
10f0c4: 8b 5d fc mov -0x4(%ebp),%ebx
10f0c7: c9 leave
10f0c8: c3 ret
10f0c9: 8d 76 00 lea 0x0(%esi),%esi
rtems_libio_t *iop;
rtems_status_code rc;
rtems_libio_check_fd(fd);
iop = rtems_libio_iop(fd);
rtems_libio_check_is_open(iop);
10f0cc: e8 0b 2d 00 00 call 111ddc <__errno>
10f0d1: c7 00 09 00 00 00 movl $0x9,(%eax)
10f0d7: b8 ff ff ff ff mov $0xffffffff,%eax
10f0dc: eb e6 jmp 10f0c4 <close+0x50>
0010778c <ctermid>:
static char *ctermid_name = "/dev/console";
char *ctermid(
char *s
)
{
10778c: 55 push %ebp
10778d: 89 e5 mov %esp,%ebp
10778f: 57 push %edi
107790: 56 push %esi
107791: 8b 45 08 mov 0x8(%ebp),%eax
if ( !s )
107794: 85 c0 test %eax,%eax
107796: 74 14 je 1077ac <ctermid+0x20>
/*
* We have no way of knowing the length of the user provided buffer.
* It may not be large enough but there is no way to know that. :(
* So this is a potential buffer owerrun that we can do nothing about.
*/
strcpy( s, ctermid_name );
107798: be 43 ca 11 00 mov $0x11ca43,%esi
10779d: b9 0d 00 00 00 mov $0xd,%ecx
1077a2: 89 c7 mov %eax,%edi
1077a4: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
return s;
}
1077a6: 5e pop %esi
1077a7: 5f pop %edi
1077a8: c9 leave
1077a9: c3 ret
1077aa: 66 90 xchg %ax,%ax
char *ctermid(
char *s
)
{
if ( !s )
return ctermid_name;
1077ac: b8 43 ca 11 00 mov $0x11ca43,%eax
* It may not be large enough but there is no way to know that. :(
* So this is a potential buffer owerrun that we can do nothing about.
*/
strcpy( s, ctermid_name );
return s;
}
1077b1: 5e pop %esi
1077b2: 5f pop %edi
1077b3: c9 leave
1077b4: c3 ret
00106fec <devFS_Show>:
#include <rtems/seterr.h>
#include "devfs.h"
int devFS_Show(void)
{
106fec: 55 push %ebp
106fed: 89 e5 mov %esp,%ebp
106fef: 56 push %esi
106ff0: 53 push %ebx
int i;
rtems_filesystem_location_info_t *temp_loc;
rtems_device_name_t *device_name_table;
temp_loc = &rtems_filesystem_root;
106ff1: a1 d0 11 12 00 mov 0x1211d0,%eax
device_name_table = (rtems_device_name_t *)temp_loc->node_access;
106ff6: 8b 70 18 mov 0x18(%eax),%esi
if (!device_name_table)
106ff9: 85 f6 test %esi,%esi
106ffb: 74 43 je 107040 <devFS_Show+0x54> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++){
106ffd: a1 50 f1 11 00 mov 0x11f150,%eax
107002: 85 c0 test %eax,%eax
107004: 74 31 je 107037 <devFS_Show+0x4b>
107006: 31 c0 xor %eax,%eax
107008: 31 db xor %ebx,%ebx
10700a: 66 90 xchg %ax,%ax
if (device_name_table[i].device_name){
10700c: 8d 04 80 lea (%eax,%eax,4),%eax
10700f: 8d 04 86 lea (%esi,%eax,4),%eax
107012: 8b 10 mov (%eax),%edx
107014: 85 d2 test %edx,%edx
107016: 74 14 je 10702c <devFS_Show+0x40>
printk("/%s %d %d\n", device_name_table[i].device_name,
107018: ff 70 0c pushl 0xc(%eax)
10701b: ff 70 08 pushl 0x8(%eax)
10701e: 52 push %edx
10701f: 68 13 db 11 00 push $0x11db13
107024: e8 6b 12 00 00 call 108294 <printk>
107029: 83 c4 10 add $0x10,%esp
temp_loc = &rtems_filesystem_root;
device_name_table = (rtems_device_name_t *)temp_loc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++){
10702c: 43 inc %ebx
10702d: 89 d8 mov %ebx,%eax
10702f: 3b 1d 50 f1 11 00 cmp 0x11f150,%ebx
107035: 72 d5 jb 10700c <devFS_Show+0x20>
if (device_name_table[i].device_name){
printk("/%s %d %d\n", device_name_table[i].device_name,
device_name_table[i].major, device_name_table[i].minor);
}
}
return 0;
107037: 31 c0 xor %eax,%eax
}
107039: 8d 65 f8 lea -0x8(%ebp),%esp
10703c: 5b pop %ebx
10703d: 5e pop %esi
10703e: c9 leave
10703f: c3 ret
rtems_device_name_t *device_name_table;
temp_loc = &rtems_filesystem_root;
device_name_table = (rtems_device_name_t *)temp_loc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
107040: e8 97 8f 00 00 call 10ffdc <__errno>
107045: c7 00 0e 00 00 00 movl $0xe,(%eax)
10704b: 83 c8 ff or $0xffffffff,%eax
10704e: eb e9 jmp 107039 <devFS_Show+0x4d>
0010ef84 <devFS_evaluate_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
10ef84: 55 push %ebp
10ef85: 89 e5 mov %esp,%ebp
10ef87: 57 push %edi
10ef88: 56 push %esi
10ef89: 53 push %ebx
10ef8a: 83 ec 1c sub $0x1c,%esp
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
10ef8d: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp)
10ef94: 0f 85 96 00 00 00 jne 10f030 <devFS_evaluate_path+0xac><== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
10ef9a: 8b 45 14 mov 0x14(%ebp),%eax
10ef9d: 8b 00 mov (%eax),%eax
10ef9f: 89 45 e4 mov %eax,-0x1c(%ebp)
if (!device_name_table)
10efa2: 85 c0 test %eax,%eax
10efa4: 0f 84 98 00 00 00 je 10f042 <devFS_evaluate_path+0xbe>
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
10efaa: 8b 15 50 01 12 00 mov 0x120150,%edx
10efb0: 89 55 e0 mov %edx,-0x20(%ebp)
10efb3: 85 d2 test %edx,%edx
10efb5: 74 38 je 10efef <devFS_evaluate_path+0x6b><== NEVER TAKEN
10efb7: 31 c0 xor %eax,%eax
10efb9: 31 db xor %ebx,%ebx
if (!device_name_table[i].device_name)
10efbb: 8d 04 80 lea (%eax,%eax,4),%eax
10efbe: 8b 55 e4 mov -0x1c(%ebp),%edx
10efc1: 8d 3c 82 lea (%edx,%eax,4),%edi
10efc4: 8b 37 mov (%edi),%esi
10efc6: 85 f6 test %esi,%esi
10efc8: 74 1d je 10efe7 <devFS_evaluate_path+0x63>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
10efca: 50 push %eax
10efcb: ff 75 0c pushl 0xc(%ebp)
10efce: 56 push %esi
10efcf: ff 75 08 pushl 0x8(%ebp)
10efd2: e8 9d 29 00 00 call 111974 <strncmp>
10efd7: 83 c4 10 add $0x10,%esp
10efda: 85 c0 test %eax,%eax
10efdc: 75 09 jne 10efe7 <devFS_evaluate_path+0x63>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
10efde: 8b 45 0c mov 0xc(%ebp),%eax
10efe1: 80 3c 06 00 cmpb $0x0,(%esi,%eax,1)
10efe5: 74 21 je 10f008 <devFS_evaluate_path+0x84><== ALWAYS TAKEN
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
10efe7: 43 inc %ebx
10efe8: 89 d8 mov %ebx,%eax
10efea: 39 5d e0 cmp %ebx,-0x20(%ebp)
10efed: 77 cc ja 10efbb <devFS_evaluate_path+0x37>
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
}
/* no such file or directory */
rtems_set_errno_and_return_minus_one( ENOENT );
10efef: e8 c8 1c 00 00 call 110cbc <__errno>
10eff4: c7 00 02 00 00 00 movl $0x2,(%eax)
10effa: b8 ff ff ff ff mov $0xffffffff,%eax
}
10efff: 8d 65 f4 lea -0xc(%ebp),%esp
10f002: 5b pop %ebx
10f003: 5e pop %esi
10f004: 5f pop %edi
10f005: c9 leave
10f006: c3 ret
10f007: 90 nop
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
10f008: 8b 55 14 mov 0x14(%ebp),%edx
10f00b: 89 3a mov %edi,(%edx)
pathloc->handlers = &devFS_file_handlers;
10f00d: c7 42 08 60 20 12 00 movl $0x122060,0x8(%edx)
pathloc->ops = &devFS_ops;
10f014: c7 42 0c 00 20 12 00 movl $0x122000,0xc(%edx)
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
10f01b: a1 d0 21 12 00 mov 0x1221d0,%eax
10f020: 8b 40 28 mov 0x28(%eax),%eax
10f023: 89 42 10 mov %eax,0x10(%edx)
return 0;
10f026: 31 c0 xor %eax,%eax
}
/* no such file or directory */
rtems_set_errno_and_return_minus_one( ENOENT );
}
10f028: 8d 65 f4 lea -0xc(%ebp),%esp
10f02b: 5b pop %ebx
10f02c: 5e pop %esi
10f02d: 5f pop %edi
10f02e: c9 leave
10f02f: c3 ret
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
10f030: e8 87 1c 00 00 call 110cbc <__errno> <== NOT EXECUTED
10f035: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
10f03b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10f040: eb e6 jmp 10f028 <devFS_evaluate_path+0xa4><== NOT EXECUTED
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
10f042: e8 75 1c 00 00 call 110cbc <__errno>
10f047: c7 00 0e 00 00 00 movl $0xe,(%eax)
10f04d: 83 c8 ff or $0xffffffff,%eax
10f050: eb d6 jmp 10f028 <devFS_evaluate_path+0xa4>
00107d3c <devFS_ioctl>:
int devFS_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
107d3c: 55 push %ebp
107d3d: 89 e5 mov %esp,%ebp
107d3f: 83 ec 1c sub $0x1c,%esp
107d42: 8b 55 08 mov 0x8(%ebp),%edx
rtems_libio_ioctl_args_t args;
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
107d45: 8b 42 18 mov 0x18(%edx),%eax
args.iop = iop;
107d48: 89 55 e8 mov %edx,-0x18(%ebp)
args.command = command;
107d4b: 8b 55 0c mov 0xc(%ebp),%edx
107d4e: 89 55 ec mov %edx,-0x14(%ebp)
args.buffer = buffer;
107d51: 8b 55 10 mov 0x10(%ebp),%edx
107d54: 89 55 f0 mov %edx,-0x10(%ebp)
status = rtems_io_control(
np->major,
np->minor,
(void *) &args
107d57: 8d 55 e8 lea -0x18(%ebp),%edx
args.iop = iop;
args.command = command;
args.buffer = buffer;
status = rtems_io_control(
107d5a: 52 push %edx
107d5b: ff 70 0c pushl 0xc(%eax)
107d5e: ff 70 08 pushl 0x8(%eax)
107d61: e8 8a 3f 00 00 call 10bcf0 <rtems_io_control>
np->major,
np->minor,
(void *) &args
);
if ( status )
107d66: 83 c4 10 add $0x10,%esp
107d69: 85 c0 test %eax,%eax
107d6b: 75 07 jne 107d74 <devFS_ioctl+0x38>
return rtems_deviceio_errno(status);
return args.ioctl_return;
107d6d: 8b 45 f4 mov -0xc(%ebp),%eax
}
107d70: c9 leave
107d71: c3 ret
107d72: 66 90 xchg %ax,%ax
np->minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
107d74: 83 ec 0c sub $0xc,%esp
107d77: 50 push %eax
107d78: e8 e7 72 00 00 call 10f064 <rtems_deviceio_errno>
107d7d: 83 c4 10 add $0x10,%esp
return args.ioctl_return;
}
107d80: c9 leave
107d81: c3 ret
00107be4 <devFS_mknod>:
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
107be4: 55 push %ebp
107be5: 89 e5 mov %esp,%ebp
107be7: 57 push %edi
107be8: 56 push %esi
107be9: 53 push %ebx
107bea: 83 ec 1c sub $0x1c,%esp
107bed: 8b 7d 08 mov 0x8(%ebp),%edi
107bf0: 8b 4d 10 mov 0x10(%ebp),%ecx
107bf3: 8b 55 14 mov 0x14(%ebp),%edx
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
107bf6: 80 3f 64 cmpb $0x64,(%edi)
107bf9: 0f 84 dd 00 00 00 je 107cdc <devFS_mknod+0xf8>
(path[2] == 'v') && (path[3] == '\0'))
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
107bff: 8b 45 0c mov 0xc(%ebp),%eax
107c02: 25 00 f0 00 00 and $0xf000,%eax
107c07: 3d 00 60 00 00 cmp $0x6000,%eax
107c0c: 74 0b je 107c19 <devFS_mknod+0x35>
107c0e: 3d 00 20 00 00 cmp $0x2000,%eax
107c13: 0f 85 e5 00 00 00 jne 107cfe <devFS_mknod+0x11a>
)
{
union __rtems_dev_t temp;
temp.device = device;
return temp.__overlay.major;
107c19: 89 4d dc mov %ecx,-0x24(%ebp)
dev_t device
)
{
union __rtems_dev_t temp;
temp.device = device;
107c1c: 89 55 d8 mov %edx,-0x28(%ebp)
rtems_set_errno_and_return_minus_one( EINVAL );
else
rtems_filesystem_split_dev_t(dev, major, minor);
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
107c1f: 8b 45 18 mov 0x18(%ebp),%eax
107c22: 8b 30 mov (%eax),%esi
if (!device_name_table)
107c24: 85 f6 test %esi,%esi
107c26: 0f 84 f4 00 00 00 je 107d20 <devFS_mknod+0x13c>
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
107c2c: 8b 15 50 01 12 00 mov 0x120150,%edx
107c32: 85 d2 test %edx,%edx
107c34: 0f 84 d6 00 00 00 je 107d10 <devFS_mknod+0x12c>
107c3a: 31 c0 xor %eax,%eax
107c3c: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp)
107c43: 31 db xor %ebx,%ebx
107c45: 89 7d e4 mov %edi,-0x1c(%ebp)
107c48: 89 d7 mov %edx,%edi
107c4a: eb 1a jmp 107c66 <devFS_mknod+0x82>
if (device_name_table[i].device_name == NULL)
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
107c4c: 83 ec 08 sub $0x8,%esp
107c4f: 50 push %eax
107c50: ff 75 e4 pushl -0x1c(%ebp)
107c53: e8 c4 9c 00 00 call 11191c <strcmp>
107c58: 83 c4 10 add $0x10,%esp
107c5b: 85 c0 test %eax,%eax
107c5d: 74 65 je 107cc4 <devFS_mknod+0xe0>
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
107c5f: 43 inc %ebx
107c60: 89 d8 mov %ebx,%eax
107c62: 39 fb cmp %edi,%ebx
107c64: 73 16 jae 107c7c <devFS_mknod+0x98>
if (device_name_table[i].device_name == NULL)
107c66: 8d 04 80 lea (%eax,%eax,4),%eax
107c69: 8b 04 86 mov (%esi,%eax,4),%eax
107c6c: 85 c0 test %eax,%eax
107c6e: 75 dc jne 107c4c <devFS_mknod+0x68>
107c70: 89 5d e0 mov %ebx,-0x20(%ebp)
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
107c73: 43 inc %ebx
107c74: 89 d8 mov %ebx,%eax
107c76: 39 fb cmp %edi,%ebx
107c78: 72 ec jb 107c66 <devFS_mknod+0x82>
107c7a: 66 90 xchg %ax,%ax
107c7c: 8b 7d e4 mov -0x1c(%ebp),%edi
else
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
}
if (slot == -1)
107c7f: 83 7d e0 ff cmpl $0xffffffff,-0x20(%ebp)
107c83: 0f 84 87 00 00 00 je 107d10 <devFS_mknod+0x12c> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOMEM );
_ISR_Disable(level);
107c89: 9c pushf
107c8a: fa cli
107c8b: 5b pop %ebx
device_name_table[slot].device_name = (char *)path;
107c8c: 8b 55 e0 mov -0x20(%ebp),%edx
107c8f: 8d 04 92 lea (%edx,%edx,4),%eax
107c92: 8d 14 86 lea (%esi,%eax,4),%edx
107c95: 89 3a mov %edi,(%edx)
device_name_table[slot].device_name_length = strlen(path);
107c97: 31 c0 xor %eax,%eax
107c99: b9 ff ff ff ff mov $0xffffffff,%ecx
107c9e: f2 ae repnz scas %es:(%edi),%al
107ca0: f7 d1 not %ecx
107ca2: 49 dec %ecx
107ca3: 89 4a 04 mov %ecx,0x4(%edx)
device_name_table[slot].major = major;
107ca6: 8b 45 dc mov -0x24(%ebp),%eax
107ca9: 89 42 08 mov %eax,0x8(%edx)
device_name_table[slot].minor = minor;
107cac: 8b 45 d8 mov -0x28(%ebp),%eax
107caf: 89 42 0c mov %eax,0xc(%edx)
device_name_table[slot].mode = mode;
107cb2: 8b 45 0c mov 0xc(%ebp),%eax
107cb5: 89 42 10 mov %eax,0x10(%edx)
_ISR_Enable(level);
107cb8: 53 push %ebx
107cb9: 9d popf
return 0;
107cba: 31 c0 xor %eax,%eax
}
107cbc: 8d 65 f4 lea -0xc(%ebp),%esp
107cbf: 5b pop %ebx
107cc0: 5e pop %esi
107cc1: 5f pop %edi
107cc2: c9 leave
107cc3: c3 ret
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
107cc4: e8 f3 8f 00 00 call 110cbc <__errno>
107cc9: c7 00 11 00 00 00 movl $0x11,(%eax)
107ccf: b8 ff ff ff ff mov $0xffffffff,%eax
device_name_table[slot].minor = minor;
device_name_table[slot].mode = mode;
_ISR_Enable(level);
return 0;
}
107cd4: 8d 65 f4 lea -0xc(%ebp),%esp
107cd7: 5b pop %ebx
107cd8: 5e pop %esi
107cd9: 5f pop %edi
107cda: c9 leave
107cdb: c3 ret
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
107cdc: 80 7f 01 65 cmpb $0x65,0x1(%edi)
107ce0: 0f 85 19 ff ff ff jne 107bff <devFS_mknod+0x1b> <== NEVER TAKEN
107ce6: 80 7f 02 76 cmpb $0x76,0x2(%edi)
107cea: 0f 85 0f ff ff ff jne 107bff <devFS_mknod+0x1b> <== NEVER TAKEN
(path[2] == 'v') && (path[3] == '\0'))
107cf0: 80 7f 03 00 cmpb $0x0,0x3(%edi)
107cf4: 0f 85 05 ff ff ff jne 107bff <devFS_mknod+0x1b>
return 0;
107cfa: 31 c0 xor %eax,%eax
107cfc: eb be jmp 107cbc <devFS_mknod+0xd8>
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
rtems_set_errno_and_return_minus_one( EINVAL );
107cfe: e8 b9 8f 00 00 call 110cbc <__errno>
107d03: c7 00 16 00 00 00 movl $0x16,(%eax)
107d09: b8 ff ff ff ff mov $0xffffffff,%eax
107d0e: eb ac jmp 107cbc <devFS_mknod+0xd8>
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
}
if (slot == -1)
rtems_set_errno_and_return_minus_one( ENOMEM );
107d10: e8 a7 8f 00 00 call 110cbc <__errno>
107d15: c7 00 0c 00 00 00 movl $0xc,(%eax)
107d1b: 83 c8 ff or $0xffffffff,%eax
107d1e: eb 9c jmp 107cbc <devFS_mknod+0xd8>
rtems_filesystem_split_dev_t(dev, major, minor);
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
107d20: e8 97 8f 00 00 call 110cbc <__errno>
107d25: c7 00 0e 00 00 00 movl $0xe,(%eax)
107d2b: 83 c8 ff or $0xffffffff,%eax
107d2e: eb 8c jmp 107cbc <devFS_mknod+0xd8>
00111558 <device_ioctl>:
int device_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
111558: 55 push %ebp
111559: 89 e5 mov %esp,%ebp
11155b: 83 ec 1c sub $0x1c,%esp
11155e: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_ioctl_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
args.iop = iop;
111561: 89 45 e8 mov %eax,-0x18(%ebp)
args.command = command;
111564: 8b 55 0c mov 0xc(%ebp),%edx
111567: 89 55 ec mov %edx,-0x14(%ebp)
args.buffer = buffer;
11156a: 8b 55 10 mov 0x10(%ebp),%edx
11156d: 89 55 f0 mov %edx,-0x10(%ebp)
the_jnode = iop->pathinfo.node_access;
111570: 8b 40 18 mov 0x18(%eax),%eax
status = rtems_io_control(
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
111573: 8d 55 e8 lea -0x18(%ebp),%edx
args.command = command;
args.buffer = buffer;
the_jnode = iop->pathinfo.node_access;
status = rtems_io_control(
111576: 52 push %edx
111577: ff 70 54 pushl 0x54(%eax)
11157a: ff 70 50 pushl 0x50(%eax)
11157d: e8 9e 05 00 00 call 111b20 <rtems_io_control>
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
111582: 83 c4 10 add $0x10,%esp
111585: 85 c0 test %eax,%eax
111587: 75 07 jne 111590 <device_ioctl+0x38>
return rtems_deviceio_errno(status);
return args.ioctl_return;
111589: 8b 45 f4 mov -0xc(%ebp),%eax
}
11158c: c9 leave
11158d: c3 ret
11158e: 66 90 xchg %ax,%ax
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
111590: 83 ec 0c sub $0xc,%esp
111593: 50 push %eax
111594: e8 f3 07 00 00 call 111d8c <rtems_deviceio_errno>
111599: 83 c4 10 add $0x10,%esp
return args.ioctl_return;
}
11159c: c9 leave
11159d: c3 ret
0010854c <drainOutput>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
10854c: 55 push %ebp
10854d: 89 e5 mov %esp,%ebp
10854f: 53 push %ebx
108550: 83 ec 04 sub $0x4,%esp
108553: 89 c3 mov %eax,%ebx
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
108555: 8b 90 b4 00 00 00 mov 0xb4(%eax),%edx
10855b: 85 d2 test %edx,%edx
10855d: 74 4d je 1085ac <drainOutput+0x60>
rtems_interrupt_disable (level);
10855f: 9c pushf
108560: fa cli
108561: 58 pop %eax
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
108562: 8b 8b 84 00 00 00 mov 0x84(%ebx),%ecx
108568: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx
10856e: 39 d1 cmp %edx,%ecx
108570: 74 38 je 1085aa <drainOutput+0x5e>
108572: 66 90 xchg %ax,%ax
tty->rawOutBufState = rob_wait;
108574: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx)
10857b: 00 00 00
rtems_interrupt_enable (level);
10857e: 50 push %eax
10857f: 9d popf
sc = rtems_semaphore_obtain(
108580: 50 push %eax
108581: 6a 00 push $0x0
108583: 6a 00 push $0x0
108585: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
10858b: e8 18 26 00 00 call 10aba8 <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
108590: 83 c4 10 add $0x10,%esp
108593: 85 c0 test %eax,%eax
108595: 75 1a jne 1085b1 <drainOutput+0x65> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
108597: 9c pushf
108598: fa cli
108599: 58 pop %eax
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
10859a: 8b 8b 84 00 00 00 mov 0x84(%ebx),%ecx
1085a0: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx
1085a6: 39 d1 cmp %edx,%ecx
1085a8: 75 ca jne 108574 <drainOutput+0x28> <== NEVER TAKEN
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
rtems_interrupt_enable (level);
1085aa: 50 push %eax
1085ab: 9d popf
}
}
1085ac: 8b 5d fc mov -0x4(%ebp),%ebx
1085af: c9 leave
1085b0: c3 ret
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
1085b1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1085b4: 50 push %eax <== NOT EXECUTED
1085b5: e8 2e 2c 00 00 call 10b1e8 <rtems_fatal_error_occurred><== NOT EXECUTED
001092e4 <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
1092e4: 55 push %ebp
1092e5: 89 e5 mov %esp,%ebp
1092e7: 53 push %ebx
1092e8: 83 ec 24 sub $0x24,%esp
if ((tty->termios.c_lflag & ECHOCTL) &&
1092eb: f6 42 3d 02 testb $0x2,0x3d(%edx)
1092ef: 74 1b je 10930c <echo+0x28> <== NEVER TAKEN
iscntrl(c) && (c != '\t') && (c != '\n')) {
1092f1: 0f b6 c8 movzbl %al,%ecx
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
1092f4: 8b 1d 54 42 12 00 mov 0x124254,%ebx
1092fa: f6 44 0b 01 20 testb $0x20,0x1(%ebx,%ecx,1)
1092ff: 74 0b je 10930c <echo+0x28>
iscntrl(c) && (c != '\t') && (c != '\n')) {
109301: 3c 09 cmp $0x9,%al
109303: 74 07 je 10930c <echo+0x28>
109305: 3c 0a cmp $0xa,%al
109307: 75 13 jne 10931c <echo+0x38>
109309: 8d 76 00 lea 0x0(%esi),%esi
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
} else {
oproc (c, tty);
10930c: 0f b6 c0 movzbl %al,%eax
10930f: e8 94 fe ff ff call 1091a8 <oproc>
}
}
109314: 8b 5d fc mov -0x4(%ebp),%ebx
109317: c9 leave
109318: c3 ret
109319: 8d 76 00 lea 0x0(%esi),%esi
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
10931c: c6 45 f6 5e movb $0x5e,-0xa(%ebp)
echobuf[1] = c ^ 0x40;
109320: 83 f0 40 xor $0x40,%eax
109323: 88 45 f7 mov %al,-0x9(%ebp)
rtems_termios_puts (echobuf, 2, tty);
109326: 53 push %ebx
109327: 52 push %edx
109328: 6a 02 push $0x2
10932a: 8d 45 f6 lea -0xa(%ebp),%eax
10932d: 50 push %eax
10932e: 89 55 e4 mov %edx,-0x1c(%ebp)
109331: e8 3e fd ff ff call 109074 <rtems_termios_puts>
tty->column += 2;
109336: 8b 55 e4 mov -0x1c(%ebp),%edx
109339: 83 42 28 02 addl $0x2,0x28(%edx)
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
10933d: 83 c4 10 add $0x10,%esp
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
} else {
oproc (c, tty);
}
}
109340: 8b 5d fc mov -0x4(%ebp),%ebx
109343: c9 leave
109344: c3 ret
001084e4 <endgrent>:
void endgrent(void)
{
1084e4: 55 push %ebp
1084e5: 89 e5 mov %esp,%ebp
1084e7: 83 ec 08 sub $0x8,%esp
if (group_fp != NULL)
1084ea: a1 a0 6f 12 00 mov 0x126fa0,%eax
1084ef: 85 c0 test %eax,%eax
1084f1: 74 0c je 1084ff <endgrent+0x1b> <== NEVER TAKEN
fclose(group_fp);
1084f3: 83 ec 0c sub $0xc,%esp
1084f6: 50 push %eax
1084f7: e8 48 a8 00 00 call 112d44 <fclose>
1084fc: 83 c4 10 add $0x10,%esp
}
1084ff: c9 leave
108500: c3 ret
0010838c <endpwent>:
void endpwent(void)
{
10838c: 55 push %ebp
10838d: 89 e5 mov %esp,%ebp
10838f: 83 ec 08 sub $0x8,%esp
if (passwd_fp != NULL)
108392: a1 88 70 12 00 mov 0x127088,%eax
108397: 85 c0 test %eax,%eax
108399: 74 0c je 1083a7 <endpwent+0x1b> <== NEVER TAKEN
fclose(passwd_fp);
10839b: 83 ec 0c sub $0xc,%esp
10839e: 50 push %eax
10839f: e8 a0 a9 00 00 call 112d44 <fclose>
1083a4: 83 c4 10 add $0x10,%esp
}
1083a7: c9 leave
1083a8: c3 ret
00109348 <erase>:
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
109348: 55 push %ebp
109349: 89 e5 mov %esp,%ebp
10934b: 57 push %edi
10934c: 56 push %esi
10934d: 53 push %ebx
10934e: 83 ec 1c sub $0x1c,%esp
109351: 89 c3 mov %eax,%ebx
109353: 89 d7 mov %edx,%edi
if (tty->ccount == 0)
109355: 8b 48 20 mov 0x20(%eax),%ecx
109358: 85 c9 test %ecx,%ecx
10935a: 0f 84 84 00 00 00 je 1093e4 <erase+0x9c>
return;
if (lineFlag) {
109360: 85 d2 test %edx,%edx
109362: 0f 85 84 00 00 00 jne 1093ec <erase+0xa4>
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
109368: 8b 50 3c mov 0x3c(%eax),%edx
10936b: 89 7d e4 mov %edi,-0x1c(%ebp)
10936e: eb 1d jmp 10938d <erase+0x45>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
109370: 80 e6 02 and $0x2,%dh <== NOT EXECUTED
109373: 0f 85 37 01 00 00 jne 1094b0 <erase+0x168> <== NOT EXECUTED
109379: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
10937c: 8b 75 e4 mov -0x1c(%ebp),%esi
10937f: 85 f6 test %esi,%esi
109381: 74 61 je 1093e4 <erase+0x9c> <== NEVER TAKEN
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
109383: 8b 4b 20 mov 0x20(%ebx),%ecx
109386: 85 c9 test %ecx,%ecx
109388: 74 5a je 1093e4 <erase+0x9c>
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
if (tty->termios.c_lflag & ECHOK)
echo ('\n', tty);
10938a: 8b 53 3c mov 0x3c(%ebx),%edx
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
10938d: 8b 7b 1c mov 0x1c(%ebx),%edi
109390: 49 dec %ecx
109391: 89 4b 20 mov %ecx,0x20(%ebx)
109394: 8a 04 0f mov (%edi,%ecx,1),%al
if (tty->termios.c_lflag & ECHO) {
109397: f6 c2 08 test $0x8,%dl
10939a: 74 e0 je 10937c <erase+0x34> <== NEVER TAKEN
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
10939c: 8b 75 e4 mov -0x1c(%ebp),%esi
10939f: 85 f6 test %esi,%esi
1093a1: 75 09 jne 1093ac <erase+0x64>
1093a3: f6 c2 10 test $0x10,%dl
1093a6: 0f 84 f0 00 00 00 je 10949c <erase+0x154> <== NEVER TAKEN
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
1093ac: 3c 09 cmp $0x9,%al
1093ae: 74 58 je 109408 <erase+0xc0>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
1093b0: 0f b6 c0 movzbl %al,%eax
1093b3: 8d 70 01 lea 0x1(%eax),%esi
1093b6: a1 54 42 12 00 mov 0x124254,%eax
1093bb: f6 04 30 20 testb $0x20,(%eax,%esi,1)
1093bf: 75 af jne 109370 <erase+0x28> <== NEVER TAKEN
rtems_termios_puts ("\b \b", 3, tty);
if (tty->column)
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
1093c1: 57 push %edi
1093c2: 53 push %ebx
1093c3: 6a 03 push $0x3
1093c5: 68 66 fe 11 00 push $0x11fe66
1093ca: e8 a5 fc ff ff call 109074 <rtems_termios_puts>
if (tty->column)
1093cf: 8b 43 28 mov 0x28(%ebx),%eax
1093d2: 83 c4 10 add $0x10,%esp
1093d5: 85 c0 test %eax,%eax
1093d7: 74 a3 je 10937c <erase+0x34> <== NEVER TAKEN
tty->column--;
1093d9: 48 dec %eax
1093da: 89 43 28 mov %eax,0x28(%ebx)
}
}
}
if (!lineFlag)
1093dd: 8b 75 e4 mov -0x1c(%ebp),%esi
1093e0: 85 f6 test %esi,%esi
1093e2: 75 9f jne 109383 <erase+0x3b>
break;
}
}
1093e4: 8d 65 f4 lea -0xc(%ebp),%esp
1093e7: 5b pop %ebx
1093e8: 5e pop %esi
1093e9: 5f pop %edi
1093ea: c9 leave
1093eb: c3 ret
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
1093ec: 8b 50 3c mov 0x3c(%eax),%edx
1093ef: f6 c2 08 test $0x8,%dl
1093f2: 0f 84 94 00 00 00 je 10948c <erase+0x144> <== NEVER TAKEN
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
1093f8: f6 c2 10 test $0x10,%dl
1093fb: 0f 84 eb 00 00 00 je 1094ec <erase+0x1a4> <== NEVER TAKEN
109401: 89 7d e4 mov %edi,-0x1c(%ebp)
109404: eb 87 jmp 10938d <erase+0x45>
109406: 66 90 xchg %ax,%ax
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
int col = tty->read_start_column;
109408: 8b 73 2c mov 0x2c(%ebx),%esi
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
10940b: 85 c9 test %ecx,%ecx
10940d: 74 46 je 109455 <erase+0x10d>
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
10940f: a1 54 42 12 00 mov 0x124254,%eax
109414: 89 45 dc mov %eax,-0x24(%ebp)
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
int col = tty->read_start_column;
int i = 0;
109417: 31 c0 xor %eax,%eax
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
109419: 81 e2 00 02 00 00 and $0x200,%edx
10941f: 89 55 e0 mov %edx,-0x20(%ebp)
109422: 89 5d d8 mov %ebx,-0x28(%ebp)
109425: 8b 5d dc mov -0x24(%ebp),%ebx
109428: eb 10 jmp 10943a <erase+0xf2>
10942a: 66 90 xchg %ax,%ax
10942c: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED
10942f: 85 d2 test %edx,%edx <== NOT EXECUTED
109431: 74 03 je 109436 <erase+0xee> <== NOT EXECUTED
col += 2;
109433: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
109436: 39 c1 cmp %eax,%ecx
109438: 74 18 je 109452 <erase+0x10a> <== NEVER TAKEN
c = tty->cbuf[i++];
10943a: 8a 14 07 mov (%edi,%eax,1),%dl
10943d: 40 inc %eax
if (c == '\t') {
10943e: 80 fa 09 cmp $0x9,%dl
109441: 74 41 je 109484 <erase+0x13c> <== NEVER TAKEN
col = (col | 7) + 1;
} else if (iscntrl (c)) {
109443: 0f b6 d2 movzbl %dl,%edx
109446: f6 44 13 01 20 testb $0x20,0x1(%ebx,%edx,1)
10944b: 75 df jne 10942c <erase+0xe4> <== NEVER TAKEN
if (tty->termios.c_lflag & ECHOCTL)
col += 2;
} else {
col++;
10944d: 46 inc %esi
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
10944e: 39 c1 cmp %eax,%ecx
109450: 75 e8 jne 10943a <erase+0xf2>
109452: 8b 5d d8 mov -0x28(%ebp),%ebx
}
/*
* Back up over the tab
*/
while (tty->column > col) {
109455: 3b 73 28 cmp 0x28(%ebx),%esi
109458: 0f 8d 1e ff ff ff jge 10937c <erase+0x34> <== NEVER TAKEN
10945e: 66 90 xchg %ax,%ax
rtems_termios_puts ("\b", 1, tty);
109460: 52 push %edx
109461: 53 push %ebx
109462: 6a 01 push $0x1
109464: 68 68 fe 11 00 push $0x11fe68
109469: e8 06 fc ff ff call 109074 <rtems_termios_puts>
tty->column--;
10946e: 8b 43 28 mov 0x28(%ebx),%eax
109471: 48 dec %eax
109472: 89 43 28 mov %eax,0x28(%ebx)
}
/*
* Back up over the tab
*/
while (tty->column > col) {
109475: 83 c4 10 add $0x10,%esp
109478: 39 f0 cmp %esi,%eax
10947a: 7f e4 jg 109460 <erase+0x118>
10947c: e9 fb fe ff ff jmp 10937c <erase+0x34>
109481: 8d 76 00 lea 0x0(%esi),%esi
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
109484: 83 ce 07 or $0x7,%esi
109487: 46 inc %esi
109488: eb ac jmp 109436 <erase+0xee>
10948a: 66 90 xchg %ax,%ax
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
tty->ccount = 0;
10948c: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
109493: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
109496: 5b pop %ebx <== NOT EXECUTED
109497: 5e pop %esi <== NOT EXECUTED
109498: 5f pop %edi <== NOT EXECUTED
109499: c9 leave <== NOT EXECUTED
10949a: c3 ret <== NOT EXECUTED
10949b: 90 nop <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
10949c: 0f b6 43 43 movzbl 0x43(%ebx),%eax <== NOT EXECUTED
1094a0: 89 da mov %ebx,%edx <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
1094a2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1094a5: 5b pop %ebx <== NOT EXECUTED
1094a6: 5e pop %esi <== NOT EXECUTED
1094a7: 5f pop %edi <== NOT EXECUTED
1094a8: c9 leave <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
1094a9: e9 36 fe ff ff jmp 1092e4 <echo> <== NOT EXECUTED
1094ae: 66 90 xchg %ax,%ax <== NOT EXECUTED
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
1094b0: 50 push %eax <== NOT EXECUTED
1094b1: 53 push %ebx <== NOT EXECUTED
1094b2: 6a 03 push $0x3 <== NOT EXECUTED
1094b4: 68 66 fe 11 00 push $0x11fe66 <== NOT EXECUTED
1094b9: e8 b6 fb ff ff call 109074 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
1094be: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
1094c1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1094c4: 85 c0 test %eax,%eax <== NOT EXECUTED
1094c6: 74 04 je 1094cc <erase+0x184> <== NOT EXECUTED
tty->column--;
1094c8: 48 dec %eax <== NOT EXECUTED
1094c9: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
1094cc: a1 54 42 12 00 mov 0x124254,%eax <== NOT EXECUTED
1094d1: f6 04 30 20 testb $0x20,(%eax,%esi,1) <== NOT EXECUTED
1094d5: 0f 84 e6 fe ff ff je 1093c1 <erase+0x79> <== NOT EXECUTED
1094db: f6 43 3d 02 testb $0x2,0x3d(%ebx) <== NOT EXECUTED
1094df: 0f 85 dc fe ff ff jne 1093c1 <erase+0x79> <== NOT EXECUTED
1094e5: e9 92 fe ff ff jmp 10937c <erase+0x34> <== NOT EXECUTED
1094ea: 66 90 xchg %ax,%ax <== NOT EXECUTED
if (!(tty->termios.c_lflag & ECHO)) {
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
1094ec: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
1094f3: 0f b6 40 44 movzbl 0x44(%eax),%eax <== NOT EXECUTED
1094f7: 89 da mov %ebx,%edx <== NOT EXECUTED
1094f9: e8 e6 fd ff ff call 1092e4 <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
1094fe: f6 43 3c 20 testb $0x20,0x3c(%ebx) <== NOT EXECUTED
109502: 0f 84 dc fe ff ff je 1093e4 <erase+0x9c> <== NOT EXECUTED
echo ('\n', tty);
109508: 89 da mov %ebx,%edx <== NOT EXECUTED
10950a: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
10950f: eb 91 jmp 1094a2 <erase+0x15a> <== NOT EXECUTED
001080b0 <fchdir>:
#include <rtems/seterr.h>
int fchdir(
int fd
)
{
1080b0: 55 push %ebp
1080b1: 89 e5 mov %esp,%ebp
1080b3: 57 push %edi
1080b4: 56 push %esi
1080b5: 53 push %ebx
1080b6: 83 ec 4c sub $0x4c,%esp
1080b9: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc, saved;
rtems_libio_check_fd( fd );
1080bc: 3b 05 ac 35 12 00 cmp 0x1235ac,%eax
1080c2: 0f 83 d0 00 00 00 jae 108198 <fchdir+0xe8>
iop = rtems_libio_iop( fd );
1080c8: c1 e0 03 shl $0x3,%eax
1080cb: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx
1080d2: 29 c3 sub %eax,%ebx
1080d4: 03 1d 40 77 12 00 add 0x127740,%ebx
rtems_libio_check_is_open(iop);
1080da: 8b 43 14 mov 0x14(%ebx),%eax
1080dd: f6 c4 01 test $0x1,%ah
1080e0: 0f 84 b2 00 00 00 je 108198 <fchdir+0xe8>
/*
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
1080e6: a8 02 test $0x2,%al
1080e8: 0f 84 be 00 00 00 je 1081ac <fchdir+0xfc>
/*
* Verify you can change directory into this node.
*/
if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) !=
1080ee: 83 ec 0c sub $0xc,%esp
1080f1: 8b 43 24 mov 0x24(%ebx),%eax
1080f4: 83 c3 18 add $0x18,%ebx
1080f7: 53 push %ebx
1080f8: ff 50 10 call *0x10(%eax)
1080fb: 83 c4 10 add $0x10,%esp
1080fe: 48 dec %eax
1080ff: 75 67 jne 108168 <fchdir+0xb8>
* but note the race condition. Threads who
* share their rtems_filesystem_current better
* be synchronized!
*/
saved = rtems_filesystem_current;
108101: a1 70 55 12 00 mov 0x125570,%eax
108106: 8d 55 c0 lea -0x40(%ebp),%edx
108109: 89 55 b4 mov %edx,-0x4c(%ebp)
10810c: 8d 70 04 lea 0x4(%eax),%esi
10810f: b9 05 00 00 00 mov $0x5,%ecx
108114: 89 d7 mov %edx,%edi
108116: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rtems_filesystem_current = iop->pathinfo;
108118: 8d 78 04 lea 0x4(%eax),%edi
10811b: b1 05 mov $0x5,%cl
10811d: 89 de mov %ebx,%esi
10811f: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* clone the current node */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
108121: 83 ec 0c sub $0xc,%esp
108124: 6a 00 push $0x0
108126: 8d 75 d4 lea -0x2c(%ebp),%esi
108129: 56 push %esi
10812a: 6a 00 push $0x0
10812c: 6a 01 push $0x1
10812e: 68 b6 16 12 00 push $0x1216b6
108133: e8 a0 fe ff ff call 107fd8 <rtems_filesystem_evaluate_path>
108138: 83 c4 20 add $0x20,%esp
10813b: 85 c0 test %eax,%eax
10813d: 75 3d jne 10817c <fchdir+0xcc>
/* cloning failed; restore original and bail out */
rtems_filesystem_current = saved;
return -1;
}
/* release the old one */
rtems_filesystem_freenode( &saved );
10813f: 83 ec 0c sub $0xc,%esp
108142: 8d 45 c0 lea -0x40(%ebp),%eax
108145: 50 push %eax
108146: e8 61 01 00 00 call 1082ac <rtems_filesystem_freenode>
rtems_filesystem_current = loc;
10814b: 8b 3d 70 55 12 00 mov 0x125570,%edi
108151: 83 c7 04 add $0x4,%edi
108154: b9 05 00 00 00 mov $0x5,%ecx
108159: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return 0;
10815b: 83 c4 10 add $0x10,%esp
10815e: 31 c0 xor %eax,%eax
}
108160: 8d 65 f4 lea -0xc(%ebp),%esp
108163: 5b pop %ebx
108164: 5e pop %esi
108165: 5f pop %edi
108166: c9 leave
108167: c3 ret
* Verify you can change directory into this node.
*/
if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) !=
RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_set_errno_and_return_minus_one( ENOTDIR );
108168: e8 af aa 00 00 call 112c1c <__errno>
10816d: c7 00 14 00 00 00 movl $0x14,(%eax)
108173: b8 ff ff ff ff mov $0xffffffff,%eax
108178: eb e6 jmp 108160 <fchdir+0xb0>
10817a: 66 90 xchg %ax,%ax
rtems_filesystem_current = iop->pathinfo;
/* clone the current node */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
/* cloning failed; restore original and bail out */
rtems_filesystem_current = saved;
10817c: 8b 3d 70 55 12 00 mov 0x125570,%edi
108182: 83 c7 04 add $0x4,%edi
108185: b9 05 00 00 00 mov $0x5,%ecx
10818a: 8b 75 b4 mov -0x4c(%ebp),%esi
10818d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return -1;
10818f: b8 ff ff ff ff mov $0xffffffff,%eax
108194: eb ca jmp 108160 <fchdir+0xb0>
108196: 66 90 xchg %ax,%ax
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc, saved;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
108198: e8 7f aa 00 00 call 112c1c <__errno>
10819d: c7 00 09 00 00 00 movl $0x9,(%eax)
1081a3: b8 ff ff ff ff mov $0xffffffff,%eax
1081a8: eb b6 jmp 108160 <fchdir+0xb0>
1081aa: 66 90 xchg %ax,%ax
/*
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
1081ac: e8 6b aa 00 00 call 112c1c <__errno>
1081b1: c7 00 16 00 00 00 movl $0x16,(%eax)
1081b7: b8 ff ff ff ff mov $0xffffffff,%eax
1081bc: eb a2 jmp 108160 <fchdir+0xb0>
001081c0 <fchmod>:
int fchmod(
int fd,
mode_t mode
)
{
1081c0: 55 push %ebp
1081c1: 89 e5 mov %esp,%ebp
1081c3: 83 ec 08 sub $0x8,%esp
1081c6: 8b 45 08 mov 0x8(%ebp),%eax
1081c9: 8b 4d 0c mov 0xc(%ebp),%ecx
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
1081cc: 3b 05 ac 35 12 00 cmp 0x1235ac,%eax
1081d2: 73 38 jae 10820c <fchmod+0x4c>
iop = rtems_libio_iop( fd );
1081d4: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
1081db: 8d 04 d5 00 00 00 00 lea 0x0(,%edx,8),%eax
1081e2: 29 d0 sub %edx,%eax
1081e4: 03 05 40 77 12 00 add 0x127740,%eax
rtems_libio_check_is_open(iop);
1081ea: 8b 50 14 mov 0x14(%eax),%edx
1081ed: f6 c6 01 test $0x1,%dh
1081f0: 74 1a je 10820c <fchmod+0x4c>
/*
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
1081f2: 83 e2 04 and $0x4,%edx
1081f5: 74 29 je 108220 <fchmod+0x60>
return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode );
1081f7: 8b 50 20 mov 0x20(%eax),%edx
1081fa: 89 4d 0c mov %ecx,0xc(%ebp)
1081fd: 83 c0 18 add $0x18,%eax
108200: 89 45 08 mov %eax,0x8(%ebp)
108203: 8b 42 1c mov 0x1c(%edx),%eax
}
108206: c9 leave
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode );
108207: ff e0 jmp *%eax
108209: 8d 76 00 lea 0x0(%esi),%esi
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
10820c: e8 0b aa 00 00 call 112c1c <__errno>
108211: c7 00 09 00 00 00 movl $0x9,(%eax)
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode );
}
108217: b8 ff ff ff ff mov $0xffffffff,%eax
10821c: c9 leave
10821d: c3 ret
10821e: 66 90 xchg %ax,%ax
/*
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
108220: e8 f7 a9 00 00 call 112c1c <__errno>
108225: c7 00 16 00 00 00 movl $0x16,(%eax)
10822b: eb ea jmp 108217 <fchmod+0x57>
00108060 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
108060: 55 push %ebp
108061: 89 e5 mov %esp,%ebp
108063: 57 push %edi
108064: 56 push %esi
108065: 53 push %ebx
108066: 83 ec 1c sub $0x1c,%esp
108069: 8b 5d 08 mov 0x8(%ebp),%ebx
10806c: 8b 55 0c mov 0xc(%ebp),%edx
int ret;
va_list ap;
va_start( ap, cmd );
10806f: 8d 7d 10 lea 0x10(%ebp),%edi
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
108072: 8b 0d 4c 31 12 00 mov 0x12314c,%ecx
108078: 39 cb cmp %ecx,%ebx
10807a: 0f 83 5c 01 00 00 jae 1081dc <fcntl+0x17c>
iop = rtems_libio_iop( fd );
108080: a1 e0 72 12 00 mov 0x1272e0,%eax
108085: 8d 34 dd 00 00 00 00 lea 0x0(,%ebx,8),%esi
10808c: 8d 1c f5 00 00 00 00 lea 0x0(,%esi,8),%ebx
108093: 29 f3 sub %esi,%ebx
108095: 8d 1c 18 lea (%eax,%ebx,1),%ebx
rtems_libio_check_is_open(iop);
108098: 8b 73 14 mov 0x14(%ebx),%esi
10809b: f7 c6 00 01 00 00 test $0x100,%esi
1080a1: 0f 84 35 01 00 00 je 1081dc <fcntl+0x17c>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
1080a7: 83 fa 09 cmp $0x9,%edx
1080aa: 76 10 jbe 1080bc <fcntl+0x5c>
errno = ENOTSUP;
ret = -1;
break;
default:
errno = EINVAL;
1080ac: e8 1b ae 00 00 call 112ecc <__errno>
1080b1: c7 00 16 00 00 00 movl $0x16,(%eax)
1080b7: eb 16 jmp 1080cf <fcntl+0x6f>
1080b9: 8d 76 00 lea 0x0(%esi),%esi
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
1080bc: ff 24 95 d0 18 12 00 jmp *0x1218d0(,%edx,4)
1080c3: 90 nop
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
1080c4: e8 03 ae 00 00 call 112ecc <__errno>
1080c9: c7 00 86 00 00 00 movl $0x86,(%eax)
if (ret >= 0) {
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
if (err) {
errno = err;
ret = -1;
1080cf: be ff ff ff ff mov $0xffffffff,%esi
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
1080d4: 89 f0 mov %esi,%eax
1080d6: 8d 65 f4 lea -0xc(%ebp),%esp
1080d9: 5b pop %ebx
1080da: 5e pop %esi
1080db: 5f pop %edi
1080dc: c9 leave
1080dd: c3 ret
1080de: 66 90 xchg %ax,%ax
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
1080e0: 83 ec 0c sub $0xc,%esp
1080e3: ff 37 pushl (%edi)
1080e5: 89 55 e0 mov %edx,-0x20(%ebp)
1080e8: e8 33 05 00 00 call 108620 <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
1080ed: 25 01 02 00 00 and $0x201,%eax
1080f2: 8b 4b 14 mov 0x14(%ebx),%ecx
1080f5: 81 e1 fe fd ff ff and $0xfffffdfe,%ecx
1080fb: 09 c8 or %ecx,%eax
1080fd: 89 43 14 mov %eax,0x14(%ebx)
108100: 83 c4 10 add $0x10,%esp
rtems_libio_t *iop;
rtems_libio_t *diop;
int fd2;
int flags;
int mask;
int ret = 0;
108103: 31 f6 xor %esi,%esi
108105: 8b 55 e0 mov -0x20(%ebp),%edx
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
108108: 83 ec 08 sub $0x8,%esp
10810b: 8b 43 20 mov 0x20(%ebx),%eax
10810e: 53 push %ebx
10810f: 52 push %edx
108110: ff 50 30 call *0x30(%eax)
108113: 89 c3 mov %eax,%ebx
if (err) {
108115: 83 c4 10 add $0x10,%esp
108118: 85 c0 test %eax,%eax
10811a: 74 b8 je 1080d4 <fcntl+0x74> <== ALWAYS TAKEN
errno = err;
10811c: e8 ab ad 00 00 call 112ecc <__errno> <== NOT EXECUTED
108121: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
108123: eb aa jmp 1080cf <fcntl+0x6f> <== NOT EXECUTED
108125: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
108128: 83 ec 0c sub $0xc,%esp
10812b: 56 push %esi
10812c: 89 55 e0 mov %edx,-0x20(%ebp)
10812f: e8 24 05 00 00 call 108658 <rtems_libio_to_fcntl_flags>
108134: 89 c6 mov %eax,%esi
108136: 83 c4 10 add $0x10,%esp
108139: 8b 55 e0 mov -0x20(%ebp),%edx
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
10813c: 85 f6 test %esi,%esi
10813e: 79 c8 jns 108108 <fcntl+0xa8> <== ALWAYS TAKEN
108140: eb 92 jmp 1080d4 <fcntl+0x74> <== NOT EXECUTED
108142: 66 90 xchg %ax,%ax <== NOT EXECUTED
* if a new process is exec()'ed. Since RTEMS does not support
* processes, then we can ignore this one except to make
* F_GETFD work.
*/
if ( va_arg( ap, int ) )
108144: 8b 07 mov (%edi),%eax
108146: 85 c0 test %eax,%eax
108148: 74 6a je 1081b4 <fcntl+0x154>
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
10814a: 81 ce 00 08 00 00 or $0x800,%esi
108150: 89 73 14 mov %esi,0x14(%ebx)
rtems_libio_t *iop;
rtems_libio_t *diop;
int fd2;
int flags;
int mask;
int ret = 0;
108153: 31 f6 xor %esi,%esi
108155: eb b1 jmp 108108 <fcntl+0xa8>
108157: 90 nop
diop->pathinfo = iop->pathinfo;
ret = (int) (diop - rtems_libio_iops);
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
108158: 31 c0 xor %eax,%eax
10815a: f7 c6 00 08 00 00 test $0x800,%esi
108160: 0f 95 c0 setne %al
108163: 89 c6 mov %eax,%esi
108165: eb a1 jmp 108108 <fcntl+0xa8>
108167: 90 nop
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
108168: 8b 3f mov (%edi),%edi
if ( fd2 )
10816a: 85 ff test %edi,%edi
10816c: 0f 84 82 00 00 00 je 1081f4 <fcntl+0x194>
diop = rtems_libio_iop( fd2 );
108172: 39 f9 cmp %edi,%ecx
108174: 77 4e ja 1081c4 <fcntl+0x164> <== ALWAYS TAKEN
108176: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) <== NOT EXECUTED
10817d: 31 ff xor %edi,%edi <== NOT EXECUTED
ret = -1;
break;
}
}
diop->flags = iop->flags;
10817f: 89 77 14 mov %esi,0x14(%edi)
diop->pathinfo = iop->pathinfo;
108182: 83 c7 18 add $0x18,%edi
108185: 8d 73 18 lea 0x18(%ebx),%esi
108188: b9 05 00 00 00 mov $0x5,%ecx
10818d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
ret = (int) (diop - rtems_libio_iops);
10818f: 8b 4d e4 mov -0x1c(%ebp),%ecx
108192: 29 c1 sub %eax,%ecx
108194: 89 c8 mov %ecx,%eax
108196: c1 f8 03 sar $0x3,%eax
108199: 8d 0c c0 lea (%eax,%eax,8),%ecx
10819c: 8d 0c c8 lea (%eax,%ecx,8),%ecx
10819f: 8d 0c c8 lea (%eax,%ecx,8),%ecx
1081a2: 8d 0c c8 lea (%eax,%ecx,8),%ecx
1081a5: 89 ce mov %ecx,%esi
1081a7: c1 e6 0f shl $0xf,%esi
1081aa: 01 f1 add %esi,%ecx
1081ac: 8d 34 c8 lea (%eax,%ecx,8),%esi
1081af: f7 de neg %esi
1081b1: eb 89 jmp 10813c <fcntl+0xdc>
1081b3: 90 nop
*/
if ( va_arg( ap, int ) )
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
1081b4: 81 e6 ff f7 ff ff and $0xfffff7ff,%esi
1081ba: 89 73 14 mov %esi,0x14(%ebx)
rtems_libio_t *iop;
rtems_libio_t *diop;
int fd2;
int flags;
int mask;
int ret = 0;
1081bd: 31 f6 xor %esi,%esi
1081bf: e9 44 ff ff ff jmp 108108 <fcntl+0xa8>
switch ( cmd ) {
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
if ( fd2 )
diop = rtems_libio_iop( fd2 );
1081c4: 8d 0c fd 00 00 00 00 lea 0x0(,%edi,8),%ecx
1081cb: 8d 3c cd 00 00 00 00 lea 0x0(,%ecx,8),%edi
1081d2: 29 cf sub %ecx,%edi
1081d4: 8d 3c 38 lea (%eax,%edi,1),%edi
1081d7: 89 7d e4 mov %edi,-0x1c(%ebp)
1081da: eb a3 jmp 10817f <fcntl+0x11f>
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
1081dc: e8 eb ac 00 00 call 112ecc <__errno>
1081e1: c7 00 09 00 00 00 movl $0x9,(%eax)
1081e7: be ff ff ff ff mov $0xffffffff,%esi
1081ec: e9 e3 fe ff ff jmp 1080d4 <fcntl+0x74>
1081f1: 8d 76 00 lea 0x0(%esi),%esi
fd2 = va_arg( ap, int );
if ( fd2 )
diop = rtems_libio_iop( fd2 );
else {
/* allocate a file control block */
diop = rtems_libio_allocate();
1081f4: 89 55 e0 mov %edx,-0x20(%ebp)
1081f7: e8 a0 04 00 00 call 10869c <rtems_libio_allocate>
1081fc: 89 c7 mov %eax,%edi
if ( diop == 0 ) {
1081fe: 85 c0 test %eax,%eax
108200: 8b 55 e0 mov -0x20(%ebp),%edx
108203: 0f 84 c6 fe ff ff je 1080cf <fcntl+0x6f> <== NEVER TAKEN
108209: 8b 73 14 mov 0x14(%ebx),%esi
10820c: 89 45 e4 mov %eax,-0x1c(%ebp)
10820f: a1 e0 72 12 00 mov 0x1272e0,%eax
108214: e9 66 ff ff ff jmp 10817f <fcntl+0x11f>
0010823c <fdatasync>:
#include <rtems/seterr.h>
int fdatasync(
int fd
)
{
10823c: 55 push %ebp
10823d: 89 e5 mov %esp,%ebp
10823f: 83 ec 08 sub $0x8,%esp
108242: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
108245: 3b 05 4c 31 12 00 cmp 0x12314c,%eax
10824b: 73 2f jae 10827c <fdatasync+0x40>
iop = rtems_libio_iop( fd );
10824d: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
108254: 8d 04 d5 00 00 00 00 lea 0x0(,%edx,8),%eax
10825b: 29 d0 sub %edx,%eax
10825d: 03 05 e0 72 12 00 add 0x1272e0,%eax
rtems_libio_check_is_open(iop);
108263: 8b 50 14 mov 0x14(%eax),%edx
108266: f6 c6 01 test $0x1,%dh
108269: 74 11 je 10827c <fdatasync+0x40>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
10826b: 83 e2 04 and $0x4,%edx
10826e: 74 20 je 108290 <fdatasync+0x54>
/*
* Now process the fdatasync().
*/
return (*iop->pathinfo.handlers->fdatasync_h)( iop );
108270: 8b 50 20 mov 0x20(%eax),%edx
108273: 89 45 08 mov %eax,0x8(%ebp)
108276: 8b 42 2c mov 0x2c(%edx),%eax
}
108279: c9 leave
/*
* Now process the fdatasync().
*/
return (*iop->pathinfo.handlers->fdatasync_h)( iop );
10827a: ff e0 jmp *%eax
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
10827c: e8 4b ac 00 00 call 112ecc <__errno>
108281: c7 00 09 00 00 00 movl $0x9,(%eax)
/*
* Now process the fdatasync().
*/
return (*iop->pathinfo.handlers->fdatasync_h)( iop );
}
108287: b8 ff ff ff ff mov $0xffffffff,%eax
10828c: c9 leave
10828d: c3 ret
10828e: 66 90 xchg %ax,%ax
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
108290: e8 37 ac 00 00 call 112ecc <__errno>
108295: c7 00 16 00 00 00 movl $0x16,(%eax)
10829b: eb ea jmp 108287 <fdatasync+0x4b>
00110dbc <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
110dbc: 55 push %ebp
110dbd: 89 e5 mov %esp,%ebp
110dbf: 57 push %edi
110dc0: 56 push %esi
110dc1: 53 push %ebx
110dc2: 83 ec 2c sub $0x2c,%esp
110dc5: 8b 75 08 mov 0x8(%ebp),%esi
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
110dc8: a1 54 85 12 00 mov 0x128554,%eax
110dcd: 85 c0 test %eax,%eax
110dcf: 0f 84 8b 00 00 00 je 110e60 <fifo_open+0xa4>
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
110dd5: 51 push %ecx
110dd6: 6a 00 push $0x0
110dd8: 6a 00 push $0x0
110dda: 50 push %eax
110ddb: e8 dc ba ff ff call 10c8bc <rtems_semaphore_obtain>
}
if (sc == RTEMS_SUCCESSFUL) {
110de0: 83 c4 10 add $0x10,%esp
110de3: 85 c0 test %eax,%eax
110de5: 0f 85 0c 03 00 00 jne 1110f7 <fifo_open+0x33b> <== NEVER TAKEN
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
110deb: 8b 1e mov (%esi),%ebx
if (pipe == NULL) {
110ded: 85 db test %ebx,%ebx
110def: 0f 84 df 01 00 00 je 110fd4 <fifo_open+0x218>
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
110df5: 52 push %edx
110df6: 6a 00 push $0x0
110df8: 6a 00 push $0x0
110dfa: ff 73 28 pushl 0x28(%ebx)
110dfd: e8 ba ba ff ff call 10c8bc <rtems_semaphore_obtain>
110e02: 83 c4 10 add $0x10,%esp
110e05: 83 f8 01 cmp $0x1,%eax
110e08: 19 ff sbb %edi,%edi
110e0a: f7 d7 not %edi
110e0c: 83 e7 fc and $0xfffffffc,%edi
err = -EINTR;
if (*pipep == NULL) {
110e0f: 8b 06 mov (%esi),%eax
110e11: 85 c0 test %eax,%eax
110e13: 0f 84 97 02 00 00 je 1110b0 <fifo_open+0x2f4>
else
*pipep = pipe;
}
out:
pipe_unlock();
110e19: e8 aa fe ff ff call 110cc8 <pipe_unlock>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
110e1e: 85 ff test %edi,%edi
110e20: 75 32 jne 110e54 <fifo_open+0x98> <== NEVER TAKEN
return err;
pipe = *pipep;
110e22: 8b 1e mov (%esi),%ebx
switch (LIBIO_ACCMODE(iop)) {
110e24: 8b 55 0c mov 0xc(%ebp),%edx
110e27: 8b 42 14 mov 0x14(%edx),%eax
110e2a: 83 e0 06 and $0x6,%eax
110e2d: 83 f8 04 cmp $0x4,%eax
110e30: 74 6a je 110e9c <fifo_open+0xe0>
110e32: 83 f8 06 cmp $0x6,%eax
110e35: 0f 84 59 01 00 00 je 110f94 <fifo_open+0x1d8>
110e3b: 83 f8 02 cmp $0x2,%eax
110e3e: 0f 84 dc 00 00 00 je 110f20 <fifo_open+0x164> <== ALWAYS TAKEN
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
break;
}
PIPE_UNLOCK(pipe);
110e44: 83 ec 0c sub $0xc,%esp
110e47: ff 73 28 pushl 0x28(%ebx)
110e4a: e8 69 bb ff ff call 10c9b8 <rtems_semaphore_release>
return 0;
110e4f: 83 c4 10 add $0x10,%esp
110e52: 31 ff xor %edi,%edi
out_error:
pipe_release(pipep, iop);
return err;
}
110e54: 89 f8 mov %edi,%eax
110e56: 8d 65 f4 lea -0xc(%ebp),%esp
110e59: 5b pop %ebx
110e5a: 5e pop %esi
110e5b: 5f pop %edi
110e5c: c9 leave
110e5d: c3 ret
110e5e: 66 90 xchg %ax,%ax
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
110e60: 57 push %edi
110e61: 6a 00 push $0x0
110e63: 6a 00 push $0x0
110e65: ff 35 88 87 12 00 pushl 0x128788
110e6b: e8 4c ba ff ff call 10c8bc <rtems_semaphore_obtain>
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
110e70: 83 c4 10 add $0x10,%esp
110e73: 8b 1d 54 85 12 00 mov 0x128554,%ebx
110e79: 85 db test %ebx,%ebx
110e7b: 0f 84 43 02 00 00 je 1110c4 <fifo_open+0x308> <== ALWAYS TAKEN
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
110e81: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
110e84: ff 35 88 87 12 00 pushl 0x128788 <== NOT EXECUTED
110e8a: e8 29 bb ff ff call 10c9b8 <rtems_semaphore_release><== NOT EXECUTED
110e8f: a1 54 85 12 00 mov 0x128554,%eax <== NOT EXECUTED
110e94: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
110e97: e9 39 ff ff ff jmp 110dd5 <fifo_open+0x19> <== NOT EXECUTED
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
110e9c: ff 43 24 incl 0x24(%ebx)
if (pipe->Writers ++ == 0)
110e9f: 8b 43 14 mov 0x14(%ebx),%eax
110ea2: 8d 50 01 lea 0x1(%eax),%edx
110ea5: 89 53 14 mov %edx,0x14(%ebx)
110ea8: 85 c0 test %eax,%eax
110eaa: 0f 84 84 02 00 00 je 111134 <fifo_open+0x378> <== ALWAYS TAKEN
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
110eb0: 8b 4b 10 mov 0x10(%ebx),%ecx
110eb3: 85 c9 test %ecx,%ecx
110eb5: 75 8d jne 110e44 <fifo_open+0x88>
110eb7: 8b 55 0c mov 0xc(%ebp),%edx
110eba: f6 42 14 01 testb $0x1,0x14(%edx)
110ebe: 0f 85 c4 02 00 00 jne 111188 <fifo_open+0x3cc>
err = -ENXIO;
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
110ec4: 8b 7b 20 mov 0x20(%ebx),%edi
110ec7: eb 20 jmp 110ee9 <fifo_open+0x12d>
110ec9: 8d 76 00 lea 0x0(%esi),%esi
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
110ecc: 51 push %ecx
110ecd: 6a 00 push $0x0
110ecf: 6a 00 push $0x0
110ed1: ff 73 28 pushl 0x28(%ebx)
110ed4: e8 e3 b9 ff ff call 10c8bc <rtems_semaphore_obtain>
110ed9: 83 c4 10 add $0x10,%esp
110edc: 85 c0 test %eax,%eax
110ede: 75 27 jne 110f07 <fifo_open+0x14b> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->readerCounter);
110ee0: 39 7b 20 cmp %edi,0x20(%ebx)
110ee3: 0f 85 5b ff ff ff jne 110e44 <fifo_open+0x88> <== ALWAYS TAKEN
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
110ee9: 83 ec 0c sub $0xc,%esp
110eec: ff 73 28 pushl 0x28(%ebx)
110eef: e8 c4 ba ff ff call 10c9b8 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
110ef4: 58 pop %eax
110ef5: 5a pop %edx
110ef6: 6a 00 push $0x0
110ef8: ff 73 30 pushl 0x30(%ebx)
110efb: e8 04 13 00 00 call 112204 <rtems_barrier_wait>
110f00: 83 c4 10 add $0x10,%esp
110f03: 85 c0 test %eax,%eax
110f05: 74 c5 je 110ecc <fifo_open+0x110> <== ALWAYS TAKEN
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
110f07: bf fc ff ff ff mov $0xfffffffc,%edi <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
110f0c: 83 ec 08 sub $0x8,%esp
110f0f: ff 75 0c pushl 0xc(%ebp)
110f12: 56 push %esi
110f13: e8 c8 fd ff ff call 110ce0 <pipe_release>
return err;
110f18: 83 c4 10 add $0x10,%esp
110f1b: e9 34 ff ff ff jmp 110e54 <fifo_open+0x98>
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
110f20: ff 43 20 incl 0x20(%ebx)
if (pipe->Readers ++ == 0)
110f23: 8b 43 10 mov 0x10(%ebx),%eax
110f26: 8d 50 01 lea 0x1(%eax),%edx
110f29: 89 53 10 mov %edx,0x10(%ebx)
110f2c: 85 c0 test %eax,%eax
110f2e: 0f 84 d0 01 00 00 je 111104 <fifo_open+0x348> <== ALWAYS TAKEN
PIPE_WAKEUPWRITERS(pipe);
if (pipe->Writers == 0) {
110f34: 8b 7b 14 mov 0x14(%ebx),%edi
110f37: 85 ff test %edi,%edi
110f39: 0f 85 05 ff ff ff jne 110e44 <fifo_open+0x88>
/* Not an error */
if (LIBIO_NODELAY(iop))
110f3f: 8b 45 0c mov 0xc(%ebp),%eax
110f42: f6 40 14 01 testb $0x1,0x14(%eax)
110f46: 0f 85 f8 fe ff ff jne 110e44 <fifo_open+0x88>
break;
prevCounter = pipe->writerCounter;
110f4c: 8b 7b 24 mov 0x24(%ebx),%edi
110f4f: eb 20 jmp 110f71 <fifo_open+0x1b5>
110f51: 8d 76 00 lea 0x0(%esi),%esi
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
110f54: 50 push %eax
110f55: 6a 00 push $0x0
110f57: 6a 00 push $0x0
110f59: ff 73 28 pushl 0x28(%ebx)
110f5c: e8 5b b9 ff ff call 10c8bc <rtems_semaphore_obtain>
110f61: 83 c4 10 add $0x10,%esp
110f64: 85 c0 test %eax,%eax
110f66: 75 9f jne 110f07 <fifo_open+0x14b> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->writerCounter);
110f68: 39 7b 24 cmp %edi,0x24(%ebx)
110f6b: 0f 85 d3 fe ff ff jne 110e44 <fifo_open+0x88> <== ALWAYS TAKEN
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
110f71: 83 ec 0c sub $0xc,%esp
110f74: ff 73 28 pushl 0x28(%ebx)
110f77: e8 3c ba ff ff call 10c9b8 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
110f7c: 5a pop %edx
110f7d: 59 pop %ecx
110f7e: 6a 00 push $0x0
110f80: ff 73 2c pushl 0x2c(%ebx)
110f83: e8 7c 12 00 00 call 112204 <rtems_barrier_wait>
110f88: 83 c4 10 add $0x10,%esp
110f8b: 85 c0 test %eax,%eax
110f8d: 74 c5 je 110f54 <fifo_open+0x198> <== ALWAYS TAKEN
110f8f: e9 73 ff ff ff jmp 110f07 <fifo_open+0x14b> <== NOT EXECUTED
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
110f94: ff 43 20 incl 0x20(%ebx)
if (pipe->Readers ++ == 0)
110f97: 8b 43 10 mov 0x10(%ebx),%eax
110f9a: 8d 50 01 lea 0x1(%eax),%edx
110f9d: 89 53 10 mov %edx,0x10(%ebx)
110fa0: 85 c0 test %eax,%eax
110fa2: 0f 84 74 01 00 00 je 11111c <fifo_open+0x360> <== ALWAYS TAKEN
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
110fa8: ff 43 24 incl 0x24(%ebx)
if (pipe->Writers ++ == 0)
110fab: 8b 43 14 mov 0x14(%ebx),%eax
110fae: 8d 50 01 lea 0x1(%eax),%edx
110fb1: 89 53 14 mov %edx,0x14(%ebx)
110fb4: 85 c0 test %eax,%eax
110fb6: 0f 85 88 fe ff ff jne 110e44 <fifo_open+0x88> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
110fbc: 83 ec 08 sub $0x8,%esp
110fbf: 8d 45 e4 lea -0x1c(%ebp),%eax
110fc2: 50 push %eax
110fc3: ff 73 2c pushl 0x2c(%ebx)
110fc6: e8 d5 11 00 00 call 1121a0 <rtems_barrier_release>
110fcb: 83 c4 10 add $0x10,%esp
110fce: e9 71 fe ff ff jmp 110e44 <fifo_open+0x88>
110fd3: 90 nop
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
110fd4: 83 ec 0c sub $0xc,%esp
110fd7: 6a 34 push $0x34
110fd9: e8 52 85 ff ff call 109530 <malloc>
110fde: 89 c3 mov %eax,%ebx
110fe0: 89 45 d4 mov %eax,-0x2c(%ebp)
if (pipe == NULL)
110fe3: 83 c4 10 add $0x10,%esp
110fe6: 85 c0 test %eax,%eax
110fe8: 0f 84 f2 01 00 00 je 1111e0 <fifo_open+0x424>
return err;
memset(pipe, 0, sizeof(pipe_control_t));
110fee: b9 34 00 00 00 mov $0x34,%ecx
110ff3: 31 c0 xor %eax,%eax
110ff5: 89 df mov %ebx,%edi
110ff7: f3 aa rep stos %al,%es:(%edi)
pipe->Size = PIPE_BUF;
110ff9: c7 43 04 00 02 00 00 movl $0x200,0x4(%ebx)
pipe->Buffer = malloc(pipe->Size);
111000: 83 ec 0c sub $0xc,%esp
111003: 68 00 02 00 00 push $0x200
111008: e8 23 85 ff ff call 109530 <malloc>
11100d: 89 03 mov %eax,(%ebx)
if (! pipe->Buffer)
11100f: 83 c4 10 add $0x10,%esp
111012: 85 c0 test %eax,%eax
111014: 0f 84 b8 01 00 00 je 1111d2 <fifo_open+0x416> <== NEVER TAKEN
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
11101a: 8d 43 2c lea 0x2c(%ebx),%eax
11101d: 50 push %eax
11101e: 6a 00 push $0x0
111020: 6a 00 push $0x0
rtems_build_name ('P', 'I', 'r', c),
111022: 0f be 05 9c 65 12 00 movsbl 0x12659c,%eax
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
111029: 0d 00 72 49 50 or $0x50497200,%eax
11102e: 50 push %eax
11102f: e8 f0 0f 00 00 call 112024 <rtems_barrier_create>
111034: 83 c4 10 add $0x10,%esp
111037: 85 c0 test %eax,%eax
111039: 0f 85 83 01 00 00 jne 1111c2 <fifo_open+0x406>
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
11103f: 8d 43 30 lea 0x30(%ebx),%eax
111042: 50 push %eax
111043: 6a 00 push $0x0
111045: 6a 00 push $0x0
rtems_build_name ('P', 'I', 'w', c),
111047: 0f be 05 9c 65 12 00 movsbl 0x12659c,%eax
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
11104e: 0d 00 77 49 50 or $0x50497700,%eax
111053: 50 push %eax
111054: e8 cb 0f 00 00 call 112024 <rtems_barrier_create>
111059: 83 c4 10 add $0x10,%esp
11105c: 85 c0 test %eax,%eax
11105e: 0f 85 4d 01 00 00 jne 1111b1 <fifo_open+0x3f5>
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
111064: 83 ec 0c sub $0xc,%esp
111067: 8d 43 28 lea 0x28(%ebx),%eax
11106a: 50 push %eax
11106b: 6a 00 push $0x0
11106d: 6a 10 push $0x10
11106f: 6a 01 push $0x1
rtems_build_name ('P', 'I', 's', c), 1,
111071: 0f be 05 9c 65 12 00 movsbl 0x12659c,%eax
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
111078: 0d 00 73 49 50 or $0x50497300,%eax
11107d: 50 push %eax
11107e: e8 bd b5 ff ff call 10c640 <rtems_semaphore_create>
111083: 83 c4 20 add $0x20,%esp
111086: 85 c0 test %eax,%eax
111088: 0f 85 12 01 00 00 jne 1111a0 <fifo_open+0x3e4>
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
11108e: a0 9c 65 12 00 mov 0x12659c,%al
111093: 8d 50 01 lea 0x1(%eax),%edx
111096: 88 15 9c 65 12 00 mov %dl,0x12659c
11109c: 3c 7a cmp $0x7a,%al
11109e: 0f 85 51 fd ff ff jne 110df5 <fifo_open+0x39>
c = 'a';
1110a4: c6 05 9c 65 12 00 61 movb $0x61,0x12659c
1110ab: e9 45 fd ff ff jmp 110df5 <fifo_open+0x39>
if (! PIPE_LOCK(pipe))
err = -EINTR;
if (*pipep == NULL) {
if (err)
1110b0: 85 ff test %edi,%edi
1110b2: 0f 85 94 00 00 00 jne 11114c <fifo_open+0x390> <== NEVER TAKEN
pipe_free(pipe);
else
*pipep = pipe;
1110b8: 89 1e mov %ebx,(%esi)
}
out:
pipe_unlock();
1110ba: e8 09 fc ff ff call 110cc8 <pipe_unlock>
1110bf: e9 5e fd ff ff jmp 110e22 <fifo_open+0x66>
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
sc = rtems_semaphore_create(
1110c4: 83 ec 0c sub $0xc,%esp
1110c7: 68 54 85 12 00 push $0x128554
1110cc: 6a 00 push $0x0
1110ce: 6a 54 push $0x54
1110d0: 6a 01 push $0x1
1110d2: 68 45 50 49 50 push $0x50495045
1110d7: e8 64 b5 ff ff call 10c640 <rtems_semaphore_create>
1110dc: 89 c3 mov %eax,%ebx
1110de: 83 c4 14 add $0x14,%esp
1110e1: ff 35 88 87 12 00 pushl 0x128788
1110e7: e8 cc b8 ff ff call 10c9b8 <rtems_semaphore_release>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
1110ec: 83 c4 10 add $0x10,%esp
1110ef: 85 db test %ebx,%ebx
1110f1: 0f 84 f0 00 00 00 je 1111e7 <fifo_open+0x42b>
)
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
1110f7: bf f4 ff ff ff mov $0xfffffff4,%edi
1110fc: e9 53 fd ff ff jmp 110e54 <fifo_open+0x98>
111101: 8d 76 00 lea 0x0(%esi),%esi
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
111104: 83 ec 08 sub $0x8,%esp
111107: 8d 45 e4 lea -0x1c(%ebp),%eax
11110a: 50 push %eax
11110b: ff 73 30 pushl 0x30(%ebx)
11110e: e8 8d 10 00 00 call 1121a0 <rtems_barrier_release>
111113: 83 c4 10 add $0x10,%esp
111116: e9 19 fe ff ff jmp 110f34 <fifo_open+0x178>
11111b: 90 nop
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
11111c: 83 ec 08 sub $0x8,%esp
11111f: 8d 45 e4 lea -0x1c(%ebp),%eax
111122: 50 push %eax
111123: ff 73 30 pushl 0x30(%ebx)
111126: e8 75 10 00 00 call 1121a0 <rtems_barrier_release>
11112b: 83 c4 10 add $0x10,%esp
11112e: e9 75 fe ff ff jmp 110fa8 <fifo_open+0x1ec>
111133: 90 nop
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
111134: 83 ec 08 sub $0x8,%esp
111137: 8d 45 e4 lea -0x1c(%ebp),%eax
11113a: 50 push %eax
11113b: ff 73 2c pushl 0x2c(%ebx)
11113e: e8 5d 10 00 00 call 1121a0 <rtems_barrier_release>
111143: 83 c4 10 add $0x10,%esp
111146: e9 65 fd ff ff jmp 110eb0 <fifo_open+0xf4>
11114b: 90 nop
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
11114c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
11114f: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED
111152: e8 b9 0f 00 00 call 112110 <rtems_barrier_delete> <== NOT EXECUTED
rtems_barrier_delete(pipe->writeBarrier);
111157: 59 pop %ecx <== NOT EXECUTED
111158: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED
11115b: e8 b0 0f 00 00 call 112110 <rtems_barrier_delete> <== NOT EXECUTED
rtems_semaphore_delete(pipe->Semaphore);
111160: 5a pop %edx <== NOT EXECUTED
111161: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED
111164: e8 af b6 ff ff call 10c818 <rtems_semaphore_delete><== NOT EXECUTED
free(pipe->Buffer);
111169: 58 pop %eax <== NOT EXECUTED
11116a: ff 33 pushl (%ebx) <== NOT EXECUTED
11116c: e8 ef 7c ff ff call 108e60 <free> <== NOT EXECUTED
free(pipe);
111171: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
111174: e8 e7 7c ff ff call 108e60 <free> <== NOT EXECUTED
111179: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
else
*pipep = pipe;
}
out:
pipe_unlock();
11117c: e8 47 fb ff ff call 110cc8 <pipe_unlock>
111181: e9 ce fc ff ff jmp 110e54 <fifo_open+0x98>
111186: 66 90 xchg %ax,%ax
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
111188: 83 ec 0c sub $0xc,%esp
11118b: ff 73 28 pushl 0x28(%ebx)
11118e: e8 25 b8 ff ff call 10c9b8 <rtems_semaphore_release>
err = -ENXIO;
goto out_error;
111193: 83 c4 10 add $0x10,%esp
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
err = -ENXIO;
111196: bf fa ff ff ff mov $0xfffffffa,%edi
goto out_error;
11119b: e9 6c fd ff ff jmp 110f0c <fifo_open+0x150>
if (c ++ == 'z')
c = 'a';
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
1111a0: 83 ec 0c sub $0xc,%esp
1111a3: 8b 45 d4 mov -0x2c(%ebp),%eax
1111a6: ff 70 30 pushl 0x30(%eax)
1111a9: e8 62 0f 00 00 call 112110 <rtems_barrier_delete>
1111ae: 83 c4 10 add $0x10,%esp
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
1111b1: 83 ec 0c sub $0xc,%esp
1111b4: 8b 55 d4 mov -0x2c(%ebp),%edx
1111b7: ff 72 2c pushl 0x2c(%edx)
1111ba: e8 51 0f 00 00 call 112110 <rtems_barrier_delete>
1111bf: 83 c4 10 add $0x10,%esp
err_rbar:
free(pipe->Buffer);
1111c2: 83 ec 0c sub $0xc,%esp
1111c5: 8b 45 d4 mov -0x2c(%ebp),%eax
1111c8: ff 30 pushl (%eax)
1111ca: e8 91 7c ff ff call 108e60 <free>
1111cf: 83 c4 10 add $0x10,%esp
err_buf:
free(pipe);
1111d2: 83 ec 0c sub $0xc,%esp
1111d5: ff 75 d4 pushl -0x2c(%ebp)
1111d8: e8 83 7c ff ff call 108e60 <free>
1111dd: 83 c4 10 add $0x10,%esp
)
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
1111e0: bf f4 ff ff ff mov $0xfffffff4,%edi
1111e5: eb 95 jmp 11117c <fifo_open+0x3c0>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
1111e7: a1 54 85 12 00 mov 0x128554,%eax
1111ec: e9 e4 fb ff ff jmp 110dd5 <fifo_open+0x19>
0010f438 <find_handler>:
const char *type;
rtems_filesystem_fsmount_me_t mount_h;
} find_arg;
static bool find_handler(const rtems_filesystem_table_t *entry, void *arg)
{
10f438: 55 push %ebp
10f439: 89 e5 mov %esp,%ebp
10f43b: 56 push %esi
10f43c: 53 push %ebx
10f43d: 8b 75 08 mov 0x8(%ebp),%esi
10f440: 8b 5d 0c mov 0xc(%ebp),%ebx
find_arg *fa = arg;
if ( strcmp( entry->type, fa->type ) != 0 ) {
10f443: 83 ec 08 sub $0x8,%esp
10f446: ff 33 pushl (%ebx)
10f448: ff 36 pushl (%esi)
10f44a: e8 fd 35 00 00 call 112a4c <strcmp>
10f44f: 83 c4 10 add $0x10,%esp
10f452: 85 c0 test %eax,%eax
10f454: 75 12 jne 10f468 <find_handler+0x30>
return false;
} else {
fa->mount_h = entry->mount_h;
10f456: 8b 46 04 mov 0x4(%esi),%eax
10f459: 89 43 04 mov %eax,0x4(%ebx)
return true;
10f45c: b0 01 mov $0x1,%al
}
}
10f45e: 8d 65 f8 lea -0x8(%ebp),%esp
10f461: 5b pop %ebx
10f462: 5e pop %esi
10f463: c9 leave
10f464: c3 ret
10f465: 8d 76 00 lea 0x0(%esi),%esi
static bool find_handler(const rtems_filesystem_table_t *entry, void *arg)
{
find_arg *fa = arg;
if ( strcmp( entry->type, fa->type ) != 0 ) {
return false;
10f468: 31 c0 xor %eax,%eax
} else {
fa->mount_h = entry->mount_h;
return true;
}
}
10f46a: 8d 65 f8 lea -0x8(%ebp),%esp
10f46d: 5b pop %ebx
10f46e: 5e pop %esi
10f46f: c9 leave
10f470: c3 ret
001082a0 <fpathconf>:
long fpathconf(
int fd,
int name
)
{
1082a0: 55 push %ebp
1082a1: 89 e5 mov %esp,%ebp
1082a3: 83 ec 08 sub $0x8,%esp
1082a6: 8b 45 08 mov 0x8(%ebp),%eax
1082a9: 8b 55 0c mov 0xc(%ebp),%edx
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
1082ac: 3b 05 4c 31 12 00 cmp 0x12314c,%eax
1082b2: 0f 83 ac 00 00 00 jae 108364 <fpathconf+0xc4>
iop = rtems_libio_iop(fd);
1082b8: 8d 0c c5 00 00 00 00 lea 0x0(,%eax,8),%ecx
1082bf: 8d 04 cd 00 00 00 00 lea 0x0(,%ecx,8),%eax
1082c6: 29 c8 sub %ecx,%eax
1082c8: 03 05 e0 72 12 00 add 0x1272e0,%eax
rtems_libio_check_is_open(iop);
1082ce: 8b 48 14 mov 0x14(%eax),%ecx
1082d1: f6 c5 01 test $0x1,%ch
1082d4: 0f 84 8a 00 00 00 je 108364 <fpathconf+0xc4> <== NEVER TAKEN
rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ);
1082da: 83 e1 02 and $0x2,%ecx
1082dd: 74 08 je 1082e7 <fpathconf+0x47>
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
1082df: 8b 40 28 mov 0x28(%eax),%eax
switch ( name ) {
1082e2: 83 fa 0b cmp $0xb,%edx
1082e5: 76 15 jbe 1082fc <fpathconf+0x5c>
break;
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
1082e7: e8 e0 ab 00 00 call 112ecc <__errno>
1082ec: c7 00 16 00 00 00 movl $0x16,(%eax)
1082f2: b8 ff ff ff ff mov $0xffffffff,%eax
break;
}
return return_value;
}
1082f7: c9 leave
1082f8: c3 ret
1082f9: 8d 76 00 lea 0x0(%esi),%esi
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
1082fc: ff 24 95 f8 18 12 00 jmp *0x1218f8(,%edx,4)
108303: 90 nop
break;
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
108304: 8b 40 5c mov 0x5c(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108307: c9 leave
108308: c3 ret
108309: 8d 76 00 lea 0x0(%esi),%esi
break;
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
break;
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
10830c: 8b 40 50 mov 0x50(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
10830f: c9 leave
108310: c3 ret
108311: 8d 76 00 lea 0x0(%esi),%esi
break;
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
break;
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
108314: 8b 40 64 mov 0x64(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108317: c9 leave
108318: c3 ret
108319: 8d 76 00 lea 0x0(%esi),%esi
break;
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
break;
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
10831c: 8b 40 58 mov 0x58(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
10831f: c9 leave
108320: c3 ret
108321: 8d 76 00 lea 0x0(%esi),%esi
break;
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
break;
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
108324: 8b 40 54 mov 0x54(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108327: c9 leave
108328: c3 ret
108329: 8d 76 00 lea 0x0(%esi),%esi
break;
case _PC_PATH_MAX:
return_value = the_limits->path_max;
break;
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
10832c: 8b 40 4c mov 0x4c(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
10832f: c9 leave
108330: c3 ret
108331: 8d 76 00 lea 0x0(%esi),%esi
break;
case _PC_NAME_MAX:
return_value = the_limits->name_max;
break;
case _PC_PATH_MAX:
return_value = the_limits->path_max;
108334: 8b 40 48 mov 0x48(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108337: c9 leave
108338: c3 ret
108339: 8d 76 00 lea 0x0(%esi),%esi
break;
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
break;
case _PC_NAME_MAX:
return_value = the_limits->name_max;
10833c: 8b 40 44 mov 0x44(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
10833f: c9 leave
108340: c3 ret
108341: 8d 76 00 lea 0x0(%esi),%esi
break;
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
break;
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
108344: 8b 40 40 mov 0x40(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108347: c9 leave
108348: c3 ret
108349: 8d 76 00 lea 0x0(%esi),%esi
switch ( name ) {
case _PC_LINK_MAX:
return_value = the_limits->link_max;
break;
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
10834c: 8b 40 3c mov 0x3c(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
10834f: c9 leave
108350: c3 ret
108351: 8d 76 00 lea 0x0(%esi),%esi
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
case _PC_LINK_MAX:
return_value = the_limits->link_max;
108354: 8b 40 38 mov 0x38(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108357: c9 leave
108358: c3 ret
108359: 8d 76 00 lea 0x0(%esi),%esi
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
break;
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
10835c: 8b 40 60 mov 0x60(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
10835f: c9 leave
108360: c3 ret
108361: 8d 76 00 lea 0x0(%esi),%esi
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
iop = rtems_libio_iop(fd);
rtems_libio_check_is_open(iop);
108364: e8 63 ab 00 00 call 112ecc <__errno>
108369: c7 00 09 00 00 00 movl $0x9,(%eax)
10836f: b8 ff ff ff ff mov $0xffffffff,%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108374: c9 leave
108375: c3 ret
00107634 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
107634: 55 push %ebp
107635: 89 e5 mov %esp,%ebp
107637: 53 push %ebx
107638: 83 ec 04 sub $0x4,%esp
10763b: 8b 5d 08 mov 0x8(%ebp),%ebx
MSBUMP(free_calls, 1);
10763e: ff 05 ac 63 12 00 incl 0x1263ac
if ( !ptr )
107644: 85 db test %ebx,%ebx
107646: 74 4b je 107693 <free+0x5f>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
107648: 83 3d 80 66 12 00 03 cmpl $0x3,0x126680
10764f: 74 47 je 107698 <free+0x64> <== ALWAYS TAKEN
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
107651: a1 a8 47 12 00 mov 0x1247a8,%eax
107656: 85 c0 test %eax,%eax
107658: 74 0a je 107664 <free+0x30>
(*rtems_malloc_statistics_helpers->at_free)(ptr);
10765a: 83 ec 0c sub $0xc,%esp
10765d: 53 push %ebx
10765e: ff 50 08 call *0x8(%eax)
107661: 83 c4 10 add $0x10,%esp
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
107664: 83 ec 08 sub $0x8,%esp
107667: 53 push %ebx
107668: ff 35 30 22 12 00 pushl 0x122230
10766e: e8 fd 4d 00 00 call 10c470 <_Protected_heap_Free>
107673: 83 c4 10 add $0x10,%esp
107676: 84 c0 test %al,%al
107678: 75 19 jne 107693 <free+0x5f>
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
ptr,
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
10767a: a1 30 22 12 00 mov 0x122230,%eax
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_free)(ptr);
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
10767f: ff 70 1c pushl 0x1c(%eax)
107682: ff 70 18 pushl 0x18(%eax)
107685: 53 push %ebx
107686: 68 70 fd 11 00 push $0x11fd70
10768b: e8 b4 0d 00 00 call 108444 <printk>
107690: 83 c4 10 add $0x10,%esp
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
107693: 8b 5d fc mov -0x4(%ebp),%ebx
107696: c9 leave
107697: c3 ret
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() ) {
107698: e8 3b 01 00 00 call 1077d8 <malloc_is_system_state_OK>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
10769d: 84 c0 test %al,%al
10769f: 75 b0 jne 107651 <free+0x1d>
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
1076a1: 89 5d 08 mov %ebx,0x8(%ebp)
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
1076a4: 8b 5d fc mov -0x4(%ebp),%ebx
1076a7: c9 leave
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
1076a8: e9 97 01 00 00 jmp 107844 <malloc_deferred_free>
00108af8 <free_user_env>:
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
108af8: 55 push %ebp
108af9: 89 e5 mov %esp,%ebp
108afb: 53 push %ebx
108afc: 83 ec 04 sub $0x4,%esp
108aff: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
108b02: 81 fb 40 63 12 00 cmp $0x126340,%ebx
108b08: 74 26 je 108b30 <free_user_env+0x38> <== NEVER TAKEN
#ifdef HAVE_USERENV_REFCNT
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
108b0a: 83 ec 0c sub $0xc,%esp
108b0d: 8d 43 04 lea 0x4(%ebx),%eax
108b10: 50 push %eax
108b11: e8 4a ef ff ff call 107a60 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &env->root_directory);
108b16: 8d 43 18 lea 0x18(%ebx),%eax
108b19: 89 04 24 mov %eax,(%esp)
108b1c: e8 3f ef ff ff call 107a60 <rtems_filesystem_freenode>
free(env);
108b21: 83 c4 10 add $0x10,%esp
108b24: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
108b27: 8b 5d fc mov -0x4(%ebp),%ebx
108b2a: c9 leave
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
rtems_filesystem_freenode( &env->root_directory);
free(env);
108b2b: e9 44 ef ff ff jmp 107a74 <free>
}
}
108b30: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
108b33: c9 leave <== NOT EXECUTED
108b34: c3 ret <== NOT EXECUTED
0011db2c <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
11db2c: 55 push %ebp
11db2d: 89 e5 mov %esp,%ebp
11db2f: 57 push %edi
11db30: 53 push %ebx
11db31: 8b 45 08 mov 0x8(%ebp),%eax
11db34: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_libio_t *iop;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
11db37: 85 db test %ebx,%ebx
11db39: 74 55 je 11db90 <fstat+0x64>
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
11db3b: 3b 05 ec 21 12 00 cmp 0x1221ec,%eax
11db41: 73 39 jae 11db7c <fstat+0x50>
11db43: c1 e0 03 shl $0x3,%eax
11db46: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
11db4d: 29 c2 sub %eax,%edx
11db4f: 03 15 80 63 12 00 add 0x126380,%edx
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
11db55: f6 42 15 01 testb $0x1,0x15(%edx)
11db59: 74 21 je 11db7c <fstat+0x50> <== NEVER TAKEN
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
11db5b: b9 48 00 00 00 mov $0x48,%ecx
11db60: 31 c0 xor %eax,%eax
11db62: 89 df mov %ebx,%edi
11db64: f3 aa rep stos %al,%es:(%edi)
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
11db66: 8b 42 20 mov 0x20(%edx),%eax
11db69: 89 5d 0c mov %ebx,0xc(%ebp)
11db6c: 83 c2 18 add $0x18,%edx
11db6f: 89 55 08 mov %edx,0x8(%ebp)
11db72: 8b 40 18 mov 0x18(%eax),%eax
}
11db75: 5b pop %ebx
11db76: 5f pop %edi
11db77: c9 leave
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
11db78: ff e0 jmp *%eax
11db7a: 66 90 xchg %ax,%ax
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
11db7c: e8 5b 42 ff ff call 111ddc <__errno>
11db81: c7 00 09 00 00 00 movl $0x9,(%eax)
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
}
11db87: b8 ff ff ff ff mov $0xffffffff,%eax
11db8c: 5b pop %ebx
11db8d: 5f pop %edi
11db8e: c9 leave
11db8f: c3 ret
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
rtems_set_errno_and_return_minus_one( EFAULT );
11db90: e8 47 42 ff ff call 111ddc <__errno>
11db95: c7 00 0e 00 00 00 movl $0xe,(%eax)
11db9b: eb ea jmp 11db87 <fstat+0x5b>
00108494 <fsync>:
#include <rtems/seterr.h>
int fsync(
int fd
)
{
108494: 55 push %ebp
108495: 89 e5 mov %esp,%ebp
108497: 83 ec 08 sub $0x8,%esp
10849a: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
10849d: 3b 05 4c 31 12 00 cmp 0x12314c,%eax
1084a3: 73 2f jae 1084d4 <fsync+0x40>
iop = rtems_libio_iop( fd );
1084a5: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
1084ac: 8d 04 d5 00 00 00 00 lea 0x0(,%edx,8),%eax
1084b3: 29 d0 sub %edx,%eax
1084b5: 03 05 e0 72 12 00 add 0x1272e0,%eax
rtems_libio_check_is_open(iop);
1084bb: 8b 50 14 mov 0x14(%eax),%edx
1084be: f6 c6 01 test $0x1,%dh
1084c1: 74 11 je 1084d4 <fsync+0x40>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
1084c3: 83 e2 04 and $0x4,%edx
1084c6: 74 20 je 1084e8 <fsync+0x54>
/*
* Now process the fsync().
*/
return (*iop->pathinfo.handlers->fsync_h)( iop );
1084c8: 8b 50 20 mov 0x20(%eax),%edx
1084cb: 89 45 08 mov %eax,0x8(%ebp)
1084ce: 8b 42 28 mov 0x28(%edx),%eax
}
1084d1: c9 leave
/*
* Now process the fsync().
*/
return (*iop->pathinfo.handlers->fsync_h)( iop );
1084d2: ff e0 jmp *%eax
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
1084d4: e8 f3 a9 00 00 call 112ecc <__errno>
1084d9: c7 00 09 00 00 00 movl $0x9,(%eax)
/*
* Now process the fsync().
*/
return (*iop->pathinfo.handlers->fsync_h)( iop );
}
1084df: b8 ff ff ff ff mov $0xffffffff,%eax
1084e4: c9 leave
1084e5: c3 ret
1084e6: 66 90 xchg %ax,%ax
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
1084e8: e8 df a9 00 00 call 112ecc <__errno>
1084ed: c7 00 16 00 00 00 movl $0x16,(%eax)
1084f3: eb ea jmp 1084df <fsync+0x4b>
0010f0f4 <ftruncate>:
int ftruncate(
int fd,
off_t length
)
{
10f0f4: 55 push %ebp
10f0f5: 89 e5 mov %esp,%ebp
10f0f7: 57 push %edi
10f0f8: 56 push %esi
10f0f9: 53 push %ebx
10f0fa: 83 ec 3c sub $0x3c,%esp
10f0fd: 8b 45 08 mov 0x8(%ebp),%eax
10f100: 8b 55 0c mov 0xc(%ebp),%edx
10f103: 8b 4d 10 mov 0x10(%ebp),%ecx
10f106: 89 55 c0 mov %edx,-0x40(%ebp)
10f109: 89 4d c4 mov %ecx,-0x3c(%ebp)
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
10f10c: 3b 05 ec 21 12 00 cmp 0x1221ec,%eax
10f112: 73 58 jae 10f16c <ftruncate+0x78>
iop = rtems_libio_iop( fd );
10f114: c1 e0 03 shl $0x3,%eax
10f117: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx
10f11e: 29 c3 sub %eax,%ebx
10f120: 03 1d 80 63 12 00 add 0x126380,%ebx
rtems_libio_check_is_open(iop);
10f126: f6 43 15 01 testb $0x1,0x15(%ebx)
10f12a: 74 40 je 10f16c <ftruncate+0x78>
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
10f12c: 8d 7d d4 lea -0x2c(%ebp),%edi
10f12f: 8d 73 18 lea 0x18(%ebx),%esi
10f132: b9 05 00 00 00 mov $0x5,%ecx
10f137: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
10f139: 83 ec 0c sub $0xc,%esp
10f13c: 8d 45 d4 lea -0x2c(%ebp),%eax
10f13f: 50 push %eax
10f140: 8b 45 e0 mov -0x20(%ebp),%eax
10f143: ff 50 10 call *0x10(%eax)
10f146: 83 c4 10 add $0x10,%esp
10f149: 48 dec %eax
10f14a: 74 46 je 10f192 <ftruncate+0x9e>
rtems_set_errno_and_return_minus_one( EISDIR );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
10f14c: f6 43 14 04 testb $0x4,0x14(%ebx)
10f150: 74 2e je 10f180 <ftruncate+0x8c>
return (*iop->pathinfo.handlers->ftruncate_h)( iop, length );
10f152: 50 push %eax
10f153: 8b 43 20 mov 0x20(%ebx),%eax
10f156: ff 75 c4 pushl -0x3c(%ebp)
10f159: ff 75 c0 pushl -0x40(%ebp)
10f15c: 53 push %ebx
10f15d: ff 50 20 call *0x20(%eax)
10f160: 83 c4 10 add $0x10,%esp
}
10f163: 8d 65 f4 lea -0xc(%ebp),%esp
10f166: 5b pop %ebx
10f167: 5e pop %esi
10f168: 5f pop %edi
10f169: c9 leave
10f16a: c3 ret
10f16b: 90 nop
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
10f16c: e8 6b 2c 00 00 call 111ddc <__errno>
10f171: c7 00 09 00 00 00 movl $0x9,(%eax)
10f177: b8 ff ff ff ff mov $0xffffffff,%eax
10f17c: eb e5 jmp 10f163 <ftruncate+0x6f>
10f17e: 66 90 xchg %ax,%ax
loc = iop->pathinfo;
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
rtems_set_errno_and_return_minus_one( EISDIR );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
10f180: e8 57 2c 00 00 call 111ddc <__errno>
10f185: c7 00 16 00 00 00 movl $0x16,(%eax)
10f18b: b8 ff ff ff ff mov $0xffffffff,%eax
10f190: eb d1 jmp 10f163 <ftruncate+0x6f>
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
rtems_set_errno_and_return_minus_one( EISDIR );
10f192: e8 45 2c 00 00 call 111ddc <__errno>
10f197: c7 00 15 00 00 00 movl $0x15,(%eax)
10f19d: b8 ff ff ff ff mov $0xffffffff,%eax
10f1a2: eb bf jmp 10f163 <ftruncate+0x6f>
00107880 <getchark>:
#include <rtems.h>
#include <rtems/bspIo.h>
int getchark(void)
{
107880: 55 push %ebp
107881: 89 e5 mov %esp,%ebp
107883: 83 ec 08 sub $0x8,%esp
if ( BSP_poll_char )
107886: a1 8c 26 12 00 mov 0x12268c,%eax
10788b: 85 c0 test %eax,%eax
10788d: 74 05 je 107894 <getchark+0x14>
return (*BSP_poll_char)();
return -1;
}
10788f: c9 leave
#include <rtems/bspIo.h>
int getchark(void)
{
if ( BSP_poll_char )
return (*BSP_poll_char)();
107890: ff e0 jmp *%eax
107892: 66 90 xchg %ax,%ax
return -1;
}
107894: b8 ff ff ff ff mov $0xffffffff,%eax
107899: c9 leave
10789a: c3 ret
0011f4a0 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
11f4a0: 55 push %ebp
11f4a1: 89 e5 mov %esp,%ebp
11f4a3: 57 push %edi
11f4a4: 56 push %esi
11f4a5: 53 push %ebx
11f4a6: 83 ec 2c sub $0x2c,%esp
11f4a9: 8b 45 08 mov 0x8(%ebp),%eax
rtems_filesystem_location_info_t loc;
/*
* Get the file control block structure associated with the file descriptor
*/
iop = rtems_libio_iop( dd_fd );
11f4ac: 3b 05 4c 41 12 00 cmp 0x12414c,%eax
11f4b2: 73 4c jae 11f500 <getdents+0x60> <== NEVER TAKEN
11f4b4: c1 e0 03 shl $0x3,%eax
11f4b7: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx
11f4be: 29 c3 sub %eax,%ebx
11f4c0: 03 1d 00 84 12 00 add 0x128400,%ebx
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
11f4c6: 8d 7d d4 lea -0x2c(%ebp),%edi
11f4c9: 8d 73 18 lea 0x18(%ebx),%esi
11f4cc: b9 05 00 00 00 mov $0x5,%ecx
11f4d1: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
11f4d3: 83 ec 0c sub $0xc,%esp
11f4d6: 8d 45 d4 lea -0x2c(%ebp),%eax
11f4d9: 50 push %eax
11f4da: 8b 45 e0 mov -0x20(%ebp),%eax
11f4dd: ff 50 10 call *0x10(%eax)
11f4e0: 83 c4 10 add $0x10,%esp
11f4e3: 48 dec %eax
11f4e4: 75 1e jne 11f504 <getdents+0x64>
/*
* Return the number of bytes that were actually transfered as a result
* of the read attempt.
*/
return (*iop->pathinfo.handlers->read_h)( iop, dd_buf, dd_len );
11f4e6: 50 push %eax
11f4e7: 8b 43 20 mov 0x20(%ebx),%eax
11f4ea: ff 75 10 pushl 0x10(%ebp)
11f4ed: ff 75 0c pushl 0xc(%ebp)
11f4f0: 53 push %ebx
11f4f1: ff 50 08 call *0x8(%eax)
11f4f4: 83 c4 10 add $0x10,%esp
}
11f4f7: 8d 65 f4 lea -0xc(%ebp),%esp
11f4fa: 5b pop %ebx
11f4fb: 5e pop %esi
11f4fc: 5f pop %edi
11f4fd: c9 leave
11f4fe: c3 ret
11f4ff: 90 nop
rtems_filesystem_location_info_t loc;
/*
* Get the file control block structure associated with the file descriptor
*/
iop = rtems_libio_iop( dd_fd );
11f500: 31 db xor %ebx,%ebx
11f502: eb c2 jmp 11f4c6 <getdents+0x26> <== NOT EXECUTED
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
11f504: e8 a3 38 ff ff call 112dac <__errno>
11f509: c7 00 14 00 00 00 movl $0x14,(%eax)
11f50f: b8 ff ff ff ff mov $0xffffffff,%eax
11f514: eb e1 jmp 11f4f7 <getdents+0x57>
001080b4 <getgr_r>:
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
1080b4: 55 push %ebp
1080b5: 89 e5 mov %esp,%ebp
1080b7: 57 push %edi
1080b8: 56 push %esi
1080b9: 53 push %ebx
1080ba: 83 ec 1c sub $0x1c,%esp
1080bd: 89 c3 mov %eax,%ebx
1080bf: 89 55 e4 mov %edx,-0x1c(%ebp)
1080c2: 89 ce mov %ecx,%esi
FILE *fp;
int match;
init_etc_passwd_group();
1080c4: e8 eb fe ff ff call 107fb4 <init_etc_passwd_group>
if ((fp = fopen("/etc/group", "r")) == NULL)
1080c9: 83 ec 08 sub $0x8,%esp
1080cc: 68 d2 02 12 00 push $0x1202d2
1080d1: 68 99 16 12 00 push $0x121699
1080d6: e8 6d b3 00 00 call 113448 <fopen>
1080db: 89 c7 mov %eax,%edi
1080dd: 83 c4 10 add $0x10,%esp
1080e0: 85 c0 test %eax,%eax
1080e2: 75 22 jne 108106 <getgr_r+0x52>
1080e4: e9 8b 00 00 00 jmp 108174 <getgr_r+0xc0>
1080e9: 8d 76 00 lea 0x0(%esi),%esi
for(;;) {
if (!scangr(fp, grp, buffer, bufsize))
goto error_einval;
if (name) {
match = (strcmp(grp->gr_name, name) == 0);
1080ec: 83 ec 08 sub $0x8,%esp
1080ef: 53 push %ebx
1080f0: ff 36 pushl (%esi)
1080f2: e8 c5 c1 00 00 call 1142bc <strcmp>
1080f7: 83 c4 10 add $0x10,%esp
1080fa: 85 c0 test %eax,%eax
1080fc: 0f 94 c0 sete %al
1080ff: 0f b6 c0 movzbl %al,%eax
} else {
match = (grp->gr_gid == gid);
}
if (match) {
108102: 85 c0 test %eax,%eax
108104: 75 2e jne 108134 <getgr_r+0x80>
if ((fp = fopen("/etc/group", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
for(;;) {
if (!scangr(fp, grp, buffer, bufsize))
108106: 83 ec 0c sub $0xc,%esp
108109: ff 75 0c pushl 0xc(%ebp)
10810c: 8b 4d 08 mov 0x8(%ebp),%ecx
10810f: 89 f2 mov %esi,%edx
108111: 89 f8 mov %edi,%eax
108113: e8 88 fc ff ff call 107da0 <scangr>
108118: 83 c4 10 add $0x10,%esp
10811b: 85 c0 test %eax,%eax
10811d: 74 31 je 108150 <getgr_r+0x9c>
goto error_einval;
if (name) {
10811f: 85 db test %ebx,%ebx
108121: 75 c9 jne 1080ec <getgr_r+0x38>
match = (strcmp(grp->gr_name, name) == 0);
} else {
match = (grp->gr_gid == gid);
108123: 0f b7 46 08 movzwl 0x8(%esi),%eax
108127: 3b 45 e4 cmp -0x1c(%ebp),%eax
10812a: 0f 94 c0 sete %al
10812d: 0f b6 c0 movzbl %al,%eax
}
if (match) {
108130: 85 c0 test %eax,%eax
108132: 74 d2 je 108106 <getgr_r+0x52>
fclose(fp);
108134: 83 ec 0c sub $0xc,%esp
108137: 57 push %edi
108138: e8 07 ac 00 00 call 112d44 <fclose>
*result = grp;
10813d: 8b 45 10 mov 0x10(%ebp),%eax
108140: 89 30 mov %esi,(%eax)
return 0;
108142: 83 c4 10 add $0x10,%esp
108145: 31 c0 xor %eax,%eax
}
}
error_einval:
fclose(fp);
rtems_set_errno_and_return_minus_one( EINVAL );
}
108147: 8d 65 f4 lea -0xc(%ebp),%esp
10814a: 5b pop %ebx
10814b: 5e pop %esi
10814c: 5f pop %edi
10814d: c9 leave
10814e: c3 ret
10814f: 90 nop
*result = grp;
return 0;
}
}
error_einval:
fclose(fp);
108150: 83 ec 0c sub $0xc,%esp
108153: 57 push %edi
108154: e8 eb ab 00 00 call 112d44 <fclose>
rtems_set_errno_and_return_minus_one( EINVAL );
108159: e8 8e aa 00 00 call 112bec <__errno>
10815e: c7 00 16 00 00 00 movl $0x16,(%eax)
108164: 83 c4 10 add $0x10,%esp
108167: b8 ff ff ff ff mov $0xffffffff,%eax
}
10816c: 8d 65 f4 lea -0xc(%ebp),%esp
10816f: 5b pop %ebx
108170: 5e pop %esi
108171: 5f pop %edi
108172: c9 leave
108173: c3 ret
int match;
init_etc_passwd_group();
if ((fp = fopen("/etc/group", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
108174: e8 73 aa 00 00 call 112bec <__errno>
108179: c7 00 16 00 00 00 movl $0x16,(%eax)
10817f: 83 c8 ff or $0xffffffff,%eax
108182: eb c3 jmp 108147 <getgr_r+0x93>
001083d8 <getgrnam>:
}
struct group *getgrnam(
const char *name
)
{
1083d8: 55 push %ebp
1083d9: 89 e5 mov %esp,%ebp
1083db: 83 ec 24 sub $0x24,%esp
struct group *p;
if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p))
1083de: 8d 45 f4 lea -0xc(%ebp),%eax
1083e1: 50 push %eax
1083e2: 68 c8 00 00 00 push $0xc8
1083e7: 68 c0 6f 12 00 push $0x126fc0
1083ec: 68 a4 6f 12 00 push $0x126fa4
1083f1: ff 75 08 pushl 0x8(%ebp)
1083f4: e8 b3 ff ff ff call 1083ac <getgrnam_r>
1083f9: 83 c4 20 add $0x20,%esp
1083fc: 85 c0 test %eax,%eax
1083fe: 75 08 jne 108408 <getgrnam+0x30>
return NULL;
return p;
108400: 8b 45 f4 mov -0xc(%ebp),%eax
}
108403: c9 leave
108404: c3 ret
108405: 8d 76 00 lea 0x0(%esi),%esi
)
{
struct group *p;
if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p))
return NULL;
108408: 31 c0 xor %eax,%eax
return p;
}
10840a: c9 leave
10840b: c3 ret
00107b78 <getlogin_r>:
*/
int getlogin_r(
char *name,
size_t namesize
)
{
107b78: 55 push %ebp
107b79: 89 e5 mov %esp,%ebp
107b7b: 53 push %ebx
107b7c: 83 ec 04 sub $0x4,%esp
107b7f: 8b 5d 08 mov 0x8(%ebp),%ebx
struct passwd *pw;
char *pname;
if ( !name )
107b82: 85 db test %ebx,%ebx
107b84: 74 42 je 107bc8 <getlogin_r+0x50>
return EFAULT;
if ( namesize < LOGIN_NAME_MAX )
107b86: 83 7d 0c 08 cmpl $0x8,0xc(%ebp)
107b8a: 77 0c ja 107b98 <getlogin_r+0x20>
return ERANGE;
107b8c: b8 22 00 00 00 mov $0x22,%eax
if ( pw )
pname = pw->pw_name;
strncpy( name, pname, LOGIN_NAME_MAX );
return 0;
}
107b91: 8b 5d fc mov -0x4(%ebp),%ebx
107b94: c9 leave
107b95: c3 ret
107b96: 66 90 xchg %ax,%ax
return ERANGE;
/* Set the pointer to a default name */
pname = "";
pw = getpwuid(getuid());
107b98: e8 e7 09 00 00 call 108584 <getuid>
107b9d: 83 ec 0c sub $0xc,%esp
107ba0: 0f b7 c0 movzwl %ax,%eax
107ba3: 50 push %eax
107ba4: e8 37 07 00 00 call 1082e0 <getpwuid>
if ( pw )
107ba9: 83 c4 10 add $0x10,%esp
107bac: 85 c0 test %eax,%eax
107bae: 74 20 je 107bd0 <getlogin_r+0x58>
pname = pw->pw_name;
107bb0: 8b 00 mov (%eax),%eax
strncpy( name, pname, LOGIN_NAME_MAX );
107bb2: 52 push %edx
107bb3: 6a 09 push $0x9
107bb5: 50 push %eax
107bb6: 53 push %ebx
107bb7: e8 80 c8 00 00 call 11443c <strncpy>
return 0;
107bbc: 83 c4 10 add $0x10,%esp
107bbf: 31 c0 xor %eax,%eax
}
107bc1: 8b 5d fc mov -0x4(%ebp),%ebx
107bc4: c9 leave
107bc5: c3 ret
107bc6: 66 90 xchg %ax,%ax
{
struct passwd *pw;
char *pname;
if ( !name )
return EFAULT;
107bc8: b8 0e 00 00 00 mov $0xe,%eax
107bcd: eb c2 jmp 107b91 <getlogin_r+0x19>
107bcf: 90 nop
if ( namesize < LOGIN_NAME_MAX )
return ERANGE;
/* Set the pointer to a default name */
pname = "";
107bd0: b8 e9 17 12 00 mov $0x1217e9,%eax
107bd5: eb db jmp 107bb2 <getlogin_r+0x3a>
00108184 <getpw_r>:
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
108184: 55 push %ebp
108185: 89 e5 mov %esp,%ebp
108187: 57 push %edi
108188: 56 push %esi
108189: 53 push %ebx
10818a: 83 ec 1c sub $0x1c,%esp
10818d: 89 c3 mov %eax,%ebx
10818f: 89 55 e4 mov %edx,-0x1c(%ebp)
108192: 89 ce mov %ecx,%esi
FILE *fp;
int match;
init_etc_passwd_group();
108194: e8 1b fe ff ff call 107fb4 <init_etc_passwd_group>
if ((fp = fopen("/etc/passwd", "r")) == NULL)
108199: 83 ec 08 sub $0x8,%esp
10819c: 68 d2 02 12 00 push $0x1202d2
1081a1: 68 8d 16 12 00 push $0x12168d
1081a6: e8 9d b2 00 00 call 113448 <fopen>
1081ab: 89 c7 mov %eax,%edi
1081ad: 83 c4 10 add $0x10,%esp
1081b0: 85 c0 test %eax,%eax
1081b2: 75 22 jne 1081d6 <getpw_r+0x52>
1081b4: e9 8b 00 00 00 jmp 108244 <getpw_r+0xc0>
1081b9: 8d 76 00 lea 0x0(%esi),%esi
for(;;) {
if (!scanpw(fp, pwd, buffer, bufsize))
goto error_einval;
if (name) {
match = (strcmp(pwd->pw_name, name) == 0);
1081bc: 83 ec 08 sub $0x8,%esp
1081bf: 53 push %ebx
1081c0: ff 36 pushl (%esi)
1081c2: e8 f5 c0 00 00 call 1142bc <strcmp>
1081c7: 83 c4 10 add $0x10,%esp
1081ca: 85 c0 test %eax,%eax
1081cc: 0f 94 c0 sete %al
1081cf: 0f b6 c0 movzbl %al,%eax
} else {
match = (pwd->pw_uid == uid);
}
if (match) {
1081d2: 85 c0 test %eax,%eax
1081d4: 75 2e jne 108204 <getpw_r+0x80>
if ((fp = fopen("/etc/passwd", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
for(;;) {
if (!scanpw(fp, pwd, buffer, bufsize))
1081d6: 83 ec 0c sub $0xc,%esp
1081d9: ff 75 0c pushl 0xc(%ebp)
1081dc: 8b 4d 08 mov 0x8(%ebp),%ecx
1081df: 89 f2 mov %esi,%edx
1081e1: 89 f8 mov %edi,%eax
1081e3: e8 d0 fc ff ff call 107eb8 <scanpw>
1081e8: 83 c4 10 add $0x10,%esp
1081eb: 85 c0 test %eax,%eax
1081ed: 74 31 je 108220 <getpw_r+0x9c>
goto error_einval;
if (name) {
1081ef: 85 db test %ebx,%ebx
1081f1: 75 c9 jne 1081bc <getpw_r+0x38>
match = (strcmp(pwd->pw_name, name) == 0);
} else {
match = (pwd->pw_uid == uid);
1081f3: 0f b7 46 08 movzwl 0x8(%esi),%eax
1081f7: 3b 45 e4 cmp -0x1c(%ebp),%eax
1081fa: 0f 94 c0 sete %al
1081fd: 0f b6 c0 movzbl %al,%eax
}
if (match) {
108200: 85 c0 test %eax,%eax
108202: 74 d2 je 1081d6 <getpw_r+0x52>
fclose(fp);
108204: 83 ec 0c sub $0xc,%esp
108207: 57 push %edi
108208: e8 37 ab 00 00 call 112d44 <fclose>
*result = pwd;
10820d: 8b 45 10 mov 0x10(%ebp),%eax
108210: 89 30 mov %esi,(%eax)
return 0;
108212: 83 c4 10 add $0x10,%esp
108215: 31 c0 xor %eax,%eax
}
}
error_einval:
fclose(fp);
rtems_set_errno_and_return_minus_one( EINVAL );
}
108217: 8d 65 f4 lea -0xc(%ebp),%esp
10821a: 5b pop %ebx
10821b: 5e pop %esi
10821c: 5f pop %edi
10821d: c9 leave
10821e: c3 ret
10821f: 90 nop
*result = pwd;
return 0;
}
}
error_einval:
fclose(fp);
108220: 83 ec 0c sub $0xc,%esp
108223: 57 push %edi
108224: e8 1b ab 00 00 call 112d44 <fclose>
rtems_set_errno_and_return_minus_one( EINVAL );
108229: e8 be a9 00 00 call 112bec <__errno>
10822e: c7 00 16 00 00 00 movl $0x16,(%eax)
108234: 83 c4 10 add $0x10,%esp
108237: b8 ff ff ff ff mov $0xffffffff,%eax
}
10823c: 8d 65 f4 lea -0xc(%ebp),%esp
10823f: 5b pop %ebx
108240: 5e pop %esi
108241: 5f pop %edi
108242: c9 leave
108243: c3 ret
int match;
init_etc_passwd_group();
if ((fp = fopen("/etc/passwd", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
108244: e8 a3 a9 00 00 call 112bec <__errno>
108249: c7 00 16 00 00 00 movl $0x16,(%eax)
10824f: 83 c8 ff or $0xffffffff,%eax
108252: eb c3 jmp 108217 <getpw_r+0x93>
00108280 <getpwnam>:
}
struct passwd *getpwnam(
const char *name
)
{
108280: 55 push %ebp
108281: 89 e5 mov %esp,%ebp
108283: 83 ec 24 sub $0x24,%esp
struct passwd *p;
if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p))
108286: 8d 45 f4 lea -0xc(%ebp),%eax
108289: 50 push %eax
10828a: 68 c8 00 00 00 push $0xc8
10828f: 68 c0 70 12 00 push $0x1270c0
108294: 68 8c 70 12 00 push $0x12708c
108299: ff 75 08 pushl 0x8(%ebp)
10829c: e8 b3 ff ff ff call 108254 <getpwnam_r>
1082a1: 83 c4 20 add $0x20,%esp
1082a4: 85 c0 test %eax,%eax
1082a6: 75 08 jne 1082b0 <getpwnam+0x30>
return NULL;
return p;
1082a8: 8b 45 f4 mov -0xc(%ebp),%eax
}
1082ab: c9 leave
1082ac: c3 ret
1082ad: 8d 76 00 lea 0x0(%esi),%esi
)
{
struct passwd *p;
if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p))
return NULL;
1082b0: 31 c0 xor %eax,%eax
return p;
}
1082b2: c9 leave
1082b3: c3 ret
001076b0 <gettimeofday>:
*/
int gettimeofday(
struct timeval *tp,
void * __tz __attribute__((unused))
)
{
1076b0: 55 push %ebp
1076b1: 89 e5 mov %esp,%ebp
1076b3: 56 push %esi
1076b4: 53 push %ebx
1076b5: 83 ec 10 sub $0x10,%esp
1076b8: 8b 5d 08 mov 0x8(%ebp),%ebx
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp )
1076bb: 85 db test %ebx,%ebx
1076bd: 74 39 je 1076f8 <gettimeofday+0x48> <== NEVER TAKEN
{
ISR_Level level;
struct timespec now;
suseconds_t useconds;
_ISR_Disable(level);
1076bf: 9c pushf
1076c0: fa cli
1076c1: 5e pop %esi
_TOD_Get( &now );
1076c2: 83 ec 0c sub $0xc,%esp
1076c5: 8d 45 f0 lea -0x10(%ebp),%eax
1076c8: 50 push %eax
1076c9: e8 32 41 00 00 call 10b800 <_TOD_Get>
_ISR_Enable(level);
1076ce: 56 push %esi
1076cf: 9d popf
useconds = (suseconds_t)now.tv_nsec;
1076d0: 8b 4d f4 mov -0xc(%ebp),%ecx
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
1076d3: 8b 45 f0 mov -0x10(%ebp),%eax
1076d6: 89 03 mov %eax,(%ebx)
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
1076d8: b8 d3 4d 62 10 mov $0x10624dd3,%eax
1076dd: f7 e9 imul %ecx
1076df: 89 d0 mov %edx,%eax
1076e1: c1 f8 06 sar $0x6,%eax
1076e4: c1 f9 1f sar $0x1f,%ecx
1076e7: 29 c8 sub %ecx,%eax
1076e9: 89 43 04 mov %eax,0x4(%ebx)
* Timezone information ignored by the OS proper. Per email
* with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X
* do it. This puts us in good company.
*/
return 0;
1076ec: 83 c4 10 add $0x10,%esp
1076ef: 31 c0 xor %eax,%eax
}
1076f1: 8d 65 f8 lea -0x8(%ebp),%esp
1076f4: 5b pop %ebx
1076f5: 5e pop %esi
1076f6: c9 leave
1076f7: c3 ret
void * __tz __attribute__((unused))
)
{
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp )
rtems_set_errno_and_return_minus_one( EFAULT );
1076f8: e8 df a6 00 00 call 111ddc <__errno> <== NOT EXECUTED
1076fd: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED
107703: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
107708: eb e7 jmp 1076f1 <gettimeofday+0x41> <== NOT EXECUTED
001115b4 <imfs_dir_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
1115b4: 55 push %ebp
1115b5: 89 e5 mov %esp,%ebp
1115b7: 8b 45 08 mov 0x8(%ebp),%eax
IMFS_jnode_t *the_jnode;
/* Is the node a directory ? */
the_jnode = (IMFS_jnode_t *) iop->pathinfo.node_access;
if ( the_jnode->type != IMFS_DIRECTORY )
1115ba: 8b 50 18 mov 0x18(%eax),%edx
1115bd: 83 7a 4c 01 cmpl $0x1,0x4c(%edx)
1115c1: 74 09 je 1115cc <imfs_dir_open+0x18> <== ALWAYS TAKEN
return -1; /* It wasn't a directory --> return error */
1115c3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
iop->offset = 0;
return 0;
}
1115c8: c9 leave <== NOT EXECUTED
1115c9: c3 ret <== NOT EXECUTED
1115ca: 66 90 xchg %ax,%ax <== NOT EXECUTED
the_jnode = (IMFS_jnode_t *) iop->pathinfo.node_access;
if ( the_jnode->type != IMFS_DIRECTORY )
return -1; /* It wasn't a directory --> return error */
iop->offset = 0;
1115cc: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
1115d3: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
return 0;
1115da: 31 c0 xor %eax,%eax
}
1115dc: c9 leave
1115dd: c3 ret
001115e0 <imfs_dir_read>:
ssize_t imfs_dir_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
1115e0: 55 push %ebp
1115e1: 89 e5 mov %esp,%ebp
1115e3: 57 push %edi
1115e4: 56 push %esi
1115e5: 53 push %ebx
1115e6: 81 ec 4c 01 00 00 sub $0x14c,%esp
int current_entry;
int first_entry;
int last_entry;
struct dirent tmp_dirent;
the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access;
1115ec: 8b 55 08 mov 0x8(%ebp),%edx
1115ef: 8b 42 18 mov 0x18(%edx),%eax
IMFS_create_orphan( the_jnode );
IMFS_check_node_remove( the_jnode );
return 0;
}
1115f2: 8b 58 50 mov 0x50(%eax),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
1115f5: 83 c0 54 add $0x54,%eax
1115f8: 89 85 cc fe ff ff mov %eax,-0x134(%ebp)
struct dirent tmp_dirent;
the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access;
the_chain = &the_jnode->info.directory.Entries;
if ( rtems_chain_is_empty( the_chain ) )
1115fe: 39 c3 cmp %eax,%ebx
111600: 0f 84 2a 01 00 00 je 111730 <imfs_dir_read+0x150>
/* Move to the first of the desired directory entries */
the_node = rtems_chain_first( the_chain );
bytes_transferred = 0;
first_entry = iop->offset;
111606: 8b 42 0c mov 0xc(%edx),%eax
111609: 89 85 d4 fe ff ff mov %eax,-0x12c(%ebp)
/* protect against using sizes that are not exact multiples of the */
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
11160f: ba f1 f0 f0 f0 mov $0xf0f0f0f1,%edx
111614: 8b 45 10 mov 0x10(%ebp),%eax
111617: f7 e2 mul %edx
111619: c1 ea 08 shr $0x8,%edx
11161c: 89 d0 mov %edx,%eax
11161e: c1 e0 04 shl $0x4,%eax
111621: c1 e2 08 shl $0x8,%edx
111624: 8d 14 10 lea (%eax,%edx,1),%edx
111627: 03 95 d4 fe ff ff add -0x12c(%ebp),%edx
11162d: 89 95 d0 fe ff ff mov %edx,-0x130(%ebp)
/* The directory was not empty so try to move to the desired entry in chain*/
for (
111633: 85 d2 test %edx,%edx
111635: 0f 8e f5 00 00 00 jle 111730 <imfs_dir_read+0x150> <== NEVER TAKEN
11163b: 31 d2 xor %edx,%edx
11163d: c7 85 c8 fe ff ff 00 movl $0x0,-0x138(%ebp)
111644: 00 00 00
tmp_dirent.d_off = current_entry;
tmp_dirent.d_reclen = sizeof( struct dirent );
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
tmp_dirent.d_namlen = strlen( the_jnode->name );
strcpy( tmp_dirent.d_name, the_jnode->name );
111647: 8d 85 d8 fe ff ff lea -0x128(%ebp),%eax
11164d: 89 85 b4 fe ff ff mov %eax,-0x14c(%ebp)
111653: eb 23 jmp 111678 <imfs_dir_read+0x98>
111655: 8d 76 00 lea 0x0(%esi),%esi
);
iop->offset = iop->offset + sizeof(struct dirent);
bytes_transferred = bytes_transferred + sizeof( struct dirent );
}
the_node = the_node->next;
111658: 8b 1b mov (%ebx),%ebx
* to the end of the exisiting file, the remaining entries will be placed in
* the buffer and the returned value will be equal to -m actual- times the
* size of a directory entry.
*/
ssize_t imfs_dir_read(
11165a: 81 c2 10 01 00 00 add $0x110,%edx
/* protect against using sizes that are not exact multiples of the */
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
/* The directory was not empty so try to move to the desired entry in chain*/
for (
111660: 39 95 d0 fe ff ff cmp %edx,-0x130(%ebp)
111666: 0f 8e b4 00 00 00 jle 111720 <imfs_dir_read+0x140> <== NEVER TAKEN
current_entry = 0;
current_entry < last_entry;
current_entry = current_entry + sizeof(struct dirent) ){
if ( rtems_chain_is_tail( the_chain, the_node ) ){
11166c: 3b 9d cc fe ff ff cmp -0x134(%ebp),%ebx
111672: 0f 84 a8 00 00 00 je 111720 <imfs_dir_read+0x140>
/* entry in the read */
return bytes_transferred; /* Indicate that there are no more */
/* entries to return */
}
if( current_entry >= first_entry ) {
111678: 39 95 d4 fe ff ff cmp %edx,-0x12c(%ebp)
11167e: 7f d8 jg 111658 <imfs_dir_read+0x78>
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
111680: 89 95 dc fe ff ff mov %edx,-0x124(%ebp)
111686: 89 d0 mov %edx,%eax
111688: c1 f8 1f sar $0x1f,%eax
11168b: 89 85 e0 fe ff ff mov %eax,-0x120(%ebp)
tmp_dirent.d_reclen = sizeof( struct dirent );
111691: 66 c7 85 e4 fe ff ff movw $0x110,-0x11c(%ebp)
111698: 10 01
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
11169a: 8b 43 38 mov 0x38(%ebx),%eax
11169d: 89 85 d8 fe ff ff mov %eax,-0x128(%ebp)
tmp_dirent.d_namlen = strlen( the_jnode->name );
1116a3: 8d 73 0c lea 0xc(%ebx),%esi
1116a6: 31 c0 xor %eax,%eax
1116a8: b9 ff ff ff ff mov $0xffffffff,%ecx
1116ad: 89 f7 mov %esi,%edi
1116af: f2 ae repnz scas %es:(%edi),%al
1116b1: f7 d1 not %ecx
1116b3: 49 dec %ecx
1116b4: 66 89 8d e6 fe ff ff mov %cx,-0x11a(%ebp)
strcpy( tmp_dirent.d_name, the_jnode->name );
1116bb: 83 ec 08 sub $0x8,%esp
1116be: 56 push %esi
1116bf: 8d 85 e8 fe ff ff lea -0x118(%ebp),%eax
1116c5: 50 push %eax
1116c6: 89 95 c4 fe ff ff mov %edx,-0x13c(%ebp)
1116cc: e8 d3 13 00 00 call 112aa4 <strcpy>
memcpy(
1116d1: 8b 45 0c mov 0xc(%ebp),%eax
1116d4: 03 85 c8 fe ff ff add -0x138(%ebp),%eax
1116da: b9 44 00 00 00 mov $0x44,%ecx
1116df: 89 c7 mov %eax,%edi
1116e1: 8b b5 b4 fe ff ff mov -0x14c(%ebp),%esi
1116e7: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
buffer + bytes_transferred,
(void *)&tmp_dirent,
sizeof( struct dirent )
);
iop->offset = iop->offset + sizeof(struct dirent);
1116e9: 8b 45 08 mov 0x8(%ebp),%eax
1116ec: 81 40 0c 10 01 00 00 addl $0x110,0xc(%eax)
1116f3: 83 50 10 00 adcl $0x0,0x10(%eax)
bytes_transferred = bytes_transferred + sizeof( struct dirent );
1116f7: 81 85 c8 fe ff ff 10 addl $0x110,-0x138(%ebp)
1116fe: 01 00 00
111701: 83 c4 10 add $0x10,%esp
111704: 8b 95 c4 fe ff ff mov -0x13c(%ebp),%edx
}
the_node = the_node->next;
11170a: 8b 1b mov (%ebx),%ebx
* to the end of the exisiting file, the remaining entries will be placed in
* the buffer and the returned value will be equal to -m actual- times the
* size of a directory entry.
*/
ssize_t imfs_dir_read(
11170c: 81 c2 10 01 00 00 add $0x110,%edx
/* protect against using sizes that are not exact multiples of the */
/* -dirent- size. These could result in unexpected results */
last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent);
/* The directory was not empty so try to move to the desired entry in chain*/
for (
111712: 39 95 d0 fe ff ff cmp %edx,-0x130(%ebp)
111718: 0f 8f 4e ff ff ff jg 11166c <imfs_dir_read+0x8c> <== NEVER TAKEN
11171e: 66 90 xchg %ax,%ax
current_entry = 0;
current_entry < last_entry;
current_entry = current_entry + sizeof(struct dirent) ){
if ( rtems_chain_is_tail( the_chain, the_node ) ){
111720: 8b 85 c8 fe ff ff mov -0x138(%ebp),%eax
the_node = the_node->next;
}
/* Success */
return bytes_transferred;
}
111726: 8d 65 f4 lea -0xc(%ebp),%esp
111729: 5b pop %ebx
11172a: 5e pop %esi
11172b: 5f pop %edi
11172c: c9 leave
11172d: c3 ret
11172e: 66 90 xchg %ax,%ax
the_jnode = (IMFS_jnode_t *)iop->pathinfo.node_access;
the_chain = &the_jnode->info.directory.Entries;
if ( rtems_chain_is_empty( the_chain ) )
return 0;
111730: 31 c0 xor %eax,%eax
the_node = the_node->next;
}
/* Success */
return bytes_transferred;
}
111732: 8d 65 f4 lea -0xc(%ebp),%esp
111735: 5b pop %ebx
111736: 5e pop %esi
111737: 5f pop %edi
111738: c9 leave
111739: c3 ret
0011186c <imfs_dir_rmnod>:
int imfs_dir_rmnod(
rtems_filesystem_location_info_t *parent_pathloc, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
11186c: 55 push %ebp
11186d: 89 e5 mov %esp,%ebp
11186f: 53 push %ebx
111870: 83 ec 04 sub $0x4,%esp
111873: 8b 45 0c mov 0xc(%ebp),%eax
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
111876: 8b 18 mov (%eax),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
111878: 8d 53 54 lea 0x54(%ebx),%edx
/*
* You cannot remove a node that still has children
*/
if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) )
11187b: 39 53 50 cmp %edx,0x50(%ebx)
11187e: 75 44 jne 1118c4 <imfs_dir_rmnod+0x58>
/*
* You cannot remove the file system root node.
*/
if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access )
111880: 8b 40 10 mov 0x10(%eax),%eax
111883: 3b 58 1c cmp 0x1c(%eax),%ebx
111886: 74 24 je 1118ac <imfs_dir_rmnod+0x40>
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
111888: 8b 4b 5c mov 0x5c(%ebx),%ecx
11188b: 85 c9 test %ecx,%ecx
11188d: 75 1d jne 1118ac <imfs_dir_rmnod+0x40> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EBUSY );
IMFS_create_orphan( the_jnode );
11188f: 83 ec 0c sub $0xc,%esp
111892: 53 push %ebx
111893: e8 bc d5 ff ff call 10ee54 <IMFS_create_orphan>
IMFS_check_node_remove( the_jnode );
111898: 89 1c 24 mov %ebx,(%esp)
11189b: e8 f8 d5 ff ff call 10ee98 <IMFS_check_node_remove>
return 0;
1118a0: 83 c4 10 add $0x10,%esp
1118a3: 31 c0 xor %eax,%eax
}
1118a5: 8b 5d fc mov -0x4(%ebp),%ebx
1118a8: c9 leave
1118a9: c3 ret
1118aa: 66 90 xchg %ax,%ax
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
rtems_set_errno_and_return_minus_one( EBUSY );
1118ac: e8 2b 05 00 00 call 111ddc <__errno>
1118b1: c7 00 10 00 00 00 movl $0x10,(%eax)
1118b7: b8 ff ff ff ff mov $0xffffffff,%eax
IMFS_create_orphan( the_jnode );
IMFS_check_node_remove( the_jnode );
return 0;
}
1118bc: 8b 5d fc mov -0x4(%ebp),%ebx
1118bf: c9 leave
1118c0: c3 ret
1118c1: 8d 76 00 lea 0x0(%esi),%esi
/*
* You cannot remove a node that still has children
*/
if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) )
rtems_set_errno_and_return_minus_one( ENOTEMPTY );
1118c4: e8 13 05 00 00 call 111ddc <__errno>
1118c9: c7 00 5a 00 00 00 movl $0x5a,(%eax)
1118cf: b8 ff ff ff ff mov $0xffffffff,%eax
1118d4: eb cf jmp 1118a5 <imfs_dir_rmnod+0x39>
00107fb4 <init_etc_passwd_group>:
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
107fb4: 55 push %ebp
107fb5: 89 e5 mov %esp,%ebp
107fb7: 53 push %ebx
107fb8: 83 ec 04 sub $0x4,%esp
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
107fbb: 80 3d 88 71 12 00 00 cmpb $0x0,0x127188
107fc2: 74 08 je 107fcc <init_etc_passwd_group+0x18>
fprintf( fp, "root:x:0:root\n"
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
}
}
107fc4: 8b 5d fc mov -0x4(%ebp),%ebx
107fc7: c9 leave
107fc8: c3 ret
107fc9: 8d 76 00 lea 0x0(%esi),%esi
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
107fcc: c6 05 88 71 12 00 01 movb $0x1,0x127188
mkdir("/etc", 0777);
107fd3: 83 ec 08 sub $0x8,%esp
107fd6: 68 ff 01 00 00 push $0x1ff
107fdb: 68 88 16 12 00 push $0x121688
107fe0: e8 37 08 00 00 call 10881c <mkdir>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
107fe5: 59 pop %ecx
107fe6: 5b pop %ebx
107fe7: 68 d2 02 12 00 push $0x1202d2
107fec: 68 8d 16 12 00 push $0x12168d
107ff1: e8 52 b4 00 00 call 113448 <fopen>
107ff6: 83 c4 10 add $0x10,%esp
107ff9: 85 c0 test %eax,%eax
107ffb: 74 77 je 108074 <init_etc_passwd_group+0xc0>
fclose(fp);
107ffd: 83 ec 0c sub $0xc,%esp
108000: 50 push %eax
108001: e8 3e ad 00 00 call 112d44 <fclose>
108006: 83 c4 10 add $0x10,%esp
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
108009: 83 ec 08 sub $0x8,%esp
10800c: 68 d2 02 12 00 push $0x1202d2
108011: 68 99 16 12 00 push $0x121699
108016: e8 2d b4 00 00 call 113448 <fopen>
10801b: 83 c4 10 add $0x10,%esp
10801e: 85 c0 test %eax,%eax
108020: 74 12 je 108034 <init_etc_passwd_group+0x80>
fclose(fp);
108022: 83 ec 0c sub $0xc,%esp
108025: 50 push %eax
108026: e8 19 ad 00 00 call 112d44 <fclose>
10802b: 83 c4 10 add $0x10,%esp
fprintf( fp, "root:x:0:root\n"
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
}
}
10802e: 8b 5d fc mov -0x4(%ebp),%ebx
108031: c9 leave
108032: c3 ret
108033: 90 nop
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
fclose(fp);
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
108034: 83 ec 08 sub $0x8,%esp
108037: 68 b4 01 12 00 push $0x1201b4
10803c: 68 99 16 12 00 push $0x121699
108041: e8 02 b4 00 00 call 113448 <fopen>
108046: 89 c3 mov %eax,%ebx
108048: 83 c4 10 add $0x10,%esp
10804b: 85 c0 test %eax,%eax
10804d: 0f 84 71 ff ff ff je 107fc4 <init_etc_passwd_group+0x10><== NEVER TAKEN
fprintf( fp, "root:x:0:root\n"
108053: 50 push %eax
108054: 6a 2a push $0x2a
108056: 6a 01 push $0x1
108058: 68 0c 17 12 00 push $0x12170c
10805d: e8 ba bb 00 00 call 113c1c <fwrite>
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
108062: 89 1c 24 mov %ebx,(%esp)
108065: e8 da ac 00 00 call 112d44 <fclose>
10806a: 83 c4 10 add $0x10,%esp
10806d: e9 52 ff ff ff jmp 107fc4 <init_etc_passwd_group+0x10>
108072: 66 90 xchg %ax,%ax
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
fclose(fp);
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
108074: 83 ec 08 sub $0x8,%esp
108077: 68 b4 01 12 00 push $0x1201b4
10807c: 68 8d 16 12 00 push $0x12168d
108081: e8 c2 b3 00 00 call 113448 <fopen>
108086: 89 c3 mov %eax,%ebx
108088: 83 c4 10 add $0x10,%esp
10808b: 85 c0 test %eax,%eax
10808d: 0f 84 76 ff ff ff je 108009 <init_etc_passwd_group+0x55><== NEVER TAKEN
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
108093: 50 push %eax
108094: 6a 66 push $0x66
108096: 6a 01 push $0x1
108098: 68 a4 16 12 00 push $0x1216a4
10809d: e8 7a bb 00 00 call 113c1c <fwrite>
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
1080a2: 89 1c 24 mov %ebx,(%esp)
1080a5: e8 9a ac 00 00 call 112d44 <fclose>
1080aa: 83 c4 10 add $0x10,%esp
1080ad: e9 57 ff ff ff jmp 108009 <init_etc_passwd_group+0x55>
00109514 <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
109514: 55 push %ebp
109515: 89 e5 mov %esp,%ebp
109517: 56 push %esi
109518: 53 push %ebx
109519: 89 d6 mov %edx,%esi
10951b: 88 c3 mov %al,%bl
if (tty->termios.c_iflag & ISTRIP)
10951d: 8b 42 30 mov 0x30(%edx),%eax
109520: a8 20 test $0x20,%al
109522: 74 03 je 109527 <iproc+0x13> <== ALWAYS TAKEN
c &= 0x7f;
109524: 83 e3 7f and $0x7f,%ebx <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
109527: f6 c4 02 test $0x2,%ah
10952a: 74 18 je 109544 <iproc+0x30>
c = tolower (c);
10952c: 0f b6 db movzbl %bl,%ebx
10952f: 8b 15 54 42 12 00 mov 0x124254,%edx
109535: 0f be 54 1a 01 movsbl 0x1(%edx,%ebx,1),%edx
10953a: 83 e2 03 and $0x3,%edx
10953d: 4a dec %edx
10953e: 0f 84 9c 00 00 00 je 1095e0 <iproc+0xcc>
if (c == '\r') {
109544: 80 fb 0d cmp $0xd,%bl
109547: 74 33 je 10957c <iproc+0x68>
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
109549: 80 fb 0a cmp $0xa,%bl
10954c: 0f 84 86 00 00 00 je 1095d8 <iproc+0xc4>
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
109552: 84 db test %bl,%bl
109554: 75 3a jne 109590 <iproc+0x7c> <== ALWAYS TAKEN
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
109556: 8b 46 20 mov 0x20(%esi),%eax
109559: 8b 15 a0 41 12 00 mov 0x1241a0,%edx
10955f: 4a dec %edx
109560: 39 d0 cmp %edx,%eax
109562: 7d 1c jge 109580 <iproc+0x6c> <== NEVER TAKEN
if (tty->termios.c_lflag & ECHO)
109564: f6 46 3c 08 testb $0x8,0x3c(%esi)
109568: 75 7e jne 1095e8 <iproc+0xd4> <== ALWAYS TAKEN
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
10956a: 8b 56 1c mov 0x1c(%esi),%edx
10956d: 88 1c 02 mov %bl,(%edx,%eax,1)
109570: 40 inc %eax
109571: 89 46 20 mov %eax,0x20(%esi)
}
return 0;
109574: 31 c0 xor %eax,%eax
}
109576: 5b pop %ebx
109577: 5e pop %esi
109578: c9 leave
109579: c3 ret
10957a: 66 90 xchg %ax,%ax
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
10957c: a8 80 test $0x80,%al
10957e: 74 08 je 109588 <iproc+0x74> <== ALWAYS TAKEN
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
109580: 31 c0 xor %eax,%eax
}
109582: 5b pop %ebx <== NOT EXECUTED
109583: 5e pop %esi <== NOT EXECUTED
109584: c9 leave <== NOT EXECUTED
109585: c3 ret <== NOT EXECUTED
109586: 66 90 xchg %ax,%ax <== NOT EXECUTED
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
109588: f6 c4 01 test $0x1,%ah
10958b: 74 03 je 109590 <iproc+0x7c> <== NEVER TAKEN
c = '\n';
10958d: b3 0a mov $0xa,%bl
10958f: 90 nop
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
109590: 8b 46 3c mov 0x3c(%esi),%eax
109593: a8 02 test $0x2,%al
109595: 74 bf je 109556 <iproc+0x42>
if (c == tty->termios.c_cc[VERASE]) {
109597: 38 5e 43 cmp %bl,0x43(%esi)
10959a: 0f 84 b0 00 00 00 je 109650 <iproc+0x13c>
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
1095a0: 38 5e 44 cmp %bl,0x44(%esi)
1095a3: 74 63 je 109608 <iproc+0xf4>
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
1095a5: 38 5e 45 cmp %bl,0x45(%esi)
1095a8: 0f 84 96 00 00 00 je 109644 <iproc+0x130> <== NEVER TAKEN
return 1;
} else if (c == '\n') {
1095ae: 80 fb 0a cmp $0xa,%bl
1095b1: 74 69 je 10961c <iproc+0x108>
if (tty->termios.c_lflag & (ECHO | ECHONL))
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
1095b3: 38 5e 4c cmp %bl,0x4c(%esi)
1095b6: 74 05 je 1095bd <iproc+0xa9> <== NEVER TAKEN
1095b8: 38 5e 51 cmp %bl,0x51(%esi)
1095bb: 75 99 jne 109556 <iproc+0x42> <== ALWAYS TAKEN
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
1095bd: a8 08 test $0x8,%al <== NOT EXECUTED
1095bf: 75 3b jne 1095fc <iproc+0xe8> <== NOT EXECUTED
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
1095c1: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED
1095c4: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED
1095c7: 88 1c 02 mov %bl,(%edx,%eax,1) <== NOT EXECUTED
1095ca: 40 inc %eax <== NOT EXECUTED
1095cb: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED
return 1;
1095ce: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
1095d3: eb a1 jmp 109576 <iproc+0x62> <== NOT EXECUTED
1095d5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
1095d8: a8 40 test $0x40,%al
1095da: 74 b4 je 109590 <iproc+0x7c> <== ALWAYS TAKEN
c = '\r';
1095dc: b3 0d mov $0xd,%bl <== NOT EXECUTED
1095de: eb b0 jmp 109590 <iproc+0x7c> <== NOT EXECUTED
{
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
1095e0: 83 c3 20 add $0x20,%ebx
1095e3: e9 5c ff ff ff jmp 109544 <iproc+0x30>
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
1095e8: 0f b6 c3 movzbl %bl,%eax
1095eb: 89 f2 mov %esi,%edx
1095ed: e8 f2 fc ff ff call 1092e4 <echo>
1095f2: 8b 46 20 mov 0x20(%esi),%eax
1095f5: e9 70 ff ff ff jmp 10956a <iproc+0x56>
1095fa: 66 90 xchg %ax,%ax
tty->cbuf[tty->ccount++] = c;
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
1095fc: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED
1095ff: 89 f2 mov %esi,%edx <== NOT EXECUTED
109601: e8 de fc ff ff call 1092e4 <echo> <== NOT EXECUTED
109606: eb b9 jmp 1095c1 <iproc+0xad> <== NOT EXECUTED
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
109608: ba 01 00 00 00 mov $0x1,%edx
10960d: 89 f0 mov %esi,%eax
10960f: e8 34 fd ff ff call 109348 <erase>
return 0;
109614: 31 c0 xor %eax,%eax
109616: e9 5b ff ff ff jmp 109576 <iproc+0x62>
10961b: 90 nop
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
} else if (c == '\n') {
if (tty->termios.c_lflag & (ECHO | ECHONL))
10961c: a8 48 test $0x48,%al
10961e: 74 0c je 10962c <iproc+0x118> <== NEVER TAKEN
echo (c, tty);
109620: 89 f2 mov %esi,%edx
109622: b8 0a 00 00 00 mov $0xa,%eax
109627: e8 b8 fc ff ff call 1092e4 <echo>
tty->cbuf[tty->ccount++] = c;
10962c: 8b 46 20 mov 0x20(%esi),%eax
10962f: 8b 56 1c mov 0x1c(%esi),%edx
109632: c6 04 02 0a movb $0xa,(%edx,%eax,1)
109636: 40 inc %eax
109637: 89 46 20 mov %eax,0x20(%esi)
return 1;
10963a: b8 01 00 00 00 mov $0x1,%eax
10963f: e9 32 ff ff ff jmp 109576 <iproc+0x62>
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
109644: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
109649: e9 28 ff ff ff jmp 109576 <iproc+0x62> <== NOT EXECUTED
10964e: 66 90 xchg %ax,%ax <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
109650: 31 d2 xor %edx,%edx
109652: 89 f0 mov %esi,%eax
109654: e8 ef fc ff ff call 109348 <erase>
return 0;
109659: 31 c0 xor %eax,%eax
10965b: e9 16 ff ff ff jmp 109576 <iproc+0x62>
001231d8 <kill>:
* These are directly supported (and completely correct) in the posix api.
*/
#if !defined(RTEMS_POSIX_API)
int kill( pid_t pid, int sig )
{
1231d8: 55 push %ebp <== NOT EXECUTED
1231d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return 0;
}
1231db: 31 c0 xor %eax,%eax <== NOT EXECUTED
1231dd: c9 leave <== NOT EXECUTED
1231de: c3 ret <== NOT EXECUTED
0011dcf4 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
11dcf4: 55 push %ebp
11dcf5: 89 e5 mov %esp,%ebp
11dcf7: 53 push %ebx
11dcf8: 83 ec 04 sub $0x4,%esp
/*
* In case RTEMS is already down, don't do this. It could be
* dangerous.
*/
if (!_System_state_Is_up(_System_state_Get()))
11dcfb: 83 3d 80 66 12 00 03 cmpl $0x3,0x126680
11dd02: 74 08 je 11dd0c <libc_wrapup+0x18> <== ALWAYS TAKEN
*/
fclose (stdin);
fclose (stdout);
fclose (stderr);
}
11dd04: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
11dd07: c9 leave <== NOT EXECUTED
11dd08: c3 ret <== NOT EXECUTED
11dd09: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != _global_impure_ptr) {
11dd0c: a1 60 42 12 00 mov 0x124260,%eax
11dd11: 8b 1d 60 07 12 00 mov 0x120760,%ebx
11dd17: 39 d8 cmp %ebx,%eax
11dd19: 74 14 je 11dd2f <libc_wrapup+0x3b>
_wrapup_reent(_global_impure_ptr);
11dd1b: 83 ec 0c sub $0xc,%esp
11dd1e: 53 push %ebx
11dd1f: e8 f8 05 00 00 call 11e31c <_wrapup_reent>
/* Don't reclaim this one, just in case we do printfs
* on the way out to ROM.
*/
_reclaim_reent(&libc_global_reent);
#endif
_REENT = _global_impure_ptr;
11dd24: 89 1d 60 42 12 00 mov %ebx,0x124260
11dd2a: 83 c4 10 add $0x10,%esp
11dd2d: 89 d8 mov %ebx,%eax
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
11dd2f: 83 ec 0c sub $0xc,%esp
11dd32: ff 70 04 pushl 0x4(%eax)
11dd35: e8 fa 41 ff ff call 111f34 <fclose>
fclose (stdout);
11dd3a: 5a pop %edx
11dd3b: a1 60 42 12 00 mov 0x124260,%eax
11dd40: ff 70 08 pushl 0x8(%eax)
11dd43: e8 ec 41 ff ff call 111f34 <fclose>
fclose (stderr);
11dd48: 58 pop %eax
11dd49: a1 60 42 12 00 mov 0x124260,%eax
11dd4e: ff 70 0c pushl 0xc(%eax)
11dd51: e8 de 41 ff ff call 111f34 <fclose>
11dd56: 83 c4 10 add $0x10,%esp
}
11dd59: 8b 5d fc mov -0x4(%ebp),%ebx
11dd5c: c9 leave
11dd5d: c3 ret
0010aae8 <link>:
int link(
const char *existing,
const char *new
)
{
10aae8: 55 push %ebp
10aae9: 89 e5 mov %esp,%ebp
10aaeb: 57 push %edi
10aaec: 56 push %esi
10aaed: 53 push %ebx
10aaee: 83 ec 58 sub $0x58,%esp
10aaf1: 8b 55 08 mov 0x8(%ebp),%edx
10aaf4: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Get the node we are linking to.
*/
result = rtems_filesystem_evaluate_path( existing, strlen( existing ),
10aaf7: 31 c0 xor %eax,%eax
10aaf9: b9 ff ff ff ff mov $0xffffffff,%ecx
10aafe: 89 d7 mov %edx,%edi
10ab00: f2 ae repnz scas %es:(%edi),%al
10ab02: f7 d1 not %ecx
10ab04: 49 dec %ecx
10ab05: 6a 01 push $0x1
10ab07: 8d 75 cc lea -0x34(%ebp),%esi
10ab0a: 56 push %esi
10ab0b: 6a 00 push $0x0
10ab0d: 51 push %ecx
10ab0e: 52 push %edx
10ab0f: e8 28 f9 ff ff call 10a43c <rtems_filesystem_evaluate_path>
0, &existing_loc, true );
if ( result != 0 )
10ab14: 83 c4 20 add $0x20,%esp
10ab17: 85 c0 test %eax,%eax
10ab19: 74 0d je 10ab28 <link+0x40>
return -1;
10ab1b: b8 ff ff ff ff mov $0xffffffff,%eax
rtems_filesystem_freenode( &existing_loc );
rtems_filesystem_freenode( &parent_loc );
return result;
}
10ab20: 8d 65 f4 lea -0xc(%ebp),%esp
10ab23: 5b pop %ebx
10ab24: 5e pop %esi
10ab25: 5f pop %edi
10ab26: c9 leave
10ab27: c3 ret
/*
* Get the parent of the node we are creating.
*/
rtems_filesystem_get_start_loc( new, &i, &parent_loc );
10ab28: 52 push %edx
10ab29: 8d 7d b8 lea -0x48(%ebp),%edi
10ab2c: 57 push %edi
10ab2d: 8d 45 e4 lea -0x1c(%ebp),%eax
10ab30: 50 push %eax
10ab31: 53 push %ebx
10ab32: e8 1d 13 00 00 call 10be54 <rtems_filesystem_get_start_loc>
result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start );
10ab37: 83 c4 0c add $0xc,%esp
10ab3a: 8d 45 e0 lea -0x20(%ebp),%eax
10ab3d: 50 push %eax
10ab3e: 57 push %edi
10ab3f: 03 5d e4 add -0x1c(%ebp),%ebx
10ab42: 53 push %ebx
10ab43: 8b 45 c4 mov -0x3c(%ebp),%eax
10ab46: ff 50 04 call *0x4(%eax)
if ( result != 0 ) {
10ab49: 83 c4 10 add $0x10,%esp
10ab4c: 85 c0 test %eax,%eax
10ab4e: 75 61 jne 10abb1 <link+0xc9>
/*
* Check to see if the caller is trying to link across file system
* boundaries.
*/
if ( parent_loc.mt_entry != existing_loc.mt_entry ) {
10ab50: 8b 45 dc mov -0x24(%ebp),%eax
10ab53: 39 45 c8 cmp %eax,-0x38(%ebp)
10ab56: 75 30 jne 10ab88 <link+0xa0>
rtems_filesystem_freenode( &existing_loc );
rtems_filesystem_freenode( &parent_loc );
rtems_set_errno_and_return_minus_one( EXDEV );
}
result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start );
10ab58: 50 push %eax
10ab59: ff 75 e0 pushl -0x20(%ebp)
10ab5c: 57 push %edi
10ab5d: 56 push %esi
10ab5e: 8b 45 c4 mov -0x3c(%ebp),%eax
10ab61: ff 50 08 call *0x8(%eax)
rtems_filesystem_freenode( &existing_loc );
10ab64: 89 34 24 mov %esi,(%esp)
10ab67: 89 45 b4 mov %eax,-0x4c(%ebp)
10ab6a: e8 81 fb ff ff call 10a6f0 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &parent_loc );
10ab6f: 89 3c 24 mov %edi,(%esp)
10ab72: e8 79 fb ff ff call 10a6f0 <rtems_filesystem_freenode>
return result;
10ab77: 83 c4 10 add $0x10,%esp
10ab7a: 8b 45 b4 mov -0x4c(%ebp),%eax
}
10ab7d: 8d 65 f4 lea -0xc(%ebp),%esp
10ab80: 5b pop %ebx
10ab81: 5e pop %esi
10ab82: 5f pop %edi
10ab83: c9 leave
10ab84: c3 ret
10ab85: 8d 76 00 lea 0x0(%esi),%esi
* Check to see if the caller is trying to link across file system
* boundaries.
*/
if ( parent_loc.mt_entry != existing_loc.mt_entry ) {
rtems_filesystem_freenode( &existing_loc );
10ab88: 83 ec 0c sub $0xc,%esp
10ab8b: 56 push %esi
10ab8c: e8 5f fb ff ff call 10a6f0 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &parent_loc );
10ab91: 89 3c 24 mov %edi,(%esp)
10ab94: e8 57 fb ff ff call 10a6f0 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EXDEV );
10ab99: e8 ba ad 00 00 call 115958 <__errno>
10ab9e: c7 00 12 00 00 00 movl $0x12,(%eax)
10aba4: 83 c4 10 add $0x10,%esp
10aba7: b8 ff ff ff ff mov $0xffffffff,%eax
10abac: e9 6f ff ff ff jmp 10ab20 <link+0x38>
rtems_filesystem_get_start_loc( new, &i, &parent_loc );
result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start );
if ( result != 0 ) {
rtems_filesystem_freenode( &existing_loc );
10abb1: 83 ec 0c sub $0xc,%esp
10abb4: 56 push %esi
10abb5: e8 36 fb ff ff call 10a6f0 <rtems_filesystem_freenode>
return -1;
10abba: 83 c4 10 add $0x10,%esp
10abbd: b8 ff ff ff ff mov $0xffffffff,%eax
10abc2: e9 59 ff ff ff jmp 10ab20 <link+0x38>
0011dbcc <lseek>:
off_t lseek(
int fd,
off_t offset,
int whence
)
{
11dbcc: 55 push %ebp
11dbcd: 89 e5 mov %esp,%ebp
11dbcf: 57 push %edi
11dbd0: 56 push %esi
11dbd1: 53 push %ebx
11dbd2: 83 ec 1c sub $0x1c,%esp
11dbd5: 8b 5d 08 mov 0x8(%ebp),%ebx
11dbd8: 8b 55 0c mov 0xc(%ebp),%edx
11dbdb: 8b 4d 10 mov 0x10(%ebp),%ecx
11dbde: 8b 45 14 mov 0x14(%ebp),%eax
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
11dbe1: 3b 1d ec 21 12 00 cmp 0x1221ec,%ebx
11dbe7: 0f 83 b3 00 00 00 jae 11dca0 <lseek+0xd4>
iop = rtems_libio_iop( fd );
11dbed: 8d 34 dd 00 00 00 00 lea 0x0(,%ebx,8),%esi
11dbf4: 8d 1c f5 00 00 00 00 lea 0x0(,%esi,8),%ebx
11dbfb: 29 f3 sub %esi,%ebx
11dbfd: 03 1d 80 63 12 00 add 0x126380,%ebx
rtems_libio_check_is_open(iop);
11dc03: f6 43 15 01 testb $0x1,0x15(%ebx)
11dc07: 0f 84 93 00 00 00 je 11dca0 <lseek+0xd4>
/*
* Now process the lseek().
*/
old_offset = iop->offset;
11dc0d: 8b 73 0c mov 0xc(%ebx),%esi
11dc10: 8b 7b 10 mov 0x10(%ebx),%edi
11dc13: 89 75 e0 mov %esi,-0x20(%ebp)
11dc16: 89 7d e4 mov %edi,-0x1c(%ebp)
switch ( whence ) {
11dc19: 83 f8 01 cmp $0x1,%eax
11dc1c: 74 6e je 11dc8c <lseek+0xc0>
11dc1e: 83 f8 02 cmp $0x2,%eax
11dc21: 74 35 je 11dc58 <lseek+0x8c>
11dc23: 85 c0 test %eax,%eax
11dc25: 75 45 jne 11dc6c <lseek+0xa0>
case SEEK_SET:
iop->offset = offset;
11dc27: 89 53 0c mov %edx,0xc(%ebx)
11dc2a: 89 4b 10 mov %ecx,0x10(%ebx)
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
11dc2d: 8b 73 20 mov 0x20(%ebx),%esi
11dc30: 50 push %eax
11dc31: 51 push %ecx
11dc32: 52 push %edx
11dc33: 53 push %ebx
11dc34: ff 56 14 call *0x14(%esi)
if ( status == (off_t) -1 )
11dc37: 83 c4 10 add $0x10,%esp
11dc3a: 89 c1 mov %eax,%ecx
11dc3c: 21 d1 and %edx,%ecx
11dc3e: 41 inc %ecx
11dc3f: 75 0c jne 11dc4d <lseek+0x81>
iop->offset = old_offset;
11dc41: 8b 75 e0 mov -0x20(%ebp),%esi
11dc44: 8b 7d e4 mov -0x1c(%ebp),%edi
11dc47: 89 73 0c mov %esi,0xc(%ebx)
11dc4a: 89 7b 10 mov %edi,0x10(%ebx)
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
11dc4d: 8d 65 f4 lea -0xc(%ebp),%esp
11dc50: 5b pop %ebx
11dc51: 5e pop %esi
11dc52: 5f pop %edi
11dc53: c9 leave
11dc54: c3 ret
11dc55: 8d 76 00 lea 0x0(%esi),%esi
case SEEK_CUR:
iop->offset += offset;
break;
case SEEK_END:
iop->offset = iop->size + offset;
11dc58: 89 d6 mov %edx,%esi
11dc5a: 89 cf mov %ecx,%edi
11dc5c: 03 73 04 add 0x4(%ebx),%esi
11dc5f: 13 7b 08 adc 0x8(%ebx),%edi
11dc62: 89 73 0c mov %esi,0xc(%ebx)
11dc65: 89 7b 10 mov %edi,0x10(%ebx)
break;
11dc68: eb c3 jmp 11dc2d <lseek+0x61>
11dc6a: 66 90 xchg %ax,%ax
default:
rtems_set_errno_and_return_minus_one( EINVAL );
11dc6c: e8 6b 41 ff ff call 111ddc <__errno>
11dc71: c7 00 16 00 00 00 movl $0x16,(%eax)
11dc77: b8 ff ff ff ff mov $0xffffffff,%eax
11dc7c: ba ff ff ff ff mov $0xffffffff,%edx
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
11dc81: 8d 65 f4 lea -0xc(%ebp),%esp
11dc84: 5b pop %ebx
11dc85: 5e pop %esi
11dc86: 5f pop %edi
11dc87: c9 leave
11dc88: c3 ret
11dc89: 8d 76 00 lea 0x0(%esi),%esi
case SEEK_SET:
iop->offset = offset;
break;
case SEEK_CUR:
iop->offset += offset;
11dc8c: 8b 75 e0 mov -0x20(%ebp),%esi
11dc8f: 8b 7d e4 mov -0x1c(%ebp),%edi
11dc92: 01 d6 add %edx,%esi
11dc94: 11 cf adc %ecx,%edi
11dc96: 89 73 0c mov %esi,0xc(%ebx)
11dc99: 89 7b 10 mov %edi,0x10(%ebx)
break;
11dc9c: eb 8f jmp 11dc2d <lseek+0x61>
11dc9e: 66 90 xchg %ax,%ax
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
11dca0: e8 37 41 ff ff call 111ddc <__errno>
11dca5: c7 00 09 00 00 00 movl $0x9,(%eax)
11dcab: b8 ff ff ff ff mov $0xffffffff,%eax
11dcb0: ba ff ff ff ff mov $0xffffffff,%edx
11dcb5: eb 96 jmp 11dc4d <lseek+0x81>
0010933c <lstat>:
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
10933c: 55 push %ebp
10933d: 89 e5 mov %esp,%ebp
10933f: 57 push %edi
109340: 56 push %esi
109341: 53 push %ebx
109342: 83 ec 3c sub $0x3c,%esp
109345: 8b 55 08 mov 0x8(%ebp),%edx
109348: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
10934b: 85 f6 test %esi,%esi
10934d: 74 65 je 1093b4 <lstat+0x78>
rtems_set_errno_and_return_minus_one( EFAULT );
status = rtems_filesystem_evaluate_path( path, strlen( path ),
10934f: b9 ff ff ff ff mov $0xffffffff,%ecx
109354: 89 d7 mov %edx,%edi
109356: 31 c0 xor %eax,%eax
109358: f2 ae repnz scas %es:(%edi),%al
10935a: f7 d1 not %ecx
10935c: 49 dec %ecx
10935d: 83 ec 0c sub $0xc,%esp
109360: 6a 00 push $0x0
109362: 8d 5d d4 lea -0x2c(%ebp),%ebx
109365: 53 push %ebx
109366: 6a 00 push $0x0
109368: 51 push %ecx
109369: 52 push %edx
10936a: e8 05 fa ff ff call 108d74 <rtems_filesystem_evaluate_path>
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
10936f: 83 c4 20 add $0x20,%esp
109372: 85 c0 test %eax,%eax
109374: 74 0e je 109384 <lstat+0x48>
return -1;
109376: b8 ff ff ff ff mov $0xffffffff,%eax
status = (*loc.handlers->fstat_h)( &loc, buf );
rtems_filesystem_freenode( &loc );
return status;
}
10937b: 8d 65 f4 lea -0xc(%ebp),%esp
10937e: 5b pop %ebx
10937f: 5e pop %esi
109380: 5f pop %edi
109381: c9 leave
109382: c3 ret
109383: 90 nop
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
109384: b9 48 00 00 00 mov $0x48,%ecx
109389: 89 f7 mov %esi,%edi
10938b: f3 aa rep stos %al,%es:(%edi)
status = (*loc.handlers->fstat_h)( &loc, buf );
10938d: 83 ec 08 sub $0x8,%esp
109390: 56 push %esi
109391: 53 push %ebx
109392: 8b 45 dc mov -0x24(%ebp),%eax
109395: ff 50 18 call *0x18(%eax)
rtems_filesystem_freenode( &loc );
109398: 89 1c 24 mov %ebx,(%esp)
10939b: 89 45 c4 mov %eax,-0x3c(%ebp)
10939e: e8 a9 fa ff ff call 108e4c <rtems_filesystem_freenode>
return status;
1093a3: 83 c4 10 add $0x10,%esp
1093a6: 8b 45 c4 mov -0x3c(%ebp),%eax
}
1093a9: 8d 65 f4 lea -0xc(%ebp),%esp
1093ac: 5b pop %ebx
1093ad: 5e pop %esi
1093ae: 5f pop %edi
1093af: c9 leave
1093b0: c3 ret
1093b1: 8d 76 00 lea 0x0(%esi),%esi
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
rtems_set_errno_and_return_minus_one( EFAULT );
1093b4: e8 eb a5 00 00 call 1139a4 <__errno>
1093b9: c7 00 0e 00 00 00 movl $0xe,(%eax)
1093bf: b8 ff ff ff ff mov $0xffffffff,%eax
status = (*loc.handlers->fstat_h)( &loc, buf );
rtems_filesystem_freenode( &loc );
return status;
}
1093c4: 8d 65 f4 lea -0xc(%ebp),%esp
1093c7: 5b pop %ebx
1093c8: 5e pop %esi
1093c9: 5f pop %edi
1093ca: c9 leave
1093cb: c3 ret
00107908 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
107908: 55 push %ebp
107909: 89 e5 mov %esp,%ebp
10790b: 56 push %esi
10790c: 53 push %ebx
10790d: 8b 75 08 mov 0x8(%ebp),%esi
void *return_this;
MSBUMP(malloc_calls, 1);
107910: ff 05 a4 63 12 00 incl 0x1263a4
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
107916: e8 fd fe ff ff call 107818 <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
10791b: 85 f6 test %esi,%esi
10791d: 74 5d je 10797c <malloc+0x74>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
10791f: 83 3d 80 66 12 00 03 cmpl $0x3,0x126680
107926: 74 48 je 107970 <malloc+0x68>
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
107928: 6a 00 push $0x0
10792a: 6a 00 push $0x0
10792c: 56 push %esi
10792d: ff 35 30 22 12 00 pushl 0x122230
107933: e8 00 4b 00 00 call 10c438 <_Protected_heap_Allocate_aligned_with_boundary>
107938: 89 c3 mov %eax,%ebx
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
10793a: 83 c4 10 add $0x10,%esp
10793d: 85 c0 test %eax,%eax
10793f: 74 47 je 107988 <malloc+0x80>
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
107941: a1 b0 47 12 00 mov 0x1247b0,%eax
107946: 85 c0 test %eax,%eax
107948: 74 0a je 107954 <malloc+0x4c>
(*rtems_malloc_dirty_helper)( return_this, size );
10794a: 83 ec 08 sub $0x8,%esp
10794d: 56 push %esi
10794e: 53 push %ebx
10794f: ff d0 call *%eax
107951: 83 c4 10 add $0x10,%esp
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
107954: a1 a8 47 12 00 mov 0x1247a8,%eax
107959: 85 c0 test %eax,%eax
10795b: 74 0a je 107967 <malloc+0x5f>
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
10795d: 83 ec 0c sub $0xc,%esp
107960: 53 push %ebx
107961: ff 50 04 call *0x4(%eax)
107964: 83 c4 10 add $0x10,%esp
return return_this;
}
107967: 89 d8 mov %ebx,%eax
107969: 8d 65 f8 lea -0x8(%ebp),%esp
10796c: 5b pop %ebx
10796d: 5e pop %esi
10796e: c9 leave
10796f: c3 ret
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() )
107970: e8 63 fe ff ff call 1077d8 <malloc_is_system_state_OK>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
107975: 84 c0 test %al,%al
107977: 75 af jne 107928 <malloc+0x20> <== ALWAYS TAKEN
107979: 8d 76 00 lea 0x0(%esi),%esi
!malloc_is_system_state_OK() )
return NULL;
10797c: 31 db xor %ebx,%ebx
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
return return_this;
}
10797e: 89 d8 mov %ebx,%eax
107980: 8d 65 f8 lea -0x8(%ebp),%esp
107983: 5b pop %ebx
107984: 5e pop %esi
107985: c9 leave
107986: c3 ret
107987: 90 nop
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
if (rtems_malloc_sbrk_helpers)
107988: a1 ac 47 12 00 mov 0x1247ac,%eax
10798d: 85 c0 test %eax,%eax
10798f: 74 12 je 1079a3 <malloc+0x9b>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
107991: 83 ec 0c sub $0xc,%esp
107994: 56 push %esi
107995: ff 50 04 call *0x4(%eax)
if ( !return_this ) {
107998: 83 c4 10 add $0x10,%esp
10799b: 85 c0 test %eax,%eax
10799d: 74 04 je 1079a3 <malloc+0x9b>
10799f: 89 c3 mov %eax,%ebx
1079a1: eb 9e jmp 107941 <malloc+0x39>
errno = ENOMEM;
1079a3: e8 34 a4 00 00 call 111ddc <__errno>
1079a8: c7 00 0c 00 00 00 movl $0xc,(%eax)
return (void *) 0;
1079ae: eb b7 jmp 107967 <malloc+0x5f>
0010787c <malloc_get_statistics>:
#include "malloc_p.h"
int malloc_get_statistics(
rtems_malloc_statistics_t *stats
)
{
10787c: 55 push %ebp
10787d: 89 e5 mov %esp,%ebp
10787f: 57 push %edi
107880: 56 push %esi
107881: 53 push %ebx
107882: 83 ec 0c sub $0xc,%esp
107885: 8b 5d 08 mov 0x8(%ebp),%ebx
if ( !stats )
107888: 85 db test %ebx,%ebx
10788a: 74 38 je 1078c4 <malloc_get_statistics+0x48>
return -1;
_RTEMS_Lock_allocator();
10788c: 83 ec 0c sub $0xc,%esp
10788f: ff 35 00 55 12 00 pushl 0x125500
107895: e8 a2 3b 00 00 call 10b43c <_API_Mutex_Lock>
*stats = rtems_malloc_statistics;
10789a: be 00 53 12 00 mov $0x125300,%esi
10789f: b9 0b 00 00 00 mov $0xb,%ecx
1078a4: 89 df mov %ebx,%edi
1078a6: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_RTEMS_Unlock_allocator();
1078a8: 58 pop %eax
1078a9: ff 35 00 55 12 00 pushl 0x125500
1078af: e8 d0 3b 00 00 call 10b484 <_API_Mutex_Unlock>
return 0;
1078b4: 83 c4 10 add $0x10,%esp
1078b7: 31 c0 xor %eax,%eax
}
1078b9: 8d 65 f4 lea -0xc(%ebp),%esp
1078bc: 5b pop %ebx
1078bd: 5e pop %esi
1078be: 5f pop %edi
1078bf: c9 leave
1078c0: c3 ret
1078c1: 8d 76 00 lea 0x0(%esi),%esi
int malloc_get_statistics(
rtems_malloc_statistics_t *stats
)
{
if ( !stats )
return -1;
1078c4: b8 ff ff ff ff mov $0xffffffff,%eax
_RTEMS_Lock_allocator();
*stats = rtems_malloc_statistics;
_RTEMS_Unlock_allocator();
return 0;
}
1078c9: 8d 65 f4 lea -0xc(%ebp),%esp
1078cc: 5b pop %ebx
1078cd: 5e pop %esi
1078ce: 5f pop %edi
1078cf: c9 leave
1078d0: c3 ret
00107c9c <malloc_sbrk_extend_and_allocate>:
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
107c9c: 55 push %ebp
107c9d: 89 e5 mov %esp,%ebp
107c9f: 56 push %esi
107ca0: 53 push %ebx
107ca1: 8b 75 08 mov 0x8(%ebp),%esi
* Round to the "requested sbrk amount" so hopefully we won't have
* to grow again for a while. This effectively does sbrk() calls
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
107ca4: 8b 0d 8c 64 12 00 mov 0x12648c,%ecx
if ( sbrk_amount == 0 )
107caa: 85 c9 test %ecx,%ecx
107cac: 75 0a jne 107cb8 <malloc_sbrk_extend_and_allocate+0x1c><== ALWAYS TAKEN
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
starting_address = (void *) sbrk(the_size);
if ( starting_address == (void*) -1 )
return (void *) 0;
107cae: 31 c0 xor %eax,%eax
MSBUMP(space_available, the_size);
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
}
107cb0: 8d 65 f8 lea -0x8(%ebp),%esp
107cb3: 5b pop %ebx
107cb4: 5e pop %esi
107cb5: c9 leave
107cb6: c3 ret
107cb7: 90 nop
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
107cb8: 8d 04 0e lea (%esi,%ecx,1),%eax
107cbb: 31 d2 xor %edx,%edx
107cbd: f7 f1 div %ecx
107cbf: 89 c3 mov %eax,%ebx
107cc1: 0f af d9 imul %ecx,%ebx
starting_address = (void *) sbrk(the_size);
107cc4: 83 ec 0c sub $0xc,%esp
107cc7: 53 push %ebx
107cc8: e8 8f 87 ff ff call 10045c <sbrk>
if ( starting_address == (void*) -1 )
107ccd: 83 c4 10 add $0x10,%esp
107cd0: 83 f8 ff cmp $0xffffffff,%eax
107cd3: 74 d9 je 107cae <malloc_sbrk_extend_and_allocate+0x12>
return (void *) 0;
if ( !_Protected_heap_Extend(
107cd5: 52 push %edx
107cd6: 53 push %ebx
107cd7: 50 push %eax
107cd8: ff 35 90 21 12 00 pushl 0x122190
107cde: e8 91 4a 00 00 call 10c774 <_Protected_heap_Extend>
107ce3: 83 c4 10 add $0x10,%esp
107ce6: 84 c0 test %al,%al
107ce8: 74 1b je 107d05 <malloc_sbrk_extend_and_allocate+0x69>
sbrk(-the_size);
errno = ENOMEM;
return (void *) 0;
}
MSBUMP(space_available, the_size);
107cea: 01 1d 60 64 12 00 add %ebx,0x126460
107cf0: 6a 00 push $0x0
107cf2: 6a 00 push $0x0
107cf4: 56 push %esi
107cf5: ff 35 90 21 12 00 pushl 0x122190
107cfb: e8 3c 4a 00 00 call 10c73c <_Protected_heap_Allocate_aligned_with_boundary>
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
107d00: 83 c4 10 add $0x10,%esp
107d03: eb ab jmp 107cb0 <malloc_sbrk_extend_and_allocate+0x14>
if ( starting_address == (void*) -1 )
return (void *) 0;
if ( !_Protected_heap_Extend(
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
107d05: 83 ec 0c sub $0xc,%esp
107d08: f7 db neg %ebx
107d0a: 53 push %ebx
107d0b: e8 4c 87 ff ff call 10045c <sbrk>
errno = ENOMEM;
107d10: e8 bb a6 00 00 call 1123d0 <__errno>
107d15: c7 00 0c 00 00 00 movl $0xc,(%eax)
return (void *) 0;
107d1b: 83 c4 10 add $0x10,%esp
107d1e: 31 c0 xor %eax,%eax
107d20: eb 8e jmp 107cb0 <malloc_sbrk_extend_and_allocate+0x14>
00110d0c <memfile_free_blocks_in_table>:
*/
void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
110d0c: 55 push %ebp
110d0d: 89 e5 mov %esp,%ebp
110d0f: 57 push %edi
110d10: 56 push %esi
110d11: 53 push %ebx
110d12: 83 ec 0c sub $0xc,%esp
110d15: 8b 7d 0c mov 0xc(%ebp),%edi
IMFS_assert( block_table );
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
110d18: 8b 45 08 mov 0x8(%ebp),%eax
110d1b: 8b 30 mov (%eax),%esi
for ( i=0 ; i<entries ; i++ ) {
110d1d: 85 ff test %edi,%edi
110d1f: 7e 27 jle 110d48 <memfile_free_blocks_in_table+0x3c><== NEVER TAKEN
110d21: 31 db xor %ebx,%ebx
110d23: 90 nop
if ( b[i] ) {
110d24: 8b 04 9e mov (%esi,%ebx,4),%eax
110d27: 85 c0 test %eax,%eax
110d29: 74 13 je 110d3e <memfile_free_blocks_in_table+0x32>
memfile_free_block( b[i] );
110d2b: 83 ec 0c sub $0xc,%esp
110d2e: 50 push %eax
110d2f: e8 bc ff ff ff call 110cf0 <memfile_free_block>
b[i] = 0;
110d34: c7 04 9e 00 00 00 00 movl $0x0,(%esi,%ebx,4)
110d3b: 83 c4 10 add $0x10,%esp
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
110d3e: 43 inc %ebx
110d3f: 39 df cmp %ebx,%edi
110d41: 7f e1 jg 110d24 <memfile_free_blocks_in_table+0x18>
110d43: 8b 45 08 mov 0x8(%ebp),%eax
110d46: 8b 30 mov (%eax),%esi
/*
* Now that all the blocks in the block table are free, we can
* free the block table itself.
*/
memfile_free_block( *block_table );
110d48: 83 ec 0c sub $0xc,%esp
110d4b: 56 push %esi
110d4c: e8 9f ff ff ff call 110cf0 <memfile_free_block>
*block_table = 0;
110d51: 8b 45 08 mov 0x8(%ebp),%eax
110d54: c7 00 00 00 00 00 movl $0x0,(%eax)
110d5a: 83 c4 10 add $0x10,%esp
}
110d5d: 8d 65 f4 lea -0xc(%ebp),%esp
110d60: 5b pop %ebx
110d61: 5e pop %esi
110d62: 5f pop %edi
110d63: c9 leave
110d64: c3 ret
00111288 <memfile_ftruncate>:
*/
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
111288: 55 push %ebp
111289: 89 e5 mov %esp,%ebp
11128b: 53 push %ebx
11128c: 83 ec 14 sub $0x14,%esp
11128f: 8b 4d 08 mov 0x8(%ebp),%ecx
111292: 8b 45 0c mov 0xc(%ebp),%eax
111295: 8b 55 10 mov 0x10(%ebp),%edx
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
111298: 8b 59 18 mov 0x18(%ecx),%ebx
* POSIX 1003.1b does not specify what happens if you truncate a file
* and the new length is greater than the current size. We treat this
* as an extend operation.
*/
if ( length > the_jnode->info.file.size )
11129b: 39 53 54 cmp %edx,0x54(%ebx)
11129e: 7f 19 jg 1112b9 <memfile_ftruncate+0x31><== NEVER TAKEN
1112a0: 7d 12 jge 1112b4 <memfile_ftruncate+0x2c><== ALWAYS TAKEN
return IMFS_memfile_extend( the_jnode, length );
1112a2: 51 push %ecx
1112a3: 52 push %edx
1112a4: 50 push %eax
1112a5: 53 push %ebx
1112a6: e8 45 fc ff ff call 110ef0 <IMFS_memfile_extend>
1112ab: 83 c4 10 add $0x10,%esp
iop->size = the_jnode->info.file.size;
IMFS_update_atime( the_jnode );
return 0;
}
1112ae: 8b 5d fc mov -0x4(%ebp),%ebx
1112b1: c9 leave
1112b2: c3 ret
1112b3: 90 nop
* POSIX 1003.1b does not specify what happens if you truncate a file
* and the new length is greater than the current size. We treat this
* as an extend operation.
*/
if ( length > the_jnode->info.file.size )
1112b4: 39 43 50 cmp %eax,0x50(%ebx)
1112b7: 72 e9 jb 1112a2 <memfile_ftruncate+0x1a>
/*
* The in-memory files do not currently reclaim memory until the file is
* deleted. So we leave the previously allocated blocks in place for
* future use and just set the length.
*/
the_jnode->info.file.size = length;
1112b9: 89 43 50 mov %eax,0x50(%ebx)
1112bc: 89 53 54 mov %edx,0x54(%ebx)
iop->size = the_jnode->info.file.size;
1112bf: 89 41 04 mov %eax,0x4(%ecx)
1112c2: 89 51 08 mov %edx,0x8(%ecx)
IMFS_update_atime( the_jnode );
1112c5: 83 ec 08 sub $0x8,%esp
1112c8: 6a 00 push $0x0
1112ca: 8d 45 f0 lea -0x10(%ebp),%eax
1112cd: 50 push %eax
1112ce: e8 dd 63 ff ff call 1076b0 <gettimeofday>
1112d3: 8b 45 f0 mov -0x10(%ebp),%eax
1112d6: 89 43 40 mov %eax,0x40(%ebx)
return 0;
1112d9: 83 c4 10 add $0x10,%esp
1112dc: 31 c0 xor %eax,%eax
}
1112de: 8b 5d fc mov -0x4(%ebp),%ebx
1112e1: c9 leave
1112e2: c3 ret
001112e4 <memfile_lseek>:
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
1112e4: 55 push %ebp
1112e5: 89 e5 mov %esp,%ebp
1112e7: 57 push %edi
1112e8: 56 push %esi
1112e9: 53 push %ebx
1112ea: 83 ec 0c sub $0xc,%esp
1112ed: 8b 5d 08 mov 0x8(%ebp),%ebx
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
1112f0: 8b 73 18 mov 0x18(%ebx),%esi
if (the_jnode->type == IMFS_LINEAR_FILE) {
1112f3: 83 7e 4c 06 cmpl $0x6,0x4c(%esi)
1112f7: 74 2f je 111328 <memfile_lseek+0x44>
if (iop->offset > the_jnode->info.linearfile.size)
iop->offset = the_jnode->info.linearfile.size;
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
1112f9: 57 push %edi
1112fa: ff 73 10 pushl 0x10(%ebx)
1112fd: ff 73 0c pushl 0xc(%ebx)
111300: 56 push %esi
111301: e8 ea fb ff ff call 110ef0 <IMFS_memfile_extend>
111306: 83 c4 10 add $0x10,%esp
111309: 85 c0 test %eax,%eax
11130b: 75 45 jne 111352 <memfile_lseek+0x6e>
rtems_set_errno_and_return_minus_one( ENOSPC );
iop->size = the_jnode->info.file.size;
11130d: 8b 46 50 mov 0x50(%esi),%eax
111310: 8b 56 54 mov 0x54(%esi),%edx
111313: 89 43 04 mov %eax,0x4(%ebx)
111316: 89 53 08 mov %edx,0x8(%ebx)
111319: 8b 43 0c mov 0xc(%ebx),%eax
11131c: 8b 53 10 mov 0x10(%ebx),%edx
}
return iop->offset;
}
11131f: 8d 65 f4 lea -0xc(%ebp),%esp
111322: 5b pop %ebx
111323: 5e pop %esi
111324: 5f pop %edi
111325: c9 leave
111326: c3 ret
111327: 90 nop
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
if (the_jnode->type == IMFS_LINEAR_FILE) {
if (iop->offset > the_jnode->info.linearfile.size)
111328: 8b 43 0c mov 0xc(%ebx),%eax
11132b: 8b 53 10 mov 0x10(%ebx),%edx
11132e: 8b 7e 50 mov 0x50(%esi),%edi
111331: 8b 4e 54 mov 0x54(%esi),%ecx
111334: 39 ca cmp %ecx,%edx
111336: 7c e7 jl 11131f <memfile_lseek+0x3b> <== NEVER TAKEN
111338: 7e 12 jle 11134c <memfile_lseek+0x68> <== ALWAYS TAKEN
iop->offset = the_jnode->info.linearfile.size;
11133a: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED
11133d: 89 4b 10 mov %ecx,0x10(%ebx) <== NOT EXECUTED
111340: 89 f8 mov %edi,%eax <== NOT EXECUTED
111342: 89 ca mov %ecx,%edx <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
iop->size = the_jnode->info.file.size;
}
return iop->offset;
}
111344: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
111347: 5b pop %ebx <== NOT EXECUTED
111348: 5e pop %esi <== NOT EXECUTED
111349: 5f pop %edi <== NOT EXECUTED
11134a: c9 leave <== NOT EXECUTED
11134b: c3 ret <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
if (the_jnode->type == IMFS_LINEAR_FILE) {
if (iop->offset > the_jnode->info.linearfile.size)
11134c: 39 f8 cmp %edi,%eax
11134e: 76 cf jbe 11131f <memfile_lseek+0x3b> <== ALWAYS TAKEN
111350: eb e8 jmp 11133a <memfile_lseek+0x56> <== NOT EXECUTED
iop->offset = the_jnode->info.linearfile.size;
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
rtems_set_errno_and_return_minus_one( ENOSPC );
111352: e8 85 0a 00 00 call 111ddc <__errno>
111357: c7 00 1c 00 00 00 movl $0x1c,(%eax)
11135d: b8 ff ff ff ff mov $0xffffffff,%eax
111362: ba ff ff ff ff mov $0xffffffff,%edx
111367: eb b6 jmp 11131f <memfile_lseek+0x3b>
001111e0 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
1111e0: 55 push %ebp
1111e1: 89 e5 mov %esp,%ebp
1111e3: 56 push %esi
1111e4: 53 push %ebx
1111e5: 8b 5d 08 mov 0x8(%ebp),%ebx
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
1111e8: 8b 73 18 mov 0x18(%ebx),%esi
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
1111eb: 8b 43 14 mov 0x14(%ebx),%eax
1111ee: a9 04 02 00 00 test $0x204,%eax
1111f3: 74 06 je 1111fb <memfile_open+0x1b>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
1111f5: 83 7e 4c 06 cmpl $0x6,0x4c(%esi)
1111f9: 74 2d je 111228 <memfile_open+0x48> <== NEVER TAKEN
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
1111fb: 8b 56 50 mov 0x50(%esi),%edx
1111fe: 8b 4e 54 mov 0x54(%esi),%ecx
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
111201: f6 c4 02 test $0x2,%ah
111204: 75 12 jne 111218 <memfile_open+0x38>
iop->offset = the_jnode->info.file.size;
iop->size = the_jnode->info.file.size;
111206: 89 53 04 mov %edx,0x4(%ebx)
111209: 89 4b 08 mov %ecx,0x8(%ebx)
return 0;
11120c: 31 c0 xor %eax,%eax
}
11120e: 8d 65 f8 lea -0x8(%ebp),%esp
111211: 5b pop %ebx
111212: 5e pop %esi
111213: c9 leave
111214: c3 ret
111215: 8d 76 00 lea 0x0(%esi),%esi
if ((count != 0)
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
iop->offset = the_jnode->info.file.size;
111218: 89 53 0c mov %edx,0xc(%ebx)
11121b: 89 4b 10 mov %ecx,0x10(%ebx)
11121e: 8b 56 50 mov 0x50(%esi),%edx
111221: 8b 4e 54 mov 0x54(%esi),%ecx
111224: eb e0 jmp 111206 <memfile_open+0x26>
111226: 66 90 xchg %ax,%ax
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
111228: 8b 46 50 mov 0x50(%esi),%eax <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
11122b: 8b 56 58 mov 0x58(%esi),%edx <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
11122e: c7 46 4c 05 00 00 00 movl $0x5,0x4c(%esi) <== NOT EXECUTED
the_jnode->info.file.size = 0;
111235: c7 46 50 00 00 00 00 movl $0x0,0x50(%esi) <== NOT EXECUTED
11123c: c7 46 54 00 00 00 00 movl $0x0,0x54(%esi) <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
111243: c7 46 58 00 00 00 00 movl $0x0,0x58(%esi) <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
11124a: c7 46 5c 00 00 00 00 movl $0x0,0x5c(%esi) <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
111251: c7 46 60 00 00 00 00 movl $0x0,0x60(%esi) <== NOT EXECUTED
if ((count != 0)
111258: 85 c0 test %eax,%eax <== NOT EXECUTED
11125a: 75 09 jne 111265 <memfile_open+0x85> <== NOT EXECUTED
11125c: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED
11125f: 31 d2 xor %edx,%edx <== NOT EXECUTED
111261: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
111263: eb 9c jmp 111201 <memfile_open+0x21> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
111265: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
111268: 50 push %eax <== NOT EXECUTED
111269: 52 push %edx <== NOT EXECUTED
11126a: 6a 00 push $0x0 <== NOT EXECUTED
11126c: 6a 00 push $0x0 <== NOT EXECUTED
11126e: 56 push %esi <== NOT EXECUTED
11126f: e8 94 fd ff ff call 111008 <IMFS_memfile_write> <== NOT EXECUTED
111274: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
111277: 40 inc %eax <== NOT EXECUTED
111278: 74 08 je 111282 <memfile_open+0xa2> <== NOT EXECUTED
11127a: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED
11127d: e9 79 ff ff ff jmp 1111fb <memfile_open+0x1b> <== NOT EXECUTED
return -1;
111282: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
111285: eb 87 jmp 11120e <memfile_open+0x2e> <== NOT EXECUTED
001079cc <mknod>:
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
1079cc: 55 push %ebp
1079cd: 89 e5 mov %esp,%ebp
1079cf: 57 push %edi
1079d0: 56 push %esi
1079d1: 53 push %ebx
1079d2: 83 ec 3c sub $0x3c,%esp
1079d5: 8b 7d 08 mov 0x8(%ebp),%edi
1079d8: 8b 5d 0c mov 0xc(%ebp),%ebx
1079db: 8b 55 10 mov 0x10(%ebp),%edx
1079de: 8b 4d 14 mov 0x14(%ebp),%ecx
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
1079e1: 89 d8 mov %ebx,%eax
1079e3: 25 00 f0 00 00 and $0xf000,%eax
1079e8: 3d 00 40 00 00 cmp $0x4000,%eax
1079ed: 74 39 je 107a28 <mknod+0x5c>
1079ef: 76 27 jbe 107a18 <mknod+0x4c>
1079f1: 3d 00 60 00 00 cmp $0x6000,%eax
1079f6: 74 30 je 107a28 <mknod+0x5c>
1079f8: 3d 00 80 00 00 cmp $0x8000,%eax
1079fd: 74 29 je 107a28 <mknod+0x5c> <== ALWAYS TAKEN
case S_IFBLK:
case S_IFREG:
case S_IFIFO:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
1079ff: e8 d8 a3 00 00 call 111ddc <__errno>
107a04: c7 00 16 00 00 00 movl $0x16,(%eax)
107a0a: b8 ff ff ff ff mov $0xffffffff,%eax
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
rtems_filesystem_freenode( &temp_loc );
return result;
}
107a0f: 8d 65 f4 lea -0xc(%ebp),%esp
107a12: 5b pop %ebx
107a13: 5e pop %esi
107a14: 5f pop %edi
107a15: c9 leave
107a16: c3 ret
107a17: 90 nop
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
107a18: 3d 00 10 00 00 cmp $0x1000,%eax
107a1d: 74 09 je 107a28 <mknod+0x5c>
107a1f: 3d 00 20 00 00 cmp $0x2000,%eax
107a24: 75 d9 jne 1079ff <mknod+0x33>
107a26: 66 90 xchg %ax,%ax
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
107a28: 50 push %eax
107a29: 8d 75 cc lea -0x34(%ebp),%esi
107a2c: 56 push %esi
107a2d: 8d 45 e4 lea -0x1c(%ebp),%eax
107a30: 50 push %eax
107a31: 57 push %edi
107a32: 89 55 c4 mov %edx,-0x3c(%ebp)
107a35: 89 4d c0 mov %ecx,-0x40(%ebp)
107a38: e8 1f 0a 00 00 call 10845c <rtems_filesystem_get_start_loc>
result = (*temp_loc.ops->evalformake_h)(
107a3d: 83 c4 0c add $0xc,%esp
107a40: 8d 45 e0 lea -0x20(%ebp),%eax
107a43: 50 push %eax
107a44: 56 push %esi
107a45: 03 7d e4 add -0x1c(%ebp),%edi
107a48: 57 push %edi
107a49: 8b 45 d8 mov -0x28(%ebp),%eax
107a4c: ff 50 04 call *0x4(%eax)
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
107a4f: 83 c4 10 add $0x10,%esp
107a52: 85 c0 test %eax,%eax
107a54: 8b 55 c4 mov -0x3c(%ebp),%edx
107a57: 8b 4d c0 mov -0x40(%ebp),%ecx
107a5a: 74 10 je 107a6c <mknod+0xa0>
return -1;
107a5c: b8 ff ff ff ff mov $0xffffffff,%eax
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
rtems_filesystem_freenode( &temp_loc );
return result;
}
107a61: 8d 65 f4 lea -0xc(%ebp),%esp
107a64: 5b pop %ebx
107a65: 5e pop %esi
107a66: 5f pop %edi
107a67: c9 leave
107a68: c3 ret
107a69: 8d 76 00 lea 0x0(%esi),%esi
&name_start
);
if ( result != 0 )
return -1;
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
107a6c: 83 ec 0c sub $0xc,%esp
107a6f: 56 push %esi
107a70: 51 push %ecx
107a71: 52 push %edx
107a72: 53 push %ebx
107a73: ff 75 e0 pushl -0x20(%ebp)
107a76: 8b 45 d8 mov -0x28(%ebp),%eax
107a79: ff 50 14 call *0x14(%eax)
rtems_filesystem_freenode( &temp_loc );
107a7c: 83 c4 14 add $0x14,%esp
107a7f: 56 push %esi
107a80: 89 45 c4 mov %eax,-0x3c(%ebp)
107a83: e8 98 fb ff ff call 107620 <rtems_filesystem_freenode>
return result;
107a88: 83 c4 10 add $0x10,%esp
107a8b: 8b 45 c4 mov -0x3c(%ebp),%eax
}
107a8e: 8d 65 f4 lea -0xc(%ebp),%esp
107a91: 5b pop %ebx
107a92: 5e pop %esi
107a93: 5f pop %edi
107a94: c9 leave
107a95: c3 ret
00107b1c <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
107b1c: 55 push %ebp
107b1d: 89 e5 mov %esp,%ebp
107b1f: 57 push %edi
107b20: 56 push %esi
107b21: 53 push %ebx
107b22: 83 ec 4c sub $0x4c,%esp
107b25: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
107b28: 83 7d 14 01 cmpl $0x1,0x14(%ebp)
107b2c: 0f 87 36 02 00 00 ja 107d68 <mount+0x24c>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
107b32: 83 ec 0c sub $0xc,%esp
107b35: 56 push %esi
107b36: e8 dd 79 00 00 call 10f518 <rtems_filesystem_get_mount_handler>
107b3b: 89 45 b8 mov %eax,-0x48(%ebp)
if ( !mount_h )
107b3e: 83 c4 10 add $0x10,%esp
107b41: 85 c0 test %eax,%eax
107b43: 0f 84 1f 02 00 00 je 107d68 <mount+0x24c>
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
bool has_target = target != NULL;
107b49: 8b 45 0c mov 0xc(%ebp),%eax
107b4c: 85 c0 test %eax,%eax
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
107b4e: 0f 95 45 b7 setne -0x49(%ebp)
107b52: 0f 84 e8 01 00 00 je 107d40 <mount+0x224>
* 4) The mount point exists with the proper permissions to allow mounting
* 5) The selected mount point already has a file system mounted to it
*
*/
int mount(
107b58: 31 c0 xor %eax,%eax
107b5a: b9 ff ff ff ff mov $0xffffffff,%ecx
107b5f: 8b 7d 0c mov 0xc(%ebp),%edi
107b62: f2 ae repnz scas %es:(%edi),%al
107b64: f7 d1 not %ecx
107b66: 8d 41 ff lea -0x1(%ecx),%eax
107b69: 89 45 ac mov %eax,-0x54(%ebp)
107b6c: 89 4d bc mov %ecx,-0x44(%ebp)
107b6f: 8b 55 0c mov 0xc(%ebp),%edx
107b72: 89 55 b0 mov %edx,-0x50(%ebp)
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
107b75: ba ff ff ff ff mov $0xffffffff,%edx
107b7a: 31 c0 xor %eax,%eax
107b7c: 89 d1 mov %edx,%ecx
107b7e: 89 f7 mov %esi,%edi
107b80: f2 ae repnz scas %es:(%edi),%al
107b82: f7 d1 not %ecx
107b84: 89 4d c4 mov %ecx,-0x3c(%ebp)
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
107b87: 8b 7d 08 mov 0x8(%ebp),%edi
107b8a: 85 ff test %edi,%edi
107b8c: 0f 84 ca 01 00 00 je 107d5c <mount+0x240>
107b92: 89 d1 mov %edx,%ecx
107b94: 8b 7d 08 mov 0x8(%ebp),%edi
107b97: f2 ae repnz scas %es:(%edi),%al
107b99: f7 d1 not %ecx
107b9b: 89 4d c0 mov %ecx,-0x40(%ebp)
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
107b9e: 83 ec 08 sub $0x8,%esp
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
107ba1: 8b 55 bc mov -0x44(%ebp),%edx
107ba4: 8b 7d c4 mov -0x3c(%ebp),%edi
107ba7: 8d 44 3a 74 lea 0x74(%edx,%edi,1),%eax
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
107bab: 03 45 c0 add -0x40(%ebp),%eax
+ filesystemtype_size + source_size + target_size;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
107bae: 50 push %eax
107baf: 6a 01 push $0x1
107bb1: e8 ee f8 ff ff call 1074a4 <calloc>
107bb6: 89 c3 mov %eax,%ebx
if ( mt_entry != NULL ) {
107bb8: 83 c4 10 add $0x10,%esp
107bbb: 85 c0 test %eax,%eax
107bbd: 0f 84 65 01 00 00 je 107d28 <mount+0x20c> <== NEVER TAKEN
char *str = (char *) mt_entry + sizeof( *mt_entry );
107bc3: 8d 40 74 lea 0x74(%eax),%eax
memcpy( str, filesystemtype, filesystemtype_size );
107bc6: 89 c7 mov %eax,%edi
107bc8: 8b 4d c4 mov -0x3c(%ebp),%ecx
107bcb: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
107bcd: 89 fa mov %edi,%edx
mt_entry->type = str;
107bcf: 89 43 6c mov %eax,0x6c(%ebx)
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
107bd2: 8b 75 08 mov 0x8(%ebp),%esi
107bd5: 8b 4d c0 mov -0x40(%ebp),%ecx
107bd8: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
107bda: 89 f8 mov %edi,%eax
mt_entry->dev = str;
107bdc: 89 53 70 mov %edx,0x70(%ebx)
str += source_size;
memcpy( str, target, target_size );
107bdf: 8b 75 b0 mov -0x50(%ebp),%esi
107be2: 8b 4d bc mov -0x44(%ebp),%ecx
107be5: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
mt_entry->target = str;
107be7: 89 43 68 mov %eax,0x68(%ebx)
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
107bea: 89 5b 2c mov %ebx,0x2c(%ebx)
mt_entry->options = options;
107bed: 8b 45 14 mov 0x14(%ebp),%eax
107bf0: 89 43 30 mov %eax,0x30(%ebx)
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
107bf3: 8d 7b 38 lea 0x38(%ebx),%edi
107bf6: be c0 fd 11 00 mov $0x11fdc0,%esi
107bfb: b1 0c mov $0xc,%cl
107bfd: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
107bff: 80 7d b7 00 cmpb $0x0,-0x49(%ebp)
107c03: 0f 85 83 00 00 00 jne 107c8c <mount+0x170>
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
107c09: 81 3d 84 40 12 00 88 cmpl $0x124088,0x124084
107c10: 40 12 00
107c13: 0f 85 67 01 00 00 jne 107d80 <mount+0x264> <== NEVER TAKEN
)
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
107c19: 31 f6 xor %esi,%esi
* mt_point_node.node_access will be left to null to indicate that this
* is the root of the entire file system.
*/
}
if ( (*mount_h)( mt_entry, data ) ) {
107c1b: 83 ec 08 sub $0x8,%esp
107c1e: ff 75 18 pushl 0x18(%ebp)
107c21: 53 push %ebx
107c22: ff 55 b8 call *-0x48(%ebp)
107c25: 83 c4 10 add $0x10,%esp
107c28: 85 c0 test %eax,%eax
107c2a: 0f 85 74 01 00 00 jne 107da4 <mount+0x288>
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
107c30: 56 push %esi
107c31: 6a 00 push $0x0
107c33: 6a 00 push $0x0
107c35: ff 35 88 63 12 00 pushl 0x126388
107c3b: e8 68 2f 00 00 call 10aba8 <rtems_semaphore_obtain>
107c40: 5a pop %edx
107c41: 59 pop %ecx
107c42: 53 push %ebx
107c43: 68 84 40 12 00 push $0x124084
107c48: e8 37 38 00 00 call 10b484 <_Chain_Append>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
107c4d: 58 pop %eax
107c4e: ff 35 88 63 12 00 pushl 0x126388
107c54: e8 4b 30 00 00 call 10aca4 <rtems_semaphore_release>
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
107c59: 83 c4 10 add $0x10,%esp
107c5c: 80 7d b7 00 cmpb $0x0,-0x49(%ebp)
107c60: 74 0a je 107c6c <mount+0x150>
rtems_filesystem_root = mt_entry->mt_fs_root;
return 0;
107c62: 31 c0 xor %eax,%eax
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
}
107c64: 8d 65 f4 lea -0xc(%ebp),%esp
107c67: 5b pop %ebx
107c68: 5e pop %esi
107c69: 5f pop %edi
107c6a: c9 leave
107c6b: c3 ret
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
rtems_filesystem_root = mt_entry->mt_fs_root;
107c6c: 8b 3d b0 41 12 00 mov 0x1241b0,%edi
107c72: 83 c7 18 add $0x18,%edi
107c75: 8d 73 1c lea 0x1c(%ebx),%esi
107c78: b9 05 00 00 00 mov $0x5,%ecx
107c7d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return 0;
107c7f: 31 c0 xor %eax,%eax
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
}
107c81: 8d 65 f4 lea -0xc(%ebp),%esp
107c84: 5b pop %ebx
107c85: 5e pop %esi
107c86: 5f pop %edi
107c87: c9 leave
107c88: c3 ret
107c89: 8d 76 00 lea 0x0(%esi),%esi
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
107c8c: 83 ec 0c sub $0xc,%esp
107c8f: 6a 01 push $0x1
107c91: 8d 75 d4 lea -0x2c(%ebp),%esi
107c94: 56 push %esi
107c95: 6a 07 push $0x7
107c97: ff 75 ac pushl -0x54(%ebp)
107c9a: ff 75 0c pushl 0xc(%ebp)
107c9d: e8 a6 f8 ff ff call 107548 <rtems_filesystem_evaluate_path>
107ca2: 83 c4 20 add $0x20,%esp
107ca5: 40 inc %eax
107ca6: 0f 84 df 00 00 00 je 107d8b <mount+0x26f> <== NEVER TAKEN
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
107cac: 83 ec 0c sub $0xc,%esp
107caf: 56 push %esi
107cb0: 8b 45 e0 mov -0x20(%ebp),%eax
107cb3: ff 50 10 call *0x10(%eax)
107cb6: 83 c4 10 add $0x10,%esp
107cb9: 48 dec %eax
107cba: 0f 85 0c 01 00 00 jne 107dcc <mount+0x2b0>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
107cc0: 83 ec 08 sub $0x8,%esp
107cc3: ff 75 d4 pushl -0x2c(%ebp)
107cc6: 68 98 7a 10 00 push $0x107a98
107ccb: e8 dc fd ff ff call 107aac <rtems_filesystem_mount_iterate>
107cd0: 83 c4 10 add $0x10,%esp
107cd3: 84 c0 test %al,%al
107cd5: 0f 85 01 01 00 00 jne 107ddc <mount+0x2c0>
* may have been allocated in loc should not be sent to freenode
* until the system is unmounted. It may be needed to correctly
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
107cdb: 8b 45 d4 mov -0x2c(%ebp),%eax
107cde: 89 43 08 mov %eax,0x8(%ebx)
mt_entry->mt_point_node.handlers = loc.handlers;
107ce1: 8b 45 dc mov -0x24(%ebp),%eax
107ce4: 89 43 10 mov %eax,0x10(%ebx)
mt_entry->mt_point_node.ops = loc.ops;
107ce7: 8b 45 e0 mov -0x20(%ebp),%eax
107cea: 89 43 14 mov %eax,0x14(%ebx)
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
107ced: 8b 55 e4 mov -0x1c(%ebp),%edx
107cf0: 89 53 18 mov %edx,0x18(%ebx)
/*
* This link to the parent is only done when we are dealing with system
* below the base file system
*/
if ( loc.ops->mount_h( mt_entry ) ) {
107cf3: 83 ec 0c sub $0xc,%esp
107cf6: 53 push %ebx
107cf7: ff 50 20 call *0x20(%eax)
107cfa: 83 c4 10 add $0x10,%esp
107cfd: 85 c0 test %eax,%eax
107cff: 0f 84 16 ff ff ff je 107c1b <mount+0xff> <== ALWAYS TAKEN
return 0;
cleanup_and_bail:
free( mt_entry );
107d05: 83 ec 0c sub $0xc,%esp
107d08: 53 push %ebx
107d09: e8 26 f9 ff ff call 107634 <free>
107d0e: 83 c4 10 add $0x10,%esp
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
107d11: 83 ec 0c sub $0xc,%esp
107d14: 56 push %esi
107d15: e8 06 f9 ff ff call 107620 <rtems_filesystem_freenode>
107d1a: 83 c4 10 add $0x10,%esp
return -1;
107d1d: b8 ff ff ff ff mov $0xffffffff,%eax
107d22: e9 3d ff ff ff jmp 107c64 <mount+0x148>
107d27: 90 nop
target,
filesystemtype,
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
107d28: e8 af a0 00 00 call 111ddc <__errno> <== NOT EXECUTED
107d2d: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
107d33: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
}
107d38: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
107d3b: 5b pop %ebx <== NOT EXECUTED
107d3c: 5e pop %esi <== NOT EXECUTED
107d3d: 5f pop %edi <== NOT EXECUTED
107d3e: c9 leave <== NOT EXECUTED
107d3f: c3 ret <== NOT EXECUTED
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
107d40: c7 45 bc 02 00 00 00 movl $0x2,-0x44(%ebp)
107d47: c7 45 ac 01 00 00 00 movl $0x1,-0x54(%ebp)
107d4e: c7 45 b0 67 fd 11 00 movl $0x11fd67,-0x50(%ebp)
107d55: e9 1b fe ff ff jmp 107b75 <mount+0x59>
107d5a: 66 90 xchg %ax,%ax
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
107d5c: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp)
107d63: e9 36 fe ff ff jmp 107b9e <mount+0x82>
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
if ( !mount_h )
rtems_set_errno_and_return_minus_one( EINVAL );
107d68: e8 6f a0 00 00 call 111ddc <__errno>
107d6d: c7 00 16 00 00 00 movl $0x16,(%eax)
107d73: b8 ff ff ff ff mov $0xffffffff,%eax
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
}
107d78: 8d 65 f4 lea -0xc(%ebp),%esp
107d7b: 5b pop %ebx
107d7c: 5e pop %esi
107d7d: 5f pop %edi
107d7e: c9 leave
107d7f: c3 ret
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
errno = EINVAL;
107d80: e8 57 a0 00 00 call 111ddc <__errno> <== NOT EXECUTED
107d85: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( mt_entry );
107d8b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107d8e: 53 push %ebx <== NOT EXECUTED
107d8f: e8 a0 f8 ff ff call 107634 <free> <== NOT EXECUTED
107d94: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
107d97: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
107d9c: e9 c3 fe ff ff jmp 107c64 <mount+0x148> <== NOT EXECUTED
107da1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if ( (*mount_h)( mt_entry, data ) ) {
/*
* Try to undo the mount operation
*/
loc.ops->unmount_h( mt_entry );
107da4: 83 ec 0c sub $0xc,%esp
107da7: 53 push %ebx
107da8: 8b 45 e0 mov -0x20(%ebp),%eax
107dab: ff 50 28 call *0x28(%eax)
return 0;
cleanup_and_bail:
free( mt_entry );
107dae: 89 1c 24 mov %ebx,(%esp)
107db1: e8 7e f8 ff ff call 107634 <free>
if ( loc_to_free )
107db6: 83 c4 10 add $0x10,%esp
107db9: 85 f6 test %esi,%esi
107dbb: 0f 85 50 ff ff ff jne 107d11 <mount+0x1f5> <== ALWAYS TAKEN
rtems_filesystem_freenode( loc_to_free );
return -1;
107dc1: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
107dc6: e9 99 fe ff ff jmp 107c64 <mount+0x148> <== NOT EXECUTED
107dcb: 90 nop <== NOT EXECUTED
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
errno = ENOTDIR;
107dcc: e8 0b a0 00 00 call 111ddc <__errno>
107dd1: c7 00 14 00 00 00 movl $0x14,(%eax)
goto cleanup_and_bail;
107dd7: e9 29 ff ff ff jmp 107d05 <mount+0x1e9>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
errno = EBUSY;
107ddc: e8 fb 9f 00 00 call 111ddc <__errno>
107de1: c7 00 10 00 00 00 movl $0x10,(%eax)
goto cleanup_and_bail;
107de7: e9 19 ff ff ff jmp 107d05 <mount+0x1e9>
00108120 <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
108120: 55 push %ebp
108121: 89 e5 mov %esp,%ebp
108123: 57 push %edi
108124: 56 push %esi
108125: 53 push %ebx
108126: 83 ec 1c sub $0x1c,%esp
108129: 8b 45 08 mov 0x8(%ebp),%eax
10812c: 89 45 e4 mov %eax,-0x1c(%ebp)
10812f: 8b 5d 0c mov 0xc(%ebp),%ebx
108132: 8b 75 10 mov 0x10(%ebp),%esi
108135: 8b 7d 14 mov 0x14(%ebp),%edi
108138: 8b 45 18 mov 0x18(%ebp),%eax
10813b: 89 45 e0 mov %eax,-0x20(%ebp)
int rv = -1;
if (target != NULL) {
10813e: 85 db test %ebx,%ebx
108140: 74 3f je 108181 <mount_and_make_target_path+0x61>
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
108142: 83 ec 08 sub $0x8,%esp
108145: 68 ff 01 00 00 push $0x1ff
10814a: 53 push %ebx
10814b: e8 08 0a 00 00 call 108b58 <rtems_mkdir>
if (rv == 0) {
108150: 83 c4 10 add $0x10,%esp
108153: 85 c0 test %eax,%eax
108155: 74 09 je 108160 <mount_and_make_target_path+0x40><== ALWAYS TAKEN
} else {
errno = EINVAL;
}
return rv;
}
108157: 8d 65 f4 lea -0xc(%ebp),%esp
10815a: 5b pop %ebx
10815b: 5e pop %esi
10815c: 5f pop %edi
10815d: c9 leave
10815e: c3 ret
10815f: 90 nop
int rv = -1;
if (target != NULL) {
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv == 0) {
rv = mount(
108160: 8b 45 e0 mov -0x20(%ebp),%eax
108163: 89 45 18 mov %eax,0x18(%ebp)
108166: 89 7d 14 mov %edi,0x14(%ebp)
108169: 89 75 10 mov %esi,0x10(%ebp)
10816c: 89 5d 0c mov %ebx,0xc(%ebp)
10816f: 8b 45 e4 mov -0x1c(%ebp),%eax
108172: 89 45 08 mov %eax,0x8(%ebp)
} else {
errno = EINVAL;
}
return rv;
}
108175: 8d 65 f4 lea -0xc(%ebp),%esp
108178: 5b pop %ebx
108179: 5e pop %esi
10817a: 5f pop %edi
10817b: c9 leave
int rv = -1;
if (target != NULL) {
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv == 0) {
rv = mount(
10817c: e9 97 00 00 00 jmp 108218 <mount>
options,
data
);
}
} else {
errno = EINVAL;
108181: e8 ca a2 00 00 call 112450 <__errno>
108186: c7 00 16 00 00 00 movl $0x16,(%eax)
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
10818c: b8 ff ff ff ff mov $0xffffffff,%eax
108191: eb c4 jmp 108157 <mount_and_make_target_path+0x37>
00107e50 <newlib_create_hook>:
*/
bool newlib_create_hook(
rtems_tcb *current_task __attribute__((unused)),
rtems_tcb *creating_task
)
{
107e50: 55 push %ebp
107e51: 89 e5 mov %esp,%ebp
107e53: 57 push %edi
107e54: 56 push %esi
107e55: 53 push %ebx
107e56: 83 ec 0c sub $0xc,%esp
struct _reent *ptr;
if (_Thread_libc_reent == 0)
107e59: a1 84 65 12 00 mov 0x126584,%eax
107e5e: 85 c0 test %eax,%eax
107e60: 0f 84 52 02 00 00 je 1080b8 <newlib_create_hook+0x268>
ptr = (struct _reent *) calloc(1, sizeof(struct _reent));
#else
/* It is OK to allocate from the workspace because these
* hooks run with thread dispatching disabled.
*/
ptr = (struct _reent *) _Workspace_Allocate(sizeof(struct _reent));
107e66: 83 ec 0c sub $0xc,%esp
107e69: 68 24 04 00 00 push $0x424
107e6e: e8 fd 5d 00 00 call 10dc70 <_Workspace_Allocate>
107e73: 89 c2 mov %eax,%edx
#endif
if (ptr) {
107e75: 83 c4 10 add $0x10,%esp
107e78: 85 c0 test %eax,%eax
107e7a: 0f 84 2c 02 00 00 je 1080ac <newlib_create_hook+0x25c>
_REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */
107e80: c7 00 00 00 00 00 movl $0x0,(%eax)
107e86: 8d 98 ec 02 00 00 lea 0x2ec(%eax),%ebx
107e8c: 89 58 04 mov %ebx,0x4(%eax)
107e8f: 8d 80 54 03 00 00 lea 0x354(%eax),%eax
107e95: 89 42 08 mov %eax,0x8(%edx)
107e98: 8d 82 bc 03 00 00 lea 0x3bc(%edx),%eax
107e9e: 89 42 0c mov %eax,0xc(%edx)
107ea1: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx)
107ea8: 8d 72 14 lea 0x14(%edx),%esi
107eab: 31 c0 xor %eax,%eax
107ead: b9 19 00 00 00 mov $0x19,%ecx
107eb2: 89 f7 mov %esi,%edi
107eb4: f3 aa rep stos %al,%es:(%edi)
107eb6: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx)
107ebd: c7 42 34 ea fa 11 00 movl $0x11faea,0x34(%edx)
107ec4: c7 42 38 00 00 00 00 movl $0x0,0x38(%edx)
107ecb: c7 42 3c 00 00 00 00 movl $0x0,0x3c(%edx)
107ed2: c7 42 40 00 00 00 00 movl $0x0,0x40(%edx)
107ed9: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx)
107ee0: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx)
107ee7: c7 42 4c 00 00 00 00 movl $0x0,0x4c(%edx)
107eee: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx)
107ef5: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx)
107efc: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx)
107f03: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx)
107f0a: c6 42 60 00 movb $0x0,0x60(%edx)
107f0e: 8d 72 7c lea 0x7c(%edx),%esi
107f11: b1 24 mov $0x24,%cl
107f13: 89 f7 mov %esi,%edi
107f15: f3 aa rep stos %al,%es:(%edi)
107f17: c7 82 a0 00 00 00 00 movl $0x0,0xa0(%edx)
107f1e: 00 00 00
107f21: c7 82 a4 00 00 00 01 movl $0x1,0xa4(%edx)
107f28: 00 00 00
107f2b: c7 82 a8 00 00 00 00 movl $0x0,0xa8(%edx)
107f32: 00 00 00
107f35: 66 c7 82 ac 00 00 00 movw $0x330e,0xac(%edx)
107f3c: 0e 33
107f3e: 66 c7 82 ae 00 00 00 movw $0xabcd,0xae(%edx)
107f45: cd ab
107f47: 66 c7 82 b0 00 00 00 movw $0x1234,0xb0(%edx)
107f4e: 34 12
107f50: 66 c7 82 b2 00 00 00 movw $0xe66d,0xb2(%edx)
107f57: 6d e6
107f59: 66 c7 82 b4 00 00 00 movw $0xdeec,0xb4(%edx)
107f60: ec de
107f62: 66 c7 82 b6 00 00 00 movw $0x5,0xb6(%edx)
107f69: 05 00
107f6b: 66 c7 82 b8 00 00 00 movw $0xb,0xb8(%edx)
107f72: 0b 00
107f74: c7 82 bc 00 00 00 00 movl $0x0,0xbc(%edx)
107f7b: 00 00 00
107f7e: c7 82 c0 00 00 00 00 movl $0x0,0xc0(%edx)
107f85: 00 00 00
107f88: c7 82 c4 00 00 00 00 movl $0x0,0xc4(%edx)
107f8f: 00 00 00
107f92: c7 82 c8 00 00 00 00 movl $0x0,0xc8(%edx)
107f99: 00 00 00
107f9c: c7 82 cc 00 00 00 00 movl $0x0,0xcc(%edx)
107fa3: 00 00 00
107fa6: c7 82 d0 00 00 00 00 movl $0x0,0xd0(%edx)
107fad: 00 00 00
107fb0: c7 82 f8 00 00 00 00 movl $0x0,0xf8(%edx)
107fb7: 00 00 00
107fba: c7 82 fc 00 00 00 00 movl $0x0,0xfc(%edx)
107fc1: 00 00 00
107fc4: c7 82 00 01 00 00 00 movl $0x0,0x100(%edx)
107fcb: 00 00 00
107fce: c7 82 04 01 00 00 00 movl $0x0,0x104(%edx)
107fd5: 00 00 00
107fd8: c7 82 08 01 00 00 00 movl $0x0,0x108(%edx)
107fdf: 00 00 00
107fe2: c7 82 0c 01 00 00 00 movl $0x0,0x10c(%edx)
107fe9: 00 00 00
107fec: c7 82 10 01 00 00 00 movl $0x0,0x110(%edx)
107ff3: 00 00 00
107ff6: c7 82 14 01 00 00 00 movl $0x0,0x114(%edx)
107ffd: 00 00 00
108000: c7 82 18 01 00 00 00 movl $0x0,0x118(%edx)
108007: 00 00 00
10800a: c7 82 1c 01 00 00 00 movl $0x0,0x11c(%edx)
108011: 00 00 00
108014: c6 82 d4 00 00 00 00 movb $0x0,0xd4(%edx)
10801b: c6 82 dc 00 00 00 00 movb $0x0,0xdc(%edx)
108022: c7 82 f4 00 00 00 00 movl $0x0,0xf4(%edx)
108029: 00 00 00
10802c: c7 82 48 01 00 00 00 movl $0x0,0x148(%edx)
108033: 00 00 00
108036: c7 82 4c 01 00 00 00 movl $0x0,0x14c(%edx)
10803d: 00 00 00
108040: c7 82 50 01 00 00 00 movl $0x0,0x150(%edx)
108047: 00 00 00
10804a: c7 82 54 01 00 00 00 movl $0x0,0x154(%edx)
108051: 00 00 00
108054: c7 82 d4 02 00 00 00 movl $0x0,0x2d4(%edx)
10805b: 00 00 00
10805e: c7 82 d4 01 00 00 00 movl $0x0,0x1d4(%edx)
108065: 00 00 00
108068: c7 82 dc 02 00 00 00 movl $0x0,0x2dc(%edx)
10806f: 00 00 00
108072: c7 82 e0 02 00 00 00 movl $0x0,0x2e0(%edx)
108079: 00 00 00
10807c: c7 82 e4 02 00 00 00 movl $0x0,0x2e4(%edx)
108083: 00 00 00
108086: c7 82 e8 02 00 00 00 movl $0x0,0x2e8(%edx)
10808d: 00 00 00
108090: 66 b9 38 01 mov $0x138,%cx
108094: 89 df mov %ebx,%edi
108096: f3 aa rep stos %al,%es:(%edi)
creating_task->libc_reent = ptr;
108098: 8b 45 0c mov 0xc(%ebp),%eax
10809b: 89 90 e0 00 00 00 mov %edx,0xe0(%eax)
return TRUE;
1080a1: b0 01 mov $0x1,%al
}
return FALSE;
}
1080a3: 8d 65 f4 lea -0xc(%ebp),%esp
1080a6: 5b pop %ebx
1080a7: 5e pop %esi
1080a8: 5f pop %edi
1080a9: c9 leave
1080aa: c3 ret
1080ab: 90 nop
_REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */
creating_task->libc_reent = ptr;
return TRUE;
}
return FALSE;
1080ac: 31 c0 xor %eax,%eax
}
1080ae: 8d 65 f4 lea -0xc(%ebp),%esp
1080b1: 5b pop %ebx
1080b2: 5e pop %esi
1080b3: 5f pop %edi
1080b4: c9 leave
1080b5: c3 ret
1080b6: 66 90 xchg %ax,%ax
{
struct _reent *ptr;
if (_Thread_libc_reent == 0)
{
_REENT = _global_impure_ptr;
1080b8: a1 60 07 12 00 mov 0x120760,%eax
1080bd: a3 60 42 12 00 mov %eax,0x124260
RTEMS_INLINE_ROUTINE void _Thread_Set_libc_reent (
struct _reent **libc_reent
)
{
_Thread_libc_reent = libc_reent;
1080c2: c7 05 84 65 12 00 60 movl $0x124260,0x126584
1080c9: 42 12 00
1080cc: e9 95 fd ff ff jmp 107e66 <newlib_create_hook+0x16>
001080d4 <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
1080d4: 55 push %ebp
1080d5: 89 e5 mov %esp,%ebp
1080d7: 57 push %edi
1080d8: 56 push %esi
1080d9: 53 push %ebx
1080da: 83 ec 0c sub $0xc,%esp
1080dd: 8b 7d 08 mov 0x8(%ebp),%edi
1080e0: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
1080e3: 39 df cmp %ebx,%edi
1080e5: 74 55 je 10813c <newlib_delete_hook+0x68>
ptr = _REENT;
} else {
ptr = deleted_task->libc_reent;
1080e7: 8b b3 e0 00 00 00 mov 0xe0(%ebx),%esi
}
if (ptr && ptr != _global_impure_ptr) {
1080ed: 85 f6 test %esi,%esi
1080ef: 74 21 je 108112 <newlib_delete_hook+0x3e><== NEVER TAKEN
1080f1: 3b 35 60 07 12 00 cmp 0x120760,%esi
1080f7: 74 19 je 108112 <newlib_delete_hook+0x3e>
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
1080f9: 83 ec 08 sub $0x8,%esp
1080fc: 68 f4 7d 10 00 push $0x107df4
108101: 56 push %esi
108102: e8 bd a4 00 00 call 1125c4 <_fwalk>
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
108107: 89 34 24 mov %esi,(%esp)
10810a: e8 7d 5b 00 00 call 10dc8c <_Workspace_Free>
10810f: 83 c4 10 add $0x10,%esp
#endif
}
deleted_task->libc_reent = NULL;
108112: c7 83 e0 00 00 00 00 movl $0x0,0xe0(%ebx)
108119: 00 00 00
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
10811c: 39 df cmp %ebx,%edi
10811e: 74 08 je 108128 <newlib_delete_hook+0x54>
_REENT = 0;
}
}
108120: 8d 65 f4 lea -0xc(%ebp),%esp
108123: 5b pop %ebx
108124: 5e pop %esi
108125: 5f pop %edi
108126: c9 leave
108127: c3 ret
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
_REENT = 0;
108128: c7 05 60 42 12 00 00 movl $0x0,0x124260
10812f: 00 00 00
}
}
108132: 8d 65 f4 lea -0xc(%ebp),%esp
108135: 5b pop %ebx
108136: 5e pop %esi
108137: 5f pop %edi
108138: c9 leave
108139: c3 ret
10813a: 66 90 xchg %ax,%ax
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ptr = _REENT;
10813c: 8b 35 60 42 12 00 mov 0x124260,%esi
108142: eb a9 jmp 1080ed <newlib_delete_hook+0x19>
00107df4 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
107df4: 55 push %ebp
107df5: 89 e5 mov %esp,%ebp
107df7: 53 push %ebx
107df8: 83 ec 10 sub $0x10,%esp
107dfb: 8b 5d 08 mov 0x8(%ebp),%ebx
switch ( fileno(fp) ) {
107dfe: 53 push %ebx
107dff: e8 ac a3 00 00 call 1121b0 <fileno>
107e04: 83 c4 10 add $0x10,%esp
107e07: 83 f8 02 cmp $0x2,%eax
107e0a: 76 14 jbe 107e20 <newlib_free_buffers+0x2c><== ALWAYS TAKEN
fp->_flags &= ~__SMBF;
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
107e0c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107e0f: 53 push %ebx <== NOT EXECUTED
107e10: e8 1f a1 00 00 call 111f34 <fclose> <== NOT EXECUTED
107e15: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
return 0;
}
107e18: 31 c0 xor %eax,%eax
107e1a: 8b 5d fc mov -0x4(%ebp),%ebx
107e1d: c9 leave
107e1e: c3 ret
107e1f: 90 nop
{
switch ( fileno(fp) ) {
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
107e20: f6 43 0c 80 testb $0x80,0xc(%ebx)
107e24: 74 f2 je 107e18 <newlib_free_buffers+0x24><== ALWAYS TAKEN
free( fp->_bf._base );
107e26: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107e29: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
107e2c: e8 03 f8 ff ff call 107634 <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
107e31: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx) <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
107e37: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED
107e3d: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED
107e44: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
break;
default:
fclose(fp);
}
return 0;
}
107e47: 31 c0 xor %eax,%eax <== NOT EXECUTED
107e49: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
107e4c: c9 leave <== NOT EXECUTED
107e4d: c3 ret <== NOT EXECUTED
00107264 <null_initialize>:
rtems_device_driver null_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *pargp __attribute__((unused))
)
{
107264: 55 push %ebp
107265: 89 e5 mov %esp,%ebp
107267: 53 push %ebx
107268: 83 ec 04 sub $0x4,%esp
10726b: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_device_driver status;
if ( !initialized ) {
10726e: 80 3d 80 40 12 00 00 cmpb $0x0,0x124080
107275: 74 09 je 107280 <null_initialize+0x1c>
NULL_major = major;
}
return RTEMS_SUCCESSFUL;
}
107277: 31 c0 xor %eax,%eax
107279: 8b 5d fc mov -0x4(%ebp),%ebx
10727c: c9 leave
10727d: c3 ret
10727e: 66 90 xchg %ax,%ax
)
{
rtems_device_driver status;
if ( !initialized ) {
initialized = 1;
107280: c6 05 80 40 12 00 01 movb $0x1,0x124080
status = rtems_io_register_name(
107287: 50 push %eax
107288: 6a 00 push $0x0
10728a: 53 push %ebx
10728b: 68 37 c5 11 00 push $0x11c537
107290: e8 7b 01 00 00 call 107410 <rtems_io_register_name>
"/dev/null",
major,
(rtems_device_minor_number) 0
);
if (status != RTEMS_SUCCESSFUL)
107295: 83 c4 10 add $0x10,%esp
107298: 85 c0 test %eax,%eax
10729a: 75 0d jne 1072a9 <null_initialize+0x45>
rtems_fatal_error_occurred(status);
NULL_major = major;
10729c: 89 1d c0 43 12 00 mov %ebx,0x1243c0
}
return RTEMS_SUCCESSFUL;
}
1072a2: 31 c0 xor %eax,%eax
1072a4: 8b 5d fc mov -0x4(%ebp),%ebx
1072a7: c9 leave
1072a8: c3 ret
major,
(rtems_device_minor_number) 0
);
if (status != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred(status);
1072a9: 83 ec 0c sub $0xc,%esp
1072ac: 50 push %eax
1072ad: e8 22 41 00 00 call 10b3d4 <rtems_fatal_error_occurred>
001081a4 <open>:
int open(
const char *pathname,
int flags,
...
)
{
1081a4: 55 push %ebp
1081a5: 89 e5 mov %esp,%ebp
1081a7: 57 push %edi
1081a8: 56 push %esi
1081a9: 53 push %ebx
1081aa: 83 ec 4c sub $0x4c,%esp
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
1081ad: 8b 45 0c mov 0xc(%ebp),%eax
1081b0: 40 inc %eax
if ( ( status & _FREAD ) == _FREAD )
1081b1: 89 c3 mov %eax,%ebx
1081b3: 83 e3 01 and $0x1,%ebx
eval_flags |= RTEMS_LIBIO_PERMS_READ;
1081b6: f7 db neg %ebx
1081b8: 83 e3 04 and $0x4,%ebx
if ( ( status & _FWRITE ) == _FWRITE )
1081bb: a8 02 test $0x2,%al
1081bd: 74 03 je 1081c2 <open+0x1e>
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
1081bf: 83 cb 02 or $0x2,%ebx
va_start(ap, flags);
mode = va_arg( ap, int );
1081c2: 8b 45 10 mov 0x10(%ebp),%eax
1081c5: 89 45 c4 mov %eax,-0x3c(%ebp)
* code does not require changes here since network file
* descriptors are obtained using socket(), not open().
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
1081c8: e8 a7 70 00 00 call 10f274 <rtems_libio_allocate>
1081cd: 89 c2 mov %eax,%edx
if ( iop == 0 ) {
1081cf: 85 c0 test %eax,%eax
1081d1: 0f 84 c5 00 00 00 je 10829c <open+0xf8>
}
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
1081d7: 31 f6 xor %esi,%esi
1081d9: b9 ff ff ff ff mov $0xffffffff,%ecx
1081de: 8b 7d 08 mov 0x8(%ebp),%edi
1081e1: 89 f0 mov %esi,%eax
1081e3: f2 ae repnz scas %es:(%edi),%al
1081e5: f7 d1 not %ecx
1081e7: 49 dec %ecx
1081e8: 83 ec 0c sub $0xc,%esp
1081eb: 6a 01 push $0x1
1081ed: 8d 45 d4 lea -0x2c(%ebp),%eax
1081f0: 89 45 b4 mov %eax,-0x4c(%ebp)
1081f3: 50 push %eax
1081f4: 53 push %ebx
1081f5: 51 push %ecx
1081f6: ff 75 08 pushl 0x8(%ebp)
1081f9: 89 55 c0 mov %edx,-0x40(%ebp)
1081fc: e8 47 f3 ff ff call 107548 <rtems_filesystem_evaluate_path>
108201: 89 c3 mov %eax,%ebx
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
108203: 83 c4 20 add $0x20,%esp
108206: 83 f8 ff cmp $0xffffffff,%eax
108209: 8b 55 c0 mov -0x40(%ebp),%edx
10820c: 0f 84 de 00 00 00 je 1082f0 <open+0x14c>
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
108212: 8b 45 0c mov 0xc(%ebp),%eax
108215: 25 00 0a 00 00 and $0xa00,%eax
10821a: 3d 00 0a 00 00 cmp $0xa00,%eax
10821f: 0f 84 8b 00 00 00 je 1082b0 <open+0x10c>
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
108225: 8b 5a 14 mov 0x14(%edx),%ebx
108228: 83 ec 0c sub $0xc,%esp
10822b: ff 75 0c pushl 0xc(%ebp)
10822e: 89 55 c0 mov %edx,-0x40(%ebp)
108231: e8 c2 6f 00 00 call 10f1f8 <rtems_libio_fcntl_flags>
108236: 09 d8 or %ebx,%eax
108238: 8b 55 c0 mov -0x40(%ebp),%edx
10823b: 89 42 14 mov %eax,0x14(%edx)
iop->pathinfo = loc;
10823e: 8d 7a 18 lea 0x18(%edx),%edi
108241: b9 05 00 00 00 mov $0x5,%ecx
108246: 8b 75 b4 mov -0x4c(%ebp),%esi
108249: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
10824b: 8b 42 20 mov 0x20(%edx),%eax
10824e: ff 75 c4 pushl -0x3c(%ebp)
108251: ff 75 0c pushl 0xc(%ebp)
108254: ff 75 08 pushl 0x8(%ebp)
108257: 52 push %edx
108258: ff 10 call *(%eax)
if ( rc ) {
10825a: 83 c4 20 add $0x20,%esp
10825d: 85 c0 test %eax,%eax
10825f: 8b 55 c0 mov -0x40(%ebp),%edx
108262: 75 78 jne 1082dc <open+0x138>
}
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
108264: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
10826b: 0f 85 9f 00 00 00 jne 108310 <open+0x16c>
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
rtems_set_errno_and_return_minus_one( rc );
}
return iop - rtems_libio_iops;
108271: 2b 15 80 63 12 00 sub 0x126380,%edx
108277: c1 fa 03 sar $0x3,%edx
10827a: 8d 04 d2 lea (%edx,%edx,8),%eax
10827d: 8d 04 c2 lea (%edx,%eax,8),%eax
108280: 8d 04 c2 lea (%edx,%eax,8),%eax
108283: 8d 04 c2 lea (%edx,%eax,8),%eax
108286: 89 c1 mov %eax,%ecx
108288: c1 e1 0f shl $0xf,%ecx
10828b: 01 c8 add %ecx,%eax
10828d: 8d 04 c2 lea (%edx,%eax,8),%eax
108290: f7 d8 neg %eax
}
108292: 8d 65 f4 lea -0xc(%ebp),%esp
108295: 5b pop %ebx
108296: 5e pop %esi
108297: 5f pop %edi
108298: c9 leave
108299: c3 ret
10829a: 66 90 xchg %ax,%ax
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
if ( iop == 0 ) {
rc = ENFILE;
10829c: bb 17 00 00 00 mov $0x17,%ebx
if ( rc ) {
if ( iop )
rtems_libio_free( iop );
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
rtems_set_errno_and_return_minus_one( rc );
1082a1: e8 36 9b 00 00 call 111ddc <__errno>
1082a6: 89 18 mov %ebx,(%eax)
1082a8: b8 ff ff ff ff mov $0xffffffff,%eax
1082ad: eb e3 jmp 108292 <open+0xee>
1082af: 90 nop
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
/* We were trying to create a file that already exists */
rc = EEXIST;
loc_to_free = &loc;
1082b0: 8d 75 d4 lea -0x2c(%ebp),%esi
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
/* We were trying to create a file that already exists */
rc = EEXIST;
1082b3: bb 11 00 00 00 mov $0x11,%ebx
*/
done:
va_end(ap);
if ( rc ) {
if ( iop )
1082b8: 85 d2 test %edx,%edx
1082ba: 74 0c je 1082c8 <open+0x124>
rtems_libio_free( iop );
1082bc: 83 ec 0c sub $0xc,%esp
1082bf: 52 push %edx
1082c0: e8 53 70 00 00 call 10f318 <rtems_libio_free>
1082c5: 83 c4 10 add $0x10,%esp
if ( loc_to_free )
1082c8: 85 f6 test %esi,%esi
1082ca: 74 d5 je 1082a1 <open+0xfd>
rtems_filesystem_freenode( loc_to_free );
1082cc: 83 ec 0c sub $0xc,%esp
1082cf: 56 push %esi
1082d0: e8 4b f3 ff ff call 107620 <rtems_filesystem_freenode>
1082d5: 83 c4 10 add $0x10,%esp
1082d8: eb c7 jmp 1082a1 <open+0xfd>
1082da: 66 90 xchg %ax,%ax
iop->flags |= rtems_libio_fcntl_flags( flags );
iop->pathinfo = loc;
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
if ( rc ) {
rc = errno;
1082dc: e8 fb 9a 00 00 call 111ddc <__errno>
1082e1: 8b 18 mov (%eax),%ebx
rc = EEXIST;
loc_to_free = &loc;
goto done;
}
loc_to_free = &loc;
1082e3: 8d 75 d4 lea -0x2c(%ebp),%esi
iop->pathinfo = loc;
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
if ( rc ) {
rc = errno;
goto done;
1082e6: 8b 55 c0 mov -0x40(%ebp),%edx
* Single exit and clean up path.
*/
done:
va_end(ap);
if ( rc ) {
1082e9: 85 db test %ebx,%ebx
1082eb: 74 84 je 108271 <open+0xcd> <== NEVER TAKEN
1082ed: eb c9 jmp 1082b8 <open+0x114>
1082ef: 90 nop
*/
status = rtems_filesystem_evaluate_path(
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
if ( errno != ENOENT ) {
1082f0: e8 e7 9a 00 00 call 111ddc <__errno>
1082f5: 83 38 02 cmpl $0x2,(%eax)
1082f8: 8b 55 c0 mov -0x40(%ebp),%edx
1082fb: 0f 84 9b 00 00 00 je 10839c <open+0x1f8>
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
if ( rc ) {
rc = errno;
108301: e8 d6 9a 00 00 call 111ddc <__errno>
108306: 8b 18 mov (%eax),%ebx
int mode;
int rc;
rtems_libio_t *iop = 0;
int status;
rtems_filesystem_location_info_t loc;
rtems_filesystem_location_info_t *loc_to_free = NULL;
108308: 31 f6 xor %esi,%esi
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
if ( rc ) {
rc = errno;
goto done;
10830a: 8b 55 c0 mov -0x40(%ebp),%edx
10830d: eb da jmp 1082e9 <open+0x145>
10830f: 90 nop
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
108310: 51 push %ecx
108311: 6a 00 push $0x0
108313: 6a 00 push $0x0
108315: 89 d0 mov %edx,%eax
108317: 2b 05 80 63 12 00 sub 0x126380,%eax
10831d: c1 f8 03 sar $0x3,%eax
108320: 8d 0c c0 lea (%eax,%eax,8),%ecx
108323: 8d 0c c8 lea (%eax,%ecx,8),%ecx
108326: 8d 0c c8 lea (%eax,%ecx,8),%ecx
108329: 8d 0c c8 lea (%eax,%ecx,8),%ecx
10832c: 89 cb mov %ecx,%ebx
10832e: c1 e3 0f shl $0xf,%ebx
108331: 01 d9 add %ebx,%ecx
108333: 8d 04 c8 lea (%eax,%ecx,8),%eax
108336: f7 d8 neg %eax
108338: 50 push %eax
108339: 89 55 c0 mov %edx,-0x40(%ebp)
10833c: e8 b3 6d 00 00 call 10f0f4 <ftruncate>
108341: 89 c3 mov %eax,%ebx
if ( rc ) {
108343: 83 c4 10 add $0x10,%esp
108346: 85 c0 test %eax,%eax
108348: 8b 55 c0 mov -0x40(%ebp),%edx
10834b: 0f 84 20 ff ff ff je 108271 <open+0xcd>
if(errno) rc = errno;
108351: e8 86 9a 00 00 call 111ddc <__errno>
108356: 8b 00 mov (%eax),%eax
108358: 85 c0 test %eax,%eax
10835a: 8b 55 c0 mov -0x40(%ebp),%edx
10835d: 0f 85 b2 00 00 00 jne 108415 <open+0x271> <== ALWAYS TAKEN
close( iop - rtems_libio_iops );
108363: 83 ec 0c sub $0xc,%esp
108366: 2b 15 80 63 12 00 sub 0x126380,%edx
10836c: c1 fa 03 sar $0x3,%edx
10836f: 8d 04 d2 lea (%edx,%edx,8),%eax
108372: 8d 04 c2 lea (%edx,%eax,8),%eax
108375: 8d 04 c2 lea (%edx,%eax,8),%eax
108378: 8d 04 c2 lea (%edx,%eax,8),%eax
10837b: 89 c1 mov %eax,%ecx
10837d: c1 e1 0f shl $0xf,%ecx
108380: 01 c8 add %ecx,%eax
108382: 8d 04 c2 lea (%edx,%eax,8),%eax
108385: f7 d8 neg %eax
108387: 50 push %eax
108388: e8 e7 6c 00 00 call 10f074 <close>
10838d: 83 c4 10 add $0x10,%esp
/* those are released by close(): */
iop = 0;
loc_to_free = NULL;
108390: 31 f6 xor %esi,%esi
rc = ftruncate( iop - rtems_libio_iops, 0 );
if ( rc ) {
if(errno) rc = errno;
close( iop - rtems_libio_iops );
/* those are released by close(): */
iop = 0;
108392: 31 d2 xor %edx,%edx
108394: e9 50 ff ff ff jmp 1082e9 <open+0x145>
108399: 8d 76 00 lea 0x0(%esi),%esi
rc = errno;
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
10839c: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
1083a3: 75 0f jne 1083b4 <open+0x210>
int mode;
int rc;
rtems_libio_t *iop = 0;
int status;
rtems_filesystem_location_info_t loc;
rtems_filesystem_location_info_t *loc_to_free = NULL;
1083a5: 31 f6 xor %esi,%esi
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
rc = ENOENT;
1083a7: bb 02 00 00 00 mov $0x2,%ebx
1083ac: e9 07 ff ff ff jmp 1082b8 <open+0x114>
1083b1: 8d 76 00 lea 0x0(%esi),%esi
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
1083b4: 6a 00 push $0x0
1083b6: 6a 00 push $0x0
1083b8: 8b 45 c4 mov -0x3c(%ebp),%eax
1083bb: 80 cc 80 or $0x80,%ah
1083be: 50 push %eax
1083bf: ff 75 08 pushl 0x8(%ebp)
1083c2: 89 55 c0 mov %edx,-0x40(%ebp)
1083c5: e8 02 f6 ff ff call 1079cc <mknod>
if ( rc ) {
1083ca: 83 c4 10 add $0x10,%esp
1083cd: 85 c0 test %eax,%eax
1083cf: 8b 55 c0 mov -0x40(%ebp),%edx
1083d2: 0f 85 29 ff ff ff jne 108301 <open+0x15d> <== NEVER TAKEN
/*
* After we do the mknod(), we have to evaluate the path to get the
* "loc" structure needed to actually have the file itself open.
* So we created it, and then we need to have "look it up."
*/
status = rtems_filesystem_evaluate_path(
1083d8: 89 d9 mov %ebx,%ecx
1083da: 8b 7d 08 mov 0x8(%ebp),%edi
1083dd: 89 f0 mov %esi,%eax
1083df: f2 ae repnz scas %es:(%edi),%al
1083e1: f7 d1 not %ecx
1083e3: 49 dec %ecx
1083e4: 83 ec 0c sub $0xc,%esp
1083e7: 6a 01 push $0x1
1083e9: 8d 45 d4 lea -0x2c(%ebp),%eax
1083ec: 50 push %eax
1083ed: 6a 00 push $0x0
1083ef: 51 push %ecx
1083f0: ff 75 08 pushl 0x8(%ebp)
1083f3: 89 55 c0 mov %edx,-0x40(%ebp)
1083f6: e8 4d f1 ff ff call 107548 <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
1083fb: 83 c4 20 add $0x20,%esp
1083fe: 85 c0 test %eax,%eax
108400: 8b 55 c0 mov -0x40(%ebp),%edx
108403: 0f 84 1c fe ff ff je 108225 <open+0x81> <== ALWAYS TAKEN
int mode;
int rc;
rtems_libio_t *iop = 0;
int status;
rtems_filesystem_location_info_t loc;
rtems_filesystem_location_info_t *loc_to_free = NULL;
108409: 31 f6 xor %esi,%esi
* So we created it, and then we need to have "look it up."
*/
status = rtems_filesystem_evaluate_path(
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
10840b: bb 0d 00 00 00 mov $0xd,%ebx <== NOT EXECUTED
108410: e9 a3 fe ff ff jmp 1082b8 <open+0x114> <== NOT EXECUTED
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
if ( rc ) {
if(errno) rc = errno;
108415: e8 c2 99 00 00 call 111ddc <__errno>
10841a: 8b 18 mov (%eax),%ebx
10841c: 8b 55 c0 mov -0x40(%ebp),%edx
10841f: e9 3f ff ff ff jmp 108363 <open+0x1bf>
001091a8 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
1091a8: 55 push %ebp
1091a9: 89 e5 mov %esp,%ebp
1091ab: 56 push %esi
1091ac: 53 push %ebx
1091ad: 83 ec 10 sub $0x10,%esp
1091b0: 88 45 f4 mov %al,-0xc(%ebp)
int i;
if (tty->termios.c_oflag & OPOST) {
1091b3: 8b 4a 34 mov 0x34(%edx),%ecx
1091b6: f6 c1 01 test $0x1,%cl
1091b9: 74 31 je 1091ec <oproc+0x44> <== NEVER TAKEN
switch (c) {
1091bb: 3c 09 cmp $0x9,%al
1091bd: 0f 84 b1 00 00 00 je 109274 <oproc+0xcc>
1091c3: 76 3f jbe 109204 <oproc+0x5c> <== NEVER TAKEN
1091c5: 3c 0a cmp $0xa,%al
1091c7: 74 4f je 109218 <oproc+0x70>
1091c9: 3c 0d cmp $0xd,%al
1091cb: 74 7f je 10924c <oproc+0xa4> <== NEVER TAKEN
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
1091cd: 83 e1 02 and $0x2,%ecx
1091d0: 0f 85 c6 00 00 00 jne 10929c <oproc+0xf4> <== NEVER TAKEN
1091d6: 8b 0d 54 42 12 00 mov 0x124254,%ecx
c = toupper(c);
if (!iscntrl(c))
1091dc: 0f b6 c0 movzbl %al,%eax
1091df: f6 44 01 01 20 testb $0x20,0x1(%ecx,%eax,1)
1091e4: 75 06 jne 1091ec <oproc+0x44> <== NEVER TAKEN
tty->column++;
1091e6: ff 42 28 incl 0x28(%edx)
1091e9: 8d 76 00 lea 0x0(%esi),%esi
break;
}
}
rtems_termios_puts (&c, 1, tty);
1091ec: 53 push %ebx
1091ed: 52 push %edx
1091ee: 6a 01 push $0x1
1091f0: 8d 45 f4 lea -0xc(%ebp),%eax
1091f3: 50 push %eax
1091f4: e8 7b fe ff ff call 109074 <rtems_termios_puts>
1091f9: 83 c4 10 add $0x10,%esp
}
1091fc: 8d 65 f8 lea -0x8(%ebp),%esp
1091ff: 5b pop %ebx
109200: 5e pop %esi
109201: c9 leave
109202: c3 ret
109203: 90 nop
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
109204: 3c 08 cmp $0x8,%al <== NOT EXECUTED
109206: 75 c5 jne 1091cd <oproc+0x25> <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
109208: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED
10920b: 85 c0 test %eax,%eax <== NOT EXECUTED
10920d: 7e dd jle 1091ec <oproc+0x44> <== NOT EXECUTED
tty->column--;
10920f: 48 dec %eax <== NOT EXECUTED
109210: 89 42 28 mov %eax,0x28(%edx) <== NOT EXECUTED
109213: eb d7 jmp 1091ec <oproc+0x44> <== NOT EXECUTED
109215: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
case '\n':
if (tty->termios.c_oflag & ONLRET)
109218: f6 c1 20 test $0x20,%cl
10921b: 74 07 je 109224 <oproc+0x7c> <== ALWAYS TAKEN
tty->column = 0;
10921d: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLCR) {
109224: 83 e1 04 and $0x4,%ecx
109227: 74 c3 je 1091ec <oproc+0x44> <== NEVER TAKEN
rtems_termios_puts ("\r", 1, tty);
109229: 51 push %ecx
10922a: 52 push %edx
10922b: 6a 01 push $0x1
10922d: 68 64 fe 11 00 push $0x11fe64
109232: 89 55 f0 mov %edx,-0x10(%ebp)
109235: e8 3a fe ff ff call 109074 <rtems_termios_puts>
tty->column = 0;
10923a: 8b 55 f0 mov -0x10(%ebp),%edx
10923d: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx)
109244: 83 c4 10 add $0x10,%esp
109247: eb a3 jmp 1091ec <oproc+0x44>
109249: 8d 76 00 lea 0x0(%esi),%esi
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
10924c: f6 c1 10 test $0x10,%cl <== NOT EXECUTED
10924f: 74 07 je 109258 <oproc+0xb0> <== NOT EXECUTED
109251: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED
109254: 85 c0 test %eax,%eax <== NOT EXECUTED
109256: 74 a4 je 1091fc <oproc+0x54> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
109258: f6 c1 08 test $0x8,%cl <== NOT EXECUTED
10925b: 74 09 je 109266 <oproc+0xbe> <== NOT EXECUTED
c = '\n';
10925d: c6 45 f4 0a movb $0xa,-0xc(%ebp) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
109261: 83 e1 20 and $0x20,%ecx <== NOT EXECUTED
109264: 74 86 je 1091ec <oproc+0x44> <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
109266: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx) <== NOT EXECUTED
break;
10926d: e9 7a ff ff ff jmp 1091ec <oproc+0x44> <== NOT EXECUTED
109272: 66 90 xchg %ax,%ax <== NOT EXECUTED
case '\t':
i = 8 - (tty->column & 7);
109274: 8b 5a 28 mov 0x28(%edx),%ebx
109277: 89 de mov %ebx,%esi
109279: 83 e6 07 and $0x7,%esi
10927c: b8 08 00 00 00 mov $0x8,%eax
109281: 29 f0 sub %esi,%eax
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
109283: 81 e1 00 18 00 00 and $0x1800,%ecx
109289: 81 f9 00 18 00 00 cmp $0x1800,%ecx
10928f: 74 37 je 1092c8 <oproc+0x120> <== ALWAYS TAKEN
tty->column += i;
rtems_termios_puts ( " ", i, tty);
return;
}
tty->column += i;
109291: 01 d8 add %ebx,%eax <== NOT EXECUTED
109293: 89 42 28 mov %eax,0x28(%edx) <== NOT EXECUTED
break;
109296: e9 51 ff ff ff jmp 1091ec <oproc+0x44> <== NOT EXECUTED
10929b: 90 nop <== NOT EXECUTED
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
c = toupper(c);
10929c: 8b 0d 54 42 12 00 mov 0x124254,%ecx <== NOT EXECUTED
1092a2: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
1092a5: 0f be 5c 01 01 movsbl 0x1(%ecx,%eax,1),%ebx <== NOT EXECUTED
1092aa: 83 e3 03 and $0x3,%ebx <== NOT EXECUTED
1092ad: 83 fb 02 cmp $0x2,%ebx <== NOT EXECUTED
1092b0: 74 0e je 1092c0 <oproc+0x118> <== NOT EXECUTED
1092b2: 89 c3 mov %eax,%ebx <== NOT EXECUTED
1092b4: 88 d8 mov %bl,%al <== NOT EXECUTED
1092b6: 88 5d f4 mov %bl,-0xc(%ebp) <== NOT EXECUTED
1092b9: e9 1e ff ff ff jmp 1091dc <oproc+0x34> <== NOT EXECUTED
1092be: 66 90 xchg %ax,%ax <== NOT EXECUTED
1092c0: 8d 58 e0 lea -0x20(%eax),%ebx <== NOT EXECUTED
1092c3: eb ef jmp 1092b4 <oproc+0x10c> <== NOT EXECUTED
1092c5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
1092c8: 8d 1c 18 lea (%eax,%ebx,1),%ebx
1092cb: 89 5a 28 mov %ebx,0x28(%edx)
rtems_termios_puts ( " ", i, tty);
1092ce: 56 push %esi
1092cf: 52 push %edx
1092d0: 50 push %eax
1092d1: 68 fc f9 11 00 push $0x11f9fc
1092d6: e8 99 fd ff ff call 109074 <rtems_termios_puts>
return;
1092db: 83 c4 10 add $0x10,%esp
1092de: e9 19 ff ff ff jmp 1091fc <oproc+0x54>
001095e0 <pathconf>:
long pathconf(
const char *path,
int name
)
{
1095e0: 55 push %ebp
1095e1: 89 e5 mov %esp,%ebp
1095e3: 56 push %esi
1095e4: 53 push %ebx
int status;
int fd;
fd = open( path, O_RDONLY );
1095e5: 83 ec 08 sub $0x8,%esp
1095e8: 6a 00 push $0x0
1095ea: ff 75 08 pushl 0x8(%ebp)
1095ed: e8 4e fd ff ff call 109340 <open>
1095f2: 89 c3 mov %eax,%ebx
if ( fd == -1 )
1095f4: 83 c4 10 add $0x10,%esp
1095f7: 83 f8 ff cmp $0xffffffff,%eax
1095fa: 74 24 je 109620 <pathconf+0x40>
return -1;
status = fpathconf( fd, name );
1095fc: 83 ec 08 sub $0x8,%esp
1095ff: ff 75 0c pushl 0xc(%ebp)
109602: 50 push %eax
109603: e8 98 ec ff ff call 1082a0 <fpathconf>
109608: 89 c6 mov %eax,%esi
(void) close( fd );
10960a: 89 1c 24 mov %ebx,(%esp)
10960d: e8 2e e8 ff ff call 107e40 <close>
return status;
109612: 83 c4 10 add $0x10,%esp
109615: 89 f0 mov %esi,%eax
}
109617: 8d 65 f8 lea -0x8(%ebp),%esp
10961a: 5b pop %ebx
10961b: 5e pop %esi
10961c: c9 leave
10961d: c3 ret
10961e: 66 90 xchg %ax,%ax
int status;
int fd;
fd = open( path, O_RDONLY );
if ( fd == -1 )
return -1;
109620: b8 ff ff ff ff mov $0xffffffff,%eax
status = fpathconf( fd, name );
(void) close( fd );
return status;
}
109625: 8d 65 f8 lea -0x8(%ebp),%esp
109628: 5b pop %ebx
109629: 5e pop %esi
10962a: c9 leave
10962b: c3 ret
00110118 <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
110118: 55 push %ebp
110119: 89 e5 mov %esp,%ebp
11011b: 57 push %edi
11011c: 56 push %esi
11011d: 53 push %ebx
11011e: 83 ec 24 sub $0x24,%esp
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
110121: 68 ff 01 00 00 push $0x1ff
110126: 68 0c 1a 12 00 push $0x121a0c
11012b: e8 ec 16 00 00 call 11181c <rtems_mkdir>
110130: 83 c4 10 add $0x10,%esp
110133: 85 c0 test %eax,%eax
110135: 74 0d je 110144 <pipe_create+0x2c> <== ALWAYS TAKEN
return -1;
110137: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
}
11013c: 8d 65 f4 lea -0xc(%ebp),%esp
11013f: 5b pop %ebx
110140: 5e pop %esi
110141: 5f pop %edi
110142: c9 leave
110143: c3 ret
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
110144: 8d 5d d9 lea -0x27(%ebp),%ebx
110147: be 11 1a 12 00 mov $0x121a11,%esi
11014c: b9 0a 00 00 00 mov $0xa,%ecx
110151: 89 df mov %ebx,%edi
110153: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
110155: 0f b7 05 d4 70 12 00 movzwl 0x1270d4,%eax
11015c: 8d 50 01 lea 0x1(%eax),%edx
11015f: 66 89 15 d4 70 12 00 mov %dx,0x1270d4
110166: 51 push %ecx
110167: 50 push %eax
110168: 68 1c 1a 12 00 push $0x121a1c
11016d: 8d 45 e3 lea -0x1d(%ebp),%eax
110170: 50 push %eax
110171: e8 f6 3b 00 00 call 113d6c <sprintf>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
110176: 58 pop %eax
110177: 5a pop %edx
110178: 68 80 01 00 00 push $0x180
11017d: 53 push %ebx
11017e: e8 e1 13 00 00 call 111564 <mkfifo>
110183: 83 c4 10 add $0x10,%esp
110186: 85 c0 test %eax,%eax
110188: 0f 85 a6 00 00 00 jne 110234 <pipe_create+0x11c>
return -1;
/* sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); */
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
11018e: 83 ec 08 sub $0x8,%esp
110191: 68 00 40 00 00 push $0x4000
110196: 53 push %ebx
110197: e8 4c 92 ff ff call 1093e8 <open>
11019c: 8b 55 08 mov 0x8(%ebp),%edx
11019f: 89 02 mov %eax,(%edx)
if (filsdes[0] < 0) {
1101a1: 83 c4 10 add $0x10,%esp
1101a4: 85 c0 test %eax,%eax
1101a6: 78 58 js 110200 <pipe_create+0xe8>
the file node will be deleted after it is closed by all. */
unlink(fifopath);
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
1101a8: 3b 05 4c 31 12 00 cmp 0x12314c,%eax
1101ae: 72 3c jb 1101ec <pipe_create+0xd4> <== ALWAYS TAKEN
1101b0: 31 d2 xor %edx,%edx <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
1101b2: 83 62 14 fe andl $0xfffffffe,0x14(%edx)
filsdes[1] = open(fifopath, O_WRONLY);
1101b6: 83 ec 08 sub $0x8,%esp
1101b9: 6a 01 push $0x1
1101bb: 53 push %ebx
1101bc: e8 27 92 ff ff call 1093e8 <open>
1101c1: 8b 55 08 mov 0x8(%ebp),%edx
1101c4: 89 42 04 mov %eax,0x4(%edx)
if (filsdes[1] < 0) {
1101c7: 83 c4 10 add $0x10,%esp
1101ca: 85 c0 test %eax,%eax
1101cc: 78 4a js 110218 <pipe_create+0x100>
int pipe_create(
int filsdes[2]
)
{
rtems_libio_t *iop;
int err = 0;
1101ce: 31 f6 xor %esi,%esi
if (filsdes[1] < 0) {
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
1101d0: 83 ec 0c sub $0xc,%esp
1101d3: 53 push %ebx
1101d4: e8 5b b2 ff ff call 10b434 <unlink>
1101d9: 83 c4 10 add $0x10,%esp
}
if(err != 0)
1101dc: 85 f6 test %esi,%esi
1101de: 75 63 jne 110243 <pipe_create+0x12b>
rtems_set_errno_and_return_minus_one(err);
return 0;
1101e0: 31 c0 xor %eax,%eax
}
1101e2: 8d 65 f4 lea -0xc(%ebp),%esp
1101e5: 5b pop %ebx
1101e6: 5e pop %esi
1101e7: 5f pop %edi
1101e8: c9 leave
1101e9: c3 ret
1101ea: 66 90 xchg %ax,%ax
the file node will be deleted after it is closed by all. */
unlink(fifopath);
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
1101ec: c1 e0 03 shl $0x3,%eax
1101ef: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
1101f6: 29 c2 sub %eax,%edx
1101f8: 03 15 00 73 12 00 add 0x127300,%edx
1101fe: eb b2 jmp 1101b2 <pipe_create+0x9a>
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
if (filsdes[0] < 0) {
err = errno;
110200: e8 cf 31 00 00 call 1133d4 <__errno>
110205: 8b 30 mov (%eax),%esi
/* Delete file at errors, or else if pipe is successfully created
the file node will be deleted after it is closed by all. */
unlink(fifopath);
110207: 83 ec 0c sub $0xc,%esp
11020a: 53 push %ebx
11020b: e8 24 b2 ff ff call 10b434 <unlink>
110210: 83 c4 10 add $0x10,%esp
110213: eb c7 jmp 1101dc <pipe_create+0xc4>
110215: 8d 76 00 lea 0x0(%esi),%esi
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
if (filsdes[1] < 0) {
err = errno;
110218: e8 b7 31 00 00 call 1133d4 <__errno>
11021d: 8b 30 mov (%eax),%esi
close(filsdes[0]);
11021f: 83 ec 0c sub $0xc,%esp
110222: 8b 45 08 mov 0x8(%ebp),%eax
110225: ff 30 pushl (%eax)
110227: e8 1c 82 ff ff call 108448 <close>
11022c: 83 c4 10 add $0x10,%esp
11022f: eb 9f jmp 1101d0 <pipe_create+0xb8>
110231: 8d 76 00 lea 0x0(%esi),%esi
memcpy(fifopath, "/tmp/.fifo", 10);
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
if (errno != EEXIST){
110234: e8 9b 31 00 00 call 1133d4 <__errno>
return -1;
110239: b8 ff ff ff ff mov $0xffffffff,%eax
11023e: e9 f9 fe ff ff jmp 11013c <pipe_create+0x24>
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
110243: e8 8c 31 00 00 call 1133d4 <__errno>
110248: 89 30 mov %esi,(%eax)
11024a: b8 ff ff ff ff mov $0xffffffff,%eax
11024f: e9 e8 fe ff ff jmp 11013c <pipe_create+0x24>
00111590 <pipe_ioctl>:
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
111590: 55 push %ebp
111591: 89 e5 mov %esp,%ebp
111593: 56 push %esi
111594: 53 push %ebx
111595: 8b 75 08 mov 0x8(%ebp),%esi
111598: 8b 5d 10 mov 0x10(%ebp),%ebx
if (cmd == FIONREAD) {
11159b: 81 7d 0c 7f 66 04 40 cmpl $0x4004667f,0xc(%ebp)
1115a2: 74 0c je 1115b0 <pipe_ioctl+0x20>
*(unsigned int *)buffer = pipe->Length;
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
1115a4: b8 ea ff ff ff mov $0xffffffea,%eax
}
1115a9: 8d 65 f8 lea -0x8(%ebp),%esp
1115ac: 5b pop %ebx
1115ad: 5e pop %esi
1115ae: c9 leave
1115af: c3 ret
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
1115b0: 85 db test %ebx,%ebx
1115b2: 75 07 jne 1115bb <pipe_ioctl+0x2b>
return -EFAULT;
1115b4: b8 f2 ff ff ff mov $0xfffffff2,%eax
1115b9: eb ee jmp 1115a9 <pipe_ioctl+0x19>
if (! PIPE_LOCK(pipe))
1115bb: 50 push %eax
1115bc: 6a 00 push $0x0
1115be: 6a 00 push $0x0
1115c0: ff 76 28 pushl 0x28(%esi)
1115c3: e8 f4 b2 ff ff call 10c8bc <rtems_semaphore_obtain>
1115c8: 83 c4 10 add $0x10,%esp
1115cb: 85 c0 test %eax,%eax
1115cd: 74 07 je 1115d6 <pipe_ioctl+0x46> <== ALWAYS TAKEN
return -EINTR;
1115cf: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED
1115d4: eb d3 jmp 1115a9 <pipe_ioctl+0x19> <== NOT EXECUTED
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
1115d6: 8b 46 0c mov 0xc(%esi),%eax
1115d9: 89 03 mov %eax,(%ebx)
PIPE_UNLOCK(pipe);
1115db: 83 ec 0c sub $0xc,%esp
1115de: ff 76 28 pushl 0x28(%esi)
1115e1: e8 d2 b3 ff ff call 10c9b8 <rtems_semaphore_release>
return 0;
1115e6: 83 c4 10 add $0x10,%esp
1115e9: 31 c0 xor %eax,%eax
1115eb: eb bc jmp 1115a9 <pipe_ioctl+0x19>
001111f4 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
1111f4: 55 push %ebp
1111f5: 89 e5 mov %esp,%ebp
1111f7: 57 push %edi
1111f8: 56 push %esi
1111f9: 53 push %ebx
1111fa: 83 ec 30 sub $0x30,%esp
1111fd: 8b 5d 08 mov 0x8(%ebp),%ebx
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
111200: 6a 00 push $0x0
111202: 6a 00 push $0x0
111204: ff 73 28 pushl 0x28(%ebx)
111207: e8 b0 b6 ff ff call 10c8bc <rtems_semaphore_obtain>
11120c: 83 c4 10 add $0x10,%esp
11120f: 85 c0 test %eax,%eax
111211: 0f 85 ad 00 00 00 jne 1112c4 <pipe_read+0xd0> <== NEVER TAKEN
return -EINTR;
while (read < count) {
111217: 8b 45 10 mov 0x10(%ebp),%eax
11121a: 85 c0 test %eax,%eax
11121c: 0f 84 7a 01 00 00 je 11139c <pipe_read+0x1a8> <== NEVER TAKEN
111222: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
111229: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
while (PIPE_EMPTY(pipe)) {
111230: 8b 53 0c mov 0xc(%ebx),%edx
111233: 85 d2 test %edx,%edx
111235: 0f 85 99 00 00 00 jne 1112d4 <pipe_read+0xe0>
/* Not an error */
if (pipe->Writers == 0)
11123b: 8b 7b 14 mov 0x14(%ebx),%edi
11123e: 85 ff test %edi,%edi
111240: 0f 84 fe 00 00 00 je 111344 <pipe_read+0x150>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
111246: 8b 45 14 mov 0x14(%ebp),%eax
111249: f6 40 14 01 testb $0x1,0x14(%eax)
11124d: 0f 85 f9 00 00 00 jne 11134c <pipe_read+0x158>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
111253: ff 43 18 incl 0x18(%ebx)
PIPE_UNLOCK(pipe);
111256: 83 ec 0c sub $0xc,%esp
111259: ff 73 28 pushl 0x28(%ebx)
11125c: e8 57 b7 ff ff call 10c9b8 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
111261: 59 pop %ecx
111262: 5e pop %esi
111263: 6a 00 push $0x0
111265: ff 73 2c pushl 0x2c(%ebx)
111268: e8 97 0f 00 00 call 112204 <rtems_barrier_wait>
11126d: 83 c4 0c add $0xc,%esp
111270: 83 f8 01 cmp $0x1,%eax
111273: 19 f6 sbb %esi,%esi
111275: f7 d6 not %esi
111277: 83 e6 fc and $0xfffffffc,%esi
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
11127a: 6a 00 push $0x0
11127c: 6a 00 push $0x0
11127e: ff 73 28 pushl 0x28(%ebx)
111281: e8 36 b6 ff ff call 10c8bc <rtems_semaphore_obtain>
111286: 83 c4 10 add $0x10,%esp
111289: 85 c0 test %eax,%eax
11128b: 0f 85 c7 00 00 00 jne 111358 <pipe_read+0x164> <== NEVER TAKEN
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
111291: ff 4b 18 decl 0x18(%ebx)
if (ret != 0)
111294: 85 f6 test %esi,%esi
111296: 74 98 je 111230 <pipe_read+0x3c> <== ALWAYS TAKEN
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
111298: 83 ec 0c sub $0xc,%esp
11129b: ff 73 28 pushl 0x28(%ebx)
11129e: e8 15 b7 ff ff call 10c9b8 <rtems_semaphore_release>
1112a3: 83 c4 10 add $0x10,%esp
out_nolock:
if (read > 0)
1112a6: 8b 45 d4 mov -0x2c(%ebp),%eax
1112a9: 85 c0 test %eax,%eax
1112ab: 7e 0b jle 1112b8 <pipe_read+0xc4>
1112ad: 8b 45 d4 mov -0x2c(%ebp),%eax
return read;
return ret;
}
1112b0: 8d 65 f4 lea -0xc(%ebp),%esp
1112b3: 5b pop %ebx
1112b4: 5e pop %esi
1112b5: 5f pop %edi
1112b6: c9 leave
1112b7: c3 ret
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
return read;
return ret;
1112b8: 89 f0 mov %esi,%eax
}
1112ba: 8d 65 f4 lea -0xc(%ebp),%esp
1112bd: 5b pop %ebx
1112be: 5e pop %esi
1112bf: 5f pop %edi
1112c0: c9 leave
1112c1: c3 ret
1112c2: 66 90 xchg %ax,%ax
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
1112c4: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED
out_nolock:
if (read > 0)
return read;
return ret;
}
1112c9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1112cc: 5b pop %ebx <== NOT EXECUTED
1112cd: 5e pop %esi <== NOT EXECUTED
1112ce: 5f pop %edi <== NOT EXECUTED
1112cf: c9 leave <== NOT EXECUTED
1112d0: c3 ret <== NOT EXECUTED
1112d1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
1112d4: 8b 45 10 mov 0x10(%ebp),%eax
1112d7: 2b 45 d0 sub -0x30(%ebp),%eax
1112da: 89 55 cc mov %edx,-0x34(%ebp)
1112dd: 39 c2 cmp %eax,%edx
1112df: 76 03 jbe 1112e4 <pipe_read+0xf0>
1112e1: 89 45 cc mov %eax,-0x34(%ebp)
chunk1 = pipe->Size - pipe->Start;
1112e4: 8b 73 08 mov 0x8(%ebx),%esi
1112e7: 8b 43 04 mov 0x4(%ebx),%eax
1112ea: 29 f0 sub %esi,%eax
if (chunk > chunk1) {
1112ec: 39 45 cc cmp %eax,-0x34(%ebp)
1112ef: 7f 71 jg 111362 <pipe_read+0x16e>
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
1112f1: 8b 45 0c mov 0xc(%ebp),%eax
1112f4: 03 45 d0 add -0x30(%ebp),%eax
1112f7: 03 33 add (%ebx),%esi
1112f9: 89 c7 mov %eax,%edi
1112fb: 8b 4d cc mov -0x34(%ebp),%ecx
1112fe: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
pipe->Start += chunk;
111300: 8b 45 cc mov -0x34(%ebp),%eax
111303: 03 43 08 add 0x8(%ebx),%eax
pipe->Start %= pipe->Size;
111306: 31 d2 xor %edx,%edx
111308: f7 73 04 divl 0x4(%ebx)
11130b: 89 53 08 mov %edx,0x8(%ebx)
pipe->Length -= chunk;
11130e: 8b 43 0c mov 0xc(%ebx),%eax
111311: 2b 45 cc sub -0x34(%ebp),%eax
111314: 89 43 0c mov %eax,0xc(%ebx)
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
111317: 85 c0 test %eax,%eax
111319: 75 07 jne 111322 <pipe_read+0x12e>
pipe->Start = 0;
11131b: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
if (pipe->waitingWriters > 0)
111322: 8b 53 1c mov 0x1c(%ebx),%edx
111325: 85 d2 test %edx,%edx
111327: 75 5f jne 111388 <pipe_read+0x194>
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
111329: 8b 45 cc mov -0x34(%ebp),%eax
11132c: 01 45 d4 add %eax,-0x2c(%ebp)
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
11132f: 8b 45 d4 mov -0x2c(%ebp),%eax
111332: 89 45 d0 mov %eax,-0x30(%ebp)
111335: 8b 45 10 mov 0x10(%ebp),%eax
111338: 39 45 d4 cmp %eax,-0x2c(%ebp)
11133b: 0f 82 ef fe ff ff jb 111230 <pipe_read+0x3c> <== NEVER TAKEN
111341: 8d 76 00 lea 0x0(%esi),%esi
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
111344: 31 f6 xor %esi,%esi
111346: e9 4d ff ff ff jmp 111298 <pipe_read+0xa4>
11134b: 90 nop
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
11134c: be f5 ff ff ff mov $0xfffffff5,%esi
111351: e9 42 ff ff ff jmp 111298 <pipe_read+0xa4>
111356: 66 90 xchg %ax,%ax
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
111358: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED
11135d: e9 44 ff ff ff jmp 1112a6 <pipe_read+0xb2> <== NOT EXECUTED
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
if (chunk > chunk1) {
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
111362: 8b 55 0c mov 0xc(%ebp),%edx
111365: 03 55 d0 add -0x30(%ebp),%edx
111368: 03 33 add (%ebx),%esi
11136a: 89 d7 mov %edx,%edi
11136c: 89 c1 mov %eax,%ecx
11136e: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
111370: 8b 55 d0 mov -0x30(%ebp),%edx
111373: 01 c2 add %eax,%edx
111375: 03 55 0c add 0xc(%ebp),%edx
111378: 8b 4d cc mov -0x34(%ebp),%ecx
11137b: 29 c1 sub %eax,%ecx
11137d: 8b 33 mov (%ebx),%esi
11137f: 89 d7 mov %edx,%edi
111381: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
111383: e9 78 ff ff ff jmp 111300 <pipe_read+0x10c>
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
111388: 83 ec 08 sub $0x8,%esp
11138b: 8d 45 e4 lea -0x1c(%ebp),%eax
11138e: 50 push %eax
11138f: ff 73 30 pushl 0x30(%ebx)
111392: e8 09 0e 00 00 call 1121a0 <rtems_barrier_release>
111397: 83 c4 10 add $0x10,%esp
11139a: eb 8d jmp 111329 <pipe_read+0x135>
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
11139c: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED
1113a3: 31 f6 xor %esi,%esi <== NOT EXECUTED
1113a5: e9 ee fe ff ff jmp 111298 <pipe_read+0xa4> <== NOT EXECUTED
00110ce0 <pipe_release>:
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
110ce0: 55 push %ebp
110ce1: 89 e5 mov %esp,%ebp
110ce3: 57 push %edi
110ce4: 56 push %esi
110ce5: 53 push %ebx
110ce6: 83 ec 1c sub $0x1c,%esp
110ce9: 8b 7d 08 mov 0x8(%ebp),%edi
pipe_control_t *pipe = *pipep;
110cec: 8b 1f mov (%edi),%ebx
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
110cee: 8b 45 0c mov 0xc(%ebp),%eax
110cf1: 8b 40 14 mov 0x14(%eax),%eax
110cf4: 89 c6 mov %eax,%esi
110cf6: 83 e6 06 and $0x6,%esi
if (mode & LIBIO_FLAGS_READ)
110cf9: a8 02 test $0x2,%al
110cfb: 74 03 je 110d00 <pipe_release+0x20>
pipe->Readers --;
110cfd: ff 4b 10 decl 0x10(%ebx)
if (mode & LIBIO_FLAGS_WRITE)
110d00: f7 c6 04 00 00 00 test $0x4,%esi
110d06: 74 03 je 110d0b <pipe_release+0x2b>
pipe->Writers --;
110d08: ff 4b 14 decl 0x14(%ebx)
PIPE_UNLOCK(pipe);
110d0b: 83 ec 0c sub $0xc,%esp
110d0e: ff 73 28 pushl 0x28(%ebx)
110d11: e8 a2 bc ff ff call 10c9b8 <rtems_semaphore_release>
if (pipe->Readers == 0 && pipe->Writers == 0) {
110d16: 83 c4 10 add $0x10,%esp
110d19: 8b 53 10 mov 0x10(%ebx),%edx
110d1c: 85 d2 test %edx,%edx
110d1e: 74 2c je 110d4c <pipe_release+0x6c>
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
110d20: 8b 43 14 mov 0x14(%ebx),%eax
110d23: 85 c0 test %eax,%eax
110d25: 75 17 jne 110d3e <pipe_release+0x5e> <== NEVER TAKEN
110d27: 83 fe 02 cmp $0x2,%esi
110d2a: 74 12 je 110d3e <pipe_release+0x5e> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
110d2c: 83 ec 08 sub $0x8,%esp
110d2f: 8d 45 e4 lea -0x1c(%ebp),%eax
110d32: 50 push %eax
110d33: ff 73 2c pushl 0x2c(%ebx)
110d36: e8 65 14 00 00 call 1121a0 <rtems_barrier_release>
110d3b: 83 c4 10 add $0x10,%esp
pipe_unlock();
110d3e: e8 85 ff ff ff call 110cc8 <pipe_unlock>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
110d43: 8d 65 f4 lea -0xc(%ebp),%esp
110d46: 5b pop %ebx
110d47: 5e pop %esi
110d48: 5f pop %edi
110d49: c9 leave
110d4a: c3 ret
110d4b: 90 nop
if (mode & LIBIO_FLAGS_WRITE)
pipe->Writers --;
PIPE_UNLOCK(pipe);
if (pipe->Readers == 0 && pipe->Writers == 0) {
110d4c: 8b 43 14 mov 0x14(%ebx),%eax
110d4f: 85 c0 test %eax,%eax
110d51: 74 25 je 110d78 <pipe_release+0x98>
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
110d53: 83 fe 04 cmp $0x4,%esi
110d56: 74 e6 je 110d3e <pipe_release+0x5e> <== NEVER TAKEN
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
110d58: 83 ec 08 sub $0x8,%esp
110d5b: 8d 45 e4 lea -0x1c(%ebp),%eax
110d5e: 50 push %eax
110d5f: ff 73 30 pushl 0x30(%ebx)
110d62: e8 39 14 00 00 call 1121a0 <rtems_barrier_release>
110d67: 83 c4 10 add $0x10,%esp
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
PIPE_WAKEUPREADERS(pipe);
pipe_unlock();
110d6a: e8 59 ff ff ff call 110cc8 <pipe_unlock>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
110d6f: 8d 65 f4 lea -0xc(%ebp),%esp
110d72: 5b pop %ebx
110d73: 5e pop %esi
110d74: 5f pop %edi
110d75: c9 leave
110d76: c3 ret
110d77: 90 nop
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
110d78: 83 ec 0c sub $0xc,%esp
110d7b: ff 73 2c pushl 0x2c(%ebx)
110d7e: e8 8d 13 00 00 call 112110 <rtems_barrier_delete>
rtems_barrier_delete(pipe->writeBarrier);
110d83: 5e pop %esi
110d84: ff 73 30 pushl 0x30(%ebx)
110d87: e8 84 13 00 00 call 112110 <rtems_barrier_delete>
rtems_semaphore_delete(pipe->Semaphore);
110d8c: 59 pop %ecx
110d8d: ff 73 28 pushl 0x28(%ebx)
110d90: e8 83 ba ff ff call 10c818 <rtems_semaphore_delete>
free(pipe->Buffer);
110d95: 5a pop %edx
110d96: ff 33 pushl (%ebx)
110d98: e8 c3 80 ff ff call 108e60 <free>
free(pipe);
110d9d: 89 1c 24 mov %ebx,(%esp)
110da0: e8 bb 80 ff ff call 108e60 <free>
/* To delete an anonymous pipe file when all users closed it */
if (pipe->Anonymous)
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
110da5: c7 07 00 00 00 00 movl $0x0,(%edi)
110dab: 83 c4 10 add $0x10,%esp
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
PIPE_WAKEUPREADERS(pipe);
pipe_unlock();
110dae: e8 15 ff ff ff call 110cc8 <pipe_unlock>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
110db3: 8d 65 f4 lea -0xc(%ebp),%esp
110db6: 5b pop %ebx
110db7: 5e pop %esi
110db8: 5f pop %edi
110db9: c9 leave
110dba: c3 ret
001113ac <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
1113ac: 55 push %ebp
1113ad: 89 e5 mov %esp,%ebp
1113af: 57 push %edi
1113b0: 56 push %esi
1113b1: 53 push %ebx
1113b2: 83 ec 2c sub $0x2c,%esp
1113b5: 8b 5d 10 mov 0x10(%ebp),%ebx
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
1113b8: 85 db test %ebx,%ebx
1113ba: 75 0c jne 1113c8 <pipe_write+0x1c> <== ALWAYS TAKEN
return 0;
1113bc: 31 c0 xor %eax,%eax
#endif
if (written > 0)
return written;
return ret;
}
1113be: 8d 65 f4 lea -0xc(%ebp),%esp
1113c1: 5b pop %ebx
1113c2: 5e pop %esi
1113c3: 5f pop %edi
1113c4: c9 leave
1113c5: c3 ret
1113c6: 66 90 xchg %ax,%ax
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
1113c8: 56 push %esi
1113c9: 6a 00 push $0x0
1113cb: 6a 00 push $0x0
1113cd: 8b 45 08 mov 0x8(%ebp),%eax
1113d0: ff 70 28 pushl 0x28(%eax)
1113d3: e8 e4 b4 ff ff call 10c8bc <rtems_semaphore_obtain>
1113d8: 83 c4 10 add $0x10,%esp
1113db: 85 c0 test %eax,%eax
1113dd: 0f 85 45 01 00 00 jne 111528 <pipe_write+0x17c> <== NEVER TAKEN
return -EINTR;
if (pipe->Readers == 0) {
1113e3: 8b 45 08 mov 0x8(%ebp),%eax
1113e6: 8b 48 10 mov 0x10(%eax),%ecx
1113e9: 85 c9 test %ecx,%ecx
1113eb: 0f 84 52 01 00 00 je 111543 <pipe_write+0x197>
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
1113f1: 8b 48 04 mov 0x4(%eax),%ecx
1113f4: 39 cb cmp %ecx,%ebx
1113f6: 0f 87 3d 01 00 00 ja 111539 <pipe_write+0x18d> <== NEVER TAKEN
1113fc: 89 de mov %ebx,%esi
1113fe: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
111405: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
11140c: 89 5d c8 mov %ebx,-0x38(%ebp)
11140f: 8b 5d 08 mov 0x8(%ebp),%ebx
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
111412: 8b 43 0c mov 0xc(%ebx),%eax
111415: 89 ca mov %ecx,%edx
111417: 29 c2 sub %eax,%edx
111419: 39 f2 cmp %esi,%edx
11141b: 73 6f jae 11148c <pipe_write+0xe0>
if (LIBIO_NODELAY(iop)) {
11141d: 8b 45 14 mov 0x14(%ebp),%eax
111420: f6 40 14 01 testb $0x1,0x14(%eax)
111424: 0f 85 2e 01 00 00 jne 111558 <pipe_write+0x1ac>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
11142a: ff 43 1c incl 0x1c(%ebx)
PIPE_UNLOCK(pipe);
11142d: 83 ec 0c sub $0xc,%esp
111430: ff 73 28 pushl 0x28(%ebx)
111433: e8 80 b5 ff ff call 10c9b8 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
111438: 58 pop %eax
111439: 5a pop %edx
11143a: 6a 00 push $0x0
11143c: ff 73 30 pushl 0x30(%ebx)
11143f: e8 c0 0d 00 00 call 112204 <rtems_barrier_wait>
111444: 83 c4 0c add $0xc,%esp
111447: 83 f8 01 cmp $0x1,%eax
11144a: 19 ff sbb %edi,%edi
11144c: f7 d7 not %edi
11144e: 83 e7 fc and $0xfffffffc,%edi
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
111451: 6a 00 push $0x0
111453: 6a 00 push $0x0
111455: ff 73 28 pushl 0x28(%ebx)
111458: e8 5f b4 ff ff call 10c8bc <rtems_semaphore_obtain>
11145d: 83 c4 10 add $0x10,%esp
111460: 85 c0 test %eax,%eax
111462: 0f 85 e9 00 00 00 jne 111551 <pipe_write+0x1a5> <== NEVER TAKEN
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
111468: ff 4b 1c decl 0x1c(%ebx)
if (ret != 0)
11146b: 85 ff test %edi,%edi
11146d: 0f 85 95 00 00 00 jne 111508 <pipe_write+0x15c> <== NEVER TAKEN
goto out_locked;
if (pipe->Readers == 0) {
111473: 8b 7b 10 mov 0x10(%ebx),%edi
111476: 85 ff test %edi,%edi
111478: 0f 84 85 00 00 00 je 111503 <pipe_write+0x157> <== NEVER TAKEN
11147e: 8b 4b 04 mov 0x4(%ebx),%ecx
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
111481: 8b 43 0c mov 0xc(%ebx),%eax
111484: 89 ca mov %ecx,%edx
111486: 29 c2 sub %eax,%edx
111488: 39 f2 cmp %esi,%edx
11148a: 72 91 jb 11141d <pipe_write+0x71> <== NEVER TAKEN
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
11148c: 8b 75 c8 mov -0x38(%ebp),%esi
11148f: 2b 75 d0 sub -0x30(%ebp),%esi
111492: 89 55 cc mov %edx,-0x34(%ebp)
111495: 39 f2 cmp %esi,%edx
111497: 76 03 jbe 11149c <pipe_write+0xf0>
111499: 89 75 cc mov %esi,-0x34(%ebp)
chunk1 = pipe->Size - PIPE_WSTART(pipe);
11149c: 03 43 08 add 0x8(%ebx),%eax
11149f: 31 d2 xor %edx,%edx
1114a1: f7 f1 div %ecx
1114a3: 89 c8 mov %ecx,%eax
1114a5: 29 d0 sub %edx,%eax
if (chunk > chunk1) {
1114a7: 39 45 cc cmp %eax,-0x34(%ebp)
1114aa: 0f 8e af 00 00 00 jle 11155f <pipe_write+0x1b3>
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
1114b0: 03 13 add (%ebx),%edx
1114b2: 8b 75 0c mov 0xc(%ebp),%esi
1114b5: 03 75 d0 add -0x30(%ebp),%esi
1114b8: 89 d7 mov %edx,%edi
1114ba: 89 c1 mov %eax,%ecx
1114bc: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
1114be: 8b 13 mov (%ebx),%edx
1114c0: 8b 4d cc mov -0x34(%ebp),%ecx
1114c3: 29 c1 sub %eax,%ecx
1114c5: 03 45 d0 add -0x30(%ebp),%eax
1114c8: 8b 75 0c mov 0xc(%ebp),%esi
1114cb: 01 c6 add %eax,%esi
1114cd: 89 d7 mov %edx,%edi
1114cf: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
1114d1: 8b 45 cc mov -0x34(%ebp),%eax
1114d4: 01 43 0c add %eax,0xc(%ebx)
if (pipe->waitingReaders > 0)
1114d7: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
1114db: 0f 85 92 00 00 00 jne 111573 <pipe_write+0x1c7>
PIPE_WAKEUPREADERS(pipe);
written += chunk;
1114e1: 8b 45 cc mov -0x34(%ebp),%eax
1114e4: 01 45 d4 add %eax,-0x2c(%ebp)
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
1114e7: 8b 45 d4 mov -0x2c(%ebp),%eax
1114ea: 89 45 d0 mov %eax,-0x30(%ebp)
1114ed: 39 45 c8 cmp %eax,-0x38(%ebp)
1114f0: 0f 86 93 00 00 00 jbe 111589 <pipe_write+0x1dd> <== ALWAYS TAKEN
1114f6: 8b 4b 04 mov 0x4(%ebx),%ecx <== NOT EXECUTED
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
written += chunk;
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
1114f9: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED
1114fe: e9 0f ff ff ff jmp 111412 <pipe_write+0x66> <== NOT EXECUTED
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
111503: bf e0 ff ff ff mov $0xffffffe0,%edi <== NOT EXECUTED
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
111508: 83 ec 0c sub $0xc,%esp
11150b: 8b 45 08 mov 0x8(%ebp),%eax
11150e: ff 70 28 pushl 0x28(%eax)
111511: e8 a2 b4 ff ff call 10c9b8 <rtems_semaphore_release>
111516: 83 c4 10 add $0x10,%esp
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
111519: 8b 55 d4 mov -0x2c(%ebp),%edx
11151c: 85 d2 test %edx,%edx
11151e: 7e 12 jle 111532 <pipe_write+0x186>
111520: 8b 45 d4 mov -0x2c(%ebp),%eax
111523: e9 96 fe ff ff jmp 1113be <pipe_write+0x12>
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
111528: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED
11152d: e9 8c fe ff ff jmp 1113be <pipe_write+0x12> <== NOT EXECUTED
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
return written;
return ret;
111532: 89 f8 mov %edi,%eax
111534: e9 85 fe ff ff jmp 1113be <pipe_write+0x12>
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
111539: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED
11153e: e9 bb fe ff ff jmp 1113fe <pipe_write+0x52> <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
if (pipe->Readers == 0) {
ret = -EPIPE;
111543: bf e0 ff ff ff mov $0xffffffe0,%edi
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
int chunk, chunk1, written = 0, ret = 0;
111548: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
11154f: eb b7 jmp 111508 <pipe_write+0x15c>
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
111551: bf fc ff ff ff mov $0xfffffffc,%edi <== NOT EXECUTED
111556: eb c1 jmp 111519 <pipe_write+0x16d> <== NOT EXECUTED
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
111558: bf f5 ff ff ff mov $0xfffffff5,%edi
11155d: eb a9 jmp 111508 <pipe_write+0x15c>
if (chunk > chunk1) {
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
11155f: 03 13 add (%ebx),%edx
111561: 8b 75 0c mov 0xc(%ebp),%esi
111564: 03 75 d0 add -0x30(%ebp),%esi
111567: 89 d7 mov %edx,%edi
111569: 8b 4d cc mov -0x34(%ebp),%ecx
11156c: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
11156e: e9 5e ff ff ff jmp 1114d1 <pipe_write+0x125>
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
111573: 51 push %ecx
111574: 51 push %ecx
111575: 8d 45 e4 lea -0x1c(%ebp),%eax
111578: 50 push %eax
111579: ff 73 2c pushl 0x2c(%ebx)
11157c: e8 1f 0c 00 00 call 1121a0 <rtems_barrier_release>
111581: 83 c4 10 add $0x10,%esp
111584: e9 58 ff ff ff jmp 1114e1 <pipe_write+0x135>
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
111589: 31 ff xor %edi,%edi
11158b: e9 78 ff ff ff jmp 111508 <pipe_write+0x15c>
0010b0d8 <posix_memalign>:
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
10b0d8: 55 push %ebp
10b0d9: 89 e5 mov %esp,%ebp
10b0db: 53 push %ebx
10b0dc: 83 ec 04 sub $0x4,%esp
10b0df: 8b 45 0c mov 0xc(%ebp),%eax
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
10b0e2: ff 05 88 d4 12 00 incl 0x12d488
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
10b0e8: 8d 50 ff lea -0x1(%eax),%edx
10b0eb: 85 c2 test %eax,%edx
10b0ed: 75 05 jne 10b0f4 <posix_memalign+0x1c> <== NEVER TAKEN
10b0ef: 83 f8 03 cmp $0x3,%eax
10b0f2: 77 0c ja 10b100 <posix_memalign+0x28>
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
}
10b0f4: b8 16 00 00 00 mov $0x16,%eax
10b0f9: 5a pop %edx
10b0fa: 5b pop %ebx
10b0fb: c9 leave
10b0fc: c3 ret
10b0fd: 8d 76 00 lea 0x0(%esi),%esi
10b100: 59 pop %ecx
10b101: 5b pop %ebx
10b102: c9 leave
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
10b103: e9 78 01 00 00 jmp 10b280 <rtems_memalign>
0011dd7c <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
11dd7c: 55 push %ebp
11dd7d: 89 e5 mov %esp,%ebp
11dd7f: 53 push %ebx
11dd80: 83 ec 04 sub $0x4,%esp
11dd83: 8b 4d 08 mov 0x8(%ebp),%ecx
11dd86: 8b 45 0c mov 0xc(%ebp),%eax
11dd89: 8b 55 10 mov 0x10(%ebp),%edx
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
11dd8c: 3b 0d ec 21 12 00 cmp 0x1221ec,%ecx
11dd92: 73 50 jae 11dde4 <read+0x68> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
11dd94: c1 e1 03 shl $0x3,%ecx
11dd97: 8d 1c cd 00 00 00 00 lea 0x0(,%ecx,8),%ebx
11dd9e: 29 cb sub %ecx,%ebx
11dda0: 03 1d 80 63 12 00 add 0x126380,%ebx
rtems_libio_check_is_open( iop );
11dda6: 8b 4b 14 mov 0x14(%ebx),%ecx
11dda9: f6 c5 01 test $0x1,%ch
11ddac: 74 36 je 11dde4 <read+0x68>
rtems_libio_check_buffer( buffer );
11ddae: 85 c0 test %eax,%eax
11ddb0: 74 46 je 11ddf8 <read+0x7c> <== NEVER TAKEN
rtems_libio_check_count( count );
11ddb2: 85 d2 test %edx,%edx
11ddb4: 74 26 je 11dddc <read+0x60>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
11ddb6: 83 e1 02 and $0x2,%ecx
11ddb9: 74 3d je 11ddf8 <read+0x7c>
/*
* Now process the read().
*/
rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
11ddbb: 51 push %ecx
11ddbc: 8b 4b 20 mov 0x20(%ebx),%ecx
11ddbf: 52 push %edx
11ddc0: 50 push %eax
11ddc1: 53 push %ebx
11ddc2: ff 51 08 call *0x8(%ecx)
if ( rc > 0 )
11ddc5: 83 c4 10 add $0x10,%esp
11ddc8: 85 c0 test %eax,%eax
11ddca: 7e 0b jle 11ddd7 <read+0x5b>
iop->offset += rc;
11ddcc: 89 c1 mov %eax,%ecx
11ddce: c1 f9 1f sar $0x1f,%ecx
11ddd1: 01 43 0c add %eax,0xc(%ebx)
11ddd4: 11 4b 10 adc %ecx,0x10(%ebx)
return rc;
}
11ddd7: 8b 5d fc mov -0x4(%ebp),%ebx
11ddda: c9 leave
11dddb: c3 ret
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
11dddc: 31 c0 xor %eax,%eax
if ( rc > 0 )
iop->offset += rc;
return rc;
}
11ddde: 8b 5d fc mov -0x4(%ebp),%ebx
11dde1: c9 leave
11dde2: c3 ret
11dde3: 90 nop
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
11dde4: e8 f3 3f ff ff call 111ddc <__errno>
11dde9: c7 00 09 00 00 00 movl $0x9,(%eax)
11ddef: b8 ff ff ff ff mov $0xffffffff,%eax
11ddf4: eb e1 jmp 11ddd7 <read+0x5b>
11ddf6: 66 90 xchg %ax,%ax
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
11ddf8: e8 df 3f ff ff call 111ddc <__errno>
11ddfd: c7 00 16 00 00 00 movl $0x16,(%eax)
11de03: b8 ff ff ff ff mov $0xffffffff,%eax
11de08: eb cd jmp 11ddd7 <read+0x5b>
0010a600 <readlink>:
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
10a600: 55 push %ebp
10a601: 89 e5 mov %esp,%ebp
10a603: 57 push %edi
10a604: 56 push %esi
10a605: 53 push %ebx
10a606: 83 ec 3c sub $0x3c,%esp
10a609: 8b 55 08 mov 0x8(%ebp),%edx
10a60c: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
10a60f: 85 db test %ebx,%ebx
10a611: 74 6d je 10a680 <readlink+0x80>
rtems_set_errno_and_return_minus_one( EFAULT );
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
10a613: 31 c0 xor %eax,%eax
10a615: b9 ff ff ff ff mov $0xffffffff,%ecx
10a61a: 89 d7 mov %edx,%edi
10a61c: f2 ae repnz scas %es:(%edi),%al
10a61e: f7 d1 not %ecx
10a620: 49 dec %ecx
10a621: 83 ec 0c sub $0xc,%esp
10a624: 6a 00 push $0x0
10a626: 8d 75 d4 lea -0x2c(%ebp),%esi
10a629: 56 push %esi
10a62a: 6a 00 push $0x0
10a62c: 51 push %ecx
10a62d: 52 push %edx
10a62e: e8 51 ee ff ff call 109484 <rtems_filesystem_evaluate_path>
0, &loc, false );
if ( result != 0 )
10a633: 83 c4 20 add $0x20,%esp
10a636: 85 c0 test %eax,%eax
10a638: 74 0e je 10a648 <readlink+0x48> <== ALWAYS TAKEN
return -1;
10a63a: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
rtems_filesystem_freenode( &loc );
return result;
}
10a63f: 8d 65 f4 lea -0xc(%ebp),%esp
10a642: 5b pop %ebx
10a643: 5e pop %esi
10a644: 5f pop %edi
10a645: c9 leave
10a646: c3 ret
10a647: 90 nop
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
0, &loc, false );
if ( result != 0 )
return -1;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
10a648: 83 ec 0c sub $0xc,%esp
10a64b: 56 push %esi
10a64c: 8b 45 e0 mov -0x20(%ebp),%eax
10a64f: ff 50 10 call *0x10(%eax)
10a652: 83 c4 10 add $0x10,%esp
10a655: 83 f8 04 cmp $0x4,%eax
10a658: 75 3e jne 10a698 <readlink+0x98>
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( EINVAL );
}
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
10a65a: 50 push %eax
10a65b: ff 75 10 pushl 0x10(%ebp)
10a65e: 53 push %ebx
10a65f: 56 push %esi
10a660: 8b 45 e0 mov -0x20(%ebp),%eax
10a663: ff 50 3c call *0x3c(%eax)
rtems_filesystem_freenode( &loc );
10a666: 89 34 24 mov %esi,(%esp)
10a669: 89 45 c4 mov %eax,-0x3c(%ebp)
10a66c: e8 eb ee ff ff call 10955c <rtems_filesystem_freenode>
return result;
10a671: 83 c4 10 add $0x10,%esp
10a674: 8b 45 c4 mov -0x3c(%ebp),%eax
}
10a677: 8d 65 f4 lea -0xc(%ebp),%esp
10a67a: 5b pop %ebx
10a67b: 5e pop %esi
10a67c: 5f pop %edi
10a67d: c9 leave
10a67e: c3 ret
10a67f: 90 nop
{
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
rtems_set_errno_and_return_minus_one( EFAULT );
10a680: e8 23 a2 00 00 call 1148a8 <__errno>
10a685: c7 00 0e 00 00 00 movl $0xe,(%eax)
10a68b: b8 ff ff ff ff mov $0xffffffff,%eax
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
rtems_filesystem_freenode( &loc );
return result;
}
10a690: 8d 65 f4 lea -0xc(%ebp),%esp
10a693: 5b pop %ebx
10a694: 5e pop %esi
10a695: 5f pop %edi
10a696: c9 leave
10a697: c3 ret
0, &loc, false );
if ( result != 0 )
return -1;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
rtems_filesystem_freenode( &loc );
10a698: 83 ec 0c sub $0xc,%esp
10a69b: 56 push %esi
10a69c: e8 bb ee ff ff call 10955c <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EINVAL );
10a6a1: e8 02 a2 00 00 call 1148a8 <__errno>
10a6a6: c7 00 16 00 00 00 movl $0x16,(%eax)
10a6ac: 83 c4 10 add $0x10,%esp
10a6af: b8 ff ff ff ff mov $0xffffffff,%eax
10a6b4: eb 89 jmp 10a63f <readlink+0x3f>
001092c4 <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
1092c4: 55 push %ebp
1092c5: 89 e5 mov %esp,%ebp
1092c7: 57 push %edi
1092c8: 56 push %esi
1092c9: 53 push %ebx
1092ca: 83 ec 1c sub $0x1c,%esp
1092cd: 8b 45 08 mov 0x8(%ebp),%eax
1092d0: 8b 5d 0c mov 0xc(%ebp),%ebx
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
1092d3: 3b 05 4c 37 12 00 cmp 0x12374c,%eax
1092d9: 0f 83 ef 00 00 00 jae 1093ce <readv+0x10a>
iop = rtems_libio_iop( fd );
1092df: c1 e0 03 shl $0x3,%eax
1092e2: 8d 34 c5 00 00 00 00 lea 0x0(,%eax,8),%esi
1092e9: 29 c6 sub %eax,%esi
1092eb: 03 35 e0 78 12 00 add 0x1278e0,%esi
rtems_libio_check_is_open( iop );
1092f1: 8b 46 14 mov 0x14(%esi),%eax
1092f4: f6 c4 01 test $0x1,%ah
1092f7: 0f 84 d1 00 00 00 je 1093ce <readv+0x10a>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
1092fd: a8 02 test $0x2,%al
1092ff: 0f 84 97 00 00 00 je 10939c <readv+0xd8> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
109305: 85 db test %ebx,%ebx
109307: 0f 84 8f 00 00 00 je 10939c <readv+0xd8>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
10930d: 8b 7d 10 mov 0x10(%ebp),%edi
109310: 85 ff test %edi,%edi
109312: 0f 8e 84 00 00 00 jle 10939c <readv+0xd8>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
109318: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp)
10931f: 7f 7b jg 10939c <readv+0xd8> <== NEVER TAKEN
109321: c6 45 e4 01 movb $0x1,-0x1c(%ebp)
109325: 31 c0 xor %eax,%eax
109327: 31 d2 xor %edx,%edx
109329: eb 03 jmp 10932e <readv+0x6a>
10932b: 90 nop
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
10932c: 89 fa mov %edi,%edx
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
10932e: 8b 0c c3 mov (%ebx,%eax,8),%ecx
109331: 85 c9 test %ecx,%ecx
109333: 74 67 je 10939c <readv+0xd8>
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
109335: 8b 4c c3 04 mov 0x4(%ebx,%eax,8),%ecx
109339: 8d 3c 0a lea (%edx,%ecx,1),%edi
if ( total < old )
10933c: 39 fa cmp %edi,%edx
10933e: 7f 5c jg 10939c <readv+0xd8>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
109340: 85 c9 test %ecx,%ecx
109342: 74 04 je 109348 <readv+0x84>
all_zeros = false;
109344: c6 45 e4 00 movb $0x0,-0x1c(%ebp)
* are obvious errors in the iovec. So this extra loop ensures
* that we do not do anything if there is an argument error.
*/
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
109348: 40 inc %eax
109349: 39 45 10 cmp %eax,0x10(%ebp)
10934c: 7f de jg 10932c <readv+0x68>
/*
* A readv with all zeros logically has no effect. Even though
* OpenGroup didn't address this case as they did with writev(),
* we will handle it the same way for symmetry.
*/
if ( all_zeros == true ) {
10934e: 80 7d e4 00 cmpb $0x0,-0x1c(%ebp)
109352: 75 68 jne 1093bc <readv+0xf8>
109354: 31 ff xor %edi,%edi
109356: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
10935d: eb 1d jmp 10937c <readv+0xb8>
10935f: 90 nop
);
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
109360: 74 0e je 109370 <readv+0xac> <== NEVER TAKEN
iop->offset += bytes;
109362: 89 c1 mov %eax,%ecx
109364: c1 f9 1f sar $0x1f,%ecx
109367: 01 46 0c add %eax,0xc(%esi)
10936a: 11 4e 10 adc %ecx,0x10(%esi)
total += bytes;
10936d: 01 45 e4 add %eax,-0x1c(%ebp)
}
if (bytes != iov[ v ].iov_len)
109370: 3b 44 fb 04 cmp 0x4(%ebx,%edi,8),%eax
109374: 75 38 jne 1093ae <readv+0xea> <== NEVER TAKEN
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
109376: 47 inc %edi
109377: 39 7d 10 cmp %edi,0x10(%ebp)
10937a: 7e 32 jle 1093ae <readv+0xea>
bytes = (*iop->pathinfo.handlers->read_h)(
10937c: 50 push %eax
10937d: 8b 46 20 mov 0x20(%esi),%eax
109380: ff 74 fb 04 pushl 0x4(%ebx,%edi,8)
109384: ff 34 fb pushl (%ebx,%edi,8)
109387: 56 push %esi
109388: ff 50 08 call *0x8(%eax)
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
10938b: 83 c4 10 add $0x10,%esp
10938e: 83 f8 00 cmp $0x0,%eax
109391: 7d cd jge 109360 <readv+0x9c> <== ALWAYS TAKEN
return -1;
109393: c7 45 e4 ff ff ff ff movl $0xffffffff,-0x1c(%ebp) <== NOT EXECUTED
10939a: eb 12 jmp 1093ae <readv+0xea> <== NOT EXECUTED
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old )
rtems_set_errno_and_return_minus_one( EINVAL );
10939c: e8 f7 96 00 00 call 112a98 <__errno>
1093a1: c7 00 16 00 00 00 movl $0x16,(%eax)
1093a7: c7 45 e4 ff ff ff ff movl $0xffffffff,-0x1c(%ebp)
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
1093ae: 8b 45 e4 mov -0x1c(%ebp),%eax
1093b1: 8d 65 f4 lea -0xc(%ebp),%esp
1093b4: 5b pop %ebx
1093b5: 5e pop %esi
1093b6: 5f pop %edi
1093b7: c9 leave
1093b8: c3 ret
1093b9: 8d 76 00 lea 0x0(%esi),%esi
* A readv with all zeros logically has no effect. Even though
* OpenGroup didn't address this case as they did with writev(),
* we will handle it the same way for symmetry.
*/
if ( all_zeros == true ) {
return 0;
1093bc: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
1093c3: 8b 45 e4 mov -0x1c(%ebp),%eax
1093c6: 8d 65 f4 lea -0xc(%ebp),%esp
1093c9: 5b pop %ebx
1093ca: 5e pop %esi
1093cb: 5f pop %edi
1093cc: c9 leave
1093cd: c3 ret
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
1093ce: e8 c5 96 00 00 call 112a98 <__errno>
1093d3: c7 00 09 00 00 00 movl $0x9,(%eax)
1093d9: c7 45 e4 ff ff ff ff movl $0xffffffff,-0x1c(%ebp)
1093e0: eb cc jmp 1093ae <readv+0xea>
0011de98 <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
11de98: 55 push %ebp
11de99: 89 e5 mov %esp,%ebp
11de9b: 57 push %edi
11de9c: 56 push %esi
11de9d: 53 push %ebx
11de9e: 83 ec 2c sub $0x2c,%esp
11dea1: 8b 5d 08 mov 0x8(%ebp),%ebx
11dea4: 8b 75 0c mov 0xc(%ebp),%esi
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
11dea7: ff 05 b0 63 12 00 incl 0x1263b0
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
11dead: 83 3d 80 66 12 00 03 cmpl $0x3,0x126680
11deb4: 74 72 je 11df28 <realloc+0x90> <== ALWAYS TAKEN
}
/*
* Continue with realloc().
*/
if ( !ptr )
11deb6: 85 db test %ebx,%ebx
11deb8: 74 5e je 11df18 <realloc+0x80>
return malloc( size );
if ( !size ) {
11deba: 85 f6 test %esi,%esi
11debc: 74 3a je 11def8 <realloc+0x60> <== NEVER TAKEN
free( ptr );
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
11debe: 52 push %edx
11debf: 8d 45 e4 lea -0x1c(%ebp),%eax
11dec2: 50 push %eax
11dec3: 53 push %ebx
11dec4: ff 35 30 22 12 00 pushl 0x122230
11deca: e8 49 01 00 00 call 11e018 <_Protected_heap_Get_block_size>
11decf: 83 c4 10 add $0x10,%esp
11ded2: 84 c0 test %al,%al
11ded4: 74 32 je 11df08 <realloc+0x70>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
11ded6: 50 push %eax
11ded7: 56 push %esi
11ded8: 53 push %ebx
11ded9: ff 35 30 22 12 00 pushl 0x122230
11dedf: e8 6c 01 00 00 call 11e050 <_Protected_heap_Resize_block>
11dee4: 83 c4 10 add $0x10,%esp
11dee7: 84 c0 test %al,%al
11dee9: 74 5d je 11df48 <realloc+0xb0>
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
11deeb: 89 d8 mov %ebx,%eax
11deed: 8d 65 f4 lea -0xc(%ebp),%esp
11def0: 5b pop %ebx
11def1: 5e pop %esi
11def2: 5f pop %edi
11def3: c9 leave
11def4: c3 ret
11def5: 8d 76 00 lea 0x0(%esi),%esi
*/
if ( !ptr )
return malloc( size );
if ( !size ) {
free( ptr );
11def8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
11defb: 53 push %ebx <== NOT EXECUTED
11defc: e8 33 97 fe ff call 107634 <free> <== NOT EXECUTED
return (void *) 0;
11df01: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
11df04: 31 db xor %ebx,%ebx <== NOT EXECUTED
11df06: eb e3 jmp 11deeb <realloc+0x53> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
11df08: e8 cf 3e ff ff call 111ddc <__errno>
11df0d: c7 00 16 00 00 00 movl $0x16,(%eax)
return (void *) 0;
11df13: 31 db xor %ebx,%ebx
11df15: eb d4 jmp 11deeb <realloc+0x53>
11df17: 90 nop
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
11df18: 83 ec 0c sub $0xc,%esp
11df1b: 56 push %esi
11df1c: e8 e7 99 fe ff call 107908 <malloc>
11df21: 89 c3 mov %eax,%ebx
11df23: 83 c4 10 add $0x10,%esp
11df26: eb c3 jmp 11deeb <realloc+0x53>
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_disable_level > 0)
11df28: a1 ec 64 12 00 mov 0x1264ec,%eax
11df2d: 85 c0 test %eax,%eax
11df2f: 74 04 je 11df35 <realloc+0x9d> <== ALWAYS TAKEN
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
return (void *) 0;
11df31: 31 db xor %ebx,%ebx
11df33: eb b6 jmp 11deeb <realloc+0x53>
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_disable_level > 0)
return (void *) 0;
if (_ISR_Nest_level > 0)
11df35: 8b 0d 74 67 12 00 mov 0x126774,%ecx
11df3b: 85 c9 test %ecx,%ecx
11df3d: 0f 84 73 ff ff ff je 11deb6 <realloc+0x1e> <== ALWAYS TAKEN
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
return (void *) 0;
11df43: 31 db xor %ebx,%ebx
11df45: eb a4 jmp 11deeb <realloc+0x53> <== NOT EXECUTED
11df47: 90 nop <== NOT EXECUTED
* There used to be a free on this error case but it is wrong to
* free the memory per OpenGroup Single UNIX Specification V2
* and the C Standard.
*/
new_area = malloc( size );
11df48: 83 ec 0c sub $0xc,%esp
11df4b: 56 push %esi
11df4c: e8 b7 99 fe ff call 107908 <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
11df51: ff 0d a4 63 12 00 decl 0x1263a4
if ( !new_area ) {
11df57: 83 c4 10 add $0x10,%esp
11df5a: 85 c0 test %eax,%eax
11df5c: 74 d3 je 11df31 <realloc+0x99>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
11df5e: 8b 55 e4 mov -0x1c(%ebp),%edx
11df61: 89 f1 mov %esi,%ecx
11df63: 39 d6 cmp %edx,%esi
11df65: 76 02 jbe 11df69 <realloc+0xd1> <== NEVER TAKEN
11df67: 89 d1 mov %edx,%ecx
11df69: 89 c7 mov %eax,%edi
11df6b: 89 de mov %ebx,%esi
11df6d: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
free( ptr );
11df6f: 83 ec 0c sub $0xc,%esp
11df72: 53 push %ebx
11df73: 89 45 d4 mov %eax,-0x2c(%ebp)
11df76: e8 b9 96 fe ff call 107634 <free>
return new_area;
11df7b: 83 c4 10 add $0x10,%esp
11df7e: 8b 45 d4 mov -0x2c(%ebp),%eax
11df81: 89 c3 mov %eax,%ebx
11df83: e9 63 ff ff ff jmp 11deeb <realloc+0x53>
001088a8 <rmdir>:
#include <rtems/seterr.h>
int rmdir(
const char *pathname
)
{
1088a8: 55 push %ebp
1088a9: 89 e5 mov %esp,%ebp
1088ab: 57 push %edi
1088ac: 56 push %esi
1088ad: 53 push %ebx
1088ae: 83 ec 58 sub $0x58,%esp
1088b1: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Get the parent node of the node we wish to remove. Find the parent path.
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
1088b4: 53 push %ebx
1088b5: e8 1e f1 ff ff call 1079d8 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
1088ba: 83 c4 10 add $0x10,%esp
1088bd: 85 c0 test %eax,%eax
1088bf: 0f 85 0f 01 00 00 jne 1089d4 <rmdir+0x12c>
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
1088c5: 50 push %eax
1088c6: 8d 45 d0 lea -0x30(%ebp),%eax
1088c9: 89 45 b4 mov %eax,-0x4c(%ebp)
1088cc: 50 push %eax
1088cd: 8d 45 e4 lea -0x1c(%ebp),%eax
1088d0: 50 push %eax
1088d1: 53 push %ebx
1088d2: e8 45 01 00 00 call 108a1c <rtems_filesystem_get_start_loc>
1088d7: 83 c4 10 add $0x10,%esp
1088da: 31 d2 xor %edx,%edx
const char *name;
rtems_filesystem_location_info_t parentloc;
rtems_filesystem_location_info_t loc;
int i;
int result;
bool free_parentloc = false;
1088dc: c6 45 b3 00 movb $0x0,-0x4d(%ebp)
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
1088e0: 8d 7d bc lea -0x44(%ebp),%edi
1088e3: b9 05 00 00 00 mov $0x5,%ecx
1088e8: 8b 75 b4 mov -0x4c(%ebp),%esi
1088eb: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
name = pathname + parentpathlen;
1088ed: 01 d3 add %edx,%ebx
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
1088ef: be ff ff ff ff mov $0xffffffff,%esi
1088f4: 89 f1 mov %esi,%ecx
1088f6: 89 df mov %ebx,%edi
1088f8: 31 c0 xor %eax,%eax
1088fa: f2 ae repnz scas %es:(%edi),%al
1088fc: f7 d1 not %ecx
1088fe: 49 dec %ecx
1088ff: 83 ec 08 sub $0x8,%esp
108902: 51 push %ecx
108903: 53 push %ebx
108904: e8 13 f1 ff ff call 107a1c <rtems_filesystem_prefix_separators>
108909: 01 c3 add %eax,%ebx
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
10890b: 89 f1 mov %esi,%ecx
10890d: 89 df mov %ebx,%edi
10890f: 31 c0 xor %eax,%eax
108911: f2 ae repnz scas %es:(%edi),%al
108913: f7 d1 not %ecx
108915: 49 dec %ecx
108916: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10891d: 8d 75 bc lea -0x44(%ebp),%esi
108920: 56 push %esi
108921: 6a 00 push $0x0
108923: 51 push %ecx
108924: 53 push %ebx
108925: e8 02 f0 ff ff call 10792c <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
10892a: 83 c4 20 add $0x20,%esp
10892d: 85 c0 test %eax,%eax
10892f: 75 5b jne 10898c <rmdir+0xe4>
}
/*
* Verify you can remove this node as a directory.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
108931: 83 ec 0c sub $0xc,%esp
108934: 56 push %esi
108935: 8b 45 c8 mov -0x38(%ebp),%eax
108938: ff 50 10 call *0x10(%eax)
10893b: 83 c4 10 add $0x10,%esp
10893e: 48 dec %eax
10893f: 75 5f jne 1089a0 <rmdir+0xf8>
/*
* Use the filesystems rmnod to remove the node.
*/
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
108941: 83 ec 08 sub $0x8,%esp
108944: 56 push %esi
108945: ff 75 b4 pushl -0x4c(%ebp)
108948: 8b 45 c4 mov -0x3c(%ebp),%eax
10894b: ff 50 34 call *0x34(%eax)
rtems_filesystem_freenode( &loc );
10894e: 89 34 24 mov %esi,(%esp)
108951: 89 45 ac mov %eax,-0x54(%ebp)
108954: e8 13 f1 ff ff call 107a6c <rtems_filesystem_freenode>
if ( free_parentloc )
108959: 83 c4 10 add $0x10,%esp
10895c: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp)
108960: 8b 45 ac mov -0x54(%ebp),%eax
108963: 75 0b jne 108970 <rmdir+0xc8>
rtems_filesystem_freenode( &parentloc );
return result;
}
108965: 8d 65 f4 lea -0xc(%ebp),%esp
108968: 5b pop %ebx
108969: 5e pop %esi
10896a: 5f pop %edi
10896b: c9 leave
10896c: c3 ret
10896d: 8d 76 00 lea 0x0(%esi),%esi
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
rtems_filesystem_freenode( &loc );
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
108970: 83 ec 0c sub $0xc,%esp
108973: ff 75 b4 pushl -0x4c(%ebp)
108976: e8 f1 f0 ff ff call 107a6c <rtems_filesystem_freenode>
10897b: 83 c4 10 add $0x10,%esp
10897e: 8b 45 ac mov -0x54(%ebp),%eax
return result;
}
108981: 8d 65 f4 lea -0xc(%ebp),%esp
108984: 5b pop %ebx
108985: 5e pop %esi
108986: 5f pop %edi
108987: c9 leave
108988: c3 ret
108989: 8d 76 00 lea 0x0(%esi),%esi
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
10898c: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp)
108990: 75 6f jne 108a01 <rmdir+0x159>
rtems_filesystem_freenode( &parentloc );
return -1;
108992: b8 ff ff ff ff mov $0xffffffff,%eax
rtems_filesystem_freenode( &loc );
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return result;
}
108997: 8d 65 f4 lea -0xc(%ebp),%esp
10899a: 5b pop %ebx
10899b: 5e pop %esi
10899c: 5f pop %edi
10899d: c9 leave
10899e: c3 ret
10899f: 90 nop
/*
* Verify you can remove this node as a directory.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_filesystem_freenode( &loc );
1089a0: 83 ec 0c sub $0xc,%esp
1089a3: 56 push %esi
1089a4: e8 c3 f0 ff ff call 107a6c <rtems_filesystem_freenode>
if ( free_parentloc )
1089a9: 83 c4 10 add $0x10,%esp
1089ac: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp)
1089b0: 74 0e je 1089c0 <rmdir+0x118> <== NEVER TAKEN
rtems_filesystem_freenode( &parentloc );
1089b2: 83 ec 0c sub $0xc,%esp
1089b5: ff 75 b4 pushl -0x4c(%ebp)
1089b8: e8 af f0 ff ff call 107a6c <rtems_filesystem_freenode>
1089bd: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( ENOTDIR );
1089c0: e8 3f 9c 00 00 call 112604 <__errno>
1089c5: c7 00 14 00 00 00 movl $0x14,(%eax)
1089cb: b8 ff ff ff ff mov $0xffffffff,%eax
1089d0: eb 93 jmp 108965 <rmdir+0xbd>
1089d2: 66 90 xchg %ax,%ax
parentpathlen = rtems_filesystem_dirname ( pathname );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
1089d4: 89 c2 mov %eax,%edx
1089d6: 83 ec 0c sub $0xc,%esp
1089d9: 6a 00 push $0x0
1089db: 8d 45 d0 lea -0x30(%ebp),%eax
1089de: 89 45 b4 mov %eax,-0x4c(%ebp)
1089e1: 50 push %eax
1089e2: 6a 02 push $0x2
1089e4: 52 push %edx
1089e5: 53 push %ebx
1089e6: 89 55 ac mov %edx,-0x54(%ebp)
1089e9: e8 a6 ef ff ff call 107994 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
1089ee: 83 c4 20 add $0x20,%esp
1089f1: 85 c0 test %eax,%eax
1089f3: 8b 55 ac mov -0x54(%ebp),%edx
1089f6: 75 9a jne 108992 <rmdir+0xea> <== NEVER TAKEN
return -1;
free_parentloc = true;
1089f8: c6 45 b3 01 movb $0x1,-0x4d(%ebp)
1089fc: e9 df fe ff ff jmp 1088e0 <rmdir+0x38>
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
108a01: 83 ec 0c sub $0xc,%esp
108a04: ff 75 b4 pushl -0x4c(%ebp)
108a07: e8 60 f0 ff ff call 107a6c <rtems_filesystem_freenode>
108a0c: 83 c4 10 add $0x10,%esp
return -1;
108a0f: b8 ff ff ff ff mov $0xffffffff,%eax
108a14: e9 4c ff ff ff jmp 108965 <rmdir+0xbd>
00107d6c <rtems_assoc_local_by_name>:
uint32_t rtems_assoc_local_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
107d6c: 55 push %ebp
107d6d: 89 e5 mov %esp,%ebp
107d6f: 83 ec 10 sub $0x10,%esp
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_name(ap, name);
107d72: ff 75 0c pushl 0xc(%ebp)
107d75: ff 75 08 pushl 0x8(%ebp)
107d78: e8 13 02 00 00 call 107f90 <rtems_assoc_ptr_by_name>
if (nap)
107d7d: 83 c4 10 add $0x10,%esp
107d80: 85 c0 test %eax,%eax
107d82: 74 08 je 107d8c <rtems_assoc_local_by_name+0x20>
return nap->local_value;
107d84: 8b 40 04 mov 0x4(%eax),%eax
return 0;
}
107d87: c9 leave
107d88: c3 ret
107d89: 8d 76 00 lea 0x0(%esi),%esi
nap = rtems_assoc_ptr_by_name(ap, name);
if (nap)
return nap->local_value;
return 0;
107d8c: 31 c0 xor %eax,%eax
}
107d8e: c9 leave
107d8f: c3 ret
0010eff8 <rtems_assoc_local_by_remote>:
uint32_t rtems_assoc_local_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
10eff8: 55 push %ebp
10eff9: 89 e5 mov %esp,%ebp
10effb: 83 ec 10 sub $0x10,%esp
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
10effe: ff 75 0c pushl 0xc(%ebp)
10f001: ff 75 08 pushl 0x8(%ebp)
10f004: e8 13 00 00 00 call 10f01c <rtems_assoc_ptr_by_remote>
if (nap)
10f009: 83 c4 10 add $0x10,%esp
10f00c: 85 c0 test %eax,%eax
10f00e: 74 08 je 10f018 <rtems_assoc_local_by_remote+0x20>
return nap->local_value;
10f010: 8b 40 04 mov 0x4(%eax),%eax
return 0;
}
10f013: c9 leave
10f014: c3 ret
10f015: 8d 76 00 lea 0x0(%esi),%esi
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
if (nap)
return nap->local_value;
return 0;
10f018: 31 c0 xor %eax,%eax
}
10f01a: c9 leave
10f01b: c3 ret
0011191c <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
11191c: 55 push %ebp
11191d: 89 e5 mov %esp,%ebp
11191f: 57 push %edi
111920: 56 push %esi
111921: 53 push %ebx
111922: 83 ec 1c sub $0x1c,%esp
111925: 8b 7d 0c mov 0xc(%ebp),%edi
111928: be 20 00 00 00 mov $0x20,%esi
uint32_t b;
uint32_t local_value = 0;
11192d: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
for (b = 1; b; b <<= 1) {
111934: bb 01 00 00 00 mov $0x1,%ebx
111939: eb 06 jmp 111941 <rtems_assoc_local_by_remote_bitfield+0x25>
11193b: 90 nop
11193c: d1 e3 shl %ebx
11193e: 4e dec %esi
11193f: 74 1b je 11195c <rtems_assoc_local_by_remote_bitfield+0x40>
if (b & remote_value)
111941: 85 fb test %edi,%ebx
111943: 74 f7 je 11193c <rtems_assoc_local_by_remote_bitfield+0x20>
local_value |= rtems_assoc_local_by_remote(ap, b);
111945: 83 ec 08 sub $0x8,%esp
111948: 53 push %ebx
111949: ff 75 08 pushl 0x8(%ebp)
11194c: e8 a7 d6 ff ff call 10eff8 <rtems_assoc_local_by_remote>
111951: 09 45 e4 or %eax,-0x1c(%ebp)
111954: 83 c4 10 add $0x10,%esp
)
{
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
111957: d1 e3 shl %ebx
111959: 4e dec %esi
11195a: 75 e5 jne 111941 <rtems_assoc_local_by_remote_bitfield+0x25><== ALWAYS TAKEN
if (b & remote_value)
local_value |= rtems_assoc_local_by_remote(ap, b);
}
return local_value;
}
11195c: 8b 45 e4 mov -0x1c(%ebp),%eax
11195f: 8d 65 f4 lea -0xc(%ebp),%esp
111962: 5b pop %ebx
111963: 5e pop %esi
111964: 5f pop %edi
111965: c9 leave
111966: c3 ret
001140bc <rtems_assoc_name_by_local>:
const char *rtems_assoc_name_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
1140bc: 55 push %ebp
1140bd: 89 e5 mov %esp,%ebp
1140bf: 53 push %ebx
1140c0: 83 ec 0c sub $0xc,%esp
1140c3: 8b 5d 0c mov 0xc(%ebp),%ebx
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
1140c6: 53 push %ebx
1140c7: ff 75 08 pushl 0x8(%ebp)
1140ca: e8 1d 00 00 00 call 1140ec <rtems_assoc_ptr_by_local>
if (nap)
1140cf: 83 c4 10 add $0x10,%esp
1140d2: 85 c0 test %eax,%eax
1140d4: 74 0a je 1140e0 <rtems_assoc_name_by_local+0x24>
return nap->name;
1140d6: 8b 00 mov (%eax),%eax
return rtems_assoc_name_bad(local_value);
}
1140d8: 8b 5d fc mov -0x4(%ebp),%ebx
1140db: c9 leave
1140dc: c3 ret
1140dd: 8d 76 00 lea 0x0(%esi),%esi
nap = rtems_assoc_ptr_by_local(ap, local_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(local_value);
1140e0: 89 5d 08 mov %ebx,0x8(%ebp)
}
1140e3: 8b 5d fc mov -0x4(%ebp),%ebx
1140e6: c9 leave
nap = rtems_assoc_ptr_by_local(ap, local_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(local_value);
1140e7: e9 00 2b 00 00 jmp 116bec <rtems_assoc_name_bad>
00107f08 <rtems_assoc_name_by_remote>:
const char *rtems_assoc_name_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
107f08: 55 push %ebp
107f09: 89 e5 mov %esp,%ebp
107f0b: 53 push %ebx
107f0c: 83 ec 0c sub $0xc,%esp
107f0f: 8b 5d 0c mov 0xc(%ebp),%ebx
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
107f12: 53 push %ebx
107f13: ff 75 08 pushl 0x8(%ebp)
107f16: e8 ed 00 00 00 call 108008 <rtems_assoc_ptr_by_remote>
if (nap)
107f1b: 83 c4 10 add $0x10,%esp
107f1e: 85 c0 test %eax,%eax
107f20: 74 0a je 107f2c <rtems_assoc_name_by_remote+0x24>
return nap->name;
107f22: 8b 00 mov (%eax),%eax
return rtems_assoc_name_bad(remote_value);
}
107f24: 8b 5d fc mov -0x4(%ebp),%ebx
107f27: c9 leave
107f28: c3 ret
107f29: 8d 76 00 lea 0x0(%esi),%esi
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(remote_value);
107f2c: 89 5d 08 mov %ebx,0x8(%ebp)
}
107f2f: 8b 5d fc mov -0x4(%ebp),%ebx
107f32: c9 leave
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(remote_value);
107f33: e9 40 7d 00 00 jmp 10fc78 <rtems_assoc_name_bad>
001140ec <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
1140ec: 55 push %ebp
1140ed: 89 e5 mov %esp,%ebp
1140ef: 57 push %edi
1140f0: 56 push %esi
1140f1: 53 push %ebx
1140f2: 8b 45 08 mov 0x8(%ebp),%eax
1140f5: 8b 55 0c mov 0xc(%ebp),%edx
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
1140f8: 8b 30 mov (%eax),%esi
1140fa: 85 f6 test %esi,%esi
1140fc: 74 3e je 11413c <rtems_assoc_ptr_by_local+0x50>
1140fe: bf d8 61 12 00 mov $0x1261d8,%edi
114103: b9 0a 00 00 00 mov $0xa,%ecx
114108: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
11410a: 74 18 je 114124 <rtems_assoc_ptr_by_local+0x38>
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
const rtems_assoc_t *default_ap = 0;
11410c: 31 c9 xor %ecx,%ecx
11410e: eb 09 jmp 114119 <rtems_assoc_ptr_by_local+0x2d>
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
114110: 83 c0 0c add $0xc,%eax
114113: 8b 18 mov (%eax),%ebx
114115: 85 db test %ebx,%ebx
114117: 74 1b je 114134 <rtems_assoc_ptr_by_local+0x48>
if (ap->local_value == local_value)
114119: 39 50 04 cmp %edx,0x4(%eax)
11411c: 75 f2 jne 114110 <rtems_assoc_ptr_by_local+0x24>
return ap;
return default_ap;
}
11411e: 5b pop %ebx
11411f: 5e pop %esi
114120: 5f pop %edi
114121: c9 leave
114122: c3 ret
114123: 90 nop
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
114124: 8d 58 0c lea 0xc(%eax),%ebx
for ( ; ap->name; ap++)
114127: 8b 70 0c mov 0xc(%eax),%esi
11412a: 85 f6 test %esi,%esi
11412c: 74 f0 je 11411e <rtems_assoc_ptr_by_local+0x32><== NEVER TAKEN
11412e: 89 c1 mov %eax,%ecx
114130: 89 d8 mov %ebx,%eax
114132: eb e5 jmp 114119 <rtems_assoc_ptr_by_local+0x2d>
114134: 89 c8 mov %ecx,%eax
if (ap->local_value == local_value)
return ap;
return default_ap;
}
114136: 5b pop %ebx
114137: 5e pop %esi
114138: 5f pop %edi
114139: c9 leave
11413a: c3 ret
11413b: 90 nop
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
const rtems_assoc_t *default_ap = 0;
11413c: 31 c0 xor %eax,%eax
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
return ap;
return default_ap;
}
11413e: 5b pop %ebx
11413f: 5e pop %esi
114140: 5f pop %edi
114141: c9 leave
114142: c3 ret
00107f90 <rtems_assoc_ptr_by_name>:
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
107f90: 55 push %ebp
107f91: 89 e5 mov %esp,%ebp
107f93: 57 push %edi
107f94: 56 push %esi
107f95: 53 push %ebx
107f96: 83 ec 0c sub $0xc,%esp
107f99: 8b 5d 08 mov 0x8(%ebp),%ebx
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
107f9c: 8b 03 mov (%ebx),%eax
107f9e: 85 c0 test %eax,%eax
107fa0: 74 5a je 107ffc <rtems_assoc_ptr_by_name+0x6c>
107fa2: bf 7d f6 11 00 mov $0x11f67d,%edi
107fa7: b9 0a 00 00 00 mov $0xa,%ecx
107fac: 89 c6 mov %eax,%esi
107fae: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
107fb0: 74 2e je 107fe0 <rtems_assoc_ptr_by_name+0x50>
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
const rtems_assoc_t *default_ap = 0;
107fb2: 31 f6 xor %esi,%esi
107fb4: eb 0b jmp 107fc1 <rtems_assoc_ptr_by_name+0x31>
107fb6: 66 90 xchg %ax,%ax
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
107fb8: 83 c3 0c add $0xc,%ebx
107fbb: 8b 03 mov (%ebx),%eax
107fbd: 85 c0 test %eax,%eax
107fbf: 74 2f je 107ff0 <rtems_assoc_ptr_by_name+0x60>
if (strcmp(ap->name, name) == 0)
107fc1: 83 ec 08 sub $0x8,%esp
107fc4: ff 75 0c pushl 0xc(%ebp)
107fc7: 50 push %eax
107fc8: e8 ff b5 00 00 call 1135cc <strcmp>
107fcd: 83 c4 10 add $0x10,%esp
107fd0: 85 c0 test %eax,%eax
107fd2: 75 e4 jne 107fb8 <rtems_assoc_ptr_by_name+0x28>
return ap;
return default_ap;
}
107fd4: 89 d8 mov %ebx,%eax
107fd6: 8d 65 f4 lea -0xc(%ebp),%esp
107fd9: 5b pop %ebx
107fda: 5e pop %esi
107fdb: 5f pop %edi
107fdc: c9 leave
107fdd: c3 ret
107fde: 66 90 xchg %ax,%ax
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
107fe0: 8d 53 0c lea 0xc(%ebx),%edx
for ( ; ap->name; ap++)
107fe3: 8b 43 0c mov 0xc(%ebx),%eax
107fe6: 85 c0 test %eax,%eax
107fe8: 74 ea je 107fd4 <rtems_assoc_ptr_by_name+0x44><== NEVER TAKEN
107fea: 89 de mov %ebx,%esi
107fec: 89 d3 mov %edx,%ebx
107fee: eb d1 jmp 107fc1 <rtems_assoc_ptr_by_name+0x31>
107ff0: 89 f3 mov %esi,%ebx
if (strcmp(ap->name, name) == 0)
return ap;
return default_ap;
}
107ff2: 89 d8 mov %ebx,%eax
107ff4: 8d 65 f4 lea -0xc(%ebp),%esp
107ff7: 5b pop %ebx
107ff8: 5e pop %esi
107ff9: 5f pop %edi
107ffa: c9 leave
107ffb: c3 ret
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
const rtems_assoc_t *default_ap = 0;
107ffc: 31 db xor %ebx,%ebx
for ( ; ap->name; ap++)
if (strcmp(ap->name, name) == 0)
return ap;
return default_ap;
}
107ffe: 89 d8 mov %ebx,%eax
108000: 8d 65 f4 lea -0xc(%ebp),%esp
108003: 5b pop %ebx
108004: 5e pop %esi
108005: 5f pop %edi
108006: c9 leave
108007: c3 ret
0010f01c <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
10f01c: 55 push %ebp
10f01d: 89 e5 mov %esp,%ebp
10f01f: 57 push %edi
10f020: 56 push %esi
10f021: 53 push %ebx
10f022: 8b 45 08 mov 0x8(%ebp),%eax
10f025: 8b 55 0c mov 0xc(%ebp),%edx
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
10f028: 8b 30 mov (%eax),%esi
10f02a: 85 f6 test %esi,%esi
10f02c: 74 3e je 10f06c <rtems_assoc_ptr_by_remote+0x50>
10f02e: bf 78 03 12 00 mov $0x120378,%edi
10f033: b9 0a 00 00 00 mov $0xa,%ecx
10f038: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10f03a: 74 18 je 10f054 <rtems_assoc_ptr_by_remote+0x38>
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
const rtems_assoc_t *default_ap = 0;
10f03c: 31 c9 xor %ecx,%ecx
10f03e: eb 09 jmp 10f049 <rtems_assoc_ptr_by_remote+0x2d>
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
10f040: 83 c0 0c add $0xc,%eax
10f043: 8b 18 mov (%eax),%ebx
10f045: 85 db test %ebx,%ebx
10f047: 74 1b je 10f064 <rtems_assoc_ptr_by_remote+0x48>
if (ap->remote_value == remote_value)
10f049: 39 50 08 cmp %edx,0x8(%eax)
10f04c: 75 f2 jne 10f040 <rtems_assoc_ptr_by_remote+0x24>
return ap;
return default_ap;
}
10f04e: 5b pop %ebx
10f04f: 5e pop %esi
10f050: 5f pop %edi
10f051: c9 leave
10f052: c3 ret
10f053: 90 nop
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
10f054: 8d 58 0c lea 0xc(%eax),%ebx
for ( ; ap->name; ap++)
10f057: 8b 70 0c mov 0xc(%eax),%esi
10f05a: 85 f6 test %esi,%esi
10f05c: 74 f0 je 10f04e <rtems_assoc_ptr_by_remote+0x32><== NEVER TAKEN
10f05e: 89 c1 mov %eax,%ecx
10f060: 89 d8 mov %ebx,%eax
10f062: eb e5 jmp 10f049 <rtems_assoc_ptr_by_remote+0x2d>
10f064: 89 c8 mov %ecx,%eax
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
10f066: 5b pop %ebx
10f067: 5e pop %esi
10f068: 5f pop %edi
10f069: c9 leave
10f06a: c3 ret
10f06b: 90 nop
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
const rtems_assoc_t *default_ap = 0;
10f06c: 31 c0 xor %eax,%eax
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
10f06e: 5b pop %ebx
10f06f: 5e pop %esi
10f070: 5f pop %edi
10f071: c9 leave
10f072: c3 ret
001080ac <rtems_assoc_remote_by_local>:
uint32_t rtems_assoc_remote_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
1080ac: 55 push %ebp
1080ad: 89 e5 mov %esp,%ebp
1080af: 83 ec 10 sub $0x10,%esp
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
1080b2: ff 75 0c pushl 0xc(%ebp)
1080b5: ff 75 08 pushl 0x8(%ebp)
1080b8: e8 7b fe ff ff call 107f38 <rtems_assoc_ptr_by_local>
if (nap)
1080bd: 83 c4 10 add $0x10,%esp
1080c0: 85 c0 test %eax,%eax
1080c2: 74 08 je 1080cc <rtems_assoc_remote_by_local+0x20>
return nap->remote_value;
1080c4: 8b 40 08 mov 0x8(%eax),%eax
return 0;
}
1080c7: c9 leave
1080c8: c3 ret
1080c9: 8d 76 00 lea 0x0(%esi),%esi
nap = rtems_assoc_ptr_by_local(ap, local_value);
if (nap)
return nap->remote_value;
return 0;
1080cc: 31 c0 xor %eax,%eax
}
1080ce: c9 leave
1080cf: c3 ret
00108060 <rtems_assoc_remote_by_local_bitfield>:
uint32_t rtems_assoc_remote_by_local_bitfield(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
108060: 55 push %ebp
108061: 89 e5 mov %esp,%ebp
108063: 57 push %edi
108064: 56 push %esi
108065: 53 push %ebx
108066: 83 ec 1c sub $0x1c,%esp
108069: 8b 7d 0c mov 0xc(%ebp),%edi
10806c: be 20 00 00 00 mov $0x20,%esi
uint32_t b;
uint32_t remote_value = 0;
108071: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
for (b = 1; b; b <<= 1)
108078: bb 01 00 00 00 mov $0x1,%ebx
10807d: eb 06 jmp 108085 <rtems_assoc_remote_by_local_bitfield+0x25>
10807f: 90 nop
108080: d1 e3 shl %ebx
108082: 4e dec %esi
108083: 74 1b je 1080a0 <rtems_assoc_remote_by_local_bitfield+0x40>
if (b & local_value)
108085: 85 fb test %edi,%ebx
108087: 74 f7 je 108080 <rtems_assoc_remote_by_local_bitfield+0x20>
remote_value |= rtems_assoc_remote_by_local(ap, b);
108089: 83 ec 08 sub $0x8,%esp
10808c: 53 push %ebx
10808d: ff 75 08 pushl 0x8(%ebp)
108090: e8 17 00 00 00 call 1080ac <rtems_assoc_remote_by_local>
108095: 09 45 e4 or %eax,-0x1c(%ebp)
108098: 83 c4 10 add $0x10,%esp
)
{
uint32_t b;
uint32_t remote_value = 0;
for (b = 1; b; b <<= 1)
10809b: d1 e3 shl %ebx
10809d: 4e dec %esi
10809e: 75 e5 jne 108085 <rtems_assoc_remote_by_local_bitfield+0x25><== ALWAYS TAKEN
if (b & local_value)
remote_value |= rtems_assoc_remote_by_local(ap, b);
return remote_value;
}
1080a0: 8b 45 e4 mov -0x1c(%ebp),%eax
1080a3: 8d 65 f4 lea -0xc(%ebp),%esp
1080a6: 5b pop %ebx
1080a7: 5e pop %esi
1080a8: 5f pop %edi
1080a9: c9 leave
1080aa: c3 ret
001080d0 <rtems_assoc_remote_by_name>:
uint32_t rtems_assoc_remote_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
1080d0: 55 push %ebp
1080d1: 89 e5 mov %esp,%ebp
1080d3: 83 ec 10 sub $0x10,%esp
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_name(ap, name);
1080d6: ff 75 0c pushl 0xc(%ebp)
1080d9: ff 75 08 pushl 0x8(%ebp)
1080dc: e8 af fe ff ff call 107f90 <rtems_assoc_ptr_by_name>
if (nap)
1080e1: 83 c4 10 add $0x10,%esp
1080e4: 85 c0 test %eax,%eax
1080e6: 74 08 je 1080f0 <rtems_assoc_remote_by_name+0x20>
return nap->remote_value;
1080e8: 8b 40 08 mov 0x8(%eax),%eax
return 0;
}
1080eb: c9 leave
1080ec: c3 ret
1080ed: 8d 76 00 lea 0x0(%esi),%esi
nap = rtems_assoc_ptr_by_name(ap, name);
if (nap)
return nap->remote_value;
return 0;
1080f0: 31 c0 xor %eax,%eax
}
1080f2: c9 leave
1080f3: c3 ret
00112024 <rtems_barrier_create>:
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
112024: 55 push %ebp
112025: 89 e5 mov %esp,%ebp
112027: 57 push %edi
112028: 56 push %esi
112029: 53 push %ebx
11202a: 83 ec 2c sub $0x2c,%esp
11202d: 8b 5d 08 mov 0x8(%ebp),%ebx
112030: 8b 7d 0c mov 0xc(%ebp),%edi
112033: 8b 45 10 mov 0x10(%ebp),%eax
112036: 8b 75 14 mov 0x14(%ebp),%esi
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
112039: 85 db test %ebx,%ebx
11203b: 0f 84 87 00 00 00 je 1120c8 <rtems_barrier_create+0xa4>
return RTEMS_INVALID_NAME;
if ( !id )
112041: 85 f6 test %esi,%esi
112043: 0f 84 bf 00 00 00 je 112108 <rtems_barrier_create+0xe4>
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
112049: f7 c7 10 00 00 00 test $0x10,%edi
11204f: 0f 84 83 00 00 00 je 1120d8 <rtems_barrier_create+0xb4>
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
112055: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
if ( maximum_waiters == 0 )
11205c: 85 c0 test %eax,%eax
11205e: 0f 84 80 00 00 00 je 1120e4 <rtems_barrier_create+0xc0>
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
the_attributes.maximum_count = maximum_waiters;
112064: 89 45 e4 mov %eax,-0x1c(%ebp)
112067: a1 ec 88 12 00 mov 0x1288ec,%eax
11206c: 40 inc %eax
11206d: a3 ec 88 12 00 mov %eax,0x1288ec
* This function allocates a barrier control block from
* the inactive chain of free barrier control blocks.
*/
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Allocate( void )
{
return (Barrier_Control *) _Objects_Allocate( &_Barrier_Information );
112072: 83 ec 0c sub $0xc,%esp
112075: 68 e0 8b 12 00 push $0x128be0
11207a: e8 45 b9 ff ff call 10d9c4 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
11207f: 83 c4 10 add $0x10,%esp
112082: 85 c0 test %eax,%eax
112084: 74 6e je 1120f4 <rtems_barrier_create+0xd0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
112086: 89 78 10 mov %edi,0x10(%eax)
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
112089: 83 ec 08 sub $0x8,%esp
11208c: 8d 55 e0 lea -0x20(%ebp),%edx
11208f: 52 push %edx
112090: 8d 50 14 lea 0x14(%eax),%edx
112093: 52 push %edx
112094: 89 45 d4 mov %eax,-0x2c(%ebp)
112097: e8 44 0a 00 00 call 112ae0 <_CORE_barrier_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
11209c: 8b 45 d4 mov -0x2c(%ebp),%eax
11209f: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
1120a2: 0f b7 fa movzwl %dx,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
1120a5: 8b 0d fc 8b 12 00 mov 0x128bfc,%ecx
1120ab: 89 04 b9 mov %eax,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
1120ae: 89 58 0c mov %ebx,0xc(%eax)
&_Barrier_Information,
&the_barrier->Object,
(Objects_Name) name
);
*id = the_barrier->Object.id;
1120b1: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
1120b3: e8 c8 c8 ff ff call 10e980 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1120b8: 83 c4 10 add $0x10,%esp
1120bb: 31 c0 xor %eax,%eax
}
1120bd: 8d 65 f4 lea -0xc(%ebp),%esp
1120c0: 5b pop %ebx
1120c1: 5e pop %esi
1120c2: 5f pop %edi
1120c3: c9 leave
1120c4: c3 ret
1120c5: 8d 76 00 lea 0x0(%esi),%esi
{
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
1120c8: b8 03 00 00 00 mov $0x3,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
1120cd: 8d 65 f4 lea -0xc(%ebp),%esp
1120d0: 5b pop %ebx
1120d1: 5e pop %esi
1120d2: 5f pop %edi
1120d3: c9 leave
1120d4: c3 ret
1120d5: 8d 76 00 lea 0x0(%esi),%esi
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
1120d8: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp)
1120df: eb 83 jmp 112064 <rtems_barrier_create+0x40>
1120e1: 8d 76 00 lea 0x0(%esi),%esi
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
1120e4: b8 0a 00 00 00 mov $0xa,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
1120e9: 8d 65 f4 lea -0xc(%ebp),%esp
1120ec: 5b pop %ebx
1120ed: 5e pop %esi
1120ee: 5f pop %edi
1120ef: c9 leave
1120f0: c3 ret
1120f1: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
1120f4: e8 87 c8 ff ff call 10e980 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
1120f9: b8 05 00 00 00 mov $0x5,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
1120fe: 8d 65 f4 lea -0xc(%ebp),%esp
112101: 5b pop %ebx
112102: 5e pop %esi
112103: 5f pop %edi
112104: c9 leave
112105: c3 ret
112106: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
112108: b8 09 00 00 00 mov $0x9,%eax
11210d: eb ae jmp 1120bd <rtems_barrier_create+0x99>
001072cc <rtems_bsp_cmdline_get_param>:
const char *rtems_bsp_cmdline_get_param(
const char *name,
char *value,
size_t length
)
{
1072cc: 55 push %ebp
1072cd: 89 e5 mov %esp,%ebp
1072cf: 57 push %edi
1072d0: 56 push %esi
1072d1: 53 push %ebx
1072d2: 83 ec 1c sub $0x1c,%esp
1072d5: 8b 45 08 mov 0x8(%ebp),%eax
1072d8: 8b 5d 0c mov 0xc(%ebp),%ebx
1072db: 8b 75 10 mov 0x10(%ebp),%esi
const char *p;
if ( !name )
1072de: 85 c0 test %eax,%eax
1072e0: 75 0a jne 1072ec <rtems_bsp_cmdline_get_param+0x20>
value[0] = '\0';
p = rtems_bsp_cmdline_get_param_raw( name );
if ( !p )
return NULL;
1072e2: 31 c0 xor %eax,%eax
copy_string( p, value, length );
return value;
}
1072e4: 8d 65 f4 lea -0xc(%ebp),%esp
1072e7: 5b pop %ebx
1072e8: 5e pop %esi
1072e9: 5f pop %edi
1072ea: c9 leave
1072eb: c3 ret
const char *p;
if ( !name )
return NULL;
if ( !value )
1072ec: 85 db test %ebx,%ebx
1072ee: 74 f2 je 1072e2 <rtems_bsp_cmdline_get_param+0x16>
return NULL;
if ( !length )
1072f0: 85 f6 test %esi,%esi
1072f2: 74 ee je 1072e2 <rtems_bsp_cmdline_get_param+0x16>
return NULL;
value[0] = '\0';
1072f4: c6 03 00 movb $0x0,(%ebx)
p = rtems_bsp_cmdline_get_param_raw( name );
1072f7: 83 ec 0c sub $0xc,%esp
1072fa: 50 push %eax
1072fb: e8 4c 00 00 00 call 10734c <rtems_bsp_cmdline_get_param_raw>
if ( !p )
107300: 83 c4 10 add $0x10,%esp
107303: 85 c0 test %eax,%eax
107305: 74 db je 1072e2 <rtems_bsp_cmdline_get_param+0x16>
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
107307: 8a 08 mov (%eax),%cl
107309: 84 c9 test %cl,%cl
10730b: 74 3a je 107347 <rtems_bsp_cmdline_get_param+0x7b><== NEVER TAKEN
10730d: 4e dec %esi
10730e: 89 75 e4 mov %esi,-0x1c(%ebp)
107311: 74 34 je 107347 <rtems_bsp_cmdline_get_param+0x7b><== NEVER TAKEN
107313: 31 f6 xor %esi,%esi
107315: 31 d2 xor %edx,%edx
107317: 31 ff xor %edi,%edi
107319: eb 24 jmp 10733f <rtems_bsp_cmdline_get_param+0x73>
10731b: 90 nop
if ( *p == '\"' ) {
quotes++;
} else if ( ((quotes % 2) == 0) && *p == ' ' )
10731c: f7 c7 01 00 00 00 test $0x1,%edi
107322: 75 05 jne 107329 <rtems_bsp_cmdline_get_param+0x5d>
107324: 80 f9 20 cmp $0x20,%cl
107327: 74 1e je 107347 <rtems_bsp_cmdline_get_param+0x7b>
break;
value[i++] = *p++;
107329: 88 0c 33 mov %cl,(%ebx,%esi,1)
10732c: 42 inc %edx
value[i] = '\0';
10732d: c6 04 13 00 movb $0x0,(%ebx,%edx,1)
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
107331: 8a 0c 10 mov (%eax,%edx,1),%cl
107334: 84 c9 test %cl,%cl
107336: 74 0f je 107347 <rtems_bsp_cmdline_get_param+0x7b>
107338: 3b 55 e4 cmp -0x1c(%ebp),%edx
10733b: 73 0a jae 107347 <rtems_bsp_cmdline_get_param+0x7b>
10733d: 89 d6 mov %edx,%esi
if ( *p == '\"' ) {
10733f: 80 f9 22 cmp $0x22,%cl
107342: 75 d8 jne 10731c <rtems_bsp_cmdline_get_param+0x50>
quotes++;
107344: 47 inc %edi
107345: eb e2 jmp 107329 <rtems_bsp_cmdline_get_param+0x5d>
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
107347: 89 d8 mov %ebx,%eax
107349: eb 99 jmp 1072e4 <rtems_bsp_cmdline_get_param+0x18>
0010734c <rtems_bsp_cmdline_get_param_raw>:
extern const char *bsp_boot_cmdline;
const char *rtems_bsp_cmdline_get_param_raw(
const char *name
)
{
10734c: 55 push %ebp
10734d: 89 e5 mov %esp,%ebp
10734f: 83 ec 08 sub $0x8,%esp
107352: 8b 45 08 mov 0x8(%ebp),%eax
const char *p;
if ( !name )
107355: 85 c0 test %eax,%eax
107357: 75 07 jne 107360 <rtems_bsp_cmdline_get_param_raw+0x14>
return NULL;
if ( !bsp_boot_cmdline )
return NULL;
107359: 31 c0 xor %eax,%eax
p = strstr(bsp_boot_cmdline, name);
/* printf( "raw: %p (%s)\n", p, p ); */
return p;
}
10735b: c9 leave
10735c: c3 ret
10735d: 8d 76 00 lea 0x0(%esi),%esi
const char *p;
if ( !name )
return NULL;
if ( !bsp_boot_cmdline )
107360: 8b 15 38 61 12 00 mov 0x126138,%edx
107366: 85 d2 test %edx,%edx
107368: 74 ef je 107359 <rtems_bsp_cmdline_get_param_raw+0xd>
return NULL;
p = strstr(bsp_boot_cmdline, name);
10736a: 83 ec 08 sub $0x8,%esp
10736d: 50 push %eax
10736e: 52 push %edx
10736f: e8 28 c3 00 00 call 11369c <strstr>
107374: 83 c4 10 add $0x10,%esp
/* printf( "raw: %p (%s)\n", p, p ); */
return p;
}
107377: c9 leave
107378: c3 ret
0010b708 <rtems_chain_append_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10b708: 55 push %ebp
10b709: 89 e5 mov %esp,%ebp
10b70b: 56 push %esi
10b70c: 53 push %ebx
10b70d: 8b 5d 10 mov 0x10(%ebp),%ebx
10b710: 8b 75 14 mov 0x14(%ebp),%esi
RTEMS_INLINE_ROUTINE bool rtems_chain_append_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Append_with_empty_check( chain, node );
10b713: 83 ec 08 sub $0x8,%esp
10b716: ff 75 0c pushl 0xc(%ebp)
10b719: ff 75 08 pushl 0x8(%ebp)
10b71c: e8 9f 04 00 00 call 10bbc0 <_Chain_Append_with_empty_check>
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
10b721: 83 c4 10 add $0x10,%esp
10b724: 84 c0 test %al,%al
10b726: 75 0c jne 10b734 <rtems_chain_append_with_notification+0x2c>
sc = rtems_event_send( task, events );
}
return sc;
}
10b728: 31 c0 xor %eax,%eax
10b72a: 8d 65 f8 lea -0x8(%ebp),%esp
10b72d: 5b pop %ebx
10b72e: 5e pop %esi
10b72f: c9 leave
10b730: c3 ret
10b731: 8d 76 00 lea 0x0(%esi),%esi
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
sc = rtems_event_send( task, events );
10b734: 89 75 0c mov %esi,0xc(%ebp)
10b737: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10b73a: 8d 65 f8 lea -0x8(%ebp),%esp
10b73d: 5b pop %ebx
10b73e: 5e pop %esi
10b73f: c9 leave
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
sc = rtems_event_send( task, events );
10b740: e9 5f f6 ff ff jmp 10ada4 <rtems_event_send>
0010b748 <rtems_chain_get_with_notification>:
rtems_chain_control *chain,
rtems_id task,
rtems_event_set events,
rtems_chain_node **node
)
{
10b748: 55 push %ebp
10b749: 89 e5 mov %esp,%ebp
10b74b: 56 push %esi
10b74c: 53 push %ebx
10b74d: 8b 5d 0c mov 0xc(%ebp),%ebx
10b750: 8b 75 10 mov 0x10(%ebp),%esi
RTEMS_INLINE_ROUTINE bool rtems_chain_get_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node **node
)
{
return _Chain_Get_with_empty_check( chain, node );
10b753: 83 ec 08 sub $0x8,%esp
10b756: ff 75 14 pushl 0x14(%ebp)
10b759: ff 75 08 pushl 0x8(%ebp)
10b75c: e8 c7 04 00 00 call 10bc28 <_Chain_Get_with_empty_check>
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool is_empty = rtems_chain_get_with_empty_check( chain, node );
if ( is_empty ) {
10b761: 83 c4 10 add $0x10,%esp
10b764: 84 c0 test %al,%al
10b766: 75 0c jne 10b774 <rtems_chain_get_with_notification+0x2c>
sc = rtems_event_send( task, events );
}
return sc;
}
10b768: 31 c0 xor %eax,%eax
10b76a: 8d 65 f8 lea -0x8(%ebp),%esp
10b76d: 5b pop %ebx
10b76e: 5e pop %esi
10b76f: c9 leave
10b770: c3 ret
10b771: 8d 76 00 lea 0x0(%esi),%esi
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool is_empty = rtems_chain_get_with_empty_check( chain, node );
if ( is_empty ) {
sc = rtems_event_send( task, events );
10b774: 89 75 0c mov %esi,0xc(%ebp)
10b777: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10b77a: 8d 65 f8 lea -0x8(%ebp),%esp
10b77d: 5b pop %ebx
10b77e: 5e pop %esi
10b77f: c9 leave
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool is_empty = rtems_chain_get_with_empty_check( chain, node );
if ( is_empty ) {
sc = rtems_event_send( task, events );
10b780: e9 1f f6 ff ff jmp 10ada4 <rtems_event_send>
0010b788 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
10b788: 55 push %ebp
10b789: 89 e5 mov %esp,%ebp
10b78b: 57 push %edi
10b78c: 56 push %esi
10b78d: 53 push %ebx
10b78e: 83 ec 1c sub $0x1c,%esp
10b791: 8b 75 08 mov 0x8(%ebp),%esi
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
10b794: 8d 7d e4 lea -0x1c(%ebp),%edi
10b797: 90 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
10b798: 83 ec 0c sub $0xc,%esp
10b79b: 56 push %esi
10b79c: e8 c3 04 00 00 call 10bc64 <_Chain_Get>
10b7a1: 89 c3 mov %eax,%ebx
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
10b7a3: 83 c4 10 add $0x10,%esp
10b7a6: 85 c0 test %eax,%eax
10b7a8: 75 22 jne 10b7cc <rtems_chain_get_with_wait+0x44>
) {
rtems_event_set out;
sc = rtems_event_receive(
10b7aa: 57 push %edi
10b7ab: ff 75 10 pushl 0x10(%ebp)
10b7ae: 6a 00 push $0x0
10b7b0: ff 75 0c pushl 0xc(%ebp)
10b7b3: e8 64 f4 ff ff call 10ac1c <rtems_event_receive>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
10b7b8: 83 c4 10 add $0x10,%esp
10b7bb: 85 c0 test %eax,%eax
10b7bd: 74 d9 je 10b798 <rtems_chain_get_with_wait+0x10><== NEVER TAKEN
timeout,
&out
);
}
*node_ptr = node;
10b7bf: 8b 55 14 mov 0x14(%ebp),%edx
10b7c2: 89 1a mov %ebx,(%edx)
return sc;
}
10b7c4: 8d 65 f4 lea -0xc(%ebp),%esp
10b7c7: 5b pop %ebx
10b7c8: 5e pop %esi
10b7c9: 5f pop %edi
10b7ca: c9 leave
10b7cb: c3 ret
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
10b7cc: 31 c0 xor %eax,%eax
timeout,
&out
);
}
*node_ptr = node;
10b7ce: 8b 55 14 mov 0x14(%ebp),%edx
10b7d1: 89 1a mov %ebx,(%edx)
return sc;
}
10b7d3: 8d 65 f4 lea -0xc(%ebp),%esp
10b7d6: 5b pop %ebx
10b7d7: 5e pop %esi
10b7d8: 5f pop %edi
10b7d9: c9 leave
10b7da: c3 ret
0010b7dc <rtems_chain_prepend_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10b7dc: 55 push %ebp
10b7dd: 89 e5 mov %esp,%ebp
10b7df: 56 push %esi
10b7e0: 53 push %ebx
10b7e1: 8b 5d 10 mov 0x10(%ebp),%ebx
10b7e4: 8b 75 14 mov 0x14(%ebp),%esi
RTEMS_INLINE_ROUTINE bool rtems_chain_prepend_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Prepend_with_empty_check( chain, node );
10b7e7: 83 ec 08 sub $0x8,%esp
10b7ea: ff 75 0c pushl 0xc(%ebp)
10b7ed: ff 75 08 pushl 0x8(%ebp)
10b7f0: e8 b3 04 00 00 call 10bca8 <_Chain_Prepend_with_empty_check>
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
10b7f5: 83 c4 10 add $0x10,%esp
10b7f8: 84 c0 test %al,%al
10b7fa: 75 0c jne 10b808 <rtems_chain_prepend_with_notification+0x2c>
sc = rtems_event_send( task, events );
}
return sc;
}
10b7fc: 31 c0 xor %eax,%eax
10b7fe: 8d 65 f8 lea -0x8(%ebp),%esp
10b801: 5b pop %ebx
10b802: 5e pop %esi
10b803: c9 leave
10b804: c3 ret
10b805: 8d 76 00 lea 0x0(%esi),%esi
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
sc = rtems_event_send( task, events );
10b808: 89 75 0c mov %esi,0xc(%ebp)
10b80b: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10b80e: 8d 65 f8 lea -0x8(%ebp),%esp
10b811: 5b pop %ebx
10b812: 5e pop %esi
10b813: c9 leave
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
sc = rtems_event_send( task, events );
10b814: e9 8b f5 ff ff jmp 10ada4 <rtems_event_send>
00115088 <rtems_clock_get>:
rtems_status_code rtems_clock_get(
rtems_clock_get_options option,
void *time_buffer
)
{
115088: 55 push %ebp
115089: 89 e5 mov %esp,%ebp
11508b: 53 push %ebx
11508c: 83 ec 04 sub $0x4,%esp
11508f: 8b 45 08 mov 0x8(%ebp),%eax
115092: 8b 5d 0c mov 0xc(%ebp),%ebx
if ( !time_buffer )
115095: 85 db test %ebx,%ebx
115097: 74 3b je 1150d4 <rtems_clock_get+0x4c>
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
115099: 85 c0 test %eax,%eax
11509b: 74 2b je 1150c8 <rtems_clock_get+0x40>
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
11509d: 83 f8 01 cmp $0x1,%eax
1150a0: 74 3e je 1150e0 <rtems_clock_get+0x58>
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
1150a2: 83 f8 02 cmp $0x2,%eax
1150a5: 74 45 je 1150ec <rtems_clock_get+0x64>
*interval = rtems_clock_get_ticks_since_boot();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
1150a7: 83 f8 03 cmp $0x3,%eax
1150aa: 74 4c je 1150f8 <rtems_clock_get+0x70>
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
1150ac: 83 f8 04 cmp $0x4,%eax
1150af: 74 0b je 1150bc <rtems_clock_get+0x34>
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
1150b1: b8 0a 00 00 00 mov $0xa,%eax
}
1150b6: 5a pop %edx
1150b7: 5b pop %ebx
1150b8: c9 leave
1150b9: c3 ret
1150ba: 66 90 xchg %ax,%ax
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
1150bc: 89 5d 08 mov %ebx,0x8(%ebp)
return RTEMS_INVALID_NUMBER;
}
1150bf: 59 pop %ecx
1150c0: 5b pop %ebx
1150c1: c9 leave
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
1150c2: e9 41 01 00 00 jmp 115208 <rtems_clock_get_tod_timeval>
1150c7: 90 nop
{
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
1150c8: 89 5d 08 mov %ebx,0x8(%ebp)
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
1150cb: 58 pop %eax
1150cc: 5b pop %ebx
1150cd: c9 leave
{
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
1150ce: e9 81 00 00 00 jmp 115154 <rtems_clock_get_tod>
1150d3: 90 nop
rtems_clock_get_options option,
void *time_buffer
)
{
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
1150d4: b8 09 00 00 00 mov $0x9,%eax
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
1150d9: 5a pop %edx
1150da: 5b pop %ebx
1150db: c9 leave
1150dc: c3 ret
1150dd: 8d 76 00 lea 0x0(%esi),%esi
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
1150e0: 89 5d 08 mov %ebx,0x8(%ebp)
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
1150e3: 5b pop %ebx
1150e4: 5b pop %ebx
1150e5: c9 leave
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
1150e6: e9 19 00 00 00 jmp 115104 <rtems_clock_get_seconds_since_epoch>
1150eb: 90 nop
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_since_boot();
1150ec: e8 57 00 00 00 call 115148 <rtems_clock_get_ticks_since_boot>
1150f1: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
1150f3: 31 c0 xor %eax,%eax
1150f5: eb bf jmp 1150b6 <rtems_clock_get+0x2e>
1150f7: 90 nop
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_per_second();
1150f8: e8 37 00 00 00 call 115134 <rtems_clock_get_ticks_per_second>
1150fd: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
1150ff: 31 c0 xor %eax,%eax
115101: eb b3 jmp 1150b6 <rtems_clock_get+0x2e>
00115208 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
115208: 55 push %ebp
115209: 89 e5 mov %esp,%ebp
11520b: 56 push %esi
11520c: 53 push %ebx
11520d: 83 ec 10 sub $0x10,%esp
115210: 8b 5d 08 mov 0x8(%ebp),%ebx
if ( !time )
115213: 85 db test %ebx,%ebx
115215: 74 51 je 115268 <rtems_clock_get_tod_timeval+0x60>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
115217: 80 3d fc 08 14 00 00 cmpb $0x0,0x1408fc
11521e: 75 0c jne 11522c <rtems_clock_get_tod_timeval+0x24>
return RTEMS_NOT_DEFINED;
115220: b8 0b 00 00 00 mov $0xb,%eax
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
}
115225: 8d 65 f8 lea -0x8(%ebp),%esp
115228: 5b pop %ebx
115229: 5e pop %esi
11522a: c9 leave
11522b: c3 ret
{
ISR_Level level;
struct timespec now;
suseconds_t useconds;
_ISR_Disable(level);
11522c: 9c pushf
11522d: fa cli
11522e: 5e pop %esi
_TOD_Get( &now );
11522f: 83 ec 0c sub $0xc,%esp
115232: 8d 45 f0 lea -0x10(%ebp),%eax
115235: 50 push %eax
115236: e8 c9 42 00 00 call 119504 <_TOD_Get>
_ISR_Enable(level);
11523b: 56 push %esi
11523c: 9d popf
useconds = (suseconds_t)now.tv_nsec;
11523d: 8b 4d f4 mov -0xc(%ebp),%ecx
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
115240: 8b 45 f0 mov -0x10(%ebp),%eax
115243: 89 03 mov %eax,(%ebx)
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
115245: b8 d3 4d 62 10 mov $0x10624dd3,%eax
11524a: f7 e9 imul %ecx
11524c: 89 d0 mov %edx,%eax
11524e: c1 f8 06 sar $0x6,%eax
115251: c1 f9 1f sar $0x1f,%ecx
115254: 29 c8 sub %ecx,%eax
115256: 89 43 04 mov %eax,0x4(%ebx)
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
115259: 83 c4 10 add $0x10,%esp
11525c: 31 c0 xor %eax,%eax
}
11525e: 8d 65 f8 lea -0x8(%ebp),%esp
115261: 5b pop %ebx
115262: 5e pop %esi
115263: c9 leave
115264: c3 ret
115265: 8d 76 00 lea 0x0(%esi),%esi
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
if ( !time )
return RTEMS_INVALID_ADDRESS;
115268: b8 09 00 00 00 mov $0x9,%eax
11526d: eb b6 jmp 115225 <rtems_clock_get_tod_timeval+0x1d>
0010a77c <rtems_clock_get_uptime>:
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
10a77c: 55 push %ebp
10a77d: 89 e5 mov %esp,%ebp
10a77f: 83 ec 08 sub $0x8,%esp
10a782: 8b 45 08 mov 0x8(%ebp),%eax
if ( !uptime )
10a785: 85 c0 test %eax,%eax
10a787: 74 13 je 10a79c <rtems_clock_get_uptime+0x20>
return RTEMS_INVALID_ADDRESS;
_TOD_Get_uptime_as_timespec( uptime );
10a789: 83 ec 0c sub $0xc,%esp
10a78c: 50 push %eax
10a78d: e8 42 14 00 00 call 10bbd4 <_TOD_Get_uptime_as_timespec>
return RTEMS_SUCCESSFUL;
10a792: 83 c4 10 add $0x10,%esp
10a795: 31 c0 xor %eax,%eax
}
10a797: c9 leave
10a798: c3 ret
10a799: 8d 76 00 lea 0x0(%esi),%esi
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
if ( !uptime )
return RTEMS_INVALID_ADDRESS;
10a79c: b8 09 00 00 00 mov $0x9,%eax
_TOD_Get_uptime_as_timespec( uptime );
return RTEMS_SUCCESSFUL;
}
10a7a1: c9 leave
10a7a2: c3 ret
0010b6f8 <rtems_clock_set>:
*/
rtems_status_code rtems_clock_set(
rtems_time_of_day *time_buffer
)
{
10b6f8: 55 push %ebp
10b6f9: 89 e5 mov %esp,%ebp
10b6fb: 53 push %ebx
10b6fc: 83 ec 14 sub $0x14,%esp
10b6ff: 8b 5d 08 mov 0x8(%ebp),%ebx
struct timespec newtime;
if ( !time_buffer )
10b702: 85 db test %ebx,%ebx
10b704: 74 66 je 10b76c <rtems_clock_set+0x74>
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( time_buffer ) ) {
10b706: 83 ec 0c sub $0xc,%esp
10b709: 53 push %ebx
10b70a: e8 39 01 00 00 call 10b848 <_TOD_Validate>
10b70f: 83 c4 10 add $0x10,%esp
10b712: 84 c0 test %al,%al
10b714: 75 0a jne 10b720 <rtems_clock_set+0x28>
_Thread_Disable_dispatch();
_TOD_Set( &newtime );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_INVALID_CLOCK;
10b716: b8 14 00 00 00 mov $0x14,%eax
}
10b71b: 8b 5d fc mov -0x4(%ebp),%ebx
10b71e: c9 leave
10b71f: c3 ret
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( time_buffer ) ) {
newtime.tv_sec = _TOD_To_seconds( time_buffer );
10b720: 83 ec 0c sub $0xc,%esp
10b723: 53 push %ebx
10b724: e8 93 00 00 00 call 10b7bc <_TOD_To_seconds>
10b729: 89 45 f0 mov %eax,-0x10(%ebp)
newtime.tv_nsec = time_buffer->ticks *
10b72c: 8b 43 18 mov 0x18(%ebx),%eax
10b72f: 0f af 05 6c 52 12 00 imul 0x12526c,%eax
10b736: 8d 04 80 lea (%eax,%eax,4),%eax
10b739: 8d 04 80 lea (%eax,%eax,4),%eax
10b73c: 8d 04 80 lea (%eax,%eax,4),%eax
10b73f: c1 e0 03 shl $0x3,%eax
10b742: 89 45 f4 mov %eax,-0xc(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b745: a1 cc 98 12 00 mov 0x1298cc,%eax
10b74a: 40 inc %eax
10b74b: a3 cc 98 12 00 mov %eax,0x1298cc
rtems_configuration_get_nanoseconds_per_tick();
_Thread_Disable_dispatch();
_TOD_Set( &newtime );
10b750: 8d 45 f0 lea -0x10(%ebp),%eax
10b753: 89 04 24 mov %eax,(%esp)
10b756: e8 21 17 00 00 call 10ce7c <_TOD_Set>
_Thread_Enable_dispatch();
10b75b: e8 bc 2c 00 00 call 10e41c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b760: 83 c4 10 add $0x10,%esp
10b763: 31 c0 xor %eax,%eax
}
return RTEMS_INVALID_CLOCK;
}
10b765: 8b 5d fc mov -0x4(%ebp),%ebx
10b768: c9 leave
10b769: c3 ret
10b76a: 66 90 xchg %ax,%ax
)
{
struct timespec newtime;
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
10b76c: b8 09 00 00 00 mov $0x9,%eax
_TOD_Set( &newtime );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_INVALID_CLOCK;
}
10b771: 8b 5d fc mov -0x4(%ebp),%ebx
10b774: c9 leave
10b775: c3 ret
0010a578 <rtems_clock_tick>:
*
* NOTE: This routine only works for leap-years through 2099.
*/
rtems_status_code rtems_clock_tick( void )
{
10a578: 55 push %ebp
10a579: 89 e5 mov %esp,%ebp
10a57b: 83 ec 08 sub $0x8,%esp
_TOD_Tickle_ticks();
10a57e: e8 05 13 00 00 call 10b888 <_TOD_Tickle_ticks>
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void )
{
_Watchdog_Tickle( &_Watchdog_Ticks_chain );
10a583: 83 ec 0c sub $0xc,%esp
10a586: 68 c0 65 12 00 push $0x1265c0
10a58b: e8 24 36 00 00 call 10dbb4 <_Watchdog_Tickle>
_Watchdog_Tickle_ticks();
_Thread_Tickle_timeslice();
10a590: e8 17 31 00 00 call 10d6ac <_Thread_Tickle_timeslice>
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void )
{
return ( _Thread_Dispatch_necessary );
10a595: a0 84 67 12 00 mov 0x126784,%al
if ( _Thread_Is_context_switch_necessary() &&
10a59a: 83 c4 10 add $0x10,%esp
10a59d: 84 c0 test %al,%al
10a59f: 74 09 je 10a5aa <rtems_clock_tick+0x32>
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void )
{
return ( _Thread_Dispatch_disable_level == 0 );
10a5a1: a1 ec 64 12 00 mov 0x1264ec,%eax
10a5a6: 85 c0 test %eax,%eax
10a5a8: 74 06 je 10a5b0 <rtems_clock_tick+0x38>
_Thread_Is_dispatching_enabled() )
_Thread_Dispatch();
return RTEMS_SUCCESSFUL;
}
10a5aa: 31 c0 xor %eax,%eax
10a5ac: c9 leave
10a5ad: c3 ret
10a5ae: 66 90 xchg %ax,%ax
_Thread_Tickle_timeslice();
if ( _Thread_Is_context_switch_necessary() &&
_Thread_Is_dispatching_enabled() )
_Thread_Dispatch();
10a5b0: e8 cf 25 00 00 call 10cb84 <_Thread_Dispatch>
return RTEMS_SUCCESSFUL;
}
10a5b5: 31 c0 xor %eax,%eax
10a5b7: c9 leave
10a5b8: c3 ret
00107980 <rtems_cpu_usage_report_with_plugin>:
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
107980: 55 push %ebp
107981: 89 e5 mov %esp,%ebp
107983: 57 push %edi
107984: 56 push %esi
107985: 53 push %ebx
107986: 83 ec 6c sub $0x6c,%esp
Timestamp_Control uptime, total, ran, uptime_at_last_reset;
#else
uint32_t total_units = 0;
#endif
if ( !print )
107989: 8b 55 0c mov 0xc(%ebp),%edx
10798c: 85 d2 test %edx,%edx
10798e: 0f 84 a0 01 00 00 je 107b34 <rtems_cpu_usage_report_with_plugin+0x1b4><== NEVER TAKEN
* When not using nanosecond CPU usage resolution, we have to count
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &total );
107994: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
10799b: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
1079a2: a1 00 9c 12 00 mov 0x129c00,%eax
1079a7: 8b 15 04 9c 12 00 mov 0x129c04,%edx
1079ad: 89 45 c0 mov %eax,-0x40(%ebp)
1079b0: 89 55 c4 mov %edx,-0x3c(%ebp)
}
}
}
#endif
(*print)(
1079b3: 83 ec 08 sub $0x8,%esp
1079b6: 68 30 1f 12 00 push $0x121f30
1079bb: ff 75 08 pushl 0x8(%ebp)
1079be: ff 55 0c call *0xc(%ebp)
1079c1: 83 c4 10 add $0x10,%esp
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
1079c4: c7 45 90 01 00 00 00 movl $0x1,-0x70(%ebp)
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
1079cb: 8b 55 90 mov -0x70(%ebp),%edx
1079ce: 8b 04 95 a4 98 12 00 mov 0x1298a4(,%edx,4),%eax
1079d5: 85 c0 test %eax,%eax
1079d7: 0f 84 2b 01 00 00 je 107b08 <rtems_cpu_usage_report_with_plugin+0x188>
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
1079dd: 8b 70 04 mov 0x4(%eax),%esi
if ( information ) {
1079e0: 85 f6 test %esi,%esi
1079e2: 0f 84 20 01 00 00 je 107b08 <rtems_cpu_usage_report_with_plugin+0x188><== NEVER TAKEN
for ( i=1 ; i <= information->maximum ; i++ ) {
1079e8: 66 83 7e 10 00 cmpw $0x0,0x10(%esi)
1079ed: 0f 84 15 01 00 00 je 107b08 <rtems_cpu_usage_report_with_plugin+0x188><== NEVER TAKEN
1079f3: bb 01 00 00 00 mov $0x1,%ebx
1079f8: eb 6f jmp 107a69 <rtems_cpu_usage_report_with_plugin+0xe9>
1079fa: 66 90 xchg %ax,%ax
Timestamp_Control last = _Thread_Time_of_last_context_switch;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract( &last, &uptime, &used );
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
1079fc: 83 ec 0c sub $0xc,%esp
1079ff: 8d 7d d8 lea -0x28(%ebp),%edi
107a02: 57 push %edi
107a03: e8 ec 53 00 00 call 10cdf4 <_TOD_Get_uptime>
107a08: 83 c4 10 add $0x10,%esp
107a0b: 8d 55 c8 lea -0x38(%ebp),%edx
107a0e: 89 55 94 mov %edx,-0x6c(%ebp)
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
107a11: 50 push %eax
107a12: 8d 45 d0 lea -0x30(%ebp),%eax
107a15: 50 push %eax
107a16: 57 push %edi
107a17: 8d 55 c0 lea -0x40(%ebp),%edx
107a1a: 52 push %edx
107a1b: e8 ec 74 00 00 call 10ef0c <_Timespec_Subtract>
_Timestamp_Divide( &ran, &total, &ival, &fval );
107a20: 8d 45 e0 lea -0x20(%ebp),%eax
107a23: 50 push %eax
107a24: 8d 55 e4 lea -0x1c(%ebp),%edx
107a27: 52 push %edx
107a28: 8d 45 d0 lea -0x30(%ebp),%eax
107a2b: 50 push %eax
107a2c: ff 75 94 pushl -0x6c(%ebp)
107a2f: e8 14 74 00 00 call 10ee48 <_Timespec_Divide>
/*
* Print the information
*/
(*print)( context,
107a34: 83 c4 18 add $0x18,%esp
107a37: ff 75 e0 pushl -0x20(%ebp)
107a3a: ff 75 e4 pushl -0x1c(%ebp)
107a3d: ba d3 4d 62 10 mov $0x10624dd3,%edx
107a42: 8b 45 cc mov -0x34(%ebp),%eax
107a45: f7 e2 mul %edx
107a47: c1 ea 06 shr $0x6,%edx
107a4a: 52 push %edx
107a4b: ff 75 c8 pushl -0x38(%ebp)
107a4e: 68 a3 21 12 00 push $0x1221a3
107a53: ff 75 08 pushl 0x8(%ebp)
107a56: ff 55 0c call *0xc(%ebp)
107a59: 83 c4 20 add $0x20,%esp
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
107a5c: 43 inc %ebx
107a5d: 0f b7 46 10 movzwl 0x10(%esi),%eax
107a61: 39 d8 cmp %ebx,%eax
107a63: 0f 82 9f 00 00 00 jb 107b08 <rtems_cpu_usage_report_with_plugin+0x188>
the_thread = (Thread_Control *)information->local_table[ i ];
107a69: 8b 46 1c mov 0x1c(%esi),%eax
107a6c: 8b 3c 98 mov (%eax,%ebx,4),%edi
if ( !the_thread )
107a6f: 85 ff test %edi,%edi
107a71: 74 e9 je 107a5c <rtems_cpu_usage_report_with_plugin+0xdc><== NEVER TAKEN
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
107a73: 50 push %eax
107a74: 8d 45 a3 lea -0x5d(%ebp),%eax
107a77: 50 push %eax
107a78: 6a 0d push $0xd
107a7a: ff 77 08 pushl 0x8(%edi)
107a7d: e8 aa 41 00 00 call 10bc2c <rtems_object_get_name>
(*print)(
107a82: 8d 55 a3 lea -0x5d(%ebp),%edx
107a85: 52 push %edx
107a86: ff 77 08 pushl 0x8(%edi)
107a89: 68 90 21 12 00 push $0x122190
107a8e: ff 75 08 pushl 0x8(%ebp)
107a91: ff 55 0c call *0xc(%ebp)
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
107a94: 8b 87 84 00 00 00 mov 0x84(%edi),%eax
107a9a: 8b 97 88 00 00 00 mov 0x88(%edi),%edx
107aa0: 89 45 c8 mov %eax,-0x38(%ebp)
107aa3: 89 55 cc mov %edx,-0x34(%ebp)
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
107aa6: 83 c4 20 add $0x20,%esp
107aa9: a1 98 9b 12 00 mov 0x129b98,%eax
107aae: 8b 57 08 mov 0x8(%edi),%edx
107ab1: 39 50 08 cmp %edx,0x8(%eax)
107ab4: 0f 85 42 ff ff ff jne 1079fc <rtems_cpu_usage_report_with_plugin+0x7c>
Timestamp_Control used;
Timestamp_Control last = _Thread_Time_of_last_context_switch;
107aba: a1 8c 99 12 00 mov 0x12998c,%eax
107abf: 8b 15 90 99 12 00 mov 0x129990,%edx
107ac5: 89 45 b0 mov %eax,-0x50(%ebp)
107ac8: 89 55 b4 mov %edx,-0x4c(%ebp)
_TOD_Get_uptime( &uptime );
107acb: 83 ec 0c sub $0xc,%esp
107ace: 8d 7d d8 lea -0x28(%ebp),%edi
107ad1: 57 push %edi
107ad2: e8 1d 53 00 00 call 10cdf4 <_TOD_Get_uptime>
_Timestamp_Subtract( &last, &uptime, &used );
107ad7: 83 c4 0c add $0xc,%esp
107ada: 8d 45 b8 lea -0x48(%ebp),%eax
107add: 50 push %eax
107ade: 57 push %edi
107adf: 8d 55 b0 lea -0x50(%ebp),%edx
107ae2: 52 push %edx
107ae3: 89 45 8c mov %eax,-0x74(%ebp)
107ae6: e8 21 74 00 00 call 10ef0c <_Timespec_Subtract>
_Timestamp_Add_to( &ran, &used );
107aeb: 5a pop %edx
107aec: 59 pop %ecx
107aed: 8b 45 8c mov -0x74(%ebp),%eax
107af0: 50 push %eax
107af1: 8d 45 c8 lea -0x38(%ebp),%eax
107af4: 89 45 94 mov %eax,-0x6c(%ebp)
107af7: 50 push %eax
107af8: e8 0f 73 00 00 call 10ee0c <_Timespec_Add_to>
107afd: 83 c4 10 add $0x10,%esp
107b00: e9 0c ff ff ff jmp 107a11 <rtems_cpu_usage_report_with_plugin+0x91>
107b05: 8d 76 00 lea 0x0(%esi),%esi
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
107b08: ff 45 90 incl -0x70(%ebp)
107b0b: 83 7d 90 04 cmpl $0x4,-0x70(%ebp)
107b0f: 0f 85 b6 fe ff ff jne 1079cb <rtems_cpu_usage_report_with_plugin+0x4b>
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)(
107b15: ba d3 4d 62 10 mov $0x10624dd3,%edx
107b1a: 8b 45 d4 mov -0x2c(%ebp),%eax
107b1d: f7 e2 mul %edx
107b1f: c1 ea 06 shr $0x6,%edx
107b22: 52 push %edx
107b23: ff 75 d0 pushl -0x30(%ebp)
107b26: 68 a4 20 12 00 push $0x1220a4
107b2b: ff 75 08 pushl 0x8(%ebp)
107b2e: ff 55 0c call *0xc(%ebp)
107b31: 83 c4 10 add $0x10,%esp
"-------------------------------------------------------------------------------\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,
total_units
);
#endif
}
107b34: 8d 65 f4 lea -0xc(%ebp),%esp
107b37: 5b pop %ebx
107b38: 5e pop %esi
107b39: 5f pop %edi
107b3a: c9 leave
107b3b: c3 ret
00111d8c <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
111d8c: 55 push %ebp
111d8d: 89 e5 mov %esp,%ebp
111d8f: 53 push %ebx
111d90: 83 ec 04 sub $0x4,%esp
111d93: 8b 45 08 mov 0x8(%ebp),%eax
if (sc == RTEMS_SUCCESSFUL) {
111d96: 85 c0 test %eax,%eax
111d98: 75 06 jne 111da0 <rtems_deviceio_errno+0x14>
return 0;
111d9a: 31 c0 xor %eax,%eax
errno = eno;
return -1;
}
}
111d9c: 5a pop %edx
111d9d: 5b pop %ebx
111d9e: c9 leave
111d9f: c3 ret
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
111da0: 83 f8 1c cmp $0x1c,%eax
111da3: 77 17 ja 111dbc <rtems_deviceio_errno+0x30><== NEVER TAKEN
eno = status_code_to_errno [sc];
111da5: 8b 1c 85 40 04 12 00 mov 0x120440(,%eax,4),%ebx
}
errno = eno;
111dac: e8 2b 00 00 00 call 111ddc <__errno>
111db1: 89 18 mov %ebx,(%eax)
return -1;
111db3: b8 ff ff ff ff mov $0xffffffff,%eax
111db8: eb e2 jmp 111d9c <rtems_deviceio_errno+0x10>
111dba: 66 90 xchg %ax,%ax
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
111dbc: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED
111dc1: eb e9 jmp 111dac <rtems_deviceio_errno+0x20><== NOT EXECUTED
0010a744 <rtems_event_send>:
rtems_status_code rtems_event_send(
rtems_id id,
rtems_event_set event_in
)
{
10a744: 55 push %ebp
10a745: 89 e5 mov %esp,%ebp
10a747: 53 push %ebx
10a748: 83 ec 1c sub $0x1c,%esp
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
the_thread = _Thread_Get( id, &location );
10a74b: 8d 45 f4 lea -0xc(%ebp),%eax
10a74e: 50 push %eax
10a74f: ff 75 08 pushl 0x8(%ebp)
10a752: e8 c9 25 00 00 call 10cd20 <_Thread_Get>
switch ( location ) {
10a757: 83 c4 10 add $0x10,%esp
10a75a: 8b 55 f4 mov -0xc(%ebp),%edx
10a75d: 85 d2 test %edx,%edx
10a75f: 75 2b jne 10a78c <rtems_event_send+0x48>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
10a761: 8b 90 e4 00 00 00 mov 0xe4(%eax),%edx
rtems_event_set *the_event_set
)
{
ISR_Level level;
_ISR_Disable( level );
10a767: 9c pushf
10a768: fa cli
10a769: 59 pop %ecx
*the_event_set |= the_new_events;
10a76a: 8b 5d 0c mov 0xc(%ebp),%ebx
10a76d: 09 1a or %ebx,(%edx)
_ISR_Enable( level );
10a76f: 51 push %ecx
10a770: 9d popf
_Event_sets_Post( event_in, &api->pending_events );
_Event_Surrender( the_thread );
10a771: 83 ec 0c sub $0xc,%esp
10a774: 50 push %eax
10a775: e8 1e 00 00 00 call 10a798 <_Event_Surrender>
_Thread_Enable_dispatch();
10a77a: e8 7d 25 00 00 call 10ccfc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10a77f: 83 c4 10 add $0x10,%esp
10a782: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a784: 8b 5d fc mov -0x4(%ebp),%ebx
10a787: c9 leave
10a788: c3 ret
10a789: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10a78c: b8 04 00 00 00 mov $0x4,%eax
}
10a791: 8b 5d fc mov -0x4(%ebp),%ebx
10a794: c9 leave
10a795: c3 ret
0010c6bc <rtems_extension_create>:
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
10c6bc: 55 push %ebp
10c6bd: 89 e5 mov %esp,%ebp
10c6bf: 57 push %edi
10c6c0: 56 push %esi
10c6c1: 53 push %ebx
10c6c2: 83 ec 1c sub $0x1c,%esp
10c6c5: 8b 75 0c mov 0xc(%ebp),%esi
10c6c8: 8b 5d 10 mov 0x10(%ebp),%ebx
Extension_Control *the_extension;
if ( !id )
10c6cb: 85 db test %ebx,%ebx
10c6cd: 0f 84 85 00 00 00 je 10c758 <rtems_extension_create+0x9c><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
10c6d3: 8b 45 08 mov 0x8(%ebp),%eax
10c6d6: 85 c0 test %eax,%eax
10c6d8: 75 0e jne 10c6e8 <rtems_extension_create+0x2c>
return RTEMS_INVALID_NAME;
10c6da: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_extension->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c6df: 8d 65 f4 lea -0xc(%ebp),%esp
10c6e2: 5b pop %ebx
10c6e3: 5e pop %esi
10c6e4: 5f pop %edi
10c6e5: c9 leave
10c6e6: c3 ret
10c6e7: 90 nop
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10c6e8: a1 cc 98 12 00 mov 0x1298cc,%eax
10c6ed: 40 inc %eax
10c6ee: a3 cc 98 12 00 mov %eax,0x1298cc
#ifndef __EXTENSION_MANAGER_inl
#define __EXTENSION_MANAGER_inl
RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void )
{
return (Extension_Control *) _Objects_Allocate( &_Extension_Information );
10c6f3: 83 ec 0c sub $0xc,%esp
10c6f6: 68 20 9b 12 00 push $0x129b20
10c6fb: e8 c0 0c 00 00 call 10d3c0 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_extension = _Extension_Allocate();
if ( !the_extension ) {
10c700: 83 c4 10 add $0x10,%esp
10c703: 85 c0 test %eax,%eax
10c705: 74 45 je 10c74c <rtems_extension_create+0x90>
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
10c707: 8d 78 24 lea 0x24(%eax),%edi
10c70a: b9 08 00 00 00 mov $0x8,%ecx
10c70f: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_User_extensions_Add_set( extension );
10c711: 83 ec 0c sub $0xc,%esp
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
_User_extensions_Add_set_with_table( &the_extension->Extension, extension_table );
10c714: 8d 50 10 lea 0x10(%eax),%edx
10c717: 52 push %edx
10c718: 89 45 e4 mov %eax,-0x1c(%ebp)
10c71b: e8 2c 28 00 00 call 10ef4c <_User_extensions_Add_set>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10c720: 8b 45 e4 mov -0x1c(%ebp),%eax
10c723: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10c726: 0f b7 f2 movzwl %dx,%esi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c729: 8b 0d 3c 9b 12 00 mov 0x129b3c,%ecx
10c72f: 89 04 b1 mov %eax,(%ecx,%esi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10c732: 8b 4d 08 mov 0x8(%ebp),%ecx
10c735: 89 48 0c mov %ecx,0xc(%eax)
&_Extension_Information,
&the_extension->Object,
(Objects_Name) name
);
*id = the_extension->Object.id;
10c738: 89 13 mov %edx,(%ebx)
_Thread_Enable_dispatch();
10c73a: e8 dd 1c 00 00 call 10e41c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c73f: 83 c4 10 add $0x10,%esp
10c742: 31 c0 xor %eax,%eax
}
10c744: 8d 65 f4 lea -0xc(%ebp),%esp
10c747: 5b pop %ebx
10c748: 5e pop %esi
10c749: 5f pop %edi
10c74a: c9 leave
10c74b: c3 ret
_Thread_Disable_dispatch(); /* to prevent deletion */
the_extension = _Extension_Allocate();
if ( !the_extension ) {
_Thread_Enable_dispatch();
10c74c: e8 cb 1c 00 00 call 10e41c <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
10c751: b8 05 00 00 00 mov $0x5,%eax
10c756: eb 87 jmp 10c6df <rtems_extension_create+0x23>
)
{
Extension_Control *the_extension;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10c758: b8 09 00 00 00 mov $0x9,%eax
10c75d: eb 80 jmp 10c6df <rtems_extension_create+0x23>
0010c4f4 <rtems_extension_delete>:
#include <rtems/extension.h>
rtems_status_code rtems_extension_delete(
rtems_id id
)
{
10c4f4: 55 push %ebp
10c4f5: 89 e5 mov %esp,%ebp
10c4f7: 53 push %ebx
10c4f8: 83 ec 18 sub $0x18,%esp
Extension_Control *the_extension;
Objects_Locations location;
the_extension = _Extension_Get( id, &location );
10c4fb: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Extension_Control *)
_Objects_Get( &_Extension_Information, id, location );
10c4fe: 50 push %eax
10c4ff: ff 75 08 pushl 0x8(%ebp)
10c502: 68 20 8b 12 00 push $0x128b20
10c507: e8 a8 10 00 00 call 10d5b4 <_Objects_Get>
10c50c: 89 c3 mov %eax,%ebx
switch ( location ) {
10c50e: 83 c4 10 add $0x10,%esp
10c511: 8b 55 f4 mov -0xc(%ebp),%edx
10c514: 85 d2 test %edx,%edx
10c516: 75 38 jne 10c550 <rtems_extension_delete+0x5c>
case OBJECTS_LOCAL:
_User_extensions_Remove_set( &the_extension->Extension );
10c518: 83 ec 0c sub $0xc,%esp
10c51b: 8d 40 10 lea 0x10(%eax),%eax
10c51e: 50 push %eax
10c51f: e8 d4 26 00 00 call 10ebf8 <_User_extensions_Remove_set>
_Objects_Close( &_Extension_Information, &the_extension->Object );
10c524: 59 pop %ecx
10c525: 58 pop %eax
10c526: 53 push %ebx
10c527: 68 20 8b 12 00 push $0x128b20
10c52c: e8 4b 0c 00 00 call 10d17c <_Objects_Close>
RTEMS_INLINE_ROUTINE void _Extension_Free (
Extension_Control *the_extension
)
{
_Objects_Free( &_Extension_Information, &the_extension->Object );
10c531: 58 pop %eax
10c532: 5a pop %edx
10c533: 53 push %ebx
10c534: 68 20 8b 12 00 push $0x128b20
10c539: e8 36 0f 00 00 call 10d474 <_Objects_Free>
_Extension_Free( the_extension );
_Thread_Enable_dispatch();
10c53e: e8 49 1b 00 00 call 10e08c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c543: 83 c4 10 add $0x10,%esp
10c546: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c548: 8b 5d fc mov -0x4(%ebp),%ebx
10c54b: c9 leave
10c54c: c3 ret
10c54d: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10c550: b8 04 00 00 00 mov $0x4,%eax
}
10c555: 8b 5d fc mov -0x4(%ebp),%ebx
10c558: c9 leave
10c559: c3 ret
0010758c <rtems_filesystem_dirname>:
int rtems_filesystem_dirname(
const char *pathname
)
{
10758c: 55 push %ebp
10758d: 89 e5 mov %esp,%ebp
10758f: 57 push %edi
107590: 56 push %esi
107591: 53 push %ebx
107592: 83 ec 0c sub $0xc,%esp
107595: 8b 5d 08 mov 0x8(%ebp),%ebx
int len = strlen( pathname );
107598: 31 c0 xor %eax,%eax
10759a: b9 ff ff ff ff mov $0xffffffff,%ecx
10759f: 89 df mov %ebx,%edi
1075a1: f2 ae repnz scas %es:(%edi),%al
1075a3: f7 d1 not %ecx
while ( len ) {
1075a5: 89 ce mov %ecx,%esi
1075a7: 4e dec %esi
1075a8: 75 06 jne 1075b0 <rtems_filesystem_dirname+0x24><== ALWAYS TAKEN
1075aa: eb 19 jmp 1075c5 <rtems_filesystem_dirname+0x39><== NOT EXECUTED
1075ac: 85 f6 test %esi,%esi
1075ae: 74 15 je 1075c5 <rtems_filesystem_dirname+0x39>
len--;
1075b0: 4e dec %esi
if ( rtems_filesystem_is_separator( pathname[len] ) )
1075b1: 83 ec 0c sub $0xc,%esp
1075b4: 0f be 04 33 movsbl (%ebx,%esi,1),%eax
1075b8: 50 push %eax
1075b9: e8 02 0f 00 00 call 1084c0 <rtems_filesystem_is_separator>
1075be: 83 c4 10 add $0x10,%esp
1075c1: 85 c0 test %eax,%eax
1075c3: 74 e7 je 1075ac <rtems_filesystem_dirname+0x20>
break;
}
return len;
}
1075c5: 89 f0 mov %esi,%eax
1075c7: 8d 65 f4 lea -0xc(%ebp),%esp
1075ca: 5b pop %ebx
1075cb: 5e pop %esi
1075cc: 5f pop %edi
1075cd: c9 leave
1075ce: c3 ret
0010f518 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
10f518: 55 push %ebp
10f519: 89 e5 mov %esp,%ebp
10f51b: 83 ec 18 sub $0x18,%esp
10f51e: 8b 45 08 mov 0x8(%ebp),%eax
find_arg fa = {
10f521: 89 45 f0 mov %eax,-0x10(%ebp)
10f524: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
10f52b: 85 c0 test %eax,%eax
10f52d: 74 19 je 10f548 <rtems_filesystem_get_mount_handler+0x30><== NEVER TAKEN
rtems_filesystem_iterate( find_handler, &fa );
10f52f: 83 ec 08 sub $0x8,%esp
10f532: 8d 45 f0 lea -0x10(%ebp),%eax
10f535: 50 push %eax
10f536: 68 38 f4 10 00 push $0x10f438
10f53b: e8 34 ff ff ff call 10f474 <rtems_filesystem_iterate>
10f540: 8b 45 f4 mov -0xc(%ebp),%eax
10f543: 83 c4 10 add $0x10,%esp
}
return fa.mount_h;
}
10f546: c9 leave
10f547: c3 ret
find_arg fa = {
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
10f548: 31 c0 xor %eax,%eax
rtems_filesystem_iterate( find_handler, &fa );
}
return fa.mount_h;
}
10f54a: c9 leave <== NOT EXECUTED
10f54b: c3 ret <== NOT EXECUTED
0010f6d4 <rtems_filesystem_get_sym_start_loc>:
#include "rtems/libio_.h"
void rtems_filesystem_get_sym_start_loc(const char *path,
int *index,
rtems_filesystem_location_info_t *loc)
{
10f6d4: 55 push %ebp
10f6d5: 89 e5 mov %esp,%ebp
10f6d7: 57 push %edi
10f6d8: 56 push %esi
10f6d9: 53 push %ebx
10f6da: 83 ec 18 sub $0x18,%esp
10f6dd: 8b 5d 0c mov 0xc(%ebp),%ebx
if (rtems_filesystem_is_separator(path[0])) {
10f6e0: 8b 45 08 mov 0x8(%ebp),%eax
10f6e3: 0f be 00 movsbl (%eax),%eax
10f6e6: 50 push %eax
10f6e7: e8 d4 8d ff ff call 1084c0 <rtems_filesystem_is_separator>
10f6ec: 83 c4 10 add $0x10,%esp
10f6ef: 85 c0 test %eax,%eax
10f6f1: 75 11 jne 10f704 <rtems_filesystem_get_sym_start_loc+0x30>
*loc = rtems_filesystem_root;
*index = 1;
}
else {
*index = 0;
10f6f3: c7 03 00 00 00 00 movl $0x0,(%ebx)
}
}
10f6f9: 8d 65 f4 lea -0xc(%ebp),%esp
10f6fc: 5b pop %ebx
10f6fd: 5e pop %esi
10f6fe: 5f pop %edi
10f6ff: c9 leave
10f700: c3 ret
10f701: 8d 76 00 lea 0x0(%esi),%esi
void rtems_filesystem_get_sym_start_loc(const char *path,
int *index,
rtems_filesystem_location_info_t *loc)
{
if (rtems_filesystem_is_separator(path[0])) {
*loc = rtems_filesystem_root;
10f704: 8b 35 b0 41 12 00 mov 0x1241b0,%esi
10f70a: 83 c6 18 add $0x18,%esi
10f70d: b9 05 00 00 00 mov $0x5,%ecx
10f712: 8b 7d 10 mov 0x10(%ebp),%edi
10f715: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*index = 1;
10f717: c7 03 01 00 00 00 movl $0x1,(%ebx)
}
else {
*index = 0;
}
}
10f71d: 8d 65 f4 lea -0xc(%ebp),%esp
10f720: 5b pop %ebx
10f721: 5e pop %esi
10f722: 5f pop %edi
10f723: c9 leave
10f724: c3 ret
001073bc <rtems_filesystem_initialize>:
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
1073bc: 55 push %ebp
1073bd: 89 e5 mov %esp,%ebp
1073bf: 57 push %edi
1073c0: 56 push %esi
1073c1: 53 push %ebx
1073c2: 83 ec 2c sub $0x2c,%esp
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
1073c5: a1 b0 41 12 00 mov 0x1241b0,%eax
1073ca: c7 40 2c 12 00 00 00 movl $0x12,0x2c(%eax)
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
1073d1: a1 a0 e4 11 00 mov 0x11e4a0,%eax
1073d6: 85 c0 test %eax,%eax
1073d8: 0f 84 9f 00 00 00 je 10747d <rtems_filesystem_initialize+0xc1><== NEVER TAKEN
rtems_fatal_error_occurred( 0xABCD0001 );
mt = &rtems_filesystem_mount_table[0];
1073de: a1 f4 21 12 00 mov 0x1221f4,%eax
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
1073e3: 83 ec 0c sub $0xc,%esp
1073e6: 6a 00 push $0x0
1073e8: ff 70 04 pushl 0x4(%eax)
1073eb: ff 30 pushl (%eax)
1073ed: ff 70 0c pushl 0xc(%eax)
1073f0: ff 70 08 pushl 0x8(%eax)
1073f3: e8 24 07 00 00 call 107b1c <mount>
if ( status == -1 )
1073f8: 83 c4 20 add $0x20,%esp
1073fb: 40 inc %eax
1073fc: 0f 84 95 00 00 00 je 107497 <rtems_filesystem_initialize+0xdb><== NEVER TAKEN
rtems_fatal_error_occurred( 0xABCD0002 );
rtems_filesystem_link_counts = 0;
107402: a1 b0 41 12 00 mov 0x1241b0,%eax
107407: 66 c7 40 30 00 00 movw $0x0,0x30(%eax)
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
10740d: 83 ec 0c sub $0xc,%esp
107410: 6a 00 push $0x0
107412: 8d 5d d4 lea -0x2c(%ebp),%ebx
107415: 53 push %ebx
107416: 6a 00 push $0x0
107418: 6a 01 push $0x1
10741a: 68 67 fd 11 00 push $0x11fd67
10741f: e8 24 01 00 00 call 107548 <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
107424: 8b 3d b0 41 12 00 mov 0x1241b0,%edi
10742a: 83 c7 18 add $0x18,%edi
10742d: b9 05 00 00 00 mov $0x5,%ecx
107432: 89 de mov %ebx,%esi
107434: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
107436: 83 c4 14 add $0x14,%esp
107439: 6a 00 push $0x0
10743b: 53 push %ebx
10743c: 6a 00 push $0x0
10743e: 6a 01 push $0x1
107440: 68 67 fd 11 00 push $0x11fd67
107445: e8 fe 00 00 00 call 107548 <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
10744a: 8b 3d b0 41 12 00 mov 0x1241b0,%edi
107450: 83 c7 04 add $0x4,%edi
107453: b9 05 00 00 00 mov $0x5,%ecx
107458: 89 de mov %ebx,%esi
10745a: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*
* NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
10745c: 83 c4 18 add $0x18,%esp
10745f: 68 ff 01 00 00 push $0x1ff
107464: 68 69 fd 11 00 push $0x11fd69
107469: e8 42 05 00 00 call 1079b0 <mkdir>
if ( status != 0 )
10746e: 83 c4 10 add $0x10,%esp
107471: 85 c0 test %eax,%eax
107473: 75 15 jne 10748a <rtems_filesystem_initialize+0xce><== NEVER TAKEN
* it will be mounted onto is created. Moreover, if it is going to
* use a device, then it is REALLY unfair to attempt this
* before device drivers are initialized. So we return via a base
* filesystem image and nothing auto-mounted at this point.
*/
}
107475: 8d 65 f4 lea -0xc(%ebp),%esp
107478: 5b pop %ebx
107479: 5e pop %esi
10747a: 5f pop %edi
10747b: c9 leave
10747c: c3 ret
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
rtems_fatal_error_occurred( 0xABCD0001 );
10747d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107480: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED
107485: e8 5e 3d 00 00 call 10b1e8 <rtems_fatal_error_occurred><== NOT EXECUTED
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
if ( status != 0 )
rtems_fatal_error_occurred( 0xABCD0003 );
10748a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10748d: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED
107492: e8 51 3d 00 00 call 10b1e8 <rtems_fatal_error_occurred><== NOT EXECUTED
mt = &rtems_filesystem_mount_table[0];
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
if ( status == -1 )
rtems_fatal_error_occurred( 0xABCD0002 );
107497: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10749a: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED
10749f: e8 44 3d 00 00 call 10b1e8 <rtems_fatal_error_occurred><== NOT EXECUTED
0010f474 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
10f474: 55 push %ebp
10f475: 89 e5 mov %esp,%ebp
10f477: 57 push %edi
10f478: 56 push %esi
10f479: 53 push %ebx
10f47a: 83 ec 1c sub $0x1c,%esp
10f47d: 8b 75 08 mov 0x8(%ebp),%esi
10f480: 8b 7d 0c mov 0xc(%ebp),%edi
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
10f483: 8b 1d 80 e4 11 00 mov 0x11e480,%ebx
10f489: 85 db test %ebx,%ebx
10f48b: 74 24 je 10f4b1 <rtems_filesystem_iterate+0x3d><== NEVER TAKEN
10f48d: bb 80 e4 11 00 mov $0x11e480,%ebx
10f492: eb 04 jmp 10f498 <rtems_filesystem_iterate+0x24>
10f494: 84 c0 test %al,%al
10f496: 75 70 jne 10f508 <rtems_filesystem_iterate+0x94>
stop = (*routine)( table_entry, routine_arg );
10f498: 83 ec 08 sub $0x8,%esp
10f49b: 57 push %edi
10f49c: 53 push %ebx
10f49d: ff d6 call *%esi
10f49f: 88 c2 mov %al,%dl
++table_entry;
10f4a1: 83 c3 08 add $0x8,%ebx
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
10f4a4: 83 c4 10 add $0x10,%esp
10f4a7: 8b 0b mov (%ebx),%ecx
10f4a9: 85 c9 test %ecx,%ecx
10f4ab: 75 e7 jne 10f494 <rtems_filesystem_iterate+0x20>
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
10f4ad: 84 c0 test %al,%al
10f4af: 75 57 jne 10f508 <rtems_filesystem_iterate+0x94>
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
10f4b1: 50 push %eax
10f4b2: 6a 00 push $0x0
10f4b4: 6a 00 push $0x0
10f4b6: ff 35 88 63 12 00 pushl 0x126388
10f4bc: e8 e7 b6 ff ff call 10aba8 <rtems_semaphore_obtain>
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
10f4c1: 8b 1d bc 41 12 00 mov 0x1241bc,%ebx
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
10f4c7: 83 c4 10 add $0x10,%esp
10f4ca: 81 fb c0 41 12 00 cmp $0x1241c0,%ebx
10f4d0: 75 06 jne 10f4d8 <rtems_filesystem_iterate+0x64>
10f4d2: eb 3e jmp 10f512 <rtems_filesystem_iterate+0x9e>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
10f4d4: 84 c0 test %al,%al
10f4d6: 75 19 jne 10f4f1 <rtems_filesystem_iterate+0x7d><== NEVER TAKEN
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
10f4d8: 83 ec 08 sub $0x8,%esp
10f4db: 57 push %edi
10f4dc: 8d 43 08 lea 0x8(%ebx),%eax
10f4df: 50 push %eax
10f4e0: ff d6 call *%esi
10f4e2: 88 c2 mov %al,%dl
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
10f4e4: 8b 1b mov (%ebx),%ebx
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
10f4e6: 83 c4 10 add $0x10,%esp
10f4e9: 81 fb c0 41 12 00 cmp $0x1241c0,%ebx
10f4ef: 75 e3 jne 10f4d4 <rtems_filesystem_iterate+0x60>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10f4f1: 83 ec 0c sub $0xc,%esp
10f4f4: ff 35 88 63 12 00 pushl 0x126388
10f4fa: 88 55 e4 mov %dl,-0x1c(%ebp)
10f4fd: e8 a2 b7 ff ff call 10aca4 <rtems_semaphore_release>
10f502: 83 c4 10 add $0x10,%esp
10f505: 8a 55 e4 mov -0x1c(%ebp),%dl
}
rtems_libio_unlock();
}
return stop;
}
10f508: 88 d0 mov %dl,%al
10f50a: 8d 65 f4 lea -0xc(%ebp),%esp
10f50d: 5b pop %ebx
10f50e: 5e pop %esi
10f50f: 5f pop %edi
10f510: c9 leave
10f511: c3 ret
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
10f512: 31 d2 xor %edx,%edx
10f514: eb db jmp 10f4f1 <rtems_filesystem_iterate+0x7d>
00107aac <rtems_filesystem_mount_iterate>:
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
107aac: 55 push %ebp
107aad: 89 e5 mov %esp,%ebp
107aaf: 57 push %edi
107ab0: 56 push %esi
107ab1: 53 push %ebx
107ab2: 83 ec 20 sub $0x20,%esp
107ab5: 8b 75 08 mov 0x8(%ebp),%esi
107ab8: 8b 7d 0c mov 0xc(%ebp),%edi
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
107abb: 6a 00 push $0x0
107abd: 6a 00 push $0x0
107abf: ff 35 88 63 12 00 pushl 0x126388
107ac5: e8 de 30 00 00 call 10aba8 <rtems_semaphore_obtain>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
107aca: 8b 1d 84 40 12 00 mov 0x124084,%ebx
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
107ad0: 83 c4 10 add $0x10,%esp
107ad3: 81 fb 88 40 12 00 cmp $0x124088,%ebx
107ad9: 75 09 jne 107ae4 <rtems_filesystem_mount_iterate+0x38><== ALWAYS TAKEN
107adb: eb 3b jmp 107b18 <rtems_filesystem_mount_iterate+0x6c><== NOT EXECUTED
107add: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
107ae0: 84 c0 test %al,%al
107ae2: 75 16 jne 107afa <rtems_filesystem_mount_iterate+0x4e><== NEVER TAKEN
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 );
107ae4: 83 ec 08 sub $0x8,%esp
107ae7: 57 push %edi
107ae8: 53 push %ebx
107ae9: ff d6 call *%esi
107aeb: 88 c2 mov %al,%dl
}
rtems_libio_unlock();
return stop;
}
107aed: 8b 1b mov (%ebx),%ebx
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
107aef: 83 c4 10 add $0x10,%esp
107af2: 81 fb 88 40 12 00 cmp $0x124088,%ebx
107af8: 75 e6 jne 107ae0 <rtems_filesystem_mount_iterate+0x34>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
107afa: 83 ec 0c sub $0xc,%esp
107afd: ff 35 88 63 12 00 pushl 0x126388
107b03: 88 55 e4 mov %dl,-0x1c(%ebp)
107b06: e8 99 31 00 00 call 10aca4 <rtems_semaphore_release>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
107b0b: 8a 55 e4 mov -0x1c(%ebp),%dl
107b0e: 88 d0 mov %dl,%al
107b10: 8d 65 f4 lea -0xc(%ebp),%esp
107b13: 5b pop %ebx
107b14: 5e pop %esi
107b15: 5f pop %edi
107b16: c9 leave
107b17: c3 ret
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
rtems_chain_node *node = NULL;
bool stop = false;
107b18: 31 d2 xor %edx,%edx <== NOT EXECUTED
107b1a: eb de jmp 107afa <rtems_filesystem_mount_iterate+0x4e><== NOT EXECUTED
001075d0 <rtems_filesystem_prefix_separators>:
int rtems_filesystem_prefix_separators(
const char *pathname,
int pathnamelen
)
{
1075d0: 55 push %ebp
1075d1: 89 e5 mov %esp,%ebp
1075d3: 57 push %edi
1075d4: 56 push %esi
1075d5: 53 push %ebx
1075d6: 83 ec 0c sub $0xc,%esp
1075d9: 8b 75 08 mov 0x8(%ebp),%esi
1075dc: 8b 7d 0c mov 0xc(%ebp),%edi
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
1075df: 8a 06 mov (%esi),%al
1075e1: 84 c0 test %al,%al
1075e3: 74 34 je 107619 <rtems_filesystem_prefix_separators+0x49><== NEVER TAKEN
1075e5: 85 ff test %edi,%edi
1075e7: 74 30 je 107619 <rtems_filesystem_prefix_separators+0x49><== NEVER TAKEN
1075e9: 31 db xor %ebx,%ebx
1075eb: eb 0f jmp 1075fc <rtems_filesystem_prefix_separators+0x2c>
1075ed: 8d 76 00 lea 0x0(%esi),%esi
{
pathname++;
pathnamelen--;
stripped++;
1075f0: 43 inc %ebx
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
1075f1: 8a 04 1e mov (%esi,%ebx,1),%al
1075f4: 84 c0 test %al,%al
1075f6: 74 17 je 10760f <rtems_filesystem_prefix_separators+0x3f><== NEVER TAKEN
1075f8: 39 df cmp %ebx,%edi
1075fa: 74 13 je 10760f <rtems_filesystem_prefix_separators+0x3f><== NEVER TAKEN
1075fc: 83 ec 0c sub $0xc,%esp
1075ff: 0f be c0 movsbl %al,%eax
107602: 50 push %eax
107603: e8 b8 0e 00 00 call 1084c0 <rtems_filesystem_is_separator>
107608: 83 c4 10 add $0x10,%esp
10760b: 85 c0 test %eax,%eax
10760d: 75 e1 jne 1075f0 <rtems_filesystem_prefix_separators+0x20>
pathname++;
pathnamelen--;
stripped++;
}
return stripped;
}
10760f: 89 d8 mov %ebx,%eax
107611: 8d 65 f4 lea -0xc(%ebp),%esp
107614: 5b pop %ebx
107615: 5e pop %esi
107616: 5f pop %edi
107617: c9 leave
107618: c3 ret
)
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
107619: 31 db xor %ebx,%ebx
10761b: eb f2 jmp 10760f <rtems_filesystem_prefix_separators+0x3f><== NOT EXECUTED
0010f54c <rtems_filesystem_register>:
int
rtems_filesystem_register(
const char *type,
rtems_filesystem_fsmount_me_t mount_h
)
{
10f54c: 55 push %ebp
10f54d: 89 e5 mov %esp,%ebp
10f54f: 57 push %edi
10f550: 56 push %esi
10f551: 53 push %ebx
10f552: 83 ec 28 sub $0x28,%esp
size_t type_size = strlen(type) + 1;
10f555: 31 c0 xor %eax,%eax
10f557: b9 ff ff ff ff mov $0xffffffff,%ecx
10f55c: 8b 7d 08 mov 0x8(%ebp),%edi
10f55f: f2 ae repnz scas %es:(%edi),%al
10f561: f7 d1 not %ecx
size_t fsn_size = sizeof( filesystem_node ) + type_size;
10f563: 8d 41 10 lea 0x10(%ecx),%eax
filesystem_node *fsn = malloc( fsn_size );
10f566: 50 push %eax
10f567: 89 4d e4 mov %ecx,-0x1c(%ebp)
10f56a: e8 99 83 ff ff call 107908 <malloc>
10f56f: 89 c3 mov %eax,%ebx
char *type_storage = (char *) fsn + sizeof( *fsn );
if ( fsn == NULL )
10f571: 83 c4 10 add $0x10,%esp
10f574: 85 c0 test %eax,%eax
10f576: 8b 4d e4 mov -0x1c(%ebp),%ecx
10f579: 0f 84 8e 00 00 00 je 10f60d <rtems_filesystem_register+0xc1><== NEVER TAKEN
)
{
size_t type_size = strlen(type) + 1;
size_t fsn_size = sizeof( filesystem_node ) + type_size;
filesystem_node *fsn = malloc( fsn_size );
char *type_storage = (char *) fsn + sizeof( *fsn );
10f57f: 8d 40 10 lea 0x10(%eax),%eax
if ( fsn == NULL )
rtems_set_errno_and_return_minus_one( ENOMEM );
memcpy(type_storage, type, type_size);
10f582: 89 c7 mov %eax,%edi
10f584: 8b 75 08 mov 0x8(%ebp),%esi
10f587: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
fsn->entry.type = type_storage;
10f589: 89 43 08 mov %eax,0x8(%ebx)
fsn->entry.mount_h = mount_h;
10f58c: 8b 45 0c mov 0xc(%ebp),%eax
10f58f: 89 43 0c mov %eax,0xc(%ebx)
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
10f592: 50 push %eax
10f593: 6a 00 push $0x0
10f595: 6a 00 push $0x0
10f597: ff 35 88 63 12 00 pushl 0x126388
10f59d: e8 06 b6 ff ff call 10aba8 <rtems_semaphore_obtain>
rtems_libio_lock();
if ( rtems_filesystem_get_mount_handler( type ) == NULL ) {
10f5a2: 5f pop %edi
10f5a3: ff 75 08 pushl 0x8(%ebp)
10f5a6: e8 6d ff ff ff call 10f518 <rtems_filesystem_get_mount_handler>
10f5ab: 83 c4 10 add $0x10,%esp
10f5ae: 85 c0 test %eax,%eax
10f5b0: 75 2a jne 10f5dc <rtems_filesystem_register+0x90><== NEVER TAKEN
10f5b2: 83 ec 08 sub $0x8,%esp
10f5b5: 53 push %ebx
10f5b6: 68 bc 41 12 00 push $0x1241bc
10f5bb: e8 c4 be ff ff call 10b484 <_Chain_Append>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10f5c0: 5e pop %esi
10f5c1: ff 35 88 63 12 00 pushl 0x126388
10f5c7: e8 d8 b6 ff ff call 10aca4 <rtems_semaphore_release>
10f5cc: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_unlock();
return 0;
10f5cf: 31 c0 xor %eax,%eax
}
10f5d1: 8d 65 f4 lea -0xc(%ebp),%esp
10f5d4: 5b pop %ebx
10f5d5: 5e pop %esi
10f5d6: 5f pop %edi
10f5d7: c9 leave
10f5d8: c3 ret
10f5d9: 8d 76 00 lea 0x0(%esi),%esi
10f5dc: 83 ec 0c sub $0xc,%esp
10f5df: ff 35 88 63 12 00 pushl 0x126388
10f5e5: e8 ba b6 ff ff call 10aca4 <rtems_semaphore_release>
rtems_libio_lock();
if ( rtems_filesystem_get_mount_handler( type ) == NULL ) {
rtems_chain_append( &filesystem_chain, &fsn->node );
} else {
rtems_libio_unlock();
free( fsn );
10f5ea: 89 1c 24 mov %ebx,(%esp)
10f5ed: e8 42 80 ff ff call 107634 <free>
rtems_set_errno_and_return_minus_one( EINVAL );
10f5f2: e8 e5 27 00 00 call 111ddc <__errno>
10f5f7: c7 00 16 00 00 00 movl $0x16,(%eax)
10f5fd: 83 c4 10 add $0x10,%esp
10f600: b8 ff ff ff ff mov $0xffffffff,%eax
}
rtems_libio_unlock();
return 0;
}
10f605: 8d 65 f4 lea -0xc(%ebp),%esp
10f608: 5b pop %ebx
10f609: 5e pop %esi
10f60a: 5f pop %edi
10f60b: c9 leave
10f60c: c3 ret
size_t fsn_size = sizeof( filesystem_node ) + type_size;
filesystem_node *fsn = malloc( fsn_size );
char *type_storage = (char *) fsn + sizeof( *fsn );
if ( fsn == NULL )
rtems_set_errno_and_return_minus_one( ENOMEM );
10f60d: e8 ca 27 00 00 call 111ddc <__errno>
10f612: c7 00 0c 00 00 00 movl $0xc,(%eax)
10f618: b8 ff ff ff ff mov $0xffffffff,%eax
10f61d: eb b2 jmp 10f5d1 <rtems_filesystem_register+0x85>
0010f620 <rtems_filesystem_unregister>:
int
rtems_filesystem_unregister(
const char *type
)
{
10f620: 55 push %ebp
10f621: 89 e5 mov %esp,%ebp
10f623: 56 push %esi
10f624: 53 push %ebx
10f625: 8b 75 08 mov 0x8(%ebp),%esi
rtems_chain_node *node = NULL;
if ( type == NULL ) {
10f628: 85 f6 test %esi,%esi
10f62a: 0f 84 94 00 00 00 je 10f6c4 <rtems_filesystem_unregister+0xa4>
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
10f630: 51 push %ecx
10f631: 6a 00 push $0x0
10f633: 6a 00 push $0x0
10f635: ff 35 88 63 12 00 pushl 0x126388
10f63b: e8 68 b5 ff ff call 10aba8 <rtems_semaphore_obtain>
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
10f640: 8b 1d bc 41 12 00 mov 0x1241bc,%ebx
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_lock();
for (
10f646: 83 c4 10 add $0x10,%esp
10f649: 81 fb c0 41 12 00 cmp $0x1241c0,%ebx
10f64f: 75 0d jne 10f65e <rtems_filesystem_unregister+0x3e>
10f651: eb 49 jmp 10f69c <rtems_filesystem_unregister+0x7c>
10f653: 90 nop
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
10f654: 8b 1b mov (%ebx),%ebx
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_lock();
for (
10f656: 81 fb c0 41 12 00 cmp $0x1241c0,%ebx
10f65c: 74 3e je 10f69c <rtems_filesystem_unregister+0x7c><== ALWAYS TAKEN
!rtems_chain_is_tail( &filesystem_chain, node );
node = rtems_chain_next( node )
) {
filesystem_node *fsn = (filesystem_node *) node;
if ( strcmp( fsn->entry.type, type ) == 0 ) {
10f65e: 83 ec 08 sub $0x8,%esp
10f661: 56 push %esi
10f662: ff 73 08 pushl 0x8(%ebx)
10f665: e8 e2 33 00 00 call 112a4c <strcmp>
10f66a: 83 c4 10 add $0x10,%esp
10f66d: 85 c0 test %eax,%eax
10f66f: 75 e3 jne 10f654 <rtems_filesystem_unregister+0x34>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10f671: 83 ec 0c sub $0xc,%esp
10f674: 53 push %ebx
10f675: e8 2e be ff ff call 10b4a8 <_Chain_Extract>
rtems_chain_extract( node );
free( fsn );
10f67a: 89 1c 24 mov %ebx,(%esp)
10f67d: e8 b2 7f ff ff call 107634 <free>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10f682: 5a pop %edx
10f683: ff 35 88 63 12 00 pushl 0x126388
10f689: e8 16 b6 ff ff call 10aca4 <rtems_semaphore_release>
10f68e: 83 c4 10 add $0x10,%esp
rtems_libio_unlock();
return 0;
10f691: 31 c0 xor %eax,%eax
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
10f693: 8d 65 f8 lea -0x8(%ebp),%esp
10f696: 5b pop %ebx
10f697: 5e pop %esi
10f698: c9 leave
10f699: c3 ret
10f69a: 66 90 xchg %ax,%ax
10f69c: 83 ec 0c sub $0xc,%esp
10f69f: ff 35 88 63 12 00 pushl 0x126388
10f6a5: e8 fa b5 ff ff call 10aca4 <rtems_semaphore_release>
return 0;
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
10f6aa: e8 2d 27 00 00 call 111ddc <__errno>
10f6af: c7 00 02 00 00 00 movl $0x2,(%eax)
10f6b5: 83 c4 10 add $0x10,%esp
10f6b8: b8 ff ff ff ff mov $0xffffffff,%eax
}
10f6bd: 8d 65 f8 lea -0x8(%ebp),%esp
10f6c0: 5b pop %ebx
10f6c1: 5e pop %esi
10f6c2: c9 leave
10f6c3: c3 ret
)
{
rtems_chain_node *node = NULL;
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
10f6c4: e8 13 27 00 00 call 111ddc <__errno>
10f6c9: c7 00 16 00 00 00 movl $0x16,(%eax)
10f6cf: 83 c8 ff or $0xffffffff,%eax
10f6d2: eb e9 jmp 10f6bd <rtems_filesystem_unregister+0x9d>
00107efc <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
107efc: 55 push %ebp
107efd: 89 e5 mov %esp,%ebp
107eff: 56 push %esi
107f00: 53 push %ebx
107f01: 8b 75 0c mov 0xc(%ebp),%esi
* pointer to the buffer that will hold the value of the key itself.
* We have to to this, because the others functions on this interface
* deal with the value of the key, as used with the POSIX API.
*/
/* Do not pull your hair, trust me this works. :-) */
__gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
107f04: 83 ec 0c sub $0xc,%esp
107f07: 6a 08 push $0x8
107f09: e8 c6 03 00 00 call 1082d4 <malloc>
107f0e: 89 c3 mov %eax,%ebx
*key = new_key;
107f10: 8b 45 08 mov 0x8(%ebp),%eax
107f13: 89 18 mov %ebx,(%eax)
new_key->val = NULL;
107f15: c7 03 00 00 00 00 movl $0x0,(%ebx)
new_key->dtor = dtor;
107f1b: 89 73 04 mov %esi,0x4(%ebx)
"gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
107f1e: 83 c4 0c add $0xc,%esp
107f21: 56 push %esi
107f22: 53 push %ebx
107f23: 6a 00 push $0x0
107f25: e8 1e 3c 00 00 call 10bb48 <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL )
107f2a: 83 c4 10 add $0x10,%esp
107f2d: 85 c0 test %eax,%eax
107f2f: 75 0b jne 107f3c <rtems_gxx_key_create+0x40><== NEVER TAKEN
return 0;
107f31: 31 c0 xor %eax,%eax
free( new_key );
return -1;
}
107f33: 8d 65 f8 lea -0x8(%ebp),%esp
107f36: 5b pop %ebx
107f37: 5e pop %esi
107f38: c9 leave
107f39: c3 ret
107f3a: 66 90 xchg %ax,%ax
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
if ( status == RTEMS_SUCCESSFUL )
return 0;
free( new_key );
107f3c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107f3f: 53 push %ebx <== NOT EXECUTED
107f40: e8 3f fe ff ff call 107d84 <free> <== NOT EXECUTED
return -1;
107f45: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107f48: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
107f4d: eb e4 jmp 107f33 <rtems_gxx_key_create+0x37><== NOT EXECUTED
00107f60 <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
107f60: 55 push %ebp
107f61: 89 e5 mov %esp,%ebp
107f63: 53 push %ebx
107f64: 83 ec 0c sub $0xc,%esp
107f67: 8b 5d 08 mov 0x8(%ebp),%ebx
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: delete key=%x\n", key );
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_delete( RTEMS_SELF, (void **)key );
107f6a: 53 push %ebx
107f6b: 6a 00 push $0x0
107f6d: e8 9a 3c 00 00 call 10bc0c <rtems_task_variable_delete>
if ( status == RTEMS_SUCCESSFUL ) {
107f72: 83 c4 10 add $0x10,%esp
107f75: 85 c0 test %eax,%eax
107f77: 75 11 jne 107f8a <rtems_gxx_key_delete+0x2a><== NEVER TAKEN
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
107f79: 85 db test %ebx,%ebx
107f7b: 74 0d je 107f8a <rtems_gxx_key_delete+0x2a><== NEVER TAKEN
107f7d: 83 ec 0c sub $0xc,%esp
107f80: ff 33 pushl (%ebx)
107f82: e8 fd fd ff ff call 107d84 <free>
107f87: 83 c4 10 add $0x10,%esp
return 0;
}
key = NULL;
return 0;
}
107f8a: 31 c0 xor %eax,%eax
107f8c: 8b 5d fc mov -0x4(%ebp),%ebx
107f8f: c9 leave
107f90: c3 ret
00107e80 <rtems_gxx_once>:
/* uncomment this if you need to debug this interface */
/*#define DEBUG_GXX_WRAPPERS 1*/
int rtems_gxx_once(__gthread_once_t *once, void (*func) (void))
{
107e80: 55 push %ebp
107e81: 89 e5 mov %esp,%ebp
107e83: 56 push %esi
107e84: 53 push %ebx
107e85: 83 ec 10 sub $0x10,%esp
107e88: 8b 5d 08 mov 0x8(%ebp),%ebx
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
107e8b: 8b 03 mov (%ebx),%eax
107e8d: 85 c0 test %eax,%eax
107e8f: 74 0b je 107e9c <rtems_gxx_once+0x1c>
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
if ( o == 0 )
(*func)();
}
return 0;
}
107e91: 31 c0 xor %eax,%eax
107e93: 8d 65 f8 lea -0x8(%ebp),%esp
107e96: 5b pop %ebx
107e97: 5e pop %esi
107e98: c9 leave
107e99: c3 ret
107e9a: 66 90 xchg %ax,%ax
if ( *(volatile __gthread_once_t *)once == 0 ) {
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
107e9c: 51 push %ecx
107e9d: 8d 75 f4 lea -0xc(%ebp),%esi
107ea0: 56 push %esi
107ea1: 68 00 01 00 00 push $0x100
107ea6: 68 00 01 00 00 push $0x100
107eab: e8 c0 3a 00 00 call 10b970 <rtems_task_mode>
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
107eb0: 8b 03 mov (%ebx),%eax
107eb2: 83 c4 10 add $0x10,%esp
107eb5: 85 c0 test %eax,%eax
107eb7: 75 27 jne 107ee0 <rtems_gxx_once+0x60> <== NEVER TAKEN
*(volatile __gthread_once_t *)once = 1;
107eb9: c7 03 01 00 00 00 movl $0x1,(%ebx)
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
107ebf: 52 push %edx
107ec0: 56 push %esi
107ec1: 68 00 01 00 00 push $0x100
107ec6: ff 75 f4 pushl -0xc(%ebp)
107ec9: e8 a2 3a 00 00 call 10b970 <rtems_task_mode>
if ( o == 0 )
(*func)();
107ece: ff 55 0c call *0xc(%ebp)
107ed1: 83 c4 10 add $0x10,%esp
}
return 0;
}
107ed4: 31 c0 xor %eax,%eax
107ed6: 8d 65 f8 lea -0x8(%ebp),%esp
107ed9: 5b pop %ebx
107eda: 5e pop %esi
107edb: c9 leave
107edc: c3 ret
107edd: 8d 76 00 lea 0x0(%esi),%esi
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
*(volatile __gthread_once_t *)once = 1;
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
107ee0: 50 push %eax <== NOT EXECUTED
107ee1: 56 push %esi <== NOT EXECUTED
107ee2: 68 00 01 00 00 push $0x100 <== NOT EXECUTED
107ee7: ff 75 f4 pushl -0xc(%ebp) <== NOT EXECUTED
107eea: e8 81 3a 00 00 call 10b970 <rtems_task_mode> <== NOT EXECUTED
107eef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if ( o == 0 )
(*func)();
}
return 0;
}
107ef2: 31 c0 xor %eax,%eax <== NOT EXECUTED
107ef4: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
107ef7: 5b pop %ebx <== NOT EXECUTED
107ef8: 5e pop %esi <== NOT EXECUTED
107ef9: c9 leave <== NOT EXECUTED
107efa: c3 ret <== NOT EXECUTED
00107ff0 <rtems_gxx_setspecific>:
#endif
return p;
}
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
107ff0: 55 push %ebp
107ff1: 89 e5 mov %esp,%ebp
107ff3: 53 push %ebx
107ff4: 83 ec 08 sub $0x8,%esp
107ff7: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_task_self()
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
107ffa: ff 73 04 pushl 0x4(%ebx)
107ffd: 53 push %ebx
107ffe: 6a 00 push $0x0
108000: e8 43 3b 00 00 call 10bb48 <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL ) {
108005: 83 c4 10 add $0x10,%esp
108008: 85 c0 test %eax,%eax
10800a: 75 0c jne 108018 <rtems_gxx_setspecific+0x28><== NEVER TAKEN
/* now let's set the proper value */
key->val = (void *)ptr;
10800c: 8b 45 0c mov 0xc(%ebp),%eax
10800f: 89 03 mov %eax,(%ebx)
return 0;
108011: 31 c0 xor %eax,%eax
}
return -1;
}
108013: 8b 5d fc mov -0x4(%ebp),%ebx
108016: c9 leave
108017: c3 ret
if ( status == RTEMS_SUCCESSFUL ) {
/* now let's set the proper value */
key->val = (void *)ptr;
return 0;
}
return -1;
108018: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
}
10801d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
108020: c9 leave <== NOT EXECUTED
108021: c3 ret <== NOT EXECUTED
0010b240 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
10b240: 55 push %ebp
10b241: 89 e5 mov %esp,%ebp
10b243: 83 ec 08 sub $0x8,%esp
if (
10b246: 83 3d 60 d7 12 00 03 cmpl $0x3,0x12d760
10b24d: 74 21 je 10b270 <rtems_heap_allocate_aligned_with_boundary+0x30><== ALWAYS TAKEN
&& !malloc_is_system_state_OK()
) {
return NULL;
}
malloc_deferred_frees_process();
10b24f: e8 b8 ef ff ff call 10a20c <malloc_deferred_frees_process>
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
10b254: ff 75 10 pushl 0x10(%ebp)
10b257: ff 75 0c pushl 0xc(%ebp)
10b25a: ff 75 08 pushl 0x8(%ebp)
10b25d: ff 35 f0 89 12 00 pushl 0x1289f0
10b263: e8 a8 4b 00 00 call 10fe10 <_Protected_heap_Allocate_aligned_with_boundary>
10b268: 83 c4 10 add $0x10,%esp
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
10b26b: c9 leave
10b26c: c3 ret
10b26d: 8d 76 00 lea 0x0(%esi),%esi
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
10b270: e8 57 ef ff ff call 10a1cc <malloc_is_system_state_OK>
10b275: 84 c0 test %al,%al
10b277: 75 d6 jne 10b24f <rtems_heap_allocate_aligned_with_boundary+0xf>
) {
return NULL;
10b279: 31 c0 xor %eax,%eax
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
10b27b: c9 leave
10b27c: c3 ret
00111ae0 <rtems_io_close>:
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
111ae0: 55 push %ebp
111ae1: 89 e5 mov %esp,%ebp
111ae3: 53 push %ebx
111ae4: 83 ec 04 sub $0x4,%esp
111ae7: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
111aea: 39 05 40 68 12 00 cmp %eax,0x126840
111af0: 76 1a jbe 111b0c <rtems_io_close+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
111af2: 8d 14 40 lea (%eax,%eax,2),%edx
111af5: c1 e2 03 shl $0x3,%edx
111af8: 03 15 44 68 12 00 add 0x126844,%edx
111afe: 8b 52 08 mov 0x8(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
111b01: 85 d2 test %edx,%edx
111b03: 74 13 je 111b18 <rtems_io_close+0x38>
}
111b05: 59 pop %ecx
111b06: 5b pop %ebx
111b07: c9 leave
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
111b08: ff e2 jmp *%edx
111b0a: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
111b0c: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].close_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
111b11: 5a pop %edx
111b12: 5b pop %ebx
111b13: c9 leave
111b14: c3 ret
111b15: 8d 76 00 lea 0x0(%esi),%esi
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
111b18: 31 c0 xor %eax,%eax
}
111b1a: 5a pop %edx
111b1b: 5b pop %ebx
111b1c: c9 leave
111b1d: c3 ret
00111b20 <rtems_io_control>:
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
111b20: 55 push %ebp
111b21: 89 e5 mov %esp,%ebp
111b23: 53 push %ebx
111b24: 83 ec 04 sub $0x4,%esp
111b27: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
111b2a: 39 05 40 68 12 00 cmp %eax,0x126840
111b30: 76 1a jbe 111b4c <rtems_io_control+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
111b32: 8d 14 40 lea (%eax,%eax,2),%edx
111b35: c1 e2 03 shl $0x3,%edx
111b38: 03 15 44 68 12 00 add 0x126844,%edx
111b3e: 8b 52 14 mov 0x14(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
111b41: 85 d2 test %edx,%edx
111b43: 74 13 je 111b58 <rtems_io_control+0x38>
}
111b45: 59 pop %ecx
111b46: 5b pop %ebx
111b47: c9 leave
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
111b48: ff e2 jmp *%edx
111b4a: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
111b4c: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].control_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
111b51: 5a pop %edx
111b52: 5b pop %ebx
111b53: c9 leave
111b54: c3 ret
111b55: 8d 76 00 lea 0x0(%esi),%esi
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
111b58: 31 c0 xor %eax,%eax
}
111b5a: 5a pop %edx
111b5b: 5b pop %ebx
111b5c: c9 leave
111b5d: c3 ret
0010fdec <rtems_io_initialize>:
rtems_status_code rtems_io_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
10fdec: 55 push %ebp
10fded: 89 e5 mov %esp,%ebp
10fdef: 53 push %ebx
10fdf0: 83 ec 04 sub $0x4,%esp
10fdf3: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
10fdf6: 39 05 40 68 12 00 cmp %eax,0x126840
10fdfc: 76 1a jbe 10fe18 <rtems_io_initialize+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].initialization_entry;
10fdfe: 8d 14 40 lea (%eax,%eax,2),%edx
10fe01: c1 e2 03 shl $0x3,%edx
10fe04: 03 15 44 68 12 00 add 0x126844,%edx
10fe0a: 8b 12 mov (%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
10fe0c: 85 d2 test %edx,%edx
10fe0e: 74 14 je 10fe24 <rtems_io_initialize+0x38>
}
10fe10: 59 pop %ecx
10fe11: 5b pop %ebx
10fe12: c9 leave
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].initialization_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
10fe13: ff e2 jmp *%edx
10fe15: 8d 76 00 lea 0x0(%esi),%esi
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
10fe18: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].initialization_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
10fe1d: 5a pop %edx
10fe1e: 5b pop %ebx
10fe1f: c9 leave
10fe20: c3 ret
10fe21: 8d 76 00 lea 0x0(%esi),%esi
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].initialization_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
10fe24: 31 c0 xor %eax,%eax
}
10fe26: 5a pop %edx
10fe27: 5b pop %ebx
10fe28: c9 leave
10fe29: c3 ret
001072e0 <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
1072e0: 55 push %ebp
1072e1: 89 e5 mov %esp,%ebp
1072e3: 57 push %edi
1072e4: 56 push %esi
1072e5: 53 push %ebx
1072e6: 83 ec 48 sub $0x48,%esp
1072e9: 8b 75 08 mov 0x8(%ebp),%esi
IMFS_jnode_t *the_jnode;
rtems_filesystem_location_info_t loc;
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path(
1072ec: b9 ff ff ff ff mov $0xffffffff,%ecx
1072f1: 89 f7 mov %esi,%edi
1072f3: 31 c0 xor %eax,%eax
1072f5: f2 ae repnz scas %es:(%edi),%al
1072f7: f7 d1 not %ecx
1072f9: 49 dec %ecx
1072fa: 6a 01 push $0x1
1072fc: 8d 5d d4 lea -0x2c(%ebp),%ebx
1072ff: 53 push %ebx
107300: 6a 00 push $0x0
107302: 51 push %ecx
107303: 56 push %esi
107304: e8 3f 02 00 00 call 107548 <rtems_filesystem_evaluate_path>
107309: 89 c7 mov %eax,%edi
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
10730b: 8b 55 d4 mov -0x2c(%ebp),%edx
10730e: 89 55 c4 mov %edx,-0x3c(%ebp)
node_type = (*loc.ops->node_type_h)( &loc );
107311: 83 c4 14 add $0x14,%esp
107314: 53 push %ebx
107315: 8b 45 e0 mov -0x20(%ebp),%eax
107318: ff 50 10 call *0x10(%eax)
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
10731b: 83 c4 10 add $0x10,%esp
10731e: 85 ff test %edi,%edi
107320: 75 05 jne 107327 <rtems_io_lookup_name+0x47><== NEVER TAKEN
107322: 83 f8 02 cmp $0x2,%eax
107325: 74 19 je 107340 <rtems_io_lookup_name+0x60>
rtems_filesystem_freenode( &loc );
107327: 83 ec 0c sub $0xc,%esp
10732a: 53 push %ebx
10732b: e8 f0 02 00 00 call 107620 <rtems_filesystem_freenode>
return RTEMS_UNSATISFIED;
107330: 83 c4 10 add $0x10,%esp
107333: b8 0d 00 00 00 mov $0xd,%eax
device_info->minor = the_jnode->info.device.minor;
rtems_filesystem_freenode( &loc );
return RTEMS_SUCCESSFUL;
}
107338: 8d 65 f4 lea -0xc(%ebp),%esp
10733b: 5b pop %ebx
10733c: 5e pop %esi
10733d: 5f pop %edi
10733e: c9 leave
10733f: c3 ret
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
rtems_filesystem_freenode( &loc );
return RTEMS_UNSATISFIED;
}
device_info->device_name = (char *) name;
107340: 8b 7d 0c mov 0xc(%ebp),%edi
107343: 89 37 mov %esi,(%edi)
device_info->device_name_length = strlen( name );
107345: b9 ff ff ff ff mov $0xffffffff,%ecx
10734a: 89 f7 mov %esi,%edi
10734c: 31 c0 xor %eax,%eax
10734e: f2 ae repnz scas %es:(%edi),%al
107350: f7 d1 not %ecx
107352: 49 dec %ecx
107353: 8b 45 0c mov 0xc(%ebp),%eax
107356: 89 48 04 mov %ecx,0x4(%eax)
device_info->major = the_jnode->info.device.major;
107359: 8b 55 c4 mov -0x3c(%ebp),%edx
10735c: 8b 42 50 mov 0x50(%edx),%eax
10735f: 8b 7d 0c mov 0xc(%ebp),%edi
107362: 89 47 08 mov %eax,0x8(%edi)
device_info->minor = the_jnode->info.device.minor;
107365: 8b 42 54 mov 0x54(%edx),%eax
107368: 89 47 0c mov %eax,0xc(%edi)
rtems_filesystem_freenode( &loc );
10736b: 83 ec 0c sub $0xc,%esp
10736e: 53 push %ebx
10736f: e8 ac 02 00 00 call 107620 <rtems_filesystem_freenode>
return RTEMS_SUCCESSFUL;
107374: 83 c4 10 add $0x10,%esp
107377: 31 c0 xor %eax,%eax
107379: eb bd jmp 107338 <rtems_io_lookup_name+0x58>
00111b60 <rtems_io_open>:
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
111b60: 55 push %ebp
111b61: 89 e5 mov %esp,%ebp
111b63: 53 push %ebx
111b64: 83 ec 04 sub $0x4,%esp
111b67: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
111b6a: 39 05 40 68 12 00 cmp %eax,0x126840
111b70: 76 1a jbe 111b8c <rtems_io_open+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
111b72: 8d 14 40 lea (%eax,%eax,2),%edx
111b75: c1 e2 03 shl $0x3,%edx
111b78: 03 15 44 68 12 00 add 0x126844,%edx
111b7e: 8b 52 04 mov 0x4(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
111b81: 85 d2 test %edx,%edx
111b83: 74 13 je 111b98 <rtems_io_open+0x38>
}
111b85: 59 pop %ecx
111b86: 5b pop %ebx
111b87: c9 leave
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
111b88: ff e2 jmp *%edx
111b8a: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
111b8c: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].open_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
111b91: 5a pop %edx
111b92: 5b pop %ebx
111b93: c9 leave
111b94: c3 ret
111b95: 8d 76 00 lea 0x0(%esi),%esi
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
111b98: 31 c0 xor %eax,%eax
}
111b9a: 5a pop %edx
111b9b: 5b pop %ebx
111b9c: c9 leave
111b9d: c3 ret
00111ba0 <rtems_io_read>:
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
111ba0: 55 push %ebp
111ba1: 89 e5 mov %esp,%ebp
111ba3: 53 push %ebx
111ba4: 83 ec 04 sub $0x4,%esp
111ba7: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
111baa: 39 05 40 68 12 00 cmp %eax,0x126840
111bb0: 76 1a jbe 111bcc <rtems_io_read+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
111bb2: 8d 14 40 lea (%eax,%eax,2),%edx
111bb5: c1 e2 03 shl $0x3,%edx
111bb8: 03 15 44 68 12 00 add 0x126844,%edx
111bbe: 8b 52 0c mov 0xc(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
111bc1: 85 d2 test %edx,%edx
111bc3: 74 13 je 111bd8 <rtems_io_read+0x38>
}
111bc5: 59 pop %ecx
111bc6: 5b pop %ebx
111bc7: c9 leave
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
111bc8: ff e2 jmp *%edx
111bca: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
111bcc: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].read_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
111bd1: 5a pop %edx
111bd2: 5b pop %ebx
111bd3: c9 leave
111bd4: c3 ret
111bd5: 8d 76 00 lea 0x0(%esi),%esi
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
111bd8: 31 c0 xor %eax,%eax
}
111bda: 5a pop %edx
111bdb: 5b pop %ebx
111bdc: c9 leave
111bdd: c3 ret
0010c3b4 <rtems_io_register_driver>:
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
10c3b4: 55 push %ebp
10c3b5: 89 e5 mov %esp,%ebp
10c3b7: 57 push %edi
10c3b8: 56 push %esi
10c3b9: 53 push %ebx
10c3ba: 83 ec 0c sub $0xc,%esp
10c3bd: 8b 5d 08 mov 0x8(%ebp),%ebx
10c3c0: 8b 75 0c mov 0xc(%ebp),%esi
10c3c3: 8b 55 10 mov 0x10(%ebp),%edx
rtems_device_major_number major_limit = _IO_Number_of_drivers;
10c3c6: a1 40 98 12 00 mov 0x129840,%eax
if ( rtems_interrupt_is_in_progress() )
10c3cb: 8b 0d 74 97 12 00 mov 0x129774,%ecx
10c3d1: 85 c9 test %ecx,%ecx
10c3d3: 0f 85 ab 00 00 00 jne 10c484 <rtems_io_register_driver+0xd0>
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
10c3d9: 85 d2 test %edx,%edx
10c3db: 0f 84 e7 00 00 00 je 10c4c8 <rtems_io_register_driver+0x114>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
10c3e1: 89 02 mov %eax,(%edx)
if ( driver_table == NULL )
10c3e3: 85 f6 test %esi,%esi
10c3e5: 0f 84 dd 00 00 00 je 10c4c8 <rtems_io_register_driver+0x114>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10c3eb: 8b 3e mov (%esi),%edi
10c3ed: 85 ff test %edi,%edi
10c3ef: 0f 84 c7 00 00 00 je 10c4bc <rtems_io_register_driver+0x108>
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
10c3f5: 39 d8 cmp %ebx,%eax
10c3f7: 76 7b jbe 10c474 <rtems_io_register_driver+0xc0>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10c3f9: a1 ec 94 12 00 mov 0x1294ec,%eax
10c3fe: 40 inc %eax
10c3ff: a3 ec 94 12 00 mov %eax,0x1294ec
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
10c404: 85 db test %ebx,%ebx
10c406: 0f 85 88 00 00 00 jne 10c494 <rtems_io_register_driver+0xe0>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
10c40c: 8b 0d 40 98 12 00 mov 0x129840,%ecx
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
10c412: 85 c9 test %ecx,%ecx
10c414: 0f 84 bb 00 00 00 je 10c4d5 <rtems_io_register_driver+0x121><== NEVER TAKEN
10c41a: 8b 3d 44 98 12 00 mov 0x129844,%edi
10c420: 89 f8 mov %edi,%eax
10c422: eb 08 jmp 10c42c <rtems_io_register_driver+0x78>
10c424: 43 inc %ebx
10c425: 83 c0 18 add $0x18,%eax
10c428: 39 d9 cmp %ebx,%ecx
10c42a: 76 0b jbe 10c437 <rtems_io_register_driver+0x83>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10c42c: 83 38 00 cmpl $0x0,(%eax)
10c42f: 75 f3 jne 10c424 <rtems_io_register_driver+0x70>
10c431: 83 78 04 00 cmpl $0x0,0x4(%eax)
10c435: 75 ed jne 10c424 <rtems_io_register_driver+0x70>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10c437: 89 1a mov %ebx,(%edx)
if ( m != n )
10c439: 39 d9 cmp %ebx,%ecx
10c43b: 0f 84 9b 00 00 00 je 10c4dc <rtems_io_register_driver+0x128>
10c441: 8d 04 5b lea (%ebx,%ebx,2),%eax
10c444: c1 e0 03 shl $0x3,%eax
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
10c447: 01 c7 add %eax,%edi
10c449: b9 06 00 00 00 mov $0x6,%ecx
10c44e: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Thread_Enable_dispatch();
10c450: e8 4b 1b 00 00 call 10dfa0 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
10c455: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp)
10c45c: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp)
10c463: 89 5d 08 mov %ebx,0x8(%ebp)
}
10c466: 83 c4 0c add $0xc,%esp
10c469: 5b pop %ebx
10c46a: 5e pop %esi
10c46b: 5f pop %edi
10c46c: c9 leave
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
10c46d: e9 b6 76 00 00 jmp 113b28 <rtems_io_initialize>
10c472: 66 90 xchg %ax,%ax
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
10c474: b8 0a 00 00 00 mov $0xa,%eax
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
10c479: 83 c4 0c add $0xc,%esp
10c47c: 5b pop %ebx
10c47d: 5e pop %esi
10c47e: 5f pop %edi
10c47f: c9 leave
10c480: c3 ret
10c481: 8d 76 00 lea 0x0(%esi),%esi
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
10c484: b8 12 00 00 00 mov $0x12,%eax
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
10c489: 83 c4 0c add $0xc,%esp
10c48c: 5b pop %ebx
10c48d: 5e pop %esi
10c48e: 5f pop %edi
10c48f: c9 leave
10c490: c3 ret
10c491: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
10c494: 8d 04 5b lea (%ebx,%ebx,2),%eax
10c497: c1 e0 03 shl $0x3,%eax
10c49a: 8b 0d 44 98 12 00 mov 0x129844,%ecx
10c4a0: 01 c1 add %eax,%ecx
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10c4a2: 8b 39 mov (%ecx),%edi
10c4a4: 85 ff test %edi,%edi
10c4a6: 74 40 je 10c4e8 <rtems_io_register_driver+0x134>
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
10c4a8: e8 f3 1a 00 00 call 10dfa0 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
10c4ad: b8 0c 00 00 00 mov $0xc,%eax
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
10c4b2: 83 c4 0c add $0xc,%esp
10c4b5: 5b pop %ebx
10c4b6: 5e pop %esi
10c4b7: 5f pop %edi
10c4b8: c9 leave
10c4b9: c3 ret
10c4ba: 66 90 xchg %ax,%ax
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10c4bc: 8b 4e 04 mov 0x4(%esi),%ecx
10c4bf: 85 c9 test %ecx,%ecx
10c4c1: 0f 85 2e ff ff ff jne 10c3f5 <rtems_io_register_driver+0x41>
10c4c7: 90 nop
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
10c4c8: b8 09 00 00 00 mov $0x9,%eax
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
10c4cd: 83 c4 0c add $0xc,%esp
10c4d0: 5b pop %ebx
10c4d1: 5e pop %esi
10c4d2: 5f pop %edi
10c4d3: c9 leave
10c4d4: c3 ret
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10c4d5: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED
10c4db: 90 nop <== NOT EXECUTED
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
10c4dc: e8 bf 1a 00 00 call 10dfa0 <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
10c4e1: b8 05 00 00 00 mov $0x5,%eax
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
return sc;
10c4e6: eb 91 jmp 10c479 <rtems_io_register_driver+0xc5>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10c4e8: 8b 49 04 mov 0x4(%ecx),%ecx
10c4eb: 85 c9 test %ecx,%ecx
10c4ed: 75 b9 jne 10c4a8 <rtems_io_register_driver+0xf4>
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
10c4ef: 89 1a mov %ebx,(%edx)
10c4f1: 8b 3d 44 98 12 00 mov 0x129844,%edi
10c4f7: e9 4b ff ff ff jmp 10c447 <rtems_io_register_driver+0x93>
0010c4fc <rtems_io_unregister_driver>:
*/
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
10c4fc: 55 push %ebp
10c4fd: 89 e5 mov %esp,%ebp
10c4ff: 57 push %edi
10c500: 83 ec 04 sub $0x4,%esp
10c503: 8b 45 08 mov 0x8(%ebp),%eax
if ( rtems_interrupt_is_in_progress() )
10c506: 8b 0d 74 97 12 00 mov 0x129774,%ecx
10c50c: 85 c9 test %ecx,%ecx
10c50e: 75 44 jne 10c554 <rtems_io_unregister_driver+0x58>
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
10c510: 39 05 40 98 12 00 cmp %eax,0x129840
10c516: 77 0c ja 10c524 <rtems_io_unregister_driver+0x28>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
10c518: b8 0d 00 00 00 mov $0xd,%eax
}
10c51d: 5a pop %edx
10c51e: 5f pop %edi
10c51f: c9 leave
10c520: c3 ret
10c521: 8d 76 00 lea 0x0(%esi),%esi
10c524: 8b 15 ec 94 12 00 mov 0x1294ec,%edx
10c52a: 42 inc %edx
10c52b: 89 15 ec 94 12 00 mov %edx,0x1294ec
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
_Thread_Disable_dispatch();
memset(
&_IO_Driver_address_table[major],
10c531: 8d 14 40 lea (%eax,%eax,2),%edx
10c534: c1 e2 03 shl $0x3,%edx
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
_Thread_Disable_dispatch();
memset(
10c537: 03 15 44 98 12 00 add 0x129844,%edx
10c53d: b9 18 00 00 00 mov $0x18,%ecx
10c542: 31 c0 xor %eax,%eax
10c544: 89 d7 mov %edx,%edi
10c546: f3 aa rep stos %al,%es:(%edi)
&_IO_Driver_address_table[major],
0,
sizeof( rtems_driver_address_table )
);
_Thread_Enable_dispatch();
10c548: e8 53 1a 00 00 call 10dfa0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c54d: 31 c0 xor %eax,%eax
}
return RTEMS_UNSATISFIED;
}
10c54f: 5a pop %edx
10c550: 5f pop %edi
10c551: c9 leave
10c552: c3 ret
10c553: 90 nop
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
10c554: b8 12 00 00 00 mov $0x12,%eax
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
}
10c559: 5a pop %edx
10c55a: 5f pop %edi
10c55b: c9 leave
10c55c: c3 ret
00111be0 <rtems_io_write>:
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
111be0: 55 push %ebp
111be1: 89 e5 mov %esp,%ebp
111be3: 53 push %ebx
111be4: 83 ec 04 sub $0x4,%esp
111be7: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
111bea: 39 05 40 68 12 00 cmp %eax,0x126840
111bf0: 76 1a jbe 111c0c <rtems_io_write+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
111bf2: 8d 14 40 lea (%eax,%eax,2),%edx
111bf5: c1 e2 03 shl $0x3,%edx
111bf8: 03 15 44 68 12 00 add 0x126844,%edx
111bfe: 8b 52 10 mov 0x10(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
111c01: 85 d2 test %edx,%edx
111c03: 74 13 je 111c18 <rtems_io_write+0x38>
}
111c05: 59 pop %ecx
111c06: 5b pop %ebx
111c07: c9 leave
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
111c08: ff e2 jmp *%edx
111c0a: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
111c0c: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].write_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
111c11: 5a pop %edx
111c12: 5b pop %ebx
111c13: c9 leave
111c14: c3 ret
111c15: 8d 76 00 lea 0x0(%esi),%esi
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
111c18: 31 c0 xor %eax,%eax
}
111c1a: 5a pop %edx
111c1b: 5b pop %ebx
111c1c: c9 leave
111c1d: c3 ret
0010d358 <rtems_iterate_over_all_threads>:
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
{
10d358: 55 push %ebp
10d359: 89 e5 mov %esp,%ebp
10d35b: 57 push %edi
10d35c: 56 push %esi
10d35d: 53 push %ebx
10d35e: 83 ec 1c sub $0x1c,%esp
10d361: 8b 7d 08 mov 0x8(%ebp),%edi
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
10d364: 85 ff test %edi,%edi
10d366: 74 4d je 10d3b5 <rtems_iterate_over_all_threads+0x5d><== NEVER TAKEN
10d368: c7 45 e4 01 00 00 00 movl $0x1,-0x1c(%ebp)
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
10d36f: 8b 55 e4 mov -0x1c(%ebp),%edx
10d372: 8b 04 95 a4 98 12 00 mov 0x1298a4(,%edx,4),%eax
10d379: 85 c0 test %eax,%eax
10d37b: 74 2f je 10d3ac <rtems_iterate_over_all_threads+0x54>
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
10d37d: 8b 70 04 mov 0x4(%eax),%esi
if ( !information )
10d380: 85 f6 test %esi,%esi
10d382: 74 28 je 10d3ac <rtems_iterate_over_all_threads+0x54>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10d384: 66 83 7e 10 00 cmpw $0x0,0x10(%esi)
10d389: 74 21 je 10d3ac <rtems_iterate_over_all_threads+0x54><== NEVER TAKEN
10d38b: bb 01 00 00 00 mov $0x1,%ebx
the_thread = (Thread_Control *)information->local_table[ i ];
10d390: 8b 46 1c mov 0x1c(%esi),%eax
10d393: 8b 04 98 mov (%eax,%ebx,4),%eax
if ( !the_thread )
10d396: 85 c0 test %eax,%eax
10d398: 74 09 je 10d3a3 <rtems_iterate_over_all_threads+0x4b><== NEVER TAKEN
continue;
(*routine)(the_thread);
10d39a: 83 ec 0c sub $0xc,%esp
10d39d: 50 push %eax
10d39e: ff d7 call *%edi
10d3a0: 83 c4 10 add $0x10,%esp
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10d3a3: 43 inc %ebx
10d3a4: 0f b7 46 10 movzwl 0x10(%esi),%eax
10d3a8: 39 d8 cmp %ebx,%eax
10d3aa: 73 e4 jae 10d390 <rtems_iterate_over_all_threads+0x38>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
10d3ac: ff 45 e4 incl -0x1c(%ebp)
10d3af: 83 7d e4 04 cmpl $0x4,-0x1c(%ebp)
10d3b3: 75 ba jne 10d36f <rtems_iterate_over_all_threads+0x17>
(*routine)(the_thread);
}
}
}
10d3b5: 8d 65 f4 lea -0xc(%ebp),%esp
10d3b8: 5b pop %ebx
10d3b9: 5e pop %esi
10d3ba: 5f pop %edi
10d3bb: c9 leave
10d3bc: c3 ret
0010f318 <rtems_libio_free>:
*/
void rtems_libio_free(
rtems_libio_t *iop
)
{
10f318: 55 push %ebp
10f319: 89 e5 mov %esp,%ebp
10f31b: 53 push %ebx
10f31c: 83 ec 08 sub $0x8,%esp
10f31f: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
10f322: 6a 00 push $0x0
10f324: 6a 00 push $0x0
10f326: ff 35 88 63 12 00 pushl 0x126388
10f32c: e8 77 b8 ff ff call 10aba8 <rtems_semaphore_obtain>
rtems_libio_lock();
if (iop->sem)
10f331: 8b 43 2c mov 0x2c(%ebx),%eax
10f334: 83 c4 10 add $0x10,%esp
10f337: 85 c0 test %eax,%eax
10f339: 74 0c je 10f347 <rtems_libio_free+0x2f> <== NEVER TAKEN
rtems_semaphore_delete(iop->sem);
10f33b: 83 ec 0c sub $0xc,%esp
10f33e: 50 push %eax
10f33f: e8 c0 b7 ff ff call 10ab04 <rtems_semaphore_delete>
10f344: 83 c4 10 add $0x10,%esp
iop->flags &= ~LIBIO_FLAGS_OPEN;
10f347: 81 63 14 ff fe ff ff andl $0xfffffeff,0x14(%ebx)
iop->data1 = rtems_libio_iop_freelist;
10f34e: a1 84 63 12 00 mov 0x126384,%eax
10f353: 89 43 34 mov %eax,0x34(%ebx)
rtems_libio_iop_freelist = iop;
10f356: 89 1d 84 63 12 00 mov %ebx,0x126384
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10f35c: a1 88 63 12 00 mov 0x126388,%eax
10f361: 89 45 08 mov %eax,0x8(%ebp)
rtems_libio_unlock();
}
10f364: 8b 5d fc mov -0x4(%ebp),%ebx
10f367: c9 leave
10f368: e9 37 b9 ff ff jmp 10aca4 <rtems_semaphore_release>
00107730 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
107730: 55 push %ebp
107731: 89 e5 mov %esp,%ebp
107733: 53 push %ebx
107734: 83 ec 04 sub $0x4,%esp
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
107737: 8b 1d ec 21 12 00 mov 0x1221ec,%ebx
10773d: 85 db test %ebx,%ebx
10773f: 74 50 je 107791 <rtems_libio_init+0x61> <== NEVER TAKEN
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
107741: 83 ec 08 sub $0x8,%esp
107744: 6a 38 push $0x38
107746: 53 push %ebx
107747: e8 58 fd ff ff call 1074a4 <calloc>
10774c: 89 c2 mov %eax,%edx
10774e: a3 80 63 12 00 mov %eax,0x126380
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
107753: 83 c4 10 add $0x10,%esp
107756: 85 c0 test %eax,%eax
107758: 74 74 je 1077ce <rtems_libio_init+0x9e>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
10775a: a3 84 63 12 00 mov %eax,0x126384
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
10775f: 83 fb 01 cmp $0x1,%ebx
107762: 76 26 jbe 10778a <rtems_libio_init+0x5a> <== NEVER TAKEN
* rtems_libio_init
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
107764: 8d 50 38 lea 0x38(%eax),%edx
107767: b9 01 00 00 00 mov $0x1,%ecx
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
iop->data1 = iop + 1;
10776c: 89 52 fc mov %edx,-0x4(%edx)
10776f: 41 inc %ecx
107770: 83 c2 38 add $0x38,%edx
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
107773: 39 d9 cmp %ebx,%ecx
107775: 75 f5 jne 10776c <rtems_libio_init+0x3c>
* rtems_libio_init
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
107777: 8d 0c cd f8 ff ff ff lea -0x8(,%ecx,8),%ecx
10777e: 8d 14 cd 00 00 00 00 lea 0x0(,%ecx,8),%edx
107785: 29 ca sub %ecx,%edx
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
107787: 8d 14 10 lea (%eax,%edx,1),%edx
iop->data1 = iop + 1;
iop->data1 = NULL;
10778a: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
107791: 83 ec 0c sub $0xc,%esp
107794: 68 88 63 12 00 push $0x126388
107799: 6a 00 push $0x0
10779b: 6a 54 push $0x54
10779d: 6a 01 push $0x1
10779f: 68 4f 49 42 4c push $0x4c42494f
1077a4: e8 83 31 00 00 call 10a92c <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
1077a9: 83 c4 20 add $0x20,%esp
1077ac: 85 c0 test %eax,%eax
1077ae: 75 15 jne 1077c5 <rtems_libio_init+0x95> <== NEVER TAKEN
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
1077b0: a1 e8 21 12 00 mov 0x1221e8,%eax
1077b5: 85 c0 test %eax,%eax
1077b7: 74 07 je 1077c0 <rtems_libio_init+0x90> <== NEVER TAKEN
(* rtems_fs_init_helper)();
}
1077b9: 8b 5d fc mov -0x4(%ebp),%ebx
1077bc: c9 leave
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
(* rtems_fs_init_helper)();
1077bd: ff e0 jmp *%eax
1077bf: 90 nop
}
1077c0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
1077c3: c9 leave <== NOT EXECUTED
1077c4: c3 ret <== NOT EXECUTED
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
rtems_fatal_error_occurred( rc );
1077c5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1077c8: 50 push %eax <== NOT EXECUTED
1077c9: e8 1a 3a 00 00 call 10b1e8 <rtems_fatal_error_occurred><== NOT EXECUTED
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
1077ce: 83 ec 0c sub $0xc,%esp
1077d1: 6a 1a push $0x1a
1077d3: e8 10 3a 00 00 call 10b1e8 <rtems_fatal_error_occurred>
0010f3d4 <rtems_libio_is_file_open>:
*/
int rtems_libio_is_file_open(
void *node_access
)
{
10f3d4: 55 push %ebp
10f3d5: 89 e5 mov %esp,%ebp
10f3d7: 53 push %ebx
10f3d8: 83 ec 08 sub $0x8,%esp
10f3db: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
10f3de: 6a 00 push $0x0
10f3e0: 6a 00 push $0x0
10f3e2: ff 35 88 63 12 00 pushl 0x126388
10f3e8: e8 bb b7 ff ff call 10aba8 <rtems_semaphore_obtain>
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
10f3ed: a1 80 63 12 00 mov 0x126380,%eax
10f3f2: 8b 0d ec 21 12 00 mov 0x1221ec,%ecx
10f3f8: 83 c4 10 add $0x10,%esp
10f3fb: 85 c9 test %ecx,%ecx
10f3fd: 74 18 je 10f417 <rtems_libio_is_file_open+0x43><== NEVER TAKEN
10f3ff: 31 d2 xor %edx,%edx
10f401: eb 04 jmp 10f407 <rtems_libio_is_file_open+0x33>
10f403: 90 nop
10f404: 83 c0 38 add $0x38,%eax
if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {
10f407: f6 40 15 01 testb $0x1,0x15(%eax)
10f40b: 74 05 je 10f412 <rtems_libio_is_file_open+0x3e>
/*
* Check if this node is under the file system that we
* are trying to dismount.
*/
if ( iop->pathinfo.node_access == node_access ) {
10f40d: 39 58 18 cmp %ebx,0x18(%eax)
10f410: 74 1e je 10f430 <rtems_libio_is_file_open+0x5c>
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
10f412: 42 inc %edx
10f413: 39 ca cmp %ecx,%edx
10f415: 72 ed jb 10f404 <rtems_libio_is_file_open+0x30>
int rtems_libio_is_file_open(
void *node_access
)
{
rtems_libio_t *iop;
int result=0;
10f417: 31 db xor %ebx,%ebx
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10f419: 83 ec 0c sub $0xc,%esp
10f41c: ff 35 88 63 12 00 pushl 0x126388
10f422: e8 7d b8 ff ff call 10aca4 <rtems_semaphore_release>
}
rtems_libio_unlock();
return result;
}
10f427: 89 d8 mov %ebx,%eax
10f429: 8b 5d fc mov -0x4(%ebp),%ebx
10f42c: c9 leave
10f42d: c3 ret
10f42e: 66 90 xchg %ax,%ax
* Check if this node is under the file system that we
* are trying to dismount.
*/
if ( iop->pathinfo.node_access == node_access ) {
result = 1;
10f430: bb 01 00 00 00 mov $0x1,%ebx
10f435: eb e2 jmp 10f419 <rtems_libio_is_file_open+0x45>
0010f370 <rtems_libio_is_open_files_in_fs>:
*/
int rtems_libio_is_open_files_in_fs(
rtems_filesystem_mount_table_entry_t * fs_mt_entry
)
{
10f370: 55 push %ebp
10f371: 89 e5 mov %esp,%ebp
10f373: 53 push %ebx
10f374: 83 ec 08 sub $0x8,%esp
10f377: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
10f37a: 6a 00 push $0x0
10f37c: 6a 00 push $0x0
10f37e: ff 35 88 63 12 00 pushl 0x126388
10f384: e8 1f b8 ff ff call 10aba8 <rtems_semaphore_obtain>
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
10f389: a1 80 63 12 00 mov 0x126380,%eax
10f38e: 8b 0d ec 21 12 00 mov 0x1221ec,%ecx
10f394: 83 c4 10 add $0x10,%esp
10f397: 85 c9 test %ecx,%ecx
10f399: 74 18 je 10f3b3 <rtems_libio_is_open_files_in_fs+0x43><== NEVER TAKEN
10f39b: 31 d2 xor %edx,%edx
10f39d: eb 04 jmp 10f3a3 <rtems_libio_is_open_files_in_fs+0x33>
10f39f: 90 nop
10f3a0: 83 c0 38 add $0x38,%eax
if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {
10f3a3: f6 40 15 01 testb $0x1,0x15(%eax)
10f3a7: 74 05 je 10f3ae <rtems_libio_is_open_files_in_fs+0x3e>
/*
* Check if this node is under the file system that we
* are trying to dismount.
*/
if ( iop->pathinfo.mt_entry == fs_mt_entry ) {
10f3a9: 39 58 28 cmp %ebx,0x28(%eax)
10f3ac: 74 1e je 10f3cc <rtems_libio_is_open_files_in_fs+0x5c>
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
10f3ae: 42 inc %edx
10f3af: 39 ca cmp %ecx,%edx
10f3b1: 72 ed jb 10f3a0 <rtems_libio_is_open_files_in_fs+0x30>
int rtems_libio_is_open_files_in_fs(
rtems_filesystem_mount_table_entry_t * fs_mt_entry
)
{
rtems_libio_t *iop;
int result = 0;
10f3b3: 31 db xor %ebx,%ebx
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10f3b5: 83 ec 0c sub $0xc,%esp
10f3b8: ff 35 88 63 12 00 pushl 0x126388
10f3be: e8 e1 b8 ff ff call 10aca4 <rtems_semaphore_release>
}
rtems_libio_unlock();
return result;
}
10f3c3: 89 d8 mov %ebx,%eax
10f3c5: 8b 5d fc mov -0x4(%ebp),%ebx
10f3c8: c9 leave
10f3c9: c3 ret
10f3ca: 66 90 xchg %ax,%ax
* Check if this node is under the file system that we
* are trying to dismount.
*/
if ( iop->pathinfo.mt_entry == fs_mt_entry ) {
result = 1;
10f3cc: bb 01 00 00 00 mov $0x1,%ebx
10f3d1: eb e2 jmp 10f3b5 <rtems_libio_is_open_files_in_fs+0x45>
00108b38 <rtems_libio_set_private_env>:
rtems_status_code rtems_libio_set_private_env(void)
{
108b38: 55 push %ebp
108b39: 89 e5 mov %esp,%ebp
108b3b: 57 push %edi
108b3c: 56 push %esi
108b3d: 53 push %ebx
108b3e: 83 ec 5c sub $0x5c,%esp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id task_id = rtems_task_self();
108b41: e8 5e 2d 00 00 call 10b8a4 <rtems_task_self>
108b46: 89 45 b4 mov %eax,-0x4c(%ebp)
rtems_filesystem_location_info_t root_loc;
rtems_filesystem_location_info_t current_loc;
rtems_user_env_t *new_env = NULL;
int rv = 0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);
108b49: 83 ec 0c sub $0xc,%esp
108b4c: 6a 00 push $0x0
108b4e: 8d 5d d4 lea -0x2c(%ebp),%ebx
108b51: 53 push %ebx
108b52: 6a 00 push $0x0
108b54: 6a 01 push $0x1
108b56: 68 27 06 12 00 push $0x120627
108b5b: e8 28 ee ff ff call 107988 <rtems_filesystem_evaluate_path>
if (rv != 0)
108b60: 83 c4 20 add $0x20,%esp
108b63: 85 c0 test %eax,%eax
108b65: 74 0d je 108b74 <rtems_libio_set_private_env+0x3c><== ALWAYS TAKEN
error_1:
rtems_filesystem_freenode(&root_loc);
error_0:
return RTEMS_NO_MEMORY;
108b67: b8 1a 00 00 00 mov $0x1a,%eax <== NOT EXECUTED
}
108b6c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
108b6f: 5b pop %ebx <== NOT EXECUTED
108b70: 5e pop %esi <== NOT EXECUTED
108b71: 5f pop %edi <== NOT EXECUTED
108b72: c9 leave <== NOT EXECUTED
108b73: c3 ret <== NOT EXECUTED
rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);
if (rv != 0)
goto error_0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, ¤t_loc, 0);
108b74: 83 ec 0c sub $0xc,%esp
108b77: 6a 00 push $0x0
108b79: 8d 45 c0 lea -0x40(%ebp),%eax
108b7c: 89 45 a4 mov %eax,-0x5c(%ebp)
108b7f: 50 push %eax
108b80: 6a 00 push $0x0
108b82: 6a 01 push $0x1
108b84: 68 27 06 12 00 push $0x120627
108b89: e8 fa ed ff ff call 107988 <rtems_filesystem_evaluate_path>
if (rv != 0)
108b8e: 83 c4 20 add $0x20,%esp
108b91: 85 c0 test %eax,%eax
108b93: 0f 85 9a 00 00 00 jne 108c33 <rtems_libio_set_private_env+0xfb><== NEVER TAKEN
* Bharath: I'm not sure if the check can be reduced to
* if( rtems_current_user_env->task_id != task_id ) {
*/
if (
rtems_current_user_env == &rtems_global_user_env
108b99: 8b 15 10 41 12 00 mov 0x124110,%edx
/*
* Bharath: I'm not sure if the check can be reduced to
* if( rtems_current_user_env->task_id != task_id ) {
*/
if (
108b9f: 81 fa 40 63 12 00 cmp $0x126340,%edx
108ba5: 74 07 je 108bae <rtems_libio_set_private_env+0x76>
rtems_current_user_env == &rtems_global_user_env
|| rtems_current_user_env->task_id != task_id
108ba7: 8b 45 b4 mov -0x4c(%ebp),%eax
108baa: 39 02 cmp %eax,(%edx)
108bac: 74 3a je 108be8 <rtems_libio_set_private_env+0xb0>
) {
new_env = malloc(sizeof(rtems_user_env_t));
108bae: 83 ec 0c sub $0xc,%esp
108bb1: 6a 48 push $0x48
108bb3: e8 ec f3 ff ff call 107fa4 <malloc>
108bb8: 89 c2 mov %eax,%edx
108bba: 89 c6 mov %eax,%esi
if (new_env == NULL)
108bbc: 83 c4 10 add $0x10,%esp
108bbf: 85 c0 test %eax,%eax
108bc1: 74 61 je 108c24 <rtems_libio_set_private_env+0xec>
#ifdef HAVE_USERENV_REFCNT
new_env->refcnt = 1;
#endif
sc = rtems_task_variable_add(
108bc3: 50 push %eax
108bc4: 68 f8 8a 10 00 push $0x108af8
108bc9: 68 10 41 12 00 push $0x124110
108bce: 6a 00 push $0x0
108bd0: 89 55 b0 mov %edx,-0x50(%ebp)
108bd3: e8 50 2d 00 00 call 10b928 <rtems_task_variable_add>
RTEMS_SELF,
(void*)&rtems_current_user_env,
(void(*)(void *))free_user_env
);
if (sc != RTEMS_SUCCESSFUL)
108bd8: 83 c4 10 add $0x10,%esp
108bdb: 85 c0 test %eax,%eax
108bdd: 8b 55 b0 mov -0x50(%ebp),%edx
108be0: 75 36 jne 108c18 <rtems_libio_set_private_env+0xe0>
goto error_3;
rtems_current_user_env = new_env;
108be2: 89 15 10 41 12 00 mov %edx,0x124110
}
/* Inherit the global values */
*rtems_current_user_env = rtems_global_user_env;
108be8: be 40 63 12 00 mov $0x126340,%esi
108bed: b9 12 00 00 00 mov $0x12,%ecx
108bf2: 89 d7 mov %edx,%edi
108bf4: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rtems_current_user_env->task_id = task_id;
108bf6: 8b 75 b4 mov -0x4c(%ebp),%esi
108bf9: 89 32 mov %esi,(%edx)
* Clone the pathlocs. In contrast to most other code we must _not_ free the
* original locs because what we are trying to do here is forking off clones.
* The reason is a pathloc can be allocated by the file system and needs to
* be freed when deleting the environment.
*/
rtems_filesystem_root = root_loc;
108bfb: 8d 7a 18 lea 0x18(%edx),%edi
108bfe: b1 05 mov $0x5,%cl
108c00: 89 de mov %ebx,%esi
108c02: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rtems_filesystem_current = current_loc;
108c04: 8d 7a 04 lea 0x4(%edx),%edi
108c07: b1 05 mov $0x5,%cl
108c09: 8b 75 a4 mov -0x5c(%ebp),%esi
108c0c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return RTEMS_SUCCESSFUL;
108c0e: 31 c0 xor %eax,%eax
error_1:
rtems_filesystem_freenode(&root_loc);
error_0:
return RTEMS_NO_MEMORY;
}
108c10: 8d 65 f4 lea -0xc(%ebp),%esp
108c13: 5b pop %ebx
108c14: 5e pop %esi
108c15: 5f pop %edi
108c16: c9 leave
108c17: c3 ret
rtems_filesystem_current = current_loc;
return RTEMS_SUCCESSFUL;
error_3:
free(new_env);
108c18: 83 ec 0c sub $0xc,%esp
108c1b: 56 push %esi
108c1c: e8 53 ee ff ff call 107a74 <free>
108c21: 83 c4 10 add $0x10,%esp
error_2:
rtems_filesystem_freenode(¤t_loc);
108c24: 83 ec 0c sub $0xc,%esp
108c27: 8d 45 c0 lea -0x40(%ebp),%eax
108c2a: 50 push %eax
108c2b: e8 30 ee ff ff call 107a60 <rtems_filesystem_freenode>
108c30: 83 c4 10 add $0x10,%esp
error_1:
rtems_filesystem_freenode(&root_loc);
108c33: 83 ec 0c sub $0xc,%esp
108c36: 53 push %ebx
108c37: e8 24 ee ff ff call 107a60 <rtems_filesystem_freenode>
108c3c: 83 c4 10 add $0x10,%esp
error_0:
return RTEMS_NO_MEMORY;
108c3f: b8 1a 00 00 00 mov $0x1a,%eax
}
108c44: 8d 65 f4 lea -0xc(%ebp),%esp
108c47: 5b pop %ebx
108c48: 5e pop %esi
108c49: 5f pop %edi
108c4a: c9 leave
108c4b: c3 ret
00108c4c <rtems_libio_share_private_env>:
* b) mutex access to rtems_filesystem_current, rtems_filesytem_root
* while changing any of those (chdir(), chroot()).
*/
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
108c4c: 55 push %ebp
108c4d: 89 e5 mov %esp,%ebp
108c4f: 56 push %esi
108c50: 53 push %ebx
108c51: 83 ec 20 sub $0x20,%esp
108c54: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
108c57: e8 48 2c 00 00 call 10b8a4 <rtems_task_self>
108c5c: 89 c6 mov %eax,%esi
/*
* If this was an attempt to share the task with self,
* if somebody wanted to do it... Lets tell them, its shared
*/
if( task_id == current_task_id )
108c5e: 39 c3 cmp %eax,%ebx
108c60: 74 32 je 108c94 <rtems_libio_share_private_env+0x48><== NEVER TAKEN
return RTEMS_SUCCESSFUL;
/*
* Try to get the requested user environment
*/
sc = rtems_task_variable_get(
108c62: 52 push %edx
task_id,
(void*)&rtems_current_user_env,
(void*)&shared_user_env );
108c63: 8d 45 f4 lea -0xc(%ebp),%eax
if( task_id == current_task_id )
return RTEMS_SUCCESSFUL;
/*
* Try to get the requested user environment
*/
sc = rtems_task_variable_get(
108c66: 50 push %eax
108c67: 68 10 41 12 00 push $0x124110
108c6c: 53 push %ebx
108c6d: e8 7a 2d 00 00 call 10b9ec <rtems_task_variable_get>
(void*)&shared_user_env );
/*
* If it was not successful, return the error code
*/
if (sc != RTEMS_SUCCESSFUL)
108c72: 83 c4 10 add $0x10,%esp
108c75: 85 c0 test %eax,%eax
108c77: 75 13 jne 108c8c <rtems_libio_share_private_env+0x40>
* If we have a current environment in place, we need to
* free it, since we will be sharing the variable with the
* shared_user_env
*/
if (rtems_current_user_env->task_id==current_task_id) {
108c79: 8b 15 10 41 12 00 mov 0x124110,%edx
108c7f: 39 32 cmp %esi,(%edx)
108c81: 74 1d je 108ca0 <rtems_libio_share_private_env+0x54>
rtems_user_env_t *tmp = rtems_current_user_env;
free_user_env( tmp );
}
/* the current_user_env is the same pointer that remote env */
rtems_current_user_env = shared_user_env;
108c83: 8b 55 f4 mov -0xc(%ebp),%edx
108c86: 89 15 10 41 12 00 mov %edx,0x124110
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
}
108c8c: 8d 65 f8 lea -0x8(%ebp),%esp
108c8f: 5b pop %ebx
108c90: 5e pop %esi
108c91: c9 leave
108c92: c3 ret
108c93: 90 nop
* If this was an attempt to share the task with self,
* if somebody wanted to do it... Lets tell them, its shared
*/
if( task_id == current_task_id )
return RTEMS_SUCCESSFUL;
108c94: 31 c0 xor %eax,%eax
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
}
108c96: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
108c99: 5b pop %ebx <== NOT EXECUTED
108c9a: 5e pop %esi <== NOT EXECUTED
108c9b: c9 leave <== NOT EXECUTED
108c9c: c3 ret <== NOT EXECUTED
108c9d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
* shared_user_env
*/
if (rtems_current_user_env->task_id==current_task_id) {
rtems_user_env_t *tmp = rtems_current_user_env;
free_user_env( tmp );
108ca0: 83 ec 0c sub $0xc,%esp
108ca3: 52 push %edx
108ca4: 89 45 e4 mov %eax,-0x1c(%ebp)
108ca7: e8 4c fe ff ff call 108af8 <free_user_env>
108cac: 83 c4 10 add $0x10,%esp
108caf: 8b 45 e4 mov -0x1c(%ebp),%eax
108cb2: eb cf jmp 108c83 <rtems_libio_share_private_env+0x37>
0010f230 <rtems_libio_to_fcntl_flags>:
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
10f230: 55 push %ebp
10f231: 89 e5 mov %esp,%ebp
10f233: 8b 55 08 mov 0x8(%ebp),%edx
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
10f236: 89 d0 mov %edx,%eax
10f238: 83 e0 06 and $0x6,%eax
10f23b: 83 f8 06 cmp $0x6,%eax
10f23e: 74 2c je 10f26c <rtems_libio_to_fcntl_flags+0x3c><== NEVER TAKEN
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
10f240: f6 c2 02 test $0x2,%dl
10f243: 75 23 jne 10f268 <rtems_libio_to_fcntl_flags+0x38><== ALWAYS TAKEN
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
10f245: 31 c0 xor %eax,%eax
10f247: f6 c2 04 test $0x4,%dl <== NOT EXECUTED
10f24a: 0f 95 c0 setne %al <== NOT EXECUTED
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
10f24d: f6 c2 01 test $0x1,%dl
10f250: 74 03 je 10f255 <rtems_libio_to_fcntl_flags+0x25>
fcntl_flags |= O_NONBLOCK;
10f252: 80 cc 40 or $0x40,%ah
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
10f255: f6 c6 02 test $0x2,%dh
10f258: 74 03 je 10f25d <rtems_libio_to_fcntl_flags+0x2d>
fcntl_flags |= O_APPEND;
10f25a: 83 c8 08 or $0x8,%eax
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
10f25d: 80 e6 04 and $0x4,%dh
10f260: 74 03 je 10f265 <rtems_libio_to_fcntl_flags+0x35>
fcntl_flags |= O_CREAT;
10f262: 80 cc 02 or $0x2,%ah
}
return fcntl_flags;
}
10f265: c9 leave
10f266: c3 ret
10f267: 90 nop
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
fcntl_flags |= O_RDONLY;
10f268: 31 c0 xor %eax,%eax
10f26a: eb e1 jmp 10f24d <rtems_libio_to_fcntl_flags+0x1d>
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
10f26c: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED
10f271: eb da jmp 10f24d <rtems_libio_to_fcntl_flags+0x1d><== NOT EXECUTED
0010a4f0 <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
10a4f0: 55 push %ebp
10a4f1: 89 e5 mov %esp,%ebp
10a4f3: 83 ec 1c sub $0x1c,%esp
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
10a4f6: 8d 45 f4 lea -0xc(%ebp),%eax
10a4f9: 50 push %eax
10a4fa: ff 75 08 pushl 0x8(%ebp)
10a4fd: ff 35 f0 89 12 00 pushl 0x1289f0
10a503: e8 b0 59 00 00 call 10feb8 <_Protected_heap_Get_block_size>
10a508: 83 c4 10 add $0x10,%esp
10a50b: 84 c0 test %al,%al
10a50d: 74 11 je 10a520 <rtems_malloc_statistics_at_free+0x30><== NEVER TAKEN
MSBUMP(lifetime_freed, size);
10a50f: 8b 45 f4 mov -0xc(%ebp),%eax
10a512: 31 d2 xor %edx,%edx
10a514: 01 05 a4 d4 12 00 add %eax,0x12d4a4
10a51a: 11 15 a8 d4 12 00 adc %edx,0x12d4a8
}
}
10a520: c9 leave
10a521: c3 ret
0010a524 <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
10a524: 55 push %ebp
10a525: 89 e5 mov %esp,%ebp
10a527: 83 ec 18 sub $0x18,%esp
10a52a: 8b 45 08 mov 0x8(%ebp),%eax
uintptr_t actual_size = 0;
10a52d: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
uint32_t current_depth;
rtems_malloc_statistics_t *s = &rtems_malloc_statistics;
if ( !pointer )
10a534: 85 c0 test %eax,%eax
10a536: 74 43 je 10a57b <rtems_malloc_statistics_at_malloc+0x57><== NEVER TAKEN
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
10a538: 52 push %edx
10a539: 8d 55 f4 lea -0xc(%ebp),%edx
10a53c: 52 push %edx
10a53d: 50 push %eax
10a53e: ff 35 f0 89 12 00 pushl 0x1289f0
10a544: e8 6f 59 00 00 call 10feb8 <_Protected_heap_Get_block_size>
MSBUMP(lifetime_allocated, actual_size);
10a549: 8b 45 f4 mov -0xc(%ebp),%eax
10a54c: 31 d2 xor %edx,%edx
10a54e: 03 05 9c d4 12 00 add 0x12d49c,%eax
10a554: 13 15 a0 d4 12 00 adc 0x12d4a0,%edx
10a55a: a3 9c d4 12 00 mov %eax,0x12d49c
10a55f: 89 15 a0 d4 12 00 mov %edx,0x12d4a0
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
10a565: 2b 05 a4 d4 12 00 sub 0x12d4a4,%eax
if (current_depth > s->max_depth)
10a56b: 83 c4 10 add $0x10,%esp
10a56e: 3b 05 98 d4 12 00 cmp 0x12d498,%eax
10a574: 76 05 jbe 10a57b <rtems_malloc_statistics_at_malloc+0x57>
s->max_depth = current_depth;
10a576: a3 98 d4 12 00 mov %eax,0x12d498
}
10a57b: c9 leave
10a57c: c3 ret
001131c4 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
1131c4: 55 push %ebp
1131c5: 89 e5 mov %esp,%ebp
1131c7: 53 push %ebx
1131c8: 83 ec 14 sub $0x14,%esp
1131cb: 8b 5d 08 mov 0x8(%ebp),%ebx
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
1131ce: 85 db test %ebx,%ebx
1131d0: 74 5b je 11322d <rtems_memalign+0x69>
return EINVAL;
*pointer = NULL;
1131d2: c7 03 00 00 00 00 movl $0x0,(%ebx)
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
1131d8: 83 3d 80 96 12 00 03 cmpl $0x3,0x129680
1131df: 74 43 je 113224 <rtems_memalign+0x60> <== ALWAYS TAKEN
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
1131e1: e8 fa 54 ff ff call 1086e0 <malloc_deferred_frees_process>
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
1131e6: 6a 00 push $0x0
1131e8: ff 75 0c pushl 0xc(%ebp)
1131eb: ff 75 10 pushl 0x10(%ebp)
1131ee: ff 35 90 51 12 00 pushl 0x125190
1131f4: e8 63 a4 ff ff call 10d65c <_Protected_heap_Allocate_aligned_with_boundary>
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
1131f9: 83 c4 10 add $0x10,%esp
1131fc: 85 c0 test %eax,%eax
1131fe: 74 38 je 113238 <rtems_memalign+0x74>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
113200: 8b 15 28 77 12 00 mov 0x127728,%edx
113206: 85 d2 test %edx,%edx
113208: 74 10 je 11321a <rtems_memalign+0x56>
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
11320a: 83 ec 0c sub $0xc,%esp
11320d: 53 push %ebx
11320e: 89 45 f4 mov %eax,-0xc(%ebp)
113211: ff 52 04 call *0x4(%edx)
113214: 83 c4 10 add $0x10,%esp
113217: 8b 45 f4 mov -0xc(%ebp),%eax
*pointer = return_this;
11321a: 89 03 mov %eax,(%ebx)
return 0;
11321c: 31 c0 xor %eax,%eax
}
11321e: 8b 5d fc mov -0x4(%ebp),%ebx
113221: c9 leave
113222: c3 ret
113223: 90 nop
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() )
113224: e8 77 54 ff ff call 1086a0 <malloc_is_system_state_OK>
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
113229: 84 c0 test %al,%al
11322b: 75 b4 jne 1131e1 <rtems_memalign+0x1d> <== ALWAYS TAKEN
!malloc_is_system_state_OK() )
return EINVAL;
11322d: b8 16 00 00 00 mov $0x16,%eax
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
*pointer = return_this;
return 0;
}
113232: 8b 5d fc mov -0x4(%ebp),%ebx
113235: c9 leave
113236: c3 ret
113237: 90 nop
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
return ENOMEM;
113238: b8 0c 00 00 00 mov $0xc,%eax
11323d: eb df jmp 11321e <rtems_memalign+0x5a>
001159e4 <rtems_message_queue_broadcast>:
rtems_id id,
const void *buffer,
size_t size,
uint32_t *count
)
{
1159e4: 55 push %ebp
1159e5: 89 e5 mov %esp,%ebp
1159e7: 57 push %edi
1159e8: 56 push %esi
1159e9: 53 push %ebx
1159ea: 83 ec 1c sub $0x1c,%esp
1159ed: 8b 7d 08 mov 0x8(%ebp),%edi
1159f0: 8b 5d 0c mov 0xc(%ebp),%ebx
1159f3: 8b 75 14 mov 0x14(%ebp),%esi
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status core_status;
if ( !buffer )
1159f6: 85 db test %ebx,%ebx
1159f8: 74 62 je 115a5c <rtems_message_queue_broadcast+0x78>
return RTEMS_INVALID_ADDRESS;
if ( !count )
1159fa: 85 f6 test %esi,%esi
1159fc: 74 5e je 115a5c <rtems_message_queue_broadcast+0x78>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
1159fe: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
1159ff: 8d 45 e4 lea -0x1c(%ebp),%eax
115a02: 50 push %eax
115a03: 57 push %edi
115a04: 68 00 0c 14 00 push $0x140c00
115a09: e8 b6 4d 00 00 call 11a7c4 <_Objects_Get>
switch ( location ) {
115a0e: 83 c4 10 add $0x10,%esp
115a11: 8b 55 e4 mov -0x1c(%ebp),%edx
115a14: 85 d2 test %edx,%edx
115a16: 74 10 je 115a28 <rtems_message_queue_broadcast+0x44>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115a18: b8 04 00 00 00 mov $0x4,%eax
}
115a1d: 8d 65 f4 lea -0xc(%ebp),%esp
115a20: 5b pop %ebx
115a21: 5e pop %esi
115a22: 5f pop %edi
115a23: c9 leave
115a24: c3 ret
115a25: 8d 76 00 lea 0x0(%esi),%esi
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
core_status = _CORE_message_queue_Broadcast(
115a28: 83 ec 08 sub $0x8,%esp
115a2b: 56 push %esi
115a2c: 6a 00 push $0x0
115a2e: 57 push %edi
115a2f: ff 75 10 pushl 0x10(%ebp)
115a32: 53 push %ebx
115a33: 83 c0 14 add $0x14,%eax
115a36: 50 push %eax
115a37: e8 60 34 00 00 call 118e9c <_CORE_message_queue_Broadcast>
115a3c: 89 c3 mov %eax,%ebx
NULL,
#endif
count
);
_Thread_Enable_dispatch();
115a3e: 83 c4 20 add $0x20,%esp
115a41: e8 ce 58 00 00 call 11b314 <_Thread_Enable_dispatch>
return
115a46: 83 ec 0c sub $0xc,%esp
115a49: 53 push %ebx
115a4a: e8 69 03 00 00 call 115db8 <_Message_queue_Translate_core_message_queue_return_code>
115a4f: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115a52: 8d 65 f4 lea -0xc(%ebp),%esp
115a55: 5b pop %ebx
115a56: 5e pop %esi
115a57: 5f pop %edi
115a58: c9 leave
115a59: c3 ret
115a5a: 66 90 xchg %ax,%ax
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !count )
return RTEMS_INVALID_ADDRESS;
115a5c: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115a61: 8d 65 f4 lea -0xc(%ebp),%esp
115a64: 5b pop %ebx
115a65: 5e pop %esi
115a66: 5f pop %edi
115a67: c9 leave
115a68: c3 ret
0010f7b0 <rtems_message_queue_create>:
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
10f7b0: 55 push %ebp
10f7b1: 89 e5 mov %esp,%ebp
10f7b3: 57 push %edi
10f7b4: 56 push %esi
10f7b5: 53 push %ebx
10f7b6: 83 ec 2c sub $0x2c,%esp
10f7b9: 8b 5d 08 mov 0x8(%ebp),%ebx
10f7bc: 8b 75 0c mov 0xc(%ebp),%esi
10f7bf: 8b 4d 10 mov 0x10(%ebp),%ecx
10f7c2: 8b 7d 18 mov 0x18(%ebp),%edi
CORE_message_queue_Attributes the_msgq_attributes;
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !rtems_is_name_valid( name ) )
10f7c5: 85 db test %ebx,%ebx
10f7c7: 74 2f je 10f7f8 <rtems_message_queue_create+0x48>
return RTEMS_INVALID_NAME;
if ( !id )
10f7c9: 85 ff test %edi,%edi
10f7cb: 0f 84 a3 00 00 00 je 10f874 <rtems_message_queue_create+0xc4>
if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
10f7d1: 85 f6 test %esi,%esi
10f7d3: 74 13 je 10f7e8 <rtems_message_queue_create+0x38>
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
10f7d5: 85 c9 test %ecx,%ecx
10f7d7: 75 2f jne 10f808 <rtems_message_queue_create+0x58>
return RTEMS_INVALID_SIZE;
10f7d9: b8 08 00 00 00 mov $0x8,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10f7de: 8d 65 f4 lea -0xc(%ebp),%esp
10f7e1: 5b pop %ebx
10f7e2: 5e pop %esi
10f7e3: 5f pop %edi
10f7e4: c9 leave
10f7e5: c3 ret
10f7e6: 66 90 xchg %ax,%ax
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
return RTEMS_INVALID_NUMBER;
10f7e8: b8 0a 00 00 00 mov $0xa,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10f7ed: 8d 65 f4 lea -0xc(%ebp),%esp
10f7f0: 5b pop %ebx
10f7f1: 5e pop %esi
10f7f2: 5f pop %edi
10f7f3: c9 leave
10f7f4: c3 ret
10f7f5: 8d 76 00 lea 0x0(%esi),%esi
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10f7f8: b8 03 00 00 00 mov $0x3,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10f7fd: 8d 65 f4 lea -0xc(%ebp),%esp
10f800: 5b pop %ebx
10f801: 5e pop %esi
10f802: 5f pop %edi
10f803: c9 leave
10f804: c3 ret
10f805: 8d 76 00 lea 0x0(%esi),%esi
10f808: a1 ec 64 12 00 mov 0x1264ec,%eax
10f80d: 40 inc %eax
10f80e: a3 ec 64 12 00 mov %eax,0x1264ec
#endif
#endif
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
10f813: 89 4d d4 mov %ecx,-0x2c(%ebp)
10f816: e8 4d 21 00 00 call 111968 <_Message_queue_Allocate>
10f81b: 89 c2 mov %eax,%edx
if ( !the_message_queue ) {
10f81d: 85 c0 test %eax,%eax
10f81f: 8b 4d d4 mov -0x2c(%ebp),%ecx
10f822: 74 7c je 10f8a0 <rtems_message_queue_create+0xf0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_message_queue->attribute_set = attribute_set;
10f824: 8b 45 14 mov 0x14(%ebp),%eax
10f827: 89 42 10 mov %eax,0x10(%edx)
if (_Attributes_Is_priority( attribute_set ) )
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
10f82a: a8 04 test $0x4,%al
10f82c: 0f 95 c0 setne %al
10f82f: 0f b6 c0 movzbl %al,%eax
10f832: 89 45 e4 mov %eax,-0x1c(%ebp)
else
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
if ( ! _CORE_message_queue_Initialize(
10f835: 51 push %ecx
10f836: 56 push %esi
10f837: 8d 45 e4 lea -0x1c(%ebp),%eax
10f83a: 50 push %eax
10f83b: 8d 42 14 lea 0x14(%edx),%eax
10f83e: 50 push %eax
10f83f: 89 55 d4 mov %edx,-0x2c(%ebp)
10f842: e8 c5 06 00 00 call 10ff0c <_CORE_message_queue_Initialize>
10f847: 83 c4 10 add $0x10,%esp
10f84a: 84 c0 test %al,%al
10f84c: 8b 55 d4 mov -0x2c(%ebp),%edx
10f84f: 75 2f jne 10f880 <rtems_message_queue_create+0xd0>
*/
RTEMS_INLINE_ROUTINE void _Message_queue_Free (
Message_queue_Control *the_message_queue
)
{
_Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
10f851: 83 ec 08 sub $0x8,%esp
10f854: 52 push %edx
10f855: 68 e0 68 12 00 push $0x1268e0
10f85a: e8 0d c8 ff ff call 10c06c <_Objects_Free>
_Objects_MP_Close(
&_Message_queue_Information, the_message_queue->Object.id);
#endif
_Message_queue_Free( the_message_queue );
_Thread_Enable_dispatch();
10f85f: e8 98 d4 ff ff call 10ccfc <_Thread_Enable_dispatch>
return RTEMS_UNSATISFIED;
10f864: 83 c4 10 add $0x10,%esp
10f867: b8 0d 00 00 00 mov $0xd,%eax
10f86c: e9 6d ff ff ff jmp 10f7de <rtems_message_queue_create+0x2e>
10f871: 8d 76 00 lea 0x0(%esi),%esi
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10f874: b8 09 00 00 00 mov $0x9,%eax
10f879: e9 60 ff ff ff jmp 10f7de <rtems_message_queue_create+0x2e>
10f87e: 66 90 xchg %ax,%ax
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10f880: 8b 42 08 mov 0x8(%edx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10f883: 0f b7 f0 movzwl %ax,%esi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10f886: 8b 0d fc 68 12 00 mov 0x1268fc,%ecx
10f88c: 89 14 b1 mov %edx,(%ecx,%esi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10f88f: 89 5a 0c mov %ebx,0xc(%edx)
&_Message_queue_Information,
&the_message_queue->Object,
(Objects_Name) name
);
*id = the_message_queue->Object.id;
10f892: 89 07 mov %eax,(%edi)
name,
0
);
#endif
_Thread_Enable_dispatch();
10f894: e8 63 d4 ff ff call 10ccfc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10f899: 31 c0 xor %eax,%eax
10f89b: e9 3e ff ff ff jmp 10f7de <rtems_message_queue_create+0x2e>
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
if ( !the_message_queue ) {
_Thread_Enable_dispatch();
10f8a0: e8 57 d4 ff ff call 10ccfc <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
10f8a5: b8 05 00 00 00 mov $0x5,%eax
10f8aa: e9 2f ff ff ff jmp 10f7de <rtems_message_queue_create+0x2e>
0010f8b0 <rtems_message_queue_delete>:
*/
rtems_status_code rtems_message_queue_delete(
rtems_id id
)
{
10f8b0: 55 push %ebp
10f8b1: 89 e5 mov %esp,%ebp
10f8b3: 53 push %ebx
10f8b4: 83 ec 18 sub $0x18,%esp
register Message_queue_Control *the_message_queue;
Objects_Locations location;
the_message_queue = _Message_queue_Get( id, &location );
10f8b7: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
10f8ba: 50 push %eax
10f8bb: ff 75 08 pushl 0x8(%ebp)
10f8be: 68 e0 68 12 00 push $0x1268e0
10f8c3: e8 e4 c8 ff ff call 10c1ac <_Objects_Get>
10f8c8: 89 c3 mov %eax,%ebx
switch ( location ) {
10f8ca: 83 c4 10 add $0x10,%esp
10f8cd: 8b 4d f4 mov -0xc(%ebp),%ecx
10f8d0: 85 c9 test %ecx,%ecx
10f8d2: 75 3c jne 10f910 <rtems_message_queue_delete+0x60>
case OBJECTS_LOCAL:
_Objects_Close( &_Message_queue_Information,
10f8d4: 83 ec 08 sub $0x8,%esp
10f8d7: 50 push %eax
10f8d8: 68 e0 68 12 00 push $0x1268e0
10f8dd: e8 92 c4 ff ff call 10bd74 <_Objects_Close>
&the_message_queue->Object );
_CORE_message_queue_Close(
10f8e2: 83 c4 0c add $0xc,%esp
10f8e5: 6a 05 push $0x5
10f8e7: 6a 00 push $0x0
10f8e9: 8d 43 14 lea 0x14(%ebx),%eax
10f8ec: 50 push %eax
10f8ed: e8 96 05 00 00 call 10fe88 <_CORE_message_queue_Close>
*/
RTEMS_INLINE_ROUTINE void _Message_queue_Free (
Message_queue_Control *the_message_queue
)
{
_Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
10f8f2: 58 pop %eax
10f8f3: 5a pop %edx
10f8f4: 53 push %ebx
10f8f5: 68 e0 68 12 00 push $0x1268e0
10f8fa: e8 6d c7 ff ff call 10c06c <_Objects_Free>
0, /* Not used */
0
);
}
#endif
_Thread_Enable_dispatch();
10f8ff: e8 f8 d3 ff ff call 10ccfc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10f904: 83 c4 10 add $0x10,%esp
10f907: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10f909: 8b 5d fc mov -0x4(%ebp),%ebx
10f90c: c9 leave
10f90d: c3 ret
10f90e: 66 90 xchg %ax,%ax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10f910: b8 04 00 00 00 mov $0x4,%eax
}
10f915: 8b 5d fc mov -0x4(%ebp),%ebx
10f918: c9 leave
10f919: c3 ret
00115bd8 <rtems_message_queue_flush>:
rtems_status_code rtems_message_queue_flush(
rtems_id id,
uint32_t *count
)
{
115bd8: 55 push %ebp
115bd9: 89 e5 mov %esp,%ebp
115bdb: 53 push %ebx
115bdc: 83 ec 14 sub $0x14,%esp
115bdf: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
115be2: 85 db test %ebx,%ebx
115be4: 74 46 je 115c2c <rtems_message_queue_flush+0x54>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
115be6: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
115be7: 8d 45 f4 lea -0xc(%ebp),%eax
115bea: 50 push %eax
115beb: ff 75 08 pushl 0x8(%ebp)
115bee: 68 00 0c 14 00 push $0x140c00
115bf3: e8 cc 4b 00 00 call 11a7c4 <_Objects_Get>
switch ( location ) {
115bf8: 83 c4 10 add $0x10,%esp
115bfb: 8b 55 f4 mov -0xc(%ebp),%edx
115bfe: 85 d2 test %edx,%edx
115c00: 74 0a je 115c0c <rtems_message_queue_flush+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115c02: b8 04 00 00 00 mov $0x4,%eax
}
115c07: 8b 5d fc mov -0x4(%ebp),%ebx
115c0a: c9 leave
115c0b: c3 ret
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
*count = _CORE_message_queue_Flush( &the_message_queue->message_queue );
115c0c: 83 ec 0c sub $0xc,%esp
115c0f: 83 c0 14 add $0x14,%eax
115c12: 50 push %eax
115c13: e8 44 33 00 00 call 118f5c <_CORE_message_queue_Flush>
115c18: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
115c1a: e8 f5 56 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115c1f: 83 c4 10 add $0x10,%esp
115c22: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115c24: 8b 5d fc mov -0x4(%ebp),%ebx
115c27: c9 leave
115c28: c3 ret
115c29: 8d 76 00 lea 0x0(%esi),%esi
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
return RTEMS_INVALID_ADDRESS;
115c2c: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115c31: 8b 5d fc mov -0x4(%ebp),%ebx
115c34: c9 leave
115c35: c3 ret
00115c38 <rtems_message_queue_get_number_pending>:
rtems_status_code rtems_message_queue_get_number_pending(
rtems_id id,
uint32_t *count
)
{
115c38: 55 push %ebp
115c39: 89 e5 mov %esp,%ebp
115c3b: 53 push %ebx
115c3c: 83 ec 14 sub $0x14,%esp
115c3f: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
115c42: 85 db test %ebx,%ebx
115c44: 74 3a je 115c80 <rtems_message_queue_get_number_pending+0x48>
115c46: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
115c47: 8d 45 f4 lea -0xc(%ebp),%eax
115c4a: 50 push %eax
115c4b: ff 75 08 pushl 0x8(%ebp)
115c4e: 68 00 0c 14 00 push $0x140c00
115c53: e8 6c 4b 00 00 call 11a7c4 <_Objects_Get>
switch ( location ) {
115c58: 83 c4 10 add $0x10,%esp
115c5b: 8b 55 f4 mov -0xc(%ebp),%edx
115c5e: 85 d2 test %edx,%edx
115c60: 74 0a je 115c6c <rtems_message_queue_get_number_pending+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115c62: b8 04 00 00 00 mov $0x4,%eax
}
115c67: 8b 5d fc mov -0x4(%ebp),%ebx
115c6a: c9 leave
115c6b: c3 ret
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
*count = the_message_queue->message_queue.number_of_pending_messages;
115c6c: 8b 40 5c mov 0x5c(%eax),%eax
115c6f: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
115c71: e8 9e 56 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115c76: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115c78: 8b 5d fc mov -0x4(%ebp),%ebx
115c7b: c9 leave
115c7c: c3 ret
115c7d: 8d 76 00 lea 0x0(%esi),%esi
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
return RTEMS_INVALID_ADDRESS;
115c80: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115c85: 8b 5d fc mov -0x4(%ebp),%ebx
115c88: c9 leave
115c89: c3 ret
0010f91c <rtems_message_queue_receive>:
void *buffer,
size_t *size,
rtems_option option_set,
rtems_interval timeout
)
{
10f91c: 55 push %ebp
10f91d: 89 e5 mov %esp,%ebp
10f91f: 56 push %esi
10f920: 53 push %ebx
10f921: 83 ec 10 sub $0x10,%esp
10f924: 8b 5d 0c mov 0xc(%ebp),%ebx
10f927: 8b 75 10 mov 0x10(%ebp),%esi
register Message_queue_Control *the_message_queue;
Objects_Locations location;
bool wait;
if ( !buffer )
10f92a: 85 db test %ebx,%ebx
10f92c: 74 6e je 10f99c <rtems_message_queue_receive+0x80>
return RTEMS_INVALID_ADDRESS;
if ( !size )
10f92e: 85 f6 test %esi,%esi
10f930: 74 6a je 10f99c <rtems_message_queue_receive+0x80>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
10f932: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
10f933: 8d 45 f4 lea -0xc(%ebp),%eax
10f936: 50 push %eax
10f937: ff 75 08 pushl 0x8(%ebp)
10f93a: 68 e0 68 12 00 push $0x1268e0
10f93f: e8 68 c8 ff ff call 10c1ac <_Objects_Get>
switch ( location ) {
10f944: 83 c4 10 add $0x10,%esp
10f947: 8b 55 f4 mov -0xc(%ebp),%edx
10f94a: 85 d2 test %edx,%edx
10f94c: 75 42 jne 10f990 <rtems_message_queue_receive+0x74>
if ( _Options_Is_no_wait( option_set ) )
wait = false;
else
wait = true;
_CORE_message_queue_Seize(
10f94e: 83 ec 08 sub $0x8,%esp
10f951: ff 75 18 pushl 0x18(%ebp)
10f954: 8b 55 14 mov 0x14(%ebp),%edx
10f957: 83 e2 01 and $0x1,%edx
10f95a: 83 f2 01 xor $0x1,%edx
10f95d: 52 push %edx
10f95e: 56 push %esi
10f95f: 53 push %ebx
10f960: ff 70 08 pushl 0x8(%eax)
10f963: 83 c0 14 add $0x14,%eax
10f966: 50 push %eax
10f967: e8 40 06 00 00 call 10ffac <_CORE_message_queue_Seize>
buffer,
size,
wait,
timeout
);
_Thread_Enable_dispatch();
10f96c: 83 c4 20 add $0x20,%esp
10f96f: e8 88 d3 ff ff call 10ccfc <_Thread_Enable_dispatch>
return _Message_queue_Translate_core_message_queue_return_code(
10f974: 83 ec 0c sub $0xc,%esp
_Thread_Executing->Wait.return_code
10f977: a1 78 67 12 00 mov 0x126778,%eax
size,
wait,
timeout
);
_Thread_Enable_dispatch();
return _Message_queue_Translate_core_message_queue_return_code(
10f97c: ff 70 34 pushl 0x34(%eax)
10f97f: e8 a0 00 00 00 call 10fa24 <_Message_queue_Translate_core_message_queue_return_code>
10f984: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10f987: 8d 65 f8 lea -0x8(%ebp),%esp
10f98a: 5b pop %ebx
10f98b: 5e pop %esi
10f98c: c9 leave
10f98d: c3 ret
10f98e: 66 90 xchg %ax,%ax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10f990: b8 04 00 00 00 mov $0x4,%eax
}
10f995: 8d 65 f8 lea -0x8(%ebp),%esp
10f998: 5b pop %ebx
10f999: 5e pop %esi
10f99a: c9 leave
10f99b: c3 ret
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
10f99c: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10f9a1: 8d 65 f8 lea -0x8(%ebp),%esp
10f9a4: 5b pop %ebx
10f9a5: 5e pop %esi
10f9a6: c9 leave
10f9a7: c3 ret
0010f9a8 <rtems_message_queue_send>:
rtems_status_code rtems_message_queue_send(
rtems_id id,
const void *buffer,
size_t size
)
{
10f9a8: 55 push %ebp
10f9a9: 89 e5 mov %esp,%ebp
10f9ab: 56 push %esi
10f9ac: 53 push %ebx
10f9ad: 83 ec 10 sub $0x10,%esp
10f9b0: 8b 75 08 mov 0x8(%ebp),%esi
10f9b3: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
10f9b6: 85 db test %ebx,%ebx
10f9b8: 74 5e je 10fa18 <rtems_message_queue_send+0x70>
10f9ba: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
10f9bb: 8d 45 f4 lea -0xc(%ebp),%eax
10f9be: 50 push %eax
10f9bf: 56 push %esi
10f9c0: 68 e0 68 12 00 push $0x1268e0
10f9c5: e8 e2 c7 ff ff call 10c1ac <_Objects_Get>
switch ( location ) {
10f9ca: 83 c4 10 add $0x10,%esp
10f9cd: 8b 55 f4 mov -0xc(%ebp),%edx
10f9d0: 85 d2 test %edx,%edx
10f9d2: 74 0c je 10f9e0 <rtems_message_queue_send+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10f9d4: b8 04 00 00 00 mov $0x4,%eax
}
10f9d9: 8d 65 f8 lea -0x8(%ebp),%esp
10f9dc: 5b pop %ebx
10f9dd: 5e pop %esi
10f9de: c9 leave
10f9df: c3 ret
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
bool wait,
Watchdog_Interval timeout
)
{
return _CORE_message_queue_Submit(
10f9e0: 6a 00 push $0x0
10f9e2: 6a 00 push $0x0
10f9e4: 68 ff ff ff 7f push $0x7fffffff
10f9e9: 6a 00 push $0x0
10f9eb: 56 push %esi
10f9ec: ff 75 10 pushl 0x10(%ebp)
10f9ef: 53 push %ebx
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status = _CORE_message_queue_Send(
10f9f0: 83 c0 14 add $0x14,%eax
10f9f3: 50 push %eax
10f9f4: e8 8b 06 00 00 call 110084 <_CORE_message_queue_Submit>
10f9f9: 89 c3 mov %eax,%ebx
MESSAGE_QUEUE_MP_HANDLER,
false, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
10f9fb: 83 c4 20 add $0x20,%esp
10f9fe: e8 f9 d2 ff ff call 10ccfc <_Thread_Enable_dispatch>
/*
* Since this API does not allow for blocking sends, we can directly
* return the returned status.
*/
return _Message_queue_Translate_core_message_queue_return_code(status);
10fa03: 83 ec 0c sub $0xc,%esp
10fa06: 53 push %ebx
10fa07: e8 18 00 00 00 call 10fa24 <_Message_queue_Translate_core_message_queue_return_code>
10fa0c: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10fa0f: 8d 65 f8 lea -0x8(%ebp),%esp
10fa12: 5b pop %ebx
10fa13: 5e pop %esi
10fa14: c9 leave
10fa15: c3 ret
10fa16: 66 90 xchg %ax,%ax
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
10fa18: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10fa1d: 8d 65 f8 lea -0x8(%ebp),%esp
10fa20: 5b pop %ebx
10fa21: 5e pop %esi
10fa22: c9 leave
10fa23: c3 ret
00115dc8 <rtems_message_queue_urgent>:
rtems_status_code rtems_message_queue_urgent(
rtems_id id,
const void *buffer,
size_t size
)
{
115dc8: 55 push %ebp
115dc9: 89 e5 mov %esp,%ebp
115dcb: 56 push %esi
115dcc: 53 push %ebx
115dcd: 83 ec 10 sub $0x10,%esp
115dd0: 8b 75 08 mov 0x8(%ebp),%esi
115dd3: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
115dd6: 85 db test %ebx,%ebx
115dd8: 74 5e je 115e38 <rtems_message_queue_urgent+0x70>
115dda: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
115ddb: 8d 45 f4 lea -0xc(%ebp),%eax
115dde: 50 push %eax
115ddf: 56 push %esi
115de0: 68 00 0c 14 00 push $0x140c00
115de5: e8 da 49 00 00 call 11a7c4 <_Objects_Get>
switch ( location ) {
115dea: 83 c4 10 add $0x10,%esp
115ded: 8b 55 f4 mov -0xc(%ebp),%edx
115df0: 85 d2 test %edx,%edx
115df2: 74 0c je 115e00 <rtems_message_queue_urgent+0x38>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115df4: b8 04 00 00 00 mov $0x4,%eax
}
115df9: 8d 65 f8 lea -0x8(%ebp),%esp
115dfc: 5b pop %ebx
115dfd: 5e pop %esi
115dfe: c9 leave
115dff: c3 ret
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
bool wait,
Watchdog_Interval timeout
)
{
return _CORE_message_queue_Submit(
115e00: 6a 00 push $0x0
115e02: 6a 00 push $0x0
115e04: 68 00 00 00 80 push $0x80000000
115e09: 6a 00 push $0x0
115e0b: 56 push %esi
115e0c: ff 75 10 pushl 0x10(%ebp)
115e0f: 53 push %ebx
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status = _CORE_message_queue_Urgent(
115e10: 83 c0 14 add $0x14,%eax
115e13: 50 push %eax
115e14: e8 1f 33 00 00 call 119138 <_CORE_message_queue_Submit>
115e19: 89 c3 mov %eax,%ebx
id,
MESSAGE_QUEUE_MP_HANDLER,
false, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
115e1b: 83 c4 20 add $0x20,%esp
115e1e: e8 f1 54 00 00 call 11b314 <_Thread_Enable_dispatch>
/*
* Since this API does not allow for blocking sends, we can directly
* return the returned status.
*/
return _Message_queue_Translate_core_message_queue_return_code(status);
115e23: 83 ec 0c sub $0xc,%esp
115e26: 53 push %ebx
115e27: e8 8c ff ff ff call 115db8 <_Message_queue_Translate_core_message_queue_return_code>
115e2c: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115e2f: 8d 65 f8 lea -0x8(%ebp),%esp
115e32: 5b pop %ebx
115e33: 5e pop %esi
115e34: c9 leave
115e35: c3 ret
115e36: 66 90 xchg %ax,%ax
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
115e38: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115e3d: 8d 65 f8 lea -0x8(%ebp),%esp
115e40: 5b pop %ebx
115e41: 5e pop %esi
115e42: c9 leave
115e43: c3 ret
0011181c <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
11181c: 55 push %ebp
11181d: 89 e5 mov %esp,%ebp
11181f: 57 push %edi
111820: 56 push %esi
111821: 53 push %ebx
111822: 83 ec 78 sub $0x78,%esp
int success = 0;
char *dup_path = strdup(path);
111825: ff 75 08 pushl 0x8(%ebp)
111828: e8 27 28 00 00 call 114054 <strdup>
11182d: 89 c7 mov %eax,%edi
if (dup_path != NULL) {
11182f: 83 c4 10 add $0x10,%esp
111832: 85 c0 test %eax,%eax
111834: 0f 84 0a 01 00 00 je 111944 <rtems_mkdir+0x128> <== NEVER TAKEN
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
11183a: 8a 10 mov (%eax),%dl
11183c: 80 fa 2f cmp $0x2f,%dl
11183f: 0f 84 0f 01 00 00 je 111954 <rtems_mkdir+0x138>
111845: 89 c3 mov %eax,%ebx
111847: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp)
11184e: b8 01 00 00 00 mov $0x1,%eax
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
111853: 84 d2 test %dl,%dl
111855: 74 11 je 111868 <rtems_mkdir+0x4c> <== NEVER TAKEN
111857: 90 nop
last = 1;
else if (p[0] != '/')
111858: 80 fa 2f cmp $0x2f,%dl
11185b: 0f 84 83 00 00 00 je 1118e4 <rtems_mkdir+0xc8>
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
111861: 43 inc %ebx
111862: 8a 13 mov (%ebx),%dl
if (p[0] == '\0')
111864: 84 d2 test %dl,%dl
111866: 75 f0 jne 111858 <rtems_mkdir+0x3c>
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
111868: c6 03 00 movb $0x0,(%ebx)
11186b: be 01 00 00 00 mov $0x1,%esi
if (!last && p[1] == '\0')
last = 1;
if (first) {
111870: 85 c0 test %eax,%eax
111872: 75 54 jne 1118c8 <rtems_mkdir+0xac>
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
111874: 85 f6 test %esi,%esi
111876: 75 3c jne 1118b4 <rtems_mkdir+0x98>
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
111878: b8 ff 01 00 00 mov $0x1ff,%eax
11187d: 83 ec 08 sub $0x8,%esp
111880: 50 push %eax
111881: 57 push %edi
111882: e8 6d 73 ff ff call 108bf4 <mkdir>
111887: 83 c4 10 add $0x10,%esp
11188a: 85 c0 test %eax,%eax
11188c: 78 6a js 1118f8 <rtems_mkdir+0xdc>
} else {
retval = 0;
break;
}
}
if (!last)
11188e: 85 f6 test %esi,%esi
111890: 75 0a jne 11189c <rtems_mkdir+0x80>
*p = '/';
111892: c6 03 2f movb $0x2f,(%ebx)
111895: 31 c0 xor %eax,%eax
111897: eb c8 jmp 111861 <rtems_mkdir+0x45>
111899: 8d 76 00 lea 0x0(%esi),%esi
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
11189c: 83 ec 0c sub $0xc,%esp
11189f: 57 push %edi
1118a0: e8 77 6d ff ff call 10861c <free>
1118a5: 83 c4 10 add $0x10,%esp
}
return success != 0 ? 0 : -1;
1118a8: 31 c0 xor %eax,%eax
}
1118aa: 8d 65 f4 lea -0xc(%ebp),%esp
1118ad: 5b pop %ebx
1118ae: 5e pop %esi
1118af: 5f pop %edi
1118b0: c9 leave
1118b1: c3 ret
1118b2: 66 90 xchg %ax,%ax
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
(void)umask(oumask);
1118b4: 83 ec 0c sub $0xc,%esp
1118b7: ff 75 94 pushl -0x6c(%ebp)
1118ba: e8 81 01 00 00 call 111a40 <umask>
1118bf: 83 c4 10 add $0x10,%esp
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
1118c2: 8b 45 0c mov 0xc(%ebp),%eax
1118c5: eb b6 jmp 11187d <rtems_mkdir+0x61>
1118c7: 90 nop
* mkdir [-m mode] dir
*
* We change the user's umask and then restore it,
* instead of doing chmod's.
*/
oumask = umask(0);
1118c8: 83 ec 0c sub $0xc,%esp
1118cb: 6a 00 push $0x0
1118cd: e8 6e 01 00 00 call 111a40 <umask>
1118d2: 89 45 94 mov %eax,-0x6c(%ebp)
numask = oumask & ~(S_IWUSR | S_IXUSR);
1118d5: 24 3f and $0x3f,%al
(void)umask(numask);
1118d7: 89 04 24 mov %eax,(%esp)
1118da: e8 61 01 00 00 call 111a40 <umask>
1118df: 83 c4 10 add $0x10,%esp
1118e2: eb 90 jmp 111874 <rtems_mkdir+0x58>
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
1118e4: c6 03 00 movb $0x0,(%ebx)
if (!last && p[1] == '\0')
1118e7: 31 d2 xor %edx,%edx
1118e9: 80 7b 01 00 cmpb $0x0,0x1(%ebx)
1118ed: 0f 94 c2 sete %dl
1118f0: 89 d6 mov %edx,%esi
1118f2: e9 79 ff ff ff jmp 111870 <rtems_mkdir+0x54>
1118f7: 90 nop
first = 0;
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
1118f8: e8 d7 1a 00 00 call 1133d4 <__errno>
1118fd: 83 38 11 cmpl $0x11,(%eax)
111900: 74 0a je 11190c <rtems_mkdir+0xf0>
111902: e8 cd 1a 00 00 call 1133d4 <__errno>
111907: 83 38 15 cmpl $0x15,(%eax)
11190a: 75 53 jne 11195f <rtems_mkdir+0x143> <== ALWAYS TAKEN
if (stat(path, &sb) < 0) {
11190c: 83 ec 08 sub $0x8,%esp
11190f: 8d 45 a0 lea -0x60(%ebp),%eax
111912: 50 push %eax
111913: 57 push %edi
111914: e8 7f 00 00 00 call 111998 <stat>
111919: 83 c4 10 add $0x10,%esp
11191c: 85 c0 test %eax,%eax
11191e: 78 3f js 11195f <rtems_mkdir+0x143> <== NEVER TAKEN
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
111920: 8b 45 ac mov -0x54(%ebp),%eax
111923: 25 00 f0 00 00 and $0xf000,%eax
111928: 3d 00 40 00 00 cmp $0x4000,%eax
11192d: 0f 84 5b ff ff ff je 11188e <rtems_mkdir+0x72>
if (last)
111933: 85 f6 test %esi,%esi
111935: 74 53 je 11198a <rtems_mkdir+0x16e>
errno = EEXIST;
111937: e8 98 1a 00 00 call 1133d4 <__errno>
11193c: c7 00 11 00 00 00 movl $0x11,(%eax)
111942: eb 2d jmp 111971 <rtems_mkdir+0x155>
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
}
return success != 0 ? 0 : -1;
111944: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
}
111949: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
11194c: 5b pop %ebx <== NOT EXECUTED
11194d: 5e pop %esi <== NOT EXECUTED
11194e: 5f pop %edi <== NOT EXECUTED
11194f: c9 leave <== NOT EXECUTED
111950: c3 ret <== NOT EXECUTED
111951: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
111954: 8d 58 01 lea 0x1(%eax),%ebx
111957: 8a 50 01 mov 0x1(%eax),%dl
11195a: e9 e8 fe ff ff jmp 111847 <rtems_mkdir+0x2b>
}
}
if (!last)
*p = '/';
}
if (!first && !last)
11195f: 85 f6 test %esi,%esi
111961: 75 0e jne 111971 <rtems_mkdir+0x155> <== ALWAYS TAKEN
(void)umask(oumask);
111963: 83 ec 0c sub $0xc,%esp
111966: ff 75 94 pushl -0x6c(%ebp)
111969: e8 d2 00 00 00 call 111a40 <umask>
11196e: 83 c4 10 add $0x10,%esp
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
111971: 83 ec 0c sub $0xc,%esp
111974: 57 push %edi
111975: e8 a2 6c ff ff call 10861c <free>
11197a: 83 c4 10 add $0x10,%esp
}
return success != 0 ? 0 : -1;
11197d: b8 ff ff ff ff mov $0xffffffff,%eax
}
111982: 8d 65 f4 lea -0xc(%ebp),%esp
111985: 5b pop %ebx
111986: 5e pop %esi
111987: 5f pop %edi
111988: c9 leave
111989: c3 ret
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
errno = EEXIST;
else
errno = ENOTDIR;
11198a: e8 45 1a 00 00 call 1133d4 <__errno>
11198f: c7 00 14 00 00 00 movl $0x14,(%eax)
111995: eb cc jmp 111963 <rtems_mkdir+0x147>
0010c4cc <rtems_object_get_api_class_name>:
const char *rtems_object_get_api_class_name(
int the_api,
int the_class
)
{
10c4cc: 55 push %ebp
10c4cd: 89 e5 mov %esp,%ebp
10c4cf: 83 ec 08 sub $0x8,%esp
10c4d2: 8b 45 08 mov 0x8(%ebp),%eax
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
10c4d5: 83 f8 01 cmp $0x1,%eax
10c4d8: 74 2a je 10c504 <rtems_object_get_api_class_name+0x38>
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
10c4da: 83 f8 02 cmp $0x2,%eax
10c4dd: 74 09 je 10c4e8 <rtems_object_get_api_class_name+0x1c>
#ifdef RTEMS_POSIX_API
else if ( the_api == OBJECTS_POSIX_API )
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
10c4df: b8 db 33 12 00 mov $0x1233db,%eax
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
if ( class_assoc )
return class_assoc->name;
return "BAD CLASS";
}
10c4e4: c9 leave
10c4e5: c3 ret
10c4e6: 66 90 xchg %ax,%ax
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
api_assoc = rtems_object_api_classic_assoc;
10c4e8: b8 40 71 12 00 mov $0x127140,%eax
else if ( the_api == OBJECTS_POSIX_API )
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
10c4ed: 83 ec 08 sub $0x8,%esp
10c4f0: ff 75 0c pushl 0xc(%ebp)
10c4f3: 50 push %eax
10c4f4: e8 03 4b 00 00 call 110ffc <rtems_assoc_ptr_by_local>
if ( class_assoc )
10c4f9: 83 c4 10 add $0x10,%esp
10c4fc: 85 c0 test %eax,%eax
10c4fe: 74 0c je 10c50c <rtems_object_get_api_class_name+0x40>
return class_assoc->name;
10c500: 8b 00 mov (%eax),%eax
return "BAD CLASS";
}
10c502: c9 leave
10c503: c3 ret
{
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
api_assoc = rtems_object_api_internal_assoc;
10c504: b8 20 71 12 00 mov $0x127120,%eax
10c509: eb e2 jmp 10c4ed <rtems_object_get_api_class_name+0x21>
10c50b: 90 nop
else
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
if ( class_assoc )
return class_assoc->name;
return "BAD CLASS";
10c50c: b8 e3 33 12 00 mov $0x1233e3,%eax
}
10c511: c9 leave
10c512: c3 ret
0010c514 <rtems_object_get_api_name>:
};
const char *rtems_object_get_api_name(
int api
)
{
10c514: 55 push %ebp
10c515: 89 e5 mov %esp,%ebp
10c517: 83 ec 10 sub $0x10,%esp
const rtems_assoc_t *api_assoc;
api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api );
10c51a: ff 75 08 pushl 0x8(%ebp)
10c51d: 68 c0 71 12 00 push $0x1271c0
10c522: e8 d5 4a 00 00 call 110ffc <rtems_assoc_ptr_by_local>
if ( api_assoc )
10c527: 83 c4 10 add $0x10,%esp
10c52a: 85 c0 test %eax,%eax
10c52c: 74 06 je 10c534 <rtems_object_get_api_name+0x20>
return api_assoc->name;
10c52e: 8b 00 mov (%eax),%eax
return "BAD CLASS";
}
10c530: c9 leave
10c531: c3 ret
10c532: 66 90 xchg %ax,%ax
const rtems_assoc_t *api_assoc;
api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api );
if ( api_assoc )
return api_assoc->name;
return "BAD CLASS";
10c534: b8 e3 33 12 00 mov $0x1233e3,%eax
}
10c539: c9 leave
10c53a: c3 ret
0010c57c <rtems_object_get_class_information>:
rtems_status_code rtems_object_get_class_information(
int the_api,
int the_class,
rtems_object_api_class_information *info
)
{
10c57c: 55 push %ebp
10c57d: 89 e5 mov %esp,%ebp
10c57f: 57 push %edi
10c580: 56 push %esi
10c581: 53 push %ebx
10c582: 83 ec 0c sub $0xc,%esp
10c585: 8b 5d 10 mov 0x10(%ebp),%ebx
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
10c588: 85 db test %ebx,%ebx
10c58a: 74 60 je 10c5ec <rtems_object_get_class_information+0x70>
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
10c58c: 83 ec 08 sub $0x8,%esp
10c58f: 0f b7 45 0c movzwl 0xc(%ebp),%eax
10c593: 50 push %eax
10c594: ff 75 08 pushl 0x8(%ebp)
10c597: e8 c8 19 00 00 call 10df64 <_Objects_Get_information>
if ( !obj_info )
10c59c: 83 c4 10 add $0x10,%esp
10c59f: 85 c0 test %eax,%eax
10c5a1: 74 59 je 10c5fc <rtems_object_get_class_information+0x80>
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
10c5a3: 8b 50 08 mov 0x8(%eax),%edx
10c5a6: 89 13 mov %edx,(%ebx)
info->maximum_id = obj_info->maximum_id;
10c5a8: 8b 50 0c mov 0xc(%eax),%edx
10c5ab: 89 53 04 mov %edx,0x4(%ebx)
info->auto_extend = obj_info->auto_extend;
10c5ae: 8a 50 12 mov 0x12(%eax),%dl
10c5b1: 88 53 0c mov %dl,0xc(%ebx)
info->maximum = obj_info->maximum;
10c5b4: 0f b7 70 10 movzwl 0x10(%eax),%esi
10c5b8: 89 73 08 mov %esi,0x8(%ebx)
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
10c5bb: 85 f6 test %esi,%esi
10c5bd: 74 44 je 10c603 <rtems_object_get_class_information+0x87><== NEVER TAKEN
10c5bf: 8b 78 1c mov 0x1c(%eax),%edi
10c5c2: b9 01 00 00 00 mov $0x1,%ecx
10c5c7: b8 01 00 00 00 mov $0x1,%eax
10c5cc: 31 d2 xor %edx,%edx
10c5ce: 66 90 xchg %ax,%ax
if ( !obj_info->local_table[i] )
unallocated++;
10c5d0: 83 3c 8f 01 cmpl $0x1,(%edi,%ecx,4)
10c5d4: 83 d2 00 adc $0x0,%edx
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
10c5d7: 40 inc %eax
10c5d8: 89 c1 mov %eax,%ecx
10c5da: 39 c6 cmp %eax,%esi
10c5dc: 73 f2 jae 10c5d0 <rtems_object_get_class_information+0x54>
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
10c5de: 89 53 10 mov %edx,0x10(%ebx)
return RTEMS_SUCCESSFUL;
10c5e1: 31 c0 xor %eax,%eax
}
10c5e3: 8d 65 f4 lea -0xc(%ebp),%esp
10c5e6: 5b pop %ebx
10c5e7: 5e pop %esi
10c5e8: 5f pop %edi
10c5e9: c9 leave
10c5ea: c3 ret
10c5eb: 90 nop
/*
* Validate parameters and look up information structure.
*/
if ( !info )
return RTEMS_INVALID_ADDRESS;
10c5ec: b8 09 00 00 00 mov $0x9,%eax
unallocated++;
info->unallocated = unallocated;
return RTEMS_SUCCESSFUL;
}
10c5f1: 8d 65 f4 lea -0xc(%ebp),%esp
10c5f4: 5b pop %ebx
10c5f5: 5e pop %esi
10c5f6: 5f pop %edi
10c5f7: c9 leave
10c5f8: c3 ret
10c5f9: 8d 76 00 lea 0x0(%esi),%esi
if ( !info )
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
if ( !obj_info )
return RTEMS_INVALID_NUMBER;
10c5fc: b8 0a 00 00 00 mov $0xa,%eax
10c601: eb e0 jmp 10c5e3 <rtems_object_get_class_information+0x67>
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
10c603: 31 d2 xor %edx,%edx <== NOT EXECUTED
10c605: eb d7 jmp 10c5de <rtems_object_get_class_information+0x62><== NOT EXECUTED
0010ba18 <rtems_object_get_classic_name>:
rtems_status_code rtems_object_get_classic_name(
rtems_id id,
rtems_name *name
)
{
10ba18: 55 push %ebp
10ba19: 89 e5 mov %esp,%ebp
10ba1b: 53 push %ebx
10ba1c: 83 ec 14 sub $0x14,%esp
10ba1f: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
10ba22: 85 db test %ebx,%ebx
10ba24: 74 26 je 10ba4c <rtems_object_get_classic_name+0x34>
return RTEMS_INVALID_ADDRESS;
status = _Objects_Id_to_name( id, &name_u );
10ba26: 83 ec 08 sub $0x8,%esp
10ba29: 8d 45 f4 lea -0xc(%ebp),%eax
10ba2c: 50 push %eax
10ba2d: ff 75 08 pushl 0x8(%ebp)
10ba30: e8 23 1a 00 00 call 10d458 <_Objects_Id_to_name>
*name = name_u.name_u32;
10ba35: 8b 55 f4 mov -0xc(%ebp),%edx
10ba38: 89 13 mov %edx,(%ebx)
return _Status_Object_name_errors_to_status[ status ];
10ba3a: 8b 04 85 ec 1d 12 00 mov 0x121dec(,%eax,4),%eax
10ba41: 83 c4 10 add $0x10,%esp
}
10ba44: 8b 5d fc mov -0x4(%ebp),%ebx
10ba47: c9 leave
10ba48: c3 ret
10ba49: 8d 76 00 lea 0x0(%esi),%esi
{
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
return RTEMS_INVALID_ADDRESS;
10ba4c: b8 09 00 00 00 mov $0x9,%eax
status = _Objects_Id_to_name( id, &name_u );
*name = name_u.name_u32;
return _Status_Object_name_errors_to_status[ status ];
}
10ba51: 8b 5d fc mov -0x4(%ebp),%ebx
10ba54: c9 leave
10ba55: c3 ret
0010c660 <rtems_object_set_name>:
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
10c660: 55 push %ebp
10c661: 89 e5 mov %esp,%ebp
10c663: 57 push %edi
10c664: 56 push %esi
10c665: 53 push %ebx
10c666: 83 ec 1c sub $0x1c,%esp
10c669: 8b 75 08 mov 0x8(%ebp),%esi
10c66c: 8b 7d 0c mov 0xc(%ebp),%edi
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
10c66f: 85 ff test %edi,%edi
10c671: 74 61 je 10c6d4 <rtems_object_set_name+0x74>
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10c673: 85 f6 test %esi,%esi
10c675: 74 35 je 10c6ac <rtems_object_set_name+0x4c>
information = _Objects_Get_information_id( tmpId );
10c677: 83 ec 0c sub $0xc,%esp
10c67a: 56 push %esi
10c67b: e8 c4 18 00 00 call 10df44 <_Objects_Get_information_id>
10c680: 89 c3 mov %eax,%ebx
if ( !information )
10c682: 83 c4 10 add $0x10,%esp
10c685: 85 c0 test %eax,%eax
10c687: 74 16 je 10c69f <rtems_object_set_name+0x3f>
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
10c689: 50 push %eax
10c68a: 8d 45 e4 lea -0x1c(%ebp),%eax
10c68d: 50 push %eax
10c68e: 56 push %esi
10c68f: 53 push %ebx
10c690: e8 4f 1a 00 00 call 10e0e4 <_Objects_Get>
switch ( location ) {
10c695: 83 c4 10 add $0x10,%esp
10c698: 8b 4d e4 mov -0x1c(%ebp),%ecx
10c69b: 85 c9 test %ecx,%ecx
10c69d: 74 19 je 10c6b8 <rtems_object_set_name+0x58>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10c69f: b8 04 00 00 00 mov $0x4,%eax
}
10c6a4: 8d 65 f4 lea -0xc(%ebp),%esp
10c6a7: 5b pop %ebx
10c6a8: 5e pop %esi
10c6a9: 5f pop %edi
10c6aa: c9 leave
10c6ab: c3 ret
Objects_Id tmpId;
if ( !name )
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10c6ac: a1 f8 97 12 00 mov 0x1297f8,%eax
10c6b1: 8b 70 08 mov 0x8(%eax),%esi
10c6b4: eb c1 jmp 10c677 <rtems_object_set_name+0x17>
10c6b6: 66 90 xchg %ax,%ax
the_object = _Objects_Get( information, tmpId, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Objects_Set_name( information, the_object, name );
10c6b8: 52 push %edx
10c6b9: 57 push %edi
10c6ba: 50 push %eax
10c6bb: 53 push %ebx
10c6bc: e8 d3 1b 00 00 call 10e294 <_Objects_Set_name>
_Thread_Enable_dispatch();
10c6c1: e8 de 25 00 00 call 10eca4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c6c6: 83 c4 10 add $0x10,%esp
10c6c9: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c6cb: 8d 65 f4 lea -0xc(%ebp),%esp
10c6ce: 5b pop %ebx
10c6cf: 5e pop %esi
10c6d0: 5f pop %edi
10c6d1: c9 leave
10c6d2: c3 ret
10c6d3: 90 nop
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
return RTEMS_INVALID_ADDRESS;
10c6d4: b8 09 00 00 00 mov $0x9,%eax
10c6d9: eb c9 jmp 10c6a4 <rtems_object_set_name+0x44>
00115e44 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
115e44: 55 push %ebp
115e45: 89 e5 mov %esp,%ebp
115e47: 57 push %edi
115e48: 56 push %esi
115e49: 53 push %ebx
115e4a: 83 ec 1c sub $0x1c,%esp
115e4d: 8b 5d 08 mov 0x8(%ebp),%ebx
115e50: 8b 75 0c mov 0xc(%ebp),%esi
115e53: 8b 55 10 mov 0x10(%ebp),%edx
115e56: 8b 7d 14 mov 0x14(%ebp),%edi
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
115e59: 85 db test %ebx,%ebx
115e5b: 74 47 je 115ea4 <rtems_partition_create+0x60>
return RTEMS_INVALID_NAME;
if ( !starting_address )
115e5d: 85 f6 test %esi,%esi
115e5f: 74 23 je 115e84 <rtems_partition_create+0x40>
return RTEMS_INVALID_ADDRESS;
if ( !id )
115e61: 8b 45 1c mov 0x1c(%ebp),%eax
115e64: 85 c0 test %eax,%eax
115e66: 74 1c je 115e84 <rtems_partition_create+0x40><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
115e68: 85 d2 test %edx,%edx
115e6a: 74 28 je 115e94 <rtems_partition_create+0x50>
115e6c: 85 ff test %edi,%edi
115e6e: 74 24 je 115e94 <rtems_partition_create+0x50>
115e70: 39 fa cmp %edi,%edx
115e72: 72 20 jb 115e94 <rtems_partition_create+0x50>
115e74: f7 c7 03 00 00 00 test $0x3,%edi
115e7a: 75 18 jne 115e94 <rtems_partition_create+0x50>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
115e7c: f7 c6 03 00 00 00 test $0x3,%esi
115e82: 74 30 je 115eb4 <rtems_partition_create+0x70>
return RTEMS_INVALID_ADDRESS;
115e84: b8 09 00 00 00 mov $0x9,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
115e89: 8d 65 f4 lea -0xc(%ebp),%esp
115e8c: 5b pop %ebx
115e8d: 5e pop %esi
115e8e: 5f pop %edi
115e8f: c9 leave
115e90: c3 ret
115e91: 8d 76 00 lea 0x0(%esi),%esi
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
115e94: b8 08 00 00 00 mov $0x8,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
115e99: 8d 65 f4 lea -0xc(%ebp),%esp
115e9c: 5b pop %ebx
115e9d: 5e pop %esi
115e9e: 5f pop %edi
115e9f: c9 leave
115ea0: c3 ret
115ea1: 8d 76 00 lea 0x0(%esi),%esi
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
115ea4: b8 03 00 00 00 mov $0x3,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
115ea9: 8d 65 f4 lea -0xc(%ebp),%esp
115eac: 5b pop %ebx
115ead: 5e pop %esi
115eae: 5f pop %edi
115eaf: c9 leave
115eb0: c3 ret
115eb1: 8d 76 00 lea 0x0(%esi),%esi
115eb4: a1 ec 08 14 00 mov 0x1408ec,%eax
115eb9: 40 inc %eax
115eba: a3 ec 08 14 00 mov %eax,0x1408ec
* This function allocates a partition control block from
* the inactive chain of free partition control blocks.
*/
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void )
{
return (Partition_Control *) _Objects_Allocate( &_Partition_Information );
115ebf: 83 ec 0c sub $0xc,%esp
115ec2: 68 80 07 14 00 push $0x140780
115ec7: 89 55 e0 mov %edx,-0x20(%ebp)
115eca: e8 05 44 00 00 call 11a2d4 <_Objects_Allocate>
115ecf: 89 45 e4 mov %eax,-0x1c(%ebp)
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
115ed2: 83 c4 10 add $0x10,%esp
115ed5: 85 c0 test %eax,%eax
115ed7: 8b 55 e0 mov -0x20(%ebp),%edx
115eda: 74 58 je 115f34 <rtems_partition_create+0xf0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
115edc: 8b 45 e4 mov -0x1c(%ebp),%eax
115edf: 89 70 10 mov %esi,0x10(%eax)
the_partition->length = length;
115ee2: 89 50 14 mov %edx,0x14(%eax)
the_partition->buffer_size = buffer_size;
115ee5: 89 78 18 mov %edi,0x18(%eax)
the_partition->attribute_set = attribute_set;
115ee8: 8b 4d 18 mov 0x18(%ebp),%ecx
115eeb: 89 48 1c mov %ecx,0x1c(%eax)
the_partition->number_of_used_blocks = 0;
115eee: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax)
_Chain_Initialize( &the_partition->Memory, starting_address,
115ef5: 57 push %edi
115ef6: 89 d0 mov %edx,%eax
115ef8: 31 d2 xor %edx,%edx
115efa: f7 f7 div %edi
115efc: 50 push %eax
115efd: 56 push %esi
115efe: 8b 45 e4 mov -0x1c(%ebp),%eax
115f01: 83 c0 24 add $0x24,%eax
115f04: 50 push %eax
115f05: e8 36 2f 00 00 call 118e40 <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
115f0a: 8b 7d e4 mov -0x1c(%ebp),%edi
115f0d: 8b 47 08 mov 0x8(%edi),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
115f10: 0f b7 f0 movzwl %ax,%esi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
115f13: 8b 15 9c 07 14 00 mov 0x14079c,%edx
115f19: 89 3c b2 mov %edi,(%edx,%esi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
115f1c: 89 5f 0c mov %ebx,0xc(%edi)
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
115f1f: 8b 55 1c mov 0x1c(%ebp),%edx
115f22: 89 02 mov %eax,(%edx)
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
115f24: e8 eb 53 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115f29: 83 c4 10 add $0x10,%esp
115f2c: 31 c0 xor %eax,%eax
115f2e: e9 66 ff ff ff jmp 115e99 <rtems_partition_create+0x55>
115f33: 90 nop
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
_Thread_Enable_dispatch();
115f34: e8 db 53 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
115f39: b8 05 00 00 00 mov $0x5,%eax
115f3e: e9 56 ff ff ff jmp 115e99 <rtems_partition_create+0x55>
00115fb0 <rtems_partition_get_buffer>:
rtems_status_code rtems_partition_get_buffer(
rtems_id id,
void **buffer
)
{
115fb0: 55 push %ebp
115fb1: 89 e5 mov %esp,%ebp
115fb3: 56 push %esi
115fb4: 53 push %ebx
115fb5: 83 ec 20 sub $0x20,%esp
115fb8: 8b 5d 0c mov 0xc(%ebp),%ebx
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
115fbb: 85 db test %ebx,%ebx
115fbd: 74 59 je 116018 <rtems_partition_get_buffer+0x68><== NEVER TAKEN
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
_Objects_Get( &_Partition_Information, id, location );
115fbf: 52 push %edx
return RTEMS_INVALID_ADDRESS;
the_partition = _Partition_Get( id, &location );
115fc0: 8d 45 f4 lea -0xc(%ebp),%eax
115fc3: 50 push %eax
115fc4: ff 75 08 pushl 0x8(%ebp)
115fc7: 68 80 07 14 00 push $0x140780
115fcc: e8 f3 47 00 00 call 11a7c4 <_Objects_Get>
115fd1: 89 c6 mov %eax,%esi
switch ( location ) {
115fd3: 83 c4 10 add $0x10,%esp
115fd6: 8b 45 f4 mov -0xc(%ebp),%eax
115fd9: 85 c0 test %eax,%eax
115fdb: 75 2f jne 11600c <rtems_partition_get_buffer+0x5c><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer (
Partition_Control *the_partition
)
{
return _Chain_Get( &the_partition->Memory );
115fdd: 83 ec 0c sub $0xc,%esp
115fe0: 8d 46 24 lea 0x24(%esi),%eax
115fe3: 50 push %eax
115fe4: e8 33 2e 00 00 call 118e1c <_Chain_Get>
case OBJECTS_LOCAL:
the_buffer = _Partition_Allocate_buffer( the_partition );
if ( the_buffer ) {
115fe9: 83 c4 10 add $0x10,%esp
115fec: 85 c0 test %eax,%eax
115fee: 74 34 je 116024 <rtems_partition_get_buffer+0x74>
the_partition->number_of_used_blocks += 1;
115ff0: ff 46 20 incl 0x20(%esi)
_Thread_Enable_dispatch();
115ff3: 89 45 e4 mov %eax,-0x1c(%ebp)
115ff6: e8 19 53 00 00 call 11b314 <_Thread_Enable_dispatch>
*buffer = the_buffer;
115ffb: 8b 45 e4 mov -0x1c(%ebp),%eax
115ffe: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
116000: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116002: 8d 65 f8 lea -0x8(%ebp),%esp
116005: 5b pop %ebx
116006: 5e pop %esi
116007: c9 leave
116008: c3 ret
116009: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11600c: b8 04 00 00 00 mov $0x4,%eax
}
116011: 8d 65 f8 lea -0x8(%ebp),%esp
116014: 5b pop %ebx
116015: 5e pop %esi
116016: c9 leave
116017: c3 ret
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
116018: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11601d: 8d 65 f8 lea -0x8(%ebp),%esp
116020: 5b pop %ebx
116021: 5e pop %esi
116022: c9 leave
116023: c3 ret
the_partition->number_of_used_blocks += 1;
_Thread_Enable_dispatch();
*buffer = the_buffer;
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
116024: e8 eb 52 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_UNSATISFIED;
116029: b8 0d 00 00 00 mov $0xd,%eax
11602e: eb e1 jmp 116011 <rtems_partition_get_buffer+0x61>
00116054 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
116054: 55 push %ebp
116055: 89 e5 mov %esp,%ebp
116057: 56 push %esi
116058: 53 push %ebx
116059: 83 ec 14 sub $0x14,%esp
11605c: 8b 75 0c mov 0xc(%ebp),%esi
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
11605f: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
_Objects_Get( &_Partition_Information, id, location );
116062: 50 push %eax
116063: ff 75 08 pushl 0x8(%ebp)
116066: 68 80 07 14 00 push $0x140780
11606b: e8 54 47 00 00 call 11a7c4 <_Objects_Get>
116070: 89 c3 mov %eax,%ebx
switch ( location ) {
116072: 83 c4 10 add $0x10,%esp
116075: 8b 45 f4 mov -0xc(%ebp),%eax
116078: 85 c0 test %eax,%eax
11607a: 74 0c je 116088 <rtems_partition_return_buffer+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11607c: b8 04 00 00 00 mov $0x4,%eax
}
116081: 8d 65 f8 lea -0x8(%ebp),%esp
116084: 5b pop %ebx
116085: 5e pop %esi
116086: c9 leave
116087: c3 ret
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
116088: 8b 43 10 mov 0x10(%ebx),%eax
ending = _Addresses_Add_offset( starting, the_partition->length );
11608b: 8b 53 14 mov 0x14(%ebx),%edx
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
11608e: 39 c6 cmp %eax,%esi
116090: 72 3a jb 1160cc <rtems_partition_return_buffer+0x78>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
116092: 8d 14 10 lea (%eax,%edx,1),%edx
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
116095: 39 d6 cmp %edx,%esi
116097: 77 33 ja 1160cc <rtems_partition_return_buffer+0x78><== NEVER TAKEN
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (
const void *left,
const void *right
)
{
return (int32_t) ((const char *) left - (const char *) right);
116099: 89 f2 mov %esi,%edx
11609b: 29 c2 sub %eax,%edx
11609d: 89 d0 mov %edx,%eax
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
11609f: 31 d2 xor %edx,%edx
1160a1: f7 73 18 divl 0x18(%ebx)
starting = the_partition->starting_address;
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
1160a4: 85 d2 test %edx,%edx
1160a6: 75 24 jne 1160cc <rtems_partition_return_buffer+0x78>
RTEMS_INLINE_ROUTINE void _Partition_Free_buffer (
Partition_Control *the_partition,
Chain_Node *the_buffer
)
{
_Chain_Append( &the_partition->Memory, the_buffer );
1160a8: 83 ec 08 sub $0x8,%esp
1160ab: 56 push %esi
1160ac: 8d 43 24 lea 0x24(%ebx),%eax
1160af: 50 push %eax
1160b0: e8 2b 2d 00 00 call 118de0 <_Chain_Append>
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
1160b5: ff 4b 20 decl 0x20(%ebx)
_Thread_Enable_dispatch();
1160b8: e8 57 52 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1160bd: 83 c4 10 add $0x10,%esp
1160c0: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1160c2: 8d 65 f8 lea -0x8(%ebp),%esp
1160c5: 5b pop %ebx
1160c6: 5e pop %esi
1160c7: c9 leave
1160c8: c3 ret
1160c9: 8d 76 00 lea 0x0(%esi),%esi
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
1160cc: e8 43 52 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
1160d1: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1160d6: 8d 65 f8 lea -0x8(%ebp),%esp
1160d9: 5b pop %ebx
1160da: 5e pop %esi
1160db: c9 leave
1160dc: c3 ret
00115478 <rtems_port_create>:
void *internal_start,
void *external_start,
uint32_t length,
rtems_id *id
)
{
115478: 55 push %ebp
115479: 89 e5 mov %esp,%ebp
11547b: 57 push %edi
11547c: 56 push %esi
11547d: 53 push %ebx
11547e: 83 ec 1c sub $0x1c,%esp
115481: 8b 5d 08 mov 0x8(%ebp),%ebx
115484: 8b 55 0c mov 0xc(%ebp),%edx
115487: 8b 7d 10 mov 0x10(%ebp),%edi
11548a: 8b 75 18 mov 0x18(%ebp),%esi
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
11548d: 85 db test %ebx,%ebx
11548f: 74 1b je 1154ac <rtems_port_create+0x34>
return RTEMS_INVALID_NAME;
if ( !id )
115491: 85 f6 test %esi,%esi
115493: 74 08 je 11549d <rtems_port_create+0x25>
* id - port id
* RTEMS_SUCCESSFUL - if successful
* error code - if unsuccessful
*/
rtems_status_code rtems_port_create(
115495: 89 f8 mov %edi,%eax
115497: 09 d0 or %edx,%eax
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( internal_start ) ||
115499: a8 03 test $0x3,%al
11549b: 74 1f je 1154bc <rtems_port_create+0x44>
!_Addresses_Is_aligned( external_start ) )
return RTEMS_INVALID_ADDRESS;
11549d: b8 09 00 00 00 mov $0x9,%eax
);
*id = the_port->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
1154a2: 8d 65 f4 lea -0xc(%ebp),%esp
1154a5: 5b pop %ebx
1154a6: 5e pop %esi
1154a7: 5f pop %edi
1154a8: c9 leave
1154a9: c3 ret
1154aa: 66 90 xchg %ax,%ax
)
{
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
1154ac: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_port->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
1154b1: 8d 65 f4 lea -0xc(%ebp),%esp
1154b4: 5b pop %ebx
1154b5: 5e pop %esi
1154b6: 5f pop %edi
1154b7: c9 leave
1154b8: c3 ret
1154b9: 8d 76 00 lea 0x0(%esi),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
1154bc: a1 ec 08 14 00 mov 0x1408ec,%eax
1154c1: 40 inc %eax
1154c2: a3 ec 08 14 00 mov %eax,0x1408ec
*/
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control
*_Dual_ported_memory_Allocate ( void )
{
return (Dual_ported_memory_Control *)
_Objects_Allocate( &_Dual_ported_memory_Information );
1154c7: 83 ec 0c sub $0xc,%esp
1154ca: 68 40 07 14 00 push $0x140740
1154cf: 89 55 e4 mov %edx,-0x1c(%ebp)
1154d2: e8 fd 4d 00 00 call 11a2d4 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
1154d7: 83 c4 10 add $0x10,%esp
1154da: 85 c0 test %eax,%eax
1154dc: 8b 55 e4 mov -0x1c(%ebp),%edx
1154df: 74 33 je 115514 <rtems_port_create+0x9c>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
1154e1: 89 50 10 mov %edx,0x10(%eax)
the_port->external_base = external_start;
1154e4: 89 78 14 mov %edi,0x14(%eax)
the_port->length = length - 1;
1154e7: 8b 55 14 mov 0x14(%ebp),%edx
1154ea: 4a dec %edx
1154eb: 89 50 18 mov %edx,0x18(%eax)
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
1154ee: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
1154f1: 0f b7 fa movzwl %dx,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
1154f4: 8b 0d 5c 07 14 00 mov 0x14075c,%ecx
1154fa: 89 04 b9 mov %eax,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
1154fd: 89 58 0c mov %ebx,0xc(%eax)
&_Dual_ported_memory_Information,
&the_port->Object,
(Objects_Name) name
);
*id = the_port->Object.id;
115500: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
115502: e8 0d 5e 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115507: 31 c0 xor %eax,%eax
}
115509: 8d 65 f4 lea -0xc(%ebp),%esp
11550c: 5b pop %ebx
11550d: 5e pop %esi
11550e: 5f pop %edi
11550f: c9 leave
115510: c3 ret
115511: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
_Thread_Enable_dispatch();
115514: e8 fb 5d 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
115519: b8 05 00 00 00 mov $0x5,%eax
11551e: eb 82 jmp 1154a2 <rtems_port_create+0x2a>
00115520 <rtems_port_delete>:
*/
rtems_status_code rtems_port_delete(
rtems_id id
)
{
115520: 55 push %ebp
115521: 89 e5 mov %esp,%ebp
115523: 83 ec 2c sub $0x2c,%esp
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
the_port = _Dual_ported_memory_Get( id, &location );
115526: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Dual_ported_memory_Control *)
_Objects_Get( &_Dual_ported_memory_Information, id, location );
115529: 50 push %eax
11552a: ff 75 08 pushl 0x8(%ebp)
11552d: 68 40 07 14 00 push $0x140740
115532: e8 8d 52 00 00 call 11a7c4 <_Objects_Get>
switch ( location ) {
115537: 83 c4 10 add $0x10,%esp
11553a: 8b 4d f4 mov -0xc(%ebp),%ecx
11553d: 85 c9 test %ecx,%ecx
11553f: 75 2f jne 115570 <rtems_port_delete+0x50>
case OBJECTS_LOCAL:
_Objects_Close( &_Dual_ported_memory_Information, &the_port->Object );
115541: 83 ec 08 sub $0x8,%esp
115544: 50 push %eax
115545: 68 40 07 14 00 push $0x140740
11554a: 89 45 e4 mov %eax,-0x1c(%ebp)
11554d: e8 fe 4d 00 00 call 11a350 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Dual_ported_memory_Free (
Dual_ported_memory_Control *the_port
)
{
_Objects_Free( &_Dual_ported_memory_Information, &the_port->Object );
115552: 58 pop %eax
115553: 5a pop %edx
115554: 8b 45 e4 mov -0x1c(%ebp),%eax
115557: 50 push %eax
115558: 68 40 07 14 00 push $0x140740
11555d: e8 e6 50 00 00 call 11a648 <_Objects_Free>
_Dual_ported_memory_Free( the_port );
_Thread_Enable_dispatch();
115562: e8 ad 5d 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115567: 83 c4 10 add $0x10,%esp
11556a: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11556c: c9 leave
11556d: c3 ret
11556e: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115570: b8 04 00 00 00 mov $0x4,%eax
}
115575: c9 leave
115576: c3 ret
00115578 <rtems_port_external_to_internal>:
rtems_status_code rtems_port_external_to_internal(
rtems_id id,
void *external,
void **internal
)
{
115578: 55 push %ebp
115579: 89 e5 mov %esp,%ebp
11557b: 56 push %esi
11557c: 53 push %ebx
11557d: 83 ec 10 sub $0x10,%esp
115580: 8b 75 0c mov 0xc(%ebp),%esi
115583: 8b 5d 10 mov 0x10(%ebp),%ebx
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !internal )
115586: 85 db test %ebx,%ebx
115588: 74 4e je 1155d8 <rtems_port_external_to_internal+0x60>
Objects_Id id,
Objects_Locations *location
)
{
return (Dual_ported_memory_Control *)
_Objects_Get( &_Dual_ported_memory_Information, id, location );
11558a: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
11558b: 8d 45 f4 lea -0xc(%ebp),%eax
11558e: 50 push %eax
11558f: ff 75 08 pushl 0x8(%ebp)
115592: 68 40 07 14 00 push $0x140740
115597: e8 28 52 00 00 call 11a7c4 <_Objects_Get>
switch ( location ) {
11559c: 83 c4 10 add $0x10,%esp
11559f: 8b 55 f4 mov -0xc(%ebp),%edx
1155a2: 85 d2 test %edx,%edx
1155a4: 74 0e je 1155b4 <rtems_port_external_to_internal+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1155a6: b8 04 00 00 00 mov $0x4,%eax
}
1155ab: 8d 65 f8 lea -0x8(%ebp),%esp
1155ae: 5b pop %ebx
1155af: 5e pop %esi
1155b0: c9 leave
1155b1: c3 ret
1155b2: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (
const void *left,
const void *right
)
{
return (int32_t) ((const char *) left - (const char *) right);
1155b4: 89 f2 mov %esi,%edx
1155b6: 2b 50 14 sub 0x14(%eax),%edx
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( external, the_port->external_base );
if ( ending > the_port->length )
1155b9: 3b 50 18 cmp 0x18(%eax),%edx
1155bc: 77 16 ja 1155d4 <rtems_port_external_to_internal+0x5c>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
1155be: 03 50 10 add 0x10(%eax),%edx
1155c1: 89 13 mov %edx,(%ebx)
*internal = external;
else
*internal = _Addresses_Add_offset( the_port->internal_base,
ending );
_Thread_Enable_dispatch();
1155c3: e8 4c 5d 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1155c8: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1155ca: 8d 65 f8 lea -0x8(%ebp),%esp
1155cd: 5b pop %ebx
1155ce: 5e pop %esi
1155cf: c9 leave
1155d0: c3 ret
1155d1: 8d 76 00 lea 0x0(%esi),%esi
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( external, the_port->external_base );
if ( ending > the_port->length )
*internal = external;
1155d4: 89 33 mov %esi,(%ebx)
1155d6: eb eb jmp 1155c3 <rtems_port_external_to_internal+0x4b>
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !internal )
return RTEMS_INVALID_ADDRESS;
1155d8: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1155dd: 8d 65 f8 lea -0x8(%ebp),%esp
1155e0: 5b pop %ebx
1155e1: 5e pop %esi
1155e2: c9 leave
1155e3: c3 ret
00115608 <rtems_port_internal_to_external>:
rtems_status_code rtems_port_internal_to_external(
rtems_id id,
void *internal,
void **external
)
{
115608: 55 push %ebp
115609: 89 e5 mov %esp,%ebp
11560b: 56 push %esi
11560c: 53 push %ebx
11560d: 83 ec 10 sub $0x10,%esp
115610: 8b 75 0c mov 0xc(%ebp),%esi
115613: 8b 5d 10 mov 0x10(%ebp),%ebx
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
115616: 85 db test %ebx,%ebx
115618: 74 4e je 115668 <rtems_port_internal_to_external+0x60>
11561a: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
11561b: 8d 45 f4 lea -0xc(%ebp),%eax
11561e: 50 push %eax
11561f: ff 75 08 pushl 0x8(%ebp)
115622: 68 40 07 14 00 push $0x140740
115627: e8 98 51 00 00 call 11a7c4 <_Objects_Get>
switch ( location ) {
11562c: 83 c4 10 add $0x10,%esp
11562f: 8b 55 f4 mov -0xc(%ebp),%edx
115632: 85 d2 test %edx,%edx
115634: 74 0e je 115644 <rtems_port_internal_to_external+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115636: b8 04 00 00 00 mov $0x4,%eax
}
11563b: 8d 65 f8 lea -0x8(%ebp),%esp
11563e: 5b pop %ebx
11563f: 5e pop %esi
115640: c9 leave
115641: c3 ret
115642: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract (
const void *left,
const void *right
)
{
return (int32_t) ((const char *) left - (const char *) right);
115644: 89 f2 mov %esi,%edx
115646: 2b 50 10 sub 0x10(%eax),%edx
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( internal, the_port->internal_base );
if ( ending > the_port->length )
115649: 3b 50 18 cmp 0x18(%eax),%edx
11564c: 77 16 ja 115664 <rtems_port_internal_to_external+0x5c>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
11564e: 03 50 14 add 0x14(%eax),%edx
115651: 89 13 mov %edx,(%ebx)
*external = internal;
else
*external = _Addresses_Add_offset( the_port->external_base,
ending );
_Thread_Enable_dispatch();
115653: e8 bc 5c 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115658: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11565a: 8d 65 f8 lea -0x8(%ebp),%esp
11565d: 5b pop %ebx
11565e: 5e pop %esi
11565f: c9 leave
115660: c3 ret
115661: 8d 76 00 lea 0x0(%esi),%esi
switch ( location ) {
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( internal, the_port->internal_base );
if ( ending > the_port->length )
*external = internal;
115664: 89 33 mov %esi,(%ebx)
115666: eb eb jmp 115653 <rtems_port_internal_to_external+0x4b>
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
return RTEMS_INVALID_ADDRESS;
115668: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11566d: 8d 65 f8 lea -0x8(%ebp),%esp
115670: 5b pop %ebx
115671: 5e pop %esi
115672: c9 leave
115673: c3 ret
00106da0 <rtems_print_buffer>:
void rtems_print_buffer(
const unsigned char *buffer,
int length
)
{
106da0: 55 push %ebp
106da1: 89 e5 mov %esp,%ebp
106da3: 57 push %edi
106da4: 56 push %esi
106da5: 53 push %ebx
106da6: 81 ec 9c 00 00 00 sub $0x9c,%esp
106dac: 8b 75 0c mov 0xc(%ebp),%esi
int i, mod, max;
if ( !length ) return;
106daf: 85 f6 test %esi,%esi
106db1: 0f 84 00 01 00 00 je 106eb7 <rtems_print_buffer+0x117>
mod = length % 16;
106db7: 89 f0 mov %esi,%eax
106db9: 25 0f 00 00 80 and $0x8000000f,%eax
106dbe: 89 85 60 ff ff ff mov %eax,-0xa0(%ebp)
106dc4: 0f 88 21 02 00 00 js 106feb <rtems_print_buffer+0x24b>
106dca: 8b 85 60 ff ff ff mov -0xa0(%ebp),%eax
106dd0: 89 85 58 ff ff ff mov %eax,-0xa8(%ebp)
max = length - mod;
106dd6: 29 c6 sub %eax,%esi
106dd8: 89 b5 5c ff ff ff mov %esi,-0xa4(%ebp)
for ( i=0 ; i<max ; i+=16 )
106dde: 85 f6 test %esi,%esi
106de0: 0f 8e c7 00 00 00 jle 106ead <rtems_print_buffer+0x10d>
106de6: c7 85 64 ff ff ff 00 movl $0x0,-0x9c(%ebp)
106ded: 00 00 00
106df0: 8d 9d 70 ff ff ff lea -0x90(%ebp),%ebx
106df6: 66 90 xchg %ax,%ax
static inline void Dump_Line(
const unsigned char *buffer,
int length
);
void rtems_print_buffer(
106df8: 8b 75 08 mov 0x8(%ebp),%esi
106dfb: 03 b5 64 ff ff ff add -0x9c(%ebp),%esi
{
int i;
char line_buffer[120];
line_buffer[0] = '\0';
106e01: c6 85 70 ff ff ff 00 movb $0x0,-0x90(%ebp)
for( i=0 ; i<length ; i++ )
106e08: 31 ff xor %edi,%edi
106e0a: 66 90 xchg %ax,%ax
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
106e0c: 0f b6 04 3e movzbl (%esi,%edi,1),%eax
106e10: 50 push %eax
106e11: 53 push %ebx
106e12: 68 b3 fd 11 00 push $0x11fdb3
106e17: 53 push %ebx
106e18: e8 27 bb 00 00 call 112944 <sprintf>
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
106e1d: 47 inc %edi
106e1e: 83 c4 10 add $0x10,%esp
106e21: 83 ff 10 cmp $0x10,%edi
106e24: 75 e6 jne 106e0c <rtems_print_buffer+0x6c>
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
106e26: 31 c0 xor %eax,%eax
106e28: b9 ff ff ff ff mov $0xffffffff,%ecx
106e2d: 89 df mov %ebx,%edi
106e2f: f2 ae repnz scas %es:(%edi),%al
106e31: f7 d1 not %ecx
106e33: 66 c7 44 0b ff 7c 00 movw $0x7c,-0x1(%ebx,%ecx,1)
for( i=0 ; i<length ; i++ )
106e3a: 31 ff xor %edi,%edi
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
106e3c: 0f b6 04 3e movzbl (%esi,%edi,1),%eax
106e40: 8b 15 54 43 12 00 mov 0x124354,%edx
106e46: 0f be 54 02 01 movsbl 0x1(%edx,%eax,1),%edx
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%c", line_buffer,
106e4b: 81 e2 97 00 00 00 and $0x97,%edx
106e51: 75 05 jne 106e58 <rtems_print_buffer+0xb8>
106e53: b8 2e 00 00 00 mov $0x2e,%eax
106e58: 50 push %eax
106e59: 53 push %ebx
106e5a: 68 bb fd 11 00 push $0x11fdbb
106e5f: 53 push %ebx
106e60: e8 df ba 00 00 call 112944 <sprintf>
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
106e65: 47 inc %edi
106e66: 83 c4 10 add $0x10,%esp
106e69: 83 ff 10 cmp $0x10,%edi
106e6c: 75 ce jne 106e3c <rtems_print_buffer+0x9c>
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|\n" );
106e6e: 31 c0 xor %eax,%eax
106e70: b9 ff ff ff ff mov $0xffffffff,%ecx
106e75: 89 df mov %ebx,%edi
106e77: f2 ae repnz scas %es:(%edi),%al
106e79: f7 d1 not %ecx
106e7b: 8d 44 0b ff lea -0x1(%ebx,%ecx,1),%eax
106e7f: 66 c7 00 7c 0a movw $0xa7c,(%eax)
106e84: c6 40 02 00 movb $0x0,0x2(%eax)
printk( line_buffer );
106e88: 83 ec 0c sub $0xc,%esp
106e8b: 53 push %ebx
106e8c: e8 3f 18 00 00 call 1086d0 <printk>
mod = length % 16;
max = length - mod;
for ( i=0 ; i<max ; i+=16 )
106e91: 83 85 64 ff ff ff 10 addl $0x10,-0x9c(%ebp)
106e98: 83 c4 10 add $0x10,%esp
106e9b: 8b 85 64 ff ff ff mov -0x9c(%ebp),%eax
106ea1: 39 85 5c ff ff ff cmp %eax,-0xa4(%ebp)
106ea7: 0f 8f 4b ff ff ff jg 106df8 <rtems_print_buffer+0x58>
Dump_Line( &buffer[ i ], 16 );
if ( mod )
106ead: 8b 8d 60 ff ff ff mov -0xa0(%ebp),%ecx
106eb3: 85 c9 test %ecx,%ecx
106eb5: 75 08 jne 106ebf <rtems_print_buffer+0x11f>
Dump_Line( &buffer[ max ], mod );
}
106eb7: 8d 65 f4 lea -0xc(%ebp),%esp
106eba: 5b pop %ebx
106ebb: 5e pop %esi
106ebc: 5f pop %edi
106ebd: c9 leave
106ebe: c3 ret
for ( i=0 ; i<max ; i+=16 )
Dump_Line( &buffer[ i ], 16 );
if ( mod )
Dump_Line( &buffer[ max ], mod );
106ebf: 8b 75 08 mov 0x8(%ebp),%esi
106ec2: 03 b5 5c ff ff ff add -0xa4(%ebp),%esi
{
int i;
char line_buffer[120];
line_buffer[0] = '\0';
106ec8: c6 85 70 ff ff ff 00 movb $0x0,-0x90(%ebp)
for( i=0 ; i<length ; i++ )
106ecf: 8b 95 60 ff ff ff mov -0xa0(%ebp),%edx
106ed5: 85 d2 test %edx,%edx
106ed7: 0f 8e 2a 01 00 00 jle 107007 <rtems_print_buffer+0x267><== NEVER TAKEN
106edd: 31 ff xor %edi,%edi
106edf: 8d 9d 70 ff ff ff lea -0x90(%ebp),%ebx
106ee5: 8d 76 00 lea 0x0(%esi),%esi
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
106ee8: 0f b6 04 3e movzbl (%esi,%edi,1),%eax
106eec: 50 push %eax
106eed: 53 push %ebx
106eee: 68 b3 fd 11 00 push $0x11fdb3
106ef3: 53 push %ebx
106ef4: e8 4b ba 00 00 call 112944 <sprintf>
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
106ef9: 47 inc %edi
106efa: 83 c4 10 add $0x10,%esp
106efd: 39 bd 60 ff ff ff cmp %edi,-0xa0(%ebp)
106f03: 7f e3 jg 106ee8 <rtems_print_buffer+0x148>
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
106f05: 83 bd 60 ff ff ff 0f cmpl $0xf,-0xa0(%ebp)
106f0c: 0f 8f 02 01 00 00 jg 107014 <rtems_print_buffer+0x274><== NEVER TAKEN
106f12: 8b 95 60 ff ff ff mov -0xa0(%ebp),%edx
strcat( line_buffer, " " );
106f18: 31 c0 xor %eax,%eax
106f1a: 66 90 xchg %ax,%ax
106f1c: b9 ff ff ff ff mov $0xffffffff,%ecx
106f21: 89 df mov %ebx,%edi
106f23: f2 ae repnz scas %es:(%edi),%al
106f25: f7 d1 not %ecx
106f27: c7 44 0b ff 20 20 20 movl $0x202020,-0x1(%ebx,%ecx,1)
106f2e: 00
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
106f2f: 42 inc %edx
106f30: 83 fa 0f cmp $0xf,%edx
106f33: 7e e7 jle 106f1c <rtems_print_buffer+0x17c>
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
106f35: 31 c0 xor %eax,%eax
106f37: b9 ff ff ff ff mov $0xffffffff,%ecx
106f3c: 89 df mov %ebx,%edi
106f3e: f2 ae repnz scas %es:(%edi),%al
106f40: f7 d1 not %ecx
106f42: 66 c7 44 0b ff 7c 00 movw $0x7c,-0x1(%ebx,%ecx,1)
for( i=0 ; i<length ; i++ )
106f49: 8b 85 60 ff ff ff mov -0xa0(%ebp),%eax
106f4f: 85 c0 test %eax,%eax
106f51: 0f 8e a4 00 00 00 jle 106ffb <rtems_print_buffer+0x25b>
106f57: 31 ff xor %edi,%edi
106f59: 8d 76 00 lea 0x0(%esi),%esi
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
106f5c: 0f b6 04 3e movzbl (%esi,%edi,1),%eax
106f60: 8b 15 54 43 12 00 mov 0x124354,%edx
106f66: 0f be 54 02 01 movsbl 0x1(%edx,%eax,1),%edx
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%c", line_buffer,
106f6b: 81 e2 97 00 00 00 and $0x97,%edx
106f71: 75 05 jne 106f78 <rtems_print_buffer+0x1d8>
106f73: b8 2e 00 00 00 mov $0x2e,%eax
106f78: 50 push %eax
106f79: 53 push %ebx
106f7a: 68 bb fd 11 00 push $0x11fdbb
106f7f: 53 push %ebx
106f80: e8 bf b9 00 00 call 112944 <sprintf>
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
106f85: 47 inc %edi
106f86: 83 c4 10 add $0x10,%esp
106f89: 39 bd 60 ff ff ff cmp %edi,-0xa0(%ebp)
106f8f: 7f cb jg 106f5c <rtems_print_buffer+0x1bc>
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
for( ; i<16 ; i++ )
106f91: 83 bd 60 ff ff ff 0f cmpl $0xf,-0xa0(%ebp)
106f98: 7f 23 jg 106fbd <rtems_print_buffer+0x21d><== NEVER TAKEN
strcat( line_buffer, " " );
106f9a: ba ff ff ff ff mov $0xffffffff,%edx
106f9f: 31 c0 xor %eax,%eax
106fa1: 8b b5 58 ff ff ff mov -0xa8(%ebp),%esi
106fa7: 90 nop
106fa8: 89 d1 mov %edx,%ecx
106faa: 89 df mov %ebx,%edi
106fac: f2 ae repnz scas %es:(%edi),%al
106fae: f7 d1 not %ecx
106fb0: 66 c7 44 0b ff 20 00 movw $0x20,-0x1(%ebx,%ecx,1)
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
for( ; i<16 ; i++ )
106fb7: 46 inc %esi
106fb8: 83 fe 0f cmp $0xf,%esi
106fbb: 7e eb jle 106fa8 <rtems_print_buffer+0x208>
strcat( line_buffer, " " );
strcat( line_buffer, "|\n" );
106fbd: 31 c0 xor %eax,%eax
106fbf: b9 ff ff ff ff mov $0xffffffff,%ecx
106fc4: 89 df mov %ebx,%edi
106fc6: f2 ae repnz scas %es:(%edi),%al
106fc8: f7 d1 not %ecx
106fca: 8d 44 0b ff lea -0x1(%ebx,%ecx,1),%eax
106fce: 66 c7 00 7c 0a movw $0xa7c,(%eax)
106fd3: c6 40 02 00 movb $0x0,0x2(%eax)
printk( line_buffer );
106fd7: 83 ec 0c sub $0xc,%esp
106fda: 53 push %ebx
106fdb: e8 f0 16 00 00 call 1086d0 <printk>
106fe0: 83 c4 10 add $0x10,%esp
for ( i=0 ; i<max ; i+=16 )
Dump_Line( &buffer[ i ], 16 );
if ( mod )
Dump_Line( &buffer[ max ], mod );
}
106fe3: 8d 65 f4 lea -0xc(%ebp),%esp
106fe6: 5b pop %ebx
106fe7: 5e pop %esi
106fe8: 5f pop %edi
106fe9: c9 leave
106fea: c3 ret
int i, mod, max;
if ( !length ) return;
mod = length % 16;
106feb: 48 dec %eax
106fec: 83 c8 f0 or $0xfffffff0,%eax
106fef: 40 inc %eax
106ff0: 89 85 60 ff ff ff mov %eax,-0xa0(%ebp)
106ff6: e9 cf fd ff ff jmp 106dca <rtems_print_buffer+0x2a>
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
106ffb: c7 85 58 ff ff ff 00 movl $0x0,-0xa8(%ebp)
107002: 00 00 00
107005: eb 93 jmp 106f9a <rtems_print_buffer+0x1fa>
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
107007: 31 d2 xor %edx,%edx
107009: 8d 9d 70 ff ff ff lea -0x90(%ebp),%ebx
10700f: e9 04 ff ff ff jmp 106f18 <rtems_print_buffer+0x178>
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
107014: 31 c0 xor %eax,%eax
107016: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED
107019: 89 df mov %ebx,%edi <== NOT EXECUTED
10701b: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED
10701d: f7 d1 not %ecx <== NOT EXECUTED
10701f: 66 c7 44 0b ff 7c 00 movw $0x7c,-0x1(%ebx,%ecx,1) <== NOT EXECUTED
107026: e9 2c ff ff ff jmp 106f57 <rtems_print_buffer+0x1b7><== NOT EXECUTED
001160e0 <rtems_rate_monotonic_cancel>:
*/
rtems_status_code rtems_rate_monotonic_cancel(
rtems_id id
)
{
1160e0: 55 push %ebp
1160e1: 89 e5 mov %esp,%ebp
1160e3: 53 push %ebx
1160e4: 83 ec 18 sub $0x18,%esp
Rate_monotonic_Control *the_period;
Objects_Locations location;
the_period = _Rate_monotonic_Get( id, &location );
1160e7: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
1160ea: 50 push %eax
1160eb: ff 75 08 pushl 0x8(%ebp)
1160ee: 68 c0 07 14 00 push $0x1407c0
1160f3: e8 cc 46 00 00 call 11a7c4 <_Objects_Get>
1160f8: 89 c3 mov %eax,%ebx
switch ( location ) {
1160fa: 83 c4 10 add $0x10,%esp
1160fd: 8b 45 f4 mov -0xc(%ebp),%eax
116100: 85 c0 test %eax,%eax
116102: 74 0c je 116110 <rtems_rate_monotonic_cancel+0x30>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
116104: b8 04 00 00 00 mov $0x4,%eax
}
116109: 8b 5d fc mov -0x4(%ebp),%ebx
11610c: c9 leave
11610d: c3 ret
11610e: 66 90 xchg %ax,%ax
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
116110: a1 78 0b 14 00 mov 0x140b78,%eax
116115: 39 43 40 cmp %eax,0x40(%ebx)
116118: 74 12 je 11612c <rtems_rate_monotonic_cancel+0x4c>
_Thread_Enable_dispatch();
11611a: e8 f5 51 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
11611f: b8 17 00 00 00 mov $0x17,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116124: 8b 5d fc mov -0x4(%ebp),%ebx
116127: c9 leave
116128: c3 ret
116129: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
(void) _Watchdog_Remove( &the_period->Timer );
11612c: 83 ec 0c sub $0xc,%esp
11612f: 8d 43 10 lea 0x10(%ebx),%eax
116132: 50 push %eax
116133: e8 3c 62 00 00 call 11c374 <_Watchdog_Remove>
the_period->state = RATE_MONOTONIC_INACTIVE;
116138: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx)
_Thread_Enable_dispatch();
11613f: e8 d0 51 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116144: 83 c4 10 add $0x10,%esp
116147: 31 c0 xor %eax,%eax
116149: eb be jmp 116109 <rtems_rate_monotonic_cancel+0x29>
0010b828 <rtems_rate_monotonic_create>:
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
rtems_id *id
)
{
10b828: 55 push %ebp
10b829: 89 e5 mov %esp,%ebp
10b82b: 57 push %edi
10b82c: 56 push %esi
10b82d: 53 push %ebx
10b82e: 83 ec 1c sub $0x1c,%esp
10b831: 8b 5d 08 mov 0x8(%ebp),%ebx
10b834: 8b 75 0c mov 0xc(%ebp),%esi
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
10b837: 85 db test %ebx,%ebx
10b839: 0f 84 a9 00 00 00 je 10b8e8 <rtems_rate_monotonic_create+0xc0>
return RTEMS_INVALID_NAME;
if ( !id )
10b83f: 85 f6 test %esi,%esi
10b841: 0f 84 c5 00 00 00 je 10b90c <rtems_rate_monotonic_create+0xe4>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b847: a1 8c 85 12 00 mov 0x12858c,%eax
10b84c: 40 inc %eax
10b84d: a3 8c 85 12 00 mov %eax,0x12858c
* the inactive chain of free period control blocks.
*/
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void )
{
return (Rate_monotonic_Control *)
_Objects_Allocate( &_Rate_monotonic_Information );
10b852: 83 ec 0c sub $0xc,%esp
10b855: 68 a0 84 12 00 push $0x1284a0
10b85a: e8 9d 1d 00 00 call 10d5fc <_Objects_Allocate>
10b85f: 89 c2 mov %eax,%edx
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
10b861: 83 c4 10 add $0x10,%esp
10b864: 85 c0 test %eax,%eax
10b866: 0f 84 8c 00 00 00 je 10b8f8 <rtems_rate_monotonic_create+0xd0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
10b86c: a1 18 88 12 00 mov 0x128818,%eax
10b871: 89 42 40 mov %eax,0x40(%edx)
the_period->state = RATE_MONOTONIC_INACTIVE;
10b874: c7 42 38 00 00 00 00 movl $0x0,0x38(%edx)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10b87b: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
10b882: c7 42 2c 00 00 00 00 movl $0x0,0x2c(%edx)
the_watchdog->id = id;
10b889: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx)
the_watchdog->user_data = user_data;
10b890: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
10b897: 8d 42 54 lea 0x54(%edx),%eax
10b89a: 89 45 e4 mov %eax,-0x1c(%ebp)
10b89d: b9 38 00 00 00 mov $0x38,%ecx
10b8a2: 31 c0 xor %eax,%eax
10b8a4: 8b 7d e4 mov -0x1c(%ebp),%edi
10b8a7: f3 aa rep stos %al,%es:(%edi)
10b8a9: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx)
10b8b0: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx)
10b8b7: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx)
10b8be: c7 42 78 ff ff ff 7f movl $0x7fffffff,0x78(%edx)
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10b8c5: 8b 42 08 mov 0x8(%edx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10b8c8: 0f b7 f8 movzwl %ax,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10b8cb: 8b 0d bc 84 12 00 mov 0x1284bc,%ecx
10b8d1: 89 14 b9 mov %edx,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10b8d4: 89 5a 0c mov %ebx,0xc(%edx)
&_Rate_monotonic_Information,
&the_period->Object,
(Objects_Name) name
);
*id = the_period->Object.id;
10b8d7: 89 06 mov %eax,(%esi)
_Thread_Enable_dispatch();
10b8d9: e8 f2 2d 00 00 call 10e6d0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b8de: 31 c0 xor %eax,%eax
}
10b8e0: 8d 65 f4 lea -0xc(%ebp),%esp
10b8e3: 5b pop %ebx
10b8e4: 5e pop %esi
10b8e5: 5f pop %edi
10b8e6: c9 leave
10b8e7: c3 ret
)
{
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10b8e8: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b8ed: 8d 65 f4 lea -0xc(%ebp),%esp
10b8f0: 5b pop %ebx
10b8f1: 5e pop %esi
10b8f2: 5f pop %edi
10b8f3: c9 leave
10b8f4: c3 ret
10b8f5: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
_Thread_Enable_dispatch();
10b8f8: e8 d3 2d 00 00 call 10e6d0 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
10b8fd: b8 05 00 00 00 mov $0x5,%eax
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b902: 8d 65 f4 lea -0xc(%ebp),%esp
10b905: 5b pop %ebx
10b906: 5e pop %esi
10b907: 5f pop %edi
10b908: c9 leave
10b909: c3 ret
10b90a: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10b90c: b8 09 00 00 00 mov $0x9,%eax
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b911: 8d 65 f4 lea -0xc(%ebp),%esp
10b914: 5b pop %ebx
10b915: 5e pop %esi
10b916: 5f pop %edi
10b917: c9 leave
10b918: c3 ret
00111648 <rtems_rate_monotonic_get_status>:
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
111648: 55 push %ebp
111649: 89 e5 mov %esp,%ebp
11164b: 53 push %ebx
11164c: 83 ec 24 sub $0x24,%esp
11164f: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
Rate_monotonic_Period_time_t since_last_period;
Rate_monotonic_Control *the_period;
bool valid_status;
if ( !status )
111652: 85 db test %ebx,%ebx
111654: 0f 84 92 00 00 00 je 1116ec <rtems_rate_monotonic_get_status+0xa4>
11165a: 50 push %eax
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
11165b: 8d 45 f4 lea -0xc(%ebp),%eax
11165e: 50 push %eax
11165f: ff 75 08 pushl 0x8(%ebp)
111662: 68 a0 84 12 00 push $0x1284a0
111667: e8 14 c5 ff ff call 10db80 <_Objects_Get>
switch ( location ) {
11166c: 83 c4 10 add $0x10,%esp
11166f: 8b 4d f4 mov -0xc(%ebp),%ecx
111672: 85 c9 test %ecx,%ecx
111674: 74 0a je 111680 <rtems_rate_monotonic_get_status+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
111676: b8 04 00 00 00 mov $0x4,%eax
}
11167b: 8b 5d fc mov -0x4(%ebp),%ebx
11167e: c9 leave
11167f: c3 ret
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
111680: 8b 50 40 mov 0x40(%eax),%edx
111683: 8b 52 08 mov 0x8(%edx),%edx
111686: 89 13 mov %edx,(%ebx)
status->state = the_period->state;
111688: 8b 50 38 mov 0x38(%eax),%edx
11168b: 89 53 04 mov %edx,0x4(%ebx)
/*
* If the period is inactive, there is no information.
*/
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
11168e: 85 d2 test %edx,%edx
111690: 75 2a jne 1116bc <rtems_rate_monotonic_get_status+0x74>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timespec_Set_to_zero( &status->since_last_period );
111692: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
111699: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
_Timespec_Set_to_zero( &status->executed_since_last_period );
1116a0: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
1116a7: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
status->since_last_period = since_last_period;
status->executed_since_last_period = executed;
#endif
}
_Thread_Enable_dispatch();
1116ae: e8 1d d0 ff ff call 10e6d0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1116b3: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1116b5: 8b 5d fc mov -0x4(%ebp),%ebx
1116b8: c9 leave
1116b9: c3 ret
1116ba: 66 90 xchg %ax,%ax
} else {
/*
* Grab the current status.
*/
valid_status =
1116bc: 52 push %edx
_Rate_monotonic_Get_status(
1116bd: 8d 55 ec lea -0x14(%ebp),%edx
} else {
/*
* Grab the current status.
*/
valid_status =
1116c0: 52 push %edx
_Rate_monotonic_Get_status(
1116c1: 8d 55 e4 lea -0x1c(%ebp),%edx
} else {
/*
* Grab the current status.
*/
valid_status =
1116c4: 52 push %edx
1116c5: 50 push %eax
1116c6: e8 75 a2 ff ff call 10b940 <_Rate_monotonic_Get_status>
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
1116cb: 83 c4 10 add $0x10,%esp
1116ce: 84 c0 test %al,%al
1116d0: 74 26 je 1116f8 <rtems_rate_monotonic_get_status+0xb0>
_Thread_Enable_dispatch();
return RTEMS_NOT_DEFINED;
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec(
1116d2: 8b 45 e4 mov -0x1c(%ebp),%eax
1116d5: 8b 55 e8 mov -0x18(%ebp),%edx
1116d8: 89 43 08 mov %eax,0x8(%ebx)
1116db: 89 53 0c mov %edx,0xc(%ebx)
&since_last_period, &status->since_last_period
);
_Timestamp_To_timespec(
1116de: 8b 45 ec mov -0x14(%ebp),%eax
1116e1: 8b 55 f0 mov -0x10(%ebp),%edx
1116e4: 89 43 10 mov %eax,0x10(%ebx)
1116e7: 89 53 14 mov %edx,0x14(%ebx)
1116ea: eb c2 jmp 1116ae <rtems_rate_monotonic_get_status+0x66>
Rate_monotonic_Period_time_t since_last_period;
Rate_monotonic_Control *the_period;
bool valid_status;
if ( !status )
return RTEMS_INVALID_ADDRESS;
1116ec: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1116f1: 8b 5d fc mov -0x4(%ebp),%ebx
1116f4: c9 leave
1116f5: c3 ret
1116f6: 66 90 xchg %ax,%ax
valid_status =
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
_Thread_Enable_dispatch();
1116f8: e8 d3 cf ff ff call 10e6d0 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
1116fd: b8 0b 00 00 00 mov $0xb,%eax
111702: e9 74 ff ff ff jmp 11167b <rtems_rate_monotonic_get_status+0x33>
0010bb3c <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
10bb3c: 55 push %ebp
10bb3d: 89 e5 mov %esp,%ebp
10bb3f: 57 push %edi
10bb40: 56 push %esi
10bb41: 53 push %ebx
10bb42: 83 ec 30 sub $0x30,%esp
10bb45: 8b 5d 08 mov 0x8(%ebp),%ebx
10bb48: 8b 75 0c mov 0xc(%ebp),%esi
Objects_Locations location;
rtems_status_code return_value;
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
10bb4b: 8d 45 e4 lea -0x1c(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
10bb4e: 50 push %eax
10bb4f: 53 push %ebx
10bb50: 68 a0 84 12 00 push $0x1284a0
10bb55: e8 26 20 00 00 call 10db80 <_Objects_Get>
switch ( location ) {
10bb5a: 83 c4 10 add $0x10,%esp
10bb5d: 8b 55 e4 mov -0x1c(%ebp),%edx
10bb60: 85 d2 test %edx,%edx
10bb62: 74 10 je 10bb74 <rtems_rate_monotonic_period+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10bb64: b8 04 00 00 00 mov $0x4,%eax
}
10bb69: 8d 65 f4 lea -0xc(%ebp),%esp
10bb6c: 5b pop %ebx
10bb6d: 5e pop %esi
10bb6e: 5f pop %edi
10bb6f: c9 leave
10bb70: c3 ret
10bb71: 8d 76 00 lea 0x0(%esi),%esi
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
10bb74: 8b 15 18 88 12 00 mov 0x128818,%edx
10bb7a: 39 50 40 cmp %edx,0x40(%eax)
10bb7d: 74 15 je 10bb94 <rtems_rate_monotonic_period+0x58>
_Thread_Enable_dispatch();
10bb7f: e8 4c 2b 00 00 call 10e6d0 <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
10bb84: b8 17 00 00 00 mov $0x17,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bb89: 8d 65 f4 lea -0xc(%ebp),%esp
10bb8c: 5b pop %ebx
10bb8d: 5e pop %esi
10bb8e: 5f pop %edi
10bb8f: c9 leave
10bb90: c3 ret
10bb91: 8d 76 00 lea 0x0(%esi),%esi
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
10bb94: 85 f6 test %esi,%esi
10bb96: 75 1c jne 10bbb4 <rtems_rate_monotonic_period+0x78>
switch ( the_period->state ) {
10bb98: 8b 40 38 mov 0x38(%eax),%eax
10bb9b: 83 f8 04 cmp $0x4,%eax
10bb9e: 77 6c ja 10bc0c <rtems_rate_monotonic_period+0xd0><== NEVER TAKEN
10bba0: 8b 04 85 7c 22 12 00 mov 0x12227c(,%eax,4),%eax
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
10bba7: 89 45 d4 mov %eax,-0x2c(%ebp)
10bbaa: e8 21 2b 00 00 call 10e6d0 <_Thread_Enable_dispatch>
return( return_value );
10bbaf: 8b 45 d4 mov -0x2c(%ebp),%eax
10bbb2: eb b5 jmp 10bb69 <rtems_rate_monotonic_period+0x2d>
}
_ISR_Disable( level );
10bbb4: 9c pushf
10bbb5: fa cli
10bbb6: 5f pop %edi
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
10bbb7: 8b 50 38 mov 0x38(%eax),%edx
10bbba: 85 d2 test %edx,%edx
10bbbc: 74 52 je 10bc10 <rtems_rate_monotonic_period+0xd4>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
10bbbe: 83 fa 02 cmp $0x2,%edx
10bbc1: 0f 84 9e 00 00 00 je 10bc65 <rtems_rate_monotonic_period+0x129>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
10bbc7: 83 fa 04 cmp $0x4,%edx
10bbca: 75 98 jne 10bb64 <rtems_rate_monotonic_period+0x28><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
10bbcc: 83 ec 0c sub $0xc,%esp
10bbcf: 50 push %eax
10bbd0: 89 45 d4 mov %eax,-0x2c(%ebp)
10bbd3: e8 74 fe ff ff call 10ba4c <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
10bbd8: 57 push %edi
10bbd9: 9d popf
the_period->state = RATE_MONOTONIC_ACTIVE;
10bbda: 8b 45 d4 mov -0x2c(%ebp),%eax
10bbdd: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax)
the_period->next_length = length;
10bbe4: 89 70 3c mov %esi,0x3c(%eax)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10bbe7: 89 70 1c mov %esi,0x1c(%eax)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10bbea: 5b pop %ebx
10bbeb: 5e pop %esi
_Watchdog_Insert_ticks( &the_period->Timer, length );
10bbec: 83 c0 10 add $0x10,%eax
10bbef: 50 push %eax
10bbf0: 68 60 86 12 00 push $0x128660
10bbf5: e8 a2 38 00 00 call 10f49c <_Watchdog_Insert>
_Thread_Enable_dispatch();
10bbfa: e8 d1 2a 00 00 call 10e6d0 <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
10bbff: 83 c4 10 add $0x10,%esp
10bc02: b8 06 00 00 00 mov $0x6,%eax
10bc07: e9 5d ff ff ff jmp 10bb69 <rtems_rate_monotonic_period+0x2d>
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
switch ( the_period->state ) {
10bc0c: 31 c0 xor %eax,%eax
10bc0e: eb 97 jmp 10bba7 <rtems_rate_monotonic_period+0x6b><== NOT EXECUTED
return( return_value );
}
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
_ISR_Enable( level );
10bc10: 57 push %edi
10bc11: 9d popf
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
10bc12: 83 ec 0c sub $0xc,%esp
10bc15: 50 push %eax
10bc16: 89 45 d4 mov %eax,-0x2c(%ebp)
10bc19: e8 ba fd ff ff call 10b9d8 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
10bc1e: 8b 45 d4 mov -0x2c(%ebp),%eax
10bc21: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10bc28: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10bc2f: c7 40 2c 94 bf 10 00 movl $0x10bf94,0x2c(%eax)
the_watchdog->id = id;
10bc36: 89 58 30 mov %ebx,0x30(%eax)
the_watchdog->user_data = user_data;
10bc39: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
10bc40: 89 70 3c mov %esi,0x3c(%eax)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10bc43: 89 70 1c mov %esi,0x1c(%eax)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10bc46: 5e pop %esi
10bc47: 5f pop %edi
_Watchdog_Insert_ticks( &the_period->Timer, length );
10bc48: 83 c0 10 add $0x10,%eax
10bc4b: 50 push %eax
10bc4c: 68 60 86 12 00 push $0x128660
10bc51: e8 46 38 00 00 call 10f49c <_Watchdog_Insert>
_Thread_Enable_dispatch();
10bc56: e8 75 2a 00 00 call 10e6d0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10bc5b: 83 c4 10 add $0x10,%esp
10bc5e: 31 c0 xor %eax,%eax
10bc60: e9 04 ff ff ff jmp 10bb69 <rtems_rate_monotonic_period+0x2d>
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
10bc65: 83 ec 0c sub $0xc,%esp
10bc68: 50 push %eax
10bc69: 89 45 d4 mov %eax,-0x2c(%ebp)
10bc6c: e8 db fd ff ff call 10ba4c <_Rate_monotonic_Update_statistics>
/*
* This tells the _Rate_monotonic_Timeout that this task is
* in the process of blocking on the period and that we
* may be changing the length of the next period.
*/
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
10bc71: 8b 45 d4 mov -0x2c(%ebp),%eax
10bc74: c7 40 38 01 00 00 00 movl $0x1,0x38(%eax)
the_period->next_length = length;
10bc7b: 89 70 3c mov %esi,0x3c(%eax)
_ISR_Enable( level );
10bc7e: 57 push %edi
10bc7f: 9d popf
_Thread_Executing->Wait.id = the_period->Object.id;
10bc80: 8b 15 18 88 12 00 mov 0x128818,%edx
10bc86: 8b 48 08 mov 0x8(%eax),%ecx
10bc89: 89 4a 20 mov %ecx,0x20(%edx)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10bc8c: 59 pop %ecx
10bc8d: 5b pop %ebx
10bc8e: 68 00 40 00 00 push $0x4000
10bc93: 52 push %edx
10bc94: 89 45 d4 mov %eax,-0x2c(%ebp)
10bc97: e8 28 32 00 00 call 10eec4 <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
10bc9c: 9c pushf
10bc9d: fa cli
10bc9e: 59 pop %ecx
local_state = the_period->state;
10bc9f: 8b 45 d4 mov -0x2c(%ebp),%eax
10bca2: 8b 50 38 mov 0x38(%eax),%edx
the_period->state = RATE_MONOTONIC_ACTIVE;
10bca5: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax)
_ISR_Enable( level );
10bcac: 51 push %ecx
10bcad: 9d popf
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
10bcae: 83 c4 10 add $0x10,%esp
10bcb1: 83 fa 03 cmp $0x3,%edx
10bcb4: 74 0c je 10bcc2 <rtems_rate_monotonic_period+0x186>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
_Thread_Enable_dispatch();
10bcb6: e8 15 2a 00 00 call 10e6d0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10bcbb: 31 c0 xor %eax,%eax
10bcbd: e9 a7 fe ff ff jmp 10bb69 <rtems_rate_monotonic_period+0x2d>
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10bcc2: 57 push %edi
10bcc3: 57 push %edi
10bcc4: 68 00 40 00 00 push $0x4000
10bcc9: ff 35 18 88 12 00 pushl 0x128818
10bccf: e8 98 26 00 00 call 10e36c <_Thread_Clear_state>
10bcd4: 83 c4 10 add $0x10,%esp
10bcd7: eb dd jmp 10bcb6 <rtems_rate_monotonic_period+0x17a>
0010bcdc <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
10bcdc: 55 push %ebp
10bcdd: 89 e5 mov %esp,%ebp
10bcdf: 57 push %edi
10bce0: 56 push %esi
10bce1: 53 push %ebx
10bce2: 81 ec 8c 00 00 00 sub $0x8c,%esp
10bce8: 8b 75 08 mov 0x8(%ebp),%esi
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
10bceb: 8b 7d 0c mov 0xc(%ebp),%edi
10bcee: 85 ff test %edi,%edi
10bcf0: 0f 84 be 00 00 00 je 10bdb4 <rtems_rate_monotonic_report_statistics_with_plugin+0xd8><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
10bcf6: 83 ec 08 sub $0x8,%esp
10bcf9: 68 90 22 12 00 push $0x122290
10bcfe: 56 push %esi
10bcff: ff 55 0c call *0xc(%ebp)
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
10bd02: 59 pop %ecx
10bd03: 5b pop %ebx
10bd04: 68 c8 22 12 00 push $0x1222c8
10bd09: 56 push %esi
10bd0a: ff 55 0c call *0xc(%ebp)
(*print)( context, "--- Wall times are in seconds ---\n" );
10bd0d: 58 pop %eax
10bd0e: 5a pop %edx
10bd0f: 68 ec 22 12 00 push $0x1222ec
10bd14: 56 push %esi
10bd15: ff 55 0c call *0xc(%ebp)
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
10bd18: 5b pop %ebx
10bd19: 5f pop %edi
10bd1a: 68 10 23 12 00 push $0x122310
10bd1f: 56 push %esi
10bd20: ff 55 0c call *0xc(%ebp)
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
10bd23: 5a pop %edx
10bd24: 59 pop %ecx
10bd25: 68 5c 23 12 00 push $0x12235c
10bd2a: 56 push %esi
10bd2b: ff 55 0c call *0xc(%ebp)
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10bd2e: 8b 1d a8 84 12 00 mov 0x1284a8,%ebx
10bd34: 83 c4 10 add $0x10,%esp
10bd37: 3b 1d ac 84 12 00 cmp 0x1284ac,%ebx
10bd3d: 77 75 ja 10bdb4 <rtems_rate_monotonic_report_statistics_with_plugin+0xd8><== NEVER TAKEN
10bd3f: 8d 7d 88 lea -0x78(%ebp),%edi
10bd42: eb 09 jmp 10bd4d <rtems_rate_monotonic_report_statistics_with_plugin+0x71>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
10bd44: 43 inc %ebx
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10bd45: 39 1d ac 84 12 00 cmp %ebx,0x1284ac
10bd4b: 72 67 jb 10bdb4 <rtems_rate_monotonic_report_statistics_with_plugin+0xd8>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
10bd4d: 83 ec 08 sub $0x8,%esp
10bd50: 57 push %edi
10bd51: 53 push %ebx
10bd52: e8 45 58 00 00 call 11159c <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
10bd57: 83 c4 10 add $0x10,%esp
10bd5a: 85 c0 test %eax,%eax
10bd5c: 75 e6 jne 10bd44 <rtems_rate_monotonic_report_statistics_with_plugin+0x68>
#if defined(RTEMS_DEBUG)
status = rtems_rate_monotonic_get_status( id, &the_status );
if ( status != RTEMS_SUCCESSFUL )
continue;
#else
(void) rtems_rate_monotonic_get_status( id, &the_status );
10bd5e: 83 ec 08 sub $0x8,%esp
10bd61: 8d 45 c0 lea -0x40(%ebp),%eax
10bd64: 50 push %eax
10bd65: 53 push %ebx
10bd66: e8 dd 58 00 00 call 111648 <rtems_rate_monotonic_get_status>
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
10bd6b: 83 c4 0c add $0xc,%esp
10bd6e: 8d 55 e3 lea -0x1d(%ebp),%edx
10bd71: 52 push %edx
10bd72: 6a 05 push $0x5
10bd74: ff 75 c0 pushl -0x40(%ebp)
10bd77: e8 b4 02 00 00 call 10c030 <rtems_object_get_name>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
10bd7c: 59 pop %ecx
10bd7d: 58 pop %eax
10bd7e: ff 75 8c pushl -0x74(%ebp)
10bd81: ff 75 88 pushl -0x78(%ebp)
10bd84: 8d 45 e3 lea -0x1d(%ebp),%eax
10bd87: 50 push %eax
10bd88: 53 push %ebx
10bd89: 68 ae 22 12 00 push $0x1222ae
10bd8e: 56 push %esi
10bd8f: ff 55 0c call *0xc(%ebp)
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
10bd92: 8b 45 88 mov -0x78(%ebp),%eax
10bd95: 83 c4 20 add $0x20,%esp
10bd98: 85 c0 test %eax,%eax
10bd9a: 75 20 jne 10bdbc <rtems_rate_monotonic_report_statistics_with_plugin+0xe0>
(*print)( context, "\n" );
10bd9c: 83 ec 08 sub $0x8,%esp
10bd9f: 68 b1 04 12 00 push $0x1204b1
10bda4: 56 push %esi
10bda5: ff 55 0c call *0xc(%ebp)
continue;
10bda8: 83 c4 10 add $0x10,%esp
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
10bdab: 43 inc %ebx
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10bdac: 39 1d ac 84 12 00 cmp %ebx,0x1284ac
10bdb2: 73 99 jae 10bd4d <rtems_rate_monotonic_report_statistics_with_plugin+0x71><== ALWAYS TAKEN
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
10bdb4: 8d 65 f4 lea -0xc(%ebp),%esp
10bdb7: 5b pop %ebx
10bdb8: 5e pop %esi
10bdb9: 5f pop %edi
10bdba: c9 leave
10bdbb: c3 ret
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
10bdbc: 52 push %edx
10bdbd: 8d 55 d8 lea -0x28(%ebp),%edx
10bdc0: 52 push %edx
10bdc1: 50 push %eax
10bdc2: 8d 45 a0 lea -0x60(%ebp),%eax
10bdc5: 50 push %eax
10bdc6: e8 31 33 00 00 call 10f0fc <_Timespec_Divide_by_integer>
(*print)( context,
10bdcb: b9 d3 4d 62 10 mov $0x10624dd3,%ecx
10bdd0: 8b 45 dc mov -0x24(%ebp),%eax
10bdd3: f7 e9 imul %ecx
10bdd5: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp)
10bddb: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax
10bde1: c1 f8 06 sar $0x6,%eax
10bde4: 8b 55 dc mov -0x24(%ebp),%edx
10bde7: c1 fa 1f sar $0x1f,%edx
10bdea: 29 d0 sub %edx,%eax
10bdec: 50 push %eax
10bded: ff 75 d8 pushl -0x28(%ebp)
10bdf0: 8b 45 9c mov -0x64(%ebp),%eax
10bdf3: f7 e9 imul %ecx
10bdf5: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp)
10bdfb: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax
10be01: c1 f8 06 sar $0x6,%eax
10be04: 8b 55 9c mov -0x64(%ebp),%edx
10be07: c1 fa 1f sar $0x1f,%edx
10be0a: 29 d0 sub %edx,%eax
10be0c: 50 push %eax
10be0d: ff 75 98 pushl -0x68(%ebp)
10be10: 8b 45 94 mov -0x6c(%ebp),%eax
10be13: f7 e9 imul %ecx
10be15: 89 85 70 ff ff ff mov %eax,-0x90(%ebp)
10be1b: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp)
10be21: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax
10be27: c1 f8 06 sar $0x6,%eax
10be2a: 8b 55 94 mov -0x6c(%ebp),%edx
10be2d: c1 fa 1f sar $0x1f,%edx
10be30: 29 d0 sub %edx,%eax
10be32: 50 push %eax
10be33: ff 75 90 pushl -0x70(%ebp)
10be36: 68 a8 23 12 00 push $0x1223a8
10be3b: 56 push %esi
10be3c: 89 4d 84 mov %ecx,-0x7c(%ebp)
10be3f: ff 55 0c call *0xc(%ebp)
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
10be42: 83 c4 2c add $0x2c,%esp
10be45: 8d 55 d8 lea -0x28(%ebp),%edx
10be48: 52 push %edx
10be49: ff 75 88 pushl -0x78(%ebp)
10be4c: 8d 45 b8 lea -0x48(%ebp),%eax
10be4f: 50 push %eax
10be50: e8 a7 32 00 00 call 10f0fc <_Timespec_Divide_by_integer>
(*print)( context,
10be55: 8b 4d 84 mov -0x7c(%ebp),%ecx
10be58: 8b 45 dc mov -0x24(%ebp),%eax
10be5b: f7 e9 imul %ecx
10be5d: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp)
10be63: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax
10be69: c1 f8 06 sar $0x6,%eax
10be6c: 8b 55 dc mov -0x24(%ebp),%edx
10be6f: c1 fa 1f sar $0x1f,%edx
10be72: 29 d0 sub %edx,%eax
10be74: 50 push %eax
10be75: ff 75 d8 pushl -0x28(%ebp)
10be78: 8b 45 b4 mov -0x4c(%ebp),%eax
10be7b: f7 e9 imul %ecx
10be7d: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp)
10be83: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax
10be89: c1 f8 06 sar $0x6,%eax
10be8c: 8b 55 b4 mov -0x4c(%ebp),%edx
10be8f: c1 fa 1f sar $0x1f,%edx
10be92: 29 d0 sub %edx,%eax
10be94: 50 push %eax
10be95: ff 75 b0 pushl -0x50(%ebp)
10be98: 8b 45 ac mov -0x54(%ebp),%eax
10be9b: f7 e9 imul %ecx
10be9d: 89 85 70 ff ff ff mov %eax,-0x90(%ebp)
10bea3: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp)
10bea9: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax
10beaf: c1 f8 06 sar $0x6,%eax
10beb2: 8b 55 ac mov -0x54(%ebp),%edx
10beb5: c1 fa 1f sar $0x1f,%edx
10beb8: 29 d0 sub %edx,%eax
10beba: 50 push %eax
10bebb: ff 75 a8 pushl -0x58(%ebp)
10bebe: 68 c8 23 12 00 push $0x1223c8
10bec3: 56 push %esi
10bec4: ff 55 0c call *0xc(%ebp)
10bec7: 83 c4 30 add $0x30,%esp
10beca: e9 75 fe ff ff jmp 10bd44 <rtems_rate_monotonic_report_statistics_with_plugin+0x68>
0010bee8 <rtems_rate_monotonic_reset_all_statistics>:
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
10bee8: 55 push %ebp
10bee9: 89 e5 mov %esp,%ebp
10beeb: 53 push %ebx
10beec: 83 ec 04 sub $0x4,%esp
10beef: a1 8c 85 12 00 mov 0x12858c,%eax
10bef4: 40 inc %eax
10bef5: a3 8c 85 12 00 mov %eax,0x12858c
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10befa: 8b 1d a8 84 12 00 mov 0x1284a8,%ebx
10bf00: 3b 1d ac 84 12 00 cmp 0x1284ac,%ebx
10bf06: 77 15 ja 10bf1d <rtems_rate_monotonic_reset_all_statistics+0x35><== NEVER TAKEN
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
10bf08: 83 ec 0c sub $0xc,%esp
10bf0b: 53 push %ebx
10bf0c: e8 17 00 00 00 call 10bf28 <rtems_rate_monotonic_reset_statistics>
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
10bf11: 43 inc %ebx
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10bf12: 83 c4 10 add $0x10,%esp
10bf15: 39 1d ac 84 12 00 cmp %ebx,0x1284ac
10bf1b: 73 eb jae 10bf08 <rtems_rate_monotonic_reset_all_statistics+0x20>
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
}
10bf1d: 8b 5d fc mov -0x4(%ebp),%ebx
10bf20: c9 leave
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
10bf21: e9 aa 27 00 00 jmp 10e6d0 <_Thread_Enable_dispatch>
0010bf28 <rtems_rate_monotonic_reset_statistics>:
*/
rtems_status_code rtems_rate_monotonic_reset_statistics(
rtems_id id
)
{
10bf28: 55 push %ebp
10bf29: 89 e5 mov %esp,%ebp
10bf2b: 57 push %edi
10bf2c: 53 push %ebx
10bf2d: 83 ec 14 sub $0x14,%esp
Objects_Locations location;
Rate_monotonic_Control *the_period;
the_period = _Rate_monotonic_Get( id, &location );
10bf30: 8d 45 f4 lea -0xc(%ebp),%eax
10bf33: 50 push %eax
10bf34: ff 75 08 pushl 0x8(%ebp)
10bf37: 68 a0 84 12 00 push $0x1284a0
10bf3c: e8 3f 1c 00 00 call 10db80 <_Objects_Get>
10bf41: 89 c2 mov %eax,%edx
switch ( location ) {
10bf43: 83 c4 10 add $0x10,%esp
10bf46: 8b 45 f4 mov -0xc(%ebp),%eax
10bf49: 85 c0 test %eax,%eax
10bf4b: 75 3b jne 10bf88 <rtems_rate_monotonic_reset_statistics+0x60>
case OBJECTS_LOCAL:
_Rate_monotonic_Reset_statistics( the_period );
10bf4d: 8d 5a 54 lea 0x54(%edx),%ebx
10bf50: b9 38 00 00 00 mov $0x38,%ecx
10bf55: 31 c0 xor %eax,%eax
10bf57: 89 df mov %ebx,%edi
10bf59: f3 aa rep stos %al,%es:(%edi)
10bf5b: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx)
10bf62: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx)
10bf69: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx)
10bf70: c7 42 78 ff ff ff 7f movl $0x7fffffff,0x78(%edx)
_Thread_Enable_dispatch();
10bf77: e8 54 27 00 00 call 10e6d0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10bf7c: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bf7e: 8d 65 f8 lea -0x8(%ebp),%esp
10bf81: 5b pop %ebx
10bf82: 5f pop %edi
10bf83: c9 leave
10bf84: c3 ret
10bf85: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10bf88: b8 04 00 00 00 mov $0x4,%eax
}
10bf8d: 8d 65 f8 lea -0x8(%ebp),%esp
10bf90: 5b pop %ebx
10bf91: 5f pop %edi
10bf92: c9 leave
10bf93: c3 ret
00116874 <rtems_region_create>:
uintptr_t length,
uintptr_t page_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
116874: 55 push %ebp
116875: 89 e5 mov %esp,%ebp
116877: 57 push %edi
116878: 56 push %esi
116879: 53 push %ebx
11687a: 83 ec 1c sub $0x1c,%esp
11687d: 8b 7d 08 mov 0x8(%ebp),%edi
116880: 8b 75 0c mov 0xc(%ebp),%esi
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
116883: 85 ff test %edi,%edi
116885: 0f 84 c1 00 00 00 je 11694c <rtems_region_create+0xd8>
return RTEMS_INVALID_NAME;
if ( !starting_address )
11688b: 85 f6 test %esi,%esi
11688d: 0f 84 e1 00 00 00 je 116974 <rtems_region_create+0x100>
return RTEMS_INVALID_ADDRESS;
if ( !id )
116893: 8b 45 1c mov 0x1c(%ebp),%eax
116896: 85 c0 test %eax,%eax
116898: 0f 84 d6 00 00 00 je 116974 <rtems_region_create+0x100>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
11689e: 83 ec 0c sub $0xc,%esp
1168a1: ff 35 a0 09 14 00 pushl 0x1409a0
1168a7: e8 bc 24 00 00 call 118d68 <_API_Mutex_Lock>
* This function allocates a region control block from
* the inactive chain of free region control blocks.
*/
RTEMS_INLINE_ROUTINE Region_Control *_Region_Allocate( void )
{
return (Region_Control *) _Objects_Allocate( &_Region_Information );
1168ac: c7 04 24 00 08 14 00 movl $0x140800,(%esp)
1168b3: e8 1c 3a 00 00 call 11a2d4 <_Objects_Allocate>
1168b8: 89 c3 mov %eax,%ebx
the_region = _Region_Allocate();
if ( !the_region )
1168ba: 83 c4 10 add $0x10,%esp
1168bd: 85 c0 test %eax,%eax
1168bf: 0f 84 bf 00 00 00 je 116984 <rtems_region_create+0x110>
return_status = RTEMS_TOO_MANY;
else {
the_region->maximum_segment_size = _Heap_Initialize(
1168c5: ff 75 14 pushl 0x14(%ebp)
1168c8: ff 75 10 pushl 0x10(%ebp)
1168cb: 56 push %esi
1168cc: 8d 40 68 lea 0x68(%eax),%eax
1168cf: 50 push %eax
1168d0: e8 0b 36 00 00 call 119ee0 <_Heap_Initialize>
1168d5: 89 43 5c mov %eax,0x5c(%ebx)
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
1168d8: 83 c4 10 add $0x10,%esp
1168db: 85 c0 test %eax,%eax
1168dd: 74 7d je 11695c <rtems_region_create+0xe8>
return_status = RTEMS_INVALID_SIZE;
}
else {
the_region->starting_address = starting_address;
1168df: 89 73 50 mov %esi,0x50(%ebx)
the_region->length = length;
1168e2: 8b 45 10 mov 0x10(%ebp),%eax
1168e5: 89 43 54 mov %eax,0x54(%ebx)
the_region->page_size = page_size;
1168e8: 8b 55 14 mov 0x14(%ebp),%edx
1168eb: 89 53 58 mov %edx,0x58(%ebx)
the_region->attribute_set = attribute_set;
1168ee: 8b 45 18 mov 0x18(%ebp),%eax
1168f1: 89 43 60 mov %eax,0x60(%ebx)
the_region->number_of_used_blocks = 0;
1168f4: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
_Thread_queue_Initialize(
1168fb: 6a 06 push $0x6
1168fd: 6a 40 push $0x40
1168ff: a8 04 test $0x4,%al
116901: 0f 95 c0 setne %al
116904: 0f b6 c0 movzbl %al,%eax
116907: 50 push %eax
116908: 8d 43 10 lea 0x10(%ebx),%eax
11690b: 50 push %eax
11690c: e8 e3 50 00 00 call 11b9f4 <_Thread_queue_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
116911: 8b 43 08 mov 0x8(%ebx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
116914: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
116917: 8b 15 1c 08 14 00 mov 0x14081c,%edx
11691d: 89 1c 8a mov %ebx,(%edx,%ecx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
116920: 89 7b 0c mov %edi,0xc(%ebx)
&_Region_Information,
&the_region->Object,
(Objects_Name) name
);
*id = the_region->Object.id;
116923: 8b 55 1c mov 0x1c(%ebp),%edx
116926: 89 02 mov %eax,(%edx)
116928: 83 c4 10 add $0x10,%esp
return_status = RTEMS_SUCCESSFUL;
11692b: 31 c0 xor %eax,%eax
}
}
_RTEMS_Unlock_allocator();
11692d: 83 ec 0c sub $0xc,%esp
116930: ff 35 a0 09 14 00 pushl 0x1409a0
116936: 89 45 e4 mov %eax,-0x1c(%ebp)
116939: e8 72 24 00 00 call 118db0 <_API_Mutex_Unlock>
return return_status;
11693e: 83 c4 10 add $0x10,%esp
116941: 8b 45 e4 mov -0x1c(%ebp),%eax
}
116944: 8d 65 f4 lea -0xc(%ebp),%esp
116947: 5b pop %ebx
116948: 5e pop %esi
116949: 5f pop %edi
11694a: c9 leave
11694b: c3 ret
{
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
11694c: b8 03 00 00 00 mov $0x3,%eax
}
}
_RTEMS_Unlock_allocator();
return return_status;
}
116951: 8d 65 f4 lea -0xc(%ebp),%esp
116954: 5b pop %ebx
116955: 5e pop %esi
116956: 5f pop %edi
116957: c9 leave
116958: c3 ret
116959: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _Region_Free (
Region_Control *the_region
)
{
_Objects_Free( &_Region_Information, &the_region->Object );
11695c: 83 ec 08 sub $0x8,%esp
11695f: 53 push %ebx
116960: 68 00 08 14 00 push $0x140800
116965: e8 de 3c 00 00 call 11a648 <_Objects_Free>
11696a: 83 c4 10 add $0x10,%esp
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
_Region_Free( the_region );
return_status = RTEMS_INVALID_SIZE;
11696d: b8 08 00 00 00 mov $0x8,%eax
116972: eb b9 jmp 11692d <rtems_region_create+0xb9>
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
116974: b8 09 00 00 00 mov $0x9,%eax
}
}
_RTEMS_Unlock_allocator();
return return_status;
}
116979: 8d 65 f4 lea -0xc(%ebp),%esp
11697c: 5b pop %ebx
11697d: 5e pop %esi
11697e: 5f pop %edi
11697f: c9 leave
116980: c3 ret
116981: 8d 76 00 lea 0x0(%esi),%esi
_RTEMS_Lock_allocator(); /* to prevent deletion */
the_region = _Region_Allocate();
if ( !the_region )
return_status = RTEMS_TOO_MANY;
116984: b8 05 00 00 00 mov $0x5,%eax
116989: eb a2 jmp 11692d <rtems_region_create+0xb9>
0011698c <rtems_region_delete>:
*/
rtems_status_code rtems_region_delete(
rtems_id id
)
{
11698c: 55 push %ebp
11698d: 89 e5 mov %esp,%ebp
11698f: 53 push %ebx
116990: 83 ec 30 sub $0x30,%esp
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
_RTEMS_Lock_allocator();
116993: ff 35 a0 09 14 00 pushl 0x1409a0
116999: e8 ca 23 00 00 call 118d68 <_API_Mutex_Lock>
Objects_Id id,
Objects_Locations *location
)
{
return (Region_Control *)
_Objects_Get_no_protection( &_Region_Information, id, location );
11699e: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
1169a1: 8d 45 f4 lea -0xc(%ebp),%eax
1169a4: 50 push %eax
1169a5: ff 75 08 pushl 0x8(%ebp)
1169a8: 68 00 08 14 00 push $0x140800
1169ad: e8 d6 3d 00 00 call 11a788 <_Objects_Get_no_protection>
switch ( location ) {
1169b2: 83 c4 10 add $0x10,%esp
1169b5: 8b 5d f4 mov -0xc(%ebp),%ebx
1169b8: 85 db test %ebx,%ebx
1169ba: 74 1c je 1169d8 <rtems_region_delete+0x4c>
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
1169bc: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
1169c1: 83 ec 0c sub $0xc,%esp
1169c4: ff 35 a0 09 14 00 pushl 0x1409a0
1169ca: e8 e1 23 00 00 call 118db0 <_API_Mutex_Unlock>
return return_status;
}
1169cf: 89 d8 mov %ebx,%eax
1169d1: 8b 5d fc mov -0x4(%ebp),%ebx
1169d4: c9 leave
1169d5: c3 ret
1169d6: 66 90 xchg %ax,%ax
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 5 );
if ( the_region->number_of_used_blocks != 0 )
1169d8: 8b 48 64 mov 0x64(%eax),%ecx
1169db: 85 c9 test %ecx,%ecx
1169dd: 74 09 je 1169e8 <rtems_region_delete+0x5c>
return_status = RTEMS_RESOURCE_IN_USE;
1169df: bb 0c 00 00 00 mov $0xc,%ebx
1169e4: eb db jmp 1169c1 <rtems_region_delete+0x35>
1169e6: 66 90 xchg %ax,%ax
else {
_Objects_Close( &_Region_Information, &the_region->Object );
1169e8: 83 ec 08 sub $0x8,%esp
1169eb: 50 push %eax
1169ec: 68 00 08 14 00 push $0x140800
1169f1: 89 45 e4 mov %eax,-0x1c(%ebp)
1169f4: e8 57 39 00 00 call 11a350 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Region_Free (
Region_Control *the_region
)
{
_Objects_Free( &_Region_Information, &the_region->Object );
1169f9: 58 pop %eax
1169fa: 5a pop %edx
1169fb: 8b 45 e4 mov -0x1c(%ebp),%eax
1169fe: 50 push %eax
1169ff: 68 00 08 14 00 push $0x140800
116a04: e8 3f 3c 00 00 call 11a648 <_Objects_Free>
116a09: 83 c4 10 add $0x10,%esp
_Region_Free( the_region );
return_status = RTEMS_SUCCESSFUL;
116a0c: 31 db xor %ebx,%ebx
116a0e: eb b1 jmp 1169c1 <rtems_region_delete+0x35>
00116a10 <rtems_region_extend>:
rtems_status_code rtems_region_extend(
rtems_id id,
void *starting_address,
uintptr_t length
)
{
116a10: 55 push %ebp
116a11: 89 e5 mov %esp,%ebp
116a13: 56 push %esi
116a14: 53 push %ebx
116a15: 83 ec 10 sub $0x10,%esp
116a18: 8b 5d 0c mov 0xc(%ebp),%ebx
bool extend_ok;
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
116a1b: 85 db test %ebx,%ebx
116a1d: 74 75 je 116a94 <rtems_region_extend+0x84>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
116a1f: 83 ec 0c sub $0xc,%esp
116a22: ff 35 a0 09 14 00 pushl 0x1409a0
116a28: e8 3b 23 00 00 call 118d68 <_API_Mutex_Lock>
Objects_Id id,
Objects_Locations *location
)
{
return (Region_Control *)
_Objects_Get_no_protection( &_Region_Information, id, location );
116a2d: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
116a30: 8d 45 f0 lea -0x10(%ebp),%eax
116a33: 50 push %eax
116a34: ff 75 08 pushl 0x8(%ebp)
116a37: 68 00 08 14 00 push $0x140800
116a3c: e8 47 3d 00 00 call 11a788 <_Objects_Get_no_protection>
116a41: 89 c6 mov %eax,%esi
switch ( location ) {
116a43: 83 c4 10 add $0x10,%esp
116a46: 8b 45 f0 mov -0x10(%ebp),%eax
116a49: 85 c0 test %eax,%eax
116a4b: 74 1f je 116a6c <rtems_region_extend+0x5c>
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
116a4d: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
116a52: 83 ec 0c sub $0xc,%esp
116a55: ff 35 a0 09 14 00 pushl 0x1409a0
116a5b: e8 50 23 00 00 call 118db0 <_API_Mutex_Unlock>
return return_status;
116a60: 83 c4 10 add $0x10,%esp
}
116a63: 89 d8 mov %ebx,%eax
116a65: 8d 65 f8 lea -0x8(%ebp),%esp
116a68: 5b pop %ebx
116a69: 5e pop %esi
116a6a: c9 leave
116a6b: c3 ret
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
extend_ok = _Heap_Extend(
116a6c: 8d 45 f4 lea -0xc(%ebp),%eax
116a6f: 50 push %eax
116a70: ff 75 10 pushl 0x10(%ebp)
116a73: 53 push %ebx
116a74: 8d 46 68 lea 0x68(%esi),%eax
116a77: 50 push %eax
116a78: e8 43 2e 00 00 call 1198c0 <_Heap_Extend>
starting_address,
length,
&amount_extended
);
if ( extend_ok ) {
116a7d: 83 c4 10 add $0x10,%esp
116a80: 84 c0 test %al,%al
116a82: 74 20 je 116aa4 <rtems_region_extend+0x94>
the_region->length += amount_extended;
116a84: 8b 45 f4 mov -0xc(%ebp),%eax
116a87: 01 46 54 add %eax,0x54(%esi)
the_region->maximum_segment_size += amount_extended;
116a8a: 01 46 5c add %eax,0x5c(%esi)
return_status = RTEMS_SUCCESSFUL;
116a8d: 31 db xor %ebx,%ebx
116a8f: eb c1 jmp 116a52 <rtems_region_extend+0x42>
116a91: 8d 76 00 lea 0x0(%esi),%esi
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
116a94: bb 09 00 00 00 mov $0x9,%ebx
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
116a99: 89 d8 mov %ebx,%eax
116a9b: 8d 65 f8 lea -0x8(%ebp),%esp
116a9e: 5b pop %ebx
116a9f: 5e pop %esi
116aa0: c9 leave
116aa1: c3 ret
116aa2: 66 90 xchg %ax,%ax
if ( extend_ok ) {
the_region->length += amount_extended;
the_region->maximum_segment_size += amount_extended;
return_status = RTEMS_SUCCESSFUL;
} else {
return_status = RTEMS_INVALID_ADDRESS;
116aa4: bb 09 00 00 00 mov $0x9,%ebx
116aa9: eb a7 jmp 116a52 <rtems_region_extend+0x42>
00116aac <rtems_region_get_free_information>:
rtems_status_code rtems_region_get_free_information(
rtems_id id,
Heap_Information_block *the_info
)
{
116aac: 55 push %ebp
116aad: 89 e5 mov %esp,%ebp
116aaf: 53 push %ebx
116ab0: 83 ec 14 sub $0x14,%esp
116ab3: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
116ab6: 85 db test %ebx,%ebx
116ab8: 74 76 je 116b30 <rtems_region_get_free_information+0x84>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
116aba: 83 ec 0c sub $0xc,%esp
116abd: ff 35 a0 09 14 00 pushl 0x1409a0
116ac3: e8 a0 22 00 00 call 118d68 <_API_Mutex_Lock>
116ac8: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
116acb: 8d 45 f4 lea -0xc(%ebp),%eax
116ace: 50 push %eax
116acf: ff 75 08 pushl 0x8(%ebp)
116ad2: 68 00 08 14 00 push $0x140800
116ad7: e8 ac 3c 00 00 call 11a788 <_Objects_Get_no_protection>
switch ( location ) {
116adc: 83 c4 10 add $0x10,%esp
116adf: 8b 55 f4 mov -0xc(%ebp),%edx
116ae2: 85 d2 test %edx,%edx
116ae4: 74 1e je 116b04 <rtems_region_get_free_information+0x58>
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
116ae6: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
116aeb: 83 ec 0c sub $0xc,%esp
116aee: ff 35 a0 09 14 00 pushl 0x1409a0
116af4: e8 b7 22 00 00 call 118db0 <_API_Mutex_Unlock>
return return_status;
116af9: 83 c4 10 add $0x10,%esp
}
116afc: 89 d8 mov %ebx,%eax
116afe: 8b 5d fc mov -0x4(%ebp),%ebx
116b01: c9 leave
116b02: c3 ret
116b03: 90 nop
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_info->Used.number = 0;
116b04: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
the_info->Used.total = 0;
116b0b: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
the_info->Used.largest = 0;
116b12: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
_Heap_Get_free_information( &the_region->Memory, &the_info->Free );
116b19: 83 ec 08 sub $0x8,%esp
116b1c: 53 push %ebx
116b1d: 83 c0 68 add $0x68,%eax
116b20: 50 push %eax
116b21: e8 96 31 00 00 call 119cbc <_Heap_Get_free_information>
return_status = RTEMS_SUCCESSFUL;
break;
116b26: 83 c4 10 add $0x10,%esp
the_info->Used.total = 0;
the_info->Used.largest = 0;
_Heap_Get_free_information( &the_region->Memory, &the_info->Free );
return_status = RTEMS_SUCCESSFUL;
116b29: 31 db xor %ebx,%ebx
break;
116b2b: eb be jmp 116aeb <rtems_region_get_free_information+0x3f>
116b2d: 8d 76 00 lea 0x0(%esi),%esi
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
116b30: bb 09 00 00 00 mov $0x9,%ebx
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
116b35: 89 d8 mov %ebx,%eax
116b37: 8b 5d fc mov -0x4(%ebp),%ebx
116b3a: c9 leave
116b3b: c3 ret
00116bb4 <rtems_region_get_segment>:
uintptr_t size,
rtems_option option_set,
rtems_interval timeout,
void **segment
)
{
116bb4: 55 push %ebp
116bb5: 89 e5 mov %esp,%ebp
116bb7: 57 push %edi
116bb8: 56 push %esi
116bb9: 53 push %ebx
116bba: 83 ec 2c sub $0x2c,%esp
116bbd: 8b 75 0c mov 0xc(%ebp),%esi
116bc0: 8b 5d 18 mov 0x18(%ebp),%ebx
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
void *the_segment;
if ( !segment )
116bc3: 85 db test %ebx,%ebx
116bc5: 0f 84 a1 00 00 00 je 116c6c <rtems_region_get_segment+0xb8>
return RTEMS_INVALID_ADDRESS;
*segment = NULL;
116bcb: c7 03 00 00 00 00 movl $0x0,(%ebx)
if ( size == 0 )
116bd1: 85 f6 test %esi,%esi
116bd3: 75 0f jne 116be4 <rtems_region_get_segment+0x30>
return RTEMS_INVALID_SIZE;
116bd5: b8 08 00 00 00 mov $0x8,%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
116bda: 8d 65 f4 lea -0xc(%ebp),%esp
116bdd: 5b pop %ebx
116bde: 5e pop %esi
116bdf: 5f pop %edi
116be0: c9 leave
116be1: c3 ret
116be2: 66 90 xchg %ax,%ax
*segment = NULL;
if ( size == 0 )
return RTEMS_INVALID_SIZE;
_RTEMS_Lock_allocator();
116be4: 83 ec 0c sub $0xc,%esp
116be7: ff 35 a0 09 14 00 pushl 0x1409a0
116bed: e8 76 21 00 00 call 118d68 <_API_Mutex_Lock>
executing = _Thread_Executing;
116bf2: a1 78 0b 14 00 mov 0x140b78,%eax
116bf7: 89 45 d4 mov %eax,-0x2c(%ebp)
116bfa: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
116bfd: 8d 45 e4 lea -0x1c(%ebp),%eax
116c00: 50 push %eax
116c01: ff 75 08 pushl 0x8(%ebp)
116c04: 68 00 08 14 00 push $0x140800
116c09: e8 7a 3b 00 00 call 11a788 <_Objects_Get_no_protection>
116c0e: 89 c7 mov %eax,%edi
switch ( location ) {
116c10: 83 c4 10 add $0x10,%esp
116c13: 8b 45 e4 mov -0x1c(%ebp),%eax
116c16: 85 c0 test %eax,%eax
116c18: 75 2a jne 116c44 <rtems_region_get_segment+0x90>
case OBJECTS_LOCAL:
if ( size > the_region->maximum_segment_size )
116c1a: 3b 77 5c cmp 0x5c(%edi),%esi
116c1d: 76 2d jbe 116c4c <rtems_region_get_segment+0x98>
return_status = RTEMS_INVALID_SIZE;
116c1f: b8 08 00 00 00 mov $0x8,%eax
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
116c24: 83 ec 0c sub $0xc,%esp
116c27: ff 35 a0 09 14 00 pushl 0x1409a0
116c2d: 89 45 d0 mov %eax,-0x30(%ebp)
116c30: e8 7b 21 00 00 call 118db0 <_API_Mutex_Unlock>
return return_status;
116c35: 83 c4 10 add $0x10,%esp
116c38: 8b 45 d0 mov -0x30(%ebp),%eax
}
116c3b: 8d 65 f4 lea -0xc(%ebp),%esp
116c3e: 5b pop %ebx
116c3f: 5e pop %esi
116c40: 5f pop %edi
116c41: c9 leave
116c42: c3 ret
116c43: 90 nop
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
116c44: b8 04 00 00 00 mov $0x4,%eax
116c49: eb d9 jmp 116c24 <rtems_region_get_segment+0x70>
116c4b: 90 nop
* @brief See _Heap_Allocate_aligned_with_boundary() with alignment and
* boundary equals zero.
*/
RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size )
{
return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
116c4c: 6a 00 push $0x0
116c4e: 6a 00 push $0x0
116c50: 56 push %esi
RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment (
Region_Control *the_region,
uintptr_t size
)
{
return _Heap_Allocate( &the_region->Memory, size );
116c51: 8d 47 68 lea 0x68(%edi),%eax
116c54: 50 push %eax
116c55: e8 92 2a 00 00 call 1196ec <_Heap_Allocate_aligned_with_boundary>
the_segment = _Region_Allocate_segment( the_region, size );
_Region_Debug_Walk( the_region, 2 );
if ( the_segment ) {
116c5a: 83 c4 10 add $0x10,%esp
116c5d: 85 c0 test %eax,%eax
116c5f: 74 17 je 116c78 <rtems_region_get_segment+0xc4>
the_region->number_of_used_blocks += 1;
116c61: ff 47 64 incl 0x64(%edi)
*segment = the_segment;
116c64: 89 03 mov %eax,(%ebx)
return_status = RTEMS_SUCCESSFUL;
116c66: 31 c0 xor %eax,%eax
116c68: eb ba jmp 116c24 <rtems_region_get_segment+0x70>
116c6a: 66 90 xchg %ax,%ax
rtems_status_code return_status;
Region_Control *the_region;
void *the_segment;
if ( !segment )
return RTEMS_INVALID_ADDRESS;
116c6c: b8 09 00 00 00 mov $0x9,%eax
116c71: e9 64 ff ff ff jmp 116bda <rtems_region_get_segment+0x26>
116c76: 66 90 xchg %ax,%ax
if ( the_segment ) {
the_region->number_of_used_blocks += 1;
*segment = the_segment;
return_status = RTEMS_SUCCESSFUL;
} else if ( _Options_Is_no_wait( option_set ) ) {
116c78: f6 45 10 01 testb $0x1,0x10(%ebp)
116c7c: 74 07 je 116c85 <rtems_region_get_segment+0xd1>
return_status = RTEMS_UNSATISFIED;
116c7e: b8 0d 00 00 00 mov $0xd,%eax
116c83: eb 9f jmp 116c24 <rtems_region_get_segment+0x70>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
116c85: a1 ec 08 14 00 mov 0x1408ec,%eax
116c8a: 40 inc %eax
116c8b: a3 ec 08 14 00 mov %eax,0x1408ec
* Switch from using the memory allocation mutex to using a
* dispatching disabled critical section. We have to do this
* because this thread is going to block.
*/
_Thread_Disable_dispatch();
_RTEMS_Unlock_allocator();
116c90: 83 ec 0c sub $0xc,%esp
116c93: ff 35 a0 09 14 00 pushl 0x1409a0
116c99: e8 12 21 00 00 call 118db0 <_API_Mutex_Unlock>
executing->Wait.queue = &the_region->Wait_queue;
116c9e: 8d 47 10 lea 0x10(%edi),%eax
116ca1: 8b 55 d4 mov -0x2c(%ebp),%edx
116ca4: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
116ca7: 8b 4d 08 mov 0x8(%ebp),%ecx
116caa: 89 4a 20 mov %ecx,0x20(%edx)
executing->Wait.count = size;
116cad: 89 72 24 mov %esi,0x24(%edx)
executing->Wait.return_argument = segment;
116cb0: 89 5a 28 mov %ebx,0x28(%edx)
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
116cb3: c7 47 40 01 00 00 00 movl $0x1,0x40(%edi)
_Thread_queue_Enter_critical_section( &the_region->Wait_queue );
_Thread_queue_Enqueue( &the_region->Wait_queue, timeout );
116cba: 83 c4 0c add $0xc,%esp
116cbd: 68 b8 ba 11 00 push $0x11bab8
116cc2: ff 75 14 pushl 0x14(%ebp)
116cc5: 50 push %eax
116cc6: e8 c1 4a 00 00 call 11b78c <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
116ccb: e8 44 46 00 00 call 11b314 <_Thread_Enable_dispatch>
return (rtems_status_code) executing->Wait.return_code;
116cd0: 8b 55 d4 mov -0x2c(%ebp),%edx
116cd3: 8b 42 34 mov 0x34(%edx),%eax
116cd6: 83 c4 10 add $0x10,%esp
116cd9: e9 fc fe ff ff jmp 116bda <rtems_region_get_segment+0x26>
00116d94 <rtems_region_resize_segment>:
rtems_id id,
void *segment,
uintptr_t size,
uintptr_t *old_size
)
{
116d94: 55 push %ebp
116d95: 89 e5 mov %esp,%ebp
116d97: 56 push %esi
116d98: 53 push %ebx
116d99: 83 ec 20 sub $0x20,%esp
116d9c: 8b 5d 14 mov 0x14(%ebp),%ebx
uintptr_t osize;
rtems_status_code return_status;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
116d9f: 85 db test %ebx,%ebx
116da1: 0f 84 89 00 00 00 je 116e30 <rtems_region_resize_segment+0x9c>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
116da7: 83 ec 0c sub $0xc,%esp
116daa: ff 35 a0 09 14 00 pushl 0x1409a0
116db0: e8 b3 1f 00 00 call 118d68 <_API_Mutex_Lock>
116db5: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
116db8: 8d 45 f0 lea -0x10(%ebp),%eax
116dbb: 50 push %eax
116dbc: ff 75 08 pushl 0x8(%ebp)
116dbf: 68 00 08 14 00 push $0x140800
116dc4: e8 bf 39 00 00 call 11a788 <_Objects_Get_no_protection>
116dc9: 89 c6 mov %eax,%esi
switch ( location ) {
116dcb: 83 c4 10 add $0x10,%esp
116dce: 8b 45 f0 mov -0x10(%ebp),%eax
116dd1: 85 c0 test %eax,%eax
116dd3: 74 1f je 116df4 <rtems_region_resize_segment+0x60>
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
116dd5: 83 ec 0c sub $0xc,%esp
116dd8: ff 35 a0 09 14 00 pushl 0x1409a0
116dde: e8 cd 1f 00 00 call 118db0 <_API_Mutex_Unlock>
return return_status;
116de3: 83 c4 10 add $0x10,%esp
116de6: b8 04 00 00 00 mov $0x4,%eax
}
116deb: 8d 65 f8 lea -0x8(%ebp),%esp
116dee: 5b pop %ebx
116def: 5e pop %esi
116df0: c9 leave
116df1: c3 ret
116df2: 66 90 xchg %ax,%ax
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 7 );
status = _Heap_Resize_block(
116df4: 83 ec 0c sub $0xc,%esp
116df7: 8d 45 f4 lea -0xc(%ebp),%eax
116dfa: 50 push %eax
116dfb: 8d 45 ec lea -0x14(%ebp),%eax
116dfe: 50 push %eax
116dff: ff 75 10 pushl 0x10(%ebp)
116e02: ff 75 0c pushl 0xc(%ebp)
116e05: 8d 46 68 lea 0x68(%esi),%eax
116e08: 50 push %eax
116e09: e8 da 32 00 00 call 11a0e8 <_Heap_Resize_block>
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
116e0e: 8b 55 ec mov -0x14(%ebp),%edx
116e11: 89 13 mov %edx,(%ebx)
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
116e13: 83 c4 20 add $0x20,%esp
116e16: 85 c0 test %eax,%eax
116e18: 75 22 jne 116e3c <rtems_region_resize_segment+0xa8>
_Region_Process_queue( the_region ); /* unlocks allocator */
116e1a: 83 ec 0c sub $0xc,%esp
116e1d: 56 push %esi
116e1e: e8 d1 72 00 00 call 11e0f4 <_Region_Process_queue>
116e23: 83 c4 10 add $0x10,%esp
else
_RTEMS_Unlock_allocator();
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
116e26: 31 c0 xor %eax,%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
116e28: 8d 65 f8 lea -0x8(%ebp),%esp
116e2b: 5b pop %ebx
116e2c: 5e pop %esi
116e2d: c9 leave
116e2e: c3 ret
116e2f: 90 nop
rtems_status_code return_status;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
return RTEMS_INVALID_ADDRESS;
116e30: b8 09 00 00 00 mov $0x9,%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
116e35: 8d 65 f8 lea -0x8(%ebp),%esp
116e38: 5b pop %ebx
116e39: 5e pop %esi
116e3a: c9 leave
116e3b: c3 ret
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
_Region_Process_queue( the_region ); /* unlocks allocator */
else
_RTEMS_Unlock_allocator();
116e3c: 83 ec 0c sub $0xc,%esp
116e3f: ff 35 a0 09 14 00 pushl 0x1409a0
116e45: 89 45 e4 mov %eax,-0x1c(%ebp)
116e48: e8 63 1f 00 00 call 118db0 <_API_Mutex_Unlock>
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
if (status == HEAP_RESIZE_UNSATISFIED)
116e4d: 83 c4 10 add $0x10,%esp
return RTEMS_UNSATISFIED;
116e50: 8b 45 e4 mov -0x1c(%ebp),%eax
116e53: 48 dec %eax
116e54: 0f 94 c0 sete %al
116e57: 0f b6 c0 movzbl %al,%eax
116e5a: 8d 04 85 09 00 00 00 lea 0x9(,%eax,4),%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
116e61: 8d 65 f8 lea -0x8(%ebp),%esp
116e64: 5b pop %ebx
116e65: 5e pop %esi
116e66: c9 leave
116e67: c3 ret
00116e68 <rtems_region_return_segment>:
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
116e68: 55 push %ebp
116e69: 89 e5 mov %esp,%ebp
116e6b: 53 push %ebx
116e6c: 83 ec 20 sub $0x20,%esp
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
116e6f: ff 35 a0 09 14 00 pushl 0x1409a0
116e75: e8 ee 1e 00 00 call 118d68 <_API_Mutex_Lock>
116e7a: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
116e7d: 8d 45 f4 lea -0xc(%ebp),%eax
116e80: 50 push %eax
116e81: ff 75 08 pushl 0x8(%ebp)
116e84: 68 00 08 14 00 push $0x140800
116e89: e8 fa 38 00 00 call 11a788 <_Objects_Get_no_protection>
116e8e: 89 c3 mov %eax,%ebx
switch ( location ) {
116e90: 83 c4 10 add $0x10,%esp
116e93: 8b 45 f4 mov -0xc(%ebp),%eax
116e96: 85 c0 test %eax,%eax
116e98: 75 1e jne 116eb8 <rtems_region_return_segment+0x50>
RTEMS_INLINE_ROUTINE bool _Region_Free_segment (
Region_Control *the_region,
void *the_segment
)
{
return _Heap_Free( &the_region->Memory, the_segment );
116e9a: 83 ec 08 sub $0x8,%esp
116e9d: ff 75 0c pushl 0xc(%ebp)
116ea0: 8d 43 68 lea 0x68(%ebx),%eax
116ea3: 50 push %eax
116ea4: e8 af 2c 00 00 call 119b58 <_Heap_Free>
#endif
status = _Region_Free_segment( the_region, segment );
_Region_Debug_Walk( the_region, 4 );
if ( !status )
116ea9: 83 c4 10 add $0x10,%esp
116eac: 84 c0 test %al,%al
116eae: 75 28 jne 116ed8 <rtems_region_return_segment+0x70>
return_status = RTEMS_INVALID_ADDRESS;
116eb0: bb 09 00 00 00 mov $0x9,%ebx
116eb5: eb 06 jmp 116ebd <rtems_region_return_segment+0x55>
116eb7: 90 nop
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
116eb8: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
116ebd: 83 ec 0c sub $0xc,%esp
116ec0: ff 35 a0 09 14 00 pushl 0x1409a0
116ec6: e8 e5 1e 00 00 call 118db0 <_API_Mutex_Unlock>
return return_status;
116ecb: 83 c4 10 add $0x10,%esp
}
116ece: 89 d8 mov %ebx,%eax
116ed0: 8b 5d fc mov -0x4(%ebp),%ebx
116ed3: c9 leave
116ed4: c3 ret
116ed5: 8d 76 00 lea 0x0(%esi),%esi
_Region_Debug_Walk( the_region, 4 );
if ( !status )
return_status = RTEMS_INVALID_ADDRESS;
else {
the_region->number_of_used_blocks -= 1;
116ed8: ff 4b 64 decl 0x64(%ebx)
_Region_Process_queue(the_region); /* unlocks allocator */
116edb: 83 ec 0c sub $0xc,%esp
116ede: 53 push %ebx
116edf: e8 10 72 00 00 call 11e0f4 <_Region_Process_queue>
return RTEMS_SUCCESSFUL;
116ee4: 83 c4 10 add $0x10,%esp
116ee7: 31 db xor %ebx,%ebx
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
116ee9: 89 d8 mov %ebx,%eax
116eeb: 8b 5d fc mov -0x4(%ebp),%ebx
116eee: c9 leave
116eef: c3 ret
0010a92c <rtems_semaphore_create>:
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
10a92c: 55 push %ebp
10a92d: 89 e5 mov %esp,%ebp
10a92f: 57 push %edi
10a930: 56 push %esi
10a931: 53 push %ebx
10a932: 83 ec 3c sub $0x3c,%esp
10a935: 8b 75 08 mov 0x8(%ebp),%esi
10a938: 8b 5d 10 mov 0x10(%ebp),%ebx
10a93b: 8b 7d 18 mov 0x18(%ebp),%edi
register Semaphore_Control *the_semaphore;
CORE_mutex_Attributes the_mutex_attr;
CORE_semaphore_Attributes the_semaphore_attr;
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
10a93e: 85 f6 test %esi,%esi
10a940: 74 4a je 10a98c <rtems_semaphore_create+0x60>
return RTEMS_INVALID_NAME;
if ( !id )
10a942: 85 ff test %edi,%edi
10a944: 0f 84 f6 00 00 00 je 10aa40 <rtems_semaphore_create+0x114><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
} else
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
10a94a: 89 da mov %ebx,%edx
10a94c: 81 e2 c0 00 00 00 and $0xc0,%edx
10a952: 74 48 je 10a99c <rtems_semaphore_create+0x70>
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_binary_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE);
10a954: 89 d8 mov %ebx,%eax
10a956: 83 e0 30 and $0x30,%eax
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
10a959: 83 f8 10 cmp $0x10,%eax
10a95c: 74 0e je 10a96c <rtems_semaphore_create+0x40>
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
10a95e: b8 0b 00 00 00 mov $0xb,%eax
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10a963: 8d 65 f4 lea -0xc(%ebp),%esp
10a966: 5b pop %ebx
10a967: 5e pop %esi
10a968: 5f pop %edi
10a969: c9 leave
10a96a: c3 ret
10a96b: 90 nop
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
10a96c: f6 c3 04 test $0x4,%bl
10a96f: 74 ed je 10a95e <rtems_semaphore_create+0x32>
_Attributes_Is_priority( attribute_set ) ) )
return RTEMS_NOT_DEFINED;
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
10a971: 81 fa c0 00 00 00 cmp $0xc0,%edx
10a977: 74 e5 je 10a95e <rtems_semaphore_create+0x32>
10a979: b9 10 00 00 00 mov $0x10,%ecx
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
10a97e: 83 7d 0c 01 cmpl $0x1,0xc(%ebp)
10a982: 76 1f jbe 10a9a3 <rtems_semaphore_create+0x77>
return RTEMS_INVALID_NUMBER;
10a984: b8 0a 00 00 00 mov $0xa,%eax
10a989: eb d8 jmp 10a963 <rtems_semaphore_create+0x37>
10a98b: 90 nop
CORE_mutex_Attributes the_mutex_attr;
CORE_semaphore_Attributes the_semaphore_attr;
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10a98c: b8 03 00 00 00 mov $0x3,%eax
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10a991: 8d 65 f4 lea -0xc(%ebp),%esp
10a994: 5b pop %ebx
10a995: 5e pop %esi
10a996: 5f pop %edi
10a997: c9 leave
10a998: c3 ret
10a999: 8d 76 00 lea 0x0(%esi),%esi
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
10a99c: 89 d9 mov %ebx,%ecx
10a99e: 83 e1 30 and $0x30,%ecx
10a9a1: 75 db jne 10a97e <rtems_semaphore_create+0x52>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a9a3: a1 ec 64 12 00 mov 0x1264ec,%eax
10a9a8: 40 inc %eax
10a9a9: a3 ec 64 12 00 mov %eax,0x1264ec
* This function allocates a semaphore control block from
* the inactive chain of free semaphore control blocks.
*/
RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void )
{
return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information );
10a9ae: 83 ec 0c sub $0xc,%esp
10a9b1: 68 40 64 12 00 push $0x126440
10a9b6: 89 4d c4 mov %ecx,-0x3c(%ebp)
10a9b9: e8 3a 13 00 00 call 10bcf8 <_Objects_Allocate>
10a9be: 89 c2 mov %eax,%edx
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
10a9c0: 83 c4 10 add $0x10,%esp
10a9c3: 85 c0 test %eax,%eax
10a9c5: 8b 4d c4 mov -0x3c(%ebp),%ecx
10a9c8: 0f 84 ba 00 00 00 je 10aa88 <rtems_semaphore_create+0x15c>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_semaphore->attribute_set = attribute_set;
10a9ce: 89 58 10 mov %ebx,0x10(%eax)
/*
* Initialize it as a counting semaphore.
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
10a9d1: 85 c9 test %ecx,%ecx
10a9d3: 74 77 je 10aa4c <rtems_semaphore_create+0x120>
/*
* It is either simple binary semaphore or a more powerful mutex
* style binary semaphore. This is the mutex style.
*/
if ( _Attributes_Is_priority( attribute_set ) )
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
10a9d5: 31 c0 xor %eax,%eax
10a9d7: f6 c3 04 test $0x4,%bl
10a9da: 0f 95 c0 setne %al
10a9dd: 89 45 d8 mov %eax,-0x28(%ebp)
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
10a9e0: 83 f9 10 cmp $0x10,%ecx
10a9e3: 0f 84 ae 00 00 00 je 10aa97 <rtems_semaphore_create+0x16b>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
the_mutex_attr.only_owner_release = true;
}
}
} else /* must be simple binary semaphore */ {
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
10a9e9: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp)
the_mutex_attr.only_owner_release = false;
10a9f0: c6 45 d4 00 movb $0x0,-0x2c(%ebp)
}
mutex_status = _CORE_mutex_Initialize(
10a9f4: 50 push %eax
10a9f5: 31 c0 xor %eax,%eax
10a9f7: 83 7d 0c 01 cmpl $0x1,0xc(%ebp)
10a9fb: 0f 94 c0 sete %al
10a9fe: 50 push %eax
10a9ff: 8d 45 d0 lea -0x30(%ebp),%eax
10aa02: 50 push %eax
10aa03: 8d 42 14 lea 0x14(%edx),%eax
10aa06: 50 push %eax
10aa07: 89 55 c4 mov %edx,-0x3c(%ebp)
10aa0a: e8 e1 0a 00 00 call 10b4f0 <_CORE_mutex_Initialize>
&the_semaphore->Core_control.mutex,
&the_mutex_attr,
(count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED
);
if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {
10aa0f: 83 c4 10 add $0x10,%esp
10aa12: 83 f8 05 cmp $0x5,%eax
10aa15: 8b 55 c4 mov -0x3c(%ebp),%edx
10aa18: 0f 84 a9 00 00 00 je 10aac7 <rtems_semaphore_create+0x19b>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10aa1e: 8b 42 08 mov 0x8(%edx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10aa21: 0f b7 d8 movzwl %ax,%ebx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10aa24: 8b 0d 5c 64 12 00 mov 0x12645c,%ecx
10aa2a: 89 14 99 mov %edx,(%ecx,%ebx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10aa2d: 89 72 0c mov %esi,0xc(%edx)
&_Semaphore_Information,
&the_semaphore->Object,
(Objects_Name) name
);
*id = the_semaphore->Object.id;
10aa30: 89 07 mov %eax,(%edi)
the_semaphore->Object.id,
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
10aa32: e8 c5 22 00 00 call 10ccfc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10aa37: 31 c0 xor %eax,%eax
10aa39: e9 25 ff ff ff jmp 10a963 <rtems_semaphore_create+0x37>
10aa3e: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10aa40: b8 09 00 00 00 mov $0x9,%eax
10aa45: e9 19 ff ff ff jmp 10a963 <rtems_semaphore_create+0x37>
10aa4a: 66 90 xchg %ax,%ax
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
/*
* This effectively disables limit checking.
*/
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
10aa4c: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp)
if ( _Attributes_Is_priority( attribute_set ) )
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
10aa53: 31 c0 xor %eax,%eax
10aa55: f6 c3 04 test $0x4,%bl
10aa58: 0f 95 c0 setne %al
10aa5b: 89 45 e4 mov %eax,-0x1c(%ebp)
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* The following are just to make Purify happy.
*/
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
10aa5e: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
10aa65: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
_CORE_semaphore_Initialize(
10aa6c: 51 push %ecx
10aa6d: ff 75 0c pushl 0xc(%ebp)
10aa70: 8d 45 e0 lea -0x20(%ebp),%eax
10aa73: 50 push %eax
10aa74: 8d 42 14 lea 0x14(%edx),%eax
10aa77: 50 push %eax
10aa78: 89 55 c4 mov %edx,-0x3c(%ebp)
10aa7b: e8 00 0d 00 00 call 10b780 <_CORE_semaphore_Initialize>
10aa80: 83 c4 10 add $0x10,%esp
10aa83: 8b 55 c4 mov -0x3c(%ebp),%edx
10aa86: eb 96 jmp 10aa1e <rtems_semaphore_create+0xf2>
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
10aa88: e8 6f 22 00 00 call 10ccfc <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
10aa8d: b8 05 00 00 00 mov $0x5,%eax
10aa92: e9 cc fe ff ff jmp 10a963 <rtems_semaphore_create+0x37>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
the_mutex_attr.priority_ceiling = priority_ceiling;
10aa97: 8b 45 14 mov 0x14(%ebp),%eax
10aa9a: 89 45 dc mov %eax,-0x24(%ebp)
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
10aa9d: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
the_mutex_attr.only_owner_release = false;
10aaa4: c6 45 d4 00 movb $0x0,-0x2c(%ebp)
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
10aaa8: 83 7d d8 01 cmpl $0x1,-0x28(%ebp)
10aaac: 0f 85 42 ff ff ff jne 10a9f4 <rtems_semaphore_create+0xc8>
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
10aab2: f6 c3 40 test $0x40,%bl
10aab5: 74 30 je 10aae7 <rtems_semaphore_create+0x1bb>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
10aab7: c7 45 d8 02 00 00 00 movl $0x2,-0x28(%ebp)
the_mutex_attr.only_owner_release = true;
10aabe: c6 45 d4 01 movb $0x1,-0x2c(%ebp)
10aac2: e9 2d ff ff ff jmp 10a9f4 <rtems_semaphore_create+0xc8>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
10aac7: 83 ec 08 sub $0x8,%esp
10aaca: 52 push %edx
10aacb: 68 40 64 12 00 push $0x126440
10aad0: e8 97 15 00 00 call 10c06c <_Objects_Free>
(count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED
);
if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {
_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
10aad5: e8 22 22 00 00 call 10ccfc <_Thread_Enable_dispatch>
return RTEMS_INVALID_PRIORITY;
10aada: 83 c4 10 add $0x10,%esp
10aadd: b8 13 00 00 00 mov $0x13,%eax
10aae2: e9 7c fe ff ff jmp 10a963 <rtems_semaphore_create+0x37>
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
the_mutex_attr.only_owner_release = true;
} else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) {
10aae7: 81 e3 80 00 00 00 and $0x80,%ebx
10aaed: 0f 84 01 ff ff ff je 10a9f4 <rtems_semaphore_create+0xc8>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
10aaf3: c7 45 d8 03 00 00 00 movl $0x3,-0x28(%ebp)
the_mutex_attr.only_owner_release = true;
10aafa: c6 45 d4 01 movb $0x1,-0x2c(%ebp)
10aafe: e9 f1 fe ff ff jmp 10a9f4 <rtems_semaphore_create+0xc8>
0010ab04 <rtems_semaphore_delete>:
#endif
rtems_status_code rtems_semaphore_delete(
rtems_id id
)
{
10ab04: 55 push %ebp
10ab05: 89 e5 mov %esp,%ebp
10ab07: 53 push %ebx
10ab08: 83 ec 18 sub $0x18,%esp
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
10ab0b: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Semaphore_Control *)
_Objects_Get( &_Semaphore_Information, id, location );
10ab0e: 50 push %eax
10ab0f: ff 75 08 pushl 0x8(%ebp)
10ab12: 68 40 64 12 00 push $0x126440
10ab17: e8 90 16 00 00 call 10c1ac <_Objects_Get>
10ab1c: 89 c3 mov %eax,%ebx
switch ( location ) {
10ab1e: 83 c4 10 add $0x10,%esp
10ab21: 8b 4d f4 mov -0xc(%ebp),%ecx
10ab24: 85 c9 test %ecx,%ecx
10ab26: 74 0c je 10ab34 <rtems_semaphore_delete+0x30>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10ab28: b8 04 00 00 00 mov $0x4,%eax
}
10ab2d: 8b 5d fc mov -0x4(%ebp),%ebx
10ab30: c9 leave
10ab31: c3 ret
10ab32: 66 90 xchg %ax,%ax
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE);
10ab34: 8b 40 10 mov 0x10(%eax),%eax
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
10ab37: 83 e0 30 and $0x30,%eax
10ab3a: 74 58 je 10ab94 <rtems_semaphore_delete+0x90>
if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) &&
10ab3c: 8b 53 64 mov 0x64(%ebx),%edx
10ab3f: 85 d2 test %edx,%edx
10ab41: 75 15 jne 10ab58 <rtems_semaphore_delete+0x54>
10ab43: 83 f8 20 cmp $0x20,%eax
10ab46: 74 10 je 10ab58 <rtems_semaphore_delete+0x54>
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
10ab48: e8 af 21 00 00 call 10ccfc <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
10ab4d: b8 0c 00 00 00 mov $0xc,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ab52: 8b 5d fc mov -0x4(%ebp),%ebx
10ab55: c9 leave
10ab56: c3 ret
10ab57: 90 nop
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
_CORE_mutex_Flush(
10ab58: 50 push %eax
10ab59: 6a 03 push $0x3
10ab5b: 6a 00 push $0x0
10ab5d: 8d 43 14 lea 0x14(%ebx),%eax
10ab60: 50 push %eax
10ab61: e8 7e 09 00 00 call 10b4e4 <_CORE_mutex_Flush>
10ab66: 83 c4 10 add $0x10,%esp
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_WAS_DELETED
);
}
_Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
10ab69: 83 ec 08 sub $0x8,%esp
10ab6c: 53 push %ebx
10ab6d: 68 40 64 12 00 push $0x126440
10ab72: e8 fd 11 00 00 call 10bd74 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
10ab77: 58 pop %eax
10ab78: 5a pop %edx
10ab79: 53 push %ebx
10ab7a: 68 40 64 12 00 push $0x126440
10ab7f: e8 e8 14 00 00 call 10c06c <_Objects_Free>
0, /* Not used */
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
10ab84: e8 73 21 00 00 call 10ccfc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10ab89: 83 c4 10 add $0x10,%esp
10ab8c: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ab8e: 8b 5d fc mov -0x4(%ebp),%ebx
10ab91: c9 leave
10ab92: c3 ret
10ab93: 90 nop
&the_semaphore->Core_control.mutex,
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_MUTEX_WAS_DELETED
);
} else {
_CORE_semaphore_Flush(
10ab94: 51 push %ecx
10ab95: 6a 02 push $0x2
10ab97: 6a 00 push $0x0
10ab99: 8d 43 14 lea 0x14(%ebx),%eax
10ab9c: 50 push %eax
10ab9d: e8 d2 0b 00 00 call 10b774 <_CORE_semaphore_Flush>
10aba2: 83 c4 10 add $0x10,%esp
10aba5: eb c2 jmp 10ab69 <rtems_semaphore_delete+0x65>
0010aba8 <rtems_semaphore_obtain>:
rtems_status_code rtems_semaphore_obtain(
rtems_id id,
rtems_option option_set,
rtems_interval timeout
)
{
10aba8: 55 push %ebp
10aba9: 89 e5 mov %esp,%ebp
10abab: 57 push %edi
10abac: 56 push %esi
10abad: 53 push %ebx
10abae: 83 ec 1c sub $0x1c,%esp
10abb1: 8b 5d 08 mov 0x8(%ebp),%ebx
10abb4: 8b 75 0c mov 0xc(%ebp),%esi
10abb7: 8b 7d 10 mov 0x10(%ebp),%edi
register Semaphore_Control *the_semaphore;
Objects_Locations location;
ISR_Level level;
the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
10abba: 8d 45 e0 lea -0x20(%ebp),%eax
Objects_Locations *location,
ISR_Level *level
)
{
return (Semaphore_Control *)
_Objects_Get_isr_disable( &_Semaphore_Information, id, location, level );
10abbd: 50 push %eax
10abbe: 8d 45 e4 lea -0x1c(%ebp),%eax
10abc1: 50 push %eax
10abc2: 53 push %ebx
10abc3: 68 40 64 12 00 push $0x126440
10abc8: e8 87 15 00 00 call 10c154 <_Objects_Get_isr_disable>
switch ( location ) {
10abcd: 83 c4 10 add $0x10,%esp
10abd0: 8b 4d e4 mov -0x1c(%ebp),%ecx
10abd3: 85 c9 test %ecx,%ecx
10abd5: 74 0d je 10abe4 <rtems_semaphore_obtain+0x3c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10abd7: b8 04 00 00 00 mov $0x4,%eax
}
10abdc: 8d 65 f4 lea -0xc(%ebp),%esp
10abdf: 5b pop %ebx
10abe0: 5e pop %esi
10abe1: 5f pop %edi
10abe2: c9 leave
10abe3: c3 ret
the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
10abe4: f6 40 10 30 testb $0x30,0x10(%eax)
10abe8: 74 36 je 10ac20 <rtems_semaphore_obtain+0x78>
_CORE_mutex_Seize(
10abea: 83 ec 0c sub $0xc,%esp
10abed: ff 75 e0 pushl -0x20(%ebp)
10abf0: 57 push %edi
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (
rtems_option option_set
)
{
return (option_set & RTEMS_NO_WAIT) ? true : false;
10abf1: 83 e6 01 and $0x1,%esi
10abf4: 83 f6 01 xor $0x1,%esi
10abf7: 56 push %esi
10abf8: 53 push %ebx
10abf9: 83 c0 14 add $0x14,%eax
10abfc: 50 push %eax
10abfd: e8 e6 09 00 00 call 10b5e8 <_CORE_mutex_Seize>
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
level
);
return _Semaphore_Translate_core_mutex_return_code(
10ac02: 83 c4 14 add $0x14,%esp
_Thread_Executing->Wait.return_code );
10ac05: a1 78 67 12 00 mov 0x126778,%eax
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
level
);
return _Semaphore_Translate_core_mutex_return_code(
10ac0a: ff 70 34 pushl 0x34(%eax)
10ac0d: e8 12 01 00 00 call 10ad24 <_Semaphore_Translate_core_mutex_return_code>
10ac12: 83 c4 10 add $0x10,%esp
break;
}
return RTEMS_INVALID_ID;
}
10ac15: 8d 65 f4 lea -0xc(%ebp),%esp
10ac18: 5b pop %ebx
10ac19: 5e pop %esi
10ac1a: 5f pop %edi
10ac1b: c9 leave
10ac1c: c3 ret
10ac1d: 8d 76 00 lea 0x0(%esi),%esi
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
10ac20: 8b 15 78 67 12 00 mov 0x126778,%edx
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10ac26: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
if ( the_semaphore->count != 0 ) {
10ac2d: 8b 48 5c mov 0x5c(%eax),%ecx
10ac30: 85 c9 test %ecx,%ecx
10ac32: 75 2c jne 10ac60 <rtems_semaphore_obtain+0xb8>
the_semaphore->count -= 1;
_ISR_Enable( *level_p );
return;
}
if ( !wait ) {
10ac34: 83 e6 01 and $0x1,%esi
10ac37: 74 33 je 10ac6c <rtems_semaphore_obtain+0xc4>
_ISR_Enable( *level_p );
10ac39: ff 75 e0 pushl -0x20(%ebp)
10ac3c: 9d popf
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
10ac3d: c7 42 34 01 00 00 00 movl $0x1,0x34(%edx)
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
&level
);
return _Semaphore_Translate_core_semaphore_return_code(
10ac44: 83 ec 0c sub $0xc,%esp
_Thread_Executing->Wait.return_code );
10ac47: a1 78 67 12 00 mov 0x126778,%eax
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
&level
);
return _Semaphore_Translate_core_semaphore_return_code(
10ac4c: ff 70 34 pushl 0x34(%eax)
10ac4f: e8 e0 00 00 00 call 10ad34 <_Semaphore_Translate_core_semaphore_return_code>
10ac54: 83 c4 10 add $0x10,%esp
break;
}
return RTEMS_INVALID_ID;
}
10ac57: 8d 65 f4 lea -0xc(%ebp),%esp
10ac5a: 5b pop %ebx
10ac5b: 5e pop %esi
10ac5c: 5f pop %edi
10ac5d: c9 leave
10ac5e: c3 ret
10ac5f: 90 nop
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( the_semaphore->count != 0 ) {
the_semaphore->count -= 1;
10ac60: 49 dec %ecx
10ac61: 89 48 5c mov %ecx,0x5c(%eax)
_ISR_Enable( *level_p );
10ac64: ff 75 e0 pushl -0x20(%ebp)
10ac67: 9d popf
10ac68: eb da jmp 10ac44 <rtems_semaphore_obtain+0x9c>
10ac6a: 66 90 xchg %ax,%ax
10ac6c: 8b 0d ec 64 12 00 mov 0x1264ec,%ecx
10ac72: 41 inc %ecx
10ac73: 89 0d ec 64 12 00 mov %ecx,0x1264ec
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10ac79: c7 40 44 01 00 00 00 movl $0x1,0x44(%eax)
return;
}
_Thread_Disable_dispatch();
_Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue );
executing->Wait.queue = &the_semaphore->Wait_queue;
10ac80: 83 c0 14 add $0x14,%eax
10ac83: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
10ac86: 89 5a 20 mov %ebx,0x20(%edx)
_ISR_Enable( *level_p );
10ac89: ff 75 e0 pushl -0x20(%ebp)
10ac8c: 9d popf
_Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
10ac8d: 52 push %edx
10ac8e: 68 a0 d4 10 00 push $0x10d4a0
10ac93: 57 push %edi
10ac94: 50 push %eax
10ac95: e8 da 24 00 00 call 10d174 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10ac9a: e8 5d 20 00 00 call 10ccfc <_Thread_Enable_dispatch>
10ac9f: 83 c4 10 add $0x10,%esp
10aca2: eb a0 jmp 10ac44 <rtems_semaphore_obtain+0x9c>
0010aca4 <rtems_semaphore_release>:
#endif
rtems_status_code rtems_semaphore_release(
rtems_id id
)
{
10aca4: 55 push %ebp
10aca5: 89 e5 mov %esp,%ebp
10aca7: 53 push %ebx
10aca8: 83 ec 18 sub $0x18,%esp
10acab: 8b 5d 08 mov 0x8(%ebp),%ebx
register Semaphore_Control *the_semaphore;
Objects_Locations location;
CORE_mutex_Status mutex_status;
CORE_semaphore_Status semaphore_status;
the_semaphore = _Semaphore_Get( id, &location );
10acae: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Semaphore_Control *)
_Objects_Get( &_Semaphore_Information, id, location );
10acb1: 50 push %eax
10acb2: 53 push %ebx
10acb3: 68 40 64 12 00 push $0x126440
10acb8: e8 ef 14 00 00 call 10c1ac <_Objects_Get>
switch ( location ) {
10acbd: 83 c4 10 add $0x10,%esp
10acc0: 8b 55 f4 mov -0xc(%ebp),%edx
10acc3: 85 d2 test %edx,%edx
10acc5: 74 0d je 10acd4 <rtems_semaphore_release+0x30>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10acc7: b8 04 00 00 00 mov $0x4,%eax
}
10accc: 8b 5d fc mov -0x4(%ebp),%ebx
10accf: c9 leave
10acd0: c3 ret
10acd1: 8d 76 00 lea 0x0(%esi),%esi
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
10acd4: f6 40 10 30 testb $0x30,0x10(%eax)
10acd8: 75 26 jne 10ad00 <rtems_semaphore_release+0x5c>
MUTEX_MP_SUPPORT
);
_Thread_Enable_dispatch();
return _Semaphore_Translate_core_mutex_return_code( mutex_status );
} else {
semaphore_status = _CORE_semaphore_Surrender(
10acda: 52 push %edx
10acdb: 6a 00 push $0x0
10acdd: 53 push %ebx
10acde: 83 c0 14 add $0x14,%eax
10ace1: 50 push %eax
10ace2: e8 d9 0a 00 00 call 10b7c0 <_CORE_semaphore_Surrender>
10ace7: 89 c3 mov %eax,%ebx
&the_semaphore->Core_control.semaphore,
id,
MUTEX_MP_SUPPORT
);
_Thread_Enable_dispatch();
10ace9: e8 0e 20 00 00 call 10ccfc <_Thread_Enable_dispatch>
return
10acee: 89 1c 24 mov %ebx,(%esp)
10acf1: e8 3e 00 00 00 call 10ad34 <_Semaphore_Translate_core_semaphore_return_code>
10acf6: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10acf9: 8b 5d fc mov -0x4(%ebp),%ebx
10acfc: c9 leave
10acfd: c3 ret
10acfe: 66 90 xchg %ax,%ax
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
mutex_status = _CORE_mutex_Surrender(
10ad00: 51 push %ecx
10ad01: 6a 00 push $0x0
10ad03: 53 push %ebx
10ad04: 83 c0 14 add $0x14,%eax
10ad07: 50 push %eax
10ad08: e8 7b 09 00 00 call 10b688 <_CORE_mutex_Surrender>
10ad0d: 89 c3 mov %eax,%ebx
&the_semaphore->Core_control.mutex,
id,
MUTEX_MP_SUPPORT
);
_Thread_Enable_dispatch();
10ad0f: e8 e8 1f 00 00 call 10ccfc <_Thread_Enable_dispatch>
return _Semaphore_Translate_core_mutex_return_code( mutex_status );
10ad14: 89 1c 24 mov %ebx,(%esp)
10ad17: e8 08 00 00 00 call 10ad24 <_Semaphore_Translate_core_mutex_return_code>
10ad1c: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ad1f: 8b 5d fc mov -0x4(%ebp),%ebx
10ad22: c9 leave
10ad23: c3 ret
00117388 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
117388: 55 push %ebp
117389: 89 e5 mov %esp,%ebp
11738b: 53 push %ebx
11738c: 83 ec 14 sub $0x14,%esp
11738f: 8b 5d 0c mov 0xc(%ebp),%ebx
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
117392: 85 db test %ebx,%ebx
117394: 75 0a jne 1173a0 <rtems_signal_send+0x18>
return RTEMS_INVALID_NUMBER;
117396: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11739b: 8b 5d fc mov -0x4(%ebp),%ebx
11739e: c9 leave
11739f: c3 ret
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
1173a0: 83 ec 08 sub $0x8,%esp
1173a3: 8d 45 f4 lea -0xc(%ebp),%eax
1173a6: 50 push %eax
1173a7: ff 75 08 pushl 0x8(%ebp)
1173aa: e8 89 3f 00 00 call 11b338 <_Thread_Get>
switch ( location ) {
1173af: 83 c4 10 add $0x10,%esp
1173b2: 8b 55 f4 mov -0xc(%ebp),%edx
1173b5: 85 d2 test %edx,%edx
1173b7: 74 0b je 1173c4 <rtems_signal_send+0x3c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1173b9: b8 04 00 00 00 mov $0x4,%eax
}
1173be: 8b 5d fc mov -0x4(%ebp),%ebx
1173c1: c9 leave
1173c2: c3 ret
1173c3: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
1173c4: 8b 90 e4 00 00 00 mov 0xe4(%eax),%edx
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
1173ca: 8b 4a 0c mov 0xc(%edx),%ecx
1173cd: 85 c9 test %ecx,%ecx
1173cf: 74 3f je 117410 <rtems_signal_send+0x88>
if ( asr->is_enabled ) {
1173d1: 80 7a 08 00 cmpb $0x0,0x8(%edx)
1173d5: 74 25 je 1173fc <rtems_signal_send+0x74>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
1173d7: 9c pushf
1173d8: fa cli
1173d9: 59 pop %ecx
*signal_set |= signals;
1173da: 09 5a 14 or %ebx,0x14(%edx)
_ISR_Enable( _level );
1173dd: 51 push %ecx
1173de: 9d popf
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
1173df: 8b 15 74 0b 14 00 mov 0x140b74,%edx
1173e5: 85 d2 test %edx,%edx
1173e7: 74 1b je 117404 <rtems_signal_send+0x7c>
1173e9: 3b 05 78 0b 14 00 cmp 0x140b78,%eax
1173ef: 75 13 jne 117404 <rtems_signal_send+0x7c><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
1173f1: c6 05 84 0b 14 00 01 movb $0x1,0x140b84
1173f8: eb 0a jmp 117404 <rtems_signal_send+0x7c>
1173fa: 66 90 xchg %ax,%ax
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
1173fc: 9c pushf
1173fd: fa cli
1173fe: 58 pop %eax
*signal_set |= signals;
1173ff: 09 5a 18 or %ebx,0x18(%edx)
_ISR_Enable( _level );
117402: 50 push %eax
117403: 9d popf
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
117404: e8 0b 3f 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
117409: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11740b: 8b 5d fc mov -0x4(%ebp),%ebx
11740e: c9 leave
11740f: c3 ret
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
117410: e8 ff 3e 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
117415: b8 0b 00 00 00 mov $0xb,%eax
11741a: e9 7c ff ff ff jmp 11739b <rtems_signal_send+0x13>
00106f90 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
106f90: 55 push %ebp
106f91: 89 e5 mov %esp,%ebp
106f93: 57 push %edi
106f94: 56 push %esi
106f95: 8b 45 08 mov 0x8(%ebp),%eax
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
106f98: 8b 48 08 mov 0x8(%eax),%ecx
106f9b: 85 c9 test %ecx,%ecx
106f9d: 74 15 je 106fb4 <rtems_stack_checker_begin_extension+0x24><== NEVER TAKEN
return;
the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
*the_pattern = Stack_check_Pattern;
106f9f: 8b b8 b8 00 00 00 mov 0xb8(%eax),%edi
106fa5: 83 c7 08 add $0x8,%edi
106fa8: be 20 69 12 00 mov $0x126920,%esi
106fad: b9 04 00 00 00 mov $0x4,%ecx
106fb2: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
106fb4: 5e pop %esi
106fb5: 5f pop %edi
106fb6: c9 leave
106fb7: c3 ret
00106f68 <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
106f68: 55 push %ebp
106f69: 89 e5 mov %esp,%ebp
106f6b: 57 push %edi
106f6c: 8b 7d 0c mov 0xc(%ebp),%edi
Stack_check_Initialize();
106f6f: e8 88 ff ff ff call 106efc <Stack_check_Initialize>
if (the_thread)
106f74: 85 ff test %edi,%edi
106f76: 74 12 je 106f8a <rtems_stack_checker_create_extension+0x22><== NEVER TAKEN
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
106f78: 8b 8f b4 00 00 00 mov 0xb4(%edi),%ecx
106f7e: 8b 97 b8 00 00 00 mov 0xb8(%edi),%edx
106f84: b0 a5 mov $0xa5,%al
106f86: 89 d7 mov %edx,%edi
106f88: f3 aa rep stos %al,%es:(%edi)
return true;
}
106f8a: b0 01 mov $0x1,%al
106f8c: 5f pop %edi
106f8d: c9 leave
106f8e: c3 ret
001070cc <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
1070cc: 55 push %ebp
1070cd: 89 e5 mov %esp,%ebp
1070cf: 57 push %edi
1070d0: 56 push %esi
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
1070d1: a1 38 6d 12 00 mov 0x126d38,%eax
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
1070d6: 8b b0 b8 00 00 00 mov 0xb8(%eax),%esi
1070dc: 39 f5 cmp %esi,%ebp
1070de: 72 3c jb 10711c <rtems_stack_checker_is_blown+0x50><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
1070e0: 8b 80 b4 00 00 00 mov 0xb4(%eax),%eax
1070e6: 8d 04 06 lea (%esi,%eax,1),%eax
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
1070e9: 39 c5 cmp %eax,%ebp
1070eb: 0f 96 c0 setbe %al
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
1070ee: 8b 15 d0 65 12 00 mov 0x1265d0,%edx
1070f4: 85 d2 test %edx,%edx
1070f6: 74 30 je 107128 <rtems_stack_checker_is_blown+0x5c><== NEVER TAKEN
pattern_ok = (!memcmp(
1070f8: 83 c6 08 add $0x8,%esi
1070fb: bf 20 69 12 00 mov $0x126920,%edi
107100: b9 10 00 00 00 mov $0x10,%ecx
107105: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
107107: 0f 94 c2 sete %dl
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
10710a: 84 c0 test %al,%al
10710c: 74 1e je 10712c <rtems_stack_checker_is_blown+0x60><== NEVER TAKEN
10710e: 84 d2 test %dl,%dl
107110: 74 1a je 10712c <rtems_stack_checker_is_blown+0x60><== NEVER TAKEN
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
107112: 31 c0 xor %eax,%eax
107114: 8d 65 f8 lea -0x8(%ebp),%esp
107117: 5e pop %esi
107118: 5f pop %edi
107119: c9 leave
10711a: c3 ret
10711b: 90 nop
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
10711c: 31 c0 xor %eax,%eax
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
10711e: 8b 15 d0 65 12 00 mov 0x1265d0,%edx <== NOT EXECUTED
107124: 85 d2 test %edx,%edx <== NOT EXECUTED
107126: 75 d0 jne 1070f8 <rtems_stack_checker_is_blown+0x2c><== NOT EXECUTED
*/
bool rtems_stack_checker_is_blown( void )
{
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
bool sp_ok;
bool pattern_ok = true;
107128: b2 01 mov $0x1,%dl <== NOT EXECUTED
10712a: eb de jmp 10710a <rtems_stack_checker_is_blown+0x3e><== NOT EXECUTED
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
10712c: 57 push %edi <== NOT EXECUTED
10712d: 57 push %edi <== NOT EXECUTED
10712e: 0f b6 d2 movzbl %dl,%edx <== NOT EXECUTED
107131: 52 push %edx <== NOT EXECUTED
107132: ff 35 38 6d 12 00 pushl 0x126d38 <== NOT EXECUTED
107138: e8 7b fe ff ff call 106fb8 <Stack_check_report_blown_task><== NOT EXECUTED
001071a8 <rtems_stack_checker_report_usage>:
void rtems_stack_checker_report_usage( void )
{
1071a8: 55 push %ebp <== NOT EXECUTED
1071a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1071ab: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
1071ae: 68 7c 88 10 00 push $0x10887c <== NOT EXECUTED
1071b3: 6a 00 push $0x0 <== NOT EXECUTED
1071b5: e8 86 ff ff ff call 107140 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
1071ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
1071bd: c9 leave <== NOT EXECUTED
1071be: c3 ret <== NOT EXECUTED
00107140 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
107140: 55 push %ebp <== NOT EXECUTED
107141: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107143: 56 push %esi <== NOT EXECUTED
107144: 53 push %ebx <== NOT EXECUTED
107145: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
107148: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED
if ( !print )
10714b: 85 db test %ebx,%ebx <== NOT EXECUTED
10714d: 74 50 je 10719f <rtems_stack_checker_report_usage_with_plugin+0x5f><== NOT EXECUTED
return;
print_context = context;
10714f: 89 35 c8 65 12 00 mov %esi,0x1265c8 <== NOT EXECUTED
print_handler = print;
107155: 89 1d cc 65 12 00 mov %ebx,0x1265cc <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
10715b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10715e: 68 8c 01 12 00 push $0x12018c <== NOT EXECUTED
107163: 56 push %esi <== NOT EXECUTED
107164: ff d3 call *%ebx <== NOT EXECUTED
(*print)( context,
107166: 59 pop %ecx <== NOT EXECUTED
107167: 58 pop %eax <== NOT EXECUTED
107168: 68 10 02 12 00 push $0x120210 <== NOT EXECUTED
10716d: 56 push %esi <== NOT EXECUTED
10716e: ff d3 call *%ebx <== NOT EXECUTED
" ID NAME LOW HIGH CURRENT AVAILABLE USED\n"
);
/* iterate over all threads and dump the usage */
rtems_iterate_over_all_threads( Stack_check_Dump_threads_usage );
107170: c7 04 24 90 6d 10 00 movl $0x106d90,(%esp) <== NOT EXECUTED
107177: e8 78 4f 00 00 call 10c0f4 <rtems_iterate_over_all_threads><== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
/* dump interrupt stack info if any */
Stack_check_Dump_threads_usage((Thread_Control *) -1);
10717c: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED
107183: e8 08 fc ff ff call 106d90 <Stack_check_Dump_threads_usage><== NOT EXECUTED
#endif
print_context = NULL;
107188: c7 05 c8 65 12 00 00 movl $0x0,0x1265c8 <== NOT EXECUTED
10718f: 00 00 00
print_handler = NULL;
107192: c7 05 cc 65 12 00 00 movl $0x0,0x1265cc <== NOT EXECUTED
107199: 00 00 00
10719c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
10719f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
1071a2: 5b pop %ebx <== NOT EXECUTED
1071a3: 5e pop %esi <== NOT EXECUTED
1071a4: c9 leave <== NOT EXECUTED
1071a5: c3 ret <== NOT EXECUTED
00107074 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
107074: 55 push %ebp
107075: 89 e5 mov %esp,%ebp
107077: 57 push %edi
107078: 56 push %esi
107079: 8b 45 08 mov 0x8(%ebp),%eax
Stack_Control *the_stack = &running->Start.Initial_stack;
void *pattern;
bool sp_ok;
bool pattern_ok = true;
pattern = Stack_check_Get_pattern_area(the_stack);
10707c: 8b 90 b8 00 00 00 mov 0xb8(%eax),%edx
107082: 8d 72 08 lea 0x8(%edx),%esi
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
107085: 39 d5 cmp %edx,%ebp
107087: 72 0a jb 107093 <rtems_stack_checker_switch_extension+0x1f><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
107089: 03 90 b4 00 00 00 add 0xb4(%eax),%edx
10708f: 39 d5 cmp %edx,%ebp
107091: 76 1d jbe 1070b0 <rtems_stack_checker_switch_extension+0x3c><== ALWAYS TAKEN
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
107093: bf 20 69 12 00 mov $0x126920,%edi <== NOT EXECUTED
107098: b9 10 00 00 00 mov $0x10,%ecx <== NOT EXECUTED
10709d: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED
10709f: 0f 94 c2 sete %dl <== NOT EXECUTED
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( running, pattern_ok );
1070a2: 56 push %esi <== NOT EXECUTED
1070a3: 56 push %esi <== NOT EXECUTED
1070a4: 0f b6 d2 movzbl %dl,%edx <== NOT EXECUTED
1070a7: 52 push %edx <== NOT EXECUTED
1070a8: 50 push %eax <== NOT EXECUTED
1070a9: e8 0a ff ff ff call 106fb8 <Stack_check_report_blown_task><== NOT EXECUTED
1070ae: 66 90 xchg %ax,%ax <== NOT EXECUTED
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
1070b0: bf 20 69 12 00 mov $0x126920,%edi
1070b5: b9 10 00 00 00 mov $0x10,%ecx
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
1070ba: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
1070bc: 75 07 jne 1070c5 <rtems_stack_checker_switch_extension+0x51><== NEVER TAKEN
Stack_check_report_blown_task( running, pattern_ok );
}
}
1070be: 8d 65 f8 lea -0x8(%ebp),%esp
1070c1: 5e pop %esi
1070c2: 5f pop %edi
1070c3: c9 leave
1070c4: c3 ret
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
1070c5: 31 d2 xor %edx,%edx <== NOT EXECUTED
1070c7: eb d9 jmp 1070a2 <rtems_stack_checker_switch_extension+0x2e><== NOT EXECUTED
0010fdd0 <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
10fdd0: 55 push %ebp
10fdd1: 89 e5 mov %esp,%ebp
10fdd3: 57 push %edi
10fdd4: 56 push %esi
10fdd5: 53 push %ebx
10fdd6: 83 ec 2c sub $0x2c,%esp
10fdd9: 8b 75 08 mov 0x8(%ebp),%esi
10fddc: 8b 5d 0c mov 0xc(%ebp),%ebx
10fddf: 8b 7d 10 mov 0x10(%ebp),%edi
double result;
char *end;
if ( !n )
10fde2: 85 db test %ebx,%ebx
10fde4: 0f 84 b2 00 00 00 je 10fe9c <rtems_string_to_double+0xcc>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10fdea: e8 4d 28 00 00 call 11263c <__errno>
10fdef: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10fdf5: c7 03 00 00 00 00 movl $0x0,(%ebx)
10fdfb: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
result = strtod( s, &end );
10fe02: 83 ec 08 sub $0x8,%esp
10fe05: 8d 45 e4 lea -0x1c(%ebp),%eax
10fe08: 50 push %eax
10fe09: 56 push %esi
10fe0a: e8 39 52 00 00 call 115048 <strtod>
if ( endptr )
10fe0f: 83 c4 10 add $0x10,%esp
10fe12: 85 ff test %edi,%edi
10fe14: 0f 84 92 00 00 00 je 10feac <rtems_string_to_double+0xdc>
*endptr = end;
10fe1a: 8b 45 e4 mov -0x1c(%ebp),%eax
10fe1d: 89 07 mov %eax,(%edi)
if ( end == s )
10fe1f: 39 c6 cmp %eax,%esi
10fe21: 74 69 je 10fe8c <rtems_string_to_double+0xbc>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10fe23: dd 5d c8 fstpl -0x38(%ebp)
10fe26: e8 11 28 00 00 call 11263c <__errno>
10fe2b: 83 38 22 cmpl $0x22,(%eax)
10fe2e: dd 45 c8 fldl -0x38(%ebp)
10fe31: 74 0d je 10fe40 <rtems_string_to_double+0x70>
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
*n = result;
10fe33: dd 1b fstpl (%ebx)
return RTEMS_SUCCESSFUL;
10fe35: 31 c0 xor %eax,%eax
}
10fe37: 8d 65 f4 lea -0xc(%ebp),%esp
10fe3a: 5b pop %ebx
10fe3b: 5e pop %esi
10fe3c: 5f pop %edi
10fe3d: c9 leave
10fe3e: c3 ret
10fe3f: 90 nop
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10fe40: d9 ee fldz
10fe42: d9 c9 fxch %st(1)
10fe44: dd e1 fucom %st(1)
10fe46: df e0 fnstsw %ax
10fe48: dd d9 fstp %st(1)
10fe4a: 80 e4 45 and $0x45,%ah
10fe4d: 80 fc 40 cmp $0x40,%ah
10fe50: 74 26 je 10fe78 <rtems_string_to_double+0xa8><== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
10fe52: dd 05 90 47 12 00 fldl 0x124790
10fe58: d9 c9 fxch %st(1)
10fe5a: dd e1 fucom %st(1)
10fe5c: df e0 fnstsw %ax
10fe5e: dd d9 fstp %st(1)
10fe60: f6 c4 45 test $0x45,%ah
10fe63: 74 17 je 10fe7c <rtems_string_to_double+0xac><== ALWAYS TAKEN
10fe65: dd 05 98 47 12 00 fldl 0x124798 <== NOT EXECUTED
10fe6b: dd e9 fucomp %st(1) <== NOT EXECUTED
10fe6d: df e0 fnstsw %ax <== NOT EXECUTED
10fe6f: f6 c4 45 test $0x45,%ah <== NOT EXECUTED
10fe72: 75 bf jne 10fe33 <rtems_string_to_double+0x63><== NOT EXECUTED
10fe74: dd d8 fstp %st(0) <== NOT EXECUTED
10fe76: eb 06 jmp 10fe7e <rtems_string_to_double+0xae><== NOT EXECUTED
10fe78: dd d8 fstp %st(0) <== NOT EXECUTED
10fe7a: eb 02 jmp 10fe7e <rtems_string_to_double+0xae><== NOT EXECUTED
10fe7c: dd d8 fstp %st(0)
return RTEMS_INVALID_NUMBER;
10fe7e: b8 0a 00 00 00 mov $0xa,%eax
*n = result;
return RTEMS_SUCCESSFUL;
}
10fe83: 8d 65 f4 lea -0xc(%ebp),%esp
10fe86: 5b pop %ebx
10fe87: 5e pop %esi
10fe88: 5f pop %edi
10fe89: c9 leave
10fe8a: c3 ret
10fe8b: 90 nop
10fe8c: dd d8 fstp %st(0)
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
10fe8e: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
10fe93: 8d 65 f4 lea -0xc(%ebp),%esp
10fe96: 5b pop %ebx
10fe97: 5e pop %esi
10fe98: 5f pop %edi
10fe99: c9 leave
10fe9a: c3 ret
10fe9b: 90 nop
{
double result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10fe9c: b8 09 00 00 00 mov $0x9,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
10fea1: 8d 65 f4 lea -0xc(%ebp),%esp
10fea4: 5b pop %ebx
10fea5: 5e pop %esi
10fea6: 5f pop %edi
10fea7: c9 leave
10fea8: c3 ret
10fea9: 8d 76 00 lea 0x0(%esi),%esi
errno = 0;
*n = 0;
result = strtod( s, &end );
if ( endptr )
10feac: 8b 45 e4 mov -0x1c(%ebp),%eax
10feaf: e9 6b ff ff ff jmp 10fe1f <rtems_string_to_double+0x4f>
0010feb4 <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
10feb4: 55 push %ebp
10feb5: 89 e5 mov %esp,%ebp
10feb7: 57 push %edi
10feb8: 56 push %esi
10feb9: 53 push %ebx
10feba: 83 ec 2c sub $0x2c,%esp
10febd: 8b 75 08 mov 0x8(%ebp),%esi
10fec0: 8b 5d 0c mov 0xc(%ebp),%ebx
10fec3: 8b 7d 10 mov 0x10(%ebp),%edi
float result;
char *end;
if ( !n )
10fec6: 85 db test %ebx,%ebx
10fec8: 0f 84 aa 00 00 00 je 10ff78 <rtems_string_to_float+0xc4>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10fece: e8 69 27 00 00 call 11263c <__errno>
10fed3: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10fed9: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtof( s, &end );
10fedf: 83 ec 08 sub $0x8,%esp
10fee2: 8d 45 e4 lea -0x1c(%ebp),%eax
10fee5: 50 push %eax
10fee6: 56 push %esi
10fee7: e8 78 51 00 00 call 115064 <strtof>
if ( endptr )
10feec: 83 c4 10 add $0x10,%esp
10feef: 85 ff test %edi,%edi
10fef1: 0f 84 91 00 00 00 je 10ff88 <rtems_string_to_float+0xd4>
*endptr = end;
10fef7: 8b 45 e4 mov -0x1c(%ebp),%eax
10fefa: 89 07 mov %eax,(%edi)
if ( end == s )
10fefc: 39 c6 cmp %eax,%esi
10fefe: 74 68 je 10ff68 <rtems_string_to_float+0xb4>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10ff00: d9 5d c8 fstps -0x38(%ebp)
10ff03: e8 34 27 00 00 call 11263c <__errno>
10ff08: 83 38 22 cmpl $0x22,(%eax)
10ff0b: d9 45 c8 flds -0x38(%ebp)
10ff0e: 74 0c je 10ff1c <rtems_string_to_float+0x68>
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
*n = result;
10ff10: d9 1b fstps (%ebx)
return RTEMS_SUCCESSFUL;
10ff12: 31 c0 xor %eax,%eax
}
10ff14: 8d 65 f4 lea -0xc(%ebp),%esp
10ff17: 5b pop %ebx
10ff18: 5e pop %esi
10ff19: 5f pop %edi
10ff1a: c9 leave
10ff1b: c3 ret
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10ff1c: d9 ee fldz
10ff1e: d9 c9 fxch %st(1)
10ff20: dd e1 fucom %st(1)
10ff22: df e0 fnstsw %ax
10ff24: dd d9 fstp %st(1)
10ff26: 80 e4 45 and $0x45,%ah
10ff29: 80 fc 40 cmp $0x40,%ah
10ff2c: 74 26 je 10ff54 <rtems_string_to_float+0xa0><== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
10ff2e: d9 05 a0 47 12 00 flds 0x1247a0
10ff34: d9 c9 fxch %st(1)
10ff36: dd e1 fucom %st(1)
10ff38: df e0 fnstsw %ax
10ff3a: dd d9 fstp %st(1)
10ff3c: f6 c4 45 test $0x45,%ah
10ff3f: 74 17 je 10ff58 <rtems_string_to_float+0xa4><== ALWAYS TAKEN
10ff41: d9 05 a4 47 12 00 flds 0x1247a4 <== NOT EXECUTED
10ff47: dd e9 fucomp %st(1) <== NOT EXECUTED
10ff49: df e0 fnstsw %ax <== NOT EXECUTED
10ff4b: f6 c4 45 test $0x45,%ah <== NOT EXECUTED
10ff4e: 75 c0 jne 10ff10 <rtems_string_to_float+0x5c><== NOT EXECUTED
10ff50: dd d8 fstp %st(0) <== NOT EXECUTED
10ff52: eb 06 jmp 10ff5a <rtems_string_to_float+0xa6><== NOT EXECUTED
10ff54: dd d8 fstp %st(0) <== NOT EXECUTED
10ff56: eb 02 jmp 10ff5a <rtems_string_to_float+0xa6><== NOT EXECUTED
10ff58: dd d8 fstp %st(0)
return RTEMS_INVALID_NUMBER;
10ff5a: b8 0a 00 00 00 mov $0xa,%eax
*n = result;
return RTEMS_SUCCESSFUL;
}
10ff5f: 8d 65 f4 lea -0xc(%ebp),%esp
10ff62: 5b pop %ebx
10ff63: 5e pop %esi
10ff64: 5f pop %edi
10ff65: c9 leave
10ff66: c3 ret
10ff67: 90 nop
10ff68: dd d8 fstp %st(0)
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
10ff6a: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
10ff6f: 8d 65 f4 lea -0xc(%ebp),%esp
10ff72: 5b pop %ebx
10ff73: 5e pop %esi
10ff74: 5f pop %edi
10ff75: c9 leave
10ff76: c3 ret
10ff77: 90 nop
{
float result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10ff78: b8 09 00 00 00 mov $0x9,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
10ff7d: 8d 65 f4 lea -0xc(%ebp),%esp
10ff80: 5b pop %ebx
10ff81: 5e pop %esi
10ff82: 5f pop %edi
10ff83: c9 leave
10ff84: c3 ret
10ff85: 8d 76 00 lea 0x0(%esi),%esi
errno = 0;
*n = 0;
result = strtof( s, &end );
if ( endptr )
10ff88: 8b 45 e4 mov -0x1c(%ebp),%eax
10ff8b: e9 6c ff ff ff jmp 10fefc <rtems_string_to_float+0x48>
0010ff90 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
10ff90: 55 push %ebp
10ff91: 89 e5 mov %esp,%ebp
10ff93: 57 push %edi
10ff94: 56 push %esi
10ff95: 53 push %ebx
10ff96: 83 ec 2c sub $0x2c,%esp
10ff99: 8b 75 08 mov 0x8(%ebp),%esi
10ff9c: 8b 5d 0c mov 0xc(%ebp),%ebx
10ff9f: 8b 7d 10 mov 0x10(%ebp),%edi
long result;
char *end;
if ( !n )
10ffa2: 85 db test %ebx,%ebx
10ffa4: 0f 84 82 00 00 00 je 11002c <rtems_string_to_int+0x9c><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
errno = 0;
10ffaa: e8 8d 26 00 00 call 11263c <__errno>
10ffaf: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10ffb5: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtol( s, &end, base );
10ffbb: 50 push %eax
10ffbc: ff 75 14 pushl 0x14(%ebp)
10ffbf: 8d 45 e4 lea -0x1c(%ebp),%eax
10ffc2: 50 push %eax
10ffc3: 56 push %esi
10ffc4: e8 5b 52 00 00 call 115224 <strtol>
10ffc9: 89 c2 mov %eax,%edx
if ( endptr )
10ffcb: 83 c4 10 add $0x10,%esp
10ffce: 85 ff test %edi,%edi
10ffd0: 74 6a je 11003c <rtems_string_to_int+0xac><== NEVER TAKEN
*endptr = end;
10ffd2: 8b 45 e4 mov -0x1c(%ebp),%eax
10ffd5: 89 07 mov %eax,(%edi)
if ( end == s )
10ffd7: 39 c6 cmp %eax,%esi
10ffd9: 74 41 je 11001c <rtems_string_to_int+0x8c><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10ffdb: 89 55 d4 mov %edx,-0x2c(%ebp)
10ffde: e8 59 26 00 00 call 11263c <__errno>
10ffe3: 83 38 22 cmpl $0x22,(%eax)
10ffe6: 8b 55 d4 mov -0x2c(%ebp),%edx
10ffe9: 74 0d je 10fff8 <rtems_string_to_int+0x68>
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
10ffeb: 89 13 mov %edx,(%ebx)
return RTEMS_SUCCESSFUL;
10ffed: 31 c0 xor %eax,%eax
}
10ffef: 8d 65 f4 lea -0xc(%ebp),%esp
10fff2: 5b pop %ebx
10fff3: 5e pop %esi
10fff4: 5f pop %edi
10fff5: c9 leave
10fff6: c3 ret
10fff7: 90 nop
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10fff8: 85 d2 test %edx,%edx
10fffa: 74 10 je 11000c <rtems_string_to_int+0x7c><== NEVER TAKEN
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
10fffc: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx
110002: 74 08 je 11000c <rtems_string_to_int+0x7c><== ALWAYS TAKEN
110004: 81 fa 00 00 00 80 cmp $0x80000000,%edx <== NOT EXECUTED
11000a: 75 df jne 10ffeb <rtems_string_to_int+0x5b><== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
11000c: b8 0a 00 00 00 mov $0xa,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
110011: 8d 65 f4 lea -0xc(%ebp),%esp
110014: 5b pop %ebx
110015: 5e pop %esi
110016: 5f pop %edi
110017: c9 leave
110018: c3 ret
110019: 8d 76 00 lea 0x0(%esi),%esi
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
11001c: b8 0b 00 00 00 mov $0xb,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
110021: 8d 65 f4 lea -0xc(%ebp),%esp
110024: 5b pop %ebx
110025: 5e pop %esi
110026: 5f pop %edi
110027: c9 leave
110028: c3 ret
110029: 8d 76 00 lea 0x0(%esi),%esi
{
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
11002c: b8 09 00 00 00 mov $0x9,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
110031: 8d 65 f4 lea -0xc(%ebp),%esp
110034: 5b pop %ebx
110035: 5e pop %esi
110036: 5f pop %edi
110037: c9 leave
110038: c3 ret
110039: 8d 76 00 lea 0x0(%esi),%esi
errno = 0;
*n = 0;
result = strtol( s, &end, base );
if ( endptr )
11003c: 8b 45 e4 mov -0x1c(%ebp),%eax
11003f: eb 96 jmp 10ffd7 <rtems_string_to_int+0x47>
00110110 <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
110110: 55 push %ebp
110111: 89 e5 mov %esp,%ebp
110113: 57 push %edi
110114: 56 push %esi
110115: 53 push %ebx
110116: 83 ec 2c sub $0x2c,%esp
110119: 8b 75 08 mov 0x8(%ebp),%esi
11011c: 8b 5d 0c mov 0xc(%ebp),%ebx
11011f: 8b 7d 10 mov 0x10(%ebp),%edi
long result;
char *end;
if ( !n )
110122: 85 db test %ebx,%ebx
110124: 0f 84 82 00 00 00 je 1101ac <rtems_string_to_long+0x9c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
11012a: e8 0d 25 00 00 call 11263c <__errno>
11012f: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
110135: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtol( s, &end, base );
11013b: 50 push %eax
11013c: ff 75 14 pushl 0x14(%ebp)
11013f: 8d 45 e4 lea -0x1c(%ebp),%eax
110142: 50 push %eax
110143: 56 push %esi
110144: e8 db 50 00 00 call 115224 <strtol>
110149: 89 c2 mov %eax,%edx
if ( endptr )
11014b: 83 c4 10 add $0x10,%esp
11014e: 85 ff test %edi,%edi
110150: 74 6a je 1101bc <rtems_string_to_long+0xac>
*endptr = end;
110152: 8b 45 e4 mov -0x1c(%ebp),%eax
110155: 89 07 mov %eax,(%edi)
if ( end == s )
110157: 39 c6 cmp %eax,%esi
110159: 74 41 je 11019c <rtems_string_to_long+0x8c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
11015b: 89 55 d4 mov %edx,-0x2c(%ebp)
11015e: e8 d9 24 00 00 call 11263c <__errno>
110163: 83 38 22 cmpl $0x22,(%eax)
110166: 8b 55 d4 mov -0x2c(%ebp),%edx
110169: 74 0d je 110178 <rtems_string_to_long+0x68>
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
11016b: 89 13 mov %edx,(%ebx)
return RTEMS_SUCCESSFUL;
11016d: 31 c0 xor %eax,%eax
}
11016f: 8d 65 f4 lea -0xc(%ebp),%esp
110172: 5b pop %ebx
110173: 5e pop %esi
110174: 5f pop %edi
110175: c9 leave
110176: c3 ret
110177: 90 nop
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
110178: 85 d2 test %edx,%edx
11017a: 74 10 je 11018c <rtems_string_to_long+0x7c><== NEVER TAKEN
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
11017c: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx
110182: 74 08 je 11018c <rtems_string_to_long+0x7c>
110184: 81 fa 00 00 00 80 cmp $0x80000000,%edx
11018a: 75 df jne 11016b <rtems_string_to_long+0x5b><== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
11018c: b8 0a 00 00 00 mov $0xa,%eax
*n = result;
return RTEMS_SUCCESSFUL;
}
110191: 8d 65 f4 lea -0xc(%ebp),%esp
110194: 5b pop %ebx
110195: 5e pop %esi
110196: 5f pop %edi
110197: c9 leave
110198: c3 ret
110199: 8d 76 00 lea 0x0(%esi),%esi
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
11019c: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
1101a1: 8d 65 f4 lea -0xc(%ebp),%esp
1101a4: 5b pop %ebx
1101a5: 5e pop %esi
1101a6: 5f pop %edi
1101a7: c9 leave
1101a8: c3 ret
1101a9: 8d 76 00 lea 0x0(%esi),%esi
{
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
1101ac: b8 09 00 00 00 mov $0x9,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
1101b1: 8d 65 f4 lea -0xc(%ebp),%esp
1101b4: 5b pop %ebx
1101b5: 5e pop %esi
1101b6: 5f pop %edi
1101b7: c9 leave
1101b8: c3 ret
1101b9: 8d 76 00 lea 0x0(%esi),%esi
errno = 0;
*n = 0;
result = strtol( s, &end, base );
if ( endptr )
1101bc: 8b 45 e4 mov -0x1c(%ebp),%eax
1101bf: eb 96 jmp 110157 <rtems_string_to_long+0x47>
00110044 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
110044: 55 push %ebp
110045: 89 e5 mov %esp,%ebp
110047: 57 push %edi
110048: 56 push %esi
110049: 53 push %ebx
11004a: 83 ec 2c sub $0x2c,%esp
11004d: 8b 5d 0c mov 0xc(%ebp),%ebx
110050: 8b 7d 10 mov 0x10(%ebp),%edi
long long result;
char *end;
if ( !n )
110053: 85 db test %ebx,%ebx
110055: 0f 84 9d 00 00 00 je 1100f8 <rtems_string_to_long_long+0xb4>
return RTEMS_INVALID_ADDRESS;
errno = 0;
11005b: e8 dc 25 00 00 call 11263c <__errno>
110060: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
110066: c7 03 00 00 00 00 movl $0x0,(%ebx)
11006c: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
result = strtoll( s, &end, base );
110073: 50 push %eax
110074: ff 75 14 pushl 0x14(%ebp)
110077: 8d 45 e4 lea -0x1c(%ebp),%eax
11007a: 50 push %eax
11007b: ff 75 08 pushl 0x8(%ebp)
11007e: e8 bd 51 00 00 call 115240 <strtoll>
110083: 89 c6 mov %eax,%esi
if ( endptr )
110085: 83 c4 10 add $0x10,%esp
110088: 85 ff test %edi,%edi
11008a: 74 7c je 110108 <rtems_string_to_long_long+0xc4>
*endptr = end;
11008c: 8b 45 e4 mov -0x1c(%ebp),%eax
11008f: 89 07 mov %eax,(%edi)
if ( end == s )
110091: 39 45 08 cmp %eax,0x8(%ebp)
110094: 74 52 je 1100e8 <rtems_string_to_long_long+0xa4>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
110096: 89 55 d4 mov %edx,-0x2c(%ebp)
110099: e8 9e 25 00 00 call 11263c <__errno>
11009e: 83 38 22 cmpl $0x22,(%eax)
1100a1: 8b 55 d4 mov -0x2c(%ebp),%edx
1100a4: 74 12 je 1100b8 <rtems_string_to_long_long+0x74>
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
1100a6: 89 33 mov %esi,(%ebx)
1100a8: 89 53 04 mov %edx,0x4(%ebx)
return RTEMS_SUCCESSFUL;
1100ab: 31 c0 xor %eax,%eax
}
1100ad: 8d 65 f4 lea -0xc(%ebp),%esp
1100b0: 5b pop %ebx
1100b1: 5e pop %esi
1100b2: 5f pop %edi
1100b3: c9 leave
1100b4: c3 ret
1100b5: 8d 76 00 lea 0x0(%esi),%esi
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1100b8: 89 d0 mov %edx,%eax
1100ba: 09 f0 or %esi,%eax
1100bc: 74 1a je 1100d8 <rtems_string_to_long_long+0x94><== NEVER TAKEN
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
1100be: 89 d1 mov %edx,%ecx
1100c0: 81 f1 ff ff ff 7f xor $0x7fffffff,%ecx
1100c6: 89 f0 mov %esi,%eax
1100c8: f7 d0 not %eax
1100ca: 09 c1 or %eax,%ecx
1100cc: 74 0a je 1100d8 <rtems_string_to_long_long+0x94>
1100ce: 8d 82 00 00 00 80 lea -0x80000000(%edx),%eax
1100d4: 09 f0 or %esi,%eax
1100d6: 75 ce jne 1100a6 <rtems_string_to_long_long+0x62><== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
1100d8: b8 0a 00 00 00 mov $0xa,%eax
*n = result;
return RTEMS_SUCCESSFUL;
}
1100dd: 8d 65 f4 lea -0xc(%ebp),%esp
1100e0: 5b pop %ebx
1100e1: 5e pop %esi
1100e2: 5f pop %edi
1100e3: c9 leave
1100e4: c3 ret
1100e5: 8d 76 00 lea 0x0(%esi),%esi
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
1100e8: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
1100ed: 8d 65 f4 lea -0xc(%ebp),%esp
1100f0: 5b pop %ebx
1100f1: 5e pop %esi
1100f2: 5f pop %edi
1100f3: c9 leave
1100f4: c3 ret
1100f5: 8d 76 00 lea 0x0(%esi),%esi
{
long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
1100f8: b8 09 00 00 00 mov $0x9,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
1100fd: 8d 65 f4 lea -0xc(%ebp),%esp
110100: 5b pop %ebx
110101: 5e pop %esi
110102: 5f pop %edi
110103: c9 leave
110104: c3 ret
110105: 8d 76 00 lea 0x0(%esi),%esi
errno = 0;
*n = 0;
result = strtoll( s, &end, base );
if ( endptr )
110108: 8b 45 e4 mov -0x1c(%ebp),%eax
11010b: eb 84 jmp 110091 <rtems_string_to_long_long+0x4d>
001101dc <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
1101dc: 55 push %ebp
1101dd: 89 e5 mov %esp,%ebp
1101df: 57 push %edi
1101e0: 56 push %esi
1101e1: 53 push %ebx
1101e2: 83 ec 2c sub $0x2c,%esp
1101e5: 8b 75 08 mov 0x8(%ebp),%esi
1101e8: 8b 5d 0c mov 0xc(%ebp),%ebx
1101eb: 8b 7d 10 mov 0x10(%ebp),%edi
unsigned long result;
char *end;
if ( !n )
1101ee: 85 db test %ebx,%ebx
1101f0: 0f 84 92 00 00 00 je 110288 <rtems_string_to_unsigned_char+0xac>
return RTEMS_INVALID_ADDRESS;
errno = 0;
1101f6: e8 41 24 00 00 call 11263c <__errno>
1101fb: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
110201: c6 03 00 movb $0x0,(%ebx)
result = strtoul( s, &end, base );
110204: 50 push %eax
110205: ff 75 14 pushl 0x14(%ebp)
110208: 8d 45 e4 lea -0x1c(%ebp),%eax
11020b: 50 push %eax
11020c: 56 push %esi
11020d: e8 ce 54 00 00 call 1156e0 <strtoul>
110212: 89 c2 mov %eax,%edx
if ( endptr )
110214: 83 c4 10 add $0x10,%esp
110217: 85 ff test %edi,%edi
110219: 74 7d je 110298 <rtems_string_to_unsigned_char+0xbc>
*endptr = end;
11021b: 8b 45 e4 mov -0x1c(%ebp),%eax
11021e: 89 07 mov %eax,(%edi)
if ( end == s )
110220: 39 c6 cmp %eax,%esi
110222: 74 54 je 110278 <rtems_string_to_unsigned_char+0x9c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
110224: 89 55 d4 mov %edx,-0x2c(%ebp)
110227: e8 10 24 00 00 call 11263c <__errno>
11022c: 83 38 22 cmpl $0x22,(%eax)
11022f: 8b 55 d4 mov -0x2c(%ebp),%edx
110232: 74 14 je 110248 <rtems_string_to_unsigned_char+0x6c><== NEVER TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
110234: 81 fa ff 00 00 00 cmp $0xff,%edx
11023a: 77 24 ja 110260 <rtems_string_to_unsigned_char+0x84><== NEVER TAKEN
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
11023c: 88 13 mov %dl,(%ebx)
return RTEMS_SUCCESSFUL;
11023e: 31 c0 xor %eax,%eax
}
110240: 8d 65 f4 lea -0xc(%ebp),%esp
110243: 5b pop %ebx
110244: 5e pop %esi
110245: 5f pop %edi
110246: c9 leave
110247: c3 ret
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
110248: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
11024b: 83 f8 fd cmp $0xfffffffd,%eax <== NOT EXECUTED
11024e: 76 e4 jbe 110234 <rtems_string_to_unsigned_char+0x58><== NOT EXECUTED
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
110250: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
110255: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
110258: 5b pop %ebx <== NOT EXECUTED
110259: 5e pop %esi <== NOT EXECUTED
11025a: 5f pop %edi <== NOT EXECUTED
11025b: c9 leave <== NOT EXECUTED
11025c: c3 ret <== NOT EXECUTED
11025d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
errno = ERANGE;
110260: e8 d7 23 00 00 call 11263c <__errno> <== NOT EXECUTED
110265: c7 00 22 00 00 00 movl $0x22,(%eax) <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
11026b: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
110270: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
110273: 5b pop %ebx <== NOT EXECUTED
110274: 5e pop %esi <== NOT EXECUTED
110275: 5f pop %edi <== NOT EXECUTED
110276: c9 leave <== NOT EXECUTED
110277: c3 ret <== NOT EXECUTED
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
110278: b8 0b 00 00 00 mov $0xb,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
11027d: 8d 65 f4 lea -0xc(%ebp),%esp
110280: 5b pop %ebx
110281: 5e pop %esi
110282: 5f pop %edi
110283: c9 leave
110284: c3 ret
110285: 8d 76 00 lea 0x0(%esi),%esi
{
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
110288: b8 09 00 00 00 mov $0x9,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
11028d: 8d 65 f4 lea -0xc(%ebp),%esp
110290: 5b pop %ebx
110291: 5e pop %esi
110292: 5f pop %edi
110293: c9 leave
110294: c3 ret
110295: 8d 76 00 lea 0x0(%esi),%esi
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
110298: 8b 45 e4 mov -0x1c(%ebp),%eax
11029b: eb 83 jmp 110220 <rtems_string_to_unsigned_char+0x44>
001102a0 <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
1102a0: 55 push %ebp
1102a1: 89 e5 mov %esp,%ebp
1102a3: 57 push %edi
1102a4: 56 push %esi
1102a5: 53 push %ebx
1102a6: 83 ec 2c sub $0x2c,%esp
1102a9: 8b 75 08 mov 0x8(%ebp),%esi
1102ac: 8b 5d 0c mov 0xc(%ebp),%ebx
1102af: 8b 7d 10 mov 0x10(%ebp),%edi
unsigned long result;
char *end;
if ( !n )
1102b2: 85 db test %ebx,%ebx
1102b4: 74 76 je 11032c <rtems_string_to_unsigned_int+0x8c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
1102b6: e8 81 23 00 00 call 11263c <__errno>
1102bb: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
1102c1: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtoul( s, &end, base );
1102c7: 50 push %eax
1102c8: ff 75 14 pushl 0x14(%ebp)
1102cb: 8d 45 e4 lea -0x1c(%ebp),%eax
1102ce: 50 push %eax
1102cf: 56 push %esi
1102d0: e8 0b 54 00 00 call 1156e0 <strtoul>
1102d5: 89 c2 mov %eax,%edx
if ( endptr )
1102d7: 83 c4 10 add $0x10,%esp
1102da: 85 ff test %edi,%edi
1102dc: 74 5e je 11033c <rtems_string_to_unsigned_int+0x9c>
*endptr = end;
1102de: 8b 45 e4 mov -0x1c(%ebp),%eax
1102e1: 89 07 mov %eax,(%edi)
if ( end == s )
1102e3: 39 c6 cmp %eax,%esi
1102e5: 74 35 je 11031c <rtems_string_to_unsigned_int+0x7c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1102e7: 89 55 d4 mov %edx,-0x2c(%ebp)
1102ea: e8 4d 23 00 00 call 11263c <__errno>
1102ef: 83 38 22 cmpl $0x22,(%eax)
1102f2: 8b 55 d4 mov -0x2c(%ebp),%edx
1102f5: 74 0d je 110304 <rtems_string_to_unsigned_int+0x64>
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
1102f7: 89 13 mov %edx,(%ebx)
return RTEMS_SUCCESSFUL;
1102f9: 31 c0 xor %eax,%eax
}
1102fb: 8d 65 f4 lea -0xc(%ebp),%esp
1102fe: 5b pop %ebx
1102ff: 5e pop %esi
110300: 5f pop %edi
110301: c9 leave
110302: c3 ret
110303: 90 nop
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
110304: 8d 42 ff lea -0x1(%edx),%eax
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
110307: 83 f8 fd cmp $0xfffffffd,%eax
11030a: 76 eb jbe 1102f7 <rtems_string_to_unsigned_int+0x57><== NEVER TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
11030c: b8 0a 00 00 00 mov $0xa,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
110311: 8d 65 f4 lea -0xc(%ebp),%esp
110314: 5b pop %ebx
110315: 5e pop %esi
110316: 5f pop %edi
110317: c9 leave
110318: c3 ret
110319: 8d 76 00 lea 0x0(%esi),%esi
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
11031c: b8 0b 00 00 00 mov $0xb,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
110321: 8d 65 f4 lea -0xc(%ebp),%esp
110324: 5b pop %ebx
110325: 5e pop %esi
110326: 5f pop %edi
110327: c9 leave
110328: c3 ret
110329: 8d 76 00 lea 0x0(%esi),%esi
{
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
11032c: b8 09 00 00 00 mov $0x9,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
110331: 8d 65 f4 lea -0xc(%ebp),%esp
110334: 5b pop %ebx
110335: 5e pop %esi
110336: 5f pop %edi
110337: c9 leave
110338: c3 ret
110339: 8d 76 00 lea 0x0(%esi),%esi
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
11033c: 8b 45 e4 mov -0x1c(%ebp),%eax
11033f: eb a2 jmp 1102e3 <rtems_string_to_unsigned_int+0x43>
0011040c <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
11040c: 55 push %ebp
11040d: 89 e5 mov %esp,%ebp
11040f: 57 push %edi
110410: 56 push %esi
110411: 53 push %ebx
110412: 83 ec 2c sub $0x2c,%esp
110415: 8b 75 08 mov 0x8(%ebp),%esi
110418: 8b 5d 0c mov 0xc(%ebp),%ebx
11041b: 8b 7d 10 mov 0x10(%ebp),%edi
unsigned long result;
char *end;
if ( !n )
11041e: 85 db test %ebx,%ebx
110420: 74 76 je 110498 <rtems_string_to_unsigned_long+0x8c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
110422: e8 15 22 00 00 call 11263c <__errno>
110427: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
11042d: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtoul( s, &end, base );
110433: 50 push %eax
110434: ff 75 14 pushl 0x14(%ebp)
110437: 8d 45 e4 lea -0x1c(%ebp),%eax
11043a: 50 push %eax
11043b: 56 push %esi
11043c: e8 9f 52 00 00 call 1156e0 <strtoul>
110441: 89 c2 mov %eax,%edx
if ( endptr )
110443: 83 c4 10 add $0x10,%esp
110446: 85 ff test %edi,%edi
110448: 74 5e je 1104a8 <rtems_string_to_unsigned_long+0x9c>
*endptr = end;
11044a: 8b 45 e4 mov -0x1c(%ebp),%eax
11044d: 89 07 mov %eax,(%edi)
if ( end == s )
11044f: 39 c6 cmp %eax,%esi
110451: 74 35 je 110488 <rtems_string_to_unsigned_long+0x7c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
110453: 89 55 d4 mov %edx,-0x2c(%ebp)
110456: e8 e1 21 00 00 call 11263c <__errno>
11045b: 83 38 22 cmpl $0x22,(%eax)
11045e: 8b 55 d4 mov -0x2c(%ebp),%edx
110461: 74 0d je 110470 <rtems_string_to_unsigned_long+0x64>
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
110463: 89 13 mov %edx,(%ebx)
return RTEMS_SUCCESSFUL;
110465: 31 c0 xor %eax,%eax
}
110467: 8d 65 f4 lea -0xc(%ebp),%esp
11046a: 5b pop %ebx
11046b: 5e pop %esi
11046c: 5f pop %edi
11046d: c9 leave
11046e: c3 ret
11046f: 90 nop
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
110470: 8d 42 ff lea -0x1(%edx),%eax
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
110473: 83 f8 fd cmp $0xfffffffd,%eax
110476: 76 eb jbe 110463 <rtems_string_to_unsigned_long+0x57><== NEVER TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
110478: b8 0a 00 00 00 mov $0xa,%eax
*n = result;
return RTEMS_SUCCESSFUL;
}
11047d: 8d 65 f4 lea -0xc(%ebp),%esp
110480: 5b pop %ebx
110481: 5e pop %esi
110482: 5f pop %edi
110483: c9 leave
110484: c3 ret
110485: 8d 76 00 lea 0x0(%esi),%esi
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
110488: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
11048d: 8d 65 f4 lea -0xc(%ebp),%esp
110490: 5b pop %ebx
110491: 5e pop %esi
110492: 5f pop %edi
110493: c9 leave
110494: c3 ret
110495: 8d 76 00 lea 0x0(%esi),%esi
{
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
110498: b8 09 00 00 00 mov $0x9,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
11049d: 8d 65 f4 lea -0xc(%ebp),%esp
1104a0: 5b pop %ebx
1104a1: 5e pop %esi
1104a2: 5f pop %edi
1104a3: c9 leave
1104a4: c3 ret
1104a5: 8d 76 00 lea 0x0(%esi),%esi
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
1104a8: 8b 45 e4 mov -0x1c(%ebp),%eax
1104ab: eb a2 jmp 11044f <rtems_string_to_unsigned_long+0x43>
00110344 <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
110344: 55 push %ebp
110345: 89 e5 mov %esp,%ebp
110347: 57 push %edi
110348: 56 push %esi
110349: 53 push %ebx
11034a: 83 ec 2c sub $0x2c,%esp
11034d: 8b 7d 08 mov 0x8(%ebp),%edi
110350: 8b 5d 0c mov 0xc(%ebp),%ebx
110353: 8b 75 10 mov 0x10(%ebp),%esi
unsigned long long result;
char *end;
if ( !n )
110356: 85 db test %ebx,%ebx
110358: 0f 84 96 00 00 00 je 1103f4 <rtems_string_to_unsigned_long_long+0xb0>
return RTEMS_INVALID_ADDRESS;
errno = 0;
11035e: e8 d9 22 00 00 call 11263c <__errno>
110363: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
110369: c7 03 00 00 00 00 movl $0x0,(%ebx)
11036f: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
result = strtoull( s, &end, base );
110376: 50 push %eax
110377: ff 75 14 pushl 0x14(%ebp)
11037a: 8d 45 e4 lea -0x1c(%ebp),%eax
11037d: 50 push %eax
11037e: 57 push %edi
11037f: e8 78 53 00 00 call 1156fc <strtoull>
110384: 89 d1 mov %edx,%ecx
110386: 89 c2 mov %eax,%edx
if ( endptr )
110388: 83 c4 10 add $0x10,%esp
11038b: 85 f6 test %esi,%esi
11038d: 74 75 je 110404 <rtems_string_to_unsigned_long_long+0xc0>
*endptr = end;
11038f: 8b 45 e4 mov -0x1c(%ebp),%eax
110392: 89 06 mov %eax,(%esi)
if ( end == s )
110394: 39 c7 cmp %eax,%edi
110396: 74 4c je 1103e4 <rtems_string_to_unsigned_long_long+0xa0>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
110398: 89 55 d4 mov %edx,-0x2c(%ebp)
11039b: 89 4d d0 mov %ecx,-0x30(%ebp)
11039e: e8 99 22 00 00 call 11263c <__errno>
1103a3: 83 38 22 cmpl $0x22,(%eax)
1103a6: 8b 55 d4 mov -0x2c(%ebp),%edx
1103a9: 8b 4d d0 mov -0x30(%ebp),%ecx
1103ac: 74 12 je 1103c0 <rtems_string_to_unsigned_long_long+0x7c>
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
1103ae: 89 13 mov %edx,(%ebx)
1103b0: 89 4b 04 mov %ecx,0x4(%ebx)
return RTEMS_SUCCESSFUL;
1103b3: 31 c0 xor %eax,%eax
}
1103b5: 8d 65 f4 lea -0xc(%ebp),%esp
1103b8: 5b pop %ebx
1103b9: 5e pop %esi
1103ba: 5f pop %edi
1103bb: c9 leave
1103bc: c3 ret
1103bd: 8d 76 00 lea 0x0(%esi),%esi
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
1103c0: 89 d6 mov %edx,%esi
1103c2: 89 cf mov %ecx,%edi
1103c4: 83 c6 ff add $0xffffffff,%esi
1103c7: 83 d7 ff adc $0xffffffff,%edi
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1103ca: 83 ff ff cmp $0xffffffff,%edi
1103cd: 72 df jb 1103ae <rtems_string_to_unsigned_long_long+0x6a><== NEVER TAKEN
1103cf: 83 fe fd cmp $0xfffffffd,%esi
1103d2: 76 da jbe 1103ae <rtems_string_to_unsigned_long_long+0x6a><== NEVER TAKEN
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
1103d4: b8 0a 00 00 00 mov $0xa,%eax
*n = result;
return RTEMS_SUCCESSFUL;
}
1103d9: 8d 65 f4 lea -0xc(%ebp),%esp
1103dc: 5b pop %ebx
1103dd: 5e pop %esi
1103de: 5f pop %edi
1103df: c9 leave
1103e0: c3 ret
1103e1: 8d 76 00 lea 0x0(%esi),%esi
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
1103e4: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
1103e9: 8d 65 f4 lea -0xc(%ebp),%esp
1103ec: 5b pop %ebx
1103ed: 5e pop %esi
1103ee: 5f pop %edi
1103ef: c9 leave
1103f0: c3 ret
1103f1: 8d 76 00 lea 0x0(%esi),%esi
{
unsigned long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
1103f4: b8 09 00 00 00 mov $0x9,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
1103f9: 8d 65 f4 lea -0xc(%ebp),%esp
1103fc: 5b pop %ebx
1103fd: 5e pop %esi
1103fe: 5f pop %edi
1103ff: c9 leave
110400: c3 ret
110401: 8d 76 00 lea 0x0(%esi),%esi
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
if ( endptr )
110404: 8b 45 e4 mov -0x1c(%ebp),%eax
110407: eb 8b jmp 110394 <rtems_string_to_unsigned_long_long+0x50>
00107394 <rtems_tarfs_load>:
int rtems_tarfs_load(
char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
107394: 55 push %ebp
107395: 89 e5 mov %esp,%ebp
107397: 57 push %edi
107398: 56 push %esi
107399: 53 push %ebx
10739a: 81 ec d8 01 00 00 sub $0x1d8,%esp
int offset;
unsigned long nblocks;
IMFS_jnode_t *node;
int status;
status = rtems_filesystem_evaluate_path(
1073a0: 31 c0 xor %eax,%eax
1073a2: b9 ff ff ff ff mov $0xffffffff,%ecx
1073a7: 8b 7d 08 mov 0x8(%ebp),%edi
1073aa: f2 ae repnz scas %es:(%edi),%al
1073ac: f7 d1 not %ecx
1073ae: 49 dec %ecx
1073af: 6a 00 push $0x0
1073b1: 8d 45 d0 lea -0x30(%ebp),%eax
1073b4: 89 85 2c fe ff ff mov %eax,-0x1d4(%ebp)
1073ba: 50 push %eax
1073bb: 6a 00 push $0x0
1073bd: 51 push %ecx
1073be: ff 75 08 pushl 0x8(%ebp)
1073c1: e8 9a 0a 00 00 call 107e60 <rtems_filesystem_evaluate_path>
1073c6: 89 85 44 fe ff ff mov %eax,-0x1bc(%ebp)
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
1073cc: 83 c4 20 add $0x20,%esp
1073cf: 85 c0 test %eax,%eax
1073d1: 0f 85 61 01 00 00 jne 107538 <rtems_tarfs_load+0x1a4>
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
1073d7: 8b 45 dc mov -0x24(%ebp),%eax
1073da: 3d 20 52 12 00 cmp $0x125220,%eax
1073df: 0f 85 47 01 00 00 jne 10752c <rtems_tarfs_load+0x198>
1073e5: 31 db xor %ebx,%ebx
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
1073e7: 8d 45 bc lea -0x44(%ebp),%eax
1073ea: 89 85 30 fe ff ff mov %eax,-0x1d0(%ebp)
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
strcpy(full_filename, mountpoint);
1073f0: 8d 95 58 fe ff ff lea -0x1a8(%ebp),%edx
1073f6: 89 95 34 fe ff ff mov %edx,-0x1cc(%ebp)
1073fc: eb 15 jmp 107413 <rtems_tarfs_load+0x7f>
1073fe: 66 90 xchg %ax,%ax
* IMFS_create_node was ONLY passed a NULL when we created the
* root node. We added a new IMFS_create_root_node() so this
* path no longer existed. The result was simpler code which
* should not have this path.
*/
else if (linkflag == REGTYPE) {
107400: 80 bd 53 fe ff ff 30 cmpb $0x30,-0x1ad(%ebp)
107407: 0f 84 43 01 00 00 je 107550 <rtems_tarfs_load+0x1bc>
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
10740d: 8b 9d 54 fe ff ff mov -0x1ac(%ebp),%ebx
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
107413: 8d 83 00 02 00 00 lea 0x200(%ebx),%eax
107419: 89 85 54 fe ff ff mov %eax,-0x1ac(%ebp)
10741f: 8b 55 10 mov 0x10(%ebp),%edx
107422: 39 d0 cmp %edx,%eax
107424: 0f 87 18 01 00 00 ja 107542 <rtems_tarfs_load+0x1ae><== NEVER TAKEN
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
10742a: 03 5d 0c add 0xc(%ebp),%ebx
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
10742d: 8d b3 01 01 00 00 lea 0x101(%ebx),%esi
107433: bf 68 52 12 00 mov $0x125268,%edi
107438: b9 05 00 00 00 mov $0x5,%ecx
10743d: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10743f: 0f 85 fd 00 00 00 jne 107542 <rtems_tarfs_load+0x1ae>
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
107445: 57 push %edi
107446: 6a 63 push $0x63
107448: 53 push %ebx
107449: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax
10744f: 50 push %eax
107450: e8 f7 ed 00 00 call 11624c <strncpy>
filename[MAX_NAME_FIELD_SIZE] = '\0';
107455: c6 45 bb 00 movb $0x0,-0x45(%ebp)
linkflag = hdr_ptr[156];
107459: 8a 93 9c 00 00 00 mov 0x9c(%ebx),%dl
10745f: 88 95 53 fe ff ff mov %dl,-0x1ad(%ebp)
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
107465: 59 pop %ecx
107466: 5e pop %esi
107467: 6a 08 push $0x8
107469: 8d 43 64 lea 0x64(%ebx),%eax
10746c: 50 push %eax
10746d: e8 3a 7b 00 00 call 10efac <_rtems_octal2ulong>
107472: 89 85 48 fe ff ff mov %eax,-0x1b8(%ebp)
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
107478: 58 pop %eax
107479: 5a pop %edx
10747a: 6a 0c push $0xc
10747c: 8d 43 7c lea 0x7c(%ebx),%eax
10747f: 50 push %eax
107480: e8 27 7b 00 00 call 10efac <_rtems_octal2ulong>
107485: 89 85 4c fe ff ff mov %eax,-0x1b4(%ebp)
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
10748b: 5e pop %esi
10748c: 5f pop %edi
10748d: 6a 08 push $0x8
10748f: 8d 83 94 00 00 00 lea 0x94(%ebx),%eax
107495: 50 push %eax
107496: e8 11 7b 00 00 call 10efac <_rtems_octal2ulong>
10749b: 89 c6 mov %eax,%esi
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
10749d: 89 1c 24 mov %ebx,(%esp)
1074a0: e8 db 7f 00 00 call 10f480 <_rtems_tar_header_checksum>
1074a5: 83 c4 10 add $0x10,%esp
1074a8: 39 f0 cmp %esi,%eax
1074aa: 0f 85 92 00 00 00 jne 107542 <rtems_tarfs_load+0x1ae><== NEVER TAKEN
* Generate an IMFS node depending on the file type.
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
1074b0: 80 bd 53 fe ff ff 35 cmpb $0x35,-0x1ad(%ebp)
1074b7: 0f 85 43 ff ff ff jne 107400 <rtems_tarfs_load+0x6c>
strcpy(full_filename, mountpoint);
1074bd: 83 ec 08 sub $0x8,%esp
1074c0: ff 75 08 pushl 0x8(%ebp)
1074c3: 8d 85 58 fe ff ff lea -0x1a8(%ebp),%eax
1074c9: 50 push %eax
1074ca: e8 15 ea 00 00 call 115ee4 <strcpy>
if (full_filename[strlen(full_filename)-1] != '/')
1074cf: 31 c0 xor %eax,%eax
1074d1: b9 ff ff ff ff mov $0xffffffff,%ecx
1074d6: 8b bd 34 fe ff ff mov -0x1cc(%ebp),%edi
1074dc: f2 ae repnz scas %es:(%edi),%al
1074de: f7 d1 not %ecx
1074e0: 49 dec %ecx
1074e1: 83 c4 10 add $0x10,%esp
1074e4: 80 bc 0d 57 fe ff ff cmpb $0x2f,-0x1a9(%ebp,%ecx,1)
1074eb: 2f
1074ec: 74 0a je 1074f8 <rtems_tarfs_load+0x164><== ALWAYS TAKEN
strcat(full_filename, "/");
1074ee: 66 c7 84 0d 58 fe ff movw $0x2f,-0x1a8(%ebp,%ecx,1) <== NOT EXECUTED
1074f5: ff 2f 00
strcat(full_filename, filename);
1074f8: 83 ec 08 sub $0x8,%esp
1074fb: 8d 95 58 ff ff ff lea -0xa8(%ebp),%edx
107501: 52 push %edx
107502: 8d 85 58 fe ff ff lea -0x1a8(%ebp),%eax
107508: 50 push %eax
107509: e8 22 e8 00 00 call 115d30 <strcat>
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
10750e: 5a pop %edx
10750f: 59 pop %ecx
107510: 68 ff 01 00 00 push $0x1ff
107515: 8d 95 58 fe ff ff lea -0x1a8(%ebp),%edx
10751b: 52 push %edx
10751c: e8 fb 10 00 00 call 10861c <mkdir>
107521: 83 c4 10 add $0x10,%esp
107524: e9 e4 fe ff ff jmp 10740d <rtems_tarfs_load+0x79>
107529: 8d 76 00 lea 0x0(%esi),%esi
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
10752c: 3d a0 5c 12 00 cmp $0x125ca0,%eax
107531: 0f 84 ae fe ff ff je 1073e5 <rtems_tarfs_load+0x51> <== NEVER TAKEN
107537: 90 nop
return -1;
107538: c7 85 44 fe ff ff ff movl $0xffffffff,-0x1bc(%ebp)
10753f: ff ff ff
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
return status;
}
107542: 8b 85 44 fe ff ff mov -0x1bc(%ebp),%eax
107548: 8d 65 f4 lea -0xc(%ebp),%esp
10754b: 5b pop %ebx
10754c: 5e pop %esi
10754d: 5f pop %edi
10754e: c9 leave
10754f: c3 ret
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
107550: 8b bd 30 fe ff ff mov -0x1d0(%ebp),%edi
107556: 8b b5 2c fe ff ff mov -0x1d4(%ebp),%esi
10755c: b9 05 00 00 00 mov $0x5,%ecx
107561: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
107563: 50 push %eax
107564: 8d 45 e4 lea -0x1c(%ebp),%eax
107567: 50 push %eax
107568: 8d 55 bc lea -0x44(%ebp),%edx
10756b: 52 push %edx
10756c: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax
107572: 50 push %eax
107573: e8 84 86 00 00 call 10fbfc <IMFS_evaluate_for_make>
107578: 83 c4 10 add $0x10,%esp
10757b: 85 c0 test %eax,%eax
10757d: 74 1d je 10759c <rtems_tarfs_load+0x208><== ALWAYS TAKEN
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
}
nblocks = (((file_size) + 511) & ~511) / 512;
10757f: 8b 85 4c fe ff ff mov -0x1b4(%ebp),%eax
107585: 05 ff 01 00 00 add $0x1ff,%eax
offset += 512 * nblocks;
10758a: 25 00 fe ff ff and $0xfffffe00,%eax
10758f: 01 85 54 fe ff ff add %eax,-0x1ac(%ebp)
107595: e9 73 fe ff ff jmp 10740d <rtems_tarfs_load+0x79>
10759a: 66 90 xchg %ax,%ax
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
node = IMFS_create_node(
10759c: 83 ec 0c sub $0xc,%esp
10759f: 6a 00 push $0x0
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
1075a1: 8b 85 48 fe ff ff mov -0x1b8(%ebp),%eax
1075a7: 25 ff 01 00 00 and $0x1ff,%eax
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
node = IMFS_create_node(
1075ac: 80 cc 80 or $0x80,%ah
1075af: 50 push %eax
1075b0: ff 75 e4 pushl -0x1c(%ebp)
1075b3: 6a 06 push $0x6
1075b5: 8d 55 bc lea -0x44(%ebp),%edx
1075b8: 52 push %edx
1075b9: e8 76 80 00 00 call 10f634 <IMFS_create_node>
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
1075be: 8b 95 4c fe ff ff mov -0x1b4(%ebp),%edx
1075c4: 89 50 50 mov %edx,0x50(%eax)
1075c7: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.linearfile.direct = &tar_image[offset];
1075ce: 8b 55 0c mov 0xc(%ebp),%edx
1075d1: 03 95 54 fe ff ff add -0x1ac(%ebp),%edx
1075d7: 89 50 58 mov %edx,0x58(%eax)
1075da: 83 c4 20 add $0x20,%esp
1075dd: eb a0 jmp 10757f <rtems_tarfs_load+0x1eb>
0010ad44 <rtems_task_create>:
size_t stack_size,
rtems_mode initial_modes,
rtems_attribute attribute_set,
rtems_id *id
)
{
10ad44: 55 push %ebp
10ad45: 89 e5 mov %esp,%ebp
10ad47: 57 push %edi
10ad48: 56 push %esi
10ad49: 53 push %ebx
10ad4a: 83 ec 1c sub $0x1c,%esp
10ad4d: 8b 5d 08 mov 0x8(%ebp),%ebx
10ad50: 8b 7d 0c mov 0xc(%ebp),%edi
10ad53: 8b 75 1c mov 0x1c(%ebp),%esi
Priority_Control core_priority;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
10ad56: 85 f6 test %esi,%esi
10ad58: 0f 84 3e 01 00 00 je 10ae9c <rtems_task_create+0x158>
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
10ad5e: 85 db test %ebx,%ebx
10ad60: 0f 84 d2 00 00 00 je 10ae38 <rtems_task_create+0xf4>
/*
* Validate the RTEMS API priority and convert it to the core priority range.
*/
if ( !_Attributes_Is_system_task( the_attribute_set ) ) {
10ad66: f7 45 18 00 80 00 00 testl $0x8000,0x18(%ebp)
10ad6d: 75 17 jne 10ad86 <rtems_task_create+0x42>
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
10ad6f: 85 ff test %edi,%edi
10ad71: 0f 84 b1 00 00 00 je 10ae28 <rtems_task_create+0xe4>
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
10ad77: 0f b6 05 f4 22 12 00 movzbl 0x1222f4,%eax
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
10ad7e: 39 c7 cmp %eax,%edi
10ad80: 0f 87 a2 00 00 00 ja 10ae28 <rtems_task_create+0xe4>
*/
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
10ad86: 83 ec 0c sub $0xc,%esp
10ad89: ff 35 a0 65 12 00 pushl 0x1265a0
10ad8f: e8 78 06 00 00 call 10b40c <_API_Mutex_Lock>
* This function allocates a task control block from
* the inactive chain of free task control blocks.
*/
RTEMS_INLINE_ROUTINE Thread_Control *_RTEMS_tasks_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_RTEMS_tasks_Information );
10ad94: c7 04 24 80 64 12 00 movl $0x126480,(%esp)
10ad9b: e8 58 0f 00 00 call 10bcf8 <_Objects_Allocate>
10ada0: 89 c2 mov %eax,%edx
* the event of an error.
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
10ada2: 83 c4 10 add $0x10,%esp
10ada5: 85 c0 test %eax,%eax
10ada7: 0f 84 cf 00 00 00 je 10ae7c <rtems_task_create+0x138>
/*
* Initialize the core thread for this task.
*/
status = _Thread_Initialize(
10adad: 50 push %eax
10adae: 53 push %ebx
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
10adaf: 8b 45 14 mov 0x14(%ebp),%eax
10adb2: 83 e0 01 and $0x1,%eax
10adb5: 50 push %eax
10adb6: 6a 00 push $0x0
10adb8: 31 c0 xor %eax,%eax
10adba: f7 45 14 00 02 00 00 testl $0x200,0x14(%ebp)
10adc1: 0f 95 c0 setne %al
10adc4: 50 push %eax
10adc5: 31 c0 xor %eax,%eax
10adc7: f7 45 14 00 01 00 00 testl $0x100,0x14(%ebp)
10adce: 0f 94 c0 sete %al
10add1: 50 push %eax
10add2: 57 push %edi
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_floating_point(
rtems_attribute attribute_set
)
{
return ( attribute_set & RTEMS_FLOATING_POINT ) ? true : false;
10add3: 8b 45 18 mov 0x18(%ebp),%eax
10add6: 83 e0 01 and $0x1,%eax
10add9: 50 push %eax
10adda: ff 75 10 pushl 0x10(%ebp)
10addd: 6a 00 push $0x0
10addf: 52 push %edx
10ade0: 68 80 64 12 00 push $0x126480
10ade5: 89 55 e4 mov %edx,-0x1c(%ebp)
10ade8: e8 ab 1f 00 00 call 10cd98 <_Thread_Initialize>
NULL, /* no budget algorithm callout */
_Modes_Get_interrupt_level(initial_modes),
(Objects_Name) name
);
if ( !status ) {
10aded: 83 c4 30 add $0x30,%esp
10adf0: 84 c0 test %al,%al
10adf2: 8b 55 e4 mov -0x1c(%ebp),%edx
10adf5: 74 51 je 10ae48 <rtems_task_create+0x104>
_RTEMS_Unlock_allocator();
return RTEMS_UNSATISFIED;
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
10adf7: 8b 82 e4 00 00 00 mov 0xe4(%edx),%eax
* id - thread id
* RTEMS_SUCCESSFUL - if successful
* error code - if unsuccessful
*/
rtems_status_code rtems_task_create(
10adfd: f7 45 14 00 04 00 00 testl $0x400,0x14(%ebp)
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
10ae04: 0f 94 40 08 sete 0x8(%eax)
*id = the_thread->Object.id;
10ae08: 8b 42 08 mov 0x8(%edx),%eax
10ae0b: 89 06 mov %eax,(%esi)
);
}
#endif
_RTEMS_Unlock_allocator();
10ae0d: 83 ec 0c sub $0xc,%esp
10ae10: ff 35 a0 65 12 00 pushl 0x1265a0
10ae16: e8 39 06 00 00 call 10b454 <_API_Mutex_Unlock>
return RTEMS_SUCCESSFUL;
10ae1b: 83 c4 10 add $0x10,%esp
10ae1e: 31 c0 xor %eax,%eax
}
10ae20: 8d 65 f4 lea -0xc(%ebp),%esp
10ae23: 5b pop %ebx
10ae24: 5e pop %esi
10ae25: 5f pop %edi
10ae26: c9 leave
10ae27: c3 ret
* Validate the RTEMS API priority and convert it to the core priority range.
*/
if ( !_Attributes_Is_system_task( the_attribute_set ) ) {
if ( !_RTEMS_tasks_Priority_is_valid( initial_priority ) )
return RTEMS_INVALID_PRIORITY;
10ae28: b8 13 00 00 00 mov $0x13,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10ae2d: 8d 65 f4 lea -0xc(%ebp),%esp
10ae30: 5b pop %ebx
10ae31: 5e pop %esi
10ae32: 5f pop %edi
10ae33: c9 leave
10ae34: c3 ret
10ae35: 8d 76 00 lea 0x0(%esi),%esi
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10ae38: b8 03 00 00 00 mov $0x3,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10ae3d: 8d 65 f4 lea -0xc(%ebp),%esp
10ae40: 5b pop %ebx
10ae41: 5e pop %esi
10ae42: 5f pop %edi
10ae43: c9 leave
10ae44: c3 ret
10ae45: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _RTEMS_tasks_Free (
Thread_Control *the_task
)
{
_Objects_Free(
10ae48: 83 ec 0c sub $0xc,%esp
10ae4b: ff 72 08 pushl 0x8(%edx)
10ae4e: e8 89 12 00 00 call 10c0dc <_Objects_Get_information_id>
10ae53: 5a pop %edx
10ae54: 59 pop %ecx
10ae55: 8b 55 e4 mov -0x1c(%ebp),%edx
10ae58: 52 push %edx
10ae59: 50 push %eax
10ae5a: e8 0d 12 00 00 call 10c06c <_Objects_Free>
#if defined(RTEMS_MULTIPROCESSING)
if ( is_global )
_Objects_MP_Free_global_object( the_global_object );
#endif
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
10ae5f: 58 pop %eax
10ae60: ff 35 a0 65 12 00 pushl 0x1265a0
10ae66: e8 e9 05 00 00 call 10b454 <_API_Mutex_Unlock>
return RTEMS_UNSATISFIED;
10ae6b: 83 c4 10 add $0x10,%esp
10ae6e: b8 0d 00 00 00 mov $0xd,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10ae73: 8d 65 f4 lea -0xc(%ebp),%esp
10ae76: 5b pop %ebx
10ae77: 5e pop %esi
10ae78: 5f pop %edi
10ae79: c9 leave
10ae7a: c3 ret
10ae7b: 90 nop
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
_RTEMS_Unlock_allocator();
10ae7c: 83 ec 0c sub $0xc,%esp
10ae7f: ff 35 a0 65 12 00 pushl 0x1265a0
10ae85: e8 ca 05 00 00 call 10b454 <_API_Mutex_Unlock>
return RTEMS_TOO_MANY;
10ae8a: 83 c4 10 add $0x10,%esp
10ae8d: b8 05 00 00 00 mov $0x5,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10ae92: 8d 65 f4 lea -0xc(%ebp),%esp
10ae95: 5b pop %ebx
10ae96: 5e pop %esi
10ae97: 5f pop %edi
10ae98: c9 leave
10ae99: c3 ret
10ae9a: 66 90 xchg %ax,%ax
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10ae9c: b8 09 00 00 00 mov $0x9,%eax
10aea1: eb 8a jmp 10ae2d <rtems_task_create+0xe9>
0010aea4 <rtems_task_delete>:
*/
rtems_status_code rtems_task_delete(
rtems_id id
)
{
10aea4: 55 push %ebp
10aea5: 89 e5 mov %esp,%ebp
10aea7: 53 push %ebx
10aea8: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
10aeab: ff 35 a0 65 12 00 pushl 0x1265a0
10aeb1: e8 56 05 00 00 call 10b40c <_API_Mutex_Lock>
the_thread = _Thread_Get( id, &location );
10aeb6: 5a pop %edx
10aeb7: 59 pop %ecx
10aeb8: 8d 45 f4 lea -0xc(%ebp),%eax
10aebb: 50 push %eax
10aebc: ff 75 08 pushl 0x8(%ebp)
10aebf: e8 5c 1e 00 00 call 10cd20 <_Thread_Get>
10aec4: 89 c3 mov %eax,%ebx
switch ( location ) {
10aec6: 83 c4 10 add $0x10,%esp
10aec9: 8b 45 f4 mov -0xc(%ebp),%eax
10aecc: 85 c0 test %eax,%eax
10aece: 75 44 jne 10af14 <rtems_task_delete+0x70>
case OBJECTS_LOCAL:
the_information = _Objects_Get_information_id( the_thread->Object.id );
10aed0: 83 ec 0c sub $0xc,%esp
10aed3: ff 73 08 pushl 0x8(%ebx)
10aed6: e8 01 12 00 00 call 10c0dc <_Objects_Get_information_id>
0 /* Not used */
);
}
#endif
_Thread_Close( the_information, the_thread );
10aedb: 5a pop %edx
10aedc: 59 pop %ecx
10aedd: 53 push %ebx
10aede: 50 push %eax
10aedf: e8 f0 1a 00 00 call 10c9d4 <_Thread_Close>
10aee4: 58 pop %eax
10aee5: ff 73 08 pushl 0x8(%ebx)
10aee8: e8 ef 11 00 00 call 10c0dc <_Objects_Get_information_id>
10aeed: 5a pop %edx
10aeee: 59 pop %ecx
10aeef: 53 push %ebx
10aef0: 50 push %eax
10aef1: e8 76 11 00 00 call 10c06c <_Objects_Free>
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
10aef6: 58 pop %eax
10aef7: ff 35 a0 65 12 00 pushl 0x1265a0
10aefd: e8 52 05 00 00 call 10b454 <_API_Mutex_Unlock>
_Thread_Enable_dispatch();
10af02: e8 f5 1d 00 00 call 10ccfc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10af07: 83 c4 10 add $0x10,%esp
10af0a: 31 c0 xor %eax,%eax
break;
}
_RTEMS_Unlock_allocator();
return RTEMS_INVALID_ID;
}
10af0c: 8b 5d fc mov -0x4(%ebp),%ebx
10af0f: c9 leave
10af10: c3 ret
10af11: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
_RTEMS_Unlock_allocator();
10af14: 83 ec 0c sub $0xc,%esp
10af17: ff 35 a0 65 12 00 pushl 0x1265a0
10af1d: e8 32 05 00 00 call 10b454 <_API_Mutex_Unlock>
return RTEMS_INVALID_ID;
10af22: 83 c4 10 add $0x10,%esp
10af25: b8 04 00 00 00 mov $0x4,%eax
}
10af2a: 8b 5d fc mov -0x4(%ebp),%ebx
10af2d: c9 leave
10af2e: c3 ret
0010ca6c <rtems_task_get_note>:
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
10ca6c: 55 push %ebp
10ca6d: 89 e5 mov %esp,%ebp
10ca6f: 56 push %esi
10ca70: 53 push %ebx
10ca71: 83 ec 10 sub $0x10,%esp
10ca74: 8b 45 08 mov 0x8(%ebp),%eax
10ca77: 8b 75 0c mov 0xc(%ebp),%esi
10ca7a: 8b 5d 10 mov 0x10(%ebp),%ebx
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
10ca7d: 80 3d 24 52 12 00 00 cmpb $0x0,0x125224
10ca84: 74 6e je 10caf4 <rtems_task_get_note+0x88>
return RTEMS_NOT_CONFIGURED;
if ( !note )
10ca86: 85 db test %ebx,%ebx
10ca88: 74 7e je 10cb08 <rtems_task_get_note+0x9c>
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
10ca8a: 83 fe 0f cmp $0xf,%esi
10ca8d: 77 3d ja 10cacc <rtems_task_get_note+0x60>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10ca8f: 85 c0 test %eax,%eax
10ca91: 74 45 je 10cad8 <rtems_task_get_note+0x6c>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
10ca93: 8b 15 18 9a 12 00 mov 0x129a18,%edx
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10ca99: 3b 42 08 cmp 0x8(%edx),%eax
10ca9c: 74 40 je 10cade <rtems_task_get_note+0x72>
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
10ca9e: 83 ec 08 sub $0x8,%esp
10caa1: 8d 55 f4 lea -0xc(%ebp),%edx
10caa4: 52 push %edx
10caa5: 50 push %eax
10caa6: e8 4d 21 00 00 call 10ebf8 <_Thread_Get>
switch ( location ) {
10caab: 83 c4 10 add $0x10,%esp
10caae: 8b 55 f4 mov -0xc(%ebp),%edx
10cab1: 85 d2 test %edx,%edx
10cab3: 75 4b jne 10cb00 <rtems_task_get_note+0x94>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
10cab5: 8b 80 e4 00 00 00 mov 0xe4(%eax),%eax
10cabb: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax
10cabf: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10cac1: e8 0e 21 00 00 call 10ebd4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10cac6: 31 c0 xor %eax,%eax
10cac8: eb 07 jmp 10cad1 <rtems_task_get_note+0x65>
10caca: 66 90 xchg %ax,%ax
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
return RTEMS_INVALID_NUMBER;
10cacc: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10cad1: 8d 65 f8 lea -0x8(%ebp),%esp
10cad4: 5b pop %ebx
10cad5: 5e pop %esi
10cad6: c9 leave
10cad7: c3 ret
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10cad8: 8b 15 18 9a 12 00 mov 0x129a18,%edx
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
10cade: 8b 82 e4 00 00 00 mov 0xe4(%edx),%eax
10cae4: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax
10cae8: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
10caea: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10caec: 8d 65 f8 lea -0x8(%ebp),%esp
10caef: 5b pop %ebx
10caf0: 5e pop %esi
10caf1: c9 leave
10caf2: c3 ret
10caf3: 90 nop
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
10caf4: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10caf9: 8d 65 f8 lea -0x8(%ebp),%esp
10cafc: 5b pop %ebx
10cafd: 5e pop %esi
10cafe: c9 leave
10caff: c3 ret
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10cb00: b8 04 00 00 00 mov $0x4,%eax
10cb05: eb ca jmp 10cad1 <rtems_task_get_note+0x65>
10cb07: 90 nop
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
if ( !note )
return RTEMS_INVALID_ADDRESS;
10cb08: b8 09 00 00 00 mov $0x9,%eax
10cb0d: eb c2 jmp 10cad1 <rtems_task_get_note+0x65>
0011776c <rtems_task_is_suspended>:
*/
rtems_status_code rtems_task_is_suspended(
rtems_id id
)
{
11776c: 55 push %ebp
11776d: 89 e5 mov %esp,%ebp
11776f: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
117772: 8d 45 f4 lea -0xc(%ebp),%eax
117775: 50 push %eax
117776: ff 75 08 pushl 0x8(%ebp)
117779: e8 ba 3b 00 00 call 11b338 <_Thread_Get>
switch ( location ) {
11777e: 83 c4 10 add $0x10,%esp
117781: 8b 55 f4 mov -0xc(%ebp),%edx
117784: 85 d2 test %edx,%edx
117786: 74 08 je 117790 <rtems_task_is_suspended+0x24>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
117788: b8 04 00 00 00 mov $0x4,%eax
}
11778d: c9 leave
11778e: c3 ret
11778f: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
117790: f6 40 10 02 testb $0x2,0x10(%eax)
117794: 74 0e je 1177a4 <rtems_task_is_suspended+0x38>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
117796: e8 79 3b 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_ALREADY_SUSPENDED;
11779b: b8 0f 00 00 00 mov $0xf,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1177a0: c9 leave
1177a1: c3 ret
1177a2: 66 90 xchg %ax,%ax
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
_Thread_Enable_dispatch();
1177a4: e8 6b 3b 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1177a9: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1177ab: c9 leave
1177ac: c3 ret
0011197c <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
11197c: 55 push %ebp
11197d: 89 e5 mov %esp,%ebp
11197f: 57 push %edi
111980: 56 push %esi
111981: 53 push %ebx
111982: 83 ec 1c sub $0x1c,%esp
111985: 8b 4d 10 mov 0x10(%ebp),%ecx
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
111988: 85 c9 test %ecx,%ecx
11198a: 0f 84 40 01 00 00 je 111ad0 <rtems_task_mode+0x154>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
111990: 8b 1d 78 67 12 00 mov 0x126778,%ebx
api = executing->API_Extensions[ THREAD_API_RTEMS ];
111996: 8b bb e4 00 00 00 mov 0xe4(%ebx),%edi
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
11199c: 80 7b 74 01 cmpb $0x1,0x74(%ebx)
1119a0: 19 f6 sbb %esi,%esi
1119a2: 81 e6 00 01 00 00 and $0x100,%esi
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
1119a8: 8b 53 7c mov 0x7c(%ebx),%edx
1119ab: 85 d2 test %edx,%edx
1119ad: 0f 85 f1 00 00 00 jne 111aa4 <rtems_task_mode+0x128>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
1119b3: 80 7f 08 01 cmpb $0x1,0x8(%edi)
1119b7: 19 d2 sbb %edx,%edx
1119b9: 81 e2 00 04 00 00 and $0x400,%edx
old_mode |= _ISR_Get_level();
1119bf: 89 55 e4 mov %edx,-0x1c(%ebp)
1119c2: 89 4d e0 mov %ecx,-0x20(%ebp)
1119c5: e8 a2 c6 ff ff call 10e06c <_CPU_ISR_Get_level>
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
1119ca: 8b 55 e4 mov -0x1c(%ebp),%edx
1119cd: 09 d0 or %edx,%eax
old_mode |= _ISR_Get_level();
1119cf: 09 f0 or %esi,%eax
1119d1: 8b 4d e0 mov -0x20(%ebp),%ecx
1119d4: 89 01 mov %eax,(%ecx)
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
1119d6: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp)
1119dd: 74 0b je 1119ea <rtems_task_mode+0x6e>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
1119df: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp)
1119e6: 0f 94 43 74 sete 0x74(%ebx)
if ( mask & RTEMS_TIMESLICE_MASK ) {
1119ea: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
1119f1: 74 1c je 111a0f <rtems_task_mode+0x93>
if ( _Modes_Is_timeslice(mode_set) ) {
1119f3: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp)
1119fa: 0f 84 b8 00 00 00 je 111ab8 <rtems_task_mode+0x13c>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
111a00: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
111a07: a1 c0 64 12 00 mov 0x1264c0,%eax
111a0c: 89 43 78 mov %eax,0x78(%ebx)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
111a0f: f6 45 0c 01 testb $0x1,0xc(%ebp)
111a13: 74 0b je 111a20 <rtems_task_mode+0xa4>
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
111a15: f6 45 08 01 testb $0x1,0x8(%ebp)
111a19: 0f 84 91 00 00 00 je 111ab0 <rtems_task_mode+0x134>
111a1f: fa cli
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
111a20: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
111a27: 74 3f je 111a68 <rtems_task_mode+0xec>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
111a29: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp)
111a30: 0f 94 c0 sete %al
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
111a33: 38 47 08 cmp %al,0x8(%edi)
111a36: 74 30 je 111a68 <rtems_task_mode+0xec>
asr->is_enabled = is_asr_enabled;
111a38: 88 47 08 mov %al,0x8(%edi)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
111a3b: 9c pushf
111a3c: fa cli
111a3d: 58 pop %eax
_signals = information->signals_pending;
111a3e: 8b 57 18 mov 0x18(%edi),%edx
information->signals_pending = information->signals_posted;
111a41: 8b 4f 14 mov 0x14(%edi),%ecx
111a44: 89 4f 18 mov %ecx,0x18(%edi)
information->signals_posted = _signals;
111a47: 89 57 14 mov %edx,0x14(%edi)
_ISR_Enable( _level );
111a4a: 50 push %eax
111a4b: 9d popf
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
111a4c: 8b 47 14 mov 0x14(%edi),%eax
111a4f: 85 c0 test %eax,%eax
111a51: 0f 95 c0 setne %al
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
111a54: 83 3d 80 66 12 00 03 cmpl $0x3,0x126680
111a5b: 74 16 je 111a73 <rtems_task_mode+0xf7> <== ALWAYS TAKEN
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
111a5d: 31 c0 xor %eax,%eax
}
111a5f: 83 c4 1c add $0x1c,%esp
111a62: 5b pop %ebx
111a63: 5e pop %esi
111a64: 5f pop %edi
111a65: c9 leave
111a66: c3 ret
111a67: 90 nop
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
111a68: 31 c0 xor %eax,%eax
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
111a6a: 83 3d 80 66 12 00 03 cmpl $0x3,0x126680
111a71: 75 ea jne 111a5d <rtems_task_mode+0xe1>
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
111a73: 8b 15 78 67 12 00 mov 0x126778,%edx
if ( are_signals_pending ||
111a79: 84 c0 test %al,%al
111a7b: 75 0e jne 111a8b <rtems_task_mode+0x10f>
111a7d: 3b 15 7c 67 12 00 cmp 0x12677c,%edx
111a83: 74 d8 je 111a5d <rtems_task_mode+0xe1>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
111a85: 80 7a 74 00 cmpb $0x0,0x74(%edx)
111a89: 74 d2 je 111a5d <rtems_task_mode+0xe1> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
111a8b: c6 05 84 67 12 00 01 movb $0x1,0x126784
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
111a92: e8 ed b0 ff ff call 10cb84 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
111a97: 31 c0 xor %eax,%eax
}
111a99: 83 c4 1c add $0x1c,%esp
111a9c: 5b pop %ebx
111a9d: 5e pop %esi
111a9e: 5f pop %edi
111a9f: c9 leave
111aa0: c3 ret
111aa1: 8d 76 00 lea 0x0(%esi),%esi
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
111aa4: 81 ce 00 02 00 00 or $0x200,%esi
111aaa: e9 04 ff ff ff jmp 1119b3 <rtems_task_mode+0x37>
111aaf: 90 nop
111ab0: fb sti
111ab1: e9 6a ff ff ff jmp 111a20 <rtems_task_mode+0xa4>
111ab6: 66 90 xchg %ax,%ax
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
111ab8: c7 43 7c 00 00 00 00 movl $0x0,0x7c(%ebx)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
111abf: f6 45 0c 01 testb $0x1,0xc(%ebp)
111ac3: 0f 84 57 ff ff ff je 111a20 <rtems_task_mode+0xa4>
111ac9: e9 47 ff ff ff jmp 111a15 <rtems_task_mode+0x99>
111ace: 66 90 xchg %ax,%ax
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
111ad0: b8 09 00 00 00 mov $0x9,%eax
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
}
111ad5: 83 c4 1c add $0x1c,%esp
111ad8: 5b pop %ebx
111ad9: 5e pop %esi
111ada: 5f pop %edi
111adb: c9 leave
111adc: c3 ret
0010e1c4 <rtems_task_resume>:
*/
rtems_status_code rtems_task_resume(
rtems_id id
)
{
10e1c4: 55 push %ebp
10e1c5: 89 e5 mov %esp,%ebp
10e1c7: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10e1ca: 8d 45 f4 lea -0xc(%ebp),%eax
10e1cd: 50 push %eax
10e1ce: ff 75 08 pushl 0x8(%ebp)
10e1d1: e8 fa 1d 00 00 call 10ffd0 <_Thread_Get>
switch ( location ) {
10e1d6: 83 c4 10 add $0x10,%esp
10e1d9: 8b 55 f4 mov -0xc(%ebp),%edx
10e1dc: 85 d2 test %edx,%edx
10e1de: 74 08 je 10e1e8 <rtems_task_resume+0x24>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10e1e0: b8 04 00 00 00 mov $0x4,%eax
}
10e1e5: c9 leave
10e1e6: c3 ret
10e1e7: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _States_Is_suspended( the_thread->current_state ) ) {
10e1e8: f6 40 10 02 testb $0x2,0x10(%eax)
10e1ec: 75 0e jne 10e1fc <rtems_task_resume+0x38>
_Thread_Resume( the_thread );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
10e1ee: e8 b9 1d 00 00 call 10ffac <_Thread_Enable_dispatch>
return RTEMS_INCORRECT_STATE;
10e1f3: b8 0e 00 00 00 mov $0xe,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10e1f8: c9 leave
10e1f9: c3 ret
10e1fa: 66 90 xchg %ax,%ax
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _States_Is_suspended( the_thread->current_state ) ) {
_Thread_Resume( the_thread );
10e1fc: 83 ec 08 sub $0x8,%esp
10e1ff: 6a 02 push $0x2
10e201: 50 push %eax
10e202: e8 41 1a 00 00 call 10fc48 <_Thread_Clear_state>
_Thread_Enable_dispatch();
10e207: e8 a0 1d 00 00 call 10ffac <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10e20c: 83 c4 10 add $0x10,%esp
10e20f: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10e211: c9 leave
10e212: c3 ret
0010cbe4 <rtems_task_set_note>:
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
10cbe4: 55 push %ebp
10cbe5: 89 e5 mov %esp,%ebp
10cbe7: 56 push %esi
10cbe8: 53 push %ebx
10cbe9: 83 ec 10 sub $0x10,%esp
10cbec: 8b 45 08 mov 0x8(%ebp),%eax
10cbef: 8b 5d 0c mov 0xc(%ebp),%ebx
10cbf2: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
10cbf5: 80 3d 24 52 12 00 00 cmpb $0x0,0x125224
10cbfc: 74 66 je 10cc64 <rtems_task_set_note+0x80>
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
10cbfe: 83 fb 0f cmp $0xf,%ebx
10cc01: 77 39 ja 10cc3c <rtems_task_set_note+0x58>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10cc03: 85 c0 test %eax,%eax
10cc05: 74 41 je 10cc48 <rtems_task_set_note+0x64>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
10cc07: 8b 15 18 9a 12 00 mov 0x129a18,%edx
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10cc0d: 3b 42 08 cmp 0x8(%edx),%eax
10cc10: 74 3c je 10cc4e <rtems_task_set_note+0x6a>
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
10cc12: 83 ec 08 sub $0x8,%esp
10cc15: 8d 55 f4 lea -0xc(%ebp),%edx
10cc18: 52 push %edx
10cc19: 50 push %eax
10cc1a: e8 d9 1f 00 00 call 10ebf8 <_Thread_Get>
switch ( location ) {
10cc1f: 83 c4 10 add $0x10,%esp
10cc22: 8b 55 f4 mov -0xc(%ebp),%edx
10cc25: 85 d2 test %edx,%edx
10cc27: 75 47 jne 10cc70 <rtems_task_set_note+0x8c>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
10cc29: 8b 80 e4 00 00 00 mov 0xe4(%eax),%eax
10cc2f: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4)
_Thread_Enable_dispatch();
10cc33: e8 9c 1f 00 00 call 10ebd4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10cc38: 31 c0 xor %eax,%eax
10cc3a: eb 05 jmp 10cc41 <rtems_task_set_note+0x5d>
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
return RTEMS_INVALID_NUMBER;
10cc3c: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10cc41: 8d 65 f8 lea -0x8(%ebp),%esp
10cc44: 5b pop %ebx
10cc45: 5e pop %esi
10cc46: c9 leave
10cc47: c3 ret
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10cc48: 8b 15 18 9a 12 00 mov 0x129a18,%edx
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
10cc4e: 8b 82 e4 00 00 00 mov 0xe4(%edx),%eax
10cc54: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4)
return RTEMS_SUCCESSFUL;
10cc58: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10cc5a: 8d 65 f8 lea -0x8(%ebp),%esp
10cc5d: 5b pop %ebx
10cc5e: 5e pop %esi
10cc5f: c9 leave
10cc60: c3 ret
10cc61: 8d 76 00 lea 0x0(%esi),%esi
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
10cc64: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10cc69: 8d 65 f8 lea -0x8(%ebp),%esp
10cc6c: 5b pop %ebx
10cc6d: 5e pop %esi
10cc6e: c9 leave
10cc6f: c3 ret
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10cc70: b8 04 00 00 00 mov $0x4,%eax
}
10cc75: 8d 65 f8 lea -0x8(%ebp),%esp
10cc78: 5b pop %ebx
10cc79: 5e pop %esi
10cc7a: c9 leave
10cc7b: c3 ret
0010ee88 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
10ee88: 55 push %ebp
10ee89: 89 e5 mov %esp,%ebp
10ee8b: 56 push %esi
10ee8c: 53 push %ebx
10ee8d: 83 ec 10 sub $0x10,%esp
10ee90: 8b 5d 0c mov 0xc(%ebp),%ebx
10ee93: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10ee96: 85 db test %ebx,%ebx
10ee98: 74 0b je 10eea5 <rtems_task_set_priority+0x1d>
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
10ee9a: 0f b6 05 54 52 12 00 movzbl 0x125254,%eax
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
10eea1: 39 c3 cmp %eax,%ebx
10eea3: 77 5f ja 10ef04 <rtems_task_set_priority+0x7c>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
10eea5: 85 f6 test %esi,%esi
10eea7: 74 67 je 10ef10 <rtems_task_set_priority+0x88>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10eea9: 83 ec 08 sub $0x8,%esp
10eeac: 8d 45 f4 lea -0xc(%ebp),%eax
10eeaf: 50 push %eax
10eeb0: ff 75 08 pushl 0x8(%ebp)
10eeb3: e8 58 1f 00 00 call 110e10 <_Thread_Get>
switch ( location ) {
10eeb8: 83 c4 10 add $0x10,%esp
10eebb: 8b 55 f4 mov -0xc(%ebp),%edx
10eebe: 85 d2 test %edx,%edx
10eec0: 75 36 jne 10eef8 <rtems_task_set_priority+0x70>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
10eec2: 8b 50 14 mov 0x14(%eax),%edx
10eec5: 89 16 mov %edx,(%esi)
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
10eec7: 85 db test %ebx,%ebx
10eec9: 74 1c je 10eee7 <rtems_task_set_priority+0x5f>
the_thread->real_priority = new_priority;
10eecb: 89 58 18 mov %ebx,0x18(%eax)
if ( the_thread->resource_count == 0 ||
10eece: 8b 48 1c mov 0x1c(%eax),%ecx
10eed1: 85 c9 test %ecx,%ecx
10eed3: 74 05 je 10eeda <rtems_task_set_priority+0x52>
10eed5: 3b 58 14 cmp 0x14(%eax),%ebx
10eed8: 73 0d jae 10eee7 <rtems_task_set_priority+0x5f><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
10eeda: 52 push %edx
10eedb: 6a 00 push $0x0
10eedd: 53 push %ebx
10eede: 50 push %eax
10eedf: e8 d0 1a 00 00 call 1109b4 <_Thread_Change_priority>
10eee4: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10eee7: e8 00 1f 00 00 call 110dec <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10eeec: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10eeee: 8d 65 f8 lea -0x8(%ebp),%esp
10eef1: 5b pop %ebx
10eef2: 5e pop %esi
10eef3: c9 leave
10eef4: c3 ret
10eef5: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10eef8: b8 04 00 00 00 mov $0x4,%eax
}
10eefd: 8d 65 f8 lea -0x8(%ebp),%esp
10ef00: 5b pop %ebx
10ef01: 5e pop %esi
10ef02: c9 leave
10ef03: c3 ret
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
10ef04: b8 13 00 00 00 mov $0x13,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ef09: 8d 65 f8 lea -0x8(%ebp),%esp
10ef0c: 5b pop %ebx
10ef0d: 5e pop %esi
10ef0e: c9 leave
10ef0f: c3 ret
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
10ef10: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ef15: 8d 65 f8 lea -0x8(%ebp),%esp
10ef18: 5b pop %ebx
10ef19: 5e pop %esi
10ef1a: c9 leave
10ef1b: c3 ret
0010afec <rtems_task_start>:
rtems_status_code rtems_task_start(
rtems_id id,
rtems_task_entry entry_point,
rtems_task_argument argument
)
{
10afec: 55 push %ebp
10afed: 89 e5 mov %esp,%ebp
10afef: 53 push %ebx
10aff0: 83 ec 14 sub $0x14,%esp
10aff3: 8b 5d 0c mov 0xc(%ebp),%ebx
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
10aff6: 85 db test %ebx,%ebx
10aff8: 74 4e je 10b048 <rtems_task_start+0x5c>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10affa: 83 ec 08 sub $0x8,%esp
10affd: 8d 45 f4 lea -0xc(%ebp),%eax
10b000: 50 push %eax
10b001: ff 75 08 pushl 0x8(%ebp)
10b004: e8 17 1d 00 00 call 10cd20 <_Thread_Get>
switch ( location ) {
10b009: 83 c4 10 add $0x10,%esp
10b00c: 8b 55 f4 mov -0xc(%ebp),%edx
10b00f: 85 d2 test %edx,%edx
10b011: 75 29 jne 10b03c <rtems_task_start+0x50>
case OBJECTS_LOCAL:
if ( _Thread_Start(
10b013: 83 ec 0c sub $0xc,%esp
10b016: ff 75 10 pushl 0x10(%ebp)
10b019: 6a 00 push $0x0
10b01b: 53 push %ebx
10b01c: 6a 00 push $0x0
10b01e: 50 push %eax
10b01f: e8 28 26 00 00 call 10d64c <_Thread_Start>
10b024: 83 c4 20 add $0x20,%esp
10b027: 84 c0 test %al,%al
10b029: 75 29 jne 10b054 <rtems_task_start+0x68>
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
10b02b: e8 cc 1c 00 00 call 10ccfc <_Thread_Enable_dispatch>
return RTEMS_INCORRECT_STATE;
10b030: b8 0e 00 00 00 mov $0xe,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b035: 8b 5d fc mov -0x4(%ebp),%ebx
10b038: c9 leave
10b039: c3 ret
10b03a: 66 90 xchg %ax,%ax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b03c: b8 04 00 00 00 mov $0x4,%eax
}
10b041: 8b 5d fc mov -0x4(%ebp),%ebx
10b044: c9 leave
10b045: c3 ret
10b046: 66 90 xchg %ax,%ax
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
return RTEMS_INVALID_ADDRESS;
10b048: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b04d: 8b 5d fc mov -0x4(%ebp),%ebx
10b050: c9 leave
10b051: c3 ret
10b052: 66 90 xchg %ax,%ax
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Thread_Start(
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
10b054: e8 a3 1c 00 00 call 10ccfc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b059: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b05b: 8b 5d fc mov -0x4(%ebp),%ebx
10b05e: c9 leave
10b05f: c3 ret
0010fd18 <rtems_task_suspend>:
*/
rtems_status_code rtems_task_suspend(
rtems_id id
)
{
10fd18: 55 push %ebp
10fd19: 89 e5 mov %esp,%ebp
10fd1b: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10fd1e: 8d 45 f4 lea -0xc(%ebp),%eax
10fd21: 50 push %eax
10fd22: ff 75 08 pushl 0x8(%ebp)
10fd25: e8 f6 cf ff ff call 10cd20 <_Thread_Get>
switch ( location ) {
10fd2a: 83 c4 10 add $0x10,%esp
10fd2d: 8b 55 f4 mov -0xc(%ebp),%edx
10fd30: 85 d2 test %edx,%edx
10fd32: 74 08 je 10fd3c <rtems_task_suspend+0x24>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10fd34: b8 04 00 00 00 mov $0x4,%eax
}
10fd39: c9 leave
10fd3a: c3 ret
10fd3b: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
10fd3c: f6 40 10 02 testb $0x2,0x10(%eax)
10fd40: 74 0e je 10fd50 <rtems_task_suspend+0x38>
_Thread_Suspend( the_thread );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
10fd42: e8 b5 cf ff ff call 10ccfc <_Thread_Enable_dispatch>
return RTEMS_ALREADY_SUSPENDED;
10fd47: b8 0f 00 00 00 mov $0xf,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10fd4c: c9 leave
10fd4d: c3 ret
10fd4e: 66 90 xchg %ax,%ax
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
_Thread_Suspend( the_thread );
10fd50: 83 ec 08 sub $0x8,%esp
10fd53: 6a 02 push $0x2
10fd55: 50 push %eax
10fd56: e8 95 d7 ff ff call 10d4f0 <_Thread_Set_state>
_Thread_Enable_dispatch();
10fd5b: e8 9c cf ff ff call 10ccfc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10fd60: 83 c4 10 add $0x10,%esp
10fd63: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10fd65: c9 leave
10fd66: c3 ret
0010bb48 <rtems_task_variable_add>:
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
10bb48: 55 push %ebp
10bb49: 89 e5 mov %esp,%ebp
10bb4b: 57 push %edi
10bb4c: 56 push %esi
10bb4d: 53 push %ebx
10bb4e: 83 ec 1c sub $0x1c,%esp
10bb51: 8b 5d 0c mov 0xc(%ebp),%ebx
10bb54: 8b 7d 10 mov 0x10(%ebp),%edi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
10bb57: 85 db test %ebx,%ebx
10bb59: 0f 84 9d 00 00 00 je 10bbfc <rtems_task_variable_add+0xb4>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
10bb5f: 83 ec 08 sub $0x8,%esp
10bb62: 8d 45 e4 lea -0x1c(%ebp),%eax
10bb65: 50 push %eax
10bb66: ff 75 08 pushl 0x8(%ebp)
10bb69: e8 4a 1e 00 00 call 10d9b8 <_Thread_Get>
10bb6e: 89 c6 mov %eax,%esi
switch (location) {
10bb70: 83 c4 10 add $0x10,%esp
10bb73: 8b 45 e4 mov -0x1c(%ebp),%eax
10bb76: 85 c0 test %eax,%eax
10bb78: 74 0e je 10bb88 <rtems_task_variable_add+0x40>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10bb7a: b8 04 00 00 00 mov $0x4,%eax
}
10bb7f: 8d 65 f4 lea -0xc(%ebp),%esp
10bb82: 5b pop %ebx
10bb83: 5e pop %esi
10bb84: 5f pop %edi
10bb85: c9 leave
10bb86: c3 ret
10bb87: 90 nop
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
10bb88: 8b 86 f0 00 00 00 mov 0xf0(%esi),%eax
while (tvp) {
10bb8e: 85 c0 test %eax,%eax
10bb90: 75 44 jne 10bbd6 <rtems_task_variable_add+0x8e>
10bb92: 66 90 xchg %ax,%ax
/*
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
10bb94: 83 ec 0c sub $0xc,%esp
10bb97: 6a 14 push $0x14
10bb99: e8 6a 2d 00 00 call 10e908 <_Workspace_Allocate>
if (new == NULL) {
10bb9e: 83 c4 10 add $0x10,%esp
10bba1: 85 c0 test %eax,%eax
10bba3: 74 4b je 10bbf0 <rtems_task_variable_add+0xa8>
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
10bba5: 8b 13 mov (%ebx),%edx
10bba7: 89 50 08 mov %edx,0x8(%eax)
new->ptr = ptr;
10bbaa: 89 58 04 mov %ebx,0x4(%eax)
new->dtor = dtor;
10bbad: 89 78 10 mov %edi,0x10(%eax)
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
10bbb0: 8b 96 f0 00 00 00 mov 0xf0(%esi),%edx
10bbb6: 89 10 mov %edx,(%eax)
the_thread->task_variables = new;
10bbb8: 89 86 f0 00 00 00 mov %eax,0xf0(%esi)
_Thread_Enable_dispatch();
10bbbe: e8 d1 1d 00 00 call 10d994 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10bbc3: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bbc5: 8d 65 f4 lea -0xc(%ebp),%esp
10bbc8: 5b pop %ebx
10bbc9: 5e pop %esi
10bbca: 5f pop %edi
10bbcb: c9 leave
10bbcc: c3 ret
10bbcd: 8d 76 00 lea 0x0(%esi),%esi
if (tvp->ptr == ptr) {
tvp->dtor = dtor;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
10bbd0: 8b 00 mov (%eax),%eax
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
10bbd2: 85 c0 test %eax,%eax
10bbd4: 74 be je 10bb94 <rtems_task_variable_add+0x4c>
if (tvp->ptr == ptr) {
10bbd6: 39 58 04 cmp %ebx,0x4(%eax)
10bbd9: 75 f5 jne 10bbd0 <rtems_task_variable_add+0x88>
tvp->dtor = dtor;
10bbdb: 89 78 10 mov %edi,0x10(%eax)
_Thread_Enable_dispatch();
10bbde: e8 b1 1d 00 00 call 10d994 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10bbe3: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bbe5: 8d 65 f4 lea -0xc(%ebp),%esp
10bbe8: 5b pop %ebx
10bbe9: 5e pop %esi
10bbea: 5f pop %edi
10bbeb: c9 leave
10bbec: c3 ret
10bbed: 8d 76 00 lea 0x0(%esi),%esi
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
10bbf0: e8 9f 1d 00 00 call 10d994 <_Thread_Enable_dispatch>
return RTEMS_NO_MEMORY;
10bbf5: b8 1a 00 00 00 mov $0x1a,%eax
10bbfa: eb 83 jmp 10bb7f <rtems_task_variable_add+0x37>
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
10bbfc: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bc01: 8d 65 f4 lea -0xc(%ebp),%esp
10bc04: 5b pop %ebx
10bc05: 5e pop %esi
10bc06: 5f pop %edi
10bc07: c9 leave
10bc08: c3 ret
0010bc0c <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
10bc0c: 55 push %ebp
10bc0d: 89 e5 mov %esp,%ebp
10bc0f: 53 push %ebx
10bc10: 83 ec 14 sub $0x14,%esp
10bc13: 8b 5d 0c mov 0xc(%ebp),%ebx
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
10bc16: 85 db test %ebx,%ebx
10bc18: 74 76 je 10bc90 <rtems_task_variable_delete+0x84>
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
10bc1a: 83 ec 08 sub $0x8,%esp
10bc1d: 8d 45 f4 lea -0xc(%ebp),%eax
10bc20: 50 push %eax
10bc21: ff 75 08 pushl 0x8(%ebp)
10bc24: e8 8f 1d 00 00 call 10d9b8 <_Thread_Get>
switch (location) {
10bc29: 83 c4 10 add $0x10,%esp
10bc2c: 8b 55 f4 mov -0xc(%ebp),%edx
10bc2f: 85 d2 test %edx,%edx
10bc31: 74 0d je 10bc40 <rtems_task_variable_delete+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10bc33: b8 04 00 00 00 mov $0x4,%eax
}
10bc38: 8b 5d fc mov -0x4(%ebp),%ebx
10bc3b: c9 leave
10bc3c: c3 ret
10bc3d: 8d 76 00 lea 0x0(%esi),%esi
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
10bc40: 8b 88 f0 00 00 00 mov 0xf0(%eax),%ecx
while (tvp) {
10bc46: 85 c9 test %ecx,%ecx
10bc48: 74 17 je 10bc61 <rtems_task_variable_delete+0x55>
if (tvp->ptr == ptr) {
10bc4a: 39 59 04 cmp %ebx,0x4(%ecx)
10bc4d: 75 0c jne 10bc5b <rtems_task_variable_delete+0x4f>
10bc4f: eb 49 jmp 10bc9a <rtems_task_variable_delete+0x8e>
10bc51: 8d 76 00 lea 0x0(%esi),%esi
10bc54: 39 5a 04 cmp %ebx,0x4(%edx)
10bc57: 74 17 je 10bc70 <rtems_task_variable_delete+0x64>
10bc59: 89 d1 mov %edx,%ecx
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
10bc5b: 8b 11 mov (%ecx),%edx
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
10bc5d: 85 d2 test %edx,%edx
10bc5f: 75 f3 jne 10bc54 <rtems_task_variable_delete+0x48><== ALWAYS TAKEN
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
10bc61: e8 2e 1d 00 00 call 10d994 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
10bc66: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bc6b: 8b 5d fc mov -0x4(%ebp),%ebx
10bc6e: c9 leave
10bc6f: c3 ret
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
10bc70: 8b 1a mov (%edx),%ebx
10bc72: 89 19 mov %ebx,(%ecx)
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
10bc74: 83 ec 08 sub $0x8,%esp
10bc77: 52 push %edx
10bc78: 50 push %eax
10bc79: e8 b2 00 00 00 call 10bd30 <_RTEMS_Tasks_Invoke_task_variable_dtor>
_Thread_Enable_dispatch();
10bc7e: e8 11 1d 00 00 call 10d994 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10bc83: 83 c4 10 add $0x10,%esp
10bc86: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bc88: 8b 5d fc mov -0x4(%ebp),%ebx
10bc8b: c9 leave
10bc8c: c3 ret
10bc8d: 8d 76 00 lea 0x0(%esi),%esi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
10bc90: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bc95: 8b 5d fc mov -0x4(%ebp),%ebx
10bc98: c9 leave
10bc99: c3 ret
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
10bc9a: 8b 11 mov (%ecx),%edx
10bc9c: 89 90 f0 00 00 00 mov %edx,0xf0(%eax)
10bca2: 89 ca mov %ecx,%edx
10bca4: eb ce jmp 10bc74 <rtems_task_variable_delete+0x68>
0010bca8 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
10bca8: 55 push %ebp
10bca9: 89 e5 mov %esp,%ebp
10bcab: 56 push %esi
10bcac: 53 push %ebx
10bcad: 83 ec 10 sub $0x10,%esp
10bcb0: 8b 5d 0c mov 0xc(%ebp),%ebx
10bcb3: 8b 75 10 mov 0x10(%ebp),%esi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
10bcb6: 85 db test %ebx,%ebx
10bcb8: 74 56 je 10bd10 <rtems_task_variable_get+0x68>
return RTEMS_INVALID_ADDRESS;
if ( !result )
10bcba: 85 f6 test %esi,%esi
10bcbc: 74 52 je 10bd10 <rtems_task_variable_get+0x68>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
10bcbe: 83 ec 08 sub $0x8,%esp
10bcc1: 8d 45 f4 lea -0xc(%ebp),%eax
10bcc4: 50 push %eax
10bcc5: ff 75 08 pushl 0x8(%ebp)
10bcc8: e8 eb 1c 00 00 call 10d9b8 <_Thread_Get>
switch (location) {
10bccd: 83 c4 10 add $0x10,%esp
10bcd0: 8b 55 f4 mov -0xc(%ebp),%edx
10bcd3: 85 d2 test %edx,%edx
10bcd5: 75 2d jne 10bd04 <rtems_task_variable_get+0x5c>
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
10bcd7: 8b 80 f0 00 00 00 mov 0xf0(%eax),%eax
while (tvp) {
10bcdd: 85 c0 test %eax,%eax
10bcdf: 75 09 jne 10bcea <rtems_task_variable_get+0x42>
10bce1: eb 39 jmp 10bd1c <rtems_task_variable_get+0x74>
10bce3: 90 nop
*/
*result = tvp->tval;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
10bce4: 8b 00 mov (%eax),%eax
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
10bce6: 85 c0 test %eax,%eax
10bce8: 74 32 je 10bd1c <rtems_task_variable_get+0x74><== NEVER TAKEN
if (tvp->ptr == ptr) {
10bcea: 39 58 04 cmp %ebx,0x4(%eax)
10bced: 75 f5 jne 10bce4 <rtems_task_variable_get+0x3c>
/*
* Should this return the current (i.e not the
* saved) value if `tid' is the current task?
*/
*result = tvp->tval;
10bcef: 8b 40 0c mov 0xc(%eax),%eax
10bcf2: 89 06 mov %eax,(%esi)
_Thread_Enable_dispatch();
10bcf4: e8 9b 1c 00 00 call 10d994 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10bcf9: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bcfb: 8d 65 f8 lea -0x8(%ebp),%esp
10bcfe: 5b pop %ebx
10bcff: 5e pop %esi
10bd00: c9 leave
10bd01: c3 ret
10bd02: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10bd04: b8 04 00 00 00 mov $0x4,%eax
}
10bd09: 8d 65 f8 lea -0x8(%ebp),%esp
10bd0c: 5b pop %ebx
10bd0d: 5e pop %esi
10bd0e: c9 leave
10bd0f: c3 ret
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
if ( !result )
return RTEMS_INVALID_ADDRESS;
10bd10: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bd15: 8d 65 f8 lea -0x8(%ebp),%esp
10bd18: 5b pop %ebx
10bd19: 5e pop %esi
10bd1a: c9 leave
10bd1b: c3 ret
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
10bd1c: e8 73 1c 00 00 call 10d994 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
10bd21: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bd26: 8d 65 f8 lea -0x8(%ebp),%esp
10bd29: 5b pop %ebx
10bd2a: 5e pop %esi
10bd2b: c9 leave
10bd2c: c3 ret
0010bea8 <rtems_task_wake_when>:
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
10bea8: 55 push %ebp
10bea9: 89 e5 mov %esp,%ebp
10beab: 53 push %ebx
10beac: 83 ec 14 sub $0x14,%esp
10beaf: 8b 5d 08 mov 0x8(%ebp),%ebx
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
10beb2: 80 3d fc 84 12 00 00 cmpb $0x0,0x1284fc
10beb9: 0f 84 a9 00 00 00 je 10bf68 <rtems_task_wake_when+0xc0>
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
10bebf: 85 db test %ebx,%ebx
10bec1: 0f 84 ad 00 00 00 je 10bf74 <rtems_task_wake_when+0xcc>
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
10bec7: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
if ( !_TOD_Validate( time_buffer ) )
10bece: 83 ec 0c sub $0xc,%esp
10bed1: 53 push %ebx
10bed2: e8 81 f4 ff ff call 10b358 <_TOD_Validate>
10bed7: 83 c4 10 add $0x10,%esp
10beda: 84 c0 test %al,%al
10bedc: 75 0a jne 10bee8 <rtems_task_wake_when+0x40>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
10bede: b8 14 00 00 00 mov $0x14,%eax
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10bee3: 8b 5d fc mov -0x4(%ebp),%ebx
10bee6: c9 leave
10bee7: c3 ret
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
10bee8: 83 ec 0c sub $0xc,%esp
10beeb: 53 push %ebx
10beec: e8 db f3 ff ff call 10b2cc <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
10bef1: 83 c4 10 add $0x10,%esp
10bef4: 3b 05 88 85 12 00 cmp 0x128588,%eax
10befa: 76 e2 jbe 10bede <rtems_task_wake_when+0x36>
10befc: 8b 15 ec 84 12 00 mov 0x1284ec,%edx
10bf02: 42 inc %edx
10bf03: 89 15 ec 84 12 00 mov %edx,0x1284ec
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
10bf09: 83 ec 08 sub $0x8,%esp
10bf0c: 6a 10 push $0x10
10bf0e: ff 35 78 87 12 00 pushl 0x128778
10bf14: 89 45 f4 mov %eax,-0xc(%ebp)
10bf17: e8 9c 24 00 00 call 10e3b8 <_Thread_Set_state>
_Watchdog_Initialize(
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
10bf1c: 8b 15 78 87 12 00 mov 0x128778,%edx
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
_Watchdog_Initialize(
10bf22: 8b 4a 08 mov 0x8(%edx),%ecx
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10bf25: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx)
the_watchdog->routine = routine;
10bf2c: c7 42 64 10 da 10 00 movl $0x10da10,0x64(%edx)
the_watchdog->id = id;
10bf33: 89 4a 68 mov %ecx,0x68(%edx)
the_watchdog->user_data = user_data;
10bf36: c7 42 6c 00 00 00 00 movl $0x0,0x6c(%edx)
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_seconds(
10bf3d: 8b 45 f4 mov -0xc(%ebp),%eax
10bf40: 2b 05 88 85 12 00 sub 0x128588,%eax
10bf46: 89 42 54 mov %eax,0x54(%edx)
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
10bf49: 58 pop %eax
10bf4a: 59 pop %ecx
10bf4b: 83 c2 48 add $0x48,%edx
10bf4e: 52 push %edx
10bf4f: 68 b4 85 12 00 push $0x1285b4
10bf54: e8 ef 29 00 00 call 10e948 <_Watchdog_Insert>
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
10bf59: e8 66 1c 00 00 call 10dbc4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10bf5e: 83 c4 10 add $0x10,%esp
10bf61: 31 c0 xor %eax,%eax
10bf63: e9 7b ff ff ff jmp 10bee3 <rtems_task_wake_when+0x3b>
)
{
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
10bf68: b8 0b 00 00 00 mov $0xb,%eax
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10bf6d: 8b 5d fc mov -0x4(%ebp),%ebx
10bf70: c9 leave
10bf71: c3 ret
10bf72: 66 90 xchg %ax,%ax
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
10bf74: b8 09 00 00 00 mov $0x9,%eax
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10bf79: 8b 5d fc mov -0x4(%ebp),%ebx
10bf7c: c9 leave
10bf7d: c3 ret
00109e74 <rtems_termios_baud_to_index>:
#include <rtems/termiostypes.h>
int rtems_termios_baud_to_index(
rtems_termios_baud_t termios_baud
)
{
109e74: 55 push %ebp
109e75: 89 e5 mov %esp,%ebp
109e77: 8b 45 08 mov 0x8(%ebp),%eax
int baud_index;
switch (termios_baud) {
109e7a: 83 f8 09 cmp $0x9,%eax
109e7d: 0f 84 f1 00 00 00 je 109f74 <rtems_termios_baud_to_index+0x100>
109e83: 7e 37 jle 109ebc <rtems_termios_baud_to_index+0x48>
109e85: 83 f8 0e cmp $0xe,%eax
109e88: 0f 84 f6 00 00 00 je 109f84 <rtems_termios_baud_to_index+0x110>
109e8e: 7e 5c jle 109eec <rtems_termios_baud_to_index+0x78>
109e90: 3d 02 10 00 00 cmp $0x1002,%eax
109e95: 0f 84 01 01 00 00 je 109f9c <rtems_termios_baud_to_index+0x128>
109e9b: 0f 8e 97 00 00 00 jle 109f38 <rtems_termios_baud_to_index+0xc4>
109ea1: 3d 03 10 00 00 cmp $0x1003,%eax
109ea6: 0f 84 e0 00 00 00 je 109f8c <rtems_termios_baud_to_index+0x118>
109eac: 3d 04 10 00 00 cmp $0x1004,%eax
109eb1: 75 51 jne 109f04 <rtems_termios_baud_to_index+0x90><== NEVER TAKEN
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
case B460800: baud_index = 19; break;
109eb3: b8 13 00 00 00 mov $0x13,%eax
default: baud_index = -1; break;
}
return baud_index;
}
109eb8: c9 leave
109eb9: c3 ret
109eba: 66 90 xchg %ax,%ax
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
109ebc: 83 f8 04 cmp $0x4,%eax
109ebf: 0f 84 b7 00 00 00 je 109f7c <rtems_termios_baud_to_index+0x108>
109ec5: 7f 45 jg 109f0c <rtems_termios_baud_to_index+0x98>
109ec7: 83 f8 01 cmp $0x1,%eax
109eca: 0f 84 8c 00 00 00 je 109f5c <rtems_termios_baud_to_index+0xe8>
109ed0: 0f 8e de 00 00 00 jle 109fb4 <rtems_termios_baud_to_index+0x140>
109ed6: 83 f8 02 cmp $0x2,%eax
109ed9: 0f 84 c5 00 00 00 je 109fa4 <rtems_termios_baud_to_index+0x130>
109edf: 83 f8 03 cmp $0x3,%eax
109ee2: 75 20 jne 109f04 <rtems_termios_baud_to_index+0x90><== NEVER TAKEN
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
case B110: baud_index = 3; break;
109ee4: b8 03 00 00 00 mov $0x3,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
109ee9: c9 leave
109eea: c3 ret
109eeb: 90 nop
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
109eec: 83 f8 0b cmp $0xb,%eax
109eef: 0f 84 9f 00 00 00 je 109f94 <rtems_termios_baud_to_index+0x120>
109ef5: 7c 39 jl 109f30 <rtems_termios_baud_to_index+0xbc>
109ef7: 83 f8 0c cmp $0xc,%eax
109efa: 74 50 je 109f4c <rtems_termios_baud_to_index+0xd8>
109efc: 83 f8 0d cmp $0xd,%eax
109eff: 74 62 je 109f63 <rtems_termios_baud_to_index+0xef><== ALWAYS TAKEN
109f01: 8d 76 00 lea 0x0(%esi),%esi
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
109f04: b8 ff ff ff ff mov $0xffffffff,%eax
}
return baud_index;
}
109f09: c9 leave
109f0a: c3 ret
109f0b: 90 nop
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
109f0c: 83 f8 06 cmp $0x6,%eax
109f0f: 74 43 je 109f54 <rtems_termios_baud_to_index+0xe0>
109f11: 7c 15 jl 109f28 <rtems_termios_baud_to_index+0xb4>
109f13: 83 f8 07 cmp $0x7,%eax
109f16: 0f 84 90 00 00 00 je 109fac <rtems_termios_baud_to_index+0x138>
109f1c: 83 f8 08 cmp $0x8,%eax
109f1f: 75 e3 jne 109f04 <rtems_termios_baud_to_index+0x90><== NEVER TAKEN
case B110: baud_index = 3; break;
case B134: baud_index = 4; break;
case B150: baud_index = 5; break;
case B200: baud_index = 6; break;
case B300: baud_index = 7; break;
case B600: baud_index = 8; break;
109f21: b8 08 00 00 00 mov $0x8,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
109f26: c9 leave
109f27: c3 ret
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
case B110: baud_index = 3; break;
case B134: baud_index = 4; break;
case B150: baud_index = 5; break;
109f28: b8 05 00 00 00 mov $0x5,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
109f2d: c9 leave
109f2e: c3 ret
109f2f: 90 nop
case B150: baud_index = 5; break;
case B200: baud_index = 6; break;
case B300: baud_index = 7; break;
case B600: baud_index = 8; break;
case B1200: baud_index = 9; break;
case B1800: baud_index = 10; break;
109f30: b8 0a 00 00 00 mov $0xa,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
109f35: c9 leave
109f36: c3 ret
109f37: 90 nop
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
109f38: 83 f8 0f cmp $0xf,%eax
109f3b: 74 2f je 109f6c <rtems_termios_baud_to_index+0xf8>
109f3d: 3d 01 10 00 00 cmp $0x1001,%eax
109f42: 75 c0 jne 109f04 <rtems_termios_baud_to_index+0x90><== NEVER TAKEN
case B2400: baud_index = 11; break;
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
109f44: b8 10 00 00 00 mov $0x10,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
109f49: c9 leave
109f4a: c3 ret
109f4b: 90 nop
case B300: baud_index = 7; break;
case B600: baud_index = 8; break;
case B1200: baud_index = 9; break;
case B1800: baud_index = 10; break;
case B2400: baud_index = 11; break;
case B4800: baud_index = 12; break;
109f4c: b8 0c 00 00 00 mov $0xc,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
109f51: c9 leave
109f52: c3 ret
109f53: 90 nop
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
case B110: baud_index = 3; break;
case B134: baud_index = 4; break;
case B150: baud_index = 5; break;
case B200: baud_index = 6; break;
109f54: b8 06 00 00 00 mov $0x6,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
109f59: c9 leave
109f5a: c3 ret
109f5b: 90 nop
{
int baud_index;
switch (termios_baud) {
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
109f5c: b8 01 00 00 00 mov $0x1,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
109f61: c9 leave
109f62: c3 ret
case B600: baud_index = 8; break;
case B1200: baud_index = 9; break;
case B1800: baud_index = 10; break;
case B2400: baud_index = 11; break;
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
109f63: b8 0d 00 00 00 mov $0xd,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
109f68: c9 leave
109f69: c3 ret
109f6a: 66 90 xchg %ax,%ax
case B1800: baud_index = 10; break;
case B2400: baud_index = 11; break;
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
109f6c: b8 0f 00 00 00 mov $0xf,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
109f71: c9 leave
109f72: c3 ret
109f73: 90 nop
case B134: baud_index = 4; break;
case B150: baud_index = 5; break;
case B200: baud_index = 6; break;
case B300: baud_index = 7; break;
case B600: baud_index = 8; break;
case B1200: baud_index = 9; break;
109f74: b8 09 00 00 00 mov $0x9,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
109f79: c9 leave
109f7a: c3 ret
109f7b: 90 nop
switch (termios_baud) {
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
case B110: baud_index = 3; break;
case B134: baud_index = 4; break;
109f7c: b8 04 00 00 00 mov $0x4,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
109f81: c9 leave
109f82: c3 ret
109f83: 90 nop
case B1200: baud_index = 9; break;
case B1800: baud_index = 10; break;
case B2400: baud_index = 11; break;
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
109f84: b8 0e 00 00 00 mov $0xe,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
109f89: c9 leave
109f8a: c3 ret
109f8b: 90 nop
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
109f8c: b8 12 00 00 00 mov $0x12,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
109f91: c9 leave
109f92: c3 ret
109f93: 90 nop
case B200: baud_index = 6; break;
case B300: baud_index = 7; break;
case B600: baud_index = 8; break;
case B1200: baud_index = 9; break;
case B1800: baud_index = 10; break;
case B2400: baud_index = 11; break;
109f94: b8 0b 00 00 00 mov $0xb,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
109f99: c9 leave
109f9a: c3 ret
109f9b: 90 nop
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
109f9c: b8 11 00 00 00 mov $0x11,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
109fa1: c9 leave
109fa2: c3 ret
109fa3: 90 nop
int baud_index;
switch (termios_baud) {
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
109fa4: b8 02 00 00 00 mov $0x2,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
109fa9: c9 leave
109faa: c3 ret
109fab: 90 nop
case B75: baud_index = 2; break;
case B110: baud_index = 3; break;
case B134: baud_index = 4; break;
case B150: baud_index = 5; break;
case B200: baud_index = 6; break;
case B300: baud_index = 7; break;
109fac: b8 07 00 00 00 mov $0x7,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
109fb1: c9 leave
109fb2: c3 ret
109fb3: 90 nop
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
109fb4: 85 c0 test %eax,%eax
109fb6: 0f 85 48 ff ff ff jne 109f04 <rtems_termios_baud_to_index+0x90>
case B0: baud_index = 0; break;
109fbc: 31 c0 xor %eax,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
109fbe: c9 leave
109fbf: c3 ret
001084e0 <rtems_termios_baud_to_number>:
extern rtems_assoc_t termios_assoc_table[];
int32_t rtems_termios_baud_to_number(
int termios_baud
)
{
1084e0: 55 push %ebp
1084e1: 89 e5 mov %esp,%ebp
1084e3: 53 push %ebx
1084e4: 83 ec 0c sub $0xc,%esp
1084e7: 8b 5d 08 mov 0x8(%ebp),%ebx
int baud;
baud = rtems_assoc_local_by_remote( termios_assoc_table, termios_baud );
1084ea: 53 push %ebx
1084eb: 68 a0 40 12 00 push $0x1240a0
1084f0: e8 03 6b 00 00 call 10eff8 <rtems_assoc_local_by_remote>
if ( baud == 0 && termios_baud != 0 )
1084f5: 83 c4 10 add $0x10,%esp
1084f8: 85 c0 test %eax,%eax
1084fa: 74 08 je 108504 <rtems_termios_baud_to_number+0x24>
return -1;
return baud;
}
1084fc: 8b 5d fc mov -0x4(%ebp),%ebx
1084ff: c9 leave
108500: c3 ret
108501: 8d 76 00 lea 0x0(%esi),%esi
)
{
int baud;
baud = rtems_assoc_local_by_remote( termios_assoc_table, termios_baud );
if ( baud == 0 && termios_baud != 0 )
108504: 83 fb 01 cmp $0x1,%ebx
108507: 19 c0 sbb %eax,%eax
108509: f7 d0 not %eax
10850b: eb ef jmp 1084fc <rtems_termios_baud_to_number+0x1c>
00108a64 <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
108a64: 55 push %ebp
108a65: 89 e5 mov %esp,%ebp
108a67: 56 push %esi
108a68: 53 push %ebx
108a69: 8b 75 08 mov 0x8(%ebp),%esi
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
108a6c: 8b 06 mov (%esi),%eax
108a6e: 8b 58 34 mov 0x34(%eax),%ebx
rtems_status_code sc;
sc = rtems_semaphore_obtain(
108a71: 52 push %edx
108a72: 6a 00 push $0x0
108a74: 6a 00 push $0x0
108a76: ff 35 cc 63 12 00 pushl 0x1263cc
108a7c: e8 27 21 00 00 call 10aba8 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
108a81: 83 c4 10 add $0x10,%esp
108a84: 85 c0 test %eax,%eax
108a86: 0f 85 9a 01 00 00 jne 108c26 <rtems_termios_close+0x1c2><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
108a8c: 8b 43 08 mov 0x8(%ebx),%eax
108a8f: 48 dec %eax
108a90: 89 43 08 mov %eax,0x8(%ebx)
108a93: 85 c0 test %eax,%eax
108a95: 0f 85 bf 00 00 00 jne 108b5a <rtems_termios_close+0xf6>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
108a9b: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
108aa1: c1 e0 05 shl $0x5,%eax
108aa4: 8b 80 44 60 12 00 mov 0x126044(%eax),%eax
108aaa: 85 c0 test %eax,%eax
108aac: 0f 84 0a 01 00 00 je 108bbc <rtems_termios_close+0x158>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
108ab2: 83 ec 0c sub $0xc,%esp
108ab5: 53 push %ebx
108ab6: ff d0 call *%eax
108ab8: 83 c4 10 add $0x10,%esp
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
108abb: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
108ac2: 0f 84 2c 01 00 00 je 108bf4 <rtems_termios_close+0x190><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
108ac8: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax
108ace: 85 c0 test %eax,%eax
108ad0: 74 0d je 108adf <rtems_termios_close+0x7b>
(*tty->device.lastClose)(tty->major, tty->minor, arg);
108ad2: 51 push %ecx
108ad3: 56 push %esi
108ad4: ff 73 10 pushl 0x10(%ebx)
108ad7: ff 73 0c pushl 0xc(%ebx)
108ada: ff d0 call *%eax
108adc: 83 c4 10 add $0x10,%esp
if (tty->forw == NULL) {
108adf: 8b 03 mov (%ebx),%eax
108ae1: 85 c0 test %eax,%eax
108ae3: 0f 84 b7 00 00 00 je 108ba0 <rtems_termios_close+0x13c>
rtems_termios_ttyTail = tty->back;
if ( rtems_termios_ttyTail != NULL ) {
rtems_termios_ttyTail->forw = NULL;
}
} else {
tty->forw->back = tty->back;
108ae9: 8b 53 04 mov 0x4(%ebx),%edx
108aec: 89 50 04 mov %edx,0x4(%eax)
108aef: 8b 53 04 mov 0x4(%ebx),%edx
}
if (tty->back == NULL) {
108af2: 85 d2 test %edx,%edx
108af4: 0f 84 8a 00 00 00 je 108b84 <rtems_termios_close+0x120><== ALWAYS TAKEN
rtems_termios_ttyHead = tty->forw;
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
}
} else {
tty->back->forw = tty->forw;
108afa: 89 02 mov %eax,(%edx)
}
rtems_semaphore_delete (tty->isem);
108afc: 83 ec 0c sub $0xc,%esp
108aff: ff 73 14 pushl 0x14(%ebx)
108b02: e8 fd 1f 00 00 call 10ab04 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
108b07: 5a pop %edx
108b08: ff 73 18 pushl 0x18(%ebx)
108b0b: e8 f4 1f 00 00 call 10ab04 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
108b10: 58 pop %eax
108b11: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
108b17: e8 e8 1f 00 00 call 10ab04 <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
108b1c: 83 c4 10 add $0x10,%esp
108b1f: 8b b3 a0 00 00 00 mov 0xa0(%ebx),%esi
108b25: 85 f6 test %esi,%esi
108b27: 74 4b je 108b74 <rtems_termios_close+0x110>
108b29: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
108b30: 74 42 je 108b74 <rtems_termios_close+0x110>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
free (tty->rawInBuf.theBuf);
108b32: 83 ec 0c sub $0xc,%esp
108b35: ff 73 58 pushl 0x58(%ebx)
108b38: e8 f7 ea ff ff call 107634 <free>
free (tty->rawOutBuf.theBuf);
108b3d: 59 pop %ecx
108b3e: ff 73 7c pushl 0x7c(%ebx)
108b41: e8 ee ea ff ff call 107634 <free>
free (tty->cbuf);
108b46: 5a pop %edx
108b47: ff 73 1c pushl 0x1c(%ebx)
108b4a: e8 e5 ea ff ff call 107634 <free>
free (tty);
108b4f: 89 1c 24 mov %ebx,(%esp)
108b52: e8 dd ea ff ff call 107634 <free>
108b57: 83 c4 10 add $0x10,%esp
}
rtems_semaphore_release (rtems_termios_ttyMutex);
108b5a: 83 ec 0c sub $0xc,%esp
108b5d: ff 35 cc 63 12 00 pushl 0x1263cc
108b63: e8 3c 21 00 00 call 10aca4 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
108b68: 31 c0 xor %eax,%eax
108b6a: 8d 65 f8 lea -0x8(%ebp),%esp
108b6d: 5b pop %ebx
108b6e: 5e pop %esi
108b6f: c9 leave
108b70: c3 ret
108b71: 8d 76 00 lea 0x0(%esi),%esi
rtems_semaphore_delete (tty->isem);
rtems_semaphore_delete (tty->osem);
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
108b74: 83 ec 0c sub $0xc,%esp
108b77: ff 73 68 pushl 0x68(%ebx)
108b7a: e8 85 1f 00 00 call 10ab04 <rtems_semaphore_delete>
108b7f: 83 c4 10 add $0x10,%esp
108b82: eb ae jmp 108b32 <rtems_termios_close+0xce>
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
108b84: a3 d4 63 12 00 mov %eax,0x1263d4
if ( rtems_termios_ttyHead != NULL ) {
108b89: 85 c0 test %eax,%eax
108b8b: 0f 84 6b ff ff ff je 108afc <rtems_termios_close+0x98>
rtems_termios_ttyHead->back = NULL;
108b91: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
108b98: e9 5f ff ff ff jmp 108afc <rtems_termios_close+0x98>
108b9d: 8d 76 00 lea 0x0(%esi),%esi
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
rtems_termios_ttyTail = tty->back;
108ba0: 8b 53 04 mov 0x4(%ebx),%edx
108ba3: 89 15 d0 63 12 00 mov %edx,0x1263d0
if ( rtems_termios_ttyTail != NULL ) {
108ba9: 85 d2 test %edx,%edx
108bab: 74 d7 je 108b84 <rtems_termios_close+0x120>
rtems_termios_ttyTail->forw = NULL;
108bad: c7 02 00 00 00 00 movl $0x0,(%edx)
108bb3: 8b 03 mov (%ebx),%eax
108bb5: e9 40 ff ff ff jmp 108afa <rtems_termios_close+0x96>
108bba: 66 90 xchg %ax,%ax
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
108bbc: 50 push %eax
108bbd: 6a 00 push $0x0
108bbf: 6a 00 push $0x0
108bc1: ff 73 18 pushl 0x18(%ebx)
108bc4: e8 df 1f 00 00 call 10aba8 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
108bc9: 83 c4 10 add $0x10,%esp
108bcc: 85 c0 test %eax,%eax
108bce: 75 56 jne 108c26 <rtems_termios_close+0x1c2><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
108bd0: 89 d8 mov %ebx,%eax
108bd2: e8 75 f9 ff ff call 10854c <drainOutput>
rtems_semaphore_release (tty->osem);
108bd7: 83 ec 0c sub $0xc,%esp
108bda: ff 73 18 pushl 0x18(%ebx)
108bdd: e8 c2 20 00 00 call 10aca4 <rtems_semaphore_release>
108be2: 83 c4 10 add $0x10,%esp
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
108be5: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
108bec: 0f 85 d6 fe ff ff jne 108ac8 <rtems_termios_close+0x64>
108bf2: 66 90 xchg %ax,%ax
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
108bf4: 83 ec 08 sub $0x8,%esp
108bf7: 6a 01 push $0x1
108bf9: ff b3 c4 00 00 00 pushl 0xc4(%ebx)
108bff: e8 40 1b 00 00 call 10a744 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
108c04: 83 c4 10 add $0x10,%esp
108c07: 85 c0 test %eax,%eax
108c09: 75 1b jne 108c26 <rtems_termios_close+0x1c2><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
108c0b: 83 ec 08 sub $0x8,%esp
108c0e: 6a 01 push $0x1
108c10: ff b3 c8 00 00 00 pushl 0xc8(%ebx)
108c16: e8 29 1b 00 00 call 10a744 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
108c1b: 83 c4 10 add $0x10,%esp
108c1e: 85 c0 test %eax,%eax
108c20: 0f 84 a2 fe ff ff je 108ac8 <rtems_termios_close+0x64><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
108c26: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108c29: 50 push %eax <== NOT EXECUTED
108c2a: e8 b9 25 00 00 call 10b1e8 <rtems_fatal_error_occurred><== NOT EXECUTED
0010a10c <rtems_termios_dequeue_characters>:
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
10a10c: 55 push %ebp
10a10d: 89 e5 mov %esp,%ebp
10a10f: 83 ec 08 sub $0x8,%esp
10a112: 8b 45 08 mov 0x8(%ebp),%eax
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
10a115: 8b 55 0c mov 0xc(%ebp),%edx
10a118: 01 90 90 00 00 00 add %edx,0x90(%eax)
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
10a11e: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax)
10a125: 74 2d je 10a154 <rtems_termios_dequeue_characters+0x48>
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
10a127: 83 b8 cc 00 00 00 05 cmpl $0x5,0xcc(%eax)
10a12e: 74 0c je 10a13c <rtems_termios_dequeue_characters+0x30>
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
10a130: 89 45 08 mov %eax,0x8(%ebp)
}
10a133: c9 leave
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
10a134: e9 27 fd ff ff jmp 109e60 <rtems_termios_refill_transmitter>
10a139: 8d 76 00 lea 0x0(%esi),%esi
if (tty->t_line == PPPDISC ) {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
10a13c: 8b 15 f4 60 12 00 mov 0x1260f4,%edx
10a142: 85 d2 test %edx,%edx
10a144: 74 09 je 10a14f <rtems_termios_dequeue_characters+0x43><== NEVER TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
10a146: 83 ec 0c sub $0xc,%esp
10a149: 50 push %eax
10a14a: ff d2 call *%edx
10a14c: 83 c4 10 add $0x10,%esp
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
}
10a14f: 31 c0 xor %eax,%eax
10a151: c9 leave
10a152: c3 ret
10a153: 90 nop
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
10a154: 83 ec 08 sub $0x8,%esp
10a157: 6a 02 push $0x2
10a159: ff b0 c8 00 00 00 pushl 0xc8(%eax)
10a15f: e8 e0 05 00 00 call 10a744 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
10a164: 83 c4 10 add $0x10,%esp
10a167: 85 c0 test %eax,%eax
10a169: 74 e4 je 10a14f <rtems_termios_dequeue_characters+0x43><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
10a16b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a16e: 50 push %eax <== NOT EXECUTED
10a16f: e8 74 10 00 00 call 10b1e8 <rtems_fatal_error_occurred><== NOT EXECUTED
00109ae8 <rtems_termios_enqueue_raw_characters>:
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, char *buf, int len)
{
109ae8: 55 push %ebp
109ae9: 89 e5 mov %esp,%ebp
109aeb: 57 push %edi
109aec: 56 push %esi
109aed: 53 push %ebx
109aee: 83 ec 3c sub $0x3c,%esp
109af1: 8b 5d 08 mov 0x8(%ebp),%ebx
109af4: 8b 75 0c mov 0xc(%ebp),%esi
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
109af7: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
109afd: c1 e0 05 shl $0x5,%eax
109b00: 8b 80 50 60 12 00 mov 0x126050(%eax),%eax
109b06: 85 c0 test %eax,%eax
109b08: 0f 84 8a 00 00 00 je 109b98 <rtems_termios_enqueue_raw_characters+0xb0>
while (len--) {
109b0e: 8b 4d 10 mov 0x10(%ebp),%ecx
109b11: 85 c9 test %ecx,%ecx
109b13: 74 2a je 109b3f <rtems_termios_enqueue_raw_characters+0x57><== NEVER TAKEN
109b15: 31 ff xor %edi,%edi
109b17: eb 12 jmp 109b2b <rtems_termios_enqueue_raw_characters+0x43>
109b19: 8d 76 00 lea 0x0(%esi),%esi
109b1c: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
109b22: c1 e0 05 shl $0x5,%eax
109b25: 8b 80 50 60 12 00 mov 0x126050(%eax),%eax
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
109b2b: 83 ec 08 sub $0x8,%esp
109b2e: 53 push %ebx
109b2f: 0f be 14 3e movsbl (%esi,%edi,1),%edx
109b33: 52 push %edx
109b34: ff d0 call *%eax
109b36: 47 inc %edi
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
109b37: 83 c4 10 add $0x10,%esp
109b3a: 3b 7d 10 cmp 0x10(%ebp),%edi
109b3d: 75 dd jne 109b1c <rtems_termios_enqueue_raw_characters+0x34>
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
109b3f: 8b 93 e4 00 00 00 mov 0xe4(%ebx),%edx
109b45: 85 d2 test %edx,%edx
109b47: 75 3b jne 109b84 <rtems_termios_enqueue_raw_characters+0x9c><== NEVER TAKEN
109b49: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax
109b4f: 85 c0 test %eax,%eax
109b51: 74 31 je 109b84 <rtems_termios_enqueue_raw_characters+0x9c><== NEVER TAKEN
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
109b53: 83 ec 08 sub $0x8,%esp
109b56: ff b3 e0 00 00 00 pushl 0xe0(%ebx)
109b5c: 8d 53 30 lea 0x30(%ebx),%edx
109b5f: 52 push %edx
109b60: ff d0 call *%eax
tty->tty_rcvwakeup = 1;
109b62: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx)
109b69: 00 00 00
109b6c: 83 c4 10 add $0x10,%esp
}
return 0;
109b6f: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
}
tty->rawInBufDropped += dropped;
rtems_semaphore_release (tty->rawInBuf.Semaphore);
return dropped;
}
109b76: 8b 45 e0 mov -0x20(%ebp),%eax
109b79: 8d 65 f4 lea -0xc(%ebp),%esp
109b7c: 5b pop %ebx
109b7d: 5e pop %esi
109b7e: 5f pop %edi
109b7f: c9 leave
109b80: c3 ret
109b81: 8d 76 00 lea 0x0(%esi),%esi
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
109b84: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
}
tty->rawInBufDropped += dropped;
rtems_semaphore_release (tty->rawInBuf.Semaphore);
return dropped;
}
109b8b: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
109b8e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
109b91: 5b pop %ebx <== NOT EXECUTED
109b92: 5e pop %esi <== NOT EXECUTED
109b93: 5f pop %edi <== NOT EXECUTED
109b94: c9 leave <== NOT EXECUTED
109b95: c3 ret <== NOT EXECUTED
109b96: 66 90 xchg %ax,%ax <== NOT EXECUTED
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
109b98: 8b 7d 10 mov 0x10(%ebp),%edi
109b9b: c6 45 db 00 movb $0x0,-0x25(%ebp)
109b9f: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
109ba6: 8d 43 30 lea 0x30(%ebx),%eax
109ba9: 89 45 d0 mov %eax,-0x30(%ebp)
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
109bac: 8d 53 4a lea 0x4a(%ebx),%edx
109baf: 89 55 cc mov %edx,-0x34(%ebp)
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
109bb2: 85 ff test %edi,%edi
109bb4: 0f 84 0b 01 00 00 je 109cc5 <rtems_termios_enqueue_raw_characters+0x1dd><== NEVER TAKEN
109bba: 66 90 xchg %ax,%ax
c = *buf++;
109bbc: 8a 06 mov (%esi),%al
109bbe: 88 45 e7 mov %al,-0x19(%ebp)
109bc1: 46 inc %esi
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
109bc2: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109bc8: f6 c4 02 test $0x2,%ah
109bcb: 74 1c je 109be9 <rtems_termios_enqueue_raw_characters+0x101>
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
109bcd: 0f be 45 e7 movsbl -0x19(%ebp),%eax
109bd1: 0f b6 53 4a movzbl 0x4a(%ebx),%edx
109bd5: 39 d0 cmp %edx,%eax
109bd7: 0f 84 07 01 00 00 je 109ce4 <rtems_termios_enqueue_raw_characters+0x1fc>
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
109bdd: 0f b6 53 49 movzbl 0x49(%ebx),%edx
109be1: 39 d0 cmp %edx,%eax
109be3: 0f 84 4f 01 00 00 je 109d38 <rtems_termios_enqueue_raw_characters+0x250><== NEVER TAKEN
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
flow_rcv = true;
}
}
if (flow_rcv) {
109be9: 80 7d db 00 cmpb $0x0,-0x25(%ebp)
109bed: 0f 85 0c 01 00 00 jne 109cff <rtems_termios_enqueue_raw_characters+0x217><== NEVER TAKEN
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
109bf3: 8b 43 60 mov 0x60(%ebx),%eax
109bf6: 8b 53 64 mov 0x64(%ebx),%edx
109bf9: 89 55 dc mov %edx,-0x24(%ebp)
109bfc: 40 inc %eax
109bfd: 31 d2 xor %edx,%edx
109bff: f7 75 dc divl -0x24(%ebp)
109c02: 89 d1 mov %edx,%ecx
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
109c04: 9c pushf
109c05: fa cli
109c06: 8f 45 d4 popl -0x2c(%ebp)
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
109c09: 8b 43 5c mov 0x5c(%ebx),%eax
109c0c: 89 45 c4 mov %eax,-0x3c(%ebp)
109c0f: 8b 43 64 mov 0x64(%ebx),%eax
% tty->rawInBuf.Size) > tty->highwater) &&
109c12: 8b 53 64 mov 0x64(%ebx),%edx
109c15: 89 55 dc mov %edx,-0x24(%ebp)
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
109c18: 2b 45 c4 sub -0x3c(%ebp),%eax
109c1b: 01 c8 add %ecx,%eax
% tty->rawInBuf.Size) > tty->highwater) &&
109c1d: 31 d2 xor %edx,%edx
109c1f: f7 75 dc divl -0x24(%ebp)
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
109c22: 3b 93 c0 00 00 00 cmp 0xc0(%ebx),%edx
109c28: 76 46 jbe 109c70 <rtems_termios_enqueue_raw_characters+0x188><== ALWAYS TAKEN
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
109c2a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
% tty->rawInBuf.Size) > tty->highwater) &&
109c30: a8 01 test $0x1,%al <== NOT EXECUTED
109c32: 75 3c jne 109c70 <rtems_termios_enqueue_raw_characters+0x188><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
109c34: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109c3a: 83 c8 01 or $0x1,%eax <== NOT EXECUTED
109c3d: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
109c43: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109c49: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED
109c4e: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED
109c53: 0f 84 22 01 00 00 je 109d7b <rtems_termios_enqueue_raw_characters+0x293><== NOT EXECUTED
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
109c59: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109c5f: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED
109c64: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED
109c69: 0f 84 50 01 00 00 je 109dbf <rtems_termios_enqueue_raw_characters+0x2d7><== NOT EXECUTED
109c6f: 90 nop <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
109c70: ff 75 d4 pushl -0x2c(%ebp)
109c73: 9d popf
if (newTail == tty->rawInBuf.Head) {
109c74: 8b 43 5c mov 0x5c(%ebx),%eax
109c77: 39 c8 cmp %ecx,%eax
109c79: 0f 84 b1 00 00 00 je 109d30 <rtems_termios_enqueue_raw_characters+0x248><== NEVER TAKEN
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
109c7f: 8b 43 58 mov 0x58(%ebx),%eax
109c82: 8a 55 e7 mov -0x19(%ebp),%dl
109c85: 88 14 08 mov %dl,(%eax,%ecx,1)
tty->rawInBuf.Tail = newTail;
109c88: 89 4b 60 mov %ecx,0x60(%ebx)
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
109c8b: 8b 83 e4 00 00 00 mov 0xe4(%ebx),%eax
109c91: 85 c0 test %eax,%eax
109c93: 75 27 jne 109cbc <rtems_termios_enqueue_raw_characters+0x1d4><== NEVER TAKEN
109c95: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax
109c9b: 85 c0 test %eax,%eax
109c9d: 74 1d je 109cbc <rtems_termios_enqueue_raw_characters+0x1d4><== ALWAYS TAKEN
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
109c9f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
109ca2: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED
109ca8: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED
109cab: ff d0 call *%eax <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
109cad: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED
109cb4: 00 00 00
109cb7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109cba: 66 90 xchg %ax,%ax <== NOT EXECUTED
109cbc: 4f dec %edi
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
109cbd: 85 ff test %edi,%edi
109cbf: 0f 85 f7 fe ff ff jne 109bbc <rtems_termios_enqueue_raw_characters+0xd4><== NEVER TAKEN
}
}
}
}
tty->rawInBufDropped += dropped;
109cc5: 8b 45 e0 mov -0x20(%ebp),%eax
109cc8: 01 43 78 add %eax,0x78(%ebx)
rtems_semaphore_release (tty->rawInBuf.Semaphore);
109ccb: 83 ec 0c sub $0xc,%esp
109cce: ff 73 68 pushl 0x68(%ebx)
109cd1: e8 ce 0f 00 00 call 10aca4 <rtems_semaphore_release>
return dropped;
109cd6: 83 c4 10 add $0x10,%esp
}
109cd9: 8b 45 e0 mov -0x20(%ebp),%eax
109cdc: 8d 65 f4 lea -0xc(%ebp),%esp
109cdf: 5b pop %ebx
109ce0: 5e pop %esi
109ce1: 5f pop %edi
109ce2: c9 leave
109ce3: c3 ret
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
109ce4: 0f b6 53 49 movzbl 0x49(%ebx),%edx
109ce8: 39 d0 cmp %edx,%eax
109cea: 74 7e je 109d6a <rtems_termios_enqueue_raw_characters+0x282><== NEVER TAKEN
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
109cec: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109cf2: 83 c8 10 or $0x10,%eax
109cf5: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
109cfb: c6 45 db 01 movb $0x1,-0x25(%ebp)
flow_rcv = true;
}
}
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
109cff: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109d05: 83 e0 30 and $0x30,%eax
109d08: 83 f8 20 cmp $0x20,%eax
109d0b: 75 af jne 109cbc <rtems_termios_enqueue_raw_characters+0x1d4><== ALWAYS TAKEN
/* disable interrupts */
rtems_interrupt_disable(level);
109d0d: 9c pushf <== NOT EXECUTED
109d0e: fa cli <== NOT EXECUTED
109d0f: 5a pop %edx <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
109d10: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109d16: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
109d19: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
109d1f: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax <== NOT EXECUTED
109d25: 85 c0 test %eax,%eax <== NOT EXECUTED
109d27: 75 20 jne 109d49 <rtems_termios_enqueue_raw_characters+0x261><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
109d29: 52 push %edx <== NOT EXECUTED
109d2a: 9d popf <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
109d2b: 4f dec %edi <== NOT EXECUTED
109d2c: eb 8f jmp 109cbd <rtems_termios_enqueue_raw_characters+0x1d5><== NOT EXECUTED
109d2e: 66 90 xchg %ax,%ax <== NOT EXECUTED
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
dropped++;
109d30: ff 45 e0 incl -0x20(%ebp) <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
109d33: 4f dec %edi <== NOT EXECUTED
109d34: eb 87 jmp 109cbd <rtems_termios_enqueue_raw_characters+0x1d5><== NOT EXECUTED
109d36: 66 90 xchg %ax,%ax <== NOT EXECUTED
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
109d38: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109d3e: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED
109d41: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
109d47: eb b2 jmp 109cfb <rtems_termios_enqueue_raw_characters+0x213><== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
109d49: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
109d4f: 51 push %ecx <== NOT EXECUTED
109d50: 6a 01 push $0x1 <== NOT EXECUTED
109d52: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED
109d55: 50 push %eax <== NOT EXECUTED
109d56: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109d59: 89 55 c8 mov %edx,-0x38(%ebp) <== NOT EXECUTED
109d5c: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
109d62: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109d65: 8b 55 c8 mov -0x38(%ebp),%edx <== NOT EXECUTED
109d68: eb bf jmp 109d29 <rtems_termios_enqueue_raw_characters+0x241><== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
109d6a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109d70: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED
109d73: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
109d79: eb 80 jmp 109cfb <rtems_termios_enqueue_raw_characters+0x213><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
109d7b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109d81: a8 20 test $0x20,%al <== NOT EXECUTED
109d83: 75 0e jne 109d93 <rtems_termios_enqueue_raw_characters+0x2ab><== NOT EXECUTED
109d85: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax <== NOT EXECUTED
109d8b: 85 c0 test %eax,%eax <== NOT EXECUTED
109d8d: 0f 85 dd fe ff ff jne 109c70 <rtems_termios_enqueue_raw_characters+0x188><== NOT EXECUTED
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
109d93: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109d99: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
109d9c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
(*tty->device.write)(tty->minor,
109da2: 52 push %edx <== NOT EXECUTED
109da3: 6a 01 push $0x1 <== NOT EXECUTED
109da5: ff 75 cc pushl -0x34(%ebp) <== NOT EXECUTED
109da8: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109dab: 89 4d c8 mov %ecx,-0x38(%ebp) <== NOT EXECUTED
109dae: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
109db4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109db7: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED
109dba: e9 b1 fe ff ff jmp 109c70 <rtems_termios_enqueue_raw_characters+0x188><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
109dbf: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109dc5: 83 c8 04 or $0x4,%eax <== NOT EXECUTED
109dc8: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
109dce: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax <== NOT EXECUTED
109dd4: 85 c0 test %eax,%eax <== NOT EXECUTED
109dd6: 0f 84 94 fe ff ff je 109c70 <rtems_termios_enqueue_raw_characters+0x188><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
109ddc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109ddf: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109de2: 89 4d c8 mov %ecx,-0x38(%ebp) <== NOT EXECUTED
109de5: ff d0 call *%eax <== NOT EXECUTED
109de7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109dea: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED
109ded: e9 7e fe ff ff jmp 109c70 <rtems_termios_enqueue_raw_characters+0x188><== NOT EXECUTED
00108510 <rtems_termios_initialize>:
struct rtems_termios_tty *rtems_termios_ttyTail;
rtems_id rtems_termios_ttyMutex;
void
rtems_termios_initialize (void)
{
108510: 55 push %ebp
108511: 89 e5 mov %esp,%ebp
108513: 83 ec 08 sub $0x8,%esp
rtems_status_code sc;
/*
* Create the mutex semaphore for the tty list
*/
if (!rtems_termios_ttyMutex) {
108516: a1 cc 63 12 00 mov 0x1263cc,%eax
10851b: 85 c0 test %eax,%eax
10851d: 74 05 je 108524 <rtems_termios_initialize+0x14>
RTEMS_NO_PRIORITY,
&rtems_termios_ttyMutex);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
}
10851f: c9 leave
108520: c3 ret
108521: 8d 76 00 lea 0x0(%esi),%esi
/*
* Create the mutex semaphore for the tty list
*/
if (!rtems_termios_ttyMutex) {
sc = rtems_semaphore_create (
108524: 83 ec 0c sub $0xc,%esp
108527: 68 cc 63 12 00 push $0x1263cc
10852c: 6a 00 push $0x0
10852e: 6a 54 push $0x54
108530: 6a 01 push $0x1
108532: 68 69 6d 52 54 push $0x54526d69
108537: e8 f0 23 00 00 call 10a92c <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'm', 'i'),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_termios_ttyMutex);
if (sc != RTEMS_SUCCESSFUL)
10853c: 83 c4 20 add $0x20,%esp
10853f: 85 c0 test %eax,%eax
108541: 74 dc je 10851f <rtems_termios_initialize+0xf>
rtems_fatal_error_occurred (sc);
108543: 83 ec 0c sub $0xc,%esp
108546: 50 push %eax
108547: e8 9c 2c 00 00 call 10b1e8 <rtems_fatal_error_occurred>
00108c50 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
108c50: 55 push %ebp
108c51: 89 e5 mov %esp,%ebp
108c53: 57 push %edi
108c54: 56 push %esi
108c55: 53 push %ebx
108c56: 83 ec 20 sub $0x20,%esp
108c59: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
108c5c: 8b 03 mov (%ebx),%eax
108c5e: 8b 40 34 mov 0x34(%eax),%eax
108c61: 89 45 e4 mov %eax,-0x1c(%ebp)
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
108c64: 8b 73 08 mov 0x8(%ebx),%esi
rtems_status_code sc;
args->ioctl_return = 0;
108c67: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
108c6e: 6a 00 push $0x0
108c70: 6a 00 push $0x0
108c72: ff 70 18 pushl 0x18(%eax)
108c75: e8 2e 1f 00 00 call 10aba8 <rtems_semaphore_obtain>
108c7a: 89 45 e0 mov %eax,-0x20(%ebp)
if (sc != RTEMS_SUCCESSFUL) {
108c7d: 83 c4 10 add $0x10,%esp
108c80: 85 c0 test %eax,%eax
108c82: 75 24 jne 108ca8 <rtems_termios_ioctl+0x58><== NEVER TAKEN
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
108c84: 8b 43 04 mov 0x4(%ebx),%eax
108c87: 83 f8 04 cmp $0x4,%eax
108c8a: 74 70 je 108cfc <rtems_termios_ioctl+0xac>
108c8c: 77 2a ja 108cb8 <rtems_termios_ioctl+0x68>
108c8e: 83 f8 02 cmp $0x2,%eax
108c91: 0f 84 9d 00 00 00 je 108d34 <rtems_termios_ioctl+0xe4>
108c97: 0f 86 3f 02 00 00 jbe 108edc <rtems_termios_ioctl+0x28c>
if (tty->device.setAttributes)
(*tty->device.setAttributes)(tty->minor, &tty->termios);
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
108c9d: 8b 45 e4 mov -0x1c(%ebp),%eax
108ca0: e8 a7 f8 ff ff call 10854c <drainOutput>
break;
108ca5: eb 69 jmp 108d10 <rtems_termios_ioctl+0xc0>
108ca7: 90 nop
rtems_status_code sc;
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
108ca8: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED
}
rtems_semaphore_release (tty->osem);
args->ioctl_return = sc;
return sc;
}
108cab: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
108cae: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
108cb1: 5b pop %ebx <== NOT EXECUTED
108cb2: 5e pop %esi <== NOT EXECUTED
108cb3: 5f pop %edi <== NOT EXECUTED
108cb4: c9 leave <== NOT EXECUTED
108cb5: c3 ret <== NOT EXECUTED
108cb6: 66 90 xchg %ax,%ax <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
108cb8: 3d 7f 66 04 40 cmp $0x4004667f,%eax
108cbd: 0f 84 f1 01 00 00 je 108eb4 <rtems_termios_ioctl+0x264><== NEVER TAKEN
108cc3: 0f 87 33 02 00 00 ja 108efc <rtems_termios_ioctl+0x2ac>
108cc9: 83 f8 05 cmp $0x5,%eax
108ccc: 0f 84 ae 02 00 00 je 108f80 <rtems_termios_ioctl+0x330>
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
108cd2: 8b 55 e4 mov -0x1c(%ebp),%edx
108cd5: 8b 82 cc 00 00 00 mov 0xcc(%edx),%eax
108cdb: c1 e0 05 shl $0x5,%eax
108cde: 8b 80 58 60 12 00 mov 0x126058(%eax),%eax
108ce4: 85 c0 test %eax,%eax
108ce6: 0f 84 b8 02 00 00 je 108fa4 <rtems_termios_ioctl+0x354><== NEVER TAKEN
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
108cec: 83 ec 08 sub $0x8,%esp
108cef: 53 push %ebx
108cf0: 52 push %edx
108cf1: ff d0 call *%eax
108cf3: 89 45 e0 mov %eax,-0x20(%ebp)
108cf6: 83 c4 10 add $0x10,%esp
108cf9: eb 15 jmp 108d10 <rtems_termios_ioctl+0xc0>
108cfb: 90 nop
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
break;
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
108cfc: 8b 06 mov (%esi),%eax
108cfe: 8b 56 04 mov 0x4(%esi),%edx
108d01: 8b 4d e4 mov -0x1c(%ebp),%ecx
108d04: 89 81 dc 00 00 00 mov %eax,0xdc(%ecx)
108d0a: 89 91 e0 00 00 00 mov %edx,0xe0(%ecx)
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
}
break;
}
rtems_semaphore_release (tty->osem);
108d10: 83 ec 0c sub $0xc,%esp
108d13: 8b 45 e4 mov -0x1c(%ebp),%eax
108d16: ff 70 18 pushl 0x18(%eax)
108d19: e8 86 1f 00 00 call 10aca4 <rtems_semaphore_release>
args->ioctl_return = sc;
108d1e: 8b 55 e0 mov -0x20(%ebp),%edx
108d21: 89 53 0c mov %edx,0xc(%ebx)
return sc;
108d24: 83 c4 10 add $0x10,%esp
}
108d27: 8b 45 e0 mov -0x20(%ebp),%eax
108d2a: 8d 65 f4 lea -0xc(%ebp),%esp
108d2d: 5b pop %ebx
108d2e: 5e pop %esi
108d2f: 5f pop %edi
108d30: c9 leave
108d31: c3 ret
108d32: 66 90 xchg %ax,%ax
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
108d34: 8b 73 08 mov 0x8(%ebx),%esi
108d37: 8b 4d e4 mov -0x1c(%ebp),%ecx
108d3a: 83 c1 30 add $0x30,%ecx
108d3d: 89 4d dc mov %ecx,-0x24(%ebp)
108d40: b9 09 00 00 00 mov $0x9,%ecx
108d45: 8b 7d dc mov -0x24(%ebp),%edi
108d48: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
108d4a: 8b 55 e4 mov -0x1c(%ebp),%edx
108d4d: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax
108d53: f6 c4 02 test $0x2,%ah
108d56: 74 44 je 108d9c <rtems_termios_ioctl+0x14c>
108d58: f6 42 31 04 testb $0x4,0x31(%edx)
108d5c: 75 3e jne 108d9c <rtems_termios_ioctl+0x14c>
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
108d5e: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax
108d64: 25 ef fd ff ff and $0xfffffdef,%eax
108d69: 89 82 b8 00 00 00 mov %eax,0xb8(%edx)
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
108d6f: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax
108d75: a8 20 test $0x20,%al
108d77: 74 23 je 108d9c <rtems_termios_ioctl+0x14c><== ALWAYS TAKEN
/* disable interrupts */
rtems_interrupt_disable(level);
108d79: 9c pushf <== NOT EXECUTED
108d7a: fa cli <== NOT EXECUTED
108d7b: 5e pop %esi <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
108d7c: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax <== NOT EXECUTED
108d82: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
108d85: 89 82 b8 00 00 00 mov %eax,0xb8(%edx) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
108d8b: 8b ba 94 00 00 00 mov 0x94(%edx),%edi <== NOT EXECUTED
108d91: 85 ff test %edi,%edi <== NOT EXECUTED
108d93: 0f 85 bb 02 00 00 jne 109054 <rtems_termios_ioctl+0x404><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
108d99: 56 push %esi <== NOT EXECUTED
108d9a: 9d popf <== NOT EXECUTED
108d9b: 90 nop <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
108d9c: 8b 4d e4 mov -0x1c(%ebp),%ecx
108d9f: 8b 81 b8 00 00 00 mov 0xb8(%ecx),%eax
108da5: f6 c4 04 test $0x4,%ah
108da8: 74 24 je 108dce <rtems_termios_ioctl+0x17e>
108daa: f6 41 31 10 testb $0x10,0x31(%ecx)
108dae: 75 1e jne 108dce <rtems_termios_ioctl+0x17e>
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
108db0: 8b 81 b8 00 00 00 mov 0xb8(%ecx),%eax
108db6: 80 e4 fb and $0xfb,%ah
108db9: 89 81 b8 00 00 00 mov %eax,0xb8(%ecx)
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
108dbf: 8b 81 b8 00 00 00 mov 0xb8(%ecx),%eax
108dc5: 83 e0 fd and $0xfffffffd,%eax
108dc8: 89 81 b8 00 00 00 mov %eax,0xb8(%ecx)
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
108dce: 8b 55 e4 mov -0x1c(%ebp),%edx
108dd1: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax
108dd7: f6 c4 01 test $0x1,%ah
108dda: 0f 84 bc 01 00 00 je 108f9c <rtems_termios_ioctl+0x34c><== ALWAYS TAKEN
108de0: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED
108de3: 8b 41 38 mov 0x38(%ecx),%eax <== NOT EXECUTED
108de6: 85 c0 test %eax,%eax <== NOT EXECUTED
108de8: 0f 88 12 02 00 00 js 109000 <rtems_termios_ioctl+0x3b0><== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
108dee: 8b 91 b8 00 00 00 mov 0xb8(%ecx),%edx <== NOT EXECUTED
108df4: 80 e6 fe and $0xfe,%dh <== NOT EXECUTED
108df7: 89 91 b8 00 00 00 mov %edx,0xb8(%ecx) <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
108dfd: 8b 91 b8 00 00 00 mov 0xb8(%ecx),%edx <== NOT EXECUTED
108e03: 83 e2 04 and $0x4,%edx <== NOT EXECUTED
108e06: 74 1b je 108e23 <rtems_termios_ioctl+0x1d3><== NOT EXECUTED
108e08: 8b 91 b0 00 00 00 mov 0xb0(%ecx),%edx <== NOT EXECUTED
108e0e: 85 d2 test %edx,%edx <== NOT EXECUTED
108e10: 74 11 je 108e23 <rtems_termios_ioctl+0x1d3><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
108e12: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108e15: ff 71 10 pushl 0x10(%ecx) <== NOT EXECUTED
108e18: ff d2 call *%edx <== NOT EXECUTED
108e1a: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
108e1d: 8b 42 38 mov 0x38(%edx),%eax <== NOT EXECUTED
108e20: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
108e23: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED
108e26: 8b 91 b8 00 00 00 mov 0xb8(%ecx),%edx <== NOT EXECUTED
108e2c: 83 e2 fb and $0xfffffffb,%edx <== NOT EXECUTED
108e2f: 89 91 b8 00 00 00 mov %edx,0xb8(%ecx) <== NOT EXECUTED
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
108e35: 85 c0 test %eax,%eax
108e37: 0f 88 c3 01 00 00 js 109000 <rtems_termios_ioctl+0x3b0><== NEVER TAKEN
tty->flow_ctrl |= FL_MDRTS;
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
108e3d: 8b 4d e4 mov -0x1c(%ebp),%ecx
108e40: 8b 41 30 mov 0x30(%ecx),%eax
108e43: f6 c4 10 test $0x10,%ah
108e46: 74 0f je 108e57 <rtems_termios_ioctl+0x207>
tty->flow_ctrl |= FL_MDXOF;
108e48: 8b 91 b8 00 00 00 mov 0xb8(%ecx),%edx
108e4e: 80 ce 04 or $0x4,%dh
108e51: 89 91 b8 00 00 00 mov %edx,0xb8(%ecx)
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
108e57: f6 c4 04 test $0x4,%ah
108e5a: 74 12 je 108e6e <rtems_termios_ioctl+0x21e>
tty->flow_ctrl |= FL_MDXON;
108e5c: 8b 55 e4 mov -0x1c(%ebp),%edx
108e5f: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax
108e65: 80 cc 02 or $0x2,%ah
108e68: 89 82 b8 00 00 00 mov %eax,0xb8(%edx)
tty->termios = *(struct termios *)args->buffer;
/* check for and process change in flow control options */
termios_set_flowctrl(tty);
if (tty->termios.c_lflag & ICANON) {
108e6e: 8b 4d e4 mov -0x1c(%ebp),%ecx
108e71: f6 41 3c 02 testb $0x2,0x3c(%ecx)
108e75: 0f 84 41 01 00 00 je 108fbc <rtems_termios_ioctl+0x36c>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
108e7b: c7 41 6c 00 00 00 00 movl $0x0,0x6c(%ecx)
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
108e82: c7 41 70 00 00 00 00 movl $0x0,0x70(%ecx)
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
108e89: c7 41 74 00 00 00 00 movl $0x0,0x74(%ecx)
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
}
}
}
if (tty->device.setAttributes)
108e90: 8b 55 e4 mov -0x1c(%ebp),%edx
108e93: 8b 82 a8 00 00 00 mov 0xa8(%edx),%eax
108e99: 85 c0 test %eax,%eax
108e9b: 0f 84 6f fe ff ff je 108d10 <rtems_termios_ioctl+0xc0><== NEVER TAKEN
(*tty->device.setAttributes)(tty->minor, &tty->termios);
108ea1: 83 ec 08 sub $0x8,%esp
108ea4: ff 75 dc pushl -0x24(%ebp)
108ea7: ff 72 10 pushl 0x10(%edx)
108eaa: ff d0 call *%eax
108eac: 83 c4 10 add $0x10,%esp
108eaf: e9 5c fe ff ff jmp 108d10 <rtems_termios_ioctl+0xc0>
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
108eb4: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
108eb7: 8b 42 60 mov 0x60(%edx),%eax <== NOT EXECUTED
108eba: 89 d1 mov %edx,%ecx <== NOT EXECUTED
108ebc: 8b 52 5c mov 0x5c(%edx),%edx <== NOT EXECUTED
if ( rawnc < 0 )
108ebf: 29 d0 sub %edx,%eax <== NOT EXECUTED
108ec1: 0f 88 e9 00 00 00 js 108fb0 <rtems_termios_ioctl+0x360><== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
108ec7: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED
108eca: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED
108ecd: 03 41 20 add 0x20(%ecx),%eax <== NOT EXECUTED
108ed0: 2b 41 24 sub 0x24(%ecx),%eax <== NOT EXECUTED
108ed3: 89 02 mov %eax,(%edx) <== NOT EXECUTED
}
break;
108ed5: e9 36 fe ff ff jmp 108d10 <rtems_termios_ioctl+0xc0><== NOT EXECUTED
108eda: 66 90 xchg %ax,%ax <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
108edc: 48 dec %eax
108edd: 0f 85 ef fd ff ff jne 108cd2 <rtems_termios_ioctl+0x82><== NEVER TAKEN
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
108ee3: 8b 43 08 mov 0x8(%ebx),%eax
108ee6: 8b 75 e4 mov -0x1c(%ebp),%esi
108ee9: 83 c6 30 add $0x30,%esi
108eec: b9 09 00 00 00 mov $0x9,%ecx
108ef1: 89 c7 mov %eax,%edi
108ef3: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
break;
108ef5: e9 16 fe ff ff jmp 108d10 <rtems_termios_ioctl+0xc0>
108efa: 66 90 xchg %ax,%ax
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
108efc: 3d 1a 74 04 40 cmp $0x4004741a,%eax
108f01: 74 69 je 108f6c <rtems_termios_ioctl+0x31c>
108f03: 3d 1b 74 04 80 cmp $0x8004741b,%eax
108f08: 0f 85 c4 fd ff ff jne 108cd2 <rtems_termios_ioctl+0x82><== NEVER TAKEN
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
108f0e: 8b 55 e4 mov -0x1c(%ebp),%edx
108f11: 8b 82 cc 00 00 00 mov 0xcc(%edx),%eax
108f17: c1 e0 05 shl $0x5,%eax
108f1a: 8b 80 44 60 12 00 mov 0x126044(%eax),%eax
108f20: 85 c0 test %eax,%eax
108f22: 74 0c je 108f30 <rtems_termios_ioctl+0x2e0>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
108f24: 83 ec 0c sub $0xc,%esp
108f27: 52 push %edx
108f28: ff d0 call *%eax
108f2a: 89 45 e0 mov %eax,-0x20(%ebp)
108f2d: 83 c4 10 add $0x10,%esp
}
tty->t_line=*(int*)(args->buffer);
108f30: 8b 43 08 mov 0x8(%ebx),%eax
108f33: 8b 00 mov (%eax),%eax
108f35: 8b 4d e4 mov -0x1c(%ebp),%ecx
108f38: 89 81 cc 00 00 00 mov %eax,0xcc(%ecx)
tty->t_sc = NULL; /* ensure that no more valid data */
108f3e: c7 81 d0 00 00 00 00 movl $0x0,0xd0(%ecx)
108f45: 00 00 00
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
108f48: c1 e0 05 shl $0x5,%eax
108f4b: 8b 80 40 60 12 00 mov 0x126040(%eax),%eax
108f51: 85 c0 test %eax,%eax
108f53: 0f 84 b7 fd ff ff je 108d10 <rtems_termios_ioctl+0xc0>
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
108f59: 83 ec 0c sub $0xc,%esp
108f5c: 51 push %ecx
108f5d: ff d0 call *%eax
108f5f: 89 45 e0 mov %eax,-0x20(%ebp)
108f62: 83 c4 10 add $0x10,%esp
108f65: e9 a6 fd ff ff jmp 108d10 <rtems_termios_ioctl+0xc0>
108f6a: 66 90 xchg %ax,%ax
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
108f6c: 8b 43 08 mov 0x8(%ebx),%eax
108f6f: 8b 4d e4 mov -0x1c(%ebp),%ecx
108f72: 8b 91 cc 00 00 00 mov 0xcc(%ecx),%edx
108f78: 89 10 mov %edx,(%eax)
break;
108f7a: e9 91 fd ff ff jmp 108d10 <rtems_termios_ioctl+0xc0>
108f7f: 90 nop
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
108f80: 8b 06 mov (%esi),%eax
108f82: 8b 56 04 mov 0x4(%esi),%edx
108f85: 8b 4d e4 mov -0x1c(%ebp),%ecx
108f88: 89 81 d4 00 00 00 mov %eax,0xd4(%ecx)
108f8e: 89 91 d8 00 00 00 mov %edx,0xd8(%ecx)
break;
108f94: e9 77 fd ff ff jmp 108d10 <rtems_termios_ioctl+0xc0>
108f99: 8d 76 00 lea 0x0(%esi),%esi
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
108f9c: 8b 42 38 mov 0x38(%edx),%eax
108f9f: e9 91 fe ff ff jmp 108e35 <rtems_termios_ioctl+0x1e5>
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
}
else {
sc = RTEMS_INVALID_NUMBER;
108fa4: c7 45 e0 0a 00 00 00 movl $0xa,-0x20(%ebp) <== NOT EXECUTED
108fab: e9 60 fd ff ff jmp 108d10 <rtems_termios_ioctl+0xc0><== NOT EXECUTED
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
if ( rawnc < 0 )
rawnc += tty->rawInBuf.Size;
108fb0: 8b 51 64 mov 0x64(%ecx),%edx <== NOT EXECUTED
108fb3: 01 d0 add %edx,%eax <== NOT EXECUTED
108fb5: e9 0d ff ff ff jmp 108ec7 <rtems_termios_ioctl+0x277><== NOT EXECUTED
108fba: 66 90 xchg %ax,%ax <== NOT EXECUTED
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
108fbc: 8b 45 e4 mov -0x1c(%ebp),%eax
108fbf: 0f b6 70 46 movzbl 0x46(%eax),%esi
rtems_clock_get_ticks_per_second() / 10;
108fc3: e8 74 15 00 00 call 10a53c <rtems_clock_get_ticks_per_second>
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
108fc8: 0f af c6 imul %esi,%eax
rtems_clock_get_ticks_per_second() / 10;
108fcb: ba cd cc cc cc mov $0xcccccccd,%edx
108fd0: f7 e2 mul %edx
108fd2: c1 ea 03 shr $0x3,%edx
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
108fd5: 8b 4d e4 mov -0x1c(%ebp),%ecx
108fd8: 89 51 54 mov %edx,0x54(%ecx)
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
108fdb: 80 79 46 00 cmpb $0x0,0x46(%ecx)
108fdf: 74 36 je 109017 <rtems_termios_ioctl+0x3c7>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
108fe1: c7 41 6c 00 00 00 00 movl $0x0,0x6c(%ecx)
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
108fe8: 89 51 70 mov %edx,0x70(%ecx)
if (tty->termios.c_cc[VMIN])
108feb: 80 79 47 00 cmpb $0x0,0x47(%ecx)
108fef: 74 49 je 10903a <rtems_termios_ioctl+0x3ea>
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
108ff1: c7 41 74 00 00 00 00 movl $0x0,0x74(%ecx)
108ff8: e9 93 fe ff ff jmp 108e90 <rtems_termios_ioctl+0x240>
108ffd: 8d 76 00 lea 0x0(%esi),%esi
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
tty->flow_ctrl |= FL_MDRTS;
109000: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
109003: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax <== NOT EXECUTED
109009: 80 cc 01 or $0x1,%ah <== NOT EXECUTED
10900c: 89 82 b8 00 00 00 mov %eax,0xb8(%edx) <== NOT EXECUTED
109012: e9 26 fe ff ff jmp 108e3d <rtems_termios_ioctl+0x1ed><== NOT EXECUTED
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
109017: 8b 55 e4 mov -0x1c(%ebp),%edx
10901a: 80 7a 47 00 cmpb $0x0,0x47(%edx)
10901e: 74 25 je 109045 <rtems_termios_ioctl+0x3f5><== ALWAYS TAKEN
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
109020: c7 42 6c 00 00 00 00 movl $0x0,0x6c(%edx) <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
109027: c7 42 70 00 00 00 00 movl $0x0,0x70(%edx) <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
10902e: c7 42 74 00 00 00 00 movl $0x0,0x74(%edx) <== NOT EXECUTED
109035: e9 56 fe ff ff jmp 108e90 <rtems_termios_ioctl+0x240><== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
10903a: 8b 45 e4 mov -0x1c(%ebp),%eax
10903d: 89 50 74 mov %edx,0x74(%eax)
109040: e9 4b fe ff ff jmp 108e90 <rtems_termios_ioctl+0x240>
if (tty->termios.c_cc[VMIN]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
109045: 8b 4d e4 mov -0x1c(%ebp),%ecx
109048: c7 41 6c 01 00 00 00 movl $0x1,0x6c(%ecx)
10904f: e9 3c fe ff ff jmp 108e90 <rtems_termios_ioctl+0x240>
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
109054: 8b 82 84 00 00 00 mov 0x84(%edx),%eax <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
10905a: 51 push %ecx <== NOT EXECUTED
10905b: 6a 01 push $0x1 <== NOT EXECUTED
10905d: 03 42 7c add 0x7c(%edx),%eax <== NOT EXECUTED
109060: 50 push %eax <== NOT EXECUTED
109061: ff 72 10 pushl 0x10(%edx) <== NOT EXECUTED
109064: ff 92 a4 00 00 00 call *0xa4(%edx) <== NOT EXECUTED
10906a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10906d: e9 27 fd ff ff jmp 108d99 <rtems_termios_ioctl+0x149><== NOT EXECUTED
0010a02c <rtems_termios_number_to_baud>:
extern rtems_assoc_t termios_assoc_table[];
int rtems_termios_number_to_baud(
int32_t baud
)
{
10a02c: 55 push %ebp
10a02d: 89 e5 mov %esp,%ebp
10a02f: 53 push %ebx
10a030: 83 ec 0c sub $0xc,%esp
10a033: 8b 5d 08 mov 0x8(%ebp),%ebx
int termios_baud;
termios_baud = rtems_assoc_remote_by_local( termios_assoc_table, baud );
10a036: 53 push %ebx
10a037: 68 00 74 12 00 push $0x127400
10a03c: e8 47 6d 00 00 call 110d88 <rtems_assoc_remote_by_local>
if ( termios_baud == 0 && baud != 0 )
10a041: 83 c4 10 add $0x10,%esp
10a044: 85 c0 test %eax,%eax
10a046: 74 08 je 10a050 <rtems_termios_number_to_baud+0x24>
return -1;
return termios_baud;
}
10a048: 8b 5d fc mov -0x4(%ebp),%ebx
10a04b: c9 leave
10a04c: c3 ret
10a04d: 8d 76 00 lea 0x0(%esi),%esi
)
{
int termios_baud;
termios_baud = rtems_assoc_remote_by_local( termios_assoc_table, baud );
if ( termios_baud == 0 && baud != 0 )
10a050: 85 db test %ebx,%ebx
10a052: 74 f4 je 10a048 <rtems_termios_number_to_baud+0x1c>
return -1;
10a054: b8 ff ff ff ff mov $0xffffffff,%eax
10a059: eb ed jmp 10a048 <rtems_termios_number_to_baud+0x1c>
001085bc <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
1085bc: 55 push %ebp
1085bd: 89 e5 mov %esp,%ebp
1085bf: 57 push %edi
1085c0: 56 push %esi
1085c1: 53 push %ebx
1085c2: 83 ec 40 sub $0x40,%esp
1085c5: 8b 55 08 mov 0x8(%ebp),%edx
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
1085c8: 6a 00 push $0x0
1085ca: 6a 00 push $0x0
1085cc: ff 35 cc 63 12 00 pushl 0x1263cc
1085d2: 89 55 dc mov %edx,-0x24(%ebp)
1085d5: e8 ce 25 00 00 call 10aba8 <rtems_semaphore_obtain>
1085da: 89 45 e4 mov %eax,-0x1c(%ebp)
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
1085dd: 83 c4 10 add $0x10,%esp
1085e0: 85 c0 test %eax,%eax
1085e2: 8b 55 dc mov -0x24(%ebp),%edx
1085e5: 75 6d jne 108654 <rtems_termios_open+0x98><== NEVER TAKEN
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
1085e7: 8b 35 d4 63 12 00 mov 0x1263d4,%esi
1085ed: 85 f6 test %esi,%esi
1085ef: 0f 84 a7 00 00 00 je 10869c <rtems_termios_open+0xe0>
1085f5: 89 f3 mov %esi,%ebx
1085f7: 8b 45 0c mov 0xc(%ebp),%eax
1085fa: eb 0a jmp 108606 <rtems_termios_open+0x4a>
1085fc: 8b 1b mov (%ebx),%ebx
1085fe: 85 db test %ebx,%ebx
108600: 0f 84 96 00 00 00 je 10869c <rtems_termios_open+0xe0><== ALWAYS TAKEN
if ((tty->major == major) && (tty->minor == minor))
108606: 39 53 0c cmp %edx,0xc(%ebx)
108609: 75 f1 jne 1085fc <rtems_termios_open+0x40>
10860b: 39 43 10 cmp %eax,0x10(%ebx)
10860e: 75 ec jne 1085fc <rtems_termios_open+0x40><== NEVER TAKEN
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
108610: 8b 75 10 mov 0x10(%ebp),%esi
108613: 8b 06 mov (%esi),%eax
108615: 89 58 34 mov %ebx,0x34(%eax)
if (!tty->refcount++) {
108618: 8b 43 08 mov 0x8(%ebx),%eax
10861b: 8d 48 01 lea 0x1(%eax),%ecx
10861e: 89 4b 08 mov %ecx,0x8(%ebx)
108621: 85 c0 test %eax,%eax
108623: 75 1e jne 108643 <rtems_termios_open+0x87>
if (tty->device.firstOpen)
108625: 8b 83 98 00 00 00 mov 0x98(%ebx),%eax
10862b: 85 c0 test %eax,%eax
10862d: 74 0b je 10863a <rtems_termios_open+0x7e>
(*tty->device.firstOpen)(major, minor, arg);
10862f: 57 push %edi
108630: 56 push %esi
108631: ff 75 0c pushl 0xc(%ebp)
108634: 52 push %edx
108635: ff d0 call *%eax
108637: 83 c4 10 add $0x10,%esp
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
10863a: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
108641: 74 1c je 10865f <rtems_termios_open+0xa3>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
108643: 83 ec 0c sub $0xc,%esp
108646: ff 35 cc 63 12 00 pushl 0x1263cc
10864c: e8 53 26 00 00 call 10aca4 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
108651: 83 c4 10 add $0x10,%esp
}
108654: 8b 45 e4 mov -0x1c(%ebp),%eax
108657: 8d 65 f4 lea -0xc(%ebp),%esp
10865a: 5b pop %ebx
10865b: 5e pop %esi
10865c: 5f pop %edi
10865d: c9 leave
10865e: c3 ret
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_start(
10865f: 56 push %esi
108660: 53 push %ebx
108661: 68 f4 9d 10 00 push $0x109df4
108666: ff b3 c4 00 00 00 pushl 0xc4(%ebx)
10866c: e8 7b 29 00 00 call 10afec <rtems_task_start>
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
108671: 83 c4 10 add $0x10,%esp
108674: 85 c0 test %eax,%eax
108676: 0f 85 3f 03 00 00 jne 1089bb <rtems_termios_open+0x3ff><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
10867c: 51 push %ecx
10867d: 53 push %ebx
10867e: 68 a4 a0 10 00 push $0x10a0a4
108683: ff b3 c8 00 00 00 pushl 0xc8(%ebx)
108689: e8 5e 29 00 00 call 10afec <rtems_task_start>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
10868e: 83 c4 10 add $0x10,%esp
108691: 85 c0 test %eax,%eax
108693: 74 ae je 108643 <rtems_termios_open+0x87><== ALWAYS TAKEN
108695: e9 21 03 00 00 jmp 1089bb <rtems_termios_open+0x3ff><== NOT EXECUTED
10869a: 66 90 xchg %ax,%ax <== NOT EXECUTED
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
10869c: 83 ec 08 sub $0x8,%esp
10869f: 68 e8 00 00 00 push $0xe8
1086a4: 6a 01 push $0x1
1086a6: 89 55 dc mov %edx,-0x24(%ebp)
1086a9: e8 f6 ed ff ff call 1074a4 <calloc>
1086ae: 89 45 e0 mov %eax,-0x20(%ebp)
1086b1: 89 c3 mov %eax,%ebx
if (tty == NULL) {
1086b3: 83 c4 10 add $0x10,%esp
1086b6: 85 c0 test %eax,%eax
1086b8: 8b 55 dc mov -0x24(%ebp),%edx
1086bb: 0f 84 75 02 00 00 je 108936 <rtems_termios_open+0x37a>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
1086c1: a1 a4 41 12 00 mov 0x1241a4,%eax
1086c6: 8b 4d e0 mov -0x20(%ebp),%ecx
1086c9: 89 41 64 mov %eax,0x64(%ecx)
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
1086cc: 8b 41 64 mov 0x64(%ecx),%eax
1086cf: 83 ec 0c sub $0xc,%esp
1086d2: 50 push %eax
1086d3: 89 55 dc mov %edx,-0x24(%ebp)
1086d6: e8 2d f2 ff ff call 107908 <malloc>
1086db: 89 45 c4 mov %eax,-0x3c(%ebp)
1086de: 8b 7d e0 mov -0x20(%ebp),%edi
1086e1: 89 47 58 mov %eax,0x58(%edi)
if (tty->rawInBuf.theBuf == NULL) {
1086e4: 83 c4 10 add $0x10,%esp
1086e7: 85 c0 test %eax,%eax
1086e9: 8b 55 dc mov -0x24(%ebp),%edx
1086ec: 0f 84 61 02 00 00 je 108953 <rtems_termios_open+0x397>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
1086f2: a1 a8 41 12 00 mov 0x1241a8,%eax
1086f7: 8b 4d e0 mov -0x20(%ebp),%ecx
1086fa: 89 81 88 00 00 00 mov %eax,0x88(%ecx)
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
108700: 8b 81 88 00 00 00 mov 0x88(%ecx),%eax
108706: 83 ec 0c sub $0xc,%esp
108709: 50 push %eax
10870a: 89 55 dc mov %edx,-0x24(%ebp)
10870d: e8 f6 f1 ff ff call 107908 <malloc>
108712: 89 c7 mov %eax,%edi
108714: 8b 45 e0 mov -0x20(%ebp),%eax
108717: 89 78 7c mov %edi,0x7c(%eax)
if (tty->rawOutBuf.theBuf == NULL) {
10871a: 83 c4 10 add $0x10,%esp
10871d: 85 ff test %edi,%edi
10871f: 8b 55 dc mov -0x24(%ebp),%edx
108722: 0f 84 4f 02 00 00 je 108977 <rtems_termios_open+0x3bb><== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
108728: 83 ec 0c sub $0xc,%esp
10872b: ff 35 a0 41 12 00 pushl 0x1241a0
108731: 89 55 dc mov %edx,-0x24(%ebp)
108734: e8 cf f1 ff ff call 107908 <malloc>
108739: 8b 4d e0 mov -0x20(%ebp),%ecx
10873c: 89 41 1c mov %eax,0x1c(%ecx)
if (tty->cbuf == NULL) {
10873f: 83 c4 10 add $0x10,%esp
108742: 85 c0 test %eax,%eax
108744: 8b 55 dc mov -0x24(%ebp),%edx
108747: 0f 84 77 02 00 00 je 1089c4 <rtems_termios_open+0x408>
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
10874d: 8b 7d e0 mov -0x20(%ebp),%edi
108750: c7 87 d4 00 00 00 00 movl $0x0,0xd4(%edi)
108757: 00 00 00
tty->tty_snd.sw_arg = NULL;
10875a: c7 87 d8 00 00 00 00 movl $0x0,0xd8(%edi)
108761: 00 00 00
tty->tty_rcv.sw_pfn = NULL;
108764: c7 87 dc 00 00 00 00 movl $0x0,0xdc(%edi)
10876b: 00 00 00
tty->tty_rcv.sw_arg = NULL;
10876e: c7 87 e0 00 00 00 00 movl $0x0,0xe0(%edi)
108775: 00 00 00
tty->tty_rcvwakeup = 0;
108778: c7 87 e4 00 00 00 00 movl $0x0,0xe4(%edi)
10877f: 00 00 00
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
108782: 89 37 mov %esi,(%edi)
tty->back = NULL;
108784: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
if (rtems_termios_ttyHead != NULL)
10878b: 85 f6 test %esi,%esi
10878d: 74 03 je 108792 <rtems_termios_open+0x1d6>
rtems_termios_ttyHead->back = tty;
10878f: 89 7e 04 mov %edi,0x4(%esi)
rtems_termios_ttyHead = tty;
108792: 8b 45 e0 mov -0x20(%ebp),%eax
108795: a3 d4 63 12 00 mov %eax,0x1263d4
if (rtems_termios_ttyTail == NULL)
10879a: 8b 0d d0 63 12 00 mov 0x1263d0,%ecx
1087a0: 85 c9 test %ecx,%ecx
1087a2: 0f 84 af 02 00 00 je 108a57 <rtems_termios_open+0x49b>
rtems_termios_ttyTail = tty;
tty->minor = minor;
1087a8: 8b 75 0c mov 0xc(%ebp),%esi
1087ab: 8b 4d e0 mov -0x20(%ebp),%ecx
1087ae: 89 71 10 mov %esi,0x10(%ecx)
tty->major = major;
1087b1: 89 51 0c mov %edx,0xc(%ecx)
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
1087b4: 83 ec 0c sub $0xc,%esp
1087b7: 89 c8 mov %ecx,%eax
1087b9: 83 c0 14 add $0x14,%eax
1087bc: 50 push %eax
1087bd: 6a 00 push $0x0
1087bf: 6a 54 push $0x54
1087c1: 6a 01 push $0x1
rtems_build_name ('T', 'R', 'i', c),
1087c3: 0f be 05 ac 41 12 00 movsbl 0x1241ac,%eax
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
1087ca: 0d 00 69 52 54 or $0x54526900,%eax
1087cf: 50 push %eax
1087d0: 89 55 dc mov %edx,-0x24(%ebp)
1087d3: e8 54 21 00 00 call 10a92c <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'i', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
1087d8: 83 c4 20 add $0x20,%esp
1087db: 85 c0 test %eax,%eax
1087dd: 8b 55 dc mov -0x24(%ebp),%edx
1087e0: 0f 85 d5 01 00 00 jne 1089bb <rtems_termios_open+0x3ff>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
1087e6: 83 ec 0c sub $0xc,%esp
1087e9: 8b 45 e0 mov -0x20(%ebp),%eax
1087ec: 83 c0 18 add $0x18,%eax
1087ef: 50 push %eax
1087f0: 6a 00 push $0x0
1087f2: 6a 54 push $0x54
1087f4: 6a 01 push $0x1
rtems_build_name ('T', 'R', 'o', c),
1087f6: 0f be 05 ac 41 12 00 movsbl 0x1241ac,%eax
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
1087fd: 0d 00 6f 52 54 or $0x54526f00,%eax
108802: 50 push %eax
108803: 89 55 dc mov %edx,-0x24(%ebp)
108806: e8 21 21 00 00 call 10a92c <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'o', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
10880b: 83 c4 20 add $0x20,%esp
10880e: 85 c0 test %eax,%eax
108810: 8b 55 dc mov -0x24(%ebp),%edx
108813: 0f 85 a2 01 00 00 jne 1089bb <rtems_termios_open+0x3ff>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
108819: 83 ec 0c sub $0xc,%esp
10881c: 8b 45 e0 mov -0x20(%ebp),%eax
10881f: 05 8c 00 00 00 add $0x8c,%eax
108824: 50 push %eax
108825: 6a 00 push $0x0
108827: 6a 20 push $0x20
108829: 6a 00 push $0x0
rtems_build_name ('T', 'R', 'x', c),
10882b: 0f be 05 ac 41 12 00 movsbl 0x1241ac,%eax
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
108832: 0d 00 78 52 54 or $0x54527800,%eax
108837: 50 push %eax
108838: 89 55 dc mov %edx,-0x24(%ebp)
10883b: e8 ec 20 00 00 call 10a92c <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'x', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,
RTEMS_NO_PRIORITY,
&tty->rawOutBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
108840: 83 c4 20 add $0x20,%esp
108843: 85 c0 test %eax,%eax
108845: 8b 55 dc mov -0x24(%ebp),%edx
108848: 0f 85 6d 01 00 00 jne 1089bb <rtems_termios_open+0x3ff>
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
10884e: 8b 7d e0 mov -0x20(%ebp),%edi
108851: c7 87 94 00 00 00 00 movl $0x0,0x94(%edi)
108858: 00 00 00
/*
* Set callbacks
*/
tty->device = *callbacks;
10885b: 81 c7 98 00 00 00 add $0x98,%edi
108861: b9 08 00 00 00 mov $0x8,%ecx
108866: 8b 75 14 mov 0x14(%ebp),%esi
108869: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
10886b: 8b 7d e0 mov -0x20(%ebp),%edi
10886e: 83 bf b4 00 00 00 02 cmpl $0x2,0xb4(%edi)
108875: 0f 84 64 01 00 00 je 1089df <rtems_termios_open+0x423>
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
10887b: 8b 45 e0 mov -0x20(%ebp),%eax
10887e: 8b 88 a0 00 00 00 mov 0xa0(%eax),%ecx
108884: 85 c9 test %ecx,%ecx
108886: 0f 84 fc 00 00 00 je 108988 <rtems_termios_open+0x3cc>
10888c: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax)
108893: 0f 84 ef 00 00 00 je 108988 <rtems_termios_open+0x3cc>
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
108899: 8b 4d e0 mov -0x20(%ebp),%ecx
10889c: c7 41 30 02 25 00 00 movl $0x2502,0x30(%ecx)
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
1088a3: c7 41 34 05 18 00 00 movl $0x1805,0x34(%ecx)
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
1088aa: c7 41 38 bd 08 00 00 movl $0x8bd,0x38(%ecx)
tty->termios.c_lflag =
1088b1: c7 41 3c 3b 82 00 00 movl $0x823b,0x3c(%ecx)
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
1088b8: c6 41 41 03 movb $0x3,0x41(%ecx)
tty->termios.c_cc[VQUIT] = '\034';
1088bc: c6 41 42 1c movb $0x1c,0x42(%ecx)
tty->termios.c_cc[VERASE] = '\177';
1088c0: c6 41 43 7f movb $0x7f,0x43(%ecx)
tty->termios.c_cc[VKILL] = '\025';
1088c4: c6 41 44 15 movb $0x15,0x44(%ecx)
tty->termios.c_cc[VEOF] = '\004';
1088c8: c6 41 45 04 movb $0x4,0x45(%ecx)
tty->termios.c_cc[VEOL] = '\000';
1088cc: c6 41 4c 00 movb $0x0,0x4c(%ecx)
tty->termios.c_cc[VEOL2] = '\000';
1088d0: c6 41 51 00 movb $0x0,0x51(%ecx)
tty->termios.c_cc[VSTART] = '\021';
1088d4: c6 41 49 11 movb $0x11,0x49(%ecx)
tty->termios.c_cc[VSTOP] = '\023';
1088d8: c6 41 4a 13 movb $0x13,0x4a(%ecx)
tty->termios.c_cc[VSUSP] = '\032';
1088dc: c6 41 4b 1a movb $0x1a,0x4b(%ecx)
tty->termios.c_cc[VREPRINT] = '\022';
1088e0: c6 41 4d 12 movb $0x12,0x4d(%ecx)
tty->termios.c_cc[VDISCARD] = '\017';
1088e4: c6 41 4e 0f movb $0xf,0x4e(%ecx)
tty->termios.c_cc[VWERASE] = '\027';
1088e8: c6 41 4f 17 movb $0x17,0x4f(%ecx)
tty->termios.c_cc[VLNEXT] = '\026';
1088ec: c6 41 50 16 movb $0x16,0x50(%ecx)
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
1088f0: c7 81 b8 00 00 00 00 movl $0x0,0xb8(%ecx)
1088f7: 00 00 00
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
1088fa: 8b 41 64 mov 0x64(%ecx),%eax
1088fd: d1 e8 shr %eax
1088ff: 89 81 bc 00 00 00 mov %eax,0xbc(%ecx)
tty->highwater = tty->rawInBuf.Size * 3/4;
108905: 8b 41 64 mov 0x64(%ecx),%eax
108908: 8d 04 40 lea (%eax,%eax,2),%eax
10890b: c1 e8 02 shr $0x2,%eax
10890e: 89 81 c0 00 00 00 mov %eax,0xc0(%ecx)
/*
* Bump name characer
*/
if (c++ == 'z')
108914: a0 ac 41 12 00 mov 0x1241ac,%al
108919: 8d 48 01 lea 0x1(%eax),%ecx
10891c: 88 0d ac 41 12 00 mov %cl,0x1241ac
108922: 3c 7a cmp $0x7a,%al
108924: 0f 85 e6 fc ff ff jne 108610 <rtems_termios_open+0x54>
c = 'a';
10892a: c6 05 ac 41 12 00 61 movb $0x61,0x1241ac
108931: e9 da fc ff ff jmp 108610 <rtems_termios_open+0x54>
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
if (tty == NULL) {
rtems_semaphore_release (rtems_termios_ttyMutex);
108936: 83 ec 0c sub $0xc,%esp
108939: ff 35 cc 63 12 00 pushl 0x1263cc
10893f: e8 60 23 00 00 call 10aca4 <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
108944: 83 c4 10 add $0x10,%esp
108947: c7 45 e4 1a 00 00 00 movl $0x1a,-0x1c(%ebp)
10894e: e9 01 fd ff ff jmp 108654 <rtems_termios_open+0x98>
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
if (tty->rawInBuf.theBuf == NULL) {
free(tty);
108953: 83 ec 0c sub $0xc,%esp
108956: 57 push %edi
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
if (tty->rawOutBuf.theBuf == NULL) {
free((void *)(tty->rawInBuf.theBuf));
free(tty);
108957: e8 d8 ec ff ff call 107634 <free>
rtems_semaphore_release (rtems_termios_ttyMutex);
10895c: 5f pop %edi
10895d: ff 35 cc 63 12 00 pushl 0x1263cc
108963: e8 3c 23 00 00 call 10aca4 <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
108968: 83 c4 10 add $0x10,%esp
10896b: c7 45 e4 1a 00 00 00 movl $0x1a,-0x1c(%ebp)
108972: e9 dd fc ff ff jmp 108654 <rtems_termios_open+0x98>
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
if (tty->rawOutBuf.theBuf == NULL) {
free((void *)(tty->rawInBuf.theBuf));
108977: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10897a: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED
10897d: e8 b2 ec ff ff call 107634 <free> <== NOT EXECUTED
free(tty);
108982: 58 pop %eax <== NOT EXECUTED
108983: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED
108986: eb cf jmp 108957 <rtems_termios_open+0x39b><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
108988: 83 ec 0c sub $0xc,%esp
10898b: 8b 45 e0 mov -0x20(%ebp),%eax
10898e: 83 c0 68 add $0x68,%eax
108991: 50 push %eax
108992: 6a 00 push $0x0
108994: 6a 24 push $0x24
108996: 6a 00 push $0x0
rtems_build_name ('T', 'R', 'r', c),
108998: 0f be 05 ac 41 12 00 movsbl 0x1241ac,%eax
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
10899f: 0d 00 72 52 54 or $0x54527200,%eax
1089a4: 50 push %eax
1089a5: 89 55 dc mov %edx,-0x24(%ebp)
1089a8: e8 7f 1f 00 00 call 10a92c <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'r', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->rawInBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
1089ad: 83 c4 20 add $0x20,%esp
1089b0: 85 c0 test %eax,%eax
1089b2: 8b 55 dc mov -0x24(%ebp),%edx
1089b5: 0f 84 de fe ff ff je 108899 <rtems_termios_open+0x2dd>
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
1089bb: 83 ec 0c sub $0xc,%esp
1089be: 50 push %eax
1089bf: e8 24 28 00 00 call 10b1e8 <rtems_fatal_error_occurred>
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
1089c4: 83 ec 0c sub $0xc,%esp
1089c7: 57 push %edi
1089c8: e8 67 ec ff ff call 107634 <free>
free((void *)(tty->rawInBuf.theBuf));
1089cd: 5e pop %esi
1089ce: ff 75 c4 pushl -0x3c(%ebp)
1089d1: e8 5e ec ff ff call 107634 <free>
free(tty);
1089d6: 5b pop %ebx
1089d7: ff 75 e0 pushl -0x20(%ebp)
1089da: e9 78 ff ff ff jmp 108957 <rtems_termios_open+0x39b>
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
1089df: 50 push %eax
1089e0: 50 push %eax
1089e1: 89 f8 mov %edi,%eax
1089e3: 05 c8 00 00 00 add $0xc8,%eax
1089e8: 50 push %eax
1089e9: 6a 00 push $0x0
1089eb: 68 00 05 00 00 push $0x500
1089f0: 68 00 04 00 00 push $0x400
1089f5: 6a 0a push $0xa
rtems_build_name ('T', 'x', 'T', c),
1089f7: 0f be 05 ac 41 12 00 movsbl 0x1241ac,%eax
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
1089fe: 0d 00 54 78 54 or $0x54785400,%eax
108a03: 50 push %eax
108a04: 89 55 dc mov %edx,-0x24(%ebp)
108a07: e8 38 23 00 00 call 10ad44 <rtems_task_create>
TERMIOS_TXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
108a0c: 83 c4 20 add $0x20,%esp
108a0f: 85 c0 test %eax,%eax
108a11: 8b 55 dc mov -0x24(%ebp),%edx
108a14: 75 a5 jne 1089bb <rtems_termios_open+0x3ff><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
108a16: 56 push %esi
108a17: 56 push %esi
108a18: 8b 45 e0 mov -0x20(%ebp),%eax
108a1b: 05 c4 00 00 00 add $0xc4,%eax
108a20: 50 push %eax
108a21: 6a 00 push $0x0
108a23: 68 00 05 00 00 push $0x500
108a28: 68 00 04 00 00 push $0x400
108a2d: 6a 09 push $0x9
rtems_build_name ('R', 'x', 'T', c),
108a2f: 0f be 05 ac 41 12 00 movsbl 0x1241ac,%eax
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
108a36: 0d 00 54 78 52 or $0x52785400,%eax
108a3b: 50 push %eax
108a3c: 89 55 dc mov %edx,-0x24(%ebp)
108a3f: e8 00 23 00 00 call 10ad44 <rtems_task_create>
TERMIOS_RXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
108a44: 83 c4 20 add $0x20,%esp
108a47: 85 c0 test %eax,%eax
108a49: 8b 55 dc mov -0x24(%ebp),%edx
108a4c: 0f 84 29 fe ff ff je 10887b <rtems_termios_open+0x2bf><== ALWAYS TAKEN
108a52: e9 64 ff ff ff jmp 1089bb <rtems_termios_open+0x3ff><== NOT EXECUTED
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
108a57: a3 d0 63 12 00 mov %eax,0x1263d0
108a5c: e9 47 fd ff ff jmp 1087a8 <rtems_termios_open+0x1ec>
00109074 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
109074: 55 push %ebp
109075: 89 e5 mov %esp,%ebp
109077: 57 push %edi
109078: 56 push %esi
109079: 53 push %ebx
10907a: 83 ec 1c sub $0x1c,%esp
10907d: 8b 45 08 mov 0x8(%ebp),%eax
109080: 8b 55 0c mov 0xc(%ebp),%edx
109083: 89 55 e4 mov %edx,-0x1c(%ebp)
109086: 8b 5d 10 mov 0x10(%ebp),%ebx
const unsigned char *buf = _buf;
109089: 89 c6 mov %eax,%esi
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
10908b: 8b 8b b4 00 00 00 mov 0xb4(%ebx),%ecx
109091: 85 c9 test %ecx,%ecx
109093: 0f 84 eb 00 00 00 je 109184 <rtems_termios_puts+0x110>
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
109099: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
10909f: 89 45 e0 mov %eax,-0x20(%ebp)
while (len) {
1090a2: 8b 55 e4 mov -0x1c(%ebp),%edx
1090a5: 85 d2 test %edx,%edx
1090a7: 0f 84 cf 00 00 00 je 10917c <rtems_termios_puts+0x108><== NEVER TAKEN
1090ad: 8d 76 00 lea 0x0(%esi),%esi
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
1090b0: 8b 45 e0 mov -0x20(%ebp),%eax
1090b3: 40 inc %eax
1090b4: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx
1090ba: 31 d2 xor %edx,%edx
1090bc: f7 f1 div %ecx
1090be: 89 55 dc mov %edx,-0x24(%ebp)
1090c1: 89 55 e0 mov %edx,-0x20(%ebp)
rtems_interrupt_disable (level);
1090c4: 9c pushf
1090c5: fa cli
1090c6: 5f pop %edi
while (newHead == tty->rawOutBuf.Tail) {
1090c7: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx
1090cd: 3b 55 e0 cmp -0x20(%ebp),%edx
1090d0: 75 3e jne 109110 <rtems_termios_puts+0x9c>
1090d2: 89 f8 mov %edi,%eax
1090d4: 89 f7 mov %esi,%edi
1090d6: 89 d6 mov %edx,%esi
tty->rawOutBufState = rob_wait;
1090d8: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx)
1090df: 00 00 00
rtems_interrupt_enable (level);
1090e2: 50 push %eax
1090e3: 9d popf
sc = rtems_semaphore_obtain(
1090e4: 50 push %eax
1090e5: 6a 00 push $0x0
1090e7: 6a 00 push $0x0
1090e9: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
1090ef: e8 b4 1a 00 00 call 10aba8 <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
1090f4: 83 c4 10 add $0x10,%esp
1090f7: 85 c0 test %eax,%eax
1090f9: 0f 85 a0 00 00 00 jne 10919f <rtems_termios_puts+0x12b><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
1090ff: 9c pushf
109100: fa cli
109101: 58 pop %eax
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
109102: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx
109108: 39 f2 cmp %esi,%edx
10910a: 74 cc je 1090d8 <rtems_termios_puts+0x64><== NEVER TAKEN
10910c: 89 fe mov %edi,%esi
10910e: 89 c7 mov %eax,%edi
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
109110: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
109116: 8b 4b 7c mov 0x7c(%ebx),%ecx
109119: 8a 16 mov (%esi),%dl
10911b: 88 14 01 mov %dl,(%ecx,%eax,1)
tty->rawOutBuf.Head = newHead;
10911e: 8b 45 dc mov -0x24(%ebp),%eax
109121: 89 83 80 00 00 00 mov %eax,0x80(%ebx)
if (tty->rawOutBufState == rob_idle) {
109127: 8b 8b 94 00 00 00 mov 0x94(%ebx),%ecx
10912d: 85 c9 test %ecx,%ecx
10912f: 75 23 jne 109154 <rtems_termios_puts+0xe0>
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
109131: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109137: a8 10 test $0x10,%al
109139: 74 26 je 109161 <rtems_termios_puts+0xed><== ALWAYS TAKEN
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
10913b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109141: 83 c8 20 or $0x20,%eax <== NOT EXECUTED
109144: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
10914a: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx)
109151: 00 00 00
}
rtems_interrupt_enable (level);
109154: 57 push %edi
109155: 9d popf
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
109156: ff 4d e4 decl -0x1c(%ebp)
109159: 74 21 je 10917c <rtems_termios_puts+0x108>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
10915b: 46 inc %esi
10915c: e9 4f ff ff ff jmp 1090b0 <rtems_termios_puts+0x3c>
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
109161: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(tty->minor,
109167: 52 push %edx
109168: 6a 01 push $0x1
10916a: 03 43 7c add 0x7c(%ebx),%eax
10916d: 50 push %eax
10916e: ff 73 10 pushl 0x10(%ebx)
109171: ff 93 a4 00 00 00 call *0xa4(%ebx)
109177: 83 c4 10 add $0x10,%esp
10917a: eb ce jmp 10914a <rtems_termios_puts+0xd6>
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
10917c: 8d 65 f4 lea -0xc(%ebp),%esp
10917f: 5b pop %ebx
109180: 5e pop %esi
109181: 5f pop %edi
109182: c9 leave
109183: c3 ret
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
109184: 89 55 10 mov %edx,0x10(%ebp)
109187: 89 45 0c mov %eax,0xc(%ebp)
10918a: 8b 43 10 mov 0x10(%ebx),%eax
10918d: 89 45 08 mov %eax,0x8(%ebp)
109190: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
109196: 8d 65 f4 lea -0xc(%ebp),%esp
109199: 5b pop %ebx
10919a: 5e pop %esi
10919b: 5f pop %edi
10919c: c9 leave
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
10919d: ff e0 jmp *%eax
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
10919f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1091a2: 50 push %eax <== NOT EXECUTED
1091a3: e8 40 20 00 00 call 10b1e8 <rtems_fatal_error_occurred><== NOT EXECUTED
00109780 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
109780: 55 push %ebp
109781: 89 e5 mov %esp,%ebp
109783: 57 push %edi
109784: 56 push %esi
109785: 53 push %ebx
109786: 83 ec 30 sub $0x30,%esp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
109789: 8b 55 08 mov 0x8(%ebp),%edx
10978c: 8b 02 mov (%edx),%eax
10978e: 8b 58 34 mov 0x34(%eax),%ebx
uint32_t count = args->count;
109791: 8b 4a 10 mov 0x10(%edx),%ecx
109794: 89 4d dc mov %ecx,-0x24(%ebp)
char *buffer = args->buffer;
109797: 8b 42 0c mov 0xc(%edx),%eax
10979a: 89 45 d8 mov %eax,-0x28(%ebp)
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
10979d: 6a 00 push $0x0
10979f: 6a 00 push $0x0
1097a1: ff 73 14 pushl 0x14(%ebx)
1097a4: e8 ff 13 00 00 call 10aba8 <rtems_semaphore_obtain>
1097a9: 89 45 e0 mov %eax,-0x20(%ebp)
if (sc != RTEMS_SUCCESSFUL)
1097ac: 83 c4 10 add $0x10,%esp
1097af: 85 c0 test %eax,%eax
1097b1: 75 35 jne 1097e8 <rtems_termios_read+0x68><== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
1097b3: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
1097b9: c1 e0 05 shl $0x5,%eax
1097bc: 8b 80 48 60 12 00 mov 0x126048(%eax),%eax
1097c2: 85 c0 test %eax,%eax
1097c4: 74 2e je 1097f4 <rtems_termios_read+0x74>
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
1097c6: 83 ec 08 sub $0x8,%esp
1097c9: ff 75 08 pushl 0x8(%ebp)
1097cc: 53 push %ebx
1097cd: ff d0 call *%eax
1097cf: 89 45 e0 mov %eax,-0x20(%ebp)
tty->tty_rcvwakeup = 0;
1097d2: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
1097d9: 00 00 00
rtems_semaphore_release (tty->isem);
1097dc: 59 pop %ecx
1097dd: ff 73 14 pushl 0x14(%ebx)
1097e0: e8 bf 14 00 00 call 10aca4 <rtems_semaphore_release>
return sc;
1097e5: 83 c4 10 add $0x10,%esp
}
args->bytes_moved = args->count - count;
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
1097e8: 8b 45 e0 mov -0x20(%ebp),%eax
1097eb: 8d 65 f4 lea -0xc(%ebp),%esp
1097ee: 5b pop %ebx
1097ef: 5e pop %esi
1097f0: 5f pop %edi
1097f1: c9 leave
1097f2: c3 ret
1097f3: 90 nop
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
1097f4: 8b 53 20 mov 0x20(%ebx),%edx
1097f7: 39 53 24 cmp %edx,0x24(%ebx)
1097fa: 74 5f je 10985b <rtems_termios_read+0xdb><== ALWAYS TAKEN
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
1097fc: 8b 45 dc mov -0x24(%ebp),%eax
1097ff: 85 c0 test %eax,%eax
109801: 74 29 je 10982c <rtems_termios_read+0xac><== NEVER TAKEN
109803: 8b 43 24 mov 0x24(%ebx),%eax
109806: 3b 43 20 cmp 0x20(%ebx),%eax
109809: 7d 21 jge 10982c <rtems_termios_read+0xac><== NEVER TAKEN
10980b: 8b 55 d8 mov -0x28(%ebp),%edx
10980e: 8b 7d dc mov -0x24(%ebp),%edi
109811: eb 06 jmp 109819 <rtems_termios_read+0x99>
109813: 90 nop
109814: 39 43 20 cmp %eax,0x20(%ebx)
109817: 7e 10 jle 109829 <rtems_termios_read+0xa9>
*buffer++ = tty->cbuf[tty->cindex++];
109819: 8b 73 1c mov 0x1c(%ebx),%esi
10981c: 8a 0c 06 mov (%esi,%eax,1),%cl
10981f: 88 0a mov %cl,(%edx)
109821: 42 inc %edx
109822: 40 inc %eax
109823: 89 43 24 mov %eax,0x24(%ebx)
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
109826: 4f dec %edi
109827: 75 eb jne 109814 <rtems_termios_read+0x94>
109829: 89 7d dc mov %edi,-0x24(%ebp)
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
10982c: 8b 55 08 mov 0x8(%ebp),%edx
10982f: 8b 42 10 mov 0x10(%edx),%eax
109832: 2b 45 dc sub -0x24(%ebp),%eax
109835: 89 42 18 mov %eax,0x18(%edx)
tty->tty_rcvwakeup = 0;
109838: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10983f: 00 00 00
rtems_semaphore_release (tty->isem);
109842: 83 ec 0c sub $0xc,%esp
109845: ff 73 14 pushl 0x14(%ebx)
109848: e8 57 14 00 00 call 10aca4 <rtems_semaphore_release>
return sc;
10984d: 83 c4 10 add $0x10,%esp
}
109850: 8b 45 e0 mov -0x20(%ebp),%eax
109853: 8d 65 f4 lea -0xc(%ebp),%esp
109856: 5b pop %ebx
109857: 5e pop %esi
109858: 5f pop %edi
109859: c9 leave
10985a: c3 ret
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
10985b: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
109862: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
tty->read_start_column = tty->column;
109869: 8b 43 28 mov 0x28(%ebx),%eax
10986c: 89 43 2c mov %eax,0x2c(%ebx)
if (tty->device.pollRead != NULL &&
10986f: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax
109875: 85 c0 test %eax,%eax
109877: 74 0e je 109887 <rtems_termios_read+0x107>
109879: 8b 93 b4 00 00 00 mov 0xb4(%ebx),%edx
10987f: 85 d2 test %edx,%edx
109881: 0f 84 82 01 00 00 je 109a09 <rtems_termios_read+0x289>
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
109887: 8b 73 74 mov 0x74(%ebx),%esi
rtems_status_code sc;
int wait = (int)1;
10988a: c7 45 e4 01 00 00 00 movl $0x1,-0x1c(%ebp)
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
109891: 8d 4b 49 lea 0x49(%ebx),%ecx
109894: 89 4d d4 mov %ecx,-0x2c(%ebp)
109897: 90 nop
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
109898: 8b 53 5c mov 0x5c(%ebx),%edx
10989b: 8b 43 60 mov 0x60(%ebx),%eax
10989e: 39 c2 cmp %eax,%edx
1098a0: 0f 84 06 01 00 00 je 1099ac <rtems_termios_read+0x22c>
(tty->ccount < (CBUFSIZE-1))) {
1098a6: a1 a0 41 12 00 mov 0x1241a0,%eax
1098ab: 48 dec %eax
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
1098ac: 3b 43 20 cmp 0x20(%ebx),%eax
1098af: 7f 3c jg 1098ed <rtems_termios_read+0x16d><== ALWAYS TAKEN
1098b1: e9 f6 00 00 00 jmp 1099ac <rtems_termios_read+0x22c><== NOT EXECUTED
1098b6: 66 90 xchg %ax,%ax <== NOT EXECUTED
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
1098b8: 0f b6 c1 movzbl %cl,%eax
1098bb: 89 da mov %ebx,%edx
1098bd: e8 9e fd ff ff call 109660 <siproc>
1098c2: 85 c0 test %eax,%eax
1098c4: 74 07 je 1098cd <rtems_termios_read+0x14d>
wait = 0;
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
1098c6: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
}
timeout = tty->rawInBufSemaphoreTimeout;
1098cd: 8b 73 70 mov 0x70(%ebx),%esi
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
1098d0: 8b 53 5c mov 0x5c(%ebx),%edx
1098d3: 8b 43 60 mov 0x60(%ebx),%eax
1098d6: 39 c2 cmp %eax,%edx
1098d8: 0f 84 ce 00 00 00 je 1099ac <rtems_termios_read+0x22c>
(tty->ccount < (CBUFSIZE-1))) {
1098de: a1 a0 41 12 00 mov 0x1241a0,%eax
1098e3: 48 dec %eax
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
1098e4: 39 43 20 cmp %eax,0x20(%ebx)
1098e7: 0f 8d bf 00 00 00 jge 1099ac <rtems_termios_read+0x22c><== NEVER TAKEN
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
1098ed: 8b 43 5c mov 0x5c(%ebx),%eax
1098f0: 8b 4b 64 mov 0x64(%ebx),%ecx
1098f3: 40 inc %eax
1098f4: 31 d2 xor %edx,%edx
1098f6: f7 f1 div %ecx
c = tty->rawInBuf.theBuf[newHead];
1098f8: 8b 43 58 mov 0x58(%ebx),%eax
1098fb: 8a 0c 10 mov (%eax,%edx,1),%cl
tty->rawInBuf.Head = newHead;
1098fe: 89 53 5c mov %edx,0x5c(%ebx)
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
109901: 8b 43 60 mov 0x60(%ebx),%eax
109904: 8b 7b 64 mov 0x64(%ebx),%edi
% tty->rawInBuf.Size)
109907: 8b 73 64 mov 0x64(%ebx),%esi
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
c = tty->rawInBuf.theBuf[newHead];
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
10990a: 8d 04 07 lea (%edi,%eax,1),%eax
10990d: 29 d0 sub %edx,%eax
% tty->rawInBuf.Size)
10990f: 31 d2 xor %edx,%edx
109911: f7 f6 div %esi
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
c = tty->rawInBuf.theBuf[newHead];
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
109913: 3b 93 bc 00 00 00 cmp 0xbc(%ebx),%edx
109919: 73 5d jae 109978 <rtems_termios_read+0x1f8><== NEVER TAKEN
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
10991b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109921: 83 e0 fe and $0xfffffffe,%eax
109924: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
10992a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109930: 25 02 02 00 00 and $0x202,%eax
109935: 3d 02 02 00 00 cmp $0x202,%eax
10993a: 0f 84 94 00 00 00 je 1099d4 <rtems_termios_read+0x254><== NEVER TAKEN
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
109940: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109946: f6 c4 01 test $0x1,%ah
109949: 74 2d je 109978 <rtems_termios_read+0x1f8><== ALWAYS TAKEN
tty->flow_ctrl &= ~FL_IRTSOFF;
10994b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109951: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED
109954: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
10995a: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED
109960: 85 c0 test %eax,%eax <== NOT EXECUTED
109962: 74 14 je 109978 <rtems_termios_read+0x1f8><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
109964: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109967: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10996a: 88 4d d0 mov %cl,-0x30(%ebp) <== NOT EXECUTED
10996d: ff d0 call *%eax <== NOT EXECUTED
10996f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109972: 8a 4d d0 mov -0x30(%ebp),%cl <== NOT EXECUTED
109975: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
109978: f6 43 3c 02 testb $0x2,0x3c(%ebx)
10997c: 0f 85 36 ff ff ff jne 1098b8 <rtems_termios_read+0x138><== ALWAYS TAKEN
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
109982: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED
109985: 89 da mov %ebx,%edx <== NOT EXECUTED
109987: e8 d4 fc ff ff call 109660 <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
10998c: 0f b6 43 47 movzbl 0x47(%ebx),%eax <== NOT EXECUTED
109990: 39 43 20 cmp %eax,0x20(%ebx) <== NOT EXECUTED
109993: 0f 8d 2d ff ff ff jge 1098c6 <rtems_termios_read+0x146><== NOT EXECUTED
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
109999: 8b 73 70 mov 0x70(%ebx),%esi <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
10999c: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED
10999f: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED
1099a2: 39 c2 cmp %eax,%edx <== NOT EXECUTED
1099a4: 0f 85 34 ff ff ff jne 1098de <rtems_termios_read+0x15e><== NOT EXECUTED
1099aa: 66 90 xchg %ax,%ax <== NOT EXECUTED
}
/*
* Wait for characters
*/
if ( wait ) {
1099ac: 8b 4d e4 mov -0x1c(%ebp),%ecx
1099af: 85 c9 test %ecx,%ecx
1099b1: 0f 84 45 fe ff ff je 1097fc <rtems_termios_read+0x7c>
sc = rtems_semaphore_obtain(
1099b7: 52 push %edx
1099b8: 56 push %esi
1099b9: ff 73 6c pushl 0x6c(%ebx)
1099bc: ff 73 68 pushl 0x68(%ebx)
1099bf: e8 e4 11 00 00 call 10aba8 <rtems_semaphore_obtain>
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
1099c4: 83 c4 10 add $0x10,%esp
1099c7: 85 c0 test %eax,%eax
1099c9: 0f 84 c9 fe ff ff je 109898 <rtems_termios_read+0x118><== ALWAYS TAKEN
1099cf: e9 28 fe ff ff jmp 1097fc <rtems_termios_read+0x7c><== NOT EXECUTED
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
1099d4: 8b bb 94 00 00 00 mov 0x94(%ebx),%edi <== NOT EXECUTED
1099da: 85 ff test %edi,%edi <== NOT EXECUTED
1099dc: 74 0e je 1099ec <rtems_termios_read+0x26c><== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
1099de: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1099e4: a8 20 test $0x20,%al <== NOT EXECUTED
1099e6: 0f 84 54 ff ff ff je 109940 <rtems_termios_read+0x1c0><== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
1099ec: 56 push %esi <== NOT EXECUTED
1099ed: 6a 01 push $0x1 <== NOT EXECUTED
1099ef: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED
1099f2: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
1099f5: 88 4d d0 mov %cl,-0x30(%ebp) <== NOT EXECUTED
1099f8: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
1099fe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109a01: 8a 4d d0 mov -0x30(%ebp),%cl <== NOT EXECUTED
109a04: e9 6f ff ff ff jmp 109978 <rtems_termios_read+0x1f8><== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
109a09: f6 43 3c 02 testb $0x2,0x3c(%ebx)
109a0d: 75 1d jne 109a2c <rtems_termios_read+0x2ac>
109a0f: eb 39 jmp 109a4a <rtems_termios_read+0x2ca>
109a11: 8d 76 00 lea 0x0(%esi),%esi
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
109a14: 0f b6 c0 movzbl %al,%eax
109a17: 89 da mov %ebx,%edx
109a19: e8 42 fc ff ff call 109660 <siproc>
109a1e: 85 c0 test %eax,%eax
109a20: 0f 85 d6 fd ff ff jne 1097fc <rtems_termios_read+0x7c>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
109a26: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
109a2c: 83 ec 0c sub $0xc,%esp
109a2f: ff 73 10 pushl 0x10(%ebx)
109a32: ff d0 call *%eax
if (n < 0) {
109a34: 83 c4 10 add $0x10,%esp
109a37: 85 c0 test %eax,%eax
109a39: 79 d9 jns 109a14 <rtems_termios_read+0x294>
rtems_task_wake_after (1);
109a3b: 83 ec 0c sub $0xc,%esp
109a3e: 6a 01 push $0x1
109a40: e8 1b 16 00 00 call 10b060 <rtems_task_wake_after>
109a45: 83 c4 10 add $0x10,%esp
109a48: eb dc jmp 109a26 <rtems_termios_read+0x2a6>
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
109a4a: e8 01 0b 00 00 call 10a550 <rtems_clock_get_ticks_since_boot>
109a4f: 89 c6 mov %eax,%esi
109a51: 8d 76 00 lea 0x0(%esi),%esi
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
109a54: 83 ec 0c sub $0xc,%esp
109a57: ff 73 10 pushl 0x10(%ebx)
109a5a: ff 93 a0 00 00 00 call *0xa0(%ebx)
if (n < 0) {
109a60: 83 c4 10 add $0x10,%esp
109a63: 85 c0 test %eax,%eax
109a65: 78 25 js 109a8c <rtems_termios_read+0x30c>
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
109a67: 0f b6 c0 movzbl %al,%eax
109a6a: 89 da mov %ebx,%edx
109a6c: e8 ef fb ff ff call 109660 <siproc>
if (tty->ccount >= tty->termios.c_cc[VMIN])
109a71: 8a 43 47 mov 0x47(%ebx),%al
109a74: 0f b6 d0 movzbl %al,%edx
109a77: 39 53 20 cmp %edx,0x20(%ebx)
109a7a: 0f 8d 7c fd ff ff jge 1097fc <rtems_termios_read+0x7c><== NEVER TAKEN
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
109a80: 84 c0 test %al,%al
109a82: 74 d0 je 109a54 <rtems_termios_read+0x2d4><== NEVER TAKEN
109a84: 80 7b 46 00 cmpb $0x0,0x46(%ebx)
109a88: 74 ca je 109a54 <rtems_termios_read+0x2d4><== NEVER TAKEN
109a8a: eb be jmp 109a4a <rtems_termios_read+0x2ca>
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
if (tty->termios.c_cc[VMIN]) {
109a8c: 80 7b 47 00 cmpb $0x0,0x47(%ebx)
109a90: 74 1d je 109aaf <rtems_termios_read+0x32f><== NEVER TAKEN
if (tty->termios.c_cc[VTIME] && tty->ccount) {
109a92: 80 7b 46 00 cmpb $0x0,0x46(%ebx)
109a96: 74 08 je 109aa0 <rtems_termios_read+0x320><== NEVER TAKEN
109a98: 8b 43 20 mov 0x20(%ebx),%eax
109a9b: 85 c0 test %eax,%eax
109a9d: 75 1a jne 109ab9 <rtems_termios_read+0x339>
109a9f: 90 nop
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
109aa0: 83 ec 0c sub $0xc,%esp
109aa3: 6a 01 push $0x1
109aa5: e8 b6 15 00 00 call 10b060 <rtems_task_wake_after>
109aaa: 83 c4 10 add $0x10,%esp
109aad: eb a5 jmp 109a54 <rtems_termios_read+0x2d4>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
109aaf: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED
109ab3: 0f 84 43 fd ff ff je 1097fc <rtems_termios_read+0x7c><== NOT EXECUTED
break;
now = rtems_clock_get_ticks_since_boot();
109ab9: e8 92 0a 00 00 call 10a550 <rtems_clock_get_ticks_since_boot>
if ((now - then) > tty->vtimeTicks) {
109abe: 29 f0 sub %esi,%eax
109ac0: 3b 43 54 cmp 0x54(%ebx),%eax
109ac3: 76 db jbe 109aa0 <rtems_termios_read+0x320>
109ac5: e9 32 fd ff ff jmp 1097fc <rtems_termios_read+0x7c>
00109e60 <rtems_termios_refill_transmitter>:
* in task-driven mode, this function is called in Tx task context
* in interrupt-driven mode, this function is called in TxIRQ context
*/
int
rtems_termios_refill_transmitter (struct rtems_termios_tty *tty)
{
109e60: 55 push %ebp
109e61: 89 e5 mov %esp,%ebp
109e63: 57 push %edi
109e64: 56 push %esi
109e65: 53 push %ebx
109e66: 83 ec 0c sub $0xc,%esp
109e69: 8b 5d 08 mov 0x8(%ebp),%ebx
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
109e6c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109e72: 25 03 04 00 00 and $0x403,%eax
109e77: 3d 01 04 00 00 cmp $0x401,%eax
109e7c: 0f 84 62 01 00 00 je 109fe4 <rtems_termios_refill_transmitter+0x184><== NEVER TAKEN
tty->flow_ctrl |= FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
109e82: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109e88: 83 e0 03 and $0x3,%eax
109e8b: 83 f8 02 cmp $0x2,%eax
109e8e: 0f 84 8c 01 00 00 je 10a020 <rtems_termios_refill_transmitter+0x1c0><== NEVER TAKEN
tty->flow_ctrl &= ~FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
109e94: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx
109e9a: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
109ea0: 39 c2 cmp %eax,%edx
109ea2: 0f 84 a4 00 00 00 je 109f4c <rtems_termios_refill_transmitter+0xec>
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
}
rtems_interrupt_disable(level);
109ea8: 9c pushf
109ea9: fa cli
109eaa: 58 pop %eax
len = tty->t_dqlen;
109eab: 8b b3 90 00 00 00 mov 0x90(%ebx),%esi
tty->t_dqlen = 0;
109eb1: c7 83 90 00 00 00 00 movl $0x0,0x90(%ebx)
109eb8: 00 00 00
rtems_interrupt_enable(level);
109ebb: 50 push %eax
109ebc: 9d popf
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
109ebd: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
109ec3: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx
109ec9: 8d 04 06 lea (%esi,%eax,1),%eax
109ecc: 31 d2 xor %edx,%edx
109ece: f7 f1 div %ecx
109ed0: 89 d6 mov %edx,%esi
tty->rawOutBuf.Tail = newTail;
109ed2: 89 93 84 00 00 00 mov %edx,0x84(%ebx)
if (tty->rawOutBufState == rob_wait) {
109ed8: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx)
109edf: 0f 84 e7 00 00 00 je 109fcc <rtems_termios_refill_transmitter+0x16c>
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
if (newTail == tty->rawOutBuf.Head) {
109ee5: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
109eeb: 39 f0 cmp %esi,%eax
109eed: 74 79 je 109f68 <rtems_termios_refill_transmitter+0x108>
if ( tty->tty_snd.sw_pfn != NULL) {
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
109eef: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109ef5: 25 10 02 00 00 and $0x210,%eax
109efa: 3d 10 02 00 00 cmp $0x210,%eax
109eff: 0f 84 57 01 00 00 je 10a05c <rtems_termios_refill_transmitter+0x1fc><== NEVER TAKEN
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
109f05: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
109f0b: 39 c6 cmp %eax,%esi
109f0d: 0f 87 91 00 00 00 ja 109fa4 <rtems_termios_refill_transmitter+0x144>
nToSend = tty->rawOutBuf.Size - newTail;
else
nToSend = tty->rawOutBuf.Head - newTail;
109f13: 8b bb 80 00 00 00 mov 0x80(%ebx),%edi
109f19: 29 f7 sub %esi,%edi
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
109f1b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109f21: f6 c4 06 test $0x6,%ah
109f24: 0f 85 91 00 00 00 jne 109fbb <rtems_termios_refill_transmitter+0x15b>
109f2a: 89 f8 mov %edi,%eax
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
109f2c: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx)
109f33: 00 00 00
(*tty->device.write)(
109f36: 52 push %edx
109f37: 50 push %eax
109f38: 8b 43 7c mov 0x7c(%ebx),%eax
109f3b: 01 f0 add %esi,%eax
109f3d: 50 push %eax
109f3e: ff 73 10 pushl 0x10(%ebx)
109f41: ff 93 a4 00 00 00 call *0xa4(%ebx)
109f47: 83 c4 10 add $0x10,%esp
109f4a: eb 48 jmp 109f94 <rtems_termios_refill_transmitter+0x134>
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
109f4c: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx)
109f53: 0f 84 2b 01 00 00 je 10a084 <rtems_termios_refill_transmitter+0x224><== NEVER TAKEN
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
109f59: 31 ff xor %edi,%edi
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
109f5b: 89 f8 mov %edi,%eax
109f5d: 8d 65 f4 lea -0xc(%ebp),%esp
109f60: 5b pop %ebx
109f61: 5e pop %esi
109f62: 5f pop %edi
109f63: c9 leave
109f64: c3 ret
109f65: 8d 76 00 lea 0x0(%esi),%esi
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
109f68: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx)
109f6f: 00 00 00
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
109f72: 8b 83 d4 00 00 00 mov 0xd4(%ebx),%eax
109f78: 85 c0 test %eax,%eax
109f7a: 0f 84 1c 01 00 00 je 10a09c <rtems_termios_refill_transmitter+0x23c><== ALWAYS TAKEN
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
109f80: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
109f83: ff b3 d8 00 00 00 pushl 0xd8(%ebx) <== NOT EXECUTED
109f89: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED
109f8c: 52 push %edx <== NOT EXECUTED
109f8d: ff d0 call *%eax <== NOT EXECUTED
109f8f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
nToSend = 0;
109f92: 31 ff xor %edi,%edi <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
109f94: 89 b3 84 00 00 00 mov %esi,0x84(%ebx)
}
return nToSend;
}
109f9a: 89 f8 mov %edi,%eax
109f9c: 8d 65 f4 lea -0xc(%ebp),%esp
109f9f: 5b pop %ebx
109fa0: 5e pop %esi
109fa1: 5f pop %edi
109fa2: c9 leave
109fa3: c3 ret
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
109fa4: 8b bb 88 00 00 00 mov 0x88(%ebx),%edi
109faa: 29 f7 sub %esi,%edi
else
nToSend = tty->rawOutBuf.Head - newTail;
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
109fac: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109fb2: f6 c4 06 test $0x6,%ah
109fb5: 0f 84 6f ff ff ff je 109f2a <rtems_termios_refill_transmitter+0xca><== ALWAYS TAKEN
109fbb: b8 01 00 00 00 mov $0x1,%eax
nToSend = 1;
109fc0: bf 01 00 00 00 mov $0x1,%edi
109fc5: e9 62 ff ff ff jmp 109f2c <rtems_termios_refill_transmitter+0xcc>
109fca: 66 90 xchg %ax,%ax
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
109fcc: 83 ec 0c sub $0xc,%esp
109fcf: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
109fd5: e8 ca 0c 00 00 call 10aca4 <rtems_semaphore_release>
109fda: 83 c4 10 add $0x10,%esp
109fdd: e9 03 ff ff ff jmp 109ee5 <rtems_termios_refill_transmitter+0x85>
109fe2: 66 90 xchg %ax,%ax
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
109fe4: 56 push %esi <== NOT EXECUTED
109fe5: 6a 01 push $0x1 <== NOT EXECUTED
109fe7: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED
109fea: 50 push %eax <== NOT EXECUTED
109feb: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109fee: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
rtems_interrupt_disable(level);
109ff4: 9c pushf <== NOT EXECUTED
109ff5: fa cli <== NOT EXECUTED
109ff6: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
109ff7: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
109ffd: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10a003: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
10a006: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
rtems_interrupt_enable(level);
10a00c: 52 push %edx <== NOT EXECUTED
10a00d: 9d popf <== NOT EXECUTED
10a00e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
nToSend = 1;
10a011: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
10a016: 89 f8 mov %edi,%eax <== NOT EXECUTED
10a018: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10a01b: 5b pop %ebx <== NOT EXECUTED
10a01c: 5e pop %esi <== NOT EXECUTED
10a01d: 5f pop %edi <== NOT EXECUTED
10a01e: c9 leave <== NOT EXECUTED
10a01f: c3 ret <== NOT EXECUTED
* FIXME: this .write call will generate another
* dequeue callback. This will advance the "Tail" in the data
* buffer, although the corresponding data is not yet out!
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
10a020: 51 push %ecx <== NOT EXECUTED
10a021: 6a 01 push $0x1 <== NOT EXECUTED
10a023: 8d 43 49 lea 0x49(%ebx),%eax <== NOT EXECUTED
10a026: 50 push %eax <== NOT EXECUTED
10a027: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10a02a: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
rtems_interrupt_disable(level);
10a030: 9c pushf <== NOT EXECUTED
10a031: fa cli <== NOT EXECUTED
10a032: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
10a033: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
10a039: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10a03f: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED
10a042: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
rtems_interrupt_enable(level);
10a048: 52 push %edx <== NOT EXECUTED
10a049: 9d popf <== NOT EXECUTED
10a04a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
nToSend = 1;
10a04d: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
10a052: 89 f8 mov %edi,%eax <== NOT EXECUTED
10a054: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10a057: 5b pop %ebx <== NOT EXECUTED
10a058: 5e pop %esi <== NOT EXECUTED
10a059: 5f pop %edi <== NOT EXECUTED
10a05a: c9 leave <== NOT EXECUTED
10a05b: c3 ret <== NOT EXECUTED
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
10a05c: 9c pushf <== NOT EXECUTED
10a05d: fa cli <== NOT EXECUTED
10a05e: 5a pop %edx <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
10a05f: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10a065: 83 c8 20 or $0x20,%eax <== NOT EXECUTED
10a068: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
10a06e: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED
10a075: 00 00 00
rtems_interrupt_enable(level);
10a078: 52 push %edx <== NOT EXECUTED
10a079: 9d popf <== NOT EXECUTED
nToSend = 0;
10a07a: 31 ff xor %edi,%edi <== NOT EXECUTED
10a07c: e9 13 ff ff ff jmp 109f94 <rtems_termios_refill_transmitter+0x134><== NOT EXECUTED
10a081: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
*/
if (tty->rawOutBufState == rob_wait) {
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
10a084: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a087: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED
10a08d: e8 12 0c 00 00 call 10aca4 <rtems_semaphore_release><== NOT EXECUTED
10a092: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
return 0;
10a095: 31 ff xor %edi,%edi <== NOT EXECUTED
10a097: e9 bf fe ff ff jmp 109f5b <rtems_termios_refill_transmitter+0xfb><== NOT EXECUTED
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
nToSend = 0;
10a09c: 31 ff xor %edi,%edi
10a09e: e9 f1 fe ff ff jmp 109f94 <rtems_termios_refill_transmitter+0x134>
00109df4 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
109df4: 55 push %ebp
109df5: 89 e5 mov %esp,%ebp
109df7: 57 push %edi
109df8: 56 push %esi
109df9: 53 push %ebx
109dfa: 83 ec 1c sub $0x1c,%esp
109dfd: 8b 5d 08 mov 0x8(%ebp),%ebx
109e00: 8d 75 e0 lea -0x20(%ebp),%esi
109e03: 8d 7d e7 lea -0x19(%ebp),%edi
109e06: eb 14 jmp 109e1c <rtems_termios_rxdaemon+0x28>
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
109e08: 83 ec 0c sub $0xc,%esp
109e0b: ff 73 10 pushl 0x10(%ebx)
109e0e: ff 93 a0 00 00 00 call *0xa0(%ebx)
if (c != EOF) {
109e14: 83 c4 10 add $0x10,%esp
109e17: 83 f8 ff cmp $0xffffffff,%eax
109e1a: 75 30 jne 109e4c <rtems_termios_rxdaemon+0x58>
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
109e1c: 56 push %esi
109e1d: 6a 00 push $0x0
109e1f: 6a 02 push $0x2
109e21: 6a 03 push $0x3
109e23: e8 94 07 00 00 call 10a5bc <rtems_event_receive>
(TERMIOS_RX_PROC_EVENT | TERMIOS_RX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
109e28: 83 c4 10 add $0x10,%esp
109e2b: f6 45 e0 01 testb $0x1,-0x20(%ebp)
109e2f: 74 d7 je 109e08 <rtems_termios_rxdaemon+0x14><== ALWAYS TAKEN
tty->rxTaskId = 0;
109e31: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) <== NOT EXECUTED
109e38: 00 00 00
rtems_task_delete(RTEMS_SELF);
109e3b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109e3e: 6a 00 push $0x0 <== NOT EXECUTED
109e40: e8 5f 10 00 00 call 10aea4 <rtems_task_delete> <== NOT EXECUTED
109e45: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109e48: eb be jmp 109e08 <rtems_termios_rxdaemon+0x14><== NOT EXECUTED
109e4a: 66 90 xchg %ax,%ax <== NOT EXECUTED
c = tty->device.pollRead(tty->minor);
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
109e4c: 88 45 e7 mov %al,-0x19(%ebp)
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
109e4f: 50 push %eax
109e50: 6a 01 push $0x1
109e52: 57 push %edi
109e53: 53 push %ebx
109e54: e8 8f fc ff ff call 109ae8 <rtems_termios_enqueue_raw_characters>
109e59: 83 c4 10 add $0x10,%esp
109e5c: eb be jmp 109e1c <rtems_termios_rxdaemon+0x28>
0010a0a4 <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
10a0a4: 55 push %ebp
10a0a5: 89 e5 mov %esp,%ebp
10a0a7: 56 push %esi
10a0a8: 53 push %ebx
10a0a9: 83 ec 10 sub $0x10,%esp
10a0ac: 8b 5d 08 mov 0x8(%ebp),%ebx
10a0af: 8d 75 f4 lea -0xc(%ebp),%esi
10a0b2: eb 28 jmp 10a0dc <rtems_termios_txdaemon+0x38>
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
10a0b4: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
10a0ba: c1 e0 05 shl $0x5,%eax
10a0bd: 8b 80 54 60 12 00 mov 0x126054(%eax),%eax
10a0c3: 85 c0 test %eax,%eax
10a0c5: 74 09 je 10a0d0 <rtems_termios_txdaemon+0x2c><== ALWAYS TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
10a0c7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a0ca: 53 push %ebx <== NOT EXECUTED
10a0cb: ff d0 call *%eax <== NOT EXECUTED
10a0cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
10a0d0: 83 ec 0c sub $0xc,%esp
10a0d3: 53 push %ebx
10a0d4: e8 87 fd ff ff call 109e60 <rtems_termios_refill_transmitter>
}
10a0d9: 83 c4 10 add $0x10,%esp
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
10a0dc: 56 push %esi
10a0dd: 6a 00 push $0x0
10a0df: 6a 02 push $0x2
10a0e1: 6a 03 push $0x3
10a0e3: e8 d4 04 00 00 call 10a5bc <rtems_event_receive>
(TERMIOS_TX_START_EVENT | TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
10a0e8: 83 c4 10 add $0x10,%esp
10a0eb: f6 45 f4 01 testb $0x1,-0xc(%ebp)
10a0ef: 74 c3 je 10a0b4 <rtems_termios_txdaemon+0x10><== ALWAYS TAKEN
tty->txTaskId = 0;
10a0f1: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED
10a0f8: 00 00 00
rtems_task_delete(RTEMS_SELF);
10a0fb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a0fe: 6a 00 push $0x0 <== NOT EXECUTED
10a100: e8 9f 0d 00 00 call 10aea4 <rtems_task_delete> <== NOT EXECUTED
10a105: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a108: eb aa jmp 10a0b4 <rtems_termios_txdaemon+0x10><== NOT EXECUTED
001096b4 <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
1096b4: 55 push %ebp
1096b5: 89 e5 mov %esp,%ebp
1096b7: 57 push %edi
1096b8: 56 push %esi
1096b9: 53 push %ebx
1096ba: 83 ec 20 sub $0x20,%esp
1096bd: 8b 7d 08 mov 0x8(%ebp),%edi
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
1096c0: 8b 07 mov (%edi),%eax
1096c2: 8b 70 34 mov 0x34(%eax),%esi
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
1096c5: 6a 00 push $0x0
1096c7: 6a 00 push $0x0
1096c9: ff 76 18 pushl 0x18(%esi)
1096cc: e8 d7 14 00 00 call 10aba8 <rtems_semaphore_obtain>
1096d1: 89 45 e4 mov %eax,-0x1c(%ebp)
if (sc != RTEMS_SUCCESSFUL)
1096d4: 83 c4 10 add $0x10,%esp
1096d7: 85 c0 test %eax,%eax
1096d9: 75 29 jne 109704 <rtems_termios_write+0x50><== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
1096db: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax
1096e1: c1 e0 05 shl $0x5,%eax
1096e4: 8b 80 4c 60 12 00 mov 0x12604c(%eax),%eax
1096ea: 85 c0 test %eax,%eax
1096ec: 74 22 je 109710 <rtems_termios_write+0x5c>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
1096ee: 83 ec 08 sub $0x8,%esp
1096f1: 57 push %edi
1096f2: 56 push %esi
1096f3: ff d0 call *%eax
1096f5: 89 45 e4 mov %eax,-0x1c(%ebp)
rtems_semaphore_release (tty->osem);
1096f8: 5f pop %edi
1096f9: ff 76 18 pushl 0x18(%esi)
1096fc: e8 a3 15 00 00 call 10aca4 <rtems_semaphore_release>
return sc;
109701: 83 c4 10 add $0x10,%esp
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
}
rtems_semaphore_release (tty->osem);
return sc;
}
109704: 8b 45 e4 mov -0x1c(%ebp),%eax
109707: 8d 65 f4 lea -0xc(%ebp),%esp
10970a: 5b pop %ebx
10970b: 5e pop %esi
10970c: 5f pop %edi
10970d: c9 leave
10970e: c3 ret
10970f: 90 nop
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
109710: f6 46 34 01 testb $0x1,0x34(%esi)
109714: 74 4e je 109764 <rtems_termios_write+0xb0><== NEVER TAKEN
uint32_t count = args->count;
109716: 8b 47 10 mov 0x10(%edi),%eax
109719: 89 45 e0 mov %eax,-0x20(%ebp)
char *buffer = args->buffer;
10971c: 8b 47 0c mov 0xc(%edi),%eax
while (count--)
10971f: 8b 5d e0 mov -0x20(%ebp),%ebx
109722: 85 db test %ebx,%ebx
109724: 74 56 je 10977c <rtems_termios_write+0xc8><== NEVER TAKEN
109726: 31 db xor %ebx,%ebx
109728: 89 7d dc mov %edi,-0x24(%ebp)
10972b: 89 c7 mov %eax,%edi
10972d: 8d 76 00 lea 0x0(%esi),%esi
oproc (*buffer++, tty);
109730: 0f b6 04 1f movzbl (%edi,%ebx,1),%eax
109734: 89 f2 mov %esi,%edx
109736: e8 6d fa ff ff call 1091a8 <oproc>
10973b: 43 inc %ebx
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
10973c: 39 5d e0 cmp %ebx,-0x20(%ebp)
10973f: 75 ef jne 109730 <rtems_termios_write+0x7c>
109741: 8b 7d dc mov -0x24(%ebp),%edi
109744: 8b 47 10 mov 0x10(%edi),%eax
oproc (*buffer++, tty);
args->bytes_moved = args->count;
109747: 89 47 18 mov %eax,0x18(%edi)
} else {
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
}
rtems_semaphore_release (tty->osem);
10974a: 83 ec 0c sub $0xc,%esp
10974d: ff 76 18 pushl 0x18(%esi)
109750: e8 4f 15 00 00 call 10aca4 <rtems_semaphore_release>
return sc;
109755: 83 c4 10 add $0x10,%esp
}
109758: 8b 45 e4 mov -0x1c(%ebp),%eax
10975b: 8d 65 f4 lea -0xc(%ebp),%esp
10975e: 5b pop %ebx
10975f: 5e pop %esi
109760: 5f pop %edi
109761: c9 leave
109762: c3 ret
109763: 90 nop
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
109764: 51 push %ecx <== NOT EXECUTED
109765: 56 push %esi <== NOT EXECUTED
109766: ff 77 10 pushl 0x10(%edi) <== NOT EXECUTED
109769: ff 77 0c pushl 0xc(%edi) <== NOT EXECUTED
10976c: e8 03 f9 ff ff call 109074 <rtems_termios_puts> <== NOT EXECUTED
args->bytes_moved = args->count;
109771: 8b 47 10 mov 0x10(%edi),%eax <== NOT EXECUTED
109774: 89 47 18 mov %eax,0x18(%edi) <== NOT EXECUTED
109777: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10977a: eb ce jmp 10974a <rtems_termios_write+0x96><== NOT EXECUTED
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
10977c: 31 c0 xor %eax,%eax <== NOT EXECUTED
10977e: eb c7 jmp 109747 <rtems_termios_write+0x93><== NOT EXECUTED
00117cfc <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
117cfc: 55 push %ebp
117cfd: 89 e5 mov %esp,%ebp
117cff: 83 ec 1c sub $0x1c,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
117d02: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
117d05: 50 push %eax
117d06: ff 75 08 pushl 0x8(%ebp)
117d09: 68 40 0c 14 00 push $0x140c40
117d0e: e8 b1 2a 00 00 call 11a7c4 <_Objects_Get>
switch ( location ) {
117d13: 83 c4 10 add $0x10,%esp
117d16: 8b 55 f4 mov -0xc(%ebp),%edx
117d19: 85 d2 test %edx,%edx
117d1b: 74 07 je 117d24 <rtems_timer_cancel+0x28>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
117d1d: b8 04 00 00 00 mov $0x4,%eax
}
117d22: c9 leave
117d23: c3 ret
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
117d24: 83 78 38 04 cmpl $0x4,0x38(%eax)
117d28: 74 0f je 117d39 <rtems_timer_cancel+0x3d><== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
117d2a: 83 ec 0c sub $0xc,%esp
117d2d: 83 c0 10 add $0x10,%eax
117d30: 50 push %eax
117d31: e8 3e 46 00 00 call 11c374 <_Watchdog_Remove>
117d36: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
117d39: e8 d6 35 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
117d3e: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
117d40: c9 leave
117d41: c3 ret
0010b4d8 <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
10b4d8: 55 push %ebp
10b4d9: 89 e5 mov %esp,%ebp
10b4db: 57 push %edi
10b4dc: 56 push %esi
10b4dd: 53 push %ebx
10b4de: 83 ec 0c sub $0xc,%esp
10b4e1: 8b 5d 08 mov 0x8(%ebp),%ebx
10b4e4: 8b 75 0c mov 0xc(%ebp),%esi
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
10b4e7: 85 db test %ebx,%ebx
10b4e9: 74 6d je 10b558 <rtems_timer_create+0x80>
return RTEMS_INVALID_NAME;
if ( !id )
10b4eb: 85 f6 test %esi,%esi
10b4ed: 0f 84 89 00 00 00 je 10b57c <rtems_timer_create+0xa4>
10b4f3: a1 2c 7a 12 00 mov 0x127a2c,%eax
10b4f8: 40 inc %eax
10b4f9: a3 2c 7a 12 00 mov %eax,0x127a2c
* This function allocates a timer control block from
* the inactive chain of free timer control blocks.
*/
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Allocate( void )
{
return (Timer_Control *) _Objects_Allocate( &_Timer_Information );
10b4fe: 83 ec 0c sub $0xc,%esp
10b501: 68 40 7d 12 00 push $0x127d40
10b506: e8 ad 0d 00 00 call 10c2b8 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
10b50b: 83 c4 10 add $0x10,%esp
10b50e: 85 c0 test %eax,%eax
10b510: 74 56 je 10b568 <rtems_timer_create+0x90>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_timer->the_class = TIMER_DORMANT;
10b512: c7 40 38 04 00 00 00 movl $0x4,0x38(%eax)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10b519: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10b520: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
the_watchdog->id = id;
10b527: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
the_watchdog->user_data = user_data;
10b52e: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10b535: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10b538: 0f b7 fa movzwl %dx,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10b53b: 8b 0d 5c 7d 12 00 mov 0x127d5c,%ecx
10b541: 89 04 b9 mov %eax,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10b544: 89 58 0c mov %ebx,0xc(%eax)
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
10b547: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
10b549: e8 f6 1c 00 00 call 10d244 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b54e: 31 c0 xor %eax,%eax
}
10b550: 8d 65 f4 lea -0xc(%ebp),%esp
10b553: 5b pop %ebx
10b554: 5e pop %esi
10b555: 5f pop %edi
10b556: c9 leave
10b557: c3 ret
)
{
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10b558: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b55d: 8d 65 f4 lea -0xc(%ebp),%esp
10b560: 5b pop %ebx
10b561: 5e pop %esi
10b562: 5f pop %edi
10b563: c9 leave
10b564: c3 ret
10b565: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
_Thread_Enable_dispatch();
10b568: e8 d7 1c 00 00 call 10d244 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
10b56d: b8 05 00 00 00 mov $0x5,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b572: 8d 65 f4 lea -0xc(%ebp),%esp
10b575: 5b pop %ebx
10b576: 5e pop %esi
10b577: 5f pop %edi
10b578: c9 leave
10b579: c3 ret
10b57a: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10b57c: b8 09 00 00 00 mov $0x9,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b581: 8d 65 f4 lea -0xc(%ebp),%esp
10b584: 5b pop %ebx
10b585: 5e pop %esi
10b586: 5f pop %edi
10b587: c9 leave
10b588: c3 ret
00117df8 <rtems_timer_delete>:
*/
rtems_status_code rtems_timer_delete(
rtems_id id
)
{
117df8: 55 push %ebp
117df9: 89 e5 mov %esp,%ebp
117dfb: 53 push %ebx
117dfc: 83 ec 18 sub $0x18,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
117dff: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
117e02: 50 push %eax
117e03: ff 75 08 pushl 0x8(%ebp)
117e06: 68 40 0c 14 00 push $0x140c40
117e0b: e8 b4 29 00 00 call 11a7c4 <_Objects_Get>
117e10: 89 c3 mov %eax,%ebx
switch ( location ) {
117e12: 83 c4 10 add $0x10,%esp
117e15: 8b 4d f4 mov -0xc(%ebp),%ecx
117e18: 85 c9 test %ecx,%ecx
117e1a: 75 38 jne 117e54 <rtems_timer_delete+0x5c>
case OBJECTS_LOCAL:
_Objects_Close( &_Timer_Information, &the_timer->Object );
117e1c: 83 ec 08 sub $0x8,%esp
117e1f: 50 push %eax
117e20: 68 40 0c 14 00 push $0x140c40
117e25: e8 26 25 00 00 call 11a350 <_Objects_Close>
(void) _Watchdog_Remove( &the_timer->Ticker );
117e2a: 8d 43 10 lea 0x10(%ebx),%eax
117e2d: 89 04 24 mov %eax,(%esp)
117e30: e8 3f 45 00 00 call 11c374 <_Watchdog_Remove>
*/
RTEMS_INLINE_ROUTINE void _Timer_Free (
Timer_Control *the_timer
)
{
_Objects_Free( &_Timer_Information, &the_timer->Object );
117e35: 58 pop %eax
117e36: 5a pop %edx
117e37: 53 push %ebx
117e38: 68 40 0c 14 00 push $0x140c40
117e3d: e8 06 28 00 00 call 11a648 <_Objects_Free>
_Timer_Free( the_timer );
_Thread_Enable_dispatch();
117e42: e8 cd 34 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
117e47: 83 c4 10 add $0x10,%esp
117e4a: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
117e4c: 8b 5d fc mov -0x4(%ebp),%ebx
117e4f: c9 leave
117e50: c3 ret
117e51: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
117e54: b8 04 00 00 00 mov $0x4,%eax
}
117e59: 8b 5d fc mov -0x4(%ebp),%ebx
117e5c: c9 leave
117e5d: c3 ret
0010b58c <rtems_timer_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
10b58c: 55 push %ebp
10b58d: 89 e5 mov %esp,%ebp
10b58f: 57 push %edi
10b590: 56 push %esi
10b591: 53 push %ebx
10b592: 83 ec 2c sub $0x2c,%esp
10b595: 8b 5d 0c mov 0xc(%ebp),%ebx
10b598: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
10b59b: 85 db test %ebx,%ebx
10b59d: 0f 84 99 00 00 00 je 10b63c <rtems_timer_fire_after+0xb0>
return RTEMS_INVALID_NUMBER;
if ( !routine )
10b5a3: 85 f6 test %esi,%esi
10b5a5: 0f 84 b1 00 00 00 je 10b65c <rtems_timer_fire_after+0xd0>
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
10b5ab: 57 push %edi
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
10b5ac: 8d 45 e4 lea -0x1c(%ebp),%eax
10b5af: 50 push %eax
10b5b0: ff 75 08 pushl 0x8(%ebp)
10b5b3: 68 40 7d 12 00 push $0x127d40
10b5b8: e8 af 11 00 00 call 10c76c <_Objects_Get>
10b5bd: 89 c7 mov %eax,%edi
switch ( location ) {
10b5bf: 83 c4 10 add $0x10,%esp
10b5c2: 8b 4d e4 mov -0x1c(%ebp),%ecx
10b5c5: 85 c9 test %ecx,%ecx
10b5c7: 74 0f je 10b5d8 <rtems_timer_fire_after+0x4c>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b5c9: b8 04 00 00 00 mov $0x4,%eax
}
10b5ce: 8d 65 f4 lea -0xc(%ebp),%esp
10b5d1: 5b pop %ebx
10b5d2: 5e pop %esi
10b5d3: 5f pop %edi
10b5d4: c9 leave
10b5d5: c3 ret
10b5d6: 66 90 xchg %ax,%ax
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
10b5d8: 8d 50 10 lea 0x10(%eax),%edx
10b5db: 83 ec 0c sub $0xc,%esp
10b5de: 52 push %edx
10b5df: 89 55 d4 mov %edx,-0x2c(%ebp)
10b5e2: e8 a9 2a 00 00 call 10e090 <_Watchdog_Remove>
_ISR_Disable( level );
10b5e7: 9c pushf
10b5e8: fa cli
10b5e9: 58 pop %eax
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
10b5ea: 83 c4 10 add $0x10,%esp
10b5ed: 8b 57 18 mov 0x18(%edi),%edx
10b5f0: 85 d2 test %edx,%edx
10b5f2: 8b 55 d4 mov -0x2c(%ebp),%edx
10b5f5: 75 55 jne 10b64c <rtems_timer_fire_after+0xc0>
/*
* OK. Now we now the timer was not rescheduled by an interrupt
* so we can atomically initialize it as in use.
*/
the_timer->the_class = TIMER_INTERVAL;
10b5f7: c7 47 38 00 00 00 00 movl $0x0,0x38(%edi)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10b5fe: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
the_watchdog->routine = routine;
10b605: 89 77 2c mov %esi,0x2c(%edi)
the_watchdog->id = id;
10b608: 8b 4d 08 mov 0x8(%ebp),%ecx
10b60b: 89 4f 30 mov %ecx,0x30(%edi)
the_watchdog->user_data = user_data;
10b60e: 8b 4d 14 mov 0x14(%ebp),%ecx
10b611: 89 4f 34 mov %ecx,0x34(%edi)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_ISR_Enable( level );
10b614: 50 push %eax
10b615: 9d popf
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b616: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b619: 83 ec 08 sub $0x8,%esp
10b61c: 52 push %edx
10b61d: 68 00 7b 12 00 push $0x127b00
10b622: e8 29 29 00 00 call 10df50 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
_Thread_Enable_dispatch();
10b627: e8 18 1c 00 00 call 10d244 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b62c: 83 c4 10 add $0x10,%esp
10b62f: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b631: 8d 65 f4 lea -0xc(%ebp),%esp
10b634: 5b pop %ebx
10b635: 5e pop %esi
10b636: 5f pop %edi
10b637: c9 leave
10b638: c3 ret
10b639: 8d 76 00 lea 0x0(%esi),%esi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
10b63c: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b641: 8d 65 f4 lea -0xc(%ebp),%esp
10b644: 5b pop %ebx
10b645: 5e pop %esi
10b646: 5f pop %edi
10b647: c9 leave
10b648: c3 ret
10b649: 8d 76 00 lea 0x0(%esi),%esi
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
10b64c: 50 push %eax
10b64d: 9d popf
_Thread_Enable_dispatch();
10b64e: e8 f1 1b 00 00 call 10d244 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b653: 31 c0 xor %eax,%eax
10b655: e9 74 ff ff ff jmp 10b5ce <rtems_timer_fire_after+0x42>
10b65a: 66 90 xchg %ax,%ax
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
10b65c: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b661: 8d 65 f4 lea -0xc(%ebp),%esp
10b664: 5b pop %ebx
10b665: 5e pop %esi
10b666: 5f pop %edi
10b667: c9 leave
10b668: c3 ret
00117f40 <rtems_timer_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
117f40: 55 push %ebp
117f41: 89 e5 mov %esp,%ebp
117f43: 57 push %edi
117f44: 56 push %esi
117f45: 53 push %ebx
117f46: 83 ec 2c sub $0x2c,%esp
117f49: 8b 75 08 mov 0x8(%ebp),%esi
117f4c: 8b 7d 0c mov 0xc(%ebp),%edi
117f4f: 8b 5d 10 mov 0x10(%ebp),%ebx
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
117f52: 80 3d fc 08 14 00 00 cmpb $0x0,0x1408fc
117f59: 75 0d jne 117f68 <rtems_timer_fire_when+0x28>
return RTEMS_NOT_DEFINED;
117f5b: b8 0b 00 00 00 mov $0xb,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
117f60: 8d 65 f4 lea -0xc(%ebp),%esp
117f63: 5b pop %ebx
117f64: 5e pop %esi
117f65: 5f pop %edi
117f66: c9 leave
117f67: c3 ret
rtems_interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
117f68: 83 ec 0c sub $0xc,%esp
117f6b: 57 push %edi
117f6c: e8 93 d4 ff ff call 115404 <_TOD_Validate>
117f71: 83 c4 10 add $0x10,%esp
117f74: 84 c0 test %al,%al
117f76: 74 1e je 117f96 <rtems_timer_fire_when+0x56>
return RTEMS_INVALID_CLOCK;
if ( !routine )
117f78: 85 db test %ebx,%ebx
117f7a: 0f 84 a4 00 00 00 je 118024 <rtems_timer_fire_when+0xe4><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
117f80: 83 ec 0c sub $0xc,%esp
117f83: 57 push %edi
117f84: e8 ef d3 ff ff call 115378 <_TOD_To_seconds>
117f89: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
117f8b: 83 c4 10 add $0x10,%esp
117f8e: 3b 05 88 09 14 00 cmp 0x140988,%eax
117f94: 77 0e ja 117fa4 <rtems_timer_fire_when+0x64>
return RTEMS_INVALID_CLOCK;
117f96: b8 14 00 00 00 mov $0x14,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
117f9b: 8d 65 f4 lea -0xc(%ebp),%esp
117f9e: 5b pop %ebx
117f9f: 5e pop %esi
117fa0: 5f pop %edi
117fa1: c9 leave
117fa2: c3 ret
117fa3: 90 nop
117fa4: 50 push %eax
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
117fa5: 8d 45 e4 lea -0x1c(%ebp),%eax
117fa8: 50 push %eax
117fa9: 56 push %esi
117faa: 68 40 0c 14 00 push $0x140c40
117faf: e8 10 28 00 00 call 11a7c4 <_Objects_Get>
switch ( location ) {
117fb4: 83 c4 10 add $0x10,%esp
117fb7: 8b 4d e4 mov -0x1c(%ebp),%ecx
117fba: 85 c9 test %ecx,%ecx
117fbc: 75 5a jne 118018 <rtems_timer_fire_when+0xd8><== NEVER TAKEN
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
117fbe: 8d 48 10 lea 0x10(%eax),%ecx
117fc1: 83 ec 0c sub $0xc,%esp
117fc4: 51 push %ecx
117fc5: 89 45 d0 mov %eax,-0x30(%ebp)
117fc8: 89 4d d4 mov %ecx,-0x2c(%ebp)
117fcb: e8 a4 43 00 00 call 11c374 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY;
117fd0: 8b 55 d0 mov -0x30(%ebp),%edx
117fd3: c7 42 38 02 00 00 00 movl $0x2,0x38(%edx)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
117fda: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
117fe1: 89 5a 2c mov %ebx,0x2c(%edx)
the_watchdog->id = id;
117fe4: 89 72 30 mov %esi,0x30(%edx)
the_watchdog->user_data = user_data;
117fe7: 8b 45 14 mov 0x14(%ebp),%eax
117fea: 89 42 34 mov %eax,0x34(%edx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_Watchdog_Insert_seconds(
117fed: 2b 3d 88 09 14 00 sub 0x140988,%edi
117ff3: 89 7a 1c mov %edi,0x1c(%edx)
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
117ff6: 58 pop %eax
117ff7: 5a pop %edx
117ff8: 8b 4d d4 mov -0x2c(%ebp),%ecx
117ffb: 51 push %ecx
117ffc: 68 b4 09 14 00 push $0x1409b4
118001: e8 2e 42 00 00 call 11c234 <_Watchdog_Insert>
&the_timer->Ticker,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
118006: e8 09 33 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11800b: 83 c4 10 add $0x10,%esp
11800e: 31 c0 xor %eax,%eax
118010: e9 4b ff ff ff jmp 117f60 <rtems_timer_fire_when+0x20>
118015: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118018: b8 04 00 00 00 mov $0x4,%eax
11801d: e9 3e ff ff ff jmp 117f60 <rtems_timer_fire_when+0x20>
118022: 66 90 xchg %ax,%ax
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
118024: b8 09 00 00 00 mov $0x9,%eax
118029: e9 32 ff ff ff jmp 117f60 <rtems_timer_fire_when+0x20>
001186bc <rtems_timer_initiate_server>:
rtems_status_code rtems_timer_initiate_server(
uint32_t priority,
uint32_t stack_size,
rtems_attribute attribute_set
)
{
1186bc: 55 push %ebp
1186bd: 89 e5 mov %esp,%ebp
1186bf: 56 push %esi
1186c0: 53 push %ebx
1186c1: 83 ec 10 sub $0x10,%esp
1186c4: 8b 45 08 mov 0x8(%ebp),%eax
1186c7: 85 c0 test %eax,%eax
1186c9: 74 41 je 11870c <rtems_timer_initiate_server+0x50>
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
1186cb: 0f b6 15 d4 82 13 00 movzbl 0x1382d4,%edx
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
1186d2: 39 d0 cmp %edx,%eax
1186d4: 76 42 jbe 118718 <rtems_timer_initiate_server+0x5c>
* structured so we check it is invalid before looking for
* a specific invalid value as the default.
*/
_priority = priority;
if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
1186d6: 40 inc %eax
1186d7: 75 33 jne 11870c <rtems_timer_initiate_server+0x50>
return RTEMS_INVALID_PRIORITY;
_priority = 0;
1186d9: 31 f6 xor %esi,%esi
1186db: 8b 15 ec 08 14 00 mov 0x1408ec,%edx
1186e1: 42 inc %edx
1186e2: 89 15 ec 08 14 00 mov %edx,0x1408ec
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
1186e8: 8a 1d 20 c2 13 00 mov 0x13c220,%bl
initialized = true;
1186ee: c6 05 20 c2 13 00 01 movb $0x1,0x13c220
_Thread_Enable_dispatch();
1186f5: e8 1a 2c 00 00 call 11b314 <_Thread_Enable_dispatch>
if ( tmpInitialized )
1186fa: 84 db test %bl,%bl
1186fc: 74 1e je 11871c <rtems_timer_initiate_server+0x60>
return RTEMS_INCORRECT_STATE;
1186fe: b8 0e 00 00 00 mov $0xe,%eax
initialized = false;
}
#endif
return status;
}
118703: 8d 65 f8 lea -0x8(%ebp),%esp
118706: 5b pop %ebx
118707: 5e pop %esi
118708: c9 leave
118709: c3 ret
11870a: 66 90 xchg %ax,%ax
* a specific invalid value as the default.
*/
_priority = priority;
if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
return RTEMS_INVALID_PRIORITY;
11870c: b8 13 00 00 00 mov $0x13,%eax
initialized = false;
}
#endif
return status;
}
118711: 8d 65 f8 lea -0x8(%ebp),%esp
118714: 5b pop %ebx
118715: 5e pop %esi
118716: c9 leave
118717: c3 ret
118718: 89 c6 mov %eax,%esi
11871a: eb bf jmp 1186db <rtems_timer_initiate_server+0x1f>
* other library rules. For example, if using a TSR written in Ada the
* Server should run at the same priority as the priority Ada task.
* Otherwise, the priority ceiling for the mutex used to protect the
* GNAT run-time is violated.
*/
status = rtems_task_create(
11871c: 83 ec 08 sub $0x8,%esp
11871f: 8d 45 f4 lea -0xc(%ebp),%eax
118722: 50 push %eax
118723: 8b 45 10 mov 0x10(%ebp),%eax
118726: 80 cc 80 or $0x80,%ah
118729: 50 push %eax
11872a: 68 00 01 00 00 push $0x100
11872f: ff 75 0c pushl 0xc(%ebp)
118732: 56 push %esi
118733: 68 45 4d 49 54 push $0x54494d45
118738: e8 e3 ec ff ff call 117420 <rtems_task_create>
/* user may want floating point but we need */
/* system task specified for 0 priority */
attribute_set | RTEMS_SYSTEM_TASK,
&id /* get the id back */
);
if (status) {
11873d: 83 c4 20 add $0x20,%esp
118740: 85 c0 test %eax,%eax
118742: 74 10 je 118754 <rtems_timer_initiate_server+0x98>
initialized = false;
118744: c6 05 20 c2 13 00 00 movb $0x0,0x13c220
initialized = false;
}
#endif
return status;
}
11874b: 8d 65 f8 lea -0x8(%ebp),%esp
11874e: 5b pop %ebx
11874f: 5e pop %esi
118750: c9 leave
118751: c3 ret
118752: 66 90 xchg %ax,%ax
* We work with the TCB pointer, not the ID, so we need to convert
* to a TCB pointer from here out.
*/
ts->thread = (Thread_Control *)_Objects_Get_local_object(
&_RTEMS_tasks_Information,
_Objects_Get_index(id)
118754: 8b 45 f4 mov -0xc(%ebp),%eax
*/
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return NULL;
#endif
return information->local_table[ index ];
118757: 0f b7 c8 movzwl %ax,%ecx
11875a: 8b 15 9c 08 14 00 mov 0x14089c,%edx
/*
* We work with the TCB pointer, not the ID, so we need to convert
* to a TCB pointer from here out.
*/
ts->thread = (Thread_Control *)_Objects_Get_local_object(
118760: 8b 14 8a mov (%edx,%ecx,4),%edx
118763: 89 15 a0 c1 13 00 mov %edx,0x13c1a0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
118769: c7 05 d0 c1 13 00 d4 movl $0x13c1d4,0x13c1d0
118770: c1 13 00
head->previous = NULL;
118773: c7 05 d4 c1 13 00 00 movl $0x0,0x13c1d4
11877a: 00 00 00
tail->previous = head;
11877d: c7 05 d8 c1 13 00 d0 movl $0x13c1d0,0x13c1d8
118784: c1 13 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
118787: c7 05 08 c2 13 00 0c movl $0x13c20c,0x13c208
11878e: c2 13 00
head->previous = NULL;
118791: c7 05 0c c2 13 00 00 movl $0x0,0x13c20c
118798: 00 00 00
tail->previous = head;
11879b: c7 05 10 c2 13 00 08 movl $0x13c208,0x13c210
1187a2: c2 13 00
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
1187a5: c7 05 b0 c1 13 00 00 movl $0x0,0x13c1b0
1187ac: 00 00 00
the_watchdog->routine = routine;
1187af: c7 05 c4 c1 13 00 60 movl $0x11b160,0x13c1c4
1187b6: b1 11 00
the_watchdog->id = id;
1187b9: a3 c8 c1 13 00 mov %eax,0x13c1c8
the_watchdog->user_data = user_data;
1187be: c7 05 cc c1 13 00 00 movl $0x0,0x13c1cc
1187c5: 00 00 00
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
1187c8: c7 05 e8 c1 13 00 00 movl $0x0,0x13c1e8
1187cf: 00 00 00
the_watchdog->routine = routine;
1187d2: c7 05 fc c1 13 00 60 movl $0x11b160,0x13c1fc
1187d9: b1 11 00
the_watchdog->id = id;
1187dc: a3 00 c2 13 00 mov %eax,0x13c200
the_watchdog->user_data = user_data;
1187e1: c7 05 04 c2 13 00 00 movl $0x0,0x13c204
1187e8: 00 00 00
/*
* Initialize the pointer to the timer schedule method so applications that
* do not use the Timer Server do not have to pull it in.
*/
ts->schedule_operation = _Timer_server_Schedule_operation_method;
1187eb: c7 05 a4 c1 13 00 8c movl $0x11858c,0x13c1a4
1187f2: 85 11 00
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
1187f5: 8b 15 24 0a 14 00 mov 0x140a24,%edx
1187fb: 89 15 dc c1 13 00 mov %edx,0x13c1dc
ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
118801: 8b 15 88 09 14 00 mov 0x140988,%edx
118807: 89 15 14 c2 13 00 mov %edx,0x13c214
ts->insert_chain = NULL;
11880d: c7 05 18 c2 13 00 00 movl $0x0,0x13c218
118814: 00 00 00
ts->active = false;
118817: c6 05 1c c2 13 00 00 movb $0x0,0x13c21c
/*
* The default timer server is now available.
*/
_Timer_server = ts;
11881e: c7 05 80 0c 14 00 a0 movl $0x13c1a0,0x140c80
118825: c1 13 00
/*
* Start the timer server
*/
status = rtems_task_start(
118828: 53 push %ebx
118829: 68 a0 c1 13 00 push $0x13c1a0
11882e: 68 e0 83 11 00 push $0x1183e0
118833: 50 push %eax
118834: e8 a7 f2 ff ff call 117ae0 <rtems_task_start>
if (status) {
initialized = false;
}
#endif
return status;
118839: 83 c4 10 add $0x10,%esp
11883c: e9 d0 fe ff ff jmp 118711 <rtems_timer_initiate_server+0x55>
001180b8 <rtems_timer_reset>:
*/
rtems_status_code rtems_timer_reset(
rtems_id id
)
{
1180b8: 55 push %ebp
1180b9: 89 e5 mov %esp,%ebp
1180bb: 56 push %esi
1180bc: 53 push %ebx
1180bd: 83 ec 24 sub $0x24,%esp
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
the_timer = _Timer_Get( id, &location );
1180c0: 8d 45 f4 lea -0xc(%ebp),%eax
1180c3: 50 push %eax
1180c4: ff 75 08 pushl 0x8(%ebp)
1180c7: 68 40 0c 14 00 push $0x140c40
1180cc: e8 f3 26 00 00 call 11a7c4 <_Objects_Get>
1180d1: 89 c3 mov %eax,%ebx
switch ( location ) {
1180d3: 83 c4 10 add $0x10,%esp
1180d6: 8b 45 f4 mov -0xc(%ebp),%eax
1180d9: 85 c0 test %eax,%eax
1180db: 74 0f je 1180ec <rtems_timer_reset+0x34>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1180dd: b8 04 00 00 00 mov $0x4,%eax
}
1180e2: 8d 65 f8 lea -0x8(%ebp),%esp
1180e5: 5b pop %ebx
1180e6: 5e pop %esi
1180e7: c9 leave
1180e8: c3 ret
1180e9: 8d 76 00 lea 0x0(%esi),%esi
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
1180ec: 8b 43 38 mov 0x38(%ebx),%eax
1180ef: 85 c0 test %eax,%eax
1180f1: 74 1d je 118110 <rtems_timer_reset+0x58>
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
1180f3: 48 dec %eax
1180f4: 74 3a je 118130 <rtems_timer_reset+0x78>
/*
* Must be dormant or time of day timer (e.g. TIMER_DORMANT,
* TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK). We
* can only reset active interval timers.
*/
status = RTEMS_NOT_DEFINED;
1180f6: b8 0b 00 00 00 mov $0xb,%eax
}
_Thread_Enable_dispatch();
1180fb: 89 45 e4 mov %eax,-0x1c(%ebp)
1180fe: e8 11 32 00 00 call 11b314 <_Thread_Enable_dispatch>
return status;
118103: 8b 45 e4 mov -0x1c(%ebp),%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118106: 8d 65 f8 lea -0x8(%ebp),%esp
118109: 5b pop %ebx
11810a: 5e pop %esi
11810b: c9 leave
11810c: c3 ret
11810d: 8d 76 00 lea 0x0(%esi),%esi
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
_Watchdog_Remove( &the_timer->Ticker );
118110: 83 c3 10 add $0x10,%ebx
118113: 83 ec 0c sub $0xc,%esp
118116: 53 push %ebx
118117: e8 58 42 00 00 call 11c374 <_Watchdog_Remove>
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
11811c: 59 pop %ecx
11811d: 5e pop %esi
11811e: 53 push %ebx
11811f: 68 c0 09 14 00 push $0x1409c0
118124: e8 0b 41 00 00 call 11c234 <_Watchdog_Insert>
118129: 83 c4 10 add $0x10,%esp
rtems_id id
)
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
11812c: 31 c0 xor %eax,%eax
11812e: eb cb jmp 1180fb <rtems_timer_reset+0x43>
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
Timer_server_Control *timer_server = _Timer_server;
118130: 8b 35 80 0c 14 00 mov 0x140c80,%esi
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
118136: 83 ec 0c sub $0xc,%esp
118139: 8d 43 10 lea 0x10(%ebx),%eax
11813c: 50 push %eax
11813d: e8 32 42 00 00 call 11c374 <_Watchdog_Remove>
(*timer_server->schedule_operation)( timer_server, the_timer );
118142: 58 pop %eax
118143: 5a pop %edx
118144: 53 push %ebx
118145: 56 push %esi
118146: ff 56 04 call *0x4(%esi)
118149: 83 c4 10 add $0x10,%esp
rtems_id id
)
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
11814c: 31 c0 xor %eax,%eax
11814e: eb ab jmp 1180fb <rtems_timer_reset+0x43>
00118150 <rtems_timer_server_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
118150: 55 push %ebp
118151: 89 e5 mov %esp,%ebp
118153: 57 push %edi
118154: 56 push %esi
118155: 53 push %ebx
118156: 83 ec 2c sub $0x2c,%esp
118159: 8b 7d 0c mov 0xc(%ebp),%edi
11815c: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
11815f: 8b 1d 80 0c 14 00 mov 0x140c80,%ebx
if ( !timer_server )
118165: 85 db test %ebx,%ebx
118167: 0f 84 9f 00 00 00 je 11820c <rtems_timer_server_fire_after+0xbc>
return RTEMS_INCORRECT_STATE;
if ( !routine )
11816d: 85 f6 test %esi,%esi
11816f: 0f 84 a3 00 00 00 je 118218 <rtems_timer_server_fire_after+0xc8>
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
118175: 85 ff test %edi,%edi
118177: 75 0f jne 118188 <rtems_timer_server_fire_after+0x38>
return RTEMS_INVALID_NUMBER;
118179: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11817e: 8d 65 f4 lea -0xc(%ebp),%esp
118181: 5b pop %ebx
118182: 5e pop %esi
118183: 5f pop %edi
118184: c9 leave
118185: c3 ret
118186: 66 90 xchg %ax,%ax
118188: 52 push %edx
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
118189: 8d 45 e4 lea -0x1c(%ebp),%eax
11818c: 50 push %eax
11818d: ff 75 08 pushl 0x8(%ebp)
118190: 68 40 0c 14 00 push $0x140c40
118195: e8 2a 26 00 00 call 11a7c4 <_Objects_Get>
11819a: 89 c2 mov %eax,%edx
switch ( location ) {
11819c: 83 c4 10 add $0x10,%esp
11819f: 8b 45 e4 mov -0x1c(%ebp),%eax
1181a2: 85 c0 test %eax,%eax
1181a4: 75 56 jne 1181fc <rtems_timer_server_fire_after+0xac>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
1181a6: 83 ec 0c sub $0xc,%esp
1181a9: 8d 42 10 lea 0x10(%edx),%eax
1181ac: 50 push %eax
1181ad: 89 55 d4 mov %edx,-0x2c(%ebp)
1181b0: e8 bf 41 00 00 call 11c374 <_Watchdog_Remove>
_ISR_Disable( level );
1181b5: 9c pushf
1181b6: fa cli
1181b7: 58 pop %eax
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
1181b8: 83 c4 10 add $0x10,%esp
1181bb: 8b 55 d4 mov -0x2c(%ebp),%edx
1181be: 8b 4a 18 mov 0x18(%edx),%ecx
1181c1: 85 c9 test %ecx,%ecx
1181c3: 75 5f jne 118224 <rtems_timer_server_fire_after+0xd4>
/*
* OK. Now we now the timer was not rescheduled by an interrupt
* so we can atomically initialize it as in use.
*/
the_timer->the_class = TIMER_INTERVAL_ON_TASK;
1181c5: c7 42 38 01 00 00 00 movl $0x1,0x38(%edx)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
1181cc: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
1181d3: 89 72 2c mov %esi,0x2c(%edx)
the_watchdog->id = id;
1181d6: 8b 4d 08 mov 0x8(%ebp),%ecx
1181d9: 89 4a 30 mov %ecx,0x30(%edx)
the_watchdog->user_data = user_data;
1181dc: 8b 4d 14 mov 0x14(%ebp),%ecx
1181df: 89 4a 34 mov %ecx,0x34(%edx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = ticks;
1181e2: 89 7a 1c mov %edi,0x1c(%edx)
_ISR_Enable( level );
1181e5: 50 push %eax
1181e6: 9d popf
(*timer_server->schedule_operation)( timer_server, the_timer );
1181e7: 83 ec 08 sub $0x8,%esp
1181ea: 52 push %edx
1181eb: 53 push %ebx
1181ec: ff 53 04 call *0x4(%ebx)
_Thread_Enable_dispatch();
1181ef: e8 20 31 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1181f4: 83 c4 10 add $0x10,%esp
1181f7: 31 c0 xor %eax,%eax
1181f9: eb 83 jmp 11817e <rtems_timer_server_fire_after+0x2e>
1181fb: 90 nop
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1181fc: b8 04 00 00 00 mov $0x4,%eax
}
118201: 8d 65 f4 lea -0xc(%ebp),%esp
118204: 5b pop %ebx
118205: 5e pop %esi
118206: 5f pop %edi
118207: c9 leave
118208: c3 ret
118209: 8d 76 00 lea 0x0(%esi),%esi
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
11820c: b8 0e 00 00 00 mov $0xe,%eax
118211: e9 68 ff ff ff jmp 11817e <rtems_timer_server_fire_after+0x2e>
118216: 66 90 xchg %ax,%ax
if ( !routine )
return RTEMS_INVALID_ADDRESS;
118218: b8 09 00 00 00 mov $0x9,%eax
11821d: e9 5c ff ff ff jmp 11817e <rtems_timer_server_fire_after+0x2e>
118222: 66 90 xchg %ax,%ax
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
118224: 50 push %eax
118225: 9d popf
_Thread_Enable_dispatch();
118226: e8 e9 30 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11822b: 31 c0 xor %eax,%eax
11822d: e9 4c ff ff ff jmp 11817e <rtems_timer_server_fire_after+0x2e>
00118234 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
118234: 55 push %ebp
118235: 89 e5 mov %esp,%ebp
118237: 57 push %edi
118238: 56 push %esi
118239: 53 push %ebx
11823a: 83 ec 2c sub $0x2c,%esp
11823d: 8b 7d 0c mov 0xc(%ebp),%edi
118240: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
118243: 8b 1d 80 0c 14 00 mov 0x140c80,%ebx
if ( !timer_server )
118249: 85 db test %ebx,%ebx
11824b: 0f 84 d7 00 00 00 je 118328 <rtems_timer_server_fire_when+0xf4>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
118251: 80 3d fc 08 14 00 00 cmpb $0x0,0x1408fc
118258: 0f 84 aa 00 00 00 je 118308 <rtems_timer_server_fire_when+0xd4><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
11825e: 85 f6 test %esi,%esi
118260: 0f 84 b2 00 00 00 je 118318 <rtems_timer_server_fire_when+0xe4>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
118266: 83 ec 0c sub $0xc,%esp
118269: 57 push %edi
11826a: e8 95 d1 ff ff call 115404 <_TOD_Validate>
11826f: 83 c4 10 add $0x10,%esp
118272: 84 c0 test %al,%al
118274: 75 0e jne 118284 <rtems_timer_server_fire_when+0x50>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
118276: b8 14 00 00 00 mov $0x14,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11827b: 8d 65 f4 lea -0xc(%ebp),%esp
11827e: 5b pop %ebx
11827f: 5e pop %esi
118280: 5f pop %edi
118281: c9 leave
118282: c3 ret
118283: 90 nop
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
118284: 83 ec 0c sub $0xc,%esp
118287: 57 push %edi
118288: e8 eb d0 ff ff call 115378 <_TOD_To_seconds>
11828d: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
11828f: 83 c4 10 add $0x10,%esp
118292: 3b 05 88 09 14 00 cmp 0x140988,%eax
118298: 76 dc jbe 118276 <rtems_timer_server_fire_when+0x42>
11829a: 52 push %edx
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
11829b: 8d 45 e4 lea -0x1c(%ebp),%eax
11829e: 50 push %eax
11829f: ff 75 08 pushl 0x8(%ebp)
1182a2: 68 40 0c 14 00 push $0x140c40
1182a7: e8 18 25 00 00 call 11a7c4 <_Objects_Get>
1182ac: 89 c2 mov %eax,%edx
switch ( location ) {
1182ae: 83 c4 10 add $0x10,%esp
1182b1: 8b 45 e4 mov -0x1c(%ebp),%eax
1182b4: 85 c0 test %eax,%eax
1182b6: 75 7c jne 118334 <rtems_timer_server_fire_when+0x100>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
1182b8: 83 ec 0c sub $0xc,%esp
1182bb: 8d 42 10 lea 0x10(%edx),%eax
1182be: 50 push %eax
1182bf: 89 55 d4 mov %edx,-0x2c(%ebp)
1182c2: e8 ad 40 00 00 call 11c374 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
1182c7: 8b 55 d4 mov -0x2c(%ebp),%edx
1182ca: c7 42 38 03 00 00 00 movl $0x3,0x38(%edx)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
1182d1: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
1182d8: 89 72 2c mov %esi,0x2c(%edx)
the_watchdog->id = id;
1182db: 8b 45 08 mov 0x8(%ebp),%eax
1182de: 89 42 30 mov %eax,0x30(%edx)
the_watchdog->user_data = user_data;
1182e1: 8b 45 14 mov 0x14(%ebp),%eax
1182e4: 89 42 34 mov %eax,0x34(%edx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
1182e7: 2b 3d 88 09 14 00 sub 0x140988,%edi
1182ed: 89 7a 1c mov %edi,0x1c(%edx)
(*timer_server->schedule_operation)( timer_server, the_timer );
1182f0: 58 pop %eax
1182f1: 59 pop %ecx
1182f2: 52 push %edx
1182f3: 53 push %ebx
1182f4: ff 53 04 call *0x4(%ebx)
_Thread_Enable_dispatch();
1182f7: e8 18 30 00 00 call 11b314 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1182fc: 83 c4 10 add $0x10,%esp
1182ff: 31 c0 xor %eax,%eax
118301: e9 75 ff ff ff jmp 11827b <rtems_timer_server_fire_when+0x47>
118306: 66 90 xchg %ax,%ax
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
118308: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11830d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
118310: 5b pop %ebx <== NOT EXECUTED
118311: 5e pop %esi <== NOT EXECUTED
118312: 5f pop %edi <== NOT EXECUTED
118313: c9 leave <== NOT EXECUTED
118314: c3 ret <== NOT EXECUTED
118315: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
118318: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11831d: 8d 65 f4 lea -0xc(%ebp),%esp
118320: 5b pop %ebx
118321: 5e pop %esi
118322: 5f pop %edi
118323: c9 leave
118324: c3 ret
118325: 8d 76 00 lea 0x0(%esi),%esi
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
118328: b8 0e 00 00 00 mov $0xe,%eax
11832d: e9 49 ff ff ff jmp 11827b <rtems_timer_server_fire_when+0x47>
118332: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118334: b8 04 00 00 00 mov $0x4,%eax
118339: e9 3d ff ff ff jmp 11827b <rtems_timer_server_fire_when+0x47>
0010bc70 <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
10bc70: 55 push %ebp
10bc71: 89 e5 mov %esp,%ebp
10bc73: 57 push %edi
10bc74: 56 push %esi
10bc75: 53 push %ebx
10bc76: 83 ec 1c sub $0x1c,%esp
10bc79: 89 c3 mov %eax,%ebx
10bc7b: 89 d6 mov %edx,%esi
10bc7d: 89 cf mov %ecx,%edi
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
10bc7f: a9 00 00 00 20 test $0x20000000,%eax
10bc84: 74 2b je 10bcb1 <rtems_verror+0x41>
if (rtems_panic_in_progress++)
10bc86: 8b 15 80 c4 12 00 mov 0x12c480,%edx
10bc8c: 8d 42 01 lea 0x1(%edx),%eax
10bc8f: a3 80 c4 12 00 mov %eax,0x12c480
10bc94: 85 d2 test %edx,%edx
10bc96: 74 10 je 10bca8 <rtems_verror+0x38> <== ALWAYS TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10bc98: a1 ec c5 12 00 mov 0x12c5ec,%eax <== NOT EXECUTED
10bc9d: 40 inc %eax <== NOT EXECUTED
10bc9e: a3 ec c5 12 00 mov %eax,0x12c5ec <== NOT EXECUTED
RTEMS_COMPILER_MEMORY_BARRIER();
10bca3: a1 80 c4 12 00 mov 0x12c480,%eax <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
10bca8: 83 f8 02 cmp $0x2,%eax
10bcab: 0f 8f af 00 00 00 jg 10bd60 <rtems_verror+0xf0> <== NEVER TAKEN
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
10bcb1: 83 ec 0c sub $0xc,%esp
10bcb4: a1 60 a2 12 00 mov 0x12a260,%eax
10bcb9: ff 70 08 pushl 0x8(%eax)
10bcbc: e8 fb b5 00 00 call 1172bc <fflush>
status = error_flag & ~RTEMS_ERROR_MASK;
10bcc1: 89 d8 mov %ebx,%eax
10bcc3: 25 ff ff ff 8f and $0x8fffffff,%eax
10bcc8: 89 45 e4 mov %eax,-0x1c(%ebp)
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
10bccb: 83 c4 10 add $0x10,%esp
10bcce: 81 e3 00 00 00 40 and $0x40000000,%ebx
10bcd4: 0f 85 be 00 00 00 jne 10bd98 <rtems_verror+0x128>
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
int local_errno = 0;
10bcda: 31 db xor %ebx,%ebx
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
10bcdc: 50 push %eax
10bcdd: 57 push %edi
10bcde: 56 push %esi
10bcdf: a1 60 a2 12 00 mov 0x12a260,%eax
10bce4: ff 70 0c pushl 0xc(%eax)
10bce7: e8 88 1a 01 00 call 11d774 <vfprintf>
10bcec: 89 c6 mov %eax,%esi
if (status)
10bcee: 83 c4 10 add $0x10,%esp
10bcf1: 8b 4d e4 mov -0x1c(%ebp),%ecx
10bcf4: 85 c9 test %ecx,%ecx
10bcf6: 75 74 jne 10bd6c <rtems_verror+0xfc>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
10bcf8: 83 fb 00 cmp $0x0,%ebx
10bcfb: 74 30 je 10bd2d <rtems_verror+0xbd>
if ((local_errno > 0) && *strerror(local_errno))
10bcfd: 7e 15 jle 10bd14 <rtems_verror+0xa4>
10bcff: 83 ec 0c sub $0xc,%esp
10bd02: 53 push %ebx
10bd03: e8 f4 c1 00 00 call 117efc <strerror>
10bd08: 83 c4 10 add $0x10,%esp
10bd0b: 80 38 00 cmpb $0x0,(%eax)
10bd0e: 0f 85 90 00 00 00 jne 10bda4 <rtems_verror+0x134> <== ALWAYS TAKEN
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
10bd14: 52 push %edx
10bd15: 53 push %ebx
10bd16: 68 89 57 12 00 push $0x125789
10bd1b: a1 60 a2 12 00 mov 0x12a260,%eax
10bd20: ff 70 0c pushl 0xc(%eax)
10bd23: e8 88 b9 00 00 call 1176b0 <fprintf>
10bd28: 01 c6 add %eax,%esi
10bd2a: 83 c4 10 add $0x10,%esp
}
chars_written += fprintf(stderr, "\n");
10bd2d: 83 ec 08 sub $0x8,%esp
10bd30: 68 cd 52 12 00 push $0x1252cd
10bd35: a1 60 a2 12 00 mov 0x12a260,%eax
10bd3a: ff 70 0c pushl 0xc(%eax)
10bd3d: e8 6e b9 00 00 call 1176b0 <fprintf>
10bd42: 8d 34 30 lea (%eax,%esi,1),%esi
(void) fflush(stderr);
10bd45: 58 pop %eax
10bd46: a1 60 a2 12 00 mov 0x12a260,%eax
10bd4b: ff 70 0c pushl 0xc(%eax)
10bd4e: e8 69 b5 00 00 call 1172bc <fflush>
return chars_written;
10bd53: 83 c4 10 add $0x10,%esp
}
10bd56: 89 f0 mov %esi,%eax
10bd58: 8d 65 f4 lea -0xc(%ebp),%esp
10bd5b: 5b pop %ebx
10bd5c: 5e pop %esi
10bd5d: 5f pop %edi
10bd5e: c9 leave
10bd5f: c3 ret
if (rtems_panic_in_progress++)
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
10bd60: 31 f6 xor %esi,%esi
chars_written += fprintf(stderr, "\n");
(void) fflush(stderr);
return chars_written;
}
10bd62: 89 f0 mov %esi,%eax <== NOT EXECUTED
10bd64: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10bd67: 5b pop %ebx <== NOT EXECUTED
10bd68: 5e pop %esi <== NOT EXECUTED
10bd69: 5f pop %edi <== NOT EXECUTED
10bd6a: c9 leave <== NOT EXECUTED
10bd6b: c3 ret <== NOT EXECUTED
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
10bd6c: 83 ec 0c sub $0xc,%esp
10bd6f: ff 75 e4 pushl -0x1c(%ebp)
10bd72: e8 e1 fe ff ff call 10bc58 <rtems_status_text>
10bd77: 83 c4 0c add $0xc,%esp
10bd7a: 50 push %eax
10bd7b: 68 6e 57 12 00 push $0x12576e
10bd80: a1 60 a2 12 00 mov 0x12a260,%eax
10bd85: ff 70 0c pushl 0xc(%eax)
10bd88: e8 23 b9 00 00 call 1176b0 <fprintf>
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
10bd8d: 01 c6 add %eax,%esi
10bd8f: 83 c4 10 add $0x10,%esp
10bd92: e9 61 ff ff ff jmp 10bcf8 <rtems_verror+0x88>
10bd97: 90 nop
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
local_errno = errno;
10bd98: e8 87 b1 00 00 call 116f24 <__errno>
10bd9d: 8b 18 mov (%eax),%ebx
10bd9f: e9 38 ff ff ff jmp 10bcdc <rtems_verror+0x6c>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
if ((local_errno > 0) && *strerror(local_errno))
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
10bda4: 83 ec 0c sub $0xc,%esp
10bda7: 53 push %ebx
10bda8: e8 4f c1 00 00 call 117efc <strerror>
10bdad: 83 c4 0c add $0xc,%esp
10bdb0: 50 push %eax
10bdb1: 68 7c 57 12 00 push $0x12577c
10bdb6: e9 60 ff ff ff jmp 10bd1b <rtems_verror+0xab>
00107c34 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
107c34: 55 push %ebp
107c35: 89 e5 mov %esp,%ebp
107c37: 57 push %edi
107c38: 56 push %esi
107c39: 53 push %ebx
107c3a: 83 ec 1c sub $0x1c,%esp
107c3d: 89 c6 mov %eax,%esi
107c3f: 89 55 e0 mov %edx,-0x20(%ebp)
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
int sign = 0;
107c42: 31 ff xor %edi,%edi
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
107c44: c7 45 e4 ff ff ff 7f movl $0x7fffffff,-0x1c(%ebp)
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
107c4b: 31 db xor %ebx,%ebx
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
107c4d: 8b 46 04 mov 0x4(%esi),%eax
107c50: 48 dec %eax
107c51: 89 46 04 mov %eax,0x4(%esi)
107c54: 85 c0 test %eax,%eax
107c56: 78 52 js 107caa <scanInt+0x76> <== NEVER TAKEN
107c58: 8b 06 mov (%esi),%eax
107c5a: 0f b6 08 movzbl (%eax),%ecx
107c5d: 40 inc %eax
107c5e: 89 06 mov %eax,(%esi)
if (c == ':')
107c60: 83 f9 3a cmp $0x3a,%ecx
107c63: 74 5f je 107cc4 <scanInt+0x90>
break;
if (sign == 0) {
107c65: 85 ff test %edi,%edi
107c67: 75 0e jne 107c77 <scanInt+0x43>
if (c == '-') {
107c69: 83 f9 2d cmp $0x2d,%ecx
107c6c: 0f 84 8a 00 00 00 je 107cfc <scanInt+0xc8>
sign = -1;
limit++;
continue;
}
sign = 1;
107c72: bf 01 00 00 00 mov $0x1,%edi
}
if (!isdigit(c))
107c77: a1 b4 51 12 00 mov 0x1251b4,%eax
107c7c: f6 44 08 01 04 testb $0x4,0x1(%eax,%ecx,1)
107c81: 74 6d je 107cf0 <scanInt+0xbc>
return 0;
d = c - '0';
if ((i > (limit / 10))
107c83: b8 cd cc cc cc mov $0xcccccccd,%eax
107c88: f7 65 e4 mull -0x1c(%ebp)
107c8b: c1 ea 03 shr $0x3,%edx
107c8e: 39 d3 cmp %edx,%ebx
107c90: 77 5e ja 107cf0 <scanInt+0xbc>
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
107c92: 83 e9 30 sub $0x30,%ecx
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
107c95: 39 d3 cmp %edx,%ebx
107c97: 74 47 je 107ce0 <scanInt+0xac>
return 0;
i = i * 10 + d;
107c99: 8d 04 9b lea (%ebx,%ebx,4),%eax
107c9c: 8d 1c 41 lea (%ecx,%eax,2),%ebx
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
107c9f: 8b 46 04 mov 0x4(%esi),%eax
107ca2: 48 dec %eax
107ca3: 89 46 04 mov %eax,0x4(%esi)
107ca6: 85 c0 test %eax,%eax
107ca8: 79 ae jns 107c58 <scanInt+0x24> <== ALWAYS TAKEN
107caa: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
107cad: 56 push %esi <== NOT EXECUTED
107cae: ff 35 c0 51 12 00 pushl 0x1251c0 <== NOT EXECUTED
107cb4: e8 0f c3 00 00 call 113fc8 <__srget_r> <== NOT EXECUTED
107cb9: 89 c1 mov %eax,%ecx <== NOT EXECUTED
107cbb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if (c == ':')
107cbe: 83 f9 3a cmp $0x3a,%ecx <== NOT EXECUTED
107cc1: 75 a2 jne 107c65 <scanInt+0x31> <== NOT EXECUTED
107cc3: 90 nop <== NOT EXECUTED
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
107cc4: 85 ff test %edi,%edi
107cc6: 74 28 je 107cf0 <scanInt+0xbc> <== NEVER TAKEN
return 0;
*val = i * sign;
107cc8: 0f af df imul %edi,%ebx
107ccb: 8b 45 e0 mov -0x20(%ebp),%eax
107cce: 89 18 mov %ebx,(%eax)
return 1;
107cd0: b8 01 00 00 00 mov $0x1,%eax
}
107cd5: 8d 65 f4 lea -0xc(%ebp),%esp
107cd8: 5b pop %ebx
107cd9: 5e pop %esi
107cda: 5f pop %edi
107cdb: c9 leave
107cdc: c3 ret
107cdd: 8d 76 00 lea 0x0(%esi),%esi
}
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
107ce0: 8d 04 9b lea (%ebx,%ebx,4),%eax
107ce3: d1 e0 shl %eax
107ce5: 8b 55 e4 mov -0x1c(%ebp),%edx
107ce8: 29 c2 sub %eax,%edx
107cea: 39 d1 cmp %edx,%ecx
107cec: 76 ab jbe 107c99 <scanInt+0x65> <== NEVER TAKEN
107cee: 66 90 xchg %ax,%ax
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
107cf0: 31 c0 xor %eax,%eax
*val = i * sign;
return 1;
}
107cf2: 8d 65 f4 lea -0xc(%ebp),%esp
107cf5: 5b pop %ebx
107cf6: 5e pop %esi
107cf7: 5f pop %edi
107cf8: c9 leave
107cf9: c3 ret
107cfa: 66 90 xchg %ax,%ax
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
limit++;
107cfc: ff 45 e4 incl -0x1c(%ebp)
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
107cff: bf ff ff ff ff mov $0xffffffff,%edi
limit++;
continue;
107d04: e9 44 ff ff ff jmp 107c4d <scanInt+0x19>
00107d0c <scanString>:
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
107d0c: 55 push %ebp
107d0d: 89 e5 mov %esp,%ebp
107d0f: 57 push %edi
107d10: 56 push %esi
107d11: 53 push %ebx
107d12: 83 ec 0c sub $0xc,%esp
107d15: 89 c3 mov %eax,%ebx
107d17: 89 ce mov %ecx,%esi
107d19: 8b 7d 08 mov 0x8(%ebp),%edi
int c;
*name = *bufp;
107d1c: 8b 01 mov (%ecx),%eax
107d1e: 89 02 mov %eax,(%edx)
107d20: eb 26 jmp 107d48 <scanString+0x3c>
107d22: 66 90 xchg %ax,%ax
for (;;) {
c = getc(fp);
107d24: 8b 13 mov (%ebx),%edx
107d26: 0f b6 02 movzbl (%edx),%eax
107d29: 42 inc %edx
107d2a: 89 13 mov %edx,(%ebx)
if (c == ':') {
107d2c: 83 f8 3a cmp $0x3a,%eax
107d2f: 74 3b je 107d6c <scanString+0x60>
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
107d31: 83 f8 0a cmp $0xa,%eax
107d34: 74 56 je 107d8c <scanString+0x80>
if (!nlFlag)
return 0;
break;
}
if (c == EOF)
107d36: 83 f8 ff cmp $0xffffffff,%eax
107d39: 74 59 je 107d94 <scanString+0x88>
return 0;
if (*nleft < 2)
107d3b: 83 3f 01 cmpl $0x1,(%edi)
107d3e: 76 54 jbe 107d94 <scanString+0x88>
return 0;
**bufp = c;
107d40: 8b 16 mov (%esi),%edx
107d42: 88 02 mov %al,(%edx)
++(*bufp);
107d44: ff 06 incl (%esi)
--(*nleft);
107d46: ff 0f decl (%edi)
{
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
107d48: 8b 43 04 mov 0x4(%ebx),%eax
107d4b: 48 dec %eax
107d4c: 89 43 04 mov %eax,0x4(%ebx)
107d4f: 85 c0 test %eax,%eax
107d51: 79 d1 jns 107d24 <scanString+0x18>
107d53: 83 ec 08 sub $0x8,%esp
107d56: 53 push %ebx
107d57: ff 35 c0 51 12 00 pushl 0x1251c0
107d5d: e8 66 c2 00 00 call 113fc8 <__srget_r>
107d62: 83 c4 10 add $0x10,%esp
if (c == ':') {
107d65: 83 f8 3a cmp $0x3a,%eax
107d68: 75 c7 jne 107d31 <scanString+0x25> <== ALWAYS TAKEN
107d6a: 66 90 xchg %ax,%ax
if (nlFlag)
107d6c: 8b 55 0c mov 0xc(%ebp),%edx
107d6f: 85 d2 test %edx,%edx
107d71: 75 21 jne 107d94 <scanString+0x88>
return 0;
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
107d73: 8b 06 mov (%esi),%eax
107d75: c6 00 00 movb $0x0,(%eax)
++(*bufp);
107d78: ff 06 incl (%esi)
--(*nleft);
107d7a: ff 0f decl (%edi)
return 1;
107d7c: b8 01 00 00 00 mov $0x1,%eax
}
107d81: 8d 65 f4 lea -0xc(%ebp),%esp
107d84: 5b pop %ebx
107d85: 5e pop %esi
107d86: 5f pop %edi
107d87: c9 leave
107d88: c3 ret
107d89: 8d 76 00 lea 0x0(%esi),%esi
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
if (!nlFlag)
107d8c: 8b 45 0c mov 0xc(%ebp),%eax
107d8f: 85 c0 test %eax,%eax
107d91: 75 e0 jne 107d73 <scanString+0x67>
107d93: 90 nop
break;
}
if (c == EOF)
return 0;
if (*nleft < 2)
return 0;
107d94: 31 c0 xor %eax,%eax
}
**bufp = '\0';
++(*bufp);
--(*nleft);
return 1;
}
107d96: 8d 65 f4 lea -0xc(%ebp),%esp
107d99: 5b pop %ebx
107d9a: 5e pop %esi
107d9b: 5f pop %edi
107d9c: c9 leave
107d9d: c3 ret
00107da0 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
107da0: 55 push %ebp
107da1: 89 e5 mov %esp,%ebp
107da3: 57 push %edi
107da4: 56 push %esi
107da5: 53 push %ebx
107da6: 83 ec 34 sub $0x34,%esp
107da9: 89 c6 mov %eax,%esi
107dab: 89 d3 mov %edx,%ebx
107dad: 89 4d d4 mov %ecx,-0x2c(%ebp)
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
107db0: 8d 7d d4 lea -0x2c(%ebp),%edi
107db3: 6a 00 push $0x0
107db5: 8d 45 08 lea 0x8(%ebp),%eax
107db8: 50 push %eax
107db9: 89 f9 mov %edi,%ecx
107dbb: 89 f0 mov %esi,%eax
107dbd: e8 4a ff ff ff call 107d0c <scanString>
107dc2: 83 c4 10 add $0x10,%esp
107dc5: 85 c0 test %eax,%eax
107dc7: 75 0b jne 107dd4 <scangr+0x34>
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
return 0;
107dc9: 31 c0 xor %eax,%eax
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
return 1;
}
107dcb: 8d 65 f4 lea -0xc(%ebp),%esp
107dce: 5b pop %ebx
107dcf: 5e pop %esi
107dd0: 5f pop %edi
107dd1: c9 leave
107dd2: c3 ret
107dd3: 90 nop
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
107dd4: 83 ec 08 sub $0x8,%esp
107dd7: 8d 53 04 lea 0x4(%ebx),%edx
107dda: 6a 00 push $0x0
107ddc: 8d 45 08 lea 0x8(%ebp),%eax
107ddf: 50 push %eax
107de0: 89 f9 mov %edi,%ecx
107de2: 89 f0 mov %esi,%eax
107de4: e8 23 ff ff ff call 107d0c <scanString>
107de9: 83 c4 10 add $0x10,%esp
107dec: 85 c0 test %eax,%eax
107dee: 74 d9 je 107dc9 <scangr+0x29> <== NEVER TAKEN
|| !scanInt(fp, &grgid)
107df0: 8d 55 e4 lea -0x1c(%ebp),%edx
107df3: 89 f0 mov %esi,%eax
107df5: e8 3a fe ff ff call 107c34 <scanInt>
107dfa: 85 c0 test %eax,%eax
107dfc: 74 cb je 107dc9 <scangr+0x29> <== NEVER TAKEN
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
107dfe: 83 ec 08 sub $0x8,%esp
107e01: 8d 55 e0 lea -0x20(%ebp),%edx
107e04: 6a 01 push $0x1
107e06: 8d 45 08 lea 0x8(%ebp),%eax
107e09: 50 push %eax
107e0a: 89 f9 mov %edi,%ecx
107e0c: 89 f0 mov %esi,%eax
107e0e: e8 f9 fe ff ff call 107d0c <scanString>
107e13: 83 c4 10 add $0x10,%esp
107e16: 85 c0 test %eax,%eax
107e18: 74 af je 107dc9 <scangr+0x29> <== NEVER TAKEN
return 0;
grp->gr_gid = grgid;
107e1a: 8b 45 e4 mov -0x1c(%ebp),%eax
107e1d: 66 89 43 08 mov %ax,0x8(%ebx)
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107e21: 8b 7d e0 mov -0x20(%ebp),%edi
107e24: 8a 07 mov (%edi),%al
107e26: 84 c0 test %al,%al
107e28: 74 7d je 107ea7 <scangr+0x107> <== NEVER TAKEN
107e2a: 89 fa mov %edi,%edx
107e2c: b9 01 00 00 00 mov $0x1,%ecx
107e31: eb 08 jmp 107e3b <scangr+0x9b>
107e33: 90 nop
107e34: 42 inc %edx
107e35: 8a 02 mov (%edx),%al
107e37: 84 c0 test %al,%al
107e39: 74 09 je 107e44 <scangr+0xa4>
if(*cp == ',')
107e3b: 3c 2c cmp $0x2c,%al
107e3d: 75 f5 jne 107e34 <scangr+0x94>
memcount++;
107e3f: 41 inc %ecx
107e40: eb f2 jmp 107e34 <scangr+0x94>
107e42: 66 90 xchg %ax,%ax
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107e44: 8d 04 8d 13 00 00 00 lea 0x13(,%ecx,4),%eax
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
107e4b: 39 45 08 cmp %eax,0x8(%ebp)
107e4e: 0f 82 75 ff ff ff jb 107dc9 <scangr+0x29> <== NEVER TAKEN
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
107e54: 8b 75 d4 mov -0x2c(%ebp),%esi
107e57: 83 c6 0f add $0xf,%esi
107e5a: 83 e6 f0 and $0xfffffff0,%esi
107e5d: 89 73 0c mov %esi,0xc(%ebx)
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
107e60: 89 3e mov %edi,(%esi)
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107e62: 8b 45 e0 mov -0x20(%ebp),%eax
107e65: 8a 10 mov (%eax),%dl
107e67: 84 d2 test %dl,%dl
107e69: 74 43 je 107eae <scangr+0x10e> <== NEVER TAKEN
}
/*
* Extract a single group record from the database
*/
static int scangr(
107e6b: 40 inc %eax
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107e6c: b9 01 00 00 00 mov $0x1,%ecx
107e71: eb 08 jmp 107e7b <scangr+0xdb>
107e73: 90 nop
107e74: 8a 10 mov (%eax),%dl
107e76: 40 inc %eax
107e77: 84 d2 test %dl,%dl
107e79: 74 15 je 107e90 <scangr+0xf0>
if(*cp == ',') {
107e7b: 80 fa 2c cmp $0x2c,%dl
107e7e: 75 f4 jne 107e74 <scangr+0xd4>
*cp = '\0';
107e80: c6 40 ff 00 movb $0x0,-0x1(%eax)
grp->gr_mem[memcount++] = cp + 1;
107e84: 8b 53 0c mov 0xc(%ebx),%edx
107e87: 89 04 8a mov %eax,(%edx,%ecx,4)
107e8a: 41 inc %ecx
107e8b: eb e7 jmp 107e74 <scangr+0xd4>
107e8d: 8d 76 00 lea 0x0(%esi),%esi
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107e90: 8b 73 0c mov 0xc(%ebx),%esi
107e93: c1 e1 02 shl $0x2,%ecx
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
107e96: c7 04 0e 00 00 00 00 movl $0x0,(%esi,%ecx,1)
return 1;
107e9d: b8 01 00 00 00 mov $0x1,%eax
107ea2: e9 24 ff ff ff jmp 107dcb <scangr+0x2b>
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107ea7: b8 17 00 00 00 mov $0x17,%eax <== NOT EXECUTED
107eac: eb 9d jmp 107e4b <scangr+0xab> <== NOT EXECUTED
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107eae: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
107eb3: eb e1 jmp 107e96 <scangr+0xf6> <== NOT EXECUTED
00107eb8 <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
107eb8: 55 push %ebp
107eb9: 89 e5 mov %esp,%ebp
107ebb: 57 push %edi
107ebc: 56 push %esi
107ebd: 53 push %ebx
107ebe: 83 ec 34 sub $0x34,%esp
107ec1: 89 c6 mov %eax,%esi
107ec3: 89 d3 mov %edx,%ebx
107ec5: 89 4d d4 mov %ecx,-0x2c(%ebp)
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
107ec8: 8d 7d d4 lea -0x2c(%ebp),%edi
107ecb: 6a 00 push $0x0
107ecd: 8d 45 08 lea 0x8(%ebp),%eax
107ed0: 50 push %eax
107ed1: 89 f9 mov %edi,%ecx
107ed3: 89 f0 mov %esi,%eax
107ed5: e8 32 fe ff ff call 107d0c <scanString>
107eda: 83 c4 10 add $0x10,%esp
107edd: 85 c0 test %eax,%eax
107edf: 75 0b jne 107eec <scanpw+0x34>
|| !scanInt(fp, &pwgid)
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
107ee1: 31 c0 xor %eax,%eax
pwd->pw_uid = pwuid;
pwd->pw_gid = pwgid;
return 1;
}
107ee3: 8d 65 f4 lea -0xc(%ebp),%esp
107ee6: 5b pop %ebx
107ee7: 5e pop %esi
107ee8: 5f pop %edi
107ee9: c9 leave
107eea: c3 ret
107eeb: 90 nop
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
107eec: 83 ec 08 sub $0x8,%esp
107eef: 8d 53 04 lea 0x4(%ebx),%edx
107ef2: 6a 00 push $0x0
107ef4: 8d 45 08 lea 0x8(%ebp),%eax
107ef7: 50 push %eax
107ef8: 89 f9 mov %edi,%ecx
107efa: 89 f0 mov %esi,%eax
107efc: e8 0b fe ff ff call 107d0c <scanString>
107f01: 83 c4 10 add $0x10,%esp
107f04: 85 c0 test %eax,%eax
107f06: 74 d9 je 107ee1 <scanpw+0x29> <== NEVER TAKEN
|| !scanInt(fp, &pwuid)
107f08: 8d 55 e4 lea -0x1c(%ebp),%edx
107f0b: 89 f0 mov %esi,%eax
107f0d: e8 22 fd ff ff call 107c34 <scanInt>
107f12: 85 c0 test %eax,%eax
107f14: 74 cb je 107ee1 <scanpw+0x29>
|| !scanInt(fp, &pwgid)
107f16: 8d 55 e0 lea -0x20(%ebp),%edx
107f19: 89 f0 mov %esi,%eax
107f1b: e8 14 fd ff ff call 107c34 <scanInt>
107f20: 85 c0 test %eax,%eax
107f22: 74 bd je 107ee1 <scanpw+0x29>
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
107f24: 83 ec 08 sub $0x8,%esp
107f27: 8d 53 0c lea 0xc(%ebx),%edx
107f2a: 6a 00 push $0x0
107f2c: 8d 45 08 lea 0x8(%ebp),%eax
107f2f: 50 push %eax
107f30: 89 f9 mov %edi,%ecx
107f32: 89 f0 mov %esi,%eax
107f34: e8 d3 fd ff ff call 107d0c <scanString>
107f39: 83 c4 10 add $0x10,%esp
107f3c: 85 c0 test %eax,%eax
107f3e: 74 a1 je 107ee1 <scanpw+0x29> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
107f40: 83 ec 08 sub $0x8,%esp
107f43: 8d 53 10 lea 0x10(%ebx),%edx
107f46: 6a 00 push $0x0
107f48: 8d 45 08 lea 0x8(%ebp),%eax
107f4b: 50 push %eax
107f4c: 89 f9 mov %edi,%ecx
107f4e: 89 f0 mov %esi,%eax
107f50: e8 b7 fd ff ff call 107d0c <scanString>
107f55: 83 c4 10 add $0x10,%esp
107f58: 85 c0 test %eax,%eax
107f5a: 74 85 je 107ee1 <scanpw+0x29> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
107f5c: 83 ec 08 sub $0x8,%esp
107f5f: 8d 53 14 lea 0x14(%ebx),%edx
107f62: 6a 00 push $0x0
107f64: 8d 45 08 lea 0x8(%ebp),%eax
107f67: 50 push %eax
107f68: 89 f9 mov %edi,%ecx
107f6a: 89 f0 mov %esi,%eax
107f6c: e8 9b fd ff ff call 107d0c <scanString>
107f71: 83 c4 10 add $0x10,%esp
107f74: 85 c0 test %eax,%eax
107f76: 0f 84 65 ff ff ff je 107ee1 <scanpw+0x29> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
107f7c: 83 ec 08 sub $0x8,%esp
107f7f: 8d 53 18 lea 0x18(%ebx),%edx
107f82: 6a 01 push $0x1
107f84: 8d 45 08 lea 0x8(%ebp),%eax
107f87: 50 push %eax
107f88: 89 f9 mov %edi,%ecx
107f8a: 89 f0 mov %esi,%eax
107f8c: e8 7b fd ff ff call 107d0c <scanString>
107f91: 83 c4 10 add $0x10,%esp
107f94: 85 c0 test %eax,%eax
107f96: 0f 84 45 ff ff ff je 107ee1 <scanpw+0x29>
return 0;
pwd->pw_uid = pwuid;
107f9c: 8b 45 e4 mov -0x1c(%ebp),%eax
107f9f: 66 89 43 08 mov %ax,0x8(%ebx)
pwd->pw_gid = pwgid;
107fa3: 8b 45 e0 mov -0x20(%ebp),%eax
107fa6: 66 89 43 0a mov %ax,0xa(%ebx)
return 1;
107faa: b8 01 00 00 00 mov $0x1,%eax
107faf: e9 2f ff ff ff jmp 107ee3 <scanpw+0x2b>
00109660 <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
109660: 55 push %ebp
109661: 89 e5 mov %esp,%ebp
109663: 56 push %esi
109664: 53 push %ebx
109665: 89 d3 mov %edx,%ebx
109667: 89 c6 mov %eax,%esi
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
109669: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx)
109670: 75 12 jne 109684 <siproc+0x24> <== ALWAYS TAKEN
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
109672: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
109675: 89 da mov %ebx,%edx <== NOT EXECUTED
}
return i;
}
109677: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10967a: 5b pop %ebx <== NOT EXECUTED
10967b: 5e pop %esi <== NOT EXECUTED
10967c: c9 leave <== NOT EXECUTED
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
10967d: e9 92 fe ff ff jmp 109514 <iproc> <== NOT EXECUTED
109682: 66 90 xchg %ax,%ax <== NOT EXECUTED
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
109684: 52 push %edx
109685: 6a 00 push $0x0
109687: 6a 00 push $0x0
109689: ff 73 18 pushl 0x18(%ebx)
10968c: e8 17 15 00 00 call 10aba8 <rtems_semaphore_obtain>
i = iproc (c, tty);
109691: 89 f2 mov %esi,%edx
109693: 0f b6 c2 movzbl %dl,%eax
109696: 89 da mov %ebx,%edx
109698: e8 77 fe ff ff call 109514 <iproc>
10969d: 89 c6 mov %eax,%esi
rtems_semaphore_release (tty->osem);
10969f: 58 pop %eax
1096a0: ff 73 18 pushl 0x18(%ebx)
1096a3: e8 fc 15 00 00 call 10aca4 <rtems_semaphore_release>
1096a8: 83 c4 10 add $0x10,%esp
}
else {
i = iproc (c, tty);
}
return i;
}
1096ab: 89 f0 mov %esi,%eax
1096ad: 8d 65 f8 lea -0x8(%ebp),%esp
1096b0: 5b pop %ebx
1096b1: 5e pop %esi
1096b2: c9 leave
1096b3: c3 ret
00108464 <stat>:
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
108464: 55 push %ebp
108465: 89 e5 mov %esp,%ebp
108467: 57 push %edi
108468: 56 push %esi
108469: 53 push %ebx
10846a: 83 ec 3c sub $0x3c,%esp
10846d: 8b 55 08 mov 0x8(%ebp),%edx
108470: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
108473: 85 f6 test %esi,%esi
108475: 74 65 je 1084dc <stat+0x78>
rtems_set_errno_and_return_minus_one( EFAULT );
status = rtems_filesystem_evaluate_path( path, strlen( path ),
108477: b9 ff ff ff ff mov $0xffffffff,%ecx
10847c: 89 d7 mov %edx,%edi
10847e: 31 c0 xor %eax,%eax
108480: f2 ae repnz scas %es:(%edi),%al
108482: f7 d1 not %ecx
108484: 49 dec %ecx
108485: 83 ec 0c sub $0xc,%esp
108488: 6a 01 push $0x1
10848a: 8d 5d d4 lea -0x2c(%ebp),%ebx
10848d: 53 push %ebx
10848e: 6a 00 push $0x0
108490: 51 push %ecx
108491: 52 push %edx
108492: e8 1d f1 ff ff call 1075b4 <rtems_filesystem_evaluate_path>
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
108497: 83 c4 20 add $0x20,%esp
10849a: 85 c0 test %eax,%eax
10849c: 74 0e je 1084ac <stat+0x48>
return -1;
10849e: b8 ff ff ff ff mov $0xffffffff,%eax
status = (*loc.handlers->fstat_h)( &loc, buf );
rtems_filesystem_freenode( &loc );
return status;
}
1084a3: 8d 65 f4 lea -0xc(%ebp),%esp
1084a6: 5b pop %ebx
1084a7: 5e pop %esi
1084a8: 5f pop %edi
1084a9: c9 leave
1084aa: c3 ret
1084ab: 90 nop
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
1084ac: b9 48 00 00 00 mov $0x48,%ecx
1084b1: 89 f7 mov %esi,%edi
1084b3: f3 aa rep stos %al,%es:(%edi)
status = (*loc.handlers->fstat_h)( &loc, buf );
1084b5: 83 ec 08 sub $0x8,%esp
1084b8: 56 push %esi
1084b9: 53 push %ebx
1084ba: 8b 45 dc mov -0x24(%ebp),%eax
1084bd: ff 50 18 call *0x18(%eax)
rtems_filesystem_freenode( &loc );
1084c0: 89 1c 24 mov %ebx,(%esp)
1084c3: 89 45 c4 mov %eax,-0x3c(%ebp)
1084c6: e8 c1 f1 ff ff call 10768c <rtems_filesystem_freenode>
return status;
1084cb: 83 c4 10 add $0x10,%esp
1084ce: 8b 45 c4 mov -0x3c(%ebp),%eax
}
1084d1: 8d 65 f4 lea -0xc(%ebp),%esp
1084d4: 5b pop %ebx
1084d5: 5e pop %esi
1084d6: 5f pop %edi
1084d7: c9 leave
1084d8: c3 ret
1084d9: 8d 76 00 lea 0x0(%esi),%esi
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
rtems_set_errno_and_return_minus_one( EFAULT );
1084dc: e8 5b 7d 00 00 call 11023c <__errno>
1084e1: c7 00 0e 00 00 00 movl $0xe,(%eax)
1084e7: b8 ff ff ff ff mov $0xffffffff,%eax
status = (*loc.handlers->fstat_h)( &loc, buf );
rtems_filesystem_freenode( &loc );
return status;
}
1084ec: 8d 65 f4 lea -0xc(%ebp),%esp
1084ef: 5b pop %ebx
1084f0: 5e pop %esi
1084f1: 5f pop %edi
1084f2: c9 leave
1084f3: c3 ret
0010a8d4 <statvfs>:
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
10a8d4: 55 push %ebp
10a8d5: 89 e5 mov %esp,%ebp
10a8d7: 57 push %edi
10a8d8: 56 push %esi
10a8d9: 53 push %ebx
10a8da: 83 ec 48 sub $0x48,%esp
10a8dd: 8b 55 08 mov 0x8(%ebp),%edx
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
10a8e0: 31 f6 xor %esi,%esi
10a8e2: b9 ff ff ff ff mov $0xffffffff,%ecx
10a8e7: 89 d7 mov %edx,%edi
10a8e9: 89 f0 mov %esi,%eax
10a8eb: f2 ae repnz scas %es:(%edi),%al
10a8ed: f7 d1 not %ecx
10a8ef: 49 dec %ecx
10a8f0: 6a 01 push $0x1
10a8f2: 8d 5d d4 lea -0x2c(%ebp),%ebx
10a8f5: 53 push %ebx
10a8f6: 6a 00 push $0x0
10a8f8: 51 push %ecx
10a8f9: 52 push %edx
10a8fa: e8 85 eb ff ff call 109484 <rtems_filesystem_evaluate_path>
10a8ff: 83 c4 20 add $0x20,%esp
10a902: 85 c0 test %eax,%eax
10a904: 74 0e je 10a914 <statvfs+0x40> <== ALWAYS TAKEN
return -1;
10a906: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
rtems_filesystem_freenode( &loc );
return result;
}
10a90b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10a90e: 5b pop %ebx <== NOT EXECUTED
10a90f: 5e pop %esi <== NOT EXECUTED
10a910: 5f pop %edi <== NOT EXECUTED
10a911: c9 leave <== NOT EXECUTED
10a912: c3 ret <== NOT EXECUTED
10a913: 90 nop <== NOT EXECUTED
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
return -1;
mt_entry = loc.mt_entry;
10a914: 8b 55 e4 mov -0x1c(%ebp),%edx
fs_mount_root = &mt_entry->mt_fs_root;
memset (sb, 0, sizeof (struct statvfs));
10a917: b9 38 00 00 00 mov $0x38,%ecx
10a91c: 8b 7d 0c mov 0xc(%ebp),%edi
10a91f: 89 f0 mov %esi,%eax
10a921: f3 aa rep stos %al,%es:(%edi)
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
10a923: 83 ec 08 sub $0x8,%esp
10a926: 8b 42 28 mov 0x28(%edx),%eax
10a929: ff 75 0c pushl 0xc(%ebp)
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
return -1;
mt_entry = loc.mt_entry;
fs_mount_root = &mt_entry->mt_fs_root;
10a92c: 83 c2 1c add $0x1c,%edx
memset (sb, 0, sizeof (struct statvfs));
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
10a92f: 52 push %edx
10a930: ff 50 44 call *0x44(%eax)
rtems_filesystem_freenode( &loc );
10a933: 89 1c 24 mov %ebx,(%esp)
10a936: 89 45 c4 mov %eax,-0x3c(%ebp)
10a939: e8 1e ec ff ff call 10955c <rtems_filesystem_freenode>
return result;
10a93e: 83 c4 10 add $0x10,%esp
10a941: 8b 45 c4 mov -0x3c(%ebp),%eax
}
10a944: 8d 65 f4 lea -0xc(%ebp),%esp
10a947: 5b pop %ebx
10a948: 5e pop %esi
10a949: 5f pop %edi
10a94a: c9 leave
10a94b: c3 ret
0010a18c <symlink>:
int symlink(
const char *actualpath,
const char *sympath
)
{
10a18c: 55 push %ebp
10a18d: 89 e5 mov %esp,%ebp
10a18f: 56 push %esi
10a190: 53 push %ebx
10a191: 83 ec 34 sub $0x34,%esp
10a194: 8b 75 0c mov 0xc(%ebp),%esi
rtems_filesystem_location_info_t loc;
int i;
const char *name_start;
int result;
rtems_filesystem_get_start_loc( sympath, &i, &loc );
10a197: 8d 5d dc lea -0x24(%ebp),%ebx
10a19a: 53 push %ebx
10a19b: 8d 45 f4 lea -0xc(%ebp),%eax
10a19e: 50 push %eax
10a19f: 56 push %esi
10a1a0: e8 0f ff ff ff call 10a0b4 <rtems_filesystem_get_start_loc>
result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start );
10a1a5: 83 c4 0c add $0xc,%esp
10a1a8: 8d 45 f0 lea -0x10(%ebp),%eax
10a1ab: 50 push %eax
10a1ac: 53 push %ebx
10a1ad: 03 75 f4 add -0xc(%ebp),%esi
10a1b0: 56 push %esi
10a1b1: 8b 45 e8 mov -0x18(%ebp),%eax
10a1b4: ff 50 04 call *0x4(%eax)
if ( result != 0 )
10a1b7: 83 c4 10 add $0x10,%esp
10a1ba: 85 c0 test %eax,%eax
10a1bc: 74 0e je 10a1cc <symlink+0x40>
return -1;
10a1be: b8 ff ff ff ff mov $0xffffffff,%eax
result = (*loc.ops->symlink_h)( &loc, actualpath, name_start);
rtems_filesystem_freenode( &loc );
return result;
}
10a1c3: 8d 65 f8 lea -0x8(%ebp),%esp
10a1c6: 5b pop %ebx
10a1c7: 5e pop %esi
10a1c8: c9 leave
10a1c9: c3 ret
10a1ca: 66 90 xchg %ax,%ax
result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start );
if ( result != 0 )
return -1;
result = (*loc.ops->symlink_h)( &loc, actualpath, name_start);
10a1cc: 50 push %eax
10a1cd: ff 75 f0 pushl -0x10(%ebp)
10a1d0: ff 75 08 pushl 0x8(%ebp)
10a1d3: 53 push %ebx
10a1d4: 8b 45 e8 mov -0x18(%ebp),%eax
10a1d7: ff 50 38 call *0x38(%eax)
rtems_filesystem_freenode( &loc );
10a1da: 89 1c 24 mov %ebx,(%esp)
10a1dd: 89 45 d4 mov %eax,-0x2c(%ebp)
10a1e0: e8 67 ec ff ff call 108e4c <rtems_filesystem_freenode>
return result;
10a1e5: 83 c4 10 add $0x10,%esp
10a1e8: 8b 45 d4 mov -0x2c(%ebp),%eax
}
10a1eb: 8d 65 f8 lea -0x8(%ebp),%esp
10a1ee: 5b pop %ebx
10a1ef: 5e pop %esi
10a1f0: c9 leave
10a1f1: c3 ret
00109770 <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
109770: 55 push %ebp
109771: 89 e5 mov %esp,%ebp
109773: 53 push %ebx
109774: 83 ec 04 sub $0x4,%esp
109777: 8b 45 08 mov 0x8(%ebp),%eax
/*
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
10977a: 8b 90 e0 00 00 00 mov 0xe0(%eax),%edx
if ( this_reent ) {
109780: 85 d2 test %edx,%edx
109782: 74 33 je 1097b7 <sync_per_thread+0x47> <== NEVER TAKEN
current_reent = _Thread_Executing->libc_reent;
109784: 8b 0d d8 76 12 00 mov 0x1276d8,%ecx
10978a: 8b 99 e0 00 00 00 mov 0xe0(%ecx),%ebx
_Thread_Executing->libc_reent = this_reent;
109790: 89 91 e0 00 00 00 mov %edx,0xe0(%ecx)
_fwalk (t->libc_reent, sync_wrapper);
109796: 83 ec 08 sub $0x8,%esp
109799: 68 bc 97 10 00 push $0x1097bc
10979e: ff b0 e0 00 00 00 pushl 0xe0(%eax)
1097a4: e8 4b a6 00 00 call 113df4 <_fwalk>
_Thread_Executing->libc_reent = current_reent;
1097a9: a1 d8 76 12 00 mov 0x1276d8,%eax
1097ae: 89 98 e0 00 00 00 mov %ebx,0xe0(%eax)
1097b4: 83 c4 10 add $0x10,%esp
}
}
1097b7: 8b 5d fc mov -0x4(%ebp),%ebx
1097ba: c9 leave
1097bb: c3 ret
00110394 <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
110394: 55 push %ebp
110395: 89 e5 mov %esp,%ebp
110397: 56 push %esi
110398: 53 push %ebx
110399: 8b 5d 08 mov 0x8(%ebp),%ebx
11039c: 8b 45 0c mov 0xc(%ebp),%eax
11039f: 8b 75 10 mov 0x10(%ebp),%esi
switch (opt) {
1103a2: 85 c0 test %eax,%eax
1103a4: 74 2c je 1103d2 <tcsetattr+0x3e>
1103a6: 48 dec %eax
1103a7: 74 17 je 1103c0 <tcsetattr+0x2c>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
1103a9: e8 6a 2b 00 00 call 112f18 <__errno>
1103ae: c7 00 86 00 00 00 movl $0x86,(%eax)
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
}
}
1103b4: b8 ff ff ff ff mov $0xffffffff,%eax
1103b9: 8d 65 f8 lea -0x8(%ebp),%esp
1103bc: 5b pop %ebx
1103bd: 5e pop %esi
1103be: c9 leave
1103bf: c3 ret
switch (opt) {
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
1103c0: 50 push %eax
1103c1: 6a 00 push $0x0
1103c3: 6a 03 push $0x3
1103c5: 53 push %ebx
1103c6: e8 55 fc ff ff call 110020 <ioctl>
1103cb: 83 c4 10 add $0x10,%esp
1103ce: 85 c0 test %eax,%eax
1103d0: 78 e2 js 1103b4 <tcsetattr+0x20> <== NEVER TAKEN
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
1103d2: 89 75 10 mov %esi,0x10(%ebp)
1103d5: c7 45 0c 02 00 00 00 movl $0x2,0xc(%ebp)
1103dc: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
1103df: 8d 65 f8 lea -0x8(%ebp),%esp
1103e2: 5b pop %ebx
1103e3: 5e pop %esi
1103e4: c9 leave
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
1103e5: e9 36 fc ff ff jmp 110020 <ioctl>
0010b12c <unlink>:
#include <rtems/seterr.h>
int unlink(
const char *path
)
{
10b12c: 55 push %ebp
10b12d: 89 e5 mov %esp,%ebp
10b12f: 57 push %edi
10b130: 56 push %esi
10b131: 53 push %ebx
10b132: 83 ec 58 sub $0x58,%esp
10b135: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
10b138: 53 push %ebx
10b139: e8 16 d3 ff ff call 108454 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
10b13e: 83 c4 10 add $0x10,%esp
10b141: 85 c0 test %eax,%eax
10b143: 0f 85 d3 00 00 00 jne 10b21c <unlink+0xf0>
rtems_filesystem_get_start_loc( path, &i, &parentloc );
10b149: 50 push %eax
10b14a: 8d 45 d0 lea -0x30(%ebp),%eax
10b14d: 89 45 b4 mov %eax,-0x4c(%ebp)
10b150: 50 push %eax
10b151: 8d 45 e4 lea -0x1c(%ebp),%eax
10b154: 50 push %eax
10b155: 53 push %ebx
10b156: e8 b9 e2 ff ff call 109414 <rtems_filesystem_get_start_loc>
10b15b: 83 c4 10 add $0x10,%esp
10b15e: 31 d2 xor %edx,%edx
const char *name;
rtems_filesystem_location_info_t parentloc;
rtems_filesystem_location_info_t loc;
int i;
int result;
bool free_parentloc = false;
10b160: c6 45 b3 00 movb $0x0,-0x4d(%ebp)
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
10b164: 8d 7d bc lea -0x44(%ebp),%edi
10b167: b9 05 00 00 00 mov $0x5,%ecx
10b16c: 8b 75 b4 mov -0x4c(%ebp),%esi
10b16f: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
name = path + parentpathlen;
10b171: 01 d3 add %edx,%ebx
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
10b173: be ff ff ff ff mov $0xffffffff,%esi
10b178: 89 f1 mov %esi,%ecx
10b17a: 89 df mov %ebx,%edi
10b17c: 31 c0 xor %eax,%eax
10b17e: f2 ae repnz scas %es:(%edi),%al
10b180: f7 d1 not %ecx
10b182: 49 dec %ecx
10b183: 83 ec 08 sub $0x8,%esp
10b186: 51 push %ecx
10b187: 53 push %ebx
10b188: e8 0b d3 ff ff call 108498 <rtems_filesystem_prefix_separators>
10b18d: 01 c3 add %eax,%ebx
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
10b18f: 89 f1 mov %esi,%ecx
10b191: 89 df mov %ebx,%edi
10b193: 31 c0 xor %eax,%eax
10b195: f2 ae repnz scas %es:(%edi),%al
10b197: f7 d1 not %ecx
10b199: 49 dec %ecx
10b19a: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10b1a1: 8d 75 bc lea -0x44(%ebp),%esi
10b1a4: 56 push %esi
10b1a5: 6a 00 push $0x0
10b1a7: 51 push %ecx
10b1a8: 53 push %ebx
10b1a9: e8 fa d1 ff ff call 1083a8 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
10b1ae: 83 c4 20 add $0x20,%esp
10b1b1: 85 c0 test %eax,%eax
10b1b3: 75 53 jne 10b208 <unlink+0xdc>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
10b1b5: 83 ec 0c sub $0xc,%esp
10b1b8: 56 push %esi
10b1b9: 8b 45 c8 mov -0x38(%ebp),%eax
10b1bc: ff 50 10 call *0x10(%eax)
10b1bf: 83 c4 10 add $0x10,%esp
10b1c2: 48 dec %eax
10b1c3: 0f 84 83 00 00 00 je 10b24c <unlink+0x120>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
rtems_set_errno_and_return_minus_one( EISDIR );
}
result = (*loc.ops->unlink_h)( &parentloc, &loc );
10b1c9: 83 ec 08 sub $0x8,%esp
10b1cc: 56 push %esi
10b1cd: ff 75 b4 pushl -0x4c(%ebp)
10b1d0: 8b 45 c8 mov -0x38(%ebp),%eax
10b1d3: ff 50 0c call *0xc(%eax)
rtems_filesystem_freenode( &loc );
10b1d6: 89 34 24 mov %esi,(%esp)
10b1d9: 89 45 ac mov %eax,-0x54(%ebp)
10b1dc: e8 07 d3 ff ff call 1084e8 <rtems_filesystem_freenode>
if ( free_parentloc )
10b1e1: 83 c4 10 add $0x10,%esp
10b1e4: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp)
10b1e8: 8b 45 ac mov -0x54(%ebp),%eax
10b1eb: 74 11 je 10b1fe <unlink+0xd2>
rtems_filesystem_freenode( &parentloc );
10b1ed: 83 ec 0c sub $0xc,%esp
10b1f0: ff 75 b4 pushl -0x4c(%ebp)
10b1f3: e8 f0 d2 ff ff call 1084e8 <rtems_filesystem_freenode>
10b1f8: 83 c4 10 add $0x10,%esp
10b1fb: 8b 45 ac mov -0x54(%ebp),%eax
return result;
}
10b1fe: 8d 65 f4 lea -0xc(%ebp),%esp
10b201: 5b pop %ebx
10b202: 5e pop %esi
10b203: 5f pop %edi
10b204: c9 leave
10b205: c3 ret
10b206: 66 90 xchg %ax,%ax
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
10b208: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp)
10b20c: 75 70 jne 10b27e <unlink+0x152> <== ALWAYS TAKEN
rtems_filesystem_freenode( &parentloc );
return -1;
10b20e: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return result;
}
10b213: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10b216: 5b pop %ebx <== NOT EXECUTED
10b217: 5e pop %esi <== NOT EXECUTED
10b218: 5f pop %edi <== NOT EXECUTED
10b219: c9 leave <== NOT EXECUTED
10b21a: c3 ret <== NOT EXECUTED
10b21b: 90 nop <== NOT EXECUTED
parentpathlen = rtems_filesystem_dirname ( path );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( path, &i, &parentloc );
else {
result = rtems_filesystem_evaluate_path( path, parentpathlen,
10b21c: 89 c2 mov %eax,%edx
10b21e: 83 ec 0c sub $0xc,%esp
10b221: 6a 00 push $0x0
10b223: 8d 45 d0 lea -0x30(%ebp),%eax
10b226: 89 45 b4 mov %eax,-0x4c(%ebp)
10b229: 50 push %eax
10b22a: 6a 02 push $0x2
10b22c: 52 push %edx
10b22d: 53 push %ebx
10b22e: 89 55 ac mov %edx,-0x54(%ebp)
10b231: e8 da d1 ff ff call 108410 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
10b236: 83 c4 20 add $0x20,%esp
10b239: 85 c0 test %eax,%eax
10b23b: 8b 55 ac mov -0x54(%ebp),%edx
10b23e: 75 ce jne 10b20e <unlink+0xe2> <== NEVER TAKEN
return -1;
free_parentloc = true;
10b240: c6 45 b3 01 movb $0x1,-0x4d(%ebp)
10b244: e9 1b ff ff ff jmp 10b164 <unlink+0x38>
10b249: 8d 76 00 lea 0x0(%esi),%esi
rtems_filesystem_freenode( &parentloc );
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_filesystem_freenode( &loc );
10b24c: 83 ec 0c sub $0xc,%esp
10b24f: 56 push %esi
10b250: e8 93 d2 ff ff call 1084e8 <rtems_filesystem_freenode>
if ( free_parentloc )
10b255: 83 c4 10 add $0x10,%esp
10b258: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp)
10b25c: 74 0e je 10b26c <unlink+0x140>
rtems_filesystem_freenode( &parentloc );
10b25e: 83 ec 0c sub $0xc,%esp
10b261: ff 75 b4 pushl -0x4c(%ebp)
10b264: e8 7f d2 ff ff call 1084e8 <rtems_filesystem_freenode>
10b269: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( EISDIR );
10b26c: e8 bf a8 00 00 call 115b30 <__errno>
10b271: c7 00 15 00 00 00 movl $0x15,(%eax)
10b277: b8 ff ff ff ff mov $0xffffffff,%eax
10b27c: eb 80 jmp 10b1fe <unlink+0xd2>
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
10b27e: 83 ec 0c sub $0xc,%esp
10b281: ff 75 b4 pushl -0x4c(%ebp)
10b284: e8 5f d2 ff ff call 1084e8 <rtems_filesystem_freenode>
10b289: 83 c4 10 add $0x10,%esp
return -1;
10b28c: b8 ff ff ff ff mov $0xffffffff,%eax
10b291: e9 68 ff ff ff jmp 10b1fe <unlink+0xd2>
0010b2fc <unmount>:
*/
int unmount(
const char *path
)
{
10b2fc: 55 push %ebp
10b2fd: 89 e5 mov %esp,%ebp
10b2ff: 57 push %edi
10b300: 56 push %esi
10b301: 53 push %ebx
10b302: 83 ec 38 sub $0x38,%esp
10b305: 8b 55 08 mov 0x8(%ebp),%edx
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
10b308: 31 c0 xor %eax,%eax
10b30a: b9 ff ff ff ff mov $0xffffffff,%ecx
10b30f: 89 d7 mov %edx,%edi
10b311: f2 ae repnz scas %es:(%edi),%al
10b313: f7 d1 not %ecx
10b315: 49 dec %ecx
10b316: 6a 01 push $0x1
10b318: 8d 75 d4 lea -0x2c(%ebp),%esi
10b31b: 56 push %esi
10b31c: 6a 00 push $0x0
10b31e: 51 push %ecx
10b31f: 52 push %edx
10b320: e8 4f cf ff ff call 108274 <rtems_filesystem_evaluate_path>
10b325: 83 c4 20 add $0x20,%esp
10b328: 85 c0 test %eax,%eax
10b32a: 75 68 jne 10b394 <unmount+0x98>
return -1;
mt_entry = loc.mt_entry;
10b32c: 8b 5d e4 mov -0x1c(%ebp),%ebx
/*
* Verify this is the root node for the file system to be unmounted.
*/
if ( fs_root_loc->node_access != loc.node_access ){
10b32f: 8b 45 d4 mov -0x2c(%ebp),%eax
10b332: 39 43 1c cmp %eax,0x1c(%ebx)
10b335: 0f 85 c5 00 00 00 jne 10b400 <unmount+0x104>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
10b33b: 83 ec 0c sub $0xc,%esp
10b33e: 56 push %esi
10b33f: e8 08 d0 ff ff call 10834c <rtems_filesystem_freenode>
* that made the current node thread based instead
* of system based? I thought it was but it doesn't
* look like it in this version.
*/
if ( rtems_filesystem_current.mt_entry == mt_entry )
10b344: 83 c4 10 add $0x10,%esp
10b347: a1 b0 61 12 00 mov 0x1261b0,%eax
10b34c: 39 58 14 cmp %ebx,0x14(%eax)
10b34f: 0f 84 cf 00 00 00 je 10b424 <unmount+0x128>
/*
* Verify there are no file systems below the path specified
*/
if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,
10b355: 83 ec 08 sub $0x8,%esp
10b358: ff 73 2c pushl 0x2c(%ebx)
10b35b: 68 e8 b2 10 00 push $0x10b2e8
10b360: e8 ab d7 ff ff call 108b10 <rtems_filesystem_mount_iterate>
10b365: 83 c4 10 add $0x10,%esp
10b368: 84 c0 test %al,%al
10b36a: 0f 85 b4 00 00 00 jne 10b424 <unmount+0x128>
* Run the file descriptor table to determine if there are any file
* descriptors that are currently active and reference nodes in the
* file system that we are trying to unmount
*/
if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 )
10b370: 83 ec 0c sub $0xc,%esp
10b373: 53 push %ebx
10b374: e8 03 d3 ff ff call 10867c <rtems_libio_is_open_files_in_fs>
10b379: 83 c4 10 add $0x10,%esp
10b37c: 48 dec %eax
10b37d: 0f 84 a1 00 00 00 je 10b424 <unmount+0x128>
* Allow the file system being unmounted on to do its cleanup.
* If it fails it will set the errno to the approprate value
* and the fileystem will not be modified.
*/
if (( fs_mount_loc->ops->unmount_h )( mt_entry ) != 0 )
10b383: 83 ec 0c sub $0xc,%esp
10b386: 8b 43 14 mov 0x14(%ebx),%eax
10b389: 53 push %ebx
10b38a: ff 50 28 call *0x28(%eax)
10b38d: 83 c4 10 add $0x10,%esp
10b390: 85 c0 test %eax,%eax
10b392: 74 10 je 10b3a4 <unmount+0xa8> <== ALWAYS TAKEN
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
rtems_fatal_error_occurred( 0 );
return -1;
10b394: b8 ff ff ff ff mov $0xffffffff,%eax
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
10b399: 8d 65 f4 lea -0xc(%ebp),%esp
10b39c: 5b pop %ebx
10b39d: 5e pop %esi
10b39e: 5f pop %edi
10b39f: c9 leave
10b3a0: c3 ret
10b3a1: 8d 76 00 lea 0x0(%esi),%esi
* NOTE: Fatal error is called in a case which should never happen
* This was response was questionable but the best we could
* come up with.
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
10b3a4: 83 ec 0c sub $0xc,%esp
10b3a7: 8b 43 28 mov 0x28(%ebx),%eax
10b3aa: 53 push %ebx
10b3ab: ff 50 2c call *0x2c(%eax)
10b3ae: 83 c4 10 add $0x10,%esp
10b3b1: 85 c0 test %eax,%eax
10b3b3: 0f 85 83 00 00 00 jne 10b43c <unmount+0x140> <== NEVER TAKEN
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
10b3b9: 52 push %edx
10b3ba: 6a 00 push $0x0
10b3bc: 6a 00 push $0x0
10b3be: ff 35 08 84 12 00 pushl 0x128408
10b3c4: e8 c7 0a 00 00 call 10be90 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10b3c9: 89 1c 24 mov %ebx,(%esp)
10b3cc: e8 77 13 00 00 call 10c748 <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10b3d1: 58 pop %eax
10b3d2: ff 35 08 84 12 00 pushl 0x128408
10b3d8: e8 af 0b 00 00 call 10bf8c <rtems_semaphore_release>
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
return -1;
mt_entry = loc.mt_entry;
fs_mount_loc = &mt_entry->mt_point_node;
10b3dd: 8d 43 08 lea 0x8(%ebx),%eax
/*
* Free the memory node that was allocated in mount
* Free the memory associated with the extracted mount table entry.
*/
rtems_filesystem_freenode( fs_mount_loc );
10b3e0: 89 04 24 mov %eax,(%esp)
10b3e3: e8 64 cf ff ff call 10834c <rtems_filesystem_freenode>
free( mt_entry );
10b3e8: 89 1c 24 mov %ebx,(%esp)
10b3eb: e8 70 cf ff ff call 108360 <free>
return 0;
10b3f0: 83 c4 10 add $0x10,%esp
10b3f3: 31 c0 xor %eax,%eax
}
10b3f5: 8d 65 f4 lea -0xc(%ebp),%esp
10b3f8: 5b pop %ebx
10b3f9: 5e pop %esi
10b3fa: 5f pop %edi
10b3fb: c9 leave
10b3fc: c3 ret
10b3fd: 8d 76 00 lea 0x0(%esi),%esi
/*
* Verify this is the root node for the file system to be unmounted.
*/
if ( fs_root_loc->node_access != loc.node_access ){
rtems_filesystem_freenode( &loc );
10b400: 83 ec 0c sub $0xc,%esp
10b403: 56 push %esi
10b404: e8 43 cf ff ff call 10834c <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EACCES );
10b409: e8 9e 79 00 00 call 112dac <__errno>
10b40e: c7 00 0d 00 00 00 movl $0xd,(%eax)
10b414: 83 c4 10 add $0x10,%esp
10b417: b8 ff ff ff ff mov $0xffffffff,%eax
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
10b41c: 8d 65 f4 lea -0xc(%ebp),%esp
10b41f: 5b pop %ebx
10b420: 5e pop %esi
10b421: 5f pop %edi
10b422: c9 leave
10b423: c3 ret
* descriptors that are currently active and reference nodes in the
* file system that we are trying to unmount
*/
if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 )
rtems_set_errno_and_return_minus_one( EBUSY );
10b424: e8 83 79 00 00 call 112dac <__errno>
10b429: c7 00 10 00 00 00 movl $0x10,(%eax)
10b42f: b8 ff ff ff ff mov $0xffffffff,%eax
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
10b434: 8d 65 f4 lea -0xc(%ebp),%esp
10b437: 5b pop %ebx
10b438: 5e pop %esi
10b439: 5f pop %edi
10b43a: c9 leave
10b43b: c3 ret
* This was response was questionable but the best we could
* come up with.
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
10b43c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b43f: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED
10b442: 53 push %ebx <== NOT EXECUTED
10b443: ff 50 20 call *0x20(%eax) <== NOT EXECUTED
10b446: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10b449: 85 c0 test %eax,%eax <== NOT EXECUTED
10b44b: 0f 84 43 ff ff ff je 10b394 <unmount+0x98> <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
10b451: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b454: 6a 00 push $0x0 <== NOT EXECUTED
10b456: e8 2d 10 00 00 call 10c488 <rtems_fatal_error_occurred><== NOT EXECUTED
0010b4b4 <utime>:
int utime(
const char *path,
const struct utimbuf *times
)
{
10b4b4: 55 push %ebp
10b4b5: 89 e5 mov %esp,%ebp
10b4b7: 57 push %edi
10b4b8: 56 push %esi
10b4b9: 53 push %ebx
10b4ba: 83 ec 48 sub $0x48,%esp
10b4bd: 8b 55 08 mov 0x8(%ebp),%edx
10b4c0: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_filesystem_location_info_t temp_loc;
int result;
struct utimbuf now;
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) )
10b4c3: 31 c0 xor %eax,%eax
10b4c5: b9 ff ff ff ff mov $0xffffffff,%ecx
10b4ca: 89 d7 mov %edx,%edi
10b4cc: f2 ae repnz scas %es:(%edi),%al
10b4ce: f7 d1 not %ecx
10b4d0: 49 dec %ecx
10b4d1: 6a 01 push $0x1
10b4d3: 8d 75 d4 lea -0x2c(%ebp),%esi
10b4d6: 56 push %esi
10b4d7: 6a 00 push $0x0
10b4d9: 51 push %ecx
10b4da: 52 push %edx
10b4db: e8 a8 ca ff ff call 107f88 <rtems_filesystem_evaluate_path>
10b4e0: 83 c4 20 add $0x20,%esp
10b4e3: 85 c0 test %eax,%eax
10b4e5: 75 2d jne 10b514 <utime+0x60>
return -1;
if ( times == NULL ) {
10b4e7: 85 db test %ebx,%ebx
10b4e9: 74 39 je 10b524 <utime+0x70>
10b4eb: 8b 53 04 mov 0x4(%ebx),%edx
10b4ee: 8b 03 mov (%ebx),%eax
now.actime = now.modtime = time( NULL );
times = &now;
}
result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime );
10b4f0: 51 push %ecx
10b4f1: 52 push %edx
10b4f2: 50 push %eax
10b4f3: 56 push %esi
10b4f4: 8b 45 e0 mov -0x20(%ebp),%eax
10b4f7: ff 50 30 call *0x30(%eax)
rtems_filesystem_freenode( &temp_loc );
10b4fa: 89 34 24 mov %esi,(%esp)
10b4fd: 89 45 c4 mov %eax,-0x3c(%ebp)
10b500: e8 73 ce ff ff call 108378 <rtems_filesystem_freenode>
return result;
10b505: 83 c4 10 add $0x10,%esp
10b508: 8b 45 c4 mov -0x3c(%ebp),%eax
}
10b50b: 8d 65 f4 lea -0xc(%ebp),%esp
10b50e: 5b pop %ebx
10b50f: 5e pop %esi
10b510: 5f pop %edi
10b511: c9 leave
10b512: c3 ret
10b513: 90 nop
rtems_filesystem_location_info_t temp_loc;
int result;
struct utimbuf now;
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) )
return -1;
10b514: b8 ff ff ff ff mov $0xffffffff,%eax
result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime );
rtems_filesystem_freenode( &temp_loc );
return result;
}
10b519: 8d 65 f4 lea -0xc(%ebp),%esp
10b51c: 5b pop %ebx
10b51d: 5e pop %esi
10b51e: 5f pop %edi
10b51f: c9 leave
10b520: c3 ret
10b521: 8d 76 00 lea 0x0(%esi),%esi
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) )
return -1;
if ( times == NULL ) {
now.actime = now.modtime = time( NULL );
10b524: 83 ec 0c sub $0xc,%esp
10b527: 6a 00 push $0x0
10b529: e8 1a c2 00 00 call 117748 <time>
10b52e: 83 c4 10 add $0x10,%esp
10b531: 89 c2 mov %eax,%edx
10b533: eb bb jmp 10b4f0 <utime+0x3c>
0010b538 <utimes>:
int utimes(
const char *path,
const struct timeval times[2]
)
{
10b538: 55 push %ebp
10b539: 89 e5 mov %esp,%ebp
10b53b: 83 ec 18 sub $0x18,%esp
10b53e: 8b 55 08 mov 0x8(%ebp),%edx
10b541: 8b 45 0c mov 0xc(%ebp),%eax
struct utimbuf timeinsecs;
if ( times == NULL )
10b544: 85 c0 test %eax,%eax
10b546: 74 20 je 10b568 <utimes+0x30>
return utime( path, NULL );
timeinsecs.actime = (time_t) times[0].tv_sec;
10b548: 8b 08 mov (%eax),%ecx
10b54a: 89 4d f0 mov %ecx,-0x10(%ebp)
timeinsecs.modtime = (time_t) times[1].tv_sec;
10b54d: 8b 40 08 mov 0x8(%eax),%eax
10b550: 89 45 f4 mov %eax,-0xc(%ebp)
return utime( path, &timeinsecs );
10b553: 83 ec 08 sub $0x8,%esp
10b556: 8d 45 f0 lea -0x10(%ebp),%eax
10b559: 50 push %eax
10b55a: 52 push %edx
10b55b: e8 54 ff ff ff call 10b4b4 <utime>
10b560: 83 c4 10 add $0x10,%esp
}
10b563: c9 leave
10b564: c3 ret
10b565: 8d 76 00 lea 0x0(%esi),%esi
)
{
struct utimbuf timeinsecs;
if ( times == NULL )
return utime( path, NULL );
10b568: 83 ec 08 sub $0x8,%esp
10b56b: 6a 00 push $0x0
10b56d: 52 push %edx
10b56e: e8 41 ff ff ff call 10b4b4 <utime>
10b573: 83 c4 10 add $0x10,%esp
timeinsecs.actime = (time_t) times[0].tv_sec;
timeinsecs.modtime = (time_t) times[1].tv_sec;
return utime( path, &timeinsecs );
}
10b576: c9 leave
10b577: c3 ret
0010a174 <vprintk>:
*/
void vprintk(
const char *fmt,
va_list ap
)
{
10a174: 55 push %ebp
10a175: 89 e5 mov %esp,%ebp
10a177: 57 push %edi
10a178: 56 push %esi
10a179: 53 push %ebx
10a17a: 83 ec 4c sub $0x4c,%esp
10a17d: 8b 75 08 mov 0x8(%ebp),%esi
for (; *fmt != '\0'; fmt++) {
10a180: 8a 06 mov (%esi),%al
10a182: 84 c0 test %al,%al
10a184: 75 21 jne 10a1a7 <vprintk+0x33>
10a186: e9 c4 01 00 00 jmp 10a34f <vprintk+0x1db>
10a18b: 90 nop
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
BSP_output_char(*fmt);
10a18c: 83 ec 0c sub $0xc,%esp
10a18f: 0f be c0 movsbl %al,%eax
10a192: 50 push %eax
10a193: ff 15 68 23 12 00 call *0x122368
continue;
10a199: 83 c4 10 add $0x10,%esp
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
10a19c: 46 inc %esi
10a19d: 8a 06 mov (%esi),%al
10a19f: 84 c0 test %al,%al
10a1a1: 0f 84 a8 01 00 00 je 10a34f <vprintk+0x1db>
bool minus = false;
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
10a1a7: 3c 25 cmp $0x25,%al
10a1a9: 75 e1 jne 10a18c <vprintk+0x18>
BSP_output_char(*fmt);
continue;
}
fmt++;
10a1ab: 46 inc %esi
if (*fmt == '0' ) {
10a1ac: 8a 06 mov (%esi),%al
10a1ae: 3c 30 cmp $0x30,%al
10a1b0: 0f 84 fe 01 00 00 je 10a3b4 <vprintk+0x240>
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
bool sign = false;
char lead = ' ';
10a1b6: b1 20 mov $0x20,%cl
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
10a1b8: 3c 2d cmp $0x2d,%al
10a1ba: 0f 84 d8 01 00 00 je 10a398 <vprintk+0x224>
{
for (; *fmt != '\0'; fmt++) {
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
10a1c0: 31 ff xor %edi,%edi
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
10a1c2: 8d 50 d0 lea -0x30(%eax),%edx
10a1c5: 80 fa 09 cmp $0x9,%dl
10a1c8: 0f 87 de 01 00 00 ja 10a3ac <vprintk+0x238>
10a1ce: 31 db xor %ebx,%ebx
width *= 10;
10a1d0: 8d 14 9b lea (%ebx,%ebx,4),%edx
width += ((unsigned) *fmt - '0');
10a1d3: 0f be c0 movsbl %al,%eax
10a1d6: 8d 5c 50 d0 lea -0x30(%eax,%edx,2),%ebx
fmt++;
10a1da: 46 inc %esi
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
10a1db: 8a 06 mov (%esi),%al
10a1dd: 8d 50 d0 lea -0x30(%eax),%edx
10a1e0: 80 fa 09 cmp $0x9,%dl
10a1e3: 76 eb jbe 10a1d0 <vprintk+0x5c>
width *= 10;
width += ((unsigned) *fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
10a1e5: 3c 6c cmp $0x6c,%al
10a1e7: 0f 84 7b 01 00 00 je 10a368 <vprintk+0x1f4>
10a1ed: 88 c2 mov %al,%dl
lflag = true;
c = *++fmt;
}
if ( c == 'c' ) {
10a1ef: 80 fa 63 cmp $0x63,%dl
10a1f2: 0f 84 7c 01 00 00 je 10a374 <vprintk+0x200>
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
BSP_output_char(chr);
continue;
}
if ( c == 's' ) {
10a1f8: 80 fa 73 cmp $0x73,%dl
10a1fb: 0f 84 bf 01 00 00 je 10a3c0 <vprintk+0x24c>
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
10a201: 80 fa 6f cmp $0x6f,%dl
10a204: 0f 84 4e 01 00 00 je 10a358 <vprintk+0x1e4> <== NEVER TAKEN
10a20a: 80 fa 4f cmp $0x4f,%dl
10a20d: 0f 84 45 01 00 00 je 10a358 <vprintk+0x1e4>
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
10a213: 80 fa 69 cmp $0x69,%dl
10a216: 74 54 je 10a26c <vprintk+0xf8>
10a218: 80 fa 49 cmp $0x49,%dl
10a21b: 74 4f je 10a26c <vprintk+0xf8>
10a21d: 80 fa 64 cmp $0x64,%dl
10a220: 74 4a je 10a26c <vprintk+0xf8>
c == 'd' || c == 'D' ) {
10a222: 80 fa 44 cmp $0x44,%dl
10a225: 74 45 je 10a26c <vprintk+0xf8>
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
10a227: 80 fa 75 cmp $0x75,%dl
10a22a: 0f 84 85 02 00 00 je 10a4b5 <vprintk+0x341>
10a230: 80 fa 55 cmp $0x55,%dl
10a233: 0f 84 7c 02 00 00 je 10a4b5 <vprintk+0x341>
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
10a239: 80 fa 78 cmp $0x78,%dl
10a23c: 0f 84 bd 02 00 00 je 10a4ff <vprintk+0x38b>
10a242: 80 fa 58 cmp $0x58,%dl
10a245: 0f 84 b4 02 00 00 je 10a4ff <vprintk+0x38b>
base = 16; sign = false;
} else if ( c == 'p' ) {
10a24b: 80 fa 70 cmp $0x70,%dl
10a24e: 0f 84 d3 02 00 00 je 10a527 <vprintk+0x3b3>
base = 16; sign = false; lflag = true;
} else {
BSP_output_char(c);
10a254: 83 ec 0c sub $0xc,%esp
10a257: 0f be d2 movsbl %dl,%edx
10a25a: 52 push %edx
10a25b: ff 15 68 23 12 00 call *0x122368
continue;
10a261: 83 c4 10 add $0x10,%esp
10a264: e9 33 ff ff ff jmp 10a19c <vprintk+0x28>
10a269: 8d 76 00 lea 0x0(%esi),%esi
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
10a26c: b2 01 mov $0x1,%dl
10a26e: c7 45 c0 0a 00 00 00 movl $0xa,-0x40(%ebp)
} else {
BSP_output_char(c);
continue;
}
printNum(
10a275: 0f be c9 movsbl %cl,%ecx
10a278: 89 4d b4 mov %ecx,-0x4c(%ebp)
10a27b: 8b 45 0c mov 0xc(%ebp),%eax
10a27e: 8b 38 mov (%eax),%edi
lflag ? va_arg(ap, long) : (long) va_arg(ap, int),
10a280: 83 c0 04 add $0x4,%eax
10a283: 89 45 0c mov %eax,0xc(%ebp)
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
10a286: 84 d2 test %dl,%dl
10a288: 74 08 je 10a292 <vprintk+0x11e>
10a28a: 85 ff test %edi,%edi
10a28c: 0f 88 31 02 00 00 js 10a4c3 <vprintk+0x34f>
BSP_output_char('-');
unsigned_num = (unsigned long) -num;
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
10a292: 89 7d b8 mov %edi,-0x48(%ebp)
}
count = 0;
while ((n = unsigned_num / base) > 0) {
10a295: 8b 45 b8 mov -0x48(%ebp),%eax
10a298: 31 d2 xor %edx,%edx
10a29a: f7 75 c0 divl -0x40(%ebp)
10a29d: 89 c1 mov %eax,%ecx
10a29f: 85 c0 test %eax,%eax
10a2a1: 0f 84 47 02 00 00 je 10a4ee <vprintk+0x37a>
10a2a7: 8a 55 c0 mov -0x40(%ebp),%dl
10a2aa: 88 55 c4 mov %dl,-0x3c(%ebp)
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
10a2ad: 31 ff xor %edi,%edi
10a2af: 89 5d b0 mov %ebx,-0x50(%ebp)
10a2b2: 8b 5d c0 mov -0x40(%ebp),%ebx
10a2b5: 8b 55 b8 mov -0x48(%ebp),%edx
10a2b8: eb 06 jmp 10a2c0 <vprintk+0x14c>
10a2ba: 66 90 xchg %ax,%ax
while ((n = unsigned_num / base) > 0) {
10a2bc: 89 ca mov %ecx,%edx
10a2be: 89 c1 mov %eax,%ecx
toPrint[count++] = (char) (unsigned_num - (n * base));
10a2c0: 8a 45 c4 mov -0x3c(%ebp),%al
10a2c3: f6 e1 mul %cl
10a2c5: 28 c2 sub %al,%dl
10a2c7: 88 54 3d d4 mov %dl,-0x2c(%ebp,%edi,1)
10a2cb: 47 inc %edi
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
10a2cc: 89 c8 mov %ecx,%eax
10a2ce: 31 d2 xor %edx,%edx
10a2d0: f7 f3 div %ebx
10a2d2: 85 c0 test %eax,%eax
10a2d4: 75 e6 jne 10a2bc <vprintk+0x148>
10a2d6: 8b 5d b0 mov -0x50(%ebp),%ebx
10a2d9: 8d 47 01 lea 0x1(%edi),%eax
10a2dc: 89 45 c4 mov %eax,-0x3c(%ebp)
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
10a2df: 88 4c 3d d4 mov %cl,-0x2c(%ebp,%edi,1)
for (n=maxwidth ; n > count; n-- )
10a2e3: 3b 5d c4 cmp -0x3c(%ebp),%ebx
10a2e6: 76 21 jbe 10a309 <vprintk+0x195>
10a2e8: 8b 7d b4 mov -0x4c(%ebp),%edi
10a2eb: 89 75 c0 mov %esi,-0x40(%ebp)
10a2ee: 8b 75 c4 mov -0x3c(%ebp),%esi
10a2f1: 8d 76 00 lea 0x0(%esi),%esi
BSP_output_char(lead);
10a2f4: 83 ec 0c sub $0xc,%esp
10a2f7: 57 push %edi
10a2f8: ff 15 68 23 12 00 call *0x122368
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
10a2fe: 4b dec %ebx
10a2ff: 83 c4 10 add $0x10,%esp
10a302: 39 f3 cmp %esi,%ebx
10a304: 77 ee ja 10a2f4 <vprintk+0x180>
10a306: 8b 75 c0 mov -0x40(%ebp),%esi
BSP_output_char(lead);
for (n = 0; n < count; n++) {
10a309: 8b 45 c4 mov -0x3c(%ebp),%eax
10a30c: 85 c0 test %eax,%eax
10a30e: 0f 84 88 fe ff ff je 10a19c <vprintk+0x28> <== NEVER TAKEN
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
10a314: 8b 55 c4 mov -0x3c(%ebp),%edx
10a317: 8d 7c 15 d3 lea -0x2d(%ebp,%edx,1),%edi
10a31b: 31 db xor %ebx,%ebx
10a31d: 89 75 c0 mov %esi,-0x40(%ebp)
10a320: 89 d6 mov %edx,%esi
10a322: 66 90 xchg %ax,%ax
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
10a324: 83 ec 0c sub $0xc,%esp
10a327: 0f be 07 movsbl (%edi),%eax
10a32a: 0f be 80 6a fe 11 00 movsbl 0x11fe6a(%eax),%eax
10a331: 50 push %eax
10a332: ff 15 68 23 12 00 call *0x122368
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
10a338: 43 inc %ebx
10a339: 4f dec %edi
10a33a: 83 c4 10 add $0x10,%esp
10a33d: 39 f3 cmp %esi,%ebx
10a33f: 72 e3 jb 10a324 <vprintk+0x1b0>
10a341: 8b 75 c0 mov -0x40(%ebp),%esi
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
10a344: 46 inc %esi
10a345: 8a 06 mov (%esi),%al
10a347: 84 c0 test %al,%al
10a349: 0f 85 58 fe ff ff jne 10a1a7 <vprintk+0x33> <== ALWAYS TAKEN
sign,
width,
lead
);
}
}
10a34f: 8d 65 f4 lea -0xc(%ebp),%esp
10a352: 5b pop %ebx
10a353: 5e pop %esi
10a354: 5f pop %edi
10a355: c9 leave
10a356: c3 ret
10a357: 90 nop
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
10a358: 31 d2 xor %edx,%edx
10a35a: c7 45 c0 08 00 00 00 movl $0x8,-0x40(%ebp)
10a361: e9 0f ff ff ff jmp 10a275 <vprintk+0x101>
10a366: 66 90 xchg %ax,%ax
fmt++;
}
if ((c = *fmt) == 'l') {
lflag = true;
c = *++fmt;
10a368: 46 inc %esi
10a369: 8a 16 mov (%esi),%dl
}
if ( c == 'c' ) {
10a36b: 80 fa 63 cmp $0x63,%dl
10a36e: 0f 85 84 fe ff ff jne 10a1f8 <vprintk+0x84> <== ALWAYS TAKEN
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
10a374: 8b 5d 0c mov 0xc(%ebp),%ebx
10a377: 83 c3 04 add $0x4,%ebx
BSP_output_char(chr);
10a37a: 83 ec 0c sub $0xc,%esp
10a37d: 8b 55 0c mov 0xc(%ebp),%edx
10a380: 0f be 02 movsbl (%edx),%eax
10a383: 50 push %eax
10a384: ff 15 68 23 12 00 call *0x122368
continue;
10a38a: 83 c4 10 add $0x10,%esp
lflag = true;
c = *++fmt;
}
if ( c == 'c' ) {
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
10a38d: 89 5d 0c mov %ebx,0xc(%ebp)
BSP_output_char(chr);
continue;
10a390: e9 07 fe ff ff jmp 10a19c <vprintk+0x28>
10a395: 8d 76 00 lea 0x0(%esi),%esi
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = true;
fmt++;
10a398: 46 inc %esi
10a399: 8a 06 mov (%esi),%al
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = true;
10a39b: bf 01 00 00 00 mov $0x1,%edi
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
10a3a0: 8d 50 d0 lea -0x30(%eax),%edx
10a3a3: 80 fa 09 cmp $0x9,%dl
10a3a6: 0f 86 22 fe ff ff jbe 10a1ce <vprintk+0x5a> <== ALWAYS TAKEN
10a3ac: 31 db xor %ebx,%ebx
10a3ae: e9 32 fe ff ff jmp 10a1e5 <vprintk+0x71>
10a3b3: 90 nop
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
10a3b4: 46 inc %esi
10a3b5: 8a 06 mov (%esi),%al
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
10a3b7: b1 30 mov $0x30,%cl
10a3b9: e9 fa fd ff ff jmp 10a1b8 <vprintk+0x44>
10a3be: 66 90 xchg %ax,%ax
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
10a3c0: 8b 45 0c mov 0xc(%ebp),%eax
10a3c3: 83 c0 04 add $0x4,%eax
10a3c6: 89 45 c0 mov %eax,-0x40(%ebp)
10a3c9: 8b 55 0c mov 0xc(%ebp),%edx
10a3cc: 8b 02 mov (%edx),%eax
if ( str == NULL ) {
10a3ce: 85 c0 test %eax,%eax
10a3d0: 0f 84 37 01 00 00 je 10a50d <vprintk+0x399>
str = "";
}
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
10a3d6: 80 38 00 cmpb $0x0,(%eax)
10a3d9: 0f 84 3c 01 00 00 je 10a51b <vprintk+0x3a7>
10a3df: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
10a3e6: 31 d2 xor %edx,%edx
10a3e8: 42 inc %edx
10a3e9: 80 3c 10 00 cmpb $0x0,(%eax,%edx,1)
10a3ed: 75 f9 jne 10a3e8 <vprintk+0x274>
10a3ef: 89 55 c4 mov %edx,-0x3c(%ebp)
;
/* leading spaces */
if ( !minus )
10a3f2: 89 fa mov %edi,%edx
10a3f4: 84 d2 test %dl,%dl
10a3f6: 75 32 jne 10a42a <vprintk+0x2b6>
for ( i=len ; i<width ; i++ )
10a3f8: 39 5d c4 cmp %ebx,-0x3c(%ebp)
10a3fb: 73 2d jae 10a42a <vprintk+0x2b6>
10a3fd: 8b 4d c4 mov -0x3c(%ebp),%ecx
10a400: 88 55 bc mov %dl,-0x44(%ebp)
10a403: 89 c7 mov %eax,%edi
10a405: 89 75 b8 mov %esi,-0x48(%ebp)
10a408: 89 de mov %ebx,%esi
10a40a: 89 cb mov %ecx,%ebx
BSP_output_char(' ');
10a40c: 83 ec 0c sub $0xc,%esp
10a40f: 6a 20 push $0x20
10a411: ff 15 68 23 12 00 call *0x122368
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
10a417: 43 inc %ebx
10a418: 83 c4 10 add $0x10,%esp
10a41b: 39 f3 cmp %esi,%ebx
10a41d: 72 ed jb 10a40c <vprintk+0x298>
10a41f: 89 f8 mov %edi,%eax
10a421: 89 f3 mov %esi,%ebx
10a423: 0f b6 7d bc movzbl -0x44(%ebp),%edi
10a427: 8b 75 b8 mov -0x48(%ebp),%esi
BSP_output_char(' ');
/* no width option */
if (width == 0) {
10a42a: 85 db test %ebx,%ebx
10a42c: 75 0a jne 10a438 <vprintk+0x2c4>
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
10a42e: 8b 55 c4 mov -0x3c(%ebp),%edx
10a431: 85 d2 test %edx,%edx
10a433: 74 47 je 10a47c <vprintk+0x308>
10a435: 8b 5d c4 mov -0x3c(%ebp),%ebx
10a438: 8a 10 mov (%eax),%dl
10a43a: 84 d2 test %dl,%dl
10a43c: 74 3e je 10a47c <vprintk+0x308> <== NEVER TAKEN
BSP_output_char(*str);
10a43e: 83 ec 0c sub $0xc,%esp
10a441: 0f be d2 movsbl %dl,%edx
10a444: 52 push %edx
10a445: 89 45 ac mov %eax,-0x54(%ebp)
10a448: ff 15 68 23 12 00 call *0x122368
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
10a44e: 8b 45 ac mov -0x54(%ebp),%eax
10a451: 40 inc %eax
10a452: 83 c4 10 add $0x10,%esp
10a455: 89 75 bc mov %esi,-0x44(%ebp)
10a458: 89 de mov %ebx,%esi
10a45a: 89 c3 mov %eax,%ebx
10a45c: eb 13 jmp 10a471 <vprintk+0x2fd>
10a45e: 66 90 xchg %ax,%ax
BSP_output_char(*str);
10a460: 83 ec 0c sub $0xc,%esp
10a463: 0f be d2 movsbl %dl,%edx
10a466: 52 push %edx
10a467: ff 15 68 23 12 00 call *0x122368
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
10a46d: 43 inc %ebx
10a46e: 83 c4 10 add $0x10,%esp
10a471: 8a 13 mov (%ebx),%dl
10a473: 84 d2 test %dl,%dl
10a475: 75 e9 jne 10a460 <vprintk+0x2ec>
10a477: 89 f3 mov %esi,%ebx
10a479: 8b 75 bc mov -0x44(%ebp),%esi
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
10a47c: 89 f8 mov %edi,%eax
10a47e: 84 c0 test %al,%al
10a480: 74 28 je 10a4aa <vprintk+0x336>
for ( i=len ; i<width ; i++ )
10a482: 39 5d c4 cmp %ebx,-0x3c(%ebp)
10a485: 73 18 jae 10a49f <vprintk+0x32b>
10a487: 8b 7d c4 mov -0x3c(%ebp),%edi
10a48a: 66 90 xchg %ax,%ax
BSP_output_char(' ');
10a48c: 83 ec 0c sub $0xc,%esp
10a48f: 6a 20 push $0x20
10a491: ff 15 68 23 12 00 call *0x122368
for ( i=0 ; i<width && *str ; str++ )
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
10a497: 47 inc %edi
10a498: 83 c4 10 add $0x10,%esp
10a49b: 39 df cmp %ebx,%edi
10a49d: 72 ed jb 10a48c <vprintk+0x318>
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
10a49f: 8b 55 c0 mov -0x40(%ebp),%edx
10a4a2: 89 55 0c mov %edx,0xc(%ebp)
10a4a5: e9 f2 fc ff ff jmp 10a19c <vprintk+0x28>
10a4aa: 8b 45 c0 mov -0x40(%ebp),%eax
10a4ad: 89 45 0c mov %eax,0xc(%ebp)
10a4b0: e9 e7 fc ff ff jmp 10a19c <vprintk+0x28>
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
base = 10; sign = false;
10a4b5: 31 d2 xor %edx,%edx
10a4b7: c7 45 c0 0a 00 00 00 movl $0xa,-0x40(%ebp)
10a4be: e9 b2 fd ff ff jmp 10a275 <vprintk+0x101>
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
BSP_output_char('-');
10a4c3: 83 ec 0c sub $0xc,%esp
10a4c6: 6a 2d push $0x2d
10a4c8: ff 15 68 23 12 00 call *0x122368
unsigned_num = (unsigned long) -num;
10a4ce: f7 df neg %edi
10a4d0: 89 7d b8 mov %edi,-0x48(%ebp)
if (maxwidth) maxwidth--;
10a4d3: 83 c4 10 add $0x10,%esp
10a4d6: 83 fb 01 cmp $0x1,%ebx
10a4d9: 83 d3 ff adc $0xffffffff,%ebx
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
10a4dc: 8b 45 b8 mov -0x48(%ebp),%eax
10a4df: 31 d2 xor %edx,%edx
10a4e1: f7 75 c0 divl -0x40(%ebp)
10a4e4: 89 c1 mov %eax,%ecx
10a4e6: 85 c0 test %eax,%eax
10a4e8: 0f 85 b9 fd ff ff jne 10a2a7 <vprintk+0x133> <== ALWAYS TAKEN
10a4ee: 8b 4d b8 mov -0x48(%ebp),%ecx
10a4f1: c7 45 c4 01 00 00 00 movl $0x1,-0x3c(%ebp)
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
10a4f8: 31 ff xor %edi,%edi
10a4fa: e9 e0 fd ff ff jmp 10a2df <vprintk+0x16b>
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
base = 16; sign = false;
10a4ff: 31 d2 xor %edx,%edx
10a501: c7 45 c0 10 00 00 00 movl $0x10,-0x40(%ebp)
10a508: e9 68 fd ff ff jmp 10a275 <vprintk+0x101>
char *s, *str;
str = va_arg(ap, char *);
if ( str == NULL ) {
str = "";
10a50d: b8 69 fe 11 00 mov $0x11fe69,%eax
}
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
10a512: 80 38 00 cmpb $0x0,(%eax)
10a515: 0f 85 c4 fe ff ff jne 10a3df <vprintk+0x26b> <== NEVER TAKEN
10a51b: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
10a522: e9 cb fe ff ff jmp 10a3f2 <vprintk+0x27e>
} else {
BSP_output_char(c);
continue;
}
printNum(
10a527: 0f be c9 movsbl %cl,%ecx
10a52a: 89 4d b4 mov %ecx,-0x4c(%ebp)
} else if ( c == 'u' || c == 'U' ) {
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
base = 16; sign = false;
} else if ( c == 'p' ) {
base = 16; sign = false; lflag = true;
10a52d: 31 d2 xor %edx,%edx
10a52f: c7 45 c0 10 00 00 00 movl $0x10,-0x40(%ebp)
10a536: e9 40 fd ff ff jmp 10a27b <vprintk+0x107>
0011df88 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
11df88: 55 push %ebp
11df89: 89 e5 mov %esp,%ebp
11df8b: 53 push %ebx
11df8c: 83 ec 04 sub $0x4,%esp
11df8f: 8b 4d 08 mov 0x8(%ebp),%ecx
11df92: 8b 45 0c mov 0xc(%ebp),%eax
11df95: 8b 55 10 mov 0x10(%ebp),%edx
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
11df98: 3b 0d ec 21 12 00 cmp 0x1221ec,%ecx
11df9e: 73 50 jae 11dff0 <write+0x68>
iop = rtems_libio_iop( fd );
11dfa0: c1 e1 03 shl $0x3,%ecx
11dfa3: 8d 1c cd 00 00 00 00 lea 0x0(,%ecx,8),%ebx
11dfaa: 29 cb sub %ecx,%ebx
11dfac: 03 1d 80 63 12 00 add 0x126380,%ebx
rtems_libio_check_is_open( iop );
11dfb2: 8b 4b 14 mov 0x14(%ebx),%ecx
11dfb5: f6 c5 01 test $0x1,%ch
11dfb8: 74 36 je 11dff0 <write+0x68>
rtems_libio_check_buffer( buffer );
11dfba: 85 c0 test %eax,%eax
11dfbc: 74 46 je 11e004 <write+0x7c> <== NEVER TAKEN
rtems_libio_check_count( count );
11dfbe: 85 d2 test %edx,%edx
11dfc0: 74 26 je 11dfe8 <write+0x60>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
11dfc2: 83 e1 04 and $0x4,%ecx
11dfc5: 74 3d je 11e004 <write+0x7c>
/*
* Now process the write() request.
*/
rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
11dfc7: 51 push %ecx
11dfc8: 8b 4b 20 mov 0x20(%ebx),%ecx
11dfcb: 52 push %edx
11dfcc: 50 push %eax
11dfcd: 53 push %ebx
11dfce: ff 51 0c call *0xc(%ecx)
if ( rc > 0 )
11dfd1: 83 c4 10 add $0x10,%esp
11dfd4: 85 c0 test %eax,%eax
11dfd6: 7e 0b jle 11dfe3 <write+0x5b>
iop->offset += rc;
11dfd8: 89 c1 mov %eax,%ecx
11dfda: c1 f9 1f sar $0x1f,%ecx
11dfdd: 01 43 0c add %eax,0xc(%ebx)
11dfe0: 11 4b 10 adc %ecx,0x10(%ebx)
return rc;
}
11dfe3: 8b 5d fc mov -0x4(%ebp),%ebx
11dfe6: c9 leave
11dfe7: c3 ret
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
11dfe8: 31 c0 xor %eax,%eax
if ( rc > 0 )
iop->offset += rc;
return rc;
}
11dfea: 8b 5d fc mov -0x4(%ebp),%ebx
11dfed: c9 leave
11dfee: c3 ret
11dfef: 90 nop
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
11dff0: e8 e7 3d ff ff call 111ddc <__errno>
11dff5: c7 00 09 00 00 00 movl $0x9,(%eax)
11dffb: b8 ff ff ff ff mov $0xffffffff,%eax
11e000: eb e1 jmp 11dfe3 <write+0x5b>
11e002: 66 90 xchg %ax,%ax
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
11e004: e8 d3 3d ff ff call 111ddc <__errno>
11e009: c7 00 16 00 00 00 movl $0x16,(%eax)
11e00f: b8 ff ff ff ff mov $0xffffffff,%eax
11e014: eb cd jmp 11dfe3 <write+0x5b>
0010b554 <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
10b554: 55 push %ebp
10b555: 89 e5 mov %esp,%ebp
10b557: 57 push %edi
10b558: 56 push %esi
10b559: 53 push %ebx
10b55a: 83 ec 3c sub $0x3c,%esp
10b55d: 8b 45 08 mov 0x8(%ebp),%eax
10b560: 8b 5d 0c mov 0xc(%ebp),%ebx
10b563: 8b 7d 10 mov 0x10(%ebp),%edi
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
10b566: 3b 05 4c 37 12 00 cmp 0x12374c,%eax
10b56c: 0f 83 ea 00 00 00 jae 10b65c <writev+0x108>
iop = rtems_libio_iop( fd );
10b572: c1 e0 03 shl $0x3,%eax
10b575: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
10b57c: 29 c2 sub %eax,%edx
10b57e: 8b 0d e0 78 12 00 mov 0x1278e0,%ecx
10b584: 01 ca add %ecx,%edx
10b586: 89 55 e4 mov %edx,-0x1c(%ebp)
rtems_libio_check_is_open( iop );
10b589: 8b 42 14 mov 0x14(%edx),%eax
10b58c: f6 c4 01 test $0x1,%ah
10b58f: 0f 84 c7 00 00 00 je 10b65c <writev+0x108>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
10b595: a8 04 test $0x4,%al
10b597: 74 6b je 10b604 <writev+0xb0> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
10b599: 85 db test %ebx,%ebx
10b59b: 74 67 je 10b604 <writev+0xb0>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
10b59d: 85 ff test %edi,%edi
10b59f: 7e 63 jle 10b604 <writev+0xb0>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
10b5a1: 81 ff 00 04 00 00 cmp $0x400,%edi
10b5a7: 7f 5b jg 10b604 <writev+0xb0> <== NEVER TAKEN
10b5a9: be 01 00 00 00 mov $0x1,%esi
10b5ae: 31 c0 xor %eax,%eax
10b5b0: 31 c9 xor %ecx,%ecx
10b5b2: eb 02 jmp 10b5b6 <writev+0x62>
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
10b5b4: 89 d1 mov %edx,%ecx
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
10b5b6: 8b 14 c3 mov (%ebx,%eax,8),%edx
10b5b9: 85 d2 test %edx,%edx
10b5bb: 74 47 je 10b604 <writev+0xb0>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
10b5bd: 8b 54 c3 04 mov 0x4(%ebx,%eax,8),%edx
10b5c1: 85 d2 test %edx,%edx
10b5c3: 74 02 je 10b5c7 <writev+0x73>
all_zeros = false;
10b5c5: 31 f6 xor %esi,%esi
/* check for wrap */
old = total;
total += iov[v].iov_len;
10b5c7: 8d 14 11 lea (%ecx,%edx,1),%edx
if ( total < old || total > SSIZE_MAX )
10b5ca: 39 ca cmp %ecx,%edx
10b5cc: 7c 36 jl 10b604 <writev+0xb0>
10b5ce: 81 fa ff 7f 00 00 cmp $0x7fff,%edx
10b5d4: 7f 2e jg 10b604 <writev+0xb0> <== NEVER TAKEN
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
10b5d6: 40 inc %eax
10b5d7: 39 c7 cmp %eax,%edi
10b5d9: 7f d9 jg 10b5b4 <writev+0x60>
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
10b5db: 89 f0 mov %esi,%eax
10b5dd: 84 c0 test %al,%al
10b5df: 75 3d jne 10b61e <writev+0xca>
10b5e1: 31 f6 xor %esi,%esi
10b5e3: 31 d2 xor %edx,%edx
10b5e5: 89 55 c0 mov %edx,-0x40(%ebp)
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
10b5e8: 8b 44 f3 04 mov 0x4(%ebx,%esi,8),%eax
10b5ec: 85 c0 test %eax,%eax
10b5ee: 75 32 jne 10b622 <writev+0xce> <== ALWAYS TAKEN
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
10b5f0: 46 inc %esi
10b5f1: 39 f7 cmp %esi,%edi
10b5f3: 7f f3 jg 10b5e8 <writev+0x94>
10b5f5: 8b 55 c0 mov -0x40(%ebp),%edx
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
10b5f8: 89 d0 mov %edx,%eax
10b5fa: 8d 65 f4 lea -0xc(%ebp),%esp
10b5fd: 5b pop %ebx
10b5fe: 5e pop %esi
10b5ff: 5f pop %edi
10b600: c9 leave
10b601: c3 ret
10b602: 66 90 xchg %ax,%ax
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
rtems_set_errno_and_return_minus_one( EINVAL );
10b604: e8 8f 74 00 00 call 112a98 <__errno>
10b609: c7 00 16 00 00 00 movl $0x16,(%eax)
10b60f: ba ff ff ff ff mov $0xffffffff,%edx
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
10b614: 89 d0 mov %edx,%eax
10b616: 8d 65 f4 lea -0xc(%ebp),%esp
10b619: 5b pop %ebx
10b61a: 5e pop %esi
10b61b: 5f pop %edi
10b61c: c9 leave
10b61d: c3 ret
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
return 0;
10b61e: 31 d2 xor %edx,%edx
10b620: eb f2 jmp 10b614 <writev+0xc0>
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
10b622: 52 push %edx
10b623: 8b 4d e4 mov -0x1c(%ebp),%ecx
10b626: 8b 51 20 mov 0x20(%ecx),%edx
10b629: 50 push %eax
10b62a: ff 34 f3 pushl (%ebx,%esi,8)
10b62d: 51 push %ecx
10b62e: ff 52 0c call *0xc(%edx)
10b631: 89 45 c4 mov %eax,-0x3c(%ebp)
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
10b634: 83 c4 10 add $0x10,%esp
10b637: 83 f8 00 cmp $0x0,%eax
10b63a: 7c 32 jl 10b66e <writev+0x11a> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
10b63c: 74 10 je 10b64e <writev+0xfa> <== NEVER TAKEN
iop->offset += bytes;
10b63e: 99 cltd
10b63f: 8b 4d e4 mov -0x1c(%ebp),%ecx
10b642: 01 41 0c add %eax,0xc(%ecx)
10b645: 11 51 10 adc %edx,0x10(%ecx)
total += bytes;
10b648: 8b 45 c4 mov -0x3c(%ebp),%eax
10b64b: 01 45 c0 add %eax,-0x40(%ebp)
}
if (bytes != iov[ v ].iov_len)
10b64e: 8b 55 c4 mov -0x3c(%ebp),%edx
10b651: 3b 54 f3 04 cmp 0x4(%ebx,%esi,8),%edx
10b655: 74 99 je 10b5f0 <writev+0x9c> <== ALWAYS TAKEN
10b657: eb 9c jmp 10b5f5 <writev+0xa1> <== NOT EXECUTED
10b659: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
10b65c: e8 37 74 00 00 call 112a98 <__errno>
10b661: c7 00 09 00 00 00 movl $0x9,(%eax)
10b667: ba ff ff ff ff mov $0xffffffff,%edx
10b66c: eb a6 jmp 10b614 <writev+0xc0>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
10b66e: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED
10b671: eb a1 jmp 10b614 <writev+0xc0> <== NOT EXECUTED