RTEMS 4.11Annotated Report
Fri Feb 18 19:24:11 2011
0010f0e8 <IMFS_Set_handlers>:
#define MAXSYMLINK 5
int IMFS_Set_handlers(
rtems_filesystem_location_info_t *loc
)
{
10f0e8: 55 push %ebp
10f0e9: 89 e5 mov %esp,%ebp
10f0eb: 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;
10f0ee: 8b 50 10 mov 0x10(%eax),%edx
10f0f1: 8b 4a 34 mov 0x34(%edx),%ecx
switch( node->type ) {
10f0f4: 8b 10 mov (%eax),%edx
10f0f6: 83 7a 4c 07 cmpl $0x7,0x4c(%edx)
10f0fa: 77 12 ja 10f10e <IMFS_Set_handlers+0x26><== NEVER TAKEN
10f0fc: 8b 52 4c mov 0x4c(%edx),%edx
10f0ff: ff 24 95 d0 17 12 00 jmp *0x1217d0(,%edx,4)
10f106: 66 90 xchg %ax,%ax
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
10f108: 8b 51 0c mov 0xc(%ecx),%edx
10f10b: 89 50 08 mov %edx,0x8(%eax)
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
10f10e: 31 c0 xor %eax,%eax
10f110: c9 leave
10f111: c3 ret
10f112: 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;
10f114: 8b 51 08 mov 0x8(%ecx),%edx
10f117: 89 50 08 mov %edx,0x8(%eax)
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
10f11a: 31 c0 xor %eax,%eax
10f11c: c9 leave
10f11d: c3 ret
10f11e: 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;
10f120: c7 40 08 80 18 12 00 movl $0x121880,0x8(%eax)
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
10f127: 31 c0 xor %eax,%eax
10f129: c9 leave
10f12a: c3 ret
10f12b: 90 nop
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_FIFO:
loc->handlers = fs_info->fifo_handlers;
10f12c: 8b 51 10 mov 0x10(%ecx),%edx
10f12f: 89 50 08 mov %edx,0x8(%eax)
break;
}
return 0;
}
10f132: 31 c0 xor %eax,%eax
10f134: c9 leave
10f135: c3 ret
10f136: 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;
10f138: c7 40 08 00 18 12 00 movl $0x121800,0x8(%eax)
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
10f13f: 31 c0 xor %eax,%eax
10f141: c9 leave
10f142: c3 ret
0010fa60 <IMFS_check_node_remove>:
void IMFS_check_node_remove( IMFS_jnode_t *jnode )
{
10fa60: 55 push %ebp
10fa61: 89 e5 mov %esp,%ebp
10fa63: 53 push %ebx
10fa64: 83 ec 10 sub $0x10,%esp
10fa67: 8b 5d 08 mov 0x8(%ebp),%ebx
if ( !rtems_libio_is_file_open( jnode ) && jnode->st_nlink < 1 ) {
10fa6a: 53 push %ebx
10fa6b: e8 f8 04 00 00 call 10ff68 <rtems_libio_is_file_open>
10fa70: 83 c4 10 add $0x10,%esp
10fa73: 85 c0 test %eax,%eax
10fa75: 75 2d jne 10faa4 <IMFS_check_node_remove+0x44>
10fa77: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx)
10fa7c: 75 26 jne 10faa4 <IMFS_check_node_remove+0x44>
if ( rtems_filesystem_current.node_access == jnode )
10fa7e: a1 90 59 12 00 mov 0x125990,%eax
10fa83: 39 58 04 cmp %ebx,0x4(%eax)
10fa86: 74 58 je 10fae0 <IMFS_check_node_remove+0x80>
rtems_filesystem_current.node_access = NULL;
switch ( jnode->type ) {
10fa88: 8b 43 4c mov 0x4c(%ebx),%eax
10fa8b: 83 f8 04 cmp $0x4,%eax
10fa8e: 74 34 je 10fac4 <IMFS_check_node_remove+0x64>
10fa90: 83 f8 05 cmp $0x5,%eax
10fa93: 74 17 je 10faac <IMFS_check_node_remove+0x4c>
break;
default:
break;
}
free( jnode );
10fa95: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
10fa98: 8b 5d fc mov -0x4(%ebp),%ebx
10fa9b: c9 leave
break;
default:
break;
}
free( jnode );
10fa9c: e9 13 86 ff ff jmp 1080b4 <free>
10faa1: 8d 76 00 lea 0x0(%esi),%esi
}
}
10faa4: 8b 5d fc mov -0x4(%ebp),%ebx
10faa7: c9 leave
10faa8: c3 ret
10faa9: 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 );
10faac: 83 ec 0c sub $0xc,%esp
10faaf: 53 push %ebx
10fab0: e8 cb 23 00 00 call 111e80 <IMFS_memfile_remove>
break;
10fab5: 83 c4 10 add $0x10,%esp
break;
default:
break;
}
free( jnode );
10fab8: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
10fabb: 8b 5d fc mov -0x4(%ebp),%ebx
10fabe: c9 leave
break;
default:
break;
}
free( jnode );
10fabf: e9 f0 85 ff ff jmp 1080b4 <free>
switch ( jnode->type ) {
case IMFS_MEMORY_FILE:
IMFS_memfile_remove( jnode );
break;
case IMFS_SYM_LINK:
free( jnode->info.sym_link.name );
10fac4: 83 ec 0c sub $0xc,%esp
10fac7: ff 73 50 pushl 0x50(%ebx)
10faca: e8 e5 85 ff ff call 1080b4 <free>
break;
10facf: 83 c4 10 add $0x10,%esp
default:
break;
}
free( jnode );
10fad2: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
10fad5: 8b 5d fc mov -0x4(%ebp),%ebx
10fad8: c9 leave
break;
default:
break;
}
free( jnode );
10fad9: e9 d6 85 ff ff jmp 1080b4 <free>
10fade: 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;
10fae0: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
10fae7: eb 9f jmp 10fa88 <IMFS_check_node_remove+0x28>
0010eea8 <IMFS_chown>:
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
10eea8: 55 push %ebp
10eea9: 89 e5 mov %esp,%ebp
10eeab: 57 push %edi
10eeac: 56 push %esi
10eead: 53 push %ebx
10eeae: 83 ec 1c sub $0x1c,%esp
10eeb1: 8b 7d 0c mov 0xc(%ebp),%edi
10eeb4: 8b 75 10 mov 0x10(%ebp),%esi
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = (IMFS_jnode_t *) pathloc->node_access;
10eeb7: 8b 45 08 mov 0x8(%ebp),%eax
10eeba: 8b 18 mov (%eax),%ebx
/*
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
10eebc: e8 bb 0e 00 00 call 10fd7c <geteuid>
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
10eec1: 66 39 43 3c cmp %ax,0x3c(%ebx)
10eec5: 74 05 je 10eecc <IMFS_chown+0x24>
10eec7: 66 85 c0 test %ax,%ax
10eeca: 75 2c jne 10eef8 <IMFS_chown+0x50> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
#endif
jnode->st_uid = owner;
10eecc: 66 89 7b 3c mov %di,0x3c(%ebx)
jnode->st_gid = group;
10eed0: 66 89 73 3e mov %si,0x3e(%ebx)
IMFS_update_ctime( jnode );
10eed4: 83 ec 08 sub $0x8,%esp
10eed7: 6a 00 push $0x0
10eed9: 8d 45 e0 lea -0x20(%ebp),%eax
10eedc: 50 push %eax
10eedd: e8 4e 92 ff ff call 108130 <gettimeofday>
10eee2: 8b 45 e0 mov -0x20(%ebp),%eax
10eee5: 89 43 48 mov %eax,0x48(%ebx)
return 0;
10eee8: 83 c4 10 add $0x10,%esp
10eeeb: 31 c0 xor %eax,%eax
}
10eeed: 8d 65 f4 lea -0xc(%ebp),%esp
10eef0: 5b pop %ebx
10eef1: 5e pop %esi
10eef2: 5f pop %edi
10eef3: c9 leave
10eef4: c3 ret
10eef5: 8d 76 00 lea 0x0(%esi),%esi
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
rtems_set_errno_and_return_minus_one( EPERM );
10eef8: e8 73 43 00 00 call 113270 <__errno>
10eefd: c7 00 01 00 00 00 movl $0x1,(%eax)
10ef03: b8 ff ff ff ff mov $0xffffffff,%eax
10ef08: eb e3 jmp 10eeed <IMFS_chown+0x45>
0010ef7c <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
10ef7c: 55 push %ebp
10ef7d: 89 e5 mov %esp,%ebp
10ef7f: 57 push %edi
10ef80: 56 push %esi
10ef81: 53 push %ebx
10ef82: 83 ec 1c sub $0x1c,%esp
10ef85: 8b 45 08 mov 0x8(%ebp),%eax
10ef88: 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 )
10ef8b: 85 c0 test %eax,%eax
10ef8d: 0f 84 ba 00 00 00 je 10f04d <IMFS_create_node+0xd1> <== NEVER TAKEN
return NULL;
parent = parent_loc->node_access;
10ef93: 8b 38 mov (%eax),%edi
fs_info = parent_loc->mt_entry->fs_info;
10ef95: 8b 40 10 mov 0x10(%eax),%eax
10ef98: 8b 70 34 mov 0x34(%eax),%esi
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
10ef9b: 83 fb 07 cmp $0x7,%ebx
10ef9e: 0f 84 9c 00 00 00 je 10f040 <IMFS_create_node+0xc4>
return NULL;
/*
* Allocate filesystem node and fill in basic information
*/
node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
10efa4: 50 push %eax
10efa5: a1 90 59 12 00 mov 0x125990,%eax
10efaa: 8b 40 2c mov 0x2c(%eax),%eax
10efad: f7 d0 not %eax
10efaf: 23 45 14 and 0x14(%ebp),%eax
10efb2: 50 push %eax
10efb3: ff 75 10 pushl 0x10(%ebp)
10efb6: 53 push %ebx
10efb7: e8 50 ff ff ff call 10ef0c <IMFS_allocate_node>
if ( !node )
10efbc: 83 c4 10 add $0x10,%esp
10efbf: 85 c0 test %eax,%eax
10efc1: 74 73 je 10f036 <IMFS_create_node+0xba>
return NULL;
/*
* Set the type specific information
*/
if ( type == IMFS_DIRECTORY ) {
10efc3: 83 fb 01 cmp $0x1,%ebx
10efc6: 74 38 je 10f000 <IMFS_create_node+0x84>
rtems_chain_initialize_empty(&node->info.directory.Entries);
} else if ( type == IMFS_HARD_LINK ) {
10efc8: 83 fb 03 cmp $0x3,%ebx
10efcb: 0f 84 97 00 00 00 je 10f068 <IMFS_create_node+0xec>
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
10efd1: 83 fb 04 cmp $0x4,%ebx
10efd4: 0f 84 8e 00 00 00 je 10f068 <IMFS_create_node+0xec>
node->info.sym_link.name = info->sym_link.name;
} else if ( type == IMFS_DEVICE ) {
10efda: 83 fb 02 cmp $0x2,%ebx
10efdd: 74 79 je 10f058 <IMFS_create_node+0xdc>
node->info.device.major = info->device.major;
node->info.device.minor = info->device.minor;
} else if ( type == IMFS_LINEAR_FILE ) {
10efdf: 83 fb 06 cmp $0x6,%ebx
10efe2: 0f 84 8c 00 00 00 je 10f074 <IMFS_create_node+0xf8>
node->info.linearfile.size = 0;
node->info.linearfile.direct = 0;
} else if ( type == IMFS_MEMORY_FILE ) {
10efe8: 83 fb 05 cmp $0x5,%ebx
10efeb: 0f 84 9b 00 00 00 je 10f08c <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 ) {
10eff1: 83 fb 07 cmp $0x7,%ebx
10eff4: 75 1d jne 10f013 <IMFS_create_node+0x97> <== NEVER TAKEN
node->info.fifo.pipe = NULL;
10eff6: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
10effd: eb 14 jmp 10f013 <IMFS_create_node+0x97>
10efff: 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 );
10f000: 8d 50 54 lea 0x54(%eax),%edx
10f003: 89 50 50 mov %edx,0x50(%eax)
head->next = tail;
head->previous = NULL;
10f006: 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 );
10f00d: 8d 50 50 lea 0x50(%eax),%edx
10f010: 89 50 58 mov %edx,0x58(%eax)
}
/*
* This node MUST have a parent, so put it in that directory list.
*/
node->Parent = parent;
10f013: 89 78 08 mov %edi,0x8(%eax)
node->st_ino = ++fs_info->ino_count;
10f016: 8b 56 04 mov 0x4(%esi),%edx
10f019: 42 inc %edx
10f01a: 89 56 04 mov %edx,0x4(%esi)
10f01d: 89 50 38 mov %edx,0x38(%eax)
10f020: 83 ec 08 sub $0x8,%esp
10f023: 50 push %eax
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
10f024: 83 c7 50 add $0x50,%edi
10f027: 57 push %edi
10f028: 89 45 e4 mov %eax,-0x1c(%ebp)
10f02b: e8 a8 cf ff ff call 10bfd8 <_Chain_Append>
return node;
10f030: 83 c4 10 add $0x10,%esp
10f033: 8b 45 e4 mov -0x1c(%ebp),%eax
}
10f036: 8d 65 f4 lea -0xc(%ebp),%esp
10f039: 5b pop %ebx
10f03a: 5e pop %esi
10f03b: 5f pop %edi
10f03c: c9 leave
10f03d: c3 ret
10f03e: 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 &&
10f040: 81 7e 10 60 17 12 00 cmpl $0x121760,0x10(%esi)
10f047: 0f 85 57 ff ff ff jne 10efa4 <IMFS_create_node+0x28>
fs_info->fifo_handlers == &rtems_filesystem_handlers_default )
return NULL;
10f04d: 31 c0 xor %eax,%eax
node->st_ino = ++fs_info->ino_count;
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
return node;
}
10f04f: 8d 65 f4 lea -0xc(%ebp),%esp
10f052: 5b pop %ebx
10f053: 5e pop %esi
10f054: 5f pop %edi
10f055: c9 leave
10f056: c3 ret
10f057: 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;
10f058: 8b 4d 18 mov 0x18(%ebp),%ecx
10f05b: 8b 11 mov (%ecx),%edx
10f05d: 89 50 50 mov %edx,0x50(%eax)
node->info.device.minor = info->device.minor;
10f060: 8b 51 04 mov 0x4(%ecx),%edx
10f063: 89 50 54 mov %edx,0x54(%eax)
10f066: eb ab jmp 10f013 <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;
10f068: 8b 4d 18 mov 0x18(%ebp),%ecx
10f06b: 8b 11 mov (%ecx),%edx
10f06d: 89 50 50 mov %edx,0x50(%eax)
10f070: eb a1 jmp 10f013 <IMFS_create_node+0x97>
10f072: 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;
10f074: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
10f07b: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.linearfile.direct = 0;
10f082: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
10f089: eb 88 jmp 10f013 <IMFS_create_node+0x97>
10f08b: 90 nop
} else if ( type == IMFS_MEMORY_FILE ) {
node->info.file.size = 0;
10f08c: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
10f093: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.file.indirect = 0;
10f09a: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
node->info.file.doubly_indirect = 0;
10f0a1: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
node->info.file.triply_indirect = 0;
10f0a8: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
10f0af: e9 5f ff ff ff jmp 10f013 <IMFS_create_node+0x97>
0010a4e8 <IMFS_dump_directory>:
*/
void IMFS_dump_directory(
IMFS_jnode_t *the_directory,
int level
)
{
10a4e8: 55 push %ebp
10a4e9: 89 e5 mov %esp,%ebp
10a4eb: 57 push %edi
10a4ec: 56 push %esi
10a4ed: 53 push %ebx
10a4ee: 83 ec 1c sub $0x1c,%esp
10a4f1: 8b 45 08 mov 0x8(%ebp),%eax
10a4f4: 8b 75 0c mov 0xc(%ebp),%esi
*
*/
int IMFS_memfile_maximum_size( void )
{
return IMFS_MEMFILE_MAXIMUM_SIZE;
}
10a4f7: 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));
10a4fa: 83 c0 54 add $0x54,%eax
10a4fd: 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 );
10a500: 39 c7 cmp %eax,%edi
10a502: 74 47 je 10a54b <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 );
10a504: 8d 46 01 lea 0x1(%esi),%eax
10a507: 89 45 e0 mov %eax,-0x20(%ebp)
10a50a: 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++ )
10a50c: 85 f6 test %esi,%esi
10a50e: 78 22 js 10a532 <IMFS_dump_directory+0x4a><== NEVER TAKEN
10a510: 31 db xor %ebx,%ebx
10a512: 66 90 xchg %ax,%ax
fprintf(stdout, "...." );
10a514: a1 20 c4 12 00 mov 0x12c420,%eax
10a519: ff 70 08 pushl 0x8(%eax)
10a51c: 6a 04 push $0x4
10a51e: 6a 01 push $0x1
10a520: 68 92 71 12 00 push $0x127192
10a525: e8 96 e0 00 00 call 1185c0 <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++ )
10a52a: 43 inc %ebx
10a52b: 83 c4 10 add $0x10,%esp
10a52e: 39 de cmp %ebx,%esi
10a530: 7d e2 jge 10a514 <IMFS_dump_directory+0x2c>
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
10a532: 83 ec 0c sub $0xc,%esp
10a535: 57 push %edi
10a536: e8 75 fe ff ff call 10a3b0 <IMFS_print_jnode>
if ( the_jnode->type == IMFS_DIRECTORY )
10a53b: 83 c4 10 add $0x10,%esp
10a53e: 83 7f 4c 01 cmpl $0x1,0x4c(%edi)
10a542: 74 10 je 10a554 <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 ) {
10a544: 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 );
10a546: 3b 7d e4 cmp -0x1c(%ebp),%edi
10a549: 75 c1 jne 10a50c <IMFS_dump_directory+0x24>
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( the_jnode->type == IMFS_DIRECTORY )
IMFS_dump_directory( the_jnode, level + 1 );
}
}
10a54b: 8d 65 f4 lea -0xc(%ebp),%esp
10a54e: 5b pop %ebx
10a54f: 5e pop %esi
10a550: 5f pop %edi
10a551: c9 leave
10a552: c3 ret
10a553: 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 );
10a554: 83 ec 08 sub $0x8,%esp
10a557: ff 75 e0 pushl -0x20(%ebp)
10a55a: 57 push %edi
10a55b: e8 88 ff ff ff call 10a4e8 <IMFS_dump_directory>
10a560: 83 c4 10 add $0x10,%esp
10a563: eb df jmp 10a544 <IMFS_dump_directory+0x5c>
0010f1f4 <IMFS_eval_path>:
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
10f1f4: 55 push %ebp
10f1f5: 89 e5 mov %esp,%ebp
10f1f7: 57 push %edi
10f1f8: 56 push %esi
10f1f9: 53 push %ebx
10f1fa: 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 ) ) {
10f1fd: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp)
10f204: 0f 85 ee 01 00 00 jne 10f3f8 <IMFS_eval_path+0x204> <== NEVER TAKEN
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
10f20a: 8b 45 14 mov 0x14(%ebp),%eax
10f20d: 8b 38 mov (%eax),%edi
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
int i = 0;
10f20f: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp)
10f216: 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 );
10f219: 8d 55 e4 lea -0x1c(%ebp),%edx
10f21c: 52 push %edx
10f21d: 56 push %esi
10f21e: ff 75 0c pushl 0xc(%ebp)
10f221: 8b 45 08 mov 0x8(%ebp),%eax
10f224: 03 45 a4 add -0x5c(%ebp),%eax
10f227: 50 push %eax
10f228: e8 17 07 00 00 call 10f944 <IMFS_get_token>
10f22d: 89 c3 mov %eax,%ebx
pathnamelen -= len;
10f22f: 8b 55 e4 mov -0x1c(%ebp),%edx
i += len;
if ( !pathloc->node_access )
10f232: 8b 4d 14 mov 0x14(%ebp),%ecx
10f235: 8b 01 mov (%ecx),%eax
10f237: 83 c4 10 add $0x10,%esp
10f23a: 85 c0 test %eax,%eax
10f23c: 0f 84 e6 00 00 00 je 10f328 <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;
10f242: 29 55 0c sub %edx,0xc(%ebp)
i += len;
10f245: 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 )
10f248: 85 db test %ebx,%ebx
10f24a: 75 44 jne 10f290 <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 ) {
10f24c: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
10f250: 0f 84 26 01 00 00 je 10f37c <IMFS_eval_path+0x188>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
10f256: 83 ec 0c sub $0xc,%esp
10f259: ff 75 14 pushl 0x14(%ebp)
10f25c: e8 87 fe ff ff call 10f0e8 <IMFS_Set_handlers>
10f261: 89 c3 mov %eax,%ebx
10f263: 5a pop %edx
10f264: 59 pop %ecx
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
10f265: ff 75 10 pushl 0x10(%ebp)
10f268: ff 75 14 pushl 0x14(%ebp)
10f26b: e8 d4 fe ff ff call 10f144 <IMFS_evaluate_permission>
10f270: 83 c4 10 add $0x10,%esp
10f273: 85 c0 test %eax,%eax
10f275: 0f 85 d1 00 00 00 jne 10f34c <IMFS_eval_path+0x158>
rtems_set_errno_and_return_minus_one( EACCES );
10f27b: e8 f0 3f 00 00 call 113270 <__errno>
10f280: c7 00 0d 00 00 00 movl $0xd,(%eax)
10f286: bb ff ff ff ff mov $0xffffffff,%ebx
10f28b: e9 bc 00 00 00 jmp 10f34c <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 )
10f290: 83 7f 4c 01 cmpl $0x1,0x4c(%edi)
10f294: 0f 84 be 00 00 00 je 10f358 <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;
10f29a: 89 c7 mov %eax,%edi
switch( type ) {
10f29c: 83 fb 03 cmp $0x3,%ebx
10f29f: 74 1b je 10f2bc <IMFS_eval_path+0xc8>
10f2a1: 83 fb 04 cmp $0x4,%ebx
10f2a4: 0f 84 92 00 00 00 je 10f33c <IMFS_eval_path+0x148>
10f2aa: 83 fb 02 cmp $0x2,%ebx
10f2ad: 74 51 je 10f300 <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) ) {
10f2af: 83 fb 04 cmp $0x4,%ebx
10f2b2: 0f 85 61 ff ff ff jne 10f219 <IMFS_eval_path+0x25> <== ALWAYS TAKEN
10f2b8: eb 92 jmp 10f24c <IMFS_eval_path+0x58> <== NOT EXECUTED
10f2ba: 66 90 xchg %ax,%ax <== NOT EXECUTED
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
10f2bc: 8b 40 4c mov 0x4c(%eax),%eax
10f2bf: 83 f8 03 cmp $0x3,%eax
10f2c2: 0f 84 08 01 00 00 je 10f3d0 <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 ) {
10f2c8: 83 f8 04 cmp $0x4,%eax
10f2cb: 0f 84 51 01 00 00 je 10f422 <IMFS_eval_path+0x22e>
}
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10f2d1: 48 dec %eax
10f2d2: 0f 85 35 01 00 00 jne 10f40d <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 ) {
10f2d8: 8b 47 5c mov 0x5c(%edi),%eax
10f2db: 85 c0 test %eax,%eax
10f2dd: 0f 85 a4 00 00 00 jne 10f387 <IMFS_eval_path+0x193>
}
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10f2e3: 83 ec 08 sub $0x8,%esp
10f2e6: 56 push %esi
10f2e7: 57 push %edi
10f2e8: e8 eb 05 00 00 call 10f8d8 <IMFS_find_match_in_dir>
10f2ed: 89 c7 mov %eax,%edi
if ( !node )
10f2ef: 83 c4 10 add $0x10,%esp
10f2f2: 85 c0 test %eax,%eax
10f2f4: 74 32 je 10f328 <IMFS_eval_path+0x134>
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
10f2f6: 8b 45 14 mov 0x14(%ebp),%eax
10f2f9: 89 38 mov %edi,(%eax)
10f2fb: e9 19 ff ff ff jmp 10f219 <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 )
10f300: 8b 15 90 59 12 00 mov 0x125990,%edx
10f306: 39 42 18 cmp %eax,0x18(%edx)
10f309: 0f 84 0a ff ff ff je 10f219 <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) {
10f30f: 8b 4d 14 mov 0x14(%ebp),%ecx
10f312: 8b 51 10 mov 0x10(%ecx),%edx
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
10f315: 39 42 1c cmp %eax,0x1c(%edx)
10f318: 0f 84 d2 00 00 00 je 10f3f0 <IMFS_eval_path+0x1fc>
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
10f31e: 8b 78 08 mov 0x8(%eax),%edi
10f321: 85 ff test %edi,%edi
10f323: 75 d1 jne 10f2f6 <IMFS_eval_path+0x102>
10f325: 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 );
10f328: e8 43 3f 00 00 call 113270 <__errno>
10f32d: c7 00 02 00 00 00 movl $0x2,(%eax)
10f333: bb ff ff ff ff mov $0xffffffff,%ebx
10f338: eb 12 jmp 10f34c <IMFS_eval_path+0x158>
10f33a: 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 );
10f33c: e8 2f 3f 00 00 call 113270 <__errno>
10f341: c7 00 5b 00 00 00 movl $0x5b,(%eax)
10f347: bb ff ff ff ff mov $0xffffffff,%ebx
if ( !IMFS_evaluate_permission( pathloc, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10f34c: 89 d8 mov %ebx,%eax
10f34e: 8d 65 f4 lea -0xc(%ebp),%esp
10f351: 5b pop %ebx
10f352: 5e pop %esi
10f353: 5f pop %edi
10f354: c9 leave
10f355: c3 ret
10f356: 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 ) )
10f358: 83 ec 08 sub $0x8,%esp
10f35b: 6a 01 push $0x1
10f35d: ff 75 14 pushl 0x14(%ebp)
10f360: e8 df fd ff ff call 10f144 <IMFS_evaluate_permission>
10f365: 83 c4 10 add $0x10,%esp
10f368: 85 c0 test %eax,%eax
10f36a: 0f 84 0b ff ff ff je 10f27b <IMFS_eval_path+0x87>
10f370: 8b 55 14 mov 0x14(%ebp),%edx
10f373: 8b 02 mov (%edx),%eax
10f375: e9 20 ff ff ff jmp 10f29a <IMFS_eval_path+0xa6>
10f37a: 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 ) {
10f37c: 8b 40 5c mov 0x5c(%eax),%eax
10f37f: 85 c0 test %eax,%eax
10f381: 0f 84 cf fe ff ff je 10f256 <IMFS_eval_path+0x62>
newloc = node->info.directory.mt_fs->mt_fs_root;
10f387: 8d 7d d0 lea -0x30(%ebp),%edi
10f38a: 8d 70 1c lea 0x1c(%eax),%esi
10f38d: b9 05 00 00 00 mov $0x5,%ecx
10f392: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*pathloc = newloc;
10f394: 8d 75 d0 lea -0x30(%ebp),%esi
10f397: b1 05 mov $0x5,%cl
10f399: 8b 7d 14 mov 0x14(%ebp),%edi
10f39c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
10f39e: 8b 55 e4 mov -0x1c(%ebp),%edx
10f3a1: 8b 4d 14 mov 0x14(%ebp),%ecx
10f3a4: 8b 41 0c mov 0xc(%ecx),%eax
10f3a7: 51 push %ecx
10f3a8: ff 75 10 pushl 0x10(%ebp)
10f3ab: 8b 4d 0c mov 0xc(%ebp),%ecx
10f3ae: 01 d1 add %edx,%ecx
10f3b0: 51 push %ecx
10f3b1: 8b 4d a4 mov -0x5c(%ebp),%ecx
10f3b4: 29 d1 sub %edx,%ecx
10f3b6: 8b 55 08 mov 0x8(%ebp),%edx
10f3b9: 01 ca add %ecx,%edx
10f3bb: 52 push %edx
10f3bc: ff 10 call *(%eax)
10f3be: 89 c3 mov %eax,%ebx
10f3c0: 83 c4 10 add $0x10,%esp
if ( !IMFS_evaluate_permission( pathloc, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10f3c3: 89 d8 mov %ebx,%eax
10f3c5: 8d 65 f4 lea -0xc(%ebp),%esp
10f3c8: 5b pop %ebx
10f3c9: 5e pop %esi
10f3ca: 5f pop %edi
10f3cb: c9 leave
10f3cc: c3 ret
10f3cd: 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 );
10f3d0: 83 ec 08 sub $0x8,%esp
10f3d3: 6a 00 push $0x0
10f3d5: ff 75 14 pushl 0x14(%ebp)
10f3d8: e8 d3 fd ff ff call 10f1b0 <IMFS_evaluate_hard_link>
node = pathloc->node_access;
10f3dd: 8b 55 14 mov 0x14(%ebp),%edx
10f3e0: 8b 3a mov (%edx),%edi
10f3e2: 8b 47 4c mov 0x4c(%edi),%eax
10f3e5: 83 c4 10 add $0x10,%esp
10f3e8: e9 e4 fe ff ff jmp 10f2d1 <IMFS_eval_path+0xdd>
10f3ed: 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;
10f3f0: 8d 7d d0 lea -0x30(%ebp),%edi
10f3f3: 8d 72 08 lea 0x8(%edx),%esi
10f3f6: eb 95 jmp 10f38d <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 );
10f3f8: e8 73 3e 00 00 call 113270 <__errno> <== NOT EXECUTED
10f3fd: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
10f403: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
10f408: e9 3f ff ff ff jmp 10f34c <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 );
10f40d: e8 5e 3e 00 00 call 113270 <__errno>
10f412: c7 00 14 00 00 00 movl $0x14,(%eax)
10f418: bb ff ff ff ff mov $0xffffffff,%ebx
10f41d: e9 2a ff ff ff jmp 10f34c <IMFS_eval_path+0x158>
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
10f422: 83 ec 08 sub $0x8,%esp
10f425: 6a 00 push $0x0
10f427: ff 75 14 pushl 0x14(%ebp)
10f42a: e8 1d 00 00 00 call 10f44c <IMFS_evaluate_sym_link>
10f42f: 89 c3 mov %eax,%ebx
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
10f431: 8b 4d 14 mov 0x14(%ebp),%ecx
10f434: 8b 39 mov (%ecx),%edi
if ( result == -1 )
10f436: 83 c4 10 add $0x10,%esp
10f439: 83 f8 ff cmp $0xffffffff,%eax
10f43c: 0f 84 0a ff ff ff je 10f34c <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;
10f442: 8b 47 4c mov 0x4c(%edi),%eax
10f445: e9 87 fe ff ff jmp 10f2d1 <IMFS_eval_path+0xdd>
0010f574 <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 */
)
{
10f574: 55 push %ebp
10f575: 89 e5 mov %esp,%ebp
10f577: 57 push %edi
10f578: 56 push %esi
10f579: 53 push %ebx
10f57a: 83 ec 5c sub $0x5c,%esp
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
10f57d: 8b 45 0c mov 0xc(%ebp),%eax
10f580: 8b 18 mov (%eax),%ebx
/*
* Get the path length.
*/
pathlen = strlen( path );
10f582: 31 c0 xor %eax,%eax
10f584: b9 ff ff ff ff mov $0xffffffff,%ecx
10f589: 8b 7d 08 mov 0x8(%ebp),%edi
10f58c: f2 ae repnz scas %es:(%edi),%al
10f58e: f7 d1 not %ecx
10f590: 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;
10f593: 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 );
10f59a: 8d 55 e4 lea -0x1c(%ebp),%edx
10f59d: 52 push %edx
10f59e: 8d 4d af lea -0x51(%ebp),%ecx
10f5a1: 51 push %ecx
10f5a2: 56 push %esi
10f5a3: 8b 45 08 mov 0x8(%ebp),%eax
10f5a6: 03 45 a4 add -0x5c(%ebp),%eax
10f5a9: 50 push %eax
10f5aa: e8 95 03 00 00 call 10f944 <IMFS_get_token>
10f5af: 89 c7 mov %eax,%edi
pathlen -= len;
10f5b1: 8b 55 e4 mov -0x1c(%ebp),%edx
10f5b4: 29 d6 sub %edx,%esi
i += len;
if ( !pathloc->node_access )
10f5b6: 8b 4d 0c mov 0xc(%ebp),%ecx
10f5b9: 8b 01 mov (%ecx),%eax
10f5bb: 83 c4 10 add $0x10,%esp
10f5be: 85 c0 test %eax,%eax
10f5c0: 0f 84 55 01 00 00 je 10f71b <IMFS_evaluate_for_make+0x1a7><== NEVER TAKEN
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
10f5c6: 85 ff test %edi,%edi
10f5c8: 75 1a jne 10f5e4 <IMFS_evaluate_for_make+0x70>
pathloc->node_access = node;
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
10f5ca: e8 a1 3c 00 00 call 113270 <__errno>
10f5cf: c7 00 11 00 00 00 movl $0x11,(%eax)
10f5d5: 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;
}
10f5da: 89 d8 mov %ebx,%eax
10f5dc: 8d 65 f4 lea -0xc(%ebp),%esp
10f5df: 5b pop %ebx
10f5e0: 5e pop %esi
10f5e1: 5f pop %edi
10f5e2: c9 leave
10f5e3: c3 ret
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
10f5e4: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10f5e8: 0f 84 c6 00 00 00 je 10f6b4 <IMFS_evaluate_for_make+0x140>
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
i += len;
10f5ee: 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;
10f5f1: 89 c3 mov %eax,%ebx
switch( type ) {
10f5f3: 83 ff 02 cmp $0x2,%edi
10f5f6: 0f 84 88 00 00 00 je 10f684 <IMFS_evaluate_for_make+0x110>
10f5fc: 76 26 jbe 10f624 <IMFS_evaluate_for_make+0xb0>
10f5fe: 83 ff 03 cmp $0x3,%edi
10f601: 74 2d je 10f630 <IMFS_evaluate_for_make+0xbc>
10f603: 83 ff 04 cmp $0x4,%edi
10f606: 75 92 jne 10f59a <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 );
10f608: e8 63 3c 00 00 call 113270 <__errno>
10f60d: c7 00 5b 00 00 00 movl $0x5b,(%eax)
10f613: 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;
}
10f618: 89 d8 mov %ebx,%eax
10f61a: 8d 65 f4 lea -0xc(%ebp),%esp
10f61d: 5b pop %ebx
10f61e: 5e pop %esi
10f61f: 5f pop %edi
10f620: c9 leave
10f621: c3 ret
10f622: 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 ) {
10f624: 85 ff test %edi,%edi
10f626: 74 a2 je 10f5ca <IMFS_evaluate_for_make+0x56><== NEVER TAKEN
10f628: e9 6d ff ff ff jmp 10f59a <IMFS_evaluate_for_make+0x26>
10f62d: 8d 76 00 lea 0x0(%esi),%esi
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
10f630: 8b 40 4c mov 0x4c(%eax),%eax
10f633: 83 f8 03 cmp $0x3,%eax
10f636: 0f 84 b4 01 00 00 je 10f7f0 <IMFS_evaluate_for_make+0x27c>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
10f63c: 83 f8 04 cmp $0x4,%eax
10f63f: 0f 84 ca 01 00 00 je 10f80f <IMFS_evaluate_for_make+0x29b>
if ( result == -1 )
return -1;
}
node = pathloc->node_access;
if ( !node )
10f645: 85 db test %ebx,%ebx
10f647: 0f 84 67 01 00 00 je 10f7b4 <IMFS_evaluate_for_make+0x240><== NEVER TAKEN
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10f64d: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10f651: 0f 85 5d 01 00 00 jne 10f7b4 <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 ) {
10f657: 8b 43 5c mov 0x5c(%ebx),%eax
10f65a: 85 c0 test %eax,%eax
10f65c: 0f 85 67 01 00 00 jne 10f7c9 <IMFS_evaluate_for_make+0x255>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10f662: 83 ec 08 sub $0x8,%esp
10f665: 8d 45 af lea -0x51(%ebp),%eax
10f668: 50 push %eax
10f669: 53 push %ebx
10f66a: e8 69 02 00 00 call 10f8d8 <IMFS_find_match_in_dir>
10f66f: 89 c3 mov %eax,%ebx
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
10f671: 83 c4 10 add $0x10,%esp
10f674: 85 c0 test %eax,%eax
10f676: 74 64 je 10f6dc <IMFS_evaluate_for_make+0x168>
done = true;
else
pathloc->node_access = node;
10f678: 8b 55 0c mov 0xc(%ebp),%edx
10f67b: 89 02 mov %eax,(%edx)
10f67d: e9 18 ff ff ff jmp 10f59a <IMFS_evaluate_for_make+0x26>
10f682: 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 )
10f684: 8b 15 90 59 12 00 mov 0x125990,%edx
10f68a: 3b 42 18 cmp 0x18(%edx),%eax
10f68d: 0f 84 07 ff ff ff je 10f59a <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){
10f693: 8b 4d 0c mov 0xc(%ebp),%ecx
10f696: 8b 51 10 mov 0x10(%ecx),%edx
10f699: 3b 42 1c cmp 0x1c(%edx),%eax
10f69c: 0f 84 8e 00 00 00 je 10f730 <IMFS_evaluate_for_make+0x1bc>
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
10f6a2: 8b 58 08 mov 0x8(%eax),%ebx
10f6a5: 85 db test %ebx,%ebx
10f6a7: 74 72 je 10f71b <IMFS_evaluate_for_make+0x1a7>
rtems_set_errno_and_return_minus_one( ENOENT );
node = node->Parent;
}
pathloc->node_access = node;
10f6a9: 8b 4d 0c mov 0xc(%ebp),%ecx
10f6ac: 89 19 mov %ebx,(%ecx)
break;
10f6ae: e9 e7 fe ff ff jmp 10f59a <IMFS_evaluate_for_make+0x26>
10f6b3: 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 ) )
10f6b4: 83 ec 08 sub $0x8,%esp
10f6b7: 6a 01 push $0x1
10f6b9: ff 75 0c pushl 0xc(%ebp)
10f6bc: 89 55 a0 mov %edx,-0x60(%ebp)
10f6bf: e8 80 fa ff ff call 10f144 <IMFS_evaluate_permission>
10f6c4: 83 c4 10 add $0x10,%esp
10f6c7: 85 c0 test %eax,%eax
10f6c9: 8b 55 a0 mov -0x60(%ebp),%edx
10f6cc: 0f 84 cd 00 00 00 je 10f79f <IMFS_evaluate_for_make+0x22b>
10f6d2: 8b 4d 0c mov 0xc(%ebp),%ecx
10f6d5: 8b 01 mov (%ecx),%eax
10f6d7: e9 12 ff ff ff jmp 10f5ee <IMFS_evaluate_for_make+0x7a>
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
10f6dc: 8b 45 a4 mov -0x5c(%ebp),%eax
10f6df: 2b 45 e4 sub -0x1c(%ebp),%eax
10f6e2: 03 45 08 add 0x8(%ebp),%eax
10f6e5: 8b 4d 10 mov 0x10(%ebp),%ecx
10f6e8: 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++) {
10f6ea: 8b 4d 08 mov 0x8(%ebp),%ecx
10f6ed: 8b 55 a4 mov -0x5c(%ebp),%edx
10f6f0: 8a 04 11 mov (%ecx,%edx,1),%al
10f6f3: 84 c0 test %al,%al
10f6f5: 74 75 je 10f76c <IMFS_evaluate_for_make+0x1f8>
10f6f7: 89 d3 mov %edx,%ebx
10f6f9: 89 ce mov %ecx,%esi
10f6fb: eb 0b jmp 10f708 <IMFS_evaluate_for_make+0x194>
10f6fd: 8d 76 00 lea 0x0(%esi),%esi
10f700: 43 inc %ebx
10f701: 8a 04 1e mov (%esi,%ebx,1),%al
10f704: 84 c0 test %al,%al
10f706: 74 64 je 10f76c <IMFS_evaluate_for_make+0x1f8>
if ( !IMFS_is_separator( path[ i ] ) )
10f708: 83 ec 0c sub $0xc,%esp
10f70b: 0f be c0 movsbl %al,%eax
10f70e: 50 push %eax
10f70f: e8 04 98 ff ff call 108f18 <rtems_filesystem_is_separator>
10f714: 83 c4 10 add $0x10,%esp
10f717: 85 c0 test %eax,%eax
10f719: 75 e5 jne 10f700 <IMFS_evaluate_for_make+0x18c>
rtems_set_errno_and_return_minus_one( ENOENT );
10f71b: e8 50 3b 00 00 call 113270 <__errno>
10f720: c7 00 02 00 00 00 movl $0x2,(%eax)
10f726: bb ff ff ff ff mov $0xffffffff,%ebx
10f72b: e9 aa fe ff ff jmp 10f5da <IMFS_evaluate_for_make+0x66>
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
10f730: 8d 7d d0 lea -0x30(%ebp),%edi
10f733: 8d 72 08 lea 0x8(%edx),%esi
10f736: b9 05 00 00 00 mov $0x5,%ecx
10f73b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*pathloc = newloc;
10f73d: 8d 75 d0 lea -0x30(%ebp),%esi
10f740: b1 05 mov $0x5,%cl
10f742: 8b 7d 0c mov 0xc(%ebp),%edi
10f745: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
10f747: 53 push %ebx
10f748: 8b 55 0c mov 0xc(%ebp),%edx
10f74b: 8b 42 0c mov 0xc(%edx),%eax
10f74e: ff 75 10 pushl 0x10(%ebp)
10f751: 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 );
10f752: 8b 55 a4 mov -0x5c(%ebp),%edx
10f755: 2b 55 e4 sub -0x1c(%ebp),%edx
10f758: 03 55 08 add 0x8(%ebp),%edx
10f75b: 52 push %edx
10f75c: ff 50 04 call *0x4(%eax)
10f75f: 89 c3 mov %eax,%ebx
10f761: 83 c4 10 add $0x10,%esp
10f764: e9 71 fe ff ff jmp 10f5da <IMFS_evaluate_for_make+0x66>
10f769: 8d 76 00 lea 0x0(%esi),%esi
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
10f76c: 83 ec 0c sub $0xc,%esp
10f76f: ff 75 0c pushl 0xc(%ebp)
10f772: e8 71 f9 ff ff call 10f0e8 <IMFS_Set_handlers>
10f777: 89 c3 mov %eax,%ebx
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
10f779: 8b 55 0c mov 0xc(%ebp),%edx
10f77c: 8b 02 mov (%edx),%eax
10f77e: 83 c4 10 add $0x10,%esp
10f781: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
10f785: 75 2d jne 10f7b4 <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 ) )
10f787: 83 ec 08 sub $0x8,%esp
10f78a: 6a 03 push $0x3
10f78c: ff 75 0c pushl 0xc(%ebp)
10f78f: e8 b0 f9 ff ff call 10f144 <IMFS_evaluate_permission>
10f794: 83 c4 10 add $0x10,%esp
10f797: 85 c0 test %eax,%eax
10f799: 0f 85 3b fe ff ff jne 10f5da <IMFS_evaluate_for_make+0x66>
rtems_set_errno_and_return_minus_one( EACCES );
10f79f: e8 cc 3a 00 00 call 113270 <__errno>
10f7a4: c7 00 0d 00 00 00 movl $0xd,(%eax)
10f7aa: bb ff ff ff ff mov $0xffffffff,%ebx
10f7af: e9 26 fe ff ff jmp 10f5da <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 );
10f7b4: e8 b7 3a 00 00 call 113270 <__errno>
10f7b9: c7 00 14 00 00 00 movl $0x14,(%eax)
10f7bf: bb ff ff ff ff mov $0xffffffff,%ebx
10f7c4: e9 11 fe ff ff jmp 10f5da <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;
10f7c9: 8d 7d d0 lea -0x30(%ebp),%edi
10f7cc: 8d 70 1c lea 0x1c(%eax),%esi
10f7cf: b9 05 00 00 00 mov $0x5,%ecx
10f7d4: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*pathloc = newloc;
10f7d6: 8d 75 d0 lea -0x30(%ebp),%esi
10f7d9: b1 05 mov $0x5,%cl
10f7db: 8b 7d 0c mov 0xc(%ebp),%edi
10f7de: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
10f7e0: 51 push %ecx
10f7e1: 8b 4d 0c mov 0xc(%ebp),%ecx
10f7e4: 8b 41 0c mov 0xc(%ecx),%eax
10f7e7: ff 75 10 pushl 0x10(%ebp)
10f7ea: 51 push %ecx
10f7eb: e9 62 ff ff ff jmp 10f752 <IMFS_evaluate_for_make+0x1de>
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
10f7f0: 83 ec 08 sub $0x8,%esp
10f7f3: 6a 00 push $0x0
10f7f5: ff 75 0c pushl 0xc(%ebp)
10f7f8: e8 cb fc ff ff call 10f4c8 <IMFS_evaluate_link>
if ( result == -1 )
10f7fd: 83 c4 10 add $0x10,%esp
10f800: 83 f8 ff cmp $0xffffffff,%eax
10f803: 74 29 je 10f82e <IMFS_evaluate_for_make+0x2ba><== NEVER TAKEN
10f805: 8b 45 0c mov 0xc(%ebp),%eax
10f808: 8b 18 mov (%eax),%ebx
10f80a: e9 36 fe ff ff jmp 10f645 <IMFS_evaluate_for_make+0xd1>
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
10f80f: 83 ec 08 sub $0x8,%esp
10f812: 6a 00 push $0x0
10f814: ff 75 0c pushl 0xc(%ebp)
10f817: e8 ac fc ff ff call 10f4c8 <IMFS_evaluate_link>
if ( result == -1 )
10f81c: 83 c4 10 add $0x10,%esp
10f81f: 83 f8 ff cmp $0xffffffff,%eax
10f822: 74 0a je 10f82e <IMFS_evaluate_for_make+0x2ba><== NEVER TAKEN
10f824: 8b 55 0c mov 0xc(%ebp),%edx
10f827: 8b 1a mov (%edx),%ebx
10f829: e9 17 fe ff ff jmp 10f645 <IMFS_evaluate_for_make+0xd1>
10f82e: 89 c3 mov %eax,%ebx <== NOT EXECUTED
10f830: e9 a5 fd ff ff jmp 10f5da <IMFS_evaluate_for_make+0x66><== NOT EXECUTED
0010f4c8 <IMFS_evaluate_link>:
*/
int IMFS_evaluate_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
10f4c8: 55 push %ebp
10f4c9: 89 e5 mov %esp,%ebp
10f4cb: 57 push %edi
10f4cc: 56 push %esi
10f4cd: 53 push %ebx
10f4ce: 83 ec 0c sub $0xc,%esp
10f4d1: 8b 75 08 mov 0x8(%ebp),%esi
10f4d4: 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 );
10f4d7: 8b 15 90 59 12 00 mov 0x125990,%edx
10f4dd: eb 0e jmp 10f4ed <IMFS_evaluate_link+0x25>
10f4df: 90 nop
*/
if ( jnode->type == IMFS_HARD_LINK )
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
10f4e0: 83 f8 04 cmp $0x4,%eax
10f4e3: 74 53 je 10f538 <IMFS_evaluate_link+0x70>
result = IMFS_evaluate_sym_link( node, flags );
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
10f4e5: 83 e8 03 sub $0x3,%eax
10f4e8: 83 f8 01 cmp $0x1,%eax
10f4eb: 77 3a ja 10f527 <IMFS_evaluate_link+0x5f><== ALWAYS TAKEN
{
IMFS_jnode_t *jnode;
int result = 0;
do {
jnode = node->node_access;
10f4ed: 8b 1e mov (%esi),%ebx
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
10f4ef: 8b 42 30 mov 0x30(%edx),%eax
10f4f2: 40 inc %eax
10f4f3: 66 89 42 30 mov %ax,0x30(%edx)
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
10f4f7: 66 83 f8 05 cmp $0x5,%ax
10f4fb: 77 57 ja 10f554 <IMFS_evaluate_link+0x8c>
/*
* Follow the Link node.
*/
if ( jnode->type == IMFS_HARD_LINK )
10f4fd: 8b 43 4c mov 0x4c(%ebx),%eax
10f500: 83 f8 03 cmp $0x3,%eax
10f503: 75 db jne 10f4e0 <IMFS_evaluate_link+0x18>
result = IMFS_evaluate_hard_link( node, flags );
10f505: 83 ec 08 sub $0x8,%esp
10f508: 57 push %edi
10f509: 56 push %esi
10f50a: e8 a1 fc ff ff call 10f1b0 <IMFS_evaluate_hard_link>
10f50f: 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 ) ) );
10f512: 85 c0 test %eax,%eax
10f514: 75 33 jne 10f549 <IMFS_evaluate_link+0x81>
10f516: 8b 43 4c mov 0x4c(%ebx),%eax
10f519: 8b 15 90 59 12 00 mov 0x125990,%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 ) ||
10f51f: 83 e8 03 sub $0x3,%eax
10f522: 83 f8 01 cmp $0x1,%eax
10f525: 76 c6 jbe 10f4ed <IMFS_evaluate_link+0x25><== ALWAYS TAKEN
10f527: 31 c0 xor %eax,%eax
/*
* Clear link counter.
*/
rtems_filesystem_link_counts = 0;
10f529: 66 c7 42 30 00 00 movw $0x0,0x30(%edx)
return result;
}
10f52f: 8d 65 f4 lea -0xc(%ebp),%esp
10f532: 5b pop %ebx
10f533: 5e pop %esi
10f534: 5f pop %edi
10f535: c9 leave
10f536: c3 ret
10f537: 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 );
10f538: 83 ec 08 sub $0x8,%esp
10f53b: 57 push %edi
10f53c: 56 push %esi
10f53d: e8 0a ff ff ff call 10f44c <IMFS_evaluate_sym_link>
10f542: 83 c4 10 add $0x10,%esp
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
( jnode->type == IMFS_HARD_LINK ) ) );
10f545: 85 c0 test %eax,%eax
10f547: 74 cd je 10f516 <IMFS_evaluate_link+0x4e>
10f549: 8b 15 90 59 12 00 mov 0x125990,%edx
10f54f: eb d8 jmp 10f529 <IMFS_evaluate_link+0x61>
10f551: 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;
10f554: 66 c7 42 30 00 00 movw $0x0,0x30(%edx)
rtems_set_errno_and_return_minus_one( ELOOP );
10f55a: e8 11 3d 00 00 call 113270 <__errno>
10f55f: c7 00 5c 00 00 00 movl $0x5c,(%eax)
10f565: b8 ff ff ff ff mov $0xffffffff,%eax
*/
rtems_filesystem_link_counts = 0;
return result;
}
10f56a: 8d 65 f4 lea -0xc(%ebp),%esp
10f56d: 5b pop %ebx
10f56e: 5e pop %esi
10f56f: 5f pop %edi
10f570: c9 leave
10f571: c3 ret
0010f144 <IMFS_evaluate_permission>:
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
10f144: 55 push %ebp
10f145: 89 e5 mov %esp,%ebp
10f147: 57 push %edi
10f148: 56 push %esi
10f149: 53 push %ebx
10f14a: 83 ec 0c sub $0xc,%esp
10f14d: 8b 75 0c mov 0xc(%ebp),%esi
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
10f150: f7 c6 f8 ff ff ff test $0xfffffff8,%esi
10f156: 75 44 jne 10f19c <IMFS_evaluate_permission+0x58><== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
jnode = node->node_access;
10f158: 8b 45 08 mov 0x8(%ebp),%eax
10f15b: 8b 18 mov (%eax),%ebx
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
10f15d: e8 1a 0c 00 00 call 10fd7c <geteuid>
10f162: 89 c7 mov %eax,%edi
st_gid = getegid();
10f164: e8 03 0c 00 00 call 10fd6c <getegid>
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
10f169: 66 39 7b 3c cmp %di,0x3c(%ebx)
10f16d: 74 1d je 10f18c <IMFS_evaluate_permission+0x48>
flags_to_test <<= 6;
else if ( st_gid == jnode->st_gid )
10f16f: 66 39 43 3e cmp %ax,0x3e(%ebx)
10f173: 74 1f je 10f194 <IMFS_evaluate_permission+0x50><== ALWAYS TAKEN
/*
* If all of the flags are set we have permission
* to do this.
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
10f175: 8b 43 30 mov 0x30(%ebx),%eax
10f178: 21 f0 and %esi,%eax
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 );
10f17a: 39 c6 cmp %eax,%esi
10f17c: 0f 94 c0 sete %al
10f17f: 0f b6 c0 movzbl %al,%eax
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
return 1;
return 0;
}
10f182: 83 c4 0c add $0xc,%esp
10f185: 5b pop %ebx
10f186: 5e pop %esi
10f187: 5f pop %edi
10f188: c9 leave
10f189: c3 ret
10f18a: 66 90 xchg %ax,%ax
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
flags_to_test <<= 6;
10f18c: c1 e6 06 shl $0x6,%esi
10f18f: eb e4 jmp 10f175 <IMFS_evaluate_permission+0x31>
10f191: 8d 76 00 lea 0x0(%esi),%esi
else if ( st_gid == jnode->st_gid )
flags_to_test <<= 3;
10f194: c1 e6 03 shl $0x3,%esi
10f197: eb dc jmp 10f175 <IMFS_evaluate_permission+0x31>
10f199: 8d 76 00 lea 0x0(%esi),%esi
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 );
10f19c: e8 cf 40 00 00 call 113270 <__errno> <== NOT EXECUTED
10f1a1: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
10f1a7: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10f1ac: eb d4 jmp 10f182 <IMFS_evaluate_permission+0x3e><== NOT EXECUTED
0010f44c <IMFS_evaluate_sym_link>:
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
10f44c: 55 push %ebp
10f44d: 89 e5 mov %esp,%ebp
10f44f: 57 push %edi
10f450: 56 push %esi
10f451: 53 push %ebx
10f452: 83 ec 20 sub $0x20,%esp
10f455: 8b 5d 08 mov 0x8(%ebp),%ebx
10f458: 8b 75 0c mov 0xc(%ebp),%esi
IMFS_jnode_t *jnode = node->node_access;
10f45b: 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;
10f45d: 8b 47 08 mov 0x8(%edi),%eax
10f460: 89 03 mov %eax,(%ebx)
rtems_filesystem_get_sym_start_loc(
10f462: 53 push %ebx
10f463: 8d 45 e4 lea -0x1c(%ebp),%eax
10f466: 50 push %eax
10f467: ff 77 50 pushl 0x50(%edi)
10f46a: e8 f9 0d 00 00 call 110268 <rtems_filesystem_get_sym_start_loc>
);
/*
* Use eval path to evaluate the path of the symbolic link.
*/
result = IMFS_eval_path(
10f46f: 8b 57 50 mov 0x50(%edi),%edx
10f472: 03 55 e4 add -0x1c(%ebp),%edx
10f475: 31 c0 xor %eax,%eax
10f477: b9 ff ff ff ff mov $0xffffffff,%ecx
10f47c: 89 d7 mov %edx,%edi
10f47e: f2 ae repnz scas %es:(%edi),%al
10f480: f7 d1 not %ecx
10f482: 49 dec %ecx
10f483: 53 push %ebx
10f484: 56 push %esi
10f485: 51 push %ecx
10f486: 52 push %edx
10f487: e8 68 fd ff ff call 10f1f4 <IMFS_eval_path>
10f48c: 89 c7 mov %eax,%edi
strlen( &jnode->info.sym_link.name[i] ),
flags,
node
);
IMFS_Set_handlers( node );
10f48e: 83 c4 14 add $0x14,%esp
10f491: 53 push %ebx
10f492: e8 51 fc ff ff call 10f0e8 <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
10f497: 58 pop %eax
10f498: 5a pop %edx
10f499: 56 push %esi
10f49a: 53 push %ebx
10f49b: e8 a4 fc ff ff call 10f144 <IMFS_evaluate_permission>
10f4a0: 83 c4 10 add $0x10,%esp
10f4a3: 85 c0 test %eax,%eax
10f4a5: 74 0d je 10f4b4 <IMFS_evaluate_sym_link+0x68>
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10f4a7: 89 f8 mov %edi,%eax
10f4a9: 8d 65 f4 lea -0xc(%ebp),%esp
10f4ac: 5b pop %ebx
10f4ad: 5e pop %esi
10f4ae: 5f pop %edi
10f4af: c9 leave
10f4b0: c3 ret
10f4b1: 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 );
10f4b4: e8 b7 3d 00 00 call 113270 <__errno>
10f4b9: c7 00 0d 00 00 00 movl $0xd,(%eax)
10f4bf: bf ff ff ff ff mov $0xffffffff,%edi
10f4c4: eb e1 jmp 10f4a7 <IMFS_evaluate_sym_link+0x5b>
001129f0 <IMFS_fchmod>:
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
1129f0: 55 push %ebp
1129f1: 89 e5 mov %esp,%ebp
1129f3: 53 push %ebx
1129f4: 83 ec 14 sub $0x14,%esp
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = loc->node_access;
1129f7: 8b 45 08 mov 0x8(%ebp),%eax
1129fa: 8b 18 mov (%eax),%ebx
/*
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
1129fc: e8 7b d3 ff ff call 10fd7c <geteuid>
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
112a01: 66 39 43 3c cmp %ax,0x3c(%ebx)
112a05: 74 05 je 112a0c <IMFS_fchmod+0x1c>
112a07: 66 85 c0 test %ax,%ax
112a0a: 75 34 jne 112a40 <IMFS_fchmod+0x50> <== ALWAYS TAKEN
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
112a0c: 8b 45 0c mov 0xc(%ebp),%eax
112a0f: 25 ff 0f 00 00 and $0xfff,%eax
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
112a14: 8b 53 30 mov 0x30(%ebx),%edx
112a17: 81 e2 00 f0 ff ff and $0xfffff000,%edx
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
112a1d: 09 d0 or %edx,%eax
112a1f: 89 43 30 mov %eax,0x30(%ebx)
IMFS_update_ctime( jnode );
112a22: 83 ec 08 sub $0x8,%esp
112a25: 6a 00 push $0x0
112a27: 8d 45 f0 lea -0x10(%ebp),%eax
112a2a: 50 push %eax
112a2b: e8 00 57 ff ff call 108130 <gettimeofday>
112a30: 8b 45 f0 mov -0x10(%ebp),%eax
112a33: 89 43 48 mov %eax,0x48(%ebx)
return 0;
112a36: 83 c4 10 add $0x10,%esp
112a39: 31 c0 xor %eax,%eax
}
112a3b: 8b 5d fc mov -0x4(%ebp),%ebx
112a3e: c9 leave
112a3f: c3 ret
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
rtems_set_errno_and_return_minus_one( EPERM );
112a40: e8 2b 08 00 00 call 113270 <__errno>
112a45: c7 00 01 00 00 00 movl $0x1,(%eax)
112a4b: b8 ff ff ff ff mov $0xffffffff,%eax
112a50: eb e9 jmp 112a3b <IMFS_fchmod+0x4b>
00108a84 <IMFS_fifo_ioctl>:
int IMFS_fifo_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
108a84: 55 push %ebp
108a85: 89 e5 mov %esp,%ebp
108a87: 53 push %ebx
108a88: 83 ec 04 sub $0x4,%esp
108a8b: 8b 45 08 mov 0x8(%ebp),%eax
108a8e: 8b 55 0c mov 0xc(%ebp),%edx
108a91: 8b 4d 10 mov 0x10(%ebp),%ecx
int err;
if (command == FIONBIO) {
108a94: 81 fa 7e 66 04 80 cmp $0x8004667e,%edx
108a9a: 74 1c je 108ab8 <IMFS_fifo_ioctl+0x34>
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
return 0;
}
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
108a9c: 50 push %eax
108a9d: 51 push %ecx
108a9e: 52 push %edx
108a9f: 8b 40 18 mov 0x18(%eax),%eax
108aa2: ff 70 50 pushl 0x50(%eax)
108aa5: e8 26 98 00 00 call 1122d0 <pipe_ioctl>
IMFS_FIFO_RETURN(err);
108aaa: 83 c4 10 add $0x10,%esp
108aad: 85 c0 test %eax,%eax
108aaf: 78 3e js 108aef <IMFS_fifo_ioctl+0x6b>
}
108ab1: 8b 5d fc mov -0x4(%ebp),%ebx
108ab4: c9 leave
108ab5: c3 ret
108ab6: 66 90 xchg %ax,%ax
)
{
int err;
if (command == FIONBIO) {
if (buffer == NULL)
108ab8: 85 c9 test %ecx,%ecx
108aba: 74 20 je 108adc <IMFS_fifo_ioctl+0x58>
err = -EFAULT;
else {
if (*(int *)buffer)
108abc: 8b 11 mov (%ecx),%edx
108abe: 85 d2 test %edx,%edx
108ac0: 74 0e je 108ad0 <IMFS_fifo_ioctl+0x4c>
iop->flags |= LIBIO_FLAGS_NO_DELAY;
108ac2: 83 48 14 01 orl $0x1,0x14(%eax)
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
return 0;
108ac6: 31 c0 xor %eax,%eax
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
IMFS_FIFO_RETURN(err);
}
108ac8: 8b 5d fc mov -0x4(%ebp),%ebx
108acb: c9 leave
108acc: c3 ret
108acd: 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;
108ad0: 83 60 14 fe andl $0xfffffffe,0x14(%eax)
return 0;
108ad4: 31 c0 xor %eax,%eax
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
IMFS_FIFO_RETURN(err);
}
108ad6: 8b 5d fc mov -0x4(%ebp),%ebx
108ad9: c9 leave
108ada: c3 ret
108adb: 90 nop
)
{
int err;
if (command == FIONBIO) {
if (buffer == NULL)
108adc: bb 0e 00 00 00 mov $0xe,%ebx
}
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
IMFS_FIFO_RETURN(err);
108ae1: e8 82 c9 00 00 call 115468 <__errno>
108ae6: 89 18 mov %ebx,(%eax)
108ae8: b8 ff ff ff ff mov $0xffffffff,%eax
108aed: eb c2 jmp 108ab1 <IMFS_fifo_ioctl+0x2d>
108aef: 89 c3 mov %eax,%ebx
108af1: f7 db neg %ebx
108af3: eb ec jmp 108ae1 <IMFS_fifo_ioctl+0x5d>
00108a40 <IMFS_fifo_lseek>:
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
108a40: 55 push %ebp
108a41: 89 e5 mov %esp,%ebp
108a43: 53 push %ebx
108a44: 83 ec 10 sub $0x10,%esp
108a47: 8b 45 08 mov 0x8(%ebp),%eax
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
108a4a: 50 push %eax
108a4b: ff 75 14 pushl 0x14(%ebp)
108a4e: ff 75 10 pushl 0x10(%ebp)
108a51: ff 75 0c pushl 0xc(%ebp)
108a54: 8b 40 18 mov 0x18(%eax),%eax
108a57: ff 70 50 pushl 0x50(%eax)
108a5a: e8 d1 98 00 00 call 112330 <pipe_lseek>
108a5f: 89 c3 mov %eax,%ebx
108a61: 99 cltd
IMFS_FIFO_RETURN(err);
108a62: 83 c4 20 add $0x20,%esp
108a65: 85 d2 test %edx,%edx
108a67: 78 05 js 108a6e <IMFS_fifo_lseek+0x2e> <== ALWAYS TAKEN
}
108a69: 8b 5d fc mov -0x4(%ebp),%ebx
108a6c: c9 leave
108a6d: c3 ret
rtems_off64_t offset,
int whence
)
{
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
IMFS_FIFO_RETURN(err);
108a6e: e8 f5 c9 00 00 call 115468 <__errno>
108a73: f7 db neg %ebx
108a75: 89 18 mov %ebx,(%eax)
108a77: b8 ff ff ff ff mov $0xffffffff,%eax
108a7c: ba ff ff ff ff mov $0xffffffff,%edx
108a81: eb e6 jmp 108a69 <IMFS_fifo_lseek+0x29>
00108af8 <IMFS_fifo_write>:
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
108af8: 55 push %ebp
108af9: 89 e5 mov %esp,%ebp
108afb: 56 push %esi
108afc: 53 push %ebx
108afd: 83 ec 10 sub $0x10,%esp
108b00: 8b 45 08 mov 0x8(%ebp),%eax
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
108b03: 8b 58 18 mov 0x18(%eax),%ebx
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
108b06: 50 push %eax
108b07: ff 75 10 pushl 0x10(%ebp)
108b0a: ff 75 0c pushl 0xc(%ebp)
108b0d: ff 73 50 pushl 0x50(%ebx)
108b10: e8 bb 95 00 00 call 1120d0 <pipe_write>
108b15: 89 c6 mov %eax,%esi
if (err > 0) {
108b17: 83 c4 10 add $0x10,%esp
108b1a: 83 f8 00 cmp $0x0,%eax
108b1d: 7e 25 jle 108b44 <IMFS_fifo_write+0x4c>
IMFS_mtime_ctime_update(jnode);
108b1f: 83 ec 08 sub $0x8,%esp
108b22: 6a 00 push $0x0
108b24: 8d 45 f0 lea -0x10(%ebp),%eax
108b27: 50 push %eax
108b28: e8 3f 0f 00 00 call 109a6c <gettimeofday>
108b2d: 8b 45 f0 mov -0x10(%ebp),%eax
108b30: 89 43 44 mov %eax,0x44(%ebx)
108b33: 89 43 48 mov %eax,0x48(%ebx)
108b36: 83 c4 10 add $0x10,%esp
108b39: 89 f0 mov %esi,%eax
}
IMFS_FIFO_RETURN(err);
}
108b3b: 8d 65 f8 lea -0x8(%ebp),%esp
108b3e: 5b pop %ebx
108b3f: 5e pop %esi
108b40: c9 leave
108b41: c3 ret
108b42: 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);
108b44: 75 09 jne 108b4f <IMFS_fifo_write+0x57> <== ALWAYS TAKEN
108b46: 31 c0 xor %eax,%eax
}
108b48: 8d 65 f8 lea -0x8(%ebp),%esp
108b4b: 5b pop %ebx <== NOT EXECUTED
108b4c: 5e pop %esi <== NOT EXECUTED
108b4d: c9 leave <== NOT EXECUTED
108b4e: 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);
108b4f: e8 14 c9 00 00 call 115468 <__errno>
108b54: f7 de neg %esi
108b56: 89 30 mov %esi,(%eax)
108b58: b8 ff ff ff ff mov $0xffffffff,%eax
108b5d: eb dc jmp 108b3b <IMFS_fifo_write+0x43>
0010f8d8 <IMFS_find_match_in_dir>:
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
10f8d8: 55 push %ebp
10f8d9: 89 e5 mov %esp,%ebp
10f8db: 57 push %edi
10f8dc: 56 push %esi
10f8dd: 53 push %ebx
10f8de: 83 ec 0c sub $0xc,%esp
10f8e1: 8b 45 08 mov 0x8(%ebp),%eax
10f8e4: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
10f8e7: bf f0 17 12 00 mov $0x1217f0,%edi
10f8ec: b9 02 00 00 00 mov $0x2,%ecx
10f8f1: 89 de mov %ebx,%esi
10f8f3: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10f8f5: 74 13 je 10f90a <IMFS_find_match_in_dir+0x32><== NEVER TAKEN
return directory;
if ( !strcmp( name, dotdotname ) )
10f8f7: bf f2 17 12 00 mov $0x1217f2,%edi
10f8fc: b9 03 00 00 00 mov $0x3,%ecx
10f901: 89 de mov %ebx,%esi
10f903: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10f905: 75 0d jne 10f914 <IMFS_find_match_in_dir+0x3c><== ALWAYS TAKEN
return directory->Parent;
10f907: 8b 40 08 mov 0x8(%eax),%eax
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
10f90a: 8d 65 f4 lea -0xc(%ebp),%esp
10f90d: 5b pop %ebx
10f90e: 5e pop %esi
10f90f: 5f pop %edi
10f910: c9 leave
10f911: c3 ret
10f912: 66 90 xchg %ax,%ax
10f914: 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));
10f917: 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 );
10f91a: 39 fe cmp %edi,%esi
10f91c: 75 08 jne 10f926 <IMFS_find_match_in_dir+0x4e>
10f91e: eb 20 jmp 10f940 <IMFS_find_match_in_dir+0x68>
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
10f920: 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 );
10f922: 39 fe cmp %edi,%esi
10f924: 74 1a je 10f940 <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 ) )
10f926: 8d 46 0c lea 0xc(%esi),%eax
10f929: 83 ec 08 sub $0x8,%esp
10f92c: 50 push %eax
10f92d: 53 push %ebx
10f92e: e8 a9 45 00 00 call 113edc <strcmp>
10f933: 83 c4 10 add $0x10,%esp
10f936: 85 c0 test %eax,%eax
10f938: 75 e6 jne 10f920 <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;
10f93a: 89 f0 mov %esi,%eax
10f93c: eb cc jmp 10f90a <IMFS_find_match_in_dir+0x32>
10f93e: 66 90 xchg %ax,%ax
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
10f940: 31 c0 xor %eax,%eax
10f942: eb c6 jmp 10f90a <IMFS_find_match_in_dir+0x32>
0010f838 <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
)
{
10f838: 55 push %ebp
10f839: 89 e5 mov %esp,%ebp
10f83b: 57 push %edi
10f83c: 56 push %esi
10f83d: 53 push %ebx
10f83e: 83 ec 3c sub $0x3c,%esp
10f841: 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;
10f844: 8b 58 1c mov 0x1c(%eax),%ebx
loc = temp_mt_entry->mt_fs_root;
10f847: 8d 55 d4 lea -0x2c(%ebp),%edx
10f84a: 89 55 c4 mov %edx,-0x3c(%ebp)
10f84d: 8d 70 1c lea 0x1c(%eax),%esi
10f850: b9 05 00 00 00 mov $0x5,%ecx
10f855: 89 d7 mov %edx,%edi
10f857: 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;
10f859: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
do {
next = jnode->Parent;
10f860: 8b 73 08 mov 0x8(%ebx),%esi
loc.node_access = (void *)jnode;
10f863: 89 5d d4 mov %ebx,-0x2c(%ebp)
IMFS_Set_handlers( &loc );
10f866: 83 ec 0c sub $0xc,%esp
10f869: 8d 45 d4 lea -0x2c(%ebp),%eax
10f86c: 50 push %eax
10f86d: e8 76 f8 ff ff call 10f0e8 <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
10f872: 83 c4 10 add $0x10,%esp
10f875: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10f879: 75 31 jne 10f8ac <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 );
10f87b: 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 ) ) {
10f87e: 39 43 50 cmp %eax,0x50(%ebx)
10f881: 74 42 je 10f8c5 <IMFS_fsunmount+0x8d>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
}
if ( jnode != NULL ) {
10f883: 85 db test %ebx,%ebx
10f885: 74 19 je 10f8a0 <IMFS_fsunmount+0x68>
if ( jnode->type == IMFS_DIRECTORY ) {
10f887: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10f88b: 75 d3 jne 10f860 <IMFS_fsunmount+0x28> <== NEVER TAKEN
}
}
} while (jnode != NULL);
return 0;
}
10f88d: 8b 43 50 mov 0x50(%ebx),%eax
10f890: 8d 53 54 lea 0x54(%ebx),%edx
return -1;
jnode = next;
}
if ( jnode != NULL ) {
if ( jnode->type == IMFS_DIRECTORY ) {
if ( jnode_has_children( jnode ) )
10f893: 39 d0 cmp %edx,%eax
10f895: 74 c9 je 10f860 <IMFS_fsunmount+0x28>
jnode = jnode_get_first_child( jnode );
10f897: 89 c3 mov %eax,%ebx
}
}
} while (jnode != NULL);
10f899: 85 c0 test %eax,%eax
10f89b: 75 c3 jne 10f860 <IMFS_fsunmount+0x28> <== ALWAYS TAKEN
10f89d: 8d 76 00 lea 0x0(%esi),%esi
return 0;
10f8a0: 31 c0 xor %eax,%eax
}
10f8a2: 8d 65 f4 lea -0xc(%ebp),%esp
10f8a5: 5b pop %ebx
10f8a6: 5e pop %esi
10f8a7: 5f pop %edi
10f8a8: c9 leave
10f8a9: c3 ret
10f8aa: 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 );
10f8ac: 83 ec 08 sub $0x8,%esp
10f8af: 8d 55 d4 lea -0x2c(%ebp),%edx
10f8b2: 52 push %edx
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
10f8b3: 6a 00 push $0x0
10f8b5: e8 42 83 ff ff call 107bfc <IMFS_unlink>
if (result != 0)
10f8ba: 83 c4 10 add $0x10,%esp
10f8bd: 85 c0 test %eax,%eax
10f8bf: 75 0d jne 10f8ce <IMFS_fsunmount+0x96> <== NEVER TAKEN
return -1;
jnode = next;
10f8c1: 89 f3 mov %esi,%ebx
10f8c3: eb be jmp 10f883 <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 );
10f8c5: 83 ec 08 sub $0x8,%esp
10f8c8: 8d 45 d4 lea -0x2c(%ebp),%eax
10f8cb: 50 push %eax
10f8cc: eb e5 jmp 10f8b3 <IMFS_fsunmount+0x7b>
if (result != 0)
return -1;
10f8ce: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10f8d3: eb cd jmp 10f8a2 <IMFS_fsunmount+0x6a> <== NOT EXECUTED
0010f944 <IMFS_get_token>:
const char *path,
int pathlen,
char *token,
int *token_len
)
{
10f944: 55 push %ebp
10f945: 89 e5 mov %esp,%ebp
10f947: 57 push %edi
10f948: 56 push %esi
10f949: 53 push %ebx
10f94a: 83 ec 1c sub $0x1c,%esp
10f94d: 8b 7d 08 mov 0x8(%ebp),%edi
10f950: 8b 5d 10 mov 0x10(%ebp),%ebx
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
10f953: 8a 17 mov (%edi),%dl
int pathlen,
char *token,
int *token_len
)
{
register int i = 0;
10f955: 31 f6 xor %esi,%esi
10f957: 89 7d e4 mov %edi,-0x1c(%ebp)
10f95a: 89 df mov %ebx,%edi
10f95c: 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) ) {
10f95e: eb 07 jmp 10f967 <IMFS_get_token+0x23>
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
10f960: 46 inc %esi
10f961: 8b 45 e4 mov -0x1c(%ebp),%eax
10f964: 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) ) {
10f967: 83 ec 0c sub $0xc,%esp
10f96a: 0f be c3 movsbl %bl,%eax
10f96d: 50 push %eax
10f96e: e8 a5 95 ff ff call 108f18 <rtems_filesystem_is_separator>
10f973: 83 c4 10 add $0x10,%esp
10f976: 85 c0 test %eax,%eax
10f978: 75 1a jne 10f994 <IMFS_get_token+0x50>
10f97a: 3b 75 0c cmp 0xc(%ebp),%esi
10f97d: 7d 15 jge 10f994 <IMFS_get_token+0x50>
token[i] = c;
10f97f: 88 1c 37 mov %bl,(%edi,%esi,1)
if ( i == IMFS_NAME_MAX )
10f982: 83 fe 20 cmp $0x20,%esi
10f985: 75 d9 jne 10f960 <IMFS_get_token+0x1c>
return IMFS_INVALID_TOKEN;
10f987: b8 04 00 00 00 mov $0x4,%eax
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
}
return type;
}
10f98c: 8d 65 f4 lea -0xc(%ebp),%esp
10f98f: 5b pop %ebx
10f990: 5e pop %esi
10f991: 5f pop %edi
10f992: c9 leave
10f993: c3 ret
10f994: 88 da mov %bl,%dl
10f996: 89 fb mov %edi,%ebx
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
10f998: 85 f6 test %esi,%esi
10f99a: 75 25 jne 10f9c1 <IMFS_get_token+0x7d>
token[i] = c;
10f99c: 88 17 mov %dl,(%edi)
if ( (token[i] != '\0') && pathlen ) {
10f99e: 84 d2 test %dl,%dl
10f9a0: 74 16 je 10f9b8 <IMFS_get_token+0x74>
10f9a2: 8b 45 0c mov 0xc(%ebp),%eax
10f9a5: 85 c0 test %eax,%eax
10f9a7: 74 0f je 10f9b8 <IMFS_get_token+0x74>
i++;
type = IMFS_CURRENT_DIR;
10f9a9: b8 01 00 00 00 mov $0x1,%eax
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
10f9ae: be 01 00 00 00 mov $0x1,%esi
10f9b3: eb 05 jmp 10f9ba <IMFS_get_token+0x76>
10f9b5: 8d 76 00 lea 0x0(%esi),%esi
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
10f9b8: 31 c0 xor %eax,%eax
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
10f9ba: 8b 55 14 mov 0x14(%ebp),%edx
10f9bd: 89 32 mov %esi,(%edx)
10f9bf: eb cb jmp 10f98c <IMFS_get_token+0x48>
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
10f9c1: 80 7c 37 ff 00 cmpb $0x0,-0x1(%edi,%esi,1)
10f9c6: 74 04 je 10f9cc <IMFS_get_token+0x88> <== NEVER TAKEN
token[i] = '\0';
10f9c8: c6 04 37 00 movb $0x0,(%edi,%esi,1)
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
10f9cc: 8b 45 14 mov 0x14(%ebp),%eax
10f9cf: 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 )
10f9d1: bf f5 17 12 00 mov $0x1217f5,%edi
10f9d6: b9 03 00 00 00 mov $0x3,%ecx
10f9db: 89 de mov %ebx,%esi
10f9dd: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10f9df: 75 0f jne 10f9f0 <IMFS_get_token+0xac>
type = IMFS_UP_DIR;
10f9e1: b8 02 00 00 00 mov $0x2,%eax
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
}
return type;
}
10f9e6: 8d 65 f4 lea -0xc(%ebp),%esp
10f9e9: 5b pop %ebx
10f9ea: 5e pop %esi
10f9eb: 5f pop %edi
10f9ec: c9 leave
10f9ed: c3 ret
10f9ee: 66 90 xchg %ax,%ax
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
10f9f0: bf f6 17 12 00 mov $0x1217f6,%edi
10f9f5: b9 02 00 00 00 mov $0x2,%ecx
10f9fa: 89 de mov %ebx,%esi
10f9fc: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10f9fe: 0f 97 c0 seta %al
10fa01: 0f 92 c2 setb %dl
10fa04: 28 d0 sub %dl,%al
10fa06: 0f be c0 movsbl %al,%eax
10fa09: 83 f8 01 cmp $0x1,%eax
10fa0c: 19 c0 sbb %eax,%eax
10fa0e: 83 e0 fe and $0xfffffffe,%eax
10fa11: 83 c0 03 add $0x3,%eax
type = IMFS_CURRENT_DIR;
}
return type;
}
10fa14: 8d 65 f4 lea -0xc(%ebp),%esp
10fa17: 5b pop %ebx
10fa18: 5e pop %esi
10fa19: 5f pop %edi
10fa1a: c9 leave
10fa1b: c3 ret
00107844 <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
)
{
107844: 55 push %ebp
107845: 89 e5 mov %esp,%ebp
107847: 57 push %edi
107848: 56 push %esi
107849: 53 push %ebx
10784a: 83 ec 1c sub $0x1c,%esp
10784d: 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,
107850: 8b 0d 70 39 12 00 mov 0x123970,%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) {
107856: 83 f9 10 cmp $0x10,%ecx
107859: 74 1f je 10787a <IMFS_initialize_support+0x36>
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
10785b: 83 f9 0f cmp $0xf,%ecx
10785e: 7e 15 jle 107875 <IMFS_initialize_support+0x31>
107860: ba 05 00 00 00 mov $0x5,%edx
107865: 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) {
10786a: 39 c1 cmp %eax,%ecx
10786c: 74 0c je 10787a <IMFS_initialize_support+0x36>
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
10786e: 7c 05 jl 107875 <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) {
107870: d1 e0 shl %eax
107872: 4a dec %edx
107873: 75 f5 jne 10786a <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);
107875: b9 80 00 00 00 mov $0x80,%ecx
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
10787a: 89 0d e0 78 12 00 mov %ecx,0x1278e0
/*
* 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();
107880: e8 2f 78 00 00 call 10f0b4 <IMFS_create_root_node>
107885: 89 c2 mov %eax,%edx
107887: 89 43 1c mov %eax,0x1c(%ebx)
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
10788a: 8b 45 14 mov 0x14(%ebp),%eax
10788d: 89 43 24 mov %eax,0x24(%ebx)
temp_mt_entry->mt_fs_root.ops = op_table;
107890: 8b 45 0c mov 0xc(%ebp),%eax
107893: 89 43 28 mov %eax,0x28(%ebx)
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
107896: 8d 7b 38 lea 0x38(%ebx),%edi
107899: be a0 17 12 00 mov $0x1217a0,%esi
10789e: b9 0c 00 00 00 mov $0xc,%ecx
1078a3: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
1078a5: 83 ec 08 sub $0x8,%esp
1078a8: 6a 14 push $0x14
1078aa: 6a 01 push $0x1
1078ac: 89 55 e4 mov %edx,-0x1c(%ebp)
1078af: e8 70 06 00 00 call 107f24 <calloc>
if ( !fs_info ) {
1078b4: 83 c4 10 add $0x10,%esp
1078b7: 85 c0 test %eax,%eax
1078b9: 8b 55 e4 mov -0x1c(%ebp),%edx
1078bc: 74 3c je 1078fa <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;
1078be: 89 43 34 mov %eax,0x34(%ebx)
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
1078c1: 8b 0d e4 78 12 00 mov 0x1278e4,%ecx
1078c7: 89 08 mov %ecx,(%eax)
1078c9: 41 inc %ecx
1078ca: 89 0d e4 78 12 00 mov %ecx,0x1278e4
fs_info->ino_count = 1;
1078d0: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
fs_info->memfile_handlers = memfile_handlers;
1078d7: 8b 4d 10 mov 0x10(%ebp),%ecx
1078da: 89 48 08 mov %ecx,0x8(%eax)
fs_info->directory_handlers = directory_handlers;
1078dd: 8b 4d 14 mov 0x14(%ebp),%ecx
1078e0: 89 48 0c mov %ecx,0xc(%eax)
fs_info->fifo_handlers = fifo_handlers;
1078e3: 8b 4d 18 mov 0x18(%ebp),%ecx
1078e6: 89 48 10 mov %ecx,0x10(%eax)
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
1078e9: c7 42 38 01 00 00 00 movl $0x1,0x38(%edx)
return 0;
1078f0: 31 c0 xor %eax,%eax
}
1078f2: 8d 65 f4 lea -0xc(%ebp),%esp
1078f5: 5b pop %ebx
1078f6: 5e pop %esi
1078f7: 5f pop %edi
1078f8: c9 leave
1078f9: 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);
1078fa: 83 ec 0c sub $0xc,%esp
1078fd: 52 push %edx
1078fe: e8 b1 07 00 00 call 1080b4 <free>
rtems_set_errno_and_return_minus_one(ENOMEM);
107903: e8 68 b9 00 00 call 113270 <__errno>
107908: c7 00 0c 00 00 00 movl $0xc,(%eax)
10790e: 83 c4 10 add $0x10,%esp
107911: 83 c8 ff or $0xffffffff,%eax
107914: eb dc jmp 1078f2 <IMFS_initialize_support+0xae>
00107918 <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 */
)
{
107918: 55 push %ebp
107919: 89 e5 mov %esp,%ebp
10791b: 57 push %edi
10791c: 53 push %ebx
10791d: 83 ec 50 sub $0x50,%esp
107920: 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;
107923: 8b 45 08 mov 0x8(%ebp),%eax
107926: 8b 00 mov (%eax),%eax
107928: 89 45 d8 mov %eax,-0x28(%ebp)
if ( info.hard_link.link_node->st_nlink >= LINK_MAX )
10792b: 66 83 78 34 07 cmpw $0x7,0x34(%eax)
107930: 77 66 ja 107998 <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 );
107932: 31 c0 xor %eax,%eax
107934: b9 ff ff ff ff mov $0xffffffff,%ecx
107939: 89 d7 mov %edx,%edi
10793b: f2 ae repnz scas %es:(%edi),%al
10793d: f7 d1 not %ecx
10793f: 49 dec %ecx
107940: 8d 45 f4 lea -0xc(%ebp),%eax
107943: 50 push %eax
107944: 8d 5d b7 lea -0x49(%ebp),%ebx
107947: 53 push %ebx
107948: 51 push %ecx
107949: 52 push %edx
10794a: e8 f5 7f 00 00 call 10f944 <IMFS_get_token>
new_node = IMFS_create_node(
parent_loc,
IMFS_HARD_LINK,
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
10794f: 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(
107952: 89 04 24 mov %eax,(%esp)
107955: 68 ff a1 00 00 push $0xa1ff
10795a: 53 push %ebx
10795b: 6a 03 push $0x3
10795d: ff 75 0c pushl 0xc(%ebp)
107960: e8 17 76 00 00 call 10ef7c <IMFS_create_node>
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if ( !new_node )
107965: 83 c4 20 add $0x20,%esp
107968: 85 c0 test %eax,%eax
10796a: 74 3e je 1079aa <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++;
10796c: 8b 45 d8 mov -0x28(%ebp),%eax
10796f: 66 ff 40 34 incw 0x34(%eax)
IMFS_update_ctime( info.hard_link.link_node );
107973: 83 ec 08 sub $0x8,%esp
107976: 6a 00 push $0x0
107978: 8d 45 ec lea -0x14(%ebp),%eax
10797b: 50 push %eax
10797c: e8 af 07 00 00 call 108130 <gettimeofday>
107981: 8b 55 ec mov -0x14(%ebp),%edx
107984: 8b 45 d8 mov -0x28(%ebp),%eax
107987: 89 50 48 mov %edx,0x48(%eax)
return 0;
10798a: 83 c4 10 add $0x10,%esp
10798d: 31 c0 xor %eax,%eax
}
10798f: 8d 65 f8 lea -0x8(%ebp),%esp
107992: 5b pop %ebx
107993: 5f pop %edi
107994: c9 leave
107995: c3 ret
107996: 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 );
107998: e8 d3 b8 00 00 call 113270 <__errno>
10799d: c7 00 1f 00 00 00 movl $0x1f,(%eax)
1079a3: b8 ff ff ff ff mov $0xffffffff,%eax
1079a8: eb e5 jmp 10798f <IMFS_link+0x77>
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if ( !new_node )
rtems_set_errno_and_return_minus_one( ENOMEM );
1079aa: e8 c1 b8 00 00 call 113270 <__errno>
1079af: c7 00 0c 00 00 00 movl $0xc,(%eax)
1079b5: b8 ff ff ff ff mov $0xffffffff,%eax
1079ba: eb d3 jmp 10798f <IMFS_link+0x77>
00111dc8 <IMFS_memfile_addblock>:
*/
MEMFILE_STATIC int IMFS_memfile_addblock(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
111dc8: 55 push %ebp
111dc9: 89 e5 mov %esp,%ebp
111dcb: 53 push %ebx
111dcc: 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 );
111dcf: 6a 01 push $0x1
111dd1: ff 75 0c pushl 0xc(%ebp)
111dd4: ff 75 08 pushl 0x8(%ebp)
111dd7: e8 28 fc ff ff call 111a04 <IMFS_memfile_get_block_pointer>
111ddc: 89 c3 mov %eax,%ebx
if ( *block_entry_ptr )
111dde: 83 c4 10 add $0x10,%esp
111de1: 8b 00 mov (%eax),%eax
111de3: 85 c0 test %eax,%eax
111de5: 74 09 je 111df0 <IMFS_memfile_addblock+0x28>
return 0;
111de7: 31 c0 xor %eax,%eax
if ( !memory )
return 1;
*block_entry_ptr = memory;
return 0;
}
111de9: 8b 5d fc mov -0x4(%ebp),%ebx
111dec: c9 leave
111ded: c3 ret
111dee: 66 90 xchg %ax,%ax
return 0;
/*
* There is no memory for this block number so allocate it.
*/
memory = memfile_alloc_block();
111df0: e8 eb fb ff ff call 1119e0 <memfile_alloc_block>
if ( !memory )
111df5: 85 c0 test %eax,%eax
111df7: 74 07 je 111e00 <IMFS_memfile_addblock+0x38>
return 1;
*block_entry_ptr = memory;
111df9: 89 03 mov %eax,(%ebx)
return 0;
111dfb: 31 c0 xor %eax,%eax
111dfd: eb ea jmp 111de9 <IMFS_memfile_addblock+0x21>
111dff: 90 nop
/*
* There is no memory for this block number so allocate it.
*/
memory = memfile_alloc_block();
if ( !memory )
return 1;
111e00: b8 01 00 00 00 mov $0x1,%eax
111e05: eb e2 jmp 111de9 <IMFS_memfile_addblock+0x21>
00112008 <IMFS_memfile_extend>:
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
112008: 55 push %ebp
112009: 89 e5 mov %esp,%ebp
11200b: 57 push %edi
11200c: 56 push %esi
11200d: 53 push %ebx
11200e: 83 ec 2c sub $0x2c,%esp
112011: 8b 5d 08 mov 0x8(%ebp),%ebx
112014: 8b 45 0c mov 0xc(%ebp),%eax
112017: 8b 55 10 mov 0x10(%ebp),%edx
11201a: 89 45 d8 mov %eax,-0x28(%ebp)
11201d: 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 )
112020: a1 e0 78 12 00 mov 0x1278e0,%eax
112025: 89 c1 mov %eax,%ecx
112027: c1 e9 02 shr $0x2,%ecx
11202a: 8d 51 01 lea 0x1(%ecx),%edx
11202d: 0f af d1 imul %ecx,%edx
112030: 42 inc %edx
112031: 0f af d1 imul %ecx,%edx
112034: 4a dec %edx
112035: 0f af d0 imul %eax,%edx
112038: 31 c9 xor %ecx,%ecx
11203a: 3b 4d dc cmp -0x24(%ebp),%ecx
11203d: 7f 1a jg 112059 <IMFS_memfile_extend+0x51><== NEVER TAKEN
11203f: 7d 13 jge 112054 <IMFS_memfile_extend+0x4c><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
112041: e8 2a 12 00 00 call 113270 <__errno>
112046: c7 00 16 00 00 00 movl $0x16,(%eax)
11204c: b8 ff ff ff ff mov $0xffffffff,%eax
112051: eb 19 jmp 11206c <IMFS_memfile_extend+0x64>
112053: 90 nop
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
112054: 3b 55 d8 cmp -0x28(%ebp),%edx
112057: 76 e8 jbe 112041 <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 )
112059: 8b 53 50 mov 0x50(%ebx),%edx
11205c: 8b 4b 54 mov 0x54(%ebx),%ecx
11205f: 89 55 e0 mov %edx,-0x20(%ebp)
112062: 89 4d e4 mov %ecx,-0x1c(%ebp)
112065: 39 4d dc cmp %ecx,-0x24(%ebp)
112068: 7d 0a jge 112074 <IMFS_memfile_extend+0x6c><== ALWAYS TAKEN
return 0;
11206a: 31 c0 xor %eax,%eax
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
return 0;
}
11206c: 8d 65 f4 lea -0xc(%ebp),%esp
11206f: 5b pop %ebx
112070: 5e pop %esi
112071: 5f pop %edi
112072: c9 leave
112073: 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 )
112074: 7f 05 jg 11207b <IMFS_memfile_extend+0x73><== NEVER TAKEN
112076: 39 55 d8 cmp %edx,-0x28(%ebp)
112079: 76 ef jbe 11206a <IMFS_memfile_extend+0x62>
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
11207b: 89 45 d0 mov %eax,-0x30(%ebp)
11207e: 89 c1 mov %eax,%ecx
112080: c1 f9 1f sar $0x1f,%ecx
112083: 89 4d d4 mov %ecx,-0x2c(%ebp)
112086: ff 75 d4 pushl -0x2c(%ebp)
112089: ff 75 d0 pushl -0x30(%ebp)
11208c: ff 75 dc pushl -0x24(%ebp)
11208f: ff 75 d8 pushl -0x28(%ebp)
112092: e8 d9 c9 00 00 call 11ea70 <__divdi3>
112097: 83 c4 10 add $0x10,%esp
11209a: 89 c6 mov %eax,%esi
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
11209c: ff 75 d4 pushl -0x2c(%ebp)
11209f: ff 75 d0 pushl -0x30(%ebp)
1120a2: ff 75 e4 pushl -0x1c(%ebp)
1120a5: ff 75 e0 pushl -0x20(%ebp)
1120a8: e8 c3 c9 00 00 call 11ea70 <__divdi3>
1120ad: 83 c4 10 add $0x10,%esp
1120b0: 89 45 e0 mov %eax,-0x20(%ebp)
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
1120b3: 39 c6 cmp %eax,%esi
1120b5: 72 51 jb 112108 <IMFS_memfile_extend+0x100><== NEVER TAKEN
1120b7: 89 c7 mov %eax,%edi
1120b9: eb 06 jmp 1120c1 <IMFS_memfile_extend+0xb9>
1120bb: 90 nop
1120bc: 47 inc %edi
1120bd: 39 fe cmp %edi,%esi
1120bf: 72 47 jb 112108 <IMFS_memfile_extend+0x100>
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
1120c1: 83 ec 08 sub $0x8,%esp
1120c4: 57 push %edi
1120c5: 53 push %ebx
1120c6: e8 fd fc ff ff call 111dc8 <IMFS_memfile_addblock>
1120cb: 83 c4 10 add $0x10,%esp
1120ce: 85 c0 test %eax,%eax
1120d0: 74 ea je 1120bc <IMFS_memfile_extend+0xb4>
for ( ; block>=old_blocks ; block-- ) {
1120d2: 39 7d e0 cmp %edi,-0x20(%ebp)
1120d5: 77 17 ja 1120ee <IMFS_memfile_extend+0xe6><== NEVER TAKEN
1120d7: 8b 75 e0 mov -0x20(%ebp),%esi
1120da: 66 90 xchg %ax,%ax
IMFS_memfile_remove_block( the_jnode, block );
1120dc: 83 ec 08 sub $0x8,%esp
1120df: 57 push %edi
1120e0: 53 push %ebx
1120e1: e8 f6 fe ff ff call 111fdc <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-- ) {
1120e6: 4f dec %edi
1120e7: 83 c4 10 add $0x10,%esp
1120ea: 39 fe cmp %edi,%esi
1120ec: 76 ee jbe 1120dc <IMFS_memfile_extend+0xd4>
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
1120ee: e8 7d 11 00 00 call 113270 <__errno>
1120f3: c7 00 1c 00 00 00 movl $0x1c,(%eax)
1120f9: b8 ff ff ff ff mov $0xffffffff,%eax
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
return 0;
}
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
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
112108: 8b 45 d8 mov -0x28(%ebp),%eax
11210b: 8b 55 dc mov -0x24(%ebp),%edx
11210e: 89 43 50 mov %eax,0x50(%ebx)
112111: 89 53 54 mov %edx,0x54(%ebx)
return 0;
112114: 31 c0 xor %eax,%eax
}
112116: 8d 65 f4 lea -0xc(%ebp),%esp
112119: 5b pop %ebx
11211a: 5e pop %esi
11211b: 5f pop %edi
11211c: c9 leave
11211d: c3 ret
00111a04 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
111a04: 55 push %ebp
111a05: 89 e5 mov %esp,%ebp
111a07: 57 push %edi
111a08: 56 push %esi
111a09: 53 push %ebx
111a0a: 83 ec 1c sub $0x1c,%esp
111a0d: 8b 5d 08 mov 0x8(%ebp),%ebx
111a10: 8b 75 0c mov 0xc(%ebp),%esi
111a13: 8b 7d 10 mov 0x10(%ebp),%edi
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
111a16: 8b 0d e0 78 12 00 mov 0x1278e0,%ecx
111a1c: c1 e9 02 shr $0x2,%ecx
111a1f: 8d 41 ff lea -0x1(%ecx),%eax
111a22: 39 c6 cmp %eax,%esi
111a24: 77 1a ja 111a40 <IMFS_memfile_get_block_pointer+0x3c>
p = info->indirect;
111a26: 8b 43 58 mov 0x58(%ebx),%eax
if ( malloc_it ) {
111a29: 85 ff test %edi,%edi
111a2b: 74 53 je 111a80 <IMFS_memfile_get_block_pointer+0x7c>
if ( !p ) {
111a2d: 85 c0 test %eax,%eax
111a2f: 0f 84 b6 00 00 00 je 111aeb <IMFS_memfile_get_block_pointer+0xe7>
}
if ( !p )
return 0;
return &info->indirect[ my_block ];
111a35: 8d 04 b0 lea (%eax,%esi,4),%eax
/*
* This means the requested block number is out of range.
*/
return 0;
}
111a38: 83 c4 1c add $0x1c,%esp
111a3b: 5b pop %ebx
111a3c: 5e pop %esi
111a3d: 5f pop %edi
111a3e: c9 leave
111a3f: c3 ret
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
111a40: 8d 41 01 lea 0x1(%ecx),%eax
111a43: 0f af c1 imul %ecx,%eax
111a46: 8d 50 ff lea -0x1(%eax),%edx
111a49: 39 d6 cmp %edx,%esi
111a4b: 77 3b ja 111a88 <IMFS_memfile_get_block_pointer+0x84>
my_block -= FIRST_DOUBLY_INDIRECT;
111a4d: 29 ce sub %ecx,%esi
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
111a4f: 89 f0 mov %esi,%eax
111a51: 31 d2 xor %edx,%edx
111a53: f7 f1 div %ecx
111a55: 89 c6 mov %eax,%esi
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
p = info->doubly_indirect;
111a57: 8b 43 5c mov 0x5c(%ebx),%eax
if ( malloc_it ) {
111a5a: 85 ff test %edi,%edi
111a5c: 74 7e je 111adc <IMFS_memfile_get_block_pointer+0xd8>
if ( !p ) {
111a5e: 85 c0 test %eax,%eax
111a60: 0f 84 96 00 00 00 je 111afc <IMFS_memfile_get_block_pointer+0xf8>
if ( !p )
return 0;
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
111a66: 8d 1c b0 lea (%eax,%esi,4),%ebx
111a69: 8b 03 mov (%ebx),%eax
if ( !p1 ) {
111a6b: 85 c0 test %eax,%eax
111a6d: 0f 84 a4 00 00 00 je 111b17 <IMFS_memfile_get_block_pointer+0x113>
p = (block_p *)p[ doubly ];
if ( !p )
return 0;
return (block_p *)&p[ singly ];
111a73: 8d 04 90 lea (%eax,%edx,4),%eax
/*
* This means the requested block number is out of range.
*/
return 0;
}
111a76: 83 c4 1c add $0x1c,%esp
111a79: 5b pop %ebx
111a7a: 5e pop %esi
111a7b: 5f pop %edi
111a7c: c9 leave
111a7d: c3 ret
111a7e: 66 90 xchg %ax,%ax
info->indirect = p;
}
return &info->indirect[ my_block ];
}
if ( !p )
111a80: 85 c0 test %eax,%eax
111a82: 75 b1 jne 111a35 <IMFS_memfile_get_block_pointer+0x31><== ALWAYS TAKEN
if ( !p )
return 0;
p1 = (block_p *) p[ triply ];
if ( !p1 )
return 0;
111a84: 31 c0 xor %eax,%eax
111a86: eb ee jmp 111a76 <IMFS_memfile_get_block_pointer+0x72><== NOT EXECUTED
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
111a88: 8d 50 01 lea 0x1(%eax),%edx
111a8b: 0f af d1 imul %ecx,%edx
111a8e: 4a dec %edx
111a8f: 39 d6 cmp %edx,%esi
111a91: 77 f1 ja 111a84 <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
my_block -= FIRST_TRIPLY_INDIRECT;
111a93: 29 c6 sub %eax,%esi
111a95: 89 f0 mov %esi,%eax
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
111a97: 31 d2 xor %edx,%edx
111a99: f7 f1 div %ecx
111a9b: 89 55 e4 mov %edx,-0x1c(%ebp)
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
111a9e: 31 d2 xor %edx,%edx
111aa0: f7 f1 div %ecx
111aa2: 89 c6 mov %eax,%esi
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
p = info->triply_indirect;
111aa4: 8b 4b 60 mov 0x60(%ebx),%ecx
if ( malloc_it ) {
111aa7: 85 ff test %edi,%edi
111aa9: 0f 84 82 00 00 00 je 111b31 <IMFS_memfile_get_block_pointer+0x12d>
if ( !p ) {
111aaf: 85 c9 test %ecx,%ecx
111ab1: 0f 84 9b 00 00 00 je 111b52 <IMFS_memfile_get_block_pointer+0x14e>
if ( !p )
return 0;
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
111ab7: 8d 1c b1 lea (%ecx,%esi,4),%ebx
111aba: 8b 0b mov (%ebx),%ecx
if ( !p1 ) {
111abc: 85 c9 test %ecx,%ecx
111abe: 0f 84 c5 00 00 00 je 111b89 <IMFS_memfile_get_block_pointer+0x185>
if ( !p1 )
return 0;
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
111ac4: 8d 1c 91 lea (%ecx,%edx,4),%ebx
111ac7: 8b 13 mov (%ebx),%edx
if ( !p2 ) {
111ac9: 85 d2 test %edx,%edx
111acb: 0f 84 a0 00 00 00 je 111b71 <IMFS_memfile_get_block_pointer+0x16d>
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
return 0;
return (block_p *)&p2[ singly ];
111ad1: 8b 4d e4 mov -0x1c(%ebp),%ecx
111ad4: 8d 04 8a lea (%edx,%ecx,4),%eax
111ad7: eb 9d jmp 111a76 <IMFS_memfile_get_block_pointer+0x72>
111ad9: 8d 76 00 lea 0x0(%esi),%esi
}
return (block_p *)&p1[ singly ];
}
if ( !p )
111adc: 85 c0 test %eax,%eax
111ade: 74 a4 je 111a84 <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
return 0;
p = (block_p *)p[ doubly ];
111ae0: 8b 04 b0 mov (%eax,%esi,4),%eax
if ( !p )
111ae3: 85 c0 test %eax,%eax
111ae5: 75 8c jne 111a73 <IMFS_memfile_get_block_pointer+0x6f><== ALWAYS TAKEN
if ( !p )
return 0;
p1 = (block_p *) p[ triply ];
if ( !p1 )
return 0;
111ae7: 31 c0 xor %eax,%eax
111ae9: eb 8b jmp 111a76 <IMFS_memfile_get_block_pointer+0x72><== NOT EXECUTED
p = info->indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
111aeb: e8 f0 fe ff ff call 1119e0 <memfile_alloc_block>
if ( !p )
111af0: 85 c0 test %eax,%eax
111af2: 74 90 je 111a84 <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
return 0;
info->indirect = p;
111af4: 89 43 58 mov %eax,0x58(%ebx)
111af7: e9 39 ff ff ff jmp 111a35 <IMFS_memfile_get_block_pointer+0x31>
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
111afc: 89 55 e0 mov %edx,-0x20(%ebp)
111aff: e8 dc fe ff ff call 1119e0 <memfile_alloc_block>
if ( !p )
111b04: 85 c0 test %eax,%eax
111b06: 8b 55 e0 mov -0x20(%ebp),%edx
111b09: 0f 84 75 ff ff ff je 111a84 <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
return 0;
info->doubly_indirect = p;
111b0f: 89 43 5c mov %eax,0x5c(%ebx)
111b12: e9 4f ff ff ff jmp 111a66 <IMFS_memfile_get_block_pointer+0x62>
}
p1 = (block_p *)p[ doubly ];
if ( !p1 ) {
p1 = memfile_alloc_block();
111b17: 89 55 e0 mov %edx,-0x20(%ebp)
111b1a: e8 c1 fe ff ff call 1119e0 <memfile_alloc_block>
if ( !p1 )
111b1f: 85 c0 test %eax,%eax
111b21: 8b 55 e0 mov -0x20(%ebp),%edx
111b24: 0f 84 5a ff ff ff je 111a84 <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
return 0;
p[ doubly ] = (block_p) p1;
111b2a: 89 03 mov %eax,(%ebx)
111b2c: e9 42 ff ff ff jmp 111a73 <IMFS_memfile_get_block_pointer+0x6f>
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
}
if ( !p )
111b31: 85 c9 test %ecx,%ecx
111b33: 0f 84 4b ff ff ff je 111a84 <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
return 0;
p1 = (block_p *) p[ triply ];
111b39: 8b 04 81 mov (%ecx,%eax,4),%eax
if ( !p1 )
111b3c: 85 c0 test %eax,%eax
111b3e: 0f 84 40 ff ff ff je 111a84 <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
return 0;
p2 = (block_p *)p1[ doubly ];
111b44: 8b 14 90 mov (%eax,%edx,4),%edx
if ( !p2 )
return 0;
111b47: 31 c0 xor %eax,%eax
p1 = (block_p *) p[ triply ];
if ( !p1 )
return 0;
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
111b49: 85 d2 test %edx,%edx
111b4b: 75 84 jne 111ad1 <IMFS_memfile_get_block_pointer+0xcd><== ALWAYS TAKEN
111b4d: e9 24 ff ff ff jmp 111a76 <IMFS_memfile_get_block_pointer+0x72><== NOT EXECUTED
p = info->triply_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
111b52: 89 55 e0 mov %edx,-0x20(%ebp)
111b55: e8 86 fe ff ff call 1119e0 <memfile_alloc_block>
111b5a: 89 c1 mov %eax,%ecx
if ( !p )
return 0;
111b5c: 31 c0 xor %eax,%eax
p = info->triply_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
111b5e: 85 c9 test %ecx,%ecx
111b60: 8b 55 e0 mov -0x20(%ebp),%edx
111b63: 0f 84 0d ff ff ff je 111a76 <IMFS_memfile_get_block_pointer+0x72><== NEVER TAKEN
return 0;
info->triply_indirect = p;
111b69: 89 4b 60 mov %ecx,0x60(%ebx)
111b6c: e9 46 ff ff ff jmp 111ab7 <IMFS_memfile_get_block_pointer+0xb3>
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
111b71: e8 6a fe ff ff call 1119e0 <memfile_alloc_block>
111b76: 89 c2 mov %eax,%edx
if ( !p2 )
return 0;
111b78: 31 c0 xor %eax,%eax
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
if ( !p2 )
111b7a: 85 d2 test %edx,%edx
111b7c: 0f 84 f4 fe ff ff je 111a76 <IMFS_memfile_get_block_pointer+0x72><== NEVER TAKEN
return 0;
p1[ doubly ] = (block_p) p2;
111b82: 89 13 mov %edx,(%ebx)
111b84: e9 48 ff ff ff jmp 111ad1 <IMFS_memfile_get_block_pointer+0xcd>
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
111b89: 89 55 e0 mov %edx,-0x20(%ebp)
111b8c: e8 4f fe ff ff call 1119e0 <memfile_alloc_block>
111b91: 89 c1 mov %eax,%ecx
if ( !p1 )
return 0;
111b93: 31 c0 xor %eax,%eax
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
111b95: 85 c9 test %ecx,%ecx
111b97: 8b 55 e0 mov -0x20(%ebp),%edx
111b9a: 0f 84 d6 fe ff ff je 111a76 <IMFS_memfile_get_block_pointer+0x72><== NEVER TAKEN
return 0;
p[ triply ] = (block_p) p1;
111ba0: 89 0b mov %ecx,(%ebx)
111ba2: e9 1d ff ff ff jmp 111ac4 <IMFS_memfile_get_block_pointer+0xc0>
00111ba8 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
111ba8: 55 push %ebp
111ba9: 89 e5 mov %esp,%ebp
111bab: 57 push %edi
111bac: 56 push %esi
111bad: 53 push %ebx
111bae: 83 ec 3c sub $0x3c,%esp
111bb1: 8b 75 0c mov 0xc(%ebp),%esi
111bb4: 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) {
111bb7: 8b 45 08 mov 0x8(%ebp),%eax
111bba: 83 78 4c 06 cmpl $0x6,0x4c(%eax)
111bbe: 0f 84 60 01 00 00 je 111d24 <IMFS_memfile_read+0x17c><== NEVER TAKEN
/*
* 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;
111bc4: 89 f0 mov %esi,%eax
if ( last_byte > the_jnode->info.file.size )
111bc6: 8b 55 08 mov 0x8(%ebp),%edx
111bc9: 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;
111bcc: 8b 5d 18 mov 0x18(%ebp),%ebx
111bcf: 01 f3 add %esi,%ebx
111bd1: 89 5d d0 mov %ebx,-0x30(%ebp)
if ( last_byte > the_jnode->info.file.size )
111bd4: 31 d2 xor %edx,%edx
111bd6: 8b 5d 08 mov 0x8(%ebp),%ebx
111bd9: 3b 53 54 cmp 0x54(%ebx),%edx
111bdc: 0f 8d d2 00 00 00 jge 111cb4 <IMFS_memfile_read+0x10c><== ALWAYS TAKEN
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
111be2: 8b 45 18 mov 0x18(%ebp),%eax
111be5: 89 45 cc mov %eax,-0x34(%ebp)
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
111be8: 8b 15 e0 78 12 00 mov 0x1278e0,%edx
111bee: 89 55 d0 mov %edx,-0x30(%ebp)
111bf1: 89 d0 mov %edx,%eax
111bf3: 99 cltd
111bf4: 89 d3 mov %edx,%ebx
111bf6: 52 push %edx
111bf7: 50 push %eax
111bf8: 57 push %edi
111bf9: 56 push %esi
111bfa: 89 45 c0 mov %eax,-0x40(%ebp)
111bfd: e8 ba cf 00 00 call 11ebbc <__moddi3>
111c02: 83 c4 10 add $0x10,%esp
111c05: 89 45 c8 mov %eax,-0x38(%ebp)
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
111c08: 8b 4d c0 mov -0x40(%ebp),%ecx
111c0b: 53 push %ebx
111c0c: 51 push %ecx
111c0d: 57 push %edi
111c0e: 56 push %esi
111c0f: e8 5c ce 00 00 call 11ea70 <__divdi3>
111c14: 83 c4 10 add $0x10,%esp
111c17: 89 c3 mov %eax,%ebx
if ( start_offset ) {
111c19: 8b 7d c8 mov -0x38(%ebp),%edi
111c1c: 85 ff test %edi,%edi
111c1e: 0f 84 a0 00 00 00 je 111cc4 <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 );
111c24: 56 push %esi
111c25: 6a 00 push $0x0
111c27: 50 push %eax
111c28: ff 75 08 pushl 0x8(%ebp)
111c2b: e8 d4 fd ff ff call 111a04 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
111c30: 83 c4 10 add $0x10,%esp
111c33: 85 c0 test %eax,%eax
111c35: 0f 84 65 01 00 00 je 111da0 <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;
111c3b: 8b 4d d0 mov -0x30(%ebp),%ecx
111c3e: 2b 4d c8 sub -0x38(%ebp),%ecx
111c41: 8b 55 cc mov -0x34(%ebp),%edx
111c44: 39 ca cmp %ecx,%edx
111c46: 0f 87 3c 01 00 00 ja 111d88 <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 );
111c4c: 8b 75 c8 mov -0x38(%ebp),%esi
111c4f: 03 30 add (%eax),%esi
dest += to_copy;
111c51: 8b 7d 14 mov 0x14(%ebp),%edi
111c54: 89 d1 mov %edx,%ecx
111c56: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
111c58: 89 7d c8 mov %edi,-0x38(%ebp)
block++;
111c5b: 43 inc %ebx
my_length -= to_copy;
111c5c: 29 55 cc sub %edx,-0x34(%ebp)
111c5f: a1 e0 78 12 00 mov 0x1278e0,%eax
111c64: 89 45 d0 mov %eax,-0x30(%ebp)
copied += to_copy;
111c67: 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 ) {
111c6a: 8b 4d d0 mov -0x30(%ebp),%ecx
111c6d: 39 4d cc cmp %ecx,-0x34(%ebp)
111c70: 73 24 jae 111c96 <IMFS_memfile_read+0xee>
111c72: eb 60 jmp 111cd4 <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 );
111c74: 8b 30 mov (%eax),%esi
111c76: 8b 7d c8 mov -0x38(%ebp),%edi
111c79: 8b 4d d0 mov -0x30(%ebp),%ecx
111c7c: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
dest += to_copy;
111c7e: 89 7d c8 mov %edi,-0x38(%ebp)
block++;
111c81: 43 inc %ebx
my_length -= to_copy;
111c82: 8b 7d d0 mov -0x30(%ebp),%edi
111c85: 29 7d cc sub %edi,-0x34(%ebp)
copied += to_copy;
111c88: 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 ) {
111c8b: 8b 45 cc mov -0x34(%ebp),%eax
111c8e: 39 05 e0 78 12 00 cmp %eax,0x1278e0
111c94: 77 3e ja 111cd4 <IMFS_memfile_read+0x12c>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
111c96: 51 push %ecx
111c97: 6a 00 push $0x0
111c99: 53 push %ebx
111c9a: ff 75 08 pushl 0x8(%ebp)
111c9d: e8 62 fd ff ff call 111a04 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
111ca2: 83 c4 10 add $0x10,%esp
111ca5: 85 c0 test %eax,%eax
111ca7: 75 cb jne 111c74 <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;
111ca9: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED
}
IMFS_update_atime( the_jnode );
return copied;
}
111cac: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
111caf: 5b pop %ebx <== NOT EXECUTED
111cb0: 5e pop %esi <== NOT EXECUTED
111cb1: 5f pop %edi <== NOT EXECUTED
111cb2: c9 leave <== NOT EXECUTED
111cb3: 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 )
111cb4: 0f 8e be 00 00 00 jle 111d78 <IMFS_memfile_read+0x1d0><== ALWAYS TAKEN
my_length = the_jnode->info.file.size - start;
111cba: 29 c1 sub %eax,%ecx
111cbc: 89 4d cc mov %ecx,-0x34(%ebp)
111cbf: e9 24 ff ff ff jmp 111be8 <IMFS_memfile_read+0x40>
unsigned int last_byte;
unsigned int copied;
unsigned int start_offset;
unsigned char *dest;
dest = destination;
111cc4: 8b 55 14 mov 0x14(%ebp),%edx
111cc7: 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;
111cca: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
111cd1: eb 97 jmp 111c6a <IMFS_memfile_read+0xc2>
111cd3: 90 nop
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
111cd4: 8b 55 cc mov -0x34(%ebp),%edx
111cd7: 85 d2 test %edx,%edx
111cd9: 74 23 je 111cfe <IMFS_memfile_read+0x156>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
111cdb: 50 push %eax
111cdc: 6a 00 push $0x0
111cde: 53 push %ebx
111cdf: ff 75 08 pushl 0x8(%ebp)
111ce2: e8 1d fd ff ff call 111a04 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
111ce7: 83 c4 10 add $0x10,%esp
111cea: 85 c0 test %eax,%eax
111cec: 74 bb je 111ca9 <IMFS_memfile_read+0x101><== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
111cee: 8b 30 mov (%eax),%esi
111cf0: 8b 7d c8 mov -0x38(%ebp),%edi
111cf3: 8b 4d cc mov -0x34(%ebp),%ecx
111cf6: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
copied += my_length;
111cf8: 8b 55 cc mov -0x34(%ebp),%edx
111cfb: 01 55 c4 add %edx,-0x3c(%ebp)
}
IMFS_update_atime( the_jnode );
111cfe: 83 ec 08 sub $0x8,%esp
111d01: 6a 00 push $0x0
111d03: 8d 45 e0 lea -0x20(%ebp),%eax
111d06: 50 push %eax
111d07: e8 24 64 ff ff call 108130 <gettimeofday>
111d0c: 8b 45 e0 mov -0x20(%ebp),%eax
111d0f: 8b 4d 08 mov 0x8(%ebp),%ecx
111d12: 89 41 40 mov %eax,0x40(%ecx)
return copied;
111d15: 8b 45 c4 mov -0x3c(%ebp),%eax
111d18: 83 c4 10 add $0x10,%esp
}
111d1b: 8d 65 f4 lea -0xc(%ebp),%esp
111d1e: 5b pop %ebx
111d1f: 5e pop %esi
111d20: 5f pop %edi
111d21: c9 leave
111d22: c3 ret
111d23: 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;
111d24: 8b 50 58 mov 0x58(%eax),%edx
111d27: 89 55 cc mov %edx,-0x34(%ebp)
if (my_length > (the_jnode->info.linearfile.size - start))
111d2a: 89 c1 mov %eax,%ecx
111d2c: 8b 40 50 mov 0x50(%eax),%eax
111d2f: 8b 51 54 mov 0x54(%ecx),%edx
111d32: 89 c1 mov %eax,%ecx
111d34: 89 d3 mov %edx,%ebx
111d36: 29 f1 sub %esi,%ecx
111d38: 19 fb sbb %edi,%ebx
111d3a: 89 4d d0 mov %ecx,-0x30(%ebp)
111d3d: 89 5d d4 mov %ebx,-0x2c(%ebp)
111d40: 31 c9 xor %ecx,%ecx
111d42: 39 d9 cmp %ebx,%ecx
111d44: 7d 4a jge 111d90 <IMFS_memfile_read+0x1e8><== ALWAYS TAKEN
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
111d46: 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);
111d49: 03 75 cc add -0x34(%ebp),%esi
111d4c: 8b 7d 14 mov 0x14(%ebp),%edi
111d4f: 89 d9 mov %ebx,%ecx
111d51: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
IMFS_update_atime( the_jnode );
111d53: 83 ec 08 sub $0x8,%esp
111d56: 6a 00 push $0x0
111d58: 8d 45 e0 lea -0x20(%ebp),%eax
111d5b: 50 push %eax
111d5c: e8 cf 63 ff ff call 108130 <gettimeofday>
111d61: 8b 45 e0 mov -0x20(%ebp),%eax
111d64: 8b 7d 08 mov 0x8(%ebp),%edi
111d67: 89 47 40 mov %eax,0x40(%edi)
return my_length;
111d6a: 89 d8 mov %ebx,%eax
111d6c: 83 c4 10 add $0x10,%esp
}
IMFS_update_atime( the_jnode );
return copied;
}
111d6f: 8d 65 f4 lea -0xc(%ebp),%esp
111d72: 5b pop %ebx
111d73: 5e pop %esi
111d74: 5f pop %edi
111d75: c9 leave
111d76: c3 ret
111d77: 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 )
111d78: 39 4d d0 cmp %ecx,-0x30(%ebp)
111d7b: 0f 86 61 fe ff ff jbe 111be2 <IMFS_memfile_read+0x3a>
111d81: e9 34 ff ff ff jmp 111cba <IMFS_memfile_read+0x112>
111d86: 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;
111d88: 89 ca mov %ecx,%edx
111d8a: e9 bd fe ff ff jmp 111c4c <IMFS_memfile_read+0xa4>
111d8f: 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))
111d90: 7f 08 jg 111d9a <IMFS_memfile_read+0x1f2><== NEVER TAKEN
111d92: 8b 5d d0 mov -0x30(%ebp),%ebx
111d95: 39 5d 18 cmp %ebx,0x18(%ebp)
111d98: 76 ac jbe 111d46 <IMFS_memfile_read+0x19e><== NEVER TAKEN
my_length = the_jnode->info.linearfile.size - start;
111d9a: 89 c3 mov %eax,%ebx
111d9c: 29 f3 sub %esi,%ebx
111d9e: eb a9 jmp 111d49 <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;
111da0: 31 c0 xor %eax,%eax
111da2: e9 05 ff ff ff jmp 111cac <IMFS_memfile_read+0x104><== NOT EXECUTED
00111e80 <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
111e80: 55 push %ebp
111e81: 89 e5 mov %esp,%ebp
111e83: 57 push %edi
111e84: 56 push %esi
111e85: 53 push %ebx
111e86: 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;
111e89: 8b 3d e0 78 12 00 mov 0x1278e0,%edi
111e8f: c1 ef 02 shr $0x2,%edi
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
111e92: 8b 45 08 mov 0x8(%ebp),%eax
111e95: 8b 50 58 mov 0x58(%eax),%edx
111e98: 85 d2 test %edx,%edx
111e9a: 74 10 je 111eac <IMFS_memfile_remove+0x2c>
memfile_free_blocks_in_table( &info->indirect, to_free );
111e9c: 83 ec 08 sub $0x8,%esp
111e9f: 57 push %edi
111ea0: 83 c0 58 add $0x58,%eax
111ea3: 50 push %eax
111ea4: e8 7b ff ff ff call 111e24 <memfile_free_blocks_in_table>
111ea9: 83 c4 10 add $0x10,%esp
}
if ( info->doubly_indirect ) {
111eac: 8b 4d 08 mov 0x8(%ebp),%ecx
111eaf: 8b 51 5c mov 0x5c(%ecx),%edx
111eb2: 85 d2 test %edx,%edx
111eb4: 74 55 je 111f0b <IMFS_memfile_remove+0x8b>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
111eb6: a1 e0 78 12 00 mov 0x1278e0,%eax
111ebb: 89 c1 mov %eax,%ecx
111ebd: c1 e9 02 shr $0x2,%ecx
111ec0: 74 36 je 111ef8 <IMFS_memfile_remove+0x78><== NEVER TAKEN
111ec2: 31 c9 xor %ecx,%ecx
111ec4: 31 db xor %ebx,%ebx
111ec6: 8b 75 08 mov 0x8(%ebp),%esi
111ec9: eb 04 jmp 111ecf <IMFS_memfile_remove+0x4f>
111ecb: 90 nop
111ecc: 8b 56 5c mov 0x5c(%esi),%edx
if ( info->doubly_indirect[i] ) {
111ecf: c1 e1 02 shl $0x2,%ecx
111ed2: 83 3c 0a 00 cmpl $0x0,(%edx,%ecx,1)
111ed6: 74 14 je 111eec <IMFS_memfile_remove+0x6c><== NEVER TAKEN
memfile_free_blocks_in_table(
111ed8: 83 ec 08 sub $0x8,%esp
111edb: 57 push %edi
111edc: 01 ca add %ecx,%edx
111ede: 52 push %edx
111edf: e8 40 ff ff ff call 111e24 <memfile_free_blocks_in_table>
111ee4: 83 c4 10 add $0x10,%esp
111ee7: a1 e0 78 12 00 mov 0x1278e0,%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++ ) {
111eec: 43 inc %ebx
111eed: 89 d9 mov %ebx,%ecx
111eef: 89 c2 mov %eax,%edx
111ef1: c1 ea 02 shr $0x2,%edx
111ef4: 39 da cmp %ebx,%edx
111ef6: 77 d4 ja 111ecc <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 );
111ef8: 83 ec 08 sub $0x8,%esp
111efb: 57 push %edi
111efc: 8b 45 08 mov 0x8(%ebp),%eax
111eff: 83 c0 5c add $0x5c,%eax
111f02: 50 push %eax
111f03: e8 1c ff ff ff call 111e24 <memfile_free_blocks_in_table>
111f08: 83 c4 10 add $0x10,%esp
}
if ( info->triply_indirect ) {
111f0b: 8b 45 08 mov 0x8(%ebp),%eax
111f0e: 8b 50 60 mov 0x60(%eax),%edx
111f11: 85 d2 test %edx,%edx
111f13: 0f 84 b6 00 00 00 je 111fcf <IMFS_memfile_remove+0x14f>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
111f19: a1 e0 78 12 00 mov 0x1278e0,%eax
111f1e: 89 c1 mov %eax,%ecx
111f20: c1 e9 02 shr $0x2,%ecx
111f23: 0f 84 93 00 00 00 je 111fbc <IMFS_memfile_remove+0x13c><== NEVER TAKEN
p = (block_p *) info->triply_indirect[i];
111f29: 8b 32 mov (%edx),%esi
if ( !p ) /* ensure we have a valid pointer */
111f2b: 85 f6 test %esi,%esi
111f2d: 0f 84 89 00 00 00 je 111fbc <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];
111f33: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
if ( !p ) /* ensure we have a valid pointer */
111f3a: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
111f41: 8d 76 00 lea 0x0(%esi),%esi
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
111f44: 89 c2 mov %eax,%edx
111f46: c1 ea 02 shr $0x2,%edx
111f49: 74 30 je 111f7b <IMFS_memfile_remove+0xfb><== NEVER TAKEN
111f4b: 31 d2 xor %edx,%edx
111f4d: 31 db xor %ebx,%ebx
111f4f: 90 nop
if ( p[j] ) {
111f50: c1 e2 02 shl $0x2,%edx
111f53: 8b 0c 16 mov (%esi,%edx,1),%ecx
111f56: 85 c9 test %ecx,%ecx
111f58: 74 15 je 111f6f <IMFS_memfile_remove+0xef><== NEVER TAKEN
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
111f5a: 83 ec 08 sub $0x8,%esp
111f5d: 57 push %edi
111f5e: 8d 14 16 lea (%esi,%edx,1),%edx
111f61: 52 push %edx
111f62: e8 bd fe ff ff call 111e24 <memfile_free_blocks_in_table>
111f67: 83 c4 10 add $0x10,%esp
111f6a: a1 e0 78 12 00 mov 0x1278e0,%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++ ) {
111f6f: 43 inc %ebx
111f70: 89 da mov %ebx,%edx
111f72: 89 c1 mov %eax,%ecx
111f74: c1 e9 02 shr $0x2,%ecx
111f77: 39 cb cmp %ecx,%ebx
111f79: 72 d5 jb 111f50 <IMFS_memfile_remove+0xd0>
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
111f7b: 83 ec 08 sub $0x8,%esp
111f7e: 57 push %edi
111f7f: 8b 45 e0 mov -0x20(%ebp),%eax
111f82: 8b 4d 08 mov 0x8(%ebp),%ecx
111f85: 03 41 60 add 0x60(%ecx),%eax
111f88: 50 push %eax
111f89: e8 96 fe ff ff call 111e24 <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++ ) {
111f8e: ff 45 e4 incl -0x1c(%ebp)
111f91: a1 e0 78 12 00 mov 0x1278e0,%eax
111f96: 89 c2 mov %eax,%edx
111f98: c1 ea 02 shr $0x2,%edx
111f9b: 83 c4 10 add $0x10,%esp
111f9e: 3b 55 e4 cmp -0x1c(%ebp),%edx
111fa1: 76 19 jbe 111fbc <IMFS_memfile_remove+0x13c>
p = (block_p *) info->triply_indirect[i];
if ( !p ) /* ensure we have a valid pointer */
111fa3: 8b 55 e4 mov -0x1c(%ebp),%edx
111fa6: c1 e2 02 shl $0x2,%edx
111fa9: 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];
111fac: 8b 4d 08 mov 0x8(%ebp),%ecx
111faf: 8b 51 60 mov 0x60(%ecx),%edx
111fb2: 8b 4d e0 mov -0x20(%ebp),%ecx
111fb5: 8b 34 0a mov (%edx,%ecx,1),%esi
if ( !p ) /* ensure we have a valid pointer */
111fb8: 85 f6 test %esi,%esi
111fba: 75 88 jne 111f44 <IMFS_memfile_remove+0xc4><== ALWAYS TAKEN
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
111fbc: 83 ec 08 sub $0x8,%esp
111fbf: 57 push %edi
(block_p **)&info->triply_indirect, to_free );
111fc0: 8b 45 08 mov 0x8(%ebp),%eax
111fc3: 83 c0 60 add $0x60,%eax
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
111fc6: 50 push %eax
111fc7: e8 58 fe ff ff call 111e24 <memfile_free_blocks_in_table>
111fcc: 83 c4 10 add $0x10,%esp
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
111fcf: 31 c0 xor %eax,%eax
111fd1: 8d 65 f4 lea -0xc(%ebp),%esp
111fd4: 5b pop %ebx
111fd5: 5e pop %esi
111fd6: 5f pop %edi
111fd7: c9 leave
111fd8: c3 ret
00112120 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
112120: 55 push %ebp
112121: 89 e5 mov %esp,%ebp
112123: 57 push %edi
112124: 56 push %esi
112125: 53 push %ebx
112126: 83 ec 3c sub $0x3c,%esp
112129: 8b 5d 0c mov 0xc(%ebp),%ebx
11212c: 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;
11212f: 8b 4d 18 mov 0x18(%ebp),%ecx
112132: 01 d9 add %ebx,%ecx
if ( last_byte > the_jnode->info.file.size ) {
112134: 89 c8 mov %ecx,%eax
112136: 31 d2 xor %edx,%edx
112138: 8b 7d 08 mov 0x8(%ebp),%edi
11213b: 3b 57 54 cmp 0x54(%edi),%edx
11213e: 7c 1c jl 11215c <IMFS_memfile_write+0x3c><== NEVER TAKEN
112140: 0f 8e f2 00 00 00 jle 112238 <IMFS_memfile_write+0x118><== ALWAYS TAKEN
status = IMFS_memfile_extend( the_jnode, last_byte );
112146: 51 push %ecx
112147: 52 push %edx
112148: 50 push %eax
112149: ff 75 08 pushl 0x8(%ebp)
11214c: e8 b7 fe ff ff call 112008 <IMFS_memfile_extend>
if ( status )
112151: 83 c4 10 add $0x10,%esp
112154: 85 c0 test %eax,%eax
112156: 0f 85 52 01 00 00 jne 1122ae <IMFS_memfile_write+0x18e>
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
11215c: a1 e0 78 12 00 mov 0x1278e0,%eax
112161: 89 45 d4 mov %eax,-0x2c(%ebp)
112164: 99 cltd
112165: 89 45 c8 mov %eax,-0x38(%ebp)
112168: 89 55 cc mov %edx,-0x34(%ebp)
11216b: 52 push %edx
11216c: 50 push %eax
11216d: 56 push %esi
11216e: 53 push %ebx
11216f: e8 48 ca 00 00 call 11ebbc <__moddi3>
112174: 83 c4 10 add $0x10,%esp
112177: 89 c7 mov %eax,%edi
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
112179: ff 75 cc pushl -0x34(%ebp)
11217c: ff 75 c8 pushl -0x38(%ebp)
11217f: 56 push %esi
112180: 53 push %ebx
112181: e8 ea c8 00 00 call 11ea70 <__divdi3>
112186: 83 c4 10 add $0x10,%esp
112189: 89 c3 mov %eax,%ebx
if ( start_offset ) {
11218b: 85 ff test %edi,%edi
11218d: 75 5d jne 1121ec <IMFS_memfile_write+0xcc>
unsigned int last_byte;
unsigned int start_offset;
int copied;
const unsigned char *src;
src = source;
11218f: 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 ) {
112192: 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;
112195: 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 ) {
11219c: 3b 55 d4 cmp -0x2c(%ebp),%edx
11219f: 73 26 jae 1121c7 <IMFS_memfile_write+0xa7>
1121a1: e9 a2 00 00 00 jmp 112248 <IMFS_memfile_write+0x128>
1121a6: 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 );
1121a8: 8b 00 mov (%eax),%eax
src += to_copy;
1121aa: 89 c7 mov %eax,%edi
1121ac: 8b 4d d4 mov -0x2c(%ebp),%ecx
1121af: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
block++;
1121b1: 43 inc %ebx
my_length -= to_copy;
1121b2: 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(
1121b5: 8b 45 d4 mov -0x2c(%ebp),%eax
1121b8: 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 ) {
1121bb: 39 15 e0 78 12 00 cmp %edx,0x1278e0
1121c1: 0f 87 81 00 00 00 ja 112248 <IMFS_memfile_write+0x128>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
1121c7: 57 push %edi
1121c8: 6a 00 push $0x0
1121ca: 53 push %ebx
1121cb: ff 75 08 pushl 0x8(%ebp)
1121ce: 89 55 c4 mov %edx,-0x3c(%ebp)
1121d1: e8 2e f8 ff ff call 111a04 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
1121d6: 83 c4 10 add $0x10,%esp
1121d9: 85 c0 test %eax,%eax
1121db: 8b 55 c4 mov -0x3c(%ebp),%edx
1121de: 75 c8 jne 1121a8 <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 )
1121e0: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
1121e3: 8d 65 f4 lea -0xc(%ebp),%esp
1121e6: 5b pop %ebx
1121e7: 5e pop %esi
1121e8: 5f pop %edi
1121e9: c9 leave
1121ea: c3 ret
1121eb: 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 );
1121ec: 50 push %eax
1121ed: 6a 00 push $0x0
1121ef: 53 push %ebx
1121f0: ff 75 08 pushl 0x8(%ebp)
1121f3: e8 0c f8 ff ff call 111a04 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
1121f8: 83 c4 10 add $0x10,%esp
1121fb: 85 c0 test %eax,%eax
1121fd: 0f 84 a1 00 00 00 je 1122a4 <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;
112203: 8b 55 d4 mov -0x2c(%ebp),%edx
112206: 29 fa sub %edi,%edx
112208: 89 55 c8 mov %edx,-0x38(%ebp)
11220b: 8b 55 18 mov 0x18(%ebp),%edx
11220e: 39 55 c8 cmp %edx,-0x38(%ebp)
112211: 0f 87 85 00 00 00 ja 11229c <IMFS_memfile_write+0x17c>
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
112217: 03 38 add (%eax),%edi
src += to_copy;
112219: 8b 75 14 mov 0x14(%ebp),%esi
11221c: 8b 4d c8 mov -0x38(%ebp),%ecx
11221f: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
block++;
112221: 43 inc %ebx
my_length -= to_copy;
112222: 8b 55 18 mov 0x18(%ebp),%edx
112225: 2b 55 c8 sub -0x38(%ebp),%edx
copied += to_copy;
112228: 8b 3d e0 78 12 00 mov 0x1278e0,%edi
11222e: 89 7d d4 mov %edi,-0x2c(%ebp)
112231: e9 66 ff ff ff jmp 11219c <IMFS_memfile_write+0x7c>
112236: 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 ) {
112238: 3b 4f 50 cmp 0x50(%edi),%ecx
11223b: 0f 86 1b ff ff ff jbe 11215c <IMFS_memfile_write+0x3c><== NEVER TAKEN
112241: e9 00 ff ff ff jmp 112146 <IMFS_memfile_write+0x26>
112246: 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 ) {
112248: 85 d2 test %edx,%edx
11224a: 74 28 je 112274 <IMFS_memfile_write+0x154>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
11224c: 51 push %ecx
11224d: 6a 00 push $0x0
11224f: 53 push %ebx
112250: ff 75 08 pushl 0x8(%ebp)
112253: 89 55 c4 mov %edx,-0x3c(%ebp)
112256: e8 a9 f7 ff ff call 111a04 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
11225b: 83 c4 10 add $0x10,%esp
11225e: 85 c0 test %eax,%eax
112260: 8b 55 c4 mov -0x3c(%ebp),%edx
112263: 0f 84 77 ff ff ff je 1121e0 <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 );
112269: 8b 00 mov (%eax),%eax
11226b: 89 c7 mov %eax,%edi
11226d: 89 d1 mov %edx,%ecx
11226f: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
my_length = 0;
copied += to_copy;
112271: 01 55 c8 add %edx,-0x38(%ebp)
}
IMFS_mtime_ctime_update( the_jnode );
112274: 83 ec 08 sub $0x8,%esp
112277: 6a 00 push $0x0
112279: 8d 45 e0 lea -0x20(%ebp),%eax
11227c: 50 push %eax
11227d: e8 ae 5e ff ff call 108130 <gettimeofday>
112282: 8b 45 e0 mov -0x20(%ebp),%eax
112285: 8b 55 08 mov 0x8(%ebp),%edx
112288: 89 42 44 mov %eax,0x44(%edx)
11228b: 89 42 48 mov %eax,0x48(%edx)
return copied;
11228e: 83 c4 10 add $0x10,%esp
112291: 8b 45 c8 mov -0x38(%ebp),%eax
}
112294: 8d 65 f4 lea -0xc(%ebp),%esp
112297: 5b pop %ebx
112298: 5e pop %esi
112299: 5f pop %edi
11229a: c9 leave
11229b: 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;
11229c: 89 55 c8 mov %edx,-0x38(%ebp)
11229f: e9 73 ff ff ff jmp 112217 <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;
1122a4: 31 c0 xor %eax,%eax
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
1122a6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1122a9: 5b pop %ebx <== NOT EXECUTED
1122aa: 5e pop %esi <== NOT EXECUTED
1122ab: 5f pop %edi <== NOT EXECUTED
1122ac: c9 leave <== NOT EXECUTED
1122ad: 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 );
1122ae: e8 bd 0f 00 00 call 113270 <__errno>
1122b3: c7 00 1c 00 00 00 movl $0x1c,(%eax)
1122b9: 83 c8 ff or $0xffffffff,%eax
1122bc: e9 22 ff ff ff jmp 1121e3 <IMFS_memfile_write+0xc3>
001079bc <IMFS_mknod>:
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
1079bc: 55 push %ebp
1079bd: 89 e5 mov %esp,%ebp
1079bf: 57 push %edi
1079c0: 56 push %esi
1079c1: 53 push %ebx
1079c2: 83 ec 5c sub $0x5c,%esp
1079c5: 8b 55 08 mov 0x8(%ebp),%edx
1079c8: 8b 5d 0c mov 0xc(%ebp),%ebx
1079cb: 8b 75 10 mov 0x10(%ebp),%esi
1079ce: 8b 45 14 mov 0x14(%ebp),%eax
1079d1: 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 );
1079d4: 31 c0 xor %eax,%eax
1079d6: b9 ff ff ff ff mov $0xffffffff,%ecx
1079db: 89 d7 mov %edx,%edi
1079dd: f2 ae repnz scas %es:(%edi),%al
1079df: f7 d1 not %ecx
1079e1: 49 dec %ecx
1079e2: 8d 45 e4 lea -0x1c(%ebp),%eax
1079e5: 50 push %eax
1079e6: 8d 7d af lea -0x51(%ebp),%edi
1079e9: 57 push %edi
1079ea: 51 push %ecx
1079eb: 52 push %edx
1079ec: e8 53 7f 00 00 call 10f944 <IMFS_get_token>
/*
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
1079f1: 89 d8 mov %ebx,%eax
1079f3: 25 00 f0 00 00 and $0xf000,%eax
1079f8: 83 c4 10 add $0x10,%esp
1079fb: 3d 00 40 00 00 cmp $0x4000,%eax
107a00: 74 56 je 107a58 <IMFS_mknod+0x9c>
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
107a02: 3d 00 80 00 00 cmp $0x8000,%eax
107a07: 74 57 je 107a60 <IMFS_mknod+0xa4>
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
107a09: 3d 00 60 00 00 cmp $0x6000,%eax
107a0e: 74 14 je 107a24 <IMFS_mknod+0x68>
107a10: 3d 00 20 00 00 cmp $0x2000,%eax
107a15: 74 0d je 107a24 <IMFS_mknod+0x68>
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
} else if (S_ISFIFO(mode))
107a17: 3d 00 10 00 00 cmp $0x1000,%eax
107a1c: 74 4a je 107a68 <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;
107a1e: 31 d2 xor %edx,%edx <== NOT EXECUTED
107a20: eb 10 jmp 107a32 <IMFS_mknod+0x76> <== NOT EXECUTED
107a22: 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 );
107a24: 89 75 d0 mov %esi,-0x30(%ebp)
dev_t device
)
{
union __rtems_dev_t temp;
temp.device = device;
107a27: 8b 45 a4 mov -0x5c(%ebp),%eax
107a2a: 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;
107a2d: 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 );
107a32: 83 ec 0c sub $0xc,%esp
107a35: 8d 45 d0 lea -0x30(%ebp),%eax
107a38: 50 push %eax
107a39: 53 push %ebx
107a3a: 57 push %edi
107a3b: 52 push %edx
107a3c: ff 75 18 pushl 0x18(%ebp)
107a3f: e8 38 75 00 00 call 10ef7c <IMFS_create_node>
if ( !new_node )
107a44: 83 c4 20 add $0x20,%esp
107a47: 85 c0 test %eax,%eax
107a49: 74 24 je 107a6f <IMFS_mknod+0xb3>
rtems_set_errno_and_return_minus_one( ENOMEM );
return 0;
107a4b: 31 c0 xor %eax,%eax
}
107a4d: 8d 65 f4 lea -0xc(%ebp),%esp
107a50: 5b pop %ebx
107a51: 5e pop %esi
107a52: 5f pop %edi
107a53: c9 leave
107a54: c3 ret
107a55: 8d 76 00 lea 0x0(%esi),%esi
/*
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
type = IMFS_DIRECTORY;
107a58: ba 01 00 00 00 mov $0x1,%edx
107a5d: eb d3 jmp 107a32 <IMFS_mknod+0x76>
107a5f: 90 nop
else if ( S_ISREG(mode) )
type = IMFS_MEMORY_FILE;
107a60: ba 05 00 00 00 mov $0x5,%edx
107a65: eb cb jmp 107a32 <IMFS_mknod+0x76>
107a67: 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;
107a68: ba 07 00 00 00 mov $0x7,%edx
107a6d: eb c3 jmp 107a32 <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 );
107a6f: e8 fc b7 00 00 call 113270 <__errno>
107a74: c7 00 0c 00 00 00 movl $0xc,(%eax)
107a7a: b8 ff ff ff ff mov $0xffffffff,%eax
107a7f: eb cc jmp 107a4d <IMFS_mknod+0x91>
00107a84 <IMFS_mount>:
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
107a84: 55 push %ebp
107a85: 89 e5 mov %esp,%ebp
107a87: 83 ec 08 sub $0x8,%esp
107a8a: 8b 55 08 mov 0x8(%ebp),%edx
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
107a8d: 8b 42 08 mov 0x8(%edx),%eax
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
107a90: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
107a94: 75 0a jne 107aa0 <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;
107a96: 89 50 5c mov %edx,0x5c(%eax)
return 0;
107a99: 31 c0 xor %eax,%eax
}
107a9b: c9 leave
107a9c: c3 ret
107a9d: 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 );
107aa0: e8 cb b7 00 00 call 113270 <__errno> <== NOT EXECUTED
107aa5: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
107aab: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
* the mounted file system.
*/
node->info.directory.mt_fs = mt_entry;
return 0;
}
107ab0: c9 leave <== NOT EXECUTED
107ab1: c3 ret <== NOT EXECUTED
0010a3b0 <IMFS_print_jnode>:
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
10a3b0: 55 push %ebp
10a3b1: 89 e5 mov %esp,%ebp
10a3b3: 53 push %ebx
10a3b4: 83 ec 0c sub $0xc,%esp
10a3b7: 8b 5d 08 mov 0x8(%ebp),%ebx
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
10a3ba: a1 20 c4 12 00 mov 0x12c420,%eax
10a3bf: ff 70 08 pushl 0x8(%eax)
10a3c2: 8d 43 0c lea 0xc(%ebx),%eax
10a3c5: 50 push %eax
10a3c6: e8 d1 d5 00 00 call 11799c <fputs>
switch( the_jnode->type ) {
10a3cb: 8b 43 4c mov 0x4c(%ebx),%eax
10a3ce: 83 c4 10 add $0x10,%esp
10a3d1: 83 f8 07 cmp $0x7,%eax
10a3d4: 76 1e jbe 10a3f4 <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 );
10a3d6: 52 push %edx <== NOT EXECUTED
10a3d7: 50 push %eax <== NOT EXECUTED
10a3d8: 68 84 71 12 00 push $0x127184 <== NOT EXECUTED
10a3dd: a1 20 c4 12 00 mov 0x12c420,%eax <== NOT EXECUTED
10a3e2: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
10a3e5: e8 a6 d4 00 00 call 117890 <fprintf> <== NOT EXECUTED
return;
10a3ea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
puts("");
}
10a3ed: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10a3f0: c9 leave <== NOT EXECUTED
10a3f1: c3 ret <== NOT EXECUTED
10a3f2: 66 90 xchg %ax,%ax <== NOT EXECUTED
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
switch( the_jnode->type ) {
10a3f4: ff 24 85 9c 71 12 00 jmp *0x12719c(,%eax,4)
10a3fb: 90 nop
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
10a3fc: a1 20 c4 12 00 mov 0x12c420,%eax
10a401: ff 70 08 pushl 0x8(%eax)
10a404: 6a 13 push $0x13
10a406: 6a 01 push $0x1
10a408: 68 5d 71 12 00 push $0x12715d
10a40d: e8 ae e1 00 00 call 1185c0 <fwrite>
return;
10a412: 83 c4 10 add $0x10,%esp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
}
10a415: 8b 5d fc mov -0x4(%ebp),%ebx
10a418: c9 leave
10a419: c3 ret
10a41a: 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" );
10a41c: a1 20 c4 12 00 mov 0x12c420,%eax
10a421: ff 70 08 pushl 0x8(%eax)
10a424: 6a 12 push $0x12
10a426: 6a 01 push $0x1
10a428: 68 71 71 12 00 push $0x127171
10a42d: e8 8e e1 00 00 call 1185c0 <fwrite>
return;
10a432: 83 c4 10 add $0x10,%esp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
}
10a435: 8b 5d fc mov -0x4(%ebp),%ebx
10a438: c9 leave
10a439: c3 ret
10a43a: 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 ")",
10a43c: 51 push %ecx
10a43d: ff 73 50 pushl 0x50(%ebx)
10a440: 68 51 71 12 00 push $0x127151
10a445: a1 20 c4 12 00 mov 0x12c420,%eax
10a44a: ff 70 08 pushl 0x8(%eax)
10a44d: e8 3e d4 00 00 call 117890 <fprintf>
(uint32_t)the_jnode->info.file.size );
#endif
break;
10a452: 83 c4 10 add $0x10,%esp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
10a455: c7 45 08 89 74 12 00 movl $0x127489,0x8(%ebp)
}
10a45c: 8b 5d fc mov -0x4(%ebp),%ebx
10a45f: c9 leave
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
10a460: e9 53 ed 00 00 jmp 1191b8 <puts>
10a465: 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)",
10a468: ff 73 58 pushl 0x58(%ebx)
10a46b: ff 73 50 pushl 0x50(%ebx)
10a46e: 68 42 71 12 00 push $0x127142
10a473: a1 20 c4 12 00 mov 0x12c420,%eax
10a478: ff 70 08 pushl 0x8(%eax)
10a47b: e8 10 d4 00 00 call 117890 <fprintf>
(uint32_t)the_jnode->info.linearfile.size,
the_jnode->info.linearfile.direct
);
break;
10a480: 83 c4 10 add $0x10,%esp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
10a483: c7 45 08 89 74 12 00 movl $0x127489,0x8(%ebp)
}
10a48a: 8b 5d fc mov -0x4(%ebp),%ebx
10a48d: c9 leave
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
10a48e: e9 25 ed 00 00 jmp 1191b8 <puts>
10a493: 90 nop
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
switch( the_jnode->type ) {
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
10a494: 83 ec 08 sub $0x8,%esp
10a497: a1 20 c4 12 00 mov 0x12c420,%eax
10a49c: ff 70 08 pushl 0x8(%eax)
10a49f: 6a 2f push $0x2f
10a4a1: e8 4a d4 00 00 call 1178f0 <fputc>
break;
10a4a6: 83 c4 10 add $0x10,%esp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
10a4a9: c7 45 08 89 74 12 00 movl $0x127489,0x8(%ebp)
}
10a4b0: 8b 5d fc mov -0x4(%ebp),%ebx
10a4b3: c9 leave
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
10a4b4: e9 ff ec 00 00 jmp 1191b8 <puts>
10a4b9: 8d 76 00 lea 0x0(%esi),%esi
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
break;
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
10a4bc: ff 73 54 pushl 0x54(%ebx)
10a4bf: ff 73 50 pushl 0x50(%ebx)
10a4c2: 68 2f 71 12 00 push $0x12712f
10a4c7: a1 20 c4 12 00 mov 0x12c420,%eax
10a4cc: ff 70 08 pushl 0x8(%eax)
10a4cf: e8 bc d3 00 00 call 117890 <fprintf>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
10a4d4: 83 c4 10 add $0x10,%esp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
10a4d7: c7 45 08 89 74 12 00 movl $0x127489,0x8(%ebp)
}
10a4de: 8b 5d fc mov -0x4(%ebp),%ebx
10a4e1: c9 leave
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
10a4e2: e9 d1 ec 00 00 jmp 1191b8 <puts>
00107ac4 <IMFS_readlink>:
ssize_t IMFS_readlink(
rtems_filesystem_location_info_t *loc,
char *buf, /* OUT */
size_t bufsize
)
{
107ac4: 55 push %ebp
107ac5: 89 e5 mov %esp,%ebp
107ac7: 57 push %edi
107ac8: 56 push %esi
107ac9: 53 push %ebx
107aca: 8b 7d 0c mov 0xc(%ebp),%edi
107acd: 8b 5d 10 mov 0x10(%ebp),%ebx
IMFS_jnode_t *node;
ssize_t i;
node = loc->node_access;
107ad0: 8b 45 08 mov 0x8(%ebp),%eax
107ad3: 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++ )
107ad5: 85 db test %ebx,%ebx
107ad7: 74 28 je 107b01 <IMFS_readlink+0x3d> <== NEVER TAKEN
107ad9: 8b 46 50 mov 0x50(%esi),%eax
107adc: 8a 10 mov (%eax),%dl
107ade: 84 d2 test %dl,%dl
107ae0: 74 1f je 107b01 <IMFS_readlink+0x3d> <== NEVER TAKEN
107ae2: 31 c9 xor %ecx,%ecx
107ae4: 31 c0 xor %eax,%eax
107ae6: eb 0a jmp 107af2 <IMFS_readlink+0x2e>
107ae8: 8b 56 50 mov 0x50(%esi),%edx
107aeb: 8a 14 02 mov (%edx,%eax,1),%dl
107aee: 84 d2 test %dl,%dl
107af0: 74 0a je 107afc <IMFS_readlink+0x38>
buf[i] = node->info.sym_link.name[i];
107af2: 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++ )
107af5: 40 inc %eax
107af6: 89 c1 mov %eax,%ecx
107af8: 39 d8 cmp %ebx,%eax
107afa: 72 ec jb 107ae8 <IMFS_readlink+0x24>
buf[i] = node->info.sym_link.name[i];
return i;
}
107afc: 5b pop %ebx
107afd: 5e pop %esi
107afe: 5f pop %edi
107aff: c9 leave
107b00: 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++ )
107b01: 31 c0 xor %eax,%eax
107b03: eb f7 jmp 107afc <IMFS_readlink+0x38> <== NOT EXECUTED
00107b08 <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 */
)
{
107b08: 55 push %ebp
107b09: 89 e5 mov %esp,%ebp
107b0b: 53 push %ebx
107b0c: 83 ec 18 sub $0x18,%esp
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
107b0f: 8b 45 0c mov 0xc(%ebp),%eax
107b12: 8b 18 mov (%eax),%ebx
strncpy( the_jnode->name, new_name, IMFS_NAME_MAX );
107b14: 6a 20 push $0x20
107b16: ff 75 14 pushl 0x14(%ebp)
107b19: 8d 43 0c lea 0xc(%ebx),%eax
107b1c: 50 push %eax
107b1d: e8 3a c5 00 00 call 11405c <strncpy>
if ( the_jnode->Parent != NULL )
107b22: 83 c4 10 add $0x10,%esp
107b25: 8b 4b 08 mov 0x8(%ebx),%ecx
107b28: 85 c9 test %ecx,%ecx
107b2a: 74 0c je 107b38 <IMFS_rename+0x30> <== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
107b2c: 83 ec 0c sub $0xc,%esp
107b2f: 53 push %ebx
107b30: e8 c7 44 00 00 call 10bffc <_Chain_Extract>
107b35: 83 c4 10 add $0x10,%esp
rtems_chain_extract( (rtems_chain_node *) the_jnode );
new_parent = new_parent_loc->node_access;
107b38: 8b 45 10 mov 0x10(%ebp),%eax
107b3b: 8b 00 mov (%eax),%eax
the_jnode->Parent = new_parent;
107b3d: 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 );
107b40: 83 ec 08 sub $0x8,%esp
107b43: 53 push %ebx
rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
107b44: 83 c0 50 add $0x50,%eax
107b47: 50 push %eax
107b48: e8 8b 44 00 00 call 10bfd8 <_Chain_Append>
/*
* Update the time.
*/
IMFS_update_ctime( the_jnode );
107b4d: 58 pop %eax
107b4e: 5a pop %edx
107b4f: 6a 00 push $0x0
107b51: 8d 45 f0 lea -0x10(%ebp),%eax
107b54: 50 push %eax
107b55: e8 d6 05 00 00 call 108130 <gettimeofday>
107b5a: 8b 45 f0 mov -0x10(%ebp),%eax
107b5d: 89 43 48 mov %eax,0x48(%ebx)
return 0;
}
107b60: 31 c0 xor %eax,%eax
107b62: 8b 5d fc mov -0x4(%ebp),%ebx
107b65: c9 leave
107b66: c3 ret
0010fb10 <IMFS_stat>:
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
10fb10: 55 push %ebp
10fb11: 89 e5 mov %esp,%ebp
10fb13: 56 push %esi
10fb14: 53 push %ebx
10fb15: 8b 4d 08 mov 0x8(%ebp),%ecx
10fb18: 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;
10fb1b: 8b 11 mov (%ecx),%edx
switch ( the_jnode->type ) {
10fb1d: 83 7a 4c 07 cmpl $0x7,0x4c(%edx)
10fb21: 76 15 jbe 10fb38 <IMFS_stat+0x28> <== ALWAYS TAKEN
case IMFS_FIFO:
buf->st_size = 0;
break;
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
10fb23: e8 48 37 00 00 call 113270 <__errno>
10fb28: c7 00 86 00 00 00 movl $0x86,(%eax)
10fb2e: 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;
}
10fb33: 5b pop %ebx
10fb34: 5e pop %esi
10fb35: c9 leave
10fb36: c3 ret
10fb37: 90 nop
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
10fb38: 8b 5a 4c mov 0x4c(%edx),%ebx
10fb3b: ff 24 9d f8 18 12 00 jmp *0x1218f8(,%ebx,4)
10fb42: 66 90 xchg %ax,%ax
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
10fb44: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax)
10fb4b: 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;
10fb52: 8b 49 10 mov 0x10(%ecx),%ecx
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
10fb55: 8b 49 34 mov 0x34(%ecx),%ecx
10fb58: 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 =
10fb5a: c7 00 fe ff 00 00 movl $0xfffe,(%eax)
10fb60: 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;
10fb63: 8b 4a 30 mov 0x30(%edx),%ecx
10fb66: 89 48 0c mov %ecx,0xc(%eax)
buf->st_nlink = the_jnode->st_nlink;
10fb69: 8b 4a 34 mov 0x34(%edx),%ecx
10fb6c: 66 89 48 10 mov %cx,0x10(%eax)
buf->st_ino = the_jnode->st_ino;
10fb70: 8b 4a 38 mov 0x38(%edx),%ecx
10fb73: 89 48 08 mov %ecx,0x8(%eax)
buf->st_uid = the_jnode->st_uid;
10fb76: 8b 4a 3c mov 0x3c(%edx),%ecx
10fb79: 66 89 48 12 mov %cx,0x12(%eax)
buf->st_gid = the_jnode->st_gid;
10fb7d: 66 8b 4a 3e mov 0x3e(%edx),%cx
10fb81: 66 89 48 14 mov %cx,0x14(%eax)
buf->st_atime = the_jnode->stat_atime;
10fb85: 8b 4a 40 mov 0x40(%edx),%ecx
10fb88: 89 48 28 mov %ecx,0x28(%eax)
buf->st_mtime = the_jnode->stat_mtime;
10fb8b: 8b 4a 44 mov 0x44(%edx),%ecx
10fb8e: 89 48 30 mov %ecx,0x30(%eax)
buf->st_ctime = the_jnode->stat_ctime;
10fb91: 8b 52 48 mov 0x48(%edx),%edx
10fb94: 89 50 38 mov %edx,0x38(%eax)
return 0;
10fb97: 31 c0 xor %eax,%eax
}
10fb99: 5b pop %ebx
10fb9a: 5e pop %esi
10fb9b: c9 leave
10fb9c: c3 ret
10fb9d: 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 );
10fba0: 8b 5a 54 mov 0x54(%edx),%ebx
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
10fba3: 8b 72 50 mov 0x50(%edx),%esi
10fba6: 89 70 18 mov %esi,0x18(%eax)
10fba9: 89 58 1c mov %ebx,0x1c(%eax)
break;
10fbac: eb a4 jmp 10fb52 <IMFS_stat+0x42>
10fbae: 66 90 xchg %ax,%ax
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
10fbb0: 8b 5a 50 mov 0x50(%edx),%ebx
10fbb3: 8b 72 54 mov 0x54(%edx),%esi
10fbb6: 89 58 20 mov %ebx,0x20(%eax)
10fbb9: 89 70 24 mov %esi,0x24(%eax)
break;
10fbbc: eb 94 jmp 10fb52 <IMFS_stat+0x42>
00107bfc <IMFS_unlink>:
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
107bfc: 55 push %ebp
107bfd: 89 e5 mov %esp,%ebp
107bff: 57 push %edi
107c00: 56 push %esi
107c01: 53 push %ebx
107c02: 83 ec 3c sub $0x3c,%esp
107c05: 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;
107c08: 8b 13 mov (%ebx),%edx
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
107c0a: 83 7a 4c 03 cmpl $0x3,0x4c(%edx)
107c0e: 74 18 je 107c28 <IMFS_unlink+0x2c>
/*
* Now actually free the node we were asked to free.
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
107c10: 83 ec 08 sub $0x8,%esp
107c13: 8b 43 08 mov 0x8(%ebx),%eax
107c16: 53 push %ebx
107c17: ff 75 08 pushl 0x8(%ebp)
107c1a: ff 50 34 call *0x34(%eax)
return result;
107c1d: 83 c4 10 add $0x10,%esp
}
107c20: 8d 65 f4 lea -0xc(%ebp),%esp
107c23: 5b pop %ebx
107c24: 5e pop %esi
107c25: 5f pop %edi
107c26: c9 leave
107c27: c3 ret
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
107c28: 8b 42 50 mov 0x50(%edx),%eax
107c2b: 85 c0 test %eax,%eax
107c2d: 74 79 je 107ca8 <IMFS_unlink+0xac> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
107c2f: 8d 7d cc lea -0x34(%ebp),%edi
107c32: b9 05 00 00 00 mov $0x5,%ecx
107c37: 89 de mov %ebx,%esi
107c39: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_link.node_access = node->info.hard_link.link_node;
107c3b: 89 45 cc mov %eax,-0x34(%ebp)
IMFS_Set_handlers( &the_link );
107c3e: 83 ec 0c sub $0xc,%esp
107c41: 8d 75 cc lea -0x34(%ebp),%esi
107c44: 56 push %esi
107c45: 89 55 c4 mov %edx,-0x3c(%ebp)
107c48: e8 9b 74 00 00 call 10f0e8 <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)
107c4d: 8b 55 c4 mov -0x3c(%ebp),%edx
107c50: 8b 42 50 mov 0x50(%edx),%eax
107c53: 8b 48 34 mov 0x34(%eax),%ecx
107c56: 83 c4 10 add $0x10,%esp
107c59: 66 83 f9 01 cmp $0x1,%cx
107c5d: 74 27 je 107c86 <IMFS_unlink+0x8a>
if ( result != 0 )
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
107c5f: 49 dec %ecx
107c60: 66 89 48 34 mov %cx,0x34(%eax)
IMFS_update_ctime( node->info.hard_link.link_node );
107c64: 83 ec 08 sub $0x8,%esp
107c67: 6a 00 push $0x0
107c69: 8d 45 e0 lea -0x20(%ebp),%eax
107c6c: 50 push %eax
107c6d: 89 55 c4 mov %edx,-0x3c(%ebp)
107c70: e8 bb 04 00 00 call 108130 <gettimeofday>
107c75: 8b 55 c4 mov -0x3c(%ebp),%edx
107c78: 8b 42 50 mov 0x50(%edx),%eax
107c7b: 8b 55 e0 mov -0x20(%ebp),%edx
107c7e: 89 50 48 mov %edx,0x48(%eax)
107c81: 83 c4 10 add $0x10,%esp
107c84: eb 8a jmp 107c10 <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 );
107c86: 83 ec 08 sub $0x8,%esp
107c89: 56 push %esi
107c8a: ff 75 08 pushl 0x8(%ebp)
107c8d: 8b 45 d4 mov -0x2c(%ebp),%eax
107c90: ff 50 34 call *0x34(%eax)
if ( result != 0 )
107c93: 83 c4 10 add $0x10,%esp
107c96: 85 c0 test %eax,%eax
107c98: 0f 84 72 ff ff ff je 107c10 <IMFS_unlink+0x14>
return -1;
107c9e: b8 ff ff ff ff mov $0xffffffff,%eax
107ca3: e9 78 ff ff ff jmp 107c20 <IMFS_unlink+0x24>
*/
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
107ca8: e8 c3 b5 00 00 call 113270 <__errno> <== NOT EXECUTED
107cad: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
107cb3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
107cb8: e9 63 ff ff ff jmp 107c20 <IMFS_unlink+0x24> <== NOT EXECUTED
00107cc0 <IMFS_unmount>:
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
107cc0: 55 push %ebp
107cc1: 89 e5 mov %esp,%ebp
107cc3: 83 ec 08 sub $0x8,%esp
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
107cc6: 8b 45 08 mov 0x8(%ebp),%eax
107cc9: 8b 40 08 mov 0x8(%eax),%eax
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
107ccc: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
107cd0: 75 12 jne 107ce4 <IMFS_unmount+0x24> <== NEVER TAKEN
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
107cd2: 8b 50 5c mov 0x5c(%eax),%edx
107cd5: 85 d2 test %edx,%edx
107cd7: 74 1d je 107cf6 <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;
107cd9: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
return 0;
107ce0: 31 c0 xor %eax,%eax
}
107ce2: c9 leave
107ce3: 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 );
107ce4: e8 87 b5 00 00 call 113270 <__errno> <== NOT EXECUTED
107ce9: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
107cef: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
*/
node->info.directory.mt_fs = NULL;
return 0;
}
107cf4: c9 leave <== NOT EXECUTED
107cf5: 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 */
107cf6: e8 75 b5 00 00 call 113270 <__errno> <== NOT EXECUTED
107cfb: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
107d01: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
*/
node->info.directory.mt_fs = NULL;
return 0;
}
107d06: c9 leave <== NOT EXECUTED
107d07: c3 ret <== NOT EXECUTED
001082dc <RTEMS_Malloc_Initialize>:
void RTEMS_Malloc_Initialize(
void *heap_begin,
uintptr_t heap_size,
size_t sbrk_amount
)
{
1082dc: 55 push %ebp
1082dd: 89 e5 mov %esp,%ebp
1082df: 57 push %edi
1082e0: 56 push %esi
1082e1: 53 push %ebx
1082e2: 83 ec 0c sub $0xc,%esp
1082e5: 8b 5d 08 mov 0x8(%ebp),%ebx
1082e8: 8b 75 0c mov 0xc(%ebp),%esi
1082eb: 8b 7d 10 mov 0x10(%ebp),%edi
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
1082ee: a1 e8 5f 12 00 mov 0x125fe8,%eax
1082f3: 85 c0 test %eax,%eax
1082f5: 74 02 je 1082f9 <RTEMS_Malloc_Initialize+0x1d>
(*rtems_malloc_statistics_helpers->initialize)();
1082f7: ff 10 call *(%eax)
}
/*
* Initialize the garbage collection list to start with nothing on it.
*/
malloc_deferred_frees_initialize();
1082f9: e8 76 ff ff ff call 108274 <malloc_deferred_frees_initialize>
/*
* Initialize the optional sbrk support for extending the heap
*/
if ( rtems_malloc_sbrk_helpers != NULL ) {
1082fe: a1 ec 5f 12 00 mov 0x125fec,%eax
108303: 85 c0 test %eax,%eax
108305: 74 0e je 108315 <RTEMS_Malloc_Initialize+0x39>
heap_begin = (*rtems_malloc_sbrk_helpers->initialize)(
108307: 83 ec 08 sub $0x8,%esp
10830a: 57 push %edi
10830b: 53 push %ebx
10830c: ff 10 call *(%eax)
10830e: 89 c3 mov %eax,%ebx
108310: 83 c4 10 add $0x10,%esp
heap_begin,
sbrk_amount
);
heap_size = (uintptr_t) sbrk_amount;
108313: 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 (
108315: 80 3d e4 5f 12 00 00 cmpb $0x0,0x125fe4
10831c: 75 1f jne 10833d <RTEMS_Malloc_Initialize+0x61>
!rtems_unified_work_area
&& rtems_configuration_get_do_zero_of_workspace()
10831e: 80 3d a8 3a 12 00 00 cmpb $0x0,0x123aa8
108325: 75 41 jne 108368 <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 );
108327: 6a 04 push $0x4
108329: 56 push %esi
10832a: 53 push %ebx
10832b: ff 35 b0 39 12 00 pushl 0x1239b0
108331: e8 b6 43 00 00 call 10c6ec <_Heap_Initialize>
RTEMS_Malloc_Heap,
heap_begin,
heap_size,
CPU_HEAP_ALIGNMENT
);
if ( status == 0 ) {
108336: 83 c4 10 add $0x10,%esp
108339: 85 c0 test %eax,%eax
10833b: 74 3e je 10837b <RTEMS_Malloc_Initialize+0x9f>
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
}
}
MSBUMP( space_available, _Protected_heap_Get_size(RTEMS_Malloc_Heap) );
10833d: 8b 1d 40 7c 12 00 mov 0x127c40,%ebx
108343: 83 ec 0c sub $0xc,%esp
108346: ff 35 b0 39 12 00 pushl 0x1239b0
10834c: e8 07 4e 00 00 call 10d158 <_Protected_heap_Get_size>
108351: 8d 1c 18 lea (%eax,%ebx,1),%ebx
108354: 89 1d 40 7c 12 00 mov %ebx,0x127c40
10835a: 83 c4 10 add $0x10,%esp
}
10835d: 8d 65 f4 lea -0xc(%ebp),%esp
108360: 5b pop %ebx
108361: 5e pop %esi
108362: 5f pop %edi
108363: c9 leave
108364: c3 ret
108365: 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 );
108368: 31 c0 xor %eax,%eax
10836a: 89 df mov %ebx,%edi
10836c: 89 f1 mov %esi,%ecx
10836e: 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 ) {
108370: 80 3d e4 5f 12 00 00 cmpb $0x0,0x125fe4
108377: 74 ae je 108327 <RTEMS_Malloc_Initialize+0x4b><== ALWAYS TAKEN
108379: eb c2 jmp 10833d <RTEMS_Malloc_Initialize+0x61><== NOT EXECUTED
heap_begin,
heap_size,
CPU_HEAP_ALIGNMENT
);
if ( status == 0 ) {
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
10837b: 83 ec 0c sub $0xc,%esp
10837e: 6a 1a push $0x1a
108380: e8 6f 39 00 00 call 10bcf4 <rtems_fatal_error_occurred>
00107df0 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
107df0: 55 push %ebp <== NOT EXECUTED
107df1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107df3: 57 push %edi <== NOT EXECUTED
107df4: 56 push %esi <== NOT EXECUTED
107df5: 53 push %ebx <== NOT EXECUTED
107df6: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED
107df9: 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) {
107dfc: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED
107dff: 0f 84 37 01 00 00 je 107f3c <Stack_check_Dump_threads_usage+0x14c><== NOT EXECUTED
the_thread = 0;
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
107e05: 8d b3 b8 00 00 00 lea 0xb8(%ebx),%esi <== NOT EXECUTED
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
107e0b: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED
107e11: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED
107e14: 8b 8b bc 00 00 00 mov 0xbc(%ebx),%ecx <== NOT EXECUTED
}
low = Stack_check_usable_stack_start(stack);
107e1a: 8d 51 10 lea 0x10(%ecx),%edx <== NOT EXECUTED
107e1d: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
107e20: 8b 3e mov (%esi),%edi <== NOT EXECUTED
107e22: 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;
107e25: 8d 41 20 lea 0x20(%ecx),%eax <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
107e28: 89 fa mov %edi,%edx <== NOT EXECUTED
107e2a: 83 e2 fc and $0xfffffffc,%edx <== NOT EXECUTED
107e2d: 8d 14 10 lea (%eax,%edx,1),%edx <== NOT EXECUTED
107e30: 39 d0 cmp %edx,%eax <== NOT EXECUTED
107e32: 73 23 jae 107e57 <Stack_check_Dump_threads_usage+0x67><== NOT EXECUTED
if (*base != U32_PATTERN)
107e34: 81 79 20 a5 a5 a5 a5 cmpl $0xa5a5a5a5,0x20(%ecx) <== NOT EXECUTED
107e3b: 74 13 je 107e50 <Stack_check_Dump_threads_usage+0x60><== NOT EXECUTED
107e3d: e9 a2 00 00 00 jmp 107ee4 <Stack_check_Dump_threads_usage+0xf4><== NOT EXECUTED
107e42: 66 90 xchg %ax,%ax <== NOT EXECUTED
107e44: 81 38 a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%eax) <== NOT EXECUTED
107e4a: 0f 85 94 00 00 00 jne 107ee4 <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++)
107e50: 83 c0 04 add $0x4,%eax <== NOT EXECUTED
107e53: 39 c2 cmp %eax,%edx <== NOT EXECUTED
107e55: 77 ed ja 107e44 <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;
107e57: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
107e5e: 85 db test %ebx,%ebx <== NOT EXECUTED
107e60: 0f 84 98 00 00 00 je 107efe <Stack_check_Dump_threads_usage+0x10e><== NOT EXECUTED
#endif
{
(*print_handler)(
107e66: a1 c4 a5 12 00 mov 0x12a5c4,%eax <== NOT EXECUTED
107e6b: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED
107e6e: 50 push %eax <== NOT EXECUTED
107e6f: 8d 45 e3 lea -0x1d(%ebp),%eax <== NOT EXECUTED
107e72: 50 push %eax <== NOT EXECUTED
107e73: 6a 05 push $0x5 <== NOT EXECUTED
107e75: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
107e78: e8 27 5f 00 00 call 10dda4 <rtems_object_get_name> <== NOT EXECUTED
107e7d: 50 push %eax <== NOT EXECUTED
107e7e: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
107e81: 68 73 3d 12 00 push $0x123d73 <== NOT EXECUTED
107e86: ff 35 c0 a5 12 00 pushl 0x12a5c0 <== NOT EXECUTED
107e8c: ff 55 cc call *-0x34(%ebp) <== NOT EXECUTED
107e8f: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
107e92: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
107e95: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
107e98: 57 push %edi <== NOT EXECUTED
107e99: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
107e9c: 8b 16 mov (%esi),%edx <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
107e9e: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED
107ea2: 52 push %edx <== NOT EXECUTED
107ea3: 50 push %eax <== NOT EXECUTED
107ea4: 68 8e 3d 12 00 push $0x123d8e <== NOT EXECUTED
107ea9: ff 35 c0 a5 12 00 pushl 0x12a5c0 <== NOT EXECUTED
107eaf: ff 15 c4 a5 12 00 call *0x12a5c4 <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
107eb5: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
107eb8: 8b 15 c8 a5 12 00 mov 0x12a5c8,%edx <== NOT EXECUTED
107ebe: 85 d2 test %edx,%edx <== NOT EXECUTED
107ec0: 74 5a je 107f1c <Stack_check_Dump_threads_usage+0x12c><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
107ec2: 50 push %eax <== NOT EXECUTED
107ec3: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED
107ec6: 68 b9 3d 12 00 push $0x123db9 <== NOT EXECUTED
107ecb: ff 35 c0 a5 12 00 pushl 0x12a5c0 <== NOT EXECUTED
107ed1: ff 15 c4 a5 12 00 call *0x12a5c4 <== NOT EXECUTED
107ed7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
107eda: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
107edd: 5b pop %ebx <== NOT EXECUTED
107ede: 5e pop %esi <== NOT EXECUTED
107edf: 5f pop %edi <== NOT EXECUTED
107ee0: c9 leave <== NOT EXECUTED
107ee1: c3 ret <== NOT EXECUTED
107ee2: 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 )
107ee4: 85 c0 test %eax,%eax <== NOT EXECUTED
107ee6: 0f 84 6b ff ff ff je 107e57 <Stack_check_Dump_threads_usage+0x67><== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
107eec: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED
107eef: 01 fa add %edi,%edx <== NOT EXECUTED
107ef1: 29 c2 sub %eax,%edx <== NOT EXECUTED
107ef3: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
107ef6: 85 db test %ebx,%ebx <== NOT EXECUTED
107ef8: 0f 85 68 ff ff ff jne 107e66 <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 );
107efe: 51 push %ecx <== NOT EXECUTED
107eff: 6a ff push $0xffffffff <== NOT EXECUTED
107f01: 68 80 3d 12 00 push $0x123d80 <== NOT EXECUTED
107f06: ff 35 c0 a5 12 00 pushl 0x12a5c0 <== NOT EXECUTED
107f0c: ff 15 c4 a5 12 00 call *0x12a5c4 <== NOT EXECUTED
107f12: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107f15: e9 78 ff ff ff jmp 107e92 <Stack_check_Dump_threads_usage+0xa2><== NOT EXECUTED
107f1a: 66 90 xchg %ax,%ax <== NOT EXECUTED
current,
size
);
if (Stack_check_Initialized == 0) {
(*print_handler)( print_context, "Unavailable\n" );
107f1c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
107f1f: 68 ac 3d 12 00 push $0x123dac <== NOT EXECUTED
107f24: ff 35 c0 a5 12 00 pushl 0x12a5c0 <== NOT EXECUTED
107f2a: ff 15 c4 a5 12 00 call *0x12a5c4 <== NOT EXECUTED
107f30: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
}
}
107f33: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
107f36: 5b pop %ebx <== NOT EXECUTED
107f37: 5e pop %esi <== NOT EXECUTED
107f38: 5f pop %edi <== NOT EXECUTED
107f39: c9 leave <== NOT EXECUTED
107f3a: c3 ret <== NOT EXECUTED
107f3b: 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)
107f3c: 8b 0d 34 a9 12 00 mov 0x12a934,%ecx <== NOT EXECUTED
107f42: 85 c9 test %ecx,%ecx <== NOT EXECUTED
107f44: 74 94 je 107eda <Stack_check_Dump_threads_usage+0xea><== NOT EXECUTED
return;
stack = &Stack_check_Interrupt_stack;
107f46: be 30 a9 12 00 mov $0x12a930,%esi <== NOT EXECUTED
the_thread = 0;
current = 0;
107f4b: 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;
107f52: 31 db xor %ebx,%ebx <== NOT EXECUTED
107f54: e9 c1 fe ff ff jmp 107e1a <Stack_check_Dump_threads_usage+0x2a><== NOT EXECUTED
00107f5c <Stack_check_Initialize>:
/*
* Stack_check_Initialize
*/
void Stack_check_Initialize( void )
{
107f5c: 55 push %ebp
107f5d: 89 e5 mov %esp,%ebp
107f5f: 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 )
107f60: 8b 15 c8 a5 12 00 mov 0x12a5c8,%edx
107f66: 85 d2 test %edx,%edx
107f68: 75 5a jne 107fc4 <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 ];
107f6a: c7 05 20 a9 12 00 0d movl $0xfeedf00d,0x12a920
107f71: f0 ed fe
107f74: c7 05 24 a9 12 00 06 movl $0xbad0d06,0x12a924
107f7b: 0d ad 0b
107f7e: c7 05 28 a9 12 00 0d movl $0xdeadf00d,0x12a928
107f85: f0 ad de
107f88: c7 05 2c a9 12 00 06 movl $0x600d0d06,0x12a92c
107f8f: 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) {
107f92: 8b 15 cc b0 12 00 mov 0x12b0cc,%edx
107f98: 85 d2 test %edx,%edx
107f9a: 74 1e je 107fba <Stack_check_Initialize+0x5e><== NEVER TAKEN
107f9c: 8b 0d d0 b0 12 00 mov 0x12b0d0,%ecx
107fa2: 85 c9 test %ecx,%ecx
107fa4: 74 14 je 107fba <Stack_check_Initialize+0x5e><== NEVER TAKEN
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
107fa6: 89 15 34 a9 12 00 mov %edx,0x12a934
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
107fac: 29 d1 sub %edx,%ecx
107fae: 89 0d 30 a9 12 00 mov %ecx,0x12a930
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
107fb4: b0 a5 mov $0xa5,%al
107fb6: 89 d7 mov %edx,%edi
107fb8: f3 aa rep stos %al,%es:(%edi)
}
#endif
Stack_check_Initialized = 1;
107fba: c7 05 c8 a5 12 00 01 movl $0x1,0x12a5c8
107fc1: 00 00 00
}
107fc4: 5f pop %edi
107fc5: c9 leave
107fc6: c3 ret
00108018 <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)
{
108018: 55 push %ebp <== NOT EXECUTED
108019: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10801b: 56 push %esi <== NOT EXECUTED
10801c: 53 push %ebx <== NOT EXECUTED
10801d: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED
108020: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
108023: 8a 55 0c mov 0xc(%ebp),%dl <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
108026: 8b b3 bc 00 00 00 mov 0xbc(%ebx),%esi <== NOT EXECUTED
char name[32];
printk("BLOWN STACK!!!\n");
10802c: 68 bf 3d 12 00 push $0x123dbf <== NOT EXECUTED
108031: 88 55 d4 mov %dl,-0x2c(%ebp) <== NOT EXECUTED
108034: e8 cb 1b 00 00 call 109c04 <printk> <== NOT EXECUTED
printk("task control block: 0x%08" PRIxPTR "\n", running);
108039: 5a pop %edx <== NOT EXECUTED
10803a: 59 pop %ecx <== NOT EXECUTED
10803b: 53 push %ebx <== NOT EXECUTED
10803c: 68 cf 3d 12 00 push $0x123dcf <== NOT EXECUTED
108041: e8 be 1b 00 00 call 109c04 <printk> <== NOT EXECUTED
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
108046: 59 pop %ecx <== NOT EXECUTED
108047: 58 pop %eax <== NOT EXECUTED
108048: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
10804b: 68 ec 3d 12 00 push $0x123dec <== NOT EXECUTED
108050: e8 af 1b 00 00 call 109c04 <printk> <== NOT EXECUTED
printk(
108055: 58 pop %eax <== NOT EXECUTED
108056: 5a pop %edx <== NOT EXECUTED
108057: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED
10805a: 68 fe 3d 12 00 push $0x123dfe <== NOT EXECUTED
10805f: e8 a0 1b 00 00 call 109c04 <printk> <== NOT EXECUTED
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
108064: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
108067: 8d 45 d8 lea -0x28(%ebp),%eax <== NOT EXECUTED
10806a: 50 push %eax <== NOT EXECUTED
10806b: 6a 20 push $0x20 <== NOT EXECUTED
10806d: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
108070: e8 2f 5d 00 00 call 10dda4 <rtems_object_get_name> <== NOT EXECUTED
108075: 5a pop %edx <== NOT EXECUTED
108076: 59 pop %ecx <== NOT EXECUTED
108077: 50 push %eax <== NOT EXECUTED
108078: 68 12 3e 12 00 push $0x123e12 <== NOT EXECUTED
10807d: e8 82 1b 00 00 call 109c04 <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)
108082: 8b 8b bc 00 00 00 mov 0xbc(%ebx),%ecx <== NOT EXECUTED
108088: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
);
printk(
"task name string: %s\n",
rtems_object_get_name(running->Object.id, sizeof(name), name)
);
printk(
10808e: 8d 1c 01 lea (%ecx,%eax,1),%ebx <== NOT EXECUTED
108091: 53 push %ebx <== NOT EXECUTED
108092: 51 push %ecx <== NOT EXECUTED
108093: 50 push %eax <== NOT EXECUTED
108094: 68 40 3e 12 00 push $0x123e40 <== NOT EXECUTED
108099: e8 66 1b 00 00 call 109c04 <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) {
10809e: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
1080a1: 8a 55 d4 mov -0x2c(%ebp),%dl <== NOT EXECUTED
1080a4: 84 d2 test %dl,%dl <== NOT EXECUTED
1080a6: 74 10 je 1080b8 <Stack_check_report_blown_task+0xa0><== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
1080a8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1080ab: 68 81 00 00 00 push $0x81 <== NOT EXECUTED
1080b0: e8 ff 64 00 00 call 10e5b4 <rtems_fatal_error_occurred><== NOT EXECUTED
1080b5: 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);
1080b8: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
printk(
1080bb: 83 c6 18 add $0x18,%esi <== NOT EXECUTED
1080be: 56 push %esi <== NOT EXECUTED
1080bf: 50 push %eax <== NOT EXECUTED
1080c0: 6a 10 push $0x10 <== NOT EXECUTED
1080c2: 68 74 3e 12 00 push $0x123e74 <== NOT EXECUTED
1080c7: e8 38 1b 00 00 call 109c04 <printk> <== NOT EXECUTED
1080cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1080cf: eb d7 jmp 1080a8 <Stack_check_report_blown_task+0x90><== NOT EXECUTED
0010be9c <_API_extensions_Run_postdriver>:
*
* _API_extensions_Run_postdriver
*/
void _API_extensions_Run_postdriver( void )
{
10be9c: 55 push %ebp
10be9d: 89 e5 mov %esp,%ebp
10be9f: 53 push %ebx
10bea0: 83 ec 04 sub $0x4,%esp
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10bea3: 8b 1d b8 7f 12 00 mov 0x127fb8,%ebx
void _API_extensions_Run_postdriver( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
10bea9: 81 fb bc 7f 12 00 cmp $0x127fbc,%ebx
10beaf: 74 10 je 10bec1 <_API_extensions_Run_postdriver+0x25><== NEVER TAKEN
10beb1: 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)();
10beb4: 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 ) {
10beb7: 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 );
10beb9: 81 fb bc 7f 12 00 cmp $0x127fbc,%ebx
10bebf: 75 f3 jne 10beb4 <_API_extensions_Run_postdriver+0x18>
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
if ( the_extension->postdriver_hook )
#endif
(*the_extension->postdriver_hook)();
}
}
10bec1: 58 pop %eax
10bec2: 5b pop %ebx
10bec3: c9 leave
10bec4: c3 ret
0010bec8 <_API_extensions_Run_postswitch>:
*
* _API_extensions_Run_postswitch
*/
void _API_extensions_Run_postswitch( void )
{
10bec8: 55 push %ebp
10bec9: 89 e5 mov %esp,%ebp
10becb: 53 push %ebx
10becc: 83 ec 04 sub $0x4,%esp
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10becf: 8b 1d b8 7f 12 00 mov 0x127fb8,%ebx
void _API_extensions_Run_postswitch( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
10bed5: 81 fb bc 7f 12 00 cmp $0x127fbc,%ebx
10bedb: 74 1c je 10bef9 <_API_extensions_Run_postswitch+0x31><== NEVER TAKEN
10bedd: 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 );
10bee0: 83 ec 0c sub $0xc,%esp
10bee3: ff 35 38 83 12 00 pushl 0x128338
10bee9: 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 ) {
10beec: 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 );
10beee: 83 c4 10 add $0x10,%esp
10bef1: 81 fb bc 7f 12 00 cmp $0x127fbc,%ebx
10bef7: 75 e7 jne 10bee0 <_API_extensions_Run_postswitch+0x18>
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10bef9: 8b 5d fc mov -0x4(%ebp),%ebx
10befc: c9 leave
10befd: c3 ret
0010e3e0 <_CORE_RWLock_Obtain_for_reading>:
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
10e3e0: 55 push %ebp
10e3e1: 89 e5 mov %esp,%ebp
10e3e3: 57 push %edi
10e3e4: 56 push %esi
10e3e5: 53 push %ebx
10e3e6: 83 ec 1c sub $0x1c,%esp
10e3e9: 8b 5d 08 mov 0x8(%ebp),%ebx
10e3ec: 8b 7d 0c mov 0xc(%ebp),%edi
10e3ef: 8b 4d 14 mov 0x14(%ebp),%ecx
10e3f2: 8a 55 10 mov 0x10(%ebp),%dl
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
10e3f5: 8b 35 d8 bc 12 00 mov 0x12bcd8,%esi
* If unlocked, then OK to read.
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
10e3fb: 9c pushf
10e3fc: fa cli
10e3fd: 8f 45 e4 popl -0x1c(%ebp)
switch ( the_rwlock->current_state ) {
10e400: 8b 43 44 mov 0x44(%ebx),%eax
10e403: 85 c0 test %eax,%eax
10e405: 75 1d jne 10e424 <_CORE_RWLock_Obtain_for_reading+0x44>
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
10e407: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx)
the_rwlock->number_of_readers += 1;
10e40e: ff 43 48 incl 0x48(%ebx)
_ISR_Enable( level );
10e411: ff 75 e4 pushl -0x1c(%ebp)
10e414: 9d popf
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10e415: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi)
timeout,
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
10e41c: 8d 65 f4 lea -0xc(%ebp),%esp
10e41f: 5b pop %ebx
10e420: 5e pop %esi
10e421: 5f pop %edi
10e422: c9 leave
10e423: c3 ret
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
switch ( the_rwlock->current_state ) {
10e424: 48 dec %eax
10e425: 74 51 je 10e478 <_CORE_RWLock_Obtain_for_reading+0x98>
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
10e427: 84 d2 test %dl,%dl
10e429: 75 15 jne 10e440 <_CORE_RWLock_Obtain_for_reading+0x60>
_ISR_Enable( level );
10e42b: ff 75 e4 pushl -0x1c(%ebp)
10e42e: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10e42f: c7 46 34 02 00 00 00 movl $0x2,0x34(%esi)
timeout,
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
10e436: 8d 65 f4 lea -0xc(%ebp),%esp
10e439: 5b pop %ebx
10e43a: 5e pop %esi
10e43b: 5f pop %edi
10e43c: c9 leave
10e43d: c3 ret
10e43e: 66 90 xchg %ax,%ax
10e440: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx)
/*
* We need to wait to enter this critical section
*/
_Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue );
executing->Wait.queue = &the_rwlock->Wait_queue;
10e447: 89 5e 44 mov %ebx,0x44(%esi)
executing->Wait.id = id;
10e44a: 89 7e 20 mov %edi,0x20(%esi)
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
10e44d: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi)
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10e454: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi)
_ISR_Enable( level );
10e45b: ff 75 e4 pushl -0x1c(%ebp)
10e45e: 9d popf
_Thread_queue_Enqueue_with_handler(
10e45f: c7 45 10 e4 e5 10 00 movl $0x10e5e4,0x10(%ebp)
10e466: 89 4d 0c mov %ecx,0xc(%ebp)
10e469: 89 5d 08 mov %ebx,0x8(%ebp)
timeout,
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
10e46c: 8d 65 f4 lea -0xc(%ebp),%esp
10e46f: 5b pop %ebx
10e470: 5e pop %esi
10e471: 5f pop %edi
10e472: c9 leave
executing->Wait.id = id;
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
_ISR_Enable( level );
_Thread_queue_Enqueue_with_handler(
10e473: e9 1c 1c 00 00 jmp 110094 <_Thread_queue_Enqueue_with_handler>
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
return;
case CORE_RWLOCK_LOCKED_FOR_READING: {
Thread_Control *waiter;
waiter = _Thread_queue_First( &the_rwlock->Wait_queue );
10e478: 83 ec 0c sub $0xc,%esp
10e47b: 53 push %ebx
10e47c: 88 55 e0 mov %dl,-0x20(%ebp)
10e47f: 89 4d dc mov %ecx,-0x24(%ebp)
10e482: e8 35 1f 00 00 call 1103bc <_Thread_queue_First>
if ( !waiter ) {
10e487: 83 c4 10 add $0x10,%esp
10e48a: 85 c0 test %eax,%eax
10e48c: 8a 55 e0 mov -0x20(%ebp),%dl
10e48f: 8b 4d dc mov -0x24(%ebp),%ecx
10e492: 75 93 jne 10e427 <_CORE_RWLock_Obtain_for_reading+0x47>
the_rwlock->number_of_readers += 1;
10e494: ff 43 48 incl 0x48(%ebx)
_ISR_Enable( level );
10e497: ff 75 e4 pushl -0x1c(%ebp)
10e49a: 9d popf
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10e49b: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi)
return;
10e4a2: e9 75 ff ff ff jmp 10e41c <_CORE_RWLock_Obtain_for_reading+0x3c>
0010e4a8 <_CORE_RWLock_Obtain_for_writing>:
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
10e4a8: 55 push %ebp
10e4a9: 89 e5 mov %esp,%ebp
10e4ab: 57 push %edi
10e4ac: 56 push %esi
10e4ad: 53 push %ebx
10e4ae: 83 ec 0c sub $0xc,%esp
10e4b1: 8b 45 08 mov 0x8(%ebp),%eax
10e4b4: 8b 7d 0c mov 0xc(%ebp),%edi
10e4b7: 8b 75 14 mov 0x14(%ebp),%esi
10e4ba: 8a 5d 10 mov 0x10(%ebp),%bl
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
10e4bd: 8b 15 d8 bc 12 00 mov 0x12bcd8,%edx
* Otherwise, we have to block.
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
10e4c3: 9c pushf
10e4c4: fa cli
10e4c5: 59 pop %ecx
switch ( the_rwlock->current_state ) {
10e4c6: 83 78 44 00 cmpl $0x0,0x44(%eax)
10e4ca: 75 18 jne 10e4e4 <_CORE_RWLock_Obtain_for_writing+0x3c>
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
10e4cc: c7 40 44 02 00 00 00 movl $0x2,0x44(%eax)
_ISR_Enable( level );
10e4d3: 51 push %ecx
10e4d4: 9d popf
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10e4d5: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
10e4dc: 83 c4 0c add $0xc,%esp
10e4df: 5b pop %ebx
10e4e0: 5e pop %esi
10e4e1: 5f pop %edi
10e4e2: c9 leave
10e4e3: c3 ret
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
10e4e4: 84 db test %bl,%bl
10e4e6: 75 14 jne 10e4fc <_CORE_RWLock_Obtain_for_writing+0x54>
_ISR_Enable( level );
10e4e8: 51 push %ecx
10e4e9: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10e4ea: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx)
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
10e4f1: 83 c4 0c add $0xc,%esp
10e4f4: 5b pop %ebx
10e4f5: 5e pop %esi
10e4f6: 5f pop %edi
10e4f7: c9 leave
10e4f8: c3 ret
10e4f9: 8d 76 00 lea 0x0(%esi),%esi
10e4fc: c7 40 30 01 00 00 00 movl $0x1,0x30(%eax)
/*
* We need to wait to enter this critical section
*/
_Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue );
executing->Wait.queue = &the_rwlock->Wait_queue;
10e503: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
10e506: 89 7a 20 mov %edi,0x20(%edx)
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE;
10e509: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx)
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10e510: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
_ISR_Enable( level );
10e517: 51 push %ecx
10e518: 9d popf
_Thread_queue_Enqueue_with_handler(
10e519: c7 45 10 e4 e5 10 00 movl $0x10e5e4,0x10(%ebp)
10e520: 89 75 0c mov %esi,0xc(%ebp)
10e523: 89 45 08 mov %eax,0x8(%ebp)
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
10e526: 83 c4 0c add $0xc,%esp
10e529: 5b pop %ebx
10e52a: 5e pop %esi
10e52b: 5f pop %edi
10e52c: c9 leave
executing->Wait.id = id;
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE;
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
_ISR_Enable( level );
_Thread_queue_Enqueue_with_handler(
10e52d: e9 62 1b 00 00 jmp 110094 <_Thread_queue_Enqueue_with_handler>
0010e534 <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
10e534: 55 push %ebp
10e535: 89 e5 mov %esp,%ebp
10e537: 53 push %ebx
10e538: 83 ec 04 sub $0x4,%esp
10e53b: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
10e53e: 8b 0d d8 bc 12 00 mov 0x12bcd8,%ecx
* Otherwise, we have to block.
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
10e544: 9c pushf
10e545: fa cli
10e546: 5a pop %edx
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
10e547: 8b 43 44 mov 0x44(%ebx),%eax
10e54a: 85 c0 test %eax,%eax
10e54c: 74 7a je 10e5c8 <_CORE_RWLock_Release+0x94>
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
10e54e: 48 dec %eax
10e54f: 74 63 je 10e5b4 <_CORE_RWLock_Release+0x80>
return CORE_RWLOCK_SUCCESSFUL;
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10e551: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx)
/*
* Implicitly transition to "unlocked" and find another thread interested
* in obtaining this rwlock.
*/
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
10e558: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
_ISR_Enable( level );
10e55f: 52 push %edx
10e560: 9d popf
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
10e561: 83 ec 0c sub $0xc,%esp
10e564: 53 push %ebx
10e565: e8 02 1a 00 00 call 10ff6c <_Thread_queue_Dequeue>
if ( next ) {
10e56a: 83 c4 10 add $0x10,%esp
10e56d: 85 c0 test %eax,%eax
10e56f: 74 39 je 10e5aa <_CORE_RWLock_Release+0x76>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
10e571: 83 78 30 01 cmpl $0x1,0x30(%eax)
10e575: 74 61 je 10e5d8 <_CORE_RWLock_Release+0xa4>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
10e577: ff 43 48 incl 0x48(%ebx)
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
10e57a: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx)
10e581: eb 17 jmp 10e59a <_CORE_RWLock_Release+0x66>
10e583: 90 nop
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !next ||
10e584: 83 78 30 01 cmpl $0x1,0x30(%eax)
10e588: 74 20 je 10e5aa <_CORE_RWLock_Release+0x76><== NEVER TAKEN
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
10e58a: ff 43 48 incl 0x48(%ebx)
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
10e58d: 83 ec 08 sub $0x8,%esp
10e590: 50 push %eax
10e591: 53 push %ebx
10e592: e8 0d 1d 00 00 call 1102a4 <_Thread_queue_Extract>
}
10e597: 83 c4 10 add $0x10,%esp
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
10e59a: 83 ec 0c sub $0xc,%esp
10e59d: 53 push %ebx
10e59e: e8 19 1e 00 00 call 1103bc <_Thread_queue_First>
if ( !next ||
10e5a3: 83 c4 10 add $0x10,%esp
10e5a6: 85 c0 test %eax,%eax
10e5a8: 75 da jne 10e584 <_CORE_RWLock_Release+0x50>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10e5aa: 31 c0 xor %eax,%eax
10e5ac: 8b 5d fc mov -0x4(%ebp),%ebx
10e5af: c9 leave
10e5b0: c3 ret
10e5b1: 8d 76 00 lea 0x0(%esi),%esi
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
the_rwlock->number_of_readers -= 1;
10e5b4: 8b 43 48 mov 0x48(%ebx),%eax
10e5b7: 48 dec %eax
10e5b8: 89 43 48 mov %eax,0x48(%ebx)
if ( the_rwlock->number_of_readers != 0 ) {
10e5bb: 85 c0 test %eax,%eax
10e5bd: 74 92 je 10e551 <_CORE_RWLock_Release+0x1d>
/* must be unlocked again */
_ISR_Enable( level );
10e5bf: 52 push %edx
10e5c0: 9d popf
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10e5c1: 31 c0 xor %eax,%eax
10e5c3: 8b 5d fc mov -0x4(%ebp),%ebx
10e5c6: c9 leave
10e5c7: c3 ret
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
_ISR_Enable( level );
10e5c8: 52 push %edx
10e5c9: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10e5ca: c7 41 34 02 00 00 00 movl $0x2,0x34(%ecx)
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10e5d1: 31 c0 xor %eax,%eax
10e5d3: 8b 5d fc mov -0x4(%ebp),%ebx
10e5d6: c9 leave
10e5d7: c3 ret
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
if ( next ) {
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
10e5d8: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx)
return CORE_RWLOCK_SUCCESSFUL;
10e5df: eb c9 jmp 10e5aa <_CORE_RWLock_Release+0x76>
0010e5e4 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
10e5e4: 55 push %ebp
10e5e5: 89 e5 mov %esp,%ebp
10e5e7: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10e5ea: 8d 45 f4 lea -0xc(%ebp),%eax
10e5ed: 50 push %eax
10e5ee: ff 75 08 pushl 0x8(%ebp)
10e5f1: e8 1e 16 00 00 call 10fc14 <_Thread_Get>
switch ( location ) {
10e5f6: 83 c4 10 add $0x10,%esp
10e5f9: 8b 55 f4 mov -0xc(%ebp),%edx
10e5fc: 85 d2 test %edx,%edx
10e5fe: 75 17 jne 10e617 <_CORE_RWLock_Timeout+0x33><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
10e600: 83 ec 0c sub $0xc,%esp
10e603: 50 push %eax
10e604: e8 93 1e 00 00 call 11049c <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10e609: a1 30 b7 12 00 mov 0x12b730,%eax
10e60e: 48 dec %eax
10e60f: a3 30 b7 12 00 mov %eax,0x12b730
10e614: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10e617: c9 leave
10e618: c3 ret
001198dc <_CORE_message_queue_Broadcast>:
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
1198dc: 55 push %ebp
1198dd: 89 e5 mov %esp,%ebp
1198df: 57 push %edi
1198e0: 56 push %esi
1198e1: 53 push %ebx
1198e2: 83 ec 1c sub $0x1c,%esp
1198e5: 8b 5d 08 mov 0x8(%ebp),%ebx
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
1198e8: 8b 45 10 mov 0x10(%ebp),%eax
1198eb: 39 43 4c cmp %eax,0x4c(%ebx)
1198ee: 72 60 jb 119950 <_CORE_message_queue_Broadcast+0x74><== NEVER TAKEN
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
1198f0: 8b 43 48 mov 0x48(%ebx),%eax
1198f3: 85 c0 test %eax,%eax
1198f5: 75 45 jne 11993c <_CORE_message_queue_Broadcast+0x60>
1198f7: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
1198fe: eb 18 jmp 119918 <_CORE_message_queue_Broadcast+0x3c>
*/
number_broadcasted = 0;
while ((the_thread =
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
119900: ff 45 e4 incl -0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
119903: 8b 42 2c mov 0x2c(%edx),%eax
119906: 89 c7 mov %eax,%edi
119908: 8b 75 0c mov 0xc(%ebp),%esi
11990b: 8b 4d 10 mov 0x10(%ebp),%ecx
11990e: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
119910: 8b 42 28 mov 0x28(%edx),%eax
119913: 8b 55 10 mov 0x10(%ebp),%edx
119916: 89 10 mov %edx,(%eax)
/*
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
number_broadcasted = 0;
while ((the_thread =
119918: 83 ec 0c sub $0xc,%esp
11991b: 53 push %ebx
11991c: e8 af 28 00 00 call 11c1d0 <_Thread_queue_Dequeue>
119921: 89 c2 mov %eax,%edx
119923: 83 c4 10 add $0x10,%esp
119926: 85 c0 test %eax,%eax
119928: 75 d6 jne 119900 <_CORE_message_queue_Broadcast+0x24>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
11992a: 8b 55 e4 mov -0x1c(%ebp),%edx
11992d: 8b 45 1c mov 0x1c(%ebp),%eax
119930: 89 10 mov %edx,(%eax)
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
119932: 31 c0 xor %eax,%eax
}
119934: 8d 65 f4 lea -0xc(%ebp),%esp
119937: 5b pop %ebx
119938: 5e pop %esi
119939: 5f pop %edi
11993a: c9 leave
11993b: c3 ret
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
*count = 0;
11993c: 8b 55 1c mov 0x1c(%ebp),%edx
11993f: c7 02 00 00 00 00 movl $0x0,(%edx)
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
119945: 31 c0 xor %eax,%eax
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
119947: 8d 65 f4 lea -0xc(%ebp),%esp
11994a: 5b pop %ebx
11994b: 5e pop %esi
11994c: 5f pop %edi
11994d: c9 leave
11994e: c3 ret
11994f: 90 nop
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
119950: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
119955: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
119958: 5b pop %ebx <== NOT EXECUTED
119959: 5e pop %esi <== NOT EXECUTED
11995a: 5f pop %edi <== NOT EXECUTED
11995b: c9 leave <== NOT EXECUTED
11995c: c3 ret <== NOT EXECUTED
00114a1c <_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
)
{
114a1c: 55 push %ebp
114a1d: 89 e5 mov %esp,%ebp
114a1f: 57 push %edi
114a20: 56 push %esi
114a21: 53 push %ebx
114a22: 83 ec 0c sub $0xc,%esp
114a25: 8b 5d 08 mov 0x8(%ebp),%ebx
114a28: 8b 75 10 mov 0x10(%ebp),%esi
114a2b: 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;
114a2e: 89 73 44 mov %esi,0x44(%ebx)
the_message_queue->number_of_pending_messages = 0;
114a31: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
the_message_queue->maximum_message_size = maximum_message_size;
114a38: 89 43 4c mov %eax,0x4c(%ebx)
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Notify_Handler the_handler,
void *the_argument
)
{
the_message_queue->notify_handler = the_handler;
114a3b: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
the_message_queue->notify_argument = the_argument;
114a42: c7 43 64 00 00 00 00 movl $0x0,0x64(%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)) {
114a49: a8 03 test $0x3,%al
114a4b: 74 17 je 114a64 <_CORE_message_queue_Initialize+0x48>
allocated_message_size += sizeof(uint32_t);
114a4d: 8d 50 04 lea 0x4(%eax),%edx
allocated_message_size &= ~(sizeof(uint32_t) - 1);
114a50: 83 e2 fc and $0xfffffffc,%edx
}
if (allocated_message_size < maximum_message_size)
114a53: 39 d0 cmp %edx,%eax
114a55: 76 0f jbe 114a66 <_CORE_message_queue_Initialize+0x4a><== 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;
114a57: 31 c0 xor %eax,%eax
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
}
114a59: 8d 65 f4 lea -0xc(%ebp),%esp
114a5c: 5b pop %ebx
114a5d: 5e pop %esi
114a5e: 5f pop %edi
114a5f: c9 leave
114a60: c3 ret
114a61: 8d 76 00 lea 0x0(%esi),%esi
/*
* 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)) {
114a64: 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));
114a66: 8d 7a 14 lea 0x14(%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 *
114a69: 89 f8 mov %edi,%eax
114a6b: 0f af c6 imul %esi,%eax
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
114a6e: 39 d0 cmp %edx,%eax
114a70: 72 e5 jb 114a57 <_CORE_message_queue_Initialize+0x3b><== NEVER TAKEN
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
114a72: 83 ec 0c sub $0xc,%esp
114a75: 50 push %eax
114a76: e8 4d 2b 00 00 call 1175c8 <_Workspace_Allocate>
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
114a7b: 89 43 5c mov %eax,0x5c(%ebx)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
114a7e: 83 c4 10 add $0x10,%esp
114a81: 85 c0 test %eax,%eax
114a83: 74 d2 je 114a57 <_CORE_message_queue_Initialize+0x3b>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
114a85: 57 push %edi
114a86: 56 push %esi
114a87: 50 push %eax
114a88: 8d 43 68 lea 0x68(%ebx),%eax
114a8b: 50 push %eax
114a8c: e8 47 52 00 00 call 119cd8 <_Chain_Initialize>
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 );
114a91: 8d 43 54 lea 0x54(%ebx),%eax
114a94: 89 43 50 mov %eax,0x50(%ebx)
head->next = tail;
head->previous = NULL;
114a97: 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 );
114a9e: 8d 43 50 lea 0x50(%ebx),%eax
114aa1: 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(
114aa4: 6a 06 push $0x6
114aa6: 68 80 00 00 00 push $0x80
114aab: 8b 45 0c mov 0xc(%ebp),%eax
114aae: 83 38 01 cmpl $0x1,(%eax)
114ab1: 0f 94 c0 sete %al
114ab4: 0f b6 c0 movzbl %al,%eax
114ab7: 50 push %eax
114ab8: 53 push %ebx
114ab9: e8 3e 22 00 00 call 116cfc <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
114abe: 83 c4 20 add $0x20,%esp
114ac1: b0 01 mov $0x1,%al
}
114ac3: 8d 65 f4 lea -0xc(%ebp),%esp
114ac6: 5b pop %ebx
114ac7: 5e pop %esi
114ac8: 5f pop %edi
114ac9: c9 leave
114aca: c3 ret
001110e0 <_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
)
{
1110e0: 55 push %ebp
1110e1: 89 e5 mov %esp,%ebp
1110e3: 56 push %esi
1110e4: 53 push %ebx
1110e5: 83 ec 10 sub $0x10,%esp
1110e8: 8b 45 08 mov 0x8(%ebp),%eax
1110eb: 8b 55 0c mov 0xc(%ebp),%edx
1110ee: 8b 4d 10 mov 0x10(%ebp),%ecx
1110f1: 89 4a 08 mov %ecx,0x8(%edx)
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
else
_CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
#else
if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST ) {
1110f4: 81 f9 ff ff ff 7f cmp $0x7fffffff,%ecx
1110fa: 74 70 je 11116c <_CORE_message_queue_Insert_message+0x8c>
_ISR_Disable( level );
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
} else if ( submit_type == CORE_MESSAGE_QUEUE_URGENT_REQUEST ) {
1110fc: 81 f9 00 00 00 80 cmp $0x80000000,%ecx
111102: 0f 84 88 00 00 00 je 111190 <_CORE_message_queue_Insert_message+0xb0>
* 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
}
111108: 8b 58 50 mov 0x50(%eax),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
11110b: 8d 70 54 lea 0x54(%eax),%esi
int the_priority;
the_priority = _CORE_message_queue_Get_message_priority(the_message);
the_header = &the_message_queue->Pending_messages;
the_node = _Chain_First( the_header );
while ( !_Chain_Is_tail( the_header, the_node ) ) {
11110e: 39 de cmp %ebx,%esi
111110: 74 05 je 111117 <_CORE_message_queue_Insert_message+0x37>
this_message = (CORE_message_queue_Buffer_control *) the_node;
this_priority = _CORE_message_queue_Get_message_priority(this_message);
if ( this_priority <= the_priority ) {
111112: 3b 4b 08 cmp 0x8(%ebx),%ecx
111115: 7d 45 jge 11115c <_CORE_message_queue_Insert_message+0x7c>
the_node = the_node->next;
continue;
}
break;
}
_ISR_Disable( level );
111117: 9c pushf
111118: fa cli
111119: 5e pop %esi
SET_NOTIFY();
11111a: 8b 48 48 mov 0x48(%eax),%ecx
*
* INTERRUPT LATENCY:
* insert
*/
void _CORE_message_queue_Insert_message(
11111d: 85 c9 test %ecx,%ecx
11111f: 0f 94 45 f7 sete -0x9(%ebp)
}
break;
}
_ISR_Disable( level );
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
111123: 41 inc %ecx
111124: 89 48 48 mov %ecx,0x48(%eax)
_Chain_Insert_unprotected( the_node->previous, &the_message->Node );
111127: 8b 4b 04 mov 0x4(%ebx),%ecx
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
11112a: 89 4a 04 mov %ecx,0x4(%edx)
before_node = after_node->next;
11112d: 8b 19 mov (%ecx),%ebx
after_node->next = the_node;
11112f: 89 11 mov %edx,(%ecx)
the_node->next = before_node;
111131: 89 1a mov %ebx,(%edx)
before_node->previous = the_node;
111133: 89 53 04 mov %edx,0x4(%ebx)
_ISR_Enable( level );
111136: 56 push %esi
111137: 9d popf
/*
* According to POSIX, does this happen before or after the message
* is actually enqueued. It is logical to think afterwards, because
* the message is actually in the queue at this point.
*/
if ( notify && the_message_queue->notify_handler )
111138: 80 7d f7 00 cmpb $0x0,-0x9(%ebp)
11113c: 74 16 je 111154 <_CORE_message_queue_Insert_message+0x74>
11113e: 8b 50 60 mov 0x60(%eax),%edx
111141: 85 d2 test %edx,%edx
111143: 74 0f je 111154 <_CORE_message_queue_Insert_message+0x74>
(*the_message_queue->notify_handler)(the_message_queue->notify_argument);
111145: 8b 40 64 mov 0x64(%eax),%eax
111148: 89 45 08 mov %eax,0x8(%ebp)
#endif
}
11114b: 83 c4 10 add $0x10,%esp
11114e: 5b pop %ebx
11114f: 5e pop %esi
111150: c9 leave
* According to POSIX, does this happen before or after the message
* is actually enqueued. It is logical to think afterwards, because
* 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);
111151: ff e2 jmp *%edx
111153: 90 nop
#endif
}
111154: 83 c4 10 add $0x10,%esp
111157: 5b pop %ebx
111158: 5e pop %esi
111159: c9 leave
11115a: c3 ret
11115b: 90 nop
this_message = (CORE_message_queue_Buffer_control *) the_node;
this_priority = _CORE_message_queue_Get_message_priority(this_message);
if ( this_priority <= the_priority ) {
the_node = the_node->next;
11115c: 8b 1b mov (%ebx),%ebx
int the_priority;
the_priority = _CORE_message_queue_Get_message_priority(the_message);
the_header = &the_message_queue->Pending_messages;
the_node = _Chain_First( the_header );
while ( !_Chain_Is_tail( the_header, the_node ) ) {
11115e: 39 de cmp %ebx,%esi
111160: 74 b5 je 111117 <_CORE_message_queue_Insert_message+0x37>
this_message = (CORE_message_queue_Buffer_control *) the_node;
this_priority = _CORE_message_queue_Get_message_priority(this_message);
if ( this_priority <= the_priority ) {
111162: 3b 4b 08 cmp 0x8(%ebx),%ecx
111165: 7c b0 jl 111117 <_CORE_message_queue_Insert_message+0x37>
111167: eb f3 jmp 11115c <_CORE_message_queue_Insert_message+0x7c>
111169: 8d 76 00 lea 0x0(%esi),%esi
else
_CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
#else
if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST ) {
_ISR_Disable( level );
11116c: 9c pushf
11116d: fa cli
11116e: 5b pop %ebx
SET_NOTIFY();
11116f: 8b 48 48 mov 0x48(%eax),%ecx
*
* INTERRUPT LATENCY:
* insert
*/
void _CORE_message_queue_Insert_message(
111172: 85 c9 test %ecx,%ecx
111174: 0f 94 45 f7 sete -0x9(%ebp)
_ISR_Enable( level );
#else
if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST ) {
_ISR_Disable( level );
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
111178: 41 inc %ecx
111179: 89 48 48 mov %ecx,0x48(%eax)
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
11117c: 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 );
11117f: 8d 70 54 lea 0x54(%eax),%esi
111182: 89 32 mov %esi,(%edx)
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
111184: 89 50 58 mov %edx,0x58(%eax)
old_last->next = the_node;
111187: 89 11 mov %edx,(%ecx)
the_node->previous = old_last;
111189: 89 4a 04 mov %ecx,0x4(%edx)
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
11118c: 53 push %ebx
11118d: 9d popf
11118e: eb a8 jmp 111138 <_CORE_message_queue_Insert_message+0x58>
} else if ( submit_type == CORE_MESSAGE_QUEUE_URGENT_REQUEST ) {
_ISR_Disable( level );
111190: 9c pushf
111191: fa cli
111192: 5b pop %ebx
SET_NOTIFY();
111193: 8b 48 48 mov 0x48(%eax),%ecx
*
* INTERRUPT LATENCY:
* insert
*/
void _CORE_message_queue_Insert_message(
111196: 85 c9 test %ecx,%ecx
111198: 0f 94 45 f7 sete -0x9(%ebp)
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
} else if ( submit_type == CORE_MESSAGE_QUEUE_URGENT_REQUEST ) {
_ISR_Disable( level );
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
11119c: 41 inc %ecx
11119d: 89 48 48 mov %ecx,0x48(%eax)
RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert_unprotected(_Chain_Head(the_chain), the_node);
1111a0: 8d 48 50 lea 0x50(%eax),%ecx
1111a3: 89 4a 04 mov %ecx,0x4(%edx)
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
1111a6: 8b 48 50 mov 0x50(%eax),%ecx
after_node->next = the_node;
1111a9: 89 50 50 mov %edx,0x50(%eax)
the_node->next = before_node;
1111ac: 89 0a mov %ecx,(%edx)
before_node->previous = the_node;
1111ae: 89 51 04 mov %edx,0x4(%ecx)
_CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
1111b1: 53 push %ebx
1111b2: 9d popf
1111b3: eb 83 jmp 111138 <_CORE_message_queue_Insert_message+0x58>
00114acc <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
114acc: 55 push %ebp
114acd: 89 e5 mov %esp,%ebp
114acf: 57 push %edi
114ad0: 56 push %esi
114ad1: 53 push %ebx
114ad2: 83 ec 2c sub $0x2c,%esp
114ad5: 8b 55 08 mov 0x8(%ebp),%edx
114ad8: 8b 45 0c mov 0xc(%ebp),%eax
114adb: 89 45 dc mov %eax,-0x24(%ebp)
114ade: 8b 4d 10 mov 0x10(%ebp),%ecx
114ae1: 89 4d e0 mov %ecx,-0x20(%ebp)
114ae4: 8b 45 14 mov 0x14(%ebp),%eax
114ae7: 8b 5d 1c mov 0x1c(%ebp),%ebx
114aea: 89 5d d8 mov %ebx,-0x28(%ebp)
114aed: 0f b6 7d 18 movzbl 0x18(%ebp),%edi
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
114af1: 8b 0d d8 0c 13 00 mov 0x130cd8,%ecx
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
114af7: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx)
_ISR_Disable( level );
114afe: 9c pushf
114aff: fa cli
114b00: 8f 45 e4 popl -0x1c(%ebp)
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
114b03: 8b 5a 50 mov 0x50(%edx),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
114b06: 8d 72 54 lea 0x54(%edx),%esi
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
114b09: 39 f3 cmp %esi,%ebx
114b0b: 74 7b je 114b88 <_CORE_message_queue_Seize+0xbc>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
114b0d: 8b 0b mov (%ebx),%ecx
head->next = new_first;
114b0f: 89 4a 50 mov %ecx,0x50(%edx)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
114b12: 8d 72 50 lea 0x50(%edx),%esi
114b15: 89 71 04 mov %esi,0x4(%ecx)
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
_ISR_Disable( level );
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
the_message_queue->number_of_pending_messages -= 1;
114b18: ff 4a 48 decl 0x48(%edx)
_ISR_Enable( level );
114b1b: ff 75 e4 pushl -0x1c(%ebp)
114b1e: 9d popf
*size_p = the_message->Contents.size;
114b1f: 8b 4b 0c mov 0xc(%ebx),%ecx
114b22: 89 08 mov %ecx,(%eax)
_Thread_Executing->Wait.count =
114b24: 8b 73 08 mov 0x8(%ebx),%esi
114b27: 8b 0d d8 0c 13 00 mov 0x130cd8,%ecx
114b2d: 89 71 24 mov %esi,0x24(%ecx)
_CORE_message_queue_Get_message_priority( the_message );
_CORE_message_queue_Copy_buffer(
the_message->Contents.buffer,
114b30: 8d 4b 10 lea 0x10(%ebx),%ecx
114b33: 89 4d e4 mov %ecx,-0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
114b36: 8b 08 mov (%eax),%ecx
114b38: 8b 7d e0 mov -0x20(%ebp),%edi
114b3b: 8b 75 e4 mov -0x1c(%ebp),%esi
114b3e: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
* is not, then we can go ahead and free the buffer.
*
* NOTE: If we note that the queue was not full before this receive,
* then we can avoid this dequeue.
*/
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
114b40: 83 ec 0c sub $0xc,%esp
114b43: 52 push %edx
114b44: 89 55 d4 mov %edx,-0x2c(%ebp)
114b47: e8 20 1e 00 00 call 11696c <_Thread_queue_Dequeue>
if ( !the_thread ) {
114b4c: 83 c4 10 add $0x10,%esp
114b4f: 85 c0 test %eax,%eax
114b51: 8b 55 d4 mov -0x2c(%ebp),%edx
114b54: 0f 84 86 00 00 00 je 114be0 <_CORE_message_queue_Seize+0x114>
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
114b5a: 8b 48 24 mov 0x24(%eax),%ecx
114b5d: 89 4b 08 mov %ecx,0x8(%ebx)
*/
_CORE_message_queue_Set_message_priority(
the_message,
the_thread->Wait.count
);
the_message->Contents.size = (size_t) the_thread->Wait.option;
114b60: 8b 48 30 mov 0x30(%eax),%ecx
114b63: 89 4b 0c mov %ecx,0xc(%ebx)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
114b66: 8b 70 2c mov 0x2c(%eax),%esi
114b69: 8b 7d e4 mov -0x1c(%ebp),%edi
114b6c: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
114b6e: 8b 43 08 mov 0x8(%ebx),%eax
114b71: 89 45 10 mov %eax,0x10(%ebp)
114b74: 89 5d 0c mov %ebx,0xc(%ebp)
114b77: 89 55 08 mov %edx,0x8(%ebp)
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
114b7a: 8d 65 f4 lea -0xc(%ebp),%esp
114b7d: 5b pop %ebx
114b7e: 5e pop %esi
114b7f: 5f pop %edi
114b80: c9 leave
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
114b81: e9 ae 51 00 00 jmp 119d34 <_CORE_message_queue_Insert_message>
114b86: 66 90 xchg %ax,%ax
return;
}
#endif
}
if ( !wait ) {
114b88: 89 fb mov %edi,%ebx
114b8a: 84 db test %bl,%bl
114b8c: 75 16 jne 114ba4 <_CORE_message_queue_Seize+0xd8>
_ISR_Enable( level );
114b8e: ff 75 e4 pushl -0x1c(%ebp)
114b91: 9d popf
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
114b92: c7 41 34 04 00 00 00 movl $0x4,0x34(%ecx)
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
114b99: 8d 65 f4 lea -0xc(%ebp),%esp
114b9c: 5b pop %ebx
114b9d: 5e pop %esi
114b9e: 5f pop %edi
114b9f: c9 leave
114ba0: c3 ret
114ba1: 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;
114ba4: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx)
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
return;
}
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
114bab: 89 51 44 mov %edx,0x44(%ecx)
executing->Wait.id = id;
114bae: 8b 5d dc mov -0x24(%ebp),%ebx
114bb1: 89 59 20 mov %ebx,0x20(%ecx)
executing->Wait.return_argument_second.mutable_object = buffer;
114bb4: 8b 5d e0 mov -0x20(%ebp),%ebx
114bb7: 89 59 2c mov %ebx,0x2c(%ecx)
executing->Wait.return_argument = size_p;
114bba: 89 41 28 mov %eax,0x28(%ecx)
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
114bbd: ff 75 e4 pushl -0x1c(%ebp)
114bc0: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
114bc1: c7 45 10 c0 6d 11 00 movl $0x116dc0,0x10(%ebp)
114bc8: 8b 45 d8 mov -0x28(%ebp),%eax
114bcb: 89 45 0c mov %eax,0xc(%ebp)
114bce: 89 55 08 mov %edx,0x8(%ebp)
}
114bd1: 8d 65 f4 lea -0xc(%ebp),%esp
114bd4: 5b pop %ebx
114bd5: 5e pop %esi
114bd6: 5f pop %edi
114bd7: c9 leave
executing->Wait.return_argument_second.mutable_object = buffer;
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
114bd8: e9 b7 1e 00 00 jmp 116a94 <_Thread_queue_Enqueue_with_handler>
114bdd: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _CORE_message_queue_Free_message_buffer (
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Buffer_control *the_message
)
{
_Chain_Append( &the_message_queue->Inactive_messages, &the_message->Node );
114be0: 89 5d 0c mov %ebx,0xc(%ebp)
114be3: 83 c2 68 add $0x68,%edx
114be6: 89 55 08 mov %edx,0x8(%ebp)
}
114be9: 8d 65 f4 lea -0xc(%ebp),%esp
114bec: 5b pop %ebx
114bed: 5e pop %esi
114bee: 5f pop %edi
114bef: c9 leave
114bf0: e9 a7 fd ff ff jmp 11499c <_Chain_Append>
0010c038 <_CORE_message_queue_Submit>:
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
10c038: 55 push %ebp
10c039: 89 e5 mov %esp,%ebp
10c03b: 57 push %edi
10c03c: 56 push %esi
10c03d: 53 push %ebx
10c03e: 83 ec 1c sub $0x1c,%esp
10c041: 8b 5d 08 mov 0x8(%ebp),%ebx
10c044: 8b 75 0c mov 0xc(%ebp),%esi
10c047: 8a 4d 20 mov 0x20(%ebp),%cl
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
10c04a: 8b 45 10 mov 0x10(%ebp),%eax
10c04d: 39 43 4c cmp %eax,0x4c(%ebx)
10c050: 72 32 jb 10c084 <_CORE_message_queue_Submit+0x4c>
}
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
10c052: 8b 43 48 mov 0x48(%ebx),%eax
10c055: 85 c0 test %eax,%eax
10c057: 74 3b je 10c094 <_CORE_message_queue_Submit+0x5c>
/*
* 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 <
10c059: 39 43 44 cmp %eax,0x44(%ebx)
10c05c: 0f 87 ba 00 00 00 ja 10c11c <_CORE_message_queue_Submit+0xe4>
/*
* No message buffers were available so we may need to return an
* overflow error or block the sender until the message is placed
* on the queue.
*/
if ( !wait ) {
10c062: 84 c9 test %cl,%cl
10c064: 0f 84 ee 00 00 00 je 10c158 <_CORE_message_queue_Submit+0x120>
/*
* Do NOT block on a send if the caller is in an ISR. It is
* deadly to block in an ISR.
*/
if ( _ISR_Is_in_progress() ) {
10c06a: 8b 15 34 83 12 00 mov 0x128334,%edx
10c070: 85 d2 test %edx,%edx
10c072: 74 60 je 10c0d4 <_CORE_message_queue_Submit+0x9c>
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED;
10c074: b8 03 00 00 00 mov $0x3,%eax
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
#endif
}
10c079: 8d 65 f4 lea -0xc(%ebp),%esp
10c07c: 5b pop %ebx
10c07d: 5e pop %esi
10c07e: 5f pop %edi
10c07f: c9 leave
10c080: c3 ret
10c081: 8d 76 00 lea 0x0(%esi),%esi
{
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;
10c084: 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
}
10c089: 8d 65 f4 lea -0xc(%ebp),%esp
10c08c: 5b pop %ebx
10c08d: 5e pop %esi
10c08e: 5f pop %edi
10c08f: c9 leave
10c090: c3 ret
10c091: 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 );
10c094: 83 ec 0c sub $0xc,%esp
10c097: 53 push %ebx
10c098: 88 4d e4 mov %cl,-0x1c(%ebp)
10c09b: e8 8c 1c 00 00 call 10dd2c <_Thread_queue_Dequeue>
10c0a0: 89 c2 mov %eax,%edx
if ( the_thread ) {
10c0a2: 83 c4 10 add $0x10,%esp
10c0a5: 85 c0 test %eax,%eax
10c0a7: 8a 4d e4 mov -0x1c(%ebp),%cl
10c0aa: 0f 84 b8 00 00 00 je 10c168 <_CORE_message_queue_Submit+0x130>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
10c0b0: 8b 40 2c mov 0x2c(%eax),%eax
10c0b3: 89 c7 mov %eax,%edi
10c0b5: 8b 4d 10 mov 0x10(%ebp),%ecx
10c0b8: 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;
10c0ba: 8b 42 28 mov 0x28(%edx),%eax
10c0bd: 8b 4d 10 mov 0x10(%ebp),%ecx
10c0c0: 89 08 mov %ecx,(%eax)
the_thread->Wait.count = (uint32_t) submit_type;
10c0c2: 8b 45 1c mov 0x1c(%ebp),%eax
10c0c5: 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;
10c0c8: 31 c0 xor %eax,%eax
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
#endif
}
10c0ca: 8d 65 f4 lea -0xc(%ebp),%esp
10c0cd: 5b pop %ebx
10c0ce: 5e pop %esi
10c0cf: 5f pop %edi
10c0d0: c9 leave
10c0d1: c3 ret
10c0d2: 66 90 xchg %ax,%ax
* Thus the unusual choice to open a new scope and declare
* it as a variable. Doing this emphasizes how dangerous it
* would be to use this variable prior to here.
*/
{
Thread_Control *executing = _Thread_Executing;
10c0d4: a1 38 83 12 00 mov 0x128338,%eax
ISR_Level level;
_ISR_Disable( level );
10c0d9: 9c pushf
10c0da: fa cli
10c0db: 59 pop %ecx
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;
10c0dc: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx)
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
10c0e3: 89 58 44 mov %ebx,0x44(%eax)
executing->Wait.id = id;
10c0e6: 8b 55 14 mov 0x14(%ebp),%edx
10c0e9: 89 50 20 mov %edx,0x20(%eax)
executing->Wait.return_argument_second.immutable_object = buffer;
10c0ec: 89 70 2c mov %esi,0x2c(%eax)
executing->Wait.option = (uint32_t) size;
10c0ef: 8b 55 10 mov 0x10(%ebp),%edx
10c0f2: 89 50 30 mov %edx,0x30(%eax)
executing->Wait.count = submit_type;
10c0f5: 8b 55 1c mov 0x1c(%ebp),%edx
10c0f8: 89 50 24 mov %edx,0x24(%eax)
_ISR_Enable( level );
10c0fb: 51 push %ecx
10c0fc: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
10c0fd: 50 push %eax
10c0fe: 68 80 e1 10 00 push $0x10e180
10c103: ff 75 24 pushl 0x24(%ebp)
10c106: 53 push %ebx
10c107: e8 48 1d 00 00 call 10de54 <_Thread_queue_Enqueue_with_handler>
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
10c10c: 83 c4 10 add $0x10,%esp
10c10f: b8 07 00 00 00 mov $0x7,%eax
#endif
}
10c114: 8d 65 f4 lea -0xc(%ebp),%esp
10c117: 5b pop %ebx
10c118: 5e pop %esi
10c119: 5f pop %edi
10c11a: c9 leave
10c11b: 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 );
10c11c: 83 ec 0c sub $0xc,%esp
10c11f: 8d 43 68 lea 0x68(%ebx),%eax
10c122: 50 push %eax
10c123: e8 ec fe ff ff call 10c014 <_Chain_Get>
10c128: 89 c2 mov %eax,%edx
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED;
#endif
_CORE_message_queue_Copy_buffer(
buffer,
the_message->Contents.buffer,
10c12a: 8d 40 10 lea 0x10(%eax),%eax
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
10c12d: 89 c7 mov %eax,%edi
10c12f: 8b 4d 10 mov 0x10(%ebp),%ecx
10c132: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
size
);
the_message->Contents.size = size;
10c134: 8b 4d 10 mov 0x10(%ebp),%ecx
10c137: 89 4a 0c mov %ecx,0xc(%edx)
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
10c13a: 8b 45 1c mov 0x1c(%ebp),%eax
10c13d: 89 42 08 mov %eax,0x8(%edx)
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
10c140: 83 c4 0c add $0xc,%esp
10c143: 50 push %eax
10c144: 52 push %edx
10c145: 53 push %ebx
10c146: e8 95 4f 00 00 call 1110e0 <_CORE_message_queue_Insert_message>
the_message_queue,
the_message,
submit_type
);
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
10c14b: 83 c4 10 add $0x10,%esp
10c14e: 31 c0 xor %eax,%eax
10c150: e9 34 ff ff ff jmp 10c089 <_CORE_message_queue_Submit+0x51>
10c155: 8d 76 00 lea 0x0(%esi),%esi
* No message buffers were available so we may need to return an
* overflow error or block the sender until the message is placed
* on the queue.
*/
if ( !wait ) {
return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY;
10c158: 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
}
10c15d: 8d 65 f4 lea -0xc(%ebp),%esp
10c160: 5b pop %ebx
10c161: 5e pop %esi
10c162: 5f pop %edi
10c163: c9 leave
10c164: c3 ret
10c165: 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 );
if ( the_thread ) {
10c168: 8b 43 48 mov 0x48(%ebx),%eax
10c16b: e9 e9 fe ff ff jmp 10c059 <_CORE_message_queue_Submit+0x21>
0010c17c <_CORE_mutex_Initialize>:
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
10c17c: 55 push %ebp
10c17d: 89 e5 mov %esp,%ebp
10c17f: 57 push %edi
10c180: 56 push %esi
10c181: 53 push %ebx
10c182: 83 ec 0c sub $0xc,%esp
10c185: 8b 45 08 mov 0x8(%ebp),%eax
10c188: 8b 5d 0c mov 0xc(%ebp),%ebx
10c18b: 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;
10c18e: 8d 78 40 lea 0x40(%eax),%edi
10c191: b9 04 00 00 00 mov $0x4,%ecx
10c196: 89 de mov %ebx,%esi
10c198: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_mutex->lock = initial_lock;
10c19a: 89 50 50 mov %edx,0x50(%eax)
the_mutex->blocked_count = 0;
10c19d: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
if ( initial_lock == CORE_MUTEX_LOCKED ) {
10c1a4: 85 d2 test %edx,%edx
10c1a6: 75 30 jne 10c1d8 <_CORE_mutex_Initialize+0x5c>
the_mutex->nest_count = 1;
10c1a8: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax)
the_mutex->holder = _Thread_Executing;
10c1af: 8b 15 38 83 12 00 mov 0x128338,%edx
10c1b5: 89 50 5c mov %edx,0x5c(%eax)
the_mutex->holder_id = _Thread_Executing->Object.id;
10c1b8: 8b 4a 08 mov 0x8(%edx),%ecx
10c1bb: 89 48 60 mov %ecx,0x60(%eax)
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10c1be: 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 ) ||
10c1c1: 83 f9 02 cmp $0x2,%ecx
10c1c4: 74 05 je 10c1cb <_CORE_mutex_Initialize+0x4f>
10c1c6: 83 f9 03 cmp $0x3,%ecx
10c1c9: 75 22 jne 10c1ed <_CORE_mutex_Initialize+0x71>
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
10c1cb: 8b 48 4c mov 0x4c(%eax),%ecx
10c1ce: 39 4a 14 cmp %ecx,0x14(%edx)
10c1d1: 72 41 jb 10c214 <_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++;
10c1d3: ff 42 1c incl 0x1c(%edx)
10c1d6: eb 15 jmp 10c1ed <_CORE_mutex_Initialize+0x71>
}
} else {
the_mutex->nest_count = 0;
10c1d8: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
the_mutex->holder = NULL;
10c1df: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
the_mutex->holder_id = 0;
10c1e6: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
}
_Thread_queue_Initialize(
10c1ed: 6a 05 push $0x5
10c1ef: 68 00 04 00 00 push $0x400
10c1f4: 31 d2 xor %edx,%edx
10c1f6: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10c1fa: 0f 95 c2 setne %dl
10c1fd: 52 push %edx
10c1fe: 50 push %eax
10c1ff: e8 b8 1e 00 00 call 10e0bc <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_FIFO : THREAD_QUEUE_DISCIPLINE_PRIORITY,
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c204: 83 c4 10 add $0x10,%esp
10c207: 31 c0 xor %eax,%eax
}
10c209: 8d 65 f4 lea -0xc(%ebp),%esp
10c20c: 5b pop %ebx
10c20d: 5e pop %esi
10c20e: 5f pop %edi
10c20f: c9 leave
10c210: c3 ret
10c211: 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;
10c214: b8 06 00 00 00 mov $0x6,%eax
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10c219: 8d 65 f4 lea -0xc(%ebp),%esp
10c21c: 5b pop %ebx
10c21d: 5e pop %esi
10c21e: 5f pop %edi
10c21f: c9 leave
10c220: c3 ret
0010c274 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
10c274: 55 push %ebp
10c275: 89 e5 mov %esp,%ebp
10c277: 53 push %ebx
10c278: 83 ec 14 sub $0x14,%esp
10c27b: 8b 5d 08 mov 0x8(%ebp),%ebx
10c27e: 8a 55 10 mov 0x10(%ebp),%dl
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10c281: a1 90 7d 12 00 mov 0x127d90,%eax
10c286: 85 c0 test %eax,%eax
10c288: 74 04 je 10c28e <_CORE_mutex_Seize+0x1a>
10c28a: 84 d2 test %dl,%dl
10c28c: 75 36 jne 10c2c4 <_CORE_mutex_Seize+0x50><== ALWAYS TAKEN
10c28e: 83 ec 08 sub $0x8,%esp
10c291: 8d 45 18 lea 0x18(%ebp),%eax
10c294: 50 push %eax
10c295: 53 push %ebx
10c296: 88 55 f4 mov %dl,-0xc(%ebp)
10c299: e8 1a 4f 00 00 call 1111b8 <_CORE_mutex_Seize_interrupt_trylock>
10c29e: 83 c4 10 add $0x10,%esp
10c2a1: 85 c0 test %eax,%eax
10c2a3: 8a 55 f4 mov -0xc(%ebp),%dl
10c2a6: 74 14 je 10c2bc <_CORE_mutex_Seize+0x48>
10c2a8: 84 d2 test %dl,%dl
10c2aa: 75 30 jne 10c2dc <_CORE_mutex_Seize+0x68>
10c2ac: ff 75 18 pushl 0x18(%ebp)
10c2af: 9d popf
10c2b0: a1 38 83 12 00 mov 0x128338,%eax
10c2b5: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax)
}
10c2bc: 8b 5d fc mov -0x4(%ebp),%ebx
10c2bf: c9 leave
10c2c0: c3 ret
10c2c1: 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 );
10c2c4: 83 3d 20 7f 12 00 01 cmpl $0x1,0x127f20
10c2cb: 76 c1 jbe 10c28e <_CORE_mutex_Seize+0x1a>
10c2cd: 53 push %ebx
10c2ce: 6a 12 push $0x12
10c2d0: 6a 00 push $0x0
10c2d2: 6a 00 push $0x0
10c2d4: e8 1b 06 00 00 call 10c8f4 <_Internal_error_Occurred>
10c2d9: 8d 76 00 lea 0x0(%esi),%esi
10c2dc: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx)
10c2e3: a1 38 83 12 00 mov 0x128338,%eax
10c2e8: 89 58 44 mov %ebx,0x44(%eax)
10c2eb: 8b 55 0c mov 0xc(%ebp),%edx
10c2ee: 89 50 20 mov %edx,0x20(%eax)
10c2f1: a1 90 7d 12 00 mov 0x127d90,%eax
10c2f6: 40 inc %eax
10c2f7: a3 90 7d 12 00 mov %eax,0x127d90
10c2fc: ff 75 18 pushl 0x18(%ebp)
10c2ff: 9d popf
10c300: 83 ec 08 sub $0x8,%esp
10c303: ff 75 14 pushl 0x14(%ebp)
10c306: 53 push %ebx
10c307: e8 18 ff ff ff call 10c224 <_CORE_mutex_Seize_interrupt_blocking>
10c30c: 83 c4 10 add $0x10,%esp
}
10c30f: 8b 5d fc mov -0x4(%ebp),%ebx
10c312: c9 leave
10c313: c3 ret
001111b8 <_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
)
{
1111b8: 55 push %ebp
1111b9: 89 e5 mov %esp,%ebp
1111bb: 56 push %esi
1111bc: 53 push %ebx
1111bd: 8b 45 08 mov 0x8(%ebp),%eax
1111c0: 8b 4d 0c mov 0xc(%ebp),%ecx
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
1111c3: 8b 15 38 83 12 00 mov 0x128338,%edx
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
1111c9: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
1111d0: 8b 58 50 mov 0x50(%eax),%ebx
1111d3: 85 db test %ebx,%ebx
1111d5: 74 31 je 111208 <_CORE_mutex_Seize_interrupt_trylock+0x50>
the_mutex->lock = CORE_MUTEX_LOCKED;
1111d7: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
the_mutex->holder = executing;
1111de: 89 50 5c mov %edx,0x5c(%eax)
the_mutex->holder_id = executing->Object.id;
1111e1: 8b 5a 08 mov 0x8(%edx),%ebx
1111e4: 89 58 60 mov %ebx,0x60(%eax)
the_mutex->nest_count = 1;
1111e7: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax)
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}
1111ee: 8b 58 48 mov 0x48(%eax),%ebx
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
1111f1: 83 fb 02 cmp $0x2,%ebx
1111f4: 74 26 je 11121c <_CORE_mutex_Seize_interrupt_trylock+0x64>
1111f6: 83 fb 03 cmp $0x3,%ebx
1111f9: 74 3d je 111238 <_CORE_mutex_Seize_interrupt_trylock+0x80>
executing->resource_count++;
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
_ISR_Enable( *level_p );
1111fb: ff 31 pushl (%ecx)
1111fd: 9d popf
return 0;
1111fe: 31 c0 xor %eax,%eax
111200: 8d 65 f8 lea -0x8(%ebp),%esp
111203: 5b pop %ebx
111204: 5e pop %esi
111205: c9 leave
111206: c3 ret
111207: 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 ) ) {
111208: 3b 50 5c cmp 0x5c(%eax),%edx
11120b: 74 17 je 111224 <_CORE_mutex_Seize_interrupt_trylock+0x6c>
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
11120d: b8 01 00 00 00 mov $0x1,%eax
111212: 8d 65 f8 lea -0x8(%ebp),%esp
111215: 5b pop %ebx
111216: 5e pop %esi
111217: c9 leave
111218: c3 ret
111219: 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++;
11121c: ff 42 1c incl 0x1c(%edx)
11121f: eb da jmp 1111fb <_CORE_mutex_Seize_interrupt_trylock+0x43>
111221: 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 ) {
111224: 8b 58 40 mov 0x40(%eax),%ebx
111227: 85 db test %ebx,%ebx
111229: 75 45 jne 111270 <_CORE_mutex_Seize_interrupt_trylock+0xb8>
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
11122b: ff 40 54 incl 0x54(%eax)
_ISR_Enable( *level_p );
11122e: ff 31 pushl (%ecx)
111230: 9d popf
return 0;
111231: 31 c0 xor %eax,%eax
111233: eb dd jmp 111212 <_CORE_mutex_Seize_interrupt_trylock+0x5a>
111235: 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++;
111238: 8b 5a 1c mov 0x1c(%edx),%ebx
11123b: 8d 73 01 lea 0x1(%ebx),%esi
11123e: 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 ) {
111241: 8b 72 14 mov 0x14(%edx),%esi
111244: 39 70 4c cmp %esi,0x4c(%eax)
111247: 74 6b je 1112b4 <_CORE_mutex_Seize_interrupt_trylock+0xfc>
_ISR_Enable( *level_p );
return 0;
}
if ( current > ceiling ) {
111249: 72 39 jb 111284 <_CORE_mutex_Seize_interrupt_trylock+0xcc>
);
_Thread_Enable_dispatch();
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
11124b: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx)
the_mutex->lock = CORE_MUTEX_UNLOCKED;
111252: c7 40 50 01 00 00 00 movl $0x1,0x50(%eax)
the_mutex->nest_count = 0; /* undo locking above */
111259: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
executing->resource_count--; /* undo locking above */
111260: 89 5a 1c mov %ebx,0x1c(%edx)
_ISR_Enable( *level_p );
111263: ff 31 pushl (%ecx)
111265: 9d popf
return 0;
111266: 31 c0 xor %eax,%eax
111268: 8d 65 f8 lea -0x8(%ebp),%esp
11126b: 5b pop %ebx
11126c: 5e pop %esi
11126d: c9 leave
11126e: c3 ret
11126f: 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 ) ) {
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
111270: 4b dec %ebx
111271: 75 9a jne 11120d <_CORE_mutex_Seize_interrupt_trylock+0x55>
the_mutex->nest_count++;
_ISR_Enable( *level_p );
return 0;
#if defined(RTEMS_POSIX_API)
case CORE_MUTEX_NESTING_IS_ERROR:
executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
111273: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx)
_ISR_Enable( *level_p );
11127a: ff 31 pushl (%ecx)
11127c: 9d popf
return 0;
11127d: 31 c0 xor %eax,%eax
11127f: eb 91 jmp 111212 <_CORE_mutex_Seize_interrupt_trylock+0x5a>
111281: 8d 76 00 lea 0x0(%esi),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
111284: 8b 15 90 7d 12 00 mov 0x127d90,%edx
11128a: 42 inc %edx
11128b: 89 15 90 7d 12 00 mov %edx,0x127d90
return 0;
}
if ( current > ceiling ) {
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
111291: ff 31 pushl (%ecx)
111293: 9d popf
_Thread_Change_priority(
111294: 52 push %edx
111295: 6a 00 push $0x0
111297: ff 70 4c pushl 0x4c(%eax)
11129a: ff 70 5c pushl 0x5c(%eax)
11129d: e8 d6 c2 ff ff call 10d578 <_Thread_Change_priority>
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
1112a2: e8 09 c7 ff ff call 10d9b0 <_Thread_Enable_dispatch>
1112a7: 83 c4 10 add $0x10,%esp
return 0;
1112aa: 31 c0 xor %eax,%eax
1112ac: e9 61 ff ff ff jmp 111212 <_CORE_mutex_Seize_interrupt_trylock+0x5a>
1112b1: 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 );
1112b4: ff 31 pushl (%ecx)
1112b6: 9d popf
return 0;
1112b7: 31 c0 xor %eax,%eax
1112b9: e9 54 ff ff ff jmp 111212 <_CORE_mutex_Seize_interrupt_trylock+0x5a>
0010c314 <_CORE_mutex_Surrender>:
#else
Objects_Id id __attribute__((unused)),
CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused))
#endif
)
{
10c314: 55 push %ebp
10c315: 89 e5 mov %esp,%ebp
10c317: 53 push %ebx
10c318: 83 ec 04 sub $0x4,%esp
10c31b: 8b 5d 08 mov 0x8(%ebp),%ebx
Thread_Control *the_thread;
Thread_Control *holder;
holder = the_mutex->holder;
10c31e: 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 ) {
10c321: 80 7b 44 00 cmpb $0x0,0x44(%ebx)
10c325: 74 15 je 10c33c <_CORE_mutex_Surrender+0x28>
if ( !_Thread_Is_executing( holder ) )
10c327: 3b 05 38 83 12 00 cmp 0x128338,%eax
10c32d: 74 0d je 10c33c <_CORE_mutex_Surrender+0x28>
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
10c32f: b8 03 00 00 00 mov $0x3,%eax
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10c334: 8b 5d fc mov -0x4(%ebp),%ebx
10c337: c9 leave
10c338: c3 ret
10c339: 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 )
10c33c: 8b 53 54 mov 0x54(%ebx),%edx
10c33f: 85 d2 test %edx,%edx
10c341: 74 51 je 10c394 <_CORE_mutex_Surrender+0x80>
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
10c343: 4a dec %edx
10c344: 89 53 54 mov %edx,0x54(%ebx)
if ( the_mutex->nest_count != 0 ) {
10c347: 85 d2 test %edx,%edx
10c349: 75 49 jne 10c394 <_CORE_mutex_Surrender+0x80>
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10c34b: 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 ) ||
10c34e: 83 fa 02 cmp $0x2,%edx
10c351: 74 69 je 10c3bc <_CORE_mutex_Surrender+0xa8>
10c353: 83 fa 03 cmp $0x3,%edx
10c356: 74 64 je 10c3bc <_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;
10c358: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
the_mutex->holder_id = 0;
10c35f: 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 ) ) ) {
10c366: 83 ec 0c sub $0xc,%esp
10c369: 53 push %ebx
10c36a: e8 bd 19 00 00 call 10dd2c <_Thread_queue_Dequeue>
10c36f: 83 c4 10 add $0x10,%esp
10c372: 85 c0 test %eax,%eax
10c374: 74 7a je 10c3f0 <_CORE_mutex_Surrender+0xdc>
} else
#endif
{
the_mutex->holder = the_thread;
10c376: 89 43 5c mov %eax,0x5c(%ebx)
the_mutex->holder_id = the_thread->Object.id;
10c379: 8b 50 08 mov 0x8(%eax),%edx
10c37c: 89 53 60 mov %edx,0x60(%ebx)
the_mutex->nest_count = 1;
10c37f: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx)
switch ( the_mutex->Attributes.discipline ) {
10c386: 8b 53 48 mov 0x48(%ebx),%edx
10c389: 83 fa 02 cmp $0x2,%edx
10c38c: 74 56 je 10c3e4 <_CORE_mutex_Surrender+0xd0>
10c38e: 83 fa 03 cmp $0x3,%edx
10c391: 74 09 je 10c39c <_CORE_mutex_Surrender+0x88>
10c393: 90 nop
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c394: 31 c0 xor %eax,%eax
}
10c396: 8b 5d fc mov -0x4(%ebp),%ebx
10c399: c9 leave
10c39a: c3 ret
10c39b: 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++;
10c39c: ff 40 1c incl 0x1c(%eax)
if (the_mutex->Attributes.priority_ceiling <
10c39f: 8b 53 4c mov 0x4c(%ebx),%edx
10c3a2: 3b 50 14 cmp 0x14(%eax),%edx
10c3a5: 73 ed jae 10c394 <_CORE_mutex_Surrender+0x80>
the_thread->current_priority){
_Thread_Change_priority(
10c3a7: 51 push %ecx
10c3a8: 6a 00 push $0x0
10c3aa: 52 push %edx
10c3ab: 50 push %eax
10c3ac: e8 c7 11 00 00 call 10d578 <_Thread_Change_priority>
10c3b1: 83 c4 10 add $0x10,%esp
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c3b4: 31 c0 xor %eax,%eax
10c3b6: e9 79 ff ff ff jmp 10c334 <_CORE_mutex_Surrender+0x20>
10c3bb: 90 nop
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
10c3bc: 8b 50 1c mov 0x1c(%eax),%edx
10c3bf: 4a dec %edx
10c3c0: 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 &&
10c3c3: 85 d2 test %edx,%edx
10c3c5: 75 91 jne 10c358 <_CORE_mutex_Surrender+0x44>
holder->real_priority != holder->current_priority ) {
10c3c7: 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 &&
10c3ca: 3b 50 14 cmp 0x14(%eax),%edx
10c3cd: 74 89 je 10c358 <_CORE_mutex_Surrender+0x44>
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, true );
10c3cf: 51 push %ecx
10c3d0: 6a 01 push $0x1
10c3d2: 52 push %edx
10c3d3: 50 push %eax
10c3d4: e8 9f 11 00 00 call 10d578 <_Thread_Change_priority>
10c3d9: 83 c4 10 add $0x10,%esp
10c3dc: e9 77 ff ff ff jmp 10c358 <_CORE_mutex_Surrender+0x44>
10c3e1: 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++;
10c3e4: ff 40 1c incl 0x1c(%eax)
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c3e7: 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;
10c3e9: e9 46 ff ff ff jmp 10c334 <_CORE_mutex_Surrender+0x20>
10c3ee: 66 90 xchg %ax,%ax
}
break;
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
10c3f0: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx)
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c3f7: 31 c0 xor %eax,%eax
10c3f9: e9 36 ff ff ff jmp 10c334 <_CORE_mutex_Surrender+0x20>
001152b8 <_CORE_semaphore_Seize>:
CORE_semaphore_Control *the_semaphore,
Objects_Id id,
bool wait,
Watchdog_Interval timeout
)
{
1152b8: 55 push %ebp
1152b9: 89 e5 mov %esp,%ebp
1152bb: 57 push %edi
1152bc: 56 push %esi
1152bd: 53 push %ebx
1152be: 83 ec 1c sub $0x1c,%esp
1152c1: 8b 45 08 mov 0x8(%ebp),%eax
1152c4: 8b 7d 0c mov 0xc(%ebp),%edi
1152c7: 8b 75 14 mov 0x14(%ebp),%esi
1152ca: 8a 5d 10 mov 0x10(%ebp),%bl
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
1152cd: 8b 15 b8 e0 12 00 mov 0x12e0b8,%edx
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
1152d3: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
_ISR_Disable( level );
1152da: 9c pushf
1152db: fa cli
1152dc: 8f 45 e4 popl -0x1c(%ebp)
if ( the_semaphore->count != 0 ) {
1152df: 8b 48 48 mov 0x48(%eax),%ecx
1152e2: 85 c9 test %ecx,%ecx
1152e4: 75 46 jne 11532c <_CORE_semaphore_Seize+0x74>
/*
* If the semaphore was not available and the caller was not willing
* to block, then return immediately with a status indicating that
* the semaphore was not available and the caller never blocked.
*/
if ( !wait ) {
1152e6: 84 db test %bl,%bl
1152e8: 75 16 jne 115300 <_CORE_semaphore_Seize+0x48>
_ISR_Enable( level );
1152ea: ff 75 e4 pushl -0x1c(%ebp)
1152ed: 9d popf
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
1152ee: c7 42 34 01 00 00 00 movl $0x1,0x34(%edx)
_Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue );
executing->Wait.queue = &the_semaphore->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
}
1152f5: 83 c4 1c add $0x1c,%esp
1152f8: 5b pop %ebx
1152f9: 5e pop %esi
1152fa: 5f pop %edi
1152fb: c9 leave
1152fc: c3 ret
1152fd: 8d 76 00 lea 0x0(%esi),%esi
115300: c7 40 30 01 00 00 00 movl $0x1,0x30(%eax)
/*
* If the semaphore is not available and the caller is willing to
* block, then we now block the caller with optional timeout.
*/
_Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue );
executing->Wait.queue = &the_semaphore->Wait_queue;
115307: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
11530a: 89 7a 20 mov %edi,0x20(%edx)
_ISR_Enable( level );
11530d: ff 75 e4 pushl -0x1c(%ebp)
115310: 9d popf
_Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
115311: c7 45 10 a4 1b 11 00 movl $0x111ba4,0x10(%ebp)
115318: 89 75 0c mov %esi,0xc(%ebp)
11531b: 89 45 08 mov %eax,0x8(%ebp)
}
11531e: 83 c4 1c add $0x1c,%esp
115321: 5b pop %ebx
115322: 5e pop %esi
115323: 5f pop %edi
115324: c9 leave
*/
_Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue );
executing->Wait.queue = &the_semaphore->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
115325: e9 4e c5 ff ff jmp 111878 <_Thread_queue_Enqueue_with_handler>
11532a: 66 90 xchg %ax,%ax
executing = _Thread_Executing;
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
_ISR_Disable( level );
if ( the_semaphore->count != 0 ) {
the_semaphore->count -= 1;
11532c: 49 dec %ecx
11532d: 89 48 48 mov %ecx,0x48(%eax)
_ISR_Enable( level );
115330: ff 75 e4 pushl -0x1c(%ebp)
115333: 9d popf
_Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue );
executing->Wait.queue = &the_semaphore->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
}
115334: 83 c4 1c add $0x1c,%esp
115337: 5b pop %ebx
115338: 5e pop %esi
115339: 5f pop %edi
11533a: c9 leave
11533b: c3 ret
0010c44c <_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
)
{
10c44c: 55 push %ebp
10c44d: 89 e5 mov %esp,%ebp
10c44f: 53 push %ebx
10c450: 83 ec 10 sub $0x10,%esp
10c453: 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)) ) {
10c456: 53 push %ebx
10c457: e8 d0 18 00 00 call 10dd2c <_Thread_queue_Dequeue>
10c45c: 83 c4 10 add $0x10,%esp
10c45f: 85 c0 test %eax,%eax
10c461: 74 09 je 10c46c <_CORE_semaphore_Surrender+0x20>
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10c463: 31 c0 xor %eax,%eax
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
10c465: 8b 5d fc mov -0x4(%ebp),%ebx
10c468: c9 leave
10c469: c3 ret
10c46a: 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 );
10c46c: 9c pushf
10c46d: fa cli
10c46e: 5a pop %edx
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
10c46f: 8b 43 48 mov 0x48(%ebx),%eax
10c472: 3b 43 40 cmp 0x40(%ebx),%eax
10c475: 72 0d jb 10c484 <_CORE_semaphore_Surrender+0x38><== ALWAYS TAKEN
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
10c477: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED
_ISR_Enable( level );
10c47c: 52 push %edx
10c47d: 9d popf
}
return status;
}
10c47e: 8b 5d fc mov -0x4(%ebp),%ebx
10c481: c9 leave
10c482: c3 ret
10c483: 90 nop
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
10c484: 40 inc %eax
10c485: 89 43 48 mov %eax,0x48(%ebx)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10c488: 31 c0 xor %eax,%eax
10c48a: eb f0 jmp 10c47c <_CORE_semaphore_Surrender+0x30>
0010c6ac <_Chain_Get_with_empty_check>:
bool _Chain_Get_with_empty_check(
Chain_Control *chain,
Chain_Node **node
)
{
10c6ac: 55 push %ebp
10c6ad: 89 e5 mov %esp,%ebp
10c6af: 57 push %edi
10c6b0: 56 push %esi
10c6b1: 53 push %ebx
10c6b2: 8b 45 08 mov 0x8(%ebp),%eax
10c6b5: 8b 7d 0c mov 0xc(%ebp),%edi
ISR_Level level;
bool is_empty_now;
_ISR_Disable( level );
10c6b8: 9c pushf
10c6b9: fa cli
10c6ba: 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 );
10c6bb: 8d 58 04 lea 0x4(%eax),%ebx
Chain_Node *old_first = head->next;
10c6be: 8b 10 mov (%eax),%edx
if ( old_first != tail ) {
10c6c0: 39 d3 cmp %edx,%ebx
10c6c2: 74 18 je 10c6dc <_Chain_Get_with_empty_check+0x30>
Chain_Node *new_first = old_first->next;
10c6c4: 8b 0a mov (%edx),%ecx
head->next = new_first;
10c6c6: 89 08 mov %ecx,(%eax)
new_first->previous = head;
10c6c8: 89 41 04 mov %eax,0x4(%ecx)
*the_node = old_first;
10c6cb: 89 17 mov %edx,(%edi)
is_empty_now = new_first == tail;
10c6cd: 39 cb cmp %ecx,%ebx
10c6cf: 0f 94 c0 sete %al
is_empty_now = _Chain_Get_with_empty_check_unprotected( chain, node );
_ISR_Enable( level );
10c6d2: 56 push %esi
10c6d3: 9d popf
return is_empty_now;
}
10c6d4: 5b pop %ebx
10c6d5: 5e pop %esi
10c6d6: 5f pop %edi
10c6d7: c9 leave
10c6d8: c3 ret
10c6d9: 8d 76 00 lea 0x0(%esi),%esi
} else
*the_node = NULL;
10c6dc: 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;
10c6e2: b0 01 mov $0x1,%al
10c6e4: eb ec jmp 10c6d2 <_Chain_Get_with_empty_check+0x26>
00111084 <_Chain_Initialize>:
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
111084: 55 push %ebp
111085: 89 e5 mov %esp,%ebp
111087: 57 push %edi
111088: 56 push %esi
111089: 53 push %ebx
11108a: 83 ec 08 sub $0x8,%esp
11108d: 8b 7d 08 mov 0x8(%ebp),%edi
111090: 8b 4d 10 mov 0x10(%ebp),%ecx
111093: 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 );
111096: 8d 47 04 lea 0x4(%edi),%eax
111099: 89 45 f0 mov %eax,-0x10(%ebp)
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
11109c: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
while ( count-- ) {
1110a3: 85 c9 test %ecx,%ecx
1110a5: 74 35 je 1110dc <_Chain_Initialize+0x58><== NEVER TAKEN
1110a7: 49 dec %ecx
1110a8: 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;
1110ab: 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;
1110ae: 89 fa mov %edi,%edx
1110b0: eb 07 jmp 1110b9 <_Chain_Initialize+0x35>
1110b2: 66 90 xchg %ax,%ax
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
1110b4: 89 c2 mov %eax,%edx
current->next = next;
next->previous = current;
current = next;
next = (Chain_Node *)
1110b6: 89 d8 mov %ebx,%eax
1110b8: 49 dec %ecx
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
current->next = next;
1110b9: 89 02 mov %eax,(%edx)
next->previous = current;
1110bb: 89 50 04 mov %edx,0x4(%eax)
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _Chain_Initialize(
1110be: 8d 1c 30 lea (%eax,%esi,1),%ebx
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
1110c1: 85 c9 test %ecx,%ecx
1110c3: 75 ef jne 1110b4 <_Chain_Initialize+0x30>
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _Chain_Initialize(
1110c5: 0f af 75 ec imul -0x14(%ebp),%esi
1110c9: 03 75 0c add 0xc(%ebp),%esi
current = next;
next = (Chain_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
current->next = tail;
1110cc: 8b 45 f0 mov -0x10(%ebp),%eax
1110cf: 89 06 mov %eax,(%esi)
tail->previous = current;
1110d1: 89 77 08 mov %esi,0x8(%edi)
}
1110d4: 83 c4 08 add $0x8,%esp
1110d7: 5b pop %ebx
1110d8: 5e pop %esi
1110d9: 5f pop %edi
1110da: c9 leave
1110db: 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;
1110dc: 89 fe mov %edi,%esi <== NOT EXECUTED
1110de: eb ec jmp 1110cc <_Chain_Initialize+0x48><== NOT EXECUTED
0010b070 <_Event_Seize>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
10b070: 55 push %ebp
10b071: 89 e5 mov %esp,%ebp
10b073: 57 push %edi
10b074: 56 push %esi
10b075: 53 push %ebx
10b076: 83 ec 2c sub $0x2c,%esp
10b079: 8b 45 08 mov 0x8(%ebp),%eax
10b07c: 8b 4d 0c mov 0xc(%ebp),%ecx
10b07f: 8b 55 10 mov 0x10(%ebp),%edx
10b082: 89 55 dc mov %edx,-0x24(%ebp)
10b085: 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;
10b088: 8b 1d 38 83 12 00 mov 0x128338,%ebx
executing->Wait.return_code = RTEMS_SUCCESSFUL;
10b08e: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx)
api = executing->API_Extensions[ THREAD_API_RTEMS ];
10b095: 8b b3 e8 00 00 00 mov 0xe8(%ebx),%esi
_ISR_Disable( level );
10b09b: 9c pushf
10b09c: fa cli
10b09d: 8f 45 e0 popl -0x20(%ebp)
pending_events = api->pending_events;
10b0a0: 8b 16 mov (%esi),%edx
10b0a2: 89 55 d4 mov %edx,-0x2c(%ebp)
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
10b0a5: 21 c2 and %eax,%edx
10b0a7: 89 55 e4 mov %edx,-0x1c(%ebp)
10b0aa: 74 0d je 10b0b9 <_Event_Seize+0x49>
10b0ac: 39 d0 cmp %edx,%eax
10b0ae: 0f 84 84 00 00 00 je 10b138 <_Event_Seize+0xc8>
(seized_events == event_in || _Options_Is_any( option_set )) ) {
10b0b4: f6 c1 02 test $0x2,%cl
10b0b7: 75 7f jne 10b138 <_Event_Seize+0xc8>
_ISR_Enable( level );
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
10b0b9: f6 c1 01 test $0x1,%cl
10b0bc: 75 62 jne 10b120 <_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;
10b0be: 89 4b 30 mov %ecx,0x30(%ebx)
executing->Wait.count = (uint32_t) event_in;
10b0c1: 89 43 24 mov %eax,0x24(%ebx)
executing->Wait.return_argument = event_out;
10b0c4: 89 7b 28 mov %edi,0x28(%ebx)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10b0c7: c7 05 68 87 12 00 01 movl $0x1,0x128768
10b0ce: 00 00 00
_ISR_Enable( level );
10b0d1: ff 75 e0 pushl -0x20(%ebp)
10b0d4: 9d popf
if ( ticks ) {
10b0d5: 8b 45 dc mov -0x24(%ebp),%eax
10b0d8: 85 c0 test %eax,%eax
10b0da: 0f 85 80 00 00 00 jne 10b160 <_Event_Seize+0xf0>
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
}
_Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
10b0e0: 83 ec 08 sub $0x8,%esp
10b0e3: 68 00 01 00 00 push $0x100
10b0e8: 53 push %ebx
10b0e9: e8 e2 30 00 00 call 10e1d0 <_Thread_Set_state>
_ISR_Disable( level );
10b0ee: 9c pushf
10b0ef: fa cli
10b0f0: 5a pop %edx
sync_state = _Event_Sync_state;
10b0f1: a1 68 87 12 00 mov 0x128768,%eax
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10b0f6: c7 05 68 87 12 00 00 movl $0x0,0x128768
10b0fd: 00 00 00
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
10b100: 83 c4 10 add $0x10,%esp
10b103: 83 f8 01 cmp $0x1,%eax
10b106: 74 4c je 10b154 <_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 );
10b108: 89 55 10 mov %edx,0x10(%ebp)
10b10b: 89 5d 0c mov %ebx,0xc(%ebp)
10b10e: 89 45 08 mov %eax,0x8(%ebp)
}
10b111: 8d 65 f4 lea -0xc(%ebp),%esp
10b114: 5b pop %ebx
10b115: 5e pop %esi
10b116: 5f pop %edi
10b117: 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 );
10b118: e9 0f 24 00 00 jmp 10d52c <_Thread_blocking_operation_Cancel>
10b11d: 8d 76 00 lea 0x0(%esi),%esi
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
_ISR_Enable( level );
10b120: ff 75 e0 pushl -0x20(%ebp)
10b123: 9d popf
executing->Wait.return_code = RTEMS_UNSATISFIED;
10b124: c7 43 34 0d 00 00 00 movl $0xd,0x34(%ebx)
*event_out = seized_events;
10b12b: 8b 55 e4 mov -0x1c(%ebp),%edx
10b12e: 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 );
}
10b130: 8d 65 f4 lea -0xc(%ebp),%esp
10b133: 5b pop %ebx
10b134: 5e pop %esi
10b135: 5f pop %edi
10b136: c9 leave
10b137: 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) );
10b138: 8b 45 e4 mov -0x1c(%ebp),%eax
10b13b: f7 d0 not %eax
10b13d: 23 45 d4 and -0x2c(%ebp),%eax
10b140: 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 );
10b142: ff 75 e0 pushl -0x20(%ebp)
10b145: 9d popf
*event_out = seized_events;
10b146: 8b 45 e4 mov -0x1c(%ebp),%eax
10b149: 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 );
}
10b14b: 8d 65 f4 lea -0xc(%ebp),%esp
10b14e: 5b pop %ebx
10b14f: 5e pop %esi
10b150: 5f pop %edi
10b151: c9 leave
10b152: c3 ret
10b153: 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 );
10b154: 52 push %edx
10b155: 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 );
}
10b156: 8d 65 f4 lea -0xc(%ebp),%esp
10b159: 5b pop %ebx
10b15a: 5e pop %esi
10b15b: 5f pop %edi
10b15c: c9 leave
10b15d: c3 ret
10b15e: 66 90 xchg %ax,%ax
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
_ISR_Enable( level );
if ( ticks ) {
_Watchdog_Initialize(
10b160: 8b 43 08 mov 0x8(%ebx),%eax
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10b163: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10b16a: c7 43 64 14 b3 10 00 movl $0x10b314,0x64(%ebx)
the_watchdog->id = id;
10b171: 89 43 68 mov %eax,0x68(%ebx)
the_watchdog->user_data = user_data;
10b174: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b17b: 8b 45 dc mov -0x24(%ebp),%eax
10b17e: 89 43 54 mov %eax,0x54(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b181: 83 ec 08 sub $0x8,%esp
&executing->Timer,
_Event_Timeout,
executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
10b184: 8d 43 48 lea 0x48(%ebx),%eax
10b187: 50 push %eax
10b188: 68 60 7e 12 00 push $0x127e60
10b18d: e8 8e 35 00 00 call 10e720 <_Watchdog_Insert>
10b192: 83 c4 10 add $0x10,%esp
10b195: e9 46 ff ff ff jmp 10b0e0 <_Event_Seize+0x70>
0010b1f0 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
10b1f0: 55 push %ebp
10b1f1: 89 e5 mov %esp,%ebp
10b1f3: 57 push %edi
10b1f4: 56 push %esi
10b1f5: 53 push %ebx
10b1f6: 83 ec 2c sub $0x2c,%esp
10b1f9: 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 ];
10b1fc: 8b 8b e8 00 00 00 mov 0xe8(%ebx),%ecx
option_set = (rtems_option) the_thread->Wait.option;
10b202: 8b 7b 30 mov 0x30(%ebx),%edi
_ISR_Disable( level );
10b205: 9c pushf
10b206: fa cli
10b207: 8f 45 d4 popl -0x2c(%ebp)
pending_events = api->pending_events;
10b20a: 8b 11 mov (%ecx),%edx
event_condition = (rtems_event_set) the_thread->Wait.count;
10b20c: 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 ) ) {
10b20f: 89 c6 mov %eax,%esi
10b211: 21 d6 and %edx,%esi
10b213: 89 75 e4 mov %esi,-0x1c(%ebp)
10b216: 74 74 je 10b28c <_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() &&
10b218: 8b 35 34 83 12 00 mov 0x128334,%esi
10b21e: 85 f6 test %esi,%esi
10b220: 74 0c je 10b22e <_Event_Surrender+0x3e>
10b222: 3b 1d 38 83 12 00 cmp 0x128338,%ebx
10b228: 0f 84 96 00 00 00 je 10b2c4 <_Event_Surrender+0xd4>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
10b22e: f6 43 11 01 testb $0x1,0x11(%ebx)
10b232: 74 4c je 10b280 <_Event_Surrender+0x90>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
10b234: 3b 45 e4 cmp -0x1c(%ebp),%eax
10b237: 74 05 je 10b23e <_Event_Surrender+0x4e>
10b239: 83 e7 02 and $0x2,%edi
10b23c: 74 42 je 10b280 <_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) );
10b23e: 8b 45 e4 mov -0x1c(%ebp),%eax
10b241: f7 d0 not %eax
10b243: 21 d0 and %edx,%eax
10b245: 89 01 mov %eax,(%ecx)
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
10b247: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
10b24e: 8b 43 28 mov 0x28(%ebx),%eax
10b251: 8b 75 e4 mov -0x1c(%ebp),%esi
10b254: 89 30 mov %esi,(%eax)
_ISR_Flash( level );
10b256: ff 75 d4 pushl -0x2c(%ebp)
10b259: 9d popf
10b25a: fa cli
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10b25b: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10b25f: 74 37 je 10b298 <_Event_Surrender+0xa8>
_ISR_Enable( level );
10b261: ff 75 d4 pushl -0x2c(%ebp)
10b264: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10b265: 83 ec 08 sub $0x8,%esp
10b268: 68 f8 ff 03 10 push $0x1003fff8
10b26d: 53 push %ebx
10b26e: e8 d9 23 00 00 call 10d64c <_Thread_Clear_state>
10b273: 83 c4 10 add $0x10,%esp
}
return;
}
}
_ISR_Enable( level );
}
10b276: 8d 65 f4 lea -0xc(%ebp),%esp
10b279: 5b pop %ebx
10b27a: 5e pop %esi
10b27b: 5f pop %edi
10b27c: c9 leave
10b27d: c3 ret
10b27e: 66 90 xchg %ax,%ax
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
10b280: ff 75 d4 pushl -0x2c(%ebp)
10b283: 9d popf
}
10b284: 8d 65 f4 lea -0xc(%ebp),%esp
10b287: 5b pop %ebx
10b288: 5e pop %esi
10b289: 5f pop %edi
10b28a: c9 leave
10b28b: c3 ret
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
_ISR_Enable( level );
10b28c: ff 75 d4 pushl -0x2c(%ebp)
10b28f: 9d popf
}
return;
}
}
_ISR_Enable( level );
}
10b290: 8d 65 f4 lea -0xc(%ebp),%esp
10b293: 5b pop %ebx
10b294: 5e pop %esi
10b295: 5f pop %edi
10b296: c9 leave
10b297: c3 ret
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
10b298: 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 );
10b29f: ff 75 d4 pushl -0x2c(%ebp)
10b2a2: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
10b2a3: 83 ec 0c sub $0xc,%esp
10b2a6: 8d 43 48 lea 0x48(%ebx),%eax
10b2a9: 50 push %eax
10b2aa: e8 b1 35 00 00 call 10e860 <_Watchdog_Remove>
10b2af: 58 pop %eax
10b2b0: 5a pop %edx
10b2b1: 68 f8 ff 03 10 push $0x1003fff8
10b2b6: 53 push %ebx
10b2b7: e8 90 23 00 00 call 10d64c <_Thread_Clear_state>
10b2bc: 83 c4 10 add $0x10,%esp
10b2bf: eb c3 jmp 10b284 <_Event_Surrender+0x94>
10b2c1: 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) ||
10b2c4: 8b 35 68 87 12 00 mov 0x128768,%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 ) &&
10b2ca: 83 fe 02 cmp $0x2,%esi
10b2cd: 74 0d je 10b2dc <_Event_Surrender+0xec> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
10b2cf: 8b 35 68 87 12 00 mov 0x128768,%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) ||
10b2d5: 4e dec %esi
10b2d6: 0f 85 52 ff ff ff jne 10b22e <_Event_Surrender+0x3e>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
10b2dc: 3b 45 e4 cmp -0x1c(%ebp),%eax
10b2df: 74 05 je 10b2e6 <_Event_Surrender+0xf6>
10b2e1: 83 e7 02 and $0x2,%edi
10b2e4: 74 22 je 10b308 <_Event_Surrender+0x118><== NEVER TAKEN
10b2e6: 8b 45 e4 mov -0x1c(%ebp),%eax
10b2e9: f7 d0 not %eax
10b2eb: 21 d0 and %edx,%eax
10b2ed: 89 01 mov %eax,(%ecx)
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
10b2ef: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
10b2f6: 8b 43 28 mov 0x28(%ebx),%eax
10b2f9: 8b 55 e4 mov -0x1c(%ebp),%edx
10b2fc: 89 10 mov %edx,(%eax)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
10b2fe: c7 05 68 87 12 00 03 movl $0x3,0x128768
10b305: 00 00 00
}
_ISR_Enable( level );
10b308: ff 75 d4 pushl -0x2c(%ebp)
10b30b: 9d popf
return;
10b30c: e9 73 ff ff ff jmp 10b284 <_Event_Surrender+0x94>
0010b314 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
10b314: 55 push %ebp
10b315: 89 e5 mov %esp,%ebp
10b317: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
10b31a: 8d 45 f4 lea -0xc(%ebp),%eax
10b31d: 50 push %eax
10b31e: ff 75 08 pushl 0x8(%ebp)
10b321: e8 ae 26 00 00 call 10d9d4 <_Thread_Get>
switch ( location ) {
10b326: 83 c4 10 add $0x10,%esp
10b329: 8b 55 f4 mov -0xc(%ebp),%edx
10b32c: 85 d2 test %edx,%edx
10b32e: 75 37 jne 10b367 <_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 );
10b330: 9c pushf
10b331: fa cli
10b332: 5a pop %edx
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
10b333: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
if ( _Thread_Is_executing( the_thread ) ) {
10b33a: 3b 05 38 83 12 00 cmp 0x128338,%eax
10b340: 74 2a je 10b36c <_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;
10b342: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax)
_ISR_Enable( level );
10b349: 52 push %edx
10b34a: 9d popf
10b34b: 83 ec 08 sub $0x8,%esp
10b34e: 68 f8 ff 03 10 push $0x1003fff8
10b353: 50 push %eax
10b354: e8 f3 22 00 00 call 10d64c <_Thread_Clear_state>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10b359: a1 90 7d 12 00 mov 0x127d90,%eax
10b35e: 48 dec %eax
10b35f: a3 90 7d 12 00 mov %eax,0x127d90
_Thread_Unblock( the_thread );
_Thread_Unnest_dispatch();
break;
10b364: 83 c4 10 add $0x10,%esp
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10b367: c9 leave
10b368: c3 ret
10b369: 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 )
10b36c: 8b 0d 68 87 12 00 mov 0x128768,%ecx
10b372: 49 dec %ecx
10b373: 75 cd jne 10b342 <_Event_Timeout+0x2e>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
10b375: c7 05 68 87 12 00 02 movl $0x2,0x128768
10b37c: 00 00 00
10b37f: eb c1 jmp 10b342 <_Event_Timeout+0x2e>
00111314 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
111314: 55 push %ebp
111315: 89 e5 mov %esp,%ebp
111317: 57 push %edi
111318: 56 push %esi
111319: 53 push %ebx
11131a: 83 ec 2c sub $0x2c,%esp
11131d: 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
111320: 8d 47 04 lea 0x4(%edi),%eax
111323: 89 45 dc mov %eax,-0x24(%ebp)
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
111326: 8b 55 08 mov 0x8(%ebp),%edx
111329: 8b 52 10 mov 0x10(%edx),%edx
11132c: 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 ) {
11132f: 39 c7 cmp %eax,%edi
111331: 0f 87 69 01 00 00 ja 1114a0 <_Heap_Allocate_aligned_with_boundary+0x18c>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
111337: 8b 5d 14 mov 0x14(%ebp),%ebx
11133a: 85 db test %ebx,%ebx
11133c: 0f 85 56 01 00 00 jne 111498 <_Heap_Allocate_aligned_with_boundary+0x184>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
111342: 8b 45 08 mov 0x8(%ebp),%eax
111345: 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 ) {
111348: 39 c8 cmp %ecx,%eax
11134a: 0f 84 50 01 00 00 je 1114a0 <_Heap_Allocate_aligned_with_boundary+0x18c>
111350: 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
111357: 8b 55 cc mov -0x34(%ebp),%edx
11135a: 83 c2 07 add $0x7,%edx
11135d: 89 55 c8 mov %edx,-0x38(%ebp)
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
111360: c7 45 d0 04 00 00 00 movl $0x4,-0x30(%ebp)
111367: 29 7d d0 sub %edi,-0x30(%ebp)
11136a: eb 1e jmp 11138a <_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;
11136c: 8d 59 08 lea 0x8(%ecx),%ebx
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
11136f: 85 db test %ebx,%ebx
111371: 0f 85 f1 00 00 00 jne 111468 <_Heap_Allocate_aligned_with_boundary+0x154><== ALWAYS TAKEN
break;
}
block = block->next;
111377: 8b 49 08 mov 0x8(%ecx),%ecx
11137a: 8b 45 e4 mov -0x1c(%ebp),%eax
11137d: 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 ) {
11137e: 39 4d 08 cmp %ecx,0x8(%ebp)
111381: 0f 84 25 01 00 00 je 1114ac <_Heap_Allocate_aligned_with_boundary+0x198>
111387: 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 ) {
11138a: 8b 59 04 mov 0x4(%ecx),%ebx
11138d: 39 5d dc cmp %ebx,-0x24(%ebp)
111390: 73 e5 jae 111377 <_Heap_Allocate_aligned_with_boundary+0x63>
if ( alignment == 0 ) {
111392: 8b 55 10 mov 0x10(%ebp),%edx
111395: 85 d2 test %edx,%edx
111397: 74 d3 je 11136c <_Heap_Allocate_aligned_with_boundary+0x58>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
111399: 8b 45 08 mov 0x8(%ebp),%eax
11139c: 8b 40 14 mov 0x14(%eax),%eax
11139f: 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;
1113a2: 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;
1113a5: 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;
1113a8: 8d 51 08 lea 0x8(%ecx),%edx
1113ab: 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;
1113ae: 8b 75 c8 mov -0x38(%ebp),%esi
1113b1: 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
1113b3: 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;
1113b5: 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);
1113b8: 89 d8 mov %ebx,%eax
1113ba: 31 d2 xor %edx,%edx
1113bc: f7 75 10 divl 0x10(%ebp)
1113bf: 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 ) {
1113c1: 39 de cmp %ebx,%esi
1113c3: 73 0b jae 1113d0 <_Heap_Allocate_aligned_with_boundary+0xbc>
1113c5: 89 f0 mov %esi,%eax
1113c7: 31 d2 xor %edx,%edx
1113c9: f7 75 10 divl 0x10(%ebp)
1113cc: 89 f3 mov %esi,%ebx
1113ce: 29 d3 sub %edx,%ebx
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
1113d0: 8b 45 14 mov 0x14(%ebp),%eax
1113d3: 85 c0 test %eax,%eax
1113d5: 74 5b je 111432 <_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;
1113d7: 8d 34 3b lea (%ebx,%edi,1),%esi
1113da: 89 f0 mov %esi,%eax
1113dc: 31 d2 xor %edx,%edx
1113de: f7 75 14 divl 0x14(%ebp)
1113e1: 89 f0 mov %esi,%eax
1113e3: 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 ) {
1113e5: 39 c3 cmp %eax,%ebx
1113e7: 73 49 jae 111432 <_Heap_Allocate_aligned_with_boundary+0x11e>
1113e9: 39 c6 cmp %eax,%esi
1113eb: 76 45 jbe 111432 <_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;
1113ed: 8b 55 d4 mov -0x2c(%ebp),%edx
1113f0: 01 fa add %edi,%edx
1113f2: 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 ) {
1113f5: 39 c2 cmp %eax,%edx
1113f7: 0f 87 7a ff ff ff ja 111377 <_Heap_Allocate_aligned_with_boundary+0x63>
1113fd: 89 ce mov %ecx,%esi
1113ff: eb 10 jmp 111411 <_Heap_Allocate_aligned_with_boundary+0xfd>
111401: 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 ) {
111404: 39 c1 cmp %eax,%ecx
111406: 76 28 jbe 111430 <_Heap_Allocate_aligned_with_boundary+0x11c>
if ( boundary_line < boundary_floor ) {
111408: 39 45 e0 cmp %eax,-0x20(%ebp)
11140b: 0f 87 9f 00 00 00 ja 1114b0 <_Heap_Allocate_aligned_with_boundary+0x19c><== NEVER TAKEN
return 0;
}
alloc_begin = boundary_line - alloc_size;
111411: 89 c3 mov %eax,%ebx
111413: 29 fb sub %edi,%ebx
111415: 89 d8 mov %ebx,%eax
111417: 31 d2 xor %edx,%edx
111419: f7 75 10 divl 0x10(%ebp)
11141c: 29 d3 sub %edx,%ebx
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
11141e: 8d 0c 3b lea (%ebx,%edi,1),%ecx
111421: 89 c8 mov %ecx,%eax
111423: 31 d2 xor %edx,%edx
111425: f7 75 14 divl 0x14(%ebp)
111428: 89 c8 mov %ecx,%eax
11142a: 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 ) {
11142c: 39 c3 cmp %eax,%ebx
11142e: 72 d4 jb 111404 <_Heap_Allocate_aligned_with_boundary+0xf0>
111430: 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 ) {
111432: 39 5d d4 cmp %ebx,-0x2c(%ebp)
111435: 0f 87 3c ff ff ff ja 111377 <_Heap_Allocate_aligned_with_boundary+0x63>
11143b: be f8 ff ff ff mov $0xfffffff8,%esi
111440: 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);
111442: 01 de add %ebx,%esi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
111444: 89 d8 mov %ebx,%eax
111446: 31 d2 xor %edx,%edx
111448: 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;
11144b: 29 d6 sub %edx,%esi
if ( free_size >= min_block_size || free_size == 0 ) {
11144d: 39 75 d8 cmp %esi,-0x28(%ebp)
111450: 0f 86 19 ff ff ff jbe 11136f <_Heap_Allocate_aligned_with_boundary+0x5b>
111456: 85 f6 test %esi,%esi
111458: 0f 85 19 ff ff ff jne 111377 <_Heap_Allocate_aligned_with_boundary+0x63>
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
11145e: 85 db test %ebx,%ebx
111460: 0f 84 11 ff ff ff je 111377 <_Heap_Allocate_aligned_with_boundary+0x63><== NEVER TAKEN
111466: 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;
111468: 8b 45 08 mov 0x8(%ebp),%eax
11146b: ff 40 48 incl 0x48(%eax)
stats->searches += search_count;
11146e: 8b 55 e4 mov -0x1c(%ebp),%edx
111471: 01 50 4c add %edx,0x4c(%eax)
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
111474: 57 push %edi
111475: 53 push %ebx
111476: 51 push %ecx
111477: 50 push %eax
111478: e8 83 b3 ff ff call 10c800 <_Heap_Block_allocate>
11147d: 89 d8 mov %ebx,%eax
11147f: 83 c4 10 add $0x10,%esp
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
111482: 8b 55 e4 mov -0x1c(%ebp),%edx
111485: 8b 4d 08 mov 0x8(%ebp),%ecx
111488: 39 51 44 cmp %edx,0x44(%ecx)
11148b: 73 15 jae 1114a2 <_Heap_Allocate_aligned_with_boundary+0x18e>
stats->max_search = search_count;
11148d: 89 51 44 mov %edx,0x44(%ecx)
}
return (void *) alloc_begin;
}
111490: 8d 65 f4 lea -0xc(%ebp),%esp
111493: 5b pop %ebx
111494: 5e pop %esi
111495: 5f pop %edi
111496: c9 leave
111497: c3 ret
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
111498: 3b 7d 14 cmp 0x14(%ebp),%edi
11149b: 76 1a jbe 1114b7 <_Heap_Allocate_aligned_with_boundary+0x1a3>
11149d: 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 ) {
1114a0: 31 c0 xor %eax,%eax
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
1114a2: 8d 65 f4 lea -0xc(%ebp),%esp
1114a5: 5b pop %ebx
1114a6: 5e pop %esi
1114a7: 5f pop %edi
1114a8: c9 leave
1114a9: c3 ret
1114aa: 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 ) {
1114ac: 31 c0 xor %eax,%eax
1114ae: eb d2 jmp 111482 <_Heap_Allocate_aligned_with_boundary+0x16e>
1114b0: 89 f1 mov %esi,%ecx <== NOT EXECUTED
1114b2: e9 c0 fe ff ff jmp 111377 <_Heap_Allocate_aligned_with_boundary+0x63><== NOT EXECUTED
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
return NULL;
}
if ( alignment == 0 ) {
1114b7: 8b 4d 10 mov 0x10(%ebp),%ecx
1114ba: 85 c9 test %ecx,%ecx
1114bc: 0f 85 80 fe ff ff jne 111342 <_Heap_Allocate_aligned_with_boundary+0x2e>
alignment = page_size;
1114c2: 89 55 10 mov %edx,0x10(%ebp)
1114c5: e9 78 fe ff ff jmp 111342 <_Heap_Allocate_aligned_with_boundary+0x2e>
001118a8 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
1118a8: 55 push %ebp
1118a9: 89 e5 mov %esp,%ebp
1118ab: 57 push %edi
1118ac: 56 push %esi
1118ad: 53 push %ebx
1118ae: 83 ec 4c sub $0x4c,%esp
1118b1: 8b 5d 08 mov 0x8(%ebp),%ebx
1118b4: 8b 4d 10 mov 0x10(%ebp),%ecx
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
1118b7: 8b 43 20 mov 0x20(%ebx),%eax
1118ba: 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;
1118bd: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
Heap_Block *extend_last_block = NULL;
1118c4: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
uintptr_t const page_size = heap->page_size;
1118cb: 8b 53 10 mov 0x10(%ebx),%edx
1118ce: 89 55 d4 mov %edx,-0x2c(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
1118d1: 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;
1118d4: 8b 73 30 mov 0x30(%ebx),%esi
1118d7: 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 ) {
1118da: 8b 55 0c mov 0xc(%ebp),%edx
1118dd: 01 ca add %ecx,%edx
1118df: 89 55 cc mov %edx,-0x34(%ebp)
1118e2: 73 0c jae 1118f0 <_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;
1118e4: 31 c0 xor %eax,%eax
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
1118e6: 8d 65 f4 lea -0xc(%ebp),%esp
1118e9: 5b pop %ebx
1118ea: 5e pop %esi
1118eb: 5f pop %edi
1118ec: c9 leave
1118ed: c3 ret
1118ee: 66 90 xchg %ax,%ax
if ( extend_area_end < extend_area_begin ) {
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
1118f0: 83 ec 08 sub $0x8,%esp
1118f3: 8d 55 e0 lea -0x20(%ebp),%edx
1118f6: 52 push %edx
1118f7: 8d 55 e4 lea -0x1c(%ebp),%edx
1118fa: 52 push %edx
1118fb: 50 push %eax
1118fc: ff 75 d4 pushl -0x2c(%ebp)
1118ff: 51 push %ecx
111900: ff 75 0c pushl 0xc(%ebp)
111903: e8 14 b1 ff ff call 10ca1c <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
111908: 83 c4 20 add $0x20,%esp
11190b: 84 c0 test %al,%al
11190d: 74 d5 je 1118e4 <_Heap_Extend+0x3c>
11190f: 8b 7d d0 mov -0x30(%ebp),%edi
111912: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%ebp)
111919: c7 45 b8 00 00 00 00 movl $0x0,-0x48(%ebp)
111920: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp)
111927: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
11192e: 8b 75 cc mov -0x34(%ebp),%esi
111931: 89 5d b4 mov %ebx,-0x4c(%ebp)
111934: eb 30 jmp 111966 <_Heap_Extend+0xbe>
111936: 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 ) {
111938: 39 ce cmp %ecx,%esi
11193a: 73 03 jae 11193f <_Heap_Extend+0x97>
11193c: 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);
11193f: 8d 59 f8 lea -0x8(%ecx),%ebx
111942: 89 c8 mov %ecx,%eax
111944: 31 d2 xor %edx,%edx
111946: 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);
111949: 29 d3 sub %edx,%ebx
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
11194b: 3b 4d 0c cmp 0xc(%ebp),%ecx
11194e: 74 3c je 11198c <_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 ) {
111950: 39 4d 0c cmp %ecx,0xc(%ebp)
111953: 76 03 jbe 111958 <_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 )
111955: 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;
111958: 8b 7b 04 mov 0x4(%ebx),%edi
11195b: 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);
11195e: 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 );
111961: 39 7d d0 cmp %edi,-0x30(%ebp)
111964: 74 39 je 11199f <_Heap_Extend+0xf7>
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
111966: 3b 7d d0 cmp -0x30(%ebp),%edi
111969: 0f 84 39 01 00 00 je 111aa8 <_Heap_Extend+0x200>
11196f: 89 f8 mov %edi,%eax
uintptr_t const sub_area_end = start_block->prev_size;
111971: 8b 0f mov (%edi),%ecx
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
111973: 39 4d 0c cmp %ecx,0xc(%ebp)
111976: 73 08 jae 111980 <_Heap_Extend+0xd8>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
111978: 39 f0 cmp %esi,%eax
11197a: 0f 82 64 ff ff ff jb 1118e4 <_Heap_Extend+0x3c>
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
111980: 39 f0 cmp %esi,%eax
111982: 75 b4 jne 111938 <_Heap_Extend+0x90>
111984: 89 7d c4 mov %edi,-0x3c(%ebp)
111987: eb b6 jmp 11193f <_Heap_Extend+0x97>
111989: 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;
11198c: 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 )
11198e: 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;
111991: 8b 7b 04 mov 0x4(%ebx),%edi
111994: 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);
111997: 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 );
11199a: 39 7d d0 cmp %edi,-0x30(%ebp)
11199d: 75 c7 jne 111966 <_Heap_Extend+0xbe> <== NEVER TAKEN
11199f: 8b 5d b4 mov -0x4c(%ebp),%ebx
if ( extend_area_begin < heap->area_begin ) {
1119a2: 8b 75 0c mov 0xc(%ebp),%esi
1119a5: 3b 73 18 cmp 0x18(%ebx),%esi
1119a8: 0f 82 06 01 00 00 jb 111ab4 <_Heap_Extend+0x20c>
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
1119ae: 8b 45 cc mov -0x34(%ebp),%eax
1119b1: 3b 43 1c cmp 0x1c(%ebx),%eax
1119b4: 76 03 jbe 1119b9 <_Heap_Extend+0x111>
heap->area_end = extend_area_end;
1119b6: 89 43 1c mov %eax,0x1c(%ebx)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
1119b9: 8b 55 e0 mov -0x20(%ebp),%edx
1119bc: 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 =
1119bf: 89 d1 mov %edx,%ecx
1119c1: 29 c1 sub %eax,%ecx
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
1119c3: 8b 75 cc mov -0x34(%ebp),%esi
1119c6: 89 30 mov %esi,(%eax)
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
1119c8: 89 ce mov %ecx,%esi
1119ca: 83 ce 01 or $0x1,%esi
1119cd: 89 70 04 mov %esi,0x4(%eax)
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
1119d0: 89 0a mov %ecx,(%edx)
extend_last_block->size_and_flag = 0;
1119d2: 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 ) {
1119d9: 39 43 20 cmp %eax,0x20(%ebx)
1119dc: 0f 86 da 00 00 00 jbe 111abc <_Heap_Extend+0x214>
heap->first_block = extend_first_block;
1119e2: 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 ) {
1119e5: 8b 75 c4 mov -0x3c(%ebp),%esi
1119e8: 85 f6 test %esi,%esi
1119ea: 0f 84 10 01 00 00 je 111b00 <_Heap_Extend+0x258>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
1119f0: 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 );
1119f3: 8b 4d 0c mov 0xc(%ebp),%ecx
1119f6: 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;
1119f9: 89 c8 mov %ecx,%eax
1119fb: 31 d2 xor %edx,%edx
1119fd: f7 f6 div %esi
if ( remainder != 0 ) {
1119ff: 85 d2 test %edx,%edx
111a01: 0f 84 c9 00 00 00 je 111ad0 <_Heap_Extend+0x228> <== ALWAYS TAKEN
return value - remainder + alignment;
111a07: 8d 04 31 lea (%ecx,%esi,1),%eax <== NOT EXECUTED
111a0a: 29 d0 sub %edx,%eax <== NOT EXECUTED
uintptr_t const new_first_block_begin =
111a0c: 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;
111a0f: 8b 75 c4 mov -0x3c(%ebp),%esi
111a12: 8b 0e mov (%esi),%ecx
111a14: 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 =
111a17: 89 f0 mov %esi,%eax
111a19: 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;
111a1b: 83 c8 01 or $0x1,%eax
111a1e: 89 42 04 mov %eax,0x4(%edx)
_Heap_Free_block( heap, new_first_block );
111a21: 89 d8 mov %ebx,%eax
111a23: e8 64 fe ff ff call 11188c <_Heap_Free_block>
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
111a28: 8b 45 c8 mov -0x38(%ebp),%eax
111a2b: 85 c0 test %eax,%eax
111a2d: 0f 84 a5 00 00 00 je 111ad8 <_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,
111a33: 8b 4d cc mov -0x34(%ebp),%ecx
111a36: 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(
111a39: 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);
111a3c: 89 c8 mov %ecx,%eax
111a3e: 31 d2 xor %edx,%edx
111a40: f7 73 10 divl 0x10(%ebx)
111a43: 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)
111a45: 8b 55 c8 mov -0x38(%ebp),%edx
111a48: 8b 42 04 mov 0x4(%edx),%eax
111a4b: 29 c8 sub %ecx,%eax
| HEAP_PREV_BLOCK_USED;
111a4d: 83 c8 01 or $0x1,%eax
111a50: 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;
111a54: 8b 42 04 mov 0x4(%edx),%eax
111a57: 83 e0 01 and $0x1,%eax
block->size_and_flag = size | flag;
111a5a: 09 c8 or %ecx,%eax
111a5c: 89 42 04 mov %eax,0x4(%edx)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
111a5f: 89 d8 mov %ebx,%eax
111a61: e8 26 fe ff ff call 11188c <_Heap_Free_block>
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
111a66: 8b 75 c4 mov -0x3c(%ebp),%esi
111a69: 85 f6 test %esi,%esi
111a6b: 0f 84 ab 00 00 00 je 111b1c <_Heap_Extend+0x274>
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
111a71: 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(
111a74: 8b 43 20 mov 0x20(%ebx),%eax
111a77: 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;
111a79: 8b 4a 04 mov 0x4(%edx),%ecx
111a7c: 83 e1 01 and $0x1,%ecx
block->size_and_flag = size | flag;
111a7f: 09 c8 or %ecx,%eax
111a81: 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;
111a84: 8b 43 30 mov 0x30(%ebx),%eax
111a87: 2b 45 c0 sub -0x40(%ebp),%eax
/* Statistics */
stats->size += extended_size;
111a8a: 01 43 2c add %eax,0x2c(%ebx)
if ( extended_size_ptr != NULL )
111a8d: 8b 55 14 mov 0x14(%ebp),%edx
111a90: 85 d2 test %edx,%edx
111a92: 0f 84 a0 00 00 00 je 111b38 <_Heap_Extend+0x290> <== NEVER TAKEN
*extended_size_ptr = extended_size;
111a98: 8b 55 14 mov 0x14(%ebp),%edx
111a9b: 89 02 mov %eax,(%edx)
return true;
111a9d: b0 01 mov $0x1,%al
}
111a9f: 8d 65 f4 lea -0xc(%ebp),%esp
111aa2: 5b pop %ebx
111aa3: 5e pop %esi
111aa4: 5f pop %edi
111aa5: c9 leave
111aa6: c3 ret
111aa7: 90 nop
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
111aa8: 8b 55 b4 mov -0x4c(%ebp),%edx
111aab: 8b 42 18 mov 0x18(%edx),%eax
111aae: e9 be fe ff ff jmp 111971 <_Heap_Extend+0xc9>
111ab3: 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;
111ab4: 89 73 18 mov %esi,0x18(%ebx)
111ab7: e9 fd fe ff ff jmp 1119b9 <_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 ) {
111abc: 39 53 24 cmp %edx,0x24(%ebx)
111abf: 0f 83 20 ff ff ff jae 1119e5 <_Heap_Extend+0x13d>
heap->last_block = extend_last_block;
111ac5: 89 53 24 mov %edx,0x24(%ebx)
111ac8: e9 18 ff ff ff jmp 1119e5 <_Heap_Extend+0x13d>
111acd: 8d 76 00 lea 0x0(%esi),%esi
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
return value - remainder + alignment;
} else {
return value;
111ad0: 89 c8 mov %ecx,%eax
111ad2: e9 35 ff ff ff jmp 111a0c <_Heap_Extend+0x164>
111ad7: 90 nop
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
111ad8: 8b 7d bc mov -0x44(%ebp),%edi
111adb: 85 ff test %edi,%edi
111add: 74 87 je 111a66 <_Heap_Extend+0x1be>
_Heap_Link_above(
111adf: 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 );
111ae2: 8b 45 e4 mov -0x1c(%ebp),%eax
111ae5: 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;
111ae8: 8b 75 bc mov -0x44(%ebp),%esi
111aeb: 8b 56 04 mov 0x4(%esi),%edx
111aee: 83 e2 01 and $0x1,%edx
block->size_and_flag = size | flag;
111af1: 09 d0 or %edx,%eax
111af3: 89 46 04 mov %eax,0x4(%esi)
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
111af6: 83 49 04 01 orl $0x1,0x4(%ecx)
111afa: e9 67 ff ff ff jmp 111a66 <_Heap_Extend+0x1be>
111aff: 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 ) {
111b00: 8b 4d b8 mov -0x48(%ebp),%ecx
111b03: 85 c9 test %ecx,%ecx
111b05: 0f 84 1d ff ff ff je 111a28 <_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;
111b0b: 8b 45 b8 mov -0x48(%ebp),%eax
111b0e: 29 d0 sub %edx,%eax
111b10: 83 c8 01 or $0x1,%eax
111b13: 89 42 04 mov %eax,0x4(%edx)
111b16: e9 0d ff ff ff jmp 111a28 <_Heap_Extend+0x180>
111b1b: 90 nop
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
111b1c: 8b 4d c8 mov -0x38(%ebp),%ecx
111b1f: 85 c9 test %ecx,%ecx
111b21: 0f 85 4a ff ff ff jne 111a71 <_Heap_Extend+0x1c9>
_Heap_Free_block( heap, extend_first_block );
111b27: 8b 55 e4 mov -0x1c(%ebp),%edx
111b2a: 89 d8 mov %ebx,%eax
111b2c: e8 5b fd ff ff call 11188c <_Heap_Free_block>
111b31: e9 3b ff ff ff jmp 111a71 <_Heap_Extend+0x1c9>
111b36: 66 90 xchg %ax,%ax
stats->size += extended_size;
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
111b38: b0 01 mov $0x1,%al <== NOT EXECUTED
111b3a: e9 a7 fd ff ff jmp 1118e6 <_Heap_Extend+0x3e> <== NOT EXECUTED
001114cc <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
1114cc: 55 push %ebp
1114cd: 89 e5 mov %esp,%ebp
1114cf: 57 push %edi
1114d0: 56 push %esi
1114d1: 53 push %ebx
1114d2: 83 ec 10 sub $0x10,%esp
1114d5: 8b 5d 08 mov 0x8(%ebp),%ebx
1114d8: 8b 45 0c mov 0xc(%ebp),%eax
1114db: 8d 48 f8 lea -0x8(%eax),%ecx
1114de: 31 d2 xor %edx,%edx
1114e0: 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);
1114e3: 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
1114e5: 8b 43 20 mov 0x20(%ebx),%eax
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
1114e8: 39 c1 cmp %eax,%ecx
1114ea: 72 07 jb 1114f3 <_Heap_Free+0x27>
1114ec: 8b 73 24 mov 0x24(%ebx),%esi
1114ef: 39 f1 cmp %esi,%ecx
1114f1: 76 0d jbe 111500 <_Heap_Free+0x34>
/* 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 );
1114f3: 31 c0 xor %eax,%eax
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
1114f5: 83 c4 10 add $0x10,%esp
1114f8: 5b pop %ebx
1114f9: 5e pop %esi
1114fa: 5f pop %edi
1114fb: c9 leave
1114fc: c3 ret
1114fd: 8d 76 00 lea 0x0(%esi),%esi
111500: 8b 51 04 mov 0x4(%ecx),%edx
111503: 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;
111506: 83 e2 fe and $0xfffffffe,%edx
111509: 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);
11150c: 8d 14 11 lea (%ecx,%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;
11150f: 39 d0 cmp %edx,%eax
111511: 77 e0 ja 1114f3 <_Heap_Free+0x27> <== NEVER TAKEN
111513: 39 d6 cmp %edx,%esi
111515: 72 dc jb 1114f3 <_Heap_Free+0x27> <== NEVER TAKEN
111517: 8b 7a 04 mov 0x4(%edx),%edi
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
_HAssert( false );
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
11151a: f7 c7 01 00 00 00 test $0x1,%edi
111520: 74 d1 je 1114f3 <_Heap_Free+0x27> <== 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;
111522: 83 e7 fe and $0xfffffffe,%edi
111525: 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 ));
111528: 39 d6 cmp %edx,%esi
11152a: 0f 84 c8 00 00 00 je 1115f8 <_Heap_Free+0x12c>
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
111530: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1)
111535: 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 ) ) {
111539: f6 45 f0 01 testb $0x1,-0x10(%ebp)
11153d: 75 45 jne 111584 <_Heap_Free+0xb8>
uintptr_t const prev_size = block->prev_size;
11153f: 8b 39 mov (%ecx),%edi
111541: 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);
111544: 29 f9 sub %edi,%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;
111546: 39 c8 cmp %ecx,%eax
111548: 77 a9 ja 1114f3 <_Heap_Free+0x27> <== NEVER TAKEN
11154a: 39 ce cmp %ecx,%esi
11154c: 72 a5 jb 1114f3 <_Heap_Free+0x27> <== 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) ) {
11154e: f6 41 04 01 testb $0x1,0x4(%ecx)
111552: 74 9f je 1114f3 <_Heap_Free+0x27> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
111554: 80 7d eb 00 cmpb $0x0,-0x15(%ebp)
111558: 0f 84 a6 00 00 00 je 111604 <_Heap_Free+0x138>
uintptr_t const size = block_size + prev_size + next_block_size;
11155e: 8b 7d e4 mov -0x1c(%ebp),%edi
111561: 03 7d ec add -0x14(%ebp),%edi
111564: 03 7d f0 add -0x10(%ebp),%edi
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
111567: 8b 42 08 mov 0x8(%edx),%eax
11156a: 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;
11156d: 89 42 08 mov %eax,0x8(%edx)
next->prev = prev;
111570: 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;
111573: ff 4b 38 decl 0x38(%ebx)
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
111576: 89 f8 mov %edi,%eax
111578: 83 c8 01 or $0x1,%eax
11157b: 89 41 04 mov %eax,0x4(%ecx)
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
11157e: 89 3c 39 mov %edi,(%ecx,%edi,1)
111581: eb 2a jmp 1115ad <_Heap_Free+0xe1>
111583: 90 nop
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 */
111584: 80 7d eb 00 cmpb $0x0,-0x15(%ebp)
111588: 74 3a je 1115c4 <_Heap_Free+0xf8>
uintptr_t const size = block_size + next_block_size;
11158a: 8b 7d e4 mov -0x1c(%ebp),%edi
11158d: 03 7d ec add -0x14(%ebp),%edi
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
111590: 8b 42 08 mov 0x8(%edx),%eax
111593: 8b 52 0c mov 0xc(%edx),%edx
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
111596: 89 41 08 mov %eax,0x8(%ecx)
new_block->prev = prev;
111599: 89 51 0c mov %edx,0xc(%ecx)
next->prev = new_block;
11159c: 89 48 0c mov %ecx,0xc(%eax)
prev->next = new_block;
11159f: 89 4a 08 mov %ecx,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;
1115a2: 89 f8 mov %edi,%eax
1115a4: 83 c8 01 or $0x1,%eax
1115a7: 89 41 04 mov %eax,0x4(%ecx)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
1115aa: 89 3c 39 mov %edi,(%ecx,%edi,1)
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
1115ad: ff 4b 40 decl 0x40(%ebx)
++stats->frees;
1115b0: ff 43 50 incl 0x50(%ebx)
stats->free_size += block_size;
1115b3: 8b 55 ec mov -0x14(%ebp),%edx
1115b6: 01 53 30 add %edx,0x30(%ebx)
return( true );
1115b9: b0 01 mov $0x1,%al
}
1115bb: 83 c4 10 add $0x10,%esp
1115be: 5b pop %ebx
1115bf: 5e pop %esi
1115c0: 5f pop %edi
1115c1: c9 leave
1115c2: c3 ret
1115c3: 90 nop
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
1115c4: 8b 43 08 mov 0x8(%ebx),%eax
new_block->next = next;
1115c7: 89 41 08 mov %eax,0x8(%ecx)
new_block->prev = block_before;
1115ca: 89 59 0c mov %ebx,0xc(%ecx)
block_before->next = new_block;
1115cd: 89 4b 08 mov %ecx,0x8(%ebx)
next->prev = new_block;
1115d0: 89 48 0c mov %ecx,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;
1115d3: 8b 45 ec mov -0x14(%ebp),%eax
1115d6: 83 c8 01 or $0x1,%eax
1115d9: 89 41 04 mov %eax,0x4(%ecx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
1115dc: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = block_size;
1115e0: 8b 45 ec mov -0x14(%ebp),%eax
1115e3: 89 02 mov %eax,(%edx)
/* Statistics */
++stats->free_blocks;
1115e5: 8b 43 38 mov 0x38(%ebx),%eax
1115e8: 40 inc %eax
1115e9: 89 43 38 mov %eax,0x38(%ebx)
if ( stats->max_free_blocks < stats->free_blocks ) {
1115ec: 3b 43 3c cmp 0x3c(%ebx),%eax
1115ef: 76 bc jbe 1115ad <_Heap_Free+0xe1>
stats->max_free_blocks = stats->free_blocks;
1115f1: 89 43 3c mov %eax,0x3c(%ebx)
1115f4: eb b7 jmp 1115ad <_Heap_Free+0xe1>
1115f6: 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 ));
1115f8: c6 45 eb 00 movb $0x0,-0x15(%ebp)
1115fc: e9 38 ff ff ff jmp 111539 <_Heap_Free+0x6d>
111601: 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;
111604: 8b 45 ec mov -0x14(%ebp),%eax
111607: 03 45 f0 add -0x10(%ebp),%eax
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
11160a: 89 c6 mov %eax,%esi
11160c: 83 ce 01 or $0x1,%esi
11160f: 89 71 04 mov %esi,0x4(%ecx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
111612: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = size;
111616: 89 02 mov %eax,(%edx)
111618: eb 93 jmp 1115ad <_Heap_Free+0xe1>
0010c690 <_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
)
{
10c690: 55 push %ebp
10c691: 89 e5 mov %esp,%ebp
10c693: 57 push %edi
10c694: 56 push %esi
10c695: 53 push %ebx
10c696: 8b 4d 08 mov 0x8(%ebp),%ecx
10c699: 8b 7d 0c mov 0xc(%ebp),%edi
uintptr_t const heap_area_end = heap_area_begin + heap_area_size;
10c69c: 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 );
10c69f: 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;
10c6a2: 89 d8 mov %ebx,%eax
10c6a4: 31 d2 xor %edx,%edx
10c6a6: f7 75 10 divl 0x10(%ebp)
if ( remainder != 0 ) {
10c6a9: 85 d2 test %edx,%edx
10c6ab: 74 05 je 10c6b2 <_Heap_Get_first_and_last_block+0x22>
return value - remainder + alignment;
10c6ad: 03 5d 10 add 0x10(%ebp),%ebx
10c6b0: 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 (
10c6b2: 39 f1 cmp %esi,%ecx
10c6b4: 77 2e ja 10c6e4 <_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);
10c6b6: 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 =
10c6b9: 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
10c6bb: 39 df cmp %ebx,%edi
10c6bd: 76 25 jbe 10c6e4 <_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 );
10c6bf: 29 df sub %ebx,%edi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
10c6c1: 89 f8 mov %edi,%eax
10c6c3: 31 d2 xor %edx,%edx
10c6c5: f7 75 10 divl 0x10(%ebp)
10c6c8: 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
10c6ca: 39 7d 14 cmp %edi,0x14(%ebp)
10c6cd: 77 15 ja 10c6e4 <_Heap_Get_first_and_last_block+0x54>
) {
/* Invalid area or area too small */
return false;
}
*first_block_ptr = first_block;
10c6cf: 8b 45 18 mov 0x18(%ebp),%eax
10c6d2: 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);
10c6d4: 01 f7 add %esi,%edi
10c6d6: 8b 45 1c mov 0x1c(%ebp),%eax
10c6d9: 89 38 mov %edi,(%eax)
*last_block_ptr = last_block;
return true;
10c6db: b0 01 mov $0x1,%al
}
10c6dd: 5b pop %ebx
10c6de: 5e pop %esi
10c6df: 5f pop %edi
10c6e0: c9 leave
10c6e1: c3 ret
10c6e2: 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;
10c6e4: 31 c0 xor %eax,%eax
*first_block_ptr = first_block;
*last_block_ptr = last_block;
return true;
}
10c6e6: 5b pop %ebx
10c6e7: 5e pop %esi
10c6e8: 5f pop %edi
10c6e9: c9 leave
10c6ea: c3 ret
001151e0 <_Heap_Get_free_information>:
void _Heap_Get_free_information(
Heap_Control *the_heap,
Heap_Information *info
)
{
1151e0: 55 push %ebp
1151e1: 89 e5 mov %esp,%ebp
1151e3: 57 push %edi
1151e4: 56 push %esi
1151e5: 53 push %ebx
1151e6: 8b 7d 0c mov 0xc(%ebp),%edi
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Free_list_tail(the_heap);
info->number = 0;
1151e9: c7 07 00 00 00 00 movl $0x0,(%edi)
info->largest = 0;
1151ef: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
info->total = 0;
1151f6: 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;
}
}
1151fd: 8b 45 08 mov 0x8(%ebp),%eax
115200: 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);
115203: 39 d0 cmp %edx,%eax
115205: 74 31 je 115238 <_Heap_Get_free_information+0x58>
115207: b9 01 00 00 00 mov $0x1,%ecx
11520c: 31 f6 xor %esi,%esi
11520e: 31 db xor %ebx,%ebx
115210: eb 07 jmp 115219 <_Heap_Get_free_information+0x39>
115212: 66 90 xchg %ax,%ax
115214: 8b 77 04 mov 0x4(%edi),%esi
115217: 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;
115219: 8b 42 04 mov 0x4(%edx),%eax
11521c: 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;
11521f: 01 c3 add %eax,%ebx
if ( info->largest < the_size )
115221: 39 f0 cmp %esi,%eax
115223: 76 03 jbe 115228 <_Heap_Get_free_information+0x48>
info->largest = the_size;
115225: 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)
115228: 8b 52 08 mov 0x8(%edx),%edx
11522b: 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);
11522e: 39 55 08 cmp %edx,0x8(%ebp)
115231: 75 e1 jne 115214 <_Heap_Get_free_information+0x34>
115233: 89 0f mov %ecx,(%edi)
115235: 89 5f 08 mov %ebx,0x8(%edi)
info->number++;
info->total += the_size;
if ( info->largest < the_size )
info->largest = the_size;
}
}
115238: 5b pop %ebx
115239: 5e pop %esi
11523a: 5f pop %edi
11523b: c9 leave
11523c: c3 ret
00112044 <_Heap_Get_information>:
void _Heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
112044: 55 push %ebp
112045: 89 e5 mov %esp,%ebp
112047: 57 push %edi
112048: 56 push %esi
112049: 53 push %ebx
11204a: 83 ec 04 sub $0x4,%esp
11204d: 8b 45 08 mov 0x8(%ebp),%eax
112050: 8b 5d 0c mov 0xc(%ebp),%ebx
Heap_Block *the_block = the_heap->first_block;
112053: 8b 50 20 mov 0x20(%eax),%edx
Heap_Block *const end = the_heap->last_block;
112056: 8b 40 24 mov 0x24(%eax),%eax
112059: 89 45 f0 mov %eax,-0x10(%ebp)
memset(the_info, 0, sizeof(*the_info));
11205c: b9 18 00 00 00 mov $0x18,%ecx
112061: 31 c0 xor %eax,%eax
112063: 89 df mov %ebx,%edi
112065: f3 aa rep stos %al,%es:(%edi)
while ( the_block != end ) {
112067: 3b 55 f0 cmp -0x10(%ebp),%edx
11206a: 74 38 je 1120a4 <_Heap_Get_information+0x60><== NEVER TAKEN
11206c: 8b 7a 04 mov 0x4(%edx),%edi
11206f: eb 18 jmp 112089 <_Heap_Get_information+0x45>
112071: 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;
112074: 8d 43 0c lea 0xc(%ebx),%eax
else
info = &the_info->Free;
info->number++;
112077: ff 00 incl (%eax)
info->total += the_size;
112079: 01 48 08 add %ecx,0x8(%eax)
if ( info->largest < the_size )
11207c: 39 48 04 cmp %ecx,0x4(%eax)
11207f: 73 03 jae 112084 <_Heap_Get_information+0x40>
info->largest = the_size;
112081: 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 ) {
112084: 39 75 f0 cmp %esi,-0x10(%ebp)
112087: 74 1b je 1120a4 <_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;
112089: 89 f9 mov %edi,%ecx
11208b: 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);
11208e: 8d 34 0a lea (%edx,%ecx,1),%esi
112091: 89 f2 mov %esi,%edx
if ( info->largest < the_size )
info->largest = the_size;
the_block = next_block;
}
}
112093: 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) )
112096: f7 c7 01 00 00 00 test $0x1,%edi
11209c: 75 d6 jne 112074 <_Heap_Get_information+0x30>
info = &the_info->Used;
else
info = &the_info->Free;
11209e: 89 d8 mov %ebx,%eax
1120a0: eb d5 jmp 112077 <_Heap_Get_information+0x33>
1120a2: 66 90 xchg %ax,%ax
if ( info->largest < the_size )
info->largest = the_size;
the_block = next_block;
}
}
1120a4: 58 pop %eax
1120a5: 5b pop %ebx
1120a6: 5e pop %esi
1120a7: 5f pop %edi
1120a8: c9 leave
1120a9: c3 ret
0011f528 <_Heap_Resize_block>:
void *alloc_begin_ptr,
uintptr_t new_alloc_size,
uintptr_t *old_size,
uintptr_t *new_size
)
{
11f528: 55 push %ebp
11f529: 89 e5 mov %esp,%ebp
11f52b: 57 push %edi
11f52c: 56 push %esi
11f52d: 53 push %ebx
11f52e: 83 ec 2c sub $0x2c,%esp
11f531: 8b 5d 08 mov 0x8(%ebp),%ebx
11f534: 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);
11f537: 8d 4e f8 lea -0x8(%esi),%ecx
11f53a: 89 f0 mov %esi,%eax
11f53c: 31 d2 xor %edx,%edx
11f53e: 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);
11f541: 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;
11f543: 8b 45 14 mov 0x14(%ebp),%eax
11f546: c7 00 00 00 00 00 movl $0x0,(%eax)
*new_size = 0;
11f54c: 8b 55 18 mov 0x18(%ebp),%edx
11f54f: 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;
11f555: 39 4b 20 cmp %ecx,0x20(%ebx)
11f558: 77 05 ja 11f55f <_Heap_Resize_block+0x37>
11f55a: 39 4b 24 cmp %ecx,0x24(%ebx)
11f55d: 73 0d jae 11f56c <_Heap_Resize_block+0x44>
new_alloc_size,
old_size,
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
11f55f: b8 02 00 00 00 mov $0x2,%eax
}
}
11f564: 8d 65 f4 lea -0xc(%ebp),%esp
11f567: 5b pop %ebx
11f568: 5e pop %esi
11f569: 5f pop %edi
11f56a: c9 leave
11f56b: 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;
11f56c: 8b 41 04 mov 0x4(%ecx),%eax
11f56f: 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;
11f572: 8d 3c 01 lea (%ecx,%eax,1),%edi
11f575: 89 7d d4 mov %edi,-0x2c(%ebp)
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
11f578: 89 fa mov %edi,%edx
11f57a: 29 f2 sub %esi,%edx
11f57c: 83 c2 04 add $0x4,%edx
11f57f: 89 55 e0 mov %edx,-0x20(%ebp)
11f582: 8b 57 04 mov 0x4(%edi),%edx
11f585: 83 e2 fe and $0xfffffffe,%edx
11f588: 89 55 d0 mov %edx,-0x30(%ebp)
RTEMS_INLINE_ROUTINE bool _Heap_Is_free(
const Heap_Block *block
)
{
return !_Heap_Is_used( block );
11f58b: f6 44 17 04 01 testb $0x1,0x4(%edi,%edx,1)
11f590: 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;
11f594: 8b 55 e0 mov -0x20(%ebp),%edx
11f597: 8b 7d 14 mov 0x14(%ebp),%edi
11f59a: 89 17 mov %edx,(%edi)
if ( next_block_is_free ) {
11f59c: 80 7d df 00 cmpb $0x0,-0x21(%ebp)
11f5a0: 75 6e jne 11f610 <_Heap_Resize_block+0xe8>
block_size += next_block_size;
alloc_size += next_block_size;
}
if ( new_alloc_size > alloc_size ) {
11f5a2: 8b 55 e0 mov -0x20(%ebp),%edx
11f5a5: 39 55 10 cmp %edx,0x10(%ebp)
11f5a8: 77 79 ja 11f623 <_Heap_Resize_block+0xfb>
return HEAP_RESIZE_UNSATISFIED;
}
if ( next_block_is_free ) {
11f5aa: 80 7d df 00 cmpb $0x0,-0x21(%ebp)
11f5ae: 74 31 je 11f5e1 <_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;
11f5b0: 8b 79 04 mov 0x4(%ecx),%edi
11f5b3: 83 e7 01 and $0x1,%edi
block->size_and_flag = size | flag;
11f5b6: 09 c7 or %eax,%edi
11f5b8: 89 79 04 mov %edi,0x4(%ecx)
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
}
}
11f5bb: 8b 7d d4 mov -0x2c(%ebp),%edi
11f5be: 8b 7f 08 mov 0x8(%edi),%edi
11f5c1: 89 7d e4 mov %edi,-0x1c(%ebp)
11f5c4: 8b 55 d4 mov -0x2c(%ebp),%edx
11f5c7: 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;
11f5ca: 8b 55 e4 mov -0x1c(%ebp),%edx
11f5cd: 89 57 08 mov %edx,0x8(%edi)
next->prev = prev;
11f5d0: 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;
11f5d3: 83 4c 01 04 01 orl $0x1,0x4(%ecx,%eax,1)
/* Statistics */
--stats->free_blocks;
11f5d8: ff 4b 38 decl 0x38(%ebx)
stats->free_size -= next_block_size;
11f5db: 8b 7d d0 mov -0x30(%ebp),%edi
11f5de: 29 7b 30 sub %edi,0x30(%ebx)
}
block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size );
11f5e1: ff 75 10 pushl 0x10(%ebp)
11f5e4: 56 push %esi
11f5e5: 51 push %ecx
11f5e6: 53 push %ebx
11f5e7: e8 14 d2 fe ff call 10c800 <_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;
11f5ec: 8b 50 04 mov 0x4(%eax),%edx
11f5ef: 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;
11f5f2: 29 f0 sub %esi,%eax
11f5f4: 8d 44 10 04 lea 0x4(%eax,%edx,1),%eax
11f5f8: 8b 55 18 mov 0x18(%ebp),%edx
11f5fb: 89 02 mov %eax,(%edx)
/* Statistics */
++stats->resizes;
11f5fd: ff 43 54 incl 0x54(%ebx)
11f600: 83 c4 10 add $0x10,%esp
return HEAP_RESIZE_SUCCESSFUL;
11f603: 31 c0 xor %eax,%eax
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
}
}
11f605: 8d 65 f4 lea -0xc(%ebp),%esp
11f608: 5b pop %ebx
11f609: 5e pop %esi
11f60a: 5f pop %edi
11f60b: c9 leave
11f60c: c3 ret
11f60d: 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;
11f610: 03 45 d0 add -0x30(%ebp),%eax
alloc_size += next_block_size;
11f613: 8b 7d d0 mov -0x30(%ebp),%edi
11f616: 01 fa add %edi,%edx
11f618: 89 55 e0 mov %edx,-0x20(%ebp)
}
if ( new_alloc_size > alloc_size ) {
11f61b: 8b 55 e0 mov -0x20(%ebp),%edx
11f61e: 39 55 10 cmp %edx,0x10(%ebp)
11f621: 76 87 jbe 11f5aa <_Heap_Resize_block+0x82>
return HEAP_RESIZE_UNSATISFIED;
11f623: b8 01 00 00 00 mov $0x1,%eax
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
}
}
11f628: 8d 65 f4 lea -0xc(%ebp),%esp
11f62b: 5b pop %ebx
11f62c: 5e pop %esi
11f62d: 5f pop %edi
11f62e: c9 leave
11f62f: c3 ret
0011f630 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
11f630: 55 push %ebp
11f631: 89 e5 mov %esp,%ebp
11f633: 56 push %esi
11f634: 53 push %ebx
11f635: 8b 5d 08 mov 0x8(%ebp),%ebx
11f638: 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);
11f63b: 8d 4e f8 lea -0x8(%esi),%ecx
11f63e: 89 f0 mov %esi,%eax
11f640: 31 d2 xor %edx,%edx
11f642: 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);
11f645: 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
11f647: 8b 43 20 mov 0x20(%ebx),%eax
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11f64a: 39 c1 cmp %eax,%ecx
11f64c: 72 07 jb 11f655 <_Heap_Size_of_alloc_area+0x25>
11f64e: 8b 53 24 mov 0x24(%ebx),%edx
11f651: 39 d1 cmp %edx,%ecx
11f653: 76 07 jbe 11f65c <_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;
11f655: 31 c0 xor %eax,%eax
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
11f657: 5b pop %ebx
11f658: 5e pop %esi
11f659: c9 leave
11f65a: c3 ret
11f65b: 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;
11f65c: 8b 59 04 mov 0x4(%ecx),%ebx
11f65f: 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);
11f662: 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;
11f664: 39 c8 cmp %ecx,%eax
11f666: 77 ed ja 11f655 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN
11f668: 39 ca cmp %ecx,%edx
11f66a: 72 e9 jb 11f655 <_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 )
11f66c: f6 41 04 01 testb $0x1,0x4(%ecx)
11f670: 74 e3 je 11f655 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
11f672: 29 f1 sub %esi,%ecx
11f674: 8d 51 04 lea 0x4(%ecx),%edx
11f677: 8b 45 10 mov 0x10(%ebp),%eax
11f67a: 89 10 mov %edx,(%eax)
return true;
11f67c: b0 01 mov $0x1,%al
}
11f67e: 5b pop %ebx
11f67f: 5e pop %esi
11f680: c9 leave
11f681: c3 ret
0010d334 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
10d334: 55 push %ebp
10d335: 89 e5 mov %esp,%ebp
10d337: 57 push %edi
10d338: 56 push %esi
10d339: 53 push %ebx
10d33a: 83 ec 4c sub $0x4c,%esp
10d33d: 8b 5d 08 mov 0x8(%ebp),%ebx
uintptr_t const page_size = heap->page_size;
10d340: 8b 43 10 mov 0x10(%ebx),%eax
10d343: 89 45 e0 mov %eax,-0x20(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10d346: 8b 53 14 mov 0x14(%ebx),%edx
10d349: 89 55 d0 mov %edx,-0x30(%ebp)
Heap_Block *const first_block = heap->first_block;
10d34c: 8b 43 20 mov 0x20(%ebx),%eax
10d34f: 89 45 dc mov %eax,-0x24(%ebp)
Heap_Block *const last_block = heap->last_block;
10d352: 8b 53 24 mov 0x24(%ebx),%edx
10d355: 89 55 cc mov %edx,-0x34(%ebp)
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
10d358: 80 7d 10 00 cmpb $0x0,0x10(%ebp)
10d35c: 74 1a je 10d378 <_Heap_Walk+0x44>
10d35e: c7 45 d8 ec d2 10 00 movl $0x10d2ec,-0x28(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
10d365: 83 3d 20 a4 12 00 03 cmpl $0x3,0x12a420
10d36c: 74 1a je 10d388 <_Heap_Walk+0x54> <== ALWAYS TAKEN
}
block = next_block;
} while ( block != first_block );
return true;
10d36e: b0 01 mov $0x1,%al
}
10d370: 8d 65 f4 lea -0xc(%ebp),%esp
10d373: 5b pop %ebx
10d374: 5e pop %esi
10d375: 5f pop %edi
10d376: c9 leave
10d377: 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;
10d378: c7 45 d8 e4 d2 10 00 movl $0x10d2e4,-0x28(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
10d37f: 83 3d 20 a4 12 00 03 cmpl $0x3,0x12a420
10d386: 75 e6 jne 10d36e <_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)(
10d388: 52 push %edx
10d389: ff 73 0c pushl 0xc(%ebx)
10d38c: ff 73 08 pushl 0x8(%ebx)
10d38f: ff 75 cc pushl -0x34(%ebp)
10d392: ff 75 dc pushl -0x24(%ebp)
10d395: ff 73 1c pushl 0x1c(%ebx)
10d398: ff 73 18 pushl 0x18(%ebx)
10d39b: ff 75 d0 pushl -0x30(%ebp)
10d39e: ff 75 e0 pushl -0x20(%ebp)
10d3a1: 68 a4 25 12 00 push $0x1225a4
10d3a6: 6a 00 push $0x0
10d3a8: ff 75 0c pushl 0xc(%ebp)
10d3ab: 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 ) {
10d3ae: 83 c4 30 add $0x30,%esp
10d3b1: 8b 45 e0 mov -0x20(%ebp),%eax
10d3b4: 85 c0 test %eax,%eax
10d3b6: 74 70 je 10d428 <_Heap_Walk+0xf4>
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
10d3b8: f6 45 e0 03 testb $0x3,-0x20(%ebp)
10d3bc: 75 72 jne 10d430 <_Heap_Walk+0xfc>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d3be: 8b 45 d0 mov -0x30(%ebp),%eax
10d3c1: 31 d2 xor %edx,%edx
10d3c3: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
10d3c6: 85 d2 test %edx,%edx
10d3c8: 75 72 jne 10d43c <_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;
10d3ca: 8b 45 dc mov -0x24(%ebp),%eax
10d3cd: 83 c0 08 add $0x8,%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d3d0: 31 d2 xor %edx,%edx
10d3d2: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if (
10d3d5: 85 d2 test %edx,%edx
10d3d7: 75 6f jne 10d448 <_Heap_Walk+0x114>
block = next_block;
} while ( block != first_block );
return true;
}
10d3d9: 8b 45 dc mov -0x24(%ebp),%eax
10d3dc: 8b 40 04 mov 0x4(%eax),%eax
10d3df: 89 45 e4 mov %eax,-0x1c(%ebp)
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
10d3e2: a8 01 test $0x1,%al
10d3e4: 0f 84 ce 02 00 00 je 10d6b8 <_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;
10d3ea: 8b 55 cc mov -0x34(%ebp),%edx
10d3ed: 8b 42 04 mov 0x4(%edx),%eax
10d3f0: 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);
10d3f3: 01 d0 add %edx,%eax
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
10d3f5: f6 40 04 01 testb $0x1,0x4(%eax)
10d3f9: 74 25 je 10d420 <_Heap_Walk+0xec>
);
return false;
}
if (
10d3fb: 39 45 dc cmp %eax,-0x24(%ebp)
10d3fe: 74 54 je 10d454 <_Heap_Walk+0x120> <== ALWAYS TAKEN
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
10d400: 51 push %ecx <== NOT EXECUTED
10d401: 68 c0 26 12 00 push $0x1226c0 <== NOT EXECUTED
10d406: 66 90 xchg %ax,%ax <== NOT EXECUTED
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10d408: 6a 01 push $0x1
10d40a: ff 75 0c pushl 0xc(%ebp)
10d40d: ff 55 d8 call *-0x28(%ebp)
10d410: 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;
10d413: 31 c0 xor %eax,%eax
block = next_block;
} while ( block != first_block );
return true;
}
10d415: 8d 65 f4 lea -0xc(%ebp),%esp
10d418: 5b pop %ebx
10d419: 5e pop %esi
10d41a: 5f pop %edi
10d41b: c9 leave
10d41c: c3 ret
10d41d: 8d 76 00 lea 0x0(%esi),%esi
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
10d420: 53 push %ebx
10d421: 68 5a 25 12 00 push $0x12255a
10d426: eb e0 jmp 10d408 <_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" );
10d428: 57 push %edi
10d429: 68 29 25 12 00 push $0x122529
10d42e: eb d8 jmp 10d408 <_Heap_Walk+0xd4>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
10d430: ff 75 e0 pushl -0x20(%ebp)
10d433: 68 3c 25 12 00 push $0x12253c
10d438: eb ce jmp 10d408 <_Heap_Walk+0xd4>
10d43a: 66 90 xchg %ax,%ax
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
10d43c: ff 75 d0 pushl -0x30(%ebp)
10d43f: 68 38 26 12 00 push $0x122638
10d444: eb c2 jmp 10d408 <_Heap_Walk+0xd4>
10d446: 66 90 xchg %ax,%ax
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
10d448: ff 75 dc pushl -0x24(%ebp)
10d44b: 68 5c 26 12 00 push $0x12265c
10d450: eb b6 jmp 10d408 <_Heap_Walk+0xd4>
10d452: 66 90 xchg %ax,%ax
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
10d454: 8b 43 10 mov 0x10(%ebx),%eax
10d457: 89 45 c8 mov %eax,-0x38(%ebp)
block = next_block;
} while ( block != first_block );
return true;
}
10d45a: 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 ) {
10d45d: 39 f3 cmp %esi,%ebx
10d45f: 74 65 je 10d4c6 <_Heap_Walk+0x192>
block = next_block;
} while ( block != first_block );
return true;
}
10d461: 8b 43 20 mov 0x20(%ebx),%eax
10d464: 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;
10d467: 39 f0 cmp %esi,%eax
10d469: 0f 87 55 02 00 00 ja 10d6c4 <_Heap_Walk+0x390> <== NEVER TAKEN
10d46f: 8b 7b 24 mov 0x24(%ebx),%edi
10d472: 39 f7 cmp %esi,%edi
10d474: 0f 82 4a 02 00 00 jb 10d6c4 <_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;
10d47a: 8d 46 08 lea 0x8(%esi),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d47d: 31 d2 xor %edx,%edx
10d47f: f7 75 c8 divl -0x38(%ebp)
);
return false;
}
if (
10d482: 85 d2 test %edx,%edx
10d484: 0f 85 71 02 00 00 jne 10d6fb <_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;
10d48a: 8b 46 04 mov 0x4(%esi),%eax
10d48d: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10d490: f6 44 06 04 01 testb $0x1,0x4(%esi,%eax,1)
10d495: 0f 85 6d 02 00 00 jne 10d708 <_Heap_Walk+0x3d4> <== NEVER TAKEN
10d49b: 89 da mov %ebx,%edx
10d49d: 8d 76 00 lea 0x0(%esi),%esi
);
return false;
}
if ( free_block->prev != prev_block ) {
10d4a0: 8b 46 0c mov 0xc(%esi),%eax
10d4a3: 39 d0 cmp %edx,%eax
10d4a5: 0f 85 6a 02 00 00 jne 10d715 <_Heap_Walk+0x3e1>
return false;
}
prev_block = free_block;
free_block = free_block->next;
10d4ab: 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 ) {
10d4ae: 39 cb cmp %ecx,%ebx
10d4b0: 74 1a je 10d4cc <_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;
10d4b2: 39 4d d4 cmp %ecx,-0x2c(%ebp)
10d4b5: 0f 86 7d 01 00 00 jbe 10d638 <_Heap_Walk+0x304>
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
(*printer)(
10d4bb: 51 push %ecx
10d4bc: 68 f0 26 12 00 push $0x1226f0
10d4c1: e9 42 ff ff ff jmp 10d408 <_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 ) {
10d4c6: 8b 53 20 mov 0x20(%ebx),%edx
10d4c9: 89 55 d4 mov %edx,-0x2c(%ebp)
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10d4cc: 8b 7d dc mov -0x24(%ebp),%edi
10d4cf: 8b 45 d4 mov -0x2c(%ebp),%eax
10d4d2: 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;
10d4d4: 8b 4d e4 mov -0x1c(%ebp),%ecx
10d4d7: 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);
10d4da: 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;
10d4dd: 39 f0 cmp %esi,%eax
10d4df: 76 23 jbe 10d504 <_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)(
10d4e1: 83 ec 0c sub $0xc,%esp
10d4e4: 56 push %esi
10d4e5: 57 push %edi
10d4e6: 68 74 27 12 00 push $0x122774
10d4eb: 90 nop
10d4ec: 6a 01 push $0x1
10d4ee: ff 75 0c pushl 0xc(%ebp)
10d4f1: ff 55 d8 call *-0x28(%ebp)
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
10d4f4: 83 c4 20 add $0x20,%esp
10d4f7: 31 c0 xor %eax,%eax
block = next_block;
} while ( block != first_block );
return true;
}
10d4f9: 8d 65 f4 lea -0xc(%ebp),%esp
10d4fc: 5b pop %ebx
10d4fd: 5e pop %esi
10d4fe: 5f pop %edi
10d4ff: c9 leave
10d500: c3 ret
10d501: 8d 76 00 lea 0x0(%esi),%esi
10d504: 39 73 24 cmp %esi,0x24(%ebx)
10d507: 72 d8 jb 10d4e1 <_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;
10d509: 3b 7d cc cmp -0x34(%ebp),%edi
10d50c: 0f 95 45 d4 setne -0x2c(%ebp)
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d510: 89 c8 mov %ecx,%eax
10d512: 31 d2 xor %edx,%edx
10d514: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
10d517: 85 d2 test %edx,%edx
10d519: 74 0a je 10d525 <_Heap_Walk+0x1f1>
10d51b: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp)
10d51f: 0f 85 a6 01 00 00 jne 10d6cb <_Heap_Walk+0x397>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
10d525: 39 4d d0 cmp %ecx,-0x30(%ebp)
10d528: 76 0a jbe 10d534 <_Heap_Walk+0x200>
10d52a: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp)
10d52e: 0f 85 a6 01 00 00 jne 10d6da <_Heap_Walk+0x3a6> <== ALWAYS TAKEN
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
10d534: 39 f7 cmp %esi,%edi
10d536: 72 0a jb 10d542 <_Heap_Walk+0x20e>
10d538: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp)
10d53c: 0f 85 aa 01 00 00 jne 10d6ec <_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;
10d542: 8b 55 e4 mov -0x1c(%ebp),%edx
10d545: 83 e2 01 and $0x1,%edx
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10d548: f6 46 04 01 testb $0x1,0x4(%esi)
10d54c: 74 4e je 10d59c <_Heap_Walk+0x268>
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
10d54e: 85 d2 test %edx,%edx
10d550: 74 2e je 10d580 <_Heap_Walk+0x24c>
(*printer)(
10d552: 83 ec 0c sub $0xc,%esp
10d555: 51 push %ecx
10d556: 57 push %edi
10d557: 68 8b 25 12 00 push $0x12258b
10d55c: 6a 00 push $0x0
10d55e: ff 75 0c pushl 0xc(%ebp)
10d561: ff 55 d8 call *-0x28(%ebp)
10d564: 83 c4 20 add $0x20,%esp
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10d567: 39 75 dc cmp %esi,-0x24(%ebp)
10d56a: 0f 84 fe fd ff ff je 10d36e <_Heap_Walk+0x3a>
10d570: 8b 56 04 mov 0x4(%esi),%edx
10d573: 89 55 e4 mov %edx,-0x1c(%ebp)
10d576: 8b 43 20 mov 0x20(%ebx),%eax
10d579: 89 f7 mov %esi,%edi
10d57b: e9 54 ff ff ff jmp 10d4d4 <_Heap_Walk+0x1a0>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
10d580: 83 ec 08 sub $0x8,%esp
10d583: ff 37 pushl (%edi)
10d585: 51 push %ecx
10d586: 57 push %edi
10d587: 68 d8 28 12 00 push $0x1228d8
10d58c: 6a 00 push $0x0
10d58e: ff 75 0c pushl 0xc(%ebp)
10d591: ff 55 d8 call *-0x28(%ebp)
10d594: 83 c4 20 add $0x20,%esp
10d597: eb ce jmp 10d567 <_Heap_Walk+0x233>
10d599: 8d 76 00 lea 0x0(%esi),%esi
block = next_block;
} while ( block != first_block );
return true;
}
10d59c: 8b 43 08 mov 0x8(%ebx),%eax
10d59f: 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 ?
10d5a2: 8b 47 08 mov 0x8(%edi),%eax
10d5a5: 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)(
10d5a8: 39 43 0c cmp %eax,0xc(%ebx)
10d5ab: 0f 84 cb 00 00 00 je 10d67c <_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)" : "")
10d5b1: 39 c3 cmp %eax,%ebx
10d5b3: 0f 84 db 00 00 00 je 10d694 <_Heap_Walk+0x360>
10d5b9: c7 45 c8 29 24 12 00 movl $0x122429,-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 ?
10d5c0: 8b 47 0c mov 0xc(%edi),%eax
10d5c3: 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)(
10d5c6: 39 45 b4 cmp %eax,-0x4c(%ebp)
10d5c9: 0f 84 b9 00 00 00 je 10d688 <_Heap_Walk+0x354>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10d5cf: 39 c3 cmp %eax,%ebx
10d5d1: 0f 84 c9 00 00 00 je 10d6a0 <_Heap_Walk+0x36c>
10d5d7: b8 29 24 12 00 mov $0x122429,%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)(
10d5dc: 83 ec 0c sub $0xc,%esp
10d5df: ff 75 c8 pushl -0x38(%ebp)
10d5e2: ff 75 e4 pushl -0x1c(%ebp)
10d5e5: 50 push %eax
10d5e6: ff 75 d4 pushl -0x2c(%ebp)
10d5e9: 51 push %ecx
10d5ea: 57 push %edi
10d5eb: 68 34 28 12 00 push $0x122834
10d5f0: 6a 00 push $0x0
10d5f2: ff 75 0c pushl 0xc(%ebp)
10d5f5: 89 55 c4 mov %edx,-0x3c(%ebp)
10d5f8: 89 4d c0 mov %ecx,-0x40(%ebp)
10d5fb: 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 ) {
10d5fe: 8b 06 mov (%esi),%eax
10d600: 83 c4 30 add $0x30,%esp
10d603: 8b 4d c0 mov -0x40(%ebp),%ecx
10d606: 39 c1 cmp %eax,%ecx
10d608: 8b 55 c4 mov -0x3c(%ebp),%edx
10d60b: 75 5f jne 10d66c <_Heap_Walk+0x338>
);
return false;
}
if ( !prev_used ) {
10d60d: 85 d2 test %edx,%edx
10d60f: 0f 84 97 00 00 00 je 10d6ac <_Heap_Walk+0x378>
block = next_block;
} while ( block != first_block );
return true;
}
10d615: 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 ) {
10d618: 39 c3 cmp %eax,%ebx
10d61a: 74 0f je 10d62b <_Heap_Walk+0x2f7> <== NEVER TAKEN
if ( free_block == block ) {
10d61c: 39 c7 cmp %eax,%edi
10d61e: 0f 84 43 ff ff ff je 10d567 <_Heap_Walk+0x233>
return true;
}
free_block = free_block->next;
10d624: 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 ) {
10d627: 39 c3 cmp %eax,%ebx
10d629: 75 f1 jne 10d61c <_Heap_Walk+0x2e8>
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10d62b: 57 push %edi
10d62c: 68 00 29 12 00 push $0x122900
10d631: e9 d2 fd ff ff jmp 10d408 <_Heap_Walk+0xd4>
10d636: 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;
10d638: 39 f9 cmp %edi,%ecx
10d63a: 0f 87 7b fe ff ff ja 10d4bb <_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;
10d640: 8d 41 08 lea 0x8(%ecx),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d643: 31 d2 xor %edx,%edx
10d645: f7 75 c8 divl -0x38(%ebp)
);
return false;
}
if (
10d648: 85 d2 test %edx,%edx
10d64a: 0f 85 ad 00 00 00 jne 10d6fd <_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;
10d650: 8b 41 04 mov 0x4(%ecx),%eax
10d653: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10d656: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1)
10d65b: 0f 85 a9 00 00 00 jne 10d70a <_Heap_Walk+0x3d6>
10d661: 89 f2 mov %esi,%edx
10d663: 89 ce mov %ecx,%esi
10d665: e9 36 fe ff ff jmp 10d4a0 <_Heap_Walk+0x16c>
10d66a: 66 90 xchg %ax,%ax
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
10d66c: 52 push %edx
10d66d: 56 push %esi
10d66e: 50 push %eax
10d66f: 51 push %ecx
10d670: 57 push %edi
10d671: 68 6c 28 12 00 push $0x12286c
10d676: e9 71 fe ff ff jmp 10d4ec <_Heap_Walk+0x1b8>
10d67b: 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)(
10d67c: c7 45 c8 f6 24 12 00 movl $0x1224f6,-0x38(%ebp)
10d683: e9 38 ff ff ff jmp 10d5c0 <_Heap_Walk+0x28c>
10d688: b8 0f 25 12 00 mov $0x12250f,%eax
10d68d: e9 4a ff ff ff jmp 10d5dc <_Heap_Walk+0x2a8>
10d692: 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)" : "")
10d694: c7 45 c8 05 25 12 00 movl $0x122505,-0x38(%ebp)
10d69b: e9 20 ff ff ff jmp 10d5c0 <_Heap_Walk+0x28c>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10d6a0: b8 1f 25 12 00 mov $0x12251f,%eax
10d6a5: e9 32 ff ff ff jmp 10d5dc <_Heap_Walk+0x2a8>
10d6aa: 66 90 xchg %ax,%ax
return false;
}
if ( !prev_used ) {
(*printer)(
10d6ac: 57 push %edi
10d6ad: 68 a8 28 12 00 push $0x1228a8
10d6b2: e9 51 fd ff ff jmp 10d408 <_Heap_Walk+0xd4>
10d6b7: 90 nop
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
10d6b8: 56 push %esi
10d6b9: 68 90 26 12 00 push $0x122690
10d6be: e9 45 fd ff ff jmp 10d408 <_Heap_Walk+0xd4>
10d6c3: 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;
10d6c4: 89 f1 mov %esi,%ecx <== NOT EXECUTED
10d6c6: e9 f0 fd ff ff jmp 10d4bb <_Heap_Walk+0x187> <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
10d6cb: 83 ec 0c sub $0xc,%esp
10d6ce: 51 push %ecx
10d6cf: 57 push %edi
10d6d0: 68 a4 27 12 00 push $0x1227a4
10d6d5: e9 12 fe ff ff jmp 10d4ec <_Heap_Walk+0x1b8>
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
(*printer)(
10d6da: 83 ec 08 sub $0x8,%esp
10d6dd: ff 75 d0 pushl -0x30(%ebp)
10d6e0: 51 push %ecx
10d6e1: 57 push %edi
10d6e2: 68 d4 27 12 00 push $0x1227d4
10d6e7: e9 00 fe ff ff jmp 10d4ec <_Heap_Walk+0x1b8>
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
(*printer)(
10d6ec: 83 ec 0c sub $0xc,%esp
10d6ef: 56 push %esi
10d6f0: 57 push %edi
10d6f1: 68 00 28 12 00 push $0x122800
10d6f6: e9 f1 fd ff ff jmp 10d4ec <_Heap_Walk+0x1b8>
);
return false;
}
if (
10d6fb: 89 f1 mov %esi,%ecx <== NOT EXECUTED
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
10d6fd: 51 push %ecx
10d6fe: 68 10 27 12 00 push $0x122710
10d703: e9 00 fd ff ff jmp 10d408 <_Heap_Walk+0xd4>
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10d708: 89 f1 mov %esi,%ecx <== NOT EXECUTED
(*printer)(
10d70a: 51 push %ecx
10d70b: 68 6f 25 12 00 push $0x12256f
10d710: e9 f3 fc ff ff jmp 10d408 <_Heap_Walk+0xd4>
return false;
}
if ( free_block->prev != prev_block ) {
(*printer)(
10d715: 83 ec 0c sub $0xc,%esp
10d718: 50 push %eax
10d719: 56 push %esi
10d71a: 68 40 27 12 00 push $0x122740
10d71f: e9 c8 fd ff ff jmp 10d4ec <_Heap_Walk+0x1b8>
0010bda0 <_IO_Initialize_all_drivers>:
*
* Output Parameters: NONE
*/
void _IO_Initialize_all_drivers( void )
{
10bda0: 55 push %ebp
10bda1: 89 e5 mov %esp,%ebp
10bda3: 53 push %ebx
10bda4: 83 ec 04 sub $0x4,%esp
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
10bda7: 8b 0d 00 88 12 00 mov 0x128800,%ecx
10bdad: 85 c9 test %ecx,%ecx
10bdaf: 74 1a je 10bdcb <_IO_Initialize_all_drivers+0x2b><== NEVER TAKEN
10bdb1: 31 db xor %ebx,%ebx
10bdb3: 90 nop
(void) rtems_io_initialize( major, 0, NULL );
10bdb4: 52 push %edx
10bdb5: 6a 00 push $0x0
10bdb7: 6a 00 push $0x0
10bdb9: 53 push %ebx
10bdba: e8 85 52 00 00 call 111044 <rtems_io_initialize>
void _IO_Initialize_all_drivers( void )
{
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
10bdbf: 43 inc %ebx
10bdc0: 83 c4 10 add $0x10,%esp
10bdc3: 39 1d 00 88 12 00 cmp %ebx,0x128800
10bdc9: 77 e9 ja 10bdb4 <_IO_Initialize_all_drivers+0x14>
(void) rtems_io_initialize( major, 0, NULL );
}
10bdcb: 8b 5d fc mov -0x4(%ebp),%ebx
10bdce: c9 leave
10bdcf: c3 ret
0010bd08 <_IO_Manager_initialization>:
* workspace.
*
*/
void _IO_Manager_initialization(void)
{
10bd08: 55 push %ebp
10bd09: 89 e5 mov %esp,%ebp
10bd0b: 57 push %edi
10bd0c: 56 push %esi
10bd0d: 53 push %ebx
10bd0e: 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;
10bd11: 8b 1d b4 3a 12 00 mov 0x123ab4,%ebx
drivers_in_table = Configuration.number_of_device_drivers;
10bd17: a1 b0 3a 12 00 mov 0x123ab0,%eax
10bd1c: 89 45 e4 mov %eax,-0x1c(%ebp)
number_of_drivers = Configuration.maximum_drivers;
10bd1f: 8b 35 ac 3a 12 00 mov 0x123aac,%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 )
10bd25: 39 f0 cmp %esi,%eax
10bd27: 73 5f jae 10bd88 <_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(
10bd29: 8d 0c 76 lea (%esi,%esi,2),%ecx
10bd2c: c1 e1 03 shl $0x3,%ecx
10bd2f: 83 ec 0c sub $0xc,%esp
10bd32: 51 push %ecx
10bd33: 89 4d dc mov %ecx,-0x24(%ebp)
10bd36: e8 81 2c 00 00 call 10e9bc <_Workspace_Allocate_or_fatal_error>
10bd3b: 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 *)
10bd3d: a3 04 88 12 00 mov %eax,0x128804
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
10bd42: 89 35 00 88 12 00 mov %esi,0x128800
memset(
10bd48: 31 c0 xor %eax,%eax
10bd4a: 8b 4d dc mov -0x24(%ebp),%ecx
10bd4d: 89 d7 mov %edx,%edi
10bd4f: 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++ )
10bd51: 83 c4 10 add $0x10,%esp
10bd54: 8b 45 e4 mov -0x1c(%ebp),%eax
10bd57: 85 c0 test %eax,%eax
10bd59: 74 25 je 10bd80 <_IO_Manager_initialization+0x78><== NEVER TAKEN
10bd5b: a1 04 88 12 00 mov 0x128804,%eax
10bd60: 89 45 e0 mov %eax,-0x20(%ebp)
10bd63: 31 c0 xor %eax,%eax
10bd65: 31 d2 xor %edx,%edx
10bd67: 90 nop
_IO_Driver_address_table[index] = driver_table[index];
10bd68: 8b 7d e0 mov -0x20(%ebp),%edi
10bd6b: 01 c7 add %eax,%edi
10bd6d: 8d 34 03 lea (%ebx,%eax,1),%esi
10bd70: b9 06 00 00 00 mov $0x6,%ecx
10bd75: 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++ )
10bd77: 42 inc %edx
10bd78: 83 c0 18 add $0x18,%eax
10bd7b: 39 55 e4 cmp %edx,-0x1c(%ebp)
10bd7e: 77 e8 ja 10bd68 <_IO_Manager_initialization+0x60>
_IO_Driver_address_table[index] = driver_table[index];
}
10bd80: 8d 65 f4 lea -0xc(%ebp),%esp
10bd83: 5b pop %ebx
10bd84: 5e pop %esi
10bd85: 5f pop %edi
10bd86: c9 leave
10bd87: 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;
10bd88: 89 1d 04 88 12 00 mov %ebx,0x128804
_IO_Number_of_drivers = number_of_drivers;
10bd8e: 8b 45 e4 mov -0x1c(%ebp),%eax
10bd91: a3 00 88 12 00 mov %eax,0x128800
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
_IO_Driver_address_table[index] = driver_table[index];
}
10bd96: 8d 65 f4 lea -0xc(%ebp),%esp
10bd99: 5b pop %ebx
10bd9a: 5e pop %esi
10bd9b: 5f pop %edi
10bd9c: c9 leave
10bd9d: c3 ret
0010c8f4 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10c8f4: 55 push %ebp
10c8f5: 89 e5 mov %esp,%ebp
10c8f7: 53 push %ebx
10c8f8: 83 ec 08 sub $0x8,%esp
10c8fb: 8b 45 08 mov 0x8(%ebp),%eax
10c8fe: 8b 55 0c mov 0xc(%ebp),%edx
10c901: 8b 5d 10 mov 0x10(%ebp),%ebx
_Internal_errors_What_happened.the_source = the_source;
10c904: a3 34 7e 12 00 mov %eax,0x127e34
_Internal_errors_What_happened.is_internal = is_internal;
10c909: 88 15 38 7e 12 00 mov %dl,0x127e38
_Internal_errors_What_happened.the_error = the_error;
10c90f: 89 1d 3c 7e 12 00 mov %ebx,0x127e3c
_User_extensions_Fatal( the_source, is_internal, the_error );
10c915: 53 push %ebx
10c916: 0f b6 d2 movzbl %dl,%edx
10c919: 52 push %edx
10c91a: 50 push %eax
10c91b: e8 9c 1c 00 00 call 10e5bc <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
10c920: c7 05 20 7f 12 00 05 movl $0x5,0x127f20 <== NOT EXECUTED
10c927: 00 00 00
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
10c92a: fa cli <== NOT EXECUTED
10c92b: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10c92d: f4 hlt <== NOT EXECUTED
10c92e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c931: eb fe jmp 10c931 <_Internal_error_Occurred+0x3d><== NOT EXECUTED
0011161c <_Objects_API_maximum_class>:
#include <rtems/score/object.h>
unsigned int _Objects_API_maximum_class(
uint32_t api
)
{
11161c: 55 push %ebp
11161d: 89 e5 mov %esp,%ebp
11161f: 8b 45 08 mov 0x8(%ebp),%eax
111622: 48 dec %eax
111623: 83 f8 02 cmp $0x2,%eax
111626: 77 0c ja 111634 <_Objects_API_maximum_class+0x18>
111628: 8b 04 85 a0 1b 12 00 mov 0x121ba0(,%eax,4),%eax
case OBJECTS_NO_API:
default:
break;
}
return 0;
}
11162f: c9 leave
111630: c3 ret
111631: 8d 76 00 lea 0x0(%esi),%esi
#include <rtems/score/object.h>
unsigned int _Objects_API_maximum_class(
uint32_t api
)
{
111634: 31 c0 xor %eax,%eax
case OBJECTS_NO_API:
default:
break;
}
return 0;
}
111636: c9 leave
111637: c3 ret
0010c984 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
10c984: 55 push %ebp
10c985: 89 e5 mov %esp,%ebp
10c987: 56 push %esi
10c988: 53 push %ebx
10c989: 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 )
10c98c: 8b 43 18 mov 0x18(%ebx),%eax
10c98f: 85 c0 test %eax,%eax
10c991: 75 0d jne 10c9a0 <_Objects_Allocate+0x1c><== ALWAYS TAKEN
return NULL;
10c993: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
);
}
#endif
return the_object;
}
10c995: 89 c8 mov %ecx,%eax
10c997: 8d 65 f8 lea -0x8(%ebp),%esp
10c99a: 5b pop %ebx
10c99b: 5e pop %esi
10c99c: c9 leave
10c99d: c3 ret
10c99e: 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 );
10c9a0: 8d 73 20 lea 0x20(%ebx),%esi
10c9a3: 83 ec 0c sub $0xc,%esp
10c9a6: 56 push %esi
10c9a7: e8 68 f6 ff ff call 10c014 <_Chain_Get>
10c9ac: 89 c1 mov %eax,%ecx
if ( information->auto_extend ) {
10c9ae: 83 c4 10 add $0x10,%esp
10c9b1: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10c9b5: 74 de je 10c995 <_Objects_Allocate+0x11>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
10c9b7: 85 c0 test %eax,%eax
10c9b9: 74 29 je 10c9e4 <_Objects_Allocate+0x60>
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
10c9bb: 0f b7 41 08 movzwl 0x8(%ecx),%eax
10c9bf: 0f b7 53 08 movzwl 0x8(%ebx),%edx
10c9c3: 29 d0 sub %edx,%eax
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
10c9c5: 0f b7 73 14 movzwl 0x14(%ebx),%esi
10c9c9: 31 d2 xor %edx,%edx
10c9cb: f7 f6 div %esi
information->inactive_per_block[ block ]--;
10c9cd: c1 e0 02 shl $0x2,%eax
10c9d0: 03 43 30 add 0x30(%ebx),%eax
10c9d3: ff 08 decl (%eax)
information->inactive--;
10c9d5: 66 ff 4b 2c decw 0x2c(%ebx)
);
}
#endif
return the_object;
}
10c9d9: 89 c8 mov %ecx,%eax
10c9db: 8d 65 f8 lea -0x8(%ebp),%esp
10c9de: 5b pop %ebx
10c9df: 5e pop %esi
10c9e0: c9 leave
10c9e1: c3 ret
10c9e2: 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 );
10c9e4: 83 ec 0c sub $0xc,%esp
10c9e7: 53 push %ebx
10c9e8: e8 3b 00 00 00 call 10ca28 <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10c9ed: 89 34 24 mov %esi,(%esp)
10c9f0: e8 1f f6 ff ff call 10c014 <_Chain_Get>
10c9f5: 89 c1 mov %eax,%ecx
}
if ( the_object ) {
10c9f7: 83 c4 10 add $0x10,%esp
10c9fa: 85 c0 test %eax,%eax
10c9fc: 74 97 je 10c995 <_Objects_Allocate+0x11>
10c9fe: eb bb jmp 10c9bb <_Objects_Allocate+0x37>
0010ca28 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
10ca28: 55 push %ebp
10ca29: 89 e5 mov %esp,%ebp
10ca2b: 57 push %edi
10ca2c: 56 push %esi
10ca2d: 53 push %ebx
10ca2e: 83 ec 4c sub $0x4c,%esp
10ca31: 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 );
10ca34: 0f b7 43 08 movzwl 0x8(%ebx),%eax
10ca38: 89 45 cc mov %eax,-0x34(%ebp)
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
10ca3b: 8b 4b 34 mov 0x34(%ebx),%ecx
10ca3e: 85 c9 test %ecx,%ecx
10ca40: 0f 84 62 02 00 00 je 10cca8 <_Objects_Extend_information+0x280>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
10ca46: 8b 73 10 mov 0x10(%ebx),%esi
10ca49: 66 89 75 d0 mov %si,-0x30(%ebp)
10ca4d: 8b 7b 14 mov 0x14(%ebx),%edi
10ca50: 89 f0 mov %esi,%eax
10ca52: 31 d2 xor %edx,%edx
10ca54: 66 f7 f7 div %di
10ca57: 0f b7 f0 movzwl %ax,%esi
for ( ; block < block_count; block++ ) {
10ca5a: 85 f6 test %esi,%esi
10ca5c: 0f 84 5f 02 00 00 je 10ccc1 <_Objects_Extend_information+0x299><== NEVER TAKEN
if ( information->object_blocks[ block ] == NULL ) {
10ca62: 8b 01 mov (%ecx),%eax
10ca64: 85 c0 test %eax,%eax
10ca66: 0f 84 67 02 00 00 je 10ccd3 <_Objects_Extend_information+0x2ab><== NEVER TAKEN
10ca6c: 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 );
10ca6f: 8b 55 cc mov -0x34(%ebp),%edx
10ca72: 89 55 d4 mov %edx,-0x2c(%ebp)
index_base = minimum_index;
block = 0;
10ca75: 31 d2 xor %edx,%edx
10ca77: 8b 45 d4 mov -0x2c(%ebp),%eax
10ca7a: eb 0a jmp 10ca86 <_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 ) {
10ca7c: 83 3c 91 00 cmpl $0x0,(%ecx,%edx,4)
10ca80: 0f 84 c2 01 00 00 je 10cc48 <_Objects_Extend_information+0x220>
do_extend = false;
break;
} else
index_base += information->allocation_size;
10ca86: 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++ ) {
10ca88: 42 inc %edx
10ca89: 39 d6 cmp %edx,%esi
10ca8b: 77 ef ja 10ca7c <_Objects_Extend_information+0x54>
10ca8d: 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;
10ca90: b1 01 mov $0x1,%cl
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
10ca92: 0f b7 45 d0 movzwl -0x30(%ebp),%eax
10ca96: 01 f8 add %edi,%eax
10ca98: 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 ) {
10ca9b: 3d ff ff 00 00 cmp $0xffff,%eax
10caa0: 0f 87 9a 01 00 00 ja 10cc40 <_Objects_Extend_information+0x218><== NEVER TAKEN
/*
* 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;
10caa6: 0f af 7b 18 imul 0x18(%ebx),%edi
if ( information->auto_extend ) {
10caaa: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10caae: 0f 84 a0 01 00 00 je 10cc54 <_Objects_Extend_information+0x22c>
new_object_block = _Workspace_Allocate( block_size );
10cab4: 83 ec 0c sub $0xc,%esp
10cab7: 57 push %edi
10cab8: 89 55 b8 mov %edx,-0x48(%ebp)
10cabb: 88 4d b4 mov %cl,-0x4c(%ebp)
10cabe: e8 c5 1e 00 00 call 10e988 <_Workspace_Allocate>
10cac3: 89 45 c8 mov %eax,-0x38(%ebp)
if ( !new_object_block )
10cac6: 83 c4 10 add $0x10,%esp
10cac9: 85 c0 test %eax,%eax
10cacb: 8b 55 b8 mov -0x48(%ebp),%edx
10cace: 8a 4d b4 mov -0x4c(%ebp),%cl
10cad1: 0f 84 69 01 00 00 je 10cc40 <_Objects_Extend_information+0x218>
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
10cad7: 84 c9 test %cl,%cl
10cad9: 0f 84 e6 00 00 00 je 10cbc5 <_Objects_Extend_information+0x19d>
*/
/*
* Up the block count and maximum
*/
block_count++;
10cadf: 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 );
10cae2: 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 *)) +
10cae5: 8d 04 7f lea (%edi,%edi,2),%eax
((maximum + minimum_index) * sizeof(Objects_Control *));
10cae8: 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 *)) +
10caeb: 03 45 cc add -0x34(%ebp),%eax
block_count++;
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
10caee: 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 );
10caf1: 50 push %eax
10caf2: 89 55 b8 mov %edx,-0x48(%ebp)
10caf5: e8 8e 1e 00 00 call 10e988 <_Workspace_Allocate>
10cafa: 89 45 c4 mov %eax,-0x3c(%ebp)
if ( !object_blocks ) {
10cafd: 83 c4 10 add $0x10,%esp
10cb00: 85 c0 test %eax,%eax
10cb02: 8b 55 b8 mov -0x48(%ebp),%edx
10cb05: 0f 84 da 01 00 00 je 10cce5 <_Objects_Extend_information+0x2bd>
10cb0b: 8b 45 c4 mov -0x3c(%ebp),%eax
10cb0e: 8d 04 b8 lea (%eax,%edi,4),%eax
10cb11: 89 45 bc mov %eax,-0x44(%ebp)
10cb14: 8b 4d c4 mov -0x3c(%ebp),%ecx
10cb17: 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 ) {
10cb1a: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx
10cb1e: 39 4d cc cmp %ecx,-0x34(%ebp)
10cb21: 0f 82 4d 01 00 00 jb 10cc74 <_Objects_Extend_information+0x24c>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
10cb27: 8b 4d cc mov -0x34(%ebp),%ecx
10cb2a: 85 c9 test %ecx,%ecx
10cb2c: 74 12 je 10cb40 <_Objects_Extend_information+0x118><== NEVER TAKEN
10cb2e: 31 c9 xor %ecx,%ecx
10cb30: 8b 7d cc mov -0x34(%ebp),%edi
10cb33: 90 nop
local_table[ index ] = NULL;
10cb34: 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++ ) {
10cb3b: 41 inc %ecx
10cb3c: 39 cf cmp %ecx,%edi
10cb3e: 77 f4 ja 10cb34 <_Objects_Extend_information+0x10c><== NEVER TAKEN
10cb40: c1 e6 02 shl $0x2,%esi
10cb43: 89 75 c0 mov %esi,-0x40(%ebp)
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
10cb46: 8b 4d c4 mov -0x3c(%ebp),%ecx
10cb49: 8b 75 c0 mov -0x40(%ebp),%esi
10cb4c: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1)
inactive_per_block[block_count] = 0;
10cb53: 8b 4d bc mov -0x44(%ebp),%ecx
10cb56: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1)
for ( index=index_base ;
index < ( information->allocation_size + index_base );
10cb5d: 0f b7 73 14 movzwl 0x14(%ebx),%esi
10cb61: 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 ;
10cb64: 39 75 d4 cmp %esi,-0x2c(%ebp)
10cb67: 73 0f jae 10cb78 <_Objects_Extend_information+0x150><== NEVER TAKEN
10cb69: 8b 4d d4 mov -0x2c(%ebp),%ecx
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
10cb6c: 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++ ) {
10cb73: 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 ;
10cb74: 39 f1 cmp %esi,%ecx
10cb76: 72 f4 jb 10cb6c <_Objects_Extend_information+0x144>
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
}
_ISR_Disable( level );
10cb78: 9c pushf
10cb79: fa cli
10cb7a: 5f pop %edi
old_tables = information->object_blocks;
10cb7b: 8b 73 34 mov 0x34(%ebx),%esi
information->object_blocks = object_blocks;
10cb7e: 8b 4d c4 mov -0x3c(%ebp),%ecx
10cb81: 89 4b 34 mov %ecx,0x34(%ebx)
information->inactive_per_block = inactive_per_block;
10cb84: 8b 4d bc mov -0x44(%ebp),%ecx
10cb87: 89 4b 30 mov %ecx,0x30(%ebx)
information->local_table = local_table;
10cb8a: 89 43 1c mov %eax,0x1c(%ebx)
information->maximum = (Objects_Maximum) maximum;
10cb8d: 8b 45 d0 mov -0x30(%ebp),%eax
10cb90: 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) |
10cb94: 8b 0b mov (%ebx),%ecx
10cb96: c1 e1 18 shl $0x18,%ecx
10cb99: 81 c9 00 00 01 00 or $0x10000,%ecx
information->maximum_id = _Objects_Build_id(
10cb9f: 0f b7 43 04 movzwl 0x4(%ebx),%eax
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10cba3: c1 e0 1b shl $0x1b,%eax
10cba6: 09 c1 or %eax,%ecx
10cba8: 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) |
10cbac: 09 c1 or %eax,%ecx
10cbae: 89 4b 0c mov %ecx,0xc(%ebx)
information->the_class,
_Objects_Local_node,
information->maximum
);
_ISR_Enable( level );
10cbb1: 57 push %edi
10cbb2: 9d popf
_Workspace_Free( old_tables );
10cbb3: 83 ec 0c sub $0xc,%esp
10cbb6: 56 push %esi
10cbb7: 89 55 b8 mov %edx,-0x48(%ebp)
10cbba: e8 e5 1d 00 00 call 10e9a4 <_Workspace_Free>
10cbbf: 83 c4 10 add $0x10,%esp
10cbc2: 8b 55 b8 mov -0x48(%ebp),%edx
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
10cbc5: c1 e2 02 shl $0x2,%edx
10cbc8: 89 55 d0 mov %edx,-0x30(%ebp)
10cbcb: 8b 43 34 mov 0x34(%ebx),%eax
10cbce: 8b 4d c8 mov -0x38(%ebp),%ecx
10cbd1: 89 0c 10 mov %ecx,(%eax,%edx,1)
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
10cbd4: ff 73 18 pushl 0x18(%ebx)
10cbd7: 0f b7 43 14 movzwl 0x14(%ebx),%eax
10cbdb: 50 push %eax
10cbdc: 51 push %ecx
10cbdd: 8d 7d dc lea -0x24(%ebp),%edi
10cbe0: 57 push %edi
10cbe1: e8 9e 44 00 00 call 111084 <_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 ) {
10cbe6: 83 c4 10 add $0x10,%esp
10cbe9: 8b 75 d4 mov -0x2c(%ebp),%esi
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10cbec: 8d 43 20 lea 0x20(%ebx),%eax
10cbef: 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 ) {
10cbf2: eb 29 jmp 10cc1d <_Objects_Extend_information+0x1f5>
10cbf4: 8b 13 mov (%ebx),%edx
10cbf6: c1 e2 18 shl $0x18,%edx
10cbf9: 81 ca 00 00 01 00 or $0x10000,%edx
the_object->id = _Objects_Build_id(
10cbff: 0f b7 4b 04 movzwl 0x4(%ebx),%ecx
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10cc03: c1 e1 1b shl $0x1b,%ecx
10cc06: 09 ca or %ecx,%edx
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10cc08: 09 f2 or %esi,%edx
10cc0a: 89 50 08 mov %edx,0x8(%eax)
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10cc0d: 83 ec 08 sub $0x8,%esp
10cc10: 50 push %eax
10cc11: ff 75 d4 pushl -0x2c(%ebp)
10cc14: e8 bf f3 ff ff call 10bfd8 <_Chain_Append>
index++;
10cc19: 46 inc %esi
10cc1a: 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 ) {
10cc1d: 83 ec 0c sub $0xc,%esp
10cc20: 57 push %edi
10cc21: e8 ee f3 ff ff call 10c014 <_Chain_Get>
10cc26: 83 c4 10 add $0x10,%esp
10cc29: 85 c0 test %eax,%eax
10cc2b: 75 c7 jne 10cbf4 <_Objects_Extend_information+0x1cc>
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
10cc2d: 8b 43 14 mov 0x14(%ebx),%eax
10cc30: 8b 53 30 mov 0x30(%ebx),%edx
10cc33: 0f b7 c8 movzwl %ax,%ecx
10cc36: 8b 75 d0 mov -0x30(%ebp),%esi
10cc39: 89 0c 32 mov %ecx,(%edx,%esi,1)
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
10cc3c: 66 01 43 2c add %ax,0x2c(%ebx)
}
10cc40: 8d 65 f4 lea -0xc(%ebp),%esp
10cc43: 5b pop %ebx
10cc44: 5e pop %esi
10cc45: 5f pop %edi
10cc46: c9 leave
10cc47: c3 ret
10cc48: 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;
10cc4b: 31 c9 xor %ecx,%ecx
10cc4d: e9 40 fe ff ff jmp 10ca92 <_Objects_Extend_information+0x6a>
10cc52: 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 );
10cc54: 83 ec 0c sub $0xc,%esp
10cc57: 57 push %edi
10cc58: 89 55 b8 mov %edx,-0x48(%ebp)
10cc5b: 88 4d b4 mov %cl,-0x4c(%ebp)
10cc5e: e8 59 1d 00 00 call 10e9bc <_Workspace_Allocate_or_fatal_error>
10cc63: 89 45 c8 mov %eax,-0x38(%ebp)
10cc66: 83 c4 10 add $0x10,%esp
10cc69: 8a 4d b4 mov -0x4c(%ebp),%cl
10cc6c: 8b 55 b8 mov -0x48(%ebp),%edx
10cc6f: e9 63 fe ff ff jmp 10cad7 <_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,
10cc74: c1 e6 02 shl $0x2,%esi
10cc77: 89 75 c0 mov %esi,-0x40(%ebp)
10cc7a: 8b 73 34 mov 0x34(%ebx),%esi
10cc7d: 8b 7d c4 mov -0x3c(%ebp),%edi
10cc80: 8b 4d c0 mov -0x40(%ebp),%ecx
10cc83: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
10cc85: 8b 73 30 mov 0x30(%ebx),%esi
10cc88: 8b 7d bc mov -0x44(%ebp),%edi
10cc8b: 8b 4d c0 mov -0x40(%ebp),%ecx
10cc8e: 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 *) );
10cc90: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx
10cc94: 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,
10cc97: c1 e1 02 shl $0x2,%ecx
10cc9a: 8b 73 1c mov 0x1c(%ebx),%esi
10cc9d: 89 c7 mov %eax,%edi
10cc9f: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
10cca1: e9 a0 fe ff ff jmp 10cb46 <_Objects_Extend_information+0x11e>
10cca6: 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 )
10cca8: 8b 53 10 mov 0x10(%ebx),%edx
10ccab: 66 89 55 d0 mov %dx,-0x30(%ebp)
10ccaf: 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 );
10ccb3: 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;
10ccb6: b1 01 mov $0x1,%cl
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
10ccb8: 31 d2 xor %edx,%edx
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
10ccba: 31 f6 xor %esi,%esi
10ccbc: e9 d1 fd ff ff jmp 10ca92 <_Objects_Extend_information+0x6a>
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
10ccc1: 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 );
10ccc4: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED
10ccc7: 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;
10ccca: b1 01 mov $0x1,%cl <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
10cccc: 31 d2 xor %edx,%edx <== NOT EXECUTED
10ccce: e9 bf fd ff ff jmp 10ca92 <_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 ) {
10ccd3: 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 );
10ccd6: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED
10ccd9: 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;
10ccdc: 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;
10ccde: 31 d2 xor %edx,%edx <== NOT EXECUTED
10cce0: e9 ad fd ff ff jmp 10ca92 <_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 );
10cce5: 83 ec 0c sub $0xc,%esp
10cce8: ff 75 c8 pushl -0x38(%ebp)
10cceb: e8 b4 1c 00 00 call 10e9a4 <_Workspace_Free>
return;
10ccf0: 83 c4 10 add $0x10,%esp
10ccf3: e9 48 ff ff ff jmp 10cc40 <_Objects_Extend_information+0x218>
0010cd88 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
10cd88: 55 push %ebp
10cd89: 89 e5 mov %esp,%ebp
10cd8b: 56 push %esi
10cd8c: 53 push %ebx
10cd8d: 8b 75 08 mov 0x8(%ebp),%esi
10cd90: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
10cd93: 66 85 db test %bx,%bx
10cd96: 75 0c jne 10cda4 <_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;
10cd98: 31 c0 xor %eax,%eax
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
10cd9a: 8d 65 f8 lea -0x8(%ebp),%esp
10cd9d: 5b pop %ebx
10cd9e: 5e pop %esi
10cd9f: c9 leave
10cda0: c3 ret
10cda1: 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 );
10cda4: 83 ec 0c sub $0xc,%esp
10cda7: 56 push %esi
10cda8: e8 6f 48 00 00 call 11161c <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
10cdad: 83 c4 10 add $0x10,%esp
10cdb0: 85 c0 test %eax,%eax
10cdb2: 74 e4 je 10cd98 <_Objects_Get_information+0x10>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
10cdb4: 0f b7 db movzwl %bx,%ebx
10cdb7: 39 d8 cmp %ebx,%eax
10cdb9: 72 dd jb 10cd98 <_Objects_Get_information+0x10>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10cdbb: 8b 14 b5 68 7d 12 00 mov 0x127d68(,%esi,4),%edx
return NULL;
10cdc2: 31 c0 xor %eax,%eax
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10cdc4: 85 d2 test %edx,%edx
10cdc6: 74 d2 je 10cd9a <_Objects_Get_information+0x12><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
10cdc8: 8b 04 9a mov (%edx,%ebx,4),%eax
if ( !info )
10cdcb: 85 c0 test %eax,%eax
10cdcd: 74 cb je 10cd9a <_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;
10cdcf: 31 d2 xor %edx,%edx
10cdd1: 66 83 78 10 00 cmpw $0x0,0x10(%eax)
10cdd6: 0f 95 c2 setne %dl
10cdd9: f7 da neg %edx
10cddb: 21 d0 and %edx,%eax
10cddd: eb bb jmp 10cd9a <_Objects_Get_information+0x12>
0010cde0 <_Objects_Get_isr_disable>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location,
ISR_Level *level_p
)
{
10cde0: 55 push %ebp
10cde1: 89 e5 mov %esp,%ebp
10cde3: 56 push %esi
10cde4: 53 push %ebx
10cde5: 8b 55 08 mov 0x8(%ebp),%edx
10cde8: 8b 5d 10 mov 0x10(%ebp),%ebx
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
10cdeb: b8 01 00 00 00 mov $0x1,%eax
10cdf0: 2b 42 08 sub 0x8(%edx),%eax
10cdf3: 03 45 0c add 0xc(%ebp),%eax
_ISR_Disable( level );
10cdf6: 9c pushf
10cdf7: fa cli
10cdf8: 5e pop %esi
if ( information->maximum >= index ) {
10cdf9: 0f b7 4a 10 movzwl 0x10(%edx),%ecx
10cdfd: 39 c8 cmp %ecx,%eax
10cdff: 77 1b ja 10ce1c <_Objects_Get_isr_disable+0x3c>
if ( (the_object = information->local_table[ index ]) != NULL ) {
10ce01: 8b 52 1c mov 0x1c(%edx),%edx
10ce04: 8b 04 82 mov (%edx,%eax,4),%eax
10ce07: 85 c0 test %eax,%eax
10ce09: 74 21 je 10ce2c <_Objects_Get_isr_disable+0x4c>
*location = OBJECTS_LOCAL;
10ce0b: c7 03 00 00 00 00 movl $0x0,(%ebx)
*level_p = level;
10ce11: 8b 55 14 mov 0x14(%ebp),%edx
10ce14: 89 32 mov %esi,(%edx)
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
#endif
}
10ce16: 5b pop %ebx
10ce17: 5e pop %esi
10ce18: c9 leave
10ce19: c3 ret
10ce1a: 66 90 xchg %ax,%ax
}
_ISR_Enable( level );
*location = OBJECTS_ERROR;
return NULL;
}
_ISR_Enable( level );
10ce1c: 56 push %esi
10ce1d: 9d popf
*location = OBJECTS_ERROR;
10ce1e: 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;
10ce24: 31 c0 xor %eax,%eax
#endif
}
10ce26: 5b pop %ebx
10ce27: 5e pop %esi
10ce28: c9 leave
10ce29: c3 ret
10ce2a: 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 );
10ce2c: 56 push %esi
10ce2d: 9d popf
*location = OBJECTS_ERROR;
10ce2e: c7 03 01 00 00 00 movl $0x1,(%ebx)
return NULL;
10ce34: eb e0 jmp 10ce16 <_Objects_Get_isr_disable+0x36>
0010e4d0 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
10e4d0: 55 push %ebp
10e4d1: 89 e5 mov %esp,%ebp
10e4d3: 57 push %edi
10e4d4: 56 push %esi
10e4d5: 53 push %ebx
10e4d6: 83 ec 2c sub $0x2c,%esp
10e4d9: 8b 55 08 mov 0x8(%ebp),%edx
10e4dc: 8b 75 0c mov 0xc(%ebp),%esi
10e4df: 8b 5d 10 mov 0x10(%ebp),%ebx
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
10e4e2: 85 f6 test %esi,%esi
10e4e4: 75 0e jne 10e4f4 <_Objects_Get_name_as_string+0x24>
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
10e4e6: 31 db xor %ebx,%ebx
_Thread_Enable_dispatch();
return name;
}
return NULL; /* unreachable path */
}
10e4e8: 89 d8 mov %ebx,%eax
10e4ea: 8d 65 f4 lea -0xc(%ebp),%esp
10e4ed: 5b pop %ebx
10e4ee: 5e pop %esi
10e4ef: 5f pop %edi
10e4f0: c9 leave
10e4f1: c3 ret
10e4f2: 66 90 xchg %ax,%ax
Objects_Id tmpId;
if ( length == 0 )
return NULL;
if ( name == NULL )
10e4f4: 85 db test %ebx,%ebx
10e4f6: 74 f0 je 10e4e8 <_Objects_Get_name_as_string+0x18>
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10e4f8: 85 d2 test %edx,%edx
10e4fa: 75 08 jne 10e504 <_Objects_Get_name_as_string+0x34>
10e4fc: a1 f8 af 12 00 mov 0x12aff8,%eax
10e501: 8b 50 08 mov 0x8(%eax),%edx
information = _Objects_Get_information_id( tmpId );
10e504: 83 ec 0c sub $0xc,%esp
10e507: 52 push %edx
10e508: 89 55 cc mov %edx,-0x34(%ebp)
10e50b: e8 f0 fe ff ff call 10e400 <_Objects_Get_information_id>
10e510: 89 c7 mov %eax,%edi
if ( !information )
10e512: 83 c4 10 add $0x10,%esp
10e515: 85 c0 test %eax,%eax
10e517: 8b 55 cc mov -0x34(%ebp),%edx
10e51a: 74 ca je 10e4e6 <_Objects_Get_name_as_string+0x16>
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
10e51c: 51 push %ecx
10e51d: 8d 45 e4 lea -0x1c(%ebp),%eax
10e520: 50 push %eax
10e521: 52 push %edx
10e522: 57 push %edi
10e523: e8 90 00 00 00 call 10e5b8 <_Objects_Get>
switch ( location ) {
10e528: 83 c4 10 add $0x10,%esp
10e52b: 8b 55 e4 mov -0x1c(%ebp),%edx
10e52e: 85 d2 test %edx,%edx
10e530: 75 b4 jne 10e4e6 <_Objects_Get_name_as_string+0x16>
return NULL;
case OBJECTS_LOCAL:
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
10e532: 80 7f 38 00 cmpb $0x0,0x38(%edi)
10e536: 74 54 je 10e58c <_Objects_Get_name_as_string+0xbc>
s = the_object->name.name_p;
10e538: 8b 78 0c mov 0xc(%eax),%edi
lname[ 4 ] = '\0';
s = lname;
}
d = name;
if ( s ) {
10e53b: 85 ff test %edi,%edi
10e53d: 74 74 je 10e5b3 <_Objects_Get_name_as_string+0xe3>
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10e53f: 4e dec %esi
10e540: 89 75 d4 mov %esi,-0x2c(%ebp)
10e543: 74 6e je 10e5b3 <_Objects_Get_name_as_string+0xe3><== NEVER TAKEN
10e545: 8a 17 mov (%edi),%dl
10e547: 84 d2 test %dl,%dl
10e549: 74 68 je 10e5b3 <_Objects_Get_name_as_string+0xe3>
10e54b: 89 d9 mov %ebx,%ecx
10e54d: 31 c0 xor %eax,%eax
10e54f: 89 5d d0 mov %ebx,-0x30(%ebp)
10e552: eb 07 jmp 10e55b <_Objects_Get_name_as_string+0x8b>
10e554: 8a 14 07 mov (%edi,%eax,1),%dl
10e557: 84 d2 test %dl,%dl
10e559: 74 21 je 10e57c <_Objects_Get_name_as_string+0xac>
*d = (isprint((unsigned char)*s)) ? *s : '*';
10e55b: 0f b6 da movzbl %dl,%ebx
10e55e: 8b 35 e8 82 12 00 mov 0x1282e8,%esi
10e564: 0f be 5c 1e 01 movsbl 0x1(%esi,%ebx,1),%ebx
10e569: 81 e3 97 00 00 00 and $0x97,%ebx
10e56f: 75 02 jne 10e573 <_Objects_Get_name_as_string+0xa3>
10e571: b2 2a mov $0x2a,%dl
10e573: 88 11 mov %dl,(%ecx)
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10e575: 40 inc %eax
10e576: 41 inc %ecx
10e577: 3b 45 d4 cmp -0x2c(%ebp),%eax
10e57a: 72 d8 jb 10e554 <_Objects_Get_name_as_string+0x84>
10e57c: 8b 5d d0 mov -0x30(%ebp),%ebx
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
10e57f: c6 01 00 movb $0x0,(%ecx)
_Thread_Enable_dispatch();
10e582: e8 a9 0b 00 00 call 10f130 <_Thread_Enable_dispatch>
return name;
10e587: e9 5c ff ff ff jmp 10e4e8 <_Objects_Get_name_as_string+0x18>
if ( information->is_string ) {
s = the_object->name.name_p;
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
10e58c: 8b 40 0c mov 0xc(%eax),%eax
lname[ 0 ] = (u32_name >> 24) & 0xff;
10e58f: 89 c2 mov %eax,%edx
10e591: c1 ea 18 shr $0x18,%edx
10e594: 88 55 df mov %dl,-0x21(%ebp)
lname[ 1 ] = (u32_name >> 16) & 0xff;
10e597: 89 c2 mov %eax,%edx
10e599: c1 ea 10 shr $0x10,%edx
10e59c: 88 55 e0 mov %dl,-0x20(%ebp)
lname[ 2 ] = (u32_name >> 8) & 0xff;
10e59f: 89 c2 mov %eax,%edx
10e5a1: c1 ea 08 shr $0x8,%edx
10e5a4: 88 55 e1 mov %dl,-0x1f(%ebp)
lname[ 3 ] = (u32_name >> 0) & 0xff;
10e5a7: 88 45 e2 mov %al,-0x1e(%ebp)
lname[ 4 ] = '\0';
10e5aa: c6 45 e3 00 movb $0x0,-0x1d(%ebp)
s = lname;
10e5ae: 8d 7d df lea -0x21(%ebp),%edi
10e5b1: eb 8c jmp 10e53f <_Objects_Get_name_as_string+0x6f>
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10e5b3: 89 d9 mov %ebx,%ecx
10e5b5: eb c8 jmp 10e57f <_Objects_Get_name_as_string+0xaf>
0010cf90 <_Objects_Get_next>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
10cf90: 55 push %ebp
10cf91: 89 e5 mov %esp,%ebp
10cf93: 57 push %edi
10cf94: 56 push %esi
10cf95: 53 push %ebx
10cf96: 83 ec 0c sub $0xc,%esp
10cf99: 8b 5d 08 mov 0x8(%ebp),%ebx
10cf9c: 8b 75 0c mov 0xc(%ebp),%esi
10cf9f: 8b 7d 10 mov 0x10(%ebp),%edi
Objects_Control *object;
Objects_Id next_id;
if ( !information )
10cfa2: 85 db test %ebx,%ebx
10cfa4: 75 0a jne 10cfb0 <_Objects_Get_next+0x20>
if ( !location_p )
return NULL;
if ( !next_id_p )
return NULL;
10cfa6: 31 c0 xor %eax,%eax
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
10cfa8: 8d 65 f4 lea -0xc(%ebp),%esp
10cfab: 5b pop %ebx
10cfac: 5e pop %esi
10cfad: 5f pop %edi
10cfae: c9 leave
10cfaf: c3 ret
Objects_Id next_id;
if ( !information )
return NULL;
if ( !location_p )
10cfb0: 85 ff test %edi,%edi
10cfb2: 74 f2 je 10cfa6 <_Objects_Get_next+0x16>
return NULL;
if ( !next_id_p )
10cfb4: 8b 45 14 mov 0x14(%ebp),%eax
10cfb7: 85 c0 test %eax,%eax
10cfb9: 74 eb je 10cfa6 <_Objects_Get_next+0x16>
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
10cfbb: 66 85 f6 test %si,%si
10cfbe: 75 04 jne 10cfc4 <_Objects_Get_next+0x34>
next_id = information->minimum_id;
10cfc0: 8b 73 08 mov 0x8(%ebx),%esi
10cfc3: 90 nop
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
10cfc4: 66 39 73 10 cmp %si,0x10(%ebx)
10cfc8: 72 22 jb 10cfec <_Objects_Get_next+0x5c>
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
10cfca: 51 push %ecx
10cfcb: 57 push %edi
10cfcc: 56 push %esi
10cfcd: 53 push %ebx
10cfce: e8 2d 00 00 00 call 10d000 <_Objects_Get>
next_id++;
10cfd3: 46 inc %esi
} while (*location_p != OBJECTS_LOCAL);
10cfd4: 83 c4 10 add $0x10,%esp
10cfd7: 8b 17 mov (%edi),%edx
10cfd9: 85 d2 test %edx,%edx
10cfdb: 75 e7 jne 10cfc4 <_Objects_Get_next+0x34>
*next_id_p = next_id;
10cfdd: 8b 55 14 mov 0x14(%ebp),%edx
10cfe0: 89 32 mov %esi,(%edx)
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
10cfe2: 8d 65 f4 lea -0xc(%ebp),%esp
10cfe5: 5b pop %ebx
10cfe6: 5e pop %esi
10cfe7: 5f pop %edi
10cfe8: c9 leave
10cfe9: c3 ret
10cfea: 66 90 xchg %ax,%ax
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
{
*location_p = OBJECTS_ERROR;
10cfec: c7 07 01 00 00 00 movl $0x1,(%edi)
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
10cff2: 8b 45 14 mov 0x14(%ebp),%eax
10cff5: c7 00 ff ff ff ff movl $0xffffffff,(%eax)
return 0;
10cffb: 31 c0 xor %eax,%eax
10cffd: eb a9 jmp 10cfa8 <_Objects_Get_next+0x18>
0011b2a0 <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
11b2a0: 55 push %ebp
11b2a1: 89 e5 mov %esp,%ebp
11b2a3: 53 push %ebx
11b2a4: 8b 55 08 mov 0x8(%ebp),%edx
11b2a7: 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;
11b2aa: b8 01 00 00 00 mov $0x1,%eax
11b2af: 2b 42 08 sub 0x8(%edx),%eax
11b2b2: 03 45 0c add 0xc(%ebp),%eax
if ( information->maximum >= index ) {
11b2b5: 0f b7 4a 10 movzwl 0x10(%edx),%ecx
11b2b9: 39 c8 cmp %ecx,%eax
11b2bb: 77 13 ja 11b2d0 <_Objects_Get_no_protection+0x30>
if ( (the_object = information->local_table[ index ]) != NULL ) {
11b2bd: 8b 52 1c mov 0x1c(%edx),%edx
11b2c0: 8b 04 82 mov (%edx,%eax,4),%eax
11b2c3: 85 c0 test %eax,%eax
11b2c5: 74 09 je 11b2d0 <_Objects_Get_no_protection+0x30><== NEVER TAKEN
*location = OBJECTS_LOCAL;
11b2c7: 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;
}
11b2cd: 5b pop %ebx
11b2ce: c9 leave
11b2cf: 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;
11b2d0: c7 03 01 00 00 00 movl $0x1,(%ebx)
return NULL;
11b2d6: 31 c0 xor %eax,%eax
}
11b2d8: 5b pop %ebx
11b2d9: c9 leave
11b2da: c3 ret
0010e0e4 <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
10e0e4: 55 push %ebp
10e0e5: 89 e5 mov %esp,%ebp
10e0e7: 83 ec 18 sub $0x18,%esp
10e0ea: 8b 55 08 mov 0x8(%ebp),%edx
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10e0ed: 85 d2 test %edx,%edx
10e0ef: 75 08 jne 10e0f9 <_Objects_Id_to_name+0x15>
10e0f1: a1 78 af 12 00 mov 0x12af78,%eax
10e0f6: 8b 50 08 mov 0x8(%eax),%edx
10e0f9: 89 d0 mov %edx,%eax
10e0fb: c1 e8 18 shr $0x18,%eax
10e0fe: 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 )
10e101: 8d 48 ff lea -0x1(%eax),%ecx
10e104: 83 f9 02 cmp $0x2,%ecx
10e107: 77 1d ja 10e126 <_Objects_Id_to_name+0x42>
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
10e109: 8b 04 85 a8 a9 12 00 mov 0x12a9a8(,%eax,4),%eax
10e110: 85 c0 test %eax,%eax
10e112: 74 12 je 10e126 <_Objects_Id_to_name+0x42>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10e114: 89 d1 mov %edx,%ecx
10e116: c1 e9 1b shr $0x1b,%ecx
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
10e119: 8b 04 88 mov (%eax,%ecx,4),%eax
if ( !information )
10e11c: 85 c0 test %eax,%eax
10e11e: 74 06 je 10e126 <_Objects_Id_to_name+0x42><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
10e120: 80 78 38 00 cmpb $0x0,0x38(%eax)
10e124: 74 0a je 10e130 <_Objects_Id_to_name+0x4c><== ALWAYS TAKEN
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;
10e126: 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;
}
10e12b: c9 leave
10e12c: c3 ret
10e12d: 8d 76 00 lea 0x0(%esi),%esi
#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 );
10e130: 51 push %ecx
10e131: 8d 4d f4 lea -0xc(%ebp),%ecx
10e134: 51 push %ecx
10e135: 52 push %edx
10e136: 50 push %eax
10e137: e8 40 ff ff ff call 10e07c <_Objects_Get>
if ( !the_object )
10e13c: 83 c4 10 add $0x10,%esp
10e13f: 85 c0 test %eax,%eax
10e141: 74 e3 je 10e126 <_Objects_Id_to_name+0x42>
return OBJECTS_INVALID_ID;
*name = the_object->name;
10e143: 8b 50 0c mov 0xc(%eax),%edx
10e146: 8b 45 0c mov 0xc(%ebp),%eax
10e149: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10e14b: e8 14 0b 00 00 call 10ec64 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10e150: 31 c0 xor %eax,%eax
}
10e152: c9 leave
10e153: c3 ret
0010cea0 <_Objects_Initialize_information>:
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
10cea0: 55 push %ebp
10cea1: 89 e5 mov %esp,%ebp
10cea3: 57 push %edi
10cea4: 56 push %esi
10cea5: 53 push %ebx
10cea6: 83 ec 0c sub $0xc,%esp
10cea9: 8b 45 08 mov 0x8(%ebp),%eax
10ceac: 8b 55 0c mov 0xc(%ebp),%edx
10ceaf: 8b 5d 10 mov 0x10(%ebp),%ebx
10ceb2: 8b 75 20 mov 0x20(%ebp),%esi
10ceb5: 0f b7 7d 18 movzwl 0x18(%ebp),%edi
uint32_t maximum_per_allocation;
#if defined(RTEMS_MULTIPROCESSING)
uint32_t index;
#endif
information->the_api = the_api;
10ceb9: 89 10 mov %edx,(%eax)
information->the_class = the_class;
10cebb: 66 89 58 04 mov %bx,0x4(%eax)
information->size = size;
10cebf: 89 78 18 mov %edi,0x18(%eax)
information->local_table = 0;
10cec2: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
information->inactive_per_block = 0;
10cec9: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
information->object_blocks = 0;
10ced0: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
information->inactive = 0;
10ced7: 66 c7 40 2c 00 00 movw $0x0,0x2c(%eax)
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
information->is_string = is_string;
10cedd: 8b 7d 1c mov 0x1c(%ebp),%edi
10cee0: 89 f9 mov %edi,%ecx
10cee2: 88 48 38 mov %cl,0x38(%eax)
/*
* Set the maximum value to 0. It will be updated when objects are
* added to the inactive set from _Objects_Extend_information()
*/
information->maximum = 0;
10cee5: 66 c7 40 10 00 00 movw $0x0,0x10(%eax)
/*
* Register this Object Class in the Object Information Table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
10ceeb: 0f b7 db movzwl %bx,%ebx
10ceee: 8b 3c 95 68 7d 12 00 mov 0x127d68(,%edx,4),%edi
10cef5: 89 04 9f mov %eax,(%edi,%ebx,4)
/*
* Are we operating in limited or unlimited (e.g. auto-extend) mode.
*/
information->auto_extend =
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
10cef8: 8b 7d 14 mov 0x14(%ebp),%edi
10cefb: c1 ef 1f shr $0x1f,%edi
_Objects_Information_table[ the_api ][ the_class ] = information;
/*
* Are we operating in limited or unlimited (e.g. auto-extend) mode.
*/
information->auto_extend =
10cefe: 89 f9 mov %edi,%ecx
10cf00: 88 48 12 mov %cl,0x12(%eax)
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS;
10cf03: 8b 4d 14 mov 0x14(%ebp),%ecx
10cf06: 81 e1 ff ff ff 7f and $0x7fffffff,%ecx
/*
* Unlimited and maximum of zero is illogical.
*/
if ( information->auto_extend && maximum_per_allocation == 0) {
10cf0c: 85 ff test %edi,%edi
10cf0e: 74 04 je 10cf14 <_Objects_Initialize_information+0x74>
10cf10: 85 c9 test %ecx,%ecx
10cf12: 74 57 je 10cf6b <_Objects_Initialize_information+0xcb><== NEVER TAKEN
}
/*
* The allocation unit is the maximum value
*/
information->allocation_size = maximum_per_allocation;
10cf14: 66 89 48 14 mov %cx,0x14(%eax)
/*
* Provide a null local table entry for the case of any empty table.
*/
information->local_table = &null_local_table;
10cf18: c7 40 1c 04 7a 12 00 movl $0x127a04,0x1c(%eax)
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10cf1f: c1 e2 18 shl $0x18,%edx
10cf22: 81 ca 00 00 01 00 or $0x10000,%edx
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10cf28: c1 e3 1b shl $0x1b,%ebx
10cf2b: 09 da or %ebx,%edx
/*
* Calculate minimum and maximum Id's
*/
minimum_index = (maximum_per_allocation == 0) ? 0 : 1;
10cf2d: 31 db xor %ebx,%ebx
10cf2f: 85 c9 test %ecx,%ecx
10cf31: 0f 95 c3 setne %bl
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10cf34: 09 da or %ebx,%edx
10cf36: 89 50 08 mov %edx,0x8(%eax)
if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
~(OBJECTS_NAME_ALIGNMENT-1);
#endif
information->name_length = name_length;
10cf39: 66 89 70 3a mov %si,0x3a(%eax)
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 );
10cf3d: 8d 50 24 lea 0x24(%eax),%edx
10cf40: 89 50 20 mov %edx,0x20(%eax)
head->next = tail;
head->previous = NULL;
10cf43: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
10cf4a: 8d 50 20 lea 0x20(%eax),%edx
10cf4d: 89 50 28 mov %edx,0x28(%eax)
_Chain_Initialize_empty( &information->Inactive );
/*
* Initialize objects .. if there are any
*/
if ( maximum_per_allocation ) {
10cf50: 85 c9 test %ecx,%ecx
10cf52: 75 08 jne 10cf5c <_Objects_Initialize_information+0xbc>
_Chain_Initialize_empty( &information->global_table[ index ] );
}
else
information->global_table = NULL;
#endif
}
10cf54: 8d 65 f4 lea -0xc(%ebp),%esp
10cf57: 5b pop %ebx
10cf58: 5e pop %esi
10cf59: 5f pop %edi
10cf5a: c9 leave
10cf5b: c3 ret
/*
* Always have the maximum size available so the current performance
* figures are create are met. If the user moves past the maximum
* number then a performance hit is taken.
*/
_Objects_Extend_information( information );
10cf5c: 89 45 08 mov %eax,0x8(%ebp)
_Chain_Initialize_empty( &information->global_table[ index ] );
}
else
information->global_table = NULL;
#endif
}
10cf5f: 8d 65 f4 lea -0xc(%ebp),%esp
10cf62: 5b pop %ebx
10cf63: 5e pop %esi
10cf64: 5f pop %edi
10cf65: c9 leave
/*
* Always have the maximum size available so the current performance
* figures are create are met. If the user moves past the maximum
* number then a performance hit is taken.
*/
_Objects_Extend_information( information );
10cf66: e9 bd fa ff ff jmp 10ca28 <_Objects_Extend_information>
/*
* Unlimited and maximum of zero is illogical.
*/
if ( information->auto_extend && maximum_per_allocation == 0) {
_Internal_error_Occurred(
10cf6b: 50 push %eax
10cf6c: 6a 13 push $0x13
10cf6e: 6a 01 push $0x1
10cf70: 6a 00 push $0x0
10cf72: e8 7d f9 ff ff call 10c8f4 <_Internal_error_Occurred>
00117994 <_Objects_Name_to_id_string>:
Objects_Name_or_id_lookup_errors _Objects_Name_to_id_string(
Objects_Information *information,
const char *name,
Objects_Id *id
)
{
117994: 55 push %ebp
117995: 89 e5 mov %esp,%ebp
117997: 57 push %edi
117998: 56 push %esi
117999: 53 push %ebx
11799a: 83 ec 1c sub $0x1c,%esp
11799d: 8b 7d 08 mov 0x8(%ebp),%edi
Objects_Control *the_object;
uint32_t index;
/* ASSERT: information->is_string == true */
if ( !id )
1179a0: 8b 5d 10 mov 0x10(%ebp),%ebx
1179a3: 85 db test %ebx,%ebx
1179a5: 74 75 je 117a1c <_Objects_Name_to_id_string+0x88>
return OBJECTS_INVALID_ADDRESS;
if ( !name )
1179a7: 8b 4d 0c mov 0xc(%ebp),%ecx
1179aa: 85 c9 test %ecx,%ecx
1179ac: 74 4b je 1179f9 <_Objects_Name_to_id_string+0x65>
return OBJECTS_INVALID_NAME;
if ( information->maximum != 0 ) {
1179ae: 8b 47 10 mov 0x10(%edi),%eax
1179b1: 66 85 c0 test %ax,%ax
1179b4: 74 43 je 1179f9 <_Objects_Name_to_id_string+0x65>
for ( index = 1; index <= information->maximum; index++ ) {
1179b6: 0f b7 c0 movzwl %ax,%eax
1179b9: 89 45 e4 mov %eax,-0x1c(%ebp)
1179bc: 8b 47 1c mov 0x1c(%edi),%eax
1179bf: bb 01 00 00 00 mov $0x1,%ebx
1179c4: 89 7d e0 mov %edi,-0x20(%ebp)
1179c7: 89 c7 mov %eax,%edi
1179c9: 8d 76 00 lea 0x0(%esi),%esi
the_object = information->local_table[ index ];
1179cc: 8b 34 9f mov (%edi,%ebx,4),%esi
if ( !the_object )
1179cf: 85 f6 test %esi,%esi
1179d1: 74 20 je 1179f3 <_Objects_Name_to_id_string+0x5f>
continue;
if ( !the_object->name.name_p )
1179d3: 8b 46 0c mov 0xc(%esi),%eax
1179d6: 85 c0 test %eax,%eax
1179d8: 74 19 je 1179f3 <_Objects_Name_to_id_string+0x5f>
continue;
if (!strncmp( name, the_object->name.name_p, information->name_length)) {
1179da: 52 push %edx
1179db: 8b 4d e0 mov -0x20(%ebp),%ecx
1179de: 0f b7 51 3a movzwl 0x3a(%ecx),%edx
1179e2: 52 push %edx
1179e3: 50 push %eax
1179e4: ff 75 0c pushl 0xc(%ebp)
1179e7: e8 a0 34 00 00 call 11ae8c <strncmp>
1179ec: 83 c4 10 add $0x10,%esp
1179ef: 85 c0 test %eax,%eax
1179f1: 74 15 je 117a08 <_Objects_Name_to_id_string+0x74>
if ( !name )
return OBJECTS_INVALID_NAME;
if ( information->maximum != 0 ) {
for ( index = 1; index <= information->maximum; index++ ) {
1179f3: 43 inc %ebx
1179f4: 3b 5d e4 cmp -0x1c(%ebp),%ebx
1179f7: 76 d3 jbe 1179cc <_Objects_Name_to_id_string+0x38>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
}
}
return OBJECTS_INVALID_NAME;
1179f9: b8 01 00 00 00 mov $0x1,%eax
}
1179fe: 8d 65 f4 lea -0xc(%ebp),%esp
117a01: 5b pop %ebx
117a02: 5e pop %esi
117a03: 5f pop %edi
117a04: c9 leave
117a05: c3 ret
117a06: 66 90 xchg %ax,%ax
if ( !the_object->name.name_p )
continue;
if (!strncmp( name, the_object->name.name_p, information->name_length)) {
*id = the_object->id;
117a08: 8b 46 08 mov 0x8(%esi),%eax
117a0b: 8b 55 10 mov 0x10(%ebp),%edx
117a0e: 89 02 mov %eax,(%edx)
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
117a10: 31 c0 xor %eax,%eax
}
}
}
return OBJECTS_INVALID_NAME;
}
117a12: 8d 65 f4 lea -0xc(%ebp),%esp
117a15: 5b pop %ebx
117a16: 5e pop %esi
117a17: 5f pop %edi
117a18: c9 leave
117a19: c3 ret
117a1a: 66 90 xchg %ax,%ax
uint32_t index;
/* ASSERT: information->is_string == true */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
117a1c: b8 02 00 00 00 mov $0x2,%eax
}
}
}
return OBJECTS_INVALID_NAME;
}
117a21: 8d 65 f4 lea -0xc(%ebp),%esp
117a24: 5b pop %ebx
117a25: 5e pop %esi
117a26: 5f pop %edi
117a27: c9 leave
117a28: c3 ret
0010cfa8 <_Objects_Name_to_id_u32>:
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
10cfa8: 55 push %ebp
10cfa9: 89 e5 mov %esp,%ebp
10cfab: 57 push %edi
10cfac: 56 push %esi
10cfad: 53 push %ebx
10cfae: 8b 45 08 mov 0x8(%ebp),%eax
10cfb1: 8b 4d 0c mov 0xc(%ebp),%ecx
10cfb4: 8b 55 10 mov 0x10(%ebp),%edx
10cfb7: 8b 7d 14 mov 0x14(%ebp),%edi
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
10cfba: 85 ff test %edi,%edi
10cfbc: 74 56 je 10d014 <_Objects_Name_to_id_u32+0x6c>
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
10cfbe: 85 c9 test %ecx,%ecx
10cfc0: 74 08 je 10cfca <_Objects_Name_to_id_u32+0x22>
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
10cfc2: 8b 70 10 mov 0x10(%eax),%esi
10cfc5: 66 85 f6 test %si,%si
10cfc8: 75 0a jne 10cfd4 <_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;
10cfca: b8 01 00 00 00 mov $0x1,%eax
#endif
}
10cfcf: 5b pop %ebx
10cfd0: 5e pop %esi
10cfd1: 5f pop %edi
10cfd2: c9 leave
10cfd3: c3 ret
if ( name == 0 )
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
10cfd4: 85 d2 test %edx,%edx
10cfd6: 75 20 jne 10cff8 <_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++ ) {
10cfd8: 0f b7 f6 movzwl %si,%esi
10cfdb: 8b 58 1c mov 0x1c(%eax),%ebx
10cfde: b8 01 00 00 00 mov $0x1,%eax
10cfe3: 90 nop
the_object = information->local_table[ index ];
10cfe4: 8b 14 83 mov (%ebx,%eax,4),%edx
if ( !the_object )
10cfe7: 85 d2 test %edx,%edx
10cfe9: 74 05 je 10cff0 <_Objects_Name_to_id_u32+0x48>
continue;
if ( name == the_object->name.name_u32 ) {
10cfeb: 39 4a 0c cmp %ecx,0xc(%edx)
10cfee: 74 18 je 10d008 <_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++ ) {
10cff0: 40 inc %eax
10cff1: 39 c6 cmp %eax,%esi
10cff3: 73 ef jae 10cfe4 <_Objects_Name_to_id_u32+0x3c>
10cff5: eb d3 jmp 10cfca <_Objects_Name_to_id_u32+0x22>
10cff7: 90 nop
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
(node == OBJECTS_SEARCH_ALL_NODES ||
10cff8: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx
10cffe: 74 d8 je 10cfd8 <_Objects_Name_to_id_u32+0x30>
node == OBJECTS_SEARCH_LOCAL_NODE ||
10d000: 4a dec %edx
10d001: 75 c7 jne 10cfca <_Objects_Name_to_id_u32+0x22>
10d003: eb d3 jmp 10cfd8 <_Objects_Name_to_id_u32+0x30>
10d005: 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;
10d008: 8b 42 08 mov 0x8(%edx),%eax
10d00b: 89 07 mov %eax,(%edi)
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10d00d: 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
}
10d00f: 5b pop %ebx
10d010: 5e pop %esi
10d011: 5f pop %edi
10d012: c9 leave
10d013: c3 ret
#endif
/* ASSERT: information->is_string == false */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
10d014: 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
}
10d019: 5b pop %ebx
10d01a: 5e pop %esi
10d01b: 5f pop %edi
10d01c: c9 leave
10d01d: c3 ret
0010d690 <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
10d690: 55 push %ebp
10d691: 89 e5 mov %esp,%ebp
10d693: 57 push %edi
10d694: 56 push %esi
10d695: 53 push %ebx
10d696: 83 ec 14 sub $0x14,%esp
10d699: 8b 7d 08 mov 0x8(%ebp),%edi
10d69c: 8b 5d 10 mov 0x10(%ebp),%ebx
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
10d69f: 0f b7 47 3a movzwl 0x3a(%edi),%eax
10d6a3: 50 push %eax
10d6a4: 53 push %ebx
10d6a5: e8 8e 79 00 00 call 115038 <strnlen>
10d6aa: 89 c6 mov %eax,%esi
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
10d6ac: 83 c4 10 add $0x10,%esp
10d6af: 80 7f 38 00 cmpb $0x0,0x38(%edi)
10d6b3: 75 57 jne 10d70c <_Objects_Set_name+0x7c>
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
10d6b5: 0f be 13 movsbl (%ebx),%edx
10d6b8: c1 e2 18 shl $0x18,%edx
10d6bb: 83 f8 01 cmp $0x1,%eax
10d6be: 76 38 jbe 10d6f8 <_Objects_Set_name+0x68>
10d6c0: 0f be 43 01 movsbl 0x1(%ebx),%eax
10d6c4: c1 e0 10 shl $0x10,%eax
10d6c7: 09 d0 or %edx,%eax
10d6c9: 83 fe 02 cmp $0x2,%esi
10d6cc: 74 31 je 10d6ff <_Objects_Set_name+0x6f>
10d6ce: 0f be 53 02 movsbl 0x2(%ebx),%edx
10d6d2: c1 e2 08 shl $0x8,%edx
10d6d5: 09 c2 or %eax,%edx
10d6d7: 83 fe 03 cmp $0x3,%esi
10d6da: 0f 84 80 00 00 00 je 10d760 <_Objects_Set_name+0xd0>
10d6e0: 0f be 43 03 movsbl 0x3(%ebx),%eax
10d6e4: 09 c2 or %eax,%edx
10d6e6: 8b 45 0c mov 0xc(%ebp),%eax
10d6e9: 89 50 0c mov %edx,0xc(%eax)
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
10d6ec: b0 01 mov $0x1,%al
}
10d6ee: 8d 65 f4 lea -0xc(%ebp),%esp
10d6f1: 5b pop %ebx
10d6f2: 5e pop %esi
10d6f3: 5f pop %edi
10d6f4: c9 leave
10d6f5: c3 ret
10d6f6: 66 90 xchg %ax,%ax
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
10d6f8: 89 d0 mov %edx,%eax
10d6fa: 0d 00 00 20 00 or $0x200000,%eax
10d6ff: 89 c2 mov %eax,%edx
10d701: 80 ce 20 or $0x20,%dh
10d704: b8 20 00 00 00 mov $0x20,%eax
10d709: eb d9 jmp 10d6e4 <_Objects_Set_name+0x54>
10d70b: 90 nop
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length + 1 );
10d70c: 83 ec 0c sub $0xc,%esp
10d70f: 8d 40 01 lea 0x1(%eax),%eax
10d712: 50 push %eax
10d713: e8 bc 19 00 00 call 10f0d4 <_Workspace_Allocate>
10d718: 89 c7 mov %eax,%edi
if ( !d )
10d71a: 83 c4 10 add $0x10,%esp
10d71d: 85 c0 test %eax,%eax
10d71f: 74 3b je 10d75c <_Objects_Set_name+0xcc>
return false;
_Workspace_Free( (void *)the_object->name.name_p );
10d721: 83 ec 0c sub $0xc,%esp
10d724: 8b 45 0c mov 0xc(%ebp),%eax
10d727: ff 70 0c pushl 0xc(%eax)
10d72a: e8 c1 19 00 00 call 10f0f0 <_Workspace_Free>
the_object->name.name_p = NULL;
10d72f: 8b 45 0c mov 0xc(%ebp),%eax
10d732: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
strncpy( d, name, length );
10d739: 83 c4 0c add $0xc,%esp
10d73c: 56 push %esi
10d73d: 53 push %ebx
10d73e: 57 push %edi
10d73f: e8 78 78 00 00 call 114fbc <strncpy>
d[length] = '\0';
10d744: c6 04 37 00 movb $0x0,(%edi,%esi,1)
the_object->name.name_p = d;
10d748: 8b 45 0c mov 0xc(%ebp),%eax
10d74b: 89 78 0c mov %edi,0xc(%eax)
10d74e: 83 c4 10 add $0x10,%esp
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
10d751: b0 01 mov $0x1,%al
}
10d753: 8d 65 f4 lea -0xc(%ebp),%esp
10d756: 5b pop %ebx
10d757: 5e pop %esi
10d758: 5f pop %edi
10d759: c9 leave
10d75a: c3 ret
10d75b: 90 nop
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length + 1 );
if ( !d )
return false;
10d75c: 31 c0 xor %eax,%eax
10d75e: eb 8e jmp 10d6ee <_Objects_Set_name+0x5e>
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
10d760: b8 20 00 00 00 mov $0x20,%eax
10d765: e9 7a ff ff ff jmp 10d6e4 <_Objects_Set_name+0x54>
0010d020 <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
10d020: 55 push %ebp
10d021: 89 e5 mov %esp,%ebp
10d023: 57 push %edi
10d024: 56 push %esi
10d025: 53 push %ebx
10d026: 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 );
10d029: 8b 45 08 mov 0x8(%ebp),%eax
10d02c: 0f b7 58 08 movzwl 0x8(%eax),%ebx
block_count = (information->maximum - index_base) /
10d030: 0f b7 48 14 movzwl 0x14(%eax),%ecx
10d034: 0f b7 40 10 movzwl 0x10(%eax),%eax
10d038: 29 d8 sub %ebx,%eax
10d03a: 31 d2 xor %edx,%edx
10d03c: f7 f1 div %ecx
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
10d03e: 85 c0 test %eax,%eax
10d040: 74 21 je 10d063 <_Objects_Shrink_information+0x43><== NEVER TAKEN
if ( information->inactive_per_block[ block ] ==
10d042: 8b 55 08 mov 0x8(%ebp),%edx
10d045: 8b 72 30 mov 0x30(%edx),%esi
10d048: 3b 0e cmp (%esi),%ecx
10d04a: 74 1f je 10d06b <_Objects_Shrink_information+0x4b><== NEVER TAKEN
10d04c: 31 d2 xor %edx,%edx
10d04e: eb 0e jmp 10d05e <_Objects_Shrink_information+0x3e>
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
10d050: 01 cb add %ecx,%ebx
10d052: 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 ] ==
10d059: 3b 0c 96 cmp (%esi,%edx,4),%ecx
10d05c: 74 12 je 10d070 <_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++ ) {
10d05e: 42 inc %edx
10d05f: 39 d0 cmp %edx,%eax
10d061: 77 ed ja 10d050 <_Objects_Shrink_information+0x30>
return;
}
index_base += information->allocation_size;
}
}
10d063: 8d 65 f4 lea -0xc(%ebp),%esp
10d066: 5b pop %ebx
10d067: 5e pop %esi
10d068: 5f pop %edi
10d069: c9 leave
10d06a: 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 ] ==
10d06b: 31 ff xor %edi,%edi <== NOT EXECUTED
10d06d: 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 );
10d070: 8b 55 08 mov 0x8(%ebp),%edx
10d073: 8b 42 20 mov 0x20(%edx),%eax
10d076: 89 7d e4 mov %edi,-0x1c(%ebp)
10d079: eb 07 jmp 10d082 <_Objects_Shrink_information+0x62>
10d07b: 90 nop
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
10d07c: 85 f6 test %esi,%esi
10d07e: 74 2c je 10d0ac <_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;
10d080: 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 );
10d082: 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;
10d086: 8b 30 mov (%eax),%esi
if ((index >= index_base) &&
10d088: 39 da cmp %ebx,%edx
10d08a: 72 f0 jb 10d07c <_Objects_Shrink_information+0x5c>
(index < (index_base + information->allocation_size))) {
10d08c: 8b 7d 08 mov 0x8(%ebp),%edi
10d08f: 0f b7 4f 14 movzwl 0x14(%edi),%ecx
10d093: 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) &&
10d096: 39 ca cmp %ecx,%edx
10d098: 73 e2 jae 10d07c <_Objects_Shrink_information+0x5c>
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
10d09a: 83 ec 0c sub $0xc,%esp
10d09d: 50 push %eax
10d09e: e8 59 ef ff ff call 10bffc <_Chain_Extract>
10d0a3: 83 c4 10 add $0x10,%esp
}
}
while ( the_object );
10d0a6: 85 f6 test %esi,%esi
10d0a8: 75 d6 jne 10d080 <_Objects_Shrink_information+0x60>
10d0aa: 66 90 xchg %ax,%ax
10d0ac: 8b 7d e4 mov -0x1c(%ebp),%edi
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
10d0af: 83 ec 0c sub $0xc,%esp
10d0b2: 8b 55 08 mov 0x8(%ebp),%edx
10d0b5: 8b 42 34 mov 0x34(%edx),%eax
10d0b8: ff 34 38 pushl (%eax,%edi,1)
10d0bb: e8 e4 18 00 00 call 10e9a4 <_Workspace_Free>
information->object_blocks[ block ] = NULL;
10d0c0: 8b 55 08 mov 0x8(%ebp),%edx
10d0c3: 8b 42 34 mov 0x34(%edx),%eax
10d0c6: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1)
information->inactive_per_block[ block ] = 0;
10d0cd: 8b 42 30 mov 0x30(%edx),%eax
10d0d0: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1)
information->inactive -= information->allocation_size;
10d0d7: 8b 42 14 mov 0x14(%edx),%eax
10d0da: 66 29 42 2c sub %ax,0x2c(%edx)
return;
10d0de: 83 c4 10 add $0x10,%esp
}
index_base += information->allocation_size;
}
}
10d0e1: 8d 65 f4 lea -0xc(%ebp),%esp
10d0e4: 5b pop %ebx
10d0e5: 5e pop %esi
10d0e6: 5f pop %edi
10d0e7: c9 leave
10d0e8: c3 ret
0010d524 <_POSIX_Absolute_timeout_to_ticks>:
*/
POSIX_Absolute_timeout_conversion_results_t _POSIX_Absolute_timeout_to_ticks(
const struct timespec *abstime,
Watchdog_Interval *ticks_out
)
{
10d524: 55 push %ebp
10d525: 89 e5 mov %esp,%ebp
10d527: 57 push %edi
10d528: 56 push %esi
10d529: 53 push %ebx
10d52a: 83 ec 38 sub $0x38,%esp
10d52d: 8b 5d 08 mov 0x8(%ebp),%ebx
10d530: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Make sure there is always a value returned.
*/
*ticks_out = 0;
10d533: c7 06 00 00 00 00 movl $0x0,(%esi)
/*
* Is the absolute time even valid?
*/
if ( !_Timespec_Is_valid(abstime) )
10d539: 53 push %ebx
10d53a: e8 c1 3d 00 00 call 111300 <_Timespec_Is_valid>
10d53f: 83 c4 10 add $0x10,%esp
10d542: 84 c0 test %al,%al
10d544: 75 0a jne 10d550 <_POSIX_Absolute_timeout_to_ticks+0x2c>
return POSIX_ABSOLUTE_TIMEOUT_INVALID;
10d546: 31 c0 xor %eax,%eax
/*
* This is the case we were expecting and it took this long to
* get here.
*/
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE;
}
10d548: 8d 65 f4 lea -0xc(%ebp),%esp
10d54b: 5b pop %ebx
10d54c: 5e pop %esi
10d54d: 5f pop %edi
10d54e: c9 leave
10d54f: c3 ret
return POSIX_ABSOLUTE_TIMEOUT_INVALID;
/*
* Is the absolute time in the past?
*/
_TOD_Get( ¤t_time );
10d550: 83 ec 0c sub $0xc,%esp
10d553: 8d 7d e0 lea -0x20(%ebp),%edi
10d556: 57 push %edi
10d557: e8 84 1d 00 00 call 10f2e0 <_TOD_Get>
if ( _Timespec_Less_than( abstime, ¤t_time ) )
10d55c: 5a pop %edx
10d55d: 59 pop %ecx
10d55e: 57 push %edi
10d55f: 53 push %ebx
10d560: e8 c3 3d 00 00 call 111328 <_Timespec_Less_than>
10d565: 83 c4 10 add $0x10,%esp
10d568: 84 c0 test %al,%al
10d56a: 74 10 je 10d57c <_POSIX_Absolute_timeout_to_ticks+0x58>
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST;
10d56c: b8 01 00 00 00 mov $0x1,%eax
/*
* This is the case we were expecting and it took this long to
* get here.
*/
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE;
}
10d571: 8d 65 f4 lea -0xc(%ebp),%esp
10d574: 5b pop %ebx
10d575: 5e pop %esi
10d576: 5f pop %edi
10d577: c9 leave
10d578: c3 ret
10d579: 8d 76 00 lea 0x0(%esi),%esi
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST;
/*
* How long until the requested absolute time?
*/
_Timespec_Subtract( ¤t_time, abstime, &difference );
10d57c: 50 push %eax
10d57d: 8d 45 d8 lea -0x28(%ebp),%eax
10d580: 50 push %eax
10d581: 53 push %ebx
10d582: 57 push %edi
10d583: 89 45 d4 mov %eax,-0x2c(%ebp)
10d586: e8 c1 3d 00 00 call 11134c <_Timespec_Subtract>
/*
* Internally the SuperCore uses ticks, so convert to them.
*/
*ticks_out = _Timespec_To_ticks( &difference );
10d58b: 8b 45 d4 mov -0x2c(%ebp),%eax
10d58e: 89 04 24 mov %eax,(%esp)
10d591: e8 f6 3d 00 00 call 11138c <_Timespec_To_ticks>
10d596: 89 06 mov %eax,(%esi)
/*
* If the difference was 0, then the future is now. It is so bright
* we better wear shades.
*/
if ( !*ticks_out )
10d598: 83 c4 10 add $0x10,%esp
return POSIX_ABSOLUTE_TIMEOUT_IS_NOW;
10d59b: 83 f8 01 cmp $0x1,%eax
10d59e: 19 c0 sbb %eax,%eax
10d5a0: 83 c0 03 add $0x3,%eax
/*
* This is the case we were expecting and it took this long to
* get here.
*/
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE;
}
10d5a3: 8d 65 f4 lea -0xc(%ebp),%esp
10d5a6: 5b pop %ebx
10d5a7: 5e pop %esi
10d5a8: 5f pop %edi
10d5a9: c9 leave
10d5aa: c3 ret
0010c0cc <_POSIX_Condition_variables_Get>:
POSIX_Condition_variables_Control *_POSIX_Condition_variables_Get (
pthread_cond_t *cond,
Objects_Locations *location
)
{
10c0cc: 55 push %ebp
10c0cd: 89 e5 mov %esp,%ebp
10c0cf: 56 push %esi
10c0d0: 53 push %ebx
10c0d1: 8b 5d 08 mov 0x8(%ebp),%ebx
10c0d4: 8b 75 0c mov 0xc(%ebp),%esi
int status;
if ( !cond ) {
10c0d7: 85 db test %ebx,%ebx
10c0d9: 74 39 je 10c114 <_POSIX_Condition_variables_Get+0x48>
*location = OBJECTS_ERROR;
return (POSIX_Condition_variables_Control *) 0;
}
if ( *cond == PTHREAD_COND_INITIALIZER ) {
10c0db: 8b 03 mov (%ebx),%eax
10c0dd: 83 f8 ff cmp $0xffffffff,%eax
10c0e0: 74 1a je 10c0fc <_POSIX_Condition_variables_Get+0x30>
}
/*
* Now call Objects_Get()
*/
return (POSIX_Condition_variables_Control *)_Objects_Get(
10c0e2: 52 push %edx
10c0e3: 56 push %esi
10c0e4: 50 push %eax
10c0e5: 68 40 9a 12 00 push $0x129a40
10c0ea: e8 75 2b 00 00 call 10ec64 <_Objects_Get>
10c0ef: 83 c4 10 add $0x10,%esp
&_POSIX_Condition_variables_Information,
(Objects_Id) *cond,
location
);
}
10c0f2: 8d 65 f8 lea -0x8(%ebp),%esp
10c0f5: 5b pop %ebx
10c0f6: 5e pop %esi
10c0f7: c9 leave
10c0f8: c3 ret
10c0f9: 8d 76 00 lea 0x0(%esi),%esi
if ( *cond == PTHREAD_COND_INITIALIZER ) {
/*
* Do an "auto-create" here.
*/
status = pthread_cond_init( cond, 0 );
10c0fc: 83 ec 08 sub $0x8,%esp
10c0ff: 6a 00 push $0x0
10c101: 53 push %ebx
10c102: e8 19 00 00 00 call 10c120 <pthread_cond_init>
if ( status ) {
10c107: 83 c4 10 add $0x10,%esp
10c10a: 85 c0 test %eax,%eax
10c10c: 75 06 jne 10c114 <_POSIX_Condition_variables_Get+0x48>
10c10e: 8b 03 mov (%ebx),%eax
10c110: eb d0 jmp 10c0e2 <_POSIX_Condition_variables_Get+0x16>
10c112: 66 90 xchg %ax,%ax
*location = OBJECTS_ERROR;
10c114: c7 06 01 00 00 00 movl $0x1,(%esi)
return (POSIX_Condition_variables_Control *) 0;
10c11a: 31 c0 xor %eax,%eax
10c11c: eb d4 jmp 10c0f2 <_POSIX_Condition_variables_Get+0x26>
0010c1e8 <_POSIX_Condition_variables_Signal_support>:
int _POSIX_Condition_variables_Signal_support(
pthread_cond_t *cond,
bool is_broadcast
)
{
10c1e8: 55 push %ebp
10c1e9: 89 e5 mov %esp,%ebp
10c1eb: 57 push %edi
10c1ec: 56 push %esi
10c1ed: 53 push %ebx
10c1ee: 83 ec 24 sub $0x24,%esp
10c1f1: 8a 5d 0c mov 0xc(%ebp),%bl
register POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
Thread_Control *the_thread;
the_cond = _POSIX_Condition_variables_Get( cond, &location );
10c1f4: 8d 45 e4 lea -0x1c(%ebp),%eax
10c1f7: 50 push %eax
10c1f8: ff 75 08 pushl 0x8(%ebp)
10c1fb: e8 cc fe ff ff call 10c0cc <_POSIX_Condition_variables_Get>
10c200: 89 c7 mov %eax,%edi
switch ( location ) {
10c202: 83 c4 10 add $0x10,%esp
10c205: 8b 45 e4 mov -0x1c(%ebp),%eax
10c208: 85 c0 test %eax,%eax
10c20a: 74 10 je 10c21c <_POSIX_Condition_variables_Signal_support+0x34>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10c20c: b8 16 00 00 00 mov $0x16,%eax
}
10c211: 8d 65 f4 lea -0xc(%ebp),%esp
10c214: 5b pop %ebx
10c215: 5e pop %esi
10c216: 5f pop %edi
10c217: c9 leave
10c218: c3 ret
10c219: 8d 76 00 lea 0x0(%esi),%esi
10c21c: 8d 77 18 lea 0x18(%edi),%esi
10c21f: eb 0b jmp 10c22c <_POSIX_Condition_variables_Signal_support+0x44>
10c221: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_LOCAL:
do {
the_thread = _Thread_queue_Dequeue( &the_cond->Wait_queue );
if ( !the_thread )
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
} while ( is_broadcast && the_thread );
10c224: 84 db test %bl,%bl
10c226: 74 20 je 10c248 <_POSIX_Condition_variables_Signal_support+0x60>
10c228: 85 c0 test %eax,%eax
10c22a: 74 1c je 10c248 <_POSIX_Condition_variables_Signal_support+0x60>
the_cond = _POSIX_Condition_variables_Get( cond, &location );
switch ( location ) {
case OBJECTS_LOCAL:
do {
the_thread = _Thread_queue_Dequeue( &the_cond->Wait_queue );
10c22c: 83 ec 0c sub $0xc,%esp
10c22f: 56 push %esi
10c230: e8 23 39 00 00 call 10fb58 <_Thread_queue_Dequeue>
if ( !the_thread )
10c235: 83 c4 10 add $0x10,%esp
10c238: 85 c0 test %eax,%eax
10c23a: 75 e8 jne 10c224 <_POSIX_Condition_variables_Signal_support+0x3c>
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
10c23c: c7 47 14 00 00 00 00 movl $0x0,0x14(%edi)
} while ( is_broadcast && the_thread );
10c243: 84 db test %bl,%bl
10c245: 75 e1 jne 10c228 <_POSIX_Condition_variables_Signal_support+0x40>
10c247: 90 nop
_Thread_Enable_dispatch();
10c248: e8 8f 35 00 00 call 10f7dc <_Thread_Enable_dispatch>
return 0;
10c24d: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c24f: 8d 65 f4 lea -0xc(%ebp),%esp
10c252: 5b pop %ebx
10c253: 5e pop %esi
10c254: 5f pop %edi
10c255: c9 leave
10c256: c3 ret
0010c2b0 <_POSIX_Condition_variables_Wait_support>:
pthread_cond_t *cond,
pthread_mutex_t *mutex,
Watchdog_Interval timeout,
bool already_timedout
)
{
10c2b0: 55 push %ebp
10c2b1: 89 e5 mov %esp,%ebp
10c2b3: 57 push %edi
10c2b4: 56 push %esi
10c2b5: 53 push %ebx
10c2b6: 83 ec 34 sub $0x34,%esp
10c2b9: 8b 7d 08 mov 0x8(%ebp),%edi
10c2bc: 8b 5d 0c mov 0xc(%ebp),%ebx
10c2bf: 8a 45 14 mov 0x14(%ebp),%al
10c2c2: 88 45 d7 mov %al,-0x29(%ebp)
register POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
int status;
int mutex_status;
if ( !_POSIX_Mutex_Get( mutex, &location ) ) {
10c2c5: 8d 75 e4 lea -0x1c(%ebp),%esi
10c2c8: 56 push %esi
10c2c9: 53 push %ebx
10c2ca: e8 59 01 00 00 call 10c428 <_POSIX_Mutex_Get>
10c2cf: 83 c4 10 add $0x10,%esp
10c2d2: 85 c0 test %eax,%eax
10c2d4: 74 21 je 10c2f7 <_POSIX_Condition_variables_Wait_support+0x47>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10c2d6: a1 90 95 12 00 mov 0x129590,%eax
10c2db: 48 dec %eax
10c2dc: a3 90 95 12 00 mov %eax,0x129590
return EINVAL;
}
_Thread_Unnest_dispatch();
the_cond = _POSIX_Condition_variables_Get( cond, &location );
10c2e1: 83 ec 08 sub $0x8,%esp
10c2e4: 56 push %esi
10c2e5: 57 push %edi
10c2e6: e8 e1 fd ff ff call 10c0cc <_POSIX_Condition_variables_Get>
10c2eb: 89 c6 mov %eax,%esi
switch ( location ) {
10c2ed: 83 c4 10 add $0x10,%esp
10c2f0: 8b 55 e4 mov -0x1c(%ebp),%edx
10c2f3: 85 d2 test %edx,%edx
10c2f5: 74 11 je 10c308 <_POSIX_Condition_variables_Wait_support+0x58>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10c2f7: be 16 00 00 00 mov $0x16,%esi
}
10c2fc: 89 f0 mov %esi,%eax
10c2fe: 8d 65 f4 lea -0xc(%ebp),%esp
10c301: 5b pop %ebx
10c302: 5e pop %esi
10c303: 5f pop %edi
10c304: c9 leave
10c305: c3 ret
10c306: 66 90 xchg %ax,%ax
the_cond = _POSIX_Condition_variables_Get( cond, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) {
10c308: 8b 40 14 mov 0x14(%eax),%eax
10c30b: 85 c0 test %eax,%eax
10c30d: 74 19 je 10c328 <_POSIX_Condition_variables_Wait_support+0x78>
10c30f: 3b 03 cmp (%ebx),%eax
10c311: 74 15 je 10c328 <_POSIX_Condition_variables_Wait_support+0x78>
_Thread_Enable_dispatch();
10c313: e8 c4 34 00 00 call 10f7dc <_Thread_Enable_dispatch>
return EINVAL;
10c318: be 16 00 00 00 mov $0x16,%esi
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c31d: 89 f0 mov %esi,%eax
10c31f: 8d 65 f4 lea -0xc(%ebp),%esp
10c322: 5b pop %ebx
10c323: 5e pop %esi
10c324: 5f pop %edi
10c325: c9 leave
10c326: c3 ret
10c327: 90 nop
if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) {
_Thread_Enable_dispatch();
return EINVAL;
}
(void) pthread_mutex_unlock( mutex );
10c328: 83 ec 0c sub $0xc,%esp
10c32b: 53 push %ebx
10c32c: e8 73 03 00 00 call 10c6a4 <pthread_mutex_unlock>
_Thread_Enable_dispatch();
return EINVAL;
}
*/
if ( !already_timedout ) {
10c331: 83 c4 10 add $0x10,%esp
10c334: 80 7d d7 00 cmpb $0x0,-0x29(%ebp)
10c338: 75 4e jne 10c388 <_POSIX_Condition_variables_Wait_support+0xd8>
the_cond->Mutex = *mutex;
10c33a: 8b 03 mov (%ebx),%eax
10c33c: 89 46 14 mov %eax,0x14(%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;
10c33f: c7 46 48 01 00 00 00 movl $0x1,0x48(%esi)
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
10c346: a1 38 9b 12 00 mov 0x129b38,%eax
10c34b: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
10c352: 83 c6 18 add $0x18,%esi
10c355: 89 70 44 mov %esi,0x44(%eax)
_Thread_Executing->Wait.id = *cond;
10c358: 8b 17 mov (%edi),%edx
10c35a: 89 50 20 mov %edx,0x20(%eax)
_Thread_queue_Enqueue( &the_cond->Wait_queue, timeout );
10c35d: 50 push %eax
10c35e: 68 fc ff 10 00 push $0x10fffc
10c363: ff 75 10 pushl 0x10(%ebp)
10c366: 56 push %esi
10c367: e8 14 39 00 00 call 10fc80 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10c36c: e8 6b 34 00 00 call 10f7dc <_Thread_Enable_dispatch>
* a POSIX signal, then pthread_cond_wait returns spuriously,
* according to the POSIX standard. It means that pthread_cond_wait
* returns a success status, except for the fact that it was not
* woken up a pthread_cond_signal or a pthread_cond_broadcast.
*/
status = _Thread_Executing->Wait.return_code;
10c371: a1 38 9b 12 00 mov 0x129b38,%eax
10c376: 8b 70 34 mov 0x34(%eax),%esi
if ( status == EINTR )
10c379: 83 c4 10 add $0x10,%esp
10c37c: 83 fe 04 cmp $0x4,%esi
10c37f: 75 11 jne 10c392 <_POSIX_Condition_variables_Wait_support+0xe2>
status = 0;
10c381: 31 f6 xor %esi,%esi
10c383: eb 0d jmp 10c392 <_POSIX_Condition_variables_Wait_support+0xe2>
10c385: 8d 76 00 lea 0x0(%esi),%esi
} else {
_Thread_Enable_dispatch();
10c388: e8 4f 34 00 00 call 10f7dc <_Thread_Enable_dispatch>
status = ETIMEDOUT;
10c38d: be 74 00 00 00 mov $0x74,%esi
/*
* When we get here the dispatch disable level is 0.
*/
mutex_status = pthread_mutex_lock( mutex );
10c392: 83 ec 0c sub $0xc,%esp
10c395: 53 push %ebx
10c396: e8 81 02 00 00 call 10c61c <pthread_mutex_lock>
if ( mutex_status )
10c39b: 83 c4 10 add $0x10,%esp
10c39e: 85 c0 test %eax,%eax
10c3a0: 0f 85 51 ff ff ff jne 10c2f7 <_POSIX_Condition_variables_Wait_support+0x47>
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c3a6: 89 f0 mov %esi,%eax
10c3a8: 8d 65 f4 lea -0xc(%ebp),%esp
10c3ab: 5b pop %ebx
10c3ac: 5e pop %esi
10c3ad: 5f pop %edi
10c3ae: c9 leave
10c3af: c3 ret
001163a8 <_POSIX_Message_queue_Create_support>:
const char *name_arg,
int pshared,
struct mq_attr *attr_ptr,
POSIX_Message_queue_Control **message_queue
)
{
1163a8: 55 push %ebp
1163a9: 89 e5 mov %esp,%ebp
1163ab: 57 push %edi
1163ac: 56 push %esi
1163ad: 53 push %ebx
1163ae: 83 ec 24 sub $0x24,%esp
1163b1: 8b 5d 10 mov 0x10(%ebp),%ebx
CORE_message_queue_Attributes *the_mq_attr;
struct mq_attr attr;
char *name;
size_t n;
n = strnlen( name_arg, NAME_MAX );
1163b4: 68 ff 00 00 00 push $0xff
1163b9: ff 75 08 pushl 0x8(%ebp)
1163bc: e8 d7 4b 00 00 call 11af98 <strnlen>
1163c1: 89 c6 mov %eax,%esi
1163c3: a1 f0 0e 13 00 mov 0x130ef0,%eax
1163c8: 40 inc %eax
1163c9: a3 f0 0e 13 00 mov %eax,0x130ef0
* There is no real basis for the default values. They will work
* but were not compared against any existing implementation for
* compatibility. See README.mqueue for an example program we
* think will print out the defaults. Report anything you find with it.
*/
if ( attr_ptr == NULL ) {
1163ce: 83 c4 10 add $0x10,%esp
1163d1: 85 db test %ebx,%ebx
1163d3: 0f 84 b7 00 00 00 je 116490 <_POSIX_Message_queue_Create_support+0xe8>
attr.mq_maxmsg = 10;
attr.mq_msgsize = 16;
} else {
if ( attr_ptr->mq_maxmsg <= 0 ){
1163d9: 8b 7b 04 mov 0x4(%ebx),%edi
1163dc: 85 ff test %edi,%edi
1163de: 0f 8e f0 00 00 00 jle 1164d4 <_POSIX_Message_queue_Create_support+0x12c>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( attr_ptr->mq_msgsize <= 0 ){
1163e4: 8b 5b 08 mov 0x8(%ebx),%ebx
1163e7: 89 5d e4 mov %ebx,-0x1c(%ebp)
1163ea: 85 db test %ebx,%ebx
1163ec: 0f 8e e2 00 00 00 jle 1164d4 <_POSIX_Message_queue_Create_support+0x12c>
RTEMS_INLINE_ROUTINE
POSIX_Message_queue_Control *_POSIX_Message_queue_Allocate( void )
{
return (POSIX_Message_queue_Control *)
_Objects_Allocate( &_POSIX_Message_queue_Information );
1163f2: 83 ec 0c sub $0xc,%esp
1163f5: 68 80 12 13 00 push $0x131280
1163fa: e8 a5 c3 ff ff call 1127a4 <_Objects_Allocate>
1163ff: 89 c3 mov %eax,%ebx
attr = *attr_ptr;
}
the_mq = _POSIX_Message_queue_Allocate();
if ( !the_mq ) {
116401: 83 c4 10 add $0x10,%esp
116404: 85 c0 test %eax,%eax
116406: 0f 84 0a 01 00 00 je 116516 <_POSIX_Message_queue_Create_support+0x16e>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
the_mq->process_shared = pshared;
11640c: 8b 45 0c mov 0xc(%ebp),%eax
11640f: 89 43 10 mov %eax,0x10(%ebx)
the_mq->named = true;
116412: c6 43 14 01 movb $0x1,0x14(%ebx)
the_mq->open_count = 1;
116416: c7 43 18 01 00 00 00 movl $0x1,0x18(%ebx)
the_mq->linked = true;
11641d: c6 43 15 01 movb $0x1,0x15(%ebx)
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
name = _Workspace_Allocate(n+1);
116421: 8d 56 01 lea 0x1(%esi),%edx
116424: 83 ec 0c sub $0xc,%esp
116427: 52 push %edx
116428: 89 55 e0 mov %edx,-0x20(%ebp)
11642b: e8 d4 e4 ff ff call 114904 <_Workspace_Allocate>
116430: 89 c6 mov %eax,%esi
if (!name) {
116432: 83 c4 10 add $0x10,%esp
116435: 85 c0 test %eax,%eax
116437: 8b 55 e0 mov -0x20(%ebp),%edx
11643a: 0f 84 ab 00 00 00 je 1164eb <_POSIX_Message_queue_Create_support+0x143>
_POSIX_Message_queue_Free( the_mq );
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOMEM );
}
strncpy( name, name_arg, n+1 );
116440: 50 push %eax
116441: 52 push %edx
116442: ff 75 08 pushl 0x8(%ebp)
116445: 56 push %esi
116446: e8 d1 4a 00 00 call 11af1c <strncpy>
*
* Joel: Cite POSIX or OpenGroup on above statement so we can determine
* if it is a real requirement.
*/
the_mq_attr = &the_mq->Message_queue.Attributes;
the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
11644b: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
if ( !_CORE_message_queue_Initialize(
116452: ff 75 e4 pushl -0x1c(%ebp)
116455: 57 push %edi
* current scheduling policy.
*
* Joel: Cite POSIX or OpenGroup on above statement so we can determine
* if it is a real requirement.
*/
the_mq_attr = &the_mq->Message_queue.Attributes;
116456: 8d 43 5c lea 0x5c(%ebx),%eax
the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
if ( !_CORE_message_queue_Initialize(
116459: 50 push %eax
11645a: 8d 43 1c lea 0x1c(%ebx),%eax
11645d: 50 push %eax
11645e: e8 25 0f 00 00 call 117388 <_CORE_message_queue_Initialize>
116463: 83 c4 20 add $0x20,%esp
116466: 84 c0 test %al,%al
116468: 74 3a je 1164a4 <_POSIX_Message_queue_Create_support+0xfc>
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
11646a: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
11646e: a1 9c 12 13 00 mov 0x13129c,%eax
116473: 89 1c 90 mov %ebx,(%eax,%edx,4)
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
116476: 89 73 0c mov %esi,0xc(%ebx)
&_POSIX_Message_queue_Information,
&the_mq->Object,
name
);
*message_queue = the_mq;
116479: 8b 45 14 mov 0x14(%ebp),%eax
11647c: 89 18 mov %ebx,(%eax)
_Thread_Enable_dispatch();
11647e: e8 cd d3 ff ff call 113850 <_Thread_Enable_dispatch>
return 0;
116483: 31 c0 xor %eax,%eax
}
116485: 8d 65 f4 lea -0xc(%ebp),%esp
116488: 5b pop %ebx
116489: 5e pop %esi
11648a: 5f pop %edi
11648b: c9 leave
11648c: c3 ret
11648d: 8d 76 00 lea 0x0(%esi),%esi
* compatibility. See README.mqueue for an example program we
* think will print out the defaults. Report anything you find with it.
*/
if ( attr_ptr == NULL ) {
attr.mq_maxmsg = 10;
attr.mq_msgsize = 16;
116490: c7 45 e4 10 00 00 00 movl $0x10,-0x1c(%ebp)
* but were not compared against any existing implementation for
* compatibility. See README.mqueue for an example program we
* think will print out the defaults. Report anything you find with it.
*/
if ( attr_ptr == NULL ) {
attr.mq_maxmsg = 10;
116497: bf 0a 00 00 00 mov $0xa,%edi
11649c: e9 51 ff ff ff jmp 1163f2 <_POSIX_Message_queue_Create_support+0x4a>
1164a1: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free (
POSIX_Message_queue_Control *the_mq
)
{
_Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object );
1164a4: 83 ec 08 sub $0x8,%esp
1164a7: 53 push %ebx
1164a8: 68 80 12 13 00 push $0x131280
1164ad: e8 66 c6 ff ff call 112b18 <_Objects_Free>
attr.mq_maxmsg,
attr.mq_msgsize
) ) {
_POSIX_Message_queue_Free( the_mq );
_Workspace_Free(name);
1164b2: 89 34 24 mov %esi,(%esp)
1164b5: e8 66 e4 ff ff call 114920 <_Workspace_Free>
_Thread_Enable_dispatch();
1164ba: e8 91 d3 ff ff call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSPC );
1164bf: e8 50 33 00 00 call 119814 <__errno>
1164c4: c7 00 1c 00 00 00 movl $0x1c,(%eax)
1164ca: 83 c4 10 add $0x10,%esp
1164cd: b8 ff ff ff ff mov $0xffffffff,%eax
1164d2: eb b1 jmp 116485 <_POSIX_Message_queue_Create_support+0xdd>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( attr_ptr->mq_msgsize <= 0 ){
_Thread_Enable_dispatch();
1164d4: e8 77 d3 ff ff call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EINVAL );
1164d9: e8 36 33 00 00 call 119814 <__errno>
1164de: c7 00 16 00 00 00 movl $0x16,(%eax)
1164e4: b8 ff ff ff ff mov $0xffffffff,%eax
1164e9: eb 9a jmp 116485 <_POSIX_Message_queue_Create_support+0xdd>
1164eb: 83 ec 08 sub $0x8,%esp
1164ee: 53 push %ebx
1164ef: 68 80 12 13 00 push $0x131280
1164f4: e8 1f c6 ff ff call 112b18 <_Objects_Free>
* dynamically constructed.
*/
name = _Workspace_Allocate(n+1);
if (!name) {
_POSIX_Message_queue_Free( the_mq );
_Thread_Enable_dispatch();
1164f9: e8 52 d3 ff ff call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOMEM );
1164fe: e8 11 33 00 00 call 119814 <__errno>
116503: c7 00 0c 00 00 00 movl $0xc,(%eax)
116509: 83 c4 10 add $0x10,%esp
11650c: b8 ff ff ff ff mov $0xffffffff,%eax
116511: e9 6f ff ff ff jmp 116485 <_POSIX_Message_queue_Create_support+0xdd>
attr = *attr_ptr;
}
the_mq = _POSIX_Message_queue_Allocate();
if ( !the_mq ) {
_Thread_Enable_dispatch();
116516: e8 35 d3 ff ff call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENFILE );
11651b: e8 f4 32 00 00 call 119814 <__errno>
116520: c7 00 17 00 00 00 movl $0x17,(%eax)
116526: b8 ff ff ff ff mov $0xffffffff,%eax
11652b: e9 55 ff ff ff jmp 116485 <_POSIX_Message_queue_Create_support+0xdd>
00116530 <_POSIX_Message_queue_Name_to_id>:
*/
int _POSIX_Message_queue_Name_to_id(
const char *name,
Objects_Id *id
)
{
116530: 55 push %ebp
116531: 89 e5 mov %esp,%ebp
116533: 53 push %ebx
116534: 83 ec 14 sub $0x14,%esp
116537: 8b 5d 08 mov 0x8(%ebp),%ebx
Objects_Name_or_id_lookup_errors status;
Objects_Id the_id;
if ( !name )
11653a: 85 db test %ebx,%ebx
11653c: 74 05 je 116543 <_POSIX_Message_queue_Name_to_id+0x13>
return EINVAL;
if ( !name[0] )
11653e: 80 3b 00 cmpb $0x0,(%ebx)
116541: 75 0d jne 116550 <_POSIX_Message_queue_Name_to_id+0x20>
return EINVAL;
116543: b8 16 00 00 00 mov $0x16,%eax
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
return ENOENT;
}
116548: 8b 5d fc mov -0x4(%ebp),%ebx
11654b: c9 leave
11654c: c3 ret
11654d: 8d 76 00 lea 0x0(%esi),%esi
return EINVAL;
if ( !name[0] )
return EINVAL;
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
116550: 83 ec 08 sub $0x8,%esp
116553: 68 ff 00 00 00 push $0xff
116558: 53 push %ebx
116559: e8 3a 4a 00 00 call 11af98 <strnlen>
11655e: 83 c4 10 add $0x10,%esp
116561: 3d fe 00 00 00 cmp $0xfe,%eax
116566: 76 0c jbe 116574 <_POSIX_Message_queue_Name_to_id+0x44>
return ENAMETOOLONG;
116568: b8 5b 00 00 00 mov $0x5b,%eax
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
return ENOENT;
}
11656d: 8b 5d fc mov -0x4(%ebp),%ebx
116570: c9 leave
116571: c3 ret
116572: 66 90 xchg %ax,%ax
return EINVAL;
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
return ENAMETOOLONG;
status = _Objects_Name_to_id_string(
116574: 50 push %eax
116575: 8d 45 f4 lea -0xc(%ebp),%eax
116578: 50 push %eax
116579: 53 push %ebx
11657a: 68 80 12 13 00 push $0x131280
11657f: e8 10 14 00 00 call 117994 <_Objects_Name_to_id_string>
&_POSIX_Message_queue_Information,
name,
&the_id
);
*id = the_id;
116584: 8b 4d f4 mov -0xc(%ebp),%ecx
116587: 8b 55 0c mov 0xc(%ebp),%edx
11658a: 89 0a mov %ecx,(%edx)
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
11658c: 83 c4 10 add $0x10,%esp
return 0;
11658f: 83 f8 01 cmp $0x1,%eax
116592: 19 c0 sbb %eax,%eax
116594: f7 d0 not %eax
116596: 83 e0 02 and $0x2,%eax
return ENOENT;
}
116599: 8b 5d fc mov -0x4(%ebp),%ebx
11659c: c9 leave
11659d: c3 ret
0010fce8 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
10fce8: 55 push %ebp
10fce9: 89 e5 mov %esp,%ebp
10fceb: 53 push %ebx
10fcec: 83 ec 28 sub $0x28,%esp
10fcef: 8b 5d 08 mov 0x8(%ebp),%ebx
10fcf2: 8a 45 18 mov 0x18(%ebp),%al
10fcf5: 88 45 e7 mov %al,-0x19(%ebp)
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
size_t length_out;
bool do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
10fcf8: 8d 45 f4 lea -0xc(%ebp),%eax
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
10fcfb: 50 push %eax
10fcfc: 53 push %ebx
10fcfd: 68 20 14 13 00 push $0x131420
10fd02: e8 51 2f 00 00 call 112c58 <_Objects_Get>
switch ( location ) {
10fd07: 83 c4 10 add $0x10,%esp
10fd0a: 8b 55 f4 mov -0xc(%ebp),%edx
10fd0d: 85 d2 test %edx,%edx
10fd0f: 74 17 je 10fd28 <_POSIX_Message_queue_Receive_support+0x40>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
10fd11: e8 fe 9a 00 00 call 119814 <__errno>
10fd16: c7 00 09 00 00 00 movl $0x9,(%eax)
10fd1c: b8 ff ff ff ff mov $0xffffffff,%eax
}
10fd21: 8b 5d fc mov -0x4(%ebp),%ebx
10fd24: c9 leave
10fd25: c3 ret
10fd26: 66 90 xchg %ax,%ax
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
10fd28: 8b 50 14 mov 0x14(%eax),%edx
10fd2b: 89 d1 mov %edx,%ecx
10fd2d: 83 e1 03 and $0x3,%ecx
10fd30: 49 dec %ecx
10fd31: 0f 84 af 00 00 00 je 10fde6 <_POSIX_Message_queue_Receive_support+0xfe>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
10fd37: 8b 40 10 mov 0x10(%eax),%eax
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
10fd3a: 8b 4d 10 mov 0x10(%ebp),%ecx
10fd3d: 39 48 68 cmp %ecx,0x68(%eax)
10fd40: 77 62 ja 10fda4 <_POSIX_Message_queue_Receive_support+0xbc>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
10fd42: c7 45 f0 ff ff ff ff movl $0xffffffff,-0x10(%ebp)
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
10fd49: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
10fd4d: 75 45 jne 10fd94 <_POSIX_Message_queue_Receive_support+0xac><== ALWAYS TAKEN
10fd4f: 31 d2 xor %edx,%edx <== NOT EXECUTED
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
10fd51: 83 ec 08 sub $0x8,%esp
10fd54: ff 75 1c pushl 0x1c(%ebp)
10fd57: 52 push %edx
10fd58: 8d 55 f0 lea -0x10(%ebp),%edx
10fd5b: 52 push %edx
10fd5c: ff 75 0c pushl 0xc(%ebp)
10fd5f: 53 push %ebx
10fd60: 83 c0 1c add $0x1c,%eax
10fd63: 50 push %eax
10fd64: e8 9f 1f 00 00 call 111d08 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
10fd69: 83 c4 20 add $0x20,%esp
10fd6c: e8 df 3a 00 00 call 113850 <_Thread_Enable_dispatch>
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
10fd71: 8b 15 98 14 13 00 mov 0x131498,%edx
RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core(
CORE_message_queue_Submit_types priority
)
{
/* absolute value without a library dependency */
return ((priority >= 0) ? priority : -priority);
10fd77: 8b 42 24 mov 0x24(%edx),%eax
10fd7a: 85 c0 test %eax,%eax
10fd7c: 78 22 js 10fda0 <_POSIX_Message_queue_Receive_support+0xb8>
do_wait,
timeout
);
_Thread_Enable_dispatch();
*msg_prio =
10fd7e: 8b 4d 14 mov 0x14(%ebp),%ecx
10fd81: 89 01 mov %eax,(%ecx)
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
if ( !_Thread_Executing->Wait.return_code )
10fd83: 8b 42 34 mov 0x34(%edx),%eax
10fd86: 85 c0 test %eax,%eax
10fd88: 75 36 jne 10fdc0 <_POSIX_Message_queue_Receive_support+0xd8>
return length_out;
10fd8a: 8b 45 f0 mov -0x10(%ebp),%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
}
10fd8d: 8b 5d fc mov -0x4(%ebp),%ebx
10fd90: c9 leave
10fd91: c3 ret
10fd92: 66 90 xchg %ax,%ax
length_out = -1;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
10fd94: 80 e6 40 and $0x40,%dh
10fd97: 0f 94 c2 sete %dl
10fd9a: 0f b6 d2 movzbl %dl,%edx
10fd9d: eb b2 jmp 10fd51 <_POSIX_Message_queue_Receive_support+0x69>
10fd9f: 90 nop
10fda0: f7 d8 neg %eax
10fda2: eb da jmp 10fd7e <_POSIX_Message_queue_Receive_support+0x96>
}
the_mq = the_mq_fd->Queue;
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
_Thread_Enable_dispatch();
10fda4: e8 a7 3a 00 00 call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
10fda9: e8 66 9a 00 00 call 119814 <__errno>
10fdae: c7 00 7a 00 00 00 movl $0x7a,(%eax)
10fdb4: b8 ff ff ff ff mov $0xffffffff,%eax
10fdb9: e9 63 ff ff ff jmp 10fd21 <_POSIX_Message_queue_Receive_support+0x39>
10fdbe: 66 90 xchg %ax,%ax
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
if ( !_Thread_Executing->Wait.return_code )
return length_out;
rtems_set_errno_and_return_minus_one(
10fdc0: e8 4f 9a 00 00 call 119814 <__errno>
10fdc5: 89 c3 mov %eax,%ebx
10fdc7: 83 ec 0c sub $0xc,%esp
10fdca: a1 98 14 13 00 mov 0x131498,%eax
10fdcf: ff 70 34 pushl 0x34(%eax)
10fdd2: e8 29 02 00 00 call 110000 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
10fdd7: 89 03 mov %eax,(%ebx)
10fdd9: 83 c4 10 add $0x10,%esp
10fddc: b8 ff ff ff ff mov $0xffffffff,%eax
10fde1: e9 3b ff ff ff jmp 10fd21 <_POSIX_Message_queue_Receive_support+0x39>
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
_Thread_Enable_dispatch();
10fde6: e8 65 3a 00 00 call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EBADF );
10fdeb: e8 24 9a 00 00 call 119814 <__errno>
10fdf0: c7 00 09 00 00 00 movl $0x9,(%eax)
10fdf6: b8 ff ff ff ff mov $0xffffffff,%eax
10fdfb: e9 21 ff ff ff jmp 10fd21 <_POSIX_Message_queue_Receive_support+0x39>
0010fe20 <_POSIX_Message_queue_Send_support>:
size_t msg_len,
uint32_t msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
10fe20: 55 push %ebp
10fe21: 89 e5 mov %esp,%ebp
10fe23: 56 push %esi
10fe24: 53 push %ebx
10fe25: 83 ec 20 sub $0x20,%esp
10fe28: 8b 75 08 mov 0x8(%ebp),%esi
10fe2b: 8b 5d 14 mov 0x14(%ebp),%ebx
10fe2e: 8a 55 18 mov 0x18(%ebp),%dl
/*
* Validate the priority.
* XXX - Do not validate msg_prio is not less than 0.
*/
if ( msg_prio > MQ_PRIO_MAX )
10fe31: 83 fb 20 cmp $0x20,%ebx
10fe34: 0f 87 92 00 00 00 ja 10fecc <_POSIX_Message_queue_Send_support+0xac>
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
10fe3a: 51 push %ecx
rtems_set_errno_and_return_minus_one( EINVAL );
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
10fe3b: 8d 45 f4 lea -0xc(%ebp),%eax
10fe3e: 50 push %eax
10fe3f: 56 push %esi
10fe40: 68 20 14 13 00 push $0x131420
10fe45: 88 55 e4 mov %dl,-0x1c(%ebp)
10fe48: e8 0b 2e 00 00 call 112c58 <_Objects_Get>
switch ( location ) {
10fe4d: 83 c4 10 add $0x10,%esp
10fe50: 8b 55 f4 mov -0xc(%ebp),%edx
10fe53: 85 d2 test %edx,%edx
10fe55: 8a 55 e4 mov -0x1c(%ebp),%dl
10fe58: 75 5e jne 10feb8 <_POSIX_Message_queue_Send_support+0x98>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) {
10fe5a: 8b 48 14 mov 0x14(%eax),%ecx
10fe5d: f6 c1 03 test $0x3,%cl
10fe60: 74 7e je 10fee0 <_POSIX_Message_queue_Send_support+0xc0>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
10fe62: 8b 40 10 mov 0x10(%eax),%eax
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
10fe65: 84 d2 test %dl,%dl
10fe67: 75 37 jne 10fea0 <_POSIX_Message_queue_Send_support+0x80>
10fe69: 31 d2 xor %edx,%edx
do_wait = wait;
/*
* Now perform the actual message receive
*/
msg_status = _CORE_message_queue_Submit(
10fe6b: ff 75 1c pushl 0x1c(%ebp)
10fe6e: 52 push %edx
RTEMS_INLINE_ROUTINE CORE_message_queue_Submit_types _POSIX_Message_queue_Priority_to_core(
unsigned int priority
)
{
return priority * -1;
10fe6f: f7 db neg %ebx
10fe71: 53 push %ebx
10fe72: 6a 00 push $0x0
10fe74: 56 push %esi
10fe75: ff 75 10 pushl 0x10(%ebp)
10fe78: ff 75 0c pushl 0xc(%ebp)
10fe7b: 83 c0 1c add $0x1c,%eax
10fe7e: 50 push %eax
10fe7f: e8 b0 1f 00 00 call 111e34 <_CORE_message_queue_Submit>
10fe84: 89 c3 mov %eax,%ebx
_POSIX_Message_queue_Priority_to_core( msg_prio ),
do_wait,
timeout /* no timeout */
);
_Thread_Enable_dispatch();
10fe86: 83 c4 20 add $0x20,%esp
10fe89: e8 c2 39 00 00 call 113850 <_Thread_Enable_dispatch>
* after it wakes up. The returned status is correct for
* non-blocking operations but if we blocked, then we need
* to look at the status in our TCB.
*/
if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT )
10fe8e: 83 fb 07 cmp $0x7,%ebx
10fe91: 74 19 je 10feac <_POSIX_Message_queue_Send_support+0x8c>
msg_status = _Thread_Executing->Wait.return_code;
if ( !msg_status )
10fe93: 85 db test %ebx,%ebx
10fe95: 75 61 jne 10fef8 <_POSIX_Message_queue_Send_support+0xd8>
return msg_status;
10fe97: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
}
10fe99: 8d 65 f8 lea -0x8(%ebp),%esp
10fe9c: 5b pop %ebx
10fe9d: 5e pop %esi
10fe9e: c9 leave
10fe9f: c3 ret
the_mq = the_mq_fd->Queue;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
10fea0: 31 d2 xor %edx,%edx
10fea2: f6 c5 40 test $0x40,%ch
10fea5: 0f 94 c2 sete %dl
10fea8: eb c1 jmp 10fe6b <_POSIX_Message_queue_Send_support+0x4b>
10feaa: 66 90 xchg %ax,%ax
* non-blocking operations but if we blocked, then we need
* to look at the status in our TCB.
*/
if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT )
msg_status = _Thread_Executing->Wait.return_code;
10feac: a1 98 14 13 00 mov 0x131498,%eax
10feb1: 8b 58 34 mov 0x34(%eax),%ebx
10feb4: eb dd jmp 10fe93 <_POSIX_Message_queue_Send_support+0x73>
10feb6: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
10feb8: e8 57 99 00 00 call 119814 <__errno>
10febd: c7 00 09 00 00 00 movl $0x9,(%eax)
10fec3: b8 ff ff ff ff mov $0xffffffff,%eax
10fec8: eb cf jmp 10fe99 <_POSIX_Message_queue_Send_support+0x79>
10feca: 66 90 xchg %ax,%ax
* Validate the priority.
* XXX - Do not validate msg_prio is not less than 0.
*/
if ( msg_prio > MQ_PRIO_MAX )
rtems_set_errno_and_return_minus_one( EINVAL );
10fecc: e8 43 99 00 00 call 119814 <__errno>
10fed1: c7 00 16 00 00 00 movl $0x16,(%eax)
10fed7: b8 ff ff ff ff mov $0xffffffff,%eax
10fedc: eb bb jmp 10fe99 <_POSIX_Message_queue_Send_support+0x79>
10fede: 66 90 xchg %ax,%ax
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) {
_Thread_Enable_dispatch();
10fee0: e8 6b 39 00 00 call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EBADF );
10fee5: e8 2a 99 00 00 call 119814 <__errno>
10feea: c7 00 09 00 00 00 movl $0x9,(%eax)
10fef0: b8 ff ff ff ff mov $0xffffffff,%eax
10fef5: eb a2 jmp 10fe99 <_POSIX_Message_queue_Send_support+0x79>
10fef7: 90 nop
msg_status = _Thread_Executing->Wait.return_code;
if ( !msg_status )
return msg_status;
rtems_set_errno_and_return_minus_one(
10fef8: e8 17 99 00 00 call 119814 <__errno>
10fefd: 89 c6 mov %eax,%esi
10feff: 83 ec 0c sub $0xc,%esp
10ff02: 53 push %ebx
10ff03: e8 f8 00 00 00 call 110000 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
10ff08: 89 06 mov %eax,(%esi)
10ff0a: 83 c4 10 add $0x10,%esp
10ff0d: b8 ff ff ff ff mov $0xffffffff,%eax
10ff12: eb 85 jmp 10fe99 <_POSIX_Message_queue_Send_support+0x79>
0010d0f4 <_POSIX_Mutex_Get>:
POSIX_Mutex_Control *_POSIX_Mutex_Get (
pthread_mutex_t *mutex,
Objects_Locations *location
)
{
10d0f4: 55 push %ebp
10d0f5: 89 e5 mov %esp,%ebp
10d0f7: 56 push %esi
10d0f8: 53 push %ebx
10d0f9: 8b 5d 08 mov 0x8(%ebp),%ebx
10d0fc: 8b 75 0c mov 0xc(%ebp),%esi
___POSIX_Mutex_Get_support_error_check( mutex, location );
10d0ff: 85 db test %ebx,%ebx
10d101: 74 39 je 10d13c <_POSIX_Mutex_Get+0x48>
___POSIX_Mutex_Get_support_auto_initialization( mutex, location );
10d103: 8b 03 mov (%ebx),%eax
10d105: 83 f8 ff cmp $0xffffffff,%eax
10d108: 74 1a je 10d124 <_POSIX_Mutex_Get+0x30>
return (POSIX_Mutex_Control *)
_Objects_Get( &_POSIX_Mutex_Information, (Objects_Id) *mutex, location );
10d10a: 52 push %edx
10d10b: 56 push %esi
10d10c: 50 push %eax
10d10d: 68 c0 d0 12 00 push $0x12d0c0
10d112: e8 e1 2b 00 00 call 10fcf8 <_Objects_Get>
{
___POSIX_Mutex_Get_support_error_check( mutex, location );
___POSIX_Mutex_Get_support_auto_initialization( mutex, location );
return (POSIX_Mutex_Control *)
10d117: 83 c4 10 add $0x10,%esp
_Objects_Get( &_POSIX_Mutex_Information, (Objects_Id) *mutex, location );
}
10d11a: 8d 65 f8 lea -0x8(%ebp),%esp
10d11d: 5b pop %ebx
10d11e: 5e pop %esi
10d11f: c9 leave
10d120: c3 ret
10d121: 8d 76 00 lea 0x0(%esi),%esi
Objects_Locations *location
)
{
___POSIX_Mutex_Get_support_error_check( mutex, location );
___POSIX_Mutex_Get_support_auto_initialization( mutex, location );
10d124: 83 ec 08 sub $0x8,%esp
10d127: 6a 00 push $0x0
10d129: 53 push %ebx
10d12a: e8 b9 00 00 00 call 10d1e8 <pthread_mutex_init>
10d12f: 83 c4 10 add $0x10,%esp
10d132: 85 c0 test %eax,%eax
10d134: 75 06 jne 10d13c <_POSIX_Mutex_Get+0x48>
10d136: 8b 03 mov (%ebx),%eax
10d138: eb d0 jmp 10d10a <_POSIX_Mutex_Get+0x16>
10d13a: 66 90 xchg %ax,%ax
10d13c: c7 06 01 00 00 00 movl $0x1,(%esi)
10d142: 31 c0 xor %eax,%eax
10d144: eb d4 jmp 10d11a <_POSIX_Mutex_Get+0x26>
0010d148 <_POSIX_Mutex_Get_interrupt_disable>:
POSIX_Mutex_Control *_POSIX_Mutex_Get_interrupt_disable (
pthread_mutex_t *mutex,
Objects_Locations *location,
ISR_Level *level
)
{
10d148: 55 push %ebp
10d149: 89 e5 mov %esp,%ebp
10d14b: 56 push %esi
10d14c: 53 push %ebx
10d14d: 8b 5d 08 mov 0x8(%ebp),%ebx
10d150: 8b 75 0c mov 0xc(%ebp),%esi
___POSIX_Mutex_Get_support_error_check( mutex, location );
10d153: 85 db test %ebx,%ebx
10d155: 74 39 je 10d190 <_POSIX_Mutex_Get_interrupt_disable+0x48>
___POSIX_Mutex_Get_support_auto_initialization( mutex, location );
10d157: 8b 03 mov (%ebx),%eax
10d159: 83 f8 ff cmp $0xffffffff,%eax
10d15c: 74 1a je 10d178 <_POSIX_Mutex_Get_interrupt_disable+0x30>
return (POSIX_Mutex_Control *) _Objects_Get_isr_disable(
10d15e: ff 75 10 pushl 0x10(%ebp)
10d161: 56 push %esi
10d162: 50 push %eax
10d163: 68 c0 d0 12 00 push $0x12d0c0
10d168: e8 33 2b 00 00 call 10fca0 <_Objects_Get_isr_disable>
10d16d: 83 c4 10 add $0x10,%esp
&_POSIX_Mutex_Information,
(Objects_Id) *mutex,
location,
level
);
}
10d170: 8d 65 f8 lea -0x8(%ebp),%esp
10d173: 5b pop %ebx
10d174: 5e pop %esi
10d175: c9 leave
10d176: c3 ret
10d177: 90 nop
ISR_Level *level
)
{
___POSIX_Mutex_Get_support_error_check( mutex, location );
___POSIX_Mutex_Get_support_auto_initialization( mutex, location );
10d178: 83 ec 08 sub $0x8,%esp
10d17b: 6a 00 push $0x0
10d17d: 53 push %ebx
10d17e: e8 65 00 00 00 call 10d1e8 <pthread_mutex_init>
10d183: 83 c4 10 add $0x10,%esp
10d186: 85 c0 test %eax,%eax
10d188: 75 06 jne 10d190 <_POSIX_Mutex_Get_interrupt_disable+0x48>
10d18a: 8b 03 mov (%ebx),%eax
10d18c: eb d0 jmp 10d15e <_POSIX_Mutex_Get_interrupt_disable+0x16>
10d18e: 66 90 xchg %ax,%ax
10d190: c7 06 01 00 00 00 movl $0x1,(%esi)
10d196: 31 c0 xor %eax,%eax
10d198: eb d6 jmp 10d170 <_POSIX_Mutex_Get_interrupt_disable+0x28>
0010d348 <_POSIX_Mutex_Lock_support>:
int _POSIX_Mutex_Lock_support(
pthread_mutex_t *mutex,
bool blocking,
Watchdog_Interval timeout
)
{
10d348: 55 push %ebp
10d349: 89 e5 mov %esp,%ebp
10d34b: 53 push %ebx
10d34c: 83 ec 18 sub $0x18,%esp
10d34f: 8a 5d 0c mov 0xc(%ebp),%bl
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
ISR_Level level;
the_mutex = _POSIX_Mutex_Get_interrupt_disable( mutex, &location, &level );
10d352: 8d 45 f0 lea -0x10(%ebp),%eax
10d355: 50 push %eax
10d356: 8d 45 f4 lea -0xc(%ebp),%eax
10d359: 50 push %eax
10d35a: ff 75 08 pushl 0x8(%ebp)
10d35d: e8 e6 fd ff ff call 10d148 <_POSIX_Mutex_Get_interrupt_disable>
switch ( location ) {
10d362: 83 c4 10 add $0x10,%esp
10d365: 8b 55 f4 mov -0xc(%ebp),%edx
10d368: 85 d2 test %edx,%edx
10d36a: 75 34 jne 10d3a0 <_POSIX_Mutex_Lock_support+0x58>
case OBJECTS_LOCAL:
_CORE_mutex_Seize(
10d36c: 83 ec 0c sub $0xc,%esp
10d36f: ff 75 f0 pushl -0x10(%ebp)
10d372: ff 75 10 pushl 0x10(%ebp)
10d375: 0f b6 db movzbl %bl,%ebx
10d378: 53 push %ebx
10d379: ff 70 08 pushl 0x8(%eax)
10d37c: 83 c0 14 add $0x14,%eax
10d37f: 50 push %eax
10d380: e8 43 1d 00 00 call 10f0c8 <_CORE_mutex_Seize>
the_mutex->Object.id,
blocking,
timeout,
level
);
return _POSIX_Mutex_Translate_core_mutex_return_code(
10d385: 83 c4 14 add $0x14,%esp
(CORE_mutex_Status) _Thread_Executing->Wait.return_code
10d388: a1 98 d2 12 00 mov 0x12d298,%eax
the_mutex->Object.id,
blocking,
timeout,
level
);
return _POSIX_Mutex_Translate_core_mutex_return_code(
10d38d: ff 70 34 pushl 0x34(%eax)
10d390: e8 1b 01 00 00 call 10d4b0 <_POSIX_Mutex_Translate_core_mutex_return_code>
10d395: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10d398: 8b 5d fc mov -0x4(%ebp),%ebx
10d39b: c9 leave
10d39c: c3 ret
10d39d: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10d3a0: b8 16 00 00 00 mov $0x16,%eax
}
10d3a5: 8b 5d fc mov -0x4(%ebp),%ebx
10d3a8: c9 leave
10d3a9: c3 ret
00114978 <_POSIX_Semaphore_Create_support>:
const char *name,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
114978: 55 push %ebp
114979: 89 e5 mov %esp,%ebp
11497b: 56 push %esi
11497c: 53 push %ebx
11497d: 8b 5d 08 mov 0x8(%ebp),%ebx
POSIX_Semaphore_Control *the_semaphore;
CORE_semaphore_Attributes *the_sem_attr;
char *name_p = (char *)name;
/* Sharing semaphores among processes is not currently supported */
if (pshared != 0)
114980: 8b 55 0c mov 0xc(%ebp),%edx
114983: 85 d2 test %edx,%edx
114985: 0f 85 b9 00 00 00 jne 114a44 <_POSIX_Semaphore_Create_support+0xcc>
rtems_set_errno_and_return_minus_one( ENOSYS );
if ( name ) {
11498b: 85 db test %ebx,%ebx
11498d: 74 1c je 1149ab <_POSIX_Semaphore_Create_support+0x33>
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
11498f: 83 ec 08 sub $0x8,%esp
114992: 68 ff 00 00 00 push $0xff
114997: 53 push %ebx
114998: e8 3b 3d 00 00 call 1186d8 <strnlen>
11499d: 83 c4 10 add $0x10,%esp
1149a0: 3d fe 00 00 00 cmp $0xfe,%eax
1149a5: 0f 87 ad 00 00 00 ja 114a58 <_POSIX_Semaphore_Create_support+0xe0>
1149ab: a1 10 db 12 00 mov 0x12db10,%eax
1149b0: 40 inc %eax
1149b1: a3 10 db 12 00 mov %eax,0x12db10
*/
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{
return (POSIX_Semaphore_Control *)
_Objects_Allocate( &_POSIX_Semaphore_Information );
1149b6: 83 ec 0c sub $0xc,%esp
1149b9: 68 20 de 12 00 push $0x12de20
1149be: e8 65 b9 ff ff call 110328 <_Objects_Allocate>
1149c3: 89 c6 mov %eax,%esi
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
1149c5: 83 c4 10 add $0x10,%esp
1149c8: 85 c0 test %eax,%eax
1149ca: 0f 84 9a 00 00 00 je 114a6a <_POSIX_Semaphore_Create_support+0xf2>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOSPC );
}
the_semaphore->process_shared = pshared;
1149d0: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
if ( name ) {
1149d7: 85 db test %ebx,%ebx
1149d9: 74 55 je 114a30 <_POSIX_Semaphore_Create_support+0xb8>
the_semaphore->named = true;
1149db: c6 40 14 01 movb $0x1,0x14(%eax)
the_semaphore->open_count = 1;
1149df: c7 40 18 01 00 00 00 movl $0x1,0x18(%eax)
the_semaphore->linked = true;
1149e6: c6 40 15 01 movb $0x1,0x15(%eax)
* blocking tasks on this semaphore should be. It could somehow
* be derived from the current scheduling policy. One
* thing is certain, no matter what we decide, it won't be
* the same as all other POSIX implementations. :)
*/
the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
1149ea: c7 46 60 00 00 00 00 movl $0x0,0x60(%esi)
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
1149f1: c7 46 5c ff ff ff ff movl $0xffffffff,0x5c(%esi)
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
1149f8: 50 push %eax
1149f9: ff 75 10 pushl 0x10(%ebp)
the_semaphore->named = false;
the_semaphore->open_count = 0;
the_semaphore->linked = false;
}
the_sem_attr = &the_semaphore->Semaphore.Attributes;
1149fc: 8d 46 5c lea 0x5c(%esi),%eax
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
1149ff: 50 push %eax
114a00: 8d 46 1c lea 0x1c(%esi),%eax
114a03: 50 push %eax
114a04: e8 a7 b3 ff ff call 10fdb0 <_CORE_semaphore_Initialize>
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
114a09: 0f b7 56 08 movzwl 0x8(%esi),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
114a0d: a1 3c de 12 00 mov 0x12de3c,%eax
114a12: 89 34 90 mov %esi,(%eax,%edx,4)
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
114a15: 89 5e 0c mov %ebx,0xc(%esi)
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name_p
);
*the_sem = the_semaphore;
114a18: 8b 45 14 mov 0x14(%ebp),%eax
114a1b: 89 30 mov %esi,(%eax)
_Thread_Enable_dispatch();
114a1d: e8 b2 c9 ff ff call 1113d4 <_Thread_Enable_dispatch>
return 0;
114a22: 83 c4 10 add $0x10,%esp
114a25: 31 c0 xor %eax,%eax
}
114a27: 8d 65 f8 lea -0x8(%ebp),%esp
114a2a: 5b pop %ebx
114a2b: 5e pop %esi
114a2c: c9 leave
114a2d: c3 ret
114a2e: 66 90 xchg %ax,%ax
if ( name ) {
the_semaphore->named = true;
the_semaphore->open_count = 1;
the_semaphore->linked = true;
} else {
the_semaphore->named = false;
114a30: c6 40 14 00 movb $0x0,0x14(%eax)
the_semaphore->open_count = 0;
114a34: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_semaphore->linked = false;
114a3b: c6 40 15 00 movb $0x0,0x15(%eax)
114a3f: eb a9 jmp 1149ea <_POSIX_Semaphore_Create_support+0x72>
114a41: 8d 76 00 lea 0x0(%esi),%esi
CORE_semaphore_Attributes *the_sem_attr;
char *name_p = (char *)name;
/* Sharing semaphores among processes is not currently supported */
if (pshared != 0)
rtems_set_errno_and_return_minus_one( ENOSYS );
114a44: e8 5f 2b 00 00 call 1175a8 <__errno>
114a49: c7 00 58 00 00 00 movl $0x58,(%eax)
114a4f: b8 ff ff ff ff mov $0xffffffff,%eax
114a54: eb d1 jmp 114a27 <_POSIX_Semaphore_Create_support+0xaf>
114a56: 66 90 xchg %ax,%ax
if ( name ) {
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
114a58: e8 4b 2b 00 00 call 1175a8 <__errno>
114a5d: c7 00 5b 00 00 00 movl $0x5b,(%eax)
114a63: b8 ff ff ff ff mov $0xffffffff,%eax
114a68: eb bd jmp 114a27 <_POSIX_Semaphore_Create_support+0xaf>
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
114a6a: e8 65 c9 ff ff call 1113d4 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSPC );
114a6f: e8 34 2b 00 00 call 1175a8 <__errno>
114a74: c7 00 1c 00 00 00 movl $0x1c,(%eax)
114a7a: b8 ff ff ff ff mov $0xffffffff,%eax
114a7f: eb a6 jmp 114a27 <_POSIX_Semaphore_Create_support+0xaf>
00114ad4 <_POSIX_Semaphore_Name_to_id>:
int _POSIX_Semaphore_Name_to_id(
const char *name,
sem_t *id
)
{
114ad4: 55 push %ebp
114ad5: 89 e5 mov %esp,%ebp
114ad7: 83 ec 18 sub $0x18,%esp
114ada: 8b 45 08 mov 0x8(%ebp),%eax
Objects_Name_or_id_lookup_errors status;
Objects_Id the_id;
if ( !name )
114add: 85 c0 test %eax,%eax
114adf: 74 05 je 114ae6 <_POSIX_Semaphore_Name_to_id+0x12>
return EINVAL;
if ( !name[0] )
114ae1: 80 38 00 cmpb $0x0,(%eax)
114ae4: 75 0a jne 114af0 <_POSIX_Semaphore_Name_to_id+0x1c>
return EINVAL;
114ae6: b8 16 00 00 00 mov $0x16,%eax
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
return ENOENT;
}
114aeb: c9 leave
114aec: c3 ret
114aed: 8d 76 00 lea 0x0(%esi),%esi
return EINVAL;
if ( !name[0] )
return EINVAL;
status = _Objects_Name_to_id_string(
114af0: 52 push %edx
114af1: 8d 55 f4 lea -0xc(%ebp),%edx
114af4: 52 push %edx
114af5: 50 push %eax
114af6: 68 20 de 12 00 push $0x12de20
114afb: e8 7c 0c 00 00 call 11577c <_Objects_Name_to_id_string>
&_POSIX_Semaphore_Information,
name,
&the_id
);
*id = the_id;
114b00: 8b 4d f4 mov -0xc(%ebp),%ecx
114b03: 8b 55 0c mov 0xc(%ebp),%edx
114b06: 89 0a mov %ecx,(%edx)
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
114b08: 83 c4 10 add $0x10,%esp
return 0;
114b0b: 83 f8 01 cmp $0x1,%eax
114b0e: 19 c0 sbb %eax,%eax
114b10: f7 d0 not %eax
114b12: 83 e0 02 and $0x2,%eax
return ENOENT;
}
114b15: c9 leave
114b16: c3 ret
00114b40 <_POSIX_Semaphore_Wait_support>:
int _POSIX_Semaphore_Wait_support(
sem_t *sem,
bool blocking,
Watchdog_Interval timeout
)
{
114b40: 55 push %ebp
114b41: 89 e5 mov %esp,%ebp
114b43: 53 push %ebx
114b44: 83 ec 18 sub $0x18,%esp
114b47: 8a 5d 0c mov 0xc(%ebp),%bl
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
114b4a: 8d 45 f4 lea -0xc(%ebp),%eax
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
_Objects_Get( &_POSIX_Semaphore_Information, (Objects_Id)*id, location );
114b4d: 50 push %eax
114b4e: 8b 45 08 mov 0x8(%ebp),%eax
114b51: ff 30 pushl (%eax)
114b53: 68 20 de 12 00 push $0x12de20
114b58: e8 7f bc ff ff call 1107dc <_Objects_Get>
switch ( location ) {
114b5d: 83 c4 10 add $0x10,%esp
114b60: 8b 55 f4 mov -0xc(%ebp),%edx
114b63: 85 d2 test %edx,%edx
114b65: 74 15 je 114b7c <_POSIX_Semaphore_Wait_support+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
114b67: e8 3c 2a 00 00 call 1175a8 <__errno>
114b6c: c7 00 16 00 00 00 movl $0x16,(%eax)
114b72: b8 ff ff ff ff mov $0xffffffff,%eax
}
114b77: 8b 5d fc mov -0x4(%ebp),%ebx
114b7a: c9 leave
114b7b: c3 ret
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_semaphore_Seize(
114b7c: ff 75 10 pushl 0x10(%ebp)
114b7f: 0f b6 db movzbl %bl,%ebx
114b82: 53 push %ebx
114b83: ff 70 08 pushl 0x8(%eax)
114b86: 83 c0 1c add $0x1c,%eax
114b89: 50 push %eax
114b8a: e8 29 07 00 00 call 1152b8 <_CORE_semaphore_Seize>
&the_semaphore->Semaphore,
the_semaphore->Object.id,
blocking,
timeout
);
_Thread_Enable_dispatch();
114b8f: e8 40 c8 ff ff call 1113d4 <_Thread_Enable_dispatch>
if ( !_Thread_Executing->Wait.return_code )
114b94: 83 c4 10 add $0x10,%esp
114b97: a1 b8 e0 12 00 mov 0x12e0b8,%eax
114b9c: 8b 40 34 mov 0x34(%eax),%eax
114b9f: 85 c0 test %eax,%eax
114ba1: 75 09 jne 114bac <_POSIX_Semaphore_Wait_support+0x6c>
return 0;
114ba3: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
114ba5: 8b 5d fc mov -0x4(%ebp),%ebx
114ba8: c9 leave
114ba9: c3 ret
114baa: 66 90 xchg %ax,%ax
_Thread_Enable_dispatch();
if ( !_Thread_Executing->Wait.return_code )
return 0;
rtems_set_errno_and_return_minus_one(
114bac: e8 f7 29 00 00 call 1175a8 <__errno>
114bb1: 89 c3 mov %eax,%ebx
114bb3: 83 ec 0c sub $0xc,%esp
114bb6: a1 b8 e0 12 00 mov 0x12e0b8,%eax
114bbb: ff 70 34 pushl 0x34(%eax)
114bbe: e8 55 25 00 00 call 117118 <_POSIX_Semaphore_Translate_core_semaphore_return_code>
114bc3: 89 03 mov %eax,(%ebx)
114bc5: 83 c4 10 add $0x10,%esp
114bc8: b8 ff ff ff ff mov $0xffffffff,%eax
114bcd: eb a8 jmp 114b77 <_POSIX_Semaphore_Wait_support+0x37>
001106fc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
#include <rtems/posix/pthread.h>
void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(
Thread_Control *the_thread
)
{
1106fc: 55 push %ebp
1106fd: 89 e5 mov %esp,%ebp
1106ff: 83 ec 08 sub $0x8,%esp
110702: 8b 55 08 mov 0x8(%ebp),%edx
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
110705: 8b 82 ec 00 00 00 mov 0xec(%edx),%eax
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
11070b: 8b 88 d8 00 00 00 mov 0xd8(%eax),%ecx
110711: 85 c9 test %ecx,%ecx
110713: 75 09 jne 11071e <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x22><== NEVER TAKEN
110715: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax)
11071c: 74 06 je 110724 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x28>
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
} else
_Thread_Enable_dispatch();
}
11071e: c9 leave
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
} else
_Thread_Enable_dispatch();
11071f: e9 d4 d6 ff ff jmp 10ddf8 <_Thread_Enable_dispatch>
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
110724: 8b 80 e0 00 00 00 mov 0xe0(%eax),%eax
11072a: 85 c0 test %eax,%eax
11072c: 74 f0 je 11071e <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x22>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
11072e: a1 b0 90 12 00 mov 0x1290b0,%eax
110733: 48 dec %eax
110734: a3 b0 90 12 00 mov %eax,0x1290b0
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
110739: 83 ec 08 sub $0x8,%esp
11073c: 6a ff push $0xffffffff
11073e: 52 push %edx
11073f: e8 c0 08 00 00 call 111004 <_POSIX_Thread_Exit>
110744: 83 c4 10 add $0x10,%esp
} else
_Thread_Enable_dispatch();
}
110747: c9 leave
110748: c3 ret
00111a6c <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
111a6c: 55 push %ebp
111a6d: 89 e5 mov %esp,%ebp
111a6f: 57 push %edi
111a70: 56 push %esi
111a71: 53 push %ebx
111a72: 83 ec 18 sub $0x18,%esp
111a75: 8b 5d 08 mov 0x8(%ebp),%ebx
111a78: 8b 75 0c mov 0xc(%ebp),%esi
111a7b: 8b 7d 10 mov 0x10(%ebp),%edi
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
111a7e: ff 36 pushl (%esi)
111a80: e8 cb ff ff ff call 111a50 <_POSIX_Priority_Is_valid>
111a85: 83 c4 10 add $0x10,%esp
111a88: 84 c0 test %al,%al
111a8a: 74 2a je 111ab6 <_POSIX_Thread_Translate_sched_param+0x4a><== NEVER TAKEN
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
111a8c: c7 07 00 00 00 00 movl $0x0,(%edi)
*budget_callout = NULL;
111a92: 8b 45 14 mov 0x14(%ebp),%eax
111a95: c7 00 00 00 00 00 movl $0x0,(%eax)
if ( policy == SCHED_OTHER ) {
111a9b: 85 db test %ebx,%ebx
111a9d: 74 25 je 111ac4 <_POSIX_Thread_Translate_sched_param+0x58>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
111a9f: 83 fb 01 cmp $0x1,%ebx
111aa2: 0f 84 90 00 00 00 je 111b38 <_POSIX_Thread_Translate_sched_param+0xcc>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
111aa8: 83 fb 02 cmp $0x2,%ebx
111aab: 0f 84 8f 00 00 00 je 111b40 <_POSIX_Thread_Translate_sched_param+0xd4>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
111ab1: 83 fb 04 cmp $0x4,%ebx
111ab4: 74 1e je 111ad4 <_POSIX_Thread_Translate_sched_param+0x68>
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
return EINVAL;
111ab6: b8 16 00 00 00 mov $0x16,%eax
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
111abb: 8d 65 f4 lea -0xc(%ebp),%esp
111abe: 5b pop %ebx
111abf: 5e pop %esi
111ac0: 5f pop %edi
111ac1: c9 leave
111ac2: c3 ret
111ac3: 90 nop
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
111ac4: c7 07 01 00 00 00 movl $0x1,(%edi)
return 0;
111aca: 31 c0 xor %eax,%eax
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
111acc: 8d 65 f4 lea -0xc(%ebp),%esp
111acf: 5b pop %ebx
111ad0: 5e pop %esi
111ad1: 5f pop %edi
111ad2: c9 leave
111ad3: c3 ret
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
111ad4: 8b 5e 08 mov 0x8(%esi),%ebx
111ad7: 85 db test %ebx,%ebx
111ad9: 75 07 jne 111ae2 <_POSIX_Thread_Translate_sched_param+0x76>
111adb: 8b 4e 0c mov 0xc(%esi),%ecx
111ade: 85 c9 test %ecx,%ecx
111ae0: 74 d4 je 111ab6 <_POSIX_Thread_Translate_sched_param+0x4a>
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
111ae2: 8b 56 10 mov 0x10(%esi),%edx
111ae5: 85 d2 test %edx,%edx
111ae7: 75 07 jne 111af0 <_POSIX_Thread_Translate_sched_param+0x84>
111ae9: 8b 46 14 mov 0x14(%esi),%eax
111aec: 85 c0 test %eax,%eax
111aee: 74 c6 je 111ab6 <_POSIX_Thread_Translate_sched_param+0x4a>
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
111af0: 83 ec 0c sub $0xc,%esp
111af3: 8d 46 08 lea 0x8(%esi),%eax
111af6: 50 push %eax
111af7: e8 00 da ff ff call 10f4fc <_Timespec_To_ticks>
111afc: 89 c3 mov %eax,%ebx
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
111afe: 8d 46 10 lea 0x10(%esi),%eax
111b01: 89 04 24 mov %eax,(%esp)
111b04: e8 f3 d9 ff ff call 10f4fc <_Timespec_To_ticks>
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
111b09: 83 c4 10 add $0x10,%esp
111b0c: 39 c3 cmp %eax,%ebx
111b0e: 72 a6 jb 111ab6 <_POSIX_Thread_Translate_sched_param+0x4a>
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
111b10: 83 ec 0c sub $0xc,%esp
111b13: ff 76 04 pushl 0x4(%esi)
111b16: e8 35 ff ff ff call 111a50 <_POSIX_Priority_Is_valid>
111b1b: 83 c4 10 add $0x10,%esp
111b1e: 84 c0 test %al,%al
111b20: 74 94 je 111ab6 <_POSIX_Thread_Translate_sched_param+0x4a>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
111b22: c7 07 03 00 00 00 movl $0x3,(%edi)
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
111b28: 8b 45 14 mov 0x14(%ebp),%eax
111b2b: c7 00 14 bd 10 00 movl $0x10bd14,(%eax)
return 0;
111b31: 31 c0 xor %eax,%eax
111b33: eb 86 jmp 111abb <_POSIX_Thread_Translate_sched_param+0x4f>
111b35: 8d 76 00 lea 0x0(%esi),%esi
return 0;
}
if ( policy == SCHED_FIFO ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
111b38: 31 c0 xor %eax,%eax
111b3a: e9 7c ff ff ff jmp 111abb <_POSIX_Thread_Translate_sched_param+0x4f>
111b3f: 90 nop
}
if ( policy == SCHED_RR ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
111b40: c7 07 02 00 00 00 movl $0x2,(%edi)
return 0;
111b46: 31 c0 xor %eax,%eax
111b48: e9 6e ff ff ff jmp 111abb <_POSIX_Thread_Translate_sched_param+0x4f>
00110918 <_POSIX_Threads_Create_extension>:
bool _POSIX_Threads_Create_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *created
)
{
110918: 55 push %ebp
110919: 89 e5 mov %esp,%ebp
11091b: 57 push %edi
11091c: 56 push %esi
11091d: 53 push %ebx
11091e: 83 ec 28 sub $0x28,%esp
110921: 8b 55 0c mov 0xc(%ebp),%edx
POSIX_API_Control *api;
POSIX_API_Control *executing_api;
api = _Workspace_Allocate( sizeof( POSIX_API_Control ) );
110924: 68 f0 00 00 00 push $0xf0
110929: 89 55 e4 mov %edx,-0x1c(%ebp)
11092c: e8 57 e0 ff ff call 10e988 <_Workspace_Allocate>
110931: 89 c3 mov %eax,%ebx
if ( !api )
110933: 83 c4 10 add $0x10,%esp
110936: 85 c0 test %eax,%eax
110938: 8b 55 e4 mov -0x1c(%ebp),%edx
11093b: 0f 84 2f 01 00 00 je 110a70 <_POSIX_Threads_Create_extension+0x158><== NEVER TAKEN
return false;
created->API_Extensions[ THREAD_API_POSIX ] = api;
110941: 89 82 ec 00 00 00 mov %eax,0xec(%edx)
/* XXX check all fields are touched */
api->Attributes = _POSIX_Threads_Default_attributes;
110947: b9 40 00 00 00 mov $0x40,%ecx
11094c: 31 c0 xor %eax,%eax
11094e: 89 df mov %ebx,%edi
110950: f3 aa rep stos %al,%es:(%edi)
110952: c7 03 01 00 00 00 movl $0x1,(%ebx)
110958: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
11095f: c7 43 14 01 00 00 00 movl $0x1,0x14(%ebx)
110966: c7 43 18 02 00 00 00 movl $0x2,0x18(%ebx)
11096d: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx)
110974: c7 43 3c 01 00 00 00 movl $0x1,0x3c(%ebx)
api->detachstate = _POSIX_Threads_Default_attributes.detachstate;
11097b: c7 43 40 01 00 00 00 movl $0x1,0x40(%ebx)
api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy;
110982: c7 83 84 00 00 00 01 movl $0x1,0x84(%ebx)
110989: 00 00 00
api->schedparam = _POSIX_Threads_Default_attributes.schedparam;
11098c: be 78 1b 12 00 mov $0x121b78,%esi
110991: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi
110997: b1 07 mov $0x7,%cl
110999: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core(
Priority_Control priority
)
{
return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
11099b: 0f b6 05 74 3a 12 00 movzbl 0x123a74,%eax
1109a2: 2b 42 14 sub 0x14(%edx),%eax
1109a5: 89 83 88 00 00 00 mov %eax,0x88(%ebx)
_POSIX_Priority_From_core( created->current_priority );
/*
* POSIX 1003.1 1996, 18.2.2.2
*/
api->cancelation_requested = 0;
1109ab: c7 83 e0 00 00 00 00 movl $0x0,0xe0(%ebx)
1109b2: 00 00 00
api->cancelability_state = PTHREAD_CANCEL_ENABLE;
1109b5: c7 83 d8 00 00 00 00 movl $0x0,0xd8(%ebx)
1109bc: 00 00 00
api->cancelability_type = PTHREAD_CANCEL_DEFERRED;
1109bf: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx)
1109c6: 00 00 00
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 );
1109c9: 8d 83 e8 00 00 00 lea 0xe8(%ebx),%eax
1109cf: 89 83 e4 00 00 00 mov %eax,0xe4(%ebx)
head->next = tail;
head->previous = NULL;
1109d5: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx)
1109dc: 00 00 00
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
1109df: 8d 83 e4 00 00 00 lea 0xe4(%ebx),%eax
1109e5: 89 83 ec 00 00 00 mov %eax,0xec(%ebx)
*
* The check for class == 1 is debug. Should never really happen.
*/
/* XXX use signal constants */
api->signals_pending = 0;
1109eb: c7 83 d4 00 00 00 00 movl $0x0,0xd4(%ebx)
1109f2: 00 00 00
1109f5: 0f b6 42 0b movzbl 0xb(%edx),%eax
1109f9: 83 e0 07 and $0x7,%eax
if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API
1109fc: 83 f8 03 cmp $0x3,%eax
1109ff: 74 53 je 110a54 <_POSIX_Threads_Create_extension+0x13c>
#endif
) {
executing_api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
api->signals_blocked = executing_api->signals_blocked;
} else {
api->signals_blocked = 0xffffffff;
110a01: c7 83 d0 00 00 00 ff movl $0xffffffff,0xd0(%ebx)
110a08: ff ff ff
}
_Thread_queue_Initialize(
110a0b: 6a 00 push $0x0
110a0d: 68 00 10 00 00 push $0x1000
110a12: 6a 00 push $0x0
110a14: 8d 43 44 lea 0x44(%ebx),%eax
110a17: 50 push %eax
110a18: 89 55 e4 mov %edx,-0x1c(%ebp)
110a1b: e8 9c d6 ff ff call 10e0bc <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_JOIN_AT_EXIT,
0
);
_Watchdog_Initialize(
110a20: 8b 55 e4 mov -0x1c(%ebp),%edx
110a23: 8b 42 08 mov 0x8(%edx),%eax
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
110a26: c7 83 b0 00 00 00 00 movl $0x0,0xb0(%ebx)
110a2d: 00 00 00
the_watchdog->routine = routine;
110a30: c7 83 c4 00 00 00 7c movl $0x110a7c,0xc4(%ebx)
110a37: 0a 11 00
the_watchdog->id = id;
110a3a: 89 83 c8 00 00 00 mov %eax,0xc8(%ebx)
the_watchdog->user_data = user_data;
110a40: 89 93 cc 00 00 00 mov %edx,0xcc(%ebx)
_POSIX_Threads_Sporadic_budget_TSR,
created->Object.id,
created
);
return true;
110a46: 83 c4 10 add $0x10,%esp
110a49: b0 01 mov $0x1,%al
}
110a4b: 8d 65 f4 lea -0xc(%ebp),%esp
110a4e: 5b pop %ebx
110a4f: 5e pop %esi
110a50: 5f pop %edi
110a51: c9 leave
110a52: c3 ret
110a53: 90 nop
if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API
#if defined(RTEMS_DEBUG)
&& _Objects_Get_class( created->Object.id ) == 1
#endif
) {
executing_api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
110a54: a1 38 83 12 00 mov 0x128338,%eax
api->signals_blocked = executing_api->signals_blocked;
110a59: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
110a5f: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
110a65: 89 83 d0 00 00 00 mov %eax,0xd0(%ebx)
110a6b: eb 9e jmp 110a0b <_POSIX_Threads_Create_extension+0xf3>
110a6d: 8d 76 00 lea 0x0(%esi),%esi
POSIX_API_Control *executing_api;
api = _Workspace_Allocate( sizeof( POSIX_API_Control ) );
if ( !api )
return false;
110a70: 31 c0 xor %eax,%eax
created->Object.id,
created
);
return true;
}
110a72: 8d 65 f4 lea -0xc(%ebp),%esp
110a75: 5b pop %ebx
110a76: 5e pop %esi
110a77: 5f pop %edi
110a78: c9 leave
110a79: c3 ret
00110890 <_POSIX_Threads_Delete_extension>:
*/
void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
110890: 55 push %ebp
110891: 89 e5 mov %esp,%ebp
110893: 57 push %edi
110894: 56 push %esi
110895: 53 push %ebx
110896: 83 ec 28 sub $0x28,%esp
110899: 8b 7d 0c mov 0xc(%ebp),%edi
Thread_Control *the_thread;
POSIX_API_Control *api;
void **value_ptr;
api = deleted->API_Extensions[ THREAD_API_POSIX ];
11089c: 8b 87 ec 00 00 00 mov 0xec(%edi),%eax
1108a2: 89 45 e4 mov %eax,-0x1c(%ebp)
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
1108a5: 57 push %edi
1108a6: e8 fd 21 00 00 call 112aa8 <_POSIX_Threads_cancel_run>
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
1108ab: 89 3c 24 mov %edi,(%esp)
1108ae: e8 5d 22 00 00 call 112b10 <_POSIX_Keys_Run_destructors>
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
1108b3: 8b 77 28 mov 0x28(%edi),%esi
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
1108b6: 83 c4 10 add $0x10,%esp
1108b9: 8b 45 e4 mov -0x1c(%ebp),%eax
1108bc: 8d 58 44 lea 0x44(%eax),%ebx
1108bf: eb 08 jmp 1108c9 <_POSIX_Threads_Delete_extension+0x39>
1108c1: 8d 76 00 lea 0x0(%esi),%esi
*(void **)the_thread->Wait.return_argument = value_ptr;
1108c4: 8b 40 28 mov 0x28(%eax),%eax
1108c7: 89 30 mov %esi,(%eax)
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
1108c9: 83 ec 0c sub $0xc,%esp
1108cc: 53 push %ebx
1108cd: e8 5a d4 ff ff call 10dd2c <_Thread_queue_Dequeue>
1108d2: 83 c4 10 add $0x10,%esp
1108d5: 85 c0 test %eax,%eax
1108d7: 75 eb jne 1108c4 <_POSIX_Threads_Delete_extension+0x34>
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
1108d9: 8b 45 e4 mov -0x1c(%ebp),%eax
1108dc: 83 b8 84 00 00 00 04 cmpl $0x4,0x84(%eax)
1108e3: 74 1f je 110904 <_POSIX_Threads_Delete_extension+0x74>
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
1108e5: c7 87 ec 00 00 00 00 movl $0x0,0xec(%edi)
1108ec: 00 00 00
_Workspace_Free( api );
1108ef: 8b 45 e4 mov -0x1c(%ebp),%eax
1108f2: 89 45 08 mov %eax,0x8(%ebp)
}
1108f5: 8d 65 f4 lea -0xc(%ebp),%esp
1108f8: 5b pop %ebx
1108f9: 5e pop %esi
1108fa: 5f pop %edi
1108fb: c9 leave
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
_Workspace_Free( api );
1108fc: e9 a3 e0 ff ff jmp 10e9a4 <_Workspace_Free>
110901: 8d 76 00 lea 0x0(%esi),%esi
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
110904: 83 ec 0c sub $0xc,%esp
110907: 05 a8 00 00 00 add $0xa8,%eax
11090c: 50 push %eax
11090d: e8 4e df ff ff call 10e860 <_Watchdog_Remove>
110912: 83 c4 10 add $0x10,%esp
110915: eb ce jmp 1108e5 <_POSIX_Threads_Delete_extension+0x55>
00110854 <_POSIX_Threads_Initialize_user_threads>:
*
* This routine creates and starts all configured user
* initialzation threads.
*/
void _POSIX_Threads_Initialize_user_threads( void )
{
110854: 55 push %ebp
110855: 89 e5 mov %esp,%ebp
110857: 83 ec 08 sub $0x8,%esp
if ( _POSIX_Threads_Initialize_user_threads_p )
11085a: a1 38 60 12 00 mov 0x126038,%eax
11085f: 85 c0 test %eax,%eax
110861: 74 05 je 110868 <_POSIX_Threads_Initialize_user_threads+0x14>
(*_POSIX_Threads_Initialize_user_threads_p)();
}
110863: c9 leave
* initialzation threads.
*/
void _POSIX_Threads_Initialize_user_threads( void )
{
if ( _POSIX_Threads_Initialize_user_threads_p )
(*_POSIX_Threads_Initialize_user_threads_p)();
110864: ff e0 jmp *%eax
110866: 66 90 xchg %ax,%ax
}
110868: c9 leave
110869: c3 ret
0010b9f4 <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
10b9f4: 55 push %ebp
10b9f5: 89 e5 mov %esp,%ebp
10b9f7: 57 push %edi
10b9f8: 56 push %esi
10b9f9: 53 push %ebx
10b9fa: 83 ec 6c sub $0x6c,%esp
uint32_t maximum;
posix_initialization_threads_table *user_threads;
pthread_t thread_id;
pthread_attr_t attr;
user_threads = Configuration_POSIX_API.User_initialization_threads_table;
10b9fd: 8b 3d 94 4d 12 00 mov 0x124d94,%edi
maximum = Configuration_POSIX_API.number_of_initialization_threads;
10ba03: a1 90 4d 12 00 mov 0x124d90,%eax
10ba08: 89 45 94 mov %eax,-0x6c(%ebp)
if ( !user_threads || maximum == 0 )
10ba0b: 85 ff test %edi,%edi
10ba0d: 74 44 je 10ba53 <_POSIX_Threads_Initialize_user_threads_body+0x5f><== NEVER TAKEN
10ba0f: 85 c0 test %eax,%eax
10ba11: 74 40 je 10ba53 <_POSIX_Threads_Initialize_user_threads_body+0x5f><== NEVER TAKEN
10ba13: 31 db xor %ebx,%ebx
10ba15: 8d 75 a4 lea -0x5c(%ebp),%esi
for ( index=0 ; index < maximum ; index++ ) {
/*
* There is no way for these calls to fail in this situation.
*/
(void) pthread_attr_init( &attr );
10ba18: 83 ec 0c sub $0xc,%esp
10ba1b: 56 push %esi
10ba1c: e8 2f 61 00 00 call 111b50 <pthread_attr_init>
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
10ba21: 5a pop %edx
10ba22: 59 pop %ecx
10ba23: 6a 02 push $0x2
10ba25: 56 push %esi
10ba26: e8 51 61 00 00 call 111b7c <pthread_attr_setinheritsched>
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
10ba2b: 59 pop %ecx
10ba2c: 58 pop %eax
10ba2d: ff 74 df 04 pushl 0x4(%edi,%ebx,8)
10ba31: 56 push %esi
10ba32: e8 79 61 00 00 call 111bb0 <pthread_attr_setstacksize>
status = pthread_create(
10ba37: 6a 00 push $0x0
10ba39: ff 34 df pushl (%edi,%ebx,8)
10ba3c: 56 push %esi
10ba3d: 8d 45 e4 lea -0x1c(%ebp),%eax
10ba40: 50 push %eax
10ba41: e8 92 fc ff ff call 10b6d8 <pthread_create>
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
10ba46: 83 c4 20 add $0x20,%esp
10ba49: 85 c0 test %eax,%eax
10ba4b: 75 0e jne 10ba5b <_POSIX_Threads_Initialize_user_threads_body+0x67>
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
10ba4d: 43 inc %ebx
10ba4e: 39 5d 94 cmp %ebx,-0x6c(%ebp)
10ba51: 77 c5 ja 10ba18 <_POSIX_Threads_Initialize_user_threads_body+0x24><== NEVER TAKEN
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
}
}
10ba53: 8d 65 f4 lea -0xc(%ebp),%esp
10ba56: 5b pop %ebx
10ba57: 5e pop %esi
10ba58: 5f pop %edi
10ba59: c9 leave
10ba5a: c3 ret
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
10ba5b: 52 push %edx
10ba5c: 50 push %eax
10ba5d: 6a 01 push $0x1
10ba5f: 6a 02 push $0x2
10ba61: e8 c2 1e 00 00 call 10d928 <_Internal_error_Occurred>
00110a7c <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
110a7c: 55 push %ebp
110a7d: 89 e5 mov %esp,%ebp
110a7f: 56 push %esi
110a80: 53 push %ebx
110a81: 8b 75 0c mov 0xc(%ebp),%esi
Thread_Control *the_thread;
POSIX_API_Control *api;
the_thread = argument;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
110a84: 8b 9e ec 00 00 00 mov 0xec(%esi),%ebx
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
110a8a: 83 ec 0c sub $0xc,%esp
110a8d: 8d 83 98 00 00 00 lea 0x98(%ebx),%eax
110a93: 50 push %eax
110a94: e8 7f 0e 00 00 call 111918 <_Timespec_To_ticks>
the_thread->cpu_time_budget = ticks;
110a99: 89 46 78 mov %eax,0x78(%esi)
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
110a9c: 0f b6 05 74 3a 12 00 movzbl 0x123a74,%eax
110aa3: 2b 83 88 00 00 00 sub 0x88(%ebx),%eax
new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority );
the_thread->real_priority = new_priority;
110aa9: 89 46 18 mov %eax,0x18(%esi)
*/
#if 0
printk( "TSR %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
110aac: 83 c4 10 add $0x10,%esp
110aaf: 8b 4e 1c mov 0x1c(%esi),%ecx
110ab2: 85 c9 test %ecx,%ecx
110ab4: 75 05 jne 110abb <_POSIX_Threads_Sporadic_budget_TSR+0x3f><== NEVER TAKEN
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
110ab6: 39 46 14 cmp %eax,0x14(%esi)
110ab9: 77 35 ja 110af0 <_POSIX_Threads_Sporadic_budget_TSR+0x74>
#endif
}
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
110abb: 83 ec 0c sub $0xc,%esp
110abe: 8d 83 90 00 00 00 lea 0x90(%ebx),%eax
110ac4: 50 push %eax
110ac5: e8 4e 0e 00 00 call 111918 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
110aca: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
110ad0: 83 c4 10 add $0x10,%esp
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
110ad3: 81 c3 a8 00 00 00 add $0xa8,%ebx
110ad9: 89 5d 0c mov %ebx,0xc(%ebp)
110adc: c7 45 08 60 7e 12 00 movl $0x127e60,0x8(%ebp)
}
110ae3: 8d 65 f8 lea -0x8(%ebp),%esp
110ae6: 5b pop %ebx
110ae7: 5e pop %esi
110ae8: c9 leave
110ae9: e9 32 dc ff ff jmp 10e720 <_Watchdog_Insert>
110aee: 66 90 xchg %ax,%ax
if ( the_thread->resource_count == 0 ) {
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
_Thread_Change_priority( the_thread, new_priority, true );
110af0: 52 push %edx
110af1: 6a 01 push $0x1
110af3: 50 push %eax
110af4: 56 push %esi
110af5: e8 7e ca ff ff call 10d578 <_Thread_Change_priority>
110afa: 83 c4 10 add $0x10,%esp
110afd: eb bc jmp 110abb <_POSIX_Threads_Sporadic_budget_TSR+0x3f>
00110b00 <_POSIX_Threads_Sporadic_budget_callout>:
* _POSIX_Threads_Sporadic_budget_callout
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
110b00: 55 push %ebp
110b01: 89 e5 mov %esp,%ebp
110b03: 83 ec 08 sub $0x8,%esp
110b06: 8b 45 08 mov 0x8(%ebp),%eax
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
110b09: 8b 88 ec 00 00 00 mov 0xec(%eax),%ecx
/*
* This will prevent the thread from consuming its entire "budget"
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
110b0f: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax)
110b16: 0f b6 15 74 3a 12 00 movzbl 0x123a74,%edx
110b1d: 2b 91 8c 00 00 00 sub 0x8c(%ecx),%edx
new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority);
the_thread->real_priority = new_priority;
110b23: 89 50 18 mov %edx,0x18(%eax)
*/
#if 0
printk( "callout %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
110b26: 8b 48 1c mov 0x1c(%eax),%ecx
110b29: 85 c9 test %ecx,%ecx
110b2b: 75 05 jne 110b32 <_POSIX_Threads_Sporadic_budget_callout+0x32><== NEVER TAKEN
/*
* Make sure we are actually lowering it. If they have lowered it
* to logically lower than sched_ss_low_priority, then we do not want to
* change it.
*/
if ( the_thread->current_priority < new_priority ) {
110b2d: 39 50 14 cmp %edx,0x14(%eax)
110b30: 72 02 jb 110b34 <_POSIX_Threads_Sporadic_budget_callout+0x34><== ALWAYS TAKEN
#if 0
printk( "lower priority\n" );
#endif
}
}
}
110b32: c9 leave <== NOT EXECUTED
110b33: c3 ret <== NOT EXECUTED
* Make sure we are actually lowering it. If they have lowered it
* to logically lower than sched_ss_low_priority, then we do not want to
* change it.
*/
if ( the_thread->current_priority < new_priority ) {
_Thread_Change_priority( the_thread, new_priority, true );
110b34: 51 push %ecx
110b35: 6a 01 push $0x1
110b37: 52 push %edx
110b38: 50 push %eax
110b39: e8 3a ca ff ff call 10d578 <_Thread_Change_priority>
110b3e: 83 c4 10 add $0x10,%esp
#if 0
printk( "lower priority\n" );
#endif
}
}
}
110b41: c9 leave
110b42: c3 ret
00112aa8 <_POSIX_Threads_cancel_run>:
#include <rtems/posix/threadsup.h>
void _POSIX_Threads_cancel_run(
Thread_Control *the_thread
)
{
112aa8: 55 push %ebp
112aa9: 89 e5 mov %esp,%ebp
112aab: 57 push %edi
112aac: 56 push %esi
112aad: 53 push %ebx
112aae: 83 ec 0c sub $0xc,%esp
POSIX_Cancel_Handler_control *handler;
Chain_Control *handler_stack;
POSIX_API_Control *thread_support;
ISR_Level level;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
112ab1: 8b 45 08 mov 0x8(%ebp),%eax
112ab4: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
112aba: c7 86 d8 00 00 00 01 movl $0x1,0xd8(%esi)
112ac1: 00 00 00
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
112ac4: 8d be e8 00 00 00 lea 0xe8(%esi),%edi
while ( !_Chain_Is_empty( handler_stack ) ) {
112aca: 39 be e4 00 00 00 cmp %edi,0xe4(%esi)
112ad0: 74 33 je 112b05 <_POSIX_Threads_cancel_run+0x5d>
112ad2: 66 90 xchg %ax,%ax
_ISR_Disable( level );
112ad4: 9c pushf
112ad5: fa cli
112ad6: 59 pop %ecx
handler = (POSIX_Cancel_Handler_control *)
112ad7: 8b 9e ec 00 00 00 mov 0xec(%esi),%ebx
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
112add: 8b 13 mov (%ebx),%edx
previous = the_node->previous;
112adf: 8b 43 04 mov 0x4(%ebx),%eax
next->previous = previous;
112ae2: 89 42 04 mov %eax,0x4(%edx)
previous->next = next;
112ae5: 89 10 mov %edx,(%eax)
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
112ae7: 51 push %ecx
112ae8: 9d popf
(*handler->routine)( handler->arg );
112ae9: 83 ec 0c sub $0xc,%esp
112aec: ff 73 0c pushl 0xc(%ebx)
112aef: ff 53 08 call *0x8(%ebx)
_Workspace_Free( handler );
112af2: 89 1c 24 mov %ebx,(%esp)
112af5: e8 aa be ff ff call 10e9a4 <_Workspace_Free>
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
while ( !_Chain_Is_empty( handler_stack ) ) {
112afa: 83 c4 10 add $0x10,%esp
112afd: 39 be e4 00 00 00 cmp %edi,0xe4(%esi)
112b03: 75 cf jne 112ad4 <_POSIX_Threads_cancel_run+0x2c><== NEVER TAKEN
(*handler->routine)( handler->arg );
_Workspace_Free( handler );
}
}
112b05: 8d 65 f4 lea -0xc(%ebp),%esp
112b08: 5b pop %ebx
112b09: 5e pop %esi
112b0a: 5f pop %edi
112b0b: c9 leave
112b0c: c3 ret
0011185c <_POSIX_Timer_Insert_helper>:
Watchdog_Interval ticks,
Objects_Id id,
Watchdog_Service_routine_entry TSR,
void *arg
)
{
11185c: 55 push %ebp
11185d: 89 e5 mov %esp,%ebp
11185f: 56 push %esi
111860: 53 push %ebx
111861: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level;
(void) _Watchdog_Remove( timer );
111864: 83 ec 0c sub $0xc,%esp
111867: 53 push %ebx
111868: e8 03 db ff ff call 10f370 <_Watchdog_Remove>
_ISR_Disable( level );
11186d: 9c pushf
11186e: fa cli
11186f: 5e pop %esi
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( timer->state != WATCHDOG_INACTIVE ) {
111870: 83 c4 10 add $0x10,%esp
111873: 8b 43 08 mov 0x8(%ebx),%eax
111876: 85 c0 test %eax,%eax
111878: 74 0e je 111888 <_POSIX_Timer_Insert_helper+0x2c>
_ISR_Enable( level );
11187a: 56 push %esi
11187b: 9d popf
return false;
11187c: 31 c0 xor %eax,%eax
*/
_Watchdog_Initialize( timer, TSR, id, arg );
_Watchdog_Insert_ticks( timer, ticks );
_ISR_Enable( level );
return true;
}
11187e: 8d 65 f8 lea -0x8(%ebp),%esp
111881: 5b pop %ebx
111882: 5e pop %esi
111883: c9 leave
111884: c3 ret
111885: 8d 76 00 lea 0x0(%esi),%esi
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
111888: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
the_watchdog->routine = routine;
11188f: 8b 45 14 mov 0x14(%ebp),%eax
111892: 89 43 1c mov %eax,0x1c(%ebx)
the_watchdog->id = id;
111895: 8b 45 10 mov 0x10(%ebp),%eax
111898: 89 43 20 mov %eax,0x20(%ebx)
the_watchdog->user_data = user_data;
11189b: 8b 45 18 mov 0x18(%ebp),%eax
11189e: 89 43 24 mov %eax,0x24(%ebx)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
1118a1: 8b 45 0c mov 0xc(%ebp),%eax
1118a4: 89 43 0c mov %eax,0xc(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
1118a7: 83 ec 08 sub $0x8,%esp
1118aa: 53 push %ebx
1118ab: 68 a0 a1 12 00 push $0x12a1a0
1118b0: e8 7b d9 ff ff call 10f230 <_Watchdog_Insert>
* OK. Now we now the timer was not rescheduled by an interrupt
* so we can atomically initialize it as in use.
*/
_Watchdog_Initialize( timer, TSR, id, arg );
_Watchdog_Insert_ticks( timer, ticks );
_ISR_Enable( level );
1118b5: 56 push %esi
1118b6: 9d popf
return true;
1118b7: 83 c4 10 add $0x10,%esp
1118ba: b0 01 mov $0x1,%al
}
1118bc: 8d 65 f8 lea -0x8(%ebp),%esp
1118bf: 5b pop %ebx
1118c0: 5e pop %esi
1118c1: c9 leave
1118c2: c3 ret
0010b804 <_POSIX_Timer_TSR>:
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR(
Objects_Id timer __attribute__((unused)),
void *data)
{
10b804: 55 push %ebp
10b805: 89 e5 mov %esp,%ebp
10b807: 53 push %ebx
10b808: 83 ec 04 sub $0x4,%esp
10b80b: 8b 5d 0c mov 0xc(%ebp),%ebx
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
10b80e: ff 43 68 incl 0x68(%ebx)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
10b811: 8b 53 54 mov 0x54(%ebx),%edx
10b814: 85 d2 test %edx,%edx
10b816: 75 28 jne 10b840 <_POSIX_Timer_TSR+0x3c>
10b818: 8b 43 58 mov 0x58(%ebx),%eax
10b81b: 85 c0 test %eax,%eax
10b81d: 75 21 jne 10b840 <_POSIX_Timer_TSR+0x3c> <== ALWAYS TAKEN
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10b81f: c6 43 3c 04 movb $0x4,0x3c(%ebx) <== NOT EXECUTED
/*
* The sending of the signal to the process running the handling function
* specified for that signal is simulated
*/
if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
10b823: 83 ec 08 sub $0x8,%esp
10b826: ff 73 44 pushl 0x44(%ebx)
10b829: ff 73 38 pushl 0x38(%ebx)
10b82c: e8 bb 5b 00 00 call 1113ec <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
10b831: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
10b838: 83 c4 10 add $0x10,%esp
}
10b83b: 8b 5d fc mov -0x4(%ebp),%ebx
10b83e: c9 leave
10b83f: c3 ret
ptimer->overrun = ptimer->overrun + 1;
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
10b840: 83 ec 0c sub $0xc,%esp
10b843: 53 push %ebx
10b844: 68 04 b8 10 00 push $0x10b804
10b849: ff 73 08 pushl 0x8(%ebx)
10b84c: ff 73 64 pushl 0x64(%ebx)
10b84f: 8d 43 10 lea 0x10(%ebx),%eax
10b852: 50 push %eax
10b853: e8 04 60 00 00 call 11185c <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
10b858: 83 c4 20 add $0x20,%esp
10b85b: 84 c0 test %al,%al
10b85d: 74 dc je 10b83b <_POSIX_Timer_TSR+0x37> <== NEVER TAKEN
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
10b85f: 83 ec 0c sub $0xc,%esp
10b862: 8d 43 6c lea 0x6c(%ebx),%eax
10b865: 50 push %eax
10b866: e8 91 16 00 00 call 10cefc <_TOD_Get>
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10b86b: c6 43 3c 03 movb $0x3,0x3c(%ebx)
10b86f: 83 c4 10 add $0x10,%esp
10b872: eb af jmp 10b823 <_POSIX_Timer_TSR+0x1f>
00112b94 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
112b94: 55 push %ebp
112b95: 89 e5 mov %esp,%ebp
112b97: 57 push %edi
112b98: 56 push %esi
112b99: 53 push %ebx
112b9a: 83 ec 78 sub $0x78,%esp
112b9d: 8b 5d 0c mov 0xc(%ebp),%ebx
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
112ba0: 6a 01 push $0x1
112ba2: 0f b6 45 10 movzbl 0x10(%ebp),%eax
112ba6: 50 push %eax
112ba7: 8d 55 dc lea -0x24(%ebp),%edx
112baa: 52 push %edx
112bab: 53 push %ebx
112bac: ff 75 08 pushl 0x8(%ebp)
112baf: 89 55 9c mov %edx,-0x64(%ebp)
112bb2: e8 b5 00 00 00 call 112c6c <_POSIX_signals_Clear_signals>
112bb7: 83 c4 20 add $0x20,%esp
112bba: 84 c0 test %al,%al
112bbc: 8b 55 9c mov -0x64(%ebp),%edx
112bbf: 0f 84 9b 00 00 00 je 112c60 <_POSIX_signals_Check_signal+0xcc>
#endif
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
112bc5: 8d 04 5b lea (%ebx,%ebx,2),%eax
112bc8: c1 e0 02 shl $0x2,%eax
112bcb: 8b 88 a8 83 12 00 mov 0x1283a8(%eax),%ecx
112bd1: 89 4d a4 mov %ecx,-0x5c(%ebp)
112bd4: 49 dec %ecx
112bd5: 0f 84 85 00 00 00 je 112c60 <_POSIX_signals_Check_signal+0xcc><== NEVER TAKEN
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
112bdb: 8b 75 08 mov 0x8(%ebp),%esi
112bde: 8b b6 d0 00 00 00 mov 0xd0(%esi),%esi
112be4: 89 75 a0 mov %esi,-0x60(%ebp)
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
112be7: 8b 88 a4 83 12 00 mov 0x1283a4(%eax),%ecx
112bed: 09 f1 or %esi,%ecx
112bef: 8b 75 08 mov 0x8(%ebp),%esi
112bf2: 89 8e d0 00 00 00 mov %ecx,0xd0(%esi)
/*
* We have to save the blocking information of the current wait queue
* because the signal handler may subsequently go on and put the thread
* on a wait queue, for its own purposes.
*/
memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,
112bf8: 8d 75 b4 lea -0x4c(%ebp),%esi
112bfb: 89 75 94 mov %esi,-0x6c(%ebp)
112bfe: 8b 35 38 83 12 00 mov 0x128338,%esi
112c04: 83 c6 20 add $0x20,%esi
112c07: b9 0a 00 00 00 mov $0xa,%ecx
112c0c: 8b 7d 94 mov -0x6c(%ebp),%edi
112c0f: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
112c11: 83 b8 a0 83 12 00 02 cmpl $0x2,0x1283a0(%eax)
112c18: 74 36 je 112c50 <_POSIX_signals_Check_signal+0xbc>
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
112c1a: 83 ec 0c sub $0xc,%esp
112c1d: 53 push %ebx
112c1e: ff 55 a4 call *-0x5c(%ebp)
break;
112c21: 83 c4 10 add $0x10,%esp
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
112c24: 8b 3d 38 83 12 00 mov 0x128338,%edi
112c2a: 83 c7 20 add $0x20,%edi
112c2d: b9 0a 00 00 00 mov $0xa,%ecx
112c32: 8b 75 94 mov -0x6c(%ebp),%esi
112c35: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
112c37: 8b 55 a0 mov -0x60(%ebp),%edx
112c3a: 8b 45 08 mov 0x8(%ebp),%eax
112c3d: 89 90 d0 00 00 00 mov %edx,0xd0(%eax)
return true;
112c43: b0 01 mov $0x1,%al
}
112c45: 8d 65 f4 lea -0xc(%ebp),%esp
112c48: 5b pop %ebx
112c49: 5e pop %esi
112c4a: 5f pop %edi
112c4b: c9 leave
112c4c: c3 ret
112c4d: 8d 76 00 lea 0x0(%esi),%esi
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
112c50: 50 push %eax
112c51: 6a 00 push $0x0
112c53: 52 push %edx
112c54: 53 push %ebx
112c55: ff 55 a4 call *-0x5c(%ebp)
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
112c58: 83 c4 10 add $0x10,%esp
112c5b: eb c7 jmp 112c24 <_POSIX_signals_Check_signal+0x90>
112c5d: 8d 76 00 lea 0x0(%esi),%esi
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
return false;
112c60: 31 c0 xor %eax,%eax
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
}
112c62: 8d 65 f4 lea -0xc(%ebp),%esp
112c65: 5b pop %ebx
112c66: 5e pop %esi
112c67: 5f pop %edi
112c68: c9 leave
112c69: c3 ret
0011321c <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
11321c: 55 push %ebp
11321d: 89 e5 mov %esp,%ebp
11321f: 53 push %ebx
113220: 8b 4d 08 mov 0x8(%ebp),%ecx
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
113223: 9c pushf
113224: fa cli
113225: 5a pop %edx
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
113226: 8d 04 49 lea (%ecx,%ecx,2),%eax
113229: c1 e0 02 shl $0x2,%eax
11322c: 83 b8 a0 83 12 00 02 cmpl $0x2,0x1283a0(%eax)
113233: 74 13 je 113248 <_POSIX_signals_Clear_process_signals+0x2c>
113235: 49 dec %ecx
113236: b8 fe ff ff ff mov $0xfffffffe,%eax
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
11323b: d3 c0 rol %cl,%eax
11323d: 21 05 a8 85 12 00 and %eax,0x1285a8
}
_ISR_Enable( level );
113243: 52 push %edx
113244: 9d popf
}
113245: 5b pop %ebx
113246: c9 leave
113247: c3 ret
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
113248: 8d 98 c4 85 12 00 lea 0x1285c4(%eax),%ebx
ISR_Level level;
_ISR_Disable( level );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
11324e: 39 98 c0 85 12 00 cmp %ebx,0x1285c0(%eax)
113254: 75 ed jne 113243 <_POSIX_signals_Clear_process_signals+0x27><== NEVER TAKEN
113256: eb dd jmp 113235 <_POSIX_signals_Clear_process_signals+0x19>
00112c6c <_POSIX_signals_Clear_signals>:
int signo,
siginfo_t *info,
bool is_global,
bool check_blocked
)
{
112c6c: 55 push %ebp
112c6d: 89 e5 mov %esp,%ebp
112c6f: 57 push %edi
112c70: 56 push %esi
112c71: 53 push %ebx
112c72: 83 ec 1c sub $0x1c,%esp
112c75: 8b 5d 0c mov 0xc(%ebp),%ebx
112c78: 0f b6 7d 14 movzbl 0x14(%ebp),%edi
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
112c7c: 8d 4b ff lea -0x1(%ebx),%ecx
112c7f: b8 01 00 00 00 mov $0x1,%eax
112c84: d3 e0 shl %cl,%eax
/* set blocked signals based on if checking for them, SIGNAL_ALL_MASK
* insures that no signals are blocked and all are checked.
*/
if ( check_blocked )
112c86: 80 7d 18 00 cmpb $0x0,0x18(%ebp)
112c8a: 74 40 je 112ccc <_POSIX_signals_Clear_signals+0x60>
signals_blocked = ~api->signals_blocked;
112c8c: 8b 55 08 mov 0x8(%ebp),%edx
112c8f: 8b 8a d0 00 00 00 mov 0xd0(%edx),%ecx
112c95: f7 d1 not %ecx
signals_blocked = SIGNAL_ALL_MASK;
/* XXX is this right for siginfo type signals? */
/* XXX are we sure they can be cleared the same way? */
_ISR_Disable( level );
112c97: 9c pushf
112c98: fa cli
112c99: 8f 45 e4 popl -0x1c(%ebp)
if ( is_global ) {
112c9c: 89 fa mov %edi,%edx
112c9e: 84 d2 test %dl,%dl
112ca0: 74 32 je 112cd4 <_POSIX_signals_Clear_signals+0x68>
if ( mask & (_POSIX_signals_Pending & signals_blocked) ) {
112ca2: 23 05 a8 85 12 00 and 0x1285a8,%eax
112ca8: 85 c8 test %ecx,%eax
112caa: 74 54 je 112d00 <_POSIX_signals_Clear_signals+0x94>
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
112cac: 8d 14 5b lea (%ebx,%ebx,2),%edx
112caf: c1 e2 02 shl $0x2,%edx
112cb2: 83 ba a0 83 12 00 02 cmpl $0x2,0x1283a0(%edx)
112cb9: 74 49 je 112d04 <_POSIX_signals_Clear_signals+0x98>
&psiginfo->Node
);
} else
do_callout = false;
}
_POSIX_signals_Clear_process_signals( signo );
112cbb: 83 ec 0c sub $0xc,%esp
112cbe: 53 push %ebx
112cbf: e8 58 05 00 00 call 11321c <_POSIX_signals_Clear_process_signals>
112cc4: 83 c4 10 add $0x10,%esp
do_callout = true;
112cc7: b0 01 mov $0x1,%al
112cc9: eb 26 jmp 112cf1 <_POSIX_signals_Clear_signals+0x85>
112ccb: 90 nop
*/
if ( check_blocked )
signals_blocked = ~api->signals_blocked;
else
signals_blocked = SIGNAL_ALL_MASK;
112ccc: b9 ff ff ff ff mov $0xffffffff,%ecx
112cd1: eb c4 jmp 112c97 <_POSIX_signals_Clear_signals+0x2b>
112cd3: 90 nop
}
_POSIX_signals_Clear_process_signals( signo );
do_callout = true;
}
} else {
if ( mask & (api->signals_pending & signals_blocked) ) {
112cd4: 8b 55 08 mov 0x8(%ebp),%edx
112cd7: 8b 9a d4 00 00 00 mov 0xd4(%edx),%ebx
112cdd: 89 c6 mov %eax,%esi
112cdf: 21 de and %ebx,%esi
112ce1: 85 ce test %ecx,%esi
112ce3: 74 1b je 112d00 <_POSIX_signals_Clear_signals+0x94>
api->signals_pending &= ~mask;
112ce5: f7 d0 not %eax
112ce7: 21 d8 and %ebx,%eax
112ce9: 89 82 d4 00 00 00 mov %eax,0xd4(%edx)
do_callout = true;
112cef: b0 01 mov $0x1,%al
}
}
_ISR_Enable( level );
112cf1: ff 75 e4 pushl -0x1c(%ebp)
112cf4: 9d popf
return do_callout;
}
112cf5: 8d 65 f4 lea -0xc(%ebp),%esp
112cf8: 5b pop %ebx
112cf9: 5e pop %esi
112cfa: 5f pop %edi
112cfb: c9 leave
112cfc: c3 ret
112cfd: 8d 76 00 lea 0x0(%esi),%esi
bool do_callout;
POSIX_signals_Siginfo_node *psiginfo;
mask = signo_to_mask( signo );
do_callout = false;
112d00: 31 c0 xor %eax,%eax
112d02: eb ed jmp 112cf1 <_POSIX_signals_Clear_signals+0x85>
do_callout = true;
}
}
_ISR_Enable( level );
return do_callout;
}
112d04: 8d 8a c0 85 12 00 lea 0x1285c0(%edx),%ecx
112d0a: 8b 82 c0 85 12 00 mov 0x1285c0(%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 );
112d10: 8d 71 04 lea 0x4(%ecx),%esi
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
112d13: 39 f0 cmp %esi,%eax
112d15: 74 45 je 112d5c <_POSIX_signals_Clear_signals+0xf0>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
112d17: 8b 30 mov (%eax),%esi
head->next = new_first;
112d19: 89 b2 c0 85 12 00 mov %esi,0x1285c0(%edx)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
112d1f: 89 4e 04 mov %ecx,0x4(%esi)
if ( is_global ) {
if ( mask & (_POSIX_signals_Pending & signals_blocked) ) {
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] );
_POSIX_signals_Clear_process_signals( signo );
112d22: 83 ec 0c sub $0xc,%esp
112d25: 53 push %ebx
112d26: 89 45 e0 mov %eax,-0x20(%ebp)
112d29: e8 ee 04 00 00 call 11321c <_POSIX_signals_Clear_process_signals>
* It may be impossible to get here with an empty chain
* BUT until that is proven we need to be defensive and
* protect against it.
*/
if ( psiginfo ) {
*info = psiginfo->Info;
112d2e: 8b 45 e0 mov -0x20(%ebp),%eax
112d31: 8d 70 08 lea 0x8(%eax),%esi
112d34: b9 03 00 00 00 mov $0x3,%ecx
112d39: 8b 7d 10 mov 0x10(%ebp),%edi
112d3c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
112d3e: 8b 15 28 85 12 00 mov 0x128528,%edx
the_node->next = tail;
112d44: c7 00 24 85 12 00 movl $0x128524,(%eax)
tail->previous = the_node;
112d4a: a3 28 85 12 00 mov %eax,0x128528
old_last->next = the_node;
112d4f: 89 02 mov %eax,(%edx)
the_node->previous = old_last;
112d51: 89 50 04 mov %edx,0x4(%eax)
112d54: 83 c4 10 add $0x10,%esp
112d57: e9 5f ff ff ff jmp 112cbb <_POSIX_signals_Clear_signals+0x4f>
if ( is_global ) {
if ( mask & (_POSIX_signals_Pending & signals_blocked) ) {
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] );
_POSIX_signals_Clear_process_signals( signo );
112d5c: 83 ec 0c sub $0xc,%esp
112d5f: 53 push %ebx
112d60: e8 b7 04 00 00 call 11321c <_POSIX_signals_Clear_process_signals>
112d65: 83 c4 10 add $0x10,%esp
112d68: e9 4e ff ff ff jmp 112cbb <_POSIX_signals_Clear_signals+0x4f>
0010c0dc <_POSIX_signals_Get_lowest>:
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
sigset_t set
)
{
10c0dc: 55 push %ebp
10c0dd: 89 e5 mov %esp,%ebp
10c0df: 56 push %esi
10c0e0: 53 push %ebx
10c0e1: 8b 55 08 mov 0x8(%ebp),%edx
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10c0e4: b8 1b 00 00 00 mov $0x1b,%eax
10c0e9: bb 01 00 00 00 mov $0x1,%ebx
#include <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
10c0ee: 8d 48 ff lea -0x1(%eax),%ecx
10c0f1: 89 de mov %ebx,%esi
10c0f3: d3 e6 shl %cl,%esi
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
10c0f5: 85 d6 test %edx,%esi
10c0f7: 75 20 jne 10c119 <_POSIX_signals_Get_lowest+0x3d><== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10c0f9: 40 inc %eax
10c0fa: 83 f8 20 cmp $0x20,%eax
10c0fd: 75 ef jne 10c0ee <_POSIX_signals_Get_lowest+0x12>
10c0ff: b0 01 mov $0x1,%al
10c101: bb 01 00 00 00 mov $0x1,%ebx
10c106: eb 06 jmp 10c10e <_POSIX_signals_Get_lowest+0x32>
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
10c108: 40 inc %eax
10c109: 83 f8 1b cmp $0x1b,%eax
10c10c: 74 0b je 10c119 <_POSIX_signals_Get_lowest+0x3d><== NEVER TAKEN
#include <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
10c10e: 8d 48 ff lea -0x1(%eax),%ecx
10c111: 89 de mov %ebx,%esi
10c113: d3 e6 shl %cl,%esi
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
10c115: 85 d6 test %edx,%esi
10c117: 74 ef je 10c108 <_POSIX_signals_Get_lowest+0x2c>
* a return 0. This routine will NOT be called unless a signal
* is pending in the set passed in.
*/
found_it:
return signo;
}
10c119: 5b pop %ebx
10c11a: 5e pop %esi
10c11b: c9 leave
10c11c: c3 ret
00124c6c <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
124c6c: 55 push %ebp
124c6d: 89 e5 mov %esp,%ebp
124c6f: 57 push %edi
124c70: 56 push %esi
124c71: 53 push %ebx
124c72: 83 ec 0c sub $0xc,%esp
124c75: 8b 5d 08 mov 0x8(%ebp),%ebx
124c78: 8b 55 0c mov 0xc(%ebp),%edx
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
124c7b: 8b b3 ec 00 00 00 mov 0xec(%ebx),%esi
124c81: 8d 4a ff lea -0x1(%edx),%ecx
124c84: b8 01 00 00 00 mov $0x1,%eax
124c89: d3 e0 shl %cl,%eax
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
124c8b: 8b 4b 10 mov 0x10(%ebx),%ecx
124c8e: 89 cf mov %ecx,%edi
124c90: 81 e7 00 80 00 10 and $0x10008000,%edi
124c96: 81 ff 00 80 00 10 cmp $0x10008000,%edi
124c9c: 74 72 je 124d10 <_POSIX_signals_Unblock_thread+0xa4>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
124c9e: 8b 96 d0 00 00 00 mov 0xd0(%esi),%edx
124ca4: f7 d2 not %edx
124ca6: 85 d0 test %edx,%eax
124ca8: 74 5a je 124d04 <_POSIX_signals_Unblock_thread+0x98>
* it is not blocked, THEN
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {
124caa: f7 c1 00 00 00 10 test $0x10000000,%ecx
124cb0: 74 3a je 124cec <_POSIX_signals_Unblock_thread+0x80>
the_thread->Wait.return_code = EINTR;
124cb2: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx)
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
124cb9: f7 c1 e0 be 03 00 test $0x3bee0,%ecx
124cbf: 0f 85 93 00 00 00 jne 124d58 <_POSIX_signals_Unblock_thread+0xec>
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
124cc5: 83 e1 08 and $0x8,%ecx
124cc8: 74 3a je 124d04 <_POSIX_signals_Unblock_thread+0x98><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
124cca: 83 ec 0c sub $0xc,%esp
124ccd: 8d 43 48 lea 0x48(%ebx),%eax
124cd0: 50 push %eax
124cd1: e8 b2 ec fe ff call 113988 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
124cd6: 5a pop %edx
124cd7: 59 pop %ecx
124cd8: 68 f8 ff 03 10 push $0x1003fff8
124cdd: 53 push %ebx
124cde: e8 91 da fe ff call 112774 <_Thread_Clear_state>
124ce3: 83 c4 10 add $0x10,%esp
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
124ce6: 31 c0 xor %eax,%eax
124ce8: eb 1c jmp 124d06 <_POSIX_signals_Unblock_thread+0x9a>
124cea: 66 90 xchg %ax,%ax
else if ( _States_Is_delaying(the_thread->current_state) ) {
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
124cec: 85 c9 test %ecx,%ecx
124cee: 75 14 jne 124d04 <_POSIX_signals_Unblock_thread+0x98><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
124cf0: a1 b4 f0 12 00 mov 0x12f0b4,%eax
124cf5: 85 c0 test %eax,%eax
124cf7: 74 0b je 124d04 <_POSIX_signals_Unblock_thread+0x98>
124cf9: 3b 1d b8 f0 12 00 cmp 0x12f0b8,%ebx
124cff: 74 7b je 124d7c <_POSIX_signals_Unblock_thread+0x110><== ALWAYS TAKEN
124d01: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Dispatch_necessary = true;
}
}
return false;
124d04: 31 c0 xor %eax,%eax
}
124d06: 8d 65 f4 lea -0xc(%ebp),%esp
124d09: 5b pop %ebx
124d0a: 5e pop %esi
124d0b: 5f pop %edi
124d0c: c9 leave
124d0d: c3 ret
124d0e: 66 90 xchg %ax,%ax
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
124d10: 85 43 30 test %eax,0x30(%ebx)
124d13: 74 33 je 124d48 <_POSIX_signals_Unblock_thread+0xdc>
the_thread->Wait.return_code = EINTR;
124d15: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx)
the_info = (siginfo_t *) the_thread->Wait.return_argument;
124d1c: 8b 43 28 mov 0x28(%ebx),%eax
if ( !info ) {
124d1f: 8b 75 10 mov 0x10(%ebp),%esi
124d22: 85 f6 test %esi,%esi
124d24: 74 42 je 124d68 <_POSIX_signals_Unblock_thread+0xfc>
the_info->si_signo = signo;
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
} else {
*the_info = *info;
124d26: b9 03 00 00 00 mov $0x3,%ecx
124d2b: 89 c7 mov %eax,%edi
124d2d: 8b 75 10 mov 0x10(%ebp),%esi
124d30: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
_Thread_queue_Extract_with_proxy( the_thread );
124d32: 83 ec 0c sub $0xc,%esp
124d35: 53 push %ebx
124d36: e8 51 e4 fe ff call 11318c <_Thread_queue_Extract_with_proxy>
return true;
124d3b: 83 c4 10 add $0x10,%esp
124d3e: b0 01 mov $0x1,%al
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
}
124d40: 8d 65 f4 lea -0xc(%ebp),%esp
124d43: 5b pop %ebx
124d44: 5e pop %esi
124d45: 5f pop %edi
124d46: c9 leave
124d47: c3 ret
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
124d48: 8b 8e d0 00 00 00 mov 0xd0(%esi),%ecx
124d4e: f7 d1 not %ecx
124d50: 85 c8 test %ecx,%eax
124d52: 75 c1 jne 124d15 <_POSIX_signals_Unblock_thread+0xa9>
124d54: eb ae jmp 124d04 <_POSIX_signals_Unblock_thread+0x98>
124d56: 66 90 xchg %ax,%ax
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
_Thread_queue_Extract_with_proxy( the_thread );
124d58: 83 ec 0c sub $0xc,%esp
124d5b: 53 push %ebx
124d5c: e8 2b e4 fe ff call 11318c <_Thread_queue_Extract_with_proxy>
124d61: 83 c4 10 add $0x10,%esp
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
124d64: 31 c0 xor %eax,%eax
124d66: eb 9e jmp 124d06 <_POSIX_signals_Unblock_thread+0x9a>
the_thread->Wait.return_code = EINTR;
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
124d68: 89 10 mov %edx,(%eax)
the_info->si_code = SI_USER;
124d6a: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
the_info->si_value.sival_int = 0;
124d71: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
124d78: eb b8 jmp 124d32 <_POSIX_signals_Unblock_thread+0xc6>
124d7a: 66 90 xchg %ax,%ax
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
124d7c: c6 05 c4 f0 12 00 01 movb $0x1,0x12f0c4
}
}
return false;
124d83: 31 c0 xor %eax,%eax
124d85: e9 7c ff ff ff jmp 124d06 <_POSIX_signals_Unblock_thread+0x9a>
0010d848 <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
10d848: 55 push %ebp
10d849: 89 e5 mov %esp,%ebp
10d84b: 56 push %esi
10d84c: 53 push %ebx
10d84d: 8b 5d 08 mov 0x8(%ebp),%ebx
10d850: 8b 75 0c mov 0xc(%ebp),%esi
if ( !the_heap )
10d853: 85 db test %ebx,%ebx
10d855: 74 35 je 10d88c <_Protected_heap_Get_information+0x44>
return false;
if ( !the_info )
10d857: 85 f6 test %esi,%esi
10d859: 74 31 je 10d88c <_Protected_heap_Get_information+0x44>
return false;
_RTEMS_Lock_allocator();
10d85b: 83 ec 0c sub $0xc,%esp
10d85e: ff 35 40 88 12 00 pushl 0x128840
10d864: e8 e7 ed ff ff call 10c650 <_API_Mutex_Lock>
_Heap_Get_information( the_heap, the_info );
10d869: 5a pop %edx
10d86a: 59 pop %ecx
10d86b: 56 push %esi
10d86c: 53 push %ebx
10d86d: e8 d2 47 00 00 call 112044 <_Heap_Get_information>
_RTEMS_Unlock_allocator();
10d872: 58 pop %eax
10d873: ff 35 40 88 12 00 pushl 0x128840
10d879: e8 1a ee ff ff call 10c698 <_API_Mutex_Unlock>
return true;
10d87e: 83 c4 10 add $0x10,%esp
10d881: b0 01 mov $0x1,%al
}
10d883: 8d 65 f8 lea -0x8(%ebp),%esp
10d886: 5b pop %ebx
10d887: 5e pop %esi
10d888: c9 leave
10d889: c3 ret
10d88a: 66 90 xchg %ax,%ax
{
if ( !the_heap )
return false;
if ( !the_info )
return false;
10d88c: 31 c0 xor %eax,%eax
_RTEMS_Lock_allocator();
_Heap_Get_information( the_heap, the_info );
_RTEMS_Unlock_allocator();
return true;
}
10d88e: 8d 65 f8 lea -0x8(%ebp),%esp
10d891: 5b pop %ebx
10d892: 5e pop %esi
10d893: c9 leave
10d894: c3 ret
00110c04 <_Protected_heap_Walk>:
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
110c04: 55 push %ebp
110c05: 89 e5 mov %esp,%ebp
110c07: 56 push %esi
110c08: 53 push %ebx
110c09: 83 ec 10 sub $0x10,%esp
110c0c: 8b 5d 08 mov 0x8(%ebp),%ebx
110c0f: 8b 75 0c mov 0xc(%ebp),%esi
110c12: 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 ) {
110c15: 8b 15 d0 f2 12 00 mov 0x12f2d0,%edx
110c1b: 85 d2 test %edx,%edx
110c1d: 74 19 je 110c38 <_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 );
110c1f: 0f b6 c0 movzbl %al,%eax
110c22: 89 45 10 mov %eax,0x10(%ebp)
110c25: 89 75 0c mov %esi,0xc(%ebp)
110c28: 89 5d 08 mov %ebx,0x8(%ebp)
}
return status;
}
110c2b: 8d 65 f8 lea -0x8(%ebp),%esp
110c2e: 5b pop %ebx
110c2f: 5e pop %esi
110c30: 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 );
110c31: e9 32 f2 ff ff jmp 10fe68 <_Heap_Walk>
110c36: 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();
110c38: 83 ec 0c sub $0xc,%esp
110c3b: ff 35 80 f3 12 00 pushl 0x12f380
110c41: 88 45 f4 mov %al,-0xc(%ebp)
110c44: e8 bf e3 ff ff call 10f008 <_API_Mutex_Lock>
status = _Heap_Walk( the_heap, source, do_dump );
110c49: 83 c4 0c add $0xc,%esp
110c4c: 8a 45 f4 mov -0xc(%ebp),%al
110c4f: 0f b6 c0 movzbl %al,%eax
110c52: 50 push %eax
110c53: 56 push %esi
110c54: 53 push %ebx
110c55: e8 0e f2 ff ff call 10fe68 <_Heap_Walk>
_RTEMS_Unlock_allocator();
110c5a: 5a pop %edx
110c5b: ff 35 80 f3 12 00 pushl 0x12f380
110c61: 88 45 f4 mov %al,-0xc(%ebp)
110c64: e8 e7 e3 ff ff call 10f050 <_API_Mutex_Unlock>
110c69: 83 c4 10 add $0x10,%esp
} else {
status = _Heap_Walk( the_heap, source, do_dump );
}
return status;
}
110c6c: 8a 45 f4 mov -0xc(%ebp),%al
110c6f: 8d 65 f8 lea -0x8(%ebp),%esp
110c72: 5b pop %ebx
110c73: 5e pop %esi
110c74: c9 leave
110c75: c3 ret
00110e94 <_RTEMS_tasks_Create_extension>:
bool _RTEMS_tasks_Create_extension(
Thread_Control *executing,
Thread_Control *created
)
{
110e94: 55 push %ebp
110e95: 89 e5 mov %esp,%ebp
110e97: 53 push %ebx
110e98: 83 ec 10 sub $0x10,%esp
110e9b: 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 );
110e9e: 80 3d 44 3a 12 00 01 cmpb $0x1,0x123a44
110ea5: 19 c0 sbb %eax,%eax
110ea7: 83 e0 c0 and $0xffffffc0,%eax
110eaa: 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 );
110ead: 50 push %eax
110eae: e8 d5 da ff ff call 10e988 <_Workspace_Allocate>
if ( !api )
110eb3: 83 c4 10 add $0x10,%esp
110eb6: 85 c0 test %eax,%eax
110eb8: 74 6a je 110f24 <_RTEMS_tasks_Create_extension+0x90>
return false;
created->API_Extensions[ THREAD_API_RTEMS ] = api;
110eba: 89 83 e8 00 00 00 mov %eax,0xe8(%ebx)
api->pending_events = EVENT_SETS_NONE_PENDING;
110ec0: c7 00 00 00 00 00 movl $0x0,(%eax)
api->event_condition = 0;
110ec6: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
*/
RTEMS_INLINE_ROUTINE void _ASR_Initialize (
ASR_Information *information
)
{
information->is_enabled = false;
110ecd: c6 40 08 00 movb $0x0,0x8(%eax)
information->handler = NULL;
110ed1: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
information->mode_set = RTEMS_DEFAULT_MODES;
110ed8: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
information->signals_posted = 0;
110edf: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax)
information->signals_pending = 0;
110ee6: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
information->nest_level = 0;
110eed: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
_ASR_Initialize( &api->Signal );
created->task_variables = NULL;
110ef4: c7 83 f4 00 00 00 00 movl $0x0,0xf4(%ebx)
110efb: 00 00 00
if ( rtems_configuration_get_notepads_enabled() ) {
110efe: 80 3d 44 3a 12 00 00 cmpb $0x0,0x123a44
110f05: 74 13 je 110f1a <_RTEMS_tasks_Create_extension+0x86>
110f07: 31 d2 xor %edx,%edx
110f09: 8d 76 00 lea 0x0(%esi),%esi
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
api->Notepads[i] = 0;
110f0c: c7 44 90 20 00 00 00 movl $0x0,0x20(%eax,%edx,4)
110f13: 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++)
110f14: 42 inc %edx
110f15: 83 fa 10 cmp $0x10,%edx
110f18: 75 f2 jne 110f0c <_RTEMS_tasks_Create_extension+0x78>
api->Notepads[i] = 0;
}
return true;
110f1a: b0 01 mov $0x1,%al
}
110f1c: 8b 5d fc mov -0x4(%ebp),%ebx
110f1f: c9 leave
110f20: c3 ret
110f21: 8d 76 00 lea 0x0(%esi),%esi
to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));
api = _Workspace_Allocate( to_allocate );
if ( !api )
return false;
110f24: 31 c0 xor %eax,%eax
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
api->Notepads[i] = 0;
}
return true;
}
110f26: 8b 5d fc mov -0x4(%ebp),%ebx
110f29: c9 leave
110f2a: c3 ret
00110e3c <_RTEMS_tasks_Delete_extension>:
void _RTEMS_tasks_Delete_extension(
Thread_Control *executing,
Thread_Control *deleted
)
{
110e3c: 55 push %ebp
110e3d: 89 e5 mov %esp,%ebp
110e3f: 56 push %esi
110e40: 53 push %ebx
110e41: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
110e44: 8b 86 f4 00 00 00 mov 0xf4(%esi),%eax
deleted->task_variables = NULL;
110e4a: c7 86 f4 00 00 00 00 movl $0x0,0xf4(%esi)
110e51: 00 00 00
while (tvp) {
110e54: 85 c0 test %eax,%eax
110e56: 75 06 jne 110e5e <_RTEMS_tasks_Delete_extension+0x22>
110e58: eb 17 jmp 110e71 <_RTEMS_tasks_Delete_extension+0x35>
110e5a: 66 90 xchg %ax,%ax
next = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
tvp = next;
110e5c: 89 d8 mov %ebx,%eax
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
next = (rtems_task_variable_t *)tvp->next;
110e5e: 8b 18 mov (%eax),%ebx
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
110e60: 83 ec 08 sub $0x8,%esp
110e63: 50 push %eax
110e64: 56 push %esi
110e65: e8 56 01 00 00 call 110fc0 <_RTEMS_Tasks_Invoke_task_variable_dtor>
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
110e6a: 83 c4 10 add $0x10,%esp
110e6d: 85 db test %ebx,%ebx
110e6f: 75 eb jne 110e5c <_RTEMS_tasks_Delete_extension+0x20>
/*
* Free API specific memory
*/
(void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] );
110e71: 83 ec 0c sub $0xc,%esp
110e74: ff b6 e8 00 00 00 pushl 0xe8(%esi)
110e7a: e8 25 db ff ff call 10e9a4 <_Workspace_Free>
deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL;
110e7f: c7 86 e8 00 00 00 00 movl $0x0,0xe8(%esi)
110e86: 00 00 00
110e89: 83 c4 10 add $0x10,%esp
}
110e8c: 8d 65 f8 lea -0x8(%ebp),%esp
110e8f: 5b pop %ebx
110e90: 5e pop %esi
110e91: c9 leave
110e92: c3 ret
00110dc0 <_RTEMS_tasks_Initialize_user_tasks>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks( void )
{
110dc0: 55 push %ebp
110dc1: 89 e5 mov %esp,%ebp
110dc3: 83 ec 08 sub $0x8,%esp
if ( _RTEMS_tasks_Initialize_user_tasks_p )
110dc6: a1 c0 3a 12 00 mov 0x123ac0,%eax
110dcb: 85 c0 test %eax,%eax
110dcd: 74 05 je 110dd4 <_RTEMS_tasks_Initialize_user_tasks+0x14>
(*_RTEMS_tasks_Initialize_user_tasks_p)();
}
110dcf: c9 leave
*/
void _RTEMS_tasks_Initialize_user_tasks( void )
{
if ( _RTEMS_tasks_Initialize_user_tasks_p )
(*_RTEMS_tasks_Initialize_user_tasks_p)();
110dd0: ff e0 jmp *%eax
110dd2: 66 90 xchg %ax,%ax
}
110dd4: c9 leave
110dd5: c3 ret
0010ba80 <_RTEMS_tasks_Initialize_user_tasks_body>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
10ba80: 55 push %ebp
10ba81: 89 e5 mov %esp,%ebp
10ba83: 57 push %edi
10ba84: 56 push %esi
10ba85: 53 push %ebx
10ba86: 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;
10ba89: 8b 1d 6c 3a 12 00 mov 0x123a6c,%ebx
maximum = Configuration_RTEMS_API.number_of_initialization_tasks;
10ba8f: 8b 3d 68 3a 12 00 mov 0x123a68,%edi
/*
* Verify that we have a set of user tasks to iterate
*/
if ( !user_tasks )
10ba95: 85 db test %ebx,%ebx
10ba97: 74 46 je 10badf <_RTEMS_tasks_Initialize_user_tasks_body+0x5f>
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
10ba99: 85 ff test %edi,%edi
10ba9b: 74 42 je 10badf <_RTEMS_tasks_Initialize_user_tasks_body+0x5f><== NEVER TAKEN
10ba9d: 31 f6 xor %esi,%esi
10ba9f: 90 nop
return_value = rtems_task_create(
10baa0: 83 ec 08 sub $0x8,%esp
10baa3: 8d 45 e4 lea -0x1c(%ebp),%eax
10baa6: 50 push %eax
10baa7: ff 73 0c pushl 0xc(%ebx)
10baaa: ff 73 14 pushl 0x14(%ebx)
10baad: ff 73 04 pushl 0x4(%ebx)
10bab0: ff 73 08 pushl 0x8(%ebx)
10bab3: ff 33 pushl (%ebx)
10bab5: e8 92 fd ff ff call 10b84c <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 ) )
10baba: 83 c4 20 add $0x20,%esp
10babd: 85 c0 test %eax,%eax
10babf: 75 26 jne 10bae7 <_RTEMS_tasks_Initialize_user_tasks_body+0x67>
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value );
return_value = rtems_task_start(
10bac1: 51 push %ecx
10bac2: ff 73 18 pushl 0x18(%ebx)
10bac5: ff 73 10 pushl 0x10(%ebx)
10bac8: ff 75 e4 pushl -0x1c(%ebp)
10bacb: e8 24 00 00 00 call 10baf4 <rtems_task_start>
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
10bad0: 83 c4 10 add $0x10,%esp
10bad3: 85 c0 test %eax,%eax
10bad5: 75 10 jne 10bae7 <_RTEMS_tasks_Initialize_user_tasks_body+0x67>
return;
/*
* Now iterate over the initialization tasks and create/start them.
*/
for ( index=0 ; index < maximum ; index++ ) {
10bad7: 46 inc %esi
10bad8: 83 c3 1c add $0x1c,%ebx
10badb: 39 f7 cmp %esi,%edi
10badd: 77 c1 ja 10baa0 <_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 );
}
}
10badf: 8d 65 f4 lea -0xc(%ebp),%esp
10bae2: 5b pop %ebx
10bae3: 5e pop %esi
10bae4: 5f pop %edi
10bae5: c9 leave
10bae6: 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 );
10bae7: 52 push %edx
10bae8: 50 push %eax
10bae9: 6a 01 push $0x1
10baeb: 6a 01 push $0x1
10baed: e8 02 0e 00 00 call 10c8f4 <_Internal_error_Occurred>
00110d78 <_RTEMS_tasks_Switch_extension>:
void _RTEMS_tasks_Switch_extension(
Thread_Control *executing,
Thread_Control *heir
)
{
110d78: 55 push %ebp
110d79: 89 e5 mov %esp,%ebp
/*
* Per Task Variables
*/
tvp = executing->task_variables;
110d7b: 8b 45 08 mov 0x8(%ebp),%eax
110d7e: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
while (tvp) {
110d84: 85 c0 test %eax,%eax
110d86: 74 13 je 110d9b <_RTEMS_tasks_Switch_extension+0x23>
tvp->tval = *tvp->ptr;
110d88: 8b 50 04 mov 0x4(%eax),%edx
110d8b: 8b 0a mov (%edx),%ecx
110d8d: 89 48 0c mov %ecx,0xc(%eax)
*tvp->ptr = tvp->gval;
110d90: 8b 48 08 mov 0x8(%eax),%ecx
110d93: 89 0a mov %ecx,(%edx)
tvp = (rtems_task_variable_t *)tvp->next;
110d95: 8b 00 mov (%eax),%eax
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
110d97: 85 c0 test %eax,%eax
110d99: 75 ed jne 110d88 <_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;
110d9b: 8b 45 0c mov 0xc(%ebp),%eax
110d9e: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
while (tvp) {
110da4: 85 c0 test %eax,%eax
110da6: 74 13 je 110dbb <_RTEMS_tasks_Switch_extension+0x43>
tvp->gval = *tvp->ptr;
110da8: 8b 50 04 mov 0x4(%eax),%edx
110dab: 8b 0a mov (%edx),%ecx
110dad: 89 48 08 mov %ecx,0x8(%eax)
*tvp->ptr = tvp->tval;
110db0: 8b 48 0c mov 0xc(%eax),%ecx
110db3: 89 0a mov %ecx,(%edx)
tvp = (rtems_task_variable_t *)tvp->next;
110db5: 8b 00 mov (%eax),%eax
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
110db7: 85 c0 test %eax,%eax
110db9: 75 ed jne 110da8 <_RTEMS_tasks_Switch_extension+0x30><== NEVER TAKEN
tvp->gval = *tvp->ptr;
*tvp->ptr = tvp->tval;
tvp = (rtems_task_variable_t *)tvp->next;
}
}
110dbb: c9 leave
110dbc: c3 ret
0010c4f0 <_Rate_monotonic_Initiate_statistics>:
}
void _Rate_monotonic_Initiate_statistics(
Rate_monotonic_Control *the_period
)
{
10c4f0: 55 push %ebp
10c4f1: 89 e5 mov %esp,%ebp
10c4f3: 57 push %edi
10c4f4: 56 push %esi
10c4f5: 53 push %ebx
10c4f6: 83 ec 28 sub $0x28,%esp
10c4f9: 8b 5d 08 mov 0x8(%ebp),%ebx
Thread_Control *owning_thread = the_period->owner;
10c4fc: 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 );
10c4ff: 8d 7d e0 lea -0x20(%ebp),%edi
10c502: 57 push %edi
10c503: e8 98 18 00 00 call 10dda0 <_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;
10c508: 8b 45 e0 mov -0x20(%ebp),%eax
10c50b: 8b 55 e4 mov -0x1c(%ebp),%edx
10c50e: 89 43 4c mov %eax,0x4c(%ebx)
10c511: 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;
10c514: 8b 86 84 00 00 00 mov 0x84(%esi),%eax
10c51a: 8b 96 88 00 00 00 mov 0x88(%esi),%edx
10c520: 89 43 44 mov %eax,0x44(%ebx)
10c523: 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) {
10c526: 83 c4 10 add $0x10,%esp
10c529: 39 35 f8 b6 12 00 cmp %esi,0x12b6f8
10c52f: 74 0b je 10c53c <_Rate_monotonic_Initiate_statistics+0x4c>
);
_Timespec_Add_to( &the_period->cpu_usage_period_initiated, &ran );
}
#endif
}
10c531: 8d 65 f4 lea -0xc(%ebp),%esp
10c534: 5b pop %ebx
10c535: 5e pop %esi
10c536: 5f pop %edi
10c537: c9 leave
10c538: c3 ret
10c539: 8d 76 00 lea 0x0(%esi),%esi
/*
* Adjust the CPU time used to account for the time since last
* context switch.
*/
_Timespec_Subtract(
10c53c: 50 push %eax
&_Thread_Time_of_last_context_switch, &uptime, &ran
10c53d: 8d 75 d8 lea -0x28(%ebp),%esi
/*
* Adjust the CPU time used to account for the time since last
* context switch.
*/
_Timespec_Subtract(
10c540: 56 push %esi
10c541: 57 push %edi
10c542: 68 0c b2 12 00 push $0x12b20c
10c547: e8 f0 39 00 00 call 10ff3c <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch, &uptime, &ran
);
_Timespec_Add_to( &the_period->cpu_usage_period_initiated, &ran );
10c54c: 59 pop %ecx
10c54d: 5f pop %edi
10c54e: 56 push %esi
10c54f: 83 c3 44 add $0x44,%ebx
10c552: 53 push %ebx
10c553: e8 e8 38 00 00 call 10fe40 <_Timespec_Add_to>
10c558: 83 c4 10 add $0x10,%esp
}
#endif
}
10c55b: 8d 65 f4 lea -0xc(%ebp),%esp
10c55e: 5b pop %ebx
10c55f: 5e pop %esi
10c560: 5f pop %edi
10c561: c9 leave
10c562: c3 ret
0010caac <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
10caac: 55 push %ebp
10caad: 89 e5 mov %esp,%ebp
10caaf: 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 );
10cab2: 8d 45 f4 lea -0xc(%ebp),%eax
10cab5: 50 push %eax
10cab6: ff 75 08 pushl 0x8(%ebp)
10cab9: 68 60 b0 12 00 push $0x12b060
10cabe: e8 71 1d 00 00 call 10e834 <_Objects_Get>
switch ( location ) {
10cac3: 83 c4 10 add $0x10,%esp
10cac6: 8b 55 f4 mov -0xc(%ebp),%edx
10cac9: 85 d2 test %edx,%edx
10cacb: 75 29 jne 10caf6 <_Rate_monotonic_Timeout+0x4a><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
10cacd: 8b 50 40 mov 0x40(%eax),%edx
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
10cad0: f6 42 11 40 testb $0x40,0x11(%edx)
10cad4: 74 08 je 10cade <_Rate_monotonic_Timeout+0x32>
10cad6: 8b 48 08 mov 0x8(%eax),%ecx
10cad9: 39 4a 20 cmp %ecx,0x20(%edx)
10cadc: 74 4e je 10cb2c <_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 ) {
10cade: 83 78 38 01 cmpl $0x1,0x38(%eax)
10cae2: 74 14 je 10caf8 <_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;
10cae4: 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;
10caeb: a1 50 b1 12 00 mov 0x12b150,%eax
10caf0: 48 dec %eax
10caf1: a3 50 b1 12 00 mov %eax,0x12b150
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10caf6: c9 leave
10caf7: 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;
10caf8: c7 40 38 03 00 00 00 movl $0x3,0x38(%eax)
_Rate_monotonic_Initiate_statistics( the_period );
10caff: 83 ec 0c sub $0xc,%esp
10cb02: 50 push %eax
10cb03: 89 45 e4 mov %eax,-0x1c(%ebp)
10cb06: e8 e5 f9 ff ff call 10c4f0 <_Rate_monotonic_Initiate_statistics>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10cb0b: 8b 45 e4 mov -0x1c(%ebp),%eax
10cb0e: 8b 50 3c mov 0x3c(%eax),%edx
10cb11: 89 50 1c mov %edx,0x1c(%eax)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10cb14: 5a pop %edx
10cb15: 59 pop %ecx
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
10cb16: 83 c0 10 add $0x10,%eax
10cb19: 50 push %eax
10cb1a: 68 20 b2 12 00 push $0x12b220
10cb1f: e8 f8 36 00 00 call 11021c <_Watchdog_Insert>
10cb24: 83 c4 10 add $0x10,%esp
10cb27: eb c2 jmp 10caeb <_Rate_monotonic_Timeout+0x3f>
10cb29: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10cb2c: 83 ec 08 sub $0x8,%esp
10cb2f: 68 f8 ff 03 10 push $0x1003fff8
10cb34: 52 push %edx
10cb35: 89 45 e4 mov %eax,-0x1c(%ebp)
10cb38: e8 0b 25 00 00 call 10f048 <_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 );
10cb3d: 8b 45 e4 mov -0x1c(%ebp),%eax
10cb40: 89 04 24 mov %eax,(%esp)
10cb43: eb c1 jmp 10cb06 <_Rate_monotonic_Timeout+0x5a>
0010c564 <_Rate_monotonic_Update_statistics>:
void _Rate_monotonic_Update_statistics(
Rate_monotonic_Control *the_period
)
{
10c564: 55 push %ebp
10c565: 89 e5 mov %esp,%ebp
10c567: 57 push %edi
10c568: 56 push %esi
10c569: 53 push %ebx
10c56a: 83 ec 1c sub $0x1c,%esp
10c56d: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
10c570: ff 43 54 incl 0x54(%ebx)
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
10c573: 83 7b 38 04 cmpl $0x4,0x38(%ebx)
10c577: 0f 84 bf 00 00 00 je 10c63c <_Rate_monotonic_Update_statistics+0xd8>
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
10c57d: 51 push %ecx
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
10c57e: 8d 7d e0 lea -0x20(%ebp),%edi
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
10c581: 57 push %edi
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
10c582: 8d 75 d8 lea -0x28(%ebp),%esi
stats->missed_count++;
/*
* Grab status for time statistics.
*/
valid_status =
10c585: 56 push %esi
10c586: 53 push %ebx
10c587: e8 cc fe ff ff call 10c458 <_Rate_monotonic_Get_status>
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
if (!valid_status)
10c58c: 83 c4 10 add $0x10,%esp
10c58f: 84 c0 test %al,%al
10c591: 75 09 jne 10c59c <_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
}
10c593: 8d 65 f4 lea -0xc(%ebp),%esp
10c596: 5b pop %ebx
10c597: 5e pop %esi
10c598: 5f pop %edi
10c599: c9 leave
10c59a: c3 ret
10c59b: 90 nop
/*
* Update CPU time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_cpu_time, &executed );
10c59c: 83 ec 08 sub $0x8,%esp
10c59f: 57 push %edi
10c5a0: 8d 43 6c lea 0x6c(%ebx),%eax
10c5a3: 50 push %eax
10c5a4: e8 97 38 00 00 call 10fe40 <_Timespec_Add_to>
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
10c5a9: 58 pop %eax
10c5aa: 5a pop %edx
10c5ab: 8d 43 5c lea 0x5c(%ebx),%eax
10c5ae: 50 push %eax
10c5af: 57 push %edi
10c5b0: e8 63 39 00 00 call 10ff18 <_Timespec_Less_than>
10c5b5: 83 c4 10 add $0x10,%esp
10c5b8: 84 c0 test %al,%al
10c5ba: 74 0c je 10c5c8 <_Rate_monotonic_Update_statistics+0x64>
stats->min_cpu_time = executed;
10c5bc: 8b 45 e0 mov -0x20(%ebp),%eax
10c5bf: 8b 55 e4 mov -0x1c(%ebp),%edx
10c5c2: 89 43 5c mov %eax,0x5c(%ebx)
10c5c5: 89 53 60 mov %edx,0x60(%ebx)
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
10c5c8: 83 ec 08 sub $0x8,%esp
10c5cb: 8d 43 64 lea 0x64(%ebx),%eax
10c5ce: 50 push %eax
10c5cf: 57 push %edi
10c5d0: e8 1f 39 00 00 call 10fef4 <_Timespec_Greater_than>
10c5d5: 83 c4 10 add $0x10,%esp
10c5d8: 84 c0 test %al,%al
10c5da: 74 0c je 10c5e8 <_Rate_monotonic_Update_statistics+0x84>
stats->max_cpu_time = executed;
10c5dc: 8b 45 e0 mov -0x20(%ebp),%eax
10c5df: 8b 55 e4 mov -0x1c(%ebp),%edx
10c5e2: 89 43 64 mov %eax,0x64(%ebx)
10c5e5: 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 );
10c5e8: 83 ec 08 sub $0x8,%esp
10c5eb: 56 push %esi
10c5ec: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax
10c5f2: 50 push %eax
10c5f3: e8 48 38 00 00 call 10fe40 <_Timespec_Add_to>
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
10c5f8: 5a pop %edx
10c5f9: 59 pop %ecx
10c5fa: 8d 43 74 lea 0x74(%ebx),%eax
10c5fd: 50 push %eax
10c5fe: 56 push %esi
10c5ff: e8 14 39 00 00 call 10ff18 <_Timespec_Less_than>
10c604: 83 c4 10 add $0x10,%esp
10c607: 84 c0 test %al,%al
10c609: 75 39 jne 10c644 <_Rate_monotonic_Update_statistics+0xe0>
stats->min_wall_time = since_last_period;
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
10c60b: 83 ec 08 sub $0x8,%esp
10c60e: 8d 43 7c lea 0x7c(%ebx),%eax
10c611: 50 push %eax
10c612: 56 push %esi
10c613: e8 dc 38 00 00 call 10fef4 <_Timespec_Greater_than>
10c618: 83 c4 10 add $0x10,%esp
10c61b: 84 c0 test %al,%al
10c61d: 0f 84 70 ff ff ff je 10c593 <_Rate_monotonic_Update_statistics+0x2f>
stats->max_wall_time = since_last_period;
10c623: 8b 45 d8 mov -0x28(%ebp),%eax
10c626: 8b 55 dc mov -0x24(%ebp),%edx
10c629: 89 43 7c mov %eax,0x7c(%ebx)
10c62c: 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
}
10c632: 8d 65 f4 lea -0xc(%ebp),%esp
10c635: 5b pop %ebx
10c636: 5e pop %esi
10c637: 5f pop %edi
10c638: c9 leave
10c639: c3 ret
10c63a: 66 90 xchg %ax,%ax
*/
stats = &the_period->Statistics;
stats->count++;
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
stats->missed_count++;
10c63c: ff 43 58 incl 0x58(%ebx)
10c63f: e9 39 ff ff ff jmp 10c57d <_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;
10c644: 8b 45 d8 mov -0x28(%ebp),%eax
10c647: 8b 55 dc mov -0x24(%ebp),%edx
10c64a: 89 43 74 mov %eax,0x74(%ebx)
10c64d: 89 53 78 mov %edx,0x78(%ebx)
10c650: eb b9 jmp 10c60b <_Rate_monotonic_Update_statistics+0xa7>
0010d18c <_Scheduler_priority_Block>:
#include <rtems/score/thread.h>
void _Scheduler_priority_Block(
Thread_Control *the_thread
)
{
10d18c: 55 push %ebp
10d18d: 89 e5 mov %esp,%ebp
10d18f: 53 push %ebx
10d190: 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;
10d193: 8b 88 8c 00 00 00 mov 0x8c(%eax),%ecx
ready = sched_info->ready_chain;
10d199: 8b 11 mov (%ecx),%edx
if ( _Chain_Has_only_one_node( ready ) ) {
10d19b: 8b 5a 08 mov 0x8(%edx),%ebx
10d19e: 39 1a cmp %ebx,(%edx)
10d1a0: 74 6e je 10d210 <_Scheduler_priority_Block+0x84>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10d1a2: 8b 08 mov (%eax),%ecx
previous = the_node->previous;
10d1a4: 8b 50 04 mov 0x4(%eax),%edx
next->previous = previous;
10d1a7: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
10d1aa: 89 0a mov %ecx,(%edx)
_Scheduler_priority_Ready_queue_extract( the_thread );
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
10d1ac: 3b 05 3c 83 12 00 cmp 0x12833c,%eax
10d1b2: 74 18 je 10d1cc <_Scheduler_priority_Block+0x40>
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
10d1b4: 3b 05 38 83 12 00 cmp 0x128338,%eax
10d1ba: 74 04 je 10d1c0 <_Scheduler_priority_Block+0x34>
_Thread_Dispatch_necessary = true;
}
10d1bc: 5b pop %ebx
10d1bd: c9 leave
10d1be: c3 ret
10d1bf: 90 nop
if ( _Thread_Is_heir( the_thread ) )
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
10d1c0: c6 05 44 83 12 00 01 movb $0x1,0x128344
}
10d1c7: 5b pop %ebx
10d1c8: c9 leave
10d1c9: c3 ret
10d1ca: 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 );
10d1cc: 66 8b 1d 60 83 12 00 mov 0x128360,%bx
10d1d3: 31 d2 xor %edx,%edx
10d1d5: 89 d1 mov %edx,%ecx
10d1d7: 66 0f bc cb bsf %bx,%cx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10d1db: 0f b7 c9 movzwl %cx,%ecx
10d1de: 66 8b 9c 09 80 83 12 mov 0x128380(%ecx,%ecx,1),%bx
10d1e5: 00
10d1e6: 66 0f bc d3 bsf %bx,%dx
return (_Priority_Bits_index( major ) << 4) +
10d1ea: c1 e1 04 shl $0x4,%ecx
10d1ed: 0f b7 d2 movzwl %dx,%edx
10d1f0: 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 ] ) )
10d1f3: 8d 14 52 lea (%edx,%edx,2),%edx
10d1f6: c1 e2 02 shl $0x2,%edx
10d1f9: 03 15 80 39 12 00 add 0x123980,%edx
10d1ff: 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 );
10d201: 83 c2 04 add $0x4,%edx
10d204: 39 d1 cmp %edx,%ecx
10d206: 74 44 je 10d24c <_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(
10d208: 89 0d 3c 83 12 00 mov %ecx,0x12833c
10d20e: eb a4 jmp 10d1b4 <_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 );
10d210: 8d 5a 04 lea 0x4(%edx),%ebx
10d213: 89 1a mov %ebx,(%edx)
head->next = tail;
head->previous = NULL;
10d215: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
tail->previous = head;
10d21c: 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;
10d21f: 8b 59 04 mov 0x4(%ecx),%ebx
10d222: 66 8b 13 mov (%ebx),%dx
10d225: 66 23 51 0e and 0xe(%ecx),%dx
10d229: 66 89 13 mov %dx,(%ebx)
if ( *the_priority_map->minor == 0 )
10d22c: 66 85 d2 test %dx,%dx
10d22f: 0f 85 77 ff ff ff jne 10d1ac <_Scheduler_priority_Block+0x20>
_Priority_Major_bit_map &= the_priority_map->block_major;
10d235: 66 8b 15 60 83 12 00 mov 0x128360,%dx
10d23c: 23 51 0c and 0xc(%ecx),%edx
10d23f: 66 89 15 60 83 12 00 mov %dx,0x128360
10d246: e9 61 ff ff ff jmp 10d1ac <_Scheduler_priority_Block+0x20>
10d24b: 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;
10d24c: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
10d24e: eb b8 jmp 10d208 <_Scheduler_priority_Block+0x7c><== NOT EXECUTED
0010d3a0 <_Scheduler_priority_Schedule>:
#include <rtems/system.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Schedule(void)
{
10d3a0: 55 push %ebp
10d3a1: 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 );
10d3a3: 66 8b 0d 60 83 12 00 mov 0x128360,%cx
10d3aa: 31 c0 xor %eax,%eax
10d3ac: 89 c2 mov %eax,%edx
10d3ae: 66 0f bc d1 bsf %cx,%dx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10d3b2: 0f b7 d2 movzwl %dx,%edx
10d3b5: 66 8b 8c 12 80 83 12 mov 0x128380(%edx,%edx,1),%cx
10d3bc: 00
10d3bd: 66 0f bc c1 bsf %cx,%ax
return (_Priority_Bits_index( major ) << 4) +
10d3c1: c1 e2 04 shl $0x4,%edx
10d3c4: 0f b7 c0 movzwl %ax,%eax
10d3c7: 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 ] ) )
10d3ca: 8d 04 40 lea (%eax,%eax,2),%eax
10d3cd: c1 e0 02 shl $0x2,%eax
10d3d0: 03 05 80 39 12 00 add 0x123980,%eax
_Scheduler_priority_Schedule_body();
}
10d3d6: 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 );
10d3d8: 83 c0 04 add $0x4,%eax
10d3db: 39 c2 cmp %eax,%edx
10d3dd: 74 09 je 10d3e8 <_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(
10d3df: 89 15 3c 83 12 00 mov %edx,0x12833c
10d3e5: c9 leave
10d3e6: c3 ret
10d3e7: 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;
10d3e8: 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(
10d3ea: 89 15 3c 83 12 00 mov %edx,0x12833c <== NOT EXECUTED
10d3f0: c9 leave <== NOT EXECUTED
10d3f1: c3 ret <== NOT EXECUTED
0010d4c4 <_Scheduler_priority_Yield>:
* ready chain
* select heir
*/
void _Scheduler_priority_Yield(void)
{
10d4c4: 55 push %ebp
10d4c5: 89 e5 mov %esp,%ebp
10d4c7: 56 push %esi
10d4c8: 53 push %ebx
Scheduler_priority_Per_thread *sched_info;
ISR_Level level;
Thread_Control *executing;
Chain_Control *ready;
executing = _Thread_Executing;
10d4c9: a1 38 83 12 00 mov 0x128338,%eax
sched_info = (Scheduler_priority_Per_thread *) executing->scheduler_info;
ready = sched_info->ready_chain;
10d4ce: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx
10d4d4: 8b 12 mov (%edx),%edx
_ISR_Disable( level );
10d4d6: 9c pushf
10d4d7: fa cli
10d4d8: 59 pop %ecx
if ( !_Chain_Has_only_one_node( ready ) ) {
10d4d9: 8b 5a 08 mov 0x8(%edx),%ebx
10d4dc: 39 1a cmp %ebx,(%edx)
10d4de: 74 40 je 10d520 <_Scheduler_priority_Yield+0x5c>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10d4e0: 8b 30 mov (%eax),%esi
previous = the_node->previous;
10d4e2: 8b 58 04 mov 0x4(%eax),%ebx
next->previous = previous;
10d4e5: 89 5e 04 mov %ebx,0x4(%esi)
previous->next = next;
10d4e8: 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;
10d4ea: 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 );
10d4ed: 8d 72 04 lea 0x4(%edx),%esi
10d4f0: 89 30 mov %esi,(%eax)
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
10d4f2: 89 42 08 mov %eax,0x8(%edx)
old_last->next = the_node;
10d4f5: 89 03 mov %eax,(%ebx)
the_node->previous = old_last;
10d4f7: 89 58 04 mov %ebx,0x4(%eax)
_Chain_Extract_unprotected( &executing->Object.Node );
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
10d4fa: 51 push %ecx
10d4fb: 9d popf
10d4fc: fa cli
if ( _Thread_Is_heir( executing ) )
10d4fd: 3b 05 3c 83 12 00 cmp 0x12833c,%eax
10d503: 74 0f je 10d514 <_Scheduler_priority_Yield+0x50>
_Thread_Heir = (Thread_Control *) _Chain_First( ready );
_Thread_Dispatch_necessary = true;
}
else if ( !_Thread_Is_heir( executing ) )
_Thread_Dispatch_necessary = true;
10d505: c6 05 44 83 12 00 01 movb $0x1,0x128344
_ISR_Enable( level );
10d50c: 51 push %ecx
10d50d: 9d popf
}
10d50e: 5b pop %ebx
10d50f: 5e pop %esi
10d510: c9 leave
10d511: c3 ret
10d512: 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 );
10d514: 8b 02 mov (%edx),%eax
10d516: a3 3c 83 12 00 mov %eax,0x12833c
10d51b: eb e8 jmp 10d505 <_Scheduler_priority_Yield+0x41>
10d51d: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Dispatch_necessary = true;
}
else if ( !_Thread_Is_heir( executing ) )
10d520: 3b 05 3c 83 12 00 cmp 0x12833c,%eax
10d526: 75 dd jne 10d505 <_Scheduler_priority_Yield+0x41>
10d528: eb e2 jmp 10d50c <_Scheduler_priority_Yield+0x48>
0010dadc <_TOD_Set>:
*/
void _TOD_Set(
const struct timespec *time
)
{
10dadc: 55 push %ebp
10dadd: 89 e5 mov %esp,%ebp
10dadf: 53 push %ebx
10dae0: 83 ec 04 sub $0x4,%esp
10dae3: 8b 5d 08 mov 0x8(%ebp),%ebx
10dae6: a1 10 aa 12 00 mov 0x12aa10,%eax
10daeb: 40 inc %eax
10daec: a3 10 aa 12 00 mov %eax,0x12aa10
long seconds;
_Thread_Disable_dispatch();
_TOD_Deactivate();
seconds = _TOD_Seconds_since_epoch();
10daf1: a1 a8 aa 12 00 mov 0x12aaa8,%eax
if ( time->tv_sec < seconds )
10daf6: 8b 13 mov (%ebx),%edx
10daf8: 39 d0 cmp %edx,%eax
10dafa: 7f 34 jg 10db30 <_TOD_Set+0x54>
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
_Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units );
10dafc: 51 push %ecx
_Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec );
else
_Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - seconds );
10dafd: 29 c2 sub %eax,%edx
10daff: 52 push %edx
10db00: 6a 00 push $0x0
10db02: 68 d4 aa 12 00 push $0x12aad4
10db07: e8 0c 25 00 00 call 110018 <_Watchdog_Adjust>
10db0c: 83 c4 10 add $0x10,%esp
/* POSIX format TOD (timespec) */
_Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );
10db0f: 8b 03 mov (%ebx),%eax
10db11: a3 a8 aa 12 00 mov %eax,0x12aaa8
10db16: 8b 43 04 mov 0x4(%ebx),%eax
10db19: a3 ac aa 12 00 mov %eax,0x12aaac
_TOD_Is_set = true;
10db1e: c6 05 24 aa 12 00 01 movb $0x1,0x12aa24
_TOD_Activate();
_Thread_Enable_dispatch();
}
10db25: 8b 5d fc mov -0x4(%ebp),%ebx
10db28: c9 leave
_Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );
_TOD_Is_set = true;
_TOD_Activate();
_Thread_Enable_dispatch();
10db29: e9 02 16 00 00 jmp 10f130 <_Thread_Enable_dispatch>
10db2e: 66 90 xchg %ax,%ax
10db30: 51 push %ecx
_TOD_Deactivate();
seconds = _TOD_Seconds_since_epoch();
if ( time->tv_sec < seconds )
_Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec );
10db31: 29 d0 sub %edx,%eax
10db33: 50 push %eax
10db34: 6a 01 push $0x1
10db36: 68 d4 aa 12 00 push $0x12aad4
10db3b: e8 d8 24 00 00 call 110018 <_Watchdog_Adjust>
10db40: 83 c4 10 add $0x10,%esp
10db43: eb ca jmp 10db0f <_TOD_Set+0x33>
0010c1e8 <_TOD_To_seconds>:
*/
uint32_t _TOD_To_seconds(
const rtems_time_of_day *the_tod
)
{
10c1e8: 55 push %ebp
10c1e9: 89 e5 mov %esp,%ebp
10c1eb: 56 push %esi
10c1ec: 53 push %ebx
10c1ed: 8b 55 08 mov 0x8(%ebp),%edx
uint32_t time;
uint32_t year_mod_4;
time = the_tod->day - 1;
10c1f0: 8b 72 08 mov 0x8(%edx),%esi
10c1f3: 4e dec %esi
year_mod_4 = the_tod->year & 3;
10c1f4: 8b 02 mov (%edx),%eax
if ( year_mod_4 == 0 )
10c1f6: 89 c3 mov %eax,%ebx
10c1f8: 83 e3 03 and $0x3,%ebx
10c1fb: 74 67 je 10c264 <_TOD_To_seconds+0x7c>
time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
else
time += _TOD_Days_to_date[ 0 ][ the_tod->month ];
10c1fd: 8b 4a 04 mov 0x4(%edx),%ecx
10c200: 0f b7 8c 09 c0 42 12 movzwl 0x1242c0(%ecx,%ecx,1),%ecx
10c207: 00
10c208: 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 ];
10c20b: 0f b7 8c 1b f4 42 12 movzwl 0x1242f4(%ebx,%ebx,1),%ecx
10c212: 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 ) *
10c213: 2d c4 07 00 00 sub $0x7c4,%eax
10c218: c1 e8 02 shr $0x2,%eax
10c21b: 8d 1c c0 lea (%eax,%eax,8),%ebx
10c21e: 8d 1c d8 lea (%eax,%ebx,8),%ebx
10c221: 8d 1c 9b lea (%ebx,%ebx,4),%ebx
10c224: 8d 04 98 lea (%eax,%ebx,4),%eax
10c227: 01 c1 add %eax,%ecx
( (TOD_DAYS_PER_YEAR * 4) + 1);
time += _TOD_Days_since_last_leap_year[ year_mod_4 ];
10c229: 01 f1 add %esi,%ecx
time *= TOD_SECONDS_PER_DAY;
10c22b: 8d 04 89 lea (%ecx,%ecx,4),%eax
10c22e: 8d 04 81 lea (%ecx,%eax,4),%eax
10c231: 8d 04 c1 lea (%ecx,%eax,8),%eax
10c234: c1 e0 02 shl $0x2,%eax
10c237: 29 c8 sub %ecx,%eax
10c239: c1 e0 07 shl $0x7,%eax
time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
10c23c: 8b 5a 14 mov 0x14(%edx),%ebx
10c23f: 8b 4a 0c mov 0xc(%edx),%ecx
10c242: 8d 0c 49 lea (%ecx,%ecx,2),%ecx
10c245: 8d 0c 89 lea (%ecx,%ecx,4),%ecx
10c248: c1 e1 02 shl $0x2,%ecx
10c24b: 03 4a 10 add 0x10(%edx),%ecx
* TOD_SECONDS_PER_MINUTE;
10c24e: 8d 14 49 lea (%ecx,%ecx,2),%edx
10c251: 8d 14 92 lea (%edx,%edx,4),%edx
time += the_tod->second;
10c254: 8d 94 93 00 e5 da 21 lea 0x21dae500(%ebx,%edx,4),%edx
time += TOD_SECONDS_1970_THROUGH_1988;
10c25b: 8d 04 02 lea (%edx,%eax,1),%eax
return( time );
}
10c25e: 5b pop %ebx
10c25f: 5e pop %esi
10c260: c9 leave
10c261: c3 ret
10c262: 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 ];
10c264: 8b 4a 04 mov 0x4(%edx),%ecx
10c267: 0f b7 8c 09 da 42 12 movzwl 0x1242da(%ecx,%ecx,1),%ecx
10c26e: 00
10c26f: 8d 34 31 lea (%ecx,%esi,1),%esi
10c272: eb 97 jmp 10c20b <_TOD_To_seconds+0x23>
0010c274 <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
10c274: 55 push %ebp
10c275: 89 e5 mov %esp,%ebp
10c277: 53 push %ebx
10c278: 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();
10c27b: 8b 1d 6c 62 12 00 mov 0x12626c,%ebx
if ((!the_tod) ||
10c281: 85 c9 test %ecx,%ecx
10c283: 74 53 je 10c2d8 <_TOD_Validate+0x64> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
10c285: b8 40 42 0f 00 mov $0xf4240,%eax
10c28a: 31 d2 xor %edx,%edx
10c28c: f7 f3 div %ebx
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
10c28e: 3b 41 18 cmp 0x18(%ecx),%eax
10c291: 76 45 jbe 10c2d8 <_TOD_Validate+0x64>
(the_tod->ticks >= ticks_per_second) ||
10c293: 83 79 14 3b cmpl $0x3b,0x14(%ecx)
10c297: 77 3f ja 10c2d8 <_TOD_Validate+0x64>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
10c299: 83 79 10 3b cmpl $0x3b,0x10(%ecx)
10c29d: 77 39 ja 10c2d8 <_TOD_Validate+0x64>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
10c29f: 83 79 0c 17 cmpl $0x17,0xc(%ecx)
10c2a3: 77 33 ja 10c2d8 <_TOD_Validate+0x64>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
10c2a5: 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) ||
10c2a8: 85 c0 test %eax,%eax
10c2aa: 74 2c je 10c2d8 <_TOD_Validate+0x64> <== NEVER TAKEN
(the_tod->month == 0) ||
10c2ac: 83 f8 0c cmp $0xc,%eax
10c2af: 77 27 ja 10c2d8 <_TOD_Validate+0x64>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10c2b1: 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) ||
10c2b3: 81 fa c3 07 00 00 cmp $0x7c3,%edx
10c2b9: 76 1d jbe 10c2d8 <_TOD_Validate+0x64>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
10c2bb: 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) ||
10c2be: 85 c9 test %ecx,%ecx
10c2c0: 74 16 je 10c2d8 <_TOD_Validate+0x64> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
10c2c2: 83 e2 03 and $0x3,%edx
10c2c5: 75 16 jne 10c2dd <_TOD_Validate+0x69>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
10c2c7: 8b 04 85 34 43 12 00 mov 0x124334(,%eax,4),%eax
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
10c2ce: 39 c8 cmp %ecx,%eax
10c2d0: 0f 93 c0 setae %al
10c2d3: eb 05 jmp 10c2da <_TOD_Validate+0x66>
10c2d5: 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;
10c2d8: 31 c0 xor %eax,%eax
if ( the_tod->day > days_in_month )
return false;
return true;
}
10c2da: 5b pop %ebx
10c2db: c9 leave
10c2dc: 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 ];
10c2dd: 8b 04 85 00 43 12 00 mov 0x124300(,%eax,4),%eax
10c2e4: eb e8 jmp 10c2ce <_TOD_Validate+0x5a>
0010d578 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
10d578: 55 push %ebp
10d579: 89 e5 mov %esp,%ebp
10d57b: 57 push %edi
10d57c: 56 push %esi
10d57d: 53 push %ebx
10d57e: 83 ec 28 sub $0x28,%esp
10d581: 8b 5d 08 mov 0x8(%ebp),%ebx
10d584: 8b 75 0c mov 0xc(%ebp),%esi
10d587: 8a 45 10 mov 0x10(%ebp),%al
10d58a: 88 45 e7 mov %al,-0x19(%ebp)
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
10d58d: 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 );
10d590: 53 push %ebx
10d591: e8 76 0c 00 00 call 10e20c <_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 )
10d596: 83 c4 10 add $0x10,%esp
10d599: 39 73 14 cmp %esi,0x14(%ebx)
10d59c: 74 0d je 10d5ab <_Thread_Change_priority+0x33>
_Thread_Set_priority( the_thread, new_priority );
10d59e: 83 ec 08 sub $0x8,%esp
10d5a1: 56 push %esi
10d5a2: 53 push %ebx
10d5a3: e8 10 0c 00 00 call 10e1b8 <_Thread_Set_priority>
10d5a8: 83 c4 10 add $0x10,%esp
_ISR_Disable( level );
10d5ab: 9c pushf
10d5ac: fa cli
10d5ad: 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;
10d5ae: 8b 43 10 mov 0x10(%ebx),%eax
if ( state != STATES_TRANSIENT ) {
10d5b1: 83 f8 04 cmp $0x4,%eax
10d5b4: 74 22 je 10d5d8 <_Thread_Change_priority+0x60>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
10d5b6: 83 e7 04 and $0x4,%edi
10d5b9: 74 11 je 10d5cc <_Thread_Change_priority+0x54><== ALWAYS TAKEN
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
10d5bb: 56 push %esi
10d5bc: 9d popf
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10d5bd: a9 e0 be 03 00 test $0x3bee0,%eax
10d5c2: 75 60 jne 10d624 <_Thread_Change_priority+0xac>
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
10d5c4: 8d 65 f4 lea -0xc(%ebp),%esp
10d5c7: 5b pop %ebx
10d5c8: 5e pop %esi
10d5c9: 5f pop %edi
10d5ca: c9 leave
10d5cb: c3 ret
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
10d5cc: 89 c2 mov %eax,%edx
10d5ce: 83 e2 fb and $0xfffffffb,%edx
10d5d1: 89 53 10 mov %edx,0x10(%ebx)
10d5d4: eb e5 jmp 10d5bb <_Thread_Change_priority+0x43>
10d5d6: 66 90 xchg %ax,%ax
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
10d5d8: 83 e7 04 and $0x4,%edi
10d5db: 75 1a jne 10d5f7 <_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 );
10d5dd: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
if ( prepend_it )
10d5e4: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
10d5e8: 74 52 je 10d63c <_Thread_Change_priority+0xc4>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
10d5ea: 83 ec 0c sub $0xc,%esp
10d5ed: 53 push %ebx
10d5ee: ff 15 a8 39 12 00 call *0x1239a8
10d5f4: 83 c4 10 add $0x10,%esp
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
10d5f7: 56 push %esi
10d5f8: 9d popf
10d5f9: 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();
10d5fa: ff 15 88 39 12 00 call *0x123988
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
10d600: a1 38 83 12 00 mov 0x128338,%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() &&
10d605: 3b 05 3c 83 12 00 cmp 0x12833c,%eax
10d60b: 74 0d je 10d61a <_Thread_Change_priority+0xa2>
10d60d: 80 78 74 00 cmpb $0x0,0x74(%eax)
10d611: 74 07 je 10d61a <_Thread_Change_priority+0xa2>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
10d613: c6 05 44 83 12 00 01 movb $0x1,0x128344
_ISR_Enable( level );
10d61a: 56 push %esi
10d61b: 9d popf
}
10d61c: 8d 65 f4 lea -0xc(%ebp),%esp
10d61f: 5b pop %ebx
10d620: 5e pop %esi
10d621: 5f pop %edi
10d622: c9 leave
10d623: 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 );
10d624: 89 5d 0c mov %ebx,0xc(%ebp)
10d627: 8b 43 44 mov 0x44(%ebx),%eax
10d62a: 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 );
}
10d62d: 8d 65 f4 lea -0xc(%ebp),%esp
10d630: 5b pop %ebx
10d631: 5e pop %esi
10d632: 5f pop %edi
10d633: 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 );
10d634: e9 e7 0a 00 00 jmp 10e120 <_Thread_queue_Requeue>
10d639: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
10d63c: 83 ec 0c sub $0xc,%esp
10d63f: 53 push %ebx
10d640: ff 15 a4 39 12 00 call *0x1239a4
10d646: 83 c4 10 add $0x10,%esp
10d649: eb ac jmp 10d5f7 <_Thread_Change_priority+0x7f>
0010d64c <_Thread_Clear_state>:
*/
void _Thread_Clear_state(
Thread_Control *the_thread,
States_Control state
)
{
10d64c: 55 push %ebp
10d64d: 89 e5 mov %esp,%ebp
10d64f: 53 push %ebx
10d650: 83 ec 04 sub $0x4,%esp
10d653: 8b 55 08 mov 0x8(%ebp),%edx
10d656: 8b 45 0c mov 0xc(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10d659: 9c pushf
10d65a: fa cli
10d65b: 5b pop %ebx
current_state = the_thread->current_state;
10d65c: 8b 4a 10 mov 0x10(%edx),%ecx
if ( current_state & state ) {
10d65f: 85 c8 test %ecx,%eax
10d661: 74 0b je 10d66e <_Thread_Clear_state+0x22>
10d663: f7 d0 not %eax
10d665: 21 c8 and %ecx,%eax
current_state =
the_thread->current_state = _States_Clear( state, current_state );
10d667: 89 42 10 mov %eax,0x10(%edx)
if ( _States_Is_ready( current_state ) ) {
10d66a: 85 c0 test %eax,%eax
10d66c: 74 0a je 10d678 <_Thread_Clear_state+0x2c>
_Scheduler_Unblock( the_thread );
}
}
_ISR_Enable( level );
10d66e: 53 push %ebx
10d66f: 9d popf
}
10d670: 8b 5d fc mov -0x4(%ebp),%ebx
10d673: c9 leave
10d674: c3 ret
10d675: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(
Thread_Control *the_thread
)
{
_Scheduler.Operations.unblock( the_thread );
10d678: 83 ec 0c sub $0xc,%esp
10d67b: 52 push %edx
10d67c: ff 15 94 39 12 00 call *0x123994
10d682: 83 c4 10 add $0x10,%esp
10d685: eb e7 jmp 10d66e <_Thread_Clear_state+0x22>
0010d7fc <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10d7fc: 55 push %ebp
10d7fd: 89 e5 mov %esp,%ebp
10d7ff: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10d802: 8d 45 f4 lea -0xc(%ebp),%eax
10d805: 50 push %eax
10d806: ff 75 08 pushl 0x8(%ebp)
10d809: e8 c6 01 00 00 call 10d9d4 <_Thread_Get>
switch ( location ) {
10d80e: 83 c4 10 add $0x10,%esp
10d811: 8b 55 f4 mov -0xc(%ebp),%edx
10d814: 85 d2 test %edx,%edx
10d816: 75 1c jne 10d834 <_Thread_Delay_ended+0x38><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
10d818: 83 ec 08 sub $0x8,%esp
10d81b: 68 18 00 00 10 push $0x10000018
10d820: 50 push %eax
10d821: e8 26 fe ff ff call 10d64c <_Thread_Clear_state>
10d826: a1 90 7d 12 00 mov 0x127d90,%eax
10d82b: 48 dec %eax
10d82c: a3 90 7d 12 00 mov %eax,0x127d90
10d831: 83 c4 10 add $0x10,%esp
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
10d834: c9 leave
10d835: c3 ret
0010d838 <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
10d838: 55 push %ebp
10d839: 89 e5 mov %esp,%ebp
10d83b: 57 push %edi
10d83c: 56 push %esi
10d83d: 53 push %ebx
10d83e: 83 ec 1c sub $0x1c,%esp
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
10d841: 8b 1d 38 83 12 00 mov 0x128338,%ebx
_ISR_Disable( level );
10d847: 9c pushf
10d848: fa cli
10d849: 58 pop %eax
while ( _Thread_Dispatch_necessary == true ) {
10d84a: 8a 15 44 83 12 00 mov 0x128344,%dl
10d850: 84 d2 test %dl,%dl
10d852: 0f 84 3c 01 00 00 je 10d994 <_Thread_Dispatch+0x15c>
heir = _Thread_Heir;
10d858: 8b 35 3c 83 12 00 mov 0x12833c,%esi
_Thread_Dispatch_disable_level = 1;
10d85e: c7 05 90 7d 12 00 01 movl $0x1,0x127d90
10d865: 00 00 00
_Thread_Dispatch_necessary = false;
10d868: c6 05 44 83 12 00 00 movb $0x0,0x128344
_Thread_Executing = heir;
10d86f: 89 35 38 83 12 00 mov %esi,0x128338
/*
* 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 )
10d875: 39 f3 cmp %esi,%ebx
10d877: 0f 84 17 01 00 00 je 10d994 <_Thread_Dispatch+0x15c>
10d87d: 8d 7d d8 lea -0x28(%ebp),%edi
10d880: e9 f5 00 00 00 jmp 10d97a <_Thread_Dispatch+0x142>
10d885: 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 );
10d888: 50 push %eax
10d889: 9d popf
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
10d88a: 83 ec 0c sub $0xc,%esp
10d88d: 8d 45 e0 lea -0x20(%ebp),%eax
10d890: 50 push %eax
10d891: e8 2a 3a 00 00 call 1112c0 <_TOD_Get_uptime>
_Timestamp_Subtract(
10d896: 83 c4 0c add $0xc,%esp
10d899: 57 push %edi
10d89a: 8d 45 e0 lea -0x20(%ebp),%eax
10d89d: 50 push %eax
10d89e: 68 4c 7e 12 00 push $0x127e4c
10d8a3: e8 98 0b 00 00 call 10e440 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
10d8a8: 58 pop %eax
10d8a9: 5a pop %edx
10d8aa: 57 push %edi
10d8ab: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax
10d8b1: 50 push %eax
10d8b2: e8 4d 0b 00 00 call 10e404 <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
10d8b7: 8b 45 e0 mov -0x20(%ebp),%eax
10d8ba: 8b 55 e4 mov -0x1c(%ebp),%edx
10d8bd: a3 4c 7e 12 00 mov %eax,0x127e4c
10d8c2: 89 15 50 7e 12 00 mov %edx,0x127e50
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
10d8c8: a1 24 7e 12 00 mov 0x127e24,%eax
10d8cd: 83 c4 10 add $0x10,%esp
10d8d0: 85 c0 test %eax,%eax
10d8d2: 74 10 je 10d8e4 <_Thread_Dispatch+0xac> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
10d8d4: 8b 10 mov (%eax),%edx
10d8d6: 89 93 e4 00 00 00 mov %edx,0xe4(%ebx)
*_Thread_libc_reent = heir->libc_reent;
10d8dc: 8b 96 e4 00 00 00 mov 0xe4(%esi),%edx
10d8e2: 89 10 mov %edx,(%eax)
}
_User_extensions_Thread_switch( executing, heir );
10d8e4: 83 ec 08 sub $0x8,%esp
10d8e7: 56 push %esi
10d8e8: 53 push %ebx
10d8e9: e8 f2 0d 00 00 call 10e6e0 <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
10d8ee: 5a pop %edx
10d8ef: 59 pop %ecx
10d8f0: 81 c6 c8 00 00 00 add $0xc8,%esi
10d8f6: 56 push %esi
10d8f7: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax
10d8fd: 50 push %eax
10d8fe: e8 ed 10 00 00 call 10e9f0 <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
10d903: 83 c4 10 add $0x10,%esp
10d906: 8b 83 e0 00 00 00 mov 0xe0(%ebx),%eax
10d90c: 85 c0 test %eax,%eax
10d90e: 74 36 je 10d946 <_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 );
10d910: a1 20 7e 12 00 mov 0x127e20,%eax
10d915: 39 c3 cmp %eax,%ebx
10d917: 74 2d je 10d946 <_Thread_Dispatch+0x10e>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
10d919: 85 c0 test %eax,%eax
10d91b: 74 11 je 10d92e <_Thread_Dispatch+0xf6>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10d91d: 83 ec 0c sub $0xc,%esp
10d920: 05 e0 00 00 00 add $0xe0,%eax
10d925: 50 push %eax
10d926: e8 f9 10 00 00 call 10ea24 <_CPU_Context_save_fp>
10d92b: 83 c4 10 add $0x10,%esp
_Context_Restore_fp( &executing->fp_context );
10d92e: 83 ec 0c sub $0xc,%esp
10d931: 8d 83 e0 00 00 00 lea 0xe0(%ebx),%eax
10d937: 50 push %eax
10d938: e8 f1 10 00 00 call 10ea2e <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
10d93d: 89 1d 20 7e 12 00 mov %ebx,0x127e20
10d943: 83 c4 10 add $0x10,%esp
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
10d946: 8b 1d 38 83 12 00 mov 0x128338,%ebx
_ISR_Disable( level );
10d94c: 9c pushf
10d94d: fa cli
10d94e: 58 pop %eax
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10d94f: 8a 15 44 83 12 00 mov 0x128344,%dl
10d955: 84 d2 test %dl,%dl
10d957: 74 3b je 10d994 <_Thread_Dispatch+0x15c>
heir = _Thread_Heir;
10d959: 8b 35 3c 83 12 00 mov 0x12833c,%esi
_Thread_Dispatch_disable_level = 1;
10d95f: c7 05 90 7d 12 00 01 movl $0x1,0x127d90
10d966: 00 00 00
_Thread_Dispatch_necessary = false;
10d969: c6 05 44 83 12 00 00 movb $0x0,0x128344
_Thread_Executing = heir;
10d970: 89 35 38 83 12 00 mov %esi,0x128338
/*
* 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 )
10d976: 39 de cmp %ebx,%esi
10d978: 74 1a je 10d994 <_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 )
10d97a: 83 7e 7c 01 cmpl $0x1,0x7c(%esi)
10d97e: 0f 85 04 ff ff ff jne 10d888 <_Thread_Dispatch+0x50>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
10d984: 8b 15 60 7d 12 00 mov 0x127d60,%edx
10d98a: 89 56 78 mov %edx,0x78(%esi)
10d98d: e9 f6 fe ff ff jmp 10d888 <_Thread_Dispatch+0x50>
10d992: 66 90 xchg %ax,%ax
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
10d994: c7 05 90 7d 12 00 00 movl $0x0,0x127d90
10d99b: 00 00 00
_ISR_Enable( level );
10d99e: 50 push %eax
10d99f: 9d popf
_API_extensions_Run_postswitch();
10d9a0: e8 23 e5 ff ff call 10bec8 <_API_extensions_Run_postswitch>
}
10d9a5: 8d 65 f4 lea -0xc(%ebp),%esp
10d9a8: 5b pop %ebx
10d9a9: 5e pop %esi
10d9aa: 5f pop %edi
10d9ab: c9 leave
10d9ac: c3 ret
0010d9d4 <_Thread_Get>:
*/
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
10d9d4: 55 push %ebp
10d9d5: 89 e5 mov %esp,%ebp
10d9d7: 53 push %ebx
10d9d8: 83 ec 04 sub $0x4,%esp
10d9db: 8b 45 08 mov 0x8(%ebp),%eax
10d9de: 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 ) ) {
10d9e1: 85 c0 test %eax,%eax
10d9e3: 74 47 je 10da2c <_Thread_Get+0x58>
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
10d9e5: 89 c2 mov %eax,%edx
10d9e7: c1 ea 18 shr $0x18,%edx
10d9ea: 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 )
10d9ed: 8d 5a ff lea -0x1(%edx),%ebx
10d9f0: 83 fb 02 cmp $0x2,%ebx
10d9f3: 77 27 ja 10da1c <_Thread_Get+0x48>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10d9f5: 89 c3 mov %eax,%ebx
10d9f7: 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 :) */
10d9fa: 4b dec %ebx
10d9fb: 75 1f jne 10da1c <_Thread_Get+0x48>
*location = OBJECTS_ERROR;
goto done;
}
#endif
information = api_information[ the_class ];
10d9fd: 8b 14 95 68 7d 12 00 mov 0x127d68(,%edx,4),%edx
10da04: 8b 52 04 mov 0x4(%edx),%edx
if ( !information ) {
10da07: 85 d2 test %edx,%edx
10da09: 74 11 je 10da1c <_Thread_Get+0x48>
*location = OBJECTS_ERROR;
goto done;
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
10da0b: 53 push %ebx
10da0c: 51 push %ecx
10da0d: 50 push %eax
10da0e: 52 push %edx
10da0f: e8 24 f4 ff ff call 10ce38 <_Objects_Get>
10da14: 83 c4 10 add $0x10,%esp
done:
return tp;
}
10da17: 8b 5d fc mov -0x4(%ebp),%ebx
10da1a: c9 leave
10da1b: c3 ret
}
#endif
information = api_information[ the_class ];
if ( !information ) {
*location = OBJECTS_ERROR;
10da1c: 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;
10da22: 31 c0 xor %eax,%eax
tp = (Thread_Control *) _Objects_Get( information, id, location );
done:
return tp;
}
10da24: 8b 5d fc mov -0x4(%ebp),%ebx
10da27: c9 leave
10da28: c3 ret
10da29: 8d 76 00 lea 0x0(%esi),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10da2c: a1 90 7d 12 00 mov 0x127d90,%eax
10da31: 40 inc %eax
10da32: a3 90 7d 12 00 mov %eax,0x127d90
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;
10da37: c7 01 00 00 00 00 movl $0x0,(%ecx)
tp = _Thread_Executing;
10da3d: a1 38 83 12 00 mov 0x128338,%eax
tp = (Thread_Control *) _Objects_Get( information, id, location );
done:
return tp;
}
10da42: 8b 5d fc mov -0x4(%ebp),%ebx
10da45: c9 leave
10da46: c3 ret
001130a8 <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
1130a8: 55 push %ebp
1130a9: 89 e5 mov %esp,%ebp
1130ab: 53 push %ebx
1130ac: 83 ec 14 sub $0x14,%esp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
1130af: 8b 1d 38 83 12 00 mov 0x128338,%ebx
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
1130b5: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax
_ISR_Set_level(level);
1130bb: 85 c0 test %eax,%eax
1130bd: 74 79 je 113138 <_Thread_Handler+0x90>
1130bf: fa cli
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
1130c0: a0 0c 7a 12 00 mov 0x127a0c,%al
1130c5: 88 45 f7 mov %al,-0x9(%ebp)
doneConstructors = 1;
1130c8: c6 05 0c 7a 12 00 01 movb $0x1,0x127a0c
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
1130cf: 8b 83 e0 00 00 00 mov 0xe0(%ebx),%eax
1130d5: 85 c0 test %eax,%eax
1130d7: 74 24 je 1130fd <_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 );
1130d9: a1 20 7e 12 00 mov 0x127e20,%eax
1130de: 39 c3 cmp %eax,%ebx
1130e0: 74 1b je 1130fd <_Thread_Handler+0x55>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
1130e2: 85 c0 test %eax,%eax
1130e4: 74 11 je 1130f7 <_Thread_Handler+0x4f>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
1130e6: 83 ec 0c sub $0xc,%esp
1130e9: 05 e0 00 00 00 add $0xe0,%eax
1130ee: 50 push %eax
1130ef: e8 30 b9 ff ff call 10ea24 <_CPU_Context_save_fp>
1130f4: 83 c4 10 add $0x10,%esp
_Thread_Allocated_fp = executing;
1130f7: 89 1d 20 7e 12 00 mov %ebx,0x127e20
/*
* 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 );
1130fd: 83 ec 0c sub $0xc,%esp
113100: 53 push %ebx
113101: e8 3e b4 ff ff call 10e544 <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
113106: e8 a5 a8 ff ff call 10d9b0 <_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) */ {
11310b: 83 c4 10 add $0x10,%esp
11310e: 80 7d f7 00 cmpb $0x0,-0x9(%ebp)
113112: 74 28 je 11313c <_Thread_Handler+0x94>
INIT_NAME ();
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
113114: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax
11311a: 85 c0 test %eax,%eax
11311c: 74 2d je 11314b <_Thread_Handler+0xa3>
(*(Thread_Entry_numeric) executing->Start.entry_point)(
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
11311e: 48 dec %eax
11311f: 74 43 je 113164 <_Thread_Handler+0xbc> <== 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 );
113121: 83 ec 0c sub $0xc,%esp
113124: 53 push %ebx
113125: e8 56 b4 ff ff call 10e580 <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
11312a: 83 c4 0c add $0xc,%esp
11312d: 6a 05 push $0x5
11312f: 6a 01 push $0x1
113131: 6a 00 push $0x0
113133: e8 bc 97 ff ff call 10c8f4 <_Internal_error_Occurred>
* 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);
113138: fb sti
113139: eb 85 jmp 1130c0 <_Thread_Handler+0x18>
11313b: 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 ();
11313c: e8 3f c7 00 00 call 11f880 <__start_set_sysctl_set>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
113141: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax
113147: 85 c0 test %eax,%eax
113149: 75 d3 jne 11311e <_Thread_Handler+0x76>
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
11314b: 83 ec 0c sub $0xc,%esp
11314e: ff b3 9c 00 00 00 pushl 0x9c(%ebx)
113154: ff 93 90 00 00 00 call *0x90(%ebx)
INIT_NAME ();
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
executing->Wait.return_argument =
11315a: 89 43 28 mov %eax,0x28(%ebx)
11315d: 83 c4 10 add $0x10,%esp
113160: eb bf jmp 113121 <_Thread_Handler+0x79>
113162: 66 90 xchg %ax,%ax
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
113164: 83 ec 0c sub $0xc,%esp
113167: ff b3 98 00 00 00 pushl 0x98(%ebx)
11316d: ff 93 90 00 00 00 call *0x90(%ebx)
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
113173: 89 43 28 mov %eax,0x28(%ebx)
113176: 83 c4 10 add $0x10,%esp
113179: eb a6 jmp 113121 <_Thread_Handler+0x79>
0010da48 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
10da48: 55 push %ebp
10da49: 89 e5 mov %esp,%ebp
10da4b: 57 push %edi
10da4c: 56 push %esi
10da4d: 53 push %ebx
10da4e: 83 ec 1c sub $0x1c,%esp
10da51: 8b 5d 0c mov 0xc(%ebp),%ebx
10da54: 8b 4d 10 mov 0x10(%ebp),%ecx
10da57: 8b 75 14 mov 0x14(%ebp),%esi
10da5a: 8b 7d 1c mov 0x1c(%ebp),%edi
10da5d: 8a 55 18 mov 0x18(%ebp),%dl
10da60: 8a 45 20 mov 0x20(%ebp),%al
10da63: 88 45 df mov %al,-0x21(%ebp)
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
10da66: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx)
10da6d: 00 00 00
10da70: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx)
10da77: 00 00 00
extensions_area = NULL;
the_thread->libc_reent = NULL;
10da7a: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10da81: 00 00 00
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
10da84: 85 c9 test %ecx,%ecx
10da86: 0f 84 d3 01 00 00 je 10dc5f <_Thread_Initialize+0x217>
stack = the_thread->Start.stack;
the_thread->Start.core_allocated_stack = true;
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
10da8c: c6 83 b4 00 00 00 00 movb $0x0,0xb4(%ebx)
10da93: 89 f0 mov %esi,%eax
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
10da95: 89 8b bc 00 00 00 mov %ecx,0xbc(%ebx)
the_stack->size = size;
10da9b: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
10daa1: 84 d2 test %dl,%dl
10daa3: 0f 85 4f 01 00 00 jne 10dbf8 <_Thread_Initialize+0x1b0>
10daa9: 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;
10daab: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
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;
10dab2: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx)
the_thread->Start.fp_context = fp_area;
10dab8: 89 83 c0 00 00 00 mov %eax,0xc0(%ebx)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10dabe: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10dac5: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
the_watchdog->id = id;
10dacc: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
the_watchdog->user_data = user_data;
10dad3: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10dada: a1 30 7e 12 00 mov 0x127e30,%eax
10dadf: 85 c0 test %eax,%eax
10dae1: 0f 85 39 01 00 00 jne 10dc20 <_Thread_Initialize+0x1d8>
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10dae7: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx)
10daee: 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;
10daf1: 31 f6 xor %esi,%esi
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
10daf3: 8a 45 df mov -0x21(%ebp),%al
10daf6: 88 83 a0 00 00 00 mov %al,0xa0(%ebx)
the_thread->Start.budget_algorithm = budget_algorithm;
10dafc: 8b 45 24 mov 0x24(%ebp),%eax
10daff: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
the_thread->Start.budget_callout = budget_callout;
10db05: 8b 45 28 mov 0x28(%ebp),%eax
10db08: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx)
switch ( budget_algorithm ) {
10db0e: 83 7d 24 02 cmpl $0x2,0x24(%ebp)
10db12: 75 08 jne 10db1c <_Thread_Initialize+0xd4>
case THREAD_CPU_BUDGET_ALGORITHM_NONE:
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
10db14: a1 60 7d 12 00 mov 0x127d60,%eax
10db19: 89 43 78 mov %eax,0x78(%ebx)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
10db1c: 8b 45 2c mov 0x2c(%ebp),%eax
10db1f: 89 83 ac 00 00 00 mov %eax,0xac(%ebx)
the_thread->current_state = STATES_DORMANT;
10db25: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
the_thread->Wait.queue = NULL;
10db2c: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
the_thread->resource_count = 0;
10db33: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->real_priority = priority;
10db3a: 89 7b 18 mov %edi,0x18(%ebx)
the_thread->Start.initial_priority = priority;
10db3d: 89 bb b0 00 00 00 mov %edi,0xb0(%ebx)
*/
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.allocate( the_thread );
10db43: 83 ec 0c sub $0xc,%esp
10db46: 53 push %ebx
10db47: ff 15 98 39 12 00 call *0x123998
10db4d: 89 45 e4 mov %eax,-0x1c(%ebp)
sched =_Scheduler_Allocate( the_thread );
if ( !sched )
10db50: 83 c4 10 add $0x10,%esp
10db53: 85 c0 test %eax,%eax
10db55: 74 40 je 10db97 <_Thread_Initialize+0x14f>
goto failed;
_Thread_Set_priority( the_thread, priority );
10db57: 83 ec 08 sub $0x8,%esp
10db5a: 57 push %edi
10db5b: 53 push %ebx
10db5c: e8 57 06 00 00 call 10e1b8 <_Thread_Set_priority>
/*
* Initialize the CPU usage statistics
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
10db61: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx)
10db68: 00 00 00
10db6b: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx)
10db72: 00 00 00
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
10db75: 8b 45 08 mov 0x8(%ebp),%eax
10db78: 8b 40 1c mov 0x1c(%eax),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10db7b: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10db7f: 89 1c 90 mov %ebx,(%eax,%edx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10db82: 8b 45 30 mov 0x30(%ebp),%eax
10db85: 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 );
10db88: 89 1c 24 mov %ebx,(%esp)
10db8b: e8 7c 0a 00 00 call 10e60c <_User_extensions_Thread_create>
if ( extension_status )
10db90: 83 c4 10 add $0x10,%esp
10db93: 84 c0 test %al,%al
10db95: 75 55 jne 10dbec <_Thread_Initialize+0x1a4>
return true;
failed:
_Workspace_Free( the_thread->libc_reent );
10db97: 83 ec 0c sub $0xc,%esp
10db9a: ff b3 e4 00 00 00 pushl 0xe4(%ebx)
10dba0: e8 ff 0d 00 00 call 10e9a4 <_Workspace_Free>
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
10dba5: 5f pop %edi
10dba6: ff b3 e8 00 00 00 pushl 0xe8(%ebx)
10dbac: e8 f3 0d 00 00 call 10e9a4 <_Workspace_Free>
10dbb1: 59 pop %ecx
10dbb2: ff b3 ec 00 00 00 pushl 0xec(%ebx)
10dbb8: e8 e7 0d 00 00 call 10e9a4 <_Workspace_Free>
_Workspace_Free( extensions_area );
10dbbd: 89 34 24 mov %esi,(%esp)
10dbc0: e8 df 0d 00 00 call 10e9a4 <_Workspace_Free>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
10dbc5: 5a pop %edx
10dbc6: ff 75 e0 pushl -0x20(%ebp)
10dbc9: e8 d6 0d 00 00 call 10e9a4 <_Workspace_Free>
#endif
_Workspace_Free( sched );
10dbce: 58 pop %eax
10dbcf: ff 75 e4 pushl -0x1c(%ebp)
10dbd2: e8 cd 0d 00 00 call 10e9a4 <_Workspace_Free>
_Thread_Stack_Free( the_thread );
10dbd7: 89 1c 24 mov %ebx,(%esp)
10dbda: e8 c1 06 00 00 call 10e2a0 <_Thread_Stack_Free>
return false;
10dbdf: 83 c4 10 add $0x10,%esp
10dbe2: 31 c0 xor %eax,%eax
}
10dbe4: 8d 65 f4 lea -0xc(%ebp),%esp
10dbe7: 5b pop %ebx
10dbe8: 5e pop %esi
10dbe9: 5f pop %edi
10dbea: c9 leave
10dbeb: c3 ret
* Mutex provides sufficient protection to let the user extensions
* run safely.
*/
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
return true;
10dbec: b0 01 mov $0x1,%al
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
10dbee: 8d 65 f4 lea -0xc(%ebp),%esp
10dbf1: 5b pop %ebx
10dbf2: 5e pop %esi
10dbf3: 5f pop %edi
10dbf4: c9 leave
10dbf5: c3 ret
10dbf6: 66 90 xchg %ax,%ax
/*
* 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 );
10dbf8: 83 ec 0c sub $0xc,%esp
10dbfb: 6a 6c push $0x6c
10dbfd: e8 86 0d 00 00 call 10e988 <_Workspace_Allocate>
10dc02: 89 45 e0 mov %eax,-0x20(%ebp)
if ( !fp_area )
10dc05: 83 c4 10 add $0x10,%esp
10dc08: 85 c0 test %eax,%eax
10dc0a: 0f 85 a2 fe ff ff jne 10dab2 <_Thread_Initialize+0x6a>
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
10dc10: 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;
10dc12: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
10dc19: e9 79 ff ff ff jmp 10db97 <_Thread_Initialize+0x14f>
10dc1e: 66 90 xchg %ax,%ax
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
extensions_area = _Workspace_Allocate(
10dc20: 83 ec 0c sub $0xc,%esp
10dc23: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax
10dc2a: 50 push %eax
10dc2b: e8 58 0d 00 00 call 10e988 <_Workspace_Allocate>
10dc30: 89 c6 mov %eax,%esi
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
10dc32: 83 c4 10 add $0x10,%esp
10dc35: 85 c0 test %eax,%eax
10dc37: 74 5a je 10dc93 <_Thread_Initialize+0x24b>
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10dc39: 89 83 f0 00 00 00 mov %eax,0xf0(%ebx)
10dc3f: 8b 0d 30 7e 12 00 mov 0x127e30,%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++ )
10dc45: 31 d2 xor %edx,%edx
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10dc47: 31 c0 xor %eax,%eax
10dc49: 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;
10dc4c: 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++ )
10dc53: 40 inc %eax
10dc54: 89 c2 mov %eax,%edx
10dc56: 39 c1 cmp %eax,%ecx
10dc58: 73 f2 jae 10dc4c <_Thread_Initialize+0x204>
10dc5a: e9 94 fe ff ff jmp 10daf3 <_Thread_Initialize+0xab>
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
10dc5f: 83 ec 08 sub $0x8,%esp
10dc62: 56 push %esi
10dc63: 53 push %ebx
10dc64: 88 55 d8 mov %dl,-0x28(%ebp)
10dc67: e8 d0 05 00 00 call 10e23c <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
10dc6c: 83 c4 10 add $0x10,%esp
10dc6f: 85 c0 test %eax,%eax
10dc71: 8a 55 d8 mov -0x28(%ebp),%dl
10dc74: 74 16 je 10dc8c <_Thread_Initialize+0x244>
10dc76: 39 c6 cmp %eax,%esi
10dc78: 77 12 ja 10dc8c <_Thread_Initialize+0x244><== NEVER TAKEN
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
10dc7a: 8b 8b c4 00 00 00 mov 0xc4(%ebx),%ecx
the_thread->Start.core_allocated_stack = true;
10dc80: c6 83 b4 00 00 00 01 movb $0x1,0xb4(%ebx)
10dc87: e9 09 fe ff ff jmp 10da95 <_Thread_Initialize+0x4d>
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
10dc8c: 31 c0 xor %eax,%eax
10dc8e: e9 51 ff ff ff jmp 10dbe4 <_Thread_Initialize+0x19c>
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;
10dc93: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
10dc9a: e9 f8 fe ff ff jmp 10db97 <_Thread_Initialize+0x14f>
00112560 <_Thread_Reset>:
void _Thread_Reset(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
112560: 55 push %ebp
112561: 89 e5 mov %esp,%ebp
112563: 53 push %ebx
112564: 83 ec 10 sub $0x10,%esp
112567: 8b 5d 08 mov 0x8(%ebp),%ebx
the_thread->resource_count = 0;
11256a: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->is_preemptible = the_thread->Start.is_preemptible;
112571: 8a 83 a0 00 00 00 mov 0xa0(%ebx),%al
112577: 88 43 74 mov %al,0x74(%ebx)
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
11257a: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax
112580: 89 43 7c mov %eax,0x7c(%ebx)
the_thread->budget_callout = the_thread->Start.budget_callout;
112583: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax
112589: 89 83 80 00 00 00 mov %eax,0x80(%ebx)
the_thread->Start.pointer_argument = pointer_argument;
11258f: 8b 45 0c mov 0xc(%ebp),%eax
112592: 89 83 98 00 00 00 mov %eax,0x98(%ebx)
the_thread->Start.numeric_argument = numeric_argument;
112598: 8b 45 10 mov 0x10(%ebp),%eax
11259b: 89 83 9c 00 00 00 mov %eax,0x9c(%ebx)
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
1125a1: 53 push %ebx
1125a2: e8 f9 c5 ff ff call 10eba0 <_Thread_queue_Extract_with_proxy>
1125a7: 83 c4 10 add $0x10,%esp
1125aa: 84 c0 test %al,%al
1125ac: 75 06 jne 1125b4 <_Thread_Reset+0x54>
if ( _Watchdog_Is_active( &the_thread->Timer ) )
1125ae: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
1125b2: 74 28 je 1125dc <_Thread_Reset+0x7c>
(void) _Watchdog_Remove( &the_thread->Timer );
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
1125b4: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax
1125ba: 39 43 14 cmp %eax,0x14(%ebx)
1125bd: 74 15 je 1125d4 <_Thread_Reset+0x74>
the_thread->real_priority = the_thread->Start.initial_priority;
1125bf: 89 43 18 mov %eax,0x18(%ebx)
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
1125c2: 89 45 0c mov %eax,0xc(%ebp)
1125c5: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
1125c8: 8b 5d fc mov -0x4(%ebp),%ebx
1125cb: 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 );
1125cc: e9 ab c7 ff ff jmp 10ed7c <_Thread_Set_priority>
1125d1: 8d 76 00 lea 0x0(%esi),%esi
}
}
1125d4: 8b 5d fc mov -0x4(%ebp),%ebx
1125d7: c9 leave
1125d8: c3 ret
1125d9: 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 );
1125dc: 83 ec 0c sub $0xc,%esp
1125df: 8d 43 48 lea 0x48(%ebx),%eax
1125e2: 50 push %eax
1125e3: e8 7c ce ff ff call 10f464 <_Watchdog_Remove>
1125e8: 83 c4 10 add $0x10,%esp
1125eb: eb c7 jmp 1125b4 <_Thread_Reset+0x54>
001114f0 <_Thread_Resume>:
*/
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
1114f0: 55 push %ebp
1114f1: 89 e5 mov %esp,%ebp
1114f3: 53 push %ebx
1114f4: 83 ec 04 sub $0x4,%esp
1114f7: 8b 45 08 mov 0x8(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
1114fa: 9c pushf
1114fb: fa cli
1114fc: 5b pop %ebx
current_state = the_thread->current_state;
1114fd: 8b 50 10 mov 0x10(%eax),%edx
if ( current_state & STATES_SUSPENDED ) {
111500: f6 c2 02 test $0x2,%dl
111503: 74 0a je 11150f <_Thread_Resume+0x1f> <== NEVER TAKEN
111505: 83 e2 fd and $0xfffffffd,%edx
current_state =
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
111508: 89 50 10 mov %edx,0x10(%eax)
if ( _States_Is_ready( current_state ) ) {
11150b: 85 d2 test %edx,%edx
11150d: 74 09 je 111518 <_Thread_Resume+0x28>
_Scheduler_Unblock( the_thread );
}
}
_ISR_Enable( level );
11150f: 53 push %ebx
111510: 9d popf
}
111511: 8b 5d fc mov -0x4(%ebp),%ebx
111514: c9 leave
111515: c3 ret
111516: 66 90 xchg %ax,%ax
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(
Thread_Control *the_thread
)
{
_Scheduler.Operations.unblock( the_thread );
111518: 83 ec 0c sub $0xc,%esp
11151b: 50 push %eax
11151c: ff 15 74 72 12 00 call *0x127274
111522: 83 c4 10 add $0x10,%esp
111525: eb e8 jmp 11150f <_Thread_Resume+0x1f>
0010e23c <_Thread_Stack_Allocate>:
size_t _Thread_Stack_Allocate(
Thread_Control *the_thread,
size_t stack_size
)
{
10e23c: 55 push %ebp
10e23d: 89 e5 mov %esp,%ebp
10e23f: 53 push %ebx
10e240: 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;
10e243: a1 70 3a 12 00 mov 0x123a70,%eax
10e248: 8b 5d 0c mov 0xc(%ebp),%ebx
10e24b: 39 c3 cmp %eax,%ebx
10e24d: 73 02 jae 10e251 <_Thread_Stack_Allocate+0x15>
10e24f: 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 ) {
10e251: a1 a0 3a 12 00 mov 0x123aa0,%eax
10e256: 85 c0 test %eax,%eax
10e258: 74 32 je 10e28c <_Thread_Stack_Allocate+0x50>
stack_addr = (*Configuration.stack_allocate_hook)( the_stack_size );
10e25a: 83 ec 0c sub $0xc,%esp
10e25d: 53 push %ebx
10e25e: ff d0 call *%eax
10e260: 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 )
10e263: 85 c0 test %eax,%eax
10e265: 74 11 je 10e278 <_Thread_Stack_Allocate+0x3c>
the_stack_size = 0;
the_thread->Start.stack = stack_addr;
10e267: 8b 55 08 mov 0x8(%ebp),%edx
10e26a: 89 82 c4 00 00 00 mov %eax,0xc4(%edx)
return the_stack_size;
}
10e270: 89 d8 mov %ebx,%eax
10e272: 8b 5d fc mov -0x4(%ebp),%ebx
10e275: c9 leave
10e276: c3 ret
10e277: 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;
10e278: 31 db xor %ebx,%ebx
the_thread->Start.stack = stack_addr;
10e27a: 8b 55 08 mov 0x8(%ebp),%edx
10e27d: 89 82 c4 00 00 00 mov %eax,0xc4(%edx)
return the_stack_size;
}
10e283: 89 d8 mov %ebx,%eax
10e285: 8b 5d fc mov -0x4(%ebp),%ebx
10e288: c9 leave
10e289: c3 ret
10e28a: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE uint32_t _Stack_Adjust_size (
size_t size
)
{
return size + CPU_STACK_ALIGNMENT;
10e28c: 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 );
10e28f: 83 ec 0c sub $0xc,%esp
10e292: 53 push %ebx
10e293: e8 f0 06 00 00 call 10e988 <_Workspace_Allocate>
10e298: 83 c4 10 add $0x10,%esp
10e29b: eb c6 jmp 10e263 <_Thread_Stack_Allocate+0x27>
0010e2a0 <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
10e2a0: 55 push %ebp
10e2a1: 89 e5 mov %esp,%ebp
10e2a3: 83 ec 08 sub $0x8,%esp
10e2a6: 8b 45 08 mov 0x8(%ebp),%eax
#if defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API)
/*
* If the API provided the stack space, then don't free it.
*/
if ( !the_thread->Start.core_allocated_stack )
10e2a9: 80 b8 b4 00 00 00 00 cmpb $0x0,0xb4(%eax)
10e2b0: 74 16 je 10e2c8 <_Thread_Stack_Free+0x28>
* 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 )
10e2b2: 8b 15 a4 3a 12 00 mov 0x123aa4,%edx
10e2b8: 85 d2 test %edx,%edx
10e2ba: 74 10 je 10e2cc <_Thread_Stack_Free+0x2c>
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
10e2bc: 8b 80 bc 00 00 00 mov 0xbc(%eax),%eax
10e2c2: 89 45 08 mov %eax,0x8(%ebp)
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
10e2c5: 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 );
10e2c6: ff e2 jmp *%edx
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
10e2c8: c9 leave
10e2c9: c3 ret
10e2ca: 66 90 xchg %ax,%ax
*/
if ( Configuration.stack_free_hook )
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
10e2cc: 8b 80 bc 00 00 00 mov 0xbc(%eax),%eax
10e2d2: 89 45 08 mov %eax,0x8(%ebp)
}
10e2d5: 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 );
10e2d6: e9 c9 06 00 00 jmp 10e9a4 <_Workspace_Free>
001118d8 <_Thread_Suspend>:
* select map
*/
void _Thread_Suspend(
Thread_Control *the_thread
)
{
1118d8: 55 push %ebp
1118d9: 89 e5 mov %esp,%ebp
1118db: 53 push %ebx
1118dc: 83 ec 04 sub $0x4,%esp
1118df: 8b 45 08 mov 0x8(%ebp),%eax
ISR_Level level;
_ISR_Disable( level );
1118e2: 9c pushf
1118e3: fa cli
1118e4: 5b pop %ebx
if ( !_States_Is_ready( the_thread->current_state ) ) {
1118e5: 8b 50 10 mov 0x10(%eax),%edx
1118e8: 85 d2 test %edx,%edx
1118ea: 74 10 je 1118fc <_Thread_Suspend+0x24>
1118ec: 83 ca 02 or $0x2,%edx
1118ef: 89 50 10 mov %edx,0x10(%eax)
the_thread->current_state =
_States_Set( STATES_SUSPENDED, the_thread->current_state );
_ISR_Enable( level );
1118f2: 53 push %ebx
1118f3: 9d popf
the_thread->current_state = STATES_SUSPENDED;
_Scheduler_Block( the_thread );
_ISR_Enable( level );
}
1118f4: 8b 5d fc mov -0x4(%ebp),%ebx
1118f7: c9 leave
1118f8: c3 ret
1118f9: 8d 76 00 lea 0x0(%esi),%esi
_States_Set( STATES_SUSPENDED, the_thread->current_state );
_ISR_Enable( level );
return;
}
the_thread->current_state = STATES_SUSPENDED;
1118fc: c7 40 10 02 00 00 00 movl $0x2,0x10(%eax)
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Block(
Thread_Control *the_thread
)
{
_Scheduler.Operations.block( the_thread );
111903: 83 ec 0c sub $0xc,%esp
111906: 50 push %eax
111907: ff 15 90 39 12 00 call *0x123990
_Scheduler_Block( the_thread );
_ISR_Enable( level );
11190d: 53 push %ebx
11190e: 9d popf
11190f: 83 c4 10 add $0x10,%esp
}
111912: 8b 5d fc mov -0x4(%ebp),%ebx
111915: c9 leave
111916: c3 ret
0010e398 <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
10e398: 55 push %ebp
10e399: 89 e5 mov %esp,%ebp
10e39b: 53 push %ebx
10e39c: 83 ec 04 sub $0x4,%esp
Thread_Control *executing;
executing = _Thread_Executing;
10e39f: 8b 1d 38 83 12 00 mov 0x128338,%ebx
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
10e3a5: 80 7b 74 00 cmpb $0x0,0x74(%ebx)
10e3a9: 74 19 je 10e3c4 <_Thread_Tickle_timeslice+0x2c>
return;
if ( !_States_Is_ready( executing->current_state ) )
10e3ab: 8b 43 10 mov 0x10(%ebx),%eax
10e3ae: 85 c0 test %eax,%eax
10e3b0: 75 12 jne 10e3c4 <_Thread_Tickle_timeslice+0x2c>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
10e3b2: 8b 43 7c mov 0x7c(%ebx),%eax
10e3b5: 83 f8 01 cmp $0x1,%eax
10e3b8: 72 0a jb 10e3c4 <_Thread_Tickle_timeslice+0x2c>
10e3ba: 83 f8 02 cmp $0x2,%eax
10e3bd: 76 29 jbe 10e3e8 <_Thread_Tickle_timeslice+0x50>
10e3bf: 83 f8 03 cmp $0x3,%eax
10e3c2: 74 08 je 10e3cc <_Thread_Tickle_timeslice+0x34><== ALWAYS TAKEN
if ( --executing->cpu_time_budget == 0 )
(*executing->budget_callout)( executing );
break;
#endif
}
}
10e3c4: 8b 5d fc mov -0x4(%ebp),%ebx
10e3c7: c9 leave
10e3c8: c3 ret
10e3c9: 8d 76 00 lea 0x0(%esi),%esi
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
10e3cc: 8b 43 78 mov 0x78(%ebx),%eax
10e3cf: 48 dec %eax
10e3d0: 89 43 78 mov %eax,0x78(%ebx)
10e3d3: 85 c0 test %eax,%eax
10e3d5: 75 ed jne 10e3c4 <_Thread_Tickle_timeslice+0x2c>
(*executing->budget_callout)( executing );
10e3d7: 83 ec 0c sub $0xc,%esp
10e3da: 53 push %ebx
10e3db: ff 93 80 00 00 00 call *0x80(%ebx)
10e3e1: 83 c4 10 add $0x10,%esp
10e3e4: eb de jmp 10e3c4 <_Thread_Tickle_timeslice+0x2c>
10e3e6: 66 90 xchg %ax,%ax
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
#endif
if ( (int)(--executing->cpu_time_budget) <= 0 ) {
10e3e8: 8b 43 78 mov 0x78(%ebx),%eax
10e3eb: 48 dec %eax
10e3ec: 89 43 78 mov %eax,0x78(%ebx)
10e3ef: 85 c0 test %eax,%eax
10e3f1: 7f d1 jg 10e3c4 <_Thread_Tickle_timeslice+0x2c>
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
10e3f3: ff 15 8c 39 12 00 call *0x12398c
* executing thread's timeslice is reset. Otherwise, the
* currently executing thread is placed at the rear of the
* FIFO for this priority and a new heir is selected.
*/
_Scheduler_Yield( );
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
10e3f9: a1 60 7d 12 00 mov 0x127d60,%eax
10e3fe: 89 43 78 mov %eax,0x78(%ebx)
10e401: eb c1 jmp 10e3c4 <_Thread_Tickle_timeslice+0x2c>
0010dd78 <_Thread_queue_Dequeue_priority>:
*/
Thread_Control *_Thread_queue_Dequeue_priority(
Thread_queue_Control *the_thread_queue
)
{
10dd78: 55 push %ebp
10dd79: 89 e5 mov %esp,%ebp
10dd7b: 57 push %edi
10dd7c: 56 push %esi
10dd7d: 53 push %ebx
10dd7e: 83 ec 2c sub $0x2c,%esp
10dd81: 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 );
10dd84: 9c pushf
10dd85: fa cli
10dd86: 58 pop %eax
10dd87: 89 f9 mov %edi,%ecx
for( index=0 ;
10dd89: 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 );
}
10dd8b: 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 );
10dd8d: 8d 34 52 lea (%edx,%edx,2),%esi
10dd90: 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 ] ) ) {
10dd94: 39 f3 cmp %esi,%ebx
10dd96: 75 18 jne 10ddb0 <_Thread_queue_Dequeue_priority+0x38>
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
10dd98: 42 inc %edx
10dd99: 83 c1 0c add $0xc,%ecx
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
10dd9c: 83 fa 04 cmp $0x4,%edx
10dd9f: 75 ea jne 10dd8b <_Thread_queue_Dequeue_priority+0x13>
}
/*
* We did not find a thread to unblock.
*/
_ISR_Enable( level );
10dda1: 50 push %eax
10dda2: 9d popf
return NULL;
10dda3: 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 );
}
10dda5: 89 f0 mov %esi,%eax
10dda7: 8d 65 f4 lea -0xc(%ebp),%esp
10ddaa: 5b pop %ebx
10ddab: 5e pop %esi
10ddac: 5f pop %edi
10ddad: c9 leave
10ddae: c3 ret
10ddaf: 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(
10ddb0: 89 de mov %ebx,%esi
*/
_ISR_Enable( level );
return NULL;
dequeue:
the_thread->Wait.queue = NULL;
10ddb2: 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 );
}
10ddb9: 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;
10ddbc: 8b 0b mov (%ebx),%ecx
previous_node = the_thread->Object.Node.previous;
10ddbe: 8b 7b 04 mov 0x4(%ebx),%edi
10ddc1: 89 7d d4 mov %edi,-0x2c(%ebp)
10ddc4: 8d 7b 3c lea 0x3c(%ebx),%edi
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
10ddc7: 39 fa cmp %edi,%edx
10ddc9: 74 7f je 10de4a <_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 );
}
10ddcb: 8b 7b 40 mov 0x40(%ebx),%edi
10ddce: 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;
10ddd1: 8b 3a mov (%edx),%edi
10ddd3: 89 7d e0 mov %edi,-0x20(%ebp)
previous_node->next = new_first_node;
10ddd6: 8b 7d d4 mov -0x2c(%ebp),%edi
10ddd9: 89 17 mov %edx,(%edi)
next_node->previous = new_first_node;
10dddb: 89 51 04 mov %edx,0x4(%ecx)
new_first_node->next = next_node;
10ddde: 89 0a mov %ecx,(%edx)
new_first_node->previous = previous_node;
10dde0: 89 7a 04 mov %edi,0x4(%edx)
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
10dde3: 8b 4b 40 mov 0x40(%ebx),%ecx
10dde6: 39 4b 38 cmp %ecx,0x38(%ebx)
10dde9: 74 17 je 10de02 <_Thread_queue_Dequeue_priority+0x8a>
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
10ddeb: 8d 4a 38 lea 0x38(%edx),%ecx
10ddee: 8b 7d e0 mov -0x20(%ebp),%edi
10ddf1: 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;
10ddf4: 89 7a 38 mov %edi,0x38(%edx)
tail->previous = last_node;
10ddf7: 8b 4d e4 mov -0x1c(%ebp),%ecx
10ddfa: 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 );
10ddfd: 83 c2 3c add $0x3c,%edx
10de00: 89 11 mov %edx,(%ecx)
} else {
previous_node->next = next_node;
next_node->previous = previous_node;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10de02: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10de06: 74 18 je 10de20 <_Thread_queue_Dequeue_priority+0xa8>
_ISR_Enable( level );
10de08: 50 push %eax
10de09: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10de0a: 83 ec 08 sub $0x8,%esp
10de0d: 68 f8 ff 03 10 push $0x1003fff8
10de12: 53 push %ebx
10de13: e8 34 f8 ff ff call 10d64c <_Thread_Clear_state>
10de18: 83 c4 10 add $0x10,%esp
10de1b: eb 88 jmp 10dda5 <_Thread_queue_Dequeue_priority+0x2d>
10de1d: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
10de20: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
10de27: 50 push %eax
10de28: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
10de29: 83 ec 0c sub $0xc,%esp
10de2c: 8d 43 48 lea 0x48(%ebx),%eax
10de2f: 50 push %eax
10de30: e8 2b 0a 00 00 call 10e860 <_Watchdog_Remove>
10de35: 58 pop %eax
10de36: 5a pop %edx
10de37: 68 f8 ff 03 10 push $0x1003fff8
10de3c: 53 push %ebx
10de3d: e8 0a f8 ff ff call 10d64c <_Thread_Clear_state>
10de42: 83 c4 10 add $0x10,%esp
10de45: e9 5b ff ff ff jmp 10dda5 <_Thread_queue_Dequeue_priority+0x2d>
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
10de4a: 8b 7d d4 mov -0x2c(%ebp),%edi
10de4d: 89 0f mov %ecx,(%edi)
next_node->previous = previous_node;
10de4f: 89 79 04 mov %edi,0x4(%ecx)
10de52: eb ae jmp 10de02 <_Thread_queue_Dequeue_priority+0x8a>
0010deec <_Thread_queue_Enqueue_priority>:
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
10deec: 55 push %ebp
10deed: 89 e5 mov %esp,%ebp
10deef: 57 push %edi
10def0: 56 push %esi
10def1: 53 push %ebx
10def2: 83 ec 0c sub $0xc,%esp
10def5: 8b 7d 0c mov 0xc(%ebp),%edi
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 );
10def8: 8d 47 3c lea 0x3c(%edi),%eax
10defb: 89 47 38 mov %eax,0x38(%edi)
head->next = tail;
head->previous = NULL;
10defe: c7 47 3c 00 00 00 00 movl $0x0,0x3c(%edi)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
10df05: 8d 47 38 lea 0x38(%edi),%eax
10df08: 89 47 40 mov %eax,0x40(%edi)
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
10df0b: 8b 57 14 mov 0x14(%edi),%edx
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
10df0e: 89 d0 mov %edx,%eax
10df10: c1 e8 06 shr $0x6,%eax
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
10df13: 8b 4d 08 mov 0x8(%ebp),%ecx
10df16: 8b 59 38 mov 0x38(%ecx),%ebx
if ( _Thread_queue_Is_reverse_search( priority ) )
10df19: f6 c2 20 test $0x20,%dl
10df1c: 75 66 jne 10df84 <_Thread_queue_Enqueue_priority+0x98>
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
10df1e: 8d 04 40 lea (%eax,%eax,2),%eax
10df21: 8d 04 81 lea (%ecx,%eax,4),%eax
10df24: 89 45 f0 mov %eax,-0x10(%ebp)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
10df27: 83 c0 04 add $0x4,%eax
10df2a: 89 7d e8 mov %edi,-0x18(%ebp)
10df2d: 89 c7 mov %eax,%edi
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
10df2f: 9c pushf
10df30: fa cli
10df31: 5e pop %esi
10df32: 89 75 ec mov %esi,-0x14(%ebp)
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
10df35: 8b 4d f0 mov -0x10(%ebp),%ecx
10df38: 8b 01 mov (%ecx),%eax
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
10df3a: 39 f8 cmp %edi,%eax
10df3c: 75 18 jne 10df56 <_Thread_queue_Enqueue_priority+0x6a>
10df3e: e9 0e 01 00 00 jmp 10e051 <_Thread_queue_Enqueue_priority+0x165>
10df43: 90 nop
break;
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
10df44: 56 push %esi
10df45: 9d popf
10df46: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10df47: 85 58 10 test %ebx,0x10(%eax)
10df4a: 0f 84 ac 00 00 00 je 10dffc <_Thread_queue_Enqueue_priority+0x110>
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
10df50: 8b 00 mov (%eax),%eax
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
10df52: 39 f8 cmp %edi,%eax
10df54: 74 07 je 10df5d <_Thread_queue_Enqueue_priority+0x71>
search_priority = search_thread->current_priority;
10df56: 8b 48 14 mov 0x14(%eax),%ecx
if ( priority <= search_priority )
10df59: 39 ca cmp %ecx,%edx
10df5b: 77 e7 ja 10df44 <_Thread_queue_Enqueue_priority+0x58>
10df5d: 8b 7d e8 mov -0x18(%ebp),%edi
10df60: 89 75 f0 mov %esi,-0x10(%ebp)
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
10df63: 8b 75 08 mov 0x8(%ebp),%esi
10df66: 8b 5e 30 mov 0x30(%esi),%ebx
10df69: 83 fb 01 cmp $0x1,%ebx
10df6c: 0f 84 92 00 00 00 je 10e004 <_Thread_queue_Enqueue_priority+0x118>
* For example, the blocking thread could have been given
* the mutex by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
10df72: 8b 45 10 mov 0x10(%ebp),%eax
10df75: 8b 55 ec mov -0x14(%ebp),%edx
10df78: 89 10 mov %edx,(%eax)
return the_thread_queue->sync_state;
}
10df7a: 89 d8 mov %ebx,%eax
10df7c: 83 c4 0c add $0xc,%esp
10df7f: 5b pop %ebx
10df80: 5e pop %esi
10df81: 5f pop %edi
10df82: c9 leave
10df83: c3 ret
10df84: 8d 04 40 lea (%eax,%eax,2),%eax
10df87: 8b 4d 08 mov 0x8(%ebp),%ecx
10df8a: 8d 34 81 lea (%ecx,%eax,4),%esi
10df8d: 89 7d f0 mov %edi,-0x10(%ebp)
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
10df90: 0f b6 0d 74 3a 12 00 movzbl 0x123a74,%ecx
10df97: 41 inc %ecx
_ISR_Disable( level );
10df98: 9c pushf
10df99: fa cli
10df9a: 5f pop %edi
10df9b: 89 7d ec mov %edi,-0x14(%ebp)
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
10df9e: 8b 46 08 mov 0x8(%esi),%eax
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
10dfa1: 39 f0 cmp %esi,%eax
10dfa3: 75 12 jne 10dfb7 <_Thread_queue_Enqueue_priority+0xcb>
10dfa5: eb 17 jmp 10dfbe <_Thread_queue_Enqueue_priority+0xd2>
10dfa7: 90 nop
break;
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
10dfa8: 57 push %edi
10dfa9: 9d popf
10dfaa: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10dfab: 85 58 10 test %ebx,0x10(%eax)
10dfae: 74 48 je 10dff8 <_Thread_queue_Enqueue_priority+0x10c><== NEVER TAKEN
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
10dfb0: 8b 40 04 mov 0x4(%eax),%eax
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
10dfb3: 39 f0 cmp %esi,%eax
10dfb5: 74 07 je 10dfbe <_Thread_queue_Enqueue_priority+0xd2>
search_priority = search_thread->current_priority;
10dfb7: 8b 48 14 mov 0x14(%eax),%ecx
if ( priority >= search_priority )
10dfba: 39 ca cmp %ecx,%edx
10dfbc: 72 ea jb 10dfa8 <_Thread_queue_Enqueue_priority+0xbc>
10dfbe: 89 7d e8 mov %edi,-0x18(%ebp)
10dfc1: 8b 7d f0 mov -0x10(%ebp),%edi
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
10dfc4: 8b 75 08 mov 0x8(%ebp),%esi
10dfc7: 8b 5e 30 mov 0x30(%esi),%ebx
10dfca: 83 fb 01 cmp $0x1,%ebx
10dfcd: 75 a3 jne 10df72 <_Thread_queue_Enqueue_priority+0x86>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10dfcf: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi)
if ( priority == search_priority )
10dfd6: 39 ca cmp %ecx,%edx
10dfd8: 74 53 je 10e02d <_Thread_queue_Enqueue_priority+0x141>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
10dfda: 8b 10 mov (%eax),%edx
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
10dfdc: 89 17 mov %edx,(%edi)
the_node->previous = search_node;
10dfde: 89 47 04 mov %eax,0x4(%edi)
search_node->next = the_node;
10dfe1: 89 38 mov %edi,(%eax)
next_node->previous = the_node;
10dfe3: 89 7a 04 mov %edi,0x4(%edx)
the_thread->Wait.queue = the_thread_queue;
10dfe6: 89 77 44 mov %esi,0x44(%edi)
_ISR_Enable( level );
10dfe9: ff 75 e8 pushl -0x18(%ebp)
10dfec: 9d popf
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
10dfed: 89 d8 mov %ebx,%eax
10dfef: 83 c4 0c add $0xc,%esp
10dff2: 5b pop %ebx
10dff3: 5e pop %esi
10dff4: 5f pop %edi
10dff5: c9 leave
10dff6: c3 ret
10dff7: 90 nop
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
_ISR_Enable( level );
10dff8: 57 push %edi <== NOT EXECUTED
10dff9: 9d popf <== NOT EXECUTED
goto restart_reverse_search;
10dffa: eb 94 jmp 10df90 <_Thread_queue_Enqueue_priority+0xa4><== NOT EXECUTED
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
_ISR_Enable( level );
10dffc: 56 push %esi
10dffd: 9d popf
goto restart_forward_search;
10dffe: e9 2c ff ff ff jmp 10df2f <_Thread_queue_Enqueue_priority+0x43>
10e003: 90 nop
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10e004: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi)
if ( priority == search_priority )
10e00b: 39 ca cmp %ecx,%edx
10e00d: 74 1e je 10e02d <_Thread_queue_Enqueue_priority+0x141>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
10e00f: 8b 50 04 mov 0x4(%eax),%edx
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
10e012: 89 07 mov %eax,(%edi)
the_node->previous = previous_node;
10e014: 89 57 04 mov %edx,0x4(%edi)
previous_node->next = the_node;
10e017: 89 3a mov %edi,(%edx)
search_node->previous = the_node;
10e019: 89 78 04 mov %edi,0x4(%eax)
the_thread->Wait.queue = the_thread_queue;
10e01c: 89 77 44 mov %esi,0x44(%edi)
_ISR_Enable( level );
10e01f: ff 75 f0 pushl -0x10(%ebp)
10e022: 9d popf
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
10e023: 89 d8 mov %ebx,%eax
10e025: 83 c4 0c add $0xc,%esp
10e028: 5b pop %ebx
10e029: 5e pop %esi
10e02a: 5f pop %edi
10e02b: c9 leave
10e02c: c3 ret
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
10e02d: 8b 50 40 mov 0x40(%eax),%edx
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
10e030: 8d 48 3c lea 0x3c(%eax),%ecx
10e033: 89 0f mov %ecx,(%edi)
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
the_node->previous = previous_node;
10e035: 89 57 04 mov %edx,0x4(%edi)
previous_node->next = the_node;
10e038: 89 3a mov %edi,(%edx)
search_node->previous = the_node;
10e03a: 89 78 40 mov %edi,0x40(%eax)
the_thread->Wait.queue = the_thread_queue;
10e03d: 8b 45 08 mov 0x8(%ebp),%eax
10e040: 89 47 44 mov %eax,0x44(%edi)
_ISR_Enable( level );
10e043: ff 75 ec pushl -0x14(%ebp)
10e046: 9d popf
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10e047: bb 01 00 00 00 mov $0x1,%ebx
10e04c: e9 29 ff ff ff jmp 10df7a <_Thread_queue_Enqueue_priority+0x8e>
10e051: 8b 7d e8 mov -0x18(%ebp),%edi
10e054: 89 75 f0 mov %esi,-0x10(%ebp)
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
10e057: b9 ff ff ff ff mov $0xffffffff,%ecx
10e05c: e9 02 ff ff ff jmp 10df63 <_Thread_queue_Enqueue_priority+0x77>
00111780 <_Thread_queue_Extract>:
void _Thread_queue_Extract(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
111780: 55 push %ebp
111781: 89 e5 mov %esp,%ebp
111783: 83 ec 08 sub $0x8,%esp
111786: 8b 45 08 mov 0x8(%ebp),%eax
111789: 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 )
11178c: 83 78 34 01 cmpl $0x1,0x34(%eax)
111790: 74 0e je 1117a0 <_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 );
111792: 89 55 0c mov %edx,0xc(%ebp)
111795: 89 45 08 mov %eax,0x8(%ebp)
}
111798: 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 );
111799: e9 de 19 00 00 jmp 11317c <_Thread_queue_Extract_fifo>
11179e: 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 );
1117a0: 51 push %ecx
1117a1: 6a 00 push $0x0
1117a3: 52 push %edx
1117a4: 50 push %eax
1117a5: e8 06 00 00 00 call 1117b0 <_Thread_queue_Extract_priority_helper>
1117aa: 83 c4 10 add $0x10,%esp
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
_Thread_queue_Extract_fifo( the_thread_queue, the_thread );
}
1117ad: c9 leave
1117ae: c3 ret
0011317c <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
11317c: 55 push %ebp
11317d: 89 e5 mov %esp,%ebp
11317f: 53 push %ebx
113180: 83 ec 04 sub $0x4,%esp
113183: 8b 5d 0c mov 0xc(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
113186: 9c pushf
113187: fa cli
113188: 58 pop %eax
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
113189: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx)
113190: 74 2e je 1131c0 <_Thread_queue_Extract_fifo+0x44>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
113192: 8b 0b mov (%ebx),%ecx
previous = the_node->previous;
113194: 8b 53 04 mov 0x4(%ebx),%edx
next->previous = previous;
113197: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
11319a: 89 0a mov %ecx,(%edx)
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
11319c: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
1131a3: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
1131a7: 74 1f je 1131c8 <_Thread_queue_Extract_fifo+0x4c>
_ISR_Enable( level );
1131a9: 50 push %eax
1131aa: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
1131ab: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp)
1131b2: 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
}
1131b5: 8b 5d fc mov -0x4(%ebp),%ebx
1131b8: c9 leave
1131b9: e9 8e a4 ff ff jmp 10d64c <_Thread_Clear_state>
1131be: 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 );
1131c0: 50 push %eax
1131c1: 9d popf
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
1131c2: 8b 5d fc mov -0x4(%ebp),%ebx
1131c5: c9 leave
1131c6: c3 ret
1131c7: 90 nop
1131c8: 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 );
1131cf: 50 push %eax
1131d0: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
1131d1: 83 ec 0c sub $0xc,%esp
1131d4: 8d 43 48 lea 0x48(%ebx),%eax
1131d7: 50 push %eax
1131d8: e8 83 b6 ff ff call 10e860 <_Watchdog_Remove>
1131dd: 83 c4 10 add $0x10,%esp
1131e0: eb c9 jmp 1131ab <_Thread_queue_Extract_fifo+0x2f>
001117b0 <_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
)
{
1117b0: 55 push %ebp
1117b1: 89 e5 mov %esp,%ebp
1117b3: 57 push %edi
1117b4: 56 push %esi
1117b5: 53 push %ebx
1117b6: 83 ec 1c sub $0x1c,%esp
1117b9: 8b 5d 0c mov 0xc(%ebp),%ebx
1117bc: 8a 45 10 mov 0x10(%ebp),%al
1117bf: 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 );
1117c2: 9c pushf
1117c3: fa cli
1117c4: 8f 45 e4 popl -0x1c(%ebp)
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
1117c7: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx)
1117ce: 74 6c je 11183c <_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;
1117d0: 8b 13 mov (%ebx),%edx
previous_node = the_node->previous;
1117d2: 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
}
1117d5: 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 );
1117d8: 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 ) ) {
1117db: 39 f0 cmp %esi,%eax
1117dd: 74 69 je 111848 <_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
}
1117df: 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;
1117e2: 8b 30 mov (%eax),%esi
previous_node->next = new_first_node;
1117e4: 89 01 mov %eax,(%ecx)
next_node->previous = new_first_node;
1117e6: 89 42 04 mov %eax,0x4(%edx)
new_first_node->next = next_node;
1117e9: 89 10 mov %edx,(%eax)
new_first_node->previous = previous_node;
1117eb: 89 48 04 mov %ecx,0x4(%eax)
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
1117ee: 8b 53 40 mov 0x40(%ebx),%edx
1117f1: 39 53 38 cmp %edx,0x38(%ebx)
1117f4: 74 11 je 111807 <_Thread_queue_Extract_priority_helper+0x57>
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
1117f6: 8d 50 38 lea 0x38(%eax),%edx
1117f9: 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;
1117fc: 89 70 38 mov %esi,0x38(%eax)
tail->previous = last_node;
1117ff: 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 );
111802: 83 c0 3c add $0x3c,%eax
111805: 89 07 mov %eax,(%edi)
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
111807: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
11180b: 75 23 jne 111830 <_Thread_queue_Extract_priority_helper+0x80>
_ISR_Enable( level );
return;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
11180d: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
111811: 74 3d je 111850 <_Thread_queue_Extract_priority_helper+0xa0>
_ISR_Enable( level );
111813: ff 75 e4 pushl -0x1c(%ebp)
111816: 9d popf
111817: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp)
11181e: 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
}
111821: 8d 65 f4 lea -0xc(%ebp),%esp
111824: 5b pop %ebx
111825: 5e pop %esi
111826: 5f pop %edi
111827: c9 leave
111828: e9 1f be ff ff jmp 10d64c <_Thread_Clear_state>
11182d: 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 );
111830: ff 75 e4 pushl -0x1c(%ebp)
111833: 9d popf
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
111834: 8d 65 f4 lea -0xc(%ebp),%esp
111837: 5b pop %ebx
111838: 5e pop %esi
111839: 5f pop %edi
11183a: c9 leave
11183b: 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 );
11183c: ff 75 e4 pushl -0x1c(%ebp)
11183f: 9d popf
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
111840: 8d 65 f4 lea -0xc(%ebp),%esp
111843: 5b pop %ebx
111844: 5e pop %esi
111845: 5f pop %edi
111846: c9 leave
111847: c3 ret
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
111848: 89 11 mov %edx,(%ecx)
next_node->previous = previous_node;
11184a: 89 4a 04 mov %ecx,0x4(%edx)
11184d: eb b8 jmp 111807 <_Thread_queue_Extract_priority_helper+0x57>
11184f: 90 nop
111850: 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 );
111857: ff 75 e4 pushl -0x1c(%ebp)
11185a: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
11185b: 83 ec 0c sub $0xc,%esp
11185e: 8d 43 48 lea 0x48(%ebx),%eax
111861: 50 push %eax
111862: e8 f9 cf ff ff call 10e860 <_Watchdog_Remove>
111867: 83 c4 10 add $0x10,%esp
11186a: eb ab jmp 111817 <_Thread_queue_Extract_priority_helper+0x67>
0010e064 <_Thread_queue_Extract_with_proxy>:
*/
bool _Thread_queue_Extract_with_proxy(
Thread_Control *the_thread
)
{
10e064: 55 push %ebp
10e065: 89 e5 mov %esp,%ebp
10e067: 83 ec 08 sub $0x8,%esp
10e06a: 8b 45 08 mov 0x8(%ebp),%eax
States_Control state;
state = the_thread->current_state;
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10e06d: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax)
10e074: 75 06 jne 10e07c <_Thread_queue_Extract_with_proxy+0x18>
#endif
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
return true;
}
return false;
10e076: 31 c0 xor %eax,%eax
}
10e078: c9 leave
10e079: c3 ret
10e07a: 66 90 xchg %ax,%ax
if ( proxy_extract_callout )
(*proxy_extract_callout)( the_thread );
}
#endif
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
10e07c: 83 ec 08 sub $0x8,%esp
10e07f: 50 push %eax
10e080: ff 70 44 pushl 0x44(%eax)
10e083: e8 f8 36 00 00 call 111780 <_Thread_queue_Extract>
return true;
10e088: 83 c4 10 add $0x10,%esp
10e08b: b0 01 mov $0x1,%al
}
return false;
}
10e08d: c9 leave
10e08e: c3 ret
0010febc <_Thread_queue_First>:
*/
Thread_Control *_Thread_queue_First(
Thread_queue_Control *the_thread_queue
)
{
10febc: 55 push %ebp
10febd: 89 e5 mov %esp,%ebp
10febf: 83 ec 08 sub $0x8,%esp
10fec2: 8b 45 08 mov 0x8(%ebp),%eax
Thread_Control * (*first_p)(Thread_queue_Control *);
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
10fec5: 83 78 34 01 cmpl $0x1,0x34(%eax)
10fec9: 74 0d je 10fed8 <_Thread_queue_First+0x1c>
first_p = _Thread_queue_First_priority;
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
first_p = _Thread_queue_First_fifo;
10fecb: ba 04 37 11 00 mov $0x113704,%edx
return (*first_p)( the_thread_queue );
10fed0: 89 45 08 mov %eax,0x8(%ebp)
}
10fed3: 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 );
10fed4: ff e2 jmp *%edx
10fed6: 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;
10fed8: ba e4 fe 10 00 mov $0x10fee4,%edx
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
first_p = _Thread_queue_First_fifo;
return (*first_p)( the_thread_queue );
10fedd: 89 45 08 mov %eax,0x8(%ebp)
}
10fee0: 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 );
10fee1: ff e2 jmp *%edx
00113704 <_Thread_queue_First_fifo>:
*/
Thread_Control *_Thread_queue_First_fifo(
Thread_queue_Control *the_thread_queue
)
{
113704: 55 push %ebp
113705: 89 e5 mov %esp,%ebp
113707: 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;
}
11370a: 8b 02 mov (%edx),%eax
11370c: 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 ) )
11370f: 39 d0 cmp %edx,%eax
113711: 74 05 je 113718 <_Thread_queue_First_fifo+0x14>
return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Fifo );
return NULL;
}
113713: c9 leave
113714: c3 ret
113715: 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;
113718: 31 c0 xor %eax,%eax
}
11371a: c9 leave
11371b: c3 ret
0010e090 <_Thread_queue_Flush>:
#else
Thread_queue_Flush_callout remote_extract_callout __attribute__((unused)),
#endif
uint32_t status
)
{
10e090: 55 push %ebp
10e091: 89 e5 mov %esp,%ebp
10e093: 56 push %esi
10e094: 53 push %ebx
10e095: 8b 5d 08 mov 0x8(%ebp),%ebx
10e098: 8b 75 10 mov 0x10(%ebp),%esi
Thread_Control *the_thread;
while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) {
10e09b: eb 06 jmp 10e0a3 <_Thread_queue_Flush+0x13>
10e09d: 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;
10e0a0: 89 70 34 mov %esi,0x34(%eax)
uint32_t status
)
{
Thread_Control *the_thread;
while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) {
10e0a3: 83 ec 0c sub $0xc,%esp
10e0a6: 53 push %ebx
10e0a7: e8 80 fc ff ff call 10dd2c <_Thread_queue_Dequeue>
10e0ac: 83 c4 10 add $0x10,%esp
10e0af: 85 c0 test %eax,%eax
10e0b1: 75 ed jne 10e0a0 <_Thread_queue_Flush+0x10>
( *remote_extract_callout )( the_thread );
else
#endif
the_thread->Wait.return_code = status;
}
}
10e0b3: 8d 65 f8 lea -0x8(%ebp),%esp
10e0b6: 5b pop %ebx
10e0b7: 5e pop %esi
10e0b8: c9 leave
10e0b9: c3 ret
0010e0bc <_Thread_queue_Initialize>:
Thread_queue_Control *the_thread_queue,
Thread_queue_Disciplines the_discipline,
States_Control state,
uint32_t timeout_status
)
{
10e0bc: 55 push %ebp
10e0bd: 89 e5 mov %esp,%ebp
10e0bf: 56 push %esi
10e0c0: 53 push %ebx
10e0c1: 8b 45 08 mov 0x8(%ebp),%eax
10e0c4: 8b 55 0c mov 0xc(%ebp),%edx
the_thread_queue->state = state;
10e0c7: 8b 4d 10 mov 0x10(%ebp),%ecx
10e0ca: 89 48 38 mov %ecx,0x38(%eax)
the_thread_queue->discipline = the_discipline;
10e0cd: 89 50 34 mov %edx,0x34(%eax)
the_thread_queue->timeout_status = timeout_status;
10e0d0: 8b 4d 14 mov 0x14(%ebp),%ecx
10e0d3: 89 48 3c mov %ecx,0x3c(%eax)
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10e0d6: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
10e0dd: 83 fa 01 cmp $0x1,%edx
10e0e0: 74 16 je 10e0f8 <_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 );
10e0e2: 8d 50 04 lea 0x4(%eax),%edx
10e0e5: 89 10 mov %edx,(%eax)
head->next = tail;
head->previous = NULL;
10e0e7: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
tail->previous = head;
10e0ee: 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 );
}
}
10e0f1: 5b pop %ebx
10e0f2: 5e pop %esi
10e0f3: c9 leave
10e0f4: c3 ret
10e0f5: 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 ) {
10e0f8: 89 c1 mov %eax,%ecx
10e0fa: 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 );
10e0fc: 8d 1c 52 lea (%edx,%edx,2),%ebx
10e0ff: 8d 1c 98 lea (%eax,%ebx,4),%ebx
10e102: 8d 73 04 lea 0x4(%ebx),%esi
10e105: 89 31 mov %esi,(%ecx)
head->next = tail;
head->previous = NULL;
10e107: 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 );
10e10e: 89 59 08 mov %ebx,0x8(%ecx)
uint32_t index;
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++)
10e111: 42 inc %edx
10e112: 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 ;
10e115: 83 fa 04 cmp $0x4,%edx
10e118: 75 e2 jne 10e0fc <_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 );
}
}
10e11a: 5b pop %ebx
10e11b: 5e pop %esi
10e11c: c9 leave
10e11d: c3 ret
0011186c <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
11186c: 55 push %ebp
11186d: 89 e5 mov %esp,%ebp
11186f: 83 ec 08 sub $0x8,%esp
111872: 8b 45 08 mov 0x8(%ebp),%eax
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
111875: 8b 50 44 mov 0x44(%eax),%edx
* 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.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
111878: 8b 4a 30 mov 0x30(%edx),%ecx
11187b: 85 c9 test %ecx,%ecx
11187d: 74 08 je 111887 <_Thread_queue_Process_timeout+0x1b>
11187f: 3b 05 38 83 12 00 cmp 0x128338,%eax
111885: 74 15 je 11189c <_Thread_queue_Process_timeout+0x30><== ALWAYS TAKEN
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
111887: 8b 4a 3c mov 0x3c(%edx),%ecx
11188a: 89 48 34 mov %ecx,0x34(%eax)
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
11188d: 83 ec 08 sub $0x8,%esp
111890: 50 push %eax
111891: 52 push %edx
111892: e8 e9 fe ff ff call 111780 <_Thread_queue_Extract>
111897: 83 c4 10 add $0x10,%esp
}
}
11189a: c9 leave
11189b: c3 ret
* a timeout is not allowed to occur.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
11189c: 83 f9 03 cmp $0x3,%ecx
11189f: 74 f9 je 11189a <_Thread_queue_Process_timeout+0x2e>
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
1118a1: 8b 4a 3c mov 0x3c(%edx),%ecx
1118a4: 89 48 34 mov %ecx,0x34(%eax)
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
1118a7: c7 42 30 02 00 00 00 movl $0x2,0x30(%edx)
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
}
}
1118ae: c9 leave
1118af: c3 ret
0010e120 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10e120: 55 push %ebp
10e121: 89 e5 mov %esp,%ebp
10e123: 57 push %edi
10e124: 56 push %esi
10e125: 53 push %ebx
10e126: 83 ec 1c sub $0x1c,%esp
10e129: 8b 75 08 mov 0x8(%ebp),%esi
10e12c: 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 )
10e12f: 85 f6 test %esi,%esi
10e131: 74 06 je 10e139 <_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 ) {
10e133: 83 7e 34 01 cmpl $0x1,0x34(%esi)
10e137: 74 0b je 10e144 <_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 );
}
}
10e139: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10e13c: 5b pop %ebx <== NOT EXECUTED
10e13d: 5e pop %esi <== NOT EXECUTED
10e13e: 5f pop %edi <== NOT EXECUTED
10e13f: c9 leave <== NOT EXECUTED
10e140: c3 ret <== NOT EXECUTED
10e141: 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 );
10e144: 9c pushf
10e145: fa cli
10e146: 5b pop %ebx
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10e147: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi)
10e14e: 75 0c jne 10e15c <_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 );
10e150: 53 push %ebx
10e151: 9d popf
}
}
10e152: 8d 65 f4 lea -0xc(%ebp),%esp
10e155: 5b pop %ebx
10e156: 5e pop %esi
10e157: 5f pop %edi
10e158: c9 leave
10e159: c3 ret
10e15a: 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;
10e15c: 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 );
10e163: 50 push %eax
10e164: 6a 01 push $0x1
10e166: 57 push %edi
10e167: 56 push %esi
10e168: e8 43 36 00 00 call 1117b0 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
10e16d: 83 c4 0c add $0xc,%esp
10e170: 8d 45 e4 lea -0x1c(%ebp),%eax
10e173: 50 push %eax
10e174: 57 push %edi
10e175: 56 push %esi
10e176: e8 71 fd ff ff call 10deec <_Thread_queue_Enqueue_priority>
10e17b: 83 c4 10 add $0x10,%esp
10e17e: eb d0 jmp 10e150 <_Thread_queue_Requeue+0x30>
0010e180 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10e180: 55 push %ebp
10e181: 89 e5 mov %esp,%ebp
10e183: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10e186: 8d 45 f4 lea -0xc(%ebp),%eax
10e189: 50 push %eax
10e18a: ff 75 08 pushl 0x8(%ebp)
10e18d: e8 42 f8 ff ff call 10d9d4 <_Thread_Get>
switch ( location ) {
10e192: 83 c4 10 add $0x10,%esp
10e195: 8b 55 f4 mov -0xc(%ebp),%edx
10e198: 85 d2 test %edx,%edx
10e19a: 75 17 jne 10e1b3 <_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 );
10e19c: 83 ec 0c sub $0xc,%esp
10e19f: 50 push %eax
10e1a0: e8 c7 36 00 00 call 11186c <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10e1a5: a1 90 7d 12 00 mov 0x127d90,%eax
10e1aa: 48 dec %eax
10e1ab: a3 90 7d 12 00 mov %eax,0x127d90
10e1b0: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10e1b3: c9 leave
10e1b4: c3 ret
00118db8 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
118db8: 55 push %ebp
118db9: 89 e5 mov %esp,%ebp
118dbb: 57 push %edi
118dbc: 56 push %esi
118dbd: 53 push %ebx
118dbe: 83 ec 4c sub $0x4c,%esp
118dc1: 8b 5d 08 mov 0x8(%ebp),%ebx
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
118dc4: 8d 45 e0 lea -0x20(%ebp),%eax
118dc7: 89 45 b4 mov %eax,-0x4c(%ebp)
118dca: 89 45 dc mov %eax,-0x24(%ebp)
head->previous = NULL;
118dcd: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
tail->previous = head;
118dd4: 8d 4d dc lea -0x24(%ebp),%ecx
118dd7: 89 4d e4 mov %ecx,-0x1c(%ebp)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
118dda: 8d 7d d0 lea -0x30(%ebp),%edi
118ddd: 8d 45 d4 lea -0x2c(%ebp),%eax
118de0: 89 45 b0 mov %eax,-0x50(%ebp)
118de3: 89 45 d0 mov %eax,-0x30(%ebp)
head->previous = NULL;
118de6: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
tail->previous = head;
118ded: 89 7d d8 mov %edi,-0x28(%ebp)
118df0: 8d 73 30 lea 0x30(%ebx),%esi
118df3: 8d 4b 68 lea 0x68(%ebx),%ecx
118df6: 89 4d c4 mov %ecx,-0x3c(%ebp)
118df9: 8d 43 08 lea 0x8(%ebx),%eax
118dfc: 89 45 bc mov %eax,-0x44(%ebp)
118dff: 8d 53 40 lea 0x40(%ebx),%edx
118e02: 89 55 c0 mov %edx,-0x40(%ebp)
118e05: 8d 76 00 lea 0x0(%esi),%esi
Chain_Control *tmp;
/*
* 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;
118e08: 8d 4d dc lea -0x24(%ebp),%ecx
118e0b: 89 4b 78 mov %ecx,0x78(%ebx)
118e0e: 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;
118e10: a1 64 2b 14 00 mov 0x142b64,%eax
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
118e15: 8b 53 3c mov 0x3c(%ebx),%edx
watchdogs->last_snapshot = snapshot;
118e18: 89 43 3c mov %eax,0x3c(%ebx)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
118e1b: 51 push %ecx
118e1c: 57 push %edi
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
118e1d: 29 d0 sub %edx,%eax
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
118e1f: 50 push %eax
118e20: 56 push %esi
118e21: e8 9e 3f 00 00 call 11cdc4 <_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();
118e26: a1 c8 2a 14 00 mov 0x142ac8,%eax
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
118e2b: 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 ) {
118e2e: 83 c4 10 add $0x10,%esp
118e31: 39 d0 cmp %edx,%eax
118e33: 0f 87 af 00 00 00 ja 118ee8 <_Timer_server_Body+0x130>
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
118e39: 0f 82 c9 00 00 00 jb 118f08 <_Timer_server_Body+0x150>
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
118e3f: 89 43 74 mov %eax,0x74(%ebx)
118e42: 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 );
118e44: 8b 43 78 mov 0x78(%ebx),%eax
118e47: 83 ec 0c sub $0xc,%esp
118e4a: 50 push %eax
118e4b: e8 0c 0a 00 00 call 11985c <_Chain_Get>
if ( timer == NULL ) {
118e50: 83 c4 10 add $0x10,%esp
118e53: 85 c0 test %eax,%eax
118e55: 74 35 je 118e8c <_Timer_server_Body+0xd4><== ALWAYS TAKEN
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
118e57: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED
118e5a: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED
118e5d: 74 19 je 118e78 <_Timer_server_Body+0xc0><== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
118e5f: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED
118e62: 75 e0 jne 118e44 <_Timer_server_Body+0x8c><== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
118e64: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
118e67: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
118e6a: 50 push %eax <== NOT EXECUTED
118e6b: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED
118e6e: e8 dd 3f 00 00 call 11ce50 <_Watchdog_Insert> <== NOT EXECUTED
118e73: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
118e76: eb cc jmp 118e44 <_Timer_server_Body+0x8c><== 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 );
118e78: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
118e7b: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
118e7e: 50 push %eax <== NOT EXECUTED
118e7f: 56 push %esi <== NOT EXECUTED
118e80: e8 cb 3f 00 00 call 11ce50 <_Watchdog_Insert> <== NOT EXECUTED
118e85: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
118e88: eb ba jmp 118e44 <_Timer_server_Body+0x8c><== NOT EXECUTED
118e8a: 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 );
118e8c: 9c pushf
118e8d: fa cli
118e8e: 58 pop %eax
tmp = ts->insert_chain;
118e8f: 8b 53 78 mov 0x78(%ebx),%edx
if ( _Chain_Is_empty( insert_chain ) ) {
118e92: 8b 55 b4 mov -0x4c(%ebp),%edx
118e95: 39 55 dc cmp %edx,-0x24(%ebp)
118e98: 0f 84 86 00 00 00 je 118f24 <_Timer_server_Body+0x16c><== ALWAYS TAKEN
118e9e: b2 01 mov $0x1,%dl <== NOT EXECUTED
ts->insert_chain = NULL;
do_loop = false;
}
_ISR_Enable( level );
118ea0: 50 push %eax
118ea1: 9d popf
* 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;
while ( do_loop ) {
118ea2: 84 d2 test %dl,%dl
118ea4: 0f 85 66 ff ff ff jne 118e10 <_Timer_server_Body+0x58><== NEVER TAKEN
_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 ) ) {
118eaa: 8b 4d b0 mov -0x50(%ebp),%ecx
118ead: 39 4d d0 cmp %ecx,-0x30(%ebp)
118eb0: 75 22 jne 118ed4 <_Timer_server_Body+0x11c>
118eb2: eb 7e jmp 118f32 <_Timer_server_Body+0x17a>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
118eb4: 8b 10 mov (%eax),%edx
head->next = new_first;
118eb6: 89 55 d0 mov %edx,-0x30(%ebp)
new_first->previous = head;
118eb9: 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;
118ebc: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
_ISR_Enable( level );
118ec3: 51 push %ecx
118ec4: 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 );
118ec5: 83 ec 08 sub $0x8,%esp
118ec8: ff 70 24 pushl 0x24(%eax)
118ecb: ff 70 20 pushl 0x20(%eax)
118ece: ff 50 1c call *0x1c(%eax)
}
118ed1: 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 );
118ed4: 9c pushf
118ed5: fa cli
118ed6: 59 pop %ecx
initialized = false;
}
#endif
return status;
}
118ed7: 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))
118eda: 3b 45 b0 cmp -0x50(%ebp),%eax
118edd: 75 d5 jne 118eb4 <_Timer_server_Body+0xfc>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
118edf: 51 push %ecx
118ee0: 9d popf
118ee1: e9 22 ff ff ff jmp 118e08 <_Timer_server_Body+0x50>
118ee6: 66 90 xchg %ax,%ax
/*
* 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 );
118ee8: 51 push %ecx
118ee9: 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;
118eea: 89 c1 mov %eax,%ecx
118eec: 29 d1 sub %edx,%ecx
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
118eee: 51 push %ecx
118eef: ff 75 c4 pushl -0x3c(%ebp)
118ef2: 89 45 b8 mov %eax,-0x48(%ebp)
118ef5: e8 ca 3e 00 00 call 11cdc4 <_Watchdog_Adjust_to_chain>
118efa: 83 c4 10 add $0x10,%esp
118efd: 8b 45 b8 mov -0x48(%ebp),%eax
118f00: e9 3a ff ff ff jmp 118e3f <_Timer_server_Body+0x87>
118f05: 8d 76 00 lea 0x0(%esi),%esi
/*
* 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 );
118f08: 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;
118f09: 29 c2 sub %eax,%edx
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
118f0b: 52 push %edx
118f0c: 6a 01 push $0x1
118f0e: ff 75 c4 pushl -0x3c(%ebp)
118f11: 89 45 b8 mov %eax,-0x48(%ebp)
118f14: e8 33 3e 00 00 call 11cd4c <_Watchdog_Adjust>
118f19: 83 c4 10 add $0x10,%esp
118f1c: 8b 45 b8 mov -0x48(%ebp),%eax
118f1f: e9 1b ff ff ff jmp 118e3f <_Timer_server_Body+0x87>
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
tmp = ts->insert_chain;
if ( _Chain_Is_empty( insert_chain ) ) {
ts->insert_chain = NULL;
118f24: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx)
do_loop = false;
118f2b: 31 d2 xor %edx,%edx
118f2d: e9 6e ff ff ff jmp 118ea0 <_Timer_server_Body+0xe8>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
118f32: c6 43 7c 00 movb $0x0,0x7c(%ebx)
118f36: a1 30 2a 14 00 mov 0x142a30,%eax
118f3b: 40 inc %eax
118f3c: a3 30 2a 14 00 mov %eax,0x142a30
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
118f41: 83 ec 08 sub $0x8,%esp
118f44: 6a 08 push $0x8
118f46: ff 33 pushl (%ebx)
118f48: e8 e7 37 00 00 call 11c734 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
118f4d: 89 d8 mov %ebx,%eax
118f4f: e8 c4 fd ff ff call 118d18 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
118f54: 89 d8 mov %ebx,%eax
118f56: e8 0d fe ff ff call 118d68 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
118f5b: e8 f4 2e 00 00 call 11be54 <_Thread_Enable_dispatch>
ts->active = true;
118f60: 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 );
118f64: 5a pop %edx
118f65: ff 75 bc pushl -0x44(%ebp)
118f68: e8 23 40 00 00 call 11cf90 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
118f6d: 58 pop %eax
118f6e: ff 75 c0 pushl -0x40(%ebp)
118f71: e8 1a 40 00 00 call 11cf90 <_Watchdog_Remove>
118f76: 83 c4 10 add $0x10,%esp
118f79: e9 8a fe ff ff jmp 118e08 <_Timer_server_Body+0x50>
00118f80 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
118f80: 55 push %ebp
118f81: 89 e5 mov %esp,%ebp
118f83: 57 push %edi
118f84: 56 push %esi
118f85: 53 push %ebx
118f86: 83 ec 2c sub $0x2c,%esp
118f89: 8b 5d 08 mov 0x8(%ebp),%ebx
118f8c: 8b 45 0c mov 0xc(%ebp),%eax
if ( ts->insert_chain == NULL ) {
118f8f: 8b 53 78 mov 0x78(%ebx),%edx
118f92: 85 d2 test %edx,%edx
118f94: 74 16 je 118fac <_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 );
118f96: 8b 53 78 mov 0x78(%ebx),%edx <== NOT EXECUTED
118f99: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED
118f9c: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED
}
}
118f9f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
118fa2: 5b pop %ebx <== NOT EXECUTED
118fa3: 5e pop %esi <== NOT EXECUTED
118fa4: 5f pop %edi <== NOT EXECUTED
118fa5: 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 );
118fa6: e9 75 08 00 00 jmp 119820 <_Chain_Append> <== NOT EXECUTED
118fab: 90 nop <== NOT EXECUTED
118fac: 8b 15 30 2a 14 00 mov 0x142a30,%edx
118fb2: 42 inc %edx
118fb3: 89 15 30 2a 14 00 mov %edx,0x142a30
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
118fb9: 8b 50 38 mov 0x38(%eax),%edx
118fbc: 83 fa 01 cmp $0x1,%edx
118fbf: 74 7b je 11903c <_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 ) {
118fc1: 83 fa 03 cmp $0x3,%edx
118fc4: 74 0e je 118fd4 <_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 );
}
}
118fc6: 8d 65 f4 lea -0xc(%ebp),%esp
118fc9: 5b pop %ebx
118fca: 5e pop %esi
118fcb: 5f pop %edi
118fcc: c9 leave
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
118fcd: e9 82 2e 00 00 jmp 11be54 <_Thread_Enable_dispatch>
118fd2: 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 );
118fd4: 9c pushf
118fd5: fa cli
118fd6: 8f 45 e4 popl -0x1c(%ebp)
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
118fd9: 8b 0d c8 2a 14 00 mov 0x142ac8,%ecx
last_snapshot = ts->TOD_watchdogs.last_snapshot;
118fdf: 8b 53 74 mov 0x74(%ebx),%edx
118fe2: 89 55 d4 mov %edx,-0x2c(%ebp)
initialized = false;
}
#endif
return status;
}
118fe5: 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 );
118fe8: 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 ) ) {
118feb: 39 fa cmp %edi,%edx
118fed: 74 21 je 119010 <_Timer_server_Schedule_operation_method+0x90>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
118fef: 8b 7a 10 mov 0x10(%edx),%edi
if ( snapshot > last_snapshot ) {
118ff2: 3b 4d d4 cmp -0x2c(%ebp),%ecx
118ff5: 0f 86 a1 00 00 00 jbe 11909c <_Timer_server_Schedule_operation_method+0x11c>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
118ffb: 89 ce mov %ecx,%esi
118ffd: 2b 75 d4 sub -0x2c(%ebp),%esi
119000: 89 75 d4 mov %esi,-0x2c(%ebp)
if (delta_interval > delta) {
119003: 39 f7 cmp %esi,%edi
119005: 0f 86 9b 00 00 00 jbe 1190a6 <_Timer_server_Schedule_operation_method+0x126><== NEVER TAKEN
delta_interval -= delta;
11900b: 29 f7 sub %esi,%edi
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
11900d: 89 7a 10 mov %edi,0x10(%edx)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
119010: 89 4b 74 mov %ecx,0x74(%ebx)
_ISR_Enable( level );
119013: ff 75 e4 pushl -0x1c(%ebp)
119016: 9d popf
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
119017: 83 ec 08 sub $0x8,%esp
11901a: 83 c0 10 add $0x10,%eax
11901d: 50 push %eax
11901e: 8d 43 68 lea 0x68(%ebx),%eax
119021: 50 push %eax
119022: e8 29 3e 00 00 call 11ce50 <_Watchdog_Insert>
if ( !ts->active ) {
119027: 8a 43 7c mov 0x7c(%ebx),%al
11902a: 83 c4 10 add $0x10,%esp
11902d: 84 c0 test %al,%al
11902f: 75 95 jne 118fc6 <_Timer_server_Schedule_operation_method+0x46>
_Timer_server_Reset_tod_system_watchdog( ts );
119031: 89 d8 mov %ebx,%eax
119033: e8 30 fd ff ff call 118d68 <_Timer_server_Reset_tod_system_watchdog>
119038: eb 8c jmp 118fc6 <_Timer_server_Schedule_operation_method+0x46>
11903a: 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 );
11903c: 9c pushf
11903d: fa cli
11903e: 8f 45 e4 popl -0x1c(%ebp)
snapshot = _Watchdog_Ticks_since_boot;
119041: 8b 0d 64 2b 14 00 mov 0x142b64,%ecx
last_snapshot = ts->Interval_watchdogs.last_snapshot;
119047: 8b 7b 3c mov 0x3c(%ebx),%edi
initialized = false;
}
#endif
return status;
}
11904a: 8b 53 30 mov 0x30(%ebx),%edx
11904d: 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 ) ) {
119050: 39 f2 cmp %esi,%edx
119052: 74 10 je 119064 <_Timer_server_Schedule_operation_method+0xe4>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
119054: 89 ce mov %ecx,%esi
119056: 29 fe sub %edi,%esi
delta_interval = first_watchdog->delta_interval;
119058: 8b 7a 10 mov 0x10(%edx),%edi
if (delta_interval > delta) {
11905b: 39 fe cmp %edi,%esi
11905d: 73 39 jae 119098 <_Timer_server_Schedule_operation_method+0x118>
delta_interval -= delta;
11905f: 29 f7 sub %esi,%edi
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
119061: 89 7a 10 mov %edi,0x10(%edx)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
119064: 89 4b 3c mov %ecx,0x3c(%ebx)
_ISR_Enable( level );
119067: ff 75 e4 pushl -0x1c(%ebp)
11906a: 9d popf
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
11906b: 83 ec 08 sub $0x8,%esp
11906e: 83 c0 10 add $0x10,%eax
119071: 50 push %eax
119072: 8d 43 30 lea 0x30(%ebx),%eax
119075: 50 push %eax
119076: e8 d5 3d 00 00 call 11ce50 <_Watchdog_Insert>
if ( !ts->active ) {
11907b: 8a 43 7c mov 0x7c(%ebx),%al
11907e: 83 c4 10 add $0x10,%esp
119081: 84 c0 test %al,%al
119083: 0f 85 3d ff ff ff jne 118fc6 <_Timer_server_Schedule_operation_method+0x46>
_Timer_server_Reset_interval_system_watchdog( ts );
119089: 89 d8 mov %ebx,%eax
11908b: e8 88 fc ff ff call 118d18 <_Timer_server_Reset_interval_system_watchdog>
119090: e9 31 ff ff ff jmp 118fc6 <_Timer_server_Schedule_operation_method+0x46>
119095: 8d 76 00 lea 0x0(%esi),%esi
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
119098: 31 ff xor %edi,%edi
11909a: eb c5 jmp 119061 <_Timer_server_Schedule_operation_method+0xe1>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
11909c: 03 7d d4 add -0x2c(%ebp),%edi
delta_interval += delta;
11909f: 29 cf sub %ecx,%edi
1190a1: e9 67 ff ff ff jmp 11900d <_Timer_server_Schedule_operation_method+0x8d>
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
1190a6: 31 ff xor %edi,%edi <== NOT EXECUTED
1190a8: e9 60 ff ff ff jmp 11900d <_Timer_server_Schedule_operation_method+0x8d><== NOT EXECUTED
0010fc38 <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
10fc38: 55 push %ebp
10fc39: 89 e5 mov %esp,%ebp
10fc3b: 57 push %edi
10fc3c: 56 push %esi
10fc3d: 53 push %ebx
10fc3e: 83 ec 2c sub $0x2c,%esp
10fc41: 8b 45 08 mov 0x8(%ebp),%eax
10fc44: 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;
10fc47: 8b 38 mov (%eax),%edi
left += lhs->tv_nsec;
10fc49: 8b 70 04 mov 0x4(%eax),%esi
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
10fc4c: bb 00 ca 9a 3b mov $0x3b9aca00,%ebx
10fc51: 8b 01 mov (%ecx),%eax
10fc53: f7 eb imul %ebx
10fc55: 89 45 e0 mov %eax,-0x20(%ebp)
10fc58: 89 55 e4 mov %edx,-0x1c(%ebp)
right += rhs->tv_nsec;
10fc5b: 8b 41 04 mov 0x4(%ecx),%eax
10fc5e: 99 cltd
10fc5f: 01 45 e0 add %eax,-0x20(%ebp)
10fc62: 11 55 e4 adc %edx,-0x1c(%ebp)
if ( right == 0 ) {
10fc65: 8b 55 e4 mov -0x1c(%ebp),%edx
10fc68: 0b 55 e0 or -0x20(%ebp),%edx
10fc6b: 74 73 je 10fce0 <_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;
10fc6d: 89 f8 mov %edi,%eax
10fc6f: f7 eb imul %ebx
10fc71: 89 45 d0 mov %eax,-0x30(%ebp)
10fc74: 89 55 d4 mov %edx,-0x2c(%ebp)
left += lhs->tv_nsec;
10fc77: 89 f7 mov %esi,%edi
10fc79: c1 ff 1f sar $0x1f,%edi
10fc7c: 01 75 d0 add %esi,-0x30(%ebp)
10fc7f: 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;
10fc82: 69 4d d4 a0 86 01 00 imul $0x186a0,-0x2c(%ebp),%ecx
10fc89: bb a0 86 01 00 mov $0x186a0,%ebx
10fc8e: 8b 45 d0 mov -0x30(%ebp),%eax
10fc91: f7 e3 mul %ebx
10fc93: 8d 34 11 lea (%ecx,%edx,1),%esi
10fc96: ff 75 e4 pushl -0x1c(%ebp)
10fc99: ff 75 e0 pushl -0x20(%ebp)
10fc9c: 56 push %esi
10fc9d: 50 push %eax
10fc9e: e8 29 12 01 00 call 120ecc <__udivdi3>
10fca3: 83 c4 10 add $0x10,%esp
10fca6: 89 c3 mov %eax,%ebx
10fca8: 89 d6 mov %edx,%esi
*ival_percentage = answer / 1000;
10fcaa: 6a 00 push $0x0
10fcac: 68 e8 03 00 00 push $0x3e8
10fcb1: 52 push %edx
10fcb2: 50 push %eax
10fcb3: e8 14 12 01 00 call 120ecc <__udivdi3>
10fcb8: 83 c4 10 add $0x10,%esp
10fcbb: 8b 55 10 mov 0x10(%ebp),%edx
10fcbe: 89 02 mov %eax,(%edx)
*fval_percentage = answer % 1000;
10fcc0: 6a 00 push $0x0
10fcc2: 68 e8 03 00 00 push $0x3e8
10fcc7: 56 push %esi
10fcc8: 53 push %ebx
10fcc9: e8 0e 13 01 00 call 120fdc <__umoddi3>
10fcce: 83 c4 10 add $0x10,%esp
10fcd1: 8b 55 14 mov 0x14(%ebp),%edx
10fcd4: 89 02 mov %eax,(%edx)
}
10fcd6: 8d 65 f4 lea -0xc(%ebp),%esp
10fcd9: 5b pop %ebx
10fcda: 5e pop %esi
10fcdb: 5f pop %edi
10fcdc: c9 leave
10fcdd: c3 ret
10fcde: 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;
10fce0: 8b 45 10 mov 0x10(%ebp),%eax
10fce3: c7 00 00 00 00 00 movl $0x0,(%eax)
*fval_percentage = 0;
10fce9: 8b 55 14 mov 0x14(%ebp),%edx
10fcec: c7 02 00 00 00 00 movl $0x0,(%edx)
answer = (left * 100000) / right;
*ival_percentage = answer / 1000;
*fval_percentage = answer % 1000;
}
10fcf2: 8d 65 f4 lea -0xc(%ebp),%esp
10fcf5: 5b pop %ebx
10fcf6: 5e pop %esi
10fcf7: 5f pop %edi
10fcf8: c9 leave
10fcf9: c3 ret
0011ff98 <_Timespec_Is_valid>:
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
const struct timespec *time
)
{
11ff98: 55 push %ebp
11ff99: 89 e5 mov %esp,%ebp
11ff9b: 8b 45 08 mov 0x8(%ebp),%eax
if ( !time )
11ff9e: 85 c0 test %eax,%eax
11ffa0: 74 1a je 11ffbc <_Timespec_Is_valid+0x24>
return false;
if ( time->tv_sec < 0 )
11ffa2: 8b 10 mov (%eax),%edx
11ffa4: 85 d2 test %edx,%edx
11ffa6: 78 14 js 11ffbc <_Timespec_Is_valid+0x24>
return false;
if ( time->tv_nsec < 0 )
11ffa8: 8b 40 04 mov 0x4(%eax),%eax
11ffab: 85 c0 test %eax,%eax
11ffad: 78 0d js 11ffbc <_Timespec_Is_valid+0x24>
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
11ffaf: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax
11ffb4: 0f 96 c0 setbe %al
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
11ffb7: c9 leave
11ffb8: c3 ret
11ffb9: 8d 76 00 lea 0x0(%esi),%esi
if ( time->tv_sec < 0 )
return false;
if ( time->tv_nsec < 0 )
return false;
11ffbc: 31 c0 xor %eax,%eax
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
11ffbe: c9 leave
11ffbf: c3 ret
00111918 <_Timespec_To_ticks>:
*/
uint32_t _Timespec_To_ticks(
const struct timespec *time
)
{
111918: 55 push %ebp
111919: 89 e5 mov %esp,%ebp
11191b: 56 push %esi
11191c: 53 push %ebx
11191d: 8b 5d 08 mov 0x8(%ebp),%ebx
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
111920: 8b 33 mov (%ebx),%esi
111922: 85 f6 test %esi,%esi
111924: 75 07 jne 11192d <_Timespec_To_ticks+0x15>
111926: 8b 43 04 mov 0x4(%ebx),%eax
111929: 85 c0 test %eax,%eax
11192b: 74 37 je 111964 <_Timespec_To_ticks+0x4c>
return 0;
ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
11192d: e8 62 17 00 00 call 113094 <TOD_TICKS_PER_SECOND_method>
111932: 89 c1 mov %eax,%ecx
111934: 0f af ce imul %esi,%ecx
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
111937: a1 8c 3a 12 00 mov 0x123a8c,%eax
11193c: 8d 04 80 lea (%eax,%eax,4),%eax
11193f: 8d 04 80 lea (%eax,%eax,4),%eax
111942: 8d 34 80 lea (%eax,%eax,4),%esi
111945: c1 e6 03 shl $0x3,%esi
111948: 8b 43 04 mov 0x4(%ebx),%eax
11194b: 31 d2 xor %edx,%edx
11194d: f7 f6 div %esi
if (ticks)
11194f: 01 c8 add %ecx,%eax
111951: 74 05 je 111958 <_Timespec_To_ticks+0x40>
return ticks;
return 1;
}
111953: 5b pop %ebx
111954: 5e pop %esi
111955: c9 leave
111956: c3 ret
111957: 90 nop
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
if (ticks)
return ticks;
return 1;
111958: b8 01 00 00 00 mov $0x1,%eax
}
11195d: 5b pop %ebx
11195e: 5e pop %esi
11195f: c9 leave
111960: c3 ret
111961: 8d 76 00 lea 0x0(%esi),%esi
)
{
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
return 0;
111964: 31 c0 xor %eax,%eax
if (ticks)
return ticks;
return 1;
}
111966: 5b pop %ebx
111967: 5e pop %esi
111968: c9 leave
111969: c3 ret
0010e5bc <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10e5bc: 55 push %ebp
10e5bd: 89 e5 mov %esp,%ebp
10e5bf: 57 push %edi
10e5c0: 56 push %esi
10e5c1: 53 push %ebx
10e5c2: 83 ec 1c sub $0x1c,%esp
10e5c5: 8b 75 08 mov 0x8(%ebp),%esi
10e5c8: 8b 7d 10 mov 0x10(%ebp),%edi
10e5cb: 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 );
}
}
10e5ce: 8b 1d b4 7f 12 00 mov 0x127fb4,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e5d4: 81 fb ac 7f 12 00 cmp $0x127fac,%ebx
10e5da: 74 25 je 10e601 <_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 );
10e5dc: 0f b6 c0 movzbl %al,%eax
10e5df: 89 45 e4 mov %eax,-0x1c(%ebp)
10e5e2: 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 )
10e5e4: 8b 43 30 mov 0x30(%ebx),%eax
10e5e7: 85 c0 test %eax,%eax
10e5e9: 74 0b je 10e5f6 <_User_extensions_Fatal+0x3a>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10e5eb: 52 push %edx
10e5ec: 57 push %edi
10e5ed: ff 75 e4 pushl -0x1c(%ebp)
10e5f0: 56 push %esi
10e5f1: ff d0 call *%eax
10e5f3: 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 ) {
10e5f6: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e5f9: 81 fb ac 7f 12 00 cmp $0x127fac,%ebx
10e5ff: 75 e3 jne 10e5e4 <_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 );
}
}
10e601: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10e604: 5b pop %ebx <== NOT EXECUTED
10e605: 5e pop %esi <== NOT EXECUTED
10e606: 5f pop %edi <== NOT EXECUTED
10e607: c9 leave <== NOT EXECUTED
10e608: c3 ret <== NOT EXECUTED
0010e480 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
10e480: 55 push %ebp
10e481: 89 e5 mov %esp,%ebp
10e483: 57 push %edi
10e484: 56 push %esi
10e485: 53 push %ebx
10e486: 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;
10e489: a1 b8 3a 12 00 mov 0x123ab8,%eax
10e48e: 89 45 dc mov %eax,-0x24(%ebp)
initial_extensions = Configuration.User_extension_table;
10e491: 8b 35 bc 3a 12 00 mov 0x123abc,%esi
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10e497: c7 05 ac 7f 12 00 b0 movl $0x127fb0,0x127fac
10e49e: 7f 12 00
head->previous = NULL;
10e4a1: c7 05 b0 7f 12 00 00 movl $0x0,0x127fb0
10e4a8: 00 00 00
tail->previous = head;
10e4ab: c7 05 b4 7f 12 00 ac movl $0x127fac,0x127fb4
10e4b2: 7f 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10e4b5: c7 05 94 7d 12 00 98 movl $0x127d98,0x127d94
10e4bc: 7d 12 00
head->previous = NULL;
10e4bf: c7 05 98 7d 12 00 00 movl $0x0,0x127d98
10e4c6: 00 00 00
tail->previous = head;
10e4c9: c7 05 9c 7d 12 00 94 movl $0x127d94,0x127d9c
10e4d0: 7d 12 00
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
10e4d3: 85 f6 test %esi,%esi
10e4d5: 74 64 je 10e53b <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
10e4d7: 89 c2 mov %eax,%edx
10e4d9: 8d 04 40 lea (%eax,%eax,2),%eax
10e4dc: 8d 0c 82 lea (%edx,%eax,4),%ecx
10e4df: c1 e1 02 shl $0x2,%ecx
10e4e2: 83 ec 0c sub $0xc,%esp
10e4e5: 51 push %ecx
10e4e6: 89 4d d8 mov %ecx,-0x28(%ebp)
10e4e9: e8 ce 04 00 00 call 10e9bc <_Workspace_Allocate_or_fatal_error>
10e4ee: 89 c3 mov %eax,%ebx
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
10e4f0: 31 c0 xor %eax,%eax
10e4f2: 8b 4d d8 mov -0x28(%ebp),%ecx
10e4f5: 89 df mov %ebx,%edi
10e4f7: f3 aa rep stos %al,%es:(%edi)
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10e4f9: 83 c4 10 add $0x10,%esp
10e4fc: 8b 45 dc mov -0x24(%ebp),%eax
10e4ff: 85 c0 test %eax,%eax
10e501: 74 38 je 10e53b <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN
10e503: 89 75 e4 mov %esi,-0x1c(%ebp)
10e506: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
10e50d: 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;
10e510: 8d 7b 14 lea 0x14(%ebx),%edi
10e513: 8b 75 e4 mov -0x1c(%ebp),%esi
10e516: b9 08 00 00 00 mov $0x8,%ecx
10e51b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_User_extensions_Add_set( extension );
10e51d: 83 ec 0c sub $0xc,%esp
10e520: 53 push %ebx
10e521: e8 46 34 00 00 call 11196c <_User_extensions_Add_set>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
10e526: 83 c3 34 add $0x34,%ebx
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10e529: ff 45 e0 incl -0x20(%ebp)
10e52c: 83 45 e4 20 addl $0x20,-0x1c(%ebp)
10e530: 83 c4 10 add $0x10,%esp
10e533: 8b 45 e0 mov -0x20(%ebp),%eax
10e536: 39 45 dc cmp %eax,-0x24(%ebp)
10e539: 77 d5 ja 10e510 <_User_extensions_Handler_initialization+0x90>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
10e53b: 8d 65 f4 lea -0xc(%ebp),%esp
10e53e: 5b pop %ebx
10e53f: 5e pop %esi
10e540: 5f pop %edi
10e541: c9 leave
10e542: c3 ret
0010fa00 <_User_extensions_Remove_set>:
#include <rtems/score/userext.h>
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
10fa00: 55 push %ebp
10fa01: 89 e5 mov %esp,%ebp
10fa03: 53 push %ebx
10fa04: 83 ec 10 sub $0x10,%esp
10fa07: 8b 5d 08 mov 0x8(%ebp),%ebx
_Chain_Extract( &the_extension->Node );
10fa0a: 53 push %ebx
10fa0b: e8 88 d9 ff ff call 10d398 <_Chain_Extract>
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
10fa10: 83 c4 10 add $0x10,%esp
10fa13: 8b 43 24 mov 0x24(%ebx),%eax
10fa16: 85 c0 test %eax,%eax
10fa18: 74 12 je 10fa2c <_User_extensions_Remove_set+0x2c>
_Chain_Extract( &the_extension->Switch.Node );
10fa1a: 83 c3 08 add $0x8,%ebx
10fa1d: 89 5d 08 mov %ebx,0x8(%ebp)
}
10fa20: 8b 5d fc mov -0x4(%ebp),%ebx
10fa23: c9 leave
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
_Chain_Extract( &the_extension->Switch.Node );
10fa24: e9 6f d9 ff ff jmp 10d398 <_Chain_Extract>
10fa29: 8d 76 00 lea 0x0(%esi),%esi
}
10fa2c: 8b 5d fc mov -0x4(%ebp),%ebx
10fa2f: c9 leave
10fa30: c3 ret
0010e544 <_User_extensions_Thread_begin>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_begin (
Thread_Control *executing
)
{
10e544: 55 push %ebp
10e545: 89 e5 mov %esp,%ebp
10e547: 56 push %esi
10e548: 53 push %ebx
10e549: 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 );
}
}
10e54c: 8b 1d ac 7f 12 00 mov 0x127fac,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e552: 81 fb b0 7f 12 00 cmp $0x127fb0,%ebx
10e558: 74 1c je 10e576 <_User_extensions_Thread_begin+0x32><== NEVER TAKEN
10e55a: 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 )
10e55c: 8b 43 28 mov 0x28(%ebx),%eax
10e55f: 85 c0 test %eax,%eax
10e561: 74 09 je 10e56c <_User_extensions_Thread_begin+0x28>
(*the_extension->Callouts.thread_begin)( executing );
10e563: 83 ec 0c sub $0xc,%esp
10e566: 56 push %esi
10e567: ff d0 call *%eax
10e569: 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 ) {
10e56c: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e56e: 81 fb b0 7f 12 00 cmp $0x127fb0,%ebx
10e574: 75 e6 jne 10e55c <_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 );
}
}
10e576: 8d 65 f8 lea -0x8(%ebp),%esp
10e579: 5b pop %ebx
10e57a: 5e pop %esi
10e57b: c9 leave
10e57c: c3 ret
0010e60c <_User_extensions_Thread_create>:
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
10e60c: 55 push %ebp
10e60d: 89 e5 mov %esp,%ebp
10e60f: 56 push %esi
10e610: 53 push %ebx
10e611: 8b 75 08 mov 0x8(%ebp),%esi
return false;
}
}
return true;
}
10e614: 8b 1d ac 7f 12 00 mov 0x127fac,%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
10e61a: 81 fb b0 7f 12 00 cmp $0x127fb0,%ebx
10e620: 74 26 je 10e648 <_User_extensions_Thread_create+0x3c><== NEVER TAKEN
10e622: 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 ) {
10e624: 8b 43 14 mov 0x14(%ebx),%eax
10e627: 85 c0 test %eax,%eax
10e629: 74 13 je 10e63e <_User_extensions_Thread_create+0x32>
status = (*the_extension->Callouts.thread_create)(
10e62b: 83 ec 08 sub $0x8,%esp
10e62e: 56 push %esi
10e62f: ff 35 38 83 12 00 pushl 0x128338
10e635: ff d0 call *%eax
_Thread_Executing,
the_thread
);
if ( !status )
10e637: 83 c4 10 add $0x10,%esp
10e63a: 84 c0 test %al,%al
10e63c: 74 16 je 10e654 <_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 ) {
10e63e: 8b 1b mov (%ebx),%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
10e640: 81 fb b0 7f 12 00 cmp $0x127fb0,%ebx
10e646: 75 dc jne 10e624 <_User_extensions_Thread_create+0x18>
if ( !status )
return false;
}
}
return true;
10e648: b0 01 mov $0x1,%al
}
10e64a: 8d 65 f8 lea -0x8(%ebp),%esp
10e64d: 5b pop %ebx
10e64e: 5e pop %esi
10e64f: c9 leave
10e650: c3 ret
10e651: 8d 76 00 lea 0x0(%esi),%esi
status = (*the_extension->Callouts.thread_create)(
_Thread_Executing,
the_thread
);
if ( !status )
return false;
10e654: 31 c0 xor %eax,%eax
}
}
return true;
}
10e656: 8d 65 f8 lea -0x8(%ebp),%esp
10e659: 5b pop %ebx
10e65a: 5e pop %esi
10e65b: c9 leave
10e65c: c3 ret
0010e660 <_User_extensions_Thread_delete>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_delete (
Thread_Control *the_thread
)
{
10e660: 55 push %ebp
10e661: 89 e5 mov %esp,%ebp
10e663: 56 push %esi
10e664: 53 push %ebx
10e665: 8b 75 08 mov 0x8(%ebp),%esi
(*the_extension->Callouts.thread_delete)(
_Thread_Executing,
the_thread
);
}
}
10e668: 8b 1d b4 7f 12 00 mov 0x127fb4,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e66e: 81 fb ac 7f 12 00 cmp $0x127fac,%ebx
10e674: 74 23 je 10e699 <_User_extensions_Thread_delete+0x39><== NEVER TAKEN
10e676: 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 )
10e678: 8b 43 20 mov 0x20(%ebx),%eax
10e67b: 85 c0 test %eax,%eax
10e67d: 74 0f je 10e68e <_User_extensions_Thread_delete+0x2e>
(*the_extension->Callouts.thread_delete)(
10e67f: 83 ec 08 sub $0x8,%esp
10e682: 56 push %esi
10e683: ff 35 38 83 12 00 pushl 0x128338
10e689: ff d0 call *%eax
10e68b: 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 ) {
10e68e: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e691: 81 fb ac 7f 12 00 cmp $0x127fac,%ebx
10e697: 75 df jne 10e678 <_User_extensions_Thread_delete+0x18>
(*the_extension->Callouts.thread_delete)(
_Thread_Executing,
the_thread
);
}
}
10e699: 8d 65 f8 lea -0x8(%ebp),%esp
10e69c: 5b pop %ebx
10e69d: 5e pop %esi
10e69e: c9 leave
10e69f: c3 ret
0010e580 <_User_extensions_Thread_exitted>:
void _User_extensions_Thread_exitted (
Thread_Control *executing
)
{
10e580: 55 push %ebp
10e581: 89 e5 mov %esp,%ebp
10e583: 56 push %esi
10e584: 53 push %ebx
10e585: 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 );
}
}
10e588: 8b 1d b4 7f 12 00 mov 0x127fb4,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e58e: 81 fb ac 7f 12 00 cmp $0x127fac,%ebx
10e594: 74 1d je 10e5b3 <_User_extensions_Thread_exitted+0x33><== NEVER TAKEN
10e596: 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 )
10e598: 8b 43 2c mov 0x2c(%ebx),%eax
10e59b: 85 c0 test %eax,%eax
10e59d: 74 09 je 10e5a8 <_User_extensions_Thread_exitted+0x28>
(*the_extension->Callouts.thread_exitted)( executing );
10e59f: 83 ec 0c sub $0xc,%esp
10e5a2: 56 push %esi
10e5a3: ff d0 call *%eax
10e5a5: 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 ) {
10e5a8: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e5ab: 81 fb ac 7f 12 00 cmp $0x127fac,%ebx
10e5b1: 75 e5 jne 10e598 <_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 );
}
}
10e5b3: 8d 65 f8 lea -0x8(%ebp),%esp
10e5b6: 5b pop %ebx
10e5b7: 5e pop %esi
10e5b8: c9 leave
10e5b9: c3 ret
0010f264 <_User_extensions_Thread_restart>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_restart (
Thread_Control *the_thread
)
{
10f264: 55 push %ebp
10f265: 89 e5 mov %esp,%ebp
10f267: 56 push %esi
10f268: 53 push %ebx
10f269: 8b 75 08 mov 0x8(%ebp),%esi
(*the_extension->Callouts.thread_restart)(
_Thread_Executing,
the_thread
);
}
}
10f26c: 8b 1d cc a2 12 00 mov 0x12a2cc,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10f272: 81 fb d0 a2 12 00 cmp $0x12a2d0,%ebx
10f278: 74 22 je 10f29c <_User_extensions_Thread_restart+0x38><== NEVER TAKEN
10f27a: 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 )
10f27c: 8b 43 1c mov 0x1c(%ebx),%eax
10f27f: 85 c0 test %eax,%eax
10f281: 74 0f je 10f292 <_User_extensions_Thread_restart+0x2e>
(*the_extension->Callouts.thread_restart)(
10f283: 83 ec 08 sub $0x8,%esp
10f286: 56 push %esi
10f287: ff 35 58 a6 12 00 pushl 0x12a658
10f28d: ff d0 call *%eax
10f28f: 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 ) {
10f292: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10f294: 81 fb d0 a2 12 00 cmp $0x12a2d0,%ebx
10f29a: 75 e0 jne 10f27c <_User_extensions_Thread_restart+0x18>
(*the_extension->Callouts.thread_restart)(
_Thread_Executing,
the_thread
);
}
}
10f29c: 8d 65 f8 lea -0x8(%ebp),%esp
10f29f: 5b pop %ebx
10f2a0: 5e pop %esi
10f2a1: c9 leave
10f2a2: c3 ret
0010e6a0 <_User_extensions_Thread_start>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_start (
Thread_Control *the_thread
)
{
10e6a0: 55 push %ebp
10e6a1: 89 e5 mov %esp,%ebp
10e6a3: 56 push %esi
10e6a4: 53 push %ebx
10e6a5: 8b 75 08 mov 0x8(%ebp),%esi
(*the_extension->Callouts.thread_start)(
_Thread_Executing,
the_thread
);
}
}
10e6a8: 8b 1d ac 7f 12 00 mov 0x127fac,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e6ae: 81 fb b0 7f 12 00 cmp $0x127fb0,%ebx
10e6b4: 74 22 je 10e6d8 <_User_extensions_Thread_start+0x38><== NEVER TAKEN
10e6b6: 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 )
10e6b8: 8b 43 18 mov 0x18(%ebx),%eax
10e6bb: 85 c0 test %eax,%eax
10e6bd: 74 0f je 10e6ce <_User_extensions_Thread_start+0x2e>
(*the_extension->Callouts.thread_start)(
10e6bf: 83 ec 08 sub $0x8,%esp
10e6c2: 56 push %esi
10e6c3: ff 35 38 83 12 00 pushl 0x128338
10e6c9: ff d0 call *%eax
10e6cb: 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 ) {
10e6ce: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e6d0: 81 fb b0 7f 12 00 cmp $0x127fb0,%ebx
10e6d6: 75 e0 jne 10e6b8 <_User_extensions_Thread_start+0x18>
(*the_extension->Callouts.thread_start)(
_Thread_Executing,
the_thread
);
}
}
10e6d8: 8d 65 f8 lea -0x8(%ebp),%esp
10e6db: 5b pop %ebx
10e6dc: 5e pop %esi
10e6dd: c9 leave
10e6de: c3 ret
0010e6e0 <_User_extensions_Thread_switch>:
void _User_extensions_Thread_switch (
Thread_Control *executing,
Thread_Control *heir
)
{
10e6e0: 55 push %ebp
10e6e1: 89 e5 mov %esp,%ebp
10e6e3: 57 push %edi
10e6e4: 56 push %esi
10e6e5: 53 push %ebx
10e6e6: 83 ec 0c sub $0xc,%esp
10e6e9: 8b 7d 08 mov 0x8(%ebp),%edi
10e6ec: 8b 75 0c mov 0xc(%ebp),%esi
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
}
}
10e6ef: 8b 1d 94 7d 12 00 mov 0x127d94,%ebx
)
{
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
10e6f5: 81 fb 98 7d 12 00 cmp $0x127d98,%ebx
10e6fb: 74 18 je 10e715 <_User_extensions_Thread_switch+0x35><== NEVER TAKEN
10e6fd: 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 );
10e700: 83 ec 08 sub $0x8,%esp
10e703: 56 push %esi
10e704: 57 push %edi
10e705: 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 ) {
10e708: 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 );
10e70a: 83 c4 10 add $0x10,%esp
10e70d: 81 fb 98 7d 12 00 cmp $0x127d98,%ebx
10e713: 75 eb jne 10e700 <_User_extensions_Thread_switch+0x20>
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
}
}
10e715: 8d 65 f4 lea -0xc(%ebp),%esp
10e718: 5b pop %ebx
10e719: 5e pop %esi
10e71a: 5f pop %edi
10e71b: c9 leave
10e71c: c3 ret
00110018 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
110018: 55 push %ebp
110019: 89 e5 mov %esp,%ebp
11001b: 57 push %edi
11001c: 56 push %esi
11001d: 53 push %ebx
11001e: 83 ec 1c sub $0x1c,%esp
110021: 8b 75 08 mov 0x8(%ebp),%esi
110024: 8b 4d 0c mov 0xc(%ebp),%ecx
110027: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
11002a: 9c pushf
11002b: fa cli
11002c: 58 pop %eax
}
}
_ISR_Enable( level );
}
11002d: 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 );
11002f: 8d 7e 04 lea 0x4(%esi),%edi
110032: 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 ) ) {
110035: 39 fa cmp %edi,%edx
110037: 74 3d je 110076 <_Watchdog_Adjust+0x5e>
switch ( direction ) {
110039: 85 c9 test %ecx,%ecx
11003b: 75 43 jne 110080 <_Watchdog_Adjust+0x68>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
11003d: 85 db test %ebx,%ebx
11003f: 74 35 je 110076 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
110041: 8b 7a 10 mov 0x10(%edx),%edi
110044: 39 fb cmp %edi,%ebx
110046: 73 0f jae 110057 <_Watchdog_Adjust+0x3f> <== ALWAYS TAKEN
110048: eb 3e jmp 110088 <_Watchdog_Adjust+0x70> <== NOT EXECUTED
11004a: 66 90 xchg %ax,%ax <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
11004c: 29 fb sub %edi,%ebx
11004e: 74 26 je 110076 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
110050: 8b 7a 10 mov 0x10(%edx),%edi
110053: 39 df cmp %ebx,%edi
110055: 77 31 ja 110088 <_Watchdog_Adjust+0x70>
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
110057: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx)
_ISR_Enable( level );
11005e: 50 push %eax
11005f: 9d popf
_Watchdog_Tickle( header );
110060: 83 ec 0c sub $0xc,%esp
110063: 56 push %esi
110064: e8 d3 01 00 00 call 11023c <_Watchdog_Tickle>
_ISR_Disable( level );
110069: 9c pushf
11006a: fa cli
11006b: 58 pop %eax
}
}
_ISR_Enable( level );
}
11006c: 8b 16 mov (%esi),%edx
_Watchdog_Tickle( header );
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
11006e: 83 c4 10 add $0x10,%esp
110071: 39 55 e4 cmp %edx,-0x1c(%ebp)
110074: 75 d6 jne 11004c <_Watchdog_Adjust+0x34>
}
break;
}
}
_ISR_Enable( level );
110076: 50 push %eax
110077: 9d popf
}
110078: 8d 65 f4 lea -0xc(%ebp),%esp
11007b: 5b pop %ebx
11007c: 5e pop %esi
11007d: 5f pop %edi
11007e: c9 leave
11007f: c3 ret
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
110080: 49 dec %ecx
110081: 75 f3 jne 110076 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
110083: 01 5a 10 add %ebx,0x10(%edx)
break;
110086: eb ee jmp 110076 <_Watchdog_Adjust+0x5e>
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
110088: 29 df sub %ebx,%edi
11008a: 89 7a 10 mov %edi,0x10(%edx)
break;
11008d: eb e7 jmp 110076 <_Watchdog_Adjust+0x5e>
0010e720 <_Watchdog_Insert>:
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
10e720: 55 push %ebp
10e721: 89 e5 mov %esp,%ebp
10e723: 57 push %edi
10e724: 56 push %esi
10e725: 53 push %ebx
10e726: 83 ec 04 sub $0x4,%esp
10e729: 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;
10e72c: 8b 3d 34 83 12 00 mov 0x128334,%edi
_ISR_Disable( level );
10e732: 9c pushf
10e733: fa cli
10e734: 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 ) {
10e737: 8b 43 08 mov 0x8(%ebx),%eax
10e73a: 85 c0 test %eax,%eax
10e73c: 0f 85 9e 00 00 00 jne 10e7e0 <_Watchdog_Insert+0xc0>
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
10e742: c7 43 08 01 00 00 00 movl $0x1,0x8(%ebx)
_Watchdog_Sync_count++;
10e749: a1 c0 7e 12 00 mov 0x127ec0,%eax
10e74e: 40 inc %eax
10e74f: a3 c0 7e 12 00 mov %eax,0x127ec0
restart:
delta_interval = the_watchdog->initial;
10e754: 8b 43 0c mov 0xc(%ebx),%eax
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
10e757: 8b 4d 08 mov 0x8(%ebp),%ecx
10e75a: 8b 11 mov (%ecx),%edx
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
10e75c: 85 c0 test %eax,%eax
10e75e: 74 5d je 10e7bd <_Watchdog_Insert+0x9d>
10e760: 8b 32 mov (%edx),%esi
10e762: 85 f6 test %esi,%esi
10e764: 74 57 je 10e7bd <_Watchdog_Insert+0x9d>
break;
if ( delta_interval < after->delta_interval ) {
10e766: 8b 4a 10 mov 0x10(%edx),%ecx
10e769: 39 c8 cmp %ecx,%eax
10e76b: 73 22 jae 10e78f <_Watchdog_Insert+0x6f>
10e76d: eb 49 jmp 10e7b8 <_Watchdog_Insert+0x98>
10e76f: 90 nop
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
10e770: 8b 35 44 7e 12 00 mov 0x127e44,%esi
10e776: 39 f7 cmp %esi,%edi
10e778: 72 72 jb 10e7ec <_Watchdog_Insert+0xcc>
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
10e77a: 29 c8 sub %ecx,%eax
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
10e77c: 8b 12 mov (%edx),%edx
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
10e77e: 85 c0 test %eax,%eax
10e780: 74 3b je 10e7bd <_Watchdog_Insert+0x9d>
10e782: 8b 0a mov (%edx),%ecx
10e784: 85 c9 test %ecx,%ecx
10e786: 74 35 je 10e7bd <_Watchdog_Insert+0x9d>
break;
if ( delta_interval < after->delta_interval ) {
10e788: 8b 4a 10 mov 0x10(%edx),%ecx
10e78b: 39 c1 cmp %eax,%ecx
10e78d: 77 29 ja 10e7b8 <_Watchdog_Insert+0x98>
break;
}
delta_interval -= after->delta_interval;
_ISR_Flash( level );
10e78f: ff 75 f0 pushl -0x10(%ebp)
10e792: 9d popf
10e793: fa cli
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
10e794: 83 7b 08 01 cmpl $0x1,0x8(%ebx)
10e798: 74 d6 je 10e770 <_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;
10e79a: 89 3d 44 7e 12 00 mov %edi,0x127e44
_Watchdog_Sync_count--;
10e7a0: a1 c0 7e 12 00 mov 0x127ec0,%eax
10e7a5: 48 dec %eax
10e7a6: a3 c0 7e 12 00 mov %eax,0x127ec0
_ISR_Enable( level );
10e7ab: ff 75 f0 pushl -0x10(%ebp)
10e7ae: 9d popf
}
10e7af: 58 pop %eax
10e7b0: 5b pop %ebx
10e7b1: 5e pop %esi
10e7b2: 5f pop %edi
10e7b3: c9 leave
10e7b4: c3 ret
10e7b5: 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;
10e7b8: 29 c1 sub %eax,%ecx
10e7ba: 89 4a 10 mov %ecx,0x10(%edx)
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_ACTIVE;
10e7bd: c7 43 08 02 00 00 00 movl $0x2,0x8(%ebx)
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
10e7c4: 89 43 10 mov %eax,0x10(%ebx)
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
10e7c7: 8b 42 04 mov 0x4(%edx),%eax
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10e7ca: 89 43 04 mov %eax,0x4(%ebx)
before_node = after_node->next;
10e7cd: 8b 10 mov (%eax),%edx
after_node->next = the_node;
10e7cf: 89 18 mov %ebx,(%eax)
the_node->next = before_node;
10e7d1: 89 13 mov %edx,(%ebx)
before_node->previous = the_node;
10e7d3: 89 5a 04 mov %ebx,0x4(%edx)
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
10e7d6: a1 c4 7e 12 00 mov 0x127ec4,%eax
10e7db: 89 43 14 mov %eax,0x14(%ebx)
10e7de: eb ba jmp 10e79a <_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 );
10e7e0: ff 75 f0 pushl -0x10(%ebp)
10e7e3: 9d popf
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
10e7e4: 58 pop %eax
10e7e5: 5b pop %ebx
10e7e6: 5e pop %esi
10e7e7: 5f pop %edi
10e7e8: c9 leave
10e7e9: c3 ret
10e7ea: 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;
10e7ec: 89 3d 44 7e 12 00 mov %edi,0x127e44
goto restart;
10e7f2: e9 5d ff ff ff jmp 10e754 <_Watchdog_Insert+0x34>
0010e860 <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
10e860: 55 push %ebp
10e861: 89 e5 mov %esp,%ebp
10e863: 56 push %esi
10e864: 53 push %ebx
10e865: 8b 55 08 mov 0x8(%ebp),%edx
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
10e868: 9c pushf
10e869: fa cli
10e86a: 59 pop %ecx
previous_state = the_watchdog->state;
10e86b: 8b 42 08 mov 0x8(%edx),%eax
switch ( previous_state ) {
10e86e: 83 f8 01 cmp $0x1,%eax
10e871: 74 4d je 10e8c0 <_Watchdog_Remove+0x60>
10e873: 73 0f jae 10e884 <_Watchdog_Remove+0x24>
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
10e875: 8b 1d c4 7e 12 00 mov 0x127ec4,%ebx
10e87b: 89 5a 18 mov %ebx,0x18(%edx)
_ISR_Enable( level );
10e87e: 51 push %ecx
10e87f: 9d popf
return( previous_state );
}
10e880: 5b pop %ebx
10e881: 5e pop %esi
10e882: c9 leave
10e883: c3 ret
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
previous_state = the_watchdog->state;
switch ( previous_state ) {
10e884: 83 f8 03 cmp $0x3,%eax
10e887: 77 ec ja 10e875 <_Watchdog_Remove+0x15> <== NEVER TAKEN
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
10e889: 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 );
}
10e890: 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) )
10e892: 8b 33 mov (%ebx),%esi
10e894: 85 f6 test %esi,%esi
10e896: 74 06 je 10e89e <_Watchdog_Remove+0x3e>
next_watchdog->delta_interval += the_watchdog->delta_interval;
10e898: 8b 72 10 mov 0x10(%edx),%esi
10e89b: 01 73 10 add %esi,0x10(%ebx)
if ( _Watchdog_Sync_count )
10e89e: 8b 35 c0 7e 12 00 mov 0x127ec0,%esi
10e8a4: 85 f6 test %esi,%esi
10e8a6: 74 0c je 10e8b4 <_Watchdog_Remove+0x54>
_Watchdog_Sync_level = _ISR_Nest_level;
10e8a8: 8b 35 34 83 12 00 mov 0x128334,%esi
10e8ae: 89 35 44 7e 12 00 mov %esi,0x127e44
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
10e8b4: 8b 72 04 mov 0x4(%edx),%esi
next->previous = previous;
10e8b7: 89 73 04 mov %esi,0x4(%ebx)
previous->next = next;
10e8ba: 89 1e mov %ebx,(%esi)
10e8bc: eb b7 jmp 10e875 <_Watchdog_Remove+0x15>
10e8be: 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;
10e8c0: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
break;
10e8c7: eb ac jmp 10e875 <_Watchdog_Remove+0x15>
0010fc0c <_Watchdog_Report>:
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
10fc0c: 55 push %ebp
10fc0d: 89 e5 mov %esp,%ebp
10fc0f: 57 push %edi
10fc10: 56 push %esi
10fc11: 53 push %ebx
10fc12: 83 ec 2c sub $0x2c,%esp
10fc15: 8b 55 08 mov 0x8(%ebp),%edx
10fc18: 8b 45 0c mov 0xc(%ebp),%eax
printk(
10fc1b: 8b 78 24 mov 0x24(%eax),%edi
10fc1e: 8b 70 20 mov 0x20(%eax),%esi
10fc21: 8b 58 1c mov 0x1c(%eax),%ebx
10fc24: 8b 48 0c mov 0xc(%eax),%ecx
10fc27: 89 4d d4 mov %ecx,-0x2c(%ebp)
10fc2a: 8b 48 10 mov 0x10(%eax),%ecx
10fc2d: 89 4d e4 mov %ecx,-0x1c(%ebp)
10fc30: 85 d2 test %edx,%edx
10fc32: 74 2c je 10fc60 <_Watchdog_Report+0x54>
10fc34: b9 83 34 12 00 mov $0x123483,%ecx
10fc39: 83 ec 0c sub $0xc,%esp
10fc3c: 57 push %edi
10fc3d: 56 push %esi
10fc3e: 53 push %ebx
10fc3f: 50 push %eax
10fc40: ff 75 d4 pushl -0x2c(%ebp)
10fc43: ff 75 e4 pushl -0x1c(%ebp)
10fc46: 51 push %ecx
10fc47: 52 push %edx
10fc48: 68 d6 3e 12 00 push $0x123ed6
10fc4d: e8 46 9e ff ff call 109a98 <printk>
10fc52: 83 c4 30 add $0x30,%esp
watch,
watch->routine,
watch->id,
watch->user_data
);
}
10fc55: 8d 65 f4 lea -0xc(%ebp),%esp
10fc58: 5b pop %ebx
10fc59: 5e pop %esi
10fc5a: 5f pop %edi
10fc5b: c9 leave
10fc5c: c3 ret
10fc5d: 8d 76 00 lea 0x0(%esi),%esi
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
printk(
10fc60: b9 49 3d 12 00 mov $0x123d49,%ecx
10fc65: 89 ca mov %ecx,%edx
10fc67: eb d0 jmp 10fc39 <_Watchdog_Report+0x2d>
0010fb9c <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
10fb9c: 55 push %ebp
10fb9d: 89 e5 mov %esp,%ebp
10fb9f: 57 push %edi
10fba0: 56 push %esi
10fba1: 53 push %ebx
10fba2: 83 ec 20 sub $0x20,%esp
10fba5: 8b 7d 08 mov 0x8(%ebp),%edi
10fba8: 8b 75 0c mov 0xc(%ebp),%esi
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
10fbab: 9c pushf
10fbac: fa cli
10fbad: 8f 45 e4 popl -0x1c(%ebp)
printk( "Watchdog Chain: %s %p\n", name, header );
10fbb0: 56 push %esi
10fbb1: 57 push %edi
10fbb2: 68 a0 3e 12 00 push $0x123ea0
10fbb7: e8 dc 9e ff ff call 109a98 <printk>
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
10fbbc: 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 );
10fbbe: 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 ) ) {
10fbc1: 83 c4 10 add $0x10,%esp
10fbc4: 39 f3 cmp %esi,%ebx
10fbc6: 74 31 je 10fbf9 <_Watchdog_Report_chain+0x5d>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
10fbc8: 83 ec 08 sub $0x8,%esp
10fbcb: 53 push %ebx
10fbcc: 6a 00 push $0x0
10fbce: e8 39 00 00 00 call 10fc0c <_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 )
10fbd3: 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 ) ;
10fbd5: 83 c4 10 add $0x10,%esp
10fbd8: 39 f3 cmp %esi,%ebx
10fbda: 75 ec jne 10fbc8 <_Watchdog_Report_chain+0x2c><== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
10fbdc: 83 ec 08 sub $0x8,%esp
10fbdf: 57 push %edi
10fbe0: 68 b7 3e 12 00 push $0x123eb7
10fbe5: e8 ae 9e ff ff call 109a98 <printk>
10fbea: 83 c4 10 add $0x10,%esp
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
10fbed: ff 75 e4 pushl -0x1c(%ebp)
10fbf0: 9d popf
}
10fbf1: 8d 65 f4 lea -0xc(%ebp),%esp
10fbf4: 5b pop %ebx
10fbf5: 5e pop %esi
10fbf6: 5f pop %edi
10fbf7: c9 leave
10fbf8: c3 ret
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
10fbf9: 83 ec 0c sub $0xc,%esp
10fbfc: 68 c6 3e 12 00 push $0x123ec6
10fc01: e8 92 9e ff ff call 109a98 <printk>
10fc06: 83 c4 10 add $0x10,%esp
10fc09: eb e2 jmp 10fbed <_Watchdog_Report_chain+0x51>
0010e8cc <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
10e8cc: 55 push %ebp
10e8cd: 89 e5 mov %esp,%ebp
10e8cf: 57 push %edi
10e8d0: 56 push %esi
10e8d1: 53 push %ebx
10e8d2: 83 ec 1c sub $0x1c,%esp
10e8d5: 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 );
10e8d8: 9c pushf
10e8d9: fa cli
10e8da: 5e pop %esi
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
10e8db: 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 );
10e8dd: 8d 47 04 lea 0x4(%edi),%eax
10e8e0: 89 45 e4 mov %eax,-0x1c(%ebp)
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
10e8e3: 39 c3 cmp %eax,%ebx
10e8e5: 74 11 je 10e8f8 <_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) {
10e8e7: 8b 43 10 mov 0x10(%ebx),%eax
10e8ea: 85 c0 test %eax,%eax
10e8ec: 74 34 je 10e922 <_Watchdog_Tickle+0x56>
the_watchdog->delta_interval--;
10e8ee: 48 dec %eax
10e8ef: 89 43 10 mov %eax,0x10(%ebx)
if ( the_watchdog->delta_interval != 0 )
10e8f2: 85 c0 test %eax,%eax
10e8f4: 74 2c je 10e922 <_Watchdog_Tickle+0x56>
10e8f6: 66 90 xchg %ax,%ax
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
10e8f8: 56 push %esi
10e8f9: 9d popf
}
10e8fa: 8d 65 f4 lea -0xc(%ebp),%esp
10e8fd: 5b pop %ebx
10e8fe: 5e pop %esi
10e8ff: 5f pop %edi
10e900: c9 leave
10e901: c3 ret
_ISR_Enable( level );
switch( watchdog_state ) {
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
10e902: 83 ec 08 sub $0x8,%esp
10e905: ff 73 24 pushl 0x24(%ebx)
10e908: ff 73 20 pushl 0x20(%ebx)
10e90b: ff 53 1c call *0x1c(%ebx)
the_watchdog->id,
the_watchdog->user_data
);
break;
10e90e: 83 c4 10 add $0x10,%esp
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
10e911: 9c pushf
10e912: fa cli
10e913: 5e pop %esi
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
10e914: 8b 1f mov (%edi),%ebx
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
10e916: 3b 5d e4 cmp -0x1c(%ebp),%ebx
10e919: 74 dd je 10e8f8 <_Watchdog_Tickle+0x2c>
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
10e91b: 8b 43 10 mov 0x10(%ebx),%eax
10e91e: 85 c0 test %eax,%eax
10e920: 75 d6 jne 10e8f8 <_Watchdog_Tickle+0x2c>
if ( the_watchdog->delta_interval != 0 )
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
10e922: 83 ec 0c sub $0xc,%esp
10e925: 53 push %ebx
10e926: e8 35 ff ff ff call 10e860 <_Watchdog_Remove>
_ISR_Enable( level );
10e92b: 56 push %esi
10e92c: 9d popf
switch( watchdog_state ) {
10e92d: 83 c4 10 add $0x10,%esp
10e930: 83 f8 02 cmp $0x2,%eax
10e933: 75 dc jne 10e911 <_Watchdog_Tickle+0x45> <== NEVER TAKEN
10e935: eb cb jmp 10e902 <_Watchdog_Tickle+0x36>
0010e938 <_Workspace_Handler_initialization>:
/*
* _Workspace_Handler_initialization
*/
void _Workspace_Handler_initialization(void)
{
10e938: 55 push %ebp
10e939: 89 e5 mov %esp,%ebp
10e93b: 57 push %edi
10e93c: 53 push %ebx
uintptr_t memory_available = 0;
void *starting_address = Configuration.work_space_start;
10e93d: 8b 1d 80 3a 12 00 mov 0x123a80,%ebx
uintptr_t size = Configuration.work_space_size;
10e943: 8b 15 84 3a 12 00 mov 0x123a84,%edx
if ( Configuration.do_zero_of_workspace )
10e949: 80 3d a8 3a 12 00 00 cmpb $0x0,0x123aa8
10e950: 75 1e jne 10e970 <_Workspace_Handler_initialization+0x38>
memset( starting_address, 0, size );
memory_available = _Heap_Initialize(
10e952: 6a 04 push $0x4
10e954: 52 push %edx
10e955: 53 push %ebx
10e956: 68 c0 7d 12 00 push $0x127dc0
10e95b: e8 8c dd ff ff call 10c6ec <_Heap_Initialize>
starting_address,
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
10e960: 83 c4 10 add $0x10,%esp
10e963: 85 c0 test %eax,%eax
10e965: 74 13 je 10e97a <_Workspace_Handler_initialization+0x42>
_Internal_error_Occurred(
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_TOO_LITTLE_WORKSPACE
);
}
10e967: 8d 65 f8 lea -0x8(%ebp),%esp
10e96a: 5b pop %ebx
10e96b: 5f pop %edi
10e96c: c9 leave
10e96d: c3 ret
10e96e: 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 );
10e970: 31 c0 xor %eax,%eax
10e972: 89 df mov %ebx,%edi
10e974: 89 d1 mov %edx,%ecx
10e976: f3 aa rep stos %al,%es:(%edi)
10e978: eb d8 jmp 10e952 <_Workspace_Handler_initialization+0x1a>
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
_Internal_error_Occurred(
10e97a: 50 push %eax
10e97b: 6a 02 push $0x2
10e97d: 6a 01 push $0x1
10e97f: 6a 00 push $0x0
10e981: e8 6e df ff ff call 10c8f4 <_Internal_error_Occurred>
0010c4ac <_rename_r>:
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
10c4ac: 55 push %ebp
10c4ad: 89 e5 mov %esp,%ebp
10c4af: 57 push %edi
10c4b0: 56 push %esi
10c4b1: 53 push %ebx
10c4b2: 83 ec 78 sub $0x78,%esp
10c4b5: 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 );
10c4b8: 53 push %ebx
10c4b9: e8 52 ea ff ff call 10af10 <rtems_filesystem_dirname>
if ( old_parent_pathlen == 0 )
10c4be: 83 c4 10 add $0x10,%esp
10c4c1: 85 c0 test %eax,%eax
10c4c3: 0f 85 57 01 00 00 jne 10c620 <_rename_r+0x174>
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
10c4c9: 52 push %edx
10c4ca: 8d 45 b8 lea -0x48(%ebp),%eax
10c4cd: 89 45 94 mov %eax,-0x6c(%ebp)
10c4d0: 50 push %eax
10c4d1: 8d 45 e4 lea -0x1c(%ebp),%eax
10c4d4: 50 push %eax
10c4d5: 53 push %ebx
10c4d6: e8 e1 03 00 00 call 10c8bc <rtems_filesystem_get_start_loc>
10c4db: 83 c4 10 add $0x10,%esp
10c4de: 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;
10c4e0: 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;
10c4e4: 8d 7d cc lea -0x34(%ebp),%edi
10c4e7: b9 05 00 00 00 mov $0x5,%ecx
10c4ec: 8b 75 94 mov -0x6c(%ebp),%esi
10c4ef: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
name = old + old_parent_pathlen;
10c4f1: 01 d3 add %edx,%ebx
10c4f3: 89 5d e0 mov %ebx,-0x20(%ebp)
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
10c4f6: be ff ff ff ff mov $0xffffffff,%esi
10c4fb: 89 f1 mov %esi,%ecx
10c4fd: 89 df mov %ebx,%edi
10c4ff: 31 c0 xor %eax,%eax
10c501: f2 ae repnz scas %es:(%edi),%al
10c503: f7 d1 not %ecx
10c505: 49 dec %ecx
10c506: 83 ec 08 sub $0x8,%esp
10c509: 51 push %ecx
10c50a: 53 push %ebx
10c50b: e8 44 ea ff ff call 10af54 <rtems_filesystem_prefix_separators>
10c510: 01 c3 add %eax,%ebx
10c512: 89 5d e0 mov %ebx,-0x20(%ebp)
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
10c515: 89 f1 mov %esi,%ecx
10c517: 89 df mov %ebx,%edi
10c519: 31 c0 xor %eax,%eax
10c51b: f2 ae repnz scas %es:(%edi),%al
10c51d: f7 d1 not %ecx
10c51f: 49 dec %ecx
10c520: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10c527: 8d 75 cc lea -0x34(%ebp),%esi
10c52a: 56 push %esi
10c52b: 6a 00 push $0x0
10c52d: 51 push %ecx
10c52e: 53 push %ebx
10c52f: e8 30 e9 ff ff call 10ae64 <rtems_filesystem_evaluate_relative_path>
0, &old_loc, false );
if ( result != 0 ) {
10c534: 83 c4 20 add $0x20,%esp
10c537: 85 c0 test %eax,%eax
10c539: 0f 85 c9 00 00 00 jne 10c608 <_rename_r+0x15c>
/*
* Get the parent of the new node we are renaming to.
*/
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
10c53f: 50 push %eax
10c540: 8d 5d a4 lea -0x5c(%ebp),%ebx
10c543: 53 push %ebx
10c544: 8d 45 e4 lea -0x1c(%ebp),%eax
10c547: 50 push %eax
10c548: ff 75 10 pushl 0x10(%ebp)
10c54b: e8 6c 03 00 00 call 10c8bc <rtems_filesystem_get_start_loc>
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
10c550: 83 c4 0c add $0xc,%esp
10c553: 8d 45 e0 lea -0x20(%ebp),%eax
10c556: 50 push %eax
10c557: 53 push %ebx
10c558: 8b 45 10 mov 0x10(%ebp),%eax
10c55b: 03 45 e4 add -0x1c(%ebp),%eax
10c55e: 50 push %eax
10c55f: 8b 45 b0 mov -0x50(%ebp),%eax
10c562: ff 50 04 call *0x4(%eax)
if ( result != 0 ) {
10c565: 83 c4 10 add $0x10,%esp
10c568: 85 c0 test %eax,%eax
10c56a: 0f 85 e0 00 00 00 jne 10c650 <_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 ) {
10c570: 8b 45 b4 mov -0x4c(%ebp),%eax
10c573: 39 45 c8 cmp %eax,-0x38(%ebp)
10c576: 75 48 jne 10c5c0 <_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 );
10c578: ff 75 e0 pushl -0x20(%ebp)
10c57b: 53 push %ebx
10c57c: 56 push %esi
10c57d: ff 75 94 pushl -0x6c(%ebp)
10c580: 8b 45 b0 mov -0x50(%ebp),%eax
10c583: ff 50 40 call *0x40(%eax)
10c586: 89 c7 mov %eax,%edi
rtems_filesystem_freenode( &new_parent_loc );
10c588: 89 1c 24 mov %ebx,(%esp)
10c58b: e8 f0 eb ff ff call 10b180 <rtems_filesystem_freenode>
if ( free_old_parentloc )
10c590: 83 c4 10 add $0x10,%esp
10c593: 80 7d 93 00 cmpb $0x0,-0x6d(%ebp)
10c597: 75 17 jne 10c5b0 <_rename_r+0x104>
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
10c599: 83 ec 0c sub $0xc,%esp
10c59c: 56 push %esi
10c59d: e8 de eb ff ff call 10b180 <rtems_filesystem_freenode>
return result;
10c5a2: 83 c4 10 add $0x10,%esp
}
10c5a5: 89 f8 mov %edi,%eax
10c5a7: 8d 65 f4 lea -0xc(%ebp),%esp
10c5aa: 5b pop %ebx
10c5ab: 5e pop %esi
10c5ac: 5f pop %edi
10c5ad: c9 leave
10c5ae: c3 ret
10c5af: 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 );
10c5b0: 83 ec 0c sub $0xc,%esp
10c5b3: ff 75 94 pushl -0x6c(%ebp)
10c5b6: e8 c5 eb ff ff call 10b180 <rtems_filesystem_freenode>
10c5bb: 83 c4 10 add $0x10,%esp
10c5be: eb d9 jmp 10c599 <_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 );
10c5c0: 83 ec 0c sub $0xc,%esp
10c5c3: 53 push %ebx
10c5c4: e8 b7 eb ff ff call 10b180 <rtems_filesystem_freenode>
if ( free_old_parentloc )
10c5c9: 83 c4 10 add $0x10,%esp
10c5cc: 80 7d 93 00 cmpb $0x0,-0x6d(%ebp)
10c5d0: 74 0e je 10c5e0 <_rename_r+0x134>
rtems_filesystem_freenode( &old_parent_loc );
10c5d2: 83 ec 0c sub $0xc,%esp
10c5d5: ff 75 94 pushl -0x6c(%ebp)
10c5d8: e8 a3 eb ff ff call 10b180 <rtems_filesystem_freenode>
10c5dd: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( &old_loc );
10c5e0: 83 ec 0c sub $0xc,%esp
10c5e3: 56 push %esi
10c5e4: e8 97 eb ff ff call 10b180 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EXDEV );
10c5e9: e8 d2 a8 00 00 call 116ec0 <__errno>
10c5ee: c7 00 12 00 00 00 movl $0x12,(%eax)
10c5f4: 83 c4 10 add $0x10,%esp
10c5f7: 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;
}
10c5fc: 89 f8 mov %edi,%eax
10c5fe: 8d 65 f4 lea -0xc(%ebp),%esp
10c601: 5b pop %ebx
10c602: 5e pop %esi
10c603: 5f pop %edi
10c604: c9 leave
10c605: c3 ret
10c606: 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 )
10c608: 80 7d 93 00 cmpb $0x0,-0x6d(%ebp)
10c60c: 75 78 jne 10c686 <_rename_r+0x1da> <== ALWAYS TAKEN
rtems_filesystem_freenode( &old_parent_loc );
return -1;
10c60e: 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;
}
10c613: 89 f8 mov %edi,%eax <== NOT EXECUTED
10c615: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10c618: 5b pop %ebx <== NOT EXECUTED
10c619: 5e pop %esi <== NOT EXECUTED
10c61a: 5f pop %edi <== NOT EXECUTED
10c61b: c9 leave <== NOT EXECUTED
10c61c: c3 ret <== NOT EXECUTED
10c61d: 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,
10c620: 89 c2 mov %eax,%edx
10c622: 83 ec 0c sub $0xc,%esp
10c625: 6a 00 push $0x0
10c627: 8d 45 b8 lea -0x48(%ebp),%eax
10c62a: 89 45 94 mov %eax,-0x6c(%ebp)
10c62d: 50 push %eax
10c62e: 6a 02 push $0x2
10c630: 52 push %edx
10c631: 53 push %ebx
10c632: 89 55 8c mov %edx,-0x74(%ebp)
10c635: e8 92 e8 ff ff call 10aecc <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
10c63a: 83 c4 20 add $0x20,%esp
10c63d: 85 c0 test %eax,%eax
10c63f: 8b 55 8c mov -0x74(%ebp),%edx
10c642: 75 ca jne 10c60e <_rename_r+0x162> <== NEVER TAKEN
return -1;
free_old_parentloc = true;
10c644: c6 45 93 01 movb $0x1,-0x6d(%ebp)
10c648: e9 97 fe ff ff jmp 10c4e4 <_rename_r+0x38>
10c64d: 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 );
10c650: 83 ec 0c sub $0xc,%esp
10c653: 53 push %ebx
10c654: e8 27 eb ff ff call 10b180 <rtems_filesystem_freenode>
if ( free_old_parentloc )
10c659: 83 c4 10 add $0x10,%esp
10c65c: 80 7d 93 00 cmpb $0x0,-0x6d(%ebp)
10c660: 74 0e je 10c670 <_rename_r+0x1c4> <== NEVER TAKEN
rtems_filesystem_freenode( &old_parent_loc );
10c662: 83 ec 0c sub $0xc,%esp
10c665: ff 75 94 pushl -0x6c(%ebp)
10c668: e8 13 eb ff ff call 10b180 <rtems_filesystem_freenode>
10c66d: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( &old_loc );
10c670: 83 ec 0c sub $0xc,%esp
10c673: 56 push %esi
10c674: e8 07 eb ff ff call 10b180 <rtems_filesystem_freenode>
return -1;
10c679: 83 c4 10 add $0x10,%esp
10c67c: bf ff ff ff ff mov $0xffffffff,%edi
10c681: e9 1f ff ff ff jmp 10c5a5 <_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 );
10c686: 83 ec 0c sub $0xc,%esp
10c689: ff 75 94 pushl -0x6c(%ebp)
10c68c: e8 ef ea ff ff call 10b180 <rtems_filesystem_freenode>
10c691: 83 c4 10 add $0x10,%esp
return -1;
10c694: bf ff ff ff ff mov $0xffffffff,%edi
10c699: e9 07 ff ff ff jmp 10c5a5 <_rename_r+0xf9>
0010ad6c <_times>:
#endif
clock_t _times(
struct tms *ptms
)
{
10ad6c: 55 push %ebp
10ad6d: 89 e5 mov %esp,%ebp
10ad6f: 56 push %esi
10ad70: 53 push %ebx
10ad71: 83 ec 10 sub $0x10,%esp
10ad74: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_interval ticks;
if ( !ptms )
10ad77: 85 db test %ebx,%ebx
10ad79: 74 75 je 10adf0 <_times+0x84>
/*
* This call does not depend on TOD being initialized and can't fail.
*/
ticks = rtems_clock_get_ticks_since_boot();
10ad7b: e8 84 04 00 00 call 10b204 <rtems_clock_get_ticks_since_boot>
10ad80: 89 c6 mov %eax,%esi
{
Timestamp_Control per_tick;
uint32_t ticks;
uint32_t fractional_ticks;
_Timestamp_Set(
10ad82: 8b 0d ac 3d 12 00 mov 0x123dac,%ecx
10ad88: ba 83 de 1b 43 mov $0x431bde83,%edx
10ad8d: 89 c8 mov %ecx,%eax
10ad8f: f7 e2 mul %edx
10ad91: c1 ea 12 shr $0x12,%edx
10ad94: 89 55 e8 mov %edx,-0x18(%ebp)
10ad97: 8d 04 89 lea (%ecx,%ecx,4),%eax
10ad9a: 8d 04 80 lea (%eax,%eax,4),%eax
10ad9d: 8d 04 80 lea (%eax,%eax,4),%eax
10ada0: c1 e0 03 shl $0x3,%eax
10ada3: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx
10ada8: 31 d2 xor %edx,%edx
10adaa: f7 f1 div %ecx
10adac: 89 55 ec mov %edx,-0x14(%ebp)
TOD_MICROSECONDS_PER_SECOND,
(rtems_configuration_get_nanoseconds_per_tick() %
TOD_NANOSECONDS_PER_SECOND)
);
_Timestamp_Divide(
10adaf: 8d 45 f0 lea -0x10(%ebp),%eax
10adb2: 50 push %eax
10adb3: 8d 45 f4 lea -0xc(%ebp),%eax
10adb6: 50 push %eax
10adb7: 8d 45 e8 lea -0x18(%ebp),%eax
10adba: 50 push %eax
10adbb: a1 58 86 12 00 mov 0x128658,%eax
10adc0: 05 84 00 00 00 add $0x84,%eax
10adc5: 50 push %eax
10adc6: e8 89 38 00 00 call 10e654 <_Timespec_Divide>
&_Thread_Executing->cpu_time_used,
&per_tick,
&ticks,
&fractional_ticks
);
ptms->tms_utime = ticks;
10adcb: 8b 45 f4 mov -0xc(%ebp),%eax
10adce: 89 03 mov %eax,(%ebx)
}
#else
ptms->tms_utime = _Thread_Executing->cpu_time_used;
#endif
ptms->tms_stime = ticks;
10add0: 89 73 04 mov %esi,0x4(%ebx)
ptms->tms_cutime = 0;
10add3: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
ptms->tms_cstime = 0;
10adda: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
return ticks;
10ade1: 83 c4 10 add $0x10,%esp
10ade4: 89 f0 mov %esi,%eax
}
10ade6: 8d 65 f8 lea -0x8(%ebp),%esp
10ade9: 5b pop %ebx
10adea: 5e pop %esi
10adeb: c9 leave
10adec: c3 ret
10aded: 8d 76 00 lea 0x0(%esi),%esi
)
{
rtems_interval ticks;
if ( !ptms )
rtems_set_errno_and_return_minus_one( EFAULT );
10adf0: e8 4b 87 00 00 call 113540 <__errno>
10adf5: c7 00 0e 00 00 00 movl $0xe,(%eax)
10adfb: b8 ff ff ff ff mov $0xffffffff,%eax
ptms->tms_stime = ticks;
ptms->tms_cutime = 0;
ptms->tms_cstime = 0;
return ticks;
}
10ae00: 8d 65 f8 lea -0x8(%ebp),%esp
10ae03: 5b pop %ebx
10ae04: 5e pop %esi
10ae05: c9 leave
10ae06: c3 ret
00109b3c <access>:
int access(
const char *path,
int amode
)
{
109b3c: 55 push %ebp
109b3d: 89 e5 mov %esp,%ebp
109b3f: 53 push %ebx
109b40: 83 ec 5c sub $0x5c,%esp
109b43: 8b 5d 0c mov 0xc(%ebp),%ebx
struct stat statbuf;
if ( stat(path, &statbuf) )
109b46: 8d 45 b0 lea -0x50(%ebp),%eax
109b49: 50 push %eax
109b4a: ff 75 08 pushl 0x8(%ebp)
109b4d: e8 42 17 00 00 call 10b294 <stat>
109b52: 83 c4 10 add $0x10,%esp
109b55: 85 c0 test %eax,%eax
109b57: 75 1f jne 109b78 <access+0x3c>
return -1;
if ( amode & R_OK ) {
109b59: f6 c3 04 test $0x4,%bl
109b5c: 75 26 jne 109b84 <access+0x48>
if (!( statbuf.st_mode & S_IREAD ))
return -1;
}
if ( amode & W_OK ) {
109b5e: f6 c3 02 test $0x2,%bl
109b61: 75 0d jne 109b70 <access+0x34>
if ( !( statbuf.st_mode & S_IWRITE ) )
return -1;
}
if ( amode & X_OK ) {
109b63: 83 e3 01 and $0x1,%ebx
109b66: 75 24 jne 109b8c <access+0x50>
if ( !( statbuf.st_mode & S_IEXEC ) )
return -1;
}
return 0;
109b68: 31 c0 xor %eax,%eax
}
109b6a: 8b 5d fc mov -0x4(%ebp),%ebx
109b6d: c9 leave
109b6e: c3 ret
109b6f: 90 nop
if (!( statbuf.st_mode & S_IREAD ))
return -1;
}
if ( amode & W_OK ) {
if ( !( statbuf.st_mode & S_IWRITE ) )
109b70: f6 45 bc 80 testb $0x80,-0x44(%ebp)
109b74: 75 ed jne 109b63 <access+0x27>
109b76: 66 90 xchg %ax,%ax
return -1;
109b78: b8 ff ff ff ff mov $0xffffffff,%eax
if ( !( statbuf.st_mode & S_IEXEC ) )
return -1;
}
return 0;
}
109b7d: 8b 5d fc mov -0x4(%ebp),%ebx
109b80: c9 leave
109b81: c3 ret
109b82: 66 90 xchg %ax,%ax
if ( stat(path, &statbuf) )
return -1;
if ( amode & R_OK ) {
if (!( statbuf.st_mode & S_IREAD ))
109b84: f6 45 bd 01 testb $0x1,-0x43(%ebp)
109b88: 75 d4 jne 109b5e <access+0x22>
109b8a: eb ec jmp 109b78 <access+0x3c>
if ( !( statbuf.st_mode & S_IWRITE ) )
return -1;
}
if ( amode & X_OK ) {
if ( !( statbuf.st_mode & S_IEXEC ) )
109b8c: 8b 45 bc mov -0x44(%ebp),%eax
109b8f: 83 e0 40 and $0x40,%eax
return -1;
}
return 0;
109b92: 83 f8 01 cmp $0x1,%eax
109b95: 19 c0 sbb %eax,%eax
109b97: eb d1 jmp 109b6a <access+0x2e>
0010b5d4 <adjtime>:
int adjtime(
struct timeval *delta,
struct timeval *olddelta
)
{
10b5d4: 55 push %ebp
10b5d5: 89 e5 mov %esp,%ebp
10b5d7: 57 push %edi
10b5d8: 56 push %esi
10b5d9: 53 push %ebx
10b5da: 83 ec 1c sub $0x1c,%esp
10b5dd: 8b 5d 08 mov 0x8(%ebp),%ebx
10b5e0: 8b 75 0c mov 0xc(%ebp),%esi
long adjustment;
/*
* Simple validations
*/
if ( !delta )
10b5e3: 85 db test %ebx,%ebx
10b5e5: 0f 84 f1 00 00 00 je 10b6dc <adjtime+0x108>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
10b5eb: 8b 53 04 mov 0x4(%ebx),%edx
10b5ee: 81 fa 3f 42 0f 00 cmp $0xf423f,%edx
10b5f4: 0f 87 e2 00 00 00 ja 10b6dc <adjtime+0x108>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( olddelta ) {
10b5fa: 85 f6 test %esi,%esi
10b5fc: 74 10 je 10b60e <adjtime+0x3a>
olddelta->tv_sec = 0;
10b5fe: c7 06 00 00 00 00 movl $0x0,(%esi)
olddelta->tv_usec = 0;
10b604: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi)
10b60b: 8b 53 04 mov 0x4(%ebx),%edx
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
10b60e: 8b 03 mov (%ebx),%eax
10b610: 8d 04 80 lea (%eax,%eax,4),%eax
10b613: 8d 04 80 lea (%eax,%eax,4),%eax
10b616: 8d 04 80 lea (%eax,%eax,4),%eax
10b619: 8d 04 80 lea (%eax,%eax,4),%eax
10b61c: 8d 04 80 lea (%eax,%eax,4),%eax
10b61f: 8d 04 80 lea (%eax,%eax,4),%eax
10b622: c1 e0 06 shl $0x6,%eax
adjustment += delta->tv_usec;
10b625: 8d 04 02 lea (%edx,%eax,1),%eax
/* too small to account for */
if ( adjustment < rtems_configuration_get_microseconds_per_tick() )
10b628: 3b 05 6c 42 12 00 cmp 0x12426c,%eax
10b62e: 73 0c jae 10b63c <adjtime+0x68>
/* set the user's output */
if ( olddelta )
*olddelta = *delta;
return 0;
10b630: 31 c0 xor %eax,%eax
}
10b632: 8d 65 f4 lea -0xc(%ebp),%esp
10b635: 5b pop %ebx
10b636: 5e pop %esi
10b637: 5f pop %edi
10b638: c9 leave
10b639: c3 ret
10b63a: 66 90 xchg %ax,%ax
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b63c: a1 d0 86 12 00 mov 0x1286d0,%eax
10b641: 40 inc %eax
10b642: a3 d0 86 12 00 mov %eax,0x1286d0
* This prevents context switches while we are adjusting the TOD
*/
_Thread_Disable_dispatch();
_TOD_Get( &ts );
10b647: 83 ec 0c sub $0xc,%esp
10b64a: 8d 7d e0 lea -0x20(%ebp),%edi
10b64d: 57 push %edi
10b64e: e8 85 17 00 00 call 10cdd8 <_TOD_Get>
ts.tv_sec += delta->tv_sec;
10b653: 8b 03 mov (%ebx),%eax
10b655: 01 45 e0 add %eax,-0x20(%ebp)
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
10b658: 8b 43 04 mov 0x4(%ebx),%eax
10b65b: 8d 04 80 lea (%eax,%eax,4),%eax
10b65e: 8d 04 80 lea (%eax,%eax,4),%eax
10b661: 8d 04 80 lea (%eax,%eax,4),%eax
10b664: c1 e0 03 shl $0x3,%eax
10b667: 03 45 e4 add -0x1c(%ebp),%eax
10b66a: 89 45 e4 mov %eax,-0x1c(%ebp)
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
10b66d: 83 c4 10 add $0x10,%esp
10b670: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax
10b675: 76 18 jbe 10b68f <adjtime+0xbb>
10b677: 8b 55 e0 mov -0x20(%ebp),%edx
10b67a: 66 90 xchg %ax,%ax
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
10b67c: 2d 00 ca 9a 3b sub $0x3b9aca00,%eax
* At one point there was a static variable named adjustment
* used by this implementation. I don't see any reason for it
* to be here based upon the GNU/Linux documentation.
*/
int adjtime(
10b681: 42 inc %edx
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
/* if adjustment is too much positive */
while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
10b682: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax
10b687: 77 f3 ja 10b67c <adjtime+0xa8> <== NEVER TAKEN
10b689: 89 45 e4 mov %eax,-0x1c(%ebp)
10b68c: 89 55 e0 mov %edx,-0x20(%ebp)
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
10b68f: 3d 00 36 65 c4 cmp $0xc4653600,%eax
10b694: 77 19 ja 10b6af <adjtime+0xdb> <== NEVER TAKEN
10b696: 8b 55 e0 mov -0x20(%ebp),%edx
10b699: 8d 76 00 lea 0x0(%esi),%esi
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
10b69c: 05 00 ca 9a 3b add $0x3b9aca00,%eax
* At one point there was a static variable named adjustment
* used by this implementation. I don't see any reason for it
* to be here based upon the GNU/Linux documentation.
*/
int adjtime(
10b6a1: 4a dec %edx
ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec++;
}
/* if adjustment is too much negative */
while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) {
10b6a2: 3d 00 36 65 c4 cmp $0xc4653600,%eax
10b6a7: 76 f3 jbe 10b69c <adjtime+0xc8>
10b6a9: 89 45 e4 mov %eax,-0x1c(%ebp)
10b6ac: 89 55 e0 mov %edx,-0x20(%ebp)
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec--;
}
_TOD_Set( &ts );
10b6af: 83 ec 0c sub $0xc,%esp
10b6b2: 57 push %edi
10b6b3: e8 a8 17 00 00 call 10ce60 <_TOD_Set>
_Thread_Enable_dispatch();
10b6b8: e8 ab 2c 00 00 call 10e368 <_Thread_Enable_dispatch>
/* set the user's output */
if ( olddelta )
10b6bd: 83 c4 10 add $0x10,%esp
10b6c0: 85 f6 test %esi,%esi
10b6c2: 0f 84 68 ff ff ff je 10b630 <adjtime+0x5c>
*olddelta = *delta;
10b6c8: 8b 03 mov (%ebx),%eax
10b6ca: 8b 53 04 mov 0x4(%ebx),%edx
10b6cd: 89 06 mov %eax,(%esi)
10b6cf: 89 56 04 mov %edx,0x4(%esi)
return 0;
10b6d2: 31 c0 xor %eax,%eax
}
10b6d4: 8d 65 f4 lea -0xc(%ebp),%esp
10b6d7: 5b pop %ebx
10b6d8: 5e pop %esi
10b6d9: 5f pop %edi
10b6da: c9 leave
10b6db: c3 ret
*/
if ( !delta )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
rtems_set_errno_and_return_minus_one( EINVAL );
10b6dc: e8 43 86 00 00 call 113d24 <__errno>
10b6e1: c7 00 16 00 00 00 movl $0x16,(%eax)
10b6e7: b8 ff ff ff ff mov $0xffffffff,%eax
10b6ec: e9 41 ff ff ff jmp 10b632 <adjtime+0x5e>
0010bd14 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
10bd14: 55 push %ebp
10bd15: 89 e5 mov %esp,%ebp
10bd17: 57 push %edi
10bd18: 56 push %esi
10bd19: 53 push %ebx
10bd1a: 83 ec 18 sub $0x18,%esp
10bd1d: 8b 75 08 mov 0x8(%ebp),%esi
10bd20: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
10bd23: 68 00 aa 12 00 push $0x12aa00
10bd28: e8 bf 11 00 00 call 10ceec <pthread_mutex_lock>
if (fcntl (fildes, F_GETFD) < 0) {
10bd2d: 5a pop %edx
10bd2e: 59 pop %ecx
10bd2f: 6a 01 push $0x1
10bd31: 56 push %esi
10bd32: e8 01 6b 00 00 call 112838 <fcntl>
10bd37: 83 c4 10 add $0x10,%esp
10bd3a: 85 c0 test %eax,%eax
10bd3c: 0f 88 9b 01 00 00 js 10bedd <aio_cancel+0x1c9>
pthread_mutex_unlock(&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EBADF);
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
10bd42: 85 db test %ebx,%ebx
10bd44: 0f 84 ea 00 00 00 je 10be34 <aio_cancel+0x120>
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
10bd4a: 8b 3b mov (%ebx),%edi
10bd4c: 39 f7 cmp %esi,%edi
10bd4e: 0f 85 b8 00 00 00 jne 10be0c <aio_cancel+0xf8>
pthread_mutex_unlock (&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
10bd54: 56 push %esi
10bd55: 6a 00 push $0x0
10bd57: 57 push %edi
10bd58: 68 48 aa 12 00 push $0x12aa48
10bd5d: e8 9e 03 00 00 call 10c100 <rtems_aio_search_fd>
10bd62: 89 c6 mov %eax,%esi
if (r_chain == NULL) {
10bd64: 83 c4 10 add $0x10,%esp
10bd67: 85 c0 test %eax,%eax
10bd69: 74 3d je 10bda8 <aio_cancel+0x94>
return AIO_ALLDONE;
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
10bd6b: 8d 78 1c lea 0x1c(%eax),%edi
10bd6e: 83 ec 0c sub $0xc,%esp
10bd71: 57 push %edi
10bd72: e8 75 11 00 00 call 10ceec <pthread_mutex_lock>
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
10bd77: 58 pop %eax
10bd78: 5a pop %edx
10bd79: 53 push %ebx
10bd7a: 83 c6 08 add $0x8,%esi
10bd7d: 56 push %esi
10bd7e: e8 5d 07 00 00 call 10c4e0 <rtems_aio_remove_req>
10bd83: 89 c3 mov %eax,%ebx
pthread_mutex_unlock (&r_chain->mutex);
10bd85: 89 3c 24 mov %edi,(%esp)
10bd88: e8 e7 11 00 00 call 10cf74 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
10bd8d: c7 04 24 00 aa 12 00 movl $0x12aa00,(%esp)
10bd94: e8 db 11 00 00 call 10cf74 <pthread_mutex_unlock>
return result;
10bd99: 83 c4 10 add $0x10,%esp
}
return AIO_ALLDONE;
}
10bd9c: 89 d8 mov %ebx,%eax
10bd9e: 8d 65 f4 lea -0xc(%ebp),%esp
10bda1: 5b pop %ebx
10bda2: 5e pop %esi
10bda3: 5f pop %edi
10bda4: c9 leave
10bda5: c3 ret
10bda6: 66 90 xchg %ax,%ax
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
10bda8: 81 3d 54 aa 12 00 58 cmpl $0x12aa58,0x12aa54
10bdaf: aa 12 00
10bdb2: 74 40 je 10bdf4 <aio_cancel+0xe0> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
10bdb4: 51 push %ecx
10bdb5: 6a 00 push $0x0
10bdb7: 57 push %edi
10bdb8: 68 54 aa 12 00 push $0x12aa54
10bdbd: e8 3e 03 00 00 call 10c100 <rtems_aio_search_fd>
if (r_chain == NULL) {
10bdc2: 83 c4 10 add $0x10,%esp
10bdc5: 85 c0 test %eax,%eax
10bdc7: 74 43 je 10be0c <aio_cancel+0xf8>
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
10bdc9: 83 ec 08 sub $0x8,%esp
10bdcc: 53 push %ebx
10bdcd: 83 c0 08 add $0x8,%eax
10bdd0: 50 push %eax
10bdd1: e8 0a 07 00 00 call 10c4e0 <rtems_aio_remove_req>
10bdd6: 89 c3 mov %eax,%ebx
pthread_mutex_unlock (&aio_request_queue.mutex);
10bdd8: c7 04 24 00 aa 12 00 movl $0x12aa00,(%esp)
10bddf: e8 90 11 00 00 call 10cf74 <pthread_mutex_unlock>
return result;
10bde4: 83 c4 10 add $0x10,%esp
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
return AIO_ALLDONE;
}
10bde7: 89 d8 mov %ebx,%eax
10bde9: 8d 65 f4 lea -0xc(%ebp),%esp
10bdec: 5b pop %ebx
10bded: 5e pop %esi
10bdee: 5f pop %edi
10bdef: c9 leave
10bdf0: c3 ret
10bdf1: 8d 76 00 lea 0x0(%esi),%esi
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
} else {
pthread_mutex_unlock (&aio_request_queue.mutex);
10bdf4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10bdf7: 68 00 aa 12 00 push $0x12aa00 <== NOT EXECUTED
10bdfc: e8 73 11 00 00 call 10cf74 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
10be01: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10be04: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED
10be09: eb 91 jmp 10bd9c <aio_cancel+0x88> <== NOT EXECUTED
10be0b: 90 nop <== NOT EXECUTED
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
if (r_chain == NULL) {
pthread_mutex_unlock (&aio_request_queue.mutex);
10be0c: 83 ec 0c sub $0xc,%esp
10be0f: 68 00 aa 12 00 push $0x12aa00
10be14: e8 5b 11 00 00 call 10cf74 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
10be19: e8 7a 9d 00 00 call 115b98 <__errno>
10be1e: c7 00 16 00 00 00 movl $0x16,(%eax)
10be24: 83 c4 10 add $0x10,%esp
10be27: bb ff ff ff ff mov $0xffffffff,%ebx
10be2c: e9 6b ff ff ff jmp 10bd9c <aio_cancel+0x88>
10be31: 8d 76 00 lea 0x0(%esi),%esi
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
10be34: 50 push %eax
10be35: 6a 00 push $0x0
10be37: 56 push %esi
10be38: 68 48 aa 12 00 push $0x12aa48
10be3d: e8 be 02 00 00 call 10c100 <rtems_aio_search_fd>
10be42: 89 c3 mov %eax,%ebx
if (r_chain == NULL) {
10be44: 83 c4 10 add $0x10,%esp
10be47: 85 c0 test %eax,%eax
10be49: 74 3d je 10be88 <aio_cancel+0x174>
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
10be4b: 8d 70 1c lea 0x1c(%eax),%esi
10be4e: 83 ec 0c sub $0xc,%esp
10be51: 56 push %esi
10be52: e8 95 10 00 00 call 10ceec <pthread_mutex_lock>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10be57: 89 1c 24 mov %ebx,(%esp)
10be5a: e8 5d 2a 00 00 call 10e8bc <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10be5f: 89 1c 24 mov %ebx,(%esp)
10be62: e8 29 06 00 00 call 10c490 <rtems_aio_remove_fd>
pthread_mutex_unlock (&r_chain->mutex);
10be67: 89 34 24 mov %esi,(%esp)
10be6a: e8 05 11 00 00 call 10cf74 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
10be6f: c7 04 24 00 aa 12 00 movl $0x12aa00,(%esp)
10be76: e8 f9 10 00 00 call 10cf74 <pthread_mutex_unlock>
return AIO_CANCELED;
10be7b: 83 c4 10 add $0x10,%esp
10be7e: 31 db xor %ebx,%ebx
10be80: e9 17 ff ff ff jmp 10bd9c <aio_cancel+0x88>
10be85: 8d 76 00 lea 0x0(%esi),%esi
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
if (r_chain == NULL) {
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
10be88: 81 3d 54 aa 12 00 58 cmpl $0x12aa58,0x12aa54
10be8f: aa 12 00
10be92: 0f 84 5c ff ff ff je 10bdf4 <aio_cancel+0xe0> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
10be98: 57 push %edi
10be99: 6a 00 push $0x0
10be9b: 56 push %esi
10be9c: 68 54 aa 12 00 push $0x12aa54
10bea1: e8 5a 02 00 00 call 10c100 <rtems_aio_search_fd>
10bea6: 89 c3 mov %eax,%ebx
if (r_chain == NULL) {
10bea8: 83 c4 10 add $0x10,%esp
10beab: 85 c0 test %eax,%eax
10bead: 74 53 je 10bf02 <aio_cancel+0x1ee>
10beaf: 83 ec 0c sub $0xc,%esp
10beb2: 50 push %eax
10beb3: e8 04 2a 00 00 call 10e8bc <_Chain_Extract>
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10beb8: 89 1c 24 mov %ebx,(%esp)
10bebb: e8 d0 05 00 00 call 10c490 <rtems_aio_remove_fd>
pthread_mutex_destroy (&r_chain->mutex);
10bec0: 8d 73 1c lea 0x1c(%ebx),%esi
10bec3: 89 34 24 mov %esi,(%esp)
10bec6: e8 b5 0d 00 00 call 10cc80 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->mutex);
10becb: 89 34 24 mov %esi,(%esp)
10bece: e8 69 0a 00 00 call 10c93c <pthread_cond_destroy>
free (r_chain);
10bed3: 89 1c 24 mov %ebx,(%esp)
10bed6: e8 59 cc ff ff call 108b34 <free>
10bedb: eb 92 jmp 10be6f <aio_cancel+0x15b>
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
if (fcntl (fildes, F_GETFD) < 0) {
pthread_mutex_unlock(&aio_request_queue.mutex);
10bedd: 83 ec 0c sub $0xc,%esp
10bee0: 68 00 aa 12 00 push $0x12aa00
10bee5: e8 8a 10 00 00 call 10cf74 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
10beea: e8 a9 9c 00 00 call 115b98 <__errno>
10beef: c7 00 09 00 00 00 movl $0x9,(%eax)
10bef5: 83 c4 10 add $0x10,%esp
10bef8: bb ff ff ff ff mov $0xffffffff,%ebx
10befd: e9 9a fe ff ff jmp 10bd9c <aio_cancel+0x88>
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
if (r_chain == NULL) {
pthread_mutex_unlock(&aio_request_queue.mutex);
10bf02: 83 ec 0c sub $0xc,%esp
10bf05: 68 00 aa 12 00 push $0x12aa00
10bf0a: e8 65 10 00 00 call 10cf74 <pthread_mutex_unlock>
return AIO_ALLDONE;
10bf0f: 83 c4 10 add $0x10,%esp
10bf12: b3 02 mov $0x2,%bl
10bf14: e9 83 fe ff ff jmp 10bd9c <aio_cancel+0x88>
0010bf28 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
10bf28: 55 push %ebp
10bf29: 89 e5 mov %esp,%ebp
10bf2b: 53 push %ebx
10bf2c: 83 ec 04 sub $0x4,%esp
10bf2f: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
10bf32: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp)
10bf39: 75 41 jne 10bf7c <aio_fsync+0x54>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10bf3b: 83 ec 08 sub $0x8,%esp
10bf3e: 6a 03 push $0x3
10bf40: ff 33 pushl (%ebx)
10bf42: e8 f1 68 00 00 call 112838 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10bf47: 83 e0 03 and $0x3,%eax
10bf4a: 48 dec %eax
10bf4b: 83 c4 10 add $0x10,%esp
10bf4e: 83 f8 01 cmp $0x1,%eax
10bf51: 77 4d ja 10bfa0 <aio_fsync+0x78>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
10bf53: 83 ec 0c sub $0xc,%esp
10bf56: 6a 18 push $0x18
10bf58: e8 eb d0 ff ff call 109048 <malloc>
if (req == NULL)
10bf5d: 83 c4 10 add $0x10,%esp
10bf60: 85 c0 test %eax,%eax
10bf62: 74 57 je 10bfbb <aio_fsync+0x93> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
10bf64: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_SYNC;
10bf67: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx)
return rtems_aio_enqueue (req);
10bf6e: 89 45 08 mov %eax,0x8(%ebp)
}
10bf71: 8b 5d fc mov -0x4(%ebp),%ebx
10bf74: c9 leave
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
10bf75: e9 d6 05 00 00 jmp 10c550 <rtems_aio_enqueue>
10bf7a: 66 90 xchg %ax,%ax
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10bf7c: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10bf83: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10bf8a: e8 09 9c 00 00 call 115b98 <__errno>
10bf8f: c7 00 16 00 00 00 movl $0x16,(%eax)
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
10bf95: b8 ff ff ff ff mov $0xffffffff,%eax
10bf9a: 8b 5d fc mov -0x4(%ebp),%ebx
10bf9d: c9 leave
10bf9e: c3 ret
10bf9f: 90 nop
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10bfa0: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10bfa7: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10bfae: e8 e5 9b 00 00 call 115b98 <__errno>
10bfb3: c7 00 09 00 00 00 movl $0x9,(%eax)
10bfb9: eb da jmp 10bf95 <aio_fsync+0x6d>
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10bfbb: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx)
10bfc2: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10bfc9: e8 ca 9b 00 00 call 115b98 <__errno> <== NOT EXECUTED
10bfce: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10bfd4: eb bf jmp 10bf95 <aio_fsync+0x6d> <== NOT EXECUTED
0010c760 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
10c760: 55 push %ebp
10c761: 89 e5 mov %esp,%ebp
10c763: 53 push %ebx
10c764: 83 ec 0c sub $0xc,%esp
10c767: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10c76a: 6a 03 push $0x3
10c76c: ff 33 pushl (%ebx)
10c76e: e8 c5 60 00 00 call 112838 <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10c773: 83 c4 10 add $0x10,%esp
10c776: 83 e0 03 and $0x3,%eax
10c779: 74 05 je 10c780 <aio_read+0x20> <== NEVER TAKEN
10c77b: 83 f8 02 cmp $0x2,%eax
10c77e: 75 38 jne 10c7b8 <aio_read+0x58>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10c780: 8b 53 14 mov 0x14(%ebx),%edx
10c783: 85 d2 test %edx,%edx
10c785: 75 55 jne 10c7dc <aio_read+0x7c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10c787: 8b 43 08 mov 0x8(%ebx),%eax
10c78a: 85 c0 test %eax,%eax
10c78c: 78 4e js 10c7dc <aio_read+0x7c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
10c78e: 83 ec 0c sub $0xc,%esp
10c791: 6a 18 push $0x18
10c793: e8 b0 c8 ff ff call 109048 <malloc>
if (req == NULL)
10c798: 83 c4 10 add $0x10,%esp
10c79b: 85 c0 test %eax,%eax
10c79d: 74 58 je 10c7f7 <aio_read+0x97> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
10c79f: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_READ;
10c7a2: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx)
return rtems_aio_enqueue (req);
10c7a9: 89 45 08 mov %eax,0x8(%ebp)
}
10c7ac: 8b 5d fc mov -0x4(%ebp),%ebx
10c7af: c9 leave
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
10c7b0: e9 9b fd ff ff jmp 10c550 <rtems_aio_enqueue>
10c7b5: 8d 76 00 lea 0x0(%esi),%esi
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10c7b8: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10c7bf: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10c7c6: e8 cd 93 00 00 call 115b98 <__errno>
10c7cb: c7 00 09 00 00 00 movl $0x9,(%eax)
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
}
10c7d1: b8 ff ff ff ff mov $0xffffffff,%eax
10c7d6: 8b 5d fc mov -0x4(%ebp),%ebx
10c7d9: c9 leave
10c7da: c3 ret
10c7db: 90 nop
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10c7dc: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10c7e3: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10c7ea: e8 a9 93 00 00 call 115b98 <__errno>
10c7ef: c7 00 16 00 00 00 movl $0x16,(%eax)
10c7f5: eb da jmp 10c7d1 <aio_read+0x71>
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10c7f7: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10c7fe: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10c805: e8 8e 93 00 00 call 115b98 <__errno> <== NOT EXECUTED
10c80a: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10c810: eb bf jmp 10c7d1 <aio_read+0x71> <== NOT EXECUTED
0010c820 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
10c820: 55 push %ebp
10c821: 89 e5 mov %esp,%ebp
10c823: 53 push %ebx
10c824: 83 ec 0c sub $0xc,%esp
10c827: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10c82a: 6a 03 push $0x3
10c82c: ff 33 pushl (%ebx)
10c82e: e8 05 60 00 00 call 112838 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10c833: 83 e0 03 and $0x3,%eax
10c836: 48 dec %eax
10c837: 83 c4 10 add $0x10,%esp
10c83a: 83 f8 01 cmp $0x1,%eax
10c83d: 77 35 ja 10c874 <aio_write+0x54>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10c83f: 8b 53 14 mov 0x14(%ebx),%edx
10c842: 85 d2 test %edx,%edx
10c844: 75 52 jne 10c898 <aio_write+0x78>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10c846: 8b 43 08 mov 0x8(%ebx),%eax
10c849: 85 c0 test %eax,%eax
10c84b: 78 4b js 10c898 <aio_write+0x78>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
10c84d: 83 ec 0c sub $0xc,%esp
10c850: 6a 18 push $0x18
10c852: e8 f1 c7 ff ff call 109048 <malloc>
if (req == NULL)
10c857: 83 c4 10 add $0x10,%esp
10c85a: 85 c0 test %eax,%eax
10c85c: 74 55 je 10c8b3 <aio_write+0x93> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
10c85e: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_WRITE;
10c861: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx)
return rtems_aio_enqueue (req);
10c868: 89 45 08 mov %eax,0x8(%ebp)
}
10c86b: 8b 5d fc mov -0x4(%ebp),%ebx
10c86e: c9 leave
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
10c86f: e9 dc fc ff ff jmp 10c550 <rtems_aio_enqueue>
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10c874: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10c87b: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10c882: e8 11 93 00 00 call 115b98 <__errno>
10c887: c7 00 09 00 00 00 movl $0x9,(%eax)
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
}
10c88d: b8 ff ff ff ff mov $0xffffffff,%eax
10c892: 8b 5d fc mov -0x4(%ebp),%ebx
10c895: c9 leave
10c896: c3 ret
10c897: 90 nop
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10c898: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10c89f: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10c8a6: e8 ed 92 00 00 call 115b98 <__errno>
10c8ab: c7 00 16 00 00 00 movl $0x16,(%eax)
10c8b1: eb da jmp 10c88d <aio_write+0x6d>
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10c8b3: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10c8ba: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10c8c1: e8 d2 92 00 00 call 115b98 <__errno> <== NOT EXECUTED
10c8c6: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10c8cc: eb bf jmp 10c88d <aio_write+0x6d> <== NOT EXECUTED
001092f0 <cfsetospeed>:
int cfsetospeed(
struct termios *tp,
speed_t speed
)
{
1092f0: 55 push %ebp
1092f1: 89 e5 mov %esp,%ebp
1092f3: 83 ec 08 sub $0x8,%esp
1092f6: 8b 4d 08 mov 0x8(%ebp),%ecx
1092f9: 8b 55 0c mov 0xc(%ebp),%edx
if ( speed & ~CBAUD )
1092fc: f7 c2 f0 ef ff ff test $0xffffeff0,%edx
109302: 75 14 jne 109318 <cfsetospeed+0x28>
rtems_set_errno_and_return_minus_one( EINVAL );
tp->c_cflag = (tp->c_cflag & ~CBAUD) | speed;
109304: 8b 41 08 mov 0x8(%ecx),%eax
109307: 25 f0 ef ff ff and $0xffffeff0,%eax
10930c: 09 d0 or %edx,%eax
10930e: 89 41 08 mov %eax,0x8(%ecx)
return 0;
109311: 31 c0 xor %eax,%eax
}
109313: c9 leave
109314: c3 ret
109315: 8d 76 00 lea 0x0(%esi),%esi
struct termios *tp,
speed_t speed
)
{
if ( speed & ~CBAUD )
rtems_set_errno_and_return_minus_one( EINVAL );
109318: e8 cb ba 00 00 call 114de8 <__errno>
10931d: c7 00 16 00 00 00 movl $0x16,(%eax)
109323: b8 ff ff ff ff mov $0xffffffff,%eax
tp->c_cflag = (tp->c_cflag & ~CBAUD) | speed;
return 0;
}
109328: c9 leave
109329: c3 ret
001106c8 <chdir>:
#include <rtems/seterr.h>
int chdir(
const char *pathname
)
{
1106c8: 55 push %ebp
1106c9: 89 e5 mov %esp,%ebp
1106cb: 57 push %edi
1106cc: 56 push %esi
1106cd: 83 ec 20 sub $0x20,%esp
1106d0: 8b 55 08 mov 0x8(%ebp),%edx
rtems_filesystem_location_info_t loc;
int result;
if ( !pathname )
1106d3: 85 d2 test %edx,%edx
1106d5: 74 75 je 11074c <chdir+0x84>
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Get the node where we wish to go.
*/
result = rtems_filesystem_evaluate_path(
1106d7: 31 c0 xor %eax,%eax
1106d9: b9 ff ff ff ff mov $0xffffffff,%ecx
1106de: 89 d7 mov %edx,%edi
1106e0: f2 ae repnz scas %es:(%edi),%al
1106e2: f7 d1 not %ecx
1106e4: 49 dec %ecx
1106e5: 83 ec 0c sub $0xc,%esp
1106e8: 6a 01 push $0x1
1106ea: 8d 75 e4 lea -0x1c(%ebp),%esi
1106ed: 56 push %esi
1106ee: 6a 01 push $0x1
1106f0: 51 push %ecx
1106f1: 52 push %edx
1106f2: e8 11 7d ff ff call 108408 <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), RTEMS_LIBIO_PERMS_SEARCH, &loc, true );
if ( result != 0 )
1106f7: 83 c4 20 add $0x20,%esp
1106fa: 85 c0 test %eax,%eax
1106fc: 74 0e je 11070c <chdir+0x44>
return -1;
1106fe: b8 ff ff ff ff mov $0xffffffff,%eax
rtems_filesystem_freenode( &rtems_filesystem_current );
rtems_filesystem_current = loc;
return 0;
}
110703: 8d 65 f8 lea -0x8(%ebp),%esp
110706: 5e pop %esi
110707: 5f pop %edi
110708: c9 leave
110709: c3 ret
11070a: 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 ) {
11070c: 83 ec 0c sub $0xc,%esp
11070f: 56 push %esi
110710: 8b 45 f0 mov -0x10(%ebp),%eax
110713: ff 50 10 call *0x10(%eax)
110716: 83 c4 10 add $0x10,%esp
110719: 48 dec %eax
11071a: 75 48 jne 110764 <chdir+0x9c>
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTDIR );
}
rtems_filesystem_freenode( &rtems_filesystem_current );
11071c: 83 ec 0c sub $0xc,%esp
11071f: a1 d0 62 12 00 mov 0x1262d0,%eax
110724: 83 c0 04 add $0x4,%eax
110727: 50 push %eax
110728: e8 b3 7d ff ff call 1084e0 <rtems_filesystem_freenode>
rtems_filesystem_current = loc;
11072d: 8b 3d d0 62 12 00 mov 0x1262d0,%edi
110733: 83 c7 04 add $0x4,%edi
110736: b9 05 00 00 00 mov $0x5,%ecx
11073b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return 0;
11073d: 83 c4 10 add $0x10,%esp
110740: 31 c0 xor %eax,%eax
}
110742: 8d 65 f8 lea -0x8(%ebp),%esp
110745: 5e pop %esi
110746: 5f pop %edi
110747: c9 leave
110748: c3 ret
110749: 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 );
11074c: e8 bb 33 00 00 call 113b0c <__errno>
110751: c7 00 0e 00 00 00 movl $0xe,(%eax)
110757: b8 ff ff ff ff mov $0xffffffff,%eax
rtems_filesystem_freenode( &rtems_filesystem_current );
rtems_filesystem_current = loc;
return 0;
}
11075c: 8d 65 f8 lea -0x8(%ebp),%esp
11075f: 5e pop %esi
110760: 5f pop %edi
110761: c9 leave
110762: c3 ret
110763: 90 nop
/*
* Verify you can change directory into this node.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_filesystem_freenode( &loc );
110764: 83 ec 0c sub $0xc,%esp
110767: 56 push %esi
110768: e8 73 7d ff ff call 1084e0 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( ENOTDIR );
11076d: e8 9a 33 00 00 call 113b0c <__errno>
110772: c7 00 14 00 00 00 movl $0x14,(%eax)
110778: 83 c4 10 add $0x10,%esp
11077b: b8 ff ff ff ff mov $0xffffffff,%eax
110780: eb 81 jmp 110703 <chdir+0x3b>
00108270 <chroot>:
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
108270: 55 push %ebp
108271: 89 e5 mov %esp,%ebp
108273: 57 push %edi
108274: 56 push %esi
108275: 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) {
108278: 81 3d d0 62 12 00 c0 cmpl $0x1285c0,0x1262d0
10827f: 85 12 00
108282: 74 60 je 1082e4 <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);
108284: 83 ec 0c sub $0xc,%esp
108287: ff 75 08 pushl 0x8(%ebp)
10828a: e8 39 84 00 00 call 1106c8 <chdir>
if (result) {
10828f: 83 c4 10 add $0x10,%esp
108292: 85 c0 test %eax,%eax
108294: 75 72 jne 108308 <chroot+0x98>
rtems_set_errno_and_return_minus_one( errno );
}
/* clone the new root location */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
108296: 83 ec 0c sub $0xc,%esp
108299: 6a 00 push $0x0
10829b: 8d 75 e4 lea -0x1c(%ebp),%esi
10829e: 56 push %esi
10829f: 6a 00 push $0x0
1082a1: 6a 01 push $0x1
1082a3: 68 d6 21 12 00 push $0x1221d6
1082a8: e8 5b 01 00 00 call 108408 <rtems_filesystem_evaluate_path>
1082ad: 83 c4 20 add $0x20,%esp
1082b0: 85 c0 test %eax,%eax
1082b2: 75 54 jne 108308 <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);
1082b4: 83 ec 0c sub $0xc,%esp
1082b7: a1 d0 62 12 00 mov 0x1262d0,%eax
1082bc: 83 c0 18 add $0x18,%eax
1082bf: 50 push %eax
1082c0: e8 1b 02 00 00 call 1084e0 <rtems_filesystem_freenode>
rtems_filesystem_root = loc;
1082c5: 8b 3d d0 62 12 00 mov 0x1262d0,%edi
1082cb: 83 c7 18 add $0x18,%edi
1082ce: b9 05 00 00 00 mov $0x5,%ecx
1082d3: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return 0;
1082d5: 83 c4 10 add $0x10,%esp
1082d8: 31 c0 xor %eax,%eax
}
1082da: 8d 65 f8 lea -0x8(%ebp),%esp
1082dd: 5e pop %esi
1082de: 5f pop %edi
1082df: c9 leave
1082e0: c3 ret
1082e1: 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*/
1082e4: e8 a7 12 00 00 call 109590 <rtems_libio_set_private_env>
if (rtems_current_user_env == &rtems_global_user_env) /* not ok */
1082e9: 81 3d d0 62 12 00 c0 cmpl $0x1285c0,0x1262d0
1082f0: 85 12 00
1082f3: 75 8f jne 108284 <chroot+0x14>
rtems_set_errno_and_return_minus_one( ENOTSUP );
1082f5: e8 12 b8 00 00 call 113b0c <__errno>
1082fa: c7 00 86 00 00 00 movl $0x86,(%eax)
108300: 83 c8 ff or $0xffffffff,%eax
108303: eb d5 jmp 1082da <chroot+0x6a>
108305: 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 );
108308: e8 ff b7 00 00 call 113b0c <__errno>
10830d: 89 c6 mov %eax,%esi
10830f: e8 f8 b7 00 00 call 113b0c <__errno>
108314: 8b 00 mov (%eax),%eax
108316: 89 06 mov %eax,(%esi)
108318: b8 ff ff ff ff mov $0xffffffff,%eax
10831d: eb bb jmp 1082da <chroot+0x6a>
0010b454 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
10b454: 55 push %ebp
10b455: 89 e5 mov %esp,%ebp
10b457: 83 ec 08 sub $0x8,%esp
10b45a: 8b 45 08 mov 0x8(%ebp),%eax
10b45d: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
10b460: 85 d2 test %edx,%edx
10b462: 74 14 je 10b478 <clock_gettime+0x24>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
10b464: 83 f8 01 cmp $0x1,%eax
10b467: 74 47 je 10b4b0 <clock_gettime+0x5c>
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
10b469: 83 f8 04 cmp $0x4,%eax
10b46c: 74 32 je 10b4a0 <clock_gettime+0x4c> <== NEVER TAKEN
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
10b46e: 83 f8 02 cmp $0x2,%eax
10b471: 74 2d je 10b4a0 <clock_gettime+0x4c>
return 0;
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
10b473: 83 f8 03 cmp $0x3,%eax
10b476: 74 14 je 10b48c <clock_gettime+0x38>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
10b478: e8 ef 8d 00 00 call 11426c <__errno>
10b47d: c7 00 16 00 00 00 movl $0x16,(%eax)
10b483: b8 ff ff ff ff mov $0xffffffff,%eax
return 0;
}
10b488: c9 leave
10b489: c3 ret
10b48a: 66 90 xchg %ax,%ax
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
rtems_set_errno_and_return_minus_one( ENOSYS );
10b48c: e8 db 8d 00 00 call 11426c <__errno>
10b491: c7 00 58 00 00 00 movl $0x58,(%eax)
10b497: b8 ff ff ff ff mov $0xffffffff,%eax
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
10b49c: c9 leave
10b49d: c3 ret
10b49e: 66 90 xchg %ax,%ax
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
_TOD_Get_uptime_as_timespec( tp );
10b4a0: 83 ec 0c sub $0xc,%esp
10b4a3: 52 push %edx
10b4a4: e8 97 1e 00 00 call 10d340 <_TOD_Get_uptime_as_timespec>
return 0;
10b4a9: 83 c4 10 add $0x10,%esp
10b4ac: 31 c0 xor %eax,%eax
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
10b4ae: c9 leave
10b4af: c3 ret
{
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
_TOD_Get(tp);
10b4b0: 83 ec 0c sub $0xc,%esp
10b4b3: 52 push %edx
10b4b4: e8 33 1e 00 00 call 10d2ec <_TOD_Get>
return 0;
10b4b9: 83 c4 10 add $0x10,%esp
10b4bc: 31 c0 xor %eax,%eax
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
10b4be: c9 leave
10b4bf: c3 ret
0010b4c0 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
10b4c0: 55 push %ebp
10b4c1: 89 e5 mov %esp,%ebp
10b4c3: 83 ec 08 sub $0x8,%esp
10b4c6: 8b 45 08 mov 0x8(%ebp),%eax
10b4c9: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
10b4cc: 85 d2 test %edx,%edx
10b4ce: 74 0f je 10b4df <clock_settime+0x1f> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
10b4d0: 83 f8 01 cmp $0x1,%eax
10b4d3: 74 1f je 10b4f4 <clock_settime+0x34>
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
10b4d5: 83 f8 02 cmp $0x2,%eax
10b4d8: 74 42 je 10b51c <clock_settime+0x5c>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
10b4da: 83 f8 03 cmp $0x3,%eax
10b4dd: 74 3d je 10b51c <clock_settime+0x5c>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
10b4df: e8 88 8d 00 00 call 11426c <__errno>
10b4e4: c7 00 16 00 00 00 movl $0x16,(%eax)
10b4ea: b8 ff ff ff ff mov $0xffffffff,%eax
return 0;
}
10b4ef: c9 leave
10b4f0: c3 ret
10b4f1: 8d 76 00 lea 0x0(%esi),%esi
{
if ( !tp )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
10b4f4: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx)
10b4fa: 76 e3 jbe 10b4df <clock_settime+0x1f>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b4fc: a1 b0 9d 12 00 mov 0x129db0,%eax
10b501: 40 inc %eax
10b502: a3 b0 9d 12 00 mov %eax,0x129db0
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
10b507: 83 ec 0c sub $0xc,%esp
10b50a: 52 push %edx
10b50b: e8 88 1e 00 00 call 10d398 <_TOD_Set>
_Thread_Enable_dispatch();
10b510: e8 8b 33 00 00 call 10e8a0 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
10b515: 83 c4 10 add $0x10,%esp
10b518: 31 c0 xor %eax,%eax
}
10b51a: c9 leave
10b51b: c3 ret
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
rtems_set_errno_and_return_minus_one( ENOSYS );
10b51c: e8 4b 8d 00 00 call 11426c <__errno>
10b521: c7 00 58 00 00 00 movl $0x58,(%eax)
10b527: b8 ff ff ff ff mov $0xffffffff,%eax
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
}
10b52c: c9 leave
10b52d: c3 ret
0010fc3c <close>:
#include <rtems/libio_.h>
int close(
int fd
)
{
10fc3c: 55 push %ebp
10fc3d: 89 e5 mov %esp,%ebp
10fc3f: 53 push %ebx
10fc40: 83 ec 14 sub $0x14,%esp
10fc43: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_t *iop;
rtems_status_code rc;
rtems_libio_check_fd(fd);
10fc46: 3b 05 6c 39 12 00 cmp 0x12396c,%eax
10fc4c: 73 46 jae 10fc94 <close+0x58>
iop = rtems_libio_iop(fd);
10fc4e: c1 e0 03 shl $0x3,%eax
10fc51: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx
10fc58: 29 c3 sub %eax,%ebx
10fc5a: 03 1d 20 7c 12 00 add 0x127c20,%ebx
rtems_libio_check_is_open(iop);
10fc60: f6 43 15 01 testb $0x1,0x15(%ebx)
10fc64: 74 2e je 10fc94 <close+0x58>
rc = RTEMS_SUCCESSFUL;
rc = (*iop->pathinfo.handlers->close_h)( iop );
10fc66: 83 ec 0c sub $0xc,%esp
10fc69: 8b 43 20 mov 0x20(%ebx),%eax
10fc6c: 53 push %ebx
10fc6d: ff 50 04 call *0x4(%eax)
rtems_filesystem_freenode( &iop->pathinfo );
10fc70: 8d 53 18 lea 0x18(%ebx),%edx
10fc73: 89 14 24 mov %edx,(%esp)
10fc76: 89 45 f4 mov %eax,-0xc(%ebp)
10fc79: e8 22 84 ff ff call 1080a0 <rtems_filesystem_freenode>
rtems_libio_free( iop );
10fc7e: 89 1c 24 mov %ebx,(%esp)
10fc81: e8 26 02 00 00 call 10feac <rtems_libio_free>
return rc;
10fc86: 83 c4 10 add $0x10,%esp
10fc89: 8b 45 f4 mov -0xc(%ebp),%eax
}
10fc8c: 8b 5d fc mov -0x4(%ebp),%ebx
10fc8f: c9 leave
10fc90: c3 ret
10fc91: 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);
10fc94: e8 d7 35 00 00 call 113270 <__errno>
10fc99: c7 00 09 00 00 00 movl $0x9,(%eax)
10fc9f: b8 ff ff ff ff mov $0xffffffff,%eax
10fca4: eb e6 jmp 10fc8c <close+0x50>
0010820c <ctermid>:
static char *ctermid_name = "/dev/console";
char *ctermid(
char *s
)
{
10820c: 55 push %ebp
10820d: 89 e5 mov %esp,%ebp
10820f: 57 push %edi
108210: 56 push %esi
108211: 8b 45 08 mov 0x8(%ebp),%eax
if ( !s )
108214: 85 c0 test %eax,%eax
108216: 74 14 je 10822c <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 );
108218: be 03 df 11 00 mov $0x11df03,%esi
10821d: b9 0d 00 00 00 mov $0xd,%ecx
108222: 89 c7 mov %eax,%edi
108224: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
return s;
}
108226: 5e pop %esi
108227: 5f pop %edi
108228: c9 leave
108229: c3 ret
10822a: 66 90 xchg %ax,%ax
char *ctermid(
char *s
)
{
if ( !s )
return ctermid_name;
10822c: b8 03 df 11 00 mov $0x11df03,%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;
}
108231: 5e pop %esi
108232: 5f pop %edi
108233: c9 leave
108234: c3 ret
0010ee88 <devFS_evaluate_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
10ee88: 55 push %ebp
10ee89: 89 e5 mov %esp,%ebp
10ee8b: 57 push %edi
10ee8c: 56 push %esi
10ee8d: 53 push %ebx
10ee8e: 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 ) )
10ee91: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp)
10ee98: 0f 85 96 00 00 00 jne 10ef34 <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;
10ee9e: 8b 45 14 mov 0x14(%ebp),%eax
10eea1: 8b 00 mov (%eax),%eax
10eea3: 89 45 e4 mov %eax,-0x1c(%ebp)
if (!device_name_table)
10eea6: 85 c0 test %eax,%eax
10eea8: 0f 84 98 00 00 00 je 10ef46 <devFS_evaluate_path+0xbe>
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
10eeae: 8b 15 10 15 12 00 mov 0x121510,%edx
10eeb4: 89 55 e0 mov %edx,-0x20(%ebp)
10eeb7: 85 d2 test %edx,%edx
10eeb9: 74 38 je 10eef3 <devFS_evaluate_path+0x6b><== NEVER TAKEN
10eebb: 31 c0 xor %eax,%eax
10eebd: 31 db xor %ebx,%ebx
if (!device_name_table[i].device_name)
10eebf: 8d 04 80 lea (%eax,%eax,4),%eax
10eec2: 8b 55 e4 mov -0x1c(%ebp),%edx
10eec5: 8d 3c 82 lea (%edx,%eax,4),%edi
10eec8: 8b 37 mov (%edi),%esi
10eeca: 85 f6 test %esi,%esi
10eecc: 74 1d je 10eeeb <devFS_evaluate_path+0x63>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
10eece: 50 push %eax
10eecf: ff 75 0c pushl 0xc(%ebp)
10eed2: 56 push %esi
10eed3: ff 75 08 pushl 0x8(%ebp)
10eed6: e8 99 31 00 00 call 112074 <strncmp>
10eedb: 83 c4 10 add $0x10,%esp
10eede: 85 c0 test %eax,%eax
10eee0: 75 09 jne 10eeeb <devFS_evaluate_path+0x63>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
10eee2: 8b 45 0c mov 0xc(%ebp),%eax
10eee5: 80 3c 06 00 cmpb $0x0,(%esi,%eax,1)
10eee9: 74 21 je 10ef0c <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++) {
10eeeb: 43 inc %ebx
10eeec: 89 d8 mov %ebx,%eax
10eeee: 39 5d e0 cmp %ebx,-0x20(%ebp)
10eef1: 77 cc ja 10eebf <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 );
10eef3: e8 4c 25 00 00 call 111444 <__errno>
10eef8: c7 00 02 00 00 00 movl $0x2,(%eax)
10eefe: b8 ff ff ff ff mov $0xffffffff,%eax
}
10ef03: 8d 65 f4 lea -0xc(%ebp),%esp
10ef06: 5b pop %ebx
10ef07: 5e pop %esi
10ef08: 5f pop %edi
10ef09: c9 leave
10ef0a: c3 ret
10ef0b: 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];
10ef0c: 8b 55 14 mov 0x14(%ebp),%edx
10ef0f: 89 3a mov %edi,(%edx)
pathloc->handlers = &devFS_file_handlers;
10ef11: c7 42 08 80 34 12 00 movl $0x123480,0x8(%edx)
pathloc->ops = &devFS_ops;
10ef18: c7 42 0c 20 34 12 00 movl $0x123420,0xc(%edx)
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
10ef1f: a1 f0 35 12 00 mov 0x1235f0,%eax
10ef24: 8b 40 28 mov 0x28(%eax),%eax
10ef27: 89 42 10 mov %eax,0x10(%edx)
return 0;
10ef2a: 31 c0 xor %eax,%eax
}
/* no such file or directory */
rtems_set_errno_and_return_minus_one( ENOENT );
}
10ef2c: 8d 65 f4 lea -0xc(%ebp),%esp
10ef2f: 5b pop %ebx
10ef30: 5e pop %esi
10ef31: 5f pop %edi
10ef32: c9 leave
10ef33: 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 );
10ef34: e8 0b 25 00 00 call 111444 <__errno> <== NOT EXECUTED
10ef39: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
10ef3f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10ef44: eb e6 jmp 10ef2c <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 );
10ef46: e8 f9 24 00 00 call 111444 <__errno>
10ef4b: c7 00 0e 00 00 00 movl $0xe,(%eax)
10ef51: 83 c8 ff or $0xffffffff,%eax
10ef54: eb d6 jmp 10ef2c <devFS_evaluate_path+0xa4>
00107ae0 <devFS_ioctl>:
int devFS_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
107ae0: 55 push %ebp
107ae1: 89 e5 mov %esp,%ebp
107ae3: 83 ec 1c sub $0x1c,%esp
107ae6: 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;
107ae9: 8b 42 18 mov 0x18(%edx),%eax
args.iop = iop;
107aec: 89 55 e8 mov %edx,-0x18(%ebp)
args.command = command;
107aef: 8b 55 0c mov 0xc(%ebp),%edx
107af2: 89 55 ec mov %edx,-0x14(%ebp)
args.buffer = buffer;
107af5: 8b 55 10 mov 0x10(%ebp),%edx
107af8: 89 55 f0 mov %edx,-0x10(%ebp)
status = rtems_io_control(
np->major,
np->minor,
(void *) &args
107afb: 8d 55 e8 lea -0x18(%ebp),%edx
args.iop = iop;
args.command = command;
args.buffer = buffer;
status = rtems_io_control(
107afe: 52 push %edx
107aff: ff 70 0c pushl 0xc(%eax)
107b02: ff 70 08 pushl 0x8(%eax)
107b05: e8 16 40 00 00 call 10bb20 <rtems_io_control>
np->major,
np->minor,
(void *) &args
);
if ( status )
107b0a: 83 c4 10 add $0x10,%esp
107b0d: 85 c0 test %eax,%eax
107b0f: 75 07 jne 107b18 <devFS_ioctl+0x38>
return rtems_deviceio_errno(status);
return args.ioctl_return;
107b11: 8b 45 f4 mov -0xc(%ebp),%eax
}
107b14: c9 leave
107b15: c3 ret
107b16: 66 90 xchg %ax,%ax
np->minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
107b18: 83 ec 0c sub $0xc,%esp
107b1b: 50 push %eax
107b1c: e8 47 74 00 00 call 10ef68 <rtems_deviceio_errno>
107b21: 83 c4 10 add $0x10,%esp
return args.ioctl_return;
}
107b24: c9 leave
107b25: c3 ret
00107924 <devFS_mknod>:
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
107924: 55 push %ebp
107925: 89 e5 mov %esp,%ebp
107927: 57 push %edi
107928: 56 push %esi
107929: 53 push %ebx
10792a: 83 ec 1c sub $0x1c,%esp
10792d: 8b 7d 08 mov 0x8(%ebp),%edi
107930: 8b 4d 10 mov 0x10(%ebp),%ecx
107933: 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') &&
107936: 80 3f 64 cmpb $0x64,(%edi)
107939: 0f 84 dd 00 00 00 je 107a1c <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))
10793f: 8b 45 0c mov 0xc(%ebp),%eax
107942: 25 00 f0 00 00 and $0xf000,%eax
107947: 3d 00 60 00 00 cmp $0x6000,%eax
10794c: 74 0b je 107959 <devFS_mknod+0x35>
10794e: 3d 00 20 00 00 cmp $0x2000,%eax
107953: 0f 85 e5 00 00 00 jne 107a3e <devFS_mknod+0x11a>
)
{
union __rtems_dev_t temp;
temp.device = device;
return temp.__overlay.major;
107959: 89 4d dc mov %ecx,-0x24(%ebp)
dev_t device
)
{
union __rtems_dev_t temp;
temp.device = device;
10795c: 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;
10795f: 8b 45 18 mov 0x18(%ebp),%eax
107962: 8b 30 mov (%eax),%esi
if (!device_name_table)
107964: 85 f6 test %esi,%esi
107966: 0f 84 f4 00 00 00 je 107a60 <devFS_mknod+0x13c>
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
10796c: 8b 15 10 15 12 00 mov 0x121510,%edx
107972: 85 d2 test %edx,%edx
107974: 0f 84 d6 00 00 00 je 107a50 <devFS_mknod+0x12c>
10797a: 31 c0 xor %eax,%eax
10797c: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp)
107983: 31 db xor %ebx,%ebx
107985: 89 7d e4 mov %edi,-0x1c(%ebp)
107988: 89 d7 mov %edx,%edi
10798a: eb 1a jmp 1079a6 <devFS_mknod+0x82>
if (device_name_table[i].device_name == NULL)
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
10798c: 83 ec 08 sub $0x8,%esp
10798f: 50 push %eax
107990: ff 75 e4 pushl -0x1c(%ebp)
107993: e8 84 a6 00 00 call 11201c <strcmp>
107998: 83 c4 10 add $0x10,%esp
10799b: 85 c0 test %eax,%eax
10799d: 74 65 je 107a04 <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++){
10799f: 43 inc %ebx
1079a0: 89 d8 mov %ebx,%eax
1079a2: 39 fb cmp %edi,%ebx
1079a4: 73 16 jae 1079bc <devFS_mknod+0x98>
if (device_name_table[i].device_name == NULL)
1079a6: 8d 04 80 lea (%eax,%eax,4),%eax
1079a9: 8b 04 86 mov (%esi,%eax,4),%eax
1079ac: 85 c0 test %eax,%eax
1079ae: 75 dc jne 10798c <devFS_mknod+0x68>
1079b0: 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++){
1079b3: 43 inc %ebx
1079b4: 89 d8 mov %ebx,%eax
1079b6: 39 fb cmp %edi,%ebx
1079b8: 72 ec jb 1079a6 <devFS_mknod+0x82>
1079ba: 66 90 xchg %ax,%ax
1079bc: 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)
1079bf: 83 7d e0 ff cmpl $0xffffffff,-0x20(%ebp)
1079c3: 0f 84 87 00 00 00 je 107a50 <devFS_mknod+0x12c> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOMEM );
_ISR_Disable(level);
1079c9: 9c pushf
1079ca: fa cli
1079cb: 5b pop %ebx
device_name_table[slot].device_name = (char *)path;
1079cc: 8b 55 e0 mov -0x20(%ebp),%edx
1079cf: 8d 04 92 lea (%edx,%edx,4),%eax
1079d2: 8d 14 86 lea (%esi,%eax,4),%edx
1079d5: 89 3a mov %edi,(%edx)
device_name_table[slot].device_name_length = strlen(path);
1079d7: 31 c0 xor %eax,%eax
1079d9: b9 ff ff ff ff mov $0xffffffff,%ecx
1079de: f2 ae repnz scas %es:(%edi),%al
1079e0: f7 d1 not %ecx
1079e2: 49 dec %ecx
1079e3: 89 4a 04 mov %ecx,0x4(%edx)
device_name_table[slot].major = major;
1079e6: 8b 45 dc mov -0x24(%ebp),%eax
1079e9: 89 42 08 mov %eax,0x8(%edx)
device_name_table[slot].minor = minor;
1079ec: 8b 45 d8 mov -0x28(%ebp),%eax
1079ef: 89 42 0c mov %eax,0xc(%edx)
device_name_table[slot].mode = mode;
1079f2: 8b 45 0c mov 0xc(%ebp),%eax
1079f5: 89 42 10 mov %eax,0x10(%edx)
_ISR_Enable(level);
1079f8: 53 push %ebx
1079f9: 9d popf
return 0;
1079fa: 31 c0 xor %eax,%eax
}
1079fc: 8d 65 f4 lea -0xc(%ebp),%esp
1079ff: 5b pop %ebx
107a00: 5e pop %esi
107a01: 5f pop %edi
107a02: c9 leave
107a03: 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 );
107a04: e8 3b 9a 00 00 call 111444 <__errno>
107a09: c7 00 11 00 00 00 movl $0x11,(%eax)
107a0f: 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;
}
107a14: 8d 65 f4 lea -0xc(%ebp),%esp
107a17: 5b pop %ebx
107a18: 5e pop %esi
107a19: 5f pop %edi
107a1a: c9 leave
107a1b: 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') &&
107a1c: 80 7f 01 65 cmpb $0x65,0x1(%edi)
107a20: 0f 85 19 ff ff ff jne 10793f <devFS_mknod+0x1b> <== NEVER TAKEN
107a26: 80 7f 02 76 cmpb $0x76,0x2(%edi)
107a2a: 0f 85 0f ff ff ff jne 10793f <devFS_mknod+0x1b> <== NEVER TAKEN
(path[2] == 'v') && (path[3] == '\0'))
107a30: 80 7f 03 00 cmpb $0x0,0x3(%edi)
107a34: 0f 85 05 ff ff ff jne 10793f <devFS_mknod+0x1b>
return 0;
107a3a: 31 c0 xor %eax,%eax
107a3c: eb be jmp 1079fc <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 );
107a3e: e8 01 9a 00 00 call 111444 <__errno>
107a43: c7 00 16 00 00 00 movl $0x16,(%eax)
107a49: b8 ff ff ff ff mov $0xffffffff,%eax
107a4e: eb ac jmp 1079fc <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 );
107a50: e8 ef 99 00 00 call 111444 <__errno>
107a55: c7 00 0c 00 00 00 movl $0xc,(%eax)
107a5b: 83 c8 ff or $0xffffffff,%eax
107a5e: eb 9c jmp 1079fc <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 );
107a60: e8 df 99 00 00 call 111444 <__errno>
107a65: c7 00 0e 00 00 00 movl $0xe,(%eax)
107a6b: 83 c8 ff or $0xffffffff,%eax
107a6e: eb 8c jmp 1079fc <devFS_mknod+0xd8>
00112670 <device_ioctl>:
int device_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
112670: 55 push %ebp
112671: 89 e5 mov %esp,%ebp
112673: 83 ec 1c sub $0x1c,%esp
112676: 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;
112679: 89 45 e8 mov %eax,-0x18(%ebp)
args.command = command;
11267c: 8b 55 0c mov 0xc(%ebp),%edx
11267f: 89 55 ec mov %edx,-0x14(%ebp)
args.buffer = buffer;
112682: 8b 55 10 mov 0x10(%ebp),%edx
112685: 89 55 f0 mov %edx,-0x10(%ebp)
the_jnode = iop->pathinfo.node_access;
112688: 8b 40 18 mov 0x18(%eax),%eax
status = rtems_io_control(
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
11268b: 8d 55 e8 lea -0x18(%ebp),%edx
args.command = command;
args.buffer = buffer;
the_jnode = iop->pathinfo.node_access;
status = rtems_io_control(
11268e: 52 push %edx
11268f: ff 70 54 pushl 0x54(%eax)
112692: ff 70 50 pushl 0x50(%eax)
112695: e8 fa 08 00 00 call 112f94 <rtems_io_control>
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
11269a: 83 c4 10 add $0x10,%esp
11269d: 85 c0 test %eax,%eax
11269f: 75 07 jne 1126a8 <device_ioctl+0x38>
return rtems_deviceio_errno(status);
return args.ioctl_return;
1126a1: 8b 45 f4 mov -0xc(%ebp),%eax
}
1126a4: c9 leave
1126a5: c3 ret
1126a6: 66 90 xchg %ax,%ax
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
1126a8: 83 ec 0c sub $0xc,%esp
1126ab: 50 push %eax
1126ac: e8 33 0b 00 00 call 1131e4 <rtems_deviceio_errno>
1126b1: 83 c4 10 add $0x10,%esp
return args.ioctl_return;
}
1126b4: c9 leave
1126b5: c3 ret
00108fa4 <drainOutput>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
108fa4: 55 push %ebp
108fa5: 89 e5 mov %esp,%ebp
108fa7: 53 push %ebx
108fa8: 83 ec 04 sub $0x4,%esp
108fab: 89 c3 mov %eax,%ebx
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
108fad: 8b 90 b4 00 00 00 mov 0xb4(%eax),%edx
108fb3: 85 d2 test %edx,%edx
108fb5: 74 4d je 109004 <drainOutput+0x60>
rtems_interrupt_disable (level);
108fb7: 9c pushf
108fb8: fa cli
108fb9: 58 pop %eax
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
108fba: 8b 8b 84 00 00 00 mov 0x84(%ebx),%ecx
108fc0: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx
108fc6: 39 d1 cmp %edx,%ecx
108fc8: 74 38 je 109002 <drainOutput+0x5e>
108fca: 66 90 xchg %ax,%ax
tty->rawOutBufState = rob_wait;
108fcc: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx)
108fd3: 00 00 00
rtems_interrupt_enable (level);
108fd6: 50 push %eax
108fd7: 9d popf
sc = rtems_semaphore_obtain(
108fd8: 50 push %eax
108fd9: 6a 00 push $0x0
108fdb: 6a 00 push $0x0
108fdd: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
108fe3: e8 c8 26 00 00 call 10b6b0 <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
108fe8: 83 c4 10 add $0x10,%esp
108feb: 85 c0 test %eax,%eax
108fed: 75 1a jne 109009 <drainOutput+0x65> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
108fef: 9c pushf
108ff0: fa cli
108ff1: 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) {
108ff2: 8b 8b 84 00 00 00 mov 0x84(%ebx),%ecx
108ff8: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx
108ffe: 39 d1 cmp %edx,%ecx
109000: 75 ca jne 108fcc <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);
109002: 50 push %eax
109003: 9d popf
}
}
109004: 8b 5d fc mov -0x4(%ebp),%ebx
109007: c9 leave
109008: 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);
109009: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10900c: 50 push %eax <== NOT EXECUTED
10900d: e8 e2 2c 00 00 call 10bcf4 <rtems_fatal_error_occurred><== NOT EXECUTED
00109d3c <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
109d3c: 55 push %ebp
109d3d: 89 e5 mov %esp,%ebp
109d3f: 53 push %ebx
109d40: 83 ec 24 sub $0x24,%esp
if ((tty->termios.c_lflag & ECHOCTL) &&
109d43: f6 42 3d 02 testb $0x2,0x3d(%edx)
109d47: 74 1b je 109d64 <echo+0x28> <== NEVER TAKEN
iscntrl(c) && (c != '\t') && (c != '\n')) {
109d49: 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) &&
109d4c: 8b 1d 94 5a 12 00 mov 0x125a94,%ebx
109d52: f6 44 0b 01 20 testb $0x20,0x1(%ebx,%ecx,1)
109d57: 74 0b je 109d64 <echo+0x28>
iscntrl(c) && (c != '\t') && (c != '\n')) {
109d59: 3c 09 cmp $0x9,%al
109d5b: 74 07 je 109d64 <echo+0x28>
109d5d: 3c 0a cmp $0xa,%al
109d5f: 75 13 jne 109d74 <echo+0x38>
109d61: 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);
109d64: 0f b6 c0 movzbl %al,%eax
109d67: e8 94 fe ff ff call 109c00 <oproc>
}
}
109d6c: 8b 5d fc mov -0x4(%ebp),%ebx
109d6f: c9 leave
109d70: c3 ret
109d71: 8d 76 00 lea 0x0(%esi),%esi
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
109d74: c6 45 f6 5e movb $0x5e,-0xa(%ebp)
echobuf[1] = c ^ 0x40;
109d78: 83 f0 40 xor $0x40,%eax
109d7b: 88 45 f7 mov %al,-0x9(%ebp)
rtems_termios_puts (echobuf, 2, tty);
109d7e: 53 push %ebx
109d7f: 52 push %edx
109d80: 6a 02 push $0x2
109d82: 8d 45 f6 lea -0xa(%ebp),%eax
109d85: 50 push %eax
109d86: 89 55 e4 mov %edx,-0x1c(%ebp)
109d89: e8 3e fd ff ff call 109acc <rtems_termios_puts>
tty->column += 2;
109d8e: 8b 55 e4 mov -0x1c(%ebp),%edx
109d91: 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')) {
109d95: 83 c4 10 add $0x10,%esp
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
} else {
oproc (c, tty);
}
}
109d98: 8b 5d fc mov -0x4(%ebp),%ebx
109d9b: c9 leave
109d9c: c3 ret
00108f64 <endgrent>:
void endgrent(void)
{
108f64: 55 push %ebp
108f65: 89 e5 mov %esp,%ebp
108f67: 83 ec 08 sub $0x8,%esp
if (group_fp != NULL)
108f6a: a1 00 93 12 00 mov 0x129300,%eax
108f6f: 85 c0 test %eax,%eax
108f71: 74 0c je 108f7f <endgrent+0x1b> <== NEVER TAKEN
fclose(group_fp);
108f73: 83 ec 0c sub $0xc,%esp
108f76: 50 push %eax
108f77: e8 ac b2 00 00 call 114228 <fclose>
108f7c: 83 c4 10 add $0x10,%esp
}
108f7f: c9 leave
108f80: c3 ret
00108e0c <endpwent>:
void endpwent(void)
{
108e0c: 55 push %ebp
108e0d: 89 e5 mov %esp,%ebp
108e0f: 83 ec 08 sub $0x8,%esp
if (passwd_fp != NULL)
108e12: a1 e8 93 12 00 mov 0x1293e8,%eax
108e17: 85 c0 test %eax,%eax
108e19: 74 0c je 108e27 <endpwent+0x1b> <== NEVER TAKEN
fclose(passwd_fp);
108e1b: 83 ec 0c sub $0xc,%esp
108e1e: 50 push %eax
108e1f: e8 04 b4 00 00 call 114228 <fclose>
108e24: 83 c4 10 add $0x10,%esp
}
108e27: c9 leave
108e28: c3 ret
00109da0 <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)
{
109da0: 55 push %ebp
109da1: 89 e5 mov %esp,%ebp
109da3: 57 push %edi
109da4: 56 push %esi
109da5: 53 push %ebx
109da6: 83 ec 1c sub $0x1c,%esp
109da9: 89 c3 mov %eax,%ebx
109dab: 89 d7 mov %edx,%edi
if (tty->ccount == 0)
109dad: 8b 48 20 mov 0x20(%eax),%ecx
109db0: 85 c9 test %ecx,%ecx
109db2: 0f 84 84 00 00 00 je 109e3c <erase+0x9c>
return;
if (lineFlag) {
109db8: 85 d2 test %edx,%edx
109dba: 0f 85 84 00 00 00 jne 109e44 <erase+0xa4>
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
109dc0: 8b 50 3c mov 0x3c(%eax),%edx
109dc3: 89 7d e4 mov %edi,-0x1c(%ebp)
109dc6: eb 1d jmp 109de5 <erase+0x45>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
109dc8: 80 e6 02 and $0x2,%dh <== NOT EXECUTED
109dcb: 0f 85 37 01 00 00 jne 109f08 <erase+0x168> <== NOT EXECUTED
109dd1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
109dd4: 8b 75 e4 mov -0x1c(%ebp),%esi
109dd7: 85 f6 test %esi,%esi
109dd9: 74 61 je 109e3c <erase+0x9c> <== NEVER TAKEN
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
109ddb: 8b 4b 20 mov 0x20(%ebx),%ecx
109dde: 85 c9 test %ecx,%ecx
109de0: 74 5a je 109e3c <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);
109de2: 8b 53 3c mov 0x3c(%ebx),%edx
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
109de5: 8b 7b 1c mov 0x1c(%ebx),%edi
109de8: 49 dec %ecx
109de9: 89 4b 20 mov %ecx,0x20(%ebx)
109dec: 8a 04 0f mov (%edi,%ecx,1),%al
if (tty->termios.c_lflag & ECHO) {
109def: f6 c2 08 test $0x8,%dl
109df2: 74 e0 je 109dd4 <erase+0x34> <== NEVER TAKEN
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
109df4: 8b 75 e4 mov -0x1c(%ebp),%esi
109df7: 85 f6 test %esi,%esi
109df9: 75 09 jne 109e04 <erase+0x64>
109dfb: f6 c2 10 test $0x10,%dl
109dfe: 0f 84 f0 00 00 00 je 109ef4 <erase+0x154> <== NEVER TAKEN
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
109e04: 3c 09 cmp $0x9,%al
109e06: 74 58 je 109e60 <erase+0xc0>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
109e08: 0f b6 c0 movzbl %al,%eax
109e0b: 8d 70 01 lea 0x1(%eax),%esi
109e0e: a1 94 5a 12 00 mov 0x125a94,%eax
109e13: f6 04 30 20 testb $0x20,(%eax,%esi,1)
109e17: 75 af jne 109dc8 <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);
109e19: 57 push %edi
109e1a: 53 push %ebx
109e1b: 6a 03 push $0x3
109e1d: 68 06 14 12 00 push $0x121406
109e22: e8 a5 fc ff ff call 109acc <rtems_termios_puts>
if (tty->column)
109e27: 8b 43 28 mov 0x28(%ebx),%eax
109e2a: 83 c4 10 add $0x10,%esp
109e2d: 85 c0 test %eax,%eax
109e2f: 74 a3 je 109dd4 <erase+0x34> <== NEVER TAKEN
tty->column--;
109e31: 48 dec %eax
109e32: 89 43 28 mov %eax,0x28(%ebx)
}
}
}
if (!lineFlag)
109e35: 8b 75 e4 mov -0x1c(%ebp),%esi
109e38: 85 f6 test %esi,%esi
109e3a: 75 9f jne 109ddb <erase+0x3b>
break;
}
}
109e3c: 8d 65 f4 lea -0xc(%ebp),%esp
109e3f: 5b pop %ebx
109e40: 5e pop %esi
109e41: 5f pop %edi
109e42: c9 leave
109e43: c3 ret
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
109e44: 8b 50 3c mov 0x3c(%eax),%edx
109e47: f6 c2 08 test $0x8,%dl
109e4a: 0f 84 94 00 00 00 je 109ee4 <erase+0x144> <== NEVER TAKEN
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
109e50: f6 c2 10 test $0x10,%dl
109e53: 0f 84 eb 00 00 00 je 109f44 <erase+0x1a4> <== NEVER TAKEN
109e59: 89 7d e4 mov %edi,-0x1c(%ebp)
109e5c: eb 87 jmp 109de5 <erase+0x45>
109e5e: 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;
109e60: 8b 73 2c mov 0x2c(%ebx),%esi
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
109e63: 85 c9 test %ecx,%ecx
109e65: 74 46 je 109ead <erase+0x10d>
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
109e67: a1 94 5a 12 00 mov 0x125a94,%eax
109e6c: 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;
109e6f: 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)
109e71: 81 e2 00 02 00 00 and $0x200,%edx
109e77: 89 55 e0 mov %edx,-0x20(%ebp)
109e7a: 89 5d d8 mov %ebx,-0x28(%ebp)
109e7d: 8b 5d dc mov -0x24(%ebp),%ebx
109e80: eb 10 jmp 109e92 <erase+0xf2>
109e82: 66 90 xchg %ax,%ax
109e84: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED
109e87: 85 d2 test %edx,%edx <== NOT EXECUTED
109e89: 74 03 je 109e8e <erase+0xee> <== NOT EXECUTED
col += 2;
109e8b: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
109e8e: 39 c1 cmp %eax,%ecx
109e90: 74 18 je 109eaa <erase+0x10a> <== NEVER TAKEN
c = tty->cbuf[i++];
109e92: 8a 14 07 mov (%edi,%eax,1),%dl
109e95: 40 inc %eax
if (c == '\t') {
109e96: 80 fa 09 cmp $0x9,%dl
109e99: 74 41 je 109edc <erase+0x13c>
col = (col | 7) + 1;
} else if (iscntrl (c)) {
109e9b: 0f b6 d2 movzbl %dl,%edx
109e9e: f6 44 13 01 20 testb $0x20,0x1(%ebx,%edx,1)
109ea3: 75 df jne 109e84 <erase+0xe4> <== NEVER TAKEN
if (tty->termios.c_lflag & ECHOCTL)
col += 2;
} else {
col++;
109ea5: 46 inc %esi
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
109ea6: 39 c1 cmp %eax,%ecx
109ea8: 75 e8 jne 109e92 <erase+0xf2>
109eaa: 8b 5d d8 mov -0x28(%ebp),%ebx
}
/*
* Back up over the tab
*/
while (tty->column > col) {
109ead: 3b 73 28 cmp 0x28(%ebx),%esi
109eb0: 0f 8d 1e ff ff ff jge 109dd4 <erase+0x34> <== NEVER TAKEN
109eb6: 66 90 xchg %ax,%ax
rtems_termios_puts ("\b", 1, tty);
109eb8: 52 push %edx
109eb9: 53 push %ebx
109eba: 6a 01 push $0x1
109ebc: 68 08 14 12 00 push $0x121408
109ec1: e8 06 fc ff ff call 109acc <rtems_termios_puts>
tty->column--;
109ec6: 8b 43 28 mov 0x28(%ebx),%eax
109ec9: 48 dec %eax
109eca: 89 43 28 mov %eax,0x28(%ebx)
}
/*
* Back up over the tab
*/
while (tty->column > col) {
109ecd: 83 c4 10 add $0x10,%esp
109ed0: 39 f0 cmp %esi,%eax
109ed2: 7f e4 jg 109eb8 <erase+0x118>
109ed4: e9 fb fe ff ff jmp 109dd4 <erase+0x34>
109ed9: 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;
109edc: 83 ce 07 or $0x7,%esi
109edf: 46 inc %esi
109ee0: eb ac jmp 109e8e <erase+0xee>
109ee2: 66 90 xchg %ax,%ax
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
tty->ccount = 0;
109ee4: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
109eeb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
109eee: 5b pop %ebx <== NOT EXECUTED
109eef: 5e pop %esi <== NOT EXECUTED
109ef0: 5f pop %edi <== NOT EXECUTED
109ef1: c9 leave <== NOT EXECUTED
109ef2: c3 ret <== NOT EXECUTED
109ef3: 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);
109ef4: 0f b6 43 43 movzbl 0x43(%ebx),%eax <== NOT EXECUTED
109ef8: 89 da mov %ebx,%edx <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
109efa: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
109efd: 5b pop %ebx <== NOT EXECUTED
109efe: 5e pop %esi <== NOT EXECUTED
109eff: 5f pop %edi <== NOT EXECUTED
109f00: 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);
109f01: e9 36 fe ff ff jmp 109d3c <echo> <== NOT EXECUTED
109f06: 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);
109f08: 50 push %eax <== NOT EXECUTED
109f09: 53 push %ebx <== NOT EXECUTED
109f0a: 6a 03 push $0x3 <== NOT EXECUTED
109f0c: 68 06 14 12 00 push $0x121406 <== NOT EXECUTED
109f11: e8 b6 fb ff ff call 109acc <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
109f16: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
109f19: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109f1c: 85 c0 test %eax,%eax <== NOT EXECUTED
109f1e: 74 04 je 109f24 <erase+0x184> <== NOT EXECUTED
tty->column--;
109f20: 48 dec %eax <== NOT EXECUTED
109f21: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
109f24: a1 94 5a 12 00 mov 0x125a94,%eax <== NOT EXECUTED
109f29: f6 04 30 20 testb $0x20,(%eax,%esi,1) <== NOT EXECUTED
109f2d: 0f 84 e6 fe ff ff je 109e19 <erase+0x79> <== NOT EXECUTED
109f33: f6 43 3d 02 testb $0x2,0x3d(%ebx) <== NOT EXECUTED
109f37: 0f 85 dc fe ff ff jne 109e19 <erase+0x79> <== NOT EXECUTED
109f3d: e9 92 fe ff ff jmp 109dd4 <erase+0x34> <== NOT EXECUTED
109f42: 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;
109f44: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
109f4b: 0f b6 40 44 movzbl 0x44(%eax),%eax <== NOT EXECUTED
109f4f: 89 da mov %ebx,%edx <== NOT EXECUTED
109f51: e8 e6 fd ff ff call 109d3c <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
109f56: f6 43 3c 20 testb $0x20,0x3c(%ebx) <== NOT EXECUTED
109f5a: 0f 84 dc fe ff ff je 109e3c <erase+0x9c> <== NOT EXECUTED
echo ('\n', tty);
109f60: 89 da mov %ebx,%edx <== NOT EXECUTED
109f62: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
109f67: eb 91 jmp 109efa <erase+0x15a> <== NOT EXECUTED
00108b30 <fchdir>:
#include <rtems/seterr.h>
int fchdir(
int fd
)
{
108b30: 55 push %ebp
108b31: 89 e5 mov %esp,%ebp
108b33: 57 push %edi
108b34: 56 push %esi
108b35: 53 push %ebx
108b36: 83 ec 4c sub $0x4c,%esp
108b39: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc, saved;
rtems_libio_check_fd( fd );
108b3c: 3b 05 ac 4d 12 00 cmp 0x124dac,%eax
108b42: 0f 83 d0 00 00 00 jae 108c18 <fchdir+0xe8>
iop = rtems_libio_iop( fd );
108b48: c1 e0 03 shl $0x3,%eax
108b4b: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx
108b52: 29 c3 sub %eax,%ebx
108b54: 03 1d 60 90 12 00 add 0x129060,%ebx
rtems_libio_check_is_open(iop);
108b5a: 8b 43 14 mov 0x14(%ebx),%eax
108b5d: f6 c4 01 test $0x1,%ah
108b60: 0f 84 b2 00 00 00 je 108c18 <fchdir+0xe8>
/*
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
108b66: a8 02 test $0x2,%al
108b68: 0f 84 be 00 00 00 je 108c2c <fchdir+0xfc>
/*
* Verify you can change directory into this node.
*/
if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) !=
108b6e: 83 ec 0c sub $0xc,%esp
108b71: 8b 43 24 mov 0x24(%ebx),%eax
108b74: 83 c3 18 add $0x18,%ebx
108b77: 53 push %ebx
108b78: ff 50 10 call *0x10(%eax)
108b7b: 83 c4 10 add $0x10,%esp
108b7e: 48 dec %eax
108b7f: 75 67 jne 108be8 <fchdir+0xb8>
* but note the race condition. Threads who
* share their rtems_filesystem_current better
* be synchronized!
*/
saved = rtems_filesystem_current;
108b81: a1 d0 6d 12 00 mov 0x126dd0,%eax
108b86: 8d 55 c0 lea -0x40(%ebp),%edx
108b89: 89 55 b4 mov %edx,-0x4c(%ebp)
108b8c: 8d 70 04 lea 0x4(%eax),%esi
108b8f: b9 05 00 00 00 mov $0x5,%ecx
108b94: 89 d7 mov %edx,%edi
108b96: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rtems_filesystem_current = iop->pathinfo;
108b98: 8d 78 04 lea 0x4(%eax),%edi
108b9b: b1 05 mov $0x5,%cl
108b9d: 89 de mov %ebx,%esi
108b9f: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* clone the current node */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
108ba1: 83 ec 0c sub $0xc,%esp
108ba4: 6a 00 push $0x0
108ba6: 8d 75 d4 lea -0x2c(%ebp),%esi
108ba9: 56 push %esi
108baa: 6a 00 push $0x0
108bac: 6a 01 push $0x1
108bae: 68 d6 2c 12 00 push $0x122cd6
108bb3: e8 a0 fe ff ff call 108a58 <rtems_filesystem_evaluate_path>
108bb8: 83 c4 20 add $0x20,%esp
108bbb: 85 c0 test %eax,%eax
108bbd: 75 3d jne 108bfc <fchdir+0xcc>
/* cloning failed; restore original and bail out */
rtems_filesystem_current = saved;
return -1;
}
/* release the old one */
rtems_filesystem_freenode( &saved );
108bbf: 83 ec 0c sub $0xc,%esp
108bc2: 8d 45 c0 lea -0x40(%ebp),%eax
108bc5: 50 push %eax
108bc6: e8 61 01 00 00 call 108d2c <rtems_filesystem_freenode>
rtems_filesystem_current = loc;
108bcb: 8b 3d d0 6d 12 00 mov 0x126dd0,%edi
108bd1: 83 c7 04 add $0x4,%edi
108bd4: b9 05 00 00 00 mov $0x5,%ecx
108bd9: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return 0;
108bdb: 83 c4 10 add $0x10,%esp
108bde: 31 c0 xor %eax,%eax
}
108be0: 8d 65 f4 lea -0xc(%ebp),%esp
108be3: 5b pop %ebx
108be4: 5e pop %esi
108be5: 5f pop %edi
108be6: c9 leave
108be7: 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 );
108be8: e8 33 b5 00 00 call 114120 <__errno>
108bed: c7 00 14 00 00 00 movl $0x14,(%eax)
108bf3: b8 ff ff ff ff mov $0xffffffff,%eax
108bf8: eb e6 jmp 108be0 <fchdir+0xb0>
108bfa: 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;
108bfc: 8b 3d d0 6d 12 00 mov 0x126dd0,%edi
108c02: 83 c7 04 add $0x4,%edi
108c05: b9 05 00 00 00 mov $0x5,%ecx
108c0a: 8b 75 b4 mov -0x4c(%ebp),%esi
108c0d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return -1;
108c0f: b8 ff ff ff ff mov $0xffffffff,%eax
108c14: eb ca jmp 108be0 <fchdir+0xb0>
108c16: 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);
108c18: e8 03 b5 00 00 call 114120 <__errno>
108c1d: c7 00 09 00 00 00 movl $0x9,(%eax)
108c23: b8 ff ff ff ff mov $0xffffffff,%eax
108c28: eb b6 jmp 108be0 <fchdir+0xb0>
108c2a: 66 90 xchg %ax,%ax
/*
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
108c2c: e8 ef b4 00 00 call 114120 <__errno>
108c31: c7 00 16 00 00 00 movl $0x16,(%eax)
108c37: b8 ff ff ff ff mov $0xffffffff,%eax
108c3c: eb a2 jmp 108be0 <fchdir+0xb0>
00108c40 <fchmod>:
int fchmod(
int fd,
mode_t mode
)
{
108c40: 55 push %ebp
108c41: 89 e5 mov %esp,%ebp
108c43: 83 ec 08 sub $0x8,%esp
108c46: 8b 45 08 mov 0x8(%ebp),%eax
108c49: 8b 4d 0c mov 0xc(%ebp),%ecx
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
108c4c: 3b 05 ac 4d 12 00 cmp 0x124dac,%eax
108c52: 73 38 jae 108c8c <fchmod+0x4c>
iop = rtems_libio_iop( fd );
108c54: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
108c5b: 8d 04 d5 00 00 00 00 lea 0x0(,%edx,8),%eax
108c62: 29 d0 sub %edx,%eax
108c64: 03 05 60 90 12 00 add 0x129060,%eax
rtems_libio_check_is_open(iop);
108c6a: 8b 50 14 mov 0x14(%eax),%edx
108c6d: f6 c6 01 test $0x1,%dh
108c70: 74 1a je 108c8c <fchmod+0x4c>
/*
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
108c72: 83 e2 04 and $0x4,%edx
108c75: 74 29 je 108ca0 <fchmod+0x60>
return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode );
108c77: 8b 50 20 mov 0x20(%eax),%edx
108c7a: 89 4d 0c mov %ecx,0xc(%ebp)
108c7d: 83 c0 18 add $0x18,%eax
108c80: 89 45 08 mov %eax,0x8(%ebp)
108c83: 8b 42 1c mov 0x1c(%edx),%eax
}
108c86: c9 leave
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode );
108c87: ff e0 jmp *%eax
108c89: 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);
108c8c: e8 8f b4 00 00 call 114120 <__errno>
108c91: 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 );
}
108c97: b8 ff ff ff ff mov $0xffffffff,%eax
108c9c: c9 leave
108c9d: c3 ret
108c9e: 66 90 xchg %ax,%ax
/*
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
108ca0: e8 7b b4 00 00 call 114120 <__errno>
108ca5: c7 00 16 00 00 00 movl $0x16,(%eax)
108cab: eb ea jmp 108c97 <fchmod+0x57>
00108ae0 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
108ae0: 55 push %ebp
108ae1: 89 e5 mov %esp,%ebp
108ae3: 57 push %edi
108ae4: 56 push %esi
108ae5: 53 push %ebx
108ae6: 83 ec 1c sub $0x1c,%esp
108ae9: 8b 5d 08 mov 0x8(%ebp),%ebx
108aec: 8b 55 0c mov 0xc(%ebp),%edx
int ret;
va_list ap;
va_start( ap, cmd );
108aef: 8d 7d 10 lea 0x10(%ebp),%edi
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
108af2: 8b 0d ac 55 12 00 mov 0x1255ac,%ecx
108af8: 39 cb cmp %ecx,%ebx
108afa: 0f 83 5c 01 00 00 jae 108c5c <fcntl+0x17c>
iop = rtems_libio_iop( fd );
108b00: a1 60 98 12 00 mov 0x129860,%eax
108b05: 8d 34 dd 00 00 00 00 lea 0x0(,%ebx,8),%esi
108b0c: 8d 1c f5 00 00 00 00 lea 0x0(,%esi,8),%ebx
108b13: 29 f3 sub %esi,%ebx
108b15: 8d 1c 18 lea (%eax,%ebx,1),%ebx
rtems_libio_check_is_open(iop);
108b18: 8b 73 14 mov 0x14(%ebx),%esi
108b1b: f7 c6 00 01 00 00 test $0x100,%esi
108b21: 0f 84 35 01 00 00 je 108c5c <fcntl+0x17c>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
108b27: 83 fa 09 cmp $0x9,%edx
108b2a: 76 10 jbe 108b3c <fcntl+0x5c>
errno = ENOTSUP;
ret = -1;
break;
default:
errno = EINVAL;
108b2c: e8 9f b8 00 00 call 1143d0 <__errno>
108b31: c7 00 16 00 00 00 movl $0x16,(%eax)
108b37: eb 16 jmp 108b4f <fcntl+0x6f>
108b39: 8d 76 00 lea 0x0(%esi),%esi
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
108b3c: ff 24 95 f0 2e 12 00 jmp *0x122ef0(,%edx,4)
108b43: 90 nop
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
108b44: e8 87 b8 00 00 call 1143d0 <__errno>
108b49: 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;
108b4f: 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;
}
108b54: 89 f0 mov %esi,%eax
108b56: 8d 65 f4 lea -0xc(%ebp),%esp
108b59: 5b pop %ebx
108b5a: 5e pop %esi
108b5b: 5f pop %edi
108b5c: c9 leave
108b5d: c3 ret
108b5e: 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 ) );
108b60: 83 ec 0c sub $0xc,%esp
108b63: ff 37 pushl (%edi)
108b65: 89 55 e0 mov %edx,-0x20(%ebp)
108b68: e8 33 05 00 00 call 1090a0 <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
108b6d: 25 01 02 00 00 and $0x201,%eax
108b72: 8b 4b 14 mov 0x14(%ebx),%ecx
108b75: 81 e1 fe fd ff ff and $0xfffffdfe,%ecx
108b7b: 09 c8 or %ecx,%eax
108b7d: 89 43 14 mov %eax,0x14(%ebx)
108b80: 83 c4 10 add $0x10,%esp
rtems_libio_t *iop;
rtems_libio_t *diop;
int fd2;
int flags;
int mask;
int ret = 0;
108b83: 31 f6 xor %esi,%esi
108b85: 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 );
108b88: 83 ec 08 sub $0x8,%esp
108b8b: 8b 43 20 mov 0x20(%ebx),%eax
108b8e: 53 push %ebx
108b8f: 52 push %edx
108b90: ff 50 30 call *0x30(%eax)
108b93: 89 c3 mov %eax,%ebx
if (err) {
108b95: 83 c4 10 add $0x10,%esp
108b98: 85 c0 test %eax,%eax
108b9a: 74 b8 je 108b54 <fcntl+0x74> <== ALWAYS TAKEN
errno = err;
108b9c: e8 2f b8 00 00 call 1143d0 <__errno> <== NOT EXECUTED
108ba1: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
108ba3: eb aa jmp 108b4f <fcntl+0x6f> <== NOT EXECUTED
108ba5: 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 );
108ba8: 83 ec 0c sub $0xc,%esp
108bab: 56 push %esi
108bac: 89 55 e0 mov %edx,-0x20(%ebp)
108baf: e8 24 05 00 00 call 1090d8 <rtems_libio_to_fcntl_flags>
108bb4: 89 c6 mov %eax,%esi
108bb6: 83 c4 10 add $0x10,%esp
108bb9: 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) {
108bbc: 85 f6 test %esi,%esi
108bbe: 79 c8 jns 108b88 <fcntl+0xa8> <== ALWAYS TAKEN
108bc0: eb 92 jmp 108b54 <fcntl+0x74> <== NOT EXECUTED
108bc2: 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 ) )
108bc4: 8b 07 mov (%edi),%eax
108bc6: 85 c0 test %eax,%eax
108bc8: 74 6a je 108c34 <fcntl+0x154>
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
108bca: 81 ce 00 08 00 00 or $0x800,%esi
108bd0: 89 73 14 mov %esi,0x14(%ebx)
rtems_libio_t *iop;
rtems_libio_t *diop;
int fd2;
int flags;
int mask;
int ret = 0;
108bd3: 31 f6 xor %esi,%esi
108bd5: eb b1 jmp 108b88 <fcntl+0xa8>
108bd7: 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);
108bd8: 31 c0 xor %eax,%eax
108bda: f7 c6 00 08 00 00 test $0x800,%esi
108be0: 0f 95 c0 setne %al
108be3: 89 c6 mov %eax,%esi
108be5: eb a1 jmp 108b88 <fcntl+0xa8>
108be7: 90 nop
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
108be8: 8b 3f mov (%edi),%edi
if ( fd2 )
108bea: 85 ff test %edi,%edi
108bec: 0f 84 82 00 00 00 je 108c74 <fcntl+0x194>
diop = rtems_libio_iop( fd2 );
108bf2: 39 f9 cmp %edi,%ecx
108bf4: 77 4e ja 108c44 <fcntl+0x164> <== ALWAYS TAKEN
108bf6: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) <== NOT EXECUTED
108bfd: 31 ff xor %edi,%edi <== NOT EXECUTED
ret = -1;
break;
}
}
diop->flags = iop->flags;
108bff: 89 77 14 mov %esi,0x14(%edi)
diop->pathinfo = iop->pathinfo;
108c02: 83 c7 18 add $0x18,%edi
108c05: 8d 73 18 lea 0x18(%ebx),%esi
108c08: b9 05 00 00 00 mov $0x5,%ecx
108c0d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
ret = (int) (diop - rtems_libio_iops);
108c0f: 8b 4d e4 mov -0x1c(%ebp),%ecx
108c12: 29 c1 sub %eax,%ecx
108c14: 89 c8 mov %ecx,%eax
108c16: c1 f8 03 sar $0x3,%eax
108c19: 8d 0c c0 lea (%eax,%eax,8),%ecx
108c1c: 8d 0c c8 lea (%eax,%ecx,8),%ecx
108c1f: 8d 0c c8 lea (%eax,%ecx,8),%ecx
108c22: 8d 0c c8 lea (%eax,%ecx,8),%ecx
108c25: 89 ce mov %ecx,%esi
108c27: c1 e6 0f shl $0xf,%esi
108c2a: 01 f1 add %esi,%ecx
108c2c: 8d 34 c8 lea (%eax,%ecx,8),%esi
108c2f: f7 de neg %esi
108c31: eb 89 jmp 108bbc <fcntl+0xdc>
108c33: 90 nop
*/
if ( va_arg( ap, int ) )
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
108c34: 81 e6 ff f7 ff ff and $0xfffff7ff,%esi
108c3a: 89 73 14 mov %esi,0x14(%ebx)
rtems_libio_t *iop;
rtems_libio_t *diop;
int fd2;
int flags;
int mask;
int ret = 0;
108c3d: 31 f6 xor %esi,%esi
108c3f: e9 44 ff ff ff jmp 108b88 <fcntl+0xa8>
switch ( cmd ) {
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
if ( fd2 )
diop = rtems_libio_iop( fd2 );
108c44: 8d 0c fd 00 00 00 00 lea 0x0(,%edi,8),%ecx
108c4b: 8d 3c cd 00 00 00 00 lea 0x0(,%ecx,8),%edi
108c52: 29 cf sub %ecx,%edi
108c54: 8d 3c 38 lea (%eax,%edi,1),%edi
108c57: 89 7d e4 mov %edi,-0x1c(%ebp)
108c5a: eb a3 jmp 108bff <fcntl+0x11f>
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
108c5c: e8 6f b7 00 00 call 1143d0 <__errno>
108c61: c7 00 09 00 00 00 movl $0x9,(%eax)
108c67: be ff ff ff ff mov $0xffffffff,%esi
108c6c: e9 e3 fe ff ff jmp 108b54 <fcntl+0x74>
108c71: 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();
108c74: 89 55 e0 mov %edx,-0x20(%ebp)
108c77: e8 a0 04 00 00 call 10911c <rtems_libio_allocate>
108c7c: 89 c7 mov %eax,%edi
if ( diop == 0 ) {
108c7e: 85 c0 test %eax,%eax
108c80: 8b 55 e0 mov -0x20(%ebp),%edx
108c83: 0f 84 c6 fe ff ff je 108b4f <fcntl+0x6f> <== NEVER TAKEN
108c89: 8b 73 14 mov 0x14(%ebx),%esi
108c8c: 89 45 e4 mov %eax,-0x1c(%ebp)
108c8f: a1 60 98 12 00 mov 0x129860,%eax
108c94: e9 66 ff ff ff jmp 108bff <fcntl+0x11f>
00108cbc <fdatasync>:
#include <rtems/seterr.h>
int fdatasync(
int fd
)
{
108cbc: 55 push %ebp
108cbd: 89 e5 mov %esp,%ebp
108cbf: 83 ec 08 sub $0x8,%esp
108cc2: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
108cc5: 3b 05 ac 55 12 00 cmp 0x1255ac,%eax
108ccb: 73 2f jae 108cfc <fdatasync+0x40>
iop = rtems_libio_iop( fd );
108ccd: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
108cd4: 8d 04 d5 00 00 00 00 lea 0x0(,%edx,8),%eax
108cdb: 29 d0 sub %edx,%eax
108cdd: 03 05 60 98 12 00 add 0x129860,%eax
rtems_libio_check_is_open(iop);
108ce3: 8b 50 14 mov 0x14(%eax),%edx
108ce6: f6 c6 01 test $0x1,%dh
108ce9: 74 11 je 108cfc <fdatasync+0x40>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
108ceb: 83 e2 04 and $0x4,%edx
108cee: 74 20 je 108d10 <fdatasync+0x54>
/*
* Now process the fdatasync().
*/
return (*iop->pathinfo.handlers->fdatasync_h)( iop );
108cf0: 8b 50 20 mov 0x20(%eax),%edx
108cf3: 89 45 08 mov %eax,0x8(%ebp)
108cf6: 8b 42 2c mov 0x2c(%edx),%eax
}
108cf9: c9 leave
/*
* Now process the fdatasync().
*/
return (*iop->pathinfo.handlers->fdatasync_h)( iop );
108cfa: ff e0 jmp *%eax
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
108cfc: e8 cf b6 00 00 call 1143d0 <__errno>
108d01: c7 00 09 00 00 00 movl $0x9,(%eax)
/*
* Now process the fdatasync().
*/
return (*iop->pathinfo.handlers->fdatasync_h)( iop );
}
108d07: b8 ff ff ff ff mov $0xffffffff,%eax
108d0c: c9 leave
108d0d: c3 ret
108d0e: 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 );
108d10: e8 bb b6 00 00 call 1143d0 <__errno>
108d15: c7 00 16 00 00 00 movl $0x16,(%eax)
108d1b: eb ea jmp 108d07 <fdatasync+0x4b>
00111aa0 <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
111aa0: 55 push %ebp
111aa1: 89 e5 mov %esp,%ebp
111aa3: 57 push %edi
111aa4: 56 push %esi
111aa5: 53 push %ebx
111aa6: 83 ec 2c sub $0x2c,%esp
111aa9: 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) {
111aac: a1 0c a4 12 00 mov 0x12a40c,%eax
111ab1: 85 c0 test %eax,%eax
111ab3: 0f 84 8b 00 00 00 je 111b44 <fifo_open+0xa4>
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
111ab9: 53 push %ebx
111aba: 6a 00 push $0x0
111abc: 6a 00 push $0x0
111abe: 50 push %eax
111abf: e8 10 ba ff ff call 10d4d4 <rtems_semaphore_obtain>
}
if (sc == RTEMS_SUCCESSFUL) {
111ac4: 83 c4 10 add $0x10,%esp
111ac7: 85 c0 test %eax,%eax
111ac9: 0f 85 4c 03 00 00 jne 111e1b <fifo_open+0x37b> <== NEVER TAKEN
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
111acf: 8b 1e mov (%esi),%ebx
if (pipe == NULL) {
111ad1: 85 db test %ebx,%ebx
111ad3: 0f 84 df 01 00 00 je 111cb8 <fifo_open+0x218>
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
111ad9: 52 push %edx
111ada: 6a 00 push $0x0
111adc: 6a 00 push $0x0
111ade: ff 73 28 pushl 0x28(%ebx)
111ae1: e8 ee b9 ff ff call 10d4d4 <rtems_semaphore_obtain>
111ae6: 83 c4 10 add $0x10,%esp
111ae9: 83 f8 01 cmp $0x1,%eax
111aec: 19 ff sbb %edi,%edi
111aee: f7 d7 not %edi
111af0: 83 e7 fc and $0xfffffffc,%edi
err = -EINTR;
if (*pipep == NULL) {
111af3: 8b 06 mov (%esi),%eax
111af5: 85 c0 test %eax,%eax
111af7: 0f 84 d7 02 00 00 je 111dd4 <fifo_open+0x334>
else
*pipep = pipe;
}
out:
pipe_unlock();
111afd: e8 aa fe ff ff call 1119ac <pipe_unlock>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
111b02: 85 ff test %edi,%edi
111b04: 75 32 jne 111b38 <fifo_open+0x98> <== NEVER TAKEN
return err;
pipe = *pipep;
111b06: 8b 1e mov (%esi),%ebx
switch (LIBIO_ACCMODE(iop)) {
111b08: 8b 55 0c mov 0xc(%ebp),%edx
111b0b: 8b 42 14 mov 0x14(%edx),%eax
111b0e: 83 e0 06 and $0x6,%eax
111b11: 83 f8 04 cmp $0x4,%eax
111b14: 74 6a je 111b80 <fifo_open+0xe0>
111b16: 83 f8 06 cmp $0x6,%eax
111b19: 0f 84 59 01 00 00 je 111c78 <fifo_open+0x1d8>
111b1f: 83 f8 02 cmp $0x2,%eax
111b22: 0f 84 dc 00 00 00 je 111c04 <fifo_open+0x164> <== ALWAYS TAKEN
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
break;
}
PIPE_UNLOCK(pipe);
111b28: 83 ec 0c sub $0xc,%esp
111b2b: ff 73 28 pushl 0x28(%ebx)
111b2e: e8 9d ba ff ff call 10d5d0 <rtems_semaphore_release>
return 0;
111b33: 83 c4 10 add $0x10,%esp
111b36: 31 ff xor %edi,%edi
out_error:
pipe_release(pipep, iop);
return err;
}
111b38: 89 f8 mov %edi,%eax
111b3a: 8d 65 f4 lea -0xc(%ebp),%esp
111b3d: 5b pop %ebx
111b3e: 5e pop %esi
111b3f: 5f pop %edi
111b40: c9 leave
111b41: c3 ret
111b42: 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 );
111b44: 50 push %eax
111b45: 6a 00 push $0x0
111b47: 6a 00 push $0x0
111b49: ff 35 28 a6 12 00 pushl 0x12a628
111b4f: e8 80 b9 ff ff call 10d4d4 <rtems_semaphore_obtain>
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
111b54: 83 c4 10 add $0x10,%esp
111b57: 8b 3d 0c a4 12 00 mov 0x12a40c,%edi
111b5d: 85 ff test %edi,%edi
111b5f: 0f 84 83 02 00 00 je 111de8 <fifo_open+0x348> <== ALWAYS TAKEN
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
111b65: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
111b68: ff 35 28 a6 12 00 pushl 0x12a628 <== NOT EXECUTED
111b6e: e8 5d ba ff ff call 10d5d0 <rtems_semaphore_release><== NOT EXECUTED
111b73: a1 0c a4 12 00 mov 0x12a40c,%eax <== NOT EXECUTED
111b78: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
111b7b: e9 39 ff ff ff jmp 111ab9 <fifo_open+0x19> <== NOT EXECUTED
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
111b80: ff 43 24 incl 0x24(%ebx)
if (pipe->Writers ++ == 0)
111b83: 8b 43 14 mov 0x14(%ebx),%eax
111b86: 8d 50 01 lea 0x1(%eax),%edx
111b89: 89 53 14 mov %edx,0x14(%ebx)
111b8c: 85 c0 test %eax,%eax
111b8e: 0f 84 c4 02 00 00 je 111e58 <fifo_open+0x3b8> <== ALWAYS TAKEN
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
111b94: 8b 4b 10 mov 0x10(%ebx),%ecx
111b97: 85 c9 test %ecx,%ecx
111b99: 75 8d jne 111b28 <fifo_open+0x88>
111b9b: 8b 55 0c mov 0xc(%ebp),%edx
111b9e: f6 42 14 01 testb $0x1,0x14(%edx)
111ba2: 0f 85 04 03 00 00 jne 111eac <fifo_open+0x40c>
err = -ENXIO;
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
111ba8: 8b 7b 20 mov 0x20(%ebx),%edi
111bab: eb 20 jmp 111bcd <fifo_open+0x12d>
111bad: 8d 76 00 lea 0x0(%esi),%esi
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
111bb0: 51 push %ecx
111bb1: 6a 00 push $0x0
111bb3: 6a 00 push $0x0
111bb5: ff 73 28 pushl 0x28(%ebx)
111bb8: e8 17 b9 ff ff call 10d4d4 <rtems_semaphore_obtain>
111bbd: 83 c4 10 add $0x10,%esp
111bc0: 85 c0 test %eax,%eax
111bc2: 75 27 jne 111beb <fifo_open+0x14b> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->readerCounter);
111bc4: 39 7b 20 cmp %edi,0x20(%ebx)
111bc7: 0f 85 5b ff ff ff jne 111b28 <fifo_open+0x88> <== ALWAYS TAKEN
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
111bcd: 83 ec 0c sub $0xc,%esp
111bd0: ff 73 28 pushl 0x28(%ebx)
111bd3: e8 f8 b9 ff ff call 10d5d0 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
111bd8: 58 pop %eax
111bd9: 5a pop %edx
111bda: 6a 00 push $0x0
111bdc: ff 73 30 pushl 0x30(%ebx)
111bdf: e8 b0 1c 00 00 call 113894 <rtems_barrier_wait>
111be4: 83 c4 10 add $0x10,%esp
111be7: 85 c0 test %eax,%eax
111be9: 74 c5 je 111bb0 <fifo_open+0x110> <== ALWAYS TAKEN
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
111beb: bf fc ff ff ff mov $0xfffffffc,%edi <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
111bf0: 83 ec 08 sub $0x8,%esp
111bf3: ff 75 0c pushl 0xc(%ebp)
111bf6: 56 push %esi
111bf7: e8 c8 fd ff ff call 1119c4 <pipe_release>
return err;
111bfc: 83 c4 10 add $0x10,%esp
111bff: e9 34 ff ff ff jmp 111b38 <fifo_open+0x98>
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
111c04: ff 43 20 incl 0x20(%ebx)
if (pipe->Readers ++ == 0)
111c07: 8b 43 10 mov 0x10(%ebx),%eax
111c0a: 8d 50 01 lea 0x1(%eax),%edx
111c0d: 89 53 10 mov %edx,0x10(%ebx)
111c10: 85 c0 test %eax,%eax
111c12: 0f 84 10 02 00 00 je 111e28 <fifo_open+0x388> <== ALWAYS TAKEN
PIPE_WAKEUPWRITERS(pipe);
if (pipe->Writers == 0) {
111c18: 8b 7b 14 mov 0x14(%ebx),%edi
111c1b: 85 ff test %edi,%edi
111c1d: 0f 85 05 ff ff ff jne 111b28 <fifo_open+0x88>
/* Not an error */
if (LIBIO_NODELAY(iop))
111c23: 8b 45 0c mov 0xc(%ebp),%eax
111c26: f6 40 14 01 testb $0x1,0x14(%eax)
111c2a: 0f 85 f8 fe ff ff jne 111b28 <fifo_open+0x88>
break;
prevCounter = pipe->writerCounter;
111c30: 8b 7b 24 mov 0x24(%ebx),%edi
111c33: eb 20 jmp 111c55 <fifo_open+0x1b5>
111c35: 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))
111c38: 50 push %eax
111c39: 6a 00 push $0x0
111c3b: 6a 00 push $0x0
111c3d: ff 73 28 pushl 0x28(%ebx)
111c40: e8 8f b8 ff ff call 10d4d4 <rtems_semaphore_obtain>
111c45: 83 c4 10 add $0x10,%esp
111c48: 85 c0 test %eax,%eax
111c4a: 75 9f jne 111beb <fifo_open+0x14b> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->writerCounter);
111c4c: 39 7b 24 cmp %edi,0x24(%ebx)
111c4f: 0f 85 d3 fe ff ff jne 111b28 <fifo_open+0x88> <== ALWAYS TAKEN
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
111c55: 83 ec 0c sub $0xc,%esp
111c58: ff 73 28 pushl 0x28(%ebx)
111c5b: e8 70 b9 ff ff call 10d5d0 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
111c60: 5a pop %edx
111c61: 59 pop %ecx
111c62: 6a 00 push $0x0
111c64: ff 73 2c pushl 0x2c(%ebx)
111c67: e8 28 1c 00 00 call 113894 <rtems_barrier_wait>
111c6c: 83 c4 10 add $0x10,%esp
111c6f: 85 c0 test %eax,%eax
111c71: 74 c5 je 111c38 <fifo_open+0x198> <== ALWAYS TAKEN
111c73: e9 73 ff ff ff jmp 111beb <fifo_open+0x14b> <== NOT EXECUTED
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
111c78: ff 43 20 incl 0x20(%ebx)
if (pipe->Readers ++ == 0)
111c7b: 8b 43 10 mov 0x10(%ebx),%eax
111c7e: 8d 50 01 lea 0x1(%eax),%edx
111c81: 89 53 10 mov %edx,0x10(%ebx)
111c84: 85 c0 test %eax,%eax
111c86: 0f 84 b4 01 00 00 je 111e40 <fifo_open+0x3a0> <== ALWAYS TAKEN
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
111c8c: ff 43 24 incl 0x24(%ebx)
if (pipe->Writers ++ == 0)
111c8f: 8b 43 14 mov 0x14(%ebx),%eax
111c92: 8d 50 01 lea 0x1(%eax),%edx
111c95: 89 53 14 mov %edx,0x14(%ebx)
111c98: 85 c0 test %eax,%eax
111c9a: 0f 85 88 fe ff ff jne 111b28 <fifo_open+0x88> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
111ca0: 83 ec 08 sub $0x8,%esp
111ca3: 8d 45 e4 lea -0x1c(%ebp),%eax
111ca6: 50 push %eax
111ca7: ff 73 2c pushl 0x2c(%ebx)
111caa: e8 81 1b 00 00 call 113830 <rtems_barrier_release>
111caf: 83 c4 10 add $0x10,%esp
111cb2: e9 71 fe ff ff jmp 111b28 <fifo_open+0x88>
111cb7: 90 nop
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
111cb8: 83 ec 0c sub $0xc,%esp
111cbb: 6a 34 push $0x34
111cbd: e8 fe 83 ff ff call 10a0c0 <malloc>
111cc2: 89 c3 mov %eax,%ebx
111cc4: 89 45 d4 mov %eax,-0x2c(%ebp)
if (pipe == NULL)
111cc7: 83 c4 10 add $0x10,%esp
111cca: 85 c0 test %eax,%eax
111ccc: 0f 84 32 02 00 00 je 111f04 <fifo_open+0x464>
return err;
memset(pipe, 0, sizeof(pipe_control_t));
111cd2: b9 34 00 00 00 mov $0x34,%ecx
111cd7: 31 c0 xor %eax,%eax
111cd9: 89 df mov %ebx,%edi
111cdb: f3 aa rep stos %al,%es:(%edi)
pipe->Size = PIPE_BUF;
111cdd: c7 43 04 00 02 00 00 movl $0x200,0x4(%ebx)
pipe->Buffer = malloc(pipe->Size);
111ce4: 83 ec 0c sub $0xc,%esp
111ce7: 68 00 02 00 00 push $0x200
111cec: e8 cf 83 ff ff call 10a0c0 <malloc>
111cf1: 89 03 mov %eax,(%ebx)
if (! pipe->Buffer)
111cf3: 83 c4 10 add $0x10,%esp
111cf6: 85 c0 test %eax,%eax
111cf8: 0f 84 f8 01 00 00 je 111ef6 <fifo_open+0x456> <== NEVER TAKEN
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
111cfe: 8d 43 2c lea 0x2c(%ebx),%eax
111d01: 50 push %eax
111d02: 6a 00 push $0x0
111d04: 6a 00 push $0x0
rtems_build_name ('P', 'I', 'r', c),
111d06: 0f be 05 98 83 12 00 movsbl 0x128398,%eax
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
111d0d: 0d 00 72 49 50 or $0x50497200,%eax
111d12: 50 push %eax
111d13: e8 9c 19 00 00 call 1136b4 <rtems_barrier_create>
111d18: 83 c4 10 add $0x10,%esp
111d1b: 85 c0 test %eax,%eax
111d1d: 0f 85 c3 01 00 00 jne 111ee6 <fifo_open+0x446>
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
111d23: 8d 43 30 lea 0x30(%ebx),%eax
111d26: 50 push %eax
111d27: 6a 00 push $0x0
111d29: 6a 00 push $0x0
rtems_build_name ('P', 'I', 'w', c),
111d2b: 0f be 05 98 83 12 00 movsbl 0x128398,%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(
111d32: 0d 00 77 49 50 or $0x50497700,%eax
111d37: 50 push %eax
111d38: e8 77 19 00 00 call 1136b4 <rtems_barrier_create>
111d3d: 83 c4 10 add $0x10,%esp
111d40: 85 c0 test %eax,%eax
111d42: 0f 85 8d 01 00 00 jne 111ed5 <fifo_open+0x435>
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
111d48: 83 ec 0c sub $0xc,%esp
111d4b: 8d 43 28 lea 0x28(%ebx),%eax
111d4e: 50 push %eax
111d4f: 6a 00 push $0x0
111d51: 6a 10 push $0x10
111d53: 6a 01 push $0x1
rtems_build_name ('P', 'I', 's', c), 1,
111d55: 0f be 05 98 83 12 00 movsbl 0x128398,%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(
111d5c: 0d 00 73 49 50 or $0x50497300,%eax
111d61: 50 push %eax
111d62: e8 f1 b4 ff ff call 10d258 <rtems_semaphore_create>
111d67: 83 c4 20 add $0x20,%esp
111d6a: 85 c0 test %eax,%eax
111d6c: 0f 85 52 01 00 00 jne 111ec4 <fifo_open+0x424>
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
_Objects_Get( &_Barrier_Information, id, location );
111d72: 51 push %ecx
/* Set barriers to be interruptible by signals. */
static void pipe_interruptible(pipe_control_t *pipe)
{
Objects_Locations location;
_Barrier_Get(pipe->readBarrier, &location)->Barrier.Wait_queue.state
111d73: 8d 7d e0 lea -0x20(%ebp),%edi
111d76: 57 push %edi
111d77: ff 73 2c pushl 0x2c(%ebx)
111d7a: 68 80 b1 12 00 push $0x12b180
111d7f: e8 90 ce ff ff call 10ec14 <_Objects_Get>
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
111d84: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax)
_Thread_Enable_dispatch();
111d8b: e8 2c da ff ff call 10f7bc <_Thread_Enable_dispatch>
111d90: 83 c4 0c add $0xc,%esp
111d93: 57 push %edi
111d94: ff 73 30 pushl 0x30(%ebx)
111d97: 68 80 b1 12 00 push $0x12b180
111d9c: e8 73 ce ff ff call 10ec14 <_Objects_Get>
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
111da1: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax)
_Thread_Enable_dispatch();
111da8: e8 0f da ff ff call 10f7bc <_Thread_Enable_dispatch>
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
111dad: a0 98 83 12 00 mov 0x128398,%al
111db2: 8d 50 01 lea 0x1(%eax),%edx
111db5: 88 15 98 83 12 00 mov %dl,0x128398
111dbb: 83 c4 10 add $0x10,%esp
111dbe: 3c 7a cmp $0x7a,%al
111dc0: 0f 85 13 fd ff ff jne 111ad9 <fifo_open+0x39>
c = 'a';
111dc6: c6 05 98 83 12 00 61 movb $0x61,0x128398
111dcd: e9 07 fd ff ff jmp 111ad9 <fifo_open+0x39>
111dd2: 66 90 xchg %ax,%ax
if (! PIPE_LOCK(pipe))
err = -EINTR;
if (*pipep == NULL) {
if (err)
111dd4: 85 ff test %edi,%edi
111dd6: 0f 85 94 00 00 00 jne 111e70 <fifo_open+0x3d0> <== NEVER TAKEN
pipe_free(pipe);
else
*pipep = pipe;
111ddc: 89 1e mov %ebx,(%esi)
}
out:
pipe_unlock();
111dde: e8 c9 fb ff ff call 1119ac <pipe_unlock>
111de3: e9 1e fd ff ff jmp 111b06 <fifo_open+0x66>
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
sc = rtems_semaphore_create(
111de8: 83 ec 0c sub $0xc,%esp
111deb: 68 0c a4 12 00 push $0x12a40c
111df0: 6a 00 push $0x0
111df2: 6a 54 push $0x54
111df4: 6a 01 push $0x1
111df6: 68 45 50 49 50 push $0x50495045
111dfb: e8 58 b4 ff ff call 10d258 <rtems_semaphore_create>
111e00: 89 c3 mov %eax,%ebx
111e02: 83 c4 14 add $0x14,%esp
111e05: ff 35 28 a6 12 00 pushl 0x12a628
111e0b: e8 c0 b7 ff ff call 10d5d0 <rtems_semaphore_release>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
111e10: 83 c4 10 add $0x10,%esp
111e13: 85 db test %ebx,%ebx
111e15: 0f 84 f0 00 00 00 je 111f0b <fifo_open+0x46b>
)
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
111e1b: bf f4 ff ff ff mov $0xfffffff4,%edi
111e20: e9 13 fd ff ff jmp 111b38 <fifo_open+0x98>
111e25: 8d 76 00 lea 0x0(%esi),%esi
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
111e28: 83 ec 08 sub $0x8,%esp
111e2b: 8d 45 e4 lea -0x1c(%ebp),%eax
111e2e: 50 push %eax
111e2f: ff 73 30 pushl 0x30(%ebx)
111e32: e8 f9 19 00 00 call 113830 <rtems_barrier_release>
111e37: 83 c4 10 add $0x10,%esp
111e3a: e9 d9 fd ff ff jmp 111c18 <fifo_open+0x178>
111e3f: 90 nop
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
111e40: 83 ec 08 sub $0x8,%esp
111e43: 8d 45 e4 lea -0x1c(%ebp),%eax
111e46: 50 push %eax
111e47: ff 73 30 pushl 0x30(%ebx)
111e4a: e8 e1 19 00 00 call 113830 <rtems_barrier_release>
111e4f: 83 c4 10 add $0x10,%esp
111e52: e9 35 fe ff ff jmp 111c8c <fifo_open+0x1ec>
111e57: 90 nop
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
111e58: 83 ec 08 sub $0x8,%esp
111e5b: 8d 45 e4 lea -0x1c(%ebp),%eax
111e5e: 50 push %eax
111e5f: ff 73 2c pushl 0x2c(%ebx)
111e62: e8 c9 19 00 00 call 113830 <rtems_barrier_release>
111e67: 83 c4 10 add $0x10,%esp
111e6a: e9 25 fd ff ff jmp 111b94 <fifo_open+0xf4>
111e6f: 90 nop
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
111e70: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
111e73: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED
111e76: e8 25 19 00 00 call 1137a0 <rtems_barrier_delete> <== NOT EXECUTED
rtems_barrier_delete(pipe->writeBarrier);
111e7b: 59 pop %ecx <== NOT EXECUTED
111e7c: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED
111e7f: e8 1c 19 00 00 call 1137a0 <rtems_barrier_delete> <== NOT EXECUTED
rtems_semaphore_delete(pipe->Semaphore);
111e84: 5a pop %edx <== NOT EXECUTED
111e85: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED
111e88: e8 a3 b5 ff ff call 10d430 <rtems_semaphore_delete><== NOT EXECUTED
free(pipe->Buffer);
111e8d: 58 pop %eax <== NOT EXECUTED
111e8e: ff 33 pushl (%ebx) <== NOT EXECUTED
111e90: e8 3b 7b ff ff call 1099d0 <free> <== NOT EXECUTED
free(pipe);
111e95: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
111e98: e8 33 7b ff ff call 1099d0 <free> <== NOT EXECUTED
111e9d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
else
*pipep = pipe;
}
out:
pipe_unlock();
111ea0: e8 07 fb ff ff call 1119ac <pipe_unlock>
111ea5: e9 8e fc ff ff jmp 111b38 <fifo_open+0x98>
111eaa: 66 90 xchg %ax,%ax
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
111eac: 83 ec 0c sub $0xc,%esp
111eaf: ff 73 28 pushl 0x28(%ebx)
111eb2: e8 19 b7 ff ff call 10d5d0 <rtems_semaphore_release>
err = -ENXIO;
goto out_error;
111eb7: 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;
111eba: bf fa ff ff ff mov $0xfffffffa,%edi
goto out_error;
111ebf: e9 2c fd ff ff jmp 111bf0 <fifo_open+0x150>
if (c ++ == 'z')
c = 'a';
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
111ec4: 83 ec 0c sub $0xc,%esp
111ec7: 8b 45 d4 mov -0x2c(%ebp),%eax
111eca: ff 70 30 pushl 0x30(%eax)
111ecd: e8 ce 18 00 00 call 1137a0 <rtems_barrier_delete>
111ed2: 83 c4 10 add $0x10,%esp
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
111ed5: 83 ec 0c sub $0xc,%esp
111ed8: 8b 55 d4 mov -0x2c(%ebp),%edx
111edb: ff 72 2c pushl 0x2c(%edx)
111ede: e8 bd 18 00 00 call 1137a0 <rtems_barrier_delete>
111ee3: 83 c4 10 add $0x10,%esp
err_rbar:
free(pipe->Buffer);
111ee6: 83 ec 0c sub $0xc,%esp
111ee9: 8b 45 d4 mov -0x2c(%ebp),%eax
111eec: ff 30 pushl (%eax)
111eee: e8 dd 7a ff ff call 1099d0 <free>
111ef3: 83 c4 10 add $0x10,%esp
err_buf:
free(pipe);
111ef6: 83 ec 0c sub $0xc,%esp
111ef9: ff 75 d4 pushl -0x2c(%ebp)
111efc: e8 cf 7a ff ff call 1099d0 <free>
111f01: 83 c4 10 add $0x10,%esp
)
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
111f04: bf f4 ff ff ff mov $0xfffffff4,%edi
111f09: eb 95 jmp 111ea0 <fifo_open+0x400>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
111f0b: a1 0c a4 12 00 mov 0x12a40c,%eax
111f10: e9 a4 fb ff ff jmp 111ab9 <fifo_open+0x19>
0010ffcc <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)
{
10ffcc: 55 push %ebp
10ffcd: 89 e5 mov %esp,%ebp
10ffcf: 56 push %esi
10ffd0: 53 push %ebx
10ffd1: 8b 75 08 mov 0x8(%ebp),%esi
10ffd4: 8b 5d 0c mov 0xc(%ebp),%ebx
find_arg *fa = arg;
if ( strcmp( entry->type, fa->type ) != 0 ) {
10ffd7: 83 ec 08 sub $0x8,%esp
10ffda: ff 33 pushl (%ebx)
10ffdc: ff 36 pushl (%esi)
10ffde: e8 f9 3e 00 00 call 113edc <strcmp>
10ffe3: 83 c4 10 add $0x10,%esp
10ffe6: 85 c0 test %eax,%eax
10ffe8: 75 12 jne 10fffc <find_handler+0x30>
return false;
} else {
fa->mount_h = entry->mount_h;
10ffea: 8b 46 04 mov 0x4(%esi),%eax
10ffed: 89 43 04 mov %eax,0x4(%ebx)
return true;
10fff0: b0 01 mov $0x1,%al
}
}
10fff2: 8d 65 f8 lea -0x8(%ebp),%esp
10fff5: 5b pop %ebx
10fff6: 5e pop %esi
10fff7: c9 leave
10fff8: c3 ret
10fff9: 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;
10fffc: 31 c0 xor %eax,%eax
} else {
fa->mount_h = entry->mount_h;
return true;
}
}
10fffe: 8d 65 f8 lea -0x8(%ebp),%esp
110001: 5b pop %ebx
110002: 5e pop %esi
110003: c9 leave
110004: c3 ret
00108d20 <fpathconf>:
long fpathconf(
int fd,
int name
)
{
108d20: 55 push %ebp
108d21: 89 e5 mov %esp,%ebp
108d23: 83 ec 08 sub $0x8,%esp
108d26: 8b 45 08 mov 0x8(%ebp),%eax
108d29: 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);
108d2c: 3b 05 ac 55 12 00 cmp 0x1255ac,%eax
108d32: 0f 83 ac 00 00 00 jae 108de4 <fpathconf+0xc4>
iop = rtems_libio_iop(fd);
108d38: 8d 0c c5 00 00 00 00 lea 0x0(,%eax,8),%ecx
108d3f: 8d 04 cd 00 00 00 00 lea 0x0(,%ecx,8),%eax
108d46: 29 c8 sub %ecx,%eax
108d48: 03 05 60 98 12 00 add 0x129860,%eax
rtems_libio_check_is_open(iop);
108d4e: 8b 48 14 mov 0x14(%eax),%ecx
108d51: f6 c5 01 test $0x1,%ch
108d54: 0f 84 8a 00 00 00 je 108de4 <fpathconf+0xc4> <== NEVER TAKEN
rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ);
108d5a: 83 e1 02 and $0x2,%ecx
108d5d: 74 08 je 108d67 <fpathconf+0x47>
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
108d5f: 8b 40 28 mov 0x28(%eax),%eax
switch ( name ) {
108d62: 83 fa 0b cmp $0xb,%edx
108d65: 76 15 jbe 108d7c <fpathconf+0x5c>
break;
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
108d67: e8 64 b6 00 00 call 1143d0 <__errno>
108d6c: c7 00 16 00 00 00 movl $0x16,(%eax)
108d72: b8 ff ff ff ff mov $0xffffffff,%eax
break;
}
return return_value;
}
108d77: c9 leave
108d78: c3 ret
108d79: 8d 76 00 lea 0x0(%esi),%esi
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
108d7c: ff 24 95 18 2f 12 00 jmp *0x122f18(,%edx,4)
108d83: 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;
108d84: 8b 40 5c mov 0x5c(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108d87: c9 leave
108d88: c3 ret
108d89: 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;
108d8c: 8b 40 50 mov 0x50(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108d8f: c9 leave
108d90: c3 ret
108d91: 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;
108d94: 8b 40 64 mov 0x64(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108d97: c9 leave
108d98: c3 ret
108d99: 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;
108d9c: 8b 40 58 mov 0x58(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108d9f: c9 leave
108da0: c3 ret
108da1: 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;
108da4: 8b 40 54 mov 0x54(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108da7: c9 leave
108da8: c3 ret
108da9: 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;
108dac: 8b 40 4c mov 0x4c(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108daf: c9 leave
108db0: c3 ret
108db1: 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;
108db4: 8b 40 48 mov 0x48(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108db7: c9 leave
108db8: c3 ret
108db9: 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;
108dbc: 8b 40 44 mov 0x44(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108dbf: c9 leave
108dc0: c3 ret
108dc1: 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;
108dc4: 8b 40 40 mov 0x40(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108dc7: c9 leave
108dc8: c3 ret
108dc9: 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;
108dcc: 8b 40 3c mov 0x3c(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108dcf: c9 leave
108dd0: c3 ret
108dd1: 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;
108dd4: 8b 40 38 mov 0x38(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108dd7: c9 leave
108dd8: c3 ret
108dd9: 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;
108ddc: 8b 40 60 mov 0x60(%eax),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108ddf: c9 leave
108de0: c3 ret
108de1: 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);
108de4: e8 e7 b5 00 00 call 1143d0 <__errno>
108de9: c7 00 09 00 00 00 movl $0x9,(%eax)
108def: b8 ff ff ff ff mov $0xffffffff,%eax
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return return_value;
}
108df4: c9 leave
108df5: c3 ret
001080b4 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
1080b4: 55 push %ebp
1080b5: 89 e5 mov %esp,%ebp
1080b7: 53 push %ebx
1080b8: 83 ec 04 sub $0x4,%esp
1080bb: 8b 5d 08 mov 0x8(%ebp),%ebx
MSBUMP(free_calls, 1);
1080be: ff 05 4c 7c 12 00 incl 0x127c4c
if ( !ptr )
1080c4: 85 db test %ebx,%ebx
1080c6: 74 4b je 108113 <free+0x5f>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
1080c8: 83 3d 20 7f 12 00 03 cmpl $0x3,0x127f20
1080cf: 74 47 je 108118 <free+0x64> <== ALWAYS TAKEN
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
1080d1: a1 e8 5f 12 00 mov 0x125fe8,%eax
1080d6: 85 c0 test %eax,%eax
1080d8: 74 0a je 1080e4 <free+0x30>
(*rtems_malloc_statistics_helpers->at_free)(ptr);
1080da: 83 ec 0c sub $0xc,%esp
1080dd: 53 push %ebx
1080de: ff 50 08 call *0x8(%eax)
1080e1: 83 c4 10 add $0x10,%esp
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
1080e4: 83 ec 08 sub $0x8,%esp
1080e7: 53 push %ebx
1080e8: ff 35 b0 39 12 00 pushl 0x1239b0
1080ee: e8 31 50 00 00 call 10d124 <_Protected_heap_Free>
1080f3: 83 c4 10 add $0x10,%esp
1080f6: 84 c0 test %al,%al
1080f8: 75 19 jne 108113 <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
1080fa: a1 b0 39 12 00 mov 0x1239b0,%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",
1080ff: ff 70 1c pushl 0x1c(%eax)
108102: ff 70 18 pushl 0x18(%eax)
108105: 53 push %ebx
108106: 68 10 13 12 00 push $0x121310
10810b: e8 8c 0d 00 00 call 108e9c <printk>
108110: 83 c4 10 add $0x10,%esp
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
108113: 8b 5d fc mov -0x4(%ebp),%ebx
108116: c9 leave
108117: 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() ) {
108118: e8 3b 01 00 00 call 108258 <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()) &&
10811d: 84 c0 test %al,%al
10811f: 75 b0 jne 1080d1 <free+0x1d>
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
108121: 89 5d 08 mov %ebx,0x8(%ebp)
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
108124: 8b 5d fc mov -0x4(%ebp),%ebx
108127: 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);
108128: e9 97 01 00 00 jmp 1082c4 <malloc_deferred_free>
00109550 <free_user_env>:
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
109550: 55 push %ebp
109551: 89 e5 mov %esp,%ebp
109553: 53 push %ebx
109554: 83 ec 04 sub $0x4,%esp
109557: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
10955a: 81 fb c0 85 12 00 cmp $0x1285c0,%ebx
109560: 74 26 je 109588 <free_user_env+0x38> <== NEVER TAKEN
#ifdef HAVE_USERENV_REFCNT
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
109562: 83 ec 0c sub $0xc,%esp
109565: 8d 43 04 lea 0x4(%ebx),%eax
109568: 50 push %eax
109569: e8 72 ef ff ff call 1084e0 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &env->root_directory);
10956e: 8d 43 18 lea 0x18(%ebx),%eax
109571: 89 04 24 mov %eax,(%esp)
109574: e8 67 ef ff ff call 1084e0 <rtems_filesystem_freenode>
free(env);
109579: 83 c4 10 add $0x10,%esp
10957c: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
10957f: 8b 5d fc mov -0x4(%ebp),%ebx
109582: c9 leave
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
rtems_filesystem_freenode( &env->root_directory);
free(env);
109583: e9 6c ef ff ff jmp 1084f4 <free>
}
}
109588: 8b 5d fc mov -0x4(%ebp),%ebx
10958b: c9 leave <== NOT EXECUTED
10958c: c3 ret <== NOT EXECUTED
0011efbc <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
11efbc: 55 push %ebp
11efbd: 89 e5 mov %esp,%ebp
11efbf: 57 push %edi
11efc0: 53 push %ebx
11efc1: 8b 45 08 mov 0x8(%ebp),%eax
11efc4: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_libio_t *iop;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
11efc7: 85 db test %ebx,%ebx
11efc9: 74 55 je 11f020 <fstat+0x64>
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
11efcb: 3b 05 6c 39 12 00 cmp 0x12396c,%eax
11efd1: 73 39 jae 11f00c <fstat+0x50>
11efd3: c1 e0 03 shl $0x3,%eax
11efd6: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
11efdd: 29 c2 sub %eax,%edx
11efdf: 03 15 20 7c 12 00 add 0x127c20,%edx
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
11efe5: f6 42 15 01 testb $0x1,0x15(%edx)
11efe9: 74 21 je 11f00c <fstat+0x50>
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
11efeb: b9 48 00 00 00 mov $0x48,%ecx
11eff0: 31 c0 xor %eax,%eax
11eff2: 89 df mov %ebx,%edi
11eff4: f3 aa rep stos %al,%es:(%edi)
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
11eff6: 8b 42 20 mov 0x20(%edx),%eax
11eff9: 89 5d 0c mov %ebx,0xc(%ebp)
11effc: 83 c2 18 add $0x18,%edx
11efff: 89 55 08 mov %edx,0x8(%ebp)
11f002: 8b 40 18 mov 0x18(%eax),%eax
}
11f005: 5b pop %ebx
11f006: 5f pop %edi
11f007: 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 );
11f008: ff e0 jmp *%eax
11f00a: 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);
11f00c: e8 5f 42 ff ff call 113270 <__errno>
11f011: 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 );
}
11f017: b8 ff ff ff ff mov $0xffffffff,%eax
11f01c: 5b pop %ebx
11f01d: 5f pop %edi
11f01e: c9 leave
11f01f: c3 ret
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
rtems_set_errno_and_return_minus_one( EFAULT );
11f020: e8 4b 42 ff ff call 113270 <__errno>
11f025: c7 00 0e 00 00 00 movl $0xe,(%eax)
11f02b: eb ea jmp 11f017 <fstat+0x5b>
00108f14 <fsync>:
#include <rtems/seterr.h>
int fsync(
int fd
)
{
108f14: 55 push %ebp
108f15: 89 e5 mov %esp,%ebp
108f17: 83 ec 08 sub $0x8,%esp
108f1a: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
108f1d: 3b 05 ac 55 12 00 cmp 0x1255ac,%eax
108f23: 73 2f jae 108f54 <fsync+0x40>
iop = rtems_libio_iop( fd );
108f25: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
108f2c: 8d 04 d5 00 00 00 00 lea 0x0(,%edx,8),%eax
108f33: 29 d0 sub %edx,%eax
108f35: 03 05 60 98 12 00 add 0x129860,%eax
rtems_libio_check_is_open(iop);
108f3b: 8b 50 14 mov 0x14(%eax),%edx
108f3e: f6 c6 01 test $0x1,%dh
108f41: 74 11 je 108f54 <fsync+0x40>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
108f43: 83 e2 04 and $0x4,%edx
108f46: 74 20 je 108f68 <fsync+0x54>
/*
* Now process the fsync().
*/
return (*iop->pathinfo.handlers->fsync_h)( iop );
108f48: 8b 50 20 mov 0x20(%eax),%edx
108f4b: 89 45 08 mov %eax,0x8(%ebp)
108f4e: 8b 42 28 mov 0x28(%edx),%eax
}
108f51: c9 leave
/*
* Now process the fsync().
*/
return (*iop->pathinfo.handlers->fsync_h)( iop );
108f52: ff e0 jmp *%eax
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
108f54: e8 77 b4 00 00 call 1143d0 <__errno>
108f59: c7 00 09 00 00 00 movl $0x9,(%eax)
/*
* Now process the fsync().
*/
return (*iop->pathinfo.handlers->fsync_h)( iop );
}
108f5f: b8 ff ff ff ff mov $0xffffffff,%eax
108f64: c9 leave
108f65: c3 ret
108f66: 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 );
108f68: e8 63 b4 00 00 call 1143d0 <__errno>
108f6d: c7 00 16 00 00 00 movl $0x16,(%eax)
108f73: eb ea jmp 108f5f <fsync+0x4b>
0010fcbc <ftruncate>:
int ftruncate(
int fd,
off_t length
)
{
10fcbc: 55 push %ebp
10fcbd: 89 e5 mov %esp,%ebp
10fcbf: 57 push %edi
10fcc0: 56 push %esi
10fcc1: 53 push %ebx
10fcc2: 83 ec 3c sub $0x3c,%esp
10fcc5: 8b 45 08 mov 0x8(%ebp),%eax
10fcc8: 8b 55 0c mov 0xc(%ebp),%edx
10fccb: 8b 4d 10 mov 0x10(%ebp),%ecx
10fcce: 89 55 c0 mov %edx,-0x40(%ebp)
10fcd1: 89 4d c4 mov %ecx,-0x3c(%ebp)
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
10fcd4: 3b 05 6c 39 12 00 cmp 0x12396c,%eax
10fcda: 73 58 jae 10fd34 <ftruncate+0x78>
iop = rtems_libio_iop( fd );
10fcdc: c1 e0 03 shl $0x3,%eax
10fcdf: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx
10fce6: 29 c3 sub %eax,%ebx
10fce8: 03 1d 20 7c 12 00 add 0x127c20,%ebx
rtems_libio_check_is_open(iop);
10fcee: f6 43 15 01 testb $0x1,0x15(%ebx)
10fcf2: 74 40 je 10fd34 <ftruncate+0x78>
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
10fcf4: 8d 7d d4 lea -0x2c(%ebp),%edi
10fcf7: 8d 73 18 lea 0x18(%ebx),%esi
10fcfa: b9 05 00 00 00 mov $0x5,%ecx
10fcff: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
10fd01: 83 ec 0c sub $0xc,%esp
10fd04: 8d 45 d4 lea -0x2c(%ebp),%eax
10fd07: 50 push %eax
10fd08: 8b 45 e0 mov -0x20(%ebp),%eax
10fd0b: ff 50 10 call *0x10(%eax)
10fd0e: 83 c4 10 add $0x10,%esp
10fd11: 48 dec %eax
10fd12: 74 46 je 10fd5a <ftruncate+0x9e>
rtems_set_errno_and_return_minus_one( EISDIR );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
10fd14: f6 43 14 04 testb $0x4,0x14(%ebx)
10fd18: 74 2e je 10fd48 <ftruncate+0x8c>
return (*iop->pathinfo.handlers->ftruncate_h)( iop, length );
10fd1a: 50 push %eax
10fd1b: 8b 43 20 mov 0x20(%ebx),%eax
10fd1e: ff 75 c4 pushl -0x3c(%ebp)
10fd21: ff 75 c0 pushl -0x40(%ebp)
10fd24: 53 push %ebx
10fd25: ff 50 20 call *0x20(%eax)
10fd28: 83 c4 10 add $0x10,%esp
}
10fd2b: 8d 65 f4 lea -0xc(%ebp),%esp
10fd2e: 5b pop %ebx
10fd2f: 5e pop %esi
10fd30: 5f pop %edi
10fd31: c9 leave
10fd32: c3 ret
10fd33: 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);
10fd34: e8 37 35 00 00 call 113270 <__errno>
10fd39: c7 00 09 00 00 00 movl $0x9,(%eax)
10fd3f: b8 ff ff ff ff mov $0xffffffff,%eax
10fd44: eb e5 jmp 10fd2b <ftruncate+0x6f>
10fd46: 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 );
10fd48: e8 23 35 00 00 call 113270 <__errno>
10fd4d: c7 00 16 00 00 00 movl $0x16,(%eax)
10fd53: b8 ff ff ff ff mov $0xffffffff,%eax
10fd58: eb d1 jmp 10fd2b <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 );
10fd5a: e8 11 35 00 00 call 113270 <__errno>
10fd5f: c7 00 15 00 00 00 movl $0x15,(%eax)
10fd65: b8 ff ff ff ff mov $0xffffffff,%eax
10fd6a: eb bf jmp 10fd2b <ftruncate+0x6f>
00108300 <getchark>:
#include <rtems.h>
#include <rtems/bspIo.h>
int getchark(void)
{
108300: 55 push %ebp
108301: 89 e5 mov %esp,%ebp
108303: 83 ec 08 sub $0x8,%esp
if ( BSP_poll_char )
108306: a1 8c 3e 12 00 mov 0x123e8c,%eax
10830b: 85 c0 test %eax,%eax
10830d: 74 05 je 108314 <getchark+0x14>
return (*BSP_poll_char)();
return -1;
}
10830f: c9 leave
#include <rtems/bspIo.h>
int getchark(void)
{
if ( BSP_poll_char )
return (*BSP_poll_char)();
108310: ff e0 jmp *%eax
108312: 66 90 xchg %ax,%ax
return -1;
}
108314: b8 ff ff ff ff mov $0xffffffff,%eax
108319: c9 leave
10831a: c3 ret
001209b0 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
1209b0: 55 push %ebp
1209b1: 89 e5 mov %esp,%ebp
1209b3: 57 push %edi
1209b4: 56 push %esi
1209b5: 53 push %ebx
1209b6: 83 ec 2c sub $0x2c,%esp
1209b9: 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 );
1209bc: 3b 05 8c 64 12 00 cmp 0x12648c,%eax
1209c2: 73 4c jae 120a10 <getdents+0x60> <== NEVER TAKEN
1209c4: c1 e0 03 shl $0x3,%eax
1209c7: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx
1209ce: 29 c3 sub %eax,%ebx
1209d0: 03 1d 80 a8 12 00 add 0x12a880,%ebx
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
1209d6: 8d 7d d4 lea -0x2c(%ebp),%edi
1209d9: 8d 73 18 lea 0x18(%ebx),%esi
1209dc: b9 05 00 00 00 mov $0x5,%ecx
1209e1: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
1209e3: 83 ec 0c sub $0xc,%esp
1209e6: 8d 45 d4 lea -0x2c(%ebp),%eax
1209e9: 50 push %eax
1209ea: 8b 45 e0 mov -0x20(%ebp),%eax
1209ed: ff 50 10 call *0x10(%eax)
1209f0: 83 c4 10 add $0x10,%esp
1209f3: 48 dec %eax
1209f4: 75 1e jne 120a14 <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 );
1209f6: 50 push %eax
1209f7: 8b 43 20 mov 0x20(%ebx),%eax
1209fa: ff 75 10 pushl 0x10(%ebp)
1209fd: ff 75 0c pushl 0xc(%ebp)
120a00: 53 push %ebx
120a01: ff 50 08 call *0x8(%eax)
120a04: 83 c4 10 add $0x10,%esp
}
120a07: 8d 65 f4 lea -0xc(%ebp),%esp
120a0a: 5b pop %ebx
120a0b: 5e pop %esi
120a0c: 5f pop %edi
120a0d: c9 leave
120a0e: c3 ret
120a0f: 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 );
120a10: 31 db xor %ebx,%ebx
120a12: eb c2 jmp 1209d6 <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 );
120a14: e8 a7 38 ff ff call 1142c0 <__errno>
120a19: c7 00 14 00 00 00 movl $0x14,(%eax)
120a1f: b8 ff ff ff ff mov $0xffffffff,%eax
120a24: eb e1 jmp 120a07 <getdents+0x57>
00108b34 <getgr_r>:
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
108b34: 55 push %ebp
108b35: 89 e5 mov %esp,%ebp
108b37: 57 push %edi
108b38: 56 push %esi
108b39: 53 push %ebx
108b3a: 83 ec 1c sub $0x1c,%esp
108b3d: 89 c3 mov %eax,%ebx
108b3f: 89 55 e4 mov %edx,-0x1c(%ebp)
108b42: 89 ce mov %ecx,%esi
FILE *fp;
int match;
init_etc_passwd_group();
108b44: e8 eb fe ff ff call 108a34 <init_etc_passwd_group>
if ((fp = fopen("/etc/group", "r")) == NULL)
108b49: 83 ec 08 sub $0x8,%esp
108b4c: 68 d2 17 12 00 push $0x1217d2
108b51: 68 b9 2c 12 00 push $0x122cb9
108b56: e8 d1 bd 00 00 call 11492c <fopen>
108b5b: 89 c7 mov %eax,%edi
108b5d: 83 c4 10 add $0x10,%esp
108b60: 85 c0 test %eax,%eax
108b62: 75 22 jne 108b86 <getgr_r+0x52>
108b64: e9 8b 00 00 00 jmp 108bf4 <getgr_r+0xc0>
108b69: 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);
108b6c: 83 ec 08 sub $0x8,%esp
108b6f: 53 push %ebx
108b70: ff 36 pushl (%esi)
108b72: e8 35 cc 00 00 call 1157ac <strcmp>
108b77: 83 c4 10 add $0x10,%esp
108b7a: 85 c0 test %eax,%eax
108b7c: 0f 94 c0 sete %al
108b7f: 0f b6 c0 movzbl %al,%eax
} else {
match = (grp->gr_gid == gid);
}
if (match) {
108b82: 85 c0 test %eax,%eax
108b84: 75 2e jne 108bb4 <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))
108b86: 83 ec 0c sub $0xc,%esp
108b89: ff 75 0c pushl 0xc(%ebp)
108b8c: 8b 4d 08 mov 0x8(%ebp),%ecx
108b8f: 89 f2 mov %esi,%edx
108b91: 89 f8 mov %edi,%eax
108b93: e8 88 fc ff ff call 108820 <scangr>
108b98: 83 c4 10 add $0x10,%esp
108b9b: 85 c0 test %eax,%eax
108b9d: 74 31 je 108bd0 <getgr_r+0x9c>
goto error_einval;
if (name) {
108b9f: 85 db test %ebx,%ebx
108ba1: 75 c9 jne 108b6c <getgr_r+0x38>
match = (strcmp(grp->gr_name, name) == 0);
} else {
match = (grp->gr_gid == gid);
108ba3: 0f b7 46 08 movzwl 0x8(%esi),%eax
108ba7: 3b 45 e4 cmp -0x1c(%ebp),%eax
108baa: 0f 94 c0 sete %al
108bad: 0f b6 c0 movzbl %al,%eax
}
if (match) {
108bb0: 85 c0 test %eax,%eax
108bb2: 74 d2 je 108b86 <getgr_r+0x52>
fclose(fp);
108bb4: 83 ec 0c sub $0xc,%esp
108bb7: 57 push %edi
108bb8: e8 6b b6 00 00 call 114228 <fclose>
*result = grp;
108bbd: 8b 45 10 mov 0x10(%ebp),%eax
108bc0: 89 30 mov %esi,(%eax)
return 0;
108bc2: 83 c4 10 add $0x10,%esp
108bc5: 31 c0 xor %eax,%eax
}
}
error_einval:
fclose(fp);
rtems_set_errno_and_return_minus_one( EINVAL );
}
108bc7: 8d 65 f4 lea -0xc(%ebp),%esp
108bca: 5b pop %ebx
108bcb: 5e pop %esi
108bcc: 5f pop %edi
108bcd: c9 leave
108bce: c3 ret
108bcf: 90 nop
*result = grp;
return 0;
}
}
error_einval:
fclose(fp);
108bd0: 83 ec 0c sub $0xc,%esp
108bd3: 57 push %edi
108bd4: e8 4f b6 00 00 call 114228 <fclose>
rtems_set_errno_and_return_minus_one( EINVAL );
108bd9: e8 f2 b4 00 00 call 1140d0 <__errno>
108bde: c7 00 16 00 00 00 movl $0x16,(%eax)
108be4: 83 c4 10 add $0x10,%esp
108be7: b8 ff ff ff ff mov $0xffffffff,%eax
}
108bec: 8d 65 f4 lea -0xc(%ebp),%esp
108bef: 5b pop %ebx
108bf0: 5e pop %esi
108bf1: 5f pop %edi
108bf2: c9 leave
108bf3: c3 ret
int match;
init_etc_passwd_group();
if ((fp = fopen("/etc/group", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
108bf4: e8 d7 b4 00 00 call 1140d0 <__errno>
108bf9: c7 00 16 00 00 00 movl $0x16,(%eax)
108bff: 83 c8 ff or $0xffffffff,%eax
108c02: eb c3 jmp 108bc7 <getgr_r+0x93>
00108e58 <getgrnam>:
}
struct group *getgrnam(
const char *name
)
{
108e58: 55 push %ebp
108e59: 89 e5 mov %esp,%ebp
108e5b: 83 ec 24 sub $0x24,%esp
struct group *p;
if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p))
108e5e: 8d 45 f4 lea -0xc(%ebp),%eax
108e61: 50 push %eax
108e62: 68 c8 00 00 00 push $0xc8
108e67: 68 20 93 12 00 push $0x129320
108e6c: 68 04 93 12 00 push $0x129304
108e71: ff 75 08 pushl 0x8(%ebp)
108e74: e8 b3 ff ff ff call 108e2c <getgrnam_r>
108e79: 83 c4 20 add $0x20,%esp
108e7c: 85 c0 test %eax,%eax
108e7e: 75 08 jne 108e88 <getgrnam+0x30>
return NULL;
return p;
108e80: 8b 45 f4 mov -0xc(%ebp),%eax
}
108e83: c9 leave
108e84: c3 ret
108e85: 8d 76 00 lea 0x0(%esi),%esi
)
{
struct group *p;
if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p))
return NULL;
108e88: 31 c0 xor %eax,%eax
return p;
}
108e8a: c9 leave
108e8b: c3 ret
0010b234 <getitimer>:
int getitimer(
int which,
struct itimerval *value
)
{
10b234: 55 push %ebp
10b235: 89 e5 mov %esp,%ebp
10b237: 83 ec 08 sub $0x8,%esp
if ( !value )
10b23a: 8b 45 0c mov 0xc(%ebp),%eax
10b23d: 85 c0 test %eax,%eax
10b23f: 74 2f je 10b270 <getitimer+0x3c>
rtems_set_errno_and_return_minus_one( EFAULT );
switch ( which ) {
10b241: 83 7d 08 02 cmpl $0x2,0x8(%ebp)
10b245: 76 15 jbe 10b25c <getitimer+0x28>
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10b247: e8 34 87 00 00 call 113980 <__errno>
10b24c: c7 00 16 00 00 00 movl $0x16,(%eax)
}
10b252: b8 ff ff ff ff mov $0xffffffff,%eax
10b257: c9 leave
10b258: c3 ret
10b259: 8d 76 00 lea 0x0(%esi),%esi
switch ( which ) {
case ITIMER_REAL:
case ITIMER_VIRTUAL:
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
10b25c: e8 1f 87 00 00 call 113980 <__errno>
10b261: c7 00 58 00 00 00 movl $0x58,(%eax)
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10b267: b8 ff ff ff ff mov $0xffffffff,%eax
10b26c: c9 leave
10b26d: c3 ret
10b26e: 66 90 xchg %ax,%ax
int which,
struct itimerval *value
)
{
if ( !value )
rtems_set_errno_and_return_minus_one( EFAULT );
10b270: e8 0b 87 00 00 call 113980 <__errno>
10b275: c7 00 0e 00 00 00 movl $0xe,(%eax)
10b27b: eb d5 jmp 10b252 <getitimer+0x1e>
001085f8 <getlogin_r>:
*/
int getlogin_r(
char *name,
size_t namesize
)
{
1085f8: 55 push %ebp
1085f9: 89 e5 mov %esp,%ebp
1085fb: 53 push %ebx
1085fc: 83 ec 04 sub $0x4,%esp
1085ff: 8b 5d 08 mov 0x8(%ebp),%ebx
struct passwd *pw;
char *pname;
if ( !name )
108602: 85 db test %ebx,%ebx
108604: 74 42 je 108648 <getlogin_r+0x50>
return EFAULT;
if ( namesize < LOGIN_NAME_MAX )
108606: 83 7d 0c 08 cmpl $0x8,0xc(%ebp)
10860a: 77 0c ja 108618 <getlogin_r+0x20>
return ERANGE;
10860c: b8 22 00 00 00 mov $0x22,%eax
if ( pw )
pname = pw->pw_name;
strncpy( name, pname, LOGIN_NAME_MAX );
return 0;
}
108611: 8b 5d fc mov -0x4(%ebp),%ebx
108614: c9 leave
108615: c3 ret
108616: 66 90 xchg %ax,%ax
return ERANGE;
/* Set the pointer to a default name */
pname = "";
pw = getpwuid(getuid());
108618: e8 e7 09 00 00 call 109004 <getuid>
10861d: 83 ec 0c sub $0xc,%esp
108620: 0f b7 c0 movzwl %ax,%eax
108623: 50 push %eax
108624: e8 37 07 00 00 call 108d60 <getpwuid>
if ( pw )
108629: 83 c4 10 add $0x10,%esp
10862c: 85 c0 test %eax,%eax
10862e: 74 20 je 108650 <getlogin_r+0x58>
pname = pw->pw_name;
108630: 8b 00 mov (%eax),%eax
strncpy( name, pname, LOGIN_NAME_MAX );
108632: 52 push %edx
108633: 6a 09 push $0x9
108635: 50 push %eax
108636: 53 push %ebx
108637: e8 f0 d2 00 00 call 11592c <strncpy>
return 0;
10863c: 83 c4 10 add $0x10,%esp
10863f: 31 c0 xor %eax,%eax
}
108641: 8b 5d fc mov -0x4(%ebp),%ebx
108644: c9 leave
108645: c3 ret
108646: 66 90 xchg %ax,%ax
{
struct passwd *pw;
char *pname;
if ( !name )
return EFAULT;
108648: b8 0e 00 00 00 mov $0xe,%eax
10864d: eb c2 jmp 108611 <getlogin_r+0x19>
10864f: 90 nop
if ( namesize < LOGIN_NAME_MAX )
return ERANGE;
/* Set the pointer to a default name */
pname = "";
108650: b8 09 2e 12 00 mov $0x122e09,%eax
108655: eb db jmp 108632 <getlogin_r+0x3a>
00108c04 <getpw_r>:
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
108c04: 55 push %ebp
108c05: 89 e5 mov %esp,%ebp
108c07: 57 push %edi
108c08: 56 push %esi
108c09: 53 push %ebx
108c0a: 83 ec 1c sub $0x1c,%esp
108c0d: 89 c3 mov %eax,%ebx
108c0f: 89 55 e4 mov %edx,-0x1c(%ebp)
108c12: 89 ce mov %ecx,%esi
FILE *fp;
int match;
init_etc_passwd_group();
108c14: e8 1b fe ff ff call 108a34 <init_etc_passwd_group>
if ((fp = fopen("/etc/passwd", "r")) == NULL)
108c19: 83 ec 08 sub $0x8,%esp
108c1c: 68 d2 17 12 00 push $0x1217d2
108c21: 68 ad 2c 12 00 push $0x122cad
108c26: e8 01 bd 00 00 call 11492c <fopen>
108c2b: 89 c7 mov %eax,%edi
108c2d: 83 c4 10 add $0x10,%esp
108c30: 85 c0 test %eax,%eax
108c32: 75 22 jne 108c56 <getpw_r+0x52>
108c34: e9 8b 00 00 00 jmp 108cc4 <getpw_r+0xc0>
108c39: 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);
108c3c: 83 ec 08 sub $0x8,%esp
108c3f: 53 push %ebx
108c40: ff 36 pushl (%esi)
108c42: e8 65 cb 00 00 call 1157ac <strcmp>
108c47: 83 c4 10 add $0x10,%esp
108c4a: 85 c0 test %eax,%eax
108c4c: 0f 94 c0 sete %al
108c4f: 0f b6 c0 movzbl %al,%eax
} else {
match = (pwd->pw_uid == uid);
}
if (match) {
108c52: 85 c0 test %eax,%eax
108c54: 75 2e jne 108c84 <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))
108c56: 83 ec 0c sub $0xc,%esp
108c59: ff 75 0c pushl 0xc(%ebp)
108c5c: 8b 4d 08 mov 0x8(%ebp),%ecx
108c5f: 89 f2 mov %esi,%edx
108c61: 89 f8 mov %edi,%eax
108c63: e8 d0 fc ff ff call 108938 <scanpw>
108c68: 83 c4 10 add $0x10,%esp
108c6b: 85 c0 test %eax,%eax
108c6d: 74 31 je 108ca0 <getpw_r+0x9c>
goto error_einval;
if (name) {
108c6f: 85 db test %ebx,%ebx
108c71: 75 c9 jne 108c3c <getpw_r+0x38>
match = (strcmp(pwd->pw_name, name) == 0);
} else {
match = (pwd->pw_uid == uid);
108c73: 0f b7 46 08 movzwl 0x8(%esi),%eax
108c77: 3b 45 e4 cmp -0x1c(%ebp),%eax
108c7a: 0f 94 c0 sete %al
108c7d: 0f b6 c0 movzbl %al,%eax
}
if (match) {
108c80: 85 c0 test %eax,%eax
108c82: 74 d2 je 108c56 <getpw_r+0x52>
fclose(fp);
108c84: 83 ec 0c sub $0xc,%esp
108c87: 57 push %edi
108c88: e8 9b b5 00 00 call 114228 <fclose>
*result = pwd;
108c8d: 8b 45 10 mov 0x10(%ebp),%eax
108c90: 89 30 mov %esi,(%eax)
return 0;
108c92: 83 c4 10 add $0x10,%esp
108c95: 31 c0 xor %eax,%eax
}
}
error_einval:
fclose(fp);
rtems_set_errno_and_return_minus_one( EINVAL );
}
108c97: 8d 65 f4 lea -0xc(%ebp),%esp
108c9a: 5b pop %ebx
108c9b: 5e pop %esi
108c9c: 5f pop %edi
108c9d: c9 leave
108c9e: c3 ret
108c9f: 90 nop
*result = pwd;
return 0;
}
}
error_einval:
fclose(fp);
108ca0: 83 ec 0c sub $0xc,%esp
108ca3: 57 push %edi
108ca4: e8 7f b5 00 00 call 114228 <fclose>
rtems_set_errno_and_return_minus_one( EINVAL );
108ca9: e8 22 b4 00 00 call 1140d0 <__errno>
108cae: c7 00 16 00 00 00 movl $0x16,(%eax)
108cb4: 83 c4 10 add $0x10,%esp
108cb7: b8 ff ff ff ff mov $0xffffffff,%eax
}
108cbc: 8d 65 f4 lea -0xc(%ebp),%esp
108cbf: 5b pop %ebx
108cc0: 5e pop %esi
108cc1: 5f pop %edi
108cc2: c9 leave
108cc3: c3 ret
int match;
init_etc_passwd_group();
if ((fp = fopen("/etc/passwd", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
108cc4: e8 07 b4 00 00 call 1140d0 <__errno>
108cc9: c7 00 16 00 00 00 movl $0x16,(%eax)
108ccf: 83 c8 ff or $0xffffffff,%eax
108cd2: eb c3 jmp 108c97 <getpw_r+0x93>
00108d00 <getpwnam>:
}
struct passwd *getpwnam(
const char *name
)
{
108d00: 55 push %ebp
108d01: 89 e5 mov %esp,%ebp
108d03: 83 ec 24 sub $0x24,%esp
struct passwd *p;
if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p))
108d06: 8d 45 f4 lea -0xc(%ebp),%eax
108d09: 50 push %eax
108d0a: 68 c8 00 00 00 push $0xc8
108d0f: 68 20 94 12 00 push $0x129420
108d14: 68 ec 93 12 00 push $0x1293ec
108d19: ff 75 08 pushl 0x8(%ebp)
108d1c: e8 b3 ff ff ff call 108cd4 <getpwnam_r>
108d21: 83 c4 20 add $0x20,%esp
108d24: 85 c0 test %eax,%eax
108d26: 75 08 jne 108d30 <getpwnam+0x30>
return NULL;
return p;
108d28: 8b 45 f4 mov -0xc(%ebp),%eax
}
108d2b: c9 leave
108d2c: c3 ret
108d2d: 8d 76 00 lea 0x0(%esi),%esi
)
{
struct passwd *p;
if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p))
return NULL;
108d30: 31 c0 xor %eax,%eax
return p;
}
108d32: c9 leave
108d33: c3 ret
001126cc <imfs_dir_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
1126cc: 55 push %ebp
1126cd: 89 e5 mov %esp,%ebp
1126cf: 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 )
1126d2: 8b 50 18 mov 0x18(%eax),%edx
1126d5: 83 7a 4c 01 cmpl $0x1,0x4c(%edx)
1126d9: 74 09 je 1126e4 <imfs_dir_open+0x18> <== ALWAYS TAKEN
return -1; /* It wasn't a directory --> return error */
1126db: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
iop->offset = 0;
return 0;
}
1126e0: c9 leave <== NOT EXECUTED
1126e1: c3 ret <== NOT EXECUTED
1126e2: 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;
1126e4: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
1126eb: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
return 0;
1126f2: 31 c0 xor %eax,%eax
}
1126f4: c9 leave
1126f5: c3 ret
001126f8 <imfs_dir_read>:
ssize_t imfs_dir_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
1126f8: 55 push %ebp
1126f9: 89 e5 mov %esp,%ebp
1126fb: 57 push %edi
1126fc: 56 push %esi
1126fd: 53 push %ebx
1126fe: 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;
112704: 8b 55 08 mov 0x8(%ebp),%edx
112707: 8b 42 18 mov 0x18(%edx),%eax
IMFS_create_orphan( the_jnode );
IMFS_check_node_remove( the_jnode );
return 0;
}
11270a: 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 );
11270d: 83 c0 54 add $0x54,%eax
112710: 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 ) )
112716: 39 c3 cmp %eax,%ebx
112718: 0f 84 2a 01 00 00 je 112848 <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;
11271e: 8b 42 0c mov 0xc(%edx),%eax
112721: 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);
112727: ba f1 f0 f0 f0 mov $0xf0f0f0f1,%edx
11272c: 8b 45 10 mov 0x10(%ebp),%eax
11272f: f7 e2 mul %edx
112731: c1 ea 08 shr $0x8,%edx
112734: 89 d0 mov %edx,%eax
112736: c1 e0 04 shl $0x4,%eax
112739: c1 e2 08 shl $0x8,%edx
11273c: 8d 14 10 lea (%eax,%edx,1),%edx
11273f: 03 95 d4 fe ff ff add -0x12c(%ebp),%edx
112745: 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 (
11274b: 85 d2 test %edx,%edx
11274d: 0f 8e f5 00 00 00 jle 112848 <imfs_dir_read+0x150> <== NEVER TAKEN
112753: 31 d2 xor %edx,%edx
112755: c7 85 c8 fe ff ff 00 movl $0x0,-0x138(%ebp)
11275c: 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 );
11275f: 8d 85 d8 fe ff ff lea -0x128(%ebp),%eax
112765: 89 85 b4 fe ff ff mov %eax,-0x14c(%ebp)
11276b: eb 23 jmp 112790 <imfs_dir_read+0x98>
11276d: 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;
112770: 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(
112772: 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 (
112778: 39 95 d0 fe ff ff cmp %edx,-0x130(%ebp)
11277e: 0f 8e b4 00 00 00 jle 112838 <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 ) ){
112784: 3b 9d cc fe ff ff cmp -0x134(%ebp),%ebx
11278a: 0f 84 a8 00 00 00 je 112838 <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 ) {
112790: 39 95 d4 fe ff ff cmp %edx,-0x12c(%ebp)
112796: 7f d8 jg 112770 <imfs_dir_read+0x78>
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
112798: 89 95 dc fe ff ff mov %edx,-0x124(%ebp)
11279e: 89 d0 mov %edx,%eax
1127a0: c1 f8 1f sar $0x1f,%eax
1127a3: 89 85 e0 fe ff ff mov %eax,-0x120(%ebp)
tmp_dirent.d_reclen = sizeof( struct dirent );
1127a9: 66 c7 85 e4 fe ff ff movw $0x110,-0x11c(%ebp)
1127b0: 10 01
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
1127b2: 8b 43 38 mov 0x38(%ebx),%eax
1127b5: 89 85 d8 fe ff ff mov %eax,-0x128(%ebp)
tmp_dirent.d_namlen = strlen( the_jnode->name );
1127bb: 8d 73 0c lea 0xc(%ebx),%esi
1127be: 31 c0 xor %eax,%eax
1127c0: b9 ff ff ff ff mov $0xffffffff,%ecx
1127c5: 89 f7 mov %esi,%edi
1127c7: f2 ae repnz scas %es:(%edi),%al
1127c9: f7 d1 not %ecx
1127cb: 49 dec %ecx
1127cc: 66 89 8d e6 fe ff ff mov %cx,-0x11a(%ebp)
strcpy( tmp_dirent.d_name, the_jnode->name );
1127d3: 83 ec 08 sub $0x8,%esp
1127d6: 56 push %esi
1127d7: 8d 85 e8 fe ff ff lea -0x118(%ebp),%eax
1127dd: 50 push %eax
1127de: 89 95 c4 fe ff ff mov %edx,-0x13c(%ebp)
1127e4: e8 4b 17 00 00 call 113f34 <strcpy>
memcpy(
1127e9: 8b 45 0c mov 0xc(%ebp),%eax
1127ec: 03 85 c8 fe ff ff add -0x138(%ebp),%eax
1127f2: b9 44 00 00 00 mov $0x44,%ecx
1127f7: 89 c7 mov %eax,%edi
1127f9: 8b b5 b4 fe ff ff mov -0x14c(%ebp),%esi
1127ff: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
buffer + bytes_transferred,
(void *)&tmp_dirent,
sizeof( struct dirent )
);
iop->offset = iop->offset + sizeof(struct dirent);
112801: 8b 45 08 mov 0x8(%ebp),%eax
112804: 81 40 0c 10 01 00 00 addl $0x110,0xc(%eax)
11280b: 83 50 10 00 adcl $0x0,0x10(%eax)
bytes_transferred = bytes_transferred + sizeof( struct dirent );
11280f: 81 85 c8 fe ff ff 10 addl $0x110,-0x138(%ebp)
112816: 01 00 00
112819: 83 c4 10 add $0x10,%esp
11281c: 8b 95 c4 fe ff ff mov -0x13c(%ebp),%edx
}
the_node = the_node->next;
112822: 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(
112824: 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 (
11282a: 39 95 d0 fe ff ff cmp %edx,-0x130(%ebp)
112830: 0f 8f 4e ff ff ff jg 112784 <imfs_dir_read+0x8c> <== NEVER TAKEN
112836: 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 ) ){
112838: 8b 85 c8 fe ff ff mov -0x138(%ebp),%eax
the_node = the_node->next;
}
/* Success */
return bytes_transferred;
}
11283e: 8d 65 f4 lea -0xc(%ebp),%esp
112841: 5b pop %ebx
112842: 5e pop %esi
112843: 5f pop %edi
112844: c9 leave
112845: c3 ret
112846: 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;
112848: 31 c0 xor %eax,%eax
the_node = the_node->next;
}
/* Success */
return bytes_transferred;
}
11284a: 8d 65 f4 lea -0xc(%ebp),%esp
11284d: 5b pop %ebx
11284e: 5e pop %esi
11284f: 5f pop %edi
112850: c9 leave
112851: c3 ret
00112984 <imfs_dir_rmnod>:
int imfs_dir_rmnod(
rtems_filesystem_location_info_t *parent_pathloc, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
112984: 55 push %ebp
112985: 89 e5 mov %esp,%ebp
112987: 53 push %ebx
112988: 83 ec 04 sub $0x4,%esp
11298b: 8b 45 0c mov 0xc(%ebp),%eax
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
11298e: 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 );
112990: 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 ) )
112993: 39 53 50 cmp %edx,0x50(%ebx)
112996: 75 44 jne 1129dc <imfs_dir_rmnod+0x58>
/*
* You cannot remove the file system root node.
*/
if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access )
112998: 8b 40 10 mov 0x10(%eax),%eax
11299b: 3b 58 1c cmp 0x1c(%eax),%ebx
11299e: 74 24 je 1129c4 <imfs_dir_rmnod+0x40>
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
1129a0: 8b 4b 5c mov 0x5c(%ebx),%ecx
1129a3: 85 c9 test %ecx,%ecx
1129a5: 75 1d jne 1129c4 <imfs_dir_rmnod+0x40> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EBUSY );
IMFS_create_orphan( the_jnode );
1129a7: 83 ec 0c sub $0xc,%esp
1129aa: 53 push %ebx
1129ab: e8 6c d0 ff ff call 10fa1c <IMFS_create_orphan>
IMFS_check_node_remove( the_jnode );
1129b0: 89 1c 24 mov %ebx,(%esp)
1129b3: e8 a8 d0 ff ff call 10fa60 <IMFS_check_node_remove>
return 0;
1129b8: 83 c4 10 add $0x10,%esp
1129bb: 31 c0 xor %eax,%eax
}
1129bd: 8b 5d fc mov -0x4(%ebp),%ebx
1129c0: c9 leave
1129c1: c3 ret
1129c2: 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 );
1129c4: e8 a7 08 00 00 call 113270 <__errno>
1129c9: c7 00 10 00 00 00 movl $0x10,(%eax)
1129cf: b8 ff ff ff ff mov $0xffffffff,%eax
IMFS_create_orphan( the_jnode );
IMFS_check_node_remove( the_jnode );
return 0;
}
1129d4: 8b 5d fc mov -0x4(%ebp),%ebx
1129d7: c9 leave
1129d8: c3 ret
1129d9: 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 );
1129dc: e8 8f 08 00 00 call 113270 <__errno>
1129e1: c7 00 5a 00 00 00 movl $0x5a,(%eax)
1129e7: b8 ff ff ff ff mov $0xffffffff,%eax
1129ec: eb cf jmp 1129bd <imfs_dir_rmnod+0x39>
00108a34 <init_etc_passwd_group>:
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
108a34: 55 push %ebp
108a35: 89 e5 mov %esp,%ebp
108a37: 53 push %ebx
108a38: 83 ec 04 sub $0x4,%esp
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
108a3b: 80 3d e8 94 12 00 00 cmpb $0x0,0x1294e8
108a42: 74 08 je 108a4c <init_etc_passwd_group+0x18>
fprintf( fp, "root:x:0:root\n"
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
}
}
108a44: 8b 5d fc mov -0x4(%ebp),%ebx
108a47: c9 leave
108a48: c3 ret
108a49: 8d 76 00 lea 0x0(%esi),%esi
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
108a4c: c6 05 e8 94 12 00 01 movb $0x1,0x1294e8
mkdir("/etc", 0777);
108a53: 83 ec 08 sub $0x8,%esp
108a56: 68 ff 01 00 00 push $0x1ff
108a5b: 68 a8 2c 12 00 push $0x122ca8
108a60: e8 37 08 00 00 call 10929c <mkdir>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
108a65: 59 pop %ecx
108a66: 5b pop %ebx
108a67: 68 d2 17 12 00 push $0x1217d2
108a6c: 68 ad 2c 12 00 push $0x122cad
108a71: e8 b6 be 00 00 call 11492c <fopen>
108a76: 83 c4 10 add $0x10,%esp
108a79: 85 c0 test %eax,%eax
108a7b: 74 77 je 108af4 <init_etc_passwd_group+0xc0>
fclose(fp);
108a7d: 83 ec 0c sub $0xc,%esp
108a80: 50 push %eax
108a81: e8 a2 b7 00 00 call 114228 <fclose>
108a86: 83 c4 10 add $0x10,%esp
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
108a89: 83 ec 08 sub $0x8,%esp
108a8c: 68 d2 17 12 00 push $0x1217d2
108a91: 68 b9 2c 12 00 push $0x122cb9
108a96: e8 91 be 00 00 call 11492c <fopen>
108a9b: 83 c4 10 add $0x10,%esp
108a9e: 85 c0 test %eax,%eax
108aa0: 74 12 je 108ab4 <init_etc_passwd_group+0x80>
fclose(fp);
108aa2: 83 ec 0c sub $0xc,%esp
108aa5: 50 push %eax
108aa6: e8 7d b7 00 00 call 114228 <fclose>
108aab: 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);
}
}
108aae: 8b 5d fc mov -0x4(%ebp),%ebx
108ab1: c9 leave
108ab2: c3 ret
108ab3: 90 nop
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
fclose(fp);
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
108ab4: 83 ec 08 sub $0x8,%esp
108ab7: 68 b4 16 12 00 push $0x1216b4
108abc: 68 b9 2c 12 00 push $0x122cb9
108ac1: e8 66 be 00 00 call 11492c <fopen>
108ac6: 89 c3 mov %eax,%ebx
108ac8: 83 c4 10 add $0x10,%esp
108acb: 85 c0 test %eax,%eax
108acd: 0f 84 71 ff ff ff je 108a44 <init_etc_passwd_group+0x10><== NEVER TAKEN
fprintf( fp, "root:x:0:root\n"
108ad3: 50 push %eax
108ad4: 6a 2a push $0x2a
108ad6: 6a 01 push $0x1
108ad8: 68 2c 2d 12 00 push $0x122d2c
108add: e8 1e c6 00 00 call 115100 <fwrite>
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
108ae2: 89 1c 24 mov %ebx,(%esp)
108ae5: e8 3e b7 00 00 call 114228 <fclose>
108aea: 83 c4 10 add $0x10,%esp
108aed: e9 52 ff ff ff jmp 108a44 <init_etc_passwd_group+0x10>
108af2: 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) {
108af4: 83 ec 08 sub $0x8,%esp
108af7: 68 b4 16 12 00 push $0x1216b4
108afc: 68 ad 2c 12 00 push $0x122cad
108b01: e8 26 be 00 00 call 11492c <fopen>
108b06: 89 c3 mov %eax,%ebx
108b08: 83 c4 10 add $0x10,%esp
108b0b: 85 c0 test %eax,%eax
108b0d: 0f 84 76 ff ff ff je 108a89 <init_etc_passwd_group+0x55><== NEVER TAKEN
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
108b13: 50 push %eax
108b14: 6a 66 push $0x66
108b16: 6a 01 push $0x1
108b18: 68 c4 2c 12 00 push $0x122cc4
108b1d: e8 de c5 00 00 call 115100 <fwrite>
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
108b22: 89 1c 24 mov %ebx,(%esp)
108b25: e8 fe b6 00 00 call 114228 <fclose>
108b2a: 83 c4 10 add $0x10,%esp
108b2d: e9 57 ff ff ff jmp 108a89 <init_etc_passwd_group+0x55>
00109f6c <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
109f6c: 55 push %ebp
109f6d: 89 e5 mov %esp,%ebp
109f6f: 56 push %esi
109f70: 53 push %ebx
109f71: 89 d6 mov %edx,%esi
109f73: 88 c3 mov %al,%bl
if (tty->termios.c_iflag & ISTRIP)
109f75: 8b 42 30 mov 0x30(%edx),%eax
109f78: a8 20 test $0x20,%al
109f7a: 74 03 je 109f7f <iproc+0x13> <== ALWAYS TAKEN
c &= 0x7f;
109f7c: 83 e3 7f and $0x7f,%ebx <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
109f7f: f6 c4 02 test $0x2,%ah
109f82: 74 18 je 109f9c <iproc+0x30>
c = tolower (c);
109f84: 0f b6 db movzbl %bl,%ebx
109f87: 8b 15 94 5a 12 00 mov 0x125a94,%edx
109f8d: 0f be 54 1a 01 movsbl 0x1(%edx,%ebx,1),%edx
109f92: 83 e2 03 and $0x3,%edx
109f95: 4a dec %edx
109f96: 0f 84 9c 00 00 00 je 10a038 <iproc+0xcc>
if (c == '\r') {
109f9c: 80 fb 0d cmp $0xd,%bl
109f9f: 74 33 je 109fd4 <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)) {
109fa1: 80 fb 0a cmp $0xa,%bl
109fa4: 0f 84 86 00 00 00 je 10a030 <iproc+0xc4>
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
109faa: 84 db test %bl,%bl
109fac: 75 3a jne 109fe8 <iproc+0x7c> <== ALWAYS TAKEN
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
109fae: 8b 46 20 mov 0x20(%esi),%eax
109fb1: 8b 15 80 59 12 00 mov 0x125980,%edx
109fb7: 4a dec %edx
109fb8: 39 d0 cmp %edx,%eax
109fba: 7d 1c jge 109fd8 <iproc+0x6c> <== NEVER TAKEN
if (tty->termios.c_lflag & ECHO)
109fbc: f6 46 3c 08 testb $0x8,0x3c(%esi)
109fc0: 75 7e jne 10a040 <iproc+0xd4> <== ALWAYS TAKEN
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
109fc2: 8b 56 1c mov 0x1c(%esi),%edx
109fc5: 88 1c 02 mov %bl,(%edx,%eax,1)
109fc8: 40 inc %eax
109fc9: 89 46 20 mov %eax,0x20(%esi)
}
return 0;
109fcc: 31 c0 xor %eax,%eax
}
109fce: 5b pop %ebx
109fcf: 5e pop %esi
109fd0: c9 leave
109fd1: c3 ret
109fd2: 66 90 xchg %ax,%ax
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
109fd4: a8 80 test $0x80,%al
109fd6: 74 08 je 109fe0 <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;
109fd8: 31 c0 xor %eax,%eax
}
109fda: 5b pop %ebx <== NOT EXECUTED
109fdb: 5e pop %esi <== NOT EXECUTED
109fdc: c9 leave <== NOT EXECUTED
109fdd: c3 ret <== NOT EXECUTED
109fde: 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)
109fe0: f6 c4 01 test $0x1,%ah
109fe3: 74 03 je 109fe8 <iproc+0x7c> <== NEVER TAKEN
c = '\n';
109fe5: b3 0a mov $0xa,%bl
109fe7: 90 nop
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
109fe8: 8b 46 3c mov 0x3c(%esi),%eax
109feb: a8 02 test $0x2,%al
109fed: 74 bf je 109fae <iproc+0x42>
if (c == tty->termios.c_cc[VERASE]) {
109fef: 38 5e 43 cmp %bl,0x43(%esi)
109ff2: 0f 84 b0 00 00 00 je 10a0a8 <iproc+0x13c>
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
109ff8: 38 5e 44 cmp %bl,0x44(%esi)
109ffb: 74 63 je 10a060 <iproc+0xf4>
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
109ffd: 38 5e 45 cmp %bl,0x45(%esi)
10a000: 0f 84 96 00 00 00 je 10a09c <iproc+0x130> <== NEVER TAKEN
return 1;
} else if (c == '\n') {
10a006: 80 fb 0a cmp $0xa,%bl
10a009: 74 69 je 10a074 <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]) ||
10a00b: 38 5e 4c cmp %bl,0x4c(%esi)
10a00e: 74 05 je 10a015 <iproc+0xa9> <== NEVER TAKEN
10a010: 38 5e 51 cmp %bl,0x51(%esi)
10a013: 75 99 jne 109fae <iproc+0x42> <== ALWAYS TAKEN
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
10a015: a8 08 test $0x8,%al <== NOT EXECUTED
10a017: 75 3b jne 10a054 <iproc+0xe8> <== NOT EXECUTED
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
10a019: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED
10a01c: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED
10a01f: 88 1c 02 mov %bl,(%edx,%eax,1) <== NOT EXECUTED
10a022: 40 inc %eax <== NOT EXECUTED
10a023: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED
return 1;
10a026: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
10a02b: eb a1 jmp 109fce <iproc+0x62> <== NOT EXECUTED
10a02d: 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)) {
10a030: a8 40 test $0x40,%al
10a032: 74 b4 je 109fe8 <iproc+0x7c> <== ALWAYS TAKEN
c = '\r';
10a034: b3 0d mov $0xd,%bl <== NOT EXECUTED
10a036: eb b0 jmp 109fe8 <iproc+0x7c> <== NOT EXECUTED
{
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
10a038: 83 c3 20 add $0x20,%ebx
10a03b: e9 5c ff ff ff jmp 109f9c <iproc+0x30>
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
10a040: 0f b6 c3 movzbl %bl,%eax
10a043: 89 f2 mov %esi,%edx
10a045: e8 f2 fc ff ff call 109d3c <echo>
10a04a: 8b 46 20 mov 0x20(%esi),%eax
10a04d: e9 70 ff ff ff jmp 109fc2 <iproc+0x56>
10a052: 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);
10a054: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED
10a057: 89 f2 mov %esi,%edx <== NOT EXECUTED
10a059: e8 de fc ff ff call 109d3c <echo> <== NOT EXECUTED
10a05e: eb b9 jmp 10a019 <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);
10a060: ba 01 00 00 00 mov $0x1,%edx
10a065: 89 f0 mov %esi,%eax
10a067: e8 34 fd ff ff call 109da0 <erase>
return 0;
10a06c: 31 c0 xor %eax,%eax
10a06e: e9 5b ff ff ff jmp 109fce <iproc+0x62>
10a073: 90 nop
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
} else if (c == '\n') {
if (tty->termios.c_lflag & (ECHO | ECHONL))
10a074: a8 48 test $0x48,%al
10a076: 74 0c je 10a084 <iproc+0x118> <== NEVER TAKEN
echo (c, tty);
10a078: 89 f2 mov %esi,%edx
10a07a: b8 0a 00 00 00 mov $0xa,%eax
10a07f: e8 b8 fc ff ff call 109d3c <echo>
tty->cbuf[tty->ccount++] = c;
10a084: 8b 46 20 mov 0x20(%esi),%eax
10a087: 8b 56 1c mov 0x1c(%esi),%edx
10a08a: c6 04 02 0a movb $0xa,(%edx,%eax,1)
10a08e: 40 inc %eax
10a08f: 89 46 20 mov %eax,0x20(%esi)
return 1;
10a092: b8 01 00 00 00 mov $0x1,%eax
10a097: e9 32 ff ff ff jmp 109fce <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;
10a09c: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
10a0a1: e9 28 ff ff ff jmp 109fce <iproc+0x62> <== NOT EXECUTED
10a0a6: 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);
10a0a8: 31 d2 xor %edx,%edx
10a0aa: 89 f0 mov %esi,%eax
10a0ac: e8 ef fc ff ff call 109da0 <erase>
return 0;
10a0b1: 31 c0 xor %eax,%eax
10a0b3: e9 16 ff ff ff jmp 109fce <iproc+0x62>
001249b8 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
1249b8: 55 push %ebp
1249b9: 89 e5 mov %esp,%ebp
1249bb: 57 push %edi
1249bc: 56 push %esi
1249bd: 53 push %ebx
1249be: 83 ec 3c sub $0x3c,%esp
1249c1: 8b 75 0c mov 0xc(%ebp),%esi
1249c4: 8b 7d 10 mov 0x10(%ebp),%edi
POSIX_signals_Siginfo_node *psiginfo;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
1249c7: e8 00 fd ff ff call 1246cc <getpid>
1249cc: 3b 45 08 cmp 0x8(%ebp),%eax
1249cf: 0f 85 3f 02 00 00 jne 124c14 <killinfo+0x25c>
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
1249d5: 85 f6 test %esi,%esi
1249d7: 0f 84 4c 02 00 00 je 124c29 <killinfo+0x271>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
1249dd: 8d 4e ff lea -0x1(%esi),%ecx
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
1249e0: 83 f9 1f cmp $0x1f,%ecx
1249e3: 0f 87 40 02 00 00 ja 124c29 <killinfo+0x271>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
1249e9: 8d 04 76 lea (%esi,%esi,2),%eax
1249ec: 83 3c 85 28 f1 12 00 cmpl $0x1,0x12f128(,%eax,4)
1249f3: 01
1249f4: 0f 84 e6 01 00 00 je 124be0 <killinfo+0x228>
/*
* P1003.1c/Draft 10, p. 33 says that certain signals should always
* be directed to the executing thread such as those caused by hardware
* faults.
*/
if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) )
1249fa: 83 fe 08 cmp $0x8,%esi
1249fd: 0f 84 c9 00 00 00 je 124acc <killinfo+0x114>
124a03: 83 fe 04 cmp $0x4,%esi
124a06: 0f 84 c0 00 00 00 je 124acc <killinfo+0x114>
124a0c: 83 fe 0b cmp $0xb,%esi
124a0f: 0f 84 b7 00 00 00 je 124acc <killinfo+0x114>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
124a15: bb 01 00 00 00 mov $0x1,%ebx
124a1a: d3 e3 shl %cl,%ebx
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
124a1c: 89 75 dc mov %esi,-0x24(%ebp)
siginfo->si_code = SI_USER;
124a1f: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp)
if ( !value ) {
124a26: 85 ff test %edi,%edi
124a28: 0f 84 ba 01 00 00 je 124be8 <killinfo+0x230>
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
124a2e: 8b 07 mov (%edi),%eax
124a30: 89 45 e4 mov %eax,-0x1c(%ebp)
124a33: a1 10 eb 12 00 mov 0x12eb10,%eax
124a38: 40 inc %eax
124a39: a3 10 eb 12 00 mov %eax,0x12eb10
/*
* Is the currently executing thread interested? If so then it will
* get it an execute it as soon as the dispatcher executes.
*/
the_thread = _Thread_Executing;
124a3e: 8b 0d b8 f0 12 00 mov 0x12f0b8,%ecx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
124a44: 8b 81 ec 00 00 00 mov 0xec(%ecx),%eax
124a4a: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
124a50: f7 d0 not %eax
124a52: 85 c3 test %eax,%ebx
124a54: 75 34 jne 124a8a <killinfo+0xd2>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
124a56: a1 c0 f2 12 00 mov 0x12f2c0,%eax
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
124a5b: 3d c4 f2 12 00 cmp $0x12f2c4,%eax
124a60: 75 1b jne 124a7d <killinfo+0xc5>
124a62: e9 81 00 00 00 jmp 124ae8 <killinfo+0x130>
124a67: 90 nop
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
124a68: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx
124a6e: f7 d2 not %edx
124a70: 85 d3 test %edx,%ebx
124a72: 75 16 jne 124a8a <killinfo+0xd2>
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
124a74: 8b 00 mov (%eax),%eax
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
124a76: 3d c4 f2 12 00 cmp $0x12f2c4,%eax
124a7b: 74 6b je 124ae8 <killinfo+0x130> <== ALWAYS TAKEN
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
124a7d: 89 c1 mov %eax,%ecx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
124a7f: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
124a85: 85 58 30 test %ebx,0x30(%eax)
124a88: 74 de je 124a68 <killinfo+0xb0>
/*
* Returns true if the signal was synchronously given to a thread
* blocked waiting for the signal.
*/
if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {
124a8a: 50 push %eax
mask = signo_to_mask( sig );
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
124a8b: 8d 45 dc lea -0x24(%ebp),%eax
/*
* Returns true if the signal was synchronously given to a thread
* blocked waiting for the signal.
*/
if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {
124a8e: 50 push %eax
124a8f: 56 push %esi
124a90: 51 push %ecx
124a91: e8 d6 01 00 00 call 124c6c <_POSIX_signals_Unblock_thread>
124a96: 83 c4 10 add $0x10,%esp
124a99: 84 c0 test %al,%al
124a9b: 75 1f jne 124abc <killinfo+0x104>
/*
* We may have woken up a thread but we definitely need to post the
* signal to the process wide information set.
*/
_POSIX_signals_Set_process_signals( mask );
124a9d: 83 ec 0c sub $0xc,%esp
124aa0: 53 push %ebx
124aa1: e8 b2 01 00 00 call 124c58 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
124aa6: 8d 1c 76 lea (%esi,%esi,2),%ebx
124aa9: c1 e3 02 shl $0x2,%ebx
124aac: 83 c4 10 add $0x10,%esp
124aaf: 83 bb 20 f1 12 00 02 cmpl $0x2,0x12f120(%ebx)
124ab6: 0f 84 e4 00 00 00 je 124ba0 <killinfo+0x1e8>
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
124abc: e8 17 e0 fe ff call 112ad8 <_Thread_Enable_dispatch>
return 0;
124ac1: 31 c0 xor %eax,%eax
}
124ac3: 8d 65 f4 lea -0xc(%ebp),%esp
124ac6: 5b pop %ebx
124ac7: 5e pop %esi
124ac8: 5f pop %edi
124ac9: c9 leave
124aca: c3 ret
124acb: 90 nop
* P1003.1c/Draft 10, p. 33 says that certain signals should always
* be directed to the executing thread such as those caused by hardware
* faults.
*/
if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) )
return pthread_kill( pthread_self(), sig );
124acc: e8 7b 03 00 00 call 124e4c <pthread_self>
124ad1: 83 ec 08 sub $0x8,%esp
124ad4: 56 push %esi
124ad5: 50 push %eax
124ad6: e8 b1 02 00 00 call 124d8c <pthread_kill>
124adb: 83 c4 10 add $0x10,%esp
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
124ade: 8d 65 f4 lea -0xc(%ebp),%esp
124ae1: 5b pop %ebx
124ae2: 5e pop %esi
124ae3: 5f pop %edi
124ae4: c9 leave
124ae5: c3 ret
124ae6: 66 90 xchg %ax,%ax
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
124ae8: 0f b6 05 54 a6 12 00 movzbl 0x12a654,%eax
124aef: 40 inc %eax
124af0: 89 45 d4 mov %eax,-0x2c(%ebp)
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
124af3: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp)
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
124afa: c7 45 cc 02 00 00 00 movl $0x2,-0x34(%ebp)
124b01: 89 5d d0 mov %ebx,-0x30(%ebp)
124b04: 89 75 c0 mov %esi,-0x40(%ebp)
/*
* This can occur when no one is interested and an API is not configured.
*/
if ( !_Objects_Information_table[ the_api ] )
124b07: 8b 55 cc mov -0x34(%ebp),%edx
124b0a: 8b 04 95 e8 ea 12 00 mov 0x12eae8(,%edx,4),%eax
124b11: 85 c0 test %eax,%eax
124b13: 74 68 je 124b7d <killinfo+0x1c5> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
124b15: 8b 40 04 mov 0x4(%eax),%eax
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
124b18: 0f b7 70 10 movzwl 0x10(%eax),%esi
object_table = the_info->local_table;
124b1c: 8b 78 1c mov 0x1c(%eax),%edi
for ( index = 1 ; index <= maximum ; index++ ) {
124b1f: 85 f6 test %esi,%esi
124b21: 74 5a je 124b7d <killinfo+0x1c5>
124b23: b8 01 00 00 00 mov $0x1,%eax
the_thread = (Thread_Control *) object_table[ index ];
124b28: 8b 14 87 mov (%edi,%eax,4),%edx
if ( !the_thread )
124b2b: 85 d2 test %edx,%edx
124b2d: 74 49 je 124b78 <killinfo+0x1c0>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
124b2f: 8b 4a 14 mov 0x14(%edx),%ecx
124b32: 3b 4d d4 cmp -0x2c(%ebp),%ecx
124b35: 77 41 ja 124b78 <killinfo+0x1c0>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
124b37: 8b 9a ec 00 00 00 mov 0xec(%edx),%ebx
124b3d: 8b 9b d0 00 00 00 mov 0xd0(%ebx),%ebx
124b43: f7 d3 not %ebx
124b45: 85 5d d0 test %ebx,-0x30(%ebp)
124b48: 74 2e je 124b78 <killinfo+0x1c0>
*
* NOTE: We initialized interested_priority to PRIORITY_MAXIMUM + 1
* so we never have to worry about deferencing a NULL
* interested thread.
*/
if ( the_thread->current_priority < interested_priority ) {
124b4a: 3b 4d d4 cmp -0x2c(%ebp),%ecx
124b4d: 72 21 jb 124b70 <killinfo+0x1b8>
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
124b4f: 8b 5d c8 mov -0x38(%ebp),%ebx
124b52: 85 db test %ebx,%ebx
124b54: 74 22 je 124b78 <killinfo+0x1c0> <== NEVER TAKEN
124b56: 8b 5d c8 mov -0x38(%ebp),%ebx
124b59: 8b 5b 10 mov 0x10(%ebx),%ebx
124b5c: 89 5d c4 mov %ebx,-0x3c(%ebp)
124b5f: 85 db test %ebx,%ebx
124b61: 74 15 je 124b78 <killinfo+0x1c0> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
124b63: 8b 5a 10 mov 0x10(%edx),%ebx
124b66: 85 db test %ebx,%ebx
124b68: 0f 85 86 00 00 00 jne 124bf4 <killinfo+0x23c>
124b6e: 66 90 xchg %ax,%ax
124b70: 89 4d d4 mov %ecx,-0x2c(%ebp)
124b73: 89 55 c8 mov %edx,-0x38(%ebp)
124b76: 66 90 xchg %ax,%ax
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
124b78: 40 inc %eax
124b79: 39 c6 cmp %eax,%esi
124b7b: 73 ab jae 124b28 <killinfo+0x170>
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
124b7d: ff 45 cc incl -0x34(%ebp)
124b80: 83 7d cc 04 cmpl $0x4,-0x34(%ebp)
124b84: 75 81 jne 124b07 <killinfo+0x14f>
124b86: 8b 5d d0 mov -0x30(%ebp),%ebx
124b89: 8b 75 c0 mov -0x40(%ebp),%esi
}
}
}
}
if ( interested ) {
124b8c: 8b 55 c8 mov -0x38(%ebp),%edx
124b8f: 85 d2 test %edx,%edx
124b91: 0f 84 06 ff ff ff je 124a9d <killinfo+0xe5>
124b97: 8b 4d c8 mov -0x38(%ebp),%ecx
124b9a: e9 eb fe ff ff jmp 124a8a <killinfo+0xd2>
124b9f: 90 nop
_POSIX_signals_Set_process_signals( mask );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
124ba0: 83 ec 0c sub $0xc,%esp
124ba3: 68 a0 f2 12 00 push $0x12f2a0
124ba8: e8 ef c4 fe ff call 11109c <_Chain_Get>
if ( !psiginfo ) {
124bad: 83 c4 10 add $0x10,%esp
124bb0: 85 c0 test %eax,%eax
124bb2: 0f 84 86 00 00 00 je 124c3e <killinfo+0x286>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
124bb8: 8d 78 08 lea 0x8(%eax),%edi
124bbb: 8d 75 dc lea -0x24(%ebp),%esi
124bbe: b9 03 00 00 00 mov $0x3,%ecx
124bc3: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
124bc5: 83 ec 08 sub $0x8,%esp
124bc8: 50 push %eax
124bc9: 81 c3 40 f3 12 00 add $0x12f340,%ebx
124bcf: 53 push %ebx
124bd0: e8 8b c4 fe ff call 111060 <_Chain_Append>
124bd5: 83 c4 10 add $0x10,%esp
124bd8: e9 df fe ff ff jmp 124abc <killinfo+0x104>
124bdd: 8d 76 00 lea 0x0(%esi),%esi
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
return 0;
124be0: 31 c0 xor %eax,%eax
124be2: e9 f7 fe ff ff jmp 124ade <killinfo+0x126>
124be7: 90 nop
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
124be8: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
124bef: e9 3f fe ff ff jmp 124a33 <killinfo+0x7b>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
124bf4: f7 45 c4 00 00 00 10 testl $0x10000000,-0x3c(%ebp)
124bfb: 0f 85 77 ff ff ff jne 124b78 <killinfo+0x1c0>
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
124c01: 81 e3 00 00 00 10 and $0x10000000,%ebx
124c07: 0f 84 6b ff ff ff je 124b78 <killinfo+0x1c0>
124c0d: e9 5e ff ff ff jmp 124b70 <killinfo+0x1b8>
124c12: 66 90 xchg %ax,%ax
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
rtems_set_errno_and_return_minus_one( ESRCH );
124c14: e8 1f 38 ff ff call 118438 <__errno>
124c19: c7 00 03 00 00 00 movl $0x3,(%eax)
124c1f: b8 ff ff ff ff mov $0xffffffff,%eax
124c24: e9 b5 fe ff ff jmp 124ade <killinfo+0x126>
*/
if ( !sig )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
124c29: e8 0a 38 ff ff call 118438 <__errno>
124c2e: c7 00 16 00 00 00 movl $0x16,(%eax)
124c34: b8 ff ff ff ff mov $0xffffffff,%eax
124c39: e9 a0 fe ff ff jmp 124ade <killinfo+0x126>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
_Thread_Enable_dispatch();
124c3e: e8 95 de fe ff call 112ad8 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
124c43: e8 f0 37 ff ff call 118438 <__errno>
124c48: c7 00 0b 00 00 00 movl $0xb,(%eax)
124c4e: 83 c8 ff or $0xffffffff,%eax
124c51: e9 88 fe ff ff jmp 124ade <killinfo+0x126>
0011f184 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
11f184: 55 push %ebp
11f185: 89 e5 mov %esp,%ebp
11f187: 53 push %ebx
11f188: 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()))
11f18b: 83 3d 20 7f 12 00 03 cmpl $0x3,0x127f20
11f192: 74 08 je 11f19c <libc_wrapup+0x18> <== ALWAYS TAKEN
*/
fclose (stdin);
fclose (stdout);
fclose (stderr);
}
11f194: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
11f197: c9 leave <== NOT EXECUTED
11f198: c3 ret <== NOT EXECUTED
11f199: 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) {
11f19c: a1 a0 5a 12 00 mov 0x125aa0,%eax
11f1a1: 8b 1d e0 1e 12 00 mov 0x121ee0,%ebx
11f1a7: 39 d8 cmp %ebx,%eax
11f1a9: 74 14 je 11f1bf <libc_wrapup+0x3b>
_wrapup_reent(_global_impure_ptr);
11f1ab: 83 ec 0c sub $0xc,%esp
11f1ae: 53 push %ebx
11f1af: e8 f8 05 00 00 call 11f7ac <_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;
11f1b4: 89 1d a0 5a 12 00 mov %ebx,0x125aa0
11f1ba: 83 c4 10 add $0x10,%esp
11f1bd: 89 d8 mov %ebx,%eax
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
11f1bf: 83 ec 0c sub $0xc,%esp
11f1c2: ff 70 04 pushl 0x4(%eax)
11f1c5: e8 fe 41 ff ff call 1133c8 <fclose>
fclose (stdout);
11f1ca: 5a pop %edx
11f1cb: a1 a0 5a 12 00 mov 0x125aa0,%eax
11f1d0: ff 70 08 pushl 0x8(%eax)
11f1d3: e8 f0 41 ff ff call 1133c8 <fclose>
fclose (stderr);
11f1d8: 58 pop %eax
11f1d9: a1 a0 5a 12 00 mov 0x125aa0,%eax
11f1de: ff 70 0c pushl 0xc(%eax)
11f1e1: e8 e2 41 ff ff call 1133c8 <fclose>
11f1e6: 83 c4 10 add $0x10,%esp
}
11f1e9: 8b 5d fc mov -0x4(%ebp),%ebx
11f1ec: c9 leave
11f1ed: c3 ret
0010b578 <link>:
int link(
const char *existing,
const char *new
)
{
10b578: 55 push %ebp
10b579: 89 e5 mov %esp,%ebp
10b57b: 57 push %edi
10b57c: 56 push %esi
10b57d: 53 push %ebx
10b57e: 83 ec 58 sub $0x58,%esp
10b581: 8b 55 08 mov 0x8(%ebp),%edx
10b584: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Get the node we are linking to.
*/
result = rtems_filesystem_evaluate_path( existing, strlen( existing ),
10b587: 31 c0 xor %eax,%eax
10b589: b9 ff ff ff ff mov $0xffffffff,%ecx
10b58e: 89 d7 mov %edx,%edi
10b590: f2 ae repnz scas %es:(%edi),%al
10b592: f7 d1 not %ecx
10b594: 49 dec %ecx
10b595: 6a 01 push $0x1
10b597: 8d 75 cc lea -0x34(%ebp),%esi
10b59a: 56 push %esi
10b59b: 6a 00 push $0x0
10b59d: 51 push %ecx
10b59e: 52 push %edx
10b59f: e8 28 f9 ff ff call 10aecc <rtems_filesystem_evaluate_path>
0, &existing_loc, true );
if ( result != 0 )
10b5a4: 83 c4 20 add $0x20,%esp
10b5a7: 85 c0 test %eax,%eax
10b5a9: 74 0d je 10b5b8 <link+0x40>
return -1;
10b5ab: b8 ff ff ff ff mov $0xffffffff,%eax
rtems_filesystem_freenode( &existing_loc );
rtems_filesystem_freenode( &parent_loc );
return result;
}
10b5b0: 8d 65 f4 lea -0xc(%ebp),%esp
10b5b3: 5b pop %ebx
10b5b4: 5e pop %esi
10b5b5: 5f pop %edi
10b5b6: c9 leave
10b5b7: c3 ret
/*
* Get the parent of the node we are creating.
*/
rtems_filesystem_get_start_loc( new, &i, &parent_loc );
10b5b8: 52 push %edx
10b5b9: 8d 7d b8 lea -0x48(%ebp),%edi
10b5bc: 57 push %edi
10b5bd: 8d 45 e4 lea -0x1c(%ebp),%eax
10b5c0: 50 push %eax
10b5c1: 53 push %ebx
10b5c2: e8 f5 12 00 00 call 10c8bc <rtems_filesystem_get_start_loc>
result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start );
10b5c7: 83 c4 0c add $0xc,%esp
10b5ca: 8d 45 e0 lea -0x20(%ebp),%eax
10b5cd: 50 push %eax
10b5ce: 57 push %edi
10b5cf: 03 5d e4 add -0x1c(%ebp),%ebx
10b5d2: 53 push %ebx
10b5d3: 8b 45 c4 mov -0x3c(%ebp),%eax
10b5d6: ff 50 04 call *0x4(%eax)
if ( result != 0 ) {
10b5d9: 83 c4 10 add $0x10,%esp
10b5dc: 85 c0 test %eax,%eax
10b5de: 75 61 jne 10b641 <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 ) {
10b5e0: 8b 45 dc mov -0x24(%ebp),%eax
10b5e3: 39 45 c8 cmp %eax,-0x38(%ebp)
10b5e6: 75 30 jne 10b618 <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 );
10b5e8: 50 push %eax
10b5e9: ff 75 e0 pushl -0x20(%ebp)
10b5ec: 57 push %edi
10b5ed: 56 push %esi
10b5ee: 8b 45 c4 mov -0x3c(%ebp),%eax
10b5f1: ff 50 08 call *0x8(%eax)
rtems_filesystem_freenode( &existing_loc );
10b5f4: 89 34 24 mov %esi,(%esp)
10b5f7: 89 45 b4 mov %eax,-0x4c(%ebp)
10b5fa: e8 81 fb ff ff call 10b180 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &parent_loc );
10b5ff: 89 3c 24 mov %edi,(%esp)
10b602: e8 79 fb ff ff call 10b180 <rtems_filesystem_freenode>
return result;
10b607: 83 c4 10 add $0x10,%esp
10b60a: 8b 45 b4 mov -0x4c(%ebp),%eax
}
10b60d: 8d 65 f4 lea -0xc(%ebp),%esp
10b610: 5b pop %ebx
10b611: 5e pop %esi
10b612: 5f pop %edi
10b613: c9 leave
10b614: c3 ret
10b615: 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 );
10b618: 83 ec 0c sub $0xc,%esp
10b61b: 56 push %esi
10b61c: e8 5f fb ff ff call 10b180 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &parent_loc );
10b621: 89 3c 24 mov %edi,(%esp)
10b624: e8 57 fb ff ff call 10b180 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EXDEV );
10b629: e8 92 b8 00 00 call 116ec0 <__errno>
10b62e: c7 00 12 00 00 00 movl $0x12,(%eax)
10b634: 83 c4 10 add $0x10,%esp
10b637: b8 ff ff ff ff mov $0xffffffff,%eax
10b63c: e9 6f ff ff ff jmp 10b5b0 <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 );
10b641: 83 ec 0c sub $0xc,%esp
10b644: 56 push %esi
10b645: e8 36 fb ff ff call 10b180 <rtems_filesystem_freenode>
return -1;
10b64a: 83 c4 10 add $0x10,%esp
10b64d: b8 ff ff ff ff mov $0xffffffff,%eax
10b652: e9 59 ff ff ff jmp 10b5b0 <link+0x38>
0011f05c <lseek>:
off_t lseek(
int fd,
off_t offset,
int whence
)
{
11f05c: 55 push %ebp
11f05d: 89 e5 mov %esp,%ebp
11f05f: 57 push %edi
11f060: 56 push %esi
11f061: 53 push %ebx
11f062: 83 ec 1c sub $0x1c,%esp
11f065: 8b 5d 08 mov 0x8(%ebp),%ebx
11f068: 8b 55 0c mov 0xc(%ebp),%edx
11f06b: 8b 4d 10 mov 0x10(%ebp),%ecx
11f06e: 8b 45 14 mov 0x14(%ebp),%eax
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
11f071: 3b 1d 6c 39 12 00 cmp 0x12396c,%ebx
11f077: 0f 83 b3 00 00 00 jae 11f130 <lseek+0xd4> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
11f07d: 8d 34 dd 00 00 00 00 lea 0x0(,%ebx,8),%esi
11f084: 8d 1c f5 00 00 00 00 lea 0x0(,%esi,8),%ebx
11f08b: 29 f3 sub %esi,%ebx
11f08d: 03 1d 20 7c 12 00 add 0x127c20,%ebx
rtems_libio_check_is_open(iop);
11f093: f6 43 15 01 testb $0x1,0x15(%ebx)
11f097: 0f 84 93 00 00 00 je 11f130 <lseek+0xd4> <== NEVER TAKEN
/*
* Now process the lseek().
*/
old_offset = iop->offset;
11f09d: 8b 73 0c mov 0xc(%ebx),%esi
11f0a0: 8b 7b 10 mov 0x10(%ebx),%edi
11f0a3: 89 75 e0 mov %esi,-0x20(%ebp)
11f0a6: 89 7d e4 mov %edi,-0x1c(%ebp)
switch ( whence ) {
11f0a9: 83 f8 01 cmp $0x1,%eax
11f0ac: 74 6e je 11f11c <lseek+0xc0>
11f0ae: 83 f8 02 cmp $0x2,%eax
11f0b1: 74 35 je 11f0e8 <lseek+0x8c>
11f0b3: 85 c0 test %eax,%eax
11f0b5: 75 45 jne 11f0fc <lseek+0xa0>
case SEEK_SET:
iop->offset = offset;
11f0b7: 89 53 0c mov %edx,0xc(%ebx)
11f0ba: 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 );
11f0bd: 8b 73 20 mov 0x20(%ebx),%esi
11f0c0: 50 push %eax
11f0c1: 51 push %ecx
11f0c2: 52 push %edx
11f0c3: 53 push %ebx
11f0c4: ff 56 14 call *0x14(%esi)
if ( status == (off_t) -1 )
11f0c7: 83 c4 10 add $0x10,%esp
11f0ca: 89 c1 mov %eax,%ecx
11f0cc: 21 d1 and %edx,%ecx
11f0ce: 41 inc %ecx
11f0cf: 75 0c jne 11f0dd <lseek+0x81>
iop->offset = old_offset;
11f0d1: 8b 75 e0 mov -0x20(%ebp),%esi
11f0d4: 8b 7d e4 mov -0x1c(%ebp),%edi
11f0d7: 89 73 0c mov %esi,0xc(%ebx)
11f0da: 89 7b 10 mov %edi,0x10(%ebx)
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
11f0dd: 8d 65 f4 lea -0xc(%ebp),%esp
11f0e0: 5b pop %ebx
11f0e1: 5e pop %esi
11f0e2: 5f pop %edi
11f0e3: c9 leave
11f0e4: c3 ret
11f0e5: 8d 76 00 lea 0x0(%esi),%esi
case SEEK_CUR:
iop->offset += offset;
break;
case SEEK_END:
iop->offset = iop->size + offset;
11f0e8: 89 d6 mov %edx,%esi
11f0ea: 89 cf mov %ecx,%edi
11f0ec: 03 73 04 add 0x4(%ebx),%esi
11f0ef: 13 7b 08 adc 0x8(%ebx),%edi
11f0f2: 89 73 0c mov %esi,0xc(%ebx)
11f0f5: 89 7b 10 mov %edi,0x10(%ebx)
break;
11f0f8: eb c3 jmp 11f0bd <lseek+0x61>
11f0fa: 66 90 xchg %ax,%ax
default:
rtems_set_errno_and_return_minus_one( EINVAL );
11f0fc: e8 6f 41 ff ff call 113270 <__errno>
11f101: c7 00 16 00 00 00 movl $0x16,(%eax)
11f107: b8 ff ff ff ff mov $0xffffffff,%eax
11f10c: ba ff ff ff ff mov $0xffffffff,%edx
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
11f111: 8d 65 f4 lea -0xc(%ebp),%esp
11f114: 5b pop %ebx
11f115: 5e pop %esi
11f116: 5f pop %edi
11f117: c9 leave
11f118: c3 ret
11f119: 8d 76 00 lea 0x0(%esi),%esi
case SEEK_SET:
iop->offset = offset;
break;
case SEEK_CUR:
iop->offset += offset;
11f11c: 8b 75 e0 mov -0x20(%ebp),%esi
11f11f: 8b 7d e4 mov -0x1c(%ebp),%edi
11f122: 01 d6 add %edx,%esi
11f124: 11 cf adc %ecx,%edi
11f126: 89 73 0c mov %esi,0xc(%ebx)
11f129: 89 7b 10 mov %edi,0x10(%ebx)
break;
11f12c: eb 8f jmp 11f0bd <lseek+0x61>
11f12e: 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);
11f130: e8 3b 41 ff ff call 113270 <__errno>
11f135: c7 00 09 00 00 00 movl $0x9,(%eax)
11f13b: b8 ff ff ff ff mov $0xffffffff,%eax
11f140: ba ff ff ff ff mov $0xffffffff,%edx
11f145: eb 96 jmp 11f0dd <lseek+0x81>
00109ecc <lstat>:
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
109ecc: 55 push %ebp
109ecd: 89 e5 mov %esp,%ebp
109ecf: 57 push %edi
109ed0: 56 push %esi
109ed1: 53 push %ebx
109ed2: 83 ec 3c sub $0x3c,%esp
109ed5: 8b 55 08 mov 0x8(%ebp),%edx
109ed8: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
109edb: 85 f6 test %esi,%esi
109edd: 74 65 je 109f44 <lstat+0x78>
rtems_set_errno_and_return_minus_one( EFAULT );
status = rtems_filesystem_evaluate_path( path, strlen( path ),
109edf: b9 ff ff ff ff mov $0xffffffff,%ecx
109ee4: 89 d7 mov %edx,%edi
109ee6: 31 c0 xor %eax,%eax
109ee8: f2 ae repnz scas %es:(%edi),%al
109eea: f7 d1 not %ecx
109eec: 49 dec %ecx
109eed: 83 ec 0c sub $0xc,%esp
109ef0: 6a 00 push $0x0
109ef2: 8d 5d d4 lea -0x2c(%ebp),%ebx
109ef5: 53 push %ebx
109ef6: 6a 00 push $0x0
109ef8: 51 push %ecx
109ef9: 52 push %edx
109efa: e8 e5 f9 ff ff call 1098e4 <rtems_filesystem_evaluate_path>
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
109eff: 83 c4 20 add $0x20,%esp
109f02: 85 c0 test %eax,%eax
109f04: 74 0e je 109f14 <lstat+0x48>
return -1;
109f06: b8 ff ff ff ff mov $0xffffffff,%eax
status = (*loc.handlers->fstat_h)( &loc, buf );
rtems_filesystem_freenode( &loc );
return status;
}
109f0b: 8d 65 f4 lea -0xc(%ebp),%esp
109f0e: 5b pop %ebx
109f0f: 5e pop %esi
109f10: 5f pop %edi
109f11: c9 leave
109f12: c3 ret
109f13: 90 nop
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
109f14: b9 48 00 00 00 mov $0x48,%ecx
109f19: 89 f7 mov %esi,%edi
109f1b: f3 aa rep stos %al,%es:(%edi)
status = (*loc.handlers->fstat_h)( &loc, buf );
109f1d: 83 ec 08 sub $0x8,%esp
109f20: 56 push %esi
109f21: 53 push %ebx
109f22: 8b 45 dc mov -0x24(%ebp),%eax
109f25: ff 50 18 call *0x18(%eax)
rtems_filesystem_freenode( &loc );
109f28: 89 1c 24 mov %ebx,(%esp)
109f2b: 89 45 c4 mov %eax,-0x3c(%ebp)
109f2e: e8 89 fa ff ff call 1099bc <rtems_filesystem_freenode>
return status;
109f33: 83 c4 10 add $0x10,%esp
109f36: 8b 45 c4 mov -0x3c(%ebp),%eax
}
109f39: 8d 65 f4 lea -0xc(%ebp),%esp
109f3c: 5b pop %ebx
109f3d: 5e pop %esi
109f3e: 5f pop %edi
109f3f: c9 leave
109f40: c3 ret
109f41: 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 );
109f44: e8 1f b5 00 00 call 115468 <__errno>
109f49: c7 00 0e 00 00 00 movl $0xe,(%eax)
109f4f: b8 ff ff ff ff mov $0xffffffff,%eax
status = (*loc.handlers->fstat_h)( &loc, buf );
rtems_filesystem_freenode( &loc );
return status;
}
109f54: 8d 65 f4 lea -0xc(%ebp),%esp
109f57: 5b pop %ebx
109f58: 5e pop %esi
109f59: 5f pop %edi
109f5a: c9 leave
109f5b: c3 ret
00108388 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
108388: 55 push %ebp
108389: 89 e5 mov %esp,%ebp
10838b: 56 push %esi
10838c: 53 push %ebx
10838d: 8b 75 08 mov 0x8(%ebp),%esi
void *return_this;
MSBUMP(malloc_calls, 1);
108390: ff 05 44 7c 12 00 incl 0x127c44
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
108396: e8 fd fe ff ff call 108298 <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
10839b: 85 f6 test %esi,%esi
10839d: 74 5d je 1083fc <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()) &&
10839f: 83 3d 20 7f 12 00 03 cmpl $0x3,0x127f20
1083a6: 74 48 je 1083f0 <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 );
1083a8: 6a 00 push $0x0
1083aa: 6a 00 push $0x0
1083ac: 56 push %esi
1083ad: ff 35 b0 39 12 00 pushl 0x1239b0
1083b3: e8 34 4d 00 00 call 10d0ec <_Protected_heap_Allocate_aligned_with_boundary>
1083b8: 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 ) {
1083ba: 83 c4 10 add $0x10,%esp
1083bd: 85 c0 test %eax,%eax
1083bf: 74 47 je 108408 <malloc+0x80>
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
1083c1: a1 f0 5f 12 00 mov 0x125ff0,%eax
1083c6: 85 c0 test %eax,%eax
1083c8: 74 0a je 1083d4 <malloc+0x4c>
(*rtems_malloc_dirty_helper)( return_this, size );
1083ca: 83 ec 08 sub $0x8,%esp
1083cd: 56 push %esi
1083ce: 53 push %ebx
1083cf: ff d0 call *%eax
1083d1: 83 c4 10 add $0x10,%esp
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
1083d4: a1 e8 5f 12 00 mov 0x125fe8,%eax
1083d9: 85 c0 test %eax,%eax
1083db: 74 0a je 1083e7 <malloc+0x5f>
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
1083dd: 83 ec 0c sub $0xc,%esp
1083e0: 53 push %ebx
1083e1: ff 50 04 call *0x4(%eax)
1083e4: 83 c4 10 add $0x10,%esp
return return_this;
}
1083e7: 89 d8 mov %ebx,%eax
1083e9: 8d 65 f8 lea -0x8(%ebp),%esp
1083ec: 5b pop %ebx
1083ed: 5e pop %esi
1083ee: c9 leave
1083ef: 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() )
1083f0: e8 63 fe ff ff call 108258 <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()) &&
1083f5: 84 c0 test %al,%al
1083f7: 75 af jne 1083a8 <malloc+0x20> <== ALWAYS TAKEN
1083f9: 8d 76 00 lea 0x0(%esi),%esi
!malloc_is_system_state_OK() )
return NULL;
1083fc: 31 db xor %ebx,%ebx
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
return return_this;
}
1083fe: 89 d8 mov %ebx,%eax
108400: 8d 65 f8 lea -0x8(%ebp),%esp
108403: 5b pop %ebx
108404: 5e pop %esi
108405: c9 leave
108406: c3 ret
108407: 90 nop
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
if (rtems_malloc_sbrk_helpers)
108408: a1 ec 5f 12 00 mov 0x125fec,%eax
10840d: 85 c0 test %eax,%eax
10840f: 74 12 je 108423 <malloc+0x9b>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
108411: 83 ec 0c sub $0xc,%esp
108414: 56 push %esi
108415: ff 50 04 call *0x4(%eax)
if ( !return_this ) {
108418: 83 c4 10 add $0x10,%esp
10841b: 85 c0 test %eax,%eax
10841d: 74 04 je 108423 <malloc+0x9b>
10841f: 89 c3 mov %eax,%ebx
108421: eb 9e jmp 1083c1 <malloc+0x39>
errno = ENOMEM;
108423: e8 48 ae 00 00 call 113270 <__errno>
108428: c7 00 0c 00 00 00 movl $0xc,(%eax)
return (void *) 0;
10842e: eb b7 jmp 1083e7 <malloc+0x5f>
0010830c <malloc_get_statistics>:
#include "malloc_p.h"
int malloc_get_statistics(
rtems_malloc_statistics_t *stats
)
{
10830c: 55 push %ebp
10830d: 89 e5 mov %esp,%ebp
10830f: 57 push %edi
108310: 56 push %esi
108311: 53 push %ebx
108312: 83 ec 0c sub $0xc,%esp
108315: 8b 5d 08 mov 0x8(%ebp),%ebx
if ( !stats )
108318: 85 db test %ebx,%ebx
10831a: 74 38 je 108354 <malloc_get_statistics+0x48>
return -1;
_RTEMS_Lock_allocator();
10831c: 83 ec 0c sub $0xc,%esp
10831f: ff 35 20 7e 12 00 pushl 0x127e20
108325: e8 76 3c 00 00 call 10bfa0 <_API_Mutex_Lock>
*stats = rtems_malloc_statistics;
10832a: be 20 7c 12 00 mov $0x127c20,%esi
10832f: b9 0b 00 00 00 mov $0xb,%ecx
108334: 89 df mov %ebx,%edi
108336: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_RTEMS_Unlock_allocator();
108338: 58 pop %eax
108339: ff 35 20 7e 12 00 pushl 0x127e20
10833f: e8 a4 3c 00 00 call 10bfe8 <_API_Mutex_Unlock>
return 0;
108344: 83 c4 10 add $0x10,%esp
108347: 31 c0 xor %eax,%eax
}
108349: 8d 65 f4 lea -0xc(%ebp),%esp
10834c: 5b pop %ebx
10834d: 5e pop %esi
10834e: 5f pop %edi
10834f: c9 leave
108350: c3 ret
108351: 8d 76 00 lea 0x0(%esi),%esi
int malloc_get_statistics(
rtems_malloc_statistics_t *stats
)
{
if ( !stats )
return -1;
108354: b8 ff ff ff ff mov $0xffffffff,%eax
_RTEMS_Lock_allocator();
*stats = rtems_malloc_statistics;
_RTEMS_Unlock_allocator();
return 0;
}
108359: 8d 65 f4 lea -0xc(%ebp),%esp
10835c: 5b pop %ebx
10835d: 5e pop %esi
10835e: 5f pop %edi
10835f: c9 leave
108360: c3 ret
0010872c <malloc_sbrk_extend_and_allocate>:
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
10872c: 55 push %ebp
10872d: 89 e5 mov %esp,%ebp
10872f: 56 push %esi
108730: 53 push %ebx
108731: 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;
108734: 8b 0d ac 75 12 00 mov 0x1275ac,%ecx
if ( sbrk_amount == 0 )
10873a: 85 c9 test %ecx,%ecx
10873c: 75 0a jne 108748 <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;
10873e: 31 c0 xor %eax,%eax
MSBUMP(space_available, the_size);
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
}
108740: 8d 65 f8 lea -0x8(%ebp),%esp
108743: 5b pop %ebx
108744: 5e pop %esi
108745: c9 leave
108746: c3 ret
108747: 90 nop
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
108748: 8d 04 0e lea (%esi,%ecx,1),%eax
10874b: 31 d2 xor %edx,%edx
10874d: f7 f1 div %ecx
10874f: 89 c3 mov %eax,%ebx
108751: 0f af d9 imul %ecx,%ebx
starting_address = (void *) sbrk(the_size);
108754: 83 ec 0c sub $0xc,%esp
108757: 53 push %ebx
108758: e8 ff 7c ff ff call 10045c <sbrk>
if ( starting_address == (void*) -1 )
10875d: 83 c4 10 add $0x10,%esp
108760: 83 f8 ff cmp $0xffffffff,%eax
108763: 74 d9 je 10873e <malloc_sbrk_extend_and_allocate+0x12>
return (void *) 0;
if ( !_Protected_heap_Extend(
108765: 52 push %edx
108766: 53 push %ebx
108767: 50 push %eax
108768: ff 35 90 31 12 00 pushl 0x123190
10876e: e8 3d 4d 00 00 call 10d4b0 <_Protected_heap_Extend>
108773: 83 c4 10 add $0x10,%esp
108776: 84 c0 test %al,%al
108778: 74 1b je 108795 <malloc_sbrk_extend_and_allocate+0x69>
sbrk(-the_size);
errno = ENOMEM;
return (void *) 0;
}
MSBUMP(space_available, the_size);
10877a: 01 1d 80 75 12 00 add %ebx,0x127580
108780: 6a 00 push $0x0
108782: 6a 00 push $0x0
108784: 56 push %esi
108785: ff 35 90 31 12 00 pushl 0x123190
10878b: e8 e8 4c 00 00 call 10d478 <_Protected_heap_Allocate_aligned_with_boundary>
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
108790: 83 c4 10 add $0x10,%esp
108793: eb ab jmp 108740 <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);
108795: 83 ec 0c sub $0xc,%esp
108798: f7 db neg %ebx
10879a: 53 push %ebx
10879b: e8 bc 7c ff ff call 10045c <sbrk>
errno = ENOMEM;
1087a0: e8 3f b1 00 00 call 1138e4 <__errno>
1087a5: c7 00 0c 00 00 00 movl $0xc,(%eax)
return (void *) 0;
1087ab: 83 c4 10 add $0x10,%esp
1087ae: 31 c0 xor %eax,%eax
1087b0: eb 8e jmp 108740 <malloc_sbrk_extend_and_allocate+0x14>
00111e24 <memfile_free_blocks_in_table>:
*/
void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
111e24: 55 push %ebp
111e25: 89 e5 mov %esp,%ebp
111e27: 57 push %edi
111e28: 56 push %esi
111e29: 53 push %ebx
111e2a: 83 ec 0c sub $0xc,%esp
111e2d: 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;
111e30: 8b 45 08 mov 0x8(%ebp),%eax
111e33: 8b 30 mov (%eax),%esi
for ( i=0 ; i<entries ; i++ ) {
111e35: 85 ff test %edi,%edi
111e37: 7e 27 jle 111e60 <memfile_free_blocks_in_table+0x3c><== NEVER TAKEN
111e39: 31 db xor %ebx,%ebx
111e3b: 90 nop
if ( b[i] ) {
111e3c: 8b 04 9e mov (%esi,%ebx,4),%eax
111e3f: 85 c0 test %eax,%eax
111e41: 74 13 je 111e56 <memfile_free_blocks_in_table+0x32>
memfile_free_block( b[i] );
111e43: 83 ec 0c sub $0xc,%esp
111e46: 50 push %eax
111e47: e8 bc ff ff ff call 111e08 <memfile_free_block>
b[i] = 0;
111e4c: c7 04 9e 00 00 00 00 movl $0x0,(%esi,%ebx,4)
111e53: 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++ ) {
111e56: 43 inc %ebx
111e57: 39 df cmp %ebx,%edi
111e59: 7f e1 jg 111e3c <memfile_free_blocks_in_table+0x18>
111e5b: 8b 45 08 mov 0x8(%ebp),%eax
111e5e: 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 );
111e60: 83 ec 0c sub $0xc,%esp
111e63: 56 push %esi
111e64: e8 9f ff ff ff call 111e08 <memfile_free_block>
*block_table = 0;
111e69: 8b 45 08 mov 0x8(%ebp),%eax
111e6c: c7 00 00 00 00 00 movl $0x0,(%eax)
111e72: 83 c4 10 add $0x10,%esp
}
111e75: 8d 65 f4 lea -0xc(%ebp),%esp
111e78: 5b pop %ebx
111e79: 5e pop %esi
111e7a: 5f pop %edi
111e7b: c9 leave
111e7c: c3 ret
001123a0 <memfile_ftruncate>:
*/
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
1123a0: 55 push %ebp
1123a1: 89 e5 mov %esp,%ebp
1123a3: 53 push %ebx
1123a4: 83 ec 14 sub $0x14,%esp
1123a7: 8b 4d 08 mov 0x8(%ebp),%ecx
1123aa: 8b 45 0c mov 0xc(%ebp),%eax
1123ad: 8b 55 10 mov 0x10(%ebp),%edx
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
1123b0: 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 )
1123b3: 39 53 54 cmp %edx,0x54(%ebx)
1123b6: 7f 19 jg 1123d1 <memfile_ftruncate+0x31><== NEVER TAKEN
1123b8: 7d 12 jge 1123cc <memfile_ftruncate+0x2c><== ALWAYS TAKEN
return IMFS_memfile_extend( the_jnode, length );
1123ba: 51 push %ecx
1123bb: 52 push %edx
1123bc: 50 push %eax
1123bd: 53 push %ebx
1123be: e8 45 fc ff ff call 112008 <IMFS_memfile_extend>
1123c3: 83 c4 10 add $0x10,%esp
iop->size = the_jnode->info.file.size;
IMFS_update_atime( the_jnode );
return 0;
}
1123c6: 8b 5d fc mov -0x4(%ebp),%ebx
1123c9: c9 leave
1123ca: c3 ret
1123cb: 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 )
1123cc: 39 43 50 cmp %eax,0x50(%ebx)
1123cf: 72 e9 jb 1123ba <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;
1123d1: 89 43 50 mov %eax,0x50(%ebx)
1123d4: 89 53 54 mov %edx,0x54(%ebx)
iop->size = the_jnode->info.file.size;
1123d7: 89 41 04 mov %eax,0x4(%ecx)
1123da: 89 51 08 mov %edx,0x8(%ecx)
IMFS_update_atime( the_jnode );
1123dd: 83 ec 08 sub $0x8,%esp
1123e0: 6a 00 push $0x0
1123e2: 8d 45 f0 lea -0x10(%ebp),%eax
1123e5: 50 push %eax
1123e6: e8 45 5d ff ff call 108130 <gettimeofday>
1123eb: 8b 45 f0 mov -0x10(%ebp),%eax
1123ee: 89 43 40 mov %eax,0x40(%ebx)
return 0;
1123f1: 83 c4 10 add $0x10,%esp
1123f4: 31 c0 xor %eax,%eax
}
1123f6: 8b 5d fc mov -0x4(%ebp),%ebx
1123f9: c9 leave
1123fa: c3 ret
001123fc <memfile_lseek>:
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
1123fc: 55 push %ebp
1123fd: 89 e5 mov %esp,%ebp
1123ff: 57 push %edi
112400: 56 push %esi
112401: 53 push %ebx
112402: 83 ec 0c sub $0xc,%esp
112405: 8b 5d 08 mov 0x8(%ebp),%ebx
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
112408: 8b 73 18 mov 0x18(%ebx),%esi
if (the_jnode->type == IMFS_LINEAR_FILE) {
11240b: 83 7e 4c 06 cmpl $0x6,0x4c(%esi)
11240f: 74 2f je 112440 <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 ))
112411: 57 push %edi
112412: ff 73 10 pushl 0x10(%ebx)
112415: ff 73 0c pushl 0xc(%ebx)
112418: 56 push %esi
112419: e8 ea fb ff ff call 112008 <IMFS_memfile_extend>
11241e: 83 c4 10 add $0x10,%esp
112421: 85 c0 test %eax,%eax
112423: 75 45 jne 11246a <memfile_lseek+0x6e>
rtems_set_errno_and_return_minus_one( ENOSPC );
iop->size = the_jnode->info.file.size;
112425: 8b 46 50 mov 0x50(%esi),%eax
112428: 8b 56 54 mov 0x54(%esi),%edx
11242b: 89 43 04 mov %eax,0x4(%ebx)
11242e: 89 53 08 mov %edx,0x8(%ebx)
112431: 8b 43 0c mov 0xc(%ebx),%eax
112434: 8b 53 10 mov 0x10(%ebx),%edx
}
return iop->offset;
}
112437: 8d 65 f4 lea -0xc(%ebp),%esp
11243a: 5b pop %ebx
11243b: 5e pop %esi
11243c: 5f pop %edi
11243d: c9 leave
11243e: c3 ret
11243f: 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)
112440: 8b 43 0c mov 0xc(%ebx),%eax
112443: 8b 53 10 mov 0x10(%ebx),%edx
112446: 8b 7e 50 mov 0x50(%esi),%edi
112449: 8b 4e 54 mov 0x54(%esi),%ecx
11244c: 39 ca cmp %ecx,%edx
11244e: 7c e7 jl 112437 <memfile_lseek+0x3b> <== NEVER TAKEN
112450: 7e 12 jle 112464 <memfile_lseek+0x68> <== ALWAYS TAKEN
iop->offset = the_jnode->info.linearfile.size;
112452: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED
112455: 89 4b 10 mov %ecx,0x10(%ebx) <== NOT EXECUTED
112458: 89 f8 mov %edi,%eax <== NOT EXECUTED
11245a: 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;
}
11245c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
11245f: 5b pop %ebx <== NOT EXECUTED
112460: 5e pop %esi <== NOT EXECUTED
112461: 5f pop %edi <== NOT EXECUTED
112462: c9 leave <== NOT EXECUTED
112463: 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)
112464: 39 f8 cmp %edi,%eax
112466: 76 cf jbe 112437 <memfile_lseek+0x3b> <== ALWAYS TAKEN
112468: eb e8 jmp 112452 <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 );
11246a: e8 01 0e 00 00 call 113270 <__errno>
11246f: c7 00 1c 00 00 00 movl $0x1c,(%eax)
112475: b8 ff ff ff ff mov $0xffffffff,%eax
11247a: ba ff ff ff ff mov $0xffffffff,%edx
11247f: eb b6 jmp 112437 <memfile_lseek+0x3b>
001122f8 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
1122f8: 55 push %ebp
1122f9: 89 e5 mov %esp,%ebp
1122fb: 56 push %esi
1122fc: 53 push %ebx
1122fd: 8b 5d 08 mov 0x8(%ebp),%ebx
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
112300: 8b 73 18 mov 0x18(%ebx),%esi
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
112303: 8b 43 14 mov 0x14(%ebx),%eax
112306: a9 04 02 00 00 test $0x204,%eax
11230b: 74 06 je 112313 <memfile_open+0x1b>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
11230d: 83 7e 4c 06 cmpl $0x6,0x4c(%esi)
112311: 74 2d je 112340 <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))
112313: 8b 56 50 mov 0x50(%esi),%edx
112316: 8b 4e 54 mov 0x54(%esi),%ecx
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
112319: f6 c4 02 test $0x2,%ah
11231c: 75 12 jne 112330 <memfile_open+0x38>
iop->offset = the_jnode->info.file.size;
iop->size = the_jnode->info.file.size;
11231e: 89 53 04 mov %edx,0x4(%ebx)
112321: 89 4b 08 mov %ecx,0x8(%ebx)
return 0;
112324: 31 c0 xor %eax,%eax
}
112326: 8d 65 f8 lea -0x8(%ebp),%esp
112329: 5b pop %ebx
11232a: 5e pop %esi
11232b: c9 leave
11232c: c3 ret
11232d: 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;
112330: 89 53 0c mov %edx,0xc(%ebx)
112333: 89 4b 10 mov %ecx,0x10(%ebx)
112336: 8b 56 50 mov 0x50(%esi),%edx
112339: 8b 4e 54 mov 0x54(%esi),%ecx
11233c: eb e0 jmp 11231e <memfile_open+0x26>
11233e: 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;
112340: 8b 46 50 mov 0x50(%esi),%eax <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
112343: 8b 56 58 mov 0x58(%esi),%edx <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
112346: c7 46 4c 05 00 00 00 movl $0x5,0x4c(%esi) <== NOT EXECUTED
the_jnode->info.file.size = 0;
11234d: c7 46 50 00 00 00 00 movl $0x0,0x50(%esi) <== NOT EXECUTED
112354: c7 46 54 00 00 00 00 movl $0x0,0x54(%esi) <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
11235b: c7 46 58 00 00 00 00 movl $0x0,0x58(%esi) <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
112362: c7 46 5c 00 00 00 00 movl $0x0,0x5c(%esi) <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
112369: c7 46 60 00 00 00 00 movl $0x0,0x60(%esi) <== NOT EXECUTED
if ((count != 0)
112370: 85 c0 test %eax,%eax <== NOT EXECUTED
112372: 75 09 jne 11237d <memfile_open+0x85> <== NOT EXECUTED
112374: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED
112377: 31 d2 xor %edx,%edx <== NOT EXECUTED
112379: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
11237b: eb 9c jmp 112319 <memfile_open+0x21> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
11237d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
112380: 50 push %eax <== NOT EXECUTED
112381: 52 push %edx <== NOT EXECUTED
112382: 6a 00 push $0x0 <== NOT EXECUTED
112384: 6a 00 push $0x0 <== NOT EXECUTED
112386: 56 push %esi <== NOT EXECUTED
112387: e8 94 fd ff ff call 112120 <IMFS_memfile_write> <== NOT EXECUTED
11238c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
11238f: 40 inc %eax <== NOT EXECUTED
112390: 74 08 je 11239a <memfile_open+0xa2> <== NOT EXECUTED
112392: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED
112395: e9 79 ff ff ff jmp 112313 <memfile_open+0x1b> <== NOT EXECUTED
return -1;
11239a: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
11239d: eb 87 jmp 112326 <memfile_open+0x2e> <== NOT EXECUTED
0010844c <mknod>:
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
10844c: 55 push %ebp
10844d: 89 e5 mov %esp,%ebp
10844f: 57 push %edi
108450: 56 push %esi
108451: 53 push %ebx
108452: 83 ec 3c sub $0x3c,%esp
108455: 8b 7d 08 mov 0x8(%ebp),%edi
108458: 8b 5d 0c mov 0xc(%ebp),%ebx
10845b: 8b 55 10 mov 0x10(%ebp),%edx
10845e: 8b 4d 14 mov 0x14(%ebp),%ecx
rtems_filesystem_location_info_t temp_loc;
int i;
const char *name_start;
int result;
if ( !(mode & (S_IFREG|S_IFCHR|S_IFBLK|S_IFIFO) ) )
108461: f6 c7 f0 test $0xf0,%bh
108464: 75 1a jne 108480 <mknod+0x34>
rtems_set_errno_and_return_minus_one( EINVAL );
108466: e8 05 ae 00 00 call 113270 <__errno>
10846b: c7 00 16 00 00 00 movl $0x16,(%eax)
108471: 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;
}
108476: 8d 65 f4 lea -0xc(%ebp),%esp
108479: 5b pop %ebx
10847a: 5e pop %esi
10847b: 5f pop %edi
10847c: c9 leave
10847d: c3 ret
10847e: 66 90 xchg %ax,%ax
int result;
if ( !(mode & (S_IFREG|S_IFCHR|S_IFBLK|S_IFIFO) ) )
rtems_set_errno_and_return_minus_one( EINVAL );
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
108480: 50 push %eax
108481: 8d 75 cc lea -0x34(%ebp),%esi
108484: 56 push %esi
108485: 8d 45 e4 lea -0x1c(%ebp),%eax
108488: 50 push %eax
108489: 57 push %edi
10848a: 89 55 c4 mov %edx,-0x3c(%ebp)
10848d: 89 4d c0 mov %ecx,-0x40(%ebp)
108490: e8 1f 0a 00 00 call 108eb4 <rtems_filesystem_get_start_loc>
result = (*temp_loc.ops->evalformake_h)(
108495: 83 c4 0c add $0xc,%esp
108498: 8d 45 e0 lea -0x20(%ebp),%eax
10849b: 50 push %eax
10849c: 56 push %esi
10849d: 03 7d e4 add -0x1c(%ebp),%edi
1084a0: 57 push %edi
1084a1: 8b 45 d8 mov -0x28(%ebp),%eax
1084a4: ff 50 04 call *0x4(%eax)
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
1084a7: 83 c4 10 add $0x10,%esp
1084aa: 85 c0 test %eax,%eax
1084ac: 8b 55 c4 mov -0x3c(%ebp),%edx
1084af: 8b 4d c0 mov -0x40(%ebp),%ecx
1084b2: 74 10 je 1084c4 <mknod+0x78>
return -1;
1084b4: 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;
}
1084b9: 8d 65 f4 lea -0xc(%ebp),%esp
1084bc: 5b pop %ebx
1084bd: 5e pop %esi
1084be: 5f pop %edi
1084bf: c9 leave
1084c0: c3 ret
1084c1: 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 );
1084c4: 83 ec 0c sub $0xc,%esp
1084c7: 56 push %esi
1084c8: 51 push %ecx
1084c9: 52 push %edx
1084ca: 53 push %ebx
1084cb: ff 75 e0 pushl -0x20(%ebp)
1084ce: 8b 45 d8 mov -0x28(%ebp),%eax
1084d1: ff 50 14 call *0x14(%eax)
rtems_filesystem_freenode( &temp_loc );
1084d4: 83 c4 14 add $0x14,%esp
1084d7: 56 push %esi
1084d8: 89 45 c4 mov %eax,-0x3c(%ebp)
1084db: e8 c0 fb ff ff call 1080a0 <rtems_filesystem_freenode>
return result;
1084e0: 83 c4 10 add $0x10,%esp
1084e3: 8b 45 c4 mov -0x3c(%ebp),%eax
}
1084e6: 8d 65 f4 lea -0xc(%ebp),%esp
1084e9: 5b pop %ebx
1084ea: 5e pop %esi
1084eb: 5f pop %edi
1084ec: c9 leave
1084ed: c3 ret
00108574 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
108574: 55 push %ebp
108575: 89 e5 mov %esp,%ebp
108577: 57 push %edi
108578: 56 push %esi
108579: 53 push %ebx
10857a: 83 ec 4c sub $0x4c,%esp
10857d: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
108580: 83 7d 14 01 cmpl $0x1,0x14(%ebp)
108584: 0f 87 36 02 00 00 ja 1087c0 <mount+0x24c>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
10858a: 83 ec 0c sub $0xc,%esp
10858d: 56 push %esi
10858e: e8 19 7b 00 00 call 1100ac <rtems_filesystem_get_mount_handler>
108593: 89 45 b8 mov %eax,-0x48(%ebp)
if ( !mount_h )
108596: 83 c4 10 add $0x10,%esp
108599: 85 c0 test %eax,%eax
10859b: 0f 84 1f 02 00 00 je 1087c0 <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;
1085a1: 8b 45 0c mov 0xc(%ebp),%eax
1085a4: 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 : "/";
1085a6: 0f 95 45 b7 setne -0x49(%ebp)
1085aa: 0f 84 e8 01 00 00 je 108798 <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(
1085b0: 31 c0 xor %eax,%eax
1085b2: b9 ff ff ff ff mov $0xffffffff,%ecx
1085b7: 8b 7d 0c mov 0xc(%ebp),%edi
1085ba: f2 ae repnz scas %es:(%edi),%al
1085bc: f7 d1 not %ecx
1085be: 8d 41 ff lea -0x1(%ecx),%eax
1085c1: 89 45 ac mov %eax,-0x54(%ebp)
1085c4: 89 4d bc mov %ecx,-0x44(%ebp)
1085c7: 8b 55 0c mov 0xc(%ebp),%edx
1085ca: 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;
1085cd: ba ff ff ff ff mov $0xffffffff,%edx
1085d2: 31 c0 xor %eax,%eax
1085d4: 89 d1 mov %edx,%ecx
1085d6: 89 f7 mov %esi,%edi
1085d8: f2 ae repnz scas %es:(%edi),%al
1085da: f7 d1 not %ecx
1085dc: 89 4d c4 mov %ecx,-0x3c(%ebp)
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
1085df: 8b 7d 08 mov 0x8(%ebp),%edi
1085e2: 85 ff test %edi,%edi
1085e4: 0f 84 ca 01 00 00 je 1087b4 <mount+0x240>
1085ea: 89 d1 mov %edx,%ecx
1085ec: 8b 7d 08 mov 0x8(%ebp),%edi
1085ef: f2 ae repnz scas %es:(%edi),%al
1085f1: f7 d1 not %ecx
1085f3: 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 );
1085f6: 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;
1085f9: 8b 55 bc mov -0x44(%ebp),%edx
1085fc: 8b 7d c4 mov -0x3c(%ebp),%edi
1085ff: 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 )
108603: 03 45 c0 add -0x40(%ebp),%eax
+ filesystemtype_size + source_size + target_size;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
108606: 50 push %eax
108607: 6a 01 push $0x1
108609: e8 16 f9 ff ff call 107f24 <calloc>
10860e: 89 c3 mov %eax,%ebx
if ( mt_entry != NULL ) {
108610: 83 c4 10 add $0x10,%esp
108613: 85 c0 test %eax,%eax
108615: 0f 84 65 01 00 00 je 108780 <mount+0x20c> <== NEVER TAKEN
char *str = (char *) mt_entry + sizeof( *mt_entry );
10861b: 8d 40 74 lea 0x74(%eax),%eax
memcpy( str, filesystemtype, filesystemtype_size );
10861e: 89 c7 mov %eax,%edi
108620: 8b 4d c4 mov -0x3c(%ebp),%ecx
108623: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
108625: 89 fa mov %edi,%edx
mt_entry->type = str;
108627: 89 43 6c mov %eax,0x6c(%ebx)
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
10862a: 8b 75 08 mov 0x8(%ebp),%esi
10862d: 8b 4d c0 mov -0x40(%ebp),%ecx
108630: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
108632: 89 f8 mov %edi,%eax
mt_entry->dev = str;
108634: 89 53 70 mov %edx,0x70(%ebx)
str += source_size;
memcpy( str, target, target_size );
108637: 8b 75 b0 mov -0x50(%ebp),%esi
10863a: 8b 4d bc mov -0x44(%ebp),%ecx
10863d: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
mt_entry->target = str;
10863f: 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;
108642: 89 5b 2c mov %ebx,0x2c(%ebx)
mt_entry->options = options;
108645: 8b 45 14 mov 0x14(%ebp),%eax
108648: 89 43 30 mov %eax,0x30(%ebx)
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
10864b: 8d 7b 38 lea 0x38(%ebx),%edi
10864e: be 60 13 12 00 mov $0x121360,%esi
108653: b1 0c mov $0xc,%cl
108655: 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 ) {
108657: 80 7d b7 00 cmpb $0x0,-0x49(%ebp)
10865b: 0f 85 83 00 00 00 jne 1086e4 <mount+0x170>
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
108661: 81 3d 64 58 12 00 68 cmpl $0x125868,0x125864
108668: 58 12 00
10866b: 0f 85 67 01 00 00 jne 1087d8 <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;
108671: 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 ) ) {
108673: 83 ec 08 sub $0x8,%esp
108676: ff 75 18 pushl 0x18(%ebp)
108679: 53 push %ebx
10867a: ff 55 b8 call *-0x48(%ebp)
10867d: 83 c4 10 add $0x10,%esp
108680: 85 c0 test %eax,%eax
108682: 0f 85 74 01 00 00 jne 1087fc <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 );
108688: 56 push %esi
108689: 6a 00 push $0x0
10868b: 6a 00 push $0x0
10868d: ff 35 28 7c 12 00 pushl 0x127c28
108693: e8 18 30 00 00 call 10b6b0 <rtems_semaphore_obtain>
108698: 5a pop %edx
108699: 59 pop %ecx
10869a: 53 push %ebx
10869b: 68 64 58 12 00 push $0x125864
1086a0: e8 33 39 00 00 call 10bfd8 <_Chain_Append>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
1086a5: 58 pop %eax
1086a6: ff 35 28 7c 12 00 pushl 0x127c28
1086ac: e8 fb 30 00 00 call 10b7ac <rtems_semaphore_release>
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
1086b1: 83 c4 10 add $0x10,%esp
1086b4: 80 7d b7 00 cmpb $0x0,-0x49(%ebp)
1086b8: 74 0a je 1086c4 <mount+0x150>
rtems_filesystem_root = mt_entry->mt_fs_root;
return 0;
1086ba: 31 c0 xor %eax,%eax
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
}
1086bc: 8d 65 f4 lea -0xc(%ebp),%esp
1086bf: 5b pop %ebx
1086c0: 5e pop %esi
1086c1: 5f pop %edi
1086c2: c9 leave
1086c3: 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;
1086c4: 8b 3d 90 59 12 00 mov 0x125990,%edi
1086ca: 83 c7 18 add $0x18,%edi
1086cd: 8d 73 1c lea 0x1c(%ebx),%esi
1086d0: b9 05 00 00 00 mov $0x5,%ecx
1086d5: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return 0;
1086d7: 31 c0 xor %eax,%eax
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
}
1086d9: 8d 65 f4 lea -0xc(%ebp),%esp
1086dc: 5b pop %ebx
1086dd: 5e pop %esi
1086de: 5f pop %edi
1086df: c9 leave
1086e0: c3 ret
1086e1: 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(
1086e4: 83 ec 0c sub $0xc,%esp
1086e7: 6a 01 push $0x1
1086e9: 8d 75 d4 lea -0x2c(%ebp),%esi
1086ec: 56 push %esi
1086ed: 6a 07 push $0x7
1086ef: ff 75 ac pushl -0x54(%ebp)
1086f2: ff 75 0c pushl 0xc(%ebp)
1086f5: e8 ce f8 ff ff call 107fc8 <rtems_filesystem_evaluate_path>
1086fa: 83 c4 20 add $0x20,%esp
1086fd: 40 inc %eax
1086fe: 0f 84 df 00 00 00 je 1087e3 <mount+0x26f> <== NEVER TAKEN
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
108704: 83 ec 0c sub $0xc,%esp
108707: 56 push %esi
108708: 8b 45 e0 mov -0x20(%ebp),%eax
10870b: ff 50 10 call *0x10(%eax)
10870e: 83 c4 10 add $0x10,%esp
108711: 48 dec %eax
108712: 0f 85 0c 01 00 00 jne 108824 <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 ) ) {
108718: 83 ec 08 sub $0x8,%esp
10871b: ff 75 d4 pushl -0x2c(%ebp)
10871e: 68 f0 84 10 00 push $0x1084f0
108723: e8 dc fd ff ff call 108504 <rtems_filesystem_mount_iterate>
108728: 83 c4 10 add $0x10,%esp
10872b: 84 c0 test %al,%al
10872d: 0f 85 01 01 00 00 jne 108834 <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;
108733: 8b 45 d4 mov -0x2c(%ebp),%eax
108736: 89 43 08 mov %eax,0x8(%ebx)
mt_entry->mt_point_node.handlers = loc.handlers;
108739: 8b 45 dc mov -0x24(%ebp),%eax
10873c: 89 43 10 mov %eax,0x10(%ebx)
mt_entry->mt_point_node.ops = loc.ops;
10873f: 8b 45 e0 mov -0x20(%ebp),%eax
108742: 89 43 14 mov %eax,0x14(%ebx)
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
108745: 8b 55 e4 mov -0x1c(%ebp),%edx
108748: 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 ) ) {
10874b: 83 ec 0c sub $0xc,%esp
10874e: 53 push %ebx
10874f: ff 50 20 call *0x20(%eax)
108752: 83 c4 10 add $0x10,%esp
108755: 85 c0 test %eax,%eax
108757: 0f 84 16 ff ff ff je 108673 <mount+0xff> <== ALWAYS TAKEN
return 0;
cleanup_and_bail:
free( mt_entry );
10875d: 83 ec 0c sub $0xc,%esp
108760: 53 push %ebx
108761: e8 4e f9 ff ff call 1080b4 <free>
108766: 83 c4 10 add $0x10,%esp
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
108769: 83 ec 0c sub $0xc,%esp
10876c: 56 push %esi
10876d: e8 2e f9 ff ff call 1080a0 <rtems_filesystem_freenode>
108772: 83 c4 10 add $0x10,%esp
return -1;
108775: b8 ff ff ff ff mov $0xffffffff,%eax
10877a: e9 3d ff ff ff jmp 1086bc <mount+0x148>
10877f: 90 nop
target,
filesystemtype,
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
108780: e8 eb aa 00 00 call 113270 <__errno> <== NOT EXECUTED
108785: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
10878b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
}
108790: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
108793: 5b pop %ebx <== NOT EXECUTED
108794: 5e pop %esi <== NOT EXECUTED
108795: 5f pop %edi <== NOT EXECUTED
108796: c9 leave <== NOT EXECUTED
108797: 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 : "/";
108798: c7 45 bc 02 00 00 00 movl $0x2,-0x44(%ebp)
10879f: c7 45 ac 01 00 00 00 movl $0x1,-0x54(%ebp)
1087a6: c7 45 b0 07 13 12 00 movl $0x121307,-0x50(%ebp)
1087ad: e9 1b fe ff ff jmp 1085cd <mount+0x59>
1087b2: 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;
1087b4: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp)
1087bb: e9 36 fe ff ff jmp 1085f6 <mount+0x82>
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
if ( !mount_h )
rtems_set_errno_and_return_minus_one( EINVAL );
1087c0: e8 ab aa 00 00 call 113270 <__errno>
1087c5: c7 00 16 00 00 00 movl $0x16,(%eax)
1087cb: b8 ff ff ff ff mov $0xffffffff,%eax
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
}
1087d0: 8d 65 f4 lea -0xc(%ebp),%esp
1087d3: 5b pop %ebx
1087d4: 5e pop %esi
1087d5: 5f pop %edi
1087d6: c9 leave
1087d7: c3 ret
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
errno = EINVAL;
1087d8: e8 93 aa 00 00 call 113270 <__errno> <== NOT EXECUTED
1087dd: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( mt_entry );
1087e3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1087e6: 53 push %ebx <== NOT EXECUTED
1087e7: e8 c8 f8 ff ff call 1080b4 <free> <== NOT EXECUTED
1087ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
1087ef: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
1087f4: e9 c3 fe ff ff jmp 1086bc <mount+0x148> <== NOT EXECUTED
1087f9: 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 );
1087fc: 83 ec 0c sub $0xc,%esp
1087ff: 53 push %ebx
108800: 8b 45 e0 mov -0x20(%ebp),%eax
108803: ff 50 28 call *0x28(%eax)
return 0;
cleanup_and_bail:
free( mt_entry );
108806: 89 1c 24 mov %ebx,(%esp)
108809: e8 a6 f8 ff ff call 1080b4 <free>
if ( loc_to_free )
10880e: 83 c4 10 add $0x10,%esp
108811: 85 f6 test %esi,%esi
108813: 0f 85 50 ff ff ff jne 108769 <mount+0x1f5> <== ALWAYS TAKEN
rtems_filesystem_freenode( loc_to_free );
return -1;
108819: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10881e: e9 99 fe ff ff jmp 1086bc <mount+0x148> <== NOT EXECUTED
108823: 90 nop <== NOT EXECUTED
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
errno = ENOTDIR;
108824: e8 47 aa 00 00 call 113270 <__errno>
108829: c7 00 14 00 00 00 movl $0x14,(%eax)
goto cleanup_and_bail;
10882f: e9 29 ff ff ff jmp 10875d <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;
108834: e8 37 aa 00 00 call 113270 <__errno>
108839: c7 00 10 00 00 00 movl $0x10,(%eax)
goto cleanup_and_bail;
10883f: e9 19 ff ff ff jmp 10875d <mount+0x1e9>
00108b88 <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
108b88: 55 push %ebp
108b89: 89 e5 mov %esp,%ebp
108b8b: 57 push %edi
108b8c: 56 push %esi
108b8d: 53 push %ebx
108b8e: 83 ec 1c sub $0x1c,%esp
108b91: 8b 45 08 mov 0x8(%ebp),%eax
108b94: 89 45 e4 mov %eax,-0x1c(%ebp)
108b97: 8b 5d 0c mov 0xc(%ebp),%ebx
108b9a: 8b 75 10 mov 0x10(%ebp),%esi
108b9d: 8b 7d 14 mov 0x14(%ebp),%edi
108ba0: 8b 45 18 mov 0x18(%ebp),%eax
108ba3: 89 45 e0 mov %eax,-0x20(%ebp)
int rv = -1;
if (target != NULL) {
108ba6: 85 db test %ebx,%ebx
108ba8: 74 3f je 108be9 <mount_and_make_target_path+0x61>
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
108baa: 83 ec 08 sub $0x8,%esp
108bad: 68 ff 01 00 00 push $0x1ff
108bb2: 53 push %ebx
108bb3: e8 08 0a 00 00 call 1095c0 <rtems_mkdir>
if (rv == 0) {
108bb8: 83 c4 10 add $0x10,%esp
108bbb: 85 c0 test %eax,%eax
108bbd: 74 09 je 108bc8 <mount_and_make_target_path+0x40><== ALWAYS TAKEN
} else {
errno = EINVAL;
}
return rv;
}
108bbf: 8d 65 f4 lea -0xc(%ebp),%esp
108bc2: 5b pop %ebx
108bc3: 5e pop %esi
108bc4: 5f pop %edi
108bc5: c9 leave
108bc6: c3 ret
108bc7: 90 nop
int rv = -1;
if (target != NULL) {
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv == 0) {
rv = mount(
108bc8: 8b 45 e0 mov -0x20(%ebp),%eax
108bcb: 89 45 18 mov %eax,0x18(%ebp)
108bce: 89 7d 14 mov %edi,0x14(%ebp)
108bd1: 89 75 10 mov %esi,0x10(%ebp)
108bd4: 89 5d 0c mov %ebx,0xc(%ebp)
108bd7: 8b 45 e4 mov -0x1c(%ebp),%eax
108bda: 89 45 08 mov %eax,0x8(%ebp)
} else {
errno = EINVAL;
}
return rv;
}
108bdd: 8d 65 f4 lea -0xc(%ebp),%esp
108be0: 5b pop %ebx
108be1: 5e pop %esi
108be2: 5f pop %edi
108be3: c9 leave
int rv = -1;
if (target != NULL) {
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv == 0) {
rv = mount(
108be4: e9 97 00 00 00 jmp 108c80 <mount>
options,
data
);
}
} else {
errno = EINVAL;
108be9: e8 76 ad 00 00 call 113964 <__errno>
108bee: c7 00 16 00 00 00 movl $0x16,(%eax)
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
108bf4: b8 ff ff ff ff mov $0xffffffff,%eax
108bf9: eb c4 jmp 108bbf <mount_and_make_target_path+0x37>
0010fb14 <mq_open>:
int oflag,
...
/* mode_t mode, */
/* struct mq_attr attr */
)
{
10fb14: 55 push %ebp
10fb15: 89 e5 mov %esp,%ebp
10fb17: 57 push %edi
10fb18: 56 push %esi
10fb19: 53 push %ebx
10fb1a: 83 ec 2c sub $0x2c,%esp
10fb1d: 8b 75 0c mov 0xc(%ebp),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10fb20: a1 f0 0e 13 00 mov 0x130ef0,%eax
10fb25: 40 inc %eax
10fb26: a3 f0 0e 13 00 mov %eax,0x130ef0
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
10fb2b: 89 f0 mov %esi,%eax
10fb2d: 25 00 02 00 00 and $0x200,%eax
10fb32: 89 45 d4 mov %eax,-0x2c(%ebp)
10fb35: 0f 85 c9 00 00 00 jne 10fc04 <mq_open+0xf0>
/* struct mq_attr attr */
)
{
va_list arg;
mode_t mode;
struct mq_attr *attr = NULL;
10fb3b: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *
_POSIX_Message_queue_Allocate_fd( void )
{
return (POSIX_Message_queue_Control_fd *)
_Objects_Allocate( &_POSIX_Message_queue_Information_fds );
10fb42: 83 ec 0c sub $0xc,%esp
10fb45: 68 20 14 13 00 push $0x131420
10fb4a: e8 55 2c 00 00 call 1127a4 <_Objects_Allocate>
10fb4f: 89 c3 mov %eax,%ebx
attr = (struct mq_attr *) va_arg( arg, struct mq_attr * );
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
10fb51: 83 c4 10 add $0x10,%esp
10fb54: 85 c0 test %eax,%eax
10fb56: 0f 84 b4 00 00 00 je 10fc10 <mq_open+0xfc>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
the_mq_fd->oflag = oflag;
10fb5c: 89 70 14 mov %esi,0x14(%eax)
status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id );
10fb5f: 83 ec 08 sub $0x8,%esp
10fb62: 8d 45 e4 lea -0x1c(%ebp),%eax
10fb65: 50 push %eax
10fb66: ff 75 08 pushl 0x8(%ebp)
10fb69: e8 c2 69 00 00 call 116530 <_POSIX_Message_queue_Name_to_id>
10fb6e: 89 c7 mov %eax,%edi
* If the name to id translation worked, then the message queue exists
* and we can just return a pointer to the id. Otherwise we may
* need to check to see if this is a "message queue does not exist"
* or some other miscellaneous error on the name.
*/
if ( status ) {
10fb70: 83 c4 10 add $0x10,%esp
10fb73: 85 c0 test %eax,%eax
10fb75: 75 59 jne 10fbd0 <mq_open+0xbc>
} else { /* name -> ID translation succeeded */
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
10fb77: 81 e6 00 0a 00 00 and $0xa00,%esi
10fb7d: 81 fe 00 0a 00 00 cmp $0xa00,%esi
10fb83: 0f 84 a7 00 00 00 je 10fc30 <mq_open+0x11c>
Objects_Id id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control *)
_Objects_Get( &_POSIX_Message_queue_Information, id, location );
10fb89: 50 push %eax
/*
* In this case we need to do an ID->pointer conversion to
* check the mode.
*/
the_mq = _POSIX_Message_queue_Get( the_mq_id, &location );
10fb8a: 8d 45 dc lea -0x24(%ebp),%eax
10fb8d: 50 push %eax
10fb8e: ff 75 e4 pushl -0x1c(%ebp)
10fb91: 68 80 12 13 00 push $0x131280
10fb96: e8 bd 30 00 00 call 112c58 <_Objects_Get>
10fb9b: 89 45 e0 mov %eax,-0x20(%ebp)
the_mq->open_count += 1;
10fb9e: ff 40 18 incl 0x18(%eax)
the_mq_fd->Queue = the_mq;
10fba1: 89 43 10 mov %eax,0x10(%ebx)
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
10fba4: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10fba8: a1 3c 14 13 00 mov 0x13143c,%eax
10fbad: 89 1c 90 mov %ebx,(%eax,%edx,4)
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
10fbb0: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
_Objects_Open_string(
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
10fbb7: e8 94 3c 00 00 call 113850 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
10fbbc: e8 8f 3c 00 00 call 113850 <_Thread_Enable_dispatch>
return (mqd_t)the_mq_fd->Object.id;
10fbc1: 8b 43 08 mov 0x8(%ebx),%eax
10fbc4: 83 c4 10 add $0x10,%esp
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
10fbc7: 8d 65 f4 lea -0xc(%ebp),%esp
10fbca: 5b pop %ebx
10fbcb: 5e pop %esi
10fbcc: 5f pop %edi
10fbcd: c9 leave
10fbce: c3 ret
10fbcf: 90 nop
if ( status ) {
/*
* Unless provided a valid name that did not already exist
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
10fbd0: 83 f8 02 cmp $0x2,%eax
10fbd3: 0f 84 87 00 00 00 je 10fc60 <mq_open+0x14c>
RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd (
POSIX_Message_queue_Control_fd *the_mq_fd
)
{
_Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object );
10fbd9: 83 ec 08 sub $0x8,%esp
10fbdc: 53 push %ebx
10fbdd: 68 20 14 13 00 push $0x131420
10fbe2: e8 31 2f 00 00 call 112b18 <_Objects_Free>
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
10fbe7: e8 64 3c 00 00 call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, mqd_t );
10fbec: e8 23 9c 00 00 call 119814 <__errno>
10fbf1: 89 38 mov %edi,(%eax)
10fbf3: 83 c4 10 add $0x10,%esp
10fbf6: b8 ff ff ff ff mov $0xffffffff,%eax
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
10fbfb: 8d 65 f4 lea -0xc(%ebp),%esp
10fbfe: 5b pop %ebx
10fbff: 5e pop %esi
10fc00: 5f pop %edi
10fc01: c9 leave
10fc02: c3 ret
10fc03: 90 nop
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
attr = (struct mq_attr *) va_arg( arg, struct mq_attr * );
10fc04: 8b 45 14 mov 0x14(%ebp),%eax
10fc07: 89 45 d0 mov %eax,-0x30(%ebp)
10fc0a: e9 33 ff ff ff jmp 10fb42 <mq_open+0x2e>
10fc0f: 90 nop
va_end(arg);
}
the_mq_fd = _POSIX_Message_queue_Allocate_fd();
if ( !the_mq_fd ) {
_Thread_Enable_dispatch();
10fc10: e8 3b 3c 00 00 call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENFILE );
10fc15: e8 fa 9b 00 00 call 119814 <__errno>
10fc1a: c7 00 17 00 00 00 movl $0x17,(%eax)
10fc20: b8 ff ff ff ff mov $0xffffffff,%eax
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
10fc25: 8d 65 f4 lea -0xc(%ebp),%esp
10fc28: 5b pop %ebx
10fc29: 5e pop %esi
10fc2a: 5f pop %edi
10fc2b: c9 leave
10fc2c: c3 ret
10fc2d: 8d 76 00 lea 0x0(%esi),%esi
10fc30: 83 ec 08 sub $0x8,%esp
10fc33: 53 push %ebx
10fc34: 68 20 14 13 00 push $0x131420
10fc39: e8 da 2e 00 00 call 112b18 <_Objects_Free>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
10fc3e: e8 0d 3c 00 00 call 113850 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t );
10fc43: e8 cc 9b 00 00 call 119814 <__errno>
10fc48: c7 00 11 00 00 00 movl $0x11,(%eax)
10fc4e: 83 c4 10 add $0x10,%esp
10fc51: b8 ff ff ff ff mov $0xffffffff,%eax
);
_Thread_Enable_dispatch();
return (mqd_t) the_mq_fd->Object.id;
}
10fc56: 8d 65 f4 lea -0xc(%ebp),%esp
10fc59: 5b pop %ebx
10fc5a: 5e pop %esi
10fc5b: 5f pop %edi
10fc5c: c9 leave
10fc5d: c3 ret
10fc5e: 66 90 xchg %ax,%ax
if ( status ) {
/*
* Unless provided a valid name that did not already exist
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
10fc60: 8b 55 d4 mov -0x2c(%ebp),%edx
10fc63: 85 d2 test %edx,%edx
10fc65: 0f 84 6e ff ff ff je 10fbd9 <mq_open+0xc5>
/*
* At this point, the message queue does not exist and everything has been
* checked. We should go ahead and create a message queue.
*/
status = _POSIX_Message_queue_Create_support(
10fc6b: 8d 45 e0 lea -0x20(%ebp),%eax
10fc6e: 50 push %eax
10fc6f: ff 75 d0 pushl -0x30(%ebp)
10fc72: 6a 01 push $0x1
10fc74: ff 75 08 pushl 0x8(%ebp)
10fc77: e8 2c 67 00 00 call 1163a8 <_POSIX_Message_queue_Create_support>
);
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
10fc7c: 83 c4 10 add $0x10,%esp
10fc7f: 40 inc %eax
10fc80: 74 26 je 10fca8 <mq_open+0x194>
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
return (mqd_t) -1;
}
the_mq_fd->Queue = the_mq;
10fc82: 8b 45 e0 mov -0x20(%ebp),%eax
10fc85: 89 43 10 mov %eax,0x10(%ebx)
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
10fc88: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10fc8c: a1 3c 14 13 00 mov 0x13143c,%eax
10fc91: 89 1c 90 mov %ebx,(%eax,%edx,4)
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
10fc94: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
&_POSIX_Message_queue_Information_fds,
&the_mq_fd->Object,
NULL
);
_Thread_Enable_dispatch();
10fc9b: e8 b0 3b 00 00 call 113850 <_Thread_Enable_dispatch>
return (mqd_t) the_mq_fd->Object.id;
10fca0: 8b 43 08 mov 0x8(%ebx),%eax
10fca3: e9 1f ff ff ff jmp 10fbc7 <mq_open+0xb3>
10fca8: 83 ec 08 sub $0x8,%esp
10fcab: 53 push %ebx
10fcac: 68 20 14 13 00 push $0x131420
10fcb1: e8 62 2e 00 00 call 112b18 <_Objects_Free>
/*
* errno was set by Create_support, so don't set it again.
*/
if ( status == -1 ) {
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
10fcb6: e8 95 3b 00 00 call 113850 <_Thread_Enable_dispatch>
return (mqd_t) -1;
10fcbb: 83 c4 10 add $0x10,%esp
10fcbe: b8 ff ff ff ff mov $0xffffffff,%eax
10fcc3: e9 ff fe ff ff jmp 10fbc7 <mq_open+0xb3>
0011fe04 <nanosleep>:
int nanosleep(
const struct timespec *rqtp,
struct timespec *rmtp
)
{
11fe04: 55 push %ebp
11fe05: 89 e5 mov %esp,%ebp
11fe07: 56 push %esi
11fe08: 53 push %ebx
11fe09: 8b 75 08 mov 0x8(%ebp),%esi
11fe0c: 8b 5d 0c mov 0xc(%ebp),%ebx
* Return EINVAL if the delay interval is negative.
*
* NOTE: This behavior is beyond the POSIX specification.
* FSU and GNU/Linux pthreads shares this behavior.
*/
if ( !_Timespec_Is_valid( rqtp ) )
11fe0f: 83 ec 0c sub $0xc,%esp
11fe12: 56 push %esi
11fe13: e8 80 01 00 00 call 11ff98 <_Timespec_Is_valid>
11fe18: 83 c4 10 add $0x10,%esp
11fe1b: 84 c0 test %al,%al
11fe1d: 0f 84 e1 00 00 00 je 11ff04 <nanosleep+0x100>
rtems_set_errno_and_return_minus_one( EINVAL );
ticks = _Timespec_To_ticks( rqtp );
11fe23: 83 ec 0c sub $0xc,%esp
11fe26: 56 push %esi
11fe27: e8 6c 1f ff ff call 111d98 <_Timespec_To_ticks>
11fe2c: 89 c6 mov %eax,%esi
* A nanosleep for zero time is implemented as a yield.
* This behavior is also beyond the POSIX specification but is
* consistent with the RTEMS API and yields desirable behavior.
*/
if ( !ticks ) {
11fe2e: 83 c4 10 add $0x10,%esp
11fe31: 85 c0 test %eax,%eax
11fe33: 75 37 jne 11fe6c <nanosleep+0x68>
11fe35: a1 90 8c 12 00 mov 0x128c90,%eax
11fe3a: 40 inc %eax
11fe3b: a3 90 8c 12 00 mov %eax,0x128c90
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
11fe40: ff 15 0c 48 12 00 call *0x12480c
_Thread_Disable_dispatch();
_Scheduler_Yield();
_Thread_Enable_dispatch();
11fe46: e8 75 df fe ff call 10ddc0 <_Thread_Enable_dispatch>
if ( rmtp ) {
11fe4b: 85 db test %ebx,%ebx
11fe4d: 0f 84 93 00 00 00 je 11fee6 <nanosleep+0xe2>
rmtp->tv_sec = 0;
11fe53: c7 03 00 00 00 00 movl $0x0,(%ebx)
rmtp->tv_nsec = 0;
11fe59: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
}
return 0;
11fe60: 31 c0 xor %eax,%eax
rtems_set_errno_and_return_minus_one( EINTR );
#endif
}
return 0;
}
11fe62: 8d 65 f8 lea -0x8(%ebp),%esp
11fe65: 5b pop %ebx
11fe66: 5e pop %esi
11fe67: c9 leave
11fe68: c3 ret
11fe69: 8d 76 00 lea 0x0(%esi),%esi
11fe6c: a1 90 8c 12 00 mov 0x128c90,%eax
11fe71: 40 inc %eax
11fe72: a3 90 8c 12 00 mov %eax,0x128c90
/*
* Block for the desired amount of time
*/
_Thread_Disable_dispatch();
_Thread_Set_state(
11fe77: 83 ec 08 sub $0x8,%esp
11fe7a: 68 08 00 00 10 push $0x10000008
11fe7f: ff 35 38 92 12 00 pushl 0x129238
11fe85: e8 56 e7 fe ff call 10e5e0 <_Thread_Set_state>
STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Watchdog_Initialize(
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
11fe8a: 8b 15 38 92 12 00 mov 0x129238,%edx
_Thread_Disable_dispatch();
_Thread_Set_state(
_Thread_Executing,
STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Watchdog_Initialize(
11fe90: 8b 42 08 mov 0x8(%edx),%eax
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
11fe93: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx)
the_watchdog->routine = routine;
11fe9a: c7 42 64 0c dc 10 00 movl $0x10dc0c,0x64(%edx)
the_watchdog->id = id;
11fea1: 89 42 68 mov %eax,0x68(%edx)
the_watchdog->user_data = user_data;
11fea4: c7 42 6c 00 00 00 00 movl $0x0,0x6c(%edx)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
11feab: 89 72 54 mov %esi,0x54(%edx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
11feae: 58 pop %eax
11feaf: 59 pop %ecx
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
11feb0: 83 c2 48 add $0x48,%edx
11feb3: 52 push %edx
11feb4: 68 60 8d 12 00 push $0x128d60
11feb9: e8 ea ec fe ff call 10eba8 <_Watchdog_Insert>
_Thread_Enable_dispatch();
11febe: e8 fd de fe ff call 10ddc0 <_Thread_Enable_dispatch>
/* calculate time remaining */
if ( rmtp ) {
11fec3: 83 c4 10 add $0x10,%esp
11fec6: 85 db test %ebx,%ebx
11fec8: 74 1c je 11fee6 <nanosleep+0xe2>
ticks -=
_Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
11feca: a1 38 92 12 00 mov 0x129238,%eax
11fecf: 03 70 5c add 0x5c(%eax),%esi
_Thread_Enable_dispatch();
/* calculate time remaining */
if ( rmtp ) {
ticks -=
11fed2: 2b 70 60 sub 0x60(%eax),%esi
_Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
_Timespec_From_ticks( ticks, rmtp );
11fed5: 83 ec 08 sub $0x8,%esp
11fed8: 53 push %ebx
11fed9: 56 push %esi
11feda: e8 71 00 00 00 call 11ff50 <_Timespec_From_ticks>
*/
#if defined(RTEMS_POSIX_API)
/*
* If there is time remaining, then we were interrupted by a signal.
*/
if ( ticks )
11fedf: 83 c4 10 add $0x10,%esp
11fee2: 85 f6 test %esi,%esi
11fee4: 75 09 jne 11feef <nanosleep+0xeb>
rtems_set_errno_and_return_minus_one( EINTR );
#endif
}
return 0;
11fee6: 31 c0 xor %eax,%eax
}
11fee8: 8d 65 f8 lea -0x8(%ebp),%esp
11feeb: 5b pop %ebx
11feec: 5e pop %esi
11feed: c9 leave
11feee: c3 ret
#if defined(RTEMS_POSIX_API)
/*
* If there is time remaining, then we were interrupted by a signal.
*/
if ( ticks )
rtems_set_errno_and_return_minus_one( EINTR );
11feef: e8 1c 38 ff ff call 113710 <__errno>
11fef4: c7 00 04 00 00 00 movl $0x4,(%eax)
11fefa: b8 ff ff ff ff mov $0xffffffff,%eax
11feff: e9 5e ff ff ff jmp 11fe62 <nanosleep+0x5e>
*
* NOTE: This behavior is beyond the POSIX specification.
* FSU and GNU/Linux pthreads shares this behavior.
*/
if ( !_Timespec_Is_valid( rqtp ) )
rtems_set_errno_and_return_minus_one( EINVAL );
11ff04: e8 07 38 ff ff call 113710 <__errno>
11ff09: c7 00 16 00 00 00 movl $0x16,(%eax)
11ff0f: b8 ff ff ff ff mov $0xffffffff,%eax
11ff14: e9 49 ff ff ff jmp 11fe62 <nanosleep+0x5e>
001088a8 <newlib_create_hook>:
*/
bool newlib_create_hook(
rtems_tcb *current_task __attribute__((unused)),
rtems_tcb *creating_task
)
{
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 0c sub $0xc,%esp
struct _reent *ptr;
if (_Thread_libc_reent == 0)
1088b1: a1 24 7e 12 00 mov 0x127e24,%eax
1088b6: 85 c0 test %eax,%eax
1088b8: 0f 84 52 02 00 00 je 108b10 <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));
1088be: 83 ec 0c sub $0xc,%esp
1088c1: 68 24 04 00 00 push $0x424
1088c6: e8 bd 60 00 00 call 10e988 <_Workspace_Allocate>
1088cb: 89 c2 mov %eax,%edx
#endif
if (ptr) {
1088cd: 83 c4 10 add $0x10,%esp
1088d0: 85 c0 test %eax,%eax
1088d2: 0f 84 2c 02 00 00 je 108b04 <newlib_create_hook+0x25c>
_REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */
1088d8: c7 00 00 00 00 00 movl $0x0,(%eax)
1088de: 8d 98 ec 02 00 00 lea 0x2ec(%eax),%ebx
1088e4: 89 58 04 mov %ebx,0x4(%eax)
1088e7: 8d 80 54 03 00 00 lea 0x354(%eax),%eax
1088ed: 89 42 08 mov %eax,0x8(%edx)
1088f0: 8d 82 bc 03 00 00 lea 0x3bc(%edx),%eax
1088f6: 89 42 0c mov %eax,0xc(%edx)
1088f9: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx)
108900: 8d 72 14 lea 0x14(%edx),%esi
108903: 31 c0 xor %eax,%eax
108905: b9 19 00 00 00 mov $0x19,%ecx
10890a: 89 f7 mov %esi,%edi
10890c: f3 aa rep stos %al,%es:(%edi)
10890e: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx)
108915: c7 42 34 8a 10 12 00 movl $0x12108a,0x34(%edx)
10891c: c7 42 38 00 00 00 00 movl $0x0,0x38(%edx)
108923: c7 42 3c 00 00 00 00 movl $0x0,0x3c(%edx)
10892a: c7 42 40 00 00 00 00 movl $0x0,0x40(%edx)
108931: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx)
108938: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx)
10893f: c7 42 4c 00 00 00 00 movl $0x0,0x4c(%edx)
108946: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx)
10894d: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx)
108954: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx)
10895b: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx)
108962: c6 42 60 00 movb $0x0,0x60(%edx)
108966: 8d 72 7c lea 0x7c(%edx),%esi
108969: b1 24 mov $0x24,%cl
10896b: 89 f7 mov %esi,%edi
10896d: f3 aa rep stos %al,%es:(%edi)
10896f: c7 82 a0 00 00 00 00 movl $0x0,0xa0(%edx)
108976: 00 00 00
108979: c7 82 a4 00 00 00 01 movl $0x1,0xa4(%edx)
108980: 00 00 00
108983: c7 82 a8 00 00 00 00 movl $0x0,0xa8(%edx)
10898a: 00 00 00
10898d: 66 c7 82 ac 00 00 00 movw $0x330e,0xac(%edx)
108994: 0e 33
108996: 66 c7 82 ae 00 00 00 movw $0xabcd,0xae(%edx)
10899d: cd ab
10899f: 66 c7 82 b0 00 00 00 movw $0x1234,0xb0(%edx)
1089a6: 34 12
1089a8: 66 c7 82 b2 00 00 00 movw $0xe66d,0xb2(%edx)
1089af: 6d e6
1089b1: 66 c7 82 b4 00 00 00 movw $0xdeec,0xb4(%edx)
1089b8: ec de
1089ba: 66 c7 82 b6 00 00 00 movw $0x5,0xb6(%edx)
1089c1: 05 00
1089c3: 66 c7 82 b8 00 00 00 movw $0xb,0xb8(%edx)
1089ca: 0b 00
1089cc: c7 82 bc 00 00 00 00 movl $0x0,0xbc(%edx)
1089d3: 00 00 00
1089d6: c7 82 c0 00 00 00 00 movl $0x0,0xc0(%edx)
1089dd: 00 00 00
1089e0: c7 82 c4 00 00 00 00 movl $0x0,0xc4(%edx)
1089e7: 00 00 00
1089ea: c7 82 c8 00 00 00 00 movl $0x0,0xc8(%edx)
1089f1: 00 00 00
1089f4: c7 82 cc 00 00 00 00 movl $0x0,0xcc(%edx)
1089fb: 00 00 00
1089fe: c7 82 d0 00 00 00 00 movl $0x0,0xd0(%edx)
108a05: 00 00 00
108a08: c7 82 f8 00 00 00 00 movl $0x0,0xf8(%edx)
108a0f: 00 00 00
108a12: c7 82 fc 00 00 00 00 movl $0x0,0xfc(%edx)
108a19: 00 00 00
108a1c: c7 82 00 01 00 00 00 movl $0x0,0x100(%edx)
108a23: 00 00 00
108a26: c7 82 04 01 00 00 00 movl $0x0,0x104(%edx)
108a2d: 00 00 00
108a30: c7 82 08 01 00 00 00 movl $0x0,0x108(%edx)
108a37: 00 00 00
108a3a: c7 82 0c 01 00 00 00 movl $0x0,0x10c(%edx)
108a41: 00 00 00
108a44: c7 82 10 01 00 00 00 movl $0x0,0x110(%edx)
108a4b: 00 00 00
108a4e: c7 82 14 01 00 00 00 movl $0x0,0x114(%edx)
108a55: 00 00 00
108a58: c7 82 18 01 00 00 00 movl $0x0,0x118(%edx)
108a5f: 00 00 00
108a62: c7 82 1c 01 00 00 00 movl $0x0,0x11c(%edx)
108a69: 00 00 00
108a6c: c6 82 d4 00 00 00 00 movb $0x0,0xd4(%edx)
108a73: c6 82 dc 00 00 00 00 movb $0x0,0xdc(%edx)
108a7a: c7 82 f4 00 00 00 00 movl $0x0,0xf4(%edx)
108a81: 00 00 00
108a84: c7 82 48 01 00 00 00 movl $0x0,0x148(%edx)
108a8b: 00 00 00
108a8e: c7 82 4c 01 00 00 00 movl $0x0,0x14c(%edx)
108a95: 00 00 00
108a98: c7 82 50 01 00 00 00 movl $0x0,0x150(%edx)
108a9f: 00 00 00
108aa2: c7 82 54 01 00 00 00 movl $0x0,0x154(%edx)
108aa9: 00 00 00
108aac: c7 82 d4 02 00 00 00 movl $0x0,0x2d4(%edx)
108ab3: 00 00 00
108ab6: c7 82 d4 01 00 00 00 movl $0x0,0x1d4(%edx)
108abd: 00 00 00
108ac0: c7 82 dc 02 00 00 00 movl $0x0,0x2dc(%edx)
108ac7: 00 00 00
108aca: c7 82 e0 02 00 00 00 movl $0x0,0x2e0(%edx)
108ad1: 00 00 00
108ad4: c7 82 e4 02 00 00 00 movl $0x0,0x2e4(%edx)
108adb: 00 00 00
108ade: c7 82 e8 02 00 00 00 movl $0x0,0x2e8(%edx)
108ae5: 00 00 00
108ae8: 66 b9 38 01 mov $0x138,%cx
108aec: 89 df mov %ebx,%edi
108aee: f3 aa rep stos %al,%es:(%edi)
creating_task->libc_reent = ptr;
108af0: 8b 45 0c mov 0xc(%ebp),%eax
108af3: 89 90 e4 00 00 00 mov %edx,0xe4(%eax)
return TRUE;
108af9: b0 01 mov $0x1,%al
}
return FALSE;
}
108afb: 8d 65 f4 lea -0xc(%ebp),%esp
108afe: 5b pop %ebx
108aff: 5e pop %esi
108b00: 5f pop %edi
108b01: c9 leave
108b02: c3 ret
108b03: 90 nop
_REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */
creating_task->libc_reent = ptr;
return TRUE;
}
return FALSE;
108b04: 31 c0 xor %eax,%eax
}
108b06: 8d 65 f4 lea -0xc(%ebp),%esp
108b09: 5b pop %ebx
108b0a: 5e pop %esi
108b0b: 5f pop %edi
108b0c: c9 leave
108b0d: c3 ret
108b0e: 66 90 xchg %ax,%ax
{
struct _reent *ptr;
if (_Thread_libc_reent == 0)
{
_REENT = _global_impure_ptr;
108b10: a1 e0 1e 12 00 mov 0x121ee0,%eax
108b15: a3 a0 5a 12 00 mov %eax,0x125aa0
RTEMS_INLINE_ROUTINE void _Thread_Set_libc_reent (
struct _reent **libc_reent
)
{
_Thread_libc_reent = libc_reent;
108b1a: c7 05 24 7e 12 00 a0 movl $0x125aa0,0x127e24
108b21: 5a 12 00
108b24: e9 95 fd ff ff jmp 1088be <newlib_create_hook+0x16>
00108b2c <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
108b2c: 55 push %ebp
108b2d: 89 e5 mov %esp,%ebp
108b2f: 57 push %edi
108b30: 56 push %esi
108b31: 53 push %ebx
108b32: 83 ec 0c sub $0xc,%esp
108b35: 8b 7d 08 mov 0x8(%ebp),%edi
108b38: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
108b3b: 39 df cmp %ebx,%edi
108b3d: 74 55 je 108b94 <newlib_delete_hook+0x68>
ptr = _REENT;
} else {
ptr = deleted_task->libc_reent;
108b3f: 8b b3 e4 00 00 00 mov 0xe4(%ebx),%esi
}
if (ptr && ptr != _global_impure_ptr) {
108b45: 85 f6 test %esi,%esi
108b47: 74 21 je 108b6a <newlib_delete_hook+0x3e><== NEVER TAKEN
108b49: 3b 35 e0 1e 12 00 cmp 0x121ee0,%esi
108b4f: 74 19 je 108b6a <newlib_delete_hook+0x3e>
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
108b51: 83 ec 08 sub $0x8,%esp
108b54: 68 4c 88 10 00 push $0x10884c
108b59: 56 push %esi
108b5a: e8 f9 ae 00 00 call 113a58 <_fwalk>
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
108b5f: 89 34 24 mov %esi,(%esp)
108b62: e8 3d 5e 00 00 call 10e9a4 <_Workspace_Free>
108b67: 83 c4 10 add $0x10,%esp
#endif
}
deleted_task->libc_reent = NULL;
108b6a: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
108b71: 00 00 00
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
108b74: 39 df cmp %ebx,%edi
108b76: 74 08 je 108b80 <newlib_delete_hook+0x54>
_REENT = 0;
}
}
108b78: 8d 65 f4 lea -0xc(%ebp),%esp
108b7b: 5b pop %ebx
108b7c: 5e pop %esi
108b7d: 5f pop %edi
108b7e: c9 leave
108b7f: c3 ret
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
_REENT = 0;
108b80: c7 05 a0 5a 12 00 00 movl $0x0,0x125aa0
108b87: 00 00 00
}
}
108b8a: 8d 65 f4 lea -0xc(%ebp),%esp
108b8d: 5b pop %ebx
108b8e: 5e pop %esi
108b8f: 5f pop %edi
108b90: c9 leave
108b91: c3 ret
108b92: 66 90 xchg %ax,%ax
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ptr = _REENT;
108b94: 8b 35 a0 5a 12 00 mov 0x125aa0,%esi
108b9a: eb a9 jmp 108b45 <newlib_delete_hook+0x19>
0010884c <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
10884c: 55 push %ebp
10884d: 89 e5 mov %esp,%ebp
10884f: 53 push %ebx
108850: 83 ec 10 sub $0x10,%esp
108853: 8b 5d 08 mov 0x8(%ebp),%ebx
switch ( fileno(fp) ) {
108856: 53 push %ebx
108857: e8 e8 ad 00 00 call 113644 <fileno>
10885c: 83 c4 10 add $0x10,%esp
10885f: 83 f8 02 cmp $0x2,%eax
108862: 76 14 jbe 108878 <newlib_free_buffers+0x2c><== ALWAYS TAKEN
fp->_flags &= ~__SMBF;
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
108864: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108867: 53 push %ebx <== NOT EXECUTED
108868: e8 5b ab 00 00 call 1133c8 <fclose> <== NOT EXECUTED
10886d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
return 0;
}
108870: 31 c0 xor %eax,%eax
108872: 8b 5d fc mov -0x4(%ebp),%ebx
108875: c9 leave
108876: c3 ret
108877: 90 nop
{
switch ( fileno(fp) ) {
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
108878: f6 43 0c 80 testb $0x80,0xc(%ebx)
10887c: 74 f2 je 108870 <newlib_free_buffers+0x24><== ALWAYS TAKEN
free( fp->_bf._base );
10887e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108881: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
108884: e8 2b f8 ff ff call 1080b4 <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
108889: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx) <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
10888f: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED
108895: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED
10889c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
break;
default:
fclose(fp);
}
return 0;
}
10889f: 31 c0 xor %eax,%eax <== NOT EXECUTED
1088a1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
1088a4: c9 leave <== NOT EXECUTED
1088a5: c3 ret <== NOT EXECUTED
00107cd4 <null_initialize>:
rtems_device_driver null_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *pargp __attribute__((unused))
)
{
107cd4: 55 push %ebp
107cd5: 89 e5 mov %esp,%ebp
107cd7: 53 push %ebx
107cd8: 83 ec 04 sub $0x4,%esp
107cdb: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_device_driver status;
if ( !initialized ) {
107cde: 80 3d 20 59 12 00 00 cmpb $0x0,0x125920
107ce5: 74 09 je 107cf0 <null_initialize+0x1c>
NULL_major = major;
}
return RTEMS_SUCCESSFUL;
}
107ce7: 31 c0 xor %eax,%eax
107ce9: 8b 5d fc mov -0x4(%ebp),%ebx
107cec: c9 leave
107ced: c3 ret
107cee: 66 90 xchg %ax,%ax
)
{
rtems_device_driver status;
if ( !initialized ) {
initialized = 1;
107cf0: c6 05 20 59 12 00 01 movb $0x1,0x125920
status = rtems_io_register_name(
107cf7: 50 push %eax
107cf8: 6a 00 push $0x0
107cfa: 53 push %ebx
107cfb: 68 9a d9 11 00 push $0x11d99a
107d00: e8 7b 01 00 00 call 107e80 <rtems_io_register_name>
"/dev/null",
major,
(rtems_device_minor_number) 0
);
if (status != RTEMS_SUCCESSFUL)
107d05: 83 c4 10 add $0x10,%esp
107d08: 85 c0 test %eax,%eax
107d0a: 75 0d jne 107d19 <null_initialize+0x45>
rtems_fatal_error_occurred(status);
NULL_major = major;
107d0c: 89 1d 60 5c 12 00 mov %ebx,0x125c60
}
return RTEMS_SUCCESSFUL;
}
107d12: 31 c0 xor %eax,%eax
107d14: 8b 5d fc mov -0x4(%ebp),%ebx
107d17: c9 leave
107d18: c3 ret
major,
(rtems_device_minor_number) 0
);
if (status != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred(status);
107d19: 83 ec 0c sub $0xc,%esp
107d1c: 50 push %eax
107d1d: e8 ae 41 00 00 call 10bed0 <rtems_fatal_error_occurred>
00108bfc <open>:
int open(
const char *pathname,
int flags,
...
)
{
108bfc: 55 push %ebp
108bfd: 89 e5 mov %esp,%ebp
108bff: 57 push %edi
108c00: 56 push %esi
108c01: 53 push %ebx
108c02: 83 ec 4c sub $0x4c,%esp
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
108c05: 8b 45 0c mov 0xc(%ebp),%eax
108c08: 40 inc %eax
if ( ( status & _FREAD ) == _FREAD )
108c09: 89 c3 mov %eax,%ebx
108c0b: 83 e3 01 and $0x1,%ebx
eval_flags |= RTEMS_LIBIO_PERMS_READ;
108c0e: f7 db neg %ebx
108c10: 83 e3 04 and $0x4,%ebx
if ( ( status & _FWRITE ) == _FWRITE )
108c13: a8 02 test $0x2,%al
108c15: 74 03 je 108c1a <open+0x1e>
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
108c17: 83 cb 02 or $0x2,%ebx
va_start(ap, flags);
mode = va_arg( ap, int );
108c1a: 8b 45 10 mov 0x10(%ebp),%eax
108c1d: 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();
108c20: e8 e3 71 00 00 call 10fe08 <rtems_libio_allocate>
108c25: 89 c2 mov %eax,%edx
if ( iop == 0 ) {
108c27: 85 c0 test %eax,%eax
108c29: 0f 84 c5 00 00 00 je 108cf4 <open+0xf8>
}
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
108c2f: 31 f6 xor %esi,%esi
108c31: b9 ff ff ff ff mov $0xffffffff,%ecx
108c36: 8b 7d 08 mov 0x8(%ebp),%edi
108c39: 89 f0 mov %esi,%eax
108c3b: f2 ae repnz scas %es:(%edi),%al
108c3d: f7 d1 not %ecx
108c3f: 49 dec %ecx
108c40: 83 ec 0c sub $0xc,%esp
108c43: 6a 01 push $0x1
108c45: 8d 45 d4 lea -0x2c(%ebp),%eax
108c48: 89 45 b4 mov %eax,-0x4c(%ebp)
108c4b: 50 push %eax
108c4c: 53 push %ebx
108c4d: 51 push %ecx
108c4e: ff 75 08 pushl 0x8(%ebp)
108c51: 89 55 c0 mov %edx,-0x40(%ebp)
108c54: e8 6f f3 ff ff call 107fc8 <rtems_filesystem_evaluate_path>
108c59: 89 c3 mov %eax,%ebx
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
108c5b: 83 c4 20 add $0x20,%esp
108c5e: 83 f8 ff cmp $0xffffffff,%eax
108c61: 8b 55 c0 mov -0x40(%ebp),%edx
108c64: 0f 84 de 00 00 00 je 108d48 <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)) {
108c6a: 8b 45 0c mov 0xc(%ebp),%eax
108c6d: 25 00 0a 00 00 and $0xa00,%eax
108c72: 3d 00 0a 00 00 cmp $0xa00,%eax
108c77: 0f 84 8b 00 00 00 je 108d08 <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 );
108c7d: 8b 5a 14 mov 0x14(%edx),%ebx
108c80: 83 ec 0c sub $0xc,%esp
108c83: ff 75 0c pushl 0xc(%ebp)
108c86: 89 55 c0 mov %edx,-0x40(%ebp)
108c89: e8 fe 70 00 00 call 10fd8c <rtems_libio_fcntl_flags>
108c8e: 09 d8 or %ebx,%eax
108c90: 8b 55 c0 mov -0x40(%ebp),%edx
108c93: 89 42 14 mov %eax,0x14(%edx)
iop->pathinfo = loc;
108c96: 8d 7a 18 lea 0x18(%edx),%edi
108c99: b9 05 00 00 00 mov $0x5,%ecx
108c9e: 8b 75 b4 mov -0x4c(%ebp),%esi
108ca1: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
108ca3: 8b 42 20 mov 0x20(%edx),%eax
108ca6: ff 75 c4 pushl -0x3c(%ebp)
108ca9: ff 75 0c pushl 0xc(%ebp)
108cac: ff 75 08 pushl 0x8(%ebp)
108caf: 52 push %edx
108cb0: ff 10 call *(%eax)
if ( rc ) {
108cb2: 83 c4 20 add $0x20,%esp
108cb5: 85 c0 test %eax,%eax
108cb7: 8b 55 c0 mov -0x40(%ebp),%edx
108cba: 75 78 jne 108d34 <open+0x138>
}
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
108cbc: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
108cc3: 0f 85 9f 00 00 00 jne 108d68 <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;
108cc9: 2b 15 20 7c 12 00 sub 0x127c20,%edx
108ccf: c1 fa 03 sar $0x3,%edx
108cd2: 8d 04 d2 lea (%edx,%edx,8),%eax
108cd5: 8d 04 c2 lea (%edx,%eax,8),%eax
108cd8: 8d 04 c2 lea (%edx,%eax,8),%eax
108cdb: 8d 04 c2 lea (%edx,%eax,8),%eax
108cde: 89 c1 mov %eax,%ecx
108ce0: c1 e1 0f shl $0xf,%ecx
108ce3: 01 c8 add %ecx,%eax
108ce5: 8d 04 c2 lea (%edx,%eax,8),%eax
108ce8: f7 d8 neg %eax
}
108cea: 8d 65 f4 lea -0xc(%ebp),%esp
108ced: 5b pop %ebx
108cee: 5e pop %esi
108cef: 5f pop %edi
108cf0: c9 leave
108cf1: c3 ret
108cf2: 66 90 xchg %ax,%ax
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
if ( iop == 0 ) {
rc = ENFILE;
108cf4: 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 );
108cf9: e8 72 a5 00 00 call 113270 <__errno>
108cfe: 89 18 mov %ebx,(%eax)
108d00: b8 ff ff ff ff mov $0xffffffff,%eax
108d05: eb e3 jmp 108cea <open+0xee>
108d07: 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;
108d08: 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;
108d0b: bb 11 00 00 00 mov $0x11,%ebx
*/
done:
va_end(ap);
if ( rc ) {
if ( iop )
108d10: 85 d2 test %edx,%edx
108d12: 74 0c je 108d20 <open+0x124>
rtems_libio_free( iop );
108d14: 83 ec 0c sub $0xc,%esp
108d17: 52 push %edx
108d18: e8 8f 71 00 00 call 10feac <rtems_libio_free>
108d1d: 83 c4 10 add $0x10,%esp
if ( loc_to_free )
108d20: 85 f6 test %esi,%esi
108d22: 74 d5 je 108cf9 <open+0xfd>
rtems_filesystem_freenode( loc_to_free );
108d24: 83 ec 0c sub $0xc,%esp
108d27: 56 push %esi
108d28: e8 73 f3 ff ff call 1080a0 <rtems_filesystem_freenode>
108d2d: 83 c4 10 add $0x10,%esp
108d30: eb c7 jmp 108cf9 <open+0xfd>
108d32: 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;
108d34: e8 37 a5 00 00 call 113270 <__errno>
108d39: 8b 18 mov (%eax),%ebx
rc = EEXIST;
loc_to_free = &loc;
goto done;
}
loc_to_free = &loc;
108d3b: 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;
108d3e: 8b 55 c0 mov -0x40(%ebp),%edx
* Single exit and clean up path.
*/
done:
va_end(ap);
if ( rc ) {
108d41: 85 db test %ebx,%ebx
108d43: 74 84 je 108cc9 <open+0xcd> <== NEVER TAKEN
108d45: eb c9 jmp 108d10 <open+0x114>
108d47: 90 nop
*/
status = rtems_filesystem_evaluate_path(
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
if ( errno != ENOENT ) {
108d48: e8 23 a5 00 00 call 113270 <__errno>
108d4d: 83 38 02 cmpl $0x2,(%eax)
108d50: 8b 55 c0 mov -0x40(%ebp),%edx
108d53: 0f 84 9b 00 00 00 je 108df4 <open+0x1f8>
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
if ( rc ) {
rc = errno;
108d59: e8 12 a5 00 00 call 113270 <__errno>
108d5e: 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;
108d60: 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;
108d62: 8b 55 c0 mov -0x40(%ebp),%edx
108d65: eb da jmp 108d41 <open+0x145>
108d67: 90 nop
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
108d68: 51 push %ecx
108d69: 6a 00 push $0x0
108d6b: 6a 00 push $0x0
108d6d: 89 d0 mov %edx,%eax
108d6f: 2b 05 20 7c 12 00 sub 0x127c20,%eax
108d75: c1 f8 03 sar $0x3,%eax
108d78: 8d 0c c0 lea (%eax,%eax,8),%ecx
108d7b: 8d 0c c8 lea (%eax,%ecx,8),%ecx
108d7e: 8d 0c c8 lea (%eax,%ecx,8),%ecx
108d81: 8d 0c c8 lea (%eax,%ecx,8),%ecx
108d84: 89 cb mov %ecx,%ebx
108d86: c1 e3 0f shl $0xf,%ebx
108d89: 01 d9 add %ebx,%ecx
108d8b: 8d 04 c8 lea (%eax,%ecx,8),%eax
108d8e: f7 d8 neg %eax
108d90: 50 push %eax
108d91: 89 55 c0 mov %edx,-0x40(%ebp)
108d94: e8 23 6f 00 00 call 10fcbc <ftruncate>
108d99: 89 c3 mov %eax,%ebx
if ( rc ) {
108d9b: 83 c4 10 add $0x10,%esp
108d9e: 85 c0 test %eax,%eax
108da0: 8b 55 c0 mov -0x40(%ebp),%edx
108da3: 0f 84 20 ff ff ff je 108cc9 <open+0xcd>
if(errno) rc = errno;
108da9: e8 c2 a4 00 00 call 113270 <__errno>
108dae: 8b 00 mov (%eax),%eax
108db0: 85 c0 test %eax,%eax
108db2: 8b 55 c0 mov -0x40(%ebp),%edx
108db5: 0f 85 b2 00 00 00 jne 108e6d <open+0x271> <== ALWAYS TAKEN
close( iop - rtems_libio_iops );
108dbb: 83 ec 0c sub $0xc,%esp
108dbe: 2b 15 20 7c 12 00 sub 0x127c20,%edx
108dc4: c1 fa 03 sar $0x3,%edx
108dc7: 8d 04 d2 lea (%edx,%edx,8),%eax
108dca: 8d 04 c2 lea (%edx,%eax,8),%eax
108dcd: 8d 04 c2 lea (%edx,%eax,8),%eax
108dd0: 8d 04 c2 lea (%edx,%eax,8),%eax
108dd3: 89 c1 mov %eax,%ecx
108dd5: c1 e1 0f shl $0xf,%ecx
108dd8: 01 c8 add %ecx,%eax
108dda: 8d 04 c2 lea (%edx,%eax,8),%eax
108ddd: f7 d8 neg %eax
108ddf: 50 push %eax
108de0: e8 57 6e 00 00 call 10fc3c <close>
108de5: 83 c4 10 add $0x10,%esp
/* those are released by close(): */
iop = 0;
loc_to_free = NULL;
108de8: 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;
108dea: 31 d2 xor %edx,%edx
108dec: e9 50 ff ff ff jmp 108d41 <open+0x145>
108df1: 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) ) {
108df4: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
108dfb: 75 0f jne 108e0c <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;
108dfd: 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;
108dff: bb 02 00 00 00 mov $0x2,%ebx
108e04: e9 07 ff ff ff jmp 108d10 <open+0x114>
108e09: 8d 76 00 lea 0x0(%esi),%esi
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
108e0c: 6a 00 push $0x0
108e0e: 6a 00 push $0x0
108e10: 8b 45 c4 mov -0x3c(%ebp),%eax
108e13: 80 cc 80 or $0x80,%ah
108e16: 50 push %eax
108e17: ff 75 08 pushl 0x8(%ebp)
108e1a: 89 55 c0 mov %edx,-0x40(%ebp)
108e1d: e8 2a f6 ff ff call 10844c <mknod>
if ( rc ) {
108e22: 83 c4 10 add $0x10,%esp
108e25: 85 c0 test %eax,%eax
108e27: 8b 55 c0 mov -0x40(%ebp),%edx
108e2a: 0f 85 29 ff ff ff jne 108d59 <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(
108e30: 89 d9 mov %ebx,%ecx
108e32: 8b 7d 08 mov 0x8(%ebp),%edi
108e35: 89 f0 mov %esi,%eax
108e37: f2 ae repnz scas %es:(%edi),%al
108e39: f7 d1 not %ecx
108e3b: 49 dec %ecx
108e3c: 83 ec 0c sub $0xc,%esp
108e3f: 6a 01 push $0x1
108e41: 8d 45 d4 lea -0x2c(%ebp),%eax
108e44: 50 push %eax
108e45: 6a 00 push $0x0
108e47: 51 push %ecx
108e48: ff 75 08 pushl 0x8(%ebp)
108e4b: 89 55 c0 mov %edx,-0x40(%ebp)
108e4e: e8 75 f1 ff ff call 107fc8 <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
108e53: 83 c4 20 add $0x20,%esp
108e56: 85 c0 test %eax,%eax
108e58: 8b 55 c0 mov -0x40(%ebp),%edx
108e5b: 0f 84 1c fe ff ff je 108c7d <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;
108e61: 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;
108e63: bb 0d 00 00 00 mov $0xd,%ebx <== NOT EXECUTED
108e68: e9 a3 fe ff ff jmp 108d10 <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;
108e6d: e8 fe a3 00 00 call 113270 <__errno>
108e72: 8b 18 mov (%eax),%ebx
108e74: 8b 55 c0 mov -0x40(%ebp),%edx
108e77: e9 3f ff ff ff jmp 108dbb <open+0x1bf>
00109c00 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
109c00: 55 push %ebp
109c01: 89 e5 mov %esp,%ebp
109c03: 56 push %esi
109c04: 53 push %ebx
109c05: 83 ec 10 sub $0x10,%esp
109c08: 88 45 f4 mov %al,-0xc(%ebp)
int i;
if (tty->termios.c_oflag & OPOST) {
109c0b: 8b 4a 34 mov 0x34(%edx),%ecx
109c0e: f6 c1 01 test $0x1,%cl
109c11: 74 31 je 109c44 <oproc+0x44> <== NEVER TAKEN
switch (c) {
109c13: 3c 09 cmp $0x9,%al
109c15: 0f 84 b1 00 00 00 je 109ccc <oproc+0xcc>
109c1b: 76 3f jbe 109c5c <oproc+0x5c> <== NEVER TAKEN
109c1d: 3c 0a cmp $0xa,%al
109c1f: 74 4f je 109c70 <oproc+0x70>
109c21: 3c 0d cmp $0xd,%al
109c23: 74 7f je 109ca4 <oproc+0xa4> <== NEVER TAKEN
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
109c25: 83 e1 02 and $0x2,%ecx
109c28: 0f 85 c6 00 00 00 jne 109cf4 <oproc+0xf4> <== NEVER TAKEN
109c2e: 8b 0d 94 5a 12 00 mov 0x125a94,%ecx
c = toupper(c);
if (!iscntrl(c))
109c34: 0f b6 c0 movzbl %al,%eax
109c37: f6 44 01 01 20 testb $0x20,0x1(%ecx,%eax,1)
109c3c: 75 06 jne 109c44 <oproc+0x44> <== NEVER TAKEN
tty->column++;
109c3e: ff 42 28 incl 0x28(%edx)
109c41: 8d 76 00 lea 0x0(%esi),%esi
break;
}
}
rtems_termios_puts (&c, 1, tty);
109c44: 53 push %ebx
109c45: 52 push %edx
109c46: 6a 01 push $0x1
109c48: 8d 45 f4 lea -0xc(%ebp),%eax
109c4b: 50 push %eax
109c4c: e8 7b fe ff ff call 109acc <rtems_termios_puts>
109c51: 83 c4 10 add $0x10,%esp
}
109c54: 8d 65 f8 lea -0x8(%ebp),%esp
109c57: 5b pop %ebx
109c58: 5e pop %esi
109c59: c9 leave
109c5a: c3 ret
109c5b: 90 nop
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
109c5c: 3c 08 cmp $0x8,%al <== NOT EXECUTED
109c5e: 75 c5 jne 109c25 <oproc+0x25> <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
109c60: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED
109c63: 85 c0 test %eax,%eax <== NOT EXECUTED
109c65: 7e dd jle 109c44 <oproc+0x44> <== NOT EXECUTED
tty->column--;
109c67: 48 dec %eax <== NOT EXECUTED
109c68: 89 42 28 mov %eax,0x28(%edx) <== NOT EXECUTED
109c6b: eb d7 jmp 109c44 <oproc+0x44> <== NOT EXECUTED
109c6d: 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)
109c70: f6 c1 20 test $0x20,%cl
109c73: 74 07 je 109c7c <oproc+0x7c> <== ALWAYS TAKEN
tty->column = 0;
109c75: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLCR) {
109c7c: 83 e1 04 and $0x4,%ecx
109c7f: 74 c3 je 109c44 <oproc+0x44> <== NEVER TAKEN
rtems_termios_puts ("\r", 1, tty);
109c81: 51 push %ecx
109c82: 52 push %edx
109c83: 6a 01 push $0x1
109c85: 68 04 14 12 00 push $0x121404
109c8a: 89 55 f0 mov %edx,-0x10(%ebp)
109c8d: e8 3a fe ff ff call 109acc <rtems_termios_puts>
tty->column = 0;
109c92: 8b 55 f0 mov -0x10(%ebp),%edx
109c95: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx)
109c9c: 83 c4 10 add $0x10,%esp
109c9f: eb a3 jmp 109c44 <oproc+0x44>
109ca1: 8d 76 00 lea 0x0(%esi),%esi
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
109ca4: f6 c1 10 test $0x10,%cl <== NOT EXECUTED
109ca7: 74 07 je 109cb0 <oproc+0xb0> <== NOT EXECUTED
109ca9: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED
109cac: 85 c0 test %eax,%eax <== NOT EXECUTED
109cae: 74 a4 je 109c54 <oproc+0x54> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
109cb0: f6 c1 08 test $0x8,%cl <== NOT EXECUTED
109cb3: 74 09 je 109cbe <oproc+0xbe> <== NOT EXECUTED
c = '\n';
109cb5: c6 45 f4 0a movb $0xa,-0xc(%ebp) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
109cb9: 83 e1 20 and $0x20,%ecx <== NOT EXECUTED
109cbc: 74 86 je 109c44 <oproc+0x44> <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
109cbe: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx) <== NOT EXECUTED
break;
109cc5: e9 7a ff ff ff jmp 109c44 <oproc+0x44> <== NOT EXECUTED
109cca: 66 90 xchg %ax,%ax <== NOT EXECUTED
case '\t':
i = 8 - (tty->column & 7);
109ccc: 8b 5a 28 mov 0x28(%edx),%ebx
109ccf: 89 de mov %ebx,%esi
109cd1: 83 e6 07 and $0x7,%esi
109cd4: b8 08 00 00 00 mov $0x8,%eax
109cd9: 29 f0 sub %esi,%eax
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
109cdb: 81 e1 00 18 00 00 and $0x1800,%ecx
109ce1: 81 f9 00 18 00 00 cmp $0x1800,%ecx
109ce7: 74 37 je 109d20 <oproc+0x120> <== ALWAYS TAKEN
tty->column += i;
rtems_termios_puts ( " ", i, tty);
return;
}
tty->column += i;
109ce9: 01 d8 add %ebx,%eax <== NOT EXECUTED
109ceb: 89 42 28 mov %eax,0x28(%edx) <== NOT EXECUTED
break;
109cee: e9 51 ff ff ff jmp 109c44 <oproc+0x44> <== NOT EXECUTED
109cf3: 90 nop <== NOT EXECUTED
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
c = toupper(c);
109cf4: 8b 0d 94 5a 12 00 mov 0x125a94,%ecx <== NOT EXECUTED
109cfa: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
109cfd: 0f be 5c 01 01 movsbl 0x1(%ecx,%eax,1),%ebx <== NOT EXECUTED
109d02: 83 e3 03 and $0x3,%ebx <== NOT EXECUTED
109d05: 83 fb 02 cmp $0x2,%ebx <== NOT EXECUTED
109d08: 74 0e je 109d18 <oproc+0x118> <== NOT EXECUTED
109d0a: 89 c3 mov %eax,%ebx <== NOT EXECUTED
109d0c: 88 d8 mov %bl,%al <== NOT EXECUTED
109d0e: 88 5d f4 mov %bl,-0xc(%ebp) <== NOT EXECUTED
109d11: e9 1e ff ff ff jmp 109c34 <oproc+0x34> <== NOT EXECUTED
109d16: 66 90 xchg %ax,%ax <== NOT EXECUTED
109d18: 8d 58 e0 lea -0x20(%eax),%ebx <== NOT EXECUTED
109d1b: eb ef jmp 109d0c <oproc+0x10c> <== NOT EXECUTED
109d1d: 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;
109d20: 8d 1c 18 lea (%eax,%ebx,1),%ebx
109d23: 89 5a 28 mov %ebx,0x28(%edx)
rtems_termios_puts ( " ", i, tty);
109d26: 56 push %esi
109d27: 52 push %edx
109d28: 50 push %eax
109d29: 68 9c 0f 12 00 push $0x120f9c
109d2e: e8 99 fd ff ff call 109acc <rtems_termios_puts>
return;
109d33: 83 c4 10 add $0x10,%esp
109d36: e9 19 ff ff ff jmp 109c54 <oproc+0x54>
0010a038 <pathconf>:
long pathconf(
const char *path,
int name
)
{
10a038: 55 push %ebp
10a039: 89 e5 mov %esp,%ebp
10a03b: 56 push %esi
10a03c: 53 push %ebx
int status;
int fd;
fd = open( path, O_RDONLY );
10a03d: 83 ec 08 sub $0x8,%esp
10a040: 6a 00 push $0x0
10a042: ff 75 08 pushl 0x8(%ebp)
10a045: e8 4e fd ff ff call 109d98 <open>
10a04a: 89 c3 mov %eax,%ebx
if ( fd == -1 )
10a04c: 83 c4 10 add $0x10,%esp
10a04f: 83 f8 ff cmp $0xffffffff,%eax
10a052: 74 24 je 10a078 <pathconf+0x40>
return -1;
status = fpathconf( fd, name );
10a054: 83 ec 08 sub $0x8,%esp
10a057: ff 75 0c pushl 0xc(%ebp)
10a05a: 50 push %eax
10a05b: e8 c0 ec ff ff call 108d20 <fpathconf>
10a060: 89 c6 mov %eax,%esi
(void) close( fd );
10a062: 89 1c 24 mov %ebx,(%esp)
10a065: e8 56 e8 ff ff call 1088c0 <close>
return status;
10a06a: 83 c4 10 add $0x10,%esp
10a06d: 89 f0 mov %esi,%eax
}
10a06f: 8d 65 f8 lea -0x8(%ebp),%esp
10a072: 5b pop %ebx
10a073: 5e pop %esi
10a074: c9 leave
10a075: c3 ret
10a076: 66 90 xchg %ax,%ax
int status;
int fd;
fd = open( path, O_RDONLY );
if ( fd == -1 )
return -1;
10a078: b8 ff ff ff ff mov $0xffffffff,%eax
status = fpathconf( fd, name );
(void) close( fd );
return status;
}
10a07d: 8d 65 f8 lea -0x8(%ebp),%esp
10a080: 5b pop %ebx
10a081: 5e pop %esi
10a082: c9 leave
10a083: c3 ret
00110d7c <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
110d7c: 55 push %ebp
110d7d: 89 e5 mov %esp,%ebp
110d7f: 57 push %edi
110d80: 56 push %esi
110d81: 53 push %ebx
110d82: 83 ec 24 sub $0x24,%esp
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
110d85: 68 ff 01 00 00 push $0x1ff
110d8a: 68 6c 35 12 00 push $0x12356c
110d8f: e8 38 17 00 00 call 1124cc <rtems_mkdir>
110d94: 83 c4 10 add $0x10,%esp
110d97: 85 c0 test %eax,%eax
110d99: 74 0d je 110da8 <pipe_create+0x2c> <== ALWAYS TAKEN
return -1;
110d9b: 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;
}
110da0: 8d 65 f4 lea -0xc(%ebp),%esp
110da3: 5b pop %ebx
110da4: 5e pop %esi
110da5: 5f pop %edi
110da6: c9 leave
110da7: 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);
110da8: 8d 5d d9 lea -0x27(%ebp),%ebx
110dab: be 71 35 12 00 mov $0x123571,%esi
110db0: b9 0a 00 00 00 mov $0xa,%ecx
110db5: 89 df mov %ebx,%edi
110db7: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
110db9: 0f b7 05 6c 96 12 00 movzwl 0x12966c,%eax
110dc0: 8d 50 01 lea 0x1(%eax),%edx
110dc3: 66 89 15 6c 96 12 00 mov %dx,0x12966c
110dca: 51 push %ecx
110dcb: 50 push %eax
110dcc: 68 7c 35 12 00 push $0x12357c
110dd1: 8d 45 e3 lea -0x1d(%ebp),%eax
110dd4: 50 push %eax
110dd5: e8 d6 49 00 00 call 1157b0 <sprintf>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
110dda: 58 pop %eax
110ddb: 5a pop %edx
110ddc: 68 80 01 00 00 push $0x180
110de1: 53 push %ebx
110de2: e8 2d 14 00 00 call 112214 <mkfifo>
110de7: 83 c4 10 add $0x10,%esp
110dea: 85 c0 test %eax,%eax
110dec: 0f 85 a6 00 00 00 jne 110e98 <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);
110df2: 83 ec 08 sub $0x8,%esp
110df5: 68 00 40 00 00 push $0x4000
110dfa: 53 push %ebx
110dfb: e8 d0 90 ff ff call 109ed0 <open>
110e00: 8b 55 08 mov 0x8(%ebp),%edx
110e03: 89 02 mov %eax,(%edx)
if (filsdes[0] < 0) {
110e05: 83 c4 10 add $0x10,%esp
110e08: 85 c0 test %eax,%eax
110e0a: 78 58 js 110e64 <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]);
110e0c: 3b 05 ac 55 12 00 cmp 0x1255ac,%eax
110e12: 72 3c jb 110e50 <pipe_create+0xd4> <== ALWAYS TAKEN
110e14: 31 d2 xor %edx,%edx
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
110e16: 83 62 14 fe andl $0xfffffffe,0x14(%edx)
filsdes[1] = open(fifopath, O_WRONLY);
110e1a: 83 ec 08 sub $0x8,%esp
110e1d: 6a 01 push $0x1
110e1f: 53 push %ebx
110e20: e8 ab 90 ff ff call 109ed0 <open>
110e25: 8b 55 08 mov 0x8(%ebp),%edx
110e28: 89 42 04 mov %eax,0x4(%edx)
if (filsdes[1] < 0) {
110e2b: 83 c4 10 add $0x10,%esp
110e2e: 85 c0 test %eax,%eax
110e30: 78 4a js 110e7c <pipe_create+0x100>
int pipe_create(
int filsdes[2]
)
{
rtems_libio_t *iop;
int err = 0;
110e32: 31 f6 xor %esi,%esi
if (filsdes[1] < 0) {
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
110e34: 83 ec 0c sub $0xc,%esp
110e37: 53 push %ebx
110e38: e8 df b0 ff ff call 10bf1c <unlink>
110e3d: 83 c4 10 add $0x10,%esp
}
if(err != 0)
110e40: 85 f6 test %esi,%esi
110e42: 75 63 jne 110ea7 <pipe_create+0x12b>
rtems_set_errno_and_return_minus_one(err);
return 0;
110e44: 31 c0 xor %eax,%eax
}
110e46: 8d 65 f4 lea -0xc(%ebp),%esp
110e49: 5b pop %ebx
110e4a: 5e pop %esi
110e4b: 5f pop %edi
110e4c: c9 leave
110e4d: c3 ret
110e4e: 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]);
110e50: c1 e0 03 shl $0x3,%eax
110e53: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
110e5a: 29 c2 sub %eax,%edx
110e5c: 03 15 a0 98 12 00 add 0x1298a0,%edx
110e62: eb b2 jmp 110e16 <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;
110e64: e8 af 3f 00 00 call 114e18 <__errno>
110e69: 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);
110e6b: 83 ec 0c sub $0xc,%esp
110e6e: 53 push %ebx
110e6f: e8 a8 b0 ff ff call 10bf1c <unlink>
110e74: 83 c4 10 add $0x10,%esp
110e77: eb c7 jmp 110e40 <pipe_create+0xc4>
110e79: 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;
110e7c: e8 97 3f 00 00 call 114e18 <__errno>
110e81: 8b 30 mov (%eax),%esi
close(filsdes[0]);
110e83: 83 ec 0c sub $0xc,%esp
110e86: 8b 45 08 mov 0x8(%ebp),%eax
110e89: ff 30 pushl (%eax)
110e8b: e8 a8 80 ff ff call 108f38 <close>
110e90: 83 c4 10 add $0x10,%esp
110e93: eb 9f jmp 110e34 <pipe_create+0xb8>
110e95: 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){
110e98: e8 7b 3f 00 00 call 114e18 <__errno>
return -1;
110e9d: b8 ff ff ff ff mov $0xffffffff,%eax
110ea2: e9 f9 fe ff ff jmp 110da0 <pipe_create+0x24>
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
110ea7: e8 6c 3f 00 00 call 114e18 <__errno>
110eac: 89 30 mov %esi,(%eax)
110eae: b8 ff ff ff ff mov $0xffffffff,%eax
110eb3: e9 e8 fe ff ff jmp 110da0 <pipe_create+0x24>
001122d0 <pipe_ioctl>:
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
1122d0: 55 push %ebp
1122d1: 89 e5 mov %esp,%ebp
1122d3: 56 push %esi
1122d4: 53 push %ebx
1122d5: 8b 75 08 mov 0x8(%ebp),%esi
1122d8: 8b 5d 10 mov 0x10(%ebp),%ebx
if (cmd == FIONREAD) {
1122db: 81 7d 0c 7f 66 04 40 cmpl $0x4004667f,0xc(%ebp)
1122e2: 74 0c je 1122f0 <pipe_ioctl+0x20>
*(unsigned int *)buffer = pipe->Length;
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
1122e4: b8 ea ff ff ff mov $0xffffffea,%eax
}
1122e9: 8d 65 f8 lea -0x8(%ebp),%esp
1122ec: 5b pop %ebx
1122ed: 5e pop %esi
1122ee: c9 leave
1122ef: c3 ret
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
1122f0: 85 db test %ebx,%ebx
1122f2: 75 07 jne 1122fb <pipe_ioctl+0x2b>
return -EFAULT;
1122f4: b8 f2 ff ff ff mov $0xfffffff2,%eax
1122f9: eb ee jmp 1122e9 <pipe_ioctl+0x19>
if (! PIPE_LOCK(pipe))
1122fb: 50 push %eax
1122fc: 6a 00 push $0x0
1122fe: 6a 00 push $0x0
112300: ff 76 28 pushl 0x28(%esi)
112303: e8 cc b1 ff ff call 10d4d4 <rtems_semaphore_obtain>
112308: 83 c4 10 add $0x10,%esp
11230b: 85 c0 test %eax,%eax
11230d: 74 07 je 112316 <pipe_ioctl+0x46> <== ALWAYS TAKEN
return -EINTR;
11230f: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED
112314: eb d3 jmp 1122e9 <pipe_ioctl+0x19> <== NOT EXECUTED
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
112316: 8b 46 0c mov 0xc(%esi),%eax
112319: 89 03 mov %eax,(%ebx)
PIPE_UNLOCK(pipe);
11231b: 83 ec 0c sub $0xc,%esp
11231e: ff 76 28 pushl 0x28(%esi)
112321: e8 aa b2 ff ff call 10d5d0 <rtems_semaphore_release>
return 0;
112326: 83 c4 10 add $0x10,%esp
112329: 31 c0 xor %eax,%eax
11232b: eb bc jmp 1122e9 <pipe_ioctl+0x19>
00111f18 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
111f18: 55 push %ebp
111f19: 89 e5 mov %esp,%ebp
111f1b: 57 push %edi
111f1c: 56 push %esi
111f1d: 53 push %ebx
111f1e: 83 ec 30 sub $0x30,%esp
111f21: 8b 5d 08 mov 0x8(%ebp),%ebx
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
111f24: 6a 00 push $0x0
111f26: 6a 00 push $0x0
111f28: ff 73 28 pushl 0x28(%ebx)
111f2b: e8 a4 b5 ff ff call 10d4d4 <rtems_semaphore_obtain>
111f30: 83 c4 10 add $0x10,%esp
111f33: 85 c0 test %eax,%eax
111f35: 0f 85 ad 00 00 00 jne 111fe8 <pipe_read+0xd0> <== NEVER TAKEN
return -EINTR;
while (read < count) {
111f3b: 8b 55 10 mov 0x10(%ebp),%edx
111f3e: 85 d2 test %edx,%edx
111f40: 0f 84 7a 01 00 00 je 1120c0 <pipe_read+0x1a8> <== NEVER TAKEN
111f46: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
111f4d: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
while (PIPE_EMPTY(pipe)) {
111f54: 8b 53 0c mov 0xc(%ebx),%edx
111f57: 85 d2 test %edx,%edx
111f59: 0f 85 99 00 00 00 jne 111ff8 <pipe_read+0xe0>
/* Not an error */
if (pipe->Writers == 0)
111f5f: 8b 43 14 mov 0x14(%ebx),%eax
111f62: 85 c0 test %eax,%eax
111f64: 0f 84 fe 00 00 00 je 112068 <pipe_read+0x150>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
111f6a: 8b 45 14 mov 0x14(%ebp),%eax
111f6d: f6 40 14 01 testb $0x1,0x14(%eax)
111f71: 0f 85 f9 00 00 00 jne 112070 <pipe_read+0x158>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
111f77: ff 43 18 incl 0x18(%ebx)
PIPE_UNLOCK(pipe);
111f7a: 83 ec 0c sub $0xc,%esp
111f7d: ff 73 28 pushl 0x28(%ebx)
111f80: e8 4b b6 ff ff call 10d5d0 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
111f85: 5e pop %esi
111f86: 5f pop %edi
111f87: 6a 00 push $0x0
111f89: ff 73 2c pushl 0x2c(%ebx)
111f8c: e8 03 19 00 00 call 113894 <rtems_barrier_wait>
111f91: 83 c4 0c add $0xc,%esp
111f94: 83 f8 01 cmp $0x1,%eax
111f97: 19 f6 sbb %esi,%esi
111f99: f7 d6 not %esi
111f9b: 83 e6 fc and $0xfffffffc,%esi
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
111f9e: 6a 00 push $0x0
111fa0: 6a 00 push $0x0
111fa2: ff 73 28 pushl 0x28(%ebx)
111fa5: e8 2a b5 ff ff call 10d4d4 <rtems_semaphore_obtain>
111faa: 83 c4 10 add $0x10,%esp
111fad: 85 c0 test %eax,%eax
111faf: 0f 85 c7 00 00 00 jne 11207c <pipe_read+0x164> <== NEVER TAKEN
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
111fb5: ff 4b 18 decl 0x18(%ebx)
if (ret != 0)
111fb8: 85 f6 test %esi,%esi
111fba: 74 98 je 111f54 <pipe_read+0x3c> <== ALWAYS TAKEN
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
111fbc: 83 ec 0c sub $0xc,%esp
111fbf: ff 73 28 pushl 0x28(%ebx)
111fc2: e8 09 b6 ff ff call 10d5d0 <rtems_semaphore_release>
111fc7: 83 c4 10 add $0x10,%esp
out_nolock:
if (read > 0)
111fca: 8b 55 d4 mov -0x2c(%ebp),%edx
111fcd: 85 d2 test %edx,%edx
111fcf: 7e 0b jle 111fdc <pipe_read+0xc4>
111fd1: 8b 45 d4 mov -0x2c(%ebp),%eax
return read;
return ret;
}
111fd4: 8d 65 f4 lea -0xc(%ebp),%esp
111fd7: 5b pop %ebx
111fd8: 5e pop %esi
111fd9: 5f pop %edi
111fda: c9 leave
111fdb: c3 ret
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
return read;
return ret;
111fdc: 89 f0 mov %esi,%eax
}
111fde: 8d 65 f4 lea -0xc(%ebp),%esp
111fe1: 5b pop %ebx
111fe2: 5e pop %esi
111fe3: 5f pop %edi
111fe4: c9 leave
111fe5: c3 ret
111fe6: 66 90 xchg %ax,%ax
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
111fe8: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED
out_nolock:
if (read > 0)
return read;
return ret;
}
111fed: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
111ff0: 5b pop %ebx <== NOT EXECUTED
111ff1: 5e pop %esi <== NOT EXECUTED
111ff2: 5f pop %edi <== NOT EXECUTED
111ff3: c9 leave <== NOT EXECUTED
111ff4: c3 ret <== NOT EXECUTED
111ff5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
111ff8: 8b 45 10 mov 0x10(%ebp),%eax
111ffb: 2b 45 d0 sub -0x30(%ebp),%eax
111ffe: 89 55 cc mov %edx,-0x34(%ebp)
112001: 39 c2 cmp %eax,%edx
112003: 76 03 jbe 112008 <pipe_read+0xf0>
112005: 89 45 cc mov %eax,-0x34(%ebp)
chunk1 = pipe->Size - pipe->Start;
112008: 8b 73 08 mov 0x8(%ebx),%esi
11200b: 8b 43 04 mov 0x4(%ebx),%eax
11200e: 29 f0 sub %esi,%eax
if (chunk > chunk1) {
112010: 39 45 cc cmp %eax,-0x34(%ebp)
112013: 7f 71 jg 112086 <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);
112015: 8b 45 0c mov 0xc(%ebp),%eax
112018: 03 45 d0 add -0x30(%ebp),%eax
11201b: 03 33 add (%ebx),%esi
11201d: 89 c7 mov %eax,%edi
11201f: 8b 4d cc mov -0x34(%ebp),%ecx
112022: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
pipe->Start += chunk;
112024: 8b 45 cc mov -0x34(%ebp),%eax
112027: 03 43 08 add 0x8(%ebx),%eax
pipe->Start %= pipe->Size;
11202a: 31 d2 xor %edx,%edx
11202c: f7 73 04 divl 0x4(%ebx)
11202f: 89 53 08 mov %edx,0x8(%ebx)
pipe->Length -= chunk;
112032: 8b 43 0c mov 0xc(%ebx),%eax
112035: 2b 45 cc sub -0x34(%ebp),%eax
112038: 89 43 0c mov %eax,0xc(%ebx)
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
11203b: 85 c0 test %eax,%eax
11203d: 75 07 jne 112046 <pipe_read+0x12e>
pipe->Start = 0;
11203f: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
if (pipe->waitingWriters > 0)
112046: 8b 4b 1c mov 0x1c(%ebx),%ecx
112049: 85 c9 test %ecx,%ecx
11204b: 75 5f jne 1120ac <pipe_read+0x194>
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
11204d: 8b 45 cc mov -0x34(%ebp),%eax
112050: 01 45 d4 add %eax,-0x2c(%ebp)
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
112053: 8b 45 d4 mov -0x2c(%ebp),%eax
112056: 89 45 d0 mov %eax,-0x30(%ebp)
112059: 8b 45 10 mov 0x10(%ebp),%eax
11205c: 39 45 d4 cmp %eax,-0x2c(%ebp)
11205f: 0f 82 ef fe ff ff jb 111f54 <pipe_read+0x3c> <== NEVER TAKEN
112065: 8d 76 00 lea 0x0(%esi),%esi
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
112068: 31 f6 xor %esi,%esi
11206a: e9 4d ff ff ff jmp 111fbc <pipe_read+0xa4>
11206f: 90 nop
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
112070: be f5 ff ff ff mov $0xfffffff5,%esi
112075: e9 42 ff ff ff jmp 111fbc <pipe_read+0xa4>
11207a: 66 90 xchg %ax,%ax
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
11207c: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED
112081: e9 44 ff ff ff jmp 111fca <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);
112086: 8b 55 0c mov 0xc(%ebp),%edx
112089: 03 55 d0 add -0x30(%ebp),%edx
11208c: 03 33 add (%ebx),%esi
11208e: 89 d7 mov %edx,%edi
112090: 89 c1 mov %eax,%ecx
112092: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
112094: 8b 55 d0 mov -0x30(%ebp),%edx
112097: 01 c2 add %eax,%edx
112099: 03 55 0c add 0xc(%ebp),%edx
11209c: 8b 4d cc mov -0x34(%ebp),%ecx
11209f: 29 c1 sub %eax,%ecx
1120a1: 8b 33 mov (%ebx),%esi
1120a3: 89 d7 mov %edx,%edi
1120a5: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
1120a7: e9 78 ff ff ff jmp 112024 <pipe_read+0x10c>
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
1120ac: 83 ec 08 sub $0x8,%esp
1120af: 8d 45 e4 lea -0x1c(%ebp),%eax
1120b2: 50 push %eax
1120b3: ff 73 30 pushl 0x30(%ebx)
1120b6: e8 75 17 00 00 call 113830 <rtems_barrier_release>
1120bb: 83 c4 10 add $0x10,%esp
1120be: eb 8d jmp 11204d <pipe_read+0x135>
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
1120c0: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED
1120c7: 31 f6 xor %esi,%esi <== NOT EXECUTED
1120c9: e9 ee fe ff ff jmp 111fbc <pipe_read+0xa4> <== NOT EXECUTED
001119c4 <pipe_release>:
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
1119c4: 55 push %ebp
1119c5: 89 e5 mov %esp,%ebp
1119c7: 57 push %edi
1119c8: 56 push %esi
1119c9: 53 push %ebx
1119ca: 83 ec 1c sub $0x1c,%esp
1119cd: 8b 7d 08 mov 0x8(%ebp),%edi
pipe_control_t *pipe = *pipep;
1119d0: 8b 1f mov (%edi),%ebx
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
1119d2: 8b 45 0c mov 0xc(%ebp),%eax
1119d5: 8b 40 14 mov 0x14(%eax),%eax
1119d8: 89 c6 mov %eax,%esi
1119da: 83 e6 06 and $0x6,%esi
if (mode & LIBIO_FLAGS_READ)
1119dd: a8 02 test $0x2,%al
1119df: 74 03 je 1119e4 <pipe_release+0x20>
pipe->Readers --;
1119e1: ff 4b 10 decl 0x10(%ebx)
if (mode & LIBIO_FLAGS_WRITE)
1119e4: f7 c6 04 00 00 00 test $0x4,%esi
1119ea: 74 03 je 1119ef <pipe_release+0x2b>
pipe->Writers --;
1119ec: ff 4b 14 decl 0x14(%ebx)
PIPE_UNLOCK(pipe);
1119ef: 83 ec 0c sub $0xc,%esp
1119f2: ff 73 28 pushl 0x28(%ebx)
1119f5: e8 d6 bb ff ff call 10d5d0 <rtems_semaphore_release>
if (pipe->Readers == 0 && pipe->Writers == 0) {
1119fa: 83 c4 10 add $0x10,%esp
1119fd: 8b 53 10 mov 0x10(%ebx),%edx
111a00: 85 d2 test %edx,%edx
111a02: 74 2c je 111a30 <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)
111a04: 8b 43 14 mov 0x14(%ebx),%eax
111a07: 85 c0 test %eax,%eax
111a09: 75 17 jne 111a22 <pipe_release+0x5e> <== NEVER TAKEN
111a0b: 83 fe 02 cmp $0x2,%esi
111a0e: 74 12 je 111a22 <pipe_release+0x5e> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
111a10: 83 ec 08 sub $0x8,%esp
111a13: 8d 45 e4 lea -0x1c(%ebp),%eax
111a16: 50 push %eax
111a17: ff 73 2c pushl 0x2c(%ebx)
111a1a: e8 11 1e 00 00 call 113830 <rtems_barrier_release>
111a1f: 83 c4 10 add $0x10,%esp
pipe_unlock();
111a22: e8 85 ff ff ff call 1119ac <pipe_unlock>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
111a27: 8d 65 f4 lea -0xc(%ebp),%esp
111a2a: 5b pop %ebx
111a2b: 5e pop %esi
111a2c: 5f pop %edi
111a2d: c9 leave
111a2e: c3 ret
111a2f: 90 nop
if (mode & LIBIO_FLAGS_WRITE)
pipe->Writers --;
PIPE_UNLOCK(pipe);
if (pipe->Readers == 0 && pipe->Writers == 0) {
111a30: 8b 43 14 mov 0x14(%ebx),%eax
111a33: 85 c0 test %eax,%eax
111a35: 74 25 je 111a5c <pipe_release+0x98>
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
111a37: 83 fe 04 cmp $0x4,%esi
111a3a: 74 e6 je 111a22 <pipe_release+0x5e> <== NEVER TAKEN
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
111a3c: 83 ec 08 sub $0x8,%esp
111a3f: 8d 45 e4 lea -0x1c(%ebp),%eax
111a42: 50 push %eax
111a43: ff 73 30 pushl 0x30(%ebx)
111a46: e8 e5 1d 00 00 call 113830 <rtems_barrier_release>
111a4b: 83 c4 10 add $0x10,%esp
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
PIPE_WAKEUPREADERS(pipe);
pipe_unlock();
111a4e: e8 59 ff ff ff call 1119ac <pipe_unlock>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
111a53: 8d 65 f4 lea -0xc(%ebp),%esp
111a56: 5b pop %ebx
111a57: 5e pop %esi
111a58: 5f pop %edi
111a59: c9 leave
111a5a: c3 ret
111a5b: 90 nop
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
111a5c: 83 ec 0c sub $0xc,%esp
111a5f: ff 73 2c pushl 0x2c(%ebx)
111a62: e8 39 1d 00 00 call 1137a0 <rtems_barrier_delete>
rtems_barrier_delete(pipe->writeBarrier);
111a67: 5e pop %esi
111a68: ff 73 30 pushl 0x30(%ebx)
111a6b: e8 30 1d 00 00 call 1137a0 <rtems_barrier_delete>
rtems_semaphore_delete(pipe->Semaphore);
111a70: 59 pop %ecx
111a71: ff 73 28 pushl 0x28(%ebx)
111a74: e8 b7 b9 ff ff call 10d430 <rtems_semaphore_delete>
free(pipe->Buffer);
111a79: 5a pop %edx
111a7a: ff 33 pushl (%ebx)
111a7c: e8 4f 7f ff ff call 1099d0 <free>
free(pipe);
111a81: 89 1c 24 mov %ebx,(%esp)
111a84: e8 47 7f ff ff call 1099d0 <free>
/* To delete an anonymous pipe file when all users closed it */
if (pipe->Anonymous)
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
111a89: c7 07 00 00 00 00 movl $0x0,(%edi)
111a8f: 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();
111a92: e8 15 ff ff ff call 1119ac <pipe_unlock>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
111a97: 8d 65 f4 lea -0xc(%ebp),%esp
111a9a: 5b pop %ebx
111a9b: 5e pop %esi
111a9c: 5f pop %edi
111a9d: c9 leave
111a9e: c3 ret
001120d0 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
1120d0: 55 push %ebp
1120d1: 89 e5 mov %esp,%ebp
1120d3: 57 push %edi
1120d4: 56 push %esi
1120d5: 53 push %ebx
1120d6: 83 ec 2c sub $0x2c,%esp
1120d9: 8b 5d 10 mov 0x10(%ebp),%ebx
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
1120dc: 85 db test %ebx,%ebx
1120de: 75 0c jne 1120ec <pipe_write+0x1c> <== ALWAYS TAKEN
return 0;
1120e0: 31 c0 xor %eax,%eax
#endif
if (written > 0)
return written;
return ret;
}
1120e2: 8d 65 f4 lea -0xc(%ebp),%esp
1120e5: 5b pop %ebx
1120e6: 5e pop %esi
1120e7: 5f pop %edi
1120e8: c9 leave
1120e9: c3 ret
1120ea: 66 90 xchg %ax,%ax
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
1120ec: 56 push %esi
1120ed: 6a 00 push $0x0
1120ef: 6a 00 push $0x0
1120f1: 8b 45 08 mov 0x8(%ebp),%eax
1120f4: ff 70 28 pushl 0x28(%eax)
1120f7: e8 d8 b3 ff ff call 10d4d4 <rtems_semaphore_obtain>
1120fc: 83 c4 10 add $0x10,%esp
1120ff: 85 c0 test %eax,%eax
112101: 0f 85 4a 01 00 00 jne 112251 <pipe_write+0x181> <== NEVER TAKEN
return -EINTR;
if (pipe->Readers == 0) {
112107: 8b 45 08 mov 0x8(%ebp),%eax
11210a: 8b 48 10 mov 0x10(%eax),%ecx
11210d: 85 c9 test %ecx,%ecx
11210f: 0f 84 57 01 00 00 je 11226c <pipe_write+0x19c>
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
112115: 8b 48 04 mov 0x4(%eax),%ecx
112118: 39 cb cmp %ecx,%ebx
11211a: 0f 87 42 01 00 00 ja 112262 <pipe_write+0x192> <== NEVER TAKEN
112120: 89 de mov %ebx,%esi
112122: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
112129: 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);
112130: 89 5d c8 mov %ebx,-0x38(%ebp)
112133: 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) {
112136: 8b 43 0c mov 0xc(%ebx),%eax
112139: 89 ca mov %ecx,%edx
11213b: 29 c2 sub %eax,%edx
11213d: 39 f2 cmp %esi,%edx
11213f: 73 6f jae 1121b0 <pipe_write+0xe0>
if (LIBIO_NODELAY(iop)) {
112141: 8b 45 14 mov 0x14(%ebp),%eax
112144: f6 40 14 01 testb $0x1,0x14(%eax)
112148: 0f 85 48 01 00 00 jne 112296 <pipe_write+0x1c6>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
11214e: ff 43 1c incl 0x1c(%ebx)
PIPE_UNLOCK(pipe);
112151: 83 ec 0c sub $0xc,%esp
112154: ff 73 28 pushl 0x28(%ebx)
112157: e8 74 b4 ff ff call 10d5d0 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
11215c: 58 pop %eax
11215d: 5a pop %edx
11215e: 6a 00 push $0x0
112160: ff 73 30 pushl 0x30(%ebx)
112163: e8 2c 17 00 00 call 113894 <rtems_barrier_wait>
112168: 83 c4 0c add $0xc,%esp
11216b: 83 f8 01 cmp $0x1,%eax
11216e: 19 ff sbb %edi,%edi
112170: f7 d7 not %edi
112172: 83 e7 fc and $0xfffffffc,%edi
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
112175: 6a 00 push $0x0
112177: 6a 00 push $0x0
112179: ff 73 28 pushl 0x28(%ebx)
11217c: e8 53 b3 ff ff call 10d4d4 <rtems_semaphore_obtain>
112181: 83 c4 10 add $0x10,%esp
112184: 85 c0 test %eax,%eax
112186: 0f 85 03 01 00 00 jne 11228f <pipe_write+0x1bf> <== NEVER TAKEN
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
11218c: ff 4b 1c decl 0x1c(%ebx)
if (ret != 0)
11218f: 85 ff test %edi,%edi
112191: 0f 85 95 00 00 00 jne 11222c <pipe_write+0x15c> <== NEVER TAKEN
goto out_locked;
if (pipe->Readers == 0) {
112197: 8b 7b 10 mov 0x10(%ebx),%edi
11219a: 85 ff test %edi,%edi
11219c: 0f 84 85 00 00 00 je 112227 <pipe_write+0x157> <== NEVER TAKEN
1121a2: 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) {
1121a5: 8b 43 0c mov 0xc(%ebx),%eax
1121a8: 89 ca mov %ecx,%edx
1121aa: 29 c2 sub %eax,%edx
1121ac: 39 f2 cmp %esi,%edx
1121ae: 72 91 jb 112141 <pipe_write+0x71> <== NEVER TAKEN
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
1121b0: 8b 75 c8 mov -0x38(%ebp),%esi
1121b3: 2b 75 d0 sub -0x30(%ebp),%esi
1121b6: 89 55 cc mov %edx,-0x34(%ebp)
1121b9: 39 f2 cmp %esi,%edx
1121bb: 76 03 jbe 1121c0 <pipe_write+0xf0>
1121bd: 89 75 cc mov %esi,-0x34(%ebp)
chunk1 = pipe->Size - PIPE_WSTART(pipe);
1121c0: 03 43 08 add 0x8(%ebx),%eax
1121c3: 31 d2 xor %edx,%edx
1121c5: f7 f1 div %ecx
1121c7: 89 c8 mov %ecx,%eax
1121c9: 29 d0 sub %edx,%eax
if (chunk > chunk1) {
1121cb: 39 45 cc cmp %eax,-0x34(%ebp)
1121ce: 0f 8e c9 00 00 00 jle 11229d <pipe_write+0x1cd>
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
1121d4: 03 13 add (%ebx),%edx
1121d6: 8b 75 0c mov 0xc(%ebp),%esi
1121d9: 03 75 d0 add -0x30(%ebp),%esi
1121dc: 89 d7 mov %edx,%edi
1121de: 89 c1 mov %eax,%ecx
1121e0: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
1121e2: 8b 13 mov (%ebx),%edx
1121e4: 8b 4d cc mov -0x34(%ebp),%ecx
1121e7: 29 c1 sub %eax,%ecx
1121e9: 03 45 d0 add -0x30(%ebp),%eax
1121ec: 8b 75 0c mov 0xc(%ebp),%esi
1121ef: 01 c6 add %eax,%esi
1121f1: 89 d7 mov %edx,%edi
1121f3: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
1121f5: 8b 45 cc mov -0x34(%ebp),%eax
1121f8: 01 43 0c add %eax,0xc(%ebx)
if (pipe->waitingReaders > 0)
1121fb: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
1121ff: 0f 85 ac 00 00 00 jne 1122b1 <pipe_write+0x1e1>
PIPE_WAKEUPREADERS(pipe);
written += chunk;
112205: 8b 45 cc mov -0x34(%ebp),%eax
112208: 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) {
11220b: 8b 45 d4 mov -0x2c(%ebp),%eax
11220e: 89 45 d0 mov %eax,-0x30(%ebp)
112211: 39 45 c8 cmp %eax,-0x38(%ebp)
112214: 0f 86 ad 00 00 00 jbe 1122c7 <pipe_write+0x1f7> <== ALWAYS TAKEN
11221a: 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;
11221d: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED
112222: e9 0f ff ff ff jmp 112136 <pipe_write+0x66> <== NOT EXECUTED
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
112227: 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);
11222c: 83 ec 0c sub $0xc,%esp
11222f: 8b 45 08 mov 0x8(%ebp),%eax
112232: ff 70 28 pushl 0x28(%eax)
112235: e8 96 b3 ff ff call 10d5d0 <rtems_semaphore_release>
11223a: 83 c4 10 add $0x10,%esp
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
11223d: 83 ff e0 cmp $0xffffffe0,%edi
112240: 74 38 je 11227a <pipe_write+0x1aa>
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
112242: 8b 4d d4 mov -0x2c(%ebp),%ecx
112245: 85 c9 test %ecx,%ecx
112247: 7e 12 jle 11225b <pipe_write+0x18b>
112249: 8b 45 d4 mov -0x2c(%ebp),%eax
11224c: e9 91 fe ff ff jmp 1120e2 <pipe_write+0x12>
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
112251: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED
112256: e9 87 fe ff ff jmp 1120e2 <pipe_write+0x12> <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
11225b: 89 f8 mov %edi,%eax
11225d: e9 80 fe ff ff jmp 1120e2 <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;
112262: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED
112267: e9 b6 fe ff ff jmp 112122 <pipe_write+0x52> <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
if (pipe->Readers == 0) {
ret = -EPIPE;
11226c: 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;
112271: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
112278: eb b2 jmp 11222c <pipe_write+0x15c>
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
11227a: e8 21 08 00 00 call 112aa0 <getpid>
11227f: 83 ec 08 sub $0x8,%esp
112282: 6a 0d push $0xd
112284: 50 push %eax
112285: e8 1a 0b 00 00 call 112da4 <kill>
11228a: 83 c4 10 add $0x10,%esp
11228d: eb b3 jmp 112242 <pipe_write+0x172>
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
11228f: bf fc ff ff ff mov $0xfffffffc,%edi <== NOT EXECUTED
112294: eb ac jmp 112242 <pipe_write+0x172> <== NOT EXECUTED
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
112296: bf f5 ff ff ff mov $0xfffffff5,%edi
11229b: eb 8f jmp 11222c <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);
11229d: 03 13 add (%ebx),%edx
11229f: 8b 75 0c mov 0xc(%ebp),%esi
1122a2: 03 75 d0 add -0x30(%ebp),%esi
1122a5: 89 d7 mov %edx,%edi
1122a7: 8b 4d cc mov -0x34(%ebp),%ecx
1122aa: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
1122ac: e9 44 ff ff ff jmp 1121f5 <pipe_write+0x125>
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
1122b1: 56 push %esi
1122b2: 56 push %esi
1122b3: 8d 45 e4 lea -0x1c(%ebp),%eax
1122b6: 50 push %eax
1122b7: ff 73 2c pushl 0x2c(%ebx)
1122ba: e8 71 15 00 00 call 113830 <rtems_barrier_release>
1122bf: 83 c4 10 add $0x10,%esp
1122c2: e9 3e ff ff ff jmp 112205 <pipe_write+0x135>
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
1122c7: 31 ff xor %edi,%edi
1122c9: e9 5e ff ff ff jmp 11222c <pipe_write+0x15c>
0010bad0 <posix_memalign>:
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
10bad0: 55 push %ebp
10bad1: 89 e5 mov %esp,%ebp
10bad3: 53 push %ebx
10bad4: 83 ec 04 sub $0x4,%esp
10bad7: 8b 45 0c mov 0xc(%ebp),%eax
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
10bada: ff 05 88 f1 12 00 incl 0x12f188
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
10bae0: 8d 50 ff lea -0x1(%eax),%edx
10bae3: 85 c2 test %eax,%edx
10bae5: 75 05 jne 10baec <posix_memalign+0x1c> <== NEVER TAKEN
10bae7: 83 f8 03 cmp $0x3,%eax
10baea: 77 0c ja 10baf8 <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 );
}
10baec: b8 16 00 00 00 mov $0x16,%eax
10baf1: 5a pop %edx
10baf2: 5b pop %ebx
10baf3: c9 leave
10baf4: c3 ret
10baf5: 8d 76 00 lea 0x0(%esi),%esi
10baf8: 59 pop %ecx
10baf9: 5b pop %ebx
10bafa: c9 leave
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
10bafb: e9 78 01 00 00 jmp 10bc78 <rtems_memalign>
00110950 <pthread_attr_destroy>:
#include <rtems/system.h>
int pthread_attr_destroy(
pthread_attr_t *attr
)
{
110950: 55 push %ebp
110951: 89 e5 mov %esp,%ebp
110953: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || !attr->is_initialized )
110956: 85 c0 test %eax,%eax
110958: 74 12 je 11096c <pthread_attr_destroy+0x1c>
11095a: 8b 10 mov (%eax),%edx
11095c: 85 d2 test %edx,%edx
11095e: 74 0c je 11096c <pthread_attr_destroy+0x1c>
return EINVAL;
attr->is_initialized = false;
110960: c7 00 00 00 00 00 movl $0x0,(%eax)
return 0;
110966: 31 c0 xor %eax,%eax
}
110968: c9 leave
110969: c3 ret
11096a: 66 90 xchg %ax,%ax
int pthread_attr_destroy(
pthread_attr_t *attr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
11096c: b8 16 00 00 00 mov $0x16,%eax
attr->is_initialized = false;
return 0;
}
110971: c9 leave
110972: c3 ret
00110ff0 <pthread_attr_getcputime>:
int pthread_attr_getcputime(
pthread_attr_t *attr,
int *clock_allowed
)
{
110ff0: 55 push %ebp
110ff1: 89 e5 mov %esp,%ebp
110ff3: 8b 45 08 mov 0x8(%ebp),%eax
110ff6: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized || !clock_allowed )
110ff9: 85 c0 test %eax,%eax
110ffb: 74 13 je 111010 <pthread_attr_getcputime+0x20><== NEVER TAKEN
110ffd: 8b 08 mov (%eax),%ecx
110fff: 85 c9 test %ecx,%ecx
111001: 74 0d je 111010 <pthread_attr_getcputime+0x20>
111003: 85 d2 test %edx,%edx
111005: 74 09 je 111010 <pthread_attr_getcputime+0x20>
return EINVAL;
*clock_allowed = attr->cputime_clock_allowed;
111007: 8b 40 38 mov 0x38(%eax),%eax
11100a: 89 02 mov %eax,(%edx)
return 0;
11100c: 31 c0 xor %eax,%eax
}
11100e: c9 leave
11100f: c3 ret
pthread_attr_t *attr,
int *clock_allowed
)
{
if ( !attr || !attr->is_initialized || !clock_allowed )
return EINVAL;
111010: b8 16 00 00 00 mov $0x16,%eax
*clock_allowed = attr->cputime_clock_allowed;
return 0;
}
111015: c9 leave
111016: c3 ret
00110a9c <pthread_attr_getstack>:
int pthread_attr_getstack(
const pthread_attr_t *attr,
void **stackaddr,
size_t *stacksize
)
{
110a9c: 55 push %ebp
110a9d: 89 e5 mov %esp,%ebp
110a9f: 53 push %ebx
110aa0: 8b 45 08 mov 0x8(%ebp),%eax
110aa3: 8b 55 0c mov 0xc(%ebp),%edx
110aa6: 8b 4d 10 mov 0x10(%ebp),%ecx
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
110aa9: 85 c0 test %eax,%eax
110aab: 74 1f je 110acc <pthread_attr_getstack+0x30>
110aad: 8b 18 mov (%eax),%ebx
110aaf: 85 db test %ebx,%ebx
110ab1: 74 19 je 110acc <pthread_attr_getstack+0x30>
110ab3: 85 d2 test %edx,%edx
110ab5: 74 15 je 110acc <pthread_attr_getstack+0x30>
110ab7: 85 c9 test %ecx,%ecx
110ab9: 74 11 je 110acc <pthread_attr_getstack+0x30>
return EINVAL;
*stackaddr = attr->stackaddr;
110abb: 8b 58 04 mov 0x4(%eax),%ebx
110abe: 89 1a mov %ebx,(%edx)
*stacksize = attr->stacksize;
110ac0: 8b 40 08 mov 0x8(%eax),%eax
110ac3: 89 01 mov %eax,(%ecx)
return 0;
110ac5: 31 c0 xor %eax,%eax
}
110ac7: 5b pop %ebx
110ac8: c9 leave
110ac9: c3 ret
110aca: 66 90 xchg %ax,%ax
void **stackaddr,
size_t *stacksize
)
{
if ( !attr || !attr->is_initialized || !stackaddr || !stacksize )
return EINVAL;
110acc: b8 16 00 00 00 mov $0x16,%eax
*stackaddr = attr->stackaddr;
*stacksize = attr->stacksize;
return 0;
}
110ad1: 5b pop %ebx
110ad2: c9 leave
110ad3: c3 ret
00110b50 <pthread_attr_setguardsize>:
int pthread_attr_setguardsize(
pthread_attr_t *attr,
size_t guardsize
)
{
110b50: 55 push %ebp
110b51: 89 e5 mov %esp,%ebp
110b53: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || !attr->is_initialized )
110b56: 85 c0 test %eax,%eax
110b58: 74 12 je 110b6c <pthread_attr_setguardsize+0x1c>
110b5a: 8b 10 mov (%eax),%edx
110b5c: 85 d2 test %edx,%edx
110b5e: 74 0c je 110b6c <pthread_attr_setguardsize+0x1c>
return EINVAL;
attr->guardsize = guardsize;
110b60: 8b 55 0c mov 0xc(%ebp),%edx
110b63: 89 50 34 mov %edx,0x34(%eax)
return 0;
110b66: 31 c0 xor %eax,%eax
}
110b68: c9 leave
110b69: c3 ret
110b6a: 66 90 xchg %ax,%ax
pthread_attr_t *attr,
size_t guardsize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
110b6c: b8 16 00 00 00 mov $0x16,%eax
attr->guardsize = guardsize;
return 0;
}
110b71: c9 leave
110b72: c3 ret
00111b7c <pthread_attr_setinheritsched>:
int pthread_attr_setinheritsched(
pthread_attr_t *attr,
int inheritsched
)
{
111b7c: 55 push %ebp
111b7d: 89 e5 mov %esp,%ebp
111b7f: 8b 45 08 mov 0x8(%ebp),%eax
111b82: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
111b85: 85 c0 test %eax,%eax
111b87: 74 1f je 111ba8 <pthread_attr_setinheritsched+0x2c>
111b89: 8b 08 mov (%eax),%ecx
111b8b: 85 c9 test %ecx,%ecx
111b8d: 74 19 je 111ba8 <pthread_attr_setinheritsched+0x2c>
return EINVAL;
switch ( inheritsched ) {
111b8f: 8d 4a ff lea -0x1(%edx),%ecx
111b92: 83 f9 01 cmp $0x1,%ecx
111b95: 76 09 jbe 111ba0 <pthread_attr_setinheritsched+0x24>
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
return 0;
default:
return ENOTSUP;
111b97: b8 86 00 00 00 mov $0x86,%eax
}
}
111b9c: c9 leave
111b9d: c3 ret
111b9e: 66 90 xchg %ax,%ax
return EINVAL;
switch ( inheritsched ) {
case PTHREAD_INHERIT_SCHED:
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
111ba0: 89 50 10 mov %edx,0x10(%eax)
return 0;
111ba3: 31 c0 xor %eax,%eax
default:
return ENOTSUP;
}
}
111ba5: c9 leave
111ba6: c3 ret
111ba7: 90 nop
pthread_attr_t *attr,
int inheritsched
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
111ba8: b8 16 00 00 00 mov $0x16,%eax
return 0;
default:
return ENOTSUP;
}
}
111bad: c9 leave
111bae: c3 ret
00110ba8 <pthread_attr_setschedparam>:
int pthread_attr_setschedparam(
pthread_attr_t *attr,
const struct sched_param *param
)
{
110ba8: 55 push %ebp
110ba9: 89 e5 mov %esp,%ebp
110bab: 57 push %edi
110bac: 56 push %esi
110bad: 8b 7d 08 mov 0x8(%ebp),%edi
110bb0: 8b 75 0c mov 0xc(%ebp),%esi
if ( !attr || !attr->is_initialized || !param )
110bb3: 85 ff test %edi,%edi
110bb5: 74 1d je 110bd4 <pthread_attr_setschedparam+0x2c>
110bb7: 8b 07 mov (%edi),%eax
110bb9: 85 c0 test %eax,%eax
110bbb: 74 17 je 110bd4 <pthread_attr_setschedparam+0x2c>
110bbd: 85 f6 test %esi,%esi
110bbf: 74 13 je 110bd4 <pthread_attr_setschedparam+0x2c>
return EINVAL;
attr->schedparam = *param;
110bc1: 83 c7 18 add $0x18,%edi
110bc4: b9 07 00 00 00 mov $0x7,%ecx
110bc9: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return 0;
110bcb: 31 c0 xor %eax,%eax
}
110bcd: 5e pop %esi
110bce: 5f pop %edi
110bcf: c9 leave
110bd0: c3 ret
110bd1: 8d 76 00 lea 0x0(%esi),%esi
pthread_attr_t *attr,
const struct sched_param *param
)
{
if ( !attr || !attr->is_initialized || !param )
return EINVAL;
110bd4: b8 16 00 00 00 mov $0x16,%eax
attr->schedparam = *param;
return 0;
}
110bd9: 5e pop %esi
110bda: 5f pop %edi
110bdb: c9 leave
110bdc: c3 ret
00110be0 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
110be0: 55 push %ebp
110be1: 89 e5 mov %esp,%ebp
110be3: 8b 45 08 mov 0x8(%ebp),%eax
110be6: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
110be9: 85 c0 test %eax,%eax
110beb: 74 23 je 110c10 <pthread_attr_setschedpolicy+0x30>
110bed: 8b 08 mov (%eax),%ecx
110bef: 85 c9 test %ecx,%ecx
110bf1: 74 1d je 110c10 <pthread_attr_setschedpolicy+0x30>
return EINVAL;
switch ( policy ) {
110bf3: 85 d2 test %edx,%edx
110bf5: 78 0a js 110c01 <pthread_attr_setschedpolicy+0x21>
110bf7: 83 fa 02 cmp $0x2,%edx
110bfa: 7e 0c jle 110c08 <pthread_attr_setschedpolicy+0x28>
110bfc: 83 fa 04 cmp $0x4,%edx
110bff: 74 07 je 110c08 <pthread_attr_setschedpolicy+0x28><== ALWAYS TAKEN
case SCHED_SPORADIC:
attr->schedpolicy = policy;
return 0;
default:
return ENOTSUP;
110c01: b8 86 00 00 00 mov $0x86,%eax
}
}
110c06: c9 leave
110c07: c3 ret
switch ( policy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
110c08: 89 50 14 mov %edx,0x14(%eax)
return 0;
110c0b: 31 c0 xor %eax,%eax
default:
return ENOTSUP;
}
}
110c0d: c9 leave
110c0e: c3 ret
110c0f: 90 nop
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
110c10: b8 16 00 00 00 mov $0x16,%eax
return 0;
default:
return ENOTSUP;
}
}
110c15: c9 leave
110c16: c3 ret
00110c18 <pthread_attr_setscope>:
int pthread_attr_setscope(
pthread_attr_t *attr,
int contentionscope
)
{
110c18: 55 push %ebp
110c19: 89 e5 mov %esp,%ebp
110c1b: 8b 45 08 mov 0x8(%ebp),%eax
110c1e: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
110c21: 85 c0 test %eax,%eax
110c23: 74 1a je 110c3f <pthread_attr_setscope+0x27>
110c25: 8b 08 mov (%eax),%ecx
110c27: 85 c9 test %ecx,%ecx
110c29: 74 14 je 110c3f <pthread_attr_setscope+0x27>
return EINVAL;
switch ( contentionscope ) {
110c2b: 85 d2 test %edx,%edx
110c2d: 75 0d jne 110c3c <pthread_attr_setscope+0x24>
case PTHREAD_SCOPE_PROCESS:
attr->contentionscope = contentionscope;
110c2f: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
return 0;
110c36: 31 c0 xor %eax,%eax
return ENOTSUP;
default:
return EINVAL;
}
}
110c38: c9 leave
110c39: c3 ret
110c3a: 66 90 xchg %ax,%ax
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
switch ( contentionscope ) {
110c3c: 4a dec %edx
110c3d: 74 09 je 110c48 <pthread_attr_setscope+0x30>
case PTHREAD_SCOPE_SYSTEM:
return ENOTSUP;
default:
return EINVAL;
110c3f: b8 16 00 00 00 mov $0x16,%eax
}
}
110c44: c9 leave
110c45: c3 ret
110c46: 66 90 xchg %ax,%ax
case PTHREAD_SCOPE_PROCESS:
attr->contentionscope = contentionscope;
return 0;
case PTHREAD_SCOPE_SYSTEM:
return ENOTSUP;
110c48: b8 86 00 00 00 mov $0x86,%eax
default:
return EINVAL;
}
}
110c4d: c9 leave
110c4e: c3 ret
00110c74 <pthread_attr_setstack>:
int pthread_attr_setstack(
pthread_attr_t *attr,
void *stackaddr,
size_t stacksize
)
{
110c74: 55 push %ebp
110c75: 89 e5 mov %esp,%ebp
110c77: 8b 45 08 mov 0x8(%ebp),%eax
110c7a: 8b 55 10 mov 0x10(%ebp),%edx
if ( !attr || !attr->is_initialized )
110c7d: 85 c0 test %eax,%eax
110c7f: 74 27 je 110ca8 <pthread_attr_setstack+0x34>
110c81: 8b 08 mov (%eax),%ecx
110c83: 85 c9 test %ecx,%ecx
110c85: 74 21 je 110ca8 <pthread_attr_setstack+0x34>
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
110c87: 8b 0d 18 e4 12 00 mov 0x12e418,%ecx
110c8d: d1 e1 shl %ecx
110c8f: 39 d1 cmp %edx,%ecx
110c91: 77 0d ja 110ca0 <pthread_attr_setstack+0x2c>
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
else
attr->stacksize = stacksize;
110c93: 89 50 08 mov %edx,0x8(%eax)
attr->stackaddr = stackaddr;
110c96: 8b 55 0c mov 0xc(%ebp),%edx
110c99: 89 50 04 mov %edx,0x4(%eax)
return 0;
110c9c: 31 c0 xor %eax,%eax
}
110c9e: c9 leave
110c9f: c3 ret
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
110ca0: 89 48 08 mov %ecx,0x8(%eax)
110ca3: eb f1 jmp 110c96 <pthread_attr_setstack+0x22>
110ca5: 8d 76 00 lea 0x0(%esi),%esi
void *stackaddr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
110ca8: b8 16 00 00 00 mov $0x16,%eax
else
attr->stacksize = stacksize;
attr->stackaddr = stackaddr;
return 0;
}
110cad: c9 leave
110cae: c3 ret
00110c50 <pthread_attr_setstackaddr>:
int pthread_attr_setstackaddr(
pthread_attr_t *attr,
void *stackaddr
)
{
110c50: 55 push %ebp
110c51: 89 e5 mov %esp,%ebp
110c53: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || !attr->is_initialized )
110c56: 85 c0 test %eax,%eax
110c58: 74 12 je 110c6c <pthread_attr_setstackaddr+0x1c>
110c5a: 8b 10 mov (%eax),%edx
110c5c: 85 d2 test %edx,%edx
110c5e: 74 0c je 110c6c <pthread_attr_setstackaddr+0x1c>
return EINVAL;
attr->stackaddr = stackaddr;
110c60: 8b 55 0c mov 0xc(%ebp),%edx
110c63: 89 50 04 mov %edx,0x4(%eax)
return 0;
110c66: 31 c0 xor %eax,%eax
}
110c68: c9 leave
110c69: c3 ret
110c6a: 66 90 xchg %ax,%ax
pthread_attr_t *attr,
void *stackaddr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
110c6c: b8 16 00 00 00 mov $0x16,%eax
attr->stackaddr = stackaddr;
return 0;
}
110c71: c9 leave
110c72: c3 ret
00111bb0 <pthread_attr_setstacksize>:
int pthread_attr_setstacksize(
pthread_attr_t *attr,
size_t stacksize
)
{
111bb0: 55 push %ebp
111bb1: 89 e5 mov %esp,%ebp
111bb3: 8b 45 08 mov 0x8(%ebp),%eax
111bb6: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
111bb9: 85 c0 test %eax,%eax
111bbb: 74 23 je 111be0 <pthread_attr_setstacksize+0x30>
111bbd: 8b 08 mov (%eax),%ecx
111bbf: 85 c9 test %ecx,%ecx
111bc1: 74 1d je 111be0 <pthread_attr_setstacksize+0x30>
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
111bc3: 8b 0d 98 4d 12 00 mov 0x124d98,%ecx
111bc9: d1 e1 shl %ecx
111bcb: 39 d1 cmp %edx,%ecx
111bcd: 77 09 ja 111bd8 <pthread_attr_setstacksize+0x28>
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
else
attr->stacksize = stacksize;
111bcf: 89 50 08 mov %edx,0x8(%eax)
return 0;
111bd2: 31 c0 xor %eax,%eax
}
111bd4: c9 leave
111bd5: c3 ret
111bd6: 66 90 xchg %ax,%ax
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
111bd8: 89 48 08 mov %ecx,0x8(%eax)
else
attr->stacksize = stacksize;
return 0;
111bdb: 31 c0 xor %eax,%eax
}
111bdd: c9 leave
111bde: c3 ret
111bdf: 90 nop
pthread_attr_t *attr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
111be0: b8 16 00 00 00 mov $0x16,%eax
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
else
attr->stacksize = stacksize;
return 0;
}
111be5: c9 leave
111be6: c3 ret
0010b99c <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
10b99c: 55 push %ebp
10b99d: 89 e5 mov %esp,%ebp
10b99f: 57 push %edi
10b9a0: 56 push %esi
10b9a1: 53 push %ebx
10b9a2: 83 ec 2c sub $0x2c,%esp
10b9a5: 8b 5d 08 mov 0x8(%ebp),%ebx
10b9a8: 8b 7d 0c mov 0xc(%ebp),%edi
10b9ab: 8b 75 10 mov 0x10(%ebp),%esi
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
10b9ae: 85 db test %ebx,%ebx
10b9b0: 0f 84 82 00 00 00 je 10ba38 <pthread_barrier_init+0x9c>
return EINVAL;
if ( count == 0 )
10b9b6: 85 f6 test %esi,%esi
10b9b8: 74 7e je 10ba38 <pthread_barrier_init+0x9c>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10b9ba: 85 ff test %edi,%edi
10b9bc: 0f 84 92 00 00 00 je 10ba54 <pthread_barrier_init+0xb8>
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
10b9c2: 8b 17 mov (%edi),%edx
10b9c4: 85 d2 test %edx,%edx
10b9c6: 74 70 je 10ba38 <pthread_barrier_init+0x9c>
return EINVAL;
switch ( the_attr->process_shared ) {
10b9c8: 8b 47 04 mov 0x4(%edi),%eax
10b9cb: 85 c0 test %eax,%eax
10b9cd: 75 69 jne 10ba38 <pthread_barrier_init+0x9c><== NEVER TAKEN
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
10b9cf: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
the_attributes.maximum_count = count;
10b9d6: 89 75 e4 mov %esi,-0x1c(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b9d9: a1 90 85 12 00 mov 0x128590,%eax
10b9de: 40 inc %eax
10b9df: a3 90 85 12 00 mov %eax,0x128590
* the inactive chain of free barrier control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void )
{
return (POSIX_Barrier_Control *)
_Objects_Allocate( &_POSIX_Barrier_Information );
10b9e4: 83 ec 0c sub $0xc,%esp
10b9e7: 68 a0 89 12 00 push $0x1289a0
10b9ec: e8 f7 20 00 00 call 10dae8 <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
10b9f1: 83 c4 10 add $0x10,%esp
10b9f4: 85 c0 test %eax,%eax
10b9f6: 74 50 je 10ba48 <pthread_barrier_init+0xac>
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
10b9f8: 83 ec 08 sub $0x8,%esp
10b9fb: 8d 55 e0 lea -0x20(%ebp),%edx
10b9fe: 52 push %edx
10b9ff: 8d 50 10 lea 0x10(%eax),%edx
10ba02: 52 push %edx
10ba03: 89 45 d4 mov %eax,-0x2c(%ebp)
10ba06: e8 d9 16 00 00 call 10d0e4 <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10ba0b: 8b 45 d4 mov -0x2c(%ebp),%eax
10ba0e: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10ba11: 0f b7 f2 movzwl %dx,%esi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10ba14: 8b 0d bc 89 12 00 mov 0x1289bc,%ecx
10ba1a: 89 04 b1 mov %eax,(%ecx,%esi,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10ba1d: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
10ba24: 89 13 mov %edx,(%ebx)
_Thread_Enable_dispatch();
10ba26: e8 e9 30 00 00 call 10eb14 <_Thread_Enable_dispatch>
return 0;
10ba2b: 83 c4 10 add $0x10,%esp
10ba2e: 31 c0 xor %eax,%eax
}
10ba30: 8d 65 f4 lea -0xc(%ebp),%esp
10ba33: 5b pop %ebx
10ba34: 5e pop %esi
10ba35: 5f pop %edi
10ba36: c9 leave
10ba37: c3 ret
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
10ba38: b8 16 00 00 00 mov $0x16,%eax
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
_Thread_Enable_dispatch();
return 0;
}
10ba3d: 8d 65 f4 lea -0xc(%ebp),%esp
10ba40: 5b pop %ebx
10ba41: 5e pop %esi
10ba42: 5f pop %edi
10ba43: c9 leave
10ba44: c3 ret
10ba45: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
10ba48: e8 c7 30 00 00 call 10eb14 <_Thread_Enable_dispatch>
return EAGAIN;
10ba4d: b8 0b 00 00 00 mov $0xb,%eax
10ba52: eb e9 jmp 10ba3d <pthread_barrier_init+0xa1>
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
10ba54: 83 ec 0c sub $0xc,%esp
10ba57: 8d 7d d8 lea -0x28(%ebp),%edi
10ba5a: 57 push %edi
10ba5b: e8 7c fe ff ff call 10b8dc <pthread_barrierattr_init>
10ba60: 83 c4 10 add $0x10,%esp
10ba63: e9 5a ff ff ff jmp 10b9c2 <pthread_barrier_init+0x26>
0010ba68 <pthread_barrier_wait>:
*/
int pthread_barrier_wait(
pthread_barrier_t *barrier
)
{
10ba68: 55 push %ebp
10ba69: 89 e5 mov %esp,%ebp
10ba6b: 83 ec 18 sub $0x18,%esp
10ba6e: 8b 45 08 mov 0x8(%ebp),%eax
POSIX_Barrier_Control *the_barrier = NULL;
Objects_Locations location;
if ( !barrier )
10ba71: 85 c0 test %eax,%eax
10ba73: 74 4f je 10bac4 <pthread_barrier_wait+0x5c>
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get (
pthread_barrier_t *barrier,
Objects_Locations *location
)
{
return (POSIX_Barrier_Control *) _Objects_Get(
10ba75: 51 push %ecx
return EINVAL;
the_barrier = _POSIX_Barrier_Get( barrier, &location );
10ba76: 8d 55 f4 lea -0xc(%ebp),%edx
10ba79: 52 push %edx
10ba7a: ff 30 pushl (%eax)
10ba7c: 68 a0 89 12 00 push $0x1289a0
10ba81: e8 16 25 00 00 call 10df9c <_Objects_Get>
switch ( location ) {
10ba86: 83 c4 10 add $0x10,%esp
10ba89: 8b 55 f4 mov -0xc(%ebp),%edx
10ba8c: 85 d2 test %edx,%edx
10ba8e: 75 34 jne 10bac4 <pthread_barrier_wait+0x5c>
case OBJECTS_LOCAL:
_CORE_barrier_Wait(
10ba90: 83 ec 0c sub $0xc,%esp
10ba93: 6a 00 push $0x0
10ba95: 6a 00 push $0x0
10ba97: 6a 01 push $0x1
10ba99: ff 70 08 pushl 0x8(%eax)
10ba9c: 83 c0 10 add $0x10,%eax
10ba9f: 50 push %eax
10baa0: e8 73 16 00 00 call 10d118 <_CORE_barrier_Wait>
the_barrier->Object.id,
true,
0,
NULL
);
_Thread_Enable_dispatch();
10baa5: 83 c4 20 add $0x20,%esp
10baa8: e8 67 30 00 00 call 10eb14 <_Thread_Enable_dispatch>
return _POSIX_Barrier_Translate_core_barrier_return_code(
10baad: 83 ec 0c sub $0xc,%esp
_Thread_Executing->Wait.return_code );
10bab0: a1 38 8b 12 00 mov 0x128b38,%eax
true,
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_Barrier_Translate_core_barrier_return_code(
10bab5: ff 70 34 pushl 0x34(%eax)
10bab8: e8 07 5c 00 00 call 1116c4 <_POSIX_Barrier_Translate_core_barrier_return_code>
10babd: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10bac0: c9 leave
10bac1: c3 ret
10bac2: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10bac4: b8 16 00 00 00 mov $0x16,%eax
}
10bac9: c9 leave
10baca: c3 ret
0010b894 <pthread_barrierattr_destroy>:
*/
int pthread_barrierattr_destroy(
pthread_barrierattr_t *attr
)
{
10b894: 55 push %ebp
10b895: 89 e5 mov %esp,%ebp
10b897: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || attr->is_initialized == false )
10b89a: 85 c0 test %eax,%eax
10b89c: 74 12 je 10b8b0 <pthread_barrierattr_destroy+0x1c>
10b89e: 8b 10 mov (%eax),%edx
10b8a0: 85 d2 test %edx,%edx
10b8a2: 74 0c je 10b8b0 <pthread_barrierattr_destroy+0x1c>
return EINVAL;
attr->is_initialized = false;
10b8a4: c7 00 00 00 00 00 movl $0x0,(%eax)
return 0;
10b8aa: 31 c0 xor %eax,%eax
}
10b8ac: c9 leave
10b8ad: c3 ret
10b8ae: 66 90 xchg %ax,%ax
int pthread_barrierattr_destroy(
pthread_barrierattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
10b8b0: b8 16 00 00 00 mov $0x16,%eax
attr->is_initialized = false;
return 0;
}
10b8b5: c9 leave
10b8b6: c3 ret
0010b134 <pthread_cancel>:
*/
int pthread_cancel(
pthread_t thread
)
{
10b134: 55 push %ebp
10b135: 89 e5 mov %esp,%ebp
10b137: 83 ec 18 sub $0x18,%esp
/*
* Don't even think about deleting a resource from an ISR.
*/
if ( _ISR_Is_in_progress() )
10b13a: a1 54 96 12 00 mov 0x129654,%eax
10b13f: 85 c0 test %eax,%eax
10b141: 74 09 je 10b14c <pthread_cancel+0x18>
return EPROTO;
10b143: b8 47 00 00 00 mov $0x47,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b148: c9 leave
10b149: c3 ret
10b14a: 66 90 xchg %ax,%ax
pthread_t id,
Objects_Locations *location
)
{
return (Thread_Control *)
_Objects_Get( &_POSIX_Threads_Information, (Objects_Id)id, location );
10b14c: 51 push %ecx
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
the_thread = _POSIX_Threads_Get( thread, &location );
10b14d: 8d 45 f4 lea -0xc(%ebp),%eax
10b150: 50 push %eax
10b151: ff 75 08 pushl 0x8(%ebp)
10b154: 68 40 93 12 00 push $0x129340
10b159: e8 22 21 00 00 call 10d280 <_Objects_Get>
switch ( location ) {
10b15e: 83 c4 10 add $0x10,%esp
10b161: 8b 55 f4 mov -0xc(%ebp),%edx
10b164: 85 d2 test %edx,%edx
10b166: 75 20 jne 10b188 <pthread_cancel+0x54>
case OBJECTS_LOCAL:
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
thread_support->cancelation_requested = 1;
10b168: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
10b16e: c7 82 e0 00 00 00 01 movl $0x1,0xe0(%edx)
10b175: 00 00 00
/* This enables dispatch implicitly */
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( the_thread );
10b178: 83 ec 0c sub $0xc,%esp
10b17b: 50 push %eax
10b17c: e8 7b 55 00 00 call 1106fc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>
return 0;
10b181: 83 c4 10 add $0x10,%esp
10b184: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b186: c9 leave
10b187: c3 ret
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10b188: b8 16 00 00 00 mov $0x16,%eax
}
10b18d: c9 leave
10b18e: c3 ret
0010afb4 <pthread_cleanup_pop>:
*/
void pthread_cleanup_pop(
int execute
)
{
10afb4: 55 push %ebp
10afb5: 89 e5 mov %esp,%ebp
10afb7: 57 push %edi
10afb8: 56 push %esi
10afb9: 53 push %ebx
10afba: 83 ec 0c sub $0xc,%esp
10afbd: 8b 75 08 mov 0x8(%ebp),%esi
POSIX_Cancel_Handler_control tmp_handler;
Chain_Control *handler_stack;
POSIX_API_Control *thread_support;
ISR_Level level;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10afc0: a1 78 87 12 00 mov 0x128778,%eax
10afc5: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10afcb: 8b 15 d0 81 12 00 mov 0x1281d0,%edx
10afd1: 42 inc %edx
10afd2: 89 15 d0 81 12 00 mov %edx,0x1281d0
* ensure that we do not get prempted and deleted while we are holding
* memory that needs to be freed.
*/
_Thread_Disable_dispatch();
_ISR_Disable( level );
10afd8: 9c pushf
10afd9: fa cli
10afda: 5b pop %ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10afdb: 8d 90 e8 00 00 00 lea 0xe8(%eax),%edx
if ( _Chain_Is_empty( handler_stack ) ) {
10afe1: 39 90 e4 00 00 00 cmp %edx,0xe4(%eax)
10afe7: 74 47 je 10b030 <pthread_cleanup_pop+0x7c>
_Thread_Enable_dispatch();
_ISR_Enable( level );
return;
}
handler = (POSIX_Cancel_Handler_control *)
10afe9: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10afef: 8b 08 mov (%eax),%ecx
previous = the_node->previous;
10aff1: 8b 50 04 mov 0x4(%eax),%edx
next->previous = previous;
10aff4: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
10aff7: 89 0a mov %ecx,(%edx)
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
10aff9: 53 push %ebx
10affa: 9d popf
10affb: 8b 58 08 mov 0x8(%eax),%ebx
10affe: 8b 78 0c mov 0xc(%eax),%edi
tmp_handler = *handler;
_Workspace_Free( handler );
10b001: 83 ec 0c sub $0xc,%esp
10b004: 50 push %eax
10b005: e8 62 3a 00 00 call 10ea6c <_Workspace_Free>
_Thread_Enable_dispatch();
10b00a: e8 69 2a 00 00 call 10da78 <_Thread_Enable_dispatch>
if ( execute )
10b00f: 83 c4 10 add $0x10,%esp
10b012: 85 f6 test %esi,%esi
10b014: 75 0a jne 10b020 <pthread_cleanup_pop+0x6c>
(*tmp_handler.routine)( tmp_handler.arg );
}
10b016: 8d 65 f4 lea -0xc(%ebp),%esp
10b019: 5b pop %ebx
10b01a: 5e pop %esi
10b01b: 5f pop %edi
10b01c: c9 leave
10b01d: c3 ret
10b01e: 66 90 xchg %ax,%ax
_Workspace_Free( handler );
_Thread_Enable_dispatch();
if ( execute )
(*tmp_handler.routine)( tmp_handler.arg );
10b020: 89 7d 08 mov %edi,0x8(%ebp)
10b023: 89 d8 mov %ebx,%eax
}
10b025: 8d 65 f4 lea -0xc(%ebp),%esp
10b028: 5b pop %ebx
10b029: 5e pop %esi
10b02a: 5f pop %edi
10b02b: c9 leave
_Workspace_Free( handler );
_Thread_Enable_dispatch();
if ( execute )
(*tmp_handler.routine)( tmp_handler.arg );
10b02c: ff e0 jmp *%eax
10b02e: 66 90 xchg %ax,%ax
_Thread_Disable_dispatch();
_ISR_Disable( level );
if ( _Chain_Is_empty( handler_stack ) ) {
_Thread_Enable_dispatch();
10b030: e8 43 2a 00 00 call 10da78 <_Thread_Enable_dispatch>
_ISR_Enable( level );
10b035: 53 push %ebx
10b036: 9d popf
_Thread_Enable_dispatch();
if ( execute )
(*tmp_handler.routine)( tmp_handler.arg );
}
10b037: 8d 65 f4 lea -0xc(%ebp),%esp
10b03a: 5b pop %ebx
10b03b: 5e pop %esi
10b03c: 5f pop %edi
10b03d: c9 leave
10b03e: c3 ret
0010b360 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
10b360: 55 push %ebp
10b361: 89 e5 mov %esp,%ebp
10b363: 56 push %esi
10b364: 53 push %ebx
10b365: 8b 5d 08 mov 0x8(%ebp),%ebx
10b368: 8b 75 0c mov 0xc(%ebp),%esi
/*
* The POSIX standard does not address what to do when the routine
* is NULL. It also does not address what happens when we cannot
* allocate memory or anything else bad happens.
*/
if ( !routine )
10b36b: 85 db test %ebx,%ebx
10b36d: 74 4d je 10b3bc <pthread_cleanup_push+0x5c>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b36f: a1 30 98 12 00 mov 0x129830,%eax
10b374: 40 inc %eax
10b375: a3 30 98 12 00 mov %eax,0x129830
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
10b37a: 83 ec 0c sub $0xc,%esp
10b37d: 6a 10 push $0x10
10b37f: e8 28 42 00 00 call 10f5ac <_Workspace_Allocate>
if ( handler ) {
10b384: 83 c4 10 add $0x10,%esp
10b387: 85 c0 test %eax,%eax
10b389: 74 25 je 10b3b0 <pthread_cleanup_push+0x50><== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10b38b: 8b 15 d8 9d 12 00 mov 0x129dd8,%edx
handler_stack = &thread_support->Cancellation_Handlers;
10b391: 8b 92 ec 00 00 00 mov 0xec(%edx),%edx
10b397: 81 c2 e4 00 00 00 add $0xe4,%edx
handler->routine = routine;
10b39d: 89 58 08 mov %ebx,0x8(%eax)
handler->arg = arg;
10b3a0: 89 70 0c mov %esi,0xc(%eax)
_Chain_Append( handler_stack, &handler->Node );
10b3a3: 83 ec 08 sub $0x8,%esp
10b3a6: 50 push %eax
10b3a7: 52 push %edx
10b3a8: e8 bf 17 00 00 call 10cb6c <_Chain_Append>
10b3ad: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
}
10b3b0: 8d 65 f8 lea -0x8(%ebp),%esp
10b3b3: 5b pop %ebx
10b3b4: 5e pop %esi
10b3b5: c9 leave
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
}
_Thread_Enable_dispatch();
10b3b6: e9 89 31 00 00 jmp 10e544 <_Thread_Enable_dispatch>
10b3bb: 90 nop
}
10b3bc: 8d 65 f8 lea -0x8(%ebp),%esp
10b3bf: 5b pop %ebx
10b3c0: 5e pop %esi
10b3c1: c9 leave
10b3c2: c3 ret
0010c054 <pthread_cond_destroy>:
*/
int pthread_cond_destroy(
pthread_cond_t *cond
)
{
10c054: 55 push %ebp
10c055: 89 e5 mov %esp,%ebp
10c057: 53 push %ebx
10c058: 83 ec 1c sub $0x1c,%esp
POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
the_cond = _POSIX_Condition_variables_Get( cond, &location );
10c05b: 8d 45 f4 lea -0xc(%ebp),%eax
10c05e: 50 push %eax
10c05f: ff 75 08 pushl 0x8(%ebp)
10c062: e8 65 00 00 00 call 10c0cc <_POSIX_Condition_variables_Get>
10c067: 89 c3 mov %eax,%ebx
switch ( location ) {
10c069: 83 c4 10 add $0x10,%esp
10c06c: 8b 4d f4 mov -0xc(%ebp),%ecx
10c06f: 85 c9 test %ecx,%ecx
10c071: 75 25 jne 10c098 <pthread_cond_destroy+0x44>
case OBJECTS_LOCAL:
if ( _Thread_queue_First( &the_cond->Wait_queue ) ) {
10c073: 83 ec 0c sub $0xc,%esp
10c076: 8d 40 18 lea 0x18(%eax),%eax
10c079: 50 push %eax
10c07a: e8 3d 3e 00 00 call 10febc <_Thread_queue_First>
10c07f: 83 c4 10 add $0x10,%esp
10c082: 85 c0 test %eax,%eax
10c084: 74 1e je 10c0a4 <pthread_cond_destroy+0x50>
_Thread_Enable_dispatch();
10c086: e8 51 37 00 00 call 10f7dc <_Thread_Enable_dispatch>
return EBUSY;
10c08b: b8 10 00 00 00 mov $0x10,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c090: 8b 5d fc mov -0x4(%ebp),%ebx
10c093: c9 leave
10c094: c3 ret
10c095: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10c098: b8 16 00 00 00 mov $0x16,%eax
}
10c09d: 8b 5d fc mov -0x4(%ebp),%ebx
10c0a0: c9 leave
10c0a1: c3 ret
10c0a2: 66 90 xchg %ax,%ax
if ( _Thread_queue_First( &the_cond->Wait_queue ) ) {
_Thread_Enable_dispatch();
return EBUSY;
}
_Objects_Close(
10c0a4: 83 ec 08 sub $0x8,%esp
10c0a7: 53 push %ebx
10c0a8: 68 40 9a 12 00 push $0x129a40
10c0ad: e8 7a 27 00 00 call 10e82c <_Objects_Close>
RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Free (
POSIX_Condition_variables_Control *the_condition_variable
)
{
_Objects_Free(
10c0b2: 58 pop %eax
10c0b3: 5a pop %edx
10c0b4: 53 push %ebx
10c0b5: 68 40 9a 12 00 push $0x129a40
10c0ba: e8 65 2a 00 00 call 10eb24 <_Objects_Free>
&_POSIX_Condition_variables_Information,
&the_cond->Object
);
_POSIX_Condition_variables_Free( the_cond );
_Thread_Enable_dispatch();
10c0bf: e8 18 37 00 00 call 10f7dc <_Thread_Enable_dispatch>
return 0;
10c0c4: 83 c4 10 add $0x10,%esp
10c0c7: 31 c0 xor %eax,%eax
10c0c9: eb d2 jmp 10c09d <pthread_cond_destroy+0x49>
0010c120 <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
10c120: 55 push %ebp
10c121: 89 e5 mov %esp,%ebp
10c123: 53 push %ebx
10c124: 83 ec 14 sub $0x14,%esp
10c127: 8b 5d 0c mov 0xc(%ebp),%ebx
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
10c12a: 85 db test %ebx,%ebx
10c12c: 0f 84 86 00 00 00 je 10c1b8 <pthread_cond_init+0x98>
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
10c132: 83 7b 04 01 cmpl $0x1,0x4(%ebx)
10c136: 74 06 je 10c13e <pthread_cond_init+0x1e><== NEVER TAKEN
return EINVAL;
if ( !the_attr->is_initialized )
10c138: 8b 03 mov (%ebx),%eax
10c13a: 85 c0 test %eax,%eax
10c13c: 75 0a jne 10c148 <pthread_cond_init+0x28>
return EINVAL;
10c13e: b8 16 00 00 00 mov $0x16,%eax
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
return 0;
}
10c143: 8b 5d fc mov -0x4(%ebp),%ebx
10c146: c9 leave
10c147: c3 ret
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10c148: a1 90 95 12 00 mov 0x129590,%eax
10c14d: 40 inc %eax
10c14e: a3 90 95 12 00 mov %eax,0x129590
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
_Objects_Allocate( &_POSIX_Condition_variables_Information );
10c153: 83 ec 0c sub $0xc,%esp
10c156: 68 40 9a 12 00 push $0x129a40
10c15b: e8 50 26 00 00 call 10e7b0 <_Objects_Allocate>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
10c160: 83 c4 10 add $0x10,%esp
10c163: 85 c0 test %eax,%eax
10c165: 74 5d je 10c1c4 <pthread_cond_init+0xa4>
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
10c167: 8b 53 04 mov 0x4(%ebx),%edx
10c16a: 89 50 10 mov %edx,0x10(%eax)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
10c16d: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax)
_Thread_queue_Initialize(
10c174: 6a 74 push $0x74
10c176: 68 00 08 00 10 push $0x10000800
10c17b: 6a 00 push $0x0
10c17d: 8d 50 18 lea 0x18(%eax),%edx
10c180: 52 push %edx
10c181: 89 45 f4 mov %eax,-0xc(%ebp)
10c184: e8 af 3d 00 00 call 10ff38 <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10c189: 8b 45 f4 mov -0xc(%ebp),%eax
10c18c: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10c18f: 0f b7 da movzwl %dx,%ebx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c192: 8b 0d 5c 9a 12 00 mov 0x129a5c,%ecx
10c198: 89 04 99 mov %eax,(%ecx,%ebx,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10c19b: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
10c1a2: 8b 45 08 mov 0x8(%ebp),%eax
10c1a5: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10c1a7: e8 30 36 00 00 call 10f7dc <_Thread_Enable_dispatch>
return 0;
10c1ac: 83 c4 10 add $0x10,%esp
10c1af: 31 c0 xor %eax,%eax
}
10c1b1: 8b 5d fc mov -0x4(%ebp),%ebx
10c1b4: c9 leave
10c1b5: c3 ret
10c1b6: 66 90 xchg %ax,%ax
{
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
else the_attr = &_POSIX_Condition_variables_Default_attributes;
10c1b8: bb 3c 3b 12 00 mov $0x123b3c,%ebx
10c1bd: e9 70 ff ff ff jmp 10c132 <pthread_cond_init+0x12>
10c1c2: 66 90 xchg %ax,%ax
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
_Thread_Enable_dispatch();
10c1c4: e8 13 36 00 00 call 10f7dc <_Thread_Enable_dispatch>
return ENOMEM;
10c1c9: b8 0c 00 00 00 mov $0xc,%eax
10c1ce: e9 70 ff ff ff jmp 10c143 <pthread_cond_init+0x23>
0010bfb0 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
10bfb0: 55 push %ebp
10bfb1: 89 e5 mov %esp,%ebp
10bfb3: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || attr->is_initialized == false )
10bfb6: 85 c0 test %eax,%eax
10bfb8: 74 12 je 10bfcc <pthread_condattr_destroy+0x1c>
10bfba: 8b 10 mov (%eax),%edx
10bfbc: 85 d2 test %edx,%edx
10bfbe: 74 0c je 10bfcc <pthread_condattr_destroy+0x1c><== NEVER TAKEN
return EINVAL;
attr->is_initialized = false;
10bfc0: c7 00 00 00 00 00 movl $0x0,(%eax)
return 0;
10bfc6: 31 c0 xor %eax,%eax
}
10bfc8: c9 leave
10bfc9: c3 ret
10bfca: 66 90 xchg %ax,%ax
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
10bfcc: b8 16 00 00 00 mov $0x16,%eax
attr->is_initialized = false;
return 0;
}
10bfd1: c9 leave
10bfd2: c3 ret
0010bfd4 <pthread_condattr_getpshared>:
int pthread_condattr_getpshared(
const pthread_condattr_t *attr,
int *pshared
)
{
10bfd4: 55 push %ebp
10bfd5: 89 e5 mov %esp,%ebp
10bfd7: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr )
10bfda: 85 c0 test %eax,%eax
10bfdc: 74 0e je 10bfec <pthread_condattr_getpshared+0x18>
return EINVAL;
*pshared = attr->process_shared;
10bfde: 8b 50 04 mov 0x4(%eax),%edx
10bfe1: 8b 45 0c mov 0xc(%ebp),%eax
10bfe4: 89 10 mov %edx,(%eax)
return 0;
10bfe6: 31 c0 xor %eax,%eax
}
10bfe8: c9 leave
10bfe9: c3 ret
10bfea: 66 90 xchg %ax,%ax
const pthread_condattr_t *attr,
int *pshared
)
{
if ( !attr )
return EINVAL;
10bfec: b8 16 00 00 00 mov $0x16,%eax
*pshared = attr->process_shared;
return 0;
}
10bff1: c9 leave
10bff2: c3 ret
0010bff4 <pthread_condattr_init>:
*/
int pthread_condattr_init(
pthread_condattr_t *attr
)
{
10bff4: 55 push %ebp
10bff5: 89 e5 mov %esp,%ebp
10bff7: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr )
10bffa: 85 c0 test %eax,%eax
10bffc: 74 16 je 10c014 <pthread_condattr_init+0x20><== NEVER TAKEN
return EINVAL;
*attr = _POSIX_Condition_variables_Default_attributes;
10bffe: 8b 15 3c 3b 12 00 mov 0x123b3c,%edx
10c004: 8b 0d 40 3b 12 00 mov 0x123b40,%ecx
10c00a: 89 10 mov %edx,(%eax)
10c00c: 89 48 04 mov %ecx,0x4(%eax)
return 0;
10c00f: 31 c0 xor %eax,%eax
}
10c011: c9 leave
10c012: c3 ret
10c013: 90 nop
int pthread_condattr_init(
pthread_condattr_t *attr
)
{
if ( !attr )
return EINVAL;
10c014: b8 16 00 00 00 mov $0x16,%eax
*attr = _POSIX_Condition_variables_Default_attributes;
return 0;
}
10c019: c9 leave
10c01a: c3 ret
0010c01c <pthread_condattr_setpshared>:
int pthread_condattr_setpshared(
pthread_condattr_t *attr,
int pshared
)
{
10c01c: 55 push %ebp
10c01d: 89 e5 mov %esp,%ebp
10c01f: 8b 45 08 mov 0x8(%ebp),%eax
10c022: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr )
10c025: 85 c0 test %eax,%eax
10c027: 74 05 je 10c02e <pthread_condattr_setpshared+0x12>
return EINVAL;
switch ( pshared ) {
10c029: 83 fa 01 cmp $0x1,%edx
10c02c: 76 0a jbe 10c038 <pthread_condattr_setpshared+0x1c>
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
10c02e: b8 16 00 00 00 mov $0x16,%eax
}
}
10c033: c9 leave
10c034: c3 ret
10c035: 8d 76 00 lea 0x0(%esi),%esi
return EINVAL;
switch ( pshared ) {
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10c038: 89 50 04 mov %edx,0x4(%eax)
return 0;
10c03b: 31 c0 xor %eax,%eax
default:
return EINVAL;
}
}
10c03d: c9 leave
10c03e: c3 ret
0010b6d8 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
10b6d8: 55 push %ebp
10b6d9: 89 e5 mov %esp,%ebp
10b6db: 57 push %edi
10b6dc: 56 push %esi
10b6dd: 53 push %ebx
10b6de: 83 ec 5c sub $0x5c,%esp
10b6e1: 8b 5d 0c mov 0xc(%ebp),%ebx
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
10b6e4: 8b 75 10 mov 0x10(%ebp),%esi
10b6e7: 85 f6 test %esi,%esi
10b6e9: 0f 84 8d 01 00 00 je 10b87c <pthread_create+0x1a4>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
10b6ef: 85 db test %ebx,%ebx
10b6f1: 74 65 je 10b758 <pthread_create+0x80>
if ( !the_attr->is_initialized )
10b6f3: 8b 0b mov (%ebx),%ecx
10b6f5: 85 c9 test %ecx,%ecx
10b6f7: 74 1e je 10b717 <pthread_create+0x3f>
* stack space if it is allowed to allocate it itself.
*
* NOTE: If the user provides the stack we will let it drop below
* twice the minimum.
*/
if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) )
10b6f9: 8b 53 04 mov 0x4(%ebx),%edx
10b6fc: 85 d2 test %edx,%edx
10b6fe: 74 0a je 10b70a <pthread_create+0x32>
10b700: a1 98 4d 12 00 mov 0x124d98,%eax
10b705: 39 43 08 cmp %eax,0x8(%ebx)
10b708: 72 0d jb 10b717 <pthread_create+0x3f>
* If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread
* inherits scheduling attributes from the creating thread. If it is
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
10b70a: 8b 43 10 mov 0x10(%ebx),%eax
10b70d: 83 f8 01 cmp $0x1,%eax
10b710: 74 4e je 10b760 <pthread_create+0x88>
10b712: 83 f8 02 cmp $0x2,%eax
10b715: 74 11 je 10b728 <pthread_create+0x50>
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
return EINVAL;
10b717: ba 16 00 00 00 mov $0x16,%edx
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
10b71c: 89 d0 mov %edx,%eax
10b71e: 8d 65 f4 lea -0xc(%ebp),%esp
10b721: 5b pop %ebx
10b722: 5e pop %esi
10b723: 5f pop %edi
10b724: c9 leave
10b725: c3 ret
10b726: 66 90 xchg %ax,%ax
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
10b728: 8b 4b 14 mov 0x14(%ebx),%ecx
10b72b: 89 4d b0 mov %ecx,-0x50(%ebp)
schedparam = the_attr->schedparam;
10b72e: 8d 45 c4 lea -0x3c(%ebp),%eax
10b731: 89 45 b4 mov %eax,-0x4c(%ebp)
10b734: 8d 73 18 lea 0x18(%ebx),%esi
10b737: b9 07 00 00 00 mov $0x7,%ecx
10b73c: 89 c7 mov %eax,%edi
10b73e: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
10b740: 8b 43 0c mov 0xc(%ebx),%eax
10b743: 85 c0 test %eax,%eax
10b745: 74 49 je 10b790 <pthread_create+0xb8> <== ALWAYS TAKEN
return ENOTSUP;
10b747: ba 86 00 00 00 mov $0x86,%edx
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
10b74c: 89 d0 mov %edx,%eax
10b74e: 8d 65 f4 lea -0xc(%ebp),%esp
10b751: 5b pop %ebx
10b752: 5e pop %esi
10b753: 5f pop %edi
10b754: c9 leave
10b755: c3 ret
10b756: 66 90 xchg %ax,%ax
int rc;
if ( !start_routine )
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
10b758: bb 00 27 12 00 mov $0x122700,%ebx
10b75d: eb 94 jmp 10b6f3 <pthread_create+0x1b>
10b75f: 90 nop
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10b760: a1 38 96 12 00 mov 0x129638,%eax
10b765: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi
schedpolicy = api->schedpolicy;
10b76b: 8b 8e 84 00 00 00 mov 0x84(%esi),%ecx
10b771: 89 4d b0 mov %ecx,-0x50(%ebp)
schedparam = api->schedparam;
10b774: 8d 45 c4 lea -0x3c(%ebp),%eax
10b777: 89 45 b4 mov %eax,-0x4c(%ebp)
10b77a: 81 c6 88 00 00 00 add $0x88,%esi
10b780: b9 07 00 00 00 mov $0x7,%ecx
10b785: 89 c7 mov %eax,%edi
10b787: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
10b789: 8b 43 0c mov 0xc(%ebx),%eax
10b78c: 85 c0 test %eax,%eax
10b78e: 75 b7 jne 10b747 <pthread_create+0x6f>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
10b790: 83 ec 0c sub $0xc,%esp
10b793: ff 75 c4 pushl -0x3c(%ebp)
10b796: e8 b5 62 00 00 call 111a50 <_POSIX_Priority_Is_valid>
10b79b: 83 c4 10 add $0x10,%esp
10b79e: 84 c0 test %al,%al
10b7a0: 0f 84 71 ff ff ff je 10b717 <pthread_create+0x3f> <== NEVER TAKEN
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
10b7a6: 8b 7d c4 mov -0x3c(%ebp),%edi
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
10b7a9: 0f b6 35 9c 4d 12 00 movzbl 0x124d9c,%esi
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
10b7b0: 8d 45 e0 lea -0x20(%ebp),%eax
10b7b3: 50 push %eax
10b7b4: 8d 45 e4 lea -0x1c(%ebp),%eax
10b7b7: 50 push %eax
10b7b8: ff 75 b4 pushl -0x4c(%ebp)
10b7bb: ff 75 b0 pushl -0x50(%ebp)
10b7be: e8 a9 62 00 00 call 111a6c <_POSIX_Thread_Translate_sched_param>
10b7c3: 89 c2 mov %eax,%edx
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
10b7c5: 83 c4 10 add $0x10,%esp
10b7c8: 85 c0 test %eax,%eax
10b7ca: 0f 85 4c ff ff ff jne 10b71c <pthread_create+0x44>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
10b7d0: 83 ec 0c sub $0xc,%esp
10b7d3: ff 35 40 91 12 00 pushl 0x129140
10b7d9: 89 45 a0 mov %eax,-0x60(%ebp)
10b7dc: e8 b3 17 00 00 call 10cf94 <_API_Mutex_Lock>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
10b7e1: c7 04 24 20 93 12 00 movl $0x129320,(%esp)
10b7e8: e8 cb 21 00 00 call 10d9b8 <_Objects_Allocate>
10b7ed: 89 45 ac mov %eax,-0x54(%ebp)
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
10b7f0: 83 c4 10 add $0x10,%esp
10b7f3: 85 c0 test %eax,%eax
10b7f5: 8b 55 a0 mov -0x60(%ebp),%edx
10b7f8: 0f 84 0f 01 00 00 je 10b90d <pthread_create+0x235>
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
10b7fe: 8b 4d e0 mov -0x20(%ebp),%ecx
10b801: 8b 45 e4 mov -0x1c(%ebp),%eax
10b804: 89 45 a4 mov %eax,-0x5c(%ebp)
10b807: 8b 43 08 mov 0x8(%ebx),%eax
10b80a: 89 45 a8 mov %eax,-0x58(%ebp)
10b80d: a1 98 4d 12 00 mov 0x124d98,%eax
10b812: d1 e0 shl %eax
10b814: 3b 45 a8 cmp -0x58(%ebp),%eax
10b817: 73 03 jae 10b81c <pthread_create+0x144>
10b819: 8b 45 a8 mov -0x58(%ebp),%eax
10b81c: 83 ec 04 sub $0x4,%esp
10b81f: 6a 00 push $0x0
10b821: 6a 00 push $0x0
10b823: 51 push %ecx
10b824: ff 75 a4 pushl -0x5c(%ebp)
10b827: 6a 01 push $0x1
10b829: 81 e6 ff 00 00 00 and $0xff,%esi
10b82f: 29 fe sub %edi,%esi
10b831: 56 push %esi
10b832: 6a 01 push $0x1
10b834: 50 push %eax
10b835: ff 73 04 pushl 0x4(%ebx)
10b838: ff 75 ac pushl -0x54(%ebp)
10b83b: 68 20 93 12 00 push $0x129320
10b840: 89 55 a0 mov %edx,-0x60(%ebp)
10b843: e8 34 32 00 00 call 10ea7c <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
10b848: 83 c4 30 add $0x30,%esp
10b84b: 84 c0 test %al,%al
10b84d: 8b 55 a0 mov -0x60(%ebp),%edx
10b850: 75 34 jne 10b886 <pthread_create+0x1ae>
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
10b852: 83 ec 08 sub $0x8,%esp
10b855: ff 75 ac pushl -0x54(%ebp)
10b858: 68 20 93 12 00 push $0x129320
10b85d: e8 ca 24 00 00 call 10dd2c <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
10b862: 59 pop %ecx
10b863: ff 35 40 91 12 00 pushl 0x129140
10b869: e8 6e 17 00 00 call 10cfdc <_API_Mutex_Unlock>
return EAGAIN;
10b86e: 83 c4 10 add $0x10,%esp
10b871: ba 0b 00 00 00 mov $0xb,%edx
10b876: e9 a1 fe ff ff jmp 10b71c <pthread_create+0x44>
10b87b: 90 nop
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
return EFAULT;
10b87c: ba 0e 00 00 00 mov $0xe,%edx
10b881: e9 96 fe ff ff jmp 10b71c <pthread_create+0x44>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10b886: 8b 4d ac mov -0x54(%ebp),%ecx
10b889: 8b 89 ec 00 00 00 mov 0xec(%ecx),%ecx
10b88f: 89 4d a8 mov %ecx,-0x58(%ebp)
api->Attributes = *the_attr;
10b892: b9 10 00 00 00 mov $0x10,%ecx
10b897: 8b 7d a8 mov -0x58(%ebp),%edi
10b89a: 89 de mov %ebx,%esi
10b89c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
api->detachstate = the_attr->detachstate;
10b89e: 8b 43 3c mov 0x3c(%ebx),%eax
10b8a1: 8b 4d a8 mov -0x58(%ebp),%ecx
10b8a4: 89 41 40 mov %eax,0x40(%ecx)
api->schedpolicy = schedpolicy;
10b8a7: 8b 45 b0 mov -0x50(%ebp),%eax
10b8aa: 89 81 84 00 00 00 mov %eax,0x84(%ecx)
api->schedparam = schedparam;
10b8b0: 89 cf mov %ecx,%edi
10b8b2: 81 c7 88 00 00 00 add $0x88,%edi
10b8b8: b9 07 00 00 00 mov $0x7,%ecx
10b8bd: 8b 75 b4 mov -0x4c(%ebp),%esi
10b8c0: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
10b8c2: 83 ec 0c sub $0xc,%esp
10b8c5: 6a 00 push $0x0
10b8c7: ff 75 14 pushl 0x14(%ebp)
10b8ca: ff 75 10 pushl 0x10(%ebp)
10b8cd: 6a 01 push $0x1
10b8cf: ff 75 ac pushl -0x54(%ebp)
10b8d2: 89 55 a0 mov %edx,-0x60(%ebp)
10b8d5: e8 92 3a 00 00 call 10f36c <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
10b8da: 83 c4 20 add $0x20,%esp
10b8dd: 83 7d b0 04 cmpl $0x4,-0x50(%ebp)
10b8e1: 8b 55 a0 mov -0x60(%ebp),%edx
10b8e4: 74 42 je 10b928 <pthread_create+0x250>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
10b8e6: 8b 45 ac mov -0x54(%ebp),%eax
10b8e9: 8b 48 08 mov 0x8(%eax),%ecx
10b8ec: 8b 45 08 mov 0x8(%ebp),%eax
10b8ef: 89 08 mov %ecx,(%eax)
_RTEMS_Unlock_allocator();
10b8f1: 83 ec 0c sub $0xc,%esp
10b8f4: ff 35 40 91 12 00 pushl 0x129140
10b8fa: 89 55 a0 mov %edx,-0x60(%ebp)
10b8fd: e8 da 16 00 00 call 10cfdc <_API_Mutex_Unlock>
return 0;
10b902: 83 c4 10 add $0x10,%esp
10b905: 8b 55 a0 mov -0x60(%ebp),%edx
10b908: e9 0f fe ff ff jmp 10b71c <pthread_create+0x44>
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
_RTEMS_Unlock_allocator();
10b90d: 83 ec 0c sub $0xc,%esp
10b910: ff 35 40 91 12 00 pushl 0x129140
10b916: e8 c1 16 00 00 call 10cfdc <_API_Mutex_Unlock>
return EAGAIN;
10b91b: 83 c4 10 add $0x10,%esp
10b91e: ba 0b 00 00 00 mov $0xb,%edx
10b923: e9 f4 fd ff ff jmp 10b71c <pthread_create+0x44>
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
10b928: 83 ec 0c sub $0xc,%esp
&api->Sporadic_timer,
_Timespec_To_ticks( &api->schedparam.sched_ss_repl_period )
10b92b: 8b 45 a8 mov -0x58(%ebp),%eax
10b92e: 05 90 00 00 00 add $0x90,%eax
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
10b933: 50 push %eax
10b934: e8 c3 3b 00 00 call 10f4fc <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b939: 8b 4d a8 mov -0x58(%ebp),%ecx
10b93c: 89 81 b4 00 00 00 mov %eax,0xb4(%ecx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b942: 58 pop %eax
10b943: 5a pop %edx
10b944: 89 c8 mov %ecx,%eax
10b946: 05 a8 00 00 00 add $0xa8,%eax
10b94b: 50 push %eax
10b94c: 68 60 91 12 00 push $0x129160
10b951: e8 d6 3e 00 00 call 10f82c <_Watchdog_Insert>
10b956: 83 c4 10 add $0x10,%esp
10b959: 8b 55 a0 mov -0x60(%ebp),%edx
10b95c: eb 88 jmp 10b8e6 <pthread_create+0x20e>
00112dd4 <pthread_exit>:
}
void pthread_exit(
void *value_ptr
)
{
112dd4: 55 push %ebp
112dd5: 89 e5 mov %esp,%ebp
112dd7: 83 ec 10 sub $0x10,%esp
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
112dda: ff 75 08 pushl 0x8(%ebp)
112ddd: ff 35 38 83 12 00 pushl 0x128338
112de3: e8 88 ff ff ff call 112d70 <_POSIX_Thread_Exit>
112de8: 83 c4 10 add $0x10,%esp
}
112deb: c9 leave <== NOT EXECUTED
112dec: c3 ret <== NOT EXECUTED
0010d8d0 <pthread_getschedparam>:
int pthread_getschedparam(
pthread_t thread,
int *policy,
struct sched_param *param
)
{
10d8d0: 55 push %ebp
10d8d1: 89 e5 mov %esp,%ebp
10d8d3: 57 push %edi
10d8d4: 56 push %esi
10d8d5: 53 push %ebx
10d8d6: 83 ec 1c sub $0x1c,%esp
10d8d9: 8b 7d 0c mov 0xc(%ebp),%edi
10d8dc: 8b 5d 10 mov 0x10(%ebp),%ebx
Objects_Locations location;
POSIX_API_Control *api;
register Thread_Control *the_thread;
if ( !policy || !param )
10d8df: 85 ff test %edi,%edi
10d8e1: 74 69 je 10d94c <pthread_getschedparam+0x7c>
10d8e3: 85 db test %ebx,%ebx
10d8e5: 74 65 je 10d94c <pthread_getschedparam+0x7c>
pthread_t id,
Objects_Locations *location
)
{
return (Thread_Control *)
_Objects_Get( &_POSIX_Threads_Information, (Objects_Id)id, location );
10d8e7: 51 push %ecx
return EINVAL;
the_thread = _POSIX_Threads_Get( thread, &location );
10d8e8: 8d 45 e4 lea -0x1c(%ebp),%eax
10d8eb: 50 push %eax
10d8ec: ff 75 08 pushl 0x8(%ebp)
10d8ef: 68 80 cf 12 00 push $0x12cf80
10d8f4: e8 ff 23 00 00 call 10fcf8 <_Objects_Get>
switch ( location ) {
10d8f9: 83 c4 10 add $0x10,%esp
10d8fc: 8b 55 e4 mov -0x1c(%ebp),%edx
10d8ff: 85 d2 test %edx,%edx
10d901: 75 39 jne 10d93c <pthread_getschedparam+0x6c>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10d903: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi
if ( policy )
*policy = api->schedpolicy;
10d909: 8b 96 84 00 00 00 mov 0x84(%esi),%edx
10d90f: 89 17 mov %edx,(%edi)
if ( param ) {
*param = api->schedparam;
10d911: 81 c6 88 00 00 00 add $0x88,%esi
10d917: b9 07 00 00 00 mov $0x7,%ecx
10d91c: 89 df mov %ebx,%edi
10d91e: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core(
Priority_Control priority
)
{
return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
10d920: 0f b6 15 9c 89 12 00 movzbl 0x12899c,%edx
10d927: 2b 50 14 sub 0x14(%eax),%edx
10d92a: 89 13 mov %edx,(%ebx)
param->sched_priority =
_POSIX_Priority_From_core( the_thread->current_priority );
}
_Thread_Enable_dispatch();
10d92c: e8 3f 2f 00 00 call 110870 <_Thread_Enable_dispatch>
return 0;
10d931: 31 c0 xor %eax,%eax
break;
}
return ESRCH;
}
10d933: 8d 65 f4 lea -0xc(%ebp),%esp
10d936: 5b pop %ebx
10d937: 5e pop %esi
10d938: 5f pop %edi
10d939: c9 leave
10d93a: c3 ret
10d93b: 90 nop
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
10d93c: b8 03 00 00 00 mov $0x3,%eax
}
10d941: 8d 65 f4 lea -0xc(%ebp),%esp
10d944: 5b pop %ebx
10d945: 5e pop %esi
10d946: 5f pop %edi
10d947: c9 leave
10d948: c3 ret
10d949: 8d 76 00 lea 0x0(%esi),%esi
Objects_Locations location;
POSIX_API_Control *api;
register Thread_Control *the_thread;
if ( !policy || !param )
return EINVAL;
10d94c: b8 16 00 00 00 mov $0x16,%eax
break;
}
return ESRCH;
}
10d951: 8d 65 f4 lea -0xc(%ebp),%esp
10d954: 5b pop %ebx
10d955: 5e pop %esi
10d956: 5f pop %edi
10d957: c9 leave
10d958: c3 ret
0010b6b8 <pthread_getspecific>:
*/
void *pthread_getspecific(
pthread_key_t key
)
{
10b6b8: 55 push %ebp
10b6b9: 89 e5 mov %esp,%ebp
10b6bb: 83 ec 2c sub $0x2c,%esp
uint32_t api;
uint32_t index;
Objects_Locations location;
void *key_data;
the_key = _POSIX_Keys_Get( key, &location );
10b6be: 8d 45 f4 lea -0xc(%ebp),%eax
pthread_key_t id,
Objects_Locations *location
)
{
return (POSIX_Keys_Control *)
_Objects_Get( &_POSIX_Keys_Information, (Objects_Id) id, location );
10b6c1: 50 push %eax
10b6c2: ff 75 08 pushl 0x8(%ebp)
10b6c5: 68 20 a1 12 00 push $0x12a120
10b6ca: e8 9d 25 00 00 call 10dc6c <_Objects_Get>
switch ( location ) {
10b6cf: 83 c4 10 add $0x10,%esp
10b6d2: 8b 55 f4 mov -0xc(%ebp),%edx
10b6d5: 85 d2 test %edx,%edx
10b6d7: 75 2b jne 10b704 <pthread_getspecific+0x4c>
case OBJECTS_LOCAL:
api = _Objects_Get_API( _Thread_Executing->Object.id );
10b6d9: 8b 15 58 a2 12 00 mov 0x12a258,%edx
10b6df: 8b 4a 08 mov 0x8(%edx),%ecx
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
10b6e2: 89 ca mov %ecx,%edx
10b6e4: c1 ea 18 shr $0x18,%edx
10b6e7: 83 e2 07 and $0x7,%edx
index = _Objects_Get_index( _Thread_Executing->Object.id );
10b6ea: 0f b7 c9 movzwl %cx,%ecx
key_data = (void *) the_key->Values[ api ][ index ];
10b6ed: 8b 44 90 14 mov 0x14(%eax,%edx,4),%eax
10b6f1: 8b 04 88 mov (%eax,%ecx,4),%eax
_Thread_Enable_dispatch();
10b6f4: 89 45 e4 mov %eax,-0x1c(%ebp)
10b6f7: e8 e8 30 00 00 call 10e7e4 <_Thread_Enable_dispatch>
return key_data;
10b6fc: 8b 45 e4 mov -0x1c(%ebp),%eax
case OBJECTS_ERROR:
break;
}
return NULL;
}
10b6ff: c9 leave
10b700: c3 ret
10b701: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return NULL;
10b704: 31 c0 xor %eax,%eax
}
10b706: c9 leave
10b707: c3 ret
00111118 <pthread_join>:
int pthread_join(
pthread_t thread,
void **value_ptr
)
{
111118: 55 push %ebp
111119: 89 e5 mov %esp,%ebp
11111b: 53 push %ebx
11111c: 83 ec 18 sub $0x18,%esp
11111f: 8b 5d 0c mov 0xc(%ebp),%ebx
register Thread_Control *the_thread;
POSIX_API_Control *api;
Objects_Locations location;
void *return_pointer;
the_thread = _POSIX_Threads_Get( thread, &location );
111122: 8d 45 f4 lea -0xc(%ebp),%eax
111125: 50 push %eax
111126: ff 75 08 pushl 0x8(%ebp)
111129: 68 40 2a 13 00 push $0x132a40
11112e: e8 09 24 00 00 call 11353c <_Objects_Get>
switch ( location ) {
111133: 83 c4 10 add $0x10,%esp
111136: 8b 55 f4 mov -0xc(%ebp),%edx
111139: 85 d2 test %edx,%edx
11113b: 74 0b je 111148 <pthread_join+0x30>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
11113d: b8 03 00 00 00 mov $0x3,%eax
}
111142: 8b 5d fc mov -0x4(%ebp),%ebx
111145: c9 leave
111146: c3 ret
111147: 90 nop
the_thread = _POSIX_Threads_Get( thread, &location );
switch ( location ) {
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
111148: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
if ( api->detachstate == PTHREAD_CREATE_DETACHED ) {
11114e: 8b 4a 40 mov 0x40(%edx),%ecx
111151: 85 c9 test %ecx,%ecx
111153: 74 43 je 111198 <pthread_join+0x80>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
111155: 8b 0d 58 2d 13 00 mov 0x132d58,%ecx
_Thread_Enable_dispatch();
return EINVAL;
}
if ( _Thread_Is_executing( the_thread ) ) {
11115b: 39 c8 cmp %ecx,%eax
11115d: 74 49 je 1111a8 <pthread_join+0x90>
/*
* Put ourself on the threads join list
*/
_Thread_Executing->Wait.return_argument = &return_pointer;
11115f: 8d 45 f0 lea -0x10(%ebp),%eax
111162: 89 41 28 mov %eax,0x28(%ecx)
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;
111165: c7 42 74 01 00 00 00 movl $0x1,0x74(%edx)
_Thread_queue_Enter_critical_section( &api->Join_List );
_Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT );
11116c: 50 push %eax
11116d: 68 84 48 11 00 push $0x114884
111172: 6a 00 push $0x0
111174: 83 c2 44 add $0x44,%edx
111177: 52 push %edx
111178: e8 db 33 00 00 call 114558 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
11117d: e8 32 2f 00 00 call 1140b4 <_Thread_Enable_dispatch>
if ( value_ptr )
111182: 83 c4 10 add $0x10,%esp
111185: 85 db test %ebx,%ebx
111187: 74 2b je 1111b4 <pthread_join+0x9c>
*value_ptr = return_pointer;
111189: 8b 45 f0 mov -0x10(%ebp),%eax
11118c: 89 03 mov %eax,(%ebx)
return 0;
11118e: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
111190: 8b 5d fc mov -0x4(%ebp),%ebx
111193: c9 leave
111194: c3 ret
111195: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( api->detachstate == PTHREAD_CREATE_DETACHED ) {
_Thread_Enable_dispatch();
111198: e8 17 2f 00 00 call 1140b4 <_Thread_Enable_dispatch>
return EINVAL;
11119d: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
1111a2: 8b 5d fc mov -0x4(%ebp),%ebx
1111a5: c9 leave
1111a6: c3 ret
1111a7: 90 nop
_Thread_Enable_dispatch();
return EINVAL;
}
if ( _Thread_Is_executing( the_thread ) ) {
_Thread_Enable_dispatch();
1111a8: e8 07 2f 00 00 call 1140b4 <_Thread_Enable_dispatch>
return EDEADLK;
1111ad: b8 2d 00 00 00 mov $0x2d,%eax
1111b2: eb 8e jmp 111142 <pthread_join+0x2a>
_Thread_Enable_dispatch();
if ( value_ptr )
*value_ptr = return_pointer;
return 0;
1111b4: 31 c0 xor %eax,%eax
1111b6: eb 8a jmp 111142 <pthread_join+0x2a>
0010b544 <pthread_key_create>:
int pthread_key_create(
pthread_key_t *key,
void (*destructor)( void * )
)
{
10b544: 55 push %ebp
10b545: 89 e5 mov %esp,%ebp
10b547: 57 push %edi
10b548: 56 push %esi
10b549: 53 push %ebx
10b54a: 83 ec 28 sub $0x28,%esp
10b54d: a1 b0 9c 12 00 mov 0x129cb0,%eax
10b552: 40 inc %eax
10b553: a3 b0 9c 12 00 mov %eax,0x129cb0
* the inactive chain of free keys control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Allocate( void )
{
return (POSIX_Keys_Control *) _Objects_Allocate( &_POSIX_Keys_Information );
10b558: 68 20 a1 12 00 push $0x12a120
10b55d: e8 56 22 00 00 call 10d7b8 <_Objects_Allocate>
10b562: 89 c6 mov %eax,%esi
_Thread_Disable_dispatch();
the_key = _POSIX_Keys_Allocate();
if ( !the_key ) {
10b564: 83 c4 10 add $0x10,%esp
10b567: 85 c0 test %eax,%eax
10b569: 74 79 je 10b5e4 <pthread_key_create+0xa0>
_Thread_Enable_dispatch();
return EAGAIN;
}
the_key->destructor = destructor;
10b56b: 8b 45 0c mov 0xc(%ebp),%eax
10b56e: 89 46 10 mov %eax,0x10(%esi)
* This is a bit more complex than one might initially expect because
* APIs are optional.
*
* NOTE: Currently RTEMS Classic API tasks are always enabled.
*/
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) {
10b571: bb 01 00 00 00 mov $0x1,%ebx
the_key->Values[ the_api ] = NULL;
10b576: c7 44 9e 14 00 00 00 movl $0x0,0x14(%esi,%ebx,4)
10b57d: 00
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
10b57e: 8b 04 9d 88 9c 12 00 mov 0x129c88(,%ebx,4),%eax
10b585: 8b 40 04 mov 0x4(%eax),%eax
10b588: 0f b7 40 10 movzwl 0x10(%eax),%eax
true,
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
10b58c: 8d 0c 85 04 00 00 00 lea 0x4(,%eax,4),%ecx
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
table = _Workspace_Allocate( bytes_to_allocate );
10b593: 83 ec 0c sub $0xc,%esp
10b596: 51 push %ecx
10b597: 89 4d e4 mov %ecx,-0x1c(%ebp)
10b59a: e8 25 43 00 00 call 10f8c4 <_Workspace_Allocate>
if ( !table ) {
10b59f: 83 c4 10 add $0x10,%esp
10b5a2: 85 c0 test %eax,%eax
10b5a4: 8b 4d e4 mov -0x1c(%ebp),%ecx
10b5a7: 74 4f je 10b5f8 <pthread_key_create+0xb4>
_POSIX_Keys_Free( the_key );
_Thread_Enable_dispatch();
return ENOMEM;
}
the_key->Values[ the_api ] = table;
10b5a9: 89 44 9e 14 mov %eax,0x14(%esi,%ebx,4)
memset( table, '\0', bytes_to_allocate );
10b5ad: 89 c7 mov %eax,%edi
10b5af: 31 c0 xor %eax,%eax
10b5b1: f3 aa rep stos %al,%es:(%edi)
* This is a bit more complex than one might initially expect because
* APIs are optional.
*
* NOTE: Currently RTEMS Classic API tasks are always enabled.
*/
for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) {
10b5b3: 43 inc %ebx
10b5b4: 83 fb 04 cmp $0x4,%ebx
10b5b7: 75 bd jne 10b576 <pthread_key_create+0x32>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10b5b9: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10b5bc: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10b5bf: 8b 15 3c a1 12 00 mov 0x12a13c,%edx
10b5c5: 89 34 8a mov %esi,(%edx,%ecx,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10b5c8: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
the_key->Values[ the_api ] = table;
memset( table, '\0', bytes_to_allocate );
}
_Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 );
*key = the_key->Object.id;
10b5cf: 8b 55 08 mov 0x8(%ebp),%edx
10b5d2: 89 02 mov %eax,(%edx)
_Thread_Enable_dispatch();
10b5d4: e8 0b 32 00 00 call 10e7e4 <_Thread_Enable_dispatch>
return 0;
10b5d9: 31 c0 xor %eax,%eax
}
10b5db: 8d 65 f4 lea -0xc(%ebp),%esp
10b5de: 5b pop %ebx
10b5df: 5e pop %esi
10b5e0: 5f pop %edi
10b5e1: c9 leave
10b5e2: c3 ret
10b5e3: 90 nop
_Thread_Disable_dispatch();
the_key = _POSIX_Keys_Allocate();
if ( !the_key ) {
_Thread_Enable_dispatch();
10b5e4: e8 fb 31 00 00 call 10e7e4 <_Thread_Enable_dispatch>
return EAGAIN;
10b5e9: b8 0b 00 00 00 mov $0xb,%eax
_Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 );
*key = the_key->Object.id;
_Thread_Enable_dispatch();
return 0;
}
10b5ee: 8d 65 f4 lea -0xc(%ebp),%esp
10b5f1: 5b pop %ebx
10b5f2: 5e pop %esi
10b5f3: 5f pop %edi
10b5f4: c9 leave
10b5f5: c3 ret
10b5f6: 66 90 xchg %ax,%ax
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
table = _Workspace_Allocate( bytes_to_allocate );
if ( !table ) {
_POSIX_Keys_Free_memory( the_key );
10b5f8: 83 ec 0c sub $0xc,%esp
10b5fb: 56 push %esi
10b5fc: e8 87 00 00 00 call 10b688 <_POSIX_Keys_Free_memory>
*/
RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free (
POSIX_Keys_Control *the_key
)
{
_Objects_Free( &_POSIX_Keys_Information, &the_key->Object );
10b601: 58 pop %eax
10b602: 5a pop %edx
10b603: 56 push %esi
10b604: 68 20 a1 12 00 push $0x12a120
10b609: e8 1e 25 00 00 call 10db2c <_Objects_Free>
_POSIX_Keys_Free( the_key );
_Thread_Enable_dispatch();
10b60e: e8 d1 31 00 00 call 10e7e4 <_Thread_Enable_dispatch>
return ENOMEM;
10b613: 83 c4 10 add $0x10,%esp
10b616: b8 0c 00 00 00 mov $0xc,%eax
_Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 );
*key = the_key->Object.id;
_Thread_Enable_dispatch();
return 0;
}
10b61b: 8d 65 f4 lea -0xc(%ebp),%esp
10b61e: 5b pop %ebx
10b61f: 5e pop %esi
10b620: 5f pop %edi
10b621: c9 leave
10b622: c3 ret
0010b624 <pthread_key_delete>:
* 17.1.3 Thread-Specific Data Key Deletion, P1003.1c/Draft 10, p. 167
*/
int pthread_key_delete(
pthread_key_t key
)
{
10b624: 55 push %ebp
10b625: 89 e5 mov %esp,%ebp
10b627: 53 push %ebx
10b628: 83 ec 18 sub $0x18,%esp
POSIX_Keys_Control *the_key;
Objects_Locations location;
the_key = _POSIX_Keys_Get( key, &location );
10b62b: 8d 45 f4 lea -0xc(%ebp),%eax
pthread_key_t id,
Objects_Locations *location
)
{
return (POSIX_Keys_Control *)
_Objects_Get( &_POSIX_Keys_Information, (Objects_Id) id, location );
10b62e: 50 push %eax
10b62f: ff 75 08 pushl 0x8(%ebp)
10b632: 68 20 a1 12 00 push $0x12a120
10b637: e8 30 26 00 00 call 10dc6c <_Objects_Get>
10b63c: 89 c3 mov %eax,%ebx
switch ( location ) {
10b63e: 83 c4 10 add $0x10,%esp
10b641: 8b 4d f4 mov -0xc(%ebp),%ecx
10b644: 85 c9 test %ecx,%ecx
10b646: 75 34 jne 10b67c <pthread_key_delete+0x58>
case OBJECTS_LOCAL:
_Objects_Close( &_POSIX_Keys_Information, &the_key->Object );
10b648: 83 ec 08 sub $0x8,%esp
10b64b: 50 push %eax
10b64c: 68 20 a1 12 00 push $0x12a120
10b651: e8 de 21 00 00 call 10d834 <_Objects_Close>
_POSIX_Keys_Free_memory( the_key );
10b656: 89 1c 24 mov %ebx,(%esp)
10b659: e8 2a 00 00 00 call 10b688 <_POSIX_Keys_Free_memory>
*/
RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free (
POSIX_Keys_Control *the_key
)
{
_Objects_Free( &_POSIX_Keys_Information, &the_key->Object );
10b65e: 58 pop %eax
10b65f: 5a pop %edx
10b660: 53 push %ebx
10b661: 68 20 a1 12 00 push $0x12a120
10b666: e8 c1 24 00 00 call 10db2c <_Objects_Free>
/*
* NOTE: The destructor is not called and it is the responsibility
* of the application to free the memory.
*/
_POSIX_Keys_Free( the_key );
_Thread_Enable_dispatch();
10b66b: e8 74 31 00 00 call 10e7e4 <_Thread_Enable_dispatch>
return 0;
10b670: 83 c4 10 add $0x10,%esp
10b673: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b675: 8b 5d fc mov -0x4(%ebp),%ebx
10b678: c9 leave
10b679: c3 ret
10b67a: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10b67c: b8 16 00 00 00 mov $0x16,%eax
}
10b681: 8b 5d fc mov -0x4(%ebp),%ebx
10b684: c9 leave
10b685: c3 ret
00124d8c <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
124d8c: 55 push %ebp
124d8d: 89 e5 mov %esp,%ebp
124d8f: 57 push %edi
124d90: 56 push %esi
124d91: 53 push %ebx
124d92: 83 ec 1c sub $0x1c,%esp
124d95: 8b 5d 0c mov 0xc(%ebp),%ebx
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
124d98: 85 db test %ebx,%ebx
124d9a: 0f 84 84 00 00 00 je 124e24 <pthread_kill+0x98>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
124da0: 8d 7b ff lea -0x1(%ebx),%edi
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
124da3: 83 ff 1f cmp $0x1f,%edi
124da6: 77 7c ja 124e24 <pthread_kill+0x98>
pthread_t id,
Objects_Locations *location
)
{
return (Thread_Control *)
_Objects_Get( &_POSIX_Threads_Information, (Objects_Id)id, location );
124da8: 56 push %esi
rtems_set_errno_and_return_minus_one( EINVAL );
the_thread = _POSIX_Threads_Get( thread, &location );
124da9: 8d 45 e4 lea -0x1c(%ebp),%eax
124dac: 50 push %eax
124dad: ff 75 08 pushl 0x8(%ebp)
124db0: 68 a0 ed 12 00 push $0x12eda0
124db5: e8 26 d1 fe ff call 111ee0 <_Objects_Get>
124dba: 89 c6 mov %eax,%esi
switch ( location ) {
124dbc: 83 c4 10 add $0x10,%esp
124dbf: 8b 4d e4 mov -0x1c(%ebp),%ecx
124dc2: 85 c9 test %ecx,%ecx
124dc4: 75 72 jne 124e38 <pthread_kill+0xac>
case OBJECTS_LOCAL:
/*
* If sig == 0 then just validate arguments
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
124dc6: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
124dcc: 8d 04 5b lea (%ebx,%ebx,2),%eax
124dcf: 83 3c 85 28 f1 12 00 cmpl $0x1,0x12f128(,%eax,4)
124dd6: 01
124dd7: 74 2d je 124e06 <pthread_kill+0x7a>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
124dd9: b8 01 00 00 00 mov $0x1,%eax
124dde: 89 f9 mov %edi,%ecx
124de0: d3 e0 shl %cl,%eax
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
124de2: 09 82 d4 00 00 00 or %eax,0xd4(%edx)
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
124de8: 52 push %edx
124de9: 6a 00 push $0x0
124deb: 53 push %ebx
124dec: 56 push %esi
124ded: e8 7a fe ff ff call 124c6c <_POSIX_signals_Unblock_thread>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
124df2: 83 c4 10 add $0x10,%esp
124df5: a1 b4 f0 12 00 mov 0x12f0b4,%eax
124dfa: 85 c0 test %eax,%eax
124dfc: 74 08 je 124e06 <pthread_kill+0x7a>
124dfe: 3b 35 b8 f0 12 00 cmp 0x12f0b8,%esi
124e04: 74 12 je 124e18 <pthread_kill+0x8c>
_Thread_Dispatch_necessary = true;
}
_Thread_Enable_dispatch();
124e06: e8 cd dc fe ff call 112ad8 <_Thread_Enable_dispatch>
return 0;
124e0b: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
}
124e0d: 8d 65 f4 lea -0xc(%ebp),%esp
124e10: 5b pop %ebx
124e11: 5e pop %esi
124e12: 5f pop %edi
124e13: c9 leave
124e14: c3 ret
124e15: 8d 76 00 lea 0x0(%esi),%esi
api->signals_pending |= signo_to_mask( sig );
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
124e18: c6 05 c4 f0 12 00 01 movb $0x1,0x12f0c4
124e1f: eb e5 jmp 124e06 <pthread_kill+0x7a>
124e21: 8d 76 00 lea 0x0(%esi),%esi
if ( !sig )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
rtems_set_errno_and_return_minus_one( EINVAL );
124e24: e8 0f 36 ff ff call 118438 <__errno>
124e29: c7 00 16 00 00 00 movl $0x16,(%eax)
124e2f: b8 ff ff ff ff mov $0xffffffff,%eax
124e34: eb d7 jmp 124e0d <pthread_kill+0x81>
124e36: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
124e38: e8 fb 35 ff ff call 118438 <__errno>
124e3d: c7 00 03 00 00 00 movl $0x3,(%eax)
124e43: b8 ff ff ff ff mov $0xffffffff,%eax
124e48: eb c3 jmp 124e0d <pthread_kill+0x81>
0010d19c <pthread_mutex_getprioceiling>:
int pthread_mutex_getprioceiling(
pthread_mutex_t *mutex,
int *prioceiling
)
{
10d19c: 55 push %ebp
10d19d: 89 e5 mov %esp,%ebp
10d19f: 53 push %ebx
10d1a0: 83 ec 14 sub $0x14,%esp
10d1a3: 8b 5d 0c mov 0xc(%ebp),%ebx
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
if ( !prioceiling )
10d1a6: 85 db test %ebx,%ebx
10d1a8: 74 19 je 10d1c3 <pthread_mutex_getprioceiling+0x27>
return EINVAL;
the_mutex = _POSIX_Mutex_Get( mutex, &location );
10d1aa: 83 ec 08 sub $0x8,%esp
10d1ad: 8d 45 f4 lea -0xc(%ebp),%eax
10d1b0: 50 push %eax
10d1b1: ff 75 08 pushl 0x8(%ebp)
10d1b4: e8 3b ff ff ff call 10d0f4 <_POSIX_Mutex_Get>
switch ( location ) {
10d1b9: 83 c4 10 add $0x10,%esp
10d1bc: 8b 55 f4 mov -0xc(%ebp),%edx
10d1bf: 85 d2 test %edx,%edx
10d1c1: 74 0d je 10d1d0 <pthread_mutex_getprioceiling+0x34>
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10d1c3: b8 16 00 00 00 mov $0x16,%eax
}
10d1c8: 8b 5d fc mov -0x4(%ebp),%ebx
10d1cb: c9 leave
10d1cc: c3 ret
10d1cd: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE int _POSIX_Priority_From_core(
Priority_Control priority
)
{
return (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
10d1d0: 0f b6 15 9c 89 12 00 movzbl 0x12899c,%edx
10d1d7: 2b 50 60 sub 0x60(%eax),%edx
10d1da: 89 13 mov %edx,(%ebx)
case OBJECTS_LOCAL:
*prioceiling = _POSIX_Priority_From_core(
the_mutex->Mutex.Attributes.priority_ceiling
);
_Thread_Enable_dispatch();
10d1dc: e8 8f 36 00 00 call 110870 <_Thread_Enable_dispatch>
return 0;
10d1e1: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10d1e3: 8b 5d fc mov -0x4(%ebp),%ebx
10d1e6: c9 leave
10d1e7: c3 ret
0010d1e8 <pthread_mutex_init>:
int pthread_mutex_init(
pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr
)
{
10d1e8: 55 push %ebp
10d1e9: 89 e5 mov %esp,%ebp
10d1eb: 57 push %edi
10d1ec: 56 push %esi
10d1ed: 53 push %ebx
10d1ee: 83 ec 1c sub $0x1c,%esp
10d1f1: 8b 75 08 mov 0x8(%ebp),%esi
10d1f4: 8b 5d 0c mov 0xc(%ebp),%ebx
POSIX_Mutex_Control *the_mutex;
CORE_mutex_Attributes *the_mutex_attr;
const pthread_mutexattr_t *the_attr;
CORE_mutex_Disciplines the_discipline;
if ( attr ) the_attr = attr;
10d1f7: 85 db test %ebx,%ebx
10d1f9: 0f 84 09 01 00 00 je 10d308 <pthread_mutex_init+0x120>
else the_attr = &_POSIX_Mutex_Default_attributes;
/* Check for NULL mutex */
if ( !mutex )
10d1ff: 85 f6 test %esi,%esi
10d201: 0f 84 e5 00 00 00 je 10d2ec <pthread_mutex_init+0x104>
}
}
}
#endif
if ( !the_attr->is_initialized )
10d207: 8b 13 mov (%ebx),%edx
10d209: 85 d2 test %edx,%edx
10d20b: 0f 84 db 00 00 00 je 10d2ec <pthread_mutex_init+0x104>
return EINVAL;
/*
* We only support process private mutexes.
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
10d211: 8b 43 04 mov 0x4(%ebx),%eax
10d214: 83 f8 01 cmp $0x1,%eax
10d217: 0f 84 f7 00 00 00 je 10d314 <pthread_mutex_init+0x12c>
return ENOSYS;
if ( the_attr->process_shared != PTHREAD_PROCESS_PRIVATE )
10d21d: 85 c0 test %eax,%eax
10d21f: 0f 85 c7 00 00 00 jne 10d2ec <pthread_mutex_init+0x104>
return EINVAL;
/*
* Determine the discipline of the mutex
*/
switch ( the_attr->protocol ) {
10d225: 8b 43 0c mov 0xc(%ebx),%eax
10d228: 83 f8 01 cmp $0x1,%eax
10d22b: 0f 84 eb 00 00 00 je 10d31c <pthread_mutex_init+0x134>
10d231: 83 f8 02 cmp $0x2,%eax
10d234: 0f 84 c2 00 00 00 je 10d2fc <pthread_mutex_init+0x114>
10d23a: 85 c0 test %eax,%eax
10d23c: 0f 85 aa 00 00 00 jne 10d2ec <pthread_mutex_init+0x104>
case PTHREAD_PRIO_NONE:
the_discipline = CORE_MUTEX_DISCIPLINES_FIFO;
10d242: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
}
/*
* Validate the priority ceiling field -- should always be valid.
*/
if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) )
10d249: 83 ec 0c sub $0xc,%esp
10d24c: ff 73 08 pushl 0x8(%ebx)
10d24f: e8 58 03 00 00 call 10d5ac <_POSIX_Priority_Is_valid>
10d254: 83 c4 10 add $0x10,%esp
10d257: 84 c0 test %al,%al
10d259: 0f 84 8d 00 00 00 je 10d2ec <pthread_mutex_init+0x104>
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
/*
* Validate the mutex type and set appropriate SuperCore mutex
* attributes.
*/
switch ( the_attr->type ) {
10d25f: 83 7b 10 03 cmpl $0x3,0x10(%ebx)
10d263: 0f 87 83 00 00 00 ja 10d2ec <pthread_mutex_init+0x104>
10d269: a1 f0 cc 12 00 mov 0x12ccf0,%eax
10d26e: 40 inc %eax
10d26f: a3 f0 cc 12 00 mov %eax,0x12ccf0
* _POSIX_Mutex_Allocate
*/
RTEMS_INLINE_ROUTINE POSIX_Mutex_Control *_POSIX_Mutex_Allocate( void )
{
return (POSIX_Mutex_Control *) _Objects_Allocate( &_POSIX_Mutex_Information );
10d274: 83 ec 0c sub $0xc,%esp
10d277: 68 c0 d0 12 00 push $0x12d0c0
10d27c: e8 c3 25 00 00 call 10f844 <_Objects_Allocate>
10d281: 89 c7 mov %eax,%edi
*/
_Thread_Disable_dispatch();
the_mutex = _POSIX_Mutex_Allocate();
if ( !the_mutex ) {
10d283: 83 c4 10 add $0x10,%esp
10d286: 85 c0 test %eax,%eax
10d288: 0f 84 9a 00 00 00 je 10d328 <pthread_mutex_init+0x140>
_Thread_Enable_dispatch();
return EAGAIN;
}
the_mutex->process_shared = the_attr->process_shared;
10d28e: 8b 43 04 mov 0x4(%ebx),%eax
10d291: 89 47 10 mov %eax,0x10(%edi)
the_mutex_attr = &the_mutex->Mutex.Attributes;
10d294: 8d 57 54 lea 0x54(%edi),%edx
if ( the_attr->recursive )
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
10d297: 31 c0 xor %eax,%eax
10d299: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10d29d: 0f 94 c0 sete %al
10d2a0: 89 47 54 mov %eax,0x54(%edi)
else
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR;
the_mutex_attr->only_owner_release = true;
10d2a3: c6 47 58 01 movb $0x1,0x58(%edi)
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
10d2a7: 0f b6 05 9c 89 12 00 movzbl 0x12899c,%eax
10d2ae: 2b 43 08 sub 0x8(%ebx),%eax
10d2b1: 89 47 60 mov %eax,0x60(%edi)
the_mutex_attr->priority_ceiling =
_POSIX_Priority_To_core( the_attr->prio_ceiling );
the_mutex_attr->discipline = the_discipline;
10d2b4: 8b 45 e4 mov -0x1c(%ebp),%eax
10d2b7: 89 47 5c mov %eax,0x5c(%edi)
/*
* Must be initialized to unlocked.
*/
_CORE_mutex_Initialize(
10d2ba: 50 push %eax
10d2bb: 6a 01 push $0x1
10d2bd: 52 push %edx
10d2be: 8d 47 14 lea 0x14(%edi),%eax
10d2c1: 50 push %eax
10d2c2: e8 09 1d 00 00 call 10efd0 <_CORE_mutex_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10d2c7: 8b 47 08 mov 0x8(%edi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10d2ca: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10d2cd: 8b 15 dc d0 12 00 mov 0x12d0dc,%edx
10d2d3: 89 3c 8a mov %edi,(%edx,%ecx,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10d2d6: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi)
CORE_MUTEX_UNLOCKED
);
_Objects_Open_u32( &_POSIX_Mutex_Information, &the_mutex->Object, 0 );
*mutex = the_mutex->Object.id;
10d2dd: 89 06 mov %eax,(%esi)
_Thread_Enable_dispatch();
10d2df: e8 8c 35 00 00 call 110870 <_Thread_Enable_dispatch>
return 0;
10d2e4: 83 c4 10 add $0x10,%esp
10d2e7: 31 c0 xor %eax,%eax
10d2e9: eb 06 jmp 10d2f1 <pthread_mutex_init+0x109>
10d2eb: 90 nop
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
break;
default:
return EINVAL;
10d2ec: b8 16 00 00 00 mov $0x16,%eax
*mutex = the_mutex->Object.id;
_Thread_Enable_dispatch();
return 0;
}
10d2f1: 8d 65 f4 lea -0xc(%ebp),%esp
10d2f4: 5b pop %ebx
10d2f5: 5e pop %esi
10d2f6: 5f pop %edi
10d2f7: c9 leave
10d2f8: c3 ret
10d2f9: 8d 76 00 lea 0x0(%esi),%esi
break;
case PTHREAD_PRIO_INHERIT:
the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
break;
case PTHREAD_PRIO_PROTECT:
the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
10d2fc: c7 45 e4 03 00 00 00 movl $0x3,-0x1c(%ebp)
break;
10d303: e9 41 ff ff ff jmp 10d249 <pthread_mutex_init+0x61>
CORE_mutex_Attributes *the_mutex_attr;
const pthread_mutexattr_t *the_attr;
CORE_mutex_Disciplines the_discipline;
if ( attr ) the_attr = attr;
else the_attr = &_POSIX_Mutex_Default_attributes;
10d308: bb 40 d1 12 00 mov $0x12d140,%ebx
10d30d: e9 ed fe ff ff jmp 10d1ff <pthread_mutex_init+0x17>
10d312: 66 90 xchg %ax,%ax
/*
* We only support process private mutexes.
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
return ENOSYS;
10d314: b8 58 00 00 00 mov $0x58,%eax
10d319: eb d6 jmp 10d2f1 <pthread_mutex_init+0x109>
10d31b: 90 nop
switch ( the_attr->protocol ) {
case PTHREAD_PRIO_NONE:
the_discipline = CORE_MUTEX_DISCIPLINES_FIFO;
break;
case PTHREAD_PRIO_INHERIT:
the_discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
10d31c: c7 45 e4 02 00 00 00 movl $0x2,-0x1c(%ebp)
10d323: e9 21 ff ff ff jmp 10d249 <pthread_mutex_init+0x61>
_Thread_Disable_dispatch();
the_mutex = _POSIX_Mutex_Allocate();
if ( !the_mutex ) {
_Thread_Enable_dispatch();
10d328: e8 43 35 00 00 call 110870 <_Thread_Enable_dispatch>
return EAGAIN;
10d32d: b8 0b 00 00 00 mov $0xb,%eax
10d332: eb bd jmp 10d2f1 <pthread_mutex_init+0x109>
0010d440 <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
10d440: 55 push %ebp
10d441: 89 e5 mov %esp,%ebp
10d443: 56 push %esi
10d444: 53 push %ebx
10d445: 83 ec 18 sub $0x18,%esp
10d448: 8b 75 08 mov 0x8(%ebp),%esi
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
10d44b: 8d 45 f4 lea -0xc(%ebp),%eax
10d44e: 50 push %eax
10d44f: ff 75 0c pushl 0xc(%ebp)
10d452: e8 cd 00 00 00 call 10d524 <_POSIX_Absolute_timeout_to_ticks>
10d457: 89 c3 mov %eax,%ebx
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
10d459: 83 c4 10 add $0x10,%esp
10d45c: 83 f8 03 cmp $0x3,%eax
10d45f: 74 2f je 10d490 <pthread_mutex_timedlock+0x50>
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
10d461: 50 push %eax
10d462: ff 75 f4 pushl -0xc(%ebp)
10d465: 6a 00 push $0x0
10d467: 56 push %esi
10d468: e8 db fe ff ff call 10d348 <_POSIX_Mutex_Lock_support>
* This service only gives us the option to block. We used a polling
* attempt to lock if the abstime was not in the future. If we did
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
10d46d: 83 c4 10 add $0x10,%esp
10d470: 83 f8 10 cmp $0x10,%eax
10d473: 74 07 je 10d47c <pthread_mutex_timedlock+0x3c><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return lock_status;
}
10d475: 8d 65 f8 lea -0x8(%ebp),%esp
10d478: 5b pop %ebx
10d479: 5e pop %esi
10d47a: c9 leave
10d47b: c3 ret
* attempt to lock if the abstime was not in the future. If we did
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10d47c: 85 db test %ebx,%ebx
10d47e: 74 28 je 10d4a8 <pthread_mutex_timedlock+0x68><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10d480: 4b dec %ebx
10d481: 83 fb 01 cmp $0x1,%ebx
10d484: 77 ef ja 10d475 <pthread_mutex_timedlock+0x35><== NEVER TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10d486: b8 74 00 00 00 mov $0x74,%eax
10d48b: eb e8 jmp 10d475 <pthread_mutex_timedlock+0x35>
10d48d: 8d 76 00 lea 0x0(%esi),%esi
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
10d490: 52 push %edx
10d491: ff 75 f4 pushl -0xc(%ebp)
10d494: 6a 01 push $0x1
10d496: 56 push %esi
10d497: e8 ac fe ff ff call 10d348 <_POSIX_Mutex_Lock_support>
10d49c: 83 c4 10 add $0x10,%esp
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return lock_status;
}
10d49f: 8d 65 f8 lea -0x8(%ebp),%esp
10d4a2: 5b pop %ebx
10d4a3: 5e pop %esi
10d4a4: c9 leave
10d4a5: c3 ret
10d4a6: 66 90 xchg %ax,%ax
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
10d4a8: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED
10d4ad: eb c6 jmp 10d475 <pthread_mutex_timedlock+0x35><== NOT EXECUTED
0010cf24 <pthread_mutexattr_destroy>:
*/
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
10cf24: 55 push %ebp
10cf25: 89 e5 mov %esp,%ebp
10cf27: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || !attr->is_initialized )
10cf2a: 85 c0 test %eax,%eax
10cf2c: 74 12 je 10cf40 <pthread_mutexattr_destroy+0x1c>
10cf2e: 8b 10 mov (%eax),%edx
10cf30: 85 d2 test %edx,%edx
10cf32: 74 0c je 10cf40 <pthread_mutexattr_destroy+0x1c>
return EINVAL;
attr->is_initialized = false;
10cf34: c7 00 00 00 00 00 movl $0x0,(%eax)
return 0;
10cf3a: 31 c0 xor %eax,%eax
}
10cf3c: c9 leave
10cf3d: c3 ret
10cf3e: 66 90 xchg %ax,%ax
int pthread_mutexattr_destroy(
pthread_mutexattr_t *attr
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
10cf40: b8 16 00 00 00 mov $0x16,%eax
attr->is_initialized = false;
return 0;
}
10cf45: c9 leave
10cf46: c3 ret
0010cfec <pthread_mutexattr_setprioceiling>:
int pthread_mutexattr_setprioceiling(
pthread_mutexattr_t *attr,
int prioceiling
)
{
10cfec: 55 push %ebp
10cfed: 89 e5 mov %esp,%ebp
10cfef: 56 push %esi
10cff0: 53 push %ebx
10cff1: 8b 5d 08 mov 0x8(%ebp),%ebx
10cff4: 8b 75 0c mov 0xc(%ebp),%esi
if ( !attr || !attr->is_initialized )
10cff7: 85 db test %ebx,%ebx
10cff9: 74 06 je 10d001 <pthread_mutexattr_setprioceiling+0x15><== NEVER TAKEN
10cffb: 8b 03 mov (%ebx),%eax
10cffd: 85 c0 test %eax,%eax
10cfff: 75 0f jne 10d010 <pthread_mutexattr_setprioceiling+0x24>
return EINVAL;
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
return EINVAL;
10d001: b8 16 00 00 00 mov $0x16,%eax
attr->prio_ceiling = prioceiling;
return 0;
}
10d006: 8d 65 f8 lea -0x8(%ebp),%esp
10d009: 5b pop %ebx
10d00a: 5e pop %esi
10d00b: c9 leave
10d00c: c3 ret
10d00d: 8d 76 00 lea 0x0(%esi),%esi
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
10d010: 83 ec 0c sub $0xc,%esp
10d013: 56 push %esi
10d014: e8 93 05 00 00 call 10d5ac <_POSIX_Priority_Is_valid>
10d019: 83 c4 10 add $0x10,%esp
10d01c: 84 c0 test %al,%al
10d01e: 74 e1 je 10d001 <pthread_mutexattr_setprioceiling+0x15>
return EINVAL;
attr->prio_ceiling = prioceiling;
10d020: 89 73 08 mov %esi,0x8(%ebx)
return 0;
10d023: 31 c0 xor %eax,%eax
}
10d025: 8d 65 f8 lea -0x8(%ebp),%esp
10d028: 5b pop %ebx
10d029: 5e pop %esi
10d02a: c9 leave
10d02b: c3 ret
0010d054 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
10d054: 55 push %ebp
10d055: 89 e5 mov %esp,%ebp
10d057: 8b 45 08 mov 0x8(%ebp),%eax
10d05a: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
10d05d: 85 c0 test %eax,%eax
10d05f: 74 0b je 10d06c <pthread_mutexattr_setpshared+0x18>
10d061: 8b 08 mov (%eax),%ecx
10d063: 85 c9 test %ecx,%ecx
10d065: 74 05 je 10d06c <pthread_mutexattr_setpshared+0x18>
return EINVAL;
switch ( pshared ) {
10d067: 83 fa 01 cmp $0x1,%edx
10d06a: 76 08 jbe 10d074 <pthread_mutexattr_setpshared+0x20><== ALWAYS TAKEN
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
10d06c: b8 16 00 00 00 mov $0x16,%eax
}
}
10d071: c9 leave
10d072: c3 ret
10d073: 90 nop
return EINVAL;
switch ( pshared ) {
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10d074: 89 50 04 mov %edx,0x4(%eax)
return 0;
10d077: 31 c0 xor %eax,%eax
default:
return EINVAL;
}
}
10d079: c9 leave
10d07a: c3 ret
0010b248 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
10b248: 55 push %ebp
10b249: 89 e5 mov %esp,%ebp
10b24b: 8b 45 08 mov 0x8(%ebp),%eax
10b24e: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
10b251: 85 c0 test %eax,%eax
10b253: 74 0b je 10b260 <pthread_mutexattr_settype+0x18>
10b255: 8b 08 mov (%eax),%ecx
10b257: 85 c9 test %ecx,%ecx
10b259: 74 05 je 10b260 <pthread_mutexattr_settype+0x18><== NEVER TAKEN
return EINVAL;
switch ( type ) {
10b25b: 83 fa 03 cmp $0x3,%edx
10b25e: 76 08 jbe 10b268 <pthread_mutexattr_settype+0x20>
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
return 0;
default:
return EINVAL;
10b260: b8 16 00 00 00 mov $0x16,%eax
}
}
10b265: c9 leave
10b266: c3 ret
10b267: 90 nop
switch ( type ) {
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
10b268: 89 50 10 mov %edx,0x10(%eax)
return 0;
10b26b: 31 c0 xor %eax,%eax
default:
return EINVAL;
}
}
10b26d: c9 leave
10b26e: c3 ret
0010bd9c <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
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 1c sub $0x1c,%esp
10bda5: 8b 5d 08 mov 0x8(%ebp),%ebx
10bda8: 8b 75 0c mov 0xc(%ebp),%esi
if ( !once_control || !init_routine )
10bdab: 85 db test %ebx,%ebx
10bdad: 74 51 je 10be00 <pthread_once+0x64>
10bdaf: 85 f6 test %esi,%esi
10bdb1: 74 4d je 10be00 <pthread_once+0x64>
return EINVAL;
if ( !once_control->init_executed ) {
10bdb3: 8b 7b 04 mov 0x4(%ebx),%edi
10bdb6: 85 ff test %edi,%edi
10bdb8: 74 0a je 10bdc4 <pthread_once+0x28>
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
10bdba: 31 c0 xor %eax,%eax
}
10bdbc: 8d 65 f4 lea -0xc(%ebp),%esp
10bdbf: 5b pop %ebx
10bdc0: 5e pop %esi
10bdc1: 5f pop %edi
10bdc2: c9 leave
10bdc3: c3 ret
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
10bdc4: 51 push %ecx
10bdc5: 8d 7d e4 lea -0x1c(%ebp),%edi
10bdc8: 57 push %edi
10bdc9: 68 00 01 00 00 push $0x100
10bdce: 68 00 01 00 00 push $0x100
10bdd3: e8 ec 0b 00 00 call 10c9c4 <rtems_task_mode>
if ( !once_control->init_executed ) {
10bdd8: 83 c4 10 add $0x10,%esp
10bddb: 8b 53 04 mov 0x4(%ebx),%edx
10bdde: 85 d2 test %edx,%edx
10bde0: 74 2e je 10be10 <pthread_once+0x74> <== ALWAYS TAKEN
once_control->is_initialized = true;
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
10bde2: 50 push %eax
10bde3: 57 push %edi
10bde4: 68 00 01 00 00 push $0x100
10bde9: ff 75 e4 pushl -0x1c(%ebp)
10bdec: e8 d3 0b 00 00 call 10c9c4 <rtems_task_mode>
10bdf1: 83 c4 10 add $0x10,%esp
}
return 0;
10bdf4: 31 c0 xor %eax,%eax
}
10bdf6: 8d 65 f4 lea -0xc(%ebp),%esp
10bdf9: 5b pop %ebx
10bdfa: 5e pop %esi
10bdfb: 5f pop %edi
10bdfc: c9 leave
10bdfd: c3 ret
10bdfe: 66 90 xchg %ax,%ax
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
10be00: b8 16 00 00 00 mov $0x16,%eax
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
10be05: 8d 65 f4 lea -0xc(%ebp),%esp
10be08: 5b pop %ebx
10be09: 5e pop %esi
10be0a: 5f pop %edi
10be0b: c9 leave
10be0c: c3 ret
10be0d: 8d 76 00 lea 0x0(%esi),%esi
if ( !once_control->init_executed ) {
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( !once_control->init_executed ) {
once_control->is_initialized = true;
10be10: c7 03 01 00 00 00 movl $0x1,(%ebx)
once_control->init_executed = true;
10be16: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx)
(*init_routine)();
10be1d: ff d6 call *%esi
10be1f: eb c1 jmp 10bde2 <pthread_once+0x46>
0010c480 <pthread_rwlock_destroy>:
*/
int pthread_rwlock_destroy(
pthread_rwlock_t *rwlock
)
{
10c480: 55 push %ebp
10c481: 89 e5 mov %esp,%ebp
10c483: 53 push %ebx
10c484: 83 ec 14 sub $0x14,%esp
10c487: 8b 45 08 mov 0x8(%ebp),%eax
POSIX_RWLock_Control *the_rwlock = NULL;
Objects_Locations location;
if ( !rwlock )
10c48a: 85 c0 test %eax,%eax
10c48c: 74 42 je 10c4d0 <pthread_rwlock_destroy+0x50>
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get (
pthread_rwlock_t *RWLock,
Objects_Locations *location
)
{
return (POSIX_RWLock_Control *) _Objects_Get(
10c48e: 53 push %ebx
return EINVAL;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10c48f: 8d 55 f4 lea -0xc(%ebp),%edx
10c492: 52 push %edx
10c493: ff 30 pushl (%eax)
10c495: 68 80 b9 12 00 push $0x12b980
10c49a: e8 d9 2b 00 00 call 10f078 <_Objects_Get>
10c49f: 89 c3 mov %eax,%ebx
switch ( location ) {
10c4a1: 83 c4 10 add $0x10,%esp
10c4a4: 8b 4d f4 mov -0xc(%ebp),%ecx
10c4a7: 85 c9 test %ecx,%ecx
10c4a9: 75 25 jne 10c4d0 <pthread_rwlock_destroy+0x50>
case OBJECTS_LOCAL:
/*
* If there is at least one thread waiting, then do not delete it.
*/
if ( _Thread_queue_First( &the_rwlock->RWLock.Wait_queue ) != NULL ) {
10c4ab: 83 ec 0c sub $0xc,%esp
10c4ae: 8d 40 10 lea 0x10(%eax),%eax
10c4b1: 50 push %eax
10c4b2: e8 05 3f 00 00 call 1103bc <_Thread_queue_First>
10c4b7: 83 c4 10 add $0x10,%esp
10c4ba: 85 c0 test %eax,%eax
10c4bc: 74 1e je 10c4dc <pthread_rwlock_destroy+0x5c>
_Thread_Enable_dispatch();
10c4be: e8 2d 37 00 00 call 10fbf0 <_Thread_Enable_dispatch>
return EBUSY;
10c4c3: b8 10 00 00 00 mov $0x10,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c4c8: 8b 5d fc mov -0x4(%ebp),%ebx
10c4cb: c9 leave
10c4cc: c3 ret
10c4cd: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
10c4d0: b8 16 00 00 00 mov $0x16,%eax
}
10c4d5: 8b 5d fc mov -0x4(%ebp),%ebx
10c4d8: c9 leave
10c4d9: c3 ret
10c4da: 66 90 xchg %ax,%ax
/*
* POSIX doesn't require behavior when it is locked.
*/
_Objects_Close( &_POSIX_RWLock_Information, &the_rwlock->Object );
10c4dc: 83 ec 08 sub $0x8,%esp
10c4df: 53 push %ebx
10c4e0: 68 80 b9 12 00 push $0x12b980
10c4e5: e8 56 27 00 00 call 10ec40 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _POSIX_RWLock_Free (
POSIX_RWLock_Control *the_RWLock
)
{
_Objects_Free( &_POSIX_RWLock_Information, &the_RWLock->Object );
10c4ea: 58 pop %eax
10c4eb: 5a pop %edx
10c4ec: 53 push %ebx
10c4ed: 68 80 b9 12 00 push $0x12b980
10c4f2: e8 41 2a 00 00 call 10ef38 <_Objects_Free>
_POSIX_RWLock_Free( the_rwlock );
_Thread_Enable_dispatch();
10c4f7: e8 f4 36 00 00 call 10fbf0 <_Thread_Enable_dispatch>
return 0;
10c4fc: 83 c4 10 add $0x10,%esp
10c4ff: 31 c0 xor %eax,%eax
10c501: eb d2 jmp 10c4d5 <pthread_rwlock_destroy+0x55>
0010c504 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
10c504: 55 push %ebp
10c505: 89 e5 mov %esp,%ebp
10c507: 56 push %esi
10c508: 53 push %ebx
10c509: 83 ec 20 sub $0x20,%esp
10c50c: 8b 5d 08 mov 0x8(%ebp),%ebx
10c50f: 8b 75 0c mov 0xc(%ebp),%esi
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
10c512: 85 db test %ebx,%ebx
10c514: 74 15 je 10c52b <pthread_rwlock_init+0x27>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10c516: 85 f6 test %esi,%esi
10c518: 0f 84 8e 00 00 00 je 10c5ac <pthread_rwlock_init+0xa8>
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
10c51e: 8b 16 mov (%esi),%edx
10c520: 85 d2 test %edx,%edx
10c522: 74 07 je 10c52b <pthread_rwlock_init+0x27><== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
10c524: 8b 46 04 mov 0x4(%esi),%eax
10c527: 85 c0 test %eax,%eax
10c529: 74 0d je 10c538 <pthread_rwlock_init+0x34><== ALWAYS TAKEN
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
10c52b: b8 16 00 00 00 mov $0x16,%eax
*rwlock = the_rwlock->Object.id;
_Thread_Enable_dispatch();
return 0;
}
10c530: 8d 65 f8 lea -0x8(%ebp),%esp
10c533: 5b pop %ebx
10c534: 5e pop %esi
10c535: c9 leave
10c536: c3 ret
10c537: 90 nop
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
10c538: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10c53f: a1 30 b7 12 00 mov 0x12b730,%eax
10c544: 40 inc %eax
10c545: a3 30 b7 12 00 mov %eax,0x12b730
* the inactive chain of free RWLock control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void )
{
return (POSIX_RWLock_Control *)
_Objects_Allocate( &_POSIX_RWLock_Information );
10c54a: 83 ec 0c sub $0xc,%esp
10c54d: 68 80 b9 12 00 push $0x12b980
10c552: e8 6d 26 00 00 call 10ebc4 <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
10c557: 83 c4 10 add $0x10,%esp
10c55a: 85 c0 test %eax,%eax
10c55c: 74 42 je 10c5a0 <pthread_rwlock_init+0x9c>
_Thread_Enable_dispatch();
return EAGAIN;
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
10c55e: 83 ec 08 sub $0x8,%esp
10c561: 8d 55 f4 lea -0xc(%ebp),%edx
10c564: 52 push %edx
10c565: 8d 50 10 lea 0x10(%eax),%edx
10c568: 52 push %edx
10c569: 89 45 e4 mov %eax,-0x1c(%ebp)
10c56c: e8 3b 1e 00 00 call 10e3ac <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10c571: 8b 45 e4 mov -0x1c(%ebp),%eax
10c574: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10c577: 0f b7 f2 movzwl %dx,%esi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c57a: 8b 0d 9c b9 12 00 mov 0x12b99c,%ecx
10c580: 89 04 b1 mov %eax,(%ecx,%esi,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10c583: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
10c58a: 89 13 mov %edx,(%ebx)
_Thread_Enable_dispatch();
10c58c: e8 5f 36 00 00 call 10fbf0 <_Thread_Enable_dispatch>
return 0;
10c591: 83 c4 10 add $0x10,%esp
10c594: 31 c0 xor %eax,%eax
}
10c596: 8d 65 f8 lea -0x8(%ebp),%esp
10c599: 5b pop %ebx
10c59a: 5e pop %esi
10c59b: c9 leave
10c59c: c3 ret
10c59d: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
_Thread_Enable_dispatch();
10c5a0: e8 4b 36 00 00 call 10fbf0 <_Thread_Enable_dispatch>
return EAGAIN;
10c5a5: b8 0b 00 00 00 mov $0xb,%eax
10c5aa: eb 84 jmp 10c530 <pthread_rwlock_init+0x2c>
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
10c5ac: 83 ec 0c sub $0xc,%esp
10c5af: 8d 75 ec lea -0x14(%ebp),%esi
10c5b2: 56 push %esi
10c5b3: e8 84 09 00 00 call 10cf3c <pthread_rwlockattr_init>
10c5b8: 83 c4 10 add $0x10,%esp
10c5bb: e9 5e ff ff ff jmp 10c51e <pthread_rwlock_init+0x1a>
0010c628 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10c628: 55 push %ebp
10c629: 89 e5 mov %esp,%ebp
10c62b: 56 push %esi
10c62c: 53 push %ebx
10c62d: 83 ec 20 sub $0x20,%esp
10c630: 8b 5d 08 mov 0x8(%ebp),%ebx
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
10c633: 85 db test %ebx,%ebx
10c635: 74 7d je 10c6b4 <pthread_rwlock_timedrdlock+0x8c>
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
10c637: 83 ec 08 sub $0x8,%esp
10c63a: 8d 45 f0 lea -0x10(%ebp),%eax
10c63d: 50 push %eax
10c63e: ff 75 0c pushl 0xc(%ebp)
10c641: e8 de 62 00 00 call 112924 <_POSIX_Absolute_timeout_to_ticks>
10c646: 89 c6 mov %eax,%esi
10c648: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10c64b: 8d 45 f4 lea -0xc(%ebp),%eax
10c64e: 50 push %eax
10c64f: ff 33 pushl (%ebx)
10c651: 68 80 b9 12 00 push $0x12b980
10c656: e8 1d 2a 00 00 call 10f078 <_Objects_Get>
switch ( location ) {
10c65b: 83 c4 10 add $0x10,%esp
10c65e: 8b 55 f4 mov -0xc(%ebp),%edx
10c661: 85 d2 test %edx,%edx
10c663: 75 4f jne 10c6b4 <pthread_rwlock_timedrdlock+0x8c>
int _EXFUN(pthread_rwlock_init,
(pthread_rwlock_t *__rwlock, _CONST pthread_rwlockattr_t *__attr));
int _EXFUN(pthread_rwlock_destroy, (pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_rdlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_tryrdlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedrdlock,
10c665: 83 fe 03 cmp $0x3,%esi
10c668: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
10c66b: 83 ec 0c sub $0xc,%esp
10c66e: 6a 00 push $0x0
10c670: ff 75 f0 pushl -0x10(%ebp)
10c673: 0f b6 ca movzbl %dl,%ecx
10c676: 51 push %ecx
10c677: ff 33 pushl (%ebx)
10c679: 83 c0 10 add $0x10,%eax
10c67c: 50 push %eax
10c67d: 88 55 e4 mov %dl,-0x1c(%ebp)
10c680: e8 5b 1d 00 00 call 10e3e0 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10c685: 83 c4 20 add $0x20,%esp
10c688: e8 63 35 00 00 call 10fbf0 <_Thread_Enable_dispatch>
if ( !do_wait ) {
10c68d: 8a 55 e4 mov -0x1c(%ebp),%dl
10c690: 84 d2 test %dl,%dl
10c692: 75 40 jne 10c6d4 <pthread_rwlock_timedrdlock+0xac>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
10c694: a1 d8 bc 12 00 mov 0x12bcd8,%eax
10c699: 8b 40 34 mov 0x34(%eax),%eax
10c69c: 83 f8 02 cmp $0x2,%eax
10c69f: 74 1f je 10c6c0 <pthread_rwlock_timedrdlock+0x98>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10c6a1: 83 ec 0c sub $0xc,%esp
10c6a4: 50 push %eax
10c6a5: e8 ee 00 00 00 call 10c798 <_POSIX_RWLock_Translate_core_RWLock_return_code>
10c6aa: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c6ad: 8d 65 f8 lea -0x8(%ebp),%esp
10c6b0: 5b pop %ebx
10c6b1: 5e pop %esi
10c6b2: c9 leave
10c6b3: c3 ret
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
10c6b4: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c6b9: 8d 65 f8 lea -0x8(%ebp),%esp
10c6bc: 5b pop %ebx
10c6bd: 5e pop %esi
10c6be: c9 leave
10c6bf: c3 ret
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10c6c0: 85 f6 test %esi,%esi
10c6c2: 74 f0 je 10c6b4 <pthread_rwlock_timedrdlock+0x8c><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10c6c4: 4e dec %esi
10c6c5: 83 fe 01 cmp $0x1,%esi
10c6c8: 77 d7 ja 10c6a1 <pthread_rwlock_timedrdlock+0x79><== NEVER TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10c6ca: b8 74 00 00 00 mov $0x74,%eax
10c6cf: eb e8 jmp 10c6b9 <pthread_rwlock_timedrdlock+0x91>
10c6d1: 8d 76 00 lea 0x0(%esi),%esi
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait ) {
10c6d4: a1 d8 bc 12 00 mov 0x12bcd8,%eax
10c6d9: 8b 40 34 mov 0x34(%eax),%eax
10c6dc: eb c3 jmp 10c6a1 <pthread_rwlock_timedrdlock+0x79>
0010c6e0 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10c6e0: 55 push %ebp
10c6e1: 89 e5 mov %esp,%ebp
10c6e3: 56 push %esi
10c6e4: 53 push %ebx
10c6e5: 83 ec 20 sub $0x20,%esp
10c6e8: 8b 5d 08 mov 0x8(%ebp),%ebx
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
10c6eb: 85 db test %ebx,%ebx
10c6ed: 74 7d je 10c76c <pthread_rwlock_timedwrlock+0x8c>
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
10c6ef: 83 ec 08 sub $0x8,%esp
10c6f2: 8d 45 f0 lea -0x10(%ebp),%eax
10c6f5: 50 push %eax
10c6f6: ff 75 0c pushl 0xc(%ebp)
10c6f9: e8 26 62 00 00 call 112924 <_POSIX_Absolute_timeout_to_ticks>
10c6fe: 89 c6 mov %eax,%esi
10c700: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10c703: 8d 45 f4 lea -0xc(%ebp),%eax
10c706: 50 push %eax
10c707: ff 33 pushl (%ebx)
10c709: 68 80 b9 12 00 push $0x12b980
10c70e: e8 65 29 00 00 call 10f078 <_Objects_Get>
switch ( location ) {
10c713: 83 c4 10 add $0x10,%esp
10c716: 8b 55 f4 mov -0xc(%ebp),%edx
10c719: 85 d2 test %edx,%edx
10c71b: 75 4f jne 10c76c <pthread_rwlock_timedwrlock+0x8c>
(pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime));
int _EXFUN(pthread_rwlock_unlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_wrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_trywrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedwrlock,
10c71d: 83 fe 03 cmp $0x3,%esi
10c720: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
10c723: 83 ec 0c sub $0xc,%esp
10c726: 6a 00 push $0x0
10c728: ff 75 f0 pushl -0x10(%ebp)
10c72b: 0f b6 ca movzbl %dl,%ecx
10c72e: 51 push %ecx
10c72f: ff 33 pushl (%ebx)
10c731: 83 c0 10 add $0x10,%eax
10c734: 50 push %eax
10c735: 88 55 e4 mov %dl,-0x1c(%ebp)
10c738: e8 6b 1d 00 00 call 10e4a8 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10c73d: 83 c4 20 add $0x20,%esp
10c740: e8 ab 34 00 00 call 10fbf0 <_Thread_Enable_dispatch>
if ( !do_wait &&
10c745: 8a 55 e4 mov -0x1c(%ebp),%dl
10c748: 84 d2 test %dl,%dl
10c74a: 75 40 jne 10c78c <pthread_rwlock_timedwrlock+0xac>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
10c74c: a1 d8 bc 12 00 mov 0x12bcd8,%eax
10c751: 8b 40 34 mov 0x34(%eax),%eax
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
10c754: 83 f8 02 cmp $0x2,%eax
10c757: 74 1f je 10c778 <pthread_rwlock_timedwrlock+0x98>
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10c759: 83 ec 0c sub $0xc,%esp
10c75c: 50 push %eax
10c75d: e8 36 00 00 00 call 10c798 <_POSIX_RWLock_Translate_core_RWLock_return_code>
10c762: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c765: 8d 65 f8 lea -0x8(%ebp),%esp
10c768: 5b pop %ebx
10c769: 5e pop %esi
10c76a: c9 leave
10c76b: c3 ret
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
10c76c: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10c771: 8d 65 f8 lea -0x8(%ebp),%esp
10c774: 5b pop %ebx
10c775: 5e pop %esi
10c776: c9 leave
10c777: c3 ret
);
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10c778: 85 f6 test %esi,%esi
10c77a: 74 f0 je 10c76c <pthread_rwlock_timedwrlock+0x8c><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10c77c: 4e dec %esi
10c77d: 83 fe 01 cmp $0x1,%esi
10c780: 77 d7 ja 10c759 <pthread_rwlock_timedwrlock+0x79><== NEVER TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10c782: b8 74 00 00 00 mov $0x74,%eax
10c787: eb e8 jmp 10c771 <pthread_rwlock_timedwrlock+0x91>
10c789: 8d 76 00 lea 0x0(%esi),%esi
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
10c78c: a1 d8 bc 12 00 mov 0x12bcd8,%eax
10c791: 8b 40 34 mov 0x34(%eax),%eax
10c794: eb c3 jmp 10c759 <pthread_rwlock_timedwrlock+0x79>
0010cef4 <pthread_rwlockattr_destroy>:
*/
int pthread_rwlockattr_destroy(
pthread_rwlockattr_t *attr
)
{
10cef4: 55 push %ebp
10cef5: 89 e5 mov %esp,%ebp
10cef7: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || attr->is_initialized == false )
10cefa: 85 c0 test %eax,%eax
10cefc: 74 12 je 10cf10 <pthread_rwlockattr_destroy+0x1c>
10cefe: 8b 10 mov (%eax),%edx
10cf00: 85 d2 test %edx,%edx
10cf02: 74 0c je 10cf10 <pthread_rwlockattr_destroy+0x1c>
return EINVAL;
attr->is_initialized = false;
10cf04: c7 00 00 00 00 00 movl $0x0,(%eax)
return 0;
10cf0a: 31 c0 xor %eax,%eax
}
10cf0c: c9 leave
10cf0d: c3 ret
10cf0e: 66 90 xchg %ax,%ax
int pthread_rwlockattr_destroy(
pthread_rwlockattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
return EINVAL;
10cf10: b8 16 00 00 00 mov $0x16,%eax
attr->is_initialized = false;
return 0;
}
10cf15: c9 leave
10cf16: c3 ret
0010cf60 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
10cf60: 55 push %ebp
10cf61: 89 e5 mov %esp,%ebp
10cf63: 8b 45 08 mov 0x8(%ebp),%eax
10cf66: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr )
10cf69: 85 c0 test %eax,%eax
10cf6b: 74 0b je 10cf78 <pthread_rwlockattr_setpshared+0x18>
return EINVAL;
if ( !attr->is_initialized )
10cf6d: 8b 08 mov (%eax),%ecx
10cf6f: 85 c9 test %ecx,%ecx
10cf71: 74 05 je 10cf78 <pthread_rwlockattr_setpshared+0x18>
return EINVAL;
switch ( pshared ) {
10cf73: 83 fa 01 cmp $0x1,%edx
10cf76: 76 08 jbe 10cf80 <pthread_rwlockattr_setpshared+0x20><== ALWAYS TAKEN
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
return 0;
default:
return EINVAL;
10cf78: b8 16 00 00 00 mov $0x16,%eax
}
}
10cf7d: c9 leave
10cf7e: c3 ret
10cf7f: 90 nop
return EINVAL;
switch ( pshared ) {
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10cf80: 89 50 04 mov %edx,0x4(%eax)
return 0;
10cf83: 31 c0 xor %eax,%eax
default:
return EINVAL;
}
}
10cf85: c9 leave
10cf86: c3 ret
0010b214 <pthread_setcancelstate>:
int pthread_setcancelstate(
int state,
int *oldstate
)
{
10b214: 55 push %ebp
10b215: 89 e5 mov %esp,%ebp
10b217: 53 push %ebx
10b218: 83 ec 04 sub $0x4,%esp
10b21b: 8b 55 08 mov 0x8(%ebp),%edx
10b21e: 8b 45 0c mov 0xc(%ebp),%eax
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
10b221: 8b 0d 54 96 12 00 mov 0x129654,%ecx
10b227: 85 c9 test %ecx,%ecx
10b229: 75 15 jne 10b240 <pthread_setcancelstate+0x2c>
return EPROTO;
if ( !oldstate )
10b22b: 85 c0 test %eax,%eax
10b22d: 74 05 je 10b234 <pthread_setcancelstate+0x20>
return EINVAL;
if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE )
10b22f: 83 fa 01 cmp $0x1,%edx
10b232: 76 18 jbe 10b24c <pthread_setcancelstate+0x38>
return EINVAL;
10b234: b8 16 00 00 00 mov $0x16,%eax
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
10b239: 8b 5d fc mov -0x4(%ebp),%ebx
10b23c: c9 leave
10b23d: c3 ret
10b23e: 66 90 xchg %ax,%ax
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
10b240: b8 47 00 00 00 mov $0x47,%eax
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
10b245: 8b 5d fc mov -0x4(%ebp),%ebx
10b248: c9 leave
10b249: c3 ret
10b24a: 66 90 xchg %ax,%ax
return EINVAL;
if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE )
return EINVAL;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10b24c: 8b 0d 58 96 12 00 mov 0x129658,%ecx
10b252: 8b 89 ec 00 00 00 mov 0xec(%ecx),%ecx
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b258: 8b 1d b0 90 12 00 mov 0x1290b0,%ebx
10b25e: 43 inc %ebx
10b25f: 89 1d b0 90 12 00 mov %ebx,0x1290b0
_Thread_Disable_dispatch();
*oldstate = thread_support->cancelability_state;
10b265: 8b 99 d8 00 00 00 mov 0xd8(%ecx),%ebx
10b26b: 89 18 mov %ebx,(%eax)
thread_support->cancelability_state = state;
10b26d: 89 91 d8 00 00 00 mov %edx,0xd8(%ecx)
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing);
10b273: 83 ec 0c sub $0xc,%esp
10b276: ff 35 58 96 12 00 pushl 0x129658
10b27c: e8 7b 54 00 00 call 1106fc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
10b281: 83 c4 10 add $0x10,%esp
10b284: 31 c0 xor %eax,%eax
}
10b286: 8b 5d fc mov -0x4(%ebp),%ebx
10b289: c9 leave
10b28a: c3 ret
0010b28c <pthread_setcanceltype>:
int pthread_setcanceltype(
int type,
int *oldtype
)
{
10b28c: 55 push %ebp
10b28d: 89 e5 mov %esp,%ebp
10b28f: 53 push %ebx
10b290: 83 ec 04 sub $0x4,%esp
10b293: 8b 55 08 mov 0x8(%ebp),%edx
10b296: 8b 45 0c mov 0xc(%ebp),%eax
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
10b299: 8b 0d 54 96 12 00 mov 0x129654,%ecx
10b29f: 85 c9 test %ecx,%ecx
10b2a1: 75 15 jne 10b2b8 <pthread_setcanceltype+0x2c>
return EPROTO;
if ( !oldtype )
10b2a3: 85 c0 test %eax,%eax
10b2a5: 74 05 je 10b2ac <pthread_setcanceltype+0x20>
return EINVAL;
if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS )
10b2a7: 83 fa 01 cmp $0x1,%edx
10b2aa: 76 18 jbe 10b2c4 <pthread_setcanceltype+0x38>
return EINVAL;
10b2ac: b8 16 00 00 00 mov $0x16,%eax
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
10b2b1: 8b 5d fc mov -0x4(%ebp),%ebx
10b2b4: c9 leave
10b2b5: c3 ret
10b2b6: 66 90 xchg %ax,%ax
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
return EPROTO;
10b2b8: b8 47 00 00 00 mov $0x47,%eax
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
}
10b2bd: 8b 5d fc mov -0x4(%ebp),%ebx
10b2c0: c9 leave
10b2c1: c3 ret
10b2c2: 66 90 xchg %ax,%ax
return EINVAL;
if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS )
return EINVAL;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10b2c4: 8b 0d 58 96 12 00 mov 0x129658,%ecx
10b2ca: 8b 89 ec 00 00 00 mov 0xec(%ecx),%ecx
10b2d0: 8b 1d b0 90 12 00 mov 0x1290b0,%ebx
10b2d6: 43 inc %ebx
10b2d7: 89 1d b0 90 12 00 mov %ebx,0x1290b0
_Thread_Disable_dispatch();
*oldtype = thread_support->cancelability_type;
10b2dd: 8b 99 dc 00 00 00 mov 0xdc(%ecx),%ebx
10b2e3: 89 18 mov %ebx,(%eax)
thread_support->cancelability_type = type;
10b2e5: 89 91 dc 00 00 00 mov %edx,0xdc(%ecx)
_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(_Thread_Executing);
10b2eb: 83 ec 0c sub $0xc,%esp
10b2ee: ff 35 58 96 12 00 pushl 0x129658
10b2f4: e8 03 54 00 00 call 1106fc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>
/*
* _Thread_Enable_dispatch is invoked by above call.
*/
return 0;
10b2f9: 83 c4 10 add $0x10,%esp
10b2fc: 31 c0 xor %eax,%eax
}
10b2fe: 8b 5d fc mov -0x4(%ebp),%ebx
10b301: c9 leave
10b302: c3 ret
0010dd14 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
10dd14: 55 push %ebp
10dd15: 89 e5 mov %esp,%ebp
10dd17: 57 push %edi
10dd18: 56 push %esi
10dd19: 53 push %ebx
10dd1a: 83 ec 2c sub $0x2c,%esp
10dd1d: 8b 75 10 mov 0x10(%ebp),%esi
int rc;
/*
* Check all the parameters
*/
if ( !param )
10dd20: 85 f6 test %esi,%esi
10dd22: 0f 84 cc 00 00 00 je 10ddf4 <pthread_setschedparam+0xe0>
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
10dd28: 8d 45 e0 lea -0x20(%ebp),%eax
10dd2b: 50 push %eax
10dd2c: 8d 45 e4 lea -0x1c(%ebp),%eax
10dd2f: 50 push %eax
10dd30: 56 push %esi
10dd31: ff 75 0c pushl 0xc(%ebp)
10dd34: e8 17 5c 00 00 call 113950 <_POSIX_Thread_Translate_sched_param>
10dd39: 89 c3 mov %eax,%ebx
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
10dd3b: 83 c4 10 add $0x10,%esp
10dd3e: 85 c0 test %eax,%eax
10dd40: 74 0a je 10dd4c <pthread_setschedparam+0x38>
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
10dd42: 89 d8 mov %ebx,%eax
10dd44: 8d 65 f4 lea -0xc(%ebp),%esp
10dd47: 5b pop %ebx
10dd48: 5e pop %esi
10dd49: 5f pop %edi
10dd4a: c9 leave
10dd4b: c3 ret
10dd4c: 50 push %eax
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _POSIX_Threads_Get( thread, &location );
10dd4d: 8d 45 dc lea -0x24(%ebp),%eax
10dd50: 50 push %eax
10dd51: ff 75 08 pushl 0x8(%ebp)
10dd54: 68 80 cf 12 00 push $0x12cf80
10dd59: e8 9a 1f 00 00 call 10fcf8 <_Objects_Get>
10dd5e: 89 c2 mov %eax,%edx
switch ( location ) {
10dd60: 83 c4 10 add $0x10,%esp
10dd63: 8b 7d dc mov -0x24(%ebp),%edi
10dd66: 85 ff test %edi,%edi
10dd68: 0f 85 96 00 00 00 jne 10de04 <pthread_setschedparam+0xf0>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10dd6e: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
10dd74: 89 45 d4 mov %eax,-0x2c(%ebp)
if ( api->schedpolicy == SCHED_SPORADIC )
10dd77: 83 b8 84 00 00 00 04 cmpl $0x4,0x84(%eax)
10dd7e: 0f 84 cc 00 00 00 je 10de50 <pthread_setschedparam+0x13c>
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
10dd84: 8b 45 0c mov 0xc(%ebp),%eax
10dd87: 8b 4d d4 mov -0x2c(%ebp),%ecx
10dd8a: 89 81 84 00 00 00 mov %eax,0x84(%ecx)
api->schedparam = *param;
10dd90: 89 cf mov %ecx,%edi
10dd92: 81 c7 88 00 00 00 add $0x88,%edi
10dd98: b9 07 00 00 00 mov $0x7,%ecx
10dd9d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_thread->budget_algorithm = budget_algorithm;
10dd9f: 8b 45 e4 mov -0x1c(%ebp),%eax
10dda2: 89 42 7c mov %eax,0x7c(%edx)
the_thread->budget_callout = budget_callout;
10dda5: 8b 45 e0 mov -0x20(%ebp),%eax
10dda8: 89 82 80 00 00 00 mov %eax,0x80(%edx)
switch ( api->schedpolicy ) {
10ddae: 8b 75 0c mov 0xc(%ebp),%esi
10ddb1: 85 f6 test %esi,%esi
10ddb3: 78 2e js 10dde3 <pthread_setschedparam+0xcf><== NEVER TAKEN
10ddb5: 83 7d 0c 02 cmpl $0x2,0xc(%ebp)
10ddb9: 7f 59 jg 10de14 <pthread_setschedparam+0x100>
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
10ddbb: a1 c0 cc 12 00 mov 0x12ccc0,%eax
10ddc0: 89 42 78 mov %eax,0x78(%edx)
10ddc3: 0f b6 05 9c 89 12 00 movzbl 0x12899c,%eax
10ddca: 8b 4d d4 mov -0x2c(%ebp),%ecx
10ddcd: 2b 81 88 00 00 00 sub 0x88(%ecx),%eax
the_thread->real_priority =
10ddd3: 89 42 18 mov %eax,0x18(%edx)
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
10ddd6: 51 push %ecx
10ddd7: 6a 01 push $0x1
10ddd9: 50 push %eax
10ddda: 52 push %edx
10dddb: e8 58 26 00 00 call 110438 <_Thread_Change_priority>
the_thread,
the_thread->real_priority,
true
);
break;
10dde0: 83 c4 10 add $0x10,%esp
_Watchdog_Remove( &api->Sporadic_timer );
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
break;
}
_Thread_Enable_dispatch();
10dde3: e8 88 2a 00 00 call 110870 <_Thread_Enable_dispatch>
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
10dde8: 89 d8 mov %ebx,%eax
10ddea: 8d 65 f4 lea -0xc(%ebp),%esp
10dded: 5b pop %ebx
10ddee: 5e pop %esi
10ddef: 5f pop %edi
10ddf0: c9 leave
10ddf1: c3 ret
10ddf2: 66 90 xchg %ax,%ax
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
10ddf4: bb 16 00 00 00 mov $0x16,%ebx
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
10ddf9: 89 d8 mov %ebx,%eax
10ddfb: 8d 65 f4 lea -0xc(%ebp),%esp
10ddfe: 5b pop %ebx
10ddff: 5e pop %esi
10de00: 5f pop %edi
10de01: c9 leave
10de02: c3 ret
10de03: 90 nop
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
10de04: bb 03 00 00 00 mov $0x3,%ebx
}
10de09: 89 d8 mov %ebx,%eax
10de0b: 8d 65 f4 lea -0xc(%ebp),%esp
10de0e: 5b pop %ebx
10de0f: 5e pop %esi
10de10: 5f pop %edi
10de11: c9 leave
10de12: c3 ret
10de13: 90 nop
api->schedpolicy = policy;
api->schedparam = *param;
the_thread->budget_algorithm = budget_algorithm;
the_thread->budget_callout = budget_callout;
switch ( api->schedpolicy ) {
10de14: 83 7d 0c 04 cmpl $0x4,0xc(%ebp)
10de18: 75 c9 jne 10dde3 <pthread_setschedparam+0xcf><== NEVER TAKEN
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
10de1a: 8b 4d d4 mov -0x2c(%ebp),%ecx
10de1d: 8b 81 88 00 00 00 mov 0x88(%ecx),%eax
10de23: 89 81 a4 00 00 00 mov %eax,0xa4(%ecx)
_Watchdog_Remove( &api->Sporadic_timer );
10de29: 83 ec 0c sub $0xc,%esp
10de2c: 89 c8 mov %ecx,%eax
10de2e: 05 a8 00 00 00 add $0xa8,%eax
10de33: 50 push %eax
10de34: 89 55 d0 mov %edx,-0x30(%ebp)
10de37: e8 38 3a 00 00 call 111874 <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
10de3c: 58 pop %eax
10de3d: 5a pop %edx
10de3e: 8b 55 d0 mov -0x30(%ebp),%edx
10de41: 52 push %edx
10de42: 6a 00 push $0x0
10de44: e8 af fd ff ff call 10dbf8 <_POSIX_Threads_Sporadic_budget_TSR>
break;
10de49: 83 c4 10 add $0x10,%esp
10de4c: eb 95 jmp 10dde3 <pthread_setschedparam+0xcf>
10de4e: 66 90 xchg %ax,%ax
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
10de50: 83 ec 0c sub $0xc,%esp
10de53: 05 a8 00 00 00 add $0xa8,%eax
10de58: 50 push %eax
10de59: 89 55 d0 mov %edx,-0x30(%ebp)
10de5c: e8 13 3a 00 00 call 111874 <_Watchdog_Remove>
10de61: 83 c4 10 add $0x10,%esp
10de64: 8b 55 d0 mov -0x30(%ebp),%edx
10de67: e9 18 ff ff ff jmp 10dd84 <pthread_setschedparam+0x70>
00111d14 <pthread_sigmask>:
int pthread_sigmask(
int how,
const sigset_t *set,
sigset_t *oset
)
{
111d14: 55 push %ebp
111d15: 89 e5 mov %esp,%ebp
111d17: 56 push %esi
111d18: 53 push %ebx
111d19: 8b 4d 08 mov 0x8(%ebp),%ecx
111d1c: 8b 55 0c mov 0xc(%ebp),%edx
111d1f: 8b 5d 10 mov 0x10(%ebp),%ebx
POSIX_API_Control *api;
if ( !set && !oset )
111d22: 85 d2 test %edx,%edx
111d24: 0f 84 8a 00 00 00 je 111db4 <pthread_sigmask+0xa0>
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
111d2a: a1 58 a3 12 00 mov 0x12a358,%eax
111d2f: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
if ( oset )
111d35: 85 db test %ebx,%ebx
111d37: 74 0c je 111d45 <pthread_sigmask+0x31>
*oset = api->signals_blocked;
111d39: 8b b0 d0 00 00 00 mov 0xd0(%eax),%esi
111d3f: 89 33 mov %esi,(%ebx)
if ( !set )
111d41: 85 d2 test %edx,%edx
111d43: 74 3b je 111d80 <pthread_sigmask+0x6c>
return 0;
switch ( how ) {
111d45: 83 f9 01 cmp $0x1,%ecx
111d48: 74 5e je 111da8 <pthread_sigmask+0x94>
111d4a: 83 f9 02 cmp $0x2,%ecx
111d4d: 74 39 je 111d88 <pthread_sigmask+0x74>
111d4f: 85 c9 test %ecx,%ecx
111d51: 75 41 jne 111d94 <pthread_sigmask+0x80>
break;
case SIG_UNBLOCK:
api->signals_blocked &= ~*set;
break;
case SIG_SETMASK:
api->signals_blocked = *set;
111d53: 8b 12 mov (%edx),%edx
111d55: 89 90 d0 00 00 00 mov %edx,0xd0(%eax)
/* XXX are there critical section problems here? */
/* XXX evaluate the new set */
if ( ~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending) ) {
111d5b: 8b 15 c8 a5 12 00 mov 0x12a5c8,%edx
111d61: 0b 90 d4 00 00 00 or 0xd4(%eax),%edx
/* XXX are there critical section problems here? */
/* XXX evaluate the new set */
if ( ~api->signals_blocked &
111d67: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
111d6d: f7 d0 not %eax
111d6f: 85 c2 test %eax,%edx
111d71: 74 0d je 111d80 <pthread_sigmask+0x6c>
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
111d73: e8 b0 c9 ff ff call 10e728 <_Thread_Dispatch>
}
return 0;
111d78: 31 c0 xor %eax,%eax
}
111d7a: 5b pop %ebx
111d7b: 5e pop %esi
111d7c: c9 leave
111d7d: c3 ret
111d7e: 66 90 xchg %ax,%ax
if ( ~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
}
return 0;
111d80: 31 c0 xor %eax,%eax
}
111d82: 5b pop %ebx
111d83: 5e pop %esi
111d84: c9 leave
111d85: c3 ret
111d86: 66 90 xchg %ax,%ax
switch ( how ) {
case SIG_BLOCK:
api->signals_blocked |= *set;
break;
case SIG_UNBLOCK:
api->signals_blocked &= ~*set;
111d88: 8b 12 mov (%edx),%edx
111d8a: f7 d2 not %edx
111d8c: 21 90 d0 00 00 00 and %edx,0xd0(%eax)
break;
111d92: eb c7 jmp 111d5b <pthread_sigmask+0x47>
case SIG_SETMASK:
api->signals_blocked = *set;
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
111d94: e8 d3 24 00 00 call 11426c <__errno>
111d99: c7 00 16 00 00 00 movl $0x16,(%eax)
111d9f: b8 ff ff ff ff mov $0xffffffff,%eax
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
}
return 0;
}
111da4: 5b pop %ebx
111da5: 5e pop %esi
111da6: c9 leave
111da7: c3 ret
if ( !set )
return 0;
switch ( how ) {
case SIG_BLOCK:
api->signals_blocked |= *set;
111da8: 8b 12 mov (%edx),%edx
111daa: 09 90 d0 00 00 00 or %edx,0xd0(%eax)
break;
111db0: eb a9 jmp 111d5b <pthread_sigmask+0x47>
111db2: 66 90 xchg %ax,%ax
sigset_t *oset
)
{
POSIX_API_Control *api;
if ( !set && !oset )
111db4: 85 db test %ebx,%ebx
111db6: 74 dc je 111d94 <pthread_sigmask+0x80>
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
111db8: a1 58 a3 12 00 mov 0x12a358,%eax
111dbd: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
111dc3: e9 71 ff ff ff jmp 111d39 <pthread_sigmask+0x25>
0010bb84 <pthread_testcancel>:
*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
10bb84: 55 push %ebp
10bb85: 89 e5 mov %esp,%ebp
10bb87: 83 ec 08 sub $0x8,%esp
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
10bb8a: 8b 0d d4 9d 12 00 mov 0x129dd4,%ecx
10bb90: 85 c9 test %ecx,%ecx
10bb92: 75 44 jne 10bbd8 <pthread_testcancel+0x54><== NEVER TAKEN
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10bb94: a1 d8 9d 12 00 mov 0x129dd8,%eax
10bb99: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
10bb9f: 8b 15 30 98 12 00 mov 0x129830,%edx
10bba5: 42 inc %edx
10bba6: 89 15 30 98 12 00 mov %edx,0x129830
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
10bbac: 8b 90 d8 00 00 00 mov 0xd8(%eax),%edx
10bbb2: 85 d2 test %edx,%edx
10bbb4: 75 26 jne 10bbdc <pthread_testcancel+0x58><== NEVER TAKEN
10bbb6: 8b 80 e0 00 00 00 mov 0xe0(%eax),%eax
10bbbc: 85 c0 test %eax,%eax
10bbbe: 74 1c je 10bbdc <pthread_testcancel+0x58>
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
10bbc0: e8 7f 29 00 00 call 10e544 <_Thread_Enable_dispatch>
if ( cancel )
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
10bbc5: 83 ec 08 sub $0x8,%esp
10bbc8: 6a ff push $0xffffffff
10bbca: ff 35 d8 9d 12 00 pushl 0x129dd8
10bbd0: e8 73 5b 00 00 call 111748 <_POSIX_Thread_Exit>
10bbd5: 83 c4 10 add $0x10,%esp
}
10bbd8: c9 leave
10bbd9: c3 ret
10bbda: 66 90 xchg %ax,%ax
10bbdc: c9 leave
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
10bbdd: e9 62 29 00 00 jmp 10e544 <_Thread_Enable_dispatch>
0011f20c <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
11f20c: 55 push %ebp
11f20d: 89 e5 mov %esp,%ebp
11f20f: 53 push %ebx
11f210: 83 ec 04 sub $0x4,%esp
11f213: 8b 4d 08 mov 0x8(%ebp),%ecx
11f216: 8b 45 0c mov 0xc(%ebp),%eax
11f219: 8b 55 10 mov 0x10(%ebp),%edx
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
11f21c: 3b 0d 6c 39 12 00 cmp 0x12396c,%ecx
11f222: 73 50 jae 11f274 <read+0x68> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
11f224: c1 e1 03 shl $0x3,%ecx
11f227: 8d 1c cd 00 00 00 00 lea 0x0(,%ecx,8),%ebx
11f22e: 29 cb sub %ecx,%ebx
11f230: 03 1d 20 7c 12 00 add 0x127c20,%ebx
rtems_libio_check_is_open( iop );
11f236: 8b 4b 14 mov 0x14(%ebx),%ecx
11f239: f6 c5 01 test $0x1,%ch
11f23c: 74 36 je 11f274 <read+0x68>
rtems_libio_check_buffer( buffer );
11f23e: 85 c0 test %eax,%eax
11f240: 74 46 je 11f288 <read+0x7c> <== NEVER TAKEN
rtems_libio_check_count( count );
11f242: 85 d2 test %edx,%edx
11f244: 74 26 je 11f26c <read+0x60>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
11f246: 83 e1 02 and $0x2,%ecx
11f249: 74 3d je 11f288 <read+0x7c>
/*
* Now process the read().
*/
rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
11f24b: 51 push %ecx
11f24c: 8b 4b 20 mov 0x20(%ebx),%ecx
11f24f: 52 push %edx
11f250: 50 push %eax
11f251: 53 push %ebx
11f252: ff 51 08 call *0x8(%ecx)
if ( rc > 0 )
11f255: 83 c4 10 add $0x10,%esp
11f258: 85 c0 test %eax,%eax
11f25a: 7e 0b jle 11f267 <read+0x5b>
iop->offset += rc;
11f25c: 89 c1 mov %eax,%ecx
11f25e: c1 f9 1f sar $0x1f,%ecx
11f261: 01 43 0c add %eax,0xc(%ebx)
11f264: 11 4b 10 adc %ecx,0x10(%ebx)
return rc;
}
11f267: 8b 5d fc mov -0x4(%ebp),%ebx
11f26a: c9 leave
11f26b: 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 );
11f26c: 31 c0 xor %eax,%eax
if ( rc > 0 )
iop->offset += rc;
return rc;
}
11f26e: 8b 5d fc mov -0x4(%ebp),%ebx
11f271: c9 leave
11f272: c3 ret
11f273: 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 );
11f274: e8 f7 3f ff ff call 113270 <__errno>
11f279: c7 00 09 00 00 00 movl $0x9,(%eax)
11f27f: b8 ff ff ff ff mov $0xffffffff,%eax
11f284: eb e1 jmp 11f267 <read+0x5b>
11f286: 66 90 xchg %ax,%ax
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
11f288: e8 e3 3f ff ff call 113270 <__errno>
11f28d: c7 00 16 00 00 00 movl $0x16,(%eax)
11f293: b8 ff ff ff ff mov $0xffffffff,%eax
11f298: eb cd jmp 11f267 <read+0x5b>
0010b068 <readlink>:
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
10b068: 55 push %ebp
10b069: 89 e5 mov %esp,%ebp
10b06b: 57 push %edi
10b06c: 56 push %esi
10b06d: 53 push %ebx
10b06e: 83 ec 3c sub $0x3c,%esp
10b071: 8b 55 08 mov 0x8(%ebp),%edx
10b074: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
10b077: 85 db test %ebx,%ebx
10b079: 74 6d je 10b0e8 <readlink+0x80>
rtems_set_errno_and_return_minus_one( EFAULT );
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
10b07b: 31 c0 xor %eax,%eax
10b07d: b9 ff ff ff ff mov $0xffffffff,%ecx
10b082: 89 d7 mov %edx,%edi
10b084: f2 ae repnz scas %es:(%edi),%al
10b086: f7 d1 not %ecx
10b088: 49 dec %ecx
10b089: 83 ec 0c sub $0xc,%esp
10b08c: 6a 00 push $0x0
10b08e: 8d 75 d4 lea -0x2c(%ebp),%esi
10b091: 56 push %esi
10b092: 6a 00 push $0x0
10b094: 51 push %ecx
10b095: 52 push %edx
10b096: e8 79 ee ff ff call 109f14 <rtems_filesystem_evaluate_path>
0, &loc, false );
if ( result != 0 )
10b09b: 83 c4 20 add $0x20,%esp
10b09e: 85 c0 test %eax,%eax
10b0a0: 74 0e je 10b0b0 <readlink+0x48> <== ALWAYS TAKEN
return -1;
10b0a2: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
rtems_filesystem_freenode( &loc );
return result;
}
10b0a7: 8d 65 f4 lea -0xc(%ebp),%esp
10b0aa: 5b pop %ebx
10b0ab: 5e pop %esi
10b0ac: 5f pop %edi
10b0ad: c9 leave
10b0ae: c3 ret
10b0af: 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 ){
10b0b0: 83 ec 0c sub $0xc,%esp
10b0b3: 56 push %esi
10b0b4: 8b 45 e0 mov -0x20(%ebp),%eax
10b0b7: ff 50 10 call *0x10(%eax)
10b0ba: 83 c4 10 add $0x10,%esp
10b0bd: 83 f8 04 cmp $0x4,%eax
10b0c0: 75 3e jne 10b100 <readlink+0x98>
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( EINVAL );
}
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
10b0c2: 50 push %eax
10b0c3: ff 75 10 pushl 0x10(%ebp)
10b0c6: 53 push %ebx
10b0c7: 56 push %esi
10b0c8: 8b 45 e0 mov -0x20(%ebp),%eax
10b0cb: ff 50 3c call *0x3c(%eax)
rtems_filesystem_freenode( &loc );
10b0ce: 89 34 24 mov %esi,(%esp)
10b0d1: 89 45 c4 mov %eax,-0x3c(%ebp)
10b0d4: e8 13 ef ff ff call 109fec <rtems_filesystem_freenode>
return result;
10b0d9: 83 c4 10 add $0x10,%esp
10b0dc: 8b 45 c4 mov -0x3c(%ebp),%eax
}
10b0df: 8d 65 f4 lea -0xc(%ebp),%esp
10b0e2: 5b pop %ebx
10b0e3: 5e pop %esi
10b0e4: 5f pop %edi
10b0e5: c9 leave
10b0e6: c3 ret
10b0e7: 90 nop
{
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
rtems_set_errno_and_return_minus_one( EFAULT );
10b0e8: e8 af ac 00 00 call 115d9c <__errno>
10b0ed: c7 00 0e 00 00 00 movl $0xe,(%eax)
10b0f3: b8 ff ff ff ff mov $0xffffffff,%eax
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
rtems_filesystem_freenode( &loc );
return result;
}
10b0f8: 8d 65 f4 lea -0xc(%ebp),%esp
10b0fb: 5b pop %ebx
10b0fc: 5e pop %esi
10b0fd: 5f pop %edi
10b0fe: c9 leave
10b0ff: 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 );
10b100: 83 ec 0c sub $0xc,%esp
10b103: 56 push %esi
10b104: e8 e3 ee ff ff call 109fec <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EINVAL );
10b109: e8 8e ac 00 00 call 115d9c <__errno>
10b10e: c7 00 16 00 00 00 movl $0x16,(%eax)
10b114: 83 c4 10 add $0x10,%esp
10b117: b8 ff ff ff ff mov $0xffffffff,%eax
10b11c: eb 89 jmp 10b0a7 <readlink+0x3f>
00109d2c <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
109d2c: 55 push %ebp
109d2d: 89 e5 mov %esp,%ebp
109d2f: 57 push %edi
109d30: 56 push %esi
109d31: 53 push %ebx
109d32: 83 ec 1c sub $0x1c,%esp
109d35: 8b 45 08 mov 0x8(%ebp),%eax
109d38: 8b 5d 0c mov 0xc(%ebp),%ebx
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
109d3b: 3b 05 ac 4f 12 00 cmp 0x124fac,%eax
109d41: 0f 83 ef 00 00 00 jae 109e36 <readv+0x10a>
iop = rtems_libio_iop( fd );
109d47: c1 e0 03 shl $0x3,%eax
109d4a: 8d 34 c5 00 00 00 00 lea 0x0(,%eax,8),%esi
109d51: 29 c6 sub %eax,%esi
109d53: 03 35 60 92 12 00 add 0x129260,%esi
rtems_libio_check_is_open( iop );
109d59: 8b 46 14 mov 0x14(%esi),%eax
109d5c: f6 c4 01 test $0x1,%ah
109d5f: 0f 84 d1 00 00 00 je 109e36 <readv+0x10a>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
109d65: a8 02 test $0x2,%al
109d67: 0f 84 97 00 00 00 je 109e04 <readv+0xd8> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
109d6d: 85 db test %ebx,%ebx
109d6f: 0f 84 8f 00 00 00 je 109e04 <readv+0xd8>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
109d75: 8b 7d 10 mov 0x10(%ebp),%edi
109d78: 85 ff test %edi,%edi
109d7a: 0f 8e 84 00 00 00 jle 109e04 <readv+0xd8>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
109d80: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp)
109d87: 7f 7b jg 109e04 <readv+0xd8> <== NEVER TAKEN
109d89: c6 45 e4 01 movb $0x1,-0x1c(%ebp)
109d8d: 31 c0 xor %eax,%eax
109d8f: 31 d2 xor %edx,%edx
109d91: eb 03 jmp 109d96 <readv+0x6a>
109d93: 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;
109d94: 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 )
109d96: 8b 0c c3 mov (%ebx,%eax,8),%ecx
109d99: 85 c9 test %ecx,%ecx
109d9b: 74 67 je 109e04 <readv+0xd8>
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
109d9d: 8b 4c c3 04 mov 0x4(%ebx,%eax,8),%ecx
109da1: 8d 3c 0a lea (%edx,%ecx,1),%edi
if ( total < old )
109da4: 39 fa cmp %edi,%edx
109da6: 7f 5c jg 109e04 <readv+0xd8>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
109da8: 85 c9 test %ecx,%ecx
109daa: 74 04 je 109db0 <readv+0x84>
all_zeros = false;
109dac: 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++ ) {
109db0: 40 inc %eax
109db1: 39 45 10 cmp %eax,0x10(%ebp)
109db4: 7f de jg 109d94 <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 ) {
109db6: 80 7d e4 00 cmpb $0x0,-0x1c(%ebp)
109dba: 75 68 jne 109e24 <readv+0xf8>
109dbc: 31 ff xor %edi,%edi
109dbe: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
109dc5: eb 1d jmp 109de4 <readv+0xb8>
109dc7: 90 nop
);
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
109dc8: 74 0e je 109dd8 <readv+0xac> <== NEVER TAKEN
iop->offset += bytes;
109dca: 89 c1 mov %eax,%ecx
109dcc: c1 f9 1f sar $0x1f,%ecx
109dcf: 01 46 0c add %eax,0xc(%esi)
109dd2: 11 4e 10 adc %ecx,0x10(%esi)
total += bytes;
109dd5: 01 45 e4 add %eax,-0x1c(%ebp)
}
if (bytes != iov[ v ].iov_len)
109dd8: 3b 44 fb 04 cmp 0x4(%ebx,%edi,8),%eax
109ddc: 75 38 jne 109e16 <readv+0xea> <== NEVER TAKEN
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
109dde: 47 inc %edi
109ddf: 39 7d 10 cmp %edi,0x10(%ebp)
109de2: 7e 32 jle 109e16 <readv+0xea>
bytes = (*iop->pathinfo.handlers->read_h)(
109de4: 50 push %eax
109de5: 8b 46 20 mov 0x20(%esi),%eax
109de8: ff 74 fb 04 pushl 0x4(%ebx,%edi,8)
109dec: ff 34 fb pushl (%ebx,%edi,8)
109def: 56 push %esi
109df0: ff 50 08 call *0x8(%eax)
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
109df3: 83 c4 10 add $0x10,%esp
109df6: 83 f8 00 cmp $0x0,%eax
109df9: 7d cd jge 109dc8 <readv+0x9c> <== ALWAYS TAKEN
return -1;
109dfb: c7 45 e4 ff ff ff ff movl $0xffffffff,-0x1c(%ebp) <== NOT EXECUTED
109e02: eb 12 jmp 109e16 <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 );
109e04: e8 f7 a1 00 00 call 114000 <__errno>
109e09: c7 00 16 00 00 00 movl $0x16,(%eax)
109e0f: c7 45 e4 ff ff ff ff movl $0xffffffff,-0x1c(%ebp)
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
109e16: 8b 45 e4 mov -0x1c(%ebp),%eax
109e19: 8d 65 f4 lea -0xc(%ebp),%esp
109e1c: 5b pop %ebx
109e1d: 5e pop %esi
109e1e: 5f pop %edi
109e1f: c9 leave
109e20: c3 ret
109e21: 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;
109e24: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
109e2b: 8b 45 e4 mov -0x1c(%ebp),%eax
109e2e: 8d 65 f4 lea -0xc(%ebp),%esp
109e31: 5b pop %ebx
109e32: 5e pop %esi
109e33: 5f pop %edi
109e34: c9 leave
109e35: 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 );
109e36: e8 c5 a1 00 00 call 114000 <__errno>
109e3b: c7 00 09 00 00 00 movl $0x9,(%eax)
109e41: c7 45 e4 ff ff ff ff movl $0xffffffff,-0x1c(%ebp)
109e48: eb cc jmp 109e16 <readv+0xea>
0011f328 <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
11f328: 55 push %ebp
11f329: 89 e5 mov %esp,%ebp
11f32b: 57 push %edi
11f32c: 56 push %esi
11f32d: 53 push %ebx
11f32e: 83 ec 2c sub $0x2c,%esp
11f331: 8b 5d 08 mov 0x8(%ebp),%ebx
11f334: 8b 75 0c mov 0xc(%ebp),%esi
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
11f337: ff 05 50 7c 12 00 incl 0x127c50
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
11f33d: 83 3d 20 7f 12 00 03 cmpl $0x3,0x127f20
11f344: 74 72 je 11f3b8 <realloc+0x90> <== ALWAYS TAKEN
}
/*
* Continue with realloc().
*/
if ( !ptr )
11f346: 85 db test %ebx,%ebx
11f348: 74 5e je 11f3a8 <realloc+0x80>
return malloc( size );
if ( !size ) {
11f34a: 85 f6 test %esi,%esi
11f34c: 74 3a je 11f388 <realloc+0x60> <== NEVER TAKEN
free( ptr );
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
11f34e: 52 push %edx
11f34f: 8d 45 e4 lea -0x1c(%ebp),%eax
11f352: 50 push %eax
11f353: 53 push %ebx
11f354: ff 35 b0 39 12 00 pushl 0x1239b0
11f35a: e8 49 01 00 00 call 11f4a8 <_Protected_heap_Get_block_size>
11f35f: 83 c4 10 add $0x10,%esp
11f362: 84 c0 test %al,%al
11f364: 74 32 je 11f398 <realloc+0x70>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
11f366: 50 push %eax
11f367: 56 push %esi
11f368: 53 push %ebx
11f369: ff 35 b0 39 12 00 pushl 0x1239b0
11f36f: e8 6c 01 00 00 call 11f4e0 <_Protected_heap_Resize_block>
11f374: 83 c4 10 add $0x10,%esp
11f377: 84 c0 test %al,%al
11f379: 74 5d je 11f3d8 <realloc+0xb0>
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
11f37b: 89 d8 mov %ebx,%eax
11f37d: 8d 65 f4 lea -0xc(%ebp),%esp
11f380: 5b pop %ebx
11f381: 5e pop %esi
11f382: 5f pop %edi
11f383: c9 leave
11f384: c3 ret
11f385: 8d 76 00 lea 0x0(%esi),%esi
*/
if ( !ptr )
return malloc( size );
if ( !size ) {
free( ptr );
11f388: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
11f38b: 53 push %ebx <== NOT EXECUTED
11f38c: e8 23 8d fe ff call 1080b4 <free> <== NOT EXECUTED
return (void *) 0;
11f391: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
11f394: 31 db xor %ebx,%ebx <== NOT EXECUTED
11f396: eb e3 jmp 11f37b <realloc+0x53> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
11f398: e8 d3 3e ff ff call 113270 <__errno>
11f39d: c7 00 16 00 00 00 movl $0x16,(%eax)
return (void *) 0;
11f3a3: 31 db xor %ebx,%ebx
11f3a5: eb d4 jmp 11f37b <realloc+0x53>
11f3a7: 90 nop
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
11f3a8: 83 ec 0c sub $0xc,%esp
11f3ab: 56 push %esi
11f3ac: e8 d7 8f fe ff call 108388 <malloc>
11f3b1: 89 c3 mov %eax,%ebx
11f3b3: 83 c4 10 add $0x10,%esp
11f3b6: eb c3 jmp 11f37b <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)
11f3b8: a1 90 7d 12 00 mov 0x127d90,%eax
11f3bd: 85 c0 test %eax,%eax
11f3bf: 74 04 je 11f3c5 <realloc+0x9d> <== ALWAYS TAKEN
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
return (void *) 0;
11f3c1: 31 db xor %ebx,%ebx
11f3c3: eb b6 jmp 11f37b <realloc+0x53>
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_disable_level > 0)
return (void *) 0;
if (_ISR_Nest_level > 0)
11f3c5: 8b 0d 34 83 12 00 mov 0x128334,%ecx
11f3cb: 85 c9 test %ecx,%ecx
11f3cd: 0f 84 73 ff ff ff je 11f346 <realloc+0x1e> <== ALWAYS TAKEN
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
return (void *) 0;
11f3d3: 31 db xor %ebx,%ebx
11f3d5: eb a4 jmp 11f37b <realloc+0x53> <== NOT EXECUTED
11f3d7: 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 );
11f3d8: 83 ec 0c sub $0xc,%esp
11f3db: 56 push %esi
11f3dc: e8 a7 8f fe ff call 108388 <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
11f3e1: ff 0d 44 7c 12 00 decl 0x127c44
if ( !new_area ) {
11f3e7: 83 c4 10 add $0x10,%esp
11f3ea: 85 c0 test %eax,%eax
11f3ec: 74 d3 je 11f3c1 <realloc+0x99>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
11f3ee: 8b 55 e4 mov -0x1c(%ebp),%edx
11f3f1: 89 f1 mov %esi,%ecx
11f3f3: 39 d6 cmp %edx,%esi
11f3f5: 76 02 jbe 11f3f9 <realloc+0xd1> <== NEVER TAKEN
11f3f7: 89 d1 mov %edx,%ecx
11f3f9: 89 c7 mov %eax,%edi
11f3fb: 89 de mov %ebx,%esi
11f3fd: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
free( ptr );
11f3ff: 83 ec 0c sub $0xc,%esp
11f402: 53 push %ebx
11f403: 89 45 d4 mov %eax,-0x2c(%ebp)
11f406: e8 a9 8c fe ff call 1080b4 <free>
return new_area;
11f40b: 83 c4 10 add $0x10,%esp
11f40e: 8b 45 d4 mov -0x2c(%ebp),%eax
11f411: 89 c3 mov %eax,%ebx
11f413: e9 63 ff ff ff jmp 11f37b <realloc+0x53>
00109300 <rmdir>:
#include <rtems/seterr.h>
int rmdir(
const char *pathname
)
{
109300: 55 push %ebp
109301: 89 e5 mov %esp,%ebp
109303: 57 push %edi
109304: 56 push %esi
109305: 53 push %ebx
109306: 83 ec 58 sub $0x58,%esp
109309: 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 );
10930c: 53 push %ebx
10930d: e8 46 f1 ff ff call 108458 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
109312: 83 c4 10 add $0x10,%esp
109315: 85 c0 test %eax,%eax
109317: 0f 85 0f 01 00 00 jne 10942c <rmdir+0x12c>
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
10931d: 50 push %eax
10931e: 8d 45 d0 lea -0x30(%ebp),%eax
109321: 89 45 b4 mov %eax,-0x4c(%ebp)
109324: 50 push %eax
109325: 8d 45 e4 lea -0x1c(%ebp),%eax
109328: 50 push %eax
109329: 53 push %ebx
10932a: e8 45 01 00 00 call 109474 <rtems_filesystem_get_start_loc>
10932f: 83 c4 10 add $0x10,%esp
109332: 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;
109334: c6 45 b3 00 movb $0x0,-0x4d(%ebp)
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
109338: 8d 7d bc lea -0x44(%ebp),%edi
10933b: b9 05 00 00 00 mov $0x5,%ecx
109340: 8b 75 b4 mov -0x4c(%ebp),%esi
109343: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
name = pathname + parentpathlen;
109345: 01 d3 add %edx,%ebx
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
109347: be ff ff ff ff mov $0xffffffff,%esi
10934c: 89 f1 mov %esi,%ecx
10934e: 89 df mov %ebx,%edi
109350: 31 c0 xor %eax,%eax
109352: f2 ae repnz scas %es:(%edi),%al
109354: f7 d1 not %ecx
109356: 49 dec %ecx
109357: 83 ec 08 sub $0x8,%esp
10935a: 51 push %ecx
10935b: 53 push %ebx
10935c: e8 3b f1 ff ff call 10849c <rtems_filesystem_prefix_separators>
109361: 01 c3 add %eax,%ebx
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
109363: 89 f1 mov %esi,%ecx
109365: 89 df mov %ebx,%edi
109367: 31 c0 xor %eax,%eax
109369: f2 ae repnz scas %es:(%edi),%al
10936b: f7 d1 not %ecx
10936d: 49 dec %ecx
10936e: c7 04 24 00 00 00 00 movl $0x0,(%esp)
109375: 8d 75 bc lea -0x44(%ebp),%esi
109378: 56 push %esi
109379: 6a 00 push $0x0
10937b: 51 push %ecx
10937c: 53 push %ebx
10937d: e8 2a f0 ff ff call 1083ac <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
109382: 83 c4 20 add $0x20,%esp
109385: 85 c0 test %eax,%eax
109387: 75 5b jne 1093e4 <rmdir+0xe4>
}
/*
* Verify you can remove this node as a directory.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
109389: 83 ec 0c sub $0xc,%esp
10938c: 56 push %esi
10938d: 8b 45 c8 mov -0x38(%ebp),%eax
109390: ff 50 10 call *0x10(%eax)
109393: 83 c4 10 add $0x10,%esp
109396: 48 dec %eax
109397: 75 5f jne 1093f8 <rmdir+0xf8>
/*
* Use the filesystems rmnod to remove the node.
*/
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
109399: 83 ec 08 sub $0x8,%esp
10939c: 56 push %esi
10939d: ff 75 b4 pushl -0x4c(%ebp)
1093a0: 8b 45 c4 mov -0x3c(%ebp),%eax
1093a3: ff 50 34 call *0x34(%eax)
rtems_filesystem_freenode( &loc );
1093a6: 89 34 24 mov %esi,(%esp)
1093a9: 89 45 ac mov %eax,-0x54(%ebp)
1093ac: e8 3b f1 ff ff call 1084ec <rtems_filesystem_freenode>
if ( free_parentloc )
1093b1: 83 c4 10 add $0x10,%esp
1093b4: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp)
1093b8: 8b 45 ac mov -0x54(%ebp),%eax
1093bb: 75 0b jne 1093c8 <rmdir+0xc8>
rtems_filesystem_freenode( &parentloc );
return result;
}
1093bd: 8d 65 f4 lea -0xc(%ebp),%esp
1093c0: 5b pop %ebx
1093c1: 5e pop %esi
1093c2: 5f pop %edi
1093c3: c9 leave
1093c4: c3 ret
1093c5: 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 );
1093c8: 83 ec 0c sub $0xc,%esp
1093cb: ff 75 b4 pushl -0x4c(%ebp)
1093ce: e8 19 f1 ff ff call 1084ec <rtems_filesystem_freenode>
1093d3: 83 c4 10 add $0x10,%esp
1093d6: 8b 45 ac mov -0x54(%ebp),%eax
return result;
}
1093d9: 8d 65 f4 lea -0xc(%ebp),%esp
1093dc: 5b pop %ebx
1093dd: 5e pop %esi
1093de: 5f pop %edi
1093df: c9 leave
1093e0: c3 ret
1093e1: 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 )
1093e4: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp)
1093e8: 75 6f jne 109459 <rmdir+0x159>
rtems_filesystem_freenode( &parentloc );
return -1;
1093ea: b8 ff ff ff ff mov $0xffffffff,%eax
rtems_filesystem_freenode( &loc );
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return result;
}
1093ef: 8d 65 f4 lea -0xc(%ebp),%esp
1093f2: 5b pop %ebx
1093f3: 5e pop %esi
1093f4: 5f pop %edi
1093f5: c9 leave
1093f6: c3 ret
1093f7: 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 );
1093f8: 83 ec 0c sub $0xc,%esp
1093fb: 56 push %esi
1093fc: e8 eb f0 ff ff call 1084ec <rtems_filesystem_freenode>
if ( free_parentloc )
109401: 83 c4 10 add $0x10,%esp
109404: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp)
109408: 74 0e je 109418 <rmdir+0x118> <== NEVER TAKEN
rtems_filesystem_freenode( &parentloc );
10940a: 83 ec 0c sub $0xc,%esp
10940d: ff 75 b4 pushl -0x4c(%ebp)
109410: e8 d7 f0 ff ff call 1084ec <rtems_filesystem_freenode>
109415: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( ENOTDIR );
109418: e8 eb a6 00 00 call 113b08 <__errno>
10941d: c7 00 14 00 00 00 movl $0x14,(%eax)
109423: b8 ff ff ff ff mov $0xffffffff,%eax
109428: eb 93 jmp 1093bd <rmdir+0xbd>
10942a: 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,
10942c: 89 c2 mov %eax,%edx
10942e: 83 ec 0c sub $0xc,%esp
109431: 6a 00 push $0x0
109433: 8d 45 d0 lea -0x30(%ebp),%eax
109436: 89 45 b4 mov %eax,-0x4c(%ebp)
109439: 50 push %eax
10943a: 6a 02 push $0x2
10943c: 52 push %edx
10943d: 53 push %ebx
10943e: 89 55 ac mov %edx,-0x54(%ebp)
109441: e8 ce ef ff ff call 108414 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
109446: 83 c4 20 add $0x20,%esp
109449: 85 c0 test %eax,%eax
10944b: 8b 55 ac mov -0x54(%ebp),%edx
10944e: 75 9a jne 1093ea <rmdir+0xea> <== NEVER TAKEN
return -1;
free_parentloc = true;
109450: c6 45 b3 01 movb $0x1,-0x4d(%ebp)
109454: e9 df fe ff ff jmp 109338 <rmdir+0x38>
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
109459: 83 ec 0c sub $0xc,%esp
10945c: ff 75 b4 pushl -0x4c(%ebp)
10945f: e8 88 f0 ff ff call 1084ec <rtems_filesystem_freenode>
109464: 83 c4 10 add $0x10,%esp
return -1;
109467: b8 ff ff ff ff mov $0xffffffff,%eax
10946c: e9 4c ff ff ff jmp 1093bd <rmdir+0xbd>
0010c550 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
10c550: 55 push %ebp
10c551: 89 e5 mov %esp,%ebp
10c553: 57 push %edi
10c554: 56 push %esi
10c555: 53 push %ebx
10c556: 83 ec 58 sub $0x58,%esp
10c559: 8b 5d 08 mov 0x8(%ebp),%ebx
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
10c55c: 68 00 aa 12 00 push $0x12aa00
10c561: e8 86 09 00 00 call 10ceec <pthread_mutex_lock>
10c566: 89 c6 mov %eax,%esi
if (result != 0) {
10c568: 83 c4 10 add $0x10,%esp
10c56b: 85 c0 test %eax,%eax
10c56d: 0f 85 c1 00 00 00 jne 10c634 <rtems_aio_enqueue+0xe4><== NEVER TAKEN
return result;
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
10c573: e8 24 12 00 00 call 10d79c <pthread_self>
10c578: 51 push %ecx
10c579: 8d 55 c4 lea -0x3c(%ebp),%edx
10c57c: 52 push %edx
10c57d: 8d 55 e0 lea -0x20(%ebp),%edx
10c580: 52 push %edx
10c581: 50 push %eax
10c582: e8 e1 0d 00 00 call 10d368 <pthread_getschedparam>
req->caller_thread = pthread_self ();
10c587: e8 10 12 00 00 call 10d79c <pthread_self>
10c58c: 89 43 10 mov %eax,0x10(%ebx)
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
10c58f: 8b 43 14 mov 0x14(%ebx),%eax
10c592: 8b 55 c4 mov -0x3c(%ebp),%edx
10c595: 2b 50 14 sub 0x14(%eax),%edx
10c598: 89 53 0c mov %edx,0xc(%ebx)
req->policy = policy;
10c59b: 8b 55 e0 mov -0x20(%ebp),%edx
10c59e: 89 53 08 mov %edx,0x8(%ebx)
req->aiocbp->error_code = EINPROGRESS;
10c5a1: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax)
req->aiocbp->return_value = 0;
10c5a8: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
if ((aio_request_queue.idle_threads == 0) &&
10c5af: 83 c4 10 add $0x10,%esp
10c5b2: 8b 15 68 aa 12 00 mov 0x12aa68,%edx
10c5b8: 85 d2 test %edx,%edx
10c5ba: 75 0d jne 10c5c9 <rtems_aio_enqueue+0x79><== NEVER TAKEN
10c5bc: 83 3d 64 aa 12 00 04 cmpl $0x4,0x12aa64
10c5c3: 0f 8e 83 00 00 00 jle 10c64c <rtems_aio_enqueue+0xfc>
else
{
/* the maximum number of threads has been already created
even though some of them might be idle.
The request belongs to one of the active fd chain */
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
10c5c9: 51 push %ecx
10c5ca: 6a 00 push $0x0
10c5cc: ff 30 pushl (%eax)
10c5ce: 68 48 aa 12 00 push $0x12aa48
10c5d3: e8 28 fb ff ff call 10c100 <rtems_aio_search_fd>
10c5d8: 89 c7 mov %eax,%edi
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
10c5da: 83 c4 10 add $0x10,%esp
10c5dd: 85 c0 test %eax,%eax
10c5df: 0f 84 df 00 00 00 je 10c6c4 <rtems_aio_enqueue+0x174>
{
pthread_mutex_lock (&r_chain->mutex);
10c5e5: 8d 57 1c lea 0x1c(%edi),%edx
10c5e8: 83 ec 0c sub $0xc,%esp
10c5eb: 52 push %edx
10c5ec: 89 55 b4 mov %edx,-0x4c(%ebp)
10c5ef: e8 f8 08 00 00 call 10ceec <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
10c5f4: 58 pop %eax
10c5f5: 5a pop %edx
10c5f6: 53 push %ebx
10c5f7: 8d 47 08 lea 0x8(%edi),%eax
10c5fa: 50 push %eax
10c5fb: e8 48 fe ff ff call 10c448 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
10c600: 83 c7 20 add $0x20,%edi
10c603: 89 3c 24 mov %edi,(%esp)
10c606: e8 b1 04 00 00 call 10cabc <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
10c60b: 8b 55 b4 mov -0x4c(%ebp),%edx
10c60e: 89 14 24 mov %edx,(%esp)
10c611: e8 5e 09 00 00 call 10cf74 <pthread_mutex_unlock>
10c616: 83 c4 10 add $0x10,%esp
if (aio_request_queue.idle_threads > 0)
pthread_cond_signal (&aio_request_queue.new_req);
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
10c619: 83 ec 0c sub $0xc,%esp
10c61c: 68 00 aa 12 00 push $0x12aa00
10c621: e8 4e 09 00 00 call 10cf74 <pthread_mutex_unlock>
return 0;
10c626: 83 c4 10 add $0x10,%esp
}
10c629: 89 f0 mov %esi,%eax
10c62b: 8d 65 f4 lea -0xc(%ebp),%esp
10c62e: 5b pop %ebx
10c62f: 5e pop %esi
10c630: 5f pop %edi
10c631: c9 leave
10c632: c3 ret
10c633: 90 nop
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
if (result != 0) {
free (req);
10c634: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c637: 53 push %ebx <== NOT EXECUTED
10c638: e8 f7 c4 ff ff call 108b34 <free> <== NOT EXECUTED
return result;
10c63d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
return 0;
}
10c640: 89 f0 mov %esi,%eax <== NOT EXECUTED
10c642: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10c645: 5b pop %ebx <== NOT EXECUTED
10c646: 5e pop %esi <== NOT EXECUTED
10c647: 5f pop %edi <== NOT EXECUTED
10c648: c9 leave <== NOT EXECUTED
10c649: c3 ret <== NOT EXECUTED
10c64a: 66 90 xchg %ax,%ax <== NOT EXECUTED
if ((aio_request_queue.idle_threads == 0) &&
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
10c64c: 57 push %edi
10c64d: 6a 01 push $0x1
10c64f: ff 30 pushl (%eax)
10c651: 68 48 aa 12 00 push $0x12aa48
10c656: e8 a5 fa ff ff call 10c100 <rtems_aio_search_fd>
10c65b: 89 c7 mov %eax,%edi
if (r_chain->new_fd == 1) {
10c65d: 83 c4 10 add $0x10,%esp
10c660: 83 78 18 01 cmpl $0x1,0x18(%eax)
10c664: 0f 85 7b ff ff ff jne 10c5e5 <rtems_aio_enqueue+0x95>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
10c66a: 83 ec 08 sub $0x8,%esp
10c66d: 53 push %ebx
10c66e: 8d 40 08 lea 0x8(%eax),%eax
10c671: 50 push %eax
10c672: e8 81 22 00 00 call 10e8f8 <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
10c677: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
pthread_mutex_init (&r_chain->mutex, NULL);
10c67e: 5a pop %edx
10c67f: 59 pop %ecx
10c680: 6a 00 push $0x0
10c682: 8d 47 1c lea 0x1c(%edi),%eax
10c685: 50 push %eax
10c686: e8 15 07 00 00 call 10cda0 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10c68b: 5b pop %ebx
10c68c: 58 pop %eax
10c68d: 6a 00 push $0x0
10c68f: 8d 47 20 lea 0x20(%edi),%eax
10c692: 50 push %eax
10c693: e8 70 03 00 00 call 10ca08 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
10c698: 57 push %edi
10c699: 68 fc c1 10 00 push $0x10c1fc
10c69e: 68 08 aa 12 00 push $0x12aa08
10c6a3: 8d 45 e4 lea -0x1c(%ebp),%eax
10c6a6: 50 push %eax
10c6a7: e8 34 0a 00 00 call 10d0e0 <pthread_create>
10c6ac: 89 c3 mov %eax,%ebx
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
10c6ae: 83 c4 20 add $0x20,%esp
10c6b1: 85 c0 test %eax,%eax
10c6b3: 0f 85 8e 00 00 00 jne 10c747 <rtems_aio_enqueue+0x1f7><== NEVER TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
++aio_request_queue.active_threads;
10c6b9: ff 05 64 aa 12 00 incl 0x12aa64
10c6bf: e9 55 ff ff ff jmp 10c619 <rtems_aio_enqueue+0xc9>
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
10c6c4: 57 push %edi
10c6c5: 6a 01 push $0x1
10c6c7: 8b 43 14 mov 0x14(%ebx),%eax
10c6ca: ff 30 pushl (%eax)
10c6cc: 68 54 aa 12 00 push $0x12aa54
10c6d1: e8 2a fa ff ff call 10c100 <rtems_aio_search_fd>
10c6d6: 89 c7 mov %eax,%edi
if (r_chain->new_fd == 1) {
10c6d8: 83 c4 10 add $0x10,%esp
10c6db: 83 78 18 01 cmpl $0x1,0x18(%eax)
10c6df: 74 33 je 10c714 <rtems_aio_enqueue+0x1c4>
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
pthread_cond_init (&r_chain->cond, NULL);
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
10c6e1: 83 ec 08 sub $0x8,%esp
10c6e4: 53 push %ebx
10c6e5: 83 c7 08 add $0x8,%edi
10c6e8: 57 push %edi
10c6e9: e8 5a fd ff ff call 10c448 <rtems_aio_insert_prio>
10c6ee: 83 c4 10 add $0x10,%esp
if (aio_request_queue.idle_threads > 0)
10c6f1: 8b 0d 68 aa 12 00 mov 0x12aa68,%ecx
10c6f7: 85 c9 test %ecx,%ecx
10c6f9: 0f 8e 1a ff ff ff jle 10c619 <rtems_aio_enqueue+0xc9><== ALWAYS TAKEN
pthread_cond_signal (&aio_request_queue.new_req);
10c6ff: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c702: 68 04 aa 12 00 push $0x12aa04 <== NOT EXECUTED
10c707: e8 b0 03 00 00 call 10cabc <pthread_cond_signal> <== NOT EXECUTED
10c70c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c70f: e9 05 ff ff ff jmp 10c619 <rtems_aio_enqueue+0xc9><== NOT EXECUTED
10c714: 83 ec 08 sub $0x8,%esp
10c717: 53 push %ebx
10c718: 8d 40 08 lea 0x8(%eax),%eax
10c71b: 50 push %eax
10c71c: e8 d7 21 00 00 call 10e8f8 <_Chain_Insert>
if (r_chain->new_fd == 1) {
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
10c721: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
pthread_mutex_init (&r_chain->mutex, NULL);
10c728: 5a pop %edx
10c729: 59 pop %ecx
10c72a: 6a 00 push $0x0
10c72c: 8d 47 1c lea 0x1c(%edi),%eax
10c72f: 50 push %eax
10c730: e8 6b 06 00 00 call 10cda0 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10c735: 5b pop %ebx
10c736: 58 pop %eax
10c737: 6a 00 push $0x0
10c739: 83 c7 20 add $0x20,%edi
10c73c: 57 push %edi
10c73d: e8 c6 02 00 00 call 10ca08 <pthread_cond_init>
10c742: 83 c4 10 add $0x10,%esp
10c745: eb aa jmp 10c6f1 <rtems_aio_enqueue+0x1a1>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
pthread_mutex_unlock (&aio_request_queue.mutex);
10c747: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c74a: 68 00 aa 12 00 push $0x12aa00 <== NOT EXECUTED
10c74f: e8 20 08 00 00 call 10cf74 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
10c754: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c757: 89 de mov %ebx,%esi <== NOT EXECUTED
10c759: e9 cb fe ff ff jmp 10c629 <rtems_aio_enqueue+0xd9><== NOT EXECUTED
0010c1fc <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
10c1fc: 55 push %ebp
10c1fd: 89 e5 mov %esp,%ebp
10c1ff: 57 push %edi
10c200: 56 push %esi
10c201: 53 push %ebx
10c202: 83 ec 4c sub $0x4c,%esp
rtems_aio_request_chain *r_chain = arg;
10c205: 8b 7d 08 mov 0x8(%ebp),%edi
10c208: 8d 47 1c lea 0x1c(%edi),%eax
10c20b: 89 45 b4 mov %eax,-0x4c(%ebp)
10c20e: 66 90 xchg %ax,%ax
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
10c210: 83 ec 0c sub $0xc,%esp
10c213: ff 75 b4 pushl -0x4c(%ebp)
10c216: e8 d1 0c 00 00 call 10ceec <pthread_mutex_lock>
if (result != 0)
10c21b: 83 c4 10 add $0x10,%esp
10c21e: 85 c0 test %eax,%eax
10c220: 0f 85 2a 01 00 00 jne 10c350 <rtems_aio_handle+0x154><== NEVER TAKEN
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c226: 8b 5f 08 mov 0x8(%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 );
10c229: 8d 47 0c lea 0xc(%edi),%eax
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
10c22c: 39 c3 cmp %eax,%ebx
10c22e: 0f 84 d0 00 00 00 je 10c304 <rtems_aio_handle+0x108>
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
10c234: e8 63 15 00 00 call 10d79c <pthread_self>
10c239: 52 push %edx
10c23a: 8d 55 c0 lea -0x40(%ebp),%edx
10c23d: 52 push %edx
10c23e: 8d 55 e4 lea -0x1c(%ebp),%edx
10c241: 52 push %edx
10c242: 50 push %eax
10c243: e8 20 11 00 00 call 10d368 <pthread_getschedparam>
param.sched_priority = req->priority;
10c248: 8b 43 0c mov 0xc(%ebx),%eax
10c24b: 89 45 c0 mov %eax,-0x40(%ebp)
pthread_setschedparam (pthread_self(), req->policy, ¶m);
10c24e: 8b 73 08 mov 0x8(%ebx),%esi
10c251: e8 46 15 00 00 call 10d79c <pthread_self>
10c256: 83 c4 0c add $0xc,%esp
10c259: 8d 55 c0 lea -0x40(%ebp),%edx
10c25c: 52 push %edx
10c25d: 56 push %esi
10c25e: 50 push %eax
10c25f: e8 48 15 00 00 call 10d7ac <pthread_setschedparam>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10c264: 89 1c 24 mov %ebx,(%esp)
10c267: e8 50 26 00 00 call 10e8bc <_Chain_Extract>
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
10c26c: 5e pop %esi
10c26d: ff 75 b4 pushl -0x4c(%ebp)
10c270: e8 ff 0c 00 00 call 10cf74 <pthread_mutex_unlock>
switch (req->aiocbp->aio_lio_opcode) {
10c275: 8b 73 14 mov 0x14(%ebx),%esi
10c278: 83 c4 10 add $0x10,%esp
10c27b: 8b 46 2c mov 0x2c(%esi),%eax
10c27e: 83 f8 02 cmp $0x2,%eax
10c281: 74 21 je 10c2a4 <rtems_aio_handle+0xa8>
10c283: 83 f8 03 cmp $0x3,%eax
10c286: 74 6c je 10c2f4 <rtems_aio_handle+0xf8> <== NEVER TAKEN
10c288: 48 dec %eax
10c289: 74 4d je 10c2d8 <rtems_aio_handle+0xdc> <== ALWAYS TAKEN
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
10c28b: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED
req->aiocbp->error_code = errno;
10c292: e8 01 99 00 00 call 115b98 <__errno> <== NOT EXECUTED
10c297: 8b 00 mov (%eax),%eax <== NOT EXECUTED
10c299: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED
10c29c: e9 6f ff ff ff jmp 10c210 <rtems_aio_handle+0x14> <== NOT EXECUTED
10c2a1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
10c2a4: 83 ec 0c sub $0xc,%esp
10c2a7: ff 76 08 pushl 0x8(%esi)
10c2aa: ff 76 04 pushl 0x4(%esi)
10c2ad: ff 76 10 pushl 0x10(%esi)
10c2b0: ff 76 0c pushl 0xc(%esi)
10c2b3: ff 36 pushl (%esi)
10c2b5: e8 76 a3 00 00 call 116630 <pwrite>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
10c2ba: 83 c4 20 add $0x20,%esp
break;
default:
result = -1;
}
if (result == -1) {
10c2bd: 83 f8 ff cmp $0xffffffff,%eax
10c2c0: 0f 84 78 01 00 00 je 10c43e <rtems_aio_handle+0x242><== NEVER TAKEN
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
10c2c6: 8b 53 14 mov 0x14(%ebx),%edx
10c2c9: 89 42 34 mov %eax,0x34(%edx)
req->aiocbp->error_code = 0;
10c2cc: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx)
10c2d3: e9 38 ff ff ff jmp 10c210 <rtems_aio_handle+0x14>
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
10c2d8: 83 ec 0c sub $0xc,%esp
10c2db: ff 76 08 pushl 0x8(%esi)
10c2de: ff 76 04 pushl 0x4(%esi)
10c2e1: ff 76 10 pushl 0x10(%esi)
10c2e4: ff 76 0c pushl 0xc(%esi)
10c2e7: ff 36 pushl (%esi)
10c2e9: e8 8e a2 00 00 call 11657c <pread>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
10c2ee: 83 c4 20 add $0x20,%esp
10c2f1: eb ca jmp 10c2bd <rtems_aio_handle+0xc1>
10c2f3: 90 nop
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
10c2f4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c2f7: ff 36 pushl (%esi) <== NOT EXECUTED
10c2f9: e8 16 67 00 00 call 112a14 <fsync> <== NOT EXECUTED
break;
10c2fe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c301: eb ba jmp 10c2bd <rtems_aio_handle+0xc1> <== NOT EXECUTED
10c303: 90 nop <== NOT EXECUTED
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
10c304: 83 ec 0c sub $0xc,%esp
10c307: ff 75 b4 pushl -0x4c(%ebp)
10c30a: e8 65 0c 00 00 call 10cf74 <pthread_mutex_unlock>
pthread_mutex_lock (&aio_request_queue.mutex);
10c30f: c7 04 24 00 aa 12 00 movl $0x12aa00,(%esp)
10c316: e8 d1 0b 00 00 call 10ceec <pthread_mutex_lock>
if (rtems_chain_is_empty (chain))
10c31b: 83 c4 10 add $0x10,%esp
10c31e: 3b 5f 08 cmp 0x8(%edi),%ebx
10c321: 74 39 je 10c35c <rtems_aio_handle+0x160><== ALWAYS TAKEN
}
}
/* If there was a request added in the initial fd chain then release
the mutex and process it */
pthread_mutex_unlock (&aio_request_queue.mutex);
10c323: 83 ec 0c sub $0xc,%esp
10c326: 68 00 aa 12 00 push $0x12aa00
10c32b: e8 44 0c 00 00 call 10cf74 <pthread_mutex_unlock>
10c330: 83 c4 10 add $0x10,%esp
10c333: e9 d8 fe ff ff jmp 10c210 <rtems_aio_handle+0x14>
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
10c338: ff 0d 68 aa 12 00 decl 0x12aa68
pthread_mutex_unlock (&aio_request_queue.mutex);
10c33e: 83 ec 0c sub $0xc,%esp
10c341: 68 00 aa 12 00 push $0x12aa00
10c346: e8 29 0c 00 00 call 10cf74 <pthread_mutex_unlock>
return NULL;
10c34b: 83 c4 10 add $0x10,%esp
10c34e: 66 90 xchg %ax,%ax
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c350: 31 c0 xor %eax,%eax
10c352: 8d 65 f4 lea -0xc(%ebp),%esp
10c355: 5b pop %ebx
10c356: 5e pop %esi
10c357: 5f pop %edi
10c358: c9 leave
10c359: c3 ret
10c35a: 66 90 xchg %ax,%ax
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
10c35c: 83 ec 08 sub $0x8,%esp
10c35f: 8d 45 dc lea -0x24(%ebp),%eax
10c362: 50 push %eax
10c363: 6a 01 push $0x1
10c365: e8 66 05 00 00 call 10c8d0 <clock_gettime>
timeout.tv_sec += 3;
10c36a: 83 45 dc 03 addl $0x3,-0x24(%ebp)
timeout.tv_nsec = 0;
10c36e: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
result = pthread_cond_timedwait (&r_chain->cond,
10c375: 8d 5f 20 lea 0x20(%edi),%ebx
10c378: 83 c4 0c add $0xc,%esp
10c37b: 8d 55 dc lea -0x24(%ebp),%edx
10c37e: 52 push %edx
10c37f: 68 00 aa 12 00 push $0x12aa00
10c384: 53 push %ebx
10c385: e8 b6 07 00 00 call 10cb40 <pthread_cond_timedwait>
&aio_request_queue.mutex,
&timeout);
/* If no requests were added to the chain we delete the fd chain from
the queue and start working with idle fd chains */
if (result == ETIMEDOUT) {
10c38a: 83 c4 10 add $0x10,%esp
10c38d: 83 f8 74 cmp $0x74,%eax
10c390: 75 91 jne 10c323 <rtems_aio_handle+0x127><== NEVER TAKEN
10c392: 83 ec 0c sub $0xc,%esp
10c395: 57 push %edi
10c396: e8 21 25 00 00 call 10e8bc <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
10c39b: 59 pop %ecx
10c39c: ff 75 b4 pushl -0x4c(%ebp)
10c39f: e8 dc 08 00 00 call 10cc80 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->cond);
10c3a4: 89 1c 24 mov %ebx,(%esp)
10c3a7: e8 90 05 00 00 call 10c93c <pthread_cond_destroy>
free (r_chain);
10c3ac: 89 3c 24 mov %edi,(%esp)
10c3af: e8 80 c7 ff ff call 108b34 <free>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c3b4: 8b 3d 54 aa 12 00 mov 0x12aa54,%edi
pthread_cond_destroy (&r_chain->cond);
free (r_chain);
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
10c3ba: 83 c4 10 add $0x10,%esp
10c3bd: 81 ff 58 aa 12 00 cmp $0x12aa58,%edi
10c3c3: 74 2b je 10c3f0 <rtems_aio_handle+0x1f4>
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
10c3c5: ff 0d 68 aa 12 00 decl 0x12aa68
++aio_request_queue.active_threads;
10c3cb: ff 05 64 aa 12 00 incl 0x12aa64
10c3d1: 83 ec 0c sub $0xc,%esp
10c3d4: 57 push %edi
10c3d5: e8 e2 24 00 00 call 10e8bc <_Chain_Extract>
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = (rtems_aio_request_chain *) node;
rtems_aio_move_to_work (r_chain);
10c3da: 89 3c 24 mov %edi,(%esp)
10c3dd: e8 de fd ff ff call 10c1c0 <rtems_aio_move_to_work>
10c3e2: 83 c4 10 add $0x10,%esp
10c3e5: 8d 47 1c lea 0x1c(%edi),%eax
10c3e8: 89 45 b4 mov %eax,-0x4c(%ebp)
10c3eb: e9 33 ff ff ff jmp 10c323 <rtems_aio_handle+0x127>
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
10c3f0: ff 05 68 aa 12 00 incl 0x12aa68
--aio_request_queue.active_threads;
10c3f6: ff 0d 64 aa 12 00 decl 0x12aa64
clock_gettime (CLOCK_REALTIME, &timeout);
10c3fc: 52 push %edx
10c3fd: 52 push %edx
10c3fe: 8d 45 dc lea -0x24(%ebp),%eax
10c401: 50 push %eax
10c402: 6a 01 push $0x1
10c404: e8 c7 04 00 00 call 10c8d0 <clock_gettime>
timeout.tv_sec += 3;
10c409: 83 45 dc 03 addl $0x3,-0x24(%ebp)
timeout.tv_nsec = 0;
10c40d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
result = pthread_cond_timedwait (&aio_request_queue.new_req,
10c414: 83 c4 0c add $0xc,%esp
10c417: 8d 55 dc lea -0x24(%ebp),%edx
10c41a: 52 push %edx
10c41b: 68 00 aa 12 00 push $0x12aa00
10c420: 68 04 aa 12 00 push $0x12aa04
10c425: e8 16 07 00 00 call 10cb40 <pthread_cond_timedwait>
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
10c42a: 83 c4 10 add $0x10,%esp
10c42d: 83 f8 74 cmp $0x74,%eax
10c430: 0f 84 02 ff ff ff je 10c338 <rtems_aio_handle+0x13c><== ALWAYS TAKEN
10c436: 8b 3d 54 aa 12 00 mov 0x12aa54,%edi <== NOT EXECUTED
10c43c: eb 87 jmp 10c3c5 <rtems_aio_handle+0x1c9><== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
10c43e: 8b 73 14 mov 0x14(%ebx),%esi <== NOT EXECUTED
10c441: e9 45 fe ff ff jmp 10c28b <rtems_aio_handle+0x8f> <== NOT EXECUTED
0010bfd8 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
10bfd8: 55 push %ebp
10bfd9: 89 e5 mov %esp,%ebp
10bfdb: 53 push %ebx
10bfdc: 83 ec 10 sub $0x10,%esp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
10bfdf: 68 08 aa 12 00 push $0x12aa08
10bfe4: e8 a3 10 00 00 call 10d08c <pthread_attr_init>
10bfe9: 89 c3 mov %eax,%ebx
if (result != 0)
10bfeb: 83 c4 10 add $0x10,%esp
10bfee: 85 c0 test %eax,%eax
10bff0: 74 0a je 10bffc <rtems_aio_init+0x24> <== ALWAYS TAKEN
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
return result;
}
10bff2: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10bff4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10bff7: c9 leave <== NOT EXECUTED
10bff8: c3 ret <== NOT EXECUTED
10bff9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
result = pthread_attr_init (&aio_request_queue.attr);
if (result != 0)
return result;
result =
10bffc: 83 ec 08 sub $0x8,%esp
10bfff: 6a 00 push $0x0
10c001: 68 08 aa 12 00 push $0x12aa08
10c006: e8 ad 10 00 00 call 10d0b8 <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
10c00b: 83 c4 10 add $0x10,%esp
10c00e: 85 c0 test %eax,%eax
10c010: 0f 85 96 00 00 00 jne 10c0ac <rtems_aio_init+0xd4> <== NEVER TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
10c016: 83 ec 08 sub $0x8,%esp
10c019: 6a 00 push $0x0
10c01b: 68 00 aa 12 00 push $0x12aa00
10c020: e8 7b 0d 00 00 call 10cda0 <pthread_mutex_init>
if (result != 0)
10c025: 83 c4 10 add $0x10,%esp
10c028: 85 c0 test %eax,%eax
10c02a: 0f 85 b8 00 00 00 jne 10c0e8 <rtems_aio_init+0x110> <== NEVER TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
10c030: 83 ec 08 sub $0x8,%esp
10c033: 6a 00 push $0x0
10c035: 68 04 aa 12 00 push $0x12aa04
10c03a: e8 c9 09 00 00 call 10ca08 <pthread_cond_init>
10c03f: 89 c3 mov %eax,%ebx
if (result != 0) {
10c041: 83 c4 10 add $0x10,%esp
10c044: 85 c0 test %eax,%eax
10c046: 75 7c jne 10c0c4 <rtems_aio_init+0xec> <== NEVER TAKEN
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10c048: c7 05 48 aa 12 00 4c movl $0x12aa4c,0x12aa48
10c04f: aa 12 00
head->previous = NULL;
10c052: c7 05 4c aa 12 00 00 movl $0x0,0x12aa4c
10c059: 00 00 00
tail->previous = head;
10c05c: c7 05 50 aa 12 00 48 movl $0x12aa48,0x12aa50
10c063: aa 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10c066: c7 05 54 aa 12 00 58 movl $0x12aa58,0x12aa54
10c06d: aa 12 00
head->previous = NULL;
10c070: c7 05 58 aa 12 00 00 movl $0x0,0x12aa58
10c077: 00 00 00
tail->previous = head;
10c07a: c7 05 5c aa 12 00 54 movl $0x12aa54,0x12aa5c
10c081: aa 12 00
}
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
10c084: c7 05 64 aa 12 00 00 movl $0x0,0x12aa64
10c08b: 00 00 00
aio_request_queue.idle_threads = 0;
10c08e: c7 05 68 aa 12 00 00 movl $0x0,0x12aa68
10c095: 00 00 00
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
10c098: c7 05 60 aa 12 00 0b movl $0xb00b,0x12aa60
10c09f: b0 00 00
return result;
}
10c0a2: 89 d8 mov %ebx,%eax
10c0a4: 8b 5d fc mov -0x4(%ebp),%ebx
10c0a7: c9 leave
10c0a8: c3 ret
10c0a9: 8d 76 00 lea 0x0(%esi),%esi
result =
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
10c0ac: 83 ec 0c sub $0xc,%esp
10c0af: 68 08 aa 12 00 push $0x12aa08 <== NOT EXECUTED
10c0b4: e8 af 0f 00 00 call 10d068 <pthread_attr_destroy> <== NOT EXECUTED
10c0b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c0bc: e9 55 ff ff ff jmp 10c016 <rtems_aio_init+0x3e> <== NOT EXECUTED
10c0c1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
if (result != 0) {
pthread_mutex_destroy (&aio_request_queue.mutex);
10c0c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c0c7: 68 00 aa 12 00 push $0x12aa00 <== NOT EXECUTED
10c0cc: e8 af 0b 00 00 call 10cc80 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
10c0d1: c7 04 24 08 aa 12 00 movl $0x12aa08,(%esp) <== NOT EXECUTED
10c0d8: e8 8b 0f 00 00 call 10d068 <pthread_attr_destroy> <== NOT EXECUTED
10c0dd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c0e0: e9 63 ff ff ff jmp 10c048 <rtems_aio_init+0x70> <== NOT EXECUTED
10c0e5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
if (result != 0)
pthread_attr_destroy (&aio_request_queue.attr);
10c0e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c0eb: 68 08 aa 12 00 push $0x12aa08 <== NOT EXECUTED
10c0f0: e8 73 0f 00 00 call 10d068 <pthread_attr_destroy> <== NOT EXECUTED
10c0f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c0f8: e9 33 ff ff ff jmp 10c030 <rtems_aio_init+0x58> <== NOT EXECUTED
0010c448 <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
10c448: 55 push %ebp
10c449: 89 e5 mov %esp,%ebp
10c44b: 56 push %esi
10c44c: 53 push %ebx
10c44d: 8b 55 08 mov 0x8(%ebp),%edx
10c450: 8b 75 0c mov 0xc(%ebp),%esi
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c453: 8b 02 mov (%edx),%eax
10c455: 8d 4a 04 lea 0x4(%edx),%ecx
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
10c458: 39 c8 cmp %ecx,%eax
10c45a: 74 27 je 10c483 <rtems_aio_insert_prio+0x3b><== NEVER TAKEN
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
10c45c: 8b 56 14 mov 0x14(%esi),%edx
10c45f: 8b 5a 14 mov 0x14(%edx),%ebx
if (rtems_chain_is_empty (chain)) {
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
10c462: 8b 50 14 mov 0x14(%eax),%edx
while (req->aiocbp->aio_reqprio > prio &&
10c465: 39 5a 14 cmp %ebx,0x14(%edx)
10c468: 7c 06 jl 10c470 <rtems_aio_insert_prio+0x28><== NEVER TAKEN
10c46a: eb 0e jmp 10c47a <rtems_aio_insert_prio+0x32>
10c46c: 39 c8 cmp %ecx,%eax <== NOT EXECUTED
10c46e: 74 1c je 10c48c <rtems_aio_insert_prio+0x44><== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c470: 8b 00 mov (%eax),%eax <== NOT EXECUTED
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
10c472: 8b 50 14 mov 0x14(%eax),%edx <== NOT EXECUTED
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
10c475: 39 5a 14 cmp %ebx,0x14(%edx) <== NOT EXECUTED
10c478: 7c f2 jl 10c46c <rtems_aio_insert_prio+0x24><== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
10c47a: 89 75 0c mov %esi,0xc(%ebp)
10c47d: 8b 40 04 mov 0x4(%eax),%eax
10c480: 89 45 08 mov %eax,0x8(%ebp)
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
10c483: 5b pop %ebx
10c484: 5e pop %esi
10c485: c9 leave
10c486: e9 6d 24 00 00 jmp 10e8f8 <_Chain_Insert>
10c48b: 90 nop
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c48c: 89 c8 mov %ecx,%eax <== NOT EXECUTED
10c48e: eb ea jmp 10c47a <rtems_aio_insert_prio+0x32><== NOT EXECUTED
0010c1c0 <rtems_aio_move_to_work>:
* NONE
*/
void
rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
{
10c1c0: 55 push %ebp
10c1c1: 89 e5 mov %esp,%ebp
10c1c3: 83 ec 08 sub $0x8,%esp
10c1c6: 8b 4d 08 mov 0x8(%ebp),%ecx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c1c9: a1 48 aa 12 00 mov 0x12aa48,%eax
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
10c1ce: 8b 51 14 mov 0x14(%ecx),%edx
10c1d1: 39 50 14 cmp %edx,0x14(%eax)
10c1d4: 7c 09 jl 10c1df <rtems_aio_move_to_work+0x1f><== ALWAYS TAKEN
10c1d6: eb 13 jmp 10c1eb <rtems_aio_move_to_work+0x2b><== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c1d8: 8b 00 mov (%eax),%eax
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
10c1da: 39 50 14 cmp %edx,0x14(%eax)
10c1dd: 7d 0c jge 10c1eb <rtems_aio_move_to_work+0x2b>
10c1df: 3d 4c aa 12 00 cmp $0x12aa4c,%eax
10c1e4: 75 f2 jne 10c1d8 <rtems_aio_move_to_work+0x18><== ALWAYS TAKEN
10c1e6: b8 4c aa 12 00 mov $0x12aa4c,%eax <== NOT EXECUTED
10c1eb: 83 ec 08 sub $0x8,%esp
10c1ee: 51 push %ecx
10c1ef: ff 70 04 pushl 0x4(%eax)
10c1f2: e8 01 27 00 00 call 10e8f8 <_Chain_Insert>
10c1f7: 83 c4 10 add $0x10,%esp
node = rtems_chain_next (node);
temp = (rtems_aio_request_chain *) node;
}
rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd);
}
10c1fa: c9 leave
10c1fb: c3 ret
0010c490 <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
10c490: 55 push %ebp
10c491: 89 e5 mov %esp,%ebp
10c493: 57 push %edi
10c494: 56 push %esi
10c495: 53 push %ebx
10c496: 83 ec 0c sub $0xc,%esp
10c499: 8b 7d 08 mov 0x8(%ebp),%edi
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c49c: 8b 5f 08 mov 0x8(%edi),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
10c49f: 83 c7 0c add $0xc,%edi
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
10c4a2: 39 fb cmp %edi,%ebx
10c4a4: 75 04 jne 10c4aa <rtems_aio_remove_fd+0x1a><== ALWAYS TAKEN
10c4a6: eb 2d jmp 10c4d5 <rtems_aio_remove_fd+0x45><== NOT EXECUTED
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
10c4a8: 89 f3 mov %esi,%ebx
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10c4aa: 83 ec 0c sub $0xc,%esp
10c4ad: 53 push %ebx
10c4ae: e8 09 24 00 00 call 10e8bc <_Chain_Extract>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c4b3: 8b 33 mov (%ebx),%esi
while (!rtems_chain_is_tail (chain, node))
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
10c4b5: 8b 43 14 mov 0x14(%ebx),%eax
10c4b8: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax)
req->aiocbp->return_value = -1;
10c4bf: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax)
free (req);
10c4c6: 89 1c 24 mov %ebx,(%esp)
10c4c9: e8 66 c6 ff ff call 108b34 <free>
rtems_chain_control *chain;
rtems_chain_node *node;
chain = &r_chain->perfd;
node = rtems_chain_first (chain);
while (!rtems_chain_is_tail (chain, node))
10c4ce: 83 c4 10 add $0x10,%esp
10c4d1: 39 fe cmp %edi,%esi
10c4d3: 75 d3 jne 10c4a8 <rtems_aio_remove_fd+0x18>
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
free (req);
}
}
10c4d5: 8d 65 f4 lea -0xc(%ebp),%esp
10c4d8: 5b pop %ebx
10c4d9: 5e pop %esi
10c4da: 5f pop %edi
10c4db: c9 leave
10c4dc: c3 ret
0010c4e0 <rtems_aio_remove_req>:
* AIO_NOTCANCELED - if request was not canceled
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
10c4e0: 55 push %ebp
10c4e1: 89 e5 mov %esp,%ebp
10c4e3: 53 push %ebx
10c4e4: 83 ec 04 sub $0x4,%esp
10c4e7: 8b 55 08 mov 0x8(%ebp),%edx
10c4ea: 8b 4d 0c mov 0xc(%ebp),%ecx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c4ed: 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 );
10c4ef: 83 c2 04 add $0x4,%edx
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
10c4f2: 39 d0 cmp %edx,%eax
10c4f4: 74 4e je 10c544 <rtems_aio_remove_req+0x64>
return AIO_ALLDONE;
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
10c4f6: 89 c3 mov %eax,%ebx
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
10c4f8: 39 48 14 cmp %ecx,0x14(%eax)
10c4fb: 75 0a jne 10c507 <rtems_aio_remove_req+0x27><== NEVER TAKEN
10c4fd: eb 19 jmp 10c518 <rtems_aio_remove_req+0x38>
10c4ff: 90 nop
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
10c500: 89 c3 mov %eax,%ebx <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
10c502: 39 48 14 cmp %ecx,0x14(%eax) <== NOT EXECUTED
10c505: 74 11 je 10c518 <rtems_aio_remove_req+0x38><== NOT EXECUTED
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c507: 8b 00 mov (%eax),%eax <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
10c509: 39 d0 cmp %edx,%eax <== NOT EXECUTED
10c50b: 75 f3 jne 10c500 <rtems_aio_remove_req+0x20><== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
10c50d: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
10c512: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10c515: c9 leave <== NOT EXECUTED
10c516: c3 ret <== NOT EXECUTED
10c517: 90 nop <== NOT EXECUTED
10c518: 83 ec 0c sub $0xc,%esp
10c51b: 50 push %eax
10c51c: e8 9b 23 00 00 call 10e8bc <_Chain_Extract>
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
10c521: 8b 43 14 mov 0x14(%ebx),%eax
10c524: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax)
current->aiocbp->return_value = -1;
10c52b: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax)
free (current);
10c532: 89 1c 24 mov %ebx,(%esp)
10c535: e8 fa c5 ff ff call 108b34 <free>
}
return AIO_CANCELED;
10c53a: 83 c4 10 add $0x10,%esp
10c53d: 31 c0 xor %eax,%eax
}
10c53f: 8b 5d fc mov -0x4(%ebp),%ebx
10c542: c9 leave
10c543: c3 ret
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
return AIO_ALLDONE;
10c544: b8 02 00 00 00 mov $0x2,%eax
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
10c549: 8b 5d fc mov -0x4(%ebp),%ebx
10c54c: c9 leave
10c54d: c3 ret
0010c100 <rtems_aio_search_fd>:
*
*/
rtems_aio_request_chain *
rtems_aio_search_fd (rtems_chain_control *chain, int fildes, int create)
{
10c100: 55 push %ebp
10c101: 89 e5 mov %esp,%ebp
10c103: 57 push %edi
10c104: 56 push %esi
10c105: 53 push %ebx
10c106: 83 ec 1c sub $0x1c,%esp
10c109: 8b 75 08 mov 0x8(%ebp),%esi
10c10c: 8b 5d 0c mov 0xc(%ebp),%ebx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c10f: 8b 06 mov (%esi),%eax
rtems_chain_node *node;
node = rtems_chain_first (chain);
r_chain = (rtems_aio_request_chain *) node;
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
10c111: 8b 50 14 mov 0x14(%eax),%edx
10c114: 39 d3 cmp %edx,%ebx
10c116: 7e 28 jle 10c140 <rtems_aio_search_fd+0x40>
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
10c118: 8d 4e 04 lea 0x4(%esi),%ecx
10c11b: eb 0c jmp 10c129 <rtems_aio_search_fd+0x29>
10c11d: 8d 76 00 lea 0x0(%esi),%esi
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c120: 8b 00 mov (%eax),%eax
rtems_chain_node *node;
node = rtems_chain_first (chain);
r_chain = (rtems_aio_request_chain *) node;
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
10c122: 8b 50 14 mov 0x14(%eax),%edx
10c125: 39 da cmp %ebx,%edx
10c127: 7d 17 jge 10c140 <rtems_aio_search_fd+0x40>
10c129: 39 c8 cmp %ecx,%eax
10c12b: 75 f3 jne 10c120 <rtems_aio_search_fd+0x20>
10c12d: 89 c7 mov %eax,%edi
}
if (r_chain->fildes == fildes)
r_chain->new_fd = 0;
else {
if (create == 0)
10c12f: 8b 45 10 mov 0x10(%ebp),%eax
10c132: 85 c0 test %eax,%eax
10c134: 75 1f jne 10c155 <rtems_aio_search_fd+0x55>
r_chain = NULL;
10c136: 31 c0 xor %eax,%eax
r_chain->new_fd = 1;
r_chain->fildes = fildes;
}
}
return r_chain;
}
10c138: 8d 65 f4 lea -0xc(%ebp),%esp
10c13b: 5b pop %ebx
10c13c: 5e pop %esi
10c13d: 5f pop %edi
10c13e: c9 leave
10c13f: c3 ret
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c140: 89 c7 mov %eax,%edi
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
r_chain = (rtems_aio_request_chain *) node;
}
if (r_chain->fildes == fildes)
10c142: 39 d3 cmp %edx,%ebx
10c144: 75 e9 jne 10c12f <rtems_aio_search_fd+0x2f>
r_chain->new_fd = 0;
10c146: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
r_chain->new_fd = 1;
r_chain->fildes = fildes;
}
}
return r_chain;
}
10c14d: 8d 65 f4 lea -0xc(%ebp),%esp
10c150: 5b pop %ebx
10c151: 5e pop %esi
10c152: 5f pop %edi
10c153: c9 leave
10c154: c3 ret
r_chain->new_fd = 0;
else {
if (create == 0)
r_chain = NULL;
else {
r_chain = malloc (sizeof (rtems_aio_request_chain));
10c155: 83 ec 0c sub $0xc,%esp
10c158: 6a 24 push $0x24
10c15a: e8 e9 ce ff ff call 109048 <malloc>
10c15f: 89 c2 mov %eax,%edx
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 );
10c161: 8d 4a 0c lea 0xc(%edx),%ecx
10c164: 89 4a 08 mov %ecx,0x8(%edx)
head->next = tail;
head->previous = NULL;
10c167: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
10c16e: 8d 4a 08 lea 0x8(%edx),%ecx
10c171: 89 4a 10 mov %ecx,0x10(%edx)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10c174: 8d 4e 04 lea 0x4(%esi),%ecx
rtems_chain_initialize_empty (&r_chain->perfd);
if (rtems_chain_is_empty (chain))
10c177: 83 c4 10 add $0x10,%esp
10c17a: 39 0e cmp %ecx,(%esi)
10c17c: 74 27 je 10c1a5 <rtems_aio_search_fd+0xa5>
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
10c17e: 83 ec 08 sub $0x8,%esp
10c181: 52 push %edx
10c182: ff 77 04 pushl 0x4(%edi)
10c185: 89 45 e4 mov %eax,-0x1c(%ebp)
10c188: 89 55 e0 mov %edx,-0x20(%ebp)
10c18b: e8 68 27 00 00 call 10e8f8 <_Chain_Insert>
10c190: 83 c4 10 add $0x10,%esp
10c193: 8b 55 e0 mov -0x20(%ebp),%edx
10c196: 8b 45 e4 mov -0x1c(%ebp),%eax
rtems_chain_prepend (chain, &r_chain->next_fd);
else
rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd);
r_chain->new_fd = 1;
10c199: c7 42 18 01 00 00 00 movl $0x1,0x18(%edx)
r_chain->fildes = fildes;
10c1a0: 89 5a 14 mov %ebx,0x14(%edx)
10c1a3: eb a8 jmp 10c14d <rtems_aio_search_fd+0x4d>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
10c1a5: 83 ec 08 sub $0x8,%esp
10c1a8: 52 push %edx
10c1a9: 56 push %esi
10c1aa: 89 45 e4 mov %eax,-0x1c(%ebp)
10c1ad: 89 55 e0 mov %edx,-0x20(%ebp)
10c1b0: e8 43 27 00 00 call 10e8f8 <_Chain_Insert>
10c1b5: 83 c4 10 add $0x10,%esp
10c1b8: 8b 45 e4 mov -0x1c(%ebp),%eax
10c1bb: 8b 55 e0 mov -0x20(%ebp),%edx
10c1be: eb d9 jmp 10c199 <rtems_aio_search_fd+0x99>
001087ec <rtems_assoc_local_by_name>:
uint32_t rtems_assoc_local_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
1087ec: 55 push %ebp
1087ed: 89 e5 mov %esp,%ebp
1087ef: 83 ec 10 sub $0x10,%esp
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_name(ap, name);
1087f2: ff 75 0c pushl 0xc(%ebp)
1087f5: ff 75 08 pushl 0x8(%ebp)
1087f8: e8 13 02 00 00 call 108a10 <rtems_assoc_ptr_by_name>
if (nap)
1087fd: 83 c4 10 add $0x10,%esp
108800: 85 c0 test %eax,%eax
108802: 74 08 je 10880c <rtems_assoc_local_by_name+0x20>
return nap->local_value;
108804: 8b 40 04 mov 0x4(%eax),%eax
return 0;
}
108807: c9 leave
108808: c3 ret
108809: 8d 76 00 lea 0x0(%esi),%esi
nap = rtems_assoc_ptr_by_name(ap, name);
if (nap)
return nap->local_value;
return 0;
10880c: 31 c0 xor %eax,%eax
}
10880e: c9 leave
10880f: c3 ret
0010fbc0 <rtems_assoc_local_by_remote>:
uint32_t rtems_assoc_local_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
10fbc0: 55 push %ebp
10fbc1: 89 e5 mov %esp,%ebp
10fbc3: 83 ec 10 sub $0x10,%esp
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
10fbc6: ff 75 0c pushl 0xc(%ebp)
10fbc9: ff 75 08 pushl 0x8(%ebp)
10fbcc: e8 13 00 00 00 call 10fbe4 <rtems_assoc_ptr_by_remote>
if (nap)
10fbd1: 83 c4 10 add $0x10,%esp
10fbd4: 85 c0 test %eax,%eax
10fbd6: 74 08 je 10fbe0 <rtems_assoc_local_by_remote+0x20>
return nap->local_value;
10fbd8: 8b 40 04 mov 0x4(%eax),%eax
return 0;
}
10fbdb: c9 leave
10fbdc: c3 ret
10fbdd: 8d 76 00 lea 0x0(%esi),%esi
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
if (nap)
return nap->local_value;
return 0;
10fbe0: 31 c0 xor %eax,%eax
}
10fbe2: c9 leave
10fbe3: c3 ret
00112a5c <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
112a5c: 55 push %ebp
112a5d: 89 e5 mov %esp,%ebp
112a5f: 57 push %edi
112a60: 56 push %esi
112a61: 53 push %ebx
112a62: 83 ec 1c sub $0x1c,%esp
112a65: 8b 7d 0c mov 0xc(%ebp),%edi
112a68: be 20 00 00 00 mov $0x20,%esi
uint32_t b;
uint32_t local_value = 0;
112a6d: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
for (b = 1; b; b <<= 1) {
112a74: bb 01 00 00 00 mov $0x1,%ebx
112a79: eb 06 jmp 112a81 <rtems_assoc_local_by_remote_bitfield+0x25>
112a7b: 90 nop
112a7c: d1 e3 shl %ebx
112a7e: 4e dec %esi
112a7f: 74 1b je 112a9c <rtems_assoc_local_by_remote_bitfield+0x40>
if (b & remote_value)
112a81: 85 fb test %edi,%ebx
112a83: 74 f7 je 112a7c <rtems_assoc_local_by_remote_bitfield+0x20>
local_value |= rtems_assoc_local_by_remote(ap, b);
112a85: 83 ec 08 sub $0x8,%esp
112a88: 53 push %ebx
112a89: ff 75 08 pushl 0x8(%ebp)
112a8c: e8 2f d1 ff ff call 10fbc0 <rtems_assoc_local_by_remote>
112a91: 09 45 e4 or %eax,-0x1c(%ebp)
112a94: 83 c4 10 add $0x10,%esp
)
{
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
112a97: d1 e3 shl %ebx
112a99: 4e dec %esi
112a9a: 75 e5 jne 112a81 <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;
}
112a9c: 8b 45 e4 mov -0x1c(%ebp),%eax
112a9f: 8d 65 f4 lea -0xc(%ebp),%esp
112aa2: 5b pop %ebx
112aa3: 5e pop %esi
112aa4: 5f pop %edi
112aa5: c9 leave
112aa6: c3 ret
00114d04 <rtems_assoc_name_by_local>:
const char *rtems_assoc_name_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
114d04: 55 push %ebp
114d05: 89 e5 mov %esp,%ebp
114d07: 53 push %ebx
114d08: 83 ec 0c sub $0xc,%esp
114d0b: 8b 5d 0c mov 0xc(%ebp),%ebx
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
114d0e: 53 push %ebx
114d0f: ff 75 08 pushl 0x8(%ebp)
114d12: e8 1d 00 00 00 call 114d34 <rtems_assoc_ptr_by_local>
if (nap)
114d17: 83 c4 10 add $0x10,%esp
114d1a: 85 c0 test %eax,%eax
114d1c: 74 0a je 114d28 <rtems_assoc_name_by_local+0x24>
return nap->name;
114d1e: 8b 00 mov (%eax),%eax
return rtems_assoc_name_bad(local_value);
}
114d20: 8b 5d fc mov -0x4(%ebp),%ebx
114d23: c9 leave
114d24: c3 ret
114d25: 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);
114d28: 89 5d 08 mov %ebx,0x8(%ebp)
}
114d2b: 8b 5d fc mov -0x4(%ebp),%ebx
114d2e: c9 leave
nap = rtems_assoc_ptr_by_local(ap, local_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(local_value);
114d2f: e9 78 30 00 00 jmp 117dac <rtems_assoc_name_bad>
00108988 <rtems_assoc_name_by_remote>:
const char *rtems_assoc_name_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
108988: 55 push %ebp
108989: 89 e5 mov %esp,%ebp
10898b: 53 push %ebx
10898c: 83 ec 0c sub $0xc,%esp
10898f: 8b 5d 0c mov 0xc(%ebp),%ebx
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
108992: 53 push %ebx
108993: ff 75 08 pushl 0x8(%ebp)
108996: e8 ed 00 00 00 call 108a88 <rtems_assoc_ptr_by_remote>
if (nap)
10899b: 83 c4 10 add $0x10,%esp
10899e: 85 c0 test %eax,%eax
1089a0: 74 0a je 1089ac <rtems_assoc_name_by_remote+0x24>
return nap->name;
1089a2: 8b 00 mov (%eax),%eax
return rtems_assoc_name_bad(remote_value);
}
1089a4: 8b 5d fc mov -0x4(%ebp),%ebx
1089a7: c9 leave
1089a8: c3 ret
1089a9: 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);
1089ac: 89 5d 08 mov %ebx,0x8(%ebp)
}
1089af: 8b 5d fc mov -0x4(%ebp),%ebx
1089b2: c9 leave
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(remote_value);
1089b3: e9 f8 7e 00 00 jmp 1108b0 <rtems_assoc_name_bad>
00114d34 <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
114d34: 55 push %ebp
114d35: 89 e5 mov %esp,%ebp
114d37: 57 push %edi
114d38: 56 push %esi
114d39: 53 push %ebx
114d3a: 8b 45 08 mov 0x8(%ebp),%eax
114d3d: 8b 55 0c mov 0xc(%ebp),%edx
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
114d40: 8b 30 mov (%eax),%esi
114d42: 85 f6 test %esi,%esi
114d44: 74 3e je 114d84 <rtems_assoc_ptr_by_local+0x50>
114d46: bf b8 7c 12 00 mov $0x127cb8,%edi
114d4b: b9 0a 00 00 00 mov $0xa,%ecx
114d50: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
114d52: 74 18 je 114d6c <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;
114d54: 31 c9 xor %ecx,%ecx
114d56: eb 09 jmp 114d61 <rtems_assoc_ptr_by_local+0x2d>
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
114d58: 83 c0 0c add $0xc,%eax
114d5b: 8b 18 mov (%eax),%ebx
114d5d: 85 db test %ebx,%ebx
114d5f: 74 1b je 114d7c <rtems_assoc_ptr_by_local+0x48>
if (ap->local_value == local_value)
114d61: 39 50 04 cmp %edx,0x4(%eax)
114d64: 75 f2 jne 114d58 <rtems_assoc_ptr_by_local+0x24>
return ap;
return default_ap;
}
114d66: 5b pop %ebx
114d67: 5e pop %esi
114d68: 5f pop %edi
114d69: c9 leave
114d6a: c3 ret
114d6b: 90 nop
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
114d6c: 8d 58 0c lea 0xc(%eax),%ebx
for ( ; ap->name; ap++)
114d6f: 8b 70 0c mov 0xc(%eax),%esi
114d72: 85 f6 test %esi,%esi
114d74: 74 f0 je 114d66 <rtems_assoc_ptr_by_local+0x32><== NEVER TAKEN
114d76: 89 c1 mov %eax,%ecx
114d78: 89 d8 mov %ebx,%eax
114d7a: eb e5 jmp 114d61 <rtems_assoc_ptr_by_local+0x2d>
114d7c: 89 c8 mov %ecx,%eax
if (ap->local_value == local_value)
return ap;
return default_ap;
}
114d7e: 5b pop %ebx
114d7f: 5e pop %esi
114d80: 5f pop %edi
114d81: c9 leave
114d82: c3 ret
114d83: 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;
114d84: 31 c0 xor %eax,%eax
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
return ap;
return default_ap;
}
114d86: 5b pop %ebx
114d87: 5e pop %esi
114d88: 5f pop %edi
114d89: c9 leave
114d8a: c3 ret
00108a10 <rtems_assoc_ptr_by_name>:
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
108a10: 55 push %ebp
108a11: 89 e5 mov %esp,%ebp
108a13: 57 push %edi
108a14: 56 push %esi
108a15: 53 push %ebx
108a16: 83 ec 0c sub $0xc,%esp
108a19: 8b 5d 08 mov 0x8(%ebp),%ebx
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
108a1c: 8b 03 mov (%ebx),%eax
108a1e: 85 c0 test %eax,%eax
108a20: 74 5a je 108a7c <rtems_assoc_ptr_by_name+0x6c>
108a22: bf 7d 0b 12 00 mov $0x120b7d,%edi
108a27: b9 0a 00 00 00 mov $0xa,%ecx
108a2c: 89 c6 mov %eax,%esi
108a2e: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
108a30: 74 2e je 108a60 <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;
108a32: 31 f6 xor %esi,%esi
108a34: eb 0b jmp 108a41 <rtems_assoc_ptr_by_name+0x31>
108a36: 66 90 xchg %ax,%ax
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
108a38: 83 c3 0c add $0xc,%ebx
108a3b: 8b 03 mov (%ebx),%eax
108a3d: 85 c0 test %eax,%eax
108a3f: 74 2f je 108a70 <rtems_assoc_ptr_by_name+0x60>
if (strcmp(ap->name, name) == 0)
108a41: 83 ec 08 sub $0x8,%esp
108a44: ff 75 0c pushl 0xc(%ebp)
108a47: 50 push %eax
108a48: e8 8f c0 00 00 call 114adc <strcmp>
108a4d: 83 c4 10 add $0x10,%esp
108a50: 85 c0 test %eax,%eax
108a52: 75 e4 jne 108a38 <rtems_assoc_ptr_by_name+0x28>
return ap;
return default_ap;
}
108a54: 89 d8 mov %ebx,%eax
108a56: 8d 65 f4 lea -0xc(%ebp),%esp
108a59: 5b pop %ebx
108a5a: 5e pop %esi
108a5b: 5f pop %edi
108a5c: c9 leave
108a5d: c3 ret
108a5e: 66 90 xchg %ax,%ax
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
108a60: 8d 53 0c lea 0xc(%ebx),%edx
for ( ; ap->name; ap++)
108a63: 8b 43 0c mov 0xc(%ebx),%eax
108a66: 85 c0 test %eax,%eax
108a68: 74 ea je 108a54 <rtems_assoc_ptr_by_name+0x44><== NEVER TAKEN
108a6a: 89 de mov %ebx,%esi
108a6c: 89 d3 mov %edx,%ebx
108a6e: eb d1 jmp 108a41 <rtems_assoc_ptr_by_name+0x31>
108a70: 89 f3 mov %esi,%ebx
if (strcmp(ap->name, name) == 0)
return ap;
return default_ap;
}
108a72: 89 d8 mov %ebx,%eax
108a74: 8d 65 f4 lea -0xc(%ebp),%esp
108a77: 5b pop %ebx
108a78: 5e pop %esi
108a79: 5f pop %edi
108a7a: c9 leave
108a7b: 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;
108a7c: 31 db xor %ebx,%ebx
for ( ; ap->name; ap++)
if (strcmp(ap->name, name) == 0)
return ap;
return default_ap;
}
108a7e: 89 d8 mov %ebx,%eax
108a80: 8d 65 f4 lea -0xc(%ebp),%esp
108a83: 5b pop %ebx
108a84: 5e pop %esi
108a85: 5f pop %edi
108a86: c9 leave
108a87: c3 ret
0010fbe4 <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
10fbe4: 55 push %ebp
10fbe5: 89 e5 mov %esp,%ebp
10fbe7: 57 push %edi
10fbe8: 56 push %esi
10fbe9: 53 push %ebx
10fbea: 8b 45 08 mov 0x8(%ebp),%eax
10fbed: 8b 55 0c mov 0xc(%ebp),%edx
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
10fbf0: 8b 30 mov (%eax),%esi
10fbf2: 85 f6 test %esi,%esi
10fbf4: 74 3e je 10fc34 <rtems_assoc_ptr_by_remote+0x50>
10fbf6: bf 18 19 12 00 mov $0x121918,%edi
10fbfb: b9 0a 00 00 00 mov $0xa,%ecx
10fc00: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10fc02: 74 18 je 10fc1c <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;
10fc04: 31 c9 xor %ecx,%ecx
10fc06: eb 09 jmp 10fc11 <rtems_assoc_ptr_by_remote+0x2d>
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
10fc08: 83 c0 0c add $0xc,%eax
10fc0b: 8b 18 mov (%eax),%ebx
10fc0d: 85 db test %ebx,%ebx
10fc0f: 74 1b je 10fc2c <rtems_assoc_ptr_by_remote+0x48>
if (ap->remote_value == remote_value)
10fc11: 39 50 08 cmp %edx,0x8(%eax)
10fc14: 75 f2 jne 10fc08 <rtems_assoc_ptr_by_remote+0x24>
return ap;
return default_ap;
}
10fc16: 5b pop %ebx
10fc17: 5e pop %esi
10fc18: 5f pop %edi
10fc19: c9 leave
10fc1a: c3 ret
10fc1b: 90 nop
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
10fc1c: 8d 58 0c lea 0xc(%eax),%ebx
for ( ; ap->name; ap++)
10fc1f: 8b 70 0c mov 0xc(%eax),%esi
10fc22: 85 f6 test %esi,%esi
10fc24: 74 f0 je 10fc16 <rtems_assoc_ptr_by_remote+0x32><== NEVER TAKEN
10fc26: 89 c1 mov %eax,%ecx
10fc28: 89 d8 mov %ebx,%eax
10fc2a: eb e5 jmp 10fc11 <rtems_assoc_ptr_by_remote+0x2d>
10fc2c: 89 c8 mov %ecx,%eax
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
10fc2e: 5b pop %ebx
10fc2f: 5e pop %esi
10fc30: 5f pop %edi
10fc31: c9 leave
10fc32: c3 ret
10fc33: 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;
10fc34: 31 c0 xor %eax,%eax
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
10fc36: 5b pop %ebx
10fc37: 5e pop %esi
10fc38: 5f pop %edi
10fc39: c9 leave
10fc3a: c3 ret
00108b2c <rtems_assoc_remote_by_local>:
uint32_t rtems_assoc_remote_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
108b2c: 55 push %ebp
108b2d: 89 e5 mov %esp,%ebp
108b2f: 83 ec 10 sub $0x10,%esp
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
108b32: ff 75 0c pushl 0xc(%ebp)
108b35: ff 75 08 pushl 0x8(%ebp)
108b38: e8 7b fe ff ff call 1089b8 <rtems_assoc_ptr_by_local>
if (nap)
108b3d: 83 c4 10 add $0x10,%esp
108b40: 85 c0 test %eax,%eax
108b42: 74 08 je 108b4c <rtems_assoc_remote_by_local+0x20>
return nap->remote_value;
108b44: 8b 40 08 mov 0x8(%eax),%eax
return 0;
}
108b47: c9 leave
108b48: c3 ret
108b49: 8d 76 00 lea 0x0(%esi),%esi
nap = rtems_assoc_ptr_by_local(ap, local_value);
if (nap)
return nap->remote_value;
return 0;
108b4c: 31 c0 xor %eax,%eax
}
108b4e: c9 leave
108b4f: c3 ret
00108ae0 <rtems_assoc_remote_by_local_bitfield>:
uint32_t rtems_assoc_remote_by_local_bitfield(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
108ae0: 55 push %ebp
108ae1: 89 e5 mov %esp,%ebp
108ae3: 57 push %edi
108ae4: 56 push %esi
108ae5: 53 push %ebx
108ae6: 83 ec 1c sub $0x1c,%esp
108ae9: 8b 7d 0c mov 0xc(%ebp),%edi
108aec: be 20 00 00 00 mov $0x20,%esi
uint32_t b;
uint32_t remote_value = 0;
108af1: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
for (b = 1; b; b <<= 1)
108af8: bb 01 00 00 00 mov $0x1,%ebx
108afd: eb 06 jmp 108b05 <rtems_assoc_remote_by_local_bitfield+0x25>
108aff: 90 nop
108b00: d1 e3 shl %ebx
108b02: 4e dec %esi
108b03: 74 1b je 108b20 <rtems_assoc_remote_by_local_bitfield+0x40>
if (b & local_value)
108b05: 85 fb test %edi,%ebx
108b07: 74 f7 je 108b00 <rtems_assoc_remote_by_local_bitfield+0x20>
remote_value |= rtems_assoc_remote_by_local(ap, b);
108b09: 83 ec 08 sub $0x8,%esp
108b0c: 53 push %ebx
108b0d: ff 75 08 pushl 0x8(%ebp)
108b10: e8 17 00 00 00 call 108b2c <rtems_assoc_remote_by_local>
108b15: 09 45 e4 or %eax,-0x1c(%ebp)
108b18: 83 c4 10 add $0x10,%esp
)
{
uint32_t b;
uint32_t remote_value = 0;
for (b = 1; b; b <<= 1)
108b1b: d1 e3 shl %ebx
108b1d: 4e dec %esi
108b1e: 75 e5 jne 108b05 <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;
}
108b20: 8b 45 e4 mov -0x1c(%ebp),%eax
108b23: 8d 65 f4 lea -0xc(%ebp),%esp
108b26: 5b pop %ebx
108b27: 5e pop %esi
108b28: 5f pop %edi
108b29: c9 leave
108b2a: c3 ret
00108b50 <rtems_assoc_remote_by_name>:
uint32_t rtems_assoc_remote_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
108b50: 55 push %ebp
108b51: 89 e5 mov %esp,%ebp
108b53: 83 ec 10 sub $0x10,%esp
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_name(ap, name);
108b56: ff 75 0c pushl 0xc(%ebp)
108b59: ff 75 08 pushl 0x8(%ebp)
108b5c: e8 af fe ff ff call 108a10 <rtems_assoc_ptr_by_name>
if (nap)
108b61: 83 c4 10 add $0x10,%esp
108b64: 85 c0 test %eax,%eax
108b66: 74 08 je 108b70 <rtems_assoc_remote_by_name+0x20>
return nap->remote_value;
108b68: 8b 40 08 mov 0x8(%eax),%eax
return 0;
}
108b6b: c9 leave
108b6c: c3 ret
108b6d: 8d 76 00 lea 0x0(%esi),%esi
nap = rtems_assoc_ptr_by_name(ap, name);
if (nap)
return nap->remote_value;
return 0;
108b70: 31 c0 xor %eax,%eax
}
108b72: c9 leave
108b73: c3 ret
001136b4 <rtems_barrier_create>:
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
1136b4: 55 push %ebp
1136b5: 89 e5 mov %esp,%ebp
1136b7: 57 push %edi
1136b8: 56 push %esi
1136b9: 53 push %ebx
1136ba: 83 ec 2c sub $0x2c,%esp
1136bd: 8b 5d 08 mov 0x8(%ebp),%ebx
1136c0: 8b 7d 0c mov 0xc(%ebp),%edi
1136c3: 8b 45 10 mov 0x10(%ebp),%eax
1136c6: 8b 75 14 mov 0x14(%ebp),%esi
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
1136c9: 85 db test %ebx,%ebx
1136cb: 0f 84 87 00 00 00 je 113758 <rtems_barrier_create+0xa4>
return RTEMS_INVALID_NAME;
if ( !id )
1136d1: 85 f6 test %esi,%esi
1136d3: 0f 84 bf 00 00 00 je 113798 <rtems_barrier_create+0xe4><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
1136d9: f7 c7 10 00 00 00 test $0x10,%edi
1136df: 0f 84 83 00 00 00 je 113768 <rtems_barrier_create+0xb4>
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
1136e5: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
if ( maximum_waiters == 0 )
1136ec: 85 c0 test %eax,%eax
1136ee: 0f 84 80 00 00 00 je 113774 <rtems_barrier_create+0xc0><== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
the_attributes.maximum_count = maximum_waiters;
1136f4: 89 45 e4 mov %eax,-0x1c(%ebp)
1136f7: a1 90 a7 12 00 mov 0x12a790,%eax
1136fc: 40 inc %eax
1136fd: a3 90 a7 12 00 mov %eax,0x12a790
* 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 );
113702: 83 ec 0c sub $0xc,%esp
113705: 68 80 b1 12 00 push $0x12b180
11370a: e8 51 b0 ff ff call 10e760 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
11370f: 83 c4 10 add $0x10,%esp
113712: 85 c0 test %eax,%eax
113714: 74 6e je 113784 <rtems_barrier_create+0xd0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
113716: 89 78 10 mov %edi,0x10(%eax)
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
113719: 83 ec 08 sub $0x8,%esp
11371c: 8d 55 e0 lea -0x20(%ebp),%edx
11371f: 52 push %edx
113720: 8d 50 14 lea 0x14(%eax),%edx
113723: 52 push %edx
113724: 89 45 d4 mov %eax,-0x2c(%ebp)
113727: e8 c0 07 00 00 call 113eec <_CORE_barrier_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
11372c: 8b 45 d4 mov -0x2c(%ebp),%eax
11372f: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
113732: 0f b7 fa movzwl %dx,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
113735: 8b 0d 9c b1 12 00 mov 0x12b19c,%ecx
11373b: 89 04 b9 mov %eax,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
11373e: 89 58 0c mov %ebx,0xc(%eax)
&_Barrier_Information,
&the_barrier->Object,
(Objects_Name) name
);
*id = the_barrier->Object.id;
113741: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
113743: e8 74 c0 ff ff call 10f7bc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
113748: 83 c4 10 add $0x10,%esp
11374b: 31 c0 xor %eax,%eax
}
11374d: 8d 65 f4 lea -0xc(%ebp),%esp
113750: 5b pop %ebx
113751: 5e pop %esi
113752: 5f pop %edi
113753: c9 leave
113754: c3 ret
113755: 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;
113758: b8 03 00 00 00 mov $0x3,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
11375d: 8d 65 f4 lea -0xc(%ebp),%esp
113760: 5b pop %ebx
113761: 5e pop %esi
113762: 5f pop %edi
113763: c9 leave
113764: c3 ret
113765: 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;
113768: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp)
11376f: eb 83 jmp 1136f4 <rtems_barrier_create+0x40>
113771: 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;
113774: b8 0a 00 00 00 mov $0xa,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
113779: 8d 65 f4 lea -0xc(%ebp),%esp
11377c: 5b pop %ebx
11377d: 5e pop %esi
11377e: 5f pop %edi
11377f: c9 leave
113780: c3 ret
113781: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
113784: e8 33 c0 ff ff call 10f7bc <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
113789: b8 05 00 00 00 mov $0x5,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
11378e: 8d 65 f4 lea -0xc(%ebp),%esp
113791: 5b pop %ebx
113792: 5e pop %esi
113793: 5f pop %edi
113794: c9 leave
113795: c3 ret
113796: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
113798: b8 09 00 00 00 mov $0x9,%eax
11379d: eb ae jmp 11374d <rtems_barrier_create+0x99>
00107d4c <rtems_bsp_cmdline_get_param>:
const char *rtems_bsp_cmdline_get_param(
const char *name,
char *value,
size_t length
)
{
107d4c: 55 push %ebp
107d4d: 89 e5 mov %esp,%ebp
107d4f: 57 push %edi
107d50: 56 push %esi
107d51: 53 push %ebx
107d52: 83 ec 1c sub $0x1c,%esp
107d55: 8b 45 08 mov 0x8(%ebp),%eax
107d58: 8b 5d 0c mov 0xc(%ebp),%ebx
107d5b: 8b 75 10 mov 0x10(%ebp),%esi
const char *p;
if ( !name )
107d5e: 85 c0 test %eax,%eax
107d60: 75 0a jne 107d6c <rtems_bsp_cmdline_get_param+0x20>
value[0] = '\0';
p = rtems_bsp_cmdline_get_param_raw( name );
if ( !p )
return NULL;
107d62: 31 c0 xor %eax,%eax
copy_string( p, value, length );
return value;
}
107d64: 8d 65 f4 lea -0xc(%ebp),%esp
107d67: 5b pop %ebx
107d68: 5e pop %esi
107d69: 5f pop %edi
107d6a: c9 leave
107d6b: c3 ret
const char *p;
if ( !name )
return NULL;
if ( !value )
107d6c: 85 db test %ebx,%ebx
107d6e: 74 f2 je 107d62 <rtems_bsp_cmdline_get_param+0x16>
return NULL;
if ( !length )
107d70: 85 f6 test %esi,%esi
107d72: 74 ee je 107d62 <rtems_bsp_cmdline_get_param+0x16>
return NULL;
value[0] = '\0';
107d74: c6 03 00 movb $0x0,(%ebx)
p = rtems_bsp_cmdline_get_param_raw( name );
107d77: 83 ec 0c sub $0xc,%esp
107d7a: 50 push %eax
107d7b: e8 4c 00 00 00 call 107dcc <rtems_bsp_cmdline_get_param_raw>
if ( !p )
107d80: 83 c4 10 add $0x10,%esp
107d83: 85 c0 test %eax,%eax
107d85: 74 db je 107d62 <rtems_bsp_cmdline_get_param+0x16>
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
107d87: 8a 08 mov (%eax),%cl
107d89: 84 c9 test %cl,%cl
107d8b: 74 3a je 107dc7 <rtems_bsp_cmdline_get_param+0x7b><== NEVER TAKEN
107d8d: 4e dec %esi
107d8e: 89 75 e4 mov %esi,-0x1c(%ebp)
107d91: 74 34 je 107dc7 <rtems_bsp_cmdline_get_param+0x7b><== NEVER TAKEN
107d93: 31 f6 xor %esi,%esi
107d95: 31 d2 xor %edx,%edx
107d97: 31 ff xor %edi,%edi
107d99: eb 24 jmp 107dbf <rtems_bsp_cmdline_get_param+0x73>
107d9b: 90 nop
if ( *p == '\"' ) {
quotes++;
} else if ( ((quotes % 2) == 0) && *p == ' ' )
107d9c: f7 c7 01 00 00 00 test $0x1,%edi
107da2: 75 05 jne 107da9 <rtems_bsp_cmdline_get_param+0x5d>
107da4: 80 f9 20 cmp $0x20,%cl
107da7: 74 1e je 107dc7 <rtems_bsp_cmdline_get_param+0x7b>
break;
value[i++] = *p++;
107da9: 88 0c 33 mov %cl,(%ebx,%esi,1)
107dac: 42 inc %edx
value[i] = '\0';
107dad: 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; ) {
107db1: 8a 0c 10 mov (%eax,%edx,1),%cl
107db4: 84 c9 test %cl,%cl
107db6: 74 0f je 107dc7 <rtems_bsp_cmdline_get_param+0x7b>
107db8: 3b 55 e4 cmp -0x1c(%ebp),%edx
107dbb: 73 0a jae 107dc7 <rtems_bsp_cmdline_get_param+0x7b>
107dbd: 89 d6 mov %edx,%esi
if ( *p == '\"' ) {
107dbf: 80 f9 22 cmp $0x22,%cl
107dc2: 75 d8 jne 107d9c <rtems_bsp_cmdline_get_param+0x50>
quotes++;
107dc4: 47 inc %edi
107dc5: eb e2 jmp 107da9 <rtems_bsp_cmdline_get_param+0x5d>
int i;
int quotes;
const char *p = start;
quotes=0;
for (i=0 ; *p && i<length-1; ) {
107dc7: 89 d8 mov %ebx,%eax
107dc9: eb 99 jmp 107d64 <rtems_bsp_cmdline_get_param+0x18>
00107dcc <rtems_bsp_cmdline_get_param_raw>:
extern const char *bsp_boot_cmdline;
const char *rtems_bsp_cmdline_get_param_raw(
const char *name
)
{
107dcc: 55 push %ebp
107dcd: 89 e5 mov %esp,%ebp
107dcf: 83 ec 08 sub $0x8,%esp
107dd2: 8b 45 08 mov 0x8(%ebp),%eax
const char *p;
if ( !name )
107dd5: 85 c0 test %eax,%eax
107dd7: 75 07 jne 107de0 <rtems_bsp_cmdline_get_param_raw+0x14>
return NULL;
if ( !bsp_boot_cmdline )
return NULL;
107dd9: 31 c0 xor %eax,%eax
p = strstr(bsp_boot_cmdline, name);
/* printf( "raw: %p (%s)\n", p, p ); */
return p;
}
107ddb: c9 leave
107ddc: c3 ret
107ddd: 8d 76 00 lea 0x0(%esi),%esi
const char *p;
if ( !name )
return NULL;
if ( !bsp_boot_cmdline )
107de0: 8b 15 38 85 12 00 mov 0x128538,%edx
107de6: 85 d2 test %edx,%edx
107de8: 74 ef je 107dd9 <rtems_bsp_cmdline_get_param_raw+0xd>
return NULL;
p = strstr(bsp_boot_cmdline, name);
107dea: 83 ec 08 sub $0x8,%esp
107ded: 50 push %eax
107dee: 52 push %edx
107def: e8 a8 cd 00 00 call 114b9c <strstr>
107df4: 83 c4 10 add $0x10,%esp
/* printf( "raw: %p (%s)\n", p, p ); */
return p;
}
107df7: c9 leave
107df8: c3 ret
0010c140 <rtems_chain_append_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10c140: 55 push %ebp
10c141: 89 e5 mov %esp,%ebp
10c143: 56 push %esi
10c144: 53 push %ebx
10c145: 8b 5d 10 mov 0x10(%ebp),%ebx
10c148: 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 );
10c14b: 83 ec 08 sub $0x8,%esp
10c14e: ff 75 0c pushl 0xc(%ebp)
10c151: ff 75 08 pushl 0x8(%ebp)
10c154: e8 eb 04 00 00 call 10c644 <_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 ) {
10c159: 83 c4 10 add $0x10,%esp
10c15c: 84 c0 test %al,%al
10c15e: 75 0c jne 10c16c <rtems_chain_append_with_notification+0x2c><== ALWAYS TAKEN
sc = rtems_event_send( task, events );
}
return sc;
}
10c160: 31 c0 xor %eax,%eax
10c162: 8d 65 f8 lea -0x8(%ebp),%esp
10c165: 5b pop %ebx <== NOT EXECUTED
10c166: 5e pop %esi <== NOT EXECUTED
10c167: c9 leave <== NOT EXECUTED
10c168: c3 ret <== NOT EXECUTED
10c169: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
{
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 );
10c16c: 89 75 0c mov %esi,0xc(%ebp)
10c16f: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10c172: 8d 65 f8 lea -0x8(%ebp),%esp
10c175: 5b pop %ebx
10c176: 5e pop %esi
10c177: 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 );
10c178: e9 af f5 ff ff jmp 10b72c <rtems_event_send>
0010c180 <rtems_chain_get_with_notification>:
rtems_chain_control *chain,
rtems_id task,
rtems_event_set events,
rtems_chain_node **node
)
{
10c180: 55 push %ebp
10c181: 89 e5 mov %esp,%ebp
10c183: 56 push %esi
10c184: 53 push %ebx
10c185: 8b 5d 0c mov 0xc(%ebp),%ebx
10c188: 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 );
10c18b: 83 ec 08 sub $0x8,%esp
10c18e: ff 75 14 pushl 0x14(%ebp)
10c191: ff 75 08 pushl 0x8(%ebp)
10c194: e8 13 05 00 00 call 10c6ac <_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 ) {
10c199: 83 c4 10 add $0x10,%esp
10c19c: 84 c0 test %al,%al
10c19e: 75 0c jne 10c1ac <rtems_chain_get_with_notification+0x2c>
sc = rtems_event_send( task, events );
}
return sc;
}
10c1a0: 31 c0 xor %eax,%eax
10c1a2: 8d 65 f8 lea -0x8(%ebp),%esp
10c1a5: 5b pop %ebx
10c1a6: 5e pop %esi
10c1a7: c9 leave
10c1a8: c3 ret
10c1a9: 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 );
10c1ac: 89 75 0c mov %esi,0xc(%ebp)
10c1af: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10c1b2: 8d 65 f8 lea -0x8(%ebp),%esp
10c1b5: 5b pop %ebx
10c1b6: 5e pop %esi
10c1b7: 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 );
10c1b8: e9 6f f5 ff ff jmp 10b72c <rtems_event_send>
0010c1c0 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
10c1c0: 55 push %ebp
10c1c1: 89 e5 mov %esp,%ebp
10c1c3: 57 push %edi
10c1c4: 56 push %esi
10c1c5: 53 push %ebx
10c1c6: 83 ec 1c sub $0x1c,%esp
10c1c9: 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(
10c1cc: 8d 7d e4 lea -0x1c(%ebp),%edi
10c1cf: 90 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
10c1d0: 83 ec 0c sub $0xc,%esp
10c1d3: 56 push %esi
10c1d4: e8 0f 05 00 00 call 10c6e8 <_Chain_Get>
10c1d9: 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
10c1db: 83 c4 10 add $0x10,%esp
10c1de: 85 c0 test %eax,%eax
10c1e0: 75 22 jne 10c204 <rtems_chain_get_with_wait+0x44>
) {
rtems_event_set out;
sc = rtems_event_receive(
10c1e2: 57 push %edi
10c1e3: ff 75 10 pushl 0x10(%ebp)
10c1e6: 6a 00 push $0x0
10c1e8: ff 75 0c pushl 0xc(%ebp)
10c1eb: e8 b4 f3 ff ff call 10b5a4 <rtems_event_receive>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
10c1f0: 83 c4 10 add $0x10,%esp
10c1f3: 85 c0 test %eax,%eax
10c1f5: 74 d9 je 10c1d0 <rtems_chain_get_with_wait+0x10><== NEVER TAKEN
timeout,
&out
);
}
*node_ptr = node;
10c1f7: 8b 55 14 mov 0x14(%ebp),%edx
10c1fa: 89 1a mov %ebx,(%edx)
return sc;
}
10c1fc: 8d 65 f4 lea -0xc(%ebp),%esp
10c1ff: 5b pop %ebx
10c200: 5e pop %esi
10c201: 5f pop %edi
10c202: c9 leave
10c203: c3 ret
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
10c204: 31 c0 xor %eax,%eax
timeout,
&out
);
}
*node_ptr = node;
10c206: 8b 55 14 mov 0x14(%ebp),%edx
10c209: 89 1a mov %ebx,(%edx)
return sc;
}
10c20b: 8d 65 f4 lea -0xc(%ebp),%esp
10c20e: 5b pop %ebx
10c20f: 5e pop %esi
10c210: 5f pop %edi
10c211: c9 leave
10c212: c3 ret
0010c214 <rtems_chain_prepend_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10c214: 55 push %ebp
10c215: 89 e5 mov %esp,%ebp
10c217: 56 push %esi
10c218: 53 push %ebx
10c219: 8b 5d 10 mov 0x10(%ebp),%ebx
10c21c: 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 );
10c21f: 83 ec 08 sub $0x8,%esp
10c222: ff 75 0c pushl 0xc(%ebp)
10c225: ff 75 08 pushl 0x8(%ebp)
10c228: e8 ff 04 00 00 call 10c72c <_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) {
10c22d: 83 c4 10 add $0x10,%esp
10c230: 84 c0 test %al,%al
10c232: 75 0c jne 10c240 <rtems_chain_prepend_with_notification+0x2c><== ALWAYS TAKEN
sc = rtems_event_send( task, events );
}
return sc;
}
10c234: 31 c0 xor %eax,%eax
10c236: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10c239: 5b pop %ebx <== NOT EXECUTED
10c23a: 5e pop %esi <== NOT EXECUTED
10c23b: c9 leave <== NOT EXECUTED
10c23c: c3 ret <== NOT EXECUTED
10c23d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
{
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 );
10c240: 89 75 0c mov %esi,0xc(%ebp)
10c243: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10c246: 8d 65 f8 lea -0x8(%ebp),%esp
10c249: 5b pop %ebx
10c24a: 5e pop %esi
10c24b: 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 );
10c24c: e9 db f4 ff ff jmp 10b72c <rtems_event_send>
00115a60 <rtems_clock_get>:
rtems_status_code rtems_clock_get(
rtems_clock_get_options option,
void *time_buffer
)
{
115a60: 55 push %ebp
115a61: 89 e5 mov %esp,%ebp
115a63: 53 push %ebx
115a64: 83 ec 04 sub $0x4,%esp
115a67: 8b 45 08 mov 0x8(%ebp),%eax
115a6a: 8b 5d 0c mov 0xc(%ebp),%ebx
if ( !time_buffer )
115a6d: 85 db test %ebx,%ebx
115a6f: 74 3b je 115aac <rtems_clock_get+0x4c>
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
115a71: 85 c0 test %eax,%eax
115a73: 74 2b je 115aa0 <rtems_clock_get+0x40>
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
115a75: 83 f8 01 cmp $0x1,%eax
115a78: 74 3e je 115ab8 <rtems_clock_get+0x58>
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
115a7a: 83 f8 02 cmp $0x2,%eax
115a7d: 74 45 je 115ac4 <rtems_clock_get+0x64>
*interval = rtems_clock_get_ticks_since_boot();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
115a7f: 83 f8 03 cmp $0x3,%eax
115a82: 74 4c je 115ad0 <rtems_clock_get+0x70>
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
115a84: 83 f8 04 cmp $0x4,%eax
115a87: 74 0b je 115a94 <rtems_clock_get+0x34>
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
115a89: b8 0a 00 00 00 mov $0xa,%eax
}
115a8e: 5a pop %edx
115a8f: 5b pop %ebx
115a90: c9 leave
115a91: c3 ret
115a92: 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 );
115a94: 89 5d 08 mov %ebx,0x8(%ebp)
return RTEMS_INVALID_NUMBER;
}
115a97: 59 pop %ecx
115a98: 5b pop %ebx
115a99: 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 );
115a9a: e9 41 01 00 00 jmp 115be0 <rtems_clock_get_tod_timeval>
115a9f: 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 );
115aa0: 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;
}
115aa3: 58 pop %eax
115aa4: 5b pop %ebx
115aa5: 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 );
115aa6: e9 81 00 00 00 jmp 115b2c <rtems_clock_get_tod>
115aab: 90 nop
rtems_clock_get_options option,
void *time_buffer
)
{
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
115aac: 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;
}
115ab1: 5a pop %edx
115ab2: 5b pop %ebx
115ab3: c9 leave
115ab4: c3 ret
115ab5: 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);
115ab8: 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;
}
115abb: 5b pop %ebx
115abc: 5b pop %ebx
115abd: 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);
115abe: e9 19 00 00 00 jmp 115adc <rtems_clock_get_seconds_since_epoch>
115ac3: 90 nop
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_since_boot();
115ac4: e8 57 00 00 00 call 115b20 <rtems_clock_get_ticks_since_boot>
115ac9: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
115acb: 31 c0 xor %eax,%eax
115acd: eb bf jmp 115a8e <rtems_clock_get+0x2e>
115acf: 90 nop
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_per_second();
115ad0: e8 37 00 00 00 call 115b0c <rtems_clock_get_ticks_per_second>
115ad5: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
115ad7: 31 c0 xor %eax,%eax
115ad9: eb b3 jmp 115a8e <rtems_clock_get+0x2e>
00115be0 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
115be0: 55 push %ebp
115be1: 89 e5 mov %esp,%ebp
115be3: 56 push %esi
115be4: 53 push %ebx
115be5: 83 ec 10 sub $0x10,%esp
115be8: 8b 5d 08 mov 0x8(%ebp),%ebx
if ( !time )
115beb: 85 db test %ebx,%ebx
115bed: 74 51 je 115c40 <rtems_clock_get_tod_timeval+0x60>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
115bef: 80 3d 44 2a 14 00 00 cmpb $0x0,0x142a44
115bf6: 75 0c jne 115c04 <rtems_clock_get_tod_timeval+0x24>
return RTEMS_NOT_DEFINED;
115bf8: b8 0b 00 00 00 mov $0xb,%eax
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
}
115bfd: 8d 65 f8 lea -0x8(%ebp),%esp
115c00: 5b pop %ebx
115c01: 5e pop %esi
115c02: c9 leave
115c03: c3 ret
{
ISR_Level level;
struct timespec now;
suseconds_t useconds;
_ISR_Disable(level);
115c04: 9c pushf
115c05: fa cli
115c06: 5e pop %esi
_TOD_Get( &now );
115c07: 83 ec 0c sub $0xc,%esp
115c0a: 8d 45 f0 lea -0x10(%ebp),%eax
115c0d: 50 push %eax
115c0e: e8 1d 44 00 00 call 11a030 <_TOD_Get>
_ISR_Enable(level);
115c13: 56 push %esi
115c14: 9d popf
useconds = (suseconds_t)now.tv_nsec;
115c15: 8b 4d f4 mov -0xc(%ebp),%ecx
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
115c18: 8b 45 f0 mov -0x10(%ebp),%eax
115c1b: 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;
115c1d: b8 d3 4d 62 10 mov $0x10624dd3,%eax
115c22: f7 e9 imul %ecx
115c24: 89 d0 mov %edx,%eax
115c26: c1 f8 06 sar $0x6,%eax
115c29: c1 f9 1f sar $0x1f,%ecx
115c2c: 29 c8 sub %ecx,%eax
115c2e: 89 43 04 mov %eax,0x4(%ebx)
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
115c31: 83 c4 10 add $0x10,%esp
115c34: 31 c0 xor %eax,%eax
}
115c36: 8d 65 f8 lea -0x8(%ebp),%esp
115c39: 5b pop %ebx
115c3a: 5e pop %esi
115c3b: c9 leave
115c3c: c3 ret
115c3d: 8d 76 00 lea 0x0(%esi),%esi
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
if ( !time )
return RTEMS_INVALID_ADDRESS;
115c40: b8 09 00 00 00 mov $0x9,%eax
115c45: eb b6 jmp 115bfd <rtems_clock_get_tod_timeval+0x1d>
0010b1d4 <rtems_clock_get_uptime>:
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
10b1d4: 55 push %ebp
10b1d5: 89 e5 mov %esp,%ebp
10b1d7: 83 ec 08 sub $0x8,%esp
10b1da: 8b 45 08 mov 0x8(%ebp),%eax
if ( !uptime )
10b1dd: 85 c0 test %eax,%eax
10b1df: 74 13 je 10b1f4 <rtems_clock_get_uptime+0x20>
return RTEMS_INVALID_ADDRESS;
_TOD_Get_uptime_as_timespec( uptime );
10b1e1: 83 ec 0c sub $0xc,%esp
10b1e4: 50 push %eax
10b1e5: e8 76 16 00 00 call 10c860 <_TOD_Get_uptime_as_timespec>
return RTEMS_SUCCESSFUL;
10b1ea: 83 c4 10 add $0x10,%esp
10b1ed: 31 c0 xor %eax,%eax
}
10b1ef: c9 leave
10b1f0: c3 ret
10b1f1: 8d 76 00 lea 0x0(%esi),%esi
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
if ( !uptime )
return RTEMS_INVALID_ADDRESS;
10b1f4: b8 09 00 00 00 mov $0x9,%eax
_TOD_Get_uptime_as_timespec( uptime );
return RTEMS_SUCCESSFUL;
}
10b1f9: c9 leave
10b1fa: c3 ret
0010c124 <rtems_clock_set>:
*/
rtems_status_code rtems_clock_set(
rtems_time_of_day *time_buffer
)
{
10c124: 55 push %ebp
10c125: 89 e5 mov %esp,%ebp
10c127: 53 push %ebx
10c128: 83 ec 14 sub $0x14,%esp
10c12b: 8b 5d 08 mov 0x8(%ebp),%ebx
struct timespec newtime;
if ( !time_buffer )
10c12e: 85 db test %ebx,%ebx
10c130: 74 66 je 10c198 <rtems_clock_set+0x74>
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( time_buffer ) ) {
10c132: 83 ec 0c sub $0xc,%esp
10c135: 53 push %ebx
10c136: e8 39 01 00 00 call 10c274 <_TOD_Validate>
10c13b: 83 c4 10 add $0x10,%esp
10c13e: 84 c0 test %al,%al
10c140: 75 0a jne 10c14c <rtems_clock_set+0x28>
_Thread_Disable_dispatch();
_TOD_Set( &newtime );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_INVALID_CLOCK;
10c142: b8 14 00 00 00 mov $0x14,%eax
}
10c147: 8b 5d fc mov -0x4(%ebp),%ebx
10c14a: c9 leave
10c14b: c3 ret
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( time_buffer ) ) {
newtime.tv_sec = _TOD_To_seconds( time_buffer );
10c14c: 83 ec 0c sub $0xc,%esp
10c14f: 53 push %ebx
10c150: e8 93 00 00 00 call 10c1e8 <_TOD_To_seconds>
10c155: 89 45 f0 mov %eax,-0x10(%ebp)
newtime.tv_nsec = time_buffer->ticks *
10c158: 8b 43 18 mov 0x18(%ebx),%eax
10c15b: 0f af 05 6c 62 12 00 imul 0x12626c,%eax
10c162: 8d 04 80 lea (%eax,%eax,4),%eax
10c165: 8d 04 80 lea (%eax,%eax,4),%eax
10c168: 8d 04 80 lea (%eax,%eax,4),%eax
10c16b: c1 e0 03 shl $0x3,%eax
10c16e: 89 45 f4 mov %eax,-0xc(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10c171: a1 10 aa 12 00 mov 0x12aa10,%eax
10c176: 40 inc %eax
10c177: a3 10 aa 12 00 mov %eax,0x12aa10
rtems_configuration_get_nanoseconds_per_tick();
_Thread_Disable_dispatch();
_TOD_Set( &newtime );
10c17c: 8d 45 f0 lea -0x10(%ebp),%eax
10c17f: 89 04 24 mov %eax,(%esp)
10c182: e8 55 19 00 00 call 10dadc <_TOD_Set>
_Thread_Enable_dispatch();
10c187: e8 a4 2f 00 00 call 10f130 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c18c: 83 c4 10 add $0x10,%esp
10c18f: 31 c0 xor %eax,%eax
}
return RTEMS_INVALID_CLOCK;
}
10c191: 8b 5d fc mov -0x4(%ebp),%ebx
10c194: c9 leave
10c195: c3 ret
10c196: 66 90 xchg %ax,%ax
)
{
struct timespec newtime;
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
10c198: b8 09 00 00 00 mov $0x9,%eax
_TOD_Set( &newtime );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_INVALID_CLOCK;
}
10c19d: 8b 5d fc mov -0x4(%ebp),%ebx
10c1a0: c9 leave
10c1a1: c3 ret
0010afd0 <rtems_clock_tick>:
*
* NOTE: This routine only works for leap-years through 2099.
*/
rtems_status_code rtems_clock_tick( void )
{
10afd0: 55 push %ebp
10afd1: 89 e5 mov %esp,%ebp
10afd3: 83 ec 08 sub $0x8,%esp
_TOD_Tickle_ticks();
10afd6: e8 39 15 00 00 call 10c514 <_TOD_Tickle_ticks>
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void )
{
_Watchdog_Tickle( &_Watchdog_Ticks_chain );
10afdb: 83 ec 0c sub $0xc,%esp
10afde: 68 60 7e 12 00 push $0x127e60
10afe3: e8 e4 38 00 00 call 10e8cc <_Watchdog_Tickle>
_Watchdog_Tickle_ticks();
_Thread_Tickle_timeslice();
10afe8: e8 ab 33 00 00 call 10e398 <_Thread_Tickle_timeslice>
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void )
{
return ( _Thread_Dispatch_necessary );
10afed: a0 44 83 12 00 mov 0x128344,%al
if ( _Thread_Is_context_switch_necessary() &&
10aff2: 83 c4 10 add $0x10,%esp
10aff5: 84 c0 test %al,%al
10aff7: 74 09 je 10b002 <rtems_clock_tick+0x32>
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void )
{
return ( _Thread_Dispatch_disable_level == 0 );
10aff9: a1 90 7d 12 00 mov 0x127d90,%eax
10affe: 85 c0 test %eax,%eax
10b000: 74 06 je 10b008 <rtems_clock_tick+0x38>
_Thread_Is_dispatching_enabled() )
_Thread_Dispatch();
return RTEMS_SUCCESSFUL;
}
10b002: 31 c0 xor %eax,%eax
10b004: c9 leave
10b005: c3 ret
10b006: 66 90 xchg %ax,%ax
_Thread_Tickle_timeslice();
if ( _Thread_Is_context_switch_necessary() &&
_Thread_Is_dispatching_enabled() )
_Thread_Dispatch();
10b008: e8 2b 28 00 00 call 10d838 <_Thread_Dispatch>
return RTEMS_SUCCESSFUL;
}
10b00d: 31 c0 xor %eax,%eax
10b00f: c9 leave
10b010: c3 ret
00108400 <rtems_cpu_usage_report_with_plugin>:
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
108400: 55 push %ebp
108401: 89 e5 mov %esp,%ebp
108403: 57 push %edi
108404: 56 push %esi
108405: 53 push %ebx
108406: 83 ec 6c sub $0x6c,%esp
108409: 8b 7d 08 mov 0x8(%ebp),%edi
Timestamp_Control uptime, total, ran, last_context_switch;
#else
uint32_t total_units = 0;
#endif
if ( !print )
10840c: 8b 45 0c mov 0xc(%ebp),%eax
10840f: 85 c0 test %eax,%eax
108411: 0f 84 6f 01 00 00 je 108586 <rtems_cpu_usage_report_with_plugin+0x186><== 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__
last_context_switch = _Thread_Time_of_last_context_switch;
108417: a1 cc aa 12 00 mov 0x12aacc,%eax
10841c: 8b 15 d0 aa 12 00 mov 0x12aad0,%edx
108422: 89 45 c0 mov %eax,-0x40(%ebp)
108425: 89 55 c4 mov %edx,-0x3c(%ebp)
_TOD_Get_uptime( &uptime );
108428: 83 ec 0c sub $0xc,%esp
10842b: 8d 45 d8 lea -0x28(%ebp),%eax
10842e: 50 push %eax
10842f: e8 20 56 00 00 call 10da54 <_TOD_Get_uptime>
_Timestamp_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total );
108434: 83 c4 0c add $0xc,%esp
108437: 8d 55 d0 lea -0x30(%ebp),%edx
10843a: 52 push %edx
10843b: 8d 4d d8 lea -0x28(%ebp),%ecx
10843e: 51 push %ecx
10843f: 68 60 b0 12 00 push $0x12b060
108444: e8 b3 78 00 00 call 10fcfc <_Timespec_Subtract>
}
}
}
#endif
(*print)(
108449: 5b pop %ebx
10844a: 5e pop %esi
10844b: 68 30 3a 12 00 push $0x123a30
108450: 57 push %edi
108451: ff 55 0c call *0xc(%ebp)
108454: 83 c4 10 add $0x10,%esp
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
108457: c7 45 a4 01 00 00 00 movl $0x1,-0x5c(%ebp)
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
10845e: 8b 5d a4 mov -0x5c(%ebp),%ebx
108461: 8b 04 9d e8 a9 12 00 mov 0x12a9e8(,%ebx,4),%eax
108468: 8b 70 04 mov 0x4(%eax),%esi
if ( information ) {
10846b: 85 f6 test %esi,%esi
10846d: 0f 84 e9 00 00 00 je 10855c <rtems_cpu_usage_report_with_plugin+0x15c><== NEVER TAKEN
for ( i=1 ; i <= information->maximum ; i++ ) {
108473: 66 83 7e 10 00 cmpw $0x0,0x10(%esi)
108478: 0f 84 de 00 00 00 je 10855c <rtems_cpu_usage_report_with_plugin+0x15c>
10847e: bb 01 00 00 00 mov $0x1,%ebx
108483: 89 5d 94 mov %ebx,-0x6c(%ebp)
108486: eb 4a jmp 1084d2 <rtems_cpu_usage_report_with_plugin+0xd2>
108488: 8d 55 c8 lea -0x38(%ebp),%edx
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
Timestamp_Control used;
_Timestamp_Subtract( &last_context_switch, &uptime, &used );
_Timestamp_Add_to( &ran, &used );
};
_Timestamp_Divide( &ran, &total, &ival, &fval );
10848b: 8d 45 e0 lea -0x20(%ebp),%eax
10848e: 50 push %eax
10848f: 8d 4d e4 lea -0x1c(%ebp),%ecx
108492: 51 push %ecx
108493: 8d 5d d0 lea -0x30(%ebp),%ebx
108496: 53 push %ebx
108497: 52 push %edx
108498: e8 9b 77 00 00 call 10fc38 <_Timespec_Divide>
/*
* Print the information
*/
(*print)( context,
10849d: 58 pop %eax
10849e: 5a pop %edx
10849f: ff 75 e0 pushl -0x20(%ebp)
1084a2: ff 75 e4 pushl -0x1c(%ebp)
1084a5: ba d3 4d 62 10 mov $0x10624dd3,%edx
1084aa: 8b 45 cc mov -0x34(%ebp),%eax
1084ad: f7 e2 mul %edx
1084af: c1 ea 06 shr $0x6,%edx
1084b2: 52 push %edx
1084b3: ff 75 c8 pushl -0x38(%ebp)
1084b6: 68 a3 3c 12 00 push $0x123ca3
1084bb: 57 push %edi
1084bc: ff 55 0c call *0xc(%ebp)
1084bf: 83 c4 20 add $0x20,%esp
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
1084c2: ff 45 94 incl -0x6c(%ebp)
1084c5: 0f b7 46 10 movzwl 0x10(%esi),%eax
1084c9: 3b 45 94 cmp -0x6c(%ebp),%eax
1084cc: 0f 82 8a 00 00 00 jb 10855c <rtems_cpu_usage_report_with_plugin+0x15c>
the_thread = (Thread_Control *)information->local_table[ i ];
1084d2: 8b 46 1c mov 0x1c(%esi),%eax
1084d5: 8b 4d 94 mov -0x6c(%ebp),%ecx
1084d8: 8b 14 88 mov (%eax,%ecx,4),%edx
if ( !the_thread )
1084db: 85 d2 test %edx,%edx
1084dd: 74 e3 je 1084c2 <rtems_cpu_usage_report_with_plugin+0xc2><== NEVER TAKEN
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
1084df: 51 push %ecx
1084e0: 8d 5d ab lea -0x55(%ebp),%ebx
1084e3: 53 push %ebx
1084e4: 6a 0d push $0xd
1084e6: ff 72 08 pushl 0x8(%edx)
1084e9: 89 55 a0 mov %edx,-0x60(%ebp)
1084ec: e8 17 42 00 00 call 10c708 <rtems_object_get_name>
(*print)(
1084f1: 53 push %ebx
1084f2: 8b 55 a0 mov -0x60(%ebp),%edx
1084f5: ff 72 08 pushl 0x8(%edx)
1084f8: 68 90 3c 12 00 push $0x123c90
1084fd: 57 push %edi
1084fe: 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;
108501: 8b 55 a0 mov -0x60(%ebp),%edx
108504: 8b 8a 84 00 00 00 mov 0x84(%edx),%ecx
10850a: 8b 9a 88 00 00 00 mov 0x88(%edx),%ebx
108510: 89 4d c8 mov %ecx,-0x38(%ebp)
108513: 89 5d cc mov %ebx,-0x34(%ebp)
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
108516: 83 c4 20 add $0x20,%esp
108519: a1 f8 af 12 00 mov 0x12aff8,%eax
10851e: 8b 5a 08 mov 0x8(%edx),%ebx
108521: 39 58 08 cmp %ebx,0x8(%eax)
108524: 0f 85 5e ff ff ff jne 108488 <rtems_cpu_usage_report_with_plugin+0x88>
Timestamp_Control used;
_Timestamp_Subtract( &last_context_switch, &uptime, &used );
10852a: 50 push %eax
10852b: 8d 45 b8 lea -0x48(%ebp),%eax
10852e: 50 push %eax
10852f: 8d 55 d8 lea -0x28(%ebp),%edx
108532: 52 push %edx
108533: 8d 4d c0 lea -0x40(%ebp),%ecx
108536: 51 push %ecx
108537: e8 c0 77 00 00 call 10fcfc <_Timespec_Subtract>
_Timestamp_Add_to( &ran, &used );
10853c: 59 pop %ecx
10853d: 5b pop %ebx
10853e: 8d 5d b8 lea -0x48(%ebp),%ebx
108541: 53 push %ebx
108542: 8d 55 c8 lea -0x38(%ebp),%edx
108545: 52 push %edx
108546: 89 55 a0 mov %edx,-0x60(%ebp)
108549: e8 ae 76 00 00 call 10fbfc <_Timespec_Add_to>
10854e: 83 c4 10 add $0x10,%esp
108551: 8b 55 a0 mov -0x60(%ebp),%edx
108554: e9 32 ff ff ff jmp 10848b <rtems_cpu_usage_report_with_plugin+0x8b>
108559: 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++ ) {
10855c: ff 45 a4 incl -0x5c(%ebp)
10855f: 83 7d a4 04 cmpl $0x4,-0x5c(%ebp)
108563: 0f 85 f5 fe ff ff jne 10845e <rtems_cpu_usage_report_with_plugin+0x5e>
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)(
108569: ba d3 4d 62 10 mov $0x10624dd3,%edx
10856e: 8b 45 d4 mov -0x2c(%ebp),%eax
108571: f7 e2 mul %edx
108573: c1 ea 06 shr $0x6,%edx
108576: 52 push %edx
108577: ff 75 d0 pushl -0x30(%ebp)
10857a: 68 a4 3b 12 00 push $0x123ba4
10857f: 57 push %edi
108580: ff 55 0c call *0xc(%ebp)
108583: 83 c4 10 add $0x10,%esp
"-------------------------------------------------------------------------------\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,
total_units
);
#endif
}
108586: 8d 65 f4 lea -0xc(%ebp),%esp
108589: 5b pop %ebx
10858a: 5e pop %esi
10858b: 5f pop %edi
10858c: c9 leave
10858d: c3 ret
001131e4 <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
1131e4: 55 push %ebp
1131e5: 89 e5 mov %esp,%ebp
1131e7: 53 push %ebx
1131e8: 83 ec 04 sub $0x4,%esp
1131eb: 8b 45 08 mov 0x8(%ebp),%eax
if (sc == RTEMS_SUCCESSFUL) {
1131ee: 85 c0 test %eax,%eax
1131f0: 75 06 jne 1131f8 <rtems_deviceio_errno+0x14>
return 0;
1131f2: 31 c0 xor %eax,%eax
errno = eno;
return -1;
}
}
1131f4: 5a pop %edx
1131f5: 5b pop %ebx
1131f6: c9 leave
1131f7: c3 ret
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
1131f8: 83 f8 1c cmp $0x1c,%eax
1131fb: 77 17 ja 113214 <rtems_deviceio_errno+0x30><== NEVER TAKEN
eno = status_code_to_errno [sc];
1131fd: 8b 1c 85 c0 1b 12 00 mov 0x121bc0(,%eax,4),%ebx
}
errno = eno;
113204: e8 67 00 00 00 call 113270 <__errno>
113209: 89 18 mov %ebx,(%eax)
return -1;
11320b: b8 ff ff ff ff mov $0xffffffff,%eax
113210: eb e2 jmp 1131f4 <rtems_deviceio_errno+0x10>
113212: 66 90 xchg %ax,%ax
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
113214: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED
113219: eb e9 jmp 113204 <rtems_deviceio_errno+0x20><== NOT EXECUTED
0010b19c <rtems_event_send>:
rtems_status_code rtems_event_send(
rtems_id id,
rtems_event_set event_in
)
{
10b19c: 55 push %ebp
10b19d: 89 e5 mov %esp,%ebp
10b19f: 53 push %ebx
10b1a0: 83 ec 1c sub $0x1c,%esp
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
the_thread = _Thread_Get( id, &location );
10b1a3: 8d 45 f4 lea -0xc(%ebp),%eax
10b1a6: 50 push %eax
10b1a7: ff 75 08 pushl 0x8(%ebp)
10b1aa: e8 25 28 00 00 call 10d9d4 <_Thread_Get>
switch ( location ) {
10b1af: 83 c4 10 add $0x10,%esp
10b1b2: 8b 55 f4 mov -0xc(%ebp),%edx
10b1b5: 85 d2 test %edx,%edx
10b1b7: 75 2b jne 10b1e4 <rtems_event_send+0x48>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
10b1b9: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx
rtems_event_set *the_event_set
)
{
ISR_Level level;
_ISR_Disable( level );
10b1bf: 9c pushf
10b1c0: fa cli
10b1c1: 59 pop %ecx
*the_event_set |= the_new_events;
10b1c2: 8b 5d 0c mov 0xc(%ebp),%ebx
10b1c5: 09 1a or %ebx,(%edx)
_ISR_Enable( level );
10b1c7: 51 push %ecx
10b1c8: 9d popf
_Event_sets_Post( event_in, &api->pending_events );
_Event_Surrender( the_thread );
10b1c9: 83 ec 0c sub $0xc,%esp
10b1cc: 50 push %eax
10b1cd: e8 1e 00 00 00 call 10b1f0 <_Event_Surrender>
_Thread_Enable_dispatch();
10b1d2: e8 d9 27 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b1d7: 83 c4 10 add $0x10,%esp
10b1da: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b1dc: 8b 5d fc mov -0x4(%ebp),%ebx
10b1df: c9 leave
10b1e0: c3 ret
10b1e1: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b1e4: b8 04 00 00 00 mov $0x4,%eax
}
10b1e9: 8b 5d fc mov -0x4(%ebp),%ebx
10b1ec: c9 leave
10b1ed: c3 ret
0010d000 <rtems_extension_delete>:
#include <rtems/extension.h>
rtems_status_code rtems_extension_delete(
rtems_id id
)
{
10d000: 55 push %ebp
10d001: 89 e5 mov %esp,%ebp
10d003: 53 push %ebx
10d004: 83 ec 18 sub $0x18,%esp
Extension_Control *the_extension;
Objects_Locations location;
the_extension = _Extension_Get( id, &location );
10d007: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Extension_Control *)
_Objects_Get( &_Extension_Information, id, location );
10d00a: 50 push %eax
10d00b: ff 75 08 pushl 0x8(%ebp)
10d00e: 68 20 b6 12 00 push $0x12b620
10d013: e8 28 12 00 00 call 10e240 <_Objects_Get>
10d018: 89 c3 mov %eax,%ebx
switch ( location ) {
10d01a: 83 c4 10 add $0x10,%esp
10d01d: 8b 55 f4 mov -0xc(%ebp),%edx
10d020: 85 d2 test %edx,%edx
10d022: 75 38 jne 10d05c <rtems_extension_delete+0x5c>
case OBJECTS_LOCAL:
_User_extensions_Remove_set( &the_extension->Extension );
10d024: 83 ec 0c sub $0xc,%esp
10d027: 8d 40 10 lea 0x10(%eax),%eax
10d02a: 50 push %eax
10d02b: e8 d0 29 00 00 call 10fa00 <_User_extensions_Remove_set>
_Objects_Close( &_Extension_Information, &the_extension->Object );
10d030: 59 pop %ecx
10d031: 58 pop %eax
10d032: 53 push %ebx
10d033: 68 20 b6 12 00 push $0x12b620
10d038: e8 cb 0d 00 00 call 10de08 <_Objects_Close>
RTEMS_INLINE_ROUTINE void _Extension_Free (
Extension_Control *the_extension
)
{
_Objects_Free( &_Extension_Information, &the_extension->Object );
10d03d: 58 pop %eax
10d03e: 5a pop %edx
10d03f: 53 push %ebx
10d040: 68 20 b6 12 00 push $0x12b620
10d045: e8 b6 10 00 00 call 10e100 <_Objects_Free>
_Extension_Free( the_extension );
_Thread_Enable_dispatch();
10d04a: e8 69 1d 00 00 call 10edb8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10d04f: 83 c4 10 add $0x10,%esp
10d052: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d054: 8b 5d fc mov -0x4(%ebp),%ebx
10d057: c9 leave
10d058: c3 ret
10d059: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10d05c: b8 04 00 00 00 mov $0x4,%eax
}
10d061: 8b 5d fc mov -0x4(%ebp),%ebx
10d064: c9 leave
10d065: c3 ret
0010800c <rtems_filesystem_dirname>:
int rtems_filesystem_dirname(
const char *pathname
)
{
10800c: 55 push %ebp
10800d: 89 e5 mov %esp,%ebp
10800f: 57 push %edi
108010: 56 push %esi
108011: 53 push %ebx
108012: 83 ec 0c sub $0xc,%esp
108015: 8b 5d 08 mov 0x8(%ebp),%ebx
int len = strlen( pathname );
108018: 31 c0 xor %eax,%eax
10801a: b9 ff ff ff ff mov $0xffffffff,%ecx
10801f: 89 df mov %ebx,%edi
108021: f2 ae repnz scas %es:(%edi),%al
108023: f7 d1 not %ecx
while ( len ) {
108025: 89 ce mov %ecx,%esi
108027: 4e dec %esi
108028: 75 06 jne 108030 <rtems_filesystem_dirname+0x24><== ALWAYS TAKEN
10802a: eb 19 jmp 108045 <rtems_filesystem_dirname+0x39><== NOT EXECUTED
10802c: 85 f6 test %esi,%esi
10802e: 74 15 je 108045 <rtems_filesystem_dirname+0x39>
len--;
108030: 4e dec %esi
if ( rtems_filesystem_is_separator( pathname[len] ) )
108031: 83 ec 0c sub $0xc,%esp
108034: 0f be 04 33 movsbl (%ebx,%esi,1),%eax
108038: 50 push %eax
108039: e8 da 0e 00 00 call 108f18 <rtems_filesystem_is_separator>
10803e: 83 c4 10 add $0x10,%esp
108041: 85 c0 test %eax,%eax
108043: 74 e7 je 10802c <rtems_filesystem_dirname+0x20>
break;
}
return len;
}
108045: 89 f0 mov %esi,%eax
108047: 8d 65 f4 lea -0xc(%ebp),%esp
10804a: 5b pop %ebx
10804b: 5e pop %esi
10804c: 5f pop %edi
10804d: c9 leave
10804e: c3 ret
001100ac <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
1100ac: 55 push %ebp
1100ad: 89 e5 mov %esp,%ebp
1100af: 83 ec 18 sub $0x18,%esp
1100b2: 8b 45 08 mov 0x8(%ebp),%eax
find_arg fa = {
1100b5: 89 45 f0 mov %eax,-0x10(%ebp)
1100b8: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
1100bf: 85 c0 test %eax,%eax
1100c1: 74 19 je 1100dc <rtems_filesystem_get_mount_handler+0x30><== NEVER TAKEN
rtems_filesystem_iterate( find_handler, &fa );
1100c3: 83 ec 08 sub $0x8,%esp
1100c6: 8d 45 f0 lea -0x10(%ebp),%eax
1100c9: 50 push %eax
1100ca: 68 cc ff 10 00 push $0x10ffcc
1100cf: e8 34 ff ff ff call 110008 <rtems_filesystem_iterate>
1100d4: 8b 45 f4 mov -0xc(%ebp),%eax
1100d7: 83 c4 10 add $0x10,%esp
}
return fa.mount_h;
}
1100da: c9 leave
1100db: c3 ret
find_arg fa = {
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
1100dc: 31 c0 xor %eax,%eax
rtems_filesystem_iterate( find_handler, &fa );
}
return fa.mount_h;
}
1100de: c9 leave <== NOT EXECUTED
1100df: c3 ret <== NOT EXECUTED
00110268 <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)
{
110268: 55 push %ebp
110269: 89 e5 mov %esp,%ebp
11026b: 57 push %edi
11026c: 56 push %esi
11026d: 53 push %ebx
11026e: 83 ec 18 sub $0x18,%esp
110271: 8b 5d 0c mov 0xc(%ebp),%ebx
if (rtems_filesystem_is_separator(path[0])) {
110274: 8b 45 08 mov 0x8(%ebp),%eax
110277: 0f be 00 movsbl (%eax),%eax
11027a: 50 push %eax
11027b: e8 98 8c ff ff call 108f18 <rtems_filesystem_is_separator>
110280: 83 c4 10 add $0x10,%esp
110283: 85 c0 test %eax,%eax
110285: 75 11 jne 110298 <rtems_filesystem_get_sym_start_loc+0x30>
*loc = rtems_filesystem_root;
*index = 1;
}
else {
*index = 0;
110287: c7 03 00 00 00 00 movl $0x0,(%ebx)
}
}
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
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;
110298: 8b 35 90 59 12 00 mov 0x125990,%esi
11029e: 83 c6 18 add $0x18,%esi
1102a1: b9 05 00 00 00 mov $0x5,%ecx
1102a6: 8b 7d 10 mov 0x10(%ebp),%edi
1102a9: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*index = 1;
1102ab: c7 03 01 00 00 00 movl $0x1,(%ebx)
}
else {
*index = 0;
}
}
1102b1: 8d 65 f4 lea -0xc(%ebp),%esp
1102b4: 5b pop %ebx
1102b5: 5e pop %esi
1102b6: 5f pop %edi
1102b7: c9 leave
1102b8: c3 ret
00107e3c <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 )
{
107e3c: 55 push %ebp
107e3d: 89 e5 mov %esp,%ebp
107e3f: 57 push %edi
107e40: 56 push %esi
107e41: 53 push %ebx
107e42: 83 ec 2c sub $0x2c,%esp
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
107e45: a1 90 59 12 00 mov 0x125990,%eax
107e4a: c7 40 2c 12 00 00 00 movl $0x12,0x2c(%eax)
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
107e51: a1 20 f9 11 00 mov 0x11f920,%eax
107e56: 85 c0 test %eax,%eax
107e58: 0f 84 9f 00 00 00 je 107efd <rtems_filesystem_initialize+0xc1><== NEVER TAKEN
rtems_fatal_error_occurred( 0xABCD0001 );
mt = &rtems_filesystem_mount_table[0];
107e5e: a1 74 39 12 00 mov 0x123974,%eax
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
107e63: 83 ec 0c sub $0xc,%esp
107e66: 6a 00 push $0x0
107e68: ff 70 04 pushl 0x4(%eax)
107e6b: ff 30 pushl (%eax)
107e6d: ff 70 0c pushl 0xc(%eax)
107e70: ff 70 08 pushl 0x8(%eax)
107e73: e8 fc 06 00 00 call 108574 <mount>
if ( status == -1 )
107e78: 83 c4 20 add $0x20,%esp
107e7b: 40 inc %eax
107e7c: 0f 84 95 00 00 00 je 107f17 <rtems_filesystem_initialize+0xdb><== NEVER TAKEN
rtems_fatal_error_occurred( 0xABCD0002 );
rtems_filesystem_link_counts = 0;
107e82: a1 90 59 12 00 mov 0x125990,%eax
107e87: 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);
107e8d: 83 ec 0c sub $0xc,%esp
107e90: 6a 00 push $0x0
107e92: 8d 5d d4 lea -0x2c(%ebp),%ebx
107e95: 53 push %ebx
107e96: 6a 00 push $0x0
107e98: 6a 01 push $0x1
107e9a: 68 07 13 12 00 push $0x121307
107e9f: e8 24 01 00 00 call 107fc8 <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
107ea4: 8b 3d 90 59 12 00 mov 0x125990,%edi
107eaa: 83 c7 18 add $0x18,%edi
107ead: b9 05 00 00 00 mov $0x5,%ecx
107eb2: 89 de mov %ebx,%esi
107eb4: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
107eb6: 83 c4 14 add $0x14,%esp
107eb9: 6a 00 push $0x0
107ebb: 53 push %ebx
107ebc: 6a 00 push $0x0
107ebe: 6a 01 push $0x1
107ec0: 68 07 13 12 00 push $0x121307
107ec5: e8 fe 00 00 00 call 107fc8 <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
107eca: 8b 3d 90 59 12 00 mov 0x125990,%edi
107ed0: 83 c7 04 add $0x4,%edi
107ed3: b9 05 00 00 00 mov $0x5,%ecx
107ed8: 89 de mov %ebx,%esi
107eda: 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);
107edc: 83 c4 18 add $0x18,%esp
107edf: 68 ff 01 00 00 push $0x1ff
107ee4: 68 09 13 12 00 push $0x121309
107ee9: e8 42 05 00 00 call 108430 <mkdir>
if ( status != 0 )
107eee: 83 c4 10 add $0x10,%esp
107ef1: 85 c0 test %eax,%eax
107ef3: 75 15 jne 107f0a <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.
*/
}
107ef5: 8d 65 f4 lea -0xc(%ebp),%esp
107ef8: 5b pop %ebx
107ef9: 5e pop %esi
107efa: 5f pop %edi
107efb: c9 leave
107efc: c3 ret
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
rtems_fatal_error_occurred( 0xABCD0001 );
107efd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107f00: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED
107f05: e8 ea 3d 00 00 call 10bcf4 <rtems_fatal_error_occurred><== NOT EXECUTED
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
if ( status != 0 )
rtems_fatal_error_occurred( 0xABCD0003 );
107f0a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107f0d: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED
107f12: e8 dd 3d 00 00 call 10bcf4 <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 );
107f17: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107f1a: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED
107f1f: e8 d0 3d 00 00 call 10bcf4 <rtems_fatal_error_occurred><== NOT EXECUTED
00110008 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
110008: 55 push %ebp
110009: 89 e5 mov %esp,%ebp
11000b: 57 push %edi
11000c: 56 push %esi
11000d: 53 push %ebx
11000e: 83 ec 1c sub $0x1c,%esp
110011: 8b 75 08 mov 0x8(%ebp),%esi
110014: 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 ) {
110017: 8b 1d 00 f9 11 00 mov 0x11f900,%ebx
11001d: 85 db test %ebx,%ebx
11001f: 74 24 je 110045 <rtems_filesystem_iterate+0x3d><== NEVER TAKEN
110021: bb 00 f9 11 00 mov $0x11f900,%ebx
110026: eb 04 jmp 11002c <rtems_filesystem_iterate+0x24>
110028: 84 c0 test %al,%al
11002a: 75 70 jne 11009c <rtems_filesystem_iterate+0x94>
stop = (*routine)( table_entry, routine_arg );
11002c: 83 ec 08 sub $0x8,%esp
11002f: 57 push %edi
110030: 53 push %ebx
110031: ff d6 call *%esi
110033: 88 c2 mov %al,%dl
++table_entry;
110035: 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 ) {
110038: 83 c4 10 add $0x10,%esp
11003b: 8b 0b mov (%ebx),%ecx
11003d: 85 c9 test %ecx,%ecx
11003f: 75 e7 jne 110028 <rtems_filesystem_iterate+0x20>
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
110041: 84 c0 test %al,%al
110043: 75 57 jne 11009c <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 );
110045: 50 push %eax
110046: 6a 00 push $0x0
110048: 6a 00 push $0x0
11004a: ff 35 28 7c 12 00 pushl 0x127c28
110050: e8 5b b6 ff ff call 10b6b0 <rtems_semaphore_obtain>
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
110055: 8b 1d b8 59 12 00 mov 0x1259b8,%ebx
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
11005b: 83 c4 10 add $0x10,%esp
11005e: 81 fb bc 59 12 00 cmp $0x1259bc,%ebx
110064: 75 06 jne 11006c <rtems_filesystem_iterate+0x64>
110066: eb 3e jmp 1100a6 <rtems_filesystem_iterate+0x9e>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
110068: 84 c0 test %al,%al
11006a: 75 19 jne 110085 <rtems_filesystem_iterate+0x7d><== NEVER TAKEN
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
11006c: 83 ec 08 sub $0x8,%esp
11006f: 57 push %edi
110070: 8d 43 08 lea 0x8(%ebx),%eax
110073: 50 push %eax
110074: ff d6 call *%esi
110076: 88 c2 mov %al,%dl
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
110078: 8b 1b mov (%ebx),%ebx
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
11007a: 83 c4 10 add $0x10,%esp
11007d: 81 fb bc 59 12 00 cmp $0x1259bc,%ebx
110083: 75 e3 jne 110068 <rtems_filesystem_iterate+0x60>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
110085: 83 ec 0c sub $0xc,%esp
110088: ff 35 28 7c 12 00 pushl 0x127c28
11008e: 88 55 e4 mov %dl,-0x1c(%ebp)
110091: e8 16 b7 ff ff call 10b7ac <rtems_semaphore_release>
110096: 83 c4 10 add $0x10,%esp
110099: 8a 55 e4 mov -0x1c(%ebp),%dl
}
rtems_libio_unlock();
}
return stop;
}
11009c: 88 d0 mov %dl,%al
11009e: 8d 65 f4 lea -0xc(%ebp),%esp
1100a1: 5b pop %ebx
1100a2: 5e pop %esi
1100a3: 5f pop %edi
1100a4: c9 leave
1100a5: c3 ret
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
1100a6: 31 d2 xor %edx,%edx
1100a8: eb db jmp 110085 <rtems_filesystem_iterate+0x7d>
00108504 <rtems_filesystem_mount_iterate>:
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
108504: 55 push %ebp
108505: 89 e5 mov %esp,%ebp
108507: 57 push %edi
108508: 56 push %esi
108509: 53 push %ebx
10850a: 83 ec 20 sub $0x20,%esp
10850d: 8b 75 08 mov 0x8(%ebp),%esi
108510: 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 );
108513: 6a 00 push $0x0
108515: 6a 00 push $0x0
108517: ff 35 28 7c 12 00 pushl 0x127c28
10851d: e8 8e 31 00 00 call 10b6b0 <rtems_semaphore_obtain>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
108522: 8b 1d 64 58 12 00 mov 0x125864,%ebx
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
108528: 83 c4 10 add $0x10,%esp
10852b: 81 fb 68 58 12 00 cmp $0x125868,%ebx
108531: 75 09 jne 10853c <rtems_filesystem_mount_iterate+0x38><== ALWAYS TAKEN
108533: eb 3b jmp 108570 <rtems_filesystem_mount_iterate+0x6c><== NOT EXECUTED
108535: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
108538: 84 c0 test %al,%al
10853a: 75 16 jne 108552 <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 );
10853c: 83 ec 08 sub $0x8,%esp
10853f: 57 push %edi
108540: 53 push %ebx
108541: ff d6 call *%esi
108543: 88 c2 mov %al,%dl
}
rtems_libio_unlock();
return stop;
}
108545: 8b 1b mov (%ebx),%ebx
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
108547: 83 c4 10 add $0x10,%esp
10854a: 81 fb 68 58 12 00 cmp $0x125868,%ebx
108550: 75 e6 jne 108538 <rtems_filesystem_mount_iterate+0x34>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
108552: 83 ec 0c sub $0xc,%esp
108555: ff 35 28 7c 12 00 pushl 0x127c28
10855b: 88 55 e4 mov %dl,-0x1c(%ebp)
10855e: e8 49 32 00 00 call 10b7ac <rtems_semaphore_release>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
108563: 8a 55 e4 mov -0x1c(%ebp),%dl
108566: 88 d0 mov %dl,%al
108568: 8d 65 f4 lea -0xc(%ebp),%esp
10856b: 5b pop %ebx
10856c: 5e pop %esi
10856d: 5f pop %edi
10856e: c9 leave
10856f: c3 ret
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
rtems_chain_node *node = NULL;
bool stop = false;
108570: 31 d2 xor %edx,%edx <== NOT EXECUTED
108572: eb de jmp 108552 <rtems_filesystem_mount_iterate+0x4e><== NOT EXECUTED
00108050 <rtems_filesystem_prefix_separators>:
int rtems_filesystem_prefix_separators(
const char *pathname,
int pathnamelen
)
{
108050: 55 push %ebp
108051: 89 e5 mov %esp,%ebp
108053: 57 push %edi
108054: 56 push %esi
108055: 53 push %ebx
108056: 83 ec 0c sub $0xc,%esp
108059: 8b 75 08 mov 0x8(%ebp),%esi
10805c: 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 ) )
10805f: 8a 06 mov (%esi),%al
108061: 84 c0 test %al,%al
108063: 74 34 je 108099 <rtems_filesystem_prefix_separators+0x49><== NEVER TAKEN
108065: 85 ff test %edi,%edi
108067: 74 30 je 108099 <rtems_filesystem_prefix_separators+0x49><== NEVER TAKEN
108069: 31 db xor %ebx,%ebx
10806b: eb 0f jmp 10807c <rtems_filesystem_prefix_separators+0x2c>
10806d: 8d 76 00 lea 0x0(%esi),%esi
{
pathname++;
pathnamelen--;
stripped++;
108070: 43 inc %ebx
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
108071: 8a 04 1e mov (%esi,%ebx,1),%al
108074: 84 c0 test %al,%al
108076: 74 17 je 10808f <rtems_filesystem_prefix_separators+0x3f><== NEVER TAKEN
108078: 39 df cmp %ebx,%edi
10807a: 74 13 je 10808f <rtems_filesystem_prefix_separators+0x3f><== NEVER TAKEN
10807c: 83 ec 0c sub $0xc,%esp
10807f: 0f be c0 movsbl %al,%eax
108082: 50 push %eax
108083: e8 90 0e 00 00 call 108f18 <rtems_filesystem_is_separator>
108088: 83 c4 10 add $0x10,%esp
10808b: 85 c0 test %eax,%eax
10808d: 75 e1 jne 108070 <rtems_filesystem_prefix_separators+0x20>
pathname++;
pathnamelen--;
stripped++;
}
return stripped;
}
10808f: 89 d8 mov %ebx,%eax
108091: 8d 65 f4 lea -0xc(%ebp),%esp
108094: 5b pop %ebx
108095: 5e pop %esi
108096: 5f pop %edi
108097: c9 leave
108098: c3 ret
)
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
108099: 31 db xor %ebx,%ebx
10809b: eb f2 jmp 10808f <rtems_filesystem_prefix_separators+0x3f><== NOT EXECUTED
001100e0 <rtems_filesystem_register>:
int
rtems_filesystem_register(
const char *type,
rtems_filesystem_fsmount_me_t mount_h
)
{
1100e0: 55 push %ebp
1100e1: 89 e5 mov %esp,%ebp
1100e3: 57 push %edi
1100e4: 56 push %esi
1100e5: 53 push %ebx
1100e6: 83 ec 28 sub $0x28,%esp
size_t type_size = strlen(type) + 1;
1100e9: 31 c0 xor %eax,%eax
1100eb: b9 ff ff ff ff mov $0xffffffff,%ecx
1100f0: 8b 7d 08 mov 0x8(%ebp),%edi
1100f3: f2 ae repnz scas %es:(%edi),%al
1100f5: f7 d1 not %ecx
size_t fsn_size = sizeof( filesystem_node ) + type_size;
1100f7: 8d 41 10 lea 0x10(%ecx),%eax
filesystem_node *fsn = malloc( fsn_size );
1100fa: 50 push %eax
1100fb: 89 4d e4 mov %ecx,-0x1c(%ebp)
1100fe: e8 85 82 ff ff call 108388 <malloc>
110103: 89 c3 mov %eax,%ebx
char *type_storage = (char *) fsn + sizeof( *fsn );
if ( fsn == NULL )
110105: 83 c4 10 add $0x10,%esp
110108: 85 c0 test %eax,%eax
11010a: 8b 4d e4 mov -0x1c(%ebp),%ecx
11010d: 0f 84 8e 00 00 00 je 1101a1 <rtems_filesystem_register+0xc1>
)
{
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 );
110113: 8d 40 10 lea 0x10(%eax),%eax
if ( fsn == NULL )
rtems_set_errno_and_return_minus_one( ENOMEM );
memcpy(type_storage, type, type_size);
110116: 89 c7 mov %eax,%edi
110118: 8b 75 08 mov 0x8(%ebp),%esi
11011b: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
fsn->entry.type = type_storage;
11011d: 89 43 08 mov %eax,0x8(%ebx)
fsn->entry.mount_h = mount_h;
110120: 8b 45 0c mov 0xc(%ebp),%eax
110123: 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 );
110126: 50 push %eax
110127: 6a 00 push $0x0
110129: 6a 00 push $0x0
11012b: ff 35 28 7c 12 00 pushl 0x127c28
110131: e8 7a b5 ff ff call 10b6b0 <rtems_semaphore_obtain>
rtems_libio_lock();
if ( rtems_filesystem_get_mount_handler( type ) == NULL ) {
110136: 5f pop %edi
110137: ff 75 08 pushl 0x8(%ebp)
11013a: e8 6d ff ff ff call 1100ac <rtems_filesystem_get_mount_handler>
11013f: 83 c4 10 add $0x10,%esp
110142: 85 c0 test %eax,%eax
110144: 75 2a jne 110170 <rtems_filesystem_register+0x90>
110146: 83 ec 08 sub $0x8,%esp
110149: 53 push %ebx
11014a: 68 b8 59 12 00 push $0x1259b8
11014f: e8 84 be ff ff call 10bfd8 <_Chain_Append>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
110154: 5e pop %esi
110155: ff 35 28 7c 12 00 pushl 0x127c28
11015b: e8 4c b6 ff ff call 10b7ac <rtems_semaphore_release>
110160: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_unlock();
return 0;
110163: 31 c0 xor %eax,%eax
}
110165: 8d 65 f4 lea -0xc(%ebp),%esp
110168: 5b pop %ebx
110169: 5e pop %esi
11016a: 5f pop %edi
11016b: c9 leave
11016c: c3 ret
11016d: 8d 76 00 lea 0x0(%esi),%esi
110170: 83 ec 0c sub $0xc,%esp
110173: ff 35 28 7c 12 00 pushl 0x127c28
110179: e8 2e b6 ff ff call 10b7ac <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 );
11017e: 89 1c 24 mov %ebx,(%esp)
110181: e8 2e 7f ff ff call 1080b4 <free>
rtems_set_errno_and_return_minus_one( EINVAL );
110186: e8 e5 30 00 00 call 113270 <__errno>
11018b: c7 00 16 00 00 00 movl $0x16,(%eax)
110191: 83 c4 10 add $0x10,%esp
110194: b8 ff ff ff ff mov $0xffffffff,%eax
}
rtems_libio_unlock();
return 0;
}
110199: 8d 65 f4 lea -0xc(%ebp),%esp
11019c: 5b pop %ebx
11019d: 5e pop %esi
11019e: 5f pop %edi
11019f: c9 leave
1101a0: 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 );
1101a1: e8 ca 30 00 00 call 113270 <__errno>
1101a6: c7 00 0c 00 00 00 movl $0xc,(%eax)
1101ac: b8 ff ff ff ff mov $0xffffffff,%eax
1101b1: eb b2 jmp 110165 <rtems_filesystem_register+0x85>
001101b4 <rtems_filesystem_unregister>:
int
rtems_filesystem_unregister(
const char *type
)
{
1101b4: 55 push %ebp
1101b5: 89 e5 mov %esp,%ebp
1101b7: 56 push %esi
1101b8: 53 push %ebx
1101b9: 8b 75 08 mov 0x8(%ebp),%esi
rtems_chain_node *node = NULL;
if ( type == NULL ) {
1101bc: 85 f6 test %esi,%esi
1101be: 0f 84 94 00 00 00 je 110258 <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 );
1101c4: 51 push %ecx
1101c5: 6a 00 push $0x0
1101c7: 6a 00 push $0x0
1101c9: ff 35 28 7c 12 00 pushl 0x127c28
1101cf: e8 dc b4 ff ff call 10b6b0 <rtems_semaphore_obtain>
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
1101d4: 8b 1d b8 59 12 00 mov 0x1259b8,%ebx
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_lock();
for (
1101da: 83 c4 10 add $0x10,%esp
1101dd: 81 fb bc 59 12 00 cmp $0x1259bc,%ebx
1101e3: 75 0d jne 1101f2 <rtems_filesystem_unregister+0x3e>
1101e5: eb 49 jmp 110230 <rtems_filesystem_unregister+0x7c>
1101e7: 90 nop
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
1101e8: 8b 1b mov (%ebx),%ebx
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_lock();
for (
1101ea: 81 fb bc 59 12 00 cmp $0x1259bc,%ebx
1101f0: 74 3e je 110230 <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 ) {
1101f2: 83 ec 08 sub $0x8,%esp
1101f5: 56 push %esi
1101f6: ff 73 08 pushl 0x8(%ebx)
1101f9: e8 de 3c 00 00 call 113edc <strcmp>
1101fe: 83 c4 10 add $0x10,%esp
110201: 85 c0 test %eax,%eax
110203: 75 e3 jne 1101e8 <rtems_filesystem_unregister+0x34>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
110205: 83 ec 0c sub $0xc,%esp
110208: 53 push %ebx
110209: e8 ee bd ff ff call 10bffc <_Chain_Extract>
rtems_chain_extract( node );
free( fsn );
11020e: 89 1c 24 mov %ebx,(%esp)
110211: e8 9e 7e ff ff call 1080b4 <free>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
110216: 5a pop %edx
110217: ff 35 28 7c 12 00 pushl 0x127c28
11021d: e8 8a b5 ff ff call 10b7ac <rtems_semaphore_release>
110222: 83 c4 10 add $0x10,%esp
rtems_libio_unlock();
return 0;
110225: 31 c0 xor %eax,%eax
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
110227: 8d 65 f8 lea -0x8(%ebp),%esp
11022a: 5b pop %ebx
11022b: 5e pop %esi
11022c: c9 leave
11022d: c3 ret
11022e: 66 90 xchg %ax,%ax
110230: 83 ec 0c sub $0xc,%esp
110233: ff 35 28 7c 12 00 pushl 0x127c28
110239: e8 6e b5 ff ff call 10b7ac <rtems_semaphore_release>
return 0;
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
11023e: e8 2d 30 00 00 call 113270 <__errno>
110243: c7 00 02 00 00 00 movl $0x2,(%eax)
110249: 83 c4 10 add $0x10,%esp
11024c: b8 ff ff ff ff mov $0xffffffff,%eax
}
110251: 8d 65 f8 lea -0x8(%ebp),%esp
110254: 5b pop %ebx
110255: 5e pop %esi
110256: c9 leave
110257: c3 ret
)
{
rtems_chain_node *node = NULL;
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
110258: e8 13 30 00 00 call 113270 <__errno>
11025d: c7 00 16 00 00 00 movl $0x16,(%eax)
110263: 83 c8 ff or $0xffffffff,%eax
110266: eb e9 jmp 110251 <rtems_filesystem_unregister+0x9d>
0010897c <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
10897c: 55 push %ebp
10897d: 89 e5 mov %esp,%ebp
10897f: 56 push %esi
108980: 53 push %ebx
108981: 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 ) );
108984: 83 ec 0c sub $0xc,%esp
108987: 6a 08 push $0x8
108989: e8 c6 03 00 00 call 108d54 <malloc>
10898e: 89 c3 mov %eax,%ebx
*key = new_key;
108990: 8b 45 08 mov 0x8(%ebp),%eax
108993: 89 18 mov %ebx,(%eax)
new_key->val = NULL;
108995: c7 03 00 00 00 00 movl $0x0,(%ebx)
new_key->dtor = dtor;
10899b: 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 );
10899e: 83 c4 0c add $0xc,%esp
1089a1: 56 push %esi
1089a2: 53 push %ebx
1089a3: 6a 00 push $0x0
1089a5: e8 a6 3c 00 00 call 10c650 <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL )
1089aa: 83 c4 10 add $0x10,%esp
1089ad: 85 c0 test %eax,%eax
1089af: 75 0b jne 1089bc <rtems_gxx_key_create+0x40><== NEVER TAKEN
return 0;
1089b1: 31 c0 xor %eax,%eax
free( new_key );
return -1;
}
1089b3: 8d 65 f8 lea -0x8(%ebp),%esp
1089b6: 5b pop %ebx
1089b7: 5e pop %esi
1089b8: c9 leave
1089b9: c3 ret
1089ba: 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 );
1089bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1089bf: 53 push %ebx <== NOT EXECUTED
1089c0: e8 3f fe ff ff call 108804 <free> <== NOT EXECUTED
return -1;
1089c5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1089c8: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
1089cd: eb e4 jmp 1089b3 <rtems_gxx_key_create+0x37><== NOT EXECUTED
001089e0 <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
1089e0: 55 push %ebp
1089e1: 89 e5 mov %esp,%ebp
1089e3: 53 push %ebx
1089e4: 83 ec 0c sub $0xc,%esp
1089e7: 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 );
1089ea: 53 push %ebx
1089eb: 6a 00 push $0x0
1089ed: e8 22 3d 00 00 call 10c714 <rtems_task_variable_delete>
if ( status == RTEMS_SUCCESSFUL ) {
1089f2: 83 c4 10 add $0x10,%esp
1089f5: 85 c0 test %eax,%eax
1089f7: 75 11 jne 108a0a <rtems_gxx_key_delete+0x2a><== NEVER TAKEN
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
1089f9: 85 db test %ebx,%ebx
1089fb: 74 0d je 108a0a <rtems_gxx_key_delete+0x2a><== NEVER TAKEN
1089fd: 83 ec 0c sub $0xc,%esp
108a00: ff 33 pushl (%ebx)
108a02: e8 fd fd ff ff call 108804 <free>
108a07: 83 c4 10 add $0x10,%esp
return 0;
}
key = NULL;
return 0;
}
108a0a: 31 c0 xor %eax,%eax
108a0c: 8b 5d fc mov -0x4(%ebp),%ebx
108a0f: c9 leave
108a10: c3 ret
00108900 <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))
{
108900: 55 push %ebp
108901: 89 e5 mov %esp,%ebp
108903: 56 push %esi
108904: 53 push %ebx
108905: 83 ec 10 sub $0x10,%esp
108908: 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 ) {
10890b: 8b 03 mov (%ebx),%eax
10890d: 85 c0 test %eax,%eax
10890f: 74 0b je 10891c <rtems_gxx_once+0x1c>
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
if ( o == 0 )
(*func)();
}
return 0;
}
108911: 31 c0 xor %eax,%eax
108913: 8d 65 f8 lea -0x8(%ebp),%esp
108916: 5b pop %ebx
108917: 5e pop %esi
108918: c9 leave
108919: c3 ret
10891a: 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);
10891c: 51 push %ecx
10891d: 8d 75 f4 lea -0xc(%ebp),%esi
108920: 56 push %esi
108921: 68 00 01 00 00 push $0x100
108926: 68 00 01 00 00 push $0x100
10892b: e8 48 3b 00 00 call 10c478 <rtems_task_mode>
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
108930: 8b 03 mov (%ebx),%eax
108932: 83 c4 10 add $0x10,%esp
108935: 85 c0 test %eax,%eax
108937: 75 27 jne 108960 <rtems_gxx_once+0x60> <== NEVER TAKEN
*(volatile __gthread_once_t *)once = 1;
108939: c7 03 01 00 00 00 movl $0x1,(%ebx)
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
10893f: 52 push %edx
108940: 56 push %esi
108941: 68 00 01 00 00 push $0x100
108946: ff 75 f4 pushl -0xc(%ebp)
108949: e8 2a 3b 00 00 call 10c478 <rtems_task_mode>
if ( o == 0 )
(*func)();
10894e: ff 55 0c call *0xc(%ebp)
108951: 83 c4 10 add $0x10,%esp
}
return 0;
}
108954: 31 c0 xor %eax,%eax
108956: 8d 65 f8 lea -0x8(%ebp),%esp
108959: 5b pop %ebx
10895a: 5e pop %esi
10895b: c9 leave
10895c: c3 ret
10895d: 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);
108960: 50 push %eax <== NOT EXECUTED
108961: 56 push %esi <== NOT EXECUTED
108962: 68 00 01 00 00 push $0x100 <== NOT EXECUTED
108967: ff 75 f4 pushl -0xc(%ebp) <== NOT EXECUTED
10896a: e8 09 3b 00 00 call 10c478 <rtems_task_mode> <== NOT EXECUTED
10896f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if ( o == 0 )
(*func)();
}
return 0;
}
108972: 31 c0 xor %eax,%eax <== NOT EXECUTED
108974: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
108977: 5b pop %ebx <== NOT EXECUTED
108978: 5e pop %esi <== NOT EXECUTED
108979: c9 leave <== NOT EXECUTED
10897a: c3 ret <== NOT EXECUTED
00108a70 <rtems_gxx_setspecific>:
#endif
return p;
}
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
108a70: 55 push %ebp
108a71: 89 e5 mov %esp,%ebp
108a73: 53 push %ebx
108a74: 83 ec 08 sub $0x8,%esp
108a77: 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 );
108a7a: ff 73 04 pushl 0x4(%ebx)
108a7d: 53 push %ebx
108a7e: 6a 00 push $0x0
108a80: e8 cb 3b 00 00 call 10c650 <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL ) {
108a85: 83 c4 10 add $0x10,%esp
108a88: 85 c0 test %eax,%eax
108a8a: 75 0c jne 108a98 <rtems_gxx_setspecific+0x28><== NEVER TAKEN
/* now let's set the proper value */
key->val = (void *)ptr;
108a8c: 8b 45 0c mov 0xc(%ebp),%eax
108a8f: 89 03 mov %eax,(%ebx)
return 0;
108a91: 31 c0 xor %eax,%eax
}
return -1;
}
108a93: 8b 5d fc mov -0x4(%ebp),%ebx
108a96: c9 leave
108a97: c3 ret
if ( status == RTEMS_SUCCESSFUL ) {
/* now let's set the proper value */
key->val = (void *)ptr;
return 0;
}
return -1;
108a98: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
}
108a9d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
108aa0: c9 leave <== NOT EXECUTED
108aa1: c3 ret <== NOT EXECUTED
0010bc38 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
10bc38: 55 push %ebp
10bc39: 89 e5 mov %esp,%ebp
10bc3b: 83 ec 08 sub $0x8,%esp
if (
10bc3e: 83 3d 60 f4 12 00 03 cmpl $0x3,0x12f460
10bc45: 74 21 je 10bc68 <rtems_heap_allocate_aligned_with_boundary+0x30><== ALWAYS TAKEN
&& !malloc_is_system_state_OK()
) {
return NULL;
}
malloc_deferred_frees_process();
10bc47: e8 e0 ef ff ff call 10ac2c <malloc_deferred_frees_process>
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
10bc4c: ff 75 10 pushl 0x10(%ebp)
10bc4f: ff 75 0c pushl 0xc(%ebp)
10bc52: ff 75 08 pushl 0x8(%ebp)
10bc55: ff 35 b0 a5 12 00 pushl 0x12a5b0
10bc5b: e8 f0 4d 00 00 call 110a50 <_Protected_heap_Allocate_aligned_with_boundary>
10bc60: 83 c4 10 add $0x10,%esp
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
10bc63: c9 leave
10bc64: c3 ret
10bc65: 8d 76 00 lea 0x0(%esi),%esi
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
10bc68: e8 7f ef ff ff call 10abec <malloc_is_system_state_OK>
10bc6d: 84 c0 test %al,%al
10bc6f: 75 d6 jne 10bc47 <rtems_heap_allocate_aligned_with_boundary+0xf>
) {
return NULL;
10bc71: 31 c0 xor %eax,%eax
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
10bc73: c9 leave
10bc74: c3 ret
00112f54 <rtems_io_close>:
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
112f54: 55 push %ebp
112f55: 89 e5 mov %esp,%ebp
112f57: 53 push %ebx
112f58: 83 ec 04 sub $0x4,%esp
112f5b: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
112f5e: 39 05 00 88 12 00 cmp %eax,0x128800
112f64: 76 1a jbe 112f80 <rtems_io_close+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
112f66: 8d 14 40 lea (%eax,%eax,2),%edx
112f69: c1 e2 03 shl $0x3,%edx
112f6c: 03 15 04 88 12 00 add 0x128804,%edx
112f72: 8b 52 08 mov 0x8(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
112f75: 85 d2 test %edx,%edx
112f77: 74 13 je 112f8c <rtems_io_close+0x38>
}
112f79: 59 pop %ecx
112f7a: 5b pop %ebx
112f7b: 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;
112f7c: ff e2 jmp *%edx
112f7e: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
112f80: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].close_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
112f85: 5a pop %edx
112f86: 5b pop %ebx
112f87: c9 leave
112f88: c3 ret
112f89: 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;
112f8c: 31 c0 xor %eax,%eax
}
112f8e: 5a pop %edx
112f8f: 5b pop %ebx
112f90: c9 leave
112f91: c3 ret
00112f94 <rtems_io_control>:
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
112f94: 55 push %ebp
112f95: 89 e5 mov %esp,%ebp
112f97: 53 push %ebx
112f98: 83 ec 04 sub $0x4,%esp
112f9b: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
112f9e: 39 05 00 88 12 00 cmp %eax,0x128800
112fa4: 76 1a jbe 112fc0 <rtems_io_control+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
112fa6: 8d 14 40 lea (%eax,%eax,2),%edx
112fa9: c1 e2 03 shl $0x3,%edx
112fac: 03 15 04 88 12 00 add 0x128804,%edx
112fb2: 8b 52 14 mov 0x14(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
112fb5: 85 d2 test %edx,%edx
112fb7: 74 13 je 112fcc <rtems_io_control+0x38>
}
112fb9: 59 pop %ecx
112fba: 5b pop %ebx
112fbb: 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;
112fbc: ff e2 jmp *%edx
112fbe: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
112fc0: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].control_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
112fc5: 5a pop %edx
112fc6: 5b pop %ebx
112fc7: c9 leave
112fc8: c3 ret
112fc9: 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;
112fcc: 31 c0 xor %eax,%eax
}
112fce: 5a pop %edx
112fcf: 5b pop %ebx
112fd0: c9 leave
112fd1: c3 ret
00111044 <rtems_io_initialize>:
rtems_status_code rtems_io_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
111044: 55 push %ebp
111045: 89 e5 mov %esp,%ebp
111047: 53 push %ebx
111048: 83 ec 04 sub $0x4,%esp
11104b: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
11104e: 39 05 00 88 12 00 cmp %eax,0x128800
111054: 76 1a jbe 111070 <rtems_io_initialize+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].initialization_entry;
111056: 8d 14 40 lea (%eax,%eax,2),%edx
111059: c1 e2 03 shl $0x3,%edx
11105c: 03 15 04 88 12 00 add 0x128804,%edx
111062: 8b 12 mov (%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
111064: 85 d2 test %edx,%edx
111066: 74 14 je 11107c <rtems_io_initialize+0x38>
}
111068: 59 pop %ecx
111069: 5b pop %ebx
11106a: 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;
11106b: ff e2 jmp *%edx
11106d: 8d 76 00 lea 0x0(%esi),%esi
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
111070: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].initialization_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
111075: 5a pop %edx
111076: 5b pop %ebx
111077: c9 leave
111078: c3 ret
111079: 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;
11107c: 31 c0 xor %eax,%eax
}
11107e: 5a pop %edx
11107f: 5b pop %ebx
111080: c9 leave
111081: c3 ret
00107d60 <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
107d60: 55 push %ebp
107d61: 89 e5 mov %esp,%ebp
107d63: 57 push %edi
107d64: 56 push %esi
107d65: 53 push %ebx
107d66: 83 ec 48 sub $0x48,%esp
107d69: 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(
107d6c: b9 ff ff ff ff mov $0xffffffff,%ecx
107d71: 89 f7 mov %esi,%edi
107d73: 31 c0 xor %eax,%eax
107d75: f2 ae repnz scas %es:(%edi),%al
107d77: f7 d1 not %ecx
107d79: 49 dec %ecx
107d7a: 6a 01 push $0x1
107d7c: 8d 5d d4 lea -0x2c(%ebp),%ebx
107d7f: 53 push %ebx
107d80: 6a 00 push $0x0
107d82: 51 push %ecx
107d83: 56 push %esi
107d84: e8 3f 02 00 00 call 107fc8 <rtems_filesystem_evaluate_path>
107d89: 89 c7 mov %eax,%edi
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
107d8b: 8b 55 d4 mov -0x2c(%ebp),%edx
107d8e: 89 55 c4 mov %edx,-0x3c(%ebp)
node_type = (*loc.ops->node_type_h)( &loc );
107d91: 83 c4 14 add $0x14,%esp
107d94: 53 push %ebx
107d95: 8b 45 e0 mov -0x20(%ebp),%eax
107d98: ff 50 10 call *0x10(%eax)
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
107d9b: 83 c4 10 add $0x10,%esp
107d9e: 85 ff test %edi,%edi
107da0: 75 05 jne 107da7 <rtems_io_lookup_name+0x47><== NEVER TAKEN
107da2: 83 f8 02 cmp $0x2,%eax
107da5: 74 19 je 107dc0 <rtems_io_lookup_name+0x60>
rtems_filesystem_freenode( &loc );
107da7: 83 ec 0c sub $0xc,%esp
107daa: 53 push %ebx
107dab: e8 f0 02 00 00 call 1080a0 <rtems_filesystem_freenode>
return RTEMS_UNSATISFIED;
107db0: 83 c4 10 add $0x10,%esp
107db3: b8 0d 00 00 00 mov $0xd,%eax
device_info->minor = the_jnode->info.device.minor;
rtems_filesystem_freenode( &loc );
return RTEMS_SUCCESSFUL;
}
107db8: 8d 65 f4 lea -0xc(%ebp),%esp
107dbb: 5b pop %ebx
107dbc: 5e pop %esi
107dbd: 5f pop %edi
107dbe: c9 leave
107dbf: c3 ret
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
rtems_filesystem_freenode( &loc );
return RTEMS_UNSATISFIED;
}
device_info->device_name = (char *) name;
107dc0: 8b 7d 0c mov 0xc(%ebp),%edi
107dc3: 89 37 mov %esi,(%edi)
device_info->device_name_length = strlen( name );
107dc5: b9 ff ff ff ff mov $0xffffffff,%ecx
107dca: 89 f7 mov %esi,%edi
107dcc: 31 c0 xor %eax,%eax
107dce: f2 ae repnz scas %es:(%edi),%al
107dd0: f7 d1 not %ecx
107dd2: 49 dec %ecx
107dd3: 8b 45 0c mov 0xc(%ebp),%eax
107dd6: 89 48 04 mov %ecx,0x4(%eax)
device_info->major = the_jnode->info.device.major;
107dd9: 8b 55 c4 mov -0x3c(%ebp),%edx
107ddc: 8b 42 50 mov 0x50(%edx),%eax
107ddf: 8b 7d 0c mov 0xc(%ebp),%edi
107de2: 89 47 08 mov %eax,0x8(%edi)
device_info->minor = the_jnode->info.device.minor;
107de5: 8b 42 54 mov 0x54(%edx),%eax
107de8: 89 47 0c mov %eax,0xc(%edi)
rtems_filesystem_freenode( &loc );
107deb: 83 ec 0c sub $0xc,%esp
107dee: 53 push %ebx
107def: e8 ac 02 00 00 call 1080a0 <rtems_filesystem_freenode>
return RTEMS_SUCCESSFUL;
107df4: 83 c4 10 add $0x10,%esp
107df7: 31 c0 xor %eax,%eax
107df9: eb bd jmp 107db8 <rtems_io_lookup_name+0x58>
00112fd4 <rtems_io_open>:
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
112fd4: 55 push %ebp
112fd5: 89 e5 mov %esp,%ebp
112fd7: 53 push %ebx
112fd8: 83 ec 04 sub $0x4,%esp
112fdb: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
112fde: 39 05 00 88 12 00 cmp %eax,0x128800
112fe4: 76 1a jbe 113000 <rtems_io_open+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
112fe6: 8d 14 40 lea (%eax,%eax,2),%edx
112fe9: c1 e2 03 shl $0x3,%edx
112fec: 03 15 04 88 12 00 add 0x128804,%edx
112ff2: 8b 52 04 mov 0x4(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
112ff5: 85 d2 test %edx,%edx
112ff7: 74 13 je 11300c <rtems_io_open+0x38>
}
112ff9: 59 pop %ecx
112ffa: 5b pop %ebx
112ffb: 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;
112ffc: ff e2 jmp *%edx
112ffe: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
113000: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].open_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
113005: 5a pop %edx
113006: 5b pop %ebx
113007: c9 leave
113008: c3 ret
113009: 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;
11300c: 31 c0 xor %eax,%eax
}
11300e: 5a pop %edx
11300f: 5b pop %ebx
113010: c9 leave
113011: c3 ret
00113014 <rtems_io_read>:
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
113014: 55 push %ebp
113015: 89 e5 mov %esp,%ebp
113017: 53 push %ebx
113018: 83 ec 04 sub $0x4,%esp
11301b: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
11301e: 39 05 00 88 12 00 cmp %eax,0x128800
113024: 76 1a jbe 113040 <rtems_io_read+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
113026: 8d 14 40 lea (%eax,%eax,2),%edx
113029: c1 e2 03 shl $0x3,%edx
11302c: 03 15 04 88 12 00 add 0x128804,%edx
113032: 8b 52 0c mov 0xc(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
113035: 85 d2 test %edx,%edx
113037: 74 13 je 11304c <rtems_io_read+0x38>
}
113039: 59 pop %ecx
11303a: 5b pop %ebx
11303b: 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;
11303c: ff e2 jmp *%edx
11303e: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
113040: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].read_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
113045: 5a pop %edx
113046: 5b pop %ebx
113047: c9 leave
113048: c3 ret
113049: 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;
11304c: 31 c0 xor %eax,%eax
}
11304e: 5a pop %edx
11304f: 5b pop %ebx
113050: c9 leave
113051: c3 ret
0010cec0 <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
)
{
10cec0: 55 push %ebp
10cec1: 89 e5 mov %esp,%ebp
10cec3: 57 push %edi
10cec4: 56 push %esi
10cec5: 53 push %ebx
10cec6: 83 ec 0c sub $0xc,%esp
10cec9: 8b 5d 08 mov 0x8(%ebp),%ebx
10cecc: 8b 75 0c mov 0xc(%ebp),%esi
10cecf: 8b 55 10 mov 0x10(%ebp),%edx
rtems_device_major_number major_limit = _IO_Number_of_drivers;
10ced2: a1 00 c5 12 00 mov 0x12c500,%eax
if ( rtems_interrupt_is_in_progress() )
10ced7: 8b 0d 34 c0 12 00 mov 0x12c034,%ecx
10cedd: 85 c9 test %ecx,%ecx
10cedf: 0f 85 ab 00 00 00 jne 10cf90 <rtems_io_register_driver+0xd0>
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
10cee5: 85 d2 test %edx,%edx
10cee7: 0f 84 e7 00 00 00 je 10cfd4 <rtems_io_register_driver+0x114>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
10ceed: 89 02 mov %eax,(%edx)
if ( driver_table == NULL )
10ceef: 85 f6 test %esi,%esi
10cef1: 0f 84 dd 00 00 00 je 10cfd4 <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;
10cef7: 8b 3e mov (%esi),%edi
10cef9: 85 ff test %edi,%edi
10cefb: 0f 84 c7 00 00 00 je 10cfc8 <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 )
10cf01: 39 d8 cmp %ebx,%eax
10cf03: 76 7b jbe 10cf80 <rtems_io_register_driver+0xc0>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10cf05: a1 90 ba 12 00 mov 0x12ba90,%eax
10cf0a: 40 inc %eax
10cf0b: a3 90 ba 12 00 mov %eax,0x12ba90
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
10cf10: 85 db test %ebx,%ebx
10cf12: 0f 85 88 00 00 00 jne 10cfa0 <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;
10cf18: 8b 0d 00 c5 12 00 mov 0x12c500,%ecx
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
10cf1e: 85 c9 test %ecx,%ecx
10cf20: 0f 84 bb 00 00 00 je 10cfe1 <rtems_io_register_driver+0x121><== NEVER TAKEN
10cf26: 8b 3d 04 c5 12 00 mov 0x12c504,%edi
10cf2c: 89 f8 mov %edi,%eax
10cf2e: eb 08 jmp 10cf38 <rtems_io_register_driver+0x78>
10cf30: 43 inc %ebx
10cf31: 83 c0 18 add $0x18,%eax
10cf34: 39 d9 cmp %ebx,%ecx
10cf36: 76 0b jbe 10cf43 <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;
10cf38: 83 38 00 cmpl $0x0,(%eax)
10cf3b: 75 f3 jne 10cf30 <rtems_io_register_driver+0x70>
10cf3d: 83 78 04 00 cmpl $0x0,0x4(%eax)
10cf41: 75 ed jne 10cf30 <rtems_io_register_driver+0x70>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10cf43: 89 1a mov %ebx,(%edx)
if ( m != n )
10cf45: 39 d9 cmp %ebx,%ecx
10cf47: 0f 84 9b 00 00 00 je 10cfe8 <rtems_io_register_driver+0x128>
10cf4d: 8d 04 5b lea (%ebx,%ebx,2),%eax
10cf50: c1 e0 03 shl $0x3,%eax
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
10cf53: 01 c7 add %eax,%edi
10cf55: b9 06 00 00 00 mov $0x6,%ecx
10cf5a: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Thread_Enable_dispatch();
10cf5c: e8 6b 1d 00 00 call 10eccc <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
10cf61: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp)
10cf68: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp)
10cf6f: 89 5d 08 mov %ebx,0x8(%ebp)
}
10cf72: 83 c4 0c add $0xc,%esp
10cf75: 5b pop %ebx
10cf76: 5e pop %esi
10cf77: 5f pop %edi
10cf78: c9 leave
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
10cf79: e9 72 7e 00 00 jmp 114df0 <rtems_io_initialize>
10cf7e: 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;
10cf80: 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 );
}
10cf85: 83 c4 0c add $0xc,%esp
10cf88: 5b pop %ebx
10cf89: 5e pop %esi
10cf8a: 5f pop %edi
10cf8b: c9 leave
10cf8c: c3 ret
10cf8d: 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;
10cf90: 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 );
}
10cf95: 83 c4 0c add $0xc,%esp
10cf98: 5b pop %ebx
10cf99: 5e pop %esi
10cf9a: 5f pop %edi
10cf9b: c9 leave
10cf9c: c3 ret
10cf9d: 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;
10cfa0: 8d 04 5b lea (%ebx,%ebx,2),%eax
10cfa3: c1 e0 03 shl $0x3,%eax
10cfa6: 8b 0d 04 c5 12 00 mov 0x12c504,%ecx
10cfac: 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;
10cfae: 8b 39 mov (%ecx),%edi
10cfb0: 85 ff test %edi,%edi
10cfb2: 74 40 je 10cff4 <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();
10cfb4: e8 13 1d 00 00 call 10eccc <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
10cfb9: 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 );
}
10cfbe: 83 c4 0c add $0xc,%esp
10cfc1: 5b pop %ebx
10cfc2: 5e pop %esi
10cfc3: 5f pop %edi
10cfc4: c9 leave
10cfc5: c3 ret
10cfc6: 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;
10cfc8: 8b 4e 04 mov 0x4(%esi),%ecx
10cfcb: 85 c9 test %ecx,%ecx
10cfcd: 0f 85 2e ff ff ff jne 10cf01 <rtems_io_register_driver+0x41>
10cfd3: 90 nop
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
10cfd4: 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 );
}
10cfd9: 83 c4 0c add $0xc,%esp
10cfdc: 5b pop %ebx
10cfdd: 5e pop %esi
10cfde: 5f pop %edi
10cfdf: c9 leave
10cfe0: c3 ret
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10cfe1: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED
10cfe7: 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();
10cfe8: e8 df 1c 00 00 call 10eccc <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
10cfed: 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;
10cff2: eb 91 jmp 10cf85 <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;
10cff4: 8b 49 04 mov 0x4(%ecx),%ecx
10cff7: 85 c9 test %ecx,%ecx
10cff9: 75 b9 jne 10cfb4 <rtems_io_register_driver+0xf4>
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
10cffb: 89 1a mov %ebx,(%edx)
10cffd: 8b 3d 04 c5 12 00 mov 0x12c504,%edi
10d003: e9 4b ff ff ff jmp 10cf53 <rtems_io_register_driver+0x93>
0010d008 <rtems_io_unregister_driver>:
*/
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
10d008: 55 push %ebp
10d009: 89 e5 mov %esp,%ebp
10d00b: 57 push %edi
10d00c: 83 ec 04 sub $0x4,%esp
10d00f: 8b 45 08 mov 0x8(%ebp),%eax
if ( rtems_interrupt_is_in_progress() )
10d012: 8b 0d 34 c0 12 00 mov 0x12c034,%ecx
10d018: 85 c9 test %ecx,%ecx
10d01a: 75 44 jne 10d060 <rtems_io_unregister_driver+0x58>
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
10d01c: 39 05 00 c5 12 00 cmp %eax,0x12c500
10d022: 77 0c ja 10d030 <rtems_io_unregister_driver+0x28>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
10d024: b8 0d 00 00 00 mov $0xd,%eax
}
10d029: 5a pop %edx
10d02a: 5f pop %edi
10d02b: c9 leave
10d02c: c3 ret
10d02d: 8d 76 00 lea 0x0(%esi),%esi
10d030: 8b 15 90 ba 12 00 mov 0x12ba90,%edx
10d036: 42 inc %edx
10d037: 89 15 90 ba 12 00 mov %edx,0x12ba90
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
_Thread_Disable_dispatch();
memset(
&_IO_Driver_address_table[major],
10d03d: 8d 14 40 lea (%eax,%eax,2),%edx
10d040: 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(
10d043: 03 15 04 c5 12 00 add 0x12c504,%edx
10d049: b9 18 00 00 00 mov $0x18,%ecx
10d04e: 31 c0 xor %eax,%eax
10d050: 89 d7 mov %edx,%edi
10d052: f3 aa rep stos %al,%es:(%edi)
&_IO_Driver_address_table[major],
0,
sizeof( rtems_driver_address_table )
);
_Thread_Enable_dispatch();
10d054: e8 73 1c 00 00 call 10eccc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10d059: 31 c0 xor %eax,%eax
}
return RTEMS_UNSATISFIED;
}
10d05b: 5a pop %edx
10d05c: 5f pop %edi
10d05d: c9 leave
10d05e: c3 ret
10d05f: 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;
10d060: b8 12 00 00 00 mov $0x12,%eax
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
}
10d065: 5a pop %edx
10d066: 5f pop %edi
10d067: c9 leave
10d068: c3 ret
00113054 <rtems_io_write>:
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
113054: 55 push %ebp
113055: 89 e5 mov %esp,%ebp
113057: 53 push %ebx
113058: 83 ec 04 sub $0x4,%esp
11305b: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
11305e: 39 05 00 88 12 00 cmp %eax,0x128800
113064: 76 1a jbe 113080 <rtems_io_write+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
113066: 8d 14 40 lea (%eax,%eax,2),%edx
113069: c1 e2 03 shl $0x3,%edx
11306c: 03 15 04 88 12 00 add 0x128804,%edx
113072: 8b 52 10 mov 0x10(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
113075: 85 d2 test %edx,%edx
113077: 74 13 je 11308c <rtems_io_write+0x38>
}
113079: 59 pop %ecx
11307a: 5b pop %ebx
11307b: 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;
11307c: ff e2 jmp *%edx
11307e: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
113080: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].write_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
113085: 5a pop %edx
113086: 5b pop %ebx
113087: c9 leave
113088: c3 ret
113089: 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;
11308c: 31 c0 xor %eax,%eax
}
11308e: 5a pop %edx
11308f: 5b pop %ebx
113090: c9 leave
113091: c3 ret
0010dfb8 <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)
{
10dfb8: 55 push %ebp
10dfb9: 89 e5 mov %esp,%ebp
10dfbb: 57 push %edi
10dfbc: 56 push %esi
10dfbd: 53 push %ebx
10dfbe: 83 ec 1c sub $0x1c,%esp
10dfc1: 8b 7d 08 mov 0x8(%ebp),%edi
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
10dfc4: 85 ff test %edi,%edi
10dfc6: 74 49 je 10e011 <rtems_iterate_over_all_threads+0x59><== NEVER TAKEN
10dfc8: c7 45 e4 01 00 00 00 movl $0x1,-0x1c(%ebp)
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
10dfcf: 8b 55 e4 mov -0x1c(%ebp),%edx
10dfd2: 8b 04 95 e8 a9 12 00 mov 0x12a9e8(,%edx,4),%eax
10dfd9: 8b 70 04 mov 0x4(%eax),%esi
if ( !information )
10dfdc: 85 f6 test %esi,%esi
10dfde: 74 28 je 10e008 <rtems_iterate_over_all_threads+0x50>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10dfe0: 66 83 7e 10 00 cmpw $0x0,0x10(%esi)
10dfe5: 74 21 je 10e008 <rtems_iterate_over_all_threads+0x50>
10dfe7: bb 01 00 00 00 mov $0x1,%ebx
the_thread = (Thread_Control *)information->local_table[ i ];
10dfec: 8b 46 1c mov 0x1c(%esi),%eax
10dfef: 8b 04 98 mov (%eax,%ebx,4),%eax
if ( !the_thread )
10dff2: 85 c0 test %eax,%eax
10dff4: 74 09 je 10dfff <rtems_iterate_over_all_threads+0x47><== NEVER TAKEN
continue;
(*routine)(the_thread);
10dff6: 83 ec 0c sub $0xc,%esp
10dff9: 50 push %eax
10dffa: ff d7 call *%edi
10dffc: 83 c4 10 add $0x10,%esp
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10dfff: 43 inc %ebx
10e000: 0f b7 46 10 movzwl 0x10(%esi),%eax
10e004: 39 d8 cmp %ebx,%eax
10e006: 73 e4 jae 10dfec <rtems_iterate_over_all_threads+0x34>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
10e008: ff 45 e4 incl -0x1c(%ebp)
10e00b: 83 7d e4 04 cmpl $0x4,-0x1c(%ebp)
10e00f: 75 be jne 10dfcf <rtems_iterate_over_all_threads+0x17>
(*routine)(the_thread);
}
}
}
10e011: 8d 65 f4 lea -0xc(%ebp),%esp
10e014: 5b pop %ebx
10e015: 5e pop %esi
10e016: 5f pop %edi
10e017: c9 leave
10e018: c3 ret
0010feac <rtems_libio_free>:
*/
void rtems_libio_free(
rtems_libio_t *iop
)
{
10feac: 55 push %ebp
10fead: 89 e5 mov %esp,%ebp
10feaf: 53 push %ebx
10feb0: 83 ec 08 sub $0x8,%esp
10feb3: 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 );
10feb6: 6a 00 push $0x0
10feb8: 6a 00 push $0x0
10feba: ff 35 28 7c 12 00 pushl 0x127c28
10fec0: e8 eb b7 ff ff call 10b6b0 <rtems_semaphore_obtain>
rtems_libio_lock();
if (iop->sem)
10fec5: 8b 43 2c mov 0x2c(%ebx),%eax
10fec8: 83 c4 10 add $0x10,%esp
10fecb: 85 c0 test %eax,%eax
10fecd: 74 0c je 10fedb <rtems_libio_free+0x2f> <== NEVER TAKEN
rtems_semaphore_delete(iop->sem);
10fecf: 83 ec 0c sub $0xc,%esp
10fed2: 50 push %eax
10fed3: e8 34 b7 ff ff call 10b60c <rtems_semaphore_delete>
10fed8: 83 c4 10 add $0x10,%esp
iop->flags &= ~LIBIO_FLAGS_OPEN;
10fedb: 81 63 14 ff fe ff ff andl $0xfffffeff,0x14(%ebx)
iop->data1 = rtems_libio_iop_freelist;
10fee2: a1 24 7c 12 00 mov 0x127c24,%eax
10fee7: 89 43 34 mov %eax,0x34(%ebx)
rtems_libio_iop_freelist = iop;
10feea: 89 1d 24 7c 12 00 mov %ebx,0x127c24
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10fef0: a1 28 7c 12 00 mov 0x127c28,%eax
10fef5: 89 45 08 mov %eax,0x8(%ebp)
rtems_libio_unlock();
}
10fef8: 8b 5d fc mov -0x4(%ebp),%ebx
10fefb: c9 leave
10fefc: e9 ab b8 ff ff jmp 10b7ac <rtems_semaphore_release>
001081b0 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
1081b0: 55 push %ebp
1081b1: 89 e5 mov %esp,%ebp
1081b3: 53 push %ebx
1081b4: 83 ec 04 sub $0x4,%esp
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
1081b7: 8b 1d 6c 39 12 00 mov 0x12396c,%ebx
1081bd: 85 db test %ebx,%ebx
1081bf: 74 50 je 108211 <rtems_libio_init+0x61> <== NEVER TAKEN
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
1081c1: 83 ec 08 sub $0x8,%esp
1081c4: 6a 38 push $0x38
1081c6: 53 push %ebx
1081c7: e8 58 fd ff ff call 107f24 <calloc>
1081cc: 89 c2 mov %eax,%edx
1081ce: a3 20 7c 12 00 mov %eax,0x127c20
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
1081d3: 83 c4 10 add $0x10,%esp
1081d6: 85 c0 test %eax,%eax
1081d8: 74 74 je 10824e <rtems_libio_init+0x9e>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
1081da: a3 24 7c 12 00 mov %eax,0x127c24
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
1081df: 83 fb 01 cmp $0x1,%ebx
1081e2: 76 26 jbe 10820a <rtems_libio_init+0x5a> <== NEVER TAKEN
* rtems_libio_init
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
1081e4: 8d 50 38 lea 0x38(%eax),%edx
1081e7: 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;
1081ec: 89 52 fc mov %edx,-0x4(%edx)
1081ef: 41 inc %ecx
1081f0: 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++)
1081f3: 39 d9 cmp %ebx,%ecx
1081f5: 75 f5 jne 1081ec <rtems_libio_init+0x3c>
* rtems_libio_init
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
1081f7: 8d 0c cd f8 ff ff ff lea -0x8(,%ecx,8),%ecx
1081fe: 8d 14 cd 00 00 00 00 lea 0x0(,%ecx,8),%edx
108205: 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++)
108207: 8d 14 10 lea (%eax,%edx,1),%edx
iop->data1 = iop + 1;
iop->data1 = NULL;
10820a: 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(
108211: 83 ec 0c sub $0xc,%esp
108214: 68 28 7c 12 00 push $0x127c28
108219: 6a 00 push $0x0
10821b: 6a 54 push $0x54
10821d: 6a 01 push $0x1
10821f: 68 4f 49 42 4c push $0x4c42494f
108224: e8 0b 32 00 00 call 10b434 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
108229: 83 c4 20 add $0x20,%esp
10822c: 85 c0 test %eax,%eax
10822e: 75 15 jne 108245 <rtems_libio_init+0x95> <== NEVER TAKEN
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
108230: a1 68 39 12 00 mov 0x123968,%eax
108235: 85 c0 test %eax,%eax
108237: 74 07 je 108240 <rtems_libio_init+0x90> <== NEVER TAKEN
(* rtems_fs_init_helper)();
}
108239: 8b 5d fc mov -0x4(%ebp),%ebx
10823c: c9 leave
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
(* rtems_fs_init_helper)();
10823d: ff e0 jmp *%eax
10823f: 90 nop
}
108240: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
108243: c9 leave <== NOT EXECUTED
108244: 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 );
108245: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108248: 50 push %eax <== NOT EXECUTED
108249: e8 a6 3a 00 00 call 10bcf4 <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);
10824e: 83 ec 0c sub $0xc,%esp
108251: 6a 1a push $0x1a
108253: e8 9c 3a 00 00 call 10bcf4 <rtems_fatal_error_occurred>
0010ff68 <rtems_libio_is_file_open>:
*/
int rtems_libio_is_file_open(
void *node_access
)
{
10ff68: 55 push %ebp
10ff69: 89 e5 mov %esp,%ebp
10ff6b: 53 push %ebx
10ff6c: 83 ec 08 sub $0x8,%esp
10ff6f: 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 );
10ff72: 6a 00 push $0x0
10ff74: 6a 00 push $0x0
10ff76: ff 35 28 7c 12 00 pushl 0x127c28
10ff7c: e8 2f b7 ff ff call 10b6b0 <rtems_semaphore_obtain>
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
10ff81: a1 20 7c 12 00 mov 0x127c20,%eax
10ff86: 8b 0d 6c 39 12 00 mov 0x12396c,%ecx
10ff8c: 83 c4 10 add $0x10,%esp
10ff8f: 85 c9 test %ecx,%ecx
10ff91: 74 18 je 10ffab <rtems_libio_is_file_open+0x43><== NEVER TAKEN
10ff93: 31 d2 xor %edx,%edx
10ff95: eb 04 jmp 10ff9b <rtems_libio_is_file_open+0x33>
10ff97: 90 nop
10ff98: 83 c0 38 add $0x38,%eax
if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {
10ff9b: f6 40 15 01 testb $0x1,0x15(%eax)
10ff9f: 74 05 je 10ffa6 <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 ) {
10ffa1: 39 58 18 cmp %ebx,0x18(%eax)
10ffa4: 74 1e je 10ffc4 <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++){
10ffa6: 42 inc %edx
10ffa7: 39 ca cmp %ecx,%edx
10ffa9: 72 ed jb 10ff98 <rtems_libio_is_file_open+0x30>
int rtems_libio_is_file_open(
void *node_access
)
{
rtems_libio_t *iop;
int result=0;
10ffab: 31 db xor %ebx,%ebx
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10ffad: 83 ec 0c sub $0xc,%esp
10ffb0: ff 35 28 7c 12 00 pushl 0x127c28
10ffb6: e8 f1 b7 ff ff call 10b7ac <rtems_semaphore_release>
}
rtems_libio_unlock();
return result;
}
10ffbb: 89 d8 mov %ebx,%eax
10ffbd: 8b 5d fc mov -0x4(%ebp),%ebx
10ffc0: c9 leave
10ffc1: c3 ret
10ffc2: 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;
10ffc4: bb 01 00 00 00 mov $0x1,%ebx
10ffc9: eb e2 jmp 10ffad <rtems_libio_is_file_open+0x45>
0010ff04 <rtems_libio_is_open_files_in_fs>:
*/
int rtems_libio_is_open_files_in_fs(
rtems_filesystem_mount_table_entry_t * fs_mt_entry
)
{
10ff04: 55 push %ebp
10ff05: 89 e5 mov %esp,%ebp
10ff07: 53 push %ebx
10ff08: 83 ec 08 sub $0x8,%esp
10ff0b: 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 );
10ff0e: 6a 00 push $0x0
10ff10: 6a 00 push $0x0
10ff12: ff 35 28 7c 12 00 pushl 0x127c28
10ff18: e8 93 b7 ff ff call 10b6b0 <rtems_semaphore_obtain>
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
10ff1d: a1 20 7c 12 00 mov 0x127c20,%eax
10ff22: 8b 0d 6c 39 12 00 mov 0x12396c,%ecx
10ff28: 83 c4 10 add $0x10,%esp
10ff2b: 85 c9 test %ecx,%ecx
10ff2d: 74 18 je 10ff47 <rtems_libio_is_open_files_in_fs+0x43><== NEVER TAKEN
10ff2f: 31 d2 xor %edx,%edx
10ff31: eb 04 jmp 10ff37 <rtems_libio_is_open_files_in_fs+0x33>
10ff33: 90 nop
10ff34: 83 c0 38 add $0x38,%eax
if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {
10ff37: f6 40 15 01 testb $0x1,0x15(%eax)
10ff3b: 74 05 je 10ff42 <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 ) {
10ff3d: 39 58 28 cmp %ebx,0x28(%eax)
10ff40: 74 1e je 10ff60 <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++){
10ff42: 42 inc %edx
10ff43: 39 ca cmp %ecx,%edx
10ff45: 72 ed jb 10ff34 <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;
10ff47: 31 db xor %ebx,%ebx
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10ff49: 83 ec 0c sub $0xc,%esp
10ff4c: ff 35 28 7c 12 00 pushl 0x127c28
10ff52: e8 55 b8 ff ff call 10b7ac <rtems_semaphore_release>
}
rtems_libio_unlock();
return result;
}
10ff57: 89 d8 mov %ebx,%eax
10ff59: 8b 5d fc mov -0x4(%ebp),%ebx
10ff5c: c9 leave
10ff5d: c3 ret
10ff5e: 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;
10ff60: bb 01 00 00 00 mov $0x1,%ebx
10ff65: eb e2 jmp 10ff49 <rtems_libio_is_open_files_in_fs+0x45>
00109590 <rtems_libio_set_private_env>:
rtems_status_code rtems_libio_set_private_env(void)
{
109590: 55 push %ebp
109591: 89 e5 mov %esp,%ebp
109593: 57 push %edi
109594: 56 push %esi
109595: 53 push %ebx
109596: 83 ec 5c sub $0x5c,%esp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id task_id = rtems_task_self();
109599: e8 0e 2e 00 00 call 10c3ac <rtems_task_self>
10959e: 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);
1095a1: 83 ec 0c sub $0xc,%esp
1095a4: 6a 00 push $0x0
1095a6: 8d 5d d4 lea -0x2c(%ebp),%ebx
1095a9: 53 push %ebx
1095aa: 6a 00 push $0x0
1095ac: 6a 01 push $0x1
1095ae: 68 47 1c 12 00 push $0x121c47
1095b3: e8 50 ee ff ff call 108408 <rtems_filesystem_evaluate_path>
if (rv != 0)
1095b8: 83 c4 20 add $0x20,%esp
1095bb: 85 c0 test %eax,%eax
1095bd: 74 0d je 1095cc <rtems_libio_set_private_env+0x3c><== ALWAYS TAKEN
error_1:
rtems_filesystem_freenode(&root_loc);
error_0:
return RTEMS_NO_MEMORY;
1095bf: b8 1a 00 00 00 mov $0x1a,%eax
}
1095c4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1095c7: 5b pop %ebx <== NOT EXECUTED
1095c8: 5e pop %esi <== NOT EXECUTED
1095c9: 5f pop %edi <== NOT EXECUTED
1095ca: c9 leave <== NOT EXECUTED
1095cb: 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);
1095cc: 83 ec 0c sub $0xc,%esp
1095cf: 6a 00 push $0x0
1095d1: 8d 45 c0 lea -0x40(%ebp),%eax
1095d4: 89 45 a4 mov %eax,-0x5c(%ebp)
1095d7: 50 push %eax
1095d8: 6a 00 push $0x0
1095da: 6a 01 push $0x1
1095dc: 68 47 1c 12 00 push $0x121c47
1095e1: e8 22 ee ff ff call 108408 <rtems_filesystem_evaluate_path>
if (rv != 0)
1095e6: 83 c4 20 add $0x20,%esp
1095e9: 85 c0 test %eax,%eax
1095eb: 0f 85 9a 00 00 00 jne 10968b <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
1095f1: 8b 15 d0 62 12 00 mov 0x1262d0,%edx
/*
* Bharath: I'm not sure if the check can be reduced to
* if( rtems_current_user_env->task_id != task_id ) {
*/
if (
1095f7: 81 fa c0 85 12 00 cmp $0x1285c0,%edx
1095fd: 74 07 je 109606 <rtems_libio_set_private_env+0x76>
rtems_current_user_env == &rtems_global_user_env
|| rtems_current_user_env->task_id != task_id
1095ff: 8b 45 b4 mov -0x4c(%ebp),%eax
109602: 39 02 cmp %eax,(%edx)
109604: 74 3a je 109640 <rtems_libio_set_private_env+0xb0>
) {
new_env = malloc(sizeof(rtems_user_env_t));
109606: 83 ec 0c sub $0xc,%esp
109609: 6a 48 push $0x48
10960b: e8 14 f4 ff ff call 108a24 <malloc>
109610: 89 c2 mov %eax,%edx
109612: 89 c6 mov %eax,%esi
if (new_env == NULL)
109614: 83 c4 10 add $0x10,%esp
109617: 85 c0 test %eax,%eax
109619: 74 61 je 10967c <rtems_libio_set_private_env+0xec>
#ifdef HAVE_USERENV_REFCNT
new_env->refcnt = 1;
#endif
sc = rtems_task_variable_add(
10961b: 50 push %eax
10961c: 68 50 95 10 00 push $0x109550
109621: 68 d0 62 12 00 push $0x1262d0
109626: 6a 00 push $0x0
109628: 89 55 b0 mov %edx,-0x50(%ebp)
10962b: e8 00 2e 00 00 call 10c430 <rtems_task_variable_add>
RTEMS_SELF,
(void*)&rtems_current_user_env,
(void(*)(void *))free_user_env
);
if (sc != RTEMS_SUCCESSFUL)
109630: 83 c4 10 add $0x10,%esp
109633: 85 c0 test %eax,%eax
109635: 8b 55 b0 mov -0x50(%ebp),%edx
109638: 75 36 jne 109670 <rtems_libio_set_private_env+0xe0>
goto error_3;
rtems_current_user_env = new_env;
10963a: 89 15 d0 62 12 00 mov %edx,0x1262d0
}
/* Inherit the global values */
*rtems_current_user_env = rtems_global_user_env;
109640: be c0 85 12 00 mov $0x1285c0,%esi
109645: b9 12 00 00 00 mov $0x12,%ecx
10964a: 89 d7 mov %edx,%edi
10964c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rtems_current_user_env->task_id = task_id;
10964e: 8b 75 b4 mov -0x4c(%ebp),%esi
109651: 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;
109653: 8d 7a 18 lea 0x18(%edx),%edi
109656: b1 05 mov $0x5,%cl
109658: 89 de mov %ebx,%esi
10965a: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rtems_filesystem_current = current_loc;
10965c: 8d 7a 04 lea 0x4(%edx),%edi
10965f: b1 05 mov $0x5,%cl
109661: 8b 75 a4 mov -0x5c(%ebp),%esi
109664: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return RTEMS_SUCCESSFUL;
109666: 31 c0 xor %eax,%eax
error_1:
rtems_filesystem_freenode(&root_loc);
error_0:
return RTEMS_NO_MEMORY;
}
109668: 8d 65 f4 lea -0xc(%ebp),%esp
10966b: 5b pop %ebx
10966c: 5e pop %esi
10966d: 5f pop %edi
10966e: c9 leave
10966f: c3 ret
rtems_filesystem_current = current_loc;
return RTEMS_SUCCESSFUL;
error_3:
free(new_env);
109670: 83 ec 0c sub $0xc,%esp
109673: 56 push %esi
109674: e8 7b ee ff ff call 1084f4 <free>
109679: 83 c4 10 add $0x10,%esp
error_2:
rtems_filesystem_freenode(¤t_loc);
10967c: 83 ec 0c sub $0xc,%esp
10967f: 8d 45 c0 lea -0x40(%ebp),%eax
109682: 50 push %eax
109683: e8 58 ee ff ff call 1084e0 <rtems_filesystem_freenode>
109688: 83 c4 10 add $0x10,%esp
error_1:
rtems_filesystem_freenode(&root_loc);
10968b: 83 ec 0c sub $0xc,%esp
10968e: 53 push %ebx
10968f: e8 4c ee ff ff call 1084e0 <rtems_filesystem_freenode>
109694: 83 c4 10 add $0x10,%esp
error_0:
return RTEMS_NO_MEMORY;
109697: b8 1a 00 00 00 mov $0x1a,%eax
}
10969c: 8d 65 f4 lea -0xc(%ebp),%esp
10969f: 5b pop %ebx
1096a0: 5e pop %esi
1096a1: 5f pop %edi
1096a2: c9 leave
1096a3: c3 ret
001096a4 <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)
{
1096a4: 55 push %ebp
1096a5: 89 e5 mov %esp,%ebp
1096a7: 56 push %esi
1096a8: 53 push %ebx
1096a9: 83 ec 20 sub $0x20,%esp
1096ac: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
1096af: e8 f8 2c 00 00 call 10c3ac <rtems_task_self>
1096b4: 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 )
1096b6: 39 c3 cmp %eax,%ebx
1096b8: 74 32 je 1096ec <rtems_libio_share_private_env+0x48><== NEVER TAKEN
return RTEMS_SUCCESSFUL;
/*
* Try to get the requested user environment
*/
sc = rtems_task_variable_get(
1096ba: 52 push %edx
task_id,
(void*)&rtems_current_user_env,
(void*)&shared_user_env );
1096bb: 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(
1096be: 50 push %eax
1096bf: 68 d0 62 12 00 push $0x1262d0
1096c4: 53 push %ebx
1096c5: e8 2a 2e 00 00 call 10c4f4 <rtems_task_variable_get>
(void*)&shared_user_env );
/*
* If it was not successful, return the error code
*/
if (sc != RTEMS_SUCCESSFUL)
1096ca: 83 c4 10 add $0x10,%esp
1096cd: 85 c0 test %eax,%eax
1096cf: 75 13 jne 1096e4 <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) {
1096d1: 8b 15 d0 62 12 00 mov 0x1262d0,%edx
1096d7: 39 32 cmp %esi,(%edx)
1096d9: 74 1d je 1096f8 <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;
1096db: 8b 55 f4 mov -0xc(%ebp),%edx
1096de: 89 15 d0 62 12 00 mov %edx,0x1262d0
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
}
1096e4: 8d 65 f8 lea -0x8(%ebp),%esp
1096e7: 5b pop %ebx
1096e8: 5e pop %esi
1096e9: c9 leave
1096ea: c3 ret
1096eb: 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;
1096ec: 31 c0 xor %eax,%eax
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
}
1096ee: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
1096f1: 5b pop %ebx <== NOT EXECUTED
1096f2: 5e pop %esi <== NOT EXECUTED
1096f3: c9 leave <== NOT EXECUTED
1096f4: c3 ret <== NOT EXECUTED
1096f5: 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 );
1096f8: 83 ec 0c sub $0xc,%esp
1096fb: 52 push %edx
1096fc: 89 45 e4 mov %eax,-0x1c(%ebp)
1096ff: e8 4c fe ff ff call 109550 <free_user_env>
109704: 83 c4 10 add $0x10,%esp
109707: 8b 45 e4 mov -0x1c(%ebp),%eax
10970a: eb cf jmp 1096db <rtems_libio_share_private_env+0x37>
0010fdc4 <rtems_libio_to_fcntl_flags>:
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
10fdc4: 55 push %ebp
10fdc5: 89 e5 mov %esp,%ebp
10fdc7: 8b 55 08 mov 0x8(%ebp),%edx
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
10fdca: 89 d0 mov %edx,%eax
10fdcc: 83 e0 06 and $0x6,%eax
10fdcf: 83 f8 06 cmp $0x6,%eax
10fdd2: 74 2c je 10fe00 <rtems_libio_to_fcntl_flags+0x3c>
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
10fdd4: f6 c2 02 test $0x2,%dl
10fdd7: 75 23 jne 10fdfc <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;
10fdd9: 31 c0 xor %eax,%eax
10fddb: f6 c2 04 test $0x4,%dl <== NOT EXECUTED
10fdde: 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 ) {
10fde1: f6 c2 01 test $0x1,%dl
10fde4: 74 03 je 10fde9 <rtems_libio_to_fcntl_flags+0x25>
fcntl_flags |= O_NONBLOCK;
10fde6: 80 cc 40 or $0x40,%ah
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
10fde9: f6 c6 02 test $0x2,%dh
10fdec: 74 03 je 10fdf1 <rtems_libio_to_fcntl_flags+0x2d>
fcntl_flags |= O_APPEND;
10fdee: 83 c8 08 or $0x8,%eax
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
10fdf1: 80 e6 04 and $0x4,%dh
10fdf4: 74 03 je 10fdf9 <rtems_libio_to_fcntl_flags+0x35>
fcntl_flags |= O_CREAT;
10fdf6: 80 cc 02 or $0x2,%ah
}
return fcntl_flags;
}
10fdf9: c9 leave
10fdfa: c3 ret
10fdfb: 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;
10fdfc: 31 c0 xor %eax,%eax
10fdfe: eb e1 jmp 10fde1 <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;
10fe00: b8 02 00 00 00 mov $0x2,%eax
10fe05: eb da jmp 10fde1 <rtems_libio_to_fcntl_flags+0x1d>
0010af10 <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
10af10: 55 push %ebp
10af11: 89 e5 mov %esp,%ebp
10af13: 83 ec 1c sub $0x1c,%esp
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
10af16: 8d 45 f4 lea -0xc(%ebp),%eax
10af19: 50 push %eax
10af1a: ff 75 08 pushl 0x8(%ebp)
10af1d: ff 35 b0 a5 12 00 pushl 0x12a5b0
10af23: e8 d0 5b 00 00 call 110af8 <_Protected_heap_Get_block_size>
10af28: 83 c4 10 add $0x10,%esp
10af2b: 84 c0 test %al,%al
10af2d: 74 11 je 10af40 <rtems_malloc_statistics_at_free+0x30><== NEVER TAKEN
MSBUMP(lifetime_freed, size);
10af2f: 8b 45 f4 mov -0xc(%ebp),%eax
10af32: 31 d2 xor %edx,%edx
10af34: 01 05 a4 f1 12 00 add %eax,0x12f1a4
10af3a: 11 15 a8 f1 12 00 adc %edx,0x12f1a8
}
}
10af40: c9 leave
10af41: c3 ret
0010af44 <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
10af44: 55 push %ebp
10af45: 89 e5 mov %esp,%ebp
10af47: 83 ec 18 sub $0x18,%esp
10af4a: 8b 45 08 mov 0x8(%ebp),%eax
uintptr_t actual_size = 0;
10af4d: 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 )
10af54: 85 c0 test %eax,%eax
10af56: 74 43 je 10af9b <rtems_malloc_statistics_at_malloc+0x57><== NEVER TAKEN
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
10af58: 52 push %edx
10af59: 8d 55 f4 lea -0xc(%ebp),%edx
10af5c: 52 push %edx
10af5d: 50 push %eax
10af5e: ff 35 b0 a5 12 00 pushl 0x12a5b0
10af64: e8 8f 5b 00 00 call 110af8 <_Protected_heap_Get_block_size>
MSBUMP(lifetime_allocated, actual_size);
10af69: 8b 45 f4 mov -0xc(%ebp),%eax
10af6c: 31 d2 xor %edx,%edx
10af6e: 03 05 9c f1 12 00 add 0x12f19c,%eax
10af74: 13 15 a0 f1 12 00 adc 0x12f1a0,%edx
10af7a: a3 9c f1 12 00 mov %eax,0x12f19c
10af7f: 89 15 a0 f1 12 00 mov %edx,0x12f1a0
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
10af85: 2b 05 a4 f1 12 00 sub 0x12f1a4,%eax
if (current_depth > s->max_depth)
10af8b: 83 c4 10 add $0x10,%esp
10af8e: 3b 05 98 f1 12 00 cmp 0x12f198,%eax
10af94: 76 05 jbe 10af9b <rtems_malloc_statistics_at_malloc+0x57>
s->max_depth = current_depth;
10af96: a3 98 f1 12 00 mov %eax,0x12f198
}
10af9b: c9 leave
10af9c: c3 ret
00113dc8 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
113dc8: 55 push %ebp
113dc9: 89 e5 mov %esp,%ebp
113dcb: 53 push %ebx
113dcc: 83 ec 14 sub $0x14,%esp
113dcf: 8b 5d 08 mov 0x8(%ebp),%ebx
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
113dd2: 85 db test %ebx,%ebx
113dd4: 74 5b je 113e31 <rtems_memalign+0x69>
return EINVAL;
*pointer = NULL;
113dd6: 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()) &&
113ddc: 83 3d 20 bc 12 00 03 cmpl $0x3,0x12bc20
113de3: 74 43 je 113e28 <rtems_memalign+0x60> <== ALWAYS TAKEN
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
113de5: e8 76 53 ff ff call 109160 <malloc_deferred_frees_process>
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
113dea: 6a 00 push $0x0
113dec: ff 75 0c pushl 0xc(%ebp)
113def: ff 75 10 pushl 0x10(%ebp)
113df2: ff 35 f0 75 12 00 pushl 0x1275f0
113df8: e8 8b a5 ff ff call 10e388 <_Protected_heap_Allocate_aligned_with_boundary>
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
113dfd: 83 c4 10 add $0x10,%esp
113e00: 85 c0 test %eax,%eax
113e02: 74 38 je 113e3c <rtems_memalign+0x74>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
113e04: 8b 15 48 9c 12 00 mov 0x129c48,%edx
113e0a: 85 d2 test %edx,%edx
113e0c: 74 10 je 113e1e <rtems_memalign+0x56>
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
113e0e: 83 ec 0c sub $0xc,%esp
113e11: 53 push %ebx
113e12: 89 45 f4 mov %eax,-0xc(%ebp)
113e15: ff 52 04 call *0x4(%edx)
113e18: 83 c4 10 add $0x10,%esp
113e1b: 8b 45 f4 mov -0xc(%ebp),%eax
*pointer = return_this;
113e1e: 89 03 mov %eax,(%ebx)
return 0;
113e20: 31 c0 xor %eax,%eax
}
113e22: 8b 5d fc mov -0x4(%ebp),%ebx
113e25: c9 leave
113e26: c3 ret
113e27: 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() )
113e28: e8 f3 52 ff ff call 109120 <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()) &&
113e2d: 84 c0 test %al,%al
113e2f: 75 b4 jne 113de5 <rtems_memalign+0x1d> <== ALWAYS TAKEN
!malloc_is_system_state_OK() )
return EINVAL;
113e31: 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;
}
113e36: 8b 5d fc mov -0x4(%ebp),%ebx
113e39: c9 leave
113e3a: c3 ret
113e3b: 90 nop
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
return ENOMEM;
113e3c: b8 0c 00 00 00 mov $0xc,%eax
113e41: eb df jmp 113e22 <rtems_memalign+0x5a>
001163bc <rtems_message_queue_broadcast>:
rtems_id id,
const void *buffer,
size_t size,
uint32_t *count
)
{
1163bc: 55 push %ebp
1163bd: 89 e5 mov %esp,%ebp
1163bf: 57 push %edi
1163c0: 56 push %esi
1163c1: 53 push %ebx
1163c2: 83 ec 1c sub $0x1c,%esp
1163c5: 8b 7d 08 mov 0x8(%ebp),%edi
1163c8: 8b 5d 0c mov 0xc(%ebp),%ebx
1163cb: 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 )
1163ce: 85 db test %ebx,%ebx
1163d0: 74 62 je 116434 <rtems_message_queue_broadcast+0x78>
return RTEMS_INVALID_ADDRESS;
if ( !count )
1163d2: 85 f6 test %esi,%esi
1163d4: 74 5e je 116434 <rtems_message_queue_broadcast+0x78>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
1163d6: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
1163d7: 8d 45 e4 lea -0x1c(%ebp),%eax
1163da: 50 push %eax
1163db: 57 push %edi
1163dc: 68 20 34 14 00 push $0x143420
1163e1: e8 f6 4e 00 00 call 11b2dc <_Objects_Get>
switch ( location ) {
1163e6: 83 c4 10 add $0x10,%esp
1163e9: 8b 55 e4 mov -0x1c(%ebp),%edx
1163ec: 85 d2 test %edx,%edx
1163ee: 74 10 je 116400 <rtems_message_queue_broadcast+0x44>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1163f0: b8 04 00 00 00 mov $0x4,%eax
}
1163f5: 8d 65 f4 lea -0xc(%ebp),%esp
1163f8: 5b pop %ebx
1163f9: 5e pop %esi
1163fa: 5f pop %edi
1163fb: c9 leave
1163fc: c3 ret
1163fd: 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(
116400: 83 ec 08 sub $0x8,%esp
116403: 56 push %esi
116404: 6a 00 push $0x0
116406: 57 push %edi
116407: ff 75 10 pushl 0x10(%ebp)
11640a: 53 push %ebx
11640b: 83 c0 14 add $0x14,%eax
11640e: 50 push %eax
11640f: e8 c8 34 00 00 call 1198dc <_CORE_message_queue_Broadcast>
116414: 89 c3 mov %eax,%ebx
NULL,
#endif
count
);
_Thread_Enable_dispatch();
116416: 83 c4 20 add $0x20,%esp
116419: e8 36 5a 00 00 call 11be54 <_Thread_Enable_dispatch>
return
11641e: 83 ec 0c sub $0xc,%esp
116421: 53 push %ebx
116422: e8 69 03 00 00 call 116790 <_Message_queue_Translate_core_message_queue_return_code>
116427: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11642a: 8d 65 f4 lea -0xc(%ebp),%esp
11642d: 5b pop %ebx
11642e: 5e pop %esi
11642f: 5f pop %edi
116430: c9 leave
116431: c3 ret
116432: 66 90 xchg %ax,%ax
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !count )
return RTEMS_INVALID_ADDRESS;
116434: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116439: 8d 65 f4 lea -0xc(%ebp),%esp
11643c: 5b pop %ebx
11643d: 5e pop %esi
11643e: 5f pop %edi
11643f: c9 leave
116440: c3 ret
00113858 <rtems_message_queue_create>:
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
113858: 55 push %ebp
113859: 89 e5 mov %esp,%ebp
11385b: 57 push %edi
11385c: 56 push %esi
11385d: 53 push %ebx
11385e: 83 ec 2c sub $0x2c,%esp
113861: 8b 5d 08 mov 0x8(%ebp),%ebx
113864: 8b 75 0c mov 0xc(%ebp),%esi
113867: 8b 4d 10 mov 0x10(%ebp),%ecx
11386a: 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 ) )
11386d: 85 db test %ebx,%ebx
11386f: 74 2f je 1138a0 <rtems_message_queue_create+0x48>
return RTEMS_INVALID_NAME;
if ( !id )
113871: 85 ff test %edi,%edi
113873: 0f 84 a3 00 00 00 je 11391c <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 )
113879: 85 f6 test %esi,%esi
11387b: 74 13 je 113890 <rtems_message_queue_create+0x38>
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
11387d: 85 c9 test %ecx,%ecx
11387f: 75 2f jne 1138b0 <rtems_message_queue_create+0x58>
return RTEMS_INVALID_SIZE;
113881: b8 08 00 00 00 mov $0x8,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
113886: 8d 65 f4 lea -0xc(%ebp),%esp
113889: 5b pop %ebx
11388a: 5e pop %esi
11388b: 5f pop %edi
11388c: c9 leave
11388d: c3 ret
11388e: 66 90 xchg %ax,%ax
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
return RTEMS_INVALID_NUMBER;
113890: b8 0a 00 00 00 mov $0xa,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
113895: 8d 65 f4 lea -0xc(%ebp),%esp
113898: 5b pop %ebx
113899: 5e pop %esi
11389a: 5f pop %edi
11389b: c9 leave
11389c: c3 ret
11389d: 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;
1138a0: b8 03 00 00 00 mov $0x3,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
1138a5: 8d 65 f4 lea -0xc(%ebp),%esp
1138a8: 5b pop %ebx
1138a9: 5e pop %esi
1138aa: 5f pop %edi
1138ab: c9 leave
1138ac: c3 ret
1138ad: 8d 76 00 lea 0x0(%esi),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
1138b0: a1 30 07 13 00 mov 0x130730,%eax
1138b5: 40 inc %eax
1138b6: a3 30 07 13 00 mov %eax,0x130730
#endif
#endif
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
1138bb: 89 4d d4 mov %ecx,-0x2c(%ebp)
1138be: e8 09 60 00 00 call 1198cc <_Message_queue_Allocate>
1138c3: 89 c2 mov %eax,%edx
if ( !the_message_queue ) {
1138c5: 85 c0 test %eax,%eax
1138c7: 8b 4d d4 mov -0x2c(%ebp),%ecx
1138ca: 74 7c je 113948 <rtems_message_queue_create+0xf0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_message_queue->attribute_set = attribute_set;
1138cc: 8b 45 14 mov 0x14(%ebp),%eax
1138cf: 89 42 10 mov %eax,0x10(%edx)
if (_Attributes_Is_priority( attribute_set ) )
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
1138d2: a8 04 test $0x4,%al
1138d4: 0f 95 c0 setne %al
1138d7: 0f b6 c0 movzbl %al,%eax
1138da: 89 45 e4 mov %eax,-0x1c(%ebp)
else
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
if ( ! _CORE_message_queue_Initialize(
1138dd: 51 push %ecx
1138de: 56 push %esi
1138df: 8d 45 e4 lea -0x1c(%ebp),%eax
1138e2: 50 push %eax
1138e3: 8d 42 14 lea 0x14(%edx),%eax
1138e6: 50 push %eax
1138e7: 89 55 d4 mov %edx,-0x2c(%ebp)
1138ea: e8 2d 11 00 00 call 114a1c <_CORE_message_queue_Initialize>
1138ef: 83 c4 10 add $0x10,%esp
1138f2: 84 c0 test %al,%al
1138f4: 8b 55 d4 mov -0x2c(%ebp),%edx
1138f7: 75 2f jne 113928 <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 );
1138f9: 83 ec 08 sub $0x8,%esp
1138fc: 52 push %edx
1138fd: 68 20 11 13 00 push $0x131120
113902: e8 b1 1f 00 00 call 1158b8 <_Objects_Free>
_Objects_MP_Close(
&_Message_queue_Information, the_message_queue->Object.id);
#endif
_Message_queue_Free( the_message_queue );
_Thread_Enable_dispatch();
113907: e8 e4 2c 00 00 call 1165f0 <_Thread_Enable_dispatch>
return RTEMS_UNSATISFIED;
11390c: 83 c4 10 add $0x10,%esp
11390f: b8 0d 00 00 00 mov $0xd,%eax
113914: e9 6d ff ff ff jmp 113886 <rtems_message_queue_create+0x2e>
113919: 8d 76 00 lea 0x0(%esi),%esi
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
11391c: b8 09 00 00 00 mov $0x9,%eax
113921: e9 60 ff ff ff jmp 113886 <rtems_message_queue_create+0x2e>
113926: 66 90 xchg %ax,%ax
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
113928: 8b 42 08 mov 0x8(%edx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
11392b: 0f b7 f0 movzwl %ax,%esi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
11392e: 8b 0d 3c 11 13 00 mov 0x13113c,%ecx
113934: 89 14 b1 mov %edx,(%ecx,%esi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
113937: 89 5a 0c mov %ebx,0xc(%edx)
&_Message_queue_Information,
&the_message_queue->Object,
(Objects_Name) name
);
*id = the_message_queue->Object.id;
11393a: 89 07 mov %eax,(%edi)
name,
0
);
#endif
_Thread_Enable_dispatch();
11393c: e8 af 2c 00 00 call 1165f0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
113941: 31 c0 xor %eax,%eax
113943: e9 3e ff ff ff jmp 113886 <rtems_message_queue_create+0x2e>
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
if ( !the_message_queue ) {
_Thread_Enable_dispatch();
113948: e8 a3 2c 00 00 call 1165f0 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
11394d: b8 05 00 00 00 mov $0x5,%eax
113952: e9 2f ff ff ff jmp 113886 <rtems_message_queue_create+0x2e>
00116544 <rtems_message_queue_delete>:
*/
rtems_status_code rtems_message_queue_delete(
rtems_id id
)
{
116544: 55 push %ebp
116545: 89 e5 mov %esp,%ebp
116547: 53 push %ebx
116548: 83 ec 18 sub $0x18,%esp
register Message_queue_Control *the_message_queue;
Objects_Locations location;
the_message_queue = _Message_queue_Get( id, &location );
11654b: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
11654e: 50 push %eax
11654f: ff 75 08 pushl 0x8(%ebp)
116552: 68 20 34 14 00 push $0x143420
116557: e8 80 4d 00 00 call 11b2dc <_Objects_Get>
11655c: 89 c3 mov %eax,%ebx
switch ( location ) {
11655e: 83 c4 10 add $0x10,%esp
116561: 8b 4d f4 mov -0xc(%ebp),%ecx
116564: 85 c9 test %ecx,%ecx
116566: 75 3c jne 1165a4 <rtems_message_queue_delete+0x60>
case OBJECTS_LOCAL:
_Objects_Close( &_Message_queue_Information,
116568: 83 ec 08 sub $0x8,%esp
11656b: 50 push %eax
11656c: 68 20 34 14 00 push $0x143420
116571: e8 f2 48 00 00 call 11ae68 <_Objects_Close>
&the_message_queue->Object );
_CORE_message_queue_Close(
116576: 83 c4 0c add $0xc,%esp
116579: 6a 05 push $0x5
11657b: 6a 00 push $0x0
11657d: 8d 43 14 lea 0x14(%ebx),%eax
116580: 50 push %eax
116581: e8 da 33 00 00 call 119960 <_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 );
116586: 58 pop %eax
116587: 5a pop %edx
116588: 53 push %ebx
116589: 68 20 34 14 00 push $0x143420
11658e: e8 cd 4b 00 00 call 11b160 <_Objects_Free>
0, /* Not used */
0
);
}
#endif
_Thread_Enable_dispatch();
116593: e8 bc 58 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116598: 83 c4 10 add $0x10,%esp
11659b: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11659d: 8b 5d fc mov -0x4(%ebp),%ebx
1165a0: c9 leave
1165a1: c3 ret
1165a2: 66 90 xchg %ax,%ax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1165a4: b8 04 00 00 00 mov $0x4,%eax
}
1165a9: 8b 5d fc mov -0x4(%ebp),%ebx
1165ac: c9 leave
1165ad: c3 ret
001165b0 <rtems_message_queue_flush>:
rtems_status_code rtems_message_queue_flush(
rtems_id id,
uint32_t *count
)
{
1165b0: 55 push %ebp
1165b1: 89 e5 mov %esp,%ebp
1165b3: 53 push %ebx
1165b4: 83 ec 14 sub $0x14,%esp
1165b7: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
1165ba: 85 db test %ebx,%ebx
1165bc: 74 46 je 116604 <rtems_message_queue_flush+0x54>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
1165be: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
1165bf: 8d 45 f4 lea -0xc(%ebp),%eax
1165c2: 50 push %eax
1165c3: ff 75 08 pushl 0x8(%ebp)
1165c6: 68 20 34 14 00 push $0x143420
1165cb: e8 0c 4d 00 00 call 11b2dc <_Objects_Get>
switch ( location ) {
1165d0: 83 c4 10 add $0x10,%esp
1165d3: 8b 55 f4 mov -0xc(%ebp),%edx
1165d6: 85 d2 test %edx,%edx
1165d8: 74 0a je 1165e4 <rtems_message_queue_flush+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1165da: b8 04 00 00 00 mov $0x4,%eax
}
1165df: 8b 5d fc mov -0x4(%ebp),%ebx
1165e2: c9 leave
1165e3: 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 );
1165e4: 83 ec 0c sub $0xc,%esp
1165e7: 83 c0 14 add $0x14,%eax
1165ea: 50 push %eax
1165eb: e8 ac 33 00 00 call 11999c <_CORE_message_queue_Flush>
1165f0: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
1165f2: e8 5d 58 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1165f7: 83 c4 10 add $0x10,%esp
1165fa: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1165fc: 8b 5d fc mov -0x4(%ebp),%ebx
1165ff: c9 leave
116600: c3 ret
116601: 8d 76 00 lea 0x0(%esi),%esi
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
return RTEMS_INVALID_ADDRESS;
116604: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116609: 8b 5d fc mov -0x4(%ebp),%ebx
11660c: c9 leave
11660d: c3 ret
00116610 <rtems_message_queue_get_number_pending>:
rtems_status_code rtems_message_queue_get_number_pending(
rtems_id id,
uint32_t *count
)
{
116610: 55 push %ebp
116611: 89 e5 mov %esp,%ebp
116613: 53 push %ebx
116614: 83 ec 14 sub $0x14,%esp
116617: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
11661a: 85 db test %ebx,%ebx
11661c: 74 3a je 116658 <rtems_message_queue_get_number_pending+0x48>
11661e: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
11661f: 8d 45 f4 lea -0xc(%ebp),%eax
116622: 50 push %eax
116623: ff 75 08 pushl 0x8(%ebp)
116626: 68 20 34 14 00 push $0x143420
11662b: e8 ac 4c 00 00 call 11b2dc <_Objects_Get>
switch ( location ) {
116630: 83 c4 10 add $0x10,%esp
116633: 8b 55 f4 mov -0xc(%ebp),%edx
116636: 85 d2 test %edx,%edx
116638: 74 0a je 116644 <rtems_message_queue_get_number_pending+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11663a: b8 04 00 00 00 mov $0x4,%eax
}
11663f: 8b 5d fc mov -0x4(%ebp),%ebx
116642: c9 leave
116643: 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;
116644: 8b 40 5c mov 0x5c(%eax),%eax
116647: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
116649: e8 06 58 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11664e: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116650: 8b 5d fc mov -0x4(%ebp),%ebx
116653: c9 leave
116654: c3 ret
116655: 8d 76 00 lea 0x0(%esi),%esi
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
return RTEMS_INVALID_ADDRESS;
116658: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11665d: 8b 5d fc mov -0x4(%ebp),%ebx
116660: c9 leave
116661: c3 ret
0011397c <rtems_message_queue_receive>:
void *buffer,
size_t *size,
rtems_option option_set,
rtems_interval timeout
)
{
11397c: 55 push %ebp
11397d: 89 e5 mov %esp,%ebp
11397f: 56 push %esi
113980: 53 push %ebx
113981: 83 ec 10 sub $0x10,%esp
113984: 8b 5d 0c mov 0xc(%ebp),%ebx
113987: 8b 75 10 mov 0x10(%ebp),%esi
register Message_queue_Control *the_message_queue;
Objects_Locations location;
bool wait;
if ( !buffer )
11398a: 85 db test %ebx,%ebx
11398c: 74 6e je 1139fc <rtems_message_queue_receive+0x80>
return RTEMS_INVALID_ADDRESS;
if ( !size )
11398e: 85 f6 test %esi,%esi
113990: 74 6a je 1139fc <rtems_message_queue_receive+0x80>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
113992: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
113993: 8d 45 f4 lea -0xc(%ebp),%eax
113996: 50 push %eax
113997: ff 75 08 pushl 0x8(%ebp)
11399a: 68 20 11 13 00 push $0x131120
11399f: e8 54 20 00 00 call 1159f8 <_Objects_Get>
switch ( location ) {
1139a4: 83 c4 10 add $0x10,%esp
1139a7: 8b 55 f4 mov -0xc(%ebp),%edx
1139aa: 85 d2 test %edx,%edx
1139ac: 75 42 jne 1139f0 <rtems_message_queue_receive+0x74>
if ( _Options_Is_no_wait( option_set ) )
wait = false;
else
wait = true;
_CORE_message_queue_Seize(
1139ae: 83 ec 08 sub $0x8,%esp
1139b1: ff 75 18 pushl 0x18(%ebp)
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (
rtems_option option_set
)
{
return (option_set & RTEMS_NO_WAIT) ? true : false;
1139b4: 8b 55 14 mov 0x14(%ebp),%edx
1139b7: 83 e2 01 and $0x1,%edx
1139ba: 83 f2 01 xor $0x1,%edx
1139bd: 52 push %edx
1139be: 56 push %esi
1139bf: 53 push %ebx
1139c0: ff 70 08 pushl 0x8(%eax)
1139c3: 83 c0 14 add $0x14,%eax
1139c6: 50 push %eax
1139c7: e8 00 11 00 00 call 114acc <_CORE_message_queue_Seize>
buffer,
size,
wait,
timeout
);
_Thread_Enable_dispatch();
1139cc: 83 c4 20 add $0x20,%esp
1139cf: e8 1c 2c 00 00 call 1165f0 <_Thread_Enable_dispatch>
return _Message_queue_Translate_core_message_queue_return_code(
1139d4: 83 ec 0c sub $0xc,%esp
_Thread_Executing->Wait.return_code
1139d7: a1 d8 0c 13 00 mov 0x130cd8,%eax
size,
wait,
timeout
);
_Thread_Enable_dispatch();
return _Message_queue_Translate_core_message_queue_return_code(
1139dc: ff 70 34 pushl 0x34(%eax)
1139df: e8 a0 00 00 00 call 113a84 <_Message_queue_Translate_core_message_queue_return_code>
1139e4: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1139e7: 8d 65 f8 lea -0x8(%ebp),%esp
1139ea: 5b pop %ebx
1139eb: 5e pop %esi
1139ec: c9 leave
1139ed: c3 ret
1139ee: 66 90 xchg %ax,%ax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1139f0: b8 04 00 00 00 mov $0x4,%eax
}
1139f5: 8d 65 f8 lea -0x8(%ebp),%esp
1139f8: 5b pop %ebx
1139f9: 5e pop %esi
1139fa: c9 leave
1139fb: c3 ret
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
1139fc: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
113a01: 8d 65 f8 lea -0x8(%ebp),%esp
113a04: 5b pop %ebx
113a05: 5e pop %esi
113a06: c9 leave
113a07: c3 ret
0010b3a8 <rtems_message_queue_send>:
rtems_status_code rtems_message_queue_send(
rtems_id id,
const void *buffer,
size_t size
)
{
10b3a8: 55 push %ebp
10b3a9: 89 e5 mov %esp,%ebp
10b3ab: 56 push %esi
10b3ac: 53 push %ebx
10b3ad: 83 ec 10 sub $0x10,%esp
10b3b0: 8b 75 08 mov 0x8(%ebp),%esi
10b3b3: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
10b3b6: 85 db test %ebx,%ebx
10b3b8: 74 5e je 10b418 <rtems_message_queue_send+0x70>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
10b3ba: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
10b3bb: 8d 45 f4 lea -0xc(%ebp),%eax
10b3be: 50 push %eax
10b3bf: 56 push %esi
10b3c0: 68 80 87 12 00 push $0x128780
10b3c5: e8 6e 1a 00 00 call 10ce38 <_Objects_Get>
switch ( location ) {
10b3ca: 83 c4 10 add $0x10,%esp
10b3cd: 8b 55 f4 mov -0xc(%ebp),%edx
10b3d0: 85 d2 test %edx,%edx
10b3d2: 74 0c je 10b3e0 <rtems_message_queue_send+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b3d4: b8 04 00 00 00 mov $0x4,%eax
}
10b3d9: 8d 65 f8 lea -0x8(%ebp),%esp
10b3dc: 5b pop %ebx
10b3dd: 5e pop %esi
10b3de: c9 leave
10b3df: c3 ret
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
bool wait,
Watchdog_Interval timeout
)
{
return _CORE_message_queue_Submit(
10b3e0: 6a 00 push $0x0
10b3e2: 6a 00 push $0x0
10b3e4: 68 ff ff ff 7f push $0x7fffffff
10b3e9: 6a 00 push $0x0
10b3eb: 56 push %esi
10b3ec: ff 75 10 pushl 0x10(%ebp)
10b3ef: 53 push %ebx
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status = _CORE_message_queue_Send(
10b3f0: 83 c0 14 add $0x14,%eax
10b3f3: 50 push %eax
10b3f4: e8 3f 0c 00 00 call 10c038 <_CORE_message_queue_Submit>
10b3f9: 89 c3 mov %eax,%ebx
MESSAGE_QUEUE_MP_HANDLER,
false, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
10b3fb: 83 c4 20 add $0x20,%esp
10b3fe: e8 ad 25 00 00 call 10d9b0 <_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);
10b403: 83 ec 0c sub $0xc,%esp
10b406: 53 push %ebx
10b407: e8 18 00 00 00 call 10b424 <_Message_queue_Translate_core_message_queue_return_code>
10b40c: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b40f: 8d 65 f8 lea -0x8(%ebp),%esp
10b412: 5b pop %ebx
10b413: 5e pop %esi
10b414: c9 leave
10b415: c3 ret
10b416: 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;
10b418: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b41d: 8d 65 f8 lea -0x8(%ebp),%esp
10b420: 5b pop %ebx
10b421: 5e pop %esi
10b422: c9 leave
10b423: c3 ret
001167a0 <rtems_message_queue_urgent>:
rtems_status_code rtems_message_queue_urgent(
rtems_id id,
const void *buffer,
size_t size
)
{
1167a0: 55 push %ebp
1167a1: 89 e5 mov %esp,%ebp
1167a3: 56 push %esi
1167a4: 53 push %ebx
1167a5: 83 ec 10 sub $0x10,%esp
1167a8: 8b 75 08 mov 0x8(%ebp),%esi
1167ab: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
1167ae: 85 db test %ebx,%ebx
1167b0: 74 5e je 116810 <rtems_message_queue_urgent+0x70>
1167b2: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
1167b3: 8d 45 f4 lea -0xc(%ebp),%eax
1167b6: 50 push %eax
1167b7: 56 push %esi
1167b8: 68 20 34 14 00 push $0x143420
1167bd: e8 1a 4b 00 00 call 11b2dc <_Objects_Get>
switch ( location ) {
1167c2: 83 c4 10 add $0x10,%esp
1167c5: 8b 55 f4 mov -0xc(%ebp),%edx
1167c8: 85 d2 test %edx,%edx
1167ca: 74 0c je 1167d8 <rtems_message_queue_urgent+0x38>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1167cc: b8 04 00 00 00 mov $0x4,%eax
}
1167d1: 8d 65 f8 lea -0x8(%ebp),%esp
1167d4: 5b pop %ebx
1167d5: 5e pop %esi
1167d6: c9 leave
1167d7: c3 ret
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
bool wait,
Watchdog_Interval timeout
)
{
return _CORE_message_queue_Submit(
1167d8: 6a 00 push $0x0
1167da: 6a 00 push $0x0
1167dc: 68 00 00 00 80 push $0x80000000
1167e1: 6a 00 push $0x0
1167e3: 56 push %esi
1167e4: ff 75 10 pushl 0x10(%ebp)
1167e7: 53 push %ebx
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status = _CORE_message_queue_Urgent(
1167e8: 83 c0 14 add $0x14,%eax
1167eb: 50 push %eax
1167ec: e8 eb 33 00 00 call 119bdc <_CORE_message_queue_Submit>
1167f1: 89 c3 mov %eax,%ebx
id,
MESSAGE_QUEUE_MP_HANDLER,
false, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
1167f3: 83 c4 20 add $0x20,%esp
1167f6: e8 59 56 00 00 call 11be54 <_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);
1167fb: 83 ec 0c sub $0xc,%esp
1167fe: 53 push %ebx
1167ff: e8 8c ff ff ff call 116790 <_Message_queue_Translate_core_message_queue_return_code>
116804: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116807: 8d 65 f8 lea -0x8(%ebp),%esp
11680a: 5b pop %ebx
11680b: 5e pop %esi
11680c: c9 leave
11680d: c3 ret
11680e: 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;
116810: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116815: 8d 65 f8 lea -0x8(%ebp),%esp
116818: 5b pop %ebx
116819: 5e pop %esi
11681a: c9 leave
11681b: c3 ret
001124cc <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
1124cc: 55 push %ebp
1124cd: 89 e5 mov %esp,%ebp
1124cf: 57 push %edi
1124d0: 56 push %esi
1124d1: 53 push %ebx
1124d2: 83 ec 78 sub $0x78,%esp
int success = 0;
char *dup_path = strdup(path);
1124d5: ff 75 08 pushl 0x8(%ebp)
1124d8: e8 c7 35 00 00 call 115aa4 <strdup>
1124dd: 89 c7 mov %eax,%edi
if (dup_path != NULL) {
1124df: 83 c4 10 add $0x10,%esp
1124e2: 85 c0 test %eax,%eax
1124e4: 0f 84 0a 01 00 00 je 1125f4 <rtems_mkdir+0x128> <== NEVER TAKEN
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
1124ea: 8a 10 mov (%eax),%dl
1124ec: 80 fa 2f cmp $0x2f,%dl
1124ef: 0f 84 0f 01 00 00 je 112604 <rtems_mkdir+0x138>
1124f5: 89 c3 mov %eax,%ebx
1124f7: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp)
1124fe: b8 01 00 00 00 mov $0x1,%eax
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
112503: 84 d2 test %dl,%dl
112505: 74 11 je 112518 <rtems_mkdir+0x4c> <== NEVER TAKEN
112507: 90 nop
last = 1;
else if (p[0] != '/')
112508: 80 fa 2f cmp $0x2f,%dl
11250b: 0f 84 83 00 00 00 je 112594 <rtems_mkdir+0xc8>
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
112511: 43 inc %ebx
112512: 8a 13 mov (%ebx),%dl
if (p[0] == '\0')
112514: 84 d2 test %dl,%dl
112516: 75 f0 jne 112508 <rtems_mkdir+0x3c>
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
112518: c6 03 00 movb $0x0,(%ebx)
11251b: be 01 00 00 00 mov $0x1,%esi
if (!last && p[1] == '\0')
last = 1;
if (first) {
112520: 85 c0 test %eax,%eax
112522: 75 54 jne 112578 <rtems_mkdir+0xac>
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
112524: 85 f6 test %esi,%esi
112526: 75 3c jne 112564 <rtems_mkdir+0x98>
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
112528: b8 ff 01 00 00 mov $0x1ff,%eax
11252d: 83 ec 08 sub $0x8,%esp
112530: 50 push %eax
112531: 57 push %edi
112532: e8 cd 71 ff ff call 109704 <mkdir>
112537: 83 c4 10 add $0x10,%esp
11253a: 85 c0 test %eax,%eax
11253c: 78 6a js 1125a8 <rtems_mkdir+0xdc>
} else {
retval = 0;
break;
}
}
if (!last)
11253e: 85 f6 test %esi,%esi
112540: 75 0a jne 11254c <rtems_mkdir+0x80>
*p = '/';
112542: c6 03 2f movb $0x2f,(%ebx)
112545: 31 c0 xor %eax,%eax
112547: eb c8 jmp 112511 <rtems_mkdir+0x45>
112549: 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);
11254c: 83 ec 0c sub $0xc,%esp
11254f: 57 push %edi
112550: e8 b7 6b ff ff call 10910c <free>
112555: 83 c4 10 add $0x10,%esp
}
return success != 0 ? 0 : -1;
112558: 31 c0 xor %eax,%eax
}
11255a: 8d 65 f4 lea -0xc(%ebp),%esp
11255d: 5b pop %ebx
11255e: 5e pop %esi
11255f: 5f pop %edi
112560: c9 leave
112561: c3 ret
112562: 66 90 xchg %ax,%ax
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
(void)umask(oumask);
112564: 83 ec 0c sub $0xc,%esp
112567: ff 75 94 pushl -0x6c(%ebp)
11256a: e8 81 01 00 00 call 1126f0 <umask>
11256f: 83 c4 10 add $0x10,%esp
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
112572: 8b 45 0c mov 0xc(%ebp),%eax
112575: eb b6 jmp 11252d <rtems_mkdir+0x61>
112577: 90 nop
* mkdir [-m mode] dir
*
* We change the user's umask and then restore it,
* instead of doing chmod's.
*/
oumask = umask(0);
112578: 83 ec 0c sub $0xc,%esp
11257b: 6a 00 push $0x0
11257d: e8 6e 01 00 00 call 1126f0 <umask>
112582: 89 45 94 mov %eax,-0x6c(%ebp)
numask = oumask & ~(S_IWUSR | S_IXUSR);
112585: 24 3f and $0x3f,%al
(void)umask(numask);
112587: 89 04 24 mov %eax,(%esp)
11258a: e8 61 01 00 00 call 1126f0 <umask>
11258f: 83 c4 10 add $0x10,%esp
112592: eb 90 jmp 112524 <rtems_mkdir+0x58>
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
112594: c6 03 00 movb $0x0,(%ebx)
if (!last && p[1] == '\0')
112597: 31 d2 xor %edx,%edx
112599: 80 7b 01 00 cmpb $0x0,0x1(%ebx)
11259d: 0f 94 c2 sete %dl
1125a0: 89 d6 mov %edx,%esi
1125a2: e9 79 ff ff ff jmp 112520 <rtems_mkdir+0x54>
1125a7: 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) {
1125a8: e8 6b 28 00 00 call 114e18 <__errno>
1125ad: 83 38 11 cmpl $0x11,(%eax)
1125b0: 74 0a je 1125bc <rtems_mkdir+0xf0>
1125b2: e8 61 28 00 00 call 114e18 <__errno>
1125b7: 83 38 15 cmpl $0x15,(%eax)
1125ba: 75 53 jne 11260f <rtems_mkdir+0x143> <== ALWAYS TAKEN
if (stat(path, &sb) < 0) {
1125bc: 83 ec 08 sub $0x8,%esp
1125bf: 8d 45 a0 lea -0x60(%ebp),%eax
1125c2: 50 push %eax
1125c3: 57 push %edi
1125c4: e8 7f 00 00 00 call 112648 <stat>
1125c9: 83 c4 10 add $0x10,%esp
1125cc: 85 c0 test %eax,%eax
1125ce: 78 3f js 11260f <rtems_mkdir+0x143> <== NEVER TAKEN
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
1125d0: 8b 45 ac mov -0x54(%ebp),%eax
1125d3: 25 00 f0 00 00 and $0xf000,%eax
1125d8: 3d 00 40 00 00 cmp $0x4000,%eax
1125dd: 0f 84 5b ff ff ff je 11253e <rtems_mkdir+0x72>
if (last)
1125e3: 85 f6 test %esi,%esi
1125e5: 74 53 je 11263a <rtems_mkdir+0x16e>
errno = EEXIST;
1125e7: e8 2c 28 00 00 call 114e18 <__errno>
1125ec: c7 00 11 00 00 00 movl $0x11,(%eax)
1125f2: eb 2d jmp 112621 <rtems_mkdir+0x155>
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
}
return success != 0 ? 0 : -1;
1125f4: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
}
1125f9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1125fc: 5b pop %ebx <== NOT EXECUTED
1125fd: 5e pop %esi <== NOT EXECUTED
1125fe: 5f pop %edi <== NOT EXECUTED
1125ff: c9 leave <== NOT EXECUTED
112600: c3 ret <== NOT EXECUTED
112601: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
112604: 8d 58 01 lea 0x1(%eax),%ebx
112607: 8a 50 01 mov 0x1(%eax),%dl
11260a: e9 e8 fe ff ff jmp 1124f7 <rtems_mkdir+0x2b>
}
}
if (!last)
*p = '/';
}
if (!first && !last)
11260f: 85 f6 test %esi,%esi
112611: 75 0e jne 112621 <rtems_mkdir+0x155> <== ALWAYS TAKEN
(void)umask(oumask);
112613: 83 ec 0c sub $0xc,%esp
112616: ff 75 94 pushl -0x6c(%ebp)
112619: e8 d2 00 00 00 call 1126f0 <umask>
11261e: 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);
112621: 83 ec 0c sub $0xc,%esp
112624: 57 push %edi
112625: e8 e2 6a ff ff call 10910c <free>
11262a: 83 c4 10 add $0x10,%esp
}
return success != 0 ? 0 : -1;
11262d: b8 ff ff ff ff mov $0xffffffff,%eax
}
112632: 8d 65 f4 lea -0xc(%ebp),%esp
112635: 5b pop %ebx
112636: 5e pop %esi
112637: 5f pop %edi
112638: c9 leave
112639: c3 ret
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
errno = EEXIST;
else
errno = ENOTDIR;
11263a: e8 d9 27 00 00 call 114e18 <__errno>
11263f: c7 00 14 00 00 00 movl $0x14,(%eax)
112645: eb cc jmp 112613 <rtems_mkdir+0x147>
0010b978 <rtems_object_get_api_name>:
};
const char *rtems_object_get_api_name(
int api
)
{
10b978: 55 push %ebp
10b979: 89 e5 mov %esp,%ebp
10b97b: 83 ec 10 sub $0x10,%esp
const rtems_assoc_t *api_assoc;
api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api );
10b97e: ff 75 08 pushl 0x8(%ebp)
10b981: 68 40 7c 12 00 push $0x127c40
10b986: e8 d9 49 00 00 call 110364 <rtems_assoc_ptr_by_local>
if ( api_assoc )
10b98b: 83 c4 10 add $0x10,%esp
10b98e: 85 c0 test %eax,%eax
10b990: 74 06 je 10b998 <rtems_object_get_api_name+0x20>
return api_assoc->name;
10b992: 8b 00 mov (%eax),%eax
return "BAD CLASS";
}
10b994: c9 leave
10b995: c3 ret
10b996: 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";
10b998: b8 63 2c 12 00 mov $0x122c63,%eax
}
10b99d: c9 leave
10b99e: c3 ret
0010cf60 <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
)
{
10cf60: 55 push %ebp
10cf61: 89 e5 mov %esp,%ebp
10cf63: 57 push %edi
10cf64: 56 push %esi
10cf65: 53 push %ebx
10cf66: 83 ec 0c sub $0xc,%esp
10cf69: 8b 5d 10 mov 0x10(%ebp),%ebx
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
10cf6c: 85 db test %ebx,%ebx
10cf6e: 74 60 je 10cfd0 <rtems_object_get_class_information+0x70>
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
10cf70: 83 ec 08 sub $0x8,%esp
10cf73: 0f b7 45 0c movzwl 0xc(%ebp),%eax
10cf77: 50 push %eax
10cf78: ff 75 08 pushl 0x8(%ebp)
10cf7b: e8 4c 1b 00 00 call 10eacc <_Objects_Get_information>
if ( !obj_info )
10cf80: 83 c4 10 add $0x10,%esp
10cf83: 85 c0 test %eax,%eax
10cf85: 74 59 je 10cfe0 <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;
10cf87: 8b 50 08 mov 0x8(%eax),%edx
10cf8a: 89 13 mov %edx,(%ebx)
info->maximum_id = obj_info->maximum_id;
10cf8c: 8b 50 0c mov 0xc(%eax),%edx
10cf8f: 89 53 04 mov %edx,0x4(%ebx)
info->auto_extend = obj_info->auto_extend;
10cf92: 8a 50 12 mov 0x12(%eax),%dl
10cf95: 88 53 0c mov %dl,0xc(%ebx)
info->maximum = obj_info->maximum;
10cf98: 0f b7 70 10 movzwl 0x10(%eax),%esi
10cf9c: 89 73 08 mov %esi,0x8(%ebx)
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
10cf9f: 85 f6 test %esi,%esi
10cfa1: 74 44 je 10cfe7 <rtems_object_get_class_information+0x87><== NEVER TAKEN
10cfa3: 8b 78 1c mov 0x1c(%eax),%edi
10cfa6: b9 01 00 00 00 mov $0x1,%ecx
10cfab: b8 01 00 00 00 mov $0x1,%eax
10cfb0: 31 d2 xor %edx,%edx
10cfb2: 66 90 xchg %ax,%ax
if ( !obj_info->local_table[i] )
unallocated++;
10cfb4: 83 3c 8f 01 cmpl $0x1,(%edi,%ecx,4)
10cfb8: 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++ )
10cfbb: 40 inc %eax
10cfbc: 89 c1 mov %eax,%ecx
10cfbe: 39 c6 cmp %eax,%esi
10cfc0: 73 f2 jae 10cfb4 <rtems_object_get_class_information+0x54>
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
10cfc2: 89 53 10 mov %edx,0x10(%ebx)
return RTEMS_SUCCESSFUL;
10cfc5: 31 c0 xor %eax,%eax
}
10cfc7: 8d 65 f4 lea -0xc(%ebp),%esp
10cfca: 5b pop %ebx
10cfcb: 5e pop %esi
10cfcc: 5f pop %edi
10cfcd: c9 leave
10cfce: c3 ret
10cfcf: 90 nop
/*
* Validate parameters and look up information structure.
*/
if ( !info )
return RTEMS_INVALID_ADDRESS;
10cfd0: b8 09 00 00 00 mov $0x9,%eax
unallocated++;
info->unallocated = unallocated;
return RTEMS_SUCCESSFUL;
}
10cfd5: 8d 65 f4 lea -0xc(%ebp),%esp
10cfd8: 5b pop %ebx
10cfd9: 5e pop %esi
10cfda: 5f pop %edi
10cfdb: c9 leave
10cfdc: c3 ret
10cfdd: 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;
10cfe0: b8 0a 00 00 00 mov $0xa,%eax
10cfe5: eb e0 jmp 10cfc7 <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++ )
10cfe7: 31 d2 xor %edx,%edx
10cfe9: eb d7 jmp 10cfc2 <rtems_object_get_class_information+0x62>
0010c520 <rtems_object_get_classic_name>:
rtems_status_code rtems_object_get_classic_name(
rtems_id id,
rtems_name *name
)
{
10c520: 55 push %ebp
10c521: 89 e5 mov %esp,%ebp
10c523: 53 push %ebx
10c524: 83 ec 14 sub $0x14,%esp
10c527: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
10c52a: 85 db test %ebx,%ebx
10c52c: 74 26 je 10c554 <rtems_object_get_classic_name+0x34>
return RTEMS_INVALID_ADDRESS;
status = _Objects_Id_to_name( id, &name_u );
10c52e: 83 ec 08 sub $0x8,%esp
10c531: 8d 45 f4 lea -0xc(%ebp),%eax
10c534: 50 push %eax
10c535: ff 75 08 pushl 0x8(%ebp)
10c538: e8 a7 1b 00 00 call 10e0e4 <_Objects_Id_to_name>
*name = name_u.name_u32;
10c53d: 8b 55 f4 mov -0xc(%ebp),%edx
10c540: 89 13 mov %edx,(%ebx)
return _Status_Object_name_errors_to_status[ status ];
10c542: 8b 04 85 4c 38 12 00 mov 0x12384c(,%eax,4),%eax
10c549: 83 c4 10 add $0x10,%esp
}
10c54c: 8b 5d fc mov -0x4(%ebp),%ebx
10c54f: c9 leave
10c550: c3 ret
10c551: 8d 76 00 lea 0x0(%esi),%esi
{
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
return RTEMS_INVALID_ADDRESS;
10c554: 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 ];
}
10c559: 8b 5d fc mov -0x4(%ebp),%ebx
10c55c: c9 leave
10c55d: c3 ret
0010b9ac <rtems_object_set_name>:
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
10b9ac: 55 push %ebp
10b9ad: 89 e5 mov %esp,%ebp
10b9af: 57 push %edi
10b9b0: 56 push %esi
10b9b1: 53 push %ebx
10b9b2: 83 ec 1c sub $0x1c,%esp
10b9b5: 8b 75 08 mov 0x8(%ebp),%esi
10b9b8: 8b 7d 0c mov 0xc(%ebp),%edi
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
10b9bb: 85 ff test %edi,%edi
10b9bd: 74 61 je 10ba20 <rtems_object_set_name+0x74>
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10b9bf: 85 f6 test %esi,%esi
10b9c1: 74 35 je 10b9f8 <rtems_object_set_name+0x4c>
information = _Objects_Get_information_id( tmpId );
10b9c3: 83 ec 0c sub $0xc,%esp
10b9c6: 56 push %esi
10b9c7: e8 24 19 00 00 call 10d2f0 <_Objects_Get_information_id>
10b9cc: 89 c3 mov %eax,%ebx
if ( !information )
10b9ce: 83 c4 10 add $0x10,%esp
10b9d1: 85 c0 test %eax,%eax
10b9d3: 74 16 je 10b9eb <rtems_object_set_name+0x3f>
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
10b9d5: 50 push %eax
10b9d6: 8d 45 e4 lea -0x1c(%ebp),%eax
10b9d9: 50 push %eax
10b9da: 56 push %esi
10b9db: 53 push %ebx
10b9dc: e8 c7 1a 00 00 call 10d4a8 <_Objects_Get>
switch ( location ) {
10b9e1: 83 c4 10 add $0x10,%esp
10b9e4: 8b 4d e4 mov -0x1c(%ebp),%ecx
10b9e7: 85 c9 test %ecx,%ecx
10b9e9: 74 19 je 10ba04 <rtems_object_set_name+0x58>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b9eb: b8 04 00 00 00 mov $0x4,%eax
}
10b9f0: 8d 65 f4 lea -0xc(%ebp),%esp
10b9f3: 5b pop %ebx
10b9f4: 5e pop %esi
10b9f5: 5f pop %edi
10b9f6: c9 leave
10b9f7: c3 ret
Objects_Id tmpId;
if ( !name )
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10b9f8: a1 f8 a5 12 00 mov 0x12a5f8,%eax
10b9fd: 8b 70 08 mov 0x8(%eax),%esi
10ba00: eb c1 jmp 10b9c3 <rtems_object_set_name+0x17>
10ba02: 66 90 xchg %ax,%ax
the_object = _Objects_Get( information, tmpId, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Objects_Set_name( information, the_object, name );
10ba04: 52 push %edx
10ba05: 57 push %edi
10ba06: 50 push %eax
10ba07: 53 push %ebx
10ba08: e8 83 1c 00 00 call 10d690 <_Objects_Set_name>
_Thread_Enable_dispatch();
10ba0d: e8 ea 26 00 00 call 10e0fc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10ba12: 83 c4 10 add $0x10,%esp
10ba15: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ba17: 8d 65 f4 lea -0xc(%ebp),%esp
10ba1a: 5b pop %ebx
10ba1b: 5e pop %esi
10ba1c: 5f pop %edi
10ba1d: c9 leave
10ba1e: c3 ret
10ba1f: 90 nop
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
return RTEMS_INVALID_ADDRESS;
10ba20: b8 09 00 00 00 mov $0x9,%eax
10ba25: eb c9 jmp 10b9f0 <rtems_object_set_name+0x44>
0011681c <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
11681c: 55 push %ebp
11681d: 89 e5 mov %esp,%ebp
11681f: 57 push %edi
116820: 56 push %esi
116821: 53 push %ebx
116822: 83 ec 1c sub $0x1c,%esp
116825: 8b 5d 08 mov 0x8(%ebp),%ebx
116828: 8b 75 0c mov 0xc(%ebp),%esi
11682b: 8b 55 10 mov 0x10(%ebp),%edx
11682e: 8b 7d 14 mov 0x14(%ebp),%edi
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
116831: 85 db test %ebx,%ebx
116833: 74 47 je 11687c <rtems_partition_create+0x60>
return RTEMS_INVALID_NAME;
if ( !starting_address )
116835: 85 f6 test %esi,%esi
116837: 74 23 je 11685c <rtems_partition_create+0x40>
return RTEMS_INVALID_ADDRESS;
if ( !id )
116839: 8b 45 1c mov 0x1c(%ebp),%eax
11683c: 85 c0 test %eax,%eax
11683e: 74 1c je 11685c <rtems_partition_create+0x40><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
116840: 85 d2 test %edx,%edx
116842: 74 28 je 11686c <rtems_partition_create+0x50>
116844: 85 ff test %edi,%edi
116846: 74 24 je 11686c <rtems_partition_create+0x50>
116848: 39 fa cmp %edi,%edx
11684a: 72 20 jb 11686c <rtems_partition_create+0x50>
11684c: f7 c7 03 00 00 00 test $0x3,%edi
116852: 75 18 jne 11686c <rtems_partition_create+0x50>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
116854: f7 c6 03 00 00 00 test $0x3,%esi
11685a: 74 30 je 11688c <rtems_partition_create+0x70>
return RTEMS_INVALID_ADDRESS;
11685c: b8 09 00 00 00 mov $0x9,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
116861: 8d 65 f4 lea -0xc(%ebp),%esp
116864: 5b pop %ebx
116865: 5e pop %esi
116866: 5f pop %edi
116867: c9 leave
116868: c3 ret
116869: 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;
11686c: b8 08 00 00 00 mov $0x8,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
116871: 8d 65 f4 lea -0xc(%ebp),%esp
116874: 5b pop %ebx
116875: 5e pop %esi
116876: 5f pop %edi
116877: c9 leave
116878: c3 ret
116879: 8d 76 00 lea 0x0(%esi),%esi
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
11687c: b8 03 00 00 00 mov $0x3,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
116881: 8d 65 f4 lea -0xc(%ebp),%esp
116884: 5b pop %ebx
116885: 5e pop %esi
116886: 5f pop %edi
116887: c9 leave
116888: c3 ret
116889: 8d 76 00 lea 0x0(%esi),%esi
11688c: a1 30 2a 14 00 mov 0x142a30,%eax
116891: 40 inc %eax
116892: a3 30 2a 14 00 mov %eax,0x142a30
* 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 );
116897: 83 ec 0c sub $0xc,%esp
11689a: 68 c0 28 14 00 push $0x1428c0
11689f: 89 55 e0 mov %edx,-0x20(%ebp)
1168a2: e8 45 45 00 00 call 11adec <_Objects_Allocate>
1168a7: 89 45 e4 mov %eax,-0x1c(%ebp)
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
1168aa: 83 c4 10 add $0x10,%esp
1168ad: 85 c0 test %eax,%eax
1168af: 8b 55 e0 mov -0x20(%ebp),%edx
1168b2: 74 58 je 11690c <rtems_partition_create+0xf0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
1168b4: 8b 45 e4 mov -0x1c(%ebp),%eax
1168b7: 89 70 10 mov %esi,0x10(%eax)
the_partition->length = length;
1168ba: 89 50 14 mov %edx,0x14(%eax)
the_partition->buffer_size = buffer_size;
1168bd: 89 78 18 mov %edi,0x18(%eax)
the_partition->attribute_set = attribute_set;
1168c0: 8b 4d 18 mov 0x18(%ebp),%ecx
1168c3: 89 48 1c mov %ecx,0x1c(%eax)
the_partition->number_of_used_blocks = 0;
1168c6: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax)
_Chain_Initialize( &the_partition->Memory, starting_address,
1168cd: 57 push %edi
1168ce: 89 d0 mov %edx,%eax
1168d0: 31 d2 xor %edx,%edx
1168d2: f7 f7 div %edi
1168d4: 50 push %eax
1168d5: 56 push %esi
1168d6: 8b 45 e4 mov -0x1c(%ebp),%eax
1168d9: 83 c0 24 add $0x24,%eax
1168dc: 50 push %eax
1168dd: e8 9e 2f 00 00 call 119880 <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
1168e2: 8b 7d e4 mov -0x1c(%ebp),%edi
1168e5: 8b 47 08 mov 0x8(%edi),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
1168e8: 0f b7 f0 movzwl %ax,%esi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
1168eb: 8b 15 dc 28 14 00 mov 0x1428dc,%edx
1168f1: 89 3c b2 mov %edi,(%edx,%esi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
1168f4: 89 5f 0c mov %ebx,0xc(%edi)
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
1168f7: 8b 55 1c mov 0x1c(%ebp),%edx
1168fa: 89 02 mov %eax,(%edx)
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
1168fc: e8 53 55 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116901: 83 c4 10 add $0x10,%esp
116904: 31 c0 xor %eax,%eax
116906: e9 66 ff ff ff jmp 116871 <rtems_partition_create+0x55>
11690b: 90 nop
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
_Thread_Enable_dispatch();
11690c: e8 43 55 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
116911: b8 05 00 00 00 mov $0x5,%eax
116916: e9 56 ff ff ff jmp 116871 <rtems_partition_create+0x55>
00116988 <rtems_partition_get_buffer>:
rtems_status_code rtems_partition_get_buffer(
rtems_id id,
void **buffer
)
{
116988: 55 push %ebp
116989: 89 e5 mov %esp,%ebp
11698b: 56 push %esi
11698c: 53 push %ebx
11698d: 83 ec 20 sub $0x20,%esp
116990: 8b 5d 0c mov 0xc(%ebp),%ebx
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
116993: 85 db test %ebx,%ebx
116995: 74 59 je 1169f0 <rtems_partition_get_buffer+0x68>
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
_Objects_Get( &_Partition_Information, id, location );
116997: 52 push %edx
return RTEMS_INVALID_ADDRESS;
the_partition = _Partition_Get( id, &location );
116998: 8d 45 f4 lea -0xc(%ebp),%eax
11699b: 50 push %eax
11699c: ff 75 08 pushl 0x8(%ebp)
11699f: 68 c0 28 14 00 push $0x1428c0
1169a4: e8 33 49 00 00 call 11b2dc <_Objects_Get>
1169a9: 89 c6 mov %eax,%esi
switch ( location ) {
1169ab: 83 c4 10 add $0x10,%esp
1169ae: 8b 45 f4 mov -0xc(%ebp),%eax
1169b1: 85 c0 test %eax,%eax
1169b3: 75 2f jne 1169e4 <rtems_partition_get_buffer+0x5c>
*/
RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer (
Partition_Control *the_partition
)
{
return _Chain_Get( &the_partition->Memory );
1169b5: 83 ec 0c sub $0xc,%esp
1169b8: 8d 46 24 lea 0x24(%esi),%eax
1169bb: 50 push %eax
1169bc: e8 9b 2e 00 00 call 11985c <_Chain_Get>
case OBJECTS_LOCAL:
the_buffer = _Partition_Allocate_buffer( the_partition );
if ( the_buffer ) {
1169c1: 83 c4 10 add $0x10,%esp
1169c4: 85 c0 test %eax,%eax
1169c6: 74 34 je 1169fc <rtems_partition_get_buffer+0x74>
the_partition->number_of_used_blocks += 1;
1169c8: ff 46 20 incl 0x20(%esi)
_Thread_Enable_dispatch();
1169cb: 89 45 e4 mov %eax,-0x1c(%ebp)
1169ce: e8 81 54 00 00 call 11be54 <_Thread_Enable_dispatch>
*buffer = the_buffer;
1169d3: 8b 45 e4 mov -0x1c(%ebp),%eax
1169d6: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
1169d8: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1169da: 8d 65 f8 lea -0x8(%ebp),%esp
1169dd: 5b pop %ebx
1169de: 5e pop %esi
1169df: c9 leave
1169e0: c3 ret
1169e1: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1169e4: b8 04 00 00 00 mov $0x4,%eax
}
1169e9: 8d 65 f8 lea -0x8(%ebp),%esp
1169ec: 5b pop %ebx
1169ed: 5e pop %esi
1169ee: c9 leave
1169ef: c3 ret
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
1169f0: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1169f5: 8d 65 f8 lea -0x8(%ebp),%esp
1169f8: 5b pop %ebx
1169f9: 5e pop %esi
1169fa: c9 leave
1169fb: c3 ret
the_partition->number_of_used_blocks += 1;
_Thread_Enable_dispatch();
*buffer = the_buffer;
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
1169fc: e8 53 54 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_UNSATISFIED;
116a01: b8 0d 00 00 00 mov $0xd,%eax
116a06: eb e1 jmp 1169e9 <rtems_partition_get_buffer+0x61>
00116a2c <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
116a2c: 55 push %ebp
116a2d: 89 e5 mov %esp,%ebp
116a2f: 56 push %esi
116a30: 53 push %ebx
116a31: 83 ec 14 sub $0x14,%esp
116a34: 8b 75 0c mov 0xc(%ebp),%esi
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
116a37: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
_Objects_Get( &_Partition_Information, id, location );
116a3a: 50 push %eax
116a3b: ff 75 08 pushl 0x8(%ebp)
116a3e: 68 c0 28 14 00 push $0x1428c0
116a43: e8 94 48 00 00 call 11b2dc <_Objects_Get>
116a48: 89 c3 mov %eax,%ebx
switch ( location ) {
116a4a: 83 c4 10 add $0x10,%esp
116a4d: 8b 45 f4 mov -0xc(%ebp),%eax
116a50: 85 c0 test %eax,%eax
116a52: 74 0c je 116a60 <rtems_partition_return_buffer+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
116a54: b8 04 00 00 00 mov $0x4,%eax
}
116a59: 8d 65 f8 lea -0x8(%ebp),%esp
116a5c: 5b pop %ebx
116a5d: 5e pop %esi
116a5e: c9 leave
116a5f: c3 ret
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
116a60: 8b 43 10 mov 0x10(%ebx),%eax
ending = _Addresses_Add_offset( starting, the_partition->length );
116a63: 8b 53 14 mov 0x14(%ebx),%edx
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
116a66: 39 c6 cmp %eax,%esi
116a68: 72 3a jb 116aa4 <rtems_partition_return_buffer+0x78>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
116a6a: 8d 14 10 lea (%eax,%edx,1),%edx
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
116a6d: 39 d6 cmp %edx,%esi
116a6f: 77 33 ja 116aa4 <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);
116a71: 89 f2 mov %esi,%edx
116a73: 29 c2 sub %eax,%edx
116a75: 89 d0 mov %edx,%eax
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
116a77: 31 d2 xor %edx,%edx
116a79: 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 ) &&
116a7c: 85 d2 test %edx,%edx
116a7e: 75 24 jne 116aa4 <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 );
116a80: 83 ec 08 sub $0x8,%esp
116a83: 56 push %esi
116a84: 8d 43 24 lea 0x24(%ebx),%eax
116a87: 50 push %eax
116a88: e8 93 2d 00 00 call 119820 <_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;
116a8d: ff 4b 20 decl 0x20(%ebx)
_Thread_Enable_dispatch();
116a90: e8 bf 53 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116a95: 83 c4 10 add $0x10,%esp
116a98: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116a9a: 8d 65 f8 lea -0x8(%ebp),%esp
116a9d: 5b pop %ebx
116a9e: 5e pop %esi
116a9f: c9 leave
116aa0: c3 ret
116aa1: 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();
116aa4: e8 ab 53 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
116aa9: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116aae: 8d 65 f8 lea -0x8(%ebp),%esp
116ab1: 5b pop %ebx
116ab2: 5e pop %esi
116ab3: c9 leave
116ab4: c3 ret
00115e50 <rtems_port_create>:
void *internal_start,
void *external_start,
uint32_t length,
rtems_id *id
)
{
115e50: 55 push %ebp
115e51: 89 e5 mov %esp,%ebp
115e53: 57 push %edi
115e54: 56 push %esi
115e55: 53 push %ebx
115e56: 83 ec 1c sub $0x1c,%esp
115e59: 8b 5d 08 mov 0x8(%ebp),%ebx
115e5c: 8b 55 0c mov 0xc(%ebp),%edx
115e5f: 8b 7d 10 mov 0x10(%ebp),%edi
115e62: 8b 75 18 mov 0x18(%ebp),%esi
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
115e65: 85 db test %ebx,%ebx
115e67: 74 1b je 115e84 <rtems_port_create+0x34>
return RTEMS_INVALID_NAME;
if ( !id )
115e69: 85 f6 test %esi,%esi
115e6b: 74 08 je 115e75 <rtems_port_create+0x25>
* id - port id
* RTEMS_SUCCESSFUL - if successful
* error code - if unsuccessful
*/
rtems_status_code rtems_port_create(
115e6d: 89 f8 mov %edi,%eax
115e6f: 09 d0 or %edx,%eax
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( internal_start ) ||
115e71: a8 03 test $0x3,%al
115e73: 74 1f je 115e94 <rtems_port_create+0x44>
!_Addresses_Is_aligned( external_start ) )
return RTEMS_INVALID_ADDRESS;
115e75: b8 09 00 00 00 mov $0x9,%eax
);
*id = the_port->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
115e7a: 8d 65 f4 lea -0xc(%ebp),%esp
115e7d: 5b pop %ebx
115e7e: 5e pop %esi
115e7f: 5f pop %edi
115e80: c9 leave
115e81: c3 ret
115e82: 66 90 xchg %ax,%ax
)
{
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
115e84: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_port->Object.id;
_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
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
115e94: a1 30 2a 14 00 mov 0x142a30,%eax
115e99: 40 inc %eax
115e9a: a3 30 2a 14 00 mov %eax,0x142a30
*/
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control
*_Dual_ported_memory_Allocate ( void )
{
return (Dual_ported_memory_Control *)
_Objects_Allocate( &_Dual_ported_memory_Information );
115e9f: 83 ec 0c sub $0xc,%esp
115ea2: 68 80 28 14 00 push $0x142880
115ea7: 89 55 e4 mov %edx,-0x1c(%ebp)
115eaa: e8 3d 4f 00 00 call 11adec <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
115eaf: 83 c4 10 add $0x10,%esp
115eb2: 85 c0 test %eax,%eax
115eb4: 8b 55 e4 mov -0x1c(%ebp),%edx
115eb7: 74 33 je 115eec <rtems_port_create+0x9c>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
115eb9: 89 50 10 mov %edx,0x10(%eax)
the_port->external_base = external_start;
115ebc: 89 78 14 mov %edi,0x14(%eax)
the_port->length = length - 1;
115ebf: 8b 55 14 mov 0x14(%ebp),%edx
115ec2: 4a dec %edx
115ec3: 89 50 18 mov %edx,0x18(%eax)
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
115ec6: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
115ec9: 0f b7 fa movzwl %dx,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
115ecc: 8b 0d 9c 28 14 00 mov 0x14289c,%ecx
115ed2: 89 04 b9 mov %eax,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
115ed5: 89 58 0c mov %ebx,0xc(%eax)
&_Dual_ported_memory_Information,
&the_port->Object,
(Objects_Name) name
);
*id = the_port->Object.id;
115ed8: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
115eda: e8 75 5f 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115edf: 31 c0 xor %eax,%eax
}
115ee1: 8d 65 f4 lea -0xc(%ebp),%esp
115ee4: 5b pop %ebx
115ee5: 5e pop %esi
115ee6: 5f pop %edi
115ee7: c9 leave
115ee8: c3 ret
115ee9: 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();
115eec: e8 63 5f 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
115ef1: b8 05 00 00 00 mov $0x5,%eax
115ef6: eb 82 jmp 115e7a <rtems_port_create+0x2a>
00115ef8 <rtems_port_delete>:
*/
rtems_status_code rtems_port_delete(
rtems_id id
)
{
115ef8: 55 push %ebp
115ef9: 89 e5 mov %esp,%ebp
115efb: 83 ec 2c sub $0x2c,%esp
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
the_port = _Dual_ported_memory_Get( id, &location );
115efe: 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 );
115f01: 50 push %eax
115f02: ff 75 08 pushl 0x8(%ebp)
115f05: 68 80 28 14 00 push $0x142880
115f0a: e8 cd 53 00 00 call 11b2dc <_Objects_Get>
switch ( location ) {
115f0f: 83 c4 10 add $0x10,%esp
115f12: 8b 4d f4 mov -0xc(%ebp),%ecx
115f15: 85 c9 test %ecx,%ecx
115f17: 75 2f jne 115f48 <rtems_port_delete+0x50>
case OBJECTS_LOCAL:
_Objects_Close( &_Dual_ported_memory_Information, &the_port->Object );
115f19: 83 ec 08 sub $0x8,%esp
115f1c: 50 push %eax
115f1d: 68 80 28 14 00 push $0x142880
115f22: 89 45 e4 mov %eax,-0x1c(%ebp)
115f25: e8 3e 4f 00 00 call 11ae68 <_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 );
115f2a: 58 pop %eax
115f2b: 5a pop %edx
115f2c: 8b 45 e4 mov -0x1c(%ebp),%eax
115f2f: 50 push %eax
115f30: 68 80 28 14 00 push $0x142880
115f35: e8 26 52 00 00 call 11b160 <_Objects_Free>
_Dual_ported_memory_Free( the_port );
_Thread_Enable_dispatch();
115f3a: e8 15 5f 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115f3f: 83 c4 10 add $0x10,%esp
115f42: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115f44: c9 leave
115f45: c3 ret
115f46: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115f48: b8 04 00 00 00 mov $0x4,%eax
}
115f4d: c9 leave
115f4e: c3 ret
00115f50 <rtems_port_external_to_internal>:
rtems_status_code rtems_port_external_to_internal(
rtems_id id,
void *external,
void **internal
)
{
115f50: 55 push %ebp
115f51: 89 e5 mov %esp,%ebp
115f53: 56 push %esi
115f54: 53 push %ebx
115f55: 83 ec 10 sub $0x10,%esp
115f58: 8b 75 0c mov 0xc(%ebp),%esi
115f5b: 8b 5d 10 mov 0x10(%ebp),%ebx
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !internal )
115f5e: 85 db test %ebx,%ebx
115f60: 74 4e je 115fb0 <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 );
115f62: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
115f63: 8d 45 f4 lea -0xc(%ebp),%eax
115f66: 50 push %eax
115f67: ff 75 08 pushl 0x8(%ebp)
115f6a: 68 80 28 14 00 push $0x142880
115f6f: e8 68 53 00 00 call 11b2dc <_Objects_Get>
switch ( location ) {
115f74: 83 c4 10 add $0x10,%esp
115f77: 8b 55 f4 mov -0xc(%ebp),%edx
115f7a: 85 d2 test %edx,%edx
115f7c: 74 0e je 115f8c <rtems_port_external_to_internal+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115f7e: b8 04 00 00 00 mov $0x4,%eax
}
115f83: 8d 65 f8 lea -0x8(%ebp),%esp
115f86: 5b pop %ebx
115f87: 5e pop %esi
115f88: c9 leave
115f89: c3 ret
115f8a: 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);
115f8c: 89 f2 mov %esi,%edx
115f8e: 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 )
115f91: 3b 50 18 cmp 0x18(%eax),%edx
115f94: 77 16 ja 115fac <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);
115f96: 03 50 10 add 0x10(%eax),%edx
115f99: 89 13 mov %edx,(%ebx)
*internal = external;
else
*internal = _Addresses_Add_offset( the_port->internal_base,
ending );
_Thread_Enable_dispatch();
115f9b: e8 b4 5e 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115fa0: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115fa2: 8d 65 f8 lea -0x8(%ebp),%esp
115fa5: 5b pop %ebx
115fa6: 5e pop %esi
115fa7: c9 leave
115fa8: c3 ret
115fa9: 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;
115fac: 89 33 mov %esi,(%ebx)
115fae: eb eb jmp 115f9b <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;
115fb0: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
115fb5: 8d 65 f8 lea -0x8(%ebp),%esp
115fb8: 5b pop %ebx
115fb9: 5e pop %esi
115fba: c9 leave
115fbb: c3 ret
00115fe0 <rtems_port_internal_to_external>:
rtems_status_code rtems_port_internal_to_external(
rtems_id id,
void *internal,
void **external
)
{
115fe0: 55 push %ebp
115fe1: 89 e5 mov %esp,%ebp
115fe3: 56 push %esi
115fe4: 53 push %ebx
115fe5: 83 ec 10 sub $0x10,%esp
115fe8: 8b 75 0c mov 0xc(%ebp),%esi
115feb: 8b 5d 10 mov 0x10(%ebp),%ebx
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
115fee: 85 db test %ebx,%ebx
115ff0: 74 4e je 116040 <rtems_port_internal_to_external+0x60><== NEVER TAKEN
115ff2: 51 push %ecx
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
115ff3: 8d 45 f4 lea -0xc(%ebp),%eax
115ff6: 50 push %eax
115ff7: ff 75 08 pushl 0x8(%ebp)
115ffa: 68 80 28 14 00 push $0x142880
115fff: e8 d8 52 00 00 call 11b2dc <_Objects_Get>
switch ( location ) {
116004: 83 c4 10 add $0x10,%esp
116007: 8b 55 f4 mov -0xc(%ebp),%edx
11600a: 85 d2 test %edx,%edx
11600c: 74 0e je 11601c <rtems_port_internal_to_external+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11600e: b8 04 00 00 00 mov $0x4,%eax
}
116013: 8d 65 f8 lea -0x8(%ebp),%esp
116016: 5b pop %ebx
116017: 5e pop %esi
116018: c9 leave
116019: c3 ret
11601a: 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);
11601c: 89 f2 mov %esi,%edx
11601e: 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 )
116021: 3b 50 18 cmp 0x18(%eax),%edx
116024: 77 16 ja 11603c <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);
116026: 03 50 14 add 0x14(%eax),%edx
116029: 89 13 mov %edx,(%ebx)
*external = internal;
else
*external = _Addresses_Add_offset( the_port->external_base,
ending );
_Thread_Enable_dispatch();
11602b: e8 24 5e 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116030: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116032: 8d 65 f8 lea -0x8(%ebp),%esp
116035: 5b pop %ebx
116036: 5e pop %esi
116037: c9 leave
116038: c3 ret
116039: 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;
11603c: 89 33 mov %esi,(%ebx)
11603e: eb eb jmp 11602b <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;
116040: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116045: 8d 65 f8 lea -0x8(%ebp),%esp
116048: 5b pop %ebx
116049: 5e pop %esi
11604a: c9 leave
11604b: c3 ret
00107830 <rtems_print_buffer>:
void rtems_print_buffer(
const unsigned char *buffer,
int length
)
{
107830: 55 push %ebp
107831: 89 e5 mov %esp,%ebp
107833: 57 push %edi
107834: 56 push %esi
107835: 53 push %ebx
107836: 81 ec 9c 00 00 00 sub $0x9c,%esp
10783c: 8b 75 0c mov 0xc(%ebp),%esi
int i, mod, max;
if ( !length ) return;
10783f: 85 f6 test %esi,%esi
107841: 0f 84 00 01 00 00 je 107947 <rtems_print_buffer+0x117>
mod = length % 16;
107847: 89 f0 mov %esi,%eax
107849: 25 0f 00 00 80 and $0x8000000f,%eax
10784e: 89 85 60 ff ff ff mov %eax,-0xa0(%ebp)
107854: 0f 88 21 02 00 00 js 107a7b <rtems_print_buffer+0x24b>
10785a: 8b 85 60 ff ff ff mov -0xa0(%ebp),%eax
107860: 89 85 58 ff ff ff mov %eax,-0xa8(%ebp)
max = length - mod;
107866: 29 c6 sub %eax,%esi
107868: 89 b5 5c ff ff ff mov %esi,-0xa4(%ebp)
for ( i=0 ; i<max ; i+=16 )
10786e: 85 f6 test %esi,%esi
107870: 0f 8e c7 00 00 00 jle 10793d <rtems_print_buffer+0x10d>
107876: c7 85 64 ff ff ff 00 movl $0x0,-0x9c(%ebp)
10787d: 00 00 00
107880: 8d 9d 70 ff ff ff lea -0x90(%ebp),%ebx
107886: 66 90 xchg %ax,%ax
static inline void Dump_Line(
const unsigned char *buffer,
int length
);
void rtems_print_buffer(
107888: 8b 75 08 mov 0x8(%ebp),%esi
10788b: 03 b5 64 ff ff ff add -0x9c(%ebp),%esi
{
int i;
char line_buffer[120];
line_buffer[0] = '\0';
107891: c6 85 70 ff ff ff 00 movb $0x0,-0x90(%ebp)
for( i=0 ; i<length ; i++ )
107898: 31 ff xor %edi,%edi
10789a: 66 90 xchg %ax,%ax
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
10789c: 0f b6 04 3e movzbl (%esi,%edi,1),%eax
1078a0: 50 push %eax
1078a1: 53 push %ebx
1078a2: 68 d3 13 12 00 push $0x1213d3
1078a7: 53 push %ebx
1078a8: e8 ab c5 00 00 call 113e58 <sprintf>
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
1078ad: 47 inc %edi
1078ae: 83 c4 10 add $0x10,%esp
1078b1: 83 ff 10 cmp $0x10,%edi
1078b4: 75 e6 jne 10789c <rtems_print_buffer+0x6c>
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
1078b6: 31 c0 xor %eax,%eax
1078b8: b9 ff ff ff ff mov $0xffffffff,%ecx
1078bd: 89 df mov %ebx,%edi
1078bf: f2 ae repnz scas %es:(%edi),%al
1078c1: f7 d1 not %ecx
1078c3: 66 c7 44 0b ff 7c 00 movw $0x7c,-0x1(%ebx,%ecx,1)
for( i=0 ; i<length ; i++ )
1078ca: 31 ff xor %edi,%edi
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
1078cc: 0f b6 04 3e movzbl (%esi,%edi,1),%eax
1078d0: 8b 15 14 5c 12 00 mov 0x125c14,%edx
1078d6: 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,
1078db: 81 e2 97 00 00 00 and $0x97,%edx
1078e1: 75 05 jne 1078e8 <rtems_print_buffer+0xb8>
1078e3: b8 2e 00 00 00 mov $0x2e,%eax
1078e8: 50 push %eax
1078e9: 53 push %ebx
1078ea: 68 db 13 12 00 push $0x1213db
1078ef: 53 push %ebx
1078f0: e8 63 c5 00 00 call 113e58 <sprintf>
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
1078f5: 47 inc %edi
1078f6: 83 c4 10 add $0x10,%esp
1078f9: 83 ff 10 cmp $0x10,%edi
1078fc: 75 ce jne 1078cc <rtems_print_buffer+0x9c>
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|\n" );
1078fe: 31 c0 xor %eax,%eax
107900: b9 ff ff ff ff mov $0xffffffff,%ecx
107905: 89 df mov %ebx,%edi
107907: f2 ae repnz scas %es:(%edi),%al
107909: f7 d1 not %ecx
10790b: 8d 44 0b ff lea -0x1(%ebx,%ecx,1),%eax
10790f: 66 c7 00 7c 0a movw $0xa7c,(%eax)
107914: c6 40 02 00 movb $0x0,0x2(%eax)
printk( line_buffer );
107918: 83 ec 0c sub $0xc,%esp
10791b: 53 push %ebx
10791c: e8 17 18 00 00 call 109138 <printk>
mod = length % 16;
max = length - mod;
for ( i=0 ; i<max ; i+=16 )
107921: 83 85 64 ff ff ff 10 addl $0x10,-0x9c(%ebp)
107928: 83 c4 10 add $0x10,%esp
10792b: 8b 85 64 ff ff ff mov -0x9c(%ebp),%eax
107931: 39 85 5c ff ff ff cmp %eax,-0xa4(%ebp)
107937: 0f 8f 4b ff ff ff jg 107888 <rtems_print_buffer+0x58>
Dump_Line( &buffer[ i ], 16 );
if ( mod )
10793d: 8b 8d 60 ff ff ff mov -0xa0(%ebp),%ecx
107943: 85 c9 test %ecx,%ecx
107945: 75 08 jne 10794f <rtems_print_buffer+0x11f>
Dump_Line( &buffer[ max ], mod );
}
107947: 8d 65 f4 lea -0xc(%ebp),%esp
10794a: 5b pop %ebx
10794b: 5e pop %esi
10794c: 5f pop %edi
10794d: c9 leave
10794e: c3 ret
for ( i=0 ; i<max ; i+=16 )
Dump_Line( &buffer[ i ], 16 );
if ( mod )
Dump_Line( &buffer[ max ], mod );
10794f: 8b 75 08 mov 0x8(%ebp),%esi
107952: 03 b5 5c ff ff ff add -0xa4(%ebp),%esi
{
int i;
char line_buffer[120];
line_buffer[0] = '\0';
107958: c6 85 70 ff ff ff 00 movb $0x0,-0x90(%ebp)
for( i=0 ; i<length ; i++ )
10795f: 8b 95 60 ff ff ff mov -0xa0(%ebp),%edx
107965: 85 d2 test %edx,%edx
107967: 0f 8e 2a 01 00 00 jle 107a97 <rtems_print_buffer+0x267>
10796d: 31 ff xor %edi,%edi
10796f: 8d 9d 70 ff ff ff lea -0x90(%ebp),%ebx
107975: 8d 76 00 lea 0x0(%esi),%esi
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
107978: 0f b6 04 3e movzbl (%esi,%edi,1),%eax
10797c: 50 push %eax
10797d: 53 push %ebx
10797e: 68 d3 13 12 00 push $0x1213d3
107983: 53 push %ebx
107984: e8 cf c4 00 00 call 113e58 <sprintf>
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
107989: 47 inc %edi
10798a: 83 c4 10 add $0x10,%esp
10798d: 39 bd 60 ff ff ff cmp %edi,-0xa0(%ebp)
107993: 7f e3 jg 107978 <rtems_print_buffer+0x148>
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
107995: 83 bd 60 ff ff ff 0f cmpl $0xf,-0xa0(%ebp)
10799c: 0f 8f 02 01 00 00 jg 107aa4 <rtems_print_buffer+0x274><== NEVER TAKEN
1079a2: 8b 95 60 ff ff ff mov -0xa0(%ebp),%edx
strcat( line_buffer, " " );
1079a8: 31 c0 xor %eax,%eax
1079aa: 66 90 xchg %ax,%ax
1079ac: b9 ff ff ff ff mov $0xffffffff,%ecx
1079b1: 89 df mov %ebx,%edi
1079b3: f2 ae repnz scas %es:(%edi),%al
1079b5: f7 d1 not %ecx
1079b7: c7 44 0b ff 20 20 20 movl $0x202020,-0x1(%ebx,%ecx,1)
1079be: 00
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
1079bf: 42 inc %edx
1079c0: 83 fa 0f cmp $0xf,%edx
1079c3: 7e e7 jle 1079ac <rtems_print_buffer+0x17c>
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
1079c5: 31 c0 xor %eax,%eax
1079c7: b9 ff ff ff ff mov $0xffffffff,%ecx
1079cc: 89 df mov %ebx,%edi
1079ce: f2 ae repnz scas %es:(%edi),%al
1079d0: f7 d1 not %ecx
1079d2: 66 c7 44 0b ff 7c 00 movw $0x7c,-0x1(%ebx,%ecx,1)
for( i=0 ; i<length ; i++ )
1079d9: 8b 85 60 ff ff ff mov -0xa0(%ebp),%eax
1079df: 85 c0 test %eax,%eax
1079e1: 0f 8e a4 00 00 00 jle 107a8b <rtems_print_buffer+0x25b>
1079e7: 31 ff xor %edi,%edi
1079e9: 8d 76 00 lea 0x0(%esi),%esi
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
1079ec: 0f b6 04 3e movzbl (%esi,%edi,1),%eax
1079f0: 8b 15 14 5c 12 00 mov 0x125c14,%edx
1079f6: 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,
1079fb: 81 e2 97 00 00 00 and $0x97,%edx
107a01: 75 05 jne 107a08 <rtems_print_buffer+0x1d8>
107a03: b8 2e 00 00 00 mov $0x2e,%eax
107a08: 50 push %eax
107a09: 53 push %ebx
107a0a: 68 db 13 12 00 push $0x1213db
107a0f: 53 push %ebx
107a10: e8 43 c4 00 00 call 113e58 <sprintf>
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
107a15: 47 inc %edi
107a16: 83 c4 10 add $0x10,%esp
107a19: 39 bd 60 ff ff ff cmp %edi,-0xa0(%ebp)
107a1f: 7f cb jg 1079ec <rtems_print_buffer+0x1bc>
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
for( ; i<16 ; i++ )
107a21: 83 bd 60 ff ff ff 0f cmpl $0xf,-0xa0(%ebp)
107a28: 7f 23 jg 107a4d <rtems_print_buffer+0x21d><== NEVER TAKEN
strcat( line_buffer, " " );
107a2a: ba ff ff ff ff mov $0xffffffff,%edx
107a2f: 31 c0 xor %eax,%eax
107a31: 8b b5 58 ff ff ff mov -0xa8(%ebp),%esi
107a37: 90 nop
107a38: 89 d1 mov %edx,%ecx
107a3a: 89 df mov %ebx,%edi
107a3c: f2 ae repnz scas %es:(%edi),%al
107a3e: f7 d1 not %ecx
107a40: 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++ )
107a47: 46 inc %esi
107a48: 83 fe 0f cmp $0xf,%esi
107a4b: 7e eb jle 107a38 <rtems_print_buffer+0x208>
strcat( line_buffer, " " );
strcat( line_buffer, "|\n" );
107a4d: 31 c0 xor %eax,%eax
107a4f: b9 ff ff ff ff mov $0xffffffff,%ecx
107a54: 89 df mov %ebx,%edi
107a56: f2 ae repnz scas %es:(%edi),%al
107a58: f7 d1 not %ecx
107a5a: 8d 44 0b ff lea -0x1(%ebx,%ecx,1),%eax
107a5e: 66 c7 00 7c 0a movw $0xa7c,(%eax)
107a63: c6 40 02 00 movb $0x0,0x2(%eax)
printk( line_buffer );
107a67: 83 ec 0c sub $0xc,%esp
107a6a: 53 push %ebx
107a6b: e8 c8 16 00 00 call 109138 <printk>
107a70: 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 );
}
107a73: 8d 65 f4 lea -0xc(%ebp),%esp
107a76: 5b pop %ebx
107a77: 5e pop %esi
107a78: 5f pop %edi
107a79: c9 leave
107a7a: c3 ret
int i, mod, max;
if ( !length ) return;
mod = length % 16;
107a7b: 48 dec %eax
107a7c: 83 c8 f0 or $0xfffffff0,%eax
107a7f: 40 inc %eax
107a80: 89 85 60 ff ff ff mov %eax,-0xa0(%ebp)
107a86: e9 cf fd ff ff jmp 10785a <rtems_print_buffer+0x2a>
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
107a8b: c7 85 58 ff ff ff 00 movl $0x0,-0xa8(%ebp)
107a92: 00 00 00
107a95: eb 93 jmp 107a2a <rtems_print_buffer+0x1fa>
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
107a97: 31 d2 xor %edx,%edx
107a99: 8d 9d 70 ff ff ff lea -0x90(%ebp),%ebx
107a9f: e9 04 ff ff ff jmp 1079a8 <rtems_print_buffer+0x178>
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
107aa4: 31 c0 xor %eax,%eax
107aa6: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED
107aa9: 89 df mov %ebx,%edi <== NOT EXECUTED
107aab: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED
107aad: f7 d1 not %ecx <== NOT EXECUTED
107aaf: 66 c7 44 0b ff 7c 00 movw $0x7c,-0x1(%ebx,%ecx,1) <== NOT EXECUTED
107ab6: e9 2c ff ff ff jmp 1079e7 <rtems_print_buffer+0x1b7><== NOT EXECUTED
00116ab8 <rtems_rate_monotonic_cancel>:
*/
rtems_status_code rtems_rate_monotonic_cancel(
rtems_id id
)
{
116ab8: 55 push %ebp
116ab9: 89 e5 mov %esp,%ebp
116abb: 53 push %ebx
116abc: 83 ec 18 sub $0x18,%esp
Rate_monotonic_Control *the_period;
Objects_Locations location;
the_period = _Rate_monotonic_Get( id, &location );
116abf: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
116ac2: 50 push %eax
116ac3: ff 75 08 pushl 0x8(%ebp)
116ac6: 68 00 29 14 00 push $0x142900
116acb: e8 0c 48 00 00 call 11b2dc <_Objects_Get>
116ad0: 89 c3 mov %eax,%ebx
switch ( location ) {
116ad2: 83 c4 10 add $0x10,%esp
116ad5: 8b 45 f4 mov -0xc(%ebp),%eax
116ad8: 85 c0 test %eax,%eax
116ada: 74 0c je 116ae8 <rtems_rate_monotonic_cancel+0x30>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
116adc: b8 04 00 00 00 mov $0x4,%eax
}
116ae1: 8b 5d fc mov -0x4(%ebp),%ebx
116ae4: c9 leave
116ae5: c3 ret
116ae6: 66 90 xchg %ax,%ax
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
116ae8: a1 d8 2f 14 00 mov 0x142fd8,%eax
116aed: 39 43 40 cmp %eax,0x40(%ebx)
116af0: 74 12 je 116b04 <rtems_rate_monotonic_cancel+0x4c>
_Thread_Enable_dispatch();
116af2: e8 5d 53 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
116af7: b8 17 00 00 00 mov $0x17,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
116afc: 8b 5d fc mov -0x4(%ebp),%ebx
116aff: c9 leave
116b00: c3 ret
116b01: 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 );
116b04: 83 ec 0c sub $0xc,%esp
116b07: 8d 43 10 lea 0x10(%ebx),%eax
116b0a: 50 push %eax
116b0b: e8 80 64 00 00 call 11cf90 <_Watchdog_Remove>
the_period->state = RATE_MONOTONIC_INACTIVE;
116b10: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx)
_Thread_Enable_dispatch();
116b17: e8 38 53 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
116b1c: 83 c4 10 add $0x10,%esp
116b1f: 31 c0 xor %eax,%eax
116b21: eb be jmp 116ae1 <rtems_rate_monotonic_cancel+0x29>
0010c340 <rtems_rate_monotonic_create>:
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
rtems_id *id
)
{
10c340: 55 push %ebp
10c341: 89 e5 mov %esp,%ebp
10c343: 57 push %edi
10c344: 56 push %esi
10c345: 53 push %ebx
10c346: 83 ec 1c sub $0x1c,%esp
10c349: 8b 5d 08 mov 0x8(%ebp),%ebx
10c34c: 8b 75 0c mov 0xc(%ebp),%esi
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
10c34f: 85 db test %ebx,%ebx
10c351: 0f 84 a9 00 00 00 je 10c400 <rtems_rate_monotonic_create+0xc0>
return RTEMS_INVALID_NAME;
if ( !id )
10c357: 85 f6 test %esi,%esi
10c359: 0f 84 c5 00 00 00 je 10c424 <rtems_rate_monotonic_create+0xe4>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10c35f: a1 50 b1 12 00 mov 0x12b150,%eax
10c364: 40 inc %eax
10c365: a3 50 b1 12 00 mov %eax,0x12b150
* 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 );
10c36a: 83 ec 0c sub $0xc,%esp
10c36d: 68 60 b0 12 00 push $0x12b060
10c372: e8 21 1f 00 00 call 10e298 <_Objects_Allocate>
10c377: 89 c2 mov %eax,%edx
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
10c379: 83 c4 10 add $0x10,%esp
10c37c: 85 c0 test %eax,%eax
10c37e: 0f 84 8c 00 00 00 je 10c410 <rtems_rate_monotonic_create+0xd0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
10c384: a1 f8 b6 12 00 mov 0x12b6f8,%eax
10c389: 89 42 40 mov %eax,0x40(%edx)
the_period->state = RATE_MONOTONIC_INACTIVE;
10c38c: 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;
10c393: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
10c39a: c7 42 2c 00 00 00 00 movl $0x0,0x2c(%edx)
the_watchdog->id = id;
10c3a1: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx)
the_watchdog->user_data = user_data;
10c3a8: 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 );
10c3af: 8d 42 54 lea 0x54(%edx),%eax
10c3b2: 89 45 e4 mov %eax,-0x1c(%ebp)
10c3b5: b9 38 00 00 00 mov $0x38,%ecx
10c3ba: 31 c0 xor %eax,%eax
10c3bc: 8b 7d e4 mov -0x1c(%ebp),%edi
10c3bf: f3 aa rep stos %al,%es:(%edi)
10c3c1: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx)
10c3c8: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx)
10c3cf: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx)
10c3d6: 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 ),
10c3dd: 8b 42 08 mov 0x8(%edx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10c3e0: 0f b7 f8 movzwl %ax,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c3e3: 8b 0d 7c b0 12 00 mov 0x12b07c,%ecx
10c3e9: 89 14 b9 mov %edx,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10c3ec: 89 5a 0c mov %ebx,0xc(%edx)
&_Rate_monotonic_Information,
&the_period->Object,
(Objects_Name) name
);
*id = the_period->Object.id;
10c3ef: 89 06 mov %eax,(%esi)
_Thread_Enable_dispatch();
10c3f1: e8 b6 2f 00 00 call 10f3ac <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c3f6: 31 c0 xor %eax,%eax
}
10c3f8: 8d 65 f4 lea -0xc(%ebp),%esp
10c3fb: 5b pop %ebx
10c3fc: 5e pop %esi
10c3fd: 5f pop %edi
10c3fe: c9 leave
10c3ff: c3 ret
)
{
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10c400: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c405: 8d 65 f4 lea -0xc(%ebp),%esp
10c408: 5b pop %ebx
10c409: 5e pop %esi
10c40a: 5f pop %edi
10c40b: c9 leave
10c40c: c3 ret
10c40d: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
_Thread_Enable_dispatch();
10c410: e8 97 2f 00 00 call 10f3ac <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
10c415: b8 05 00 00 00 mov $0x5,%eax
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c41a: 8d 65 f4 lea -0xc(%ebp),%esp
10c41d: 5b pop %ebx
10c41e: 5e pop %esi
10c41f: 5f pop %edi
10c420: c9 leave
10c421: c3 ret
10c422: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10c424: b8 09 00 00 00 mov $0x9,%eax
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c429: 8d 65 f4 lea -0xc(%ebp),%esp
10c42c: 5b pop %ebx
10c42d: 5e pop %esi
10c42e: 5f pop %edi
10c42f: c9 leave
10c430: c3 ret
00112900 <rtems_rate_monotonic_get_status>:
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
112900: 55 push %ebp
112901: 89 e5 mov %esp,%ebp
112903: 53 push %ebx
112904: 83 ec 24 sub $0x24,%esp
112907: 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 )
11290a: 85 db test %ebx,%ebx
11290c: 0f 84 92 00 00 00 je 1129a4 <rtems_rate_monotonic_get_status+0xa4>
112912: 50 push %eax
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
112913: 8d 45 f4 lea -0xc(%ebp),%eax
112916: 50 push %eax
112917: ff 75 08 pushl 0x8(%ebp)
11291a: 68 60 b0 12 00 push $0x12b060
11291f: e8 10 bf ff ff call 10e834 <_Objects_Get>
switch ( location ) {
112924: 83 c4 10 add $0x10,%esp
112927: 8b 4d f4 mov -0xc(%ebp),%ecx
11292a: 85 c9 test %ecx,%ecx
11292c: 74 0a je 112938 <rtems_rate_monotonic_get_status+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11292e: b8 04 00 00 00 mov $0x4,%eax
}
112933: 8b 5d fc mov -0x4(%ebp),%ebx
112936: c9 leave
112937: c3 ret
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
112938: 8b 50 40 mov 0x40(%eax),%edx
11293b: 8b 52 08 mov 0x8(%edx),%edx
11293e: 89 13 mov %edx,(%ebx)
status->state = the_period->state;
112940: 8b 50 38 mov 0x38(%eax),%edx
112943: 89 53 04 mov %edx,0x4(%ebx)
/*
* If the period is inactive, there is no information.
*/
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
112946: 85 d2 test %edx,%edx
112948: 75 2a jne 112974 <rtems_rate_monotonic_get_status+0x74>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timespec_Set_to_zero( &status->since_last_period );
11294a: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
112951: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
_Timespec_Set_to_zero( &status->executed_since_last_period );
112958: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
11295f: 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();
112966: e8 41 ca ff ff call 10f3ac <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11296b: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11296d: 8b 5d fc mov -0x4(%ebp),%ebx
112970: c9 leave
112971: c3 ret
112972: 66 90 xchg %ax,%ax
} else {
/*
* Grab the current status.
*/
valid_status =
112974: 52 push %edx
_Rate_monotonic_Get_status(
112975: 8d 55 ec lea -0x14(%ebp),%edx
} else {
/*
* Grab the current status.
*/
valid_status =
112978: 52 push %edx
_Rate_monotonic_Get_status(
112979: 8d 55 e4 lea -0x1c(%ebp),%edx
} else {
/*
* Grab the current status.
*/
valid_status =
11297c: 52 push %edx
11297d: 50 push %eax
11297e: e8 d5 9a ff ff call 10c458 <_Rate_monotonic_Get_status>
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
112983: 83 c4 10 add $0x10,%esp
112986: 84 c0 test %al,%al
112988: 74 26 je 1129b0 <rtems_rate_monotonic_get_status+0xb0>
_Thread_Enable_dispatch();
return RTEMS_NOT_DEFINED;
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec(
11298a: 8b 45 e4 mov -0x1c(%ebp),%eax
11298d: 8b 55 e8 mov -0x18(%ebp),%edx
112990: 89 43 08 mov %eax,0x8(%ebx)
112993: 89 53 0c mov %edx,0xc(%ebx)
&since_last_period, &status->since_last_period
);
_Timestamp_To_timespec(
112996: 8b 45 ec mov -0x14(%ebp),%eax
112999: 8b 55 f0 mov -0x10(%ebp),%edx
11299c: 89 43 10 mov %eax,0x10(%ebx)
11299f: 89 53 14 mov %edx,0x14(%ebx)
1129a2: eb c2 jmp 112966 <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;
1129a4: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1129a9: 8b 5d fc mov -0x4(%ebp),%ebx
1129ac: c9 leave
1129ad: c3 ret
1129ae: 66 90 xchg %ax,%ax
valid_status =
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
_Thread_Enable_dispatch();
1129b0: e8 f7 c9 ff ff call 10f3ac <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
1129b5: b8 0b 00 00 00 mov $0xb,%eax
1129ba: e9 74 ff ff ff jmp 112933 <rtems_rate_monotonic_get_status+0x33>
0010c654 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
10c654: 55 push %ebp
10c655: 89 e5 mov %esp,%ebp
10c657: 57 push %edi
10c658: 56 push %esi
10c659: 53 push %ebx
10c65a: 83 ec 30 sub $0x30,%esp
10c65d: 8b 5d 08 mov 0x8(%ebp),%ebx
10c660: 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 );
10c663: 8d 45 e4 lea -0x1c(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
10c666: 50 push %eax
10c667: 53 push %ebx
10c668: 68 60 b0 12 00 push $0x12b060
10c66d: e8 c2 21 00 00 call 10e834 <_Objects_Get>
switch ( location ) {
10c672: 83 c4 10 add $0x10,%esp
10c675: 8b 55 e4 mov -0x1c(%ebp),%edx
10c678: 85 d2 test %edx,%edx
10c67a: 74 10 je 10c68c <rtems_rate_monotonic_period+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10c67c: b8 04 00 00 00 mov $0x4,%eax
}
10c681: 8d 65 f4 lea -0xc(%ebp),%esp
10c684: 5b pop %ebx
10c685: 5e pop %esi
10c686: 5f pop %edi
10c687: c9 leave
10c688: c3 ret
10c689: 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 ) ) {
10c68c: 8b 15 f8 b6 12 00 mov 0x12b6f8,%edx
10c692: 39 50 40 cmp %edx,0x40(%eax)
10c695: 74 15 je 10c6ac <rtems_rate_monotonic_period+0x58>
_Thread_Enable_dispatch();
10c697: e8 10 2d 00 00 call 10f3ac <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
10c69c: b8 17 00 00 00 mov $0x17,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c6a1: 8d 65 f4 lea -0xc(%ebp),%esp
10c6a4: 5b pop %ebx
10c6a5: 5e pop %esi
10c6a6: 5f pop %edi
10c6a7: c9 leave
10c6a8: c3 ret
10c6a9: 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 ) {
10c6ac: 85 f6 test %esi,%esi
10c6ae: 75 1c jne 10c6cc <rtems_rate_monotonic_period+0x78>
switch ( the_period->state ) {
10c6b0: 8b 40 38 mov 0x38(%eax),%eax
10c6b3: 83 f8 04 cmp $0x4,%eax
10c6b6: 77 6c ja 10c724 <rtems_rate_monotonic_period+0xd0><== NEVER TAKEN
10c6b8: 8b 04 85 1c 3d 12 00 mov 0x123d1c(,%eax,4),%eax
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
10c6bf: 89 45 d4 mov %eax,-0x2c(%ebp)
10c6c2: e8 e5 2c 00 00 call 10f3ac <_Thread_Enable_dispatch>
return( return_value );
10c6c7: 8b 45 d4 mov -0x2c(%ebp),%eax
10c6ca: eb b5 jmp 10c681 <rtems_rate_monotonic_period+0x2d>
}
_ISR_Disable( level );
10c6cc: 9c pushf
10c6cd: fa cli
10c6ce: 5f pop %edi
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
10c6cf: 8b 50 38 mov 0x38(%eax),%edx
10c6d2: 85 d2 test %edx,%edx
10c6d4: 74 52 je 10c728 <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 ) {
10c6d6: 83 fa 02 cmp $0x2,%edx
10c6d9: 0f 84 9e 00 00 00 je 10c77d <rtems_rate_monotonic_period+0x129>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
10c6df: 83 fa 04 cmp $0x4,%edx
10c6e2: 75 98 jne 10c67c <rtems_rate_monotonic_period+0x28><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
10c6e4: 83 ec 0c sub $0xc,%esp
10c6e7: 50 push %eax
10c6e8: 89 45 d4 mov %eax,-0x2c(%ebp)
10c6eb: e8 74 fe ff ff call 10c564 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
10c6f0: 57 push %edi
10c6f1: 9d popf
the_period->state = RATE_MONOTONIC_ACTIVE;
10c6f2: 8b 45 d4 mov -0x2c(%ebp),%eax
10c6f5: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax)
the_period->next_length = length;
10c6fc: 89 70 3c mov %esi,0x3c(%eax)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10c6ff: 89 70 1c mov %esi,0x1c(%eax)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10c702: 5b pop %ebx
10c703: 5e pop %esi
_Watchdog_Insert_ticks( &the_period->Timer, length );
10c704: 83 c0 10 add $0x10,%eax
10c707: 50 push %eax
10c708: 68 20 b2 12 00 push $0x12b220
10c70d: e8 0a 3b 00 00 call 11021c <_Watchdog_Insert>
_Thread_Enable_dispatch();
10c712: e8 95 2c 00 00 call 10f3ac <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
10c717: 83 c4 10 add $0x10,%esp
10c71a: b8 06 00 00 00 mov $0x6,%eax
10c71f: e9 5d ff ff ff jmp 10c681 <rtems_rate_monotonic_period+0x2d>
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
switch ( the_period->state ) {
10c724: 31 c0 xor %eax,%eax
10c726: eb 97 jmp 10c6bf <rtems_rate_monotonic_period+0x6b><== NOT EXECUTED
return( return_value );
}
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
_ISR_Enable( level );
10c728: 57 push %edi
10c729: 9d popf
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
10c72a: 83 ec 0c sub $0xc,%esp
10c72d: 50 push %eax
10c72e: 89 45 d4 mov %eax,-0x2c(%ebp)
10c731: e8 ba fd ff ff call 10c4f0 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
10c736: 8b 45 d4 mov -0x2c(%ebp),%eax
10c739: 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;
10c740: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10c747: c7 40 2c ac ca 10 00 movl $0x10caac,0x2c(%eax)
the_watchdog->id = id;
10c74e: 89 58 30 mov %ebx,0x30(%eax)
the_watchdog->user_data = user_data;
10c751: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
10c758: 89 70 3c mov %esi,0x3c(%eax)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10c75b: 89 70 1c mov %esi,0x1c(%eax)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10c75e: 5e pop %esi
10c75f: 5f pop %edi
_Watchdog_Insert_ticks( &the_period->Timer, length );
10c760: 83 c0 10 add $0x10,%eax
10c763: 50 push %eax
10c764: 68 20 b2 12 00 push $0x12b220
10c769: e8 ae 3a 00 00 call 11021c <_Watchdog_Insert>
_Thread_Enable_dispatch();
10c76e: e8 39 2c 00 00 call 10f3ac <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c773: 83 c4 10 add $0x10,%esp
10c776: 31 c0 xor %eax,%eax
10c778: e9 04 ff ff ff jmp 10c681 <rtems_rate_monotonic_period+0x2d>
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
10c77d: 83 ec 0c sub $0xc,%esp
10c780: 50 push %eax
10c781: 89 45 d4 mov %eax,-0x2c(%ebp)
10c784: e8 db fd ff ff call 10c564 <_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;
10c789: 8b 45 d4 mov -0x2c(%ebp),%eax
10c78c: c7 40 38 01 00 00 00 movl $0x1,0x38(%eax)
the_period->next_length = length;
10c793: 89 70 3c mov %esi,0x3c(%eax)
_ISR_Enable( level );
10c796: 57 push %edi
10c797: 9d popf
_Thread_Executing->Wait.id = the_period->Object.id;
10c798: 8b 15 f8 b6 12 00 mov 0x12b6f8,%edx
10c79e: 8b 48 08 mov 0x8(%eax),%ecx
10c7a1: 89 4a 20 mov %ecx,0x20(%edx)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10c7a4: 59 pop %ecx
10c7a5: 5b pop %ebx
10c7a6: 68 00 40 00 00 push $0x4000
10c7ab: 52 push %edx
10c7ac: 89 45 d4 mov %eax,-0x2c(%ebp)
10c7af: e8 18 34 00 00 call 10fbcc <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
10c7b4: 9c pushf
10c7b5: fa cli
10c7b6: 59 pop %ecx
local_state = the_period->state;
10c7b7: 8b 45 d4 mov -0x2c(%ebp),%eax
10c7ba: 8b 50 38 mov 0x38(%eax),%edx
the_period->state = RATE_MONOTONIC_ACTIVE;
10c7bd: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax)
_ISR_Enable( level );
10c7c4: 51 push %ecx
10c7c5: 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 )
10c7c6: 83 c4 10 add $0x10,%esp
10c7c9: 83 fa 03 cmp $0x3,%edx
10c7cc: 74 0c je 10c7da <rtems_rate_monotonic_period+0x186>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
_Thread_Enable_dispatch();
10c7ce: e8 d9 2b 00 00 call 10f3ac <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c7d3: 31 c0 xor %eax,%eax
10c7d5: e9 a7 fe ff ff jmp 10c681 <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 );
10c7da: 57 push %edi
10c7db: 57 push %edi
10c7dc: 68 00 40 00 00 push $0x4000
10c7e1: ff 35 f8 b6 12 00 pushl 0x12b6f8
10c7e7: e8 5c 28 00 00 call 10f048 <_Thread_Clear_state>
10c7ec: 83 c4 10 add $0x10,%esp
10c7ef: eb dd jmp 10c7ce <rtems_rate_monotonic_period+0x17a>
0010c7f4 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
10c7f4: 55 push %ebp
10c7f5: 89 e5 mov %esp,%ebp
10c7f7: 57 push %edi
10c7f8: 56 push %esi
10c7f9: 53 push %ebx
10c7fa: 81 ec 8c 00 00 00 sub $0x8c,%esp
10c800: 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 )
10c803: 8b 7d 0c mov 0xc(%ebp),%edi
10c806: 85 ff test %edi,%edi
10c808: 0f 84 be 00 00 00 je 10c8cc <rtems_rate_monotonic_report_statistics_with_plugin+0xd8><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
10c80e: 83 ec 08 sub $0x8,%esp
10c811: 68 30 3d 12 00 push $0x123d30
10c816: 56 push %esi
10c817: ff 55 0c call *0xc(%ebp)
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
10c81a: 59 pop %ecx
10c81b: 5b pop %ebx
10c81c: 68 68 3d 12 00 push $0x123d68
10c821: 56 push %esi
10c822: ff 55 0c call *0xc(%ebp)
(*print)( context, "--- Wall times are in seconds ---\n" );
10c825: 58 pop %eax
10c826: 5a pop %edx
10c827: 68 8c 3d 12 00 push $0x123d8c
10c82c: 56 push %esi
10c82d: ff 55 0c call *0xc(%ebp)
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
10c830: 5b pop %ebx
10c831: 5f pop %edi
10c832: 68 b0 3d 12 00 push $0x123db0
10c837: 56 push %esi
10c838: ff 55 0c call *0xc(%ebp)
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
10c83b: 5a pop %edx
10c83c: 59 pop %ecx
10c83d: 68 fc 3d 12 00 push $0x123dfc
10c842: 56 push %esi
10c843: 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 ;
10c846: 8b 1d 68 b0 12 00 mov 0x12b068,%ebx
10c84c: 83 c4 10 add $0x10,%esp
10c84f: 3b 1d 6c b0 12 00 cmp 0x12b06c,%ebx
10c855: 77 75 ja 10c8cc <rtems_rate_monotonic_report_statistics_with_plugin+0xd8><== NEVER TAKEN
10c857: 8d 7d 88 lea -0x78(%ebp),%edi
10c85a: eb 09 jmp 10c865 <rtems_rate_monotonic_report_statistics_with_plugin+0x71>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
10c85c: 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 ;
10c85d: 39 1d 6c b0 12 00 cmp %ebx,0x12b06c
10c863: 72 67 jb 10c8cc <rtems_rate_monotonic_report_statistics_with_plugin+0xd8>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
10c865: 83 ec 08 sub $0x8,%esp
10c868: 57 push %edi
10c869: 53 push %ebx
10c86a: e8 e5 5f 00 00 call 112854 <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
10c86f: 83 c4 10 add $0x10,%esp
10c872: 85 c0 test %eax,%eax
10c874: 75 e6 jne 10c85c <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 );
10c876: 83 ec 08 sub $0x8,%esp
10c879: 8d 45 c0 lea -0x40(%ebp),%eax
10c87c: 50 push %eax
10c87d: 53 push %ebx
10c87e: e8 7d 60 00 00 call 112900 <rtems_rate_monotonic_get_status>
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
10c883: 83 c4 0c add $0xc,%esp
10c886: 8d 55 e3 lea -0x1d(%ebp),%edx
10c889: 52 push %edx
10c88a: 6a 05 push $0x5
10c88c: ff 75 c0 pushl -0x40(%ebp)
10c88f: e8 b4 02 00 00 call 10cb48 <rtems_object_get_name>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
10c894: 59 pop %ecx
10c895: 58 pop %eax
10c896: ff 75 8c pushl -0x74(%ebp)
10c899: ff 75 88 pushl -0x78(%ebp)
10c89c: 8d 45 e3 lea -0x1d(%ebp),%eax
10c89f: 50 push %eax
10c8a0: 53 push %ebx
10c8a1: 68 4e 3d 12 00 push $0x123d4e
10c8a6: 56 push %esi
10c8a7: ff 55 0c call *0xc(%ebp)
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
10c8aa: 8b 45 88 mov -0x78(%ebp),%eax
10c8ad: 83 c4 20 add $0x20,%esp
10c8b0: 85 c0 test %eax,%eax
10c8b2: 75 20 jne 10c8d4 <rtems_rate_monotonic_report_statistics_with_plugin+0xe0>
(*print)( context, "\n" );
10c8b4: 83 ec 08 sub $0x8,%esp
10c8b7: 68 31 1e 12 00 push $0x121e31
10c8bc: 56 push %esi
10c8bd: ff 55 0c call *0xc(%ebp)
continue;
10c8c0: 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++ ) {
10c8c3: 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 ;
10c8c4: 39 1d 6c b0 12 00 cmp %ebx,0x12b06c
10c8ca: 73 99 jae 10c865 <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
}
}
}
10c8cc: 8d 65 f4 lea -0xc(%ebp),%esp
10c8cf: 5b pop %ebx
10c8d0: 5e pop %esi
10c8d1: 5f pop %edi
10c8d2: c9 leave
10c8d3: 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 );
10c8d4: 52 push %edx
10c8d5: 8d 55 d8 lea -0x28(%ebp),%edx
10c8d8: 52 push %edx
10c8d9: 50 push %eax
10c8da: 8d 45 a0 lea -0x60(%ebp),%eax
10c8dd: 50 push %eax
10c8de: e8 99 35 00 00 call 10fe7c <_Timespec_Divide_by_integer>
(*print)( context,
10c8e3: b9 d3 4d 62 10 mov $0x10624dd3,%ecx
10c8e8: 8b 45 dc mov -0x24(%ebp),%eax
10c8eb: f7 e9 imul %ecx
10c8ed: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp)
10c8f3: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax
10c8f9: c1 f8 06 sar $0x6,%eax
10c8fc: 8b 55 dc mov -0x24(%ebp),%edx
10c8ff: c1 fa 1f sar $0x1f,%edx
10c902: 29 d0 sub %edx,%eax
10c904: 50 push %eax
10c905: ff 75 d8 pushl -0x28(%ebp)
10c908: 8b 45 9c mov -0x64(%ebp),%eax
10c90b: f7 e9 imul %ecx
10c90d: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp)
10c913: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax
10c919: c1 f8 06 sar $0x6,%eax
10c91c: 8b 55 9c mov -0x64(%ebp),%edx
10c91f: c1 fa 1f sar $0x1f,%edx
10c922: 29 d0 sub %edx,%eax
10c924: 50 push %eax
10c925: ff 75 98 pushl -0x68(%ebp)
10c928: 8b 45 94 mov -0x6c(%ebp),%eax
10c92b: f7 e9 imul %ecx
10c92d: 89 85 70 ff ff ff mov %eax,-0x90(%ebp)
10c933: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp)
10c939: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax
10c93f: c1 f8 06 sar $0x6,%eax
10c942: 8b 55 94 mov -0x6c(%ebp),%edx
10c945: c1 fa 1f sar $0x1f,%edx
10c948: 29 d0 sub %edx,%eax
10c94a: 50 push %eax
10c94b: ff 75 90 pushl -0x70(%ebp)
10c94e: 68 48 3e 12 00 push $0x123e48
10c953: 56 push %esi
10c954: 89 4d 84 mov %ecx,-0x7c(%ebp)
10c957: 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);
10c95a: 83 c4 2c add $0x2c,%esp
10c95d: 8d 55 d8 lea -0x28(%ebp),%edx
10c960: 52 push %edx
10c961: ff 75 88 pushl -0x78(%ebp)
10c964: 8d 45 b8 lea -0x48(%ebp),%eax
10c967: 50 push %eax
10c968: e8 0f 35 00 00 call 10fe7c <_Timespec_Divide_by_integer>
(*print)( context,
10c96d: 8b 4d 84 mov -0x7c(%ebp),%ecx
10c970: 8b 45 dc mov -0x24(%ebp),%eax
10c973: f7 e9 imul %ecx
10c975: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp)
10c97b: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax
10c981: c1 f8 06 sar $0x6,%eax
10c984: 8b 55 dc mov -0x24(%ebp),%edx
10c987: c1 fa 1f sar $0x1f,%edx
10c98a: 29 d0 sub %edx,%eax
10c98c: 50 push %eax
10c98d: ff 75 d8 pushl -0x28(%ebp)
10c990: 8b 45 b4 mov -0x4c(%ebp),%eax
10c993: f7 e9 imul %ecx
10c995: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp)
10c99b: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax
10c9a1: c1 f8 06 sar $0x6,%eax
10c9a4: 8b 55 b4 mov -0x4c(%ebp),%edx
10c9a7: c1 fa 1f sar $0x1f,%edx
10c9aa: 29 d0 sub %edx,%eax
10c9ac: 50 push %eax
10c9ad: ff 75 b0 pushl -0x50(%ebp)
10c9b0: 8b 45 ac mov -0x54(%ebp),%eax
10c9b3: f7 e9 imul %ecx
10c9b5: 89 85 70 ff ff ff mov %eax,-0x90(%ebp)
10c9bb: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp)
10c9c1: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax
10c9c7: c1 f8 06 sar $0x6,%eax
10c9ca: 8b 55 ac mov -0x54(%ebp),%edx
10c9cd: c1 fa 1f sar $0x1f,%edx
10c9d0: 29 d0 sub %edx,%eax
10c9d2: 50 push %eax
10c9d3: ff 75 a8 pushl -0x58(%ebp)
10c9d6: 68 68 3e 12 00 push $0x123e68
10c9db: 56 push %esi
10c9dc: ff 55 0c call *0xc(%ebp)
10c9df: 83 c4 30 add $0x30,%esp
10c9e2: e9 75 fe ff ff jmp 10c85c <rtems_rate_monotonic_report_statistics_with_plugin+0x68>
0010ca00 <rtems_rate_monotonic_reset_all_statistics>:
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
10ca00: 55 push %ebp
10ca01: 89 e5 mov %esp,%ebp
10ca03: 53 push %ebx
10ca04: 83 ec 04 sub $0x4,%esp
10ca07: a1 50 b1 12 00 mov 0x12b150,%eax
10ca0c: 40 inc %eax
10ca0d: a3 50 b1 12 00 mov %eax,0x12b150
/*
* 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 ;
10ca12: 8b 1d 68 b0 12 00 mov 0x12b068,%ebx
10ca18: 3b 1d 6c b0 12 00 cmp 0x12b06c,%ebx
10ca1e: 77 15 ja 10ca35 <rtems_rate_monotonic_reset_all_statistics+0x35><== NEVER TAKEN
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
10ca20: 83 ec 0c sub $0xc,%esp
10ca23: 53 push %ebx
10ca24: e8 17 00 00 00 call 10ca40 <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++ ) {
10ca29: 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 ;
10ca2a: 83 c4 10 add $0x10,%esp
10ca2d: 39 1d 6c b0 12 00 cmp %ebx,0x12b06c
10ca33: 73 eb jae 10ca20 <rtems_rate_monotonic_reset_all_statistics+0x20>
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
}
10ca35: 8b 5d fc mov -0x4(%ebp),%ebx
10ca38: c9 leave
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
10ca39: e9 6e 29 00 00 jmp 10f3ac <_Thread_Enable_dispatch>
0010ca40 <rtems_rate_monotonic_reset_statistics>:
*/
rtems_status_code rtems_rate_monotonic_reset_statistics(
rtems_id id
)
{
10ca40: 55 push %ebp
10ca41: 89 e5 mov %esp,%ebp
10ca43: 57 push %edi
10ca44: 53 push %ebx
10ca45: 83 ec 14 sub $0x14,%esp
Objects_Locations location;
Rate_monotonic_Control *the_period;
the_period = _Rate_monotonic_Get( id, &location );
10ca48: 8d 45 f4 lea -0xc(%ebp),%eax
10ca4b: 50 push %eax
10ca4c: ff 75 08 pushl 0x8(%ebp)
10ca4f: 68 60 b0 12 00 push $0x12b060
10ca54: e8 db 1d 00 00 call 10e834 <_Objects_Get>
10ca59: 89 c2 mov %eax,%edx
switch ( location ) {
10ca5b: 83 c4 10 add $0x10,%esp
10ca5e: 8b 45 f4 mov -0xc(%ebp),%eax
10ca61: 85 c0 test %eax,%eax
10ca63: 75 3b jne 10caa0 <rtems_rate_monotonic_reset_statistics+0x60>
case OBJECTS_LOCAL:
_Rate_monotonic_Reset_statistics( the_period );
10ca65: 8d 5a 54 lea 0x54(%edx),%ebx
10ca68: b9 38 00 00 00 mov $0x38,%ecx
10ca6d: 31 c0 xor %eax,%eax
10ca6f: 89 df mov %ebx,%edi
10ca71: f3 aa rep stos %al,%es:(%edi)
10ca73: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx)
10ca7a: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx)
10ca81: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx)
10ca88: c7 42 78 ff ff ff 7f movl $0x7fffffff,0x78(%edx)
_Thread_Enable_dispatch();
10ca8f: e8 18 29 00 00 call 10f3ac <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10ca94: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ca96: 8d 65 f8 lea -0x8(%ebp),%esp
10ca99: 5b pop %ebx
10ca9a: 5f pop %edi
10ca9b: c9 leave
10ca9c: c3 ret
10ca9d: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10caa0: b8 04 00 00 00 mov $0x4,%eax
}
10caa5: 8d 65 f8 lea -0x8(%ebp),%esp
10caa8: 5b pop %ebx
10caa9: 5f pop %edi
10caaa: c9 leave
10caab: c3 ret
0011724c <rtems_region_create>:
uintptr_t length,
uintptr_t page_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
11724c: 55 push %ebp
11724d: 89 e5 mov %esp,%ebp
11724f: 57 push %edi
117250: 56 push %esi
117251: 53 push %ebx
117252: 83 ec 1c sub $0x1c,%esp
117255: 8b 7d 08 mov 0x8(%ebp),%edi
117258: 8b 75 0c mov 0xc(%ebp),%esi
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
11725b: 85 ff test %edi,%edi
11725d: 0f 84 c1 00 00 00 je 117324 <rtems_region_create+0xd8>
return RTEMS_INVALID_NAME;
if ( !starting_address )
117263: 85 f6 test %esi,%esi
117265: 0f 84 e1 00 00 00 je 11734c <rtems_region_create+0x100>
return RTEMS_INVALID_ADDRESS;
if ( !id )
11726b: 8b 45 1c mov 0x1c(%ebp),%eax
11726e: 85 c0 test %eax,%eax
117270: 0f 84 d6 00 00 00 je 11734c <rtems_region_create+0x100>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
117276: 83 ec 0c sub $0xc,%esp
117279: ff 35 e0 2a 14 00 pushl 0x142ae0
11727f: e8 24 25 00 00 call 1197a8 <_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 );
117284: c7 04 24 40 29 14 00 movl $0x142940,(%esp)
11728b: e8 5c 3b 00 00 call 11adec <_Objects_Allocate>
117290: 89 c3 mov %eax,%ebx
the_region = _Region_Allocate();
if ( !the_region )
117292: 83 c4 10 add $0x10,%esp
117295: 85 c0 test %eax,%eax
117297: 0f 84 bf 00 00 00 je 11735c <rtems_region_create+0x110>
return_status = RTEMS_TOO_MANY;
else {
the_region->maximum_segment_size = _Heap_Initialize(
11729d: ff 75 14 pushl 0x14(%ebp)
1172a0: ff 75 10 pushl 0x10(%ebp)
1172a3: 56 push %esi
1172a4: 8d 40 68 lea 0x68(%eax),%eax
1172a7: 50 push %eax
1172a8: e8 4b 37 00 00 call 11a9f8 <_Heap_Initialize>
1172ad: 89 43 5c mov %eax,0x5c(%ebx)
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
1172b0: 83 c4 10 add $0x10,%esp
1172b3: 85 c0 test %eax,%eax
1172b5: 74 7d je 117334 <rtems_region_create+0xe8>
return_status = RTEMS_INVALID_SIZE;
}
else {
the_region->starting_address = starting_address;
1172b7: 89 73 50 mov %esi,0x50(%ebx)
the_region->length = length;
1172ba: 8b 45 10 mov 0x10(%ebp),%eax
1172bd: 89 43 54 mov %eax,0x54(%ebx)
the_region->page_size = page_size;
1172c0: 8b 55 14 mov 0x14(%ebp),%edx
1172c3: 89 53 58 mov %edx,0x58(%ebx)
the_region->attribute_set = attribute_set;
1172c6: 8b 45 18 mov 0x18(%ebp),%eax
1172c9: 89 43 60 mov %eax,0x60(%ebx)
the_region->number_of_used_blocks = 0;
1172cc: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
_Thread_queue_Initialize(
1172d3: 6a 06 push $0x6
1172d5: 6a 40 push $0x40
1172d7: a8 04 test $0x4,%al
1172d9: 0f 95 c0 setne %al
1172dc: 0f b6 c0 movzbl %al,%eax
1172df: 50 push %eax
1172e0: 8d 43 10 lea 0x10(%ebx),%eax
1172e3: 50 push %eax
1172e4: e8 77 52 00 00 call 11c560 <_Thread_queue_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
1172e9: 8b 43 08 mov 0x8(%ebx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
1172ec: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
1172ef: 8b 15 5c 29 14 00 mov 0x14295c,%edx
1172f5: 89 1c 8a mov %ebx,(%edx,%ecx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
1172f8: 89 7b 0c mov %edi,0xc(%ebx)
&_Region_Information,
&the_region->Object,
(Objects_Name) name
);
*id = the_region->Object.id;
1172fb: 8b 55 1c mov 0x1c(%ebp),%edx
1172fe: 89 02 mov %eax,(%edx)
117300: 83 c4 10 add $0x10,%esp
return_status = RTEMS_SUCCESSFUL;
117303: 31 c0 xor %eax,%eax
}
}
_RTEMS_Unlock_allocator();
117305: 83 ec 0c sub $0xc,%esp
117308: ff 35 e0 2a 14 00 pushl 0x142ae0
11730e: 89 45 e4 mov %eax,-0x1c(%ebp)
117311: e8 da 24 00 00 call 1197f0 <_API_Mutex_Unlock>
return return_status;
117316: 83 c4 10 add $0x10,%esp
117319: 8b 45 e4 mov -0x1c(%ebp),%eax
}
11731c: 8d 65 f4 lea -0xc(%ebp),%esp
11731f: 5b pop %ebx
117320: 5e pop %esi
117321: 5f pop %edi
117322: c9 leave
117323: c3 ret
{
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
117324: b8 03 00 00 00 mov $0x3,%eax
}
}
_RTEMS_Unlock_allocator();
return return_status;
}
117329: 8d 65 f4 lea -0xc(%ebp),%esp
11732c: 5b pop %ebx
11732d: 5e pop %esi
11732e: 5f pop %edi
11732f: c9 leave
117330: c3 ret
117331: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _Region_Free (
Region_Control *the_region
)
{
_Objects_Free( &_Region_Information, &the_region->Object );
117334: 83 ec 08 sub $0x8,%esp
117337: 53 push %ebx
117338: 68 40 29 14 00 push $0x142940
11733d: e8 1e 3e 00 00 call 11b160 <_Objects_Free>
117342: 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;
117345: b8 08 00 00 00 mov $0x8,%eax
11734a: eb b9 jmp 117305 <rtems_region_create+0xb9>
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
11734c: b8 09 00 00 00 mov $0x9,%eax
}
}
_RTEMS_Unlock_allocator();
return return_status;
}
117351: 8d 65 f4 lea -0xc(%ebp),%esp
117354: 5b pop %ebx
117355: 5e pop %esi
117356: 5f pop %edi
117357: c9 leave
117358: c3 ret
117359: 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;
11735c: b8 05 00 00 00 mov $0x5,%eax
117361: eb a2 jmp 117305 <rtems_region_create+0xb9>
00117364 <rtems_region_delete>:
*/
rtems_status_code rtems_region_delete(
rtems_id id
)
{
117364: 55 push %ebp
117365: 89 e5 mov %esp,%ebp
117367: 53 push %ebx
117368: 83 ec 30 sub $0x30,%esp
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
_RTEMS_Lock_allocator();
11736b: ff 35 e0 2a 14 00 pushl 0x142ae0
117371: e8 32 24 00 00 call 1197a8 <_API_Mutex_Lock>
Objects_Id id,
Objects_Locations *location
)
{
return (Region_Control *)
_Objects_Get_no_protection( &_Region_Information, id, location );
117376: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
117379: 8d 45 f4 lea -0xc(%ebp),%eax
11737c: 50 push %eax
11737d: ff 75 08 pushl 0x8(%ebp)
117380: 68 40 29 14 00 push $0x142940
117385: e8 16 3f 00 00 call 11b2a0 <_Objects_Get_no_protection>
switch ( location ) {
11738a: 83 c4 10 add $0x10,%esp
11738d: 8b 5d f4 mov -0xc(%ebp),%ebx
117390: 85 db test %ebx,%ebx
117392: 74 1c je 1173b0 <rtems_region_delete+0x4c>
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
117394: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
117399: 83 ec 0c sub $0xc,%esp
11739c: ff 35 e0 2a 14 00 pushl 0x142ae0
1173a2: e8 49 24 00 00 call 1197f0 <_API_Mutex_Unlock>
return return_status;
}
1173a7: 89 d8 mov %ebx,%eax
1173a9: 8b 5d fc mov -0x4(%ebp),%ebx
1173ac: c9 leave
1173ad: c3 ret
1173ae: 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 )
1173b0: 8b 48 64 mov 0x64(%eax),%ecx
1173b3: 85 c9 test %ecx,%ecx
1173b5: 74 09 je 1173c0 <rtems_region_delete+0x5c>
return_status = RTEMS_RESOURCE_IN_USE;
1173b7: bb 0c 00 00 00 mov $0xc,%ebx
1173bc: eb db jmp 117399 <rtems_region_delete+0x35>
1173be: 66 90 xchg %ax,%ax
else {
_Objects_Close( &_Region_Information, &the_region->Object );
1173c0: 83 ec 08 sub $0x8,%esp
1173c3: 50 push %eax
1173c4: 68 40 29 14 00 push $0x142940
1173c9: 89 45 e4 mov %eax,-0x1c(%ebp)
1173cc: e8 97 3a 00 00 call 11ae68 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Region_Free (
Region_Control *the_region
)
{
_Objects_Free( &_Region_Information, &the_region->Object );
1173d1: 58 pop %eax
1173d2: 5a pop %edx
1173d3: 8b 45 e4 mov -0x1c(%ebp),%eax
1173d6: 50 push %eax
1173d7: 68 40 29 14 00 push $0x142940
1173dc: e8 7f 3d 00 00 call 11b160 <_Objects_Free>
1173e1: 83 c4 10 add $0x10,%esp
_Region_Free( the_region );
return_status = RTEMS_SUCCESSFUL;
1173e4: 31 db xor %ebx,%ebx
1173e6: eb b1 jmp 117399 <rtems_region_delete+0x35>
001173e8 <rtems_region_extend>:
rtems_status_code rtems_region_extend(
rtems_id id,
void *starting_address,
uintptr_t length
)
{
1173e8: 55 push %ebp
1173e9: 89 e5 mov %esp,%ebp
1173eb: 56 push %esi
1173ec: 53 push %ebx
1173ed: 83 ec 10 sub $0x10,%esp
1173f0: 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 )
1173f3: 85 db test %ebx,%ebx
1173f5: 74 75 je 11746c <rtems_region_extend+0x84>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
1173f7: 83 ec 0c sub $0xc,%esp
1173fa: ff 35 e0 2a 14 00 pushl 0x142ae0
117400: e8 a3 23 00 00 call 1197a8 <_API_Mutex_Lock>
Objects_Id id,
Objects_Locations *location
)
{
return (Region_Control *)
_Objects_Get_no_protection( &_Region_Information, id, location );
117405: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
117408: 8d 45 f0 lea -0x10(%ebp),%eax
11740b: 50 push %eax
11740c: ff 75 08 pushl 0x8(%ebp)
11740f: 68 40 29 14 00 push $0x142940
117414: e8 87 3e 00 00 call 11b2a0 <_Objects_Get_no_protection>
117419: 89 c6 mov %eax,%esi
switch ( location ) {
11741b: 83 c4 10 add $0x10,%esp
11741e: 8b 45 f0 mov -0x10(%ebp),%eax
117421: 85 c0 test %eax,%eax
117423: 74 1f je 117444 <rtems_region_extend+0x5c>
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
117425: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
11742a: 83 ec 0c sub $0xc,%esp
11742d: ff 35 e0 2a 14 00 pushl 0x142ae0
117433: e8 b8 23 00 00 call 1197f0 <_API_Mutex_Unlock>
return return_status;
117438: 83 c4 10 add $0x10,%esp
}
11743b: 89 d8 mov %ebx,%eax
11743d: 8d 65 f8 lea -0x8(%ebp),%esp
117440: 5b pop %ebx
117441: 5e pop %esi
117442: c9 leave
117443: c3 ret
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
extend_ok = _Heap_Extend(
117444: 8d 45 f4 lea -0xc(%ebp),%eax
117447: 50 push %eax
117448: ff 75 10 pushl 0x10(%ebp)
11744b: 53 push %ebx
11744c: 8d 46 68 lea 0x68(%esi),%eax
11744f: 50 push %eax
117450: e8 97 2f 00 00 call 11a3ec <_Heap_Extend>
starting_address,
length,
&amount_extended
);
if ( extend_ok ) {
117455: 83 c4 10 add $0x10,%esp
117458: 84 c0 test %al,%al
11745a: 74 20 je 11747c <rtems_region_extend+0x94>
the_region->length += amount_extended;
11745c: 8b 45 f4 mov -0xc(%ebp),%eax
11745f: 01 46 54 add %eax,0x54(%esi)
the_region->maximum_segment_size += amount_extended;
117462: 01 46 5c add %eax,0x5c(%esi)
return_status = RTEMS_SUCCESSFUL;
117465: 31 db xor %ebx,%ebx
117467: eb c1 jmp 11742a <rtems_region_extend+0x42>
117469: 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;
11746c: bb 09 00 00 00 mov $0x9,%ebx
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
117471: 89 d8 mov %ebx,%eax
117473: 8d 65 f8 lea -0x8(%ebp),%esp
117476: 5b pop %ebx
117477: 5e pop %esi
117478: c9 leave
117479: c3 ret
11747a: 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;
11747c: bb 09 00 00 00 mov $0x9,%ebx
117481: eb a7 jmp 11742a <rtems_region_extend+0x42>
00117484 <rtems_region_get_free_information>:
rtems_status_code rtems_region_get_free_information(
rtems_id id,
Heap_Information_block *the_info
)
{
117484: 55 push %ebp
117485: 89 e5 mov %esp,%ebp
117487: 53 push %ebx
117488: 83 ec 14 sub $0x14,%esp
11748b: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
11748e: 85 db test %ebx,%ebx
117490: 74 76 je 117508 <rtems_region_get_free_information+0x84>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
117492: 83 ec 0c sub $0xc,%esp
117495: ff 35 e0 2a 14 00 pushl 0x142ae0
11749b: e8 08 23 00 00 call 1197a8 <_API_Mutex_Lock>
1174a0: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
1174a3: 8d 45 f4 lea -0xc(%ebp),%eax
1174a6: 50 push %eax
1174a7: ff 75 08 pushl 0x8(%ebp)
1174aa: 68 40 29 14 00 push $0x142940
1174af: e8 ec 3d 00 00 call 11b2a0 <_Objects_Get_no_protection>
switch ( location ) {
1174b4: 83 c4 10 add $0x10,%esp
1174b7: 8b 55 f4 mov -0xc(%ebp),%edx
1174ba: 85 d2 test %edx,%edx
1174bc: 74 1e je 1174dc <rtems_region_get_free_information+0x58>
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
1174be: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
1174c3: 83 ec 0c sub $0xc,%esp
1174c6: ff 35 e0 2a 14 00 pushl 0x142ae0
1174cc: e8 1f 23 00 00 call 1197f0 <_API_Mutex_Unlock>
return return_status;
1174d1: 83 c4 10 add $0x10,%esp
}
1174d4: 89 d8 mov %ebx,%eax
1174d6: 8b 5d fc mov -0x4(%ebp),%ebx
1174d9: c9 leave
1174da: c3 ret
1174db: 90 nop
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_info->Used.number = 0;
1174dc: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
the_info->Used.total = 0;
1174e3: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
the_info->Used.largest = 0;
1174ea: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
_Heap_Get_free_information( &the_region->Memory, &the_info->Free );
1174f1: 83 ec 08 sub $0x8,%esp
1174f4: 53 push %ebx
1174f5: 83 c0 68 add $0x68,%eax
1174f8: 50 push %eax
1174f9: e8 d6 32 00 00 call 11a7d4 <_Heap_Get_free_information>
return_status = RTEMS_SUCCESSFUL;
break;
1174fe: 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;
117501: 31 db xor %ebx,%ebx
break;
117503: eb be jmp 1174c3 <rtems_region_get_free_information+0x3f>
117505: 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;
117508: bb 09 00 00 00 mov $0x9,%ebx
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
11750d: 89 d8 mov %ebx,%eax
11750f: 8b 5d fc mov -0x4(%ebp),%ebx
117512: c9 leave
117513: c3 ret
0011758c <rtems_region_get_segment>:
uintptr_t size,
rtems_option option_set,
rtems_interval timeout,
void **segment
)
{
11758c: 55 push %ebp
11758d: 89 e5 mov %esp,%ebp
11758f: 57 push %edi
117590: 56 push %esi
117591: 53 push %ebx
117592: 83 ec 2c sub $0x2c,%esp
117595: 8b 75 0c mov 0xc(%ebp),%esi
117598: 8b 5d 18 mov 0x18(%ebp),%ebx
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
void *the_segment;
if ( !segment )
11759b: 85 db test %ebx,%ebx
11759d: 0f 84 a1 00 00 00 je 117644 <rtems_region_get_segment+0xb8>
return RTEMS_INVALID_ADDRESS;
*segment = NULL;
1175a3: c7 03 00 00 00 00 movl $0x0,(%ebx)
if ( size == 0 )
1175a9: 85 f6 test %esi,%esi
1175ab: 75 0f jne 1175bc <rtems_region_get_segment+0x30>
return RTEMS_INVALID_SIZE;
1175ad: b8 08 00 00 00 mov $0x8,%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
1175b2: 8d 65 f4 lea -0xc(%ebp),%esp
1175b5: 5b pop %ebx
1175b6: 5e pop %esi
1175b7: 5f pop %edi
1175b8: c9 leave
1175b9: c3 ret
1175ba: 66 90 xchg %ax,%ax
*segment = NULL;
if ( size == 0 )
return RTEMS_INVALID_SIZE;
_RTEMS_Lock_allocator();
1175bc: 83 ec 0c sub $0xc,%esp
1175bf: ff 35 e0 2a 14 00 pushl 0x142ae0
1175c5: e8 de 21 00 00 call 1197a8 <_API_Mutex_Lock>
executing = _Thread_Executing;
1175ca: a1 d8 2f 14 00 mov 0x142fd8,%eax
1175cf: 89 45 d4 mov %eax,-0x2c(%ebp)
1175d2: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
1175d5: 8d 45 e4 lea -0x1c(%ebp),%eax
1175d8: 50 push %eax
1175d9: ff 75 08 pushl 0x8(%ebp)
1175dc: 68 40 29 14 00 push $0x142940
1175e1: e8 ba 3c 00 00 call 11b2a0 <_Objects_Get_no_protection>
1175e6: 89 c7 mov %eax,%edi
switch ( location ) {
1175e8: 83 c4 10 add $0x10,%esp
1175eb: 8b 45 e4 mov -0x1c(%ebp),%eax
1175ee: 85 c0 test %eax,%eax
1175f0: 75 2a jne 11761c <rtems_region_get_segment+0x90>
case OBJECTS_LOCAL:
if ( size > the_region->maximum_segment_size )
1175f2: 3b 77 5c cmp 0x5c(%edi),%esi
1175f5: 76 2d jbe 117624 <rtems_region_get_segment+0x98>
return_status = RTEMS_INVALID_SIZE;
1175f7: b8 08 00 00 00 mov $0x8,%eax
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
1175fc: 83 ec 0c sub $0xc,%esp
1175ff: ff 35 e0 2a 14 00 pushl 0x142ae0
117605: 89 45 d0 mov %eax,-0x30(%ebp)
117608: e8 e3 21 00 00 call 1197f0 <_API_Mutex_Unlock>
return return_status;
11760d: 83 c4 10 add $0x10,%esp
117610: 8b 45 d0 mov -0x30(%ebp),%eax
}
117613: 8d 65 f4 lea -0xc(%ebp),%esp
117616: 5b pop %ebx
117617: 5e pop %esi
117618: 5f pop %edi
117619: c9 leave
11761a: c3 ret
11761b: 90 nop
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
11761c: b8 04 00 00 00 mov $0x4,%eax
117621: eb d9 jmp 1175fc <rtems_region_get_segment+0x70>
117623: 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 );
117624: 6a 00 push $0x0
117626: 6a 00 push $0x0
117628: 56 push %esi
RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment (
Region_Control *the_region,
uintptr_t size
)
{
return _Heap_Allocate( &the_region->Memory, size );
117629: 8d 47 68 lea 0x68(%edi),%eax
11762c: 50 push %eax
11762d: e8 e6 2b 00 00 call 11a218 <_Heap_Allocate_aligned_with_boundary>
the_segment = _Region_Allocate_segment( the_region, size );
_Region_Debug_Walk( the_region, 2 );
if ( the_segment ) {
117632: 83 c4 10 add $0x10,%esp
117635: 85 c0 test %eax,%eax
117637: 74 17 je 117650 <rtems_region_get_segment+0xc4>
the_region->number_of_used_blocks += 1;
117639: ff 47 64 incl 0x64(%edi)
*segment = the_segment;
11763c: 89 03 mov %eax,(%ebx)
return_status = RTEMS_SUCCESSFUL;
11763e: 31 c0 xor %eax,%eax
117640: eb ba jmp 1175fc <rtems_region_get_segment+0x70>
117642: 66 90 xchg %ax,%ax
rtems_status_code return_status;
Region_Control *the_region;
void *the_segment;
if ( !segment )
return RTEMS_INVALID_ADDRESS;
117644: b8 09 00 00 00 mov $0x9,%eax
117649: e9 64 ff ff ff jmp 1175b2 <rtems_region_get_segment+0x26>
11764e: 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 ) ) {
117650: f6 45 10 01 testb $0x1,0x10(%ebp)
117654: 74 07 je 11765d <rtems_region_get_segment+0xd1>
return_status = RTEMS_UNSATISFIED;
117656: b8 0d 00 00 00 mov $0xd,%eax
11765b: eb 9f jmp 1175fc <rtems_region_get_segment+0x70>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
11765d: a1 30 2a 14 00 mov 0x142a30,%eax
117662: 40 inc %eax
117663: a3 30 2a 14 00 mov %eax,0x142a30
* 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();
117668: 83 ec 0c sub $0xc,%esp
11766b: ff 35 e0 2a 14 00 pushl 0x142ae0
117671: e8 7a 21 00 00 call 1197f0 <_API_Mutex_Unlock>
executing->Wait.queue = &the_region->Wait_queue;
117676: 8d 47 10 lea 0x10(%edi),%eax
117679: 8b 55 d4 mov -0x2c(%ebp),%edx
11767c: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
11767f: 8b 4d 08 mov 0x8(%ebp),%ecx
117682: 89 4a 20 mov %ecx,0x20(%edx)
executing->Wait.count = size;
117685: 89 72 24 mov %esi,0x24(%edx)
executing->Wait.return_argument = segment;
117688: 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;
11768b: 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 );
117692: 83 c4 0c add $0xc,%esp
117695: 68 24 c6 11 00 push $0x11c624
11769a: ff 75 14 pushl 0x14(%ebp)
11769d: 50 push %eax
11769e: e8 55 4c 00 00 call 11c2f8 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
1176a3: e8 ac 47 00 00 call 11be54 <_Thread_Enable_dispatch>
return (rtems_status_code) executing->Wait.return_code;
1176a8: 8b 55 d4 mov -0x2c(%ebp),%edx
1176ab: 8b 42 34 mov 0x34(%edx),%eax
1176ae: 83 c4 10 add $0x10,%esp
1176b1: e9 fc fe ff ff jmp 1175b2 <rtems_region_get_segment+0x26>
0011776c <rtems_region_resize_segment>:
rtems_id id,
void *segment,
uintptr_t size,
uintptr_t *old_size
)
{
11776c: 55 push %ebp
11776d: 89 e5 mov %esp,%ebp
11776f: 56 push %esi
117770: 53 push %ebx
117771: 83 ec 20 sub $0x20,%esp
117774: 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 )
117777: 85 db test %ebx,%ebx
117779: 0f 84 89 00 00 00 je 117808 <rtems_region_resize_segment+0x9c>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
11777f: 83 ec 0c sub $0xc,%esp
117782: ff 35 e0 2a 14 00 pushl 0x142ae0
117788: e8 1b 20 00 00 call 1197a8 <_API_Mutex_Lock>
11778d: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
117790: 8d 45 f0 lea -0x10(%ebp),%eax
117793: 50 push %eax
117794: ff 75 08 pushl 0x8(%ebp)
117797: 68 40 29 14 00 push $0x142940
11779c: e8 ff 3a 00 00 call 11b2a0 <_Objects_Get_no_protection>
1177a1: 89 c6 mov %eax,%esi
switch ( location ) {
1177a3: 83 c4 10 add $0x10,%esp
1177a6: 8b 45 f0 mov -0x10(%ebp),%eax
1177a9: 85 c0 test %eax,%eax
1177ab: 74 1f je 1177cc <rtems_region_resize_segment+0x60>
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
1177ad: 83 ec 0c sub $0xc,%esp
1177b0: ff 35 e0 2a 14 00 pushl 0x142ae0
1177b6: e8 35 20 00 00 call 1197f0 <_API_Mutex_Unlock>
return return_status;
1177bb: 83 c4 10 add $0x10,%esp
1177be: b8 04 00 00 00 mov $0x4,%eax
}
1177c3: 8d 65 f8 lea -0x8(%ebp),%esp
1177c6: 5b pop %ebx
1177c7: 5e pop %esi
1177c8: c9 leave
1177c9: c3 ret
1177ca: 66 90 xchg %ax,%ax
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 7 );
status = _Heap_Resize_block(
1177cc: 83 ec 0c sub $0xc,%esp
1177cf: 8d 45 f4 lea -0xc(%ebp),%eax
1177d2: 50 push %eax
1177d3: 8d 45 ec lea -0x14(%ebp),%eax
1177d6: 50 push %eax
1177d7: ff 75 10 pushl 0x10(%ebp)
1177da: ff 75 0c pushl 0xc(%ebp)
1177dd: 8d 46 68 lea 0x68(%esi),%eax
1177e0: 50 push %eax
1177e1: e8 1a 34 00 00 call 11ac00 <_Heap_Resize_block>
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
1177e6: 8b 55 ec mov -0x14(%ebp),%edx
1177e9: 89 13 mov %edx,(%ebx)
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
1177eb: 83 c4 20 add $0x20,%esp
1177ee: 85 c0 test %eax,%eax
1177f0: 75 22 jne 117814 <rtems_region_resize_segment+0xa8>
_Region_Process_queue( the_region ); /* unlocks allocator */
1177f2: 83 ec 0c sub $0xc,%esp
1177f5: 56 push %esi
1177f6: e8 d5 7c 00 00 call 11f4d0 <_Region_Process_queue>
1177fb: 83 c4 10 add $0x10,%esp
else
_RTEMS_Unlock_allocator();
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
1177fe: 31 c0 xor %eax,%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
117800: 8d 65 f8 lea -0x8(%ebp),%esp
117803: 5b pop %ebx
117804: 5e pop %esi
117805: c9 leave
117806: c3 ret
117807: 90 nop
rtems_status_code return_status;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
return RTEMS_INVALID_ADDRESS;
117808: b8 09 00 00 00 mov $0x9,%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
11780d: 8d 65 f8 lea -0x8(%ebp),%esp
117810: 5b pop %ebx
117811: 5e pop %esi
117812: c9 leave
117813: c3 ret
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
_Region_Process_queue( the_region ); /* unlocks allocator */
else
_RTEMS_Unlock_allocator();
117814: 83 ec 0c sub $0xc,%esp
117817: ff 35 e0 2a 14 00 pushl 0x142ae0
11781d: 89 45 e4 mov %eax,-0x1c(%ebp)
117820: e8 cb 1f 00 00 call 1197f0 <_API_Mutex_Unlock>
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
if (status == HEAP_RESIZE_UNSATISFIED)
117825: 83 c4 10 add $0x10,%esp
return RTEMS_UNSATISFIED;
117828: 8b 45 e4 mov -0x1c(%ebp),%eax
11782b: 48 dec %eax
11782c: 0f 94 c0 sete %al
11782f: 0f b6 c0 movzbl %al,%eax
117832: 8d 04 85 09 00 00 00 lea 0x9(,%eax,4),%eax
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
117839: 8d 65 f8 lea -0x8(%ebp),%esp
11783c: 5b pop %ebx
11783d: 5e pop %esi
11783e: c9 leave
11783f: c3 ret
00117840 <rtems_region_return_segment>:
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
117840: 55 push %ebp
117841: 89 e5 mov %esp,%ebp
117843: 53 push %ebx
117844: 83 ec 20 sub $0x20,%esp
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
117847: ff 35 e0 2a 14 00 pushl 0x142ae0
11784d: e8 56 1f 00 00 call 1197a8 <_API_Mutex_Lock>
117852: 83 c4 0c add $0xc,%esp
the_region = _Region_Get( id, &location );
117855: 8d 45 f4 lea -0xc(%ebp),%eax
117858: 50 push %eax
117859: ff 75 08 pushl 0x8(%ebp)
11785c: 68 40 29 14 00 push $0x142940
117861: e8 3a 3a 00 00 call 11b2a0 <_Objects_Get_no_protection>
117866: 89 c3 mov %eax,%ebx
switch ( location ) {
117868: 83 c4 10 add $0x10,%esp
11786b: 8b 45 f4 mov -0xc(%ebp),%eax
11786e: 85 c0 test %eax,%eax
117870: 75 1e jne 117890 <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 );
117872: 83 ec 08 sub $0x8,%esp
117875: ff 75 0c pushl 0xc(%ebp)
117878: 8d 43 68 lea 0x68(%ebx),%eax
11787b: 50 push %eax
11787c: e8 03 2e 00 00 call 11a684 <_Heap_Free>
#endif
status = _Region_Free_segment( the_region, segment );
_Region_Debug_Walk( the_region, 4 );
if ( !status )
117881: 83 c4 10 add $0x10,%esp
117884: 84 c0 test %al,%al
117886: 75 28 jne 1178b0 <rtems_region_return_segment+0x70>
return_status = RTEMS_INVALID_ADDRESS;
117888: bb 09 00 00 00 mov $0x9,%ebx
11788d: eb 06 jmp 117895 <rtems_region_return_segment+0x55>
11788f: 90 nop
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
117890: bb 04 00 00 00 mov $0x4,%ebx
break;
}
_RTEMS_Unlock_allocator();
117895: 83 ec 0c sub $0xc,%esp
117898: ff 35 e0 2a 14 00 pushl 0x142ae0
11789e: e8 4d 1f 00 00 call 1197f0 <_API_Mutex_Unlock>
return return_status;
1178a3: 83 c4 10 add $0x10,%esp
}
1178a6: 89 d8 mov %ebx,%eax
1178a8: 8b 5d fc mov -0x4(%ebp),%ebx
1178ab: c9 leave
1178ac: c3 ret
1178ad: 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;
1178b0: ff 4b 64 decl 0x64(%ebx)
_Region_Process_queue(the_region); /* unlocks allocator */
1178b3: 83 ec 0c sub $0xc,%esp
1178b6: 53 push %ebx
1178b7: e8 14 7c 00 00 call 11f4d0 <_Region_Process_queue>
return RTEMS_SUCCESSFUL;
1178bc: 83 c4 10 add $0x10,%esp
1178bf: 31 db xor %ebx,%ebx
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
1178c1: 89 d8 mov %ebx,%eax
1178c3: 8b 5d fc mov -0x4(%ebp),%ebx
1178c6: c9 leave
1178c7: c3 ret
0010b434 <rtems_semaphore_create>:
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
10b434: 55 push %ebp
10b435: 89 e5 mov %esp,%ebp
10b437: 57 push %edi
10b438: 56 push %esi
10b439: 53 push %ebx
10b43a: 83 ec 3c sub $0x3c,%esp
10b43d: 8b 75 08 mov 0x8(%ebp),%esi
10b440: 8b 5d 10 mov 0x10(%ebp),%ebx
10b443: 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 ) )
10b446: 85 f6 test %esi,%esi
10b448: 74 4a je 10b494 <rtems_semaphore_create+0x60>
return RTEMS_INVALID_NAME;
if ( !id )
10b44a: 85 ff test %edi,%edi
10b44c: 0f 84 f6 00 00 00 je 10b548 <rtems_semaphore_create+0x114>
return RTEMS_NOT_DEFINED;
} else
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
10b452: 89 da mov %ebx,%edx
10b454: 81 e2 c0 00 00 00 and $0xc0,%edx
10b45a: 74 48 je 10b4a4 <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);
10b45c: 89 d8 mov %ebx,%eax
10b45e: 83 e0 30 and $0x30,%eax
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
10b461: 83 f8 10 cmp $0x10,%eax
10b464: 74 0e je 10b474 <rtems_semaphore_create+0x40>
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
10b466: b8 0b 00 00 00 mov $0xb,%eax
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b46b: 8d 65 f4 lea -0xc(%ebp),%esp
10b46e: 5b pop %ebx
10b46f: 5e pop %esi
10b470: 5f pop %edi
10b471: c9 leave
10b472: c3 ret
10b473: 90 nop
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
10b474: f6 c3 04 test $0x4,%bl
10b477: 74 ed je 10b466 <rtems_semaphore_create+0x32>
_Attributes_Is_priority( attribute_set ) ) )
return RTEMS_NOT_DEFINED;
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
10b479: 81 fa c0 00 00 00 cmp $0xc0,%edx
10b47f: 74 e5 je 10b466 <rtems_semaphore_create+0x32>
10b481: 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 ) )
10b486: 83 7d 0c 01 cmpl $0x1,0xc(%ebp)
10b48a: 76 1f jbe 10b4ab <rtems_semaphore_create+0x77>
return RTEMS_INVALID_NUMBER;
10b48c: b8 0a 00 00 00 mov $0xa,%eax
10b491: eb d8 jmp 10b46b <rtems_semaphore_create+0x37>
10b493: 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;
10b494: b8 03 00 00 00 mov $0x3,%eax
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b499: 8d 65 f4 lea -0xc(%ebp),%esp
10b49c: 5b pop %ebx
10b49d: 5e pop %esi
10b49e: 5f pop %edi
10b49f: c9 leave
10b4a0: c3 ret
10b4a1: 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 ) )
10b4a4: 89 d9 mov %ebx,%ecx
10b4a6: 83 e1 30 and $0x30,%ecx
10b4a9: 75 db jne 10b486 <rtems_semaphore_create+0x52>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b4ab: a1 90 7d 12 00 mov 0x127d90,%eax
10b4b0: 40 inc %eax
10b4b1: a3 90 7d 12 00 mov %eax,0x127d90
* 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 );
10b4b6: 83 ec 0c sub $0xc,%esp
10b4b9: 68 e0 7c 12 00 push $0x127ce0
10b4be: 89 4d c4 mov %ecx,-0x3c(%ebp)
10b4c1: e8 be 14 00 00 call 10c984 <_Objects_Allocate>
10b4c6: 89 c2 mov %eax,%edx
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
10b4c8: 83 c4 10 add $0x10,%esp
10b4cb: 85 c0 test %eax,%eax
10b4cd: 8b 4d c4 mov -0x3c(%ebp),%ecx
10b4d0: 0f 84 ba 00 00 00 je 10b590 <rtems_semaphore_create+0x15c>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_semaphore->attribute_set = attribute_set;
10b4d6: 89 58 10 mov %ebx,0x10(%eax)
/*
* Initialize it as a counting semaphore.
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
10b4d9: 85 c9 test %ecx,%ecx
10b4db: 74 77 je 10b554 <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;
10b4dd: 31 c0 xor %eax,%eax
10b4df: f6 c3 04 test $0x4,%bl
10b4e2: 0f 95 c0 setne %al
10b4e5: 89 45 d8 mov %eax,-0x28(%ebp)
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
10b4e8: 83 f9 10 cmp $0x10,%ecx
10b4eb: 0f 84 ae 00 00 00 je 10b59f <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;
10b4f1: c7 45 d0 02 00 00 00 movl $0x2,-0x30(%ebp)
the_mutex_attr.only_owner_release = false;
10b4f8: c6 45 d4 00 movb $0x0,-0x2c(%ebp)
}
mutex_status = _CORE_mutex_Initialize(
10b4fc: 50 push %eax
10b4fd: 31 c0 xor %eax,%eax
10b4ff: 83 7d 0c 01 cmpl $0x1,0xc(%ebp)
10b503: 0f 94 c0 sete %al
10b506: 50 push %eax
10b507: 8d 45 d0 lea -0x30(%ebp),%eax
10b50a: 50 push %eax
10b50b: 8d 42 14 lea 0x14(%edx),%eax
10b50e: 50 push %eax
10b50f: 89 55 c4 mov %edx,-0x3c(%ebp)
10b512: e8 65 0c 00 00 call 10c17c <_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 ) {
10b517: 83 c4 10 add $0x10,%esp
10b51a: 83 f8 06 cmp $0x6,%eax
10b51d: 8b 55 c4 mov -0x3c(%ebp),%edx
10b520: 0f 84 a9 00 00 00 je 10b5cf <rtems_semaphore_create+0x19b>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10b526: 8b 42 08 mov 0x8(%edx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10b529: 0f b7 d8 movzwl %ax,%ebx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10b52c: 8b 0d fc 7c 12 00 mov 0x127cfc,%ecx
10b532: 89 14 99 mov %edx,(%ecx,%ebx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10b535: 89 72 0c mov %esi,0xc(%edx)
&_Semaphore_Information,
&the_semaphore->Object,
(Objects_Name) name
);
*id = the_semaphore->Object.id;
10b538: 89 07 mov %eax,(%edi)
the_semaphore->Object.id,
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
10b53a: e8 71 24 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b53f: 31 c0 xor %eax,%eax
10b541: e9 25 ff ff ff jmp 10b46b <rtems_semaphore_create+0x37>
10b546: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10b548: b8 09 00 00 00 mov $0x9,%eax
10b54d: e9 19 ff ff ff jmp 10b46b <rtems_semaphore_create+0x37>
10b552: 66 90 xchg %ax,%ax
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
/*
* This effectively disables limit checking.
*/
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
10b554: 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;
10b55b: 31 c0 xor %eax,%eax
10b55d: f6 c3 04 test $0x4,%bl
10b560: 0f 95 c0 setne %al
10b563: 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;
10b566: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
10b56d: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
_CORE_semaphore_Initialize(
10b574: 51 push %ecx
10b575: ff 75 0c pushl 0xc(%ebp)
10b578: 8d 45 e0 lea -0x20(%ebp),%eax
10b57b: 50 push %eax
10b57c: 8d 42 14 lea 0x14(%edx),%eax
10b57f: 50 push %eax
10b580: 89 55 c4 mov %edx,-0x3c(%ebp)
10b583: e8 84 0e 00 00 call 10c40c <_CORE_semaphore_Initialize>
10b588: 83 c4 10 add $0x10,%esp
10b58b: 8b 55 c4 mov -0x3c(%ebp),%edx
10b58e: eb 96 jmp 10b526 <rtems_semaphore_create+0xf2>
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
10b590: e8 1b 24 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
10b595: b8 05 00 00 00 mov $0x5,%eax
10b59a: e9 cc fe ff ff jmp 10b46b <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;
10b59f: 8b 45 14 mov 0x14(%ebp),%eax
10b5a2: 89 45 dc mov %eax,-0x24(%ebp)
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
10b5a5: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
the_mutex_attr.only_owner_release = false;
10b5ac: c6 45 d4 00 movb $0x0,-0x2c(%ebp)
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
10b5b0: 83 7d d8 01 cmpl $0x1,-0x28(%ebp)
10b5b4: 0f 85 42 ff ff ff jne 10b4fc <rtems_semaphore_create+0xc8>
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
10b5ba: f6 c3 40 test $0x40,%bl
10b5bd: 74 30 je 10b5ef <rtems_semaphore_create+0x1bb>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
10b5bf: c7 45 d8 02 00 00 00 movl $0x2,-0x28(%ebp)
the_mutex_attr.only_owner_release = true;
10b5c6: c6 45 d4 01 movb $0x1,-0x2c(%ebp)
10b5ca: e9 2d ff ff ff jmp 10b4fc <rtems_semaphore_create+0xc8>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
10b5cf: 83 ec 08 sub $0x8,%esp
10b5d2: 52 push %edx
10b5d3: 68 e0 7c 12 00 push $0x127ce0
10b5d8: e8 1b 17 00 00 call 10ccf8 <_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();
10b5dd: e8 ce 23 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_INVALID_PRIORITY;
10b5e2: 83 c4 10 add $0x10,%esp
10b5e5: b8 13 00 00 00 mov $0x13,%eax
10b5ea: e9 7c fe ff ff jmp 10b46b <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 ) ) {
10b5ef: 81 e3 80 00 00 00 and $0x80,%ebx
10b5f5: 0f 84 01 ff ff ff je 10b4fc <rtems_semaphore_create+0xc8>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
10b5fb: c7 45 d8 03 00 00 00 movl $0x3,-0x28(%ebp)
the_mutex_attr.only_owner_release = true;
10b602: c6 45 d4 01 movb $0x1,-0x2c(%ebp)
10b606: e9 f1 fe ff ff jmp 10b4fc <rtems_semaphore_create+0xc8>
0010b60c <rtems_semaphore_delete>:
#endif
rtems_status_code rtems_semaphore_delete(
rtems_id id
)
{
10b60c: 55 push %ebp
10b60d: 89 e5 mov %esp,%ebp
10b60f: 53 push %ebx
10b610: 83 ec 18 sub $0x18,%esp
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
10b613: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Semaphore_Control *)
_Objects_Get( &_Semaphore_Information, id, location );
10b616: 50 push %eax
10b617: ff 75 08 pushl 0x8(%ebp)
10b61a: 68 e0 7c 12 00 push $0x127ce0
10b61f: e8 14 18 00 00 call 10ce38 <_Objects_Get>
10b624: 89 c3 mov %eax,%ebx
switch ( location ) {
10b626: 83 c4 10 add $0x10,%esp
10b629: 8b 4d f4 mov -0xc(%ebp),%ecx
10b62c: 85 c9 test %ecx,%ecx
10b62e: 74 0c je 10b63c <rtems_semaphore_delete+0x30>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b630: b8 04 00 00 00 mov $0x4,%eax
}
10b635: 8b 5d fc mov -0x4(%ebp),%ebx
10b638: c9 leave
10b639: c3 ret
10b63a: 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);
10b63c: 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) ) {
10b63f: 83 e0 30 and $0x30,%eax
10b642: 74 58 je 10b69c <rtems_semaphore_delete+0x90>
if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) &&
10b644: 8b 53 64 mov 0x64(%ebx),%edx
10b647: 85 d2 test %edx,%edx
10b649: 75 15 jne 10b660 <rtems_semaphore_delete+0x54>
10b64b: 83 f8 20 cmp $0x20,%eax
10b64e: 74 10 je 10b660 <rtems_semaphore_delete+0x54>
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
10b650: e8 5b 23 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
10b655: b8 0c 00 00 00 mov $0xc,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b65a: 8b 5d fc mov -0x4(%ebp),%ebx
10b65d: c9 leave
10b65e: c3 ret
10b65f: 90 nop
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
_CORE_mutex_Flush(
10b660: 50 push %eax
10b661: 6a 04 push $0x4
10b663: 6a 00 push $0x0
10b665: 8d 43 14 lea 0x14(%ebx),%eax
10b668: 50 push %eax
10b669: e8 02 0b 00 00 call 10c170 <_CORE_mutex_Flush>
10b66e: 83 c4 10 add $0x10,%esp
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_WAS_DELETED
);
}
_Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
10b671: 83 ec 08 sub $0x8,%esp
10b674: 53 push %ebx
10b675: 68 e0 7c 12 00 push $0x127ce0
10b67a: e8 81 13 00 00 call 10ca00 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
10b67f: 58 pop %eax
10b680: 5a pop %edx
10b681: 53 push %ebx
10b682: 68 e0 7c 12 00 push $0x127ce0
10b687: e8 6c 16 00 00 call 10ccf8 <_Objects_Free>
0, /* Not used */
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
10b68c: e8 1f 23 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b691: 83 c4 10 add $0x10,%esp
10b694: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b696: 8b 5d fc mov -0x4(%ebp),%ebx
10b699: c9 leave
10b69a: c3 ret
10b69b: 90 nop
&the_semaphore->Core_control.mutex,
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_MUTEX_WAS_DELETED
);
} else {
_CORE_semaphore_Flush(
10b69c: 51 push %ecx
10b69d: 6a 02 push $0x2
10b69f: 6a 00 push $0x0
10b6a1: 8d 43 14 lea 0x14(%ebx),%eax
10b6a4: 50 push %eax
10b6a5: e8 56 0d 00 00 call 10c400 <_CORE_semaphore_Flush>
10b6aa: 83 c4 10 add $0x10,%esp
10b6ad: eb c2 jmp 10b671 <rtems_semaphore_delete+0x65>
0010b6b0 <rtems_semaphore_obtain>:
rtems_status_code rtems_semaphore_obtain(
rtems_id id,
rtems_option option_set,
rtems_interval timeout
)
{
10b6b0: 55 push %ebp
10b6b1: 89 e5 mov %esp,%ebp
10b6b3: 57 push %edi
10b6b4: 56 push %esi
10b6b5: 53 push %ebx
10b6b6: 83 ec 1c sub $0x1c,%esp
10b6b9: 8b 5d 08 mov 0x8(%ebp),%ebx
10b6bc: 8b 75 0c mov 0xc(%ebp),%esi
10b6bf: 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 );
10b6c2: 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 );
10b6c5: 50 push %eax
10b6c6: 8d 45 e4 lea -0x1c(%ebp),%eax
10b6c9: 50 push %eax
10b6ca: 53 push %ebx
10b6cb: 68 e0 7c 12 00 push $0x127ce0
10b6d0: e8 0b 17 00 00 call 10cde0 <_Objects_Get_isr_disable>
switch ( location ) {
10b6d5: 83 c4 10 add $0x10,%esp
10b6d8: 8b 4d e4 mov -0x1c(%ebp),%ecx
10b6db: 85 c9 test %ecx,%ecx
10b6dd: 74 0d je 10b6ec <rtems_semaphore_obtain+0x3c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b6df: b8 04 00 00 00 mov $0x4,%eax
}
10b6e4: 8d 65 f4 lea -0xc(%ebp),%esp
10b6e7: 5b pop %ebx
10b6e8: 5e pop %esi
10b6e9: 5f pop %edi
10b6ea: c9 leave
10b6eb: 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) ) {
10b6ec: f6 40 10 30 testb $0x30,0x10(%eax)
10b6f0: 74 36 je 10b728 <rtems_semaphore_obtain+0x78>
_CORE_mutex_Seize(
10b6f2: 83 ec 0c sub $0xc,%esp
10b6f5: ff 75 e0 pushl -0x20(%ebp)
10b6f8: 57 push %edi
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (
rtems_option option_set
)
{
return (option_set & RTEMS_NO_WAIT) ? true : false;
10b6f9: 83 e6 01 and $0x1,%esi
10b6fc: 83 f6 01 xor $0x1,%esi
10b6ff: 56 push %esi
10b700: 53 push %ebx
10b701: 83 c0 14 add $0x14,%eax
10b704: 50 push %eax
10b705: e8 6a 0b 00 00 call 10c274 <_CORE_mutex_Seize>
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
level
);
return _Semaphore_Translate_core_mutex_return_code(
10b70a: 83 c4 14 add $0x14,%esp
_Thread_Executing->Wait.return_code );
10b70d: a1 38 83 12 00 mov 0x128338,%eax
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
level
);
return _Semaphore_Translate_core_mutex_return_code(
10b712: ff 70 34 pushl 0x34(%eax)
10b715: e8 12 01 00 00 call 10b82c <_Semaphore_Translate_core_mutex_return_code>
10b71a: 83 c4 10 add $0x10,%esp
break;
}
return RTEMS_INVALID_ID;
}
10b71d: 8d 65 f4 lea -0xc(%ebp),%esp
10b720: 5b pop %ebx
10b721: 5e pop %esi
10b722: 5f pop %edi
10b723: c9 leave
10b724: c3 ret
10b725: 8d 76 00 lea 0x0(%esi),%esi
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
10b728: 8b 15 38 83 12 00 mov 0x128338,%edx
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10b72e: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
if ( the_semaphore->count != 0 ) {
10b735: 8b 48 5c mov 0x5c(%eax),%ecx
10b738: 85 c9 test %ecx,%ecx
10b73a: 75 2c jne 10b768 <rtems_semaphore_obtain+0xb8>
the_semaphore->count -= 1;
_ISR_Enable( *level_p );
return;
}
if ( !wait ) {
10b73c: 83 e6 01 and $0x1,%esi
10b73f: 74 33 je 10b774 <rtems_semaphore_obtain+0xc4>
_ISR_Enable( *level_p );
10b741: ff 75 e0 pushl -0x20(%ebp)
10b744: 9d popf
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
10b745: 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(
10b74c: 83 ec 0c sub $0xc,%esp
_Thread_Executing->Wait.return_code );
10b74f: a1 38 83 12 00 mov 0x128338,%eax
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
&level
);
return _Semaphore_Translate_core_semaphore_return_code(
10b754: ff 70 34 pushl 0x34(%eax)
10b757: e8 e0 00 00 00 call 10b83c <_Semaphore_Translate_core_semaphore_return_code>
10b75c: 83 c4 10 add $0x10,%esp
break;
}
return RTEMS_INVALID_ID;
}
10b75f: 8d 65 f4 lea -0xc(%ebp),%esp
10b762: 5b pop %ebx
10b763: 5e pop %esi
10b764: 5f pop %edi
10b765: c9 leave
10b766: c3 ret
10b767: 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;
10b768: 49 dec %ecx
10b769: 89 48 5c mov %ecx,0x5c(%eax)
_ISR_Enable( *level_p );
10b76c: ff 75 e0 pushl -0x20(%ebp)
10b76f: 9d popf
10b770: eb da jmp 10b74c <rtems_semaphore_obtain+0x9c>
10b772: 66 90 xchg %ax,%ax
10b774: 8b 0d 90 7d 12 00 mov 0x127d90,%ecx
10b77a: 41 inc %ecx
10b77b: 89 0d 90 7d 12 00 mov %ecx,0x127d90
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;
10b781: 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;
10b788: 83 c0 14 add $0x14,%eax
10b78b: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
10b78e: 89 5a 20 mov %ebx,0x20(%edx)
_ISR_Enable( *level_p );
10b791: ff 75 e0 pushl -0x20(%ebp)
10b794: 9d popf
_Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
10b795: 52 push %edx
10b796: 68 80 e1 10 00 push $0x10e180
10b79b: 57 push %edi
10b79c: 50 push %eax
10b79d: e8 b2 26 00 00 call 10de54 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10b7a2: e8 09 22 00 00 call 10d9b0 <_Thread_Enable_dispatch>
10b7a7: 83 c4 10 add $0x10,%esp
10b7aa: eb a0 jmp 10b74c <rtems_semaphore_obtain+0x9c>
0010b7ac <rtems_semaphore_release>:
#endif
rtems_status_code rtems_semaphore_release(
rtems_id id
)
{
10b7ac: 55 push %ebp
10b7ad: 89 e5 mov %esp,%ebp
10b7af: 53 push %ebx
10b7b0: 83 ec 18 sub $0x18,%esp
10b7b3: 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 );
10b7b6: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Semaphore_Control *)
_Objects_Get( &_Semaphore_Information, id, location );
10b7b9: 50 push %eax
10b7ba: 53 push %ebx
10b7bb: 68 e0 7c 12 00 push $0x127ce0
10b7c0: e8 73 16 00 00 call 10ce38 <_Objects_Get>
switch ( location ) {
10b7c5: 83 c4 10 add $0x10,%esp
10b7c8: 8b 55 f4 mov -0xc(%ebp),%edx
10b7cb: 85 d2 test %edx,%edx
10b7cd: 74 0d je 10b7dc <rtems_semaphore_release+0x30>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b7cf: b8 04 00 00 00 mov $0x4,%eax
}
10b7d4: 8b 5d fc mov -0x4(%ebp),%ebx
10b7d7: c9 leave
10b7d8: c3 ret
10b7d9: 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) ) {
10b7dc: f6 40 10 30 testb $0x30,0x10(%eax)
10b7e0: 75 26 jne 10b808 <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(
10b7e2: 52 push %edx
10b7e3: 6a 00 push $0x0
10b7e5: 53 push %ebx
10b7e6: 83 c0 14 add $0x14,%eax
10b7e9: 50 push %eax
10b7ea: e8 5d 0c 00 00 call 10c44c <_CORE_semaphore_Surrender>
10b7ef: 89 c3 mov %eax,%ebx
&the_semaphore->Core_control.semaphore,
id,
MUTEX_MP_SUPPORT
);
_Thread_Enable_dispatch();
10b7f1: e8 ba 21 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return
10b7f6: 89 1c 24 mov %ebx,(%esp)
10b7f9: e8 3e 00 00 00 call 10b83c <_Semaphore_Translate_core_semaphore_return_code>
10b7fe: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b801: 8b 5d fc mov -0x4(%ebp),%ebx
10b804: c9 leave
10b805: c3 ret
10b806: 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(
10b808: 51 push %ecx
10b809: 6a 00 push $0x0
10b80b: 53 push %ebx
10b80c: 83 c0 14 add $0x14,%eax
10b80f: 50 push %eax
10b810: e8 ff 0a 00 00 call 10c314 <_CORE_mutex_Surrender>
10b815: 89 c3 mov %eax,%ebx
&the_semaphore->Core_control.mutex,
id,
MUTEX_MP_SUPPORT
);
_Thread_Enable_dispatch();
10b817: e8 94 21 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return _Semaphore_Translate_core_mutex_return_code( mutex_status );
10b81c: 89 1c 24 mov %ebx,(%esp)
10b81f: e8 08 00 00 00 call 10b82c <_Semaphore_Translate_core_mutex_return_code>
10b824: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b827: 8b 5d fc mov -0x4(%ebp),%ebx
10b82a: c9 leave
10b82b: c3 ret
00117d60 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
117d60: 55 push %ebp
117d61: 89 e5 mov %esp,%ebp
117d63: 53 push %ebx
117d64: 83 ec 14 sub $0x14,%esp
117d67: 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 )
117d6a: 85 db test %ebx,%ebx
117d6c: 75 0a jne 117d78 <rtems_signal_send+0x18>
return RTEMS_INVALID_NUMBER;
117d6e: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
117d73: 8b 5d fc mov -0x4(%ebp),%ebx
117d76: c9 leave
117d77: c3 ret
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
117d78: 83 ec 08 sub $0x8,%esp
117d7b: 8d 45 f4 lea -0xc(%ebp),%eax
117d7e: 50 push %eax
117d7f: ff 75 08 pushl 0x8(%ebp)
117d82: e8 f1 40 00 00 call 11be78 <_Thread_Get>
switch ( location ) {
117d87: 83 c4 10 add $0x10,%esp
117d8a: 8b 55 f4 mov -0xc(%ebp),%edx
117d8d: 85 d2 test %edx,%edx
117d8f: 74 0b je 117d9c <rtems_signal_send+0x3c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
117d91: b8 04 00 00 00 mov $0x4,%eax
}
117d96: 8b 5d fc mov -0x4(%ebp),%ebx
117d99: c9 leave
117d9a: c3 ret
117d9b: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
117d9c: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
117da2: 8b 4a 0c mov 0xc(%edx),%ecx
117da5: 85 c9 test %ecx,%ecx
117da7: 74 3f je 117de8 <rtems_signal_send+0x88>
if ( asr->is_enabled ) {
117da9: 80 7a 08 00 cmpb $0x0,0x8(%edx)
117dad: 74 25 je 117dd4 <rtems_signal_send+0x74>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
117daf: 9c pushf
117db0: fa cli
117db1: 59 pop %ecx
*signal_set |= signals;
117db2: 09 5a 14 or %ebx,0x14(%edx)
_ISR_Enable( _level );
117db5: 51 push %ecx
117db6: 9d popf
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
117db7: 8b 15 d4 2f 14 00 mov 0x142fd4,%edx
117dbd: 85 d2 test %edx,%edx
117dbf: 74 1b je 117ddc <rtems_signal_send+0x7c>
117dc1: 3b 05 d8 2f 14 00 cmp 0x142fd8,%eax
117dc7: 75 13 jne 117ddc <rtems_signal_send+0x7c><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
117dc9: c6 05 e4 2f 14 00 01 movb $0x1,0x142fe4
117dd0: eb 0a jmp 117ddc <rtems_signal_send+0x7c>
117dd2: 66 90 xchg %ax,%ax
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
117dd4: 9c pushf
117dd5: fa cli
117dd6: 58 pop %eax
*signal_set |= signals;
117dd7: 09 5a 18 or %ebx,0x18(%edx)
_ISR_Enable( _level );
117dda: 50 push %eax
117ddb: 9d popf
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
117ddc: e8 73 40 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
117de1: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
117de3: 8b 5d fc mov -0x4(%ebp),%ebx
117de6: c9 leave
117de7: c3 ret
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
117de8: e8 67 40 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
117ded: b8 0b 00 00 00 mov $0xb,%eax
117df2: e9 7c ff ff ff jmp 117d73 <rtems_signal_send+0x13>
00107ff0 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
107ff0: 55 push %ebp
107ff1: 89 e5 mov %esp,%ebp
107ff3: 57 push %edi
107ff4: 56 push %esi
107ff5: 8b 45 08 mov 0x8(%ebp),%eax
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
107ff8: 8b 48 08 mov 0x8(%eax),%ecx
107ffb: 85 c9 test %ecx,%ecx
107ffd: 74 15 je 108014 <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;
107fff: 8b b8 bc 00 00 00 mov 0xbc(%eax),%edi
108005: 83 c7 08 add $0x8,%edi
108008: be 20 a9 12 00 mov $0x12a920,%esi
10800d: b9 04 00 00 00 mov $0x4,%ecx
108012: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
108014: 5e pop %esi
108015: 5f pop %edi
108016: c9 leave
108017: c3 ret
00107fc8 <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
107fc8: 55 push %ebp
107fc9: 89 e5 mov %esp,%ebp
107fcb: 57 push %edi
107fcc: 8b 7d 0c mov 0xc(%ebp),%edi
Stack_check_Initialize();
107fcf: e8 88 ff ff ff call 107f5c <Stack_check_Initialize>
if (the_thread)
107fd4: 85 ff test %edi,%edi
107fd6: 74 12 je 107fea <rtems_stack_checker_create_extension+0x22><== NEVER TAKEN
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
107fd8: 8b 8f b8 00 00 00 mov 0xb8(%edi),%ecx
107fde: 8b 97 bc 00 00 00 mov 0xbc(%edi),%edx
107fe4: b0 a5 mov $0xa5,%al
107fe6: 89 d7 mov %edx,%edi
107fe8: f3 aa rep stos %al,%es:(%edi)
return true;
}
107fea: b0 01 mov $0x1,%al
107fec: 5f pop %edi
107fed: c9 leave
107fee: c3 ret
0010812c <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
10812c: 55 push %ebp
10812d: 89 e5 mov %esp,%ebp
10812f: 57 push %edi
108130: 56 push %esi
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
108131: a1 d8 b0 12 00 mov 0x12b0d8,%eax
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
108136: 8b b0 bc 00 00 00 mov 0xbc(%eax),%esi
10813c: 39 f5 cmp %esi,%ebp
10813e: 72 3c jb 10817c <rtems_stack_checker_is_blown+0x50><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
108140: 8b 80 b8 00 00 00 mov 0xb8(%eax),%eax
108146: 8d 04 06 lea (%esi,%eax,1),%eax
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
108149: 39 c5 cmp %eax,%ebp
10814b: 0f 96 c0 setbe %al
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
10814e: 8b 15 c8 a5 12 00 mov 0x12a5c8,%edx
108154: 85 d2 test %edx,%edx
108156: 74 30 je 108188 <rtems_stack_checker_is_blown+0x5c><== NEVER TAKEN
pattern_ok = (!memcmp(
108158: 83 c6 08 add $0x8,%esi
10815b: bf 20 a9 12 00 mov $0x12a920,%edi
108160: b9 10 00 00 00 mov $0x10,%ecx
108165: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
108167: 0f 94 c2 sete %dl
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
10816a: 84 c0 test %al,%al
10816c: 74 1e je 10818c <rtems_stack_checker_is_blown+0x60><== NEVER TAKEN
10816e: 84 d2 test %dl,%dl
108170: 74 1a je 10818c <rtems_stack_checker_is_blown+0x60><== NEVER TAKEN
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
108172: 31 c0 xor %eax,%eax
108174: 8d 65 f8 lea -0x8(%ebp),%esp
108177: 5e pop %esi
108178: 5f pop %edi
108179: c9 leave
10817a: c3 ret
10817b: 90 nop
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
10817c: 31 c0 xor %eax,%eax
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
10817e: 8b 15 c8 a5 12 00 mov 0x12a5c8,%edx <== NOT EXECUTED
108184: 85 d2 test %edx,%edx <== NOT EXECUTED
108186: 75 d0 jne 108158 <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;
108188: b2 01 mov $0x1,%dl <== NOT EXECUTED
10818a: eb de jmp 10816a <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 );
10818c: 57 push %edi <== NOT EXECUTED
10818d: 57 push %edi <== NOT EXECUTED
10818e: 0f b6 d2 movzbl %dl,%edx <== NOT EXECUTED
108191: 52 push %edx <== NOT EXECUTED
108192: ff 35 d8 b0 12 00 pushl 0x12b0d8 <== NOT EXECUTED
108198: e8 7b fe ff ff call 108018 <Stack_check_report_blown_task><== NOT EXECUTED
00108208 <rtems_stack_checker_report_usage>:
void rtems_stack_checker_report_usage( void )
{
108208: 55 push %ebp <== NOT EXECUTED
108209: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10820b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
10820e: 68 1c 9c 10 00 push $0x109c1c <== NOT EXECUTED
108213: 6a 00 push $0x0 <== NOT EXECUTED
108215: e8 86 ff ff ff call 1081a0 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
10821a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
10821d: c9 leave <== NOT EXECUTED
10821e: c3 ret <== NOT EXECUTED
001081a0 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
1081a0: 55 push %ebp <== NOT EXECUTED
1081a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1081a3: 56 push %esi <== NOT EXECUTED
1081a4: 53 push %ebx <== NOT EXECUTED
1081a5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
1081a8: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED
if ( !print )
1081ab: 85 db test %ebx,%ebx <== NOT EXECUTED
1081ad: 74 50 je 1081ff <rtems_stack_checker_report_usage_with_plugin+0x5f><== NOT EXECUTED
return;
print_context = context;
1081af: 89 35 c0 a5 12 00 mov %esi,0x12a5c0 <== NOT EXECUTED
print_handler = print;
1081b5: 89 1d c4 a5 12 00 mov %ebx,0x12a5c4 <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
1081bb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
1081be: 68 28 3e 12 00 push $0x123e28 <== NOT EXECUTED
1081c3: 56 push %esi <== NOT EXECUTED
1081c4: ff d3 call *%ebx <== NOT EXECUTED
(*print)( context,
1081c6: 59 pop %ecx <== NOT EXECUTED
1081c7: 58 pop %eax <== NOT EXECUTED
1081c8: 68 ac 3e 12 00 push $0x123eac <== NOT EXECUTED
1081cd: 56 push %esi <== NOT EXECUTED
1081ce: 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 );
1081d0: c7 04 24 f0 7d 10 00 movl $0x107df0,(%esp) <== NOT EXECUTED
1081d7: e8 ac 70 00 00 call 10f288 <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);
1081dc: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED
1081e3: e8 08 fc ff ff call 107df0 <Stack_check_Dump_threads_usage><== NOT EXECUTED
#endif
print_context = NULL;
1081e8: c7 05 c0 a5 12 00 00 movl $0x0,0x12a5c0 <== NOT EXECUTED
1081ef: 00 00 00
print_handler = NULL;
1081f2: c7 05 c4 a5 12 00 00 movl $0x0,0x12a5c4 <== NOT EXECUTED
1081f9: 00 00 00
1081fc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
1081ff: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
108202: 5b pop %ebx <== NOT EXECUTED
108203: 5e pop %esi <== NOT EXECUTED
108204: c9 leave <== NOT EXECUTED
108205: c3 ret <== NOT EXECUTED
001080d4 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
1080d4: 55 push %ebp
1080d5: 89 e5 mov %esp,%ebp
1080d7: 57 push %edi
1080d8: 56 push %esi
1080d9: 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);
1080dc: 8b 90 bc 00 00 00 mov 0xbc(%eax),%edx
1080e2: 8d 72 08 lea 0x8(%edx),%esi
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
1080e5: 39 d5 cmp %edx,%ebp
1080e7: 72 0a jb 1080f3 <rtems_stack_checker_switch_extension+0x1f><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
1080e9: 03 90 b8 00 00 00 add 0xb8(%eax),%edx
1080ef: 39 d5 cmp %edx,%ebp
1080f1: 76 1d jbe 108110 <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,
1080f3: bf 20 a9 12 00 mov $0x12a920,%edi <== NOT EXECUTED
1080f8: b9 10 00 00 00 mov $0x10,%ecx <== NOT EXECUTED
1080fd: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED
1080ff: 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 );
108102: 56 push %esi <== NOT EXECUTED
108103: 56 push %esi <== NOT EXECUTED
108104: 0f b6 d2 movzbl %dl,%edx <== NOT EXECUTED
108107: 52 push %edx <== NOT EXECUTED
108108: 50 push %eax <== NOT EXECUTED
108109: e8 0a ff ff ff call 108018 <Stack_check_report_blown_task><== NOT EXECUTED
10810e: 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,
108110: bf 20 a9 12 00 mov $0x12a920,%edi
108115: b9 10 00 00 00 mov $0x10,%ecx
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
10811a: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10811c: 75 07 jne 108125 <rtems_stack_checker_switch_extension+0x51><== NEVER TAKEN
Stack_check_report_blown_task( running, pattern_ok );
}
}
10811e: 8d 65 f8 lea -0x8(%ebp),%esp
108121: 5e pop %esi
108122: 5f pop %edi
108123: c9 leave
108124: 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 ) {
108125: 31 d2 xor %edx,%edx <== NOT EXECUTED
108127: eb d9 jmp 108102 <rtems_stack_checker_switch_extension+0x2e><== NOT EXECUTED
00110b60 <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
110b60: 55 push %ebp
110b61: 89 e5 mov %esp,%ebp
110b63: 57 push %edi
110b64: 56 push %esi
110b65: 53 push %ebx
110b66: 83 ec 2c sub $0x2c,%esp
110b69: 8b 75 08 mov 0x8(%ebp),%esi
110b6c: 8b 5d 0c mov 0xc(%ebp),%ebx
110b6f: 8b 7d 10 mov 0x10(%ebp),%edi
double result;
char *end;
if ( !n )
110b72: 85 db test %ebx,%ebx
110b74: 0f 84 b2 00 00 00 je 110c2c <rtems_string_to_double+0xcc>
return RTEMS_INVALID_ADDRESS;
errno = 0;
110b7a: e8 15 2f 00 00 call 113a94 <__errno>
110b7f: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
110b85: c7 03 00 00 00 00 movl $0x0,(%ebx)
110b8b: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
result = strtod( s, &end );
110b92: 83 ec 08 sub $0x8,%esp
110b95: 8d 45 e4 lea -0x1c(%ebp),%eax
110b98: 50 push %eax
110b99: 56 push %esi
110b9a: e8 f9 58 00 00 call 116498 <strtod>
if ( endptr )
110b9f: 83 c4 10 add $0x10,%esp
110ba2: 85 ff test %edi,%edi
110ba4: 0f 84 92 00 00 00 je 110c3c <rtems_string_to_double+0xdc>
*endptr = end;
110baa: 8b 45 e4 mov -0x1c(%ebp),%eax
110bad: 89 07 mov %eax,(%edi)
if ( end == s )
110baf: 39 c6 cmp %eax,%esi
110bb1: 74 69 je 110c1c <rtems_string_to_double+0xbc>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
110bb3: dd 5d c8 fstpl -0x38(%ebp)
110bb6: e8 d9 2e 00 00 call 113a94 <__errno>
110bbb: 83 38 22 cmpl $0x22,(%eax)
110bbe: dd 45 c8 fldl -0x38(%ebp)
110bc1: 74 0d je 110bd0 <rtems_string_to_double+0x70>
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
*n = result;
110bc3: dd 1b fstpl (%ebx)
return RTEMS_SUCCESSFUL;
110bc5: 31 c0 xor %eax,%eax
}
110bc7: 8d 65 f4 lea -0xc(%ebp),%esp
110bca: 5b pop %ebx
110bcb: 5e pop %esi
110bcc: 5f pop %edi
110bcd: c9 leave
110bce: c3 ret
110bcf: 90 nop
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
110bd0: d9 ee fldz
110bd2: d9 c9 fxch %st(1)
110bd4: dd e1 fucom %st(1)
110bd6: df e0 fnstsw %ax
110bd8: dd d9 fstp %st(1)
110bda: 80 e4 45 and $0x45,%ah
110bdd: 80 fc 40 cmp $0x40,%ah
110be0: 74 26 je 110c08 <rtems_string_to_double+0xa8><== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
110be2: dd 05 90 61 12 00 fldl 0x126190
110be8: d9 c9 fxch %st(1)
110bea: dd e1 fucom %st(1)
110bec: df e0 fnstsw %ax
110bee: dd d9 fstp %st(1)
110bf0: f6 c4 45 test $0x45,%ah
110bf3: 74 17 je 110c0c <rtems_string_to_double+0xac><== ALWAYS TAKEN
110bf5: dd 05 98 61 12 00 fldl 0x126198 <== NOT EXECUTED
110bfb: dd e9 fucomp %st(1) <== NOT EXECUTED
110bfd: df e0 fnstsw %ax <== NOT EXECUTED
110bff: f6 c4 45 test $0x45,%ah <== NOT EXECUTED
110c02: 75 bf jne 110bc3 <rtems_string_to_double+0x63><== NOT EXECUTED
110c04: dd d8 fstp %st(0) <== NOT EXECUTED
110c06: eb 06 jmp 110c0e <rtems_string_to_double+0xae><== NOT EXECUTED
110c08: dd d8 fstp %st(0) <== NOT EXECUTED
110c0a: eb 02 jmp 110c0e <rtems_string_to_double+0xae><== NOT EXECUTED
110c0c: dd d8 fstp %st(0)
return RTEMS_INVALID_NUMBER;
110c0e: b8 0a 00 00 00 mov $0xa,%eax
*n = result;
return RTEMS_SUCCESSFUL;
}
110c13: 8d 65 f4 lea -0xc(%ebp),%esp
110c16: 5b pop %ebx
110c17: 5e pop %esi
110c18: 5f pop %edi
110c19: c9 leave
110c1a: c3 ret
110c1b: 90 nop
110c1c: dd d8 fstp %st(0)
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
110c1e: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
110c23: 8d 65 f4 lea -0xc(%ebp),%esp
110c26: 5b pop %ebx
110c27: 5e pop %esi
110c28: 5f pop %edi
110c29: c9 leave
110c2a: c3 ret
110c2b: 90 nop
{
double result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
110c2c: b8 09 00 00 00 mov $0x9,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
110c31: 8d 65 f4 lea -0xc(%ebp),%esp
110c34: 5b pop %ebx
110c35: 5e pop %esi
110c36: 5f pop %edi
110c37: c9 leave
110c38: c3 ret
110c39: 8d 76 00 lea 0x0(%esi),%esi
errno = 0;
*n = 0;
result = strtod( s, &end );
if ( endptr )
110c3c: 8b 45 e4 mov -0x1c(%ebp),%eax
110c3f: e9 6b ff ff ff jmp 110baf <rtems_string_to_double+0x4f>
00110c44 <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
110c44: 55 push %ebp
110c45: 89 e5 mov %esp,%ebp
110c47: 57 push %edi
110c48: 56 push %esi
110c49: 53 push %ebx
110c4a: 83 ec 2c sub $0x2c,%esp
110c4d: 8b 75 08 mov 0x8(%ebp),%esi
110c50: 8b 5d 0c mov 0xc(%ebp),%ebx
110c53: 8b 7d 10 mov 0x10(%ebp),%edi
float result;
char *end;
if ( !n )
110c56: 85 db test %ebx,%ebx
110c58: 0f 84 aa 00 00 00 je 110d08 <rtems_string_to_float+0xc4>
return RTEMS_INVALID_ADDRESS;
errno = 0;
110c5e: e8 31 2e 00 00 call 113a94 <__errno>
110c63: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
110c69: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtof( s, &end );
110c6f: 83 ec 08 sub $0x8,%esp
110c72: 8d 45 e4 lea -0x1c(%ebp),%eax
110c75: 50 push %eax
110c76: 56 push %esi
110c77: e8 38 58 00 00 call 1164b4 <strtof>
if ( endptr )
110c7c: 83 c4 10 add $0x10,%esp
110c7f: 85 ff test %edi,%edi
110c81: 0f 84 91 00 00 00 je 110d18 <rtems_string_to_float+0xd4>
*endptr = end;
110c87: 8b 45 e4 mov -0x1c(%ebp),%eax
110c8a: 89 07 mov %eax,(%edi)
if ( end == s )
110c8c: 39 c6 cmp %eax,%esi
110c8e: 74 68 je 110cf8 <rtems_string_to_float+0xb4>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
110c90: d9 5d c8 fstps -0x38(%ebp)
110c93: e8 fc 2d 00 00 call 113a94 <__errno>
110c98: 83 38 22 cmpl $0x22,(%eax)
110c9b: d9 45 c8 flds -0x38(%ebp)
110c9e: 74 0c je 110cac <rtems_string_to_float+0x68>
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
*n = result;
110ca0: d9 1b fstps (%ebx)
return RTEMS_SUCCESSFUL;
110ca2: 31 c0 xor %eax,%eax
}
110ca4: 8d 65 f4 lea -0xc(%ebp),%esp
110ca7: 5b pop %ebx
110ca8: 5e pop %esi
110ca9: 5f pop %edi
110caa: c9 leave
110cab: c3 ret
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
110cac: d9 ee fldz
110cae: d9 c9 fxch %st(1)
110cb0: dd e1 fucom %st(1)
110cb2: df e0 fnstsw %ax
110cb4: dd d9 fstp %st(1)
110cb6: 80 e4 45 and $0x45,%ah
110cb9: 80 fc 40 cmp $0x40,%ah
110cbc: 74 26 je 110ce4 <rtems_string_to_float+0xa0><== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
110cbe: d9 05 a0 61 12 00 flds 0x1261a0
110cc4: d9 c9 fxch %st(1)
110cc6: dd e1 fucom %st(1)
110cc8: df e0 fnstsw %ax
110cca: dd d9 fstp %st(1)
110ccc: f6 c4 45 test $0x45,%ah
110ccf: 74 17 je 110ce8 <rtems_string_to_float+0xa4><== ALWAYS TAKEN
110cd1: d9 05 a4 61 12 00 flds 0x1261a4 <== NOT EXECUTED
110cd7: dd e9 fucomp %st(1) <== NOT EXECUTED
110cd9: df e0 fnstsw %ax <== NOT EXECUTED
110cdb: f6 c4 45 test $0x45,%ah <== NOT EXECUTED
110cde: 75 c0 jne 110ca0 <rtems_string_to_float+0x5c><== NOT EXECUTED
110ce0: dd d8 fstp %st(0) <== NOT EXECUTED
110ce2: eb 06 jmp 110cea <rtems_string_to_float+0xa6><== NOT EXECUTED
110ce4: dd d8 fstp %st(0) <== NOT EXECUTED
110ce6: eb 02 jmp 110cea <rtems_string_to_float+0xa6><== NOT EXECUTED
110ce8: dd d8 fstp %st(0)
return RTEMS_INVALID_NUMBER;
110cea: b8 0a 00 00 00 mov $0xa,%eax
*n = result;
return RTEMS_SUCCESSFUL;
}
110cef: 8d 65 f4 lea -0xc(%ebp),%esp
110cf2: 5b pop %ebx
110cf3: 5e pop %esi
110cf4: 5f pop %edi
110cf5: c9 leave
110cf6: c3 ret
110cf7: 90 nop
110cf8: dd d8 fstp %st(0)
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
110cfa: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
110cff: 8d 65 f4 lea -0xc(%ebp),%esp
110d02: 5b pop %ebx
110d03: 5e pop %esi
110d04: 5f pop %edi
110d05: c9 leave
110d06: c3 ret
110d07: 90 nop
{
float result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
110d08: b8 09 00 00 00 mov $0x9,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
110d0d: 8d 65 f4 lea -0xc(%ebp),%esp
110d10: 5b pop %ebx
110d11: 5e pop %esi
110d12: 5f pop %edi
110d13: c9 leave
110d14: c3 ret
110d15: 8d 76 00 lea 0x0(%esi),%esi
errno = 0;
*n = 0;
result = strtof( s, &end );
if ( endptr )
110d18: 8b 45 e4 mov -0x1c(%ebp),%eax
110d1b: e9 6c ff ff ff jmp 110c8c <rtems_string_to_float+0x48>
00110d20 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
110d20: 55 push %ebp
110d21: 89 e5 mov %esp,%ebp
110d23: 57 push %edi
110d24: 56 push %esi
110d25: 53 push %ebx
110d26: 83 ec 2c sub $0x2c,%esp
110d29: 8b 75 08 mov 0x8(%ebp),%esi
110d2c: 8b 5d 0c mov 0xc(%ebp),%ebx
110d2f: 8b 7d 10 mov 0x10(%ebp),%edi
long result;
char *end;
if ( !n )
110d32: 85 db test %ebx,%ebx
110d34: 0f 84 82 00 00 00 je 110dbc <rtems_string_to_int+0x9c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
110d3a: e8 55 2d 00 00 call 113a94 <__errno>
110d3f: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
110d45: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtol( s, &end, base );
110d4b: 50 push %eax
110d4c: ff 75 14 pushl 0x14(%ebp)
110d4f: 8d 45 e4 lea -0x1c(%ebp),%eax
110d52: 50 push %eax
110d53: 56 push %esi
110d54: e8 1b 59 00 00 call 116674 <strtol>
110d59: 89 c2 mov %eax,%edx
if ( endptr )
110d5b: 83 c4 10 add $0x10,%esp
110d5e: 85 ff test %edi,%edi
110d60: 74 6a je 110dcc <rtems_string_to_int+0xac>
*endptr = end;
110d62: 8b 45 e4 mov -0x1c(%ebp),%eax
110d65: 89 07 mov %eax,(%edi)
if ( end == s )
110d67: 39 c6 cmp %eax,%esi
110d69: 74 41 je 110dac <rtems_string_to_int+0x8c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
110d6b: 89 55 d4 mov %edx,-0x2c(%ebp)
110d6e: e8 21 2d 00 00 call 113a94 <__errno>
110d73: 83 38 22 cmpl $0x22,(%eax)
110d76: 8b 55 d4 mov -0x2c(%ebp),%edx
110d79: 74 0d je 110d88 <rtems_string_to_int+0x68>
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
110d7b: 89 13 mov %edx,(%ebx)
return RTEMS_SUCCESSFUL;
110d7d: 31 c0 xor %eax,%eax
}
110d7f: 8d 65 f4 lea -0xc(%ebp),%esp
110d82: 5b pop %ebx
110d83: 5e pop %esi
110d84: 5f pop %edi
110d85: c9 leave
110d86: c3 ret
110d87: 90 nop
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
110d88: 85 d2 test %edx,%edx
110d8a: 74 10 je 110d9c <rtems_string_to_int+0x7c><== NEVER TAKEN
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
110d8c: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx
110d92: 74 08 je 110d9c <rtems_string_to_int+0x7c><== ALWAYS TAKEN
110d94: 81 fa 00 00 00 80 cmp $0x80000000,%edx <== NOT EXECUTED
110d9a: 75 df jne 110d7b <rtems_string_to_int+0x5b><== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
110d9c: b8 0a 00 00 00 mov $0xa,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
110da1: 8d 65 f4 lea -0xc(%ebp),%esp
110da4: 5b pop %ebx
110da5: 5e pop %esi
110da6: 5f pop %edi
110da7: c9 leave
110da8: c3 ret
110da9: 8d 76 00 lea 0x0(%esi),%esi
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
110dac: b8 0b 00 00 00 mov $0xb,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
110db1: 8d 65 f4 lea -0xc(%ebp),%esp
110db4: 5b pop %ebx
110db5: 5e pop %esi
110db6: 5f pop %edi
110db7: c9 leave
110db8: c3 ret
110db9: 8d 76 00 lea 0x0(%esi),%esi
{
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
110dbc: b8 09 00 00 00 mov $0x9,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
110dc1: 8d 65 f4 lea -0xc(%ebp),%esp
110dc4: 5b pop %ebx
110dc5: 5e pop %esi
110dc6: 5f pop %edi
110dc7: c9 leave
110dc8: c3 ret
110dc9: 8d 76 00 lea 0x0(%esi),%esi
errno = 0;
*n = 0;
result = strtol( s, &end, base );
if ( endptr )
110dcc: 8b 45 e4 mov -0x1c(%ebp),%eax
110dcf: eb 96 jmp 110d67 <rtems_string_to_int+0x47>
00110ea0 <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
110ea0: 55 push %ebp
110ea1: 89 e5 mov %esp,%ebp
110ea3: 57 push %edi
110ea4: 56 push %esi
110ea5: 53 push %ebx
110ea6: 83 ec 2c sub $0x2c,%esp
110ea9: 8b 75 08 mov 0x8(%ebp),%esi
110eac: 8b 5d 0c mov 0xc(%ebp),%ebx
110eaf: 8b 7d 10 mov 0x10(%ebp),%edi
long result;
char *end;
if ( !n )
110eb2: 85 db test %ebx,%ebx
110eb4: 0f 84 82 00 00 00 je 110f3c <rtems_string_to_long+0x9c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
110eba: e8 d5 2b 00 00 call 113a94 <__errno>
110ebf: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
110ec5: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtol( s, &end, base );
110ecb: 50 push %eax
110ecc: ff 75 14 pushl 0x14(%ebp)
110ecf: 8d 45 e4 lea -0x1c(%ebp),%eax
110ed2: 50 push %eax
110ed3: 56 push %esi
110ed4: e8 9b 57 00 00 call 116674 <strtol>
110ed9: 89 c2 mov %eax,%edx
if ( endptr )
110edb: 83 c4 10 add $0x10,%esp
110ede: 85 ff test %edi,%edi
110ee0: 74 6a je 110f4c <rtems_string_to_long+0xac>
*endptr = end;
110ee2: 8b 45 e4 mov -0x1c(%ebp),%eax
110ee5: 89 07 mov %eax,(%edi)
if ( end == s )
110ee7: 39 c6 cmp %eax,%esi
110ee9: 74 41 je 110f2c <rtems_string_to_long+0x8c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
110eeb: 89 55 d4 mov %edx,-0x2c(%ebp)
110eee: e8 a1 2b 00 00 call 113a94 <__errno>
110ef3: 83 38 22 cmpl $0x22,(%eax)
110ef6: 8b 55 d4 mov -0x2c(%ebp),%edx
110ef9: 74 0d je 110f08 <rtems_string_to_long+0x68>
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
110efb: 89 13 mov %edx,(%ebx)
return RTEMS_SUCCESSFUL;
110efd: 31 c0 xor %eax,%eax
}
110eff: 8d 65 f4 lea -0xc(%ebp),%esp
110f02: 5b pop %ebx
110f03: 5e pop %esi
110f04: 5f pop %edi
110f05: c9 leave
110f06: c3 ret
110f07: 90 nop
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
110f08: 85 d2 test %edx,%edx
110f0a: 74 10 je 110f1c <rtems_string_to_long+0x7c><== NEVER TAKEN
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
110f0c: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx
110f12: 74 08 je 110f1c <rtems_string_to_long+0x7c>
110f14: 81 fa 00 00 00 80 cmp $0x80000000,%edx
110f1a: 75 df jne 110efb <rtems_string_to_long+0x5b><== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
110f1c: b8 0a 00 00 00 mov $0xa,%eax
*n = result;
return RTEMS_SUCCESSFUL;
}
110f21: 8d 65 f4 lea -0xc(%ebp),%esp
110f24: 5b pop %ebx
110f25: 5e pop %esi
110f26: 5f pop %edi
110f27: c9 leave
110f28: c3 ret
110f29: 8d 76 00 lea 0x0(%esi),%esi
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
110f2c: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
110f31: 8d 65 f4 lea -0xc(%ebp),%esp
110f34: 5b pop %ebx
110f35: 5e pop %esi
110f36: 5f pop %edi
110f37: c9 leave
110f38: c3 ret
110f39: 8d 76 00 lea 0x0(%esi),%esi
{
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
110f3c: b8 09 00 00 00 mov $0x9,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
110f41: 8d 65 f4 lea -0xc(%ebp),%esp
110f44: 5b pop %ebx
110f45: 5e pop %esi
110f46: 5f pop %edi
110f47: c9 leave
110f48: c3 ret
110f49: 8d 76 00 lea 0x0(%esi),%esi
errno = 0;
*n = 0;
result = strtol( s, &end, base );
if ( endptr )
110f4c: 8b 45 e4 mov -0x1c(%ebp),%eax
110f4f: eb 96 jmp 110ee7 <rtems_string_to_long+0x47>
00110dd4 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
110dd4: 55 push %ebp
110dd5: 89 e5 mov %esp,%ebp
110dd7: 57 push %edi
110dd8: 56 push %esi
110dd9: 53 push %ebx
110dda: 83 ec 2c sub $0x2c,%esp
110ddd: 8b 5d 0c mov 0xc(%ebp),%ebx
110de0: 8b 7d 10 mov 0x10(%ebp),%edi
long long result;
char *end;
if ( !n )
110de3: 85 db test %ebx,%ebx
110de5: 0f 84 9d 00 00 00 je 110e88 <rtems_string_to_long_long+0xb4>
return RTEMS_INVALID_ADDRESS;
errno = 0;
110deb: e8 a4 2c 00 00 call 113a94 <__errno>
110df0: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
110df6: c7 03 00 00 00 00 movl $0x0,(%ebx)
110dfc: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
result = strtoll( s, &end, base );
110e03: 50 push %eax
110e04: ff 75 14 pushl 0x14(%ebp)
110e07: 8d 45 e4 lea -0x1c(%ebp),%eax
110e0a: 50 push %eax
110e0b: ff 75 08 pushl 0x8(%ebp)
110e0e: e8 7d 58 00 00 call 116690 <strtoll>
110e13: 89 c6 mov %eax,%esi
if ( endptr )
110e15: 83 c4 10 add $0x10,%esp
110e18: 85 ff test %edi,%edi
110e1a: 74 7c je 110e98 <rtems_string_to_long_long+0xc4>
*endptr = end;
110e1c: 8b 45 e4 mov -0x1c(%ebp),%eax
110e1f: 89 07 mov %eax,(%edi)
if ( end == s )
110e21: 39 45 08 cmp %eax,0x8(%ebp)
110e24: 74 52 je 110e78 <rtems_string_to_long_long+0xa4>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
110e26: 89 55 d4 mov %edx,-0x2c(%ebp)
110e29: e8 66 2c 00 00 call 113a94 <__errno>
110e2e: 83 38 22 cmpl $0x22,(%eax)
110e31: 8b 55 d4 mov -0x2c(%ebp),%edx
110e34: 74 12 je 110e48 <rtems_string_to_long_long+0x74>
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
*n = result;
110e36: 89 33 mov %esi,(%ebx)
110e38: 89 53 04 mov %edx,0x4(%ebx)
return RTEMS_SUCCESSFUL;
110e3b: 31 c0 xor %eax,%eax
}
110e3d: 8d 65 f4 lea -0xc(%ebp),%esp
110e40: 5b pop %ebx
110e41: 5e pop %esi
110e42: 5f pop %edi
110e43: c9 leave
110e44: c3 ret
110e45: 8d 76 00 lea 0x0(%esi),%esi
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
110e48: 89 d0 mov %edx,%eax
110e4a: 09 f0 or %esi,%eax
110e4c: 74 1a je 110e68 <rtems_string_to_long_long+0x94><== NEVER TAKEN
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
110e4e: 89 d1 mov %edx,%ecx
110e50: 81 f1 ff ff ff 7f xor $0x7fffffff,%ecx
110e56: 89 f0 mov %esi,%eax
110e58: f7 d0 not %eax
110e5a: 09 c1 or %eax,%ecx
110e5c: 74 0a je 110e68 <rtems_string_to_long_long+0x94>
110e5e: 8d 82 00 00 00 80 lea -0x80000000(%edx),%eax
110e64: 09 f0 or %esi,%eax
110e66: 75 ce jne 110e36 <rtems_string_to_long_long+0x62><== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
110e68: b8 0a 00 00 00 mov $0xa,%eax
*n = result;
return RTEMS_SUCCESSFUL;
}
110e6d: 8d 65 f4 lea -0xc(%ebp),%esp
110e70: 5b pop %ebx
110e71: 5e pop %esi
110e72: 5f pop %edi
110e73: c9 leave
110e74: c3 ret
110e75: 8d 76 00 lea 0x0(%esi),%esi
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
110e78: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
110e7d: 8d 65 f4 lea -0xc(%ebp),%esp
110e80: 5b pop %ebx
110e81: 5e pop %esi
110e82: 5f pop %edi
110e83: c9 leave
110e84: c3 ret
110e85: 8d 76 00 lea 0x0(%esi),%esi
{
long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
110e88: b8 09 00 00 00 mov $0x9,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
110e8d: 8d 65 f4 lea -0xc(%ebp),%esp
110e90: 5b pop %ebx
110e91: 5e pop %esi
110e92: 5f pop %edi
110e93: c9 leave
110e94: c3 ret
110e95: 8d 76 00 lea 0x0(%esi),%esi
errno = 0;
*n = 0;
result = strtoll( s, &end, base );
if ( endptr )
110e98: 8b 45 e4 mov -0x1c(%ebp),%eax
110e9b: eb 84 jmp 110e21 <rtems_string_to_long_long+0x4d>
00110f6c <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
110f6c: 55 push %ebp
110f6d: 89 e5 mov %esp,%ebp
110f6f: 57 push %edi
110f70: 56 push %esi
110f71: 53 push %ebx
110f72: 83 ec 2c sub $0x2c,%esp
110f75: 8b 75 08 mov 0x8(%ebp),%esi
110f78: 8b 5d 0c mov 0xc(%ebp),%ebx
110f7b: 8b 7d 10 mov 0x10(%ebp),%edi
unsigned long result;
char *end;
if ( !n )
110f7e: 85 db test %ebx,%ebx
110f80: 0f 84 92 00 00 00 je 111018 <rtems_string_to_unsigned_char+0xac><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
errno = 0;
110f86: e8 09 2b 00 00 call 113a94 <__errno>
110f8b: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
110f91: c6 03 00 movb $0x0,(%ebx)
result = strtoul( s, &end, base );
110f94: 50 push %eax
110f95: ff 75 14 pushl 0x14(%ebp)
110f98: 8d 45 e4 lea -0x1c(%ebp),%eax
110f9b: 50 push %eax
110f9c: 56 push %esi
110f9d: e8 8e 5b 00 00 call 116b30 <strtoul>
110fa2: 89 c2 mov %eax,%edx
if ( endptr )
110fa4: 83 c4 10 add $0x10,%esp
110fa7: 85 ff test %edi,%edi
110fa9: 74 7d je 111028 <rtems_string_to_unsigned_char+0xbc><== NEVER TAKEN
*endptr = end;
110fab: 8b 45 e4 mov -0x1c(%ebp),%eax
110fae: 89 07 mov %eax,(%edi)
if ( end == s )
110fb0: 39 c6 cmp %eax,%esi
110fb2: 74 54 je 111008 <rtems_string_to_unsigned_char+0x9c><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
110fb4: 89 55 d4 mov %edx,-0x2c(%ebp)
110fb7: e8 d8 2a 00 00 call 113a94 <__errno>
110fbc: 83 38 22 cmpl $0x22,(%eax)
110fbf: 8b 55 d4 mov -0x2c(%ebp),%edx
110fc2: 74 14 je 110fd8 <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 ) {
110fc4: 81 fa ff 00 00 00 cmp $0xff,%edx
110fca: 77 24 ja 110ff0 <rtems_string_to_unsigned_char+0x84><== NEVER TAKEN
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
110fcc: 88 13 mov %dl,(%ebx)
return RTEMS_SUCCESSFUL;
110fce: 31 c0 xor %eax,%eax
}
110fd0: 8d 65 f4 lea -0xc(%ebp),%esp
110fd3: 5b pop %ebx
110fd4: 5e pop %esi
110fd5: 5f pop %edi
110fd6: c9 leave
110fd7: c3 ret
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
110fd8: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
110fdb: 83 f8 fd cmp $0xfffffffd,%eax <== NOT EXECUTED
110fde: 76 e4 jbe 110fc4 <rtems_string_to_unsigned_char+0x58><== NOT EXECUTED
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
110fe0: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
110fe5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
110fe8: 5b pop %ebx <== NOT EXECUTED
110fe9: 5e pop %esi <== NOT EXECUTED
110fea: 5f pop %edi <== NOT EXECUTED
110feb: c9 leave <== NOT EXECUTED
110fec: c3 ret <== NOT EXECUTED
110fed: 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;
110ff0: e8 9f 2a 00 00 call 113a94 <__errno> <== NOT EXECUTED
110ff5: c7 00 22 00 00 00 movl $0x22,(%eax) <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
110ffb: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
111000: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
111003: 5b pop %ebx <== NOT EXECUTED
111004: 5e pop %esi <== NOT EXECUTED
111005: 5f pop %edi <== NOT EXECUTED
111006: c9 leave <== NOT EXECUTED
111007: c3 ret <== NOT EXECUTED
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
111008: b8 0b 00 00 00 mov $0xb,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
11100d: 8d 65 f4 lea -0xc(%ebp),%esp
111010: 5b pop %ebx
111011: 5e pop %esi
111012: 5f pop %edi
111013: c9 leave
111014: c3 ret
111015: 8d 76 00 lea 0x0(%esi),%esi
{
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
111018: b8 09 00 00 00 mov $0x9,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
11101d: 8d 65 f4 lea -0xc(%ebp),%esp
111020: 5b pop %ebx
111021: 5e pop %esi
111022: 5f pop %edi
111023: c9 leave
111024: c3 ret
111025: 8d 76 00 lea 0x0(%esi),%esi
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
111028: 8b 45 e4 mov -0x1c(%ebp),%eax
11102b: eb 83 jmp 110fb0 <rtems_string_to_unsigned_char+0x44>
00111030 <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
111030: 55 push %ebp
111031: 89 e5 mov %esp,%ebp
111033: 57 push %edi
111034: 56 push %esi
111035: 53 push %ebx
111036: 83 ec 2c sub $0x2c,%esp
111039: 8b 75 08 mov 0x8(%ebp),%esi
11103c: 8b 5d 0c mov 0xc(%ebp),%ebx
11103f: 8b 7d 10 mov 0x10(%ebp),%edi
unsigned long result;
char *end;
if ( !n )
111042: 85 db test %ebx,%ebx
111044: 74 76 je 1110bc <rtems_string_to_unsigned_int+0x8c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
111046: e8 49 2a 00 00 call 113a94 <__errno>
11104b: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
111051: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtoul( s, &end, base );
111057: 50 push %eax
111058: ff 75 14 pushl 0x14(%ebp)
11105b: 8d 45 e4 lea -0x1c(%ebp),%eax
11105e: 50 push %eax
11105f: 56 push %esi
111060: e8 cb 5a 00 00 call 116b30 <strtoul>
111065: 89 c2 mov %eax,%edx
if ( endptr )
111067: 83 c4 10 add $0x10,%esp
11106a: 85 ff test %edi,%edi
11106c: 74 5e je 1110cc <rtems_string_to_unsigned_int+0x9c>
*endptr = end;
11106e: 8b 45 e4 mov -0x1c(%ebp),%eax
111071: 89 07 mov %eax,(%edi)
if ( end == s )
111073: 39 c6 cmp %eax,%esi
111075: 74 35 je 1110ac <rtems_string_to_unsigned_int+0x7c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
111077: 89 55 d4 mov %edx,-0x2c(%ebp)
11107a: e8 15 2a 00 00 call 113a94 <__errno>
11107f: 83 38 22 cmpl $0x22,(%eax)
111082: 8b 55 d4 mov -0x2c(%ebp),%edx
111085: 74 0d je 111094 <rtems_string_to_unsigned_int+0x64>
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
111087: 89 13 mov %edx,(%ebx)
return RTEMS_SUCCESSFUL;
111089: 31 c0 xor %eax,%eax
}
11108b: 8d 65 f4 lea -0xc(%ebp),%esp
11108e: 5b pop %ebx
11108f: 5e pop %esi
111090: 5f pop %edi
111091: c9 leave
111092: c3 ret
111093: 90 nop
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
111094: 8d 42 ff lea -0x1(%edx),%eax
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
111097: 83 f8 fd cmp $0xfffffffd,%eax
11109a: 76 eb jbe 111087 <rtems_string_to_unsigned_int+0x57><== NEVER TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
11109c: b8 0a 00 00 00 mov $0xa,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
1110a1: 8d 65 f4 lea -0xc(%ebp),%esp
1110a4: 5b pop %ebx
1110a5: 5e pop %esi
1110a6: 5f pop %edi
1110a7: c9 leave
1110a8: c3 ret
1110a9: 8d 76 00 lea 0x0(%esi),%esi
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
1110ac: b8 0b 00 00 00 mov $0xb,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
1110b1: 8d 65 f4 lea -0xc(%ebp),%esp
1110b4: 5b pop %ebx
1110b5: 5e pop %esi
1110b6: 5f pop %edi
1110b7: c9 leave
1110b8: c3 ret
1110b9: 8d 76 00 lea 0x0(%esi),%esi
{
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
1110bc: b8 09 00 00 00 mov $0x9,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
1110c1: 8d 65 f4 lea -0xc(%ebp),%esp
1110c4: 5b pop %ebx
1110c5: 5e pop %esi
1110c6: 5f pop %edi
1110c7: c9 leave
1110c8: c3 ret
1110c9: 8d 76 00 lea 0x0(%esi),%esi
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
1110cc: 8b 45 e4 mov -0x1c(%ebp),%eax
1110cf: eb a2 jmp 111073 <rtems_string_to_unsigned_int+0x43>
0011119c <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
11119c: 55 push %ebp
11119d: 89 e5 mov %esp,%ebp
11119f: 57 push %edi
1111a0: 56 push %esi
1111a1: 53 push %ebx
1111a2: 83 ec 2c sub $0x2c,%esp
1111a5: 8b 75 08 mov 0x8(%ebp),%esi
1111a8: 8b 5d 0c mov 0xc(%ebp),%ebx
1111ab: 8b 7d 10 mov 0x10(%ebp),%edi
unsigned long result;
char *end;
if ( !n )
1111ae: 85 db test %ebx,%ebx
1111b0: 74 76 je 111228 <rtems_string_to_unsigned_long+0x8c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
1111b2: e8 dd 28 00 00 call 113a94 <__errno>
1111b7: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
1111bd: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtoul( s, &end, base );
1111c3: 50 push %eax
1111c4: ff 75 14 pushl 0x14(%ebp)
1111c7: 8d 45 e4 lea -0x1c(%ebp),%eax
1111ca: 50 push %eax
1111cb: 56 push %esi
1111cc: e8 5f 59 00 00 call 116b30 <strtoul>
1111d1: 89 c2 mov %eax,%edx
if ( endptr )
1111d3: 83 c4 10 add $0x10,%esp
1111d6: 85 ff test %edi,%edi
1111d8: 74 5e je 111238 <rtems_string_to_unsigned_long+0x9c>
*endptr = end;
1111da: 8b 45 e4 mov -0x1c(%ebp),%eax
1111dd: 89 07 mov %eax,(%edi)
if ( end == s )
1111df: 39 c6 cmp %eax,%esi
1111e1: 74 35 je 111218 <rtems_string_to_unsigned_long+0x7c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1111e3: 89 55 d4 mov %edx,-0x2c(%ebp)
1111e6: e8 a9 28 00 00 call 113a94 <__errno>
1111eb: 83 38 22 cmpl $0x22,(%eax)
1111ee: 8b 55 d4 mov -0x2c(%ebp),%edx
1111f1: 74 0d je 111200 <rtems_string_to_unsigned_long+0x64>
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
1111f3: 89 13 mov %edx,(%ebx)
return RTEMS_SUCCESSFUL;
1111f5: 31 c0 xor %eax,%eax
}
1111f7: 8d 65 f4 lea -0xc(%ebp),%esp
1111fa: 5b pop %ebx
1111fb: 5e pop %esi
1111fc: 5f pop %edi
1111fd: c9 leave
1111fe: c3 ret
1111ff: 90 nop
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
111200: 8d 42 ff lea -0x1(%edx),%eax
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
111203: 83 f8 fd cmp $0xfffffffd,%eax
111206: 76 eb jbe 1111f3 <rtems_string_to_unsigned_long+0x57><== NEVER TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
111208: b8 0a 00 00 00 mov $0xa,%eax
*n = result;
return RTEMS_SUCCESSFUL;
}
11120d: 8d 65 f4 lea -0xc(%ebp),%esp
111210: 5b pop %ebx
111211: 5e pop %esi
111212: 5f pop %edi
111213: c9 leave
111214: c3 ret
111215: 8d 76 00 lea 0x0(%esi),%esi
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
111218: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
11121d: 8d 65 f4 lea -0xc(%ebp),%esp
111220: 5b pop %ebx
111221: 5e pop %esi
111222: 5f pop %edi
111223: c9 leave
111224: c3 ret
111225: 8d 76 00 lea 0x0(%esi),%esi
{
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
111228: b8 09 00 00 00 mov $0x9,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
11122d: 8d 65 f4 lea -0xc(%ebp),%esp
111230: 5b pop %ebx
111231: 5e pop %esi
111232: 5f pop %edi
111233: c9 leave
111234: c3 ret
111235: 8d 76 00 lea 0x0(%esi),%esi
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
111238: 8b 45 e4 mov -0x1c(%ebp),%eax
11123b: eb a2 jmp 1111df <rtems_string_to_unsigned_long+0x43>
001110d4 <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
1110d4: 55 push %ebp
1110d5: 89 e5 mov %esp,%ebp
1110d7: 57 push %edi
1110d8: 56 push %esi
1110d9: 53 push %ebx
1110da: 83 ec 2c sub $0x2c,%esp
1110dd: 8b 7d 08 mov 0x8(%ebp),%edi
1110e0: 8b 5d 0c mov 0xc(%ebp),%ebx
1110e3: 8b 75 10 mov 0x10(%ebp),%esi
unsigned long long result;
char *end;
if ( !n )
1110e6: 85 db test %ebx,%ebx
1110e8: 0f 84 96 00 00 00 je 111184 <rtems_string_to_unsigned_long_long+0xb0>
return RTEMS_INVALID_ADDRESS;
errno = 0;
1110ee: e8 a1 29 00 00 call 113a94 <__errno>
1110f3: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
1110f9: c7 03 00 00 00 00 movl $0x0,(%ebx)
1110ff: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
result = strtoull( s, &end, base );
111106: 50 push %eax
111107: ff 75 14 pushl 0x14(%ebp)
11110a: 8d 45 e4 lea -0x1c(%ebp),%eax
11110d: 50 push %eax
11110e: 57 push %edi
11110f: e8 38 5a 00 00 call 116b4c <strtoull>
111114: 89 d1 mov %edx,%ecx
111116: 89 c2 mov %eax,%edx
if ( endptr )
111118: 83 c4 10 add $0x10,%esp
11111b: 85 f6 test %esi,%esi
11111d: 74 75 je 111194 <rtems_string_to_unsigned_long_long+0xc0>
*endptr = end;
11111f: 8b 45 e4 mov -0x1c(%ebp),%eax
111122: 89 06 mov %eax,(%esi)
if ( end == s )
111124: 39 c7 cmp %eax,%edi
111126: 74 4c je 111174 <rtems_string_to_unsigned_long_long+0xa0>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
111128: 89 55 d4 mov %edx,-0x2c(%ebp)
11112b: 89 4d d0 mov %ecx,-0x30(%ebp)
11112e: e8 61 29 00 00 call 113a94 <__errno>
111133: 83 38 22 cmpl $0x22,(%eax)
111136: 8b 55 d4 mov -0x2c(%ebp),%edx
111139: 8b 4d d0 mov -0x30(%ebp),%ecx
11113c: 74 12 je 111150 <rtems_string_to_unsigned_long_long+0x7c>
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
11113e: 89 13 mov %edx,(%ebx)
111140: 89 4b 04 mov %ecx,0x4(%ebx)
return RTEMS_SUCCESSFUL;
111143: 31 c0 xor %eax,%eax
}
111145: 8d 65 f4 lea -0xc(%ebp),%esp
111148: 5b pop %ebx
111149: 5e pop %esi
11114a: 5f pop %edi
11114b: c9 leave
11114c: c3 ret
11114d: 8d 76 00 lea 0x0(%esi),%esi
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
111150: 89 d6 mov %edx,%esi
111152: 89 cf mov %ecx,%edi
111154: 83 c6 ff add $0xffffffff,%esi
111157: 83 d7 ff adc $0xffffffff,%edi
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
11115a: 83 ff ff cmp $0xffffffff,%edi
11115d: 72 df jb 11113e <rtems_string_to_unsigned_long_long+0x6a><== NEVER TAKEN
11115f: 83 fe fd cmp $0xfffffffd,%esi
111162: 76 da jbe 11113e <rtems_string_to_unsigned_long_long+0x6a><== NEVER TAKEN
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
111164: b8 0a 00 00 00 mov $0xa,%eax
*n = result;
return RTEMS_SUCCESSFUL;
}
111169: 8d 65 f4 lea -0xc(%ebp),%esp
11116c: 5b pop %ebx
11116d: 5e pop %esi
11116e: 5f pop %edi
11116f: c9 leave
111170: c3 ret
111171: 8d 76 00 lea 0x0(%esi),%esi
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
111174: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
111179: 8d 65 f4 lea -0xc(%ebp),%esp
11117c: 5b pop %ebx
11117d: 5e pop %esi
11117e: 5f pop %edi
11117f: c9 leave
111180: c3 ret
111181: 8d 76 00 lea 0x0(%esi),%esi
{
unsigned long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
111184: b8 09 00 00 00 mov $0x9,%eax
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
}
111189: 8d 65 f4 lea -0xc(%ebp),%esp
11118c: 5b pop %ebx
11118d: 5e pop %esi
11118e: 5f pop %edi
11118f: c9 leave
111190: c3 ret
111191: 8d 76 00 lea 0x0(%esi),%esi
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
if ( endptr )
111194: 8b 45 e4 mov -0x1c(%ebp),%eax
111197: eb 8b jmp 111124 <rtems_string_to_unsigned_long_long+0x50>
00107e24 <rtems_tarfs_load>:
int rtems_tarfs_load(
char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
107e24: 55 push %ebp
107e25: 89 e5 mov %esp,%ebp
107e27: 57 push %edi
107e28: 56 push %esi
107e29: 53 push %ebx
107e2a: 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(
107e30: 31 c0 xor %eax,%eax
107e32: b9 ff ff ff ff mov $0xffffffff,%ecx
107e37: 8b 7d 08 mov 0x8(%ebp),%edi
107e3a: f2 ae repnz scas %es:(%edi),%al
107e3c: f7 d1 not %ecx
107e3e: 49 dec %ecx
107e3f: 6a 00 push $0x0
107e41: 8d 45 d0 lea -0x30(%ebp),%eax
107e44: 89 85 2c fe ff ff mov %eax,-0x1d4(%ebp)
107e4a: 50 push %eax
107e4b: 6a 00 push $0x0
107e4d: 51 push %ecx
107e4e: ff 75 08 pushl 0x8(%ebp)
107e51: e8 9a 0a 00 00 call 1088f0 <rtems_filesystem_evaluate_path>
107e56: 89 85 44 fe ff ff mov %eax,-0x1bc(%ebp)
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
107e5c: 83 c4 20 add $0x20,%esp
107e5f: 85 c0 test %eax,%eax
107e61: 0f 85 61 01 00 00 jne 107fc8 <rtems_tarfs_load+0x1a4>
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
107e67: 8b 45 dc mov -0x24(%ebp),%eax
107e6a: 3d 80 6d 12 00 cmp $0x126d80,%eax
107e6f: 0f 85 47 01 00 00 jne 107fbc <rtems_tarfs_load+0x198>
107e75: 31 db xor %ebx,%ebx
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
107e77: 8d 45 bc lea -0x44(%ebp),%eax
107e7a: 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);
107e80: 8d 95 58 fe ff ff lea -0x1a8(%ebp),%edx
107e86: 89 95 34 fe ff ff mov %edx,-0x1cc(%ebp)
107e8c: eb 15 jmp 107ea3 <rtems_tarfs_load+0x7f>
107e8e: 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) {
107e90: 80 bd 53 fe ff ff 30 cmpb $0x30,-0x1ad(%ebp)
107e97: 0f 84 43 01 00 00 je 107fe0 <rtems_tarfs_load+0x1bc>
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
107e9d: 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)
107ea3: 8d 83 00 02 00 00 lea 0x200(%ebx),%eax
107ea9: 89 85 54 fe ff ff mov %eax,-0x1ac(%ebp)
107eaf: 8b 55 10 mov 0x10(%ebp),%edx
107eb2: 39 d0 cmp %edx,%eax
107eb4: 0f 87 18 01 00 00 ja 107fd2 <rtems_tarfs_load+0x1ae><== NEVER TAKEN
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
107eba: 03 5d 0c add 0xc(%ebp),%ebx
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
107ebd: 8d b3 01 01 00 00 lea 0x101(%ebx),%esi
107ec3: bf c8 6d 12 00 mov $0x126dc8,%edi
107ec8: b9 05 00 00 00 mov $0x5,%ecx
107ecd: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
107ecf: 0f 85 fd 00 00 00 jne 107fd2 <rtems_tarfs_load+0x1ae>
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
107ed5: 57 push %edi
107ed6: 6a 63 push $0x63
107ed8: 53 push %ebx
107ed9: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax
107edf: 50 push %eax
107ee0: e8 a7 fd 00 00 call 117c8c <strncpy>
filename[MAX_NAME_FIELD_SIZE] = '\0';
107ee5: c6 45 bb 00 movb $0x0,-0x45(%ebp)
linkflag = hdr_ptr[156];
107ee9: 8a 93 9c 00 00 00 mov 0x9c(%ebx),%dl
107eef: 88 95 53 fe ff ff mov %dl,-0x1ad(%ebp)
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
107ef5: 59 pop %ecx
107ef6: 5e pop %esi
107ef7: 6a 08 push $0x8
107ef9: 8d 43 64 lea 0x64(%ebx),%eax
107efc: 50 push %eax
107efd: e8 8e 7c 00 00 call 10fb90 <_rtems_octal2ulong>
107f02: 89 85 48 fe ff ff mov %eax,-0x1b8(%ebp)
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
107f08: 58 pop %eax
107f09: 5a pop %edx
107f0a: 6a 0c push $0xc
107f0c: 8d 43 7c lea 0x7c(%ebx),%eax
107f0f: 50 push %eax
107f10: e8 7b 7c 00 00 call 10fb90 <_rtems_octal2ulong>
107f15: 89 85 4c fe ff ff mov %eax,-0x1b4(%ebp)
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
107f1b: 5e pop %esi
107f1c: 5f pop %edi
107f1d: 6a 08 push $0x8
107f1f: 8d 83 94 00 00 00 lea 0x94(%ebx),%eax
107f25: 50 push %eax
107f26: e8 65 7c 00 00 call 10fb90 <_rtems_octal2ulong>
107f2b: 89 c6 mov %eax,%esi
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
107f2d: 89 1c 24 mov %ebx,(%esp)
107f30: e8 2f 81 00 00 call 110064 <_rtems_tar_header_checksum>
107f35: 83 c4 10 add $0x10,%esp
107f38: 39 f0 cmp %esi,%eax
107f3a: 0f 85 92 00 00 00 jne 107fd2 <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) {
107f40: 80 bd 53 fe ff ff 35 cmpb $0x35,-0x1ad(%ebp)
107f47: 0f 85 43 ff ff ff jne 107e90 <rtems_tarfs_load+0x6c>
strcpy(full_filename, mountpoint);
107f4d: 83 ec 08 sub $0x8,%esp
107f50: ff 75 08 pushl 0x8(%ebp)
107f53: 8d 85 58 fe ff ff lea -0x1a8(%ebp),%eax
107f59: 50 push %eax
107f5a: e8 c5 f9 00 00 call 117924 <strcpy>
if (full_filename[strlen(full_filename)-1] != '/')
107f5f: 31 c0 xor %eax,%eax
107f61: b9 ff ff ff ff mov $0xffffffff,%ecx
107f66: 8b bd 34 fe ff ff mov -0x1cc(%ebp),%edi
107f6c: f2 ae repnz scas %es:(%edi),%al
107f6e: f7 d1 not %ecx
107f70: 49 dec %ecx
107f71: 83 c4 10 add $0x10,%esp
107f74: 80 bc 0d 57 fe ff ff cmpb $0x2f,-0x1a9(%ebp,%ecx,1)
107f7b: 2f
107f7c: 74 0a je 107f88 <rtems_tarfs_load+0x164><== ALWAYS TAKEN
strcat(full_filename, "/");
107f7e: 66 c7 84 0d 58 fe ff movw $0x2f,-0x1a8(%ebp,%ecx,1) <== NOT EXECUTED
107f85: ff 2f 00
strcat(full_filename, filename);
107f88: 83 ec 08 sub $0x8,%esp
107f8b: 8d 95 58 ff ff ff lea -0xa8(%ebp),%edx
107f91: 52 push %edx
107f92: 8d 85 58 fe ff ff lea -0x1a8(%ebp),%eax
107f98: 50 push %eax
107f99: e8 d2 f7 00 00 call 117770 <strcat>
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
107f9e: 5a pop %edx
107f9f: 59 pop %ecx
107fa0: 68 ff 01 00 00 push $0x1ff
107fa5: 8d 95 58 fe ff ff lea -0x1a8(%ebp),%edx
107fab: 52 push %edx
107fac: e8 fb 10 00 00 call 1090ac <mkdir>
107fb1: 83 c4 10 add $0x10,%esp
107fb4: e9 e4 fe ff ff jmp 107e9d <rtems_tarfs_load+0x79>
107fb9: 8d 76 00 lea 0x0(%esi),%esi
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
107fbc: 3d 00 78 12 00 cmp $0x127800,%eax
107fc1: 0f 84 ae fe ff ff je 107e75 <rtems_tarfs_load+0x51> <== NEVER TAKEN
107fc7: 90 nop
return -1;
107fc8: c7 85 44 fe ff ff ff movl $0xffffffff,-0x1bc(%ebp)
107fcf: ff ff ff
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
return status;
}
107fd2: 8b 85 44 fe ff ff mov -0x1bc(%ebp),%eax
107fd8: 8d 65 f4 lea -0xc(%ebp),%esp
107fdb: 5b pop %ebx
107fdc: 5e pop %esi
107fdd: 5f pop %edi
107fde: c9 leave
107fdf: c3 ret
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
107fe0: 8b bd 30 fe ff ff mov -0x1d0(%ebp),%edi
107fe6: 8b b5 2c fe ff ff mov -0x1d4(%ebp),%esi
107fec: b9 05 00 00 00 mov $0x5,%ecx
107ff1: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
107ff3: 50 push %eax
107ff4: 8d 45 e4 lea -0x1c(%ebp),%eax
107ff7: 50 push %eax
107ff8: 8d 55 bc lea -0x44(%ebp),%edx
107ffb: 52 push %edx
107ffc: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax
108002: 50 push %eax
108003: e8 3c 88 00 00 call 110844 <IMFS_evaluate_for_make>
108008: 83 c4 10 add $0x10,%esp
10800b: 85 c0 test %eax,%eax
10800d: 74 1d je 10802c <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;
10800f: 8b 85 4c fe ff ff mov -0x1b4(%ebp),%eax
108015: 05 ff 01 00 00 add $0x1ff,%eax
offset += 512 * nblocks;
10801a: 25 00 fe ff ff and $0xfffffe00,%eax
10801f: 01 85 54 fe ff ff add %eax,-0x1ac(%ebp)
108025: e9 73 fe ff ff jmp 107e9d <rtems_tarfs_load+0x79>
10802a: 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(
10802c: 83 ec 0c sub $0xc,%esp
10802f: 6a 00 push $0x0
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
108031: 8b 85 48 fe ff ff mov -0x1b8(%ebp),%eax
108037: 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(
10803c: 80 cc 80 or $0x80,%ah
10803f: 50 push %eax
108040: ff 75 e4 pushl -0x1c(%ebp)
108043: 6a 06 push $0x6
108045: 8d 55 bc lea -0x44(%ebp),%edx
108048: 52 push %edx
108049: e8 fe 81 00 00 call 11024c <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;
10804e: 8b 95 4c fe ff ff mov -0x1b4(%ebp),%edx
108054: 89 50 50 mov %edx,0x50(%eax)
108057: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.linearfile.direct = &tar_image[offset];
10805e: 8b 55 0c mov 0xc(%ebp),%edx
108061: 03 95 54 fe ff ff add -0x1ac(%ebp),%edx
108067: 89 50 58 mov %edx,0x58(%eax)
10806a: 83 c4 20 add $0x20,%esp
10806d: eb a0 jmp 10800f <rtems_tarfs_load+0x1eb>
0010b84c <rtems_task_create>:
size_t stack_size,
rtems_mode initial_modes,
rtems_attribute attribute_set,
rtems_id *id
)
{
10b84c: 55 push %ebp
10b84d: 89 e5 mov %esp,%ebp
10b84f: 57 push %edi
10b850: 56 push %esi
10b851: 53 push %ebx
10b852: 83 ec 1c sub $0x1c,%esp
10b855: 8b 5d 08 mov 0x8(%ebp),%ebx
10b858: 8b 7d 0c mov 0xc(%ebp),%edi
10b85b: 8b 75 1c mov 0x1c(%ebp),%esi
Priority_Control core_priority;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
10b85e: 85 f6 test %esi,%esi
10b860: 0f 84 3e 01 00 00 je 10b9a4 <rtems_task_create+0x158>
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
10b866: 85 db test %ebx,%ebx
10b868: 0f 84 d2 00 00 00 je 10b940 <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 ) ) {
10b86e: f7 45 18 00 80 00 00 testl $0x8000,0x18(%ebp)
10b875: 75 17 jne 10b88e <rtems_task_create+0x42>
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
10b877: 85 ff test %edi,%edi
10b879: 0f 84 b1 00 00 00 je 10b930 <rtems_task_create+0xe4>
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
10b87f: 0f b6 05 74 3a 12 00 movzbl 0x123a74,%eax
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
10b886: 39 c7 cmp %eax,%edi
10b888: 0f 87 a2 00 00 00 ja 10b930 <rtems_task_create+0xe4>
*/
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
10b88e: 83 ec 0c sub $0xc,%esp
10b891: ff 35 40 7e 12 00 pushl 0x127e40
10b897: e8 c4 06 00 00 call 10bf60 <_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 );
10b89c: c7 04 24 20 7d 12 00 movl $0x127d20,(%esp)
10b8a3: e8 dc 10 00 00 call 10c984 <_Objects_Allocate>
10b8a8: 89 c2 mov %eax,%edx
* the event of an error.
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
10b8aa: 83 c4 10 add $0x10,%esp
10b8ad: 85 c0 test %eax,%eax
10b8af: 0f 84 cf 00 00 00 je 10b984 <rtems_task_create+0x138>
/*
* Initialize the core thread for this task.
*/
status = _Thread_Initialize(
10b8b5: 50 push %eax
10b8b6: 53 push %ebx
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
10b8b7: 8b 45 14 mov 0x14(%ebp),%eax
10b8ba: 83 e0 01 and $0x1,%eax
10b8bd: 50 push %eax
10b8be: 6a 00 push $0x0
10b8c0: 31 c0 xor %eax,%eax
10b8c2: f7 45 14 00 02 00 00 testl $0x200,0x14(%ebp)
10b8c9: 0f 95 c0 setne %al
10b8cc: 50 push %eax
10b8cd: 31 c0 xor %eax,%eax
10b8cf: f7 45 14 00 01 00 00 testl $0x100,0x14(%ebp)
10b8d6: 0f 94 c0 sete %al
10b8d9: 50 push %eax
10b8da: 57 push %edi
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_floating_point(
rtems_attribute attribute_set
)
{
return ( attribute_set & RTEMS_FLOATING_POINT ) ? true : false;
10b8db: 8b 45 18 mov 0x18(%ebp),%eax
10b8de: 83 e0 01 and $0x1,%eax
10b8e1: 50 push %eax
10b8e2: ff 75 10 pushl 0x10(%ebp)
10b8e5: 6a 00 push $0x0
10b8e7: 52 push %edx
10b8e8: 68 20 7d 12 00 push $0x127d20
10b8ed: 89 55 e4 mov %edx,-0x1c(%ebp)
10b8f0: e8 53 21 00 00 call 10da48 <_Thread_Initialize>
NULL, /* no budget algorithm callout */
_Modes_Get_interrupt_level(initial_modes),
(Objects_Name) name
);
if ( !status ) {
10b8f5: 83 c4 30 add $0x30,%esp
10b8f8: 84 c0 test %al,%al
10b8fa: 8b 55 e4 mov -0x1c(%ebp),%edx
10b8fd: 74 51 je 10b950 <rtems_task_create+0x104>
_RTEMS_Unlock_allocator();
return RTEMS_UNSATISFIED;
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
10b8ff: 8b 82 e8 00 00 00 mov 0xe8(%edx),%eax
* id - thread id
* RTEMS_SUCCESSFUL - if successful
* error code - if unsuccessful
*/
rtems_status_code rtems_task_create(
10b905: 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;
10b90c: 0f 94 40 08 sete 0x8(%eax)
*id = the_thread->Object.id;
10b910: 8b 42 08 mov 0x8(%edx),%eax
10b913: 89 06 mov %eax,(%esi)
);
}
#endif
_RTEMS_Unlock_allocator();
10b915: 83 ec 0c sub $0xc,%esp
10b918: ff 35 40 7e 12 00 pushl 0x127e40
10b91e: e8 85 06 00 00 call 10bfa8 <_API_Mutex_Unlock>
return RTEMS_SUCCESSFUL;
10b923: 83 c4 10 add $0x10,%esp
10b926: 31 c0 xor %eax,%eax
}
10b928: 8d 65 f4 lea -0xc(%ebp),%esp
10b92b: 5b pop %ebx
10b92c: 5e pop %esi
10b92d: 5f pop %edi
10b92e: c9 leave
10b92f: 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;
10b930: b8 13 00 00 00 mov $0x13,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10b935: 8d 65 f4 lea -0xc(%ebp),%esp
10b938: 5b pop %ebx
10b939: 5e pop %esi
10b93a: 5f pop %edi
10b93b: c9 leave
10b93c: c3 ret
10b93d: 8d 76 00 lea 0x0(%esi),%esi
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10b940: b8 03 00 00 00 mov $0x3,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10b945: 8d 65 f4 lea -0xc(%ebp),%esp
10b948: 5b pop %ebx
10b949: 5e pop %esi
10b94a: 5f pop %edi
10b94b: c9 leave
10b94c: c3 ret
10b94d: 8d 76 00 lea 0x0(%esi),%esi
*/
RTEMS_INLINE_ROUTINE void _RTEMS_tasks_Free (
Thread_Control *the_task
)
{
_Objects_Free(
10b950: 83 ec 0c sub $0xc,%esp
10b953: ff 72 08 pushl 0x8(%edx)
10b956: e8 0d 14 00 00 call 10cd68 <_Objects_Get_information_id>
10b95b: 5a pop %edx
10b95c: 59 pop %ecx
10b95d: 8b 55 e4 mov -0x1c(%ebp),%edx
10b960: 52 push %edx
10b961: 50 push %eax
10b962: e8 91 13 00 00 call 10ccf8 <_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();
10b967: 58 pop %eax
10b968: ff 35 40 7e 12 00 pushl 0x127e40
10b96e: e8 35 06 00 00 call 10bfa8 <_API_Mutex_Unlock>
return RTEMS_UNSATISFIED;
10b973: 83 c4 10 add $0x10,%esp
10b976: b8 0d 00 00 00 mov $0xd,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10b97b: 8d 65 f4 lea -0xc(%ebp),%esp
10b97e: 5b pop %ebx
10b97f: 5e pop %esi
10b980: 5f pop %edi
10b981: c9 leave
10b982: c3 ret
10b983: 90 nop
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
_RTEMS_Unlock_allocator();
10b984: 83 ec 0c sub $0xc,%esp
10b987: ff 35 40 7e 12 00 pushl 0x127e40
10b98d: e8 16 06 00 00 call 10bfa8 <_API_Mutex_Unlock>
return RTEMS_TOO_MANY;
10b992: 83 c4 10 add $0x10,%esp
10b995: b8 05 00 00 00 mov $0x5,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10b99a: 8d 65 f4 lea -0xc(%ebp),%esp
10b99d: 5b pop %ebx
10b99e: 5e pop %esi
10b99f: 5f pop %edi
10b9a0: c9 leave
10b9a1: c3 ret
10b9a2: 66 90 xchg %ax,%ax
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10b9a4: b8 09 00 00 00 mov $0x9,%eax
10b9a9: eb 8a jmp 10b935 <rtems_task_create+0xe9>
0010b9ac <rtems_task_delete>:
*/
rtems_status_code rtems_task_delete(
rtems_id id
)
{
10b9ac: 55 push %ebp
10b9ad: 89 e5 mov %esp,%ebp
10b9af: 53 push %ebx
10b9b0: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
10b9b3: ff 35 40 7e 12 00 pushl 0x127e40
10b9b9: e8 a2 05 00 00 call 10bf60 <_API_Mutex_Lock>
the_thread = _Thread_Get( id, &location );
10b9be: 5a pop %edx
10b9bf: 59 pop %ecx
10b9c0: 8d 45 f4 lea -0xc(%ebp),%eax
10b9c3: 50 push %eax
10b9c4: ff 75 08 pushl 0x8(%ebp)
10b9c7: e8 08 20 00 00 call 10d9d4 <_Thread_Get>
10b9cc: 89 c3 mov %eax,%ebx
switch ( location ) {
10b9ce: 83 c4 10 add $0x10,%esp
10b9d1: 8b 45 f4 mov -0xc(%ebp),%eax
10b9d4: 85 c0 test %eax,%eax
10b9d6: 75 44 jne 10ba1c <rtems_task_delete+0x70>
case OBJECTS_LOCAL:
the_information = _Objects_Get_information_id( the_thread->Object.id );
10b9d8: 83 ec 0c sub $0xc,%esp
10b9db: ff 73 08 pushl 0x8(%ebx)
10b9de: e8 85 13 00 00 call 10cd68 <_Objects_Get_information_id>
0 /* Not used */
);
}
#endif
_Thread_Close( the_information, the_thread );
10b9e3: 5a pop %edx
10b9e4: 59 pop %ecx
10b9e5: 53 push %ebx
10b9e6: 50 push %eax
10b9e7: e8 9c 1c 00 00 call 10d688 <_Thread_Close>
10b9ec: 58 pop %eax
10b9ed: ff 73 08 pushl 0x8(%ebx)
10b9f0: e8 73 13 00 00 call 10cd68 <_Objects_Get_information_id>
10b9f5: 5a pop %edx
10b9f6: 59 pop %ecx
10b9f7: 53 push %ebx
10b9f8: 50 push %eax
10b9f9: e8 fa 12 00 00 call 10ccf8 <_Objects_Free>
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
10b9fe: 58 pop %eax
10b9ff: ff 35 40 7e 12 00 pushl 0x127e40
10ba05: e8 9e 05 00 00 call 10bfa8 <_API_Mutex_Unlock>
_Thread_Enable_dispatch();
10ba0a: e8 a1 1f 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10ba0f: 83 c4 10 add $0x10,%esp
10ba12: 31 c0 xor %eax,%eax
break;
}
_RTEMS_Unlock_allocator();
return RTEMS_INVALID_ID;
}
10ba14: 8b 5d fc mov -0x4(%ebp),%ebx
10ba17: c9 leave
10ba18: c3 ret
10ba19: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
_RTEMS_Unlock_allocator();
10ba1c: 83 ec 0c sub $0xc,%esp
10ba1f: ff 35 40 7e 12 00 pushl 0x127e40
10ba25: e8 7e 05 00 00 call 10bfa8 <_API_Mutex_Unlock>
return RTEMS_INVALID_ID;
10ba2a: 83 c4 10 add $0x10,%esp
10ba2d: b8 04 00 00 00 mov $0x4,%eax
}
10ba32: 8b 5d fc mov -0x4(%ebp),%ebx
10ba35: c9 leave
10ba36: c3 ret
0010d4e4 <rtems_task_get_note>:
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
10d4e4: 55 push %ebp
10d4e5: 89 e5 mov %esp,%ebp
10d4e7: 56 push %esi
10d4e8: 53 push %ebx
10d4e9: 83 ec 10 sub $0x10,%esp
10d4ec: 8b 45 08 mov 0x8(%ebp),%eax
10d4ef: 8b 75 0c mov 0xc(%ebp),%esi
10d4f2: 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() )
10d4f5: 80 3d 04 79 12 00 00 cmpb $0x0,0x127904
10d4fc: 74 6e je 10d56c <rtems_task_get_note+0x88>
return RTEMS_NOT_CONFIGURED;
if ( !note )
10d4fe: 85 db test %ebx,%ebx
10d500: 74 7e je 10d580 <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 )
10d502: 83 fe 0f cmp $0xf,%esi
10d505: 77 3d ja 10d544 <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 ) ||
10d507: 85 c0 test %eax,%eax
10d509: 74 45 je 10d550 <rtems_task_get_note+0x6c>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
10d50b: 8b 15 38 c5 12 00 mov 0x12c538,%edx
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10d511: 3b 42 08 cmp 0x8(%edx),%eax
10d514: 74 40 je 10d556 <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 );
10d516: 83 ec 08 sub $0x8,%esp
10d519: 8d 55 f4 lea -0xc(%ebp),%edx
10d51c: 52 push %edx
10d51d: 50 push %eax
10d51e: e8 f9 22 00 00 call 10f81c <_Thread_Get>
switch ( location ) {
10d523: 83 c4 10 add $0x10,%esp
10d526: 8b 55 f4 mov -0xc(%ebp),%edx
10d529: 85 d2 test %edx,%edx
10d52b: 75 4b jne 10d578 <rtems_task_get_note+0x94>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
10d52d: 8b 80 e8 00 00 00 mov 0xe8(%eax),%eax
10d533: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax
10d537: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10d539: e8 ba 22 00 00 call 10f7f8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10d53e: 31 c0 xor %eax,%eax
10d540: eb 07 jmp 10d549 <rtems_task_get_note+0x65>
10d542: 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;
10d544: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d549: 8d 65 f8 lea -0x8(%ebp),%esp
10d54c: 5b pop %ebx
10d54d: 5e pop %esi
10d54e: c9 leave
10d54f: c3 ret
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10d550: 8b 15 38 c5 12 00 mov 0x12c538,%edx
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
10d556: 8b 82 e8 00 00 00 mov 0xe8(%edx),%eax
10d55c: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax
10d560: 89 03 mov %eax,(%ebx)
return RTEMS_SUCCESSFUL;
10d562: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d564: 8d 65 f8 lea -0x8(%ebp),%esp
10d567: 5b pop %ebx
10d568: 5e pop %esi
10d569: c9 leave
10d56a: c3 ret
10d56b: 90 nop
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
10d56c: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d571: 8d 65 f8 lea -0x8(%ebp),%esp
10d574: 5b pop %ebx
10d575: 5e pop %esi
10d576: c9 leave
10d577: c3 ret
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10d578: b8 04 00 00 00 mov $0x4,%eax
10d57d: eb ca jmp 10d549 <rtems_task_get_note+0x65>
10d57f: 90 nop
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
if ( !note )
return RTEMS_INVALID_ADDRESS;
10d580: b8 09 00 00 00 mov $0x9,%eax
10d585: eb c2 jmp 10d549 <rtems_task_get_note+0x65>
00118144 <rtems_task_is_suspended>:
*/
rtems_status_code rtems_task_is_suspended(
rtems_id id
)
{
118144: 55 push %ebp
118145: 89 e5 mov %esp,%ebp
118147: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
11814a: 8d 45 f4 lea -0xc(%ebp),%eax
11814d: 50 push %eax
11814e: ff 75 08 pushl 0x8(%ebp)
118151: e8 22 3d 00 00 call 11be78 <_Thread_Get>
switch ( location ) {
118156: 83 c4 10 add $0x10,%esp
118159: 8b 55 f4 mov -0xc(%ebp),%edx
11815c: 85 d2 test %edx,%edx
11815e: 74 08 je 118168 <rtems_task_is_suspended+0x24>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118160: b8 04 00 00 00 mov $0x4,%eax
}
118165: c9 leave
118166: c3 ret
118167: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
118168: f6 40 10 02 testb $0x2,0x10(%eax)
11816c: 74 0e je 11817c <rtems_task_is_suspended+0x38>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
11816e: e8 e1 3c 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_ALREADY_SUSPENDED;
118173: b8 0f 00 00 00 mov $0xf,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118178: c9 leave
118179: c3 ret
11817a: 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();
11817c: e8 d3 3c 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
118181: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118183: c9 leave
118184: c3 ret
00112df0 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
112df0: 55 push %ebp
112df1: 89 e5 mov %esp,%ebp
112df3: 57 push %edi
112df4: 56 push %esi
112df5: 53 push %ebx
112df6: 83 ec 1c sub $0x1c,%esp
112df9: 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 )
112dfc: 85 c9 test %ecx,%ecx
112dfe: 0f 84 40 01 00 00 je 112f44 <rtems_task_mode+0x154>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
112e04: 8b 1d 38 83 12 00 mov 0x128338,%ebx
api = executing->API_Extensions[ THREAD_API_RTEMS ];
112e0a: 8b bb e8 00 00 00 mov 0xe8(%ebx),%edi
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
112e10: 80 7b 74 01 cmpb $0x1,0x74(%ebx)
112e14: 19 f6 sbb %esi,%esi
112e16: 81 e6 00 01 00 00 and $0x100,%esi
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
112e1c: 8b 53 7c mov 0x7c(%ebx),%edx
112e1f: 85 d2 test %edx,%edx
112e21: 0f 85 f1 00 00 00 jne 112f18 <rtems_task_mode+0x128>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
112e27: 80 7f 08 01 cmpb $0x1,0x8(%edi)
112e2b: 19 d2 sbb %edx,%edx
112e2d: 81 e2 00 04 00 00 and $0x400,%edx
old_mode |= _ISR_Get_level();
112e33: 89 55 e4 mov %edx,-0x1c(%ebp)
112e36: 89 4d e0 mov %ecx,-0x20(%ebp)
112e39: e8 4e bf ff ff call 10ed8c <_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;
112e3e: 8b 55 e4 mov -0x1c(%ebp),%edx
112e41: 09 d0 or %edx,%eax
old_mode |= _ISR_Get_level();
112e43: 09 f0 or %esi,%eax
112e45: 8b 4d e0 mov -0x20(%ebp),%ecx
112e48: 89 01 mov %eax,(%ecx)
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
112e4a: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp)
112e51: 74 0b je 112e5e <rtems_task_mode+0x6e>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
112e53: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp)
112e5a: 0f 94 43 74 sete 0x74(%ebx)
if ( mask & RTEMS_TIMESLICE_MASK ) {
112e5e: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
112e65: 74 1c je 112e83 <rtems_task_mode+0x93>
if ( _Modes_Is_timeslice(mode_set) ) {
112e67: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp)
112e6e: 0f 84 b8 00 00 00 je 112f2c <rtems_task_mode+0x13c>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
112e74: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
112e7b: a1 60 7d 12 00 mov 0x127d60,%eax
112e80: 89 43 78 mov %eax,0x78(%ebx)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
112e83: f6 45 0c 01 testb $0x1,0xc(%ebp)
112e87: 74 0b je 112e94 <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 ) );
112e89: f6 45 08 01 testb $0x1,0x8(%ebp)
112e8d: 0f 84 91 00 00 00 je 112f24 <rtems_task_mode+0x134>
112e93: fa cli
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
112e94: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
112e9b: 74 3f je 112edc <rtems_task_mode+0xec>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
112e9d: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp)
112ea4: 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 ) {
112ea7: 38 47 08 cmp %al,0x8(%edi)
112eaa: 74 30 je 112edc <rtems_task_mode+0xec>
asr->is_enabled = is_asr_enabled;
112eac: 88 47 08 mov %al,0x8(%edi)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
112eaf: 9c pushf
112eb0: fa cli
112eb1: 58 pop %eax
_signals = information->signals_pending;
112eb2: 8b 57 18 mov 0x18(%edi),%edx
information->signals_pending = information->signals_posted;
112eb5: 8b 4f 14 mov 0x14(%edi),%ecx
112eb8: 89 4f 18 mov %ecx,0x18(%edi)
information->signals_posted = _signals;
112ebb: 89 57 14 mov %edx,0x14(%edi)
_ISR_Enable( _level );
112ebe: 50 push %eax
112ebf: 9d popf
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
112ec0: 8b 47 14 mov 0x14(%edi),%eax
112ec3: 85 c0 test %eax,%eax
112ec5: 0f 95 c0 setne %al
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
112ec8: 83 3d 20 7f 12 00 03 cmpl $0x3,0x127f20
112ecf: 74 16 je 112ee7 <rtems_task_mode+0xf7> <== ALWAYS TAKEN
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
112ed1: 31 c0 xor %eax,%eax
}
112ed3: 83 c4 1c add $0x1c,%esp
112ed6: 5b pop %ebx
112ed7: 5e pop %esi
112ed8: 5f pop %edi
112ed9: c9 leave
112eda: c3 ret
112edb: 90 nop
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
112edc: 31 c0 xor %eax,%eax
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
112ede: 83 3d 20 7f 12 00 03 cmpl $0x3,0x127f20
112ee5: 75 ea jne 112ed1 <rtems_task_mode+0xe1> <== NEVER TAKEN
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
112ee7: 8b 15 38 83 12 00 mov 0x128338,%edx
if ( are_signals_pending ||
112eed: 84 c0 test %al,%al
112eef: 75 0e jne 112eff <rtems_task_mode+0x10f>
112ef1: 3b 15 3c 83 12 00 cmp 0x12833c,%edx
112ef7: 74 d8 je 112ed1 <rtems_task_mode+0xe1>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
112ef9: 80 7a 74 00 cmpb $0x0,0x74(%edx)
112efd: 74 d2 je 112ed1 <rtems_task_mode+0xe1> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
112eff: c6 05 44 83 12 00 01 movb $0x1,0x128344
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
112f06: e8 2d a9 ff ff call 10d838 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
112f0b: 31 c0 xor %eax,%eax
}
112f0d: 83 c4 1c add $0x1c,%esp
112f10: 5b pop %ebx
112f11: 5e pop %esi
112f12: 5f pop %edi
112f13: c9 leave
112f14: c3 ret
112f15: 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;
112f18: 81 ce 00 02 00 00 or $0x200,%esi
112f1e: e9 04 ff ff ff jmp 112e27 <rtems_task_mode+0x37>
112f23: 90 nop
112f24: fb sti
112f25: e9 6a ff ff ff jmp 112e94 <rtems_task_mode+0xa4>
112f2a: 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;
112f2c: c7 43 7c 00 00 00 00 movl $0x0,0x7c(%ebx)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
112f33: f6 45 0c 01 testb $0x1,0xc(%ebp)
112f37: 0f 84 57 ff ff ff je 112e94 <rtems_task_mode+0xa4>
112f3d: e9 47 ff ff ff jmp 112e89 <rtems_task_mode+0x99>
112f42: 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;
112f44: b8 09 00 00 00 mov $0x9,%eax
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
}
112f49: 83 c4 1c add $0x1c,%esp
112f4c: 5b pop %ebx
112f4d: 5e pop %esi
112f4e: 5f pop %edi
112f4f: c9 leave
112f50: c3 ret
0010ecdc <rtems_task_resume>:
*/
rtems_status_code rtems_task_resume(
rtems_id id
)
{
10ecdc: 55 push %ebp
10ecdd: 89 e5 mov %esp,%ebp
10ecdf: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10ece2: 8d 45 f4 lea -0xc(%ebp),%eax
10ece5: 50 push %eax
10ece6: ff 75 08 pushl 0x8(%ebp)
10ece9: e8 1e 20 00 00 call 110d0c <_Thread_Get>
switch ( location ) {
10ecee: 83 c4 10 add $0x10,%esp
10ecf1: 8b 55 f4 mov -0xc(%ebp),%edx
10ecf4: 85 d2 test %edx,%edx
10ecf6: 74 08 je 10ed00 <rtems_task_resume+0x24>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10ecf8: b8 04 00 00 00 mov $0x4,%eax
}
10ecfd: c9 leave
10ecfe: c3 ret
10ecff: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _States_Is_suspended( the_thread->current_state ) ) {
10ed00: f6 40 10 02 testb $0x2,0x10(%eax)
10ed04: 75 0e jne 10ed14 <rtems_task_resume+0x38>
_Thread_Resume( the_thread, true );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
10ed06: e8 dd 1f 00 00 call 110ce8 <_Thread_Enable_dispatch>
return RTEMS_INCORRECT_STATE;
10ed0b: b8 0e 00 00 00 mov $0xe,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ed10: c9 leave
10ed11: c3 ret
10ed12: 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, true );
10ed14: 83 ec 08 sub $0x8,%esp
10ed17: 6a 01 push $0x1
10ed19: 50 push %eax
10ed1a: e8 d1 27 00 00 call 1114f0 <_Thread_Resume>
_Thread_Enable_dispatch();
10ed1f: e8 c4 1f 00 00 call 110ce8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10ed24: 83 c4 10 add $0x10,%esp
10ed27: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ed29: c9 leave
10ed2a: c3 ret
0010d65c <rtems_task_set_note>:
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
10d65c: 55 push %ebp
10d65d: 89 e5 mov %esp,%ebp
10d65f: 56 push %esi
10d660: 53 push %ebx
10d661: 83 ec 10 sub $0x10,%esp
10d664: 8b 45 08 mov 0x8(%ebp),%eax
10d667: 8b 5d 0c mov 0xc(%ebp),%ebx
10d66a: 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() )
10d66d: 80 3d 04 79 12 00 00 cmpb $0x0,0x127904
10d674: 74 66 je 10d6dc <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 )
10d676: 83 fb 0f cmp $0xf,%ebx
10d679: 77 39 ja 10d6b4 <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 ) ||
10d67b: 85 c0 test %eax,%eax
10d67d: 74 41 je 10d6c0 <rtems_task_set_note+0x64>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
10d67f: 8b 15 38 c5 12 00 mov 0x12c538,%edx
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10d685: 3b 42 08 cmp 0x8(%edx),%eax
10d688: 74 3c je 10d6c6 <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 );
10d68a: 83 ec 08 sub $0x8,%esp
10d68d: 8d 55 f4 lea -0xc(%ebp),%edx
10d690: 52 push %edx
10d691: 50 push %eax
10d692: e8 85 21 00 00 call 10f81c <_Thread_Get>
switch ( location ) {
10d697: 83 c4 10 add $0x10,%esp
10d69a: 8b 55 f4 mov -0xc(%ebp),%edx
10d69d: 85 d2 test %edx,%edx
10d69f: 75 47 jne 10d6e8 <rtems_task_set_note+0x8c>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
10d6a1: 8b 80 e8 00 00 00 mov 0xe8(%eax),%eax
10d6a7: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4)
_Thread_Enable_dispatch();
10d6ab: e8 48 21 00 00 call 10f7f8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10d6b0: 31 c0 xor %eax,%eax
10d6b2: eb 05 jmp 10d6b9 <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;
10d6b4: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d6b9: 8d 65 f8 lea -0x8(%ebp),%esp
10d6bc: 5b pop %ebx
10d6bd: 5e pop %esi
10d6be: c9 leave
10d6bf: c3 ret
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10d6c0: 8b 15 38 c5 12 00 mov 0x12c538,%edx
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
10d6c6: 8b 82 e8 00 00 00 mov 0xe8(%edx),%eax
10d6cc: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4)
return RTEMS_SUCCESSFUL;
10d6d0: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d6d2: 8d 65 f8 lea -0x8(%ebp),%esp
10d6d5: 5b pop %ebx
10d6d6: 5e pop %esi
10d6d7: c9 leave
10d6d8: c3 ret
10d6d9: 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;
10d6dc: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d6e1: 8d 65 f8 lea -0x8(%ebp),%esp
10d6e4: 5b pop %ebx
10d6e5: 5e pop %esi
10d6e6: c9 leave
10d6e7: c3 ret
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10d6e8: b8 04 00 00 00 mov $0x4,%eax
}
10d6ed: 8d 65 f8 lea -0x8(%ebp),%esp
10d6f0: 5b pop %ebx
10d6f1: 5e pop %esi
10d6f2: c9 leave
10d6f3: c3 ret
0010f9a0 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
10f9a0: 55 push %ebp
10f9a1: 89 e5 mov %esp,%ebp
10f9a3: 56 push %esi
10f9a4: 53 push %ebx
10f9a5: 83 ec 10 sub $0x10,%esp
10f9a8: 8b 5d 0c mov 0xc(%ebp),%ebx
10f9ab: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10f9ae: 85 db test %ebx,%ebx
10f9b0: 74 0b je 10f9bd <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 ) );
10f9b2: 0f b6 05 34 7a 12 00 movzbl 0x127a34,%eax
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
10f9b9: 39 c3 cmp %eax,%ebx
10f9bb: 77 5f ja 10fa1c <rtems_task_set_priority+0x7c>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
10f9bd: 85 f6 test %esi,%esi
10f9bf: 74 67 je 10fa28 <rtems_task_set_priority+0x88>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10f9c1: 83 ec 08 sub $0x8,%esp
10f9c4: 8d 45 f4 lea -0xc(%ebp),%eax
10f9c7: 50 push %eax
10f9c8: ff 75 08 pushl 0x8(%ebp)
10f9cb: e8 7c 21 00 00 call 111b4c <_Thread_Get>
switch ( location ) {
10f9d0: 83 c4 10 add $0x10,%esp
10f9d3: 8b 55 f4 mov -0xc(%ebp),%edx
10f9d6: 85 d2 test %edx,%edx
10f9d8: 75 36 jne 10fa10 <rtems_task_set_priority+0x70>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
10f9da: 8b 50 14 mov 0x14(%eax),%edx
10f9dd: 89 16 mov %edx,(%esi)
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
10f9df: 85 db test %ebx,%ebx
10f9e1: 74 1c je 10f9ff <rtems_task_set_priority+0x5f>
the_thread->real_priority = new_priority;
10f9e3: 89 58 18 mov %ebx,0x18(%eax)
if ( the_thread->resource_count == 0 ||
10f9e6: 8b 48 1c mov 0x1c(%eax),%ecx
10f9e9: 85 c9 test %ecx,%ecx
10f9eb: 74 05 je 10f9f2 <rtems_task_set_priority+0x52>
10f9ed: 3b 58 14 cmp 0x14(%eax),%ebx
10f9f0: 73 0d jae 10f9ff <rtems_task_set_priority+0x5f><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
10f9f2: 52 push %edx
10f9f3: 6a 00 push $0x0
10f9f5: 53 push %ebx
10f9f6: 50 push %eax
10f9f7: e8 f4 1c 00 00 call 1116f0 <_Thread_Change_priority>
10f9fc: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10f9ff: e8 24 21 00 00 call 111b28 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10fa04: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10fa06: 8d 65 f8 lea -0x8(%ebp),%esp
10fa09: 5b pop %ebx
10fa0a: 5e pop %esi
10fa0b: c9 leave
10fa0c: c3 ret
10fa0d: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10fa10: b8 04 00 00 00 mov $0x4,%eax
}
10fa15: 8d 65 f8 lea -0x8(%ebp),%esp
10fa18: 5b pop %ebx
10fa19: 5e pop %esi
10fa1a: c9 leave
10fa1b: 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;
10fa1c: b8 13 00 00 00 mov $0x13,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10fa21: 8d 65 f8 lea -0x8(%ebp),%esp
10fa24: 5b pop %ebx
10fa25: 5e pop %esi
10fa26: c9 leave
10fa27: 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;
10fa28: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10fa2d: 8d 65 f8 lea -0x8(%ebp),%esp
10fa30: 5b pop %ebx
10fa31: 5e pop %esi
10fa32: c9 leave
10fa33: c3 ret
0010baf4 <rtems_task_start>:
rtems_status_code rtems_task_start(
rtems_id id,
rtems_task_entry entry_point,
rtems_task_argument argument
)
{
10baf4: 55 push %ebp
10baf5: 89 e5 mov %esp,%ebp
10baf7: 53 push %ebx
10baf8: 83 ec 14 sub $0x14,%esp
10bafb: 8b 5d 0c mov 0xc(%ebp),%ebx
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
10bafe: 85 db test %ebx,%ebx
10bb00: 74 4e je 10bb50 <rtems_task_start+0x5c>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10bb02: 83 ec 08 sub $0x8,%esp
10bb05: 8d 45 f4 lea -0xc(%ebp),%eax
10bb08: 50 push %eax
10bb09: ff 75 08 pushl 0x8(%ebp)
10bb0c: e8 c3 1e 00 00 call 10d9d4 <_Thread_Get>
switch ( location ) {
10bb11: 83 c4 10 add $0x10,%esp
10bb14: 8b 55 f4 mov -0xc(%ebp),%edx
10bb17: 85 d2 test %edx,%edx
10bb19: 75 29 jne 10bb44 <rtems_task_start+0x50>
case OBJECTS_LOCAL:
if ( _Thread_Start(
10bb1b: 83 ec 0c sub $0xc,%esp
10bb1e: ff 75 10 pushl 0x10(%ebp)
10bb21: 6a 00 push $0x0
10bb23: 53 push %ebx
10bb24: 6a 00 push $0x0
10bb26: 50 push %eax
10bb27: e8 0c 28 00 00 call 10e338 <_Thread_Start>
10bb2c: 83 c4 20 add $0x20,%esp
10bb2f: 84 c0 test %al,%al
10bb31: 75 29 jne 10bb5c <rtems_task_start+0x68>
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
10bb33: e8 78 1e 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_INCORRECT_STATE;
10bb38: b8 0e 00 00 00 mov $0xe,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bb3d: 8b 5d fc mov -0x4(%ebp),%ebx
10bb40: c9 leave
10bb41: c3 ret
10bb42: 66 90 xchg %ax,%ax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10bb44: b8 04 00 00 00 mov $0x4,%eax
}
10bb49: 8b 5d fc mov -0x4(%ebp),%ebx
10bb4c: c9 leave
10bb4d: c3 ret
10bb4e: 66 90 xchg %ax,%ax
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
return RTEMS_INVALID_ADDRESS;
10bb50: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bb55: 8b 5d fc mov -0x4(%ebp),%ebx
10bb58: c9 leave
10bb59: c3 ret
10bb5a: 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();
10bb5c: e8 4f 1e 00 00 call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10bb61: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bb63: 8b 5d fc mov -0x4(%ebp),%ebx
10bb66: c9 leave
10bb67: c3 ret
00110f70 <rtems_task_suspend>:
*/
rtems_status_code rtems_task_suspend(
rtems_id id
)
{
110f70: 55 push %ebp
110f71: 89 e5 mov %esp,%ebp
110f73: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
110f76: 8d 45 f4 lea -0xc(%ebp),%eax
110f79: 50 push %eax
110f7a: ff 75 08 pushl 0x8(%ebp)
110f7d: e8 52 ca ff ff call 10d9d4 <_Thread_Get>
switch ( location ) {
110f82: 83 c4 10 add $0x10,%esp
110f85: 8b 55 f4 mov -0xc(%ebp),%edx
110f88: 85 d2 test %edx,%edx
110f8a: 74 08 je 110f94 <rtems_task_suspend+0x24>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
110f8c: b8 04 00 00 00 mov $0x4,%eax
}
110f91: c9 leave
110f92: c3 ret
110f93: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
110f94: f6 40 10 02 testb $0x2,0x10(%eax)
110f98: 74 0e je 110fa8 <rtems_task_suspend+0x38>
_Thread_Suspend( the_thread );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
110f9a: e8 11 ca ff ff call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_ALREADY_SUSPENDED;
110f9f: b8 0f 00 00 00 mov $0xf,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
110fa4: c9 leave
110fa5: c3 ret
110fa6: 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 );
110fa8: 83 ec 0c sub $0xc,%esp
110fab: 50 push %eax
110fac: e8 27 09 00 00 call 1118d8 <_Thread_Suspend>
_Thread_Enable_dispatch();
110fb1: e8 fa c9 ff ff call 10d9b0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
110fb6: 83 c4 10 add $0x10,%esp
110fb9: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
110fbb: c9 leave
110fbc: c3 ret
0010c650 <rtems_task_variable_add>:
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
10c650: 55 push %ebp
10c651: 89 e5 mov %esp,%ebp
10c653: 57 push %edi
10c654: 56 push %esi
10c655: 53 push %ebx
10c656: 83 ec 1c sub $0x1c,%esp
10c659: 8b 5d 0c mov 0xc(%ebp),%ebx
10c65c: 8b 7d 10 mov 0x10(%ebp),%edi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
10c65f: 85 db test %ebx,%ebx
10c661: 0f 84 9d 00 00 00 je 10c704 <rtems_task_variable_add+0xb4>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
10c667: 83 ec 08 sub $0x8,%esp
10c66a: 8d 45 e4 lea -0x1c(%ebp),%eax
10c66d: 50 push %eax
10c66e: ff 75 08 pushl 0x8(%ebp)
10c671: e8 6e 20 00 00 call 10e6e4 <_Thread_Get>
10c676: 89 c6 mov %eax,%esi
switch (location) {
10c678: 83 c4 10 add $0x10,%esp
10c67b: 8b 45 e4 mov -0x1c(%ebp),%eax
10c67e: 85 c0 test %eax,%eax
10c680: 74 0e je 10c690 <rtems_task_variable_add+0x40>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10c682: b8 04 00 00 00 mov $0x4,%eax
}
10c687: 8d 65 f4 lea -0xc(%ebp),%esp
10c68a: 5b pop %ebx
10c68b: 5e pop %esi
10c68c: 5f pop %edi
10c68d: c9 leave
10c68e: c3 ret
10c68f: 90 nop
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
10c690: 8b 86 f4 00 00 00 mov 0xf4(%esi),%eax
while (tvp) {
10c696: 85 c0 test %eax,%eax
10c698: 75 44 jne 10c6de <rtems_task_variable_add+0x8e>
10c69a: 66 90 xchg %ax,%ax
/*
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
10c69c: 83 ec 0c sub $0xc,%esp
10c69f: 6a 14 push $0x14
10c6a1: e8 f2 2f 00 00 call 10f698 <_Workspace_Allocate>
if (new == NULL) {
10c6a6: 83 c4 10 add $0x10,%esp
10c6a9: 85 c0 test %eax,%eax
10c6ab: 74 4b je 10c6f8 <rtems_task_variable_add+0xa8>
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
10c6ad: 8b 13 mov (%ebx),%edx
10c6af: 89 50 08 mov %edx,0x8(%eax)
new->ptr = ptr;
10c6b2: 89 58 04 mov %ebx,0x4(%eax)
new->dtor = dtor;
10c6b5: 89 78 10 mov %edi,0x10(%eax)
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
10c6b8: 8b 96 f4 00 00 00 mov 0xf4(%esi),%edx
10c6be: 89 10 mov %edx,(%eax)
the_thread->task_variables = new;
10c6c0: 89 86 f4 00 00 00 mov %eax,0xf4(%esi)
_Thread_Enable_dispatch();
10c6c6: e8 f5 1f 00 00 call 10e6c0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c6cb: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c6cd: 8d 65 f4 lea -0xc(%ebp),%esp
10c6d0: 5b pop %ebx
10c6d1: 5e pop %esi
10c6d2: 5f pop %edi
10c6d3: c9 leave
10c6d4: c3 ret
10c6d5: 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;
10c6d8: 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) {
10c6da: 85 c0 test %eax,%eax
10c6dc: 74 be je 10c69c <rtems_task_variable_add+0x4c>
if (tvp->ptr == ptr) {
10c6de: 39 58 04 cmp %ebx,0x4(%eax)
10c6e1: 75 f5 jne 10c6d8 <rtems_task_variable_add+0x88>
tvp->dtor = dtor;
10c6e3: 89 78 10 mov %edi,0x10(%eax)
_Thread_Enable_dispatch();
10c6e6: e8 d5 1f 00 00 call 10e6c0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c6eb: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c6ed: 8d 65 f4 lea -0xc(%ebp),%esp
10c6f0: 5b pop %ebx
10c6f1: 5e pop %esi
10c6f2: 5f pop %edi
10c6f3: c9 leave
10c6f4: c3 ret
10c6f5: 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();
10c6f8: e8 c3 1f 00 00 call 10e6c0 <_Thread_Enable_dispatch>
return RTEMS_NO_MEMORY;
10c6fd: b8 1a 00 00 00 mov $0x1a,%eax
10c702: eb 83 jmp 10c687 <rtems_task_variable_add+0x37>
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
10c704: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c709: 8d 65 f4 lea -0xc(%ebp),%esp
10c70c: 5b pop %ebx
10c70d: 5e pop %esi
10c70e: 5f pop %edi
10c70f: c9 leave
10c710: c3 ret
0010c714 <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
10c714: 55 push %ebp
10c715: 89 e5 mov %esp,%ebp
10c717: 53 push %ebx
10c718: 83 ec 14 sub $0x14,%esp
10c71b: 8b 5d 0c mov 0xc(%ebp),%ebx
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
10c71e: 85 db test %ebx,%ebx
10c720: 74 76 je 10c798 <rtems_task_variable_delete+0x84>
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
10c722: 83 ec 08 sub $0x8,%esp
10c725: 8d 45 f4 lea -0xc(%ebp),%eax
10c728: 50 push %eax
10c729: ff 75 08 pushl 0x8(%ebp)
10c72c: e8 b3 1f 00 00 call 10e6e4 <_Thread_Get>
switch (location) {
10c731: 83 c4 10 add $0x10,%esp
10c734: 8b 55 f4 mov -0xc(%ebp),%edx
10c737: 85 d2 test %edx,%edx
10c739: 74 0d je 10c748 <rtems_task_variable_delete+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10c73b: b8 04 00 00 00 mov $0x4,%eax
}
10c740: 8b 5d fc mov -0x4(%ebp),%ebx
10c743: c9 leave
10c744: c3 ret
10c745: 8d 76 00 lea 0x0(%esi),%esi
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
10c748: 8b 88 f4 00 00 00 mov 0xf4(%eax),%ecx
while (tvp) {
10c74e: 85 c9 test %ecx,%ecx
10c750: 74 17 je 10c769 <rtems_task_variable_delete+0x55>
if (tvp->ptr == ptr) {
10c752: 39 59 04 cmp %ebx,0x4(%ecx)
10c755: 75 0c jne 10c763 <rtems_task_variable_delete+0x4f>
10c757: eb 49 jmp 10c7a2 <rtems_task_variable_delete+0x8e>
10c759: 8d 76 00 lea 0x0(%esi),%esi
10c75c: 39 5a 04 cmp %ebx,0x4(%edx)
10c75f: 74 17 je 10c778 <rtems_task_variable_delete+0x64>
10c761: 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;
10c763: 8b 11 mov (%ecx),%edx
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
10c765: 85 d2 test %edx,%edx
10c767: 75 f3 jne 10c75c <rtems_task_variable_delete+0x48><== ALWAYS TAKEN
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
10c769: e8 52 1f 00 00 call 10e6c0 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
10c76e: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c773: 8b 5d fc mov -0x4(%ebp),%ebx
10c776: c9 leave
10c777: c3 ret
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
10c778: 8b 1a mov (%edx),%ebx
10c77a: 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 );
10c77c: 83 ec 08 sub $0x8,%esp
10c77f: 52 push %edx
10c780: 50 push %eax
10c781: e8 b2 00 00 00 call 10c838 <_RTEMS_Tasks_Invoke_task_variable_dtor>
_Thread_Enable_dispatch();
10c786: e8 35 1f 00 00 call 10e6c0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c78b: 83 c4 10 add $0x10,%esp
10c78e: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c790: 8b 5d fc mov -0x4(%ebp),%ebx
10c793: c9 leave
10c794: c3 ret
10c795: 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;
10c798: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c79d: 8b 5d fc mov -0x4(%ebp),%ebx
10c7a0: c9 leave
10c7a1: 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;
10c7a2: 8b 11 mov (%ecx),%edx
10c7a4: 89 90 f4 00 00 00 mov %edx,0xf4(%eax)
10c7aa: 89 ca mov %ecx,%edx
10c7ac: eb ce jmp 10c77c <rtems_task_variable_delete+0x68>
0010c7b0 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
10c7b0: 55 push %ebp
10c7b1: 89 e5 mov %esp,%ebp
10c7b3: 56 push %esi
10c7b4: 53 push %ebx
10c7b5: 83 ec 10 sub $0x10,%esp
10c7b8: 8b 5d 0c mov 0xc(%ebp),%ebx
10c7bb: 8b 75 10 mov 0x10(%ebp),%esi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
10c7be: 85 db test %ebx,%ebx
10c7c0: 74 56 je 10c818 <rtems_task_variable_get+0x68>
return RTEMS_INVALID_ADDRESS;
if ( !result )
10c7c2: 85 f6 test %esi,%esi
10c7c4: 74 52 je 10c818 <rtems_task_variable_get+0x68>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
10c7c6: 83 ec 08 sub $0x8,%esp
10c7c9: 8d 45 f4 lea -0xc(%ebp),%eax
10c7cc: 50 push %eax
10c7cd: ff 75 08 pushl 0x8(%ebp)
10c7d0: e8 0f 1f 00 00 call 10e6e4 <_Thread_Get>
switch (location) {
10c7d5: 83 c4 10 add $0x10,%esp
10c7d8: 8b 55 f4 mov -0xc(%ebp),%edx
10c7db: 85 d2 test %edx,%edx
10c7dd: 75 2d jne 10c80c <rtems_task_variable_get+0x5c>
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
10c7df: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
while (tvp) {
10c7e5: 85 c0 test %eax,%eax
10c7e7: 75 09 jne 10c7f2 <rtems_task_variable_get+0x42>
10c7e9: eb 39 jmp 10c824 <rtems_task_variable_get+0x74>
10c7eb: 90 nop
*/
*result = tvp->tval;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
10c7ec: 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) {
10c7ee: 85 c0 test %eax,%eax
10c7f0: 74 32 je 10c824 <rtems_task_variable_get+0x74><== NEVER TAKEN
if (tvp->ptr == ptr) {
10c7f2: 39 58 04 cmp %ebx,0x4(%eax)
10c7f5: 75 f5 jne 10c7ec <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;
10c7f7: 8b 40 0c mov 0xc(%eax),%eax
10c7fa: 89 06 mov %eax,(%esi)
_Thread_Enable_dispatch();
10c7fc: e8 bf 1e 00 00 call 10e6c0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c801: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c803: 8d 65 f8 lea -0x8(%ebp),%esp
10c806: 5b pop %ebx
10c807: 5e pop %esi
10c808: c9 leave
10c809: c3 ret
10c80a: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10c80c: b8 04 00 00 00 mov $0x4,%eax
}
10c811: 8d 65 f8 lea -0x8(%ebp),%esp
10c814: 5b pop %ebx
10c815: 5e pop %esi
10c816: c9 leave
10c817: c3 ret
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
if ( !result )
return RTEMS_INVALID_ADDRESS;
10c818: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c81d: 8d 65 f8 lea -0x8(%ebp),%esp
10c820: 5b pop %ebx
10c821: 5e pop %esi
10c822: c9 leave
10c823: c3 ret
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
10c824: e8 97 1e 00 00 call 10e6c0 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
10c829: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c82e: 8d 65 f8 lea -0x8(%ebp),%esp
10c831: 5b pop %ebx
10c832: 5e pop %esi
10c833: c9 leave
10c834: c3 ret
0010c9c0 <rtems_task_wake_when>:
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
10c9c0: 55 push %ebp
10c9c1: 89 e5 mov %esp,%ebp
10c9c3: 53 push %ebx
10c9c4: 83 ec 14 sub $0x14,%esp
10c9c7: 8b 5d 08 mov 0x8(%ebp),%ebx
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
10c9ca: 80 3d c4 aa 12 00 00 cmpb $0x0,0x12aac4
10c9d1: 0f 84 a9 00 00 00 je 10ca80 <rtems_task_wake_when+0xc0>
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
10c9d7: 85 db test %ebx,%ebx
10c9d9: 0f 84 ad 00 00 00 je 10ca8c <rtems_task_wake_when+0xcc>
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
10c9df: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
if ( !_TOD_Validate( time_buffer ) )
10c9e6: 83 ec 0c sub $0xc,%esp
10c9e9: 53 push %ebx
10c9ea: e8 d1 f3 ff ff call 10bdc0 <_TOD_Validate>
10c9ef: 83 c4 10 add $0x10,%esp
10c9f2: 84 c0 test %al,%al
10c9f4: 75 0a jne 10ca00 <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;
10c9f6: b8 14 00 00 00 mov $0x14,%eax
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c9fb: 8b 5d fc mov -0x4(%ebp),%ebx
10c9fe: c9 leave
10c9ff: c3 ret
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
10ca00: 83 ec 0c sub $0xc,%esp
10ca03: 53 push %ebx
10ca04: e8 2b f3 ff ff call 10bd34 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
10ca09: 83 c4 10 add $0x10,%esp
10ca0c: 3b 05 48 ab 12 00 cmp 0x12ab48,%eax
10ca12: 76 e2 jbe 10c9f6 <rtems_task_wake_when+0x36>
10ca14: 8b 15 b0 aa 12 00 mov 0x12aab0,%edx
10ca1a: 42 inc %edx
10ca1b: 89 15 b0 aa 12 00 mov %edx,0x12aab0
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
10ca21: 83 ec 08 sub $0x8,%esp
10ca24: 6a 10 push $0x10
10ca26: ff 35 58 b0 12 00 pushl 0x12b058
10ca2c: 89 45 f4 mov %eax,-0xc(%ebp)
10ca2f: e8 ec 26 00 00 call 10f120 <_Thread_Set_state>
_Watchdog_Initialize(
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
10ca34: 8b 15 58 b0 12 00 mov 0x12b058,%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(
10ca3a: 8b 4a 08 mov 0x8(%edx),%ecx
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10ca3d: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx)
the_watchdog->routine = routine;
10ca44: c7 42 64 4c e7 10 00 movl $0x10e74c,0x64(%edx)
the_watchdog->id = id;
10ca4b: 89 4a 68 mov %ecx,0x68(%edx)
the_watchdog->user_data = user_data;
10ca4e: 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(
10ca55: 8b 45 f4 mov -0xc(%ebp),%eax
10ca58: 2b 05 48 ab 12 00 sub 0x12ab48,%eax
10ca5e: 89 42 54 mov %eax,0x54(%edx)
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
10ca61: 58 pop %eax
10ca62: 59 pop %ecx
10ca63: 83 c2 48 add $0x48,%edx
10ca66: 52 push %edx
10ca67: 68 74 ab 12 00 push $0x12ab74
10ca6c: e8 77 2c 00 00 call 10f6e8 <_Watchdog_Insert>
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
10ca71: e8 8a 1e 00 00 call 10e900 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10ca76: 83 c4 10 add $0x10,%esp
10ca79: 31 c0 xor %eax,%eax
10ca7b: e9 7b ff ff ff jmp 10c9fb <rtems_task_wake_when+0x3b>
)
{
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
10ca80: b8 0b 00 00 00 mov $0xb,%eax
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10ca85: 8b 5d fc mov -0x4(%ebp),%ebx
10ca88: c9 leave
10ca89: c3 ret
10ca8a: 66 90 xchg %ax,%ax
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
10ca8c: b8 09 00 00 00 mov $0x9,%eax
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10ca91: 8b 5d fc mov -0x4(%ebp),%ebx
10ca94: c9 leave
10ca95: c3 ret
0010a8cc <rtems_termios_baud_to_index>:
#include <rtems/termiostypes.h>
int rtems_termios_baud_to_index(
rtems_termios_baud_t termios_baud
)
{
10a8cc: 55 push %ebp
10a8cd: 89 e5 mov %esp,%ebp
10a8cf: 8b 45 08 mov 0x8(%ebp),%eax
int baud_index;
switch (termios_baud) {
10a8d2: 83 f8 09 cmp $0x9,%eax
10a8d5: 0f 84 f1 00 00 00 je 10a9cc <rtems_termios_baud_to_index+0x100>
10a8db: 7e 37 jle 10a914 <rtems_termios_baud_to_index+0x48>
10a8dd: 83 f8 0e cmp $0xe,%eax
10a8e0: 0f 84 f6 00 00 00 je 10a9dc <rtems_termios_baud_to_index+0x110>
10a8e6: 7e 5c jle 10a944 <rtems_termios_baud_to_index+0x78>
10a8e8: 3d 02 10 00 00 cmp $0x1002,%eax
10a8ed: 0f 84 01 01 00 00 je 10a9f4 <rtems_termios_baud_to_index+0x128>
10a8f3: 0f 8e 97 00 00 00 jle 10a990 <rtems_termios_baud_to_index+0xc4>
10a8f9: 3d 03 10 00 00 cmp $0x1003,%eax
10a8fe: 0f 84 e0 00 00 00 je 10a9e4 <rtems_termios_baud_to_index+0x118>
10a904: 3d 04 10 00 00 cmp $0x1004,%eax
10a909: 75 51 jne 10a95c <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;
10a90b: b8 13 00 00 00 mov $0x13,%eax
default: baud_index = -1; break;
}
return baud_index;
}
10a910: c9 leave
10a911: c3 ret
10a912: 66 90 xchg %ax,%ax
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
10a914: 83 f8 04 cmp $0x4,%eax
10a917: 0f 84 b7 00 00 00 je 10a9d4 <rtems_termios_baud_to_index+0x108>
10a91d: 7f 45 jg 10a964 <rtems_termios_baud_to_index+0x98>
10a91f: 83 f8 01 cmp $0x1,%eax
10a922: 0f 84 8c 00 00 00 je 10a9b4 <rtems_termios_baud_to_index+0xe8>
10a928: 0f 8e de 00 00 00 jle 10aa0c <rtems_termios_baud_to_index+0x140>
10a92e: 83 f8 02 cmp $0x2,%eax
10a931: 0f 84 c5 00 00 00 je 10a9fc <rtems_termios_baud_to_index+0x130>
10a937: 83 f8 03 cmp $0x3,%eax
10a93a: 75 20 jne 10a95c <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;
10a93c: b8 03 00 00 00 mov $0x3,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10a941: c9 leave
10a942: c3 ret
10a943: 90 nop
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
10a944: 83 f8 0b cmp $0xb,%eax
10a947: 0f 84 9f 00 00 00 je 10a9ec <rtems_termios_baud_to_index+0x120>
10a94d: 7c 39 jl 10a988 <rtems_termios_baud_to_index+0xbc>
10a94f: 83 f8 0c cmp $0xc,%eax
10a952: 74 50 je 10a9a4 <rtems_termios_baud_to_index+0xd8>
10a954: 83 f8 0d cmp $0xd,%eax
10a957: 74 62 je 10a9bb <rtems_termios_baud_to_index+0xef><== ALWAYS TAKEN
10a959: 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;
10a95c: b8 ff ff ff ff mov $0xffffffff,%eax
}
return baud_index;
}
10a961: c9 leave
10a962: c3 ret
10a963: 90 nop
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
10a964: 83 f8 06 cmp $0x6,%eax
10a967: 74 43 je 10a9ac <rtems_termios_baud_to_index+0xe0>
10a969: 7c 15 jl 10a980 <rtems_termios_baud_to_index+0xb4>
10a96b: 83 f8 07 cmp $0x7,%eax
10a96e: 0f 84 90 00 00 00 je 10aa04 <rtems_termios_baud_to_index+0x138>
10a974: 83 f8 08 cmp $0x8,%eax
10a977: 75 e3 jne 10a95c <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;
10a979: b8 08 00 00 00 mov $0x8,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10a97e: c9 leave
10a97f: 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;
10a980: b8 05 00 00 00 mov $0x5,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10a985: c9 leave
10a986: c3 ret
10a987: 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;
10a988: b8 0a 00 00 00 mov $0xa,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10a98d: c9 leave
10a98e: c3 ret
10a98f: 90 nop
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
10a990: 83 f8 0f cmp $0xf,%eax
10a993: 74 2f je 10a9c4 <rtems_termios_baud_to_index+0xf8>
10a995: 3d 01 10 00 00 cmp $0x1001,%eax
10a99a: 75 c0 jne 10a95c <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;
10a99c: b8 10 00 00 00 mov $0x10,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10a9a1: c9 leave
10a9a2: c3 ret
10a9a3: 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;
10a9a4: b8 0c 00 00 00 mov $0xc,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10a9a9: c9 leave
10a9aa: c3 ret
10a9ab: 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;
10a9ac: b8 06 00 00 00 mov $0x6,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10a9b1: c9 leave
10a9b2: c3 ret
10a9b3: 90 nop
{
int baud_index;
switch (termios_baud) {
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
10a9b4: b8 01 00 00 00 mov $0x1,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10a9b9: c9 leave
10a9ba: 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;
10a9bb: b8 0d 00 00 00 mov $0xd,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10a9c0: c9 leave
10a9c1: c3 ret
10a9c2: 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;
10a9c4: b8 0f 00 00 00 mov $0xf,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10a9c9: c9 leave
10a9ca: c3 ret
10a9cb: 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;
10a9cc: b8 09 00 00 00 mov $0x9,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10a9d1: c9 leave
10a9d2: c3 ret
10a9d3: 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;
10a9d4: b8 04 00 00 00 mov $0x4,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10a9d9: c9 leave
10a9da: c3 ret
10a9db: 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;
10a9dc: b8 0e 00 00 00 mov $0xe,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10a9e1: c9 leave
10a9e2: c3 ret
10a9e3: 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;
10a9e4: b8 12 00 00 00 mov $0x12,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10a9e9: c9 leave
10a9ea: c3 ret
10a9eb: 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;
10a9ec: b8 0b 00 00 00 mov $0xb,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10a9f1: c9 leave
10a9f2: c3 ret
10a9f3: 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;
10a9f4: b8 11 00 00 00 mov $0x11,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10a9f9: c9 leave
10a9fa: c3 ret
10a9fb: 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;
10a9fc: b8 02 00 00 00 mov $0x2,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10aa01: c9 leave
10aa02: c3 ret
10aa03: 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;
10aa04: b8 07 00 00 00 mov $0x7,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10aa09: c9 leave
10aa0a: c3 ret
10aa0b: 90 nop
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
10aa0c: 85 c0 test %eax,%eax
10aa0e: 0f 85 48 ff ff ff jne 10a95c <rtems_termios_baud_to_index+0x90>
case B0: baud_index = 0; break;
10aa14: 31 c0 xor %eax,%eax
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
}
return baud_index;
}
10aa16: c9 leave
10aa17: c3 ret
00108f38 <rtems_termios_baud_to_number>:
extern rtems_assoc_t termios_assoc_table[];
int32_t rtems_termios_baud_to_number(
int termios_baud
)
{
108f38: 55 push %ebp
108f39: 89 e5 mov %esp,%ebp
108f3b: 53 push %ebx
108f3c: 83 ec 0c sub $0xc,%esp
108f3f: 8b 5d 08 mov 0x8(%ebp),%ebx
int baud;
baud = rtems_assoc_local_by_remote( termios_assoc_table, termios_baud );
108f42: 53 push %ebx
108f43: 68 80 58 12 00 push $0x125880
108f48: e8 73 6c 00 00 call 10fbc0 <rtems_assoc_local_by_remote>
if ( baud == 0 && termios_baud != 0 )
108f4d: 83 c4 10 add $0x10,%esp
108f50: 85 c0 test %eax,%eax
108f52: 74 08 je 108f5c <rtems_termios_baud_to_number+0x24>
return -1;
return baud;
}
108f54: 8b 5d fc mov -0x4(%ebp),%ebx
108f57: c9 leave
108f58: c3 ret
108f59: 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 )
108f5c: 83 fb 01 cmp $0x1,%ebx
108f5f: 19 c0 sbb %eax,%eax
108f61: f7 d0 not %eax
108f63: eb ef jmp 108f54 <rtems_termios_baud_to_number+0x1c>
001094bc <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
1094bc: 55 push %ebp
1094bd: 89 e5 mov %esp,%ebp
1094bf: 56 push %esi
1094c0: 53 push %ebx
1094c1: 8b 75 08 mov 0x8(%ebp),%esi
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
1094c4: 8b 06 mov (%esi),%eax
1094c6: 8b 58 34 mov 0x34(%eax),%ebx
rtems_status_code sc;
sc = rtems_semaphore_obtain(
1094c9: 52 push %edx
1094ca: 6a 00 push $0x0
1094cc: 6a 00 push $0x0
1094ce: ff 35 6c 7c 12 00 pushl 0x127c6c
1094d4: e8 d7 21 00 00 call 10b6b0 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
1094d9: 83 c4 10 add $0x10,%esp
1094dc: 85 c0 test %eax,%eax
1094de: 0f 85 9a 01 00 00 jne 10967e <rtems_termios_close+0x1c2><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
1094e4: 8b 43 08 mov 0x8(%ebx),%eax
1094e7: 48 dec %eax
1094e8: 89 43 08 mov %eax,0x8(%ebx)
1094eb: 85 c0 test %eax,%eax
1094ed: 0f 85 bf 00 00 00 jne 1095b2 <rtems_termios_close+0xf6>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
1094f3: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
1094f9: c1 e0 05 shl $0x5,%eax
1094fc: 8b 80 04 79 12 00 mov 0x127904(%eax),%eax
109502: 85 c0 test %eax,%eax
109504: 0f 84 0a 01 00 00 je 109614 <rtems_termios_close+0x158>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
10950a: 83 ec 0c sub $0xc,%esp
10950d: 53 push %ebx
10950e: ff d0 call *%eax
109510: 83 c4 10 add $0x10,%esp
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
109513: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
10951a: 0f 84 2c 01 00 00 je 10964c <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)
109520: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax
109526: 85 c0 test %eax,%eax
109528: 74 0d je 109537 <rtems_termios_close+0x7b>
(*tty->device.lastClose)(tty->major, tty->minor, arg);
10952a: 51 push %ecx
10952b: 56 push %esi
10952c: ff 73 10 pushl 0x10(%ebx)
10952f: ff 73 0c pushl 0xc(%ebx)
109532: ff d0 call *%eax
109534: 83 c4 10 add $0x10,%esp
if (tty->forw == NULL) {
109537: 8b 03 mov (%ebx),%eax
109539: 85 c0 test %eax,%eax
10953b: 0f 84 b7 00 00 00 je 1095f8 <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;
109541: 8b 53 04 mov 0x4(%ebx),%edx
109544: 89 50 04 mov %edx,0x4(%eax)
109547: 8b 53 04 mov 0x4(%ebx),%edx
}
if (tty->back == NULL) {
10954a: 85 d2 test %edx,%edx
10954c: 0f 84 8a 00 00 00 je 1095dc <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;
109552: 89 02 mov %eax,(%edx)
}
rtems_semaphore_delete (tty->isem);
109554: 83 ec 0c sub $0xc,%esp
109557: ff 73 14 pushl 0x14(%ebx)
10955a: e8 ad 20 00 00 call 10b60c <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
10955f: 5a pop %edx
109560: ff 73 18 pushl 0x18(%ebx)
109563: e8 a4 20 00 00 call 10b60c <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
109568: 58 pop %eax
109569: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
10956f: e8 98 20 00 00 call 10b60c <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
109574: 83 c4 10 add $0x10,%esp
109577: 8b b3 a0 00 00 00 mov 0xa0(%ebx),%esi
10957d: 85 f6 test %esi,%esi
10957f: 74 4b je 1095cc <rtems_termios_close+0x110>
109581: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
109588: 74 42 je 1095cc <rtems_termios_close+0x110>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
free (tty->rawInBuf.theBuf);
10958a: 83 ec 0c sub $0xc,%esp
10958d: ff 73 58 pushl 0x58(%ebx)
109590: e8 1f eb ff ff call 1080b4 <free>
free (tty->rawOutBuf.theBuf);
109595: 59 pop %ecx
109596: ff 73 7c pushl 0x7c(%ebx)
109599: e8 16 eb ff ff call 1080b4 <free>
free (tty->cbuf);
10959e: 5a pop %edx
10959f: ff 73 1c pushl 0x1c(%ebx)
1095a2: e8 0d eb ff ff call 1080b4 <free>
free (tty);
1095a7: 89 1c 24 mov %ebx,(%esp)
1095aa: e8 05 eb ff ff call 1080b4 <free>
1095af: 83 c4 10 add $0x10,%esp
}
rtems_semaphore_release (rtems_termios_ttyMutex);
1095b2: 83 ec 0c sub $0xc,%esp
1095b5: ff 35 6c 7c 12 00 pushl 0x127c6c
1095bb: e8 ec 21 00 00 call 10b7ac <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
1095c0: 31 c0 xor %eax,%eax
1095c2: 8d 65 f8 lea -0x8(%ebp),%esp
1095c5: 5b pop %ebx
1095c6: 5e pop %esi
1095c7: c9 leave
1095c8: c3 ret
1095c9: 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);
1095cc: 83 ec 0c sub $0xc,%esp
1095cf: ff 73 68 pushl 0x68(%ebx)
1095d2: e8 35 20 00 00 call 10b60c <rtems_semaphore_delete>
1095d7: 83 c4 10 add $0x10,%esp
1095da: eb ae jmp 10958a <rtems_termios_close+0xce>
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
1095dc: a3 74 7c 12 00 mov %eax,0x127c74
if ( rtems_termios_ttyHead != NULL ) {
1095e1: 85 c0 test %eax,%eax
1095e3: 0f 84 6b ff ff ff je 109554 <rtems_termios_close+0x98>
rtems_termios_ttyHead->back = NULL;
1095e9: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
1095f0: e9 5f ff ff ff jmp 109554 <rtems_termios_close+0x98>
1095f5: 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;
1095f8: 8b 53 04 mov 0x4(%ebx),%edx
1095fb: 89 15 70 7c 12 00 mov %edx,0x127c70
if ( rtems_termios_ttyTail != NULL ) {
109601: 85 d2 test %edx,%edx
109603: 74 d7 je 1095dc <rtems_termios_close+0x120>
rtems_termios_ttyTail->forw = NULL;
109605: c7 02 00 00 00 00 movl $0x0,(%edx)
10960b: 8b 03 mov (%ebx),%eax
10960d: e9 40 ff ff ff jmp 109552 <rtems_termios_close+0x96>
109612: 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);
109614: 50 push %eax
109615: 6a 00 push $0x0
109617: 6a 00 push $0x0
109619: ff 73 18 pushl 0x18(%ebx)
10961c: e8 8f 20 00 00 call 10b6b0 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
109621: 83 c4 10 add $0x10,%esp
109624: 85 c0 test %eax,%eax
109626: 75 56 jne 10967e <rtems_termios_close+0x1c2><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
109628: 89 d8 mov %ebx,%eax
10962a: e8 75 f9 ff ff call 108fa4 <drainOutput>
rtems_semaphore_release (tty->osem);
10962f: 83 ec 0c sub $0xc,%esp
109632: ff 73 18 pushl 0x18(%ebx)
109635: e8 72 21 00 00 call 10b7ac <rtems_semaphore_release>
10963a: 83 c4 10 add $0x10,%esp
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
10963d: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
109644: 0f 85 d6 fe ff ff jne 109520 <rtems_termios_close+0x64>
10964a: 66 90 xchg %ax,%ax
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
10964c: 83 ec 08 sub $0x8,%esp
10964f: 6a 01 push $0x1
109651: ff b3 c4 00 00 00 pushl 0xc4(%ebx)
109657: e8 40 1b 00 00 call 10b19c <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
10965c: 83 c4 10 add $0x10,%esp
10965f: 85 c0 test %eax,%eax
109661: 75 1b jne 10967e <rtems_termios_close+0x1c2><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
109663: 83 ec 08 sub $0x8,%esp
109666: 6a 01 push $0x1
109668: ff b3 c8 00 00 00 pushl 0xc8(%ebx)
10966e: e8 29 1b 00 00 call 10b19c <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
109673: 83 c4 10 add $0x10,%esp
109676: 85 c0 test %eax,%eax
109678: 0f 84 a2 fe ff ff je 109520 <rtems_termios_close+0x64><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
10967e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109681: 50 push %eax <== NOT EXECUTED
109682: e8 6d 26 00 00 call 10bcf4 <rtems_fatal_error_occurred><== NOT EXECUTED
0010ab64 <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)
{
10ab64: 55 push %ebp
10ab65: 89 e5 mov %esp,%ebp
10ab67: 83 ec 08 sub $0x8,%esp
10ab6a: 8b 45 08 mov 0x8(%ebp),%eax
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
10ab6d: 8b 55 0c mov 0xc(%ebp),%edx
10ab70: 01 90 90 00 00 00 add %edx,0x90(%eax)
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
10ab76: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax)
10ab7d: 74 2d je 10abac <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 ) {
10ab7f: 83 b8 cc 00 00 00 05 cmpl $0x5,0xcc(%eax)
10ab86: 74 0c je 10ab94 <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);
10ab88: 89 45 08 mov %eax,0x8(%ebp)
}
10ab8b: c9 leave
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
10ab8c: e9 27 fd ff ff jmp 10a8b8 <rtems_termios_refill_transmitter>
10ab91: 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) {
10ab94: 8b 15 b4 79 12 00 mov 0x1279b4,%edx
10ab9a: 85 d2 test %edx,%edx
10ab9c: 74 09 je 10aba7 <rtems_termios_dequeue_characters+0x43><== NEVER TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
10ab9e: 83 ec 0c sub $0xc,%esp
10aba1: 50 push %eax
10aba2: ff d2 call *%edx
10aba4: 83 c4 10 add $0x10,%esp
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
}
10aba7: 31 c0 xor %eax,%eax
10aba9: c9 leave
10abaa: c3 ret
10abab: 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);
10abac: 83 ec 08 sub $0x8,%esp
10abaf: 6a 02 push $0x2
10abb1: ff b0 c8 00 00 00 pushl 0xc8(%eax)
10abb7: e8 e0 05 00 00 call 10b19c <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
10abbc: 83 c4 10 add $0x10,%esp
10abbf: 85 c0 test %eax,%eax
10abc1: 74 e4 je 10aba7 <rtems_termios_dequeue_characters+0x43><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
10abc3: 83 ec 0c sub $0xc,%esp
10abc6: 50 push %eax <== NOT EXECUTED
10abc7: e8 28 11 00 00 call 10bcf4 <rtems_fatal_error_occurred><== NOT EXECUTED
0010a540 <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)
{
10a540: 55 push %ebp
10a541: 89 e5 mov %esp,%ebp
10a543: 57 push %edi
10a544: 56 push %esi
10a545: 53 push %ebx
10a546: 83 ec 3c sub $0x3c,%esp
10a549: 8b 5d 08 mov 0x8(%ebp),%ebx
10a54c: 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) {
10a54f: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
10a555: c1 e0 05 shl $0x5,%eax
10a558: 8b 80 10 79 12 00 mov 0x127910(%eax),%eax
10a55e: 85 c0 test %eax,%eax
10a560: 0f 84 8a 00 00 00 je 10a5f0 <rtems_termios_enqueue_raw_characters+0xb0>
while (len--) {
10a566: 8b 4d 10 mov 0x10(%ebp),%ecx
10a569: 85 c9 test %ecx,%ecx
10a56b: 74 2a je 10a597 <rtems_termios_enqueue_raw_characters+0x57><== NEVER TAKEN
10a56d: 31 ff xor %edi,%edi
10a56f: eb 12 jmp 10a583 <rtems_termios_enqueue_raw_characters+0x43>
10a571: 8d 76 00 lea 0x0(%esi),%esi
10a574: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
10a57a: c1 e0 05 shl $0x5,%eax
10a57d: 8b 80 10 79 12 00 mov 0x127910(%eax),%eax
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
10a583: 83 ec 08 sub $0x8,%esp
10a586: 53 push %ebx
10a587: 0f be 14 3e movsbl (%esi,%edi,1),%edx
10a58b: 52 push %edx
10a58c: ff d0 call *%eax
10a58e: 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--) {
10a58f: 83 c4 10 add $0x10,%esp
10a592: 3b 7d 10 cmp 0x10(%ebp),%edi
10a595: 75 dd jne 10a574 <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 )) {
10a597: 8b 93 e4 00 00 00 mov 0xe4(%ebx),%edx
10a59d: 85 d2 test %edx,%edx
10a59f: 75 3b jne 10a5dc <rtems_termios_enqueue_raw_characters+0x9c><== NEVER TAKEN
10a5a1: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax
10a5a7: 85 c0 test %eax,%eax
10a5a9: 74 31 je 10a5dc <rtems_termios_enqueue_raw_characters+0x9c><== NEVER TAKEN
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
10a5ab: 83 ec 08 sub $0x8,%esp
10a5ae: ff b3 e0 00 00 00 pushl 0xe0(%ebx)
10a5b4: 8d 53 30 lea 0x30(%ebx),%edx
10a5b7: 52 push %edx
10a5b8: ff d0 call *%eax
tty->tty_rcvwakeup = 1;
10a5ba: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx)
10a5c1: 00 00 00
10a5c4: 83 c4 10 add $0x10,%esp
}
return 0;
10a5c7: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
}
tty->rawInBufDropped += dropped;
rtems_semaphore_release (tty->rawInBuf.Semaphore);
return dropped;
}
10a5ce: 8b 45 e0 mov -0x20(%ebp),%eax
10a5d1: 8d 65 f4 lea -0xc(%ebp),%esp
10a5d4: 5b pop %ebx
10a5d5: 5e pop %esi
10a5d6: 5f pop %edi
10a5d7: c9 leave
10a5d8: c3 ret
10a5d9: 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;
10a5dc: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
}
tty->rawInBufDropped += dropped;
rtems_semaphore_release (tty->rawInBuf.Semaphore);
return dropped;
}
10a5e3: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
10a5e6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10a5e9: 5b pop %ebx <== NOT EXECUTED
10a5ea: 5e pop %esi <== NOT EXECUTED
10a5eb: 5f pop %edi <== NOT EXECUTED
10a5ec: c9 leave <== NOT EXECUTED
10a5ed: c3 ret <== NOT EXECUTED
10a5ee: 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) {
10a5f0: 8b 7d 10 mov 0x10(%ebp),%edi
10a5f3: c6 45 db 00 movb $0x0,-0x25(%ebp)
10a5f7: 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);
10a5fe: 8d 43 30 lea 0x30(%ebx),%eax
10a601: 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,
10a604: 8d 53 4a lea 0x4a(%ebx),%edx
10a607: 89 55 cc mov %edx,-0x34(%ebp)
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
10a60a: 85 ff test %edi,%edi
10a60c: 0f 84 0b 01 00 00 je 10a71d <rtems_termios_enqueue_raw_characters+0x1dd><== NEVER TAKEN
10a612: 66 90 xchg %ax,%ax
c = *buf++;
10a614: 8a 06 mov (%esi),%al
10a616: 88 45 e7 mov %al,-0x19(%ebp)
10a619: 46 inc %esi
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
10a61a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10a620: f6 c4 02 test $0x2,%ah
10a623: 74 1c je 10a641 <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]) {
10a625: 0f be 45 e7 movsbl -0x19(%ebp),%eax
10a629: 0f b6 53 4a movzbl 0x4a(%ebx),%edx
10a62d: 39 d0 cmp %edx,%eax
10a62f: 0f 84 07 01 00 00 je 10a73c <rtems_termios_enqueue_raw_characters+0x1fc>
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
10a635: 0f b6 53 49 movzbl 0x49(%ebx),%edx
10a639: 39 d0 cmp %edx,%eax
10a63b: 0f 84 4f 01 00 00 je 10a790 <rtems_termios_enqueue_raw_characters+0x250><== NEVER TAKEN
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
flow_rcv = true;
}
}
if (flow_rcv) {
10a641: 80 7d db 00 cmpb $0x0,-0x25(%ebp)
10a645: 0f 85 0c 01 00 00 jne 10a757 <rtems_termios_enqueue_raw_characters+0x217><== NEVER TAKEN
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
10a64b: 8b 43 60 mov 0x60(%ebx),%eax
10a64e: 8b 53 64 mov 0x64(%ebx),%edx
10a651: 89 55 dc mov %edx,-0x24(%ebp)
10a654: 40 inc %eax
10a655: 31 d2 xor %edx,%edx
10a657: f7 75 dc divl -0x24(%ebp)
10a65a: 89 d1 mov %edx,%ecx
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
10a65c: 9c pushf
10a65d: fa cli
10a65e: 8f 45 d4 popl -0x2c(%ebp)
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
10a661: 8b 43 5c mov 0x5c(%ebx),%eax
10a664: 89 45 c4 mov %eax,-0x3c(%ebp)
10a667: 8b 43 64 mov 0x64(%ebx),%eax
% tty->rawInBuf.Size) > tty->highwater) &&
10a66a: 8b 53 64 mov 0x64(%ebx),%edx
10a66d: 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)
10a670: 2b 45 c4 sub -0x3c(%ebp),%eax
10a673: 01 c8 add %ecx,%eax
% tty->rawInBuf.Size) > tty->highwater) &&
10a675: 31 d2 xor %edx,%edx
10a677: 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)
10a67a: 3b 93 c0 00 00 00 cmp 0xc0(%ebx),%edx
10a680: 76 46 jbe 10a6c8 <rtems_termios_enqueue_raw_characters+0x188><== ALWAYS TAKEN
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
10a682: 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) &&
10a688: a8 01 test $0x1,%al <== NOT EXECUTED
10a68a: 75 3c jne 10a6c8 <rtems_termios_enqueue_raw_characters+0x188><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
10a68c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10a692: 83 c8 01 or $0x1,%eax <== NOT EXECUTED
10a695: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
10a69b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10a6a1: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED
10a6a6: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED
10a6ab: 0f 84 22 01 00 00 je 10a7d3 <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) ) {
10a6b1: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10a6b7: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED
10a6bc: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED
10a6c1: 0f 84 50 01 00 00 je 10a817 <rtems_termios_enqueue_raw_characters+0x2d7><== NOT EXECUTED
10a6c7: 90 nop <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
10a6c8: ff 75 d4 pushl -0x2c(%ebp)
10a6cb: 9d popf
if (newTail == tty->rawInBuf.Head) {
10a6cc: 8b 43 5c mov 0x5c(%ebx),%eax
10a6cf: 39 c8 cmp %ecx,%eax
10a6d1: 0f 84 b1 00 00 00 je 10a788 <rtems_termios_enqueue_raw_characters+0x248><== NEVER TAKEN
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
10a6d7: 8b 43 58 mov 0x58(%ebx),%eax
10a6da: 8a 55 e7 mov -0x19(%ebp),%dl
10a6dd: 88 14 08 mov %dl,(%eax,%ecx,1)
tty->rawInBuf.Tail = newTail;
10a6e0: 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 )) {
10a6e3: 8b 83 e4 00 00 00 mov 0xe4(%ebx),%eax
10a6e9: 85 c0 test %eax,%eax
10a6eb: 75 27 jne 10a714 <rtems_termios_enqueue_raw_characters+0x1d4><== NEVER TAKEN
10a6ed: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax
10a6f3: 85 c0 test %eax,%eax
10a6f5: 74 1d je 10a714 <rtems_termios_enqueue_raw_characters+0x1d4><== ALWAYS TAKEN
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
10a6f7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10a6fa: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED
10a700: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED
10a703: ff d0 call *%eax <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
10a705: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED
10a70c: 00 00 00
10a70f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a712: 66 90 xchg %ax,%ax <== NOT EXECUTED
10a714: 4f dec %edi
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
10a715: 85 ff test %edi,%edi
10a717: 0f 85 f7 fe ff ff jne 10a614 <rtems_termios_enqueue_raw_characters+0xd4><== NEVER TAKEN
}
}
}
}
tty->rawInBufDropped += dropped;
10a71d: 8b 45 e0 mov -0x20(%ebp),%eax
10a720: 01 43 78 add %eax,0x78(%ebx)
rtems_semaphore_release (tty->rawInBuf.Semaphore);
10a723: 83 ec 0c sub $0xc,%esp
10a726: ff 73 68 pushl 0x68(%ebx)
10a729: e8 7e 10 00 00 call 10b7ac <rtems_semaphore_release>
return dropped;
10a72e: 83 c4 10 add $0x10,%esp
}
10a731: 8b 45 e0 mov -0x20(%ebp),%eax
10a734: 8d 65 f4 lea -0xc(%ebp),%esp
10a737: 5b pop %ebx
10a738: 5e pop %esi
10a739: 5f pop %edi
10a73a: c9 leave
10a73b: 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]) {
10a73c: 0f b6 53 49 movzbl 0x49(%ebx),%edx
10a740: 39 d0 cmp %edx,%eax
10a742: 74 7e je 10a7c2 <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;
10a744: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10a74a: 83 c8 10 or $0x10,%eax
10a74d: 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--) {
10a753: 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) {
10a757: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10a75d: 83 e0 30 and $0x30,%eax
10a760: 83 f8 20 cmp $0x20,%eax
10a763: 75 af jne 10a714 <rtems_termios_enqueue_raw_characters+0x1d4><== ALWAYS TAKEN
/* disable interrupts */
rtems_interrupt_disable(level);
10a765: 9c pushf <== NOT EXECUTED
10a766: fa cli <== NOT EXECUTED
10a767: 5a pop %edx <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
10a768: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10a76e: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
10a771: 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) {
10a777: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax <== NOT EXECUTED
10a77d: 85 c0 test %eax,%eax <== NOT EXECUTED
10a77f: 75 20 jne 10a7a1 <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);
10a781: 52 push %edx <== NOT EXECUTED
10a782: 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;
10a783: 4f dec %edi <== NOT EXECUTED
10a784: eb 8f jmp 10a715 <rtems_termios_enqueue_raw_characters+0x1d5><== NOT EXECUTED
10a786: 66 90 xchg %ax,%ax <== NOT EXECUTED
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
dropped++;
10a788: 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;
10a78b: 4f dec %edi <== NOT EXECUTED
10a78c: eb 87 jmp 10a715 <rtems_termios_enqueue_raw_characters+0x1d5><== NOT EXECUTED
10a78e: 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;
10a790: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10a796: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED
10a799: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
10a79f: eb b2 jmp 10a753 <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);
10a7a1: 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)(
10a7a7: 51 push %ecx <== NOT EXECUTED
10a7a8: 6a 01 push $0x1 <== NOT EXECUTED
10a7aa: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED
10a7ad: 50 push %eax <== NOT EXECUTED
10a7ae: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10a7b1: 89 55 c8 mov %edx,-0x38(%ebp) <== NOT EXECUTED
10a7b4: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
10a7ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a7bd: 8b 55 c8 mov -0x38(%ebp),%edx <== NOT EXECUTED
10a7c0: eb bf jmp 10a781 <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;
10a7c2: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10a7c8: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED
10a7cb: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
10a7d1: eb 80 jmp 10a753 <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) ||
10a7d3: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10a7d9: a8 20 test $0x20,%al <== NOT EXECUTED
10a7db: 75 0e jne 10a7eb <rtems_termios_enqueue_raw_characters+0x2ab><== NOT EXECUTED
10a7dd: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax <== NOT EXECUTED
10a7e3: 85 c0 test %eax,%eax <== NOT EXECUTED
10a7e5: 0f 85 dd fe ff ff jne 10a6c8 <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;
10a7eb: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10a7f1: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
10a7f4: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
(*tty->device.write)(tty->minor,
10a7fa: 52 push %edx <== NOT EXECUTED
10a7fb: 6a 01 push $0x1 <== NOT EXECUTED
10a7fd: ff 75 cc pushl -0x34(%ebp) <== NOT EXECUTED
10a800: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10a803: 89 4d c8 mov %ecx,-0x38(%ebp) <== NOT EXECUTED
10a806: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
10a80c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a80f: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED
10a812: e9 b1 fe ff ff jmp 10a6c8 <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;
10a817: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10a81d: 83 c8 04 or $0x4,%eax <== NOT EXECUTED
10a820: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
10a826: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax <== NOT EXECUTED
10a82c: 85 c0 test %eax,%eax <== NOT EXECUTED
10a82e: 0f 84 94 fe ff ff je 10a6c8 <rtems_termios_enqueue_raw_characters+0x188><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
10a834: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a837: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10a83a: 89 4d c8 mov %ecx,-0x38(%ebp) <== NOT EXECUTED
10a83d: ff d0 call *%eax <== NOT EXECUTED
10a83f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a842: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED
10a845: e9 7e fe ff ff jmp 10a6c8 <rtems_termios_enqueue_raw_characters+0x188><== NOT EXECUTED
00108f68 <rtems_termios_initialize>:
struct rtems_termios_tty *rtems_termios_ttyTail;
rtems_id rtems_termios_ttyMutex;
void
rtems_termios_initialize (void)
{
108f68: 55 push %ebp
108f69: 89 e5 mov %esp,%ebp
108f6b: 83 ec 08 sub $0x8,%esp
rtems_status_code sc;
/*
* Create the mutex semaphore for the tty list
*/
if (!rtems_termios_ttyMutex) {
108f6e: a1 6c 7c 12 00 mov 0x127c6c,%eax
108f73: 85 c0 test %eax,%eax
108f75: 74 05 je 108f7c <rtems_termios_initialize+0x14>
RTEMS_NO_PRIORITY,
&rtems_termios_ttyMutex);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
}
108f77: c9 leave
108f78: c3 ret
108f79: 8d 76 00 lea 0x0(%esi),%esi
/*
* Create the mutex semaphore for the tty list
*/
if (!rtems_termios_ttyMutex) {
sc = rtems_semaphore_create (
108f7c: 83 ec 0c sub $0xc,%esp
108f7f: 68 6c 7c 12 00 push $0x127c6c
108f84: 6a 00 push $0x0
108f86: 6a 54 push $0x54
108f88: 6a 01 push $0x1
108f8a: 68 69 6d 52 54 push $0x54526d69
108f8f: e8 a0 24 00 00 call 10b434 <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)
108f94: 83 c4 20 add $0x20,%esp
108f97: 85 c0 test %eax,%eax
108f99: 74 dc je 108f77 <rtems_termios_initialize+0xf>
rtems_fatal_error_occurred (sc);
108f9b: 83 ec 0c sub $0xc,%esp
108f9e: 50 push %eax
108f9f: e8 50 2d 00 00 call 10bcf4 <rtems_fatal_error_occurred>
001096a8 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
1096a8: 55 push %ebp
1096a9: 89 e5 mov %esp,%ebp
1096ab: 57 push %edi
1096ac: 56 push %esi
1096ad: 53 push %ebx
1096ae: 83 ec 20 sub $0x20,%esp
1096b1: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
1096b4: 8b 03 mov (%ebx),%eax
1096b6: 8b 40 34 mov 0x34(%eax),%eax
1096b9: 89 45 e4 mov %eax,-0x1c(%ebp)
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
1096bc: 8b 73 08 mov 0x8(%ebx),%esi
rtems_status_code sc;
args->ioctl_return = 0;
1096bf: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
1096c6: 6a 00 push $0x0
1096c8: 6a 00 push $0x0
1096ca: ff 70 18 pushl 0x18(%eax)
1096cd: e8 de 1f 00 00 call 10b6b0 <rtems_semaphore_obtain>
1096d2: 89 45 e0 mov %eax,-0x20(%ebp)
if (sc != RTEMS_SUCCESSFUL) {
1096d5: 83 c4 10 add $0x10,%esp
1096d8: 85 c0 test %eax,%eax
1096da: 75 24 jne 109700 <rtems_termios_ioctl+0x58><== NEVER TAKEN
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
1096dc: 8b 43 04 mov 0x4(%ebx),%eax
1096df: 83 f8 04 cmp $0x4,%eax
1096e2: 74 70 je 109754 <rtems_termios_ioctl+0xac>
1096e4: 77 2a ja 109710 <rtems_termios_ioctl+0x68>
1096e6: 83 f8 02 cmp $0x2,%eax
1096e9: 0f 84 9d 00 00 00 je 10978c <rtems_termios_ioctl+0xe4>
1096ef: 0f 86 3f 02 00 00 jbe 109934 <rtems_termios_ioctl+0x28c>
if (tty->device.setAttributes)
(*tty->device.setAttributes)(tty->minor, &tty->termios);
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
1096f5: 8b 45 e4 mov -0x1c(%ebp),%eax
1096f8: e8 a7 f8 ff ff call 108fa4 <drainOutput>
break;
1096fd: eb 69 jmp 109768 <rtems_termios_ioctl+0xc0>
1096ff: 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;
109700: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED
}
rtems_semaphore_release (tty->osem);
args->ioctl_return = sc;
return sc;
}
109703: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
109706: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
109709: 5b pop %ebx <== NOT EXECUTED
10970a: 5e pop %esi <== NOT EXECUTED
10970b: 5f pop %edi <== NOT EXECUTED
10970c: c9 leave <== NOT EXECUTED
10970d: c3 ret <== NOT EXECUTED
10970e: 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) {
109710: 3d 7f 66 04 40 cmp $0x4004667f,%eax
109715: 0f 84 f1 01 00 00 je 10990c <rtems_termios_ioctl+0x264><== NEVER TAKEN
10971b: 0f 87 33 02 00 00 ja 109954 <rtems_termios_ioctl+0x2ac>
109721: 83 f8 05 cmp $0x5,%eax
109724: 0f 84 ae 02 00 00 je 1099d8 <rtems_termios_ioctl+0x330>
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
10972a: 8b 55 e4 mov -0x1c(%ebp),%edx
10972d: 8b 82 cc 00 00 00 mov 0xcc(%edx),%eax
109733: c1 e0 05 shl $0x5,%eax
109736: 8b 80 18 79 12 00 mov 0x127918(%eax),%eax
10973c: 85 c0 test %eax,%eax
10973e: 0f 84 b8 02 00 00 je 1099fc <rtems_termios_ioctl+0x354><== NEVER TAKEN
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
109744: 83 ec 08 sub $0x8,%esp
109747: 53 push %ebx
109748: 52 push %edx
109749: ff d0 call *%eax
10974b: 89 45 e0 mov %eax,-0x20(%ebp)
10974e: 83 c4 10 add $0x10,%esp
109751: eb 15 jmp 109768 <rtems_termios_ioctl+0xc0>
109753: 90 nop
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
break;
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
109754: 8b 06 mov (%esi),%eax
109756: 8b 56 04 mov 0x4(%esi),%edx
109759: 8b 4d e4 mov -0x1c(%ebp),%ecx
10975c: 89 81 dc 00 00 00 mov %eax,0xdc(%ecx)
109762: 89 91 e0 00 00 00 mov %edx,0xe0(%ecx)
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
}
break;
}
rtems_semaphore_release (tty->osem);
109768: 83 ec 0c sub $0xc,%esp
10976b: 8b 45 e4 mov -0x1c(%ebp),%eax
10976e: ff 70 18 pushl 0x18(%eax)
109771: e8 36 20 00 00 call 10b7ac <rtems_semaphore_release>
args->ioctl_return = sc;
109776: 8b 55 e0 mov -0x20(%ebp),%edx
109779: 89 53 0c mov %edx,0xc(%ebx)
return sc;
10977c: 83 c4 10 add $0x10,%esp
}
10977f: 8b 45 e0 mov -0x20(%ebp),%eax
109782: 8d 65 f4 lea -0xc(%ebp),%esp
109785: 5b pop %ebx
109786: 5e pop %esi
109787: 5f pop %edi
109788: c9 leave
109789: c3 ret
10978a: 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;
10978c: 8b 73 08 mov 0x8(%ebx),%esi
10978f: 8b 4d e4 mov -0x1c(%ebp),%ecx
109792: 83 c1 30 add $0x30,%ecx
109795: 89 4d dc mov %ecx,-0x24(%ebp)
109798: b9 09 00 00 00 mov $0x9,%ecx
10979d: 8b 7d dc mov -0x24(%ebp),%edi
1097a0: 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) &&
1097a2: 8b 55 e4 mov -0x1c(%ebp),%edx
1097a5: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax
1097ab: f6 c4 02 test $0x2,%ah
1097ae: 74 44 je 1097f4 <rtems_termios_ioctl+0x14c>
1097b0: f6 42 31 04 testb $0x4,0x31(%edx)
1097b4: 75 3e jne 1097f4 <rtems_termios_ioctl+0x14c>
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
1097b6: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax
1097bc: 25 ef fd ff ff and $0xfffffdef,%eax
1097c1: 89 82 b8 00 00 00 mov %eax,0xb8(%edx)
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
1097c7: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax
1097cd: a8 20 test $0x20,%al
1097cf: 74 23 je 1097f4 <rtems_termios_ioctl+0x14c><== ALWAYS TAKEN
/* disable interrupts */
rtems_interrupt_disable(level);
1097d1: 9c pushf <== NOT EXECUTED
1097d2: fa cli <== NOT EXECUTED
1097d3: 5e pop %esi <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
1097d4: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax <== NOT EXECUTED
1097da: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
1097dd: 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) {
1097e3: 8b ba 94 00 00 00 mov 0x94(%edx),%edi <== NOT EXECUTED
1097e9: 85 ff test %edi,%edi <== NOT EXECUTED
1097eb: 0f 85 bb 02 00 00 jne 109aac <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);
1097f1: 56 push %esi <== NOT EXECUTED
1097f2: 9d popf <== NOT EXECUTED
1097f3: 90 nop <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
1097f4: 8b 4d e4 mov -0x1c(%ebp),%ecx
1097f7: 8b 81 b8 00 00 00 mov 0xb8(%ecx),%eax
1097fd: f6 c4 04 test $0x4,%ah
109800: 74 24 je 109826 <rtems_termios_ioctl+0x17e>
109802: f6 41 31 10 testb $0x10,0x31(%ecx)
109806: 75 1e jne 109826 <rtems_termios_ioctl+0x17e>
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
109808: 8b 81 b8 00 00 00 mov 0xb8(%ecx),%eax
10980e: 80 e4 fb and $0xfb,%ah
109811: 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);
109817: 8b 81 b8 00 00 00 mov 0xb8(%ecx),%eax
10981d: 83 e0 fd and $0xfffffffd,%eax
109820: 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)) {
109826: 8b 55 e4 mov -0x1c(%ebp),%edx
109829: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax
10982f: f6 c4 01 test $0x1,%ah
109832: 0f 84 bc 01 00 00 je 1099f4 <rtems_termios_ioctl+0x34c><== ALWAYS TAKEN
109838: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED
10983b: 8b 41 38 mov 0x38(%ecx),%eax <== NOT EXECUTED
10983e: 85 c0 test %eax,%eax <== NOT EXECUTED
109840: 0f 88 12 02 00 00 js 109a58 <rtems_termios_ioctl+0x3b0><== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
109846: 8b 91 b8 00 00 00 mov 0xb8(%ecx),%edx <== NOT EXECUTED
10984c: 80 e6 fe and $0xfe,%dh <== NOT EXECUTED
10984f: 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)) {
109855: 8b 91 b8 00 00 00 mov 0xb8(%ecx),%edx <== NOT EXECUTED
10985b: 83 e2 04 and $0x4,%edx <== NOT EXECUTED
10985e: 74 1b je 10987b <rtems_termios_ioctl+0x1d3><== NOT EXECUTED
109860: 8b 91 b0 00 00 00 mov 0xb0(%ecx),%edx <== NOT EXECUTED
109866: 85 d2 test %edx,%edx <== NOT EXECUTED
109868: 74 11 je 10987b <rtems_termios_ioctl+0x1d3><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
10986a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10986d: ff 71 10 pushl 0x10(%ecx) <== NOT EXECUTED
109870: ff d2 call *%edx <== NOT EXECUTED
109872: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
109875: 8b 42 38 mov 0x38(%edx),%eax <== NOT EXECUTED
109878: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
10987b: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED
10987e: 8b 91 b8 00 00 00 mov 0xb8(%ecx),%edx <== NOT EXECUTED
109884: 83 e2 fb and $0xfffffffb,%edx <== NOT EXECUTED
109887: 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) {
10988d: 85 c0 test %eax,%eax
10988f: 0f 88 c3 01 00 00 js 109a58 <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) {
109895: 8b 4d e4 mov -0x1c(%ebp),%ecx
109898: 8b 41 30 mov 0x30(%ecx),%eax
10989b: f6 c4 10 test $0x10,%ah
10989e: 74 0f je 1098af <rtems_termios_ioctl+0x207>
tty->flow_ctrl |= FL_MDXOF;
1098a0: 8b 91 b8 00 00 00 mov 0xb8(%ecx),%edx
1098a6: 80 ce 04 or $0x4,%dh
1098a9: 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) {
1098af: f6 c4 04 test $0x4,%ah
1098b2: 74 12 je 1098c6 <rtems_termios_ioctl+0x21e>
tty->flow_ctrl |= FL_MDXON;
1098b4: 8b 55 e4 mov -0x1c(%ebp),%edx
1098b7: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax
1098bd: 80 cc 02 or $0x2,%ah
1098c0: 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) {
1098c6: 8b 4d e4 mov -0x1c(%ebp),%ecx
1098c9: f6 41 3c 02 testb $0x2,0x3c(%ecx)
1098cd: 0f 84 41 01 00 00 je 109a14 <rtems_termios_ioctl+0x36c>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
1098d3: c7 41 6c 00 00 00 00 movl $0x0,0x6c(%ecx)
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
1098da: c7 41 70 00 00 00 00 movl $0x0,0x70(%ecx)
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
1098e1: c7 41 74 00 00 00 00 movl $0x0,0x74(%ecx)
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
}
}
}
if (tty->device.setAttributes)
1098e8: 8b 55 e4 mov -0x1c(%ebp),%edx
1098eb: 8b 82 a8 00 00 00 mov 0xa8(%edx),%eax
1098f1: 85 c0 test %eax,%eax
1098f3: 0f 84 6f fe ff ff je 109768 <rtems_termios_ioctl+0xc0><== NEVER TAKEN
(*tty->device.setAttributes)(tty->minor, &tty->termios);
1098f9: 83 ec 08 sub $0x8,%esp
1098fc: ff 75 dc pushl -0x24(%ebp)
1098ff: ff 72 10 pushl 0x10(%edx)
109902: ff d0 call *%eax
109904: 83 c4 10 add $0x10,%esp
109907: e9 5c fe ff ff jmp 109768 <rtems_termios_ioctl+0xc0>
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
10990c: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
10990f: 8b 42 60 mov 0x60(%edx),%eax <== NOT EXECUTED
109912: 89 d1 mov %edx,%ecx <== NOT EXECUTED
109914: 8b 52 5c mov 0x5c(%edx),%edx <== NOT EXECUTED
if ( rawnc < 0 )
109917: 29 d0 sub %edx,%eax <== NOT EXECUTED
109919: 0f 88 e9 00 00 00 js 109a08 <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;
10991f: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED
109922: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED
109925: 03 41 20 add 0x20(%ecx),%eax <== NOT EXECUTED
109928: 2b 41 24 sub 0x24(%ecx),%eax <== NOT EXECUTED
10992b: 89 02 mov %eax,(%edx) <== NOT EXECUTED
}
break;
10992d: e9 36 fe ff ff jmp 109768 <rtems_termios_ioctl+0xc0><== NOT EXECUTED
109932: 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) {
109934: 48 dec %eax
109935: 0f 85 ef fd ff ff jne 10972a <rtems_termios_ioctl+0x82><== NEVER TAKEN
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
10993b: 8b 43 08 mov 0x8(%ebx),%eax
10993e: 8b 75 e4 mov -0x1c(%ebp),%esi
109941: 83 c6 30 add $0x30,%esi
109944: b9 09 00 00 00 mov $0x9,%ecx
109949: 89 c7 mov %eax,%edi
10994b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
break;
10994d: e9 16 fe ff ff jmp 109768 <rtems_termios_ioctl+0xc0>
109952: 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) {
109954: 3d 1a 74 04 40 cmp $0x4004741a,%eax
109959: 74 69 je 1099c4 <rtems_termios_ioctl+0x31c>
10995b: 3d 1b 74 04 80 cmp $0x8004741b,%eax
109960: 0f 85 c4 fd ff ff jne 10972a <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) {
109966: 8b 55 e4 mov -0x1c(%ebp),%edx
109969: 8b 82 cc 00 00 00 mov 0xcc(%edx),%eax
10996f: c1 e0 05 shl $0x5,%eax
109972: 8b 80 04 79 12 00 mov 0x127904(%eax),%eax
109978: 85 c0 test %eax,%eax
10997a: 74 0c je 109988 <rtems_termios_ioctl+0x2e0>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
10997c: 83 ec 0c sub $0xc,%esp
10997f: 52 push %edx
109980: ff d0 call *%eax
109982: 89 45 e0 mov %eax,-0x20(%ebp)
109985: 83 c4 10 add $0x10,%esp
}
tty->t_line=*(int*)(args->buffer);
109988: 8b 43 08 mov 0x8(%ebx),%eax
10998b: 8b 00 mov (%eax),%eax
10998d: 8b 4d e4 mov -0x1c(%ebp),%ecx
109990: 89 81 cc 00 00 00 mov %eax,0xcc(%ecx)
tty->t_sc = NULL; /* ensure that no more valid data */
109996: c7 81 d0 00 00 00 00 movl $0x0,0xd0(%ecx)
10999d: 00 00 00
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
1099a0: c1 e0 05 shl $0x5,%eax
1099a3: 8b 80 00 79 12 00 mov 0x127900(%eax),%eax
1099a9: 85 c0 test %eax,%eax
1099ab: 0f 84 b7 fd ff ff je 109768 <rtems_termios_ioctl+0xc0><== NEVER TAKEN
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
1099b1: 83 ec 0c sub $0xc,%esp
1099b4: 51 push %ecx
1099b5: ff d0 call *%eax
1099b7: 89 45 e0 mov %eax,-0x20(%ebp)
1099ba: 83 c4 10 add $0x10,%esp
1099bd: e9 a6 fd ff ff jmp 109768 <rtems_termios_ioctl+0xc0>
1099c2: 66 90 xchg %ax,%ax
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
1099c4: 8b 43 08 mov 0x8(%ebx),%eax
1099c7: 8b 4d e4 mov -0x1c(%ebp),%ecx
1099ca: 8b 91 cc 00 00 00 mov 0xcc(%ecx),%edx
1099d0: 89 10 mov %edx,(%eax)
break;
1099d2: e9 91 fd ff ff jmp 109768 <rtems_termios_ioctl+0xc0>
1099d7: 90 nop
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
1099d8: 8b 06 mov (%esi),%eax
1099da: 8b 56 04 mov 0x4(%esi),%edx
1099dd: 8b 4d e4 mov -0x1c(%ebp),%ecx
1099e0: 89 81 d4 00 00 00 mov %eax,0xd4(%ecx)
1099e6: 89 91 d8 00 00 00 mov %edx,0xd8(%ecx)
break;
1099ec: e9 77 fd ff ff jmp 109768 <rtems_termios_ioctl+0xc0>
1099f1: 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)) {
1099f4: 8b 42 38 mov 0x38(%edx),%eax
1099f7: e9 91 fe ff ff jmp 10988d <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;
1099fc: c7 45 e0 0a 00 00 00 movl $0xa,-0x20(%ebp) <== NOT EXECUTED
109a03: e9 60 fd ff ff jmp 109768 <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;
109a08: 8b 51 64 mov 0x64(%ecx),%edx <== NOT EXECUTED
109a0b: 01 d0 add %edx,%eax <== NOT EXECUTED
109a0d: e9 0d ff ff ff jmp 10991f <rtems_termios_ioctl+0x277><== NOT EXECUTED
109a12: 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] *
109a14: 8b 45 e4 mov -0x1c(%ebp),%eax
109a17: 0f b6 70 46 movzbl 0x46(%eax),%esi
rtems_clock_get_ticks_per_second() / 10;
109a1b: e8 74 15 00 00 call 10af94 <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] *
109a20: 0f af c6 imul %esi,%eax
rtems_clock_get_ticks_per_second() / 10;
109a23: ba cd cc cc cc mov $0xcccccccd,%edx
109a28: f7 e2 mul %edx
109a2a: 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] *
109a2d: 8b 4d e4 mov -0x1c(%ebp),%ecx
109a30: 89 51 54 mov %edx,0x54(%ecx)
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
109a33: 80 79 46 00 cmpb $0x0,0x46(%ecx)
109a37: 74 36 je 109a6f <rtems_termios_ioctl+0x3c7>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
109a39: c7 41 6c 00 00 00 00 movl $0x0,0x6c(%ecx)
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
109a40: 89 51 70 mov %edx,0x70(%ecx)
if (tty->termios.c_cc[VMIN])
109a43: 80 79 47 00 cmpb $0x0,0x47(%ecx)
109a47: 74 49 je 109a92 <rtems_termios_ioctl+0x3ea>
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
109a49: c7 41 74 00 00 00 00 movl $0x0,0x74(%ecx)
109a50: e9 93 fe ff ff jmp 1098e8 <rtems_termios_ioctl+0x240>
109a55: 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;
109a58: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
109a5b: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax <== NOT EXECUTED
109a61: 80 cc 01 or $0x1,%ah <== NOT EXECUTED
109a64: 89 82 b8 00 00 00 mov %eax,0xb8(%edx) <== NOT EXECUTED
109a6a: e9 26 fe ff ff jmp 109895 <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]) {
109a6f: 8b 55 e4 mov -0x1c(%ebp),%edx
109a72: 80 7a 47 00 cmpb $0x0,0x47(%edx)
109a76: 74 25 je 109a9d <rtems_termios_ioctl+0x3f5><== ALWAYS TAKEN
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
109a78: c7 42 6c 00 00 00 00 movl $0x0,0x6c(%edx) <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
109a7f: c7 42 70 00 00 00 00 movl $0x0,0x70(%edx) <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
109a86: c7 42 74 00 00 00 00 movl $0x0,0x74(%edx) <== NOT EXECUTED
109a8d: e9 56 fe ff ff jmp 1098e8 <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;
109a92: 8b 45 e4 mov -0x1c(%ebp),%eax
109a95: 89 50 74 mov %edx,0x74(%eax)
109a98: e9 4b fe ff ff jmp 1098e8 <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;
109a9d: 8b 4d e4 mov -0x1c(%ebp),%ecx
109aa0: c7 41 6c 01 00 00 00 movl $0x1,0x6c(%ecx)
109aa7: e9 3c fe ff ff jmp 1098e8 <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);
109aac: 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)(
109ab2: 51 push %ecx <== NOT EXECUTED
109ab3: 6a 01 push $0x1 <== NOT EXECUTED
109ab5: 03 42 7c add 0x7c(%edx),%eax <== NOT EXECUTED
109ab8: 50 push %eax <== NOT EXECUTED
109ab9: ff 72 10 pushl 0x10(%edx) <== NOT EXECUTED
109abc: ff 92 a4 00 00 00 call *0xa4(%edx) <== NOT EXECUTED
109ac2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109ac5: e9 27 fd ff ff jmp 1097f1 <rtems_termios_ioctl+0x149><== NOT EXECUTED
0010aa84 <rtems_termios_number_to_baud>:
extern rtems_assoc_t termios_assoc_table[];
int rtems_termios_number_to_baud(
int32_t baud
)
{
10aa84: 55 push %ebp
10aa85: 89 e5 mov %esp,%ebp
10aa87: 53 push %ebx
10aa88: 83 ec 0c sub $0xc,%esp
10aa8b: 8b 5d 08 mov 0x8(%ebp),%ebx
int termios_baud;
termios_baud = rtems_assoc_remote_by_local( termios_assoc_table, baud );
10aa8e: 53 push %ebx
10aa8f: 68 c0 81 12 00 push $0x1281c0
10aa94: e8 27 6f 00 00 call 1119c0 <rtems_assoc_remote_by_local>
if ( termios_baud == 0 && baud != 0 )
10aa99: 83 c4 10 add $0x10,%esp
10aa9c: 85 c0 test %eax,%eax
10aa9e: 74 08 je 10aaa8 <rtems_termios_number_to_baud+0x24>
return -1;
return termios_baud;
}
10aaa0: 8b 5d fc mov -0x4(%ebp),%ebx
10aaa3: c9 leave
10aaa4: c3 ret
10aaa5: 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 )
10aaa8: 85 db test %ebx,%ebx
10aaaa: 74 f4 je 10aaa0 <rtems_termios_number_to_baud+0x1c>
return -1;
10aaac: b8 ff ff ff ff mov $0xffffffff,%eax
10aab1: eb ed jmp 10aaa0 <rtems_termios_number_to_baud+0x1c>
00109014 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
109014: 55 push %ebp
109015: 89 e5 mov %esp,%ebp
109017: 57 push %edi
109018: 56 push %esi
109019: 53 push %ebx
10901a: 83 ec 40 sub $0x40,%esp
10901d: 8b 55 08 mov 0x8(%ebp),%edx
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
109020: 6a 00 push $0x0
109022: 6a 00 push $0x0
109024: ff 35 6c 7c 12 00 pushl 0x127c6c
10902a: 89 55 dc mov %edx,-0x24(%ebp)
10902d: e8 7e 26 00 00 call 10b6b0 <rtems_semaphore_obtain>
109032: 89 45 e4 mov %eax,-0x1c(%ebp)
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
109035: 83 c4 10 add $0x10,%esp
109038: 85 c0 test %eax,%eax
10903a: 8b 55 dc mov -0x24(%ebp),%edx
10903d: 75 6d jne 1090ac <rtems_termios_open+0x98><== NEVER TAKEN
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
10903f: 8b 35 74 7c 12 00 mov 0x127c74,%esi
109045: 85 f6 test %esi,%esi
109047: 0f 84 a7 00 00 00 je 1090f4 <rtems_termios_open+0xe0>
10904d: 89 f3 mov %esi,%ebx
10904f: 8b 45 0c mov 0xc(%ebp),%eax
109052: eb 0a jmp 10905e <rtems_termios_open+0x4a>
109054: 8b 1b mov (%ebx),%ebx
109056: 85 db test %ebx,%ebx
109058: 0f 84 96 00 00 00 je 1090f4 <rtems_termios_open+0xe0><== ALWAYS TAKEN
if ((tty->major == major) && (tty->minor == minor))
10905e: 39 53 0c cmp %edx,0xc(%ebx)
109061: 75 f1 jne 109054 <rtems_termios_open+0x40>
109063: 39 43 10 cmp %eax,0x10(%ebx)
109066: 75 ec jne 109054 <rtems_termios_open+0x40><== NEVER TAKEN
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
109068: 8b 75 10 mov 0x10(%ebp),%esi
10906b: 8b 06 mov (%esi),%eax
10906d: 89 58 34 mov %ebx,0x34(%eax)
if (!tty->refcount++) {
109070: 8b 43 08 mov 0x8(%ebx),%eax
109073: 8d 48 01 lea 0x1(%eax),%ecx
109076: 89 4b 08 mov %ecx,0x8(%ebx)
109079: 85 c0 test %eax,%eax
10907b: 75 1e jne 10909b <rtems_termios_open+0x87>
if (tty->device.firstOpen)
10907d: 8b 83 98 00 00 00 mov 0x98(%ebx),%eax
109083: 85 c0 test %eax,%eax
109085: 74 0b je 109092 <rtems_termios_open+0x7e>
(*tty->device.firstOpen)(major, minor, arg);
109087: 57 push %edi
109088: 56 push %esi
109089: ff 75 0c pushl 0xc(%ebp)
10908c: 52 push %edx
10908d: ff d0 call *%eax
10908f: 83 c4 10 add $0x10,%esp
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
109092: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
109099: 74 1c je 1090b7 <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);
10909b: 83 ec 0c sub $0xc,%esp
10909e: ff 35 6c 7c 12 00 pushl 0x127c6c
1090a4: e8 03 27 00 00 call 10b7ac <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
1090a9: 83 c4 10 add $0x10,%esp
}
1090ac: 8b 45 e4 mov -0x1c(%ebp),%eax
1090af: 8d 65 f4 lea -0xc(%ebp),%esp
1090b2: 5b pop %ebx
1090b3: 5e pop %esi
1090b4: 5f pop %edi
1090b5: c9 leave
1090b6: c3 ret
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_start(
1090b7: 56 push %esi
1090b8: 53 push %ebx
1090b9: 68 4c a8 10 00 push $0x10a84c
1090be: ff b3 c4 00 00 00 pushl 0xc4(%ebx)
1090c4: e8 2b 2a 00 00 call 10baf4 <rtems_task_start>
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
1090c9: 83 c4 10 add $0x10,%esp
1090cc: 85 c0 test %eax,%eax
1090ce: 0f 85 3f 03 00 00 jne 109413 <rtems_termios_open+0x3ff><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
1090d4: 51 push %ecx
1090d5: 53 push %ebx
1090d6: 68 fc aa 10 00 push $0x10aafc
1090db: ff b3 c8 00 00 00 pushl 0xc8(%ebx)
1090e1: e8 0e 2a 00 00 call 10baf4 <rtems_task_start>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
1090e6: 83 c4 10 add $0x10,%esp
1090e9: 85 c0 test %eax,%eax
1090eb: 74 ae je 10909b <rtems_termios_open+0x87><== ALWAYS TAKEN
1090ed: e9 21 03 00 00 jmp 109413 <rtems_termios_open+0x3ff><== NOT EXECUTED
1090f2: 66 90 xchg %ax,%ax <== NOT EXECUTED
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
1090f4: 83 ec 08 sub $0x8,%esp
1090f7: 68 e8 00 00 00 push $0xe8
1090fc: 6a 01 push $0x1
1090fe: 89 55 dc mov %edx,-0x24(%ebp)
109101: e8 1e ee ff ff call 107f24 <calloc>
109106: 89 45 e0 mov %eax,-0x20(%ebp)
109109: 89 c3 mov %eax,%ebx
if (tty == NULL) {
10910b: 83 c4 10 add $0x10,%esp
10910e: 85 c0 test %eax,%eax
109110: 8b 55 dc mov -0x24(%ebp),%edx
109113: 0f 84 75 02 00 00 je 10938e <rtems_termios_open+0x37a>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
109119: a1 84 59 12 00 mov 0x125984,%eax
10911e: 8b 4d e0 mov -0x20(%ebp),%ecx
109121: 89 41 64 mov %eax,0x64(%ecx)
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
109124: 8b 41 64 mov 0x64(%ecx),%eax
109127: 83 ec 0c sub $0xc,%esp
10912a: 50 push %eax
10912b: 89 55 dc mov %edx,-0x24(%ebp)
10912e: e8 55 f2 ff ff call 108388 <malloc>
109133: 89 45 c4 mov %eax,-0x3c(%ebp)
109136: 8b 7d e0 mov -0x20(%ebp),%edi
109139: 89 47 58 mov %eax,0x58(%edi)
if (tty->rawInBuf.theBuf == NULL) {
10913c: 83 c4 10 add $0x10,%esp
10913f: 85 c0 test %eax,%eax
109141: 8b 55 dc mov -0x24(%ebp),%edx
109144: 0f 84 61 02 00 00 je 1093ab <rtems_termios_open+0x397>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
10914a: a1 88 59 12 00 mov 0x125988,%eax
10914f: 8b 4d e0 mov -0x20(%ebp),%ecx
109152: 89 81 88 00 00 00 mov %eax,0x88(%ecx)
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
109158: 8b 81 88 00 00 00 mov 0x88(%ecx),%eax
10915e: 83 ec 0c sub $0xc,%esp
109161: 50 push %eax
109162: 89 55 dc mov %edx,-0x24(%ebp)
109165: e8 1e f2 ff ff call 108388 <malloc>
10916a: 89 c7 mov %eax,%edi
10916c: 8b 45 e0 mov -0x20(%ebp),%eax
10916f: 89 78 7c mov %edi,0x7c(%eax)
if (tty->rawOutBuf.theBuf == NULL) {
109172: 83 c4 10 add $0x10,%esp
109175: 85 ff test %edi,%edi
109177: 8b 55 dc mov -0x24(%ebp),%edx
10917a: 0f 84 4f 02 00 00 je 1093cf <rtems_termios_open+0x3bb><== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
109180: 83 ec 0c sub $0xc,%esp
109183: ff 35 80 59 12 00 pushl 0x125980
109189: 89 55 dc mov %edx,-0x24(%ebp)
10918c: e8 f7 f1 ff ff call 108388 <malloc>
109191: 8b 4d e0 mov -0x20(%ebp),%ecx
109194: 89 41 1c mov %eax,0x1c(%ecx)
if (tty->cbuf == NULL) {
109197: 83 c4 10 add $0x10,%esp
10919a: 85 c0 test %eax,%eax
10919c: 8b 55 dc mov -0x24(%ebp),%edx
10919f: 0f 84 77 02 00 00 je 10941c <rtems_termios_open+0x408>
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
1091a5: 8b 7d e0 mov -0x20(%ebp),%edi
1091a8: c7 87 d4 00 00 00 00 movl $0x0,0xd4(%edi)
1091af: 00 00 00
tty->tty_snd.sw_arg = NULL;
1091b2: c7 87 d8 00 00 00 00 movl $0x0,0xd8(%edi)
1091b9: 00 00 00
tty->tty_rcv.sw_pfn = NULL;
1091bc: c7 87 dc 00 00 00 00 movl $0x0,0xdc(%edi)
1091c3: 00 00 00
tty->tty_rcv.sw_arg = NULL;
1091c6: c7 87 e0 00 00 00 00 movl $0x0,0xe0(%edi)
1091cd: 00 00 00
tty->tty_rcvwakeup = 0;
1091d0: c7 87 e4 00 00 00 00 movl $0x0,0xe4(%edi)
1091d7: 00 00 00
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
1091da: 89 37 mov %esi,(%edi)
tty->back = NULL;
1091dc: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
if (rtems_termios_ttyHead != NULL)
1091e3: 85 f6 test %esi,%esi
1091e5: 74 03 je 1091ea <rtems_termios_open+0x1d6>
rtems_termios_ttyHead->back = tty;
1091e7: 89 7e 04 mov %edi,0x4(%esi)
rtems_termios_ttyHead = tty;
1091ea: 8b 45 e0 mov -0x20(%ebp),%eax
1091ed: a3 74 7c 12 00 mov %eax,0x127c74
if (rtems_termios_ttyTail == NULL)
1091f2: 8b 0d 70 7c 12 00 mov 0x127c70,%ecx
1091f8: 85 c9 test %ecx,%ecx
1091fa: 0f 84 af 02 00 00 je 1094af <rtems_termios_open+0x49b>
rtems_termios_ttyTail = tty;
tty->minor = minor;
109200: 8b 75 0c mov 0xc(%ebp),%esi
109203: 8b 4d e0 mov -0x20(%ebp),%ecx
109206: 89 71 10 mov %esi,0x10(%ecx)
tty->major = major;
109209: 89 51 0c mov %edx,0xc(%ecx)
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
10920c: 83 ec 0c sub $0xc,%esp
10920f: 89 c8 mov %ecx,%eax
109211: 83 c0 14 add $0x14,%eax
109214: 50 push %eax
109215: 6a 00 push $0x0
109217: 6a 54 push $0x54
109219: 6a 01 push $0x1
rtems_build_name ('T', 'R', 'i', c),
10921b: 0f be 05 8c 59 12 00 movsbl 0x12598c,%eax
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
109222: 0d 00 69 52 54 or $0x54526900,%eax
109227: 50 push %eax
109228: 89 55 dc mov %edx,-0x24(%ebp)
10922b: e8 04 22 00 00 call 10b434 <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)
109230: 83 c4 20 add $0x20,%esp
109233: 85 c0 test %eax,%eax
109235: 8b 55 dc mov -0x24(%ebp),%edx
109238: 0f 85 d5 01 00 00 jne 109413 <rtems_termios_open+0x3ff>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
10923e: 83 ec 0c sub $0xc,%esp
109241: 8b 45 e0 mov -0x20(%ebp),%eax
109244: 83 c0 18 add $0x18,%eax
109247: 50 push %eax
109248: 6a 00 push $0x0
10924a: 6a 54 push $0x54
10924c: 6a 01 push $0x1
rtems_build_name ('T', 'R', 'o', c),
10924e: 0f be 05 8c 59 12 00 movsbl 0x12598c,%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 (
109255: 0d 00 6f 52 54 or $0x54526f00,%eax
10925a: 50 push %eax
10925b: 89 55 dc mov %edx,-0x24(%ebp)
10925e: e8 d1 21 00 00 call 10b434 <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)
109263: 83 c4 20 add $0x20,%esp
109266: 85 c0 test %eax,%eax
109268: 8b 55 dc mov -0x24(%ebp),%edx
10926b: 0f 85 a2 01 00 00 jne 109413 <rtems_termios_open+0x3ff>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
109271: 83 ec 0c sub $0xc,%esp
109274: 8b 45 e0 mov -0x20(%ebp),%eax
109277: 05 8c 00 00 00 add $0x8c,%eax
10927c: 50 push %eax
10927d: 6a 00 push $0x0
10927f: 6a 20 push $0x20
109281: 6a 00 push $0x0
rtems_build_name ('T', 'R', 'x', c),
109283: 0f be 05 8c 59 12 00 movsbl 0x12598c,%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 (
10928a: 0d 00 78 52 54 or $0x54527800,%eax
10928f: 50 push %eax
109290: 89 55 dc mov %edx,-0x24(%ebp)
109293: e8 9c 21 00 00 call 10b434 <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)
109298: 83 c4 20 add $0x20,%esp
10929b: 85 c0 test %eax,%eax
10929d: 8b 55 dc mov -0x24(%ebp),%edx
1092a0: 0f 85 6d 01 00 00 jne 109413 <rtems_termios_open+0x3ff>
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
1092a6: 8b 7d e0 mov -0x20(%ebp),%edi
1092a9: c7 87 94 00 00 00 00 movl $0x0,0x94(%edi)
1092b0: 00 00 00
/*
* Set callbacks
*/
tty->device = *callbacks;
1092b3: 81 c7 98 00 00 00 add $0x98,%edi
1092b9: b9 08 00 00 00 mov $0x8,%ecx
1092be: 8b 75 14 mov 0x14(%ebp),%esi
1092c1: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
1092c3: 8b 7d e0 mov -0x20(%ebp),%edi
1092c6: 83 bf b4 00 00 00 02 cmpl $0x2,0xb4(%edi)
1092cd: 0f 84 64 01 00 00 je 109437 <rtems_termios_open+0x423><== NEVER TAKEN
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
1092d3: 8b 45 e0 mov -0x20(%ebp),%eax
1092d6: 8b 88 a0 00 00 00 mov 0xa0(%eax),%ecx
1092dc: 85 c9 test %ecx,%ecx
1092de: 0f 84 fc 00 00 00 je 1093e0 <rtems_termios_open+0x3cc>
1092e4: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax)
1092eb: 0f 84 ef 00 00 00 je 1093e0 <rtems_termios_open+0x3cc><== NEVER TAKEN
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
1092f1: 8b 4d e0 mov -0x20(%ebp),%ecx
1092f4: c7 41 30 02 25 00 00 movl $0x2502,0x30(%ecx)
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
1092fb: c7 41 34 05 18 00 00 movl $0x1805,0x34(%ecx)
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
109302: c7 41 38 bd 08 00 00 movl $0x8bd,0x38(%ecx)
tty->termios.c_lflag =
109309: c7 41 3c 3b 82 00 00 movl $0x823b,0x3c(%ecx)
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
109310: c6 41 41 03 movb $0x3,0x41(%ecx)
tty->termios.c_cc[VQUIT] = '\034';
109314: c6 41 42 1c movb $0x1c,0x42(%ecx)
tty->termios.c_cc[VERASE] = '\177';
109318: c6 41 43 7f movb $0x7f,0x43(%ecx)
tty->termios.c_cc[VKILL] = '\025';
10931c: c6 41 44 15 movb $0x15,0x44(%ecx)
tty->termios.c_cc[VEOF] = '\004';
109320: c6 41 45 04 movb $0x4,0x45(%ecx)
tty->termios.c_cc[VEOL] = '\000';
109324: c6 41 4c 00 movb $0x0,0x4c(%ecx)
tty->termios.c_cc[VEOL2] = '\000';
109328: c6 41 51 00 movb $0x0,0x51(%ecx)
tty->termios.c_cc[VSTART] = '\021';
10932c: c6 41 49 11 movb $0x11,0x49(%ecx)
tty->termios.c_cc[VSTOP] = '\023';
109330: c6 41 4a 13 movb $0x13,0x4a(%ecx)
tty->termios.c_cc[VSUSP] = '\032';
109334: c6 41 4b 1a movb $0x1a,0x4b(%ecx)
tty->termios.c_cc[VREPRINT] = '\022';
109338: c6 41 4d 12 movb $0x12,0x4d(%ecx)
tty->termios.c_cc[VDISCARD] = '\017';
10933c: c6 41 4e 0f movb $0xf,0x4e(%ecx)
tty->termios.c_cc[VWERASE] = '\027';
109340: c6 41 4f 17 movb $0x17,0x4f(%ecx)
tty->termios.c_cc[VLNEXT] = '\026';
109344: c6 41 50 16 movb $0x16,0x50(%ecx)
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
109348: c7 81 b8 00 00 00 00 movl $0x0,0xb8(%ecx)
10934f: 00 00 00
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
109352: 8b 41 64 mov 0x64(%ecx),%eax
109355: d1 e8 shr %eax
109357: 89 81 bc 00 00 00 mov %eax,0xbc(%ecx)
tty->highwater = tty->rawInBuf.Size * 3/4;
10935d: 8b 41 64 mov 0x64(%ecx),%eax
109360: 8d 04 40 lea (%eax,%eax,2),%eax
109363: c1 e8 02 shr $0x2,%eax
109366: 89 81 c0 00 00 00 mov %eax,0xc0(%ecx)
/*
* Bump name characer
*/
if (c++ == 'z')
10936c: a0 8c 59 12 00 mov 0x12598c,%al
109371: 8d 48 01 lea 0x1(%eax),%ecx
109374: 88 0d 8c 59 12 00 mov %cl,0x12598c
10937a: 3c 7a cmp $0x7a,%al
10937c: 0f 85 e6 fc ff ff jne 109068 <rtems_termios_open+0x54>
c = 'a';
109382: c6 05 8c 59 12 00 61 movb $0x61,0x12598c
109389: e9 da fc ff ff jmp 109068 <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);
10938e: 83 ec 0c sub $0xc,%esp
109391: ff 35 6c 7c 12 00 pushl 0x127c6c
109397: e8 10 24 00 00 call 10b7ac <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
10939c: 83 c4 10 add $0x10,%esp
10939f: c7 45 e4 1a 00 00 00 movl $0x1a,-0x1c(%ebp)
1093a6: e9 01 fd ff ff jmp 1090ac <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);
1093ab: 83 ec 0c sub $0xc,%esp
1093ae: 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);
1093af: e8 00 ed ff ff call 1080b4 <free>
rtems_semaphore_release (rtems_termios_ttyMutex);
1093b4: 5f pop %edi
1093b5: ff 35 6c 7c 12 00 pushl 0x127c6c
1093bb: e8 ec 23 00 00 call 10b7ac <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
1093c0: 83 c4 10 add $0x10,%esp
1093c3: c7 45 e4 1a 00 00 00 movl $0x1a,-0x1c(%ebp)
1093ca: e9 dd fc ff ff jmp 1090ac <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));
1093cf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1093d2: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED
1093d5: e8 da ec ff ff call 1080b4 <free> <== NOT EXECUTED
free(tty);
1093da: 58 pop %eax <== NOT EXECUTED
1093db: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED
1093de: eb cf jmp 1093af <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 (
1093e0: 83 ec 0c sub $0xc,%esp
1093e3: 8b 45 e0 mov -0x20(%ebp),%eax
1093e6: 83 c0 68 add $0x68,%eax
1093e9: 50 push %eax
1093ea: 6a 00 push $0x0
1093ec: 6a 24 push $0x24
1093ee: 6a 00 push $0x0
rtems_build_name ('T', 'R', 'r', c),
1093f0: 0f be 05 8c 59 12 00 movsbl 0x12598c,%eax
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
1093f7: 0d 00 72 52 54 or $0x54527200,%eax
1093fc: 50 push %eax
1093fd: 89 55 dc mov %edx,-0x24(%ebp)
109400: e8 2f 20 00 00 call 10b434 <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)
109405: 83 c4 20 add $0x20,%esp
109408: 85 c0 test %eax,%eax
10940a: 8b 55 dc mov -0x24(%ebp),%edx
10940d: 0f 84 de fe ff ff je 1092f1 <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);
109413: 83 ec 0c sub $0xc,%esp
109416: 50 push %eax
109417: e8 d8 28 00 00 call 10bcf4 <rtems_fatal_error_occurred>
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
10941c: 83 ec 0c sub $0xc,%esp
10941f: 57 push %edi
109420: e8 8f ec ff ff call 1080b4 <free>
free((void *)(tty->rawInBuf.theBuf));
109425: 5e pop %esi
109426: ff 75 c4 pushl -0x3c(%ebp)
109429: e8 86 ec ff ff call 1080b4 <free>
free(tty);
10942e: 5b pop %ebx
10942f: ff 75 e0 pushl -0x20(%ebp)
109432: e9 78 ff ff ff jmp 1093af <rtems_termios_open+0x39b>
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
109437: 50 push %eax
109438: 50 push %eax
109439: 89 f8 mov %edi,%eax
10943b: 05 c8 00 00 00 add $0xc8,%eax
109440: 50 push %eax
109441: 6a 00 push $0x0
109443: 68 00 05 00 00 push $0x500
109448: 68 00 04 00 00 push $0x400
10944d: 6a 0a push $0xa
rtems_build_name ('T', 'x', 'T', c),
10944f: 0f be 05 8c 59 12 00 movsbl 0x12598c,%eax
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
109456: 0d 00 54 78 54 or $0x54785400,%eax
10945b: 50 push %eax
10945c: 89 55 dc mov %edx,-0x24(%ebp)
10945f: e8 e8 23 00 00 call 10b84c <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)
109464: 83 c4 20 add $0x20,%esp
109467: 85 c0 test %eax,%eax
109469: 8b 55 dc mov -0x24(%ebp),%edx
10946c: 75 a5 jne 109413 <rtems_termios_open+0x3ff><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
10946e: 56 push %esi
10946f: 56 push %esi
109470: 8b 45 e0 mov -0x20(%ebp),%eax
109473: 05 c4 00 00 00 add $0xc4,%eax
109478: 50 push %eax
109479: 6a 00 push $0x0
10947b: 68 00 05 00 00 push $0x500
109480: 68 00 04 00 00 push $0x400
109485: 6a 09 push $0x9
rtems_build_name ('R', 'x', 'T', c),
109487: 0f be 05 8c 59 12 00 movsbl 0x12598c,%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 (
10948e: 0d 00 54 78 52 or $0x52785400,%eax
109493: 50 push %eax
109494: 89 55 dc mov %edx,-0x24(%ebp)
109497: e8 b0 23 00 00 call 10b84c <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)
10949c: 83 c4 20 add $0x20,%esp
10949f: 85 c0 test %eax,%eax
1094a1: 8b 55 dc mov -0x24(%ebp),%edx
1094a4: 0f 84 29 fe ff ff je 1092d3 <rtems_termios_open+0x2bf>
1094aa: e9 64 ff ff ff jmp 109413 <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;
1094af: a3 70 7c 12 00 mov %eax,0x127c70
1094b4: e9 47 fd ff ff jmp 109200 <rtems_termios_open+0x1ec>
00109acc <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
109acc: 55 push %ebp
109acd: 89 e5 mov %esp,%ebp
109acf: 57 push %edi
109ad0: 56 push %esi
109ad1: 53 push %ebx
109ad2: 83 ec 1c sub $0x1c,%esp
109ad5: 8b 45 08 mov 0x8(%ebp),%eax
109ad8: 8b 55 0c mov 0xc(%ebp),%edx
109adb: 89 55 e4 mov %edx,-0x1c(%ebp)
109ade: 8b 5d 10 mov 0x10(%ebp),%ebx
const unsigned char *buf = _buf;
109ae1: 89 c6 mov %eax,%esi
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
109ae3: 8b 8b b4 00 00 00 mov 0xb4(%ebx),%ecx
109ae9: 85 c9 test %ecx,%ecx
109aeb: 0f 84 eb 00 00 00 je 109bdc <rtems_termios_puts+0x110>
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
109af1: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
109af7: 89 45 e0 mov %eax,-0x20(%ebp)
while (len) {
109afa: 8b 55 e4 mov -0x1c(%ebp),%edx
109afd: 85 d2 test %edx,%edx
109aff: 0f 84 cf 00 00 00 je 109bd4 <rtems_termios_puts+0x108><== NEVER TAKEN
109b05: 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;
109b08: 8b 45 e0 mov -0x20(%ebp),%eax
109b0b: 40 inc %eax
109b0c: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx
109b12: 31 d2 xor %edx,%edx
109b14: f7 f1 div %ecx
109b16: 89 55 dc mov %edx,-0x24(%ebp)
109b19: 89 55 e0 mov %edx,-0x20(%ebp)
rtems_interrupt_disable (level);
109b1c: 9c pushf
109b1d: fa cli
109b1e: 5f pop %edi
while (newHead == tty->rawOutBuf.Tail) {
109b1f: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx
109b25: 3b 55 e0 cmp -0x20(%ebp),%edx
109b28: 75 3e jne 109b68 <rtems_termios_puts+0x9c>
109b2a: 89 f8 mov %edi,%eax
109b2c: 89 f7 mov %esi,%edi
109b2e: 89 d6 mov %edx,%esi
tty->rawOutBufState = rob_wait;
109b30: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx)
109b37: 00 00 00
rtems_interrupt_enable (level);
109b3a: 50 push %eax
109b3b: 9d popf
sc = rtems_semaphore_obtain(
109b3c: 50 push %eax
109b3d: 6a 00 push $0x0
109b3f: 6a 00 push $0x0
109b41: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
109b47: e8 64 1b 00 00 call 10b6b0 <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
109b4c: 83 c4 10 add $0x10,%esp
109b4f: 85 c0 test %eax,%eax
109b51: 0f 85 a0 00 00 00 jne 109bf7 <rtems_termios_puts+0x12b><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
109b57: 9c pushf
109b58: fa cli
109b59: 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) {
109b5a: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx
109b60: 39 f2 cmp %esi,%edx
109b62: 74 cc je 109b30 <rtems_termios_puts+0x64><== NEVER TAKEN
109b64: 89 fe mov %edi,%esi
109b66: 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++;
109b68: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
109b6e: 8b 4b 7c mov 0x7c(%ebx),%ecx
109b71: 8a 16 mov (%esi),%dl
109b73: 88 14 01 mov %dl,(%ecx,%eax,1)
tty->rawOutBuf.Head = newHead;
109b76: 8b 45 dc mov -0x24(%ebp),%eax
109b79: 89 83 80 00 00 00 mov %eax,0x80(%ebx)
if (tty->rawOutBufState == rob_idle) {
109b7f: 8b 8b 94 00 00 00 mov 0x94(%ebx),%ecx
109b85: 85 c9 test %ecx,%ecx
109b87: 75 23 jne 109bac <rtems_termios_puts+0xe0>
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
109b89: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109b8f: a8 10 test $0x10,%al
109b91: 74 26 je 109bb9 <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;
109b93: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109b99: 83 c8 20 or $0x20,%eax
109b9c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
109ba2: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx)
109ba9: 00 00 00
}
rtems_interrupt_enable (level);
109bac: 57 push %edi
109bad: 9d popf
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
109bae: ff 4d e4 decl -0x1c(%ebp)
109bb1: 74 21 je 109bd4 <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++;
109bb3: 46 inc %esi
109bb4: e9 4f ff ff ff jmp 109b08 <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);
109bb9: 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,
109bbf: 52 push %edx
109bc0: 6a 01 push $0x1
109bc2: 03 43 7c add 0x7c(%ebx),%eax
109bc5: 50 push %eax
109bc6: ff 73 10 pushl 0x10(%ebx)
109bc9: ff 93 a4 00 00 00 call *0xa4(%ebx)
109bcf: 83 c4 10 add $0x10,%esp
109bd2: eb ce jmp 109ba2 <rtems_termios_puts+0xd6>
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
109bd4: 8d 65 f4 lea -0xc(%ebp),%esp
109bd7: 5b pop %ebx
109bd8: 5e pop %esi
109bd9: 5f pop %edi
109bda: c9 leave
109bdb: 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);
109bdc: 89 55 10 mov %edx,0x10(%ebp)
109bdf: 89 45 0c mov %eax,0xc(%ebp)
109be2: 8b 43 10 mov 0x10(%ebx),%eax
109be5: 89 45 08 mov %eax,0x8(%ebp)
109be8: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
109bee: 8d 65 f4 lea -0xc(%ebp),%esp
109bf1: 5b pop %ebx
109bf2: 5e pop %esi
109bf3: 5f pop %edi
109bf4: 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);
109bf5: 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);
109bf7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109bfa: 50 push %eax <== NOT EXECUTED
109bfb: e8 f4 20 00 00 call 10bcf4 <rtems_fatal_error_occurred><== NOT EXECUTED
0010a1d8 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
10a1d8: 55 push %ebp
10a1d9: 89 e5 mov %esp,%ebp
10a1db: 57 push %edi
10a1dc: 56 push %esi
10a1dd: 53 push %ebx
10a1de: 83 ec 30 sub $0x30,%esp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
10a1e1: 8b 55 08 mov 0x8(%ebp),%edx
10a1e4: 8b 02 mov (%edx),%eax
10a1e6: 8b 58 34 mov 0x34(%eax),%ebx
uint32_t count = args->count;
10a1e9: 8b 4a 10 mov 0x10(%edx),%ecx
10a1ec: 89 4d dc mov %ecx,-0x24(%ebp)
char *buffer = args->buffer;
10a1ef: 8b 42 0c mov 0xc(%edx),%eax
10a1f2: 89 45 d8 mov %eax,-0x28(%ebp)
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
10a1f5: 6a 00 push $0x0
10a1f7: 6a 00 push $0x0
10a1f9: ff 73 14 pushl 0x14(%ebx)
10a1fc: e8 af 14 00 00 call 10b6b0 <rtems_semaphore_obtain>
10a201: 89 45 e0 mov %eax,-0x20(%ebp)
if (sc != RTEMS_SUCCESSFUL)
10a204: 83 c4 10 add $0x10,%esp
10a207: 85 c0 test %eax,%eax
10a209: 75 35 jne 10a240 <rtems_termios_read+0x68><== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
10a20b: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
10a211: c1 e0 05 shl $0x5,%eax
10a214: 8b 80 08 79 12 00 mov 0x127908(%eax),%eax
10a21a: 85 c0 test %eax,%eax
10a21c: 74 2e je 10a24c <rtems_termios_read+0x74>
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
10a21e: 83 ec 08 sub $0x8,%esp
10a221: ff 75 08 pushl 0x8(%ebp)
10a224: 53 push %ebx
10a225: ff d0 call *%eax
10a227: 89 45 e0 mov %eax,-0x20(%ebp)
tty->tty_rcvwakeup = 0;
10a22a: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10a231: 00 00 00
rtems_semaphore_release (tty->isem);
10a234: 59 pop %ecx
10a235: ff 73 14 pushl 0x14(%ebx)
10a238: e8 6f 15 00 00 call 10b7ac <rtems_semaphore_release>
return sc;
10a23d: 83 c4 10 add $0x10,%esp
}
args->bytes_moved = args->count - count;
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
10a240: 8b 45 e0 mov -0x20(%ebp),%eax
10a243: 8d 65 f4 lea -0xc(%ebp),%esp
10a246: 5b pop %ebx
10a247: 5e pop %esi
10a248: 5f pop %edi
10a249: c9 leave
10a24a: c3 ret
10a24b: 90 nop
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
10a24c: 8b 53 20 mov 0x20(%ebx),%edx
10a24f: 39 53 24 cmp %edx,0x24(%ebx)
10a252: 74 5f je 10a2b3 <rtems_termios_read+0xdb><== ALWAYS TAKEN
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
10a254: 8b 45 dc mov -0x24(%ebp),%eax
10a257: 85 c0 test %eax,%eax
10a259: 74 29 je 10a284 <rtems_termios_read+0xac><== NEVER TAKEN
10a25b: 8b 43 24 mov 0x24(%ebx),%eax
10a25e: 3b 43 20 cmp 0x20(%ebx),%eax
10a261: 7d 21 jge 10a284 <rtems_termios_read+0xac><== NEVER TAKEN
10a263: 8b 55 d8 mov -0x28(%ebp),%edx
10a266: 8b 7d dc mov -0x24(%ebp),%edi
10a269: eb 06 jmp 10a271 <rtems_termios_read+0x99>
10a26b: 90 nop
10a26c: 39 43 20 cmp %eax,0x20(%ebx)
10a26f: 7e 10 jle 10a281 <rtems_termios_read+0xa9>
*buffer++ = tty->cbuf[tty->cindex++];
10a271: 8b 73 1c mov 0x1c(%ebx),%esi
10a274: 8a 0c 06 mov (%esi,%eax,1),%cl
10a277: 88 0a mov %cl,(%edx)
10a279: 42 inc %edx
10a27a: 40 inc %eax
10a27b: 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)) {
10a27e: 4f dec %edi
10a27f: 75 eb jne 10a26c <rtems_termios_read+0x94>
10a281: 89 7d dc mov %edi,-0x24(%ebp)
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
10a284: 8b 55 08 mov 0x8(%ebp),%edx
10a287: 8b 42 10 mov 0x10(%edx),%eax
10a28a: 2b 45 dc sub -0x24(%ebp),%eax
10a28d: 89 42 18 mov %eax,0x18(%edx)
tty->tty_rcvwakeup = 0;
10a290: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10a297: 00 00 00
rtems_semaphore_release (tty->isem);
10a29a: 83 ec 0c sub $0xc,%esp
10a29d: ff 73 14 pushl 0x14(%ebx)
10a2a0: e8 07 15 00 00 call 10b7ac <rtems_semaphore_release>
return sc;
10a2a5: 83 c4 10 add $0x10,%esp
}
10a2a8: 8b 45 e0 mov -0x20(%ebp),%eax
10a2ab: 8d 65 f4 lea -0xc(%ebp),%esp
10a2ae: 5b pop %ebx
10a2af: 5e pop %esi
10a2b0: 5f pop %edi
10a2b1: c9 leave
10a2b2: c3 ret
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
10a2b3: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
10a2ba: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
tty->read_start_column = tty->column;
10a2c1: 8b 43 28 mov 0x28(%ebx),%eax
10a2c4: 89 43 2c mov %eax,0x2c(%ebx)
if (tty->device.pollRead != NULL &&
10a2c7: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax
10a2cd: 85 c0 test %eax,%eax
10a2cf: 74 0e je 10a2df <rtems_termios_read+0x107>
10a2d1: 8b 93 b4 00 00 00 mov 0xb4(%ebx),%edx
10a2d7: 85 d2 test %edx,%edx
10a2d9: 0f 84 82 01 00 00 je 10a461 <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;
10a2df: 8b 73 74 mov 0x74(%ebx),%esi
rtems_status_code sc;
int wait = (int)1;
10a2e2: 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)(
10a2e9: 8d 4b 49 lea 0x49(%ebx),%ecx
10a2ec: 89 4d d4 mov %ecx,-0x2c(%ebp)
10a2ef: 90 nop
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
10a2f0: 8b 53 5c mov 0x5c(%ebx),%edx
10a2f3: 8b 43 60 mov 0x60(%ebx),%eax
10a2f6: 39 c2 cmp %eax,%edx
10a2f8: 0f 84 06 01 00 00 je 10a404 <rtems_termios_read+0x22c>
(tty->ccount < (CBUFSIZE-1))) {
10a2fe: a1 80 59 12 00 mov 0x125980,%eax
10a303: 48 dec %eax
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
10a304: 3b 43 20 cmp 0x20(%ebx),%eax
10a307: 7f 3c jg 10a345 <rtems_termios_read+0x16d><== ALWAYS TAKEN
10a309: e9 f6 00 00 00 jmp 10a404 <rtems_termios_read+0x22c><== NOT EXECUTED
10a30e: 66 90 xchg %ax,%ax <== NOT EXECUTED
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
10a310: 0f b6 c1 movzbl %cl,%eax
10a313: 89 da mov %ebx,%edx
10a315: e8 9e fd ff ff call 10a0b8 <siproc>
10a31a: 85 c0 test %eax,%eax
10a31c: 74 07 je 10a325 <rtems_termios_read+0x14d>
wait = 0;
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
10a31e: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
}
timeout = tty->rawInBufSemaphoreTimeout;
10a325: 8b 73 70 mov 0x70(%ebx),%esi
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
10a328: 8b 53 5c mov 0x5c(%ebx),%edx
10a32b: 8b 43 60 mov 0x60(%ebx),%eax
10a32e: 39 c2 cmp %eax,%edx
10a330: 0f 84 ce 00 00 00 je 10a404 <rtems_termios_read+0x22c>
(tty->ccount < (CBUFSIZE-1))) {
10a336: a1 80 59 12 00 mov 0x125980,%eax
10a33b: 48 dec %eax
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
10a33c: 39 43 20 cmp %eax,0x20(%ebx)
10a33f: 0f 8d bf 00 00 00 jge 10a404 <rtems_termios_read+0x22c><== NEVER TAKEN
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
10a345: 8b 43 5c mov 0x5c(%ebx),%eax
10a348: 8b 4b 64 mov 0x64(%ebx),%ecx
10a34b: 40 inc %eax
10a34c: 31 d2 xor %edx,%edx
10a34e: f7 f1 div %ecx
c = tty->rawInBuf.theBuf[newHead];
10a350: 8b 43 58 mov 0x58(%ebx),%eax
10a353: 8a 0c 10 mov (%eax,%edx,1),%cl
tty->rawInBuf.Head = newHead;
10a356: 89 53 5c mov %edx,0x5c(%ebx)
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
10a359: 8b 43 60 mov 0x60(%ebx),%eax
10a35c: 8b 7b 64 mov 0x64(%ebx),%edi
% tty->rawInBuf.Size)
10a35f: 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)
10a362: 8d 04 07 lea (%edi,%eax,1),%eax
10a365: 29 d0 sub %edx,%eax
% tty->rawInBuf.Size)
10a367: 31 d2 xor %edx,%edx
10a369: 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)
10a36b: 3b 93 bc 00 00 00 cmp 0xbc(%ebx),%edx
10a371: 73 5d jae 10a3d0 <rtems_termios_read+0x1f8><== NEVER TAKEN
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
10a373: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10a379: 83 e0 fe and $0xfffffffe,%eax
10a37c: 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))
10a382: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10a388: 25 02 02 00 00 and $0x202,%eax
10a38d: 3d 02 02 00 00 cmp $0x202,%eax
10a392: 0f 84 94 00 00 00 je 10a42c <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) {
10a398: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10a39e: f6 c4 01 test $0x1,%ah
10a3a1: 74 2d je 10a3d0 <rtems_termios_read+0x1f8><== ALWAYS TAKEN
tty->flow_ctrl &= ~FL_IRTSOFF;
10a3a3: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10a3a9: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED
10a3ac: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
10a3b2: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED
10a3b8: 85 c0 test %eax,%eax <== NOT EXECUTED
10a3ba: 74 14 je 10a3d0 <rtems_termios_read+0x1f8><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
10a3bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a3bf: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10a3c2: 88 4d d0 mov %cl,-0x30(%ebp) <== NOT EXECUTED
10a3c5: ff d0 call *%eax <== NOT EXECUTED
10a3c7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a3ca: 8a 4d d0 mov -0x30(%ebp),%cl <== NOT EXECUTED
10a3cd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
10a3d0: f6 43 3c 02 testb $0x2,0x3c(%ebx)
10a3d4: 0f 85 36 ff ff ff jne 10a310 <rtems_termios_read+0x138><== ALWAYS TAKEN
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
10a3da: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED
10a3dd: 89 da mov %ebx,%edx <== NOT EXECUTED
10a3df: e8 d4 fc ff ff call 10a0b8 <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
10a3e4: 0f b6 43 47 movzbl 0x47(%ebx),%eax <== NOT EXECUTED
10a3e8: 39 43 20 cmp %eax,0x20(%ebx) <== NOT EXECUTED
10a3eb: 0f 8d 2d ff ff ff jge 10a31e <rtems_termios_read+0x146><== NOT EXECUTED
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
10a3f1: 8b 73 70 mov 0x70(%ebx),%esi <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
10a3f4: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED
10a3f7: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED
10a3fa: 39 c2 cmp %eax,%edx <== NOT EXECUTED
10a3fc: 0f 85 34 ff ff ff jne 10a336 <rtems_termios_read+0x15e><== NOT EXECUTED
10a402: 66 90 xchg %ax,%ax <== NOT EXECUTED
}
/*
* Wait for characters
*/
if ( wait ) {
10a404: 8b 4d e4 mov -0x1c(%ebp),%ecx
10a407: 85 c9 test %ecx,%ecx
10a409: 0f 84 45 fe ff ff je 10a254 <rtems_termios_read+0x7c>
sc = rtems_semaphore_obtain(
10a40f: 52 push %edx
10a410: 56 push %esi
10a411: ff 73 6c pushl 0x6c(%ebx)
10a414: ff 73 68 pushl 0x68(%ebx)
10a417: e8 94 12 00 00 call 10b6b0 <rtems_semaphore_obtain>
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
10a41c: 83 c4 10 add $0x10,%esp
10a41f: 85 c0 test %eax,%eax
10a421: 0f 84 c9 fe ff ff je 10a2f0 <rtems_termios_read+0x118><== ALWAYS TAKEN
10a427: e9 28 fe ff ff jmp 10a254 <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)
10a42c: 8b bb 94 00 00 00 mov 0x94(%ebx),%edi <== NOT EXECUTED
10a432: 85 ff test %edi,%edi <== NOT EXECUTED
10a434: 74 0e je 10a444 <rtems_termios_read+0x26c><== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
10a436: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10a43c: a8 20 test $0x20,%al <== NOT EXECUTED
10a43e: 0f 84 54 ff ff ff je 10a398 <rtems_termios_read+0x1c0><== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
10a444: 56 push %esi <== NOT EXECUTED
10a445: 6a 01 push $0x1 <== NOT EXECUTED
10a447: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED
10a44a: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10a44d: 88 4d d0 mov %cl,-0x30(%ebp) <== NOT EXECUTED
10a450: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
10a456: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a459: 8a 4d d0 mov -0x30(%ebp),%cl <== NOT EXECUTED
10a45c: e9 6f ff ff ff jmp 10a3d0 <rtems_termios_read+0x1f8><== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
10a461: f6 43 3c 02 testb $0x2,0x3c(%ebx)
10a465: 75 1d jne 10a484 <rtems_termios_read+0x2ac><== NEVER TAKEN
10a467: eb 39 jmp 10a4a2 <rtems_termios_read+0x2ca>
10a469: 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))
10a46c: 0f b6 c0 movzbl %al,%eax
10a46f: 89 da mov %ebx,%edx
10a471: e8 42 fc ff ff call 10a0b8 <siproc>
10a476: 85 c0 test %eax,%eax
10a478: 0f 85 d6 fd ff ff jne 10a254 <rtems_termios_read+0x7c><== NEVER TAKEN
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
10a47e: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
10a484: 83 ec 0c sub $0xc,%esp
10a487: ff 73 10 pushl 0x10(%ebx)
10a48a: ff d0 call *%eax
if (n < 0) {
10a48c: 83 c4 10 add $0x10,%esp
10a48f: 85 c0 test %eax,%eax
10a491: 79 d9 jns 10a46c <rtems_termios_read+0x294><== NEVER TAKEN
rtems_task_wake_after (1);
10a493: 83 ec 0c sub $0xc,%esp
10a496: 6a 01 push $0x1
10a498: e8 cb 16 00 00 call 10bb68 <rtems_task_wake_after>
10a49d: 83 c4 10 add $0x10,%esp
10a4a0: eb dc jmp 10a47e <rtems_termios_read+0x2a6>
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
10a4a2: e8 01 0b 00 00 call 10afa8 <rtems_clock_get_ticks_since_boot>
10a4a7: 89 c6 mov %eax,%esi
10a4a9: 8d 76 00 lea 0x0(%esi),%esi
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
10a4ac: 83 ec 0c sub $0xc,%esp
10a4af: ff 73 10 pushl 0x10(%ebx)
10a4b2: ff 93 a0 00 00 00 call *0xa0(%ebx)
if (n < 0) {
10a4b8: 83 c4 10 add $0x10,%esp
10a4bb: 85 c0 test %eax,%eax
10a4bd: 78 25 js 10a4e4 <rtems_termios_read+0x30c>
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
10a4bf: 0f b6 c0 movzbl %al,%eax
10a4c2: 89 da mov %ebx,%edx
10a4c4: e8 ef fb ff ff call 10a0b8 <siproc>
if (tty->ccount >= tty->termios.c_cc[VMIN])
10a4c9: 8a 43 47 mov 0x47(%ebx),%al
10a4cc: 0f b6 d0 movzbl %al,%edx
10a4cf: 39 53 20 cmp %edx,0x20(%ebx)
10a4d2: 0f 8d 7c fd ff ff jge 10a254 <rtems_termios_read+0x7c><== NEVER TAKEN
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
10a4d8: 84 c0 test %al,%al
10a4da: 74 d0 je 10a4ac <rtems_termios_read+0x2d4><== NEVER TAKEN
10a4dc: 80 7b 46 00 cmpb $0x0,0x46(%ebx)
10a4e0: 74 ca je 10a4ac <rtems_termios_read+0x2d4><== NEVER TAKEN
10a4e2: eb be jmp 10a4a2 <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]) {
10a4e4: 80 7b 47 00 cmpb $0x0,0x47(%ebx)
10a4e8: 74 1d je 10a507 <rtems_termios_read+0x32f><== NEVER TAKEN
if (tty->termios.c_cc[VTIME] && tty->ccount) {
10a4ea: 80 7b 46 00 cmpb $0x0,0x46(%ebx)
10a4ee: 74 08 je 10a4f8 <rtems_termios_read+0x320><== NEVER TAKEN
10a4f0: 8b 43 20 mov 0x20(%ebx),%eax
10a4f3: 85 c0 test %eax,%eax
10a4f5: 75 1a jne 10a511 <rtems_termios_read+0x339>
10a4f7: 90 nop
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
10a4f8: 83 ec 0c sub $0xc,%esp
10a4fb: 6a 01 push $0x1
10a4fd: e8 66 16 00 00 call 10bb68 <rtems_task_wake_after>
10a502: 83 c4 10 add $0x10,%esp
10a505: eb a5 jmp 10a4ac <rtems_termios_read+0x2d4>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
10a507: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED
10a50b: 0f 84 43 fd ff ff je 10a254 <rtems_termios_read+0x7c><== NOT EXECUTED
break;
now = rtems_clock_get_ticks_since_boot();
10a511: e8 92 0a 00 00 call 10afa8 <rtems_clock_get_ticks_since_boot>
if ((now - then) > tty->vtimeTicks) {
10a516: 29 f0 sub %esi,%eax
10a518: 3b 43 54 cmp 0x54(%ebx),%eax
10a51b: 76 db jbe 10a4f8 <rtems_termios_read+0x320>
10a51d: e9 32 fd ff ff jmp 10a254 <rtems_termios_read+0x7c>
0010a8b8 <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)
{
10a8b8: 55 push %ebp
10a8b9: 89 e5 mov %esp,%ebp
10a8bb: 57 push %edi
10a8bc: 56 push %esi
10a8bd: 53 push %ebx
10a8be: 83 ec 0c sub $0xc,%esp
10a8c1: 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))
10a8c4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10a8ca: 25 03 04 00 00 and $0x403,%eax
10a8cf: 3d 01 04 00 00 cmp $0x401,%eax
10a8d4: 0f 84 62 01 00 00 je 10aa3c <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) {
10a8da: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10a8e0: 83 e0 03 and $0x3,%eax
10a8e3: 83 f8 02 cmp $0x2,%eax
10a8e6: 0f 84 8c 01 00 00 je 10aa78 <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 ) {
10a8ec: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx
10a8f2: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
10a8f8: 39 c2 cmp %eax,%edx
10a8fa: 0f 84 a4 00 00 00 je 10a9a4 <rtems_termios_refill_transmitter+0xec>
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
}
rtems_interrupt_disable(level);
10a900: 9c pushf
10a901: fa cli
10a902: 58 pop %eax
len = tty->t_dqlen;
10a903: 8b b3 90 00 00 00 mov 0x90(%ebx),%esi
tty->t_dqlen = 0;
10a909: c7 83 90 00 00 00 00 movl $0x0,0x90(%ebx)
10a910: 00 00 00
rtems_interrupt_enable(level);
10a913: 50 push %eax
10a914: 9d popf
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
10a915: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
10a91b: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx
10a921: 8d 04 06 lea (%esi,%eax,1),%eax
10a924: 31 d2 xor %edx,%edx
10a926: f7 f1 div %ecx
10a928: 89 d6 mov %edx,%esi
tty->rawOutBuf.Tail = newTail;
10a92a: 89 93 84 00 00 00 mov %edx,0x84(%ebx)
if (tty->rawOutBufState == rob_wait) {
10a930: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx)
10a937: 0f 84 e7 00 00 00 je 10aa24 <rtems_termios_refill_transmitter+0x16c>
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
if (newTail == tty->rawOutBuf.Head) {
10a93d: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
10a943: 39 f0 cmp %esi,%eax
10a945: 74 79 je 10a9c0 <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))
10a947: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10a94d: 25 10 02 00 00 and $0x210,%eax
10a952: 3d 10 02 00 00 cmp $0x210,%eax
10a957: 0f 84 57 01 00 00 je 10aab4 <rtems_termios_refill_transmitter+0x1fc><== NEVER TAKEN
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
10a95d: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
10a963: 39 c6 cmp %eax,%esi
10a965: 0f 87 91 00 00 00 ja 10a9fc <rtems_termios_refill_transmitter+0x144>
nToSend = tty->rawOutBuf.Size - newTail;
else
nToSend = tty->rawOutBuf.Head - newTail;
10a96b: 8b bb 80 00 00 00 mov 0x80(%ebx),%edi
10a971: 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)) {
10a973: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10a979: f6 c4 06 test $0x6,%ah
10a97c: 0f 85 91 00 00 00 jne 10aa13 <rtems_termios_refill_transmitter+0x15b>
10a982: 89 f8 mov %edi,%eax
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
10a984: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx)
10a98b: 00 00 00
(*tty->device.write)(
10a98e: 52 push %edx
10a98f: 50 push %eax
10a990: 8b 43 7c mov 0x7c(%ebx),%eax
10a993: 01 f0 add %esi,%eax
10a995: 50 push %eax
10a996: ff 73 10 pushl 0x10(%ebx)
10a999: ff 93 a4 00 00 00 call *0xa4(%ebx)
10a99f: 83 c4 10 add $0x10,%esp
10a9a2: eb 48 jmp 10a9ec <rtems_termios_refill_transmitter+0x134>
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
10a9a4: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx)
10a9ab: 0f 84 2b 01 00 00 je 10aadc <rtems_termios_refill_transmitter+0x224><== NEVER TAKEN
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
10a9b1: 31 ff xor %edi,%edi
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
10a9b3: 89 f8 mov %edi,%eax
10a9b5: 8d 65 f4 lea -0xc(%ebp),%esp
10a9b8: 5b pop %ebx
10a9b9: 5e pop %esi
10a9ba: 5f pop %edi
10a9bb: c9 leave
10a9bc: c3 ret
10a9bd: 8d 76 00 lea 0x0(%esi),%esi
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
10a9c0: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx)
10a9c7: 00 00 00
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
10a9ca: 8b 83 d4 00 00 00 mov 0xd4(%ebx),%eax
10a9d0: 85 c0 test %eax,%eax
10a9d2: 0f 84 1c 01 00 00 je 10aaf4 <rtems_termios_refill_transmitter+0x23c><== ALWAYS TAKEN
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
10a9d8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10a9db: ff b3 d8 00 00 00 pushl 0xd8(%ebx) <== NOT EXECUTED
10a9e1: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED
10a9e4: 52 push %edx <== NOT EXECUTED
10a9e5: ff d0 call *%eax <== NOT EXECUTED
10a9e7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
nToSend = 0;
10a9ea: 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*/
10a9ec: 89 b3 84 00 00 00 mov %esi,0x84(%ebx)
}
return nToSend;
}
10a9f2: 89 f8 mov %edi,%eax
10a9f4: 8d 65 f4 lea -0xc(%ebp),%esp
10a9f7: 5b pop %ebx
10a9f8: 5e pop %esi
10a9f9: 5f pop %edi
10a9fa: c9 leave
10a9fb: c3 ret
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
10a9fc: 8b bb 88 00 00 00 mov 0x88(%ebx),%edi
10aa02: 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)) {
10aa04: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10aa0a: f6 c4 06 test $0x6,%ah
10aa0d: 0f 84 6f ff ff ff je 10a982 <rtems_termios_refill_transmitter+0xca><== ALWAYS TAKEN
10aa13: b8 01 00 00 00 mov $0x1,%eax
nToSend = 1;
10aa18: bf 01 00 00 00 mov $0x1,%edi
10aa1d: e9 62 ff ff ff jmp 10a984 <rtems_termios_refill_transmitter+0xcc>
10aa22: 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);
10aa24: 83 ec 0c sub $0xc,%esp
10aa27: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
10aa2d: e8 7a 0d 00 00 call 10b7ac <rtems_semaphore_release>
10aa32: 83 c4 10 add $0x10,%esp
10aa35: e9 03 ff ff ff jmp 10a93d <rtems_termios_refill_transmitter+0x85>
10aa3a: 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);
10aa3c: 56 push %esi <== NOT EXECUTED
10aa3d: 6a 01 push $0x1 <== NOT EXECUTED
10aa3f: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED
10aa42: 50 push %eax <== NOT EXECUTED
10aa43: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10aa46: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
rtems_interrupt_disable(level);
10aa4c: 9c pushf <== NOT EXECUTED
10aa4d: fa cli <== NOT EXECUTED
10aa4e: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
10aa4f: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
10aa55: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10aa5b: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
10aa5e: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
rtems_interrupt_enable(level);
10aa64: 52 push %edx <== NOT EXECUTED
10aa65: 9d popf <== NOT EXECUTED
10aa66: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
nToSend = 1;
10aa69: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
10aa6e: 89 f8 mov %edi,%eax <== NOT EXECUTED
10aa70: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10aa73: 5b pop %ebx <== NOT EXECUTED
10aa74: 5e pop %esi <== NOT EXECUTED
10aa75: 5f pop %edi <== NOT EXECUTED
10aa76: c9 leave <== NOT EXECUTED
10aa77: 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);
10aa78: 51 push %ecx <== NOT EXECUTED
10aa79: 6a 01 push $0x1 <== NOT EXECUTED
10aa7b: 8d 43 49 lea 0x49(%ebx),%eax <== NOT EXECUTED
10aa7e: 50 push %eax <== NOT EXECUTED
10aa7f: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10aa82: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
rtems_interrupt_disable(level);
10aa88: 9c pushf <== NOT EXECUTED
10aa89: fa cli <== NOT EXECUTED
10aa8a: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
10aa8b: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
10aa91: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10aa97: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED
10aa9a: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
rtems_interrupt_enable(level);
10aaa0: 52 push %edx <== NOT EXECUTED
10aaa1: 9d popf <== NOT EXECUTED
10aaa2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
nToSend = 1;
10aaa5: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
10aaaa: 89 f8 mov %edi,%eax <== NOT EXECUTED
10aaac: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10aaaf: 5b pop %ebx <== NOT EXECUTED
10aab0: 5e pop %esi <== NOT EXECUTED
10aab1: 5f pop %edi <== NOT EXECUTED
10aab2: c9 leave <== NOT EXECUTED
10aab3: 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);
10aab4: 9c pushf <== NOT EXECUTED
10aab5: fa cli <== NOT EXECUTED
10aab6: 5a pop %edx <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
10aab7: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10aabd: 83 c8 20 or $0x20,%eax <== NOT EXECUTED
10aac0: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
10aac6: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED
10aacd: 00 00 00
rtems_interrupt_enable(level);
10aad0: 52 push %edx <== NOT EXECUTED
10aad1: 9d popf <== NOT EXECUTED
nToSend = 0;
10aad2: 31 ff xor %edi,%edi <== NOT EXECUTED
10aad4: e9 13 ff ff ff jmp 10a9ec <rtems_termios_refill_transmitter+0x134><== NOT EXECUTED
10aad9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
*/
if (tty->rawOutBufState == rob_wait) {
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
10aadc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aadf: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED
10aae5: e8 c2 0c 00 00 call 10b7ac <rtems_semaphore_release><== NOT EXECUTED
10aaea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
return 0;
10aaed: 31 ff xor %edi,%edi <== NOT EXECUTED
10aaef: e9 bf fe ff ff jmp 10a9b3 <rtems_termios_refill_transmitter+0xfb><== NOT EXECUTED
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
nToSend = 0;
10aaf4: 31 ff xor %edi,%edi
10aaf6: e9 f1 fe ff ff jmp 10a9ec <rtems_termios_refill_transmitter+0x134>
0010a84c <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
10a84c: 55 push %ebp
10a84d: 89 e5 mov %esp,%ebp
10a84f: 57 push %edi
10a850: 56 push %esi
10a851: 53 push %ebx
10a852: 83 ec 1c sub $0x1c,%esp
10a855: 8b 5d 08 mov 0x8(%ebp),%ebx
10a858: 8d 75 e0 lea -0x20(%ebp),%esi
10a85b: 8d 7d e7 lea -0x19(%ebp),%edi
10a85e: eb 14 jmp 10a874 <rtems_termios_rxdaemon+0x28>
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
10a860: 83 ec 0c sub $0xc,%esp
10a863: ff 73 10 pushl 0x10(%ebx)
10a866: ff 93 a0 00 00 00 call *0xa0(%ebx)
if (c != EOF) {
10a86c: 83 c4 10 add $0x10,%esp
10a86f: 83 f8 ff cmp $0xffffffff,%eax
10a872: 75 30 jne 10a8a4 <rtems_termios_rxdaemon+0x58>
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
10a874: 56 push %esi
10a875: 6a 00 push $0x0
10a877: 6a 02 push $0x2
10a879: 6a 03 push $0x3
10a87b: e8 94 07 00 00 call 10b014 <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) {
10a880: 83 c4 10 add $0x10,%esp
10a883: f6 45 e0 01 testb $0x1,-0x20(%ebp)
10a887: 74 d7 je 10a860 <rtems_termios_rxdaemon+0x14><== ALWAYS TAKEN
tty->rxTaskId = 0;
10a889: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) <== NOT EXECUTED
10a890: 00 00 00
rtems_task_delete(RTEMS_SELF);
10a893: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a896: 6a 00 push $0x0 <== NOT EXECUTED
10a898: e8 0f 11 00 00 call 10b9ac <rtems_task_delete> <== NOT EXECUTED
10a89d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a8a0: eb be jmp 10a860 <rtems_termios_rxdaemon+0x14><== NOT EXECUTED
10a8a2: 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;
10a8a4: 88 45 e7 mov %al,-0x19(%ebp)
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
10a8a7: 50 push %eax
10a8a8: 6a 01 push $0x1
10a8aa: 57 push %edi
10a8ab: 53 push %ebx
10a8ac: e8 8f fc ff ff call 10a540 <rtems_termios_enqueue_raw_characters>
10a8b1: 83 c4 10 add $0x10,%esp
10a8b4: eb be jmp 10a874 <rtems_termios_rxdaemon+0x28>
0010aafc <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
10aafc: 55 push %ebp
10aafd: 89 e5 mov %esp,%ebp
10aaff: 56 push %esi
10ab00: 53 push %ebx
10ab01: 83 ec 10 sub $0x10,%esp
10ab04: 8b 5d 08 mov 0x8(%ebp),%ebx
10ab07: 8d 75 f4 lea -0xc(%ebp),%esi
10ab0a: eb 28 jmp 10ab34 <rtems_termios_txdaemon+0x38>
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
10ab0c: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
10ab12: c1 e0 05 shl $0x5,%eax
10ab15: 8b 80 14 79 12 00 mov 0x127914(%eax),%eax
10ab1b: 85 c0 test %eax,%eax
10ab1d: 74 09 je 10ab28 <rtems_termios_txdaemon+0x2c><== ALWAYS TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
10ab1f: 83 ec 0c sub $0xc,%esp
10ab22: 53 push %ebx <== NOT EXECUTED
10ab23: ff d0 call *%eax <== NOT EXECUTED
10ab25: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
10ab28: 83 ec 0c sub $0xc,%esp
10ab2b: 53 push %ebx
10ab2c: e8 87 fd ff ff call 10a8b8 <rtems_termios_refill_transmitter>
}
10ab31: 83 c4 10 add $0x10,%esp
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
10ab34: 56 push %esi
10ab35: 6a 00 push $0x0
10ab37: 6a 02 push $0x2
10ab39: 6a 03 push $0x3
10ab3b: e8 d4 04 00 00 call 10b014 <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) {
10ab40: 83 c4 10 add $0x10,%esp
10ab43: f6 45 f4 01 testb $0x1,-0xc(%ebp)
10ab47: 74 c3 je 10ab0c <rtems_termios_txdaemon+0x10><== ALWAYS TAKEN
tty->txTaskId = 0;
10ab49: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED
10ab50: 00 00 00
rtems_task_delete(RTEMS_SELF);
10ab53: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ab56: 6a 00 push $0x0 <== NOT EXECUTED
10ab58: e8 4f 0e 00 00 call 10b9ac <rtems_task_delete> <== NOT EXECUTED
10ab5d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ab60: eb aa jmp 10ab0c <rtems_termios_txdaemon+0x10><== NOT EXECUTED
0010a10c <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
10a10c: 55 push %ebp
10a10d: 89 e5 mov %esp,%ebp
10a10f: 57 push %edi
10a110: 56 push %esi
10a111: 53 push %ebx
10a112: 83 ec 20 sub $0x20,%esp
10a115: 8b 7d 08 mov 0x8(%ebp),%edi
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
10a118: 8b 07 mov (%edi),%eax
10a11a: 8b 70 34 mov 0x34(%eax),%esi
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
10a11d: 6a 00 push $0x0
10a11f: 6a 00 push $0x0
10a121: ff 76 18 pushl 0x18(%esi)
10a124: e8 87 15 00 00 call 10b6b0 <rtems_semaphore_obtain>
10a129: 89 45 e4 mov %eax,-0x1c(%ebp)
if (sc != RTEMS_SUCCESSFUL)
10a12c: 83 c4 10 add $0x10,%esp
10a12f: 85 c0 test %eax,%eax
10a131: 75 29 jne 10a15c <rtems_termios_write+0x50><== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
10a133: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax
10a139: c1 e0 05 shl $0x5,%eax
10a13c: 8b 80 0c 79 12 00 mov 0x12790c(%eax),%eax
10a142: 85 c0 test %eax,%eax
10a144: 74 22 je 10a168 <rtems_termios_write+0x5c>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
10a146: 83 ec 08 sub $0x8,%esp
10a149: 57 push %edi
10a14a: 56 push %esi
10a14b: ff d0 call *%eax
10a14d: 89 45 e4 mov %eax,-0x1c(%ebp)
rtems_semaphore_release (tty->osem);
10a150: 5f pop %edi
10a151: ff 76 18 pushl 0x18(%esi)
10a154: e8 53 16 00 00 call 10b7ac <rtems_semaphore_release>
return sc;
10a159: 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;
}
10a15c: 8b 45 e4 mov -0x1c(%ebp),%eax
10a15f: 8d 65 f4 lea -0xc(%ebp),%esp
10a162: 5b pop %ebx
10a163: 5e pop %esi
10a164: 5f pop %edi
10a165: c9 leave
10a166: c3 ret
10a167: 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) {
10a168: f6 46 34 01 testb $0x1,0x34(%esi)
10a16c: 74 4e je 10a1bc <rtems_termios_write+0xb0><== NEVER TAKEN
uint32_t count = args->count;
10a16e: 8b 47 10 mov 0x10(%edi),%eax
10a171: 89 45 e0 mov %eax,-0x20(%ebp)
char *buffer = args->buffer;
10a174: 8b 47 0c mov 0xc(%edi),%eax
while (count--)
10a177: 8b 5d e0 mov -0x20(%ebp),%ebx
10a17a: 85 db test %ebx,%ebx
10a17c: 74 56 je 10a1d4 <rtems_termios_write+0xc8><== NEVER TAKEN
10a17e: 31 db xor %ebx,%ebx
10a180: 89 7d dc mov %edi,-0x24(%ebp)
10a183: 89 c7 mov %eax,%edi
10a185: 8d 76 00 lea 0x0(%esi),%esi
oproc (*buffer++, tty);
10a188: 0f b6 04 1f movzbl (%edi,%ebx,1),%eax
10a18c: 89 f2 mov %esi,%edx
10a18e: e8 6d fa ff ff call 109c00 <oproc>
10a193: 43 inc %ebx
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
10a194: 39 5d e0 cmp %ebx,-0x20(%ebp)
10a197: 75 ef jne 10a188 <rtems_termios_write+0x7c>
10a199: 8b 7d dc mov -0x24(%ebp),%edi
10a19c: 8b 47 10 mov 0x10(%edi),%eax
oproc (*buffer++, tty);
args->bytes_moved = args->count;
10a19f: 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);
10a1a2: 83 ec 0c sub $0xc,%esp
10a1a5: ff 76 18 pushl 0x18(%esi)
10a1a8: e8 ff 15 00 00 call 10b7ac <rtems_semaphore_release>
return sc;
10a1ad: 83 c4 10 add $0x10,%esp
}
10a1b0: 8b 45 e4 mov -0x1c(%ebp),%eax
10a1b3: 8d 65 f4 lea -0xc(%ebp),%esp
10a1b6: 5b pop %ebx
10a1b7: 5e pop %esi
10a1b8: 5f pop %edi
10a1b9: c9 leave
10a1ba: c3 ret
10a1bb: 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);
10a1bc: 51 push %ecx <== NOT EXECUTED
10a1bd: 56 push %esi <== NOT EXECUTED
10a1be: ff 77 10 pushl 0x10(%edi) <== NOT EXECUTED
10a1c1: ff 77 0c pushl 0xc(%edi) <== NOT EXECUTED
10a1c4: e8 03 f9 ff ff call 109acc <rtems_termios_puts> <== NOT EXECUTED
args->bytes_moved = args->count;
10a1c9: 8b 47 10 mov 0x10(%edi),%eax <== NOT EXECUTED
10a1cc: 89 47 18 mov %eax,0x18(%edi) <== NOT EXECUTED
10a1cf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a1d2: eb ce jmp 10a1a2 <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--)
10a1d4: 31 c0 xor %eax,%eax <== NOT EXECUTED
10a1d6: eb c7 jmp 10a19f <rtems_termios_write+0x93><== NOT EXECUTED
001186d4 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
1186d4: 55 push %ebp
1186d5: 89 e5 mov %esp,%ebp
1186d7: 83 ec 1c sub $0x1c,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
1186da: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
1186dd: 50 push %eax
1186de: ff 75 08 pushl 0x8(%ebp)
1186e1: 68 60 34 14 00 push $0x143460
1186e6: e8 f1 2b 00 00 call 11b2dc <_Objects_Get>
switch ( location ) {
1186eb: 83 c4 10 add $0x10,%esp
1186ee: 8b 55 f4 mov -0xc(%ebp),%edx
1186f1: 85 d2 test %edx,%edx
1186f3: 74 07 je 1186fc <rtems_timer_cancel+0x28>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1186f5: b8 04 00 00 00 mov $0x4,%eax
}
1186fa: c9 leave
1186fb: c3 ret
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
1186fc: 83 78 38 04 cmpl $0x4,0x38(%eax)
118700: 74 0f je 118711 <rtems_timer_cancel+0x3d><== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
118702: 83 ec 0c sub $0xc,%esp
118705: 83 c0 10 add $0x10,%eax
118708: 50 push %eax
118709: e8 82 48 00 00 call 11cf90 <_Watchdog_Remove>
11870e: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
118711: e8 3e 37 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
118716: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118718: c9 leave
118719: c3 ret
0010bff0 <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
10bff0: 55 push %ebp
10bff1: 89 e5 mov %esp,%ebp
10bff3: 57 push %edi
10bff4: 56 push %esi
10bff5: 53 push %ebx
10bff6: 83 ec 0c sub $0xc,%esp
10bff9: 8b 5d 08 mov 0x8(%ebp),%ebx
10bffc: 8b 75 0c mov 0xc(%ebp),%esi
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
10bfff: 85 db test %ebx,%ebx
10c001: 74 6d je 10c070 <rtems_timer_create+0x80>
return RTEMS_INVALID_NAME;
if ( !id )
10c003: 85 f6 test %esi,%esi
10c005: 0f 84 89 00 00 00 je 10c094 <rtems_timer_create+0xa4>
10c00b: a1 10 98 12 00 mov 0x129810,%eax
10c010: 40 inc %eax
10c011: a3 10 98 12 00 mov %eax,0x129810
* 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 );
10c016: 83 ec 0c sub $0xc,%esp
10c019: 68 40 a2 12 00 push $0x12a240
10c01e: e8 31 0f 00 00 call 10cf54 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
10c023: 83 c4 10 add $0x10,%esp
10c026: 85 c0 test %eax,%eax
10c028: 74 56 je 10c080 <rtems_timer_create+0x90>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_timer->the_class = TIMER_DORMANT;
10c02a: 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;
10c031: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10c038: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
the_watchdog->id = id;
10c03f: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
the_watchdog->user_data = user_data;
10c046: 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 ),
10c04d: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10c050: 0f b7 fa movzwl %dx,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c053: 8b 0d 5c a2 12 00 mov 0x12a25c,%ecx
10c059: 89 04 b9 mov %eax,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10c05c: 89 58 0c mov %ebx,0xc(%eax)
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
10c05f: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
10c061: e8 1a 1f 00 00 call 10df80 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c066: 31 c0 xor %eax,%eax
}
10c068: 8d 65 f4 lea -0xc(%ebp),%esp
10c06b: 5b pop %ebx
10c06c: 5e pop %esi
10c06d: 5f pop %edi
10c06e: c9 leave
10c06f: c3 ret
)
{
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10c070: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c075: 8d 65 f4 lea -0xc(%ebp),%esp
10c078: 5b pop %ebx
10c079: 5e pop %esi
10c07a: 5f pop %edi
10c07b: c9 leave
10c07c: c3 ret
10c07d: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
_Thread_Enable_dispatch();
10c080: e8 fb 1e 00 00 call 10df80 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
10c085: b8 05 00 00 00 mov $0x5,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c08a: 8d 65 f4 lea -0xc(%ebp),%esp
10c08d: 5b pop %ebx
10c08e: 5e pop %esi
10c08f: 5f pop %edi
10c090: c9 leave
10c091: c3 ret
10c092: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10c094: b8 09 00 00 00 mov $0x9,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c099: 8d 65 f4 lea -0xc(%ebp),%esp
10c09c: 5b pop %ebx
10c09d: 5e pop %esi
10c09e: 5f pop %edi
10c09f: c9 leave
10c0a0: c3 ret
001187d0 <rtems_timer_delete>:
*/
rtems_status_code rtems_timer_delete(
rtems_id id
)
{
1187d0: 55 push %ebp
1187d1: 89 e5 mov %esp,%ebp
1187d3: 53 push %ebx
1187d4: 83 ec 18 sub $0x18,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
1187d7: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
1187da: 50 push %eax
1187db: ff 75 08 pushl 0x8(%ebp)
1187de: 68 60 34 14 00 push $0x143460
1187e3: e8 f4 2a 00 00 call 11b2dc <_Objects_Get>
1187e8: 89 c3 mov %eax,%ebx
switch ( location ) {
1187ea: 83 c4 10 add $0x10,%esp
1187ed: 8b 4d f4 mov -0xc(%ebp),%ecx
1187f0: 85 c9 test %ecx,%ecx
1187f2: 75 38 jne 11882c <rtems_timer_delete+0x5c>
case OBJECTS_LOCAL:
_Objects_Close( &_Timer_Information, &the_timer->Object );
1187f4: 83 ec 08 sub $0x8,%esp
1187f7: 50 push %eax
1187f8: 68 60 34 14 00 push $0x143460
1187fd: e8 66 26 00 00 call 11ae68 <_Objects_Close>
(void) _Watchdog_Remove( &the_timer->Ticker );
118802: 8d 43 10 lea 0x10(%ebx),%eax
118805: 89 04 24 mov %eax,(%esp)
118808: e8 83 47 00 00 call 11cf90 <_Watchdog_Remove>
*/
RTEMS_INLINE_ROUTINE void _Timer_Free (
Timer_Control *the_timer
)
{
_Objects_Free( &_Timer_Information, &the_timer->Object );
11880d: 58 pop %eax
11880e: 5a pop %edx
11880f: 53 push %ebx
118810: 68 60 34 14 00 push $0x143460
118815: e8 46 29 00 00 call 11b160 <_Objects_Free>
_Timer_Free( the_timer );
_Thread_Enable_dispatch();
11881a: e8 35 36 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11881f: 83 c4 10 add $0x10,%esp
118822: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118824: 8b 5d fc mov -0x4(%ebp),%ebx
118827: c9 leave
118828: c3 ret
118829: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
11882c: b8 04 00 00 00 mov $0x4,%eax
}
118831: 8b 5d fc mov -0x4(%ebp),%ebx
118834: c9 leave
118835: c3 ret
0010c0a4 <rtems_timer_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
10c0a4: 55 push %ebp
10c0a5: 89 e5 mov %esp,%ebp
10c0a7: 57 push %edi
10c0a8: 56 push %esi
10c0a9: 53 push %ebx
10c0aa: 83 ec 2c sub $0x2c,%esp
10c0ad: 8b 5d 0c mov 0xc(%ebp),%ebx
10c0b0: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
10c0b3: 85 db test %ebx,%ebx
10c0b5: 0f 84 99 00 00 00 je 10c154 <rtems_timer_fire_after+0xb0>
return RTEMS_INVALID_NUMBER;
if ( !routine )
10c0bb: 85 f6 test %esi,%esi
10c0bd: 0f 84 b1 00 00 00 je 10c174 <rtems_timer_fire_after+0xd0>
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
10c0c3: 57 push %edi
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
10c0c4: 8d 45 e4 lea -0x1c(%ebp),%eax
10c0c7: 50 push %eax
10c0c8: ff 75 08 pushl 0x8(%ebp)
10c0cb: 68 40 a2 12 00 push $0x12a240
10c0d0: e8 33 13 00 00 call 10d408 <_Objects_Get>
10c0d5: 89 c7 mov %eax,%edi
switch ( location ) {
10c0d7: 83 c4 10 add $0x10,%esp
10c0da: 8b 4d e4 mov -0x1c(%ebp),%ecx
10c0dd: 85 c9 test %ecx,%ecx
10c0df: 74 0f je 10c0f0 <rtems_timer_fire_after+0x4c>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10c0e1: b8 04 00 00 00 mov $0x4,%eax
}
10c0e6: 8d 65 f4 lea -0xc(%ebp),%esp
10c0e9: 5b pop %ebx
10c0ea: 5e pop %esi
10c0eb: 5f pop %edi
10c0ec: c9 leave
10c0ed: c3 ret
10c0ee: 66 90 xchg %ax,%ax
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
10c0f0: 8d 50 10 lea 0x10(%eax),%edx
10c0f3: 83 ec 0c sub $0xc,%esp
10c0f6: 52 push %edx
10c0f7: 89 55 d4 mov %edx,-0x2c(%ebp)
10c0fa: e8 31 2d 00 00 call 10ee30 <_Watchdog_Remove>
_ISR_Disable( level );
10c0ff: 9c pushf
10c100: fa cli
10c101: 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 ) {
10c102: 83 c4 10 add $0x10,%esp
10c105: 8b 57 18 mov 0x18(%edi),%edx
10c108: 85 d2 test %edx,%edx
10c10a: 8b 55 d4 mov -0x2c(%ebp),%edx
10c10d: 75 55 jne 10c164 <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;
10c10f: 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;
10c116: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
the_watchdog->routine = routine;
10c11d: 89 77 2c mov %esi,0x2c(%edi)
the_watchdog->id = id;
10c120: 8b 4d 08 mov 0x8(%ebp),%ecx
10c123: 89 4f 30 mov %ecx,0x30(%edi)
the_watchdog->user_data = user_data;
10c126: 8b 4d 14 mov 0x14(%ebp),%ecx
10c129: 89 4f 34 mov %ecx,0x34(%edi)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_ISR_Enable( level );
10c12c: 50 push %eax
10c12d: 9d popf
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10c12e: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10c131: 83 ec 08 sub $0x8,%esp
10c134: 52 push %edx
10c135: 68 e0 98 12 00 push $0x1298e0
10c13a: e8 b1 2b 00 00 call 10ecf0 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
_Thread_Enable_dispatch();
10c13f: e8 3c 1e 00 00 call 10df80 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c144: 83 c4 10 add $0x10,%esp
10c147: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c149: 8d 65 f4 lea -0xc(%ebp),%esp
10c14c: 5b pop %ebx
10c14d: 5e pop %esi
10c14e: 5f pop %edi
10c14f: c9 leave
10c150: c3 ret
10c151: 8d 76 00 lea 0x0(%esi),%esi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
10c154: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c159: 8d 65 f4 lea -0xc(%ebp),%esp
10c15c: 5b pop %ebx
10c15d: 5e pop %esi
10c15e: 5f pop %edi
10c15f: c9 leave
10c160: c3 ret
10c161: 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 );
10c164: 50 push %eax
10c165: 9d popf
_Thread_Enable_dispatch();
10c166: e8 15 1e 00 00 call 10df80 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c16b: 31 c0 xor %eax,%eax
10c16d: e9 74 ff ff ff jmp 10c0e6 <rtems_timer_fire_after+0x42>
10c172: 66 90 xchg %ax,%ax
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
10c174: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c179: 8d 65 f4 lea -0xc(%ebp),%esp
10c17c: 5b pop %ebx
10c17d: 5e pop %esi
10c17e: 5f pop %edi
10c17f: c9 leave
10c180: c3 ret
00118918 <rtems_timer_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
118918: 55 push %ebp
118919: 89 e5 mov %esp,%ebp
11891b: 57 push %edi
11891c: 56 push %esi
11891d: 53 push %ebx
11891e: 83 ec 2c sub $0x2c,%esp
118921: 8b 75 08 mov 0x8(%ebp),%esi
118924: 8b 7d 0c mov 0xc(%ebp),%edi
118927: 8b 5d 10 mov 0x10(%ebp),%ebx
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
11892a: 80 3d 44 2a 14 00 00 cmpb $0x0,0x142a44
118931: 75 0d jne 118940 <rtems_timer_fire_when+0x28>
return RTEMS_NOT_DEFINED;
118933: b8 0b 00 00 00 mov $0xb,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118938: 8d 65 f4 lea -0xc(%ebp),%esp
11893b: 5b pop %ebx
11893c: 5e pop %esi
11893d: 5f pop %edi
11893e: c9 leave
11893f: c3 ret
rtems_interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
118940: 83 ec 0c sub $0xc,%esp
118943: 57 push %edi
118944: e8 93 d4 ff ff call 115ddc <_TOD_Validate>
118949: 83 c4 10 add $0x10,%esp
11894c: 84 c0 test %al,%al
11894e: 74 1e je 11896e <rtems_timer_fire_when+0x56>
return RTEMS_INVALID_CLOCK;
if ( !routine )
118950: 85 db test %ebx,%ebx
118952: 0f 84 a4 00 00 00 je 1189fc <rtems_timer_fire_when+0xe4>
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
118958: 83 ec 0c sub $0xc,%esp
11895b: 57 push %edi
11895c: e8 ef d3 ff ff call 115d50 <_TOD_To_seconds>
118961: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
118963: 83 c4 10 add $0x10,%esp
118966: 3b 05 c8 2a 14 00 cmp 0x142ac8,%eax
11896c: 77 0e ja 11897c <rtems_timer_fire_when+0x64>
return RTEMS_INVALID_CLOCK;
11896e: b8 14 00 00 00 mov $0x14,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118973: 8d 65 f4 lea -0xc(%ebp),%esp
118976: 5b pop %ebx
118977: 5e pop %esi
118978: 5f pop %edi
118979: c9 leave
11897a: c3 ret
11897b: 90 nop
11897c: 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 );
11897d: 8d 45 e4 lea -0x1c(%ebp),%eax
118980: 50 push %eax
118981: 56 push %esi
118982: 68 60 34 14 00 push $0x143460
118987: e8 50 29 00 00 call 11b2dc <_Objects_Get>
switch ( location ) {
11898c: 83 c4 10 add $0x10,%esp
11898f: 8b 4d e4 mov -0x1c(%ebp),%ecx
118992: 85 c9 test %ecx,%ecx
118994: 75 5a jne 1189f0 <rtems_timer_fire_when+0xd8>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
118996: 8d 48 10 lea 0x10(%eax),%ecx
118999: 83 ec 0c sub $0xc,%esp
11899c: 51 push %ecx
11899d: 89 45 d0 mov %eax,-0x30(%ebp)
1189a0: 89 4d d4 mov %ecx,-0x2c(%ebp)
1189a3: e8 e8 45 00 00 call 11cf90 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY;
1189a8: 8b 55 d0 mov -0x30(%ebp),%edx
1189ab: 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;
1189b2: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
1189b9: 89 5a 2c mov %ebx,0x2c(%edx)
the_watchdog->id = id;
1189bc: 89 72 30 mov %esi,0x30(%edx)
the_watchdog->user_data = user_data;
1189bf: 8b 45 14 mov 0x14(%ebp),%eax
1189c2: 89 42 34 mov %eax,0x34(%edx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_Watchdog_Insert_seconds(
1189c5: 2b 3d c8 2a 14 00 sub 0x142ac8,%edi
1189cb: 89 7a 1c mov %edi,0x1c(%edx)
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
1189ce: 58 pop %eax
1189cf: 5a pop %edx
1189d0: 8b 4d d4 mov -0x2c(%ebp),%ecx
1189d3: 51 push %ecx
1189d4: 68 f4 2a 14 00 push $0x142af4
1189d9: e8 72 44 00 00 call 11ce50 <_Watchdog_Insert>
&the_timer->Ticker,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
1189de: e8 71 34 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1189e3: 83 c4 10 add $0x10,%esp
1189e6: 31 c0 xor %eax,%eax
1189e8: e9 4b ff ff ff jmp 118938 <rtems_timer_fire_when+0x20>
1189ed: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1189f0: b8 04 00 00 00 mov $0x4,%eax
1189f5: e9 3e ff ff ff jmp 118938 <rtems_timer_fire_when+0x20>
1189fa: 66 90 xchg %ax,%ax
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
1189fc: b8 09 00 00 00 mov $0x9,%eax
118a01: e9 32 ff ff ff jmp 118938 <rtems_timer_fire_when+0x20>
001190b0 <rtems_timer_initiate_server>:
rtems_status_code rtems_timer_initiate_server(
uint32_t priority,
uint32_t stack_size,
rtems_attribute attribute_set
)
{
1190b0: 55 push %ebp
1190b1: 89 e5 mov %esp,%ebp
1190b3: 56 push %esi
1190b4: 53 push %ebx
1190b5: 83 ec 10 sub $0x10,%esp
1190b8: 8b 45 08 mov 0x8(%ebp),%eax
1190bb: 85 c0 test %eax,%eax
1190bd: 74 41 je 119100 <rtems_timer_initiate_server+0x50>
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
1190bf: 0f b6 15 d4 a2 13 00 movzbl 0x13a2d4,%edx
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
1190c6: 39 d0 cmp %edx,%eax
1190c8: 76 42 jbe 11910c <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 )
1190ca: 40 inc %eax
1190cb: 75 33 jne 119100 <rtems_timer_initiate_server+0x50>
return RTEMS_INVALID_PRIORITY;
_priority = 0;
1190cd: 31 f6 xor %esi,%esi
1190cf: 8b 15 30 2a 14 00 mov 0x142a30,%edx
1190d5: 42 inc %edx
1190d6: 89 15 30 2a 14 00 mov %edx,0x142a30
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
1190dc: 8a 1d 60 e3 13 00 mov 0x13e360,%bl
initialized = true;
1190e2: c6 05 60 e3 13 00 01 movb $0x1,0x13e360
_Thread_Enable_dispatch();
1190e9: e8 66 2d 00 00 call 11be54 <_Thread_Enable_dispatch>
if ( tmpInitialized )
1190ee: 84 db test %bl,%bl
1190f0: 74 1e je 119110 <rtems_timer_initiate_server+0x60>
return RTEMS_INCORRECT_STATE;
1190f2: b8 0e 00 00 00 mov $0xe,%eax
initialized = false;
}
#endif
return status;
}
1190f7: 8d 65 f8 lea -0x8(%ebp),%esp
1190fa: 5b pop %ebx
1190fb: 5e pop %esi
1190fc: c9 leave
1190fd: c3 ret
1190fe: 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;
119100: b8 13 00 00 00 mov $0x13,%eax
initialized = false;
}
#endif
return status;
}
119105: 8d 65 f8 lea -0x8(%ebp),%esp
119108: 5b pop %ebx
119109: 5e pop %esi
11910a: c9 leave
11910b: c3 ret
11910c: 89 c6 mov %eax,%esi
11910e: eb bf jmp 1190cf <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(
119110: 83 ec 08 sub $0x8,%esp
119113: 8d 45 f4 lea -0xc(%ebp),%eax
119116: 50 push %eax
119117: 8b 45 10 mov 0x10(%ebp),%eax
11911a: 80 cc 80 or $0x80,%ah
11911d: 50 push %eax
11911e: 68 00 01 00 00 push $0x100
119123: ff 75 0c pushl 0xc(%ebp)
119126: 56 push %esi
119127: 68 45 4d 49 54 push $0x54494d45
11912c: e8 c7 ec ff ff call 117df8 <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) {
119131: 83 c4 20 add $0x20,%esp
119134: 85 c0 test %eax,%eax
119136: 74 10 je 119148 <rtems_timer_initiate_server+0x98>
initialized = false;
119138: c6 05 60 e3 13 00 00 movb $0x0,0x13e360
initialized = false;
}
#endif
return status;
}
11913f: 8d 65 f8 lea -0x8(%ebp),%esp
119142: 5b pop %ebx
119143: 5e pop %esi
119144: c9 leave
119145: c3 ret
119146: 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)
119148: 8b 45 f4 mov -0xc(%ebp),%eax
*/
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return NULL;
#endif
return information->local_table[ index ];
11914b: 0f b7 c8 movzwl %ax,%ecx
11914e: 8b 15 dc 29 14 00 mov 0x1429dc,%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(
119154: 8b 14 8a mov (%edx,%ecx,4),%edx
119157: 89 15 e0 e2 13 00 mov %edx,0x13e2e0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
11915d: c7 05 10 e3 13 00 14 movl $0x13e314,0x13e310
119164: e3 13 00
head->previous = NULL;
119167: c7 05 14 e3 13 00 00 movl $0x0,0x13e314
11916e: 00 00 00
tail->previous = head;
119171: c7 05 18 e3 13 00 10 movl $0x13e310,0x13e318
119178: e3 13 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
11917b: c7 05 48 e3 13 00 4c movl $0x13e34c,0x13e348
119182: e3 13 00
head->previous = NULL;
119185: c7 05 4c e3 13 00 00 movl $0x0,0x13e34c
11918c: 00 00 00
tail->previous = head;
11918f: c7 05 50 e3 13 00 48 movl $0x13e348,0x13e350
119196: e3 13 00
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
119199: c7 05 f0 e2 13 00 00 movl $0x0,0x13e2f0
1191a0: 00 00 00
the_watchdog->routine = routine;
1191a3: c7 05 04 e3 13 00 a0 movl $0x11bca0,0x13e304
1191aa: bc 11 00
the_watchdog->id = id;
1191ad: a3 08 e3 13 00 mov %eax,0x13e308
the_watchdog->user_data = user_data;
1191b2: c7 05 0c e3 13 00 00 movl $0x0,0x13e30c
1191b9: 00 00 00
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
1191bc: c7 05 28 e3 13 00 00 movl $0x0,0x13e328
1191c3: 00 00 00
the_watchdog->routine = routine;
1191c6: c7 05 3c e3 13 00 a0 movl $0x11bca0,0x13e33c
1191cd: bc 11 00
the_watchdog->id = id;
1191d0: a3 40 e3 13 00 mov %eax,0x13e340
the_watchdog->user_data = user_data;
1191d5: c7 05 44 e3 13 00 00 movl $0x0,0x13e344
1191dc: 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;
1191df: c7 05 e4 e2 13 00 80 movl $0x118f80,0x13e2e4
1191e6: 8f 11 00
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
1191e9: 8b 15 64 2b 14 00 mov 0x142b64,%edx
1191ef: 89 15 1c e3 13 00 mov %edx,0x13e31c
ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
1191f5: 8b 15 c8 2a 14 00 mov 0x142ac8,%edx
1191fb: 89 15 54 e3 13 00 mov %edx,0x13e354
ts->insert_chain = NULL;
119201: c7 05 58 e3 13 00 00 movl $0x0,0x13e358
119208: 00 00 00
ts->active = false;
11920b: c6 05 5c e3 13 00 00 movb $0x0,0x13e35c
/*
* The default timer server is now available.
*/
_Timer_server = ts;
119212: c7 05 a0 34 14 00 e0 movl $0x13e2e0,0x1434a0
119219: e2 13 00
/*
* Start the timer server
*/
status = rtems_task_start(
11921c: 53 push %ebx
11921d: 68 e0 e2 13 00 push $0x13e2e0
119222: 68 b8 8d 11 00 push $0x118db8
119227: 50 push %eax
119228: e8 8b f2 ff ff call 1184b8 <rtems_task_start>
if (status) {
initialized = false;
}
#endif
return status;
11922d: 83 c4 10 add $0x10,%esp
119230: e9 d0 fe ff ff jmp 119105 <rtems_timer_initiate_server+0x55>
00118a90 <rtems_timer_reset>:
*/
rtems_status_code rtems_timer_reset(
rtems_id id
)
{
118a90: 55 push %ebp
118a91: 89 e5 mov %esp,%ebp
118a93: 56 push %esi
118a94: 53 push %ebx
118a95: 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 );
118a98: 8d 45 f4 lea -0xc(%ebp),%eax
118a9b: 50 push %eax
118a9c: ff 75 08 pushl 0x8(%ebp)
118a9f: 68 60 34 14 00 push $0x143460
118aa4: e8 33 28 00 00 call 11b2dc <_Objects_Get>
118aa9: 89 c3 mov %eax,%ebx
switch ( location ) {
118aab: 83 c4 10 add $0x10,%esp
118aae: 8b 45 f4 mov -0xc(%ebp),%eax
118ab1: 85 c0 test %eax,%eax
118ab3: 74 0f je 118ac4 <rtems_timer_reset+0x34>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118ab5: b8 04 00 00 00 mov $0x4,%eax
}
118aba: 8d 65 f8 lea -0x8(%ebp),%esp
118abd: 5b pop %ebx
118abe: 5e pop %esi
118abf: c9 leave
118ac0: c3 ret
118ac1: 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 ) {
118ac4: 8b 43 38 mov 0x38(%ebx),%eax
118ac7: 85 c0 test %eax,%eax
118ac9: 74 1d je 118ae8 <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 ) {
118acb: 48 dec %eax
118acc: 74 3a je 118b08 <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;
118ace: b8 0b 00 00 00 mov $0xb,%eax
}
_Thread_Enable_dispatch();
118ad3: 89 45 e4 mov %eax,-0x1c(%ebp)
118ad6: e8 79 33 00 00 call 11be54 <_Thread_Enable_dispatch>
return status;
118adb: 8b 45 e4 mov -0x1c(%ebp),%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118ade: 8d 65 f8 lea -0x8(%ebp),%esp
118ae1: 5b pop %ebx
118ae2: 5e pop %esi
118ae3: c9 leave
118ae4: c3 ret
118ae5: 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 );
118ae8: 83 c3 10 add $0x10,%ebx
118aeb: 83 ec 0c sub $0xc,%esp
118aee: 53 push %ebx
118aef: e8 9c 44 00 00 call 11cf90 <_Watchdog_Remove>
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
118af4: 59 pop %ecx
118af5: 5e pop %esi
118af6: 53 push %ebx
118af7: 68 00 2b 14 00 push $0x142b00
118afc: e8 4f 43 00 00 call 11ce50 <_Watchdog_Insert>
118b01: 83 c4 10 add $0x10,%esp
rtems_id id
)
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
118b04: 31 c0 xor %eax,%eax
118b06: eb cb jmp 118ad3 <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;
118b08: 8b 35 a0 34 14 00 mov 0x1434a0,%esi
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
118b0e: 83 ec 0c sub $0xc,%esp
118b11: 8d 43 10 lea 0x10(%ebx),%eax
118b14: 50 push %eax
118b15: e8 76 44 00 00 call 11cf90 <_Watchdog_Remove>
(*timer_server->schedule_operation)( timer_server, the_timer );
118b1a: 58 pop %eax
118b1b: 5a pop %edx
118b1c: 53 push %ebx
118b1d: 56 push %esi
118b1e: ff 56 04 call *0x4(%esi)
118b21: 83 c4 10 add $0x10,%esp
rtems_id id
)
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
118b24: 31 c0 xor %eax,%eax
118b26: eb ab jmp 118ad3 <rtems_timer_reset+0x43>
00118b28 <rtems_timer_server_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
118b28: 55 push %ebp
118b29: 89 e5 mov %esp,%ebp
118b2b: 57 push %edi
118b2c: 56 push %esi
118b2d: 53 push %ebx
118b2e: 83 ec 2c sub $0x2c,%esp
118b31: 8b 7d 0c mov 0xc(%ebp),%edi
118b34: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
118b37: 8b 1d a0 34 14 00 mov 0x1434a0,%ebx
if ( !timer_server )
118b3d: 85 db test %ebx,%ebx
118b3f: 0f 84 9f 00 00 00 je 118be4 <rtems_timer_server_fire_after+0xbc>
return RTEMS_INCORRECT_STATE;
if ( !routine )
118b45: 85 f6 test %esi,%esi
118b47: 0f 84 a3 00 00 00 je 118bf0 <rtems_timer_server_fire_after+0xc8>
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
118b4d: 85 ff test %edi,%edi
118b4f: 75 0f jne 118b60 <rtems_timer_server_fire_after+0x38>
return RTEMS_INVALID_NUMBER;
118b51: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118b56: 8d 65 f4 lea -0xc(%ebp),%esp
118b59: 5b pop %ebx
118b5a: 5e pop %esi
118b5b: 5f pop %edi
118b5c: c9 leave
118b5d: c3 ret
118b5e: 66 90 xchg %ax,%ax
118b60: 52 push %edx
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
118b61: 8d 45 e4 lea -0x1c(%ebp),%eax
118b64: 50 push %eax
118b65: ff 75 08 pushl 0x8(%ebp)
118b68: 68 60 34 14 00 push $0x143460
118b6d: e8 6a 27 00 00 call 11b2dc <_Objects_Get>
118b72: 89 c2 mov %eax,%edx
switch ( location ) {
118b74: 83 c4 10 add $0x10,%esp
118b77: 8b 45 e4 mov -0x1c(%ebp),%eax
118b7a: 85 c0 test %eax,%eax
118b7c: 75 56 jne 118bd4 <rtems_timer_server_fire_after+0xac>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
118b7e: 83 ec 0c sub $0xc,%esp
118b81: 8d 42 10 lea 0x10(%edx),%eax
118b84: 50 push %eax
118b85: 89 55 d4 mov %edx,-0x2c(%ebp)
118b88: e8 03 44 00 00 call 11cf90 <_Watchdog_Remove>
_ISR_Disable( level );
118b8d: 9c pushf
118b8e: fa cli
118b8f: 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 ) {
118b90: 83 c4 10 add $0x10,%esp
118b93: 8b 55 d4 mov -0x2c(%ebp),%edx
118b96: 8b 4a 18 mov 0x18(%edx),%ecx
118b99: 85 c9 test %ecx,%ecx
118b9b: 75 5f jne 118bfc <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;
118b9d: 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;
118ba4: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
118bab: 89 72 2c mov %esi,0x2c(%edx)
the_watchdog->id = id;
118bae: 8b 4d 08 mov 0x8(%ebp),%ecx
118bb1: 89 4a 30 mov %ecx,0x30(%edx)
the_watchdog->user_data = user_data;
118bb4: 8b 4d 14 mov 0x14(%ebp),%ecx
118bb7: 89 4a 34 mov %ecx,0x34(%edx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = ticks;
118bba: 89 7a 1c mov %edi,0x1c(%edx)
_ISR_Enable( level );
118bbd: 50 push %eax
118bbe: 9d popf
(*timer_server->schedule_operation)( timer_server, the_timer );
118bbf: 83 ec 08 sub $0x8,%esp
118bc2: 52 push %edx
118bc3: 53 push %ebx
118bc4: ff 53 04 call *0x4(%ebx)
_Thread_Enable_dispatch();
118bc7: e8 88 32 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
118bcc: 83 c4 10 add $0x10,%esp
118bcf: 31 c0 xor %eax,%eax
118bd1: eb 83 jmp 118b56 <rtems_timer_server_fire_after+0x2e>
118bd3: 90 nop
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118bd4: b8 04 00 00 00 mov $0x4,%eax
}
118bd9: 8d 65 f4 lea -0xc(%ebp),%esp
118bdc: 5b pop %ebx
118bdd: 5e pop %esi
118bde: 5f pop %edi
118bdf: c9 leave
118be0: c3 ret
118be1: 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;
118be4: b8 0e 00 00 00 mov $0xe,%eax
118be9: e9 68 ff ff ff jmp 118b56 <rtems_timer_server_fire_after+0x2e>
118bee: 66 90 xchg %ax,%ax
if ( !routine )
return RTEMS_INVALID_ADDRESS;
118bf0: b8 09 00 00 00 mov $0x9,%eax
118bf5: e9 5c ff ff ff jmp 118b56 <rtems_timer_server_fire_after+0x2e>
118bfa: 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 );
118bfc: 50 push %eax
118bfd: 9d popf
_Thread_Enable_dispatch();
118bfe: e8 51 32 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
118c03: 31 c0 xor %eax,%eax
118c05: e9 4c ff ff ff jmp 118b56 <rtems_timer_server_fire_after+0x2e>
00118c0c <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
118c0c: 55 push %ebp
118c0d: 89 e5 mov %esp,%ebp
118c0f: 57 push %edi
118c10: 56 push %esi
118c11: 53 push %ebx
118c12: 83 ec 2c sub $0x2c,%esp
118c15: 8b 7d 0c mov 0xc(%ebp),%edi
118c18: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
118c1b: 8b 1d a0 34 14 00 mov 0x1434a0,%ebx
if ( !timer_server )
118c21: 85 db test %ebx,%ebx
118c23: 0f 84 d7 00 00 00 je 118d00 <rtems_timer_server_fire_when+0xf4>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
118c29: 80 3d 44 2a 14 00 00 cmpb $0x0,0x142a44
118c30: 0f 84 aa 00 00 00 je 118ce0 <rtems_timer_server_fire_when+0xd4><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
118c36: 85 f6 test %esi,%esi
118c38: 0f 84 b2 00 00 00 je 118cf0 <rtems_timer_server_fire_when+0xe4>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
118c3e: 83 ec 0c sub $0xc,%esp
118c41: 57 push %edi
118c42: e8 95 d1 ff ff call 115ddc <_TOD_Validate>
118c47: 83 c4 10 add $0x10,%esp
118c4a: 84 c0 test %al,%al
118c4c: 75 0e jne 118c5c <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;
118c4e: b8 14 00 00 00 mov $0x14,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118c53: 8d 65 f4 lea -0xc(%ebp),%esp
118c56: 5b pop %ebx
118c57: 5e pop %esi
118c58: 5f pop %edi
118c59: c9 leave
118c5a: c3 ret
118c5b: 90 nop
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
118c5c: 83 ec 0c sub $0xc,%esp
118c5f: 57 push %edi
118c60: e8 eb d0 ff ff call 115d50 <_TOD_To_seconds>
118c65: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
118c67: 83 c4 10 add $0x10,%esp
118c6a: 3b 05 c8 2a 14 00 cmp 0x142ac8,%eax
118c70: 76 dc jbe 118c4e <rtems_timer_server_fire_when+0x42>
118c72: 52 push %edx
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
118c73: 8d 45 e4 lea -0x1c(%ebp),%eax
118c76: 50 push %eax
118c77: ff 75 08 pushl 0x8(%ebp)
118c7a: 68 60 34 14 00 push $0x143460
118c7f: e8 58 26 00 00 call 11b2dc <_Objects_Get>
118c84: 89 c2 mov %eax,%edx
switch ( location ) {
118c86: 83 c4 10 add $0x10,%esp
118c89: 8b 45 e4 mov -0x1c(%ebp),%eax
118c8c: 85 c0 test %eax,%eax
118c8e: 75 7c jne 118d0c <rtems_timer_server_fire_when+0x100>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
118c90: 83 ec 0c sub $0xc,%esp
118c93: 8d 42 10 lea 0x10(%edx),%eax
118c96: 50 push %eax
118c97: 89 55 d4 mov %edx,-0x2c(%ebp)
118c9a: e8 f1 42 00 00 call 11cf90 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
118c9f: 8b 55 d4 mov -0x2c(%ebp),%edx
118ca2: 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;
118ca9: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
118cb0: 89 72 2c mov %esi,0x2c(%edx)
the_watchdog->id = id;
118cb3: 8b 45 08 mov 0x8(%ebp),%eax
118cb6: 89 42 30 mov %eax,0x30(%edx)
the_watchdog->user_data = user_data;
118cb9: 8b 45 14 mov 0x14(%ebp),%eax
118cbc: 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();
118cbf: 2b 3d c8 2a 14 00 sub 0x142ac8,%edi
118cc5: 89 7a 1c mov %edi,0x1c(%edx)
(*timer_server->schedule_operation)( timer_server, the_timer );
118cc8: 58 pop %eax
118cc9: 59 pop %ecx
118cca: 52 push %edx
118ccb: 53 push %ebx
118ccc: ff 53 04 call *0x4(%ebx)
_Thread_Enable_dispatch();
118ccf: e8 80 31 00 00 call 11be54 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
118cd4: 83 c4 10 add $0x10,%esp
118cd7: 31 c0 xor %eax,%eax
118cd9: e9 75 ff ff ff jmp 118c53 <rtems_timer_server_fire_when+0x47>
118cde: 66 90 xchg %ax,%ax
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
118ce0: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118ce5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
118ce8: 5b pop %ebx <== NOT EXECUTED
118ce9: 5e pop %esi <== NOT EXECUTED
118cea: 5f pop %edi <== NOT EXECUTED
118ceb: c9 leave <== NOT EXECUTED
118cec: c3 ret <== NOT EXECUTED
118ced: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
118cf0: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118cf5: 8d 65 f4 lea -0xc(%ebp),%esp
118cf8: 5b pop %ebx
118cf9: 5e pop %esi
118cfa: 5f pop %edi
118cfb: c9 leave
118cfc: c3 ret
118cfd: 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;
118d00: b8 0e 00 00 00 mov $0xe,%eax
118d05: e9 49 ff ff ff jmp 118c53 <rtems_timer_server_fire_when+0x47>
118d0a: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118d0c: b8 04 00 00 00 mov $0x4,%eax
118d11: e9 3d ff ff ff jmp 118c53 <rtems_timer_server_fire_when+0x47>
0010c700 <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
10c700: 55 push %ebp
10c701: 89 e5 mov %esp,%ebp
10c703: 57 push %edi
10c704: 56 push %esi
10c705: 53 push %ebx
10c706: 83 ec 1c sub $0x1c,%esp
10c709: 89 c3 mov %eax,%ebx
10c70b: 89 d6 mov %edx,%esi
10c70d: 89 cf mov %ecx,%edi
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
10c70f: a9 00 00 00 20 test $0x20000000,%eax
10c714: 74 2b je 10c741 <rtems_verror+0x41>
if (rtems_panic_in_progress++)
10c716: 8b 15 a0 e9 12 00 mov 0x12e9a0,%edx
10c71c: 8d 42 01 lea 0x1(%edx),%eax
10c71f: a3 a0 e9 12 00 mov %eax,0x12e9a0
10c724: 85 d2 test %edx,%edx
10c726: 74 10 je 10c738 <rtems_verror+0x38> <== ALWAYS TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10c728: a1 10 eb 12 00 mov 0x12eb10,%eax <== NOT EXECUTED
10c72d: 40 inc %eax <== NOT EXECUTED
10c72e: a3 10 eb 12 00 mov %eax,0x12eb10 <== NOT EXECUTED
RTEMS_COMPILER_MEMORY_BARRIER();
10c733: a1 a0 e9 12 00 mov 0x12e9a0,%eax <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
10c738: 83 f8 02 cmp $0x2,%eax
10c73b: 0f 8f af 00 00 00 jg 10c7f0 <rtems_verror+0xf0> <== NEVER TAKEN
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
10c741: 83 ec 0c sub $0xc,%esp
10c744: a1 20 c7 12 00 mov 0x12c720,%eax
10c749: ff 70 08 pushl 0x8(%eax)
10c74c: e8 7f c0 00 00 call 1187d0 <fflush>
status = error_flag & ~RTEMS_ERROR_MASK;
10c751: 89 d8 mov %ebx,%eax
10c753: 25 ff ff ff 8f and $0x8fffffff,%eax
10c758: 89 45 e4 mov %eax,-0x1c(%ebp)
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
10c75b: 83 c4 10 add $0x10,%esp
10c75e: 81 e3 00 00 00 40 and $0x40000000,%ebx
10c764: 0f 85 be 00 00 00 jne 10c828 <rtems_verror+0x128> <== NEVER TAKEN
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
int local_errno = 0;
10c76a: 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);
10c76c: 50 push %eax
10c76d: 57 push %edi
10c76e: 56 push %esi
10c76f: a1 20 c7 12 00 mov 0x12c720,%eax
10c774: ff 70 0c pushl 0xc(%eax)
10c777: e8 18 25 01 00 call 11ec94 <vfprintf>
10c77c: 89 c6 mov %eax,%esi
if (status)
10c77e: 83 c4 10 add $0x10,%esp
10c781: 8b 4d e4 mov -0x1c(%ebp),%ecx
10c784: 85 c9 test %ecx,%ecx
10c786: 75 74 jne 10c7fc <rtems_verror+0xfc> <== NEVER TAKEN
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
10c788: 83 fb 00 cmp $0x0,%ebx
10c78b: 74 30 je 10c7bd <rtems_verror+0xbd>
if ((local_errno > 0) && *strerror(local_errno))
10c78d: 7e 15 jle 10c7a4 <rtems_verror+0xa4>
10c78f: 83 ec 0c sub $0xc,%esp
10c792: 53 push %ebx
10c793: e8 84 cc 00 00 call 11941c <strerror>
10c798: 83 c4 10 add $0x10,%esp
10c79b: 80 38 00 cmpb $0x0,(%eax)
10c79e: 0f 85 90 00 00 00 jne 10c834 <rtems_verror+0x134> <== ALWAYS TAKEN
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
10c7a4: 52 push %edx
10c7a5: 53 push %ebx
10c7a6: 68 69 72 12 00 push $0x127269
10c7ab: a1 20 c7 12 00 mov 0x12c720,%eax
10c7b0: ff 70 0c pushl 0xc(%eax)
10c7b3: e8 0c c4 00 00 call 118bc4 <fprintf>
10c7b8: 01 c6 add %eax,%esi
10c7ba: 83 c4 10 add $0x10,%esp
}
chars_written += fprintf(stderr, "\n");
10c7bd: 83 ec 08 sub $0x8,%esp
10c7c0: 68 22 65 12 00 push $0x126522
10c7c5: a1 20 c7 12 00 mov 0x12c720,%eax
10c7ca: ff 70 0c pushl 0xc(%eax)
10c7cd: e8 f2 c3 00 00 call 118bc4 <fprintf>
10c7d2: 8d 34 30 lea (%eax,%esi,1),%esi
(void) fflush(stderr);
10c7d5: 58 pop %eax
10c7d6: a1 20 c7 12 00 mov 0x12c720,%eax
10c7db: ff 70 0c pushl 0xc(%eax)
10c7de: e8 ed bf 00 00 call 1187d0 <fflush>
return chars_written;
10c7e3: 83 c4 10 add $0x10,%esp
}
10c7e6: 89 f0 mov %esi,%eax
10c7e8: 8d 65 f4 lea -0xc(%ebp),%esp
10c7eb: 5b pop %ebx
10c7ec: 5e pop %esi
10c7ed: 5f pop %edi
10c7ee: c9 leave
10c7ef: 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;
10c7f0: 31 f6 xor %esi,%esi
chars_written += fprintf(stderr, "\n");
(void) fflush(stderr);
return chars_written;
}
10c7f2: 89 f0 mov %esi,%eax <== NOT EXECUTED
10c7f4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10c7f7: 5b pop %ebx <== NOT EXECUTED
10c7f8: 5e pop %esi <== NOT EXECUTED
10c7f9: 5f pop %edi <== NOT EXECUTED
10c7fa: c9 leave <== NOT EXECUTED
10c7fb: c3 ret <== NOT EXECUTED
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
10c7fc: 83 ec 0c sub $0xc,%esp
10c7ff: ff 75 e4 pushl -0x1c(%ebp)
10c802: e8 e1 fe ff ff call 10c6e8 <rtems_status_text>
10c807: 83 c4 0c add $0xc,%esp
10c80a: 50 push %eax
10c80b: 68 4e 72 12 00 push $0x12724e
10c810: a1 20 c7 12 00 mov 0x12c720,%eax
10c815: ff 70 0c pushl 0xc(%eax)
10c818: e8 a7 c3 00 00 call 118bc4 <fprintf>
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
10c81d: 01 c6 add %eax,%esi
10c81f: 83 c4 10 add $0x10,%esp
10c822: e9 61 ff ff ff jmp 10c788 <rtems_verror+0x88>
10c827: 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;
10c828: e8 0b bc 00 00 call 118438 <__errno>
10c82d: 8b 18 mov (%eax),%ebx
10c82f: e9 38 ff ff ff jmp 10c76c <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));
10c834: 83 ec 0c sub $0xc,%esp
10c837: 53 push %ebx
10c838: e8 df cb 00 00 call 11941c <strerror>
10c83d: 83 c4 0c add $0xc,%esp
10c840: 50 push %eax
10c841: 68 5c 72 12 00 push $0x12725c
10c846: e9 60 ff ff ff jmp 10c7ab <rtems_verror+0xab>
001086b4 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
1086b4: 55 push %ebp
1086b5: 89 e5 mov %esp,%ebp
1086b7: 57 push %edi
1086b8: 56 push %esi
1086b9: 53 push %ebx
1086ba: 83 ec 1c sub $0x1c,%esp
1086bd: 89 c6 mov %eax,%esi
1086bf: 89 55 e0 mov %edx,-0x20(%ebp)
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
int sign = 0;
1086c2: 31 ff xor %edi,%edi
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
1086c4: c7 45 e4 ff ff ff 7f movl $0x7fffffff,-0x1c(%ebp)
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
1086cb: 31 db xor %ebx,%ebx
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
1086cd: 8b 46 04 mov 0x4(%esi),%eax
1086d0: 48 dec %eax
1086d1: 89 46 04 mov %eax,0x4(%esi)
1086d4: 85 c0 test %eax,%eax
1086d6: 78 52 js 10872a <scanInt+0x76> <== NEVER TAKEN
1086d8: 8b 06 mov (%esi),%eax
1086da: 0f b6 08 movzbl (%eax),%ecx
1086dd: 40 inc %eax
1086de: 89 06 mov %eax,(%esi)
if (c == ':')
1086e0: 83 f9 3a cmp $0x3a,%ecx
1086e3: 74 5f je 108744 <scanInt+0x90>
break;
if (sign == 0) {
1086e5: 85 ff test %edi,%edi
1086e7: 75 0e jne 1086f7 <scanInt+0x43>
if (c == '-') {
1086e9: 83 f9 2d cmp $0x2d,%ecx
1086ec: 0f 84 8a 00 00 00 je 10877c <scanInt+0xc8>
sign = -1;
limit++;
continue;
}
sign = 1;
1086f2: bf 01 00 00 00 mov $0x1,%edi
}
if (!isdigit(c))
1086f7: a1 94 74 12 00 mov 0x127494,%eax
1086fc: f6 44 08 01 04 testb $0x4,0x1(%eax,%ecx,1)
108701: 74 6d je 108770 <scanInt+0xbc>
return 0;
d = c - '0';
if ((i > (limit / 10))
108703: b8 cd cc cc cc mov $0xcccccccd,%eax
108708: f7 65 e4 mull -0x1c(%ebp)
10870b: c1 ea 03 shr $0x3,%edx
10870e: 39 d3 cmp %edx,%ebx
108710: 77 5e ja 108770 <scanInt+0xbc>
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
108712: 83 e9 30 sub $0x30,%ecx
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
108715: 39 d3 cmp %edx,%ebx
108717: 74 47 je 108760 <scanInt+0xac>
return 0;
i = i * 10 + d;
108719: 8d 04 9b lea (%ebx,%ebx,4),%eax
10871c: 8d 1c 41 lea (%ecx,%eax,2),%ebx
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
10871f: 8b 46 04 mov 0x4(%esi),%eax
108722: 48 dec %eax
108723: 89 46 04 mov %eax,0x4(%esi)
108726: 85 c0 test %eax,%eax
108728: 79 ae jns 1086d8 <scanInt+0x24> <== ALWAYS TAKEN
10872a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10872d: 56 push %esi <== NOT EXECUTED
10872e: ff 35 a0 74 12 00 pushl 0x1274a0 <== NOT EXECUTED
108734: e8 73 cd 00 00 call 1154ac <__srget_r> <== NOT EXECUTED
108739: 89 c1 mov %eax,%ecx <== NOT EXECUTED
10873b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if (c == ':')
10873e: 83 f9 3a cmp $0x3a,%ecx <== NOT EXECUTED
108741: 75 a2 jne 1086e5 <scanInt+0x31> <== NOT EXECUTED
108743: 90 nop <== NOT EXECUTED
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
108744: 85 ff test %edi,%edi
108746: 74 28 je 108770 <scanInt+0xbc> <== NEVER TAKEN
return 0;
*val = i * sign;
108748: 0f af df imul %edi,%ebx
10874b: 8b 45 e0 mov -0x20(%ebp),%eax
10874e: 89 18 mov %ebx,(%eax)
return 1;
108750: b8 01 00 00 00 mov $0x1,%eax
}
108755: 8d 65 f4 lea -0xc(%ebp),%esp
108758: 5b pop %ebx
108759: 5e pop %esi
10875a: 5f pop %edi
10875b: c9 leave
10875c: c3 ret
10875d: 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))))
108760: 8d 04 9b lea (%ebx,%ebx,4),%eax
108763: d1 e0 shl %eax
108765: 8b 55 e4 mov -0x1c(%ebp),%edx
108768: 29 c2 sub %eax,%edx
10876a: 39 d1 cmp %edx,%ecx
10876c: 76 ab jbe 108719 <scanInt+0x65> <== NEVER TAKEN
10876e: 66 90 xchg %ax,%ax
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
108770: 31 c0 xor %eax,%eax
*val = i * sign;
return 1;
}
108772: 8d 65 f4 lea -0xc(%ebp),%esp
108775: 5b pop %ebx
108776: 5e pop %esi
108777: 5f pop %edi
108778: c9 leave
108779: c3 ret
10877a: 66 90 xchg %ax,%ax
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
limit++;
10877c: ff 45 e4 incl -0x1c(%ebp)
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
10877f: bf ff ff ff ff mov $0xffffffff,%edi
limit++;
continue;
108784: e9 44 ff ff ff jmp 1086cd <scanInt+0x19>
0010878c <scanString>:
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
10878c: 55 push %ebp
10878d: 89 e5 mov %esp,%ebp
10878f: 57 push %edi
108790: 56 push %esi
108791: 53 push %ebx
108792: 83 ec 0c sub $0xc,%esp
108795: 89 c3 mov %eax,%ebx
108797: 89 ce mov %ecx,%esi
108799: 8b 7d 08 mov 0x8(%ebp),%edi
int c;
*name = *bufp;
10879c: 8b 01 mov (%ecx),%eax
10879e: 89 02 mov %eax,(%edx)
1087a0: eb 26 jmp 1087c8 <scanString+0x3c>
1087a2: 66 90 xchg %ax,%ax
for (;;) {
c = getc(fp);
1087a4: 8b 13 mov (%ebx),%edx
1087a6: 0f b6 02 movzbl (%edx),%eax
1087a9: 42 inc %edx
1087aa: 89 13 mov %edx,(%ebx)
if (c == ':') {
1087ac: 83 f8 3a cmp $0x3a,%eax
1087af: 74 3b je 1087ec <scanString+0x60>
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
1087b1: 83 f8 0a cmp $0xa,%eax
1087b4: 74 56 je 10880c <scanString+0x80>
if (!nlFlag)
return 0;
break;
}
if (c == EOF)
1087b6: 83 f8 ff cmp $0xffffffff,%eax
1087b9: 74 59 je 108814 <scanString+0x88>
return 0;
if (*nleft < 2)
1087bb: 83 3f 01 cmpl $0x1,(%edi)
1087be: 76 54 jbe 108814 <scanString+0x88>
return 0;
**bufp = c;
1087c0: 8b 16 mov (%esi),%edx
1087c2: 88 02 mov %al,(%edx)
++(*bufp);
1087c4: ff 06 incl (%esi)
--(*nleft);
1087c6: ff 0f decl (%edi)
{
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
1087c8: 8b 43 04 mov 0x4(%ebx),%eax
1087cb: 48 dec %eax
1087cc: 89 43 04 mov %eax,0x4(%ebx)
1087cf: 85 c0 test %eax,%eax
1087d1: 79 d1 jns 1087a4 <scanString+0x18>
1087d3: 83 ec 08 sub $0x8,%esp
1087d6: 53 push %ebx
1087d7: ff 35 a0 74 12 00 pushl 0x1274a0
1087dd: e8 ca cc 00 00 call 1154ac <__srget_r>
1087e2: 83 c4 10 add $0x10,%esp
if (c == ':') {
1087e5: 83 f8 3a cmp $0x3a,%eax
1087e8: 75 c7 jne 1087b1 <scanString+0x25> <== ALWAYS TAKEN
1087ea: 66 90 xchg %ax,%ax
if (nlFlag)
1087ec: 8b 55 0c mov 0xc(%ebp),%edx
1087ef: 85 d2 test %edx,%edx
1087f1: 75 21 jne 108814 <scanString+0x88>
return 0;
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
1087f3: 8b 06 mov (%esi),%eax
1087f5: c6 00 00 movb $0x0,(%eax)
++(*bufp);
1087f8: ff 06 incl (%esi)
--(*nleft);
1087fa: ff 0f decl (%edi)
return 1;
1087fc: b8 01 00 00 00 mov $0x1,%eax
}
108801: 8d 65 f4 lea -0xc(%ebp),%esp
108804: 5b pop %ebx
108805: 5e pop %esi
108806: 5f pop %edi
108807: c9 leave
108808: c3 ret
108809: 8d 76 00 lea 0x0(%esi),%esi
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
if (!nlFlag)
10880c: 8b 45 0c mov 0xc(%ebp),%eax
10880f: 85 c0 test %eax,%eax
108811: 75 e0 jne 1087f3 <scanString+0x67>
108813: 90 nop
break;
}
if (c == EOF)
return 0;
if (*nleft < 2)
return 0;
108814: 31 c0 xor %eax,%eax
}
**bufp = '\0';
++(*bufp);
--(*nleft);
return 1;
}
108816: 8d 65 f4 lea -0xc(%ebp),%esp
108819: 5b pop %ebx
10881a: 5e pop %esi
10881b: 5f pop %edi
10881c: c9 leave
10881d: c3 ret
00108820 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
108820: 55 push %ebp
108821: 89 e5 mov %esp,%ebp
108823: 57 push %edi
108824: 56 push %esi
108825: 53 push %ebx
108826: 83 ec 34 sub $0x34,%esp
108829: 89 c6 mov %eax,%esi
10882b: 89 d3 mov %edx,%ebx
10882d: 89 4d d4 mov %ecx,-0x2c(%ebp)
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
108830: 8d 7d d4 lea -0x2c(%ebp),%edi
108833: 6a 00 push $0x0
108835: 8d 45 08 lea 0x8(%ebp),%eax
108838: 50 push %eax
108839: 89 f9 mov %edi,%ecx
10883b: 89 f0 mov %esi,%eax
10883d: e8 4a ff ff ff call 10878c <scanString>
108842: 83 c4 10 add $0x10,%esp
108845: 85 c0 test %eax,%eax
108847: 75 0b jne 108854 <scangr+0x34>
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
return 0;
108849: 31 c0 xor %eax,%eax
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
return 1;
}
10884b: 8d 65 f4 lea -0xc(%ebp),%esp
10884e: 5b pop %ebx
10884f: 5e pop %esi
108850: 5f pop %edi
108851: c9 leave
108852: c3 ret
108853: 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)
108854: 83 ec 08 sub $0x8,%esp
108857: 8d 53 04 lea 0x4(%ebx),%edx
10885a: 6a 00 push $0x0
10885c: 8d 45 08 lea 0x8(%ebp),%eax
10885f: 50 push %eax
108860: 89 f9 mov %edi,%ecx
108862: 89 f0 mov %esi,%eax
108864: e8 23 ff ff ff call 10878c <scanString>
108869: 83 c4 10 add $0x10,%esp
10886c: 85 c0 test %eax,%eax
10886e: 74 d9 je 108849 <scangr+0x29> <== NEVER TAKEN
|| !scanInt(fp, &grgid)
108870: 8d 55 e4 lea -0x1c(%ebp),%edx
108873: 89 f0 mov %esi,%eax
108875: e8 3a fe ff ff call 1086b4 <scanInt>
10887a: 85 c0 test %eax,%eax
10887c: 74 cb je 108849 <scangr+0x29> <== NEVER TAKEN
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
10887e: 83 ec 08 sub $0x8,%esp
108881: 8d 55 e0 lea -0x20(%ebp),%edx
108884: 6a 01 push $0x1
108886: 8d 45 08 lea 0x8(%ebp),%eax
108889: 50 push %eax
10888a: 89 f9 mov %edi,%ecx
10888c: 89 f0 mov %esi,%eax
10888e: e8 f9 fe ff ff call 10878c <scanString>
108893: 83 c4 10 add $0x10,%esp
108896: 85 c0 test %eax,%eax
108898: 74 af je 108849 <scangr+0x29> <== NEVER TAKEN
return 0;
grp->gr_gid = grgid;
10889a: 8b 45 e4 mov -0x1c(%ebp),%eax
10889d: 66 89 43 08 mov %ax,0x8(%ebx)
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
1088a1: 8b 7d e0 mov -0x20(%ebp),%edi
1088a4: 8a 07 mov (%edi),%al
1088a6: 84 c0 test %al,%al
1088a8: 74 7d je 108927 <scangr+0x107> <== NEVER TAKEN
1088aa: 89 fa mov %edi,%edx
1088ac: b9 01 00 00 00 mov $0x1,%ecx
1088b1: eb 08 jmp 1088bb <scangr+0x9b>
1088b3: 90 nop
1088b4: 42 inc %edx
1088b5: 8a 02 mov (%edx),%al
1088b7: 84 c0 test %al,%al
1088b9: 74 09 je 1088c4 <scangr+0xa4>
if(*cp == ',')
1088bb: 3c 2c cmp $0x2c,%al
1088bd: 75 f5 jne 1088b4 <scangr+0x94>
memcount++;
1088bf: 41 inc %ecx
1088c0: eb f2 jmp 1088b4 <scangr+0x94>
1088c2: 66 90 xchg %ax,%ax
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
1088c4: 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))
1088cb: 39 45 08 cmp %eax,0x8(%ebp)
1088ce: 0f 82 75 ff ff ff jb 108849 <scangr+0x29> <== NEVER TAKEN
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
1088d4: 8b 75 d4 mov -0x2c(%ebp),%esi
1088d7: 83 c6 0f add $0xf,%esi
1088da: 83 e6 f0 and $0xfffffff0,%esi
1088dd: 89 73 0c mov %esi,0xc(%ebx)
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
1088e0: 89 3e mov %edi,(%esi)
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
1088e2: 8b 45 e0 mov -0x20(%ebp),%eax
1088e5: 8a 10 mov (%eax),%dl
1088e7: 84 d2 test %dl,%dl
1088e9: 74 43 je 10892e <scangr+0x10e> <== NEVER TAKEN
}
/*
* Extract a single group record from the database
*/
static int scangr(
1088eb: 40 inc %eax
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
1088ec: b9 01 00 00 00 mov $0x1,%ecx
1088f1: eb 08 jmp 1088fb <scangr+0xdb>
1088f3: 90 nop
1088f4: 8a 10 mov (%eax),%dl
1088f6: 40 inc %eax
1088f7: 84 d2 test %dl,%dl
1088f9: 74 15 je 108910 <scangr+0xf0>
if(*cp == ',') {
1088fb: 80 fa 2c cmp $0x2c,%dl
1088fe: 75 f4 jne 1088f4 <scangr+0xd4>
*cp = '\0';
108900: c6 40 ff 00 movb $0x0,-0x1(%eax)
grp->gr_mem[memcount++] = cp + 1;
108904: 8b 53 0c mov 0xc(%ebx),%edx
108907: 89 04 8a mov %eax,(%edx,%ecx,4)
10890a: 41 inc %ecx
10890b: eb e7 jmp 1088f4 <scangr+0xd4>
10890d: 8d 76 00 lea 0x0(%esi),%esi
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
108910: 8b 73 0c mov 0xc(%ebx),%esi
108913: c1 e1 02 shl $0x2,%ecx
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
108916: c7 04 0e 00 00 00 00 movl $0x0,(%esi,%ecx,1)
return 1;
10891d: b8 01 00 00 00 mov $0x1,%eax
108922: e9 24 ff ff ff jmp 10884b <scangr+0x2b>
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
108927: b8 17 00 00 00 mov $0x17,%eax <== NOT EXECUTED
10892c: eb 9d jmp 1088cb <scangr+0xab> <== NOT EXECUTED
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
10892e: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
108933: eb e1 jmp 108916 <scangr+0xf6> <== NOT EXECUTED
00108938 <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
108938: 55 push %ebp
108939: 89 e5 mov %esp,%ebp
10893b: 57 push %edi
10893c: 56 push %esi
10893d: 53 push %ebx
10893e: 83 ec 34 sub $0x34,%esp
108941: 89 c6 mov %eax,%esi
108943: 89 d3 mov %edx,%ebx
108945: 89 4d d4 mov %ecx,-0x2c(%ebp)
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
108948: 8d 7d d4 lea -0x2c(%ebp),%edi
10894b: 6a 00 push $0x0
10894d: 8d 45 08 lea 0x8(%ebp),%eax
108950: 50 push %eax
108951: 89 f9 mov %edi,%ecx
108953: 89 f0 mov %esi,%eax
108955: e8 32 fe ff ff call 10878c <scanString>
10895a: 83 c4 10 add $0x10,%esp
10895d: 85 c0 test %eax,%eax
10895f: 75 0b jne 10896c <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;
108961: 31 c0 xor %eax,%eax
pwd->pw_uid = pwuid;
pwd->pw_gid = pwgid;
return 1;
}
108963: 8d 65 f4 lea -0xc(%ebp),%esp
108966: 5b pop %ebx
108967: 5e pop %esi
108968: 5f pop %edi
108969: c9 leave
10896a: c3 ret
10896b: 90 nop
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
10896c: 83 ec 08 sub $0x8,%esp
10896f: 8d 53 04 lea 0x4(%ebx),%edx
108972: 6a 00 push $0x0
108974: 8d 45 08 lea 0x8(%ebp),%eax
108977: 50 push %eax
108978: 89 f9 mov %edi,%ecx
10897a: 89 f0 mov %esi,%eax
10897c: e8 0b fe ff ff call 10878c <scanString>
108981: 83 c4 10 add $0x10,%esp
108984: 85 c0 test %eax,%eax
108986: 74 d9 je 108961 <scanpw+0x29> <== NEVER TAKEN
|| !scanInt(fp, &pwuid)
108988: 8d 55 e4 lea -0x1c(%ebp),%edx
10898b: 89 f0 mov %esi,%eax
10898d: e8 22 fd ff ff call 1086b4 <scanInt>
108992: 85 c0 test %eax,%eax
108994: 74 cb je 108961 <scanpw+0x29>
|| !scanInt(fp, &pwgid)
108996: 8d 55 e0 lea -0x20(%ebp),%edx
108999: 89 f0 mov %esi,%eax
10899b: e8 14 fd ff ff call 1086b4 <scanInt>
1089a0: 85 c0 test %eax,%eax
1089a2: 74 bd je 108961 <scanpw+0x29>
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
1089a4: 83 ec 08 sub $0x8,%esp
1089a7: 8d 53 0c lea 0xc(%ebx),%edx
1089aa: 6a 00 push $0x0
1089ac: 8d 45 08 lea 0x8(%ebp),%eax
1089af: 50 push %eax
1089b0: 89 f9 mov %edi,%ecx
1089b2: 89 f0 mov %esi,%eax
1089b4: e8 d3 fd ff ff call 10878c <scanString>
1089b9: 83 c4 10 add $0x10,%esp
1089bc: 85 c0 test %eax,%eax
1089be: 74 a1 je 108961 <scanpw+0x29> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
1089c0: 83 ec 08 sub $0x8,%esp
1089c3: 8d 53 10 lea 0x10(%ebx),%edx
1089c6: 6a 00 push $0x0
1089c8: 8d 45 08 lea 0x8(%ebp),%eax
1089cb: 50 push %eax
1089cc: 89 f9 mov %edi,%ecx
1089ce: 89 f0 mov %esi,%eax
1089d0: e8 b7 fd ff ff call 10878c <scanString>
1089d5: 83 c4 10 add $0x10,%esp
1089d8: 85 c0 test %eax,%eax
1089da: 74 85 je 108961 <scanpw+0x29> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
1089dc: 83 ec 08 sub $0x8,%esp
1089df: 8d 53 14 lea 0x14(%ebx),%edx
1089e2: 6a 00 push $0x0
1089e4: 8d 45 08 lea 0x8(%ebp),%eax
1089e7: 50 push %eax
1089e8: 89 f9 mov %edi,%ecx
1089ea: 89 f0 mov %esi,%eax
1089ec: e8 9b fd ff ff call 10878c <scanString>
1089f1: 83 c4 10 add $0x10,%esp
1089f4: 85 c0 test %eax,%eax
1089f6: 0f 84 65 ff ff ff je 108961 <scanpw+0x29> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
1089fc: 83 ec 08 sub $0x8,%esp
1089ff: 8d 53 18 lea 0x18(%ebx),%edx
108a02: 6a 01 push $0x1
108a04: 8d 45 08 lea 0x8(%ebp),%eax
108a07: 50 push %eax
108a08: 89 f9 mov %edi,%ecx
108a0a: 89 f0 mov %esi,%eax
108a0c: e8 7b fd ff ff call 10878c <scanString>
108a11: 83 c4 10 add $0x10,%esp
108a14: 85 c0 test %eax,%eax
108a16: 0f 84 45 ff ff ff je 108961 <scanpw+0x29>
return 0;
pwd->pw_uid = pwuid;
108a1c: 8b 45 e4 mov -0x1c(%ebp),%eax
108a1f: 66 89 43 08 mov %ax,0x8(%ebx)
pwd->pw_gid = pwgid;
108a23: 8b 45 e0 mov -0x20(%ebp),%eax
108a26: 66 89 43 0a mov %ax,0xa(%ebx)
return 1;
108a2a: b8 01 00 00 00 mov $0x1,%eax
108a2f: e9 2f ff ff ff jmp 108963 <scanpw+0x2b>
0010be34 <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
10be34: 55 push %ebp
10be35: 89 e5 mov %esp,%ebp
10be37: 83 ec 08 sub $0x8,%esp
10be3a: 8b 45 08 mov 0x8(%ebp),%eax
switch ( policy ) {
10be3d: 85 c0 test %eax,%eax
10be3f: 78 0a js 10be4b <sched_get_priority_max+0x17>
10be41: 83 f8 02 cmp $0x2,%eax
10be44: 7e 1a jle 10be60 <sched_get_priority_max+0x2c>
10be46: 83 f8 04 cmp $0x4,%eax
10be49: 74 15 je 10be60 <sched_get_priority_max+0x2c><== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10be4b: e8 20 81 00 00 call 113f70 <__errno>
10be50: c7 00 16 00 00 00 movl $0x16,(%eax)
10be56: b8 ff ff ff ff mov $0xffffffff,%eax
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
}
10be5b: c9 leave
10be5c: c3 ret
10be5d: 8d 76 00 lea 0x0(%esi),%esi
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
10be60: 0f b6 05 9c 4d 12 00 movzbl 0x124d9c,%eax
10be67: 48 dec %eax
}
10be68: c9 leave
10be69: c3 ret
0010be6c <sched_get_priority_min>:
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
10be6c: 55 push %ebp
10be6d: 89 e5 mov %esp,%ebp
10be6f: 83 ec 08 sub $0x8,%esp
10be72: 8b 45 08 mov 0x8(%ebp),%eax
switch ( policy ) {
10be75: 85 c0 test %eax,%eax
10be77: 78 0a js 10be83 <sched_get_priority_min+0x17>
10be79: 83 f8 02 cmp $0x2,%eax
10be7c: 7e 1a jle 10be98 <sched_get_priority_min+0x2c><== ALWAYS TAKEN
10be7e: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED
10be81: 74 15 je 10be98 <sched_get_priority_min+0x2c><== NOT EXECUTED
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10be83: e8 e8 80 00 00 call 113f70 <__errno>
10be88: c7 00 16 00 00 00 movl $0x16,(%eax)
10be8e: b8 ff ff ff ff mov $0xffffffff,%eax
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
10be93: c9 leave
10be94: c3 ret
10be95: 8d 76 00 lea 0x0(%esi),%esi
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
10be98: b8 01 00 00 00 mov $0x1,%eax
}
10be9d: c9 leave
10be9e: c3 ret
0010bea0 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
10bea0: 55 push %ebp
10bea1: 89 e5 mov %esp,%ebp
10bea3: 56 push %esi
10bea4: 53 push %ebx
10bea5: 8b 75 08 mov 0x8(%ebp),%esi
10bea8: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
10beab: 85 f6 test %esi,%esi
10bead: 75 21 jne 10bed0 <sched_rr_get_interval+0x30><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ESRCH );
if ( !interval )
10beaf: 85 db test %ebx,%ebx
10beb1: 74 38 je 10beeb <sched_rr_get_interval+0x4b>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
10beb3: 83 ec 08 sub $0x8,%esp
10beb6: 53 push %ebx
10beb7: ff 35 60 90 12 00 pushl 0x129060
10bebd: e8 b2 35 00 00 call 10f474 <_Timespec_From_ticks>
return 0;
10bec2: 83 c4 10 add $0x10,%esp
10bec5: 31 c0 xor %eax,%eax
}
10bec7: 8d 65 f8 lea -0x8(%ebp),%esp
10beca: 5b pop %ebx
10becb: 5e pop %esi
10becc: c9 leave
10becd: c3 ret
10bece: 66 90 xchg %ax,%ax
{
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
10bed0: e8 fb c8 ff ff call 1087d0 <getpid>
10bed5: 39 f0 cmp %esi,%eax
10bed7: 74 d6 je 10beaf <sched_rr_get_interval+0xf>
rtems_set_errno_and_return_minus_one( ESRCH );
10bed9: e8 92 80 00 00 call 113f70 <__errno>
10bede: c7 00 03 00 00 00 movl $0x3,(%eax)
10bee4: b8 ff ff ff ff mov $0xffffffff,%eax
10bee9: eb dc jmp 10bec7 <sched_rr_get_interval+0x27>
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
10beeb: e8 80 80 00 00 call 113f70 <__errno>
10bef0: c7 00 16 00 00 00 movl $0x16,(%eax)
10bef6: b8 ff ff ff ff mov $0xffffffff,%eax
10befb: eb ca jmp 10bec7 <sched_rr_get_interval+0x27>
0010e604 <sem_close>:
*/
int sem_close(
sem_t *sem
)
{
10e604: 55 push %ebp
10e605: 89 e5 mov %esp,%ebp
10e607: 83 ec 1c sub $0x1c,%esp
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
10e60a: 8d 45 f4 lea -0xc(%ebp),%eax
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
_Objects_Get( &_POSIX_Semaphore_Information, (Objects_Id)*id, location );
10e60d: 50 push %eax
10e60e: 8b 45 08 mov 0x8(%ebp),%eax
10e611: ff 30 pushl (%eax)
10e613: 68 20 de 12 00 push $0x12de20
10e618: e8 bf 21 00 00 call 1107dc <_Objects_Get>
switch ( location ) {
10e61d: 83 c4 10 add $0x10,%esp
10e620: 8b 55 f4 mov -0xc(%ebp),%edx
10e623: 85 d2 test %edx,%edx
10e625: 74 15 je 10e63c <sem_close+0x38>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10e627: e8 7c 8f 00 00 call 1175a8 <__errno>
10e62c: c7 00 16 00 00 00 movl $0x16,(%eax)
10e632: b8 ff ff ff ff mov $0xffffffff,%eax
}
10e637: c9 leave
10e638: c3 ret
10e639: 8d 76 00 lea 0x0(%esi),%esi
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_semaphore->open_count -= 1;
10e63c: ff 48 18 decl 0x18(%eax)
_POSIX_Semaphore_Delete( the_semaphore );
10e63f: 83 ec 0c sub $0xc,%esp
10e642: 50 push %eax
10e643: e8 3c 64 00 00 call 114a84 <_POSIX_Semaphore_Delete>
_Thread_Enable_dispatch();
10e648: e8 87 2d 00 00 call 1113d4 <_Thread_Enable_dispatch>
return 0;
10e64d: 83 c4 10 add $0x10,%esp
10e650: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10e652: c9 leave
10e653: c3 ret
0010e654 <sem_destroy>:
*/
int sem_destroy(
sem_t *sem
)
{
10e654: 55 push %ebp
10e655: 89 e5 mov %esp,%ebp
10e657: 83 ec 1c sub $0x1c,%esp
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
10e65a: 8d 45 f4 lea -0xc(%ebp),%eax
10e65d: 50 push %eax
10e65e: 8b 45 08 mov 0x8(%ebp),%eax
10e661: ff 30 pushl (%eax)
10e663: 68 20 de 12 00 push $0x12de20
10e668: e8 6f 21 00 00 call 1107dc <_Objects_Get>
switch ( location ) {
10e66d: 83 c4 10 add $0x10,%esp
10e670: 8b 55 f4 mov -0xc(%ebp),%edx
10e673: 85 d2 test %edx,%edx
10e675: 74 15 je 10e68c <sem_destroy+0x38>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10e677: e8 2c 8f 00 00 call 1175a8 <__errno>
10e67c: c7 00 16 00 00 00 movl $0x16,(%eax)
10e682: b8 ff ff ff ff mov $0xffffffff,%eax
}
10e687: c9 leave
10e688: c3 ret
10e689: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_LOCAL:
/*
* Undefined operation on a named semaphore.
*/
if ( the_semaphore->named == true ) {
10e68c: 80 78 14 00 cmpb $0x0,0x14(%eax)
10e690: 75 16 jne 10e6a8 <sem_destroy+0x54>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
_POSIX_Semaphore_Delete( the_semaphore );
10e692: 83 ec 0c sub $0xc,%esp
10e695: 50 push %eax
10e696: e8 e9 63 00 00 call 114a84 <_POSIX_Semaphore_Delete>
_Thread_Enable_dispatch();
10e69b: e8 34 2d 00 00 call 1113d4 <_Thread_Enable_dispatch>
return 0;
10e6a0: 83 c4 10 add $0x10,%esp
10e6a3: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10e6a5: c9 leave
10e6a6: c3 ret
10e6a7: 90 nop
/*
* Undefined operation on a named semaphore.
*/
if ( the_semaphore->named == true ) {
_Thread_Enable_dispatch();
10e6a8: e8 27 2d 00 00 call 1113d4 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EINVAL );
10e6ad: e8 f6 8e 00 00 call 1175a8 <__errno>
10e6b2: c7 00 16 00 00 00 movl $0x16,(%eax)
10e6b8: b8 ff ff ff ff mov $0xffffffff,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10e6bd: c9 leave
10e6be: c3 ret
0010e6c0 <sem_getvalue>:
int sem_getvalue(
sem_t *sem,
int *sval
)
{
10e6c0: 55 push %ebp
10e6c1: 89 e5 mov %esp,%ebp
10e6c3: 83 ec 1c sub $0x1c,%esp
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
10e6c6: 8d 45 f4 lea -0xc(%ebp),%eax
10e6c9: 50 push %eax
10e6ca: 8b 45 08 mov 0x8(%ebp),%eax
10e6cd: ff 30 pushl (%eax)
10e6cf: 68 20 de 12 00 push $0x12de20
10e6d4: e8 03 21 00 00 call 1107dc <_Objects_Get>
switch ( location ) {
10e6d9: 83 c4 10 add $0x10,%esp
10e6dc: 8b 55 f4 mov -0xc(%ebp),%edx
10e6df: 85 d2 test %edx,%edx
10e6e1: 74 15 je 10e6f8 <sem_getvalue+0x38>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10e6e3: e8 c0 8e 00 00 call 1175a8 <__errno>
10e6e8: c7 00 16 00 00 00 movl $0x16,(%eax)
10e6ee: b8 ff ff ff ff mov $0xffffffff,%eax
}
10e6f3: c9 leave
10e6f4: c3 ret
10e6f5: 8d 76 00 lea 0x0(%esi),%esi
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
*sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore );
10e6f8: 8b 50 64 mov 0x64(%eax),%edx
10e6fb: 8b 45 0c mov 0xc(%ebp),%eax
10e6fe: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10e700: e8 cf 2c 00 00 call 1113d4 <_Thread_Enable_dispatch>
return 0;
10e705: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10e707: c9 leave
10e708: c3 ret
0010e754 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
10e754: 55 push %ebp
10e755: 89 e5 mov %esp,%ebp
10e757: 57 push %edi
10e758: 56 push %esi
10e759: 53 push %ebx
10e75a: 83 ec 2c sub $0x2c,%esp
10e75d: 8b 75 08 mov 0x8(%ebp),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10e760: a1 10 db 12 00 mov 0x12db10,%eax
10e765: 40 inc %eax
10e766: a3 10 db 12 00 mov %eax,0x12db10
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
10e76b: 8b 7d 0c mov 0xc(%ebp),%edi
10e76e: 81 e7 00 02 00 00 and $0x200,%edi
10e774: 0f 85 86 00 00 00 jne 10e800 <sem_open+0xac>
/* unsigned int value */
)
{
va_list arg;
mode_t mode;
unsigned int value = 0;
10e77a: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
10e781: 83 ec 08 sub $0x8,%esp
10e784: 8d 45 e4 lea -0x1c(%ebp),%eax
10e787: 50 push %eax
10e788: 56 push %esi
10e789: e8 46 63 00 00 call 114ad4 <_POSIX_Semaphore_Name_to_id>
10e78e: 89 c3 mov %eax,%ebx
* and we can just return a pointer to the id. Otherwise we may
* need to check to see if this is a "semaphore does not exist"
* or some other miscellaneous error on the name.
*/
if ( status ) {
10e790: 83 c4 10 add $0x10,%esp
10e793: 85 c0 test %eax,%eax
10e795: 74 25 je 10e7bc <sem_open+0x68>
/*
* Unless provided a valid name that did not already exist
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
10e797: 83 f8 02 cmp $0x2,%eax
10e79a: 75 04 jne 10e7a0 <sem_open+0x4c> <== NEVER TAKEN
10e79c: 85 ff test %edi,%edi
10e79e: 75 6c jne 10e80c <sem_open+0xb8>
_Thread_Enable_dispatch();
10e7a0: e8 2f 2c 00 00 call 1113d4 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
10e7a5: e8 fe 8d 00 00 call 1175a8 <__errno>
10e7aa: 89 18 mov %ebx,(%eax)
10e7ac: b8 ff ff ff ff mov $0xffffffff,%eax
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
#endif
return id;
}
10e7b1: 8d 65 f4 lea -0xc(%ebp),%esp
10e7b4: 5b pop %ebx
10e7b5: 5e pop %esi
10e7b6: 5f pop %edi
10e7b7: c9 leave
10e7b8: c3 ret
10e7b9: 8d 76 00 lea 0x0(%esi),%esi
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
10e7bc: 8b 45 0c mov 0xc(%ebp),%eax
10e7bf: 25 00 0a 00 00 and $0xa00,%eax
10e7c4: 3d 00 0a 00 00 cmp $0xa00,%eax
10e7c9: 74 65 je 10e830 <sem_open+0xdc>
10e7cb: 50 push %eax
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
10e7cc: 8d 45 dc lea -0x24(%ebp),%eax
10e7cf: 50 push %eax
10e7d0: ff 75 e4 pushl -0x1c(%ebp)
10e7d3: 68 20 de 12 00 push $0x12de20
10e7d8: e8 ff 1f 00 00 call 1107dc <_Objects_Get>
10e7dd: 89 45 e0 mov %eax,-0x20(%ebp)
the_semaphore->open_count += 1;
10e7e0: ff 40 18 incl 0x18(%eax)
_Thread_Enable_dispatch();
10e7e3: e8 ec 2b 00 00 call 1113d4 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
10e7e8: e8 e7 2b 00 00 call 1113d4 <_Thread_Enable_dispatch>
goto return_id;
10e7ed: 83 c4 10 add $0x10,%esp
return_id:
#if defined(RTEMS_USE_16_BIT_OBJECT)
the_semaphore->Semaphore_id = the_semaphore->Object.id;
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
10e7f0: 8b 45 e0 mov -0x20(%ebp),%eax
10e7f3: 83 c0 08 add $0x8,%eax
#endif
return id;
}
10e7f6: 8d 65 f4 lea -0xc(%ebp),%esp
10e7f9: 5b pop %ebx
10e7fa: 5e pop %esi
10e7fb: 5f pop %edi
10e7fc: c9 leave
10e7fd: c3 ret
10e7fe: 66 90 xchg %ax,%ax
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
10e800: 8b 45 14 mov 0x14(%ebp),%eax
10e803: 89 45 d4 mov %eax,-0x2c(%ebp)
10e806: e9 76 ff ff ff jmp 10e781 <sem_open+0x2d>
10e80b: 90 nop
/*
* At this point, the semaphore does not exist and everything has been
* checked. We should go ahead and create a semaphore.
*/
status =_POSIX_Semaphore_Create_support(
10e80c: 8d 45 e0 lea -0x20(%ebp),%eax
10e80f: 50 push %eax
10e810: ff 75 d4 pushl -0x2c(%ebp)
10e813: 6a 00 push $0x0
10e815: 56 push %esi
10e816: e8 5d 61 00 00 call 114978 <_POSIX_Semaphore_Create_support>
10e81b: 89 c3 mov %eax,%ebx
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
10e81d: e8 b2 2b 00 00 call 1113d4 <_Thread_Enable_dispatch>
if ( status == -1 )
10e822: 83 c4 10 add $0x10,%esp
10e825: 43 inc %ebx
10e826: 75 c8 jne 10e7f0 <sem_open+0x9c>
return SEM_FAILED;
10e828: b8 ff ff ff ff mov $0xffffffff,%eax
10e82d: eb c7 jmp 10e7f6 <sem_open+0xa2>
10e82f: 90 nop
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
_Thread_Enable_dispatch();
10e830: e8 9f 2b 00 00 call 1113d4 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
10e835: e8 6e 8d 00 00 call 1175a8 <__errno>
10e83a: c7 00 11 00 00 00 movl $0x11,(%eax)
10e840: b8 ff ff ff ff mov $0xffffffff,%eax
10e845: eb af jmp 10e7f6 <sem_open+0xa2>
0010e848 <sem_post>:
*/
int sem_post(
sem_t *sem
)
{
10e848: 55 push %ebp
10e849: 89 e5 mov %esp,%ebp
10e84b: 83 ec 1c sub $0x1c,%esp
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
10e84e: 8d 45 f4 lea -0xc(%ebp),%eax
10e851: 50 push %eax
10e852: 8b 45 08 mov 0x8(%ebp),%eax
10e855: ff 30 pushl (%eax)
10e857: 68 20 de 12 00 push $0x12de20
10e85c: e8 7b 1f 00 00 call 1107dc <_Objects_Get>
switch ( location ) {
10e861: 83 c4 10 add $0x10,%esp
10e864: 8b 4d f4 mov -0xc(%ebp),%ecx
10e867: 85 c9 test %ecx,%ecx
10e869: 74 15 je 10e880 <sem_post+0x38>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10e86b: e8 38 8d 00 00 call 1175a8 <__errno>
10e870: c7 00 16 00 00 00 movl $0x16,(%eax)
10e876: b8 ff ff ff ff mov $0xffffffff,%eax
}
10e87b: c9 leave
10e87c: c3 ret
10e87d: 8d 76 00 lea 0x0(%esi),%esi
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_semaphore_Surrender(
10e880: 52 push %edx
10e881: 6a 00 push $0x0
10e883: ff 70 08 pushl 0x8(%eax)
10e886: 83 c0 1c add $0x1c,%eax
10e889: 50 push %eax
10e88a: e8 61 15 00 00 call 10fdf0 <_CORE_semaphore_Surrender>
NULL /* XXX need to define a routine to handle this case */
#else
NULL
#endif
);
_Thread_Enable_dispatch();
10e88f: e8 40 2b 00 00 call 1113d4 <_Thread_Enable_dispatch>
return 0;
10e894: 83 c4 10 add $0x10,%esp
10e897: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10e899: c9 leave
10e89a: c3 ret
0010e89c <sem_timedwait>:
int sem_timedwait(
sem_t *sem,
const struct timespec *abstime
)
{
10e89c: 55 push %ebp
10e89d: 89 e5 mov %esp,%ebp
10e89f: 53 push %ebx
10e8a0: 83 ec 1c sub $0x1c,%esp
10e8a3: 8b 5d 08 mov 0x8(%ebp),%ebx
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
10e8a6: 8d 45 f4 lea -0xc(%ebp),%eax
10e8a9: 50 push %eax
10e8aa: ff 75 0c pushl 0xc(%ebp)
10e8ad: e8 56 55 00 00 call 113e08 <_POSIX_Absolute_timeout_to_ticks>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
10e8b2: 83 c4 10 add $0x10,%esp
10e8b5: 83 f8 03 cmp $0x3,%eax
10e8b8: 74 16 je 10e8d0 <sem_timedwait+0x34> <== ALWAYS TAKEN
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
10e8ba: 50 push %eax <== NOT EXECUTED
10e8bb: ff 75 f4 pushl -0xc(%ebp) <== NOT EXECUTED
10e8be: 6a 00 push $0x0 <== NOT EXECUTED
10e8c0: 53 push %ebx <== NOT EXECUTED
10e8c1: e8 7a 62 00 00 call 114b40 <_POSIX_Semaphore_Wait_support><== NOT EXECUTED
10e8c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
10e8c9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10e8cc: c9 leave <== NOT EXECUTED
10e8cd: c3 ret <== NOT EXECUTED
10e8ce: 66 90 xchg %ax,%ax <== NOT EXECUTED
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks );
10e8d0: 52 push %edx
10e8d1: ff 75 f4 pushl -0xc(%ebp)
10e8d4: 6a 01 push $0x1
10e8d6: 53 push %ebx
10e8d7: e8 64 62 00 00 call 114b40 <_POSIX_Semaphore_Wait_support>
10e8dc: 83 c4 10 add $0x10,%esp
lock_status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
rtems_set_errno_and_return_minus_one( ETIMEDOUT );
}
return lock_status;
}
10e8df: 8b 5d fc mov -0x4(%ebp),%ebx
10e8e2: c9 leave
10e8e3: c3 ret
0010b2f4 <setitimer>:
int setitimer(
int which,
const struct itimerval *value,
struct itimerval *ovalue
)
{
10b2f4: 55 push %ebp
10b2f5: 89 e5 mov %esp,%ebp
10b2f7: 83 ec 08 sub $0x8,%esp
if ( !value )
10b2fa: 8b 55 0c mov 0xc(%ebp),%edx
10b2fd: 85 d2 test %edx,%edx
10b2ff: 74 33 je 10b334 <setitimer+0x40>
rtems_set_errno_and_return_minus_one( EFAULT );
if ( !ovalue )
10b301: 8b 45 10 mov 0x10(%ebp),%eax
10b304: 85 c0 test %eax,%eax
10b306: 74 2c je 10b334 <setitimer+0x40>
rtems_set_errno_and_return_minus_one( EFAULT );
switch ( which ) {
10b308: 83 7d 08 02 cmpl $0x2,0x8(%ebp)
10b30c: 76 12 jbe 10b320 <setitimer+0x2c>
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10b30e: e8 6d 86 00 00 call 113980 <__errno>
10b313: c7 00 16 00 00 00 movl $0x16,(%eax)
}
10b319: b8 ff ff ff ff mov $0xffffffff,%eax
10b31e: c9 leave
10b31f: c3 ret
switch ( which ) {
case ITIMER_REAL:
case ITIMER_VIRTUAL:
case ITIMER_PROF:
rtems_set_errno_and_return_minus_one( ENOSYS );
10b320: e8 5b 86 00 00 call 113980 <__errno>
10b325: c7 00 58 00 00 00 movl $0x58,(%eax)
default:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10b32b: b8 ff ff ff ff mov $0xffffffff,%eax
10b330: c9 leave
10b331: c3 ret
10b332: 66 90 xchg %ax,%ax
{
if ( !value )
rtems_set_errno_and_return_minus_one( EFAULT );
if ( !ovalue )
rtems_set_errno_and_return_minus_one( EFAULT );
10b334: e8 47 86 00 00 call 113980 <__errno>
10b339: c7 00 0e 00 00 00 movl $0xe,(%eax)
10b33f: eb d8 jmp 10b319 <setitimer+0x25>
0010bd48 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
10bd48: 55 push %ebp
10bd49: 89 e5 mov %esp,%ebp
10bd4b: 57 push %edi
10bd4c: 56 push %esi
10bd4d: 53 push %ebx
10bd4e: 83 ec 1c sub $0x1c,%esp
10bd51: 8b 5d 08 mov 0x8(%ebp),%ebx
10bd54: 8b 45 0c mov 0xc(%ebp),%eax
10bd57: 8b 55 10 mov 0x10(%ebp),%edx
ISR_Level level;
if ( oact )
10bd5a: 85 d2 test %edx,%edx
10bd5c: 74 13 je 10bd71 <sigaction+0x29>
*oact = _POSIX_signals_Vectors[ sig ];
10bd5e: 8d 0c 5b lea (%ebx,%ebx,2),%ecx
10bd61: 8d 34 8d c0 a3 12 00 lea 0x12a3c0(,%ecx,4),%esi
10bd68: b9 03 00 00 00 mov $0x3,%ecx
10bd6d: 89 d7 mov %edx,%edi
10bd6f: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !sig )
10bd71: 85 db test %ebx,%ebx
10bd73: 74 77 je 10bdec <sigaction+0xa4>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10bd75: 8d 53 ff lea -0x1(%ebx),%edx
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
10bd78: 83 fa 1f cmp $0x1f,%edx
10bd7b: 77 6f ja 10bdec <sigaction+0xa4>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
10bd7d: 83 fb 09 cmp $0x9,%ebx
10bd80: 74 6a je 10bdec <sigaction+0xa4>
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
10bd82: 85 c0 test %eax,%eax
10bd84: 74 62 je 10bde8 <sigaction+0xa0> <== NEVER TAKEN
/*
* Unless the user is installing the default signal actions, then
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
10bd86: 9c pushf
10bd87: fa cli
10bd88: 8f 45 e4 popl -0x1c(%ebp)
if ( act->sa_handler == SIG_DFL ) {
10bd8b: 8b 50 08 mov 0x8(%eax),%edx
10bd8e: 85 d2 test %edx,%edx
10bd90: 74 36 je 10bdc8 <sigaction+0x80>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
10bd92: 83 ec 0c sub $0xc,%esp
10bd95: 53 push %ebx
10bd96: 89 45 e0 mov %eax,-0x20(%ebp)
10bd99: e8 be 57 00 00 call 11155c <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
10bd9e: 8d 14 5b lea (%ebx,%ebx,2),%edx
10bda1: 8d 14 95 c0 a3 12 00 lea 0x12a3c0(,%edx,4),%edx
10bda8: b9 03 00 00 00 mov $0x3,%ecx
10bdad: 8b 45 e0 mov -0x20(%ebp),%eax
10bdb0: 89 d7 mov %edx,%edi
10bdb2: 89 c6 mov %eax,%esi
10bdb4: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10bdb6: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10bdb9: ff 75 e4 pushl -0x1c(%ebp)
10bdbc: 9d popf
* now (signals not posted when SIG_IGN).
* + If we are now ignoring a signal that was previously pending,
* we clear the pending signal indicator.
*/
return 0;
10bdbd: 31 c0 xor %eax,%eax
}
10bdbf: 8d 65 f4 lea -0xc(%ebp),%esp
10bdc2: 5b pop %ebx
10bdc3: 5e pop %esi
10bdc4: 5f pop %edi
10bdc5: c9 leave
10bdc6: c3 ret
10bdc7: 90 nop
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
10bdc8: 8d 34 5b lea (%ebx,%ebx,2),%esi
10bdcb: c1 e6 02 shl $0x2,%esi
10bdce: 8d 86 c0 a3 12 00 lea 0x12a3c0(%esi),%eax
10bdd4: 81 c6 40 38 12 00 add $0x123840,%esi
10bdda: b9 03 00 00 00 mov $0x3,%ecx
10bddf: 89 c7 mov %eax,%edi
10bde1: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10bde3: eb d4 jmp 10bdb9 <sigaction+0x71>
10bde5: 8d 76 00 lea 0x0(%esi),%esi
* now (signals not posted when SIG_IGN).
* + If we are now ignoring a signal that was previously pending,
* we clear the pending signal indicator.
*/
return 0;
10bde8: 31 c0 xor %eax,%eax
10bdea: eb d3 jmp 10bdbf <sigaction+0x77> <== NOT EXECUTED
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
rtems_set_errno_and_return_minus_one( EINVAL );
10bdec: e8 7b 84 00 00 call 11426c <__errno>
10bdf1: c7 00 16 00 00 00 movl $0x16,(%eax)
10bdf7: b8 ff ff ff ff mov $0xffffffff,%eax
10bdfc: eb c1 jmp 10bdbf <sigaction+0x77>
0010c120 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
10c120: 55 push %ebp
10c121: 89 e5 mov %esp,%ebp
10c123: 57 push %edi
10c124: 56 push %esi
10c125: 53 push %ebx
10c126: 83 ec 2c sub $0x2c,%esp
10c129: 8b 5d 08 mov 0x8(%ebp),%ebx
10c12c: 8b 7d 0c mov 0xc(%ebp),%edi
10c12f: 8b 75 10 mov 0x10(%ebp),%esi
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
10c132: 85 db test %ebx,%ebx
10c134: 0f 84 9e 01 00 00 je 10c2d8 <sigtimedwait+0x1b8>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
10c13a: 85 f6 test %esi,%esi
10c13c: 0f 84 3e 01 00 00 je 10c280 <sigtimedwait+0x160>
if ( !_Timespec_Is_valid( timeout ) )
10c142: 83 ec 0c sub $0xc,%esp
10c145: 56 push %esi
10c146: e8 41 36 00 00 call 10f78c <_Timespec_Is_valid>
10c14b: 83 c4 10 add $0x10,%esp
10c14e: 84 c0 test %al,%al
10c150: 0f 84 82 01 00 00 je 10c2d8 <sigtimedwait+0x1b8>
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
10c156: 83 ec 0c sub $0xc,%esp
10c159: 56 push %esi
10c15a: e8 95 36 00 00 call 10f7f4 <_Timespec_To_ticks>
if ( !interval )
10c15f: 83 c4 10 add $0x10,%esp
10c162: 85 c0 test %eax,%eax
10c164: 0f 84 6e 01 00 00 je 10c2d8 <sigtimedwait+0x1b8> <== NEVER TAKEN
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
10c16a: 85 ff test %edi,%edi
10c16c: 0f 84 18 01 00 00 je 10c28a <sigtimedwait+0x16a> <== NEVER TAKEN
the_thread = _Thread_Executing;
10c172: 8b 0d 98 9b 12 00 mov 0x129b98,%ecx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10c178: 8b 91 ec 00 00 00 mov 0xec(%ecx),%edx
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
10c17e: 9c pushf
10c17f: fa cli
10c180: 8f 45 d0 popl -0x30(%ebp)
if ( *set & api->signals_pending ) {
10c183: 8b 33 mov (%ebx),%esi
10c185: 89 75 d4 mov %esi,-0x2c(%ebp)
10c188: 8b b2 d4 00 00 00 mov 0xd4(%edx),%esi
10c18e: 85 75 d4 test %esi,-0x2c(%ebp)
10c191: 0f 85 fd 00 00 00 jne 10c294 <sigtimedwait+0x174>
return the_info->si_signo;
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
10c197: 8b 35 08 9e 12 00 mov 0x129e08,%esi
10c19d: 85 75 d4 test %esi,-0x2c(%ebp)
10c1a0: 0f 85 96 00 00 00 jne 10c23c <sigtimedwait+0x11c>
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
return signo;
}
the_info->si_signo = -1;
10c1a6: c7 07 ff ff ff ff movl $0xffffffff,(%edi)
10c1ac: 8b 35 f0 95 12 00 mov 0x1295f0,%esi
10c1b2: 46 inc %esi
10c1b3: 89 35 f0 95 12 00 mov %esi,0x1295f0
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
10c1b9: c7 41 44 a0 9d 12 00 movl $0x129da0,0x44(%ecx)
the_thread->Wait.return_code = EINTR;
10c1c0: c7 41 34 04 00 00 00 movl $0x4,0x34(%ecx)
the_thread->Wait.option = *set;
10c1c7: 8b 33 mov (%ebx),%esi
10c1c9: 89 71 30 mov %esi,0x30(%ecx)
the_thread->Wait.return_argument = the_info;
10c1cc: 89 79 28 mov %edi,0x28(%ecx)
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;
10c1cf: c7 05 d0 9d 12 00 01 movl $0x1,0x129dd0
10c1d6: 00 00 00
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
10c1d9: ff 75 d0 pushl -0x30(%ebp)
10c1dc: 9d popf
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
10c1dd: 51 push %ecx
10c1de: 68 cc f4 10 00 push $0x10f4cc
10c1e3: 50 push %eax
10c1e4: 68 a0 9d 12 00 push $0x129da0
10c1e9: 89 55 cc mov %edx,-0x34(%ebp)
10c1ec: e8 af 2f 00 00 call 10f1a0 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10c1f1: e8 06 2b 00 00 call 10ecfc <_Thread_Enable_dispatch>
/*
* When the thread is set free by a signal, it is need to eliminate
* the signal.
*/
_POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false );
10c1f6: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10c1fd: 6a 00 push $0x0
10c1ff: 57 push %edi
10c200: ff 37 pushl (%edi)
10c202: 8b 55 cc mov -0x34(%ebp),%edx
10c205: 52 push %edx
10c206: e8 4d 5a 00 00 call 111c58 <_POSIX_signals_Clear_signals>
/* Set errno only if return code is not EINTR or
* if EINTR was caused by a signal being caught, which
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
10c20b: 83 c4 20 add $0x20,%esp
10c20e: a1 98 9b 12 00 mov 0x129b98,%eax
10c213: 83 78 34 04 cmpl $0x4,0x34(%eax)
10c217: 0f 85 d3 00 00 00 jne 10c2f0 <sigtimedwait+0x1d0>
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
10c21d: 8b 37 mov (%edi),%esi
10c21f: 8d 4e ff lea -0x1(%esi),%ecx
10c222: b8 01 00 00 00 mov $0x1,%eax
10c227: d3 e0 shl %cl,%eax
10c229: 85 03 test %eax,(%ebx)
10c22b: 0f 84 bf 00 00 00 je 10c2f0 <sigtimedwait+0x1d0>
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
10c231: 89 f0 mov %esi,%eax
10c233: 8d 65 f4 lea -0xc(%ebp),%esp
10c236: 5b pop %ebx
10c237: 5e pop %esi
10c238: 5f pop %edi
10c239: c9 leave
10c23a: c3 ret
10c23b: 90 nop
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
10c23c: 83 ec 0c sub $0xc,%esp
10c23f: 56 push %esi
10c240: 89 55 cc mov %edx,-0x34(%ebp)
10c243: e8 94 fe ff ff call 10c0dc <_POSIX_signals_Get_lowest>
10c248: 89 c6 mov %eax,%esi
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
10c24a: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10c251: 6a 01 push $0x1
10c253: 57 push %edi
10c254: 50 push %eax
10c255: 8b 55 cc mov -0x34(%ebp),%edx
10c258: 52 push %edx
10c259: e8 fa 59 00 00 call 111c58 <_POSIX_signals_Clear_signals>
_ISR_Enable( level );
10c25e: ff 75 d0 pushl -0x30(%ebp)
10c261: 9d popf
the_info->si_signo = signo;
10c262: 89 37 mov %esi,(%edi)
the_info->si_code = SI_USER;
10c264: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10c26b: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return signo;
10c272: 83 c4 20 add $0x20,%esp
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
10c275: 89 f0 mov %esi,%eax
10c277: 8d 65 f4 lea -0xc(%ebp),%esp
10c27a: 5b pop %ebx
10c27b: 5e pop %esi
10c27c: 5f pop %edi
10c27d: c9 leave
10c27e: c3 ret
10c27f: 90 nop
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
10c280: 31 c0 xor %eax,%eax
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
10c282: 85 ff test %edi,%edi
10c284: 0f 85 e8 fe ff ff jne 10c172 <sigtimedwait+0x52>
10c28a: 8d 7d dc lea -0x24(%ebp),%edi
10c28d: e9 e0 fe ff ff jmp 10c172 <sigtimedwait+0x52>
10c292: 66 90 xchg %ax,%ax
/* API signals pending? */
_ISR_Disable( level );
if ( *set & api->signals_pending ) {
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
10c294: 83 ec 0c sub $0xc,%esp
10c297: 56 push %esi
10c298: 89 55 cc mov %edx,-0x34(%ebp)
10c29b: e8 3c fe ff ff call 10c0dc <_POSIX_signals_Get_lowest>
10c2a0: 89 07 mov %eax,(%edi)
_POSIX_signals_Clear_signals(
10c2a2: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10c2a9: 6a 00 push $0x0
10c2ab: 57 push %edi
10c2ac: 50 push %eax
10c2ad: 8b 55 cc mov -0x34(%ebp),%edx
10c2b0: 52 push %edx
10c2b1: e8 a2 59 00 00 call 111c58 <_POSIX_signals_Clear_signals>
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
10c2b6: ff 75 d0 pushl -0x30(%ebp)
10c2b9: 9d popf
the_info->si_code = SI_USER;
10c2ba: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10c2c1: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return the_info->si_signo;
10c2c8: 8b 37 mov (%edi),%esi
10c2ca: 83 c4 20 add $0x20,%esp
errno = _Thread_Executing->Wait.return_code;
return -1;
}
return the_info->si_signo;
}
10c2cd: 89 f0 mov %esi,%eax
10c2cf: 8d 65 f4 lea -0xc(%ebp),%esp
10c2d2: 5b pop %ebx
10c2d3: 5e pop %esi
10c2d4: 5f pop %edi
10c2d5: c9 leave
10c2d6: c3 ret
10c2d7: 90 nop
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
if ( !interval )
rtems_set_errno_and_return_minus_one( EINVAL );
10c2d8: e8 e3 85 00 00 call 1148c0 <__errno>
10c2dd: c7 00 16 00 00 00 movl $0x16,(%eax)
10c2e3: be ff ff ff ff mov $0xffffffff,%esi
10c2e8: e9 44 ff ff ff jmp 10c231 <sigtimedwait+0x111>
10c2ed: 8d 76 00 lea 0x0(%esi),%esi
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
errno = _Thread_Executing->Wait.return_code;
10c2f0: e8 cb 85 00 00 call 1148c0 <__errno>
10c2f5: 8b 15 98 9b 12 00 mov 0x129b98,%edx
10c2fb: 8b 52 34 mov 0x34(%edx),%edx
10c2fe: 89 10 mov %edx,(%eax)
return -1;
10c300: be ff ff ff ff mov $0xffffffff,%esi
10c305: e9 27 ff ff ff jmp 10c231 <sigtimedwait+0x111>
0010df98 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
10df98: 55 push %ebp
10df99: 89 e5 mov %esp,%ebp
10df9b: 53 push %ebx
10df9c: 83 ec 08 sub $0x8,%esp
10df9f: 8b 5d 0c mov 0xc(%ebp),%ebx
int status;
status = sigtimedwait( set, NULL, NULL );
10dfa2: 6a 00 push $0x0
10dfa4: 6a 00 push $0x0
10dfa6: ff 75 08 pushl 0x8(%ebp)
10dfa9: e8 e6 fd ff ff call 10dd94 <sigtimedwait>
if ( status != -1 ) {
10dfae: 83 c4 10 add $0x10,%esp
10dfb1: 83 f8 ff cmp $0xffffffff,%eax
10dfb4: 74 0e je 10dfc4 <sigwait+0x2c>
if ( sig )
10dfb6: 85 db test %ebx,%ebx
10dfb8: 74 16 je 10dfd0 <sigwait+0x38> <== NEVER TAKEN
*sig = status;
10dfba: 89 03 mov %eax,(%ebx)
return 0;
10dfbc: 31 c0 xor %eax,%eax
}
return errno;
}
10dfbe: 8b 5d fc mov -0x4(%ebp),%ebx
10dfc1: c9 leave
10dfc2: c3 ret
10dfc3: 90 nop
if ( sig )
*sig = status;
return 0;
}
return errno;
10dfc4: e8 a7 80 00 00 call 116070 <__errno>
10dfc9: 8b 00 mov (%eax),%eax
}
10dfcb: 8b 5d fc mov -0x4(%ebp),%ebx
10dfce: c9 leave
10dfcf: c3 ret
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
*sig = status;
return 0;
10dfd0: 31 c0 xor %eax,%eax
}
return errno;
}
10dfd2: 8b 5d fc mov -0x4(%ebp),%ebx
10dfd5: c9 leave
10dfd6: c3 ret <== NOT EXECUTED
0010a0b8 <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
10a0b8: 55 push %ebp
10a0b9: 89 e5 mov %esp,%ebp
10a0bb: 56 push %esi
10a0bc: 53 push %ebx
10a0bd: 89 d3 mov %edx,%ebx
10a0bf: 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)) {
10a0c1: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx)
10a0c8: 75 12 jne 10a0dc <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);
10a0ca: 0f b6 c0 movzbl %al,%eax
10a0cd: 89 da mov %ebx,%edx
}
return i;
}
10a0cf: 8d 65 f8 lea -0x8(%ebp),%esp
10a0d2: 5b pop %ebx <== NOT EXECUTED
10a0d3: 5e pop %esi <== NOT EXECUTED
10a0d4: 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);
10a0d5: e9 92 fe ff ff jmp 109f6c <iproc> <== NOT EXECUTED
10a0da: 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);
10a0dc: 52 push %edx
10a0dd: 6a 00 push $0x0
10a0df: 6a 00 push $0x0
10a0e1: ff 73 18 pushl 0x18(%ebx)
10a0e4: e8 c7 15 00 00 call 10b6b0 <rtems_semaphore_obtain>
i = iproc (c, tty);
10a0e9: 89 f2 mov %esi,%edx
10a0eb: 0f b6 c2 movzbl %dl,%eax
10a0ee: 89 da mov %ebx,%edx
10a0f0: e8 77 fe ff ff call 109f6c <iproc>
10a0f5: 89 c6 mov %eax,%esi
rtems_semaphore_release (tty->osem);
10a0f7: 58 pop %eax
10a0f8: ff 73 18 pushl 0x18(%ebx)
10a0fb: e8 ac 16 00 00 call 10b7ac <rtems_semaphore_release>
10a100: 83 c4 10 add $0x10,%esp
}
else {
i = iproc (c, tty);
}
return i;
}
10a103: 89 f0 mov %esi,%eax
10a105: 8d 65 f8 lea -0x8(%ebp),%esp
10a108: 5b pop %ebx
10a109: 5e pop %esi
10a10a: c9 leave
10a10b: c3 ret
00108ecc <stat>:
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
108ecc: 55 push %ebp
108ecd: 89 e5 mov %esp,%ebp
108ecf: 57 push %edi
108ed0: 56 push %esi
108ed1: 53 push %ebx
108ed2: 83 ec 3c sub $0x3c,%esp
108ed5: 8b 55 08 mov 0x8(%ebp),%edx
108ed8: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
108edb: 85 f6 test %esi,%esi
108edd: 74 65 je 108f44 <stat+0x78>
rtems_set_errno_and_return_minus_one( EFAULT );
status = rtems_filesystem_evaluate_path( path, strlen( path ),
108edf: b9 ff ff ff ff mov $0xffffffff,%ecx
108ee4: 89 d7 mov %edx,%edi
108ee6: 31 c0 xor %eax,%eax
108ee8: f2 ae repnz scas %es:(%edi),%al
108eea: f7 d1 not %ecx
108eec: 49 dec %ecx
108eed: 83 ec 0c sub $0xc,%esp
108ef0: 6a 01 push $0x1
108ef2: 8d 5d d4 lea -0x2c(%ebp),%ebx
108ef5: 53 push %ebx
108ef6: 6a 00 push $0x0
108ef8: 51 push %ecx
108ef9: 52 push %edx
108efa: e8 45 f1 ff ff call 108044 <rtems_filesystem_evaluate_path>
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
108eff: 83 c4 20 add $0x20,%esp
108f02: 85 c0 test %eax,%eax
108f04: 74 0e je 108f14 <stat+0x48>
return -1;
108f06: b8 ff ff ff ff mov $0xffffffff,%eax
status = (*loc.handlers->fstat_h)( &loc, buf );
rtems_filesystem_freenode( &loc );
return status;
}
108f0b: 8d 65 f4 lea -0xc(%ebp),%esp
108f0e: 5b pop %ebx
108f0f: 5e pop %esi
108f10: 5f pop %edi
108f11: c9 leave
108f12: c3 ret
108f13: 90 nop
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
108f14: b9 48 00 00 00 mov $0x48,%ecx
108f19: 89 f7 mov %esi,%edi
108f1b: f3 aa rep stos %al,%es:(%edi)
status = (*loc.handlers->fstat_h)( &loc, buf );
108f1d: 83 ec 08 sub $0x8,%esp
108f20: 56 push %esi
108f21: 53 push %ebx
108f22: 8b 45 dc mov -0x24(%ebp),%eax
108f25: ff 50 18 call *0x18(%eax)
rtems_filesystem_freenode( &loc );
108f28: 89 1c 24 mov %ebx,(%esp)
108f2b: 89 45 c4 mov %eax,-0x3c(%ebp)
108f2e: e8 e9 f1 ff ff call 10811c <rtems_filesystem_freenode>
return status;
108f33: 83 c4 10 add $0x10,%esp
108f36: 8b 45 c4 mov -0x3c(%ebp),%eax
}
108f39: 8d 65 f4 lea -0xc(%ebp),%esp
108f3c: 5b pop %ebx
108f3d: 5e pop %esi
108f3e: 5f pop %edi
108f3f: c9 leave
108f40: c3 ret
108f41: 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 );
108f44: e8 5b 87 00 00 call 1116a4 <__errno>
108f49: c7 00 0e 00 00 00 movl $0xe,(%eax)
108f4f: b8 ff ff ff ff mov $0xffffffff,%eax
status = (*loc.handlers->fstat_h)( &loc, buf );
rtems_filesystem_freenode( &loc );
return status;
}
108f54: 8d 65 f4 lea -0xc(%ebp),%esp
108f57: 5b pop %ebx
108f58: 5e pop %esi
108f59: 5f pop %edi
108f5a: c9 leave
108f5b: c3 ret
0010b33c <statvfs>:
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
10b33c: 55 push %ebp
10b33d: 89 e5 mov %esp,%ebp
10b33f: 57 push %edi
10b340: 56 push %esi
10b341: 53 push %ebx
10b342: 83 ec 48 sub $0x48,%esp
10b345: 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 ) )
10b348: 31 f6 xor %esi,%esi
10b34a: b9 ff ff ff ff mov $0xffffffff,%ecx
10b34f: 89 d7 mov %edx,%edi
10b351: 89 f0 mov %esi,%eax
10b353: f2 ae repnz scas %es:(%edi),%al
10b355: f7 d1 not %ecx
10b357: 49 dec %ecx
10b358: 6a 01 push $0x1
10b35a: 8d 5d d4 lea -0x2c(%ebp),%ebx
10b35d: 53 push %ebx
10b35e: 6a 00 push $0x0
10b360: 51 push %ecx
10b361: 52 push %edx
10b362: e8 ad eb ff ff call 109f14 <rtems_filesystem_evaluate_path>
10b367: 83 c4 20 add $0x20,%esp
10b36a: 85 c0 test %eax,%eax
10b36c: 74 0e je 10b37c <statvfs+0x40> <== ALWAYS TAKEN
return -1;
10b36e: b8 ff ff ff ff mov $0xffffffff,%eax
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
rtems_filesystem_freenode( &loc );
return result;
}
10b373: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10b376: 5b pop %ebx <== NOT EXECUTED
10b377: 5e pop %esi <== NOT EXECUTED
10b378: 5f pop %edi <== NOT EXECUTED
10b379: c9 leave <== NOT EXECUTED
10b37a: c3 ret <== NOT EXECUTED
10b37b: 90 nop <== NOT EXECUTED
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
return -1;
mt_entry = loc.mt_entry;
10b37c: 8b 55 e4 mov -0x1c(%ebp),%edx
fs_mount_root = &mt_entry->mt_fs_root;
memset (sb, 0, sizeof (struct statvfs));
10b37f: b9 38 00 00 00 mov $0x38,%ecx
10b384: 8b 7d 0c mov 0xc(%ebp),%edi
10b387: 89 f0 mov %esi,%eax
10b389: f3 aa rep stos %al,%es:(%edi)
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
10b38b: 83 ec 08 sub $0x8,%esp
10b38e: 8b 42 28 mov 0x28(%edx),%eax
10b391: 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;
10b394: 83 c2 1c add $0x1c,%edx
memset (sb, 0, sizeof (struct statvfs));
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
10b397: 52 push %edx
10b398: ff 50 44 call *0x44(%eax)
rtems_filesystem_freenode( &loc );
10b39b: 89 1c 24 mov %ebx,(%esp)
10b39e: 89 45 c4 mov %eax,-0x3c(%ebp)
10b3a1: e8 46 ec ff ff call 109fec <rtems_filesystem_freenode>
return result;
10b3a6: 83 c4 10 add $0x10,%esp
10b3a9: 8b 45 c4 mov -0x3c(%ebp),%eax
}
10b3ac: 8d 65 f4 lea -0xc(%ebp),%esp
10b3af: 5b pop %ebx
10b3b0: 5e pop %esi
10b3b1: 5f pop %edi
10b3b2: c9 leave
10b3b3: c3 ret
0010acf4 <symlink>:
int symlink(
const char *actualpath,
const char *sympath
)
{
10acf4: 55 push %ebp
10acf5: 89 e5 mov %esp,%ebp
10acf7: 56 push %esi
10acf8: 53 push %ebx
10acf9: 83 ec 34 sub $0x34,%esp
10acfc: 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 );
10acff: 8d 5d dc lea -0x24(%ebp),%ebx
10ad02: 53 push %ebx
10ad03: 8d 45 f4 lea -0xc(%ebp),%eax
10ad06: 50 push %eax
10ad07: 56 push %esi
10ad08: e8 0f ff ff ff call 10ac1c <rtems_filesystem_get_start_loc>
result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start );
10ad0d: 83 c4 0c add $0xc,%esp
10ad10: 8d 45 f0 lea -0x10(%ebp),%eax
10ad13: 50 push %eax
10ad14: 53 push %ebx
10ad15: 03 75 f4 add -0xc(%ebp),%esi
10ad18: 56 push %esi
10ad19: 8b 45 e8 mov -0x18(%ebp),%eax
10ad1c: ff 50 04 call *0x4(%eax)
if ( result != 0 )
10ad1f: 83 c4 10 add $0x10,%esp
10ad22: 85 c0 test %eax,%eax
10ad24: 74 0e je 10ad34 <symlink+0x40>
return -1;
10ad26: b8 ff ff ff ff mov $0xffffffff,%eax
result = (*loc.ops->symlink_h)( &loc, actualpath, name_start);
rtems_filesystem_freenode( &loc );
return result;
}
10ad2b: 8d 65 f8 lea -0x8(%ebp),%esp
10ad2e: 5b pop %ebx
10ad2f: 5e pop %esi
10ad30: c9 leave
10ad31: c3 ret
10ad32: 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);
10ad34: 50 push %eax
10ad35: ff 75 f0 pushl -0x10(%ebp)
10ad38: ff 75 08 pushl 0x8(%ebp)
10ad3b: 53 push %ebx
10ad3c: 8b 45 e8 mov -0x18(%ebp),%eax
10ad3f: ff 50 38 call *0x38(%eax)
rtems_filesystem_freenode( &loc );
10ad42: 89 1c 24 mov %ebx,(%esp)
10ad45: 89 45 d4 mov %eax,-0x2c(%ebp)
10ad48: e8 6f ec ff ff call 1099bc <rtems_filesystem_freenode>
return result;
10ad4d: 83 c4 10 add $0x10,%esp
10ad50: 8b 45 d4 mov -0x2c(%ebp),%eax
}
10ad53: 8d 65 f8 lea -0x8(%ebp),%esp
10ad56: 5b pop %ebx
10ad57: 5e pop %esi
10ad58: c9 leave
10ad59: c3 ret
0010a1c8 <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
10a1c8: 55 push %ebp
10a1c9: 89 e5 mov %esp,%ebp
10a1cb: 53 push %ebx
10a1cc: 83 ec 04 sub $0x4,%esp
10a1cf: 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;
10a1d2: 8b 90 e4 00 00 00 mov 0xe4(%eax),%edx
if ( this_reent ) {
10a1d8: 85 d2 test %edx,%edx
10a1da: 74 33 je 10a20f <sync_per_thread+0x47> <== NEVER TAKEN
current_reent = _Thread_Executing->libc_reent;
10a1dc: 8b 0d 78 9f 12 00 mov 0x129f78,%ecx
10a1e2: 8b 99 e4 00 00 00 mov 0xe4(%ecx),%ebx
_Thread_Executing->libc_reent = this_reent;
10a1e8: 89 91 e4 00 00 00 mov %edx,0xe4(%ecx)
_fwalk (t->libc_reent, sync_wrapper);
10a1ee: 83 ec 08 sub $0x8,%esp
10a1f1: 68 14 a2 10 00 push $0x10a214
10a1f6: ff b0 e4 00 00 00 pushl 0xe4(%eax)
10a1fc: e8 f7 b0 00 00 call 1152f8 <_fwalk>
_Thread_Executing->libc_reent = current_reent;
10a201: a1 78 9f 12 00 mov 0x129f78,%eax
10a206: 89 98 e4 00 00 00 mov %ebx,0xe4(%eax)
10a20c: 83 c4 10 add $0x10,%esp
}
}
10a20f: 8b 5d fc mov -0x4(%ebp),%ebx
10a212: c9 leave
10a213: c3 ret
0010a874 <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
10a874: 55 push %ebp
10a875: 89 e5 mov %esp,%ebp
10a877: 56 push %esi
10a878: 53 push %ebx
10a879: 8b 5d 08 mov 0x8(%ebp),%ebx
10a87c: 8b 45 0c mov 0xc(%ebp),%eax
10a87f: 8b 75 10 mov 0x10(%ebp),%esi
switch (opt) {
10a882: 85 c0 test %eax,%eax
10a884: 74 2c je 10a8b2 <tcsetattr+0x3e>
10a886: 48 dec %eax
10a887: 74 17 je 10a8a0 <tcsetattr+0x2c>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
10a889: e8 5a a5 00 00 call 114de8 <__errno>
10a88e: c7 00 86 00 00 00 movl $0x86,(%eax)
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
}
}
10a894: b8 ff ff ff ff mov $0xffffffff,%eax
10a899: 8d 65 f8 lea -0x8(%ebp),%esp
10a89c: 5b pop %ebx
10a89d: 5e pop %esi
10a89e: c9 leave
10a89f: c3 ret
switch (opt) {
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
10a8a0: 50 push %eax
10a8a1: 6a 00 push $0x0
10a8a3: 6a 03 push $0x3
10a8a5: 53 push %ebx
10a8a6: e8 09 72 00 00 call 111ab4 <ioctl>
10a8ab: 83 c4 10 add $0x10,%esp
10a8ae: 85 c0 test %eax,%eax
10a8b0: 78 e2 js 10a894 <tcsetattr+0x20> <== NEVER TAKEN
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
10a8b2: 89 75 10 mov %esi,0x10(%ebp)
10a8b5: c7 45 0c 02 00 00 00 movl $0x2,0xc(%ebp)
10a8bc: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
10a8bf: 8d 65 f8 lea -0x8(%ebp),%esp
10a8c2: 5b pop %ebx
10a8c3: 5e pop %esi
10a8c4: c9 leave
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
10a8c5: e9 ea 71 00 00 jmp 111ab4 <ioctl>
0010b500 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
10b500: 55 push %ebp
10b501: 89 e5 mov %esp,%ebp
10b503: 56 push %esi
10b504: 53 push %ebx
10b505: 8b 5d 0c mov 0xc(%ebp),%ebx
10b508: 8b 75 10 mov 0x10(%ebp),%esi
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
10b50b: 83 7d 08 01 cmpl $0x1,0x8(%ebp)
10b50f: 0f 85 db 00 00 00 jne 10b5f0 <timer_create+0xf0>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
10b515: 85 f6 test %esi,%esi
10b517: 0f 84 d3 00 00 00 je 10b5f0 <timer_create+0xf0>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
10b51d: 85 db test %ebx,%ebx
10b51f: 74 21 je 10b542 <timer_create+0x42>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
10b521: 8b 03 mov (%ebx),%eax
10b523: 48 dec %eax
10b524: 83 f8 01 cmp $0x1,%eax
10b527: 0f 87 c3 00 00 00 ja 10b5f0 <timer_create+0xf0> <== NEVER TAKEN
( evp->sigev_notify != SIGEV_SIGNAL ) ) {
/* The value of the field sigev_notify is not valid */
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !evp->sigev_signo )
10b52d: 8b 43 04 mov 0x4(%ebx),%eax
10b530: 85 c0 test %eax,%eax
10b532: 0f 84 b8 00 00 00 je 10b5f0 <timer_create+0xf0> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10b538: 48 dec %eax
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
10b539: 83 f8 1f cmp $0x1f,%eax
10b53c: 0f 87 ae 00 00 00 ja 10b5f0 <timer_create+0xf0> <== NEVER TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b542: a1 d0 a0 12 00 mov 0x12a0d0,%eax
10b547: 40 inc %eax
10b548: a3 d0 a0 12 00 mov %eax,0x12a0d0
* the inactive chain of free timer control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void )
{
return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information );
10b54d: 83 ec 0c sub $0xc,%esp
10b550: 68 20 a4 12 00 push $0x12a420
10b555: e8 9a 1e 00 00 call 10d3f4 <_Objects_Allocate>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
10b55a: 83 c4 10 add $0x10,%esp
10b55d: 85 c0 test %eax,%eax
10b55f: 0f 84 a2 00 00 00 je 10b607 <timer_create+0x107>
rtems_set_errno_and_return_minus_one( EAGAIN );
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
10b565: c6 40 3c 02 movb $0x2,0x3c(%eax)
ptimer->thread_id = _Thread_Executing->Object.id;
10b569: 8b 15 78 a6 12 00 mov 0x12a678,%edx
10b56f: 8b 52 08 mov 0x8(%edx),%edx
10b572: 89 50 38 mov %edx,0x38(%eax)
if ( evp != NULL ) {
10b575: 85 db test %ebx,%ebx
10b577: 74 11 je 10b58a <timer_create+0x8a>
ptimer->inf.sigev_notify = evp->sigev_notify;
10b579: 8b 13 mov (%ebx),%edx
10b57b: 89 50 40 mov %edx,0x40(%eax)
ptimer->inf.sigev_signo = evp->sigev_signo;
10b57e: 8b 53 04 mov 0x4(%ebx),%edx
10b581: 89 50 44 mov %edx,0x44(%eax)
ptimer->inf.sigev_value = evp->sigev_value;
10b584: 8b 53 08 mov 0x8(%ebx),%edx
10b587: 89 50 48 mov %edx,0x48(%eax)
}
ptimer->overrun = 0;
10b58a: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax)
ptimer->timer_data.it_value.tv_sec = 0;
10b591: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
ptimer->timer_data.it_value.tv_nsec = 0;
10b598: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
ptimer->timer_data.it_interval.tv_sec = 0;
10b59f: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
ptimer->timer_data.it_interval.tv_nsec = 0;
10b5a6: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10b5ad: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10b5b4: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
the_watchdog->id = id;
10b5bb: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
the_watchdog->user_data = user_data;
10b5c2: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10b5c9: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10b5cc: 0f b7 da movzwl %dx,%ebx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10b5cf: 8b 0d 3c a4 12 00 mov 0x12a43c,%ecx
10b5d5: 89 04 99 mov %eax,(%ecx,%ebx,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10b5d8: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
_Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL );
_Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);
*timerid = ptimer->Object.id;
10b5df: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
10b5e1: e8 3a 2e 00 00 call 10e420 <_Thread_Enable_dispatch>
return 0;
10b5e6: 31 c0 xor %eax,%eax
}
10b5e8: 8d 65 f8 lea -0x8(%ebp),%esp
10b5eb: 5b pop %ebx
10b5ec: 5e pop %esi
10b5ed: c9 leave
10b5ee: c3 ret
10b5ef: 90 nop
if ( !evp->sigev_signo )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
rtems_set_errno_and_return_minus_one( EINVAL );
10b5f0: e8 2f 8a 00 00 call 114024 <__errno>
10b5f5: c7 00 16 00 00 00 movl $0x16,(%eax)
10b5fb: b8 ff ff ff ff mov $0xffffffff,%eax
_Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);
*timerid = ptimer->Object.id;
_Thread_Enable_dispatch();
return 0;
}
10b600: 8d 65 f8 lea -0x8(%ebp),%esp
10b603: 5b pop %ebx
10b604: 5e pop %esi
10b605: c9 leave
10b606: c3 ret
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
_Thread_Enable_dispatch();
10b607: e8 14 2e 00 00 call 10e420 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
10b60c: e8 13 8a 00 00 call 114024 <__errno>
10b611: c7 00 0b 00 00 00 movl $0xb,(%eax)
10b617: b8 ff ff ff ff mov $0xffffffff,%eax
10b61c: eb ca jmp 10b5e8 <timer_create+0xe8>
0010ba44 <timer_delete>:
int timer_delete(
timer_t timerid
)
{
10ba44: 55 push %ebp
10ba45: 89 e5 mov %esp,%ebp
10ba47: 53 push %ebx
10ba48: 83 ec 18 sub $0x18,%esp
* because rtems_timer_delete stops the timer before deleting it.
*/
POSIX_Timer_Control *ptimer;
Objects_Locations location;
ptimer = _POSIX_Timer_Get( timerid, &location );
10ba4b: 8d 45 f4 lea -0xc(%ebp),%eax
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
_Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location );
10ba4e: 50 push %eax
10ba4f: ff 75 08 pushl 0x8(%ebp)
10ba52: 68 00 a3 12 00 push $0x12a300
10ba57: e8 9c 21 00 00 call 10dbf8 <_Objects_Get>
10ba5c: 89 c3 mov %eax,%ebx
switch ( location ) {
10ba5e: 83 c4 10 add $0x10,%esp
10ba61: 8b 4d f4 mov -0xc(%ebp),%ecx
10ba64: 85 c9 test %ecx,%ecx
10ba66: 74 18 je 10ba80 <timer_delete+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10ba68: e8 b7 8c 00 00 call 114724 <__errno>
10ba6d: c7 00 16 00 00 00 movl $0x16,(%eax)
10ba73: b8 ff ff ff ff mov $0xffffffff,%eax
}
10ba78: 8b 5d fc mov -0x4(%ebp),%ebx
10ba7b: c9 leave
10ba7c: c3 ret
10ba7d: 8d 76 00 lea 0x0(%esi),%esi
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Objects_Close( &_POSIX_Timer_Information, &ptimer->Object );
10ba80: 83 ec 08 sub $0x8,%esp
10ba83: 50 push %eax
10ba84: 68 00 a3 12 00 push $0x12a300
10ba89: e8 32 1d 00 00 call 10d7c0 <_Objects_Close>
ptimer->state = POSIX_TIMER_STATE_FREE;
10ba8e: c6 43 3c 01 movb $0x1,0x3c(%ebx)
(void) _Watchdog_Remove( &ptimer->Timer );
10ba92: 8d 43 10 lea 0x10(%ebx),%eax
10ba95: 89 04 24 mov %eax,(%esp)
10ba98: e8 6b 3c 00 00 call 10f708 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _POSIX_Timer_Free (
POSIX_Timer_Control *the_timer
)
{
_Objects_Free( &_POSIX_Timer_Information, &the_timer->Object );
10ba9d: 58 pop %eax
10ba9e: 5a pop %edx
10ba9f: 53 push %ebx
10baa0: 68 00 a3 12 00 push $0x12a300
10baa5: e8 0e 20 00 00 call 10dab8 <_Objects_Free>
_POSIX_Timer_Free( ptimer );
_Thread_Enable_dispatch();
10baaa: e8 c1 2c 00 00 call 10e770 <_Thread_Enable_dispatch>
return 0;
10baaf: 83 c4 10 add $0x10,%esp
10bab2: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10bab4: 8b 5d fc mov -0x4(%ebp),%ebx
10bab7: c9 leave
10bab8: c3 ret
0010c900 <timer_getoverrun>:
* its execution, _POSIX_Timer_TSR will have to set this counter to 0.
*/
int timer_getoverrun(
timer_t timerid
)
{
10c900: 55 push %ebp
10c901: 89 e5 mov %esp,%ebp
10c903: 53 push %ebx
10c904: 83 ec 18 sub $0x18,%esp
int overrun;
POSIX_Timer_Control *ptimer;
Objects_Locations location;
ptimer = _POSIX_Timer_Get( timerid, &location );
10c907: 8d 45 f4 lea -0xc(%ebp),%eax
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
_Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location );
10c90a: 50 push %eax
10c90b: ff 75 08 pushl 0x8(%ebp)
10c90e: 68 e0 b9 12 00 push $0x12b9e0
10c913: e8 24 21 00 00 call 10ea3c <_Objects_Get>
switch ( location ) {
10c918: 83 c4 10 add $0x10,%esp
10c91b: 8b 55 f4 mov -0xc(%ebp),%edx
10c91e: 85 d2 test %edx,%edx
10c920: 74 1a je 10c93c <timer_getoverrun+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10c922: e8 7d 88 00 00 call 1151a4 <__errno>
10c927: c7 00 16 00 00 00 movl $0x16,(%eax)
10c92d: bb ff ff ff ff mov $0xffffffff,%ebx
}
10c932: 89 d8 mov %ebx,%eax
10c934: 8b 5d fc mov -0x4(%ebp),%ebx
10c937: c9 leave
10c938: c3 ret
10c939: 8d 76 00 lea 0x0(%esi),%esi
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
case OBJECTS_LOCAL:
overrun = ptimer->overrun;
10c93c: 8b 58 68 mov 0x68(%eax),%ebx
ptimer->overrun = 0;
10c93f: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax)
_Thread_Enable_dispatch();
10c946: e8 69 2c 00 00 call 10f5b4 <_Thread_Enable_dispatch>
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10c94b: 89 d8 mov %ebx,%eax
10c94d: 8b 5d fc mov -0x4(%ebp),%ebx
10c950: c9 leave
10c951: c3 ret
0010c954 <timer_gettime>:
int timer_gettime(
timer_t timerid,
struct itimerspec *value
)
{
10c954: 55 push %ebp
10c955: 89 e5 mov %esp,%ebp
10c957: 56 push %esi
10c958: 53 push %ebx
10c959: 83 ec 10 sub $0x10,%esp
10c95c: 8b 5d 0c mov 0xc(%ebp),%ebx
POSIX_Timer_Control *ptimer;
Objects_Locations location;
struct timespec current_time;
Watchdog_Interval left;
if ( !value )
10c95f: 85 db test %ebx,%ebx
10c961: 74 65 je 10c9c8 <timer_gettime+0x74>
rtems_set_errno_and_return_minus_one( EINVAL );
/* Reads the current time */
_TOD_Get( ¤t_time );
10c963: 83 ec 0c sub $0xc,%esp
10c966: 8d 45 ec lea -0x14(%ebp),%eax
10c969: 50 push %eax
10c96a: e8 fd 16 00 00 call 10e06c <_TOD_Get>
10c96f: 83 c4 0c add $0xc,%esp
ptimer = _POSIX_Timer_Get( timerid, &location );
10c972: 8d 45 f4 lea -0xc(%ebp),%eax
10c975: 50 push %eax
10c976: ff 75 08 pushl 0x8(%ebp)
10c979: 68 e0 b9 12 00 push $0x12b9e0
10c97e: e8 b9 20 00 00 call 10ea3c <_Objects_Get>
10c983: 89 c6 mov %eax,%esi
switch ( location ) {
10c985: 83 c4 10 add $0x10,%esp
10c988: 8b 45 f4 mov -0xc(%ebp),%eax
10c98b: 85 c0 test %eax,%eax
10c98d: 75 39 jne 10c9c8 <timer_gettime+0x74>
case OBJECTS_LOCAL:
/* Calculates the time left before the timer finishes */
left =
(ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */
10c98f: a1 c4 b7 12 00 mov 0x12b7c4,%eax
_Watchdog_Ticks_since_boot; /* now */
_Timespec_From_ticks( left, &value->it_value );
10c994: 83 ec 08 sub $0x8,%esp
10c997: 8d 53 08 lea 0x8(%ebx),%edx
10c99a: 52 push %edx
case OBJECTS_LOCAL:
/* Calculates the time left before the timer finishes */
left =
(ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */
10c99b: 8b 56 1c mov 0x1c(%esi),%edx
10c99e: 03 56 24 add 0x24(%esi),%edx
case OBJECTS_LOCAL:
/* Calculates the time left before the timer finishes */
left =
10c9a1: 29 c2 sub %eax,%edx
(ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */
_Watchdog_Ticks_since_boot; /* now */
_Timespec_From_ticks( left, &value->it_value );
10c9a3: 52 push %edx
10c9a4: e8 9b 36 00 00 call 110044 <_Timespec_From_ticks>
value->it_interval = ptimer->timer_data.it_interval;
10c9a9: 8b 46 54 mov 0x54(%esi),%eax
10c9ac: 8b 56 58 mov 0x58(%esi),%edx
10c9af: 89 03 mov %eax,(%ebx)
10c9b1: 89 53 04 mov %edx,0x4(%ebx)
_Thread_Enable_dispatch();
10c9b4: e8 fb 2b 00 00 call 10f5b4 <_Thread_Enable_dispatch>
return 0;
10c9b9: 83 c4 10 add $0x10,%esp
10c9bc: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10c9be: 8d 65 f8 lea -0x8(%ebp),%esp
10c9c1: 5b pop %ebx
10c9c2: 5e pop %esi
10c9c3: c9 leave
10c9c4: c3 ret
10c9c5: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10c9c8: e8 d7 87 00 00 call 1151a4 <__errno>
10c9cd: c7 00 16 00 00 00 movl $0x16,(%eax)
10c9d3: b8 ff ff ff ff mov $0xffffffff,%eax
10c9d8: eb e4 jmp 10c9be <timer_gettime+0x6a>
0010b620 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
10b620: 55 push %ebp
10b621: 89 e5 mov %esp,%ebp
10b623: 57 push %edi
10b624: 56 push %esi
10b625: 53 push %ebx
10b626: 83 ec 3c sub $0x3c,%esp
10b629: 8b 5d 10 mov 0x10(%ebp),%ebx
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
10b62c: 85 db test %ebx,%ebx
10b62e: 0f 84 50 01 00 00 je 10b784 <timer_settime+0x164> <== NEVER TAKEN
/*
* First, it verifies if the structure "value" is correct
* if the number of nanoseconds is not correct return EINVAL
*/
if ( !_Timespec_Is_valid( &(value->it_value) ) ) {
10b634: 83 ec 0c sub $0xc,%esp
10b637: 8d 43 08 lea 0x8(%ebx),%eax
10b63a: 50 push %eax
10b63b: e8 94 38 00 00 call 10eed4 <_Timespec_Is_valid>
10b640: 83 c4 10 add $0x10,%esp
10b643: 84 c0 test %al,%al
10b645: 0f 84 39 01 00 00 je 10b784 <timer_settime+0x164>
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
10b64b: 83 ec 0c sub $0xc,%esp
10b64e: 53 push %ebx
10b64f: e8 80 38 00 00 call 10eed4 <_Timespec_Is_valid>
10b654: 83 c4 10 add $0x10,%esp
10b657: 84 c0 test %al,%al
10b659: 0f 84 25 01 00 00 je 10b784 <timer_settime+0x164> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
10b65f: 83 7d 0c 04 cmpl $0x4,0xc(%ebp)
10b663: 0f 84 db 00 00 00 je 10b744 <timer_settime+0x124>
10b669: 8b 45 0c mov 0xc(%ebp),%eax
10b66c: 85 c0 test %eax,%eax
10b66e: 0f 85 10 01 00 00 jne 10b784 <timer_settime+0x164>
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
10b674: 8d 45 cc lea -0x34(%ebp),%eax
10b677: 89 45 c4 mov %eax,-0x3c(%ebp)
10b67a: b9 04 00 00 00 mov $0x4,%ecx
10b67f: 89 c7 mov %eax,%edi
10b681: 89 de mov %ebx,%esi
10b683: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
_Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location );
10b685: 50 push %eax
/* If the function reaches this point, then it will be necessary to do
* something with the structure of times of the timer: to stop, start
* or start it again
*/
ptimer = _POSIX_Timer_Get( timerid, &location );
10b686: 8d 45 e4 lea -0x1c(%ebp),%eax
10b689: 50 push %eax
10b68a: ff 75 08 pushl 0x8(%ebp)
10b68d: 68 20 a4 12 00 push $0x12a420
10b692: e8 11 22 00 00 call 10d8a8 <_Objects_Get>
10b697: 89 c2 mov %eax,%edx
switch ( location ) {
10b699: 83 c4 10 add $0x10,%esp
10b69c: 8b 7d e4 mov -0x1c(%ebp),%edi
10b69f: 85 ff test %edi,%edi
10b6a1: 0f 85 dd 00 00 00 jne 10b784 <timer_settime+0x164>
case OBJECTS_LOCAL:
/* First, it verifies if the timer must be stopped */
if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) {
10b6a7: 8b 75 d4 mov -0x2c(%ebp),%esi
10b6aa: 85 f6 test %esi,%esi
10b6ac: 75 0b jne 10b6b9 <timer_settime+0x99>
10b6ae: 8b 4d d8 mov -0x28(%ebp),%ecx
10b6b1: 85 c9 test %ecx,%ecx
10b6b3: 0f 84 df 00 00 00 je 10b798 <timer_settime+0x178>
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
10b6b9: 83 ec 0c sub $0xc,%esp
10b6bc: 53 push %ebx
10b6bd: 89 55 c0 mov %edx,-0x40(%ebp)
10b6c0: e8 77 38 00 00 call 10ef3c <_Timespec_To_ticks>
10b6c5: 8b 55 c0 mov -0x40(%ebp),%edx
10b6c8: 89 42 64 mov %eax,0x64(%edx)
initial_period = _Timespec_To_ticks( &normalize.it_value );
10b6cb: 8d 45 d4 lea -0x2c(%ebp),%eax
10b6ce: 89 04 24 mov %eax,(%esp)
10b6d1: e8 66 38 00 00 call 10ef3c <_Timespec_To_ticks>
activated = _POSIX_Timer_Insert_helper(
10b6d6: 8b 55 c0 mov -0x40(%ebp),%edx
10b6d9: 89 14 24 mov %edx,(%esp)
10b6dc: 68 04 b8 10 00 push $0x10b804
10b6e1: ff 72 08 pushl 0x8(%edx)
10b6e4: 50 push %eax
10b6e5: 8d 42 10 lea 0x10(%edx),%eax
10b6e8: 50 push %eax
10b6e9: e8 6e 61 00 00 call 11185c <_POSIX_Timer_Insert_helper>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
10b6ee: 83 c4 20 add $0x20,%esp
10b6f1: 84 c0 test %al,%al
10b6f3: 8b 55 c0 mov -0x40(%ebp),%edx
10b6f6: 0f 84 e8 00 00 00 je 10b7e4 <timer_settime+0x1c4>
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
10b6fc: 8b 45 14 mov 0x14(%ebp),%eax
10b6ff: 85 c0 test %eax,%eax
10b701: 0f 84 ed 00 00 00 je 10b7f4 <timer_settime+0x1d4>
*ovalue = ptimer->timer_data;
10b707: 8d 42 54 lea 0x54(%edx),%eax
10b70a: b9 04 00 00 00 mov $0x4,%ecx
10b70f: 8b 7d 14 mov 0x14(%ebp),%edi
10b712: 89 c6 mov %eax,%esi
10b714: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
ptimer->timer_data = normalize;
10b716: b9 04 00 00 00 mov $0x4,%ecx
10b71b: 89 c7 mov %eax,%edi
10b71d: 8b 75 c4 mov -0x3c(%ebp),%esi
10b720: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10b722: c6 42 3c 03 movb $0x3,0x3c(%edx)
_TOD_Get( &ptimer->time );
10b726: 83 ec 0c sub $0xc,%esp
10b729: 83 c2 6c add $0x6c,%edx
10b72c: 52 push %edx
10b72d: e8 ca 17 00 00 call 10cefc <_TOD_Get>
_Thread_Enable_dispatch();
10b732: e8 e9 2c 00 00 call 10e420 <_Thread_Enable_dispatch>
return 0;
10b737: 83 c4 10 add $0x10,%esp
10b73a: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10b73c: 8d 65 f4 lea -0xc(%ebp),%esp
10b73f: 5b pop %ebx
10b740: 5e pop %esi
10b741: 5f pop %edi
10b742: c9 leave
10b743: c3 ret
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
10b744: 8d 45 cc lea -0x34(%ebp),%eax
10b747: 89 45 c4 mov %eax,-0x3c(%ebp)
10b74a: 89 c7 mov %eax,%edi
10b74c: 89 de mov %ebx,%esi
10b74e: 8b 4d 0c mov 0xc(%ebp),%ecx
10b751: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
struct timespec now;
_TOD_Get( &now );
10b753: 83 ec 0c sub $0xc,%esp
10b756: 8d 75 dc lea -0x24(%ebp),%esi
10b759: 56 push %esi
10b75a: e8 9d 17 00 00 call 10cefc <_TOD_Get>
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
10b75f: 59 pop %ecx
10b760: 5f pop %edi
10b761: 8d 7d d4 lea -0x2c(%ebp),%edi
10b764: 57 push %edi
10b765: 56 push %esi
10b766: e8 45 37 00 00 call 10eeb0 <_Timespec_Greater_than>
10b76b: 83 c4 10 add $0x10,%esp
10b76e: 84 c0 test %al,%al
10b770: 75 12 jne 10b784 <timer_settime+0x164>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
10b772: 52 push %edx
10b773: 57 push %edi
10b774: 57 push %edi
10b775: 56 push %esi
10b776: e8 81 37 00 00 call 10eefc <_Timespec_Subtract>
10b77b: 83 c4 10 add $0x10,%esp
10b77e: e9 02 ff ff ff jmp 10b685 <timer_settime+0x65>
10b783: 90 nop
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10b784: e8 9b 88 00 00 call 114024 <__errno>
10b789: c7 00 16 00 00 00 movl $0x16,(%eax)
10b78f: b8 ff ff ff ff mov $0xffffffff,%eax
10b794: eb a6 jmp 10b73c <timer_settime+0x11c>
10b796: 66 90 xchg %ax,%ax
case OBJECTS_LOCAL:
/* First, it verifies if the timer must be stopped */
if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) {
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
10b798: 83 ec 0c sub $0xc,%esp
10b79b: 8d 40 10 lea 0x10(%eax),%eax
10b79e: 50 push %eax
10b79f: 89 55 c0 mov %edx,-0x40(%ebp)
10b7a2: e8 c9 3b 00 00 call 10f370 <_Watchdog_Remove>
/* The old data of the timer are returned */
if ( ovalue )
10b7a7: 83 c4 10 add $0x10,%esp
10b7aa: 8b 55 14 mov 0x14(%ebp),%edx
10b7ad: 85 d2 test %edx,%edx
10b7af: 8b 55 c0 mov -0x40(%ebp),%edx
10b7b2: 74 48 je 10b7fc <timer_settime+0x1dc>
*ovalue = ptimer->timer_data;
10b7b4: 8d 42 54 lea 0x54(%edx),%eax
10b7b7: b9 04 00 00 00 mov $0x4,%ecx
10b7bc: 8b 7d 14 mov 0x14(%ebp),%edi
10b7bf: 89 c6 mov %eax,%esi
10b7c1: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* The new data are set */
ptimer->timer_data = normalize;
10b7c3: b9 04 00 00 00 mov $0x4,%ecx
10b7c8: 89 c7 mov %eax,%edi
10b7ca: 8b 75 c4 mov -0x3c(%ebp),%esi
10b7cd: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10b7cf: c6 42 3c 04 movb $0x4,0x3c(%edx)
/* Returns with success */
_Thread_Enable_dispatch();
10b7d3: e8 48 2c 00 00 call 10e420 <_Thread_Enable_dispatch>
return 0;
10b7d8: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10b7da: 8d 65 f4 lea -0xc(%ebp),%esp
10b7dd: 5b pop %ebx
10b7de: 5e pop %esi
10b7df: 5f pop %edi
10b7e0: c9 leave
10b7e1: c3 ret
10b7e2: 66 90 xchg %ax,%ax
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
_Thread_Enable_dispatch();
10b7e4: e8 37 2c 00 00 call 10e420 <_Thread_Enable_dispatch>
return 0;
10b7e9: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
10b7eb: 8d 65 f4 lea -0xc(%ebp),%esp
10b7ee: 5b pop %ebx
10b7ef: 5e pop %esi
10b7f0: 5f pop %edi
10b7f1: c9 leave
10b7f2: c3 ret
10b7f3: 90 nop
10b7f4: 8d 42 54 lea 0x54(%edx),%eax
10b7f7: e9 1a ff ff ff jmp 10b716 <timer_settime+0xf6>
10b7fc: 8d 42 54 lea 0x54(%edx),%eax
10b7ff: eb c2 jmp 10b7c3 <timer_settime+0x1a3>
0010b410 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
10b410: 55 push %ebp
10b411: 89 e5 mov %esp,%ebp
10b413: 56 push %esi
10b414: 53 push %ebx
10b415: 83 ec 10 sub $0x10,%esp
10b418: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
10b41b: 8b 0d 5c a6 12 00 mov 0x12a65c,%ecx
10b421: 85 c9 test %ecx,%ecx
10b423: 0f 84 8f 00 00 00 je 10b4b8 <ualarm+0xa8>
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
10b429: 83 ec 0c sub $0xc,%esp
10b42c: 68 40 a6 12 00 push $0x12a640
10b431: e8 9a 3a 00 00 call 10eed0 <_Watchdog_Remove>
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
10b436: 83 e8 02 sub $0x2,%eax
10b439: 83 c4 10 add $0x10,%esp
10b43c: 83 f8 01 cmp $0x1,%eax
10b43f: 0f 86 a3 00 00 00 jbe 10b4e8 <ualarm+0xd8> <== ALWAYS TAKEN
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
10b445: 31 f6 xor %esi,%esi
/*
* If useconds is non-zero, then the caller wants to schedule
* the alarm repeatedly at that interval. If the interval is
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
10b447: 85 db test %ebx,%ebx
10b449: 74 62 je 10b4ad <ualarm+0x9d>
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
10b44b: ba 83 de 1b 43 mov $0x431bde83,%edx
10b450: 89 d8 mov %ebx,%eax
10b452: f7 e2 mul %edx
10b454: c1 ea 12 shr $0x12,%edx
10b457: 89 55 f0 mov %edx,-0x10(%ebp)
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
10b45a: 8d 04 92 lea (%edx,%edx,4),%eax
10b45d: 8d 04 80 lea (%eax,%eax,4),%eax
10b460: 8d 04 80 lea (%eax,%eax,4),%eax
10b463: 8d 04 80 lea (%eax,%eax,4),%eax
10b466: 8d 04 80 lea (%eax,%eax,4),%eax
10b469: 8d 04 80 lea (%eax,%eax,4),%eax
10b46c: c1 e0 06 shl $0x6,%eax
10b46f: 29 c3 sub %eax,%ebx
10b471: 8d 04 9b lea (%ebx,%ebx,4),%eax
10b474: 8d 04 80 lea (%eax,%eax,4),%eax
10b477: 8d 04 80 lea (%eax,%eax,4),%eax
10b47a: c1 e0 03 shl $0x3,%eax
10b47d: 89 45 f4 mov %eax,-0xc(%ebp)
ticks = _Timespec_To_ticks( &tp );
10b480: 83 ec 0c sub $0xc,%esp
10b483: 8d 5d f0 lea -0x10(%ebp),%ebx
10b486: 53 push %ebx
10b487: e8 98 35 00 00 call 10ea24 <_Timespec_To_ticks>
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
10b48c: 89 1c 24 mov %ebx,(%esp)
10b48f: e8 90 35 00 00 call 10ea24 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b494: a3 4c a6 12 00 mov %eax,0x12a64c
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b499: 58 pop %eax
10b49a: 5a pop %edx
10b49b: 68 40 a6 12 00 push $0x12a640
10b4a0: 68 60 9d 12 00 push $0x129d60
10b4a5: e8 e6 38 00 00 call 10ed90 <_Watchdog_Insert>
10b4aa: 83 c4 10 add $0x10,%esp
}
return remaining;
}
10b4ad: 89 f0 mov %esi,%eax
10b4af: 8d 65 f8 lea -0x8(%ebp),%esp
10b4b2: 5b pop %ebx
10b4b3: 5e pop %esi
10b4b4: c9 leave
10b4b5: c3 ret
10b4b6: 66 90 xchg %ax,%ax
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10b4b8: c7 05 48 a6 12 00 00 movl $0x0,0x12a648
10b4bf: 00 00 00
the_watchdog->routine = routine;
10b4c2: c7 05 5c a6 12 00 d4 movl $0x10b3d4,0x12a65c
10b4c9: b3 10 00
the_watchdog->id = id;
10b4cc: c7 05 60 a6 12 00 00 movl $0x0,0x12a660
10b4d3: 00 00 00
the_watchdog->user_data = user_data;
10b4d6: c7 05 64 a6 12 00 00 movl $0x0,0x12a664
10b4dd: 00 00 00
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
10b4e0: 31 f6 xor %esi,%esi
10b4e2: e9 60 ff ff ff jmp 10b447 <ualarm+0x37>
10b4e7: 90 nop
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
10b4e8: a1 54 a6 12 00 mov 0x12a654,%eax
10b4ed: 03 05 4c a6 12 00 add 0x12a64c,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
10b4f3: 83 ec 08 sub $0x8,%esp
10b4f6: 8d 55 f0 lea -0x10(%ebp),%edx
10b4f9: 52 push %edx
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
10b4fa: 2b 05 58 a6 12 00 sub 0x12a658,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
10b500: 50 push %eax
10b501: e8 96 34 00 00 call 10e99c <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
10b506: 8b 45 f0 mov -0x10(%ebp),%eax
10b509: 8d 04 80 lea (%eax,%eax,4),%eax
10b50c: 8d 04 80 lea (%eax,%eax,4),%eax
10b50f: 8d 04 80 lea (%eax,%eax,4),%eax
10b512: 8d 04 80 lea (%eax,%eax,4),%eax
10b515: 8d 04 80 lea (%eax,%eax,4),%eax
10b518: 8d 0c 80 lea (%eax,%eax,4),%ecx
10b51b: c1 e1 06 shl $0x6,%ecx
remaining += tp.tv_nsec / 1000;
10b51e: 8b 75 f4 mov -0xc(%ebp),%esi
10b521: b8 d3 4d 62 10 mov $0x10624dd3,%eax
10b526: f7 ee imul %esi
10b528: 89 d0 mov %edx,%eax
10b52a: c1 f8 06 sar $0x6,%eax
10b52d: c1 fe 1f sar $0x1f,%esi
10b530: 29 f0 sub %esi,%eax
10b532: 8d 34 08 lea (%eax,%ecx,1),%esi
10b535: 83 c4 10 add $0x10,%esp
10b538: e9 0a ff ff ff jmp 10b447 <ualarm+0x37>
0010bb84 <unlink>:
#include <rtems/seterr.h>
int unlink(
const char *path
)
{
10bb84: 55 push %ebp
10bb85: 89 e5 mov %esp,%ebp
10bb87: 57 push %edi
10bb88: 56 push %esi
10bb89: 53 push %ebx
10bb8a: 83 ec 58 sub $0x58,%esp
10bb8d: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
10bb90: 53 push %ebx
10bb91: e8 3e d3 ff ff call 108ed4 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
10bb96: 83 c4 10 add $0x10,%esp
10bb99: 85 c0 test %eax,%eax
10bb9b: 0f 85 d3 00 00 00 jne 10bc74 <unlink+0xf0>
rtems_filesystem_get_start_loc( path, &i, &parentloc );
10bba1: 50 push %eax
10bba2: 8d 45 d0 lea -0x30(%ebp),%eax
10bba5: 89 45 b4 mov %eax,-0x4c(%ebp)
10bba8: 50 push %eax
10bba9: 8d 45 e4 lea -0x1c(%ebp),%eax
10bbac: 50 push %eax
10bbad: 53 push %ebx
10bbae: e8 b9 e2 ff ff call 109e6c <rtems_filesystem_get_start_loc>
10bbb3: 83 c4 10 add $0x10,%esp
10bbb6: 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;
10bbb8: c6 45 b3 00 movb $0x0,-0x4d(%ebp)
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
10bbbc: 8d 7d bc lea -0x44(%ebp),%edi
10bbbf: b9 05 00 00 00 mov $0x5,%ecx
10bbc4: 8b 75 b4 mov -0x4c(%ebp),%esi
10bbc7: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
name = path + parentpathlen;
10bbc9: 01 d3 add %edx,%ebx
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
10bbcb: be ff ff ff ff mov $0xffffffff,%esi
10bbd0: 89 f1 mov %esi,%ecx
10bbd2: 89 df mov %ebx,%edi
10bbd4: 31 c0 xor %eax,%eax
10bbd6: f2 ae repnz scas %es:(%edi),%al
10bbd8: f7 d1 not %ecx
10bbda: 49 dec %ecx
10bbdb: 83 ec 08 sub $0x8,%esp
10bbde: 51 push %ecx
10bbdf: 53 push %ebx
10bbe0: e8 33 d3 ff ff call 108f18 <rtems_filesystem_prefix_separators>
10bbe5: 01 c3 add %eax,%ebx
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
10bbe7: 89 f1 mov %esi,%ecx
10bbe9: 89 df mov %ebx,%edi
10bbeb: 31 c0 xor %eax,%eax
10bbed: f2 ae repnz scas %es:(%edi),%al
10bbef: f7 d1 not %ecx
10bbf1: 49 dec %ecx
10bbf2: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10bbf9: 8d 75 bc lea -0x44(%ebp),%esi
10bbfc: 56 push %esi
10bbfd: 6a 00 push $0x0
10bbff: 51 push %ecx
10bc00: 53 push %ebx
10bc01: e8 22 d2 ff ff call 108e28 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
10bc06: 83 c4 20 add $0x20,%esp
10bc09: 85 c0 test %eax,%eax
10bc0b: 75 53 jne 10bc60 <unlink+0xdc>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
10bc0d: 83 ec 0c sub $0xc,%esp
10bc10: 56 push %esi
10bc11: 8b 45 c8 mov -0x38(%ebp),%eax
10bc14: ff 50 10 call *0x10(%eax)
10bc17: 83 c4 10 add $0x10,%esp
10bc1a: 48 dec %eax
10bc1b: 0f 84 83 00 00 00 je 10bca4 <unlink+0x120>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
rtems_set_errno_and_return_minus_one( EISDIR );
}
result = (*loc.ops->unlink_h)( &parentloc, &loc );
10bc21: 83 ec 08 sub $0x8,%esp
10bc24: 56 push %esi
10bc25: ff 75 b4 pushl -0x4c(%ebp)
10bc28: 8b 45 c8 mov -0x38(%ebp),%eax
10bc2b: ff 50 0c call *0xc(%eax)
rtems_filesystem_freenode( &loc );
10bc2e: 89 34 24 mov %esi,(%esp)
10bc31: 89 45 ac mov %eax,-0x54(%ebp)
10bc34: e8 2f d3 ff ff call 108f68 <rtems_filesystem_freenode>
if ( free_parentloc )
10bc39: 83 c4 10 add $0x10,%esp
10bc3c: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp)
10bc40: 8b 45 ac mov -0x54(%ebp),%eax
10bc43: 74 11 je 10bc56 <unlink+0xd2>
rtems_filesystem_freenode( &parentloc );
10bc45: 83 ec 0c sub $0xc,%esp
10bc48: ff 75 b4 pushl -0x4c(%ebp)
10bc4b: e8 18 d3 ff ff call 108f68 <rtems_filesystem_freenode>
10bc50: 83 c4 10 add $0x10,%esp
10bc53: 8b 45 ac mov -0x54(%ebp),%eax
return result;
}
10bc56: 8d 65 f4 lea -0xc(%ebp),%esp
10bc59: 5b pop %ebx
10bc5a: 5e pop %esi
10bc5b: 5f pop %edi
10bc5c: c9 leave
10bc5d: c3 ret
10bc5e: 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 )
10bc60: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp)
10bc64: 75 70 jne 10bcd6 <unlink+0x152> <== ALWAYS TAKEN
rtems_filesystem_freenode( &parentloc );
return -1;
10bc66: b8 ff ff ff ff mov $0xffffffff,%eax
rtems_filesystem_freenode( &loc );
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return result;
}
10bc6b: 8d 65 f4 lea -0xc(%ebp),%esp
10bc6e: 5b pop %ebx <== NOT EXECUTED
10bc6f: 5e pop %esi <== NOT EXECUTED
10bc70: 5f pop %edi <== NOT EXECUTED
10bc71: c9 leave <== NOT EXECUTED
10bc72: c3 ret <== NOT EXECUTED
10bc73: 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,
10bc74: 89 c2 mov %eax,%edx
10bc76: 83 ec 0c sub $0xc,%esp
10bc79: 6a 00 push $0x0
10bc7b: 8d 45 d0 lea -0x30(%ebp),%eax
10bc7e: 89 45 b4 mov %eax,-0x4c(%ebp)
10bc81: 50 push %eax
10bc82: 6a 02 push $0x2
10bc84: 52 push %edx
10bc85: 53 push %ebx
10bc86: 89 55 ac mov %edx,-0x54(%ebp)
10bc89: e8 02 d2 ff ff call 108e90 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
10bc8e: 83 c4 20 add $0x20,%esp
10bc91: 85 c0 test %eax,%eax
10bc93: 8b 55 ac mov -0x54(%ebp),%edx
10bc96: 75 ce jne 10bc66 <unlink+0xe2> <== NEVER TAKEN
return -1;
free_parentloc = true;
10bc98: c6 45 b3 01 movb $0x1,-0x4d(%ebp)
10bc9c: e9 1b ff ff ff jmp 10bbbc <unlink+0x38>
10bca1: 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 );
10bca4: 83 ec 0c sub $0xc,%esp
10bca7: 56 push %esi
10bca8: e8 bb d2 ff ff call 108f68 <rtems_filesystem_freenode>
if ( free_parentloc )
10bcad: 83 c4 10 add $0x10,%esp
10bcb0: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp)
10bcb4: 74 0e je 10bcc4 <unlink+0x140>
rtems_filesystem_freenode( &parentloc );
10bcb6: 83 ec 0c sub $0xc,%esp
10bcb9: ff 75 b4 pushl -0x4c(%ebp)
10bcbc: e8 a7 d2 ff ff call 108f68 <rtems_filesystem_freenode>
10bcc1: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( EISDIR );
10bcc4: e8 6b b3 00 00 call 117034 <__errno>
10bcc9: c7 00 15 00 00 00 movl $0x15,(%eax)
10bccf: b8 ff ff ff ff mov $0xffffffff,%eax
10bcd4: eb 80 jmp 10bc56 <unlink+0xd2>
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
10bcd6: 83 ec 0c sub $0xc,%esp
10bcd9: ff 75 b4 pushl -0x4c(%ebp)
10bcdc: e8 87 d2 ff ff call 108f68 <rtems_filesystem_freenode>
10bce1: 83 c4 10 add $0x10,%esp
return -1;
10bce4: b8 ff ff ff ff mov $0xffffffff,%eax
10bce9: e9 68 ff ff ff jmp 10bc56 <unlink+0xd2>
0010bd64 <unmount>:
*/
int unmount(
const char *path
)
{
10bd64: 55 push %ebp
10bd65: 89 e5 mov %esp,%ebp
10bd67: 57 push %edi
10bd68: 56 push %esi
10bd69: 53 push %ebx
10bd6a: 83 ec 38 sub $0x38,%esp
10bd6d: 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 ) )
10bd70: 31 c0 xor %eax,%eax
10bd72: b9 ff ff ff ff mov $0xffffffff,%ecx
10bd77: 89 d7 mov %edx,%edi
10bd79: f2 ae repnz scas %es:(%edi),%al
10bd7b: f7 d1 not %ecx
10bd7d: 49 dec %ecx
10bd7e: 6a 01 push $0x1
10bd80: 8d 75 d4 lea -0x2c(%ebp),%esi
10bd83: 56 push %esi
10bd84: 6a 00 push $0x0
10bd86: 51 push %ecx
10bd87: 52 push %edx
10bd88: e8 77 cf ff ff call 108d04 <rtems_filesystem_evaluate_path>
10bd8d: 83 c4 20 add $0x20,%esp
10bd90: 85 c0 test %eax,%eax
10bd92: 75 68 jne 10bdfc <unmount+0x98>
return -1;
mt_entry = loc.mt_entry;
10bd94: 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 ){
10bd97: 8b 45 d4 mov -0x2c(%ebp),%eax
10bd9a: 39 43 1c cmp %eax,0x1c(%ebx)
10bd9d: 0f 85 c5 00 00 00 jne 10be68 <unmount+0x104>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
10bda3: 83 ec 0c sub $0xc,%esp
10bda6: 56 push %esi
10bda7: e8 30 d0 ff ff call 108ddc <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 )
10bdac: 83 c4 10 add $0x10,%esp
10bdaf: a1 50 85 12 00 mov 0x128550,%eax
10bdb4: 39 58 14 cmp %ebx,0x14(%eax)
10bdb7: 0f 84 cf 00 00 00 je 10be8c <unmount+0x128>
/*
* Verify there are no file systems below the path specified
*/
if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,
10bdbd: 83 ec 08 sub $0x8,%esp
10bdc0: ff 73 2c pushl 0x2c(%ebx)
10bdc3: 68 50 bd 10 00 push $0x10bd50
10bdc8: e8 ab d7 ff ff call 109578 <rtems_filesystem_mount_iterate>
10bdcd: 83 c4 10 add $0x10,%esp
10bdd0: 84 c0 test %al,%al
10bdd2: 0f 85 b4 00 00 00 jne 10be8c <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 )
10bdd8: 83 ec 0c sub $0xc,%esp
10bddb: 53 push %ebx
10bddc: e8 2b d3 ff ff call 10910c <rtems_libio_is_open_files_in_fs>
10bde1: 83 c4 10 add $0x10,%esp
10bde4: 48 dec %eax
10bde5: 0f 84 a1 00 00 00 je 10be8c <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 )
10bdeb: 83 ec 0c sub $0xc,%esp
10bdee: 8b 43 14 mov 0x14(%ebx),%eax
10bdf1: 53 push %ebx
10bdf2: ff 50 28 call *0x28(%eax)
10bdf5: 83 c4 10 add $0x10,%esp
10bdf8: 85 c0 test %eax,%eax
10bdfa: 74 10 je 10be0c <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;
10bdfc: b8 ff ff ff ff mov $0xffffffff,%eax
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
10be01: 8d 65 f4 lea -0xc(%ebp),%esp
10be04: 5b pop %ebx
10be05: 5e pop %esi
10be06: 5f pop %edi
10be07: c9 leave
10be08: c3 ret
10be09: 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){
10be0c: 83 ec 0c sub $0xc,%esp
10be0f: 8b 43 28 mov 0x28(%ebx),%eax
10be12: 53 push %ebx
10be13: ff 50 2c call *0x2c(%eax)
10be16: 83 c4 10 add $0x10,%esp
10be19: 85 c0 test %eax,%eax
10be1b: 0f 85 83 00 00 00 jne 10bea4 <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 );
10be21: 52 push %edx
10be22: 6a 00 push $0x0
10be24: 6a 00 push $0x0
10be26: ff 35 88 a8 12 00 pushl 0x12a888
10be2c: e8 77 0b 00 00 call 10c9a8 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10be31: 89 1c 24 mov %ebx,(%esp)
10be34: e8 73 14 00 00 call 10d2ac <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10be39: 58 pop %eax
10be3a: ff 35 88 a8 12 00 pushl 0x12a888
10be40: e8 5f 0c 00 00 call 10caa4 <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;
10be45: 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 );
10be48: 89 04 24 mov %eax,(%esp)
10be4b: e8 8c cf ff ff call 108ddc <rtems_filesystem_freenode>
free( mt_entry );
10be50: 89 1c 24 mov %ebx,(%esp)
10be53: e8 98 cf ff ff call 108df0 <free>
return 0;
10be58: 83 c4 10 add $0x10,%esp
10be5b: 31 c0 xor %eax,%eax
}
10be5d: 8d 65 f4 lea -0xc(%ebp),%esp
10be60: 5b pop %ebx
10be61: 5e pop %esi
10be62: 5f pop %edi
10be63: c9 leave
10be64: c3 ret
10be65: 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 );
10be68: 83 ec 0c sub $0xc,%esp
10be6b: 56 push %esi
10be6c: e8 6b cf ff ff call 108ddc <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EACCES );
10be71: e8 4a 84 00 00 call 1142c0 <__errno>
10be76: c7 00 0d 00 00 00 movl $0xd,(%eax)
10be7c: 83 c4 10 add $0x10,%esp
10be7f: b8 ff ff ff ff mov $0xffffffff,%eax
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
10be84: 8d 65 f4 lea -0xc(%ebp),%esp
10be87: 5b pop %ebx
10be88: 5e pop %esi
10be89: 5f pop %edi
10be8a: c9 leave
10be8b: 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 );
10be8c: e8 2f 84 00 00 call 1142c0 <__errno>
10be91: c7 00 10 00 00 00 movl $0x10,(%eax)
10be97: b8 ff ff ff ff mov $0xffffffff,%eax
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
10be9c: 8d 65 f4 lea -0xc(%ebp),%esp
10be9f: 5b pop %ebx
10bea0: 5e pop %esi
10bea1: 5f pop %edi
10bea2: c9 leave
10bea3: 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 )
10bea4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10bea7: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED
10beaa: 53 push %ebx <== NOT EXECUTED
10beab: ff 50 20 call *0x20(%eax) <== NOT EXECUTED
10beae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10beb1: 85 c0 test %eax,%eax <== NOT EXECUTED
10beb3: 0f 84 43 ff ff ff je 10bdfc <unmount+0x98> <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
10beb9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10bebc: 6a 00 push $0x0 <== NOT EXECUTED
10bebe: e8 e1 10 00 00 call 10cfa4 <rtems_fatal_error_occurred><== NOT EXECUTED
0010bf0c <utime>:
int utime(
const char *path,
const struct utimbuf *times
)
{
10bf0c: 55 push %ebp
10bf0d: 89 e5 mov %esp,%ebp
10bf0f: 57 push %edi
10bf10: 56 push %esi
10bf11: 53 push %ebx
10bf12: 83 ec 48 sub $0x48,%esp
10bf15: 8b 55 08 mov 0x8(%ebp),%edx
10bf18: 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 ) )
10bf1b: 31 c0 xor %eax,%eax
10bf1d: b9 ff ff ff ff mov $0xffffffff,%ecx
10bf22: 89 d7 mov %edx,%edi
10bf24: f2 ae repnz scas %es:(%edi),%al
10bf26: f7 d1 not %ecx
10bf28: 49 dec %ecx
10bf29: 6a 01 push $0x1
10bf2b: 8d 75 d4 lea -0x2c(%ebp),%esi
10bf2e: 56 push %esi
10bf2f: 6a 00 push $0x0
10bf31: 51 push %ecx
10bf32: 52 push %edx
10bf33: e8 d0 ca ff ff call 108a08 <rtems_filesystem_evaluate_path>
10bf38: 83 c4 20 add $0x20,%esp
10bf3b: 85 c0 test %eax,%eax
10bf3d: 75 2d jne 10bf6c <utime+0x60>
return -1;
if ( times == NULL ) {
10bf3f: 85 db test %ebx,%ebx
10bf41: 74 39 je 10bf7c <utime+0x70>
10bf43: 8b 53 04 mov 0x4(%ebx),%edx
10bf46: 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 );
10bf48: 51 push %ecx
10bf49: 52 push %edx
10bf4a: 50 push %eax
10bf4b: 56 push %esi
10bf4c: 8b 45 e0 mov -0x20(%ebp),%eax
10bf4f: ff 50 30 call *0x30(%eax)
rtems_filesystem_freenode( &temp_loc );
10bf52: 89 34 24 mov %esi,(%esp)
10bf55: 89 45 c4 mov %eax,-0x3c(%ebp)
10bf58: e8 9b ce ff ff call 108df8 <rtems_filesystem_freenode>
return result;
10bf5d: 83 c4 10 add $0x10,%esp
10bf60: 8b 45 c4 mov -0x3c(%ebp),%eax
}
10bf63: 8d 65 f4 lea -0xc(%ebp),%esp
10bf66: 5b pop %ebx
10bf67: 5e pop %esi
10bf68: 5f pop %edi
10bf69: c9 leave
10bf6a: c3 ret
10bf6b: 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;
10bf6c: 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;
}
10bf71: 8d 65 f4 lea -0xc(%ebp),%esp
10bf74: 5b pop %ebx
10bf75: 5e pop %esi
10bf76: 5f pop %edi
10bf77: c9 leave
10bf78: c3 ret
10bf79: 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 );
10bf7c: 83 ec 0c sub $0xc,%esp
10bf7f: 6a 00 push $0x0
10bf81: e8 c2 cc 00 00 call 118c48 <time>
10bf86: 83 c4 10 add $0x10,%esp
10bf89: 89 c2 mov %eax,%edx
10bf8b: eb bb jmp 10bf48 <utime+0x3c>
0010bf90 <utimes>:
int utimes(
const char *path,
const struct timeval times[2]
)
{
10bf90: 55 push %ebp
10bf91: 89 e5 mov %esp,%ebp
10bf93: 83 ec 18 sub $0x18,%esp
10bf96: 8b 55 08 mov 0x8(%ebp),%edx
10bf99: 8b 45 0c mov 0xc(%ebp),%eax
struct utimbuf timeinsecs;
if ( times == NULL )
10bf9c: 85 c0 test %eax,%eax
10bf9e: 74 20 je 10bfc0 <utimes+0x30>
return utime( path, NULL );
timeinsecs.actime = (time_t) times[0].tv_sec;
10bfa0: 8b 08 mov (%eax),%ecx
10bfa2: 89 4d f0 mov %ecx,-0x10(%ebp)
timeinsecs.modtime = (time_t) times[1].tv_sec;
10bfa5: 8b 40 08 mov 0x8(%eax),%eax
10bfa8: 89 45 f4 mov %eax,-0xc(%ebp)
return utime( path, &timeinsecs );
10bfab: 83 ec 08 sub $0x8,%esp
10bfae: 8d 45 f0 lea -0x10(%ebp),%eax
10bfb1: 50 push %eax
10bfb2: 52 push %edx
10bfb3: e8 54 ff ff ff call 10bf0c <utime>
10bfb8: 83 c4 10 add $0x10,%esp
}
10bfbb: c9 leave
10bfbc: c3 ret
10bfbd: 8d 76 00 lea 0x0(%esi),%esi
)
{
struct utimbuf timeinsecs;
if ( times == NULL )
return utime( path, NULL );
10bfc0: 83 ec 08 sub $0x8,%esp
10bfc3: 6a 00 push $0x0
10bfc5: 52 push %edx
10bfc6: e8 41 ff ff ff call 10bf0c <utime>
10bfcb: 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 );
}
10bfce: c9 leave
10bfcf: c3 ret
0010abcc <vprintk>:
*/
void vprintk(
const char *fmt,
va_list ap
)
{
10abcc: 55 push %ebp
10abcd: 89 e5 mov %esp,%ebp
10abcf: 57 push %edi
10abd0: 56 push %esi
10abd1: 53 push %ebx
10abd2: 83 ec 4c sub $0x4c,%esp
10abd5: 8b 75 08 mov 0x8(%ebp),%esi
for (; *fmt != '\0'; fmt++) {
10abd8: 8a 06 mov (%esi),%al
10abda: 84 c0 test %al,%al
10abdc: 75 21 jne 10abff <vprintk+0x33>
10abde: e9 c4 01 00 00 jmp 10ada7 <vprintk+0x1db>
10abe3: 90 nop
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
BSP_output_char(*fmt);
10abe4: 83 ec 0c sub $0xc,%esp
10abe7: 0f be c0 movsbl %al,%eax
10abea: 50 push %eax
10abeb: ff 15 e8 3a 12 00 call *0x123ae8
continue;
10abf1: 83 c4 10 add $0x10,%esp
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
10abf4: 46 inc %esi
10abf5: 8a 06 mov (%esi),%al
10abf7: 84 c0 test %al,%al
10abf9: 0f 84 a8 01 00 00 je 10ada7 <vprintk+0x1db>
bool minus = false;
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
10abff: 3c 25 cmp $0x25,%al
10ac01: 75 e1 jne 10abe4 <vprintk+0x18>
BSP_output_char(*fmt);
continue;
}
fmt++;
10ac03: 46 inc %esi
if (*fmt == '0' ) {
10ac04: 8a 06 mov (%esi),%al
10ac06: 3c 30 cmp $0x30,%al
10ac08: 0f 84 fe 01 00 00 je 10ae0c <vprintk+0x240>
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
bool sign = false;
char lead = ' ';
10ac0e: b1 20 mov $0x20,%cl
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
10ac10: 3c 2d cmp $0x2d,%al
10ac12: 0f 84 d8 01 00 00 je 10adf0 <vprintk+0x224>
{
for (; *fmt != '\0'; fmt++) {
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
10ac18: 31 ff xor %edi,%edi
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
10ac1a: 8d 50 d0 lea -0x30(%eax),%edx
10ac1d: 80 fa 09 cmp $0x9,%dl
10ac20: 0f 87 de 01 00 00 ja 10ae04 <vprintk+0x238>
10ac26: 31 db xor %ebx,%ebx
width *= 10;
10ac28: 8d 14 9b lea (%ebx,%ebx,4),%edx
width += ((unsigned) *fmt - '0');
10ac2b: 0f be c0 movsbl %al,%eax
10ac2e: 8d 5c 50 d0 lea -0x30(%eax,%edx,2),%ebx
fmt++;
10ac32: 46 inc %esi
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
10ac33: 8a 06 mov (%esi),%al
10ac35: 8d 50 d0 lea -0x30(%eax),%edx
10ac38: 80 fa 09 cmp $0x9,%dl
10ac3b: 76 eb jbe 10ac28 <vprintk+0x5c>
width *= 10;
width += ((unsigned) *fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
10ac3d: 3c 6c cmp $0x6c,%al
10ac3f: 0f 84 7b 01 00 00 je 10adc0 <vprintk+0x1f4>
10ac45: 88 c2 mov %al,%dl
lflag = true;
c = *++fmt;
}
if ( c == 'c' ) {
10ac47: 80 fa 63 cmp $0x63,%dl
10ac4a: 0f 84 7c 01 00 00 je 10adcc <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' ) {
10ac50: 80 fa 73 cmp $0x73,%dl
10ac53: 0f 84 bf 01 00 00 je 10ae18 <vprintk+0x24c>
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
10ac59: 80 fa 6f cmp $0x6f,%dl
10ac5c: 0f 84 4e 01 00 00 je 10adb0 <vprintk+0x1e4>
10ac62: 80 fa 4f cmp $0x4f,%dl
10ac65: 0f 84 45 01 00 00 je 10adb0 <vprintk+0x1e4>
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
10ac6b: 80 fa 69 cmp $0x69,%dl
10ac6e: 74 54 je 10acc4 <vprintk+0xf8>
10ac70: 80 fa 49 cmp $0x49,%dl
10ac73: 74 4f je 10acc4 <vprintk+0xf8>
10ac75: 80 fa 64 cmp $0x64,%dl
10ac78: 74 4a je 10acc4 <vprintk+0xf8>
c == 'd' || c == 'D' ) {
10ac7a: 80 fa 44 cmp $0x44,%dl
10ac7d: 74 45 je 10acc4 <vprintk+0xf8>
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
10ac7f: 80 fa 75 cmp $0x75,%dl
10ac82: 0f 84 85 02 00 00 je 10af0d <vprintk+0x341>
10ac88: 80 fa 55 cmp $0x55,%dl
10ac8b: 0f 84 7c 02 00 00 je 10af0d <vprintk+0x341> <== NEVER TAKEN
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
10ac91: 80 fa 78 cmp $0x78,%dl
10ac94: 0f 84 bd 02 00 00 je 10af57 <vprintk+0x38b>
10ac9a: 80 fa 58 cmp $0x58,%dl
10ac9d: 0f 84 b4 02 00 00 je 10af57 <vprintk+0x38b> <== NEVER TAKEN
base = 16; sign = false;
} else if ( c == 'p' ) {
10aca3: 80 fa 70 cmp $0x70,%dl
10aca6: 0f 84 d3 02 00 00 je 10af7f <vprintk+0x3b3>
base = 16; sign = false; lflag = true;
} else {
BSP_output_char(c);
10acac: 83 ec 0c sub $0xc,%esp
10acaf: 0f be d2 movsbl %dl,%edx
10acb2: 52 push %edx
10acb3: ff 15 e8 3a 12 00 call *0x123ae8
continue;
10acb9: 83 c4 10 add $0x10,%esp
10acbc: e9 33 ff ff ff jmp 10abf4 <vprintk+0x28>
10acc1: 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;
10acc4: b2 01 mov $0x1,%dl
10acc6: c7 45 c0 0a 00 00 00 movl $0xa,-0x40(%ebp)
} else {
BSP_output_char(c);
continue;
}
printNum(
10accd: 0f be c9 movsbl %cl,%ecx
10acd0: 89 4d b4 mov %ecx,-0x4c(%ebp)
10acd3: 8b 45 0c mov 0xc(%ebp),%eax
10acd6: 8b 38 mov (%eax),%edi
lflag ? va_arg(ap, long) : (long) va_arg(ap, int),
10acd8: 83 c0 04 add $0x4,%eax
10acdb: 89 45 0c mov %eax,0xc(%ebp)
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
10acde: 84 d2 test %dl,%dl
10ace0: 74 08 je 10acea <vprintk+0x11e>
10ace2: 85 ff test %edi,%edi
10ace4: 0f 88 31 02 00 00 js 10af1b <vprintk+0x34f> <== NEVER TAKEN
BSP_output_char('-');
unsigned_num = (unsigned long) -num;
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
10acea: 89 7d b8 mov %edi,-0x48(%ebp)
}
count = 0;
while ((n = unsigned_num / base) > 0) {
10aced: 8b 45 b8 mov -0x48(%ebp),%eax
10acf0: 31 d2 xor %edx,%edx
10acf2: f7 75 c0 divl -0x40(%ebp)
10acf5: 89 c1 mov %eax,%ecx
10acf7: 85 c0 test %eax,%eax
10acf9: 0f 84 47 02 00 00 je 10af46 <vprintk+0x37a>
10acff: 8a 55 c0 mov -0x40(%ebp),%dl
10ad02: 88 55 c4 mov %dl,-0x3c(%ebp)
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
10ad05: 31 ff xor %edi,%edi
10ad07: 89 5d b0 mov %ebx,-0x50(%ebp)
10ad0a: 8b 5d c0 mov -0x40(%ebp),%ebx
10ad0d: 8b 55 b8 mov -0x48(%ebp),%edx
10ad10: eb 06 jmp 10ad18 <vprintk+0x14c>
10ad12: 66 90 xchg %ax,%ax
while ((n = unsigned_num / base) > 0) {
10ad14: 89 ca mov %ecx,%edx
10ad16: 89 c1 mov %eax,%ecx
toPrint[count++] = (char) (unsigned_num - (n * base));
10ad18: 8a 45 c4 mov -0x3c(%ebp),%al
10ad1b: f6 e1 mul %cl
10ad1d: 28 c2 sub %al,%dl
10ad1f: 88 54 3d d4 mov %dl,-0x2c(%ebp,%edi,1)
10ad23: 47 inc %edi
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
10ad24: 89 c8 mov %ecx,%eax
10ad26: 31 d2 xor %edx,%edx
10ad28: f7 f3 div %ebx
10ad2a: 85 c0 test %eax,%eax
10ad2c: 75 e6 jne 10ad14 <vprintk+0x148>
10ad2e: 8b 5d b0 mov -0x50(%ebp),%ebx
10ad31: 8d 47 01 lea 0x1(%edi),%eax
10ad34: 89 45 c4 mov %eax,-0x3c(%ebp)
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
10ad37: 88 4c 3d d4 mov %cl,-0x2c(%ebp,%edi,1)
for (n=maxwidth ; n > count; n-- )
10ad3b: 3b 5d c4 cmp -0x3c(%ebp),%ebx
10ad3e: 76 21 jbe 10ad61 <vprintk+0x195>
10ad40: 8b 7d b4 mov -0x4c(%ebp),%edi
10ad43: 89 75 c0 mov %esi,-0x40(%ebp)
10ad46: 8b 75 c4 mov -0x3c(%ebp),%esi
10ad49: 8d 76 00 lea 0x0(%esi),%esi
BSP_output_char(lead);
10ad4c: 83 ec 0c sub $0xc,%esp
10ad4f: 57 push %edi
10ad50: ff 15 e8 3a 12 00 call *0x123ae8
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
10ad56: 4b dec %ebx
10ad57: 83 c4 10 add $0x10,%esp
10ad5a: 39 f3 cmp %esi,%ebx
10ad5c: 77 ee ja 10ad4c <vprintk+0x180>
10ad5e: 8b 75 c0 mov -0x40(%ebp),%esi
BSP_output_char(lead);
for (n = 0; n < count; n++) {
10ad61: 8b 45 c4 mov -0x3c(%ebp),%eax
10ad64: 85 c0 test %eax,%eax
10ad66: 0f 84 88 fe ff ff je 10abf4 <vprintk+0x28> <== NEVER TAKEN
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
10ad6c: 8b 55 c4 mov -0x3c(%ebp),%edx
10ad6f: 8d 7c 15 d3 lea -0x2d(%ebp,%edx,1),%edi
10ad73: 31 db xor %ebx,%ebx
10ad75: 89 75 c0 mov %esi,-0x40(%ebp)
10ad78: 89 d6 mov %edx,%esi
10ad7a: 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)])]);
10ad7c: 83 ec 0c sub $0xc,%esp
10ad7f: 0f be 07 movsbl (%edi),%eax
10ad82: 0f be 80 0a 14 12 00 movsbl 0x12140a(%eax),%eax
10ad89: 50 push %eax
10ad8a: ff 15 e8 3a 12 00 call *0x123ae8
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
10ad90: 43 inc %ebx
10ad91: 4f dec %edi
10ad92: 83 c4 10 add $0x10,%esp
10ad95: 39 f3 cmp %esi,%ebx
10ad97: 72 e3 jb 10ad7c <vprintk+0x1b0>
10ad99: 8b 75 c0 mov -0x40(%ebp),%esi
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
10ad9c: 46 inc %esi
10ad9d: 8a 06 mov (%esi),%al
10ad9f: 84 c0 test %al,%al
10ada1: 0f 85 58 fe ff ff jne 10abff <vprintk+0x33> <== ALWAYS TAKEN
sign,
width,
lead
);
}
}
10ada7: 8d 65 f4 lea -0xc(%ebp),%esp
10adaa: 5b pop %ebx
10adab: 5e pop %esi
10adac: 5f pop %edi
10adad: c9 leave
10adae: c3 ret
10adaf: 90 nop
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
10adb0: 31 d2 xor %edx,%edx
10adb2: c7 45 c0 08 00 00 00 movl $0x8,-0x40(%ebp)
10adb9: e9 0f ff ff ff jmp 10accd <vprintk+0x101>
10adbe: 66 90 xchg %ax,%ax
fmt++;
}
if ((c = *fmt) == 'l') {
lflag = true;
c = *++fmt;
10adc0: 46 inc %esi
10adc1: 8a 16 mov (%esi),%dl
}
if ( c == 'c' ) {
10adc3: 80 fa 63 cmp $0x63,%dl
10adc6: 0f 85 84 fe ff ff jne 10ac50 <vprintk+0x84> <== ALWAYS TAKEN
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
10adcc: 8b 5d 0c mov 0xc(%ebp),%ebx
10adcf: 83 c3 04 add $0x4,%ebx
BSP_output_char(chr);
10add2: 83 ec 0c sub $0xc,%esp
10add5: 8b 55 0c mov 0xc(%ebp),%edx
10add8: 0f be 02 movsbl (%edx),%eax
10addb: 50 push %eax
10addc: ff 15 e8 3a 12 00 call *0x123ae8
continue;
10ade2: 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);
10ade5: 89 5d 0c mov %ebx,0xc(%ebp)
BSP_output_char(chr);
continue;
10ade8: e9 07 fe ff ff jmp 10abf4 <vprintk+0x28>
10aded: 8d 76 00 lea 0x0(%esi),%esi
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = true;
fmt++;
10adf0: 46 inc %esi
10adf1: 8a 06 mov (%esi),%al
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = true;
10adf3: bf 01 00 00 00 mov $0x1,%edi
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
10adf8: 8d 50 d0 lea -0x30(%eax),%edx
10adfb: 80 fa 09 cmp $0x9,%dl
10adfe: 0f 86 22 fe ff ff jbe 10ac26 <vprintk+0x5a> <== ALWAYS TAKEN
10ae04: 31 db xor %ebx,%ebx
10ae06: e9 32 fe ff ff jmp 10ac3d <vprintk+0x71>
10ae0b: 90 nop
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
10ae0c: 46 inc %esi
10ae0d: 8a 06 mov (%esi),%al
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
10ae0f: b1 30 mov $0x30,%cl
10ae11: e9 fa fd ff ff jmp 10ac10 <vprintk+0x44>
10ae16: 66 90 xchg %ax,%ax
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
10ae18: 8b 45 0c mov 0xc(%ebp),%eax
10ae1b: 83 c0 04 add $0x4,%eax
10ae1e: 89 45 c0 mov %eax,-0x40(%ebp)
10ae21: 8b 55 0c mov 0xc(%ebp),%edx
10ae24: 8b 02 mov (%edx),%eax
if ( str == NULL ) {
10ae26: 85 c0 test %eax,%eax
10ae28: 0f 84 37 01 00 00 je 10af65 <vprintk+0x399>
str = "";
}
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
10ae2e: 80 38 00 cmpb $0x0,(%eax)
10ae31: 0f 84 3c 01 00 00 je 10af73 <vprintk+0x3a7>
10ae37: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
10ae3e: 31 d2 xor %edx,%edx
10ae40: 42 inc %edx
10ae41: 80 3c 10 00 cmpb $0x0,(%eax,%edx,1)
10ae45: 75 f9 jne 10ae40 <vprintk+0x274>
10ae47: 89 55 c4 mov %edx,-0x3c(%ebp)
;
/* leading spaces */
if ( !minus )
10ae4a: 89 fa mov %edi,%edx
10ae4c: 84 d2 test %dl,%dl
10ae4e: 75 32 jne 10ae82 <vprintk+0x2b6>
for ( i=len ; i<width ; i++ )
10ae50: 39 5d c4 cmp %ebx,-0x3c(%ebp)
10ae53: 73 2d jae 10ae82 <vprintk+0x2b6>
10ae55: 8b 4d c4 mov -0x3c(%ebp),%ecx
10ae58: 88 55 bc mov %dl,-0x44(%ebp)
10ae5b: 89 c7 mov %eax,%edi
10ae5d: 89 75 b8 mov %esi,-0x48(%ebp)
10ae60: 89 de mov %ebx,%esi
10ae62: 89 cb mov %ecx,%ebx
BSP_output_char(' ');
10ae64: 83 ec 0c sub $0xc,%esp
10ae67: 6a 20 push $0x20
10ae69: ff 15 e8 3a 12 00 call *0x123ae8
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
10ae6f: 43 inc %ebx
10ae70: 83 c4 10 add $0x10,%esp
10ae73: 39 f3 cmp %esi,%ebx
10ae75: 72 ed jb 10ae64 <vprintk+0x298>
10ae77: 89 f8 mov %edi,%eax
10ae79: 89 f3 mov %esi,%ebx
10ae7b: 0f b6 7d bc movzbl -0x44(%ebp),%edi
10ae7f: 8b 75 b8 mov -0x48(%ebp),%esi
BSP_output_char(' ');
/* no width option */
if (width == 0) {
10ae82: 85 db test %ebx,%ebx
10ae84: 75 0a jne 10ae90 <vprintk+0x2c4>
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
10ae86: 8b 55 c4 mov -0x3c(%ebp),%edx
10ae89: 85 d2 test %edx,%edx
10ae8b: 74 47 je 10aed4 <vprintk+0x308>
10ae8d: 8b 5d c4 mov -0x3c(%ebp),%ebx
10ae90: 8a 10 mov (%eax),%dl
10ae92: 84 d2 test %dl,%dl
10ae94: 74 3e je 10aed4 <vprintk+0x308> <== NEVER TAKEN
BSP_output_char(*str);
10ae96: 83 ec 0c sub $0xc,%esp
10ae99: 0f be d2 movsbl %dl,%edx
10ae9c: 52 push %edx
10ae9d: 89 45 ac mov %eax,-0x54(%ebp)
10aea0: ff 15 e8 3a 12 00 call *0x123ae8
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
10aea6: 8b 45 ac mov -0x54(%ebp),%eax
10aea9: 40 inc %eax
10aeaa: 83 c4 10 add $0x10,%esp
10aead: 89 75 bc mov %esi,-0x44(%ebp)
10aeb0: 89 de mov %ebx,%esi
10aeb2: 89 c3 mov %eax,%ebx
10aeb4: eb 13 jmp 10aec9 <vprintk+0x2fd>
10aeb6: 66 90 xchg %ax,%ax
BSP_output_char(*str);
10aeb8: 83 ec 0c sub $0xc,%esp
10aebb: 0f be d2 movsbl %dl,%edx
10aebe: 52 push %edx
10aebf: ff 15 e8 3a 12 00 call *0x123ae8
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
10aec5: 43 inc %ebx
10aec6: 83 c4 10 add $0x10,%esp
10aec9: 8a 13 mov (%ebx),%dl
10aecb: 84 d2 test %dl,%dl
10aecd: 75 e9 jne 10aeb8 <vprintk+0x2ec>
10aecf: 89 f3 mov %esi,%ebx
10aed1: 8b 75 bc mov -0x44(%ebp),%esi
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
10aed4: 89 f8 mov %edi,%eax
10aed6: 84 c0 test %al,%al
10aed8: 74 28 je 10af02 <vprintk+0x336>
for ( i=len ; i<width ; i++ )
10aeda: 39 5d c4 cmp %ebx,-0x3c(%ebp)
10aedd: 73 18 jae 10aef7 <vprintk+0x32b>
10aedf: 8b 7d c4 mov -0x3c(%ebp),%edi
10aee2: 66 90 xchg %ax,%ax
BSP_output_char(' ');
10aee4: 83 ec 0c sub $0xc,%esp
10aee7: 6a 20 push $0x20
10aee9: ff 15 e8 3a 12 00 call *0x123ae8
for ( i=0 ; i<width && *str ; str++ )
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
10aeef: 47 inc %edi
10aef0: 83 c4 10 add $0x10,%esp
10aef3: 39 df cmp %ebx,%edi
10aef5: 72 ed jb 10aee4 <vprintk+0x318>
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
10aef7: 8b 55 c0 mov -0x40(%ebp),%edx
10aefa: 89 55 0c mov %edx,0xc(%ebp)
10aefd: e9 f2 fc ff ff jmp 10abf4 <vprintk+0x28>
10af02: 8b 45 c0 mov -0x40(%ebp),%eax
10af05: 89 45 0c mov %eax,0xc(%ebp)
10af08: e9 e7 fc ff ff jmp 10abf4 <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;
10af0d: 31 d2 xor %edx,%edx
10af0f: c7 45 c0 0a 00 00 00 movl $0xa,-0x40(%ebp)
10af16: e9 b2 fd ff ff jmp 10accd <vprintk+0x101>
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
BSP_output_char('-');
10af1b: 83 ec 0c sub $0xc,%esp
10af1e: 6a 2d push $0x2d
10af20: ff 15 e8 3a 12 00 call *0x123ae8
unsigned_num = (unsigned long) -num;
10af26: f7 df neg %edi
10af28: 89 7d b8 mov %edi,-0x48(%ebp)
if (maxwidth) maxwidth--;
10af2b: 83 c4 10 add $0x10,%esp
10af2e: 83 fb 01 cmp $0x1,%ebx
10af31: 83 d3 ff adc $0xffffffff,%ebx
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
10af34: 8b 45 b8 mov -0x48(%ebp),%eax
10af37: 31 d2 xor %edx,%edx
10af39: f7 75 c0 divl -0x40(%ebp)
10af3c: 89 c1 mov %eax,%ecx
10af3e: 85 c0 test %eax,%eax
10af40: 0f 85 b9 fd ff ff jne 10acff <vprintk+0x133>
10af46: 8b 4d b8 mov -0x48(%ebp),%ecx
10af49: c7 45 c4 01 00 00 00 movl $0x1,-0x3c(%ebp)
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
10af50: 31 ff xor %edi,%edi
10af52: e9 e0 fd ff ff jmp 10ad37 <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;
10af57: 31 d2 xor %edx,%edx
10af59: c7 45 c0 10 00 00 00 movl $0x10,-0x40(%ebp)
10af60: e9 68 fd ff ff jmp 10accd <vprintk+0x101>
char *s, *str;
str = va_arg(ap, char *);
if ( str == NULL ) {
str = "";
10af65: b8 09 14 12 00 mov $0x121409,%eax
}
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
10af6a: 80 38 00 cmpb $0x0,(%eax)
10af6d: 0f 85 c4 fe ff ff jne 10ae37 <vprintk+0x26b> <== NEVER TAKEN
10af73: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
10af7a: e9 cb fe ff ff jmp 10ae4a <vprintk+0x27e>
} else {
BSP_output_char(c);
continue;
}
printNum(
10af7f: 0f be c9 movsbl %cl,%ecx
10af82: 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;
10af85: 31 d2 xor %edx,%edx
10af87: c7 45 c0 10 00 00 00 movl $0x10,-0x40(%ebp)
10af8e: e9 40 fd ff ff jmp 10acd3 <vprintk+0x107>
0011f418 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
11f418: 55 push %ebp
11f419: 89 e5 mov %esp,%ebp
11f41b: 53 push %ebx
11f41c: 83 ec 04 sub $0x4,%esp
11f41f: 8b 4d 08 mov 0x8(%ebp),%ecx
11f422: 8b 45 0c mov 0xc(%ebp),%eax
11f425: 8b 55 10 mov 0x10(%ebp),%edx
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
11f428: 3b 0d 6c 39 12 00 cmp 0x12396c,%ecx
11f42e: 73 50 jae 11f480 <write+0x68>
iop = rtems_libio_iop( fd );
11f430: c1 e1 03 shl $0x3,%ecx
11f433: 8d 1c cd 00 00 00 00 lea 0x0(,%ecx,8),%ebx
11f43a: 29 cb sub %ecx,%ebx
11f43c: 03 1d 20 7c 12 00 add 0x127c20,%ebx
rtems_libio_check_is_open( iop );
11f442: 8b 4b 14 mov 0x14(%ebx),%ecx
11f445: f6 c5 01 test $0x1,%ch
11f448: 74 36 je 11f480 <write+0x68>
rtems_libio_check_buffer( buffer );
11f44a: 85 c0 test %eax,%eax
11f44c: 74 46 je 11f494 <write+0x7c> <== NEVER TAKEN
rtems_libio_check_count( count );
11f44e: 85 d2 test %edx,%edx
11f450: 74 26 je 11f478 <write+0x60>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
11f452: 83 e1 04 and $0x4,%ecx
11f455: 74 3d je 11f494 <write+0x7c>
/*
* Now process the write() request.
*/
rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
11f457: 51 push %ecx
11f458: 8b 4b 20 mov 0x20(%ebx),%ecx
11f45b: 52 push %edx
11f45c: 50 push %eax
11f45d: 53 push %ebx
11f45e: ff 51 0c call *0xc(%ecx)
if ( rc > 0 )
11f461: 83 c4 10 add $0x10,%esp
11f464: 85 c0 test %eax,%eax
11f466: 7e 0b jle 11f473 <write+0x5b>
iop->offset += rc;
11f468: 89 c1 mov %eax,%ecx
11f46a: c1 f9 1f sar $0x1f,%ecx
11f46d: 01 43 0c add %eax,0xc(%ebx)
11f470: 11 4b 10 adc %ecx,0x10(%ebx)
return rc;
}
11f473: 8b 5d fc mov -0x4(%ebp),%ebx
11f476: c9 leave
11f477: 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 );
11f478: 31 c0 xor %eax,%eax
if ( rc > 0 )
iop->offset += rc;
return rc;
}
11f47a: 8b 5d fc mov -0x4(%ebp),%ebx
11f47d: c9 leave
11f47e: c3 ret
11f47f: 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 );
11f480: e8 eb 3d ff ff call 113270 <__errno>
11f485: c7 00 09 00 00 00 movl $0x9,(%eax)
11f48b: b8 ff ff ff ff mov $0xffffffff,%eax
11f490: eb e1 jmp 11f473 <write+0x5b>
11f492: 66 90 xchg %ax,%ax
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
11f494: e8 d7 3d ff ff call 113270 <__errno>
11f499: c7 00 16 00 00 00 movl $0x16,(%eax)
11f49f: b8 ff ff ff ff mov $0xffffffff,%eax
11f4a4: eb cd jmp 11f473 <write+0x5b>
0010bfbc <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
10bfbc: 55 push %ebp
10bfbd: 89 e5 mov %esp,%ebp
10bfbf: 57 push %edi
10bfc0: 56 push %esi
10bfc1: 53 push %ebx
10bfc2: 83 ec 3c sub $0x3c,%esp
10bfc5: 8b 45 08 mov 0x8(%ebp),%eax
10bfc8: 8b 5d 0c mov 0xc(%ebp),%ebx
10bfcb: 8b 7d 10 mov 0x10(%ebp),%edi
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
10bfce: 3b 05 ac 4f 12 00 cmp 0x124fac,%eax
10bfd4: 0f 83 ea 00 00 00 jae 10c0c4 <writev+0x108> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
10bfda: c1 e0 03 shl $0x3,%eax
10bfdd: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
10bfe4: 29 c2 sub %eax,%edx
10bfe6: 8b 0d 60 92 12 00 mov 0x129260,%ecx
10bfec: 01 ca add %ecx,%edx
10bfee: 89 55 e4 mov %edx,-0x1c(%ebp)
rtems_libio_check_is_open( iop );
10bff1: 8b 42 14 mov 0x14(%edx),%eax
10bff4: f6 c4 01 test $0x1,%ah
10bff7: 0f 84 c7 00 00 00 je 10c0c4 <writev+0x108>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
10bffd: a8 04 test $0x4,%al
10bfff: 74 6b je 10c06c <writev+0xb0> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
10c001: 85 db test %ebx,%ebx
10c003: 74 67 je 10c06c <writev+0xb0>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
10c005: 85 ff test %edi,%edi
10c007: 7e 63 jle 10c06c <writev+0xb0>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
10c009: 81 ff 00 04 00 00 cmp $0x400,%edi
10c00f: 7f 5b jg 10c06c <writev+0xb0> <== NEVER TAKEN
10c011: be 01 00 00 00 mov $0x1,%esi
10c016: 31 c0 xor %eax,%eax
10c018: 31 c9 xor %ecx,%ecx
10c01a: eb 02 jmp 10c01e <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++ ) {
10c01c: 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 )
10c01e: 8b 14 c3 mov (%ebx,%eax,8),%edx
10c021: 85 d2 test %edx,%edx
10c023: 74 47 je 10c06c <writev+0xb0>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
10c025: 8b 54 c3 04 mov 0x4(%ebx,%eax,8),%edx
10c029: 85 d2 test %edx,%edx
10c02b: 74 02 je 10c02f <writev+0x73>
all_zeros = false;
10c02d: 31 f6 xor %esi,%esi
/* check for wrap */
old = total;
total += iov[v].iov_len;
10c02f: 8d 14 11 lea (%ecx,%edx,1),%edx
if ( total < old || total > SSIZE_MAX )
10c032: 39 ca cmp %ecx,%edx
10c034: 7c 36 jl 10c06c <writev+0xb0>
10c036: 81 fa ff 7f 00 00 cmp $0x7fff,%edx
10c03c: 7f 2e jg 10c06c <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++ ) {
10c03e: 40 inc %eax
10c03f: 39 c7 cmp %eax,%edi
10c041: 7f d9 jg 10c01c <writev+0x60>
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
10c043: 89 f0 mov %esi,%eax
10c045: 84 c0 test %al,%al
10c047: 75 3d jne 10c086 <writev+0xca>
10c049: 31 f6 xor %esi,%esi
10c04b: 31 d2 xor %edx,%edx
10c04d: 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 )
10c050: 8b 44 f3 04 mov 0x4(%ebx,%esi,8),%eax
10c054: 85 c0 test %eax,%eax
10c056: 75 32 jne 10c08a <writev+0xce> <== ALWAYS TAKEN
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
10c058: 46 inc %esi
10c059: 39 f7 cmp %esi,%edi
10c05b: 7f f3 jg 10c050 <writev+0x94>
10c05d: 8b 55 c0 mov -0x40(%ebp),%edx
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
10c060: 89 d0 mov %edx,%eax
10c062: 8d 65 f4 lea -0xc(%ebp),%esp
10c065: 5b pop %ebx
10c066: 5e pop %esi
10c067: 5f pop %edi
10c068: c9 leave
10c069: c3 ret
10c06a: 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 );
10c06c: e8 8f 7f 00 00 call 114000 <__errno>
10c071: c7 00 16 00 00 00 movl $0x16,(%eax)
10c077: ba ff ff ff ff mov $0xffffffff,%edx
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
10c07c: 89 d0 mov %edx,%eax
10c07e: 8d 65 f4 lea -0xc(%ebp),%esp
10c081: 5b pop %ebx
10c082: 5e pop %esi
10c083: 5f pop %edi
10c084: c9 leave
10c085: c3 ret
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
return 0;
10c086: 31 d2 xor %edx,%edx
10c088: eb f2 jmp 10c07c <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)(
10c08a: 52 push %edx
10c08b: 8b 4d e4 mov -0x1c(%ebp),%ecx
10c08e: 8b 51 20 mov 0x20(%ecx),%edx
10c091: 50 push %eax
10c092: ff 34 f3 pushl (%ebx,%esi,8)
10c095: 51 push %ecx
10c096: ff 52 0c call *0xc(%edx)
10c099: 89 45 c4 mov %eax,-0x3c(%ebp)
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
10c09c: 83 c4 10 add $0x10,%esp
10c09f: 83 f8 00 cmp $0x0,%eax
10c0a2: 7c 32 jl 10c0d6 <writev+0x11a> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
10c0a4: 74 10 je 10c0b6 <writev+0xfa> <== NEVER TAKEN
iop->offset += bytes;
10c0a6: 99 cltd
10c0a7: 8b 4d e4 mov -0x1c(%ebp),%ecx
10c0aa: 01 41 0c add %eax,0xc(%ecx)
10c0ad: 11 51 10 adc %edx,0x10(%ecx)
total += bytes;
10c0b0: 8b 45 c4 mov -0x3c(%ebp),%eax
10c0b3: 01 45 c0 add %eax,-0x40(%ebp)
}
if (bytes != iov[ v ].iov_len)
10c0b6: 8b 55 c4 mov -0x3c(%ebp),%edx
10c0b9: 3b 54 f3 04 cmp 0x4(%ebx,%esi,8),%edx
10c0bd: 74 99 je 10c058 <writev+0x9c> <== ALWAYS TAKEN
10c0bf: eb 9c jmp 10c05d <writev+0xa1> <== NOT EXECUTED
10c0c1: 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 );
10c0c4: e8 37 7f 00 00 call 114000 <__errno>
10c0c9: c7 00 09 00 00 00 movl $0x9,(%eax)
10c0cf: ba ff ff ff ff mov $0xffffffff,%edx
10c0d4: eb a6 jmp 10c07c <writev+0xc0>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
10c0d6: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED
10c0d9: eb a1 jmp 10c07c <writev+0xc0> <== NOT EXECUTED