RTEMS 4.11Annotated Report
Sun Jan 9 16:08:41 2011
0010f0b8 <IMFS_Set_handlers>:
#define MAXSYMLINK 5
int IMFS_Set_handlers(
rtems_filesystem_location_info_t *loc
)
{
10f0b8: 55 push %ebp
10f0b9: 89 e5 mov %esp,%ebp
10f0bb: 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;
10f0be: 8b 50 10 mov 0x10(%eax),%edx
10f0c1: 8b 4a 34 mov 0x34(%edx),%ecx
switch( node->type ) {
10f0c4: 8b 10 mov (%eax),%edx
10f0c6: 83 7a 4c 07 cmpl $0x7,0x4c(%edx)
10f0ca: 77 12 ja 10f0de <IMFS_Set_handlers+0x26><== NEVER TAKEN
10f0cc: 8b 52 4c mov 0x4c(%edx),%edx
10f0cf: ff 24 95 d0 0f 12 00 jmp *0x120fd0(,%edx,4)
10f0d6: 66 90 xchg %ax,%ax
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
10f0d8: 8b 51 0c mov 0xc(%ecx),%edx
10f0db: 89 50 08 mov %edx,0x8(%eax)
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
10f0de: 31 c0 xor %eax,%eax
10f0e0: c9 leave
10f0e1: c3 ret
10f0e2: 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;
10f0e4: 8b 51 08 mov 0x8(%ecx),%edx
10f0e7: 89 50 08 mov %edx,0x8(%eax)
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
10f0ea: 31 c0 xor %eax,%eax
10f0ec: c9 leave
10f0ed: c3 ret
10f0ee: 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;
10f0f0: c7 40 08 80 10 12 00 movl $0x121080,0x8(%eax)
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
10f0f7: 31 c0 xor %eax,%eax
10f0f9: c9 leave
10f0fa: c3 ret
10f0fb: 90 nop
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_FIFO:
loc->handlers = fs_info->fifo_handlers;
10f0fc: 8b 51 10 mov 0x10(%ecx),%edx
10f0ff: 89 50 08 mov %edx,0x8(%eax)
break;
}
return 0;
}
10f102: 31 c0 xor %eax,%eax
10f104: c9 leave
10f105: c3 ret
10f106: 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;
10f108: c7 40 08 00 10 12 00 movl $0x121000,0x8(%eax)
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
10f10f: 31 c0 xor %eax,%eax
10f111: c9 leave
10f112: c3 ret
0010fa30 <IMFS_check_node_remove>:
void IMFS_check_node_remove( IMFS_jnode_t *jnode )
{
10fa30: 55 push %ebp
10fa31: 89 e5 mov %esp,%ebp
10fa33: 53 push %ebx
10fa34: 83 ec 10 sub $0x10,%esp
10fa37: 8b 5d 08 mov 0x8(%ebp),%ebx
if ( !rtems_libio_is_file_open( jnode ) && jnode->st_nlink < 1 ) {
10fa3a: 53 push %ebx
10fa3b: e8 f8 04 00 00 call 10ff38 <rtems_libio_is_file_open>
10fa40: 83 c4 10 add $0x10,%esp
10fa43: 85 c0 test %eax,%eax
10fa45: 75 2d jne 10fa74 <IMFS_check_node_remove+0x44>
10fa47: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx)
10fa4c: 75 26 jne 10fa74 <IMFS_check_node_remove+0x44>
if ( rtems_filesystem_current.node_access == jnode )
10fa4e: a1 b0 51 12 00 mov 0x1251b0,%eax
10fa53: 39 58 04 cmp %ebx,0x4(%eax)
10fa56: 74 58 je 10fab0 <IMFS_check_node_remove+0x80>
rtems_filesystem_current.node_access = NULL;
switch ( jnode->type ) {
10fa58: 8b 43 4c mov 0x4c(%ebx),%eax
10fa5b: 83 f8 04 cmp $0x4,%eax
10fa5e: 74 34 je 10fa94 <IMFS_check_node_remove+0x64>
10fa60: 83 f8 05 cmp $0x5,%eax
10fa63: 74 17 je 10fa7c <IMFS_check_node_remove+0x4c>
break;
default:
break;
}
free( jnode );
10fa65: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
10fa68: 8b 5d fc mov -0x4(%ebp),%ebx
10fa6b: c9 leave
break;
default:
break;
}
free( jnode );
10fa6c: e9 43 86 ff ff jmp 1080b4 <free>
10fa71: 8d 76 00 lea 0x0(%esi),%esi
}
}
10fa74: 8b 5d fc mov -0x4(%ebp),%ebx
10fa77: c9 leave
10fa78: c3 ret
10fa79: 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 );
10fa7c: 83 ec 0c sub $0xc,%esp
10fa7f: 53 push %ebx
10fa80: e8 9f 24 00 00 call 111f24 <IMFS_memfile_remove>
break;
10fa85: 83 c4 10 add $0x10,%esp
break;
default:
break;
}
free( jnode );
10fa88: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
10fa8b: 8b 5d fc mov -0x4(%ebp),%ebx
10fa8e: c9 leave
break;
default:
break;
}
free( jnode );
10fa8f: e9 20 86 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 );
10fa94: 83 ec 0c sub $0xc,%esp
10fa97: ff 73 50 pushl 0x50(%ebx)
10fa9a: e8 15 86 ff ff call 1080b4 <free>
break;
10fa9f: 83 c4 10 add $0x10,%esp
default:
break;
}
free( jnode );
10faa2: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
10faa5: 8b 5d fc mov -0x4(%ebp),%ebx
10faa8: c9 leave
break;
default:
break;
}
free( jnode );
10faa9: e9 06 86 ff ff jmp 1080b4 <free>
10faae: 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;
10fab0: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
10fab7: eb 9f jmp 10fa58 <IMFS_check_node_remove+0x28>
0010ee78 <IMFS_chown>:
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
10ee78: 55 push %ebp
10ee79: 89 e5 mov %esp,%ebp
10ee7b: 57 push %edi
10ee7c: 56 push %esi
10ee7d: 53 push %ebx
10ee7e: 83 ec 1c sub $0x1c,%esp
10ee81: 8b 7d 0c mov 0xc(%ebp),%edi
10ee84: 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;
10ee87: 8b 45 08 mov 0x8(%ebp),%eax
10ee8a: 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();
10ee8c: e8 bb 0e 00 00 call 10fd4c <geteuid>
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
10ee91: 66 39 43 3c cmp %ax,0x3c(%ebx)
10ee95: 74 05 je 10ee9c <IMFS_chown+0x24>
10ee97: 66 85 c0 test %ax,%ax
10ee9a: 75 2c jne 10eec8 <IMFS_chown+0x50> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
#endif
jnode->st_uid = owner;
10ee9c: 66 89 7b 3c mov %di,0x3c(%ebx)
jnode->st_gid = group;
10eea0: 66 89 73 3e mov %si,0x3e(%ebx)
IMFS_update_ctime( jnode );
10eea4: 83 ec 08 sub $0x8,%esp
10eea7: 6a 00 push $0x0
10eea9: 8d 45 e0 lea -0x20(%ebp),%eax
10eeac: 50 push %eax
10eead: e8 7e 92 ff ff call 108130 <gettimeofday>
10eeb2: 8b 45 e0 mov -0x20(%ebp),%eax
10eeb5: 89 43 48 mov %eax,0x48(%ebx)
return 0;
10eeb8: 83 c4 10 add $0x10,%esp
10eebb: 31 c0 xor %eax,%eax
}
10eebd: 8d 65 f4 lea -0xc(%ebp),%esp
10eec0: 5b pop %ebx
10eec1: 5e pop %esi
10eec2: 5f pop %edi
10eec3: c9 leave
10eec4: c3 ret
10eec5: 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 );
10eec8: e8 47 44 00 00 call 113314 <__errno>
10eecd: c7 00 01 00 00 00 movl $0x1,(%eax)
10eed3: b8 ff ff ff ff mov $0xffffffff,%eax
10eed8: eb e3 jmp 10eebd <IMFS_chown+0x45>
0010ef4c <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
10ef4c: 55 push %ebp
10ef4d: 89 e5 mov %esp,%ebp
10ef4f: 57 push %edi
10ef50: 56 push %esi
10ef51: 53 push %ebx
10ef52: 83 ec 1c sub $0x1c,%esp
10ef55: 8b 45 08 mov 0x8(%ebp),%eax
10ef58: 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 )
10ef5b: 85 c0 test %eax,%eax
10ef5d: 0f 84 ba 00 00 00 je 10f01d <IMFS_create_node+0xd1> <== NEVER TAKEN
return NULL;
parent = parent_loc->node_access;
10ef63: 8b 38 mov (%eax),%edi
fs_info = parent_loc->mt_entry->fs_info;
10ef65: 8b 40 10 mov 0x10(%eax),%eax
10ef68: 8b 70 34 mov 0x34(%eax),%esi
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
10ef6b: 83 fb 07 cmp $0x7,%ebx
10ef6e: 0f 84 9c 00 00 00 je 10f010 <IMFS_create_node+0xc4>
return NULL;
/*
* Allocate filesystem node and fill in basic information
*/
node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
10ef74: 50 push %eax
10ef75: a1 b0 51 12 00 mov 0x1251b0,%eax
10ef7a: 8b 40 2c mov 0x2c(%eax),%eax
10ef7d: f7 d0 not %eax
10ef7f: 23 45 14 and 0x14(%ebp),%eax
10ef82: 50 push %eax
10ef83: ff 75 10 pushl 0x10(%ebp)
10ef86: 53 push %ebx
10ef87: e8 50 ff ff ff call 10eedc <IMFS_allocate_node>
if ( !node )
10ef8c: 83 c4 10 add $0x10,%esp
10ef8f: 85 c0 test %eax,%eax
10ef91: 74 73 je 10f006 <IMFS_create_node+0xba>
return NULL;
/*
* Set the type specific information
*/
if ( type == IMFS_DIRECTORY ) {
10ef93: 83 fb 01 cmp $0x1,%ebx
10ef96: 74 38 je 10efd0 <IMFS_create_node+0x84>
rtems_chain_initialize_empty(&node->info.directory.Entries);
} else if ( type == IMFS_HARD_LINK ) {
10ef98: 83 fb 03 cmp $0x3,%ebx
10ef9b: 0f 84 97 00 00 00 je 10f038 <IMFS_create_node+0xec>
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
10efa1: 83 fb 04 cmp $0x4,%ebx
10efa4: 0f 84 8e 00 00 00 je 10f038 <IMFS_create_node+0xec>
node->info.sym_link.name = info->sym_link.name;
} else if ( type == IMFS_DEVICE ) {
10efaa: 83 fb 02 cmp $0x2,%ebx
10efad: 74 79 je 10f028 <IMFS_create_node+0xdc>
node->info.device.major = info->device.major;
node->info.device.minor = info->device.minor;
} else if ( type == IMFS_LINEAR_FILE ) {
10efaf: 83 fb 06 cmp $0x6,%ebx
10efb2: 0f 84 8c 00 00 00 je 10f044 <IMFS_create_node+0xf8>
node->info.linearfile.size = 0;
node->info.linearfile.direct = 0;
} else if ( type == IMFS_MEMORY_FILE ) {
10efb8: 83 fb 05 cmp $0x5,%ebx
10efbb: 0f 84 9b 00 00 00 je 10f05c <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 ) {
10efc1: 83 fb 07 cmp $0x7,%ebx
10efc4: 75 1d jne 10efe3 <IMFS_create_node+0x97> <== NEVER TAKEN
node->info.fifo.pipe = NULL;
10efc6: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
10efcd: eb 14 jmp 10efe3 <IMFS_create_node+0x97>
10efcf: 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 );
10efd0: 8d 50 54 lea 0x54(%eax),%edx
10efd3: 89 50 50 mov %edx,0x50(%eax)
head->next = tail;
head->previous = NULL;
10efd6: 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 );
10efdd: 8d 50 50 lea 0x50(%eax),%edx
10efe0: 89 50 58 mov %edx,0x58(%eax)
}
/*
* This node MUST have a parent, so put it in that directory list.
*/
node->Parent = parent;
10efe3: 89 78 08 mov %edi,0x8(%eax)
node->st_ino = ++fs_info->ino_count;
10efe6: 8b 56 04 mov 0x4(%esi),%edx
10efe9: 42 inc %edx
10efea: 89 56 04 mov %edx,0x4(%esi)
10efed: 89 50 38 mov %edx,0x38(%eax)
10eff0: 83 ec 08 sub $0x8,%esp
10eff3: 50 push %eax
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
10eff4: 83 c7 50 add $0x50,%edi
10eff7: 57 push %edi
10eff8: 89 45 e4 mov %eax,-0x1c(%ebp)
10effb: e8 dc cf ff ff call 10bfdc <_Chain_Append>
return node;
10f000: 83 c4 10 add $0x10,%esp
10f003: 8b 45 e4 mov -0x1c(%ebp),%eax
}
10f006: 8d 65 f4 lea -0xc(%ebp),%esp
10f009: 5b pop %ebx
10f00a: 5e pop %esi
10f00b: 5f pop %edi
10f00c: c9 leave
10f00d: c3 ret
10f00e: 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 &&
10f010: 81 7e 10 60 0f 12 00 cmpl $0x120f60,0x10(%esi)
10f017: 0f 85 57 ff ff ff jne 10ef74 <IMFS_create_node+0x28>
fs_info->fifo_handlers == &rtems_filesystem_handlers_default )
return NULL;
10f01d: 31 c0 xor %eax,%eax
node->st_ino = ++fs_info->ino_count;
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
return node;
}
10f01f: 8d 65 f4 lea -0xc(%ebp),%esp
10f022: 5b pop %ebx
10f023: 5e pop %esi
10f024: 5f pop %edi
10f025: c9 leave
10f026: c3 ret
10f027: 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;
10f028: 8b 4d 18 mov 0x18(%ebp),%ecx
10f02b: 8b 11 mov (%ecx),%edx
10f02d: 89 50 50 mov %edx,0x50(%eax)
node->info.device.minor = info->device.minor;
10f030: 8b 51 04 mov 0x4(%ecx),%edx
10f033: 89 50 54 mov %edx,0x54(%eax)
10f036: eb ab jmp 10efe3 <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;
10f038: 8b 4d 18 mov 0x18(%ebp),%ecx
10f03b: 8b 11 mov (%ecx),%edx
10f03d: 89 50 50 mov %edx,0x50(%eax)
10f040: eb a1 jmp 10efe3 <IMFS_create_node+0x97>
10f042: 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;
10f044: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
10f04b: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.linearfile.direct = 0;
10f052: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
10f059: eb 88 jmp 10efe3 <IMFS_create_node+0x97>
10f05b: 90 nop
} else if ( type == IMFS_MEMORY_FILE ) {
node->info.file.size = 0;
10f05c: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
10f063: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.file.indirect = 0;
10f06a: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
node->info.file.doubly_indirect = 0;
10f071: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
node->info.file.triply_indirect = 0;
10f078: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
10f07f: e9 5f ff ff ff jmp 10efe3 <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 60 b2 12 00 mov 0x12b260,%eax
10a519: ff 70 08 pushl 0x8(%eax)
10a51c: 6a 04 push $0x4
10a51e: 6a 01 push $0x1
10a520: 68 92 69 12 00 push $0x126992
10a525: e8 3a e1 00 00 call 118664 <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>
0010f1c4 <IMFS_eval_path>:
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
10f1c4: 55 push %ebp
10f1c5: 89 e5 mov %esp,%ebp
10f1c7: 57 push %edi
10f1c8: 56 push %esi
10f1c9: 53 push %ebx
10f1ca: 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 ) ) {
10f1cd: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp)
10f1d4: 0f 85 ee 01 00 00 jne 10f3c8 <IMFS_eval_path+0x204> <== NEVER TAKEN
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
10f1da: 8b 45 14 mov 0x14(%ebp),%eax
10f1dd: 8b 38 mov (%eax),%edi
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
int i = 0;
10f1df: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp)
10f1e6: 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 );
10f1e9: 8d 55 e4 lea -0x1c(%ebp),%edx
10f1ec: 52 push %edx
10f1ed: 56 push %esi
10f1ee: ff 75 0c pushl 0xc(%ebp)
10f1f1: 8b 45 08 mov 0x8(%ebp),%eax
10f1f4: 03 45 a4 add -0x5c(%ebp),%eax
10f1f7: 50 push %eax
10f1f8: e8 17 07 00 00 call 10f914 <IMFS_get_token>
10f1fd: 89 c3 mov %eax,%ebx
pathnamelen -= len;
10f1ff: 8b 55 e4 mov -0x1c(%ebp),%edx
i += len;
if ( !pathloc->node_access )
10f202: 8b 4d 14 mov 0x14(%ebp),%ecx
10f205: 8b 01 mov (%ecx),%eax
10f207: 83 c4 10 add $0x10,%esp
10f20a: 85 c0 test %eax,%eax
10f20c: 0f 84 e6 00 00 00 je 10f2f8 <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;
10f212: 29 55 0c sub %edx,0xc(%ebp)
i += len;
10f215: 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 )
10f218: 85 db test %ebx,%ebx
10f21a: 75 44 jne 10f260 <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 ) {
10f21c: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
10f220: 0f 84 26 01 00 00 je 10f34c <IMFS_eval_path+0x188>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
10f226: 83 ec 0c sub $0xc,%esp
10f229: ff 75 14 pushl 0x14(%ebp)
10f22c: e8 87 fe ff ff call 10f0b8 <IMFS_Set_handlers>
10f231: 89 c3 mov %eax,%ebx
10f233: 5a pop %edx
10f234: 59 pop %ecx
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
10f235: ff 75 10 pushl 0x10(%ebp)
10f238: ff 75 14 pushl 0x14(%ebp)
10f23b: e8 d4 fe ff ff call 10f114 <IMFS_evaluate_permission>
10f240: 83 c4 10 add $0x10,%esp
10f243: 85 c0 test %eax,%eax
10f245: 0f 85 d1 00 00 00 jne 10f31c <IMFS_eval_path+0x158>
rtems_set_errno_and_return_minus_one( EACCES );
10f24b: e8 c4 40 00 00 call 113314 <__errno>
10f250: c7 00 0d 00 00 00 movl $0xd,(%eax)
10f256: bb ff ff ff ff mov $0xffffffff,%ebx
10f25b: e9 bc 00 00 00 jmp 10f31c <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 )
10f260: 83 7f 4c 01 cmpl $0x1,0x4c(%edi)
10f264: 0f 84 be 00 00 00 je 10f328 <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;
10f26a: 89 c7 mov %eax,%edi
switch( type ) {
10f26c: 83 fb 03 cmp $0x3,%ebx
10f26f: 74 1b je 10f28c <IMFS_eval_path+0xc8>
10f271: 83 fb 04 cmp $0x4,%ebx
10f274: 0f 84 92 00 00 00 je 10f30c <IMFS_eval_path+0x148>
10f27a: 83 fb 02 cmp $0x2,%ebx
10f27d: 74 51 je 10f2d0 <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) ) {
10f27f: 83 fb 04 cmp $0x4,%ebx
10f282: 0f 85 61 ff ff ff jne 10f1e9 <IMFS_eval_path+0x25> <== ALWAYS TAKEN
10f288: eb 92 jmp 10f21c <IMFS_eval_path+0x58> <== NOT EXECUTED
10f28a: 66 90 xchg %ax,%ax <== NOT EXECUTED
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
10f28c: 8b 40 4c mov 0x4c(%eax),%eax
10f28f: 83 f8 03 cmp $0x3,%eax
10f292: 0f 84 08 01 00 00 je 10f3a0 <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 ) {
10f298: 83 f8 04 cmp $0x4,%eax
10f29b: 0f 84 51 01 00 00 je 10f3f2 <IMFS_eval_path+0x22e>
}
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10f2a1: 48 dec %eax
10f2a2: 0f 85 35 01 00 00 jne 10f3dd <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 ) {
10f2a8: 8b 47 5c mov 0x5c(%edi),%eax
10f2ab: 85 c0 test %eax,%eax
10f2ad: 0f 85 a4 00 00 00 jne 10f357 <IMFS_eval_path+0x193>
}
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10f2b3: 83 ec 08 sub $0x8,%esp
10f2b6: 56 push %esi
10f2b7: 57 push %edi
10f2b8: e8 eb 05 00 00 call 10f8a8 <IMFS_find_match_in_dir>
10f2bd: 89 c7 mov %eax,%edi
if ( !node )
10f2bf: 83 c4 10 add $0x10,%esp
10f2c2: 85 c0 test %eax,%eax
10f2c4: 74 32 je 10f2f8 <IMFS_eval_path+0x134>
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
10f2c6: 8b 45 14 mov 0x14(%ebp),%eax
10f2c9: 89 38 mov %edi,(%eax)
10f2cb: e9 19 ff ff ff jmp 10f1e9 <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 )
10f2d0: 8b 15 b0 51 12 00 mov 0x1251b0,%edx
10f2d6: 39 42 18 cmp %eax,0x18(%edx)
10f2d9: 0f 84 0a ff ff ff je 10f1e9 <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) {
10f2df: 8b 4d 14 mov 0x14(%ebp),%ecx
10f2e2: 8b 51 10 mov 0x10(%ecx),%edx
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
10f2e5: 39 42 1c cmp %eax,0x1c(%edx)
10f2e8: 0f 84 d2 00 00 00 je 10f3c0 <IMFS_eval_path+0x1fc>
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
10f2ee: 8b 78 08 mov 0x8(%eax),%edi
10f2f1: 85 ff test %edi,%edi
10f2f3: 75 d1 jne 10f2c6 <IMFS_eval_path+0x102>
10f2f5: 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 );
10f2f8: e8 17 40 00 00 call 113314 <__errno>
10f2fd: c7 00 02 00 00 00 movl $0x2,(%eax)
10f303: bb ff ff ff ff mov $0xffffffff,%ebx
10f308: eb 12 jmp 10f31c <IMFS_eval_path+0x158>
10f30a: 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 );
10f30c: e8 03 40 00 00 call 113314 <__errno>
10f311: c7 00 5b 00 00 00 movl $0x5b,(%eax)
10f317: bb ff ff ff ff mov $0xffffffff,%ebx
if ( !IMFS_evaluate_permission( pathloc, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10f31c: 89 d8 mov %ebx,%eax
10f31e: 8d 65 f4 lea -0xc(%ebp),%esp
10f321: 5b pop %ebx
10f322: 5e pop %esi
10f323: 5f pop %edi
10f324: c9 leave
10f325: c3 ret
10f326: 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 ) )
10f328: 83 ec 08 sub $0x8,%esp
10f32b: 6a 01 push $0x1
10f32d: ff 75 14 pushl 0x14(%ebp)
10f330: e8 df fd ff ff call 10f114 <IMFS_evaluate_permission>
10f335: 83 c4 10 add $0x10,%esp
10f338: 85 c0 test %eax,%eax
10f33a: 0f 84 0b ff ff ff je 10f24b <IMFS_eval_path+0x87>
10f340: 8b 55 14 mov 0x14(%ebp),%edx
10f343: 8b 02 mov (%edx),%eax
10f345: e9 20 ff ff ff jmp 10f26a <IMFS_eval_path+0xa6>
10f34a: 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 ) {
10f34c: 8b 40 5c mov 0x5c(%eax),%eax
10f34f: 85 c0 test %eax,%eax
10f351: 0f 84 cf fe ff ff je 10f226 <IMFS_eval_path+0x62>
newloc = node->info.directory.mt_fs->mt_fs_root;
10f357: 8d 7d d0 lea -0x30(%ebp),%edi
10f35a: 8d 70 1c lea 0x1c(%eax),%esi
10f35d: b9 05 00 00 00 mov $0x5,%ecx
10f362: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*pathloc = newloc;
10f364: 8d 75 d0 lea -0x30(%ebp),%esi
10f367: b1 05 mov $0x5,%cl
10f369: 8b 7d 14 mov 0x14(%ebp),%edi
10f36c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
10f36e: 8b 55 e4 mov -0x1c(%ebp),%edx
10f371: 8b 4d 14 mov 0x14(%ebp),%ecx
10f374: 8b 41 0c mov 0xc(%ecx),%eax
10f377: 51 push %ecx
10f378: ff 75 10 pushl 0x10(%ebp)
10f37b: 8b 4d 0c mov 0xc(%ebp),%ecx
10f37e: 01 d1 add %edx,%ecx
10f380: 51 push %ecx
10f381: 8b 4d a4 mov -0x5c(%ebp),%ecx
10f384: 29 d1 sub %edx,%ecx
10f386: 8b 55 08 mov 0x8(%ebp),%edx
10f389: 01 ca add %ecx,%edx
10f38b: 52 push %edx
10f38c: ff 10 call *(%eax)
10f38e: 89 c3 mov %eax,%ebx
10f390: 83 c4 10 add $0x10,%esp
if ( !IMFS_evaluate_permission( pathloc, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10f393: 89 d8 mov %ebx,%eax
10f395: 8d 65 f4 lea -0xc(%ebp),%esp
10f398: 5b pop %ebx
10f399: 5e pop %esi
10f39a: 5f pop %edi
10f39b: c9 leave
10f39c: c3 ret
10f39d: 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 );
10f3a0: 83 ec 08 sub $0x8,%esp
10f3a3: 6a 00 push $0x0
10f3a5: ff 75 14 pushl 0x14(%ebp)
10f3a8: e8 d3 fd ff ff call 10f180 <IMFS_evaluate_hard_link>
node = pathloc->node_access;
10f3ad: 8b 55 14 mov 0x14(%ebp),%edx
10f3b0: 8b 3a mov (%edx),%edi
10f3b2: 8b 47 4c mov 0x4c(%edi),%eax
10f3b5: 83 c4 10 add $0x10,%esp
10f3b8: e9 e4 fe ff ff jmp 10f2a1 <IMFS_eval_path+0xdd>
10f3bd: 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;
10f3c0: 8d 7d d0 lea -0x30(%ebp),%edi
10f3c3: 8d 72 08 lea 0x8(%edx),%esi
10f3c6: eb 95 jmp 10f35d <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 );
10f3c8: e8 47 3f 00 00 call 113314 <__errno> <== NOT EXECUTED
10f3cd: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
10f3d3: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
10f3d8: e9 3f ff ff ff jmp 10f31c <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 );
10f3dd: e8 32 3f 00 00 call 113314 <__errno>
10f3e2: c7 00 14 00 00 00 movl $0x14,(%eax)
10f3e8: bb ff ff ff ff mov $0xffffffff,%ebx
10f3ed: e9 2a ff ff ff jmp 10f31c <IMFS_eval_path+0x158>
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
10f3f2: 83 ec 08 sub $0x8,%esp
10f3f5: 6a 00 push $0x0
10f3f7: ff 75 14 pushl 0x14(%ebp)
10f3fa: e8 1d 00 00 00 call 10f41c <IMFS_evaluate_sym_link>
10f3ff: 89 c3 mov %eax,%ebx
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
10f401: 8b 4d 14 mov 0x14(%ebp),%ecx
10f404: 8b 39 mov (%ecx),%edi
if ( result == -1 )
10f406: 83 c4 10 add $0x10,%esp
10f409: 83 f8 ff cmp $0xffffffff,%eax
10f40c: 0f 84 0a ff ff ff je 10f31c <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;
10f412: 8b 47 4c mov 0x4c(%edi),%eax
10f415: e9 87 fe ff ff jmp 10f2a1 <IMFS_eval_path+0xdd>
0010f544 <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 */
)
{
10f544: 55 push %ebp
10f545: 89 e5 mov %esp,%ebp
10f547: 57 push %edi
10f548: 56 push %esi
10f549: 53 push %ebx
10f54a: 83 ec 5c sub $0x5c,%esp
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
10f54d: 8b 45 0c mov 0xc(%ebp),%eax
10f550: 8b 18 mov (%eax),%ebx
/*
* Get the path length.
*/
pathlen = strlen( path );
10f552: 31 c0 xor %eax,%eax
10f554: b9 ff ff ff ff mov $0xffffffff,%ecx
10f559: 8b 7d 08 mov 0x8(%ebp),%edi
10f55c: f2 ae repnz scas %es:(%edi),%al
10f55e: f7 d1 not %ecx
10f560: 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;
10f563: 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 );
10f56a: 8d 55 e4 lea -0x1c(%ebp),%edx
10f56d: 52 push %edx
10f56e: 8d 4d af lea -0x51(%ebp),%ecx
10f571: 51 push %ecx
10f572: 56 push %esi
10f573: 8b 45 08 mov 0x8(%ebp),%eax
10f576: 03 45 a4 add -0x5c(%ebp),%eax
10f579: 50 push %eax
10f57a: e8 95 03 00 00 call 10f914 <IMFS_get_token>
10f57f: 89 c7 mov %eax,%edi
pathlen -= len;
10f581: 8b 55 e4 mov -0x1c(%ebp),%edx
10f584: 29 d6 sub %edx,%esi
i += len;
if ( !pathloc->node_access )
10f586: 8b 4d 0c mov 0xc(%ebp),%ecx
10f589: 8b 01 mov (%ecx),%eax
10f58b: 83 c4 10 add $0x10,%esp
10f58e: 85 c0 test %eax,%eax
10f590: 0f 84 55 01 00 00 je 10f6eb <IMFS_evaluate_for_make+0x1a7><== NEVER TAKEN
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
10f596: 85 ff test %edi,%edi
10f598: 75 1a jne 10f5b4 <IMFS_evaluate_for_make+0x70>
pathloc->node_access = node;
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
10f59a: e8 75 3d 00 00 call 113314 <__errno>
10f59f: c7 00 11 00 00 00 movl $0x11,(%eax)
10f5a5: 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;
}
10f5aa: 89 d8 mov %ebx,%eax
10f5ac: 8d 65 f4 lea -0xc(%ebp),%esp
10f5af: 5b pop %ebx
10f5b0: 5e pop %esi
10f5b1: 5f pop %edi
10f5b2: c9 leave
10f5b3: c3 ret
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
10f5b4: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10f5b8: 0f 84 c6 00 00 00 je 10f684 <IMFS_evaluate_for_make+0x140>
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
i += len;
10f5be: 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;
10f5c1: 89 c3 mov %eax,%ebx
switch( type ) {
10f5c3: 83 ff 02 cmp $0x2,%edi
10f5c6: 0f 84 88 00 00 00 je 10f654 <IMFS_evaluate_for_make+0x110>
10f5cc: 76 26 jbe 10f5f4 <IMFS_evaluate_for_make+0xb0>
10f5ce: 83 ff 03 cmp $0x3,%edi
10f5d1: 74 2d je 10f600 <IMFS_evaluate_for_make+0xbc>
10f5d3: 83 ff 04 cmp $0x4,%edi
10f5d6: 75 92 jne 10f56a <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 );
10f5d8: e8 37 3d 00 00 call 113314 <__errno>
10f5dd: c7 00 5b 00 00 00 movl $0x5b,(%eax)
10f5e3: 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;
}
10f5e8: 89 d8 mov %ebx,%eax
10f5ea: 8d 65 f4 lea -0xc(%ebp),%esp
10f5ed: 5b pop %ebx
10f5ee: 5e pop %esi
10f5ef: 5f pop %edi
10f5f0: c9 leave
10f5f1: c3 ret
10f5f2: 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 ) {
10f5f4: 85 ff test %edi,%edi
10f5f6: 74 a2 je 10f59a <IMFS_evaluate_for_make+0x56><== NEVER TAKEN
10f5f8: e9 6d ff ff ff jmp 10f56a <IMFS_evaluate_for_make+0x26>
10f5fd: 8d 76 00 lea 0x0(%esi),%esi
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
10f600: 8b 40 4c mov 0x4c(%eax),%eax
10f603: 83 f8 03 cmp $0x3,%eax
10f606: 0f 84 b4 01 00 00 je 10f7c0 <IMFS_evaluate_for_make+0x27c>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
10f60c: 83 f8 04 cmp $0x4,%eax
10f60f: 0f 84 ca 01 00 00 je 10f7df <IMFS_evaluate_for_make+0x29b>
if ( result == -1 )
return -1;
}
node = pathloc->node_access;
if ( !node )
10f615: 85 db test %ebx,%ebx
10f617: 0f 84 67 01 00 00 je 10f784 <IMFS_evaluate_for_make+0x240><== NEVER TAKEN
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10f61d: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10f621: 0f 85 5d 01 00 00 jne 10f784 <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 ) {
10f627: 8b 43 5c mov 0x5c(%ebx),%eax
10f62a: 85 c0 test %eax,%eax
10f62c: 0f 85 67 01 00 00 jne 10f799 <IMFS_evaluate_for_make+0x255>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10f632: 83 ec 08 sub $0x8,%esp
10f635: 8d 45 af lea -0x51(%ebp),%eax
10f638: 50 push %eax
10f639: 53 push %ebx
10f63a: e8 69 02 00 00 call 10f8a8 <IMFS_find_match_in_dir>
10f63f: 89 c3 mov %eax,%ebx
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
10f641: 83 c4 10 add $0x10,%esp
10f644: 85 c0 test %eax,%eax
10f646: 74 64 je 10f6ac <IMFS_evaluate_for_make+0x168>
done = true;
else
pathloc->node_access = node;
10f648: 8b 55 0c mov 0xc(%ebp),%edx
10f64b: 89 02 mov %eax,(%edx)
10f64d: e9 18 ff ff ff jmp 10f56a <IMFS_evaluate_for_make+0x26>
10f652: 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 )
10f654: 8b 15 b0 51 12 00 mov 0x1251b0,%edx
10f65a: 3b 42 18 cmp 0x18(%edx),%eax
10f65d: 0f 84 07 ff ff ff je 10f56a <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){
10f663: 8b 4d 0c mov 0xc(%ebp),%ecx
10f666: 8b 51 10 mov 0x10(%ecx),%edx
10f669: 3b 42 1c cmp 0x1c(%edx),%eax
10f66c: 0f 84 8e 00 00 00 je 10f700 <IMFS_evaluate_for_make+0x1bc>
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
10f672: 8b 58 08 mov 0x8(%eax),%ebx
10f675: 85 db test %ebx,%ebx
10f677: 74 72 je 10f6eb <IMFS_evaluate_for_make+0x1a7>
rtems_set_errno_and_return_minus_one( ENOENT );
node = node->Parent;
}
pathloc->node_access = node;
10f679: 8b 4d 0c mov 0xc(%ebp),%ecx
10f67c: 89 19 mov %ebx,(%ecx)
break;
10f67e: e9 e7 fe ff ff jmp 10f56a <IMFS_evaluate_for_make+0x26>
10f683: 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 ) )
10f684: 83 ec 08 sub $0x8,%esp
10f687: 6a 01 push $0x1
10f689: ff 75 0c pushl 0xc(%ebp)
10f68c: 89 55 a0 mov %edx,-0x60(%ebp)
10f68f: e8 80 fa ff ff call 10f114 <IMFS_evaluate_permission>
10f694: 83 c4 10 add $0x10,%esp
10f697: 85 c0 test %eax,%eax
10f699: 8b 55 a0 mov -0x60(%ebp),%edx
10f69c: 0f 84 cd 00 00 00 je 10f76f <IMFS_evaluate_for_make+0x22b>
10f6a2: 8b 4d 0c mov 0xc(%ebp),%ecx
10f6a5: 8b 01 mov (%ecx),%eax
10f6a7: e9 12 ff ff ff jmp 10f5be <IMFS_evaluate_for_make+0x7a>
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
10f6ac: 8b 45 a4 mov -0x5c(%ebp),%eax
10f6af: 2b 45 e4 sub -0x1c(%ebp),%eax
10f6b2: 03 45 08 add 0x8(%ebp),%eax
10f6b5: 8b 4d 10 mov 0x10(%ebp),%ecx
10f6b8: 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++) {
10f6ba: 8b 4d 08 mov 0x8(%ebp),%ecx
10f6bd: 8b 55 a4 mov -0x5c(%ebp),%edx
10f6c0: 8a 04 11 mov (%ecx,%edx,1),%al
10f6c3: 84 c0 test %al,%al
10f6c5: 74 75 je 10f73c <IMFS_evaluate_for_make+0x1f8>
10f6c7: 89 d3 mov %edx,%ebx
10f6c9: 89 ce mov %ecx,%esi
10f6cb: eb 0b jmp 10f6d8 <IMFS_evaluate_for_make+0x194>
10f6cd: 8d 76 00 lea 0x0(%esi),%esi
10f6d0: 43 inc %ebx
10f6d1: 8a 04 1e mov (%esi,%ebx,1),%al
10f6d4: 84 c0 test %al,%al
10f6d6: 74 64 je 10f73c <IMFS_evaluate_for_make+0x1f8>
if ( !IMFS_is_separator( path[ i ] ) )
10f6d8: 83 ec 0c sub $0xc,%esp
10f6db: 0f be c0 movsbl %al,%eax
10f6de: 50 push %eax
10f6df: e8 34 98 ff ff call 108f18 <rtems_filesystem_is_separator>
10f6e4: 83 c4 10 add $0x10,%esp
10f6e7: 85 c0 test %eax,%eax
10f6e9: 75 e5 jne 10f6d0 <IMFS_evaluate_for_make+0x18c>
rtems_set_errno_and_return_minus_one( ENOENT );
10f6eb: e8 24 3c 00 00 call 113314 <__errno>
10f6f0: c7 00 02 00 00 00 movl $0x2,(%eax)
10f6f6: bb ff ff ff ff mov $0xffffffff,%ebx
10f6fb: e9 aa fe ff ff jmp 10f5aa <IMFS_evaluate_for_make+0x66>
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
10f700: 8d 7d d0 lea -0x30(%ebp),%edi
10f703: 8d 72 08 lea 0x8(%edx),%esi
10f706: b9 05 00 00 00 mov $0x5,%ecx
10f70b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*pathloc = newloc;
10f70d: 8d 75 d0 lea -0x30(%ebp),%esi
10f710: b1 05 mov $0x5,%cl
10f712: 8b 7d 0c mov 0xc(%ebp),%edi
10f715: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
10f717: 53 push %ebx
10f718: 8b 55 0c mov 0xc(%ebp),%edx
10f71b: 8b 42 0c mov 0xc(%edx),%eax
10f71e: ff 75 10 pushl 0x10(%ebp)
10f721: 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 );
10f722: 8b 55 a4 mov -0x5c(%ebp),%edx
10f725: 2b 55 e4 sub -0x1c(%ebp),%edx
10f728: 03 55 08 add 0x8(%ebp),%edx
10f72b: 52 push %edx
10f72c: ff 50 04 call *0x4(%eax)
10f72f: 89 c3 mov %eax,%ebx
10f731: 83 c4 10 add $0x10,%esp
10f734: e9 71 fe ff ff jmp 10f5aa <IMFS_evaluate_for_make+0x66>
10f739: 8d 76 00 lea 0x0(%esi),%esi
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
10f73c: 83 ec 0c sub $0xc,%esp
10f73f: ff 75 0c pushl 0xc(%ebp)
10f742: e8 71 f9 ff ff call 10f0b8 <IMFS_Set_handlers>
10f747: 89 c3 mov %eax,%ebx
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
10f749: 8b 55 0c mov 0xc(%ebp),%edx
10f74c: 8b 02 mov (%edx),%eax
10f74e: 83 c4 10 add $0x10,%esp
10f751: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
10f755: 75 2d jne 10f784 <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 ) )
10f757: 83 ec 08 sub $0x8,%esp
10f75a: 6a 03 push $0x3
10f75c: ff 75 0c pushl 0xc(%ebp)
10f75f: e8 b0 f9 ff ff call 10f114 <IMFS_evaluate_permission>
10f764: 83 c4 10 add $0x10,%esp
10f767: 85 c0 test %eax,%eax
10f769: 0f 85 3b fe ff ff jne 10f5aa <IMFS_evaluate_for_make+0x66>
rtems_set_errno_and_return_minus_one( EACCES );
10f76f: e8 a0 3b 00 00 call 113314 <__errno>
10f774: c7 00 0d 00 00 00 movl $0xd,(%eax)
10f77a: bb ff ff ff ff mov $0xffffffff,%ebx
10f77f: e9 26 fe ff ff jmp 10f5aa <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 );
10f784: e8 8b 3b 00 00 call 113314 <__errno>
10f789: c7 00 14 00 00 00 movl $0x14,(%eax)
10f78f: bb ff ff ff ff mov $0xffffffff,%ebx
10f794: e9 11 fe ff ff jmp 10f5aa <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;
10f799: 8d 7d d0 lea -0x30(%ebp),%edi
10f79c: 8d 70 1c lea 0x1c(%eax),%esi
10f79f: b9 05 00 00 00 mov $0x5,%ecx
10f7a4: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*pathloc = newloc;
10f7a6: 8d 75 d0 lea -0x30(%ebp),%esi
10f7a9: b1 05 mov $0x5,%cl
10f7ab: 8b 7d 0c mov 0xc(%ebp),%edi
10f7ae: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
10f7b0: 51 push %ecx
10f7b1: 8b 4d 0c mov 0xc(%ebp),%ecx
10f7b4: 8b 41 0c mov 0xc(%ecx),%eax
10f7b7: ff 75 10 pushl 0x10(%ebp)
10f7ba: 51 push %ecx
10f7bb: e9 62 ff ff ff jmp 10f722 <IMFS_evaluate_for_make+0x1de>
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
10f7c0: 83 ec 08 sub $0x8,%esp
10f7c3: 6a 00 push $0x0
10f7c5: ff 75 0c pushl 0xc(%ebp)
10f7c8: e8 cb fc ff ff call 10f498 <IMFS_evaluate_link>
if ( result == -1 )
10f7cd: 83 c4 10 add $0x10,%esp
10f7d0: 83 f8 ff cmp $0xffffffff,%eax
10f7d3: 74 29 je 10f7fe <IMFS_evaluate_for_make+0x2ba><== NEVER TAKEN
10f7d5: 8b 45 0c mov 0xc(%ebp),%eax
10f7d8: 8b 18 mov (%eax),%ebx
10f7da: e9 36 fe ff ff jmp 10f615 <IMFS_evaluate_for_make+0xd1>
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
10f7df: 83 ec 08 sub $0x8,%esp
10f7e2: 6a 00 push $0x0
10f7e4: ff 75 0c pushl 0xc(%ebp)
10f7e7: e8 ac fc ff ff call 10f498 <IMFS_evaluate_link>
if ( result == -1 )
10f7ec: 83 c4 10 add $0x10,%esp
10f7ef: 83 f8 ff cmp $0xffffffff,%eax
10f7f2: 74 0a je 10f7fe <IMFS_evaluate_for_make+0x2ba><== NEVER TAKEN
10f7f4: 8b 55 0c mov 0xc(%ebp),%edx
10f7f7: 8b 1a mov (%edx),%ebx
10f7f9: e9 17 fe ff ff jmp 10f615 <IMFS_evaluate_for_make+0xd1>
10f7fe: 89 c3 mov %eax,%ebx <== NOT EXECUTED
10f800: e9 a5 fd ff ff jmp 10f5aa <IMFS_evaluate_for_make+0x66><== NOT EXECUTED
0010f498 <IMFS_evaluate_link>:
*/
int IMFS_evaluate_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
10f498: 55 push %ebp
10f499: 89 e5 mov %esp,%ebp
10f49b: 57 push %edi
10f49c: 56 push %esi
10f49d: 53 push %ebx
10f49e: 83 ec 0c sub $0xc,%esp
10f4a1: 8b 75 08 mov 0x8(%ebp),%esi
10f4a4: 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 );
10f4a7: 8b 15 b0 51 12 00 mov 0x1251b0,%edx
10f4ad: eb 0e jmp 10f4bd <IMFS_evaluate_link+0x25>
10f4af: 90 nop
*/
if ( jnode->type == IMFS_HARD_LINK )
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
10f4b0: 83 f8 04 cmp $0x4,%eax
10f4b3: 74 53 je 10f508 <IMFS_evaluate_link+0x70>
result = IMFS_evaluate_sym_link( node, flags );
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
10f4b5: 83 e8 03 sub $0x3,%eax
10f4b8: 83 f8 01 cmp $0x1,%eax
10f4bb: 77 3a ja 10f4f7 <IMFS_evaluate_link+0x5f><== ALWAYS TAKEN
{
IMFS_jnode_t *jnode;
int result = 0;
do {
jnode = node->node_access;
10f4bd: 8b 1e mov (%esi),%ebx
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
10f4bf: 8b 42 30 mov 0x30(%edx),%eax
10f4c2: 40 inc %eax
10f4c3: 66 89 42 30 mov %ax,0x30(%edx)
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
10f4c7: 66 83 f8 05 cmp $0x5,%ax
10f4cb: 77 57 ja 10f524 <IMFS_evaluate_link+0x8c><== NEVER TAKEN
/*
* Follow the Link node.
*/
if ( jnode->type == IMFS_HARD_LINK )
10f4cd: 8b 43 4c mov 0x4c(%ebx),%eax
10f4d0: 83 f8 03 cmp $0x3,%eax
10f4d3: 75 db jne 10f4b0 <IMFS_evaluate_link+0x18>
result = IMFS_evaluate_hard_link( node, flags );
10f4d5: 83 ec 08 sub $0x8,%esp
10f4d8: 57 push %edi
10f4d9: 56 push %esi
10f4da: e8 a1 fc ff ff call 10f180 <IMFS_evaluate_hard_link>
10f4df: 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 ) ) );
10f4e2: 85 c0 test %eax,%eax
10f4e4: 75 33 jne 10f519 <IMFS_evaluate_link+0x81>
10f4e6: 8b 43 4c mov 0x4c(%ebx),%eax
10f4e9: 8b 15 b0 51 12 00 mov 0x1251b0,%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 ) ||
10f4ef: 83 e8 03 sub $0x3,%eax
10f4f2: 83 f8 01 cmp $0x1,%eax
10f4f5: 76 c6 jbe 10f4bd <IMFS_evaluate_link+0x25><== ALWAYS TAKEN
10f4f7: 31 c0 xor %eax,%eax
/*
* Clear link counter.
*/
rtems_filesystem_link_counts = 0;
10f4f9: 66 c7 42 30 00 00 movw $0x0,0x30(%edx)
return result;
}
10f4ff: 8d 65 f4 lea -0xc(%ebp),%esp
10f502: 5b pop %ebx
10f503: 5e pop %esi
10f504: 5f pop %edi
10f505: c9 leave
10f506: c3 ret
10f507: 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 );
10f508: 83 ec 08 sub $0x8,%esp
10f50b: 57 push %edi
10f50c: 56 push %esi
10f50d: e8 0a ff ff ff call 10f41c <IMFS_evaluate_sym_link>
10f512: 83 c4 10 add $0x10,%esp
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
( jnode->type == IMFS_HARD_LINK ) ) );
10f515: 85 c0 test %eax,%eax
10f517: 74 cd je 10f4e6 <IMFS_evaluate_link+0x4e>
10f519: 8b 15 b0 51 12 00 mov 0x1251b0,%edx
10f51f: eb d8 jmp 10f4f9 <IMFS_evaluate_link+0x61>
10f521: 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;
10f524: 66 c7 42 30 00 00 movw $0x0,0x30(%edx)
rtems_set_errno_and_return_minus_one( ELOOP );
10f52a: e8 e5 3d 00 00 call 113314 <__errno>
10f52f: c7 00 5c 00 00 00 movl $0x5c,(%eax)
10f535: b8 ff ff ff ff mov $0xffffffff,%eax
*/
rtems_filesystem_link_counts = 0;
return result;
}
10f53a: 8d 65 f4 lea -0xc(%ebp),%esp
10f53d: 5b pop %ebx
10f53e: 5e pop %esi
10f53f: 5f pop %edi
10f540: c9 leave
10f541: c3 ret
0010f114 <IMFS_evaluate_permission>:
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
10f114: 55 push %ebp
10f115: 89 e5 mov %esp,%ebp
10f117: 57 push %edi
10f118: 56 push %esi
10f119: 53 push %ebx
10f11a: 83 ec 0c sub $0xc,%esp
10f11d: 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 ) )
10f120: f7 c6 f8 ff ff ff test $0xfffffff8,%esi
10f126: 75 44 jne 10f16c <IMFS_evaluate_permission+0x58><== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
jnode = node->node_access;
10f128: 8b 45 08 mov 0x8(%ebp),%eax
10f12b: 8b 18 mov (%eax),%ebx
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
10f12d: e8 1a 0c 00 00 call 10fd4c <geteuid>
10f132: 89 c7 mov %eax,%edi
st_gid = getegid();
10f134: e8 03 0c 00 00 call 10fd3c <getegid>
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
10f139: 66 39 7b 3c cmp %di,0x3c(%ebx)
10f13d: 74 1d je 10f15c <IMFS_evaluate_permission+0x48>
flags_to_test <<= 6;
else if ( st_gid == jnode->st_gid )
10f13f: 66 39 43 3e cmp %ax,0x3e(%ebx)
10f143: 74 1f je 10f164 <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 )
10f145: 8b 43 30 mov 0x30(%ebx),%eax
10f148: 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 );
10f14a: 39 c6 cmp %eax,%esi
10f14c: 0f 94 c0 sete %al
10f14f: 0f b6 c0 movzbl %al,%eax
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
return 1;
return 0;
}
10f152: 83 c4 0c add $0xc,%esp
10f155: 5b pop %ebx
10f156: 5e pop %esi
10f157: 5f pop %edi
10f158: c9 leave
10f159: c3 ret
10f15a: 66 90 xchg %ax,%ax
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
flags_to_test <<= 6;
10f15c: c1 e6 06 shl $0x6,%esi
10f15f: eb e4 jmp 10f145 <IMFS_evaluate_permission+0x31>
10f161: 8d 76 00 lea 0x0(%esi),%esi
else if ( st_gid == jnode->st_gid )
flags_to_test <<= 3;
10f164: c1 e6 03 shl $0x3,%esi
10f167: eb dc jmp 10f145 <IMFS_evaluate_permission+0x31>
10f169: 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 );
10f16c: e8 a3 41 00 00 call 113314 <__errno> <== NOT EXECUTED
10f171: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
10f177: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10f17c: eb d4 jmp 10f152 <IMFS_evaluate_permission+0x3e><== NOT EXECUTED
0010f41c <IMFS_evaluate_sym_link>:
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
10f41c: 55 push %ebp
10f41d: 89 e5 mov %esp,%ebp
10f41f: 57 push %edi
10f420: 56 push %esi
10f421: 53 push %ebx
10f422: 83 ec 20 sub $0x20,%esp
10f425: 8b 5d 08 mov 0x8(%ebp),%ebx
10f428: 8b 75 0c mov 0xc(%ebp),%esi
IMFS_jnode_t *jnode = node->node_access;
10f42b: 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;
10f42d: 8b 47 08 mov 0x8(%edi),%eax
10f430: 89 03 mov %eax,(%ebx)
rtems_filesystem_get_sym_start_loc(
10f432: 53 push %ebx
10f433: 8d 45 e4 lea -0x1c(%ebp),%eax
10f436: 50 push %eax
10f437: ff 77 50 pushl 0x50(%edi)
10f43a: e8 f9 0d 00 00 call 110238 <rtems_filesystem_get_sym_start_loc>
);
/*
* Use eval path to evaluate the path of the symbolic link.
*/
result = IMFS_eval_path(
10f43f: 8b 57 50 mov 0x50(%edi),%edx
10f442: 03 55 e4 add -0x1c(%ebp),%edx
10f445: 31 c0 xor %eax,%eax
10f447: b9 ff ff ff ff mov $0xffffffff,%ecx
10f44c: 89 d7 mov %edx,%edi
10f44e: f2 ae repnz scas %es:(%edi),%al
10f450: f7 d1 not %ecx
10f452: 49 dec %ecx
10f453: 53 push %ebx
10f454: 56 push %esi
10f455: 51 push %ecx
10f456: 52 push %edx
10f457: e8 68 fd ff ff call 10f1c4 <IMFS_eval_path>
10f45c: 89 c7 mov %eax,%edi
strlen( &jnode->info.sym_link.name[i] ),
flags,
node
);
IMFS_Set_handlers( node );
10f45e: 83 c4 14 add $0x14,%esp
10f461: 53 push %ebx
10f462: e8 51 fc ff ff call 10f0b8 <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
10f467: 58 pop %eax
10f468: 5a pop %edx
10f469: 56 push %esi
10f46a: 53 push %ebx
10f46b: e8 a4 fc ff ff call 10f114 <IMFS_evaluate_permission>
10f470: 83 c4 10 add $0x10,%esp
10f473: 85 c0 test %eax,%eax
10f475: 74 0d je 10f484 <IMFS_evaluate_sym_link+0x68>
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10f477: 89 f8 mov %edi,%eax
10f479: 8d 65 f4 lea -0xc(%ebp),%esp
10f47c: 5b pop %ebx
10f47d: 5e pop %esi
10f47e: 5f pop %edi
10f47f: c9 leave
10f480: c3 ret
10f481: 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 );
10f484: e8 8b 3e 00 00 call 113314 <__errno>
10f489: c7 00 0d 00 00 00 movl $0xd,(%eax)
10f48f: bf ff ff ff ff mov $0xffffffff,%edi
10f494: eb e1 jmp 10f477 <IMFS_evaluate_sym_link+0x5b>
00112a94 <IMFS_fchmod>:
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
112a94: 55 push %ebp
112a95: 89 e5 mov %esp,%ebp
112a97: 53 push %ebx
112a98: 83 ec 14 sub $0x14,%esp
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = loc->node_access;
112a9b: 8b 45 08 mov 0x8(%ebp),%eax
112a9e: 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();
112aa0: e8 a7 d2 ff ff call 10fd4c <geteuid>
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
112aa5: 66 39 43 3c cmp %ax,0x3c(%ebx)
112aa9: 74 05 je 112ab0 <IMFS_fchmod+0x1c>
112aab: 66 85 c0 test %ax,%ax
112aae: 75 34 jne 112ae4 <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);
112ab0: 8b 45 0c mov 0xc(%ebp),%eax
112ab3: 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);
112ab8: 8b 53 30 mov 0x30(%ebx),%edx
112abb: 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);
112ac1: 09 d0 or %edx,%eax
112ac3: 89 43 30 mov %eax,0x30(%ebx)
IMFS_update_ctime( jnode );
112ac6: 83 ec 08 sub $0x8,%esp
112ac9: 6a 00 push $0x0
112acb: 8d 45 f0 lea -0x10(%ebp),%eax
112ace: 50 push %eax
112acf: e8 5c 56 ff ff call 108130 <gettimeofday>
112ad4: 8b 45 f0 mov -0x10(%ebp),%eax
112ad7: 89 43 48 mov %eax,0x48(%ebx)
return 0;
112ada: 83 c4 10 add $0x10,%esp
112add: 31 c0 xor %eax,%eax
}
112adf: 8b 5d fc mov -0x4(%ebp),%ebx
112ae2: c9 leave
112ae3: 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 );
112ae4: e8 2b 08 00 00 call 113314 <__errno>
112ae9: c7 00 01 00 00 00 movl $0x1,(%eax)
112aef: b8 ff ff ff ff mov $0xffffffff,%eax
112af4: eb e9 jmp 112adf <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 f6 97 00 00 call 1122a0 <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 26 ca 00 00 call 11550c <__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 a1 98 00 00 call 112300 <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 99 ca 00 00 call 11550c <__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 8b 95 00 00 call 1120a0 <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 <== NOT EXECUTED
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 b8 c9 00 00 call 11550c <__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>
0010f8a8 <IMFS_find_match_in_dir>:
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
10f8a8: 55 push %ebp
10f8a9: 89 e5 mov %esp,%ebp
10f8ab: 57 push %edi
10f8ac: 56 push %esi
10f8ad: 53 push %ebx
10f8ae: 83 ec 0c sub $0xc,%esp
10f8b1: 8b 45 08 mov 0x8(%ebp),%eax
10f8b4: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
10f8b7: bf f0 0f 12 00 mov $0x120ff0,%edi
10f8bc: b9 02 00 00 00 mov $0x2,%ecx
10f8c1: 89 de mov %ebx,%esi
10f8c3: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10f8c5: 74 13 je 10f8da <IMFS_find_match_in_dir+0x32><== NEVER TAKEN
return directory;
if ( !strcmp( name, dotdotname ) )
10f8c7: bf f2 0f 12 00 mov $0x120ff2,%edi
10f8cc: b9 03 00 00 00 mov $0x3,%ecx
10f8d1: 89 de mov %ebx,%esi
10f8d3: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10f8d5: 75 0d jne 10f8e4 <IMFS_find_match_in_dir+0x3c><== ALWAYS TAKEN
return directory->Parent;
10f8d7: 8b 40 08 mov 0x8(%eax),%eax
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
10f8da: 8d 65 f4 lea -0xc(%ebp),%esp
10f8dd: 5b pop %ebx
10f8de: 5e pop %esi
10f8df: 5f pop %edi
10f8e0: c9 leave
10f8e1: c3 ret
10f8e2: 66 90 xchg %ax,%ax
10f8e4: 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));
10f8e7: 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 );
10f8ea: 39 fe cmp %edi,%esi
10f8ec: 75 08 jne 10f8f6 <IMFS_find_match_in_dir+0x4e>
10f8ee: eb 20 jmp 10f910 <IMFS_find_match_in_dir+0x68>
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
10f8f0: 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 );
10f8f2: 39 fe cmp %edi,%esi
10f8f4: 74 1a je 10f910 <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 ) )
10f8f6: 8d 46 0c lea 0xc(%esi),%eax
10f8f9: 83 ec 08 sub $0x8,%esp
10f8fc: 50 push %eax
10f8fd: 53 push %ebx
10f8fe: e8 89 46 00 00 call 113f8c <strcmp>
10f903: 83 c4 10 add $0x10,%esp
10f906: 85 c0 test %eax,%eax
10f908: 75 e6 jne 10f8f0 <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;
10f90a: 89 f0 mov %esi,%eax
10f90c: eb cc jmp 10f8da <IMFS_find_match_in_dir+0x32>
10f90e: 66 90 xchg %ax,%ax
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
10f910: 31 c0 xor %eax,%eax
10f912: eb c6 jmp 10f8da <IMFS_find_match_in_dir+0x32>
0010f808 <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
)
{
10f808: 55 push %ebp
10f809: 89 e5 mov %esp,%ebp
10f80b: 57 push %edi
10f80c: 56 push %esi
10f80d: 53 push %ebx
10f80e: 83 ec 3c sub $0x3c,%esp
10f811: 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;
10f814: 8b 58 1c mov 0x1c(%eax),%ebx
loc = temp_mt_entry->mt_fs_root;
10f817: 8d 55 d4 lea -0x2c(%ebp),%edx
10f81a: 89 55 c4 mov %edx,-0x3c(%ebp)
10f81d: 8d 70 1c lea 0x1c(%eax),%esi
10f820: b9 05 00 00 00 mov $0x5,%ecx
10f825: 89 d7 mov %edx,%edi
10f827: 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;
10f829: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
do {
next = jnode->Parent;
10f830: 8b 73 08 mov 0x8(%ebx),%esi
loc.node_access = (void *)jnode;
10f833: 89 5d d4 mov %ebx,-0x2c(%ebp)
IMFS_Set_handlers( &loc );
10f836: 83 ec 0c sub $0xc,%esp
10f839: 8d 45 d4 lea -0x2c(%ebp),%eax
10f83c: 50 push %eax
10f83d: e8 76 f8 ff ff call 10f0b8 <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
10f842: 83 c4 10 add $0x10,%esp
10f845: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10f849: 75 31 jne 10f87c <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 );
10f84b: 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 ) ) {
10f84e: 39 43 50 cmp %eax,0x50(%ebx)
10f851: 74 42 je 10f895 <IMFS_fsunmount+0x8d>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
}
if ( jnode != NULL ) {
10f853: 85 db test %ebx,%ebx
10f855: 74 19 je 10f870 <IMFS_fsunmount+0x68>
if ( jnode->type == IMFS_DIRECTORY ) {
10f857: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10f85b: 75 d3 jne 10f830 <IMFS_fsunmount+0x28> <== NEVER TAKEN
}
}
} while (jnode != NULL);
return 0;
}
10f85d: 8b 43 50 mov 0x50(%ebx),%eax
10f860: 8d 53 54 lea 0x54(%ebx),%edx
return -1;
jnode = next;
}
if ( jnode != NULL ) {
if ( jnode->type == IMFS_DIRECTORY ) {
if ( jnode_has_children( jnode ) )
10f863: 39 d0 cmp %edx,%eax
10f865: 74 c9 je 10f830 <IMFS_fsunmount+0x28>
jnode = jnode_get_first_child( jnode );
10f867: 89 c3 mov %eax,%ebx
}
}
} while (jnode != NULL);
10f869: 85 c0 test %eax,%eax
10f86b: 75 c3 jne 10f830 <IMFS_fsunmount+0x28> <== ALWAYS TAKEN
10f86d: 8d 76 00 lea 0x0(%esi),%esi
return 0;
10f870: 31 c0 xor %eax,%eax
}
10f872: 8d 65 f4 lea -0xc(%ebp),%esp
10f875: 5b pop %ebx
10f876: 5e pop %esi
10f877: 5f pop %edi
10f878: c9 leave
10f879: c3 ret
10f87a: 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 );
10f87c: 83 ec 08 sub $0x8,%esp
10f87f: 8d 55 d4 lea -0x2c(%ebp),%edx
10f882: 52 push %edx
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
10f883: 6a 00 push $0x0
10f885: e8 72 83 ff ff call 107bfc <IMFS_unlink>
if (result != 0)
10f88a: 83 c4 10 add $0x10,%esp
10f88d: 85 c0 test %eax,%eax
10f88f: 75 0d jne 10f89e <IMFS_fsunmount+0x96> <== NEVER TAKEN
return -1;
jnode = next;
10f891: 89 f3 mov %esi,%ebx
10f893: eb be jmp 10f853 <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 );
10f895: 83 ec 08 sub $0x8,%esp
10f898: 8d 45 d4 lea -0x2c(%ebp),%eax
10f89b: 50 push %eax
10f89c: eb e5 jmp 10f883 <IMFS_fsunmount+0x7b>
if (result != 0)
return -1;
10f89e: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10f8a3: eb cd jmp 10f872 <IMFS_fsunmount+0x6a> <== NOT EXECUTED
0010f914 <IMFS_get_token>:
const char *path,
int pathlen,
char *token,
int *token_len
)
{
10f914: 55 push %ebp
10f915: 89 e5 mov %esp,%ebp
10f917: 57 push %edi
10f918: 56 push %esi
10f919: 53 push %ebx
10f91a: 83 ec 1c sub $0x1c,%esp
10f91d: 8b 7d 08 mov 0x8(%ebp),%edi
10f920: 8b 5d 10 mov 0x10(%ebp),%ebx
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
10f923: 8a 17 mov (%edi),%dl
int pathlen,
char *token,
int *token_len
)
{
register int i = 0;
10f925: 31 f6 xor %esi,%esi
10f927: 89 7d e4 mov %edi,-0x1c(%ebp)
10f92a: 89 df mov %ebx,%edi
10f92c: 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) ) {
10f92e: eb 07 jmp 10f937 <IMFS_get_token+0x23>
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
10f930: 46 inc %esi
10f931: 8b 45 e4 mov -0x1c(%ebp),%eax
10f934: 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) ) {
10f937: 83 ec 0c sub $0xc,%esp
10f93a: 0f be c3 movsbl %bl,%eax
10f93d: 50 push %eax
10f93e: e8 d5 95 ff ff call 108f18 <rtems_filesystem_is_separator>
10f943: 83 c4 10 add $0x10,%esp
10f946: 85 c0 test %eax,%eax
10f948: 75 1a jne 10f964 <IMFS_get_token+0x50>
10f94a: 3b 75 0c cmp 0xc(%ebp),%esi
10f94d: 7d 15 jge 10f964 <IMFS_get_token+0x50>
token[i] = c;
10f94f: 88 1c 37 mov %bl,(%edi,%esi,1)
if ( i == IMFS_NAME_MAX )
10f952: 83 fe 20 cmp $0x20,%esi
10f955: 75 d9 jne 10f930 <IMFS_get_token+0x1c>
return IMFS_INVALID_TOKEN;
10f957: b8 04 00 00 00 mov $0x4,%eax
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
}
return type;
}
10f95c: 8d 65 f4 lea -0xc(%ebp),%esp
10f95f: 5b pop %ebx
10f960: 5e pop %esi
10f961: 5f pop %edi
10f962: c9 leave
10f963: c3 ret
10f964: 88 da mov %bl,%dl
10f966: 89 fb mov %edi,%ebx
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
10f968: 85 f6 test %esi,%esi
10f96a: 75 25 jne 10f991 <IMFS_get_token+0x7d>
token[i] = c;
10f96c: 88 17 mov %dl,(%edi)
if ( (token[i] != '\0') && pathlen ) {
10f96e: 84 d2 test %dl,%dl
10f970: 74 16 je 10f988 <IMFS_get_token+0x74>
10f972: 8b 45 0c mov 0xc(%ebp),%eax
10f975: 85 c0 test %eax,%eax
10f977: 74 0f je 10f988 <IMFS_get_token+0x74>
i++;
type = IMFS_CURRENT_DIR;
10f979: b8 01 00 00 00 mov $0x1,%eax
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
10f97e: be 01 00 00 00 mov $0x1,%esi
10f983: eb 05 jmp 10f98a <IMFS_get_token+0x76>
10f985: 8d 76 00 lea 0x0(%esi),%esi
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
10f988: 31 c0 xor %eax,%eax
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
10f98a: 8b 55 14 mov 0x14(%ebp),%edx
10f98d: 89 32 mov %esi,(%edx)
10f98f: eb cb jmp 10f95c <IMFS_get_token+0x48>
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
10f991: 80 7c 37 ff 00 cmpb $0x0,-0x1(%edi,%esi,1)
10f996: 74 04 je 10f99c <IMFS_get_token+0x88> <== NEVER TAKEN
token[i] = '\0';
10f998: c6 04 37 00 movb $0x0,(%edi,%esi,1)
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
10f99c: 8b 45 14 mov 0x14(%ebp),%eax
10f99f: 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 )
10f9a1: bf f5 0f 12 00 mov $0x120ff5,%edi
10f9a6: b9 03 00 00 00 mov $0x3,%ecx
10f9ab: 89 de mov %ebx,%esi
10f9ad: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10f9af: 75 0f jne 10f9c0 <IMFS_get_token+0xac>
type = IMFS_UP_DIR;
10f9b1: b8 02 00 00 00 mov $0x2,%eax
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
}
return type;
}
10f9b6: 8d 65 f4 lea -0xc(%ebp),%esp
10f9b9: 5b pop %ebx
10f9ba: 5e pop %esi
10f9bb: 5f pop %edi
10f9bc: c9 leave
10f9bd: c3 ret
10f9be: 66 90 xchg %ax,%ax
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
10f9c0: bf f6 0f 12 00 mov $0x120ff6,%edi
10f9c5: b9 02 00 00 00 mov $0x2,%ecx
10f9ca: 89 de mov %ebx,%esi
10f9cc: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10f9ce: 0f 97 c0 seta %al
10f9d1: 0f 92 c2 setb %dl
10f9d4: 28 d0 sub %dl,%al
10f9d6: 0f be c0 movsbl %al,%eax
10f9d9: 83 f8 01 cmp $0x1,%eax
10f9dc: 19 c0 sbb %eax,%eax
10f9de: 83 e0 fe and $0xfffffffe,%eax
10f9e1: 83 c0 03 add $0x3,%eax
type = IMFS_CURRENT_DIR;
}
return type;
}
10f9e4: 8d 65 f4 lea -0xc(%ebp),%esp
10f9e7: 5b pop %ebx
10f9e8: 5e pop %esi
10f9e9: 5f pop %edi
10f9ea: c9 leave
10f9eb: 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 b0 31 12 00 mov 0x1231b0,%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 c0 70 12 00 mov %ecx,0x1270c0
/*
* 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 ff 77 00 00 call 10f084 <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 0f 12 00 mov $0x120fa0,%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 c4 70 12 00 mov 0x1270c4,%ecx
1078c7: 89 08 mov %ecx,(%eax)
1078c9: 41 inc %ecx
1078ca: 89 0d c4 70 12 00 mov %ecx,0x1270c4
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 0c ba 00 00 call 113314 <__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 c5 7f 00 00 call 10f914 <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 e7 75 00 00 call 10ef4c <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 77 b9 00 00 call 113314 <__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 65 b9 00 00 call 113314 <__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>
00111e6c <IMFS_memfile_addblock>:
*/
MEMFILE_STATIC int IMFS_memfile_addblock(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
111e6c: 55 push %ebp
111e6d: 89 e5 mov %esp,%ebp
111e6f: 53 push %ebx
111e70: 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 );
111e73: 6a 01 push $0x1
111e75: ff 75 0c pushl 0xc(%ebp)
111e78: ff 75 08 pushl 0x8(%ebp)
111e7b: e8 28 fc ff ff call 111aa8 <IMFS_memfile_get_block_pointer>
111e80: 89 c3 mov %eax,%ebx
if ( *block_entry_ptr )
111e82: 83 c4 10 add $0x10,%esp
111e85: 8b 00 mov (%eax),%eax
111e87: 85 c0 test %eax,%eax
111e89: 74 09 je 111e94 <IMFS_memfile_addblock+0x28>
return 0;
111e8b: 31 c0 xor %eax,%eax
if ( !memory )
return 1;
*block_entry_ptr = memory;
return 0;
}
111e8d: 8b 5d fc mov -0x4(%ebp),%ebx
111e90: c9 leave
111e91: c3 ret
111e92: 66 90 xchg %ax,%ax
return 0;
/*
* There is no memory for this block number so allocate it.
*/
memory = memfile_alloc_block();
111e94: e8 eb fb ff ff call 111a84 <memfile_alloc_block>
if ( !memory )
111e99: 85 c0 test %eax,%eax
111e9b: 74 07 je 111ea4 <IMFS_memfile_addblock+0x38>
return 1;
*block_entry_ptr = memory;
111e9d: 89 03 mov %eax,(%ebx)
return 0;
111e9f: 31 c0 xor %eax,%eax
111ea1: eb ea jmp 111e8d <IMFS_memfile_addblock+0x21>
111ea3: 90 nop
/*
* There is no memory for this block number so allocate it.
*/
memory = memfile_alloc_block();
if ( !memory )
return 1;
111ea4: b8 01 00 00 00 mov $0x1,%eax
111ea9: eb e2 jmp 111e8d <IMFS_memfile_addblock+0x21>
001120ac <IMFS_memfile_extend>:
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
1120ac: 55 push %ebp
1120ad: 89 e5 mov %esp,%ebp
1120af: 57 push %edi
1120b0: 56 push %esi
1120b1: 53 push %ebx
1120b2: 83 ec 2c sub $0x2c,%esp
1120b5: 8b 5d 08 mov 0x8(%ebp),%ebx
1120b8: 8b 45 0c mov 0xc(%ebp),%eax
1120bb: 8b 55 10 mov 0x10(%ebp),%edx
1120be: 89 45 d8 mov %eax,-0x28(%ebp)
1120c1: 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 )
1120c4: a1 c0 70 12 00 mov 0x1270c0,%eax
1120c9: 89 c1 mov %eax,%ecx
1120cb: c1 e9 02 shr $0x2,%ecx
1120ce: 8d 51 01 lea 0x1(%ecx),%edx
1120d1: 0f af d1 imul %ecx,%edx
1120d4: 42 inc %edx
1120d5: 0f af d1 imul %ecx,%edx
1120d8: 4a dec %edx
1120d9: 0f af d0 imul %eax,%edx
1120dc: 31 c9 xor %ecx,%ecx
1120de: 3b 4d dc cmp -0x24(%ebp),%ecx
1120e1: 7f 1a jg 1120fd <IMFS_memfile_extend+0x51><== NEVER TAKEN
1120e3: 7d 13 jge 1120f8 <IMFS_memfile_extend+0x4c><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
1120e5: e8 2a 12 00 00 call 113314 <__errno>
1120ea: c7 00 16 00 00 00 movl $0x16,(%eax)
1120f0: b8 ff ff ff ff mov $0xffffffff,%eax
1120f5: eb 19 jmp 112110 <IMFS_memfile_extend+0x64>
1120f7: 90 nop
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
1120f8: 3b 55 d8 cmp -0x28(%ebp),%edx
1120fb: 76 e8 jbe 1120e5 <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 )
1120fd: 8b 53 50 mov 0x50(%ebx),%edx
112100: 8b 4b 54 mov 0x54(%ebx),%ecx
112103: 89 55 e0 mov %edx,-0x20(%ebp)
112106: 89 4d e4 mov %ecx,-0x1c(%ebp)
112109: 39 4d dc cmp %ecx,-0x24(%ebp)
11210c: 7d 0a jge 112118 <IMFS_memfile_extend+0x6c><== ALWAYS TAKEN
return 0;
11210e: 31 c0 xor %eax,%eax
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
return 0;
}
112110: 8d 65 f4 lea -0xc(%ebp),%esp
112113: 5b pop %ebx
112114: 5e pop %esi
112115: 5f pop %edi
112116: c9 leave
112117: 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 )
112118: 7f 05 jg 11211f <IMFS_memfile_extend+0x73><== NEVER TAKEN
11211a: 39 55 d8 cmp %edx,-0x28(%ebp)
11211d: 76 ef jbe 11210e <IMFS_memfile_extend+0x62>
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
11211f: 89 45 d0 mov %eax,-0x30(%ebp)
112122: 89 c1 mov %eax,%ecx
112124: c1 f9 1f sar $0x1f,%ecx
112127: 89 4d d4 mov %ecx,-0x2c(%ebp)
11212a: ff 75 d4 pushl -0x2c(%ebp)
11212d: ff 75 d0 pushl -0x30(%ebp)
112130: ff 75 dc pushl -0x24(%ebp)
112133: ff 75 d8 pushl -0x28(%ebp)
112136: e8 29 c1 00 00 call 11e264 <__divdi3>
11213b: 83 c4 10 add $0x10,%esp
11213e: 89 c6 mov %eax,%esi
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
112140: ff 75 d4 pushl -0x2c(%ebp)
112143: ff 75 d0 pushl -0x30(%ebp)
112146: ff 75 e4 pushl -0x1c(%ebp)
112149: ff 75 e0 pushl -0x20(%ebp)
11214c: e8 13 c1 00 00 call 11e264 <__divdi3>
112151: 83 c4 10 add $0x10,%esp
112154: 89 45 e0 mov %eax,-0x20(%ebp)
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
112157: 39 c6 cmp %eax,%esi
112159: 72 51 jb 1121ac <IMFS_memfile_extend+0x100><== NEVER TAKEN
11215b: 89 c7 mov %eax,%edi
11215d: eb 06 jmp 112165 <IMFS_memfile_extend+0xb9>
11215f: 90 nop
112160: 47 inc %edi
112161: 39 fe cmp %edi,%esi
112163: 72 47 jb 1121ac <IMFS_memfile_extend+0x100>
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
112165: 83 ec 08 sub $0x8,%esp
112168: 57 push %edi
112169: 53 push %ebx
11216a: e8 fd fc ff ff call 111e6c <IMFS_memfile_addblock>
11216f: 83 c4 10 add $0x10,%esp
112172: 85 c0 test %eax,%eax
112174: 74 ea je 112160 <IMFS_memfile_extend+0xb4>
for ( ; block>=old_blocks ; block-- ) {
112176: 39 7d e0 cmp %edi,-0x20(%ebp)
112179: 77 17 ja 112192 <IMFS_memfile_extend+0xe6><== NEVER TAKEN
11217b: 8b 75 e0 mov -0x20(%ebp),%esi
11217e: 66 90 xchg %ax,%ax
IMFS_memfile_remove_block( the_jnode, block );
112180: 83 ec 08 sub $0x8,%esp
112183: 57 push %edi
112184: 53 push %ebx
112185: e8 f6 fe ff ff call 112080 <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-- ) {
11218a: 4f dec %edi
11218b: 83 c4 10 add $0x10,%esp
11218e: 39 fe cmp %edi,%esi
112190: 76 ee jbe 112180 <IMFS_memfile_extend+0xd4>
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
112192: e8 7d 11 00 00 call 113314 <__errno>
112197: c7 00 1c 00 00 00 movl $0x1c,(%eax)
11219d: b8 ff ff ff ff mov $0xffffffff,%eax
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
return 0;
}
1121a2: 8d 65 f4 lea -0xc(%ebp),%esp
1121a5: 5b pop %ebx
1121a6: 5e pop %esi
1121a7: 5f pop %edi
1121a8: c9 leave
1121a9: c3 ret
1121aa: 66 90 xchg %ax,%ax
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
1121ac: 8b 45 d8 mov -0x28(%ebp),%eax
1121af: 8b 55 dc mov -0x24(%ebp),%edx
1121b2: 89 43 50 mov %eax,0x50(%ebx)
1121b5: 89 53 54 mov %edx,0x54(%ebx)
return 0;
1121b8: 31 c0 xor %eax,%eax
}
1121ba: 8d 65 f4 lea -0xc(%ebp),%esp
1121bd: 5b pop %ebx
1121be: 5e pop %esi
1121bf: 5f pop %edi
1121c0: c9 leave
1121c1: c3 ret
00111aa8 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
111aa8: 55 push %ebp
111aa9: 89 e5 mov %esp,%ebp
111aab: 57 push %edi
111aac: 56 push %esi
111aad: 53 push %ebx
111aae: 83 ec 1c sub $0x1c,%esp
111ab1: 8b 5d 08 mov 0x8(%ebp),%ebx
111ab4: 8b 75 0c mov 0xc(%ebp),%esi
111ab7: 8b 7d 10 mov 0x10(%ebp),%edi
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
111aba: 8b 0d c0 70 12 00 mov 0x1270c0,%ecx
111ac0: c1 e9 02 shr $0x2,%ecx
111ac3: 8d 41 ff lea -0x1(%ecx),%eax
111ac6: 39 c6 cmp %eax,%esi
111ac8: 77 1a ja 111ae4 <IMFS_memfile_get_block_pointer+0x3c>
p = info->indirect;
111aca: 8b 43 58 mov 0x58(%ebx),%eax
if ( malloc_it ) {
111acd: 85 ff test %edi,%edi
111acf: 74 53 je 111b24 <IMFS_memfile_get_block_pointer+0x7c>
if ( !p ) {
111ad1: 85 c0 test %eax,%eax
111ad3: 0f 84 b6 00 00 00 je 111b8f <IMFS_memfile_get_block_pointer+0xe7>
}
if ( !p )
return 0;
return &info->indirect[ my_block ];
111ad9: 8d 04 b0 lea (%eax,%esi,4),%eax
/*
* This means the requested block number is out of range.
*/
return 0;
}
111adc: 83 c4 1c add $0x1c,%esp
111adf: 5b pop %ebx
111ae0: 5e pop %esi
111ae1: 5f pop %edi
111ae2: c9 leave
111ae3: c3 ret
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
111ae4: 8d 41 01 lea 0x1(%ecx),%eax
111ae7: 0f af c1 imul %ecx,%eax
111aea: 8d 50 ff lea -0x1(%eax),%edx
111aed: 39 d6 cmp %edx,%esi
111aef: 77 3b ja 111b2c <IMFS_memfile_get_block_pointer+0x84>
my_block -= FIRST_DOUBLY_INDIRECT;
111af1: 29 ce sub %ecx,%esi
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
111af3: 89 f0 mov %esi,%eax
111af5: 31 d2 xor %edx,%edx
111af7: f7 f1 div %ecx
111af9: 89 c6 mov %eax,%esi
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
p = info->doubly_indirect;
111afb: 8b 43 5c mov 0x5c(%ebx),%eax
if ( malloc_it ) {
111afe: 85 ff test %edi,%edi
111b00: 74 7e je 111b80 <IMFS_memfile_get_block_pointer+0xd8>
if ( !p ) {
111b02: 85 c0 test %eax,%eax
111b04: 0f 84 96 00 00 00 je 111ba0 <IMFS_memfile_get_block_pointer+0xf8>
if ( !p )
return 0;
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
111b0a: 8d 1c b0 lea (%eax,%esi,4),%ebx
111b0d: 8b 03 mov (%ebx),%eax
if ( !p1 ) {
111b0f: 85 c0 test %eax,%eax
111b11: 0f 84 a4 00 00 00 je 111bbb <IMFS_memfile_get_block_pointer+0x113>
p = (block_p *)p[ doubly ];
if ( !p )
return 0;
return (block_p *)&p[ singly ];
111b17: 8d 04 90 lea (%eax,%edx,4),%eax
/*
* This means the requested block number is out of range.
*/
return 0;
}
111b1a: 83 c4 1c add $0x1c,%esp
111b1d: 5b pop %ebx
111b1e: 5e pop %esi
111b1f: 5f pop %edi
111b20: c9 leave
111b21: c3 ret
111b22: 66 90 xchg %ax,%ax
info->indirect = p;
}
return &info->indirect[ my_block ];
}
if ( !p )
111b24: 85 c0 test %eax,%eax
111b26: 75 b1 jne 111ad9 <IMFS_memfile_get_block_pointer+0x31><== ALWAYS TAKEN
if ( !p )
return 0;
p1 = (block_p *) p[ triply ];
if ( !p1 )
return 0;
111b28: 31 c0 xor %eax,%eax
111b2a: eb ee jmp 111b1a <IMFS_memfile_get_block_pointer+0x72><== NOT EXECUTED
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
111b2c: 8d 50 01 lea 0x1(%eax),%edx
111b2f: 0f af d1 imul %ecx,%edx
111b32: 4a dec %edx
111b33: 39 d6 cmp %edx,%esi
111b35: 77 f1 ja 111b28 <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
my_block -= FIRST_TRIPLY_INDIRECT;
111b37: 29 c6 sub %eax,%esi
111b39: 89 f0 mov %esi,%eax
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
111b3b: 31 d2 xor %edx,%edx
111b3d: f7 f1 div %ecx
111b3f: 89 55 e4 mov %edx,-0x1c(%ebp)
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
111b42: 31 d2 xor %edx,%edx
111b44: f7 f1 div %ecx
111b46: 89 c6 mov %eax,%esi
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
p = info->triply_indirect;
111b48: 8b 4b 60 mov 0x60(%ebx),%ecx
if ( malloc_it ) {
111b4b: 85 ff test %edi,%edi
111b4d: 0f 84 82 00 00 00 je 111bd5 <IMFS_memfile_get_block_pointer+0x12d>
if ( !p ) {
111b53: 85 c9 test %ecx,%ecx
111b55: 0f 84 9b 00 00 00 je 111bf6 <IMFS_memfile_get_block_pointer+0x14e>
if ( !p )
return 0;
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
111b5b: 8d 1c b1 lea (%ecx,%esi,4),%ebx
111b5e: 8b 0b mov (%ebx),%ecx
if ( !p1 ) {
111b60: 85 c9 test %ecx,%ecx
111b62: 0f 84 c5 00 00 00 je 111c2d <IMFS_memfile_get_block_pointer+0x185>
if ( !p1 )
return 0;
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
111b68: 8d 1c 91 lea (%ecx,%edx,4),%ebx
111b6b: 8b 13 mov (%ebx),%edx
if ( !p2 ) {
111b6d: 85 d2 test %edx,%edx
111b6f: 0f 84 a0 00 00 00 je 111c15 <IMFS_memfile_get_block_pointer+0x16d>
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
return 0;
return (block_p *)&p2[ singly ];
111b75: 8b 4d e4 mov -0x1c(%ebp),%ecx
111b78: 8d 04 8a lea (%edx,%ecx,4),%eax
111b7b: eb 9d jmp 111b1a <IMFS_memfile_get_block_pointer+0x72>
111b7d: 8d 76 00 lea 0x0(%esi),%esi
}
return (block_p *)&p1[ singly ];
}
if ( !p )
111b80: 85 c0 test %eax,%eax
111b82: 74 a4 je 111b28 <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
return 0;
p = (block_p *)p[ doubly ];
111b84: 8b 04 b0 mov (%eax,%esi,4),%eax
if ( !p )
111b87: 85 c0 test %eax,%eax
111b89: 75 8c jne 111b17 <IMFS_memfile_get_block_pointer+0x6f><== ALWAYS TAKEN
if ( !p )
return 0;
p1 = (block_p *) p[ triply ];
if ( !p1 )
return 0;
111b8b: 31 c0 xor %eax,%eax
111b8d: eb 8b jmp 111b1a <IMFS_memfile_get_block_pointer+0x72><== NOT EXECUTED
p = info->indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
111b8f: e8 f0 fe ff ff call 111a84 <memfile_alloc_block>
if ( !p )
111b94: 85 c0 test %eax,%eax
111b96: 74 90 je 111b28 <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
return 0;
info->indirect = p;
111b98: 89 43 58 mov %eax,0x58(%ebx)
111b9b: e9 39 ff ff ff jmp 111ad9 <IMFS_memfile_get_block_pointer+0x31>
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
111ba0: 89 55 e0 mov %edx,-0x20(%ebp)
111ba3: e8 dc fe ff ff call 111a84 <memfile_alloc_block>
if ( !p )
111ba8: 85 c0 test %eax,%eax
111baa: 8b 55 e0 mov -0x20(%ebp),%edx
111bad: 0f 84 75 ff ff ff je 111b28 <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
return 0;
info->doubly_indirect = p;
111bb3: 89 43 5c mov %eax,0x5c(%ebx)
111bb6: e9 4f ff ff ff jmp 111b0a <IMFS_memfile_get_block_pointer+0x62>
}
p1 = (block_p *)p[ doubly ];
if ( !p1 ) {
p1 = memfile_alloc_block();
111bbb: 89 55 e0 mov %edx,-0x20(%ebp)
111bbe: e8 c1 fe ff ff call 111a84 <memfile_alloc_block>
if ( !p1 )
111bc3: 85 c0 test %eax,%eax
111bc5: 8b 55 e0 mov -0x20(%ebp),%edx
111bc8: 0f 84 5a ff ff ff je 111b28 <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
return 0;
p[ doubly ] = (block_p) p1;
111bce: 89 03 mov %eax,(%ebx)
111bd0: e9 42 ff ff ff jmp 111b17 <IMFS_memfile_get_block_pointer+0x6f>
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
}
if ( !p )
111bd5: 85 c9 test %ecx,%ecx
111bd7: 0f 84 4b ff ff ff je 111b28 <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
return 0;
p1 = (block_p *) p[ triply ];
111bdd: 8b 04 81 mov (%ecx,%eax,4),%eax
if ( !p1 )
111be0: 85 c0 test %eax,%eax
111be2: 0f 84 40 ff ff ff je 111b28 <IMFS_memfile_get_block_pointer+0x80><== NEVER TAKEN
return 0;
p2 = (block_p *)p1[ doubly ];
111be8: 8b 14 90 mov (%eax,%edx,4),%edx
if ( !p2 )
return 0;
111beb: 31 c0 xor %eax,%eax
p1 = (block_p *) p[ triply ];
if ( !p1 )
return 0;
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
111bed: 85 d2 test %edx,%edx
111bef: 75 84 jne 111b75 <IMFS_memfile_get_block_pointer+0xcd><== ALWAYS TAKEN
111bf1: e9 24 ff ff ff jmp 111b1a <IMFS_memfile_get_block_pointer+0x72><== NOT EXECUTED
p = info->triply_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
111bf6: 89 55 e0 mov %edx,-0x20(%ebp)
111bf9: e8 86 fe ff ff call 111a84 <memfile_alloc_block>
111bfe: 89 c1 mov %eax,%ecx
if ( !p )
return 0;
111c00: 31 c0 xor %eax,%eax
p = info->triply_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
111c02: 85 c9 test %ecx,%ecx
111c04: 8b 55 e0 mov -0x20(%ebp),%edx
111c07: 0f 84 0d ff ff ff je 111b1a <IMFS_memfile_get_block_pointer+0x72><== NEVER TAKEN
return 0;
info->triply_indirect = p;
111c0d: 89 4b 60 mov %ecx,0x60(%ebx)
111c10: e9 46 ff ff ff jmp 111b5b <IMFS_memfile_get_block_pointer+0xb3>
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
111c15: e8 6a fe ff ff call 111a84 <memfile_alloc_block>
111c1a: 89 c2 mov %eax,%edx
if ( !p2 )
return 0;
111c1c: 31 c0 xor %eax,%eax
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
if ( !p2 )
111c1e: 85 d2 test %edx,%edx
111c20: 0f 84 f4 fe ff ff je 111b1a <IMFS_memfile_get_block_pointer+0x72><== NEVER TAKEN
return 0;
p1[ doubly ] = (block_p) p2;
111c26: 89 13 mov %edx,(%ebx)
111c28: e9 48 ff ff ff jmp 111b75 <IMFS_memfile_get_block_pointer+0xcd>
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
111c2d: 89 55 e0 mov %edx,-0x20(%ebp)
111c30: e8 4f fe ff ff call 111a84 <memfile_alloc_block>
111c35: 89 c1 mov %eax,%ecx
if ( !p1 )
return 0;
111c37: 31 c0 xor %eax,%eax
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
111c39: 85 c9 test %ecx,%ecx
111c3b: 8b 55 e0 mov -0x20(%ebp),%edx
111c3e: 0f 84 d6 fe ff ff je 111b1a <IMFS_memfile_get_block_pointer+0x72><== NEVER TAKEN
return 0;
p[ triply ] = (block_p) p1;
111c44: 89 0b mov %ecx,(%ebx)
111c46: e9 1d ff ff ff jmp 111b68 <IMFS_memfile_get_block_pointer+0xc0>
00111c4c <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
111c4c: 55 push %ebp
111c4d: 89 e5 mov %esp,%ebp
111c4f: 57 push %edi
111c50: 56 push %esi
111c51: 53 push %ebx
111c52: 83 ec 3c sub $0x3c,%esp
111c55: 8b 75 0c mov 0xc(%ebp),%esi
111c58: 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) {
111c5b: 8b 45 08 mov 0x8(%ebp),%eax
111c5e: 83 78 4c 06 cmpl $0x6,0x4c(%eax)
111c62: 0f 84 60 01 00 00 je 111dc8 <IMFS_memfile_read+0x17c>
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
111c68: 89 f0 mov %esi,%eax
if ( last_byte > the_jnode->info.file.size )
111c6a: 8b 55 08 mov 0x8(%ebp),%edx
111c6d: 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;
111c70: 8b 5d 18 mov 0x18(%ebp),%ebx
111c73: 01 f3 add %esi,%ebx
111c75: 89 5d d0 mov %ebx,-0x30(%ebp)
if ( last_byte > the_jnode->info.file.size )
111c78: 31 d2 xor %edx,%edx
111c7a: 8b 5d 08 mov 0x8(%ebp),%ebx
111c7d: 3b 53 54 cmp 0x54(%ebx),%edx
111c80: 0f 8d d2 00 00 00 jge 111d58 <IMFS_memfile_read+0x10c><== ALWAYS TAKEN
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
111c86: 8b 45 18 mov 0x18(%ebp),%eax
111c89: 89 45 cc mov %eax,-0x34(%ebp)
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
111c8c: 8b 15 c0 70 12 00 mov 0x1270c0,%edx
111c92: 89 55 d0 mov %edx,-0x30(%ebp)
111c95: 89 d0 mov %edx,%eax
111c97: 99 cltd
111c98: 89 d3 mov %edx,%ebx
111c9a: 52 push %edx
111c9b: 50 push %eax
111c9c: 57 push %edi
111c9d: 56 push %esi
111c9e: 89 45 c0 mov %eax,-0x40(%ebp)
111ca1: e8 0a c7 00 00 call 11e3b0 <__moddi3>
111ca6: 83 c4 10 add $0x10,%esp
111ca9: 89 45 c8 mov %eax,-0x38(%ebp)
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
111cac: 8b 4d c0 mov -0x40(%ebp),%ecx
111caf: 53 push %ebx
111cb0: 51 push %ecx
111cb1: 57 push %edi
111cb2: 56 push %esi
111cb3: e8 ac c5 00 00 call 11e264 <__divdi3>
111cb8: 83 c4 10 add $0x10,%esp
111cbb: 89 c3 mov %eax,%ebx
if ( start_offset ) {
111cbd: 8b 7d c8 mov -0x38(%ebp),%edi
111cc0: 85 ff test %edi,%edi
111cc2: 0f 84 a0 00 00 00 je 111d68 <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 );
111cc8: 56 push %esi
111cc9: 6a 00 push $0x0
111ccb: 50 push %eax
111ccc: ff 75 08 pushl 0x8(%ebp)
111ccf: e8 d4 fd ff ff call 111aa8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
111cd4: 83 c4 10 add $0x10,%esp
111cd7: 85 c0 test %eax,%eax
111cd9: 0f 84 65 01 00 00 je 111e44 <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;
111cdf: 8b 4d d0 mov -0x30(%ebp),%ecx
111ce2: 2b 4d c8 sub -0x38(%ebp),%ecx
111ce5: 8b 55 cc mov -0x34(%ebp),%edx
111ce8: 39 ca cmp %ecx,%edx
111cea: 0f 87 3c 01 00 00 ja 111e2c <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 );
111cf0: 8b 75 c8 mov -0x38(%ebp),%esi
111cf3: 03 30 add (%eax),%esi
dest += to_copy;
111cf5: 8b 7d 14 mov 0x14(%ebp),%edi
111cf8: 89 d1 mov %edx,%ecx
111cfa: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
111cfc: 89 7d c8 mov %edi,-0x38(%ebp)
block++;
111cff: 43 inc %ebx
my_length -= to_copy;
111d00: 29 55 cc sub %edx,-0x34(%ebp)
111d03: a1 c0 70 12 00 mov 0x1270c0,%eax
111d08: 89 45 d0 mov %eax,-0x30(%ebp)
copied += to_copy;
111d0b: 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 ) {
111d0e: 8b 4d d0 mov -0x30(%ebp),%ecx
111d11: 39 4d cc cmp %ecx,-0x34(%ebp)
111d14: 73 24 jae 111d3a <IMFS_memfile_read+0xee>
111d16: eb 60 jmp 111d78 <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 );
111d18: 8b 30 mov (%eax),%esi
111d1a: 8b 7d c8 mov -0x38(%ebp),%edi
111d1d: 8b 4d d0 mov -0x30(%ebp),%ecx
111d20: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
dest += to_copy;
111d22: 89 7d c8 mov %edi,-0x38(%ebp)
block++;
111d25: 43 inc %ebx
my_length -= to_copy;
111d26: 8b 7d d0 mov -0x30(%ebp),%edi
111d29: 29 7d cc sub %edi,-0x34(%ebp)
copied += to_copy;
111d2c: 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 ) {
111d2f: 8b 45 cc mov -0x34(%ebp),%eax
111d32: 39 05 c0 70 12 00 cmp %eax,0x1270c0
111d38: 77 3e ja 111d78 <IMFS_memfile_read+0x12c>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
111d3a: 51 push %ecx
111d3b: 6a 00 push $0x0
111d3d: 53 push %ebx
111d3e: ff 75 08 pushl 0x8(%ebp)
111d41: e8 62 fd ff ff call 111aa8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
111d46: 83 c4 10 add $0x10,%esp
111d49: 85 c0 test %eax,%eax
111d4b: 75 cb jne 111d18 <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;
111d4d: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED
}
IMFS_update_atime( the_jnode );
return copied;
}
111d50: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
111d53: 5b pop %ebx <== NOT EXECUTED
111d54: 5e pop %esi <== NOT EXECUTED
111d55: 5f pop %edi <== NOT EXECUTED
111d56: c9 leave <== NOT EXECUTED
111d57: 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 )
111d58: 0f 8e be 00 00 00 jle 111e1c <IMFS_memfile_read+0x1d0><== ALWAYS TAKEN
my_length = the_jnode->info.file.size - start;
111d5e: 29 c1 sub %eax,%ecx
111d60: 89 4d cc mov %ecx,-0x34(%ebp)
111d63: e9 24 ff ff ff jmp 111c8c <IMFS_memfile_read+0x40>
unsigned int last_byte;
unsigned int copied;
unsigned int start_offset;
unsigned char *dest;
dest = destination;
111d68: 8b 55 14 mov 0x14(%ebp),%edx
111d6b: 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;
111d6e: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
111d75: eb 97 jmp 111d0e <IMFS_memfile_read+0xc2>
111d77: 90 nop
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
111d78: 8b 55 cc mov -0x34(%ebp),%edx
111d7b: 85 d2 test %edx,%edx
111d7d: 74 23 je 111da2 <IMFS_memfile_read+0x156>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
111d7f: 50 push %eax
111d80: 6a 00 push $0x0
111d82: 53 push %ebx
111d83: ff 75 08 pushl 0x8(%ebp)
111d86: e8 1d fd ff ff call 111aa8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
111d8b: 83 c4 10 add $0x10,%esp
111d8e: 85 c0 test %eax,%eax
111d90: 74 bb je 111d4d <IMFS_memfile_read+0x101><== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
111d92: 8b 30 mov (%eax),%esi
111d94: 8b 7d c8 mov -0x38(%ebp),%edi
111d97: 8b 4d cc mov -0x34(%ebp),%ecx
111d9a: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
copied += my_length;
111d9c: 8b 55 cc mov -0x34(%ebp),%edx
111d9f: 01 55 c4 add %edx,-0x3c(%ebp)
}
IMFS_update_atime( the_jnode );
111da2: 83 ec 08 sub $0x8,%esp
111da5: 6a 00 push $0x0
111da7: 8d 45 e0 lea -0x20(%ebp),%eax
111daa: 50 push %eax
111dab: e8 80 63 ff ff call 108130 <gettimeofday>
111db0: 8b 45 e0 mov -0x20(%ebp),%eax
111db3: 8b 4d 08 mov 0x8(%ebp),%ecx
111db6: 89 41 40 mov %eax,0x40(%ecx)
return copied;
111db9: 8b 45 c4 mov -0x3c(%ebp),%eax
111dbc: 83 c4 10 add $0x10,%esp
}
111dbf: 8d 65 f4 lea -0xc(%ebp),%esp
111dc2: 5b pop %ebx
111dc3: 5e pop %esi
111dc4: 5f pop %edi
111dc5: c9 leave
111dc6: c3 ret
111dc7: 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;
111dc8: 8b 50 58 mov 0x58(%eax),%edx
111dcb: 89 55 cc mov %edx,-0x34(%ebp)
if (my_length > (the_jnode->info.linearfile.size - start))
111dce: 89 c1 mov %eax,%ecx
111dd0: 8b 40 50 mov 0x50(%eax),%eax
111dd3: 8b 51 54 mov 0x54(%ecx),%edx
111dd6: 89 c1 mov %eax,%ecx
111dd8: 89 d3 mov %edx,%ebx
111dda: 29 f1 sub %esi,%ecx
111ddc: 19 fb sbb %edi,%ebx
111dde: 89 4d d0 mov %ecx,-0x30(%ebp)
111de1: 89 5d d4 mov %ebx,-0x2c(%ebp)
111de4: 31 c9 xor %ecx,%ecx
111de6: 39 d9 cmp %ebx,%ecx
111de8: 7d 4a jge 111e34 <IMFS_memfile_read+0x1e8><== ALWAYS TAKEN
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
111dea: 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);
111ded: 03 75 cc add -0x34(%ebp),%esi
111df0: 8b 7d 14 mov 0x14(%ebp),%edi
111df3: 89 d9 mov %ebx,%ecx
111df5: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
IMFS_update_atime( the_jnode );
111df7: 83 ec 08 sub $0x8,%esp
111dfa: 6a 00 push $0x0
111dfc: 8d 45 e0 lea -0x20(%ebp),%eax
111dff: 50 push %eax
111e00: e8 2b 63 ff ff call 108130 <gettimeofday>
111e05: 8b 45 e0 mov -0x20(%ebp),%eax
111e08: 8b 7d 08 mov 0x8(%ebp),%edi
111e0b: 89 47 40 mov %eax,0x40(%edi)
return my_length;
111e0e: 89 d8 mov %ebx,%eax
111e10: 83 c4 10 add $0x10,%esp
}
IMFS_update_atime( the_jnode );
return copied;
}
111e13: 8d 65 f4 lea -0xc(%ebp),%esp
111e16: 5b pop %ebx
111e17: 5e pop %esi
111e18: 5f pop %edi
111e19: c9 leave
111e1a: c3 ret
111e1b: 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 )
111e1c: 39 4d d0 cmp %ecx,-0x30(%ebp)
111e1f: 0f 86 61 fe ff ff jbe 111c86 <IMFS_memfile_read+0x3a>
111e25: e9 34 ff ff ff jmp 111d5e <IMFS_memfile_read+0x112>
111e2a: 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;
111e2c: 89 ca mov %ecx,%edx
111e2e: e9 bd fe ff ff jmp 111cf0 <IMFS_memfile_read+0xa4>
111e33: 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))
111e34: 7f 08 jg 111e3e <IMFS_memfile_read+0x1f2><== NEVER TAKEN
111e36: 8b 5d d0 mov -0x30(%ebp),%ebx
111e39: 39 5d 18 cmp %ebx,0x18(%ebp)
111e3c: 76 ac jbe 111dea <IMFS_memfile_read+0x19e><== NEVER TAKEN
my_length = the_jnode->info.linearfile.size - start;
111e3e: 89 c3 mov %eax,%ebx
111e40: 29 f3 sub %esi,%ebx
111e42: eb a9 jmp 111ded <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;
111e44: 31 c0 xor %eax,%eax
111e46: e9 05 ff ff ff jmp 111d50 <IMFS_memfile_read+0x104><== NOT EXECUTED
00111f24 <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
111f24: 55 push %ebp
111f25: 89 e5 mov %esp,%ebp
111f27: 57 push %edi
111f28: 56 push %esi
111f29: 53 push %ebx
111f2a: 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;
111f2d: 8b 3d c0 70 12 00 mov 0x1270c0,%edi
111f33: c1 ef 02 shr $0x2,%edi
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
111f36: 8b 45 08 mov 0x8(%ebp),%eax
111f39: 8b 50 58 mov 0x58(%eax),%edx
111f3c: 85 d2 test %edx,%edx
111f3e: 74 10 je 111f50 <IMFS_memfile_remove+0x2c>
memfile_free_blocks_in_table( &info->indirect, to_free );
111f40: 83 ec 08 sub $0x8,%esp
111f43: 57 push %edi
111f44: 83 c0 58 add $0x58,%eax
111f47: 50 push %eax
111f48: e8 7b ff ff ff call 111ec8 <memfile_free_blocks_in_table>
111f4d: 83 c4 10 add $0x10,%esp
}
if ( info->doubly_indirect ) {
111f50: 8b 4d 08 mov 0x8(%ebp),%ecx
111f53: 8b 51 5c mov 0x5c(%ecx),%edx
111f56: 85 d2 test %edx,%edx
111f58: 74 55 je 111faf <IMFS_memfile_remove+0x8b>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
111f5a: a1 c0 70 12 00 mov 0x1270c0,%eax
111f5f: 89 c1 mov %eax,%ecx
111f61: c1 e9 02 shr $0x2,%ecx
111f64: 74 36 je 111f9c <IMFS_memfile_remove+0x78><== NEVER TAKEN
111f66: 31 c9 xor %ecx,%ecx
111f68: 31 db xor %ebx,%ebx
111f6a: 8b 75 08 mov 0x8(%ebp),%esi
111f6d: eb 04 jmp 111f73 <IMFS_memfile_remove+0x4f>
111f6f: 90 nop
111f70: 8b 56 5c mov 0x5c(%esi),%edx
if ( info->doubly_indirect[i] ) {
111f73: c1 e1 02 shl $0x2,%ecx
111f76: 83 3c 0a 00 cmpl $0x0,(%edx,%ecx,1)
111f7a: 74 14 je 111f90 <IMFS_memfile_remove+0x6c><== NEVER TAKEN
memfile_free_blocks_in_table(
111f7c: 83 ec 08 sub $0x8,%esp
111f7f: 57 push %edi
111f80: 01 ca add %ecx,%edx
111f82: 52 push %edx
111f83: e8 40 ff ff ff call 111ec8 <memfile_free_blocks_in_table>
111f88: 83 c4 10 add $0x10,%esp
111f8b: a1 c0 70 12 00 mov 0x1270c0,%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++ ) {
111f90: 43 inc %ebx
111f91: 89 d9 mov %ebx,%ecx
111f93: 89 c2 mov %eax,%edx
111f95: c1 ea 02 shr $0x2,%edx
111f98: 39 da cmp %ebx,%edx
111f9a: 77 d4 ja 111f70 <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 );
111f9c: 83 ec 08 sub $0x8,%esp
111f9f: 57 push %edi
111fa0: 8b 45 08 mov 0x8(%ebp),%eax
111fa3: 83 c0 5c add $0x5c,%eax
111fa6: 50 push %eax
111fa7: e8 1c ff ff ff call 111ec8 <memfile_free_blocks_in_table>
111fac: 83 c4 10 add $0x10,%esp
}
if ( info->triply_indirect ) {
111faf: 8b 45 08 mov 0x8(%ebp),%eax
111fb2: 8b 50 60 mov 0x60(%eax),%edx
111fb5: 85 d2 test %edx,%edx
111fb7: 0f 84 b6 00 00 00 je 112073 <IMFS_memfile_remove+0x14f>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
111fbd: a1 c0 70 12 00 mov 0x1270c0,%eax
111fc2: 89 c1 mov %eax,%ecx
111fc4: c1 e9 02 shr $0x2,%ecx
111fc7: 0f 84 93 00 00 00 je 112060 <IMFS_memfile_remove+0x13c><== NEVER TAKEN
p = (block_p *) info->triply_indirect[i];
111fcd: 8b 32 mov (%edx),%esi
if ( !p ) /* ensure we have a valid pointer */
111fcf: 85 f6 test %esi,%esi
111fd1: 0f 84 89 00 00 00 je 112060 <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];
111fd7: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
if ( !p ) /* ensure we have a valid pointer */
111fde: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
111fe5: 8d 76 00 lea 0x0(%esi),%esi
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
111fe8: 89 c2 mov %eax,%edx
111fea: c1 ea 02 shr $0x2,%edx
111fed: 74 30 je 11201f <IMFS_memfile_remove+0xfb><== NEVER TAKEN
111fef: 31 d2 xor %edx,%edx
111ff1: 31 db xor %ebx,%ebx
111ff3: 90 nop
if ( p[j] ) {
111ff4: c1 e2 02 shl $0x2,%edx
111ff7: 8b 0c 16 mov (%esi,%edx,1),%ecx
111ffa: 85 c9 test %ecx,%ecx
111ffc: 74 15 je 112013 <IMFS_memfile_remove+0xef><== NEVER TAKEN
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
111ffe: 83 ec 08 sub $0x8,%esp
112001: 57 push %edi
112002: 8d 14 16 lea (%esi,%edx,1),%edx
112005: 52 push %edx
112006: e8 bd fe ff ff call 111ec8 <memfile_free_blocks_in_table>
11200b: 83 c4 10 add $0x10,%esp
11200e: a1 c0 70 12 00 mov 0x1270c0,%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++ ) {
112013: 43 inc %ebx
112014: 89 da mov %ebx,%edx
112016: 89 c1 mov %eax,%ecx
112018: c1 e9 02 shr $0x2,%ecx
11201b: 39 cb cmp %ecx,%ebx
11201d: 72 d5 jb 111ff4 <IMFS_memfile_remove+0xd0>
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
11201f: 83 ec 08 sub $0x8,%esp
112022: 57 push %edi
112023: 8b 45 e0 mov -0x20(%ebp),%eax
112026: 8b 4d 08 mov 0x8(%ebp),%ecx
112029: 03 41 60 add 0x60(%ecx),%eax
11202c: 50 push %eax
11202d: e8 96 fe ff ff call 111ec8 <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++ ) {
112032: ff 45 e4 incl -0x1c(%ebp)
112035: a1 c0 70 12 00 mov 0x1270c0,%eax
11203a: 89 c2 mov %eax,%edx
11203c: c1 ea 02 shr $0x2,%edx
11203f: 83 c4 10 add $0x10,%esp
112042: 3b 55 e4 cmp -0x1c(%ebp),%edx
112045: 76 19 jbe 112060 <IMFS_memfile_remove+0x13c>
p = (block_p *) info->triply_indirect[i];
if ( !p ) /* ensure we have a valid pointer */
112047: 8b 55 e4 mov -0x1c(%ebp),%edx
11204a: c1 e2 02 shl $0x2,%edx
11204d: 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];
112050: 8b 4d 08 mov 0x8(%ebp),%ecx
112053: 8b 51 60 mov 0x60(%ecx),%edx
112056: 8b 4d e0 mov -0x20(%ebp),%ecx
112059: 8b 34 0a mov (%edx,%ecx,1),%esi
if ( !p ) /* ensure we have a valid pointer */
11205c: 85 f6 test %esi,%esi
11205e: 75 88 jne 111fe8 <IMFS_memfile_remove+0xc4><== ALWAYS TAKEN
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
112060: 83 ec 08 sub $0x8,%esp
112063: 57 push %edi
(block_p **)&info->triply_indirect, to_free );
112064: 8b 45 08 mov 0x8(%ebp),%eax
112067: 83 c0 60 add $0x60,%eax
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
11206a: 50 push %eax
11206b: e8 58 fe ff ff call 111ec8 <memfile_free_blocks_in_table>
112070: 83 c4 10 add $0x10,%esp
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
112073: 31 c0 xor %eax,%eax
112075: 8d 65 f4 lea -0xc(%ebp),%esp
112078: 5b pop %ebx
112079: 5e pop %esi
11207a: 5f pop %edi
11207b: c9 leave
11207c: c3 ret
001121c4 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
1121c4: 55 push %ebp
1121c5: 89 e5 mov %esp,%ebp
1121c7: 57 push %edi
1121c8: 56 push %esi
1121c9: 53 push %ebx
1121ca: 83 ec 3c sub $0x3c,%esp
1121cd: 8b 5d 0c mov 0xc(%ebp),%ebx
1121d0: 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;
1121d3: 8b 4d 18 mov 0x18(%ebp),%ecx
1121d6: 01 d9 add %ebx,%ecx
if ( last_byte > the_jnode->info.file.size ) {
1121d8: 89 c8 mov %ecx,%eax
1121da: 31 d2 xor %edx,%edx
1121dc: 8b 7d 08 mov 0x8(%ebp),%edi
1121df: 3b 57 54 cmp 0x54(%edi),%edx
1121e2: 7c 1c jl 112200 <IMFS_memfile_write+0x3c><== NEVER TAKEN
1121e4: 0f 8e f2 00 00 00 jle 1122dc <IMFS_memfile_write+0x118><== ALWAYS TAKEN
status = IMFS_memfile_extend( the_jnode, last_byte );
1121ea: 51 push %ecx
1121eb: 52 push %edx
1121ec: 50 push %eax
1121ed: ff 75 08 pushl 0x8(%ebp)
1121f0: e8 b7 fe ff ff call 1120ac <IMFS_memfile_extend>
if ( status )
1121f5: 83 c4 10 add $0x10,%esp
1121f8: 85 c0 test %eax,%eax
1121fa: 0f 85 52 01 00 00 jne 112352 <IMFS_memfile_write+0x18e>
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
112200: a1 c0 70 12 00 mov 0x1270c0,%eax
112205: 89 45 d4 mov %eax,-0x2c(%ebp)
112208: 99 cltd
112209: 89 45 c8 mov %eax,-0x38(%ebp)
11220c: 89 55 cc mov %edx,-0x34(%ebp)
11220f: 52 push %edx
112210: 50 push %eax
112211: 56 push %esi
112212: 53 push %ebx
112213: e8 98 c1 00 00 call 11e3b0 <__moddi3>
112218: 83 c4 10 add $0x10,%esp
11221b: 89 c7 mov %eax,%edi
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
11221d: ff 75 cc pushl -0x34(%ebp)
112220: ff 75 c8 pushl -0x38(%ebp)
112223: 56 push %esi
112224: 53 push %ebx
112225: e8 3a c0 00 00 call 11e264 <__divdi3>
11222a: 83 c4 10 add $0x10,%esp
11222d: 89 c3 mov %eax,%ebx
if ( start_offset ) {
11222f: 85 ff test %edi,%edi
112231: 75 5d jne 112290 <IMFS_memfile_write+0xcc>
unsigned int last_byte;
unsigned int start_offset;
int copied;
const unsigned char *src;
src = source;
112233: 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 ) {
112236: 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;
112239: 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 ) {
112240: 3b 55 d4 cmp -0x2c(%ebp),%edx
112243: 73 26 jae 11226b <IMFS_memfile_write+0xa7>
112245: e9 a2 00 00 00 jmp 1122ec <IMFS_memfile_write+0x128>
11224a: 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 );
11224c: 8b 00 mov (%eax),%eax
src += to_copy;
11224e: 89 c7 mov %eax,%edi
112250: 8b 4d d4 mov -0x2c(%ebp),%ecx
112253: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
block++;
112255: 43 inc %ebx
my_length -= to_copy;
112256: 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(
112259: 8b 45 d4 mov -0x2c(%ebp),%eax
11225c: 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 ) {
11225f: 39 15 c0 70 12 00 cmp %edx,0x1270c0
112265: 0f 87 81 00 00 00 ja 1122ec <IMFS_memfile_write+0x128>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
11226b: 57 push %edi
11226c: 6a 00 push $0x0
11226e: 53 push %ebx
11226f: ff 75 08 pushl 0x8(%ebp)
112272: 89 55 c4 mov %edx,-0x3c(%ebp)
112275: e8 2e f8 ff ff call 111aa8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
11227a: 83 c4 10 add $0x10,%esp
11227d: 85 c0 test %eax,%eax
11227f: 8b 55 c4 mov -0x3c(%ebp),%edx
112282: 75 c8 jne 11224c <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 )
112284: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
112287: 8d 65 f4 lea -0xc(%ebp),%esp
11228a: 5b pop %ebx
11228b: 5e pop %esi
11228c: 5f pop %edi
11228d: c9 leave
11228e: c3 ret
11228f: 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 );
112290: 50 push %eax
112291: 6a 00 push $0x0
112293: 53 push %ebx
112294: ff 75 08 pushl 0x8(%ebp)
112297: e8 0c f8 ff ff call 111aa8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
11229c: 83 c4 10 add $0x10,%esp
11229f: 85 c0 test %eax,%eax
1122a1: 0f 84 a1 00 00 00 je 112348 <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;
1122a7: 8b 55 d4 mov -0x2c(%ebp),%edx
1122aa: 29 fa sub %edi,%edx
1122ac: 89 55 c8 mov %edx,-0x38(%ebp)
1122af: 8b 55 18 mov 0x18(%ebp),%edx
1122b2: 39 55 c8 cmp %edx,-0x38(%ebp)
1122b5: 0f 87 85 00 00 00 ja 112340 <IMFS_memfile_write+0x17c>
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
1122bb: 03 38 add (%eax),%edi
src += to_copy;
1122bd: 8b 75 14 mov 0x14(%ebp),%esi
1122c0: 8b 4d c8 mov -0x38(%ebp),%ecx
1122c3: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
block++;
1122c5: 43 inc %ebx
my_length -= to_copy;
1122c6: 8b 55 18 mov 0x18(%ebp),%edx
1122c9: 2b 55 c8 sub -0x38(%ebp),%edx
copied += to_copy;
1122cc: 8b 3d c0 70 12 00 mov 0x1270c0,%edi
1122d2: 89 7d d4 mov %edi,-0x2c(%ebp)
1122d5: e9 66 ff ff ff jmp 112240 <IMFS_memfile_write+0x7c>
1122da: 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 ) {
1122dc: 3b 4f 50 cmp 0x50(%edi),%ecx
1122df: 0f 86 1b ff ff ff jbe 112200 <IMFS_memfile_write+0x3c><== NEVER TAKEN
1122e5: e9 00 ff ff ff jmp 1121ea <IMFS_memfile_write+0x26>
1122ea: 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 ) {
1122ec: 85 d2 test %edx,%edx
1122ee: 74 28 je 112318 <IMFS_memfile_write+0x154>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
1122f0: 51 push %ecx
1122f1: 6a 00 push $0x0
1122f3: 53 push %ebx
1122f4: ff 75 08 pushl 0x8(%ebp)
1122f7: 89 55 c4 mov %edx,-0x3c(%ebp)
1122fa: e8 a9 f7 ff ff call 111aa8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
1122ff: 83 c4 10 add $0x10,%esp
112302: 85 c0 test %eax,%eax
112304: 8b 55 c4 mov -0x3c(%ebp),%edx
112307: 0f 84 77 ff ff ff je 112284 <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 );
11230d: 8b 00 mov (%eax),%eax
11230f: 89 c7 mov %eax,%edi
112311: 89 d1 mov %edx,%ecx
112313: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
my_length = 0;
copied += to_copy;
112315: 01 55 c8 add %edx,-0x38(%ebp)
}
IMFS_mtime_ctime_update( the_jnode );
112318: 83 ec 08 sub $0x8,%esp
11231b: 6a 00 push $0x0
11231d: 8d 45 e0 lea -0x20(%ebp),%eax
112320: 50 push %eax
112321: e8 0a 5e ff ff call 108130 <gettimeofday>
112326: 8b 45 e0 mov -0x20(%ebp),%eax
112329: 8b 55 08 mov 0x8(%ebp),%edx
11232c: 89 42 44 mov %eax,0x44(%edx)
11232f: 89 42 48 mov %eax,0x48(%edx)
return copied;
112332: 83 c4 10 add $0x10,%esp
112335: 8b 45 c8 mov -0x38(%ebp),%eax
}
112338: 8d 65 f4 lea -0xc(%ebp),%esp
11233b: 5b pop %ebx
11233c: 5e pop %esi
11233d: 5f pop %edi
11233e: c9 leave
11233f: 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;
112340: 89 55 c8 mov %edx,-0x38(%ebp)
112343: e9 73 ff ff ff jmp 1122bb <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;
112348: 31 c0 xor %eax,%eax
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
11234a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
11234d: 5b pop %ebx <== NOT EXECUTED
11234e: 5e pop %esi <== NOT EXECUTED
11234f: 5f pop %edi <== NOT EXECUTED
112350: c9 leave <== NOT EXECUTED
112351: 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 );
112352: e8 bd 0f 00 00 call 113314 <__errno>
112357: c7 00 1c 00 00 00 movl $0x1c,(%eax)
11235d: 83 c8 ff or $0xffffffff,%eax
112360: e9 22 ff ff ff jmp 112287 <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 23 7f 00 00 call 10f914 <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 08 75 00 00 call 10ef4c <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 a0 b8 00 00 call 113314 <__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 6f b8 00 00 call 113314 <__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 60 b2 12 00 mov 0x12b260,%eax
10a3bf: ff 70 08 pushl 0x8(%eax)
10a3c2: 8d 43 0c lea 0xc(%ebx),%eax
10a3c5: 50 push %eax
10a3c6: e8 75 d6 00 00 call 117a40 <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 69 12 00 push $0x126984 <== NOT EXECUTED
10a3dd: a1 60 b2 12 00 mov 0x12b260,%eax <== NOT EXECUTED
10a3e2: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
10a3e5: e8 4a d5 00 00 call 117934 <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 69 12 00 jmp *0x12699c(,%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 60 b2 12 00 mov 0x12b260,%eax
10a401: ff 70 08 pushl 0x8(%eax)
10a404: 6a 13 push $0x13
10a406: 6a 01 push $0x1
10a408: 68 5d 69 12 00 push $0x12695d
10a40d: e8 52 e2 00 00 call 118664 <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 60 b2 12 00 mov 0x12b260,%eax
10a421: ff 70 08 pushl 0x8(%eax)
10a424: 6a 12 push $0x12
10a426: 6a 01 push $0x1
10a428: 68 71 69 12 00 push $0x126971
10a42d: e8 32 e2 00 00 call 118664 <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 69 12 00 push $0x126951
10a445: a1 60 b2 12 00 mov 0x12b260,%eax
10a44a: ff 70 08 pushl 0x8(%eax)
10a44d: e8 e2 d4 00 00 call 117934 <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 6c 12 00 movl $0x126c89,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 f3 ed 00 00 jmp 119258 <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 69 12 00 push $0x126942
10a473: a1 60 b2 12 00 mov 0x12b260,%eax
10a478: ff 70 08 pushl 0x8(%eax)
10a47b: e8 b4 d4 00 00 call 117934 <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 6c 12 00 movl $0x126c89,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 c5 ed 00 00 jmp 119258 <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 60 b2 12 00 mov 0x12b260,%eax
10a49c: ff 70 08 pushl 0x8(%eax)
10a49f: 6a 2f push $0x2f
10a4a1: e8 ee d4 00 00 call 117994 <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 6c 12 00 movl $0x126c89,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 9f ed 00 00 jmp 119258 <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 69 12 00 push $0x12692f
10a4c7: a1 60 b2 12 00 mov 0x12b260,%eax
10a4cc: ff 70 08 pushl 0x8(%eax)
10a4cf: e8 60 d4 00 00 call 117934 <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 6c 12 00 movl $0x126c89,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 71 ed 00 00 jmp 119258 <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 ea c5 00 00 call 11410c <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 cb 44 00 00 call 10c000 <_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 8f 44 00 00 call 10bfdc <_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
0010fae0 <IMFS_stat>:
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
10fae0: 55 push %ebp
10fae1: 89 e5 mov %esp,%ebp
10fae3: 56 push %esi
10fae4: 53 push %ebx
10fae5: 8b 4d 08 mov 0x8(%ebp),%ecx
10fae8: 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;
10faeb: 8b 11 mov (%ecx),%edx
switch ( the_jnode->type ) {
10faed: 83 7a 4c 07 cmpl $0x7,0x4c(%edx)
10faf1: 76 15 jbe 10fb08 <IMFS_stat+0x28> <== ALWAYS TAKEN
case IMFS_FIFO:
buf->st_size = 0;
break;
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
10faf3: e8 1c 38 00 00 call 113314 <__errno>
10faf8: c7 00 86 00 00 00 movl $0x86,(%eax)
10fafe: 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;
}
10fb03: 5b pop %ebx
10fb04: 5e pop %esi
10fb05: c9 leave
10fb06: c3 ret
10fb07: 90 nop
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
10fb08: 8b 5a 4c mov 0x4c(%edx),%ebx
10fb0b: ff 24 9d f8 10 12 00 jmp *0x1210f8(,%ebx,4)
10fb12: 66 90 xchg %ax,%ax
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
10fb14: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax)
10fb1b: 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;
10fb22: 8b 49 10 mov 0x10(%ecx),%ecx
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
10fb25: 8b 49 34 mov 0x34(%ecx),%ecx
10fb28: 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 =
10fb2a: c7 00 fe ff 00 00 movl $0xfffe,(%eax)
10fb30: 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;
10fb33: 8b 4a 30 mov 0x30(%edx),%ecx
10fb36: 89 48 0c mov %ecx,0xc(%eax)
buf->st_nlink = the_jnode->st_nlink;
10fb39: 8b 4a 34 mov 0x34(%edx),%ecx
10fb3c: 66 89 48 10 mov %cx,0x10(%eax)
buf->st_ino = the_jnode->st_ino;
10fb40: 8b 4a 38 mov 0x38(%edx),%ecx
10fb43: 89 48 08 mov %ecx,0x8(%eax)
buf->st_uid = the_jnode->st_uid;
10fb46: 8b 4a 3c mov 0x3c(%edx),%ecx
10fb49: 66 89 48 12 mov %cx,0x12(%eax)
buf->st_gid = the_jnode->st_gid;
10fb4d: 66 8b 4a 3e mov 0x3e(%edx),%cx
10fb51: 66 89 48 14 mov %cx,0x14(%eax)
buf->st_atime = the_jnode->stat_atime;
10fb55: 8b 4a 40 mov 0x40(%edx),%ecx
10fb58: 89 48 28 mov %ecx,0x28(%eax)
buf->st_mtime = the_jnode->stat_mtime;
10fb5b: 8b 4a 44 mov 0x44(%edx),%ecx
10fb5e: 89 48 30 mov %ecx,0x30(%eax)
buf->st_ctime = the_jnode->stat_ctime;
10fb61: 8b 52 48 mov 0x48(%edx),%edx
10fb64: 89 50 38 mov %edx,0x38(%eax)
return 0;
10fb67: 31 c0 xor %eax,%eax
}
10fb69: 5b pop %ebx
10fb6a: 5e pop %esi
10fb6b: c9 leave
10fb6c: c3 ret
10fb6d: 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 );
10fb70: 8b 5a 54 mov 0x54(%edx),%ebx
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
10fb73: 8b 72 50 mov 0x50(%edx),%esi
10fb76: 89 70 18 mov %esi,0x18(%eax)
10fb79: 89 58 1c mov %ebx,0x1c(%eax)
break;
10fb7c: eb a4 jmp 10fb22 <IMFS_stat+0x42>
10fb7e: 66 90 xchg %ax,%ax
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
10fb80: 8b 5a 50 mov 0x50(%edx),%ebx
10fb83: 8b 72 54 mov 0x54(%edx),%esi
10fb86: 89 58 20 mov %ebx,0x20(%eax)
10fb89: 89 70 24 mov %esi,0x24(%eax)
break;
10fb8c: eb 94 jmp 10fb22 <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 6b 74 00 00 call 10f0b8 <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 67 b6 00 00 call 113314 <__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 2b b6 00 00 call 113314 <__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 19 b6 00 00 call 113314 <__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 c8 57 12 00 mov 0x1257c8,%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 cc 57 12 00 mov 0x1257cc,%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 c4 57 12 00 00 cmpb $0x0,0x1257c4
10831c: 75 1f jne 10833d <RTEMS_Malloc_Initialize+0x61>
!rtems_unified_work_area
&& rtems_configuration_get_do_zero_of_workspace()
10831e: 80 3d ac 32 12 00 00 cmpb $0x0,0x1232ac
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 b8 31 12 00 pushl 0x1231b8
108331: e8 ba 43 00 00 call 10c6f0 <_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 20 74 12 00 mov 0x127420,%ebx
108343: 83 ec 0c sub $0xc,%esp
108346: ff 35 b8 31 12 00 pushl 0x1231b8
10834c: e8 23 4e 00 00 call 10d174 <_Protected_heap_Get_size>
108351: 8d 1c 18 lea (%eax,%ebx,1),%ebx
108354: 89 1d 20 74 12 00 mov %ebx,0x127420
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 c4 57 12 00 00 cmpb $0x0,0x1257c4
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 7b 39 00 00 call 10bd00 <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 44 9d 12 00 mov 0x129d44,%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 db 5e 00 00 call 10dd58 <rtems_object_get_name> <== NOT EXECUTED
107e7d: 50 push %eax <== NOT EXECUTED
107e7e: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
107e81: 68 13 35 12 00 push $0x123513 <== NOT EXECUTED
107e86: ff 35 40 9d 12 00 pushl 0x129d40 <== 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 2e 35 12 00 push $0x12352e <== NOT EXECUTED
107ea9: ff 35 40 9d 12 00 pushl 0x129d40 <== NOT EXECUTED
107eaf: ff 15 44 9d 12 00 call *0x129d44 <== 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 48 9d 12 00 mov 0x129d48,%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 59 35 12 00 push $0x123559 <== NOT EXECUTED
107ecb: ff 35 40 9d 12 00 pushl 0x129d40 <== NOT EXECUTED
107ed1: ff 15 44 9d 12 00 call *0x129d44 <== 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 20 35 12 00 push $0x123520 <== NOT EXECUTED
107f06: ff 35 40 9d 12 00 pushl 0x129d40 <== NOT EXECUTED
107f0c: ff 15 44 9d 12 00 call *0x129d44 <== 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 4c 35 12 00 push $0x12354c <== NOT EXECUTED
107f24: ff 35 40 9d 12 00 pushl 0x129d40 <== NOT EXECUTED
107f2a: ff 15 44 9d 12 00 call *0x129d44 <== 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 b4 a0 12 00 mov 0x12a0b4,%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 b0 a0 12 00 mov $0x12a0b0,%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 48 9d 12 00 mov 0x129d48,%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 a0 a0 12 00 0d movl $0xfeedf00d,0x12a0a0
107f71: f0 ed fe
107f74: c7 05 a4 a0 12 00 06 movl $0xbad0d06,0x12a0a4
107f7b: 0d ad 0b
107f7e: c7 05 a8 a0 12 00 0d movl $0xdeadf00d,0x12a0a8
107f85: f0 ad de
107f88: c7 05 ac a0 12 00 06 movl $0x600d0d06,0x12a0ac
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 8c a8 12 00 mov 0x12a88c,%edx
107f98: 85 d2 test %edx,%edx
107f9a: 74 1e je 107fba <Stack_check_Initialize+0x5e><== NEVER TAKEN
107f9c: 8b 0d 90 a8 12 00 mov 0x12a890,%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 b4 a0 12 00 mov %edx,0x12a0b4
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
107fac: 29 d1 sub %edx,%ecx
107fae: 89 0d b0 a0 12 00 mov %ecx,0x12a0b0
(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 48 9d 12 00 01 movl $0x1,0x129d48
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 5f 35 12 00 push $0x12355f <== 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 6f 35 12 00 push $0x12356f <== 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 8c 35 12 00 push $0x12358c <== 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 9e 35 12 00 push $0x12359e <== 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 e3 5c 00 00 call 10dd58 <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 b2 35 12 00 push $0x1235b2 <== 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 e0 35 12 00 push $0x1235e0 <== 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 bf 64 00 00 call 10e574 <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 14 36 12 00 push $0x123614 <== 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
0010bea8 <_API_extensions_Run_postdriver>:
*
* _API_extensions_Run_postdriver
*/
void _API_extensions_Run_postdriver( void )
{
10bea8: 55 push %ebp
10bea9: 89 e5 mov %esp,%ebp
10beab: 53 push %ebx
10beac: 83 ec 04 sub $0x4,%esp
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10beaf: 8b 1d d8 77 12 00 mov 0x1277d8,%ebx
void _API_extensions_Run_postdriver( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
10beb5: 81 fb dc 77 12 00 cmp $0x1277dc,%ebx
10bebb: 74 10 je 10becd <_API_extensions_Run_postdriver+0x25><== NEVER TAKEN
10bebd: 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)();
10bec0: 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 ) {
10bec3: 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 );
10bec5: 81 fb dc 77 12 00 cmp $0x1277dc,%ebx
10becb: 75 f3 jne 10bec0 <_API_extensions_Run_postdriver+0x18>
#if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
if ( the_extension->postdriver_hook )
#endif
(*the_extension->postdriver_hook)();
}
}
10becd: 58 pop %eax
10bece: 5b pop %ebx
10becf: c9 leave
10bed0: c3 ret
0010bed4 <_API_extensions_Run_postswitch>:
*
* _API_extensions_Run_postswitch
*/
void _API_extensions_Run_postswitch( void )
{
10bed4: 55 push %ebp
10bed5: 89 e5 mov %esp,%ebp
10bed7: 53 push %ebx
10bed8: 83 ec 04 sub $0x4,%esp
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10bedb: 8b 1d d8 77 12 00 mov 0x1277d8,%ebx
void _API_extensions_Run_postswitch( void )
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_API_extensions_List );
10bee1: 81 fb dc 77 12 00 cmp $0x1277dc,%ebx
10bee7: 74 1c je 10bf05 <_API_extensions_Run_postswitch+0x31><== NEVER TAKEN
10bee9: 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 );
10beec: 83 ec 0c sub $0xc,%esp
10beef: ff 35 58 7b 12 00 pushl 0x127b58
10bef5: 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 ) {
10bef8: 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 );
10befa: 83 c4 10 add $0x10,%esp
10befd: 81 fb dc 77 12 00 cmp $0x1277dc,%ebx
10bf03: 75 e7 jne 10beec <_API_extensions_Run_postswitch+0x18>
the_extension = (API_extensions_Control *) the_node;
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10bf05: 8b 5d fc mov -0x4(%ebp),%ebx
10bf08: c9 leave
10bf09: c3 ret
0010e3e4 <_CORE_RWLock_Obtain_for_reading>:
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
10e3e4: 55 push %ebp
10e3e5: 89 e5 mov %esp,%ebp
10e3e7: 57 push %edi
10e3e8: 56 push %esi
10e3e9: 53 push %ebx
10e3ea: 83 ec 1c sub $0x1c,%esp
10e3ed: 8b 5d 08 mov 0x8(%ebp),%ebx
10e3f0: 8b 7d 0c mov 0xc(%ebp),%edi
10e3f3: 8b 4d 14 mov 0x14(%ebp),%ecx
10e3f6: 8a 55 10 mov 0x10(%ebp),%dl
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
10e3f9: 8b 35 d8 b4 12 00 mov 0x12b4d8,%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 );
10e3ff: 9c pushf
10e400: fa cli
10e401: 8f 45 e4 popl -0x1c(%ebp)
switch ( the_rwlock->current_state ) {
10e404: 8b 43 44 mov 0x44(%ebx),%eax
10e407: 85 c0 test %eax,%eax
10e409: 75 1d jne 10e428 <_CORE_RWLock_Obtain_for_reading+0x44>
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
10e40b: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx)
the_rwlock->number_of_readers += 1;
10e412: ff 43 48 incl 0x48(%ebx)
_ISR_Enable( level );
10e415: ff 75 e4 pushl -0x1c(%ebp)
10e418: 9d popf
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10e419: 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 */
}
10e420: 8d 65 f4 lea -0xc(%ebp),%esp
10e423: 5b pop %ebx
10e424: 5e pop %esi
10e425: 5f pop %edi
10e426: c9 leave
10e427: 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 ) {
10e428: 48 dec %eax
10e429: 74 51 je 10e47c <_CORE_RWLock_Obtain_for_reading+0x98>
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
10e42b: 84 d2 test %dl,%dl
10e42d: 75 15 jne 10e444 <_CORE_RWLock_Obtain_for_reading+0x60>
_ISR_Enable( level );
10e42f: ff 75 e4 pushl -0x1c(%ebp)
10e432: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10e433: 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 */
}
10e43a: 8d 65 f4 lea -0xc(%ebp),%esp
10e43d: 5b pop %ebx
10e43e: 5e pop %esi
10e43f: 5f pop %edi
10e440: c9 leave
10e441: c3 ret
10e442: 66 90 xchg %ax,%ax
10e444: 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;
10e44b: 89 5e 44 mov %ebx,0x44(%esi)
executing->Wait.id = id;
10e44e: 89 7e 20 mov %edi,0x20(%esi)
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
10e451: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi)
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10e458: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi)
_ISR_Enable( level );
10e45f: ff 75 e4 pushl -0x1c(%ebp)
10e462: 9d popf
_Thread_queue_Enqueue_with_handler(
10e463: c7 45 10 e8 e5 10 00 movl $0x10e5e8,0x10(%ebp)
10e46a: 89 4d 0c mov %ecx,0xc(%ebp)
10e46d: 89 5d 08 mov %ebx,0x8(%ebp)
timeout,
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
10e470: 8d 65 f4 lea -0xc(%ebp),%esp
10e473: 5b pop %ebx
10e474: 5e pop %esi
10e475: 5f pop %edi
10e476: 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(
10e477: e9 94 1b 00 00 jmp 110010 <_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 );
10e47c: 83 ec 0c sub $0xc,%esp
10e47f: 53 push %ebx
10e480: 88 55 e0 mov %dl,-0x20(%ebp)
10e483: 89 4d dc mov %ecx,-0x24(%ebp)
10e486: e8 ad 1e 00 00 call 110338 <_Thread_queue_First>
if ( !waiter ) {
10e48b: 83 c4 10 add $0x10,%esp
10e48e: 85 c0 test %eax,%eax
10e490: 8a 55 e0 mov -0x20(%ebp),%dl
10e493: 8b 4d dc mov -0x24(%ebp),%ecx
10e496: 75 93 jne 10e42b <_CORE_RWLock_Obtain_for_reading+0x47>
the_rwlock->number_of_readers += 1;
10e498: ff 43 48 incl 0x48(%ebx)
_ISR_Enable( level );
10e49b: ff 75 e4 pushl -0x1c(%ebp)
10e49e: 9d popf
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10e49f: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi)
return;
10e4a6: e9 75 ff ff ff jmp 10e420 <_CORE_RWLock_Obtain_for_reading+0x3c>
0010e4ac <_CORE_RWLock_Obtain_for_writing>:
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
10e4ac: 55 push %ebp
10e4ad: 89 e5 mov %esp,%ebp
10e4af: 57 push %edi
10e4b0: 56 push %esi
10e4b1: 53 push %ebx
10e4b2: 83 ec 0c sub $0xc,%esp
10e4b5: 8b 45 08 mov 0x8(%ebp),%eax
10e4b8: 8b 7d 0c mov 0xc(%ebp),%edi
10e4bb: 8b 75 14 mov 0x14(%ebp),%esi
10e4be: 8a 5d 10 mov 0x10(%ebp),%bl
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
10e4c1: 8b 15 d8 b4 12 00 mov 0x12b4d8,%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 );
10e4c7: 9c pushf
10e4c8: fa cli
10e4c9: 59 pop %ecx
switch ( the_rwlock->current_state ) {
10e4ca: 83 78 44 00 cmpl $0x0,0x44(%eax)
10e4ce: 75 18 jne 10e4e8 <_CORE_RWLock_Obtain_for_writing+0x3c>
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
10e4d0: c7 40 44 02 00 00 00 movl $0x2,0x44(%eax)
_ISR_Enable( level );
10e4d7: 51 push %ecx
10e4d8: 9d popf
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10e4d9: 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 */
}
10e4e0: 83 c4 0c add $0xc,%esp
10e4e3: 5b pop %ebx
10e4e4: 5e pop %esi
10e4e5: 5f pop %edi
10e4e6: c9 leave
10e4e7: c3 ret
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
10e4e8: 84 db test %bl,%bl
10e4ea: 75 14 jne 10e500 <_CORE_RWLock_Obtain_for_writing+0x54>
_ISR_Enable( level );
10e4ec: 51 push %ecx
10e4ed: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10e4ee: 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 */
}
10e4f5: 83 c4 0c add $0xc,%esp
10e4f8: 5b pop %ebx
10e4f9: 5e pop %esi
10e4fa: 5f pop %edi
10e4fb: c9 leave
10e4fc: c3 ret
10e4fd: 8d 76 00 lea 0x0(%esi),%esi
10e500: 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;
10e507: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
10e50a: 89 7a 20 mov %edi,0x20(%edx)
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE;
10e50d: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx)
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10e514: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
_ISR_Enable( level );
10e51b: 51 push %ecx
10e51c: 9d popf
_Thread_queue_Enqueue_with_handler(
10e51d: c7 45 10 e8 e5 10 00 movl $0x10e5e8,0x10(%ebp)
10e524: 89 75 0c mov %esi,0xc(%ebp)
10e527: 89 45 08 mov %eax,0x8(%ebp)
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
10e52a: 83 c4 0c add $0xc,%esp
10e52d: 5b pop %ebx
10e52e: 5e pop %esi
10e52f: 5f pop %edi
10e530: 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(
10e531: e9 da 1a 00 00 jmp 110010 <_Thread_queue_Enqueue_with_handler>
0010e538 <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
10e538: 55 push %ebp
10e539: 89 e5 mov %esp,%ebp
10e53b: 53 push %ebx
10e53c: 83 ec 04 sub $0x4,%esp
10e53f: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
10e542: 8b 0d d8 b4 12 00 mov 0x12b4d8,%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 );
10e548: 9c pushf
10e549: fa cli
10e54a: 5a pop %edx
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
10e54b: 8b 43 44 mov 0x44(%ebx),%eax
10e54e: 85 c0 test %eax,%eax
10e550: 74 7a je 10e5cc <_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 ) {
10e552: 48 dec %eax
10e553: 74 63 je 10e5b8 <_CORE_RWLock_Release+0x80>
return CORE_RWLOCK_SUCCESSFUL;
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10e555: 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;
10e55c: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
_ISR_Enable( level );
10e563: 52 push %edx
10e564: 9d popf
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
10e565: 83 ec 0c sub $0xc,%esp
10e568: 53 push %ebx
10e569: e8 7a 19 00 00 call 10fee8 <_Thread_queue_Dequeue>
if ( next ) {
10e56e: 83 c4 10 add $0x10,%esp
10e571: 85 c0 test %eax,%eax
10e573: 74 39 je 10e5ae <_CORE_RWLock_Release+0x76>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
10e575: 83 78 30 01 cmpl $0x1,0x30(%eax)
10e579: 74 61 je 10e5dc <_CORE_RWLock_Release+0xa4>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
10e57b: ff 43 48 incl 0x48(%ebx)
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
10e57e: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx)
10e585: eb 17 jmp 10e59e <_CORE_RWLock_Release+0x66>
10e587: 90 nop
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !next ||
10e588: 83 78 30 01 cmpl $0x1,0x30(%eax)
10e58c: 74 20 je 10e5ae <_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;
10e58e: ff 43 48 incl 0x48(%ebx)
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
10e591: 83 ec 08 sub $0x8,%esp
10e594: 50 push %eax
10e595: 53 push %ebx
10e596: e8 85 1c 00 00 call 110220 <_Thread_queue_Extract>
}
10e59b: 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 );
10e59e: 83 ec 0c sub $0xc,%esp
10e5a1: 53 push %ebx
10e5a2: e8 91 1d 00 00 call 110338 <_Thread_queue_First>
if ( !next ||
10e5a7: 83 c4 10 add $0x10,%esp
10e5aa: 85 c0 test %eax,%eax
10e5ac: 75 da jne 10e588 <_CORE_RWLock_Release+0x50>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10e5ae: 31 c0 xor %eax,%eax
10e5b0: 8b 5d fc mov -0x4(%ebp),%ebx
10e5b3: c9 leave
10e5b4: c3 ret
10e5b5: 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;
10e5b8: 8b 43 48 mov 0x48(%ebx),%eax
10e5bb: 48 dec %eax
10e5bc: 89 43 48 mov %eax,0x48(%ebx)
if ( the_rwlock->number_of_readers != 0 ) {
10e5bf: 85 c0 test %eax,%eax
10e5c1: 74 92 je 10e555 <_CORE_RWLock_Release+0x1d>
/* must be unlocked again */
_ISR_Enable( level );
10e5c3: 52 push %edx
10e5c4: 9d popf
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10e5c5: 31 c0 xor %eax,%eax
10e5c7: 8b 5d fc mov -0x4(%ebp),%ebx
10e5ca: c9 leave
10e5cb: c3 ret
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
_ISR_Enable( level );
10e5cc: 52 push %edx
10e5cd: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10e5ce: c7 41 34 02 00 00 00 movl $0x2,0x34(%ecx)
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10e5d5: 31 c0 xor %eax,%eax
10e5d7: 8b 5d fc mov -0x4(%ebp),%ebx
10e5da: c9 leave
10e5db: 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;
10e5dc: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx)
return CORE_RWLOCK_SUCCESSFUL;
10e5e3: eb c9 jmp 10e5ae <_CORE_RWLock_Release+0x76>
0010e5e8 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
10e5e8: 55 push %ebp
10e5e9: 89 e5 mov %esp,%ebp
10e5eb: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10e5ee: 8d 45 f4 lea -0xc(%ebp),%eax
10e5f1: 50 push %eax
10e5f2: ff 75 08 pushl 0x8(%ebp)
10e5f5: e8 5e 15 00 00 call 10fb58 <_Thread_Get>
switch ( location ) {
10e5fa: 83 c4 10 add $0x10,%esp
10e5fd: 8b 55 f4 mov -0xc(%ebp),%edx
10e600: 85 d2 test %edx,%edx
10e602: 75 17 jne 10e61b <_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 );
10e604: 83 ec 0c sub $0xc,%esp
10e607: 50 push %eax
10e608: e8 0b 1e 00 00 call 110418 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10e60d: a1 f0 ae 12 00 mov 0x12aef0,%eax
10e612: 48 dec %eax
10e613: a3 f0 ae 12 00 mov %eax,0x12aef0
10e618: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10e61b: c9 leave
10e61c: c3 ret
001198e0 <_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
)
{
1198e0: 55 push %ebp
1198e1: 89 e5 mov %esp,%ebp
1198e3: 57 push %edi
1198e4: 56 push %esi
1198e5: 53 push %ebx
1198e6: 83 ec 1c sub $0x1c,%esp
1198e9: 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 ) {
1198ec: 8b 45 10 mov 0x10(%ebp),%eax
1198ef: 39 43 4c cmp %eax,0x4c(%ebx)
1198f2: 72 60 jb 119954 <_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 ) {
1198f4: 8b 43 48 mov 0x48(%ebx),%eax
1198f7: 85 c0 test %eax,%eax
1198f9: 75 45 jne 119940 <_CORE_message_queue_Broadcast+0x60>
1198fb: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
119902: eb 18 jmp 11991c <_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;
119904: ff 45 e4 incl -0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
119907: 8b 42 2c mov 0x2c(%edx),%eax
11990a: 89 c7 mov %eax,%edi
11990c: 8b 75 0c mov 0xc(%ebp),%esi
11990f: 8b 4d 10 mov 0x10(%ebp),%ecx
119912: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
119914: 8b 42 28 mov 0x28(%edx),%eax
119917: 8b 55 10 mov 0x10(%ebp),%edx
11991a: 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 =
11991c: 83 ec 0c sub $0xc,%esp
11991f: 53 push %ebx
119920: e8 27 28 00 00 call 11c14c <_Thread_queue_Dequeue>
119925: 89 c2 mov %eax,%edx
119927: 83 c4 10 add $0x10,%esp
11992a: 85 c0 test %eax,%eax
11992c: 75 d6 jne 119904 <_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;
11992e: 8b 55 e4 mov -0x1c(%ebp),%edx
119931: 8b 45 1c mov 0x1c(%ebp),%eax
119934: 89 10 mov %edx,(%eax)
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
119936: 31 c0 xor %eax,%eax
}
119938: 8d 65 f4 lea -0xc(%ebp),%esp
11993b: 5b pop %ebx
11993c: 5e pop %esi
11993d: 5f pop %edi
11993e: c9 leave
11993f: 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;
119940: 8b 55 1c mov 0x1c(%ebp),%edx
119943: c7 02 00 00 00 00 movl $0x0,(%edx)
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
119949: 31 c0 xor %eax,%eax
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
11994b: 8d 65 f4 lea -0xc(%ebp),%esp
11994e: 5b pop %ebx
11994f: 5e pop %esi
119950: 5f pop %edi
119951: c9 leave
119952: c3 ret
119953: 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;
119954: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
119959: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
11995c: 5b pop %ebx <== NOT EXECUTED
11995d: 5e pop %esi <== NOT EXECUTED
11995e: 5f pop %edi <== NOT EXECUTED
11995f: c9 leave <== NOT EXECUTED
119960: c3 ret <== NOT EXECUTED
00114a20 <_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
)
{
114a20: 55 push %ebp
114a21: 89 e5 mov %esp,%ebp
114a23: 57 push %edi
114a24: 56 push %esi
114a25: 53 push %ebx
114a26: 83 ec 0c sub $0xc,%esp
114a29: 8b 5d 08 mov 0x8(%ebp),%ebx
114a2c: 8b 75 10 mov 0x10(%ebp),%esi
114a2f: 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;
114a32: 89 73 44 mov %esi,0x44(%ebx)
the_message_queue->number_of_pending_messages = 0;
114a35: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
the_message_queue->maximum_message_size = maximum_message_size;
114a3c: 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;
114a3f: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
the_message_queue->notify_argument = the_argument;
114a46: 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)) {
114a4d: a8 03 test $0x3,%al
114a4f: 74 17 je 114a68 <_CORE_message_queue_Initialize+0x48>
allocated_message_size += sizeof(uint32_t);
114a51: 8d 50 04 lea 0x4(%eax),%edx
allocated_message_size &= ~(sizeof(uint32_t) - 1);
114a54: 83 e2 fc and $0xfffffffc,%edx
}
if (allocated_message_size < maximum_message_size)
114a57: 39 d0 cmp %edx,%eax
114a59: 76 0f jbe 114a6a <_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;
114a5b: 31 c0 xor %eax,%eax
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
}
114a5d: 8d 65 f4 lea -0xc(%ebp),%esp
114a60: 5b pop %ebx
114a61: 5e pop %esi
114a62: 5f pop %edi
114a63: c9 leave
114a64: c3 ret
114a65: 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)) {
114a68: 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));
114a6a: 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 *
114a6d: 89 f8 mov %edi,%eax
114a6f: 0f af c6 imul %esi,%eax
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
114a72: 39 d0 cmp %edx,%eax
114a74: 72 e5 jb 114a5b <_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 );
114a76: 83 ec 0c sub $0xc,%esp
114a79: 50 push %eax
114a7a: e8 21 2b 00 00 call 1175a0 <_Workspace_Allocate>
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
114a7f: 89 43 5c mov %eax,0x5c(%ebx)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
114a82: 83 c4 10 add $0x10,%esp
114a85: 85 c0 test %eax,%eax
114a87: 74 d2 je 114a5b <_CORE_message_queue_Initialize+0x3b>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
114a89: 57 push %edi
114a8a: 56 push %esi
114a8b: 50 push %eax
114a8c: 8d 43 68 lea 0x68(%ebx),%eax
114a8f: 50 push %eax
114a90: e8 13 52 00 00 call 119ca8 <_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 );
114a95: 8d 43 54 lea 0x54(%ebx),%eax
114a98: 89 43 50 mov %eax,0x50(%ebx)
head->next = tail;
head->previous = NULL;
114a9b: 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 );
114aa2: 8d 43 50 lea 0x50(%ebx),%eax
114aa5: 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(
114aa8: 6a 06 push $0x6
114aaa: 68 80 00 00 00 push $0x80
114aaf: 8b 45 0c mov 0xc(%ebp),%eax
114ab2: 83 38 01 cmpl $0x1,(%eax)
114ab5: 0f 94 c0 sete %al
114ab8: 0f b6 c0 movzbl %al,%eax
114abb: 50 push %eax
114abc: 53 push %ebx
114abd: e8 b6 21 00 00 call 116c78 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
114ac2: 83 c4 20 add $0x20,%esp
114ac5: b0 01 mov $0x1,%al
}
114ac7: 8d 65 f4 lea -0xc(%ebp),%esp
114aca: 5b pop %ebx
114acb: 5e pop %esi
114acc: 5f pop %edi
114acd: c9 leave
114ace: c3 ret
001110b0 <_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
)
{
1110b0: 55 push %ebp
1110b1: 89 e5 mov %esp,%ebp
1110b3: 56 push %esi
1110b4: 53 push %ebx
1110b5: 83 ec 10 sub $0x10,%esp
1110b8: 8b 45 08 mov 0x8(%ebp),%eax
1110bb: 8b 55 0c mov 0xc(%ebp),%edx
1110be: 8b 4d 10 mov 0x10(%ebp),%ecx
1110c1: 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 ) {
1110c4: 81 f9 ff ff ff 7f cmp $0x7fffffff,%ecx
1110ca: 74 70 je 11113c <_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 ) {
1110cc: 81 f9 00 00 00 80 cmp $0x80000000,%ecx
1110d2: 0f 84 88 00 00 00 je 111160 <_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
}
1110d8: 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));
1110db: 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 ) ) {
1110de: 39 de cmp %ebx,%esi
1110e0: 74 05 je 1110e7 <_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 ) {
1110e2: 3b 4b 08 cmp 0x8(%ebx),%ecx
1110e5: 7d 45 jge 11112c <_CORE_message_queue_Insert_message+0x7c>
the_node = the_node->next;
continue;
}
break;
}
_ISR_Disable( level );
1110e7: 9c pushf
1110e8: fa cli
1110e9: 5e pop %esi
SET_NOTIFY();
1110ea: 8b 48 48 mov 0x48(%eax),%ecx
*
* INTERRUPT LATENCY:
* insert
*/
void _CORE_message_queue_Insert_message(
1110ed: 85 c9 test %ecx,%ecx
1110ef: 0f 94 45 f7 sete -0x9(%ebp)
}
break;
}
_ISR_Disable( level );
SET_NOTIFY();
the_message_queue->number_of_pending_messages++;
1110f3: 41 inc %ecx
1110f4: 89 48 48 mov %ecx,0x48(%eax)
_Chain_Insert_unprotected( the_node->previous, &the_message->Node );
1110f7: 8b 4b 04 mov 0x4(%ebx),%ecx
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
1110fa: 89 4a 04 mov %ecx,0x4(%edx)
before_node = after_node->next;
1110fd: 8b 19 mov (%ecx),%ebx
after_node->next = the_node;
1110ff: 89 11 mov %edx,(%ecx)
the_node->next = before_node;
111101: 89 1a mov %ebx,(%edx)
before_node->previous = the_node;
111103: 89 53 04 mov %edx,0x4(%ebx)
_ISR_Enable( level );
111106: 56 push %esi
111107: 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 )
111108: 80 7d f7 00 cmpb $0x0,-0x9(%ebp)
11110c: 74 16 je 111124 <_CORE_message_queue_Insert_message+0x74>
11110e: 8b 50 60 mov 0x60(%eax),%edx
111111: 85 d2 test %edx,%edx
111113: 74 0f je 111124 <_CORE_message_queue_Insert_message+0x74>
(*the_message_queue->notify_handler)(the_message_queue->notify_argument);
111115: 8b 40 64 mov 0x64(%eax),%eax
111118: 89 45 08 mov %eax,0x8(%ebp)
#endif
}
11111b: 83 c4 10 add $0x10,%esp
11111e: 5b pop %ebx
11111f: 5e pop %esi
111120: 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);
111121: ff e2 jmp *%edx
111123: 90 nop
#endif
}
111124: 83 c4 10 add $0x10,%esp
111127: 5b pop %ebx
111128: 5e pop %esi
111129: c9 leave
11112a: c3 ret
11112b: 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;
11112c: 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 ) ) {
11112e: 39 de cmp %ebx,%esi
111130: 74 b5 je 1110e7 <_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 ) {
111132: 3b 4b 08 cmp 0x8(%ebx),%ecx
111135: 7c b0 jl 1110e7 <_CORE_message_queue_Insert_message+0x37>
111137: eb f3 jmp 11112c <_CORE_message_queue_Insert_message+0x7c>
111139: 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 );
11113c: 9c pushf
11113d: fa cli
11113e: 5b pop %ebx
SET_NOTIFY();
11113f: 8b 48 48 mov 0x48(%eax),%ecx
*
* INTERRUPT LATENCY:
* insert
*/
void _CORE_message_queue_Insert_message(
111142: 85 c9 test %ecx,%ecx
111144: 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++;
111148: 41 inc %ecx
111149: 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;
11114c: 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 );
11114f: 8d 70 54 lea 0x54(%eax),%esi
111152: 89 32 mov %esi,(%edx)
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
111154: 89 50 58 mov %edx,0x58(%eax)
old_last->next = the_node;
111157: 89 11 mov %edx,(%ecx)
the_node->previous = old_last;
111159: 89 4a 04 mov %ecx,0x4(%edx)
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
11115c: 53 push %ebx
11115d: 9d popf
11115e: eb a8 jmp 111108 <_CORE_message_queue_Insert_message+0x58>
} else if ( submit_type == CORE_MESSAGE_QUEUE_URGENT_REQUEST ) {
_ISR_Disable( level );
111160: 9c pushf
111161: fa cli
111162: 5b pop %ebx
SET_NOTIFY();
111163: 8b 48 48 mov 0x48(%eax),%ecx
*
* INTERRUPT LATENCY:
* insert
*/
void _CORE_message_queue_Insert_message(
111166: 85 c9 test %ecx,%ecx
111168: 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++;
11116c: 41 inc %ecx
11116d: 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);
111170: 8d 48 50 lea 0x50(%eax),%ecx
111173: 89 4a 04 mov %ecx,0x4(%edx)
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
111176: 8b 48 50 mov 0x50(%eax),%ecx
after_node->next = the_node;
111179: 89 50 50 mov %edx,0x50(%eax)
the_node->next = before_node;
11117c: 89 0a mov %ecx,(%edx)
before_node->previous = the_node;
11117e: 89 51 04 mov %edx,0x4(%ecx)
_CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
111181: 53 push %ebx
111182: 9d popf
111183: eb 83 jmp 111108 <_CORE_message_queue_Insert_message+0x58>
00114ad0 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
114ad0: 55 push %ebp
114ad1: 89 e5 mov %esp,%ebp
114ad3: 57 push %edi
114ad4: 56 push %esi
114ad5: 53 push %ebx
114ad6: 83 ec 2c sub $0x2c,%esp
114ad9: 8b 55 08 mov 0x8(%ebp),%edx
114adc: 8b 45 0c mov 0xc(%ebp),%eax
114adf: 89 45 dc mov %eax,-0x24(%ebp)
114ae2: 8b 4d 10 mov 0x10(%ebp),%ecx
114ae5: 89 4d e0 mov %ecx,-0x20(%ebp)
114ae8: 8b 45 14 mov 0x14(%ebp),%eax
114aeb: 8b 5d 1c mov 0x1c(%ebp),%ebx
114aee: 89 5d d8 mov %ebx,-0x28(%ebp)
114af1: 0f b6 7d 18 movzbl 0x18(%ebp),%edi
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
114af5: 8b 0d d8 11 13 00 mov 0x1311d8,%ecx
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
114afb: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx)
_ISR_Disable( level );
114b02: 9c pushf
114b03: fa cli
114b04: 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 );
}
114b07: 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 );
114b0a: 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))
114b0d: 39 f3 cmp %esi,%ebx
114b0f: 74 7b je 114b8c <_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;
114b11: 8b 0b mov (%ebx),%ecx
head->next = new_first;
114b13: 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 );
114b16: 8d 72 50 lea 0x50(%edx),%esi
114b19: 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;
114b1c: ff 4a 48 decl 0x48(%edx)
_ISR_Enable( level );
114b1f: ff 75 e4 pushl -0x1c(%ebp)
114b22: 9d popf
*size_p = the_message->Contents.size;
114b23: 8b 4b 0c mov 0xc(%ebx),%ecx
114b26: 89 08 mov %ecx,(%eax)
_Thread_Executing->Wait.count =
114b28: 8b 73 08 mov 0x8(%ebx),%esi
114b2b: 8b 0d d8 11 13 00 mov 0x1311d8,%ecx
114b31: 89 71 24 mov %esi,0x24(%ecx)
_CORE_message_queue_Get_message_priority( the_message );
_CORE_message_queue_Copy_buffer(
the_message->Contents.buffer,
114b34: 8d 4b 10 lea 0x10(%ebx),%ecx
114b37: 89 4d e4 mov %ecx,-0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
114b3a: 8b 08 mov (%eax),%ecx
114b3c: 8b 7d e0 mov -0x20(%ebp),%edi
114b3f: 8b 75 e4 mov -0x1c(%ebp),%esi
114b42: 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 );
114b44: 83 ec 0c sub $0xc,%esp
114b47: 52 push %edx
114b48: 89 55 d4 mov %edx,-0x2c(%ebp)
114b4b: e8 98 1d 00 00 call 1168e8 <_Thread_queue_Dequeue>
if ( !the_thread ) {
114b50: 83 c4 10 add $0x10,%esp
114b53: 85 c0 test %eax,%eax
114b55: 8b 55 d4 mov -0x2c(%ebp),%edx
114b58: 0f 84 86 00 00 00 je 114be4 <_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;
114b5e: 8b 48 24 mov 0x24(%eax),%ecx
114b61: 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;
114b64: 8b 48 30 mov 0x30(%eax),%ecx
114b67: 89 4b 0c mov %ecx,0xc(%ebx)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
114b6a: 8b 70 2c mov 0x2c(%eax),%esi
114b6d: 8b 7d e4 mov -0x1c(%ebp),%edi
114b70: 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(
114b72: 8b 43 08 mov 0x8(%ebx),%eax
114b75: 89 45 10 mov %eax,0x10(%ebp)
114b78: 89 5d 0c mov %ebx,0xc(%ebp)
114b7b: 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 );
}
114b7e: 8d 65 f4 lea -0xc(%ebp),%esp
114b81: 5b pop %ebx
114b82: 5e pop %esi
114b83: 5f pop %edi
114b84: c9 leave
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
114b85: e9 7a 51 00 00 jmp 119d04 <_CORE_message_queue_Insert_message>
114b8a: 66 90 xchg %ax,%ax
return;
}
#endif
}
if ( !wait ) {
114b8c: 89 fb mov %edi,%ebx
114b8e: 84 db test %bl,%bl
114b90: 75 16 jne 114ba8 <_CORE_message_queue_Seize+0xd8>
_ISR_Enable( level );
114b92: ff 75 e4 pushl -0x1c(%ebp)
114b95: 9d popf
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
114b96: 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 );
}
114b9d: 8d 65 f4 lea -0xc(%ebp),%esp
114ba0: 5b pop %ebx
114ba1: 5e pop %esi
114ba2: 5f pop %edi
114ba3: c9 leave
114ba4: c3 ret
114ba5: 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;
114ba8: 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;
114baf: 89 51 44 mov %edx,0x44(%ecx)
executing->Wait.id = id;
114bb2: 8b 5d dc mov -0x24(%ebp),%ebx
114bb5: 89 59 20 mov %ebx,0x20(%ecx)
executing->Wait.return_argument_second.mutable_object = buffer;
114bb8: 8b 5d e0 mov -0x20(%ebp),%ebx
114bbb: 89 59 2c mov %ebx,0x2c(%ecx)
executing->Wait.return_argument = size_p;
114bbe: 89 41 28 mov %eax,0x28(%ecx)
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
114bc1: ff 75 e4 pushl -0x1c(%ebp)
114bc4: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
114bc5: c7 45 10 3c 6d 11 00 movl $0x116d3c,0x10(%ebp)
114bcc: 8b 45 d8 mov -0x28(%ebp),%eax
114bcf: 89 45 0c mov %eax,0xc(%ebp)
114bd2: 89 55 08 mov %edx,0x8(%ebp)
}
114bd5: 8d 65 f4 lea -0xc(%ebp),%esp
114bd8: 5b pop %ebx
114bd9: 5e pop %esi
114bda: 5f pop %edi
114bdb: 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 );
114bdc: e9 2f 1e 00 00 jmp 116a10 <_Thread_queue_Enqueue_with_handler>
114be1: 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 );
114be4: 89 5d 0c mov %ebx,0xc(%ebp)
114be7: 83 c2 68 add $0x68,%edx
114bea: 89 55 08 mov %edx,0x8(%ebp)
}
114bed: 8d 65 f4 lea -0xc(%ebp),%esp
114bf0: 5b pop %ebx
114bf1: 5e pop %esi
114bf2: 5f pop %edi
114bf3: c9 leave
114bf4: e9 a7 fd ff ff jmp 1149a0 <_Chain_Append>
0010c03c <_CORE_message_queue_Submit>:
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
10c03c: 55 push %ebp
10c03d: 89 e5 mov %esp,%ebp
10c03f: 57 push %edi
10c040: 56 push %esi
10c041: 53 push %ebx
10c042: 83 ec 1c sub $0x1c,%esp
10c045: 8b 5d 08 mov 0x8(%ebp),%ebx
10c048: 8b 75 0c mov 0xc(%ebp),%esi
10c04b: 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 ) {
10c04e: 8b 45 10 mov 0x10(%ebp),%eax
10c051: 39 43 4c cmp %eax,0x4c(%ebx)
10c054: 72 32 jb 10c088 <_CORE_message_queue_Submit+0x4c>
}
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
10c056: 8b 43 48 mov 0x48(%ebx),%eax
10c059: 85 c0 test %eax,%eax
10c05b: 74 3b je 10c098 <_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 <
10c05d: 39 43 44 cmp %eax,0x44(%ebx)
10c060: 0f 87 ba 00 00 00 ja 10c120 <_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 ) {
10c066: 84 c9 test %cl,%cl
10c068: 0f 84 ee 00 00 00 je 10c15c <_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() ) {
10c06e: 8b 15 54 7b 12 00 mov 0x127b54,%edx
10c074: 85 d2 test %edx,%edx
10c076: 74 60 je 10c0d8 <_CORE_message_queue_Submit+0x9c>
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED;
10c078: 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
}
10c07d: 8d 65 f4 lea -0xc(%ebp),%esp
10c080: 5b pop %ebx
10c081: 5e pop %esi
10c082: 5f pop %edi
10c083: c9 leave
10c084: c3 ret
10c085: 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;
10c088: 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
}
10c08d: 8d 65 f4 lea -0xc(%ebp),%esp
10c090: 5b pop %ebx
10c091: 5e pop %esi
10c092: 5f pop %edi
10c093: c9 leave
10c094: c3 ret
10c095: 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 );
10c098: 83 ec 0c sub $0xc,%esp
10c09b: 53 push %ebx
10c09c: 88 4d e4 mov %cl,-0x1c(%ebp)
10c09f: e8 04 1c 00 00 call 10dca8 <_Thread_queue_Dequeue>
10c0a4: 89 c2 mov %eax,%edx
if ( the_thread ) {
10c0a6: 83 c4 10 add $0x10,%esp
10c0a9: 85 c0 test %eax,%eax
10c0ab: 8a 4d e4 mov -0x1c(%ebp),%cl
10c0ae: 0f 84 b8 00 00 00 je 10c16c <_CORE_message_queue_Submit+0x130>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
10c0b4: 8b 40 2c mov 0x2c(%eax),%eax
10c0b7: 89 c7 mov %eax,%edi
10c0b9: 8b 4d 10 mov 0x10(%ebp),%ecx
10c0bc: 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;
10c0be: 8b 42 28 mov 0x28(%edx),%eax
10c0c1: 8b 4d 10 mov 0x10(%ebp),%ecx
10c0c4: 89 08 mov %ecx,(%eax)
the_thread->Wait.count = (uint32_t) submit_type;
10c0c6: 8b 45 1c mov 0x1c(%ebp),%eax
10c0c9: 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;
10c0cc: 31 c0 xor %eax,%eax
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
#endif
}
10c0ce: 8d 65 f4 lea -0xc(%ebp),%esp
10c0d1: 5b pop %ebx
10c0d2: 5e pop %esi
10c0d3: 5f pop %edi
10c0d4: c9 leave
10c0d5: c3 ret
10c0d6: 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;
10c0d8: a1 58 7b 12 00 mov 0x127b58,%eax
ISR_Level level;
_ISR_Disable( level );
10c0dd: 9c pushf
10c0de: fa cli
10c0df: 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;
10c0e0: 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;
10c0e7: 89 58 44 mov %ebx,0x44(%eax)
executing->Wait.id = id;
10c0ea: 8b 55 14 mov 0x14(%ebp),%edx
10c0ed: 89 50 20 mov %edx,0x20(%eax)
executing->Wait.return_argument_second.immutable_object = buffer;
10c0f0: 89 70 2c mov %esi,0x2c(%eax)
executing->Wait.option = (uint32_t) size;
10c0f3: 8b 55 10 mov 0x10(%ebp),%edx
10c0f6: 89 50 30 mov %edx,0x30(%eax)
executing->Wait.count = submit_type;
10c0f9: 8b 55 1c mov 0x1c(%ebp),%edx
10c0fc: 89 50 24 mov %edx,0x24(%eax)
_ISR_Enable( level );
10c0ff: 51 push %ecx
10c100: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
10c101: 50 push %eax
10c102: 68 fc e0 10 00 push $0x10e0fc
10c107: ff 75 24 pushl 0x24(%ebp)
10c10a: 53 push %ebx
10c10b: e8 c0 1c 00 00 call 10ddd0 <_Thread_queue_Enqueue_with_handler>
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
10c110: 83 c4 10 add $0x10,%esp
10c113: b8 07 00 00 00 mov $0x7,%eax
#endif
}
10c118: 8d 65 f4 lea -0xc(%ebp),%esp
10c11b: 5b pop %ebx
10c11c: 5e pop %esi
10c11d: 5f pop %edi
10c11e: c9 leave
10c11f: 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 );
10c120: 83 ec 0c sub $0xc,%esp
10c123: 8d 43 68 lea 0x68(%ebx),%eax
10c126: 50 push %eax
10c127: e8 ec fe ff ff call 10c018 <_Chain_Get>
10c12c: 89 c2 mov %eax,%edx
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED;
#endif
_CORE_message_queue_Copy_buffer(
buffer,
the_message->Contents.buffer,
10c12e: 8d 40 10 lea 0x10(%eax),%eax
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
10c131: 89 c7 mov %eax,%edi
10c133: 8b 4d 10 mov 0x10(%ebp),%ecx
10c136: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
size
);
the_message->Contents.size = size;
10c138: 8b 4d 10 mov 0x10(%ebp),%ecx
10c13b: 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;
10c13e: 8b 45 1c mov 0x1c(%ebp),%eax
10c141: 89 42 08 mov %eax,0x8(%edx)
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
10c144: 83 c4 0c add $0xc,%esp
10c147: 50 push %eax
10c148: 52 push %edx
10c149: 53 push %ebx
10c14a: e8 61 4f 00 00 call 1110b0 <_CORE_message_queue_Insert_message>
the_message_queue,
the_message,
submit_type
);
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
10c14f: 83 c4 10 add $0x10,%esp
10c152: 31 c0 xor %eax,%eax
10c154: e9 34 ff ff ff jmp 10c08d <_CORE_message_queue_Submit+0x51>
10c159: 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;
10c15c: 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
}
10c161: 8d 65 f4 lea -0xc(%ebp),%esp
10c164: 5b pop %ebx
10c165: 5e pop %esi
10c166: 5f pop %edi
10c167: c9 leave
10c168: c3 ret
10c169: 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 ) {
10c16c: 8b 43 48 mov 0x48(%ebx),%eax
10c16f: e9 e9 fe ff ff jmp 10c05d <_CORE_message_queue_Submit+0x21>
0010c180 <_CORE_mutex_Initialize>:
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
10c180: 55 push %ebp
10c181: 89 e5 mov %esp,%ebp
10c183: 57 push %edi
10c184: 56 push %esi
10c185: 53 push %ebx
10c186: 83 ec 0c sub $0xc,%esp
10c189: 8b 45 08 mov 0x8(%ebp),%eax
10c18c: 8b 5d 0c mov 0xc(%ebp),%ebx
10c18f: 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;
10c192: 8d 78 40 lea 0x40(%eax),%edi
10c195: b9 04 00 00 00 mov $0x4,%ecx
10c19a: 89 de mov %ebx,%esi
10c19c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_mutex->lock = initial_lock;
10c19e: 89 50 50 mov %edx,0x50(%eax)
the_mutex->blocked_count = 0;
10c1a1: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
if ( initial_lock == CORE_MUTEX_LOCKED ) {
10c1a8: 85 d2 test %edx,%edx
10c1aa: 75 30 jne 10c1dc <_CORE_mutex_Initialize+0x5c>
the_mutex->nest_count = 1;
10c1ac: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax)
the_mutex->holder = _Thread_Executing;
10c1b3: 8b 15 58 7b 12 00 mov 0x127b58,%edx
10c1b9: 89 50 5c mov %edx,0x5c(%eax)
the_mutex->holder_id = _Thread_Executing->Object.id;
10c1bc: 8b 4a 08 mov 0x8(%edx),%ecx
10c1bf: 89 48 60 mov %ecx,0x60(%eax)
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10c1c2: 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 ) ||
10c1c5: 83 f9 02 cmp $0x2,%ecx
10c1c8: 74 05 je 10c1cf <_CORE_mutex_Initialize+0x4f>
10c1ca: 83 f9 03 cmp $0x3,%ecx
10c1cd: 75 22 jne 10c1f1 <_CORE_mutex_Initialize+0x71>
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
10c1cf: 8b 48 4c mov 0x4c(%eax),%ecx
10c1d2: 39 4a 14 cmp %ecx,0x14(%edx)
10c1d5: 72 41 jb 10c218 <_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++;
10c1d7: ff 42 1c incl 0x1c(%edx)
10c1da: eb 15 jmp 10c1f1 <_CORE_mutex_Initialize+0x71>
}
} else {
the_mutex->nest_count = 0;
10c1dc: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
the_mutex->holder = NULL;
10c1e3: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
the_mutex->holder_id = 0;
10c1ea: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
}
_Thread_queue_Initialize(
10c1f1: 6a 05 push $0x5
10c1f3: 68 00 04 00 00 push $0x400
10c1f8: 31 d2 xor %edx,%edx
10c1fa: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10c1fe: 0f 95 c2 setne %dl
10c201: 52 push %edx
10c202: 50 push %eax
10c203: e8 30 1e 00 00 call 10e038 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_FIFO : THREAD_QUEUE_DISCIPLINE_PRIORITY,
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c208: 83 c4 10 add $0x10,%esp
10c20b: 31 c0 xor %eax,%eax
}
10c20d: 8d 65 f4 lea -0xc(%ebp),%esp
10c210: 5b pop %ebx
10c211: 5e pop %esi
10c212: 5f pop %edi
10c213: c9 leave
10c214: c3 ret
10c215: 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;
10c218: b8 06 00 00 00 mov $0x6,%eax
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10c21d: 8d 65 f4 lea -0xc(%ebp),%esp
10c220: 5b pop %ebx
10c221: 5e pop %esi
10c222: 5f pop %edi
10c223: c9 leave
10c224: c3 ret
0010c278 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
10c278: 55 push %ebp
10c279: 89 e5 mov %esp,%ebp
10c27b: 53 push %ebx
10c27c: 83 ec 14 sub $0x14,%esp
10c27f: 8b 5d 08 mov 0x8(%ebp),%ebx
10c282: 8a 55 10 mov 0x10(%ebp),%dl
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10c285: a1 70 75 12 00 mov 0x127570,%eax
10c28a: 85 c0 test %eax,%eax
10c28c: 74 04 je 10c292 <_CORE_mutex_Seize+0x1a>
10c28e: 84 d2 test %dl,%dl
10c290: 75 36 jne 10c2c8 <_CORE_mutex_Seize+0x50><== ALWAYS TAKEN
10c292: 83 ec 08 sub $0x8,%esp
10c295: 8d 45 18 lea 0x18(%ebp),%eax
10c298: 50 push %eax
10c299: 53 push %ebx
10c29a: 88 55 f4 mov %dl,-0xc(%ebp)
10c29d: e8 e6 4e 00 00 call 111188 <_CORE_mutex_Seize_interrupt_trylock>
10c2a2: 83 c4 10 add $0x10,%esp
10c2a5: 85 c0 test %eax,%eax
10c2a7: 8a 55 f4 mov -0xc(%ebp),%dl
10c2aa: 74 14 je 10c2c0 <_CORE_mutex_Seize+0x48>
10c2ac: 84 d2 test %dl,%dl
10c2ae: 75 30 jne 10c2e0 <_CORE_mutex_Seize+0x68>
10c2b0: ff 75 18 pushl 0x18(%ebp)
10c2b3: 9d popf
10c2b4: a1 58 7b 12 00 mov 0x127b58,%eax
10c2b9: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax)
}
10c2c0: 8b 5d fc mov -0x4(%ebp),%ebx
10c2c3: c9 leave
10c2c4: c3 ret
10c2c5: 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 );
10c2c8: 83 3d 40 77 12 00 01 cmpl $0x1,0x127740
10c2cf: 76 c1 jbe 10c292 <_CORE_mutex_Seize+0x1a>
10c2d1: 53 push %ebx
10c2d2: 6a 12 push $0x12
10c2d4: 6a 00 push $0x0
10c2d6: 6a 00 push $0x0
10c2d8: e8 1b 06 00 00 call 10c8f8 <_Internal_error_Occurred>
10c2dd: 8d 76 00 lea 0x0(%esi),%esi
10c2e0: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx)
10c2e7: a1 58 7b 12 00 mov 0x127b58,%eax
10c2ec: 89 58 44 mov %ebx,0x44(%eax)
10c2ef: 8b 55 0c mov 0xc(%ebp),%edx
10c2f2: 89 50 20 mov %edx,0x20(%eax)
10c2f5: a1 70 75 12 00 mov 0x127570,%eax
10c2fa: 40 inc %eax
10c2fb: a3 70 75 12 00 mov %eax,0x127570
10c300: ff 75 18 pushl 0x18(%ebp)
10c303: 9d popf
10c304: 83 ec 08 sub $0x8,%esp
10c307: ff 75 14 pushl 0x14(%ebp)
10c30a: 53 push %ebx
10c30b: e8 18 ff ff ff call 10c228 <_CORE_mutex_Seize_interrupt_blocking>
10c310: 83 c4 10 add $0x10,%esp
}
10c313: 8b 5d fc mov -0x4(%ebp),%ebx
10c316: c9 leave
10c317: c3 ret
00111188 <_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
)
{
111188: 55 push %ebp
111189: 89 e5 mov %esp,%ebp
11118b: 56 push %esi
11118c: 53 push %ebx
11118d: 8b 45 08 mov 0x8(%ebp),%eax
111190: 8b 4d 0c mov 0xc(%ebp),%ecx
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
111193: 8b 15 58 7b 12 00 mov 0x127b58,%edx
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
111199: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
1111a0: 8b 58 50 mov 0x50(%eax),%ebx
1111a3: 85 db test %ebx,%ebx
1111a5: 74 31 je 1111d8 <_CORE_mutex_Seize_interrupt_trylock+0x50>
the_mutex->lock = CORE_MUTEX_LOCKED;
1111a7: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
the_mutex->holder = executing;
1111ae: 89 50 5c mov %edx,0x5c(%eax)
the_mutex->holder_id = executing->Object.id;
1111b1: 8b 5a 08 mov 0x8(%edx),%ebx
1111b4: 89 58 60 mov %ebx,0x60(%eax)
the_mutex->nest_count = 1;
1111b7: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax)
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}
1111be: 8b 58 48 mov 0x48(%eax),%ebx
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
1111c1: 83 fb 02 cmp $0x2,%ebx
1111c4: 74 26 je 1111ec <_CORE_mutex_Seize_interrupt_trylock+0x64>
1111c6: 83 fb 03 cmp $0x3,%ebx
1111c9: 74 3d je 111208 <_CORE_mutex_Seize_interrupt_trylock+0x80>
executing->resource_count++;
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
_ISR_Enable( *level_p );
1111cb: ff 31 pushl (%ecx)
1111cd: 9d popf
return 0;
1111ce: 31 c0 xor %eax,%eax
1111d0: 8d 65 f8 lea -0x8(%ebp),%esp
1111d3: 5b pop %ebx
1111d4: 5e pop %esi
1111d5: c9 leave
1111d6: c3 ret
1111d7: 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 ) ) {
1111d8: 3b 50 5c cmp 0x5c(%eax),%edx
1111db: 74 17 je 1111f4 <_CORE_mutex_Seize_interrupt_trylock+0x6c>
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
1111dd: b8 01 00 00 00 mov $0x1,%eax
1111e2: 8d 65 f8 lea -0x8(%ebp),%esp
1111e5: 5b pop %ebx
1111e6: 5e pop %esi
1111e7: c9 leave
1111e8: c3 ret
1111e9: 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++;
1111ec: ff 42 1c incl 0x1c(%edx)
1111ef: eb da jmp 1111cb <_CORE_mutex_Seize_interrupt_trylock+0x43>
1111f1: 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 ) {
1111f4: 8b 58 40 mov 0x40(%eax),%ebx
1111f7: 85 db test %ebx,%ebx
1111f9: 75 45 jne 111240 <_CORE_mutex_Seize_interrupt_trylock+0xb8>
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
1111fb: ff 40 54 incl 0x54(%eax)
_ISR_Enable( *level_p );
1111fe: ff 31 pushl (%ecx)
111200: 9d popf
return 0;
111201: 31 c0 xor %eax,%eax
111203: eb dd jmp 1111e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a>
111205: 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++;
111208: 8b 5a 1c mov 0x1c(%edx),%ebx
11120b: 8d 73 01 lea 0x1(%ebx),%esi
11120e: 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 ) {
111211: 8b 72 14 mov 0x14(%edx),%esi
111214: 39 70 4c cmp %esi,0x4c(%eax)
111217: 74 6b je 111284 <_CORE_mutex_Seize_interrupt_trylock+0xfc>
_ISR_Enable( *level_p );
return 0;
}
if ( current > ceiling ) {
111219: 72 39 jb 111254 <_CORE_mutex_Seize_interrupt_trylock+0xcc>
);
_Thread_Enable_dispatch();
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
11121b: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx)
the_mutex->lock = CORE_MUTEX_UNLOCKED;
111222: c7 40 50 01 00 00 00 movl $0x1,0x50(%eax)
the_mutex->nest_count = 0; /* undo locking above */
111229: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
executing->resource_count--; /* undo locking above */
111230: 89 5a 1c mov %ebx,0x1c(%edx)
_ISR_Enable( *level_p );
111233: ff 31 pushl (%ecx)
111235: 9d popf
return 0;
111236: 31 c0 xor %eax,%eax
111238: 8d 65 f8 lea -0x8(%ebp),%esp
11123b: 5b pop %ebx
11123c: 5e pop %esi
11123d: c9 leave
11123e: c3 ret
11123f: 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 ) {
111240: 4b dec %ebx
111241: 75 9a jne 1111dd <_CORE_mutex_Seize_interrupt_trylock+0x55>
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
_ISR_Enable( *level_p );
return 0;
case CORE_MUTEX_NESTING_IS_ERROR:
executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
111243: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx)
_ISR_Enable( *level_p );
11124a: ff 31 pushl (%ecx)
11124c: 9d popf
return 0;
11124d: 31 c0 xor %eax,%eax
11124f: eb 91 jmp 1111e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a>
111251: 8d 76 00 lea 0x0(%esi),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
111254: 8b 15 70 75 12 00 mov 0x127570,%edx
11125a: 42 inc %edx
11125b: 89 15 70 75 12 00 mov %edx,0x127570
return 0;
}
if ( current > ceiling ) {
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
111261: ff 31 pushl (%ecx)
111263: 9d popf
_Thread_Change_priority(
111264: 52 push %edx
111265: 6a 00 push $0x0
111267: ff 70 4c pushl 0x4c(%eax)
11126a: ff 70 5c pushl 0x5c(%eax)
11126d: e8 ce c1 ff ff call 10d440 <_Thread_Change_priority>
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
111272: e8 7d c6 ff ff call 10d8f4 <_Thread_Enable_dispatch>
111277: 83 c4 10 add $0x10,%esp
return 0;
11127a: 31 c0 xor %eax,%eax
11127c: e9 61 ff ff ff jmp 1111e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a>
111281: 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 );
111284: ff 31 pushl (%ecx)
111286: 9d popf
return 0;
111287: 31 c0 xor %eax,%eax
111289: e9 54 ff ff ff jmp 1111e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a>
0010c318 <_CORE_mutex_Surrender>:
#else
Objects_Id id __attribute__((unused)),
CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused))
#endif
)
{
10c318: 55 push %ebp
10c319: 89 e5 mov %esp,%ebp
10c31b: 53 push %ebx
10c31c: 83 ec 04 sub $0x4,%esp
10c31f: 8b 5d 08 mov 0x8(%ebp),%ebx
Thread_Control *the_thread;
Thread_Control *holder;
holder = the_mutex->holder;
10c322: 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 ) {
10c325: 80 7b 44 00 cmpb $0x0,0x44(%ebx)
10c329: 74 15 je 10c340 <_CORE_mutex_Surrender+0x28>
if ( !_Thread_Is_executing( holder ) )
10c32b: 3b 05 58 7b 12 00 cmp 0x127b58,%eax
10c331: 74 0d je 10c340 <_CORE_mutex_Surrender+0x28>
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
10c333: b8 03 00 00 00 mov $0x3,%eax
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10c338: 8b 5d fc mov -0x4(%ebp),%ebx
10c33b: c9 leave
10c33c: c3 ret
10c33d: 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 )
10c340: 8b 53 54 mov 0x54(%ebx),%edx
10c343: 85 d2 test %edx,%edx
10c345: 74 51 je 10c398 <_CORE_mutex_Surrender+0x80>
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
10c347: 4a dec %edx
10c348: 89 53 54 mov %edx,0x54(%ebx)
if ( the_mutex->nest_count != 0 ) {
10c34b: 85 d2 test %edx,%edx
10c34d: 75 49 jne 10c398 <_CORE_mutex_Surrender+0x80>
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10c34f: 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 ) ||
10c352: 83 fa 02 cmp $0x2,%edx
10c355: 74 69 je 10c3c0 <_CORE_mutex_Surrender+0xa8>
10c357: 83 fa 03 cmp $0x3,%edx
10c35a: 74 64 je 10c3c0 <_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;
10c35c: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
the_mutex->holder_id = 0;
10c363: 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 ) ) ) {
10c36a: 83 ec 0c sub $0xc,%esp
10c36d: 53 push %ebx
10c36e: e8 35 19 00 00 call 10dca8 <_Thread_queue_Dequeue>
10c373: 83 c4 10 add $0x10,%esp
10c376: 85 c0 test %eax,%eax
10c378: 74 7a je 10c3f4 <_CORE_mutex_Surrender+0xdc>
} else
#endif
{
the_mutex->holder = the_thread;
10c37a: 89 43 5c mov %eax,0x5c(%ebx)
the_mutex->holder_id = the_thread->Object.id;
10c37d: 8b 50 08 mov 0x8(%eax),%edx
10c380: 89 53 60 mov %edx,0x60(%ebx)
the_mutex->nest_count = 1;
10c383: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx)
switch ( the_mutex->Attributes.discipline ) {
10c38a: 8b 53 48 mov 0x48(%ebx),%edx
10c38d: 83 fa 02 cmp $0x2,%edx
10c390: 74 56 je 10c3e8 <_CORE_mutex_Surrender+0xd0>
10c392: 83 fa 03 cmp $0x3,%edx
10c395: 74 09 je 10c3a0 <_CORE_mutex_Surrender+0x88>
10c397: 90 nop
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c398: 31 c0 xor %eax,%eax
}
10c39a: 8b 5d fc mov -0x4(%ebp),%ebx
10c39d: c9 leave
10c39e: c3 ret
10c39f: 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++;
10c3a0: ff 40 1c incl 0x1c(%eax)
if (the_mutex->Attributes.priority_ceiling <
10c3a3: 8b 53 4c mov 0x4c(%ebx),%edx
10c3a6: 3b 50 14 cmp 0x14(%eax),%edx
10c3a9: 73 ed jae 10c398 <_CORE_mutex_Surrender+0x80>
the_thread->current_priority){
_Thread_Change_priority(
10c3ab: 51 push %ecx
10c3ac: 6a 00 push $0x0
10c3ae: 52 push %edx
10c3af: 50 push %eax
10c3b0: e8 8b 10 00 00 call 10d440 <_Thread_Change_priority>
10c3b5: 83 c4 10 add $0x10,%esp
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c3b8: 31 c0 xor %eax,%eax
10c3ba: e9 79 ff ff ff jmp 10c338 <_CORE_mutex_Surrender+0x20>
10c3bf: 90 nop
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
10c3c0: 8b 50 1c mov 0x1c(%eax),%edx
10c3c3: 4a dec %edx
10c3c4: 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 &&
10c3c7: 85 d2 test %edx,%edx
10c3c9: 75 91 jne 10c35c <_CORE_mutex_Surrender+0x44>
holder->real_priority != holder->current_priority ) {
10c3cb: 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 &&
10c3ce: 3b 50 14 cmp 0x14(%eax),%edx
10c3d1: 74 89 je 10c35c <_CORE_mutex_Surrender+0x44>
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, true );
10c3d3: 51 push %ecx
10c3d4: 6a 01 push $0x1
10c3d6: 52 push %edx
10c3d7: 50 push %eax
10c3d8: e8 63 10 00 00 call 10d440 <_Thread_Change_priority>
10c3dd: 83 c4 10 add $0x10,%esp
10c3e0: e9 77 ff ff ff jmp 10c35c <_CORE_mutex_Surrender+0x44>
10c3e5: 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++;
10c3e8: ff 40 1c incl 0x1c(%eax)
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c3eb: 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;
10c3ed: e9 46 ff ff ff jmp 10c338 <_CORE_mutex_Surrender+0x20>
10c3f2: 66 90 xchg %ax,%ax
}
break;
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
10c3f4: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx)
return CORE_MUTEX_STATUS_SUCCESSFUL;
10c3fb: 31 c0 xor %eax,%eax
10c3fd: e9 36 ff ff ff jmp 10c338 <_CORE_mutex_Surrender+0x20>
00115298 <_CORE_semaphore_Seize>:
CORE_semaphore_Control *the_semaphore,
Objects_Id id,
bool wait,
Watchdog_Interval timeout
)
{
115298: 55 push %ebp
115299: 89 e5 mov %esp,%ebp
11529b: 57 push %edi
11529c: 56 push %esi
11529d: 53 push %ebx
11529e: 83 ec 1c sub $0x1c,%esp
1152a1: 8b 45 08 mov 0x8(%ebp),%eax
1152a4: 8b 7d 0c mov 0xc(%ebp),%edi
1152a7: 8b 75 14 mov 0x14(%ebp),%esi
1152aa: 8a 5d 10 mov 0x10(%ebp),%bl
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
1152ad: 8b 15 d8 d8 12 00 mov 0x12d8d8,%edx
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
1152b3: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
_ISR_Disable( level );
1152ba: 9c pushf
1152bb: fa cli
1152bc: 8f 45 e4 popl -0x1c(%ebp)
if ( the_semaphore->count != 0 ) {
1152bf: 8b 48 48 mov 0x48(%eax),%ecx
1152c2: 85 c9 test %ecx,%ecx
1152c4: 75 46 jne 11530c <_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 ) {
1152c6: 84 db test %bl,%bl
1152c8: 75 16 jne 1152e0 <_CORE_semaphore_Seize+0x48>
_ISR_Enable( level );
1152ca: ff 75 e4 pushl -0x1c(%ebp)
1152cd: 9d popf
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
1152ce: 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 );
}
1152d5: 83 c4 1c add $0x1c,%esp
1152d8: 5b pop %ebx
1152d9: 5e pop %esi
1152da: 5f pop %edi
1152db: c9 leave
1152dc: c3 ret
1152dd: 8d 76 00 lea 0x0(%esi),%esi
1152e0: 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;
1152e7: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
1152ea: 89 7a 20 mov %edi,0x20(%edx)
_ISR_Enable( level );
1152ed: ff 75 e4 pushl -0x1c(%ebp)
1152f0: 9d popf
_Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
1152f1: c7 45 10 20 1b 11 00 movl $0x111b20,0x10(%ebp)
1152f8: 89 75 0c mov %esi,0xc(%ebp)
1152fb: 89 45 08 mov %eax,0x8(%ebp)
}
1152fe: 83 c4 1c add $0x1c,%esp
115301: 5b pop %ebx
115302: 5e pop %esi
115303: 5f pop %edi
115304: 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 );
115305: e9 ea c4 ff ff jmp 1117f4 <_Thread_queue_Enqueue_with_handler>
11530a: 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;
11530c: 49 dec %ecx
11530d: 89 48 48 mov %ecx,0x48(%eax)
_ISR_Enable( level );
115310: ff 75 e4 pushl -0x1c(%ebp)
115313: 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 );
}
115314: 83 c4 1c add $0x1c,%esp
115317: 5b pop %ebx
115318: 5e pop %esi
115319: 5f pop %edi
11531a: c9 leave
11531b: c3 ret
0010c450 <_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
)
{
10c450: 55 push %ebp
10c451: 89 e5 mov %esp,%ebp
10c453: 53 push %ebx
10c454: 83 ec 10 sub $0x10,%esp
10c457: 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)) ) {
10c45a: 53 push %ebx
10c45b: e8 48 18 00 00 call 10dca8 <_Thread_queue_Dequeue>
10c460: 83 c4 10 add $0x10,%esp
10c463: 85 c0 test %eax,%eax
10c465: 74 09 je 10c470 <_CORE_semaphore_Surrender+0x20>
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10c467: 31 c0 xor %eax,%eax
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
10c469: 8b 5d fc mov -0x4(%ebp),%ebx
10c46c: c9 leave
10c46d: c3 ret
10c46e: 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 );
10c470: 9c pushf
10c471: fa cli
10c472: 5a pop %edx
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
10c473: 8b 43 48 mov 0x48(%ebx),%eax
10c476: 3b 43 40 cmp 0x40(%ebx),%eax
10c479: 72 0d jb 10c488 <_CORE_semaphore_Surrender+0x38><== ALWAYS TAKEN
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
10c47b: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED
_ISR_Enable( level );
10c480: 52 push %edx
10c481: 9d popf
}
return status;
}
10c482: 8b 5d fc mov -0x4(%ebp),%ebx
10c485: c9 leave
10c486: c3 ret
10c487: 90 nop
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
10c488: 40 inc %eax
10c489: 89 43 48 mov %eax,0x48(%ebx)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10c48c: 31 c0 xor %eax,%eax
10c48e: eb f0 jmp 10c480 <_CORE_semaphore_Surrender+0x30>
0010c6b0 <_Chain_Get_with_empty_check>:
bool _Chain_Get_with_empty_check(
Chain_Control *chain,
Chain_Node **node
)
{
10c6b0: 55 push %ebp
10c6b1: 89 e5 mov %esp,%ebp
10c6b3: 57 push %edi
10c6b4: 56 push %esi
10c6b5: 53 push %ebx
10c6b6: 8b 45 08 mov 0x8(%ebp),%eax
10c6b9: 8b 7d 0c mov 0xc(%ebp),%edi
ISR_Level level;
bool is_empty_now;
_ISR_Disable( level );
10c6bc: 9c pushf
10c6bd: fa cli
10c6be: 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 );
10c6bf: 8d 58 04 lea 0x4(%eax),%ebx
Chain_Node *old_first = head->next;
10c6c2: 8b 10 mov (%eax),%edx
if ( old_first != tail ) {
10c6c4: 39 d3 cmp %edx,%ebx
10c6c6: 74 18 je 10c6e0 <_Chain_Get_with_empty_check+0x30>
Chain_Node *new_first = old_first->next;
10c6c8: 8b 0a mov (%edx),%ecx
head->next = new_first;
10c6ca: 89 08 mov %ecx,(%eax)
new_first->previous = head;
10c6cc: 89 41 04 mov %eax,0x4(%ecx)
*the_node = old_first;
10c6cf: 89 17 mov %edx,(%edi)
is_empty_now = new_first == tail;
10c6d1: 39 cb cmp %ecx,%ebx
10c6d3: 0f 94 c0 sete %al
is_empty_now = _Chain_Get_with_empty_check_unprotected( chain, node );
_ISR_Enable( level );
10c6d6: 56 push %esi
10c6d7: 9d popf
return is_empty_now;
}
10c6d8: 5b pop %ebx
10c6d9: 5e pop %esi
10c6da: 5f pop %edi
10c6db: c9 leave
10c6dc: c3 ret
10c6dd: 8d 76 00 lea 0x0(%esi),%esi
} else
*the_node = NULL;
10c6e0: 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;
10c6e6: b0 01 mov $0x1,%al
10c6e8: eb ec jmp 10c6d6 <_Chain_Get_with_empty_check+0x26>
00111054 <_Chain_Initialize>:
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
111054: 55 push %ebp
111055: 89 e5 mov %esp,%ebp
111057: 57 push %edi
111058: 56 push %esi
111059: 53 push %ebx
11105a: 83 ec 08 sub $0x8,%esp
11105d: 8b 7d 08 mov 0x8(%ebp),%edi
111060: 8b 4d 10 mov 0x10(%ebp),%ecx
111063: 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 );
111066: 8d 47 04 lea 0x4(%edi),%eax
111069: 89 45 f0 mov %eax,-0x10(%ebp)
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
11106c: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
while ( count-- ) {
111073: 85 c9 test %ecx,%ecx
111075: 74 35 je 1110ac <_Chain_Initialize+0x58><== NEVER TAKEN
111077: 49 dec %ecx
111078: 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;
11107b: 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;
11107e: 89 fa mov %edi,%edx
111080: eb 07 jmp 111089 <_Chain_Initialize+0x35>
111082: 66 90 xchg %ax,%ax
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
111084: 89 c2 mov %eax,%edx
current->next = next;
next->previous = current;
current = next;
next = (Chain_Node *)
111086: 89 d8 mov %ebx,%eax
111088: 49 dec %ecx
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
current->next = next;
111089: 89 02 mov %eax,(%edx)
next->previous = current;
11108b: 89 50 04 mov %edx,0x4(%eax)
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _Chain_Initialize(
11108e: 8d 1c 30 lea (%eax,%esi,1),%ebx
Chain_Node *current = head;
Chain_Node *next = starting_address;
head->previous = NULL;
while ( count-- ) {
111091: 85 c9 test %ecx,%ecx
111093: 75 ef jne 111084 <_Chain_Initialize+0x30>
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _Chain_Initialize(
111095: 0f af 75 ec imul -0x14(%ebp),%esi
111099: 03 75 0c add 0xc(%ebp),%esi
current = next;
next = (Chain_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
current->next = tail;
11109c: 8b 45 f0 mov -0x10(%ebp),%eax
11109f: 89 06 mov %eax,(%esi)
tail->previous = current;
1110a1: 89 77 08 mov %esi,0x8(%edi)
}
1110a4: 83 c4 08 add $0x8,%esp
1110a7: 5b pop %ebx
1110a8: 5e pop %esi
1110a9: 5f pop %edi
1110aa: c9 leave
1110ab: 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;
1110ac: 89 fe mov %edi,%esi <== NOT EXECUTED
1110ae: eb ec jmp 11109c <_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 58 7b 12 00 mov 0x127b58,%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 88 7f 12 00 01 movl $0x1,0x127f88
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 6a 30 00 00 call 10e158 <_Thread_Set_state>
_ISR_Disable( level );
10b0ee: 9c pushf
10b0ef: fa cli
10b0f0: 5a pop %edx
sync_state = _Event_Sync_state;
10b0f1: a1 88 7f 12 00 mov 0x127f88,%eax
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10b0f6: c7 05 88 7f 12 00 00 movl $0x0,0x127f88
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 d7 22 00 00 jmp 10d3f4 <_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 7c 76 12 00 push $0x12767c
10b18d: e8 66 35 00 00 call 10e6f8 <_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 54 7b 12 00 mov 0x127b54,%esi
10b21e: 85 f6 test %esi,%esi
10b220: 74 0c je 10b22e <_Event_Surrender+0x3e>
10b222: 3b 1d 58 7b 12 00 cmp 0x127b58,%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 01 23 00 00 call 10d574 <_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 89 35 00 00 call 10e838 <_Watchdog_Remove>
10b2af: 58 pop %eax
10b2b0: 5a pop %edx
10b2b1: 68 f8 ff 03 10 push $0x1003fff8
10b2b6: 53 push %ebx
10b2b7: e8 b8 22 00 00 call 10d574 <_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 88 7f 12 00 mov 0x127f88,%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 88 7f 12 00 mov 0x127f88,%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 88 7f 12 00 03 movl $0x3,0x127f88
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 f2 25 00 00 call 10d918 <_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 58 7b 12 00 cmp 0x127b58,%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 1b 22 00 00 call 10d574 <_Thread_Clear_state>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10b359: a1 70 75 12 00 mov 0x127570,%eax
10b35e: 48 dec %eax
10b35f: a3 70 75 12 00 mov %eax,0x127570
_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 88 7f 12 00 mov 0x127f88,%ecx
10b372: 49 dec %ecx
10b373: 75 cd jne 10b342 <_Event_Timeout+0x2e>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
10b375: c7 05 88 7f 12 00 02 movl $0x2,0x127f88
10b37c: 00 00 00
10b37f: eb c1 jmp 10b342 <_Event_Timeout+0x2e>
001112e4 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
1112e4: 55 push %ebp
1112e5: 89 e5 mov %esp,%ebp
1112e7: 57 push %edi
1112e8: 56 push %esi
1112e9: 53 push %ebx
1112ea: 83 ec 2c sub $0x2c,%esp
1112ed: 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
1112f0: 8d 47 04 lea 0x4(%edi),%eax
1112f3: 89 45 dc mov %eax,-0x24(%ebp)
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
1112f6: 8b 55 08 mov 0x8(%ebp),%edx
1112f9: 8b 52 10 mov 0x10(%edx),%edx
1112fc: 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 ) {
1112ff: 39 c7 cmp %eax,%edi
111301: 0f 87 69 01 00 00 ja 111470 <_Heap_Allocate_aligned_with_boundary+0x18c>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
111307: 8b 5d 14 mov 0x14(%ebp),%ebx
11130a: 85 db test %ebx,%ebx
11130c: 0f 85 56 01 00 00 jne 111468 <_Heap_Allocate_aligned_with_boundary+0x184>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
111312: 8b 45 08 mov 0x8(%ebp),%eax
111315: 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 ) {
111318: 39 c8 cmp %ecx,%eax
11131a: 0f 84 50 01 00 00 je 111470 <_Heap_Allocate_aligned_with_boundary+0x18c>
111320: 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
111327: 8b 55 cc mov -0x34(%ebp),%edx
11132a: 83 c2 07 add $0x7,%edx
11132d: 89 55 c8 mov %edx,-0x38(%ebp)
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
111330: c7 45 d0 04 00 00 00 movl $0x4,-0x30(%ebp)
111337: 29 7d d0 sub %edi,-0x30(%ebp)
11133a: eb 1e jmp 11135a <_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;
11133c: 8d 59 08 lea 0x8(%ecx),%ebx
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
11133f: 85 db test %ebx,%ebx
111341: 0f 85 f1 00 00 00 jne 111438 <_Heap_Allocate_aligned_with_boundary+0x154><== ALWAYS TAKEN
break;
}
block = block->next;
111347: 8b 49 08 mov 0x8(%ecx),%ecx
11134a: 8b 45 e4 mov -0x1c(%ebp),%eax
11134d: 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 ) {
11134e: 39 4d 08 cmp %ecx,0x8(%ebp)
111351: 0f 84 25 01 00 00 je 11147c <_Heap_Allocate_aligned_with_boundary+0x198>
111357: 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 ) {
11135a: 8b 59 04 mov 0x4(%ecx),%ebx
11135d: 39 5d dc cmp %ebx,-0x24(%ebp)
111360: 73 e5 jae 111347 <_Heap_Allocate_aligned_with_boundary+0x63>
if ( alignment == 0 ) {
111362: 8b 55 10 mov 0x10(%ebp),%edx
111365: 85 d2 test %edx,%edx
111367: 74 d3 je 11133c <_Heap_Allocate_aligned_with_boundary+0x58>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
111369: 8b 45 08 mov 0x8(%ebp),%eax
11136c: 8b 40 14 mov 0x14(%eax),%eax
11136f: 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;
111372: 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;
111375: 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;
111378: 8d 51 08 lea 0x8(%ecx),%edx
11137b: 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;
11137e: 8b 75 c8 mov -0x38(%ebp),%esi
111381: 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
111383: 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;
111385: 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);
111388: 89 d8 mov %ebx,%eax
11138a: 31 d2 xor %edx,%edx
11138c: f7 75 10 divl 0x10(%ebp)
11138f: 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 ) {
111391: 39 de cmp %ebx,%esi
111393: 73 0b jae 1113a0 <_Heap_Allocate_aligned_with_boundary+0xbc>
111395: 89 f0 mov %esi,%eax
111397: 31 d2 xor %edx,%edx
111399: f7 75 10 divl 0x10(%ebp)
11139c: 89 f3 mov %esi,%ebx
11139e: 29 d3 sub %edx,%ebx
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
1113a0: 8b 45 14 mov 0x14(%ebp),%eax
1113a3: 85 c0 test %eax,%eax
1113a5: 74 5b je 111402 <_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;
1113a7: 8d 34 3b lea (%ebx,%edi,1),%esi
1113aa: 89 f0 mov %esi,%eax
1113ac: 31 d2 xor %edx,%edx
1113ae: f7 75 14 divl 0x14(%ebp)
1113b1: 89 f0 mov %esi,%eax
1113b3: 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 ) {
1113b5: 39 c3 cmp %eax,%ebx
1113b7: 73 49 jae 111402 <_Heap_Allocate_aligned_with_boundary+0x11e>
1113b9: 39 c6 cmp %eax,%esi
1113bb: 76 45 jbe 111402 <_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;
1113bd: 8b 55 d4 mov -0x2c(%ebp),%edx
1113c0: 01 fa add %edi,%edx
1113c2: 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 ) {
1113c5: 39 c2 cmp %eax,%edx
1113c7: 0f 87 7a ff ff ff ja 111347 <_Heap_Allocate_aligned_with_boundary+0x63>
1113cd: 89 ce mov %ecx,%esi
1113cf: eb 10 jmp 1113e1 <_Heap_Allocate_aligned_with_boundary+0xfd>
1113d1: 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 ) {
1113d4: 39 c1 cmp %eax,%ecx
1113d6: 76 28 jbe 111400 <_Heap_Allocate_aligned_with_boundary+0x11c>
if ( boundary_line < boundary_floor ) {
1113d8: 39 45 e0 cmp %eax,-0x20(%ebp)
1113db: 0f 87 9f 00 00 00 ja 111480 <_Heap_Allocate_aligned_with_boundary+0x19c><== NEVER TAKEN
return 0;
}
alloc_begin = boundary_line - alloc_size;
1113e1: 89 c3 mov %eax,%ebx
1113e3: 29 fb sub %edi,%ebx
1113e5: 89 d8 mov %ebx,%eax
1113e7: 31 d2 xor %edx,%edx
1113e9: f7 75 10 divl 0x10(%ebp)
1113ec: 29 d3 sub %edx,%ebx
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
1113ee: 8d 0c 3b lea (%ebx,%edi,1),%ecx
1113f1: 89 c8 mov %ecx,%eax
1113f3: 31 d2 xor %edx,%edx
1113f5: f7 75 14 divl 0x14(%ebp)
1113f8: 89 c8 mov %ecx,%eax
1113fa: 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 ) {
1113fc: 39 c3 cmp %eax,%ebx
1113fe: 72 d4 jb 1113d4 <_Heap_Allocate_aligned_with_boundary+0xf0>
111400: 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 ) {
111402: 39 5d d4 cmp %ebx,-0x2c(%ebp)
111405: 0f 87 3c ff ff ff ja 111347 <_Heap_Allocate_aligned_with_boundary+0x63>
11140b: be f8 ff ff ff mov $0xfffffff8,%esi
111410: 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);
111412: 01 de add %ebx,%esi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
111414: 89 d8 mov %ebx,%eax
111416: 31 d2 xor %edx,%edx
111418: 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;
11141b: 29 d6 sub %edx,%esi
if ( free_size >= min_block_size || free_size == 0 ) {
11141d: 39 75 d8 cmp %esi,-0x28(%ebp)
111420: 0f 86 19 ff ff ff jbe 11133f <_Heap_Allocate_aligned_with_boundary+0x5b>
111426: 85 f6 test %esi,%esi
111428: 0f 85 19 ff ff ff jne 111347 <_Heap_Allocate_aligned_with_boundary+0x63>
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
11142e: 85 db test %ebx,%ebx
111430: 0f 84 11 ff ff ff je 111347 <_Heap_Allocate_aligned_with_boundary+0x63><== NEVER TAKEN
111436: 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;
111438: 8b 45 08 mov 0x8(%ebp),%eax
11143b: ff 40 48 incl 0x48(%eax)
stats->searches += search_count;
11143e: 8b 55 e4 mov -0x1c(%ebp),%edx
111441: 01 50 4c add %edx,0x4c(%eax)
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
111444: 57 push %edi
111445: 53 push %ebx
111446: 51 push %ecx
111447: 50 push %eax
111448: e8 b7 b3 ff ff call 10c804 <_Heap_Block_allocate>
11144d: 89 d8 mov %ebx,%eax
11144f: 83 c4 10 add $0x10,%esp
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
111452: 8b 55 e4 mov -0x1c(%ebp),%edx
111455: 8b 4d 08 mov 0x8(%ebp),%ecx
111458: 39 51 44 cmp %edx,0x44(%ecx)
11145b: 73 15 jae 111472 <_Heap_Allocate_aligned_with_boundary+0x18e>
stats->max_search = search_count;
11145d: 89 51 44 mov %edx,0x44(%ecx)
}
return (void *) alloc_begin;
}
111460: 8d 65 f4 lea -0xc(%ebp),%esp
111463: 5b pop %ebx
111464: 5e pop %esi
111465: 5f pop %edi
111466: c9 leave
111467: c3 ret
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
111468: 3b 7d 14 cmp 0x14(%ebp),%edi
11146b: 76 1a jbe 111487 <_Heap_Allocate_aligned_with_boundary+0x1a3>
11146d: 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 ) {
111470: 31 c0 xor %eax,%eax
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
111472: 8d 65 f4 lea -0xc(%ebp),%esp
111475: 5b pop %ebx
111476: 5e pop %esi
111477: 5f pop %edi
111478: c9 leave
111479: c3 ret
11147a: 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 ) {
11147c: 31 c0 xor %eax,%eax
11147e: eb d2 jmp 111452 <_Heap_Allocate_aligned_with_boundary+0x16e>
111480: 89 f1 mov %esi,%ecx <== NOT EXECUTED
111482: e9 c0 fe ff ff jmp 111347 <_Heap_Allocate_aligned_with_boundary+0x63><== NOT EXECUTED
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
return NULL;
}
if ( alignment == 0 ) {
111487: 8b 4d 10 mov 0x10(%ebp),%ecx
11148a: 85 c9 test %ecx,%ecx
11148c: 0f 85 80 fe ff ff jne 111312 <_Heap_Allocate_aligned_with_boundary+0x2e>
alignment = page_size;
111492: 89 55 10 mov %edx,0x10(%ebp)
111495: e9 78 fe ff ff jmp 111312 <_Heap_Allocate_aligned_with_boundary+0x2e>
00111888 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
111888: 55 push %ebp
111889: 89 e5 mov %esp,%ebp
11188b: 57 push %edi
11188c: 56 push %esi
11188d: 53 push %ebx
11188e: 83 ec 4c sub $0x4c,%esp
111891: 8b 5d 08 mov 0x8(%ebp),%ebx
111894: 8b 4d 10 mov 0x10(%ebp),%ecx
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
111897: 8b 43 20 mov 0x20(%ebx),%eax
11189a: 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;
11189d: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
Heap_Block *extend_last_block = NULL;
1118a4: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
uintptr_t const page_size = heap->page_size;
1118ab: 8b 53 10 mov 0x10(%ebx),%edx
1118ae: 89 55 d4 mov %edx,-0x2c(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
1118b1: 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;
1118b4: 8b 73 30 mov 0x30(%ebx),%esi
1118b7: 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 ) {
1118ba: 8b 55 0c mov 0xc(%ebp),%edx
1118bd: 01 ca add %ecx,%edx
1118bf: 89 55 cc mov %edx,-0x34(%ebp)
1118c2: 73 0c jae 1118d0 <_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;
1118c4: 31 c0 xor %eax,%eax
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
1118c6: 8d 65 f4 lea -0xc(%ebp),%esp
1118c9: 5b pop %ebx
1118ca: 5e pop %esi
1118cb: 5f pop %edi
1118cc: c9 leave
1118cd: c3 ret
1118ce: 66 90 xchg %ax,%ax
if ( extend_area_end < extend_area_begin ) {
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
1118d0: 83 ec 08 sub $0x8,%esp
1118d3: 8d 55 e0 lea -0x20(%ebp),%edx
1118d6: 52 push %edx
1118d7: 8d 55 e4 lea -0x1c(%ebp),%edx
1118da: 52 push %edx
1118db: 50 push %eax
1118dc: ff 75 d4 pushl -0x2c(%ebp)
1118df: 51 push %ecx
1118e0: ff 75 0c pushl 0xc(%ebp)
1118e3: e8 38 b1 ff ff call 10ca20 <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
1118e8: 83 c4 20 add $0x20,%esp
1118eb: 84 c0 test %al,%al
1118ed: 74 d5 je 1118c4 <_Heap_Extend+0x3c>
1118ef: 8b 7d d0 mov -0x30(%ebp),%edi
1118f2: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%ebp)
1118f9: c7 45 b8 00 00 00 00 movl $0x0,-0x48(%ebp)
111900: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp)
111907: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
11190e: 8b 75 cc mov -0x34(%ebp),%esi
111911: 89 5d b4 mov %ebx,-0x4c(%ebp)
111914: eb 30 jmp 111946 <_Heap_Extend+0xbe>
111916: 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 ) {
111918: 39 ce cmp %ecx,%esi
11191a: 73 03 jae 11191f <_Heap_Extend+0x97>
11191c: 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);
11191f: 8d 59 f8 lea -0x8(%ecx),%ebx
111922: 89 c8 mov %ecx,%eax
111924: 31 d2 xor %edx,%edx
111926: 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);
111929: 29 d3 sub %edx,%ebx
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
11192b: 3b 4d 0c cmp 0xc(%ebp),%ecx
11192e: 74 3c je 11196c <_Heap_Extend+0xe4>
start_block->prev_size = extend_area_end;
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
111930: 39 4d 0c cmp %ecx,0xc(%ebp)
111933: 76 03 jbe 111938 <_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 )
111935: 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;
111938: 8b 7b 04 mov 0x4(%ebx),%edi
11193b: 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);
11193e: 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 );
111941: 39 7d d0 cmp %edi,-0x30(%ebp)
111944: 74 39 je 11197f <_Heap_Extend+0xf7>
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
111946: 3b 7d d0 cmp -0x30(%ebp),%edi
111949: 0f 84 39 01 00 00 je 111a88 <_Heap_Extend+0x200>
11194f: 89 f8 mov %edi,%eax
uintptr_t const sub_area_end = start_block->prev_size;
111951: 8b 0f mov (%edi),%ecx
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
111953: 39 4d 0c cmp %ecx,0xc(%ebp)
111956: 73 08 jae 111960 <_Heap_Extend+0xd8>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
111958: 39 f0 cmp %esi,%eax
11195a: 0f 82 64 ff ff ff jb 1118c4 <_Heap_Extend+0x3c>
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
111960: 39 f0 cmp %esi,%eax
111962: 75 b4 jne 111918 <_Heap_Extend+0x90>
111964: 89 7d c4 mov %edi,-0x3c(%ebp)
111967: eb b6 jmp 11191f <_Heap_Extend+0x97>
111969: 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;
11196c: 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 )
11196e: 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;
111971: 8b 7b 04 mov 0x4(%ebx),%edi
111974: 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);
111977: 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 );
11197a: 39 7d d0 cmp %edi,-0x30(%ebp)
11197d: 75 c7 jne 111946 <_Heap_Extend+0xbe> <== NEVER TAKEN
11197f: 8b 5d b4 mov -0x4c(%ebp),%ebx
if ( extend_area_begin < heap->area_begin ) {
111982: 8b 75 0c mov 0xc(%ebp),%esi
111985: 3b 73 18 cmp 0x18(%ebx),%esi
111988: 0f 82 06 01 00 00 jb 111a94 <_Heap_Extend+0x20c>
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
11198e: 8b 45 cc mov -0x34(%ebp),%eax
111991: 3b 43 1c cmp 0x1c(%ebx),%eax
111994: 76 03 jbe 111999 <_Heap_Extend+0x111>
heap->area_end = extend_area_end;
111996: 89 43 1c mov %eax,0x1c(%ebx)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
111999: 8b 55 e0 mov -0x20(%ebp),%edx
11199c: 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 =
11199f: 89 d1 mov %edx,%ecx
1119a1: 29 c1 sub %eax,%ecx
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
1119a3: 8b 75 cc mov -0x34(%ebp),%esi
1119a6: 89 30 mov %esi,(%eax)
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
1119a8: 89 ce mov %ecx,%esi
1119aa: 83 ce 01 or $0x1,%esi
1119ad: 89 70 04 mov %esi,0x4(%eax)
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
1119b0: 89 0a mov %ecx,(%edx)
extend_last_block->size_and_flag = 0;
1119b2: 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 ) {
1119b9: 39 43 20 cmp %eax,0x20(%ebx)
1119bc: 0f 86 da 00 00 00 jbe 111a9c <_Heap_Extend+0x214>
heap->first_block = extend_first_block;
1119c2: 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 ) {
1119c5: 8b 75 c4 mov -0x3c(%ebp),%esi
1119c8: 85 f6 test %esi,%esi
1119ca: 0f 84 10 01 00 00 je 111ae0 <_Heap_Extend+0x258>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
1119d0: 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 );
1119d3: 8b 4d 0c mov 0xc(%ebp),%ecx
1119d6: 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;
1119d9: 89 c8 mov %ecx,%eax
1119db: 31 d2 xor %edx,%edx
1119dd: f7 f6 div %esi
if ( remainder != 0 ) {
1119df: 85 d2 test %edx,%edx
1119e1: 0f 84 c9 00 00 00 je 111ab0 <_Heap_Extend+0x228> <== ALWAYS TAKEN
return value - remainder + alignment;
1119e7: 8d 04 31 lea (%ecx,%esi,1),%eax <== NOT EXECUTED
1119ea: 29 d0 sub %edx,%eax <== NOT EXECUTED
uintptr_t const new_first_block_begin =
1119ec: 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;
1119ef: 8b 75 c4 mov -0x3c(%ebp),%esi
1119f2: 8b 0e mov (%esi),%ecx
1119f4: 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 =
1119f7: 89 f0 mov %esi,%eax
1119f9: 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;
1119fb: 83 c8 01 or $0x1,%eax
1119fe: 89 42 04 mov %eax,0x4(%edx)
_Heap_Free_block( heap, new_first_block );
111a01: 89 d8 mov %ebx,%eax
111a03: e8 64 fe ff ff call 11186c <_Heap_Free_block>
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
111a08: 8b 45 c8 mov -0x38(%ebp),%eax
111a0b: 85 c0 test %eax,%eax
111a0d: 0f 84 a5 00 00 00 je 111ab8 <_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,
111a13: 8b 4d cc mov -0x34(%ebp),%ecx
111a16: 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(
111a19: 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);
111a1c: 89 c8 mov %ecx,%eax
111a1e: 31 d2 xor %edx,%edx
111a20: f7 73 10 divl 0x10(%ebx)
111a23: 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)
111a25: 8b 55 c8 mov -0x38(%ebp),%edx
111a28: 8b 42 04 mov 0x4(%edx),%eax
111a2b: 29 c8 sub %ecx,%eax
| HEAP_PREV_BLOCK_USED;
111a2d: 83 c8 01 or $0x1,%eax
111a30: 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;
111a34: 8b 42 04 mov 0x4(%edx),%eax
111a37: 83 e0 01 and $0x1,%eax
block->size_and_flag = size | flag;
111a3a: 09 c8 or %ecx,%eax
111a3c: 89 42 04 mov %eax,0x4(%edx)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
111a3f: 89 d8 mov %ebx,%eax
111a41: e8 26 fe ff ff call 11186c <_Heap_Free_block>
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
111a46: 8b 75 c4 mov -0x3c(%ebp),%esi
111a49: 85 f6 test %esi,%esi
111a4b: 0f 84 ab 00 00 00 je 111afc <_Heap_Extend+0x274>
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
111a51: 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(
111a54: 8b 43 20 mov 0x20(%ebx),%eax
111a57: 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;
111a59: 8b 4a 04 mov 0x4(%edx),%ecx
111a5c: 83 e1 01 and $0x1,%ecx
block->size_and_flag = size | flag;
111a5f: 09 c8 or %ecx,%eax
111a61: 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;
111a64: 8b 43 30 mov 0x30(%ebx),%eax
111a67: 2b 45 c0 sub -0x40(%ebp),%eax
/* Statistics */
stats->size += extended_size;
111a6a: 01 43 2c add %eax,0x2c(%ebx)
if ( extended_size_ptr != NULL )
111a6d: 8b 55 14 mov 0x14(%ebp),%edx
111a70: 85 d2 test %edx,%edx
111a72: 0f 84 a0 00 00 00 je 111b18 <_Heap_Extend+0x290> <== NEVER TAKEN
*extended_size_ptr = extended_size;
111a78: 8b 55 14 mov 0x14(%ebp),%edx
111a7b: 89 02 mov %eax,(%edx)
return true;
111a7d: b0 01 mov $0x1,%al
}
111a7f: 8d 65 f4 lea -0xc(%ebp),%esp
111a82: 5b pop %ebx
111a83: 5e pop %esi
111a84: 5f pop %edi
111a85: c9 leave
111a86: c3 ret
111a87: 90 nop
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
111a88: 8b 55 b4 mov -0x4c(%ebp),%edx
111a8b: 8b 42 18 mov 0x18(%edx),%eax
111a8e: e9 be fe ff ff jmp 111951 <_Heap_Extend+0xc9>
111a93: 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;
111a94: 89 73 18 mov %esi,0x18(%ebx)
111a97: e9 fd fe ff ff jmp 111999 <_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 ) {
111a9c: 39 53 24 cmp %edx,0x24(%ebx)
111a9f: 0f 83 20 ff ff ff jae 1119c5 <_Heap_Extend+0x13d>
heap->last_block = extend_last_block;
111aa5: 89 53 24 mov %edx,0x24(%ebx)
111aa8: e9 18 ff ff ff jmp 1119c5 <_Heap_Extend+0x13d>
111aad: 8d 76 00 lea 0x0(%esi),%esi
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
return value - remainder + alignment;
} else {
return value;
111ab0: 89 c8 mov %ecx,%eax
111ab2: e9 35 ff ff ff jmp 1119ec <_Heap_Extend+0x164>
111ab7: 90 nop
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
111ab8: 8b 7d bc mov -0x44(%ebp),%edi
111abb: 85 ff test %edi,%edi
111abd: 74 87 je 111a46 <_Heap_Extend+0x1be>
_Heap_Link_above(
111abf: 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 );
111ac2: 8b 45 e4 mov -0x1c(%ebp),%eax
111ac5: 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;
111ac8: 8b 75 bc mov -0x44(%ebp),%esi
111acb: 8b 56 04 mov 0x4(%esi),%edx
111ace: 83 e2 01 and $0x1,%edx
block->size_and_flag = size | flag;
111ad1: 09 d0 or %edx,%eax
111ad3: 89 46 04 mov %eax,0x4(%esi)
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
111ad6: 83 49 04 01 orl $0x1,0x4(%ecx)
111ada: e9 67 ff ff ff jmp 111a46 <_Heap_Extend+0x1be>
111adf: 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 ) {
111ae0: 8b 4d b8 mov -0x48(%ebp),%ecx
111ae3: 85 c9 test %ecx,%ecx
111ae5: 0f 84 1d ff ff ff je 111a08 <_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;
111aeb: 8b 45 b8 mov -0x48(%ebp),%eax
111aee: 29 d0 sub %edx,%eax
111af0: 83 c8 01 or $0x1,%eax
111af3: 89 42 04 mov %eax,0x4(%edx)
111af6: e9 0d ff ff ff jmp 111a08 <_Heap_Extend+0x180>
111afb: 90 nop
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
111afc: 8b 4d c8 mov -0x38(%ebp),%ecx
111aff: 85 c9 test %ecx,%ecx
111b01: 0f 85 4a ff ff ff jne 111a51 <_Heap_Extend+0x1c9>
_Heap_Free_block( heap, extend_first_block );
111b07: 8b 55 e4 mov -0x1c(%ebp),%edx
111b0a: 89 d8 mov %ebx,%eax
111b0c: e8 5b fd ff ff call 11186c <_Heap_Free_block>
111b11: e9 3b ff ff ff jmp 111a51 <_Heap_Extend+0x1c9>
111b16: 66 90 xchg %ax,%ax
stats->size += extended_size;
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
111b18: b0 01 mov $0x1,%al <== NOT EXECUTED
111b1a: e9 a7 fd ff ff jmp 1118c6 <_Heap_Extend+0x3e> <== NOT EXECUTED
0011149c <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
11149c: 55 push %ebp
11149d: 89 e5 mov %esp,%ebp
11149f: 57 push %edi
1114a0: 56 push %esi
1114a1: 53 push %ebx
1114a2: 83 ec 10 sub $0x10,%esp
1114a5: 8b 5d 08 mov 0x8(%ebp),%ebx
1114a8: 8b 45 0c mov 0xc(%ebp),%eax
1114ab: 8d 48 f8 lea -0x8(%eax),%ecx
1114ae: 31 d2 xor %edx,%edx
1114b0: 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);
1114b3: 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
1114b5: 8b 43 20 mov 0x20(%ebx),%eax
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
1114b8: 39 c1 cmp %eax,%ecx
1114ba: 72 07 jb 1114c3 <_Heap_Free+0x27>
1114bc: 8b 73 24 mov 0x24(%ebx),%esi
1114bf: 39 f1 cmp %esi,%ecx
1114c1: 76 0d jbe 1114d0 <_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 );
1114c3: 31 c0 xor %eax,%eax
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
1114c5: 83 c4 10 add $0x10,%esp
1114c8: 5b pop %ebx
1114c9: 5e pop %esi
1114ca: 5f pop %edi
1114cb: c9 leave
1114cc: c3 ret
1114cd: 8d 76 00 lea 0x0(%esi),%esi
1114d0: 8b 51 04 mov 0x4(%ecx),%edx
1114d3: 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;
1114d6: 83 e2 fe and $0xfffffffe,%edx
1114d9: 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);
1114dc: 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;
1114df: 39 d0 cmp %edx,%eax
1114e1: 77 e0 ja 1114c3 <_Heap_Free+0x27> <== NEVER TAKEN
1114e3: 39 d6 cmp %edx,%esi
1114e5: 72 dc jb 1114c3 <_Heap_Free+0x27> <== NEVER TAKEN
1114e7: 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 ) ) {
1114ea: f7 c7 01 00 00 00 test $0x1,%edi
1114f0: 74 d1 je 1114c3 <_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;
1114f2: 83 e7 fe and $0xfffffffe,%edi
1114f5: 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 ));
1114f8: 39 d6 cmp %edx,%esi
1114fa: 0f 84 c8 00 00 00 je 1115c8 <_Heap_Free+0x12c>
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
111500: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1)
111505: 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 ) ) {
111509: f6 45 f0 01 testb $0x1,-0x10(%ebp)
11150d: 75 45 jne 111554 <_Heap_Free+0xb8>
uintptr_t const prev_size = block->prev_size;
11150f: 8b 39 mov (%ecx),%edi
111511: 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);
111514: 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;
111516: 39 c8 cmp %ecx,%eax
111518: 77 a9 ja 1114c3 <_Heap_Free+0x27> <== NEVER TAKEN
11151a: 39 ce cmp %ecx,%esi
11151c: 72 a5 jb 1114c3 <_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) ) {
11151e: f6 41 04 01 testb $0x1,0x4(%ecx)
111522: 74 9f je 1114c3 <_Heap_Free+0x27> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
111524: 80 7d eb 00 cmpb $0x0,-0x15(%ebp)
111528: 0f 84 a6 00 00 00 je 1115d4 <_Heap_Free+0x138>
uintptr_t const size = block_size + prev_size + next_block_size;
11152e: 8b 7d e4 mov -0x1c(%ebp),%edi
111531: 03 7d ec add -0x14(%ebp),%edi
111534: 03 7d f0 add -0x10(%ebp),%edi
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
111537: 8b 42 08 mov 0x8(%edx),%eax
11153a: 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;
11153d: 89 42 08 mov %eax,0x8(%edx)
next->prev = prev;
111540: 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;
111543: ff 4b 38 decl 0x38(%ebx)
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
111546: 89 f8 mov %edi,%eax
111548: 83 c8 01 or $0x1,%eax
11154b: 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;
11154e: 89 3c 39 mov %edi,(%ecx,%edi,1)
111551: eb 2a jmp 11157d <_Heap_Free+0xe1>
111553: 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 */
111554: 80 7d eb 00 cmpb $0x0,-0x15(%ebp)
111558: 74 3a je 111594 <_Heap_Free+0xf8>
uintptr_t const size = block_size + next_block_size;
11155a: 8b 7d e4 mov -0x1c(%ebp),%edi
11155d: 03 7d ec add -0x14(%ebp),%edi
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
111560: 8b 42 08 mov 0x8(%edx),%eax
111563: 8b 52 0c mov 0xc(%edx),%edx
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
111566: 89 41 08 mov %eax,0x8(%ecx)
new_block->prev = prev;
111569: 89 51 0c mov %edx,0xc(%ecx)
next->prev = new_block;
11156c: 89 48 0c mov %ecx,0xc(%eax)
prev->next = new_block;
11156f: 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;
111572: 89 f8 mov %edi,%eax
111574: 83 c8 01 or $0x1,%eax
111577: 89 41 04 mov %eax,0x4(%ecx)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
11157a: 89 3c 39 mov %edi,(%ecx,%edi,1)
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
11157d: ff 4b 40 decl 0x40(%ebx)
++stats->frees;
111580: ff 43 50 incl 0x50(%ebx)
stats->free_size += block_size;
111583: 8b 55 ec mov -0x14(%ebp),%edx
111586: 01 53 30 add %edx,0x30(%ebx)
return( true );
111589: b0 01 mov $0x1,%al
}
11158b: 83 c4 10 add $0x10,%esp
11158e: 5b pop %ebx
11158f: 5e pop %esi
111590: 5f pop %edi
111591: c9 leave
111592: c3 ret
111593: 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;
111594: 8b 43 08 mov 0x8(%ebx),%eax
new_block->next = next;
111597: 89 41 08 mov %eax,0x8(%ecx)
new_block->prev = block_before;
11159a: 89 59 0c mov %ebx,0xc(%ecx)
block_before->next = new_block;
11159d: 89 4b 08 mov %ecx,0x8(%ebx)
next->prev = new_block;
1115a0: 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;
1115a3: 8b 45 ec mov -0x14(%ebp),%eax
1115a6: 83 c8 01 or $0x1,%eax
1115a9: 89 41 04 mov %eax,0x4(%ecx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
1115ac: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = block_size;
1115b0: 8b 45 ec mov -0x14(%ebp),%eax
1115b3: 89 02 mov %eax,(%edx)
/* Statistics */
++stats->free_blocks;
1115b5: 8b 43 38 mov 0x38(%ebx),%eax
1115b8: 40 inc %eax
1115b9: 89 43 38 mov %eax,0x38(%ebx)
if ( stats->max_free_blocks < stats->free_blocks ) {
1115bc: 3b 43 3c cmp 0x3c(%ebx),%eax
1115bf: 76 bc jbe 11157d <_Heap_Free+0xe1>
stats->max_free_blocks = stats->free_blocks;
1115c1: 89 43 3c mov %eax,0x3c(%ebx)
1115c4: eb b7 jmp 11157d <_Heap_Free+0xe1>
1115c6: 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 ));
1115c8: c6 45 eb 00 movb $0x0,-0x15(%ebp)
1115cc: e9 38 ff ff ff jmp 111509 <_Heap_Free+0x6d>
1115d1: 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;
1115d4: 8b 45 ec mov -0x14(%ebp),%eax
1115d7: 03 45 f0 add -0x10(%ebp),%eax
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
1115da: 89 c6 mov %eax,%esi
1115dc: 83 ce 01 or $0x1,%esi
1115df: 89 71 04 mov %esi,0x4(%ecx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
1115e2: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = size;
1115e6: 89 02 mov %eax,(%edx)
1115e8: eb 93 jmp 11157d <_Heap_Free+0xe1>
0010c694 <_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
)
{
10c694: 55 push %ebp
10c695: 89 e5 mov %esp,%ebp
10c697: 57 push %edi
10c698: 56 push %esi
10c699: 53 push %ebx
10c69a: 8b 4d 08 mov 0x8(%ebp),%ecx
10c69d: 8b 7d 0c mov 0xc(%ebp),%edi
uintptr_t const heap_area_end = heap_area_begin + heap_area_size;
10c6a0: 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 );
10c6a3: 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;
10c6a6: 89 d8 mov %ebx,%eax
10c6a8: 31 d2 xor %edx,%edx
10c6aa: f7 75 10 divl 0x10(%ebp)
if ( remainder != 0 ) {
10c6ad: 85 d2 test %edx,%edx
10c6af: 74 05 je 10c6b6 <_Heap_Get_first_and_last_block+0x22>
return value - remainder + alignment;
10c6b1: 03 5d 10 add 0x10(%ebp),%ebx
10c6b4: 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 (
10c6b6: 39 f1 cmp %esi,%ecx
10c6b8: 77 2e ja 10c6e8 <_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);
10c6ba: 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 =
10c6bd: 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
10c6bf: 39 df cmp %ebx,%edi
10c6c1: 76 25 jbe 10c6e8 <_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 );
10c6c3: 29 df sub %ebx,%edi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
10c6c5: 89 f8 mov %edi,%eax
10c6c7: 31 d2 xor %edx,%edx
10c6c9: f7 75 10 divl 0x10(%ebp)
10c6cc: 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
10c6ce: 39 7d 14 cmp %edi,0x14(%ebp)
10c6d1: 77 15 ja 10c6e8 <_Heap_Get_first_and_last_block+0x54>
) {
/* Invalid area or area too small */
return false;
}
*first_block_ptr = first_block;
10c6d3: 8b 45 18 mov 0x18(%ebp),%eax
10c6d6: 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);
10c6d8: 01 f7 add %esi,%edi
10c6da: 8b 45 1c mov 0x1c(%ebp),%eax
10c6dd: 89 38 mov %edi,(%eax)
*last_block_ptr = last_block;
return true;
10c6df: b0 01 mov $0x1,%al
}
10c6e1: 5b pop %ebx
10c6e2: 5e pop %esi
10c6e3: 5f pop %edi
10c6e4: c9 leave
10c6e5: c3 ret
10c6e6: 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;
10c6e8: 31 c0 xor %eax,%eax
*first_block_ptr = first_block;
*last_block_ptr = last_block;
return true;
}
10c6ea: 5b pop %ebx
10c6eb: 5e pop %esi
10c6ec: 5f pop %edi
10c6ed: c9 leave
10c6ee: c3 ret
001151b0 <_Heap_Get_free_information>:
void _Heap_Get_free_information(
Heap_Control *the_heap,
Heap_Information *info
)
{
1151b0: 55 push %ebp
1151b1: 89 e5 mov %esp,%ebp
1151b3: 57 push %edi
1151b4: 56 push %esi
1151b5: 53 push %ebx
1151b6: 8b 7d 0c mov 0xc(%ebp),%edi
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Free_list_tail(the_heap);
info->number = 0;
1151b9: c7 07 00 00 00 00 movl $0x0,(%edi)
info->largest = 0;
1151bf: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
info->total = 0;
1151c6: 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;
}
}
1151cd: 8b 45 08 mov 0x8(%ebp),%eax
1151d0: 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);
1151d3: 39 d0 cmp %edx,%eax
1151d5: 74 31 je 115208 <_Heap_Get_free_information+0x58>
1151d7: b9 01 00 00 00 mov $0x1,%ecx
1151dc: 31 f6 xor %esi,%esi
1151de: 31 db xor %ebx,%ebx
1151e0: eb 07 jmp 1151e9 <_Heap_Get_free_information+0x39>
1151e2: 66 90 xchg %ax,%ax
1151e4: 8b 77 04 mov 0x4(%edi),%esi
1151e7: 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;
1151e9: 8b 42 04 mov 0x4(%edx),%eax
1151ec: 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;
1151ef: 01 c3 add %eax,%ebx
if ( info->largest < the_size )
1151f1: 39 f0 cmp %esi,%eax
1151f3: 76 03 jbe 1151f8 <_Heap_Get_free_information+0x48>
info->largest = the_size;
1151f5: 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)
1151f8: 8b 52 08 mov 0x8(%edx),%edx
1151fb: 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);
1151fe: 39 55 08 cmp %edx,0x8(%ebp)
115201: 75 e1 jne 1151e4 <_Heap_Get_free_information+0x34>
115203: 89 0f mov %ecx,(%edi)
115205: 89 5f 08 mov %ebx,0x8(%edi)
info->number++;
info->total += the_size;
if ( info->largest < the_size )
info->largest = the_size;
}
}
115208: 5b pop %ebx
115209: 5e pop %esi
11520a: 5f pop %edi
11520b: c9 leave
11520c: c3 ret
00112014 <_Heap_Get_information>:
void _Heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
112014: 55 push %ebp
112015: 89 e5 mov %esp,%ebp
112017: 57 push %edi
112018: 56 push %esi
112019: 53 push %ebx
11201a: 83 ec 04 sub $0x4,%esp
11201d: 8b 45 08 mov 0x8(%ebp),%eax
112020: 8b 5d 0c mov 0xc(%ebp),%ebx
Heap_Block *the_block = the_heap->first_block;
112023: 8b 50 20 mov 0x20(%eax),%edx
Heap_Block *const end = the_heap->last_block;
112026: 8b 40 24 mov 0x24(%eax),%eax
112029: 89 45 f0 mov %eax,-0x10(%ebp)
memset(the_info, 0, sizeof(*the_info));
11202c: b9 18 00 00 00 mov $0x18,%ecx
112031: 31 c0 xor %eax,%eax
112033: 89 df mov %ebx,%edi
112035: f3 aa rep stos %al,%es:(%edi)
while ( the_block != end ) {
112037: 3b 55 f0 cmp -0x10(%ebp),%edx
11203a: 74 38 je 112074 <_Heap_Get_information+0x60><== NEVER TAKEN
11203c: 8b 7a 04 mov 0x4(%edx),%edi
11203f: eb 18 jmp 112059 <_Heap_Get_information+0x45>
112041: 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;
112044: 8d 43 0c lea 0xc(%ebx),%eax
else
info = &the_info->Free;
info->number++;
112047: ff 00 incl (%eax)
info->total += the_size;
112049: 01 48 08 add %ecx,0x8(%eax)
if ( info->largest < the_size )
11204c: 39 48 04 cmp %ecx,0x4(%eax)
11204f: 73 03 jae 112054 <_Heap_Get_information+0x40>
info->largest = the_size;
112051: 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 ) {
112054: 39 75 f0 cmp %esi,-0x10(%ebp)
112057: 74 1b je 112074 <_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;
112059: 89 f9 mov %edi,%ecx
11205b: 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);
11205e: 8d 34 0a lea (%edx,%ecx,1),%esi
112061: 89 f2 mov %esi,%edx
if ( info->largest < the_size )
info->largest = the_size;
the_block = next_block;
}
}
112063: 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) )
112066: f7 c7 01 00 00 00 test $0x1,%edi
11206c: 75 d6 jne 112044 <_Heap_Get_information+0x30>
info = &the_info->Used;
else
info = &the_info->Free;
11206e: 89 d8 mov %ebx,%eax
112070: eb d5 jmp 112047 <_Heap_Get_information+0x33>
112072: 66 90 xchg %ax,%ax
if ( info->largest < the_size )
info->largest = the_size;
the_block = next_block;
}
}
112074: 58 pop %eax
112075: 5b pop %ebx
112076: 5e pop %esi
112077: 5f pop %edi
112078: c9 leave
112079: c3 ret
0011ed1c <_Heap_Resize_block>:
void *alloc_begin_ptr,
uintptr_t new_alloc_size,
uintptr_t *old_size,
uintptr_t *new_size
)
{
11ed1c: 55 push %ebp
11ed1d: 89 e5 mov %esp,%ebp
11ed1f: 57 push %edi
11ed20: 56 push %esi
11ed21: 53 push %ebx
11ed22: 83 ec 2c sub $0x2c,%esp
11ed25: 8b 5d 08 mov 0x8(%ebp),%ebx
11ed28: 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);
11ed2b: 8d 4e f8 lea -0x8(%esi),%ecx
11ed2e: 89 f0 mov %esi,%eax
11ed30: 31 d2 xor %edx,%edx
11ed32: 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);
11ed35: 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;
11ed37: 8b 45 14 mov 0x14(%ebp),%eax
11ed3a: c7 00 00 00 00 00 movl $0x0,(%eax)
*new_size = 0;
11ed40: 8b 55 18 mov 0x18(%ebp),%edx
11ed43: 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;
11ed49: 39 4b 20 cmp %ecx,0x20(%ebx)
11ed4c: 77 05 ja 11ed53 <_Heap_Resize_block+0x37>
11ed4e: 39 4b 24 cmp %ecx,0x24(%ebx)
11ed51: 73 0d jae 11ed60 <_Heap_Resize_block+0x44>
new_alloc_size,
old_size,
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
11ed53: b8 02 00 00 00 mov $0x2,%eax
}
}
11ed58: 8d 65 f4 lea -0xc(%ebp),%esp
11ed5b: 5b pop %ebx
11ed5c: 5e pop %esi
11ed5d: 5f pop %edi
11ed5e: c9 leave
11ed5f: 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;
11ed60: 8b 41 04 mov 0x4(%ecx),%eax
11ed63: 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;
11ed66: 8d 3c 01 lea (%ecx,%eax,1),%edi
11ed69: 89 7d d4 mov %edi,-0x2c(%ebp)
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
11ed6c: 89 fa mov %edi,%edx
11ed6e: 29 f2 sub %esi,%edx
11ed70: 83 c2 04 add $0x4,%edx
11ed73: 89 55 e0 mov %edx,-0x20(%ebp)
11ed76: 8b 57 04 mov 0x4(%edi),%edx
11ed79: 83 e2 fe and $0xfffffffe,%edx
11ed7c: 89 55 d0 mov %edx,-0x30(%ebp)
RTEMS_INLINE_ROUTINE bool _Heap_Is_free(
const Heap_Block *block
)
{
return !_Heap_Is_used( block );
11ed7f: f6 44 17 04 01 testb $0x1,0x4(%edi,%edx,1)
11ed84: 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;
11ed88: 8b 55 e0 mov -0x20(%ebp),%edx
11ed8b: 8b 7d 14 mov 0x14(%ebp),%edi
11ed8e: 89 17 mov %edx,(%edi)
if ( next_block_is_free ) {
11ed90: 80 7d df 00 cmpb $0x0,-0x21(%ebp)
11ed94: 75 6e jne 11ee04 <_Heap_Resize_block+0xe8>
block_size += next_block_size;
alloc_size += next_block_size;
}
if ( new_alloc_size > alloc_size ) {
11ed96: 8b 55 e0 mov -0x20(%ebp),%edx
11ed99: 39 55 10 cmp %edx,0x10(%ebp)
11ed9c: 77 79 ja 11ee17 <_Heap_Resize_block+0xfb>
return HEAP_RESIZE_UNSATISFIED;
}
if ( next_block_is_free ) {
11ed9e: 80 7d df 00 cmpb $0x0,-0x21(%ebp)
11eda2: 74 31 je 11edd5 <_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;
11eda4: 8b 79 04 mov 0x4(%ecx),%edi
11eda7: 83 e7 01 and $0x1,%edi
block->size_and_flag = size | flag;
11edaa: 09 c7 or %eax,%edi
11edac: 89 79 04 mov %edi,0x4(%ecx)
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
}
}
11edaf: 8b 7d d4 mov -0x2c(%ebp),%edi
11edb2: 8b 7f 08 mov 0x8(%edi),%edi
11edb5: 89 7d e4 mov %edi,-0x1c(%ebp)
11edb8: 8b 55 d4 mov -0x2c(%ebp),%edx
11edbb: 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;
11edbe: 8b 55 e4 mov -0x1c(%ebp),%edx
11edc1: 89 57 08 mov %edx,0x8(%edi)
next->prev = prev;
11edc4: 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;
11edc7: 83 4c 01 04 01 orl $0x1,0x4(%ecx,%eax,1)
/* Statistics */
--stats->free_blocks;
11edcc: ff 4b 38 decl 0x38(%ebx)
stats->free_size -= next_block_size;
11edcf: 8b 7d d0 mov -0x30(%ebp),%edi
11edd2: 29 7b 30 sub %edi,0x30(%ebx)
}
block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size );
11edd5: ff 75 10 pushl 0x10(%ebp)
11edd8: 56 push %esi
11edd9: 51 push %ecx
11edda: 53 push %ebx
11eddb: e8 24 da fe ff call 10c804 <_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;
11ede0: 8b 50 04 mov 0x4(%eax),%edx
11ede3: 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;
11ede6: 29 f0 sub %esi,%eax
11ede8: 8d 44 10 04 lea 0x4(%eax,%edx,1),%eax
11edec: 8b 55 18 mov 0x18(%ebp),%edx
11edef: 89 02 mov %eax,(%edx)
/* Statistics */
++stats->resizes;
11edf1: ff 43 54 incl 0x54(%ebx)
11edf4: 83 c4 10 add $0x10,%esp
return HEAP_RESIZE_SUCCESSFUL;
11edf7: 31 c0 xor %eax,%eax
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
}
}
11edf9: 8d 65 f4 lea -0xc(%ebp),%esp
11edfc: 5b pop %ebx
11edfd: 5e pop %esi
11edfe: 5f pop %edi
11edff: c9 leave
11ee00: c3 ret
11ee01: 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;
11ee04: 03 45 d0 add -0x30(%ebp),%eax
alloc_size += next_block_size;
11ee07: 8b 7d d0 mov -0x30(%ebp),%edi
11ee0a: 01 fa add %edi,%edx
11ee0c: 89 55 e0 mov %edx,-0x20(%ebp)
}
if ( new_alloc_size > alloc_size ) {
11ee0f: 8b 55 e0 mov -0x20(%ebp),%edx
11ee12: 39 55 10 cmp %edx,0x10(%ebp)
11ee15: 76 87 jbe 11ed9e <_Heap_Resize_block+0x82>
return HEAP_RESIZE_UNSATISFIED;
11ee17: b8 01 00 00 00 mov $0x1,%eax
new_size
);
} else {
return HEAP_RESIZE_FATAL_ERROR;
}
}
11ee1c: 8d 65 f4 lea -0xc(%ebp),%esp
11ee1f: 5b pop %ebx
11ee20: 5e pop %esi
11ee21: 5f pop %edi
11ee22: c9 leave
11ee23: c3 ret
0011ee24 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
11ee24: 55 push %ebp
11ee25: 89 e5 mov %esp,%ebp
11ee27: 56 push %esi
11ee28: 53 push %ebx
11ee29: 8b 5d 08 mov 0x8(%ebp),%ebx
11ee2c: 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);
11ee2f: 8d 4e f8 lea -0x8(%esi),%ecx
11ee32: 89 f0 mov %esi,%eax
11ee34: 31 d2 xor %edx,%edx
11ee36: 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);
11ee39: 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
11ee3b: 8b 43 20 mov 0x20(%ebx),%eax
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11ee3e: 39 c1 cmp %eax,%ecx
11ee40: 72 07 jb 11ee49 <_Heap_Size_of_alloc_area+0x25>
11ee42: 8b 53 24 mov 0x24(%ebx),%edx
11ee45: 39 d1 cmp %edx,%ecx
11ee47: 76 07 jbe 11ee50 <_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;
11ee49: 31 c0 xor %eax,%eax
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
11ee4b: 5b pop %ebx
11ee4c: 5e pop %esi
11ee4d: c9 leave
11ee4e: c3 ret
11ee4f: 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;
11ee50: 8b 59 04 mov 0x4(%ecx),%ebx
11ee53: 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);
11ee56: 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;
11ee58: 39 c8 cmp %ecx,%eax
11ee5a: 77 ed ja 11ee49 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN
11ee5c: 39 ca cmp %ecx,%edx
11ee5e: 72 e9 jb 11ee49 <_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 )
11ee60: f6 41 04 01 testb $0x1,0x4(%ecx)
11ee64: 74 e3 je 11ee49 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
11ee66: 29 f1 sub %esi,%ecx
11ee68: 8d 51 04 lea 0x4(%ecx),%edx
11ee6b: 8b 45 10 mov 0x10(%ebp),%eax
11ee6e: 89 10 mov %edx,(%eax)
return true;
11ee70: b0 01 mov $0x1,%al
}
11ee72: 5b pop %ebx
11ee73: 5e pop %esi
11ee74: c9 leave
11ee75: c3 ret
0010d338 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
10d338: 55 push %ebp
10d339: 89 e5 mov %esp,%ebp
10d33b: 57 push %edi
10d33c: 56 push %esi
10d33d: 53 push %ebx
10d33e: 83 ec 4c sub $0x4c,%esp
10d341: 8b 5d 08 mov 0x8(%ebp),%ebx
uintptr_t const page_size = heap->page_size;
10d344: 8b 43 10 mov 0x10(%ebx),%eax
10d347: 89 45 e0 mov %eax,-0x20(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10d34a: 8b 53 14 mov 0x14(%ebx),%edx
10d34d: 89 55 d0 mov %edx,-0x30(%ebp)
Heap_Block *const first_block = heap->first_block;
10d350: 8b 43 20 mov 0x20(%ebx),%eax
10d353: 89 45 dc mov %eax,-0x24(%ebp)
Heap_Block *const last_block = heap->last_block;
10d356: 8b 53 24 mov 0x24(%ebx),%edx
10d359: 89 55 cc mov %edx,-0x34(%ebp)
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
10d35c: 80 7d 10 00 cmpb $0x0,0x10(%ebp)
10d360: 74 1a je 10d37c <_Heap_Walk+0x44>
10d362: c7 45 d8 f0 d2 10 00 movl $0x10d2f0,-0x28(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
10d369: 83 3d 40 9c 12 00 03 cmpl $0x3,0x129c40
10d370: 74 1a je 10d38c <_Heap_Walk+0x54> <== ALWAYS TAKEN
}
block = next_block;
} while ( block != first_block );
return true;
10d372: b0 01 mov $0x1,%al
}
10d374: 8d 65 f4 lea -0xc(%ebp),%esp
10d377: 5b pop %ebx
10d378: 5e pop %esi
10d379: 5f pop %edi
10d37a: c9 leave
10d37b: 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;
10d37c: c7 45 d8 e8 d2 10 00 movl $0x10d2e8,-0x28(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
10d383: 83 3d 40 9c 12 00 03 cmpl $0x3,0x129c40
10d38a: 75 e6 jne 10d372 <_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)(
10d38c: 52 push %edx
10d38d: ff 73 0c pushl 0xc(%ebx)
10d390: ff 73 08 pushl 0x8(%ebx)
10d393: ff 75 cc pushl -0x34(%ebp)
10d396: ff 75 dc pushl -0x24(%ebp)
10d399: ff 73 1c pushl 0x1c(%ebx)
10d39c: ff 73 18 pushl 0x18(%ebx)
10d39f: ff 75 d0 pushl -0x30(%ebp)
10d3a2: ff 75 e0 pushl -0x20(%ebp)
10d3a5: 68 94 1d 12 00 push $0x121d94
10d3aa: 6a 00 push $0x0
10d3ac: ff 75 0c pushl 0xc(%ebp)
10d3af: 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 ) {
10d3b2: 83 c4 30 add $0x30,%esp
10d3b5: 8b 45 e0 mov -0x20(%ebp),%eax
10d3b8: 85 c0 test %eax,%eax
10d3ba: 74 70 je 10d42c <_Heap_Walk+0xf4>
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
10d3bc: f6 45 e0 03 testb $0x3,-0x20(%ebp)
10d3c0: 75 72 jne 10d434 <_Heap_Walk+0xfc>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d3c2: 8b 45 d0 mov -0x30(%ebp),%eax
10d3c5: 31 d2 xor %edx,%edx
10d3c7: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
10d3ca: 85 d2 test %edx,%edx
10d3cc: 75 72 jne 10d440 <_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;
10d3ce: 8b 45 dc mov -0x24(%ebp),%eax
10d3d1: 83 c0 08 add $0x8,%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d3d4: 31 d2 xor %edx,%edx
10d3d6: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if (
10d3d9: 85 d2 test %edx,%edx
10d3db: 75 6f jne 10d44c <_Heap_Walk+0x114>
block = next_block;
} while ( block != first_block );
return true;
}
10d3dd: 8b 45 dc mov -0x24(%ebp),%eax
10d3e0: 8b 40 04 mov 0x4(%eax),%eax
10d3e3: 89 45 e4 mov %eax,-0x1c(%ebp)
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
10d3e6: a8 01 test $0x1,%al
10d3e8: 0f 84 ce 02 00 00 je 10d6bc <_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;
10d3ee: 8b 55 cc mov -0x34(%ebp),%edx
10d3f1: 8b 42 04 mov 0x4(%edx),%eax
10d3f4: 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);
10d3f7: 01 d0 add %edx,%eax
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
10d3f9: f6 40 04 01 testb $0x1,0x4(%eax)
10d3fd: 74 25 je 10d424 <_Heap_Walk+0xec>
);
return false;
}
if (
10d3ff: 39 45 dc cmp %eax,-0x24(%ebp)
10d402: 74 54 je 10d458 <_Heap_Walk+0x120> <== ALWAYS TAKEN
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
10d404: 51 push %ecx <== NOT EXECUTED
10d405: 68 b0 1e 12 00 push $0x121eb0 <== NOT EXECUTED
10d40a: 66 90 xchg %ax,%ax <== NOT EXECUTED
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10d40c: 6a 01 push $0x1
10d40e: ff 75 0c pushl 0xc(%ebp)
10d411: ff 55 d8 call *-0x28(%ebp)
10d414: 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;
10d417: 31 c0 xor %eax,%eax
block = next_block;
} while ( block != first_block );
return true;
}
10d419: 8d 65 f4 lea -0xc(%ebp),%esp
10d41c: 5b pop %ebx
10d41d: 5e pop %esi
10d41e: 5f pop %edi
10d41f: c9 leave
10d420: c3 ret
10d421: 8d 76 00 lea 0x0(%esi),%esi
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
10d424: 53 push %ebx
10d425: 68 4a 1d 12 00 push $0x121d4a
10d42a: eb e0 jmp 10d40c <_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" );
10d42c: 57 push %edi
10d42d: 68 19 1d 12 00 push $0x121d19
10d432: eb d8 jmp 10d40c <_Heap_Walk+0xd4>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
10d434: ff 75 e0 pushl -0x20(%ebp)
10d437: 68 2c 1d 12 00 push $0x121d2c
10d43c: eb ce jmp 10d40c <_Heap_Walk+0xd4>
10d43e: 66 90 xchg %ax,%ax
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
10d440: ff 75 d0 pushl -0x30(%ebp)
10d443: 68 28 1e 12 00 push $0x121e28
10d448: eb c2 jmp 10d40c <_Heap_Walk+0xd4>
10d44a: 66 90 xchg %ax,%ax
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
10d44c: ff 75 dc pushl -0x24(%ebp)
10d44f: 68 4c 1e 12 00 push $0x121e4c
10d454: eb b6 jmp 10d40c <_Heap_Walk+0xd4>
10d456: 66 90 xchg %ax,%ax
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
10d458: 8b 43 10 mov 0x10(%ebx),%eax
10d45b: 89 45 c8 mov %eax,-0x38(%ebp)
block = next_block;
} while ( block != first_block );
return true;
}
10d45e: 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 ) {
10d461: 39 f3 cmp %esi,%ebx
10d463: 74 65 je 10d4ca <_Heap_Walk+0x192>
block = next_block;
} while ( block != first_block );
return true;
}
10d465: 8b 43 20 mov 0x20(%ebx),%eax
10d468: 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;
10d46b: 39 f0 cmp %esi,%eax
10d46d: 0f 87 55 02 00 00 ja 10d6c8 <_Heap_Walk+0x390> <== NEVER TAKEN
10d473: 8b 7b 24 mov 0x24(%ebx),%edi
10d476: 39 f7 cmp %esi,%edi
10d478: 0f 82 4a 02 00 00 jb 10d6c8 <_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;
10d47e: 8d 46 08 lea 0x8(%esi),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d481: 31 d2 xor %edx,%edx
10d483: f7 75 c8 divl -0x38(%ebp)
);
return false;
}
if (
10d486: 85 d2 test %edx,%edx
10d488: 0f 85 71 02 00 00 jne 10d6ff <_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;
10d48e: 8b 46 04 mov 0x4(%esi),%eax
10d491: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10d494: f6 44 06 04 01 testb $0x1,0x4(%esi,%eax,1)
10d499: 0f 85 6d 02 00 00 jne 10d70c <_Heap_Walk+0x3d4> <== NEVER TAKEN
10d49f: 89 da mov %ebx,%edx
10d4a1: 8d 76 00 lea 0x0(%esi),%esi
);
return false;
}
if ( free_block->prev != prev_block ) {
10d4a4: 8b 46 0c mov 0xc(%esi),%eax
10d4a7: 39 d0 cmp %edx,%eax
10d4a9: 0f 85 6a 02 00 00 jne 10d719 <_Heap_Walk+0x3e1>
return false;
}
prev_block = free_block;
free_block = free_block->next;
10d4af: 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 ) {
10d4b2: 39 cb cmp %ecx,%ebx
10d4b4: 74 1a je 10d4d0 <_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;
10d4b6: 39 4d d4 cmp %ecx,-0x2c(%ebp)
10d4b9: 0f 86 7d 01 00 00 jbe 10d63c <_Heap_Walk+0x304>
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
(*printer)(
10d4bf: 51 push %ecx
10d4c0: 68 e0 1e 12 00 push $0x121ee0
10d4c5: e9 42 ff ff ff jmp 10d40c <_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 ) {
10d4ca: 8b 53 20 mov 0x20(%ebx),%edx
10d4cd: 89 55 d4 mov %edx,-0x2c(%ebp)
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10d4d0: 8b 7d dc mov -0x24(%ebp),%edi
10d4d3: 8b 45 d4 mov -0x2c(%ebp),%eax
10d4d6: 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;
10d4d8: 8b 4d e4 mov -0x1c(%ebp),%ecx
10d4db: 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);
10d4de: 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;
10d4e1: 39 f0 cmp %esi,%eax
10d4e3: 76 23 jbe 10d508 <_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)(
10d4e5: 83 ec 0c sub $0xc,%esp
10d4e8: 56 push %esi
10d4e9: 57 push %edi
10d4ea: 68 64 1f 12 00 push $0x121f64
10d4ef: 90 nop
10d4f0: 6a 01 push $0x1
10d4f2: ff 75 0c pushl 0xc(%ebp)
10d4f5: ff 55 d8 call *-0x28(%ebp)
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
10d4f8: 83 c4 20 add $0x20,%esp
10d4fb: 31 c0 xor %eax,%eax
block = next_block;
} while ( block != first_block );
return true;
}
10d4fd: 8d 65 f4 lea -0xc(%ebp),%esp
10d500: 5b pop %ebx
10d501: 5e pop %esi
10d502: 5f pop %edi
10d503: c9 leave
10d504: c3 ret
10d505: 8d 76 00 lea 0x0(%esi),%esi
10d508: 39 73 24 cmp %esi,0x24(%ebx)
10d50b: 72 d8 jb 10d4e5 <_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;
10d50d: 3b 7d cc cmp -0x34(%ebp),%edi
10d510: 0f 95 45 d4 setne -0x2c(%ebp)
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d514: 89 c8 mov %ecx,%eax
10d516: 31 d2 xor %edx,%edx
10d518: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
10d51b: 85 d2 test %edx,%edx
10d51d: 74 0a je 10d529 <_Heap_Walk+0x1f1>
10d51f: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp)
10d523: 0f 85 a6 01 00 00 jne 10d6cf <_Heap_Walk+0x397>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
10d529: 39 4d d0 cmp %ecx,-0x30(%ebp)
10d52c: 76 0a jbe 10d538 <_Heap_Walk+0x200>
10d52e: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp)
10d532: 0f 85 a6 01 00 00 jne 10d6de <_Heap_Walk+0x3a6> <== ALWAYS TAKEN
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
10d538: 39 f7 cmp %esi,%edi
10d53a: 72 0a jb 10d546 <_Heap_Walk+0x20e>
10d53c: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp)
10d540: 0f 85 aa 01 00 00 jne 10d6f0 <_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;
10d546: 8b 55 e4 mov -0x1c(%ebp),%edx
10d549: 83 e2 01 and $0x1,%edx
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10d54c: f6 46 04 01 testb $0x1,0x4(%esi)
10d550: 74 4e je 10d5a0 <_Heap_Walk+0x268>
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
10d552: 85 d2 test %edx,%edx
10d554: 74 2e je 10d584 <_Heap_Walk+0x24c>
(*printer)(
10d556: 83 ec 0c sub $0xc,%esp
10d559: 51 push %ecx
10d55a: 57 push %edi
10d55b: 68 7b 1d 12 00 push $0x121d7b
10d560: 6a 00 push $0x0
10d562: ff 75 0c pushl 0xc(%ebp)
10d565: ff 55 d8 call *-0x28(%ebp)
10d568: 83 c4 20 add $0x20,%esp
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10d56b: 39 75 dc cmp %esi,-0x24(%ebp)
10d56e: 0f 84 fe fd ff ff je 10d372 <_Heap_Walk+0x3a>
10d574: 8b 56 04 mov 0x4(%esi),%edx
10d577: 89 55 e4 mov %edx,-0x1c(%ebp)
10d57a: 8b 43 20 mov 0x20(%ebx),%eax
10d57d: 89 f7 mov %esi,%edi
10d57f: e9 54 ff ff ff jmp 10d4d8 <_Heap_Walk+0x1a0>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
10d584: 83 ec 08 sub $0x8,%esp
10d587: ff 37 pushl (%edi)
10d589: 51 push %ecx
10d58a: 57 push %edi
10d58b: 68 c8 20 12 00 push $0x1220c8
10d590: 6a 00 push $0x0
10d592: ff 75 0c pushl 0xc(%ebp)
10d595: ff 55 d8 call *-0x28(%ebp)
10d598: 83 c4 20 add $0x20,%esp
10d59b: eb ce jmp 10d56b <_Heap_Walk+0x233>
10d59d: 8d 76 00 lea 0x0(%esi),%esi
block = next_block;
} while ( block != first_block );
return true;
}
10d5a0: 8b 43 08 mov 0x8(%ebx),%eax
10d5a3: 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 ?
10d5a6: 8b 47 08 mov 0x8(%edi),%eax
10d5a9: 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)(
10d5ac: 39 43 0c cmp %eax,0xc(%ebx)
10d5af: 0f 84 cb 00 00 00 je 10d680 <_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)" : "")
10d5b5: 39 c3 cmp %eax,%ebx
10d5b7: 0f 84 db 00 00 00 je 10d698 <_Heap_Walk+0x360>
10d5bd: c7 45 c8 09 1c 12 00 movl $0x121c09,-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 ?
10d5c4: 8b 47 0c mov 0xc(%edi),%eax
10d5c7: 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)(
10d5ca: 39 45 b4 cmp %eax,-0x4c(%ebp)
10d5cd: 0f 84 b9 00 00 00 je 10d68c <_Heap_Walk+0x354>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10d5d3: 39 c3 cmp %eax,%ebx
10d5d5: 0f 84 c9 00 00 00 je 10d6a4 <_Heap_Walk+0x36c>
10d5db: b8 09 1c 12 00 mov $0x121c09,%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)(
10d5e0: 83 ec 0c sub $0xc,%esp
10d5e3: ff 75 c8 pushl -0x38(%ebp)
10d5e6: ff 75 e4 pushl -0x1c(%ebp)
10d5e9: 50 push %eax
10d5ea: ff 75 d4 pushl -0x2c(%ebp)
10d5ed: 51 push %ecx
10d5ee: 57 push %edi
10d5ef: 68 24 20 12 00 push $0x122024
10d5f4: 6a 00 push $0x0
10d5f6: ff 75 0c pushl 0xc(%ebp)
10d5f9: 89 55 c4 mov %edx,-0x3c(%ebp)
10d5fc: 89 4d c0 mov %ecx,-0x40(%ebp)
10d5ff: 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 ) {
10d602: 8b 06 mov (%esi),%eax
10d604: 83 c4 30 add $0x30,%esp
10d607: 8b 4d c0 mov -0x40(%ebp),%ecx
10d60a: 39 c1 cmp %eax,%ecx
10d60c: 8b 55 c4 mov -0x3c(%ebp),%edx
10d60f: 75 5f jne 10d670 <_Heap_Walk+0x338>
);
return false;
}
if ( !prev_used ) {
10d611: 85 d2 test %edx,%edx
10d613: 0f 84 97 00 00 00 je 10d6b0 <_Heap_Walk+0x378>
block = next_block;
} while ( block != first_block );
return true;
}
10d619: 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 ) {
10d61c: 39 c3 cmp %eax,%ebx
10d61e: 74 0f je 10d62f <_Heap_Walk+0x2f7> <== NEVER TAKEN
if ( free_block == block ) {
10d620: 39 c7 cmp %eax,%edi
10d622: 0f 84 43 ff ff ff je 10d56b <_Heap_Walk+0x233>
return true;
}
free_block = free_block->next;
10d628: 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 ) {
10d62b: 39 c3 cmp %eax,%ebx
10d62d: 75 f1 jne 10d620 <_Heap_Walk+0x2e8>
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10d62f: 57 push %edi
10d630: 68 f0 20 12 00 push $0x1220f0
10d635: e9 d2 fd ff ff jmp 10d40c <_Heap_Walk+0xd4>
10d63a: 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;
10d63c: 39 f9 cmp %edi,%ecx
10d63e: 0f 87 7b fe ff ff ja 10d4bf <_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;
10d644: 8d 41 08 lea 0x8(%ecx),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10d647: 31 d2 xor %edx,%edx
10d649: f7 75 c8 divl -0x38(%ebp)
);
return false;
}
if (
10d64c: 85 d2 test %edx,%edx
10d64e: 0f 85 ad 00 00 00 jne 10d701 <_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;
10d654: 8b 41 04 mov 0x4(%ecx),%eax
10d657: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10d65a: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1)
10d65f: 0f 85 a9 00 00 00 jne 10d70e <_Heap_Walk+0x3d6>
10d665: 89 f2 mov %esi,%edx
10d667: 89 ce mov %ecx,%esi
10d669: e9 36 fe ff ff jmp 10d4a4 <_Heap_Walk+0x16c>
10d66e: 66 90 xchg %ax,%ax
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
10d670: 52 push %edx
10d671: 56 push %esi
10d672: 50 push %eax
10d673: 51 push %ecx
10d674: 57 push %edi
10d675: 68 5c 20 12 00 push $0x12205c
10d67a: e9 71 fe ff ff jmp 10d4f0 <_Heap_Walk+0x1b8>
10d67f: 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)(
10d680: c7 45 c8 e6 1c 12 00 movl $0x121ce6,-0x38(%ebp)
10d687: e9 38 ff ff ff jmp 10d5c4 <_Heap_Walk+0x28c>
10d68c: b8 ff 1c 12 00 mov $0x121cff,%eax
10d691: e9 4a ff ff ff jmp 10d5e0 <_Heap_Walk+0x2a8>
10d696: 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)" : "")
10d698: c7 45 c8 f5 1c 12 00 movl $0x121cf5,-0x38(%ebp)
10d69f: e9 20 ff ff ff jmp 10d5c4 <_Heap_Walk+0x28c>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10d6a4: b8 0f 1d 12 00 mov $0x121d0f,%eax
10d6a9: e9 32 ff ff ff jmp 10d5e0 <_Heap_Walk+0x2a8>
10d6ae: 66 90 xchg %ax,%ax
return false;
}
if ( !prev_used ) {
(*printer)(
10d6b0: 57 push %edi
10d6b1: 68 98 20 12 00 push $0x122098
10d6b6: e9 51 fd ff ff jmp 10d40c <_Heap_Walk+0xd4>
10d6bb: 90 nop
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
10d6bc: 56 push %esi
10d6bd: 68 80 1e 12 00 push $0x121e80
10d6c2: e9 45 fd ff ff jmp 10d40c <_Heap_Walk+0xd4>
10d6c7: 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;
10d6c8: 89 f1 mov %esi,%ecx <== NOT EXECUTED
10d6ca: e9 f0 fd ff ff jmp 10d4bf <_Heap_Walk+0x187> <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
10d6cf: 83 ec 0c sub $0xc,%esp
10d6d2: 51 push %ecx
10d6d3: 57 push %edi
10d6d4: 68 94 1f 12 00 push $0x121f94
10d6d9: e9 12 fe ff ff jmp 10d4f0 <_Heap_Walk+0x1b8>
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
(*printer)(
10d6de: 83 ec 08 sub $0x8,%esp
10d6e1: ff 75 d0 pushl -0x30(%ebp)
10d6e4: 51 push %ecx
10d6e5: 57 push %edi
10d6e6: 68 c4 1f 12 00 push $0x121fc4
10d6eb: e9 00 fe ff ff jmp 10d4f0 <_Heap_Walk+0x1b8>
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
(*printer)(
10d6f0: 83 ec 0c sub $0xc,%esp
10d6f3: 56 push %esi
10d6f4: 57 push %edi
10d6f5: 68 f0 1f 12 00 push $0x121ff0
10d6fa: e9 f1 fd ff ff jmp 10d4f0 <_Heap_Walk+0x1b8>
);
return false;
}
if (
10d6ff: 89 f1 mov %esi,%ecx <== NOT EXECUTED
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
10d701: 51 push %ecx
10d702: 68 00 1f 12 00 push $0x121f00
10d707: e9 00 fd ff ff jmp 10d40c <_Heap_Walk+0xd4>
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10d70c: 89 f1 mov %esi,%ecx <== NOT EXECUTED
(*printer)(
10d70e: 51 push %ecx
10d70f: 68 5f 1d 12 00 push $0x121d5f
10d714: e9 f3 fc ff ff jmp 10d40c <_Heap_Walk+0xd4>
return false;
}
if ( free_block->prev != prev_block ) {
(*printer)(
10d719: 83 ec 0c sub $0xc,%esp
10d71c: 50 push %eax
10d71d: 56 push %esi
10d71e: 68 30 1f 12 00 push $0x121f30
10d723: e9 c8 fd ff ff jmp 10d4f0 <_Heap_Walk+0x1b8>
0010bdac <_IO_Initialize_all_drivers>:
*
* Output Parameters: NONE
*/
void _IO_Initialize_all_drivers( void )
{
10bdac: 55 push %ebp
10bdad: 89 e5 mov %esp,%ebp
10bdaf: 53 push %ebx
10bdb0: 83 ec 04 sub $0x4,%esp
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
10bdb3: 8b 0d 20 80 12 00 mov 0x128020,%ecx
10bdb9: 85 c9 test %ecx,%ecx
10bdbb: 74 1a je 10bdd7 <_IO_Initialize_all_drivers+0x2b><== NEVER TAKEN
10bdbd: 31 db xor %ebx,%ebx
10bdbf: 90 nop
(void) rtems_io_initialize( major, 0, NULL );
10bdc0: 52 push %edx
10bdc1: 6a 00 push $0x0
10bdc3: 6a 00 push $0x0
10bdc5: 53 push %ebx
10bdc6: e8 49 52 00 00 call 111014 <rtems_io_initialize>
void _IO_Initialize_all_drivers( void )
{
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
10bdcb: 43 inc %ebx
10bdcc: 83 c4 10 add $0x10,%esp
10bdcf: 39 1d 20 80 12 00 cmp %ebx,0x128020
10bdd5: 77 e9 ja 10bdc0 <_IO_Initialize_all_drivers+0x14>
(void) rtems_io_initialize( major, 0, NULL );
}
10bdd7: 8b 5d fc mov -0x4(%ebp),%ebx
10bdda: c9 leave
10bddb: c3 ret
0010bd14 <_IO_Manager_initialization>:
* workspace.
*
*/
void _IO_Manager_initialization(void)
{
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 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;
10bd1d: 8b 1d b8 32 12 00 mov 0x1232b8,%ebx
drivers_in_table = Configuration.number_of_device_drivers;
10bd23: a1 b4 32 12 00 mov 0x1232b4,%eax
10bd28: 89 45 e4 mov %eax,-0x1c(%ebp)
number_of_drivers = Configuration.maximum_drivers;
10bd2b: 8b 35 b0 32 12 00 mov 0x1232b0,%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 )
10bd31: 39 f0 cmp %esi,%eax
10bd33: 73 5f jae 10bd94 <_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(
10bd35: 8d 0c 76 lea (%esi,%esi,2),%ecx
10bd38: c1 e1 03 shl $0x3,%ecx
10bd3b: 83 ec 0c sub $0xc,%esp
10bd3e: 51 push %ecx
10bd3f: 89 4d dc mov %ecx,-0x24(%ebp)
10bd42: e8 4d 2c 00 00 call 10e994 <_Workspace_Allocate_or_fatal_error>
10bd47: 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 *)
10bd49: a3 24 80 12 00 mov %eax,0x128024
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
10bd4e: 89 35 20 80 12 00 mov %esi,0x128020
memset(
10bd54: 31 c0 xor %eax,%eax
10bd56: 8b 4d dc mov -0x24(%ebp),%ecx
10bd59: 89 d7 mov %edx,%edi
10bd5b: 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++ )
10bd5d: 83 c4 10 add $0x10,%esp
10bd60: 8b 45 e4 mov -0x1c(%ebp),%eax
10bd63: 85 c0 test %eax,%eax
10bd65: 74 25 je 10bd8c <_IO_Manager_initialization+0x78><== NEVER TAKEN
10bd67: a1 24 80 12 00 mov 0x128024,%eax
10bd6c: 89 45 e0 mov %eax,-0x20(%ebp)
10bd6f: 31 c0 xor %eax,%eax
10bd71: 31 d2 xor %edx,%edx
10bd73: 90 nop
_IO_Driver_address_table[index] = driver_table[index];
10bd74: 8b 7d e0 mov -0x20(%ebp),%edi
10bd77: 01 c7 add %eax,%edi
10bd79: 8d 34 03 lea (%ebx,%eax,1),%esi
10bd7c: b9 06 00 00 00 mov $0x6,%ecx
10bd81: 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++ )
10bd83: 42 inc %edx
10bd84: 83 c0 18 add $0x18,%eax
10bd87: 39 55 e4 cmp %edx,-0x1c(%ebp)
10bd8a: 77 e8 ja 10bd74 <_IO_Manager_initialization+0x60>
_IO_Driver_address_table[index] = driver_table[index];
}
10bd8c: 8d 65 f4 lea -0xc(%ebp),%esp
10bd8f: 5b pop %ebx
10bd90: 5e pop %esi
10bd91: 5f pop %edi
10bd92: c9 leave
10bd93: 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;
10bd94: 89 1d 24 80 12 00 mov %ebx,0x128024
_IO_Number_of_drivers = number_of_drivers;
10bd9a: 8b 45 e4 mov -0x1c(%ebp),%eax
10bd9d: a3 20 80 12 00 mov %eax,0x128020
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
_IO_Driver_address_table[index] = driver_table[index];
}
10bda2: 8d 65 f4 lea -0xc(%ebp),%esp
10bda5: 5b pop %ebx
10bda6: 5e pop %esi
10bda7: 5f pop %edi
10bda8: c9 leave
10bda9: c3 ret
0010c8f8 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10c8f8: 55 push %ebp
10c8f9: 89 e5 mov %esp,%ebp
10c8fb: 53 push %ebx
10c8fc: 83 ec 08 sub $0x8,%esp
10c8ff: 8b 45 08 mov 0x8(%ebp),%eax
10c902: 8b 55 0c mov 0xc(%ebp),%edx
10c905: 8b 5d 10 mov 0x10(%ebp),%ebx
_Internal_errors_What_happened.the_source = the_source;
10c908: a3 50 76 12 00 mov %eax,0x127650
_Internal_errors_What_happened.is_internal = is_internal;
10c90d: 88 15 54 76 12 00 mov %dl,0x127654
_Internal_errors_What_happened.the_error = the_error;
10c913: 89 1d 58 76 12 00 mov %ebx,0x127658
_User_extensions_Fatal( the_source, is_internal, the_error );
10c919: 53 push %ebx
10c91a: 0f b6 d2 movzbl %dl,%edx
10c91d: 52 push %edx
10c91e: 50 push %eax
10c91f: e8 70 1c 00 00 call 10e594 <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
10c924: c7 05 40 77 12 00 05 movl $0x5,0x127740 <== NOT EXECUTED
10c92b: 00 00 00
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
10c92e: fa cli <== NOT EXECUTED
10c92f: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10c931: f4 hlt <== NOT EXECUTED
10c932: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c935: eb fe jmp 10c935 <_Internal_error_Occurred+0x3d><== NOT EXECUTED
001115ec <_Objects_API_maximum_class>:
#include <rtems/score/object.h>
unsigned int _Objects_API_maximum_class(
uint32_t api
)
{
1115ec: 55 push %ebp
1115ed: 89 e5 mov %esp,%ebp
1115ef: 8b 45 08 mov 0x8(%ebp),%eax
1115f2: 48 dec %eax
1115f3: 83 f8 02 cmp $0x2,%eax
1115f6: 77 0c ja 111604 <_Objects_API_maximum_class+0x18>
1115f8: 8b 04 85 a0 13 12 00 mov 0x1213a0(,%eax,4),%eax
case OBJECTS_NO_API:
default:
break;
}
return 0;
}
1115ff: c9 leave
111600: c3 ret
111601: 8d 76 00 lea 0x0(%esi),%esi
#include <rtems/score/object.h>
unsigned int _Objects_API_maximum_class(
uint32_t api
)
{
111604: 31 c0 xor %eax,%eax
case OBJECTS_NO_API:
default:
break;
}
return 0;
}
111606: c9 leave
111607: c3 ret
0010c988 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
10c988: 55 push %ebp
10c989: 89 e5 mov %esp,%ebp
10c98b: 56 push %esi
10c98c: 53 push %ebx
10c98d: 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 )
10c990: 8b 43 18 mov 0x18(%ebx),%eax
10c993: 85 c0 test %eax,%eax
10c995: 75 0d jne 10c9a4 <_Objects_Allocate+0x1c><== ALWAYS TAKEN
return NULL;
10c997: 31 c9 xor %ecx,%ecx
);
}
#endif
return the_object;
}
10c999: 89 c8 mov %ecx,%eax
10c99b: 8d 65 f8 lea -0x8(%ebp),%esp
10c99e: 5b pop %ebx
10c99f: 5e pop %esi
10c9a0: c9 leave
10c9a1: c3 ret
10c9a2: 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 );
10c9a4: 8d 73 20 lea 0x20(%ebx),%esi
10c9a7: 83 ec 0c sub $0xc,%esp
10c9aa: 56 push %esi
10c9ab: e8 68 f6 ff ff call 10c018 <_Chain_Get>
10c9b0: 89 c1 mov %eax,%ecx
if ( information->auto_extend ) {
10c9b2: 83 c4 10 add $0x10,%esp
10c9b5: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10c9b9: 74 de je 10c999 <_Objects_Allocate+0x11>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
10c9bb: 85 c0 test %eax,%eax
10c9bd: 74 29 je 10c9e8 <_Objects_Allocate+0x60>
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
10c9bf: 0f b7 41 08 movzwl 0x8(%ecx),%eax
10c9c3: 0f b7 53 08 movzwl 0x8(%ebx),%edx
10c9c7: 29 d0 sub %edx,%eax
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
10c9c9: 0f b7 73 14 movzwl 0x14(%ebx),%esi
10c9cd: 31 d2 xor %edx,%edx
10c9cf: f7 f6 div %esi
information->inactive_per_block[ block ]--;
10c9d1: c1 e0 02 shl $0x2,%eax
10c9d4: 03 43 30 add 0x30(%ebx),%eax
10c9d7: ff 08 decl (%eax)
information->inactive--;
10c9d9: 66 ff 4b 2c decw 0x2c(%ebx)
);
}
#endif
return the_object;
}
10c9dd: 89 c8 mov %ecx,%eax
10c9df: 8d 65 f8 lea -0x8(%ebp),%esp
10c9e2: 5b pop %ebx
10c9e3: 5e pop %esi
10c9e4: c9 leave
10c9e5: c3 ret
10c9e6: 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 );
10c9e8: 83 ec 0c sub $0xc,%esp
10c9eb: 53 push %ebx
10c9ec: e8 3b 00 00 00 call 10ca2c <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10c9f1: 89 34 24 mov %esi,(%esp)
10c9f4: e8 1f f6 ff ff call 10c018 <_Chain_Get>
10c9f9: 89 c1 mov %eax,%ecx
}
if ( the_object ) {
10c9fb: 83 c4 10 add $0x10,%esp
10c9fe: 85 c0 test %eax,%eax
10ca00: 74 97 je 10c999 <_Objects_Allocate+0x11>
10ca02: eb bb jmp 10c9bf <_Objects_Allocate+0x37>
0010ca2c <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
10ca2c: 55 push %ebp
10ca2d: 89 e5 mov %esp,%ebp
10ca2f: 57 push %edi
10ca30: 56 push %esi
10ca31: 53 push %ebx
10ca32: 83 ec 4c sub $0x4c,%esp
10ca35: 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 );
10ca38: 0f b7 43 08 movzwl 0x8(%ebx),%eax
10ca3c: 89 45 cc mov %eax,-0x34(%ebp)
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
10ca3f: 8b 4b 34 mov 0x34(%ebx),%ecx
10ca42: 85 c9 test %ecx,%ecx
10ca44: 0f 84 66 02 00 00 je 10ccb0 <_Objects_Extend_information+0x284>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
10ca4a: 8b 73 10 mov 0x10(%ebx),%esi
10ca4d: 66 89 75 d0 mov %si,-0x30(%ebp)
10ca51: 8b 7b 14 mov 0x14(%ebx),%edi
10ca54: 89 f0 mov %esi,%eax
10ca56: 31 d2 xor %edx,%edx
10ca58: 66 f7 f7 div %di
10ca5b: 0f b7 f0 movzwl %ax,%esi
for ( ; block < block_count; block++ ) {
10ca5e: 85 f6 test %esi,%esi
10ca60: 0f 84 63 02 00 00 je 10ccc9 <_Objects_Extend_information+0x29d><== NEVER TAKEN
if ( information->object_blocks[ block ] == NULL ) {
10ca66: 8b 01 mov (%ecx),%eax
10ca68: 85 c0 test %eax,%eax
10ca6a: 0f 84 6b 02 00 00 je 10ccdb <_Objects_Extend_information+0x2af><== NEVER TAKEN
10ca70: 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 );
10ca73: 8b 55 cc mov -0x34(%ebp),%edx
10ca76: 89 55 d4 mov %edx,-0x2c(%ebp)
index_base = minimum_index;
block = 0;
10ca79: 31 d2 xor %edx,%edx
10ca7b: 8b 45 d4 mov -0x2c(%ebp),%eax
10ca7e: eb 0a jmp 10ca8a <_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 ) {
10ca80: 83 3c 91 00 cmpl $0x0,(%ecx,%edx,4)
10ca84: 0f 84 c6 01 00 00 je 10cc50 <_Objects_Extend_information+0x224>
do_extend = false;
break;
} else
index_base += information->allocation_size;
10ca8a: 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++ ) {
10ca8c: 42 inc %edx
10ca8d: 39 d6 cmp %edx,%esi
10ca8f: 77 ef ja 10ca80 <_Objects_Extend_information+0x54>
10ca91: 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;
10ca94: b1 01 mov $0x1,%cl
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
10ca96: 0f b7 45 d0 movzwl -0x30(%ebp),%eax
10ca9a: 01 f8 add %edi,%eax
10ca9c: 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 ) {
10ca9f: 3d ff ff 00 00 cmp $0xffff,%eax
10caa4: 0f 87 9e 01 00 00 ja 10cc48 <_Objects_Extend_information+0x21c><== 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;
10caaa: 0f af 7b 18 imul 0x18(%ebx),%edi
if ( information->auto_extend ) {
10caae: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10cab2: 0f 84 a4 01 00 00 je 10cc5c <_Objects_Extend_information+0x230>
new_object_block = _Workspace_Allocate( block_size );
10cab8: 83 ec 0c sub $0xc,%esp
10cabb: 57 push %edi
10cabc: 89 55 b8 mov %edx,-0x48(%ebp)
10cabf: 88 4d b4 mov %cl,-0x4c(%ebp)
10cac2: e8 99 1e 00 00 call 10e960 <_Workspace_Allocate>
10cac7: 89 45 c8 mov %eax,-0x38(%ebp)
if ( !new_object_block )
10caca: 83 c4 10 add $0x10,%esp
10cacd: 85 c0 test %eax,%eax
10cacf: 8b 55 b8 mov -0x48(%ebp),%edx
10cad2: 8a 4d b4 mov -0x4c(%ebp),%cl
10cad5: 0f 84 6d 01 00 00 je 10cc48 <_Objects_Extend_information+0x21c>
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
10cadb: 84 c9 test %cl,%cl
10cadd: 0f 84 ea 00 00 00 je 10cbcd <_Objects_Extend_information+0x1a1>
*/
/*
* Up the block count and maximum
*/
block_count++;
10cae3: 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 );
10cae6: 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 *)) +
10cae9: 8d 04 7f lea (%edi,%edi,2),%eax
((maximum + minimum_index) * sizeof(Objects_Control *));
10caec: 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 *)) +
10caef: 03 45 cc add -0x34(%ebp),%eax
block_count++;
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
10caf2: 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 );
10caf5: 50 push %eax
10caf6: 89 55 b8 mov %edx,-0x48(%ebp)
10caf9: e8 62 1e 00 00 call 10e960 <_Workspace_Allocate>
10cafe: 89 45 c4 mov %eax,-0x3c(%ebp)
if ( !object_blocks ) {
10cb01: 83 c4 10 add $0x10,%esp
10cb04: 85 c0 test %eax,%eax
10cb06: 8b 55 b8 mov -0x48(%ebp),%edx
10cb09: 0f 84 de 01 00 00 je 10cced <_Objects_Extend_information+0x2c1>
10cb0f: 8b 45 c4 mov -0x3c(%ebp),%eax
10cb12: 8d 04 b8 lea (%eax,%edi,4),%eax
10cb15: 89 45 bc mov %eax,-0x44(%ebp)
10cb18: 8b 4d c4 mov -0x3c(%ebp),%ecx
10cb1b: 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 ) {
10cb1e: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx
10cb22: 39 4d cc cmp %ecx,-0x34(%ebp)
10cb25: 0f 82 51 01 00 00 jb 10cc7c <_Objects_Extend_information+0x250>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
10cb2b: 8b 4d cc mov -0x34(%ebp),%ecx
10cb2e: 85 c9 test %ecx,%ecx
10cb30: 74 12 je 10cb44 <_Objects_Extend_information+0x118><== NEVER TAKEN
10cb32: 31 c9 xor %ecx,%ecx
10cb34: 8b 7d cc mov -0x34(%ebp),%edi
10cb37: 90 nop
local_table[ index ] = NULL;
10cb38: 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++ ) {
10cb3f: 41 inc %ecx
10cb40: 39 cf cmp %ecx,%edi
10cb42: 77 f4 ja 10cb38 <_Objects_Extend_information+0x10c><== NEVER TAKEN
10cb44: c1 e6 02 shl $0x2,%esi
10cb47: 89 75 c0 mov %esi,-0x40(%ebp)
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
10cb4a: 8b 4d c4 mov -0x3c(%ebp),%ecx
10cb4d: 8b 75 c0 mov -0x40(%ebp),%esi
10cb50: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1)
inactive_per_block[block_count] = 0;
10cb57: 8b 4d bc mov -0x44(%ebp),%ecx
10cb5a: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1)
for ( index=index_base ;
index < ( information->allocation_size + index_base );
10cb61: 0f b7 73 14 movzwl 0x14(%ebx),%esi
10cb65: 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 ;
10cb68: 39 75 d4 cmp %esi,-0x2c(%ebp)
10cb6b: 73 0f jae 10cb7c <_Objects_Extend_information+0x150><== NEVER TAKEN
10cb6d: 8b 4d d4 mov -0x2c(%ebp),%ecx
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
10cb70: 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++ ) {
10cb77: 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 ;
10cb78: 39 f1 cmp %esi,%ecx
10cb7a: 72 f4 jb 10cb70 <_Objects_Extend_information+0x144>
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
}
_ISR_Disable( level );
10cb7c: 9c pushf
10cb7d: fa cli
10cb7e: 5f pop %edi
old_tables = information->object_blocks;
10cb7f: 8b 4b 34 mov 0x34(%ebx),%ecx
information->object_blocks = object_blocks;
10cb82: 8b 75 c4 mov -0x3c(%ebp),%esi
10cb85: 89 73 34 mov %esi,0x34(%ebx)
information->inactive_per_block = inactive_per_block;
10cb88: 8b 75 bc mov -0x44(%ebp),%esi
10cb8b: 89 73 30 mov %esi,0x30(%ebx)
information->local_table = local_table;
10cb8e: 89 43 1c mov %eax,0x1c(%ebx)
information->maximum = (Objects_Maximum) maximum;
10cb91: 8b 45 d0 mov -0x30(%ebp),%eax
10cb94: 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) |
10cb98: 8b 33 mov (%ebx),%esi
10cb9a: c1 e6 18 shl $0x18,%esi
10cb9d: 81 ce 00 00 01 00 or $0x10000,%esi
information->maximum_id = _Objects_Build_id(
10cba3: 0f b7 43 04 movzwl 0x4(%ebx),%eax
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10cba7: c1 e0 1b shl $0x1b,%eax
10cbaa: 09 c6 or %eax,%esi
10cbac: 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) |
10cbb0: 09 c6 or %eax,%esi
10cbb2: 89 73 0c mov %esi,0xc(%ebx)
information->the_class,
_Objects_Local_node,
information->maximum
);
_ISR_Enable( level );
10cbb5: 57 push %edi
10cbb6: 9d popf
if ( old_tables )
10cbb7: 85 c9 test %ecx,%ecx
10cbb9: 74 12 je 10cbcd <_Objects_Extend_information+0x1a1>
_Workspace_Free( old_tables );
10cbbb: 83 ec 0c sub $0xc,%esp
10cbbe: 51 push %ecx
10cbbf: 89 55 b8 mov %edx,-0x48(%ebp)
10cbc2: e8 b5 1d 00 00 call 10e97c <_Workspace_Free>
10cbc7: 83 c4 10 add $0x10,%esp
10cbca: 8b 55 b8 mov -0x48(%ebp),%edx
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
10cbcd: c1 e2 02 shl $0x2,%edx
10cbd0: 89 55 d0 mov %edx,-0x30(%ebp)
10cbd3: 8b 43 34 mov 0x34(%ebx),%eax
10cbd6: 8b 4d c8 mov -0x38(%ebp),%ecx
10cbd9: 89 0c 10 mov %ecx,(%eax,%edx,1)
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
10cbdc: ff 73 18 pushl 0x18(%ebx)
10cbdf: 0f b7 43 14 movzwl 0x14(%ebx),%eax
10cbe3: 50 push %eax
10cbe4: 51 push %ecx
10cbe5: 8d 7d dc lea -0x24(%ebp),%edi
10cbe8: 57 push %edi
10cbe9: e8 66 44 00 00 call 111054 <_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 ) {
10cbee: 83 c4 10 add $0x10,%esp
10cbf1: 8b 75 d4 mov -0x2c(%ebp),%esi
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10cbf4: 8d 43 20 lea 0x20(%ebx),%eax
10cbf7: 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 ) {
10cbfa: eb 29 jmp 10cc25 <_Objects_Extend_information+0x1f9>
10cbfc: 8b 13 mov (%ebx),%edx
10cbfe: c1 e2 18 shl $0x18,%edx
10cc01: 81 ca 00 00 01 00 or $0x10000,%edx
the_object->id = _Objects_Build_id(
10cc07: 0f b7 4b 04 movzwl 0x4(%ebx),%ecx
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10cc0b: c1 e1 1b shl $0x1b,%ecx
10cc0e: 09 ca or %ecx,%edx
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10cc10: 09 f2 or %esi,%edx
10cc12: 89 50 08 mov %edx,0x8(%eax)
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10cc15: 83 ec 08 sub $0x8,%esp
10cc18: 50 push %eax
10cc19: ff 75 d4 pushl -0x2c(%ebp)
10cc1c: e8 bb f3 ff ff call 10bfdc <_Chain_Append>
index++;
10cc21: 46 inc %esi
10cc22: 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 ) {
10cc25: 83 ec 0c sub $0xc,%esp
10cc28: 57 push %edi
10cc29: e8 ea f3 ff ff call 10c018 <_Chain_Get>
10cc2e: 83 c4 10 add $0x10,%esp
10cc31: 85 c0 test %eax,%eax
10cc33: 75 c7 jne 10cbfc <_Objects_Extend_information+0x1d0>
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
10cc35: 8b 43 14 mov 0x14(%ebx),%eax
10cc38: 8b 53 30 mov 0x30(%ebx),%edx
10cc3b: 0f b7 c8 movzwl %ax,%ecx
10cc3e: 8b 75 d0 mov -0x30(%ebp),%esi
10cc41: 89 0c 32 mov %ecx,(%edx,%esi,1)
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
10cc44: 66 01 43 2c add %ax,0x2c(%ebx)
}
10cc48: 8d 65 f4 lea -0xc(%ebp),%esp
10cc4b: 5b pop %ebx
10cc4c: 5e pop %esi
10cc4d: 5f pop %edi
10cc4e: c9 leave
10cc4f: c3 ret
10cc50: 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;
10cc53: 31 c9 xor %ecx,%ecx
10cc55: e9 3c fe ff ff jmp 10ca96 <_Objects_Extend_information+0x6a>
10cc5a: 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 );
10cc5c: 83 ec 0c sub $0xc,%esp
10cc5f: 57 push %edi
10cc60: 89 55 b8 mov %edx,-0x48(%ebp)
10cc63: 88 4d b4 mov %cl,-0x4c(%ebp)
10cc66: e8 29 1d 00 00 call 10e994 <_Workspace_Allocate_or_fatal_error>
10cc6b: 89 45 c8 mov %eax,-0x38(%ebp)
10cc6e: 83 c4 10 add $0x10,%esp
10cc71: 8a 4d b4 mov -0x4c(%ebp),%cl
10cc74: 8b 55 b8 mov -0x48(%ebp),%edx
10cc77: e9 5f fe ff ff jmp 10cadb <_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,
10cc7c: c1 e6 02 shl $0x2,%esi
10cc7f: 89 75 c0 mov %esi,-0x40(%ebp)
10cc82: 8b 73 34 mov 0x34(%ebx),%esi
10cc85: 8b 7d c4 mov -0x3c(%ebp),%edi
10cc88: 8b 4d c0 mov -0x40(%ebp),%ecx
10cc8b: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
10cc8d: 8b 73 30 mov 0x30(%ebx),%esi
10cc90: 8b 7d bc mov -0x44(%ebp),%edi
10cc93: 8b 4d c0 mov -0x40(%ebp),%ecx
10cc96: 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 *) );
10cc98: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx
10cc9c: 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,
10cc9f: c1 e1 02 shl $0x2,%ecx
10cca2: 8b 73 1c mov 0x1c(%ebx),%esi
10cca5: 89 c7 mov %eax,%edi
10cca7: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
10cca9: e9 9c fe ff ff jmp 10cb4a <_Objects_Extend_information+0x11e>
10ccae: 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 )
10ccb0: 8b 53 10 mov 0x10(%ebx),%edx
10ccb3: 66 89 55 d0 mov %dx,-0x30(%ebp)
10ccb7: 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 );
10ccbb: 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;
10ccbe: b1 01 mov $0x1,%cl
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
10ccc0: 31 d2 xor %edx,%edx
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
10ccc2: 31 f6 xor %esi,%esi
10ccc4: e9 cd fd ff ff jmp 10ca96 <_Objects_Extend_information+0x6a>
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
10ccc9: 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 );
10cccc: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED
10cccf: 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;
10ccd2: b1 01 mov $0x1,%cl <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
10ccd4: 31 d2 xor %edx,%edx <== NOT EXECUTED
10ccd6: e9 bb fd ff ff jmp 10ca96 <_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 ) {
10ccdb: 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 );
10ccde: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED
10cce1: 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;
10cce4: 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;
10cce6: 31 d2 xor %edx,%edx <== NOT EXECUTED
10cce8: e9 a9 fd ff ff jmp 10ca96 <_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 );
10cced: 83 ec 0c sub $0xc,%esp
10ccf0: ff 75 c8 pushl -0x38(%ebp)
10ccf3: e8 84 1c 00 00 call 10e97c <_Workspace_Free>
return;
10ccf8: 83 c4 10 add $0x10,%esp
10ccfb: e9 48 ff ff ff jmp 10cc48 <_Objects_Extend_information+0x21c>
0010cd90 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
10cd90: 55 push %ebp
10cd91: 89 e5 mov %esp,%ebp
10cd93: 56 push %esi
10cd94: 53 push %ebx
10cd95: 8b 75 08 mov 0x8(%ebp),%esi
10cd98: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
10cd9b: 66 85 db test %bx,%bx
10cd9e: 75 0c jne 10cdac <_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;
10cda0: 31 c0 xor %eax,%eax
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
10cda2: 8d 65 f8 lea -0x8(%ebp),%esp
10cda5: 5b pop %ebx
10cda6: 5e pop %esi
10cda7: c9 leave
10cda8: c3 ret
10cda9: 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 );
10cdac: 83 ec 0c sub $0xc,%esp
10cdaf: 56 push %esi
10cdb0: e8 37 48 00 00 call 1115ec <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
10cdb5: 83 c4 10 add $0x10,%esp
10cdb8: 85 c0 test %eax,%eax
10cdba: 74 e4 je 10cda0 <_Objects_Get_information+0x10>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
10cdbc: 0f b7 db movzwl %bx,%ebx
10cdbf: 39 d8 cmp %ebx,%eax
10cdc1: 72 dd jb 10cda0 <_Objects_Get_information+0x10>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10cdc3: 8b 14 b5 48 75 12 00 mov 0x127548(,%esi,4),%edx
return NULL;
10cdca: 31 c0 xor %eax,%eax
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10cdcc: 85 d2 test %edx,%edx
10cdce: 74 d2 je 10cda2 <_Objects_Get_information+0x12><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
10cdd0: 8b 04 9a mov (%edx,%ebx,4),%eax
if ( !info )
10cdd3: 85 c0 test %eax,%eax
10cdd5: 74 cb je 10cda2 <_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;
10cdd7: 31 d2 xor %edx,%edx
10cdd9: 66 83 78 10 00 cmpw $0x0,0x10(%eax)
10cdde: 0f 95 c2 setne %dl
10cde1: f7 da neg %edx
10cde3: 21 d0 and %edx,%eax
10cde5: eb bb jmp 10cda2 <_Objects_Get_information+0x12>
0010cde8 <_Objects_Get_isr_disable>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location,
ISR_Level *level_p
)
{
10cde8: 55 push %ebp
10cde9: 89 e5 mov %esp,%ebp
10cdeb: 56 push %esi
10cdec: 53 push %ebx
10cded: 8b 55 08 mov 0x8(%ebp),%edx
10cdf0: 8b 5d 10 mov 0x10(%ebp),%ebx
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
10cdf3: b8 01 00 00 00 mov $0x1,%eax
10cdf8: 2b 42 08 sub 0x8(%edx),%eax
10cdfb: 03 45 0c add 0xc(%ebp),%eax
_ISR_Disable( level );
10cdfe: 9c pushf
10cdff: fa cli
10ce00: 5e pop %esi
if ( information->maximum >= index ) {
10ce01: 0f b7 4a 10 movzwl 0x10(%edx),%ecx
10ce05: 39 c8 cmp %ecx,%eax
10ce07: 77 1b ja 10ce24 <_Objects_Get_isr_disable+0x3c>
if ( (the_object = information->local_table[ index ]) != NULL ) {
10ce09: 8b 52 1c mov 0x1c(%edx),%edx
10ce0c: 8b 04 82 mov (%edx,%eax,4),%eax
10ce0f: 85 c0 test %eax,%eax
10ce11: 74 21 je 10ce34 <_Objects_Get_isr_disable+0x4c>
*location = OBJECTS_LOCAL;
10ce13: c7 03 00 00 00 00 movl $0x0,(%ebx)
*level_p = level;
10ce19: 8b 55 14 mov 0x14(%ebp),%edx
10ce1c: 89 32 mov %esi,(%edx)
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
#endif
}
10ce1e: 5b pop %ebx
10ce1f: 5e pop %esi
10ce20: c9 leave
10ce21: c3 ret
10ce22: 66 90 xchg %ax,%ax
}
_ISR_Enable( level );
*location = OBJECTS_ERROR;
return NULL;
}
_ISR_Enable( level );
10ce24: 56 push %esi
10ce25: 9d popf
*location = OBJECTS_ERROR;
10ce26: 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;
10ce2c: 31 c0 xor %eax,%eax
#endif
}
10ce2e: 5b pop %ebx
10ce2f: 5e pop %esi
10ce30: c9 leave
10ce31: c3 ret
10ce32: 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 );
10ce34: 56 push %esi
10ce35: 9d popf
*location = OBJECTS_ERROR;
10ce36: c7 03 01 00 00 00 movl $0x1,(%ebx)
return NULL;
10ce3c: eb e0 jmp 10ce1e <_Objects_Get_isr_disable+0x36>
0010e4d8 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
10e4d8: 55 push %ebp
10e4d9: 89 e5 mov %esp,%ebp
10e4db: 57 push %edi
10e4dc: 56 push %esi
10e4dd: 53 push %ebx
10e4de: 83 ec 2c sub $0x2c,%esp
10e4e1: 8b 55 08 mov 0x8(%ebp),%edx
10e4e4: 8b 75 0c mov 0xc(%ebp),%esi
10e4e7: 8b 5d 10 mov 0x10(%ebp),%ebx
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
10e4ea: 85 f6 test %esi,%esi
10e4ec: 75 0e jne 10e4fc <_Objects_Get_name_as_string+0x24>
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
10e4ee: 31 db xor %ebx,%ebx
_Thread_Enable_dispatch();
return name;
}
return NULL; /* unreachable path */
}
10e4f0: 89 d8 mov %ebx,%eax
10e4f2: 8d 65 f4 lea -0xc(%ebp),%esp
10e4f5: 5b pop %ebx
10e4f6: 5e pop %esi
10e4f7: 5f pop %edi
10e4f8: c9 leave
10e4f9: c3 ret
10e4fa: 66 90 xchg %ax,%ax
Objects_Id tmpId;
if ( length == 0 )
return NULL;
if ( name == NULL )
10e4fc: 85 db test %ebx,%ebx
10e4fe: 74 f0 je 10e4f0 <_Objects_Get_name_as_string+0x18>
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10e500: 85 d2 test %edx,%edx
10e502: 75 08 jne 10e50c <_Objects_Get_name_as_string+0x34>
10e504: a1 98 29 13 00 mov 0x132998,%eax
10e509: 8b 50 08 mov 0x8(%eax),%edx
information = _Objects_Get_information_id( tmpId );
10e50c: 83 ec 0c sub $0xc,%esp
10e50f: 52 push %edx
10e510: 89 55 cc mov %edx,-0x34(%ebp)
10e513: e8 f0 fe ff ff call 10e408 <_Objects_Get_information_id>
10e518: 89 c7 mov %eax,%edi
if ( !information )
10e51a: 83 c4 10 add $0x10,%esp
10e51d: 85 c0 test %eax,%eax
10e51f: 8b 55 cc mov -0x34(%ebp),%edx
10e522: 74 ca je 10e4ee <_Objects_Get_name_as_string+0x16>
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
10e524: 51 push %ecx
10e525: 8d 45 e4 lea -0x1c(%ebp),%eax
10e528: 50 push %eax
10e529: 52 push %edx
10e52a: 57 push %edi
10e52b: e8 90 00 00 00 call 10e5c0 <_Objects_Get>
switch ( location ) {
10e530: 83 c4 10 add $0x10,%esp
10e533: 8b 55 e4 mov -0x1c(%ebp),%edx
10e536: 85 d2 test %edx,%edx
10e538: 75 b4 jne 10e4ee <_Objects_Get_name_as_string+0x16>
return NULL;
case OBJECTS_LOCAL:
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
10e53a: 80 7f 38 00 cmpb $0x0,0x38(%edi)
10e53e: 74 54 je 10e594 <_Objects_Get_name_as_string+0xbc>
s = the_object->name.name_p;
10e540: 8b 78 0c mov 0xc(%eax),%edi
lname[ 4 ] = '\0';
s = lname;
}
d = name;
if ( s ) {
10e543: 85 ff test %edi,%edi
10e545: 74 74 je 10e5bb <_Objects_Get_name_as_string+0xe3>
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10e547: 4e dec %esi
10e548: 89 75 d4 mov %esi,-0x2c(%ebp)
10e54b: 74 6e je 10e5bb <_Objects_Get_name_as_string+0xe3><== NEVER TAKEN
10e54d: 8a 17 mov (%edi),%dl
10e54f: 84 d2 test %dl,%dl
10e551: 74 68 je 10e5bb <_Objects_Get_name_as_string+0xe3>
10e553: 89 d9 mov %ebx,%ecx
10e555: 31 c0 xor %eax,%eax
10e557: 89 5d d0 mov %ebx,-0x30(%ebp)
10e55a: eb 07 jmp 10e563 <_Objects_Get_name_as_string+0x8b>
10e55c: 8a 14 07 mov (%edi,%eax,1),%dl
10e55f: 84 d2 test %dl,%dl
10e561: 74 21 je 10e584 <_Objects_Get_name_as_string+0xac>
*d = (isprint((unsigned char)*s)) ? *s : '*';
10e563: 0f b6 da movzbl %dl,%ebx
10e566: 8b 35 a8 82 12 00 mov 0x1282a8,%esi
10e56c: 0f be 5c 1e 01 movsbl 0x1(%esi,%ebx,1),%ebx
10e571: 81 e3 97 00 00 00 and $0x97,%ebx
10e577: 75 02 jne 10e57b <_Objects_Get_name_as_string+0xa3>
10e579: b2 2a mov $0x2a,%dl
10e57b: 88 11 mov %dl,(%ecx)
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10e57d: 40 inc %eax
10e57e: 41 inc %ecx
10e57f: 3b 45 d4 cmp -0x2c(%ebp),%eax
10e582: 72 d8 jb 10e55c <_Objects_Get_name_as_string+0x84>
10e584: 8b 5d d0 mov -0x30(%ebp),%ebx
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
10e587: c6 01 00 movb $0x0,(%ecx)
_Thread_Enable_dispatch();
10e58a: e8 e5 0a 00 00 call 10f074 <_Thread_Enable_dispatch>
return name;
10e58f: e9 5c ff ff ff jmp 10e4f0 <_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;
10e594: 8b 40 0c mov 0xc(%eax),%eax
lname[ 0 ] = (u32_name >> 24) & 0xff;
10e597: 89 c2 mov %eax,%edx
10e599: c1 ea 18 shr $0x18,%edx
10e59c: 88 55 df mov %dl,-0x21(%ebp)
lname[ 1 ] = (u32_name >> 16) & 0xff;
10e59f: 89 c2 mov %eax,%edx
10e5a1: c1 ea 10 shr $0x10,%edx
10e5a4: 88 55 e0 mov %dl,-0x20(%ebp)
lname[ 2 ] = (u32_name >> 8) & 0xff;
10e5a7: 89 c2 mov %eax,%edx
10e5a9: c1 ea 08 shr $0x8,%edx
10e5ac: 88 55 e1 mov %dl,-0x1f(%ebp)
lname[ 3 ] = (u32_name >> 0) & 0xff;
10e5af: 88 45 e2 mov %al,-0x1e(%ebp)
lname[ 4 ] = '\0';
10e5b2: c6 45 e3 00 movb $0x0,-0x1d(%ebp)
s = lname;
10e5b6: 8d 7d df lea -0x21(%ebp),%edi
10e5b9: eb 8c jmp 10e547 <_Objects_Get_name_as_string+0x6f>
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10e5bb: 89 d9 mov %ebx,%ecx
10e5bd: eb c8 jmp 10e587 <_Objects_Get_name_as_string+0xaf>
0010cf98 <_Objects_Get_next>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
10cf98: 55 push %ebp
10cf99: 89 e5 mov %esp,%ebp
10cf9b: 57 push %edi
10cf9c: 56 push %esi
10cf9d: 53 push %ebx
10cf9e: 83 ec 0c sub $0xc,%esp
10cfa1: 8b 5d 08 mov 0x8(%ebp),%ebx
10cfa4: 8b 75 0c mov 0xc(%ebp),%esi
10cfa7: 8b 7d 10 mov 0x10(%ebp),%edi
Objects_Control *object;
Objects_Id next_id;
if ( !information )
10cfaa: 85 db test %ebx,%ebx
10cfac: 75 0a jne 10cfb8 <_Objects_Get_next+0x20>
if ( !location_p )
return NULL;
if ( !next_id_p )
return NULL;
10cfae: 31 c0 xor %eax,%eax
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
10cfb0: 8d 65 f4 lea -0xc(%ebp),%esp
10cfb3: 5b pop %ebx
10cfb4: 5e pop %esi
10cfb5: 5f pop %edi
10cfb6: c9 leave
10cfb7: c3 ret
Objects_Id next_id;
if ( !information )
return NULL;
if ( !location_p )
10cfb8: 85 ff test %edi,%edi
10cfba: 74 f2 je 10cfae <_Objects_Get_next+0x16>
return NULL;
if ( !next_id_p )
10cfbc: 8b 45 14 mov 0x14(%ebp),%eax
10cfbf: 85 c0 test %eax,%eax
10cfc1: 74 eb je 10cfae <_Objects_Get_next+0x16>
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
10cfc3: 66 85 f6 test %si,%si
10cfc6: 75 04 jne 10cfcc <_Objects_Get_next+0x34>
next_id = information->minimum_id;
10cfc8: 8b 73 08 mov 0x8(%ebx),%esi
10cfcb: 90 nop
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
10cfcc: 66 39 73 10 cmp %si,0x10(%ebx)
10cfd0: 72 22 jb 10cff4 <_Objects_Get_next+0x5c>
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
10cfd2: 51 push %ecx
10cfd3: 57 push %edi
10cfd4: 56 push %esi
10cfd5: 53 push %ebx
10cfd6: e8 2d 00 00 00 call 10d008 <_Objects_Get>
next_id++;
10cfdb: 46 inc %esi
} while (*location_p != OBJECTS_LOCAL);
10cfdc: 83 c4 10 add $0x10,%esp
10cfdf: 8b 17 mov (%edi),%edx
10cfe1: 85 d2 test %edx,%edx
10cfe3: 75 e7 jne 10cfcc <_Objects_Get_next+0x34>
*next_id_p = next_id;
10cfe5: 8b 55 14 mov 0x14(%ebp),%edx
10cfe8: 89 32 mov %esi,(%edx)
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
10cfea: 8d 65 f4 lea -0xc(%ebp),%esp
10cfed: 5b pop %ebx
10cfee: 5e pop %esi
10cfef: 5f pop %edi
10cff0: c9 leave
10cff1: c3 ret
10cff2: 66 90 xchg %ax,%ax
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
{
*location_p = OBJECTS_ERROR;
10cff4: c7 07 01 00 00 00 movl $0x1,(%edi)
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
10cffa: 8b 45 14 mov 0x14(%ebp),%eax
10cffd: c7 00 ff ff ff ff movl $0xffffffff,(%eax)
return 0;
10d003: 31 c0 xor %eax,%eax
10d005: eb a9 jmp 10cfb0 <_Objects_Get_next+0x18>
0011b2a8 <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
11b2a8: 55 push %ebp
11b2a9: 89 e5 mov %esp,%ebp
11b2ab: 53 push %ebx
11b2ac: 8b 55 08 mov 0x8(%ebp),%edx
11b2af: 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;
11b2b2: b8 01 00 00 00 mov $0x1,%eax
11b2b7: 2b 42 08 sub 0x8(%edx),%eax
11b2ba: 03 45 0c add 0xc(%ebp),%eax
if ( information->maximum >= index ) {
11b2bd: 0f b7 4a 10 movzwl 0x10(%edx),%ecx
11b2c1: 39 c8 cmp %ecx,%eax
11b2c3: 77 13 ja 11b2d8 <_Objects_Get_no_protection+0x30>
if ( (the_object = information->local_table[ index ]) != NULL ) {
11b2c5: 8b 52 1c mov 0x1c(%edx),%edx
11b2c8: 8b 04 82 mov (%edx,%eax,4),%eax
11b2cb: 85 c0 test %eax,%eax
11b2cd: 74 09 je 11b2d8 <_Objects_Get_no_protection+0x30><== NEVER TAKEN
*location = OBJECTS_LOCAL;
11b2cf: 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;
}
11b2d5: 5b pop %ebx
11b2d6: c9 leave
11b2d7: 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;
11b2d8: c7 03 01 00 00 00 movl $0x1,(%ebx)
return NULL;
11b2de: 31 c0 xor %eax,%eax
}
11b2e0: 5b pop %ebx
11b2e1: c9 leave
11b2e2: c3 ret
0010e0ec <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
10e0ec: 55 push %ebp
10e0ed: 89 e5 mov %esp,%ebp
10e0ef: 83 ec 18 sub $0x18,%esp
10e0f2: 8b 55 08 mov 0x8(%ebp),%edx
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10e0f5: 85 d2 test %edx,%edx
10e0f7: 75 08 jne 10e101 <_Objects_Id_to_name+0x15>
10e0f9: a1 78 a7 12 00 mov 0x12a778,%eax
10e0fe: 8b 50 08 mov 0x8(%eax),%edx
10e101: 89 d0 mov %edx,%eax
10e103: c1 e8 18 shr $0x18,%eax
10e106: 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 )
10e109: 8d 48 ff lea -0x1(%eax),%ecx
10e10c: 83 f9 02 cmp $0x2,%ecx
10e10f: 77 1d ja 10e12e <_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 ] )
10e111: 8b 04 85 68 a1 12 00 mov 0x12a168(,%eax,4),%eax
10e118: 85 c0 test %eax,%eax
10e11a: 74 12 je 10e12e <_Objects_Id_to_name+0x42>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10e11c: 89 d1 mov %edx,%ecx
10e11e: c1 e9 1b shr $0x1b,%ecx
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
10e121: 8b 04 88 mov (%eax,%ecx,4),%eax
if ( !information )
10e124: 85 c0 test %eax,%eax
10e126: 74 06 je 10e12e <_Objects_Id_to_name+0x42><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
10e128: 80 78 38 00 cmpb $0x0,0x38(%eax)
10e12c: 74 0a je 10e138 <_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;
10e12e: 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;
}
10e133: c9 leave
10e134: c3 ret
10e135: 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 );
10e138: 51 push %ecx
10e139: 8d 4d f4 lea -0xc(%ebp),%ecx
10e13c: 51 push %ecx
10e13d: 52 push %edx
10e13e: 50 push %eax
10e13f: e8 40 ff ff ff call 10e084 <_Objects_Get>
if ( !the_object )
10e144: 83 c4 10 add $0x10,%esp
10e147: 85 c0 test %eax,%eax
10e149: 74 e3 je 10e12e <_Objects_Id_to_name+0x42>
return OBJECTS_INVALID_ID;
*name = the_object->name;
10e14b: 8b 50 0c mov 0xc(%eax),%edx
10e14e: 8b 45 0c mov 0xc(%ebp),%eax
10e151: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10e153: e8 50 0a 00 00 call 10eba8 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10e158: 31 c0 xor %eax,%eax
}
10e15a: c9 leave
10e15b: c3 ret
0010cea8 <_Objects_Initialize_information>:
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
10cea8: 55 push %ebp
10cea9: 89 e5 mov %esp,%ebp
10ceab: 57 push %edi
10ceac: 56 push %esi
10cead: 53 push %ebx
10ceae: 83 ec 0c sub $0xc,%esp
10ceb1: 8b 45 08 mov 0x8(%ebp),%eax
10ceb4: 8b 55 0c mov 0xc(%ebp),%edx
10ceb7: 8b 5d 10 mov 0x10(%ebp),%ebx
10ceba: 8b 75 20 mov 0x20(%ebp),%esi
10cebd: 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;
10cec1: 89 10 mov %edx,(%eax)
information->the_class = the_class;
10cec3: 66 89 58 04 mov %bx,0x4(%eax)
information->size = size;
10cec7: 89 78 18 mov %edi,0x18(%eax)
information->local_table = 0;
10ceca: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
information->inactive_per_block = 0;
10ced1: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
information->object_blocks = 0;
10ced8: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
information->inactive = 0;
10cedf: 66 c7 40 2c 00 00 movw $0x0,0x2c(%eax)
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
information->is_string = is_string;
10cee5: 8b 7d 1c mov 0x1c(%ebp),%edi
10cee8: 89 f9 mov %edi,%ecx
10ceea: 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;
10ceed: 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;
10cef3: 0f b7 db movzwl %bx,%ebx
10cef6: 8b 3c 95 48 75 12 00 mov 0x127548(,%edx,4),%edi
10cefd: 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;
10cf00: 8b 7d 14 mov 0x14(%ebp),%edi
10cf03: 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 =
10cf06: 89 f9 mov %edi,%ecx
10cf08: 88 48 12 mov %cl,0x12(%eax)
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS;
10cf0b: 8b 4d 14 mov 0x14(%ebp),%ecx
10cf0e: 81 e1 ff ff ff 7f and $0x7fffffff,%ecx
/*
* Unlimited and maximum of zero is illogical.
*/
if ( information->auto_extend && maximum_per_allocation == 0) {
10cf14: 85 ff test %edi,%edi
10cf16: 74 04 je 10cf1c <_Objects_Initialize_information+0x74>
10cf18: 85 c9 test %ecx,%ecx
10cf1a: 74 67 je 10cf83 <_Objects_Initialize_information+0xdb><== NEVER TAKEN
}
/*
* The allocation unit is the maximum value
*/
information->allocation_size = maximum_per_allocation;
10cf1c: 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;
10cf20: c7 40 1c e4 71 12 00 movl $0x1271e4,0x1c(%eax)
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10cf27: c1 e2 18 shl $0x18,%edx
10cf2a: 81 ca 00 00 01 00 or $0x10000,%edx
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
10cf30: c1 e3 1b shl $0x1b,%ebx
10cf33: 09 da or %ebx,%edx
/*
* Calculate minimum and maximum Id's
*/
minimum_index = (maximum_per_allocation == 0) ? 0 : 1;
10cf35: 31 db xor %ebx,%ebx
10cf37: 85 c9 test %ecx,%ecx
10cf39: 0f 95 c3 setne %bl
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
10cf3c: 09 da or %ebx,%edx
10cf3e: 89 50 08 mov %edx,0x8(%eax)
/*
* Calculate the maximum name length
*/
name_length = maximum_name_length;
if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
10cf41: f7 c6 03 00 00 00 test $0x3,%esi
10cf47: 75 23 jne 10cf6c <_Objects_Initialize_information+0xc4>
name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
~(OBJECTS_NAME_ALIGNMENT-1);
information->name_length = name_length;
10cf49: 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 );
10cf4d: 8d 50 24 lea 0x24(%eax),%edx
10cf50: 89 50 20 mov %edx,0x20(%eax)
head->next = tail;
head->previous = NULL;
10cf53: 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 );
10cf5a: 8d 50 20 lea 0x20(%eax),%edx
10cf5d: 89 50 28 mov %edx,0x28(%eax)
_Chain_Initialize_empty( &information->Inactive );
/*
* Initialize objects .. if there are any
*/
if ( maximum_per_allocation ) {
10cf60: 85 c9 test %ecx,%ecx
10cf62: 75 10 jne 10cf74 <_Objects_Initialize_information+0xcc>
_Chain_Initialize_empty( &information->global_table[ index ] );
}
else
information->global_table = NULL;
#endif
}
10cf64: 8d 65 f4 lea -0xc(%ebp),%esp
10cf67: 5b pop %ebx
10cf68: 5e pop %esi
10cf69: 5f pop %edi
10cf6a: c9 leave
10cf6b: c3 ret
* Calculate the maximum name length
*/
name_length = maximum_name_length;
if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
10cf6c: 83 c6 04 add $0x4,%esi
10cf6f: 83 e6 fc and $0xfffffffc,%esi
10cf72: eb d5 jmp 10cf49 <_Objects_Initialize_information+0xa1>
/*
* 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 );
10cf74: 89 45 08 mov %eax,0x8(%ebp)
_Chain_Initialize_empty( &information->global_table[ index ] );
}
else
information->global_table = NULL;
#endif
}
10cf77: 8d 65 f4 lea -0xc(%ebp),%esp
10cf7a: 5b pop %ebx
10cf7b: 5e pop %esi
10cf7c: 5f pop %edi
10cf7d: 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 );
10cf7e: e9 a9 fa ff ff jmp 10ca2c <_Objects_Extend_information>
/*
* Unlimited and maximum of zero is illogical.
*/
if ( information->auto_extend && maximum_per_allocation == 0) {
_Internal_error_Occurred(
10cf83: 50 push %eax
10cf84: 6a 13 push $0x13
10cf86: 6a 01 push $0x1
10cf88: 6a 00 push $0x0
10cf8a: e8 69 f9 ff ff call 10c8f8 <_Internal_error_Occurred>
00117964 <_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
)
{
117964: 55 push %ebp
117965: 89 e5 mov %esp,%ebp
117967: 57 push %edi
117968: 56 push %esi
117969: 53 push %ebx
11796a: 83 ec 1c sub $0x1c,%esp
11796d: 8b 7d 08 mov 0x8(%ebp),%edi
Objects_Control *the_object;
uint32_t index;
/* ASSERT: information->is_string == true */
if ( !id )
117970: 8b 5d 10 mov 0x10(%ebp),%ebx
117973: 85 db test %ebx,%ebx
117975: 74 75 je 1179ec <_Objects_Name_to_id_string+0x88>
return OBJECTS_INVALID_ADDRESS;
if ( !name )
117977: 8b 4d 0c mov 0xc(%ebp),%ecx
11797a: 85 c9 test %ecx,%ecx
11797c: 74 4b je 1179c9 <_Objects_Name_to_id_string+0x65>
return OBJECTS_INVALID_NAME;
if ( information->maximum != 0 ) {
11797e: 8b 47 10 mov 0x10(%edi),%eax
117981: 66 85 c0 test %ax,%ax
117984: 74 43 je 1179c9 <_Objects_Name_to_id_string+0x65>
for ( index = 1; index <= information->maximum; index++ ) {
117986: 0f b7 c0 movzwl %ax,%eax
117989: 89 45 e4 mov %eax,-0x1c(%ebp)
11798c: 8b 47 1c mov 0x1c(%edi),%eax
11798f: bb 01 00 00 00 mov $0x1,%ebx
117994: 89 7d e0 mov %edi,-0x20(%ebp)
117997: 89 c7 mov %eax,%edi
117999: 8d 76 00 lea 0x0(%esi),%esi
the_object = information->local_table[ index ];
11799c: 8b 34 9f mov (%edi,%ebx,4),%esi
if ( !the_object )
11799f: 85 f6 test %esi,%esi
1179a1: 74 20 je 1179c3 <_Objects_Name_to_id_string+0x5f>
continue;
if ( !the_object->name.name_p )
1179a3: 8b 46 0c mov 0xc(%esi),%eax
1179a6: 85 c0 test %eax,%eax
1179a8: 74 19 je 1179c3 <_Objects_Name_to_id_string+0x5f>
continue;
if (!strncmp( name, the_object->name.name_p, information->name_length)) {
1179aa: 52 push %edx
1179ab: 8b 4d e0 mov -0x20(%ebp),%ecx
1179ae: 0f b7 51 3a movzwl 0x3a(%ecx),%edx
1179b2: 52 push %edx
1179b3: 50 push %eax
1179b4: ff 75 0c pushl 0xc(%ebp)
1179b7: e8 70 35 00 00 call 11af2c <strncmp>
1179bc: 83 c4 10 add $0x10,%esp
1179bf: 85 c0 test %eax,%eax
1179c1: 74 15 je 1179d8 <_Objects_Name_to_id_string+0x74>
if ( !name )
return OBJECTS_INVALID_NAME;
if ( information->maximum != 0 ) {
for ( index = 1; index <= information->maximum; index++ ) {
1179c3: 43 inc %ebx
1179c4: 3b 5d e4 cmp -0x1c(%ebp),%ebx
1179c7: 76 d3 jbe 11799c <_Objects_Name_to_id_string+0x38>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
}
}
return OBJECTS_INVALID_NAME;
1179c9: b8 01 00 00 00 mov $0x1,%eax
}
1179ce: 8d 65 f4 lea -0xc(%ebp),%esp
1179d1: 5b pop %ebx
1179d2: 5e pop %esi
1179d3: 5f pop %edi
1179d4: c9 leave
1179d5: c3 ret
1179d6: 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;
1179d8: 8b 46 08 mov 0x8(%esi),%eax
1179db: 8b 55 10 mov 0x10(%ebp),%edx
1179de: 89 02 mov %eax,(%edx)
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
1179e0: 31 c0 xor %eax,%eax
}
}
}
return OBJECTS_INVALID_NAME;
}
1179e2: 8d 65 f4 lea -0xc(%ebp),%esp
1179e5: 5b pop %ebx
1179e6: 5e pop %esi
1179e7: 5f pop %edi
1179e8: c9 leave
1179e9: c3 ret
1179ea: 66 90 xchg %ax,%ax
uint32_t index;
/* ASSERT: information->is_string == true */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
1179ec: b8 02 00 00 00 mov $0x2,%eax
}
}
}
return OBJECTS_INVALID_NAME;
}
1179f1: 8d 65 f4 lea -0xc(%ebp),%esp
1179f4: 5b pop %ebx
1179f5: 5e pop %esi
1179f6: 5f pop %edi
1179f7: c9 leave
1179f8: c3 ret
0010cfc4 <_Objects_Name_to_id_u32>:
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
10cfc4: 55 push %ebp
10cfc5: 89 e5 mov %esp,%ebp
10cfc7: 57 push %edi
10cfc8: 56 push %esi
10cfc9: 53 push %ebx
10cfca: 8b 45 08 mov 0x8(%ebp),%eax
10cfcd: 8b 4d 0c mov 0xc(%ebp),%ecx
10cfd0: 8b 55 10 mov 0x10(%ebp),%edx
10cfd3: 8b 7d 14 mov 0x14(%ebp),%edi
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
10cfd6: 85 ff test %edi,%edi
10cfd8: 74 56 je 10d030 <_Objects_Name_to_id_u32+0x6c>
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
10cfda: 85 c9 test %ecx,%ecx
10cfdc: 74 08 je 10cfe6 <_Objects_Name_to_id_u32+0x22>
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
10cfde: 8b 70 10 mov 0x10(%eax),%esi
10cfe1: 66 85 f6 test %si,%si
10cfe4: 75 0a jne 10cff0 <_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;
10cfe6: b8 01 00 00 00 mov $0x1,%eax
#endif
}
10cfeb: 5b pop %ebx
10cfec: 5e pop %esi
10cfed: 5f pop %edi
10cfee: c9 leave
10cfef: c3 ret
if ( name == 0 )
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
10cff0: 85 d2 test %edx,%edx
10cff2: 75 20 jne 10d014 <_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++ ) {
10cff4: 0f b7 f6 movzwl %si,%esi
10cff7: 8b 58 1c mov 0x1c(%eax),%ebx
10cffa: b8 01 00 00 00 mov $0x1,%eax
10cfff: 90 nop
the_object = information->local_table[ index ];
10d000: 8b 14 83 mov (%ebx,%eax,4),%edx
if ( !the_object )
10d003: 85 d2 test %edx,%edx
10d005: 74 05 je 10d00c <_Objects_Name_to_id_u32+0x48>
continue;
if ( name == the_object->name.name_u32 ) {
10d007: 39 4a 0c cmp %ecx,0xc(%edx)
10d00a: 74 18 je 10d024 <_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++ ) {
10d00c: 40 inc %eax
10d00d: 39 c6 cmp %eax,%esi
10d00f: 73 ef jae 10d000 <_Objects_Name_to_id_u32+0x3c>
10d011: eb d3 jmp 10cfe6 <_Objects_Name_to_id_u32+0x22>
10d013: 90 nop
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
(node == OBJECTS_SEARCH_ALL_NODES ||
10d014: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx
10d01a: 74 d8 je 10cff4 <_Objects_Name_to_id_u32+0x30>
node == OBJECTS_SEARCH_LOCAL_NODE ||
10d01c: 4a dec %edx
10d01d: 75 c7 jne 10cfe6 <_Objects_Name_to_id_u32+0x22>
10d01f: eb d3 jmp 10cff4 <_Objects_Name_to_id_u32+0x30>
10d021: 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;
10d024: 8b 42 08 mov 0x8(%edx),%eax
10d027: 89 07 mov %eax,(%edi)
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10d029: 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
}
10d02b: 5b pop %ebx
10d02c: 5e pop %esi
10d02d: 5f pop %edi
10d02e: c9 leave
10d02f: c3 ret
#endif
/* ASSERT: information->is_string == false */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
10d030: 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
}
10d035: 5b pop %ebx
10d036: 5e pop %esi
10d037: 5f pop %edi
10d038: c9 leave
10d039: c3 ret
0010d6ac <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
10d6ac: 55 push %ebp
10d6ad: 89 e5 mov %esp,%ebp
10d6af: 57 push %edi
10d6b0: 56 push %esi
10d6b1: 53 push %ebx
10d6b2: 83 ec 14 sub $0x14,%esp
10d6b5: 8b 7d 08 mov 0x8(%ebp),%edi
10d6b8: 8b 5d 10 mov 0x10(%ebp),%ebx
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
10d6bb: 0f b7 47 3a movzwl 0x3a(%edi),%eax
10d6bf: 50 push %eax
10d6c0: 53 push %ebx
10d6c1: e8 22 7a 00 00 call 1150e8 <strnlen>
10d6c6: 89 c6 mov %eax,%esi
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
10d6c8: 83 c4 10 add $0x10,%esp
10d6cb: 80 7f 38 00 cmpb $0x0,0x38(%edi)
10d6cf: 75 57 jne 10d728 <_Objects_Set_name+0x7c>
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
10d6d1: 0f be 13 movsbl (%ebx),%edx
10d6d4: c1 e2 18 shl $0x18,%edx
10d6d7: 83 f8 01 cmp $0x1,%eax
10d6da: 76 38 jbe 10d714 <_Objects_Set_name+0x68>
10d6dc: 0f be 43 01 movsbl 0x1(%ebx),%eax
10d6e0: c1 e0 10 shl $0x10,%eax
10d6e3: 09 d0 or %edx,%eax
10d6e5: 83 fe 02 cmp $0x2,%esi
10d6e8: 74 31 je 10d71b <_Objects_Set_name+0x6f>
10d6ea: 0f be 53 02 movsbl 0x2(%ebx),%edx
10d6ee: c1 e2 08 shl $0x8,%edx
10d6f1: 09 c2 or %eax,%edx
10d6f3: 83 fe 03 cmp $0x3,%esi
10d6f6: 0f 84 88 00 00 00 je 10d784 <_Objects_Set_name+0xd8>
10d6fc: 0f be 43 03 movsbl 0x3(%ebx),%eax
10d700: 09 c2 or %eax,%edx
10d702: 8b 45 0c mov 0xc(%ebp),%eax
10d705: 89 50 0c mov %edx,0xc(%eax)
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
10d708: b0 01 mov $0x1,%al
}
10d70a: 8d 65 f4 lea -0xc(%ebp),%esp
10d70d: 5b pop %ebx
10d70e: 5e pop %esi
10d70f: 5f pop %edi
10d710: c9 leave
10d711: c3 ret
10d712: 66 90 xchg %ax,%ax
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
10d714: 89 d0 mov %edx,%eax
10d716: 0d 00 00 20 00 or $0x200000,%eax
10d71b: 89 c2 mov %eax,%edx
10d71d: 80 ce 20 or $0x20,%dh
10d720: b8 20 00 00 00 mov $0x20,%eax
10d725: eb d9 jmp 10d700 <_Objects_Set_name+0x54>
10d727: 90 nop
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length + 1 );
10d728: 83 ec 0c sub $0xc,%esp
10d72b: 8d 40 01 lea 0x1(%eax),%eax
10d72e: 50 push %eax
10d72f: e8 80 19 00 00 call 10f0b4 <_Workspace_Allocate>
10d734: 89 c7 mov %eax,%edi
if ( !d )
10d736: 83 c4 10 add $0x10,%esp
10d739: 85 c0 test %eax,%eax
10d73b: 74 43 je 10d780 <_Objects_Set_name+0xd4>
return false;
if ( the_object->name.name_p ) {
10d73d: 8b 55 0c mov 0xc(%ebp),%edx
10d740: 8b 42 0c mov 0xc(%edx),%eax
10d743: 85 c0 test %eax,%eax
10d745: 74 16 je 10d75d <_Objects_Set_name+0xb1>
_Workspace_Free( (void *)the_object->name.name_p );
10d747: 83 ec 0c sub $0xc,%esp
10d74a: 50 push %eax
10d74b: e8 80 19 00 00 call 10f0d0 <_Workspace_Free>
the_object->name.name_p = NULL;
10d750: 8b 45 0c mov 0xc(%ebp),%eax
10d753: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
10d75a: 83 c4 10 add $0x10,%esp
}
strncpy( d, name, length );
10d75d: 50 push %eax
10d75e: 56 push %esi
10d75f: 53 push %ebx
10d760: 57 push %edi
10d761: e8 06 79 00 00 call 11506c <strncpy>
d[length] = '\0';
10d766: c6 04 37 00 movb $0x0,(%edi,%esi,1)
the_object->name.name_p = d;
10d76a: 8b 55 0c mov 0xc(%ebp),%edx
10d76d: 89 7a 0c mov %edi,0xc(%edx)
10d770: 83 c4 10 add $0x10,%esp
((3 < length) ? s[ 3 ] : ' ')
);
}
return true;
10d773: b0 01 mov $0x1,%al
}
10d775: 8d 65 f4 lea -0xc(%ebp),%esp
10d778: 5b pop %ebx
10d779: 5e pop %esi
10d77a: 5f pop %edi
10d77b: c9 leave
10d77c: c3 ret
10d77d: 8d 76 00 lea 0x0(%esi),%esi
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length + 1 );
if ( !d )
return false;
10d780: 31 c0 xor %eax,%eax
10d782: eb 86 jmp 10d70a <_Objects_Set_name+0x5e>
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
10d784: b8 20 00 00 00 mov $0x20,%eax
10d789: e9 72 ff ff ff jmp 10d700 <_Objects_Set_name+0x54>
0010d03c <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
10d03c: 55 push %ebp
10d03d: 89 e5 mov %esp,%ebp
10d03f: 57 push %edi
10d040: 56 push %esi
10d041: 53 push %ebx
10d042: 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 );
10d045: 8b 45 08 mov 0x8(%ebp),%eax
10d048: 0f b7 58 08 movzwl 0x8(%eax),%ebx
block_count = (information->maximum - index_base) /
10d04c: 0f b7 48 14 movzwl 0x14(%eax),%ecx
10d050: 0f b7 40 10 movzwl 0x10(%eax),%eax
10d054: 29 d8 sub %ebx,%eax
10d056: 31 d2 xor %edx,%edx
10d058: f7 f1 div %ecx
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
10d05a: 85 c0 test %eax,%eax
10d05c: 74 21 je 10d07f <_Objects_Shrink_information+0x43><== NEVER TAKEN
if ( information->inactive_per_block[ block ] ==
10d05e: 8b 55 08 mov 0x8(%ebp),%edx
10d061: 8b 7a 30 mov 0x30(%edx),%edi
10d064: 3b 0f cmp (%edi),%ecx
10d066: 74 1f je 10d087 <_Objects_Shrink_information+0x4b><== NEVER TAKEN
10d068: 31 d2 xor %edx,%edx
10d06a: eb 0e jmp 10d07a <_Objects_Shrink_information+0x3e>
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
10d06c: 01 cb add %ecx,%ebx
10d06e: 8d 34 95 00 00 00 00 lea 0x0(,%edx,4),%esi
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 ] ==
10d075: 3b 0c 97 cmp (%edi,%edx,4),%ecx
10d078: 74 12 je 10d08c <_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++ ) {
10d07a: 42 inc %edx
10d07b: 39 d0 cmp %edx,%eax
10d07d: 77 ed ja 10d06c <_Objects_Shrink_information+0x30>
return;
}
index_base += information->allocation_size;
}
}
10d07f: 8d 65 f4 lea -0xc(%ebp),%esp
10d082: 5b pop %ebx
10d083: 5e pop %esi
10d084: 5f pop %edi
10d085: c9 leave
10d086: 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 ] ==
10d087: 31 f6 xor %esi,%esi
10d089: 8d 76 00 lea 0x0(%esi),%esi
information->allocation_size ) {
/*
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
10d08c: 8b 55 08 mov 0x8(%ebp),%edx
10d08f: 8b 42 20 mov 0x20(%edx),%eax
10d092: 89 75 e4 mov %esi,-0x1c(%ebp)
10d095: eb 07 jmp 10d09e <_Objects_Shrink_information+0x62>
10d097: 90 nop
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
10d098: 85 ff test %edi,%edi
10d09a: 74 2c je 10d0c8 <_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;
10d09c: 89 f8 mov %edi,%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 );
10d09e: 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;
10d0a2: 8b 38 mov (%eax),%edi
if ((index >= index_base) &&
10d0a4: 39 da cmp %ebx,%edx
10d0a6: 72 f0 jb 10d098 <_Objects_Shrink_information+0x5c>
(index < (index_base + information->allocation_size))) {
10d0a8: 8b 75 08 mov 0x8(%ebp),%esi
10d0ab: 0f b7 4e 14 movzwl 0x14(%esi),%ecx
10d0af: 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) &&
10d0b2: 39 ca cmp %ecx,%edx
10d0b4: 73 e2 jae 10d098 <_Objects_Shrink_information+0x5c>
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
10d0b6: 83 ec 0c sub $0xc,%esp
10d0b9: 50 push %eax
10d0ba: e8 41 ef ff ff call 10c000 <_Chain_Extract>
10d0bf: 83 c4 10 add $0x10,%esp
}
}
while ( the_object );
10d0c2: 85 ff test %edi,%edi
10d0c4: 75 d6 jne 10d09c <_Objects_Shrink_information+0x60>
10d0c6: 66 90 xchg %ax,%ax
10d0c8: 8b 75 e4 mov -0x1c(%ebp),%esi
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
10d0cb: 83 ec 0c sub $0xc,%esp
10d0ce: 8b 55 08 mov 0x8(%ebp),%edx
10d0d1: 8b 42 34 mov 0x34(%edx),%eax
10d0d4: ff 34 30 pushl (%eax,%esi,1)
10d0d7: e8 a0 18 00 00 call 10e97c <_Workspace_Free>
information->object_blocks[ block ] = NULL;
10d0dc: 8b 55 08 mov 0x8(%ebp),%edx
10d0df: 8b 42 34 mov 0x34(%edx),%eax
10d0e2: c7 04 30 00 00 00 00 movl $0x0,(%eax,%esi,1)
information->inactive_per_block[ block ] = 0;
10d0e9: 8b 42 30 mov 0x30(%edx),%eax
10d0ec: c7 04 30 00 00 00 00 movl $0x0,(%eax,%esi,1)
information->inactive -= information->allocation_size;
10d0f3: 8b 42 14 mov 0x14(%edx),%eax
10d0f6: 66 29 42 2c sub %ax,0x2c(%edx)
return;
10d0fa: 83 c4 10 add $0x10,%esp
}
index_base += information->allocation_size;
}
}
10d0fd: 8d 65 f4 lea -0xc(%ebp),%esp
10d100: 5b pop %ebx
10d101: 5e pop %esi
10d102: 5f pop %edi
10d103: c9 leave
10d104: 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 99 3d 00 00 call 1112d8 <_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 88 1d 00 00 call 10f2e4 <_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 9b 3d 00 00 call 111300 <_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 99 3d 00 00 call 111324 <_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 ce 3d 00 00 call 111364 <_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 c0 a1 12 00 push $0x12a1c0
10c0ea: e8 7d 2b 00 00 call 10ec6c <_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 9f 38 00 00 call 10fad4 <_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 d3 34 00 00 call 10f720 <_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 d0 9c 12 00 mov 0x129cd0,%eax
10c2db: 48 dec %eax
10c2dc: a3 d0 9c 12 00 mov %eax,0x129cd0
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 08 34 00 00 call 10f720 <_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 b8 a2 12 00 mov 0x12a2b8,%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 78 ff 10 00 push $0x10ff78
10c363: ff 75 10 pushl 0x10(%ebp)
10c366: 56 push %esi
10c367: e8 90 38 00 00 call 10fbfc <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10c36c: e8 af 33 00 00 call 10f720 <_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 b8 a2 12 00 mov 0x12a2b8,%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 93 33 00 00 call 10f720 <_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
00116378 <_POSIX_Message_queue_Create_support>:
const char *name_arg,
int pshared,
struct mq_attr *attr_ptr,
POSIX_Message_queue_Control **message_queue
)
{
116378: 55 push %ebp
116379: 89 e5 mov %esp,%ebp
11637b: 57 push %edi
11637c: 56 push %esi
11637d: 53 push %ebx
11637e: 83 ec 24 sub $0x24,%esp
116381: 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 );
116384: 68 ff 00 00 00 push $0xff
116389: ff 75 08 pushl 0x8(%ebp)
11638c: e8 a7 4c 00 00 call 11b038 <strnlen>
116391: 89 c6 mov %eax,%esi
116393: a1 b0 fa 12 00 mov 0x12fab0,%eax
116398: 40 inc %eax
116399: a3 b0 fa 12 00 mov %eax,0x12fab0
* 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 ) {
11639e: 83 c4 10 add $0x10,%esp
1163a1: 85 db test %ebx,%ebx
1163a3: 0f 84 b7 00 00 00 je 116460 <_POSIX_Message_queue_Create_support+0xe8>
attr.mq_maxmsg = 10;
attr.mq_msgsize = 16;
} else {
if ( attr_ptr->mq_maxmsg <= 0 ){
1163a9: 8b 7b 04 mov 0x4(%ebx),%edi
1163ac: 85 ff test %edi,%edi
1163ae: 0f 8e f0 00 00 00 jle 1164a4 <_POSIX_Message_queue_Create_support+0x12c>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( attr_ptr->mq_msgsize <= 0 ){
1163b4: 8b 5b 08 mov 0x8(%ebx),%ebx
1163b7: 89 5d e4 mov %ebx,-0x1c(%ebp)
1163ba: 85 db test %ebx,%ebx
1163bc: 0f 8e e2 00 00 00 jle 1164a4 <_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 );
1163c2: 83 ec 0c sub $0xc,%esp
1163c5: 68 80 fe 12 00 push $0x12fe80
1163ca: e8 d9 c3 ff ff call 1127a8 <_Objects_Allocate>
1163cf: 89 c3 mov %eax,%ebx
attr = *attr_ptr;
}
the_mq = _POSIX_Message_queue_Allocate();
if ( !the_mq ) {
1163d1: 83 c4 10 add $0x10,%esp
1163d4: 85 c0 test %eax,%eax
1163d6: 0f 84 0a 01 00 00 je 1164e6 <_POSIX_Message_queue_Create_support+0x16e>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENFILE );
}
the_mq->process_shared = pshared;
1163dc: 8b 45 0c mov 0xc(%ebp),%eax
1163df: 89 43 10 mov %eax,0x10(%ebx)
the_mq->named = true;
1163e2: c6 43 14 01 movb $0x1,0x14(%ebx)
the_mq->open_count = 1;
1163e6: c7 43 18 01 00 00 00 movl $0x1,0x18(%ebx)
the_mq->linked = true;
1163ed: 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);
1163f1: 8d 56 01 lea 0x1(%esi),%edx
1163f4: 83 ec 0c sub $0xc,%esp
1163f7: 52 push %edx
1163f8: 89 55 e0 mov %edx,-0x20(%ebp)
1163fb: e8 dc e4 ff ff call 1148dc <_Workspace_Allocate>
116400: 89 c6 mov %eax,%esi
if (!name) {
116402: 83 c4 10 add $0x10,%esp
116405: 85 c0 test %eax,%eax
116407: 8b 55 e0 mov -0x20(%ebp),%edx
11640a: 0f 84 ab 00 00 00 je 1164bb <_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 );
116410: 50 push %eax
116411: 52 push %edx
116412: ff 75 08 pushl 0x8(%ebp)
116415: 56 push %esi
116416: e8 a1 4b 00 00 call 11afbc <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;
11641b: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
if ( !_CORE_message_queue_Initialize(
116422: ff 75 e4 pushl -0x1c(%ebp)
116425: 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;
116426: 8d 43 5c lea 0x5c(%ebx),%eax
the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
if ( !_CORE_message_queue_Initialize(
116429: 50 push %eax
11642a: 8d 43 1c lea 0x1c(%ebx),%eax
11642d: 50 push %eax
11642e: e8 25 0f 00 00 call 117358 <_CORE_message_queue_Initialize>
116433: 83 c4 20 add $0x20,%esp
116436: 84 c0 test %al,%al
116438: 74 3a je 116474 <_POSIX_Message_queue_Create_support+0xfc>
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
11643a: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
11643e: a1 9c fe 12 00 mov 0x12fe9c,%eax
116443: 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;
116446: 89 73 0c mov %esi,0xc(%ebx)
&_POSIX_Message_queue_Information,
&the_mq->Object,
name
);
*message_queue = the_mq;
116449: 8b 45 14 mov 0x14(%ebp),%eax
11644c: 89 18 mov %ebx,(%eax)
_Thread_Enable_dispatch();
11644e: e8 41 d3 ff ff call 113794 <_Thread_Enable_dispatch>
return 0;
116453: 31 c0 xor %eax,%eax
}
116455: 8d 65 f4 lea -0xc(%ebp),%esp
116458: 5b pop %ebx
116459: 5e pop %esi
11645a: 5f pop %edi
11645b: c9 leave
11645c: c3 ret
11645d: 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;
116460: 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;
116467: bf 0a 00 00 00 mov $0xa,%edi
11646c: e9 51 ff ff ff jmp 1163c2 <_POSIX_Message_queue_Create_support+0x4a>
116471: 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 );
116474: 83 ec 08 sub $0x8,%esp
116477: 53 push %ebx
116478: 68 80 fe 12 00 push $0x12fe80
11647d: e8 9e c6 ff ff call 112b20 <_Objects_Free>
attr.mq_maxmsg,
attr.mq_msgsize
) ) {
_POSIX_Message_queue_Free( the_mq );
_Workspace_Free(name);
116482: 89 34 24 mov %esi,(%esp)
116485: e8 6e e4 ff ff call 1148f8 <_Workspace_Free>
_Thread_Enable_dispatch();
11648a: e8 05 d3 ff ff call 113794 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSPC );
11648f: e8 24 34 00 00 call 1198b8 <__errno>
116494: c7 00 1c 00 00 00 movl $0x1c,(%eax)
11649a: 83 c4 10 add $0x10,%esp
11649d: b8 ff ff ff ff mov $0xffffffff,%eax
1164a2: eb b1 jmp 116455 <_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();
1164a4: e8 eb d2 ff ff call 113794 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EINVAL );
1164a9: e8 0a 34 00 00 call 1198b8 <__errno>
1164ae: c7 00 16 00 00 00 movl $0x16,(%eax)
1164b4: b8 ff ff ff ff mov $0xffffffff,%eax
1164b9: eb 9a jmp 116455 <_POSIX_Message_queue_Create_support+0xdd>
1164bb: 83 ec 08 sub $0x8,%esp
1164be: 53 push %ebx
1164bf: 68 80 fe 12 00 push $0x12fe80
1164c4: e8 57 c6 ff ff call 112b20 <_Objects_Free>
* dynamically constructed.
*/
name = _Workspace_Allocate(n+1);
if (!name) {
_POSIX_Message_queue_Free( the_mq );
_Thread_Enable_dispatch();
1164c9: e8 c6 d2 ff ff call 113794 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOMEM );
1164ce: e8 e5 33 00 00 call 1198b8 <__errno>
1164d3: c7 00 0c 00 00 00 movl $0xc,(%eax)
1164d9: 83 c4 10 add $0x10,%esp
1164dc: b8 ff ff ff ff mov $0xffffffff,%eax
1164e1: e9 6f ff ff ff jmp 116455 <_POSIX_Message_queue_Create_support+0xdd>
attr = *attr_ptr;
}
the_mq = _POSIX_Message_queue_Allocate();
if ( !the_mq ) {
_Thread_Enable_dispatch();
1164e6: e8 a9 d2 ff ff call 113794 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENFILE );
1164eb: e8 c8 33 00 00 call 1198b8 <__errno>
1164f0: c7 00 17 00 00 00 movl $0x17,(%eax)
1164f6: b8 ff ff ff ff mov $0xffffffff,%eax
1164fb: e9 55 ff ff ff jmp 116455 <_POSIX_Message_queue_Create_support+0xdd>
00116500 <_POSIX_Message_queue_Name_to_id>:
*/
int _POSIX_Message_queue_Name_to_id(
const char *name,
Objects_Id *id
)
{
116500: 55 push %ebp
116501: 89 e5 mov %esp,%ebp
116503: 53 push %ebx
116504: 83 ec 14 sub $0x14,%esp
116507: 8b 5d 08 mov 0x8(%ebp),%ebx
Objects_Name_or_id_lookup_errors status;
Objects_Id the_id;
if ( !name )
11650a: 85 db test %ebx,%ebx
11650c: 74 05 je 116513 <_POSIX_Message_queue_Name_to_id+0x13>
return EINVAL;
if ( !name[0] )
11650e: 80 3b 00 cmpb $0x0,(%ebx)
116511: 75 0d jne 116520 <_POSIX_Message_queue_Name_to_id+0x20>
return EINVAL;
116513: b8 16 00 00 00 mov $0x16,%eax
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
return ENOENT;
}
116518: 8b 5d fc mov -0x4(%ebp),%ebx
11651b: c9 leave
11651c: c3 ret
11651d: 8d 76 00 lea 0x0(%esi),%esi
return EINVAL;
if ( !name[0] )
return EINVAL;
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
116520: 83 ec 08 sub $0x8,%esp
116523: 68 ff 00 00 00 push $0xff
116528: 53 push %ebx
116529: e8 0a 4b 00 00 call 11b038 <strnlen>
11652e: 83 c4 10 add $0x10,%esp
116531: 3d fe 00 00 00 cmp $0xfe,%eax
116536: 76 0c jbe 116544 <_POSIX_Message_queue_Name_to_id+0x44>
return ENAMETOOLONG;
116538: b8 5b 00 00 00 mov $0x5b,%eax
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
return ENOENT;
}
11653d: 8b 5d fc mov -0x4(%ebp),%ebx
116540: c9 leave
116541: c3 ret
116542: 66 90 xchg %ax,%ax
return EINVAL;
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
return ENAMETOOLONG;
status = _Objects_Name_to_id_string(
116544: 50 push %eax
116545: 8d 45 f4 lea -0xc(%ebp),%eax
116548: 50 push %eax
116549: 53 push %ebx
11654a: 68 80 fe 12 00 push $0x12fe80
11654f: e8 10 14 00 00 call 117964 <_Objects_Name_to_id_string>
&_POSIX_Message_queue_Information,
name,
&the_id
);
*id = the_id;
116554: 8b 4d f4 mov -0xc(%ebp),%ecx
116557: 8b 55 0c mov 0xc(%ebp),%edx
11655a: 89 0a mov %ecx,(%edx)
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
11655c: 83 c4 10 add $0x10,%esp
return 0;
11655f: 83 f8 01 cmp $0x1,%eax
116562: 19 c0 sbb %eax,%eax
116564: f7 d0 not %eax
116566: 83 e0 02 and $0x2,%eax
return ENOENT;
}
116569: 8b 5d fc mov -0x4(%ebp),%ebx
11656c: c9 leave
11656d: 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 00 13 00 push $0x130020
10fd02: e8 59 2f 00 00 call 112c60 <_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 a2 9b 00 00 call 1198b8 <__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 a3 1f 00 00 call 111d0c <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
10fd69: 83 c4 20 add $0x20,%esp
10fd6c: e8 23 3a 00 00 call 113794 <_Thread_Enable_dispatch>
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
10fd71: 8b 15 98 00 13 00 mov 0x130098,%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 eb 39 00 00 call 113794 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
10fda9: e8 0a 9b 00 00 call 1198b8 <__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 f3 9a 00 00 call 1198b8 <__errno>
10fdc5: 89 c3 mov %eax,%ebx
10fdc7: 83 ec 0c sub $0xc,%esp
10fdca: a1 98 00 13 00 mov 0x130098,%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 a9 39 00 00 call 113794 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EBADF );
10fdeb: e8 c8 9a 00 00 call 1198b8 <__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 00 13 00 push $0x130020
10fe45: 88 55 e4 mov %dl,-0x1c(%ebp)
10fe48: e8 13 2e 00 00 call 112c60 <_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 b4 1f 00 00 call 111e38 <_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 06 39 00 00 call 113794 <_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 00 13 00 mov 0x130098,%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 fb 99 00 00 call 1198b8 <__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 e7 99 00 00 call 1198b8 <__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 af 38 00 00 call 113794 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EBADF );
10fee5: e8 ce 99 00 00 call 1198b8 <__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 bb 99 00 00 call 1198b8 <__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 a0 b9 12 00 push $0x12b9a0
10d112: e8 e9 2b 00 00 call 10fd00 <_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 a0 b9 12 00 push $0x12b9a0
10d168: e8 3b 2b 00 00 call 10fca8 <_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 47 1d 00 00 call 10f0cc <_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 78 bb 12 00 mov 0x12bb78,%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
00114958 <_POSIX_Semaphore_Create_support>:
const char *name,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
114958: 55 push %ebp
114959: 89 e5 mov %esp,%ebp
11495b: 56 push %esi
11495c: 53 push %ebx
11495d: 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)
114960: 8b 55 0c mov 0xc(%ebp),%edx
114963: 85 d2 test %edx,%edx
114965: 0f 85 b9 00 00 00 jne 114a24 <_POSIX_Semaphore_Create_support+0xcc>
rtems_set_errno_and_return_minus_one( ENOSYS );
if ( name ) {
11496b: 85 db test %ebx,%ebx
11496d: 74 1c je 11498b <_POSIX_Semaphore_Create_support+0x33>
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
11496f: 83 ec 08 sub $0x8,%esp
114972: 68 ff 00 00 00 push $0xff
114977: 53 push %ebx
114978: e8 0b 3e 00 00 call 118788 <strnlen>
11497d: 83 c4 10 add $0x10,%esp
114980: 3d fe 00 00 00 cmp $0xfe,%eax
114985: 0f 87 ad 00 00 00 ja 114a38 <_POSIX_Semaphore_Create_support+0xe0>
11498b: a1 f0 d2 12 00 mov 0x12d2f0,%eax
114990: 40 inc %eax
114991: a3 f0 d2 12 00 mov %eax,0x12d2f0
*/
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{
return (POSIX_Semaphore_Control *)
_Objects_Allocate( &_POSIX_Semaphore_Information );
114996: 83 ec 0c sub $0xc,%esp
114999: 68 40 d6 12 00 push $0x12d640
11499e: e8 89 b9 ff ff call 11032c <_Objects_Allocate>
1149a3: 89 c6 mov %eax,%esi
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
1149a5: 83 c4 10 add $0x10,%esp
1149a8: 85 c0 test %eax,%eax
1149aa: 0f 84 9a 00 00 00 je 114a4a <_POSIX_Semaphore_Create_support+0xf2>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( ENOSPC );
}
the_semaphore->process_shared = pshared;
1149b0: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
if ( name ) {
1149b7: 85 db test %ebx,%ebx
1149b9: 74 55 je 114a10 <_POSIX_Semaphore_Create_support+0xb8>
the_semaphore->named = true;
1149bb: c6 40 14 01 movb $0x1,0x14(%eax)
the_semaphore->open_count = 1;
1149bf: c7 40 18 01 00 00 00 movl $0x1,0x18(%eax)
the_semaphore->linked = true;
1149c6: 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;
1149ca: c7 46 60 00 00 00 00 movl $0x0,0x60(%esi)
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
1149d1: c7 46 5c ff ff ff ff movl $0xffffffff,0x5c(%esi)
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
1149d8: 50 push %eax
1149d9: 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;
1149dc: 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 );
1149df: 50 push %eax
1149e0: 8d 46 1c lea 0x1c(%esi),%eax
1149e3: 50 push %eax
1149e4: e8 cb b3 ff ff call 10fdb4 <_CORE_semaphore_Initialize>
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
1149e9: 0f b7 56 08 movzwl 0x8(%esi),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
1149ed: a1 5c d6 12 00 mov 0x12d65c,%eax
1149f2: 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;
1149f5: 89 5e 0c mov %ebx,0xc(%esi)
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name_p
);
*the_sem = the_semaphore;
1149f8: 8b 45 14 mov 0x14(%ebp),%eax
1149fb: 89 30 mov %esi,(%eax)
_Thread_Enable_dispatch();
1149fd: e8 16 c9 ff ff call 111318 <_Thread_Enable_dispatch>
return 0;
114a02: 83 c4 10 add $0x10,%esp
114a05: 31 c0 xor %eax,%eax
}
114a07: 8d 65 f8 lea -0x8(%ebp),%esp
114a0a: 5b pop %ebx
114a0b: 5e pop %esi
114a0c: c9 leave
114a0d: c3 ret
114a0e: 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;
114a10: c6 40 14 00 movb $0x0,0x14(%eax)
the_semaphore->open_count = 0;
114a14: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_semaphore->linked = false;
114a1b: c6 40 15 00 movb $0x0,0x15(%eax)
114a1f: eb a9 jmp 1149ca <_POSIX_Semaphore_Create_support+0x72>
114a21: 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 );
114a24: e8 33 2c 00 00 call 11765c <__errno>
114a29: c7 00 58 00 00 00 movl $0x58,(%eax)
114a2f: b8 ff ff ff ff mov $0xffffffff,%eax
114a34: eb d1 jmp 114a07 <_POSIX_Semaphore_Create_support+0xaf>
114a36: 66 90 xchg %ax,%ax
if ( name ) {
if ( strnlen( name, NAME_MAX ) >= NAME_MAX )
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
114a38: e8 1f 2c 00 00 call 11765c <__errno>
114a3d: c7 00 5b 00 00 00 movl $0x5b,(%eax)
114a43: b8 ff ff ff ff mov $0xffffffff,%eax
114a48: eb bd jmp 114a07 <_POSIX_Semaphore_Create_support+0xaf>
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
114a4a: e8 c9 c8 ff ff call 111318 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSPC );
114a4f: e8 08 2c 00 00 call 11765c <__errno>
114a54: c7 00 1c 00 00 00 movl $0x1c,(%eax)
114a5a: b8 ff ff ff ff mov $0xffffffff,%eax
114a5f: eb a6 jmp 114a07 <_POSIX_Semaphore_Create_support+0xaf>
00114ab4 <_POSIX_Semaphore_Name_to_id>:
int _POSIX_Semaphore_Name_to_id(
const char *name,
sem_t *id
)
{
114ab4: 55 push %ebp
114ab5: 89 e5 mov %esp,%ebp
114ab7: 83 ec 18 sub $0x18,%esp
114aba: 8b 45 08 mov 0x8(%ebp),%eax
Objects_Name_or_id_lookup_errors status;
Objects_Id the_id;
if ( !name )
114abd: 85 c0 test %eax,%eax
114abf: 74 05 je 114ac6 <_POSIX_Semaphore_Name_to_id+0x12>
return EINVAL;
if ( !name[0] )
114ac1: 80 38 00 cmpb $0x0,(%eax)
114ac4: 75 0a jne 114ad0 <_POSIX_Semaphore_Name_to_id+0x1c>
return EINVAL;
114ac6: b8 16 00 00 00 mov $0x16,%eax
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
return 0;
return ENOENT;
}
114acb: c9 leave
114acc: c3 ret
114acd: 8d 76 00 lea 0x0(%esi),%esi
return EINVAL;
if ( !name[0] )
return EINVAL;
status = _Objects_Name_to_id_string(
114ad0: 52 push %edx
114ad1: 8d 55 f4 lea -0xc(%ebp),%edx
114ad4: 52 push %edx
114ad5: 50 push %eax
114ad6: 68 40 d6 12 00 push $0x12d640
114adb: e8 7c 0c 00 00 call 11575c <_Objects_Name_to_id_string>
&_POSIX_Semaphore_Information,
name,
&the_id
);
*id = the_id;
114ae0: 8b 4d f4 mov -0xc(%ebp),%ecx
114ae3: 8b 55 0c mov 0xc(%ebp),%edx
114ae6: 89 0a mov %ecx,(%edx)
if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL )
114ae8: 83 c4 10 add $0x10,%esp
return 0;
114aeb: 83 f8 01 cmp $0x1,%eax
114aee: 19 c0 sbb %eax,%eax
114af0: f7 d0 not %eax
114af2: 83 e0 02 and $0x2,%eax
return ENOENT;
}
114af5: c9 leave
114af6: c3 ret
00114b20 <_POSIX_Semaphore_Wait_support>:
int _POSIX_Semaphore_Wait_support(
sem_t *sem,
bool blocking,
Watchdog_Interval timeout
)
{
114b20: 55 push %ebp
114b21: 89 e5 mov %esp,%ebp
114b23: 53 push %ebx
114b24: 83 ec 18 sub $0x18,%esp
114b27: 8a 5d 0c mov 0xc(%ebp),%bl
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
114b2a: 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 );
114b2d: 50 push %eax
114b2e: 8b 45 08 mov 0x8(%ebp),%eax
114b31: ff 30 pushl (%eax)
114b33: 68 40 d6 12 00 push $0x12d640
114b38: e8 a7 bc ff ff call 1107e4 <_Objects_Get>
switch ( location ) {
114b3d: 83 c4 10 add $0x10,%esp
114b40: 8b 55 f4 mov -0xc(%ebp),%edx
114b43: 85 d2 test %edx,%edx
114b45: 74 15 je 114b5c <_POSIX_Semaphore_Wait_support+0x3c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
114b47: e8 10 2b 00 00 call 11765c <__errno>
114b4c: c7 00 16 00 00 00 movl $0x16,(%eax)
114b52: b8 ff ff ff ff mov $0xffffffff,%eax
}
114b57: 8b 5d fc mov -0x4(%ebp),%ebx
114b5a: c9 leave
114b5b: c3 ret
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_semaphore_Seize(
114b5c: ff 75 10 pushl 0x10(%ebp)
114b5f: 0f b6 db movzbl %bl,%ebx
114b62: 53 push %ebx
114b63: ff 70 08 pushl 0x8(%eax)
114b66: 83 c0 1c add $0x1c,%eax
114b69: 50 push %eax
114b6a: e8 29 07 00 00 call 115298 <_CORE_semaphore_Seize>
&the_semaphore->Semaphore,
the_semaphore->Object.id,
blocking,
timeout
);
_Thread_Enable_dispatch();
114b6f: e8 a4 c7 ff ff call 111318 <_Thread_Enable_dispatch>
if ( !_Thread_Executing->Wait.return_code )
114b74: 83 c4 10 add $0x10,%esp
114b77: a1 d8 d8 12 00 mov 0x12d8d8,%eax
114b7c: 8b 40 34 mov 0x34(%eax),%eax
114b7f: 85 c0 test %eax,%eax
114b81: 75 09 jne 114b8c <_POSIX_Semaphore_Wait_support+0x6c>
return 0;
114b83: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
114b85: 8b 5d fc mov -0x4(%ebp),%ebx
114b88: c9 leave
114b89: c3 ret
114b8a: 66 90 xchg %ax,%ax
_Thread_Enable_dispatch();
if ( !_Thread_Executing->Wait.return_code )
return 0;
rtems_set_errno_and_return_minus_one(
114b8c: e8 cb 2a 00 00 call 11765c <__errno>
114b91: 89 c3 mov %eax,%ebx
114b93: 83 ec 0c sub $0xc,%esp
114b96: a1 d8 d8 12 00 mov 0x12d8d8,%eax
114b9b: ff 70 34 pushl 0x34(%eax)
114b9e: e8 29 26 00 00 call 1171cc <_POSIX_Semaphore_Translate_core_semaphore_return_code>
114ba3: 89 03 mov %eax,(%ebx)
114ba5: 83 c4 10 add $0x10,%esp
114ba8: b8 ff ff ff ff mov $0xffffffff,%eax
114bad: eb a8 jmp 114b57 <_POSIX_Semaphore_Wait_support+0x37>
001106dc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
#include <rtems/posix/pthread.h>
void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(
Thread_Control *the_thread
)
{
1106dc: 55 push %ebp
1106dd: 89 e5 mov %esp,%ebp
1106df: 83 ec 08 sub $0x8,%esp
1106e2: 8b 55 08 mov 0x8(%ebp),%edx
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
1106e5: 8b 82 ec 00 00 00 mov 0xec(%edx),%eax
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
1106eb: 8b 88 d8 00 00 00 mov 0xd8(%eax),%ecx
1106f1: 85 c9 test %ecx,%ecx
1106f3: 75 09 jne 1106fe <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x22><== NEVER TAKEN
1106f5: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax)
1106fc: 74 06 je 110704 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x28>
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
} else
_Thread_Enable_dispatch();
}
1106fe: 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();
1106ff: e9 38 d6 ff ff jmp 10dd3c <_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 &&
110704: 8b 80 e0 00 00 00 mov 0xe0(%eax),%eax
11070a: 85 c0 test %eax,%eax
11070c: 74 f0 je 1106fe <_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;
11070e: a1 70 88 12 00 mov 0x128870,%eax
110713: 48 dec %eax
110714: a3 70 88 12 00 mov %eax,0x128870
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
110719: 83 ec 08 sub $0x8,%esp
11071c: 6a ff push $0xffffffff
11071e: 52 push %edx
11071f: e8 c0 08 00 00 call 110fe4 <_POSIX_Thread_Exit>
110724: 83 c4 10 add $0x10,%esp
} else
_Thread_Enable_dispatch();
}
110727: c9 leave
110728: c3 ret
00111a4c <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
111a4c: 55 push %ebp
111a4d: 89 e5 mov %esp,%ebp
111a4f: 57 push %edi
111a50: 56 push %esi
111a51: 53 push %ebx
111a52: 83 ec 18 sub $0x18,%esp
111a55: 8b 5d 08 mov 0x8(%ebp),%ebx
111a58: 8b 75 0c mov 0xc(%ebp),%esi
111a5b: 8b 7d 10 mov 0x10(%ebp),%edi
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
111a5e: ff 36 pushl (%esi)
111a60: e8 cb ff ff ff call 111a30 <_POSIX_Priority_Is_valid>
111a65: 83 c4 10 add $0x10,%esp
111a68: 84 c0 test %al,%al
111a6a: 74 2a je 111a96 <_POSIX_Thread_Translate_sched_param+0x4a><== NEVER TAKEN
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
111a6c: c7 07 00 00 00 00 movl $0x0,(%edi)
*budget_callout = NULL;
111a72: 8b 45 14 mov 0x14(%ebp),%eax
111a75: c7 00 00 00 00 00 movl $0x0,(%eax)
if ( policy == SCHED_OTHER ) {
111a7b: 85 db test %ebx,%ebx
111a7d: 74 25 je 111aa4 <_POSIX_Thread_Translate_sched_param+0x58>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
111a7f: 83 fb 01 cmp $0x1,%ebx
111a82: 0f 84 90 00 00 00 je 111b18 <_POSIX_Thread_Translate_sched_param+0xcc>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
111a88: 83 fb 02 cmp $0x2,%ebx
111a8b: 0f 84 8f 00 00 00 je 111b20 <_POSIX_Thread_Translate_sched_param+0xd4>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
111a91: 83 fb 04 cmp $0x4,%ebx
111a94: 74 1e je 111ab4 <_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;
111a96: b8 16 00 00 00 mov $0x16,%eax
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
111a9b: 8d 65 f4 lea -0xc(%ebp),%esp
111a9e: 5b pop %ebx
111a9f: 5e pop %esi
111aa0: 5f pop %edi
111aa1: c9 leave
111aa2: c3 ret
111aa3: 90 nop
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
111aa4: c7 07 01 00 00 00 movl $0x1,(%edi)
return 0;
111aaa: 31 c0 xor %eax,%eax
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
}
111aac: 8d 65 f4 lea -0xc(%ebp),%esp
111aaf: 5b pop %ebx
111ab0: 5e pop %esi
111ab1: 5f pop %edi
111ab2: c9 leave
111ab3: 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) &&
111ab4: 8b 5e 08 mov 0x8(%esi),%ebx
111ab7: 85 db test %ebx,%ebx
111ab9: 75 07 jne 111ac2 <_POSIX_Thread_Translate_sched_param+0x76>
111abb: 8b 4e 0c mov 0xc(%esi),%ecx
111abe: 85 c9 test %ecx,%ecx
111ac0: 74 d4 je 111a96 <_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) &&
111ac2: 8b 56 10 mov 0x10(%esi),%edx
111ac5: 85 d2 test %edx,%edx
111ac7: 75 07 jne 111ad0 <_POSIX_Thread_Translate_sched_param+0x84>
111ac9: 8b 46 14 mov 0x14(%esi),%eax
111acc: 85 c0 test %eax,%eax
111ace: 74 c6 je 111a96 <_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 ) <
111ad0: 83 ec 0c sub $0xc,%esp
111ad3: 8d 46 08 lea 0x8(%esi),%eax
111ad6: 50 push %eax
111ad7: e8 00 da ff ff call 10f4dc <_Timespec_To_ticks>
111adc: 89 c3 mov %eax,%ebx
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
111ade: 8d 46 10 lea 0x10(%esi),%eax
111ae1: 89 04 24 mov %eax,(%esp)
111ae4: e8 f3 d9 ff ff call 10f4dc <_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 ) <
111ae9: 83 c4 10 add $0x10,%esp
111aec: 39 c3 cmp %eax,%ebx
111aee: 72 a6 jb 111a96 <_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 ) )
111af0: 83 ec 0c sub $0xc,%esp
111af3: ff 76 04 pushl 0x4(%esi)
111af6: e8 35 ff ff ff call 111a30 <_POSIX_Priority_Is_valid>
111afb: 83 c4 10 add $0x10,%esp
111afe: 84 c0 test %al,%al
111b00: 74 94 je 111a96 <_POSIX_Thread_Translate_sched_param+0x4a>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
111b02: c7 07 03 00 00 00 movl $0x3,(%edi)
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
111b08: 8b 45 14 mov 0x14(%ebp),%eax
111b0b: c7 00 14 bd 10 00 movl $0x10bd14,(%eax)
return 0;
111b11: 31 c0 xor %eax,%eax
111b13: eb 86 jmp 111a9b <_POSIX_Thread_Translate_sched_param+0x4f>
111b15: 8d 76 00 lea 0x0(%esi),%esi
return 0;
}
if ( policy == SCHED_FIFO ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
111b18: 31 c0 xor %eax,%eax
111b1a: e9 7c ff ff ff jmp 111a9b <_POSIX_Thread_Translate_sched_param+0x4f>
111b1f: 90 nop
}
if ( policy == SCHED_RR ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
111b20: c7 07 02 00 00 00 movl $0x2,(%edi)
return 0;
111b26: 31 c0 xor %eax,%eax
111b28: e9 6e ff ff ff jmp 111a9b <_POSIX_Thread_Translate_sched_param+0x4f>
001108e8 <_POSIX_Threads_Create_extension>:
bool _POSIX_Threads_Create_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *created
)
{
1108e8: 55 push %ebp
1108e9: 89 e5 mov %esp,%ebp
1108eb: 57 push %edi
1108ec: 56 push %esi
1108ed: 53 push %ebx
1108ee: 83 ec 28 sub $0x28,%esp
1108f1: 8b 55 0c mov 0xc(%ebp),%edx
POSIX_API_Control *api;
POSIX_API_Control *executing_api;
api = _Workspace_Allocate( sizeof( POSIX_API_Control ) );
1108f4: 68 f0 00 00 00 push $0xf0
1108f9: 89 55 e4 mov %edx,-0x1c(%ebp)
1108fc: e8 5f e0 ff ff call 10e960 <_Workspace_Allocate>
110901: 89 c3 mov %eax,%ebx
if ( !api )
110903: 83 c4 10 add $0x10,%esp
110906: 85 c0 test %eax,%eax
110908: 8b 55 e4 mov -0x1c(%ebp),%edx
11090b: 0f 84 2f 01 00 00 je 110a40 <_POSIX_Threads_Create_extension+0x158><== NEVER TAKEN
return false;
created->API_Extensions[ THREAD_API_POSIX ] = api;
110911: 89 82 ec 00 00 00 mov %eax,0xec(%edx)
/* XXX check all fields are touched */
api->Attributes = _POSIX_Threads_Default_attributes;
110917: b9 40 00 00 00 mov $0x40,%ecx
11091c: 31 c0 xor %eax,%eax
11091e: 89 df mov %ebx,%edi
110920: f3 aa rep stos %al,%es:(%edi)
110922: c7 03 01 00 00 00 movl $0x1,(%ebx)
110928: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
11092f: c7 43 14 01 00 00 00 movl $0x1,0x14(%ebx)
110936: c7 43 18 02 00 00 00 movl $0x2,0x18(%ebx)
11093d: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx)
110944: c7 43 3c 01 00 00 00 movl $0x1,0x3c(%ebx)
api->detachstate = _POSIX_Threads_Default_attributes.detachstate;
11094b: c7 43 40 01 00 00 00 movl $0x1,0x40(%ebx)
api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy;
110952: c7 83 84 00 00 00 01 movl $0x1,0x84(%ebx)
110959: 00 00 00
api->schedparam = _POSIX_Threads_Default_attributes.schedparam;
11095c: be 78 13 12 00 mov $0x121378,%esi
110961: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi
110967: b1 07 mov $0x7,%cl
110969: 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);
11096b: 0f b6 05 74 32 12 00 movzbl 0x123274,%eax
110972: 2b 42 14 sub 0x14(%edx),%eax
110975: 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;
11097b: c7 83 e0 00 00 00 00 movl $0x0,0xe0(%ebx)
110982: 00 00 00
api->cancelability_state = PTHREAD_CANCEL_ENABLE;
110985: c7 83 d8 00 00 00 00 movl $0x0,0xd8(%ebx)
11098c: 00 00 00
api->cancelability_type = PTHREAD_CANCEL_DEFERRED;
11098f: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx)
110996: 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 );
110999: 8d 83 e8 00 00 00 lea 0xe8(%ebx),%eax
11099f: 89 83 e4 00 00 00 mov %eax,0xe4(%ebx)
head->next = tail;
head->previous = NULL;
1109a5: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx)
1109ac: 00 00 00
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
1109af: 8d 83 e4 00 00 00 lea 0xe4(%ebx),%eax
1109b5: 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;
1109bb: c7 83 d4 00 00 00 00 movl $0x0,0xd4(%ebx)
1109c2: 00 00 00
1109c5: 0f b6 42 0b movzbl 0xb(%edx),%eax
1109c9: 83 e0 07 and $0x7,%eax
if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API
1109cc: 83 f8 03 cmp $0x3,%eax
1109cf: 74 53 je 110a24 <_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;
1109d1: c7 83 d0 00 00 00 ff movl $0xffffffff,0xd0(%ebx)
1109d8: ff ff ff
}
_Thread_queue_Initialize(
1109db: 6a 00 push $0x0
1109dd: 68 00 10 00 00 push $0x1000
1109e2: 6a 00 push $0x0
1109e4: 8d 43 44 lea 0x44(%ebx),%eax
1109e7: 50 push %eax
1109e8: 89 55 e4 mov %edx,-0x1c(%ebp)
1109eb: e8 48 d6 ff ff call 10e038 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_JOIN_AT_EXIT,
0
);
_Watchdog_Initialize(
1109f0: 8b 55 e4 mov -0x1c(%ebp),%edx
1109f3: 8b 42 08 mov 0x8(%edx),%eax
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
1109f6: c7 83 b0 00 00 00 00 movl $0x0,0xb0(%ebx)
1109fd: 00 00 00
the_watchdog->routine = routine;
110a00: c7 83 c4 00 00 00 4c movl $0x110a4c,0xc4(%ebx)
110a07: 0a 11 00
the_watchdog->id = id;
110a0a: 89 83 c8 00 00 00 mov %eax,0xc8(%ebx)
the_watchdog->user_data = user_data;
110a10: 89 93 cc 00 00 00 mov %edx,0xcc(%ebx)
_POSIX_Threads_Sporadic_budget_TSR,
created->Object.id,
created
);
return true;
110a16: 83 c4 10 add $0x10,%esp
110a19: b0 01 mov $0x1,%al
}
110a1b: 8d 65 f4 lea -0xc(%ebp),%esp
110a1e: 5b pop %ebx
110a1f: 5e pop %esi
110a20: 5f pop %edi
110a21: c9 leave
110a22: c3 ret
110a23: 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 ];
110a24: a1 58 7b 12 00 mov 0x127b58,%eax
api->signals_blocked = executing_api->signals_blocked;
110a29: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
110a2f: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
110a35: 89 83 d0 00 00 00 mov %eax,0xd0(%ebx)
110a3b: eb 9e jmp 1109db <_POSIX_Threads_Create_extension+0xf3>
110a3d: 8d 76 00 lea 0x0(%esi),%esi
POSIX_API_Control *executing_api;
api = _Workspace_Allocate( sizeof( POSIX_API_Control ) );
if ( !api )
return false;
110a40: 31 c0 xor %eax,%eax
created->Object.id,
created
);
return true;
}
110a42: 8d 65 f4 lea -0xc(%ebp),%esp
110a45: 5b pop %ebx
110a46: 5e pop %esi
110a47: 5f pop %edi
110a48: c9 leave
110a49: c3 ret
00110860 <_POSIX_Threads_Delete_extension>:
*/
void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
110860: 55 push %ebp
110861: 89 e5 mov %esp,%ebp
110863: 57 push %edi
110864: 56 push %esi
110865: 53 push %ebx
110866: 83 ec 28 sub $0x28,%esp
110869: 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 ];
11086c: 8b 87 ec 00 00 00 mov 0xec(%edi),%eax
110872: 89 45 e4 mov %eax,-0x1c(%ebp)
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
110875: 57 push %edi
110876: e8 d1 22 00 00 call 112b4c <_POSIX_Threads_cancel_run>
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
11087b: 89 3c 24 mov %edi,(%esp)
11087e: e8 31 23 00 00 call 112bb4 <_POSIX_Keys_Run_destructors>
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
110883: 8b 77 28 mov 0x28(%edi),%esi
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
110886: 83 c4 10 add $0x10,%esp
110889: 8b 45 e4 mov -0x1c(%ebp),%eax
11088c: 8d 58 44 lea 0x44(%eax),%ebx
11088f: eb 08 jmp 110899 <_POSIX_Threads_Delete_extension+0x39>
110891: 8d 76 00 lea 0x0(%esi),%esi
*(void **)the_thread->Wait.return_argument = value_ptr;
110894: 8b 40 28 mov 0x28(%eax),%eax
110897: 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 )) )
110899: 83 ec 0c sub $0xc,%esp
11089c: 53 push %ebx
11089d: e8 06 d4 ff ff call 10dca8 <_Thread_queue_Dequeue>
1108a2: 83 c4 10 add $0x10,%esp
1108a5: 85 c0 test %eax,%eax
1108a7: 75 eb jne 110894 <_POSIX_Threads_Delete_extension+0x34>
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
1108a9: 8b 45 e4 mov -0x1c(%ebp),%eax
1108ac: 83 b8 84 00 00 00 04 cmpl $0x4,0x84(%eax)
1108b3: 74 1f je 1108d4 <_POSIX_Threads_Delete_extension+0x74>
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
1108b5: c7 87 ec 00 00 00 00 movl $0x0,0xec(%edi)
1108bc: 00 00 00
(void) _Workspace_Free( api );
1108bf: 8b 45 e4 mov -0x1c(%ebp),%eax
1108c2: 89 45 08 mov %eax,0x8(%ebp)
}
1108c5: 8d 65 f4 lea -0xc(%ebp),%esp
1108c8: 5b pop %ebx
1108c9: 5e pop %esi
1108ca: 5f pop %edi
1108cb: c9 leave
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
(void) _Workspace_Free( api );
1108cc: e9 ab e0 ff ff jmp 10e97c <_Workspace_Free>
1108d1: 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 );
1108d4: 83 ec 0c sub $0xc,%esp
1108d7: 05 a8 00 00 00 add $0xa8,%eax
1108dc: 50 push %eax
1108dd: e8 56 df ff ff call 10e838 <_Watchdog_Remove>
1108e2: 83 c4 10 add $0x10,%esp
1108e5: eb ce jmp 1108b5 <_POSIX_Threads_Delete_extension+0x55>
00110824 <_POSIX_Threads_Initialize_user_threads>:
*
* This routine creates and starts all configured user
* initialzation threads.
*/
void _POSIX_Threads_Initialize_user_threads( void )
{
110824: 55 push %ebp
110825: 89 e5 mov %esp,%ebp
110827: 83 ec 08 sub $0x8,%esp
if ( _POSIX_Threads_Initialize_user_threads_p )
11082a: a1 18 58 12 00 mov 0x125818,%eax
11082f: 85 c0 test %eax,%eax
110831: 74 05 je 110838 <_POSIX_Threads_Initialize_user_threads+0x14>
(*_POSIX_Threads_Initialize_user_threads_p)();
}
110833: c9 leave
* initialzation threads.
*/
void _POSIX_Threads_Initialize_user_threads( void )
{
if ( _POSIX_Threads_Initialize_user_threads_p )
(*_POSIX_Threads_Initialize_user_threads_p)();
110834: ff e0 jmp *%eax
110836: 66 90 xchg %ax,%ax
}
110838: c9 leave
110839: 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 74 45 12 00 mov 0x124574,%edi
maximum = Configuration_POSIX_API.number_of_initialization_threads;
10ba03: a1 70 45 12 00 mov 0x124570,%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 0f 61 00 00 call 111b30 <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 31 61 00 00 call 111b5c <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 59 61 00 00 call 111b90 <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 ce 1e 00 00 call 10d934 <_Internal_error_Occurred>
00110a4c <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
110a4c: 55 push %ebp
110a4d: 89 e5 mov %esp,%ebp
110a4f: 56 push %esi
110a50: 53 push %ebx
110a51: 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 ];
110a54: 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 );
110a5a: 83 ec 0c sub $0xc,%esp
110a5d: 8d 83 98 00 00 00 lea 0x98(%ebx),%eax
110a63: 50 push %eax
110a64: e8 53 0f 00 00 call 1119bc <_Timespec_To_ticks>
the_thread->cpu_time_budget = ticks;
110a69: 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);
110a6c: 0f b6 05 74 32 12 00 movzbl 0x123274,%eax
110a73: 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;
110a79: 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 ) {
110a7c: 83 c4 10 add $0x10,%esp
110a7f: 8b 4e 1c mov 0x1c(%esi),%ecx
110a82: 85 c9 test %ecx,%ecx
110a84: 75 05 jne 110a8b <_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 ) {
110a86: 39 46 14 cmp %eax,0x14(%esi)
110a89: 77 35 ja 110ac0 <_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 );
110a8b: 83 ec 0c sub $0xc,%esp
110a8e: 8d 83 90 00 00 00 lea 0x90(%ebx),%eax
110a94: 50 push %eax
110a95: e8 22 0f 00 00 call 1119bc <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
110a9a: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
110aa0: 83 c4 10 add $0x10,%esp
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
110aa3: 81 c3 a8 00 00 00 add $0xa8,%ebx
110aa9: 89 5d 0c mov %ebx,0xc(%ebp)
110aac: c7 45 08 7c 76 12 00 movl $0x12767c,0x8(%ebp)
}
110ab3: 8d 65 f8 lea -0x8(%ebp),%esp
110ab6: 5b pop %ebx
110ab7: 5e pop %esi
110ab8: c9 leave
110ab9: e9 3a dc ff ff jmp 10e6f8 <_Watchdog_Insert>
110abe: 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 );
110ac0: 52 push %edx
110ac1: 6a 01 push $0x1
110ac3: 50 push %eax
110ac4: 56 push %esi
110ac5: e8 76 c9 ff ff call 10d440 <_Thread_Change_priority>
110aca: 83 c4 10 add $0x10,%esp
110acd: eb bc jmp 110a8b <_POSIX_Threads_Sporadic_budget_TSR+0x3f>
00110ad0 <_POSIX_Threads_Sporadic_budget_callout>:
* _POSIX_Threads_Sporadic_budget_callout
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
110ad0: 55 push %ebp
110ad1: 89 e5 mov %esp,%ebp
110ad3: 83 ec 08 sub $0x8,%esp
110ad6: 8b 45 08 mov 0x8(%ebp),%eax
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
110ad9: 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 */
110adf: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax)
110ae6: 0f b6 15 74 32 12 00 movzbl 0x123274,%edx
110aed: 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;
110af3: 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 ) {
110af6: 8b 48 1c mov 0x1c(%eax),%ecx
110af9: 85 c9 test %ecx,%ecx
110afb: 75 05 jne 110b02 <_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 ) {
110afd: 39 50 14 cmp %edx,0x14(%eax)
110b00: 72 02 jb 110b04 <_POSIX_Threads_Sporadic_budget_callout+0x34><== ALWAYS TAKEN
#if 0
printk( "lower priority\n" );
#endif
}
}
}
110b02: c9 leave <== NOT EXECUTED
110b03: 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 );
110b04: 51 push %ecx
110b05: 6a 01 push $0x1
110b07: 52 push %edx
110b08: 50 push %eax
110b09: e8 32 c9 ff ff call 10d440 <_Thread_Change_priority>
110b0e: 83 c4 10 add $0x10,%esp
#if 0
printk( "lower priority\n" );
#endif
}
}
}
110b11: c9 leave
110b12: c3 ret
00112b4c <_POSIX_Threads_cancel_run>:
#include <rtems/posix/threadsup.h>
void _POSIX_Threads_cancel_run(
Thread_Control *the_thread
)
{
112b4c: 55 push %ebp
112b4d: 89 e5 mov %esp,%ebp
112b4f: 57 push %edi
112b50: 56 push %esi
112b51: 53 push %ebx
112b52: 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 ];
112b55: 8b 45 08 mov 0x8(%ebp),%eax
112b58: 8b 98 ec 00 00 00 mov 0xec(%eax),%ebx
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
112b5e: c7 83 d8 00 00 00 01 movl $0x1,0xd8(%ebx)
112b65: 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 );
112b68: 8d b3 e8 00 00 00 lea 0xe8(%ebx),%esi
while ( !_Chain_Is_empty( handler_stack ) ) {
112b6e: 39 b3 e4 00 00 00 cmp %esi,0xe4(%ebx)
112b74: 74 33 je 112ba9 <_POSIX_Threads_cancel_run+0x5d>
112b76: 66 90 xchg %ax,%ax
_ISR_Disable( level );
112b78: 9c pushf
112b79: fa cli
112b7a: 59 pop %ecx
handler = (POSIX_Cancel_Handler_control *)
112b7b: 8b bb ec 00 00 00 mov 0xec(%ebx),%edi
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
112b81: 8b 17 mov (%edi),%edx
previous = the_node->previous;
112b83: 8b 47 04 mov 0x4(%edi),%eax
next->previous = previous;
112b86: 89 42 04 mov %eax,0x4(%edx)
previous->next = next;
112b89: 89 10 mov %edx,(%eax)
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
112b8b: 51 push %ecx
112b8c: 9d popf
(*handler->routine)( handler->arg );
112b8d: 83 ec 0c sub $0xc,%esp
112b90: ff 77 0c pushl 0xc(%edi)
112b93: ff 57 08 call *0x8(%edi)
_Workspace_Free( handler );
112b96: 89 3c 24 mov %edi,(%esp)
112b99: e8 de bd ff ff call 10e97c <_Workspace_Free>
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
while ( !_Chain_Is_empty( handler_stack ) ) {
112b9e: 83 c4 10 add $0x10,%esp
112ba1: 39 b3 e4 00 00 00 cmp %esi,0xe4(%ebx)
112ba7: 75 cf jne 112b78 <_POSIX_Threads_cancel_run+0x2c><== NEVER TAKEN
(*handler->routine)( handler->arg );
_Workspace_Free( handler );
}
}
112ba9: 8d 65 f4 lea -0xc(%ebp),%esp
112bac: 5b pop %ebx
112bad: 5e pop %esi
112bae: 5f pop %edi
112baf: c9 leave
112bb0: c3 ret
0011182c <_POSIX_Timer_Insert_helper>:
Watchdog_Interval ticks,
Objects_Id id,
Watchdog_Service_routine_entry TSR,
void *arg
)
{
11182c: 55 push %ebp
11182d: 89 e5 mov %esp,%ebp
11182f: 56 push %esi
111830: 53 push %ebx
111831: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level;
(void) _Watchdog_Remove( timer );
111834: 83 ec 0c sub $0xc,%esp
111837: 53 push %ebx
111838: e8 0b db ff ff call 10f348 <_Watchdog_Remove>
_ISR_Disable( level );
11183d: 9c pushf
11183e: fa cli
11183f: 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 ) {
111840: 83 c4 10 add $0x10,%esp
111843: 8b 43 08 mov 0x8(%ebx),%eax
111846: 85 c0 test %eax,%eax
111848: 74 0e je 111858 <_POSIX_Timer_Insert_helper+0x2c>
_ISR_Enable( level );
11184a: 56 push %esi
11184b: 9d popf
return false;
11184c: 31 c0 xor %eax,%eax
*/
_Watchdog_Initialize( timer, TSR, id, arg );
_Watchdog_Insert_ticks( timer, ticks );
_ISR_Enable( level );
return true;
}
11184e: 8d 65 f8 lea -0x8(%ebp),%esp
111851: 5b pop %ebx
111852: 5e pop %esi
111853: c9 leave
111854: c3 ret
111855: 8d 76 00 lea 0x0(%esi),%esi
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
111858: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
the_watchdog->routine = routine;
11185f: 8b 45 14 mov 0x14(%ebp),%eax
111862: 89 43 1c mov %eax,0x1c(%ebx)
the_watchdog->id = id;
111865: 8b 45 10 mov 0x10(%ebp),%eax
111868: 89 43 20 mov %eax,0x20(%ebx)
the_watchdog->user_data = user_data;
11186b: 8b 45 18 mov 0x18(%ebp),%eax
11186e: 89 43 24 mov %eax,0x24(%ebx)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
111871: 8b 45 0c mov 0xc(%ebp),%eax
111874: 89 43 0c mov %eax,0xc(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
111877: 83 ec 08 sub $0x8,%esp
11187a: 53 push %ebx
11187b: 68 9c 99 12 00 push $0x12999c
111880: e8 83 d9 ff ff call 10f208 <_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 );
111885: 56 push %esi
111886: 9d popf
return true;
111887: 83 c4 10 add $0x10,%esp
11188a: b0 01 mov $0x1,%al
}
11188c: 8d 65 f8 lea -0x8(%ebp),%esp
11188f: 5b pop %ebx
111890: 5e pop %esi
111891: c9 leave
111892: 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 8b 5b 00 00 call 1113bc <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 d4 5f 00 00 call 11182c <_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 95 16 00 00 call 10cf00 <_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>
00112c38 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
112c38: 55 push %ebp
112c39: 89 e5 mov %esp,%ebp
112c3b: 57 push %edi
112c3c: 56 push %esi
112c3d: 53 push %ebx
112c3e: 83 ec 78 sub $0x78,%esp
112c41: 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,
112c44: 6a 01 push $0x1
112c46: 0f b6 45 10 movzbl 0x10(%ebp),%eax
112c4a: 50 push %eax
112c4b: 8d 55 dc lea -0x24(%ebp),%edx
112c4e: 52 push %edx
112c4f: 53 push %ebx
112c50: ff 75 08 pushl 0x8(%ebp)
112c53: 89 55 9c mov %edx,-0x64(%ebp)
112c56: e8 b5 00 00 00 call 112d10 <_POSIX_signals_Clear_signals>
112c5b: 83 c4 20 add $0x20,%esp
112c5e: 84 c0 test %al,%al
112c60: 8b 55 9c mov -0x64(%ebp),%edx
112c63: 0f 84 9b 00 00 00 je 112d04 <_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 )
112c69: 8d 04 5b lea (%ebx,%ebx,2),%eax
112c6c: c1 e0 02 shl $0x2,%eax
112c6f: 8b 88 c8 7b 12 00 mov 0x127bc8(%eax),%ecx
112c75: 89 4d a4 mov %ecx,-0x5c(%ebp)
112c78: 49 dec %ecx
112c79: 0f 84 85 00 00 00 je 112d04 <_POSIX_signals_Check_signal+0xcc><== NEVER TAKEN
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
112c7f: 8b 75 08 mov 0x8(%ebp),%esi
112c82: 8b b6 d0 00 00 00 mov 0xd0(%esi),%esi
112c88: 89 75 a0 mov %esi,-0x60(%ebp)
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
112c8b: 8b 88 c4 7b 12 00 mov 0x127bc4(%eax),%ecx
112c91: 09 f1 or %esi,%ecx
112c93: 8b 75 08 mov 0x8(%ebp),%esi
112c96: 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,
112c9c: 8d 75 b4 lea -0x4c(%ebp),%esi
112c9f: 89 75 94 mov %esi,-0x6c(%ebp)
112ca2: 8b 35 58 7b 12 00 mov 0x127b58,%esi
112ca8: 83 c6 20 add $0x20,%esi
112cab: b9 0a 00 00 00 mov $0xa,%ecx
112cb0: 8b 7d 94 mov -0x6c(%ebp),%edi
112cb3: 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 ) {
112cb5: 83 b8 c0 7b 12 00 02 cmpl $0x2,0x127bc0(%eax)
112cbc: 74 36 je 112cf4 <_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 );
112cbe: 83 ec 0c sub $0xc,%esp
112cc1: 53 push %ebx
112cc2: ff 55 a4 call *-0x5c(%ebp)
break;
112cc5: 83 c4 10 add $0x10,%esp
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
112cc8: 8b 3d 58 7b 12 00 mov 0x127b58,%edi
112cce: 83 c7 20 add $0x20,%edi
112cd1: b9 0a 00 00 00 mov $0xa,%ecx
112cd6: 8b 75 94 mov -0x6c(%ebp),%esi
112cd9: 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;
112cdb: 8b 55 a0 mov -0x60(%ebp),%edx
112cde: 8b 45 08 mov 0x8(%ebp),%eax
112ce1: 89 90 d0 00 00 00 mov %edx,0xd0(%eax)
return true;
112ce7: b0 01 mov $0x1,%al
}
112ce9: 8d 65 f4 lea -0xc(%ebp),%esp
112cec: 5b pop %ebx
112ced: 5e pop %esi
112cee: 5f pop %edi
112cef: c9 leave
112cf0: c3 ret
112cf1: 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)(
112cf4: 50 push %eax
112cf5: 6a 00 push $0x0
112cf7: 52 push %edx
112cf8: 53 push %ebx
112cf9: ff 55 a4 call *-0x5c(%ebp)
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
112cfc: 83 c4 10 add $0x10,%esp
112cff: eb c7 jmp 112cc8 <_POSIX_signals_Check_signal+0x90>
112d01: 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;
112d04: 31 c0 xor %eax,%eax
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
}
112d06: 8d 65 f4 lea -0xc(%ebp),%esp
112d09: 5b pop %ebx
112d0a: 5e pop %esi
112d0b: 5f pop %edi
112d0c: c9 leave
112d0d: c3 ret
001132c0 <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
1132c0: 55 push %ebp
1132c1: 89 e5 mov %esp,%ebp
1132c3: 53 push %ebx
1132c4: 8b 4d 08 mov 0x8(%ebp),%ecx
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
1132c7: 9c pushf
1132c8: fa cli
1132c9: 5a pop %edx
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
1132ca: 8d 04 49 lea (%ecx,%ecx,2),%eax
1132cd: c1 e0 02 shl $0x2,%eax
1132d0: 83 b8 c0 7b 12 00 02 cmpl $0x2,0x127bc0(%eax)
1132d7: 74 13 je 1132ec <_POSIX_signals_Clear_process_signals+0x2c>
1132d9: 49 dec %ecx
1132da: 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;
1132df: d3 c0 rol %cl,%eax
1132e1: 21 05 c8 7d 12 00 and %eax,0x127dc8
}
_ISR_Enable( level );
1132e7: 52 push %edx
1132e8: 9d popf
}
1132e9: 5b pop %ebx
1132ea: c9 leave
1132eb: 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 );
1132ec: 8d 98 e4 7d 12 00 lea 0x127de4(%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 ] ) )
1132f2: 39 98 e0 7d 12 00 cmp %ebx,0x127de0(%eax)
1132f8: 75 ed jne 1132e7 <_POSIX_signals_Clear_process_signals+0x27><== NEVER TAKEN
1132fa: eb dd jmp 1132d9 <_POSIX_signals_Clear_process_signals+0x19>
00112d10 <_POSIX_signals_Clear_signals>:
int signo,
siginfo_t *info,
bool is_global,
bool check_blocked
)
{
112d10: 55 push %ebp
112d11: 89 e5 mov %esp,%ebp
112d13: 57 push %edi
112d14: 56 push %esi
112d15: 53 push %ebx
112d16: 83 ec 1c sub $0x1c,%esp
112d19: 8b 5d 0c mov 0xc(%ebp),%ebx
112d1c: 0f b6 7d 14 movzbl 0x14(%ebp),%edi
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
112d20: 8d 4b ff lea -0x1(%ebx),%ecx
112d23: b8 01 00 00 00 mov $0x1,%eax
112d28: 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 )
112d2a: 80 7d 18 00 cmpb $0x0,0x18(%ebp)
112d2e: 74 40 je 112d70 <_POSIX_signals_Clear_signals+0x60>
signals_blocked = ~api->signals_blocked;
112d30: 8b 55 08 mov 0x8(%ebp),%edx
112d33: 8b 8a d0 00 00 00 mov 0xd0(%edx),%ecx
112d39: 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 );
112d3b: 9c pushf
112d3c: fa cli
112d3d: 8f 45 e4 popl -0x1c(%ebp)
if ( is_global ) {
112d40: 89 fa mov %edi,%edx
112d42: 84 d2 test %dl,%dl
112d44: 74 32 je 112d78 <_POSIX_signals_Clear_signals+0x68>
if ( mask & (_POSIX_signals_Pending & signals_blocked) ) {
112d46: 23 05 c8 7d 12 00 and 0x127dc8,%eax
112d4c: 85 c8 test %ecx,%eax
112d4e: 74 54 je 112da4 <_POSIX_signals_Clear_signals+0x94>
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
112d50: 8d 14 5b lea (%ebx,%ebx,2),%edx
112d53: c1 e2 02 shl $0x2,%edx
112d56: 83 ba c0 7b 12 00 02 cmpl $0x2,0x127bc0(%edx)
112d5d: 74 49 je 112da8 <_POSIX_signals_Clear_signals+0x98>
&psiginfo->Node
);
} else
do_callout = false;
}
_POSIX_signals_Clear_process_signals( signo );
112d5f: 83 ec 0c sub $0xc,%esp
112d62: 53 push %ebx
112d63: e8 58 05 00 00 call 1132c0 <_POSIX_signals_Clear_process_signals>
112d68: 83 c4 10 add $0x10,%esp
do_callout = true;
112d6b: b0 01 mov $0x1,%al
112d6d: eb 26 jmp 112d95 <_POSIX_signals_Clear_signals+0x85>
112d6f: 90 nop
*/
if ( check_blocked )
signals_blocked = ~api->signals_blocked;
else
signals_blocked = SIGNAL_ALL_MASK;
112d70: b9 ff ff ff ff mov $0xffffffff,%ecx
112d75: eb c4 jmp 112d3b <_POSIX_signals_Clear_signals+0x2b>
112d77: 90 nop
}
_POSIX_signals_Clear_process_signals( signo );
do_callout = true;
}
} else {
if ( mask & (api->signals_pending & signals_blocked) ) {
112d78: 8b 55 08 mov 0x8(%ebp),%edx
112d7b: 8b 9a d4 00 00 00 mov 0xd4(%edx),%ebx
112d81: 89 c6 mov %eax,%esi
112d83: 21 de and %ebx,%esi
112d85: 85 ce test %ecx,%esi
112d87: 74 1b je 112da4 <_POSIX_signals_Clear_signals+0x94>
api->signals_pending &= ~mask;
112d89: f7 d0 not %eax
112d8b: 21 d8 and %ebx,%eax
112d8d: 89 82 d4 00 00 00 mov %eax,0xd4(%edx)
do_callout = true;
112d93: b0 01 mov $0x1,%al
}
}
_ISR_Enable( level );
112d95: ff 75 e4 pushl -0x1c(%ebp)
112d98: 9d popf
return do_callout;
}
112d99: 8d 65 f4 lea -0xc(%ebp),%esp
112d9c: 5b pop %ebx
112d9d: 5e pop %esi
112d9e: 5f pop %edi
112d9f: c9 leave
112da0: c3 ret
112da1: 8d 76 00 lea 0x0(%esi),%esi
bool do_callout;
POSIX_signals_Siginfo_node *psiginfo;
mask = signo_to_mask( signo );
do_callout = false;
112da4: 31 c0 xor %eax,%eax
112da6: eb ed jmp 112d95 <_POSIX_signals_Clear_signals+0x85>
do_callout = true;
}
}
_ISR_Enable( level );
return do_callout;
}
112da8: 8d 8a e0 7d 12 00 lea 0x127de0(%edx),%ecx
112dae: 8b 82 e0 7d 12 00 mov 0x127de0(%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 );
112db4: 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))
112db7: 39 f0 cmp %esi,%eax
112db9: 74 45 je 112e00 <_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;
112dbb: 8b 30 mov (%eax),%esi
head->next = new_first;
112dbd: 89 b2 e0 7d 12 00 mov %esi,0x127de0(%edx)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
112dc3: 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 );
112dc6: 83 ec 0c sub $0xc,%esp
112dc9: 53 push %ebx
112dca: 89 45 e0 mov %eax,-0x20(%ebp)
112dcd: e8 ee 04 00 00 call 1132c0 <_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;
112dd2: 8b 45 e0 mov -0x20(%ebp),%eax
112dd5: 8d 70 08 lea 0x8(%eax),%esi
112dd8: b9 03 00 00 00 mov $0x3,%ecx
112ddd: 8b 7d 10 mov 0x10(%ebp),%edi
112de0: 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;
112de2: 8b 15 48 7d 12 00 mov 0x127d48,%edx
the_node->next = tail;
112de8: c7 00 44 7d 12 00 movl $0x127d44,(%eax)
tail->previous = the_node;
112dee: a3 48 7d 12 00 mov %eax,0x127d48
old_last->next = the_node;
112df3: 89 02 mov %eax,(%edx)
the_node->previous = old_last;
112df5: 89 50 04 mov %edx,0x4(%eax)
112df8: 83 c4 10 add $0x10,%esp
112dfb: e9 5f ff ff ff jmp 112d5f <_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 );
112e00: 83 ec 0c sub $0xc,%esp
112e03: 53 push %ebx
112e04: e8 b7 04 00 00 call 1132c0 <_POSIX_signals_Clear_process_signals>
112e09: 83 c4 10 add $0x10,%esp
112e0c: e9 4e ff ff ff jmp 112d5f <_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
00124468 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
124468: 55 push %ebp
124469: 89 e5 mov %esp,%ebp
12446b: 57 push %edi
12446c: 56 push %esi
12446d: 53 push %ebx
12446e: 83 ec 0c sub $0xc,%esp
124471: 8b 5d 08 mov 0x8(%ebp),%ebx
124474: 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 ];
124477: 8b b3 ec 00 00 00 mov 0xec(%ebx),%esi
12447d: 8d 4a ff lea -0x1(%edx),%ecx
124480: b8 01 00 00 00 mov $0x1,%eax
124485: d3 e0 shl %cl,%eax
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
124487: 8b 4b 10 mov 0x10(%ebx),%ecx
12448a: 89 cf mov %ecx,%edi
12448c: 81 e7 00 80 00 10 and $0x10008000,%edi
124492: 81 ff 00 80 00 10 cmp $0x10008000,%edi
124498: 74 72 je 12450c <_POSIX_signals_Unblock_thread+0xa4>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
12449a: 8b 96 d0 00 00 00 mov 0xd0(%esi),%edx
1244a0: f7 d2 not %edx
1244a2: 85 d0 test %edx,%eax
1244a4: 74 5a je 124500 <_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 ) ) {
1244a6: f7 c1 00 00 00 10 test $0x10000000,%ecx
1244ac: 74 3a je 1244e8 <_POSIX_signals_Unblock_thread+0x80>
the_thread->Wait.return_code = EINTR;
1244ae: 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) )
1244b5: f7 c1 e0 be 03 00 test $0x3bee0,%ecx
1244bb: 0f 85 93 00 00 00 jne 124554 <_POSIX_signals_Unblock_thread+0xec>
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
1244c1: 83 e1 08 and $0x8,%ecx
1244c4: 74 3a je 124500 <_POSIX_signals_Unblock_thread+0x98><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
1244c6: 83 ec 0c sub $0xc,%esp
1244c9: 8d 43 48 lea 0x48(%ebx),%eax
1244cc: 50 push %eax
1244cd: e8 8e f4 fe ff call 113960 <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
1244d2: 5a pop %edx
1244d3: 59 pop %ecx
1244d4: 68 f8 ff 03 10 push $0x1003fff8
1244d9: 53 push %ebx
1244da: e8 bd e1 fe ff call 11269c <_Thread_Clear_state>
1244df: 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;
1244e2: 31 c0 xor %eax,%eax
1244e4: eb 1c jmp 124502 <_POSIX_signals_Unblock_thread+0x9a>
1244e6: 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 ) {
1244e8: 85 c9 test %ecx,%ecx
1244ea: 75 14 jne 124500 <_POSIX_signals_Unblock_thread+0x98><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
1244ec: a1 b4 e8 12 00 mov 0x12e8b4,%eax
1244f1: 85 c0 test %eax,%eax
1244f3: 74 0b je 124500 <_POSIX_signals_Unblock_thread+0x98>
1244f5: 3b 1d b8 e8 12 00 cmp 0x12e8b8,%ebx
1244fb: 74 7b je 124578 <_POSIX_signals_Unblock_thread+0x110><== ALWAYS TAKEN
1244fd: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Dispatch_necessary = true;
}
}
return false;
124500: 31 c0 xor %eax,%eax
}
124502: 8d 65 f4 lea -0xc(%ebp),%esp
124505: 5b pop %ebx
124506: 5e pop %esi
124507: 5f pop %edi
124508: c9 leave
124509: c3 ret
12450a: 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) ) {
12450c: 85 43 30 test %eax,0x30(%ebx)
12450f: 74 33 je 124544 <_POSIX_signals_Unblock_thread+0xdc>
the_thread->Wait.return_code = EINTR;
124511: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx)
the_info = (siginfo_t *) the_thread->Wait.return_argument;
124518: 8b 43 28 mov 0x28(%ebx),%eax
if ( !info ) {
12451b: 8b 75 10 mov 0x10(%ebp),%esi
12451e: 85 f6 test %esi,%esi
124520: 74 42 je 124564 <_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;
124522: b9 03 00 00 00 mov $0x3,%ecx
124527: 89 c7 mov %eax,%edi
124529: 8b 75 10 mov 0x10(%ebp),%esi
12452c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
_Thread_queue_Extract_with_proxy( the_thread );
12452e: 83 ec 0c sub $0xc,%esp
124531: 53 push %ebx
124532: e8 d1 eb fe ff call 113108 <_Thread_queue_Extract_with_proxy>
return true;
124537: 83 c4 10 add $0x10,%esp
12453a: b0 01 mov $0x1,%al
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
}
12453c: 8d 65 f4 lea -0xc(%ebp),%esp
12453f: 5b pop %ebx
124540: 5e pop %esi
124541: 5f pop %edi
124542: c9 leave
124543: 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) ) {
124544: 8b 8e d0 00 00 00 mov 0xd0(%esi),%ecx
12454a: f7 d1 not %ecx
12454c: 85 c8 test %ecx,%eax
12454e: 75 c1 jne 124511 <_POSIX_signals_Unblock_thread+0xa9>
124550: eb ae jmp 124500 <_POSIX_signals_Unblock_thread+0x98>
124552: 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 );
124554: 83 ec 0c sub $0xc,%esp
124557: 53 push %ebx
124558: e8 ab eb fe ff call 113108 <_Thread_queue_Extract_with_proxy>
12455d: 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;
124560: 31 c0 xor %eax,%eax
124562: eb 9e jmp 124502 <_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;
124564: 89 10 mov %edx,(%eax)
the_info->si_code = SI_USER;
124566: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
the_info->si_value.sival_int = 0;
12456d: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
124574: eb b8 jmp 12452e <_POSIX_signals_Unblock_thread+0xc6>
124576: 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;
124578: c6 05 c4 e8 12 00 01 movb $0x1,0x12e8c4
}
}
return false;
12457f: 31 c0 xor %eax,%eax
124581: e9 7c ff ff ff jmp 124502 <_POSIX_signals_Unblock_thread+0x9a>
0010d864 <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
10d864: 55 push %ebp
10d865: 89 e5 mov %esp,%ebp
10d867: 56 push %esi
10d868: 53 push %ebx
10d869: 8b 5d 08 mov 0x8(%ebp),%ebx
10d86c: 8b 75 0c mov 0xc(%ebp),%esi
if ( !the_heap )
10d86f: 85 db test %ebx,%ebx
10d871: 74 35 je 10d8a8 <_Protected_heap_Get_information+0x44>
return false;
if ( !the_info )
10d873: 85 f6 test %esi,%esi
10d875: 74 31 je 10d8a8 <_Protected_heap_Get_information+0x44>
return false;
_RTEMS_Lock_allocator();
10d877: 83 ec 0c sub $0xc,%esp
10d87a: ff 35 3c 80 12 00 pushl 0x12803c
10d880: e8 cf ed ff ff call 10c654 <_API_Mutex_Lock>
_Heap_Get_information( the_heap, the_info );
10d885: 5a pop %edx
10d886: 59 pop %ecx
10d887: 56 push %esi
10d888: 53 push %ebx
10d889: e8 86 47 00 00 call 112014 <_Heap_Get_information>
_RTEMS_Unlock_allocator();
10d88e: 58 pop %eax
10d88f: ff 35 3c 80 12 00 pushl 0x12803c
10d895: e8 02 ee ff ff call 10c69c <_API_Mutex_Unlock>
return true;
10d89a: 83 c4 10 add $0x10,%esp
10d89d: b0 01 mov $0x1,%al
}
10d89f: 8d 65 f8 lea -0x8(%ebp),%esp
10d8a2: 5b pop %ebx
10d8a3: 5e pop %esi
10d8a4: c9 leave
10d8a5: c3 ret
10d8a6: 66 90 xchg %ax,%ax
{
if ( !the_heap )
return false;
if ( !the_info )
return false;
10d8a8: 31 c0 xor %eax,%eax
_RTEMS_Lock_allocator();
_Heap_Get_information( the_heap, the_info );
_RTEMS_Unlock_allocator();
return true;
}
10d8aa: 8d 65 f8 lea -0x8(%ebp),%esp
10d8ad: 5b pop %ebx
10d8ae: 5e pop %esi
10d8af: c9 leave
10d8b0: c3 ret
00110c20 <_Protected_heap_Walk>:
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
110c20: 55 push %ebp
110c21: 89 e5 mov %esp,%ebp
110c23: 56 push %esi
110c24: 53 push %ebx
110c25: 83 ec 10 sub $0x10,%esp
110c28: 8b 5d 08 mov 0x8(%ebp),%ebx
110c2b: 8b 75 0c mov 0xc(%ebp),%esi
110c2e: 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 ) {
110c31: 8b 15 50 de 12 00 mov 0x12de50,%edx
110c37: 85 d2 test %edx,%edx
110c39: 74 19 je 110c54 <_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 );
110c3b: 0f b6 c0 movzbl %al,%eax
110c3e: 89 45 10 mov %eax,0x10(%ebp)
110c41: 89 75 0c mov %esi,0xc(%ebp)
110c44: 89 5d 08 mov %ebx,0x8(%ebp)
}
return status;
}
110c47: 8d 65 f8 lea -0x8(%ebp),%esp
110c4a: 5b pop %ebx
110c4b: 5e pop %esi
110c4c: 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 );
110c4d: e9 1a f2 ff ff jmp 10fe6c <_Heap_Walk>
110c52: 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();
110c54: 83 ec 0c sub $0xc,%esp
110c57: ff 35 3c df 12 00 pushl 0x12df3c
110c5d: 88 45 f4 mov %al,-0xc(%ebp)
110c60: e8 a7 e3 ff ff call 10f00c <_API_Mutex_Lock>
status = _Heap_Walk( the_heap, source, do_dump );
110c65: 83 c4 0c add $0xc,%esp
110c68: 8a 45 f4 mov -0xc(%ebp),%al
110c6b: 0f b6 c0 movzbl %al,%eax
110c6e: 50 push %eax
110c6f: 56 push %esi
110c70: 53 push %ebx
110c71: e8 f6 f1 ff ff call 10fe6c <_Heap_Walk>
_RTEMS_Unlock_allocator();
110c76: 5a pop %edx
110c77: ff 35 3c df 12 00 pushl 0x12df3c
110c7d: 88 45 f4 mov %al,-0xc(%ebp)
110c80: e8 cf e3 ff ff call 10f054 <_API_Mutex_Unlock>
110c85: 83 c4 10 add $0x10,%esp
} else {
status = _Heap_Walk( the_heap, source, do_dump );
}
return status;
}
110c88: 8a 45 f4 mov -0xc(%ebp),%al
110c8b: 8d 65 f8 lea -0x8(%ebp),%esp
110c8e: 5b pop %ebx
110c8f: 5e pop %esi
110c90: c9 leave
110c91: c3 ret
00110e64 <_RTEMS_tasks_Create_extension>:
bool _RTEMS_tasks_Create_extension(
Thread_Control *executing,
Thread_Control *created
)
{
110e64: 55 push %ebp
110e65: 89 e5 mov %esp,%ebp
110e67: 53 push %ebx
110e68: 83 ec 10 sub $0x10,%esp
110e6b: 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 );
110e6e: 80 3d 44 32 12 00 01 cmpb $0x1,0x123244
110e75: 19 c0 sbb %eax,%eax
110e77: 83 e0 c0 and $0xffffffc0,%eax
110e7a: 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 );
110e7d: 50 push %eax
110e7e: e8 dd da ff ff call 10e960 <_Workspace_Allocate>
if ( !api )
110e83: 83 c4 10 add $0x10,%esp
110e86: 85 c0 test %eax,%eax
110e88: 74 6a je 110ef4 <_RTEMS_tasks_Create_extension+0x90>
return false;
created->API_Extensions[ THREAD_API_RTEMS ] = api;
110e8a: 89 83 e8 00 00 00 mov %eax,0xe8(%ebx)
api->pending_events = EVENT_SETS_NONE_PENDING;
110e90: c7 00 00 00 00 00 movl $0x0,(%eax)
api->event_condition = 0;
110e96: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
*/
RTEMS_INLINE_ROUTINE void _ASR_Initialize (
ASR_Information *information
)
{
information->is_enabled = false;
110e9d: c6 40 08 00 movb $0x0,0x8(%eax)
information->handler = NULL;
110ea1: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
information->mode_set = RTEMS_DEFAULT_MODES;
110ea8: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
information->signals_posted = 0;
110eaf: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax)
information->signals_pending = 0;
110eb6: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
information->nest_level = 0;
110ebd: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
_ASR_Initialize( &api->Signal );
created->task_variables = NULL;
110ec4: c7 83 f4 00 00 00 00 movl $0x0,0xf4(%ebx)
110ecb: 00 00 00
if ( rtems_configuration_get_notepads_enabled() ) {
110ece: 80 3d 44 32 12 00 00 cmpb $0x0,0x123244
110ed5: 74 13 je 110eea <_RTEMS_tasks_Create_extension+0x86>
110ed7: 31 d2 xor %edx,%edx
110ed9: 8d 76 00 lea 0x0(%esi),%esi
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
api->Notepads[i] = 0;
110edc: c7 44 90 20 00 00 00 movl $0x0,0x20(%eax,%edx,4)
110ee3: 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++)
110ee4: 42 inc %edx
110ee5: 83 fa 10 cmp $0x10,%edx
110ee8: 75 f2 jne 110edc <_RTEMS_tasks_Create_extension+0x78>
api->Notepads[i] = 0;
}
return true;
110eea: b0 01 mov $0x1,%al
}
110eec: 8b 5d fc mov -0x4(%ebp),%ebx
110eef: c9 leave
110ef0: c3 ret
110ef1: 8d 76 00 lea 0x0(%esi),%esi
to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));
api = _Workspace_Allocate( to_allocate );
if ( !api )
return false;
110ef4: 31 c0 xor %eax,%eax
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
api->Notepads[i] = 0;
}
return true;
}
110ef6: 8b 5d fc mov -0x4(%ebp),%ebx
110ef9: c9 leave
110efa: c3 ret
00110e0c <_RTEMS_tasks_Delete_extension>:
void _RTEMS_tasks_Delete_extension(
Thread_Control *executing,
Thread_Control *deleted
)
{
110e0c: 55 push %ebp
110e0d: 89 e5 mov %esp,%ebp
110e0f: 56 push %esi
110e10: 53 push %ebx
110e11: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
110e14: 8b 83 f4 00 00 00 mov 0xf4(%ebx),%eax
deleted->task_variables = NULL;
110e1a: c7 83 f4 00 00 00 00 movl $0x0,0xf4(%ebx)
110e21: 00 00 00
while (tvp) {
110e24: 85 c0 test %eax,%eax
110e26: 75 06 jne 110e2e <_RTEMS_tasks_Delete_extension+0x22>
110e28: eb 17 jmp 110e41 <_RTEMS_tasks_Delete_extension+0x35>
110e2a: 66 90 xchg %ax,%ax
next = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
tvp = next;
110e2c: 89 f0 mov %esi,%eax
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
next = (rtems_task_variable_t *)tvp->next;
110e2e: 8b 30 mov (%eax),%esi
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
110e30: 83 ec 08 sub $0x8,%esp
110e33: 50 push %eax
110e34: 53 push %ebx
110e35: e8 56 01 00 00 call 110f90 <_RTEMS_Tasks_Invoke_task_variable_dtor>
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
110e3a: 83 c4 10 add $0x10,%esp
110e3d: 85 f6 test %esi,%esi
110e3f: 75 eb jne 110e2c <_RTEMS_tasks_Delete_extension+0x20>
/*
* Free API specific memory
*/
(void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] );
110e41: 83 ec 0c sub $0xc,%esp
110e44: ff b3 e8 00 00 00 pushl 0xe8(%ebx)
110e4a: e8 2d db ff ff call 10e97c <_Workspace_Free>
deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL;
110e4f: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx)
110e56: 00 00 00
110e59: 83 c4 10 add $0x10,%esp
}
110e5c: 8d 65 f8 lea -0x8(%ebp),%esp
110e5f: 5b pop %ebx
110e60: 5e pop %esi
110e61: c9 leave
110e62: c3 ret
00110d90 <_RTEMS_tasks_Initialize_user_tasks>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks( void )
{
110d90: 55 push %ebp
110d91: 89 e5 mov %esp,%ebp
110d93: 83 ec 08 sub $0x8,%esp
if ( _RTEMS_tasks_Initialize_user_tasks_p )
110d96: a1 c4 32 12 00 mov 0x1232c4,%eax
110d9b: 85 c0 test %eax,%eax
110d9d: 74 05 je 110da4 <_RTEMS_tasks_Initialize_user_tasks+0x14>
(*_RTEMS_tasks_Initialize_user_tasks_p)();
}
110d9f: c9 leave
*/
void _RTEMS_tasks_Initialize_user_tasks( void )
{
if ( _RTEMS_tasks_Initialize_user_tasks_p )
(*_RTEMS_tasks_Initialize_user_tasks_p)();
110da0: ff e0 jmp *%eax
110da2: 66 90 xchg %ax,%ax
}
110da4: c9 leave
110da5: 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 32 12 00 mov 0x12326c,%ebx
maximum = Configuration_RTEMS_API.number_of_initialization_tasks;
10ba8f: 8b 3d 68 32 12 00 mov 0x123268,%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 06 0e 00 00 call 10c8f8 <_Internal_error_Occurred>
00110d48 <_RTEMS_tasks_Switch_extension>:
void _RTEMS_tasks_Switch_extension(
Thread_Control *executing,
Thread_Control *heir
)
{
110d48: 55 push %ebp
110d49: 89 e5 mov %esp,%ebp
/*
* Per Task Variables
*/
tvp = executing->task_variables;
110d4b: 8b 45 08 mov 0x8(%ebp),%eax
110d4e: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
while (tvp) {
110d54: 85 c0 test %eax,%eax
110d56: 74 13 je 110d6b <_RTEMS_tasks_Switch_extension+0x23>
tvp->tval = *tvp->ptr;
110d58: 8b 50 04 mov 0x4(%eax),%edx
110d5b: 8b 0a mov (%edx),%ecx
110d5d: 89 48 0c mov %ecx,0xc(%eax)
*tvp->ptr = tvp->gval;
110d60: 8b 48 08 mov 0x8(%eax),%ecx
110d63: 89 0a mov %ecx,(%edx)
tvp = (rtems_task_variable_t *)tvp->next;
110d65: 8b 00 mov (%eax),%eax
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
110d67: 85 c0 test %eax,%eax
110d69: 75 ed jne 110d58 <_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;
110d6b: 8b 45 0c mov 0xc(%ebp),%eax
110d6e: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
while (tvp) {
110d74: 85 c0 test %eax,%eax
110d76: 74 13 je 110d8b <_RTEMS_tasks_Switch_extension+0x43>
tvp->gval = *tvp->ptr;
110d78: 8b 50 04 mov 0x4(%eax),%edx
110d7b: 8b 0a mov (%edx),%ecx
110d7d: 89 48 08 mov %ecx,0x8(%eax)
*tvp->ptr = tvp->tval;
110d80: 8b 48 0c mov 0xc(%eax),%ecx
110d83: 89 0a mov %ecx,(%edx)
tvp = (rtems_task_variable_t *)tvp->next;
110d85: 8b 00 mov (%eax),%eax
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
110d87: 85 c0 test %eax,%eax
110d89: 75 ed jne 110d78 <_RTEMS_tasks_Switch_extension+0x30><== NEVER TAKEN
tvp->gval = *tvp->ptr;
*tvp->ptr = tvp->tval;
tvp = (rtems_task_variable_t *)tvp->next;
}
}
110d8b: c9 leave
110d8c: 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 9c 18 00 00 call 10dda4 <_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 b8 ae 12 00 cmp %esi,0x12aeb8
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 c8 a9 12 00 push $0x12a9c8
10c547: e8 cc 39 00 00 call 10ff18 <_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 c4 38 00 00 call 10fe1c <_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 e0 a7 12 00 push $0x12a7e0
10cabe: e8 79 1d 00 00 call 10e83c <_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 d0 a8 12 00 mov 0x12a8d0,%eax
10caf0: 48 dec %eax
10caf1: a3 d0 a8 12 00 mov %eax,0x12a8d0
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 dc a9 12 00 push $0x12a9dc
10cb1f: e8 d4 36 00 00 call 1101f8 <_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 33 24 00 00 call 10ef70 <_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 73 38 00 00 call 10fe1c <_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 3f 39 00 00 call 10fef4 <_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 fb 38 00 00 call 10fed0 <_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 24 38 00 00 call 10fe1c <_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 f0 38 00 00 call 10fef4 <_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 b8 38 00 00 call 10fed0 <_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>
00111608 <_Scheduler_priority_Block>:
void _Scheduler_priority_Block(
Scheduler_Control *the_scheduler,
Thread_Control *the_thread
)
{
111608: 55 push %ebp
111609: 89 e5 mov %esp,%ebp
11160b: 53 push %ebx
11160c: 8b 45 0c mov 0xc(%ebp),%eax
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_extract(
Thread_Control *the_thread
)
{
Chain_Control *ready = the_thread->scheduler.priority->ready_chain;
11160f: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx
111615: 8b 12 mov (%edx),%edx
if ( _Chain_Has_only_one_node( ready ) ) {
111617: 8b 4a 08 mov 0x8(%edx),%ecx
11161a: 39 0a cmp %ecx,(%edx)
11161c: 74 6e je 11168c <_Scheduler_priority_Block+0x84>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
11161e: 8b 08 mov (%eax),%ecx
previous = the_node->previous;
111620: 8b 50 04 mov 0x4(%eax),%edx
next->previous = previous;
111623: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
111626: 89 0a mov %ecx,(%edx)
{
_Scheduler_priority_Ready_queue_extract(the_thread);
/* TODO: flash critical section */
if ( _Thread_Is_heir( the_thread ) )
111628: 3b 05 5c 7b 12 00 cmp 0x127b5c,%eax
11162e: 74 18 je 111648 <_Scheduler_priority_Block+0x40>
_Scheduler_priority_Schedule_body(the_scheduler);
if ( _Thread_Is_executing( the_thread ) )
111630: 3b 05 58 7b 12 00 cmp 0x127b58,%eax
111636: 74 04 je 11163c <_Scheduler_priority_Block+0x34>
_Scheduler_priority_Block_body(the_scheduler, the_thread);
}
111638: 5b pop %ebx
111639: c9 leave
11163a: c3 ret
11163b: 90 nop
_Thread_Dispatch_necessary = true;
11163c: c6 05 64 7b 12 00 01 movb $0x1,0x127b64
111643: 5b pop %ebx
111644: c9 leave
111645: c3 ret
111646: 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 );
111648: 66 8b 1d 80 7b 12 00 mov 0x127b80,%bx
11164f: 31 d2 xor %edx,%edx
111651: 89 d1 mov %edx,%ecx
111653: 66 0f bc cb bsf %bx,%cx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
111657: 0f b7 c9 movzwl %cx,%ecx
11165a: 66 8b 9c 09 a0 7b 12 mov 0x127ba0(%ecx,%ecx,1),%bx
111661: 00
111662: 66 0f bc d3 bsf %bx,%dx
return (_Priority_Bits_index( major ) << 4) +
111666: c1 e1 04 shl $0x4,%ecx
111669: 0f b7 d2 movzwl %dx,%edx
11166c: 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 ] ) )
11166f: 8d 14 52 lea (%edx,%edx,2),%edx
111672: c1 e2 02 shl $0x2,%edx
111675: 8b 4d 08 mov 0x8(%ebp),%ecx
111678: 03 11 add (%ecx),%edx
11167a: 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 );
11167c: 83 c2 04 add $0x4,%edx
11167f: 39 d1 cmp %edx,%ecx
111681: 74 4d je 1116d0 <_Scheduler_priority_Block+0xc8><== NEVER TAKEN
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(
Scheduler_Control *the_scheduler
)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
111683: 89 0d 5c 7b 12 00 mov %ecx,0x127b5c
111689: eb a5 jmp 111630 <_Scheduler_priority_Block+0x28>
11168b: 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 );
11168c: 8d 4a 04 lea 0x4(%edx),%ecx
11168f: 89 0a mov %ecx,(%edx)
head->next = tail;
head->previous = NULL;
111691: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
tail->previous = head;
111698: 89 52 08 mov %edx,0x8(%edx)
{
Chain_Control *ready = the_thread->scheduler.priority->ready_chain;
if ( _Chain_Has_only_one_node( ready ) ) {
_Chain_Initialize_empty( ready );
_Priority_bit_map_Remove( &the_thread->scheduler.priority->Priority_map );
11169b: 8b 88 8c 00 00 00 mov 0x8c(%eax),%ecx
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor &= the_priority_map->block_minor;
1116a1: 8b 59 04 mov 0x4(%ecx),%ebx
1116a4: 66 8b 13 mov (%ebx),%dx
1116a7: 66 23 51 0e and 0xe(%ecx),%dx
1116ab: 66 89 13 mov %dx,(%ebx)
if ( *the_priority_map->minor == 0 )
1116ae: 66 85 d2 test %dx,%dx
1116b1: 0f 85 71 ff ff ff jne 111628 <_Scheduler_priority_Block+0x20>
_Priority_Major_bit_map &= the_priority_map->block_major;
1116b7: 66 8b 15 80 7b 12 00 mov 0x127b80,%dx
1116be: 23 51 0c and 0xc(%ecx),%edx
1116c1: 66 89 15 80 7b 12 00 mov %dx,0x127b80
1116c8: e9 5b ff ff ff jmp 111628 <_Scheduler_priority_Block+0x20>
1116cd: 8d 76 00 lea 0x0(%esi),%esi
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;
1116d0: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
1116d2: eb af jmp 111683 <_Scheduler_priority_Block+0x7b><== NOT EXECUTED
0010d238 <_Scheduler_priority_Schedule>:
*/
void _Scheduler_priority_Schedule(
Scheduler_Control *the_scheduler
)
{
10d238: 55 push %ebp
10d239: 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 );
10d23b: 66 8b 0d 80 7b 12 00 mov 0x127b80,%cx
10d242: 31 c0 xor %eax,%eax
10d244: 89 c2 mov %eax,%edx
10d246: 66 0f bc d1 bsf %cx,%dx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10d24a: 0f b7 d2 movzwl %dx,%edx
10d24d: 66 8b 8c 12 a0 7b 12 mov 0x127ba0(%edx,%edx,1),%cx
10d254: 00
10d255: 66 0f bc c1 bsf %cx,%ax
return (_Priority_Bits_index( major ) << 4) +
10d259: c1 e2 04 shl $0x4,%edx
10d25c: 0f b7 c0 movzwl %ax,%eax
10d25f: 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 ] ) )
10d262: 8d 04 40 lea (%eax,%eax,2),%eax
10d265: c1 e0 02 shl $0x2,%eax
10d268: 8b 55 08 mov 0x8(%ebp),%edx
10d26b: 03 02 add (%edx),%eax
_Scheduler_priority_Schedule_body( the_scheduler );
}
10d26d: 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 );
10d26f: 83 c0 04 add $0x4,%eax
10d272: 39 c2 cmp %eax,%edx
10d274: 74 0a je 10d280 <_Scheduler_priority_Schedule+0x48><== NEVER TAKEN
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(
Scheduler_Control *the_scheduler
)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10d276: 89 15 5c 7b 12 00 mov %edx,0x127b5c
10d27c: c9 leave
10d27d: c3 ret
10d27e: 66 90 xchg %ax,%ax
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;
10d280: 31 d2 xor %edx,%edx <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(
Scheduler_Control *the_scheduler
)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10d282: 89 15 5c 7b 12 00 mov %edx,0x127b5c <== NOT EXECUTED
10d288: c9 leave <== NOT EXECUTED
10d289: c3 ret <== NOT EXECUTED
0010d318 <_Scheduler_priority_Unblock>:
void _Scheduler_priority_Unblock (
Scheduler_Control *the_scheduler,
Thread_Control *the_thread
)
{
10d318: 55 push %ebp
10d319: 89 e5 mov %esp,%ebp
10d31b: 53 push %ebx
10d31c: 8b 45 0c mov 0xc(%ebp),%eax
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_enqueue(
Thread_Control *the_thread
)
{
_Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map );
10d31f: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
10d325: 8b 4a 04 mov 0x4(%edx),%ecx
10d328: 66 8b 5a 0a mov 0xa(%edx),%bx
10d32c: 66 09 19 or %bx,(%ecx)
_Priority_Major_bit_map |= the_priority_map->ready_major;
10d32f: 66 8b 0d 80 7b 12 00 mov 0x127b80,%cx
10d336: 0b 4a 08 or 0x8(%edx),%ecx
10d339: 66 89 0d 80 7b 12 00 mov %cx,0x127b80
_Chain_Append_unprotected( the_thread->scheduler.priority->ready_chain,
10d340: 8b 12 mov (%edx),%edx
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
10d342: 8b 4a 08 mov 0x8(%edx),%ecx
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
10d345: 8d 5a 04 lea 0x4(%edx),%ebx
10d348: 89 18 mov %ebx,(%eax)
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
10d34a: 89 42 08 mov %eax,0x8(%edx)
old_last->next = the_node;
10d34d: 89 01 mov %eax,(%ecx)
the_node->previous = old_last;
10d34f: 89 48 04 mov %ecx,0x4(%eax)
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
10d352: 8b 50 14 mov 0x14(%eax),%edx
10d355: 8b 0d 5c 7b 12 00 mov 0x127b5c,%ecx
10d35b: 3b 51 14 cmp 0x14(%ecx),%edx
10d35e: 73 17 jae 10d377 <_Scheduler_priority_Unblock+0x5f>
_Thread_Heir = the_thread;
10d360: a3 5c 7b 12 00 mov %eax,0x127b5c
if ( _Thread_Executing->is_preemptible ||
10d365: a1 58 7b 12 00 mov 0x127b58,%eax
10d36a: 80 78 74 00 cmpb $0x0,0x74(%eax)
10d36e: 74 0c je 10d37c <_Scheduler_priority_Unblock+0x64>
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
10d370: c6 05 64 7b 12 00 01 movb $0x1,0x127b64
_Scheduler_priority_Unblock_body(the_scheduler, the_thread);
}
10d377: 5b pop %ebx
10d378: c9 leave
10d379: c3 ret
10d37a: 66 90 xchg %ax,%ax
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
10d37c: 85 d2 test %edx,%edx
10d37e: 75 f7 jne 10d377 <_Scheduler_priority_Unblock+0x5f>
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
10d380: c6 05 64 7b 12 00 01 movb $0x1,0x127b64
10d387: eb ee jmp 10d377 <_Scheduler_priority_Unblock+0x5f>
0010d38c <_Scheduler_priority_Yield>:
*/
void _Scheduler_priority_Yield(
Scheduler_Control *the_scheduler __attribute__((unused))
)
{
10d38c: 55 push %ebp
10d38d: 89 e5 mov %esp,%ebp
10d38f: 56 push %esi
10d390: 53 push %ebx
ISR_Level level;
Thread_Control *executing;
Chain_Control *ready;
executing = _Thread_Executing;
10d391: a1 58 7b 12 00 mov 0x127b58,%eax
ready = executing->scheduler.priority->ready_chain;
10d396: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx
10d39c: 8b 12 mov (%edx),%edx
_ISR_Disable( level );
10d39e: 9c pushf
10d39f: fa cli
10d3a0: 59 pop %ecx
if ( !_Chain_Has_only_one_node( ready ) ) {
10d3a1: 8b 5a 08 mov 0x8(%edx),%ebx
10d3a4: 39 1a cmp %ebx,(%edx)
10d3a6: 74 40 je 10d3e8 <_Scheduler_priority_Yield+0x5c>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10d3a8: 8b 30 mov (%eax),%esi
previous = the_node->previous;
10d3aa: 8b 58 04 mov 0x4(%eax),%ebx
next->previous = previous;
10d3ad: 89 5e 04 mov %ebx,0x4(%esi)
previous->next = next;
10d3b0: 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;
10d3b2: 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 );
10d3b5: 8d 72 04 lea 0x4(%edx),%esi
10d3b8: 89 30 mov %esi,(%eax)
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
10d3ba: 89 42 08 mov %eax,0x8(%edx)
old_last->next = the_node;
10d3bd: 89 03 mov %eax,(%ebx)
the_node->previous = old_last;
10d3bf: 89 58 04 mov %ebx,0x4(%eax)
_Chain_Extract_unprotected( &executing->Object.Node );
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
10d3c2: 51 push %ecx
10d3c3: 9d popf
10d3c4: fa cli
if ( _Thread_Is_heir( executing ) )
10d3c5: 3b 05 5c 7b 12 00 cmp 0x127b5c,%eax
10d3cb: 74 0f je 10d3dc <_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;
10d3cd: c6 05 64 7b 12 00 01 movb $0x1,0x127b64
_ISR_Enable( level );
10d3d4: 51 push %ecx
10d3d5: 9d popf
}
10d3d6: 5b pop %ebx
10d3d7: 5e pop %esi
10d3d8: c9 leave
10d3d9: c3 ret
10d3da: 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 );
10d3dc: 8b 02 mov (%edx),%eax
10d3de: a3 5c 7b 12 00 mov %eax,0x127b5c
10d3e3: eb e8 jmp 10d3cd <_Scheduler_priority_Yield+0x41>
10d3e5: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Dispatch_necessary = true;
}
else if ( !_Thread_Is_heir( executing ) )
10d3e8: 3b 05 5c 7b 12 00 cmp 0x127b5c,%eax
10d3ee: 75 dd jne 10d3cd <_Scheduler_priority_Yield+0x41>
10d3f0: eb e2 jmp 10d3d4 <_Scheduler_priority_Yield+0x48>
0010dae0 <_TOD_Set>:
*/
void _TOD_Set(
const struct timespec *time
)
{
10dae0: 55 push %ebp
10dae1: 89 e5 mov %esp,%ebp
10dae3: 53 push %ebx
10dae4: 83 ec 04 sub $0x4,%esp
10dae7: 8b 5d 08 mov 0x8(%ebp),%ebx
10daea: a1 70 23 13 00 mov 0x132370,%eax
10daef: 40 inc %eax
10daf0: a3 70 23 13 00 mov %eax,0x132370
long seconds;
_Thread_Disable_dispatch();
_TOD_Deactivate();
seconds = _TOD_Seconds_since_epoch();
10daf5: a1 44 24 13 00 mov 0x132444,%eax
if ( time->tv_sec < seconds )
10dafa: 8b 13 mov (%ebx),%edx
10dafc: 39 d0 cmp %edx,%eax
10dafe: 7f 34 jg 10db34 <_TOD_Set+0x54>
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
_Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units );
10db00: 51 push %ecx
_Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec );
else
_Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - seconds );
10db01: 29 c2 sub %eax,%edx
10db03: 52 push %edx
10db04: 6a 00 push $0x0
10db06: 68 70 24 13 00 push $0x132470
10db0b: e8 e8 24 00 00 call 10fff8 <_Watchdog_Adjust>
10db10: 83 c4 10 add $0x10,%esp
/* POSIX format TOD (timespec) */
_Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );
10db13: 8b 03 mov (%ebx),%eax
10db15: a3 44 24 13 00 mov %eax,0x132444
10db1a: 8b 43 04 mov 0x4(%ebx),%eax
10db1d: a3 48 24 13 00 mov %eax,0x132448
_TOD_Is_set = true;
10db22: c6 05 84 23 13 00 01 movb $0x1,0x132384
_TOD_Activate();
_Thread_Enable_dispatch();
}
10db29: 8b 5d fc mov -0x4(%ebp),%ebx
10db2c: c9 leave
_Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );
_TOD_Is_set = true;
_TOD_Activate();
_Thread_Enable_dispatch();
10db2d: e9 42 15 00 00 jmp 10f074 <_Thread_Enable_dispatch>
10db32: 66 90 xchg %ax,%ax
10db34: 51 push %ecx
_TOD_Deactivate();
seconds = _TOD_Seconds_since_epoch();
if ( time->tv_sec < seconds )
_Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec );
10db35: 29 d0 sub %edx,%eax
10db37: 50 push %eax
10db38: 6a 01 push $0x1
10db3a: 68 70 24 13 00 push $0x132470
10db3f: e8 b4 24 00 00 call 10fff8 <_Watchdog_Adjust>
10db44: 83 c4 10 add $0x10,%esp
10db47: eb ca jmp 10db13 <_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 e0 3a 12 movzwl 0x123ae0(%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 14 3b 12 movzwl 0x123b14(%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 fa 3a 12 movzwl 0x123afa(%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 2c 62 12 00 mov 0x12622c,%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 54 3b 12 00 mov 0x123b54(,%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 20 3b 12 00 mov 0x123b20(,%eax,4),%eax
10c2e4: eb e8 jmp 10c2ce <_TOD_Validate+0x5a>
0010d440 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
10d440: 55 push %ebp
10d441: 89 e5 mov %esp,%ebp
10d443: 57 push %edi
10d444: 56 push %esi
10d445: 53 push %ebx
10d446: 83 ec 28 sub $0x28,%esp
10d449: 8b 5d 08 mov 0x8(%ebp),%ebx
10d44c: 8b 75 0c mov 0xc(%ebp),%esi
10d44f: 8a 45 10 mov 0x10(%ebp),%al
10d452: 88 45 e7 mov %al,-0x19(%ebp)
*/
/*
* Save original state
*/
original_state = the_thread->current_state;
10d455: 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 );
10d458: 53 push %ebx
10d459: e8 3a 0d 00 00 call 10e198 <_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 )
10d45e: 83 c4 10 add $0x10,%esp
10d461: 39 73 14 cmp %esi,0x14(%ebx)
10d464: 74 0d je 10d473 <_Thread_Change_priority+0x33>
_Thread_Set_priority( the_thread, new_priority );
10d466: 83 ec 08 sub $0x8,%esp
10d469: 56 push %esi
10d46a: 53 push %ebx
10d46b: e8 c4 0c 00 00 call 10e134 <_Thread_Set_priority>
10d470: 83 c4 10 add $0x10,%esp
_ISR_Disable( level );
10d473: 9c pushf
10d474: fa cli
10d475: 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;
10d476: 8b 43 10 mov 0x10(%ebx),%eax
if ( state != STATES_TRANSIENT ) {
10d479: 83 f8 04 cmp $0x4,%eax
10d47c: 74 26 je 10d4a4 <_Thread_Change_priority+0x64>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
10d47e: 83 e7 04 and $0x4,%edi
10d481: 74 15 je 10d498 <_Thread_Change_priority+0x58><== ALWAYS TAKEN
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
10d483: 56 push %esi
10d484: 9d popf
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10d485: a9 e0 be 03 00 test $0x3bee0,%eax
10d48a: 0f 85 94 00 00 00 jne 10d524 <_Thread_Change_priority+0xe4>
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
10d490: 8d 65 f4 lea -0xc(%ebp),%esp
10d493: 5b pop %ebx
10d494: 5e pop %esi
10d495: 5f pop %edi
10d496: c9 leave
10d497: c3 ret
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
10d498: 89 c2 mov %eax,%edx
10d49a: 83 e2 fb and $0xfffffffb,%edx
10d49d: 89 53 10 mov %edx,0x10(%ebx)
10d4a0: eb e1 jmp 10d483 <_Thread_Change_priority+0x43>
10d4a2: 66 90 xchg %ax,%ax
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
10d4a4: 83 e7 04 and $0x4,%edi
10d4a7: 75 40 jne 10d4e9 <_Thread_Change_priority+0xa9><== NEVER TAKEN
* Ready Queue with interrupts off.
*
* FIXME: hard-coded for priority scheduling. Might be ok since this
* function is specific to priority scheduling?
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
10d4a9: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
if ( prepend_it )
10d4b0: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
10d4b4: 0f 84 82 00 00 00 je 10d53c <_Thread_Change_priority+0xfc>
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_enqueue_first(
Thread_Control *the_thread
)
{
_Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map );
10d4ba: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
10d4c0: 8b 50 04 mov 0x4(%eax),%edx
10d4c3: 66 8b 48 0a mov 0xa(%eax),%cx
10d4c7: 66 09 0a or %cx,(%edx)
_Priority_Major_bit_map |= the_priority_map->ready_major;
10d4ca: 66 8b 15 80 7b 12 00 mov 0x127b80,%dx
10d4d1: 0b 50 08 or 0x8(%eax),%edx
10d4d4: 66 89 15 80 7b 12 00 mov %dx,0x127b80
_Chain_Prepend_unprotected( the_thread->scheduler.priority->ready_chain,
10d4db: 8b 00 mov (%eax),%eax
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10d4dd: 89 43 04 mov %eax,0x4(%ebx)
before_node = after_node->next;
10d4e0: 8b 10 mov (%eax),%edx
after_node->next = the_node;
10d4e2: 89 18 mov %ebx,(%eax)
the_node->next = before_node;
10d4e4: 89 13 mov %edx,(%ebx)
before_node->previous = the_node;
10d4e6: 89 5a 04 mov %ebx,0x4(%edx)
_Scheduler_priority_Ready_queue_enqueue_first( the_thread );
else
_Scheduler_priority_Ready_queue_enqueue( the_thread );
}
_ISR_Flash( level );
10d4e9: 56 push %esi
10d4ea: 9d popf
10d4eb: fa cli
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Schedule(
Scheduler_Control *the_scheduler
)
{
the_scheduler->Operations.schedule( the_scheduler );
10d4ec: 83 ec 0c sub $0xc,%esp
10d4ef: 68 20 76 12 00 push $0x127620
10d4f4: ff 15 24 76 12 00 call *0x127624
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
10d4fa: a1 58 7b 12 00 mov 0x127b58,%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(&_Scheduler);
if ( !_Thread_Is_executing_also_the_heir() &&
10d4ff: 83 c4 10 add $0x10,%esp
10d502: 3b 05 5c 7b 12 00 cmp 0x127b5c,%eax
10d508: 74 0d je 10d517 <_Thread_Change_priority+0xd7>
10d50a: 80 78 74 00 cmpb $0x0,0x74(%eax)
10d50e: 74 07 je 10d517 <_Thread_Change_priority+0xd7>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
10d510: c6 05 64 7b 12 00 01 movb $0x1,0x127b64
_ISR_Enable( level );
10d517: 56 push %esi
10d518: 9d popf
}
10d519: 8d 65 f4 lea -0xc(%ebp),%esp
10d51c: 5b pop %ebx
10d51d: 5e pop %esi
10d51e: 5f pop %edi
10d51f: c9 leave
10d520: c3 ret
10d521: 8d 76 00 lea 0x0(%esi),%esi
/* 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 );
10d524: 89 5d 0c mov %ebx,0xc(%ebp)
10d527: 8b 43 44 mov 0x44(%ebx),%eax
10d52a: 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 );
}
10d52d: 8d 65 f4 lea -0xc(%ebp),%esp
10d530: 5b pop %ebx
10d531: 5e pop %esi
10d532: 5f pop %edi
10d533: 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 );
10d534: e9 63 0b 00 00 jmp 10e09c <_Thread_queue_Requeue>
10d539: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_enqueue(
Thread_Control *the_thread
)
{
_Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map );
10d53c: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
10d542: 8b 50 04 mov 0x4(%eax),%edx
10d545: 66 8b 48 0a mov 0xa(%eax),%cx
10d549: 66 09 0a or %cx,(%edx)
_Priority_Major_bit_map |= the_priority_map->ready_major;
10d54c: 66 8b 15 80 7b 12 00 mov 0x127b80,%dx
10d553: 0b 50 08 or 0x8(%eax),%edx
10d556: 66 89 15 80 7b 12 00 mov %dx,0x127b80
_Chain_Append_unprotected( the_thread->scheduler.priority->ready_chain,
10d55d: 8b 00 mov (%eax),%eax
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
10d55f: 8b 50 08 mov 0x8(%eax),%edx
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
10d562: 8d 48 04 lea 0x4(%eax),%ecx
10d565: 89 0b mov %ecx,(%ebx)
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
10d567: 89 58 08 mov %ebx,0x8(%eax)
old_last->next = the_node;
10d56a: 89 1a mov %ebx,(%edx)
the_node->previous = old_last;
10d56c: 89 53 04 mov %edx,0x4(%ebx)
10d56f: e9 75 ff ff ff jmp 10d4e9 <_Thread_Change_priority+0xa9>
0010d574 <_Thread_Clear_state>:
void _Thread_Clear_state(
Thread_Control *the_thread,
States_Control state
)
{
10d574: 55 push %ebp
10d575: 89 e5 mov %esp,%ebp
10d577: 53 push %ebx
10d578: 83 ec 04 sub $0x4,%esp
10d57b: 8b 55 08 mov 0x8(%ebp),%edx
10d57e: 8b 45 0c mov 0xc(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10d581: 9c pushf
10d582: fa cli
10d583: 5b pop %ebx
current_state = the_thread->current_state;
10d584: 8b 4a 10 mov 0x10(%edx),%ecx
if ( current_state & state ) {
10d587: 85 c8 test %ecx,%eax
10d589: 74 0b je 10d596 <_Thread_Clear_state+0x22>
10d58b: f7 d0 not %eax
10d58d: 21 c8 and %ecx,%eax
current_state =
the_thread->current_state = _States_Clear( state, current_state );
10d58f: 89 42 10 mov %eax,0x10(%edx)
if ( _States_Is_ready( current_state ) ) {
10d592: 85 c0 test %eax,%eax
10d594: 74 0a je 10d5a0 <_Thread_Clear_state+0x2c>
_Scheduler_Unblock( &_Scheduler, the_thread);
}
}
_ISR_Enable( level );
10d596: 53 push %ebx
10d597: 9d popf
}
10d598: 8b 5d fc mov -0x4(%ebp),%ebx
10d59b: c9 leave
10d59c: c3 ret
10d59d: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(
Scheduler_Control *the_scheduler,
Thread_Control *the_thread
)
{
the_scheduler->Operations.unblock( the_scheduler, the_thread );
10d5a0: 83 ec 08 sub $0x8,%esp
10d5a3: 52 push %edx
10d5a4: 68 20 76 12 00 push $0x127620
10d5a9: ff 15 30 76 12 00 call *0x127630
10d5af: 83 c4 10 add $0x10,%esp
10d5b2: eb e2 jmp 10d596 <_Thread_Clear_state+0x22>
0010d740 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10d740: 55 push %ebp
10d741: 89 e5 mov %esp,%ebp
10d743: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10d746: 8d 45 f4 lea -0xc(%ebp),%eax
10d749: 50 push %eax
10d74a: ff 75 08 pushl 0x8(%ebp)
10d74d: e8 c6 01 00 00 call 10d918 <_Thread_Get>
switch ( location ) {
10d752: 83 c4 10 add $0x10,%esp
10d755: 8b 55 f4 mov -0xc(%ebp),%edx
10d758: 85 d2 test %edx,%edx
10d75a: 75 1c jne 10d778 <_Thread_Delay_ended+0x38><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
10d75c: 83 ec 08 sub $0x8,%esp
10d75f: 68 18 00 00 10 push $0x10000018
10d764: 50 push %eax
10d765: e8 0a fe ff ff call 10d574 <_Thread_Clear_state>
10d76a: a1 70 75 12 00 mov 0x127570,%eax
10d76f: 48 dec %eax
10d770: a3 70 75 12 00 mov %eax,0x127570
10d775: 83 c4 10 add $0x10,%esp
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
10d778: c9 leave
10d779: c3 ret
0010d77c <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
10d77c: 55 push %ebp
10d77d: 89 e5 mov %esp,%ebp
10d77f: 57 push %edi
10d780: 56 push %esi
10d781: 53 push %ebx
10d782: 83 ec 1c sub $0x1c,%esp
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
10d785: 8b 1d 58 7b 12 00 mov 0x127b58,%ebx
_ISR_Disable( level );
10d78b: 9c pushf
10d78c: fa cli
10d78d: 58 pop %eax
while ( _Thread_Dispatch_necessary == true ) {
10d78e: 8a 15 64 7b 12 00 mov 0x127b64,%dl
10d794: 84 d2 test %dl,%dl
10d796: 0f 84 3c 01 00 00 je 10d8d8 <_Thread_Dispatch+0x15c>
heir = _Thread_Heir;
10d79c: 8b 35 5c 7b 12 00 mov 0x127b5c,%esi
_Thread_Dispatch_disable_level = 1;
10d7a2: c7 05 70 75 12 00 01 movl $0x1,0x127570
10d7a9: 00 00 00
_Thread_Dispatch_necessary = false;
10d7ac: c6 05 64 7b 12 00 00 movb $0x0,0x127b64
_Thread_Executing = heir;
10d7b3: 89 35 58 7b 12 00 mov %esi,0x127b58
/*
* 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 )
10d7b9: 39 f3 cmp %esi,%ebx
10d7bb: 0f 84 17 01 00 00 je 10d8d8 <_Thread_Dispatch+0x15c>
10d7c1: 8d 7d d8 lea -0x28(%ebp),%edi
10d7c4: e9 f5 00 00 00 jmp 10d8be <_Thread_Dispatch+0x142>
10d7c9: 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 );
10d7cc: 50 push %eax
10d7cd: 9d popf
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
10d7ce: 83 ec 0c sub $0xc,%esp
10d7d1: 8d 45 e0 lea -0x20(%ebp),%eax
10d7d4: 50 push %eax
10d7d5: e8 b6 3a 00 00 call 111290 <_TOD_Get_uptime>
_Timestamp_Subtract(
10d7da: 83 c4 0c add $0xc,%esp
10d7dd: 57 push %edi
10d7de: 8d 45 e0 lea -0x20(%ebp),%eax
10d7e1: 50 push %eax
10d7e2: 68 68 76 12 00 push $0x127668
10d7e7: e8 2c 0c 00 00 call 10e418 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
10d7ec: 58 pop %eax
10d7ed: 5a pop %edx
10d7ee: 57 push %edi
10d7ef: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax
10d7f5: 50 push %eax
10d7f6: e8 e1 0b 00 00 call 10e3dc <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
10d7fb: 8b 45 e0 mov -0x20(%ebp),%eax
10d7fe: 8b 55 e4 mov -0x1c(%ebp),%edx
10d801: a3 68 76 12 00 mov %eax,0x127668
10d806: 89 15 6c 76 12 00 mov %edx,0x12766c
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
10d80c: a1 40 76 12 00 mov 0x127640,%eax
10d811: 83 c4 10 add $0x10,%esp
10d814: 85 c0 test %eax,%eax
10d816: 74 10 je 10d828 <_Thread_Dispatch+0xac> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
10d818: 8b 10 mov (%eax),%edx
10d81a: 89 93 e4 00 00 00 mov %edx,0xe4(%ebx)
*_Thread_libc_reent = heir->libc_reent;
10d820: 8b 96 e4 00 00 00 mov 0xe4(%esi),%edx
10d826: 89 10 mov %edx,(%eax)
}
_User_extensions_Thread_switch( executing, heir );
10d828: 83 ec 08 sub $0x8,%esp
10d82b: 56 push %esi
10d82c: 53 push %ebx
10d82d: e8 86 0e 00 00 call 10e6b8 <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
10d832: 5a pop %edx
10d833: 59 pop %ecx
10d834: 81 c6 c8 00 00 00 add $0xc8,%esi
10d83a: 56 push %esi
10d83b: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax
10d841: 50 push %eax
10d842: e8 79 11 00 00 call 10e9c0 <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
10d847: 83 c4 10 add $0x10,%esp
10d84a: 8b 83 e0 00 00 00 mov 0xe0(%ebx),%eax
10d850: 85 c0 test %eax,%eax
10d852: 74 36 je 10d88a <_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 );
10d854: a1 00 76 12 00 mov 0x127600,%eax
10d859: 39 c3 cmp %eax,%ebx
10d85b: 74 2d je 10d88a <_Thread_Dispatch+0x10e>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
10d85d: 85 c0 test %eax,%eax
10d85f: 74 11 je 10d872 <_Thread_Dispatch+0xf6>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10d861: 83 ec 0c sub $0xc,%esp
10d864: 05 e0 00 00 00 add $0xe0,%eax
10d869: 50 push %eax
10d86a: e8 85 11 00 00 call 10e9f4 <_CPU_Context_save_fp>
10d86f: 83 c4 10 add $0x10,%esp
_Context_Restore_fp( &executing->fp_context );
10d872: 83 ec 0c sub $0xc,%esp
10d875: 8d 83 e0 00 00 00 lea 0xe0(%ebx),%eax
10d87b: 50 push %eax
10d87c: e8 7d 11 00 00 call 10e9fe <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
10d881: 89 1d 00 76 12 00 mov %ebx,0x127600
10d887: 83 c4 10 add $0x10,%esp
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
10d88a: 8b 1d 58 7b 12 00 mov 0x127b58,%ebx
_ISR_Disable( level );
10d890: 9c pushf
10d891: fa cli
10d892: 58 pop %eax
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10d893: 8a 15 64 7b 12 00 mov 0x127b64,%dl
10d899: 84 d2 test %dl,%dl
10d89b: 74 3b je 10d8d8 <_Thread_Dispatch+0x15c>
heir = _Thread_Heir;
10d89d: 8b 35 5c 7b 12 00 mov 0x127b5c,%esi
_Thread_Dispatch_disable_level = 1;
10d8a3: c7 05 70 75 12 00 01 movl $0x1,0x127570
10d8aa: 00 00 00
_Thread_Dispatch_necessary = false;
10d8ad: c6 05 64 7b 12 00 00 movb $0x0,0x127b64
_Thread_Executing = heir;
10d8b4: 89 35 58 7b 12 00 mov %esi,0x127b58
/*
* 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 )
10d8ba: 39 de cmp %ebx,%esi
10d8bc: 74 1a je 10d8d8 <_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 )
10d8be: 83 7e 7c 01 cmpl $0x1,0x7c(%esi)
10d8c2: 0f 85 04 ff ff ff jne 10d7cc <_Thread_Dispatch+0x50>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
10d8c8: 8b 15 40 75 12 00 mov 0x127540,%edx
10d8ce: 89 56 78 mov %edx,0x78(%esi)
10d8d1: e9 f6 fe ff ff jmp 10d7cc <_Thread_Dispatch+0x50>
10d8d6: 66 90 xchg %ax,%ax
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
10d8d8: c7 05 70 75 12 00 00 movl $0x0,0x127570
10d8df: 00 00 00
_ISR_Enable( level );
10d8e2: 50 push %eax
10d8e3: 9d popf
_API_extensions_Run_postswitch();
10d8e4: e8 eb e5 ff ff call 10bed4 <_API_extensions_Run_postswitch>
}
10d8e9: 8d 65 f4 lea -0xc(%ebp),%esp
10d8ec: 5b pop %ebx
10d8ed: 5e pop %esi
10d8ee: 5f pop %edi
10d8ef: c9 leave
10d8f0: c3 ret
0010d918 <_Thread_Get>:
*/
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
10d918: 55 push %ebp
10d919: 89 e5 mov %esp,%ebp
10d91b: 53 push %ebx
10d91c: 83 ec 04 sub $0x4,%esp
10d91f: 8b 45 08 mov 0x8(%ebp),%eax
10d922: 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 ) ) {
10d925: 85 c0 test %eax,%eax
10d927: 74 47 je 10d970 <_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);
10d929: 89 c2 mov %eax,%edx
10d92b: c1 ea 18 shr $0x18,%edx
10d92e: 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 )
10d931: 8d 5a ff lea -0x1(%edx),%ebx
10d934: 83 fb 02 cmp $0x2,%ebx
10d937: 77 27 ja 10d960 <_Thread_Get+0x48>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10d939: 89 c3 mov %eax,%ebx
10d93b: 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 :) */
10d93e: 4b dec %ebx
10d93f: 75 1f jne 10d960 <_Thread_Get+0x48>
*location = OBJECTS_ERROR;
goto done;
}
#endif
information = api_information[ the_class ];
10d941: 8b 14 95 48 75 12 00 mov 0x127548(,%edx,4),%edx
10d948: 8b 52 04 mov 0x4(%edx),%edx
if ( !information ) {
10d94b: 85 d2 test %edx,%edx
10d94d: 74 11 je 10d960 <_Thread_Get+0x48>
*location = OBJECTS_ERROR;
goto done;
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
10d94f: 53 push %ebx
10d950: 51 push %ecx
10d951: 50 push %eax
10d952: 52 push %edx
10d953: e8 e8 f4 ff ff call 10ce40 <_Objects_Get>
10d958: 83 c4 10 add $0x10,%esp
done:
return tp;
}
10d95b: 8b 5d fc mov -0x4(%ebp),%ebx
10d95e: c9 leave
10d95f: c3 ret
}
#endif
information = api_information[ the_class ];
if ( !information ) {
*location = OBJECTS_ERROR;
10d960: 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;
10d966: 31 c0 xor %eax,%eax
tp = (Thread_Control *) _Objects_Get( information, id, location );
done:
return tp;
}
10d968: 8b 5d fc mov -0x4(%ebp),%ebx
10d96b: c9 leave
10d96c: c3 ret
10d96d: 8d 76 00 lea 0x0(%esi),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10d970: a1 70 75 12 00 mov 0x127570,%eax
10d975: 40 inc %eax
10d976: a3 70 75 12 00 mov %eax,0x127570
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;
10d97b: c7 01 00 00 00 00 movl $0x0,(%ecx)
tp = _Thread_Executing;
10d981: a1 58 7b 12 00 mov 0x127b58,%eax
tp = (Thread_Control *) _Objects_Get( information, id, location );
done:
return tp;
}
10d986: 8b 5d fc mov -0x4(%ebp),%ebx
10d989: c9 leave
10d98a: c3 ret
0011314c <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
11314c: 55 push %ebp
11314d: 89 e5 mov %esp,%ebp
11314f: 53 push %ebx
113150: 83 ec 14 sub $0x14,%esp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
113153: 8b 1d 58 7b 12 00 mov 0x127b58,%ebx
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
113159: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax
_ISR_Set_level(level);
11315f: 85 c0 test %eax,%eax
113161: 74 79 je 1131dc <_Thread_Handler+0x90>
113163: fa cli
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
113164: a0 ec 71 12 00 mov 0x1271ec,%al
113169: 88 45 f7 mov %al,-0x9(%ebp)
doneConstructors = 1;
11316c: c6 05 ec 71 12 00 01 movb $0x1,0x1271ec
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
113173: 8b 83 e0 00 00 00 mov 0xe0(%ebx),%eax
113179: 85 c0 test %eax,%eax
11317b: 74 24 je 1131a1 <_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 );
11317d: a1 00 76 12 00 mov 0x127600,%eax
113182: 39 c3 cmp %eax,%ebx
113184: 74 1b je 1131a1 <_Thread_Handler+0x55>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
113186: 85 c0 test %eax,%eax
113188: 74 11 je 11319b <_Thread_Handler+0x4f>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
11318a: 83 ec 0c sub $0xc,%esp
11318d: 05 e0 00 00 00 add $0xe0,%eax
113192: 50 push %eax
113193: e8 5c b8 ff ff call 10e9f4 <_CPU_Context_save_fp>
113198: 83 c4 10 add $0x10,%esp
_Thread_Allocated_fp = executing;
11319b: 89 1d 00 76 12 00 mov %ebx,0x127600
/*
* 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 );
1131a1: 83 ec 0c sub $0xc,%esp
1131a4: 53 push %ebx
1131a5: e8 72 b3 ff ff call 10e51c <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
1131aa: e8 45 a7 ff ff call 10d8f4 <_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) */ {
1131af: 83 c4 10 add $0x10,%esp
1131b2: 80 7d f7 00 cmpb $0x0,-0x9(%ebp)
1131b6: 74 28 je 1131e0 <_Thread_Handler+0x94>
INIT_NAME ();
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
1131b8: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax
1131be: 85 c0 test %eax,%eax
1131c0: 74 2d je 1131ef <_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 ) {
1131c2: 48 dec %eax
1131c3: 74 43 je 113208 <_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 );
1131c5: 83 ec 0c sub $0xc,%esp
1131c8: 53 push %ebx
1131c9: e8 8a b3 ff ff call 10e558 <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
1131ce: 83 c4 0c add $0xc,%esp
1131d1: 6a 05 push $0x5
1131d3: 6a 01 push $0x1
1131d5: 6a 00 push $0x0
1131d7: e8 1c 97 ff ff call 10c8f8 <_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);
1131dc: fb sti
1131dd: eb 85 jmp 113164 <_Thread_Handler+0x18>
1131df: 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 ();
1131e0: e8 8b be 00 00 call 11f070 <__start_set_sysctl_set>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
1131e5: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax
1131eb: 85 c0 test %eax,%eax
1131ed: 75 d3 jne 1131c2 <_Thread_Handler+0x76>
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
1131ef: 83 ec 0c sub $0xc,%esp
1131f2: ff b3 9c 00 00 00 pushl 0x9c(%ebx)
1131f8: ff 93 90 00 00 00 call *0x90(%ebx)
INIT_NAME ();
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
executing->Wait.return_argument =
1131fe: 89 43 28 mov %eax,0x28(%ebx)
113201: 83 c4 10 add $0x10,%esp
113204: eb bf jmp 1131c5 <_Thread_Handler+0x79>
113206: 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)(
113208: 83 ec 0c sub $0xc,%esp
11320b: ff b3 98 00 00 00 pushl 0x98(%ebx)
113211: 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 =
113217: 89 43 28 mov %eax,0x28(%ebx)
11321a: 83 c4 10 add $0x10,%esp
11321d: eb a6 jmp 1131c5 <_Thread_Handler+0x79>
0010d98c <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
10d98c: 55 push %ebp
10d98d: 89 e5 mov %esp,%ebp
10d98f: 57 push %edi
10d990: 56 push %esi
10d991: 53 push %ebx
10d992: 83 ec 1c sub $0x1c,%esp
10d995: 8b 5d 0c mov 0xc(%ebp),%ebx
10d998: 8b 4d 10 mov 0x10(%ebp),%ecx
10d99b: 8b 75 14 mov 0x14(%ebp),%esi
10d99e: 8a 55 18 mov 0x18(%ebp),%dl
10d9a1: 0f b6 7d 20 movzbl 0x20(%ebp),%edi
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
10d9a5: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx)
10d9ac: 00 00 00
10d9af: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx)
10d9b6: 00 00 00
extensions_area = NULL;
the_thread->libc_reent = NULL;
10d9b9: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10d9c0: 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 ) {
10d9c3: 85 c9 test %ecx,%ecx
10d9c5: 0f 84 14 02 00 00 je 10dbdf <_Thread_Initialize+0x253>
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;
10d9cb: c6 83 b4 00 00 00 00 movb $0x0,0xb4(%ebx)
10d9d2: 89 f0 mov %esi,%eax
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
10d9d4: 89 8b bc 00 00 00 mov %ecx,0xbc(%ebx)
the_stack->size = size;
10d9da: 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 ) {
10d9e0: 84 d2 test %dl,%dl
10d9e2: 0f 85 94 01 00 00 jne 10db7c <_Thread_Initialize+0x1f0>
10d9e8: 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;
10d9ea: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%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;
10d9f1: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx)
the_thread->Start.fp_context = fp_area;
10d9f7: 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;
10d9fd: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10da04: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
the_watchdog->id = id;
10da0b: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
the_watchdog->user_data = user_data;
10da12: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10da19: a1 4c 76 12 00 mov 0x12764c,%eax
10da1e: 85 c0 test %eax,%eax
10da20: 0f 85 7a 01 00 00 jne 10dba0 <_Thread_Initialize+0x214>
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10da26: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx)
10da2d: 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;
10da30: 31 f6 xor %esi,%esi
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
10da32: 89 f8 mov %edi,%eax
10da34: 88 83 a0 00 00 00 mov %al,0xa0(%ebx)
the_thread->Start.budget_algorithm = budget_algorithm;
10da3a: 8b 45 24 mov 0x24(%ebp),%eax
10da3d: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
the_thread->Start.budget_callout = budget_callout;
10da43: 8b 45 28 mov 0x28(%ebp),%eax
10da46: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx)
switch ( budget_algorithm ) {
10da4c: 83 7d 24 02 cmpl $0x2,0x24(%ebp)
10da50: 75 08 jne 10da5a <_Thread_Initialize+0xce>
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;
10da52: a1 40 75 12 00 mov 0x127540,%eax
10da57: 89 43 78 mov %eax,0x78(%ebx)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
10da5a: 8b 45 2c mov 0x2c(%ebp),%eax
10da5d: 89 83 ac 00 00 00 mov %eax,0xac(%ebx)
the_thread->current_state = STATES_DORMANT;
10da63: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
the_thread->Wait.queue = NULL;
10da6a: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
the_thread->resource_count = 0;
10da71: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->real_priority = priority;
10da78: 8b 45 1c mov 0x1c(%ebp),%eax
10da7b: 89 43 18 mov %eax,0x18(%ebx)
the_thread->Start.initial_priority = priority;
10da7e: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx)
RTEMS_INLINE_ROUTINE void* _Scheduler_Thread_scheduler_allocate(
Scheduler_Control *the_scheduler,
Thread_Control *the_thread
)
{
return
10da84: 83 ec 08 sub $0x8,%esp
10da87: 53 push %ebx
10da88: 68 20 76 12 00 push $0x127620
10da8d: ff 15 34 76 12 00 call *0x127634
10da93: 89 c7 mov %eax,%edi
sched =_Scheduler_Thread_scheduler_allocate( &_Scheduler, the_thread );
if ( !sched )
10da95: 83 c4 10 add $0x10,%esp
10da98: 85 c0 test %eax,%eax
10da9a: 74 46 je 10dae2 <_Thread_Initialize+0x156>
goto failed;
_Thread_Set_priority( the_thread, priority );
10da9c: 83 ec 08 sub $0x8,%esp
10da9f: ff 75 1c pushl 0x1c(%ebp)
10daa2: 53 push %ebx
10daa3: e8 8c 06 00 00 call 10e134 <_Thread_Set_priority>
/*
* Initialize the CPU usage statistics
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
10daa8: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx)
10daaf: 00 00 00
10dab2: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx)
10dab9: 00 00 00
_Thread_Stack_Free( the_thread );
return false;
}
10dabc: 8b 45 08 mov 0x8(%ebp),%eax
10dabf: 8b 40 1c mov 0x1c(%eax),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10dac2: 0f b7 53 08 movzwl 0x8(%ebx),%edx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10dac6: 89 1c 90 mov %ebx,(%eax,%edx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10dac9: 8b 45 30 mov 0x30(%ebp),%eax
10dacc: 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 );
10dacf: 89 1c 24 mov %ebx,(%esp)
10dad2: e8 0d 0b 00 00 call 10e5e4 <_User_extensions_Thread_create>
if ( extension_status )
10dad7: 83 c4 10 add $0x10,%esp
10dada: 84 c0 test %al,%al
10dadc: 0f 85 8e 00 00 00 jne 10db70 <_Thread_Initialize+0x1e4>
return true;
failed:
if ( the_thread->libc_reent )
10dae2: 8b 83 e4 00 00 00 mov 0xe4(%ebx),%eax
10dae8: 85 c0 test %eax,%eax
10daea: 74 0c je 10daf8 <_Thread_Initialize+0x16c>
_Workspace_Free( the_thread->libc_reent );
10daec: 83 ec 0c sub $0xc,%esp
10daef: 50 push %eax
10daf0: e8 87 0e 00 00 call 10e97c <_Workspace_Free>
10daf5: 83 c4 10 add $0x10,%esp
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
if ( the_thread->API_Extensions[i] )
10daf8: 8b 83 e8 00 00 00 mov 0xe8(%ebx),%eax
10dafe: 85 c0 test %eax,%eax
10db00: 74 0c je 10db0e <_Thread_Initialize+0x182>
_Workspace_Free( the_thread->API_Extensions[i] );
10db02: 83 ec 0c sub $0xc,%esp
10db05: 50 push %eax
10db06: e8 71 0e 00 00 call 10e97c <_Workspace_Free>
10db0b: 83 c4 10 add $0x10,%esp
failed:
if ( the_thread->libc_reent )
_Workspace_Free( the_thread->libc_reent );
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
if ( the_thread->API_Extensions[i] )
10db0e: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax
10db14: 85 c0 test %eax,%eax
10db16: 74 0c je 10db24 <_Thread_Initialize+0x198>
_Workspace_Free( the_thread->API_Extensions[i] );
10db18: 83 ec 0c sub $0xc,%esp
10db1b: 50 push %eax
10db1c: e8 5b 0e 00 00 call 10e97c <_Workspace_Free>
10db21: 83 c4 10 add $0x10,%esp
if ( extensions_area )
10db24: 85 f6 test %esi,%esi
10db26: 74 0c je 10db34 <_Thread_Initialize+0x1a8>
(void) _Workspace_Free( extensions_area );
10db28: 83 ec 0c sub $0xc,%esp
10db2b: 56 push %esi
10db2c: e8 4b 0e 00 00 call 10e97c <_Workspace_Free>
10db31: 83 c4 10 add $0x10,%esp
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( fp_area )
10db34: 8b 45 e4 mov -0x1c(%ebp),%eax
10db37: 85 c0 test %eax,%eax
10db39: 74 0e je 10db49 <_Thread_Initialize+0x1bd>
(void) _Workspace_Free( fp_area );
10db3b: 83 ec 0c sub $0xc,%esp
10db3e: ff 75 e4 pushl -0x1c(%ebp)
10db41: e8 36 0e 00 00 call 10e97c <_Workspace_Free>
10db46: 83 c4 10 add $0x10,%esp
#endif
if ( sched )
10db49: 85 ff test %edi,%edi
10db4b: 74 0c je 10db59 <_Thread_Initialize+0x1cd>
(void) _Workspace_Free( sched );
10db4d: 83 ec 0c sub $0xc,%esp
10db50: 57 push %edi
10db51: e8 26 0e 00 00 call 10e97c <_Workspace_Free>
10db56: 83 c4 10 add $0x10,%esp
_Thread_Stack_Free( the_thread );
10db59: 83 ec 0c sub $0xc,%esp
10db5c: 53 push %ebx
10db5d: e8 0a 07 00 00 call 10e26c <_Thread_Stack_Free>
return false;
10db62: 83 c4 10 add $0x10,%esp
10db65: 31 c0 xor %eax,%eax
}
10db67: 8d 65 f4 lea -0xc(%ebp),%esp
10db6a: 5b pop %ebx
10db6b: 5e pop %esi
10db6c: 5f pop %edi
10db6d: c9 leave
10db6e: c3 ret
10db6f: 90 nop
* Mutex provides sufficient protection to let the user extensions
* run safely.
*/
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
return true;
10db70: b0 01 mov $0x1,%al
_Thread_Stack_Free( the_thread );
return false;
}
10db72: 8d 65 f4 lea -0xc(%ebp),%esp
10db75: 5b pop %ebx
10db76: 5e pop %esi
10db77: 5f pop %edi
10db78: c9 leave
10db79: c3 ret
10db7a: 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 );
10db7c: 83 ec 0c sub $0xc,%esp
10db7f: 6a 6c push $0x6c
10db81: e8 da 0d 00 00 call 10e960 <_Workspace_Allocate>
10db86: 89 45 e4 mov %eax,-0x1c(%ebp)
if ( !fp_area )
10db89: 83 c4 10 add $0x10,%esp
10db8c: 85 c0 test %eax,%eax
10db8e: 0f 85 5d fe ff ff jne 10d9f1 <_Thread_Initialize+0x65>
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
10db94: 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;
10db96: 31 ff xor %edi,%edi
10db98: e9 45 ff ff ff jmp 10dae2 <_Thread_Initialize+0x156>
10db9d: 8d 76 00 lea 0x0(%esi),%esi
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
extensions_area = _Workspace_Allocate(
10dba0: 83 ec 0c sub $0xc,%esp
10dba3: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax
10dbaa: 50 push %eax
10dbab: e8 b0 0d 00 00 call 10e960 <_Workspace_Allocate>
10dbb0: 89 c6 mov %eax,%esi
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
10dbb2: 83 c4 10 add $0x10,%esp
10dbb5: 85 c0 test %eax,%eax
10dbb7: 74 5a je 10dc13 <_Thread_Initialize+0x287>
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10dbb9: 89 83 f0 00 00 00 mov %eax,0xf0(%ebx)
10dbbf: 8b 0d 4c 76 12 00 mov 0x12764c,%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++ )
10dbc5: 31 d2 xor %edx,%edx
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10dbc7: 31 c0 xor %eax,%eax
10dbc9: 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;
10dbcc: 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++ )
10dbd3: 40 inc %eax
10dbd4: 89 c2 mov %eax,%edx
10dbd6: 39 c1 cmp %eax,%ecx
10dbd8: 73 f2 jae 10dbcc <_Thread_Initialize+0x240>
10dbda: e9 53 fe ff ff jmp 10da32 <_Thread_Initialize+0xa6>
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
10dbdf: 83 ec 08 sub $0x8,%esp
10dbe2: 56 push %esi
10dbe3: 53 push %ebx
10dbe4: 88 55 e0 mov %dl,-0x20(%ebp)
10dbe7: e8 1c 06 00 00 call 10e208 <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
10dbec: 83 c4 10 add $0x10,%esp
10dbef: 85 c0 test %eax,%eax
10dbf1: 8a 55 e0 mov -0x20(%ebp),%dl
10dbf4: 74 16 je 10dc0c <_Thread_Initialize+0x280>
10dbf6: 39 c6 cmp %eax,%esi
10dbf8: 77 12 ja 10dc0c <_Thread_Initialize+0x280><== NEVER TAKEN
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
10dbfa: 8b 8b c4 00 00 00 mov 0xc4(%ebx),%ecx
the_thread->Start.core_allocated_stack = true;
10dc00: c6 83 b4 00 00 00 01 movb $0x1,0xb4(%ebx)
10dc07: e9 c8 fd ff ff jmp 10d9d4 <_Thread_Initialize+0x48>
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 */
10dc0c: 31 c0 xor %eax,%eax
10dc0e: e9 54 ff ff ff jmp 10db67 <_Thread_Initialize+0x1db>
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;
10dc13: 31 ff xor %edi,%edi
10dc15: e9 c8 fe ff ff jmp 10dae2 <_Thread_Initialize+0x156>
00112610 <_Thread_Reset>:
void _Thread_Reset(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
112610: 55 push %ebp
112611: 89 e5 mov %esp,%ebp
112613: 53 push %ebx
112614: 83 ec 10 sub $0x10,%esp
112617: 8b 5d 08 mov 0x8(%ebp),%ebx
the_thread->resource_count = 0;
11261a: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->is_preemptible = the_thread->Start.is_preemptible;
112621: 8a 83 a0 00 00 00 mov 0xa0(%ebx),%al
112627: 88 43 74 mov %al,0x74(%ebx)
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
11262a: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax
112630: 89 43 7c mov %eax,0x7c(%ebx)
the_thread->budget_callout = the_thread->Start.budget_callout;
112633: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax
112639: 89 83 80 00 00 00 mov %eax,0x80(%ebx)
the_thread->Start.pointer_argument = pointer_argument;
11263f: 8b 45 0c mov 0xc(%ebp),%eax
112642: 89 83 98 00 00 00 mov %eax,0x98(%ebx)
the_thread->Start.numeric_argument = numeric_argument;
112648: 8b 45 10 mov 0x10(%ebp),%eax
11264b: 89 83 9c 00 00 00 mov %eax,0x9c(%ebx)
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
112651: 53 push %ebx
112652: e8 c5 c4 ff ff call 10eb1c <_Thread_queue_Extract_with_proxy>
112657: 83 c4 10 add $0x10,%esp
11265a: 84 c0 test %al,%al
11265c: 75 06 jne 112664 <_Thread_Reset+0x54>
if ( _Watchdog_Is_active( &the_thread->Timer ) )
11265e: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
112662: 74 28 je 11268c <_Thread_Reset+0x7c>
(void) _Watchdog_Remove( &the_thread->Timer );
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
112664: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax
11266a: 39 43 14 cmp %eax,0x14(%ebx)
11266d: 74 15 je 112684 <_Thread_Reset+0x74>
the_thread->real_priority = the_thread->Start.initial_priority;
11266f: 89 43 18 mov %eax,0x18(%ebx)
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
112672: 89 45 0c mov %eax,0xc(%ebp)
112675: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
112678: 8b 5d fc mov -0x4(%ebp),%ebx
11267b: 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 );
11267c: e9 77 c6 ff ff jmp 10ecf8 <_Thread_Set_priority>
112681: 8d 76 00 lea 0x0(%esi),%esi
}
}
112684: 8b 5d fc mov -0x4(%ebp),%ebx
112687: c9 leave
112688: c3 ret
112689: 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 );
11268c: 83 ec 0c sub $0xc,%esp
11268f: 8d 43 48 lea 0x48(%ebx),%eax
112692: 50 push %eax
112693: e8 a4 cd ff ff call 10f43c <_Watchdog_Remove>
112698: 83 c4 10 add $0x10,%esp
11269b: eb c7 jmp 112664 <_Thread_Reset+0x54>
0011146c <_Thread_Resume>:
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
11146c: 55 push %ebp
11146d: 89 e5 mov %esp,%ebp
11146f: 53 push %ebx
111470: 83 ec 04 sub $0x4,%esp
111473: 8b 45 08 mov 0x8(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
111476: 9c pushf
111477: fa cli
111478: 5b pop %ebx
current_state = the_thread->current_state;
111479: 8b 50 10 mov 0x10(%eax),%edx
if ( current_state & STATES_SUSPENDED ) {
11147c: f6 c2 02 test $0x2,%dl
11147f: 74 0a je 11148b <_Thread_Resume+0x1f> <== NEVER TAKEN
111481: 83 e2 fd and $0xfffffffd,%edx
current_state =
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
111484: 89 50 10 mov %edx,0x10(%eax)
if ( _States_Is_ready( current_state ) ) {
111487: 85 d2 test %edx,%edx
111489: 74 09 je 111494 <_Thread_Resume+0x28>
_Scheduler_Unblock( &_Scheduler, the_thread );
}
}
_ISR_Enable( level );
11148b: 53 push %ebx
11148c: 9d popf
}
11148d: 8b 5d fc mov -0x4(%ebp),%ebx
111490: c9 leave
111491: c3 ret
111492: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(
Scheduler_Control *the_scheduler,
Thread_Control *the_thread
)
{
the_scheduler->Operations.unblock( the_scheduler, the_thread );
111494: 83 ec 08 sub $0x8,%esp
111497: 50 push %eax
111498: 68 e0 af 12 00 push $0x12afe0
11149d: ff 15 f0 af 12 00 call *0x12aff0
1114a3: 83 c4 10 add $0x10,%esp
1114a6: eb e3 jmp 11148b <_Thread_Resume+0x1f>
0010e208 <_Thread_Stack_Allocate>:
size_t _Thread_Stack_Allocate(
Thread_Control *the_thread,
size_t stack_size
)
{
10e208: 55 push %ebp
10e209: 89 e5 mov %esp,%ebp
10e20b: 53 push %ebx
10e20c: 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;
10e20f: a1 70 32 12 00 mov 0x123270,%eax
10e214: 8b 5d 0c mov 0xc(%ebp),%ebx
10e217: 39 c3 cmp %eax,%ebx
10e219: 73 02 jae 10e21d <_Thread_Stack_Allocate+0x15>
10e21b: 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 ) {
10e21d: a1 a4 32 12 00 mov 0x1232a4,%eax
10e222: 85 c0 test %eax,%eax
10e224: 74 32 je 10e258 <_Thread_Stack_Allocate+0x50>
stack_addr = (*Configuration.stack_allocate_hook)( the_stack_size );
10e226: 83 ec 0c sub $0xc,%esp
10e229: 53 push %ebx
10e22a: ff d0 call *%eax
10e22c: 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 )
10e22f: 85 c0 test %eax,%eax
10e231: 74 11 je 10e244 <_Thread_Stack_Allocate+0x3c>
the_stack_size = 0;
the_thread->Start.stack = stack_addr;
10e233: 8b 55 08 mov 0x8(%ebp),%edx
10e236: 89 82 c4 00 00 00 mov %eax,0xc4(%edx)
return the_stack_size;
}
10e23c: 89 d8 mov %ebx,%eax
10e23e: 8b 5d fc mov -0x4(%ebp),%ebx
10e241: c9 leave
10e242: c3 ret
10e243: 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;
10e244: 31 db xor %ebx,%ebx
the_thread->Start.stack = stack_addr;
10e246: 8b 55 08 mov 0x8(%ebp),%edx
10e249: 89 82 c4 00 00 00 mov %eax,0xc4(%edx)
return the_stack_size;
}
10e24f: 89 d8 mov %ebx,%eax
10e251: 8b 5d fc mov -0x4(%ebp),%ebx
10e254: c9 leave
10e255: c3 ret
10e256: 66 90 xchg %ax,%ax
RTEMS_INLINE_ROUTINE uint32_t _Stack_Adjust_size (
size_t size
)
{
return size + CPU_STACK_ALIGNMENT;
10e258: 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 );
10e25b: 83 ec 0c sub $0xc,%esp
10e25e: 53 push %ebx
10e25f: e8 fc 06 00 00 call 10e960 <_Workspace_Allocate>
10e264: 83 c4 10 add $0x10,%esp
10e267: eb c6 jmp 10e22f <_Thread_Stack_Allocate+0x27>
0010e26c <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
10e26c: 55 push %ebp
10e26d: 89 e5 mov %esp,%ebp
10e26f: 83 ec 08 sub $0x8,%esp
10e272: 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 )
10e275: 80 b8 b4 00 00 00 00 cmpb $0x0,0xb4(%eax)
10e27c: 74 16 je 10e294 <_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 )
10e27e: 8b 15 a8 32 12 00 mov 0x1232a8,%edx
10e284: 85 d2 test %edx,%edx
10e286: 74 10 je 10e298 <_Thread_Stack_Free+0x2c>
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
10e288: 8b 80 bc 00 00 00 mov 0xbc(%eax),%eax
10e28e: 89 45 08 mov %eax,0x8(%ebp)
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
10e291: 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 );
10e292: ff e2 jmp *%edx
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
10e294: c9 leave
10e295: c3 ret
10e296: 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 );
10e298: 8b 80 bc 00 00 00 mov 0xbc(%eax),%eax
10e29e: 89 45 08 mov %eax,0x8(%ebp)
}
10e2a1: 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 );
10e2a2: e9 d5 06 00 00 jmp 10e97c <_Workspace_Free>
00111978 <_Thread_Suspend>:
*/
void _Thread_Suspend(
Thread_Control *the_thread
)
{
111978: 55 push %ebp
111979: 89 e5 mov %esp,%ebp
11197b: 53 push %ebx
11197c: 83 ec 04 sub $0x4,%esp
11197f: 8b 45 08 mov 0x8(%ebp),%eax
ISR_Level level;
_ISR_Disable( level );
111982: 9c pushf
111983: fa cli
111984: 5b pop %ebx
if ( !_States_Is_ready( the_thread->current_state ) ) {
111985: 8b 50 10 mov 0x10(%eax),%edx
111988: 85 d2 test %edx,%edx
11198a: 74 10 je 11199c <_Thread_Suspend+0x24>
11198c: 83 ca 02 or $0x2,%edx
11198f: 89 50 10 mov %edx,0x10(%eax)
the_thread->current_state =
_States_Set( STATES_SUSPENDED, the_thread->current_state );
_ISR_Enable( level );
111992: 53 push %ebx
111993: 9d popf
the_thread->current_state = STATES_SUSPENDED;
_Scheduler_Block(&_Scheduler, the_thread);
_ISR_Enable( level );
}
111994: 8b 5d fc mov -0x4(%ebp),%ebx
111997: c9 leave
111998: c3 ret
111999: 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;
11199c: c7 40 10 02 00 00 00 movl $0x2,0x10(%eax)
RTEMS_INLINE_ROUTINE void _Scheduler_Block(
Scheduler_Control *the_scheduler,
Thread_Control *the_thread
)
{
the_scheduler->Operations.block( the_scheduler, the_thread );
1119a3: 83 ec 08 sub $0x8,%esp
1119a6: 50 push %eax
1119a7: 68 20 76 12 00 push $0x127620
1119ac: ff 15 2c 76 12 00 call *0x12762c
_Scheduler_Block(&_Scheduler, the_thread);
_ISR_Enable( level );
1119b2: 53 push %ebx
1119b3: 9d popf
1119b4: 83 c4 10 add $0x10,%esp
}
1119b7: 8b 5d fc mov -0x4(%ebp),%ebx
1119ba: c9 leave
1119bb: c3 ret
0010e364 <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
10e364: 55 push %ebp
10e365: 89 e5 mov %esp,%ebp
10e367: 53 push %ebx
10e368: 83 ec 04 sub $0x4,%esp
Thread_Control *executing;
executing = _Thread_Executing;
10e36b: 8b 1d 58 7b 12 00 mov 0x127b58,%ebx
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
10e371: 80 7b 74 00 cmpb $0x0,0x74(%ebx)
10e375: 74 19 je 10e390 <_Thread_Tickle_timeslice+0x2c>
return;
if ( !_States_Is_ready( executing->current_state ) )
10e377: 8b 43 10 mov 0x10(%ebx),%eax
10e37a: 85 c0 test %eax,%eax
10e37c: 75 12 jne 10e390 <_Thread_Tickle_timeslice+0x2c>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
10e37e: 8b 43 7c mov 0x7c(%ebx),%eax
10e381: 83 f8 01 cmp $0x1,%eax
10e384: 72 0a jb 10e390 <_Thread_Tickle_timeslice+0x2c>
10e386: 83 f8 02 cmp $0x2,%eax
10e389: 76 29 jbe 10e3b4 <_Thread_Tickle_timeslice+0x50>
10e38b: 83 f8 03 cmp $0x3,%eax
10e38e: 74 08 je 10e398 <_Thread_Tickle_timeslice+0x34><== ALWAYS TAKEN
if ( --executing->cpu_time_budget == 0 )
(*executing->budget_callout)( executing );
break;
#endif
}
}
10e390: 8b 5d fc mov -0x4(%ebp),%ebx
10e393: c9 leave
10e394: c3 ret
10e395: 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 )
10e398: 8b 43 78 mov 0x78(%ebx),%eax
10e39b: 48 dec %eax
10e39c: 89 43 78 mov %eax,0x78(%ebx)
10e39f: 85 c0 test %eax,%eax
10e3a1: 75 ed jne 10e390 <_Thread_Tickle_timeslice+0x2c>
(*executing->budget_callout)( executing );
10e3a3: 83 ec 0c sub $0xc,%esp
10e3a6: 53 push %ebx
10e3a7: ff 93 80 00 00 00 call *0x80(%ebx)
10e3ad: 83 c4 10 add $0x10,%esp
10e3b0: eb de jmp 10e390 <_Thread_Tickle_timeslice+0x2c>
10e3b2: 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 ) {
10e3b4: 8b 43 78 mov 0x78(%ebx),%eax
10e3b7: 48 dec %eax
10e3b8: 89 43 78 mov %eax,0x78(%ebx)
10e3bb: 85 c0 test %eax,%eax
10e3bd: 7f d1 jg 10e390 <_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( &_Scheduler );
10e3bf: 83 ec 0c sub $0xc,%esp
10e3c2: 68 20 76 12 00 push $0x127620
10e3c7: ff 15 28 76 12 00 call *0x127628
* 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;
10e3cd: a1 40 75 12 00 mov 0x127540,%eax
10e3d2: 89 43 78 mov %eax,0x78(%ebx)
10e3d5: 83 c4 10 add $0x10,%esp
10e3d8: eb b6 jmp 10e390 <_Thread_Tickle_timeslice+0x2c>
0010dcf4 <_Thread_queue_Dequeue_priority>:
*/
Thread_Control *_Thread_queue_Dequeue_priority(
Thread_queue_Control *the_thread_queue
)
{
10dcf4: 55 push %ebp
10dcf5: 89 e5 mov %esp,%ebp
10dcf7: 57 push %edi
10dcf8: 56 push %esi
10dcf9: 53 push %ebx
10dcfa: 83 ec 2c sub $0x2c,%esp
10dcfd: 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 );
10dd00: 9c pushf
10dd01: fa cli
10dd02: 58 pop %eax
10dd03: 89 f9 mov %edi,%ecx
for( index=0 ;
10dd05: 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 );
}
10dd07: 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 );
10dd09: 8d 34 52 lea (%edx,%edx,2),%esi
10dd0c: 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 ] ) ) {
10dd10: 39 f3 cmp %esi,%ebx
10dd12: 75 18 jne 10dd2c <_Thread_queue_Dequeue_priority+0x38>
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
10dd14: 42 inc %edx
10dd15: 83 c1 0c add $0xc,%ecx
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
10dd18: 83 fa 04 cmp $0x4,%edx
10dd1b: 75 ea jne 10dd07 <_Thread_queue_Dequeue_priority+0x13>
}
/*
* We did not find a thread to unblock.
*/
_ISR_Enable( level );
10dd1d: 50 push %eax
10dd1e: 9d popf
return NULL;
10dd1f: 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 );
}
10dd21: 89 f0 mov %esi,%eax
10dd23: 8d 65 f4 lea -0xc(%ebp),%esp
10dd26: 5b pop %ebx
10dd27: 5e pop %esi
10dd28: 5f pop %edi
10dd29: c9 leave
10dd2a: c3 ret
10dd2b: 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(
10dd2c: 89 de mov %ebx,%esi
*/
_ISR_Enable( level );
return NULL;
dequeue:
the_thread->Wait.queue = NULL;
10dd2e: 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 );
}
10dd35: 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;
10dd38: 8b 0b mov (%ebx),%ecx
previous_node = the_thread->Object.Node.previous;
10dd3a: 8b 7b 04 mov 0x4(%ebx),%edi
10dd3d: 89 7d d4 mov %edi,-0x2c(%ebp)
10dd40: 8d 7b 3c lea 0x3c(%ebx),%edi
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
10dd43: 39 fa cmp %edi,%edx
10dd45: 74 7f je 10ddc6 <_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 );
}
10dd47: 8b 7b 40 mov 0x40(%ebx),%edi
10dd4a: 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;
10dd4d: 8b 3a mov (%edx),%edi
10dd4f: 89 7d e0 mov %edi,-0x20(%ebp)
previous_node->next = new_first_node;
10dd52: 8b 7d d4 mov -0x2c(%ebp),%edi
10dd55: 89 17 mov %edx,(%edi)
next_node->previous = new_first_node;
10dd57: 89 51 04 mov %edx,0x4(%ecx)
new_first_node->next = next_node;
10dd5a: 89 0a mov %ecx,(%edx)
new_first_node->previous = previous_node;
10dd5c: 89 7a 04 mov %edi,0x4(%edx)
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
10dd5f: 8b 4b 40 mov 0x40(%ebx),%ecx
10dd62: 39 4b 38 cmp %ecx,0x38(%ebx)
10dd65: 74 17 je 10dd7e <_Thread_queue_Dequeue_priority+0x8a>
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
10dd67: 8d 4a 38 lea 0x38(%edx),%ecx
10dd6a: 8b 7d e0 mov -0x20(%ebp),%edi
10dd6d: 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;
10dd70: 89 7a 38 mov %edi,0x38(%edx)
tail->previous = last_node;
10dd73: 8b 4d e4 mov -0x1c(%ebp),%ecx
10dd76: 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 );
10dd79: 83 c2 3c add $0x3c,%edx
10dd7c: 89 11 mov %edx,(%ecx)
} else {
previous_node->next = next_node;
next_node->previous = previous_node;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10dd7e: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10dd82: 74 18 je 10dd9c <_Thread_queue_Dequeue_priority+0xa8>
_ISR_Enable( level );
10dd84: 50 push %eax
10dd85: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10dd86: 83 ec 08 sub $0x8,%esp
10dd89: 68 f8 ff 03 10 push $0x1003fff8
10dd8e: 53 push %ebx
10dd8f: e8 e0 f7 ff ff call 10d574 <_Thread_Clear_state>
10dd94: 83 c4 10 add $0x10,%esp
10dd97: eb 88 jmp 10dd21 <_Thread_queue_Dequeue_priority+0x2d>
10dd99: 8d 76 00 lea 0x0(%esi),%esi
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
10dd9c: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
10dda3: 50 push %eax
10dda4: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
10dda5: 83 ec 0c sub $0xc,%esp
10dda8: 8d 43 48 lea 0x48(%ebx),%eax
10ddab: 50 push %eax
10ddac: e8 87 0a 00 00 call 10e838 <_Watchdog_Remove>
10ddb1: 58 pop %eax
10ddb2: 5a pop %edx
10ddb3: 68 f8 ff 03 10 push $0x1003fff8
10ddb8: 53 push %ebx
10ddb9: e8 b6 f7 ff ff call 10d574 <_Thread_Clear_state>
10ddbe: 83 c4 10 add $0x10,%esp
10ddc1: e9 5b ff ff ff jmp 10dd21 <_Thread_queue_Dequeue_priority+0x2d>
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
10ddc6: 8b 7d d4 mov -0x2c(%ebp),%edi
10ddc9: 89 0f mov %ecx,(%edi)
next_node->previous = previous_node;
10ddcb: 89 79 04 mov %edi,0x4(%ecx)
10ddce: eb ae jmp 10dd7e <_Thread_queue_Dequeue_priority+0x8a>
0010de68 <_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
)
{
10de68: 55 push %ebp
10de69: 89 e5 mov %esp,%ebp
10de6b: 57 push %edi
10de6c: 56 push %esi
10de6d: 53 push %ebx
10de6e: 83 ec 0c sub $0xc,%esp
10de71: 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 );
10de74: 8d 47 3c lea 0x3c(%edi),%eax
10de77: 89 47 38 mov %eax,0x38(%edi)
head->next = tail;
head->previous = NULL;
10de7a: 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 );
10de81: 8d 47 38 lea 0x38(%edi),%eax
10de84: 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;
10de87: 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);
10de8a: 89 d0 mov %edx,%eax
10de8c: 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;
10de8f: 8b 4d 08 mov 0x8(%ebp),%ecx
10de92: 8b 59 38 mov 0x38(%ecx),%ebx
if ( _Thread_queue_Is_reverse_search( priority ) )
10de95: f6 c2 20 test $0x20,%dl
10de98: 75 66 jne 10df00 <_Thread_queue_Enqueue_priority+0x98>
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
10de9a: 8d 04 40 lea (%eax,%eax,2),%eax
10de9d: 8d 04 81 lea (%ecx,%eax,4),%eax
10dea0: 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));
10dea3: 83 c0 04 add $0x4,%eax
10dea6: 89 7d e8 mov %edi,-0x18(%ebp)
10dea9: 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 );
10deab: 9c pushf
10deac: fa cli
10dead: 5e pop %esi
10deae: 89 75 ec mov %esi,-0x14(%ebp)
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
10deb1: 8b 4d f0 mov -0x10(%ebp),%ecx
10deb4: 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 ) ) {
10deb6: 39 f8 cmp %edi,%eax
10deb8: 75 18 jne 10ded2 <_Thread_queue_Enqueue_priority+0x6a>
10deba: e9 0e 01 00 00 jmp 10dfcd <_Thread_queue_Enqueue_priority+0x165>
10debf: 90 nop
break;
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
10dec0: 56 push %esi
10dec1: 9d popf
10dec2: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10dec3: 85 58 10 test %ebx,0x10(%eax)
10dec6: 0f 84 ac 00 00 00 je 10df78 <_Thread_queue_Enqueue_priority+0x110><== NEVER TAKEN
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
10decc: 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 ) ) {
10dece: 39 f8 cmp %edi,%eax
10ded0: 74 07 je 10ded9 <_Thread_queue_Enqueue_priority+0x71>
search_priority = search_thread->current_priority;
10ded2: 8b 48 14 mov 0x14(%eax),%ecx
if ( priority <= search_priority )
10ded5: 39 ca cmp %ecx,%edx
10ded7: 77 e7 ja 10dec0 <_Thread_queue_Enqueue_priority+0x58>
10ded9: 8b 7d e8 mov -0x18(%ebp),%edi
10dedc: 89 75 f0 mov %esi,-0x10(%ebp)
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
10dedf: 8b 75 08 mov 0x8(%ebp),%esi
10dee2: 8b 5e 30 mov 0x30(%esi),%ebx
10dee5: 83 fb 01 cmp $0x1,%ebx
10dee8: 0f 84 92 00 00 00 je 10df80 <_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;
10deee: 8b 45 10 mov 0x10(%ebp),%eax
10def1: 8b 55 ec mov -0x14(%ebp),%edx
10def4: 89 10 mov %edx,(%eax)
return the_thread_queue->sync_state;
}
10def6: 89 d8 mov %ebx,%eax
10def8: 83 c4 0c add $0xc,%esp
10defb: 5b pop %ebx
10defc: 5e pop %esi
10defd: 5f pop %edi
10defe: c9 leave
10deff: c3 ret
10df00: 8d 04 40 lea (%eax,%eax,2),%eax
10df03: 8b 4d 08 mov 0x8(%ebp),%ecx
10df06: 8d 34 81 lea (%ecx,%eax,4),%esi
10df09: 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;
10df0c: 0f b6 0d 74 32 12 00 movzbl 0x123274,%ecx
10df13: 41 inc %ecx
_ISR_Disable( level );
10df14: 9c pushf
10df15: fa cli
10df16: 5f pop %edi
10df17: 89 7d ec mov %edi,-0x14(%ebp)
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
10df1a: 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 ) ) {
10df1d: 39 f0 cmp %esi,%eax
10df1f: 75 12 jne 10df33 <_Thread_queue_Enqueue_priority+0xcb>
10df21: eb 17 jmp 10df3a <_Thread_queue_Enqueue_priority+0xd2>
10df23: 90 nop
break;
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
10df24: 57 push %edi
10df25: 9d popf
10df26: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10df27: 85 58 10 test %ebx,0x10(%eax)
10df2a: 74 48 je 10df74 <_Thread_queue_Enqueue_priority+0x10c>
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
10df2c: 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 ) ) {
10df2f: 39 f0 cmp %esi,%eax
10df31: 74 07 je 10df3a <_Thread_queue_Enqueue_priority+0xd2>
search_priority = search_thread->current_priority;
10df33: 8b 48 14 mov 0x14(%eax),%ecx
if ( priority >= search_priority )
10df36: 39 ca cmp %ecx,%edx
10df38: 72 ea jb 10df24 <_Thread_queue_Enqueue_priority+0xbc>
10df3a: 89 7d e8 mov %edi,-0x18(%ebp)
10df3d: 8b 7d f0 mov -0x10(%ebp),%edi
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
10df40: 8b 75 08 mov 0x8(%ebp),%esi
10df43: 8b 5e 30 mov 0x30(%esi),%ebx
10df46: 83 fb 01 cmp $0x1,%ebx
10df49: 75 a3 jne 10deee <_Thread_queue_Enqueue_priority+0x86>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10df4b: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi)
if ( priority == search_priority )
10df52: 39 ca cmp %ecx,%edx
10df54: 74 53 je 10dfa9 <_Thread_queue_Enqueue_priority+0x141>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
10df56: 8b 10 mov (%eax),%edx
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
10df58: 89 17 mov %edx,(%edi)
the_node->previous = search_node;
10df5a: 89 47 04 mov %eax,0x4(%edi)
search_node->next = the_node;
10df5d: 89 38 mov %edi,(%eax)
next_node->previous = the_node;
10df5f: 89 7a 04 mov %edi,0x4(%edx)
the_thread->Wait.queue = the_thread_queue;
10df62: 89 77 44 mov %esi,0x44(%edi)
_ISR_Enable( level );
10df65: ff 75 e8 pushl -0x18(%ebp)
10df68: 9d popf
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
10df69: 89 d8 mov %ebx,%eax
10df6b: 83 c4 0c add $0xc,%esp
10df6e: 5b pop %ebx
10df6f: 5e pop %esi
10df70: 5f pop %edi
10df71: c9 leave
10df72: c3 ret
10df73: 90 nop
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
_ISR_Enable( level );
10df74: 57 push %edi
10df75: 9d popf
goto restart_reverse_search;
10df76: eb 94 jmp 10df0c <_Thread_queue_Enqueue_priority+0xa4>
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
_ISR_Enable( level );
10df78: 56 push %esi <== NOT EXECUTED
10df79: 9d popf <== NOT EXECUTED
goto restart_forward_search;
10df7a: e9 2c ff ff ff jmp 10deab <_Thread_queue_Enqueue_priority+0x43><== NOT EXECUTED
10df7f: 90 nop <== NOT EXECUTED
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10df80: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi)
if ( priority == search_priority )
10df87: 39 ca cmp %ecx,%edx
10df89: 74 1e je 10dfa9 <_Thread_queue_Enqueue_priority+0x141>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
10df8b: 8b 50 04 mov 0x4(%eax),%edx
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
10df8e: 89 07 mov %eax,(%edi)
the_node->previous = previous_node;
10df90: 89 57 04 mov %edx,0x4(%edi)
previous_node->next = the_node;
10df93: 89 3a mov %edi,(%edx)
search_node->previous = the_node;
10df95: 89 78 04 mov %edi,0x4(%eax)
the_thread->Wait.queue = the_thread_queue;
10df98: 89 77 44 mov %esi,0x44(%edi)
_ISR_Enable( level );
10df9b: ff 75 f0 pushl -0x10(%ebp)
10df9e: 9d popf
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
10df9f: 89 d8 mov %ebx,%eax
10dfa1: 83 c4 0c add $0xc,%esp
10dfa4: 5b pop %ebx
10dfa5: 5e pop %esi
10dfa6: 5f pop %edi
10dfa7: c9 leave
10dfa8: 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;
10dfa9: 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 );
10dfac: 8d 48 3c lea 0x3c(%eax),%ecx
10dfaf: 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;
10dfb1: 89 57 04 mov %edx,0x4(%edi)
previous_node->next = the_node;
10dfb4: 89 3a mov %edi,(%edx)
search_node->previous = the_node;
10dfb6: 89 78 40 mov %edi,0x40(%eax)
the_thread->Wait.queue = the_thread_queue;
10dfb9: 8b 45 08 mov 0x8(%ebp),%eax
10dfbc: 89 47 44 mov %eax,0x44(%edi)
_ISR_Enable( level );
10dfbf: ff 75 ec pushl -0x14(%ebp)
10dfc2: 9d popf
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10dfc3: bb 01 00 00 00 mov $0x1,%ebx
10dfc8: e9 29 ff ff ff jmp 10def6 <_Thread_queue_Enqueue_priority+0x8e>
10dfcd: 8b 7d e8 mov -0x18(%ebp),%edi
10dfd0: 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;
10dfd3: b9 ff ff ff ff mov $0xffffffff,%ecx
10dfd8: e9 02 ff ff ff jmp 10dedf <_Thread_queue_Enqueue_priority+0x77>
0011181c <_Thread_queue_Extract>:
void _Thread_queue_Extract(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
11181c: 55 push %ebp
11181d: 89 e5 mov %esp,%ebp
11181f: 83 ec 08 sub $0x8,%esp
111822: 8b 45 08 mov 0x8(%ebp),%eax
111825: 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 )
111828: 83 78 34 01 cmpl $0x1,0x34(%eax)
11182c: 74 0e je 11183c <_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 );
11182e: 89 55 0c mov %edx,0xc(%ebp)
111831: 89 45 08 mov %eax,0x8(%ebp)
}
111834: 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 );
111835: e9 e6 19 00 00 jmp 113220 <_Thread_queue_Extract_fifo>
11183a: 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 );
11183c: 51 push %ecx
11183d: 6a 00 push $0x0
11183f: 52 push %edx
111840: 50 push %eax
111841: e8 06 00 00 00 call 11184c <_Thread_queue_Extract_priority_helper>
111846: 83 c4 10 add $0x10,%esp
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
_Thread_queue_Extract_fifo( the_thread_queue, the_thread );
}
111849: c9 leave
11184a: c3 ret
00113220 <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
113220: 55 push %ebp
113221: 89 e5 mov %esp,%ebp
113223: 53 push %ebx
113224: 83 ec 04 sub $0x4,%esp
113227: 8b 5d 0c mov 0xc(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
11322a: 9c pushf
11322b: fa cli
11322c: 58 pop %eax
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
11322d: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx)
113234: 74 2e je 113264 <_Thread_queue_Extract_fifo+0x44>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
113236: 8b 0b mov (%ebx),%ecx
previous = the_node->previous;
113238: 8b 53 04 mov 0x4(%ebx),%edx
next->previous = previous;
11323b: 89 51 04 mov %edx,0x4(%ecx)
previous->next = next;
11323e: 89 0a mov %ecx,(%edx)
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
113240: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
113247: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
11324b: 74 1f je 11326c <_Thread_queue_Extract_fifo+0x4c>
_ISR_Enable( level );
11324d: 50 push %eax
11324e: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
11324f: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp)
113256: 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
}
113259: 8b 5d fc mov -0x4(%ebp),%ebx
11325c: c9 leave
11325d: e9 12 a3 ff ff jmp 10d574 <_Thread_Clear_state>
113262: 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 );
113264: 50 push %eax
113265: 9d popf
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
113266: 8b 5d fc mov -0x4(%ebp),%ebx
113269: c9 leave
11326a: c3 ret
11326b: 90 nop
11326c: 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 );
113273: 50 push %eax
113274: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
113275: 83 ec 0c sub $0xc,%esp
113278: 8d 43 48 lea 0x48(%ebx),%eax
11327b: 50 push %eax
11327c: e8 b7 b5 ff ff call 10e838 <_Watchdog_Remove>
113281: 83 c4 10 add $0x10,%esp
113284: eb c9 jmp 11324f <_Thread_queue_Extract_fifo+0x2f>
0011184c <_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
)
{
11184c: 55 push %ebp
11184d: 89 e5 mov %esp,%ebp
11184f: 57 push %edi
111850: 56 push %esi
111851: 53 push %ebx
111852: 83 ec 1c sub $0x1c,%esp
111855: 8b 5d 0c mov 0xc(%ebp),%ebx
111858: 8a 45 10 mov 0x10(%ebp),%al
11185b: 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 );
11185e: 9c pushf
11185f: fa cli
111860: 8f 45 e4 popl -0x1c(%ebp)
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
111863: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx)
11186a: 74 6c je 1118d8 <_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;
11186c: 8b 13 mov (%ebx),%edx
previous_node = the_node->previous;
11186e: 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
}
111871: 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 );
111874: 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 ) ) {
111877: 39 f0 cmp %esi,%eax
111879: 74 69 je 1118e4 <_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
}
11187b: 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;
11187e: 8b 30 mov (%eax),%esi
previous_node->next = new_first_node;
111880: 89 01 mov %eax,(%ecx)
next_node->previous = new_first_node;
111882: 89 42 04 mov %eax,0x4(%edx)
new_first_node->next = next_node;
111885: 89 10 mov %edx,(%eax)
new_first_node->previous = previous_node;
111887: 89 48 04 mov %ecx,0x4(%eax)
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
11188a: 8b 53 40 mov 0x40(%ebx),%edx
11188d: 39 53 38 cmp %edx,0x38(%ebx)
111890: 74 11 je 1118a3 <_Thread_queue_Extract_priority_helper+0x57>
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
111892: 8d 50 38 lea 0x38(%eax),%edx
111895: 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;
111898: 89 70 38 mov %esi,0x38(%eax)
tail->previous = last_node;
11189b: 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 );
11189e: 83 c0 3c add $0x3c,%eax
1118a1: 89 07 mov %eax,(%edi)
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
1118a3: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
1118a7: 75 23 jne 1118cc <_Thread_queue_Extract_priority_helper+0x80>
_ISR_Enable( level );
return;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
1118a9: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
1118ad: 74 3d je 1118ec <_Thread_queue_Extract_priority_helper+0xa0>
_ISR_Enable( level );
1118af: ff 75 e4 pushl -0x1c(%ebp)
1118b2: 9d popf
1118b3: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp)
1118ba: 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
}
1118bd: 8d 65 f4 lea -0xc(%ebp),%esp
1118c0: 5b pop %ebx
1118c1: 5e pop %esi
1118c2: 5f pop %edi
1118c3: c9 leave
1118c4: e9 ab bc ff ff jmp 10d574 <_Thread_Clear_state>
1118c9: 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 );
1118cc: ff 75 e4 pushl -0x1c(%ebp)
1118cf: 9d popf
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
1118d0: 8d 65 f4 lea -0xc(%ebp),%esp
1118d3: 5b pop %ebx
1118d4: 5e pop %esi
1118d5: 5f pop %edi
1118d6: c9 leave
1118d7: 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 );
1118d8: ff 75 e4 pushl -0x1c(%ebp)
1118db: 9d popf
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
1118dc: 8d 65 f4 lea -0xc(%ebp),%esp
1118df: 5b pop %ebx
1118e0: 5e pop %esi
1118e1: 5f pop %edi
1118e2: c9 leave
1118e3: c3 ret
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
1118e4: 89 11 mov %edx,(%ecx)
next_node->previous = previous_node;
1118e6: 89 4a 04 mov %ecx,0x4(%edx)
1118e9: eb b8 jmp 1118a3 <_Thread_queue_Extract_priority_helper+0x57>
1118eb: 90 nop
1118ec: 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 );
1118f3: ff 75 e4 pushl -0x1c(%ebp)
1118f6: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
1118f7: 83 ec 0c sub $0xc,%esp
1118fa: 8d 43 48 lea 0x48(%ebx),%eax
1118fd: 50 push %eax
1118fe: e8 35 cf ff ff call 10e838 <_Watchdog_Remove>
111903: 83 c4 10 add $0x10,%esp
111906: eb ab jmp 1118b3 <_Thread_queue_Extract_priority_helper+0x67>
0010dfe0 <_Thread_queue_Extract_with_proxy>:
*/
bool _Thread_queue_Extract_with_proxy(
Thread_Control *the_thread
)
{
10dfe0: 55 push %ebp
10dfe1: 89 e5 mov %esp,%ebp
10dfe3: 83 ec 08 sub $0x8,%esp
10dfe6: 8b 45 08 mov 0x8(%ebp),%eax
States_Control state;
state = the_thread->current_state;
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10dfe9: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax)
10dff0: 75 06 jne 10dff8 <_Thread_queue_Extract_with_proxy+0x18>
#endif
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
return true;
}
return false;
10dff2: 31 c0 xor %eax,%eax
}
10dff4: c9 leave
10dff5: c3 ret
10dff6: 66 90 xchg %ax,%ax
if ( proxy_extract_callout )
(*proxy_extract_callout)( the_thread );
}
#endif
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
10dff8: 83 ec 08 sub $0x8,%esp
10dffb: 50 push %eax
10dffc: ff 70 44 pushl 0x44(%eax)
10dfff: e8 18 38 00 00 call 11181c <_Thread_queue_Extract>
return true;
10e004: 83 c4 10 add $0x10,%esp
10e007: b0 01 mov $0x1,%al
}
return false;
}
10e009: c9 leave
10e00a: c3 ret
0010fe38 <_Thread_queue_First>:
*/
Thread_Control *_Thread_queue_First(
Thread_queue_Control *the_thread_queue
)
{
10fe38: 55 push %ebp
10fe39: 89 e5 mov %esp,%ebp
10fe3b: 83 ec 08 sub $0x8,%esp
10fe3e: 8b 45 08 mov 0x8(%ebp),%eax
Thread_Control * (*first_p)(Thread_queue_Control *);
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
10fe41: 83 78 34 01 cmpl $0x1,0x34(%eax)
10fe45: 74 0d je 10fe54 <_Thread_queue_First+0x1c>
first_p = _Thread_queue_First_priority;
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
first_p = _Thread_queue_First_fifo;
10fe47: ba b0 37 11 00 mov $0x1137b0,%edx
return (*first_p)( the_thread_queue );
10fe4c: 89 45 08 mov %eax,0x8(%ebp)
}
10fe4f: 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 );
10fe50: ff e2 jmp *%edx
10fe52: 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;
10fe54: ba 60 fe 10 00 mov $0x10fe60,%edx
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
first_p = _Thread_queue_First_fifo;
return (*first_p)( the_thread_queue );
10fe59: 89 45 08 mov %eax,0x8(%ebp)
}
10fe5c: 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 );
10fe5d: ff e2 jmp *%edx
001137b0 <_Thread_queue_First_fifo>:
*/
Thread_Control *_Thread_queue_First_fifo(
Thread_queue_Control *the_thread_queue
)
{
1137b0: 55 push %ebp
1137b1: 89 e5 mov %esp,%ebp
1137b3: 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;
}
1137b6: 8b 02 mov (%edx),%eax
1137b8: 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 ) )
1137bb: 39 d0 cmp %edx,%eax
1137bd: 74 05 je 1137c4 <_Thread_queue_First_fifo+0x14>
return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Fifo );
return NULL;
}
1137bf: c9 leave
1137c0: c3 ret
1137c1: 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;
1137c4: 31 c0 xor %eax,%eax
}
1137c6: c9 leave
1137c7: c3 ret
0010e00c <_Thread_queue_Flush>:
#else
Thread_queue_Flush_callout remote_extract_callout __attribute__((unused)),
#endif
uint32_t status
)
{
10e00c: 55 push %ebp
10e00d: 89 e5 mov %esp,%ebp
10e00f: 56 push %esi
10e010: 53 push %ebx
10e011: 8b 5d 08 mov 0x8(%ebp),%ebx
10e014: 8b 75 10 mov 0x10(%ebp),%esi
Thread_Control *the_thread;
while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) {
10e017: eb 06 jmp 10e01f <_Thread_queue_Flush+0x13>
10e019: 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;
10e01c: 89 70 34 mov %esi,0x34(%eax)
uint32_t status
)
{
Thread_Control *the_thread;
while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) {
10e01f: 83 ec 0c sub $0xc,%esp
10e022: 53 push %ebx
10e023: e8 80 fc ff ff call 10dca8 <_Thread_queue_Dequeue>
10e028: 83 c4 10 add $0x10,%esp
10e02b: 85 c0 test %eax,%eax
10e02d: 75 ed jne 10e01c <_Thread_queue_Flush+0x10>
( *remote_extract_callout )( the_thread );
else
#endif
the_thread->Wait.return_code = status;
}
}
10e02f: 8d 65 f8 lea -0x8(%ebp),%esp
10e032: 5b pop %ebx
10e033: 5e pop %esi
10e034: c9 leave
10e035: c3 ret
0010e038 <_Thread_queue_Initialize>:
Thread_queue_Control *the_thread_queue,
Thread_queue_Disciplines the_discipline,
States_Control state,
uint32_t timeout_status
)
{
10e038: 55 push %ebp
10e039: 89 e5 mov %esp,%ebp
10e03b: 56 push %esi
10e03c: 53 push %ebx
10e03d: 8b 45 08 mov 0x8(%ebp),%eax
10e040: 8b 55 0c mov 0xc(%ebp),%edx
the_thread_queue->state = state;
10e043: 8b 4d 10 mov 0x10(%ebp),%ecx
10e046: 89 48 38 mov %ecx,0x38(%eax)
the_thread_queue->discipline = the_discipline;
10e049: 89 50 34 mov %edx,0x34(%eax)
the_thread_queue->timeout_status = timeout_status;
10e04c: 8b 4d 14 mov 0x14(%ebp),%ecx
10e04f: 89 48 3c mov %ecx,0x3c(%eax)
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10e052: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
10e059: 83 fa 01 cmp $0x1,%edx
10e05c: 74 16 je 10e074 <_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 );
10e05e: 8d 50 04 lea 0x4(%eax),%edx
10e061: 89 10 mov %edx,(%eax)
head->next = tail;
head->previous = NULL;
10e063: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
tail->previous = head;
10e06a: 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 );
}
}
10e06d: 5b pop %ebx
10e06e: 5e pop %esi
10e06f: c9 leave
10e070: c3 ret
10e071: 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 ) {
10e074: 89 c1 mov %eax,%ecx
10e076: 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 );
10e078: 8d 1c 52 lea (%edx,%edx,2),%ebx
10e07b: 8d 1c 98 lea (%eax,%ebx,4),%ebx
10e07e: 8d 73 04 lea 0x4(%ebx),%esi
10e081: 89 31 mov %esi,(%ecx)
head->next = tail;
head->previous = NULL;
10e083: 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 );
10e08a: 89 59 08 mov %ebx,0x8(%ecx)
uint32_t index;
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++)
10e08d: 42 inc %edx
10e08e: 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 ;
10e091: 83 fa 04 cmp $0x4,%edx
10e094: 75 e2 jne 10e078 <_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 );
}
}
10e096: 5b pop %ebx
10e097: 5e pop %esi
10e098: c9 leave
10e099: c3 ret
0010e09c <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10e09c: 55 push %ebp
10e09d: 89 e5 mov %esp,%ebp
10e09f: 57 push %edi
10e0a0: 56 push %esi
10e0a1: 53 push %ebx
10e0a2: 83 ec 1c sub $0x1c,%esp
10e0a5: 8b 75 08 mov 0x8(%ebp),%esi
10e0a8: 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 )
10e0ab: 85 f6 test %esi,%esi
10e0ad: 74 06 je 10e0b5 <_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 ) {
10e0af: 83 7e 34 01 cmpl $0x1,0x34(%esi)
10e0b3: 74 0b je 10e0c0 <_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 );
}
}
10e0b5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10e0b8: 5b pop %ebx <== NOT EXECUTED
10e0b9: 5e pop %esi <== NOT EXECUTED
10e0ba: 5f pop %edi <== NOT EXECUTED
10e0bb: c9 leave <== NOT EXECUTED
10e0bc: c3 ret <== NOT EXECUTED
10e0bd: 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 );
10e0c0: 9c pushf
10e0c1: fa cli
10e0c2: 5b pop %ebx
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10e0c3: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi)
10e0ca: 75 0c jne 10e0d8 <_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 );
10e0cc: 53 push %ebx
10e0cd: 9d popf
}
}
10e0ce: 8d 65 f4 lea -0xc(%ebp),%esp
10e0d1: 5b pop %ebx
10e0d2: 5e pop %esi
10e0d3: 5f pop %edi
10e0d4: c9 leave
10e0d5: c3 ret
10e0d6: 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;
10e0d8: 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 );
10e0df: 50 push %eax
10e0e0: 6a 01 push $0x1
10e0e2: 57 push %edi
10e0e3: 56 push %esi
10e0e4: e8 63 37 00 00 call 11184c <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
10e0e9: 83 c4 0c add $0xc,%esp
10e0ec: 8d 45 e4 lea -0x1c(%ebp),%eax
10e0ef: 50 push %eax
10e0f0: 57 push %edi
10e0f1: 56 push %esi
10e0f2: e8 71 fd ff ff call 10de68 <_Thread_queue_Enqueue_priority>
10e0f7: 83 c4 10 add $0x10,%esp
10e0fa: eb d0 jmp 10e0cc <_Thread_queue_Requeue+0x30>
0010e0fc <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10e0fc: 55 push %ebp
10e0fd: 89 e5 mov %esp,%ebp
10e0ff: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10e102: 8d 45 f4 lea -0xc(%ebp),%eax
10e105: 50 push %eax
10e106: ff 75 08 pushl 0x8(%ebp)
10e109: e8 0a f8 ff ff call 10d918 <_Thread_Get>
switch ( location ) {
10e10e: 83 c4 10 add $0x10,%esp
10e111: 8b 55 f4 mov -0xc(%ebp),%edx
10e114: 85 d2 test %edx,%edx
10e116: 75 17 jne 10e12f <_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 );
10e118: 83 ec 0c sub $0xc,%esp
10e11b: 50 push %eax
10e11c: e8 e7 37 00 00 call 111908 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10e121: a1 70 75 12 00 mov 0x127570,%eax
10e126: 48 dec %eax
10e127: a3 70 75 12 00 mov %eax,0x127570
10e12c: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10e12f: c9 leave
10e130: c3 ret
00118dc4 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
118dc4: 55 push %ebp
118dc5: 89 e5 mov %esp,%ebp
118dc7: 57 push %edi
118dc8: 56 push %esi
118dc9: 53 push %ebx
118dca: 83 ec 4c sub $0x4c,%esp
118dcd: 8b 5d 08 mov 0x8(%ebp),%ebx
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
118dd0: 8d 45 e0 lea -0x20(%ebp),%eax
118dd3: 89 45 b4 mov %eax,-0x4c(%ebp)
118dd6: 89 45 dc mov %eax,-0x24(%ebp)
head->previous = NULL;
118dd9: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
tail->previous = head;
118de0: 8d 4d dc lea -0x24(%ebp),%ecx
118de3: 89 4d e4 mov %ecx,-0x1c(%ebp)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
118de6: 8d 7d d0 lea -0x30(%ebp),%edi
118de9: 8d 45 d4 lea -0x2c(%ebp),%eax
118dec: 89 45 b0 mov %eax,-0x50(%ebp)
118def: 89 45 d0 mov %eax,-0x30(%ebp)
head->previous = NULL;
118df2: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
tail->previous = head;
118df9: 89 7d d8 mov %edi,-0x28(%ebp)
118dfc: 8d 73 30 lea 0x30(%ebx),%esi
118dff: 8d 4b 68 lea 0x68(%ebx),%ecx
118e02: 89 4d c4 mov %ecx,-0x3c(%ebp)
118e05: 8d 43 08 lea 0x8(%ebx),%eax
118e08: 89 45 bc mov %eax,-0x44(%ebp)
118e0b: 8d 53 40 lea 0x40(%ebx),%edx
118e0e: 89 55 c0 mov %edx,-0x40(%ebp)
118e11: 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;
118e14: 8d 4d dc lea -0x24(%ebp),%ecx
118e17: 89 4b 78 mov %ecx,0x78(%ebx)
118e1a: 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;
118e1c: a1 84 23 14 00 mov 0x142384,%eax
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
118e21: 8b 53 3c mov 0x3c(%ebx),%edx
watchdogs->last_snapshot = snapshot;
118e24: 89 43 3c mov %eax,0x3c(%ebx)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
118e27: 51 push %ecx
118e28: 57 push %edi
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
118e29: 29 d0 sub %edx,%eax
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
118e2b: 50 push %eax
118e2c: 56 push %esi
118e2d: e8 72 3f 00 00 call 11cda4 <_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();
118e32: a1 e4 22 14 00 mov 0x1422e4,%eax
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
118e37: 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 ) {
118e3a: 83 c4 10 add $0x10,%esp
118e3d: 39 d0 cmp %edx,%eax
118e3f: 0f 87 af 00 00 00 ja 118ef4 <_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 ) {
118e45: 0f 82 c9 00 00 00 jb 118f14 <_Timer_server_Body+0x150>
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
118e4b: 89 43 74 mov %eax,0x74(%ebx)
118e4e: 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 );
118e50: 8b 43 78 mov 0x78(%ebx),%eax
118e53: 83 ec 0c sub $0xc,%esp
118e56: 50 push %eax
118e57: e8 04 0a 00 00 call 119860 <_Chain_Get>
if ( timer == NULL ) {
118e5c: 83 c4 10 add $0x10,%esp
118e5f: 85 c0 test %eax,%eax
118e61: 74 35 je 118e98 <_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 ) {
118e63: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED
118e66: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED
118e69: 74 19 je 118e84 <_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 ) {
118e6b: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED
118e6e: 75 e0 jne 118e50 <_Timer_server_Body+0x8c><== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
118e70: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
118e73: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
118e76: 50 push %eax <== NOT EXECUTED
118e77: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED
118e7a: e8 b1 3f 00 00 call 11ce30 <_Watchdog_Insert> <== NOT EXECUTED
118e7f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
118e82: eb cc jmp 118e50 <_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 );
118e84: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
118e87: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
118e8a: 50 push %eax <== NOT EXECUTED
118e8b: 56 push %esi <== NOT EXECUTED
118e8c: e8 9f 3f 00 00 call 11ce30 <_Watchdog_Insert> <== NOT EXECUTED
118e91: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
118e94: eb ba jmp 118e50 <_Timer_server_Body+0x8c><== NOT EXECUTED
118e96: 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 );
118e98: 9c pushf
118e99: fa cli
118e9a: 58 pop %eax
tmp = ts->insert_chain;
118e9b: 8b 53 78 mov 0x78(%ebx),%edx
if ( _Chain_Is_empty( insert_chain ) ) {
118e9e: 8b 55 b4 mov -0x4c(%ebp),%edx
118ea1: 39 55 dc cmp %edx,-0x24(%ebp)
118ea4: 0f 84 86 00 00 00 je 118f30 <_Timer_server_Body+0x16c><== ALWAYS TAKEN
118eaa: b2 01 mov $0x1,%dl <== NOT EXECUTED
ts->insert_chain = NULL;
do_loop = false;
}
_ISR_Enable( level );
118eac: 50 push %eax
118ead: 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 ) {
118eae: 84 d2 test %dl,%dl
118eb0: 0f 85 66 ff ff ff jne 118e1c <_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 ) ) {
118eb6: 8b 4d b0 mov -0x50(%ebp),%ecx
118eb9: 39 4d d0 cmp %ecx,-0x30(%ebp)
118ebc: 75 22 jne 118ee0 <_Timer_server_Body+0x11c>
118ebe: eb 7e jmp 118f3e <_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;
118ec0: 8b 10 mov (%eax),%edx
head->next = new_first;
118ec2: 89 55 d0 mov %edx,-0x30(%ebp)
new_first->previous = head;
118ec5: 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;
118ec8: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
_ISR_Enable( level );
118ecf: 51 push %ecx
118ed0: 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 );
118ed1: 83 ec 08 sub $0x8,%esp
118ed4: ff 70 24 pushl 0x24(%eax)
118ed7: ff 70 20 pushl 0x20(%eax)
118eda: ff 50 1c call *0x1c(%eax)
}
118edd: 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 );
118ee0: 9c pushf
118ee1: fa cli
118ee2: 59 pop %ecx
initialized = false;
}
#endif
return status;
}
118ee3: 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))
118ee6: 3b 45 b0 cmp -0x50(%ebp),%eax
118ee9: 75 d5 jne 118ec0 <_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 );
118eeb: 51 push %ecx
118eec: 9d popf
118eed: e9 22 ff ff ff jmp 118e14 <_Timer_server_Body+0x50>
118ef2: 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 );
118ef4: 51 push %ecx
118ef5: 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;
118ef6: 89 c1 mov %eax,%ecx
118ef8: 29 d1 sub %edx,%ecx
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
118efa: 51 push %ecx
118efb: ff 75 c4 pushl -0x3c(%ebp)
118efe: 89 45 b8 mov %eax,-0x48(%ebp)
118f01: e8 9e 3e 00 00 call 11cda4 <_Watchdog_Adjust_to_chain>
118f06: 83 c4 10 add $0x10,%esp
118f09: 8b 45 b8 mov -0x48(%ebp),%eax
118f0c: e9 3a ff ff ff jmp 118e4b <_Timer_server_Body+0x87>
118f11: 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 );
118f14: 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;
118f15: 29 c2 sub %eax,%edx
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
118f17: 52 push %edx
118f18: 6a 01 push $0x1
118f1a: ff 75 c4 pushl -0x3c(%ebp)
118f1d: 89 45 b8 mov %eax,-0x48(%ebp)
118f20: e8 07 3e 00 00 call 11cd2c <_Watchdog_Adjust>
118f25: 83 c4 10 add $0x10,%esp
118f28: 8b 45 b8 mov -0x48(%ebp),%eax
118f2b: e9 1b ff ff ff jmp 118e4b <_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;
118f30: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx)
do_loop = false;
118f37: 31 d2 xor %edx,%edx
118f39: e9 6e ff ff ff jmp 118eac <_Timer_server_Body+0xe8>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
118f3e: c6 43 7c 00 movb $0x0,0x7c(%ebx)
118f42: a1 10 22 14 00 mov 0x142210,%eax
118f47: 40 inc %eax
118f48: a3 10 22 14 00 mov %eax,0x142210
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
118f4d: 83 ec 08 sub $0x8,%esp
118f50: 6a 08 push $0x8
118f52: ff 33 pushl (%ebx)
118f54: e8 67 37 00 00 call 11c6c0 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
118f59: 89 d8 mov %ebx,%eax
118f5b: e8 c4 fd ff ff call 118d24 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
118f60: 89 d8 mov %ebx,%eax
118f62: e8 0d fe ff ff call 118d74 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
118f67: e8 2c 2e 00 00 call 11bd98 <_Thread_Enable_dispatch>
ts->active = true;
118f6c: 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 );
118f70: 5a pop %edx
118f71: ff 75 bc pushl -0x44(%ebp)
118f74: e8 f7 3f 00 00 call 11cf70 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
118f79: 58 pop %eax
118f7a: ff 75 c0 pushl -0x40(%ebp)
118f7d: e8 ee 3f 00 00 call 11cf70 <_Watchdog_Remove>
118f82: 83 c4 10 add $0x10,%esp
118f85: e9 8a fe ff ff jmp 118e14 <_Timer_server_Body+0x50>
00118f8c <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
118f8c: 55 push %ebp
118f8d: 89 e5 mov %esp,%ebp
118f8f: 57 push %edi
118f90: 56 push %esi
118f91: 53 push %ebx
118f92: 83 ec 2c sub $0x2c,%esp
118f95: 8b 5d 08 mov 0x8(%ebp),%ebx
118f98: 8b 45 0c mov 0xc(%ebp),%eax
if ( ts->insert_chain == NULL ) {
118f9b: 8b 53 78 mov 0x78(%ebx),%edx
118f9e: 85 d2 test %edx,%edx
118fa0: 74 16 je 118fb8 <_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 );
118fa2: 8b 53 78 mov 0x78(%ebx),%edx <== NOT EXECUTED
118fa5: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED
118fa8: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED
}
}
118fab: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
118fae: 5b pop %ebx <== NOT EXECUTED
118faf: 5e pop %esi <== NOT EXECUTED
118fb0: 5f pop %edi <== NOT EXECUTED
118fb1: 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 );
118fb2: e9 6d 08 00 00 jmp 119824 <_Chain_Append> <== NOT EXECUTED
118fb7: 90 nop <== NOT EXECUTED
118fb8: 8b 15 10 22 14 00 mov 0x142210,%edx
118fbe: 42 inc %edx
118fbf: 89 15 10 22 14 00 mov %edx,0x142210
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
118fc5: 8b 50 38 mov 0x38(%eax),%edx
118fc8: 83 fa 01 cmp $0x1,%edx
118fcb: 74 7b je 119048 <_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 ) {
118fcd: 83 fa 03 cmp $0x3,%edx
118fd0: 74 0e je 118fe0 <_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 );
}
}
118fd2: 8d 65 f4 lea -0xc(%ebp),%esp
118fd5: 5b pop %ebx
118fd6: 5e pop %esi
118fd7: 5f pop %edi
118fd8: c9 leave
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
118fd9: e9 ba 2d 00 00 jmp 11bd98 <_Thread_Enable_dispatch>
118fde: 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 );
118fe0: 9c pushf
118fe1: fa cli
118fe2: 8f 45 e4 popl -0x1c(%ebp)
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
118fe5: 8b 0d e4 22 14 00 mov 0x1422e4,%ecx
last_snapshot = ts->TOD_watchdogs.last_snapshot;
118feb: 8b 53 74 mov 0x74(%ebx),%edx
118fee: 89 55 d4 mov %edx,-0x2c(%ebp)
initialized = false;
}
#endif
return status;
}
118ff1: 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 );
118ff4: 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 ) ) {
118ff7: 39 fa cmp %edi,%edx
118ff9: 74 21 je 11901c <_Timer_server_Schedule_operation_method+0x90>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
118ffb: 8b 7a 10 mov 0x10(%edx),%edi
if ( snapshot > last_snapshot ) {
118ffe: 3b 4d d4 cmp -0x2c(%ebp),%ecx
119001: 0f 86 a1 00 00 00 jbe 1190a8 <_Timer_server_Schedule_operation_method+0x11c>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
119007: 89 ce mov %ecx,%esi
119009: 2b 75 d4 sub -0x2c(%ebp),%esi
11900c: 89 75 d4 mov %esi,-0x2c(%ebp)
if (delta_interval > delta) {
11900f: 39 f7 cmp %esi,%edi
119011: 0f 86 9b 00 00 00 jbe 1190b2 <_Timer_server_Schedule_operation_method+0x126><== NEVER TAKEN
delta_interval -= delta;
119017: 29 f7 sub %esi,%edi
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
119019: 89 7a 10 mov %edi,0x10(%edx)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
11901c: 89 4b 74 mov %ecx,0x74(%ebx)
_ISR_Enable( level );
11901f: ff 75 e4 pushl -0x1c(%ebp)
119022: 9d popf
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
119023: 83 ec 08 sub $0x8,%esp
119026: 83 c0 10 add $0x10,%eax
119029: 50 push %eax
11902a: 8d 43 68 lea 0x68(%ebx),%eax
11902d: 50 push %eax
11902e: e8 fd 3d 00 00 call 11ce30 <_Watchdog_Insert>
if ( !ts->active ) {
119033: 8a 43 7c mov 0x7c(%ebx),%al
119036: 83 c4 10 add $0x10,%esp
119039: 84 c0 test %al,%al
11903b: 75 95 jne 118fd2 <_Timer_server_Schedule_operation_method+0x46>
_Timer_server_Reset_tod_system_watchdog( ts );
11903d: 89 d8 mov %ebx,%eax
11903f: e8 30 fd ff ff call 118d74 <_Timer_server_Reset_tod_system_watchdog>
119044: eb 8c jmp 118fd2 <_Timer_server_Schedule_operation_method+0x46>
119046: 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 );
119048: 9c pushf
119049: fa cli
11904a: 8f 45 e4 popl -0x1c(%ebp)
snapshot = _Watchdog_Ticks_since_boot;
11904d: 8b 0d 84 23 14 00 mov 0x142384,%ecx
last_snapshot = ts->Interval_watchdogs.last_snapshot;
119053: 8b 7b 3c mov 0x3c(%ebx),%edi
initialized = false;
}
#endif
return status;
}
119056: 8b 53 30 mov 0x30(%ebx),%edx
119059: 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 ) ) {
11905c: 39 f2 cmp %esi,%edx
11905e: 74 10 je 119070 <_Timer_server_Schedule_operation_method+0xe4>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
119060: 89 ce mov %ecx,%esi
119062: 29 fe sub %edi,%esi
delta_interval = first_watchdog->delta_interval;
119064: 8b 7a 10 mov 0x10(%edx),%edi
if (delta_interval > delta) {
119067: 39 fe cmp %edi,%esi
119069: 73 39 jae 1190a4 <_Timer_server_Schedule_operation_method+0x118>
delta_interval -= delta;
11906b: 29 f7 sub %esi,%edi
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
11906d: 89 7a 10 mov %edi,0x10(%edx)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
119070: 89 4b 3c mov %ecx,0x3c(%ebx)
_ISR_Enable( level );
119073: ff 75 e4 pushl -0x1c(%ebp)
119076: 9d popf
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
119077: 83 ec 08 sub $0x8,%esp
11907a: 83 c0 10 add $0x10,%eax
11907d: 50 push %eax
11907e: 8d 43 30 lea 0x30(%ebx),%eax
119081: 50 push %eax
119082: e8 a9 3d 00 00 call 11ce30 <_Watchdog_Insert>
if ( !ts->active ) {
119087: 8a 43 7c mov 0x7c(%ebx),%al
11908a: 83 c4 10 add $0x10,%esp
11908d: 84 c0 test %al,%al
11908f: 0f 85 3d ff ff ff jne 118fd2 <_Timer_server_Schedule_operation_method+0x46>
_Timer_server_Reset_interval_system_watchdog( ts );
119095: 89 d8 mov %ebx,%eax
119097: e8 88 fc ff ff call 118d24 <_Timer_server_Reset_interval_system_watchdog>
11909c: e9 31 ff ff ff jmp 118fd2 <_Timer_server_Schedule_operation_method+0x46>
1190a1: 8d 76 00 lea 0x0(%esi),%esi
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
1190a4: 31 ff xor %edi,%edi
1190a6: eb c5 jmp 11906d <_Timer_server_Schedule_operation_method+0xe1>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
1190a8: 03 7d d4 add -0x2c(%ebp),%edi
delta_interval += delta;
1190ab: 29 cf sub %ecx,%edi
1190ad: e9 67 ff ff ff jmp 119019 <_Timer_server_Schedule_operation_method+0x8d>
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
1190b2: 31 ff xor %edi,%edi <== NOT EXECUTED
1190b4: e9 60 ff ff ff jmp 119019 <_Timer_server_Schedule_operation_method+0x8d><== NOT EXECUTED
0010fc18 <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
10fc18: 55 push %ebp
10fc19: 89 e5 mov %esp,%ebp
10fc1b: 57 push %edi
10fc1c: 56 push %esi
10fc1d: 53 push %ebx
10fc1e: 83 ec 2c sub $0x2c,%esp
10fc21: 8b 45 08 mov 0x8(%ebp),%eax
10fc24: 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;
10fc27: 8b 38 mov (%eax),%edi
left += lhs->tv_nsec;
10fc29: 8b 70 04 mov 0x4(%eax),%esi
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
10fc2c: bb 00 ca 9a 3b mov $0x3b9aca00,%ebx
10fc31: 8b 01 mov (%ecx),%eax
10fc33: f7 eb imul %ebx
10fc35: 89 45 e0 mov %eax,-0x20(%ebp)
10fc38: 89 55 e4 mov %edx,-0x1c(%ebp)
right += rhs->tv_nsec;
10fc3b: 8b 41 04 mov 0x4(%ecx),%eax
10fc3e: 99 cltd
10fc3f: 01 45 e0 add %eax,-0x20(%ebp)
10fc42: 11 55 e4 adc %edx,-0x1c(%ebp)
if ( right == 0 ) {
10fc45: 8b 55 e4 mov -0x1c(%ebp),%edx
10fc48: 0b 55 e0 or -0x20(%ebp),%edx
10fc4b: 74 73 je 10fcc0 <_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;
10fc4d: 89 f8 mov %edi,%eax
10fc4f: f7 eb imul %ebx
10fc51: 89 45 d0 mov %eax,-0x30(%ebp)
10fc54: 89 55 d4 mov %edx,-0x2c(%ebp)
left += lhs->tv_nsec;
10fc57: 89 f7 mov %esi,%edi
10fc59: c1 ff 1f sar $0x1f,%edi
10fc5c: 01 75 d0 add %esi,-0x30(%ebp)
10fc5f: 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;
10fc62: 69 4d d4 a0 86 01 00 imul $0x186a0,-0x2c(%ebp),%ecx
10fc69: bb a0 86 01 00 mov $0x186a0,%ebx
10fc6e: 8b 45 d0 mov -0x30(%ebp),%eax
10fc71: f7 e3 mul %ebx
10fc73: 8d 34 11 lea (%ecx,%edx,1),%esi
10fc76: ff 75 e4 pushl -0x1c(%ebp)
10fc79: ff 75 e0 pushl -0x20(%ebp)
10fc7c: 56 push %esi
10fc7d: 50 push %eax
10fc7e: e8 3d 0a 01 00 call 1206c0 <__udivdi3>
10fc83: 83 c4 10 add $0x10,%esp
10fc86: 89 c3 mov %eax,%ebx
10fc88: 89 d6 mov %edx,%esi
*ival_percentage = answer / 1000;
10fc8a: 6a 00 push $0x0
10fc8c: 68 e8 03 00 00 push $0x3e8
10fc91: 52 push %edx
10fc92: 50 push %eax
10fc93: e8 28 0a 01 00 call 1206c0 <__udivdi3>
10fc98: 83 c4 10 add $0x10,%esp
10fc9b: 8b 55 10 mov 0x10(%ebp),%edx
10fc9e: 89 02 mov %eax,(%edx)
*fval_percentage = answer % 1000;
10fca0: 6a 00 push $0x0
10fca2: 68 e8 03 00 00 push $0x3e8
10fca7: 56 push %esi
10fca8: 53 push %ebx
10fca9: e8 22 0b 01 00 call 1207d0 <__umoddi3>
10fcae: 83 c4 10 add $0x10,%esp
10fcb1: 8b 55 14 mov 0x14(%ebp),%edx
10fcb4: 89 02 mov %eax,(%edx)
}
10fcb6: 8d 65 f4 lea -0xc(%ebp),%esp
10fcb9: 5b pop %ebx
10fcba: 5e pop %esi
10fcbb: 5f pop %edi
10fcbc: c9 leave
10fcbd: c3 ret
10fcbe: 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;
10fcc0: 8b 45 10 mov 0x10(%ebp),%eax
10fcc3: c7 00 00 00 00 00 movl $0x0,(%eax)
*fval_percentage = 0;
10fcc9: 8b 55 14 mov 0x14(%ebp),%edx
10fccc: c7 02 00 00 00 00 movl $0x0,(%edx)
answer = (left * 100000) / right;
*ival_percentage = answer / 1000;
*fval_percentage = answer % 1000;
}
10fcd2: 8d 65 f4 lea -0xc(%ebp),%esp
10fcd5: 5b pop %ebx
10fcd6: 5e pop %esi
10fcd7: 5f pop %edi
10fcd8: c9 leave
10fcd9: c3 ret
0011f794 <_Timespec_Is_valid>:
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
const struct timespec *time
)
{
11f794: 55 push %ebp
11f795: 89 e5 mov %esp,%ebp
11f797: 8b 45 08 mov 0x8(%ebp),%eax
if ( !time )
11f79a: 85 c0 test %eax,%eax
11f79c: 74 1a je 11f7b8 <_Timespec_Is_valid+0x24>
return false;
if ( time->tv_sec < 0 )
11f79e: 8b 10 mov (%eax),%edx
11f7a0: 85 d2 test %edx,%edx
11f7a2: 78 14 js 11f7b8 <_Timespec_Is_valid+0x24>
return false;
if ( time->tv_nsec < 0 )
11f7a4: 8b 40 04 mov 0x4(%eax),%eax
11f7a7: 85 c0 test %eax,%eax
11f7a9: 78 0d js 11f7b8 <_Timespec_Is_valid+0x24>
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
11f7ab: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax
11f7b0: 0f 96 c0 setbe %al
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
11f7b3: c9 leave
11f7b4: c3 ret
11f7b5: 8d 76 00 lea 0x0(%esi),%esi
if ( time->tv_sec < 0 )
return false;
if ( time->tv_nsec < 0 )
return false;
11f7b8: 31 c0 xor %eax,%eax
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
11f7ba: c9 leave
11f7bb: c3 ret
001119bc <_Timespec_To_ticks>:
*/
uint32_t _Timespec_To_ticks(
const struct timespec *time
)
{
1119bc: 55 push %ebp
1119bd: 89 e5 mov %esp,%ebp
1119bf: 56 push %esi
1119c0: 53 push %ebx
1119c1: 8b 5d 08 mov 0x8(%ebp),%ebx
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
1119c4: 8b 33 mov (%ebx),%esi
1119c6: 85 f6 test %esi,%esi
1119c8: 75 07 jne 1119d1 <_Timespec_To_ticks+0x15>
1119ca: 8b 43 04 mov 0x4(%ebx),%eax
1119cd: 85 c0 test %eax,%eax
1119cf: 74 37 je 111a08 <_Timespec_To_ticks+0x4c>
return 0;
ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
1119d1: e8 62 17 00 00 call 113138 <TOD_TICKS_PER_SECOND_method>
1119d6: 89 c1 mov %eax,%ecx
1119d8: 0f af ce imul %esi,%ecx
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
1119db: a1 8c 32 12 00 mov 0x12328c,%eax
1119e0: 8d 04 80 lea (%eax,%eax,4),%eax
1119e3: 8d 04 80 lea (%eax,%eax,4),%eax
1119e6: 8d 34 80 lea (%eax,%eax,4),%esi
1119e9: c1 e6 03 shl $0x3,%esi
1119ec: 8b 43 04 mov 0x4(%ebx),%eax
1119ef: 31 d2 xor %edx,%edx
1119f1: f7 f6 div %esi
if (ticks)
1119f3: 01 c8 add %ecx,%eax
1119f5: 74 05 je 1119fc <_Timespec_To_ticks+0x40>
return ticks;
return 1;
}
1119f7: 5b pop %ebx
1119f8: 5e pop %esi
1119f9: c9 leave
1119fa: c3 ret
1119fb: 90 nop
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
if (ticks)
return ticks;
return 1;
1119fc: b8 01 00 00 00 mov $0x1,%eax
}
111a01: 5b pop %ebx
111a02: 5e pop %esi
111a03: c9 leave
111a04: c3 ret
111a05: 8d 76 00 lea 0x0(%esi),%esi
)
{
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
return 0;
111a08: 31 c0 xor %eax,%eax
if (ticks)
return ticks;
return 1;
}
111a0a: 5b pop %ebx
111a0b: 5e pop %esi
111a0c: c9 leave
111a0d: c3 ret
0010e594 <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10e594: 55 push %ebp
10e595: 89 e5 mov %esp,%ebp
10e597: 57 push %edi
10e598: 56 push %esi
10e599: 53 push %ebx
10e59a: 83 ec 1c sub $0x1c,%esp
10e59d: 8b 75 08 mov 0x8(%ebp),%esi
10e5a0: 8b 7d 10 mov 0x10(%ebp),%edi
10e5a3: 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 );
}
}
10e5a6: 8b 1d d4 77 12 00 mov 0x1277d4,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e5ac: 81 fb cc 77 12 00 cmp $0x1277cc,%ebx
10e5b2: 74 25 je 10e5d9 <_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 );
10e5b4: 0f b6 c0 movzbl %al,%eax
10e5b7: 89 45 e4 mov %eax,-0x1c(%ebp)
10e5ba: 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 )
10e5bc: 8b 43 30 mov 0x30(%ebx),%eax
10e5bf: 85 c0 test %eax,%eax
10e5c1: 74 0b je 10e5ce <_User_extensions_Fatal+0x3a>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10e5c3: 52 push %edx
10e5c4: 57 push %edi
10e5c5: ff 75 e4 pushl -0x1c(%ebp)
10e5c8: 56 push %esi
10e5c9: ff d0 call *%eax
10e5cb: 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 ) {
10e5ce: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e5d1: 81 fb cc 77 12 00 cmp $0x1277cc,%ebx
10e5d7: 75 e3 jne 10e5bc <_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 );
}
}
10e5d9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10e5dc: 5b pop %ebx <== NOT EXECUTED
10e5dd: 5e pop %esi <== NOT EXECUTED
10e5de: 5f pop %edi <== NOT EXECUTED
10e5df: c9 leave <== NOT EXECUTED
10e5e0: c3 ret <== NOT EXECUTED
0010e458 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
10e458: 55 push %ebp
10e459: 89 e5 mov %esp,%ebp
10e45b: 57 push %edi
10e45c: 56 push %esi
10e45d: 53 push %ebx
10e45e: 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;
10e461: a1 bc 32 12 00 mov 0x1232bc,%eax
10e466: 89 45 dc mov %eax,-0x24(%ebp)
initial_extensions = Configuration.User_extension_table;
10e469: 8b 35 c0 32 12 00 mov 0x1232c0,%esi
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10e46f: c7 05 cc 77 12 00 d0 movl $0x1277d0,0x1277cc
10e476: 77 12 00
head->previous = NULL;
10e479: c7 05 d0 77 12 00 00 movl $0x0,0x1277d0
10e480: 00 00 00
tail->previous = head;
10e483: c7 05 d4 77 12 00 cc movl $0x1277cc,0x1277d4
10e48a: 77 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10e48d: c7 05 74 75 12 00 78 movl $0x127578,0x127574
10e494: 75 12 00
head->previous = NULL;
10e497: c7 05 78 75 12 00 00 movl $0x0,0x127578
10e49e: 00 00 00
tail->previous = head;
10e4a1: c7 05 7c 75 12 00 74 movl $0x127574,0x12757c
10e4a8: 75 12 00
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
10e4ab: 85 f6 test %esi,%esi
10e4ad: 74 64 je 10e513 <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
10e4af: 89 c2 mov %eax,%edx
10e4b1: 8d 04 40 lea (%eax,%eax,2),%eax
10e4b4: 8d 0c 82 lea (%edx,%eax,4),%ecx
10e4b7: c1 e1 02 shl $0x2,%ecx
10e4ba: 83 ec 0c sub $0xc,%esp
10e4bd: 51 push %ecx
10e4be: 89 4d d8 mov %ecx,-0x28(%ebp)
10e4c1: e8 ce 04 00 00 call 10e994 <_Workspace_Allocate_or_fatal_error>
10e4c6: 89 c3 mov %eax,%ebx
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
10e4c8: 31 c0 xor %eax,%eax
10e4ca: 8b 4d d8 mov -0x28(%ebp),%ecx
10e4cd: 89 df mov %ebx,%edi
10e4cf: f3 aa rep stos %al,%es:(%edi)
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10e4d1: 83 c4 10 add $0x10,%esp
10e4d4: 8b 45 dc mov -0x24(%ebp),%eax
10e4d7: 85 c0 test %eax,%eax
10e4d9: 74 38 je 10e513 <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN
10e4db: 89 75 e4 mov %esi,-0x1c(%ebp)
10e4de: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
10e4e5: 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;
10e4e8: 8d 7b 14 lea 0x14(%ebx),%edi
10e4eb: 8b 75 e4 mov -0x1c(%ebp),%esi
10e4ee: b9 08 00 00 00 mov $0x8,%ecx
10e4f3: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_User_extensions_Add_set( extension );
10e4f5: 83 ec 0c sub $0xc,%esp
10e4f8: 53 push %ebx
10e4f9: e8 12 35 00 00 call 111a10 <_User_extensions_Add_set>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
10e4fe: 83 c3 34 add $0x34,%ebx
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10e501: ff 45 e0 incl -0x20(%ebp)
10e504: 83 45 e4 20 addl $0x20,-0x1c(%ebp)
10e508: 83 c4 10 add $0x10,%esp
10e50b: 8b 45 e0 mov -0x20(%ebp),%eax
10e50e: 39 45 dc cmp %eax,-0x24(%ebp)
10e511: 77 d5 ja 10e4e8 <_User_extensions_Handler_initialization+0x90>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
10e513: 8d 65 f4 lea -0xc(%ebp),%esp
10e516: 5b pop %ebx
10e517: 5e pop %esi
10e518: 5f pop %edi
10e519: c9 leave
10e51a: c3 ret
0010f9e0 <_User_extensions_Remove_set>:
#include <rtems/score/userext.h>
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
10f9e0: 55 push %ebp
10f9e1: 89 e5 mov %esp,%ebp
10f9e3: 53 push %ebx
10f9e4: 83 ec 10 sub $0x10,%esp
10f9e7: 8b 5d 08 mov 0x8(%ebp),%ebx
_Chain_Extract( &the_extension->Node );
10f9ea: 53 push %ebx
10f9eb: e8 ac d9 ff ff call 10d39c <_Chain_Extract>
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
10f9f0: 83 c4 10 add $0x10,%esp
10f9f3: 8b 43 24 mov 0x24(%ebx),%eax
10f9f6: 85 c0 test %eax,%eax
10f9f8: 74 12 je 10fa0c <_User_extensions_Remove_set+0x2c>
_Chain_Extract( &the_extension->Switch.Node );
10f9fa: 83 c3 08 add $0x8,%ebx
10f9fd: 89 5d 08 mov %ebx,0x8(%ebp)
}
10fa00: 8b 5d fc mov -0x4(%ebp),%ebx
10fa03: c9 leave
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
_Chain_Extract( &the_extension->Switch.Node );
10fa04: e9 93 d9 ff ff jmp 10d39c <_Chain_Extract>
10fa09: 8d 76 00 lea 0x0(%esi),%esi
}
10fa0c: 8b 5d fc mov -0x4(%ebp),%ebx
10fa0f: c9 leave
10fa10: c3 ret
0010e51c <_User_extensions_Thread_begin>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_begin (
Thread_Control *executing
)
{
10e51c: 55 push %ebp
10e51d: 89 e5 mov %esp,%ebp
10e51f: 56 push %esi
10e520: 53 push %ebx
10e521: 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 );
}
}
10e524: 8b 1d cc 77 12 00 mov 0x1277cc,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e52a: 81 fb d0 77 12 00 cmp $0x1277d0,%ebx
10e530: 74 1c je 10e54e <_User_extensions_Thread_begin+0x32><== NEVER TAKEN
10e532: 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 )
10e534: 8b 43 28 mov 0x28(%ebx),%eax
10e537: 85 c0 test %eax,%eax
10e539: 74 09 je 10e544 <_User_extensions_Thread_begin+0x28>
(*the_extension->Callouts.thread_begin)( executing );
10e53b: 83 ec 0c sub $0xc,%esp
10e53e: 56 push %esi
10e53f: ff d0 call *%eax
10e541: 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 ) {
10e544: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e546: 81 fb d0 77 12 00 cmp $0x1277d0,%ebx
10e54c: 75 e6 jne 10e534 <_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 );
}
}
10e54e: 8d 65 f8 lea -0x8(%ebp),%esp
10e551: 5b pop %ebx
10e552: 5e pop %esi
10e553: c9 leave
10e554: c3 ret
0010e5e4 <_User_extensions_Thread_create>:
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
10e5e4: 55 push %ebp
10e5e5: 89 e5 mov %esp,%ebp
10e5e7: 56 push %esi
10e5e8: 53 push %ebx
10e5e9: 8b 75 08 mov 0x8(%ebp),%esi
return false;
}
}
return true;
}
10e5ec: 8b 1d cc 77 12 00 mov 0x1277cc,%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
10e5f2: 81 fb d0 77 12 00 cmp $0x1277d0,%ebx
10e5f8: 74 26 je 10e620 <_User_extensions_Thread_create+0x3c><== NEVER TAKEN
10e5fa: 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 ) {
10e5fc: 8b 43 14 mov 0x14(%ebx),%eax
10e5ff: 85 c0 test %eax,%eax
10e601: 74 13 je 10e616 <_User_extensions_Thread_create+0x32>
status = (*the_extension->Callouts.thread_create)(
10e603: 83 ec 08 sub $0x8,%esp
10e606: 56 push %esi
10e607: ff 35 58 7b 12 00 pushl 0x127b58
10e60d: ff d0 call *%eax
_Thread_Executing,
the_thread
);
if ( !status )
10e60f: 83 c4 10 add $0x10,%esp
10e612: 84 c0 test %al,%al
10e614: 74 16 je 10e62c <_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 ) {
10e616: 8b 1b mov (%ebx),%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
10e618: 81 fb d0 77 12 00 cmp $0x1277d0,%ebx
10e61e: 75 dc jne 10e5fc <_User_extensions_Thread_create+0x18>
if ( !status )
return false;
}
}
return true;
10e620: b0 01 mov $0x1,%al
}
10e622: 8d 65 f8 lea -0x8(%ebp),%esp
10e625: 5b pop %ebx
10e626: 5e pop %esi
10e627: c9 leave
10e628: c3 ret
10e629: 8d 76 00 lea 0x0(%esi),%esi
status = (*the_extension->Callouts.thread_create)(
_Thread_Executing,
the_thread
);
if ( !status )
return false;
10e62c: 31 c0 xor %eax,%eax
}
}
return true;
}
10e62e: 8d 65 f8 lea -0x8(%ebp),%esp
10e631: 5b pop %ebx
10e632: 5e pop %esi
10e633: c9 leave
10e634: c3 ret
0010e638 <_User_extensions_Thread_delete>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_delete (
Thread_Control *the_thread
)
{
10e638: 55 push %ebp
10e639: 89 e5 mov %esp,%ebp
10e63b: 56 push %esi
10e63c: 53 push %ebx
10e63d: 8b 75 08 mov 0x8(%ebp),%esi
(*the_extension->Callouts.thread_delete)(
_Thread_Executing,
the_thread
);
}
}
10e640: 8b 1d d4 77 12 00 mov 0x1277d4,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e646: 81 fb cc 77 12 00 cmp $0x1277cc,%ebx
10e64c: 74 23 je 10e671 <_User_extensions_Thread_delete+0x39><== NEVER TAKEN
10e64e: 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 )
10e650: 8b 43 20 mov 0x20(%ebx),%eax
10e653: 85 c0 test %eax,%eax
10e655: 74 0f je 10e666 <_User_extensions_Thread_delete+0x2e>
(*the_extension->Callouts.thread_delete)(
10e657: 83 ec 08 sub $0x8,%esp
10e65a: 56 push %esi
10e65b: ff 35 58 7b 12 00 pushl 0x127b58
10e661: ff d0 call *%eax
10e663: 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 ) {
10e666: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e669: 81 fb cc 77 12 00 cmp $0x1277cc,%ebx
10e66f: 75 df jne 10e650 <_User_extensions_Thread_delete+0x18>
(*the_extension->Callouts.thread_delete)(
_Thread_Executing,
the_thread
);
}
}
10e671: 8d 65 f8 lea -0x8(%ebp),%esp
10e674: 5b pop %ebx
10e675: 5e pop %esi
10e676: c9 leave
10e677: c3 ret
0010e558 <_User_extensions_Thread_exitted>:
void _User_extensions_Thread_exitted (
Thread_Control *executing
)
{
10e558: 55 push %ebp
10e559: 89 e5 mov %esp,%ebp
10e55b: 56 push %esi
10e55c: 53 push %ebx
10e55d: 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 );
}
}
10e560: 8b 1d d4 77 12 00 mov 0x1277d4,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e566: 81 fb cc 77 12 00 cmp $0x1277cc,%ebx
10e56c: 74 1d je 10e58b <_User_extensions_Thread_exitted+0x33><== NEVER TAKEN
10e56e: 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 )
10e570: 8b 43 2c mov 0x2c(%ebx),%eax
10e573: 85 c0 test %eax,%eax
10e575: 74 09 je 10e580 <_User_extensions_Thread_exitted+0x28>
(*the_extension->Callouts.thread_exitted)( executing );
10e577: 83 ec 0c sub $0xc,%esp
10e57a: 56 push %esi
10e57b: ff d0 call *%eax
10e57d: 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 ) {
10e580: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10e583: 81 fb cc 77 12 00 cmp $0x1277cc,%ebx
10e589: 75 e5 jne 10e570 <_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 );
}
}
10e58b: 8d 65 f8 lea -0x8(%ebp),%esp
10e58e: 5b pop %ebx
10e58f: 5e pop %esi
10e590: c9 leave
10e591: c3 ret
0010f23c <_User_extensions_Thread_restart>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_restart (
Thread_Control *the_thread
)
{
10f23c: 55 push %ebp
10f23d: 89 e5 mov %esp,%ebp
10f23f: 56 push %esi
10f240: 53 push %ebx
10f241: 8b 75 08 mov 0x8(%ebp),%esi
(*the_extension->Callouts.thread_restart)(
_Thread_Executing,
the_thread
);
}
}
10f244: 8b 1d cc 9a 12 00 mov 0x129acc,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10f24a: 81 fb d0 9a 12 00 cmp $0x129ad0,%ebx
10f250: 74 22 je 10f274 <_User_extensions_Thread_restart+0x38><== NEVER TAKEN
10f252: 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 )
10f254: 8b 43 1c mov 0x1c(%ebx),%eax
10f257: 85 c0 test %eax,%eax
10f259: 74 0f je 10f26a <_User_extensions_Thread_restart+0x2e>
(*the_extension->Callouts.thread_restart)(
10f25b: 83 ec 08 sub $0x8,%esp
10f25e: 56 push %esi
10f25f: ff 35 58 9e 12 00 pushl 0x129e58
10f265: ff d0 call *%eax
10f267: 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 ) {
10f26a: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10f26c: 81 fb d0 9a 12 00 cmp $0x129ad0,%ebx
10f272: 75 e0 jne 10f254 <_User_extensions_Thread_restart+0x18>
(*the_extension->Callouts.thread_restart)(
_Thread_Executing,
the_thread
);
}
}
10f274: 8d 65 f8 lea -0x8(%ebp),%esp
10f277: 5b pop %ebx
10f278: 5e pop %esi
10f279: c9 leave
10f27a: c3 ret
0010e678 <_User_extensions_Thread_start>:
#include <rtems/score/userext.h>
void _User_extensions_Thread_start (
Thread_Control *the_thread
)
{
10e678: 55 push %ebp
10e679: 89 e5 mov %esp,%ebp
10e67b: 56 push %esi
10e67c: 53 push %ebx
10e67d: 8b 75 08 mov 0x8(%ebp),%esi
(*the_extension->Callouts.thread_start)(
_Thread_Executing,
the_thread
);
}
}
10e680: 8b 1d cc 77 12 00 mov 0x1277cc,%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e686: 81 fb d0 77 12 00 cmp $0x1277d0,%ebx
10e68c: 74 22 je 10e6b0 <_User_extensions_Thread_start+0x38><== NEVER TAKEN
10e68e: 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 )
10e690: 8b 43 18 mov 0x18(%ebx),%eax
10e693: 85 c0 test %eax,%eax
10e695: 74 0f je 10e6a6 <_User_extensions_Thread_start+0x2e>
(*the_extension->Callouts.thread_start)(
10e697: 83 ec 08 sub $0x8,%esp
10e69a: 56 push %esi
10e69b: ff 35 58 7b 12 00 pushl 0x127b58
10e6a1: ff d0 call *%eax
10e6a3: 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 ) {
10e6a6: 8b 1b mov (%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_First( &_User_extensions_List );
10e6a8: 81 fb d0 77 12 00 cmp $0x1277d0,%ebx
10e6ae: 75 e0 jne 10e690 <_User_extensions_Thread_start+0x18>
(*the_extension->Callouts.thread_start)(
_Thread_Executing,
the_thread
);
}
}
10e6b0: 8d 65 f8 lea -0x8(%ebp),%esp
10e6b3: 5b pop %ebx
10e6b4: 5e pop %esi
10e6b5: c9 leave
10e6b6: c3 ret
0010e6b8 <_User_extensions_Thread_switch>:
void _User_extensions_Thread_switch (
Thread_Control *executing,
Thread_Control *heir
)
{
10e6b8: 55 push %ebp
10e6b9: 89 e5 mov %esp,%ebp
10e6bb: 57 push %edi
10e6bc: 56 push %esi
10e6bd: 53 push %ebx
10e6be: 83 ec 0c sub $0xc,%esp
10e6c1: 8b 7d 08 mov 0x8(%ebp),%edi
10e6c4: 8b 75 0c mov 0xc(%ebp),%esi
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
}
}
10e6c7: 8b 1d 74 75 12 00 mov 0x127574,%ebx
)
{
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _Chain_First( &_User_extensions_Switches_list );
10e6cd: 81 fb 78 75 12 00 cmp $0x127578,%ebx
10e6d3: 74 18 je 10e6ed <_User_extensions_Thread_switch+0x35><== NEVER TAKEN
10e6d5: 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 );
10e6d8: 83 ec 08 sub $0x8,%esp
10e6db: 56 push %esi
10e6dc: 57 push %edi
10e6dd: 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 ) {
10e6e0: 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 );
10e6e2: 83 c4 10 add $0x10,%esp
10e6e5: 81 fb 78 75 12 00 cmp $0x127578,%ebx
10e6eb: 75 eb jne 10e6d8 <_User_extensions_Thread_switch+0x20>
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
}
}
10e6ed: 8d 65 f4 lea -0xc(%ebp),%esp
10e6f0: 5b pop %ebx
10e6f1: 5e pop %esi
10e6f2: 5f pop %edi
10e6f3: c9 leave
10e6f4: c3 ret
0010fff8 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
10fff8: 55 push %ebp
10fff9: 89 e5 mov %esp,%ebp
10fffb: 57 push %edi
10fffc: 56 push %esi
10fffd: 53 push %ebx
10fffe: 83 ec 1c sub $0x1c,%esp
110001: 8b 75 08 mov 0x8(%ebp),%esi
110004: 8b 4d 0c mov 0xc(%ebp),%ecx
110007: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
11000a: 9c pushf
11000b: fa cli
11000c: 58 pop %eax
}
}
_ISR_Enable( level );
}
11000d: 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 );
11000f: 8d 7e 04 lea 0x4(%esi),%edi
110012: 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 ) ) {
110015: 39 fa cmp %edi,%edx
110017: 74 3d je 110056 <_Watchdog_Adjust+0x5e>
switch ( direction ) {
110019: 85 c9 test %ecx,%ecx
11001b: 75 43 jne 110060 <_Watchdog_Adjust+0x68>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
11001d: 85 db test %ebx,%ebx
11001f: 74 35 je 110056 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
110021: 8b 7a 10 mov 0x10(%edx),%edi
110024: 39 fb cmp %edi,%ebx
110026: 73 0f jae 110037 <_Watchdog_Adjust+0x3f> <== ALWAYS TAKEN
110028: eb 3e jmp 110068 <_Watchdog_Adjust+0x70> <== NOT EXECUTED
11002a: 66 90 xchg %ax,%ax <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
11002c: 29 fb sub %edi,%ebx
11002e: 74 26 je 110056 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
110030: 8b 7a 10 mov 0x10(%edx),%edi
110033: 39 df cmp %ebx,%edi
110035: 77 31 ja 110068 <_Watchdog_Adjust+0x70>
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
110037: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx)
_ISR_Enable( level );
11003e: 50 push %eax
11003f: 9d popf
_Watchdog_Tickle( header );
110040: 83 ec 0c sub $0xc,%esp
110043: 56 push %esi
110044: e8 d3 01 00 00 call 11021c <_Watchdog_Tickle>
_ISR_Disable( level );
110049: 9c pushf
11004a: fa cli
11004b: 58 pop %eax
}
}
_ISR_Enable( level );
}
11004c: 8b 16 mov (%esi),%edx
_Watchdog_Tickle( header );
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
11004e: 83 c4 10 add $0x10,%esp
110051: 39 55 e4 cmp %edx,-0x1c(%ebp)
110054: 75 d6 jne 11002c <_Watchdog_Adjust+0x34>
}
break;
}
}
_ISR_Enable( level );
110056: 50 push %eax
110057: 9d popf
}
110058: 8d 65 f4 lea -0xc(%ebp),%esp
11005b: 5b pop %ebx
11005c: 5e pop %esi
11005d: 5f pop %edi
11005e: c9 leave
11005f: c3 ret
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
110060: 49 dec %ecx
110061: 75 f3 jne 110056 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
110063: 01 5a 10 add %ebx,0x10(%edx)
break;
110066: eb ee jmp 110056 <_Watchdog_Adjust+0x5e>
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
110068: 29 df sub %ebx,%edi
11006a: 89 7a 10 mov %edi,0x10(%edx)
break;
11006d: eb e7 jmp 110056 <_Watchdog_Adjust+0x5e>
0010e6f8 <_Watchdog_Insert>:
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
10e6f8: 55 push %ebp
10e6f9: 89 e5 mov %esp,%ebp
10e6fb: 57 push %edi
10e6fc: 56 push %esi
10e6fd: 53 push %ebx
10e6fe: 83 ec 04 sub $0x4,%esp
10e701: 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;
10e704: 8b 3d 54 7b 12 00 mov 0x127b54,%edi
_ISR_Disable( level );
10e70a: 9c pushf
10e70b: fa cli
10e70c: 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 ) {
10e70f: 8b 43 08 mov 0x8(%ebx),%eax
10e712: 85 c0 test %eax,%eax
10e714: 0f 85 9e 00 00 00 jne 10e7b8 <_Watchdog_Insert+0xc0>
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
10e71a: c7 43 08 01 00 00 00 movl $0x1,0x8(%ebx)
_Watchdog_Sync_count++;
10e721: a1 e0 76 12 00 mov 0x1276e0,%eax
10e726: 40 inc %eax
10e727: a3 e0 76 12 00 mov %eax,0x1276e0
restart:
delta_interval = the_watchdog->initial;
10e72c: 8b 43 0c mov 0xc(%ebx),%eax
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
10e72f: 8b 4d 08 mov 0x8(%ebp),%ecx
10e732: 8b 11 mov (%ecx),%edx
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
10e734: 85 c0 test %eax,%eax
10e736: 74 5d je 10e795 <_Watchdog_Insert+0x9d>
10e738: 8b 32 mov (%edx),%esi
10e73a: 85 f6 test %esi,%esi
10e73c: 74 57 je 10e795 <_Watchdog_Insert+0x9d>
break;
if ( delta_interval < after->delta_interval ) {
10e73e: 8b 4a 10 mov 0x10(%edx),%ecx
10e741: 39 c8 cmp %ecx,%eax
10e743: 73 22 jae 10e767 <_Watchdog_Insert+0x6f>
10e745: eb 49 jmp 10e790 <_Watchdog_Insert+0x98>
10e747: 90 nop
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
10e748: 8b 35 60 76 12 00 mov 0x127660,%esi
10e74e: 39 f7 cmp %esi,%edi
10e750: 72 72 jb 10e7c4 <_Watchdog_Insert+0xcc>
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
10e752: 29 c8 sub %ecx,%eax
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
10e754: 8b 12 mov (%edx),%edx
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
10e756: 85 c0 test %eax,%eax
10e758: 74 3b je 10e795 <_Watchdog_Insert+0x9d>
10e75a: 8b 0a mov (%edx),%ecx
10e75c: 85 c9 test %ecx,%ecx
10e75e: 74 35 je 10e795 <_Watchdog_Insert+0x9d>
break;
if ( delta_interval < after->delta_interval ) {
10e760: 8b 4a 10 mov 0x10(%edx),%ecx
10e763: 39 c1 cmp %eax,%ecx
10e765: 77 29 ja 10e790 <_Watchdog_Insert+0x98>
break;
}
delta_interval -= after->delta_interval;
_ISR_Flash( level );
10e767: ff 75 f0 pushl -0x10(%ebp)
10e76a: 9d popf
10e76b: fa cli
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
10e76c: 83 7b 08 01 cmpl $0x1,0x8(%ebx)
10e770: 74 d6 je 10e748 <_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;
10e772: 89 3d 60 76 12 00 mov %edi,0x127660
_Watchdog_Sync_count--;
10e778: a1 e0 76 12 00 mov 0x1276e0,%eax
10e77d: 48 dec %eax
10e77e: a3 e0 76 12 00 mov %eax,0x1276e0
_ISR_Enable( level );
10e783: ff 75 f0 pushl -0x10(%ebp)
10e786: 9d popf
}
10e787: 58 pop %eax
10e788: 5b pop %ebx
10e789: 5e pop %esi
10e78a: 5f pop %edi
10e78b: c9 leave
10e78c: c3 ret
10e78d: 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;
10e790: 29 c1 sub %eax,%ecx
10e792: 89 4a 10 mov %ecx,0x10(%edx)
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_ACTIVE;
10e795: c7 43 08 02 00 00 00 movl $0x2,0x8(%ebx)
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
10e79c: 89 43 10 mov %eax,0x10(%ebx)
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
10e79f: 8b 42 04 mov 0x4(%edx),%eax
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
10e7a2: 89 43 04 mov %eax,0x4(%ebx)
before_node = after_node->next;
10e7a5: 8b 10 mov (%eax),%edx
after_node->next = the_node;
10e7a7: 89 18 mov %ebx,(%eax)
the_node->next = before_node;
10e7a9: 89 13 mov %edx,(%ebx)
before_node->previous = the_node;
10e7ab: 89 5a 04 mov %ebx,0x4(%edx)
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
10e7ae: a1 e4 76 12 00 mov 0x1276e4,%eax
10e7b3: 89 43 14 mov %eax,0x14(%ebx)
10e7b6: eb ba jmp 10e772 <_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 );
10e7b8: ff 75 f0 pushl -0x10(%ebp)
10e7bb: 9d popf
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
10e7bc: 58 pop %eax
10e7bd: 5b pop %ebx
10e7be: 5e pop %esi
10e7bf: 5f pop %edi
10e7c0: c9 leave
10e7c1: c3 ret
10e7c2: 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;
10e7c4: 89 3d 60 76 12 00 mov %edi,0x127660
goto restart;
10e7ca: e9 5d ff ff ff jmp 10e72c <_Watchdog_Insert+0x34>
0010e838 <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
10e838: 55 push %ebp
10e839: 89 e5 mov %esp,%ebp
10e83b: 56 push %esi
10e83c: 53 push %ebx
10e83d: 8b 55 08 mov 0x8(%ebp),%edx
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
10e840: 9c pushf
10e841: fa cli
10e842: 59 pop %ecx
previous_state = the_watchdog->state;
10e843: 8b 42 08 mov 0x8(%edx),%eax
switch ( previous_state ) {
10e846: 83 f8 01 cmp $0x1,%eax
10e849: 74 4d je 10e898 <_Watchdog_Remove+0x60>
10e84b: 73 0f jae 10e85c <_Watchdog_Remove+0x24>
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
10e84d: 8b 1d e4 76 12 00 mov 0x1276e4,%ebx
10e853: 89 5a 18 mov %ebx,0x18(%edx)
_ISR_Enable( level );
10e856: 51 push %ecx
10e857: 9d popf
return( previous_state );
}
10e858: 5b pop %ebx
10e859: 5e pop %esi
10e85a: c9 leave
10e85b: c3 ret
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
previous_state = the_watchdog->state;
switch ( previous_state ) {
10e85c: 83 f8 03 cmp $0x3,%eax
10e85f: 77 ec ja 10e84d <_Watchdog_Remove+0x15> <== NEVER TAKEN
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
10e861: 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 );
}
10e868: 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) )
10e86a: 8b 33 mov (%ebx),%esi
10e86c: 85 f6 test %esi,%esi
10e86e: 74 06 je 10e876 <_Watchdog_Remove+0x3e>
next_watchdog->delta_interval += the_watchdog->delta_interval;
10e870: 8b 72 10 mov 0x10(%edx),%esi
10e873: 01 73 10 add %esi,0x10(%ebx)
if ( _Watchdog_Sync_count )
10e876: 8b 35 e0 76 12 00 mov 0x1276e0,%esi
10e87c: 85 f6 test %esi,%esi
10e87e: 74 0c je 10e88c <_Watchdog_Remove+0x54>
_Watchdog_Sync_level = _ISR_Nest_level;
10e880: 8b 35 54 7b 12 00 mov 0x127b54,%esi
10e886: 89 35 60 76 12 00 mov %esi,0x127660
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
10e88c: 8b 72 04 mov 0x4(%edx),%esi
next->previous = previous;
10e88f: 89 73 04 mov %esi,0x4(%ebx)
previous->next = next;
10e892: 89 1e mov %ebx,(%esi)
10e894: eb b7 jmp 10e84d <_Watchdog_Remove+0x15>
10e896: 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;
10e898: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
break;
10e89f: eb ac jmp 10e84d <_Watchdog_Remove+0x15>
0010fbec <_Watchdog_Report>:
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
10fbec: 55 push %ebp
10fbed: 89 e5 mov %esp,%ebp
10fbef: 57 push %edi
10fbf0: 56 push %esi
10fbf1: 53 push %ebx
10fbf2: 83 ec 2c sub $0x2c,%esp
10fbf5: 8b 55 08 mov 0x8(%ebp),%edx
10fbf8: 8b 45 0c mov 0xc(%ebp),%eax
printk(
10fbfb: 8b 78 24 mov 0x24(%eax),%edi
10fbfe: 8b 70 20 mov 0x20(%eax),%esi
10fc01: 8b 58 1c mov 0x1c(%eax),%ebx
10fc04: 8b 48 0c mov 0xc(%eax),%ecx
10fc07: 89 4d d4 mov %ecx,-0x2c(%ebp)
10fc0a: 8b 48 10 mov 0x10(%eax),%ecx
10fc0d: 89 4d e4 mov %ecx,-0x1c(%ebp)
10fc10: 85 d2 test %edx,%edx
10fc12: 74 2c je 10fc40 <_Watchdog_Report+0x54>
10fc14: b9 a3 2c 12 00 mov $0x122ca3,%ecx
10fc19: 83 ec 0c sub $0xc,%esp
10fc1c: 57 push %edi
10fc1d: 56 push %esi
10fc1e: 53 push %ebx
10fc1f: 50 push %eax
10fc20: ff 75 d4 pushl -0x2c(%ebp)
10fc23: ff 75 e4 pushl -0x1c(%ebp)
10fc26: 51 push %ecx
10fc27: 52 push %edx
10fc28: 68 06 37 12 00 push $0x123706
10fc2d: e8 66 9e ff ff call 109a98 <printk>
10fc32: 83 c4 30 add $0x30,%esp
watch,
watch->routine,
watch->id,
watch->user_data
);
}
10fc35: 8d 65 f4 lea -0xc(%ebp),%esp
10fc38: 5b pop %ebx
10fc39: 5e pop %esi
10fc3a: 5f pop %edi
10fc3b: c9 leave
10fc3c: c3 ret
10fc3d: 8d 76 00 lea 0x0(%esi),%esi
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
printk(
10fc40: b9 69 35 12 00 mov $0x123569,%ecx
10fc45: 89 ca mov %ecx,%edx
10fc47: eb d0 jmp 10fc19 <_Watchdog_Report+0x2d>
0010fb7c <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
10fb7c: 55 push %ebp
10fb7d: 89 e5 mov %esp,%ebp
10fb7f: 57 push %edi
10fb80: 56 push %esi
10fb81: 53 push %ebx
10fb82: 83 ec 20 sub $0x20,%esp
10fb85: 8b 7d 08 mov 0x8(%ebp),%edi
10fb88: 8b 75 0c mov 0xc(%ebp),%esi
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
10fb8b: 9c pushf
10fb8c: fa cli
10fb8d: 8f 45 e4 popl -0x1c(%ebp)
printk( "Watchdog Chain: %s %p\n", name, header );
10fb90: 56 push %esi
10fb91: 57 push %edi
10fb92: 68 d0 36 12 00 push $0x1236d0
10fb97: e8 fc 9e ff ff call 109a98 <printk>
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
10fb9c: 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 );
10fb9e: 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 ) ) {
10fba1: 83 c4 10 add $0x10,%esp
10fba4: 39 f3 cmp %esi,%ebx
10fba6: 74 31 je 10fbd9 <_Watchdog_Report_chain+0x5d>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
10fba8: 83 ec 08 sub $0x8,%esp
10fbab: 53 push %ebx
10fbac: 6a 00 push $0x0
10fbae: e8 39 00 00 00 call 10fbec <_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 )
10fbb3: 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 ) ;
10fbb5: 83 c4 10 add $0x10,%esp
10fbb8: 39 f3 cmp %esi,%ebx
10fbba: 75 ec jne 10fba8 <_Watchdog_Report_chain+0x2c><== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
10fbbc: 83 ec 08 sub $0x8,%esp
10fbbf: 57 push %edi
10fbc0: 68 e7 36 12 00 push $0x1236e7
10fbc5: e8 ce 9e ff ff call 109a98 <printk>
10fbca: 83 c4 10 add $0x10,%esp
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
10fbcd: ff 75 e4 pushl -0x1c(%ebp)
10fbd0: 9d popf
}
10fbd1: 8d 65 f4 lea -0xc(%ebp),%esp
10fbd4: 5b pop %ebx
10fbd5: 5e pop %esi
10fbd6: 5f pop %edi
10fbd7: c9 leave
10fbd8: c3 ret
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
10fbd9: 83 ec 0c sub $0xc,%esp
10fbdc: 68 f6 36 12 00 push $0x1236f6
10fbe1: e8 b2 9e ff ff call 109a98 <printk>
10fbe6: 83 c4 10 add $0x10,%esp
10fbe9: eb e2 jmp 10fbcd <_Watchdog_Report_chain+0x51>
0010e8a4 <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
10e8a4: 55 push %ebp
10e8a5: 89 e5 mov %esp,%ebp
10e8a7: 57 push %edi
10e8a8: 56 push %esi
10e8a9: 53 push %ebx
10e8aa: 83 ec 1c sub $0x1c,%esp
10e8ad: 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 );
10e8b0: 9c pushf
10e8b1: fa cli
10e8b2: 5e pop %esi
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
10e8b3: 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 );
10e8b5: 8d 47 04 lea 0x4(%edi),%eax
10e8b8: 89 45 e4 mov %eax,-0x1c(%ebp)
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
10e8bb: 39 c3 cmp %eax,%ebx
10e8bd: 74 11 je 10e8d0 <_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) {
10e8bf: 8b 43 10 mov 0x10(%ebx),%eax
10e8c2: 85 c0 test %eax,%eax
10e8c4: 74 34 je 10e8fa <_Watchdog_Tickle+0x56>
the_watchdog->delta_interval--;
10e8c6: 48 dec %eax
10e8c7: 89 43 10 mov %eax,0x10(%ebx)
if ( the_watchdog->delta_interval != 0 )
10e8ca: 85 c0 test %eax,%eax
10e8cc: 74 2c je 10e8fa <_Watchdog_Tickle+0x56>
10e8ce: 66 90 xchg %ax,%ax
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
10e8d0: 56 push %esi
10e8d1: 9d popf
}
10e8d2: 8d 65 f4 lea -0xc(%ebp),%esp
10e8d5: 5b pop %ebx
10e8d6: 5e pop %esi
10e8d7: 5f pop %edi
10e8d8: c9 leave
10e8d9: c3 ret
_ISR_Enable( level );
switch( watchdog_state ) {
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
10e8da: 83 ec 08 sub $0x8,%esp
10e8dd: ff 73 24 pushl 0x24(%ebx)
10e8e0: ff 73 20 pushl 0x20(%ebx)
10e8e3: ff 53 1c call *0x1c(%ebx)
the_watchdog->id,
the_watchdog->user_data
);
break;
10e8e6: 83 c4 10 add $0x10,%esp
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
10e8e9: 9c pushf
10e8ea: fa cli
10e8eb: 5e pop %esi
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
10e8ec: 8b 1f mov (%edi),%ebx
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
10e8ee: 3b 5d e4 cmp -0x1c(%ebp),%ebx
10e8f1: 74 dd je 10e8d0 <_Watchdog_Tickle+0x2c>
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
10e8f3: 8b 43 10 mov 0x10(%ebx),%eax
10e8f6: 85 c0 test %eax,%eax
10e8f8: 75 d6 jne 10e8d0 <_Watchdog_Tickle+0x2c>
if ( the_watchdog->delta_interval != 0 )
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
10e8fa: 83 ec 0c sub $0xc,%esp
10e8fd: 53 push %ebx
10e8fe: e8 35 ff ff ff call 10e838 <_Watchdog_Remove>
_ISR_Enable( level );
10e903: 56 push %esi
10e904: 9d popf
switch( watchdog_state ) {
10e905: 83 c4 10 add $0x10,%esp
10e908: 83 f8 02 cmp $0x2,%eax
10e90b: 75 dc jne 10e8e9 <_Watchdog_Tickle+0x45> <== NEVER TAKEN
10e90d: eb cb jmp 10e8da <_Watchdog_Tickle+0x36>
0010e910 <_Workspace_Handler_initialization>:
/*
* _Workspace_Handler_initialization
*/
void _Workspace_Handler_initialization(void)
{
10e910: 55 push %ebp
10e911: 89 e5 mov %esp,%ebp
10e913: 57 push %edi
10e914: 53 push %ebx
uintptr_t memory_available = 0;
void *starting_address = Configuration.work_space_start;
10e915: 8b 1d 80 32 12 00 mov 0x123280,%ebx
uintptr_t size = Configuration.work_space_size;
10e91b: 8b 15 84 32 12 00 mov 0x123284,%edx
if ( Configuration.do_zero_of_workspace )
10e921: 80 3d ac 32 12 00 00 cmpb $0x0,0x1232ac
10e928: 75 1e jne 10e948 <_Workspace_Handler_initialization+0x38>
memset( starting_address, 0, size );
memory_available = _Heap_Initialize(
10e92a: 6a 04 push $0x4
10e92c: 52 push %edx
10e92d: 53 push %ebx
10e92e: 68 a0 75 12 00 push $0x1275a0
10e933: e8 b8 dd ff ff call 10c6f0 <_Heap_Initialize>
starting_address,
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
10e938: 83 c4 10 add $0x10,%esp
10e93b: 85 c0 test %eax,%eax
10e93d: 74 13 je 10e952 <_Workspace_Handler_initialization+0x42>
_Internal_error_Occurred(
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_TOO_LITTLE_WORKSPACE
);
}
10e93f: 8d 65 f8 lea -0x8(%ebp),%esp
10e942: 5b pop %ebx
10e943: 5f pop %edi
10e944: c9 leave
10e945: c3 ret
10e946: 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 );
10e948: 31 c0 xor %eax,%eax
10e94a: 89 df mov %ebx,%edi
10e94c: 89 d1 mov %edx,%ecx
10e94e: f3 aa rep stos %al,%es:(%edi)
10e950: eb d8 jmp 10e92a <_Workspace_Handler_initialization+0x1a>
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
_Internal_error_Occurred(
10e952: 50 push %eax
10e953: 6a 02 push $0x2
10e955: 6a 01 push $0x1
10e957: 6a 00 push $0x0
10e959: e8 9a df ff ff call 10c8f8 <_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 76 a9 00 00 call 116f64 <__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 35 12 00 mov 0x1235ac,%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 78 7e 12 00 mov 0x127e78,%eax
10adc0: 05 84 00 00 00 add $0x84,%eax
10adc5: 50 push %eax
10adc6: e8 61 38 00 00 call 10e62c <_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 ff 87 00 00 call 1135f4 <__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 8c 47 12 00 cmp 0x12478c,%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 b0 8b 12 00 mov 0x128bb0,%eax
10b641: 40 inc %eax
10b642: a3 b0 8b 12 00 mov %eax,0x128bb0
* 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 89 17 00 00 call 10cddc <_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 ac 17 00 00 call 10ce64 <_TOD_Set>
_Thread_Enable_dispatch();
10b6b8: e8 ef 2b 00 00 call 10e2ac <_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 e7 86 00 00 call 113dc8 <__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 80 a1 12 00 push $0x12a180
10bd28: e8 73 11 00 00 call 10cea0 <pthread_mutex_lock>
if (fcntl (fildes, F_GETFD) < 0) {
10bd2d: 5f pop %edi
10bd2e: 58 pop %eax
10bd2f: 6a 01 push $0x1
10bd31: 56 push %esi
10bd32: e8 91 6a 00 00 call 1127c8 <fcntl>
10bd37: 83 c4 10 add $0x10,%esp
10bd3a: 85 c0 test %eax,%eax
10bd3c: 0f 88 73 01 00 00 js 10beb5 <aio_cancel+0x1a1>
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 82 00 00 00 je 10bdcc <aio_cancel+0xb8>
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 3c 01 00 00 jne 10be90 <aio_cancel+0x17c>
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: 52 push %edx
10bd55: 6a 00 push $0x0
10bd57: 57 push %edi
10bd58: 68 c8 a1 12 00 push $0x12a1c8
10bd5d: e8 76 03 00 00 call 10c0d8 <rtems_aio_search_fd>
if (r_chain == NULL) {
10bd62: 83 c4 10 add $0x10,%esp
10bd65: 85 c0 test %eax,%eax
10bd67: 74 0f je 10bd78 <aio_cancel+0x64>
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
}
return AIO_ALLDONE;
10bd69: bb 02 00 00 00 mov $0x2,%ebx
}
10bd6e: 89 d8 mov %ebx,%eax
10bd70: 8d 65 f4 lea -0xc(%ebp),%esp
10bd73: 5b pop %ebx
10bd74: 5e pop %esi
10bd75: 5f pop %edi
10bd76: c9 leave
10bd77: c3 ret
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)) {
10bd78: 81 3d d4 a1 12 00 d8 cmpl $0x12a1d8,0x12a1d4
10bd7f: a1 12 00
10bd82: 0f 84 98 00 00 00 je 10be20 <aio_cancel+0x10c> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
10bd88: 50 push %eax
10bd89: 6a 00 push $0x0
10bd8b: 57 push %edi
10bd8c: 68 d4 a1 12 00 push $0x12a1d4
10bd91: e8 42 03 00 00 call 10c0d8 <rtems_aio_search_fd>
if (r_chain == NULL) {
10bd96: 83 c4 10 add $0x10,%esp
10bd99: 85 c0 test %eax,%eax
10bd9b: 0f 84 ef 00 00 00 je 10be90 <aio_cancel+0x17c>
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
10bda1: 83 ec 08 sub $0x8,%esp
10bda4: 53 push %ebx
10bda5: 83 c0 08 add $0x8,%eax
10bda8: 50 push %eax
10bda9: e8 ee 06 00 00 call 10c49c <rtems_aio_remove_req>
10bdae: 89 c3 mov %eax,%ebx
pthread_mutex_unlock (&aio_request_queue.mutex);
10bdb0: c7 04 24 80 a1 12 00 movl $0x12a180,(%esp)
10bdb7: e8 6c 11 00 00 call 10cf28 <pthread_mutex_unlock>
return result;
10bdbc: 83 c4 10 add $0x10,%esp
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
}
return AIO_ALLDONE;
}
10bdbf: 89 d8 mov %ebx,%eax
10bdc1: 8d 65 f4 lea -0xc(%ebp),%esp
10bdc4: 5b pop %ebx
10bdc5: 5e pop %esi
10bdc6: 5f pop %edi
10bdc7: c9 leave
10bdc8: c3 ret
10bdc9: 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);
10bdcc: 53 push %ebx
10bdcd: 6a 00 push $0x0
10bdcf: 56 push %esi
10bdd0: 68 c8 a1 12 00 push $0x12a1c8
10bdd5: e8 fe 02 00 00 call 10c0d8 <rtems_aio_search_fd>
10bdda: 89 c3 mov %eax,%ebx
if (r_chain == NULL) {
10bddc: 83 c4 10 add $0x10,%esp
10bddf: 85 c0 test %eax,%eax
10bde1: 74 59 je 10be3c <aio_cancel+0x128>
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
10bde3: 8d 70 1c lea 0x1c(%eax),%esi
10bde6: 83 ec 0c sub $0xc,%esp
10bde9: 56 push %esi
10bdea: e8 b1 10 00 00 call 10cea0 <pthread_mutex_lock>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10bdef: 89 1c 24 mov %ebx,(%esp)
10bdf2: e8 7d 2a 00 00 call 10e874 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10bdf7: 89 1c 24 mov %ebx,(%esp)
10bdfa: e8 4d 06 00 00 call 10c44c <rtems_aio_remove_fd>
pthread_mutex_unlock (&r_chain->mutex);
10bdff: 89 34 24 mov %esi,(%esp)
10be02: e8 21 11 00 00 call 10cf28 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
10be07: c7 04 24 80 a1 12 00 movl $0x12a180,(%esp)
10be0e: e8 15 11 00 00 call 10cf28 <pthread_mutex_unlock>
return AIO_CANCELED;
10be13: 83 c4 10 add $0x10,%esp
10be16: 31 db xor %ebx,%ebx
10be18: e9 51 ff ff ff jmp 10bd6e <aio_cancel+0x5a>
10be1d: 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);
10be20: 83 ec 0c sub $0xc,%esp
10be23: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED
10be28: e8 fb 10 00 00 call 10cf28 <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
10be2d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10be30: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED
10be35: e9 34 ff ff ff jmp 10bd6e <aio_cancel+0x5a> <== NOT EXECUTED
10be3a: 66 90 xchg %ax,%ax <== NOT EXECUTED
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)) {
10be3c: 81 3d d4 a1 12 00 d8 cmpl $0x12a1d8,0x12a1d4
10be43: a1 12 00
10be46: 74 d8 je 10be20 <aio_cancel+0x10c> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
10be48: 51 push %ecx
10be49: 6a 00 push $0x0
10be4b: 56 push %esi
10be4c: 68 d4 a1 12 00 push $0x12a1d4
10be51: e8 82 02 00 00 call 10c0d8 <rtems_aio_search_fd>
10be56: 89 c3 mov %eax,%ebx
if (r_chain == NULL) {
10be58: 83 c4 10 add $0x10,%esp
10be5b: 85 c0 test %eax,%eax
10be5d: 74 7b je 10beda <aio_cancel+0x1c6>
10be5f: 83 ec 0c sub $0xc,%esp
10be62: 50 push %eax
10be63: e8 0c 2a 00 00 call 10e874 <_Chain_Extract>
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10be68: 89 1c 24 mov %ebx,(%esp)
10be6b: e8 dc 05 00 00 call 10c44c <rtems_aio_remove_fd>
pthread_mutex_destroy (&r_chain->mutex);
10be70: 8d 73 1c lea 0x1c(%ebx),%esi
10be73: 89 34 24 mov %esi,(%esp)
10be76: e8 b9 0d 00 00 call 10cc34 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->mutex);
10be7b: 89 34 24 mov %esi,(%esp)
10be7e: e8 6d 0a 00 00 call 10c8f0 <pthread_cond_destroy>
free (r_chain);
10be83: 89 1c 24 mov %ebx,(%esp)
10be86: e8 a9 cc ff ff call 108b34 <free>
10be8b: e9 77 ff ff ff jmp 10be07 <aio_cancel+0xf3>
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);
10be90: 83 ec 0c sub $0xc,%esp
10be93: 68 80 a1 12 00 push $0x12a180
10be98: e8 8b 10 00 00 call 10cf28 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
10be9d: e8 5a 9d 00 00 call 115bfc <__errno>
10bea2: c7 00 16 00 00 00 movl $0x16,(%eax)
10bea8: 83 c4 10 add $0x10,%esp
10beab: bb ff ff ff ff mov $0xffffffff,%ebx
10beb0: e9 b9 fe ff ff jmp 10bd6e <aio_cancel+0x5a>
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
if (fcntl (fildes, F_GETFD) < 0) {
pthread_mutex_unlock(&aio_request_queue.mutex);
10beb5: 83 ec 0c sub $0xc,%esp
10beb8: 68 80 a1 12 00 push $0x12a180
10bebd: e8 66 10 00 00 call 10cf28 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
10bec2: e8 35 9d 00 00 call 115bfc <__errno>
10bec7: c7 00 09 00 00 00 movl $0x9,(%eax)
10becd: 83 c4 10 add $0x10,%esp
10bed0: bb ff ff ff ff mov $0xffffffff,%ebx
10bed5: e9 94 fe ff ff jmp 10bd6e <aio_cancel+0x5a>
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);
10beda: 83 ec 0c sub $0xc,%esp
10bedd: 68 80 a1 12 00 push $0x12a180
10bee2: e8 41 10 00 00 call 10cf28 <pthread_mutex_unlock>
return AIO_ALLDONE;
10bee7: 83 c4 10 add $0x10,%esp
10beea: b3 02 mov $0x2,%bl
10beec: e9 7d fe ff ff jmp 10bd6e <aio_cancel+0x5a>
0010bf00 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
10bf00: 55 push %ebp
10bf01: 89 e5 mov %esp,%ebp
10bf03: 53 push %ebx
10bf04: 83 ec 04 sub $0x4,%esp
10bf07: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
10bf0a: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp)
10bf11: 75 41 jne 10bf54 <aio_fsync+0x54>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10bf13: 83 ec 08 sub $0x8,%esp
10bf16: 6a 03 push $0x3
10bf18: ff 33 pushl (%ebx)
10bf1a: e8 a9 68 00 00 call 1127c8 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10bf1f: 83 e0 03 and $0x3,%eax
10bf22: 48 dec %eax
10bf23: 83 c4 10 add $0x10,%esp
10bf26: 83 f8 01 cmp $0x1,%eax
10bf29: 77 4d ja 10bf78 <aio_fsync+0x78>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
10bf2b: 83 ec 0c sub $0xc,%esp
10bf2e: 6a 18 push $0x18
10bf30: e8 13 d1 ff ff call 109048 <malloc>
if (req == NULL)
10bf35: 83 c4 10 add $0x10,%esp
10bf38: 85 c0 test %eax,%eax
10bf3a: 74 57 je 10bf93 <aio_fsync+0x93> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
10bf3c: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_SYNC;
10bf3f: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx)
return rtems_aio_enqueue (req);
10bf46: 89 45 08 mov %eax,0x8(%ebp)
}
10bf49: 8b 5d fc mov -0x4(%ebp),%ebx
10bf4c: 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);
10bf4d: e9 ba 05 00 00 jmp 10c50c <rtems_aio_enqueue>
10bf52: 66 90 xchg %ax,%ax
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10bf54: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10bf5b: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10bf62: e8 95 9c 00 00 call 115bfc <__errno>
10bf67: c7 00 16 00 00 00 movl $0x16,(%eax)
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
}
10bf6d: b8 ff ff ff ff mov $0xffffffff,%eax
10bf72: 8b 5d fc mov -0x4(%ebp),%ebx
10bf75: c9 leave
10bf76: c3 ret
10bf77: 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);
10bf78: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10bf7f: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10bf86: e8 71 9c 00 00 call 115bfc <__errno>
10bf8b: c7 00 09 00 00 00 movl $0x9,(%eax)
10bf91: eb da jmp 10bf6d <aio_fsync+0x6d>
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10bf93: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx)
10bf9a: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10bfa1: e8 56 9c 00 00 call 115bfc <__errno> <== NOT EXECUTED
10bfa6: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10bfac: eb bf jmp 10bf6d <aio_fsync+0x6d> <== NOT EXECUTED
0010c714 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
10c714: 55 push %ebp
10c715: 89 e5 mov %esp,%ebp
10c717: 53 push %ebx
10c718: 83 ec 0c sub $0xc,%esp
10c71b: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10c71e: 6a 03 push $0x3
10c720: ff 33 pushl (%ebx)
10c722: e8 a1 60 00 00 call 1127c8 <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10c727: 83 c4 10 add $0x10,%esp
10c72a: 83 e0 03 and $0x3,%eax
10c72d: 74 05 je 10c734 <aio_read+0x20> <== NEVER TAKEN
10c72f: 83 f8 02 cmp $0x2,%eax
10c732: 75 38 jne 10c76c <aio_read+0x58>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10c734: 8b 53 14 mov 0x14(%ebx),%edx
10c737: 85 d2 test %edx,%edx
10c739: 75 55 jne 10c790 <aio_read+0x7c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10c73b: 8b 43 08 mov 0x8(%ebx),%eax
10c73e: 85 c0 test %eax,%eax
10c740: 78 4e js 10c790 <aio_read+0x7c>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
10c742: 83 ec 0c sub $0xc,%esp
10c745: 6a 18 push $0x18
10c747: e8 fc c8 ff ff call 109048 <malloc>
if (req == NULL)
10c74c: 83 c4 10 add $0x10,%esp
10c74f: 85 c0 test %eax,%eax
10c751: 74 58 je 10c7ab <aio_read+0x97> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
10c753: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_READ;
10c756: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx)
return rtems_aio_enqueue (req);
10c75d: 89 45 08 mov %eax,0x8(%ebp)
}
10c760: 8b 5d fc mov -0x4(%ebp),%ebx
10c763: 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);
10c764: e9 a3 fd ff ff jmp 10c50c <rtems_aio_enqueue>
10c769: 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);
10c76c: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10c773: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10c77a: e8 7d 94 00 00 call 115bfc <__errno>
10c77f: c7 00 09 00 00 00 movl $0x9,(%eax)
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
}
10c785: b8 ff ff ff ff mov $0xffffffff,%eax
10c78a: 8b 5d fc mov -0x4(%ebp),%ebx
10c78d: c9 leave
10c78e: c3 ret
10c78f: 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);
10c790: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10c797: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10c79e: e8 59 94 00 00 call 115bfc <__errno>
10c7a3: c7 00 16 00 00 00 movl $0x16,(%eax)
10c7a9: eb da jmp 10c785 <aio_read+0x71>
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10c7ab: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10c7b2: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10c7b9: e8 3e 94 00 00 call 115bfc <__errno> <== NOT EXECUTED
10c7be: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10c7c4: eb bf jmp 10c785 <aio_read+0x71> <== NOT EXECUTED
0010c7d4 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
10c7d4: 55 push %ebp
10c7d5: 89 e5 mov %esp,%ebp
10c7d7: 53 push %ebx
10c7d8: 83 ec 0c sub $0xc,%esp
10c7db: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10c7de: 6a 03 push $0x3
10c7e0: ff 33 pushl (%ebx)
10c7e2: e8 e1 5f 00 00 call 1127c8 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10c7e7: 83 e0 03 and $0x3,%eax
10c7ea: 48 dec %eax
10c7eb: 83 c4 10 add $0x10,%esp
10c7ee: 83 f8 01 cmp $0x1,%eax
10c7f1: 77 35 ja 10c828 <aio_write+0x54>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10c7f3: 8b 53 14 mov 0x14(%ebx),%edx
10c7f6: 85 d2 test %edx,%edx
10c7f8: 75 52 jne 10c84c <aio_write+0x78>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10c7fa: 8b 43 08 mov 0x8(%ebx),%eax
10c7fd: 85 c0 test %eax,%eax
10c7ff: 78 4b js 10c84c <aio_write+0x78>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
10c801: 83 ec 0c sub $0xc,%esp
10c804: 6a 18 push $0x18
10c806: e8 3d c8 ff ff call 109048 <malloc>
if (req == NULL)
10c80b: 83 c4 10 add $0x10,%esp
10c80e: 85 c0 test %eax,%eax
10c810: 74 55 je 10c867 <aio_write+0x93> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
10c812: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_WRITE;
10c815: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx)
return rtems_aio_enqueue (req);
10c81c: 89 45 08 mov %eax,0x8(%ebp)
}
10c81f: 8b 5d fc mov -0x4(%ebp),%ebx
10c822: 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);
10c823: e9 e4 fc ff ff jmp 10c50c <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);
10c828: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10c82f: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10c836: e8 c1 93 00 00 call 115bfc <__errno>
10c83b: c7 00 09 00 00 00 movl $0x9,(%eax)
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
}
10c841: b8 ff ff ff ff mov $0xffffffff,%eax
10c846: 8b 5d fc mov -0x4(%ebp),%ebx
10c849: c9 leave
10c84a: c3 ret
10c84b: 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);
10c84c: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10c853: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10c85a: e8 9d 93 00 00 call 115bfc <__errno>
10c85f: c7 00 16 00 00 00 movl $0x16,(%eax)
10c865: eb da jmp 10c841 <aio_write+0x6d>
req = malloc (sizeof (rtems_aio_request));
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10c867: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10c86e: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10c875: e8 82 93 00 00 call 115bfc <__errno> <== NOT EXECUTED
10c87a: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10c880: eb bf jmp 10c841 <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 6f bb 00 00 call 114e8c <__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
001106a8 <chdir>:
#include <rtems/seterr.h>
int chdir(
const char *pathname
)
{
1106a8: 55 push %ebp
1106a9: 89 e5 mov %esp,%ebp
1106ab: 57 push %edi
1106ac: 56 push %esi
1106ad: 83 ec 20 sub $0x20,%esp
1106b0: 8b 55 08 mov 0x8(%ebp),%edx
rtems_filesystem_location_info_t loc;
int result;
if ( !pathname )
1106b3: 85 d2 test %edx,%edx
1106b5: 74 75 je 11072c <chdir+0x84>
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Get the node where we wish to go.
*/
result = rtems_filesystem_evaluate_path(
1106b7: 31 c0 xor %eax,%eax
1106b9: b9 ff ff ff ff mov $0xffffffff,%ecx
1106be: 89 d7 mov %edx,%edi
1106c0: f2 ae repnz scas %es:(%edi),%al
1106c2: f7 d1 not %ecx
1106c4: 49 dec %ecx
1106c5: 83 ec 0c sub $0xc,%esp
1106c8: 6a 01 push $0x1
1106ca: 8d 75 e4 lea -0x1c(%ebp),%esi
1106cd: 56 push %esi
1106ce: 6a 01 push $0x1
1106d0: 51 push %ecx
1106d1: 52 push %edx
1106d2: e8 31 7d ff ff call 108408 <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), RTEMS_LIBIO_PERMS_SEARCH, &loc, true );
if ( result != 0 )
1106d7: 83 c4 20 add $0x20,%esp
1106da: 85 c0 test %eax,%eax
1106dc: 74 0e je 1106ec <chdir+0x44>
return -1;
1106de: b8 ff ff ff ff mov $0xffffffff,%eax
rtems_filesystem_freenode( &rtems_filesystem_current );
rtems_filesystem_current = loc;
return 0;
}
1106e3: 8d 65 f8 lea -0x8(%ebp),%esp
1106e6: 5e pop %esi
1106e7: 5f pop %edi
1106e8: c9 leave
1106e9: c3 ret
1106ea: 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 ) {
1106ec: 83 ec 0c sub $0xc,%esp
1106ef: 56 push %esi
1106f0: 8b 45 f0 mov -0x10(%ebp),%eax
1106f3: ff 50 10 call *0x10(%eax)
1106f6: 83 c4 10 add $0x10,%esp
1106f9: 48 dec %eax
1106fa: 75 48 jne 110744 <chdir+0x9c>
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTDIR );
}
rtems_filesystem_freenode( &rtems_filesystem_current );
1106fc: 83 ec 0c sub $0xc,%esp
1106ff: a1 b0 5a 12 00 mov 0x125ab0,%eax
110704: 83 c0 04 add $0x4,%eax
110707: 50 push %eax
110708: e8 d3 7d ff ff call 1084e0 <rtems_filesystem_freenode>
rtems_filesystem_current = loc;
11070d: 8b 3d b0 5a 12 00 mov 0x125ab0,%edi
110713: 83 c7 04 add $0x4,%edi
110716: b9 05 00 00 00 mov $0x5,%ecx
11071b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return 0;
11071d: 83 c4 10 add $0x10,%esp
110720: 31 c0 xor %eax,%eax
}
110722: 8d 65 f8 lea -0x8(%ebp),%esp
110725: 5e pop %esi
110726: 5f pop %edi
110727: c9 leave
110728: c3 ret
110729: 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 );
11072c: e8 8f 34 00 00 call 113bc0 <__errno>
110731: c7 00 0e 00 00 00 movl $0xe,(%eax)
110737: b8 ff ff ff ff mov $0xffffffff,%eax
rtems_filesystem_freenode( &rtems_filesystem_current );
rtems_filesystem_current = loc;
return 0;
}
11073c: 8d 65 f8 lea -0x8(%ebp),%esp
11073f: 5e pop %esi
110740: 5f pop %edi
110741: c9 leave
110742: c3 ret
110743: 90 nop
/*
* Verify you can change directory into this node.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_filesystem_freenode( &loc );
110744: 83 ec 0c sub $0xc,%esp
110747: 56 push %esi
110748: e8 93 7d ff ff call 1084e0 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( ENOTDIR );
11074d: e8 6e 34 00 00 call 113bc0 <__errno>
110752: c7 00 14 00 00 00 movl $0x14,(%eax)
110758: 83 c4 10 add $0x10,%esp
11075b: b8 ff ff ff ff mov $0xffffffff,%eax
110760: eb 81 jmp 1106e3 <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 b0 5a 12 00 60 cmpl $0x127d60,0x125ab0
10827f: 7d 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 19 84 00 00 call 1106a8 <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 b6 19 12 00 push $0x1219b6
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 b0 5a 12 00 mov 0x125ab0,%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 b0 5a 12 00 mov 0x125ab0,%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 b0 5a 12 00 60 cmpl $0x127d60,0x125ab0
1082f0: 7d 12 00
1082f3: 75 8f jne 108284 <chroot+0x14>
rtems_set_errno_and_return_minus_one( ENOTSUP );
1082f5: e8 c6 b8 00 00 call 113bc0 <__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 b3 b8 00 00 call 113bc0 <__errno>
10830d: 89 c6 mov %eax,%esi
10830f: e8 ac b8 00 00 call 113bc0 <__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 a3 8e 00 00 call 114320 <__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 8f 8e 00 00 call 114320 <__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 a3 1e 00 00 call 10d34c <_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 3f 1e 00 00 call 10d2f8 <_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 3c 8e 00 00 call 114320 <__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 90 85 12 00 mov 0x128590,%eax
10b501: 40 inc %eax
10b502: a3 90 85 12 00 mov %eax,0x128590
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 94 1e 00 00 call 10d3a4 <_TOD_Set>
_Thread_Enable_dispatch();
10b510: e8 d7 32 00 00 call 10e7ec <_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 ff 8d 00 00 call 114320 <__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
0010fc0c <close>:
#include <rtems/libio_.h>
int close(
int fd
)
{
10fc0c: 55 push %ebp
10fc0d: 89 e5 mov %esp,%ebp
10fc0f: 53 push %ebx
10fc10: 83 ec 14 sub $0x14,%esp
10fc13: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_t *iop;
rtems_status_code rc;
rtems_libio_check_fd(fd);
10fc16: 3b 05 ac 31 12 00 cmp 0x1231ac,%eax
10fc1c: 73 46 jae 10fc64 <close+0x58>
iop = rtems_libio_iop(fd);
10fc1e: c1 e0 03 shl $0x3,%eax
10fc21: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx
10fc28: 29 c3 sub %eax,%ebx
10fc2a: 03 1d 00 74 12 00 add 0x127400,%ebx
rtems_libio_check_is_open(iop);
10fc30: f6 43 15 01 testb $0x1,0x15(%ebx)
10fc34: 74 2e je 10fc64 <close+0x58>
rc = RTEMS_SUCCESSFUL;
rc = (*iop->pathinfo.handlers->close_h)( iop );
10fc36: 83 ec 0c sub $0xc,%esp
10fc39: 8b 43 20 mov 0x20(%ebx),%eax
10fc3c: 53 push %ebx
10fc3d: ff 50 04 call *0x4(%eax)
rtems_filesystem_freenode( &iop->pathinfo );
10fc40: 8d 53 18 lea 0x18(%ebx),%edx
10fc43: 89 14 24 mov %edx,(%esp)
10fc46: 89 45 f4 mov %eax,-0xc(%ebp)
10fc49: e8 52 84 ff ff call 1080a0 <rtems_filesystem_freenode>
rtems_libio_free( iop );
10fc4e: 89 1c 24 mov %ebx,(%esp)
10fc51: e8 26 02 00 00 call 10fe7c <rtems_libio_free>
return rc;
10fc56: 83 c4 10 add $0x10,%esp
10fc59: 8b 45 f4 mov -0xc(%ebp),%eax
}
10fc5c: 8b 5d fc mov -0x4(%ebp),%ebx
10fc5f: c9 leave
10fc60: c3 ret
10fc61: 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);
10fc64: e8 ab 36 00 00 call 113314 <__errno>
10fc69: c7 00 09 00 00 00 movl $0x9,(%eax)
10fc6f: b8 ff ff ff ff mov $0xffffffff,%eax
10fc74: eb e6 jmp 10fc5c <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 6b d6 11 00 mov $0x11d66b,%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 6b d6 11 00 mov $0x11d66b,%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
0010ee58 <devFS_evaluate_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
10ee58: 55 push %ebp
10ee59: 89 e5 mov %esp,%ebp
10ee5b: 57 push %edi
10ee5c: 56 push %esi
10ee5d: 53 push %ebx
10ee5e: 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 ) )
10ee61: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp)
10ee68: 0f 85 96 00 00 00 jne 10ef04 <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;
10ee6e: 8b 45 14 mov 0x14(%ebp),%eax
10ee71: 8b 00 mov (%eax),%eax
10ee73: 89 45 e4 mov %eax,-0x1c(%ebp)
if (!device_name_table)
10ee76: 85 c0 test %eax,%eax
10ee78: 0f 84 98 00 00 00 je 10ef16 <devFS_evaluate_path+0xbe>
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
10ee7e: 8b 15 d0 0c 12 00 mov 0x120cd0,%edx
10ee84: 89 55 e0 mov %edx,-0x20(%ebp)
10ee87: 85 d2 test %edx,%edx
10ee89: 74 38 je 10eec3 <devFS_evaluate_path+0x6b><== NEVER TAKEN
10ee8b: 31 c0 xor %eax,%eax
10ee8d: 31 db xor %ebx,%ebx
if (!device_name_table[i].device_name)
10ee8f: 8d 04 80 lea (%eax,%eax,4),%eax
10ee92: 8b 55 e4 mov -0x1c(%ebp),%edx
10ee95: 8d 3c 82 lea (%edx,%eax,4),%edi
10ee98: 8b 37 mov (%edi),%esi
10ee9a: 85 f6 test %esi,%esi
10ee9c: 74 1d je 10eebb <devFS_evaluate_path+0x63>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
10ee9e: 50 push %eax
10ee9f: ff 75 0c pushl 0xc(%ebp)
10eea2: 56 push %esi
10eea3: ff 75 08 pushl 0x8(%ebp)
10eea6: e8 79 32 00 00 call 112124 <strncmp>
10eeab: 83 c4 10 add $0x10,%esp
10eeae: 85 c0 test %eax,%eax
10eeb0: 75 09 jne 10eebb <devFS_evaluate_path+0x63>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
10eeb2: 8b 45 0c mov 0xc(%ebp),%eax
10eeb5: 80 3c 06 00 cmpb $0x0,(%esi,%eax,1)
10eeb9: 74 21 je 10eedc <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++) {
10eebb: 43 inc %ebx
10eebc: 89 d8 mov %ebx,%eax
10eebe: 39 5d e0 cmp %ebx,-0x20(%ebp)
10eec1: 77 cc ja 10ee8f <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 );
10eec3: e8 20 26 00 00 call 1114e8 <__errno>
10eec8: c7 00 02 00 00 00 movl $0x2,(%eax)
10eece: b8 ff ff ff ff mov $0xffffffff,%eax
}
10eed3: 8d 65 f4 lea -0xc(%ebp),%esp
10eed6: 5b pop %ebx
10eed7: 5e pop %esi
10eed8: 5f pop %edi
10eed9: c9 leave
10eeda: c3 ret
10eedb: 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];
10eedc: 8b 55 14 mov 0x14(%ebp),%edx
10eedf: 89 3a mov %edi,(%edx)
pathloc->handlers = &devFS_file_handlers;
10eee1: c7 42 08 20 2c 12 00 movl $0x122c20,0x8(%edx)
pathloc->ops = &devFS_ops;
10eee8: c7 42 0c c0 2b 12 00 movl $0x122bc0,0xc(%edx)
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
10eeef: a1 90 2d 12 00 mov 0x122d90,%eax
10eef4: 8b 40 28 mov 0x28(%eax),%eax
10eef7: 89 42 10 mov %eax,0x10(%edx)
return 0;
10eefa: 31 c0 xor %eax,%eax
}
/* no such file or directory */
rtems_set_errno_and_return_minus_one( ENOENT );
}
10eefc: 8d 65 f4 lea -0xc(%ebp),%esp
10eeff: 5b pop %ebx
10ef00: 5e pop %esi
10ef01: 5f pop %edi
10ef02: c9 leave
10ef03: 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 );
10ef04: e8 df 25 00 00 call 1114e8 <__errno> <== NOT EXECUTED
10ef09: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
10ef0f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10ef14: eb e6 jmp 10eefc <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 );
10ef16: e8 cd 25 00 00 call 1114e8 <__errno>
10ef1b: c7 00 0e 00 00 00 movl $0xe,(%eax)
10ef21: 83 c8 ff or $0xffffffff,%eax
10ef24: eb d6 jmp 10eefc <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 22 40 00 00 call 10bb2c <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 17 74 00 00 call 10ef38 <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 d0 0c 12 00 mov 0x120cd0,%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 34 a7 00 00 call 1120cc <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 df 9a 00 00 call 1114e8 <__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 a5 9a 00 00 call 1114e8 <__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 93 9a 00 00 call 1114e8 <__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 83 9a 00 00 call 1114e8 <__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>
00112714 <device_ioctl>:
int device_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
112714: 55 push %ebp
112715: 89 e5 mov %esp,%ebp
112717: 83 ec 1c sub $0x1c,%esp
11271a: 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;
11271d: 89 45 e8 mov %eax,-0x18(%ebp)
args.command = command;
112720: 8b 55 0c mov 0xc(%ebp),%edx
112723: 89 55 ec mov %edx,-0x14(%ebp)
args.buffer = buffer;
112726: 8b 55 10 mov 0x10(%ebp),%edx
112729: 89 55 f0 mov %edx,-0x10(%ebp)
the_jnode = iop->pathinfo.node_access;
11272c: 8b 40 18 mov 0x18(%eax),%eax
status = rtems_io_control(
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
11272f: 8d 55 e8 lea -0x18(%ebp),%edx
args.command = command;
args.buffer = buffer;
the_jnode = iop->pathinfo.node_access;
status = rtems_io_control(
112732: 52 push %edx
112733: ff 70 54 pushl 0x54(%eax)
112736: ff 70 50 pushl 0x50(%eax)
112739: e8 fa 08 00 00 call 113038 <rtems_io_control>
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
11273e: 83 c4 10 add $0x10,%esp
112741: 85 c0 test %eax,%eax
112743: 75 07 jne 11274c <device_ioctl+0x38>
return rtems_deviceio_errno(status);
return args.ioctl_return;
112745: 8b 45 f4 mov -0xc(%ebp),%eax
}
112748: c9 leave
112749: c3 ret
11274a: 66 90 xchg %ax,%ax
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
11274c: 83 ec 0c sub $0xc,%esp
11274f: 50 push %eax
112750: e8 33 0b 00 00 call 113288 <rtems_deviceio_errno>
112755: 83 c4 10 add $0x10,%esp
return args.ioctl_return;
}
112758: c9 leave
112759: 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 ee 2c 00 00 call 10bd00 <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 b4 52 12 00 mov 0x1252b4,%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 e0 8a 12 00 mov 0x128ae0,%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 50 b3 00 00 call 1142cc <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 c8 8b 12 00 mov 0x128bc8,%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 a8 b4 00 00 call 1142cc <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 b4 52 12 00 mov 0x1252b4,%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 0c 12 00 push $0x120c06
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 b4 52 12 00 mov 0x1252b4,%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 0c 12 00 push $0x120c08
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 0c 12 00 push $0x120c06 <== 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 b4 52 12 00 mov 0x1252b4,%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 ec 45 12 00 cmp 0x1245ec,%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 40 88 12 00 add 0x128840,%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 f0 65 12 00 mov 0x1265f0,%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 24 12 00 push $0x1224d6
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 f0 65 12 00 mov 0x1265f0,%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 e7 b5 00 00 call 1141d4 <__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 f0 65 12 00 mov 0x1265f0,%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 b7 b5 00 00 call 1141d4 <__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 a3 b5 00 00 call 1141d4 <__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 ec 45 12 00 cmp 0x1245ec,%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 40 88 12 00 add 0x128840,%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 43 b5 00 00 call 1141d4 <__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 2f b5 00 00 call 1141d4 <__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 cc 4d 12 00 mov 0x124dcc,%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 20 90 12 00 mov 0x129020,%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 43 b9 00 00 call 114474 <__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 d0 26 12 00 jmp *0x1226d0(,%edx,4)
108b43: 90 nop
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
108b44: e8 2b b9 00 00 call 114474 <__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 d3 b8 00 00 call 114474 <__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 13 b8 00 00 call 114474 <__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 20 90 12 00 mov 0x129020,%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 cc 4d 12 00 cmp 0x124dcc,%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 20 90 12 00 add 0x129020,%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 73 b7 00 00 call 114474 <__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 5f b7 00 00 call 114474 <__errno>
108d15: c7 00 16 00 00 00 movl $0x16,(%eax)
108d1b: eb ea jmp 108d07 <fdatasync+0x4b>
00111a70 <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
111a70: 55 push %ebp
111a71: 89 e5 mov %esp,%ebp
111a73: 57 push %edi
111a74: 56 push %esi
111a75: 53 push %ebx
111a76: 83 ec 2c sub $0x2c,%esp
111a79: 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) {
111a7c: a1 ec 9b 12 00 mov 0x129bec,%eax
111a81: 85 c0 test %eax,%eax
111a83: 0f 84 8b 00 00 00 je 111b14 <fifo_open+0xa4>
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
111a89: 53 push %ebx
111a8a: 6a 00 push $0x0
111a8c: 6a 00 push $0x0
111a8e: 50 push %eax
111a8f: e8 40 ba ff ff call 10d4d4 <rtems_semaphore_obtain>
}
if (sc == RTEMS_SUCCESSFUL) {
111a94: 83 c4 10 add $0x10,%esp
111a97: 85 c0 test %eax,%eax
111a99: 0f 85 4c 03 00 00 jne 111deb <fifo_open+0x37b> <== NEVER TAKEN
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
111a9f: 8b 1e mov (%esi),%ebx
if (pipe == NULL) {
111aa1: 85 db test %ebx,%ebx
111aa3: 0f 84 df 01 00 00 je 111c88 <fifo_open+0x218>
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
111aa9: 52 push %edx
111aaa: 6a 00 push $0x0
111aac: 6a 00 push $0x0
111aae: ff 73 28 pushl 0x28(%ebx)
111ab1: e8 1e ba ff ff call 10d4d4 <rtems_semaphore_obtain>
111ab6: 83 c4 10 add $0x10,%esp
111ab9: 83 f8 01 cmp $0x1,%eax
111abc: 19 ff sbb %edi,%edi
111abe: f7 d7 not %edi
111ac0: 83 e7 fc and $0xfffffffc,%edi
err = -EINTR;
if (*pipep == NULL) {
111ac3: 8b 06 mov (%esi),%eax
111ac5: 85 c0 test %eax,%eax
111ac7: 0f 84 d7 02 00 00 je 111da4 <fifo_open+0x334>
else
*pipep = pipe;
}
out:
pipe_unlock();
111acd: e8 aa fe ff ff call 11197c <pipe_unlock>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
111ad2: 85 ff test %edi,%edi
111ad4: 75 32 jne 111b08 <fifo_open+0x98> <== NEVER TAKEN
return err;
pipe = *pipep;
111ad6: 8b 1e mov (%esi),%ebx
switch (LIBIO_ACCMODE(iop)) {
111ad8: 8b 55 0c mov 0xc(%ebp),%edx
111adb: 8b 42 14 mov 0x14(%edx),%eax
111ade: 83 e0 06 and $0x6,%eax
111ae1: 83 f8 04 cmp $0x4,%eax
111ae4: 74 6a je 111b50 <fifo_open+0xe0>
111ae6: 83 f8 06 cmp $0x6,%eax
111ae9: 0f 84 59 01 00 00 je 111c48 <fifo_open+0x1d8>
111aef: 83 f8 02 cmp $0x2,%eax
111af2: 0f 84 dc 00 00 00 je 111bd4 <fifo_open+0x164> <== ALWAYS TAKEN
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
break;
}
PIPE_UNLOCK(pipe);
111af8: 83 ec 0c sub $0xc,%esp
111afb: ff 73 28 pushl 0x28(%ebx)
111afe: e8 cd ba ff ff call 10d5d0 <rtems_semaphore_release>
return 0;
111b03: 83 c4 10 add $0x10,%esp
111b06: 31 ff xor %edi,%edi
out_error:
pipe_release(pipep, iop);
return err;
}
111b08: 89 f8 mov %edi,%eax
111b0a: 8d 65 f4 lea -0xc(%ebp),%esp
111b0d: 5b pop %ebx
111b0e: 5e pop %esi
111b0f: 5f pop %edi
111b10: c9 leave
111b11: c3 ret
111b12: 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 );
111b14: 50 push %eax
111b15: 6a 00 push $0x0
111b17: 6a 00 push $0x0
111b19: ff 35 08 9e 12 00 pushl 0x129e08
111b1f: e8 b0 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) {
111b24: 83 c4 10 add $0x10,%esp
111b27: 8b 3d ec 9b 12 00 mov 0x129bec,%edi
111b2d: 85 ff test %edi,%edi
111b2f: 0f 84 83 02 00 00 je 111db8 <fifo_open+0x348> <== ALWAYS TAKEN
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
111b35: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
111b38: ff 35 08 9e 12 00 pushl 0x129e08 <== NOT EXECUTED
111b3e: e8 8d ba ff ff call 10d5d0 <rtems_semaphore_release><== NOT EXECUTED
111b43: a1 ec 9b 12 00 mov 0x129bec,%eax <== NOT EXECUTED
111b48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
111b4b: e9 39 ff ff ff jmp 111a89 <fifo_open+0x19> <== NOT EXECUTED
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
111b50: ff 43 24 incl 0x24(%ebx)
if (pipe->Writers ++ == 0)
111b53: 8b 43 14 mov 0x14(%ebx),%eax
111b56: 8d 50 01 lea 0x1(%eax),%edx
111b59: 89 53 14 mov %edx,0x14(%ebx)
111b5c: 85 c0 test %eax,%eax
111b5e: 0f 84 c4 02 00 00 je 111e28 <fifo_open+0x3b8> <== ALWAYS TAKEN
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
111b64: 8b 4b 10 mov 0x10(%ebx),%ecx
111b67: 85 c9 test %ecx,%ecx
111b69: 75 8d jne 111af8 <fifo_open+0x88>
111b6b: 8b 55 0c mov 0xc(%ebp),%edx
111b6e: f6 42 14 01 testb $0x1,0x14(%edx)
111b72: 0f 85 04 03 00 00 jne 111e7c <fifo_open+0x40c>
err = -ENXIO;
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
111b78: 8b 7b 20 mov 0x20(%ebx),%edi
111b7b: eb 20 jmp 111b9d <fifo_open+0x12d>
111b7d: 8d 76 00 lea 0x0(%esi),%esi
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
111b80: 51 push %ecx
111b81: 6a 00 push $0x0
111b83: 6a 00 push $0x0
111b85: ff 73 28 pushl 0x28(%ebx)
111b88: e8 47 b9 ff ff call 10d4d4 <rtems_semaphore_obtain>
111b8d: 83 c4 10 add $0x10,%esp
111b90: 85 c0 test %eax,%eax
111b92: 75 27 jne 111bbb <fifo_open+0x14b> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->readerCounter);
111b94: 39 7b 20 cmp %edi,0x20(%ebx)
111b97: 0f 85 5b ff ff ff jne 111af8 <fifo_open+0x88> <== ALWAYS TAKEN
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
111b9d: 83 ec 0c sub $0xc,%esp
111ba0: ff 73 28 pushl 0x28(%ebx)
111ba3: e8 28 ba ff ff call 10d5d0 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
111ba8: 58 pop %eax
111ba9: 5a pop %edx
111baa: 6a 00 push $0x0
111bac: ff 73 30 pushl 0x30(%ebx)
111baf: e8 b0 1c 00 00 call 113864 <rtems_barrier_wait>
111bb4: 83 c4 10 add $0x10,%esp
111bb7: 85 c0 test %eax,%eax
111bb9: 74 c5 je 111b80 <fifo_open+0x110> <== ALWAYS TAKEN
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
111bbb: bf fc ff ff ff mov $0xfffffffc,%edi <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
111bc0: 83 ec 08 sub $0x8,%esp
111bc3: ff 75 0c pushl 0xc(%ebp)
111bc6: 56 push %esi
111bc7: e8 c8 fd ff ff call 111994 <pipe_release>
return err;
111bcc: 83 c4 10 add $0x10,%esp
111bcf: e9 34 ff ff ff jmp 111b08 <fifo_open+0x98>
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
111bd4: ff 43 20 incl 0x20(%ebx)
if (pipe->Readers ++ == 0)
111bd7: 8b 43 10 mov 0x10(%ebx),%eax
111bda: 8d 50 01 lea 0x1(%eax),%edx
111bdd: 89 53 10 mov %edx,0x10(%ebx)
111be0: 85 c0 test %eax,%eax
111be2: 0f 84 10 02 00 00 je 111df8 <fifo_open+0x388> <== ALWAYS TAKEN
PIPE_WAKEUPWRITERS(pipe);
if (pipe->Writers == 0) {
111be8: 8b 7b 14 mov 0x14(%ebx),%edi
111beb: 85 ff test %edi,%edi
111bed: 0f 85 05 ff ff ff jne 111af8 <fifo_open+0x88>
/* Not an error */
if (LIBIO_NODELAY(iop))
111bf3: 8b 45 0c mov 0xc(%ebp),%eax
111bf6: f6 40 14 01 testb $0x1,0x14(%eax)
111bfa: 0f 85 f8 fe ff ff jne 111af8 <fifo_open+0x88>
break;
prevCounter = pipe->writerCounter;
111c00: 8b 7b 24 mov 0x24(%ebx),%edi
111c03: eb 20 jmp 111c25 <fifo_open+0x1b5>
111c05: 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))
111c08: 50 push %eax
111c09: 6a 00 push $0x0
111c0b: 6a 00 push $0x0
111c0d: ff 73 28 pushl 0x28(%ebx)
111c10: e8 bf b8 ff ff call 10d4d4 <rtems_semaphore_obtain>
111c15: 83 c4 10 add $0x10,%esp
111c18: 85 c0 test %eax,%eax
111c1a: 75 9f jne 111bbb <fifo_open+0x14b> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->writerCounter);
111c1c: 39 7b 24 cmp %edi,0x24(%ebx)
111c1f: 0f 85 d3 fe ff ff jne 111af8 <fifo_open+0x88> <== ALWAYS TAKEN
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
111c25: 83 ec 0c sub $0xc,%esp
111c28: ff 73 28 pushl 0x28(%ebx)
111c2b: e8 a0 b9 ff ff call 10d5d0 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
111c30: 5a pop %edx
111c31: 59 pop %ecx
111c32: 6a 00 push $0x0
111c34: ff 73 2c pushl 0x2c(%ebx)
111c37: e8 28 1c 00 00 call 113864 <rtems_barrier_wait>
111c3c: 83 c4 10 add $0x10,%esp
111c3f: 85 c0 test %eax,%eax
111c41: 74 c5 je 111c08 <fifo_open+0x198> <== ALWAYS TAKEN
111c43: e9 73 ff ff ff jmp 111bbb <fifo_open+0x14b> <== NOT EXECUTED
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
111c48: ff 43 20 incl 0x20(%ebx)
if (pipe->Readers ++ == 0)
111c4b: 8b 43 10 mov 0x10(%ebx),%eax
111c4e: 8d 50 01 lea 0x1(%eax),%edx
111c51: 89 53 10 mov %edx,0x10(%ebx)
111c54: 85 c0 test %eax,%eax
111c56: 0f 84 b4 01 00 00 je 111e10 <fifo_open+0x3a0> <== ALWAYS TAKEN
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
111c5c: ff 43 24 incl 0x24(%ebx)
if (pipe->Writers ++ == 0)
111c5f: 8b 43 14 mov 0x14(%ebx),%eax
111c62: 8d 50 01 lea 0x1(%eax),%edx
111c65: 89 53 14 mov %edx,0x14(%ebx)
111c68: 85 c0 test %eax,%eax
111c6a: 0f 85 88 fe ff ff jne 111af8 <fifo_open+0x88> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
111c70: 83 ec 08 sub $0x8,%esp
111c73: 8d 45 e4 lea -0x1c(%ebp),%eax
111c76: 50 push %eax
111c77: ff 73 2c pushl 0x2c(%ebx)
111c7a: e8 81 1b 00 00 call 113800 <rtems_barrier_release>
111c7f: 83 c4 10 add $0x10,%esp
111c82: e9 71 fe ff ff jmp 111af8 <fifo_open+0x88>
111c87: 90 nop
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
111c88: 83 ec 0c sub $0xc,%esp
111c8b: 6a 34 push $0x34
111c8d: e8 2e 84 ff ff call 10a0c0 <malloc>
111c92: 89 c3 mov %eax,%ebx
111c94: 89 45 d4 mov %eax,-0x2c(%ebp)
if (pipe == NULL)
111c97: 83 c4 10 add $0x10,%esp
111c9a: 85 c0 test %eax,%eax
111c9c: 0f 84 32 02 00 00 je 111ed4 <fifo_open+0x464>
return err;
memset(pipe, 0, sizeof(pipe_control_t));
111ca2: b9 34 00 00 00 mov $0x34,%ecx
111ca7: 31 c0 xor %eax,%eax
111ca9: 89 df mov %ebx,%edi
111cab: f3 aa rep stos %al,%es:(%edi)
pipe->Size = PIPE_BUF;
111cad: c7 43 04 00 02 00 00 movl $0x200,0x4(%ebx)
pipe->Buffer = malloc(pipe->Size);
111cb4: 83 ec 0c sub $0xc,%esp
111cb7: 68 00 02 00 00 push $0x200
111cbc: e8 ff 83 ff ff call 10a0c0 <malloc>
111cc1: 89 03 mov %eax,(%ebx)
if (! pipe->Buffer)
111cc3: 83 c4 10 add $0x10,%esp
111cc6: 85 c0 test %eax,%eax
111cc8: 0f 84 f8 01 00 00 je 111ec6 <fifo_open+0x456> <== NEVER TAKEN
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
111cce: 8d 43 2c lea 0x2c(%ebx),%eax
111cd1: 50 push %eax
111cd2: 6a 00 push $0x0
111cd4: 6a 00 push $0x0
rtems_build_name ('P', 'I', 'r', c),
111cd6: 0f be 05 b8 7b 12 00 movsbl 0x127bb8,%eax
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
111cdd: 0d 00 72 49 50 or $0x50497200,%eax
111ce2: 50 push %eax
111ce3: e8 9c 19 00 00 call 113684 <rtems_barrier_create>
111ce8: 83 c4 10 add $0x10,%esp
111ceb: 85 c0 test %eax,%eax
111ced: 0f 85 c3 01 00 00 jne 111eb6 <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(
111cf3: 8d 43 30 lea 0x30(%ebx),%eax
111cf6: 50 push %eax
111cf7: 6a 00 push $0x0
111cf9: 6a 00 push $0x0
rtems_build_name ('P', 'I', 'w', c),
111cfb: 0f be 05 b8 7b 12 00 movsbl 0x127bb8,%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(
111d02: 0d 00 77 49 50 or $0x50497700,%eax
111d07: 50 push %eax
111d08: e8 77 19 00 00 call 113684 <rtems_barrier_create>
111d0d: 83 c4 10 add $0x10,%esp
111d10: 85 c0 test %eax,%eax
111d12: 0f 85 8d 01 00 00 jne 111ea5 <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(
111d18: 83 ec 0c sub $0xc,%esp
111d1b: 8d 43 28 lea 0x28(%ebx),%eax
111d1e: 50 push %eax
111d1f: 6a 00 push $0x0
111d21: 6a 10 push $0x10
111d23: 6a 01 push $0x1
rtems_build_name ('P', 'I', 's', c), 1,
111d25: 0f be 05 b8 7b 12 00 movsbl 0x127bb8,%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(
111d2c: 0d 00 73 49 50 or $0x50497300,%eax
111d31: 50 push %eax
111d32: e8 21 b5 ff ff call 10d258 <rtems_semaphore_create>
111d37: 83 c4 20 add $0x20,%esp
111d3a: 85 c0 test %eax,%eax
111d3c: 0f 85 52 01 00 00 jne 111e94 <fifo_open+0x424>
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
_Objects_Get( &_Barrier_Information, id, location );
111d42: 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
111d43: 8d 7d e0 lea -0x20(%ebp),%edi
111d46: 57 push %edi
111d47: ff 73 2c pushl 0x2c(%ebx)
111d4a: 68 a0 a9 12 00 push $0x12a9a0
111d4f: e8 c8 ce ff ff call 10ec1c <_Objects_Get>
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
111d54: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax)
_Thread_Enable_dispatch();
111d5b: e8 a0 d9 ff ff call 10f700 <_Thread_Enable_dispatch>
111d60: 83 c4 0c add $0xc,%esp
111d63: 57 push %edi
111d64: ff 73 30 pushl 0x30(%ebx)
111d67: 68 a0 a9 12 00 push $0x12a9a0
111d6c: e8 ab ce ff ff call 10ec1c <_Objects_Get>
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
111d71: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax)
_Thread_Enable_dispatch();
111d78: e8 83 d9 ff ff call 10f700 <_Thread_Enable_dispatch>
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
111d7d: a0 b8 7b 12 00 mov 0x127bb8,%al
111d82: 8d 50 01 lea 0x1(%eax),%edx
111d85: 88 15 b8 7b 12 00 mov %dl,0x127bb8
111d8b: 83 c4 10 add $0x10,%esp
111d8e: 3c 7a cmp $0x7a,%al
111d90: 0f 85 13 fd ff ff jne 111aa9 <fifo_open+0x39>
c = 'a';
111d96: c6 05 b8 7b 12 00 61 movb $0x61,0x127bb8
111d9d: e9 07 fd ff ff jmp 111aa9 <fifo_open+0x39>
111da2: 66 90 xchg %ax,%ax
if (! PIPE_LOCK(pipe))
err = -EINTR;
if (*pipep == NULL) {
if (err)
111da4: 85 ff test %edi,%edi
111da6: 0f 85 94 00 00 00 jne 111e40 <fifo_open+0x3d0> <== NEVER TAKEN
pipe_free(pipe);
else
*pipep = pipe;
111dac: 89 1e mov %ebx,(%esi)
}
out:
pipe_unlock();
111dae: e8 c9 fb ff ff call 11197c <pipe_unlock>
111db3: e9 1e fd ff ff jmp 111ad6 <fifo_open+0x66>
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
sc = rtems_semaphore_create(
111db8: 83 ec 0c sub $0xc,%esp
111dbb: 68 ec 9b 12 00 push $0x129bec
111dc0: 6a 00 push $0x0
111dc2: 6a 54 push $0x54
111dc4: 6a 01 push $0x1
111dc6: 68 45 50 49 50 push $0x50495045
111dcb: e8 88 b4 ff ff call 10d258 <rtems_semaphore_create>
111dd0: 89 c3 mov %eax,%ebx
111dd2: 83 c4 14 add $0x14,%esp
111dd5: ff 35 08 9e 12 00 pushl 0x129e08
111ddb: e8 f0 b7 ff ff call 10d5d0 <rtems_semaphore_release>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
111de0: 83 c4 10 add $0x10,%esp
111de3: 85 db test %ebx,%ebx
111de5: 0f 84 f0 00 00 00 je 111edb <fifo_open+0x46b>
)
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
111deb: bf f4 ff ff ff mov $0xfffffff4,%edi
111df0: e9 13 fd ff ff jmp 111b08 <fifo_open+0x98>
111df5: 8d 76 00 lea 0x0(%esi),%esi
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
111df8: 83 ec 08 sub $0x8,%esp
111dfb: 8d 45 e4 lea -0x1c(%ebp),%eax
111dfe: 50 push %eax
111dff: ff 73 30 pushl 0x30(%ebx)
111e02: e8 f9 19 00 00 call 113800 <rtems_barrier_release>
111e07: 83 c4 10 add $0x10,%esp
111e0a: e9 d9 fd ff ff jmp 111be8 <fifo_open+0x178>
111e0f: 90 nop
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
111e10: 83 ec 08 sub $0x8,%esp
111e13: 8d 45 e4 lea -0x1c(%ebp),%eax
111e16: 50 push %eax
111e17: ff 73 30 pushl 0x30(%ebx)
111e1a: e8 e1 19 00 00 call 113800 <rtems_barrier_release>
111e1f: 83 c4 10 add $0x10,%esp
111e22: e9 35 fe ff ff jmp 111c5c <fifo_open+0x1ec>
111e27: 90 nop
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
111e28: 83 ec 08 sub $0x8,%esp
111e2b: 8d 45 e4 lea -0x1c(%ebp),%eax
111e2e: 50 push %eax
111e2f: ff 73 2c pushl 0x2c(%ebx)
111e32: e8 c9 19 00 00 call 113800 <rtems_barrier_release>
111e37: 83 c4 10 add $0x10,%esp
111e3a: e9 25 fd ff ff jmp 111b64 <fifo_open+0xf4>
111e3f: 90 nop
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
111e40: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
111e43: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED
111e46: e8 25 19 00 00 call 113770 <rtems_barrier_delete> <== NOT EXECUTED
rtems_barrier_delete(pipe->writeBarrier);
111e4b: 59 pop %ecx <== NOT EXECUTED
111e4c: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED
111e4f: e8 1c 19 00 00 call 113770 <rtems_barrier_delete> <== NOT EXECUTED
rtems_semaphore_delete(pipe->Semaphore);
111e54: 5a pop %edx <== NOT EXECUTED
111e55: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED
111e58: e8 d3 b5 ff ff call 10d430 <rtems_semaphore_delete><== NOT EXECUTED
free(pipe->Buffer);
111e5d: 58 pop %eax <== NOT EXECUTED
111e5e: ff 33 pushl (%ebx) <== NOT EXECUTED
111e60: e8 6b 7b ff ff call 1099d0 <free> <== NOT EXECUTED
free(pipe);
111e65: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
111e68: e8 63 7b ff ff call 1099d0 <free> <== NOT EXECUTED
111e6d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
else
*pipep = pipe;
}
out:
pipe_unlock();
111e70: e8 07 fb ff ff call 11197c <pipe_unlock>
111e75: e9 8e fc ff ff jmp 111b08 <fifo_open+0x98>
111e7a: 66 90 xchg %ax,%ax
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
111e7c: 83 ec 0c sub $0xc,%esp
111e7f: ff 73 28 pushl 0x28(%ebx)
111e82: e8 49 b7 ff ff call 10d5d0 <rtems_semaphore_release>
err = -ENXIO;
goto out_error;
111e87: 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;
111e8a: bf fa ff ff ff mov $0xfffffffa,%edi
goto out_error;
111e8f: e9 2c fd ff ff jmp 111bc0 <fifo_open+0x150>
if (c ++ == 'z')
c = 'a';
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
111e94: 83 ec 0c sub $0xc,%esp
111e97: 8b 45 d4 mov -0x2c(%ebp),%eax
111e9a: ff 70 30 pushl 0x30(%eax)
111e9d: e8 ce 18 00 00 call 113770 <rtems_barrier_delete>
111ea2: 83 c4 10 add $0x10,%esp
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
111ea5: 83 ec 0c sub $0xc,%esp
111ea8: 8b 55 d4 mov -0x2c(%ebp),%edx
111eab: ff 72 2c pushl 0x2c(%edx)
111eae: e8 bd 18 00 00 call 113770 <rtems_barrier_delete>
111eb3: 83 c4 10 add $0x10,%esp
err_rbar:
free(pipe->Buffer);
111eb6: 83 ec 0c sub $0xc,%esp
111eb9: 8b 45 d4 mov -0x2c(%ebp),%eax
111ebc: ff 30 pushl (%eax)
111ebe: e8 0d 7b ff ff call 1099d0 <free>
111ec3: 83 c4 10 add $0x10,%esp
err_buf:
free(pipe);
111ec6: 83 ec 0c sub $0xc,%esp
111ec9: ff 75 d4 pushl -0x2c(%ebp)
111ecc: e8 ff 7a ff ff call 1099d0 <free>
111ed1: 83 c4 10 add $0x10,%esp
)
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
111ed4: bf f4 ff ff ff mov $0xfffffff4,%edi
111ed9: eb 95 jmp 111e70 <fifo_open+0x400>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
111edb: a1 ec 9b 12 00 mov 0x129bec,%eax
111ee0: e9 a4 fb ff ff jmp 111a89 <fifo_open+0x19>
0010ff9c <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)
{
10ff9c: 55 push %ebp
10ff9d: 89 e5 mov %esp,%ebp
10ff9f: 56 push %esi
10ffa0: 53 push %ebx
10ffa1: 8b 75 08 mov 0x8(%ebp),%esi
10ffa4: 8b 5d 0c mov 0xc(%ebp),%ebx
find_arg *fa = arg;
if ( strcmp( entry->type, fa->type ) != 0 ) {
10ffa7: 83 ec 08 sub $0x8,%esp
10ffaa: ff 33 pushl (%ebx)
10ffac: ff 36 pushl (%esi)
10ffae: e8 d9 3f 00 00 call 113f8c <strcmp>
10ffb3: 83 c4 10 add $0x10,%esp
10ffb6: 85 c0 test %eax,%eax
10ffb8: 75 12 jne 10ffcc <find_handler+0x30>
return false;
} else {
fa->mount_h = entry->mount_h;
10ffba: 8b 46 04 mov 0x4(%esi),%eax
10ffbd: 89 43 04 mov %eax,0x4(%ebx)
return true;
10ffc0: b0 01 mov $0x1,%al
}
}
10ffc2: 8d 65 f8 lea -0x8(%ebp),%esp
10ffc5: 5b pop %ebx
10ffc6: 5e pop %esi
10ffc7: c9 leave
10ffc8: c3 ret
10ffc9: 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;
10ffcc: 31 c0 xor %eax,%eax
} else {
fa->mount_h = entry->mount_h;
return true;
}
}
10ffce: 8d 65 f8 lea -0x8(%ebp),%esp
10ffd1: 5b pop %ebx
10ffd2: 5e pop %esi
10ffd3: c9 leave
10ffd4: 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 cc 4d 12 00 cmp 0x124dcc,%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 20 90 12 00 add 0x129020,%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 08 b7 00 00 call 114474 <__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 f8 26 12 00 jmp *0x1226f8(,%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 8b b6 00 00 call 114474 <__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 2c 74 12 00 incl 0x12742c
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 40 77 12 00 03 cmpl $0x3,0x127740
1080cf: 74 47 je 108118 <free+0x64> <== ALWAYS TAKEN
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
1080d1: a1 c8 57 12 00 mov 0x1257c8,%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 b8 31 12 00 pushl 0x1231b8
1080ee: e8 4d 50 00 00 call 10d140 <_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 b8 31 12 00 mov 0x1231b8,%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 0b 12 00 push $0x120b10
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 60 7d 12 00 cmp $0x127d60,%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
10958c: c3 ret <== NOT EXECUTED
0011e7b0 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
11e7b0: 55 push %ebp
11e7b1: 89 e5 mov %esp,%ebp
11e7b3: 57 push %edi
11e7b4: 53 push %ebx
11e7b5: 8b 45 08 mov 0x8(%ebp),%eax
11e7b8: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_libio_t *iop;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
11e7bb: 85 db test %ebx,%ebx
11e7bd: 74 55 je 11e814 <fstat+0x64>
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
11e7bf: 3b 05 ac 31 12 00 cmp 0x1231ac,%eax
11e7c5: 73 39 jae 11e800 <fstat+0x50>
11e7c7: c1 e0 03 shl $0x3,%eax
11e7ca: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
11e7d1: 29 c2 sub %eax,%edx
11e7d3: 03 15 00 74 12 00 add 0x127400,%edx
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
11e7d9: f6 42 15 01 testb $0x1,0x15(%edx)
11e7dd: 74 21 je 11e800 <fstat+0x50>
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
11e7df: b9 48 00 00 00 mov $0x48,%ecx
11e7e4: 31 c0 xor %eax,%eax
11e7e6: 89 df mov %ebx,%edi
11e7e8: f3 aa rep stos %al,%es:(%edi)
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
11e7ea: 8b 42 20 mov 0x20(%edx),%eax
11e7ed: 89 5d 0c mov %ebx,0xc(%ebp)
11e7f0: 83 c2 18 add $0x18,%edx
11e7f3: 89 55 08 mov %edx,0x8(%ebp)
11e7f6: 8b 40 18 mov 0x18(%eax),%eax
}
11e7f9: 5b pop %ebx
11e7fa: 5f pop %edi
11e7fb: 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 );
11e7fc: ff e0 jmp *%eax
11e7fe: 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);
11e800: e8 0f 4b ff ff call 113314 <__errno>
11e805: 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 );
}
11e80b: b8 ff ff ff ff mov $0xffffffff,%eax
11e810: 5b pop %ebx
11e811: 5f pop %edi
11e812: c9 leave
11e813: c3 ret
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
rtems_set_errno_and_return_minus_one( EFAULT );
11e814: e8 fb 4a ff ff call 113314 <__errno>
11e819: c7 00 0e 00 00 00 movl $0xe,(%eax)
11e81f: eb ea jmp 11e80b <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 cc 4d 12 00 cmp 0x124dcc,%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 20 90 12 00 add 0x129020,%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 1b b5 00 00 call 114474 <__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 07 b5 00 00 call 114474 <__errno>
108f6d: c7 00 16 00 00 00 movl $0x16,(%eax)
108f73: eb ea jmp 108f5f <fsync+0x4b>
0010fc8c <ftruncate>:
int ftruncate(
int fd,
off_t length
)
{
10fc8c: 55 push %ebp
10fc8d: 89 e5 mov %esp,%ebp
10fc8f: 57 push %edi
10fc90: 56 push %esi
10fc91: 53 push %ebx
10fc92: 83 ec 3c sub $0x3c,%esp
10fc95: 8b 45 08 mov 0x8(%ebp),%eax
10fc98: 8b 55 0c mov 0xc(%ebp),%edx
10fc9b: 8b 4d 10 mov 0x10(%ebp),%ecx
10fc9e: 89 55 c0 mov %edx,-0x40(%ebp)
10fca1: 89 4d c4 mov %ecx,-0x3c(%ebp)
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
10fca4: 3b 05 ac 31 12 00 cmp 0x1231ac,%eax
10fcaa: 73 58 jae 10fd04 <ftruncate+0x78>
iop = rtems_libio_iop( fd );
10fcac: c1 e0 03 shl $0x3,%eax
10fcaf: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx
10fcb6: 29 c3 sub %eax,%ebx
10fcb8: 03 1d 00 74 12 00 add 0x127400,%ebx
rtems_libio_check_is_open(iop);
10fcbe: f6 43 15 01 testb $0x1,0x15(%ebx)
10fcc2: 74 40 je 10fd04 <ftruncate+0x78>
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
10fcc4: 8d 7d d4 lea -0x2c(%ebp),%edi
10fcc7: 8d 73 18 lea 0x18(%ebx),%esi
10fcca: b9 05 00 00 00 mov $0x5,%ecx
10fccf: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
10fcd1: 83 ec 0c sub $0xc,%esp
10fcd4: 8d 45 d4 lea -0x2c(%ebp),%eax
10fcd7: 50 push %eax
10fcd8: 8b 45 e0 mov -0x20(%ebp),%eax
10fcdb: ff 50 10 call *0x10(%eax)
10fcde: 83 c4 10 add $0x10,%esp
10fce1: 48 dec %eax
10fce2: 74 46 je 10fd2a <ftruncate+0x9e>
rtems_set_errno_and_return_minus_one( EISDIR );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
10fce4: f6 43 14 04 testb $0x4,0x14(%ebx)
10fce8: 74 2e je 10fd18 <ftruncate+0x8c>
return (*iop->pathinfo.handlers->ftruncate_h)( iop, length );
10fcea: 50 push %eax
10fceb: 8b 43 20 mov 0x20(%ebx),%eax
10fcee: ff 75 c4 pushl -0x3c(%ebp)
10fcf1: ff 75 c0 pushl -0x40(%ebp)
10fcf4: 53 push %ebx
10fcf5: ff 50 20 call *0x20(%eax)
10fcf8: 83 c4 10 add $0x10,%esp
}
10fcfb: 8d 65 f4 lea -0xc(%ebp),%esp
10fcfe: 5b pop %ebx
10fcff: 5e pop %esi
10fd00: 5f pop %edi
10fd01: c9 leave
10fd02: c3 ret
10fd03: 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);
10fd04: e8 0b 36 00 00 call 113314 <__errno>
10fd09: c7 00 09 00 00 00 movl $0x9,(%eax)
10fd0f: b8 ff ff ff ff mov $0xffffffff,%eax
10fd14: eb e5 jmp 10fcfb <ftruncate+0x6f>
10fd16: 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 );
10fd18: e8 f7 35 00 00 call 113314 <__errno>
10fd1d: c7 00 16 00 00 00 movl $0x16,(%eax)
10fd23: b8 ff ff ff ff mov $0xffffffff,%eax
10fd28: eb d1 jmp 10fcfb <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 );
10fd2a: e8 e5 35 00 00 call 113314 <__errno>
10fd2f: c7 00 15 00 00 00 movl $0x15,(%eax)
10fd35: b8 ff ff ff ff mov $0xffffffff,%eax
10fd3a: eb bf jmp 10fcfb <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 6c 36 12 00 mov 0x12366c,%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
001201a4 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
1201a4: 55 push %ebp
1201a5: 89 e5 mov %esp,%ebp
1201a7: 57 push %edi
1201a8: 56 push %esi
1201a9: 53 push %ebx
1201aa: 83 ec 2c sub $0x2c,%esp
1201ad: 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 );
1201b0: 3b 05 cc 5c 12 00 cmp 0x125ccc,%eax
1201b6: 73 4c jae 120204 <getdents+0x60> <== NEVER TAKEN
1201b8: c1 e0 03 shl $0x3,%eax
1201bb: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx
1201c2: 29 c3 sub %eax,%ebx
1201c4: 03 1d 40 a0 12 00 add 0x12a040,%ebx
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
1201ca: 8d 7d d4 lea -0x2c(%ebp),%edi
1201cd: 8d 73 18 lea 0x18(%ebx),%esi
1201d0: b9 05 00 00 00 mov $0x5,%ecx
1201d5: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
1201d7: 83 ec 0c sub $0xc,%esp
1201da: 8d 45 d4 lea -0x2c(%ebp),%eax
1201dd: 50 push %eax
1201de: 8b 45 e0 mov -0x20(%ebp),%eax
1201e1: ff 50 10 call *0x10(%eax)
1201e4: 83 c4 10 add $0x10,%esp
1201e7: 48 dec %eax
1201e8: 75 1e jne 120208 <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 );
1201ea: 50 push %eax
1201eb: 8b 43 20 mov 0x20(%ebx),%eax
1201ee: ff 75 10 pushl 0x10(%ebp)
1201f1: ff 75 0c pushl 0xc(%ebp)
1201f4: 53 push %ebx
1201f5: ff 50 08 call *0x8(%eax)
1201f8: 83 c4 10 add $0x10,%esp
}
1201fb: 8d 65 f4 lea -0xc(%ebp),%esp
1201fe: 5b pop %ebx
1201ff: 5e pop %esi
120200: 5f pop %edi
120201: c9 leave
120202: c3 ret
120203: 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 );
120204: 31 db xor %ebx,%ebx
120206: eb c2 jmp 1201ca <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 );
120208: e8 57 41 ff ff call 114364 <__errno>
12020d: c7 00 14 00 00 00 movl $0x14,(%eax)
120213: b8 ff ff ff ff mov $0xffffffff,%eax
120218: eb e1 jmp 1201fb <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 0f 12 00 push $0x120fd2
108b51: 68 b9 24 12 00 push $0x1224b9
108b56: e8 75 be 00 00 call 1149d0 <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 d5 cc 00 00 call 11584c <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 0f b7 00 00 call 1142cc <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 f3 b6 00 00 call 1142cc <fclose>
rtems_set_errno_and_return_minus_one( EINVAL );
108bd9: e8 96 b5 00 00 call 114174 <__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 7b b5 00 00 call 114174 <__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 00 8b 12 00 push $0x128b00
108e6c: 68 e4 8a 12 00 push $0x128ae4
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 e8 87 00 00 call 113a34 <__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 d3 87 00 00 call 113a34 <__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 bf 87 00 00 call 113a34 <__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 90 d3 00 00 call 1159cc <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 26 12 00 mov $0x122609,%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 0f 12 00 push $0x120fd2
108c21: 68 ad 24 12 00 push $0x1224ad
108c26: e8 a5 bd 00 00 call 1149d0 <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 05 cc 00 00 call 11584c <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 3f b6 00 00 call 1142cc <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 23 b6 00 00 call 1142cc <fclose>
rtems_set_errno_and_return_minus_one( EINVAL );
108ca9: e8 c6 b4 00 00 call 114174 <__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 ab b4 00 00 call 114174 <__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 00 8c 12 00 push $0x128c00
108d14: 68 cc 8b 12 00 push $0x128bcc
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
00112770 <imfs_dir_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
112770: 55 push %ebp
112771: 89 e5 mov %esp,%ebp
112773: 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 )
112776: 8b 50 18 mov 0x18(%eax),%edx
112779: 83 7a 4c 01 cmpl $0x1,0x4c(%edx)
11277d: 74 09 je 112788 <imfs_dir_open+0x18> <== ALWAYS TAKEN
return -1; /* It wasn't a directory --> return error */
11277f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
iop->offset = 0;
return 0;
}
112784: c9 leave <== NOT EXECUTED
112785: c3 ret <== NOT EXECUTED
112786: 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;
112788: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
11278f: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
return 0;
112796: 31 c0 xor %eax,%eax
}
112798: c9 leave
112799: c3 ret
0011279c <imfs_dir_read>:
ssize_t imfs_dir_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
11279c: 55 push %ebp
11279d: 89 e5 mov %esp,%ebp
11279f: 57 push %edi
1127a0: 56 push %esi
1127a1: 53 push %ebx
1127a2: 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;
1127a8: 8b 55 08 mov 0x8(%ebp),%edx
1127ab: 8b 42 18 mov 0x18(%edx),%eax
IMFS_create_orphan( the_jnode );
IMFS_check_node_remove( the_jnode );
return 0;
}
1127ae: 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 );
1127b1: 83 c0 54 add $0x54,%eax
1127b4: 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 ) )
1127ba: 39 c3 cmp %eax,%ebx
1127bc: 0f 84 2a 01 00 00 je 1128ec <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;
1127c2: 8b 42 0c mov 0xc(%edx),%eax
1127c5: 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);
1127cb: ba f1 f0 f0 f0 mov $0xf0f0f0f1,%edx
1127d0: 8b 45 10 mov 0x10(%ebp),%eax
1127d3: f7 e2 mul %edx
1127d5: c1 ea 08 shr $0x8,%edx
1127d8: 89 d0 mov %edx,%eax
1127da: c1 e0 04 shl $0x4,%eax
1127dd: c1 e2 08 shl $0x8,%edx
1127e0: 8d 14 10 lea (%eax,%edx,1),%edx
1127e3: 03 95 d4 fe ff ff add -0x12c(%ebp),%edx
1127e9: 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 (
1127ef: 85 d2 test %edx,%edx
1127f1: 0f 8e f5 00 00 00 jle 1128ec <imfs_dir_read+0x150> <== NEVER TAKEN
1127f7: 31 d2 xor %edx,%edx
1127f9: c7 85 c8 fe ff ff 00 movl $0x0,-0x138(%ebp)
112800: 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 );
112803: 8d 85 d8 fe ff ff lea -0x128(%ebp),%eax
112809: 89 85 b4 fe ff ff mov %eax,-0x14c(%ebp)
11280f: eb 23 jmp 112834 <imfs_dir_read+0x98>
112811: 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;
112814: 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(
112816: 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 (
11281c: 39 95 d0 fe ff ff cmp %edx,-0x130(%ebp)
112822: 0f 8e b4 00 00 00 jle 1128dc <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 ) ){
112828: 3b 9d cc fe ff ff cmp -0x134(%ebp),%ebx
11282e: 0f 84 a8 00 00 00 je 1128dc <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 ) {
112834: 39 95 d4 fe ff ff cmp %edx,-0x12c(%ebp)
11283a: 7f d8 jg 112814 <imfs_dir_read+0x78>
/* Move the entry to the return buffer */
tmp_dirent.d_off = current_entry;
11283c: 89 95 dc fe ff ff mov %edx,-0x124(%ebp)
112842: 89 d0 mov %edx,%eax
112844: c1 f8 1f sar $0x1f,%eax
112847: 89 85 e0 fe ff ff mov %eax,-0x120(%ebp)
tmp_dirent.d_reclen = sizeof( struct dirent );
11284d: 66 c7 85 e4 fe ff ff movw $0x110,-0x11c(%ebp)
112854: 10 01
the_jnode = (IMFS_jnode_t *) the_node;
tmp_dirent.d_ino = the_jnode->st_ino;
112856: 8b 43 38 mov 0x38(%ebx),%eax
112859: 89 85 d8 fe ff ff mov %eax,-0x128(%ebp)
tmp_dirent.d_namlen = strlen( the_jnode->name );
11285f: 8d 73 0c lea 0xc(%ebx),%esi
112862: 31 c0 xor %eax,%eax
112864: b9 ff ff ff ff mov $0xffffffff,%ecx
112869: 89 f7 mov %esi,%edi
11286b: f2 ae repnz scas %es:(%edi),%al
11286d: f7 d1 not %ecx
11286f: 49 dec %ecx
112870: 66 89 8d e6 fe ff ff mov %cx,-0x11a(%ebp)
strcpy( tmp_dirent.d_name, the_jnode->name );
112877: 83 ec 08 sub $0x8,%esp
11287a: 56 push %esi
11287b: 8d 85 e8 fe ff ff lea -0x118(%ebp),%eax
112881: 50 push %eax
112882: 89 95 c4 fe ff ff mov %edx,-0x13c(%ebp)
112888: e8 57 17 00 00 call 113fe4 <strcpy>
memcpy(
11288d: 8b 45 0c mov 0xc(%ebp),%eax
112890: 03 85 c8 fe ff ff add -0x138(%ebp),%eax
112896: b9 44 00 00 00 mov $0x44,%ecx
11289b: 89 c7 mov %eax,%edi
11289d: 8b b5 b4 fe ff ff mov -0x14c(%ebp),%esi
1128a3: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
buffer + bytes_transferred,
(void *)&tmp_dirent,
sizeof( struct dirent )
);
iop->offset = iop->offset + sizeof(struct dirent);
1128a5: 8b 45 08 mov 0x8(%ebp),%eax
1128a8: 81 40 0c 10 01 00 00 addl $0x110,0xc(%eax)
1128af: 83 50 10 00 adcl $0x0,0x10(%eax)
bytes_transferred = bytes_transferred + sizeof( struct dirent );
1128b3: 81 85 c8 fe ff ff 10 addl $0x110,-0x138(%ebp)
1128ba: 01 00 00
1128bd: 83 c4 10 add $0x10,%esp
1128c0: 8b 95 c4 fe ff ff mov -0x13c(%ebp),%edx
}
the_node = the_node->next;
1128c6: 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(
1128c8: 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 (
1128ce: 39 95 d0 fe ff ff cmp %edx,-0x130(%ebp)
1128d4: 0f 8f 4e ff ff ff jg 112828 <imfs_dir_read+0x8c> <== NEVER TAKEN
1128da: 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 ) ){
1128dc: 8b 85 c8 fe ff ff mov -0x138(%ebp),%eax
the_node = the_node->next;
}
/* Success */
return bytes_transferred;
}
1128e2: 8d 65 f4 lea -0xc(%ebp),%esp
1128e5: 5b pop %ebx
1128e6: 5e pop %esi
1128e7: 5f pop %edi
1128e8: c9 leave
1128e9: c3 ret
1128ea: 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;
1128ec: 31 c0 xor %eax,%eax
the_node = the_node->next;
}
/* Success */
return bytes_transferred;
}
1128ee: 8d 65 f4 lea -0xc(%ebp),%esp
1128f1: 5b pop %ebx
1128f2: 5e pop %esi
1128f3: 5f pop %edi
1128f4: c9 leave
1128f5: c3 ret
00112a28 <imfs_dir_rmnod>:
int imfs_dir_rmnod(
rtems_filesystem_location_info_t *parent_pathloc, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
112a28: 55 push %ebp
112a29: 89 e5 mov %esp,%ebp
112a2b: 53 push %ebx
112a2c: 83 ec 04 sub $0x4,%esp
112a2f: 8b 45 0c mov 0xc(%ebp),%eax
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
112a32: 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 );
112a34: 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 ) )
112a37: 39 53 50 cmp %edx,0x50(%ebx)
112a3a: 75 44 jne 112a80 <imfs_dir_rmnod+0x58>
/*
* You cannot remove the file system root node.
*/
if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access )
112a3c: 8b 40 10 mov 0x10(%eax),%eax
112a3f: 3b 58 1c cmp 0x1c(%eax),%ebx
112a42: 74 24 je 112a68 <imfs_dir_rmnod+0x40>
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
112a44: 8b 4b 5c mov 0x5c(%ebx),%ecx
112a47: 85 c9 test %ecx,%ecx
112a49: 75 1d jne 112a68 <imfs_dir_rmnod+0x40> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EBUSY );
IMFS_create_orphan( the_jnode );
112a4b: 83 ec 0c sub $0xc,%esp
112a4e: 53 push %ebx
112a4f: e8 98 cf ff ff call 10f9ec <IMFS_create_orphan>
IMFS_check_node_remove( the_jnode );
112a54: 89 1c 24 mov %ebx,(%esp)
112a57: e8 d4 cf ff ff call 10fa30 <IMFS_check_node_remove>
return 0;
112a5c: 83 c4 10 add $0x10,%esp
112a5f: 31 c0 xor %eax,%eax
}
112a61: 8b 5d fc mov -0x4(%ebp),%ebx
112a64: c9 leave
112a65: c3 ret
112a66: 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 );
112a68: e8 a7 08 00 00 call 113314 <__errno>
112a6d: c7 00 10 00 00 00 movl $0x10,(%eax)
112a73: b8 ff ff ff ff mov $0xffffffff,%eax
IMFS_create_orphan( the_jnode );
IMFS_check_node_remove( the_jnode );
return 0;
}
112a78: 8b 5d fc mov -0x4(%ebp),%ebx
112a7b: c9 leave
112a7c: c3 ret
112a7d: 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 );
112a80: e8 8f 08 00 00 call 113314 <__errno>
112a85: c7 00 5a 00 00 00 movl $0x5a,(%eax)
112a8b: b8 ff ff ff ff mov $0xffffffff,%eax
112a90: eb cf jmp 112a61 <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 c8 8c 12 00 00 cmpb $0x0,0x128cc8
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 c8 8c 12 00 01 movb $0x1,0x128cc8
mkdir("/etc", 0777);
108a53: 83 ec 08 sub $0x8,%esp
108a56: 68 ff 01 00 00 push $0x1ff
108a5b: 68 a8 24 12 00 push $0x1224a8
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 0f 12 00 push $0x120fd2
108a6c: 68 ad 24 12 00 push $0x1224ad
108a71: e8 5a bf 00 00 call 1149d0 <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 46 b8 00 00 call 1142cc <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 0f 12 00 push $0x120fd2
108a91: 68 b9 24 12 00 push $0x1224b9
108a96: e8 35 bf 00 00 call 1149d0 <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 21 b8 00 00 call 1142cc <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 0e 12 00 push $0x120eb4
108abc: 68 b9 24 12 00 push $0x1224b9
108ac1: e8 0a bf 00 00 call 1149d0 <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 25 12 00 push $0x12252c
108add: e8 c2 c6 00 00 call 1151a4 <fwrite>
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
108ae2: 89 1c 24 mov %ebx,(%esp)
108ae5: e8 e2 b7 00 00 call 1142cc <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 0e 12 00 push $0x120eb4
108afc: 68 ad 24 12 00 push $0x1224ad
108b01: e8 ca be 00 00 call 1149d0 <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 24 12 00 push $0x1224c4
108b1d: e8 82 c6 00 00 call 1151a4 <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 a2 b7 00 00 call 1142cc <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 b4 52 12 00 mov 0x1252b4,%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 a0 51 12 00 mov 0x1251a0,%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>
001241b4 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
1241b4: 55 push %ebp
1241b5: 89 e5 mov %esp,%ebp
1241b7: 57 push %edi
1241b8: 56 push %esi
1241b9: 53 push %ebx
1241ba: 83 ec 3c sub $0x3c,%esp
1241bd: 8b 75 0c mov 0xc(%ebp),%esi
1241c0: 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() )
1241c3: e8 00 fd ff ff call 123ec8 <getpid>
1241c8: 3b 45 08 cmp 0x8(%ebp),%eax
1241cb: 0f 85 3f 02 00 00 jne 124410 <killinfo+0x25c>
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
1241d1: 85 f6 test %esi,%esi
1241d3: 0f 84 4c 02 00 00 je 124425 <killinfo+0x271>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
1241d9: 8d 4e ff lea -0x1(%esi),%ecx
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
1241dc: 83 f9 1f cmp $0x1f,%ecx
1241df: 0f 87 40 02 00 00 ja 124425 <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 )
1241e5: 8d 04 76 lea (%esi,%esi,2),%eax
1241e8: 83 3c 85 28 e9 12 00 cmpl $0x1,0x12e928(,%eax,4)
1241ef: 01
1241f0: 0f 84 e6 01 00 00 je 1243dc <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 ) )
1241f6: 83 fe 08 cmp $0x8,%esi
1241f9: 0f 84 c9 00 00 00 je 1242c8 <killinfo+0x114>
1241ff: 83 fe 04 cmp $0x4,%esi
124202: 0f 84 c0 00 00 00 je 1242c8 <killinfo+0x114>
124208: 83 fe 0b cmp $0xb,%esi
12420b: 0f 84 b7 00 00 00 je 1242c8 <killinfo+0x114>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
124211: bb 01 00 00 00 mov $0x1,%ebx
124216: d3 e3 shl %cl,%ebx
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
124218: 89 75 dc mov %esi,-0x24(%ebp)
siginfo->si_code = SI_USER;
12421b: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp)
if ( !value ) {
124222: 85 ff test %edi,%edi
124224: 0f 84 ba 01 00 00 je 1243e4 <killinfo+0x230>
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
12422a: 8b 07 mov (%edi),%eax
12422c: 89 45 e4 mov %eax,-0x1c(%ebp)
12422f: a1 d0 e2 12 00 mov 0x12e2d0,%eax
124234: 40 inc %eax
124235: a3 d0 e2 12 00 mov %eax,0x12e2d0
/*
* 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;
12423a: 8b 0d b8 e8 12 00 mov 0x12e8b8,%ecx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
124240: 8b 81 ec 00 00 00 mov 0xec(%ecx),%eax
124246: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
12424c: f7 d0 not %eax
12424e: 85 c3 test %eax,%ebx
124250: 75 34 jne 124286 <killinfo+0xd2>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
124252: a1 c0 ea 12 00 mov 0x12eac0,%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 );
124257: 3d c4 ea 12 00 cmp $0x12eac4,%eax
12425c: 75 1b jne 124279 <killinfo+0xc5>
12425e: e9 81 00 00 00 jmp 1242e4 <killinfo+0x130>
124263: 90 nop
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
124264: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx
12426a: f7 d2 not %edx
12426c: 85 d3 test %edx,%ebx
12426e: 75 16 jne 124286 <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 ) {
124270: 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 );
124272: 3d c4 ea 12 00 cmp $0x12eac4,%eax
124277: 74 6b je 1242e4 <killinfo+0x130> <== ALWAYS TAKEN
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
124279: 89 c1 mov %eax,%ecx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
12427b: 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)
124281: 85 58 30 test %ebx,0x30(%eax)
124284: 74 de je 124264 <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 ) ) {
124286: 50 push %eax
mask = signo_to_mask( sig );
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
124287: 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 ) ) {
12428a: 50 push %eax
12428b: 56 push %esi
12428c: 51 push %ecx
12428d: e8 d6 01 00 00 call 124468 <_POSIX_signals_Unblock_thread>
124292: 83 c4 10 add $0x10,%esp
124295: 84 c0 test %al,%al
124297: 75 1f jne 1242b8 <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 );
124299: 83 ec 0c sub $0xc,%esp
12429c: 53 push %ebx
12429d: e8 b2 01 00 00 call 124454 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
1242a2: 8d 1c 76 lea (%esi,%esi,2),%ebx
1242a5: c1 e3 02 shl $0x2,%ebx
1242a8: 83 c4 10 add $0x10,%esp
1242ab: 83 bb 20 e9 12 00 02 cmpl $0x2,0x12e920(%ebx)
1242b2: 0f 84 e4 00 00 00 je 12439c <killinfo+0x1e8>
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
1242b8: e8 5f e7 fe ff call 112a1c <_Thread_Enable_dispatch>
return 0;
1242bd: 31 c0 xor %eax,%eax
}
1242bf: 8d 65 f4 lea -0xc(%ebp),%esp
1242c2: 5b pop %ebx
1242c3: 5e pop %esi
1242c4: 5f pop %edi
1242c5: c9 leave
1242c6: c3 ret
1242c7: 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 );
1242c8: e8 7b 03 00 00 call 124648 <pthread_self>
1242cd: 83 ec 08 sub $0x8,%esp
1242d0: 56 push %esi
1242d1: 50 push %eax
1242d2: e8 b1 02 00 00 call 124588 <pthread_kill>
1242d7: 83 c4 10 add $0x10,%esp
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
1242da: 8d 65 f4 lea -0xc(%ebp),%esp
1242dd: 5b pop %ebx
1242de: 5e pop %esi
1242df: 5f pop %edi
1242e0: c9 leave
1242e1: c3 ret
1242e2: 66 90 xchg %ax,%ax
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
1242e4: 0f b6 05 54 9e 12 00 movzbl 0x129e54,%eax
1242eb: 40 inc %eax
1242ec: 89 45 d4 mov %eax,-0x2c(%ebp)
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
1242ef: 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++) {
1242f6: c7 45 cc 02 00 00 00 movl $0x2,-0x34(%ebp)
1242fd: 89 5d d0 mov %ebx,-0x30(%ebp)
124300: 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 ] )
124303: 8b 55 cc mov -0x34(%ebp),%edx
124306: 8b 04 95 a8 e2 12 00 mov 0x12e2a8(,%edx,4),%eax
12430d: 85 c0 test %eax,%eax
12430f: 74 68 je 124379 <killinfo+0x1c5> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
124311: 8b 40 04 mov 0x4(%eax),%eax
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
124314: 0f b7 70 10 movzwl 0x10(%eax),%esi
object_table = the_info->local_table;
124318: 8b 78 1c mov 0x1c(%eax),%edi
for ( index = 1 ; index <= maximum ; index++ ) {
12431b: 85 f6 test %esi,%esi
12431d: 74 5a je 124379 <killinfo+0x1c5>
12431f: b8 01 00 00 00 mov $0x1,%eax
the_thread = (Thread_Control *) object_table[ index ];
124324: 8b 14 87 mov (%edi,%eax,4),%edx
if ( !the_thread )
124327: 85 d2 test %edx,%edx
124329: 74 49 je 124374 <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 )
12432b: 8b 4a 14 mov 0x14(%edx),%ecx
12432e: 3b 4d d4 cmp -0x2c(%ebp),%ecx
124331: 77 41 ja 124374 <killinfo+0x1c0>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
124333: 8b 9a ec 00 00 00 mov 0xec(%edx),%ebx
124339: 8b 9b d0 00 00 00 mov 0xd0(%ebx),%ebx
12433f: f7 d3 not %ebx
124341: 85 5d d0 test %ebx,-0x30(%ebp)
124344: 74 2e je 124374 <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 ) {
124346: 3b 4d d4 cmp -0x2c(%ebp),%ecx
124349: 72 21 jb 12436c <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 ) ) {
12434b: 8b 5d c8 mov -0x38(%ebp),%ebx
12434e: 85 db test %ebx,%ebx
124350: 74 22 je 124374 <killinfo+0x1c0> <== NEVER TAKEN
124352: 8b 5d c8 mov -0x38(%ebp),%ebx
124355: 8b 5b 10 mov 0x10(%ebx),%ebx
124358: 89 5d c4 mov %ebx,-0x3c(%ebp)
12435b: 85 db test %ebx,%ebx
12435d: 74 15 je 124374 <killinfo+0x1c0> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
12435f: 8b 5a 10 mov 0x10(%edx),%ebx
124362: 85 db test %ebx,%ebx
124364: 0f 85 86 00 00 00 jne 1243f0 <killinfo+0x23c>
12436a: 66 90 xchg %ax,%ax
12436c: 89 4d d4 mov %ecx,-0x2c(%ebp)
12436f: 89 55 c8 mov %edx,-0x38(%ebp)
124372: 66 90 xchg %ax,%ax
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
124374: 40 inc %eax
124375: 39 c6 cmp %eax,%esi
124377: 73 ab jae 124324 <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++) {
124379: ff 45 cc incl -0x34(%ebp)
12437c: 83 7d cc 04 cmpl $0x4,-0x34(%ebp)
124380: 75 81 jne 124303 <killinfo+0x14f>
124382: 8b 5d d0 mov -0x30(%ebp),%ebx
124385: 8b 75 c0 mov -0x40(%ebp),%esi
}
}
}
}
if ( interested ) {
124388: 8b 55 c8 mov -0x38(%ebp),%edx
12438b: 85 d2 test %edx,%edx
12438d: 0f 84 06 ff ff ff je 124299 <killinfo+0xe5>
124393: 8b 4d c8 mov -0x38(%ebp),%ecx
124396: e9 eb fe ff ff jmp 124286 <killinfo+0xd2>
12439b: 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 );
12439c: 83 ec 0c sub $0xc,%esp
12439f: 68 a0 ea 12 00 push $0x12eaa0
1243a4: e8 f7 cc fe ff call 1110a0 <_Chain_Get>
if ( !psiginfo ) {
1243a9: 83 c4 10 add $0x10,%esp
1243ac: 85 c0 test %eax,%eax
1243ae: 0f 84 86 00 00 00 je 12443a <killinfo+0x286>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
1243b4: 8d 78 08 lea 0x8(%eax),%edi
1243b7: 8d 75 dc lea -0x24(%ebp),%esi
1243ba: b9 03 00 00 00 mov $0x3,%ecx
1243bf: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
1243c1: 83 ec 08 sub $0x8,%esp
1243c4: 50 push %eax
1243c5: 81 c3 40 eb 12 00 add $0x12eb40,%ebx
1243cb: 53 push %ebx
1243cc: e8 93 cc fe ff call 111064 <_Chain_Append>
1243d1: 83 c4 10 add $0x10,%esp
1243d4: e9 df fe ff ff jmp 1242b8 <killinfo+0x104>
1243d9: 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;
1243dc: 31 c0 xor %eax,%eax
1243de: e9 f7 fe ff ff jmp 1242da <killinfo+0x126>
1243e3: 90 nop
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
siginfo->si_value.sival_int = 0;
1243e4: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
1243eb: e9 3f fe ff ff jmp 12422f <killinfo+0x7b>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
1243f0: f7 45 c4 00 00 00 10 testl $0x10000000,-0x3c(%ebp)
1243f7: 0f 85 77 ff ff ff jne 124374 <killinfo+0x1c0>
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
1243fd: 81 e3 00 00 00 10 and $0x10000000,%ebx
124403: 0f 84 6b ff ff ff je 124374 <killinfo+0x1c0>
124409: e9 5e ff ff ff jmp 12436c <killinfo+0x1b8>
12440e: 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 );
124410: e8 d7 40 ff ff call 1184ec <__errno>
124415: c7 00 03 00 00 00 movl $0x3,(%eax)
12441b: b8 ff ff ff ff mov $0xffffffff,%eax
124420: e9 b5 fe ff ff jmp 1242da <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 );
124425: e8 c2 40 ff ff call 1184ec <__errno>
12442a: c7 00 16 00 00 00 movl $0x16,(%eax)
124430: b8 ff ff ff ff mov $0xffffffff,%eax
124435: e9 a0 fe ff ff jmp 1242da <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();
12443a: e8 dd e5 fe ff call 112a1c <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
12443f: e8 a8 40 ff ff call 1184ec <__errno>
124444: c7 00 0b 00 00 00 movl $0xb,(%eax)
12444a: 83 c8 ff or $0xffffffff,%eax
12444d: e9 88 fe ff ff jmp 1242da <killinfo+0x126>
0011e978 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
11e978: 55 push %ebp
11e979: 89 e5 mov %esp,%ebp
11e97b: 53 push %ebx
11e97c: 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()))
11e97f: 83 3d 40 77 12 00 03 cmpl $0x3,0x127740
11e986: 74 08 je 11e990 <libc_wrapup+0x18> <== ALWAYS TAKEN
*/
fclose (stdin);
fclose (stdout);
fclose (stderr);
}
11e988: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
11e98b: c9 leave <== NOT EXECUTED
11e98c: c3 ret <== NOT EXECUTED
11e98d: 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) {
11e990: a1 c0 52 12 00 mov 0x1252c0,%eax
11e995: 8b 1d e0 16 12 00 mov 0x1216e0,%ebx
11e99b: 39 d8 cmp %ebx,%eax
11e99d: 74 14 je 11e9b3 <libc_wrapup+0x3b>
_wrapup_reent(_global_impure_ptr);
11e99f: 83 ec 0c sub $0xc,%esp
11e9a2: 53 push %ebx
11e9a3: e8 f8 05 00 00 call 11efa0 <_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;
11e9a8: 89 1d c0 52 12 00 mov %ebx,0x1252c0
11e9ae: 83 c4 10 add $0x10,%esp
11e9b1: 89 d8 mov %ebx,%eax
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
11e9b3: 83 ec 0c sub $0xc,%esp
11e9b6: ff 70 04 pushl 0x4(%eax)
11e9b9: e8 ae 4a ff ff call 11346c <fclose>
fclose (stdout);
11e9be: 5a pop %edx
11e9bf: a1 c0 52 12 00 mov 0x1252c0,%eax
11e9c4: ff 70 08 pushl 0x8(%eax)
11e9c7: e8 a0 4a ff ff call 11346c <fclose>
fclose (stderr);
11e9cc: 58 pop %eax
11e9cd: a1 c0 52 12 00 mov 0x1252c0,%eax
11e9d2: ff 70 0c pushl 0xc(%eax)
11e9d5: e8 92 4a ff ff call 11346c <fclose>
11e9da: 83 c4 10 add $0x10,%esp
}
11e9dd: 8b 5d fc mov -0x4(%ebp),%ebx
11e9e0: c9 leave
11e9e1: 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 36 b9 00 00 call 116f64 <__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>
0011e850 <lseek>:
off_t lseek(
int fd,
off_t offset,
int whence
)
{
11e850: 55 push %ebp
11e851: 89 e5 mov %esp,%ebp
11e853: 57 push %edi
11e854: 56 push %esi
11e855: 53 push %ebx
11e856: 83 ec 1c sub $0x1c,%esp
11e859: 8b 5d 08 mov 0x8(%ebp),%ebx
11e85c: 8b 55 0c mov 0xc(%ebp),%edx
11e85f: 8b 4d 10 mov 0x10(%ebp),%ecx
11e862: 8b 45 14 mov 0x14(%ebp),%eax
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
11e865: 3b 1d ac 31 12 00 cmp 0x1231ac,%ebx
11e86b: 0f 83 b3 00 00 00 jae 11e924 <lseek+0xd4> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
11e871: 8d 34 dd 00 00 00 00 lea 0x0(,%ebx,8),%esi
11e878: 8d 1c f5 00 00 00 00 lea 0x0(,%esi,8),%ebx
11e87f: 29 f3 sub %esi,%ebx
11e881: 03 1d 00 74 12 00 add 0x127400,%ebx
rtems_libio_check_is_open(iop);
11e887: f6 43 15 01 testb $0x1,0x15(%ebx)
11e88b: 0f 84 93 00 00 00 je 11e924 <lseek+0xd4> <== NEVER TAKEN
/*
* Now process the lseek().
*/
old_offset = iop->offset;
11e891: 8b 73 0c mov 0xc(%ebx),%esi
11e894: 8b 7b 10 mov 0x10(%ebx),%edi
11e897: 89 75 e0 mov %esi,-0x20(%ebp)
11e89a: 89 7d e4 mov %edi,-0x1c(%ebp)
switch ( whence ) {
11e89d: 83 f8 01 cmp $0x1,%eax
11e8a0: 74 6e je 11e910 <lseek+0xc0>
11e8a2: 83 f8 02 cmp $0x2,%eax
11e8a5: 74 35 je 11e8dc <lseek+0x8c>
11e8a7: 85 c0 test %eax,%eax
11e8a9: 75 45 jne 11e8f0 <lseek+0xa0>
case SEEK_SET:
iop->offset = offset;
11e8ab: 89 53 0c mov %edx,0xc(%ebx)
11e8ae: 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 );
11e8b1: 8b 73 20 mov 0x20(%ebx),%esi
11e8b4: 50 push %eax
11e8b5: 51 push %ecx
11e8b6: 52 push %edx
11e8b7: 53 push %ebx
11e8b8: ff 56 14 call *0x14(%esi)
if ( status == (off_t) -1 )
11e8bb: 83 c4 10 add $0x10,%esp
11e8be: 89 c1 mov %eax,%ecx
11e8c0: 21 d1 and %edx,%ecx
11e8c2: 41 inc %ecx
11e8c3: 75 0c jne 11e8d1 <lseek+0x81>
iop->offset = old_offset;
11e8c5: 8b 75 e0 mov -0x20(%ebp),%esi
11e8c8: 8b 7d e4 mov -0x1c(%ebp),%edi
11e8cb: 89 73 0c mov %esi,0xc(%ebx)
11e8ce: 89 7b 10 mov %edi,0x10(%ebx)
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
11e8d1: 8d 65 f4 lea -0xc(%ebp),%esp
11e8d4: 5b pop %ebx
11e8d5: 5e pop %esi
11e8d6: 5f pop %edi
11e8d7: c9 leave
11e8d8: c3 ret
11e8d9: 8d 76 00 lea 0x0(%esi),%esi
case SEEK_CUR:
iop->offset += offset;
break;
case SEEK_END:
iop->offset = iop->size + offset;
11e8dc: 89 d6 mov %edx,%esi
11e8de: 89 cf mov %ecx,%edi
11e8e0: 03 73 04 add 0x4(%ebx),%esi
11e8e3: 13 7b 08 adc 0x8(%ebx),%edi
11e8e6: 89 73 0c mov %esi,0xc(%ebx)
11e8e9: 89 7b 10 mov %edi,0x10(%ebx)
break;
11e8ec: eb c3 jmp 11e8b1 <lseek+0x61>
11e8ee: 66 90 xchg %ax,%ax
default:
rtems_set_errno_and_return_minus_one( EINVAL );
11e8f0: e8 1f 4a ff ff call 113314 <__errno>
11e8f5: c7 00 16 00 00 00 movl $0x16,(%eax)
11e8fb: b8 ff ff ff ff mov $0xffffffff,%eax
11e900: ba ff ff ff ff mov $0xffffffff,%edx
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
11e905: 8d 65 f4 lea -0xc(%ebp),%esp
11e908: 5b pop %ebx
11e909: 5e pop %esi
11e90a: 5f pop %edi
11e90b: c9 leave
11e90c: c3 ret
11e90d: 8d 76 00 lea 0x0(%esi),%esi
case SEEK_SET:
iop->offset = offset;
break;
case SEEK_CUR:
iop->offset += offset;
11e910: 8b 75 e0 mov -0x20(%ebp),%esi
11e913: 8b 7d e4 mov -0x1c(%ebp),%edi
11e916: 01 d6 add %edx,%esi
11e918: 11 cf adc %ecx,%edi
11e91a: 89 73 0c mov %esi,0xc(%ebx)
11e91d: 89 7b 10 mov %edi,0x10(%ebx)
break;
11e920: eb 8f jmp 11e8b1 <lseek+0x61>
11e922: 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);
11e924: e8 eb 49 ff ff call 113314 <__errno>
11e929: c7 00 09 00 00 00 movl $0x9,(%eax)
11e92f: b8 ff ff ff ff mov $0xffffffff,%eax
11e934: ba ff ff ff ff mov $0xffffffff,%edx
11e939: eb 96 jmp 11e8d1 <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 c3 b5 00 00 call 11550c <__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 24 74 12 00 incl 0x127424
/*
* 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 40 77 12 00 03 cmpl $0x3,0x127740
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 b8 31 12 00 pushl 0x1231b8
1083b3: e8 50 4d 00 00 call 10d108 <_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 d0 57 12 00 mov 0x1257d0,%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 c8 57 12 00 mov 0x1257c8,%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 cc 57 12 00 mov 0x1257cc,%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 ec ae 00 00 call 113314 <__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 1c 76 12 00 pushl 0x12761c
108325: e8 7a 3c 00 00 call 10bfa4 <_API_Mutex_Lock>
*stats = rtems_malloc_statistics;
10832a: be e0 73 12 00 mov $0x1273e0,%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 1c 76 12 00 pushl 0x12761c
10833f: e8 a8 3c 00 00 call 10bfec <_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 4c 7c 12 00 mov 0x127c4c,%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 58 38 12 00 pushl 0x123858
10876e: e8 59 4d 00 00 call 10d4cc <_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 20 7c 12 00 add %ebx,0x127c20
108780: 6a 00 push $0x0
108782: 6a 00 push $0x0
108784: 56 push %esi
108785: ff 35 58 38 12 00 pushl 0x123858
10878b: e8 04 4d 00 00 call 10d494 <_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 f3 b1 00 00 call 113998 <__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>
00111ec8 <memfile_free_blocks_in_table>:
*/
void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
111ec8: 55 push %ebp
111ec9: 89 e5 mov %esp,%ebp
111ecb: 57 push %edi
111ecc: 56 push %esi
111ecd: 53 push %ebx
111ece: 83 ec 0c sub $0xc,%esp
111ed1: 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;
111ed4: 8b 45 08 mov 0x8(%ebp),%eax
111ed7: 8b 30 mov (%eax),%esi
for ( i=0 ; i<entries ; i++ ) {
111ed9: 85 ff test %edi,%edi
111edb: 7e 27 jle 111f04 <memfile_free_blocks_in_table+0x3c><== NEVER TAKEN
111edd: 31 db xor %ebx,%ebx
111edf: 90 nop
if ( b[i] ) {
111ee0: 8b 04 9e mov (%esi,%ebx,4),%eax
111ee3: 85 c0 test %eax,%eax
111ee5: 74 13 je 111efa <memfile_free_blocks_in_table+0x32>
memfile_free_block( b[i] );
111ee7: 83 ec 0c sub $0xc,%esp
111eea: 50 push %eax
111eeb: e8 bc ff ff ff call 111eac <memfile_free_block>
b[i] = 0;
111ef0: c7 04 9e 00 00 00 00 movl $0x0,(%esi,%ebx,4)
111ef7: 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++ ) {
111efa: 43 inc %ebx
111efb: 39 df cmp %ebx,%edi
111efd: 7f e1 jg 111ee0 <memfile_free_blocks_in_table+0x18>
111eff: 8b 45 08 mov 0x8(%ebp),%eax
111f02: 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 );
111f04: 83 ec 0c sub $0xc,%esp
111f07: 56 push %esi
111f08: e8 9f ff ff ff call 111eac <memfile_free_block>
*block_table = 0;
111f0d: 8b 45 08 mov 0x8(%ebp),%eax
111f10: c7 00 00 00 00 00 movl $0x0,(%eax)
111f16: 83 c4 10 add $0x10,%esp
}
111f19: 8d 65 f4 lea -0xc(%ebp),%esp
111f1c: 5b pop %ebx
111f1d: 5e pop %esi
111f1e: 5f pop %edi
111f1f: c9 leave
111f20: c3 ret
00112444 <memfile_ftruncate>:
*/
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
112444: 55 push %ebp
112445: 89 e5 mov %esp,%ebp
112447: 53 push %ebx
112448: 83 ec 14 sub $0x14,%esp
11244b: 8b 4d 08 mov 0x8(%ebp),%ecx
11244e: 8b 45 0c mov 0xc(%ebp),%eax
112451: 8b 55 10 mov 0x10(%ebp),%edx
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
112454: 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 )
112457: 39 53 54 cmp %edx,0x54(%ebx)
11245a: 7f 19 jg 112475 <memfile_ftruncate+0x31><== NEVER TAKEN
11245c: 7d 12 jge 112470 <memfile_ftruncate+0x2c><== ALWAYS TAKEN
return IMFS_memfile_extend( the_jnode, length );
11245e: 51 push %ecx
11245f: 52 push %edx
112460: 50 push %eax
112461: 53 push %ebx
112462: e8 45 fc ff ff call 1120ac <IMFS_memfile_extend>
112467: 83 c4 10 add $0x10,%esp
iop->size = the_jnode->info.file.size;
IMFS_update_atime( the_jnode );
return 0;
}
11246a: 8b 5d fc mov -0x4(%ebp),%ebx
11246d: c9 leave
11246e: c3 ret
11246f: 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 )
112470: 39 43 50 cmp %eax,0x50(%ebx)
112473: 72 e9 jb 11245e <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;
112475: 89 43 50 mov %eax,0x50(%ebx)
112478: 89 53 54 mov %edx,0x54(%ebx)
iop->size = the_jnode->info.file.size;
11247b: 89 41 04 mov %eax,0x4(%ecx)
11247e: 89 51 08 mov %edx,0x8(%ecx)
IMFS_update_atime( the_jnode );
112481: 83 ec 08 sub $0x8,%esp
112484: 6a 00 push $0x0
112486: 8d 45 f0 lea -0x10(%ebp),%eax
112489: 50 push %eax
11248a: e8 a1 5c ff ff call 108130 <gettimeofday>
11248f: 8b 45 f0 mov -0x10(%ebp),%eax
112492: 89 43 40 mov %eax,0x40(%ebx)
return 0;
112495: 83 c4 10 add $0x10,%esp
112498: 31 c0 xor %eax,%eax
}
11249a: 8b 5d fc mov -0x4(%ebp),%ebx
11249d: c9 leave
11249e: c3 ret
001124a0 <memfile_lseek>:
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
1124a0: 55 push %ebp
1124a1: 89 e5 mov %esp,%ebp
1124a3: 57 push %edi
1124a4: 56 push %esi
1124a5: 53 push %ebx
1124a6: 83 ec 0c sub $0xc,%esp
1124a9: 8b 5d 08 mov 0x8(%ebp),%ebx
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
1124ac: 8b 73 18 mov 0x18(%ebx),%esi
if (the_jnode->type == IMFS_LINEAR_FILE) {
1124af: 83 7e 4c 06 cmpl $0x6,0x4c(%esi)
1124b3: 74 2f je 1124e4 <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 ))
1124b5: 57 push %edi
1124b6: ff 73 10 pushl 0x10(%ebx)
1124b9: ff 73 0c pushl 0xc(%ebx)
1124bc: 56 push %esi
1124bd: e8 ea fb ff ff call 1120ac <IMFS_memfile_extend>
1124c2: 83 c4 10 add $0x10,%esp
1124c5: 85 c0 test %eax,%eax
1124c7: 75 45 jne 11250e <memfile_lseek+0x6e>
rtems_set_errno_and_return_minus_one( ENOSPC );
iop->size = the_jnode->info.file.size;
1124c9: 8b 46 50 mov 0x50(%esi),%eax
1124cc: 8b 56 54 mov 0x54(%esi),%edx
1124cf: 89 43 04 mov %eax,0x4(%ebx)
1124d2: 89 53 08 mov %edx,0x8(%ebx)
1124d5: 8b 43 0c mov 0xc(%ebx),%eax
1124d8: 8b 53 10 mov 0x10(%ebx),%edx
}
return iop->offset;
}
1124db: 8d 65 f4 lea -0xc(%ebp),%esp
1124de: 5b pop %ebx
1124df: 5e pop %esi
1124e0: 5f pop %edi
1124e1: c9 leave
1124e2: c3 ret
1124e3: 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)
1124e4: 8b 43 0c mov 0xc(%ebx),%eax
1124e7: 8b 53 10 mov 0x10(%ebx),%edx
1124ea: 8b 7e 50 mov 0x50(%esi),%edi
1124ed: 8b 4e 54 mov 0x54(%esi),%ecx
1124f0: 39 ca cmp %ecx,%edx
1124f2: 7c e7 jl 1124db <memfile_lseek+0x3b> <== NEVER TAKEN
1124f4: 7e 12 jle 112508 <memfile_lseek+0x68> <== ALWAYS TAKEN
iop->offset = the_jnode->info.linearfile.size;
1124f6: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED
1124f9: 89 4b 10 mov %ecx,0x10(%ebx) <== NOT EXECUTED
1124fc: 89 f8 mov %edi,%eax <== NOT EXECUTED
1124fe: 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;
}
112500: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
112503: 5b pop %ebx <== NOT EXECUTED
112504: 5e pop %esi <== NOT EXECUTED
112505: 5f pop %edi <== NOT EXECUTED
112506: c9 leave <== NOT EXECUTED
112507: 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)
112508: 39 f8 cmp %edi,%eax
11250a: 76 cf jbe 1124db <memfile_lseek+0x3b> <== ALWAYS TAKEN
11250c: eb e8 jmp 1124f6 <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 );
11250e: e8 01 0e 00 00 call 113314 <__errno>
112513: c7 00 1c 00 00 00 movl $0x1c,(%eax)
112519: b8 ff ff ff ff mov $0xffffffff,%eax
11251e: ba ff ff ff ff mov $0xffffffff,%edx
112523: eb b6 jmp 1124db <memfile_lseek+0x3b>
0011239c <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
11239c: 55 push %ebp
11239d: 89 e5 mov %esp,%ebp
11239f: 56 push %esi
1123a0: 53 push %ebx
1123a1: 8b 5d 08 mov 0x8(%ebp),%ebx
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
1123a4: 8b 73 18 mov 0x18(%ebx),%esi
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
1123a7: 8b 43 14 mov 0x14(%ebx),%eax
1123aa: a9 04 02 00 00 test $0x204,%eax
1123af: 74 06 je 1123b7 <memfile_open+0x1b>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
1123b1: 83 7e 4c 06 cmpl $0x6,0x4c(%esi)
1123b5: 74 2d je 1123e4 <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))
1123b7: 8b 56 50 mov 0x50(%esi),%edx
1123ba: 8b 4e 54 mov 0x54(%esi),%ecx
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
1123bd: f6 c4 02 test $0x2,%ah
1123c0: 75 12 jne 1123d4 <memfile_open+0x38>
iop->offset = the_jnode->info.file.size;
iop->size = the_jnode->info.file.size;
1123c2: 89 53 04 mov %edx,0x4(%ebx)
1123c5: 89 4b 08 mov %ecx,0x8(%ebx)
return 0;
1123c8: 31 c0 xor %eax,%eax
}
1123ca: 8d 65 f8 lea -0x8(%ebp),%esp
1123cd: 5b pop %ebx
1123ce: 5e pop %esi
1123cf: c9 leave
1123d0: c3 ret
1123d1: 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;
1123d4: 89 53 0c mov %edx,0xc(%ebx)
1123d7: 89 4b 10 mov %ecx,0x10(%ebx)
1123da: 8b 56 50 mov 0x50(%esi),%edx
1123dd: 8b 4e 54 mov 0x54(%esi),%ecx
1123e0: eb e0 jmp 1123c2 <memfile_open+0x26>
1123e2: 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;
1123e4: 8b 46 50 mov 0x50(%esi),%eax <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
1123e7: 8b 56 58 mov 0x58(%esi),%edx <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
1123ea: c7 46 4c 05 00 00 00 movl $0x5,0x4c(%esi) <== NOT EXECUTED
the_jnode->info.file.size = 0;
1123f1: c7 46 50 00 00 00 00 movl $0x0,0x50(%esi) <== NOT EXECUTED
1123f8: c7 46 54 00 00 00 00 movl $0x0,0x54(%esi) <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
1123ff: c7 46 58 00 00 00 00 movl $0x0,0x58(%esi) <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
112406: c7 46 5c 00 00 00 00 movl $0x0,0x5c(%esi) <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
11240d: c7 46 60 00 00 00 00 movl $0x0,0x60(%esi) <== NOT EXECUTED
if ((count != 0)
112414: 85 c0 test %eax,%eax <== NOT EXECUTED
112416: 75 09 jne 112421 <memfile_open+0x85> <== NOT EXECUTED
112418: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED
11241b: 31 d2 xor %edx,%edx <== NOT EXECUTED
11241d: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
11241f: eb 9c jmp 1123bd <memfile_open+0x21> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
112421: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
112424: 50 push %eax <== NOT EXECUTED
112425: 52 push %edx <== NOT EXECUTED
112426: 6a 00 push $0x0 <== NOT EXECUTED
112428: 6a 00 push $0x0 <== NOT EXECUTED
11242a: 56 push %esi <== NOT EXECUTED
11242b: e8 94 fd ff ff call 1121c4 <IMFS_memfile_write> <== NOT EXECUTED
112430: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
112433: 40 inc %eax <== NOT EXECUTED
112434: 74 08 je 11243e <memfile_open+0xa2> <== NOT EXECUTED
112436: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED
112439: e9 79 ff ff ff jmp 1123b7 <memfile_open+0x1b> <== NOT EXECUTED
return -1;
11243e: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
112441: eb 87 jmp 1123ca <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 a9 ae 00 00 call 113314 <__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 e9 7a 00 00 call 11007c <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 0b 12 00 mov $0x120b60,%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 84 50 12 00 88 cmpl $0x125088,0x125084
108668: 50 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 08 74 12 00 pushl 0x127408
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 84 50 12 00 push $0x125084
1086a0: e8 37 39 00 00 call 10bfdc <_Chain_Append>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
1086a5: 58 pop %eax
1086a6: ff 35 08 74 12 00 pushl 0x127408
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 b0 51 12 00 mov 0x1251b0,%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 8f ab 00 00 call 113314 <__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 0b 12 00 movl $0x120b07,-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 4f ab 00 00 call 113314 <__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 37 ab 00 00 call 113314 <__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 eb aa 00 00 call 113314 <__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 db aa 00 00 call 113314 <__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 1a ae 00 00 call 113a08 <__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 b0 fa 12 00 mov 0x12fab0,%eax
10fb25: 40 inc %eax
10fb26: a3 b0 fa 12 00 mov %eax,0x12fab0
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 00 13 00 push $0x130020
10fb4a: e8 59 2c 00 00 call 1127a8 <_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 92 69 00 00 call 116500 <_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 fe 12 00 push $0x12fe80
10fb96: e8 c5 30 00 00 call 112c60 <_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 00 13 00 mov 0x13003c,%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 d8 3b 00 00 call 113794 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
10fbbc: e8 d3 3b 00 00 call 113794 <_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 00 13 00 push $0x130020
10fbe2: e8 39 2f 00 00 call 112b20 <_Objects_Free>
_POSIX_Message_queue_Free_fd( the_mq_fd );
_Thread_Enable_dispatch();
10fbe7: e8 a8 3b 00 00 call 113794 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, mqd_t );
10fbec: e8 c7 9c 00 00 call 1198b8 <__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 7f 3b 00 00 call 113794 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENFILE );
10fc15: e8 9e 9c 00 00 call 1198b8 <__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 00 13 00 push $0x130020
10fc39: e8 e2 2e 00 00 call 112b20 <_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 51 3b 00 00 call 113794 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t );
10fc43: e8 70 9c 00 00 call 1198b8 <__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 fc 66 00 00 call 116378 <_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 00 13 00 mov 0x13003c,%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 f4 3a 00 00 call 113794 <_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 00 13 00 push $0x130020
10fcb1: e8 6a 2e 00 00 call 112b20 <_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 d9 3a 00 00 call 113794 <_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>
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 40 76 12 00 mov 0x127640,%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 95 60 00 00 call 10e960 <_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 08 12 00 movl $0x12088a,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 16 12 00 mov 0x1216e0,%eax
108b15: a3 c0 52 12 00 mov %eax,0x1252c0
RTEMS_INLINE_ROUTINE void _Thread_Set_libc_reent (
struct _reent **libc_reent
)
{
_Thread_libc_reent = libc_reent;
108b1a: c7 05 40 76 12 00 c0 movl $0x1252c0,0x127640
108b21: 52 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 16 12 00 cmp 0x1216e0,%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 9d af 00 00 call 113afc <_fwalk>
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
108b5f: 89 34 24 mov %esi,(%esp)
108b62: e8 15 5e 00 00 call 10e97c <_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 c0 52 12 00 00 movl $0x0,0x1252c0
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 c0 52 12 00 mov 0x1252c0,%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 8c ae 00 00 call 1136e8 <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 ff ab 00 00 call 11346c <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 40 41 12 00 00 cmpb $0x0,0x124140
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 40 41 12 00 01 movb $0x1,0x124140
status = rtems_io_register_name(
107cf7: 50 push %eax
107cf8: 6a 00 push $0x0
107cfa: 53 push %ebx
107cfb: 68 1a d1 11 00 push $0x11d11a
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 80 44 12 00 mov %ebx,0x124480
}
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 ba 41 00 00 call 10bedc <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 b3 71 00 00 call 10fdd8 <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 ce 70 00 00 call 10fd5c <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 00 74 12 00 sub 0x127400,%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 16 a6 00 00 call 113314 <__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 5f 71 00 00 call 10fe7c <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 db a5 00 00 call 113314 <__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 c7 a5 00 00 call 113314 <__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 b6 a5 00 00 call 113314 <__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 00 74 12 00 sub 0x127400,%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 f3 6e 00 00 call 10fc8c <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 66 a5 00 00 call 113314 <__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 00 74 12 00 sub 0x127400,%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 27 6e 00 00 call 10fc0c <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 a2 a4 00 00 call 113314 <__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 b4 52 12 00 mov 0x1252b4,%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 0c 12 00 push $0x120c04
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 b4 52 12 00 mov 0x1252b4,%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 07 12 00 push $0x12079c
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
00110d5c <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
110d5c: 55 push %ebp
110d5d: 89 e5 mov %esp,%ebp
110d5f: 57 push %edi
110d60: 56 push %esi
110d61: 53 push %ebx
110d62: 83 ec 24 sub $0x24,%esp
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
110d65: 68 ff 01 00 00 push $0x1ff
110d6a: 68 6c 2d 12 00 push $0x122d6c
110d6f: e8 38 17 00 00 call 1124ac <rtems_mkdir>
110d74: 83 c4 10 add $0x10,%esp
110d77: 85 c0 test %eax,%eax
110d79: 74 0d je 110d88 <pipe_create+0x2c> <== ALWAYS TAKEN
return -1;
110d7b: b8 ff ff ff ff mov $0xffffffff,%eax
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
}
110d80: 8d 65 f4 lea -0xc(%ebp),%esp
110d83: 5b pop %ebx
110d84: 5e pop %esi
110d85: 5f pop %edi
110d86: c9 leave
110d87: 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);
110d88: 8d 5d d9 lea -0x27(%ebp),%ebx
110d8b: be 71 2d 12 00 mov $0x122d71,%esi
110d90: b9 0a 00 00 00 mov $0xa,%ecx
110d95: 89 df mov %ebx,%edi
110d97: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
110d99: 0f b7 05 4c 8e 12 00 movzwl 0x128e4c,%eax
110da0: 8d 50 01 lea 0x1(%eax),%edx
110da3: 66 89 15 4c 8e 12 00 mov %dx,0x128e4c
110daa: 51 push %ecx
110dab: 50 push %eax
110dac: 68 7c 2d 12 00 push $0x122d7c
110db1: 8d 45 e3 lea -0x1d(%ebp),%eax
110db4: 50 push %eax
110db5: e8 aa 4a 00 00 call 115864 <sprintf>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
110dba: 58 pop %eax
110dbb: 5a pop %edx
110dbc: 68 80 01 00 00 push $0x180
110dc1: 53 push %ebx
110dc2: e8 2d 14 00 00 call 1121f4 <mkfifo>
110dc7: 83 c4 10 add $0x10,%esp
110dca: 85 c0 test %eax,%eax
110dcc: 0f 85 a6 00 00 00 jne 110e78 <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);
110dd2: 83 ec 08 sub $0x8,%esp
110dd5: 68 00 40 00 00 push $0x4000
110dda: 53 push %ebx
110ddb: e8 f0 90 ff ff call 109ed0 <open>
110de0: 8b 55 08 mov 0x8(%ebp),%edx
110de3: 89 02 mov %eax,(%edx)
if (filsdes[0] < 0) {
110de5: 83 c4 10 add $0x10,%esp
110de8: 85 c0 test %eax,%eax
110dea: 78 58 js 110e44 <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]);
110dec: 3b 05 ec 4d 12 00 cmp 0x124dec,%eax
110df2: 72 3c jb 110e30 <pipe_create+0xd4> <== ALWAYS TAKEN
110df4: 31 d2 xor %edx,%edx <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
110df6: 83 62 14 fe andl $0xfffffffe,0x14(%edx)
filsdes[1] = open(fifopath, O_WRONLY);
110dfa: 83 ec 08 sub $0x8,%esp
110dfd: 6a 01 push $0x1
110dff: 53 push %ebx
110e00: e8 cb 90 ff ff call 109ed0 <open>
110e05: 8b 55 08 mov 0x8(%ebp),%edx
110e08: 89 42 04 mov %eax,0x4(%edx)
if (filsdes[1] < 0) {
110e0b: 83 c4 10 add $0x10,%esp
110e0e: 85 c0 test %eax,%eax
110e10: 78 4a js 110e5c <pipe_create+0x100>
int pipe_create(
int filsdes[2]
)
{
rtems_libio_t *iop;
int err = 0;
110e12: 31 f6 xor %esi,%esi
if (filsdes[1] < 0) {
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
110e14: 83 ec 0c sub $0xc,%esp
110e17: 53 push %ebx
110e18: e8 ff b0 ff ff call 10bf1c <unlink>
110e1d: 83 c4 10 add $0x10,%esp
}
if(err != 0)
110e20: 85 f6 test %esi,%esi
110e22: 75 63 jne 110e87 <pipe_create+0x12b>
rtems_set_errno_and_return_minus_one(err);
return 0;
110e24: 31 c0 xor %eax,%eax
}
110e26: 8d 65 f4 lea -0xc(%ebp),%esp
110e29: 5b pop %ebx
110e2a: 5e pop %esi
110e2b: 5f pop %edi
110e2c: c9 leave
110e2d: c3 ret
110e2e: 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]);
110e30: c1 e0 03 shl $0x3,%eax
110e33: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
110e3a: 29 c2 sub %eax,%edx
110e3c: 03 15 80 90 12 00 add 0x129080,%edx
110e42: eb b2 jmp 110df6 <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;
110e44: e8 83 40 00 00 call 114ecc <__errno>
110e49: 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);
110e4b: 83 ec 0c sub $0xc,%esp
110e4e: 53 push %ebx
110e4f: e8 c8 b0 ff ff call 10bf1c <unlink>
110e54: 83 c4 10 add $0x10,%esp
110e57: eb c7 jmp 110e20 <pipe_create+0xc4>
110e59: 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;
110e5c: e8 6b 40 00 00 call 114ecc <__errno>
110e61: 8b 30 mov (%eax),%esi
close(filsdes[0]);
110e63: 83 ec 0c sub $0xc,%esp
110e66: 8b 45 08 mov 0x8(%ebp),%eax
110e69: ff 30 pushl (%eax)
110e6b: e8 c8 80 ff ff call 108f38 <close>
110e70: 83 c4 10 add $0x10,%esp
110e73: eb 9f jmp 110e14 <pipe_create+0xb8>
110e75: 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){
110e78: e8 4f 40 00 00 call 114ecc <__errno>
return -1;
110e7d: b8 ff ff ff ff mov $0xffffffff,%eax
110e82: e9 f9 fe ff ff jmp 110d80 <pipe_create+0x24>
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
110e87: e8 40 40 00 00 call 114ecc <__errno>
110e8c: 89 30 mov %esi,(%eax)
110e8e: b8 ff ff ff ff mov $0xffffffff,%eax
110e93: e9 e8 fe ff ff jmp 110d80 <pipe_create+0x24>
001122a0 <pipe_ioctl>:
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
1122a0: 55 push %ebp
1122a1: 89 e5 mov %esp,%ebp
1122a3: 56 push %esi
1122a4: 53 push %ebx
1122a5: 8b 75 08 mov 0x8(%ebp),%esi
1122a8: 8b 5d 10 mov 0x10(%ebp),%ebx
if (cmd == FIONREAD) {
1122ab: 81 7d 0c 7f 66 04 40 cmpl $0x4004667f,0xc(%ebp)
1122b2: 74 0c je 1122c0 <pipe_ioctl+0x20>
*(unsigned int *)buffer = pipe->Length;
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
1122b4: b8 ea ff ff ff mov $0xffffffea,%eax
}
1122b9: 8d 65 f8 lea -0x8(%ebp),%esp
1122bc: 5b pop %ebx
1122bd: 5e pop %esi
1122be: c9 leave
1122bf: c3 ret
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
1122c0: 85 db test %ebx,%ebx
1122c2: 75 07 jne 1122cb <pipe_ioctl+0x2b>
return -EFAULT;
1122c4: b8 f2 ff ff ff mov $0xfffffff2,%eax
1122c9: eb ee jmp 1122b9 <pipe_ioctl+0x19>
if (! PIPE_LOCK(pipe))
1122cb: 50 push %eax
1122cc: 6a 00 push $0x0
1122ce: 6a 00 push $0x0
1122d0: ff 76 28 pushl 0x28(%esi)
1122d3: e8 fc b1 ff ff call 10d4d4 <rtems_semaphore_obtain>
1122d8: 83 c4 10 add $0x10,%esp
1122db: 85 c0 test %eax,%eax
1122dd: 74 07 je 1122e6 <pipe_ioctl+0x46> <== ALWAYS TAKEN
return -EINTR;
1122df: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED
1122e4: eb d3 jmp 1122b9 <pipe_ioctl+0x19> <== NOT EXECUTED
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
1122e6: 8b 46 0c mov 0xc(%esi),%eax
1122e9: 89 03 mov %eax,(%ebx)
PIPE_UNLOCK(pipe);
1122eb: 83 ec 0c sub $0xc,%esp
1122ee: ff 76 28 pushl 0x28(%esi)
1122f1: e8 da b2 ff ff call 10d5d0 <rtems_semaphore_release>
return 0;
1122f6: 83 c4 10 add $0x10,%esp
1122f9: 31 c0 xor %eax,%eax
1122fb: eb bc jmp 1122b9 <pipe_ioctl+0x19>
00111ee8 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
111ee8: 55 push %ebp
111ee9: 89 e5 mov %esp,%ebp
111eeb: 57 push %edi
111eec: 56 push %esi
111eed: 53 push %ebx
111eee: 83 ec 30 sub $0x30,%esp
111ef1: 8b 5d 08 mov 0x8(%ebp),%ebx
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
111ef4: 6a 00 push $0x0
111ef6: 6a 00 push $0x0
111ef8: ff 73 28 pushl 0x28(%ebx)
111efb: e8 d4 b5 ff ff call 10d4d4 <rtems_semaphore_obtain>
111f00: 83 c4 10 add $0x10,%esp
111f03: 85 c0 test %eax,%eax
111f05: 0f 85 ad 00 00 00 jne 111fb8 <pipe_read+0xd0> <== NEVER TAKEN
return -EINTR;
while (read < count) {
111f0b: 8b 55 10 mov 0x10(%ebp),%edx
111f0e: 85 d2 test %edx,%edx
111f10: 0f 84 7a 01 00 00 je 112090 <pipe_read+0x1a8> <== NEVER TAKEN
111f16: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
111f1d: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
while (PIPE_EMPTY(pipe)) {
111f24: 8b 53 0c mov 0xc(%ebx),%edx
111f27: 85 d2 test %edx,%edx
111f29: 0f 85 99 00 00 00 jne 111fc8 <pipe_read+0xe0>
/* Not an error */
if (pipe->Writers == 0)
111f2f: 8b 43 14 mov 0x14(%ebx),%eax
111f32: 85 c0 test %eax,%eax
111f34: 0f 84 fe 00 00 00 je 112038 <pipe_read+0x150>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
111f3a: 8b 45 14 mov 0x14(%ebp),%eax
111f3d: f6 40 14 01 testb $0x1,0x14(%eax)
111f41: 0f 85 f9 00 00 00 jne 112040 <pipe_read+0x158>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
111f47: ff 43 18 incl 0x18(%ebx)
PIPE_UNLOCK(pipe);
111f4a: 83 ec 0c sub $0xc,%esp
111f4d: ff 73 28 pushl 0x28(%ebx)
111f50: e8 7b b6 ff ff call 10d5d0 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
111f55: 5e pop %esi
111f56: 5f pop %edi
111f57: 6a 00 push $0x0
111f59: ff 73 2c pushl 0x2c(%ebx)
111f5c: e8 03 19 00 00 call 113864 <rtems_barrier_wait>
111f61: 83 c4 0c add $0xc,%esp
111f64: 83 f8 01 cmp $0x1,%eax
111f67: 19 f6 sbb %esi,%esi
111f69: f7 d6 not %esi
111f6b: 83 e6 fc and $0xfffffffc,%esi
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
111f6e: 6a 00 push $0x0
111f70: 6a 00 push $0x0
111f72: ff 73 28 pushl 0x28(%ebx)
111f75: e8 5a b5 ff ff call 10d4d4 <rtems_semaphore_obtain>
111f7a: 83 c4 10 add $0x10,%esp
111f7d: 85 c0 test %eax,%eax
111f7f: 0f 85 c7 00 00 00 jne 11204c <pipe_read+0x164> <== NEVER TAKEN
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
111f85: ff 4b 18 decl 0x18(%ebx)
if (ret != 0)
111f88: 85 f6 test %esi,%esi
111f8a: 74 98 je 111f24 <pipe_read+0x3c> <== ALWAYS TAKEN
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
111f8c: 83 ec 0c sub $0xc,%esp
111f8f: ff 73 28 pushl 0x28(%ebx)
111f92: e8 39 b6 ff ff call 10d5d0 <rtems_semaphore_release>
111f97: 83 c4 10 add $0x10,%esp
out_nolock:
if (read > 0)
111f9a: 8b 55 d4 mov -0x2c(%ebp),%edx
111f9d: 85 d2 test %edx,%edx
111f9f: 7e 0b jle 111fac <pipe_read+0xc4>
111fa1: 8b 45 d4 mov -0x2c(%ebp),%eax
return read;
return ret;
}
111fa4: 8d 65 f4 lea -0xc(%ebp),%esp
111fa7: 5b pop %ebx
111fa8: 5e pop %esi
111fa9: 5f pop %edi
111faa: c9 leave
111fab: c3 ret
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
return read;
return ret;
111fac: 89 f0 mov %esi,%eax
}
111fae: 8d 65 f4 lea -0xc(%ebp),%esp
111fb1: 5b pop %ebx
111fb2: 5e pop %esi
111fb3: 5f pop %edi
111fb4: c9 leave
111fb5: c3 ret
111fb6: 66 90 xchg %ax,%ax
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
111fb8: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED
out_nolock:
if (read > 0)
return read;
return ret;
}
111fbd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
111fc0: 5b pop %ebx <== NOT EXECUTED
111fc1: 5e pop %esi <== NOT EXECUTED
111fc2: 5f pop %edi <== NOT EXECUTED
111fc3: c9 leave <== NOT EXECUTED
111fc4: c3 ret <== NOT EXECUTED
111fc5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
111fc8: 8b 45 10 mov 0x10(%ebp),%eax
111fcb: 2b 45 d0 sub -0x30(%ebp),%eax
111fce: 89 55 cc mov %edx,-0x34(%ebp)
111fd1: 39 c2 cmp %eax,%edx
111fd3: 76 03 jbe 111fd8 <pipe_read+0xf0>
111fd5: 89 45 cc mov %eax,-0x34(%ebp)
chunk1 = pipe->Size - pipe->Start;
111fd8: 8b 73 08 mov 0x8(%ebx),%esi
111fdb: 8b 43 04 mov 0x4(%ebx),%eax
111fde: 29 f0 sub %esi,%eax
if (chunk > chunk1) {
111fe0: 39 45 cc cmp %eax,-0x34(%ebp)
111fe3: 7f 71 jg 112056 <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);
111fe5: 8b 45 0c mov 0xc(%ebp),%eax
111fe8: 03 45 d0 add -0x30(%ebp),%eax
111feb: 03 33 add (%ebx),%esi
111fed: 89 c7 mov %eax,%edi
111fef: 8b 4d cc mov -0x34(%ebp),%ecx
111ff2: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
pipe->Start += chunk;
111ff4: 8b 45 cc mov -0x34(%ebp),%eax
111ff7: 03 43 08 add 0x8(%ebx),%eax
pipe->Start %= pipe->Size;
111ffa: 31 d2 xor %edx,%edx
111ffc: f7 73 04 divl 0x4(%ebx)
111fff: 89 53 08 mov %edx,0x8(%ebx)
pipe->Length -= chunk;
112002: 8b 43 0c mov 0xc(%ebx),%eax
112005: 2b 45 cc sub -0x34(%ebp),%eax
112008: 89 43 0c mov %eax,0xc(%ebx)
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
11200b: 85 c0 test %eax,%eax
11200d: 75 07 jne 112016 <pipe_read+0x12e>
pipe->Start = 0;
11200f: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
if (pipe->waitingWriters > 0)
112016: 8b 4b 1c mov 0x1c(%ebx),%ecx
112019: 85 c9 test %ecx,%ecx
11201b: 75 5f jne 11207c <pipe_read+0x194>
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
11201d: 8b 45 cc mov -0x34(%ebp),%eax
112020: 01 45 d4 add %eax,-0x2c(%ebp)
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
112023: 8b 45 d4 mov -0x2c(%ebp),%eax
112026: 89 45 d0 mov %eax,-0x30(%ebp)
112029: 8b 45 10 mov 0x10(%ebp),%eax
11202c: 39 45 d4 cmp %eax,-0x2c(%ebp)
11202f: 0f 82 ef fe ff ff jb 111f24 <pipe_read+0x3c> <== NEVER TAKEN
112035: 8d 76 00 lea 0x0(%esi),%esi
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
112038: 31 f6 xor %esi,%esi
11203a: e9 4d ff ff ff jmp 111f8c <pipe_read+0xa4>
11203f: 90 nop
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
112040: be f5 ff ff ff mov $0xfffffff5,%esi
112045: e9 42 ff ff ff jmp 111f8c <pipe_read+0xa4>
11204a: 66 90 xchg %ax,%ax
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
11204c: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED
112051: e9 44 ff ff ff jmp 111f9a <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);
112056: 8b 55 0c mov 0xc(%ebp),%edx
112059: 03 55 d0 add -0x30(%ebp),%edx
11205c: 03 33 add (%ebx),%esi
11205e: 89 d7 mov %edx,%edi
112060: 89 c1 mov %eax,%ecx
112062: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
112064: 8b 55 d0 mov -0x30(%ebp),%edx
112067: 01 c2 add %eax,%edx
112069: 03 55 0c add 0xc(%ebp),%edx
11206c: 8b 4d cc mov -0x34(%ebp),%ecx
11206f: 29 c1 sub %eax,%ecx
112071: 8b 33 mov (%ebx),%esi
112073: 89 d7 mov %edx,%edi
112075: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
112077: e9 78 ff ff ff jmp 111ff4 <pipe_read+0x10c>
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
11207c: 83 ec 08 sub $0x8,%esp
11207f: 8d 45 e4 lea -0x1c(%ebp),%eax
112082: 50 push %eax
112083: ff 73 30 pushl 0x30(%ebx)
112086: e8 75 17 00 00 call 113800 <rtems_barrier_release>
11208b: 83 c4 10 add $0x10,%esp
11208e: eb 8d jmp 11201d <pipe_read+0x135>
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
112090: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED
112097: 31 f6 xor %esi,%esi <== NOT EXECUTED
112099: e9 ee fe ff ff jmp 111f8c <pipe_read+0xa4> <== NOT EXECUTED
00111994 <pipe_release>:
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
111994: 55 push %ebp
111995: 89 e5 mov %esp,%ebp
111997: 57 push %edi
111998: 56 push %esi
111999: 53 push %ebx
11199a: 83 ec 1c sub $0x1c,%esp
11199d: 8b 7d 08 mov 0x8(%ebp),%edi
pipe_control_t *pipe = *pipep;
1119a0: 8b 1f mov (%edi),%ebx
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
1119a2: 8b 45 0c mov 0xc(%ebp),%eax
1119a5: 8b 40 14 mov 0x14(%eax),%eax
1119a8: 89 c6 mov %eax,%esi
1119aa: 83 e6 06 and $0x6,%esi
if (mode & LIBIO_FLAGS_READ)
1119ad: a8 02 test $0x2,%al
1119af: 74 03 je 1119b4 <pipe_release+0x20>
pipe->Readers --;
1119b1: ff 4b 10 decl 0x10(%ebx)
if (mode & LIBIO_FLAGS_WRITE)
1119b4: f7 c6 04 00 00 00 test $0x4,%esi
1119ba: 74 03 je 1119bf <pipe_release+0x2b>
pipe->Writers --;
1119bc: ff 4b 14 decl 0x14(%ebx)
PIPE_UNLOCK(pipe);
1119bf: 83 ec 0c sub $0xc,%esp
1119c2: ff 73 28 pushl 0x28(%ebx)
1119c5: e8 06 bc ff ff call 10d5d0 <rtems_semaphore_release>
if (pipe->Readers == 0 && pipe->Writers == 0) {
1119ca: 83 c4 10 add $0x10,%esp
1119cd: 8b 53 10 mov 0x10(%ebx),%edx
1119d0: 85 d2 test %edx,%edx
1119d2: 74 2c je 111a00 <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)
1119d4: 8b 43 14 mov 0x14(%ebx),%eax
1119d7: 85 c0 test %eax,%eax
1119d9: 75 17 jne 1119f2 <pipe_release+0x5e> <== NEVER TAKEN
1119db: 83 fe 02 cmp $0x2,%esi
1119de: 74 12 je 1119f2 <pipe_release+0x5e> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
1119e0: 83 ec 08 sub $0x8,%esp
1119e3: 8d 45 e4 lea -0x1c(%ebp),%eax
1119e6: 50 push %eax
1119e7: ff 73 2c pushl 0x2c(%ebx)
1119ea: e8 11 1e 00 00 call 113800 <rtems_barrier_release>
1119ef: 83 c4 10 add $0x10,%esp
pipe_unlock();
1119f2: e8 85 ff ff ff call 11197c <pipe_unlock>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
1119f7: 8d 65 f4 lea -0xc(%ebp),%esp
1119fa: 5b pop %ebx
1119fb: 5e pop %esi
1119fc: 5f pop %edi
1119fd: c9 leave
1119fe: c3 ret
1119ff: 90 nop
if (mode & LIBIO_FLAGS_WRITE)
pipe->Writers --;
PIPE_UNLOCK(pipe);
if (pipe->Readers == 0 && pipe->Writers == 0) {
111a00: 8b 43 14 mov 0x14(%ebx),%eax
111a03: 85 c0 test %eax,%eax
111a05: 74 25 je 111a2c <pipe_release+0x98>
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
111a07: 83 fe 04 cmp $0x4,%esi
111a0a: 74 e6 je 1119f2 <pipe_release+0x5e> <== NEVER TAKEN
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
111a0c: 83 ec 08 sub $0x8,%esp
111a0f: 8d 45 e4 lea -0x1c(%ebp),%eax
111a12: 50 push %eax
111a13: ff 73 30 pushl 0x30(%ebx)
111a16: e8 e5 1d 00 00 call 113800 <rtems_barrier_release>
111a1b: 83 c4 10 add $0x10,%esp
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
PIPE_WAKEUPREADERS(pipe);
pipe_unlock();
111a1e: e8 59 ff ff ff call 11197c <pipe_unlock>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
111a23: 8d 65 f4 lea -0xc(%ebp),%esp
111a26: 5b pop %ebx
111a27: 5e pop %esi
111a28: 5f pop %edi
111a29: c9 leave
111a2a: c3 ret
111a2b: 90 nop
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
111a2c: 83 ec 0c sub $0xc,%esp
111a2f: ff 73 2c pushl 0x2c(%ebx)
111a32: e8 39 1d 00 00 call 113770 <rtems_barrier_delete>
rtems_barrier_delete(pipe->writeBarrier);
111a37: 5e pop %esi
111a38: ff 73 30 pushl 0x30(%ebx)
111a3b: e8 30 1d 00 00 call 113770 <rtems_barrier_delete>
rtems_semaphore_delete(pipe->Semaphore);
111a40: 59 pop %ecx
111a41: ff 73 28 pushl 0x28(%ebx)
111a44: e8 e7 b9 ff ff call 10d430 <rtems_semaphore_delete>
free(pipe->Buffer);
111a49: 5a pop %edx
111a4a: ff 33 pushl (%ebx)
111a4c: e8 7f 7f ff ff call 1099d0 <free>
free(pipe);
111a51: 89 1c 24 mov %ebx,(%esp)
111a54: e8 77 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;
111a59: c7 07 00 00 00 00 movl $0x0,(%edi)
111a5f: 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();
111a62: e8 15 ff ff ff call 11197c <pipe_unlock>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
111a67: 8d 65 f4 lea -0xc(%ebp),%esp
111a6a: 5b pop %ebx
111a6b: 5e pop %esi
111a6c: 5f pop %edi
111a6d: c9 leave
111a6e: c3 ret
001120a0 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
1120a0: 55 push %ebp
1120a1: 89 e5 mov %esp,%ebp
1120a3: 57 push %edi
1120a4: 56 push %esi
1120a5: 53 push %ebx
1120a6: 83 ec 2c sub $0x2c,%esp
1120a9: 8b 5d 10 mov 0x10(%ebp),%ebx
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
1120ac: 85 db test %ebx,%ebx
1120ae: 75 0c jne 1120bc <pipe_write+0x1c> <== ALWAYS TAKEN
return 0;
1120b0: 31 c0 xor %eax,%eax
#endif
if (written > 0)
return written;
return ret;
}
1120b2: 8d 65 f4 lea -0xc(%ebp),%esp
1120b5: 5b pop %ebx
1120b6: 5e pop %esi
1120b7: 5f pop %edi
1120b8: c9 leave
1120b9: c3 ret
1120ba: 66 90 xchg %ax,%ax
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
1120bc: 56 push %esi
1120bd: 6a 00 push $0x0
1120bf: 6a 00 push $0x0
1120c1: 8b 45 08 mov 0x8(%ebp),%eax
1120c4: ff 70 28 pushl 0x28(%eax)
1120c7: e8 08 b4 ff ff call 10d4d4 <rtems_semaphore_obtain>
1120cc: 83 c4 10 add $0x10,%esp
1120cf: 85 c0 test %eax,%eax
1120d1: 0f 85 4a 01 00 00 jne 112221 <pipe_write+0x181> <== NEVER TAKEN
return -EINTR;
if (pipe->Readers == 0) {
1120d7: 8b 45 08 mov 0x8(%ebp),%eax
1120da: 8b 48 10 mov 0x10(%eax),%ecx
1120dd: 85 c9 test %ecx,%ecx
1120df: 0f 84 57 01 00 00 je 11223c <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;
1120e5: 8b 48 04 mov 0x4(%eax),%ecx
1120e8: 39 cb cmp %ecx,%ebx
1120ea: 0f 87 42 01 00 00 ja 112232 <pipe_write+0x192> <== NEVER TAKEN
1120f0: 89 de mov %ebx,%esi
1120f2: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
1120f9: 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);
112100: 89 5d c8 mov %ebx,-0x38(%ebp)
112103: 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) {
112106: 8b 43 0c mov 0xc(%ebx),%eax
112109: 89 ca mov %ecx,%edx
11210b: 29 c2 sub %eax,%edx
11210d: 39 f2 cmp %esi,%edx
11210f: 73 6f jae 112180 <pipe_write+0xe0>
if (LIBIO_NODELAY(iop)) {
112111: 8b 45 14 mov 0x14(%ebp),%eax
112114: f6 40 14 01 testb $0x1,0x14(%eax)
112118: 0f 85 48 01 00 00 jne 112266 <pipe_write+0x1c6>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
11211e: ff 43 1c incl 0x1c(%ebx)
PIPE_UNLOCK(pipe);
112121: 83 ec 0c sub $0xc,%esp
112124: ff 73 28 pushl 0x28(%ebx)
112127: e8 a4 b4 ff ff call 10d5d0 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
11212c: 58 pop %eax
11212d: 5a pop %edx
11212e: 6a 00 push $0x0
112130: ff 73 30 pushl 0x30(%ebx)
112133: e8 2c 17 00 00 call 113864 <rtems_barrier_wait>
112138: 83 c4 0c add $0xc,%esp
11213b: 83 f8 01 cmp $0x1,%eax
11213e: 19 ff sbb %edi,%edi
112140: f7 d7 not %edi
112142: 83 e7 fc and $0xfffffffc,%edi
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
112145: 6a 00 push $0x0
112147: 6a 00 push $0x0
112149: ff 73 28 pushl 0x28(%ebx)
11214c: e8 83 b3 ff ff call 10d4d4 <rtems_semaphore_obtain>
112151: 83 c4 10 add $0x10,%esp
112154: 85 c0 test %eax,%eax
112156: 0f 85 03 01 00 00 jne 11225f <pipe_write+0x1bf> <== NEVER TAKEN
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
11215c: ff 4b 1c decl 0x1c(%ebx)
if (ret != 0)
11215f: 85 ff test %edi,%edi
112161: 0f 85 95 00 00 00 jne 1121fc <pipe_write+0x15c> <== NEVER TAKEN
goto out_locked;
if (pipe->Readers == 0) {
112167: 8b 7b 10 mov 0x10(%ebx),%edi
11216a: 85 ff test %edi,%edi
11216c: 0f 84 85 00 00 00 je 1121f7 <pipe_write+0x157> <== NEVER TAKEN
112172: 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) {
112175: 8b 43 0c mov 0xc(%ebx),%eax
112178: 89 ca mov %ecx,%edx
11217a: 29 c2 sub %eax,%edx
11217c: 39 f2 cmp %esi,%edx
11217e: 72 91 jb 112111 <pipe_write+0x71> <== NEVER TAKEN
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
112180: 8b 75 c8 mov -0x38(%ebp),%esi
112183: 2b 75 d0 sub -0x30(%ebp),%esi
112186: 89 55 cc mov %edx,-0x34(%ebp)
112189: 39 f2 cmp %esi,%edx
11218b: 76 03 jbe 112190 <pipe_write+0xf0>
11218d: 89 75 cc mov %esi,-0x34(%ebp)
chunk1 = pipe->Size - PIPE_WSTART(pipe);
112190: 03 43 08 add 0x8(%ebx),%eax
112193: 31 d2 xor %edx,%edx
112195: f7 f1 div %ecx
112197: 89 c8 mov %ecx,%eax
112199: 29 d0 sub %edx,%eax
if (chunk > chunk1) {
11219b: 39 45 cc cmp %eax,-0x34(%ebp)
11219e: 0f 8e c9 00 00 00 jle 11226d <pipe_write+0x1cd>
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
1121a4: 03 13 add (%ebx),%edx
1121a6: 8b 75 0c mov 0xc(%ebp),%esi
1121a9: 03 75 d0 add -0x30(%ebp),%esi
1121ac: 89 d7 mov %edx,%edi
1121ae: 89 c1 mov %eax,%ecx
1121b0: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
1121b2: 8b 13 mov (%ebx),%edx
1121b4: 8b 4d cc mov -0x34(%ebp),%ecx
1121b7: 29 c1 sub %eax,%ecx
1121b9: 03 45 d0 add -0x30(%ebp),%eax
1121bc: 8b 75 0c mov 0xc(%ebp),%esi
1121bf: 01 c6 add %eax,%esi
1121c1: 89 d7 mov %edx,%edi
1121c3: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
1121c5: 8b 45 cc mov -0x34(%ebp),%eax
1121c8: 01 43 0c add %eax,0xc(%ebx)
if (pipe->waitingReaders > 0)
1121cb: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
1121cf: 0f 85 ac 00 00 00 jne 112281 <pipe_write+0x1e1>
PIPE_WAKEUPREADERS(pipe);
written += chunk;
1121d5: 8b 45 cc mov -0x34(%ebp),%eax
1121d8: 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) {
1121db: 8b 45 d4 mov -0x2c(%ebp),%eax
1121de: 89 45 d0 mov %eax,-0x30(%ebp)
1121e1: 39 45 c8 cmp %eax,-0x38(%ebp)
1121e4: 0f 86 ad 00 00 00 jbe 112297 <pipe_write+0x1f7> <== ALWAYS TAKEN
1121ea: 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;
1121ed: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED
1121f2: e9 0f ff ff ff jmp 112106 <pipe_write+0x66> <== NOT EXECUTED
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
1121f7: 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);
1121fc: 83 ec 0c sub $0xc,%esp
1121ff: 8b 45 08 mov 0x8(%ebp),%eax
112202: ff 70 28 pushl 0x28(%eax)
112205: e8 c6 b3 ff ff call 10d5d0 <rtems_semaphore_release>
11220a: 83 c4 10 add $0x10,%esp
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
11220d: 83 ff e0 cmp $0xffffffe0,%edi
112210: 74 38 je 11224a <pipe_write+0x1aa>
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
112212: 8b 4d d4 mov -0x2c(%ebp),%ecx
112215: 85 c9 test %ecx,%ecx
112217: 7e 12 jle 11222b <pipe_write+0x18b>
112219: 8b 45 d4 mov -0x2c(%ebp),%eax
11221c: e9 91 fe ff ff jmp 1120b2 <pipe_write+0x12>
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
112221: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED
112226: e9 87 fe ff ff jmp 1120b2 <pipe_write+0x12> <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
11222b: 89 f8 mov %edi,%eax
11222d: e9 80 fe ff ff jmp 1120b2 <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;
112232: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED
112237: e9 b6 fe ff ff jmp 1120f2 <pipe_write+0x52> <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
if (pipe->Readers == 0) {
ret = -EPIPE;
11223c: 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;
112241: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
112248: eb b2 jmp 1121fc <pipe_write+0x15c>
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
11224a: e8 21 08 00 00 call 112a70 <getpid>
11224f: 83 ec 08 sub $0x8,%esp
112252: 6a 0d push $0xd
112254: 50 push %eax
112255: e8 1a 0b 00 00 call 112d74 <kill>
11225a: 83 c4 10 add $0x10,%esp
11225d: eb b3 jmp 112212 <pipe_write+0x172>
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
11225f: bf fc ff ff ff mov $0xfffffffc,%edi <== NOT EXECUTED
112264: eb ac jmp 112212 <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;
112266: bf f5 ff ff ff mov $0xfffffff5,%edi
11226b: eb 8f jmp 1121fc <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);
11226d: 03 13 add (%ebx),%edx
11226f: 8b 75 0c mov 0xc(%ebp),%esi
112272: 03 75 d0 add -0x30(%ebp),%esi
112275: 89 d7 mov %edx,%edi
112277: 8b 4d cc mov -0x34(%ebp),%ecx
11227a: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
11227c: e9 44 ff ff ff jmp 1121c5 <pipe_write+0x125>
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
112281: 56 push %esi
112282: 56 push %esi
112283: 8d 45 e4 lea -0x1c(%ebp),%eax
112286: 50 push %eax
112287: ff 73 2c pushl 0x2c(%ebx)
11228a: e8 71 15 00 00 call 113800 <rtems_barrier_release>
11228f: 83 c4 10 add $0x10,%esp
112292: e9 3e ff ff ff jmp 1121d5 <pipe_write+0x135>
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
112297: 31 ff xor %edi,%edi
112299: e9 5e ff ff ff jmp 1121fc <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 08 dd 12 00 incl 0x12dd08
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
00111b5c <pthread_attr_setinheritsched>:
int pthread_attr_setinheritsched(
pthread_attr_t *attr,
int inheritsched
)
{
111b5c: 55 push %ebp
111b5d: 89 e5 mov %esp,%ebp
111b5f: 8b 45 08 mov 0x8(%ebp),%eax
111b62: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
111b65: 85 c0 test %eax,%eax
111b67: 74 1f je 111b88 <pthread_attr_setinheritsched+0x2c>
111b69: 8b 08 mov (%eax),%ecx
111b6b: 85 c9 test %ecx,%ecx
111b6d: 74 19 je 111b88 <pthread_attr_setinheritsched+0x2c>
return EINVAL;
switch ( inheritsched ) {
111b6f: 8d 4a ff lea -0x1(%edx),%ecx
111b72: 83 f9 01 cmp $0x1,%ecx
111b75: 76 09 jbe 111b80 <pthread_attr_setinheritsched+0x24>
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
return 0;
default:
return ENOTSUP;
111b77: b8 86 00 00 00 mov $0x86,%eax
}
}
111b7c: c9 leave
111b7d: c3 ret
111b7e: 66 90 xchg %ax,%ax
return EINVAL;
switch ( inheritsched ) {
case PTHREAD_INHERIT_SCHED:
case PTHREAD_EXPLICIT_SCHED:
attr->inheritsched = inheritsched;
111b80: 89 50 10 mov %edx,0x10(%eax)
return 0;
111b83: 31 c0 xor %eax,%eax
default:
return ENOTSUP;
}
}
111b85: c9 leave
111b86: c3 ret
111b87: 90 nop
pthread_attr_t *attr,
int inheritsched
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
111b88: b8 16 00 00 00 mov $0x16,%eax
return 0;
default:
return ENOTSUP;
}
}
111b8d: c9 leave
111b8e: 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 f8 db 12 00 mov 0x12dbf8,%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
00111b90 <pthread_attr_setstacksize>:
int pthread_attr_setstacksize(
pthread_attr_t *attr,
size_t stacksize
)
{
111b90: 55 push %ebp
111b91: 89 e5 mov %esp,%ebp
111b93: 8b 45 08 mov 0x8(%ebp),%eax
111b96: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
111b99: 85 c0 test %eax,%eax
111b9b: 74 23 je 111bc0 <pthread_attr_setstacksize+0x30>
111b9d: 8b 08 mov (%eax),%ecx
111b9f: 85 c9 test %ecx,%ecx
111ba1: 74 1d je 111bc0 <pthread_attr_setstacksize+0x30>
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
111ba3: 8b 0d 78 45 12 00 mov 0x124578,%ecx
111ba9: d1 e1 shl %ecx
111bab: 39 d1 cmp %edx,%ecx
111bad: 77 09 ja 111bb8 <pthread_attr_setstacksize+0x28>
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
else
attr->stacksize = stacksize;
111baf: 89 50 08 mov %edx,0x8(%eax)
return 0;
111bb2: 31 c0 xor %eax,%eax
}
111bb4: c9 leave
111bb5: c3 ret
111bb6: 66 90 xchg %ax,%ax
{
if ( !attr || !attr->is_initialized )
return EINVAL;
if (stacksize < PTHREAD_MINIMUM_STACK_SIZE)
attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE;
111bb8: 89 48 08 mov %ecx,0x8(%eax)
else
attr->stacksize = stacksize;
return 0;
111bbb: 31 c0 xor %eax,%eax
}
111bbd: c9 leave
111bbe: c3 ret
111bbf: 90 nop
pthread_attr_t *attr,
size_t stacksize
)
{
if ( !attr || !attr->is_initialized )
return EINVAL;
111bc0: 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;
}
111bc5: c9 leave
111bc6: 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 f0 8c 12 00 mov 0x128cf0,%eax
10b9de: 40 inc %eax
10b9df: a3 f0 8c 12 00 mov %eax,0x128cf0
* 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 40 91 12 00 push $0x129140
10b9ec: e8 fb 20 00 00 call 10daec <_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 dd 16 00 00 call 10d0e8 <_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 5c 91 12 00 mov 0x12915c,%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 2d 30 00 00 call 10ea58 <_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 0b 30 00 00 call 10ea58 <_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 40 91 12 00 push $0x129140
10ba81: e8 1e 25 00 00 call 10dfa4 <_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 77 16 00 00 call 10d11c <_CORE_barrier_Wait>
the_barrier->Object.id,
true,
0,
NULL
);
_Thread_Enable_dispatch();
10baa5: 83 c4 20 add $0x20,%esp
10baa8: e8 ab 2f 00 00 call 10ea58 <_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 d8 92 12 00 mov 0x1292d8,%eax
true,
0,
NULL
);
_Thread_Enable_dispatch();
return _POSIX_Barrier_Translate_core_barrier_return_code(
10bab5: ff 70 34 pushl 0x34(%eax)
10bab8: e8 e7 5b 00 00 call 1116a4 <_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 8e 12 00 mov 0x128e54,%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 8b 12 00 push $0x128b40
10b159: e8 2a 21 00 00 call 10d288 <_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 5b 55 00 00 call 1106dc <_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 5d 08 mov 0x8(%ebp),%ebx
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 58 7f 12 00 mov 0x127f58,%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 70 79 12 00 mov 0x127970,%edx
10afd1: 42 inc %edx
10afd2: 89 15 70 79 12 00 mov %edx,0x127970
* 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: 5e pop %esi
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: 56 push %esi
10affa: 9d popf
10affb: 8b 70 08 mov 0x8(%eax),%esi
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 3a 3a 00 00 call 10ea44 <_Workspace_Free>
_Thread_Enable_dispatch();
10b00a: e8 ad 29 00 00 call 10d9bc <_Thread_Enable_dispatch>
if ( execute )
10b00f: 83 c4 10 add $0x10,%esp
10b012: 85 db test %ebx,%ebx
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 f0 mov %esi,%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 87 29 00 00 call 10d9bc <_Thread_Enable_dispatch>
_ISR_Enable( level );
10b035: 56 push %esi
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 10 90 12 00 mov 0x129010,%eax
10b374: 40 inc %eax
10b375: a3 10 90 12 00 mov %eax,0x129010
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 00 42 00 00 call 10f584 <_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 f8 95 12 00 mov 0x1295f8,%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 c3 17 00 00 call 10cb70 <_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 cd 30 00 00 jmp 10e488 <_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 b9 3d 00 00 call 10fe38 <_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 95 36 00 00 call 10f720 <_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 c0 a1 12 00 push $0x12a1c0
10c0ad: e8 7e 27 00 00 call 10e830 <_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 c0 a1 12 00 push $0x12a1c0
10c0ba: e8 6d 2a 00 00 call 10eb2c <_Objects_Free>
&_POSIX_Condition_variables_Information,
&the_cond->Object
);
_POSIX_Condition_variables_Free( the_cond );
_Thread_Enable_dispatch();
10c0bf: e8 5c 36 00 00 call 10f720 <_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 d0 9c 12 00 mov 0x129cd0,%eax
10c14d: 40 inc %eax
10c14e: a3 d0 9c 12 00 mov %eax,0x129cd0
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 c0 a1 12 00 push $0x12a1c0
10c15b: e8 54 26 00 00 call 10e7b4 <_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 2b 3d 00 00 call 10feb4 <_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 dc a1 12 00 mov 0x12a1dc,%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 74 35 00 00 call 10f720 <_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 33 12 00 mov $0x12333c,%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 57 35 00 00 call 10f720 <_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 33 12 00 mov 0x12333c,%edx
10c004: 8b 0d 40 33 12 00 mov 0x123340,%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 78 45 12 00 mov 0x124578,%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 e0 1e 12 00 mov $0x121ee0,%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 8e 12 00 mov 0x128e38,%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 95 62 00 00 call 111a30 <_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 7c 45 12 00 movzbl 0x12457c,%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 89 62 00 00 call 111a4c <_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 3c 89 12 00 pushl 0x12893c
10b7d9: 89 45 a0 mov %eax,-0x60(%ebp)
10b7dc: e8 bf 17 00 00 call 10cfa0 <_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 8b 12 00 movl $0x128b20,(%esp)
10b7e8: e8 d7 21 00 00 call 10d9c4 <_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 78 45 12 00 mov 0x124578,%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 8b 12 00 push $0x128b20
10b840: 89 55 a0 mov %edx,-0x60(%ebp)
10b843: e8 80 31 00 00 call 10e9c8 <_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 8b 12 00 push $0x128b20
10b85d: e8 da 24 00 00 call 10dd3c <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
10b862: 59 pop %ecx
10b863: ff 35 3c 89 12 00 pushl 0x12893c
10b869: e8 7a 17 00 00 call 10cfe8 <_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 66 3a 00 00 call 10f340 <_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 3c 89 12 00 pushl 0x12893c
10b8fa: 89 55 a0 mov %edx,-0x60(%ebp)
10b8fd: e8 e6 16 00 00 call 10cfe8 <_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 3c 89 12 00 pushl 0x12893c
10b916: e8 cd 16 00 00 call 10cfe8 <_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 a3 3b 00 00 call 10f4dc <_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 5c 89 12 00 push $0x12895c
10b951: e8 b6 3e 00 00 call 10f80c <_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>
00112e78 <pthread_exit>:
}
void pthread_exit(
void *value_ptr
)
{
112e78: 55 push %ebp
112e79: 89 e5 mov %esp,%ebp
112e7b: 83 ec 10 sub $0x10,%esp
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
112e7e: ff 75 08 pushl 0x8(%ebp)
112e81: ff 35 58 7b 12 00 pushl 0x127b58
112e87: e8 88 ff ff ff call 112e14 <_POSIX_Thread_Exit>
112e8c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
112e8f: c9 leave <== NOT EXECUTED
112e90: 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 60 b8 12 00 push $0x12b860
10d8f4: e8 07 24 00 00 call 10fd00 <_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 5c 72 12 00 movzbl 0x12725c,%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 83 2e 00 00 call 1107b4 <_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 40 8a 12 00 push $0x128a40
10b6ca: e8 a5 25 00 00 call 10dc74 <_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 78 8b 12 00 mov 0x128b78,%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 2c 30 00 00 call 10e728 <_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 22 13 00 push $0x132240
11112e: e8 11 24 00 00 call 113544 <_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 25 13 00 mov 0x132558,%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 00 48 11 00 push $0x114800
111172: 6a 00 push $0x0
111174: 83 c2 44 add $0x44,%edx
111177: 52 push %edx
111178: e8 57 33 00 00 call 1144d4 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
11117d: e8 76 2e 00 00 call 113ff8 <_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 5b 2e 00 00 call 113ff8 <_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 4b 2e 00 00 call 113ff8 <_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 90 85 12 00 mov 0x128590,%eax
10b552: 40 inc %eax
10b553: a3 90 85 12 00 mov %eax,0x128590
* 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 40 8a 12 00 push $0x128a40
10b55d: e8 5a 22 00 00 call 10d7bc <_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 68 85 12 00 mov 0x128568(,%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 fd 42 00 00 call 10f89c <_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 5c 8a 12 00 mov 0x128a5c,%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 4f 31 00 00 call 10e728 <_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 3f 31 00 00 call 10e728 <_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 40 8a 12 00 push $0x128a40
10b609: e8 26 25 00 00 call 10db34 <_Objects_Free>
_POSIX_Keys_Free( the_key );
_Thread_Enable_dispatch();
10b60e: e8 15 31 00 00 call 10e728 <_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 40 8a 12 00 push $0x128a40
10b637: e8 38 26 00 00 call 10dc74 <_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 40 8a 12 00 push $0x128a40
10b651: e8 e2 21 00 00 call 10d838 <_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 40 8a 12 00 push $0x128a40
10b666: e8 c9 24 00 00 call 10db34 <_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 b8 30 00 00 call 10e728 <_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
00124588 <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
124588: 55 push %ebp
124589: 89 e5 mov %esp,%ebp
12458b: 57 push %edi
12458c: 56 push %esi
12458d: 53 push %ebx
12458e: 83 ec 1c sub $0x1c,%esp
124591: 8b 5d 0c mov 0xc(%ebp),%ebx
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
124594: 85 db test %ebx,%ebx
124596: 0f 84 84 00 00 00 je 124620 <pthread_kill+0x98>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
12459c: 8d 7b ff lea -0x1(%ebx),%edi
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
12459f: 83 ff 1f cmp $0x1f,%edi
1245a2: 77 7c ja 124620 <pthread_kill+0x98>
pthread_t id,
Objects_Locations *location
)
{
return (Thread_Control *)
_Objects_Get( &_POSIX_Threads_Information, (Objects_Id)id, location );
1245a4: 56 push %esi
rtems_set_errno_and_return_minus_one( EINVAL );
the_thread = _POSIX_Threads_Get( thread, &location );
1245a5: 8d 45 e4 lea -0x1c(%ebp),%eax
1245a8: 50 push %eax
1245a9: ff 75 08 pushl 0x8(%ebp)
1245ac: 68 a0 e5 12 00 push $0x12e5a0
1245b1: e8 32 d9 fe ff call 111ee8 <_Objects_Get>
1245b6: 89 c6 mov %eax,%esi
switch ( location ) {
1245b8: 83 c4 10 add $0x10,%esp
1245bb: 8b 4d e4 mov -0x1c(%ebp),%ecx
1245be: 85 c9 test %ecx,%ecx
1245c0: 75 72 jne 124634 <pthread_kill+0xac>
case OBJECTS_LOCAL:
/*
* If sig == 0 then just validate arguments
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
1245c2: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
1245c8: 8d 04 5b lea (%ebx,%ebx,2),%eax
1245cb: 83 3c 85 28 e9 12 00 cmpl $0x1,0x12e928(,%eax,4)
1245d2: 01
1245d3: 74 2d je 124602 <pthread_kill+0x7a>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
1245d5: b8 01 00 00 00 mov $0x1,%eax
1245da: 89 f9 mov %edi,%ecx
1245dc: d3 e0 shl %cl,%eax
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
1245de: 09 82 d4 00 00 00 or %eax,0xd4(%edx)
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
1245e4: 52 push %edx
1245e5: 6a 00 push $0x0
1245e7: 53 push %ebx
1245e8: 56 push %esi
1245e9: e8 7a fe ff ff call 124468 <_POSIX_signals_Unblock_thread>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
1245ee: 83 c4 10 add $0x10,%esp
1245f1: a1 b4 e8 12 00 mov 0x12e8b4,%eax
1245f6: 85 c0 test %eax,%eax
1245f8: 74 08 je 124602 <pthread_kill+0x7a>
1245fa: 3b 35 b8 e8 12 00 cmp 0x12e8b8,%esi
124600: 74 12 je 124614 <pthread_kill+0x8c>
_Thread_Dispatch_necessary = true;
}
_Thread_Enable_dispatch();
124602: e8 15 e4 fe ff call 112a1c <_Thread_Enable_dispatch>
return 0;
124607: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
}
124609: 8d 65 f4 lea -0xc(%ebp),%esp
12460c: 5b pop %ebx
12460d: 5e pop %esi
12460e: 5f pop %edi
12460f: c9 leave
124610: c3 ret
124611: 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;
124614: c6 05 c4 e8 12 00 01 movb $0x1,0x12e8c4
12461b: eb e5 jmp 124602 <pthread_kill+0x7a>
12461d: 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 );
124620: e8 c7 3e ff ff call 1184ec <__errno>
124625: c7 00 16 00 00 00 movl $0x16,(%eax)
12462b: b8 ff ff ff ff mov $0xffffffff,%eax
124630: eb d7 jmp 124609 <pthread_kill+0x81>
124632: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
124634: e8 b3 3e ff ff call 1184ec <__errno>
124639: c7 00 03 00 00 00 movl $0x3,(%eax)
12463f: b8 ff ff ff ff mov $0xffffffff,%eax
124644: eb c3 jmp 124609 <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 5c 72 12 00 movzbl 0x12725c,%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 d3 35 00 00 call 1107b4 <_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 90 b5 12 00 mov 0x12b590,%eax
10d26e: 40 inc %eax
10d26f: a3 90 b5 12 00 mov %eax,0x12b590
* _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 a0 b9 12 00 push $0x12b9a0
10d27c: e8 c7 25 00 00 call 10f848 <_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 5c 72 12 00 movzbl 0x12725c,%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 0d 1d 00 00 call 10efd4 <_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 bc b9 12 00 mov 0x12b9bc,%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 d0 34 00 00 call 1107b4 <_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 20 ba 12 00 mov $0x12ba20,%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 87 34 00 00 call 1107b4 <_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 f4 0b 00 00 call 10c9cc <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 db 0b 00 00 call 10c9cc <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 b1 12 00 push $0x12b180
10c49a: e8 e1 2b 00 00 call 10f080 <_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 81 3e 00 00 call 110338 <_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 71 36 00 00 call 10fb34 <_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 b1 12 00 push $0x12b180
10c4e5: e8 5a 27 00 00 call 10ec44 <_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 b1 12 00 push $0x12b180
10c4f2: e8 49 2a 00 00 call 10ef40 <_Objects_Free>
_POSIX_RWLock_Free( the_rwlock );
_Thread_Enable_dispatch();
10c4f7: e8 38 36 00 00 call 10fb34 <_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 f0 ae 12 00 mov 0x12aef0,%eax
10c544: 40 inc %eax
10c545: a3 f0 ae 12 00 mov %eax,0x12aef0
* 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 b1 12 00 push $0x12b180
10c552: e8 71 26 00 00 call 10ebc8 <_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 3f 1e 00 00 call 10e3b0 <_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 b1 12 00 mov 0x12b19c,%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 a3 35 00 00 call 10fb34 <_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 8f 35 00 00 call 10fb34 <_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 ae 62 00 00 call 1128f4 <_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 b1 12 00 push $0x12b180
10c656: e8 25 2a 00 00 call 10f080 <_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 5f 1d 00 00 call 10e3e4 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10c685: 83 c4 20 add $0x20,%esp
10c688: e8 a7 34 00 00 call 10fb34 <_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 b4 12 00 mov 0x12b4d8,%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 b4 12 00 mov 0x12b4d8,%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 f6 61 00 00 call 1128f4 <_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 b1 12 00 push $0x12b180
10c70e: e8 6d 29 00 00 call 10f080 <_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 6f 1d 00 00 call 10e4ac <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10c73d: 83 c4 20 add $0x20,%esp
10c740: e8 ef 33 00 00 call 10fb34 <_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 b4 12 00 mov 0x12b4d8,%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 b4 12 00 mov 0x12b4d8,%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 8e 12 00 mov 0x128e54,%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 8e 12 00 mov 0x128e58,%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 70 88 12 00 mov 0x128870,%ebx
10b25e: 43 inc %ebx
10b25f: 89 1d 70 88 12 00 mov %ebx,0x128870
_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 8e 12 00 pushl 0x128e58
10b27c: e8 5b 54 00 00 call 1106dc <_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 8e 12 00 mov 0x128e54,%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 8e 12 00 mov 0x128e58,%ecx
10b2ca: 8b 89 ec 00 00 00 mov 0xec(%ecx),%ecx
10b2d0: 8b 1d 70 88 12 00 mov 0x128870,%ebx
10b2d6: 43 inc %ebx
10b2d7: 89 1d 70 88 12 00 mov %ebx,0x128870
_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 8e 12 00 pushl 0x128e58
10b2f4: e8 e3 53 00 00 call 1106dc <_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 f7 5b 00 00 call 113930 <_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 60 b8 12 00 push $0x12b860
10dd59: e8 a2 1f 00 00 call 10fd00 <_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 60 b5 12 00 mov 0x12b560,%eax
10ddc0: 89 42 78 mov %eax,0x78(%edx)
10ddc3: 0f b6 05 5c 72 12 00 movzbl 0x12725c,%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 20 25 00 00 call 110300 <_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 cc 29 00 00 call 1107b4 <_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 10 3a 00 00 call 11184c <_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 eb 39 00 00 call 11184c <_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>
00111cf4 <pthread_sigmask>:
int pthread_sigmask(
int how,
const sigset_t *set,
sigset_t *oset
)
{
111cf4: 55 push %ebp
111cf5: 89 e5 mov %esp,%ebp
111cf7: 56 push %esi
111cf8: 53 push %ebx
111cf9: 8b 4d 08 mov 0x8(%ebp),%ecx
111cfc: 8b 55 0c mov 0xc(%ebp),%edx
111cff: 8b 5d 10 mov 0x10(%ebp),%ebx
POSIX_API_Control *api;
if ( !set && !oset )
111d02: 85 d2 test %edx,%edx
111d04: 0f 84 8a 00 00 00 je 111d94 <pthread_sigmask+0xa0>
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
111d0a: a1 78 8b 12 00 mov 0x128b78,%eax
111d0f: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
if ( oset )
111d15: 85 db test %ebx,%ebx
111d17: 74 0c je 111d25 <pthread_sigmask+0x31>
*oset = api->signals_blocked;
111d19: 8b b0 d0 00 00 00 mov 0xd0(%eax),%esi
111d1f: 89 33 mov %esi,(%ebx)
if ( !set )
111d21: 85 d2 test %edx,%edx
111d23: 74 3b je 111d60 <pthread_sigmask+0x6c>
return 0;
switch ( how ) {
111d25: 83 f9 01 cmp $0x1,%ecx
111d28: 74 5e je 111d88 <pthread_sigmask+0x94>
111d2a: 83 f9 02 cmp $0x2,%ecx
111d2d: 74 39 je 111d68 <pthread_sigmask+0x74>
111d2f: 85 c9 test %ecx,%ecx
111d31: 75 41 jne 111d74 <pthread_sigmask+0x80>
break;
case SIG_UNBLOCK:
api->signals_blocked &= ~*set;
break;
case SIG_SETMASK:
api->signals_blocked = *set;
111d33: 8b 12 mov (%edx),%edx
111d35: 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) ) {
111d3b: 8b 15 e8 8d 12 00 mov 0x128de8,%edx
111d41: 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 &
111d47: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
111d4d: f7 d0 not %eax
111d4f: 85 c2 test %eax,%edx
111d51: 74 0d je 111d60 <pthread_sigmask+0x6c>
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
111d53: e8 1c c9 ff ff call 10e674 <_Thread_Dispatch>
}
return 0;
111d58: 31 c0 xor %eax,%eax
}
111d5a: 5b pop %ebx
111d5b: 5e pop %esi
111d5c: c9 leave
111d5d: c3 ret
111d5e: 66 90 xchg %ax,%ax
if ( ~api->signals_blocked &
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
}
return 0;
111d60: 31 c0 xor %eax,%eax
}
111d62: 5b pop %ebx
111d63: 5e pop %esi
111d64: c9 leave
111d65: c3 ret
111d66: 66 90 xchg %ax,%ax
switch ( how ) {
case SIG_BLOCK:
api->signals_blocked |= *set;
break;
case SIG_UNBLOCK:
api->signals_blocked &= ~*set;
111d68: 8b 12 mov (%edx),%edx
111d6a: f7 d2 not %edx
111d6c: 21 90 d0 00 00 00 and %edx,0xd0(%eax)
break;
111d72: eb c7 jmp 111d3b <pthread_sigmask+0x47>
case SIG_SETMASK:
api->signals_blocked = *set;
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
111d74: e8 a7 25 00 00 call 114320 <__errno>
111d79: c7 00 16 00 00 00 movl $0x16,(%eax)
111d7f: b8 ff ff ff ff mov $0xffffffff,%eax
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Dispatch();
}
return 0;
}
111d84: 5b pop %ebx
111d85: 5e pop %esi
111d86: c9 leave
111d87: c3 ret
if ( !set )
return 0;
switch ( how ) {
case SIG_BLOCK:
api->signals_blocked |= *set;
111d88: 8b 12 mov (%edx),%edx
111d8a: 09 90 d0 00 00 00 or %edx,0xd0(%eax)
break;
111d90: eb a9 jmp 111d3b <pthread_sigmask+0x47>
111d92: 66 90 xchg %ax,%ax
sigset_t *oset
)
{
POSIX_API_Control *api;
if ( !set && !oset )
111d94: 85 db test %ebx,%ebx
111d96: 74 dc je 111d74 <pthread_sigmask+0x80>
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
111d98: a1 78 8b 12 00 mov 0x128b78,%eax
111d9d: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
111da3: e9 71 ff ff ff jmp 111d19 <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 f4 95 12 00 mov 0x1295f4,%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 f8 95 12 00 mov 0x1295f8,%eax
10bb99: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
10bb9f: 8b 15 10 90 12 00 mov 0x129010,%edx
10bba5: 42 inc %edx
10bba6: 89 15 10 90 12 00 mov %edx,0x129010
_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 c3 28 00 00 call 10e488 <_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 f8 95 12 00 pushl 0x1295f8
10bbd0: e8 53 5b 00 00 call 111728 <_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 a6 28 00 00 jmp 10e488 <_Thread_Enable_dispatch>
0011ea00 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
11ea00: 55 push %ebp
11ea01: 89 e5 mov %esp,%ebp
11ea03: 53 push %ebx
11ea04: 83 ec 04 sub $0x4,%esp
11ea07: 8b 4d 08 mov 0x8(%ebp),%ecx
11ea0a: 8b 45 0c mov 0xc(%ebp),%eax
11ea0d: 8b 55 10 mov 0x10(%ebp),%edx
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
11ea10: 3b 0d ac 31 12 00 cmp 0x1231ac,%ecx
11ea16: 73 50 jae 11ea68 <read+0x68> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
11ea18: c1 e1 03 shl $0x3,%ecx
11ea1b: 8d 1c cd 00 00 00 00 lea 0x0(,%ecx,8),%ebx
11ea22: 29 cb sub %ecx,%ebx
11ea24: 03 1d 00 74 12 00 add 0x127400,%ebx
rtems_libio_check_is_open( iop );
11ea2a: 8b 4b 14 mov 0x14(%ebx),%ecx
11ea2d: f6 c5 01 test $0x1,%ch
11ea30: 74 36 je 11ea68 <read+0x68>
rtems_libio_check_buffer( buffer );
11ea32: 85 c0 test %eax,%eax
11ea34: 74 46 je 11ea7c <read+0x7c> <== NEVER TAKEN
rtems_libio_check_count( count );
11ea36: 85 d2 test %edx,%edx
11ea38: 74 26 je 11ea60 <read+0x60>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
11ea3a: 83 e1 02 and $0x2,%ecx
11ea3d: 74 3d je 11ea7c <read+0x7c>
/*
* Now process the read().
*/
rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
11ea3f: 51 push %ecx
11ea40: 8b 4b 20 mov 0x20(%ebx),%ecx
11ea43: 52 push %edx
11ea44: 50 push %eax
11ea45: 53 push %ebx
11ea46: ff 51 08 call *0x8(%ecx)
if ( rc > 0 )
11ea49: 83 c4 10 add $0x10,%esp
11ea4c: 85 c0 test %eax,%eax
11ea4e: 7e 0b jle 11ea5b <read+0x5b>
iop->offset += rc;
11ea50: 89 c1 mov %eax,%ecx
11ea52: c1 f9 1f sar $0x1f,%ecx
11ea55: 01 43 0c add %eax,0xc(%ebx)
11ea58: 11 4b 10 adc %ecx,0x10(%ebx)
return rc;
}
11ea5b: 8b 5d fc mov -0x4(%ebp),%ebx
11ea5e: c9 leave
11ea5f: 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 );
11ea60: 31 c0 xor %eax,%eax
if ( rc > 0 )
iop->offset += rc;
return rc;
}
11ea62: 8b 5d fc mov -0x4(%ebp),%ebx
11ea65: c9 leave
11ea66: c3 ret
11ea67: 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 );
11ea68: e8 a7 48 ff ff call 113314 <__errno>
11ea6d: c7 00 09 00 00 00 movl $0x9,(%eax)
11ea73: b8 ff ff ff ff mov $0xffffffff,%eax
11ea78: eb e1 jmp 11ea5b <read+0x5b>
11ea7a: 66 90 xchg %ax,%ax
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
11ea7c: e8 93 48 ff ff call 113314 <__errno>
11ea81: c7 00 16 00 00 00 movl $0x16,(%eax)
11ea87: b8 ff ff ff ff mov $0xffffffff,%eax
11ea8c: eb cd jmp 11ea5b <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 53 ad 00 00 call 115e40 <__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 32 ad 00 00 call 115e40 <__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 cc 47 12 00 cmp 0x1247cc,%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 20 8a 12 00 add 0x128a20,%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 9b a2 00 00 call 1140a4 <__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 69 a2 00 00 call 1140a4 <__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>
0011eb1c <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
11eb1c: 55 push %ebp
11eb1d: 89 e5 mov %esp,%ebp
11eb1f: 57 push %edi
11eb20: 56 push %esi
11eb21: 53 push %ebx
11eb22: 83 ec 2c sub $0x2c,%esp
11eb25: 8b 5d 08 mov 0x8(%ebp),%ebx
11eb28: 8b 75 0c mov 0xc(%ebp),%esi
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
11eb2b: ff 05 30 74 12 00 incl 0x127430
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
11eb31: 83 3d 40 77 12 00 03 cmpl $0x3,0x127740
11eb38: 74 72 je 11ebac <realloc+0x90> <== ALWAYS TAKEN
}
/*
* Continue with realloc().
*/
if ( !ptr )
11eb3a: 85 db test %ebx,%ebx
11eb3c: 74 5e je 11eb9c <realloc+0x80>
return malloc( size );
if ( !size ) {
11eb3e: 85 f6 test %esi,%esi
11eb40: 74 3a je 11eb7c <realloc+0x60> <== NEVER TAKEN
free( ptr );
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
11eb42: 52 push %edx
11eb43: 8d 45 e4 lea -0x1c(%ebp),%eax
11eb46: 50 push %eax
11eb47: 53 push %ebx
11eb48: ff 35 b8 31 12 00 pushl 0x1231b8
11eb4e: e8 49 01 00 00 call 11ec9c <_Protected_heap_Get_block_size>
11eb53: 83 c4 10 add $0x10,%esp
11eb56: 84 c0 test %al,%al
11eb58: 74 32 je 11eb8c <realloc+0x70>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
11eb5a: 50 push %eax
11eb5b: 56 push %esi
11eb5c: 53 push %ebx
11eb5d: ff 35 b8 31 12 00 pushl 0x1231b8
11eb63: e8 6c 01 00 00 call 11ecd4 <_Protected_heap_Resize_block>
11eb68: 83 c4 10 add $0x10,%esp
11eb6b: 84 c0 test %al,%al
11eb6d: 74 5d je 11ebcc <realloc+0xb0>
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
11eb6f: 89 d8 mov %ebx,%eax
11eb71: 8d 65 f4 lea -0xc(%ebp),%esp
11eb74: 5b pop %ebx
11eb75: 5e pop %esi
11eb76: 5f pop %edi
11eb77: c9 leave
11eb78: c3 ret
11eb79: 8d 76 00 lea 0x0(%esi),%esi
*/
if ( !ptr )
return malloc( size );
if ( !size ) {
free( ptr );
11eb7c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
11eb7f: 53 push %ebx <== NOT EXECUTED
11eb80: e8 2f 95 fe ff call 1080b4 <free> <== NOT EXECUTED
return (void *) 0;
11eb85: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
11eb88: 31 db xor %ebx,%ebx <== NOT EXECUTED
11eb8a: eb e3 jmp 11eb6f <realloc+0x53> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
11eb8c: e8 83 47 ff ff call 113314 <__errno>
11eb91: c7 00 16 00 00 00 movl $0x16,(%eax)
return (void *) 0;
11eb97: 31 db xor %ebx,%ebx
11eb99: eb d4 jmp 11eb6f <realloc+0x53>
11eb9b: 90 nop
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
11eb9c: 83 ec 0c sub $0xc,%esp
11eb9f: 56 push %esi
11eba0: e8 e3 97 fe ff call 108388 <malloc>
11eba5: 89 c3 mov %eax,%ebx
11eba7: 83 c4 10 add $0x10,%esp
11ebaa: eb c3 jmp 11eb6f <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)
11ebac: a1 70 75 12 00 mov 0x127570,%eax
11ebb1: 85 c0 test %eax,%eax
11ebb3: 74 04 je 11ebb9 <realloc+0x9d> <== ALWAYS TAKEN
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
return (void *) 0;
11ebb5: 31 db xor %ebx,%ebx
11ebb7: eb b6 jmp 11eb6f <realloc+0x53>
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_disable_level > 0)
return (void *) 0;
if (_ISR_Nest_level > 0)
11ebb9: 8b 0d 54 7b 12 00 mov 0x127b54,%ecx
11ebbf: 85 c9 test %ecx,%ecx
11ebc1: 0f 84 73 ff ff ff je 11eb3a <realloc+0x1e> <== ALWAYS TAKEN
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
return (void *) 0;
11ebc7: 31 db xor %ebx,%ebx
11ebc9: eb a4 jmp 11eb6f <realloc+0x53> <== NOT EXECUTED
11ebcb: 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 );
11ebcc: 83 ec 0c sub $0xc,%esp
11ebcf: 56 push %esi
11ebd0: e8 b3 97 fe ff call 108388 <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
11ebd5: ff 0d 24 74 12 00 decl 0x127424
if ( !new_area ) {
11ebdb: 83 c4 10 add $0x10,%esp
11ebde: 85 c0 test %eax,%eax
11ebe0: 74 d3 je 11ebb5 <realloc+0x99>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
11ebe2: 8b 55 e4 mov -0x1c(%ebp),%edx
11ebe5: 89 f1 mov %esi,%ecx
11ebe7: 39 d6 cmp %edx,%esi
11ebe9: 76 02 jbe 11ebed <realloc+0xd1> <== NEVER TAKEN
11ebeb: 89 d1 mov %edx,%ecx
11ebed: 89 c7 mov %eax,%edi
11ebef: 89 de mov %ebx,%esi
11ebf1: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
free( ptr );
11ebf3: 83 ec 0c sub $0xc,%esp
11ebf6: 53 push %ebx
11ebf7: 89 45 d4 mov %eax,-0x2c(%ebp)
11ebfa: e8 b5 94 fe ff call 1080b4 <free>
return new_area;
11ebff: 83 c4 10 add $0x10,%esp
11ec02: 8b 45 d4 mov -0x2c(%ebp),%eax
11ec05: 89 c3 mov %eax,%ebx
11ec07: e9 63 ff ff ff jmp 11eb6f <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 8f a7 00 00 call 113bac <__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>
0010c50c <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
10c50c: 55 push %ebp
10c50d: 89 e5 mov %esp,%ebp
10c50f: 57 push %edi
10c510: 56 push %esi
10c511: 53 push %ebx
10c512: 83 ec 58 sub $0x58,%esp
10c515: 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);
10c518: 68 80 a1 12 00 push $0x12a180
10c51d: e8 7e 09 00 00 call 10cea0 <pthread_mutex_lock>
10c522: 89 c6 mov %eax,%esi
if (result != 0) {
10c524: 83 c4 10 add $0x10,%esp
10c527: 85 c0 test %eax,%eax
10c529: 0f 85 c1 00 00 00 jne 10c5f0 <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);
10c52f: e8 1c 12 00 00 call 10d750 <pthread_self>
10c534: 51 push %ecx
10c535: 8d 55 c4 lea -0x3c(%ebp),%edx
10c538: 52 push %edx
10c539: 8d 55 e0 lea -0x20(%ebp),%edx
10c53c: 52 push %edx
10c53d: 50 push %eax
10c53e: e8 d9 0d 00 00 call 10d31c <pthread_getschedparam>
req->caller_thread = pthread_self ();
10c543: e8 08 12 00 00 call 10d750 <pthread_self>
10c548: 89 43 10 mov %eax,0x10(%ebx)
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
10c54b: 8b 43 14 mov 0x14(%ebx),%eax
10c54e: 8b 55 c4 mov -0x3c(%ebp),%edx
10c551: 2b 50 14 sub 0x14(%eax),%edx
10c554: 89 53 0c mov %edx,0xc(%ebx)
req->policy = policy;
10c557: 8b 55 e0 mov -0x20(%ebp),%edx
10c55a: 89 53 08 mov %edx,0x8(%ebx)
req->aiocbp->error_code = EINPROGRESS;
10c55d: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax)
req->aiocbp->return_value = 0;
10c564: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
if ((aio_request_queue.idle_threads == 0) &&
10c56b: 83 c4 10 add $0x10,%esp
10c56e: 8b 15 e8 a1 12 00 mov 0x12a1e8,%edx
10c574: 85 d2 test %edx,%edx
10c576: 75 0d jne 10c585 <rtems_aio_enqueue+0x79>
10c578: 83 3d e4 a1 12 00 04 cmpl $0x4,0x12a1e4
10c57f: 0f 8e 83 00 00 00 jle 10c608 <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,
10c585: 51 push %ecx
10c586: 6a 00 push $0x0
10c588: ff 30 pushl (%eax)
10c58a: 68 c8 a1 12 00 push $0x12a1c8
10c58f: e8 44 fb ff ff call 10c0d8 <rtems_aio_search_fd>
10c594: 89 c7 mov %eax,%edi
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
10c596: 83 c4 10 add $0x10,%esp
10c599: 85 c0 test %eax,%eax
10c59b: 0f 84 df 00 00 00 je 10c680 <rtems_aio_enqueue+0x174>
{
pthread_mutex_lock (&r_chain->mutex);
10c5a1: 8d 57 1c lea 0x1c(%edi),%edx
10c5a4: 83 ec 0c sub $0xc,%esp
10c5a7: 52 push %edx
10c5a8: 89 55 b4 mov %edx,-0x4c(%ebp)
10c5ab: e8 f0 08 00 00 call 10cea0 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
10c5b0: 58 pop %eax
10c5b1: 5a pop %edx
10c5b2: 53 push %ebx
10c5b3: 8d 47 08 lea 0x8(%edi),%eax
10c5b6: 50 push %eax
10c5b7: e8 48 fe ff ff call 10c404 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
10c5bc: 83 c7 20 add $0x20,%edi
10c5bf: 89 3c 24 mov %edi,(%esp)
10c5c2: e8 a9 04 00 00 call 10ca70 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
10c5c7: 8b 55 b4 mov -0x4c(%ebp),%edx
10c5ca: 89 14 24 mov %edx,(%esp)
10c5cd: e8 56 09 00 00 call 10cf28 <pthread_mutex_unlock>
10c5d2: 83 c4 10 add $0x10,%esp
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
10c5d5: 83 ec 0c sub $0xc,%esp
10c5d8: 68 80 a1 12 00 push $0x12a180
10c5dd: e8 46 09 00 00 call 10cf28 <pthread_mutex_unlock>
return 0;
10c5e2: 83 c4 10 add $0x10,%esp
}
10c5e5: 89 f0 mov %esi,%eax
10c5e7: 8d 65 f4 lea -0xc(%ebp),%esp
10c5ea: 5b pop %ebx
10c5eb: 5e pop %esi
10c5ec: 5f pop %edi
10c5ed: c9 leave
10c5ee: c3 ret
10c5ef: 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);
10c5f0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c5f3: 53 push %ebx <== NOT EXECUTED
10c5f4: e8 3b c5 ff ff call 108b34 <free> <== NOT EXECUTED
return result;
10c5f9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
return 0;
}
10c5fc: 89 f0 mov %esi,%eax <== NOT EXECUTED
10c5fe: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10c601: 5b pop %ebx <== NOT EXECUTED
10c602: 5e pop %esi <== NOT EXECUTED
10c603: 5f pop %edi <== NOT EXECUTED
10c604: c9 leave <== NOT EXECUTED
10c605: c3 ret <== NOT EXECUTED
10c606: 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);
10c608: 57 push %edi
10c609: 6a 01 push $0x1
10c60b: ff 30 pushl (%eax)
10c60d: 68 c8 a1 12 00 push $0x12a1c8
10c612: e8 c1 fa ff ff call 10c0d8 <rtems_aio_search_fd>
10c617: 89 c7 mov %eax,%edi
if (r_chain->new_fd == 1) {
10c619: 83 c4 10 add $0x10,%esp
10c61c: 83 78 18 01 cmpl $0x1,0x18(%eax)
10c620: 0f 85 7b ff ff ff jne 10c5a1 <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);
10c626: 83 ec 08 sub $0x8,%esp
10c629: 53 push %ebx
10c62a: 8d 40 08 lea 0x8(%eax),%eax
10c62d: 50 push %eax
10c62e: e8 7d 22 00 00 call 10e8b0 <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
10c633: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
pthread_mutex_init (&r_chain->mutex, NULL);
10c63a: 5a pop %edx
10c63b: 59 pop %ecx
10c63c: 6a 00 push $0x0
10c63e: 8d 47 1c lea 0x1c(%edi),%eax
10c641: 50 push %eax
10c642: e8 0d 07 00 00 call 10cd54 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10c647: 5b pop %ebx
10c648: 58 pop %eax
10c649: 6a 00 push $0x0
10c64b: 8d 47 20 lea 0x20(%edi),%eax
10c64e: 50 push %eax
10c64f: e8 68 03 00 00 call 10c9bc <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
10c654: 57 push %edi
10c655: 68 98 c1 10 00 push $0x10c198
10c65a: 68 88 a1 12 00 push $0x12a188
10c65f: 8d 45 e4 lea -0x1c(%ebp),%eax
10c662: 50 push %eax
10c663: e8 2c 0a 00 00 call 10d094 <pthread_create>
10c668: 89 c3 mov %eax,%ebx
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
10c66a: 83 c4 20 add $0x20,%esp
10c66d: 85 c0 test %eax,%eax
10c66f: 0f 85 87 00 00 00 jne 10c6fc <rtems_aio_enqueue+0x1f0><== NEVER TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
}
++aio_request_queue.active_threads;
10c675: ff 05 e4 a1 12 00 incl 0x12a1e4
10c67b: e9 55 ff ff ff jmp 10c5d5 <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);
10c680: 51 push %ecx
10c681: 6a 01 push $0x1
10c683: 8b 43 14 mov 0x14(%ebx),%eax
10c686: ff 30 pushl (%eax)
10c688: 68 d4 a1 12 00 push $0x12a1d4
10c68d: e8 46 fa ff ff call 10c0d8 <rtems_aio_search_fd>
10c692: 89 c7 mov %eax,%edi
if (r_chain->new_fd == 1) {
10c694: 83 c4 10 add $0x10,%esp
10c697: 83 78 18 01 cmpl $0x1,0x18(%eax)
10c69b: 74 17 je 10c6b4 <rtems_aio_enqueue+0x1a8>
pthread_cond_init (&r_chain->cond, NULL);
pthread_cond_signal (&aio_request_queue.new_req);
++aio_request_queue.idle_threads;
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
10c69d: 83 ec 08 sub $0x8,%esp
10c6a0: 53 push %ebx
10c6a1: 83 c7 08 add $0x8,%edi
10c6a4: 57 push %edi
10c6a5: e8 5a fd ff ff call 10c404 <rtems_aio_insert_prio>
10c6aa: 83 c4 10 add $0x10,%esp
10c6ad: e9 23 ff ff ff jmp 10c5d5 <rtems_aio_enqueue+0xc9>
10c6b2: 66 90 xchg %ax,%ax
10c6b4: 83 ec 08 sub $0x8,%esp
10c6b7: 53 push %ebx
10c6b8: 8d 40 08 lea 0x8(%eax),%eax
10c6bb: 50 push %eax
10c6bc: e8 ef 21 00 00 call 10e8b0 <_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;
10c6c1: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
pthread_mutex_init (&r_chain->mutex, NULL);
10c6c8: 58 pop %eax
10c6c9: 5a pop %edx
10c6ca: 6a 00 push $0x0
10c6cc: 8d 47 1c lea 0x1c(%edi),%eax
10c6cf: 50 push %eax
10c6d0: e8 7f 06 00 00 call 10cd54 <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10c6d5: 59 pop %ecx
10c6d6: 5b pop %ebx
10c6d7: 6a 00 push $0x0
10c6d9: 83 c7 20 add $0x20,%edi
10c6dc: 57 push %edi
10c6dd: e8 da 02 00 00 call 10c9bc <pthread_cond_init>
pthread_cond_signal (&aio_request_queue.new_req);
10c6e2: c7 04 24 84 a1 12 00 movl $0x12a184,(%esp)
10c6e9: e8 82 03 00 00 call 10ca70 <pthread_cond_signal>
++aio_request_queue.idle_threads;
10c6ee: ff 05 e8 a1 12 00 incl 0x12a1e8
10c6f4: 83 c4 10 add $0x10,%esp
10c6f7: e9 d9 fe ff ff jmp 10c5d5 <rtems_aio_enqueue+0xc9>
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);
10c6fc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c6ff: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED
10c704: e8 1f 08 00 00 call 10cf28 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
10c709: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c70c: 89 de mov %ebx,%esi <== NOT EXECUTED
10c70e: e9 d2 fe ff ff jmp 10c5e5 <rtems_aio_enqueue+0xd9><== NOT EXECUTED
0010c198 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
10c198: 55 push %ebp <== NOT EXECUTED
10c199: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10c19b: 57 push %edi <== NOT EXECUTED
10c19c: 56 push %esi <== NOT EXECUTED
10c19d: 53 push %ebx <== NOT EXECUTED
10c19e: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED
rtems_aio_request_chain *r_chain = arg;
10c1a1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
10c1a4: 8d 43 1c lea 0x1c(%ebx),%eax <== NOT EXECUTED
10c1a7: 89 45 b4 mov %eax,-0x4c(%ebp) <== NOT EXECUTED
10c1aa: 66 90 xchg %ax,%ax <== NOT EXECUTED
/* 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);
10c1ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c1af: ff 75 b4 pushl -0x4c(%ebp) <== NOT EXECUTED
10c1b2: e8 e9 0c 00 00 call 10cea0 <pthread_mutex_lock> <== NOT EXECUTED
if (result != 0)
10c1b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c1ba: 85 c0 test %eax,%eax <== NOT EXECUTED
10c1bc: 0f 85 92 01 00 00 jne 10c354 <rtems_aio_handle+0x1bc><== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c1c2: 8b 73 08 mov 0x8(%ebx),%esi <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10c1c5: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED
/* 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)) {
10c1c8: 39 c6 cmp %eax,%esi <== NOT EXECUTED
10c1ca: 0f 84 d0 00 00 00 je 10c2a0 <rtems_aio_handle+0x108><== NOT EXECUTED
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);
10c1d0: e8 7b 15 00 00 call 10d750 <pthread_self> <== NOT EXECUTED
10c1d5: 52 push %edx <== NOT EXECUTED
10c1d6: 8d 55 c0 lea -0x40(%ebp),%edx <== NOT EXECUTED
10c1d9: 52 push %edx <== NOT EXECUTED
10c1da: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED
10c1dd: 52 push %edx <== NOT EXECUTED
10c1de: 50 push %eax <== NOT EXECUTED
10c1df: e8 38 11 00 00 call 10d31c <pthread_getschedparam> <== NOT EXECUTED
param.sched_priority = req->priority;
10c1e4: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED
10c1e7: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED
pthread_setschedparam (pthread_self(), req->policy, ¶m);
10c1ea: 8b 7e 08 mov 0x8(%esi),%edi <== NOT EXECUTED
10c1ed: e8 5e 15 00 00 call 10d750 <pthread_self> <== NOT EXECUTED
10c1f2: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10c1f5: 8d 55 c0 lea -0x40(%ebp),%edx <== NOT EXECUTED
10c1f8: 52 push %edx <== NOT EXECUTED
10c1f9: 57 push %edi <== NOT EXECUTED
10c1fa: 50 push %eax <== NOT EXECUTED
10c1fb: e8 60 15 00 00 call 10d760 <pthread_setschedparam> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10c200: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10c203: e8 6c 26 00 00 call 10e874 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
10c208: 5f pop %edi <== NOT EXECUTED
10c209: ff 75 b4 pushl -0x4c(%ebp) <== NOT EXECUTED
10c20c: e8 17 0d 00 00 call 10cf28 <pthread_mutex_unlock> <== NOT EXECUTED
switch (req->aiocbp->aio_lio_opcode) {
10c211: 8b 7e 14 mov 0x14(%esi),%edi <== NOT EXECUTED
10c214: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c217: 8b 47 2c mov 0x2c(%edi),%eax <== NOT EXECUTED
10c21a: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED
10c21d: 74 21 je 10c240 <rtems_aio_handle+0xa8> <== NOT EXECUTED
10c21f: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED
10c222: 74 6c je 10c290 <rtems_aio_handle+0xf8> <== NOT EXECUTED
10c224: 48 dec %eax <== NOT EXECUTED
10c225: 74 4d je 10c274 <rtems_aio_handle+0xdc> <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
10c227: c7 47 34 ff ff ff ff movl $0xffffffff,0x34(%edi) <== NOT EXECUTED
req->aiocbp->error_code = errno;
10c22e: e8 c9 99 00 00 call 115bfc <__errno> <== NOT EXECUTED
10c233: 8b 00 mov (%eax),%eax <== NOT EXECUTED
10c235: 89 47 30 mov %eax,0x30(%edi) <== NOT EXECUTED
10c238: e9 6f ff ff ff jmp 10c1ac <rtems_aio_handle+0x14> <== NOT EXECUTED
10c23d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
result = pwrite (req->aiocbp->aio_fildes,
10c240: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c243: ff 77 08 pushl 0x8(%edi) <== NOT EXECUTED
10c246: ff 77 04 pushl 0x4(%edi) <== NOT EXECUTED
10c249: ff 77 10 pushl 0x10(%edi) <== NOT EXECUTED
10c24c: ff 77 0c pushl 0xc(%edi) <== NOT EXECUTED
10c24f: ff 37 pushl (%edi) <== NOT EXECUTED
10c251: e8 3e a4 00 00 call 116694 <pwrite> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
10c256: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
10c259: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED
10c25c: 0f 84 9a 01 00 00 je 10c3fc <rtems_aio_handle+0x264><== NOT EXECUTED
req->aiocbp->return_value = -1;
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
10c262: 8b 56 14 mov 0x14(%esi),%edx <== NOT EXECUTED
10c265: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED
req->aiocbp->error_code = 0;
10c268: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) <== NOT EXECUTED
10c26f: e9 38 ff ff ff jmp 10c1ac <rtems_aio_handle+0x14> <== NOT EXECUTED
pthread_mutex_unlock (&r_chain->mutex);
switch (req->aiocbp->aio_lio_opcode) {
case LIO_READ:
result = pread (req->aiocbp->aio_fildes,
10c274: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c277: ff 77 08 pushl 0x8(%edi) <== NOT EXECUTED
10c27a: ff 77 04 pushl 0x4(%edi) <== NOT EXECUTED
10c27d: ff 77 10 pushl 0x10(%edi) <== NOT EXECUTED
10c280: ff 77 0c pushl 0xc(%edi) <== NOT EXECUTED
10c283: ff 37 pushl (%edi) <== NOT EXECUTED
10c285: e8 56 a3 00 00 call 1165e0 <pread> <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
10c28a: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
10c28d: eb ca jmp 10c259 <rtems_aio_handle+0xc1> <== NOT EXECUTED
10c28f: 90 nop <== NOT EXECUTED
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_SYNC:
result = fsync (req->aiocbp->aio_fildes);
10c290: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c293: ff 37 pushl (%edi) <== NOT EXECUTED
10c295: e8 0a 67 00 00 call 1129a4 <fsync> <== NOT EXECUTED
break;
10c29a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c29d: eb ba jmp 10c259 <rtems_aio_handle+0xc1> <== NOT EXECUTED
10c29f: 90 nop <== NOT EXECUTED
wait for a signal on chain, this will unlock the queue.
The fd chain is already unlocked */
struct timespec timeout;
pthread_mutex_unlock (&r_chain->mutex);
10c2a0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c2a3: ff 75 b4 pushl -0x4c(%ebp) <== NOT EXECUTED
10c2a6: e8 7d 0c 00 00 call 10cf28 <pthread_mutex_unlock> <== NOT EXECUTED
pthread_mutex_lock (&aio_request_queue.mutex);
10c2ab: c7 04 24 80 a1 12 00 movl $0x12a180,(%esp) <== NOT EXECUTED
10c2b2: e8 e9 0b 00 00 call 10cea0 <pthread_mutex_lock> <== NOT EXECUTED
if (rtems_chain_is_empty (chain))
10c2b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c2ba: 3b 73 08 cmp 0x8(%ebx),%esi <== NOT EXECUTED
10c2bd: 0f 85 e9 fe ff ff jne 10c1ac <rtems_aio_handle+0x14> <== NOT EXECUTED
{
clock_gettime (CLOCK_REALTIME, &timeout);
10c2c3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10c2c6: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED
10c2c9: 50 push %eax <== NOT EXECUTED
10c2ca: 6a 01 push $0x1 <== NOT EXECUTED
10c2cc: e8 b3 05 00 00 call 10c884 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
10c2d1: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED
timeout.tv_nsec = 0;
10c2d5: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
result = pthread_cond_timedwait (&r_chain->cond,
10c2dc: 8d 73 20 lea 0x20(%ebx),%esi <== NOT EXECUTED
10c2df: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10c2e2: 8d 55 dc lea -0x24(%ebp),%edx <== NOT EXECUTED
10c2e5: 52 push %edx <== NOT EXECUTED
10c2e6: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED
10c2eb: 56 push %esi <== NOT EXECUTED
10c2ec: e8 03 08 00 00 call 10caf4 <pthread_cond_timedwait><== NOT EXECUTED
&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) {
10c2f1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c2f4: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED
10c2f7: 0f 85 af fe ff ff jne 10c1ac <rtems_aio_handle+0x14> <== NOT EXECUTED
10c2fd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c300: 53 push %ebx <== NOT EXECUTED
10c301: e8 6e 25 00 00 call 10e874 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
10c306: 59 pop %ecx <== NOT EXECUTED
10c307: ff 75 b4 pushl -0x4c(%ebp) <== NOT EXECUTED
10c30a: e8 25 09 00 00 call 10cc34 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_cond_destroy (&r_chain->cond);
10c30f: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10c312: e8 d9 05 00 00 call 10c8f0 <pthread_cond_destroy> <== NOT EXECUTED
free (r_chain);
10c317: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10c31a: e8 15 c8 ff ff call 108b34 <free> <== NOT EXECUTED
/* 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)) {
10c31f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c322: 81 3d d4 a1 12 00 d8 cmpl $0x12a1d8,0x12a1d4 <== NOT EXECUTED
10c329: a1 12 00
10c32c: 74 30 je 10c35e <rtems_aio_handle+0x1c6><== NOT EXECUTED
r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd;
}
else
/* 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);
10c32e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c331: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED
10c336: e8 ed 0b 00 00 call 10cf28 <pthread_mutex_unlock> <== NOT EXECUTED
10c33b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c33e: e9 69 fe ff ff jmp 10c1ac <rtems_aio_handle+0x14> <== NOT EXECUTED
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
pthread_mutex_unlock (&aio_request_queue.mutex);
10c343: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c346: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED
10c34b: e8 d8 0b 00 00 call 10cf28 <pthread_mutex_unlock> <== NOT EXECUTED
return NULL;
10c350: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c353: 90 nop <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c354: 31 c0 xor %eax,%eax <== NOT EXECUTED
10c356: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10c359: 5b pop %ebx <== NOT EXECUTED
10c35a: 5e pop %esi <== NOT EXECUTED
10c35b: 5f pop %edi <== NOT EXECUTED
10c35c: c9 leave <== NOT EXECUTED
10c35d: c3 ret <== NOT EXECUTED
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)) {
++aio_request_queue.idle_threads;
10c35e: ff 05 e8 a1 12 00 incl 0x12a1e8 <== NOT EXECUTED
clock_gettime (CLOCK_REALTIME, &timeout);
10c364: 52 push %edx <== NOT EXECUTED
10c365: 52 push %edx <== NOT EXECUTED
10c366: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED
10c369: 50 push %eax <== NOT EXECUTED
10c36a: 6a 01 push $0x1 <== NOT EXECUTED
10c36c: e8 13 05 00 00 call 10c884 <clock_gettime> <== NOT EXECUTED
timeout.tv_sec += 3;
10c371: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED
timeout.tv_nsec = 0;
10c375: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
result = pthread_cond_timedwait (&aio_request_queue.new_req,
10c37c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10c37f: 8d 55 dc lea -0x24(%ebp),%edx <== NOT EXECUTED
10c382: 52 push %edx <== NOT EXECUTED
10c383: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED
10c388: 68 84 a1 12 00 push $0x12a184 <== NOT EXECUTED
10c38d: e8 62 07 00 00 call 10caf4 <pthread_cond_timedwait><== NOT EXECUTED
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
10c392: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c395: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED
10c398: 74 a9 je 10c343 <rtems_aio_handle+0x1ab><== NOT EXECUTED
return NULL;
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
--aio_request_queue.idle_threads;
10c39a: ff 0d e8 a1 12 00 decl 0x12a1e8 <== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c3a0: 8b 35 d4 a1 12 00 mov 0x12a1d4,%esi <== NOT EXECUTED
10c3a6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c3a9: 56 push %esi <== NOT EXECUTED
10c3aa: e8 c5 24 00 00 call 10e874 <_Chain_Extract> <== NOT EXECUTED
/* Otherwise move this chain to the working chain and
start the loop all over again */
--aio_request_queue.idle_threads;
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
10c3af: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10c3b2: 6a 01 push $0x1 <== NOT EXECUTED
10c3b4: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED
10c3b7: 68 c8 a1 12 00 push $0x12a1c8 <== NOT EXECUTED
10c3bc: e8 17 fd ff ff call 10c0d8 <rtems_aio_search_fd> <== NOT EXECUTED
10c3c1: 89 c3 mov %eax,%ebx <== NOT EXECUTED
((rtems_aio_request_chain *)node)->fildes,
1);
r_chain->new_fd = 0;
10c3c3: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED
pthread_mutex_init (&r_chain->mutex, NULL);
10c3ca: 5f pop %edi <== NOT EXECUTED
10c3cb: 58 pop %eax <== NOT EXECUTED
10c3cc: 6a 00 push $0x0 <== NOT EXECUTED
10c3ce: 8d 43 1c lea 0x1c(%ebx),%eax <== NOT EXECUTED
10c3d1: 89 45 b4 mov %eax,-0x4c(%ebp) <== NOT EXECUTED
10c3d4: 50 push %eax <== NOT EXECUTED
10c3d5: e8 7a 09 00 00 call 10cd54 <pthread_mutex_init> <== NOT EXECUTED
pthread_cond_init (&r_chain->cond, NULL);
10c3da: 5a pop %edx <== NOT EXECUTED
10c3db: 59 pop %ecx <== NOT EXECUTED
10c3dc: 6a 00 push $0x0 <== NOT EXECUTED
10c3de: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED
10c3e1: 50 push %eax <== NOT EXECUTED
10c3e2: e8 d5 05 00 00 call 10c9bc <pthread_cond_init> <== NOT EXECUTED
r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd;
10c3e7: 8d 7b 08 lea 0x8(%ebx),%edi <== NOT EXECUTED
10c3ea: 83 c6 08 add $0x8,%esi <== NOT EXECUTED
10c3ed: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED
10c3f2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
10c3f4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c3f7: e9 b0 fd ff ff jmp 10c1ac <rtems_aio_handle+0x14> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
10c3fc: 8b 7e 14 mov 0x14(%esi),%edi <== NOT EXECUTED
10c3ff: e9 23 fe ff ff jmp 10c227 <rtems_aio_handle+0x8f> <== NOT EXECUTED
0010bfb0 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
10bfb0: 55 push %ebp
10bfb1: 89 e5 mov %esp,%ebp
10bfb3: 53 push %ebx
10bfb4: 83 ec 10 sub $0x10,%esp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
10bfb7: 68 88 a1 12 00 push $0x12a188
10bfbc: e8 7f 10 00 00 call 10d040 <pthread_attr_init>
10bfc1: 89 c3 mov %eax,%ebx
if (result != 0)
10bfc3: 83 c4 10 add $0x10,%esp
10bfc6: 85 c0 test %eax,%eax
10bfc8: 74 0a je 10bfd4 <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;
}
10bfca: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10bfcc: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10bfcf: c9 leave <== NOT EXECUTED
10bfd0: c3 ret <== NOT EXECUTED
10bfd1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
result = pthread_attr_init (&aio_request_queue.attr);
if (result != 0)
return result;
result =
10bfd4: 83 ec 08 sub $0x8,%esp
10bfd7: 6a 00 push $0x0
10bfd9: 68 88 a1 12 00 push $0x12a188
10bfde: e8 89 10 00 00 call 10d06c <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
10bfe3: 83 c4 10 add $0x10,%esp
10bfe6: 85 c0 test %eax,%eax
10bfe8: 0f 85 96 00 00 00 jne 10c084 <rtems_aio_init+0xd4> <== NEVER TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
10bfee: 83 ec 08 sub $0x8,%esp
10bff1: 6a 00 push $0x0
10bff3: 68 80 a1 12 00 push $0x12a180
10bff8: e8 57 0d 00 00 call 10cd54 <pthread_mutex_init>
if (result != 0)
10bffd: 83 c4 10 add $0x10,%esp
10c000: 85 c0 test %eax,%eax
10c002: 0f 85 b8 00 00 00 jne 10c0c0 <rtems_aio_init+0x110> <== NEVER TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
10c008: 83 ec 08 sub $0x8,%esp
10c00b: 6a 00 push $0x0
10c00d: 68 84 a1 12 00 push $0x12a184
10c012: e8 a5 09 00 00 call 10c9bc <pthread_cond_init>
10c017: 89 c3 mov %eax,%ebx
if (result != 0) {
10c019: 83 c4 10 add $0x10,%esp
10c01c: 85 c0 test %eax,%eax
10c01e: 75 7c jne 10c09c <rtems_aio_init+0xec> <== NEVER TAKEN
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10c020: c7 05 c8 a1 12 00 cc movl $0x12a1cc,0x12a1c8
10c027: a1 12 00
head->previous = NULL;
10c02a: c7 05 cc a1 12 00 00 movl $0x0,0x12a1cc
10c031: 00 00 00
tail->previous = head;
10c034: c7 05 d0 a1 12 00 c8 movl $0x12a1c8,0x12a1d0
10c03b: a1 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10c03e: c7 05 d4 a1 12 00 d8 movl $0x12a1d8,0x12a1d4
10c045: a1 12 00
head->previous = NULL;
10c048: c7 05 d8 a1 12 00 00 movl $0x0,0x12a1d8
10c04f: 00 00 00
tail->previous = head;
10c052: c7 05 dc a1 12 00 d4 movl $0x12a1d4,0x12a1dc
10c059: a1 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;
10c05c: c7 05 e4 a1 12 00 00 movl $0x0,0x12a1e4
10c063: 00 00 00
aio_request_queue.idle_threads = 0;
10c066: c7 05 e8 a1 12 00 00 movl $0x0,0x12a1e8
10c06d: 00 00 00
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
10c070: c7 05 e0 a1 12 00 0b movl $0xb00b,0x12a1e0
10c077: b0 00 00
return result;
}
10c07a: 89 d8 mov %ebx,%eax
10c07c: 8b 5d fc mov -0x4(%ebp),%ebx
10c07f: c9 leave
10c080: c3 ret
10c081: 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);
10c084: 83 ec 0c sub $0xc,%esp
10c087: 68 88 a1 12 00 push $0x12a188 <== NOT EXECUTED
10c08c: e8 8b 0f 00 00 call 10d01c <pthread_attr_destroy> <== NOT EXECUTED
10c091: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c094: e9 55 ff ff ff jmp 10bfee <rtems_aio_init+0x3e> <== NOT EXECUTED
10c099: 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);
10c09c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c09f: 68 80 a1 12 00 push $0x12a180 <== NOT EXECUTED
10c0a4: e8 8b 0b 00 00 call 10cc34 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
10c0a9: c7 04 24 88 a1 12 00 movl $0x12a188,(%esp) <== NOT EXECUTED
10c0b0: e8 67 0f 00 00 call 10d01c <pthread_attr_destroy> <== NOT EXECUTED
10c0b5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c0b8: e9 63 ff ff ff jmp 10c020 <rtems_aio_init+0x70> <== NOT EXECUTED
10c0bd: 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);
10c0c0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c0c3: 68 88 a1 12 00 push $0x12a188 <== NOT EXECUTED
10c0c8: e8 4f 0f 00 00 call 10d01c <pthread_attr_destroy> <== NOT EXECUTED
10c0cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c0d0: e9 33 ff ff ff jmp 10c008 <rtems_aio_init+0x58> <== NOT EXECUTED
0010c404 <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
10c404: 55 push %ebp
10c405: 89 e5 mov %esp,%ebp
10c407: 56 push %esi
10c408: 53 push %ebx
10c409: 8b 55 08 mov 0x8(%ebp),%edx
10c40c: 8b 75 0c mov 0xc(%ebp),%esi
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c40f: 8b 02 mov (%edx),%eax
10c411: 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)) {
10c414: 39 c8 cmp %ecx,%eax
10c416: 74 27 je 10c43f <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 &&
10c418: 8b 56 14 mov 0x14(%esi),%edx
10c41b: 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;
10c41e: 8b 50 14 mov 0x14(%eax),%edx
while (req->aiocbp->aio_reqprio > prio &&
10c421: 39 5a 14 cmp %ebx,0x14(%edx)
10c424: 7c 06 jl 10c42c <rtems_aio_insert_prio+0x28><== NEVER TAKEN
10c426: eb 0e jmp 10c436 <rtems_aio_insert_prio+0x32>
10c428: 39 c8 cmp %ecx,%eax <== NOT EXECUTED
10c42a: 74 1c je 10c448 <rtems_aio_insert_prio+0x44><== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c42c: 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;
10c42e: 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 &&
10c431: 39 5a 14 cmp %ebx,0x14(%edx) <== NOT EXECUTED
10c434: 7c f2 jl 10c428 <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 );
10c436: 89 75 0c mov %esi,0xc(%ebp)
10c439: 8b 40 04 mov 0x4(%eax),%eax
10c43c: 89 45 08 mov %eax,0x8(%ebp)
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
10c43f: 5b pop %ebx
10c440: 5e pop %esi
10c441: c9 leave
10c442: e9 69 24 00 00 jmp 10e8b0 <_Chain_Insert>
10c447: 90 nop
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c448: 89 c8 mov %ecx,%eax <== NOT EXECUTED
10c44a: eb ea jmp 10c436 <rtems_aio_insert_prio+0x32><== NOT EXECUTED
0010c44c <rtems_aio_remove_fd>:
* Output parameters:
* NONE
*/
void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain)
{
10c44c: 55 push %ebp
10c44d: 89 e5 mov %esp,%ebp
10c44f: 57 push %edi
10c450: 56 push %esi
10c451: 53 push %ebx
10c452: 83 ec 0c sub $0xc,%esp
10c455: 8b 7d 08 mov 0x8(%ebp),%edi
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c458: 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));
10c45b: 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))
10c45e: 39 fb cmp %edi,%ebx
10c460: 75 04 jne 10c466 <rtems_aio_remove_fd+0x1a><== ALWAYS TAKEN
10c462: eb 2d jmp 10c491 <rtems_aio_remove_fd+0x45><== NOT EXECUTED
{
rtems_chain_extract (node);
rtems_aio_request *req = (rtems_aio_request *) node;
node = rtems_chain_next (node);
10c464: 89 f3 mov %esi,%ebx
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10c466: 83 ec 0c sub $0xc,%esp
10c469: 53 push %ebx
10c46a: e8 05 24 00 00 call 10e874 <_Chain_Extract>
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c46f: 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;
10c471: 8b 43 14 mov 0x14(%ebx),%eax
10c474: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax)
req->aiocbp->return_value = -1;
10c47b: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax)
free (req);
10c482: 89 1c 24 mov %ebx,(%esp)
10c485: e8 aa 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))
10c48a: 83 c4 10 add $0x10,%esp
10c48d: 39 fe cmp %edi,%esi
10c48f: 75 d3 jne 10c464 <rtems_aio_remove_fd+0x18>
node = rtems_chain_next (node);
req->aiocbp->error_code = ECANCELED;
req->aiocbp->return_value = -1;
free (req);
}
}
10c491: 8d 65 f4 lea -0xc(%ebp),%esp
10c494: 5b pop %ebx
10c495: 5e pop %esi
10c496: 5f pop %edi
10c497: c9 leave
10c498: c3 ret
0010c49c <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)
{
10c49c: 55 push %ebp
10c49d: 89 e5 mov %esp,%ebp
10c49f: 53 push %ebx
10c4a0: 83 ec 04 sub $0x4,%esp
10c4a3: 8b 55 08 mov 0x8(%ebp),%edx
10c4a6: 8b 4d 0c mov 0xc(%ebp),%ecx
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c4a9: 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 );
10c4ab: 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))
10c4ae: 39 d0 cmp %edx,%eax
10c4b0: 74 4e je 10c500 <rtems_aio_remove_req+0x64><== NEVER TAKEN
return AIO_ALLDONE;
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
10c4b2: 89 c3 mov %eax,%ebx
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
10c4b4: 39 48 14 cmp %ecx,0x14(%eax)
10c4b7: 75 0a jne 10c4c3 <rtems_aio_remove_req+0x27><== NEVER TAKEN
10c4b9: eb 19 jmp 10c4d4 <rtems_aio_remove_req+0x38>
10c4bb: 90 nop
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
10c4bc: 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) {
10c4be: 39 48 14 cmp %ecx,0x14(%eax) <== NOT EXECUTED
10c4c1: 74 11 je 10c4d4 <rtems_aio_remove_req+0x38><== NOT EXECUTED
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c4c3: 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) {
10c4c5: 39 d0 cmp %edx,%eax <== NOT EXECUTED
10c4c7: 75 f3 jne 10c4bc <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;
10c4c9: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
10c4ce: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10c4d1: c9 leave <== NOT EXECUTED
10c4d2: c3 ret <== NOT EXECUTED
10c4d3: 90 nop <== NOT EXECUTED
10c4d4: 83 ec 0c sub $0xc,%esp
10c4d7: 50 push %eax
10c4d8: e8 97 23 00 00 call 10e874 <_Chain_Extract>
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
10c4dd: 8b 43 14 mov 0x14(%ebx),%eax
10c4e0: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax)
current->aiocbp->return_value = -1;
10c4e7: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax)
free (current);
10c4ee: 89 1c 24 mov %ebx,(%esp)
10c4f1: e8 3e c6 ff ff call 108b34 <free>
}
return AIO_CANCELED;
10c4f6: 83 c4 10 add $0x10,%esp
10c4f9: 31 c0 xor %eax,%eax
}
10c4fb: 8b 5d fc mov -0x4(%ebp),%ebx
10c4fe: c9 leave
10c4ff: c3 ret
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
return AIO_ALLDONE;
10c500: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
10c505: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10c508: c9 leave <== NOT EXECUTED
10c509: c3 ret <== NOT EXECUTED
0010c0d8 <rtems_aio_search_fd>:
*
*/
rtems_aio_request_chain *
rtems_aio_search_fd (rtems_chain_control *chain, int fildes, int create)
{
10c0d8: 55 push %ebp
10c0d9: 89 e5 mov %esp,%ebp
10c0db: 57 push %edi
10c0dc: 56 push %esi
10c0dd: 53 push %ebx
10c0de: 83 ec 1c sub $0x1c,%esp
10c0e1: 8b 75 08 mov 0x8(%ebp),%esi
10c0e4: 8b 5d 0c mov 0xc(%ebp),%ebx
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c0e7: 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)) {
10c0e9: 8b 50 14 mov 0x14(%eax),%edx
10c0ec: 39 d3 cmp %edx,%ebx
10c0ee: 7e 28 jle 10c118 <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));
10c0f0: 8d 4e 04 lea 0x4(%esi),%ecx
10c0f3: eb 0c jmp 10c101 <rtems_aio_search_fd+0x29>
10c0f5: 8d 76 00 lea 0x0(%esi),%esi
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c0f8: 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)) {
10c0fa: 8b 50 14 mov 0x14(%eax),%edx
10c0fd: 39 da cmp %ebx,%edx
10c0ff: 7d 17 jge 10c118 <rtems_aio_search_fd+0x40>
10c101: 39 c8 cmp %ecx,%eax
10c103: 75 f3 jne 10c0f8 <rtems_aio_search_fd+0x20>
10c105: 89 c7 mov %eax,%edi
}
if (r_chain->fildes == fildes)
r_chain->new_fd = 0;
else {
if (create == 0)
10c107: 8b 45 10 mov 0x10(%ebp),%eax
10c10a: 85 c0 test %eax,%eax
10c10c: 75 1f jne 10c12d <rtems_aio_search_fd+0x55>
r_chain = NULL;
10c10e: 31 c0 xor %eax,%eax
r_chain->new_fd = 1;
r_chain->fildes = fildes;
}
}
return r_chain;
}
10c110: 8d 65 f4 lea -0xc(%ebp),%esp
10c113: 5b pop %ebx
10c114: 5e pop %esi
10c115: 5f pop %edi
10c116: c9 leave
10c117: c3 ret
}
AIO_printf ("Thread finished\n");
return NULL;
}
10c118: 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)
10c11a: 39 d3 cmp %edx,%ebx
10c11c: 75 e9 jne 10c107 <rtems_aio_search_fd+0x2f>
r_chain->new_fd = 0;
10c11e: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
r_chain->new_fd = 1;
r_chain->fildes = fildes;
}
}
return r_chain;
}
10c125: 8d 65 f4 lea -0xc(%ebp),%esp
10c128: 5b pop %ebx
10c129: 5e pop %esi
10c12a: 5f pop %edi
10c12b: c9 leave
10c12c: c3 ret
r_chain->new_fd = 0;
else {
if (create == 0)
r_chain = NULL;
else {
r_chain = malloc (sizeof (rtems_aio_request_chain));
10c12d: 83 ec 0c sub $0xc,%esp
10c130: 6a 24 push $0x24
10c132: e8 11 cf ff ff call 109048 <malloc>
10c137: 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 );
10c139: 8d 4a 0c lea 0xc(%edx),%ecx
10c13c: 89 4a 08 mov %ecx,0x8(%edx)
head->next = tail;
head->previous = NULL;
10c13f: 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 );
10c146: 8d 4a 08 lea 0x8(%edx),%ecx
10c149: 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 );
10c14c: 8d 4e 04 lea 0x4(%esi),%ecx
rtems_chain_initialize_empty (&r_chain->perfd);
if (rtems_chain_is_empty (chain))
10c14f: 83 c4 10 add $0x10,%esp
10c152: 39 0e cmp %ecx,(%esi)
10c154: 74 27 je 10c17d <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 );
10c156: 83 ec 08 sub $0x8,%esp
10c159: 52 push %edx
10c15a: ff 77 04 pushl 0x4(%edi)
10c15d: 89 45 e4 mov %eax,-0x1c(%ebp)
10c160: 89 55 e0 mov %edx,-0x20(%ebp)
10c163: e8 48 27 00 00 call 10e8b0 <_Chain_Insert>
10c168: 83 c4 10 add $0x10,%esp
10c16b: 8b 55 e0 mov -0x20(%ebp),%edx
10c16e: 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;
10c171: c7 42 18 01 00 00 00 movl $0x1,0x18(%edx)
r_chain->fildes = fildes;
10c178: 89 5a 14 mov %ebx,0x14(%edx)
10c17b: eb a8 jmp 10c125 <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);
10c17d: 83 ec 08 sub $0x8,%esp
10c180: 52 push %edx
10c181: 56 push %esi
10c182: 89 45 e4 mov %eax,-0x1c(%ebp)
10c185: 89 55 e0 mov %edx,-0x20(%ebp)
10c188: e8 23 27 00 00 call 10e8b0 <_Chain_Insert>
10c18d: 83 c4 10 add $0x10,%esp
10c190: 8b 45 e4 mov -0x1c(%ebp),%eax
10c193: 8b 55 e0 mov -0x20(%ebp),%edx
10c196: eb d9 jmp 10c171 <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
0010fb90 <rtems_assoc_local_by_remote>:
uint32_t rtems_assoc_local_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
10fb90: 55 push %ebp
10fb91: 89 e5 mov %esp,%ebp
10fb93: 83 ec 10 sub $0x10,%esp
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
10fb96: ff 75 0c pushl 0xc(%ebp)
10fb99: ff 75 08 pushl 0x8(%ebp)
10fb9c: e8 13 00 00 00 call 10fbb4 <rtems_assoc_ptr_by_remote>
if (nap)
10fba1: 83 c4 10 add $0x10,%esp
10fba4: 85 c0 test %eax,%eax
10fba6: 74 08 je 10fbb0 <rtems_assoc_local_by_remote+0x20>
return nap->local_value;
10fba8: 8b 40 04 mov 0x4(%eax),%eax
return 0;
}
10fbab: c9 leave
10fbac: c3 ret
10fbad: 8d 76 00 lea 0x0(%esi),%esi
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
if (nap)
return nap->local_value;
return 0;
10fbb0: 31 c0 xor %eax,%eax
}
10fbb2: c9 leave
10fbb3: c3 ret
00112b00 <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
112b00: 55 push %ebp
112b01: 89 e5 mov %esp,%ebp
112b03: 57 push %edi
112b04: 56 push %esi
112b05: 53 push %ebx
112b06: 83 ec 1c sub $0x1c,%esp
112b09: 8b 7d 0c mov 0xc(%ebp),%edi
112b0c: be 20 00 00 00 mov $0x20,%esi
uint32_t b;
uint32_t local_value = 0;
112b11: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
for (b = 1; b; b <<= 1) {
112b18: bb 01 00 00 00 mov $0x1,%ebx
112b1d: eb 06 jmp 112b25 <rtems_assoc_local_by_remote_bitfield+0x25>
112b1f: 90 nop
112b20: d1 e3 shl %ebx
112b22: 4e dec %esi
112b23: 74 1b je 112b40 <rtems_assoc_local_by_remote_bitfield+0x40>
if (b & remote_value)
112b25: 85 fb test %edi,%ebx
112b27: 74 f7 je 112b20 <rtems_assoc_local_by_remote_bitfield+0x20>
local_value |= rtems_assoc_local_by_remote(ap, b);
112b29: 83 ec 08 sub $0x8,%esp
112b2c: 53 push %ebx
112b2d: ff 75 08 pushl 0x8(%ebp)
112b30: e8 5b d0 ff ff call 10fb90 <rtems_assoc_local_by_remote>
112b35: 09 45 e4 or %eax,-0x1c(%ebp)
112b38: 83 c4 10 add $0x10,%esp
)
{
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
112b3b: d1 e3 shl %ebx
112b3d: 4e dec %esi
112b3e: 75 e5 jne 112b25 <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;
}
112b40: 8b 45 e4 mov -0x1c(%ebp),%eax
112b43: 8d 65 f4 lea -0xc(%ebp),%esp
112b46: 5b pop %ebx
112b47: 5e pop %esi
112b48: 5f pop %edi
112b49: c9 leave
112b4a: c3 ret
00114ce4 <rtems_assoc_name_by_local>:
const char *rtems_assoc_name_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
114ce4: 55 push %ebp
114ce5: 89 e5 mov %esp,%ebp
114ce7: 53 push %ebx
114ce8: 83 ec 0c sub $0xc,%esp
114ceb: 8b 5d 0c mov 0xc(%ebp),%ebx
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
114cee: 53 push %ebx
114cef: ff 75 08 pushl 0x8(%ebp)
114cf2: e8 1d 00 00 00 call 114d14 <rtems_assoc_ptr_by_local>
if (nap)
114cf7: 83 c4 10 add $0x10,%esp
114cfa: 85 c0 test %eax,%eax
114cfc: 74 0a je 114d08 <rtems_assoc_name_by_local+0x24>
return nap->name;
114cfe: 8b 00 mov (%eax),%eax
return rtems_assoc_name_bad(local_value);
}
114d00: 8b 5d fc mov -0x4(%ebp),%ebx
114d03: c9 leave
114d04: c3 ret
114d05: 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);
114d08: 89 5d 08 mov %ebx,0x8(%ebp)
}
114d0b: 8b 5d fc mov -0x4(%ebp),%ebx
114d0e: c9 leave
nap = rtems_assoc_ptr_by_local(ap, local_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(local_value);
114d0f: e9 4c 31 00 00 jmp 117e60 <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 c8 7e 00 00 jmp 110880 <rtems_assoc_name_bad>
00114d14 <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
114d14: 55 push %ebp
114d15: 89 e5 mov %esp,%ebp
114d17: 57 push %edi
114d18: 56 push %esi
114d19: 53 push %ebx
114d1a: 8b 45 08 mov 0x8(%ebp),%eax
114d1d: 8b 55 0c mov 0xc(%ebp),%edx
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
114d20: 8b 30 mov (%eax),%esi
114d22: 85 f6 test %esi,%esi
114d24: 74 3e je 114d64 <rtems_assoc_ptr_by_local+0x50>
114d26: bf b8 74 12 00 mov $0x1274b8,%edi
114d2b: b9 0a 00 00 00 mov $0xa,%ecx
114d30: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
114d32: 74 18 je 114d4c <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;
114d34: 31 c9 xor %ecx,%ecx
114d36: eb 09 jmp 114d41 <rtems_assoc_ptr_by_local+0x2d>
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
114d38: 83 c0 0c add $0xc,%eax
114d3b: 8b 18 mov (%eax),%ebx
114d3d: 85 db test %ebx,%ebx
114d3f: 74 1b je 114d5c <rtems_assoc_ptr_by_local+0x48>
if (ap->local_value == local_value)
114d41: 39 50 04 cmp %edx,0x4(%eax)
114d44: 75 f2 jne 114d38 <rtems_assoc_ptr_by_local+0x24>
return ap;
return default_ap;
}
114d46: 5b pop %ebx
114d47: 5e pop %esi
114d48: 5f pop %edi
114d49: c9 leave
114d4a: c3 ret
114d4b: 90 nop
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
114d4c: 8d 58 0c lea 0xc(%eax),%ebx
for ( ; ap->name; ap++)
114d4f: 8b 70 0c mov 0xc(%eax),%esi
114d52: 85 f6 test %esi,%esi
114d54: 74 f0 je 114d46 <rtems_assoc_ptr_by_local+0x32><== NEVER TAKEN
114d56: 89 c1 mov %eax,%ecx
114d58: 89 d8 mov %ebx,%eax
114d5a: eb e5 jmp 114d41 <rtems_assoc_ptr_by_local+0x2d>
114d5c: 89 c8 mov %ecx,%eax
if (ap->local_value == local_value)
return ap;
return default_ap;
}
114d5e: 5b pop %ebx
114d5f: 5e pop %esi
114d60: 5f pop %edi
114d61: c9 leave
114d62: c3 ret
114d63: 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;
114d64: 31 c0 xor %eax,%eax
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
return ap;
return default_ap;
}
114d66: 5b pop %ebx
114d67: 5e pop %esi
114d68: 5f pop %edi
114d69: c9 leave
114d6a: 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 5d 03 12 00 mov $0x12035d,%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 2f c1 00 00 call 114b7c <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
0010fbb4 <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
10fbb4: 55 push %ebp
10fbb5: 89 e5 mov %esp,%ebp
10fbb7: 57 push %edi
10fbb8: 56 push %esi
10fbb9: 53 push %ebx
10fbba: 8b 45 08 mov 0x8(%ebp),%eax
10fbbd: 8b 55 0c mov 0xc(%ebp),%edx
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
10fbc0: 8b 30 mov (%eax),%esi
10fbc2: 85 f6 test %esi,%esi
10fbc4: 74 3e je 10fc04 <rtems_assoc_ptr_by_remote+0x50>
10fbc6: bf 18 11 12 00 mov $0x121118,%edi
10fbcb: b9 0a 00 00 00 mov $0xa,%ecx
10fbd0: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10fbd2: 74 18 je 10fbec <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;
10fbd4: 31 c9 xor %ecx,%ecx
10fbd6: eb 09 jmp 10fbe1 <rtems_assoc_ptr_by_remote+0x2d>
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
10fbd8: 83 c0 0c add $0xc,%eax
10fbdb: 8b 18 mov (%eax),%ebx
10fbdd: 85 db test %ebx,%ebx
10fbdf: 74 1b je 10fbfc <rtems_assoc_ptr_by_remote+0x48>
if (ap->remote_value == remote_value)
10fbe1: 39 50 08 cmp %edx,0x8(%eax)
10fbe4: 75 f2 jne 10fbd8 <rtems_assoc_ptr_by_remote+0x24>
return ap;
return default_ap;
}
10fbe6: 5b pop %ebx
10fbe7: 5e pop %esi
10fbe8: 5f pop %edi
10fbe9: c9 leave
10fbea: c3 ret
10fbeb: 90 nop
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
10fbec: 8d 58 0c lea 0xc(%eax),%ebx
for ( ; ap->name; ap++)
10fbef: 8b 70 0c mov 0xc(%eax),%esi
10fbf2: 85 f6 test %esi,%esi
10fbf4: 74 f0 je 10fbe6 <rtems_assoc_ptr_by_remote+0x32><== NEVER TAKEN
10fbf6: 89 c1 mov %eax,%ecx
10fbf8: 89 d8 mov %ebx,%eax
10fbfa: eb e5 jmp 10fbe1 <rtems_assoc_ptr_by_remote+0x2d>
10fbfc: 89 c8 mov %ecx,%eax
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
10fbfe: 5b pop %ebx
10fbff: 5e pop %esi
10fc00: 5f pop %edi
10fc01: c9 leave
10fc02: c3 ret
10fc03: 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;
10fc04: 31 c0 xor %eax,%eax
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
10fc06: 5b pop %ebx
10fc07: 5e pop %esi
10fc08: 5f pop %edi
10fc09: c9 leave
10fc0a: 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
00113684 <rtems_barrier_create>:
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
113684: 55 push %ebp
113685: 89 e5 mov %esp,%ebp
113687: 57 push %edi
113688: 56 push %esi
113689: 53 push %ebx
11368a: 83 ec 2c sub $0x2c,%esp
11368d: 8b 5d 08 mov 0x8(%ebp),%ebx
113690: 8b 7d 0c mov 0xc(%ebp),%edi
113693: 8b 45 10 mov 0x10(%ebp),%eax
113696: 8b 75 14 mov 0x14(%ebp),%esi
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
113699: 85 db test %ebx,%ebx
11369b: 0f 84 87 00 00 00 je 113728 <rtems_barrier_create+0xa4>
return RTEMS_INVALID_NAME;
if ( !id )
1136a1: 85 f6 test %esi,%esi
1136a3: 0f 84 bf 00 00 00 je 113768 <rtems_barrier_create+0xe4><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
1136a9: f7 c7 10 00 00 00 test $0x10,%edi
1136af: 0f 84 83 00 00 00 je 113738 <rtems_barrier_create+0xb4>
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
1136b5: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
if ( maximum_waiters == 0 )
1136bc: 85 c0 test %eax,%eax
1136be: 0f 84 80 00 00 00 je 113744 <rtems_barrier_create+0xc0><== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
the_attributes.maximum_count = maximum_waiters;
1136c4: 89 45 e4 mov %eax,-0x1c(%ebp)
1136c7: a1 70 9f 12 00 mov 0x129f70,%eax
1136cc: 40 inc %eax
1136cd: a3 70 9f 12 00 mov %eax,0x129f70
* 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 );
1136d2: 83 ec 0c sub $0xc,%esp
1136d5: 68 a0 a9 12 00 push $0x12a9a0
1136da: e8 85 b0 ff ff call 10e764 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
1136df: 83 c4 10 add $0x10,%esp
1136e2: 85 c0 test %eax,%eax
1136e4: 74 6e je 113754 <rtems_barrier_create+0xd0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
1136e6: 89 78 10 mov %edi,0x10(%eax)
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
1136e9: 83 ec 08 sub $0x8,%esp
1136ec: 8d 55 e0 lea -0x20(%ebp),%edx
1136ef: 52 push %edx
1136f0: 8d 50 14 lea 0x14(%eax),%edx
1136f3: 52 push %edx
1136f4: 89 45 d4 mov %eax,-0x2c(%ebp)
1136f7: e8 c0 07 00 00 call 113ebc <_CORE_barrier_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
1136fc: 8b 45 d4 mov -0x2c(%ebp),%eax
1136ff: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
113702: 0f b7 fa movzwl %dx,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
113705: 8b 0d bc a9 12 00 mov 0x12a9bc,%ecx
11370b: 89 04 b9 mov %eax,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
11370e: 89 58 0c mov %ebx,0xc(%eax)
&_Barrier_Information,
&the_barrier->Object,
(Objects_Name) name
);
*id = the_barrier->Object.id;
113711: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
113713: e8 e8 bf ff ff call 10f700 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
113718: 83 c4 10 add $0x10,%esp
11371b: 31 c0 xor %eax,%eax
}
11371d: 8d 65 f4 lea -0xc(%ebp),%esp
113720: 5b pop %ebx
113721: 5e pop %esi
113722: 5f pop %edi
113723: c9 leave
113724: c3 ret
113725: 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;
113728: b8 03 00 00 00 mov $0x3,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
11372d: 8d 65 f4 lea -0xc(%ebp),%esp
113730: 5b pop %ebx
113731: 5e pop %esi
113732: 5f pop %edi
113733: c9 leave
113734: c3 ret
113735: 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;
113738: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp)
11373f: eb 83 jmp 1136c4 <rtems_barrier_create+0x40>
113741: 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;
113744: b8 0a 00 00 00 mov $0xa,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
113749: 8d 65 f4 lea -0xc(%ebp),%esp
11374c: 5b pop %ebx
11374d: 5e pop %esi
11374e: 5f pop %edi
11374f: c9 leave
113750: c3 ret
113751: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
113754: e8 a7 bf ff ff call 10f700 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
113759: b8 05 00 00 00 mov $0x5,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
11375e: 8d 65 f4 lea -0xc(%ebp),%esp
113761: 5b pop %ebx
113762: 5e pop %esi
113763: 5f pop %edi
113764: c9 leave
113765: c3 ret
113766: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
113768: b8 09 00 00 00 mov $0x9,%eax
11376d: eb ae jmp 11371d <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 f8 7c 12 00 mov 0x127cf8,%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 58 ce 00 00 call 114c4c <strstr>
107df4: 83 c4 10 add $0x10,%esp
/* printf( "raw: %p (%s)\n", p, p ); */
return p;
}
107df7: c9 leave
107df8: c3 ret
0010c14c <rtems_chain_append_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10c14c: 55 push %ebp
10c14d: 89 e5 mov %esp,%ebp
10c14f: 56 push %esi
10c150: 53 push %ebx
10c151: 8b 5d 10 mov 0x10(%ebp),%ebx
10c154: 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 );
10c157: 83 ec 08 sub $0x8,%esp
10c15a: ff 75 0c pushl 0xc(%ebp)
10c15d: ff 75 08 pushl 0x8(%ebp)
10c160: e8 e3 04 00 00 call 10c648 <_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 ) {
10c165: 83 c4 10 add $0x10,%esp
10c168: 84 c0 test %al,%al
10c16a: 75 0c jne 10c178 <rtems_chain_append_with_notification+0x2c><== ALWAYS TAKEN
sc = rtems_event_send( task, events );
}
return sc;
}
10c16c: 31 c0 xor %eax,%eax
10c16e: 8d 65 f8 lea -0x8(%ebp),%esp
10c171: 5b pop %ebx
10c172: 5e pop %esi <== NOT EXECUTED
10c173: c9 leave <== NOT EXECUTED
10c174: c3 ret <== NOT EXECUTED
10c175: 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 );
10c178: 89 75 0c mov %esi,0xc(%ebp)
10c17b: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10c17e: 8d 65 f8 lea -0x8(%ebp),%esp
10c181: 5b pop %ebx
10c182: 5e pop %esi
10c183: 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 );
10c184: e9 a3 f5 ff ff jmp 10b72c <rtems_event_send>
0010c18c <rtems_chain_get_with_notification>:
rtems_chain_control *chain,
rtems_id task,
rtems_event_set events,
rtems_chain_node **node
)
{
10c18c: 55 push %ebp
10c18d: 89 e5 mov %esp,%ebp
10c18f: 56 push %esi
10c190: 53 push %ebx
10c191: 8b 5d 0c mov 0xc(%ebp),%ebx
10c194: 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 );
10c197: 83 ec 08 sub $0x8,%esp
10c19a: ff 75 14 pushl 0x14(%ebp)
10c19d: ff 75 08 pushl 0x8(%ebp)
10c1a0: e8 0b 05 00 00 call 10c6b0 <_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 ) {
10c1a5: 83 c4 10 add $0x10,%esp
10c1a8: 84 c0 test %al,%al
10c1aa: 75 0c jne 10c1b8 <rtems_chain_get_with_notification+0x2c>
sc = rtems_event_send( task, events );
}
return sc;
}
10c1ac: 31 c0 xor %eax,%eax
10c1ae: 8d 65 f8 lea -0x8(%ebp),%esp
10c1b1: 5b pop %ebx
10c1b2: 5e pop %esi
10c1b3: c9 leave
10c1b4: c3 ret
10c1b5: 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 );
10c1b8: 89 75 0c mov %esi,0xc(%ebp)
10c1bb: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10c1be: 8d 65 f8 lea -0x8(%ebp),%esp
10c1c1: 5b pop %ebx
10c1c2: 5e pop %esi
10c1c3: 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 );
10c1c4: e9 63 f5 ff ff jmp 10b72c <rtems_event_send>
0010c1cc <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
10c1cc: 55 push %ebp
10c1cd: 89 e5 mov %esp,%ebp
10c1cf: 57 push %edi
10c1d0: 56 push %esi
10c1d1: 53 push %ebx
10c1d2: 83 ec 1c sub $0x1c,%esp
10c1d5: 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(
10c1d8: 8d 7d e4 lea -0x1c(%ebp),%edi
10c1db: 90 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
10c1dc: 83 ec 0c sub $0xc,%esp
10c1df: 56 push %esi
10c1e0: e8 07 05 00 00 call 10c6ec <_Chain_Get>
10c1e5: 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
10c1e7: 83 c4 10 add $0x10,%esp
10c1ea: 85 c0 test %eax,%eax
10c1ec: 75 22 jne 10c210 <rtems_chain_get_with_wait+0x44>
) {
rtems_event_set out;
sc = rtems_event_receive(
10c1ee: 57 push %edi
10c1ef: ff 75 10 pushl 0x10(%ebp)
10c1f2: 6a 00 push $0x0
10c1f4: ff 75 0c pushl 0xc(%ebp)
10c1f7: e8 a8 f3 ff ff call 10b5a4 <rtems_event_receive>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
10c1fc: 83 c4 10 add $0x10,%esp
10c1ff: 85 c0 test %eax,%eax
10c201: 74 d9 je 10c1dc <rtems_chain_get_with_wait+0x10><== NEVER TAKEN
timeout,
&out
);
}
*node_ptr = node;
10c203: 8b 55 14 mov 0x14(%ebp),%edx
10c206: 89 1a mov %ebx,(%edx)
return sc;
}
10c208: 8d 65 f4 lea -0xc(%ebp),%esp
10c20b: 5b pop %ebx
10c20c: 5e pop %esi
10c20d: 5f pop %edi
10c20e: c9 leave
10c20f: c3 ret
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
10c210: 31 c0 xor %eax,%eax
timeout,
&out
);
}
*node_ptr = node;
10c212: 8b 55 14 mov 0x14(%ebp),%edx
10c215: 89 1a mov %ebx,(%edx)
return sc;
}
10c217: 8d 65 f4 lea -0xc(%ebp),%esp
10c21a: 5b pop %ebx
10c21b: 5e pop %esi
10c21c: 5f pop %edi
10c21d: c9 leave
10c21e: c3 ret
0010c220 <rtems_chain_prepend_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10c220: 55 push %ebp
10c221: 89 e5 mov %esp,%ebp
10c223: 56 push %esi
10c224: 53 push %ebx
10c225: 8b 5d 10 mov 0x10(%ebp),%ebx
10c228: 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 );
10c22b: 83 ec 08 sub $0x8,%esp
10c22e: ff 75 0c pushl 0xc(%ebp)
10c231: ff 75 08 pushl 0x8(%ebp)
10c234: e8 f7 04 00 00 call 10c730 <_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) {
10c239: 83 c4 10 add $0x10,%esp
10c23c: 84 c0 test %al,%al
10c23e: 75 0c jne 10c24c <rtems_chain_prepend_with_notification+0x2c><== ALWAYS TAKEN
sc = rtems_event_send( task, events );
}
return sc;
}
10c240: 31 c0 xor %eax,%eax
10c242: 8d 65 f8 lea -0x8(%ebp),%esp
10c245: 5b pop %ebx
10c246: 5e pop %esi <== NOT EXECUTED
10c247: c9 leave <== NOT EXECUTED
10c248: c3 ret <== NOT EXECUTED
10c249: 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 );
10c24c: 89 75 0c mov %esi,0xc(%ebp)
10c24f: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10c252: 8d 65 f8 lea -0x8(%ebp),%esp
10c255: 5b pop %ebx
10c256: 5e pop %esi
10c257: 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 );
10c258: e9 cf 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 24 22 14 00 00 cmpb $0x0,0x142224
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 21 44 00 00 call 11a034 <_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 7a 16 00 00 call 10c864 <_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 2c 62 12 00 imul 0x12622c,%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 70 23 13 00 mov 0x132370,%eax
10c176: 40 inc %eax
10c177: a3 70 23 13 00 mov %eax,0x132370
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 59 19 00 00 call 10dae0 <_TOD_Set>
_Thread_Enable_dispatch();
10c187: e8 e8 2e 00 00 call 10f074 <_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 3d 15 00 00 call 10c518 <_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 7c 76 12 00 push $0x12767c
10afe3: e8 bc 38 00 00 call 10e8a4 <_Watchdog_Tickle>
_Watchdog_Tickle_ticks();
_Thread_Tickle_timeslice();
10afe8: e8 77 33 00 00 call 10e364 <_Thread_Tickle_timeslice>
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void )
{
return ( _Thread_Dispatch_necessary );
10afed: a0 64 7b 12 00 mov 0x127b64,%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 70 75 12 00 mov 0x127570,%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 6f 27 00 00 call 10d77c <_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 68 24 13 00 mov 0x132468,%eax
10841c: 8b 15 6c 24 13 00 mov 0x13246c,%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 24 56 00 00 call 10da58 <_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 00 2a 13 00 push $0x132a00
108444: e8 93 78 00 00 call 10fcdc <_Timespec_Subtract>
}
}
}
#endif
(*print)(
108449: 5b pop %ebx
10844a: 5e pop %esi
10844b: 68 50 32 12 00 push $0x123250
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 48 23 13 00 mov 0x132348(,%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 7b 77 00 00 call 10fc18 <_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 c3 34 12 00 push $0x1234c3
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 b0 34 12 00 push $0x1234b0
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 98 29 13 00 mov 0x132998,%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 a0 77 00 00 call 10fcdc <_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 8e 76 00 00 call 10fbdc <_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 c4 33 12 00 push $0x1233c4
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
00113288 <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
113288: 55 push %ebp
113289: 89 e5 mov %esp,%ebp
11328b: 53 push %ebx
11328c: 83 ec 04 sub $0x4,%esp
11328f: 8b 45 08 mov 0x8(%ebp),%eax
if (sc == RTEMS_SUCCESSFUL) {
113292: 85 c0 test %eax,%eax
113294: 75 06 jne 11329c <rtems_deviceio_errno+0x14>
return 0;
113296: 31 c0 xor %eax,%eax
errno = eno;
return -1;
}
}
113298: 5a pop %edx
113299: 5b pop %ebx
11329a: c9 leave
11329b: c3 ret
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
11329c: 83 f8 1c cmp $0x1c,%eax
11329f: 77 17 ja 1132b8 <rtems_deviceio_errno+0x30><== NEVER TAKEN
eno = status_code_to_errno [sc];
1132a1: 8b 1c 85 c0 13 12 00 mov 0x1213c0(,%eax,4),%ebx
}
errno = eno;
1132a8: e8 67 00 00 00 call 113314 <__errno>
1132ad: 89 18 mov %ebx,(%eax)
return -1;
1132af: b8 ff ff ff ff mov $0xffffffff,%eax
1132b4: eb e2 jmp 113298 <rtems_deviceio_errno+0x10>
1132b6: 66 90 xchg %ax,%ax
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
1132b8: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED
1132bd: eb e9 jmp 1132a8 <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 69 27 00 00 call 10d918 <_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 1d 27 00 00 call 10d8f4 <_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
0010d00c <rtems_extension_delete>:
#include <rtems/extension.h>
rtems_status_code rtems_extension_delete(
rtems_id id
)
{
10d00c: 55 push %ebp
10d00d: 89 e5 mov %esp,%ebp
10d00f: 53 push %ebx
10d010: 83 ec 18 sub $0x18,%esp
Extension_Control *the_extension;
Objects_Locations location;
the_extension = _Extension_Get( id, &location );
10d013: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Extension_Control *)
_Objects_Get( &_Extension_Information, id, location );
10d016: 50 push %eax
10d017: ff 75 08 pushl 0x8(%ebp)
10d01a: 68 00 26 13 00 push $0x132600
10d01f: e8 24 12 00 00 call 10e248 <_Objects_Get>
10d024: 89 c3 mov %eax,%ebx
switch ( location ) {
10d026: 83 c4 10 add $0x10,%esp
10d029: 8b 55 f4 mov -0xc(%ebp),%edx
10d02c: 85 d2 test %edx,%edx
10d02e: 75 38 jne 10d068 <rtems_extension_delete+0x5c>
case OBJECTS_LOCAL:
_User_extensions_Remove_set( &the_extension->Extension );
10d030: 83 ec 0c sub $0xc,%esp
10d033: 8d 40 10 lea 0x10(%eax),%eax
10d036: 50 push %eax
10d037: e8 a4 29 00 00 call 10f9e0 <_User_extensions_Remove_set>
_Objects_Close( &_Extension_Information, &the_extension->Object );
10d03c: 59 pop %ecx
10d03d: 58 pop %eax
10d03e: 53 push %ebx
10d03f: 68 00 26 13 00 push $0x132600
10d044: e8 c3 0d 00 00 call 10de0c <_Objects_Close>
RTEMS_INLINE_ROUTINE void _Extension_Free (
Extension_Control *the_extension
)
{
_Objects_Free( &_Extension_Information, &the_extension->Object );
10d049: 58 pop %eax
10d04a: 5a pop %edx
10d04b: 53 push %ebx
10d04c: 68 00 26 13 00 push $0x132600
10d051: e8 b2 10 00 00 call 10e108 <_Objects_Free>
_Extension_Free( the_extension );
_Thread_Enable_dispatch();
10d056: e8 a1 1c 00 00 call 10ecfc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10d05b: 83 c4 10 add $0x10,%esp
10d05e: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10d060: 8b 5d fc mov -0x4(%ebp),%ebx
10d063: c9 leave
10d064: c3 ret
10d065: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10d068: b8 04 00 00 00 mov $0x4,%eax
}
10d06d: 8b 5d fc mov -0x4(%ebp),%ebx
10d070: c9 leave
10d071: 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
0011007c <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
11007c: 55 push %ebp
11007d: 89 e5 mov %esp,%ebp
11007f: 83 ec 18 sub $0x18,%esp
110082: 8b 45 08 mov 0x8(%ebp),%eax
find_arg fa = {
110085: 89 45 f0 mov %eax,-0x10(%ebp)
110088: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
11008f: 85 c0 test %eax,%eax
110091: 74 19 je 1100ac <rtems_filesystem_get_mount_handler+0x30><== NEVER TAKEN
rtems_filesystem_iterate( find_handler, &fa );
110093: 83 ec 08 sub $0x8,%esp
110096: 8d 45 f0 lea -0x10(%ebp),%eax
110099: 50 push %eax
11009a: 68 9c ff 10 00 push $0x10ff9c
11009f: e8 34 ff ff ff call 10ffd8 <rtems_filesystem_iterate>
1100a4: 8b 45 f4 mov -0xc(%ebp),%eax
1100a7: 83 c4 10 add $0x10,%esp
}
return fa.mount_h;
}
1100aa: c9 leave
1100ab: c3 ret
find_arg fa = {
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
1100ac: 31 c0 xor %eax,%eax
rtems_filesystem_iterate( find_handler, &fa );
}
return fa.mount_h;
}
1100ae: c9 leave <== NOT EXECUTED
1100af: c3 ret <== NOT EXECUTED
00110238 <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)
{
110238: 55 push %ebp
110239: 89 e5 mov %esp,%ebp
11023b: 57 push %edi
11023c: 56 push %esi
11023d: 53 push %ebx
11023e: 83 ec 18 sub $0x18,%esp
110241: 8b 5d 0c mov 0xc(%ebp),%ebx
if (rtems_filesystem_is_separator(path[0])) {
110244: 8b 45 08 mov 0x8(%ebp),%eax
110247: 0f be 00 movsbl (%eax),%eax
11024a: 50 push %eax
11024b: e8 c8 8c ff ff call 108f18 <rtems_filesystem_is_separator>
110250: 83 c4 10 add $0x10,%esp
110253: 85 c0 test %eax,%eax
110255: 75 11 jne 110268 <rtems_filesystem_get_sym_start_loc+0x30>
*loc = rtems_filesystem_root;
*index = 1;
}
else {
*index = 0;
110257: c7 03 00 00 00 00 movl $0x0,(%ebx)
}
}
11025d: 8d 65 f4 lea -0xc(%ebp),%esp
110260: 5b pop %ebx
110261: 5e pop %esi
110262: 5f pop %edi
110263: c9 leave
110264: c3 ret
110265: 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;
110268: 8b 35 b0 51 12 00 mov 0x1251b0,%esi
11026e: 83 c6 18 add $0x18,%esi
110271: b9 05 00 00 00 mov $0x5,%ecx
110276: 8b 7d 10 mov 0x10(%ebp),%edi
110279: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*index = 1;
11027b: c7 03 01 00 00 00 movl $0x1,(%ebx)
}
else {
*index = 0;
}
}
110281: 8d 65 f4 lea -0xc(%ebp),%esp
110284: 5b pop %ebx
110285: 5e pop %esi
110286: 5f pop %edi
110287: c9 leave
110288: 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 b0 51 12 00 mov 0x1251b0,%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 f1 11 00 mov 0x11f120,%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 b4 31 12 00 mov 0x1231b4,%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 b0 51 12 00 mov 0x1251b0,%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 0b 12 00 push $0x120b07
107e9f: e8 24 01 00 00 call 107fc8 <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
107ea4: 8b 3d b0 51 12 00 mov 0x1251b0,%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 0b 12 00 push $0x120b07
107ec5: e8 fe 00 00 00 call 107fc8 <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
107eca: 8b 3d b0 51 12 00 mov 0x1251b0,%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 0b 12 00 push $0x120b09
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 f6 3d 00 00 call 10bd00 <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 e9 3d 00 00 call 10bd00 <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 dc 3d 00 00 call 10bd00 <rtems_fatal_error_occurred><== NOT EXECUTED
0010ffd8 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
10ffd8: 55 push %ebp
10ffd9: 89 e5 mov %esp,%ebp
10ffdb: 57 push %edi
10ffdc: 56 push %esi
10ffdd: 53 push %ebx
10ffde: 83 ec 1c sub $0x1c,%esp
10ffe1: 8b 75 08 mov 0x8(%ebp),%esi
10ffe4: 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 ) {
10ffe7: 8b 1d 00 f1 11 00 mov 0x11f100,%ebx
10ffed: 85 db test %ebx,%ebx
10ffef: 74 24 je 110015 <rtems_filesystem_iterate+0x3d><== NEVER TAKEN
10fff1: bb 00 f1 11 00 mov $0x11f100,%ebx
10fff6: eb 04 jmp 10fffc <rtems_filesystem_iterate+0x24>
10fff8: 84 c0 test %al,%al
10fffa: 75 70 jne 11006c <rtems_filesystem_iterate+0x94>
stop = (*routine)( table_entry, routine_arg );
10fffc: 83 ec 08 sub $0x8,%esp
10ffff: 57 push %edi
110000: 53 push %ebx
110001: ff d6 call *%esi
110003: 88 c2 mov %al,%dl
++table_entry;
110005: 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 ) {
110008: 83 c4 10 add $0x10,%esp
11000b: 8b 0b mov (%ebx),%ecx
11000d: 85 c9 test %ecx,%ecx
11000f: 75 e7 jne 10fff8 <rtems_filesystem_iterate+0x20>
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
110011: 84 c0 test %al,%al
110013: 75 57 jne 11006c <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 );
110015: 50 push %eax
110016: 6a 00 push $0x0
110018: 6a 00 push $0x0
11001a: ff 35 08 74 12 00 pushl 0x127408
110020: e8 8b b6 ff ff call 10b6b0 <rtems_semaphore_obtain>
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
110025: 8b 1d d8 51 12 00 mov 0x1251d8,%ebx
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
11002b: 83 c4 10 add $0x10,%esp
11002e: 81 fb dc 51 12 00 cmp $0x1251dc,%ebx
110034: 75 06 jne 11003c <rtems_filesystem_iterate+0x64>
110036: eb 3e jmp 110076 <rtems_filesystem_iterate+0x9e>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
110038: 84 c0 test %al,%al
11003a: 75 19 jne 110055 <rtems_filesystem_iterate+0x7d><== NEVER TAKEN
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
11003c: 83 ec 08 sub $0x8,%esp
11003f: 57 push %edi
110040: 8d 43 08 lea 0x8(%ebx),%eax
110043: 50 push %eax
110044: ff d6 call *%esi
110046: 88 c2 mov %al,%dl
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
110048: 8b 1b mov (%ebx),%ebx
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
11004a: 83 c4 10 add $0x10,%esp
11004d: 81 fb dc 51 12 00 cmp $0x1251dc,%ebx
110053: 75 e3 jne 110038 <rtems_filesystem_iterate+0x60>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
110055: 83 ec 0c sub $0xc,%esp
110058: ff 35 08 74 12 00 pushl 0x127408
11005e: 88 55 e4 mov %dl,-0x1c(%ebp)
110061: e8 46 b7 ff ff call 10b7ac <rtems_semaphore_release>
110066: 83 c4 10 add $0x10,%esp
110069: 8a 55 e4 mov -0x1c(%ebp),%dl
}
rtems_libio_unlock();
}
return stop;
}
11006c: 88 d0 mov %dl,%al
11006e: 8d 65 f4 lea -0xc(%ebp),%esp
110071: 5b pop %ebx
110072: 5e pop %esi
110073: 5f pop %edi
110074: c9 leave
110075: c3 ret
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
110076: 31 d2 xor %edx,%edx
110078: eb db jmp 110055 <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 08 74 12 00 pushl 0x127408
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 84 50 12 00 mov 0x125084,%ebx
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
108528: 83 c4 10 add $0x10,%esp
10852b: 81 fb 88 50 12 00 cmp $0x125088,%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 88 50 12 00 cmp $0x125088,%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 08 74 12 00 pushl 0x127408
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
001100b0 <rtems_filesystem_register>:
int
rtems_filesystem_register(
const char *type,
rtems_filesystem_fsmount_me_t mount_h
)
{
1100b0: 55 push %ebp
1100b1: 89 e5 mov %esp,%ebp
1100b3: 57 push %edi
1100b4: 56 push %esi
1100b5: 53 push %ebx
1100b6: 83 ec 28 sub $0x28,%esp
size_t type_size = strlen(type) + 1;
1100b9: 31 c0 xor %eax,%eax
1100bb: b9 ff ff ff ff mov $0xffffffff,%ecx
1100c0: 8b 7d 08 mov 0x8(%ebp),%edi
1100c3: f2 ae repnz scas %es:(%edi),%al
1100c5: f7 d1 not %ecx
size_t fsn_size = sizeof( filesystem_node ) + type_size;
1100c7: 8d 41 10 lea 0x10(%ecx),%eax
filesystem_node *fsn = malloc( fsn_size );
1100ca: 50 push %eax
1100cb: 89 4d e4 mov %ecx,-0x1c(%ebp)
1100ce: e8 b5 82 ff ff call 108388 <malloc>
1100d3: 89 c3 mov %eax,%ebx
char *type_storage = (char *) fsn + sizeof( *fsn );
if ( fsn == NULL )
1100d5: 83 c4 10 add $0x10,%esp
1100d8: 85 c0 test %eax,%eax
1100da: 8b 4d e4 mov -0x1c(%ebp),%ecx
1100dd: 0f 84 8e 00 00 00 je 110171 <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 );
1100e3: 8d 40 10 lea 0x10(%eax),%eax
if ( fsn == NULL )
rtems_set_errno_and_return_minus_one( ENOMEM );
memcpy(type_storage, type, type_size);
1100e6: 89 c7 mov %eax,%edi
1100e8: 8b 75 08 mov 0x8(%ebp),%esi
1100eb: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
fsn->entry.type = type_storage;
1100ed: 89 43 08 mov %eax,0x8(%ebx)
fsn->entry.mount_h = mount_h;
1100f0: 8b 45 0c mov 0xc(%ebp),%eax
1100f3: 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 );
1100f6: 50 push %eax
1100f7: 6a 00 push $0x0
1100f9: 6a 00 push $0x0
1100fb: ff 35 08 74 12 00 pushl 0x127408
110101: e8 aa b5 ff ff call 10b6b0 <rtems_semaphore_obtain>
rtems_libio_lock();
if ( rtems_filesystem_get_mount_handler( type ) == NULL ) {
110106: 5f pop %edi
110107: ff 75 08 pushl 0x8(%ebp)
11010a: e8 6d ff ff ff call 11007c <rtems_filesystem_get_mount_handler>
11010f: 83 c4 10 add $0x10,%esp
110112: 85 c0 test %eax,%eax
110114: 75 2a jne 110140 <rtems_filesystem_register+0x90>
110116: 83 ec 08 sub $0x8,%esp
110119: 53 push %ebx
11011a: 68 d8 51 12 00 push $0x1251d8
11011f: e8 b8 be ff ff call 10bfdc <_Chain_Append>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
110124: 5e pop %esi
110125: ff 35 08 74 12 00 pushl 0x127408
11012b: e8 7c b6 ff ff call 10b7ac <rtems_semaphore_release>
110130: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_unlock();
return 0;
110133: 31 c0 xor %eax,%eax
}
110135: 8d 65 f4 lea -0xc(%ebp),%esp
110138: 5b pop %ebx
110139: 5e pop %esi
11013a: 5f pop %edi
11013b: c9 leave
11013c: c3 ret
11013d: 8d 76 00 lea 0x0(%esi),%esi
110140: 83 ec 0c sub $0xc,%esp
110143: ff 35 08 74 12 00 pushl 0x127408
110149: e8 5e 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 );
11014e: 89 1c 24 mov %ebx,(%esp)
110151: e8 5e 7f ff ff call 1080b4 <free>
rtems_set_errno_and_return_minus_one( EINVAL );
110156: e8 b9 31 00 00 call 113314 <__errno>
11015b: c7 00 16 00 00 00 movl $0x16,(%eax)
110161: 83 c4 10 add $0x10,%esp
110164: b8 ff ff ff ff mov $0xffffffff,%eax
}
rtems_libio_unlock();
return 0;
}
110169: 8d 65 f4 lea -0xc(%ebp),%esp
11016c: 5b pop %ebx
11016d: 5e pop %esi
11016e: 5f pop %edi
11016f: c9 leave
110170: 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 );
110171: e8 9e 31 00 00 call 113314 <__errno>
110176: c7 00 0c 00 00 00 movl $0xc,(%eax)
11017c: b8 ff ff ff ff mov $0xffffffff,%eax
110181: eb b2 jmp 110135 <rtems_filesystem_register+0x85>
00110184 <rtems_filesystem_unregister>:
int
rtems_filesystem_unregister(
const char *type
)
{
110184: 55 push %ebp
110185: 89 e5 mov %esp,%ebp
110187: 56 push %esi
110188: 53 push %ebx
110189: 8b 75 08 mov 0x8(%ebp),%esi
rtems_chain_node *node = NULL;
if ( type == NULL ) {
11018c: 85 f6 test %esi,%esi
11018e: 0f 84 94 00 00 00 je 110228 <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 );
110194: 51 push %ecx
110195: 6a 00 push $0x0
110197: 6a 00 push $0x0
110199: ff 35 08 74 12 00 pushl 0x127408
11019f: e8 0c b5 ff ff call 10b6b0 <rtems_semaphore_obtain>
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
1101a4: 8b 1d d8 51 12 00 mov 0x1251d8,%ebx
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_lock();
for (
1101aa: 83 c4 10 add $0x10,%esp
1101ad: 81 fb dc 51 12 00 cmp $0x1251dc,%ebx
1101b3: 75 0d jne 1101c2 <rtems_filesystem_unregister+0x3e>
1101b5: eb 49 jmp 110200 <rtems_filesystem_unregister+0x7c>
1101b7: 90 nop
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
1101b8: 8b 1b mov (%ebx),%ebx
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_lock();
for (
1101ba: 81 fb dc 51 12 00 cmp $0x1251dc,%ebx
1101c0: 74 3e je 110200 <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 ) {
1101c2: 83 ec 08 sub $0x8,%esp
1101c5: 56 push %esi
1101c6: ff 73 08 pushl 0x8(%ebx)
1101c9: e8 be 3d 00 00 call 113f8c <strcmp>
1101ce: 83 c4 10 add $0x10,%esp
1101d1: 85 c0 test %eax,%eax
1101d3: 75 e3 jne 1101b8 <rtems_filesystem_unregister+0x34>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
1101d5: 83 ec 0c sub $0xc,%esp
1101d8: 53 push %ebx
1101d9: e8 22 be ff ff call 10c000 <_Chain_Extract>
rtems_chain_extract( node );
free( fsn );
1101de: 89 1c 24 mov %ebx,(%esp)
1101e1: e8 ce 7e ff ff call 1080b4 <free>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
1101e6: 5a pop %edx
1101e7: ff 35 08 74 12 00 pushl 0x127408
1101ed: e8 ba b5 ff ff call 10b7ac <rtems_semaphore_release>
1101f2: 83 c4 10 add $0x10,%esp
rtems_libio_unlock();
return 0;
1101f5: 31 c0 xor %eax,%eax
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
1101f7: 8d 65 f8 lea -0x8(%ebp),%esp
1101fa: 5b pop %ebx
1101fb: 5e pop %esi
1101fc: c9 leave
1101fd: c3 ret
1101fe: 66 90 xchg %ax,%ax
110200: 83 ec 0c sub $0xc,%esp
110203: ff 35 08 74 12 00 pushl 0x127408
110209: e8 9e b5 ff ff call 10b7ac <rtems_semaphore_release>
return 0;
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
11020e: e8 01 31 00 00 call 113314 <__errno>
110213: c7 00 02 00 00 00 movl $0x2,(%eax)
110219: 83 c4 10 add $0x10,%esp
11021c: b8 ff ff ff ff mov $0xffffffff,%eax
}
110221: 8d 65 f8 lea -0x8(%ebp),%esp
110224: 5b pop %ebx
110225: 5e pop %esi
110226: c9 leave
110227: c3 ret
)
{
rtems_chain_node *node = NULL;
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
110228: e8 e7 30 00 00 call 113314 <__errno>
11022d: c7 00 16 00 00 00 movl $0x16,(%eax)
110233: 83 c8 ff or $0xffffffff,%eax
110236: eb e9 jmp 110221 <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 20 e0 12 00 03 cmpl $0x3,0x12e020
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 58 91 12 00 pushl 0x129158
10bc5b: e8 0c 4e 00 00 call 110a6c <_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
00112ff8 <rtems_io_close>:
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
112ff8: 55 push %ebp
112ff9: 89 e5 mov %esp,%ebp
112ffb: 53 push %ebx
112ffc: 83 ec 04 sub $0x4,%esp
112fff: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
113002: 39 05 20 80 12 00 cmp %eax,0x128020
113008: 76 1a jbe 113024 <rtems_io_close+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
11300a: 8d 14 40 lea (%eax,%eax,2),%edx
11300d: c1 e2 03 shl $0x3,%edx
113010: 03 15 24 80 12 00 add 0x128024,%edx
113016: 8b 52 08 mov 0x8(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
113019: 85 d2 test %edx,%edx
11301b: 74 13 je 113030 <rtems_io_close+0x38>
}
11301d: 59 pop %ecx
11301e: 5b pop %ebx
11301f: 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;
113020: ff e2 jmp *%edx
113022: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
113024: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].close_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
113029: 5a pop %edx
11302a: 5b pop %ebx
11302b: c9 leave
11302c: c3 ret
11302d: 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;
113030: 31 c0 xor %eax,%eax
}
113032: 5a pop %edx
113033: 5b pop %ebx
113034: c9 leave
113035: c3 ret
00113038 <rtems_io_control>:
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
113038: 55 push %ebp
113039: 89 e5 mov %esp,%ebp
11303b: 53 push %ebx
11303c: 83 ec 04 sub $0x4,%esp
11303f: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
113042: 39 05 20 80 12 00 cmp %eax,0x128020
113048: 76 1a jbe 113064 <rtems_io_control+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
11304a: 8d 14 40 lea (%eax,%eax,2),%edx
11304d: c1 e2 03 shl $0x3,%edx
113050: 03 15 24 80 12 00 add 0x128024,%edx
113056: 8b 52 14 mov 0x14(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
113059: 85 d2 test %edx,%edx
11305b: 74 13 je 113070 <rtems_io_control+0x38>
}
11305d: 59 pop %ecx
11305e: 5b pop %ebx
11305f: 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;
113060: ff e2 jmp *%edx
113062: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
113064: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].control_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
113069: 5a pop %edx
11306a: 5b pop %ebx
11306b: c9 leave
11306c: c3 ret
11306d: 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;
113070: 31 c0 xor %eax,%eax
}
113072: 5a pop %edx
113073: 5b pop %ebx
113074: c9 leave
113075: c3 ret
00111014 <rtems_io_initialize>:
rtems_status_code rtems_io_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
111014: 55 push %ebp
111015: 89 e5 mov %esp,%ebp
111017: 53 push %ebx
111018: 83 ec 04 sub $0x4,%esp
11101b: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
11101e: 39 05 20 80 12 00 cmp %eax,0x128020
111024: 76 1a jbe 111040 <rtems_io_initialize+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].initialization_entry;
111026: 8d 14 40 lea (%eax,%eax,2),%edx
111029: c1 e2 03 shl $0x3,%edx
11102c: 03 15 24 80 12 00 add 0x128024,%edx
111032: 8b 12 mov (%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
111034: 85 d2 test %edx,%edx
111036: 74 14 je 11104c <rtems_io_initialize+0x38>
}
111038: 59 pop %ecx
111039: 5b pop %ebx
11103a: 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;
11103b: ff e2 jmp *%edx
11103d: 8d 76 00 lea 0x0(%esi),%esi
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
111040: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].initialization_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
111045: 5a pop %edx
111046: 5b pop %ebx
111047: c9 leave
111048: c3 ret
111049: 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;
11104c: 31 c0 xor %eax,%eax
}
11104e: 5a pop %edx
11104f: 5b pop %ebx
111050: c9 leave
111051: 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>
00113078 <rtems_io_open>:
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
113078: 55 push %ebp
113079: 89 e5 mov %esp,%ebp
11307b: 53 push %ebx
11307c: 83 ec 04 sub $0x4,%esp
11307f: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
113082: 39 05 20 80 12 00 cmp %eax,0x128020
113088: 76 1a jbe 1130a4 <rtems_io_open+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
11308a: 8d 14 40 lea (%eax,%eax,2),%edx
11308d: c1 e2 03 shl $0x3,%edx
113090: 03 15 24 80 12 00 add 0x128024,%edx
113096: 8b 52 04 mov 0x4(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
113099: 85 d2 test %edx,%edx
11309b: 74 13 je 1130b0 <rtems_io_open+0x38>
}
11309d: 59 pop %ecx
11309e: 5b pop %ebx
11309f: 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;
1130a0: ff e2 jmp *%edx
1130a2: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
1130a4: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].open_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
1130a9: 5a pop %edx
1130aa: 5b pop %ebx
1130ab: c9 leave
1130ac: c3 ret
1130ad: 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;
1130b0: 31 c0 xor %eax,%eax
}
1130b2: 5a pop %edx
1130b3: 5b pop %ebx
1130b4: c9 leave
1130b5: c3 ret
001130b8 <rtems_io_read>:
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
1130b8: 55 push %ebp
1130b9: 89 e5 mov %esp,%ebp
1130bb: 53 push %ebx
1130bc: 83 ec 04 sub $0x4,%esp
1130bf: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
1130c2: 39 05 20 80 12 00 cmp %eax,0x128020
1130c8: 76 1a jbe 1130e4 <rtems_io_read+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
1130ca: 8d 14 40 lea (%eax,%eax,2),%edx
1130cd: c1 e2 03 shl $0x3,%edx
1130d0: 03 15 24 80 12 00 add 0x128024,%edx
1130d6: 8b 52 0c mov 0xc(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
1130d9: 85 d2 test %edx,%edx
1130db: 74 13 je 1130f0 <rtems_io_read+0x38>
}
1130dd: 59 pop %ecx
1130de: 5b pop %ebx
1130df: 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;
1130e0: ff e2 jmp *%edx
1130e2: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
1130e4: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].read_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
1130e9: 5a pop %edx
1130ea: 5b pop %ebx
1130eb: c9 leave
1130ec: c3 ret
1130ed: 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;
1130f0: 31 c0 xor %eax,%eax
}
1130f2: 5a pop %edx
1130f3: 5b pop %ebx
1130f4: c9 leave
1130f5: c3 ret
0010cecc <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
)
{
10cecc: 55 push %ebp
10cecd: 89 e5 mov %esp,%ebp
10cecf: 57 push %edi
10ced0: 56 push %esi
10ced1: 53 push %ebx
10ced2: 83 ec 0c sub $0xc,%esp
10ced5: 8b 5d 08 mov 0x8(%ebp),%ebx
10ced8: 8b 75 0c mov 0xc(%ebp),%esi
10cedb: 8b 55 10 mov 0x10(%ebp),%edx
rtems_device_major_number major_limit = _IO_Number_of_drivers;
10cede: a1 00 bd 12 00 mov 0x12bd00,%eax
if ( rtems_interrupt_is_in_progress() )
10cee3: 8b 0d 34 b8 12 00 mov 0x12b834,%ecx
10cee9: 85 c9 test %ecx,%ecx
10ceeb: 0f 85 ab 00 00 00 jne 10cf9c <rtems_io_register_driver+0xd0>
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
10cef1: 85 d2 test %edx,%edx
10cef3: 0f 84 e7 00 00 00 je 10cfe0 <rtems_io_register_driver+0x114>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
10cef9: 89 02 mov %eax,(%edx)
if ( driver_table == NULL )
10cefb: 85 f6 test %esi,%esi
10cefd: 0f 84 dd 00 00 00 je 10cfe0 <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;
10cf03: 8b 3e mov (%esi),%edi
10cf05: 85 ff test %edi,%edi
10cf07: 0f 84 c7 00 00 00 je 10cfd4 <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 )
10cf0d: 39 d8 cmp %ebx,%eax
10cf0f: 76 7b jbe 10cf8c <rtems_io_register_driver+0xc0>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10cf11: a1 50 b2 12 00 mov 0x12b250,%eax
10cf16: 40 inc %eax
10cf17: a3 50 b2 12 00 mov %eax,0x12b250
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
10cf1c: 85 db test %ebx,%ebx
10cf1e: 0f 85 88 00 00 00 jne 10cfac <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;
10cf24: 8b 0d 00 bd 12 00 mov 0x12bd00,%ecx
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
10cf2a: 85 c9 test %ecx,%ecx
10cf2c: 0f 84 bb 00 00 00 je 10cfed <rtems_io_register_driver+0x121><== NEVER TAKEN
10cf32: 8b 3d 04 bd 12 00 mov 0x12bd04,%edi
10cf38: 89 f8 mov %edi,%eax
10cf3a: eb 08 jmp 10cf44 <rtems_io_register_driver+0x78>
10cf3c: 43 inc %ebx
10cf3d: 83 c0 18 add $0x18,%eax
10cf40: 39 d9 cmp %ebx,%ecx
10cf42: 76 0b jbe 10cf4f <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;
10cf44: 83 38 00 cmpl $0x0,(%eax)
10cf47: 75 f3 jne 10cf3c <rtems_io_register_driver+0x70>
10cf49: 83 78 04 00 cmpl $0x0,0x4(%eax)
10cf4d: 75 ed jne 10cf3c <rtems_io_register_driver+0x70>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10cf4f: 89 1a mov %ebx,(%edx)
if ( m != n )
10cf51: 39 d9 cmp %ebx,%ecx
10cf53: 0f 84 9b 00 00 00 je 10cff4 <rtems_io_register_driver+0x128>
10cf59: 8d 04 5b lea (%ebx,%ebx,2),%eax
10cf5c: c1 e0 03 shl $0x3,%eax
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
10cf5f: 01 c7 add %eax,%edi
10cf61: b9 06 00 00 00 mov $0x6,%ecx
10cf66: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Thread_Enable_dispatch();
10cf68: e8 a3 1c 00 00 call 10ec10 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
10cf6d: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp)
10cf74: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp)
10cf7b: 89 5d 08 mov %ebx,0x8(%ebp)
}
10cf7e: 83 c4 0c add $0xc,%esp
10cf81: 5b pop %ebx
10cf82: 5e pop %esi
10cf83: 5f pop %edi
10cf84: c9 leave
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
10cf85: e9 36 7e 00 00 jmp 114dc0 <rtems_io_initialize>
10cf8a: 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;
10cf8c: 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 );
}
10cf91: 83 c4 0c add $0xc,%esp
10cf94: 5b pop %ebx
10cf95: 5e pop %esi
10cf96: 5f pop %edi
10cf97: c9 leave
10cf98: c3 ret
10cf99: 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;
10cf9c: 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 );
}
10cfa1: 83 c4 0c add $0xc,%esp
10cfa4: 5b pop %ebx
10cfa5: 5e pop %esi
10cfa6: 5f pop %edi
10cfa7: c9 leave
10cfa8: c3 ret
10cfa9: 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;
10cfac: 8d 04 5b lea (%ebx,%ebx,2),%eax
10cfaf: c1 e0 03 shl $0x3,%eax
10cfb2: 8b 0d 04 bd 12 00 mov 0x12bd04,%ecx
10cfb8: 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;
10cfba: 8b 39 mov (%ecx),%edi
10cfbc: 85 ff test %edi,%edi
10cfbe: 74 40 je 10d000 <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();
10cfc0: e8 4b 1c 00 00 call 10ec10 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
10cfc5: 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 );
}
10cfca: 83 c4 0c add $0xc,%esp
10cfcd: 5b pop %ebx
10cfce: 5e pop %esi
10cfcf: 5f pop %edi
10cfd0: c9 leave
10cfd1: c3 ret
10cfd2: 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;
10cfd4: 8b 4e 04 mov 0x4(%esi),%ecx
10cfd7: 85 c9 test %ecx,%ecx
10cfd9: 0f 85 2e ff ff ff jne 10cf0d <rtems_io_register_driver+0x41>
10cfdf: 90 nop
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
10cfe0: 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 );
}
10cfe5: 83 c4 0c add $0xc,%esp
10cfe8: 5b pop %ebx
10cfe9: 5e pop %esi
10cfea: 5f pop %edi
10cfeb: c9 leave
10cfec: c3 ret
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10cfed: c7 02 00 00 00 00 movl $0x0,(%edx)
10cff3: 90 nop
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
10cff4: e8 17 1c 00 00 call 10ec10 <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
10cff9: 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;
10cffe: eb 91 jmp 10cf91 <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;
10d000: 8b 49 04 mov 0x4(%ecx),%ecx
10d003: 85 c9 test %ecx,%ecx
10d005: 75 b9 jne 10cfc0 <rtems_io_register_driver+0xf4>
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
10d007: 89 1a mov %ebx,(%edx)
10d009: 8b 3d 04 bd 12 00 mov 0x12bd04,%edi
10d00f: e9 4b ff ff ff jmp 10cf5f <rtems_io_register_driver+0x93>
0010d014 <rtems_io_unregister_driver>:
*/
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
10d014: 55 push %ebp
10d015: 89 e5 mov %esp,%ebp
10d017: 57 push %edi
10d018: 83 ec 04 sub $0x4,%esp
10d01b: 8b 45 08 mov 0x8(%ebp),%eax
if ( rtems_interrupt_is_in_progress() )
10d01e: 8b 0d 34 b8 12 00 mov 0x12b834,%ecx
10d024: 85 c9 test %ecx,%ecx
10d026: 75 44 jne 10d06c <rtems_io_unregister_driver+0x58>
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
10d028: 39 05 00 bd 12 00 cmp %eax,0x12bd00
10d02e: 77 0c ja 10d03c <rtems_io_unregister_driver+0x28>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
10d030: b8 0d 00 00 00 mov $0xd,%eax
}
10d035: 5a pop %edx
10d036: 5f pop %edi
10d037: c9 leave
10d038: c3 ret
10d039: 8d 76 00 lea 0x0(%esi),%esi
10d03c: 8b 15 50 b2 12 00 mov 0x12b250,%edx
10d042: 42 inc %edx
10d043: 89 15 50 b2 12 00 mov %edx,0x12b250
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
_Thread_Disable_dispatch();
memset(
&_IO_Driver_address_table[major],
10d049: 8d 14 40 lea (%eax,%eax,2),%edx
10d04c: 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(
10d04f: 03 15 04 bd 12 00 add 0x12bd04,%edx
10d055: b9 18 00 00 00 mov $0x18,%ecx
10d05a: 31 c0 xor %eax,%eax
10d05c: 89 d7 mov %edx,%edi
10d05e: f3 aa rep stos %al,%es:(%edi)
&_IO_Driver_address_table[major],
0,
sizeof( rtems_driver_address_table )
);
_Thread_Enable_dispatch();
10d060: e8 ab 1b 00 00 call 10ec10 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10d065: 31 c0 xor %eax,%eax
}
return RTEMS_UNSATISFIED;
}
10d067: 5a pop %edx
10d068: 5f pop %edi
10d069: c9 leave
10d06a: c3 ret
10d06b: 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;
10d06c: b8 12 00 00 00 mov $0x12,%eax
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
}
10d071: 5a pop %edx
10d072: 5f pop %edi
10d073: c9 leave
10d074: c3 ret
001130f8 <rtems_io_write>:
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
1130f8: 55 push %ebp
1130f9: 89 e5 mov %esp,%ebp
1130fb: 53 push %ebx
1130fc: 83 ec 04 sub $0x4,%esp
1130ff: 8b 45 08 mov 0x8(%ebp),%eax
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
113102: 39 05 20 80 12 00 cmp %eax,0x128020
113108: 76 1a jbe 113124 <rtems_io_write+0x2c>
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
11310a: 8d 14 40 lea (%eax,%eax,2),%edx
11310d: c1 e2 03 shl $0x3,%edx
113110: 03 15 24 80 12 00 add 0x128024,%edx
113116: 8b 52 10 mov 0x10(%edx),%edx
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
113119: 85 d2 test %edx,%edx
11311b: 74 13 je 113130 <rtems_io_write+0x38>
}
11311d: 59 pop %ecx
11311e: 5b pop %ebx
11311f: 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;
113120: ff e2 jmp *%edx
113122: 66 90 xchg %ax,%ax
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
return RTEMS_INVALID_NUMBER;
113124: b8 0a 00 00 00 mov $0xa,%eax
callout = _IO_Driver_address_table[major].write_entry;
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
}
113129: 5a pop %edx
11312a: 5b pop %ebx
11312b: c9 leave
11312c: c3 ret
11312d: 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;
113130: 31 c0 xor %eax,%eax
}
113132: 5a pop %edx
113133: 5b pop %ebx
113134: c9 leave
113135: c3 ret
0010dfbc <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)
{
10dfbc: 55 push %ebp
10dfbd: 89 e5 mov %esp,%ebp
10dfbf: 57 push %edi
10dfc0: 56 push %esi
10dfc1: 53 push %ebx
10dfc2: 83 ec 1c sub $0x1c,%esp
10dfc5: 8b 7d 08 mov 0x8(%ebp),%edi
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
10dfc8: 85 ff test %edi,%edi
10dfca: 74 49 je 10e015 <rtems_iterate_over_all_threads+0x59><== NEVER TAKEN
10dfcc: 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 ];
10dfd3: 8b 55 e4 mov -0x1c(%ebp),%edx
10dfd6: 8b 04 95 48 23 13 00 mov 0x132348(,%edx,4),%eax
10dfdd: 8b 70 04 mov 0x4(%eax),%esi
if ( !information )
10dfe0: 85 f6 test %esi,%esi
10dfe2: 74 28 je 10e00c <rtems_iterate_over_all_threads+0x50>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10dfe4: 66 83 7e 10 00 cmpw $0x0,0x10(%esi)
10dfe9: 74 21 je 10e00c <rtems_iterate_over_all_threads+0x50>
10dfeb: bb 01 00 00 00 mov $0x1,%ebx
the_thread = (Thread_Control *)information->local_table[ i ];
10dff0: 8b 46 1c mov 0x1c(%esi),%eax
10dff3: 8b 04 98 mov (%eax,%ebx,4),%eax
if ( !the_thread )
10dff6: 85 c0 test %eax,%eax
10dff8: 74 09 je 10e003 <rtems_iterate_over_all_threads+0x47><== NEVER TAKEN
continue;
(*routine)(the_thread);
10dffa: 83 ec 0c sub $0xc,%esp
10dffd: 50 push %eax
10dffe: ff d7 call *%edi
10e000: 83 c4 10 add $0x10,%esp
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10e003: 43 inc %ebx
10e004: 0f b7 46 10 movzwl 0x10(%esi),%eax
10e008: 39 d8 cmp %ebx,%eax
10e00a: 73 e4 jae 10dff0 <rtems_iterate_over_all_threads+0x34>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
10e00c: ff 45 e4 incl -0x1c(%ebp)
10e00f: 83 7d e4 04 cmpl $0x4,-0x1c(%ebp)
10e013: 75 be jne 10dfd3 <rtems_iterate_over_all_threads+0x17>
(*routine)(the_thread);
}
}
}
10e015: 8d 65 f4 lea -0xc(%ebp),%esp
10e018: 5b pop %ebx
10e019: 5e pop %esi
10e01a: 5f pop %edi
10e01b: c9 leave
10e01c: c3 ret
0010fe7c <rtems_libio_free>:
*/
void rtems_libio_free(
rtems_libio_t *iop
)
{
10fe7c: 55 push %ebp
10fe7d: 89 e5 mov %esp,%ebp
10fe7f: 53 push %ebx
10fe80: 83 ec 08 sub $0x8,%esp
10fe83: 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 );
10fe86: 6a 00 push $0x0
10fe88: 6a 00 push $0x0
10fe8a: ff 35 08 74 12 00 pushl 0x127408
10fe90: e8 1b b8 ff ff call 10b6b0 <rtems_semaphore_obtain>
rtems_libio_lock();
if (iop->sem)
10fe95: 8b 43 2c mov 0x2c(%ebx),%eax
10fe98: 83 c4 10 add $0x10,%esp
10fe9b: 85 c0 test %eax,%eax
10fe9d: 74 0c je 10feab <rtems_libio_free+0x2f> <== NEVER TAKEN
rtems_semaphore_delete(iop->sem);
10fe9f: 83 ec 0c sub $0xc,%esp
10fea2: 50 push %eax
10fea3: e8 64 b7 ff ff call 10b60c <rtems_semaphore_delete>
10fea8: 83 c4 10 add $0x10,%esp
iop->flags &= ~LIBIO_FLAGS_OPEN;
10feab: 81 63 14 ff fe ff ff andl $0xfffffeff,0x14(%ebx)
iop->data1 = rtems_libio_iop_freelist;
10feb2: a1 04 74 12 00 mov 0x127404,%eax
10feb7: 89 43 34 mov %eax,0x34(%ebx)
rtems_libio_iop_freelist = iop;
10feba: 89 1d 04 74 12 00 mov %ebx,0x127404
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10fec0: a1 08 74 12 00 mov 0x127408,%eax
10fec5: 89 45 08 mov %eax,0x8(%ebp)
rtems_libio_unlock();
}
10fec8: 8b 5d fc mov -0x4(%ebp),%ebx
10fecb: c9 leave
10fecc: e9 db 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 ac 31 12 00 mov 0x1231ac,%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 00 74 12 00 mov %eax,0x127400
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 04 74 12 00 mov %eax,0x127404
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 08 74 12 00 push $0x127408
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 a8 31 12 00 mov 0x1231a8,%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 b2 3a 00 00 call 10bd00 <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 a8 3a 00 00 call 10bd00 <rtems_fatal_error_occurred>
0010ff38 <rtems_libio_is_file_open>:
*/
int rtems_libio_is_file_open(
void *node_access
)
{
10ff38: 55 push %ebp
10ff39: 89 e5 mov %esp,%ebp
10ff3b: 53 push %ebx
10ff3c: 83 ec 08 sub $0x8,%esp
10ff3f: 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 );
10ff42: 6a 00 push $0x0
10ff44: 6a 00 push $0x0
10ff46: ff 35 08 74 12 00 pushl 0x127408
10ff4c: e8 5f 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++){
10ff51: a1 00 74 12 00 mov 0x127400,%eax
10ff56: 8b 0d ac 31 12 00 mov 0x1231ac,%ecx
10ff5c: 83 c4 10 add $0x10,%esp
10ff5f: 85 c9 test %ecx,%ecx
10ff61: 74 18 je 10ff7b <rtems_libio_is_file_open+0x43><== NEVER TAKEN
10ff63: 31 d2 xor %edx,%edx
10ff65: eb 04 jmp 10ff6b <rtems_libio_is_file_open+0x33>
10ff67: 90 nop
10ff68: 83 c0 38 add $0x38,%eax
if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {
10ff6b: f6 40 15 01 testb $0x1,0x15(%eax)
10ff6f: 74 05 je 10ff76 <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 ) {
10ff71: 39 58 18 cmp %ebx,0x18(%eax)
10ff74: 74 1e je 10ff94 <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++){
10ff76: 42 inc %edx
10ff77: 39 ca cmp %ecx,%edx
10ff79: 72 ed jb 10ff68 <rtems_libio_is_file_open+0x30>
int rtems_libio_is_file_open(
void *node_access
)
{
rtems_libio_t *iop;
int result=0;
10ff7b: 31 db xor %ebx,%ebx
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10ff7d: 83 ec 0c sub $0xc,%esp
10ff80: ff 35 08 74 12 00 pushl 0x127408
10ff86: e8 21 b8 ff ff call 10b7ac <rtems_semaphore_release>
}
rtems_libio_unlock();
return result;
}
10ff8b: 89 d8 mov %ebx,%eax
10ff8d: 8b 5d fc mov -0x4(%ebp),%ebx
10ff90: c9 leave
10ff91: c3 ret
10ff92: 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;
10ff94: bb 01 00 00 00 mov $0x1,%ebx
10ff99: eb e2 jmp 10ff7d <rtems_libio_is_file_open+0x45>
0010fed4 <rtems_libio_is_open_files_in_fs>:
*/
int rtems_libio_is_open_files_in_fs(
rtems_filesystem_mount_table_entry_t * fs_mt_entry
)
{
10fed4: 55 push %ebp
10fed5: 89 e5 mov %esp,%ebp
10fed7: 53 push %ebx
10fed8: 83 ec 08 sub $0x8,%esp
10fedb: 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 );
10fede: 6a 00 push $0x0
10fee0: 6a 00 push $0x0
10fee2: ff 35 08 74 12 00 pushl 0x127408
10fee8: e8 c3 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++){
10feed: a1 00 74 12 00 mov 0x127400,%eax
10fef2: 8b 0d ac 31 12 00 mov 0x1231ac,%ecx
10fef8: 83 c4 10 add $0x10,%esp
10fefb: 85 c9 test %ecx,%ecx
10fefd: 74 18 je 10ff17 <rtems_libio_is_open_files_in_fs+0x43><== NEVER TAKEN
10feff: 31 d2 xor %edx,%edx
10ff01: eb 04 jmp 10ff07 <rtems_libio_is_open_files_in_fs+0x33>
10ff03: 90 nop
10ff04: 83 c0 38 add $0x38,%eax
if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {
10ff07: f6 40 15 01 testb $0x1,0x15(%eax)
10ff0b: 74 05 je 10ff12 <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 ) {
10ff0d: 39 58 28 cmp %ebx,0x28(%eax)
10ff10: 74 1e je 10ff30 <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++){
10ff12: 42 inc %edx
10ff13: 39 ca cmp %ecx,%edx
10ff15: 72 ed jb 10ff04 <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;
10ff17: 31 db xor %ebx,%ebx
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10ff19: 83 ec 0c sub $0xc,%esp
10ff1c: ff 35 08 74 12 00 pushl 0x127408
10ff22: e8 85 b8 ff ff call 10b7ac <rtems_semaphore_release>
}
rtems_libio_unlock();
return result;
}
10ff27: 89 d8 mov %ebx,%eax
10ff29: 8b 5d fc mov -0x4(%ebp),%ebx
10ff2c: c9 leave
10ff2d: c3 ret
10ff2e: 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;
10ff30: bb 01 00 00 00 mov $0x1,%ebx
10ff35: eb e2 jmp 10ff19 <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 27 14 12 00 push $0x121427
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
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 27 14 12 00 push $0x121427
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 b0 5a 12 00 mov 0x125ab0,%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 60 7d 12 00 cmp $0x127d60,%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 b0 5a 12 00 push $0x125ab0
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 b0 5a 12 00 mov %edx,0x125ab0
}
/* Inherit the global values */
*rtems_current_user_env = rtems_global_user_env;
109640: be 60 7d 12 00 mov $0x127d60,%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 b0 5a 12 00 push $0x125ab0
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 b0 5a 12 00 mov 0x125ab0,%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 b0 5a 12 00 mov %edx,0x125ab0
#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>
0010fd94 <rtems_libio_to_fcntl_flags>:
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
10fd94: 55 push %ebp
10fd95: 89 e5 mov %esp,%ebp
10fd97: 8b 55 08 mov 0x8(%ebp),%edx
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
10fd9a: 89 d0 mov %edx,%eax
10fd9c: 83 e0 06 and $0x6,%eax
10fd9f: 83 f8 06 cmp $0x6,%eax
10fda2: 74 2c je 10fdd0 <rtems_libio_to_fcntl_flags+0x3c>
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
10fda4: f6 c2 02 test $0x2,%dl
10fda7: 75 23 jne 10fdcc <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;
10fda9: 31 c0 xor %eax,%eax
10fdab: f6 c2 04 test $0x4,%dl <== NOT EXECUTED
10fdae: 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 ) {
10fdb1: f6 c2 01 test $0x1,%dl
10fdb4: 74 03 je 10fdb9 <rtems_libio_to_fcntl_flags+0x25>
fcntl_flags |= O_NONBLOCK;
10fdb6: 80 cc 40 or $0x40,%ah
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
10fdb9: f6 c6 02 test $0x2,%dh
10fdbc: 74 03 je 10fdc1 <rtems_libio_to_fcntl_flags+0x2d>
fcntl_flags |= O_APPEND;
10fdbe: 83 c8 08 or $0x8,%eax
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
10fdc1: 80 e6 04 and $0x4,%dh
10fdc4: 74 03 je 10fdc9 <rtems_libio_to_fcntl_flags+0x35>
fcntl_flags |= O_CREAT;
10fdc6: 80 cc 02 or $0x2,%ah
}
return fcntl_flags;
}
10fdc9: c9 leave
10fdca: c3 ret
10fdcb: 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;
10fdcc: 31 c0 xor %eax,%eax
10fdce: eb e1 jmp 10fdb1 <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;
10fdd0: b8 02 00 00 00 mov $0x2,%eax
10fdd5: eb da jmp 10fdb1 <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 58 91 12 00 pushl 0x129158
10af23: e8 ec 5b 00 00 call 110b14 <_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 24 dd 12 00 add %eax,0x12dd24
10af3a: 11 15 28 dd 12 00 adc %edx,0x12dd28
}
}
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 58 91 12 00 pushl 0x129158
10af64: e8 ab 5b 00 00 call 110b14 <_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 1c dd 12 00 add 0x12dd1c,%eax
10af74: 13 15 20 dd 12 00 adc 0x12dd20,%edx
10af7a: a3 1c dd 12 00 mov %eax,0x12dd1c
10af7f: 89 15 20 dd 12 00 mov %edx,0x12dd20
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
10af85: 2b 05 24 dd 12 00 sub 0x12dd24,%eax
if (current_depth > s->max_depth)
10af8b: 83 c4 10 add $0x10,%esp
10af8e: 3b 05 18 dd 12 00 cmp 0x12dd18,%eax
10af94: 76 05 jbe 10af9b <rtems_malloc_statistics_at_malloc+0x57>
s->max_depth = current_depth;
10af96: a3 18 dd 12 00 mov %eax,0x12dd18
}
10af9b: c9 leave
10af9c: c3 ret
00113d98 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
113d98: 55 push %ebp
113d99: 89 e5 mov %esp,%ebp
113d9b: 53 push %ebx
113d9c: 83 ec 14 sub $0x14,%esp
113d9f: 8b 5d 08 mov 0x8(%ebp),%ebx
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
113da2: 85 db test %ebx,%ebx
113da4: 74 5b je 113e01 <rtems_memalign+0x69>
return EINVAL;
*pointer = NULL;
113da6: 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()) &&
113dac: 83 3d 20 b4 12 00 03 cmpl $0x3,0x12b420
113db3: 74 43 je 113df8 <rtems_memalign+0x60> <== ALWAYS TAKEN
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
113db5: e8 a6 53 ff ff call 109160 <malloc_deferred_frees_process>
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
113dba: 6a 00 push $0x0
113dbc: ff 75 0c pushl 0xc(%ebp)
113dbf: ff 75 10 pushl 0x10(%ebp)
113dc2: ff 35 f8 6d 12 00 pushl 0x126df8
113dc8: e8 d7 a5 ff ff call 10e3a4 <_Protected_heap_Allocate_aligned_with_boundary>
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
113dcd: 83 c4 10 add $0x10,%esp
113dd0: 85 c0 test %eax,%eax
113dd2: 74 38 je 113e0c <rtems_memalign+0x74>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
113dd4: 8b 15 08 94 12 00 mov 0x129408,%edx
113dda: 85 d2 test %edx,%edx
113ddc: 74 10 je 113dee <rtems_memalign+0x56>
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
113dde: 83 ec 0c sub $0xc,%esp
113de1: 53 push %ebx
113de2: 89 45 f4 mov %eax,-0xc(%ebp)
113de5: ff 52 04 call *0x4(%edx)
113de8: 83 c4 10 add $0x10,%esp
113deb: 8b 45 f4 mov -0xc(%ebp),%eax
*pointer = return_this;
113dee: 89 03 mov %eax,(%ebx)
return 0;
113df0: 31 c0 xor %eax,%eax
}
113df2: 8b 5d fc mov -0x4(%ebp),%ebx
113df5: c9 leave
113df6: c3 ret
113df7: 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() )
113df8: e8 23 53 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()) &&
113dfd: 84 c0 test %al,%al
113dff: 75 b4 jne 113db5 <rtems_memalign+0x1d> <== ALWAYS TAKEN
!malloc_is_system_state_OK() )
return EINVAL;
113e01: 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;
}
113e06: 8b 5d fc mov -0x4(%ebp),%ebx
113e09: c9 leave
113e0a: c3 ret
113e0b: 90 nop
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
return ENOMEM;
113e0c: b8 0c 00 00 00 mov $0xc,%eax
113e11: eb df jmp 113df2 <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 40 2c 14 00 push $0x142c40
1163e1: e8 fe 4e 00 00 call 11b2e4 <_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 cc 34 00 00 call 1198e0 <_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 7a 59 00 00 call 11bd98 <_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 f0 0b 13 00 mov 0x130bf0,%eax
1138b5: 40 inc %eax
1138b6: a3 f0 0b 13 00 mov %eax,0x130bf0
#endif
#endif
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
1138bb: 89 4d d4 mov %ecx,-0x2c(%ebp)
1138be: e8 d9 5f 00 00 call 11989c <_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 31 11 00 00 call 114a20 <_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 16 13 00 push $0x131620
113902: e8 b9 1f 00 00 call 1158c0 <_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 28 2c 00 00 call 116534 <_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 16 13 00 mov 0x13163c,%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 f3 2b 00 00 call 116534 <_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 e7 2b 00 00 call 116534 <_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 40 2c 14 00 push $0x142c40
116557: e8 88 4d 00 00 call 11b2e4 <_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 40 2c 14 00 push $0x142c40
116571: e8 f6 48 00 00 call 11ae6c <_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 de 33 00 00 call 119964 <_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 40 2c 14 00 push $0x142c40
11658e: e8 d5 4b 00 00 call 11b168 <_Objects_Free>
0, /* Not used */
0
);
}
#endif
_Thread_Enable_dispatch();
116593: e8 00 58 00 00 call 11bd98 <_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 40 2c 14 00 push $0x142c40
1165cb: e8 14 4d 00 00 call 11b2e4 <_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 b0 33 00 00 call 1199a0 <_CORE_message_queue_Flush>
1165f0: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
1165f2: e8 a1 57 00 00 call 11bd98 <_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 40 2c 14 00 push $0x142c40
11662b: e8 b4 4c 00 00 call 11b2e4 <_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 4a 57 00 00 call 11bd98 <_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 16 13 00 push $0x131620
11399f: e8 5c 20 00 00 call 115a00 <_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 04 11 00 00 call 114ad0 <_CORE_message_queue_Seize>
buffer,
size,
wait,
timeout
);
_Thread_Enable_dispatch();
1139cc: 83 c4 20 add $0x20,%esp
1139cf: e8 60 2b 00 00 call 116534 <_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 11 13 00 mov 0x1311d8,%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 a0 7f 12 00 push $0x127fa0
10b3c5: e8 76 1a 00 00 call 10ce40 <_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 43 0c 00 00 call 10c03c <_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 f1 24 00 00 call 10d8f4 <_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 40 2c 14 00 push $0x142c40
1167bd: e8 22 4b 00 00 call 11b2e4 <_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 ef 33 00 00 call 119be0 <_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 9d 55 00 00 call 11bd98 <_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
001124ac <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
1124ac: 55 push %ebp
1124ad: 89 e5 mov %esp,%ebp
1124af: 57 push %edi
1124b0: 56 push %esi
1124b1: 53 push %ebx
1124b2: 83 ec 78 sub $0x78,%esp
int success = 0;
char *dup_path = strdup(path);
1124b5: ff 75 08 pushl 0x8(%ebp)
1124b8: e8 97 36 00 00 call 115b54 <strdup>
1124bd: 89 c7 mov %eax,%edi
if (dup_path != NULL) {
1124bf: 83 c4 10 add $0x10,%esp
1124c2: 85 c0 test %eax,%eax
1124c4: 0f 84 0a 01 00 00 je 1125d4 <rtems_mkdir+0x128> <== NEVER TAKEN
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
1124ca: 8a 10 mov (%eax),%dl
1124cc: 80 fa 2f cmp $0x2f,%dl
1124cf: 0f 84 0f 01 00 00 je 1125e4 <rtems_mkdir+0x138>
1124d5: 89 c3 mov %eax,%ebx
1124d7: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp)
1124de: b8 01 00 00 00 mov $0x1,%eax
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
1124e3: 84 d2 test %dl,%dl
1124e5: 74 11 je 1124f8 <rtems_mkdir+0x4c> <== NEVER TAKEN
1124e7: 90 nop
last = 1;
else if (p[0] != '/')
1124e8: 80 fa 2f cmp $0x2f,%dl
1124eb: 0f 84 83 00 00 00 je 112574 <rtems_mkdir+0xc8>
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
1124f1: 43 inc %ebx
1124f2: 8a 13 mov (%ebx),%dl
if (p[0] == '\0')
1124f4: 84 d2 test %dl,%dl
1124f6: 75 f0 jne 1124e8 <rtems_mkdir+0x3c>
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
1124f8: c6 03 00 movb $0x0,(%ebx)
1124fb: be 01 00 00 00 mov $0x1,%esi
if (!last && p[1] == '\0')
last = 1;
if (first) {
112500: 85 c0 test %eax,%eax
112502: 75 54 jne 112558 <rtems_mkdir+0xac>
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
112504: 85 f6 test %esi,%esi
112506: 75 3c jne 112544 <rtems_mkdir+0x98>
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
112508: b8 ff 01 00 00 mov $0x1ff,%eax
11250d: 83 ec 08 sub $0x8,%esp
112510: 50 push %eax
112511: 57 push %edi
112512: e8 ed 71 ff ff call 109704 <mkdir>
112517: 83 c4 10 add $0x10,%esp
11251a: 85 c0 test %eax,%eax
11251c: 78 6a js 112588 <rtems_mkdir+0xdc>
} else {
retval = 0;
break;
}
}
if (!last)
11251e: 85 f6 test %esi,%esi
112520: 75 0a jne 11252c <rtems_mkdir+0x80>
*p = '/';
112522: c6 03 2f movb $0x2f,(%ebx)
112525: 31 c0 xor %eax,%eax
112527: eb c8 jmp 1124f1 <rtems_mkdir+0x45>
112529: 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);
11252c: 83 ec 0c sub $0xc,%esp
11252f: 57 push %edi
112530: e8 d7 6b ff ff call 10910c <free>
112535: 83 c4 10 add $0x10,%esp
}
return success != 0 ? 0 : -1;
112538: 31 c0 xor %eax,%eax
}
11253a: 8d 65 f4 lea -0xc(%ebp),%esp
11253d: 5b pop %ebx
11253e: 5e pop %esi
11253f: 5f pop %edi
112540: c9 leave
112541: c3 ret
112542: 66 90 xchg %ax,%ax
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
(void)umask(oumask);
112544: 83 ec 0c sub $0xc,%esp
112547: ff 75 94 pushl -0x6c(%ebp)
11254a: e8 81 01 00 00 call 1126d0 <umask>
11254f: 83 c4 10 add $0x10,%esp
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
112552: 8b 45 0c mov 0xc(%ebp),%eax
112555: eb b6 jmp 11250d <rtems_mkdir+0x61>
112557: 90 nop
* mkdir [-m mode] dir
*
* We change the user's umask and then restore it,
* instead of doing chmod's.
*/
oumask = umask(0);
112558: 83 ec 0c sub $0xc,%esp
11255b: 6a 00 push $0x0
11255d: e8 6e 01 00 00 call 1126d0 <umask>
112562: 89 45 94 mov %eax,-0x6c(%ebp)
numask = oumask & ~(S_IWUSR | S_IXUSR);
112565: 24 3f and $0x3f,%al
(void)umask(numask);
112567: 89 04 24 mov %eax,(%esp)
11256a: e8 61 01 00 00 call 1126d0 <umask>
11256f: 83 c4 10 add $0x10,%esp
112572: eb 90 jmp 112504 <rtems_mkdir+0x58>
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
112574: c6 03 00 movb $0x0,(%ebx)
if (!last && p[1] == '\0')
112577: 31 d2 xor %edx,%edx
112579: 80 7b 01 00 cmpb $0x0,0x1(%ebx)
11257d: 0f 94 c2 sete %dl
112580: 89 d6 mov %edx,%esi
112582: e9 79 ff ff ff jmp 112500 <rtems_mkdir+0x54>
112587: 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) {
112588: e8 3f 29 00 00 call 114ecc <__errno>
11258d: 83 38 11 cmpl $0x11,(%eax)
112590: 74 0a je 11259c <rtems_mkdir+0xf0>
112592: e8 35 29 00 00 call 114ecc <__errno>
112597: 83 38 15 cmpl $0x15,(%eax)
11259a: 75 53 jne 1125ef <rtems_mkdir+0x143> <== ALWAYS TAKEN
if (stat(path, &sb) < 0) {
11259c: 83 ec 08 sub $0x8,%esp
11259f: 8d 45 a0 lea -0x60(%ebp),%eax
1125a2: 50 push %eax
1125a3: 57 push %edi
1125a4: e8 7f 00 00 00 call 112628 <stat>
1125a9: 83 c4 10 add $0x10,%esp
1125ac: 85 c0 test %eax,%eax
1125ae: 78 3f js 1125ef <rtems_mkdir+0x143> <== NEVER TAKEN
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
1125b0: 8b 45 ac mov -0x54(%ebp),%eax
1125b3: 25 00 f0 00 00 and $0xf000,%eax
1125b8: 3d 00 40 00 00 cmp $0x4000,%eax
1125bd: 0f 84 5b ff ff ff je 11251e <rtems_mkdir+0x72>
if (last)
1125c3: 85 f6 test %esi,%esi
1125c5: 74 53 je 11261a <rtems_mkdir+0x16e>
errno = EEXIST;
1125c7: e8 00 29 00 00 call 114ecc <__errno>
1125cc: c7 00 11 00 00 00 movl $0x11,(%eax)
1125d2: eb 2d jmp 112601 <rtems_mkdir+0x155>
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
}
return success != 0 ? 0 : -1;
1125d4: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
}
1125d9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1125dc: 5b pop %ebx <== NOT EXECUTED
1125dd: 5e pop %esi <== NOT EXECUTED
1125de: 5f pop %edi <== NOT EXECUTED
1125df: c9 leave <== NOT EXECUTED
1125e0: c3 ret <== NOT EXECUTED
1125e1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
1125e4: 8d 58 01 lea 0x1(%eax),%ebx
1125e7: 8a 50 01 mov 0x1(%eax),%dl
1125ea: e9 e8 fe ff ff jmp 1124d7 <rtems_mkdir+0x2b>
}
}
if (!last)
*p = '/';
}
if (!first && !last)
1125ef: 85 f6 test %esi,%esi
1125f1: 75 0e jne 112601 <rtems_mkdir+0x155> <== ALWAYS TAKEN
(void)umask(oumask);
1125f3: 83 ec 0c sub $0xc,%esp
1125f6: ff 75 94 pushl -0x6c(%ebp)
1125f9: e8 d2 00 00 00 call 1126d0 <umask>
1125fe: 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);
112601: 83 ec 0c sub $0xc,%esp
112604: 57 push %edi
112605: e8 02 6b ff ff call 10910c <free>
11260a: 83 c4 10 add $0x10,%esp
}
return success != 0 ? 0 : -1;
11260d: b8 ff ff ff ff mov $0xffffffff,%eax
}
112612: 8d 65 f4 lea -0xc(%ebp),%esp
112615: 5b pop %ebx
112616: 5e pop %esi
112617: 5f pop %edi
112618: c9 leave
112619: c3 ret
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
errno = EEXIST;
else
errno = ENOTDIR;
11261a: e8 ad 28 00 00 call 114ecc <__errno>
11261f: c7 00 14 00 00 00 movl $0x14,(%eax)
112625: eb cc jmp 1125f3 <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 60 74 12 00 push $0x127460
10b986: e8 b9 49 00 00 call 110344 <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 43 24 12 00 mov $0x122443,%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 54 1b 00 00 call 10ead4 <_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 <== NOT EXECUTED
10cfe9: eb d7 jmp 10cfc2 <rtems_object_get_class_information+0x62><== NOT EXECUTED
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 af 1b 00 00 call 10e0ec <_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 2c 30 12 00 mov 0x12302c(,%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 2c 19 00 00 call 10d2f8 <_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 cf 1a 00 00 call 10d4b0 <_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 18 9e 12 00 mov 0x129e18,%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 9f 1c 00 00 call 10d6ac <_Objects_Set_name>
_Thread_Enable_dispatch();
10ba0d: e8 36 26 00 00 call 10e048 <_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 10 22 14 00 mov 0x142210,%eax
116891: 40 inc %eax
116892: a3 10 22 14 00 mov %eax,0x142210
* 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 a0 20 14 00 push $0x1420a0
11689f: 89 55 e0 mov %edx,-0x20(%ebp)
1168a2: e8 49 45 00 00 call 11adf0 <_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 a2 2f 00 00 call 119884 <_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 bc 20 14 00 mov 0x1420bc,%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 97 54 00 00 call 11bd98 <_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 87 54 00 00 call 11bd98 <_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 a0 20 14 00 push $0x1420a0
1169a4: e8 3b 49 00 00 call 11b2e4 <_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 9f 2e 00 00 call 119860 <_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 c5 53 00 00 call 11bd98 <_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 97 53 00 00 call 11bd98 <_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 a0 20 14 00 push $0x1420a0
116a43: e8 9c 48 00 00 call 11b2e4 <_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 97 2d 00 00 call 119824 <_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 03 53 00 00 call 11bd98 <_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 ef 52 00 00 call 11bd98 <_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 10 22 14 00 mov 0x142210,%eax
115e99: 40 inc %eax
115e9a: a3 10 22 14 00 mov %eax,0x142210
*/
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 60 20 14 00 push $0x142060
115ea7: 89 55 e4 mov %edx,-0x1c(%ebp)
115eaa: e8 41 4f 00 00 call 11adf0 <_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 7c 20 14 00 mov 0x14207c,%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 b9 5e 00 00 call 11bd98 <_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 a7 5e 00 00 call 11bd98 <_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 60 20 14 00 push $0x142060
115f0a: e8 d5 53 00 00 call 11b2e4 <_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 60 20 14 00 push $0x142060
115f22: 89 45 e4 mov %eax,-0x1c(%ebp)
115f25: e8 42 4f 00 00 call 11ae6c <_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 60 20 14 00 push $0x142060
115f35: e8 2e 52 00 00 call 11b168 <_Objects_Free>
_Dual_ported_memory_Free( the_port );
_Thread_Enable_dispatch();
115f3a: e8 59 5e 00 00 call 11bd98 <_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 60 20 14 00 push $0x142060
115f6f: e8 70 53 00 00 call 11b2e4 <_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 f8 5d 00 00 call 11bd98 <_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 60 20 14 00 push $0x142060
115fff: e8 e0 52 00 00 call 11b2e4 <_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 68 5d 00 00 call 11bd98 <_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 0b 12 00 push $0x120bd3
1078a7: 53 push %ebx
1078a8: e8 5f c6 00 00 call 113f0c <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 34 54 12 00 mov 0x125434,%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 0b 12 00 push $0x120bdb
1078ef: 53 push %ebx
1078f0: e8 17 c6 00 00 call 113f0c <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 0b 12 00 push $0x120bd3
107983: 53 push %ebx
107984: e8 83 c5 00 00 call 113f0c <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 34 54 12 00 mov 0x125434,%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 0b 12 00 push $0x120bdb
107a0f: 53 push %ebx
107a10: e8 f7 c4 00 00 call 113f0c <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 e0 20 14 00 push $0x1420e0
116acb: e8 14 48 00 00 call 11b2e4 <_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 f8 27 14 00 mov 0x1427f8,%eax
116aed: 39 43 40 cmp %eax,0x40(%ebx)
116af0: 74 12 je 116b04 <rtems_rate_monotonic_cancel+0x4c>
_Thread_Enable_dispatch();
116af2: e8 a1 52 00 00 call 11bd98 <_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 60 64 00 00 call 11cf70 <_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 7c 52 00 00 call 11bd98 <_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 d0 a8 12 00 mov 0x12a8d0,%eax
10c364: 40 inc %eax
10c365: a3 d0 a8 12 00 mov %eax,0x12a8d0
* 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 e0 a7 12 00 push $0x12a7e0
10c372: e8 25 1f 00 00 call 10e29c <_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 b8 ae 12 00 mov 0x12aeb8,%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 fc a7 12 00 mov 0x12a7fc,%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 fa 2e 00 00 call 10f2f0 <_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 db 2e 00 00 call 10f2f0 <_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
001128d0 <rtems_rate_monotonic_get_status>:
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
1128d0: 55 push %ebp
1128d1: 89 e5 mov %esp,%ebp
1128d3: 53 push %ebx
1128d4: 83 ec 24 sub $0x24,%esp
1128d7: 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 )
1128da: 85 db test %ebx,%ebx
1128dc: 0f 84 92 00 00 00 je 112974 <rtems_rate_monotonic_get_status+0xa4>
1128e2: 50 push %eax
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
1128e3: 8d 45 f4 lea -0xc(%ebp),%eax
1128e6: 50 push %eax
1128e7: ff 75 08 pushl 0x8(%ebp)
1128ea: 68 e0 a7 12 00 push $0x12a7e0
1128ef: e8 48 bf ff ff call 10e83c <_Objects_Get>
switch ( location ) {
1128f4: 83 c4 10 add $0x10,%esp
1128f7: 8b 4d f4 mov -0xc(%ebp),%ecx
1128fa: 85 c9 test %ecx,%ecx
1128fc: 74 0a je 112908 <rtems_rate_monotonic_get_status+0x38>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1128fe: b8 04 00 00 00 mov $0x4,%eax
}
112903: 8b 5d fc mov -0x4(%ebp),%ebx
112906: c9 leave
112907: c3 ret
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
112908: 8b 50 40 mov 0x40(%eax),%edx
11290b: 8b 52 08 mov 0x8(%edx),%edx
11290e: 89 13 mov %edx,(%ebx)
status->state = the_period->state;
112910: 8b 50 38 mov 0x38(%eax),%edx
112913: 89 53 04 mov %edx,0x4(%ebx)
/*
* If the period is inactive, there is no information.
*/
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
112916: 85 d2 test %edx,%edx
112918: 75 2a jne 112944 <rtems_rate_monotonic_get_status+0x74>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timespec_Set_to_zero( &status->since_last_period );
11291a: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
112921: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
_Timespec_Set_to_zero( &status->executed_since_last_period );
112928: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
11292f: 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();
112936: e8 b5 c9 ff ff call 10f2f0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11293b: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11293d: 8b 5d fc mov -0x4(%ebp),%ebx
112940: c9 leave
112941: c3 ret
112942: 66 90 xchg %ax,%ax
} else {
/*
* Grab the current status.
*/
valid_status =
112944: 52 push %edx
_Rate_monotonic_Get_status(
112945: 8d 55 ec lea -0x14(%ebp),%edx
} else {
/*
* Grab the current status.
*/
valid_status =
112948: 52 push %edx
_Rate_monotonic_Get_status(
112949: 8d 55 e4 lea -0x1c(%ebp),%edx
} else {
/*
* Grab the current status.
*/
valid_status =
11294c: 52 push %edx
11294d: 50 push %eax
11294e: e8 05 9b ff ff call 10c458 <_Rate_monotonic_Get_status>
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
112953: 83 c4 10 add $0x10,%esp
112956: 84 c0 test %al,%al
112958: 74 26 je 112980 <rtems_rate_monotonic_get_status+0xb0>
_Thread_Enable_dispatch();
return RTEMS_NOT_DEFINED;
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec(
11295a: 8b 45 e4 mov -0x1c(%ebp),%eax
11295d: 8b 55 e8 mov -0x18(%ebp),%edx
112960: 89 43 08 mov %eax,0x8(%ebx)
112963: 89 53 0c mov %edx,0xc(%ebx)
&since_last_period, &status->since_last_period
);
_Timestamp_To_timespec(
112966: 8b 45 ec mov -0x14(%ebp),%eax
112969: 8b 55 f0 mov -0x10(%ebp),%edx
11296c: 89 43 10 mov %eax,0x10(%ebx)
11296f: 89 53 14 mov %edx,0x14(%ebx)
112972: eb c2 jmp 112936 <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;
112974: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112979: 8b 5d fc mov -0x4(%ebp),%ebx
11297c: c9 leave
11297d: c3 ret
11297e: 66 90 xchg %ax,%ax
valid_status =
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
_Thread_Enable_dispatch();
112980: e8 6b c9 ff ff call 10f2f0 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
112985: b8 0b 00 00 00 mov $0xb,%eax
11298a: e9 74 ff ff ff jmp 112903 <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 e0 a7 12 00 push $0x12a7e0
10c66d: e8 ca 21 00 00 call 10e83c <_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 b8 ae 12 00 mov 0x12aeb8,%edx
10c692: 39 50 40 cmp %edx,0x40(%eax)
10c695: 74 15 je 10c6ac <rtems_rate_monotonic_period+0x58>
_Thread_Enable_dispatch();
10c697: e8 54 2c 00 00 call 10f2f0 <_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 dc 34 12 00 mov 0x1234dc(,%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 29 2c 00 00 call 10f2f0 <_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 dc a9 12 00 push $0x12a9dc
10c70d: e8 e6 3a 00 00 call 1101f8 <_Watchdog_Insert>
_Thread_Enable_dispatch();
10c712: e8 d9 2b 00 00 call 10f2f0 <_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 dc a9 12 00 push $0x12a9dc
10c769: e8 8a 3a 00 00 call 1101f8 <_Watchdog_Insert>
_Thread_Enable_dispatch();
10c76e: e8 7d 2b 00 00 call 10f2f0 <_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 b8 ae 12 00 mov 0x12aeb8,%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 a0 33 00 00 call 10fb54 <_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 1d 2b 00 00 call 10f2f0 <_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 b8 ae 12 00 pushl 0x12aeb8
10c7e7: e8 84 27 00 00 call 10ef70 <_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 f0 34 12 00 push $0x1234f0
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 28 35 12 00 push $0x123528
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 4c 35 12 00 push $0x12354c
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 70 35 12 00 push $0x123570
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 bc 35 12 00 push $0x1235bc
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 e8 a7 12 00 mov 0x12a7e8,%ebx
10c84c: 83 c4 10 add $0x10,%esp
10c84f: 3b 1d ec a7 12 00 cmp 0x12a7ec,%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 ec a7 12 00 cmp %ebx,0x12a7ec
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 b5 5f 00 00 call 112824 <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 4d 60 00 00 call 1128d0 <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 0e 35 12 00 push $0x12350e
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 f9 15 12 00 push $0x1215f9
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 ec a7 12 00 cmp %ebx,0x12a7ec
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 75 35 00 00 call 10fe58 <_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 08 36 12 00 push $0x123608
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 eb 34 00 00 call 10fe58 <_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 28 36 12 00 push $0x123628
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 d0 a8 12 00 mov 0x12a8d0,%eax
10ca0c: 40 inc %eax
10ca0d: a3 d0 a8 12 00 mov %eax,0x12a8d0
/*
* 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 e8 a7 12 00 mov 0x12a7e8,%ebx
10ca18: 3b 1d ec a7 12 00 cmp 0x12a7ec,%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 ec a7 12 00 cmp %ebx,0x12a7ec
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 b2 28 00 00 jmp 10f2f0 <_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 e0 a7 12 00 push $0x12a7e0
10ca54: e8 e3 1d 00 00 call 10e83c <_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 5c 28 00 00 call 10f2f0 <_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 fc 22 14 00 pushl 0x1422fc
11727f: e8 28 25 00 00 call 1197ac <_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 20 21 14 00 movl $0x142120,(%esp)
11728b: e8 60 3b 00 00 call 11adf0 <_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 4f 37 00 00 call 11a9fc <_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 f3 51 00 00 call 11c4dc <_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 3c 21 14 00 mov 0x14213c,%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 fc 22 14 00 pushl 0x1422fc
11730e: 89 45 e4 mov %eax,-0x1c(%ebp)
117311: e8 de 24 00 00 call 1197f4 <_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 20 21 14 00 push $0x142120
11733d: e8 26 3e 00 00 call 11b168 <_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 fc 22 14 00 pushl 0x1422fc
117371: e8 36 24 00 00 call 1197ac <_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 20 21 14 00 push $0x142120
117385: e8 1e 3f 00 00 call 11b2a8 <_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 fc 22 14 00 pushl 0x1422fc
1173a2: e8 4d 24 00 00 call 1197f4 <_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 20 21 14 00 push $0x142120
1173c9: 89 45 e4 mov %eax,-0x1c(%ebp)
1173cc: e8 9b 3a 00 00 call 11ae6c <_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 20 21 14 00 push $0x142120
1173dc: e8 87 3d 00 00 call 11b168 <_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 fc 22 14 00 pushl 0x1422fc
117400: e8 a7 23 00 00 call 1197ac <_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 20 21 14 00 push $0x142120
117414: e8 8f 3e 00 00 call 11b2a8 <_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 fc 22 14 00 pushl 0x1422fc
117433: e8 bc 23 00 00 call 1197f4 <_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 9b 2f 00 00 call 11a3f0 <_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 fc 22 14 00 pushl 0x1422fc
11749b: e8 0c 23 00 00 call 1197ac <_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 20 21 14 00 push $0x142120
1174af: e8 f4 3d 00 00 call 11b2a8 <_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 fc 22 14 00 pushl 0x1422fc
1174cc: e8 23 23 00 00 call 1197f4 <_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 da 32 00 00 call 11a7d8 <_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 fc 22 14 00 pushl 0x1422fc
1175c5: e8 e2 21 00 00 call 1197ac <_API_Mutex_Lock>
executing = _Thread_Executing;
1175ca: a1 f8 27 14 00 mov 0x1427f8,%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 20 21 14 00 push $0x142120
1175e1: e8 c2 3c 00 00 call 11b2a8 <_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 fc 22 14 00 pushl 0x1422fc
117605: 89 45 d0 mov %eax,-0x30(%ebp)
117608: e8 e7 21 00 00 call 1197f4 <_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 ea 2b 00 00 call 11a21c <_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 10 22 14 00 mov 0x142210,%eax
117662: 40 inc %eax
117663: a3 10 22 14 00 mov %eax,0x142210
* 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 fc 22 14 00 pushl 0x1422fc
117671: e8 7e 21 00 00 call 1197f4 <_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 a0 c5 11 00 push $0x11c5a0
11769a: ff 75 14 pushl 0x14(%ebp)
11769d: 50 push %eax
11769e: e8 d1 4b 00 00 call 11c274 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
1176a3: e8 f0 46 00 00 call 11bd98 <_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 fc 22 14 00 pushl 0x1422fc
117788: e8 1f 20 00 00 call 1197ac <_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 20 21 14 00 push $0x142120
11779c: e8 07 3b 00 00 call 11b2a8 <_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 fc 22 14 00 pushl 0x1422fc
1177b6: e8 39 20 00 00 call 1197f4 <_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 1e 34 00 00 call 11ac04 <_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 b5 7c 00 00 call 11f4b0 <_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 fc 22 14 00 pushl 0x1422fc
11781d: 89 45 e4 mov %eax,-0x1c(%ebp)
117820: e8 cf 1f 00 00 call 1197f4 <_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 fc 22 14 00 pushl 0x1422fc
11784d: e8 5a 1f 00 00 call 1197ac <_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 20 21 14 00 push $0x142120
117861: e8 42 3a 00 00 call 11b2a8 <_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 07 2e 00 00 call 11a688 <_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 fc 22 14 00 pushl 0x1422fc
11789e: e8 51 1f 00 00 call 1197f4 <_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 f4 7b 00 00 call 11f4b0 <_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 70 75 12 00 mov 0x127570,%eax
10b4b0: 40 inc %eax
10b4b1: a3 70 75 12 00 mov %eax,0x127570
* 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 c0 74 12 00 push $0x1274c0
10b4be: 89 4d c4 mov %ecx,-0x3c(%ebp)
10b4c1: e8 c2 14 00 00 call 10c988 <_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 69 0c 00 00 call 10c180 <_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 dc 74 12 00 mov 0x1274dc,%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 b5 23 00 00 call 10d8f4 <_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 88 0e 00 00 call 10c410 <_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 5f 23 00 00 call 10d8f4 <_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 c0 74 12 00 push $0x1274c0
10b5d8: e8 23 17 00 00 call 10cd00 <_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 12 23 00 00 call 10d8f4 <_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 c0 74 12 00 push $0x1274c0
10b61f: e8 1c 18 00 00 call 10ce40 <_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 9f 22 00 00 call 10d8f4 <_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 06 0b 00 00 call 10c174 <_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 c0 74 12 00 push $0x1274c0
10b67a: e8 85 13 00 00 call 10ca04 <_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 c0 74 12 00 push $0x1274c0
10b687: e8 74 16 00 00 call 10cd00 <_Objects_Free>
0, /* Not used */
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
10b68c: e8 63 22 00 00 call 10d8f4 <_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 5a 0d 00 00 call 10c404 <_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 c0 74 12 00 push $0x1274c0
10b6d0: e8 13 17 00 00 call 10cde8 <_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 6e 0b 00 00 call 10c278 <_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 58 7b 12 00 mov 0x127b58,%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 58 7b 12 00 mov 0x127b58,%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 58 7b 12 00 mov 0x127b58,%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 70 75 12 00 mov 0x127570,%ecx
10b77a: 41 inc %ecx
10b77b: 89 0d 70 75 12 00 mov %ecx,0x127570
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 fc e0 10 00 push $0x10e0fc
10b79b: 57 push %edi
10b79c: 50 push %eax
10b79d: e8 2e 26 00 00 call 10ddd0 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10b7a2: e8 4d 21 00 00 call 10d8f4 <_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 c0 74 12 00 push $0x1274c0
10b7c0: e8 7b 16 00 00 call 10ce40 <_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 61 0c 00 00 call 10c450 <_CORE_semaphore_Surrender>
10b7ef: 89 c3 mov %eax,%ebx
&the_semaphore->Core_control.semaphore,
id,
MUTEX_MP_SUPPORT
);
_Thread_Enable_dispatch();
10b7f1: e8 fe 20 00 00 call 10d8f4 <_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 03 0b 00 00 call 10c318 <_CORE_mutex_Surrender>
10b815: 89 c3 mov %eax,%ebx
&the_semaphore->Core_control.mutex,
id,
MUTEX_MP_SUPPORT
);
_Thread_Enable_dispatch();
10b817: e8 d8 20 00 00 call 10d8f4 <_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 35 40 00 00 call 11bdbc <_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 f4 27 14 00 mov 0x1427f4,%edx
117dbd: 85 d2 test %edx,%edx
117dbf: 74 1b je 117ddc <rtems_signal_send+0x7c>
117dc1: 3b 05 f8 27 14 00 cmp 0x1427f8,%eax
117dc7: 75 13 jne 117ddc <rtems_signal_send+0x7c><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
117dc9: c6 05 04 28 14 00 01 movb $0x1,0x142804
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 b7 3f 00 00 call 11bd98 <_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 ab 3f 00 00 call 11bd98 <_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 a0 a0 12 00 mov $0x12a0a0,%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 98 a8 12 00 mov 0x12a898,%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 48 9d 12 00 mov 0x129d48,%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 a0 a0 12 00 mov $0x12a0a0,%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 48 9d 12 00 mov 0x129d48,%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 98 a8 12 00 pushl 0x12a898 <== 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 40 9d 12 00 mov %esi,0x129d40 <== NOT EXECUTED
print_handler = print;
1081b5: 89 1d 44 9d 12 00 mov %ebx,0x129d44 <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
1081bb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
1081be: 68 c8 35 12 00 push $0x1235c8 <== 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 4c 36 12 00 push $0x12364c <== 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 64 70 00 00 call 10f240 <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 40 9d 12 00 00 movl $0x0,0x129d40 <== NOT EXECUTED
1081ef: 00 00 00
print_handler = NULL;
1081f2: c7 05 44 9d 12 00 00 movl $0x0,0x129d44 <== 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 a0 a0 12 00 mov $0x12a0a0,%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 a0 a0 12 00 mov $0x12a0a0,%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
00110b40 <rtems_string_to_double>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
110b40: 55 push %ebp
110b41: 89 e5 mov %esp,%ebp
110b43: 57 push %edi
110b44: 56 push %esi
110b45: 53 push %ebx
110b46: 83 ec 2c sub $0x2c,%esp
110b49: 8b 75 08 mov 0x8(%ebp),%esi
110b4c: 8b 5d 0c mov 0xc(%ebp),%ebx
110b4f: 8b 7d 10 mov 0x10(%ebp),%edi
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
110b52: 85 db test %ebx,%ebx
110b54: 74 72 je 110bc8 <rtems_string_to_double+0x88>
return RTEMS_INVALID_ADDRESS;
errno = 0;
110b56: e8 f9 2e 00 00 call 113a54 <__errno>
110b5b: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
110b61: c7 03 00 00 00 00 movl $0x0,(%ebx)
110b67: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
110b6e: 83 ec 08 sub $0x8,%esp
110b71: 8d 45 e4 lea -0x1c(%ebp),%eax
110b74: 50 push %eax
110b75: 56 push %esi
110b76: e8 dd 58 00 00 call 116458 <strtod>
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
110b7b: 83 c4 10 add $0x10,%esp
110b7e: 85 ff test %edi,%edi
110b80: 74 56 je 110bd8 <rtems_string_to_double+0x98>
*endptr = end;
110b82: 8b 45 e4 mov -0x1c(%ebp),%eax
110b85: 89 07 mov %eax,(%edi)
/* nothing was converted */
if ( end == s )
110b87: 39 c6 cmp %eax,%esi
110b89: 74 55 je 110be0 <rtems_string_to_double+0xa0>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
110b8b: dd 05 30 58 12 00 fldl 0x125830
110b91: d9 c9 fxch %st(1)
110b93: dd e1 fucom %st(1)
110b95: df e0 fnstsw %ax
110b97: dd d9 fstp %st(1)
110b99: f6 c4 45 test $0x45,%ah
110b9c: 74 0e je 110bac <rtems_string_to_double+0x6c>
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
110b9e: dd 1b fstpl (%ebx)
#endif
return RTEMS_SUCCESSFUL;
110ba0: 31 c0 xor %eax,%eax
}
110ba2: 8d 65 f4 lea -0xc(%ebp),%esp
110ba5: 5b pop %ebx
110ba6: 5e pop %esi
110ba7: 5f pop %edi
110ba8: c9 leave
110ba9: c3 ret
110baa: 66 90 xchg %ax,%ax
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
110bac: dd 5d c8 fstpl -0x38(%ebp)
110baf: e8 a0 2e 00 00 call 113a54 <__errno>
110bb4: 83 38 22 cmpl $0x22,(%eax)
110bb7: dd 45 c8 fldl -0x38(%ebp)
110bba: 75 e2 jne 110b9e <rtems_string_to_double+0x5e><== NEVER TAKEN
110bbc: dd d8 fstp %st(0)
return RTEMS_INVALID_NUMBER;
110bbe: b8 0a 00 00 00 mov $0xa,%eax
110bc3: eb dd jmp 110ba2 <rtems_string_to_double+0x62>
110bc5: 8d 76 00 lea 0x0(%esi),%esi
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
110bc8: b8 09 00 00 00 mov $0x9,%eax
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
#endif
return RTEMS_SUCCESSFUL;
}
110bcd: 8d 65 f4 lea -0xc(%ebp),%esp
110bd0: 5b pop %ebx
110bd1: 5e pop %esi
110bd2: 5f pop %edi
110bd3: c9 leave
110bd4: c3 ret
110bd5: 8d 76 00 lea 0x0(%esi),%esi
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
110bd8: 8b 45 e4 mov -0x1c(%ebp),%eax
110bdb: eb aa jmp 110b87 <rtems_string_to_double+0x47>
110bdd: 8d 76 00 lea 0x0(%esi),%esi
110be0: dd d8 fstp %st(0)
*endptr = end;
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
110be2: b8 0b 00 00 00 mov $0xb,%eax
110be7: eb b9 jmp 110ba2 <rtems_string_to_double+0x62>
00110bec <rtems_string_to_float>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
110bec: 55 push %ebp
110bed: 89 e5 mov %esp,%ebp
110bef: 57 push %edi
110bf0: 56 push %esi
110bf1: 53 push %ebx
110bf2: 83 ec 2c sub $0x2c,%esp
110bf5: 8b 75 08 mov 0x8(%ebp),%esi
110bf8: 8b 5d 0c mov 0xc(%ebp),%ebx
110bfb: 8b 7d 10 mov 0x10(%ebp),%edi
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
110bfe: 85 db test %ebx,%ebx
110c00: 74 6a je 110c6c <rtems_string_to_float+0x80>
return RTEMS_INVALID_ADDRESS;
errno = 0;
110c02: e8 4d 2e 00 00 call 113a54 <__errno>
110c07: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
110c0d: c7 03 00 00 00 00 movl $0x0,(%ebx)
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
110c13: 83 ec 08 sub $0x8,%esp
110c16: 8d 45 e4 lea -0x1c(%ebp),%eax
110c19: 50 push %eax
110c1a: 56 push %esi
110c1b: e8 54 58 00 00 call 116474 <strtof>
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
110c20: 83 c4 10 add $0x10,%esp
110c23: 85 ff test %edi,%edi
110c25: 74 55 je 110c7c <rtems_string_to_float+0x90>
*endptr = end;
110c27: 8b 45 e4 mov -0x1c(%ebp),%eax
110c2a: 89 07 mov %eax,(%edi)
/* nothing was converted */
if ( end == s )
110c2c: 39 c6 cmp %eax,%esi
110c2e: 74 54 je 110c84 <rtems_string_to_float+0x98>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
110c30: d9 05 38 58 12 00 flds 0x125838
110c36: d9 c9 fxch %st(1)
110c38: dd e1 fucom %st(1)
110c3a: df e0 fnstsw %ax
110c3c: dd d9 fstp %st(1)
110c3e: f6 c4 45 test $0x45,%ah
110c41: 74 0d je 110c50 <rtems_string_to_float+0x64>
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
110c43: d9 1b fstps (%ebx)
#endif
return RTEMS_SUCCESSFUL;
110c45: 31 c0 xor %eax,%eax
}
110c47: 8d 65 f4 lea -0xc(%ebp),%esp
110c4a: 5b pop %ebx
110c4b: 5e pop %esi
110c4c: 5f pop %edi
110c4d: c9 leave
110c4e: c3 ret
110c4f: 90 nop
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
110c50: d9 5d c8 fstps -0x38(%ebp)
110c53: e8 fc 2d 00 00 call 113a54 <__errno>
110c58: 83 38 22 cmpl $0x22,(%eax)
110c5b: d9 45 c8 flds -0x38(%ebp)
110c5e: 75 e3 jne 110c43 <rtems_string_to_float+0x57><== NEVER TAKEN
110c60: dd d8 fstp %st(0)
return RTEMS_INVALID_NUMBER;
110c62: b8 0a 00 00 00 mov $0xa,%eax
110c67: eb de jmp 110c47 <rtems_string_to_float+0x5b>
110c69: 8d 76 00 lea 0x0(%esi),%esi
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
110c6c: b8 09 00 00 00 mov $0x9,%eax
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
#endif
return RTEMS_SUCCESSFUL;
}
110c71: 8d 65 f4 lea -0xc(%ebp),%esp
110c74: 5b pop %ebx
110c75: 5e pop %esi
110c76: 5f pop %edi
110c77: c9 leave
110c78: c3 ret
110c79: 8d 76 00 lea 0x0(%esi),%esi
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
110c7c: 8b 45 e4 mov -0x1c(%ebp),%eax
110c7f: eb ab jmp 110c2c <rtems_string_to_float+0x40>
110c81: 8d 76 00 lea 0x0(%esi),%esi
110c84: dd d8 fstp %st(0)
*endptr = end;
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
110c86: b8 0b 00 00 00 mov $0xb,%eax
110c8b: eb ba jmp 110c47 <rtems_string_to_float+0x5b>
00110c90 <rtems_string_to_int>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
110c90: 55 push %ebp
110c91: 89 e5 mov %esp,%ebp
110c93: 57 push %edi
110c94: 56 push %esi
110c95: 53 push %ebx
110c96: 83 ec 2c sub $0x2c,%esp
110c99: 8b 75 08 mov 0x8(%ebp),%esi
110c9c: 8b 5d 0c mov 0xc(%ebp),%ebx
110c9f: 8b 7d 10 mov 0x10(%ebp),%edi
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
110ca2: 85 db test %ebx,%ebx
110ca4: 74 5e je 110d04 <rtems_string_to_int+0x74>
return RTEMS_INVALID_ADDRESS;
errno = 0;
110ca6: e8 a9 2d 00 00 call 113a54 <__errno>
110cab: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
110cb1: c7 03 00 00 00 00 movl $0x0,(%ebx)
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
#elif defined(STRING_TO_POINTER)
result = STRING_TO_METHOD( s, &end, 16 );
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
110cb7: 50 push %eax
110cb8: ff 75 14 pushl 0x14(%ebp)
110cbb: 8d 45 e4 lea -0x1c(%ebp),%eax
110cbe: 50 push %eax
110cbf: 56 push %esi
110cc0: e8 6f 59 00 00 call 116634 <strtol>
110cc5: 89 c2 mov %eax,%edx
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
110cc7: 83 c4 10 add $0x10,%esp
110cca: 85 ff test %edi,%edi
110ccc: 74 46 je 110d14 <rtems_string_to_int+0x84>
*endptr = end;
110cce: 8b 45 e4 mov -0x1c(%ebp),%eax
110cd1: 89 07 mov %eax,(%edi)
/* nothing was converted */
if ( end == s )
110cd3: 39 c6 cmp %eax,%esi
110cd5: 74 45 je 110d1c <rtems_string_to_int+0x8c>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
110cd7: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx
110cdd: 74 0d je 110cec <rtems_string_to_int+0x5c>
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
110cdf: 89 13 mov %edx,(%ebx)
#endif
return RTEMS_SUCCESSFUL;
110ce1: 31 c0 xor %eax,%eax
}
110ce3: 8d 65 f4 lea -0xc(%ebp),%esp
110ce6: 5b pop %ebx
110ce7: 5e pop %esi
110ce8: 5f pop %edi
110ce9: c9 leave
110cea: c3 ret
110ceb: 90 nop
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
110cec: 89 55 d4 mov %edx,-0x2c(%ebp)
110cef: e8 60 2d 00 00 call 113a54 <__errno>
110cf4: 83 38 22 cmpl $0x22,(%eax)
110cf7: 8b 55 d4 mov -0x2c(%ebp),%edx
110cfa: 75 e3 jne 110cdf <rtems_string_to_int+0x4f>
return RTEMS_INVALID_NUMBER;
110cfc: b8 0a 00 00 00 mov $0xa,%eax
110d01: eb e0 jmp 110ce3 <rtems_string_to_int+0x53>
110d03: 90 nop
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
110d04: b8 09 00 00 00 mov $0x9,%eax
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
#endif
return RTEMS_SUCCESSFUL;
}
110d09: 8d 65 f4 lea -0xc(%ebp),%esp
110d0c: 5b pop %ebx
110d0d: 5e pop %esi
110d0e: 5f pop %edi
110d0f: c9 leave
110d10: c3 ret
110d11: 8d 76 00 lea 0x0(%esi),%esi
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
110d14: 8b 45 e4 mov -0x1c(%ebp),%eax
110d17: eb ba jmp 110cd3 <rtems_string_to_int+0x43>
110d19: 8d 76 00 lea 0x0(%esi),%esi
*endptr = end;
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
110d1c: b8 0b 00 00 00 mov $0xb,%eax
110d21: eb c0 jmp 110ce3 <rtems_string_to_int+0x53>
00110dd4 <rtems_string_to_long>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
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 1c sub $0x1c,%esp
110ddd: 8b 7d 08 mov 0x8(%ebp),%edi
110de0: 8b 5d 0c mov 0xc(%ebp),%ebx
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
110de3: 85 db test %ebx,%ebx
110de5: 74 69 je 110e50 <rtems_string_to_long+0x7c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
110de7: e8 68 2c 00 00 call 113a54 <__errno>
110dec: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
110df2: c7 03 00 00 00 00 movl $0x0,(%ebx)
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
#elif defined(STRING_TO_POINTER)
result = STRING_TO_METHOD( s, &end, 16 );
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
110df8: 52 push %edx
110df9: ff 75 14 pushl 0x14(%ebp)
110dfc: 8d 45 e4 lea -0x1c(%ebp),%eax
110dff: 50 push %eax
110e00: 57 push %edi
110e01: e8 2e 58 00 00 call 116634 <strtol>
110e06: 89 c6 mov %eax,%esi
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
110e08: 83 c4 10 add $0x10,%esp
110e0b: 8b 45 10 mov 0x10(%ebp),%eax
110e0e: 85 c0 test %eax,%eax
110e10: 74 4e je 110e60 <rtems_string_to_long+0x8c>
*endptr = end;
110e12: 8b 45 e4 mov -0x1c(%ebp),%eax
110e15: 8b 55 10 mov 0x10(%ebp),%edx
110e18: 89 02 mov %eax,(%edx)
/* nothing was converted */
if ( end == s )
110e1a: 39 c7 cmp %eax,%edi
110e1c: 74 4a je 110e68 <rtems_string_to_long+0x94>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
110e1e: 81 fe ff ff ff 7f cmp $0x7fffffff,%esi
110e24: 74 16 je 110e3c <rtems_string_to_long+0x68>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MIN
/* there was an underflow */
if ( (result == STRING_TO_MIN) && (errno == ERANGE))
110e26: 81 fe 00 00 00 80 cmp $0x80000000,%esi
110e2c: 74 0e je 110e3c <rtems_string_to_long+0x68>
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
110e2e: 89 33 mov %esi,(%ebx)
#endif
return RTEMS_SUCCESSFUL;
110e30: 31 c0 xor %eax,%eax
}
110e32: 8d 65 f4 lea -0xc(%ebp),%esp
110e35: 5b pop %ebx
110e36: 5e pop %esi
110e37: 5f pop %edi
110e38: c9 leave
110e39: c3 ret
110e3a: 66 90 xchg %ax,%ax
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MIN
/* there was an underflow */
if ( (result == STRING_TO_MIN) && (errno == ERANGE))
110e3c: e8 13 2c 00 00 call 113a54 <__errno>
110e41: 83 38 22 cmpl $0x22,(%eax)
110e44: 75 e8 jne 110e2e <rtems_string_to_long+0x5a>
return RTEMS_INVALID_NUMBER;
110e46: b8 0a 00 00 00 mov $0xa,%eax
110e4b: eb e5 jmp 110e32 <rtems_string_to_long+0x5e>
110e4d: 8d 76 00 lea 0x0(%esi),%esi
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
110e50: b8 09 00 00 00 mov $0x9,%eax
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
#endif
return RTEMS_SUCCESSFUL;
}
110e55: 8d 65 f4 lea -0xc(%ebp),%esp
110e58: 5b pop %ebx
110e59: 5e pop %esi
110e5a: 5f pop %edi
110e5b: c9 leave
110e5c: c3 ret
110e5d: 8d 76 00 lea 0x0(%esi),%esi
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
110e60: 8b 45 e4 mov -0x1c(%ebp),%eax
110e63: eb b5 jmp 110e1a <rtems_string_to_long+0x46>
110e65: 8d 76 00 lea 0x0(%esi),%esi
*endptr = end;
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
110e68: b8 0b 00 00 00 mov $0xb,%eax
110e6d: eb c3 jmp 110e32 <rtems_string_to_long+0x5e>
00110d24 <rtems_string_to_long_long>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
110d24: 55 push %ebp
110d25: 89 e5 mov %esp,%ebp
110d27: 57 push %edi
110d28: 56 push %esi
110d29: 53 push %ebx
110d2a: 83 ec 2c sub $0x2c,%esp
110d2d: 8b 5d 0c mov 0xc(%ebp),%ebx
110d30: 8b 7d 10 mov 0x10(%ebp),%edi
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
110d33: 85 db test %ebx,%ebx
110d35: 74 7d je 110db4 <rtems_string_to_long_long+0x90>
return RTEMS_INVALID_ADDRESS;
errno = 0;
110d37: e8 18 2d 00 00 call 113a54 <__errno>
110d3c: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
110d42: c7 03 00 00 00 00 movl $0x0,(%ebx)
110d48: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
#elif defined(STRING_TO_POINTER)
result = STRING_TO_METHOD( s, &end, 16 );
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
110d4f: 50 push %eax
110d50: ff 75 14 pushl 0x14(%ebp)
110d53: 8d 45 e4 lea -0x1c(%ebp),%eax
110d56: 50 push %eax
110d57: ff 75 08 pushl 0x8(%ebp)
110d5a: e8 f1 58 00 00 call 116650 <strtoll>
110d5f: 89 c6 mov %eax,%esi
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
110d61: 83 c4 10 add $0x10,%esp
110d64: 85 ff test %edi,%edi
110d66: 74 5c je 110dc4 <rtems_string_to_long_long+0xa0>
*endptr = end;
110d68: 8b 45 e4 mov -0x1c(%ebp),%eax
110d6b: 89 07 mov %eax,(%edi)
/* nothing was converted */
if ( end == s )
110d6d: 39 45 08 cmp %eax,0x8(%ebp)
110d70: 74 5a je 110dcc <rtems_string_to_long_long+0xa8>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
110d72: 89 d1 mov %edx,%ecx
110d74: 81 f1 ff ff ff 7f xor $0x7fffffff,%ecx
110d7a: 89 f0 mov %esi,%eax
110d7c: f7 d0 not %eax
110d7e: 09 c1 or %eax,%ecx
110d80: 74 1a je 110d9c <rtems_string_to_long_long+0x78>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MIN
/* there was an underflow */
if ( (result == STRING_TO_MIN) && (errno == ERANGE))
110d82: 8d 82 00 00 00 80 lea -0x80000000(%edx),%eax
110d88: 09 f0 or %esi,%eax
110d8a: 74 10 je 110d9c <rtems_string_to_long_long+0x78>
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
110d8c: 89 33 mov %esi,(%ebx)
110d8e: 89 53 04 mov %edx,0x4(%ebx)
#endif
return RTEMS_SUCCESSFUL;
110d91: 31 c0 xor %eax,%eax
}
110d93: 8d 65 f4 lea -0xc(%ebp),%esp
110d96: 5b pop %ebx
110d97: 5e pop %esi
110d98: 5f pop %edi
110d99: c9 leave
110d9a: c3 ret
110d9b: 90 nop
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MIN
/* there was an underflow */
if ( (result == STRING_TO_MIN) && (errno == ERANGE))
110d9c: 89 55 d4 mov %edx,-0x2c(%ebp)
110d9f: e8 b0 2c 00 00 call 113a54 <__errno>
110da4: 83 38 22 cmpl $0x22,(%eax)
110da7: 8b 55 d4 mov -0x2c(%ebp),%edx
110daa: 75 e0 jne 110d8c <rtems_string_to_long_long+0x68>
return RTEMS_INVALID_NUMBER;
110dac: b8 0a 00 00 00 mov $0xa,%eax
110db1: eb e0 jmp 110d93 <rtems_string_to_long_long+0x6f>
110db3: 90 nop
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
110db4: b8 09 00 00 00 mov $0x9,%eax
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
#endif
return RTEMS_SUCCESSFUL;
}
110db9: 8d 65 f4 lea -0xc(%ebp),%esp
110dbc: 5b pop %ebx
110dbd: 5e pop %esi
110dbe: 5f pop %edi
110dbf: c9 leave
110dc0: c3 ret
110dc1: 8d 76 00 lea 0x0(%esi),%esi
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
110dc4: 8b 45 e4 mov -0x1c(%ebp),%eax
110dc7: eb a4 jmp 110d6d <rtems_string_to_long_long+0x49>
110dc9: 8d 76 00 lea 0x0(%esi),%esi
*endptr = end;
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
110dcc: b8 0b 00 00 00 mov $0xb,%eax
110dd1: eb c0 jmp 110d93 <rtems_string_to_long_long+0x6f>
00110e70 <rtems_string_to_pointer>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
110e70: 55 push %ebp
110e71: 89 e5 mov %esp,%ebp
110e73: 57 push %edi
110e74: 56 push %esi
110e75: 53 push %ebx
110e76: 83 ec 2c sub $0x2c,%esp
110e79: 8b 75 08 mov 0x8(%ebp),%esi
110e7c: 8b 5d 0c mov 0xc(%ebp),%ebx
110e7f: 8b 7d 10 mov 0x10(%ebp),%edi
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
110e82: 85 db test %ebx,%ebx
110e84: 74 5a je 110ee0 <rtems_string_to_pointer+0x70>
return RTEMS_INVALID_ADDRESS;
errno = 0;
110e86: e8 c9 2b 00 00 call 113a54 <__errno>
110e8b: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
110e91: c7 03 00 00 00 00 movl $0x0,(%ebx)
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
#elif defined(STRING_TO_POINTER)
result = STRING_TO_METHOD( s, &end, 16 );
110e97: 50 push %eax
110e98: 6a 10 push $0x10
110e9a: 8d 45 e4 lea -0x1c(%ebp),%eax
110e9d: 50 push %eax
110e9e: 56 push %esi
110e9f: e8 4c 5c 00 00 call 116af0 <strtoul>
110ea4: 89 c2 mov %eax,%edx
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
110ea6: 83 c4 10 add $0x10,%esp
110ea9: 85 ff test %edi,%edi
110eab: 74 43 je 110ef0 <rtems_string_to_pointer+0x80>
*endptr = end;
110ead: 8b 45 e4 mov -0x1c(%ebp),%eax
110eb0: 89 07 mov %eax,(%edi)
/* nothing was converted */
if ( end == s )
110eb2: 39 c6 cmp %eax,%esi
110eb4: 74 42 je 110ef8 <rtems_string_to_pointer+0x88>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
110eb6: 83 fa ff cmp $0xffffffff,%edx
110eb9: 74 0d je 110ec8 <rtems_string_to_pointer+0x58><== NEVER TAKEN
if ( (result == STRING_TO_MIN) && (errno == ERANGE))
return RTEMS_INVALID_NUMBER;
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
110ebb: 89 13 mov %edx,(%ebx)
#else
*n = (STRING_TO_TYPE) result;
#endif
return RTEMS_SUCCESSFUL;
110ebd: 31 c0 xor %eax,%eax
}
110ebf: 8d 65 f4 lea -0xc(%ebp),%esp
110ec2: 5b pop %ebx
110ec3: 5e pop %esi
110ec4: 5f pop %edi
110ec5: c9 leave
110ec6: c3 ret
110ec7: 90 nop
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
110ec8: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED
110ecb: e8 84 2b 00 00 call 113a54 <__errno> <== NOT EXECUTED
110ed0: 83 38 22 cmpl $0x22,(%eax) <== NOT EXECUTED
110ed3: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED
110ed6: 75 e3 jne 110ebb <rtems_string_to_pointer+0x4b><== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
110ed8: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
110edd: eb e0 jmp 110ebf <rtems_string_to_pointer+0x4f><== NOT EXECUTED
110edf: 90 nop <== NOT EXECUTED
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
110ee0: b8 09 00 00 00 mov $0x9,%eax
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
#endif
return RTEMS_SUCCESSFUL;
}
110ee5: 8d 65 f4 lea -0xc(%ebp),%esp
110ee8: 5b pop %ebx
110ee9: 5e pop %esi
110eea: 5f pop %edi
110eeb: c9 leave
110eec: c3 ret
110eed: 8d 76 00 lea 0x0(%esi),%esi
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
110ef0: 8b 45 e4 mov -0x1c(%ebp),%eax
110ef3: eb bd jmp 110eb2 <rtems_string_to_pointer+0x42>
110ef5: 8d 76 00 lea 0x0(%esi),%esi
*endptr = end;
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
110ef8: b8 0b 00 00 00 mov $0xb,%eax
110efd: eb c0 jmp 110ebf <rtems_string_to_pointer+0x4f>
00110f00 <rtems_string_to_unsigned_char>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
110f00: 55 push %ebp
110f01: 89 e5 mov %esp,%ebp
110f03: 57 push %edi
110f04: 56 push %esi
110f05: 53 push %ebx
110f06: 83 ec 1c sub $0x1c,%esp
110f09: 8b 75 08 mov 0x8(%ebp),%esi
110f0c: 8b 5d 0c mov 0xc(%ebp),%ebx
110f0f: 8b 7d 10 mov 0x10(%ebp),%edi
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
110f12: 85 db test %ebx,%ebx
110f14: 74 3a je 110f50 <rtems_string_to_unsigned_char+0x50>
return RTEMS_INVALID_ADDRESS;
errno = 0;
110f16: e8 39 2b 00 00 call 113a54 <__errno>
110f1b: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
110f21: c6 03 00 movb $0x0,(%ebx)
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
#elif defined(STRING_TO_POINTER)
result = STRING_TO_METHOD( s, &end, 16 );
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
110f24: 50 push %eax
110f25: ff 75 14 pushl 0x14(%ebp)
110f28: 8d 45 e4 lea -0x1c(%ebp),%eax
110f2b: 50 push %eax
110f2c: 56 push %esi
110f2d: e8 be 5b 00 00 call 116af0 <strtoul>
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
110f32: 83 c4 10 add $0x10,%esp
110f35: 85 ff test %edi,%edi
110f37: 74 27 je 110f60 <rtems_string_to_unsigned_char+0x60>
*endptr = end;
110f39: 8b 55 e4 mov -0x1c(%ebp),%edx
110f3c: 89 17 mov %edx,(%edi)
/* nothing was converted */
if ( end == s )
110f3e: 39 d6 cmp %edx,%esi
110f40: 74 26 je 110f68 <rtems_string_to_unsigned_char+0x68>
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
#elif defined(STRING_TO_POINTER)
result = STRING_TO_METHOD( s, &end, 16 );
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
110f42: 88 03 mov %al,(%ebx)
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
#endif
return RTEMS_SUCCESSFUL;
110f44: 31 c0 xor %eax,%eax
}
110f46: 8d 65 f4 lea -0xc(%ebp),%esp
110f49: 5b pop %ebx
110f4a: 5e pop %esi
110f4b: 5f pop %edi
110f4c: c9 leave
110f4d: c3 ret
110f4e: 66 90 xchg %ax,%ax
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
110f50: b8 09 00 00 00 mov $0x9,%eax
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
#endif
return RTEMS_SUCCESSFUL;
}
110f55: 8d 65 f4 lea -0xc(%ebp),%esp
110f58: 5b pop %ebx
110f59: 5e pop %esi
110f5a: 5f pop %edi
110f5b: c9 leave
110f5c: c3 ret
110f5d: 8d 76 00 lea 0x0(%esi),%esi
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
110f60: 8b 55 e4 mov -0x1c(%ebp),%edx
110f63: eb d9 jmp 110f3e <rtems_string_to_unsigned_char+0x3e>
110f65: 8d 76 00 lea 0x0(%esi),%esi
*endptr = end;
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
110f68: b8 0b 00 00 00 mov $0xb,%eax
110f6d: eb d7 jmp 110f46 <rtems_string_to_unsigned_char+0x46>
00110f70 <rtems_string_to_unsigned_int>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
110f70: 55 push %ebp
110f71: 89 e5 mov %esp,%ebp
110f73: 57 push %edi
110f74: 56 push %esi
110f75: 53 push %ebx
110f76: 83 ec 2c sub $0x2c,%esp
110f79: 8b 75 08 mov 0x8(%ebp),%esi
110f7c: 8b 5d 0c mov 0xc(%ebp),%ebx
110f7f: 8b 7d 10 mov 0x10(%ebp),%edi
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
110f82: 85 db test %ebx,%ebx
110f84: 74 5a je 110fe0 <rtems_string_to_unsigned_int+0x70>
return RTEMS_INVALID_ADDRESS;
errno = 0;
110f86: e8 c9 2a 00 00 call 113a54 <__errno>
110f8b: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
110f91: c7 03 00 00 00 00 movl $0x0,(%ebx)
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
#elif defined(STRING_TO_POINTER)
result = STRING_TO_METHOD( s, &end, 16 );
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
110f97: 50 push %eax
110f98: ff 75 14 pushl 0x14(%ebp)
110f9b: 8d 45 e4 lea -0x1c(%ebp),%eax
110f9e: 50 push %eax
110f9f: 56 push %esi
110fa0: e8 4b 5b 00 00 call 116af0 <strtoul>
110fa5: 89 c2 mov %eax,%edx
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
110fa7: 83 c4 10 add $0x10,%esp
110faa: 85 ff test %edi,%edi
110fac: 74 42 je 110ff0 <rtems_string_to_unsigned_int+0x80>
*endptr = end;
110fae: 8b 45 e4 mov -0x1c(%ebp),%eax
110fb1: 89 07 mov %eax,(%edi)
/* nothing was converted */
if ( end == s )
110fb3: 39 c6 cmp %eax,%esi
110fb5: 74 41 je 110ff8 <rtems_string_to_unsigned_int+0x88>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
110fb7: 83 fa ff cmp $0xffffffff,%edx
110fba: 74 0c je 110fc8 <rtems_string_to_unsigned_int+0x58>
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
110fbc: 89 13 mov %edx,(%ebx)
#endif
return RTEMS_SUCCESSFUL;
110fbe: 31 c0 xor %eax,%eax
}
110fc0: 8d 65 f4 lea -0xc(%ebp),%esp
110fc3: 5b pop %ebx
110fc4: 5e pop %esi
110fc5: 5f pop %edi
110fc6: c9 leave
110fc7: c3 ret
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
110fc8: 89 55 d4 mov %edx,-0x2c(%ebp)
110fcb: e8 84 2a 00 00 call 113a54 <__errno>
110fd0: 83 38 22 cmpl $0x22,(%eax)
110fd3: 8b 55 d4 mov -0x2c(%ebp),%edx
110fd6: 75 e4 jne 110fbc <rtems_string_to_unsigned_int+0x4c><== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
110fd8: b8 0a 00 00 00 mov $0xa,%eax
110fdd: eb e1 jmp 110fc0 <rtems_string_to_unsigned_int+0x50>
110fdf: 90 nop
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
110fe0: b8 09 00 00 00 mov $0x9,%eax
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
#endif
return RTEMS_SUCCESSFUL;
}
110fe5: 8d 65 f4 lea -0xc(%ebp),%esp
110fe8: 5b pop %ebx
110fe9: 5e pop %esi
110fea: 5f pop %edi
110feb: c9 leave
110fec: c3 ret
110fed: 8d 76 00 lea 0x0(%esi),%esi
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
110ff0: 8b 45 e4 mov -0x1c(%ebp),%eax
110ff3: eb be jmp 110fb3 <rtems_string_to_unsigned_int+0x43>
110ff5: 8d 76 00 lea 0x0(%esi),%esi
*endptr = end;
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
110ff8: b8 0b 00 00 00 mov $0xb,%eax
110ffd: eb c1 jmp 110fc0 <rtems_string_to_unsigned_int+0x50>
0011109c <rtems_string_to_unsigned_long>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
11109c: 55 push %ebp
11109d: 89 e5 mov %esp,%ebp
11109f: 57 push %edi
1110a0: 56 push %esi
1110a1: 53 push %ebx
1110a2: 83 ec 2c sub $0x2c,%esp
1110a5: 8b 75 08 mov 0x8(%ebp),%esi
1110a8: 8b 5d 0c mov 0xc(%ebp),%ebx
1110ab: 8b 7d 10 mov 0x10(%ebp),%edi
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
1110ae: 85 db test %ebx,%ebx
1110b0: 74 5a je 11110c <rtems_string_to_unsigned_long+0x70>
return RTEMS_INVALID_ADDRESS;
errno = 0;
1110b2: e8 9d 29 00 00 call 113a54 <__errno>
1110b7: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
1110bd: c7 03 00 00 00 00 movl $0x0,(%ebx)
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
#elif defined(STRING_TO_POINTER)
result = STRING_TO_METHOD( s, &end, 16 );
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
1110c3: 50 push %eax
1110c4: ff 75 14 pushl 0x14(%ebp)
1110c7: 8d 45 e4 lea -0x1c(%ebp),%eax
1110ca: 50 push %eax
1110cb: 56 push %esi
1110cc: e8 1f 5a 00 00 call 116af0 <strtoul>
1110d1: 89 c2 mov %eax,%edx
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
1110d3: 83 c4 10 add $0x10,%esp
1110d6: 85 ff test %edi,%edi
1110d8: 74 42 je 11111c <rtems_string_to_unsigned_long+0x80>
*endptr = end;
1110da: 8b 45 e4 mov -0x1c(%ebp),%eax
1110dd: 89 07 mov %eax,(%edi)
/* nothing was converted */
if ( end == s )
1110df: 39 c6 cmp %eax,%esi
1110e1: 74 41 je 111124 <rtems_string_to_unsigned_long+0x88>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
1110e3: 83 fa ff cmp $0xffffffff,%edx
1110e6: 74 0c je 1110f4 <rtems_string_to_unsigned_long+0x58>
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
1110e8: 89 13 mov %edx,(%ebx)
#endif
return RTEMS_SUCCESSFUL;
1110ea: 31 c0 xor %eax,%eax
}
1110ec: 8d 65 f4 lea -0xc(%ebp),%esp
1110ef: 5b pop %ebx
1110f0: 5e pop %esi
1110f1: 5f pop %edi
1110f2: c9 leave
1110f3: c3 ret
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
1110f4: 89 55 d4 mov %edx,-0x2c(%ebp)
1110f7: e8 58 29 00 00 call 113a54 <__errno>
1110fc: 83 38 22 cmpl $0x22,(%eax)
1110ff: 8b 55 d4 mov -0x2c(%ebp),%edx
111102: 75 e4 jne 1110e8 <rtems_string_to_unsigned_long+0x4c><== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
111104: b8 0a 00 00 00 mov $0xa,%eax
111109: eb e1 jmp 1110ec <rtems_string_to_unsigned_long+0x50>
11110b: 90 nop
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
11110c: b8 09 00 00 00 mov $0x9,%eax
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
#endif
return RTEMS_SUCCESSFUL;
}
111111: 8d 65 f4 lea -0xc(%ebp),%esp
111114: 5b pop %ebx
111115: 5e pop %esi
111116: 5f pop %edi
111117: c9 leave
111118: c3 ret
111119: 8d 76 00 lea 0x0(%esi),%esi
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
11111c: 8b 45 e4 mov -0x1c(%ebp),%eax
11111f: eb be jmp 1110df <rtems_string_to_unsigned_long+0x43>
111121: 8d 76 00 lea 0x0(%esi),%esi
*endptr = end;
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
111124: b8 0b 00 00 00 mov $0xb,%eax
111129: eb c1 jmp 1110ec <rtems_string_to_unsigned_long+0x50>
00111000 <rtems_string_to_unsigned_long_long>:
#if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER)
,
int base
#endif
)
{
111000: 55 push %ebp
111001: 89 e5 mov %esp,%ebp
111003: 57 push %edi
111004: 56 push %esi
111005: 53 push %ebx
111006: 83 ec 2c sub $0x2c,%esp
111009: 8b 5d 0c mov 0xc(%ebp),%ebx
11100c: 8b 7d 10 mov 0x10(%ebp),%edi
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
11100f: 85 db test %ebx,%ebx
111011: 74 69 je 11107c <rtems_string_to_unsigned_long_long+0x7c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
111013: e8 3c 2a 00 00 call 113a54 <__errno>
111018: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
11101e: c7 03 00 00 00 00 movl $0x0,(%ebx)
111024: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
#ifdef STRING_TO_FLOAT
result = STRING_TO_METHOD( s, &end );
#elif defined(STRING_TO_POINTER)
result = STRING_TO_METHOD( s, &end, 16 );
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
11102b: 50 push %eax
11102c: ff 75 14 pushl 0x14(%ebp)
11102f: 8d 45 e4 lea -0x1c(%ebp),%eax
111032: 50 push %eax
111033: ff 75 08 pushl 0x8(%ebp)
111036: e8 d1 5a 00 00 call 116b0c <strtoull>
11103b: 89 c6 mov %eax,%esi
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
11103d: 83 c4 10 add $0x10,%esp
111040: 85 ff test %edi,%edi
111042: 74 48 je 11108c <rtems_string_to_unsigned_long_long+0x8c>
*endptr = end;
111044: 8b 45 e4 mov -0x1c(%ebp),%eax
111047: 89 07 mov %eax,(%edi)
/* nothing was converted */
if ( end == s )
111049: 39 45 08 cmp %eax,0x8(%ebp)
11104c: 74 46 je 111094 <rtems_string_to_unsigned_long_long+0x94>
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
11104e: 89 f0 mov %esi,%eax
111050: 21 d0 and %edx,%eax
111052: 40 inc %eax
111053: 74 0f je 111064 <rtems_string_to_unsigned_long_long+0x64>
#endif
#if defined(STRING_TO_POINTER)
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
111055: 89 33 mov %esi,(%ebx)
111057: 89 53 04 mov %edx,0x4(%ebx)
#endif
return RTEMS_SUCCESSFUL;
11105a: 31 c0 xor %eax,%eax
}
11105c: 8d 65 f4 lea -0xc(%ebp),%esp
11105f: 5b pop %ebx
111060: 5e pop %esi
111061: 5f pop %edi
111062: c9 leave
111063: c3 ret
return RTEMS_INVALID_NUMBER;
#endif
#ifdef STRING_TO_MAX
/* there was an overflow */
if ( (result == STRING_TO_MAX) && (errno == ERANGE))
111064: 89 55 d4 mov %edx,-0x2c(%ebp)
111067: e8 e8 29 00 00 call 113a54 <__errno>
11106c: 83 38 22 cmpl $0x22,(%eax)
11106f: 8b 55 d4 mov -0x2c(%ebp),%edx
111072: 75 e1 jne 111055 <rtems_string_to_unsigned_long_long+0x55><== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
111074: b8 0a 00 00 00 mov $0xa,%eax
111079: eb e1 jmp 11105c <rtems_string_to_unsigned_long_long+0x5c>
11107b: 90 nop
{
STRING_TO_INPUT_TYPE result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
11107c: b8 09 00 00 00 mov $0x9,%eax
*n = (STRING_TO_TYPE) (uintptr_t)result;
#else
*n = (STRING_TO_TYPE) result;
#endif
return RTEMS_SUCCESSFUL;
}
111081: 8d 65 f4 lea -0xc(%ebp),%esp
111084: 5b pop %ebx
111085: 5e pop %esi
111086: 5f pop %edi
111087: c9 leave
111088: c3 ret
111089: 8d 76 00 lea 0x0(%esi),%esi
#elif defined(STRING_TO_INTEGER)
result = STRING_TO_METHOD( s, &end, base );
#endif
/* If the user wants the end pointer back, then return it. */
if ( endptr )
11108c: 8b 45 e4 mov -0x1c(%ebp),%eax
11108f: eb b8 jmp 111049 <rtems_string_to_unsigned_long_long+0x49>
111091: 8d 76 00 lea 0x0(%esi),%esi
*endptr = end;
/* nothing was converted */
if ( end == s )
return RTEMS_NOT_DEFINED;
111094: b8 0b 00 00 00 mov $0xb,%eax
111099: eb c1 jmp 11105c <rtems_string_to_unsigned_long_long+0x5c>
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 65 12 00 cmp $0x126580,%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 65 12 00 mov $0x1265c8,%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 57 fe 00 00 call 117d3c <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 5e 7c 00 00 call 10fb60 <_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 4b 7c 00 00 call 10fb60 <_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 35 7c 00 00 call 10fb60 <_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 ff 80 00 00 call 110034 <_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 75 fa 00 00 call 1179d4 <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 82 f8 00 00 call 117820 <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 70 12 00 cmp $0x127000,%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 0c 88 00 00 call 110814 <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 ce 81 00 00 call 11021c <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 32 12 00 movzbl 0x123274,%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 5c 76 12 00 pushl 0x12765c
10b897: e8 c8 06 00 00 call 10bf64 <_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 00 75 12 00 movl $0x127500,(%esp)
10b8a3: e8 e0 10 00 00 call 10c988 <_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 00 75 12 00 push $0x127500
10b8ed: 89 55 e4 mov %edx,-0x1c(%ebp)
10b8f0: e8 97 20 00 00 call 10d98c <_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 5c 76 12 00 pushl 0x12765c
10b91e: e8 89 06 00 00 call 10bfac <_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 15 14 00 00 call 10cd70 <_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 99 13 00 00 call 10cd00 <_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 5c 76 12 00 pushl 0x12765c
10b96e: e8 39 06 00 00 call 10bfac <_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 5c 76 12 00 pushl 0x12765c
10b98d: e8 1a 06 00 00 call 10bfac <_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 5c 76 12 00 pushl 0x12765c
10b9b9: e8 a6 05 00 00 call 10bf64 <_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 4c 1f 00 00 call 10d918 <_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 8d 13 00 00 call 10cd70 <_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 c8 1b 00 00 call 10d5b4 <_Thread_Close>
10b9ec: 58 pop %eax
10b9ed: ff 73 08 pushl 0x8(%ebx)
10b9f0: e8 7b 13 00 00 call 10cd70 <_Objects_Get_information_id>
10b9f5: 5a pop %edx
10b9f6: 59 pop %ecx
10b9f7: 53 push %ebx
10b9f8: 50 push %eax
10b9f9: e8 02 13 00 00 call 10cd00 <_Objects_Free>
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
10b9fe: 58 pop %eax
10b9ff: ff 35 5c 76 12 00 pushl 0x12765c
10ba05: e8 a2 05 00 00 call 10bfac <_API_Mutex_Unlock>
_Thread_Enable_dispatch();
10ba0a: e8 e5 1e 00 00 call 10d8f4 <_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 5c 76 12 00 pushl 0x12765c
10ba25: e8 82 05 00 00 call 10bfac <_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 e4 61 12 00 00 cmpb $0x0,0x1261e4
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 18 ae 12 00 mov 0x12ae18,%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 3d 22 00 00 call 10f760 <_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 fe 21 00 00 call 10f73c <_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 18 ae 12 00 mov 0x12ae18,%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 66 3c 00 00 call 11bdbc <_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 25 3c 00 00 call 11bd98 <_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 17 3c 00 00 call 11bd98 <_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
00112e94 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
112e94: 55 push %ebp
112e95: 89 e5 mov %esp,%ebp
112e97: 57 push %edi
112e98: 56 push %esi
112e99: 53 push %ebx
112e9a: 83 ec 1c sub $0x1c,%esp
112e9d: 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 )
112ea0: 85 c9 test %ecx,%ecx
112ea2: 0f 84 40 01 00 00 je 112fe8 <rtems_task_mode+0x154>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
112ea8: 8b 1d 58 7b 12 00 mov 0x127b58,%ebx
api = executing->API_Extensions[ THREAD_API_RTEMS ];
112eae: 8b bb e8 00 00 00 mov 0xe8(%ebx),%edi
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
112eb4: 80 7b 74 01 cmpb $0x1,0x74(%ebx)
112eb8: 19 f6 sbb %esi,%esi
112eba: 81 e6 00 01 00 00 and $0x100,%esi
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
112ec0: 8b 53 7c mov 0x7c(%ebx),%edx
112ec3: 85 d2 test %edx,%edx
112ec5: 0f 85 f1 00 00 00 jne 112fbc <rtems_task_mode+0x128>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
112ecb: 80 7f 08 01 cmpb $0x1,0x8(%edi)
112ecf: 19 d2 sbb %edx,%edx
112ed1: 81 e2 00 04 00 00 and $0x400,%edx
old_mode |= _ISR_Get_level();
112ed7: 89 55 e4 mov %edx,-0x1c(%ebp)
112eda: 89 4d e0 mov %ecx,-0x20(%ebp)
112edd: e8 7a be ff ff call 10ed5c <_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;
112ee2: 8b 55 e4 mov -0x1c(%ebp),%edx
112ee5: 09 d0 or %edx,%eax
old_mode |= _ISR_Get_level();
112ee7: 09 f0 or %esi,%eax
112ee9: 8b 4d e0 mov -0x20(%ebp),%ecx
112eec: 89 01 mov %eax,(%ecx)
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
112eee: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp)
112ef5: 74 0b je 112f02 <rtems_task_mode+0x6e>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
112ef7: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp)
112efe: 0f 94 43 74 sete 0x74(%ebx)
if ( mask & RTEMS_TIMESLICE_MASK ) {
112f02: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
112f09: 74 1c je 112f27 <rtems_task_mode+0x93>
if ( _Modes_Is_timeslice(mode_set) ) {
112f0b: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp)
112f12: 0f 84 b8 00 00 00 je 112fd0 <rtems_task_mode+0x13c>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
112f18: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
112f1f: a1 40 75 12 00 mov 0x127540,%eax
112f24: 89 43 78 mov %eax,0x78(%ebx)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
112f27: f6 45 0c 01 testb $0x1,0xc(%ebp)
112f2b: 74 0b je 112f38 <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 ) );
112f2d: f6 45 08 01 testb $0x1,0x8(%ebp)
112f31: 0f 84 91 00 00 00 je 112fc8 <rtems_task_mode+0x134>
112f37: fa cli
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
112f38: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
112f3f: 74 3f je 112f80 <rtems_task_mode+0xec>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
112f41: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp)
112f48: 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 ) {
112f4b: 38 47 08 cmp %al,0x8(%edi)
112f4e: 74 30 je 112f80 <rtems_task_mode+0xec>
asr->is_enabled = is_asr_enabled;
112f50: 88 47 08 mov %al,0x8(%edi)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
112f53: 9c pushf
112f54: fa cli
112f55: 58 pop %eax
_signals = information->signals_pending;
112f56: 8b 57 18 mov 0x18(%edi),%edx
information->signals_pending = information->signals_posted;
112f59: 8b 4f 14 mov 0x14(%edi),%ecx
112f5c: 89 4f 18 mov %ecx,0x18(%edi)
information->signals_posted = _signals;
112f5f: 89 57 14 mov %edx,0x14(%edi)
_ISR_Enable( _level );
112f62: 50 push %eax
112f63: 9d popf
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
112f64: 8b 47 14 mov 0x14(%edi),%eax
112f67: 85 c0 test %eax,%eax
112f69: 0f 95 c0 setne %al
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
112f6c: 83 3d 40 77 12 00 03 cmpl $0x3,0x127740
112f73: 74 16 je 112f8b <rtems_task_mode+0xf7> <== ALWAYS TAKEN
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
112f75: 31 c0 xor %eax,%eax
}
112f77: 83 c4 1c add $0x1c,%esp
112f7a: 5b pop %ebx
112f7b: 5e pop %esi
112f7c: 5f pop %edi
112f7d: c9 leave
112f7e: c3 ret
112f7f: 90 nop
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
112f80: 31 c0 xor %eax,%eax
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
112f82: 83 3d 40 77 12 00 03 cmpl $0x3,0x127740
112f89: 75 ea jne 112f75 <rtems_task_mode+0xe1> <== NEVER TAKEN
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
112f8b: 8b 15 58 7b 12 00 mov 0x127b58,%edx
if ( are_signals_pending ||
112f91: 84 c0 test %al,%al
112f93: 75 0e jne 112fa3 <rtems_task_mode+0x10f>
112f95: 3b 15 5c 7b 12 00 cmp 0x127b5c,%edx
112f9b: 74 d8 je 112f75 <rtems_task_mode+0xe1>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
112f9d: 80 7a 74 00 cmpb $0x0,0x74(%edx)
112fa1: 74 d2 je 112f75 <rtems_task_mode+0xe1> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
112fa3: c6 05 64 7b 12 00 01 movb $0x1,0x127b64
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
112faa: e8 cd a7 ff ff call 10d77c <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
112faf: 31 c0 xor %eax,%eax
}
112fb1: 83 c4 1c add $0x1c,%esp
112fb4: 5b pop %ebx
112fb5: 5e pop %esi
112fb6: 5f pop %edi
112fb7: c9 leave
112fb8: c3 ret
112fb9: 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;
112fbc: 81 ce 00 02 00 00 or $0x200,%esi
112fc2: e9 04 ff ff ff jmp 112ecb <rtems_task_mode+0x37>
112fc7: 90 nop
112fc8: fb sti
112fc9: e9 6a ff ff ff jmp 112f38 <rtems_task_mode+0xa4>
112fce: 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;
112fd0: c7 43 7c 00 00 00 00 movl $0x0,0x7c(%ebx)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
112fd7: f6 45 0c 01 testb $0x1,0xc(%ebp)
112fdb: 0f 84 57 ff ff ff je 112f38 <rtems_task_mode+0xa4>
112fe1: e9 47 ff ff ff jmp 112f2d <rtems_task_mode+0x99>
112fe6: 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;
112fe8: b8 09 00 00 00 mov $0x9,%eax
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
}
112fed: 83 c4 1c add $0x1c,%esp
112ff0: 5b pop %ebx
112ff1: 5e pop %esi
112ff2: 5f pop %edi
112ff3: c9 leave
112ff4: 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 62 1f 00 00 call 110c50 <_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 21 1f 00 00 call 110c2c <_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 4d 27 00 00 call 11146c <_Thread_Resume>
_Thread_Enable_dispatch();
10ed1f: e8 08 1f 00 00 call 110c2c <_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 e4 61 12 00 00 cmpb $0x0,0x1261e4
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 18 ae 12 00 mov 0x12ae18,%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 c9 20 00 00 call 10f760 <_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 8c 20 00 00 call 10f73c <_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 18 ae 12 00 mov 0x12ae18,%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 72 12 00 movzbl 0x127234,%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 c0 20 00 00 call 111a90 <_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 bc 1b 00 00 call 1115b8 <_Thread_Change_priority>
10f9fc: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10f9ff: e8 68 20 00 00 call 111a6c <_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 07 1e 00 00 call 10d918 <_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 d8 27 00 00 call 10e304 <_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 bc 1d 00 00 call 10d8f4 <_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 93 1d 00 00 call 10d8f4 <_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
00110f40 <rtems_task_suspend>:
*/
rtems_status_code rtems_task_suspend(
rtems_id id
)
{
110f40: 55 push %ebp
110f41: 89 e5 mov %esp,%ebp
110f43: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
110f46: 8d 45 f4 lea -0xc(%ebp),%eax
110f49: 50 push %eax
110f4a: ff 75 08 pushl 0x8(%ebp)
110f4d: e8 c6 c9 ff ff call 10d918 <_Thread_Get>
switch ( location ) {
110f52: 83 c4 10 add $0x10,%esp
110f55: 8b 55 f4 mov -0xc(%ebp),%edx
110f58: 85 d2 test %edx,%edx
110f5a: 74 08 je 110f64 <rtems_task_suspend+0x24>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
110f5c: b8 04 00 00 00 mov $0x4,%eax
}
110f61: c9 leave
110f62: c3 ret
110f63: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
110f64: f6 40 10 02 testb $0x2,0x10(%eax)
110f68: 74 0e je 110f78 <rtems_task_suspend+0x38>
_Thread_Suspend( the_thread );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
110f6a: e8 85 c9 ff ff call 10d8f4 <_Thread_Enable_dispatch>
return RTEMS_ALREADY_SUSPENDED;
110f6f: b8 0f 00 00 00 mov $0xf,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
110f74: c9 leave
110f75: c3 ret
110f76: 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 );
110f78: 83 ec 0c sub $0xc,%esp
110f7b: 50 push %eax
110f7c: e8 f7 09 00 00 call 111978 <_Thread_Suspend>
_Thread_Enable_dispatch();
110f81: e8 6e c9 ff ff call 10d8f4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
110f86: 83 c4 10 add $0x10,%esp
110f89: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
110f8b: c9 leave
110f8c: 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 b2 1f 00 00 call 10e628 <_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 ca 2f 00 00 call 10f670 <_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 39 1f 00 00 call 10e604 <_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 19 1f 00 00 call 10e604 <_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 07 1f 00 00 call 10e604 <_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 f7 1e 00 00 call 10e628 <_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 96 1e 00 00 call 10e604 <_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 79 1e 00 00 call 10e604 <_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 53 1e 00 00 call 10e628 <_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 03 1e 00 00 call 10e604 <_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 db 1d 00 00 call 10e604 <_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
0010c9cc <rtems_task_wake_when>:
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
10c9cc: 55 push %ebp
10c9cd: 89 e5 mov %esp,%ebp
10c9cf: 53 push %ebx
10c9d0: 83 ec 14 sub $0x14,%esp
10c9d3: 8b 5d 08 mov 0x8(%ebp),%ebx
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
10c9d6: 80 3d 84 a2 12 00 00 cmpb $0x0,0x12a284
10c9dd: 0f 84 a9 00 00 00 je 10ca8c <rtems_task_wake_when+0xc0>
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
10c9e3: 85 db test %ebx,%ebx
10c9e5: 0f 84 ad 00 00 00 je 10ca98 <rtems_task_wake_when+0xcc>
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
10c9eb: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
if ( !_TOD_Validate( time_buffer ) )
10c9f2: 83 ec 0c sub $0xc,%esp
10c9f5: 53 push %ebx
10c9f6: e8 c5 f3 ff ff call 10bdc0 <_TOD_Validate>
10c9fb: 83 c4 10 add $0x10,%esp
10c9fe: 84 c0 test %al,%al
10ca00: 75 0a jne 10ca0c <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;
10ca02: b8 14 00 00 00 mov $0x14,%eax
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10ca07: 8b 5d fc mov -0x4(%ebp),%ebx
10ca0a: c9 leave
10ca0b: c3 ret
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
10ca0c: 83 ec 0c sub $0xc,%esp
10ca0f: 53 push %ebx
10ca10: e8 1f f3 ff ff call 10bd34 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
10ca15: 83 c4 10 add $0x10,%esp
10ca18: 3b 05 44 a3 12 00 cmp 0x12a344,%eax
10ca1e: 76 e2 jbe 10ca02 <rtems_task_wake_when+0x36>
10ca20: 8b 15 70 a2 12 00 mov 0x12a270,%edx
10ca26: 42 inc %edx
10ca27: 89 15 70 a2 12 00 mov %edx,0x12a270
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
10ca2d: 83 ec 08 sub $0x8,%esp
10ca30: 6a 10 push $0x10
10ca32: ff 35 58 a8 12 00 pushl 0x12a858
10ca38: 89 45 f4 mov %eax,-0xc(%ebp)
10ca3b: e8 68 26 00 00 call 10f0a8 <_Thread_Set_state>
_Watchdog_Initialize(
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
10ca40: 8b 15 58 a8 12 00 mov 0x12a858,%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(
10ca46: 8b 4a 08 mov 0x8(%edx),%ecx
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10ca49: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx)
the_watchdog->routine = routine;
10ca50: c7 42 64 90 e6 10 00 movl $0x10e690,0x64(%edx)
the_watchdog->id = id;
10ca57: 89 4a 68 mov %ecx,0x68(%edx)
the_watchdog->user_data = user_data;
10ca5a: 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(
10ca61: 8b 45 f4 mov -0xc(%ebp),%eax
10ca64: 2b 05 44 a3 12 00 sub 0x12a344,%eax
10ca6a: 89 42 54 mov %eax,0x54(%edx)
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
10ca6d: 58 pop %eax
10ca6e: 59 pop %ecx
10ca6f: 83 c2 48 add $0x48,%edx
10ca72: 52 push %edx
10ca73: 68 70 a3 12 00 push $0x12a370
10ca78: e8 43 2c 00 00 call 10f6c0 <_Watchdog_Insert>
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
10ca7d: e8 c2 1d 00 00 call 10e844 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10ca82: 83 c4 10 add $0x10,%esp
10ca85: 31 c0 xor %eax,%eax
10ca87: e9 7b ff ff ff jmp 10ca07 <rtems_task_wake_when+0x3b>
)
{
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
10ca8c: b8 0b 00 00 00 mov $0xb,%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
10ca96: 66 90 xchg %ax,%ax
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
10ca98: b8 09 00 00 00 mov $0x9,%eax
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10ca9d: 8b 5d fc mov -0x4(%ebp),%ebx
10caa0: c9 leave
10caa1: 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 a0 50 12 00 push $0x1250a0
108f48: e8 43 6c 00 00 call 10fb90 <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 4c 74 12 00 pushl 0x12744c
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 e4 70 12 00 mov 0x1270e4(%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 4c 74 12 00 pushl 0x12744c
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 54 74 12 00 mov %eax,0x127454
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 50 74 12 00 mov %edx,0x127450
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 79 26 00 00 call 10bd00 <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 94 71 12 00 mov 0x127194,%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 34 11 00 00 call 10bd00 <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 f0 70 12 00 mov 0x1270f0(%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 f0 70 12 00 mov 0x1270f0(%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 4c 74 12 00 mov 0x12744c,%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 4c 74 12 00 push $0x12744c
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 5c 2d 00 00 call 10bd00 <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 f8 70 12 00 mov 0x1270f8(%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><== ALWAYS TAKEN
!(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 <== NOT EXECUTED
1097bc: 25 ef fd ff ff and $0xfffffdef,%eax <== NOT EXECUTED
1097c1: 89 82 b8 00 00 00 mov %eax,0xb8(%edx) <== NOT EXECUTED
/* 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 <== NOT EXECUTED
1097cd: a8 20 test $0x20,%al <== NOT EXECUTED
1097cf: 74 23 je 1097f4 <rtems_termios_ioctl+0x14c><== NOT EXECUTED
/* 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><== ALWAYS TAKEN
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
109808: 8b 81 b8 00 00 00 mov 0xb8(%ecx),%eax <== NOT EXECUTED
10980e: 80 e4 fb and $0xfb,%ah <== NOT EXECUTED
109811: 89 81 b8 00 00 00 mov %eax,0xb8(%ecx) <== NOT EXECUTED
/* 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 <== NOT EXECUTED
10981d: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED
109820: 89 81 b8 00 00 00 mov %eax,0xb8(%ecx) <== NOT EXECUTED
}
/* 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 e4 70 12 00 mov 0x1270e4(%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 e0 70 12 00 mov 0x1270e0(%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 60 89 12 00 push $0x128960
10aa94: e8 f7 6e 00 00 call 111990 <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 4c 74 12 00 pushl 0x12744c
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 54 74 12 00 mov 0x127454,%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 4c 74 12 00 pushl 0x12744c
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 a4 51 12 00 mov 0x1251a4,%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 a8 51 12 00 mov 0x1251a8,%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 a0 51 12 00 pushl 0x1251a0
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 54 74 12 00 mov %eax,0x127454
if (rtems_termios_ttyTail == NULL)
1091f2: 8b 0d 50 74 12 00 mov 0x127450,%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 ac 51 12 00 movsbl 0x1251ac,%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 ac 51 12 00 movsbl 0x1251ac,%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 ac 51 12 00 movsbl 0x1251ac,%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 ac 51 12 00 mov 0x1251ac,%al
109371: 8d 48 01 lea 0x1(%eax),%ecx
109374: 88 0d ac 51 12 00 mov %cl,0x1251ac
10937a: 3c 7a cmp $0x7a,%al
10937c: 0f 85 e6 fc ff ff jne 109068 <rtems_termios_open+0x54>
c = 'a';
109382: c6 05 ac 51 12 00 61 movb $0x61,0x1251ac
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 4c 74 12 00 pushl 0x12744c
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 4c 74 12 00 pushl 0x12744c
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 ac 51 12 00 movsbl 0x1251ac,%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 e4 28 00 00 call 10bd00 <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 ac 51 12 00 movsbl 0x1251ac,%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 ac 51 12 00 movsbl 0x1251ac,%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 50 74 12 00 mov %eax,0x127450
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 <== NOT EXECUTED
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
109bfa: 50 push %eax <== NOT EXECUTED
109bfb: e8 00 21 00 00 call 10bd00 <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 e8 70 12 00 mov 0x1270e8(%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 a0 51 12 00 mov 0x1251a0,%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 a0 51 12 00 mov 0x1251a0,%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 f4 70 12 00 mov 0x1270f4(%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 <== NOT EXECUTED
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 ec 70 12 00 mov 0x1270ec(%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
001186e0 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
1186e0: 55 push %ebp
1186e1: 89 e5 mov %esp,%ebp
1186e3: 83 ec 1c sub $0x1c,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
1186e6: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
1186e9: 50 push %eax
1186ea: ff 75 08 pushl 0x8(%ebp)
1186ed: 68 80 2c 14 00 push $0x142c80
1186f2: e8 ed 2b 00 00 call 11b2e4 <_Objects_Get>
switch ( location ) {
1186f7: 83 c4 10 add $0x10,%esp
1186fa: 8b 55 f4 mov -0xc(%ebp),%edx
1186fd: 85 d2 test %edx,%edx
1186ff: 74 07 je 118708 <rtems_timer_cancel+0x28>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118701: b8 04 00 00 00 mov $0x4,%eax
}
118706: c9 leave
118707: c3 ret
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
118708: 83 78 38 04 cmpl $0x4,0x38(%eax)
11870c: 74 0f je 11871d <rtems_timer_cancel+0x3d><== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
11870e: 83 ec 0c sub $0xc,%esp
118711: 83 c0 10 add $0x10,%eax
118714: 50 push %eax
118715: e8 56 48 00 00 call 11cf70 <_Watchdog_Remove>
11871a: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
11871d: e8 76 36 00 00 call 11bd98 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
118722: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118724: c9 leave
118725: c3 ret
0010bffc <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
10bffc: 55 push %ebp
10bffd: 89 e5 mov %esp,%ebp
10bfff: 57 push %edi
10c000: 56 push %esi
10c001: 53 push %ebx
10c002: 83 ec 0c sub $0xc,%esp
10c005: 8b 5d 08 mov 0x8(%ebp),%ebx
10c008: 8b 75 0c mov 0xc(%ebp),%esi
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
10c00b: 85 db test %ebx,%ebx
10c00d: 74 6d je 10c07c <rtems_timer_create+0x80>
return RTEMS_INVALID_NAME;
if ( !id )
10c00f: 85 f6 test %esi,%esi
10c011: 0f 84 89 00 00 00 je 10c0a0 <rtems_timer_create+0xa4>
10c017: a1 d0 8f 12 00 mov 0x128fd0,%eax
10c01c: 40 inc %eax
10c01d: a3 d0 8f 12 00 mov %eax,0x128fd0
* 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 );
10c022: 83 ec 0c sub $0xc,%esp
10c025: 68 40 9a 12 00 push $0x129a40
10c02a: e8 29 0f 00 00 call 10cf58 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
10c02f: 83 c4 10 add $0x10,%esp
10c032: 85 c0 test %eax,%eax
10c034: 74 56 je 10c08c <rtems_timer_create+0x90>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_timer->the_class = TIMER_DORMANT;
10c036: 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;
10c03d: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10c044: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
the_watchdog->id = id;
10c04b: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
the_watchdog->user_data = user_data;
10c052: 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 ),
10c059: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10c05c: 0f b7 fa movzwl %dx,%edi
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c05f: 8b 0d 5c 9a 12 00 mov 0x129a5c,%ecx
10c065: 89 04 b9 mov %eax,(%ecx,%edi,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10c068: 89 58 0c mov %ebx,0xc(%eax)
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
10c06b: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
10c06d: e8 52 1e 00 00 call 10dec4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c072: 31 c0 xor %eax,%eax
}
10c074: 8d 65 f4 lea -0xc(%ebp),%esp
10c077: 5b pop %ebx
10c078: 5e pop %esi
10c079: 5f pop %edi
10c07a: c9 leave
10c07b: c3 ret
)
{
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
10c07c: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c081: 8d 65 f4 lea -0xc(%ebp),%esp
10c084: 5b pop %ebx
10c085: 5e pop %esi
10c086: 5f pop %edi
10c087: c9 leave
10c088: c3 ret
10c089: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
_Thread_Enable_dispatch();
10c08c: e8 33 1e 00 00 call 10dec4 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
10c091: b8 05 00 00 00 mov $0x5,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c096: 8d 65 f4 lea -0xc(%ebp),%esp
10c099: 5b pop %ebx
10c09a: 5e pop %esi
10c09b: 5f pop %edi
10c09c: c9 leave
10c09d: c3 ret
10c09e: 66 90 xchg %ax,%ax
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
10c0a0: b8 09 00 00 00 mov $0x9,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10c0a5: 8d 65 f4 lea -0xc(%ebp),%esp
10c0a8: 5b pop %ebx
10c0a9: 5e pop %esi
10c0aa: 5f pop %edi
10c0ab: c9 leave
10c0ac: c3 ret
001187dc <rtems_timer_delete>:
*/
rtems_status_code rtems_timer_delete(
rtems_id id
)
{
1187dc: 55 push %ebp
1187dd: 89 e5 mov %esp,%ebp
1187df: 53 push %ebx
1187e0: 83 ec 18 sub $0x18,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
1187e3: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
1187e6: 50 push %eax
1187e7: ff 75 08 pushl 0x8(%ebp)
1187ea: 68 80 2c 14 00 push $0x142c80
1187ef: e8 f0 2a 00 00 call 11b2e4 <_Objects_Get>
1187f4: 89 c3 mov %eax,%ebx
switch ( location ) {
1187f6: 83 c4 10 add $0x10,%esp
1187f9: 8b 4d f4 mov -0xc(%ebp),%ecx
1187fc: 85 c9 test %ecx,%ecx
1187fe: 75 38 jne 118838 <rtems_timer_delete+0x5c>
case OBJECTS_LOCAL:
_Objects_Close( &_Timer_Information, &the_timer->Object );
118800: 83 ec 08 sub $0x8,%esp
118803: 50 push %eax
118804: 68 80 2c 14 00 push $0x142c80
118809: e8 5e 26 00 00 call 11ae6c <_Objects_Close>
(void) _Watchdog_Remove( &the_timer->Ticker );
11880e: 8d 43 10 lea 0x10(%ebx),%eax
118811: 89 04 24 mov %eax,(%esp)
118814: e8 57 47 00 00 call 11cf70 <_Watchdog_Remove>
*/
RTEMS_INLINE_ROUTINE void _Timer_Free (
Timer_Control *the_timer
)
{
_Objects_Free( &_Timer_Information, &the_timer->Object );
118819: 58 pop %eax
11881a: 5a pop %edx
11881b: 53 push %ebx
11881c: 68 80 2c 14 00 push $0x142c80
118821: e8 42 29 00 00 call 11b168 <_Objects_Free>
_Timer_Free( the_timer );
_Thread_Enable_dispatch();
118826: e8 6d 35 00 00 call 11bd98 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
11882b: 83 c4 10 add $0x10,%esp
11882e: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118830: 8b 5d fc mov -0x4(%ebp),%ebx
118833: c9 leave
118834: c3 ret
118835: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118838: b8 04 00 00 00 mov $0x4,%eax
}
11883d: 8b 5d fc mov -0x4(%ebp),%ebx
118840: c9 leave
118841: c3 ret
0010c0b0 <rtems_timer_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
10c0b0: 55 push %ebp
10c0b1: 89 e5 mov %esp,%ebp
10c0b3: 57 push %edi
10c0b4: 56 push %esi
10c0b5: 53 push %ebx
10c0b6: 83 ec 2c sub $0x2c,%esp
10c0b9: 8b 5d 0c mov 0xc(%ebp),%ebx
10c0bc: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
10c0bf: 85 db test %ebx,%ebx
10c0c1: 0f 84 99 00 00 00 je 10c160 <rtems_timer_fire_after+0xb0>
return RTEMS_INVALID_NUMBER;
if ( !routine )
10c0c7: 85 f6 test %esi,%esi
10c0c9: 0f 84 b1 00 00 00 je 10c180 <rtems_timer_fire_after+0xd0>
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
10c0cf: 57 push %edi
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
10c0d0: 8d 45 e4 lea -0x1c(%ebp),%eax
10c0d3: 50 push %eax
10c0d4: ff 75 08 pushl 0x8(%ebp)
10c0d7: 68 40 9a 12 00 push $0x129a40
10c0dc: e8 2f 13 00 00 call 10d410 <_Objects_Get>
10c0e1: 89 c7 mov %eax,%edi
switch ( location ) {
10c0e3: 83 c4 10 add $0x10,%esp
10c0e6: 8b 4d e4 mov -0x1c(%ebp),%ecx
10c0e9: 85 c9 test %ecx,%ecx
10c0eb: 74 0f je 10c0fc <rtems_timer_fire_after+0x4c>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10c0ed: b8 04 00 00 00 mov $0x4,%eax
}
10c0f2: 8d 65 f4 lea -0xc(%ebp),%esp
10c0f5: 5b pop %ebx
10c0f6: 5e pop %esi
10c0f7: 5f pop %edi
10c0f8: c9 leave
10c0f9: c3 ret
10c0fa: 66 90 xchg %ax,%ax
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
10c0fc: 8d 50 10 lea 0x10(%eax),%edx
10c0ff: 83 ec 0c sub $0xc,%esp
10c102: 52 push %edx
10c103: 89 55 d4 mov %edx,-0x2c(%ebp)
10c106: e8 fd 2c 00 00 call 10ee08 <_Watchdog_Remove>
_ISR_Disable( level );
10c10b: 9c pushf
10c10c: fa cli
10c10d: 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 ) {
10c10e: 83 c4 10 add $0x10,%esp
10c111: 8b 57 18 mov 0x18(%edi),%edx
10c114: 85 d2 test %edx,%edx
10c116: 8b 55 d4 mov -0x2c(%ebp),%edx
10c119: 75 55 jne 10c170 <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;
10c11b: 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;
10c122: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
the_watchdog->routine = routine;
10c129: 89 77 2c mov %esi,0x2c(%edi)
the_watchdog->id = id;
10c12c: 8b 4d 08 mov 0x8(%ebp),%ecx
10c12f: 89 4f 30 mov %ecx,0x30(%edi)
the_watchdog->user_data = user_data;
10c132: 8b 4d 14 mov 0x14(%ebp),%ecx
10c135: 89 4f 34 mov %ecx,0x34(%edi)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_ISR_Enable( level );
10c138: 50 push %eax
10c139: 9d popf
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10c13a: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10c13d: 83 ec 08 sub $0x8,%esp
10c140: 52 push %edx
10c141: 68 dc 90 12 00 push $0x1290dc
10c146: e8 7d 2b 00 00 call 10ecc8 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
_Thread_Enable_dispatch();
10c14b: e8 74 1d 00 00 call 10dec4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c150: 83 c4 10 add $0x10,%esp
10c153: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c155: 8d 65 f4 lea -0xc(%ebp),%esp
10c158: 5b pop %ebx
10c159: 5e pop %esi
10c15a: 5f pop %edi
10c15b: c9 leave
10c15c: c3 ret
10c15d: 8d 76 00 lea 0x0(%esi),%esi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
10c160: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c165: 8d 65 f4 lea -0xc(%ebp),%esp
10c168: 5b pop %ebx
10c169: 5e pop %esi
10c16a: 5f pop %edi
10c16b: c9 leave
10c16c: c3 ret
10c16d: 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 );
10c170: 50 push %eax
10c171: 9d popf
_Thread_Enable_dispatch();
10c172: e8 4d 1d 00 00 call 10dec4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10c177: 31 c0 xor %eax,%eax
10c179: e9 74 ff ff ff jmp 10c0f2 <rtems_timer_fire_after+0x42>
10c17e: 66 90 xchg %ax,%ax
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
10c180: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c185: 8d 65 f4 lea -0xc(%ebp),%esp
10c188: 5b pop %ebx
10c189: 5e pop %esi
10c18a: 5f pop %edi
10c18b: c9 leave
10c18c: c3 ret
00118924 <rtems_timer_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
118924: 55 push %ebp
118925: 89 e5 mov %esp,%ebp
118927: 57 push %edi
118928: 56 push %esi
118929: 53 push %ebx
11892a: 83 ec 2c sub $0x2c,%esp
11892d: 8b 75 08 mov 0x8(%ebp),%esi
118930: 8b 7d 0c mov 0xc(%ebp),%edi
118933: 8b 5d 10 mov 0x10(%ebp),%ebx
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
118936: 80 3d 24 22 14 00 00 cmpb $0x0,0x142224
11893d: 75 0d jne 11894c <rtems_timer_fire_when+0x28>
return RTEMS_NOT_DEFINED;
11893f: b8 0b 00 00 00 mov $0xb,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118944: 8d 65 f4 lea -0xc(%ebp),%esp
118947: 5b pop %ebx
118948: 5e pop %esi
118949: 5f pop %edi
11894a: c9 leave
11894b: c3 ret
rtems_interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
11894c: 83 ec 0c sub $0xc,%esp
11894f: 57 push %edi
118950: e8 87 d4 ff ff call 115ddc <_TOD_Validate>
118955: 83 c4 10 add $0x10,%esp
118958: 84 c0 test %al,%al
11895a: 74 1e je 11897a <rtems_timer_fire_when+0x56>
return RTEMS_INVALID_CLOCK;
if ( !routine )
11895c: 85 db test %ebx,%ebx
11895e: 0f 84 a4 00 00 00 je 118a08 <rtems_timer_fire_when+0xe4>
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
118964: 83 ec 0c sub $0xc,%esp
118967: 57 push %edi
118968: e8 e3 d3 ff ff call 115d50 <_TOD_To_seconds>
11896d: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
11896f: 83 c4 10 add $0x10,%esp
118972: 3b 05 e4 22 14 00 cmp 0x1422e4,%eax
118978: 77 0e ja 118988 <rtems_timer_fire_when+0x64>
return RTEMS_INVALID_CLOCK;
11897a: b8 14 00 00 00 mov $0x14,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11897f: 8d 65 f4 lea -0xc(%ebp),%esp
118982: 5b pop %ebx
118983: 5e pop %esi
118984: 5f pop %edi
118985: c9 leave
118986: c3 ret
118987: 90 nop
118988: 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 );
118989: 8d 45 e4 lea -0x1c(%ebp),%eax
11898c: 50 push %eax
11898d: 56 push %esi
11898e: 68 80 2c 14 00 push $0x142c80
118993: e8 4c 29 00 00 call 11b2e4 <_Objects_Get>
switch ( location ) {
118998: 83 c4 10 add $0x10,%esp
11899b: 8b 4d e4 mov -0x1c(%ebp),%ecx
11899e: 85 c9 test %ecx,%ecx
1189a0: 75 5a jne 1189fc <rtems_timer_fire_when+0xd8>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
1189a2: 8d 48 10 lea 0x10(%eax),%ecx
1189a5: 83 ec 0c sub $0xc,%esp
1189a8: 51 push %ecx
1189a9: 89 45 d0 mov %eax,-0x30(%ebp)
1189ac: 89 4d d4 mov %ecx,-0x2c(%ebp)
1189af: e8 bc 45 00 00 call 11cf70 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY;
1189b4: 8b 55 d0 mov -0x30(%ebp),%edx
1189b7: 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;
1189be: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
1189c5: 89 5a 2c mov %ebx,0x2c(%edx)
the_watchdog->id = id;
1189c8: 89 72 30 mov %esi,0x30(%edx)
the_watchdog->user_data = user_data;
1189cb: 8b 45 14 mov 0x14(%ebp),%eax
1189ce: 89 42 34 mov %eax,0x34(%edx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_Watchdog_Insert_seconds(
1189d1: 2b 3d e4 22 14 00 sub 0x1422e4,%edi
1189d7: 89 7a 1c mov %edi,0x1c(%edx)
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
1189da: 58 pop %eax
1189db: 5a pop %edx
1189dc: 8b 4d d4 mov -0x2c(%ebp),%ecx
1189df: 51 push %ecx
1189e0: 68 10 23 14 00 push $0x142310
1189e5: e8 46 44 00 00 call 11ce30 <_Watchdog_Insert>
&the_timer->Ticker,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
1189ea: e8 a9 33 00 00 call 11bd98 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1189ef: 83 c4 10 add $0x10,%esp
1189f2: 31 c0 xor %eax,%eax
1189f4: e9 4b ff ff ff jmp 118944 <rtems_timer_fire_when+0x20>
1189f9: 8d 76 00 lea 0x0(%esi),%esi
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1189fc: b8 04 00 00 00 mov $0x4,%eax
118a01: e9 3e ff ff ff jmp 118944 <rtems_timer_fire_when+0x20>
118a06: 66 90 xchg %ax,%ax
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
118a08: b8 09 00 00 00 mov $0x9,%eax
118a0d: e9 32 ff ff ff jmp 118944 <rtems_timer_fire_when+0x20>
001190bc <rtems_timer_initiate_server>:
rtems_status_code rtems_timer_initiate_server(
uint32_t priority,
uint32_t stack_size,
rtems_attribute attribute_set
)
{
1190bc: 55 push %ebp
1190bd: 89 e5 mov %esp,%ebp
1190bf: 56 push %esi
1190c0: 53 push %ebx
1190c1: 83 ec 10 sub $0x10,%esp
1190c4: 8b 45 08 mov 0x8(%ebp),%eax
1190c7: 85 c0 test %eax,%eax
1190c9: 74 41 je 11910c <rtems_timer_initiate_server+0x50>
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
1190cb: 0f b6 15 d4 9a 13 00 movzbl 0x139ad4,%edx
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
1190d2: 39 d0 cmp %edx,%eax
1190d4: 76 42 jbe 119118 <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 )
1190d6: 40 inc %eax
1190d7: 75 33 jne 11910c <rtems_timer_initiate_server+0x50>
return RTEMS_INVALID_PRIORITY;
_priority = 0;
1190d9: 31 f6 xor %esi,%esi
1190db: 8b 15 10 22 14 00 mov 0x142210,%edx
1190e1: 42 inc %edx
1190e2: 89 15 10 22 14 00 mov %edx,0x142210
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
1190e8: 8a 1d 40 db 13 00 mov 0x13db40,%bl
initialized = true;
1190ee: c6 05 40 db 13 00 01 movb $0x1,0x13db40
_Thread_Enable_dispatch();
1190f5: e8 9e 2c 00 00 call 11bd98 <_Thread_Enable_dispatch>
if ( tmpInitialized )
1190fa: 84 db test %bl,%bl
1190fc: 74 1e je 11911c <rtems_timer_initiate_server+0x60>
return RTEMS_INCORRECT_STATE;
1190fe: b8 0e 00 00 00 mov $0xe,%eax
initialized = false;
}
#endif
return status;
}
119103: 8d 65 f8 lea -0x8(%ebp),%esp
119106: 5b pop %ebx
119107: 5e pop %esi
119108: c9 leave
119109: c3 ret
11910a: 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;
11910c: b8 13 00 00 00 mov $0x13,%eax
initialized = false;
}
#endif
return status;
}
119111: 8d 65 f8 lea -0x8(%ebp),%esp
119114: 5b pop %ebx
119115: 5e pop %esi
119116: c9 leave
119117: c3 ret
119118: 89 c6 mov %eax,%esi
11911a: eb bf jmp 1190db <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(
11911c: 83 ec 08 sub $0x8,%esp
11911f: 8d 45 f4 lea -0xc(%ebp),%eax
119122: 50 push %eax
119123: 8b 45 10 mov 0x10(%ebp),%eax
119126: 80 cc 80 or $0x80,%ah
119129: 50 push %eax
11912a: 68 00 01 00 00 push $0x100
11912f: ff 75 0c pushl 0xc(%ebp)
119132: 56 push %esi
119133: 68 45 4d 49 54 push $0x54494d45
119138: e8 bb 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) {
11913d: 83 c4 20 add $0x20,%esp
119140: 85 c0 test %eax,%eax
119142: 74 10 je 119154 <rtems_timer_initiate_server+0x98>
initialized = false;
119144: c6 05 40 db 13 00 00 movb $0x0,0x13db40
initialized = false;
}
#endif
return status;
}
11914b: 8d 65 f8 lea -0x8(%ebp),%esp
11914e: 5b pop %ebx
11914f: 5e pop %esi
119150: c9 leave
119151: c3 ret
119152: 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)
119154: 8b 45 f4 mov -0xc(%ebp),%eax
*/
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return NULL;
#endif
return information->local_table[ index ];
119157: 0f b7 c8 movzwl %ax,%ecx
11915a: 8b 15 bc 21 14 00 mov 0x1421bc,%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(
119160: 8b 14 8a mov (%edx,%ecx,4),%edx
119163: 89 15 c0 da 13 00 mov %edx,0x13dac0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
119169: c7 05 f0 da 13 00 f4 movl $0x13daf4,0x13daf0
119170: da 13 00
head->previous = NULL;
119173: c7 05 f4 da 13 00 00 movl $0x0,0x13daf4
11917a: 00 00 00
tail->previous = head;
11917d: c7 05 f8 da 13 00 f0 movl $0x13daf0,0x13daf8
119184: da 13 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
119187: c7 05 28 db 13 00 2c movl $0x13db2c,0x13db28
11918e: db 13 00
head->previous = NULL;
119191: c7 05 2c db 13 00 00 movl $0x0,0x13db2c
119198: 00 00 00
tail->previous = head;
11919b: c7 05 30 db 13 00 28 movl $0x13db28,0x13db30
1191a2: db 13 00
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
1191a5: c7 05 d0 da 13 00 00 movl $0x0,0x13dad0
1191ac: 00 00 00
the_watchdog->routine = routine;
1191af: c7 05 e4 da 13 00 e4 movl $0x11bbe4,0x13dae4
1191b6: bb 11 00
the_watchdog->id = id;
1191b9: a3 e8 da 13 00 mov %eax,0x13dae8
the_watchdog->user_data = user_data;
1191be: c7 05 ec da 13 00 00 movl $0x0,0x13daec
1191c5: 00 00 00
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
1191c8: c7 05 08 db 13 00 00 movl $0x0,0x13db08
1191cf: 00 00 00
the_watchdog->routine = routine;
1191d2: c7 05 1c db 13 00 e4 movl $0x11bbe4,0x13db1c
1191d9: bb 11 00
the_watchdog->id = id;
1191dc: a3 20 db 13 00 mov %eax,0x13db20
the_watchdog->user_data = user_data;
1191e1: c7 05 24 db 13 00 00 movl $0x0,0x13db24
1191e8: 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;
1191eb: c7 05 c4 da 13 00 8c movl $0x118f8c,0x13dac4
1191f2: 8f 11 00
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
1191f5: 8b 15 84 23 14 00 mov 0x142384,%edx
1191fb: 89 15 fc da 13 00 mov %edx,0x13dafc
ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
119201: 8b 15 e4 22 14 00 mov 0x1422e4,%edx
119207: 89 15 34 db 13 00 mov %edx,0x13db34
ts->insert_chain = NULL;
11920d: c7 05 38 db 13 00 00 movl $0x0,0x13db38
119214: 00 00 00
ts->active = false;
119217: c6 05 3c db 13 00 00 movb $0x0,0x13db3c
/*
* The default timer server is now available.
*/
_Timer_server = ts;
11921e: c7 05 c0 2c 14 00 c0 movl $0x13dac0,0x142cc0
119225: da 13 00
/*
* Start the timer server
*/
status = rtems_task_start(
119228: 53 push %ebx
119229: 68 c0 da 13 00 push $0x13dac0
11922e: 68 c4 8d 11 00 push $0x118dc4
119233: 50 push %eax
119234: e8 7f f2 ff ff call 1184b8 <rtems_task_start>
if (status) {
initialized = false;
}
#endif
return status;
119239: 83 c4 10 add $0x10,%esp
11923c: e9 d0 fe ff ff jmp 119111 <rtems_timer_initiate_server+0x55>
00118a9c <rtems_timer_reset>:
*/
rtems_status_code rtems_timer_reset(
rtems_id id
)
{
118a9c: 55 push %ebp
118a9d: 89 e5 mov %esp,%ebp
118a9f: 56 push %esi
118aa0: 53 push %ebx
118aa1: 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 );
118aa4: 8d 45 f4 lea -0xc(%ebp),%eax
118aa7: 50 push %eax
118aa8: ff 75 08 pushl 0x8(%ebp)
118aab: 68 80 2c 14 00 push $0x142c80
118ab0: e8 2f 28 00 00 call 11b2e4 <_Objects_Get>
118ab5: 89 c3 mov %eax,%ebx
switch ( location ) {
118ab7: 83 c4 10 add $0x10,%esp
118aba: 8b 45 f4 mov -0xc(%ebp),%eax
118abd: 85 c0 test %eax,%eax
118abf: 74 0f je 118ad0 <rtems_timer_reset+0x34>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118ac1: b8 04 00 00 00 mov $0x4,%eax
}
118ac6: 8d 65 f8 lea -0x8(%ebp),%esp
118ac9: 5b pop %ebx
118aca: 5e pop %esi
118acb: c9 leave
118acc: c3 ret
118acd: 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 ) {
118ad0: 8b 43 38 mov 0x38(%ebx),%eax
118ad3: 85 c0 test %eax,%eax
118ad5: 74 1d je 118af4 <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 ) {
118ad7: 48 dec %eax
118ad8: 74 3a je 118b14 <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;
118ada: b8 0b 00 00 00 mov $0xb,%eax
}
_Thread_Enable_dispatch();
118adf: 89 45 e4 mov %eax,-0x1c(%ebp)
118ae2: e8 b1 32 00 00 call 11bd98 <_Thread_Enable_dispatch>
return status;
118ae7: 8b 45 e4 mov -0x1c(%ebp),%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118aea: 8d 65 f8 lea -0x8(%ebp),%esp
118aed: 5b pop %ebx
118aee: 5e pop %esi
118aef: c9 leave
118af0: c3 ret
118af1: 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 );
118af4: 83 c3 10 add $0x10,%ebx
118af7: 83 ec 0c sub $0xc,%esp
118afa: 53 push %ebx
118afb: e8 70 44 00 00 call 11cf70 <_Watchdog_Remove>
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
118b00: 59 pop %ecx
118b01: 5e pop %esi
118b02: 53 push %ebx
118b03: 68 1c 23 14 00 push $0x14231c
118b08: e8 23 43 00 00 call 11ce30 <_Watchdog_Insert>
118b0d: 83 c4 10 add $0x10,%esp
rtems_id id
)
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
118b10: 31 c0 xor %eax,%eax
118b12: eb cb jmp 118adf <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;
118b14: 8b 35 c0 2c 14 00 mov 0x142cc0,%esi
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
118b1a: 83 ec 0c sub $0xc,%esp
118b1d: 8d 43 10 lea 0x10(%ebx),%eax
118b20: 50 push %eax
118b21: e8 4a 44 00 00 call 11cf70 <_Watchdog_Remove>
(*timer_server->schedule_operation)( timer_server, the_timer );
118b26: 58 pop %eax
118b27: 5a pop %edx
118b28: 53 push %ebx
118b29: 56 push %esi
118b2a: ff 56 04 call *0x4(%esi)
118b2d: 83 c4 10 add $0x10,%esp
rtems_id id
)
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
118b30: 31 c0 xor %eax,%eax
118b32: eb ab jmp 118adf <rtems_timer_reset+0x43>
00118b34 <rtems_timer_server_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
118b34: 55 push %ebp
118b35: 89 e5 mov %esp,%ebp
118b37: 57 push %edi
118b38: 56 push %esi
118b39: 53 push %ebx
118b3a: 83 ec 2c sub $0x2c,%esp
118b3d: 8b 7d 0c mov 0xc(%ebp),%edi
118b40: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
118b43: 8b 1d c0 2c 14 00 mov 0x142cc0,%ebx
if ( !timer_server )
118b49: 85 db test %ebx,%ebx
118b4b: 0f 84 9f 00 00 00 je 118bf0 <rtems_timer_server_fire_after+0xbc>
return RTEMS_INCORRECT_STATE;
if ( !routine )
118b51: 85 f6 test %esi,%esi
118b53: 0f 84 a3 00 00 00 je 118bfc <rtems_timer_server_fire_after+0xc8>
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
118b59: 85 ff test %edi,%edi
118b5b: 75 0f jne 118b6c <rtems_timer_server_fire_after+0x38>
return RTEMS_INVALID_NUMBER;
118b5d: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118b62: 8d 65 f4 lea -0xc(%ebp),%esp
118b65: 5b pop %ebx
118b66: 5e pop %esi
118b67: 5f pop %edi
118b68: c9 leave
118b69: c3 ret
118b6a: 66 90 xchg %ax,%ax
118b6c: 52 push %edx
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
118b6d: 8d 45 e4 lea -0x1c(%ebp),%eax
118b70: 50 push %eax
118b71: ff 75 08 pushl 0x8(%ebp)
118b74: 68 80 2c 14 00 push $0x142c80
118b79: e8 66 27 00 00 call 11b2e4 <_Objects_Get>
118b7e: 89 c2 mov %eax,%edx
switch ( location ) {
118b80: 83 c4 10 add $0x10,%esp
118b83: 8b 45 e4 mov -0x1c(%ebp),%eax
118b86: 85 c0 test %eax,%eax
118b88: 75 56 jne 118be0 <rtems_timer_server_fire_after+0xac>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
118b8a: 83 ec 0c sub $0xc,%esp
118b8d: 8d 42 10 lea 0x10(%edx),%eax
118b90: 50 push %eax
118b91: 89 55 d4 mov %edx,-0x2c(%ebp)
118b94: e8 d7 43 00 00 call 11cf70 <_Watchdog_Remove>
_ISR_Disable( level );
118b99: 9c pushf
118b9a: fa cli
118b9b: 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 ) {
118b9c: 83 c4 10 add $0x10,%esp
118b9f: 8b 55 d4 mov -0x2c(%ebp),%edx
118ba2: 8b 4a 18 mov 0x18(%edx),%ecx
118ba5: 85 c9 test %ecx,%ecx
118ba7: 75 5f jne 118c08 <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;
118ba9: 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;
118bb0: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
118bb7: 89 72 2c mov %esi,0x2c(%edx)
the_watchdog->id = id;
118bba: 8b 4d 08 mov 0x8(%ebp),%ecx
118bbd: 89 4a 30 mov %ecx,0x30(%edx)
the_watchdog->user_data = user_data;
118bc0: 8b 4d 14 mov 0x14(%ebp),%ecx
118bc3: 89 4a 34 mov %ecx,0x34(%edx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = ticks;
118bc6: 89 7a 1c mov %edi,0x1c(%edx)
_ISR_Enable( level );
118bc9: 50 push %eax
118bca: 9d popf
(*timer_server->schedule_operation)( timer_server, the_timer );
118bcb: 83 ec 08 sub $0x8,%esp
118bce: 52 push %edx
118bcf: 53 push %ebx
118bd0: ff 53 04 call *0x4(%ebx)
_Thread_Enable_dispatch();
118bd3: e8 c0 31 00 00 call 11bd98 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
118bd8: 83 c4 10 add $0x10,%esp
118bdb: 31 c0 xor %eax,%eax
118bdd: eb 83 jmp 118b62 <rtems_timer_server_fire_after+0x2e>
118bdf: 90 nop
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118be0: b8 04 00 00 00 mov $0x4,%eax
}
118be5: 8d 65 f4 lea -0xc(%ebp),%esp
118be8: 5b pop %ebx
118be9: 5e pop %esi
118bea: 5f pop %edi
118beb: c9 leave
118bec: c3 ret
118bed: 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;
118bf0: b8 0e 00 00 00 mov $0xe,%eax
118bf5: e9 68 ff ff ff jmp 118b62 <rtems_timer_server_fire_after+0x2e>
118bfa: 66 90 xchg %ax,%ax
if ( !routine )
return RTEMS_INVALID_ADDRESS;
118bfc: b8 09 00 00 00 mov $0x9,%eax
118c01: e9 5c ff ff ff jmp 118b62 <rtems_timer_server_fire_after+0x2e>
118c06: 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 );
118c08: 50 push %eax
118c09: 9d popf
_Thread_Enable_dispatch();
118c0a: e8 89 31 00 00 call 11bd98 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
118c0f: 31 c0 xor %eax,%eax
118c11: e9 4c ff ff ff jmp 118b62 <rtems_timer_server_fire_after+0x2e>
00118c18 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
118c18: 55 push %ebp
118c19: 89 e5 mov %esp,%ebp
118c1b: 57 push %edi
118c1c: 56 push %esi
118c1d: 53 push %ebx
118c1e: 83 ec 2c sub $0x2c,%esp
118c21: 8b 7d 0c mov 0xc(%ebp),%edi
118c24: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
118c27: 8b 1d c0 2c 14 00 mov 0x142cc0,%ebx
if ( !timer_server )
118c2d: 85 db test %ebx,%ebx
118c2f: 0f 84 d7 00 00 00 je 118d0c <rtems_timer_server_fire_when+0xf4>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
118c35: 80 3d 24 22 14 00 00 cmpb $0x0,0x142224
118c3c: 0f 84 aa 00 00 00 je 118cec <rtems_timer_server_fire_when+0xd4><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
118c42: 85 f6 test %esi,%esi
118c44: 0f 84 b2 00 00 00 je 118cfc <rtems_timer_server_fire_when+0xe4>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
118c4a: 83 ec 0c sub $0xc,%esp
118c4d: 57 push %edi
118c4e: e8 89 d1 ff ff call 115ddc <_TOD_Validate>
118c53: 83 c4 10 add $0x10,%esp
118c56: 84 c0 test %al,%al
118c58: 75 0e jne 118c68 <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;
118c5a: b8 14 00 00 00 mov $0x14,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118c5f: 8d 65 f4 lea -0xc(%ebp),%esp
118c62: 5b pop %ebx
118c63: 5e pop %esi
118c64: 5f pop %edi
118c65: c9 leave
118c66: c3 ret
118c67: 90 nop
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
118c68: 83 ec 0c sub $0xc,%esp
118c6b: 57 push %edi
118c6c: e8 df d0 ff ff call 115d50 <_TOD_To_seconds>
118c71: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
118c73: 83 c4 10 add $0x10,%esp
118c76: 3b 05 e4 22 14 00 cmp 0x1422e4,%eax
118c7c: 76 dc jbe 118c5a <rtems_timer_server_fire_when+0x42>
118c7e: 52 push %edx
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
118c7f: 8d 45 e4 lea -0x1c(%ebp),%eax
118c82: 50 push %eax
118c83: ff 75 08 pushl 0x8(%ebp)
118c86: 68 80 2c 14 00 push $0x142c80
118c8b: e8 54 26 00 00 call 11b2e4 <_Objects_Get>
118c90: 89 c2 mov %eax,%edx
switch ( location ) {
118c92: 83 c4 10 add $0x10,%esp
118c95: 8b 45 e4 mov -0x1c(%ebp),%eax
118c98: 85 c0 test %eax,%eax
118c9a: 75 7c jne 118d18 <rtems_timer_server_fire_when+0x100>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
118c9c: 83 ec 0c sub $0xc,%esp
118c9f: 8d 42 10 lea 0x10(%edx),%eax
118ca2: 50 push %eax
118ca3: 89 55 d4 mov %edx,-0x2c(%ebp)
118ca6: e8 c5 42 00 00 call 11cf70 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
118cab: 8b 55 d4 mov -0x2c(%ebp),%edx
118cae: 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;
118cb5: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
the_watchdog->routine = routine;
118cbc: 89 72 2c mov %esi,0x2c(%edx)
the_watchdog->id = id;
118cbf: 8b 45 08 mov 0x8(%ebp),%eax
118cc2: 89 42 30 mov %eax,0x30(%edx)
the_watchdog->user_data = user_data;
118cc5: 8b 45 14 mov 0x14(%ebp),%eax
118cc8: 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();
118ccb: 2b 3d e4 22 14 00 sub 0x1422e4,%edi
118cd1: 89 7a 1c mov %edi,0x1c(%edx)
(*timer_server->schedule_operation)( timer_server, the_timer );
118cd4: 58 pop %eax
118cd5: 59 pop %ecx
118cd6: 52 push %edx
118cd7: 53 push %ebx
118cd8: ff 53 04 call *0x4(%ebx)
_Thread_Enable_dispatch();
118cdb: e8 b8 30 00 00 call 11bd98 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
118ce0: 83 c4 10 add $0x10,%esp
118ce3: 31 c0 xor %eax,%eax
118ce5: e9 75 ff ff ff jmp 118c5f <rtems_timer_server_fire_when+0x47>
118cea: 66 90 xchg %ax,%ax
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
118cec: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118cf1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
118cf4: 5b pop %ebx <== NOT EXECUTED
118cf5: 5e pop %esi <== NOT EXECUTED
118cf6: 5f pop %edi <== NOT EXECUTED
118cf7: c9 leave <== NOT EXECUTED
118cf8: c3 ret <== NOT EXECUTED
118cf9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
118cfc: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
118d01: 8d 65 f4 lea -0xc(%ebp),%esp
118d04: 5b pop %ebx
118d05: 5e pop %esi
118d06: 5f pop %edi
118d07: c9 leave
118d08: c3 ret
118d09: 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;
118d0c: b8 0e 00 00 00 mov $0xe,%eax
118d11: e9 49 ff ff ff jmp 118c5f <rtems_timer_server_fire_when+0x47>
118d16: 66 90 xchg %ax,%ax
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
118d18: b8 04 00 00 00 mov $0x4,%eax
118d1d: e9 3d ff ff ff jmp 118c5f <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 60 e1 12 00 mov 0x12e160,%edx
10c71c: 8d 42 01 lea 0x1(%edx),%eax
10c71f: a3 60 e1 12 00 mov %eax,0x12e160
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 d0 e2 12 00 mov 0x12e2d0,%eax <== NOT EXECUTED
10c72d: 40 inc %eax <== NOT EXECUTED
10c72e: a3 d0 e2 12 00 mov %eax,0x12e2d0 <== NOT EXECUTED
RTEMS_COMPILER_MEMORY_BARRIER();
10c733: a1 60 e1 12 00 mov 0x12e160,%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 bf 12 00 mov 0x12bf20,%eax
10c749: ff 70 08 pushl 0x8(%eax)
10c74c: e8 33 c1 00 00 call 118884 <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 bf 12 00 mov 0x12bf20,%eax
10c774: ff 70 0c pushl 0xc(%eax)
10c777: e8 88 1e 01 00 call 11e604 <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 34 cd 00 00 call 1194cc <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 6a 12 00 push $0x126a69
10c7ab: a1 20 bf 12 00 mov 0x12bf20,%eax
10c7b0: ff 70 0c pushl 0xc(%eax)
10c7b3: e8 c0 c4 00 00 call 118c78 <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 5d 12 00 push $0x125d22
10c7c5: a1 20 bf 12 00 mov 0x12bf20,%eax
10c7ca: ff 70 0c pushl 0xc(%eax)
10c7cd: e8 a6 c4 00 00 call 118c78 <fprintf>
10c7d2: 8d 34 30 lea (%eax,%esi,1),%esi
(void) fflush(stderr);
10c7d5: 58 pop %eax
10c7d6: a1 20 bf 12 00 mov 0x12bf20,%eax
10c7db: ff 70 0c pushl 0xc(%eax)
10c7de: e8 a1 c0 00 00 call 118884 <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 6a 12 00 push $0x126a4e
10c810: a1 20 bf 12 00 mov 0x12bf20,%eax
10c815: ff 70 0c pushl 0xc(%eax)
10c818: e8 5b c4 00 00 call 118c78 <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 bf bc 00 00 call 1184ec <__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 8f cc 00 00 call 1194cc <strerror>
10c83d: 83 c4 0c add $0xc,%esp
10c840: 50 push %eax
10c841: 68 5c 6a 12 00 push $0x126a5c
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 b4 6c 12 00 mov 0x126cb4,%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 c0 6c 12 00 pushl 0x126cc0 <== NOT EXECUTED
108734: e8 17 ce 00 00 call 115550 <__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 c0 6c 12 00 pushl 0x126cc0
1087dd: e8 6e cd 00 00 call 115550 <__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 d4 81 00 00 call 114024 <__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 7c 45 12 00 movzbl 0x12457c,%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 9c 81 00 00 call 114024 <__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 20 88 12 00 pushl 0x128820
10bebd: e8 92 35 00 00 call 10f454 <_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 46 81 00 00 call 114024 <__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 34 81 00 00 call 114024 <__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 40 d6 12 00 push $0x12d640
10e618: e8 c7 21 00 00 call 1107e4 <_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 30 90 00 00 call 11765c <__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 1c 64 00 00 call 114a64 <_POSIX_Semaphore_Delete>
_Thread_Enable_dispatch();
10e648: e8 cb 2c 00 00 call 111318 <_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 40 d6 12 00 push $0x12d640
10e668: e8 77 21 00 00 call 1107e4 <_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 e0 8f 00 00 call 11765c <__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 c9 63 00 00 call 114a64 <_POSIX_Semaphore_Delete>
_Thread_Enable_dispatch();
10e69b: e8 78 2c 00 00 call 111318 <_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 6b 2c 00 00 call 111318 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EINVAL );
10e6ad: e8 aa 8f 00 00 call 11765c <__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 40 d6 12 00 push $0x12d640
10e6d4: e8 0b 21 00 00 call 1107e4 <_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 74 8f 00 00 call 11765c <__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 13 2c 00 00 call 111318 <_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 f0 d2 12 00 mov 0x12d2f0,%eax
10e765: 40 inc %eax
10e766: a3 f0 d2 12 00 mov %eax,0x12d2f0
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 26 63 00 00 call 114ab4 <_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 73 2b 00 00 call 111318 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
10e7a5: e8 b2 8e 00 00 call 11765c <__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 40 d6 12 00 push $0x12d640
10e7d8: e8 07 20 00 00 call 1107e4 <_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 30 2b 00 00 call 111318 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
10e7e8: e8 2b 2b 00 00 call 111318 <_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 3d 61 00 00 call 114958 <_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 f6 2a 00 00 call 111318 <_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 e3 2a 00 00 call 111318 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
10e835: e8 22 8e 00 00 call 11765c <__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 40 d6 12 00 push $0x12d640
10e85c: e8 83 1f 00 00 call 1107e4 <_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 ec 8d 00 00 call 11765c <__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 65 15 00 00 call 10fdf4 <_CORE_semaphore_Surrender>
NULL /* XXX need to define a routine to handle this case */
#else
NULL
#endif
);
_Thread_Enable_dispatch();
10e88f: e8 84 2a 00 00 call 111318 <_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 36 55 00 00 call 113de8 <_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 5a 62 00 00 call 114b20 <_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 44 62 00 00 call 114b20 <_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 21 87 00 00 call 113a34 <__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 0f 87 00 00 call 113a34 <__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 fb 86 00 00 call 113a34 <__errno>
10b339: c7 00 0e 00 00 00 movl $0xe,(%eax)
10b33f: eb d8 jmp 10b319 <setitimer+0x25>
0010bd50 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
10bd50: 55 push %ebp
10bd51: 89 e5 mov %esp,%ebp
10bd53: 57 push %edi
10bd54: 56 push %esi
10bd55: 53 push %ebx
10bd56: 83 ec 1c sub $0x1c,%esp
10bd59: 8b 5d 08 mov 0x8(%ebp),%ebx
10bd5c: 8b 45 0c mov 0xc(%ebp),%eax
10bd5f: 8b 55 10 mov 0x10(%ebp),%edx
ISR_Level level;
if ( oact )
10bd62: 85 d2 test %edx,%edx
10bd64: 74 13 je 10bd79 <sigaction+0x29>
*oact = _POSIX_signals_Vectors[ sig ];
10bd66: 8d 0c 5b lea (%ebx,%ebx,2),%ecx
10bd69: 8d 34 8d e0 8b 12 00 lea 0x128be0(,%ecx,4),%esi
10bd70: b9 03 00 00 00 mov $0x3,%ecx
10bd75: 89 d7 mov %edx,%edi
10bd77: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !sig )
10bd79: 85 db test %ebx,%ebx
10bd7b: 74 77 je 10bdf4 <sigaction+0xa4>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10bd7d: 8d 53 ff lea -0x1(%ebx),%edx
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
10bd80: 83 fa 1f cmp $0x1f,%edx
10bd83: 77 6f ja 10bdf4 <sigaction+0xa4>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
10bd85: 83 fb 09 cmp $0x9,%ebx
10bd88: 74 6a je 10bdf4 <sigaction+0xa4>
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
10bd8a: 85 c0 test %eax,%eax
10bd8c: 74 62 je 10bdf0 <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 );
10bd8e: 9c pushf
10bd8f: fa cli
10bd90: 8f 45 e4 popl -0x1c(%ebp)
if ( act->sa_handler == SIG_DFL ) {
10bd93: 8b 50 08 mov 0x8(%eax),%edx
10bd96: 85 d2 test %edx,%edx
10bd98: 74 36 je 10bdd0 <sigaction+0x80>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
10bd9a: 83 ec 0c sub $0xc,%esp
10bd9d: 53 push %ebx
10bd9e: 89 45 e0 mov %eax,-0x20(%ebp)
10bda1: e8 96 57 00 00 call 11153c <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
10bda6: 8d 14 5b lea (%ebx,%ebx,2),%edx
10bda9: 8d 14 95 e0 8b 12 00 lea 0x128be0(,%edx,4),%edx
10bdb0: b9 03 00 00 00 mov $0x3,%ecx
10bdb5: 8b 45 e0 mov -0x20(%ebp),%eax
10bdb8: 89 d7 mov %edx,%edi
10bdba: 89 c6 mov %eax,%esi
10bdbc: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10bdbe: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10bdc1: ff 75 e4 pushl -0x1c(%ebp)
10bdc4: 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;
10bdc5: 31 c0 xor %eax,%eax
}
10bdc7: 8d 65 f4 lea -0xc(%ebp),%esp
10bdca: 5b pop %ebx
10bdcb: 5e pop %esi
10bdcc: 5f pop %edi
10bdcd: c9 leave
10bdce: c3 ret
10bdcf: 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 ];
10bdd0: 8d 34 5b lea (%ebx,%ebx,2),%esi
10bdd3: c1 e6 02 shl $0x2,%esi
10bdd6: 8d 86 e0 8b 12 00 lea 0x128be0(%esi),%eax
10bddc: 81 c6 20 30 12 00 add $0x123020,%esi
10bde2: b9 03 00 00 00 mov $0x3,%ecx
10bde7: 89 c7 mov %eax,%edi
10bde9: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10bdeb: eb d4 jmp 10bdc1 <sigaction+0x71>
10bded: 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;
10bdf0: 31 c0 xor %eax,%eax
10bdf2: eb d3 jmp 10bdc7 <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 );
10bdf4: e8 27 85 00 00 call 114320 <__errno>
10bdf9: c7 00 16 00 00 00 movl $0x16,(%eax)
10bdff: b8 ff ff ff ff mov $0xffffffff,%eax
10be04: eb c1 jmp 10bdc7 <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 19 36 00 00 call 10f764 <_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 6d 36 00 00 call 10f7cc <_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 38 a2 12 00 mov 0x12a238,%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 a8 a4 12 00 mov 0x12a4a8,%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 50 9c 12 00 mov 0x129c50,%esi
10c1b2: 46 inc %esi
10c1b3: 89 35 50 9c 12 00 mov %esi,0x129c50
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
10c1b9: c7 41 44 40 a4 12 00 movl $0x12a440,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 70 a4 12 00 01 movl $0x1,0x12a470
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 48 f4 10 00 push $0x10f448
10c1e3: 50 push %eax
10c1e4: 68 40 a4 12 00 push $0x12a440
10c1e9: 89 55 cc mov %edx,-0x34(%ebp)
10c1ec: e8 2b 2f 00 00 call 10f11c <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10c1f1: e8 4a 2a 00 00 call 10ec40 <_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 1d 5a 00 00 call 111c28 <_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 38 a2 12 00 mov 0x12a238,%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> <== NEVER TAKEN
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 ca 59 00 00 call 111c28 <_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 72 59 00 00 call 111c28 <_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 87 86 00 00 call 114964 <__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 6f 86 00 00 call 114964 <__errno>
10c2f5: 8b 15 38 a2 12 00 mov 0x12a238,%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 5b 81 00 00 call 116124 <__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 ff 87 00 00 call 111748 <__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 <== NOT EXECUTED
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 97 12 00 mov 0x129778,%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 9b b1 00 00 call 11539c <_fwalk>
_Thread_Executing->libc_reent = current_reent;
10a201: a1 78 97 12 00 mov 0x129778,%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 fe a5 00 00 call 114e8c <__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 d9 71 00 00 call 111a84 <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 ba 71 00 00 jmp 111a84 <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 90 98 12 00 mov 0x129890,%eax
10b547: 40 inc %eax
10b548: a3 90 98 12 00 mov %eax,0x129890
* 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 9c 12 00 push $0x129c20
10b555: e8 9e 1e 00 00 call 10d3f8 <_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 9e 12 00 mov 0x129e78,%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 9c 12 00 mov 0x129c3c,%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 7e 2d 00 00 call 10e364 <_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 d3 8a 00 00 call 1140c8 <__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 58 2d 00 00 call 10e364 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
10b60c: e8 b7 8a 00 00 call 1140c8 <__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 9b 12 00 push $0x129b00
10ba57: e8 a4 21 00 00 call 10dc00 <_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 6b 8d 00 00 call 1147d8 <__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 9b 12 00 push $0x129b00
10ba89: e8 36 1d 00 00 call 10d7c4 <_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 43 3c 00 00 call 10f6e0 <_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 9b 12 00 push $0x129b00
10baa5: e8 16 20 00 00 call 10dac0 <_Objects_Free>
_POSIX_Timer_Free( ptimer );
_Thread_Enable_dispatch();
10baaa: e8 05 2c 00 00 call 10e6b4 <_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 c0 b1 12 00 push $0x12b1c0
10c913: e8 2c 21 00 00 call 10ea44 <_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 31 89 00 00 call 115258 <__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 ad 2b 00 00 call 10f4f8 <_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 01 17 00 00 call 10e070 <_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 c0 b1 12 00 push $0x12b1c0
10c97e: e8 c1 20 00 00 call 10ea44 <_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 a4 af 12 00 mov 0x12afa4,%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 73 36 00 00 call 11001c <_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 3f 2b 00 00 call 10f4f8 <_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 8b 88 00 00 call 115258 <__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 6c 38 00 00 call 10eeac <_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 58 38 00 00 call 10eeac <_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 9c 12 00 push $0x129c20
10b692: e8 19 22 00 00 call 10d8b0 <_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 4f 38 00 00 call 10ef14 <_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 3e 38 00 00 call 10ef14 <_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 3e 61 00 00 call 11182c <_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 ce 17 00 00 call 10cf00 <_TOD_Get>
_Thread_Enable_dispatch();
10b732: e8 2d 2c 00 00 call 10e364 <_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 a1 17 00 00 call 10cf00 <_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 1d 37 00 00 call 10ee88 <_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 59 37 00 00 call 10eed4 <_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 3f 89 00 00 call 1140c8 <__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 a1 3b 00 00 call 10f348 <_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 8c 2b 00 00 call 10e364 <_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 7b 2b 00 00 call 10e364 <_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 9c 8f 12 00 mov 0x128f9c,%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 80 8f 12 00 push $0x128f80
10b431: e8 72 3a 00 00 call 10eea8 <_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 70 35 00 00 call 10e9fc <_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 68 35 00 00 call 10e9fc <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b494: a3 8c 8f 12 00 mov %eax,0x128f8c
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b499: 58 pop %eax
10b49a: 5a pop %edx
10b49b: 68 80 8f 12 00 push $0x128f80
10b4a0: 68 9c 86 12 00 push $0x12869c
10b4a5: e8 be 38 00 00 call 10ed68 <_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 88 8f 12 00 00 movl $0x0,0x128f88
10b4bf: 00 00 00
the_watchdog->routine = routine;
10b4c2: c7 05 9c 8f 12 00 d4 movl $0x10b3d4,0x128f9c
10b4c9: b3 10 00
the_watchdog->id = id;
10b4cc: c7 05 a0 8f 12 00 00 movl $0x0,0x128fa0
10b4d3: 00 00 00
the_watchdog->user_data = user_data;
10b4d6: c7 05 a4 8f 12 00 00 movl $0x0,0x128fa4
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 94 8f 12 00 mov 0x128f94,%eax
10b4ed: 03 05 8c 8f 12 00 add 0x128f8c,%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 98 8f 12 00 sub 0x128f98,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
10b500: 50 push %eax
10b501: e8 6e 34 00 00 call 10e974 <_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 0f b4 00 00 call 1170d8 <__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 7d 12 00 mov 0x127d50,%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 48 a0 12 00 pushl 0x12a048
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 77 14 00 00 call 10d2b0 <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10be39: 58 pop %eax
10be3a: ff 35 48 a0 12 00 pushl 0x12a048
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 ee 84 00 00 call 114364 <__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 d3 84 00 00 call 114364 <__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 ed 10 00 00 call 10cfb0 <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 7a c9 00 00 call 118900 <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 08 33 12 00 call *0x123308
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 08 33 12 00 call *0x123308
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 08 33 12 00 call *0x123308
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 0c 12 00 movsbl 0x120c0a(%eax),%eax
10ad89: 50 push %eax
10ad8a: ff 15 08 33 12 00 call *0x123308
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 08 33 12 00 call *0x123308
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 08 33 12 00 call *0x123308
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 08 33 12 00 call *0x123308
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 08 33 12 00 call *0x123308
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 08 33 12 00 call *0x123308
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 08 33 12 00 call *0x123308
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 0c 12 00 mov $0x120c09,%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>
0011ec0c <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
11ec0c: 55 push %ebp
11ec0d: 89 e5 mov %esp,%ebp
11ec0f: 53 push %ebx
11ec10: 83 ec 04 sub $0x4,%esp
11ec13: 8b 4d 08 mov 0x8(%ebp),%ecx
11ec16: 8b 45 0c mov 0xc(%ebp),%eax
11ec19: 8b 55 10 mov 0x10(%ebp),%edx
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
11ec1c: 3b 0d ac 31 12 00 cmp 0x1231ac,%ecx
11ec22: 73 50 jae 11ec74 <write+0x68>
iop = rtems_libio_iop( fd );
11ec24: c1 e1 03 shl $0x3,%ecx
11ec27: 8d 1c cd 00 00 00 00 lea 0x0(,%ecx,8),%ebx
11ec2e: 29 cb sub %ecx,%ebx
11ec30: 03 1d 00 74 12 00 add 0x127400,%ebx
rtems_libio_check_is_open( iop );
11ec36: 8b 4b 14 mov 0x14(%ebx),%ecx
11ec39: f6 c5 01 test $0x1,%ch
11ec3c: 74 36 je 11ec74 <write+0x68>
rtems_libio_check_buffer( buffer );
11ec3e: 85 c0 test %eax,%eax
11ec40: 74 46 je 11ec88 <write+0x7c> <== NEVER TAKEN
rtems_libio_check_count( count );
11ec42: 85 d2 test %edx,%edx
11ec44: 74 26 je 11ec6c <write+0x60>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
11ec46: 83 e1 04 and $0x4,%ecx
11ec49: 74 3d je 11ec88 <write+0x7c>
/*
* Now process the write() request.
*/
rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
11ec4b: 51 push %ecx
11ec4c: 8b 4b 20 mov 0x20(%ebx),%ecx
11ec4f: 52 push %edx
11ec50: 50 push %eax
11ec51: 53 push %ebx
11ec52: ff 51 0c call *0xc(%ecx)
if ( rc > 0 )
11ec55: 83 c4 10 add $0x10,%esp
11ec58: 85 c0 test %eax,%eax
11ec5a: 7e 0b jle 11ec67 <write+0x5b>
iop->offset += rc;
11ec5c: 89 c1 mov %eax,%ecx
11ec5e: c1 f9 1f sar $0x1f,%ecx
11ec61: 01 43 0c add %eax,0xc(%ebx)
11ec64: 11 4b 10 adc %ecx,0x10(%ebx)
return rc;
}
11ec67: 8b 5d fc mov -0x4(%ebp),%ebx
11ec6a: c9 leave
11ec6b: 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 );
11ec6c: 31 c0 xor %eax,%eax
if ( rc > 0 )
iop->offset += rc;
return rc;
}
11ec6e: 8b 5d fc mov -0x4(%ebp),%ebx
11ec71: c9 leave
11ec72: c3 ret
11ec73: 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 );
11ec74: e8 9b 46 ff ff call 113314 <__errno>
11ec79: c7 00 09 00 00 00 movl $0x9,(%eax)
11ec7f: b8 ff ff ff ff mov $0xffffffff,%eax
11ec84: eb e1 jmp 11ec67 <write+0x5b>
11ec86: 66 90 xchg %ax,%ax
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
11ec88: e8 87 46 ff ff call 113314 <__errno>
11ec8d: c7 00 16 00 00 00 movl $0x16,(%eax)
11ec93: b8 ff ff ff ff mov $0xffffffff,%eax
11ec98: eb cd jmp 11ec67 <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 cc 47 12 00 cmp 0x1247cc,%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 20 8a 12 00 mov 0x128a20,%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 33 80 00 00 call 1140a4 <__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 db 7f 00 00 call 1140a4 <__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