RTEMS 4.9.6Annotated Report
Sun Jul 24 19:09:13 2011
0010c238 <IMFS_Set_handlers>:
#define MAXSYMLINK 5
int IMFS_Set_handlers(
rtems_filesystem_location_info_t *loc
)
{
10c238: 55 push %ebp
10c239: 89 e5 mov %esp,%ebp
10c23b: 8b 4d 08 mov 0x8(%ebp),%ecx
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
10c23e: 8b 41 0c mov 0xc(%ecx),%eax
10c241: 8b 50 2c mov 0x2c(%eax),%edx
switch( node->type ) {
10c244: 8b 01 mov (%ecx),%eax
10c246: 8b 40 4c mov 0x4c(%eax),%eax
10c249: 48 dec %eax
10c24a: 83 f8 05 cmp $0x5,%eax
10c24d: 77 24 ja 10c273 <IMFS_Set_handlers+0x3b><== NEVER TAKEN
10c24f: ff 24 85 c4 75 11 00 jmp *0x1175c4(,%eax,4)
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
10c256: 8b 42 08 mov 0x8(%edx),%eax
10c259: eb 15 jmp 10c270 <IMFS_Set_handlers+0x38>
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
10c25b: c7 41 04 b8 76 11 00 movl $0x1176b8,0x4(%ecx)
10c262: eb 0f jmp 10c273 <IMFS_Set_handlers+0x3b>
break;
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
10c264: c7 41 04 f0 76 11 00 movl $0x1176f0,0x4(%ecx)
10c26b: eb 06 jmp 10c273 <IMFS_Set_handlers+0x3b>
break;
case IMFS_LINEAR_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
10c26d: 8b 42 04 mov 0x4(%edx),%eax
10c270: 89 41 04 mov %eax,0x4(%ecx)
break;
}
return 0;
}
10c273: 31 c0 xor %eax,%eax
10c275: c9 leave
10c276: c3 ret
0010d718 <IMFS_chown>:
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
10d718: 55 push %ebp
10d719: 89 e5 mov %esp,%ebp
10d71b: 57 push %edi
10d71c: 56 push %esi
10d71d: 53 push %ebx
10d71e: 83 ec 1c sub $0x1c,%esp
10d721: 8b 75 0c mov 0xc(%ebp),%esi
10d724: 8b 7d 10 mov 0x10(%ebp),%edi
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = (IMFS_jnode_t *) pathloc->node_access;
10d727: 8b 45 08 mov 0x8(%ebp),%eax
10d72a: 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();
10d72c: e8 87 0c 00 00 call 10e3b8 <geteuid>
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
10d731: 66 3b 43 3c cmp 0x3c(%ebx),%ax
10d735: 74 15 je 10d74c <IMFS_chown+0x34> <== ALWAYS TAKEN
10d737: 66 85 c0 test %ax,%ax <== NOT EXECUTED
10d73a: 74 10 je 10d74c <IMFS_chown+0x34> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
10d73c: e8 9f 38 00 00 call 110fe0 <__errno> <== NOT EXECUTED
10d741: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
10d747: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10d74a: eb 20 jmp 10d76c <IMFS_chown+0x54> <== NOT EXECUTED
#endif
jnode->st_uid = owner;
10d74c: 66 89 73 3c mov %si,0x3c(%ebx)
jnode->st_gid = group;
10d750: 66 89 7b 3e mov %di,0x3e(%ebx)
IMFS_update_ctime( jnode );
10d754: 50 push %eax
10d755: 50 push %eax
10d756: 6a 00 push $0x0
10d758: 8d 45 ec lea -0x14(%ebp),%eax
10d75b: 50 push %eax
10d75c: e8 07 9d ff ff call 107468 <gettimeofday>
10d761: 8b 45 ec mov -0x14(%ebp),%eax
10d764: 89 43 48 mov %eax,0x48(%ebx)
10d767: 31 c0 xor %eax,%eax
10d769: 83 c4 10 add $0x10,%esp
return 0;
}
10d76c: 8d 65 f4 lea -0xc(%ebp),%esp
10d76f: 5b pop %ebx
10d770: 5e pop %esi
10d771: 5f pop %edi
10d772: c9 leave
10d773: c3 ret
0010e770 <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
10e770: 55 push %ebp
10e771: 89 e5 mov %esp,%ebp
10e773: 57 push %edi
10e774: 56 push %esi
10e775: 53 push %ebx
10e776: 83 ec 1c sub $0x1c,%esp
10e779: 8b 75 14 mov 0x14(%ebp),%esi
IMFS_jnode_t *node;
struct timeval tv;
IMFS_jnode_t *parent = NULL;
IMFS_fs_info_t *fs_info;
if ( parent_loc != NULL )
10e77c: 31 ff xor %edi,%edi
10e77e: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
10e782: 74 05 je 10e789 <IMFS_create_node+0x19>
parent = parent_loc->node_access;
10e784: 8b 45 08 mov 0x8(%ebp),%eax
10e787: 8b 38 mov (%eax),%edi
/*
* Allocate an IMFS jnode
*/
node = calloc( 1, sizeof( IMFS_jnode_t ) );
10e789: 50 push %eax
10e78a: 50 push %eax
10e78b: 6a 60 push $0x60
10e78d: 6a 01 push $0x1
10e78f: e8 3c e5 ff ff call 10ccd0 <calloc>
10e794: 89 c3 mov %eax,%ebx
if ( !node )
10e796: 83 c4 10 add $0x10,%esp
10e799: 85 c0 test %eax,%eax
10e79b: 0f 84 00 01 00 00 je 10e8a1 <IMFS_create_node+0x131><== NEVER TAKEN
/*
* Fill in the basic information
*/
node->st_nlink = 1;
10e7a1: 66 c7 40 34 01 00 movw $0x1,0x34(%eax)
node->type = type;
10e7a7: 8b 55 0c mov 0xc(%ebp),%edx
10e7aa: 89 50 4c mov %edx,0x4c(%eax)
strncpy( node->name, name, IMFS_NAME_MAX );
10e7ad: 50 push %eax
10e7ae: 6a 20 push $0x20
10e7b0: ff 75 10 pushl 0x10(%ebp)
10e7b3: 8d 43 0c lea 0xc(%ebx),%eax
10e7b6: 50 push %eax
10e7b7: e8 f4 1b 00 00 call 1103b0 <strncpy>
/*
* Fill in the mode and permission information for the jnode structure.
*/
node->st_mode = mode & ~rtems_filesystem_umask;
10e7bc: a1 6c b6 11 00 mov 0x11b66c,%eax
10e7c1: 8b 40 24 mov 0x24(%eax),%eax
10e7c4: f7 d0 not %eax
10e7c6: 21 c6 and %eax,%esi
10e7c8: 89 73 30 mov %esi,0x30(%ebx)
#if defined(RTEMS_POSIX_API)
node->st_uid = geteuid();
10e7cb: e8 74 e6 ff ff call 10ce44 <geteuid>
10e7d0: 66 89 43 3c mov %ax,0x3c(%ebx)
node->st_gid = getegid();
10e7d4: e8 5b e6 ff ff call 10ce34 <getegid>
10e7d9: 66 89 43 3e mov %ax,0x3e(%ebx)
/*
* Now set all the times.
*/
gettimeofday( &tv, 0 );
10e7dd: 5a pop %edx
10e7de: 59 pop %ecx
10e7df: 6a 00 push $0x0
10e7e1: 8d 45 ec lea -0x14(%ebp),%eax
10e7e4: 50 push %eax
10e7e5: e8 6a e6 ff ff call 10ce54 <gettimeofday>
node->stat_atime = (time_t) tv.tv_sec;
10e7ea: 8b 45 ec mov -0x14(%ebp),%eax
10e7ed: 89 43 40 mov %eax,0x40(%ebx)
node->stat_mtime = (time_t) tv.tv_sec;
10e7f0: 89 43 44 mov %eax,0x44(%ebx)
node->stat_ctime = (time_t) tv.tv_sec;
10e7f3: 89 43 48 mov %eax,0x48(%ebx)
/*
* Set the type specific information
*/
switch (type) {
10e7f6: 83 c4 10 add $0x10,%esp
10e7f9: 8b 45 0c mov 0xc(%ebp),%eax
10e7fc: 48 dec %eax
10e7fd: 83 f8 05 cmp $0x5,%eax
10e800: 77 62 ja 10e864 <IMFS_create_node+0xf4> <== NEVER TAKEN
10e802: ff 24 85 e0 7a 11 00 jmp *0x117ae0(,%eax,4)
10e809: 8d 43 54 lea 0x54(%ebx),%eax
10e80c: 89 43 50 mov %eax,0x50(%ebx)
10e80f: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx)
10e816: 8d 43 50 lea 0x50(%ebx),%eax
10e819: 89 43 58 mov %eax,0x58(%ebx)
10e81c: eb 5c jmp 10e87a <IMFS_create_node+0x10a>
case IMFS_HARD_LINK:
node->info.hard_link.link_node = info->hard_link.link_node;
break;
case IMFS_SYM_LINK:
node->info.sym_link.name = info->sym_link.name;
10e81e: 8b 55 18 mov 0x18(%ebp),%edx
10e821: 8b 02 mov (%edx),%eax
10e823: 89 43 50 mov %eax,0x50(%ebx)
10e826: eb 52 jmp 10e87a <IMFS_create_node+0x10a>
break;
case IMFS_DEVICE:
node->info.device.major = info->device.major;
10e828: 8b 55 18 mov 0x18(%ebp),%edx
10e82b: 8b 02 mov (%edx),%eax
10e82d: 89 43 50 mov %eax,0x50(%ebx)
node->info.device.minor = info->device.minor;
10e830: 8b 42 04 mov 0x4(%edx),%eax
10e833: 89 43 54 mov %eax,0x54(%ebx)
10e836: eb 42 jmp 10e87a <IMFS_create_node+0x10a>
break;
case IMFS_LINEAR_FILE:
node->info.linearfile.size = 0;
10e838: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED
node->info.linearfile.direct = 0;
10e83f: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED
case IMFS_MEMORY_FILE:
node->info.file.size = 0;
10e846: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
node->info.file.indirect = 0;
10e84d: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx)
node->info.file.doubly_indirect = 0;
10e854: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx)
node->info.file.triply_indirect = 0;
10e85b: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
10e862: eb 16 jmp 10e87a <IMFS_create_node+0x10a>
break;
default:
assert(0);
10e864: 68 a3 6b 11 00 push $0x116ba3 <== NOT EXECUTED
10e869: 68 f8 7a 11 00 push $0x117af8 <== NOT EXECUTED
10e86e: 6a 74 push $0x74 <== NOT EXECUTED
10e870: 68 90 7a 11 00 push $0x117a90 <== NOT EXECUTED
10e875: e8 0e 7a ff ff call 106288 <__assert_func> <== NOT EXECUTED
/*
* If this node has a parent, then put it in that directory list.
*/
if ( parent ) {
10e87a: 85 ff test %edi,%edi
10e87c: 74 23 je 10e8a1 <IMFS_create_node+0x131>
10e87e: 50 push %eax
10e87f: 50 push %eax
10e880: 53 push %ebx
10e881: 8d 47 50 lea 0x50(%edi),%eax
10e884: 50 push %eax
10e885: e8 62 b2 ff ff call 109aec <_Chain_Append>
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
node->Parent = parent;
10e88a: 89 7b 08 mov %edi,0x8(%ebx)
fs_info = parent_loc->mt_entry->fs_info;
10e88d: 8b 55 08 mov 0x8(%ebp),%edx
10e890: 8b 42 0c mov 0xc(%edx),%eax
10e893: 8b 50 2c mov 0x2c(%eax),%edx
node->st_ino = ++fs_info->ino_count;
10e896: 8b 02 mov (%edx),%eax
10e898: 40 inc %eax
10e899: 89 02 mov %eax,(%edx)
10e89b: 89 43 38 mov %eax,0x38(%ebx)
10e89e: 83 c4 10 add $0x10,%esp
}
return node;
}
10e8a1: 89 d8 mov %ebx,%eax
10e8a3: 8d 65 f4 lea -0xc(%ebp),%esp
10e8a6: 5b pop %ebx
10e8a7: 5e pop %esi
10e8a8: 5f pop %edi
10e8a9: c9 leave
10e8aa: c3 ret
00107936 <IMFS_dump_directory>:
void IMFS_dump_directory(
IMFS_jnode_t *the_directory,
int level
)
{
107936: 55 push %ebp
107937: 89 e5 mov %esp,%ebp
107939: 57 push %edi
10793a: 56 push %esi
10793b: 53 push %ebx
10793c: 83 ec 0c sub $0xc,%esp
10793f: 8b 45 08 mov 0x8(%ebp),%eax
107942: 8b 7d 0c mov 0xc(%ebp),%edi
rtems_chain_node *the_node;
rtems_chain_control *the_chain;
IMFS_jnode_t *the_jnode;
int i;
assert( the_directory );
107945: 85 c0 test %eax,%eax
107947: 75 0e jne 107957 <IMFS_dump_directory+0x21><== ALWAYS TAKEN
107949: 68 2b cc 11 00 push $0x11cc2b <== NOT EXECUTED
10794e: 68 14 cd 11 00 push $0x11cd14 <== NOT EXECUTED
107953: 6a 7f push $0x7f <== NOT EXECUTED
107955: eb 13 jmp 10796a <IMFS_dump_directory+0x34><== NOT EXECUTED
assert( level >= 0 );
107957: 85 ff test %edi,%edi
107959: 79 19 jns 107974 <IMFS_dump_directory+0x3e><== ALWAYS TAKEN
10795b: 68 39 cc 11 00 push $0x11cc39 <== NOT EXECUTED
107960: 68 14 cd 11 00 push $0x11cd14 <== NOT EXECUTED
107965: 68 81 00 00 00 push $0x81 <== NOT EXECUTED
10796a: 68 8c cb 11 00 push $0x11cb8c <== NOT EXECUTED
10796f: e8 d8 05 00 00 call 107f4c <__assert_func> <== NOT EXECUTED
assert( the_directory->type == IMFS_DIRECTORY );
107974: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
107978: 74 11 je 10798b <IMFS_dump_directory+0x55><== ALWAYS TAKEN
10797a: 68 44 cc 11 00 push $0x11cc44 <== NOT EXECUTED
10797f: 68 14 cd 11 00 push $0x11cd14 <== NOT EXECUTED
107984: 68 83 00 00 00 push $0x83 <== NOT EXECUTED
107989: eb df jmp 10796a <IMFS_dump_directory+0x34><== NOT EXECUTED
the_chain = &the_directory->info.directory.Entries;
for ( the_node = the_chain->first;
10798b: 8b 70 50 mov 0x50(%eax),%esi
10798e: 83 c0 54 add $0x54,%eax
107991: 89 45 f0 mov %eax,-0x10(%ebp)
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 );
107994: 8d 47 01 lea 0x1(%edi),%eax
107997: 89 45 ec mov %eax,-0x14(%ebp)
10799a: eb 40 jmp 1079dc <IMFS_dump_directory+0xa6>
for ( the_node = the_chain->first;
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
10799c: 31 db xor %ebx,%ebx
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
10799e: 50 push %eax
10799f: 50 push %eax
1079a0: a1 80 14 12 00 mov 0x121480,%eax
1079a5: ff 70 08 pushl 0x8(%eax)
1079a8: 68 6a cc 11 00 push $0x11cc6a
1079ad: e8 a2 b2 00 00 call 112c54 <fputs>
!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++ )
1079b2: 43 inc %ebx
1079b3: 83 c4 10 add $0x10,%esp
1079b6: 39 fb cmp %edi,%ebx
1079b8: 7e e4 jle 10799e <IMFS_dump_directory+0x68>
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
1079ba: 83 ec 0c sub $0xc,%esp
1079bd: 56 push %esi
1079be: e8 73 fe ff ff call 107836 <IMFS_print_jnode>
if ( the_jnode->type == IMFS_DIRECTORY )
1079c3: 83 c4 10 add $0x10,%esp
1079c6: 83 7e 4c 01 cmpl $0x1,0x4c(%esi)
1079ca: 75 0e jne 1079da <IMFS_dump_directory+0xa4>
IMFS_dump_directory( the_jnode, level + 1 );
1079cc: 50 push %eax
1079cd: 50 push %eax
1079ce: ff 75 ec pushl -0x14(%ebp)
1079d1: 56 push %esi
1079d2: e8 5f ff ff ff call 107936 <IMFS_dump_directory>
1079d7: 83 c4 10 add $0x10,%esp
the_chain = &the_directory->info.directory.Entries;
for ( the_node = the_chain->first;
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
1079da: 8b 36 mov (%esi),%esi
assert( the_directory->type == IMFS_DIRECTORY );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = the_chain->first;
!rtems_chain_is_tail( the_chain, the_node );
1079dc: 3b 75 f0 cmp -0x10(%ebp),%esi
1079df: 75 bb jne 10799c <IMFS_dump_directory+0x66>
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( the_jnode->type == IMFS_DIRECTORY )
IMFS_dump_directory( the_jnode, level + 1 );
}
}
1079e1: 8d 65 f4 lea -0xc(%ebp),%esp
1079e4: 5b pop %ebx
1079e5: 5e pop %esi
1079e6: 5f pop %edi
1079e7: c9 leave
1079e8: c3 ret
0010c3d7 <IMFS_eval_path>:
int IMFS_eval_path(
const char *pathname, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
10c3d7: 55 push %ebp
10c3d8: 89 e5 mov %esp,%ebp
10c3da: 57 push %edi
10c3db: 56 push %esi
10c3dc: 53 push %ebx
10c3dd: 83 ec 4c sub $0x4c,%esp
10c3e0: 8b 5d 10 mov 0x10(%ebp),%ebx
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 ) ) {
10c3e3: f7 45 0c f8 ff ff ff testl $0xfffffff8,0xc(%ebp)
10c3ea: 74 19 je 10c405 <IMFS_eval_path+0x2e> <== ALWAYS TAKEN
assert( 0 );
10c3ec: 68 a3 6b 11 00 push $0x116ba3 <== NOT EXECUTED
10c3f1: 68 dc 75 11 00 push $0x1175dc <== NOT EXECUTED
10c3f6: 68 ea 01 00 00 push $0x1ea <== NOT EXECUTED
10c3fb: 68 eb 75 11 00 push $0x1175eb <== NOT EXECUTED
10c400: e8 83 9e ff ff call 106288 <__assert_func> <== NOT EXECUTED
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
10c405: 8b 33 mov (%ebx),%esi
10c407: c7 45 b0 00 00 00 00 movl $0x0,-0x50(%ebp)
10c40e: bf 01 00 00 00 mov $0x1,%edi
10c413: e9 1d 01 00 00 jmp 10c535 <IMFS_eval_path+0x15e>
* 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], token, &len );
10c418: 50 push %eax
10c419: 8d 45 f0 lea -0x10(%ebp),%eax
10c41c: 50 push %eax
10c41d: 8d 45 bf lea -0x41(%ebp),%eax
10c420: 50 push %eax
10c421: 8b 45 08 mov 0x8(%ebp),%eax
10c424: 03 45 b0 add -0x50(%ebp),%eax
10c427: 50 push %eax
10c428: e8 73 04 00 00 call 10c8a0 <IMFS_get_token>
10c42d: 89 c7 mov %eax,%edi
i += len;
10c42f: 8b 45 f0 mov -0x10(%ebp),%eax
10c432: 89 45 ac mov %eax,-0x54(%ebp)
if ( !pathloc->node_access )
10c435: 83 c4 10 add $0x10,%esp
10c438: 83 3b 00 cmpl $0x0,(%ebx)
10c43b: 0f 84 d0 00 00 00 je 10c511 <IMFS_eval_path+0x13a> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
10c441: 85 ff test %edi,%edi
10c443: 74 1b je 10c460 <IMFS_eval_path+0x89>
if ( node->type == IMFS_DIRECTORY )
10c445: 83 7e 4c 01 cmpl $0x1,0x4c(%esi)
10c449: 75 15 jne 10c460 <IMFS_eval_path+0x89>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
10c44b: 50 push %eax
10c44c: 50 push %eax
10c44d: 6a 01 push $0x1
10c44f: 53 push %ebx
10c450: e8 22 fe ff ff call 10c277 <IMFS_evaluate_permission>
10c455: 83 c4 10 add $0x10,%esp
10c458: 85 c0 test %eax,%eax
10c45a: 0f 84 3c 01 00 00 je 10c59c <IMFS_eval_path+0x1c5>
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], token, &len );
i += len;
10c460: 8b 45 ac mov -0x54(%ebp),%eax
10c463: 01 45 b0 add %eax,-0x50(%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;
10c466: 8b 33 mov (%ebx),%esi
switch( type ) {
10c468: 83 ff 03 cmp $0x3,%edi
10c46b: 74 34 je 10c4a1 <IMFS_eval_path+0xca>
10c46d: 83 ff 04 cmp $0x4,%edi
10c470: 0f 84 b2 00 00 00 je 10c528 <IMFS_eval_path+0x151>
10c476: 83 ff 02 cmp $0x2,%edi
10c479: 0f 85 b6 00 00 00 jne 10c535 <IMFS_eval_path+0x15e>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
10c47f: a1 6c b6 11 00 mov 0x11b66c,%eax
10c484: 3b 70 14 cmp 0x14(%eax),%esi
10c487: 74 8f je 10c418 <IMFS_eval_path+0x41>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
10c489: 8b 43 0c mov 0xc(%ebx),%eax
10c48c: 3b 70 18 cmp 0x18(%eax),%esi
10c48f: 75 0b jne 10c49c <IMFS_eval_path+0xc5>
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
newloc = pathloc->mt_entry->mt_point_node;
10c491: 8d 7d e0 lea -0x20(%ebp),%edi
10c494: 8d 70 08 lea 0x8(%eax),%esi
10c497: e9 b9 00 00 00 jmp 10c555 <IMFS_eval_path+0x17e>
*pathloc = newloc;
return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),flags,pathloc);
}
} else {
if ( !node->Parent )
10c49c: 8b 76 08 mov 0x8(%esi),%esi
10c49f: eb 6c jmp 10c50d <IMFS_eval_path+0x136>
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
10c4a1: 8b 46 4c mov 0x4c(%esi),%eax
10c4a4: 83 f8 03 cmp $0x3,%eax
10c4a7: 75 15 jne 10c4be <IMFS_eval_path+0xe7>
IMFS_evaluate_hard_link( pathloc, 0 );
10c4a9: 50 push %eax
10c4aa: 50 push %eax
10c4ab: 6a 00 push $0x0
10c4ad: 53 push %ebx
10c4ae: e8 2a fe ff ff call 10c2dd <IMFS_evaluate_hard_link>
node = pathloc->node_access;
10c4b3: 8b 33 mov (%ebx),%esi
if ( !node )
10c4b5: 83 c4 10 add $0x10,%esp
10c4b8: 85 f6 test %esi,%esi
10c4ba: 75 23 jne 10c4df <IMFS_eval_path+0x108> <== ALWAYS TAKEN
10c4bc: eb 27 jmp 10c4e5 <IMFS_eval_path+0x10e> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTDIR );
} else if ( node->type == IMFS_SYM_LINK ) {
10c4be: 83 f8 04 cmp $0x4,%eax
10c4c1: 75 1c jne 10c4df <IMFS_eval_path+0x108>
result = IMFS_evaluate_sym_link( pathloc, 0 );
10c4c3: 50 push %eax
10c4c4: 50 push %eax
10c4c5: 6a 00 push $0x0
10c4c7: 53 push %ebx
10c4c8: e8 62 fe ff ff call 10c32f <IMFS_evaluate_sym_link>
10c4cd: 89 c6 mov %eax,%esi
node = pathloc->node_access;
10c4cf: 8b 03 mov (%ebx),%eax
if ( result == -1 )
10c4d1: 83 c4 10 add $0x10,%esp
10c4d4: 83 fe ff cmp $0xffffffff,%esi
10c4d7: 0f 84 cd 00 00 00 je 10c5aa <IMFS_eval_path+0x1d3> <== NEVER TAKEN
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
node = pathloc->node_access;
10c4dd: 89 c6 mov %eax,%esi
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10c4df: 83 7e 4c 01 cmpl $0x1,0x4c(%esi)
10c4e3: 74 10 je 10c4f5 <IMFS_eval_path+0x11e>
rtems_set_errno_and_return_minus_one( ENOTDIR );
10c4e5: e8 3e 2c 00 00 call 10f128 <__errno>
10c4ea: c7 00 14 00 00 00 movl $0x14,(%eax)
10c4f0: e9 b2 00 00 00 jmp 10c5a7 <IMFS_eval_path+0x1d0>
/*
* 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 ) {
10c4f5: 8b 46 5c mov 0x5c(%esi),%eax
10c4f8: 85 c0 test %eax,%eax
10c4fa: 75 53 jne 10c54f <IMFS_eval_path+0x178>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10c4fc: 50 push %eax
10c4fd: 50 push %eax
10c4fe: 8d 45 bf lea -0x41(%ebp),%eax
10c501: 50 push %eax
10c502: 56 push %esi
10c503: e8 0c 03 00 00 call 10c814 <IMFS_find_match_in_dir>
10c508: 89 c6 mov %eax,%esi
if ( !node )
10c50a: 83 c4 10 add $0x10,%esp
10c50d: 85 f6 test %esi,%esi
10c50f: 75 10 jne 10c521 <IMFS_eval_path+0x14a>
rtems_set_errno_and_return_minus_one( ENOENT );
10c511: e8 12 2c 00 00 call 10f128 <__errno>
10c516: c7 00 02 00 00 00 movl $0x2,(%eax)
10c51c: e9 86 00 00 00 jmp 10c5a7 <IMFS_eval_path+0x1d0>
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
10c521: 89 33 mov %esi,(%ebx)
10c523: e9 f0 fe ff ff jmp 10c418 <IMFS_eval_path+0x41>
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
10c528: e8 fb 2b 00 00 call 10f128 <__errno>
10c52d: c7 00 5b 00 00 00 movl $0x5b,(%eax)
10c533: eb 72 jmp 10c5a7 <IMFS_eval_path+0x1d0>
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
10c535: 85 ff test %edi,%edi
10c537: 74 09 je 10c542 <IMFS_eval_path+0x16b>
10c539: 83 ff 04 cmp $0x4,%edi
10c53c: 0f 85 d6 fe ff ff jne 10c418 <IMFS_eval_path+0x41> <== ALWAYS TAKEN
* 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 ) {
10c542: 83 7e 4c 01 cmpl $0x1,0x4c(%esi)
10c546: 75 3b jne 10c583 <IMFS_eval_path+0x1ac>
if ( node->info.directory.mt_fs != NULL ) {
10c548: 8b 46 5c mov 0x5c(%esi),%eax
10c54b: 85 c0 test %eax,%eax
10c54d: 74 34 je 10c583 <IMFS_eval_path+0x1ac>
newloc = node->info.directory.mt_fs->mt_fs_root;
10c54f: 8d 7d e0 lea -0x20(%ebp),%edi
10c552: 8d 70 18 lea 0x18(%eax),%esi
10c555: b9 04 00 00 00 mov $0x4,%ecx
10c55a: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*pathloc = newloc;
10c55c: 8d 75 e0 lea -0x20(%ebp),%esi
10c55f: b1 04 mov $0x4,%cl
10c561: 89 df mov %ebx,%edi
10c563: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc );
10c565: 50 push %eax
10c566: 8b 53 08 mov 0x8(%ebx),%edx
10c569: 53 push %ebx
10c56a: ff 75 0c pushl 0xc(%ebp)
10c56d: 8b 45 f0 mov -0x10(%ebp),%eax
10c570: 29 45 b0 sub %eax,-0x50(%ebp)
10c573: 8b 45 08 mov 0x8(%ebp),%eax
10c576: 03 45 b0 add -0x50(%ebp),%eax
10c579: 50 push %eax
10c57a: ff 12 call *(%edx)
10c57c: 89 c6 mov %eax,%esi
10c57e: 83 c4 10 add $0x10,%esp
10c581: eb 27 jmp 10c5aa <IMFS_eval_path+0x1d3>
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
10c583: 53 push %ebx
10c584: e8 af fc ff ff call 10c238 <IMFS_Set_handlers>
10c589: 89 c6 mov %eax,%esi
10c58b: 57 push %edi
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
10c58c: ff 75 0c pushl 0xc(%ebp)
10c58f: 53 push %ebx
10c590: e8 e2 fc ff ff call 10c277 <IMFS_evaluate_permission>
10c595: 83 c4 10 add $0x10,%esp
10c598: 85 c0 test %eax,%eax
10c59a: 75 0e jne 10c5aa <IMFS_eval_path+0x1d3>
rtems_set_errno_and_return_minus_one( EACCES );
10c59c: e8 87 2b 00 00 call 10f128 <__errno>
10c5a1: c7 00 0d 00 00 00 movl $0xd,(%eax)
10c5a7: 83 ce ff or $0xffffffff,%esi
return result;
}
10c5aa: 89 f0 mov %esi,%eax
10c5ac: 8d 65 f4 lea -0xc(%ebp),%esp
10c5af: 5b pop %ebx
10c5b0: 5e pop %esi
10c5b1: 5f pop %edi
10c5b2: c9 leave
10c5b3: c3 ret
0010c63b <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 */
)
{
10c63b: 55 push %ebp
10c63c: 89 e5 mov %esp,%ebp
10c63e: 57 push %edi
10c63f: 56 push %esi
10c640: 53 push %ebx
10c641: 83 ec 4c sub $0x4c,%esp
10c644: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
10c647: 8b 33 mov (%ebx),%esi
10c649: c7 45 b0 00 00 00 00 movl $0x0,-0x50(%ebp)
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], token, &len );
10c650: 50 push %eax
10c651: 8d 45 f0 lea -0x10(%ebp),%eax
10c654: 50 push %eax
10c655: 8d 55 bf lea -0x41(%ebp),%edx
10c658: 52 push %edx
10c659: 8b 45 08 mov 0x8(%ebp),%eax
10c65c: 03 45 b0 add -0x50(%ebp),%eax
10c65f: 50 push %eax
10c660: e8 3b 02 00 00 call 10c8a0 <IMFS_get_token>
10c665: 89 c7 mov %eax,%edi
i += len;
10c667: 8b 45 f0 mov -0x10(%ebp),%eax
10c66a: 89 45 ac mov %eax,-0x54(%ebp)
if ( !pathloc->node_access )
10c66d: 83 c4 10 add $0x10,%esp
10c670: 83 3b 00 cmpl $0x0,(%ebx)
10c673: 0f 84 40 01 00 00 je 10c7b9 <IMFS_evaluate_for_make+0x17e><== NEVER TAKEN
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
10c679: 85 ff test %edi,%edi
10c67b: 74 1b je 10c698 <IMFS_evaluate_for_make+0x5d>
if ( node->type == IMFS_DIRECTORY )
10c67d: 83 7e 4c 01 cmpl $0x1,0x4c(%esi)
10c681: 75 15 jne 10c698 <IMFS_evaluate_for_make+0x5d>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
10c683: 50 push %eax
10c684: 50 push %eax
10c685: 6a 01 push $0x1
10c687: 53 push %ebx
10c688: e8 ea fb ff ff call 10c277 <IMFS_evaluate_permission>
10c68d: 83 c4 10 add $0x10,%esp
10c690: 85 c0 test %eax,%eax
10c692: 0f 84 63 01 00 00 je 10c7fb <IMFS_evaluate_for_make+0x1c0>
*/
while( !done ) {
type = IMFS_get_token( &path[i], token, &len );
i += len;
10c698: 8b 55 ac mov -0x54(%ebp),%edx
10c69b: 01 55 b0 add %edx,-0x50(%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;
10c69e: 8b 33 mov (%ebx),%esi
switch( type ) {
10c6a0: 83 ff 02 cmp $0x2,%edi
10c6a3: 74 1b je 10c6c0 <IMFS_evaluate_for_make+0x85>
10c6a5: 77 0a ja 10c6b1 <IMFS_evaluate_for_make+0x76>
10c6a7: 85 ff test %edi,%edi
10c6a9: 0f 84 cf 00 00 00 je 10c77e <IMFS_evaluate_for_make+0x143>
10c6af: eb 9f jmp 10c650 <IMFS_evaluate_for_make+0x15>
10c6b1: 83 ff 03 cmp $0x3,%edi
10c6b4: 74 34 je 10c6ea <IMFS_evaluate_for_make+0xaf>
10c6b6: 83 ff 04 cmp $0x4,%edi
10c6b9: 75 95 jne 10c650 <IMFS_evaluate_for_make+0x15><== NEVER TAKEN
10c6bb: e9 cb 00 00 00 jmp 10c78b <IMFS_evaluate_for_make+0x150>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
10c6c0: a1 6c b6 11 00 mov 0x11b66c,%eax
10c6c5: 3b 70 14 cmp 0x14(%eax),%esi
10c6c8: 74 86 je 10c650 <IMFS_evaluate_for_make+0x15>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){
10c6ca: 8b 43 0c mov 0xc(%ebx),%eax
10c6cd: 3b 70 18 cmp 0x18(%eax),%esi
10c6d0: 75 08 jne 10c6da <IMFS_evaluate_for_make+0x9f>
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
10c6d2: 8d 7d e0 lea -0x20(%ebp),%edi
10c6d5: 8d 70 08 lea 0x8(%eax),%esi
10c6d8: eb 56 jmp 10c730 <IMFS_evaluate_for_make+0xf5>
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
10c6da: 8b 76 08 mov 0x8(%esi),%esi
10c6dd: 85 f6 test %esi,%esi
10c6df: 0f 85 92 00 00 00 jne 10c777 <IMFS_evaluate_for_make+0x13c>
10c6e5: e9 cf 00 00 00 jmp 10c7b9 <IMFS_evaluate_for_make+0x17e>
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
10c6ea: 8b 46 4c mov 0x4c(%esi),%eax
10c6ed: 83 f8 03 cmp $0x3,%eax
10c6f0: 74 05 je 10c6f7 <IMFS_evaluate_for_make+0xbc>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
10c6f2: 83 f8 04 cmp $0x4,%eax
10c6f5: 75 18 jne 10c70f <IMFS_evaluate_for_make+0xd4>
result = IMFS_evaluate_link( pathloc, 0 );
10c6f7: 57 push %edi
10c6f8: 57 push %edi
10c6f9: 6a 00 push $0x0
10c6fb: 53 push %ebx
10c6fc: e8 b3 fe ff ff call 10c5b4 <IMFS_evaluate_link>
10c701: 89 c6 mov %eax,%esi
if ( result == -1 )
10c703: 83 c4 10 add $0x10,%esp
10c706: 83 f8 ff cmp $0xffffffff,%eax
10c709: 0f 84 fa 00 00 00 je 10c809 <IMFS_evaluate_for_make+0x1ce><== NEVER TAKEN
return -1;
}
node = pathloc->node_access;
10c70f: 8b 03 mov (%ebx),%eax
if ( !node )
10c711: 85 c0 test %eax,%eax
10c713: 0f 84 c4 00 00 00 je 10c7dd <IMFS_evaluate_for_make+0x1a2><== NEVER TAKEN
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10c719: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
10c71d: 0f 85 ba 00 00 00 jne 10c7dd <IMFS_evaluate_for_make+0x1a2>
/*
* 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 ) {
10c723: 8b 50 5c mov 0x5c(%eax),%edx
10c726: 85 d2 test %edx,%edx
10c728: 74 38 je 10c762 <IMFS_evaluate_for_make+0x127>
newloc = node->info.directory.mt_fs->mt_fs_root;
10c72a: 8d 7d e0 lea -0x20(%ebp),%edi
10c72d: 8d 72 18 lea 0x18(%edx),%esi
10c730: b9 04 00 00 00 mov $0x4,%ecx
10c735: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*pathloc = newloc;
10c737: 8d 75 e0 lea -0x20(%ebp),%esi
10c73a: b1 04 mov $0x4,%cl
10c73c: 89 df mov %ebx,%edi
10c73e: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
10c740: 56 push %esi
10c741: 8b 53 08 mov 0x8(%ebx),%edx
10c744: ff 75 10 pushl 0x10(%ebp)
10c747: 53 push %ebx
10c748: 8b 45 f0 mov -0x10(%ebp),%eax
10c74b: 29 45 b0 sub %eax,-0x50(%ebp)
10c74e: 8b 45 08 mov 0x8(%ebp),%eax
10c751: 03 45 b0 add -0x50(%ebp),%eax
10c754: 50 push %eax
10c755: ff 52 04 call *0x4(%edx)
10c758: 89 c6 mov %eax,%esi
10c75a: 83 c4 10 add $0x10,%esp
10c75d: e9 a7 00 00 00 jmp 10c809 <IMFS_evaluate_for_make+0x1ce>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10c762: 51 push %ecx
10c763: 51 push %ecx
10c764: 8d 55 bf lea -0x41(%ebp),%edx
10c767: 52 push %edx
10c768: 50 push %eax
10c769: e8 a6 00 00 00 call 10c814 <IMFS_find_match_in_dir>
10c76e: 89 c6 mov %eax,%esi
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
10c770: 83 c4 10 add $0x10,%esp
10c773: 85 c0 test %eax,%eax
10c775: 74 21 je 10c798 <IMFS_evaluate_for_make+0x15d>
done = true;
else
pathloc->node_access = node;
10c777: 89 33 mov %esi,(%ebx)
10c779: e9 d2 fe ff ff jmp 10c650 <IMFS_evaluate_for_make+0x15>
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
10c77e: e8 a5 29 00 00 call 10f128 <__errno>
10c783: c7 00 11 00 00 00 movl $0x11,(%eax)
10c789: eb 7b jmp 10c806 <IMFS_evaluate_for_make+0x1cb>
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
10c78b: e8 98 29 00 00 call 10f128 <__errno>
10c790: c7 00 5b 00 00 00 movl $0x5b,(%eax)
10c796: eb 6e jmp 10c806 <IMFS_evaluate_for_make+0x1cb>
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
10c798: 8b 45 b0 mov -0x50(%ebp),%eax
10c79b: 2b 45 f0 sub -0x10(%ebp),%eax
10c79e: 03 45 08 add 0x8(%ebp),%eax
10c7a1: 8b 55 10 mov 0x10(%ebp),%edx
10c7a4: 89 02 mov %eax,(%edx)
10c7a6: 8b 45 08 mov 0x8(%ebp),%eax
10c7a9: 03 45 b0 add -0x50(%ebp),%eax
10c7ac: eb 18 jmp 10c7c6 <IMFS_evaluate_for_make+0x18b>
/*
* 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++) {
10c7ae: 40 inc %eax
if ( !IMFS_is_separator( path[ i ] ) )
10c7af: 80 fa 2f cmp $0x2f,%dl
10c7b2: 74 12 je 10c7c6 <IMFS_evaluate_for_make+0x18b>
10c7b4: 80 fa 5c cmp $0x5c,%dl
10c7b7: 74 0d je 10c7c6 <IMFS_evaluate_for_make+0x18b>
rtems_set_errno_and_return_minus_one( ENOENT );
10c7b9: e8 6a 29 00 00 call 10f128 <__errno>
10c7be: c7 00 02 00 00 00 movl $0x2,(%eax)
10c7c4: eb 40 jmp 10c806 <IMFS_evaluate_for_make+0x1cb>
/*
* 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++) {
10c7c6: 8a 10 mov (%eax),%dl
10c7c8: 84 d2 test %dl,%dl
10c7ca: 75 e2 jne 10c7ae <IMFS_evaluate_for_make+0x173>
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
10c7cc: 53 push %ebx
10c7cd: e8 66 fa ff ff call 10c238 <IMFS_Set_handlers>
10c7d2: 89 c6 mov %eax,%esi
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
10c7d4: 8b 03 mov (%ebx),%eax
10c7d6: 5a pop %edx
10c7d7: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
10c7db: 74 0d je 10c7ea <IMFS_evaluate_for_make+0x1af><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
10c7dd: e8 46 29 00 00 call 10f128 <__errno>
10c7e2: c7 00 14 00 00 00 movl $0x14,(%eax)
10c7e8: eb 1c jmp 10c806 <IMFS_evaluate_for_make+0x1cb>
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
10c7ea: 57 push %edi
10c7eb: 57 push %edi
10c7ec: 6a 03 push $0x3
10c7ee: 53 push %ebx
10c7ef: e8 83 fa ff ff call 10c277 <IMFS_evaluate_permission>
10c7f4: 83 c4 10 add $0x10,%esp
10c7f7: 85 c0 test %eax,%eax
10c7f9: 75 0e jne 10c809 <IMFS_evaluate_for_make+0x1ce>
rtems_set_errno_and_return_minus_one( EACCES );
10c7fb: e8 28 29 00 00 call 10f128 <__errno>
10c800: c7 00 0d 00 00 00 movl $0xd,(%eax)
10c806: 83 ce ff or $0xffffffff,%esi
return result;
}
10c809: 89 f0 mov %esi,%eax
10c80b: 8d 65 f4 lea -0xc(%ebp),%esp
10c80e: 5b pop %ebx
10c80f: 5e pop %esi
10c810: 5f pop %edi
10c811: c9 leave
10c812: c3 ret
0010c2dd <IMFS_evaluate_hard_link>:
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
10c2dd: 55 push %ebp
10c2de: 89 e5 mov %esp,%ebp
10c2e0: 53 push %ebx
10c2e1: 83 ec 04 sub $0x4,%esp
10c2e4: 8b 5d 08 mov 0x8(%ebp),%ebx
IMFS_jnode_t *jnode = node->node_access;
10c2e7: 8b 03 mov (%ebx),%eax
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_HARD_LINK )
10c2e9: 83 78 4c 03 cmpl $0x3,0x4c(%eax)
10c2ed: 74 0d je 10c2fc <IMFS_evaluate_hard_link+0x1f>
rtems_fatal_error_occurred (0xABCD0000);
10c2ef: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c2f2: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED
10c2f7: e8 98 d4 ff ff call 109794 <rtems_fatal_error_occurred><== NOT EXECUTED
/*
* Set the hard link value and the handlers.
*/
node->node_access = jnode->info.hard_link.link_node;
10c2fc: 8b 40 50 mov 0x50(%eax),%eax
10c2ff: 89 03 mov %eax,(%ebx)
IMFS_Set_handlers( node );
10c301: 53 push %ebx
10c302: e8 31 ff ff ff call 10c238 <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
10c307: 50 push %eax
10c308: ff 75 0c pushl 0xc(%ebp)
10c30b: 53 push %ebx
10c30c: e8 66 ff ff ff call 10c277 <IMFS_evaluate_permission>
10c311: 83 c4 10 add $0x10,%esp
10c314: 31 d2 xor %edx,%edx
10c316: 85 c0 test %eax,%eax
10c318: 75 0e jne 10c328 <IMFS_evaluate_hard_link+0x4b><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EACCES );
10c31a: e8 09 2e 00 00 call 10f128 <__errno> <== NOT EXECUTED
10c31f: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED
10c325: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED
return result;
}
10c328: 89 d0 mov %edx,%eax
10c32a: 8b 5d fc mov -0x4(%ebp),%ebx
10c32d: c9 leave
10c32e: c3 ret
0010c277 <IMFS_evaluate_permission>:
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
10c277: 55 push %ebp
10c278: 89 e5 mov %esp,%ebp
10c27a: 57 push %edi
10c27b: 56 push %esi
10c27c: 53 push %ebx
10c27d: 83 ec 0c sub $0xc,%esp
10c280: 8b 7d 0c mov 0xc(%ebp),%edi
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
10c283: f7 c7 f8 ff ff ff test $0xfffffff8,%edi
10c289: 74 10 je 10c29b <IMFS_evaluate_permission+0x24><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
10c28b: e8 98 2e 00 00 call 10f128 <__errno> <== NOT EXECUTED
10c290: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
10c296: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10c299: eb 3a jmp 10c2d5 <IMFS_evaluate_permission+0x5e><== NOT EXECUTED
jnode = node->node_access;
10c29b: 8b 45 08 mov 0x8(%ebp),%eax
10c29e: 8b 30 mov (%eax),%esi
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
10c2a0: e8 9f 0b 00 00 call 10ce44 <geteuid>
10c2a5: 89 c3 mov %eax,%ebx
st_gid = getegid();
10c2a7: e8 88 0b 00 00 call 10ce34 <getegid>
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
10c2ac: 66 3b 5e 3c cmp 0x3c(%esi),%bx
10c2b0: 75 07 jne 10c2b9 <IMFS_evaluate_permission+0x42>
flags_to_test <<= 6;
10c2b2: 89 fa mov %edi,%edx
10c2b4: c1 e2 06 shl $0x6,%edx
10c2b7: eb 0f jmp 10c2c8 <IMFS_evaluate_permission+0x51>
else if ( st_gid == jnode->st_gid )
10c2b9: 89 fa mov %edi,%edx
10c2bb: 66 3b 46 3e cmp 0x3e(%esi),%ax
10c2bf: 75 07 jne 10c2c8 <IMFS_evaluate_permission+0x51><== NEVER TAKEN
flags_to_test <<= 3;
10c2c1: 8d 14 fd 00 00 00 00 lea 0x0(,%edi,8),%edx
/*
* If all of the flags are set we have permission
* to do this.
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
10c2c8: 89 d0 mov %edx,%eax
10c2ca: 23 46 30 and 0x30(%esi),%eax
10c2cd: 39 d0 cmp %edx,%eax
10c2cf: 0f 94 c0 sete %al
10c2d2: 0f b6 c0 movzbl %al,%eax
return 1;
return 0;
}
10c2d5: 83 c4 0c add $0xc,%esp
10c2d8: 5b pop %ebx
10c2d9: 5e pop %esi
10c2da: 5f pop %edi
10c2db: c9 leave
10c2dc: c3 ret
0010c32f <IMFS_evaluate_sym_link>:
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
10c32f: 55 push %ebp
10c330: 89 e5 mov %esp,%ebp
10c332: 57 push %edi
10c333: 56 push %esi
10c334: 53 push %ebx
10c335: 83 ec 0c sub $0xc,%esp
IMFS_jnode_t *jnode = node->node_access;
10c338: 8b 45 08 mov 0x8(%ebp),%eax
10c33b: 8b 18 mov (%eax),%ebx
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_SYM_LINK )
10c33d: 83 7b 4c 04 cmpl $0x4,0x4c(%ebx)
10c341: 74 0a je 10c34d <IMFS_evaluate_sym_link+0x1e><== ALWAYS TAKEN
rtems_fatal_error_occurred (0xABCD0000);
10c343: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c346: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED
10c34b: eb 0f jmp 10c35c <IMFS_evaluate_sym_link+0x2d><== NOT EXECUTED
if ( !jnode->Parent )
10c34d: 8b 43 08 mov 0x8(%ebx),%eax
10c350: 85 c0 test %eax,%eax
10c352: 75 0d jne 10c361 <IMFS_evaluate_sym_link+0x32><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xBAD00000 );
10c354: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c357: 68 00 00 d0 ba push $0xbad00000 <== NOT EXECUTED
10c35c: e8 33 d4 ff ff call 109794 <rtems_fatal_error_occurred><== NOT EXECUTED
/*
* Move the node_access to either the symbolic links parent or
* root depending on the symbolic links path.
*/
node->node_access = jnode->Parent;
10c361: 8b 55 08 mov 0x8(%ebp),%edx
10c364: 89 02 mov %eax,(%edx)
rtems_filesystem_get_sym_start_loc(
10c366: 8b 43 50 mov 0x50(%ebx),%eax
10c369: 8a 00 mov (%eax),%al
10c36b: 3c 2f cmp $0x2f,%al
10c36d: 74 0a je 10c379 <IMFS_evaluate_sym_link+0x4a>
10c36f: 3c 5c cmp $0x5c,%al
10c371: 74 06 je 10c379 <IMFS_evaluate_sym_link+0x4a><== NEVER TAKEN
10c373: 31 d2 xor %edx,%edx
10c375: 84 c0 test %al,%al
10c377: 75 17 jne 10c390 <IMFS_evaluate_sym_link+0x61><== ALWAYS TAKEN
10c379: a1 6c b6 11 00 mov 0x11b66c,%eax
10c37e: 8d 70 14 lea 0x14(%eax),%esi
10c381: b9 04 00 00 00 mov $0x4,%ecx
10c386: 8b 7d 08 mov 0x8(%ebp),%edi
10c389: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10c38b: ba 01 00 00 00 mov $0x1,%edx
/*
* Use eval path to evaluate the path of the symbolic link.
*/
result = IMFS_eval_path(
10c390: 51 push %ecx
10c391: ff 75 08 pushl 0x8(%ebp)
10c394: ff 75 0c pushl 0xc(%ebp)
10c397: 03 53 50 add 0x50(%ebx),%edx
10c39a: 52 push %edx
10c39b: e8 37 00 00 00 call 10c3d7 <IMFS_eval_path>
10c3a0: 89 c3 mov %eax,%ebx
&jnode->info.sym_link.name[i],
flags,
node
);
IMFS_Set_handlers( node );
10c3a2: ff 75 08 pushl 0x8(%ebp)
10c3a5: e8 8e fe ff ff call 10c238 <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
10c3aa: 83 c4 0c add $0xc,%esp
10c3ad: ff 75 0c pushl 0xc(%ebp)
10c3b0: ff 75 08 pushl 0x8(%ebp)
10c3b3: e8 bf fe ff ff call 10c277 <IMFS_evaluate_permission>
10c3b8: 83 c4 10 add $0x10,%esp
10c3bb: 85 c0 test %eax,%eax
10c3bd: 75 0e jne 10c3cd <IMFS_evaluate_sym_link+0x9e><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EACCES );
10c3bf: e8 64 2d 00 00 call 10f128 <__errno> <== NOT EXECUTED
10c3c4: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED
10c3ca: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED
return result;
}
10c3cd: 89 d8 mov %ebx,%eax
10c3cf: 8d 65 f4 lea -0xc(%ebp),%esp
10c3d2: 5b pop %ebx
10c3d3: 5e pop %esi
10c3d4: 5f pop %edi
10c3d5: c9 leave
10c3d6: c3 ret
0010e8ac <IMFS_fchmod>:
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
10e8ac: 55 push %ebp
10e8ad: 89 e5 mov %esp,%ebp
10e8af: 56 push %esi
10e8b0: 53 push %ebx
10e8b1: 83 ec 10 sub $0x10,%esp
10e8b4: 8b 5d 0c mov 0xc(%ebp),%ebx
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = loc->node_access;
10e8b7: 8b 45 08 mov 0x8(%ebp),%eax
10e8ba: 8b 30 mov (%eax),%esi
/*
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
10e8bc: e8 83 e5 ff ff call 10ce44 <geteuid>
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
10e8c1: 66 3b 46 3c cmp 0x3c(%esi),%ax
10e8c5: 74 05 je 10e8cc <IMFS_fchmod+0x20> <== ALWAYS TAKEN
10e8c7: 66 85 c0 test %ax,%ax <== NOT EXECUTED
10e8ca: 75 08 jne 10e8d4 <IMFS_fchmod+0x28> <== NOT EXECUTED
#endif
/*
* Change only the RWX permissions on the jnode to mode.
*/
if ( mode & (~ (S_IRWXU | S_IRWXG | S_IRWXO ) ) )
10e8cc: f7 c3 00 fe ff ff test $0xfffffe00,%ebx
10e8d2: 74 10 je 10e8e4 <IMFS_fchmod+0x38>
rtems_set_errno_and_return_minus_one( EPERM );
10e8d4: e8 4f 08 00 00 call 10f128 <__errno>
10e8d9: c7 00 01 00 00 00 movl $0x1,(%eax)
10e8df: 83 c8 ff or $0xffffffff,%eax
10e8e2: eb 25 jmp 10e909 <IMFS_fchmod+0x5d>
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO);
jnode->st_mode |= mode;
10e8e4: 8b 46 30 mov 0x30(%esi),%eax
10e8e7: 25 00 fe ff ff and $0xfffffe00,%eax
10e8ec: 09 c3 or %eax,%ebx
10e8ee: 89 5e 30 mov %ebx,0x30(%esi)
IMFS_update_ctime( jnode );
10e8f1: 50 push %eax
10e8f2: 50 push %eax
10e8f3: 6a 00 push $0x0
10e8f5: 8d 45 f0 lea -0x10(%ebp),%eax
10e8f8: 50 push %eax
10e8f9: e8 56 e5 ff ff call 10ce54 <gettimeofday>
10e8fe: 8b 45 f0 mov -0x10(%ebp),%eax
10e901: 89 46 48 mov %eax,0x48(%esi)
10e904: 31 c0 xor %eax,%eax
10e906: 83 c4 10 add $0x10,%esp
return 0;
}
10e909: 8d 65 f8 lea -0x8(%ebp),%esp
10e90c: 5b pop %ebx
10e90d: 5e pop %esi
10e90e: c9 leave
10e90f: c3 ret
0010c814 <IMFS_find_match_in_dir>:
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
10c814: 55 push %ebp
10c815: 89 e5 mov %esp,%ebp
10c817: 57 push %edi
10c818: 56 push %esi
10c819: 53 push %ebx
10c81a: 83 ec 0c sub $0xc,%esp
10c81d: 8b 5d 08 mov 0x8(%ebp),%ebx
10c820: 8b 7d 0c mov 0xc(%ebp),%edi
/*
* Check for fatal errors. A NULL directory show a problem in the
* the IMFS code.
*/
assert( directory );
10c823: 85 db test %ebx,%ebx
10c825: 75 16 jne 10c83d <IMFS_find_match_in_dir+0x29><== ALWAYS TAKEN
10c827: 68 39 76 11 00 push $0x117639 <== NOT EXECUTED
10c82c: 68 a0 76 11 00 push $0x1176a0 <== NOT EXECUTED
10c831: 6a 2a push $0x2a <== NOT EXECUTED
10c833: 68 43 76 11 00 push $0x117643 <== NOT EXECUTED
10c838: e8 4b 9a ff ff call 106288 <__assert_func> <== NOT EXECUTED
if ( !name )
10c83d: 85 ff test %edi,%edi
10c83f: 74 52 je 10c893 <IMFS_find_match_in_dir+0x7f><== NEVER TAKEN
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
10c841: 51 push %ecx
10c842: 51 push %ecx
10c843: 68 98 76 11 00 push $0x117698
10c848: 57 push %edi
10c849: e8 d6 39 00 00 call 110224 <strcmp>
10c84e: 83 c4 10 add $0x10,%esp
10c851: 85 c0 test %eax,%eax
10c853: 74 40 je 10c895 <IMFS_find_match_in_dir+0x81><== NEVER TAKEN
return directory;
if ( !strcmp( name, dotdotname ) )
10c855: 52 push %edx
10c856: 52 push %edx
10c857: 68 9a 76 11 00 push $0x11769a
10c85c: 57 push %edi
10c85d: e8 c2 39 00 00 call 110224 <strcmp>
10c862: 83 c4 10 add $0x10,%esp
10c865: 85 c0 test %eax,%eax
10c867: 75 05 jne 10c86e <IMFS_find_match_in_dir+0x5a><== ALWAYS TAKEN
return directory->Parent;
10c869: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED
10c86c: eb 27 jmp 10c895 <IMFS_find_match_in_dir+0x81><== NOT EXECUTED
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
10c86e: 8b 73 50 mov 0x50(%ebx),%esi
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
10c871: 83 c3 54 add $0x54,%ebx
10c874: eb 19 jmp 10c88f <IMFS_find_match_in_dir+0x7b>
!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 ) )
10c876: 50 push %eax
10c877: 50 push %eax
10c878: 8d 46 0c lea 0xc(%esi),%eax
10c87b: 50 push %eax
10c87c: 57 push %edi
10c87d: e8 a2 39 00 00 call 110224 <strcmp>
10c882: 83 c4 10 add $0x10,%esp
10c885: 85 c0 test %eax,%eax
10c887: 75 04 jne 10c88d <IMFS_find_match_in_dir+0x79>
10c889: 89 f3 mov %esi,%ebx
10c88b: eb 08 jmp 10c895 <IMFS_find_match_in_dir+0x81>
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
10c88d: 8b 36 mov (%esi),%esi
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
!rtems_chain_is_tail( the_chain, the_node );
10c88f: 39 de cmp %ebx,%esi
10c891: 75 e3 jne 10c876 <IMFS_find_match_in_dir+0x62>
10c893: 31 db xor %ebx,%ebx
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
10c895: 89 d8 mov %ebx,%eax
10c897: 8d 65 f4 lea -0xc(%ebp),%esp
10c89a: 5b pop %ebx
10c89b: 5e pop %esi
10c89c: 5f pop %edi
10c89d: c9 leave
10c89e: c3 ret
0010de94 <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
)
{
10de94: 55 push %ebp
10de95: 89 e5 mov %esp,%ebp
10de97: 57 push %edi
10de98: 56 push %esi
10de99: 53 push %ebx
10de9a: 83 ec 1c sub $0x1c,%esp
10de9d: 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;
10dea0: 8b 58 18 mov 0x18(%eax),%ebx
loc = temp_mt_entry->mt_fs_root;
10dea3: 8d 7d e4 lea -0x1c(%ebp),%edi
10dea6: 8d 70 18 lea 0x18(%eax),%esi
10dea9: b9 04 00 00 00 mov $0x4,%ecx
10deae: 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;
10deb0: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
10deb7: 8d 75 e4 lea -0x1c(%ebp),%esi
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
10deba: 8b 7b 08 mov 0x8(%ebx),%edi
loc.node_access = (void *)jnode;
10debd: 89 5d e4 mov %ebx,-0x1c(%ebp)
IMFS_Set_handlers( &loc );
10dec0: 83 ec 0c sub $0xc,%esp
10dec3: 56 push %esi
10dec4: e8 e7 f9 ff ff call 10d8b0 <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
10dec9: 83 c4 10 add $0x10,%esp
10decc: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10ded0: 75 08 jne 10deda <IMFS_fsunmount+0x46>
result = IMFS_unlink( &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
10ded2: 8d 43 54 lea 0x54(%ebx),%eax
10ded5: 39 43 50 cmp %eax,0x50(%ebx)
10ded8: 75 12 jne 10deec <IMFS_fsunmount+0x58>
result = IMFS_unlink( &loc );
10deda: 83 ec 0c sub $0xc,%esp
10dedd: 56 push %esi
10dede: e8 c1 8c ff ff call 106ba4 <IMFS_unlink>
if (result != 0)
10dee3: 83 c4 10 add $0x10,%esp
10dee6: 85 c0 test %eax,%eax
10dee8: 75 1d jne 10df07 <IMFS_fsunmount+0x73> <== NEVER TAKEN
10deea: 89 fb mov %edi,%ebx
return -1;
jnode = next;
}
if ( jnode != NULL ) {
10deec: 85 db test %ebx,%ebx
10deee: 74 1c je 10df0c <IMFS_fsunmount+0x78>
if ( jnode->type == IMFS_DIRECTORY ) {
10def0: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10def4: 75 c4 jne 10deba <IMFS_fsunmount+0x26> <== NEVER TAKEN
if ( jnode_has_children( jnode ) )
10def6: 8d 43 54 lea 0x54(%ebx),%eax
10def9: 39 43 50 cmp %eax,0x50(%ebx)
10defc: 74 bc je 10deba <IMFS_fsunmount+0x26>
jnode = jnode_get_first_child( jnode );
10defe: 8b 5b 50 mov 0x50(%ebx),%ebx
}
}
} while (jnode != NULL);
10df01: 85 db test %ebx,%ebx
10df03: 75 b5 jne 10deba <IMFS_fsunmount+0x26> <== ALWAYS TAKEN
10df05: eb 05 jmp 10df0c <IMFS_fsunmount+0x78> <== NOT EXECUTED
10df07: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10df0a: eb 02 jmp 10df0e <IMFS_fsunmount+0x7a> <== NOT EXECUTED
10df0c: 31 c0 xor %eax,%eax
return 0;
}
10df0e: 8d 65 f4 lea -0xc(%ebp),%esp
10df11: 5b pop %ebx
10df12: 5e pop %esi
10df13: 5f pop %edi
10df14: c9 leave
10df15: c3 ret
0010c8a0 <IMFS_get_token>:
IMFS_token_types IMFS_get_token(
const char *path,
char *token,
int *token_len
)
{
10c8a0: 55 push %ebp
10c8a1: 89 e5 mov %esp,%ebp
10c8a3: 56 push %esi
10c8a4: 53 push %ebx
10c8a5: 8b 4d 08 mov 0x8(%ebp),%ecx
10c8a8: 8b 75 0c mov 0xc(%ebp),%esi
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
10c8ab: 8a 01 mov (%ecx),%al
10c8ad: 31 d2 xor %edx,%edx
10c8af: eb 10 jmp 10c8c1 <IMFS_get_token+0x21>
while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) {
token[i] = c;
10c8b1: 88 04 16 mov %al,(%esi,%edx,1)
if ( i == IMFS_NAME_MAX )
10c8b4: 75 07 jne 10c8bd <IMFS_get_token+0x1d>
10c8b6: bb 04 00 00 00 mov $0x4,%ebx
10c8bb: eb 77 jmp 10c934 <IMFS_get_token+0x94>
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
10c8bd: 42 inc %edx
10c8be: 8a 04 11 mov (%ecx,%edx,1),%al
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) {
10c8c1: 3c 2f cmp $0x2f,%al
10c8c3: 74 0d je 10c8d2 <IMFS_get_token+0x32>
10c8c5: 3c 5c cmp $0x5c,%al
10c8c7: 74 09 je 10c8d2 <IMFS_get_token+0x32>
10c8c9: 84 c0 test %al,%al
10c8cb: 74 05 je 10c8d2 <IMFS_get_token+0x32>
10c8cd: 83 fa 20 cmp $0x20,%edx
10c8d0: 7e df jle 10c8b1 <IMFS_get_token+0x11> <== ALWAYS TAKEN
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
10c8d2: 85 d2 test %edx,%edx
10c8d4: 75 0e jne 10c8e4 <IMFS_get_token+0x44>
token[i] = c;
10c8d6: 88 06 mov %al,(%esi)
if ( token[i] != '\0' ) {
10c8d8: 31 db xor %ebx,%ebx
10c8da: 84 c0 test %al,%al
10c8dc: 74 1b je 10c8f9 <IMFS_get_token+0x59>
10c8de: b2 01 mov $0x1,%dl
10c8e0: b3 01 mov $0x1,%bl
10c8e2: eb 15 jmp 10c8f9 <IMFS_get_token+0x59>
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
10c8e4: bb 03 00 00 00 mov $0x3,%ebx
10c8e9: 80 7c 16 ff 00 cmpb $0x0,-0x1(%esi,%edx,1)
10c8ee: 74 09 je 10c8f9 <IMFS_get_token+0x59> <== NEVER TAKEN
token[i] = '\0';
10c8f0: c6 04 16 00 movb $0x0,(%esi,%edx,1)
10c8f4: bb 03 00 00 00 mov $0x3,%ebx
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
10c8f9: 8b 45 10 mov 0x10(%ebp),%eax
10c8fc: 89 10 mov %edx,(%eax)
/*
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
10c8fe: 83 fb 03 cmp $0x3,%ebx
10c901: 75 31 jne 10c934 <IMFS_get_token+0x94>
if ( strcmp( token, "..") == 0 )
10c903: 52 push %edx
10c904: 52 push %edx
10c905: 68 f9 71 11 00 push $0x1171f9
10c90a: 56 push %esi
10c90b: e8 14 39 00 00 call 110224 <strcmp>
10c910: 83 c4 10 add $0x10,%esp
10c913: 85 c0 test %eax,%eax
10c915: 75 04 jne 10c91b <IMFS_get_token+0x7b>
10c917: b3 02 mov $0x2,%bl
10c919: eb 19 jmp 10c934 <IMFS_get_token+0x94>
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
10c91b: 50 push %eax
10c91c: 50 push %eax
10c91d: 68 fa 71 11 00 push $0x1171fa
10c922: 56 push %esi
10c923: e8 fc 38 00 00 call 110224 <strcmp>
10c928: 83 c4 10 add $0x10,%esp
10c92b: 85 c0 test %eax,%eax
10c92d: 75 05 jne 10c934 <IMFS_get_token+0x94>
10c92f: bb 01 00 00 00 mov $0x1,%ebx
type = IMFS_CURRENT_DIR;
}
return type;
}
10c934: 89 d8 mov %ebx,%eax
10c936: 8d 65 f8 lea -0x8(%ebp),%esp
10c939: 5b pop %ebx
10c93a: 5e pop %esi
10c93b: c9 leave
10c93c: c3 ret
0010c940 <IMFS_initialize_support>:
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *memfile_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers
)
{
10c940: 55 push %ebp
10c941: 89 e5 mov %esp,%ebp
10c943: 57 push %edi
10c944: 56 push %esi
10c945: 53 push %ebx
10c946: 83 ec 0c sub $0xc,%esp
10c949: 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,
10c94c: 8b 0d dc 92 11 00 mov 0x1192dc,%ecx
10c952: b8 10 00 00 00 mov $0x10,%eax
10c957: 31 d2 xor %edx,%edx
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16;
!is_valid && (bit_mask <= 512);
10c959: 39 c8 cmp %ecx,%eax
10c95b: 74 0d je 10c96a <IMFS_initialize_support+0x2a>
bit_mask <<= 1) {
10c95d: d1 e0 shl %eax
10c95f: 42 inc %edx
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16;
!is_valid && (bit_mask <= 512);
10c960: 83 fa 06 cmp $0x6,%edx
10c963: 75 f4 jne 10c959 <IMFS_initialize_support+0x19><== ALWAYS TAKEN
10c965: b8 80 00 00 00 mov $0x80,%eax <== NOT EXECUTED
bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
is_valid = true;
}
}
*dest_bytes_per_block = ((is_valid)
10c96a: a3 54 d5 11 00 mov %eax,0x11d554
* 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_node(
10c96f: 83 ec 0c sub $0xc,%esp
10c972: 6a 00 push $0x0
10c974: 68 ed 41 00 00 push $0x41ed
10c979: 68 55 72 11 00 push $0x117255
10c97e: 6a 01 push $0x1
10c980: 6a 00 push $0x0
10c982: e8 e9 1d 00 00 call 10e770 <IMFS_create_node>
10c987: 89 43 18 mov %eax,0x18(%ebx)
"",
( S_IFDIR | 0755 ),
NULL
);
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
10c98a: 8b 45 14 mov 0x14(%ebp),%eax
10c98d: 89 43 1c mov %eax,0x1c(%ebx)
temp_mt_entry->mt_fs_root.ops = op_table;
10c990: 8b 45 0c mov 0xc(%ebp),%eax
10c993: 89 43 20 mov %eax,0x20(%ebx)
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
10c996: 8d 7b 30 lea 0x30(%ebx),%edi
10c999: be 60 7a 11 00 mov $0x117a60,%esi
10c99e: b9 0c 00 00 00 mov $0xc,%ecx
10c9a3: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
10c9a5: 83 c4 18 add $0x18,%esp
10c9a8: 6a 0c push $0xc
10c9aa: 6a 01 push $0x1
10c9ac: e8 1f 03 00 00 call 10ccd0 <calloc>
10c9b1: 89 c2 mov %eax,%edx
if ( !fs_info ){
10c9b3: 83 c4 10 add $0x10,%esp
10c9b6: 85 c0 test %eax,%eax
10c9b8: 75 1e jne 10c9d8 <IMFS_initialize_support+0x98><== ALWAYS TAKEN
free(temp_mt_entry->mt_fs_root.node_access);
10c9ba: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c9bd: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED
10c9c0: e8 b3 9a ff ff call 106478 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
10c9c5: e8 5e 27 00 00 call 10f128 <__errno> <== NOT EXECUTED
10c9ca: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
10c9d0: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10c9d3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c9d6: eb 21 jmp 10c9f9 <IMFS_initialize_support+0xb9><== NOT EXECUTED
}
temp_mt_entry->fs_info = fs_info;
10c9d8: 89 43 2c mov %eax,0x2c(%ebx)
/*
* Set st_ino for the root to 1.
*/
fs_info->ino_count = 1;
10c9db: c7 00 01 00 00 00 movl $0x1,(%eax)
fs_info->memfile_handlers = memfile_handlers;
10c9e1: 8b 45 10 mov 0x10(%ebp),%eax
10c9e4: 89 42 04 mov %eax,0x4(%edx)
fs_info->directory_handlers = directory_handlers;
10c9e7: 8b 45 14 mov 0x14(%ebp),%eax
10c9ea: 89 42 08 mov %eax,0x8(%edx)
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
10c9ed: 8b 43 18 mov 0x18(%ebx),%eax
10c9f0: c7 40 38 01 00 00 00 movl $0x1,0x38(%eax)
10c9f7: 31 c0 xor %eax,%eax
return 0;
}
10c9f9: 8d 65 f4 lea -0xc(%ebp),%esp
10c9fc: 5b pop %ebx
10c9fd: 5e pop %esi
10c9fe: 5f pop %edi
10c9ff: c9 leave
10ca00: c3 ret
0010697c <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 */
)
{
10697c: 55 push %ebp
10697d: 89 e5 mov %esp,%ebp
10697f: 53 push %ebx
106980: 83 ec 44 sub $0x44,%esp
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
106983: 8b 45 08 mov 0x8(%ebp),%eax
106986: 8b 00 mov (%eax),%eax
106988: 89 45 e0 mov %eax,-0x20(%ebp)
if ( info.hard_link.link_node->st_nlink >= LINK_MAX )
10698b: 66 83 78 34 07 cmpw $0x7,0x34(%eax)
106990: 76 0d jbe 10699f <IMFS_link+0x23>
rtems_set_errno_and_return_minus_one( EMLINK );
106992: e8 49 a6 00 00 call 110fe0 <__errno>
106997: c7 00 1f 00 00 00 movl $0x1f,(%eax)
10699d: eb 39 jmp 1069d8 <IMFS_link+0x5c>
/*
* Remove any separators at the end of the string.
*/
IMFS_get_token( token, new_name, &i );
10699f: 52 push %edx
1069a0: 8d 45 f8 lea -0x8(%ebp),%eax
1069a3: 50 push %eax
1069a4: 8d 5d bf lea -0x41(%ebp),%ebx
1069a7: 53 push %ebx
1069a8: ff 75 10 pushl 0x10(%ebp)
1069ab: e8 f4 75 00 00 call 10dfa4 <IMFS_get_token>
/*
* Create a new link node.
*/
new_node = IMFS_create_node(
1069b0: 8d 45 e0 lea -0x20(%ebp),%eax
1069b3: 89 04 24 mov %eax,(%esp)
1069b6: 68 ff a1 00 00 push $0xa1ff
1069bb: 53 push %ebx
1069bc: 6a 03 push $0x3
1069be: ff 75 0c pushl 0xc(%ebp)
1069c1: e8 ae 6d 00 00 call 10d774 <IMFS_create_node>
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if ( !new_node )
1069c6: 83 c4 20 add $0x20,%esp
1069c9: 85 c0 test %eax,%eax
1069cb: 75 10 jne 1069dd <IMFS_link+0x61> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOMEM );
1069cd: e8 0e a6 00 00 call 110fe0 <__errno> <== NOT EXECUTED
1069d2: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
1069d8: 83 c8 ff or $0xffffffff,%eax
1069db: eb 22 jmp 1069ff <IMFS_link+0x83>
/*
* Increment the link count of the node being pointed to.
*/
info.hard_link.link_node->st_nlink++;
1069dd: 8b 45 e0 mov -0x20(%ebp),%eax
1069e0: 66 ff 40 34 incw 0x34(%eax)
IMFS_update_ctime( info.hard_link.link_node );
1069e4: 50 push %eax
1069e5: 50 push %eax
1069e6: 6a 00 push $0x0
1069e8: 8d 45 f0 lea -0x10(%ebp),%eax
1069eb: 50 push %eax
1069ec: e8 77 0a 00 00 call 107468 <gettimeofday>
1069f1: 8b 55 f0 mov -0x10(%ebp),%edx
1069f4: 8b 45 e0 mov -0x20(%ebp),%eax
1069f7: 89 50 48 mov %edx,0x48(%eax)
1069fa: 31 c0 xor %eax,%eax
1069fc: 83 c4 10 add $0x10,%esp
return 0;
}
1069ff: 8b 5d fc mov -0x4(%ebp),%ebx
106a02: c9 leave
106a03: c3 ret
0010fd2f <IMFS_memfile_addblock>:
MEMFILE_STATIC int IMFS_memfile_addblock(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
10fd2f: 55 push %ebp
10fd30: 89 e5 mov %esp,%ebp
10fd32: 53 push %ebx
10fd33: 83 ec 04 sub $0x4,%esp
10fd36: 8b 45 08 mov 0x8(%ebp),%eax
block_p memory;
block_p *block_entry_ptr;
assert( the_jnode );
10fd39: 85 c0 test %eax,%eax
10fd3b: 75 11 jne 10fd4e <IMFS_memfile_addblock+0x1f><== ALWAYS TAKEN
10fd3d: 68 bc b5 11 00 push $0x11b5bc <== NOT EXECUTED
10fd42: 68 48 b7 11 00 push $0x11b748 <== NOT EXECUTED
10fd47: 68 69 01 00 00 push $0x169 <== NOT EXECUTED
10fd4c: eb 15 jmp 10fd63 <IMFS_memfile_addblock+0x34><== NOT EXECUTED
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE );
10fd4e: 83 78 4c 05 cmpl $0x5,0x4c(%eax)
10fd52: 74 19 je 10fd6d <IMFS_memfile_addblock+0x3e><== ALWAYS TAKEN
10fd54: 68 12 b6 11 00 push $0x11b612 <== NOT EXECUTED
10fd59: 68 48 b7 11 00 push $0x11b748 <== NOT EXECUTED
10fd5e: 68 6d 01 00 00 push $0x16d <== NOT EXECUTED
10fd63: 68 c6 b5 11 00 push $0x11b5c6 <== NOT EXECUTED
10fd68: e8 37 70 ff ff call 106da4 <__assert_func> <== NOT EXECUTED
if ( the_jnode->type != IMFS_MEMORY_FILE )
rtems_set_errno_and_return_minus_one( EIO );
block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 );
10fd6d: 52 push %edx
10fd6e: 6a 01 push $0x1
10fd70: ff 75 0c pushl 0xc(%ebp)
10fd73: 50 push %eax
10fd74: e8 95 fb ff ff call 10f90e <IMFS_memfile_get_block_pointer>
10fd79: 89 c3 mov %eax,%ebx
if ( *block_entry_ptr )
10fd7b: 83 c4 10 add $0x10,%esp
10fd7e: 31 c0 xor %eax,%eax
10fd80: 83 3b 00 cmpl $0x0,(%ebx)
10fd83: 75 14 jne 10fd99 <IMFS_memfile_addblock+0x6a>
#if 0
fprintf(stdout, "%d %p", block, block_entry_ptr );
fflush(stdout);
#endif
memory = memfile_alloc_block();
10fd85: e8 62 fb ff ff call 10f8ec <memfile_alloc_block>
10fd8a: 89 c2 mov %eax,%edx
if ( !memory )
10fd8c: b8 01 00 00 00 mov $0x1,%eax
10fd91: 85 d2 test %edx,%edx
10fd93: 74 04 je 10fd99 <IMFS_memfile_addblock+0x6a><== NEVER TAKEN
return 1;
*block_entry_ptr = memory;
10fd95: 89 13 mov %edx,(%ebx)
10fd97: 31 c0 xor %eax,%eax
return 0;
}
10fd99: 8b 5d fc mov -0x4(%ebp),%ebx
10fd9c: c9 leave
10fd9d: c3 ret
0010fd9e <IMFS_memfile_extend>:
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
10fd9e: 55 push %ebp
10fd9f: 89 e5 mov %esp,%ebp
10fda1: 57 push %edi
10fda2: 56 push %esi
10fda3: 53 push %ebx
10fda4: 83 ec 0c sub $0xc,%esp
10fda7: 8b 7d 08 mov 0x8(%ebp),%edi
10fdaa: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Perform internal consistency checks
*/
assert( the_jnode );
10fdad: 85 ff test %edi,%edi
10fdaf: 75 11 jne 10fdc2 <IMFS_memfile_extend+0x24><== ALWAYS TAKEN
10fdb1: 68 bc b5 11 00 push $0x11b5bc <== NOT EXECUTED
10fdb6: 68 60 b7 11 00 push $0x11b760 <== NOT EXECUTED
10fdbb: 68 31 01 00 00 push $0x131 <== NOT EXECUTED
10fdc0: eb 15 jmp 10fdd7 <IMFS_memfile_extend+0x39><== NOT EXECUTED
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE );
10fdc2: 83 7f 4c 05 cmpl $0x5,0x4c(%edi)
10fdc6: 74 19 je 10fde1 <IMFS_memfile_extend+0x43><== ALWAYS TAKEN
10fdc8: 68 12 b6 11 00 push $0x11b612 <== NOT EXECUTED
10fdcd: 68 60 b7 11 00 push $0x11b760 <== NOT EXECUTED
10fdd2: 68 35 01 00 00 push $0x135 <== NOT EXECUTED
10fdd7: 68 c6 b5 11 00 push $0x11b5c6 <== NOT EXECUTED
10fddc: e8 c3 6f ff ff call 106da4 <__assert_func> <== NOT EXECUTED
if ( the_jnode->type != IMFS_MEMORY_FILE )
rtems_set_errno_and_return_minus_one( EIO );
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
10fde1: 8b 0d ac 11 12 00 mov 0x1211ac,%ecx
10fde7: 89 ca mov %ecx,%edx
10fde9: c1 ea 02 shr $0x2,%edx
10fdec: 8d 42 01 lea 0x1(%edx),%eax
10fdef: 0f af c2 imul %edx,%eax
10fdf2: 40 inc %eax
10fdf3: 0f af c2 imul %edx,%eax
10fdf6: 48 dec %eax
10fdf7: 0f af c1 imul %ecx,%eax
10fdfa: 39 c6 cmp %eax,%esi
10fdfc: 72 0d jb 10fe0b <IMFS_memfile_extend+0x6d><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10fdfe: e8 dd 11 00 00 call 110fe0 <__errno> <== NOT EXECUTED
10fe03: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
10fe09: eb 4c jmp 10fe57 <IMFS_memfile_extend+0xb9><== NOT EXECUTED
if ( new_length <= the_jnode->info.file.size )
10fe0b: 8b 5f 50 mov 0x50(%edi),%ebx
10fe0e: 31 d2 xor %edx,%edx
10fe10: 39 de cmp %ebx,%esi
10fe12: 7e 53 jle 10fe67 <IMFS_memfile_extend+0xc9>
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
10fe14: 89 f0 mov %esi,%eax
10fe16: 99 cltd
10fe17: f7 f9 idiv %ecx
10fe19: 89 45 f0 mov %eax,-0x10(%ebp)
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
10fe1c: 89 d8 mov %ebx,%eax
10fe1e: 99 cltd
10fe1f: f7 f9 idiv %ecx
10fe21: 89 45 ec mov %eax,-0x14(%ebp)
10fe24: 89 c3 mov %eax,%ebx
10fe26: eb 35 jmp 10fe5d <IMFS_memfile_extend+0xbf>
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
10fe28: 50 push %eax
10fe29: 50 push %eax
10fe2a: 53 push %ebx
10fe2b: 57 push %edi
10fe2c: e8 fe fe ff ff call 10fd2f <IMFS_memfile_addblock>
10fe31: 83 c4 10 add $0x10,%esp
10fe34: 85 c0 test %eax,%eax
10fe36: 74 24 je 10fe5c <IMFS_memfile_extend+0xbe><== ALWAYS TAKEN
10fe38: eb 0d jmp 10fe47 <IMFS_memfile_extend+0xa9><== NOT EXECUTED
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
10fe3a: 51 push %ecx <== NOT EXECUTED
10fe3b: 51 push %ecx <== NOT EXECUTED
10fe3c: 53 push %ebx <== NOT EXECUTED
10fe3d: 57 push %edi <== NOT EXECUTED
10fe3e: e8 4f fc ff ff call 10fa92 <IMFS_memfile_remove_block><== NOT EXECUTED
* 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-- ) {
10fe43: 4b dec %ebx <== NOT EXECUTED
10fe44: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10fe47: 3b 5d ec cmp -0x14(%ebp),%ebx <== NOT EXECUTED
10fe4a: 73 ee jae 10fe3a <IMFS_memfile_extend+0x9c><== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
10fe4c: e8 8f 11 00 00 call 110fe0 <__errno> <== NOT EXECUTED
10fe51: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED
10fe57: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED
10fe5a: eb 0b jmp 10fe67 <IMFS_memfile_extend+0xc9><== NOT EXECUTED
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
10fe5c: 43 inc %ebx
10fe5d: 3b 5d f0 cmp -0x10(%ebp),%ebx
10fe60: 76 c6 jbe 10fe28 <IMFS_memfile_extend+0x8a>
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
10fe62: 89 77 50 mov %esi,0x50(%edi)
10fe65: 31 d2 xor %edx,%edx
return 0;
}
10fe67: 89 d0 mov %edx,%eax
10fe69: 8d 65 f4 lea -0xc(%ebp),%esp
10fe6c: 5b pop %ebx
10fe6d: 5e pop %esi
10fe6e: 5f pop %edi
10fe6f: c9 leave
10fe70: c3 ret
0010f90e <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
10f90e: 55 push %ebp
10f90f: 89 e5 mov %esp,%ebp
10f911: 57 push %edi
10f912: 56 push %esi
10f913: 53 push %ebx
10f914: 83 ec 1c sub $0x1c,%esp
10f917: 8b 75 08 mov 0x8(%ebp),%esi
10f91a: 8b 5d 0c mov 0xc(%ebp),%ebx
10f91d: 8b 7d 10 mov 0x10(%ebp),%edi
/*
* Perform internal consistency checks
*/
assert( the_jnode );
10f920: 85 f6 test %esi,%esi
10f922: 75 11 jne 10f935 <IMFS_memfile_get_block_pointer+0x27><== ALWAYS TAKEN
10f924: 68 bc b5 11 00 push $0x11b5bc <== NOT EXECUTED
10f929: 68 cc b6 11 00 push $0x11b6cc <== NOT EXECUTED
10f92e: 68 86 03 00 00 push $0x386 <== NOT EXECUTED
10f933: eb 15 jmp 10f94a <IMFS_memfile_get_block_pointer+0x3c><== NOT EXECUTED
if ( !the_jnode )
return NULL;
assert( the_jnode->type == IMFS_MEMORY_FILE );
10f935: 83 7e 4c 05 cmpl $0x5,0x4c(%esi)
10f939: 74 19 je 10f954 <IMFS_memfile_get_block_pointer+0x46><== ALWAYS TAKEN
10f93b: 68 12 b6 11 00 push $0x11b612 <== NOT EXECUTED
10f940: 68 cc b6 11 00 push $0x11b6cc <== NOT EXECUTED
10f945: 68 8a 03 00 00 push $0x38a <== NOT EXECUTED
10f94a: 68 c6 b5 11 00 push $0x11b5c6 <== NOT EXECUTED
10f94f: e8 50 74 ff ff call 106da4 <__assert_func> <== NOT EXECUTED
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
10f954: a1 ac 11 12 00 mov 0x1211ac,%eax
10f959: c1 e8 02 shr $0x2,%eax
10f95c: 89 45 e4 mov %eax,-0x1c(%ebp)
10f95f: 48 dec %eax
10f960: 39 c3 cmp %eax,%ebx
10f962: 77 32 ja 10f996 <IMFS_memfile_get_block_pointer+0x88><== NEVER TAKEN
#if 0
fprintf(stdout, "(s %d) ", block );
fflush(stdout);
#endif
p = info->indirect;
10f964: 8b 46 54 mov 0x54(%esi),%eax
if ( malloc_it ) {
10f967: 85 ff test %edi,%edi
10f969: 74 23 je 10f98e <IMFS_memfile_get_block_pointer+0x80>
if ( !p ) {
10f96b: 85 c0 test %eax,%eax
10f96d: 75 10 jne 10f97f <IMFS_memfile_get_block_pointer+0x71>
p = memfile_alloc_block();
10f96f: e8 78 ff ff ff call 10f8ec <memfile_alloc_block>
if ( !p )
10f974: 85 c0 test %eax,%eax
10f976: 0f 84 0a 01 00 00 je 10fa86 <IMFS_memfile_get_block_pointer+0x178><== NEVER TAKEN
return 0;
info->indirect = p;
10f97c: 89 46 54 mov %eax,0x54(%esi)
}
return &info->indirect[ my_block ];
10f97f: 8d 14 9d 00 00 00 00 lea 0x0(,%ebx,4),%edx
10f986: 03 56 54 add 0x54(%esi),%edx
10f989: e9 fa 00 00 00 jmp 10fa88 <IMFS_memfile_get_block_pointer+0x17a>
}
if ( !p )
return 0;
return &info->indirect[ my_block ];
10f98e: 8d 14 98 lea (%eax,%ebx,4),%edx
10f991: e9 ec 00 00 00 jmp 10fa82 <IMFS_memfile_get_block_pointer+0x174>
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
10f996: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED
10f999: 41 inc %ecx <== NOT EXECUTED
10f99a: 0f af 4d e4 imul -0x1c(%ebp),%ecx <== NOT EXECUTED
10f99e: 8d 41 ff lea -0x1(%ecx),%eax <== NOT EXECUTED
10f9a1: 39 c3 cmp %eax,%ebx <== NOT EXECUTED
10f9a3: 77 5a ja 10f9ff <IMFS_memfile_get_block_pointer+0xf1><== NOT EXECUTED
#if 0
fprintf(stdout, "(d %d) ", block );
fflush(stdout);
#endif
my_block -= FIRST_DOUBLY_INDIRECT;
10f9a5: 2b 5d e4 sub -0x1c(%ebp),%ebx <== NOT EXECUTED
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
10f9a8: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10f9aa: 31 d2 xor %edx,%edx <== NOT EXECUTED
10f9ac: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED
10f9af: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED
10f9b2: 89 c3 mov %eax,%ebx <== NOT EXECUTED
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
p = info->doubly_indirect;
10f9b4: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED
if ( malloc_it ) {
10f9b7: 85 ff test %edi,%edi <== NOT EXECUTED
10f9b9: 74 31 je 10f9ec <IMFS_memfile_get_block_pointer+0xde><== NOT EXECUTED
if ( !p ) {
10f9bb: 85 c0 test %eax,%eax <== NOT EXECUTED
10f9bd: 75 10 jne 10f9cf <IMFS_memfile_get_block_pointer+0xc1><== NOT EXECUTED
p = memfile_alloc_block();
10f9bf: e8 28 ff ff ff call 10f8ec <memfile_alloc_block> <== NOT EXECUTED
if ( !p )
10f9c4: 85 c0 test %eax,%eax <== NOT EXECUTED
10f9c6: 0f 84 ba 00 00 00 je 10fa86 <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
return 0;
info->doubly_indirect = p;
10f9cc: 89 46 58 mov %eax,0x58(%esi) <== NOT EXECUTED
}
p1 = (block_p *)p[ doubly ];
10f9cf: 8d 1c 98 lea (%eax,%ebx,4),%ebx <== NOT EXECUTED
10f9d2: 8b 03 mov (%ebx),%eax <== NOT EXECUTED
if ( !p1 ) {
10f9d4: 85 c0 test %eax,%eax <== NOT EXECUTED
10f9d6: 75 0f jne 10f9e7 <IMFS_memfile_get_block_pointer+0xd9><== NOT EXECUTED
p1 = memfile_alloc_block();
10f9d8: e8 0f ff ff ff call 10f8ec <memfile_alloc_block> <== NOT EXECUTED
if ( !p1 )
10f9dd: 85 c0 test %eax,%eax <== NOT EXECUTED
10f9df: 0f 84 a1 00 00 00 je 10fa86 <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
return 0;
p[ doubly ] = (block_p) p1;
10f9e5: 89 03 mov %eax,(%ebx) <== NOT EXECUTED
}
return (block_p *)&p1[ singly ];
10f9e7: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED
10f9ea: eb 7a jmp 10fa66 <IMFS_memfile_get_block_pointer+0x158><== NOT EXECUTED
}
if ( !p )
10f9ec: 85 c0 test %eax,%eax <== NOT EXECUTED
10f9ee: 0f 84 92 00 00 00 je 10fa86 <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
return 0;
p = (block_p *)p[ doubly ];
10f9f4: 8b 04 98 mov (%eax,%ebx,4),%eax <== NOT EXECUTED
#if 0
fprintf(stdout, "(d %d %d %d %d %p %p) ", block, my_block, doubly,
singly, p, &p[singly] );
fflush(stdout);
#endif
return (block_p *)&p[ singly ];
10f9f7: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED
10f9fa: e9 80 00 00 00 jmp 10fa7f <IMFS_memfile_get_block_pointer+0x171><== NOT EXECUTED
#endif
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
10f9ff: 8d 41 01 lea 0x1(%ecx),%eax <== NOT EXECUTED
10fa02: 0f af 45 e4 imul -0x1c(%ebp),%eax <== NOT EXECUTED
10fa06: 48 dec %eax <== NOT EXECUTED
10fa07: 39 c3 cmp %eax,%ebx <== NOT EXECUTED
10fa09: 77 7b ja 10fa86 <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
my_block -= FIRST_TRIPLY_INDIRECT;
10fa0b: 29 cb sub %ecx,%ebx <== NOT EXECUTED
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
10fa0d: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10fa0f: 31 d2 xor %edx,%edx <== NOT EXECUTED
10fa11: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED
10fa14: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
10fa17: 31 d2 xor %edx,%edx <== NOT EXECUTED
10fa19: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED
10fa1c: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED
10fa1f: 89 c3 mov %eax,%ebx <== NOT EXECUTED
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
p = info->triply_indirect;
10fa21: 8b 46 5c mov 0x5c(%esi),%eax <== NOT EXECUTED
if ( malloc_it ) {
10fa24: 85 ff test %edi,%edi <== NOT EXECUTED
10fa26: 74 43 je 10fa6b <IMFS_memfile_get_block_pointer+0x15d><== NOT EXECUTED
if ( !p ) {
10fa28: 85 c0 test %eax,%eax <== NOT EXECUTED
10fa2a: 75 0c jne 10fa38 <IMFS_memfile_get_block_pointer+0x12a><== NOT EXECUTED
p = memfile_alloc_block();
10fa2c: e8 bb fe ff ff call 10f8ec <memfile_alloc_block> <== NOT EXECUTED
if ( !p )
10fa31: 85 c0 test %eax,%eax <== NOT EXECUTED
10fa33: 74 51 je 10fa86 <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
return 0;
info->triply_indirect = p;
10fa35: 89 46 5c mov %eax,0x5c(%esi) <== NOT EXECUTED
}
p1 = (block_p *) p[ triply ];
10fa38: 8d 1c 98 lea (%eax,%ebx,4),%ebx <== NOT EXECUTED
10fa3b: 8b 03 mov (%ebx),%eax <== NOT EXECUTED
if ( !p1 ) {
10fa3d: 85 c0 test %eax,%eax <== NOT EXECUTED
10fa3f: 75 0b jne 10fa4c <IMFS_memfile_get_block_pointer+0x13e><== NOT EXECUTED
p1 = memfile_alloc_block();
10fa41: e8 a6 fe ff ff call 10f8ec <memfile_alloc_block> <== NOT EXECUTED
if ( !p1 )
10fa46: 85 c0 test %eax,%eax <== NOT EXECUTED
10fa48: 74 3c je 10fa86 <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
return 0;
p[ triply ] = (block_p) p1;
10fa4a: 89 03 mov %eax,(%ebx) <== NOT EXECUTED
}
p2 = (block_p *)p1[ doubly ];
10fa4c: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED
10fa4f: 8d 1c 88 lea (%eax,%ecx,4),%ebx <== NOT EXECUTED
10fa52: 8b 03 mov (%ebx),%eax <== NOT EXECUTED
if ( !p2 ) {
10fa54: 85 c0 test %eax,%eax <== NOT EXECUTED
10fa56: 75 0b jne 10fa63 <IMFS_memfile_get_block_pointer+0x155><== NOT EXECUTED
p2 = memfile_alloc_block();
10fa58: e8 8f fe ff ff call 10f8ec <memfile_alloc_block> <== NOT EXECUTED
if ( !p2 )
10fa5d: 85 c0 test %eax,%eax <== NOT EXECUTED
10fa5f: 74 25 je 10fa86 <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
return 0;
p1[ doubly ] = (block_p) p2;
10fa61: 89 03 mov %eax,(%ebx) <== NOT EXECUTED
}
return (block_p *)&p2[ singly ];
10fa63: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED
10fa66: 8d 14 88 lea (%eax,%ecx,4),%edx <== NOT EXECUTED
10fa69: eb 1d jmp 10fa88 <IMFS_memfile_get_block_pointer+0x17a><== NOT EXECUTED
}
if ( !p )
10fa6b: 85 c0 test %eax,%eax <== NOT EXECUTED
10fa6d: 74 17 je 10fa86 <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
#if 0
fprintf(stdout, "(t %d %d %d %d %d) ", block, my_block, triply, doubly, singly );
fflush(stdout);
#endif
p1 = (block_p *) p[ triply ];
10fa6f: 8b 04 98 mov (%eax,%ebx,4),%eax <== NOT EXECUTED
if ( !p1 )
10fa72: 85 c0 test %eax,%eax <== NOT EXECUTED
10fa74: 74 10 je 10fa86 <IMFS_memfile_get_block_pointer+0x178><== NOT EXECUTED
return 0;
p2 = (block_p *)p1[ doubly ];
10fa76: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED
10fa79: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED
if ( !p2 )
return 0;
return (block_p *)&p2[ singly ];
10fa7c: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED
10fa7f: 8d 14 88 lea (%eax,%ecx,4),%edx <== NOT EXECUTED
p1 = (block_p *) p[ triply ];
if ( !p1 )
return 0;
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
10fa82: 85 c0 test %eax,%eax
10fa84: 75 02 jne 10fa88 <IMFS_memfile_get_block_pointer+0x17a><== ALWAYS TAKEN
return 0;
return (block_p *)&p2[ singly ];
10fa86: 31 d2 xor %edx,%edx <== NOT EXECUTED
/*
* This means the requested block number is out of range.
*/
return 0;
}
10fa88: 89 d0 mov %edx,%eax
10fa8a: 8d 65 f4 lea -0xc(%ebp),%esp
10fa8d: 5b pop %ebx
10fa8e: 5e pop %esi
10fa8f: 5f pop %edi
10fa90: c9 leave
10fa91: c3 ret
00110172 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
110172: 55 push %ebp
110173: 89 e5 mov %esp,%ebp
110175: 57 push %edi
110176: 56 push %esi
110177: 53 push %ebx
110178: 83 ec 3c sub $0x3c,%esp
11017b: 8b 5d 14 mov 0x14(%ebp),%ebx
/*
* Perform internal consistency checks
*/
assert( the_jnode );
11017e: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
110182: 75 11 jne 110195 <IMFS_memfile_read+0x23><== ALWAYS TAKEN
110184: 68 bc b5 11 00 push $0x11b5bc <== NOT EXECUTED
110189: 68 00 b7 11 00 push $0x11b700 <== NOT EXECUTED
11018e: 68 4a 02 00 00 push $0x24a <== NOT EXECUTED
110193: eb 1d jmp 1101b2 <IMFS_memfile_read+0x40><== NOT EXECUTED
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE ||
110195: 8b 45 08 mov 0x8(%ebp),%eax
110198: 8b 48 4c mov 0x4c(%eax),%ecx
11019b: 8d 41 fb lea -0x5(%ecx),%eax
11019e: 83 f8 01 cmp $0x1,%eax
1101a1: 76 19 jbe 1101bc <IMFS_memfile_read+0x4a><== ALWAYS TAKEN
1101a3: 68 7c b6 11 00 push $0x11b67c <== NOT EXECUTED
1101a8: 68 00 b7 11 00 push $0x11b700 <== NOT EXECUTED
1101ad: 68 4f 02 00 00 push $0x24f <== NOT EXECUTED
1101b2: 68 c6 b5 11 00 push $0x11b5c6 <== NOT EXECUTED
1101b7: e8 e8 6b ff ff call 106da4 <__assert_func> <== NOT EXECUTED
/*
* Error checks on arguments
*/
assert( dest );
1101bc: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
1101c0: 75 11 jne 1101d3 <IMFS_memfile_read+0x61><== ALWAYS TAKEN
1101c2: 68 c7 b6 11 00 push $0x11b6c7 <== NOT EXECUTED
1101c7: 68 00 b7 11 00 push $0x11b700 <== NOT EXECUTED
1101cc: 68 58 02 00 00 push $0x258 <== NOT EXECUTED
1101d1: eb df jmp 1101b2 <IMFS_memfile_read+0x40><== NOT EXECUTED
/*
* If there is nothing to read, then quick exit.
*/
my_length = length;
if ( !my_length )
1101d3: 85 db test %ebx,%ebx
1101d5: 75 13 jne 1101ea <IMFS_memfile_read+0x78><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
1101d7: e8 04 0e 00 00 call 110fe0 <__errno> <== NOT EXECUTED
1101dc: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
1101e2: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED
1101e5: e9 86 01 00 00 jmp 110370 <IMFS_memfile_read+0x1fe><== NOT EXECUTED
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
if (the_jnode->type == IMFS_LINEAR_FILE) {
1101ea: 83 f9 06 cmp $0x6,%ecx
1101ed: 75 47 jne 110236 <IMFS_memfile_read+0xc4><== ALWAYS TAKEN
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
1101ef: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
1101f2: 8b 52 50 mov 0x50(%edx),%edx <== NOT EXECUTED
1101f5: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
1101f8: 29 ca sub %ecx,%edx <== NOT EXECUTED
1101fa: 89 55 c4 mov %edx,-0x3c(%ebp) <== NOT EXECUTED
1101fd: 39 da cmp %ebx,%edx <== NOT EXECUTED
1101ff: 76 03 jbe 110204 <IMFS_memfile_read+0x92><== NOT EXECUTED
110201: 89 5d c4 mov %ebx,-0x3c(%ebp) <== NOT EXECUTED
my_length = the_jnode->info.linearfile.size - start;
memcpy(dest, &file_ptr[start], my_length);
110204: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
110207: 8b 76 54 mov 0x54(%esi),%esi <== NOT EXECUTED
11020a: 01 75 0c add %esi,0xc(%ebp) <== NOT EXECUTED
11020d: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED
110210: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED
110213: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED
110216: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED
IMFS_update_atime( the_jnode );
110218: 50 push %eax <== NOT EXECUTED
110219: 50 push %eax <== NOT EXECUTED
11021a: 6a 00 push $0x0 <== NOT EXECUTED
11021c: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED
11021f: 50 push %eax <== NOT EXECUTED
110220: e8 43 72 ff ff call 107468 <gettimeofday> <== NOT EXECUTED
110225: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
110228: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED
11022b: 89 47 40 mov %eax,0x40(%edi) <== NOT EXECUTED
return my_length;
11022e: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED
110231: e9 37 01 00 00 jmp 11036d <IMFS_memfile_read+0x1fb><== 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 )
110236: 8b 45 08 mov 0x8(%ebp),%eax
110239: 8b 48 50 mov 0x50(%eax),%ecx
11023c: 8b 55 0c mov 0xc(%ebp),%edx
11023f: 8d 04 13 lea (%ebx,%edx,1),%eax
110242: 39 c8 cmp %ecx,%eax
110244: 76 05 jbe 11024b <IMFS_memfile_read+0xd9><== NEVER TAKEN
my_length = the_jnode->info.file.size - start;
110246: 89 cb mov %ecx,%ebx
110248: 2b 5d 0c sub 0xc(%ebp),%ebx
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
11024b: 8b 3d ac 11 12 00 mov 0x1211ac,%edi
110251: 8b 45 0c mov 0xc(%ebp),%eax
110254: 99 cltd
110255: f7 ff idiv %edi
110257: 89 d6 mov %edx,%esi
110259: 89 45 cc mov %eax,-0x34(%ebp)
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
11025c: 89 45 d4 mov %eax,-0x2c(%ebp)
if ( start_offset ) {
11025f: 85 d2 test %edx,%edx
110261: 75 0f jne 110272 <IMFS_memfile_read+0x100>
110263: 8b 4d 10 mov 0x10(%ebp),%ecx
110266: 89 4d dc mov %ecx,-0x24(%ebp)
110269: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp)
110270: eb 54 jmp 1102c6 <IMFS_memfile_read+0x154>
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 );
110272: 50 push %eax
110273: 6a 00 push $0x0
110275: ff 75 cc pushl -0x34(%ebp)
110278: ff 75 08 pushl 0x8(%ebp)
11027b: e8 8e f6 ff ff call 10f90e <IMFS_memfile_get_block_pointer>
assert( block_ptr );
110280: 83 c4 10 add $0x10,%esp
110283: 85 c0 test %eax,%eax
110285: 75 14 jne 11029b <IMFS_memfile_read+0x129><== ALWAYS TAKEN
110287: 68 49 b6 11 00 push $0x11b649 <== NOT EXECUTED
11028c: 68 00 b7 11 00 push $0x11b700 <== NOT EXECUTED
110291: 68 94 02 00 00 push $0x294 <== NOT EXECUTED
110296: e9 17 ff ff ff jmp 1101b2 <IMFS_memfile_read+0x40><== NOT EXECUTED
*/
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;
11029b: 89 fa mov %edi,%edx
11029d: 29 f2 sub %esi,%edx
11029f: 89 5d c0 mov %ebx,-0x40(%ebp)
1102a2: 39 d3 cmp %edx,%ebx
1102a4: 76 03 jbe 1102a9 <IMFS_memfile_read+0x137>
1102a6: 89 55 c0 mov %edx,-0x40(%ebp)
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
assert( block_ptr );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
1102a9: 03 30 add (%eax),%esi
dest += to_copy;
1102ab: 8b 7d 10 mov 0x10(%ebp),%edi
1102ae: 8b 4d c0 mov -0x40(%ebp),%ecx
1102b1: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
1102b3: 89 7d dc mov %edi,-0x24(%ebp)
block++;
1102b6: 8b 45 cc mov -0x34(%ebp),%eax
1102b9: 40 inc %eax
1102ba: 89 45 d4 mov %eax,-0x2c(%ebp)
my_length -= to_copy;
1102bd: 2b 5d c0 sub -0x40(%ebp),%ebx
1102c0: 8b 55 c0 mov -0x40(%ebp),%edx
1102c3: 89 55 d8 mov %edx,-0x28(%ebp)
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
1102c6: 8b 0d ac 11 12 00 mov 0x1211ac,%ecx
1102cc: 89 4d e0 mov %ecx,-0x20(%ebp)
1102cf: eb 42 jmp 110313 <IMFS_memfile_read+0x1a1>
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
1102d1: 57 push %edi
1102d2: 6a 00 push $0x0
1102d4: ff 75 d4 pushl -0x2c(%ebp)
1102d7: ff 75 08 pushl 0x8(%ebp)
1102da: e8 2f f6 ff ff call 10f90e <IMFS_memfile_get_block_pointer>
assert( block_ptr );
1102df: 83 c4 10 add $0x10,%esp
1102e2: 85 c0 test %eax,%eax
1102e4: 75 14 jne 1102fa <IMFS_memfile_read+0x188><== ALWAYS TAKEN
1102e6: 68 49 b6 11 00 push $0x11b649 <== NOT EXECUTED
1102eb: 68 00 b7 11 00 push $0x11b700 <== NOT EXECUTED
1102f0: 68 a5 02 00 00 push $0x2a5 <== NOT EXECUTED
1102f5: e9 b8 fe ff ff jmp 1101b2 <IMFS_memfile_read+0x40><== NOT EXECUTED
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
1102fa: 8b 30 mov (%eax),%esi
1102fc: 8b 7d dc mov -0x24(%ebp),%edi
1102ff: 8b 4d e0 mov -0x20(%ebp),%ecx
110302: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
dest += to_copy;
110304: 89 7d dc mov %edi,-0x24(%ebp)
block++;
110307: ff 45 d4 incl -0x2c(%ebp)
my_length -= to_copy;
11030a: 2b 5d e0 sub -0x20(%ebp),%ebx
copied += to_copy;
11030d: 8b 75 e0 mov -0x20(%ebp),%esi
110310: 01 75 d8 add %esi,-0x28(%ebp)
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
110313: 3b 1d ac 11 12 00 cmp 0x1211ac,%ebx
110319: 73 b6 jae 1102d1 <IMFS_memfile_read+0x15f>
* Phase 3: possibly the first part of one block
*/
assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
11031b: 85 db test %ebx,%ebx
11031d: 74 35 je 110354 <IMFS_memfile_read+0x1e2>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
11031f: 56 push %esi
110320: 6a 00 push $0x0
110322: ff 75 d4 pushl -0x2c(%ebp)
110325: ff 75 08 pushl 0x8(%ebp)
110328: e8 e1 f5 ff ff call 10f90e <IMFS_memfile_get_block_pointer>
assert( block_ptr );
11032d: 83 c4 10 add $0x10,%esp
110330: 85 c0 test %eax,%eax
110332: 75 14 jne 110348 <IMFS_memfile_read+0x1d6><== ALWAYS TAKEN
110334: 68 49 b6 11 00 push $0x11b649 <== NOT EXECUTED
110339: 68 00 b7 11 00 push $0x11b700 <== NOT EXECUTED
11033e: 68 b7 02 00 00 push $0x2b7 <== NOT EXECUTED
110343: e9 6a fe ff ff jmp 1101b2 <IMFS_memfile_read+0x40><== NOT EXECUTED
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
110348: 8b 30 mov (%eax),%esi
11034a: 8b 7d dc mov -0x24(%ebp),%edi
11034d: 89 d9 mov %ebx,%ecx
11034f: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
copied += my_length;
110351: 01 5d d8 add %ebx,-0x28(%ebp)
}
IMFS_update_atime( the_jnode );
110354: 53 push %ebx
110355: 53 push %ebx
110356: 6a 00 push $0x0
110358: 8d 45 ec lea -0x14(%ebp),%eax
11035b: 50 push %eax
11035c: e8 07 71 ff ff call 107468 <gettimeofday>
110361: 8b 45 ec mov -0x14(%ebp),%eax
110364: 8b 7d 08 mov 0x8(%ebp),%edi
110367: 89 47 40 mov %eax,0x40(%edi)
return copied;
11036a: 8b 4d d8 mov -0x28(%ebp),%ecx
11036d: 83 c4 10 add $0x10,%esp
}
110370: 89 c8 mov %ecx,%eax
110372: 8d 65 f4 lea -0xc(%ebp),%esp
110375: 5b pop %ebx
110376: 5e pop %esi
110377: 5f pop %edi
110378: c9 leave
110379: c3 ret
0010fb26 <IMFS_memfile_remove>:
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
10fb26: 55 push %ebp
10fb27: 89 e5 mov %esp,%ebp
10fb29: 57 push %edi
10fb2a: 56 push %esi
10fb2b: 53 push %ebx
10fb2c: 83 ec 0c sub $0xc,%esp
/*
* Perform internal consistency checks
*/
assert( the_jnode );
10fb2f: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
10fb33: 75 11 jne 10fb46 <IMFS_memfile_remove+0x20><== ALWAYS TAKEN
10fb35: 68 bc b5 11 00 push $0x11b5bc <== NOT EXECUTED
10fb3a: 68 14 b7 11 00 push $0x11b714 <== NOT EXECUTED
10fb3f: 68 ec 01 00 00 push $0x1ec <== NOT EXECUTED
10fb44: eb 18 jmp 10fb5e <IMFS_memfile_remove+0x38><== NOT EXECUTED
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE );
10fb46: 8b 45 08 mov 0x8(%ebp),%eax
10fb49: 83 78 4c 05 cmpl $0x5,0x4c(%eax)
10fb4d: 74 19 je 10fb68 <IMFS_memfile_remove+0x42><== ALWAYS TAKEN
10fb4f: 68 12 b6 11 00 push $0x11b612 <== NOT EXECUTED
10fb54: 68 14 b7 11 00 push $0x11b714 <== NOT EXECUTED
10fb59: 68 f0 01 00 00 push $0x1f0 <== NOT EXECUTED
10fb5e: 68 c6 b5 11 00 push $0x11b5c6 <== NOT EXECUTED
10fb63: e8 3c 72 ff ff call 106da4 <__assert_func> <== NOT EXECUTED
/*
* 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;
10fb68: 8b 3d ac 11 12 00 mov 0x1211ac,%edi
10fb6e: c1 ef 02 shr $0x2,%edi
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
10fb71: 8b 55 08 mov 0x8(%ebp),%edx
10fb74: 83 7a 54 00 cmpl $0x0,0x54(%edx)
10fb78: 74 11 je 10fb8b <IMFS_memfile_remove+0x65>
memfile_free_blocks_in_table( &info->indirect, to_free );
10fb7a: 50 push %eax
10fb7b: 50 push %eax
10fb7c: 57 push %edi
10fb7d: 89 d0 mov %edx,%eax
10fb7f: 83 c0 54 add $0x54,%eax
10fb82: 50 push %eax
10fb83: e8 34 ff ff ff call 10fabc <memfile_free_blocks_in_table>
10fb88: 83 c4 10 add $0x10,%esp
}
if ( info->doubly_indirect ) {
10fb8b: 31 db xor %ebx,%ebx
10fb8d: 8b 45 08 mov 0x8(%ebp),%eax
10fb90: 83 78 58 00 cmpl $0x0,0x58(%eax)
10fb94: 75 24 jne 10fbba <IMFS_memfile_remove+0x94><== NEVER TAKEN
10fb96: eb 40 jmp 10fbd8 <IMFS_memfile_remove+0xb2>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
if ( info->doubly_indirect[i] ) {
10fb98: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
10fb9b: 8b 42 58 mov 0x58(%edx),%eax <== NOT EXECUTED
10fb9e: 8d 14 9d 00 00 00 00 lea 0x0(,%ebx,4),%edx <== NOT EXECUTED
10fba5: 83 3c 98 00 cmpl $0x0,(%eax,%ebx,4) <== NOT EXECUTED
10fba9: 74 0e je 10fbb9 <IMFS_memfile_remove+0x93><== NOT EXECUTED
memfile_free_blocks_in_table(
10fbab: 56 push %esi <== NOT EXECUTED
10fbac: 56 push %esi <== NOT EXECUTED
10fbad: 57 push %edi <== NOT EXECUTED
10fbae: 01 d0 add %edx,%eax <== NOT EXECUTED
10fbb0: 50 push %eax <== NOT EXECUTED
10fbb1: e8 06 ff ff ff call 10fabc <memfile_free_blocks_in_table><== NOT EXECUTED
10fbb6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
10fbb9: 43 inc %ebx <== NOT EXECUTED
10fbba: a1 ac 11 12 00 mov 0x1211ac,%eax <== NOT EXECUTED
10fbbf: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED
10fbc2: 39 c3 cmp %eax,%ebx <== NOT EXECUTED
10fbc4: 72 d2 jb 10fb98 <IMFS_memfile_remove+0x72><== NOT EXECUTED
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 );
10fbc6: 53 push %ebx <== NOT EXECUTED
10fbc7: 53 push %ebx <== NOT EXECUTED
10fbc8: 57 push %edi <== NOT EXECUTED
10fbc9: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10fbcc: 83 c0 58 add $0x58,%eax <== NOT EXECUTED
10fbcf: 50 push %eax <== NOT EXECUTED
10fbd0: e8 e7 fe ff ff call 10fabc <memfile_free_blocks_in_table><== NOT EXECUTED
10fbd5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
if ( info->triply_indirect ) {
10fbd8: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
10fbdf: 8b 45 08 mov 0x8(%ebp),%eax
10fbe2: 83 78 5c 00 cmpl $0x0,0x5c(%eax)
10fbe6: 75 5c jne 10fc44 <IMFS_memfile_remove+0x11e><== NEVER TAKEN
10fbe8: eb 79 jmp 10fc63 <IMFS_memfile_remove+0x13d>
10fbea: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED
10fbed: c1 e2 02 shl $0x2,%edx <== NOT EXECUTED
10fbf0: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
10fbf3: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
10fbf6: 8b 42 5c mov 0x5c(%edx),%eax <== NOT EXECUTED
10fbf9: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED
10fbfc: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED
if ( !p ) /* ensure we have a valid pointer */
10fbff: 85 c0 test %eax,%eax <== NOT EXECUTED
10fc01: 74 4e je 10fc51 <IMFS_memfile_remove+0x12b><== NOT EXECUTED
break;
10fc03: 89 c3 mov %eax,%ebx <== NOT EXECUTED
10fc05: 31 f6 xor %esi,%esi <== NOT EXECUTED
10fc07: eb 15 jmp 10fc1e <IMFS_memfile_remove+0xf8><== NOT EXECUTED
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
10fc09: 83 3b 00 cmpl $0x0,(%ebx) <== NOT EXECUTED
10fc0c: 74 0c je 10fc1a <IMFS_memfile_remove+0xf4><== NOT EXECUTED
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
10fc0e: 51 push %ecx <== NOT EXECUTED
10fc0f: 51 push %ecx <== NOT EXECUTED
10fc10: 57 push %edi <== NOT EXECUTED
10fc11: 53 push %ebx <== NOT EXECUTED
10fc12: e8 a5 fe ff ff call 10fabc <memfile_free_blocks_in_table><== NOT EXECUTED
10fc17: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
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++ ) {
10fc1a: 46 inc %esi <== NOT EXECUTED
10fc1b: 83 c3 04 add $0x4,%ebx <== NOT EXECUTED
10fc1e: a1 ac 11 12 00 mov 0x1211ac,%eax <== NOT EXECUTED
10fc23: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED
10fc26: 39 c6 cmp %eax,%esi <== NOT EXECUTED
10fc28: 72 df jb 10fc09 <IMFS_memfile_remove+0xe3><== NOT EXECUTED
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
10fc2a: 52 push %edx <== NOT EXECUTED
10fc2b: 52 push %edx <== NOT EXECUTED
10fc2c: 57 push %edi <== NOT EXECUTED
10fc2d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10fc30: 8b 40 5c mov 0x5c(%eax),%eax <== NOT EXECUTED
10fc33: 01 45 f0 add %eax,-0x10(%ebp) <== NOT EXECUTED
10fc36: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED
10fc39: e8 7e fe ff ff call 10fabc <memfile_free_blocks_in_table><== NOT EXECUTED
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
10fc3e: ff 45 ec incl -0x14(%ebp) <== NOT EXECUTED
10fc41: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10fc44: a1 ac 11 12 00 mov 0x1211ac,%eax <== NOT EXECUTED
10fc49: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED
10fc4c: 39 45 ec cmp %eax,-0x14(%ebp) <== NOT EXECUTED
10fc4f: 72 99 jb 10fbea <IMFS_memfile_remove+0xc4><== NOT EXECUTED
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
10fc51: 50 push %eax <== NOT EXECUTED
10fc52: 50 push %eax <== NOT EXECUTED
10fc53: 57 push %edi <== NOT EXECUTED
10fc54: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10fc57: 83 c0 5c add $0x5c,%eax <== NOT EXECUTED
10fc5a: 50 push %eax <== NOT EXECUTED
10fc5b: e8 5c fe ff ff call 10fabc <memfile_free_blocks_in_table><== NOT EXECUTED
10fc60: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
10fc63: 31 c0 xor %eax,%eax
10fc65: 8d 65 f4 lea -0xc(%ebp),%esp
10fc68: 5b pop %ebx
10fc69: 5e pop %esi
10fc6a: 5f pop %edi
10fc6b: c9 leave
10fc6c: c3 ret
0010fa92 <IMFS_memfile_remove_block>:
MEMFILE_STATIC int IMFS_memfile_remove_block(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
10fa92: 55 push %ebp <== NOT EXECUTED
10fa93: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10fa95: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
block_p *block_entry_ptr;
block_p ptr;
block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
10fa98: 6a 00 push $0x0 <== NOT EXECUTED
10fa9a: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
10fa9d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
10faa0: e8 69 fe ff ff call 10f90e <IMFS_memfile_get_block_pointer><== NOT EXECUTED
ptr = *block_entry_ptr;
10faa5: 8b 10 mov (%eax),%edx <== NOT EXECUTED
*block_entry_ptr = 0;
10faa7: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
memfile_free_block( ptr );
10faad: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED
10fab0: e8 1e fe ff ff call 10f8d3 <memfile_free_block> <== NOT EXECUTED
return 1;
}
10fab5: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
10faba: c9 leave <== NOT EXECUTED
10fabb: c3 ret <== NOT EXECUTED
0010ff04 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
10ff04: 55 push %ebp
10ff05: 89 e5 mov %esp,%ebp
10ff07: 57 push %edi
10ff08: 56 push %esi
10ff09: 53 push %ebx
10ff0a: 83 ec 3c sub $0x3c,%esp
/*
* Perform internal consistency checks
*/
assert( the_jnode );
10ff0d: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
10ff11: 75 11 jne 10ff24 <IMFS_memfile_write+0x20><== ALWAYS TAKEN
10ff13: 68 bc b5 11 00 push $0x11b5bc <== NOT EXECUTED
10ff18: 68 ec b6 11 00 push $0x11b6ec <== NOT EXECUTED
10ff1d: 68 e1 02 00 00 push $0x2e1 <== NOT EXECUTED
10ff22: eb 18 jmp 10ff3c <IMFS_memfile_write+0x38><== NOT EXECUTED
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE );
10ff24: 8b 45 08 mov 0x8(%ebp),%eax
10ff27: 83 78 4c 05 cmpl $0x5,0x4c(%eax)
10ff2b: 74 19 je 10ff46 <IMFS_memfile_write+0x42><== ALWAYS TAKEN
10ff2d: 68 12 b6 11 00 push $0x11b612 <== NOT EXECUTED
10ff32: 68 ec b6 11 00 push $0x11b6ec <== NOT EXECUTED
10ff37: 68 e5 02 00 00 push $0x2e5 <== NOT EXECUTED
10ff3c: 68 c6 b5 11 00 push $0x11b5c6 <== NOT EXECUTED
10ff41: e8 5e 6e ff ff call 106da4 <__assert_func> <== NOT EXECUTED
/*
* Error check arguments
*/
assert( source );
10ff46: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10ff4a: 75 11 jne 10ff5d <IMFS_memfile_write+0x59><== ALWAYS TAKEN
10ff4c: 68 42 b6 11 00 push $0x11b642 <== NOT EXECUTED
10ff51: 68 ec b6 11 00 push $0x11b6ec <== NOT EXECUTED
10ff56: 68 ed 02 00 00 push $0x2ed <== NOT EXECUTED
10ff5b: eb df jmp 10ff3c <IMFS_memfile_write+0x38><== NOT EXECUTED
/*
* If there is nothing to write, then quick exit.
*/
my_length = length;
if ( !my_length )
10ff5d: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10ff61: 75 0d jne 10ff70 <IMFS_memfile_write+0x6c><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10ff63: e8 78 10 00 00 call 110fe0 <__errno> <== NOT EXECUTED
10ff68: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
10ff6e: eb 29 jmp 10ff99 <IMFS_memfile_write+0x95><== NOT EXECUTED
/*
* 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 + length;
10ff70: 8b 45 14 mov 0x14(%ebp),%eax
10ff73: 03 45 0c add 0xc(%ebp),%eax
if ( last_byte > the_jnode->info.file.size ) {
10ff76: 8b 55 08 mov 0x8(%ebp),%edx
10ff79: 3b 42 50 cmp 0x50(%edx),%eax
10ff7c: 76 27 jbe 10ffa5 <IMFS_memfile_write+0xa1><== NEVER TAKEN
status = IMFS_memfile_extend( the_jnode, last_byte );
10ff7e: 51 push %ecx
10ff7f: 51 push %ecx
10ff80: 50 push %eax
10ff81: 52 push %edx
10ff82: e8 17 fe ff ff call 10fd9e <IMFS_memfile_extend>
if ( status )
10ff87: 83 c4 10 add $0x10,%esp
10ff8a: 85 c0 test %eax,%eax
10ff8c: 74 17 je 10ffa5 <IMFS_memfile_write+0xa1><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOSPC );
10ff8e: e8 4d 10 00 00 call 110fe0 <__errno> <== NOT EXECUTED
10ff93: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED
10ff99: c7 45 dc ff ff ff ff movl $0xffffffff,-0x24(%ebp) <== NOT EXECUTED
10ffa0: e9 24 01 00 00 jmp 1100c9 <IMFS_memfile_write+0x1c5><== NOT EXECUTED
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
10ffa5: 8b 1d ac 11 12 00 mov 0x1211ac,%ebx
10ffab: 8b 45 0c mov 0xc(%ebp),%eax
10ffae: 99 cltd
10ffaf: f7 fb idiv %ebx
10ffb1: 89 d7 mov %edx,%edi
10ffb3: 89 45 c4 mov %eax,-0x3c(%ebp)
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
10ffb6: 89 45 d8 mov %eax,-0x28(%ebp)
if ( start_offset ) {
10ffb9: 85 d2 test %edx,%edx
10ffbb: 75 12 jne 10ffcf <IMFS_memfile_write+0xcb>
10ffbd: 8b 5d 14 mov 0x14(%ebp),%ebx
10ffc0: 8b 4d 10 mov 0x10(%ebp),%ecx
10ffc3: 89 4d e0 mov %ecx,-0x20(%ebp)
10ffc6: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
10ffcd: eb 50 jmp 11001f <IMFS_memfile_write+0x11b>
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 );
10ffcf: 50 push %eax
10ffd0: 6a 00 push $0x0
10ffd2: ff 75 c4 pushl -0x3c(%ebp)
10ffd5: ff 75 08 pushl 0x8(%ebp)
10ffd8: e8 31 f9 ff ff call 10f90e <IMFS_memfile_get_block_pointer>
assert( block_ptr );
10ffdd: 83 c4 10 add $0x10,%esp
10ffe0: 85 c0 test %eax,%eax
10ffe2: 75 14 jne 10fff8 <IMFS_memfile_write+0xf4><== ALWAYS TAKEN
10ffe4: 68 49 b6 11 00 push $0x11b649 <== NOT EXECUTED
10ffe9: 68 ec b6 11 00 push $0x11b6ec <== NOT EXECUTED
10ffee: 68 1a 03 00 00 push $0x31a <== NOT EXECUTED
10fff3: e9 44 ff ff ff jmp 10ff3c <IMFS_memfile_write+0x38><== NOT EXECUTED
*/
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;
10fff8: 89 da mov %ebx,%edx
10fffa: 29 fa sub %edi,%edx
10fffc: 3b 55 14 cmp 0x14(%ebp),%edx
10ffff: 76 03 jbe 110004 <IMFS_memfile_write+0x100><== NEVER TAKEN
110001: 8b 55 14 mov 0x14(%ebp),%edx
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d at %d in %d: %*s\n", to_copy, start_offset, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
110004: 03 38 add (%eax),%edi
src += to_copy;
110006: 8b 75 10 mov 0x10(%ebp),%esi
110009: 89 d1 mov %edx,%ecx
11000b: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
11000d: 89 75 e0 mov %esi,-0x20(%ebp)
block++;
110010: 8b 45 c4 mov -0x3c(%ebp),%eax
110013: 40 inc %eax
110014: 89 45 d8 mov %eax,-0x28(%ebp)
my_length -= to_copy;
110017: 8b 5d 14 mov 0x14(%ebp),%ebx
11001a: 29 d3 sub %edx,%ebx
copied += to_copy;
11001c: 89 55 dc mov %edx,-0x24(%ebp)
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
11001f: 8b 15 ac 11 12 00 mov 0x1211ac,%edx
110025: 89 55 c4 mov %edx,-0x3c(%ebp)
110028: eb 42 jmp 11006c <IMFS_memfile_write+0x168>
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
11002a: 57 push %edi
11002b: 6a 00 push $0x0
11002d: ff 75 d8 pushl -0x28(%ebp)
110030: ff 75 08 pushl 0x8(%ebp)
110033: e8 d6 f8 ff ff call 10f90e <IMFS_memfile_get_block_pointer>
assert( block_ptr );
110038: 83 c4 10 add $0x10,%esp
11003b: 85 c0 test %eax,%eax
11003d: 75 14 jne 110053 <IMFS_memfile_write+0x14f><== ALWAYS TAKEN
11003f: 68 49 b6 11 00 push $0x11b649 <== NOT EXECUTED
110044: 68 ec b6 11 00 push $0x11b6ec <== NOT EXECUTED
110049: 68 2e 03 00 00 push $0x32e <== NOT EXECUTED
11004e: e9 e9 fe ff ff jmp 10ff3c <IMFS_memfile_write+0x38><== NOT EXECUTED
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 );
110053: 8b 38 mov (%eax),%edi
src += to_copy;
110055: 8b 75 e0 mov -0x20(%ebp),%esi
110058: 8b 4d c4 mov -0x3c(%ebp),%ecx
11005b: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
11005d: 89 75 e0 mov %esi,-0x20(%ebp)
block++;
110060: ff 45 d8 incl -0x28(%ebp)
my_length -= to_copy;
110063: 2b 5d c4 sub -0x3c(%ebp),%ebx
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
110066: 8b 45 c4 mov -0x3c(%ebp),%eax
110069: 01 45 dc add %eax,-0x24(%ebp)
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
11006c: 3b 1d ac 11 12 00 cmp 0x1211ac,%ebx
110072: 73 b6 jae 11002a <IMFS_memfile_write+0x126>
*/
assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
110074: 85 db test %ebx,%ebx
110076: 74 35 je 1100ad <IMFS_memfile_write+0x1a9>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
110078: 56 push %esi
110079: 6a 00 push $0x0
11007b: ff 75 d8 pushl -0x28(%ebp)
11007e: ff 75 08 pushl 0x8(%ebp)
110081: e8 88 f8 ff ff call 10f90e <IMFS_memfile_get_block_pointer>
assert( block_ptr );
110086: 83 c4 10 add $0x10,%esp
110089: 85 c0 test %eax,%eax
11008b: 75 14 jne 1100a1 <IMFS_memfile_write+0x19d><== ALWAYS TAKEN
11008d: 68 49 b6 11 00 push $0x11b649 <== NOT EXECUTED
110092: 68 ec b6 11 00 push $0x11b6ec <== NOT EXECUTED
110097: 68 44 03 00 00 push $0x344 <== NOT EXECUTED
11009c: e9 9b fe ff ff jmp 10ff3c <IMFS_memfile_write+0x38><== NOT EXECUTED
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, my_length );
1100a1: 8b 38 mov (%eax),%edi
1100a3: 8b 75 e0 mov -0x20(%ebp),%esi
1100a6: 89 d9 mov %ebx,%ecx
1100a8: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
my_length = 0;
copied += to_copy;
1100aa: 01 5d dc add %ebx,-0x24(%ebp)
}
IMFS_atime_mtime_update( the_jnode );
1100ad: 53 push %ebx
1100ae: 53 push %ebx
1100af: 6a 00 push $0x0
1100b1: 8d 45 ec lea -0x14(%ebp),%eax
1100b4: 50 push %eax
1100b5: e8 ae 73 ff ff call 107468 <gettimeofday>
1100ba: 8b 45 ec mov -0x14(%ebp),%eax
1100bd: 8b 55 08 mov 0x8(%ebp),%edx
1100c0: 89 42 44 mov %eax,0x44(%edx)
1100c3: 89 42 40 mov %eax,0x40(%edx)
1100c6: 83 c4 10 add $0x10,%esp
return copied;
}
1100c9: 8b 45 dc mov -0x24(%ebp),%eax
1100cc: 8d 65 f4 lea -0xc(%ebp),%esp
1100cf: 5b pop %ebx
1100d0: 5e pop %esi
1100d1: 5f pop %edi
1100d2: c9 leave
1100d3: c3 ret
0010ca04 <IMFS_mknod>:
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
10ca04: 55 push %ebp
10ca05: 89 e5 mov %esp,%ebp
10ca07: 57 push %edi
10ca08: 56 push %esi
10ca09: 53 push %ebx
10ca0a: 83 ec 50 sub $0x50,%esp
10ca0d: 8b 7d 0c mov 0xc(%ebp),%edi
10ca10: 8b 5d 10 mov 0x10(%ebp),%ebx
10ca13: 8b 75 14 mov 0x14(%ebp),%esi
IMFS_jnode_t *new_node;
int result;
char new_name[ IMFS_NAME_MAX + 1 ];
IMFS_types_union info;
IMFS_get_token( token, new_name, &result );
10ca16: 8d 45 f0 lea -0x10(%ebp),%eax
10ca19: 50 push %eax
10ca1a: 8d 45 bf lea -0x41(%ebp),%eax
10ca1d: 50 push %eax
10ca1e: ff 75 08 pushl 0x8(%ebp)
10ca21: e8 7a fe ff ff call 10c8a0 <IMFS_get_token>
/*
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
10ca26: 89 f8 mov %edi,%eax
10ca28: 25 00 f0 00 00 and $0xf000,%eax
10ca2d: 83 c4 10 add $0x10,%esp
10ca30: 3d 00 40 00 00 cmp $0x4000,%eax
10ca35: 74 34 je 10ca6b <IMFS_mknod+0x67>
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
10ca37: ba 05 00 00 00 mov $0x5,%edx
10ca3c: 3d 00 80 00 00 cmp $0x8000,%eax
10ca41: 74 2d je 10ca70 <IMFS_mknod+0x6c>
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
10ca43: 3d 00 60 00 00 cmp $0x6000,%eax
10ca48: 74 07 je 10ca51 <IMFS_mknod+0x4d> <== NEVER TAKEN
10ca4a: 3d 00 20 00 00 cmp $0x2000,%eax
10ca4f: 75 0d jne 10ca5e <IMFS_mknod+0x5a> <== NEVER TAKEN
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
10ca51: 89 5d e0 mov %ebx,-0x20(%ebp)
10ca54: 89 75 e4 mov %esi,-0x1c(%ebp)
10ca57: ba 02 00 00 00 mov $0x2,%edx
10ca5c: eb 12 jmp 10ca70 <IMFS_mknod+0x6c>
} else {
rtems_set_errno_and_return_minus_one( EINVAL );
10ca5e: e8 c5 26 00 00 call 10f128 <__errno> <== NOT EXECUTED
10ca63: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
10ca69: eb 2e jmp 10ca99 <IMFS_mknod+0x95> <== NOT EXECUTED
10ca6b: ba 01 00 00 00 mov $0x1,%edx
/*
* Allocate and fill in an IMFS jnode
*/
new_node = IMFS_create_node(
10ca70: 83 ec 0c sub $0xc,%esp
10ca73: 8d 45 e0 lea -0x20(%ebp),%eax
10ca76: 50 push %eax
10ca77: 57 push %edi
10ca78: 8d 45 bf lea -0x41(%ebp),%eax
10ca7b: 50 push %eax
10ca7c: 52 push %edx
10ca7d: ff 75 18 pushl 0x18(%ebp)
10ca80: e8 eb 1c 00 00 call 10e770 <IMFS_create_node>
new_name,
mode,
&info
);
if ( !new_node )
10ca85: 83 c4 20 add $0x20,%esp
10ca88: 31 d2 xor %edx,%edx
10ca8a: 85 c0 test %eax,%eax
10ca8c: 75 0e jne 10ca9c <IMFS_mknod+0x98> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOMEM );
10ca8e: e8 95 26 00 00 call 10f128 <__errno> <== NOT EXECUTED
10ca93: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
10ca99: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED
return 0;
}
10ca9c: 89 d0 mov %edx,%eax
10ca9e: 8d 65 f4 lea -0xc(%ebp),%esp
10caa1: 5b pop %ebx
10caa2: 5e pop %esi
10caa3: 5f pop %edi
10caa4: c9 leave
10caa5: c3 ret
00106aa8 <IMFS_mount>:
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
106aa8: 55 push %ebp
106aa9: 89 e5 mov %esp,%ebp
106aab: 83 ec 08 sub $0x8,%esp
106aae: 8b 55 08 mov 0x8(%ebp),%edx
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
106ab1: 8b 42 08 mov 0x8(%edx),%eax
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
106ab4: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
106ab8: 74 10 je 106aca <IMFS_mount+0x22> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
106aba: e8 21 a5 00 00 call 110fe0 <__errno> <== NOT EXECUTED
106abf: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
106ac5: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106ac8: eb 05 jmp 106acf <IMFS_mount+0x27> <== NOT EXECUTED
/*
* Set mt_fs pointer to point to the mount table entry for
* the mounted file system.
*/
node->info.directory.mt_fs = mt_entry;
106aca: 89 50 5c mov %edx,0x5c(%eax)
106acd: 31 c0 xor %eax,%eax
return 0;
}
106acf: c9 leave
106ad0: c3 ret
00107836 <IMFS_print_jnode>:
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
107836: 55 push %ebp
107837: 89 e5 mov %esp,%ebp
107839: 53 push %ebx
10783a: 83 ec 04 sub $0x4,%esp
10783d: 8b 5d 08 mov 0x8(%ebp),%ebx
assert( the_jnode );
107840: 85 db test %ebx,%ebx
107842: 75 11 jne 107855 <IMFS_print_jnode+0x1f> <== ALWAYS TAKEN
107844: 68 82 cb 11 00 push $0x11cb82 <== NOT EXECUTED
107849: 68 28 cd 11 00 push $0x11cd28 <== NOT EXECUTED
10784e: 6a 38 push $0x38 <== NOT EXECUTED
107850: e9 98 00 00 00 jmp 1078ed <IMFS_print_jnode+0xb7> <== NOT EXECUTED
fprintf(stdout, "%s", the_jnode->name );
107855: 50 push %eax
107856: 50 push %eax
107857: a1 80 14 12 00 mov 0x121480,%eax
10785c: ff 70 08 pushl 0x8(%eax)
10785f: 8d 43 0c lea 0xc(%ebx),%eax
107862: 50 push %eax
107863: e8 ec b3 00 00 call 112c54 <fputs>
switch( the_jnode->type ) {
107868: 8b 43 4c mov 0x4c(%ebx),%eax
10786b: 83 c4 10 add $0x10,%esp
10786e: 8d 50 ff lea -0x1(%eax),%edx
107871: 83 fa 05 cmp $0x5,%edx
107874: 0f 87 9a 00 00 00 ja 107914 <IMFS_print_jnode+0xde> <== NEVER TAKEN
10787a: a1 80 14 12 00 mov 0x121480,%eax
10787f: ff 24 95 fc cc 11 00 jmp *0x11ccfc(,%edx,4)
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
107886: 51 push %ecx
107887: 51 push %ecx
107888: ff 70 08 pushl 0x8(%eax)
10788b: 6a 2f push $0x2f
10788d: e8 f2 b2 00 00 call 112b84 <fputc>
107892: eb 2b jmp 1078bf <IMFS_print_jnode+0x89>
break;
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
107894: ff 73 54 pushl 0x54(%ebx)
107897: ff 73 50 pushl 0x50(%ebx)
10789a: 68 db cb 11 00 push $0x11cbdb
10789f: eb 16 jmp 1078b7 <IMFS_print_jnode+0x81>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
1078a1: ff 73 54 pushl 0x54(%ebx) <== NOT EXECUTED
1078a4: ff 73 50 pushl 0x50(%ebx) <== NOT EXECUTED
1078a7: 68 ee cb 11 00 push $0x11cbee <== NOT EXECUTED
1078ac: eb 09 jmp 1078b7 <IMFS_print_jnode+0x81> <== NOT EXECUTED
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
1078ae: 52 push %edx
1078af: ff 73 50 pushl 0x50(%ebx)
1078b2: 68 fd cb 11 00 push $0x11cbfd
1078b7: ff 70 08 pushl 0x8(%eax)
1078ba: e8 89 b2 00 00 call 112b48 <fprintf>
1078bf: 83 c4 10 add $0x10,%esp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
assert(0);
break;
}
puts("");
1078c2: c7 45 08 99 ce 11 00 movl $0x11ce99,0x8(%ebp)
}
1078c9: 8b 5d fc mov -0x4(%ebp),%ebx
1078cc: c9 leave
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
assert(0);
break;
}
puts("");
1078cd: e9 5e c9 00 00 jmp 114230 <puts>
(uint32_t)the_jnode->info.file.size );
#endif
break;
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
1078d2: 53 push %ebx <== NOT EXECUTED
1078d3: 53 push %ebx <== NOT EXECUTED
1078d4: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
1078d7: 68 09 cc 11 00 push $0x11cc09 <== NOT EXECUTED
1078dc: e8 73 b3 00 00 call 112c54 <fputs> <== NOT EXECUTED
assert(0);
1078e1: 68 6f c5 11 00 push $0x11c56f <== NOT EXECUTED
1078e6: 68 28 cd 11 00 push $0x11cd28 <== NOT EXECUTED
1078eb: 6a 5d push $0x5d <== NOT EXECUTED
1078ed: 68 8c cb 11 00 push $0x11cb8c <== NOT EXECUTED
1078f2: e8 55 06 00 00 call 107f4c <__assert_func> <== NOT EXECUTED
break;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
1078f7: 51 push %ecx <== NOT EXECUTED
1078f8: 51 push %ecx <== NOT EXECUTED
1078f9: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
1078fc: 68 09 cc 11 00 push $0x11cc09 <== NOT EXECUTED
107901: e8 4e b3 00 00 call 112c54 <fputs> <== NOT EXECUTED
assert(0);
107906: 68 6f c5 11 00 push $0x11c56f <== NOT EXECUTED
10790b: 68 28 cd 11 00 push $0x11cd28 <== NOT EXECUTED
107910: 6a 62 push $0x62 <== NOT EXECUTED
107912: eb d9 jmp 1078ed <IMFS_print_jnode+0xb7> <== NOT EXECUTED
break;
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
107914: 52 push %edx <== NOT EXECUTED
107915: 50 push %eax <== NOT EXECUTED
107916: 68 1d cc 11 00 push $0x11cc1d <== NOT EXECUTED
10791b: a1 80 14 12 00 mov 0x121480,%eax <== NOT EXECUTED
107920: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
107923: e8 20 b2 00 00 call 112b48 <fprintf> <== NOT EXECUTED
assert(0);
107928: 68 6f c5 11 00 push $0x11c56f <== NOT EXECUTED
10792d: 68 28 cd 11 00 push $0x11cd28 <== NOT EXECUTED
107932: 6a 67 push $0x67 <== NOT EXECUTED
107934: eb b7 jmp 1078ed <IMFS_print_jnode+0xb7> <== NOT EXECUTED
00106ae4 <IMFS_readlink>:
int IMFS_readlink(
rtems_filesystem_location_info_t *loc,
char *buf, /* OUT */
size_t bufsize
)
{
106ae4: 55 push %ebp
106ae5: 89 e5 mov %esp,%ebp
106ae7: 53 push %ebx
106ae8: 83 ec 04 sub $0x4,%esp
106aeb: 8b 5d 0c mov 0xc(%ebp),%ebx
IMFS_jnode_t *node;
int i;
node = loc->node_access;
106aee: 8b 45 08 mov 0x8(%ebp),%eax
106af1: 8b 08 mov (%eax),%ecx
if ( node->type != IMFS_SYM_LINK )
106af3: 31 d2 xor %edx,%edx
106af5: 83 79 4c 04 cmpl $0x4,0x4c(%ecx)
106af9: 74 14 je 106b0f <IMFS_readlink+0x2b> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
106afb: e8 e0 a4 00 00 call 110fe0 <__errno> <== NOT EXECUTED
106b00: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
106b06: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED
106b09: eb 13 jmp 106b1e <IMFS_readlink+0x3a> <== NOT EXECUTED
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
buf[i] = node->info.sym_link.name[i];
106b0b: 88 04 13 mov %al,(%ebx,%edx,1)
node = loc->node_access;
if ( node->type != IMFS_SYM_LINK )
rtems_set_errno_and_return_minus_one( EINVAL );
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
106b0e: 42 inc %edx
106b0f: 3b 55 10 cmp 0x10(%ebp),%edx
106b12: 73 0a jae 106b1e <IMFS_readlink+0x3a>
106b14: 8b 41 50 mov 0x50(%ecx),%eax
106b17: 8a 04 10 mov (%eax,%edx,1),%al
106b1a: 84 c0 test %al,%al
106b1c: 75 ed jne 106b0b <IMFS_readlink+0x27>
buf[i] = node->info.sym_link.name[i];
return i;
}
106b1e: 89 d0 mov %edx,%eax
106b20: 5a pop %edx
106b21: 5b pop %ebx
106b22: c9 leave
106b23: c3 ret
0010cab8 <IMFS_rmnod>:
*/
int IMFS_rmnod(
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
10cab8: 55 push %ebp
10cab9: 89 e5 mov %esp,%ebp
10cabb: 56 push %esi
10cabc: 53 push %ebx
10cabd: 83 ec 10 sub $0x10,%esp
10cac0: 8b 75 08 mov 0x8(%ebp),%esi
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
10cac3: 8b 1e mov (%esi),%ebx
/*
* Take the node out of the parent's chain that contains this node
*/
if ( the_jnode->Parent != NULL ) {
10cac5: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10cac9: 74 13 je 10cade <IMFS_rmnod+0x26> <== NEVER TAKEN
10cacb: 83 ec 0c sub $0xc,%esp
10cace: 53 push %ebx
10cacf: e8 70 12 00 00 call 10dd44 <_Chain_Extract>
rtems_chain_extract( (rtems_chain_node *) the_jnode );
the_jnode->Parent = NULL;
10cad4: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
10cadb: 83 c4 10 add $0x10,%esp
/*
* Decrement the link counter and see if we can free the space.
*/
the_jnode->st_nlink--;
10cade: 66 ff 4b 34 decw 0x34(%ebx)
IMFS_update_ctime( the_jnode );
10cae2: 50 push %eax
10cae3: 50 push %eax
10cae4: 6a 00 push $0x0
10cae6: 8d 45 f0 lea -0x10(%ebp),%eax
10cae9: 50 push %eax
10caea: e8 65 03 00 00 call 10ce54 <gettimeofday>
10caef: 8b 45 f0 mov -0x10(%ebp),%eax
10caf2: 89 43 48 mov %eax,0x48(%ebx)
/*
* The file cannot be open and the link must be less than 1 to free.
*/
if ( !rtems_libio_is_file_open( the_jnode ) && (the_jnode->st_nlink < 1) ) {
10caf5: 89 1c 24 mov %ebx,(%esp)
10caf8: e8 07 04 00 00 call 10cf04 <rtems_libio_is_file_open>
10cafd: 83 c4 10 add $0x10,%esp
10cb00: 85 c0 test %eax,%eax
10cb02: 75 40 jne 10cb44 <IMFS_rmnod+0x8c> <== NEVER TAKEN
10cb04: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx)
10cb09: 75 39 jne 10cb44 <IMFS_rmnod+0x8c> <== NEVER TAKEN
/*
* Is rtems_filesystem_current this node?
*/
if ( rtems_filesystem_current.node_access == pathloc->node_access )
10cb0b: 8b 15 6c b6 11 00 mov 0x11b66c,%edx
10cb11: 8b 42 04 mov 0x4(%edx),%eax
10cb14: 3b 06 cmp (%esi),%eax
10cb16: 75 07 jne 10cb1f <IMFS_rmnod+0x67> <== ALWAYS TAKEN
rtems_filesystem_current.node_access = NULL;
10cb18: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED
/*
* Free memory associated with a memory file.
*/
if ( the_jnode->type == IMFS_SYM_LINK ) {
10cb1f: 83 7b 4c 04 cmpl $0x4,0x4c(%ebx)
10cb23: 75 13 jne 10cb38 <IMFS_rmnod+0x80>
if ( the_jnode->info.sym_link.name )
10cb25: 8b 43 50 mov 0x50(%ebx),%eax
10cb28: 85 c0 test %eax,%eax
10cb2a: 74 0c je 10cb38 <IMFS_rmnod+0x80> <== NEVER TAKEN
free( (void*) the_jnode->info.sym_link.name );
10cb2c: 83 ec 0c sub $0xc,%esp
10cb2f: 50 push %eax
10cb30: e8 43 99 ff ff call 106478 <free>
10cb35: 83 c4 10 add $0x10,%esp
}
free( the_jnode );
10cb38: 83 ec 0c sub $0xc,%esp
10cb3b: 53 push %ebx
10cb3c: e8 37 99 ff ff call 106478 <free>
10cb41: 83 c4 10 add $0x10,%esp
}
return 0;
}
10cb44: 31 c0 xor %eax,%eax
10cb46: 8d 65 f8 lea -0x8(%ebp),%esp
10cb49: 5b pop %ebx
10cb4a: 5e pop %esi
10cb4b: c9 leave
10cb4c: c3 ret
0010cb50 <IMFS_stat>:
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
10cb50: 55 push %ebp
10cb51: 89 e5 mov %esp,%ebp
10cb53: 53 push %ebx
10cb54: 83 ec 04 sub $0x4,%esp
10cb57: 8b 5d 0c mov 0xc(%ebp),%ebx
IMFS_jnode_t *the_jnode;
IMFS_device_t *io;
the_jnode = loc->node_access;
10cb5a: 8b 45 08 mov 0x8(%ebp),%eax
10cb5d: 8b 08 mov (%eax),%ecx
switch ( the_jnode->type ) {
10cb5f: 8b 41 4c mov 0x4c(%ecx),%eax
10cb62: 83 f8 04 cmp $0x4,%eax
10cb65: 74 25 je 10cb8c <IMFS_stat+0x3c> <== NEVER TAKEN
10cb67: 7f 07 jg 10cb70 <IMFS_stat+0x20>
10cb69: 83 f8 02 cmp $0x2,%eax
10cb6c: 75 27 jne 10cb95 <IMFS_stat+0x45> <== NEVER TAKEN
10cb6e: eb 07 jmp 10cb77 <IMFS_stat+0x27>
10cb70: 83 f8 06 cmp $0x6,%eax
10cb73: 7f 20 jg 10cb95 <IMFS_stat+0x45> <== NEVER TAKEN
10cb75: eb 0d jmp 10cb84 <IMFS_stat+0x34>
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_dev = rtems_filesystem_make_dev_t( io->major, io->minor );
10cb77: 8b 51 54 mov 0x54(%ecx),%edx
10cb7a: 8b 41 50 mov 0x50(%ecx),%eax
10cb7d: 89 03 mov %eax,(%ebx)
10cb7f: 89 53 04 mov %edx,0x4(%ebx)
10cb82: eb 21 jmp 10cba5 <IMFS_stat+0x55>
break;
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
10cb84: 8b 41 50 mov 0x50(%ecx),%eax
10cb87: 89 43 20 mov %eax,0x20(%ebx)
10cb8a: eb 19 jmp 10cba5 <IMFS_stat+0x55>
break;
case IMFS_SYM_LINK:
buf->st_size = 0;
10cb8c: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED
10cb93: eb 10 jmp 10cba5 <IMFS_stat+0x55> <== NOT EXECUTED
break;
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
10cb95: e8 8e 25 00 00 call 10f128 <__errno> <== NOT EXECUTED
10cb9a: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10cba0: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10cba3: eb 3e jmp 10cbe3 <IMFS_stat+0x93> <== NOT EXECUTED
break;
}
buf->st_mode = the_jnode->st_mode;
10cba5: 8b 41 30 mov 0x30(%ecx),%eax
10cba8: 89 43 0c mov %eax,0xc(%ebx)
buf->st_nlink = the_jnode->st_nlink;
10cbab: 8b 41 34 mov 0x34(%ecx),%eax
10cbae: 66 89 43 10 mov %ax,0x10(%ebx)
buf->st_ino = the_jnode->st_ino;
10cbb2: 8b 41 38 mov 0x38(%ecx),%eax
10cbb5: 89 43 08 mov %eax,0x8(%ebx)
buf->st_uid = the_jnode->st_uid;
10cbb8: 8b 41 3c mov 0x3c(%ecx),%eax
10cbbb: 66 89 43 12 mov %ax,0x12(%ebx)
buf->st_gid = the_jnode->st_gid;
10cbbf: 66 8b 41 3e mov 0x3e(%ecx),%ax
10cbc3: 66 89 43 14 mov %ax,0x14(%ebx)
buf->st_atime = the_jnode->stat_atime;
10cbc7: 8b 41 40 mov 0x40(%ecx),%eax
10cbca: 89 43 24 mov %eax,0x24(%ebx)
buf->st_mtime = the_jnode->stat_mtime;
10cbcd: 8b 41 44 mov 0x44(%ecx),%eax
10cbd0: 89 43 2c mov %eax,0x2c(%ebx)
buf->st_ctime = the_jnode->stat_ctime;
10cbd3: 8b 41 48 mov 0x48(%ecx),%eax
10cbd6: 89 43 34 mov %eax,0x34(%ebx)
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
10cbd9: a1 dc 92 11 00 mov 0x1192dc,%eax
10cbde: 89 43 3c mov %eax,0x3c(%ebx)
10cbe1: 31 c0 xor %eax,%eax
return 0;
}
10cbe3: 5a pop %edx
10cbe4: 5b pop %ebx
10cbe5: c9 leave
10cbe6: c3 ret
00106b24 <IMFS_symlink>:
int IMFS_symlink(
rtems_filesystem_location_info_t *parent_loc,
const char *link_name,
const char *node_name
)
{
106b24: 55 push %ebp
106b25: 89 e5 mov %esp,%ebp
106b27: 53 push %ebx
106b28: 83 ec 48 sub $0x48,%esp
/*
* Remove any separators at the end of the string.
*/
IMFS_get_token( node_name, new_name, &i );
106b2b: 8d 45 f8 lea -0x8(%ebp),%eax
106b2e: 50 push %eax
106b2f: 8d 5d c7 lea -0x39(%ebp),%ebx
106b32: 53 push %ebx
106b33: ff 75 10 pushl 0x10(%ebp)
106b36: e8 69 74 00 00 call 10dfa4 <IMFS_get_token>
/*
* Duplicate link name
*/
info.sym_link.name = strdup( link_name);
106b3b: 58 pop %eax
106b3c: ff 75 0c pushl 0xc(%ebp)
106b3f: e8 fc bf 00 00 call 112b40 <strdup>
106b44: 89 45 e8 mov %eax,-0x18(%ebp)
if (info.sym_link.name == NULL) {
106b47: 83 c4 10 add $0x10,%esp
106b4a: 85 c0 test %eax,%eax
106b4c: 75 10 jne 106b5e <IMFS_symlink+0x3a> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOMEM);
106b4e: e8 8d a4 00 00 call 110fe0 <__errno> <== NOT EXECUTED
106b53: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
106b59: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED
106b5c: eb 3c jmp 106b9a <IMFS_symlink+0x76> <== NOT EXECUTED
/*
* Create a new link node.
*/
new_node = IMFS_create_node(
106b5e: 83 ec 0c sub $0xc,%esp
106b61: 8d 45 e8 lea -0x18(%ebp),%eax
106b64: 50 push %eax
106b65: 68 ff a1 00 00 push $0xa1ff
106b6a: 53 push %ebx
106b6b: 6a 04 push $0x4
106b6d: ff 75 08 pushl 0x8(%ebp)
106b70: e8 ff 6b 00 00 call 10d774 <IMFS_create_node>
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if (new_node == NULL) {
106b75: 83 c4 20 add $0x20,%esp
106b78: 31 d2 xor %edx,%edx
106b7a: 85 c0 test %eax,%eax
106b7c: 75 1c jne 106b9a <IMFS_symlink+0x76> <== ALWAYS TAKEN
free( info.sym_link.name);
106b7e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106b81: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED
106b84: e8 6f 07 00 00 call 1072f8 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM);
106b89: e8 52 a4 00 00 call 110fe0 <__errno> <== NOT EXECUTED
106b8e: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
106b94: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED
106b97: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
return 0;
}
106b9a: 89 d0 mov %edx,%eax
106b9c: 8b 5d fc mov -0x4(%ebp),%ebx
106b9f: c9 leave
106ba0: c3 ret
00106ba4 <IMFS_unlink>:
#include <rtems/seterr.h>
int IMFS_unlink(
rtems_filesystem_location_info_t *loc /* IN */
)
{
106ba4: 55 push %ebp
106ba5: 89 e5 mov %esp,%ebp
106ba7: 57 push %edi
106ba8: 56 push %esi
106ba9: 53 push %ebx
106baa: 83 ec 2c sub $0x2c,%esp
IMFS_jnode_t *node;
rtems_filesystem_location_info_t the_link;
int result = 0;
node = loc->node_access;
106bad: 8b 45 08 mov 0x8(%ebp),%eax
106bb0: 8b 18 mov (%eax),%ebx
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
106bb2: 83 7b 4c 03 cmpl $0x3,0x4c(%ebx)
106bb6: 75 76 jne 106c2e <IMFS_unlink+0x8a>
if ( !node->info.hard_link.link_node )
106bb8: 8b 43 50 mov 0x50(%ebx),%eax
106bbb: 85 c0 test %eax,%eax
106bbd: 75 10 jne 106bcf <IMFS_unlink+0x2b> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
106bbf: e8 1c a4 00 00 call 110fe0 <__errno> <== NOT EXECUTED
106bc4: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
106bca: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED
106bcd: eb 71 jmp 106c40 <IMFS_unlink+0x9c> <== NOT EXECUTED
the_link = *loc;
106bcf: 8d 7d dc lea -0x24(%ebp),%edi
106bd2: b9 04 00 00 00 mov $0x4,%ecx
106bd7: 8b 75 08 mov 0x8(%ebp),%esi
106bda: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_link.node_access = node->info.hard_link.link_node;
106bdc: 89 45 dc mov %eax,-0x24(%ebp)
IMFS_Set_handlers( &the_link );
106bdf: 83 ec 0c sub $0xc,%esp
106be2: 8d 7d dc lea -0x24(%ebp),%edi
106be5: 57 push %edi
106be6: e8 c5 6c 00 00 call 10d8b0 <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)
106beb: 8b 53 50 mov 0x50(%ebx),%edx
106bee: 8b 42 34 mov 0x34(%edx),%eax
106bf1: 83 c4 10 add $0x10,%esp
106bf4: 66 83 f8 01 cmp $0x1,%ax
106bf8: 75 16 jne 106c10 <IMFS_unlink+0x6c>
{
result = (*the_link.handlers->rmnod_h)( &the_link );
106bfa: 83 ec 0c sub $0xc,%esp
106bfd: 57 push %edi
106bfe: 8b 45 e0 mov -0x20(%ebp),%eax
106c01: ff 50 34 call *0x34(%eax)
if ( result != 0 )
106c04: 83 c4 10 add $0x10,%esp
106c07: 83 ca ff or $0xffffffff,%edx
106c0a: 85 c0 test %eax,%eax
106c0c: 74 20 je 106c2e <IMFS_unlink+0x8a>
106c0e: eb 30 jmp 106c40 <IMFS_unlink+0x9c>
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
106c10: 48 dec %eax
106c11: 66 89 42 34 mov %ax,0x34(%edx)
IMFS_update_ctime( node->info.hard_link.link_node );
106c15: 50 push %eax
106c16: 50 push %eax
106c17: 6a 00 push $0x0
106c19: 8d 45 ec lea -0x14(%ebp),%eax
106c1c: 50 push %eax
106c1d: e8 46 08 00 00 call 107468 <gettimeofday>
106c22: 8b 53 50 mov 0x50(%ebx),%edx
106c25: 8b 45 ec mov -0x14(%ebp),%eax
106c28: 89 42 48 mov %eax,0x48(%edx)
106c2b: 83 c4 10 add $0x10,%esp
/*
* Now actually free the node we were asked to free.
*/
result = (*loc->handlers->rmnod_h)( loc );
106c2e: 83 ec 0c sub $0xc,%esp
106c31: 8b 55 08 mov 0x8(%ebp),%edx
106c34: 8b 42 04 mov 0x4(%edx),%eax
106c37: 52 push %edx
106c38: ff 50 34 call *0x34(%eax)
106c3b: 89 c2 mov %eax,%edx
106c3d: 83 c4 10 add $0x10,%esp
return result;
}
106c40: 89 d0 mov %edx,%eax
106c42: 8d 65 f4 lea -0xc(%ebp),%esp
106c45: 5b pop %ebx
106c46: 5e pop %esi
106c47: 5f pop %edi
106c48: c9 leave
106c49: c3 ret
00106c4c <IMFS_unmount>:
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
106c4c: 55 push %ebp
106c4d: 89 e5 mov %esp,%ebp
106c4f: 83 ec 08 sub $0x8,%esp
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
106c52: 8b 45 08 mov 0x8(%ebp),%eax
106c55: 8b 40 08 mov 0x8(%eax),%eax
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
106c58: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
106c5c: 74 0d je 106c6b <IMFS_unmount+0x1f> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
106c5e: e8 7d a3 00 00 call 110fe0 <__errno> <== NOT EXECUTED
106c63: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
106c69: eb 11 jmp 106c7c <IMFS_unmount+0x30> <== NOT EXECUTED
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
106c6b: 83 78 5c 00 cmpl $0x0,0x5c(%eax)
106c6f: 75 10 jne 106c81 <IMFS_unmount+0x35> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */
106c71: e8 6a a3 00 00 call 110fe0 <__errno> <== NOT EXECUTED
106c76: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
106c7c: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106c7f: eb 09 jmp 106c8a <IMFS_unmount+0x3e> <== NOT EXECUTED
/*
* 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;
106c81: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
106c88: 31 c0 xor %eax,%eax
return 0;
}
106c8a: c9 leave
106c8b: c3 ret
001065fc <RTEMS_Malloc_Initialize>:
void RTEMS_Malloc_Initialize(
void *start,
size_t length,
size_t sbrk_amount
)
{
1065fc: 55 push %ebp
1065fd: 89 e5 mov %esp,%ebp
1065ff: 57 push %edi
106600: 56 push %esi
106601: 53 push %ebx
106602: 83 ec 0c sub $0xc,%esp
106605: 8b 75 08 mov 0x8(%ebp),%esi
106608: 8b 5d 0c mov 0xc(%ebp),%ebx
#endif
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers )
10660b: a1 d4 bb 11 00 mov 0x11bbd4,%eax
106610: 85 c0 test %eax,%eax
106612: 74 02 je 106616 <RTEMS_Malloc_Initialize+0x1a><== ALWAYS TAKEN
(*rtems_malloc_statistics_helpers->initialize)();
106614: ff 10 call *(%eax) <== NOT EXECUTED
/*
* Initialize the garbage collection list to start with nothing on it.
*/
malloc_deferred_frees_initialize();
106616: e8 79 ff ff ff call 106594 <malloc_deferred_frees_initialize>
starting_address = start;
/*
* Initialize the optional sbrk support for extending the heap
*/
if (rtems_malloc_sbrk_helpers) {
10661b: a1 d8 bb 11 00 mov 0x11bbd8,%eax
106620: 89 f2 mov %esi,%edx
106622: 85 c0 test %eax,%eax
106624: 74 0d je 106633 <RTEMS_Malloc_Initialize+0x37><== ALWAYS TAKEN
starting_address = (*rtems_malloc_sbrk_helpers->initialize)(
106626: 52 push %edx <== NOT EXECUTED
106627: 52 push %edx <== NOT EXECUTED
106628: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED
10662b: 56 push %esi <== NOT EXECUTED
10662c: ff 10 call *(%eax) <== NOT EXECUTED
10662e: 89 c2 mov %eax,%edx <== NOT EXECUTED
106630: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
* 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 ( rtems_configuration_get_do_zero_of_workspace() )
106633: a1 30 d8 11 00 mov 0x11d830,%eax
106638: 80 78 28 00 cmpb $0x0,0x28(%eax)
10663c: 74 08 je 106646 <RTEMS_Malloc_Initialize+0x4a><== ALWAYS TAKEN
memset( starting_address, 0, length );
10663e: 31 c0 xor %eax,%eax
106640: 89 d7 mov %edx,%edi <== NOT EXECUTED
106642: 89 d9 mov %ebx,%ecx <== NOT EXECUTED
106644: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED
void *starting_address,
size_t size,
uint32_t page_size
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
106646: 6a 04 push $0x4
106648: 53 push %ebx
106649: 52 push %edx
10664a: 68 50 d6 11 00 push $0x11d650
10664f: e8 d8 39 00 00 call 10a02c <_Heap_Initialize>
&RTEMS_Malloc_Heap,
starting_address,
length,
CPU_HEAP_ALIGNMENT
);
if ( !status )
106654: 83 c4 10 add $0x10,%esp
106657: 85 c0 test %eax,%eax
106659: 75 0a jne 106665 <RTEMS_Malloc_Initialize+0x69><== ALWAYS TAKEN
rtems_fatal_error_occurred( status );
10665b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10665e: 6a 00 push $0x0 <== NOT EXECUTED
106660: e8 2f 31 00 00 call 109794 <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_print_buffer( (start + length) - 48, 48 );
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
}
#endif
MSBUMP(space_available, length);
106665: 01 1d a8 d6 11 00 add %ebx,0x11d6a8
}
10666b: 8d 65 f4 lea -0xc(%ebp),%esp
10666e: 5b pop %ebx
10666f: 5e pop %esi
106670: 5f pop %edi
106671: c9 leave
106672: c3 ret
0010674a <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
10674a: 55 push %ebp <== NOT EXECUTED
10674b: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10674d: 57 push %edi <== NOT EXECUTED
10674e: 56 push %esi <== NOT EXECUTED
10674f: 53 push %ebx <== NOT EXECUTED
106750: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED
106753: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
void *high_water_mark;
void *current;
Stack_Control *stack;
char name[5];
if ( !the_thread )
106756: 85 db test %ebx,%ebx <== NOT EXECUTED
106758: 0f 84 fc 00 00 00 je 10685a <Stack_check_Dump_threads_usage+0x110><== NOT EXECUTED
return;
if ( !print_handler )
10675e: a1 f4 0d 12 00 mov 0x120df4,%eax <== NOT EXECUTED
106763: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED
106766: 85 c0 test %eax,%eax <== NOT EXECUTED
106768: 0f 84 ec 00 00 00 je 10685a <Stack_check_Dump_threads_usage+0x110><== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
if (the_thread == (Thread_Control *) -1) {
10676e: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED
106771: 75 1d jne 106790 <Stack_check_Dump_threads_usage+0x46><== NOT EXECUTED
if (Stack_check_Interrupt_stack.area) {
106773: 83 3d 1c 10 12 00 00 cmpl $0x0,0x12101c <== NOT EXECUTED
10677a: 0f 84 da 00 00 00 je 10685a <Stack_check_Dump_threads_usage+0x110><== NOT EXECUTED
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
current = 0;
}
else
return;
106780: 31 db xor %ebx,%ebx <== NOT EXECUTED
106782: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
106789: be 18 10 12 00 mov $0x121018,%esi <== NOT EXECUTED
10678e: eb 0f jmp 10679f <Stack_check_Dump_threads_usage+0x55><== NOT EXECUTED
} else {
stack = &the_thread->Start.Initial_stack;
106790: 8d b3 c4 00 00 00 lea 0xc4(%ebx),%esi <== NOT EXECUTED
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
106796: 8b 83 d8 00 00 00 mov 0xd8(%ebx),%eax <== NOT EXECUTED
10679c: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED
}
low = Stack_check_usable_stack_start(stack);
10679f: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED
1067a2: 8d 78 10 lea 0x10(%eax),%edi <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
1067a5: 8b 06 mov (%esi),%eax <== NOT EXECUTED
1067a7: 83 e8 10 sub $0x10,%eax <== NOT EXECUTED
1067aa: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED
high_water_mark = Stack_check_find_high_water_mark(low, size);
1067ad: 50 push %eax <== NOT EXECUTED
1067ae: 57 push %edi <== NOT EXECUTED
1067af: e8 6b ff ff ff call 10671f <Stack_check_find_high_water_mark><== NOT EXECUTED
if ( high_water_mark )
1067b4: 5a pop %edx <== NOT EXECUTED
1067b5: 59 pop %ecx <== NOT EXECUTED
1067b6: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED
1067bd: 85 c0 test %eax,%eax <== NOT EXECUTED
1067bf: 74 09 je 1067ca <Stack_check_Dump_threads_usage+0x80><== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
1067c1: 03 7d d8 add -0x28(%ebp),%edi <== NOT EXECUTED
1067c4: 89 7d dc mov %edi,-0x24(%ebp) <== NOT EXECUTED
1067c7: 29 45 dc sub %eax,-0x24(%ebp) <== NOT EXECUTED
else
used = 0;
if ( the_thread ) {
1067ca: 85 db test %ebx,%ebx <== NOT EXECUTED
1067cc: 74 26 je 1067f4 <Stack_check_Dump_threads_usage+0xaa><== NOT EXECUTED
(*print_handler)(
1067ce: 50 push %eax <== NOT EXECUTED
1067cf: 8d 45 ef lea -0x11(%ebp),%eax <== NOT EXECUTED
1067d2: 50 push %eax <== NOT EXECUTED
1067d3: 6a 05 push $0x5 <== NOT EXECUTED
1067d5: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
1067d8: e8 1f 34 00 00 call 109bfc <rtems_object_get_name> <== NOT EXECUTED
1067dd: 50 push %eax <== NOT EXECUTED
1067de: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
1067e1: 68 d9 99 11 00 push $0x1199d9 <== NOT EXECUTED
1067e6: ff 35 f0 0d 12 00 pushl 0x120df0 <== NOT EXECUTED
1067ec: ff 55 d4 call *-0x2c(%ebp) <== NOT EXECUTED
1067ef: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
1067f2: eb 14 jmp 106808 <Stack_check_Dump_threads_usage+0xbe><== NOT EXECUTED
"0x%08" PRIx32 " %4s",
the_thread->Object.id,
rtems_object_get_name( the_thread->Object.id, sizeof(name), name )
);
} else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
1067f4: 57 push %edi <== NOT EXECUTED
1067f5: 6a ff push $0xffffffff <== NOT EXECUTED
1067f7: 68 e6 99 11 00 push $0x1199e6 <== NOT EXECUTED
1067fc: ff 35 f0 0d 12 00 pushl 0x120df0 <== NOT EXECUTED
106802: ff 55 d4 call *-0x2c(%ebp) <== NOT EXECUTED
106805: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
(*print_handler)(
106808: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED
10680b: 53 push %ebx <== NOT EXECUTED
10680c: 53 push %ebx <== NOT EXECUTED
10680d: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED
106810: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED
106813: 8b 16 mov (%esi),%edx <== NOT EXECUTED
106815: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED
106819: 52 push %edx <== NOT EXECUTED
10681a: 50 push %eax <== NOT EXECUTED
10681b: 68 f4 99 11 00 push $0x1199f4 <== NOT EXECUTED
106820: ff 35 f0 0d 12 00 pushl 0x120df0 <== NOT EXECUTED
106826: ff 15 f4 0d 12 00 call *0x120df4 <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
10682c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
10682f: 83 3d ec 0d 12 00 00 cmpl $0x0,0x120dec <== NOT EXECUTED
106836: a1 f4 0d 12 00 mov 0x120df4,%eax <== NOT EXECUTED
10683b: 75 09 jne 106846 <Stack_check_Dump_threads_usage+0xfc><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
10683d: 51 push %ecx <== NOT EXECUTED
10683e: 51 push %ecx <== NOT EXECUTED
10683f: 68 12 9a 11 00 push $0x119a12 <== NOT EXECUTED
106844: eb 09 jmp 10684f <Stack_check_Dump_threads_usage+0x105><== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
106846: 52 push %edx <== NOT EXECUTED
106847: ff 75 dc pushl -0x24(%ebp) <== NOT EXECUTED
10684a: 68 1f 9a 11 00 push $0x119a1f <== NOT EXECUTED
10684f: ff 35 f0 0d 12 00 pushl 0x120df0 <== NOT EXECUTED
106855: ff d0 call *%eax <== NOT EXECUTED
106857: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
10685a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10685d: 5b pop %ebx <== NOT EXECUTED
10685e: 5e pop %esi <== NOT EXECUTED
10685f: 5f pop %edi <== NOT EXECUTED
106860: c9 leave <== NOT EXECUTED
106861: c3 ret <== NOT EXECUTED
00106a13 <Stack_check_Initialize>:
/*
* Stack_check_Initialize
*/
void Stack_check_Initialize( void )
{
106a13: 55 push %ebp
106a14: 89 e5 mov %esp,%ebp
106a16: 57 push %edi
106a17: 83 ec 04 sub $0x4,%esp
uint32_t *p;
if (Stack_check_Initialized)
106a1a: 83 3d ec 0d 12 00 00 cmpl $0x0,0x120dec
106a21: 75 59 jne 106a7c <Stack_check_Initialize+0x69>
for ( p = Stack_check_Pattern.pattern;
p < &Stack_check_Pattern.pattern[PATTERN_SIZE_WORDS];
p += 4
) {
p[0] = 0xFEEDF00D; /* FEED FOOD to BAD DOG */
106a23: c7 05 08 10 12 00 0d movl $0xfeedf00d,0x121008
106a2a: f0 ed fe
p[1] = 0x0BAD0D06;
106a2d: c7 05 0c 10 12 00 06 movl $0xbad0d06,0x12100c
106a34: 0d ad 0b
p[2] = 0xDEADF00D; /* DEAD FOOD GOOD DOG */
106a37: c7 05 10 10 12 00 0d movl $0xdeadf00d,0x121010
106a3e: f0 ad de
p[3] = 0x600D0D06;
106a41: c7 05 14 10 12 00 06 movl $0x600d0d06,0x121014
106a48: 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) {
106a4b: 8b 3d 94 11 12 00 mov 0x121194,%edi
106a51: 85 ff test %edi,%edi
106a53: 74 1d je 106a72 <Stack_check_Initialize+0x5f><== NEVER TAKEN
106a55: a1 54 11 12 00 mov 0x121154,%eax
106a5a: 85 c0 test %eax,%eax
106a5c: 74 14 je 106a72 <Stack_check_Initialize+0x5f><== NEVER TAKEN
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
106a5e: 89 3d 1c 10 12 00 mov %edi,0x12101c
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
106a64: 89 c1 mov %eax,%ecx
106a66: 29 f9 sub %edi,%ecx
106a68: 89 0d 18 10 12 00 mov %ecx,0x121018
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
106a6e: b0 a5 mov $0xa5,%al
106a70: f3 aa rep stos %al,%es:(%edi)
}
#endif
Stack_check_Initialized = 1;
106a72: c7 05 ec 0d 12 00 01 movl $0x1,0x120dec
106a79: 00 00 00
}
106a7c: 58 pop %eax
106a7d: 5f pop %edi
106a7e: c9 leave
106a7f: c3 ret
0010671f <Stack_check_find_high_water_mark>:
*/
void *Stack_check_find_high_water_mark(
const void *s,
size_t n
)
{
10671f: 55 push %ebp <== NOT EXECUTED
106720: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106722: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
106725: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
106728: 83 c2 10 add $0x10,%edx <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
10672b: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED
10672e: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED
106731: eb 0f jmp 106742 <Stack_check_find_high_water_mark+0x23><== NOT EXECUTED
if (*base != U32_PATTERN)
106733: 81 3a a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%edx) <== NOT EXECUTED
106739: 74 04 je 10673f <Stack_check_find_high_water_mark+0x20><== NOT EXECUTED
return (void *) base;
10673b: 89 d0 mov %edx,%eax <== NOT EXECUTED
10673d: eb 09 jmp 106748 <Stack_check_find_high_water_mark+0x29><== 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++)
10673f: 83 c2 04 add $0x4,%edx <== NOT EXECUTED
106742: 39 c2 cmp %eax,%edx <== NOT EXECUTED
106744: 72 ed jb 106733 <Stack_check_find_high_water_mark+0x14><== NOT EXECUTED
106746: 31 c0 xor %eax,%eax <== NOT EXECUTED
if (*base != U32_PATTERN)
return (void *) base;
#endif
return (void *)0;
}
106748: c9 leave <== NOT EXECUTED
106749: c3 ret <== NOT EXECUTED
001068da <Stack_check_report_blown_task>:
*/
void Stack_check_report_blown_task(
Thread_Control *running,
bool pattern_ok
)
{
1068da: 55 push %ebp
1068db: 89 e5 mov %esp,%ebp
1068dd: 56 push %esi
1068de: 53 push %ebx
1068df: 8b 75 08 mov 0x8(%ebp),%esi
1068e2: 8a 5d 0c mov 0xc(%ebp),%bl
Stack_Control *stack = &running->Start.Initial_stack;
printk(
1068e5: ff 76 0c pushl 0xc(%esi)
1068e8: ff 76 08 pushl 0x8(%esi)
1068eb: 56 push %esi
1068ec: 68 86 9a 11 00 push $0x119a86
1068f1: e8 c0 12 00 00 call 107bb6 <printk>
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
printk(
1068f6: 8b 96 c8 00 00 00 mov 0xc8(%esi),%edx
1068fc: 8b 86 c4 00 00 00 mov 0xc4(%esi),%eax
106902: 50 push %eax
106903: 8d 44 02 ff lea -0x1(%edx,%eax,1),%eax
106907: 50 push %eax
106908: 52 push %edx
106909: 68 c4 9a 11 00 push $0x119ac4
10690e: e8 a3 12 00 00 call 107bb6 <printk>
stack->area,
stack->area + stack->size - 1,
stack->size
);
if ( !pattern_ok ) {
106913: 83 c4 20 add $0x20,%esp
106916: 84 db test %bl,%bl
106918: 75 1a jne 106934 <Stack_check_report_blown_task+0x5a><== NEVER TAKEN
printk(
10691a: 53 push %ebx
10691b: 6a 10 push $0x10
10691d: 8b 86 c8 00 00 00 mov 0xc8(%esi),%eax
106923: 83 c0 08 add $0x8,%eax
106926: 50 push %eax
106927: 68 f2 9a 11 00 push $0x119af2
10692c: e8 85 12 00 00 call 107bb6 <printk>
106931: 83 c4 10 add $0x10,%esp
" Damaged pattern begins at 0x%08lx and is %d bytes long\n",
(unsigned long) Stack_check_Get_pattern_area(stack),
PATTERN_SIZE_BYTES);
}
rtems_fatal_error_occurred( 0x81 );
106934: 83 ec 0c sub $0xc,%esp
106937: 68 81 00 00 00 push $0x81
10693c: e8 4b 3b 00 00 call 10a48c <rtems_fatal_error_occurred>
001099a9 <_API_extensions_Run_postdriver>:
*
* _API_extensions_Run_postdriver
*/
void _API_extensions_Run_postdriver( void )
{
1099a9: 55 push %ebp
1099aa: 89 e5 mov %esp,%ebp
1099ac: 53 push %ebx
1099ad: 83 ec 04 sub $0x4,%esp
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
1099b0: 8b 1d bc d9 11 00 mov 0x11d9bc,%ebx
1099b6: eb 0b jmp 1099c3 <_API_extensions_Run_postdriver+0x1a>
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->postdriver_hook )
1099b8: 8b 43 0c mov 0xc(%ebx),%eax
1099bb: 85 c0 test %eax,%eax
1099bd: 74 02 je 1099c1 <_API_extensions_Run_postdriver+0x18><== NEVER TAKEN
(*the_extension->postdriver_hook)();
1099bf: ff d0 call *%eax
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
1099c1: 8b 1b mov (%ebx),%ebx
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
1099c3: 81 fb c0 d9 11 00 cmp $0x11d9c0,%ebx
1099c9: 75 ed jne 1099b8 <_API_extensions_Run_postdriver+0xf>
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->postdriver_hook )
(*the_extension->postdriver_hook)();
}
}
1099cb: 5a pop %edx
1099cc: 5b pop %ebx
1099cd: c9 leave
1099ce: c3 ret
001099cf <_API_extensions_Run_postswitch>:
*
* _API_extensions_Run_postswitch
*/
void _API_extensions_Run_postswitch( void )
{
1099cf: 55 push %ebp
1099d0: 89 e5 mov %esp,%ebp
1099d2: 53 push %ebx
1099d3: 83 ec 04 sub $0x4,%esp
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
1099d6: 8b 1d bc d9 11 00 mov 0x11d9bc,%ebx
1099dc: eb 17 jmp 1099f5 <_API_extensions_Run_postswitch+0x26>
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->postswitch_hook )
1099de: 8b 43 10 mov 0x10(%ebx),%eax
1099e1: 85 c0 test %eax,%eax
1099e3: 74 0e je 1099f3 <_API_extensions_Run_postswitch+0x24><== NEVER TAKEN
(*the_extension->postswitch_hook)( _Thread_Executing );
1099e5: 83 ec 0c sub $0xc,%esp
1099e8: ff 35 58 d8 11 00 pushl 0x11d858
1099ee: ff d0 call *%eax
1099f0: 83 c4 10 add $0x10,%esp
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
1099f3: 8b 1b mov (%ebx),%ebx
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
1099f5: 81 fb c0 d9 11 00 cmp $0x11d9c0,%ebx
1099fb: 75 e1 jne 1099de <_API_extensions_Run_postswitch+0xf>
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->postswitch_hook )
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
1099fd: 8b 5d fc mov -0x4(%ebp),%ebx
109a00: c9 leave
109a01: c3 ret
00109983 <_API_extensions_Run_predriver>:
*
* _API_extensions_Run_predriver
*/
void _API_extensions_Run_predriver( void )
{
109983: 55 push %ebp
109984: 89 e5 mov %esp,%ebp
109986: 53 push %ebx
109987: 83 ec 04 sub $0x4,%esp
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
10998a: 8b 1d bc d9 11 00 mov 0x11d9bc,%ebx
109990: eb 0b jmp 10999d <_API_extensions_Run_predriver+0x1a>
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->predriver_hook )
109992: 8b 43 08 mov 0x8(%ebx),%eax
109995: 85 c0 test %eax,%eax
109997: 74 02 je 10999b <_API_extensions_Run_predriver+0x18><== ALWAYS TAKEN
(*the_extension->predriver_hook)();
109999: ff d0 call *%eax <== NOT EXECUTED
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
10999b: 8b 1b mov (%ebx),%ebx
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
10999d: 81 fb c0 d9 11 00 cmp $0x11d9c0,%ebx
1099a3: 75 ed jne 109992 <_API_extensions_Run_predriver+0xf>
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->predriver_hook )
(*the_extension->predriver_hook)();
}
}
1099a5: 58 pop %eax
1099a6: 5b pop %ebx
1099a7: c9 leave
1099a8: c3 ret
0010b720 <_CORE_RWLock_Obtain_for_reading>:
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_RWLock_API_mp_support_callout api_rwlock_mp_support
)
{
10b720: 55 push %ebp
10b721: 89 e5 mov %esp,%ebp
10b723: 57 push %edi
10b724: 56 push %esi
10b725: 53 push %ebx
10b726: 83 ec 0c sub $0xc,%esp
10b729: 8b 5d 08 mov 0x8(%ebp),%ebx
10b72c: 8b 45 0c mov 0xc(%ebp),%eax
10b72f: 89 45 f0 mov %eax,-0x10(%ebp)
10b732: 8b 45 14 mov 0x14(%ebp),%eax
10b735: 89 45 e8 mov %eax,-0x18(%ebp)
10b738: 8a 45 10 mov 0x10(%ebp),%al
10b73b: 88 45 ef mov %al,-0x11(%ebp)
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
10b73e: 8b 35 90 fc 11 00 mov 0x11fc90,%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 );
10b744: 9c pushf
10b745: fa cli
10b746: 5f pop %edi
switch ( the_rwlock->current_state ) {
10b747: 8b 43 44 mov 0x44(%ebx),%eax
10b74a: 85 c0 test %eax,%eax
10b74c: 74 05 je 10b753 <_CORE_RWLock_Obtain_for_reading+0x33>
10b74e: 48 dec %eax
10b74f: 75 2e jne 10b77f <_CORE_RWLock_Obtain_for_reading+0x5f>
10b751: eb 0e jmp 10b761 <_CORE_RWLock_Obtain_for_reading+0x41>
case CORE_RWLOCK_UNLOCKED:
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
10b753: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx)
the_rwlock->number_of_readers += 1;
10b75a: ff 43 48 incl 0x48(%ebx)
_ISR_Enable( level );
10b75d: 57 push %edi
10b75e: 9d popf
10b75f: eb 15 jmp 10b776 <_CORE_RWLock_Obtain_for_reading+0x56>
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 );
10b761: 83 ec 0c sub $0xc,%esp
10b764: 53 push %ebx
10b765: e8 2e 19 00 00 call 10d098 <_Thread_queue_First>
if ( !waiter ) {
10b76a: 83 c4 10 add $0x10,%esp
10b76d: 85 c0 test %eax,%eax
10b76f: 75 0e jne 10b77f <_CORE_RWLock_Obtain_for_reading+0x5f><== NEVER TAKEN
the_rwlock->number_of_readers += 1;
10b771: ff 43 48 incl 0x48(%ebx)
_ISR_Enable( level );
10b774: 57 push %edi
10b775: 9d popf
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10b776: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi)
10b77d: eb 4d jmp 10b7cc <_CORE_RWLock_Obtain_for_reading+0xac>
/*
* If the thread is not willing to wait, then return immediately.
*/
if ( !wait ) {
10b77f: 80 7d ef 00 cmpb $0x0,-0x11(%ebp)
10b783: 75 0b jne 10b790 <_CORE_RWLock_Obtain_for_reading+0x70>
_ISR_Enable( level );
10b785: 57 push %edi
10b786: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10b787: c7 46 34 02 00 00 00 movl $0x2,0x34(%esi)
10b78e: eb 3c jmp 10b7cc <_CORE_RWLock_Obtain_for_reading+0xac>
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
* This routine grows @a the_heap memory area using the size bytes which
10b790: 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;
10b797: 89 5e 44 mov %ebx,0x44(%esi)
executing->Wait.id = id;
10b79a: 8b 45 f0 mov -0x10(%ebp),%eax
10b79d: 89 46 20 mov %eax,0x20(%esi)
executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ;
10b7a0: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi)
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10b7a7: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi)
_ISR_Enable( level );
10b7ae: 57 push %edi
10b7af: 9d popf
_Thread_queue_Enqueue_with_handler(
10b7b0: c7 45 10 f0 b8 10 00 movl $0x10b8f0,0x10(%ebp)
10b7b7: 8b 45 e8 mov -0x18(%ebp),%eax
10b7ba: 89 45 0c mov %eax,0xc(%ebp)
10b7bd: 89 5d 08 mov %ebx,0x8(%ebp)
timeout,
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
10b7c0: 8d 65 f4 lea -0xc(%ebp),%esp
10b7c3: 5b pop %ebx
10b7c4: 5e pop %esi
10b7c5: 5f pop %edi
10b7c6: 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(
10b7c7: e9 d0 15 00 00 jmp 10cd9c <_Thread_queue_Enqueue_with_handler>
timeout,
_CORE_RWLock_Timeout
);
/* return to API level so it can dispatch and we block */
}
10b7cc: 8d 65 f4 lea -0xc(%ebp),%esp
10b7cf: 5b pop %ebx
10b7d0: 5e pop %esi
10b7d1: 5f pop %edi
10b7d2: c9 leave
10b7d3: c3 ret
0010b850 <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
10b850: 55 push %ebp
10b851: 89 e5 mov %esp,%ebp
10b853: 53 push %ebx
10b854: 83 ec 04 sub $0x4,%esp
10b857: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
10b85a: 8b 0d 90 fc 11 00 mov 0x11fc90,%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 );
10b860: 9c pushf
10b861: fa cli
10b862: 5a pop %edx
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
10b863: 8b 43 44 mov 0x44(%ebx),%eax
10b866: 85 c0 test %eax,%eax
10b868: 75 0b jne 10b875 <_CORE_RWLock_Release+0x25><== ALWAYS TAKEN
_ISR_Enable( level );
10b86a: 52 push %edx <== NOT EXECUTED
10b86b: 9d popf <== NOT EXECUTED
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10b86c: c7 41 34 02 00 00 00 movl $0x2,0x34(%ecx) <== NOT EXECUTED
10b873: eb 72 jmp 10b8e7 <_CORE_RWLock_Release+0x97><== NOT EXECUTED
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
10b875: 48 dec %eax
10b876: 75 0f jne 10b887 <_CORE_RWLock_Release+0x37>
the_rwlock->number_of_readers -= 1;
10b878: 8b 43 48 mov 0x48(%ebx),%eax
10b87b: 48 dec %eax
10b87c: 89 43 48 mov %eax,0x48(%ebx)
if ( the_rwlock->number_of_readers != 0 ) {
10b87f: 85 c0 test %eax,%eax
10b881: 74 04 je 10b887 <_CORE_RWLock_Release+0x37>
/* must be unlocked again */
_ISR_Enable( level );
10b883: 52 push %edx
10b884: 9d popf
10b885: eb 60 jmp 10b8e7 <_CORE_RWLock_Release+0x97>
return CORE_RWLOCK_SUCCESSFUL;
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10b887: 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;
10b88e: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
_ISR_Enable( level );
10b895: 52 push %edx
10b896: 9d popf
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
10b897: 83 ec 0c sub $0xc,%esp
10b89a: 53 push %ebx
10b89b: e8 e4 13 00 00 call 10cc84 <_Thread_queue_Dequeue>
if ( next ) {
10b8a0: 83 c4 10 add $0x10,%esp
10b8a3: 85 c0 test %eax,%eax
10b8a5: 74 40 je 10b8e7 <_CORE_RWLock_Release+0x97>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
10b8a7: 83 78 30 01 cmpl $0x1,0x30(%eax)
10b8ab: 75 09 jne 10b8b6 <_CORE_RWLock_Release+0x66>
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
10b8ad: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx)
10b8b4: eb 31 jmp 10b8e7 <_CORE_RWLock_Release+0x97>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
10b8b6: ff 43 48 incl 0x48(%ebx)
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
10b8b9: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx)
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
10b8c0: 83 ec 0c sub $0xc,%esp
10b8c3: 53 push %ebx
10b8c4: e8 cf 17 00 00 call 10d098 <_Thread_queue_First>
if ( !next ||
10b8c9: 83 c4 10 add $0x10,%esp
10b8cc: 85 c0 test %eax,%eax
10b8ce: 74 17 je 10b8e7 <_CORE_RWLock_Release+0x97>
10b8d0: 83 78 30 01 cmpl $0x1,0x30(%eax)
10b8d4: 74 11 je 10b8e7 <_CORE_RWLock_Release+0x97><== NEVER TAKEN
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
10b8d6: ff 43 48 incl 0x48(%ebx)
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
10b8d9: 52 push %edx
10b8da: 52 push %edx
10b8db: 50 push %eax
10b8dc: 53 push %ebx
10b8dd: e8 9e 16 00 00 call 10cf80 <_Thread_queue_Extract>
10b8e2: 83 c4 10 add $0x10,%esp
10b8e5: eb d9 jmp 10b8c0 <_CORE_RWLock_Release+0x70>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10b8e7: 31 c0 xor %eax,%eax
10b8e9: 8b 5d fc mov -0x4(%ebp),%ebx
10b8ec: c9 leave
10b8ed: c3 ret
0010b8f0 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
10b8f0: 55 push %ebp
10b8f1: 89 e5 mov %esp,%ebp
10b8f3: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10b8f6: 8d 45 fc lea -0x4(%ebp),%eax
10b8f9: 50 push %eax
10b8fa: ff 75 08 pushl 0x8(%ebp)
10b8fd: e8 6a 10 00 00 call 10c96c <_Thread_Get>
switch ( location ) {
10b902: 83 c4 10 add $0x10,%esp
10b905: 83 7d fc 00 cmpl $0x0,-0x4(%ebp)
10b909: 75 17 jne 10b922 <_CORE_RWLock_Timeout+0x32><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
10b90b: 83 ec 0c sub $0xc,%esp
10b90e: 50 push %eax
10b90f: e8 74 18 00 00 call 10d188 <_Thread_queue_Process_timeout>
10b914: a1 d0 fb 11 00 mov 0x11fbd0,%eax
10b919: 48 dec %eax
10b91a: a3 d0 fb 11 00 mov %eax,0x11fbd0
10b91f: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10b922: c9 leave
10b923: c3 ret
0010aa34 <_CORE_barrier_Wait>:
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
10aa34: 55 push %ebp
10aa35: 89 e5 mov %esp,%ebp
10aa37: 57 push %edi
10aa38: 56 push %esi
10aa39: 53 push %ebx
10aa3a: 83 ec 04 sub $0x4,%esp
10aa3d: 8b 55 08 mov 0x8(%ebp),%edx
10aa40: 8b 75 0c mov 0xc(%ebp),%esi
10aa43: 8b 45 14 mov 0x14(%ebp),%eax
10aa46: 89 45 f0 mov %eax,-0x10(%ebp)
10aa49: 8b 7d 18 mov 0x18(%ebp),%edi
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
10aa4c: 8b 0d 50 ed 11 00 mov 0x11ed50,%ecx
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
10aa52: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx)
_ISR_Disable( level );
10aa59: 9c pushf
10aa5a: fa cli
10aa5b: 5b pop %ebx
the_barrier->number_of_waiting_threads++;
10aa5c: 8b 42 48 mov 0x48(%edx),%eax
10aa5f: 40 inc %eax
10aa60: 89 42 48 mov %eax,0x48(%edx)
if ( the_barrier->number_of_waiting_threads ==
10aa63: 3b 42 44 cmp 0x44(%edx),%eax
10aa66: 75 22 jne 10aa8a <_CORE_barrier_Wait+0x56>
the_barrier->Attributes.maximum_count) {
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
10aa68: 83 7a 40 00 cmpl $0x0,0x40(%edx)
10aa6c: 75 1c jne 10aa8a <_CORE_barrier_Wait+0x56><== NEVER TAKEN
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
10aa6e: c7 41 34 01 00 00 00 movl $0x1,0x34(%ecx)
_ISR_Enable( level );
10aa75: 53 push %ebx
10aa76: 9d popf
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
10aa77: 89 7d 10 mov %edi,0x10(%ebp)
10aa7a: 89 75 0c mov %esi,0xc(%ebp)
10aa7d: 89 55 08 mov %edx,0x8(%ebp)
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
}
10aa80: 5a pop %edx
10aa81: 5b pop %ebx
10aa82: 5e pop %esi
10aa83: 5f pop %edi
10aa84: c9 leave
if ( the_barrier->number_of_waiting_threads ==
the_barrier->Attributes.maximum_count) {
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
_ISR_Enable( level );
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
10aa85: e9 c6 42 00 00 jmp 10ed50 <_CORE_barrier_Release>
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
* This routine grows @a the_heap memory area using the size bytes which
10aa8a: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx)
return;
}
}
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
10aa91: 89 51 44 mov %edx,0x44(%ecx)
executing->Wait.id = id;
10aa94: 89 71 20 mov %esi,0x20(%ecx)
_ISR_Enable( level );
10aa97: 53 push %ebx
10aa98: 9d popf
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
10aa99: c7 45 10 5c c5 10 00 movl $0x10c55c,0x10(%ebp)
10aaa0: 8b 45 f0 mov -0x10(%ebp),%eax
10aaa3: 89 45 0c mov %eax,0xc(%ebp)
10aaa6: 89 55 08 mov %edx,0x8(%ebp)
}
10aaa9: 58 pop %eax
10aaaa: 5b pop %ebx
10aaab: 5e pop %esi
10aaac: 5f pop %edi
10aaad: c9 leave
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
10aaae: e9 a5 17 00 00 jmp 10c258 <_Thread_queue_Enqueue_with_handler>
00113b08 <_CORE_message_queue_Broadcast>:
size_t size,
Objects_Id id,
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
uint32_t *count
)
{
113b08: 55 push %ebp
113b09: 89 e5 mov %esp,%ebp
113b0b: 57 push %edi
113b0c: 56 push %esi
113b0d: 53 push %ebx
113b0e: 83 ec 0c sub $0xc,%esp
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
113b11: b8 01 00 00 00 mov $0x1,%eax
113b16: 8b 4d 10 mov 0x10(%ebp),%ecx
113b19: 8b 55 08 mov 0x8(%ebp),%edx
113b1c: 3b 4a 4c cmp 0x4c(%edx),%ecx
113b1f: 77 43 ja 113b64 <_CORE_message_queue_Broadcast+0x5c><== NEVER TAKEN
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
number_broadcasted = 0;
while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
113b21: 31 db xor %ebx,%ebx
* 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 ) {
113b23: 8b 75 08 mov 0x8(%ebp),%esi
113b26: 83 7e 48 00 cmpl $0x0,0x48(%esi)
113b2a: 74 21 je 113b4d <_CORE_message_queue_Broadcast+0x45><== ALWAYS TAKEN
*count = 0;
113b2c: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED
113b2f: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
113b35: 31 c0 xor %eax,%eax <== NOT EXECUTED
113b37: eb 2b jmp 113b64 <_CORE_message_queue_Broadcast+0x5c><== NOT EXECUTED
*/
number_broadcasted = 0;
while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
113b39: 43 inc %ebx
* alignments are possible.
* Returns pointer to the start of the memory block if success, NULL if
* failure.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
113b3a: 8b 78 2c mov 0x2c(%eax),%edi
113b3d: 8b 75 0c mov 0xc(%ebp),%esi
113b40: 8b 4d 10 mov 0x10(%ebp),%ecx
113b43: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
113b45: 8b 40 28 mov 0x28(%eax),%eax
113b48: 8b 55 10 mov 0x10(%ebp),%edx
113b4b: 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 = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
113b4d: 83 ec 0c sub $0xc,%esp
113b50: ff 75 08 pushl 0x8(%ebp)
113b53: e8 98 1f 00 00 call 115af0 <_Thread_queue_Dequeue>
113b58: 83 c4 10 add $0x10,%esp
113b5b: 85 c0 test %eax,%eax
113b5d: 75 da jne 113b39 <_CORE_message_queue_Broadcast+0x31>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
113b5f: 8b 4d 1c mov 0x1c(%ebp),%ecx
113b62: 89 19 mov %ebx,(%ecx)
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
113b64: 8d 65 f4 lea -0xc(%ebp),%esp
113b67: 5b pop %ebx
113b68: 5e pop %esi
113b69: 5f pop %edi
113b6a: c9 leave
113b6b: c3 ret
00112ec8 <_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
)
{
112ec8: 55 push %ebp
112ec9: 89 e5 mov %esp,%ebp
112ecb: 57 push %edi
112ecc: 56 push %esi
112ecd: 53 push %ebx
112ece: 83 ec 0c sub $0xc,%esp
112ed1: 8b 5d 08 mov 0x8(%ebp),%ebx
112ed4: 8b 7d 10 mov 0x10(%ebp),%edi
112ed7: 8b 55 14 mov 0x14(%ebp),%edx
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
112eda: 89 7b 44 mov %edi,0x44(%ebx)
the_message_queue->number_of_pending_messages = 0;
112edd: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
the_message_queue->maximum_message_size = maximum_message_size;
112ee4: 89 53 4c mov %edx,0x4c(%ebx)
112ee7: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
112eee: 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)) {
112ef5: 89 d0 mov %edx,%eax
112ef7: f6 c2 03 test $0x3,%dl
112efa: 74 0a je 112f06 <_CORE_message_queue_Initialize+0x3e>
allocated_message_size += sizeof(uint32_t);
112efc: 8d 42 04 lea 0x4(%edx),%eax
allocated_message_size &= ~(sizeof(uint32_t) - 1);
112eff: 83 e0 fc and $0xfffffffc,%eax
}
if (allocated_message_size < maximum_message_size)
112f02: 39 d0 cmp %edx,%eax
112f04: 72 5f jb 112f65 <_CORE_message_queue_Initialize+0x9d><== NEVER TAKEN
/*
* 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 *
112f06: 8d 70 14 lea 0x14(%eax),%esi
112f09: 89 f2 mov %esi,%edx
112f0b: 0f af d7 imul %edi,%edx
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
112f0e: 39 c2 cmp %eax,%edx
112f10: 72 53 jb 112f65 <_CORE_message_queue_Initialize+0x9d><== NEVER TAKEN
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
112f12: 83 ec 0c sub $0xc,%esp
112f15: 52 push %edx
112f16: e8 92 de ff ff call 110dad <_Workspace_Allocate>
112f1b: 89 43 5c mov %eax,0x5c(%ebx)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
112f1e: 83 c4 10 add $0x10,%esp
112f21: 85 c0 test %eax,%eax
112f23: 74 40 je 112f65 <_CORE_message_queue_Initialize+0x9d>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
112f25: 56 push %esi
112f26: 57 push %edi
112f27: 50 push %eax
112f28: 8d 43 68 lea 0x68(%ebx),%eax
112f2b: 50 push %eax
112f2c: e8 93 fe ff ff call 112dc4 <_Chain_Initialize>
112f31: 8d 43 54 lea 0x54(%ebx),%eax
112f34: 89 43 50 mov %eax,0x50(%ebx)
112f37: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx)
112f3e: 8d 43 50 lea 0x50(%ebx),%eax
112f41: 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(
112f44: 6a 06 push $0x6
112f46: 68 80 00 00 00 push $0x80
112f4b: 8b 45 0c mov 0xc(%ebp),%eax
112f4e: 83 38 01 cmpl $0x1,(%eax)
112f51: 0f 94 c0 sete %al
112f54: 0f b6 c0 movzbl %al,%eax
112f57: 50 push %eax
112f58: 53 push %ebx
112f59: e8 5a d4 ff ff call 1103b8 <_Thread_queue_Initialize>
112f5e: b0 01 mov $0x1,%al
112f60: 83 c4 20 add $0x20,%esp
112f63: eb 02 jmp 112f67 <_CORE_message_queue_Initialize+0x9f>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
112f65: 31 c0 xor %eax,%eax
}
112f67: 8d 65 f4 lea -0xc(%ebp),%esp
112f6a: 5b pop %ebx
112f6b: 5e pop %esi
112f6c: 5f pop %edi
112f6d: c9 leave
112f6e: c3 ret
0010e7f8 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
10e7f8: 55 push %ebp
10e7f9: 89 e5 mov %esp,%ebp
10e7fb: 57 push %edi
10e7fc: 56 push %esi
10e7fd: 53 push %ebx
10e7fe: 83 ec 2c sub $0x2c,%esp
10e801: 8b 45 08 mov 0x8(%ebp),%eax
10e804: 89 45 d0 mov %eax,-0x30(%ebp)
10e807: 8b 55 0c mov 0xc(%ebp),%edx
10e80a: 89 55 ec mov %edx,-0x14(%ebp)
10e80d: 8b 7d 10 mov 0x10(%ebp),%edi
10e810: 89 7d e8 mov %edi,-0x18(%ebp)
10e813: 8b 45 14 mov 0x14(%ebp),%eax
10e816: 89 45 e4 mov %eax,-0x1c(%ebp)
10e819: 8b 55 1c mov 0x1c(%ebp),%edx
10e81c: 89 55 dc mov %edx,-0x24(%ebp)
10e81f: 8a 45 18 mov 0x18(%ebp),%al
10e822: 88 45 e3 mov %al,-0x1d(%ebp)
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
Thread_Control *the_thread;
executing = _Thread_Executing;
10e825: 8b 35 18 64 12 00 mov 0x126418,%esi
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
10e82b: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi)
_ISR_Disable( level );
10e832: 9c pushf
10e833: fa cli
10e834: 59 pop %ecx
* to obtain the size of
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
10e835: 8b 55 d0 mov -0x30(%ebp),%edx
10e838: 8b 5a 50 mov 0x50(%edx),%ebx
10e83b: 89 d0 mov %edx,%eax
10e83d: 83 c0 54 add $0x54,%eax
10e840: 39 c3 cmp %eax,%ebx
10e842: 0f 84 9e 00 00 00 je 10e8e6 <_CORE_message_queue_Seize+0xee>
10e848: 8b 13 mov (%ebx),%edx
10e84a: 8b 7d d0 mov -0x30(%ebp),%edi
10e84d: 89 57 50 mov %edx,0x50(%edi)
10e850: 89 f8 mov %edi,%eax
10e852: 83 c0 50 add $0x50,%eax
10e855: 89 42 04 mov %eax,0x4(%edx)
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
10e858: 85 db test %ebx,%ebx
10e85a: 0f 84 86 00 00 00 je 10e8e6 <_CORE_message_queue_Seize+0xee><== NEVER TAKEN
the_message_queue->number_of_pending_messages -= 1;
10e860: ff 4f 48 decl 0x48(%edi)
_ISR_Enable( level );
10e863: 51 push %ecx
10e864: 9d popf
*size_p = the_message->Contents.size;
10e865: 8b 43 0c mov 0xc(%ebx),%eax
10e868: 8b 55 e4 mov -0x1c(%ebp),%edx
10e86b: 89 02 mov %eax,(%edx)
_Thread_Executing->Wait.count = the_message->priority;
10e86d: 8b 53 08 mov 0x8(%ebx),%edx
10e870: a1 18 64 12 00 mov 0x126418,%eax
10e875: 89 50 24 mov %edx,0x24(%eax)
_CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size_p);
10e878: 8d 7b 10 lea 0x10(%ebx),%edi
10e87b: 89 7d f0 mov %edi,-0x10(%ebp)
* alignments are possible.
* Returns pointer to the start of the memory block if success, NULL if
* failure.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
10e87e: 8b 45 e4 mov -0x1c(%ebp),%eax
10e881: 8b 08 mov (%eax),%ecx
10e883: 8b 7d e8 mov -0x18(%ebp),%edi
10e886: 8b 75 f0 mov -0x10(%ebp),%esi
10e889: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
*
* 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 );
10e88b: 83 ec 0c sub $0xc,%esp
10e88e: ff 75 d0 pushl -0x30(%ebp)
10e891: e8 d6 17 00 00 call 11006c <_Thread_queue_Dequeue>
10e896: 89 c2 mov %eax,%edx
if ( !the_thread ) {
10e898: 83 c4 10 add $0x10,%esp
10e89b: 85 c0 test %eax,%eax
10e89d: 75 18 jne 10e8b7 <_CORE_message_queue_Seize+0xbf>
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
Heap_Control *the_heap,
void *starting_address,
size_t *size
10e89f: 89 5d 0c mov %ebx,0xc(%ebp)
10e8a2: 8b 45 d0 mov -0x30(%ebp),%eax
10e8a5: 83 c0 68 add $0x68,%eax
10e8a8: 89 45 08 mov %eax,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 );
}
10e8ab: 8d 65 f4 lea -0xc(%ebp),%esp
10e8ae: 5b pop %ebx
10e8af: 5e pop %esi
10e8b0: 5f pop %edi
10e8b1: c9 leave
10e8b2: e9 71 fe ff ff jmp 10e728 <_Chain_Append>
* There was a thread waiting to send a message. This code
* puts the messages in the message queue on behalf of the
* waiting task.
*/
the_message->priority = the_thread->Wait.count;
10e8b7: 8b 40 24 mov 0x24(%eax),%eax
10e8ba: 89 43 08 mov %eax,0x8(%ebx)
the_message->Contents.size = (size_t) the_thread->Wait.option;
10e8bd: 8b 4a 30 mov 0x30(%edx),%ecx
10e8c0: 89 4b 0c mov %ecx,0xc(%ebx)
* alignments are possible.
* Returns pointer to the start of the memory block if success, NULL if
* failure.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
10e8c3: 8b 72 2c mov 0x2c(%edx),%esi
10e8c6: 8b 7d f0 mov -0x10(%ebp),%edi
10e8c9: 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(
10e8cb: 8b 43 08 mov 0x8(%ebx),%eax
10e8ce: 89 45 10 mov %eax,0x10(%ebp)
10e8d1: 89 5d 0c mov %ebx,0xc(%ebp)
10e8d4: 8b 45 d0 mov -0x30(%ebp),%eax
10e8d7: 89 45 08 mov %eax,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 );
}
10e8da: 8d 65 f4 lea -0xc(%ebp),%esp
10e8dd: 5b pop %ebx
10e8de: 5e pop %esi
10e8df: 5f pop %edi
10e8e0: c9 leave
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
10e8e1: e9 16 45 00 00 jmp 112dfc <_CORE_message_queue_Insert_message>
the_message->priority
);
return;
}
if ( !wait ) {
10e8e6: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
10e8ea: 75 11 jne 10e8fd <_CORE_message_queue_Seize+0x105>
_ISR_Enable( level );
10e8ec: 51 push %ecx
10e8ed: 9d popf
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
10e8ee: c7 46 34 04 00 00 00 movl $0x4,0x34(%esi)
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 );
}
10e8f5: 8d 65 f4 lea -0xc(%ebp),%esp
10e8f8: 5b pop %ebx
10e8f9: 5e pop %esi
10e8fa: 5f pop %edi
10e8fb: c9 leave
10e8fc: c3 ret
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
* This routine grows @a the_heap memory area using the size bytes which
10e8fd: 8b 55 d0 mov -0x30(%ebp),%edx
10e900: 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;
10e907: 89 56 44 mov %edx,0x44(%esi)
executing->Wait.id = id;
10e90a: 8b 7d ec mov -0x14(%ebp),%edi
10e90d: 89 7e 20 mov %edi,0x20(%esi)
executing->Wait.return_argument_second.mutable_object = buffer;
10e910: 8b 45 e8 mov -0x18(%ebp),%eax
10e913: 89 46 2c mov %eax,0x2c(%esi)
executing->Wait.return_argument = size_p;
10e916: 8b 55 e4 mov -0x1c(%ebp),%edx
10e919: 89 56 28 mov %edx,0x28(%esi)
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
10e91c: 51 push %ecx
10e91d: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
10e91e: c7 45 10 88 04 11 00 movl $0x110488,0x10(%ebp)
10e925: 8b 7d dc mov -0x24(%ebp),%edi
10e928: 89 7d 0c mov %edi,0xc(%ebp)
10e92b: 8b 45 d0 mov -0x30(%ebp),%eax
10e92e: 89 45 08 mov %eax,0x8(%ebp)
}
10e931: 8d 65 f4 lea -0xc(%ebp),%esp
10e934: 5b pop %ebx
10e935: 5e pop %esi
10e936: 5f pop %edi
10e937: 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 );
10e938: e9 47 18 00 00 jmp 110184 <_Thread_queue_Enqueue_with_handler>
00109b38 <_CORE_message_queue_Submit>:
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
109b38: 55 push %ebp
109b39: 89 e5 mov %esp,%ebp
109b3b: 57 push %edi
109b3c: 56 push %esi
109b3d: 53 push %ebx
109b3e: 83 ec 1c sub $0x1c,%esp
109b41: 8b 5d 10 mov 0x10(%ebp),%ebx
109b44: 8a 45 20 mov 0x20(%ebp),%al
109b47: 88 45 f3 mov %al,-0xd(%ebp)
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
109b4a: b8 01 00 00 00 mov $0x1,%eax
109b4f: 8b 55 08 mov 0x8(%ebp),%edx
109b52: 3b 5a 4c cmp 0x4c(%edx),%ebx
109b55: 0f 87 d9 00 00 00 ja 109c34 <_CORE_message_queue_Submit+0xfc>
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
109b5b: 8b 75 08 mov 0x8(%ebp),%esi
109b5e: 83 7e 48 00 cmpl $0x0,0x48(%esi)
109b62: 75 2e jne 109b92 <_CORE_message_queue_Submit+0x5a>
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
109b64: 83 ec 0c sub $0xc,%esp
109b67: 56 push %esi
109b68: e8 57 16 00 00 call 10b1c4 <_Thread_queue_Dequeue>
109b6d: 89 c2 mov %eax,%edx
if ( the_thread ) {
109b6f: 83 c4 10 add $0x10,%esp
109b72: 85 c0 test %eax,%eax
109b74: 74 1c je 109b92 <_CORE_message_queue_Submit+0x5a>
* alignments are possible.
* Returns pointer to the start of the memory block if success, NULL if
* failure.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
109b76: 8b 78 2c mov 0x2c(%eax),%edi
109b79: 8b 75 0c mov 0xc(%ebp),%esi
109b7c: 89 d9 mov %ebx,%ecx
109b7e: 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;
109b80: 8b 40 28 mov 0x28(%eax),%eax
109b83: 89 18 mov %ebx,(%eax)
the_thread->Wait.count = submit_type;
109b85: 8b 45 1c mov 0x1c(%ebp),%eax
109b88: 89 42 24 mov %eax,0x24(%edx)
109b8b: 31 c0 xor %eax,%eax
109b8d: e9 a2 00 00 00 jmp 109c34 <_CORE_message_queue_Submit+0xfc>
/*
* 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 <
109b92: 8b 55 08 mov 0x8(%ebp),%edx
109b95: 8b 42 48 mov 0x48(%edx),%eax
109b98: 3b 42 44 cmp 0x44(%edx),%eax
109b9b: 73 37 jae 109bd4 <_CORE_message_queue_Submit+0x9c>
);
/**
* This function sets @a *size to the size of the block of user memory
* which begins at @a starting_address. The size returned in @a *size could
* be greater than the size requested for allocation.
109b9d: 83 ec 0c sub $0xc,%esp
109ba0: 89 d0 mov %edx,%eax
109ba2: 83 c0 68 add $0x68,%eax
109ba5: 50 push %eax
109ba6: e8 65 ff ff ff call 109b10 <_Chain_Get>
/*
* NOTE: If the system is consistent, this error should never occur.
*/
if ( !the_message ) {
109bab: 83 c4 10 add $0x10,%esp
109bae: 85 c0 test %eax,%eax
109bb0: 74 7d je 109c2f <_CORE_message_queue_Submit+0xf7><== NEVER TAKEN
* alignments are possible.
* Returns pointer to the start of the memory block if success, NULL if
* failure.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
109bb2: 8d 78 10 lea 0x10(%eax),%edi
109bb5: 8b 75 0c mov 0xc(%ebp),%esi
109bb8: 89 d9 mov %ebx,%ecx
109bba: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
_CORE_message_queue_Copy_buffer(
buffer,
the_message->Contents.buffer,
size
);
the_message->Contents.size = size;
109bbc: 89 58 0c mov %ebx,0xc(%eax)
the_message->priority = submit_type;
109bbf: 8b 55 1c mov 0x1c(%ebp),%edx
109bc2: 89 50 08 mov %edx,0x8(%eax)
_CORE_message_queue_Insert_message(
109bc5: 51 push %ecx
109bc6: 52 push %edx
109bc7: 50 push %eax
109bc8: ff 75 08 pushl 0x8(%ebp)
109bcb: e8 c4 41 00 00 call 10dd94 <_CORE_message_queue_Insert_message>
109bd0: 31 c0 xor %eax,%eax
109bd2: eb 56 jmp 109c2a <_CORE_message_queue_Submit+0xf2>
* 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 ) {
109bd4: b8 02 00 00 00 mov $0x2,%eax
109bd9: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
109bdd: 74 55 je 109c34 <_CORE_message_queue_Submit+0xfc>
/*
* 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() ) {
109bdf: a1 34 d8 11 00 mov 0x11d834,%eax
109be4: 85 c0 test %eax,%eax
109be6: 75 47 jne 109c2f <_CORE_message_queue_Submit+0xf7><== NEVER TAKEN
* it as a variable. Doing this emphasizes how dangerous it
* would be to use this variable prior to here.
*/
{
Thread_Control *executing = _Thread_Executing;
109be8: a1 58 d8 11 00 mov 0x11d858,%eax
_ISR_Disable( level );
109bed: 9c pushf
109bee: fa cli
109bef: 59 pop %ecx
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
* This routine grows @a the_heap memory area using the size bytes which
109bf0: 8b 75 08 mov 0x8(%ebp),%esi
109bf3: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi)
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
109bfa: 89 70 44 mov %esi,0x44(%eax)
executing->Wait.id = id;
109bfd: 8b 55 14 mov 0x14(%ebp),%edx
109c00: 89 50 20 mov %edx,0x20(%eax)
executing->Wait.return_argument_second.immutable_object = buffer;
109c03: 8b 55 0c mov 0xc(%ebp),%edx
109c06: 89 50 2c mov %edx,0x2c(%eax)
executing->Wait.option = (uint32_t) size;
109c09: 89 58 30 mov %ebx,0x30(%eax)
executing->Wait.count = submit_type;
109c0c: 8b 75 1c mov 0x1c(%ebp),%esi
109c0f: 89 70 24 mov %esi,0x24(%eax)
_ISR_Enable( level );
109c12: 51 push %ecx
109c13: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
109c14: 50 push %eax
109c15: 68 e0 b5 10 00 push $0x10b5e0
109c1a: ff 75 24 pushl 0x24(%ebp)
109c1d: ff 75 08 pushl 0x8(%ebp)
109c20: e8 b7 16 00 00 call 10b2dc <_Thread_queue_Enqueue_with_handler>
109c25: b8 07 00 00 00 mov $0x7,%eax
109c2a: 83 c4 10 add $0x10,%esp
109c2d: eb 05 jmp 109c34 <_CORE_message_queue_Submit+0xfc>
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
109c2f: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED
}
109c34: 8d 65 f4 lea -0xc(%ebp),%esp
109c37: 5b pop %ebx
109c38: 5e pop %esi
109c39: 5f pop %edi
109c3a: c9 leave
109c3b: c3 ret
00109c48 <_CORE_mutex_Initialize>:
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
109c48: 55 push %ebp
109c49: 89 e5 mov %esp,%ebp
109c4b: 57 push %edi
109c4c: 56 push %esi
109c4d: 53 push %ebx
109c4e: 83 ec 0c sub $0xc,%esp
109c51: 8b 5d 08 mov 0x8(%ebp),%ebx
109c54: 8b 45 10 mov 0x10(%ebp),%eax
/* 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;
109c57: 8d 7b 40 lea 0x40(%ebx),%edi
109c5a: b9 04 00 00 00 mov $0x4,%ecx
109c5f: 8b 75 0c mov 0xc(%ebp),%esi
109c62: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_mutex->lock = initial_lock;
109c64: 89 43 50 mov %eax,0x50(%ebx)
the_mutex->blocked_count = 0;
109c67: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx)
if ( initial_lock == CORE_MUTEX_LOCKED ) {
109c6e: 85 c0 test %eax,%eax
109c70: 75 35 jne 109ca7 <_CORE_mutex_Initialize+0x5f>
the_mutex->nest_count = 1;
109c72: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx)
the_mutex->holder = _Thread_Executing;
109c79: 8b 15 58 d8 11 00 mov 0x11d858,%edx
109c7f: 89 53 5c mov %edx,0x5c(%ebx)
the_mutex->holder_id = _Thread_Executing->Object.id;
109c82: 8b 42 08 mov 0x8(%edx),%eax
109c85: 89 43 60 mov %eax,0x60(%ebx)
/**
* This function attempts to allocate a memory block of @a size bytes from
* @a the_heap so that the start of the user memory is aligned on the
* @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT.
* Any other value of @a alignment is taken "as is", i.e., even odd
109c88: 8b 43 48 mov 0x48(%ebx),%eax
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
109c8b: 83 f8 02 cmp $0x2,%eax
109c8e: 74 05 je 109c95 <_CORE_mutex_Initialize+0x4d>
109c90: 83 f8 03 cmp $0x3,%eax
109c93: 75 27 jne 109cbc <_CORE_mutex_Initialize+0x74><== ALWAYS TAKEN
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
109c95: 8b 42 14 mov 0x14(%edx),%eax
109c98: b9 06 00 00 00 mov $0x6,%ecx
109c9d: 3b 43 4c cmp 0x4c(%ebx),%eax
109ca0: 72 3a jb 109cdc <_CORE_mutex_Initialize+0x94><== NEVER TAKEN
_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++;
109ca2: ff 42 1c incl 0x1c(%edx)
109ca5: eb 15 jmp 109cbc <_CORE_mutex_Initialize+0x74>
}
} else {
the_mutex->nest_count = 0;
109ca7: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx)
the_mutex->holder = NULL;
109cae: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
the_mutex->holder_id = 0;
109cb5: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
}
_Thread_queue_Initialize(
109cbc: 6a 05 push $0x5
109cbe: 68 00 04 00 00 push $0x400
109cc3: 8b 45 0c mov 0xc(%ebp),%eax
109cc6: 83 78 08 00 cmpl $0x0,0x8(%eax)
109cca: 0f 95 c0 setne %al
109ccd: 0f b6 c0 movzbl %al,%eax
109cd0: 50 push %eax
109cd1: 53 push %ebx
109cd2: e8 39 18 00 00 call 10b510 <_Thread_queue_Initialize>
109cd7: 31 c9 xor %ecx,%ecx
109cd9: 83 c4 10 add $0x10,%esp
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
109cdc: 89 c8 mov %ecx,%eax
109cde: 8d 65 f4 lea -0xc(%ebp),%esp
109ce1: 5b pop %ebx
109ce2: 5e pop %esi
109ce3: 5f pop %edi
109ce4: c9 leave
109ce5: c3 ret
00109d34 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
109d34: 55 push %ebp
109d35: 89 e5 mov %esp,%ebp
109d37: 56 push %esi
109d38: 53 push %ebx
109d39: 8b 75 08 mov 0x8(%ebp),%esi
109d3c: 8a 5d 10 mov 0x10(%ebp),%bl
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
109d3f: a1 98 d7 11 00 mov 0x11d798,%eax
109d44: 85 c0 test %eax,%eax
109d46: 74 19 je 109d61 <_CORE_mutex_Seize+0x2d>
109d48: 84 db test %bl,%bl
109d4a: 74 15 je 109d61 <_CORE_mutex_Seize+0x2d><== NEVER TAKEN
109d4c: 83 3d 38 d9 11 00 01 cmpl $0x1,0x11d938
109d53: 76 0c jbe 109d61 <_CORE_mutex_Seize+0x2d>
109d55: 50 push %eax
109d56: 6a 13 push $0x13
109d58: 6a 00 push $0x0
109d5a: 6a 00 push $0x0
109d5c: e8 93 04 00 00 call 10a1f4 <_Internal_error_Occurred>
109d61: 50 push %eax
109d62: 50 push %eax
109d63: 8d 45 18 lea 0x18(%ebp),%eax
109d66: 50 push %eax
109d67: 56 push %esi
109d68: e8 f3 40 00 00 call 10de60 <_CORE_mutex_Seize_interrupt_trylock>
109d6d: 83 c4 10 add $0x10,%esp
109d70: 85 c0 test %eax,%eax
109d72: 74 49 je 109dbd <_CORE_mutex_Seize+0x89>
109d74: 84 db test %bl,%bl
109d76: 75 12 jne 109d8a <_CORE_mutex_Seize+0x56>
109d78: ff 75 18 pushl 0x18(%ebp)
109d7b: 9d popf
109d7c: a1 58 d8 11 00 mov 0x11d858,%eax
109d81: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax)
109d88: eb 33 jmp 109dbd <_CORE_mutex_Seize+0x89>
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
* This routine grows @a the_heap memory area using the size bytes which
109d8a: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi)
109d91: 8b 15 58 d8 11 00 mov 0x11d858,%edx
109d97: 89 72 44 mov %esi,0x44(%edx)
109d9a: 8b 45 0c mov 0xc(%ebp),%eax
109d9d: 89 42 20 mov %eax,0x20(%edx)
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
109da0: a1 98 d7 11 00 mov 0x11d798,%eax
109da5: 40 inc %eax
109da6: a3 98 d7 11 00 mov %eax,0x11d798
109dab: ff 75 18 pushl 0x18(%ebp)
109dae: 9d popf
109daf: 53 push %ebx
109db0: 53 push %ebx
109db1: ff 75 14 pushl 0x14(%ebp)
109db4: 56 push %esi
109db5: e8 2e ff ff ff call 109ce8 <_CORE_mutex_Seize_interrupt_blocking>
109dba: 83 c4 10 add $0x10,%esp
}
109dbd: 8d 65 f8 lea -0x8(%ebp),%esp
109dc0: 5b pop %ebx
109dc1: 5e pop %esi
109dc2: c9 leave
109dc3: c3 ret
0010de60 <_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
)
{
10de60: 55 push %ebp
10de61: 89 e5 mov %esp,%ebp
10de63: 56 push %esi
10de64: 53 push %ebx
10de65: 8b 4d 08 mov 0x8(%ebp),%ecx
bool _Protected_heap_Get_block_size(
Heap_Control *the_heap,
void *starting_address,
size_t *size
);
10de68: 8b 45 0c mov 0xc(%ebp),%eax
10de6b: 8b 30 mov (%eax),%esi
/**
* This function tries to resize in place the block that is pointed to by the
* @a starting_address to the new @a size.
*
10de6d: 8b 15 58 d8 11 00 mov 0x11d858,%edx
* @param[in] the_heap is the heap to operate upon
10de73: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
* @param[in] starting_address is the starting address of the user block
10de7a: 83 79 50 00 cmpl $0x0,0x50(%ecx)
10de7e: 0f 84 82 00 00 00 je 10df06 <_CORE_mutex_Seize_interrupt_trylock+0xa6>
* to be resized
10de84: c7 41 50 00 00 00 00 movl $0x0,0x50(%ecx)
* @param[in] size is the new size
10de8b: 89 51 5c mov %edx,0x5c(%ecx)
*
10de8e: 8b 42 08 mov 0x8(%edx),%eax
10de91: 89 41 60 mov %eax,0x60(%ecx)
* @return TRUE if successfully able to resize the block.
10de94: c7 41 54 01 00 00 00 movl $0x1,0x54(%ecx)
/**
* This function attempts to allocate a memory block of @a size bytes from
* @a the_heap so that the start of the user memory is aligned on the
* @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT.
* Any other value of @a alignment is taken "as is", i.e., even odd
10de9b: 8b 41 48 mov 0x48(%ecx),%eax
* @param[in] starting_address is the starting address of the user block
* to be resized
* @param[in] size is the new size
*
* @return TRUE if successfully able to resize the block.
* FALSE if the block can't be resized in place.
10de9e: 83 f8 02 cmp $0x2,%eax
10dea1: 74 05 je 10dea8 <_CORE_mutex_Seize_interrupt_trylock+0x48>
10dea3: 83 f8 03 cmp $0x3,%eax
10dea6: 75 03 jne 10deab <_CORE_mutex_Seize_interrupt_trylock+0x4b>
void *starting_address,
size_t size
);
/**
* This routine returns the block of memory which begins
10dea8: ff 42 1c incl 0x1c(%edx)
* at @a starting_address to @a the_heap. Any coalescing which is
* possible with the freeing of this routine is performed.
*
10deab: 83 79 48 03 cmpl $0x3,0x48(%ecx)
10deaf: 74 04 je 10deb5 <_CORE_mutex_Seize_interrupt_trylock+0x55>
* @param[in] the_heap is the heap to operate upon
10deb1: 56 push %esi
10deb2: 9d popf
10deb3: eb 74 jmp 10df29 <_CORE_mutex_Seize_interrupt_trylock+0xc9>
void *start_address
);
/**
* This routine walks the heap to verify its integrity.
*
10deb5: 8b 42 14 mov 0x14(%edx),%eax
* @param[in] the_heap is the heap to operate upon
10deb8: 3b 41 4c cmp 0x4c(%ecx),%eax
10debb: 75 04 jne 10dec1 <_CORE_mutex_Seize_interrupt_trylock+0x61><== ALWAYS TAKEN
* @param[in] source is a user specified integer which may be used to
10debd: 56 push %esi <== NOT EXECUTED
10debe: 9d popf <== NOT EXECUTED
10debf: eb 68 jmp 10df29 <_CORE_mutex_Seize_interrupt_trylock+0xc9><== NOT EXECUTED
* indicate where in the application this was invoked from
* @param[in] do_dump is set to TRUE if errors should be printed
* @return TRUE if the test passed fine, FALSE otherwise.
*/
10dec1: 76 27 jbe 10deea <_CORE_mutex_Seize_interrupt_trylock+0x8a>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10dec3: a1 98 d7 11 00 mov 0x11d798,%eax
10dec8: 40 inc %eax
10dec9: a3 98 d7 11 00 mov %eax,0x11d798
* indicate where in the application this was invoked from
* @param[in] do_dump is set to TRUE if errors should be printed
* @return TRUE if the test passed fine, FALSE otherwise.
*/
bool _Protected_heap_Walk(
Heap_Control *the_heap,
10dece: 56 push %esi
10decf: 9d popf
int source,
10ded0: 50 push %eax
10ded1: 6a 00 push $0x0
10ded3: ff 71 4c pushl 0x4c(%ecx)
10ded6: ff 71 5c pushl 0x5c(%ecx)
10ded9: e8 0e cb ff ff call 10a9ec <_Thread_Change_priority>
bool do_dump
);
/**
* This routine walks the heap and tots up the free and allocated
10dede: e8 a9 cf ff ff call 10ae8c <_Thread_Enable_dispatch>
10dee3: 31 c0 xor %eax,%eax
10dee5: 83 c4 10 add $0x10,%esp
10dee8: eb 48 jmp 10df32 <_CORE_mutex_Seize_interrupt_trylock+0xd2>
* sizes.
*
* @param[in] the_heap pointer to heap header
* @param[in] the_info pointer to a status information area
10deea: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx)
*
10def1: c7 41 50 01 00 00 00 movl $0x1,0x50(%ecx)
* @return true if successfully able to return information
10def8: c7 41 54 00 00 00 00 movl $0x0,0x54(%ecx)
*/
10deff: ff 4a 1c decl 0x1c(%edx)
bool _Protected_heap_Get_information(
10df02: 56 push %esi
10df03: 9d popf
10df04: eb 23 jmp 10df29 <_CORE_mutex_Seize_interrupt_trylock+0xc9>
* in the specified heap.
*
* @param[in] the_heap pointer to heap header.
* @param[in] info pointer to the free block information.
*
* @return free block information filled in.
10df06: 8b 59 5c mov 0x5c(%ecx),%ebx
10df09: 39 d3 cmp %edx,%ebx
10df0b: 75 20 jne 10df2d <_CORE_mutex_Seize_interrupt_trylock+0xcd>
*/
10df0d: 8b 41 40 mov 0x40(%ecx),%eax
10df10: 85 c0 test %eax,%eax
10df12: 74 05 je 10df19 <_CORE_mutex_Seize_interrupt_trylock+0xb9>
10df14: 48 dec %eax
10df15: 75 16 jne 10df2d <_CORE_mutex_Seize_interrupt_trylock+0xcd>
10df17: eb 07 jmp 10df20 <_CORE_mutex_Seize_interrupt_trylock+0xc0>
bool _Protected_heap_Get_free_information(
Heap_Control *the_heap,
10df19: ff 41 54 incl 0x54(%ecx)
Heap_Information *info
10df1c: 56 push %esi
10df1d: 9d popf
10df1e: eb 09 jmp 10df29 <_CORE_mutex_Seize_interrupt_trylock+0xc9>
);
#ifdef __cplusplus
10df20: c7 43 34 02 00 00 00 movl $0x2,0x34(%ebx)
}
10df27: 56 push %esi
10df28: 9d popf
10df29: 31 c0 xor %eax,%eax
10df2b: eb 05 jmp 10df32 <_CORE_mutex_Seize_interrupt_trylock+0xd2>
10df2d: b8 01 00 00 00 mov $0x1,%eax
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}
10df32: 8d 65 f8 lea -0x8(%ebp),%esp
10df35: 5b pop %ebx
10df36: 5e pop %esi
10df37: c9 leave
10df38: c3 ret
00109dc4 <_CORE_mutex_Surrender>:
CORE_mutex_Status _CORE_mutex_Surrender(
CORE_mutex_Control *the_mutex,
Objects_Id id,
CORE_mutex_API_mp_support_callout api_mutex_mp_support
)
{
109dc4: 55 push %ebp
109dc5: 89 e5 mov %esp,%ebp
109dc7: 53 push %ebx
109dc8: 83 ec 04 sub $0x4,%esp
109dcb: 8b 5d 08 mov 0x8(%ebp),%ebx
Thread_Control *the_thread;
Thread_Control *holder;
#ifdef __RTEMS_STRICT_ORDER_MUTEX__
Chain_Node *first_node;
#endif
holder = the_mutex->holder;
109dce: 8b 4b 5c mov 0x5c(%ebx),%ecx
* 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 ) {
109dd1: 80 7b 44 00 cmpb $0x0,0x44(%ebx)
109dd5: 74 11 je 109de8 <_CORE_mutex_Surrender+0x24>
if ( !_Thread_Is_executing( holder ) )
109dd7: b8 03 00 00 00 mov $0x3,%eax
109ddc: 3b 0d 58 d8 11 00 cmp 0x11d858,%ecx
109de2: 0f 85 cb 00 00 00 jne 109eb3 <_CORE_mutex_Surrender+0xef>
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
}
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
109de8: 8b 43 54 mov 0x54(%ebx),%eax
109deb: 85 c0 test %eax,%eax
109ded: 0f 84 be 00 00 00 je 109eb1 <_CORE_mutex_Surrender+0xed>
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
109df3: 48 dec %eax
109df4: 89 43 54 mov %eax,0x54(%ebx)
if ( the_mutex->nest_count != 0 ) {
109df7: 85 c0 test %eax,%eax
109df9: 74 17 je 109e12 <_CORE_mutex_Surrender+0x4e>
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
109dfb: 8b 53 40 mov 0x40(%ebx),%edx
109dfe: 85 d2 test %edx,%edx
109e00: 0f 84 ab 00 00 00 je 109eb1 <_CORE_mutex_Surrender+0xed><== ALWAYS TAKEN
109e06: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED
109e0b: 4a dec %edx <== NOT EXECUTED
109e0c: 0f 84 a1 00 00 00 je 109eb3 <_CORE_mutex_Surrender+0xef><== NOT EXECUTED
/**
* This function attempts to allocate a memory block of @a size bytes from
* @a the_heap so that the start of the user memory is aligned on the
* @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT.
* Any other value of @a alignment is taken "as is", i.e., even odd
109e12: 8b 43 48 mov 0x48(%ebx),%eax
/*
* Formally release the mutex before possibly transferring it to a
* blocked thread.
*/
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
109e15: 83 f8 02 cmp $0x2,%eax
109e18: 74 05 je 109e1f <_CORE_mutex_Surrender+0x5b>
109e1a: 83 f8 03 cmp $0x3,%eax
109e1d: 75 03 jne 109e22 <_CORE_mutex_Surrender+0x5e>
the_mutex->nest_count++;
return CORE_MUTEX_RELEASE_NOT_ORDER;
}
first_node = _Chain_Get_first_unprotected(&holder->lock_mutex);
#endif
holder->resource_count--;
109e1f: ff 49 1c decl 0x1c(%ecx)
}
the_mutex->holder = NULL;
109e22: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
the_mutex->holder_id = 0;
109e29: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
109e30: 8b 43 48 mov 0x48(%ebx),%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 ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
109e33: 83 f8 02 cmp $0x2,%eax
109e36: 74 05 je 109e3d <_CORE_mutex_Surrender+0x79>
109e38: 83 f8 03 cmp $0x3,%eax
109e3b: 75 1b jne 109e58 <_CORE_mutex_Surrender+0x94>
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
#ifdef __RTEMS_STRICT_ORDER_MUTEX__
if(the_mutex->queue.priority_before != holder->current_priority)
_Thread_Change_priority(holder,the_mutex->queue.priority_before,TRUE);
#endif
if ( holder->resource_count == 0 &&
109e3d: 83 79 1c 00 cmpl $0x0,0x1c(%ecx)
109e41: 75 15 jne 109e58 <_CORE_mutex_Surrender+0x94>
109e43: 8b 41 18 mov 0x18(%ecx),%eax
109e46: 3b 41 14 cmp 0x14(%ecx),%eax
109e49: 74 0d je 109e58 <_CORE_mutex_Surrender+0x94>
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, TRUE );
109e4b: 52 push %edx
109e4c: 6a 01 push $0x1
109e4e: 50 push %eax
109e4f: 51 push %ecx
109e50: e8 97 0b 00 00 call 10a9ec <_Thread_Change_priority>
109e55: 83 c4 10 add $0x10,%esp
/*
* 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 ) ) ) {
109e58: 83 ec 0c sub $0xc,%esp
109e5b: 53 push %ebx
109e5c: e8 63 13 00 00 call 10b1c4 <_Thread_queue_Dequeue>
109e61: 89 c2 mov %eax,%edx
109e63: 83 c4 10 add $0x10,%esp
109e66: 85 c0 test %eax,%eax
109e68: 74 40 je 109eaa <_CORE_mutex_Surrender+0xe6>
} else
#endif
{
the_mutex->holder = the_thread;
109e6a: 89 43 5c mov %eax,0x5c(%ebx)
the_mutex->holder_id = the_thread->Object.id;
109e6d: 8b 40 08 mov 0x8(%eax),%eax
109e70: 89 43 60 mov %eax,0x60(%ebx)
the_mutex->nest_count = 1;
109e73: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx)
switch ( the_mutex->Attributes.discipline ) {
109e7a: 8b 43 48 mov 0x48(%ebx),%eax
109e7d: 83 f8 02 cmp $0x2,%eax
109e80: 74 07 je 109e89 <_CORE_mutex_Surrender+0xc5>
109e82: 83 f8 03 cmp $0x3,%eax
109e85: 75 2a jne 109eb1 <_CORE_mutex_Surrender+0xed>
109e87: eb 05 jmp 109e8e <_CORE_mutex_Surrender+0xca>
case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
#ifdef __RTEMS_STRICT_ORDER_MUTEX__
_Chain_Prepend_unprotected(&the_thread->lock_mutex,&the_mutex->queue.lock_queue);
the_mutex->queue.priority_before = the_thread->current_priority;
#endif
the_thread->resource_count++;
109e89: ff 42 1c incl 0x1c(%edx)
109e8c: eb 23 jmp 109eb1 <_CORE_mutex_Surrender+0xed>
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
#ifdef __RTEMS_STRICT_ORDER_MUTEX__
_Chain_Prepend_unprotected(&the_thread->lock_mutex,&the_mutex->queue.lock_queue);
the_mutex->queue.priority_before = the_thread->current_priority;
#endif
the_thread->resource_count++;
109e8e: ff 42 1c incl 0x1c(%edx)
if (the_mutex->Attributes.priority_ceiling <
109e91: 8b 43 4c mov 0x4c(%ebx),%eax
109e94: 3b 42 14 cmp 0x14(%edx),%eax
109e97: 73 18 jae 109eb1 <_CORE_mutex_Surrender+0xed><== NEVER TAKEN
the_thread->current_priority){
_Thread_Change_priority(
109e99: 51 push %ecx
109e9a: 6a 00 push $0x0
109e9c: 50 push %eax
109e9d: 52 push %edx
109e9e: e8 49 0b 00 00 call 10a9ec <_Thread_Change_priority>
109ea3: 31 c0 xor %eax,%eax
109ea5: 83 c4 10 add $0x10,%esp
109ea8: eb 09 jmp 109eb3 <_CORE_mutex_Surrender+0xef>
}
break;
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
109eaa: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx)
109eb1: 31 c0 xor %eax,%eax
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
109eb3: 8b 5d fc mov -0x4(%ebp),%ebx
109eb6: c9 leave
109eb7: c3 ret
00109f04 <_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
)
{
109f04: 55 push %ebp
109f05: 89 e5 mov %esp,%ebp
109f07: 53 push %ebx
109f08: 83 ec 10 sub $0x10,%esp
109f0b: 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)) ) {
109f0e: 53 push %ebx
109f0f: e8 b0 12 00 00 call 10b1c4 <_Thread_queue_Dequeue>
109f14: 83 c4 10 add $0x10,%esp
109f17: 31 d2 xor %edx,%edx
109f19: 85 c0 test %eax,%eax
109f1b: 75 18 jne 109f35 <_CORE_semaphore_Surrender+0x31>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
109f1d: 9c pushf
109f1e: fa cli
109f1f: 59 pop %ecx
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
109f20: 8b 43 48 mov 0x48(%ebx),%eax
109f23: ba 04 00 00 00 mov $0x4,%edx
109f28: 3b 43 40 cmp 0x40(%ebx),%eax
109f2b: 73 06 jae 109f33 <_CORE_semaphore_Surrender+0x2f><== NEVER TAKEN
the_semaphore->count += 1;
109f2d: 40 inc %eax
109f2e: 89 43 48 mov %eax,0x48(%ebx)
109f31: 31 d2 xor %edx,%edx
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
109f33: 51 push %ecx
109f34: 9d popf
}
return status;
}
109f35: 89 d0 mov %edx,%eax
109f37: 8b 5d fc mov -0x4(%ebp),%ebx
109f3a: c9 leave
109f3b: c3 ret
0010a750 <_CORE_spinlock_Release>:
*/
CORE_spinlock_Status _CORE_spinlock_Release(
CORE_spinlock_Control *the_spinlock
)
{
10a750: 55 push %ebp
10a751: 89 e5 mov %esp,%ebp
10a753: 53 push %ebx
10a754: 8b 4d 08 mov 0x8(%ebp),%ecx
ISR_Level level;
_ISR_Disable( level );
10a757: 9c pushf
10a758: fa cli
10a759: 5b pop %ebx
/*
* It must locked before it can be unlocked.
*/
if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) {
10a75a: 8b 41 04 mov 0x4(%ecx),%eax
10a75d: 85 c0 test %eax,%eax
10a75f: 75 06 jne 10a767 <_CORE_spinlock_Release+0x17>
_ISR_Enable( level );
10a761: 53 push %ebx
10a762: 9d popf
10a763: b0 06 mov $0x6,%al
10a765: eb 2f jmp 10a796 <_CORE_spinlock_Release+0x46>
}
/*
* It must locked by the current thread before it can be unlocked.
*/
if ( the_spinlock->holder != _Thread_Executing->Object.id ) {
10a767: 8b 51 0c mov 0xc(%ecx),%edx
10a76a: a1 d8 e7 11 00 mov 0x11e7d8,%eax
10a76f: 3b 50 08 cmp 0x8(%eax),%edx
10a772: 74 09 je 10a77d <_CORE_spinlock_Release+0x2d><== ALWAYS TAKEN
_ISR_Enable( level );
10a774: 53 push %ebx <== NOT EXECUTED
10a775: 9d popf <== NOT EXECUTED
10a776: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED
10a77b: eb 19 jmp 10a796 <_CORE_spinlock_Release+0x46><== NOT EXECUTED
}
/*
* Let it be unlocked.
*/
the_spinlock->users -= 1;
10a77d: 8b 41 08 mov 0x8(%ecx),%eax
10a780: 48 dec %eax
10a781: 89 41 08 mov %eax,0x8(%ecx)
the_spinlock->lock = CORE_SPINLOCK_UNLOCKED;
10a784: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx)
the_spinlock->holder = 0;
10a78b: c7 41 0c 00 00 00 00 movl $0x0,0xc(%ecx)
_ISR_Enable( level );
10a792: 53 push %ebx
10a793: 9d popf
10a794: 31 c0 xor %eax,%eax
return CORE_SPINLOCK_SUCCESSFUL;
}
10a796: 5b pop %ebx
10a797: c9 leave
10a798: c3 ret
0010a79c <_CORE_spinlock_Wait>:
CORE_spinlock_Status _CORE_spinlock_Wait(
CORE_spinlock_Control *the_spinlock,
bool wait,
Watchdog_Interval timeout
)
{
10a79c: 55 push %ebp
10a79d: 89 e5 mov %esp,%ebp
10a79f: 57 push %edi
10a7a0: 56 push %esi
10a7a1: 53 push %ebx
10a7a2: 83 ec 0c sub $0xc,%esp
10a7a5: 8b 5d 08 mov 0x8(%ebp),%ebx
10a7a8: 8b 7d 10 mov 0x10(%ebp),%edi
10a7ab: 8a 45 0c mov 0xc(%ebp),%al
10a7ae: 88 45 f3 mov %al,-0xd(%ebp)
ISR_Level level;
Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout;
10a7b1: a1 68 e8 11 00 mov 0x11e868,%eax
10a7b6: 8d 34 07 lea (%edi,%eax,1),%esi
_ISR_Disable( level );
10a7b9: 9c pushf
10a7ba: fa cli
10a7bb: 59 pop %ecx
if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) &&
10a7bc: 8b 43 04 mov 0x4(%ebx),%eax
10a7bf: 48 dec %eax
10a7c0: 75 16 jne 10a7d8 <_CORE_spinlock_Wait+0x3c>
10a7c2: 8b 53 0c mov 0xc(%ebx),%edx
10a7c5: a1 d8 e7 11 00 mov 0x11e7d8,%eax
10a7ca: 3b 50 08 cmp 0x8(%eax),%edx
10a7cd: 75 09 jne 10a7d8 <_CORE_spinlock_Wait+0x3c>
(the_spinlock->holder == _Thread_Executing->Object.id) ) {
_ISR_Enable( level );
10a7cf: 51 push %ecx
10a7d0: 9d popf
10a7d1: b8 01 00 00 00 mov $0x1,%eax
10a7d6: eb 70 jmp 10a848 <_CORE_spinlock_Wait+0xac>
return CORE_SPINLOCK_HOLDER_RELOCKING;
}
the_spinlock->users += 1;
10a7d8: 8b 43 08 mov 0x8(%ebx),%eax
10a7db: 40 inc %eax
10a7dc: 89 43 08 mov %eax,0x8(%ebx)
for ( ;; ) {
if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) {
10a7df: 8b 43 04 mov 0x4(%ebx),%eax
10a7e2: 85 c0 test %eax,%eax
10a7e4: 75 18 jne 10a7fe <_CORE_spinlock_Wait+0x62>
the_spinlock->lock = CORE_SPINLOCK_LOCKED;
10a7e6: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx)
the_spinlock->holder = _Thread_Executing->Object.id;
10a7ed: a1 d8 e7 11 00 mov 0x11e7d8,%eax
10a7f2: 8b 40 08 mov 0x8(%eax),%eax
10a7f5: 89 43 0c mov %eax,0xc(%ebx)
_ISR_Enable( level );
10a7f8: 51 push %ecx
10a7f9: 9d popf
10a7fa: 31 c0 xor %eax,%eax
10a7fc: eb 4a jmp 10a848 <_CORE_spinlock_Wait+0xac>
}
/*
* Spinlock is unavailable. If not willing to wait, return.
*/
if ( !wait ) {
10a7fe: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
10a802: 75 10 jne 10a814 <_CORE_spinlock_Wait+0x78><== ALWAYS TAKEN
the_spinlock->users -= 1;
10a804: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED
10a807: 48 dec %eax <== NOT EXECUTED
10a808: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED
_ISR_Enable( level );
10a80b: 51 push %ecx <== NOT EXECUTED
10a80c: 9d popf <== NOT EXECUTED
10a80d: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED
10a812: eb 34 jmp 10a848 <_CORE_spinlock_Wait+0xac><== NOT EXECUTED
}
/*
* They are willing to wait but there could be a timeout.
*/
if ( timeout && (limit <= _Watchdog_Ticks_since_boot) ) {
10a814: 85 ff test %edi,%edi
10a816: 74 19 je 10a831 <_CORE_spinlock_Wait+0x95><== ALWAYS TAKEN
10a818: a1 68 e8 11 00 mov 0x11e868,%eax <== NOT EXECUTED
10a81d: 39 c6 cmp %eax,%esi <== NOT EXECUTED
10a81f: 77 10 ja 10a831 <_CORE_spinlock_Wait+0x95><== NOT EXECUTED
the_spinlock->users -= 1;
10a821: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED
10a824: 48 dec %eax <== NOT EXECUTED
10a825: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED
_ISR_Enable( level );
10a828: 51 push %ecx <== NOT EXECUTED
10a829: 9d popf <== NOT EXECUTED
10a82a: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED
10a82f: eb 17 jmp 10a848 <_CORE_spinlock_Wait+0xac><== NOT EXECUTED
*
* A spinlock cannot be deleted while it is being used so we are
* safe from deletion.
*/
_ISR_Enable( level );
10a831: 51 push %ecx
10a832: 9d popf
/* An ISR could occur here */
_Thread_Enable_dispatch();
10a833: e8 68 0f 00 00 call 10b7a0 <_Thread_Enable_dispatch>
10a838: a1 18 e7 11 00 mov 0x11e718,%eax
10a83d: 40 inc %eax
10a83e: a3 18 e7 11 00 mov %eax,0x11e718
/* Another thread could get dispatched here */
/* Reenter the critical sections so we can attempt the lock again. */
_Thread_Disable_dispatch();
_ISR_Disable( level );
10a843: 9c pushf
10a844: fa cli
10a845: 59 pop %ecx
10a846: eb 97 jmp 10a7df <_CORE_spinlock_Wait+0x43>
}
}
10a848: 83 c4 0c add $0xc,%esp
10a84b: 5b pop %ebx
10a84c: 5e pop %esi
10a84d: 5f pop %edi
10a84e: c9 leave
10a84f: c3 ret
0010dcf1 <_Debug_Is_enabled>:
*/
bool _Debug_Is_enabled(
rtems_debug_control level
)
{
10dcf1: 55 push %ebp <== NOT EXECUTED
10dcf2: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10dcf4: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10dcf7: 85 05 5c d8 11 00 test %eax,0x11d85c <== NOT EXECUTED
10dcfd: 0f 95 c0 setne %al <== NOT EXECUTED
return (_Debug_Level & level) ? true : false;
}
10dd00: c9 leave <== NOT EXECUTED
10dd01: c3 ret <== NOT EXECUTED
00108bcc <_Event_Seize>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
108bcc: 55 push %ebp
108bcd: 89 e5 mov %esp,%ebp
108bcf: 57 push %edi
108bd0: 56 push %esi
108bd1: 53 push %ebx
108bd2: 83 ec 0c sub $0xc,%esp
108bd5: 8b 45 08 mov 0x8(%ebp),%eax
108bd8: 8b 75 0c mov 0xc(%ebp),%esi
108bdb: 8b 55 10 mov 0x10(%ebp),%edx
108bde: 89 55 ec mov %edx,-0x14(%ebp)
108be1: 8b 4d 14 mov 0x14(%ebp),%ecx
108be4: 89 4d e8 mov %ecx,-0x18(%ebp)
rtems_event_set pending_events;
ISR_Level level;
RTEMS_API_Control *api;
Thread_blocking_operation_States sync_state;
executing = _Thread_Executing;
108be7: 8b 1d 58 d8 11 00 mov 0x11d858,%ebx
executing->Wait.return_code = RTEMS_SUCCESSFUL;
108bed: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx)
api = executing->API_Extensions[ THREAD_API_RTEMS ];
108bf4: 8b 93 f4 00 00 00 mov 0xf4(%ebx),%edx
108bfa: 89 55 f0 mov %edx,-0x10(%ebp)
_ISR_Disable( level );
108bfd: 9c pushf
108bfe: fa cli
108bff: 5f pop %edi
pending_events = api->pending_events;
108c00: 8b 4d f0 mov -0x10(%ebp),%ecx
108c03: 8b 11 mov (%ecx),%edx
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
108c05: 89 c1 mov %eax,%ecx
108c07: 21 d1 and %edx,%ecx
108c09: 74 23 je 108c2e <_Event_Seize+0x62>
108c0b: 39 c1 cmp %eax,%ecx
108c0d: 74 08 je 108c17 <_Event_Seize+0x4b>
108c0f: f7 c6 02 00 00 00 test $0x2,%esi
108c15: 74 17 je 108c2e <_Event_Seize+0x62> <== NEVER TAKEN
(seized_events == event_in || _Options_Is_any( option_set )) ) {
api->pending_events =
108c17: 89 c8 mov %ecx,%eax
108c19: f7 d0 not %eax
108c1b: 21 d0 and %edx,%eax
108c1d: 8b 55 f0 mov -0x10(%ebp),%edx
108c20: 89 02 mov %eax,(%edx)
_Event_sets_Clear( pending_events, seized_events );
_ISR_Enable( level );
108c22: 57 push %edi
108c23: 9d popf
*event_out = seized_events;
108c24: 8b 45 e8 mov -0x18(%ebp),%eax
108c27: 89 08 mov %ecx,(%eax)
108c29: e9 ad 00 00 00 jmp 108cdb <_Event_Seize+0x10f>
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
108c2e: f7 c6 01 00 00 00 test $0x1,%esi
108c34: 74 13 je 108c49 <_Event_Seize+0x7d>
_ISR_Enable( level );
108c36: 57 push %edi
108c37: 9d popf
executing->Wait.return_code = RTEMS_UNSATISFIED;
108c38: c7 43 34 0d 00 00 00 movl $0xd,0x34(%ebx)
*event_out = seized_events;
108c3f: 8b 55 e8 mov -0x18(%ebp),%edx
108c42: 89 0a mov %ecx,(%edx)
108c44: e9 92 00 00 00 jmp 108cdb <_Event_Seize+0x10f>
return;
}
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
108c49: c7 05 8c e0 11 00 01 movl $0x1,0x11e08c
108c50: 00 00 00
executing->Wait.option = (uint32_t) option_set;
108c53: 89 73 30 mov %esi,0x30(%ebx)
executing->Wait.count = (uint32_t) event_in;
108c56: 89 43 24 mov %eax,0x24(%ebx)
executing->Wait.return_argument = event_out;
108c59: 8b 4d e8 mov -0x18(%ebp),%ecx
108c5c: 89 4b 28 mov %ecx,0x28(%ebx)
_ISR_Enable( level );
108c5f: 57 push %edi
108c60: 9d popf
if ( ticks ) {
108c61: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
108c65: 74 34 je 108c9b <_Event_Seize+0xcf>
_Watchdog_Initialize(
108c67: 8b 43 08 mov 0x8(%ebx),%eax
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
108c6a: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
* @param[in] the_heap is the heap to operate upon
108c71: c7 43 64 1c 8e 10 00 movl $0x108e1c,0x64(%ebx)
* @param[in] starting_address is the starting address of the memory for
108c78: 89 43 68 mov %eax,0x68(%ebx)
* the heap
108c7b: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
Heap_Control *the_heap,
108c82: 8b 45 ec mov -0x14(%ebp),%eax
108c85: 89 43 54 mov %eax,0x54(%ebx)
void *starting_address,
size_t *size
108c88: 52 push %edx
108c89: 52 push %edx
108c8a: 8d 43 48 lea 0x48(%ebx),%eax
108c8d: 50 push %eax
108c8e: 68 78 d8 11 00 push $0x11d878
108c93: e8 90 2f 00 00 call 10bc28 <_Watchdog_Insert>
108c98: 83 c4 10 add $0x10,%esp
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
}
_Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
108c9b: 50 push %eax
108c9c: 50 push %eax
108c9d: 68 00 01 00 00 push $0x100
108ca2: 53 push %ebx
108ca3: e8 d4 29 00 00 call 10b67c <_Thread_Set_state>
_ISR_Disable( level );
108ca8: 9c pushf
108ca9: fa cli
108caa: 5a pop %edx
sync_state = _Event_Sync_state;
108cab: a1 8c e0 11 00 mov 0x11e08c,%eax
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
108cb0: c7 05 8c e0 11 00 00 movl $0x0,0x11e08c
108cb7: 00 00 00
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
108cba: 83 c4 10 add $0x10,%esp
108cbd: 83 f8 01 cmp $0x1,%eax
108cc0: 75 04 jne 108cc6 <_Event_Seize+0xfa>
_ISR_Enable( level );
108cc2: 52 push %edx
108cc3: 9d popf
108cc4: eb 15 jmp 108cdb <_Event_Seize+0x10f>
* 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 );
108cc6: 89 55 10 mov %edx,0x10(%ebp)
108cc9: 89 5d 0c mov %ebx,0xc(%ebp)
108ccc: 89 45 08 mov %eax,0x8(%ebp)
}
108ccf: 8d 65 f4 lea -0xc(%ebp),%esp
108cd2: 5b pop %ebx
108cd3: 5e pop %esi
108cd4: 5f pop %edi
108cd5: 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 );
108cd6: e9 c5 1c 00 00 jmp 10a9a0 <_Thread_blocking_operation_Cancel>
}
108cdb: 8d 65 f4 lea -0xc(%ebp),%esp
108cde: 5b pop %ebx
108cdf: 5e pop %esi
108ce0: 5f pop %edi
108ce1: c9 leave
108ce2: c3 ret
00108d30 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
108d30: 55 push %ebp
108d31: 89 e5 mov %esp,%ebp
108d33: 57 push %edi
108d34: 56 push %esi
108d35: 53 push %ebx
108d36: 83 ec 0c sub $0xc,%esp
108d39: 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 ];
108d3c: 8b 83 f4 00 00 00 mov 0xf4(%ebx),%eax
108d42: 89 45 f0 mov %eax,-0x10(%ebp)
option_set = (rtems_option) the_thread->Wait.option;
108d45: 8b 53 30 mov 0x30(%ebx),%edx
108d48: 89 55 ec mov %edx,-0x14(%ebp)
_ISR_Disable( level );
108d4b: 9c pushf
108d4c: fa cli
108d4d: 5f pop %edi
pending_events = api->pending_events;
108d4e: 8b 30 mov (%eax),%esi
event_condition = (rtems_event_set) the_thread->Wait.count;
108d50: 8b 53 24 mov 0x24(%ebx),%edx
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
108d53: 89 d1 mov %edx,%ecx
108d55: 21 f1 and %esi,%ecx
108d57: 75 07 jne 108d60 <_Event_Surrender+0x30>
_ISR_Enable( level );
108d59: 57 push %edi
108d5a: 9d popf
108d5b: e9 b1 00 00 00 jmp 108e11 <_Event_Surrender+0xe1>
/*
* 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() &&
108d60: a1 34 d8 11 00 mov 0x11d834,%eax
108d65: 85 c0 test %eax,%eax
108d67: 74 49 je 108db2 <_Event_Surrender+0x82>
108d69: 3b 1d 58 d8 11 00 cmp 0x11d858,%ebx
108d6f: 75 41 jne 108db2 <_Event_Surrender+0x82> <== NEVER TAKEN
108d71: a1 8c e0 11 00 mov 0x11e08c,%eax
108d76: 48 dec %eax
108d77: 74 0a je 108d83 <_Event_Surrender+0x53> <== ALWAYS TAKEN
108d79: a1 8c e0 11 00 mov 0x11e08c,%eax <== NOT EXECUTED
108d7e: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED
108d81: 75 2f jne 108db2 <_Event_Surrender+0x82> <== NOT EXECUTED
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
108d83: 39 d1 cmp %edx,%ecx
108d85: 74 06 je 108d8d <_Event_Surrender+0x5d> <== ALWAYS TAKEN
108d87: f6 45 ec 02 testb $0x2,-0x14(%ebp) <== NOT EXECUTED
108d8b: 74 21 je 108dae <_Event_Surrender+0x7e> <== NOT EXECUTED
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
108d8d: 89 c8 mov %ecx,%eax
108d8f: f7 d0 not %eax
108d91: 21 f0 and %esi,%eax
108d93: 8b 55 f0 mov -0x10(%ebp),%edx
108d96: 89 02 mov %eax,(%edx)
the_thread->Wait.count = 0;
108d98: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
108d9f: 8b 43 28 mov 0x28(%ebx),%eax
108da2: 89 08 mov %ecx,(%eax)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
108da4: c7 05 8c e0 11 00 03 movl $0x3,0x11e08c
108dab: 00 00 00
}
_ISR_Enable( level );
108dae: 57 push %edi
108daf: 9d popf
108db0: eb 5f jmp 108e11 <_Event_Surrender+0xe1>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
108db2: f6 43 11 01 testb $0x1,0x11(%ebx)
108db6: 74 57 je 108e0f <_Event_Surrender+0xdf> <== NEVER TAKEN
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
108db8: 39 d1 cmp %edx,%ecx
108dba: 74 06 je 108dc2 <_Event_Surrender+0x92>
108dbc: f6 45 ec 02 testb $0x2,-0x14(%ebp)
108dc0: 74 4d je 108e0f <_Event_Surrender+0xdf> <== NEVER TAKEN
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
108dc2: 89 c8 mov %ecx,%eax
108dc4: f7 d0 not %eax
108dc6: 21 f0 and %esi,%eax
108dc8: 8b 55 f0 mov -0x10(%ebp),%edx
108dcb: 89 02 mov %eax,(%edx)
the_thread->Wait.count = 0;
108dcd: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
108dd4: 8b 43 28 mov 0x28(%ebx),%eax
108dd7: 89 08 mov %ecx,(%eax)
_ISR_Flash( level );
108dd9: 57 push %edi
108dda: 9d popf
108ddb: fa cli
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
108ddc: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
108de0: 74 06 je 108de8 <_Event_Surrender+0xb8>
_ISR_Enable( level );
108de2: 57 push %edi
108de3: 9d popf
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
108de4: 51 push %ecx
108de5: 51 push %ecx
108de6: eb 17 jmp 108dff <_Event_Surrender+0xcf>
* a block of the requested size, then NULL is returned.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
* @return NULL if unsuccessful and a pointer to the block if successful
*/
108de8: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
108def: 57 push %edi
108df0: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
108df1: 83 ec 0c sub $0xc,%esp
108df4: 8d 43 48 lea 0x48(%ebx),%eax
108df7: 50 push %eax
108df8: e8 43 2f 00 00 call 10bd40 <_Watchdog_Remove>
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
108dfd: 58 pop %eax
108dfe: 5a pop %edx
108dff: 68 f8 ff 03 10 push $0x1003fff8
108e04: 53 push %ebx
108e05: e8 02 1d 00 00 call 10ab0c <_Thread_Clear_state>
108e0a: 83 c4 10 add $0x10,%esp
108e0d: eb 02 jmp 108e11 <_Event_Surrender+0xe1>
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
108e0f: 57 push %edi <== NOT EXECUTED
108e10: 9d popf <== NOT EXECUTED
}
108e11: 8d 65 f4 lea -0xc(%ebp),%esp
108e14: 5b pop %ebx
108e15: 5e pop %esi
108e16: 5f pop %edi
108e17: c9 leave
108e18: c3 ret
00108e1c <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
108e1c: 55 push %ebp
108e1d: 89 e5 mov %esp,%ebp
108e1f: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
108e22: 8d 45 fc lea -0x4(%ebp),%eax
108e25: 50 push %eax
108e26: ff 75 08 pushl 0x8(%ebp)
108e29: e8 7e 20 00 00 call 10aeac <_Thread_Get>
108e2e: 89 c2 mov %eax,%edx
switch ( location ) {
108e30: 83 c4 10 add $0x10,%esp
108e33: 83 7d fc 00 cmpl $0x0,-0x4(%ebp)
108e37: 75 5f jne 108e98 <_Event_Timeout+0x7c> <== NEVER TAKEN
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
_ISR_Disable( level );
108e39: 9c pushf
108e3a: fa cli
108e3b: 59 pop %ecx
if ( !the_thread->Wait.count ) { /* verify thread is waiting */
108e3c: 83 78 24 00 cmpl $0x0,0x24(%eax)
108e40: 75 0f jne 108e51 <_Event_Timeout+0x35> <== ALWAYS TAKEN
108e42: a1 98 d7 11 00 mov 0x11d798,%eax <== NOT EXECUTED
108e47: 48 dec %eax <== NOT EXECUTED
108e48: a3 98 d7 11 00 mov %eax,0x11d798 <== NOT EXECUTED
_Thread_Unnest_dispatch();
_ISR_Enable( level );
108e4d: 51 push %ecx <== NOT EXECUTED
108e4e: 9d popf <== NOT EXECUTED
108e4f: eb 47 jmp 108e98 <_Event_Timeout+0x7c> <== NOT EXECUTED
return;
}
the_thread->Wait.count = 0;
108e51: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
if ( _Thread_Is_executing( the_thread ) ) {
108e58: 3b 05 58 d8 11 00 cmp 0x11d858,%eax
108e5e: 75 14 jne 108e74 <_Event_Timeout+0x58>
Thread_blocking_operation_States sync = _Event_Sync_state;
108e60: a1 8c e0 11 00 mov 0x11e08c,%eax
if ( (sync == THREAD_BLOCKING_OPERATION_SYNCHRONIZED) ||
108e65: 83 f8 01 cmp $0x1,%eax
108e68: 77 0a ja 108e74 <_Event_Timeout+0x58> <== NEVER TAKEN
(sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
108e6a: c7 05 8c e0 11 00 02 movl $0x2,0x11e08c
108e71: 00 00 00
}
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
108e74: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx)
_ISR_Enable( level );
108e7b: 51 push %ecx
108e7c: 9d popf
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
108e7d: 50 push %eax
108e7e: 50 push %eax
108e7f: 68 f8 ff 03 10 push $0x1003fff8
108e84: 52 push %edx
108e85: e8 82 1c 00 00 call 10ab0c <_Thread_Clear_state>
108e8a: a1 98 d7 11 00 mov 0x11d798,%eax
108e8f: 48 dec %eax
108e90: a3 98 d7 11 00 mov %eax,0x11d798
108e95: 83 c4 10 add $0x10,%esp
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
108e98: c9 leave
108e99: c3 ret
0010df90 <_Heap_Allocate>:
void *_Heap_Allocate(
Heap_Control *the_heap,
size_t size
)
{
10df90: 55 push %ebp
10df91: 89 e5 mov %esp,%ebp
10df93: 57 push %edi
10df94: 56 push %esi
10df95: 53 push %ebx
10df96: 83 ec 10 sub $0x10,%esp
10df99: 8b 75 08 mov 0x8(%ebp),%esi
Heap_Block *the_block;
void *ptr = NULL;
Heap_Statistics *const stats = &the_heap->stats;
Heap_Block *const tail = _Heap_Tail(the_heap);
the_size =
10df9c: ff 76 14 pushl 0x14(%esi)
10df9f: ff 76 10 pushl 0x10(%esi)
10dfa2: ff 75 0c pushl 0xc(%ebp)
10dfa5: e8 91 c1 ff ff call 10a13b <_Heap_Calc_block_size>
_Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size);
if(the_size == 0)
10dfaa: 83 c4 10 add $0x10,%esp
10dfad: 31 d2 xor %edx,%edx
10dfaf: 85 c0 test %eax,%eax
10dfb1: 74 3c je 10dfef <_Heap_Allocate+0x5f> <== NEVER TAKEN
* @param[in] starting_address is the starting address of the memory
* to add to the heap
* @param[in] size is the size in bytes of the memory area to add
* @return a status indicating success or the reason for failure
*/
bool _Protected_heap_Extend(
10dfb3: 8b 5e 08 mov 0x8(%esi),%ebx
10dfb6: 31 ff xor %edi,%edi
10dfb8: eb 27 jmp 10dfe1 <_Heap_Allocate+0x51>
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
/* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the
result of the comparison. */
if(the_block->size >= the_size) {
10dfba: 39 43 04 cmp %eax,0x4(%ebx)
10dfbd: 72 1e jb 10dfdd <_Heap_Allocate+0x4d>
(void)_Heap_Block_allocate(the_heap, the_block, the_size );
10dfbf: 52 push %edx
10dfc0: 50 push %eax
10dfc1: 53 push %ebx
10dfc2: 56 push %esi
10dfc3: e8 b0 c1 ff ff call 10a178 <_Heap_Block_allocate>
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory for
* the heap
10dfc8: 8d 53 08 lea 0x8(%ebx),%edx
ptr = _Heap_User_area(the_block);
stats->allocs += 1;
10dfcb: ff 46 48 incl 0x48(%esi)
stats->searches += search_count + 1;
10dfce: 8b 46 4c mov 0x4c(%esi),%eax
10dfd1: 8d 44 07 01 lea 0x1(%edi,%eax,1),%eax
10dfd5: 89 46 4c mov %eax,0x4c(%esi)
10dfd8: 83 c4 10 add $0x10,%esp
10dfdb: eb 0a jmp 10dfe7 <_Heap_Allocate+0x57>
return NULL;
/* Find large enough free block. */
for(the_block = _Heap_First(the_heap), search_count = 0;
the_block != tail;
the_block = the_block->next, ++search_count)
10dfdd: 8b 5b 08 mov 0x8(%ebx),%ebx
10dfe0: 47 inc %edi
if(the_size == 0)
return NULL;
/* Find large enough free block. */
for(the_block = _Heap_First(the_heap), search_count = 0;
the_block != tail;
10dfe1: 39 f3 cmp %esi,%ebx
10dfe3: 75 d5 jne 10dfba <_Heap_Allocate+0x2a>
10dfe5: 31 d2 xor %edx,%edx
_HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size));
break;
}
}
if(stats->max_search < search_count)
10dfe7: 39 7e 44 cmp %edi,0x44(%esi)
10dfea: 73 03 jae 10dfef <_Heap_Allocate+0x5f>
stats->max_search = search_count;
10dfec: 89 7e 44 mov %edi,0x44(%esi)
return ptr;
}
10dfef: 89 d0 mov %edx,%eax
10dff1: 8d 65 f4 lea -0xc(%ebp),%esp
10dff4: 5b pop %ebx
10dff5: 5e pop %esi
10dff6: 5f pop %edi
10dff7: c9 leave
10dff8: c3 ret
0010b7f8 <_Heap_Allocate_aligned>:
void *_Heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
)
{
10b7f8: 55 push %ebp
10b7f9: 89 e5 mov %esp,%ebp
10b7fb: 57 push %edi
10b7fc: 56 push %esi
10b7fd: 53 push %ebx
10b7fe: 83 ec 30 sub $0x30,%esp
10b801: 8b 45 0c mov 0xc(%ebp),%eax
uint32_t search_count;
Heap_Block *the_block;
void *user_ptr = NULL;
uint32_t const page_size = the_heap->page_size;
10b804: 8b 55 08 mov 0x8(%ebp),%edx
10b807: 8b 52 10 mov 0x10(%edx),%edx
10b80a: 89 55 dc mov %edx,-0x24(%ebp)
Heap_Statistics *const stats = &the_heap->stats;
Heap_Block *const tail = _Heap_Tail(the_heap);
uint32_t const end_to_user_offs = size - HEAP_BLOCK_HEADER_OFFSET;
10b80d: 8d 48 fc lea -0x4(%eax),%ecx
10b810: 89 4d e0 mov %ecx,-0x20(%ebp)
uint32_t const the_size =
_Heap_Calc_block_size(size, page_size, the_heap->min_block_size);
10b813: 8b 55 08 mov 0x8(%ebp),%edx
10b816: ff 72 14 pushl 0x14(%edx)
10b819: ff 75 dc pushl -0x24(%ebp)
10b81c: 50 push %eax
10b81d: e8 2d 04 00 00 call 10bc4f <_Heap_Calc_block_size>
10b822: 89 45 e4 mov %eax,-0x1c(%ebp)
if(the_size == 0)
10b825: 83 c4 10 add $0x10,%esp
10b828: 31 c0 xor %eax,%eax
10b82a: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b82e: 0f 84 30 01 00 00 je 10b964 <_Heap_Allocate_aligned+0x16c><== NEVER TAKEN
return NULL;
if(alignment == 0)
10b834: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10b838: 75 07 jne 10b841 <_Heap_Allocate_aligned+0x49>
10b83a: c7 45 10 04 00 00 00 movl $0x4,0x10(%ebp)
)
{
return ( the_thread == _Thread_Heir );
}
/**
10b841: 8b 4d 08 mov 0x8(%ebp),%ecx
10b844: 8b 59 08 mov 0x8(%ecx),%ebx
10b847: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp)
10b84e: e9 f8 00 00 00 jmp 10b94b <_Heap_Allocate_aligned+0x153>
10b853: 8b 43 04 mov 0x4(%ebx),%eax
10b856: 83 e0 fe and $0xfffffffe,%eax
10b859: 89 45 e8 mov %eax,-0x18(%ebp)
uint32_t const block_size = _Heap_Block_size(the_block);
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
if(block_size >= the_size) { /* the_block is large enough. */
10b85c: 8b 55 e4 mov -0x1c(%ebp),%edx
10b85f: 39 d0 cmp %edx,%eax
10b861: 0f 82 de 00 00 00 jb 10b945 <_Heap_Allocate_aligned+0x14d>
_H_uptr_t user_addr;
_H_uptr_t aligned_user_addr;
_H_uptr_t const user_area = _H_p2u(_Heap_User_area(the_block));
10b867: 8d 4b 08 lea 0x8(%ebx),%ecx
/* Calculate 'aligned_user_addr' that will become the user pointer we
return. It should be at least 'end_to_user_offs' bytes less than the
the 'block_end' and should be aligned on 'alignment' boundary.
Calculations are from the 'block_end' as we are going to split free
block so that the upper part of the block becomes used block. */
_H_uptr_t const block_end = _H_p2u(the_block) + block_size;
10b86a: 01 d8 add %ebx,%eax
10b86c: 89 45 ec mov %eax,-0x14(%ebp)
aligned_user_addr = block_end - end_to_user_offs;
10b86f: 89 c6 mov %eax,%esi
10b871: 2b 75 e0 sub -0x20(%ebp),%esi
RTEMS_INLINE_ROUTINE void _Thread_Dispatch_initialization( void )
{
_Thread_Dispatch_disable_level = 1;
}
10b874: 89 f0 mov %esi,%eax
10b876: 31 d2 xor %edx,%edx
10b878: f7 75 10 divl 0x10(%ebp)
10b87b: 89 f7 mov %esi,%edi
10b87d: 29 d7 sub %edx,%edi
10b87f: 89 f8 mov %edi,%eax
10b881: 31 d2 xor %edx,%edx
10b883: f7 75 dc divl -0x24(%ebp)
10b886: 89 fe mov %edi,%esi
10b888: 29 d6 sub %edx,%esi
only at 'page_size' aligned addresses */
user_addr = aligned_user_addr;
_Heap_Align_down_uptr(&user_addr, page_size);
/* Make sure 'user_addr' calculated didn't run out of 'the_block'. */
if(user_addr >= user_area) {
10b88a: 39 ce cmp %ecx,%esi
10b88c: 0f 82 b3 00 00 00 jb 10b945 <_Heap_Allocate_aligned+0x14d>
/* The block seems to be acceptable. Check if the remainder of
'the_block' is less than 'min_block_size' so that 'the_block' won't
actually be split at the address we assume. */
if(user_addr - user_area < the_heap->min_block_size) {
10b892: 8b 55 08 mov 0x8(%ebp),%edx
10b895: 8b 52 14 mov 0x14(%edx),%edx
10b898: 89 55 f0 mov %edx,-0x10(%ebp)
10b89b: 89 f0 mov %esi,%eax
10b89d: 29 c8 sub %ecx,%eax
10b89f: 39 d0 cmp %edx,%eax
10b8a1: 73 2f jae 10b8d2 <_Heap_Allocate_aligned+0xda>
'aligned_user_addr' to be outside of [0,page_size) range. If we do,
we will need to store this distance somewhere to be able to
resurrect the block address from the user pointer. (Having the
distance within [0,page_size) range allows resurrection by
aligning user pointer down to the nearest 'page_size' boundary.) */
if(aligned_user_addr - user_addr >= page_size) {
10b8a3: 89 f8 mov %edi,%eax
10b8a5: 29 c8 sub %ecx,%eax
10b8a7: 89 ce mov %ecx,%esi
10b8a9: 3b 45 dc cmp -0x24(%ebp),%eax
10b8ac: 72 24 jb 10b8d2 <_Heap_Allocate_aligned+0xda>
RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void )
{
return ( _Thread_Dispatch_disable_level == 0 );
}
/**
10b8ae: 89 c8 mov %ecx,%eax
10b8b0: 31 d2 xor %edx,%edx
10b8b2: f7 75 10 divl 0x10(%ebp)
10b8b5: 89 d6 mov %edx,%esi
* This function returns TRUE if dispatching is disabled, and FALSE
10b8b7: 89 ca mov %ecx,%edx
10b8b9: 85 f6 test %esi,%esi
10b8bb: 74 08 je 10b8c5 <_Heap_Allocate_aligned+0xcd>
10b8bd: 8b 45 10 mov 0x10(%ebp),%eax
10b8c0: 8d 14 01 lea (%ecx,%eax,1),%edx
10b8c3: 29 f2 sub %esi,%edx
/* The user pointer will be too far from 'user_addr'. See if we
can make 'aligned_user_addr' to be close enough to the
'user_addr'. */
aligned_user_addr = user_addr;
_Heap_Align_up_uptr(&aligned_user_addr, alignment);
if(aligned_user_addr - user_addr >= page_size) {
10b8c5: 89 d0 mov %edx,%eax
10b8c7: 29 c8 sub %ecx,%eax
10b8c9: 3b 45 dc cmp -0x24(%ebp),%eax
10b8cc: 73 77 jae 10b945 <_Heap_Allocate_aligned+0x14d>
10b8ce: 89 ce mov %ecx,%esi
10b8d0: 89 d7 mov %edx,%edi
aligned_user_addr = 0;
}
}
}
if(aligned_user_addr) {
10b8d2: 85 ff test %edi,%edi
10b8d4: 74 6f je 10b945 <_Heap_Allocate_aligned+0x14d><== NEVER TAKEN
/* The block is indeed acceptable: calculate the size of the block
to be allocated and perform allocation. */
uint32_t const alloc_size =
block_end - user_addr + HEAP_BLOCK_USER_OFFSET;
10b8d6: 8b 55 ec mov -0x14(%ebp),%edx
10b8d9: 83 c2 08 add $0x8,%edx
10b8dc: 29 f2 sub %esi,%edx
Heap_Block *the_block,
uint32_t alloc_size)
{
Heap_Statistics *const stats = &the_heap->stats;
uint32_t const block_size = _Heap_Block_size(the_block);
uint32_t const the_rest = block_size - alloc_size;
10b8de: 8b 4d e8 mov -0x18(%ebp),%ecx
10b8e1: 29 d1 sub %edx,%ecx
_HAssert(_Heap_Is_aligned(block_size, the_heap->page_size));
_HAssert(_Heap_Is_aligned(alloc_size, the_heap->page_size));
_HAssert(alloc_size <= block_size);
_HAssert(_Heap_Is_prev_used(the_block));
if(the_rest >= the_heap->min_block_size) {
10b8e3: 3b 4d f0 cmp -0x10(%ebp),%ecx
10b8e6: 72 14 jb 10b8fc <_Heap_Allocate_aligned+0x104>
/* Split the block so that lower part is still free, and upper part
becomes used. */
the_block->size = the_rest | HEAP_PREV_USED;
10b8e8: 89 c8 mov %ecx,%eax
10b8ea: 83 c8 01 or $0x1,%eax
10b8ed: 89 43 04 mov %eax,0x4(%ebx)
Context_Control *context_p = &context_area;
if ( _System_state_Is_up(_System_state_Get ()) )
context_p = &_Thread_Executing->Registers;
_Context_Switch( context_p, &_Thread_BSP_context );
10b8f0: 8d 04 0b lea (%ebx,%ecx,1),%eax
/** @brief _Thread_Is_proxy_blocking
*
* status which indicates that a proxy is blocking, and FALSE otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking (
uint32_t code
10b8f3: 89 c3 mov %eax,%ebx
the_block = _Heap_Block_at(the_block, the_rest);
the_block->prev_size = the_rest;
10b8f5: 89 08 mov %ecx,(%eax)
the_block->size = alloc_size;
10b8f7: 89 50 04 mov %edx,0x4(%eax)
10b8fa: eb 15 jmp 10b911 <_Heap_Allocate_aligned+0x119>
* This routine resets the current context of the calling thread
* to that of its initial state.
*/
RTEMS_INLINE_ROUTINE void _Thread_Restart_self( void )
{
10b8fc: 8b 53 08 mov 0x8(%ebx),%edx
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
10b8ff: 8b 43 0c mov 0xc(%ebx),%eax
if ( _Thread_Executing->fp_context != NULL )
10b902: 89 50 08 mov %edx,0x8(%eax)
_Context_Restore_fp( &_Thread_Executing->fp_context );
10b905: 89 42 0c mov %eax,0xc(%edx)
/* Don't split the block as remainder is either zero or too small to be
used as a separate free block. Change 'alloc_size' to the size of the
block and remove the block from the list of free blocks. */
_Heap_Block_remove(the_block);
alloc_size = block_size;
stats->free_blocks -= 1;
10b908: 8b 55 08 mov 0x8(%ebp),%edx
10b90b: ff 4a 38 decl 0x38(%edx)
10b90e: 8b 55 e8 mov -0x18(%ebp),%edx
}
/* Mark the block as used (in the next block). */
_Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED;
10b911: 83 4c 13 04 01 orl $0x1,0x4(%ebx,%edx,1)
/* Update statistics */
stats->free_size -= alloc_size;
10b916: 8b 4d 08 mov 0x8(%ebp),%ecx
10b919: 8b 41 30 mov 0x30(%ecx),%eax
10b91c: 29 d0 sub %edx,%eax
10b91e: 89 41 30 mov %eax,0x30(%ecx)
if(stats->min_free_size > stats->free_size)
10b921: 39 41 34 cmp %eax,0x34(%ecx)
10b924: 76 03 jbe 10b929 <_Heap_Allocate_aligned+0x131>
stats->min_free_size = stats->free_size;
10b926: 89 41 34 mov %eax,0x34(%ecx)
stats->used_blocks += 1;
10b929: 8b 45 08 mov 0x8(%ebp),%eax
10b92c: ff 40 40 incl 0x40(%eax)
_HAssert(_Heap_Is_aligned_ptr((void*)aligned_user_addr, alignment));
the_block = block_allocate(the_heap, the_block, alloc_size);
stats->searches += search_count + 1;
10b92f: 89 c2 mov %eax,%edx
10b931: 8b 40 4c mov 0x4c(%eax),%eax
10b934: 8b 4d d8 mov -0x28(%ebp),%ecx
10b937: 8d 44 01 01 lea 0x1(%ecx,%eax,1),%eax
10b93b: 89 42 4c mov %eax,0x4c(%edx)
stats->allocs += 1;
10b93e: ff 42 48 incl 0x48(%edx)
check_result(the_heap, the_block, user_addr,
aligned_user_addr, size);
user_ptr = (void*)aligned_user_addr;
10b941: 89 f8 mov %edi,%eax
10b943: eb 11 jmp 10b956 <_Heap_Allocate_aligned+0x15e>
/* Find large enough free block that satisfies the alignment requirements. */
for(the_block = _Heap_First(the_heap), search_count = 0;
the_block != tail;
the_block = the_block->next, ++search_count)
10b945: 8b 5b 08 mov 0x8(%ebx),%ebx
10b948: ff 45 d8 incl -0x28(%ebp)
alignment = CPU_ALIGNMENT;
/* Find large enough free block that satisfies the alignment requirements. */
for(the_block = _Heap_First(the_heap), search_count = 0;
the_block != tail;
10b94b: 3b 5d 08 cmp 0x8(%ebp),%ebx
10b94e: 0f 85 ff fe ff ff jne 10b853 <_Heap_Allocate_aligned+0x5b>
10b954: 31 c0 xor %eax,%eax
}
}
}
}
if(stats->max_search < search_count)
10b956: 8b 55 d8 mov -0x28(%ebp),%edx
10b959: 8b 4d 08 mov 0x8(%ebp),%ecx
10b95c: 39 51 44 cmp %edx,0x44(%ecx)
10b95f: 73 03 jae 10b964 <_Heap_Allocate_aligned+0x16c>
stats->max_search = search_count;
10b961: 89 51 44 mov %edx,0x44(%ecx)
return user_ptr;
}
10b964: 8d 65 f4 lea -0xc(%ebp),%esp
10b967: 5b pop %ebx
10b968: 5e pop %esi
10b969: 5f pop %edi
10b96a: c9 leave
10b96b: c3 ret
0010ff58 <_Heap_Extend>:
Heap_Control *the_heap,
void *starting_address,
size_t size,
uint32_t *amount_extended
)
{
10ff58: 55 push %ebp
10ff59: 89 e5 mov %esp,%ebp
10ff5b: 57 push %edi
10ff5c: 56 push %esi
10ff5d: 53 push %ebx
10ff5e: 83 ec 0c sub $0xc,%esp
10ff61: 8b 4d 08 mov 0x8(%ebp),%ecx
10ff64: 8b 55 0c mov 0xc(%ebp),%edx
10ff67: 8b 75 10 mov 0x10(%ebp),%esi
* 5. non-contiguous higher address (NOT SUPPORTED)
*
* As noted, this code only supports (4).
*/
if ( starting_address >= the_heap->begin && /* case 3 */
10ff6a: 3b 51 18 cmp 0x18(%ecx),%edx
10ff6d: 72 0a jb 10ff79 <_Heap_Extend+0x21>
10ff6f: b8 01 00 00 00 mov $0x1,%eax
10ff74: 3b 51 1c cmp 0x1c(%ecx),%edx
10ff77: 72 5f jb 10ffd8 <_Heap_Extend+0x80>
starting_address < the_heap->end
)
return HEAP_EXTEND_ERROR;
if ( starting_address != the_heap->end )
10ff79: b8 02 00 00 00 mov $0x2,%eax
10ff7e: 3b 51 1c cmp 0x1c(%ecx),%edx
10ff81: 75 55 jne 10ffd8 <_Heap_Extend+0x80>
* Currently only case 4 should make it to this point.
* The basic trick is to make the extend area look like a used
* block and free it.
*/
old_final = the_heap->final;
10ff83: 8b 59 24 mov 0x24(%ecx),%ebx
Context_Control *context_p = &context_area;
if ( _System_state_Is_up(_System_state_Get ()) )
context_p = &_Thread_Executing->Registers;
_Context_Switch( context_p, &_Thread_BSP_context );
10ff86: 8d 04 32 lea (%edx,%esi,1),%eax
the_heap->end = _Addresses_Add_offset( the_heap->end, size );
10ff89: 89 41 1c mov %eax,0x1c(%ecx)
the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD;
10ff8c: 29 d8 sub %ebx,%eax
10ff8e: 8d 78 f8 lea -0x8(%eax),%edi
* the outer most dispatching critical section, then a dispatching
* operation will be performed and, if necessary, control of the
* processor will be transferred to the heir thread.
*/
#if ( (CPU_INLINE_ENABLE_DISPATCH == FALSE) || \
10ff91: 89 f8 mov %edi,%eax
10ff93: 31 d2 xor %edx,%edx
10ff95: f7 71 10 divl 0x10(%ecx)
10ff98: 29 d7 sub %edx,%edi
_Heap_Align_down( &the_size, the_heap->page_size );
*amount_extended = size;
10ff9a: 8b 45 14 mov 0x14(%ebp),%eax
10ff9d: 89 30 mov %esi,(%eax)
if( the_size < the_heap->min_block_size )
10ff9f: 31 c0 xor %eax,%eax
10ffa1: 3b 79 14 cmp 0x14(%ecx),%edi
10ffa4: 72 32 jb 10ffd8 <_Heap_Extend+0x80> <== NEVER TAKEN
return HEAP_EXTEND_SUCCESSFUL;
old_final->size = the_size | (old_final->size & HEAP_PREV_USED);
10ffa6: 8b 43 04 mov 0x4(%ebx),%eax
10ffa9: 83 e0 01 and $0x1,%eax
10ffac: 09 f8 or %edi,%eax
10ffae: 89 43 04 mov %eax,0x4(%ebx)
/** @brief _Thread_Is_proxy_blocking
*
* status which indicates that a proxy is blocking, and FALSE otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking (
uint32_t code
10ffb1: 8d 04 3b lea (%ebx,%edi,1),%eax
new_final = _Heap_Block_at( old_final, the_size );
new_final->size = HEAP_PREV_USED;
10ffb4: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
the_heap->final = new_final;
10ffbb: 89 41 24 mov %eax,0x24(%ecx)
stats->size += size;
10ffbe: 01 71 2c add %esi,0x2c(%ecx)
stats->used_blocks += 1;
10ffc1: ff 41 40 incl 0x40(%ecx)
stats->frees -= 1; /* Don't count subsequent call as actual free() */
10ffc4: ff 49 50 decl 0x50(%ecx)
_Heap_Free( the_heap, _Heap_User_area( old_final ) );
10ffc7: 50 push %eax
10ffc8: 50 push %eax
10ffc9: 8d 43 08 lea 0x8(%ebx),%eax
10ffcc: 50 push %eax
10ffcd: 51 push %ecx
10ffce: e8 05 ba ff ff call 10b9d8 <_Heap_Free>
10ffd3: 31 c0 xor %eax,%eax
10ffd5: 83 c4 10 add $0x10,%esp
return HEAP_EXTEND_SUCCESSFUL;
}
10ffd8: 8d 65 f4 lea -0xc(%ebp),%esp
10ffdb: 5b pop %ebx
10ffdc: 5e pop %esi
10ffdd: 5f pop %edi
10ffde: c9 leave
10ffdf: c3 ret
0010dffc <_Heap_Free>:
bool _Heap_Free(
Heap_Control *the_heap,
void *starting_address
)
{
10dffc: 55 push %ebp
10dffd: 89 e5 mov %esp,%ebp
10dfff: 57 push %edi
10e000: 56 push %esi
10e001: 53 push %ebx
10e002: 83 ec 14 sub $0x14,%esp
10e005: 8b 7d 08 mov 0x8(%ebp),%edi
10e008: 8b 4d 0c mov 0xc(%ebp),%ecx
uint32_t the_size;
uint32_t next_size;
Heap_Statistics *const stats = &the_heap->stats;
bool next_is_free;
if ( !_Addresses_Is_in_range(
10e00b: 8b 47 24 mov 0x24(%edi),%eax
10e00e: 89 45 e0 mov %eax,-0x20(%ebp)
10e011: 8b 57 20 mov 0x20(%edi),%edx
10e014: 89 55 e4 mov %edx,-0x1c(%ebp)
10e017: 39 d1 cmp %edx,%ecx
10e019: 0f 93 c2 setae %dl
10e01c: 39 c1 cmp %eax,%ecx
10e01e: 0f 96 c0 setbe %al
10e021: 84 d0 test %dl,%al
10e023: 0f 84 2f 01 00 00 je 10e158 <_Heap_Free+0x15c>
10e029: 8d 59 f8 lea -0x8(%ecx),%ebx
10e02c: 89 c8 mov %ecx,%eax
10e02e: 31 d2 xor %edx,%edx
10e030: f7 77 10 divl 0x10(%edi)
10e033: 29 d3 sub %edx,%ebx
return( FALSE );
}
_Heap_Start_of_block( the_heap, starting_address, &the_block );
if ( !_Heap_Is_block_in( the_heap, the_block ) ) {
10e035: 3b 5d e4 cmp -0x1c(%ebp),%ebx
10e038: 0f 93 c2 setae %dl
10e03b: 3b 5d e0 cmp -0x20(%ebp),%ebx
10e03e: 0f 96 c0 setbe %al
10e041: 84 d0 test %dl,%al
10e043: 0f 84 0f 01 00 00 je 10e158 <_Heap_Free+0x15c> <== NEVER TAKEN
10e049: 8b 4b 04 mov 0x4(%ebx),%ecx
10e04c: 89 c8 mov %ecx,%eax
10e04e: 83 e0 fe and $0xfffffffe,%eax
10e051: 89 45 e8 mov %eax,-0x18(%ebp)
10e054: 8d 34 03 lea (%ebx,%eax,1),%esi
}
the_size = _Heap_Block_size( the_block );
next_block = _Heap_Block_at( the_block, the_size );
if ( !_Heap_Is_block_in( the_heap, next_block ) ) {
10e057: 3b 75 e4 cmp -0x1c(%ebp),%esi
10e05a: 0f 93 c2 setae %dl
10e05d: 3b 75 e0 cmp -0x20(%ebp),%esi
10e060: 0f 96 c0 setbe %al
10e063: 84 d0 test %dl,%al
10e065: 0f 84 ed 00 00 00 je 10e158 <_Heap_Free+0x15c> <== NEVER TAKEN
10e06b: 8b 46 04 mov 0x4(%esi),%eax
_HAssert( FALSE );
return( FALSE );
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10e06e: a8 01 test $0x1,%al
10e070: 0f 84 e2 00 00 00 je 10e158 <_Heap_Free+0x15c> <== NEVER TAKEN
10e076: 83 e0 fe and $0xfffffffe,%eax
10e079: 89 45 ec mov %eax,-0x14(%ebp)
_HAssert( FALSE );
return( FALSE );
}
next_size = _Heap_Block_size( next_block );
next_is_free = next_block < the_heap->final &&
10e07c: 31 c0 xor %eax,%eax
10e07e: 3b 75 e0 cmp -0x20(%ebp),%esi
10e081: 73 0c jae 10e08f <_Heap_Free+0x93>
10e083: 8b 55 ec mov -0x14(%ebp),%edx
10e086: 8b 44 16 04 mov 0x4(%esi,%edx,1),%eax
10e08a: f7 d0 not %eax
10e08c: 83 e0 01 and $0x1,%eax
10e08f: 88 45 f3 mov %al,-0xd(%ebp)
!_Heap_Is_prev_used(_Heap_Block_at(next_block, next_size));
if ( !_Heap_Is_prev_used( the_block ) ) {
10e092: 80 e1 01 and $0x1,%cl
10e095: 75 56 jne 10e0ed <_Heap_Free+0xf1>
uint32_t const prev_size = the_block->prev_size;
10e097: 8b 0b mov (%ebx),%ecx
10e099: 29 cb sub %ecx,%ebx
Heap_Block *const prev_block = _Heap_Block_at( the_block, -prev_size );
if ( !_Heap_Is_block_in( the_heap, prev_block ) ) {
10e09b: 3b 5d e4 cmp -0x1c(%ebp),%ebx
10e09e: 0f 93 c2 setae %dl
10e0a1: 3b 5d e0 cmp -0x20(%ebp),%ebx
10e0a4: 0f 96 c0 setbe %al
10e0a7: 84 d0 test %dl,%al
10e0a9: 0f 84 a9 00 00 00 je 10e158 <_Heap_Free+0x15c> <== 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) ) {
10e0af: f6 43 04 01 testb $0x1,0x4(%ebx)
10e0b3: 0f 84 9f 00 00 00 je 10e158 <_Heap_Free+0x15c> <== NEVER TAKEN
_HAssert( FALSE );
return( FALSE );
}
if ( next_is_free ) { /* coalesce both */
10e0b9: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
10e0bd: 74 19 je 10e0d8 <_Heap_Free+0xdc>
uint32_t const size = the_size + prev_size + next_size;
10e0bf: 8b 55 e8 mov -0x18(%ebp),%edx
10e0c2: 03 55 ec add -0x14(%ebp),%edx
10e0c5: 01 ca add %ecx,%edx
* Any other value of @a alignment is taken "as is", i.e., even odd
* alignments are possible.
* Returns pointer to the start of the memory block if success, NULL if
* failure.
*
* @param[in] the_heap is the heap to operate upon
10e0c7: 8b 4e 08 mov 0x8(%esi),%ecx
* @param[in] size is the amount of memory to allocate in bytes
10e0ca: 8b 46 0c mov 0xc(%esi),%eax
* @param[in] alignment the required alignment
10e0cd: 89 48 08 mov %ecx,0x8(%eax)
* @return NULL if unsuccessful and a pointer to the block if successful
10e0d0: 89 41 0c mov %eax,0xc(%ecx)
_Heap_Block_remove( next_block );
stats->free_blocks -= 1;
10e0d3: ff 4f 38 decl 0x38(%edi)
10e0d6: eb 33 jmp 10e10b <_Heap_Free+0x10f>
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
}
else { /* coalesce prev */
uint32_t const size = the_size + prev_size;
10e0d8: 8b 55 e8 mov -0x18(%ebp),%edx
10e0db: 01 ca add %ecx,%edx
prev_block->size = size | HEAP_PREV_USED;
10e0dd: 89 d0 mov %edx,%eax
10e0df: 83 c8 01 or $0x1,%eax
10e0e2: 89 43 04 mov %eax,0x4(%ebx)
next_block->size &= ~HEAP_PREV_USED;
10e0e5: 83 66 04 fe andl $0xfffffffe,0x4(%esi)
next_block->prev_size = size;
10e0e9: 89 16 mov %edx,(%esi)
10e0eb: eb 5b jmp 10e148 <_Heap_Free+0x14c>
}
}
else if ( next_is_free ) { /* coalesce next */
10e0ed: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
10e0f1: 74 25 je 10e118 <_Heap_Free+0x11c>
uint32_t const size = the_size + next_size;
10e0f3: 8b 55 ec mov -0x14(%ebp),%edx
10e0f6: 03 55 e8 add -0x18(%ebp),%edx
* @param[in] starting_address is the starting address of the user block
* to obtain the size of
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
10e0f9: 8b 4e 08 mov 0x8(%esi),%ecx
bool _Protected_heap_Get_block_size(
10e0fc: 8b 46 0c mov 0xc(%esi),%eax
Heap_Control *the_heap,
void *starting_address,
size_t *size
10e0ff: 89 4b 08 mov %ecx,0x8(%ebx)
);
10e102: 89 43 0c mov %eax,0xc(%ebx)
10e105: 89 58 08 mov %ebx,0x8(%eax)
10e108: 89 59 0c mov %ebx,0xc(%ecx)
_Heap_Block_replace( next_block, the_block );
the_block->size = size | HEAP_PREV_USED;
10e10b: 89 d0 mov %edx,%eax
10e10d: 83 c8 01 or $0x1,%eax
10e110: 89 43 04 mov %eax,0x4(%ebx)
next_block = _Heap_Block_at( the_block, size );
next_block->prev_size = size;
10e113: 89 14 13 mov %edx,(%ebx,%edx,1)
10e116: eb 30 jmp 10e148 <_Heap_Free+0x14c>
bool _Protected_heap_Resize_block(
Heap_Control *the_heap,
void *starting_address,
size_t size
);
10e118: 8b 47 08 mov 0x8(%edi),%eax
/**
10e11b: 89 43 08 mov %eax,0x8(%ebx)
* This routine returns the block of memory which begins
10e11e: 89 7b 0c mov %edi,0xc(%ebx)
* at @a starting_address to @a the_heap. Any coalescing which is
10e121: 89 5f 08 mov %ebx,0x8(%edi)
10e124: 89 58 0c mov %ebx,0xc(%eax)
}
else { /* no coalesce */
/* Add 'the_block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Block_insert_after( _Heap_Head( the_heap), the_block );
the_block->size = the_size | HEAP_PREV_USED;
10e127: 8b 45 e8 mov -0x18(%ebp),%eax
10e12a: 83 c8 01 or $0x1,%eax
10e12d: 89 43 04 mov %eax,0x4(%ebx)
next_block->size &= ~HEAP_PREV_USED;
10e130: 83 66 04 fe andl $0xfffffffe,0x4(%esi)
next_block->prev_size = the_size;
10e134: 8b 45 e8 mov -0x18(%ebp),%eax
10e137: 89 06 mov %eax,(%esi)
stats->free_blocks += 1;
10e139: 8b 47 38 mov 0x38(%edi),%eax
10e13c: 40 inc %eax
10e13d: 89 47 38 mov %eax,0x38(%edi)
if ( stats->max_free_blocks < stats->free_blocks )
10e140: 39 47 3c cmp %eax,0x3c(%edi)
10e143: 73 03 jae 10e148 <_Heap_Free+0x14c>
stats->max_free_blocks = stats->free_blocks;
10e145: 89 47 3c mov %eax,0x3c(%edi)
}
stats->used_blocks -= 1;
10e148: ff 4f 40 decl 0x40(%edi)
stats->free_size += the_size;
10e14b: 8b 55 e8 mov -0x18(%ebp),%edx
10e14e: 01 57 30 add %edx,0x30(%edi)
stats->frees += 1;
10e151: ff 47 50 incl 0x50(%edi)
10e154: b0 01 mov $0x1,%al
10e156: eb 02 jmp 10e15a <_Heap_Free+0x15e>
return( TRUE );
10e158: 31 c0 xor %eax,%eax
}
10e15a: 83 c4 14 add $0x14,%esp
10e15d: 5b pop %ebx
10e15e: 5e pop %esi
10e15f: 5f pop %edi
10e160: c9 leave
10e161: c3 ret
0010ffe0 <_Heap_Get_free_information>:
void _Heap_Get_free_information(
Heap_Control *the_heap,
Heap_Information *info
)
{
10ffe0: 55 push %ebp
10ffe1: 89 e5 mov %esp,%ebp
10ffe3: 53 push %ebx
10ffe4: 8b 5d 08 mov 0x8(%ebp),%ebx
10ffe7: 8b 55 0c mov 0xc(%ebp),%edx
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Tail(the_heap);
info->number = 0;
10ffea: c7 02 00 00 00 00 movl $0x0,(%edx)
info->largest = 0;
10fff0: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
info->total = 0;
10fff7: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
)
{
return ( the_thread == _Thread_Heir );
}
/**
10fffe: 8b 4b 08 mov 0x8(%ebx),%ecx
110001: eb 16 jmp 110019 <_Heap_Get_free_information+0x39>
110003: 8b 41 04 mov 0x4(%ecx),%eax
110006: 83 e0 fe and $0xfffffffe,%eax
uint32_t const the_size = _Heap_Block_size(the_block);
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
info->number++;
110009: ff 02 incl (%edx)
info->total += the_size;
11000b: 01 42 08 add %eax,0x8(%edx)
if ( info->largest < the_size )
11000e: 39 42 04 cmp %eax,0x4(%edx)
110011: 73 03 jae 110016 <_Heap_Get_free_information+0x36><== NEVER TAKEN
info->largest = the_size;
110013: 89 42 04 mov %eax,0x4(%edx)
info->largest = 0;
info->total = 0;
for(the_block = _Heap_First(the_heap);
the_block != tail;
the_block = the_block->next)
110016: 8b 49 08 mov 0x8(%ecx),%ecx
info->number = 0;
info->largest = 0;
info->total = 0;
for(the_block = _Heap_First(the_heap);
the_block != tail;
110019: 39 d9 cmp %ebx,%ecx
11001b: 75 e6 jne 110003 <_Heap_Get_free_information+0x23>
info->number++;
info->total += the_size;
if ( info->largest < the_size )
info->largest = the_size;
}
}
11001d: 5b pop %ebx
11001e: c9 leave
11001f: c3 ret
00110020 <_Heap_Get_information>:
Heap_Get_information_status _Heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
110020: 55 push %ebp
110021: 89 e5 mov %esp,%ebp
110023: 53 push %ebx
110024: 8b 45 08 mov 0x8(%ebp),%eax
110027: 8b 55 0c mov 0xc(%ebp),%edx
Heap_Block *the_block = the_heap->start;
11002a: 8b 48 20 mov 0x20(%eax),%ecx
Heap_Block *const end = the_heap->final;
11002d: 8b 58 24 mov 0x24(%eax),%ebx
_HAssert(the_block->prev_size == HEAP_PREV_USED);
_HAssert(_Heap_Is_prev_used(the_block));
the_info->Free.number = 0;
110030: c7 02 00 00 00 00 movl $0x0,(%edx)
the_info->Free.total = 0;
110036: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
the_info->Free.largest = 0;
11003d: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
the_info->Used.number = 0;
110044: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
the_info->Used.total = 0;
11004b: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx)
the_info->Used.largest = 0;
110052: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx)
110059: eb 36 jmp 110091 <_Heap_Get_information+0x71>
11005b: 8b 41 04 mov 0x4(%ecx),%eax
11005e: 83 e0 fe and $0xfffffffe,%eax
/** @brief _Thread_Is_proxy_blocking
*
* status which indicates that a proxy is blocking, and FALSE otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking (
uint32_t code
110061: 01 c1 add %eax,%ecx
while ( the_block != end ) {
uint32_t const the_size = _Heap_Block_size(the_block);
Heap_Block *const next_block = _Heap_Block_at(the_block, the_size);
if ( _Heap_Is_prev_used(next_block) ) {
110063: f6 41 04 01 testb $0x1,0x4(%ecx)
110067: 74 10 je 110079 <_Heap_Get_information+0x59>
the_info->Used.number++;
110069: ff 42 0c incl 0xc(%edx)
the_info->Used.total += the_size;
11006c: 01 42 14 add %eax,0x14(%edx)
if ( the_info->Used.largest < the_size )
11006f: 39 42 10 cmp %eax,0x10(%edx)
110072: 73 1d jae 110091 <_Heap_Get_information+0x71>
the_info->Used.largest = the_size;
110074: 89 42 10 mov %eax,0x10(%edx)
110077: eb 18 jmp 110091 <_Heap_Get_information+0x71>
} else {
the_info->Free.number++;
110079: ff 02 incl (%edx)
the_info->Free.total += the_size;
11007b: 01 42 08 add %eax,0x8(%edx)
if ( the_info->Free.largest < the_size )
11007e: 39 42 04 cmp %eax,0x4(%edx)
110081: 73 03 jae 110086 <_Heap_Get_information+0x66><== NEVER TAKEN
the_info->Free.largest = the_size;
110083: 89 42 04 mov %eax,0x4(%edx)
if ( the_size != next_block->prev_size )
110086: 3b 01 cmp (%ecx),%eax
110088: 74 07 je 110091 <_Heap_Get_information+0x71><== ALWAYS TAKEN
11008a: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
11008f: eb 0a jmp 11009b <_Heap_Get_information+0x7b><== NOT EXECUTED
the_info->Free.largest = 0;
the_info->Used.number = 0;
the_info->Used.total = 0;
the_info->Used.largest = 0;
while ( the_block != end ) {
110091: 39 d9 cmp %ebx,%ecx
110093: 75 c6 jne 11005b <_Heap_Get_information+0x3b>
}
/* Handle the last dummy block. Don't consider this block to be
"used" as client never allocated it. Make 'Used.total' contain this
blocks' overhead though. */
the_info->Used.total += HEAP_OVERHEAD;
110095: 83 42 14 08 addl $0x8,0x14(%edx)
110099: 31 c0 xor %eax,%eax
return HEAP_GET_INFORMATION_SUCCESSFUL;
}
11009b: 5b pop %ebx
11009c: c9 leave
11009d: c3 ret
0010a02c <_Heap_Initialize>:
Heap_Control *the_heap,
void *starting_address,
size_t size,
uint32_t page_size
)
{
10a02c: 55 push %ebp
10a02d: 89 e5 mov %esp,%ebp
10a02f: 57 push %edi
10a030: 56 push %esi
10a031: 53 push %ebx
10a032: 83 ec 0c sub $0xc,%esp
10a035: 8b 75 08 mov 0x8(%ebp),%esi
10a038: 8b 7d 0c mov 0xc(%ebp),%edi
10a03b: 8b 4d 14 mov 0x14(%ebp),%ecx
_H_uptr_t start;
_H_uptr_t aligned_start;
uint32_t overhead;
Heap_Statistics *const stats = &the_heap->stats;
if (page_size == 0)
10a03e: 85 c9 test %ecx,%ecx
10a040: 75 04 jne 10a046 <_Heap_Initialize+0x1a>
10a042: b1 04 mov $0x4,%cl
10a044: eb 0c jmp 10a052 <_Heap_Initialize+0x26>
*
* @param[in] the_heap pointer to heap header
* @param[in] the_info pointer to a status information area
*
* @return true if successfully able to return information
*/
10a046: 89 c8 mov %ecx,%eax
10a048: 83 e0 03 and $0x3,%eax
10a04b: 74 05 je 10a052 <_Heap_Initialize+0x26>
10a04d: 83 c1 04 add $0x4,%ecx
10a050: 29 c1 sub %eax,%ecx
/* Calculate aligned_start so that aligned_start + HEAP_BLOCK_USER_OFFSET
(value of user pointer) is aligned on 'page_size' boundary. Make sure
resulting 'aligned_start' is not below 'starting_address'. */
start = _H_p2u(starting_address);
aligned_start = start + HEAP_BLOCK_USER_OFFSET;
10a052: 8d 5f 08 lea 0x8(%edi),%ebx
10a055: 89 d8 mov %ebx,%eax
10a057: 31 d2 xor %edx,%edx
10a059: f7 f1 div %ecx
10a05b: 85 d2 test %edx,%edx
10a05d: 74 05 je 10a064 <_Heap_Initialize+0x38>
10a05f: 8d 1c 19 lea (%ecx,%ebx,1),%ebx
10a062: 29 d3 sub %edx,%ebx
_Heap_Align_up_uptr ( &aligned_start, page_size );
aligned_start -= HEAP_BLOCK_USER_OFFSET;
10a064: 83 eb 08 sub $0x8,%ebx
* sizes.
*
* @param[in] the_heap pointer to heap header
* @param[in] the_info pointer to a status information area
*
* @return true if successfully able to return information
10a067: b8 10 00 00 00 mov $0x10,%eax
10a06c: 31 d2 xor %edx,%edx
10a06e: f7 f1 div %ecx
*/
10a070: b8 10 00 00 00 mov $0x10,%eax
10a075: 85 d2 test %edx,%edx
10a077: 74 05 je 10a07e <_Heap_Initialize+0x52>
10a079: 8d 41 10 lea 0x10(%ecx),%eax
10a07c: 29 d0 sub %edx,%eax
10a07e: 89 46 14 mov %eax,0x14(%esi)
/* Calculate 'the_size' -- size of the first block so that there is enough
space at the end for the permanent last block. It is equal to 'size'
minus total overhead aligned down to the nearest multiple of
'page_size'. */
overhead = HEAP_OVERHEAD + (aligned_start - start);
10a081: 89 d8 mov %ebx,%eax
10a083: 29 f8 sub %edi,%eax
10a085: 83 c0 08 add $0x8,%eax
if ( size < overhead )
10a088: 39 45 10 cmp %eax,0x10(%ebp)
10a08b: 0f 82 a0 00 00 00 jb 10a131 <_Heap_Initialize+0x105>
return 0; /* Too small area for the heap */
the_size = size - overhead;
10a091: 8b 55 10 mov 0x10(%ebp),%edx
10a094: 29 c2 sub %eax,%edx
10a096: 89 55 e8 mov %edx,-0x18(%ebp)
*
* @return free block information filled in.
*/
bool _Protected_heap_Get_free_information(
Heap_Control *the_heap,
Heap_Information *info
10a099: 89 d0 mov %edx,%eax
10a09b: 31 d2 xor %edx,%edx
10a09d: f7 f1 div %ecx
_Heap_Align_down ( &the_size, page_size );
if ( the_size == 0 )
10a09f: 8b 45 e8 mov -0x18(%ebp),%eax
10a0a2: 29 d0 sub %edx,%eax
10a0a4: 89 c2 mov %eax,%edx
10a0a6: 0f 84 85 00 00 00 je 10a131 <_Heap_Initialize+0x105><== NEVER TAKEN
return 0; /* Too small area for the heap */
the_heap->page_size = page_size;
10a0ac: 89 4e 10 mov %ecx,0x10(%esi)
the_heap->begin = starting_address;
10a0af: 89 7e 18 mov %edi,0x18(%esi)
the_heap->end = starting_address + size;
10a0b2: 03 7d 10 add 0x10(%ebp),%edi
10a0b5: 89 7e 1c mov %edi,0x1c(%esi)
the_block = (Heap_Block *) aligned_start;
the_block->prev_size = page_size;
10a0b8: 89 0b mov %ecx,(%ebx)
the_block->size = the_size | HEAP_PREV_USED;
10a0ba: 83 c8 01 or $0x1,%eax
10a0bd: 89 43 04 mov %eax,0x4(%ebx)
the_block->next = _Heap_Tail( the_heap );
10a0c0: 89 73 08 mov %esi,0x8(%ebx)
the_block->prev = _Heap_Head( the_heap );
10a0c3: 89 73 0c mov %esi,0xc(%ebx)
_Heap_Head(the_heap)->next = the_block;
10a0c6: 89 5e 08 mov %ebx,0x8(%esi)
_Heap_Tail(the_heap)->prev = the_block;
10a0c9: 89 5e 0c mov %ebx,0xc(%esi)
the_heap->start = the_block;
10a0cc: 89 5e 20 mov %ebx,0x20(%esi)
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory for
* the heap
10a0cf: 8d 04 13 lea (%ebx,%edx,1),%eax
_HAssert(_Heap_Is_aligned(the_heap->page_size, CPU_ALIGNMENT));
_HAssert(_Heap_Is_aligned(the_heap->min_block_size, page_size));
_HAssert(_Heap_Is_aligned_ptr(_Heap_User_area(the_block), page_size));
the_block = _Heap_Block_at( the_block, the_size );
the_heap->final = the_block; /* Permanent final block of the heap */
10a0d2: 89 46 24 mov %eax,0x24(%esi)
the_block->prev_size = the_size; /* Previous block is free */
10a0d5: 89 10 mov %edx,(%eax)
the_block->size = page_size;
10a0d7: 89 48 04 mov %ecx,0x4(%eax)
stats->size = size;
10a0da: 8b 45 10 mov 0x10(%ebp),%eax
10a0dd: 89 46 2c mov %eax,0x2c(%esi)
stats->free_size = the_size;
10a0e0: 89 56 30 mov %edx,0x30(%esi)
stats->min_free_size = the_size;
10a0e3: 89 56 34 mov %edx,0x34(%esi)
stats->free_blocks = 1;
10a0e6: c7 46 38 01 00 00 00 movl $0x1,0x38(%esi)
stats->max_free_blocks = 1;
10a0ed: c7 46 3c 01 00 00 00 movl $0x1,0x3c(%esi)
stats->used_blocks = 0;
10a0f4: c7 46 40 00 00 00 00 movl $0x0,0x40(%esi)
stats->max_search = 0;
10a0fb: c7 46 44 00 00 00 00 movl $0x0,0x44(%esi)
stats->allocs = 0;
10a102: c7 46 48 00 00 00 00 movl $0x0,0x48(%esi)
stats->searches = 0;
10a109: c7 46 4c 00 00 00 00 movl $0x0,0x4c(%esi)
stats->frees = 0;
10a110: c7 46 50 00 00 00 00 movl $0x0,0x50(%esi)
stats->resizes = 0;
10a117: c7 46 54 00 00 00 00 movl $0x0,0x54(%esi)
stats->instance = instance++;
10a11e: a1 4c d5 11 00 mov 0x11d54c,%eax
10a123: 89 46 28 mov %eax,0x28(%esi)
10a126: 40 inc %eax
10a127: a3 4c d5 11 00 mov %eax,0x11d54c
return ( the_size - HEAP_BLOCK_USED_OVERHEAD );
10a12c: 8d 42 fc lea -0x4(%edx),%eax
10a12f: eb 02 jmp 10a133 <_Heap_Initialize+0x107>
10a131: 31 c0 xor %eax,%eax
}
10a133: 83 c4 0c add $0xc,%esp
10a136: 5b pop %ebx
10a137: 5e pop %esi
10a138: 5f pop %edi
10a139: c9 leave
10a13a: c3 ret
00115a54 <_Heap_Resize_block>:
void *starting_address,
size_t size,
uint32_t *old_mem_size,
uint32_t *avail_mem_size
)
{
115a54: 55 push %ebp
115a55: 89 e5 mov %esp,%ebp
115a57: 57 push %edi
115a58: 56 push %esi
115a59: 53 push %ebx
115a5a: 83 ec 2c sub $0x2c,%esp
Heap_Block *next_next_block;
uint32_t old_block_size;
uint32_t old_user_size;
uint32_t prev_used_flag;
Heap_Statistics *const stats = &the_heap->stats;
uint32_t const min_block_size = the_heap->min_block_size;
115a5d: 8b 45 08 mov 0x8(%ebp),%eax
115a60: 8b 40 14 mov 0x14(%eax),%eax
115a63: 89 45 ec mov %eax,-0x14(%ebp)
uint32_t const page_size = the_heap->page_size;
115a66: 8b 55 08 mov 0x8(%ebp),%edx
115a69: 8b 72 10 mov 0x10(%edx),%esi
*old_mem_size = 0;
115a6c: 8b 4d 14 mov 0x14(%ebp),%ecx
115a6f: c7 01 00 00 00 00 movl $0x0,(%ecx)
*avail_mem_size = 0;
115a75: 8b 45 18 mov 0x18(%ebp),%eax
115a78: c7 00 00 00 00 00 movl $0x0,(%eax)
115a7e: 8b 55 0c mov 0xc(%ebp),%edx
115a81: 83 ea 08 sub $0x8,%edx
115a84: 89 55 f0 mov %edx,-0x10(%ebp)
115a87: 8b 45 0c mov 0xc(%ebp),%eax
115a8a: 8b 4d 08 mov 0x8(%ebp),%ecx
115a8d: 31 d2 xor %edx,%edx
115a8f: f7 71 10 divl 0x10(%ecx)
115a92: 29 55 f0 sub %edx,-0x10(%ebp)
115a95: 89 c8 mov %ecx,%eax
115a97: 8b 49 24 mov 0x24(%ecx),%ecx
115a9a: 8b 58 20 mov 0x20(%eax),%ebx
_Heap_Start_of_block(the_heap, starting_address, &the_block);
_HAssert(_Heap_Is_block_in(the_heap, the_block));
if (!_Heap_Is_block_in(the_heap, the_block))
115a9d: 39 5d f0 cmp %ebx,-0x10(%ebp)
115aa0: 0f 93 c2 setae %dl
115aa3: 39 4d f0 cmp %ecx,-0x10(%ebp)
115aa6: 0f 96 c0 setbe %al
115aa9: 84 d0 test %dl,%al
115aab: 0f 84 7e 01 00 00 je 115c2f <_Heap_Resize_block+0x1db>
return HEAP_RESIZE_FATAL_ERROR;
prev_used_flag = the_block->size & HEAP_PREV_USED;
115ab1: 8b 55 f0 mov -0x10(%ebp),%edx
115ab4: 8b 52 04 mov 0x4(%edx),%edx
115ab7: 89 55 d8 mov %edx,-0x28(%ebp)
115aba: 83 e2 fe and $0xfffffffe,%edx
115abd: 89 55 e4 mov %edx,-0x1c(%ebp)
115ac0: 8b 7d f0 mov -0x10(%ebp),%edi
115ac3: 01 d7 add %edx,%edi
old_block_size = _Heap_Block_size(the_block);
next_block = _Heap_Block_at(the_block, old_block_size);
_HAssert(_Heap_Is_block_in(the_heap, next_block));
_HAssert(_Heap_Is_prev_used(next_block));
if ( !_Heap_Is_block_in(the_heap, next_block) ||
115ac5: 39 df cmp %ebx,%edi
115ac7: 0f 93 c2 setae %dl
115aca: 39 cf cmp %ecx,%edi
115acc: 0f 96 c0 setbe %al
115acf: 84 d0 test %dl,%al
115ad1: 0f 84 58 01 00 00 je 115c2f <_Heap_Resize_block+0x1db><== NEVER TAKEN
115ad7: 8b 47 04 mov 0x4(%edi),%eax
115ada: a8 01 test $0x1,%al
115adc: 0f 84 4d 01 00 00 je 115c2f <_Heap_Resize_block+0x1db><== NEVER TAKEN
115ae2: 83 e0 fe and $0xfffffffe,%eax
115ae5: 89 45 dc mov %eax,-0x24(%ebp)
115ae8: 01 f8 add %edi,%eax
115aea: 89 45 e0 mov %eax,-0x20(%ebp)
!_Heap_Is_prev_used(next_block))
return HEAP_RESIZE_FATAL_ERROR;
next_block_size = _Heap_Block_size(next_block);
next_next_block = _Heap_Block_at(next_block, next_block_size);
next_is_used = (next_block == the_heap->final) ||
115aed: b8 01 00 00 00 mov $0x1,%eax
115af2: 39 cf cmp %ecx,%edi
115af4: 74 09 je 115aff <_Heap_Resize_block+0xab><== NEVER TAKEN
115af6: 8b 4d e0 mov -0x20(%ebp),%ecx
115af9: 8b 41 04 mov 0x4(%ecx),%eax
115afc: 83 e0 01 and $0x1,%eax
_Heap_Start_of_block(the_heap, starting_address, &the_block);
_HAssert(_Heap_Is_block_in(the_heap, the_block));
if (!_Heap_Is_block_in(the_heap, the_block))
return HEAP_RESIZE_FATAL_ERROR;
prev_used_flag = the_block->size & HEAP_PREV_USED;
115aff: 8b 55 d8 mov -0x28(%ebp),%edx
115b02: 83 e2 01 and $0x1,%edx
115b05: 89 55 e8 mov %edx,-0x18(%ebp)
!_Heap_Is_prev_used(next_block))
return HEAP_RESIZE_FATAL_ERROR;
next_block_size = _Heap_Block_size(next_block);
next_next_block = _Heap_Block_at(next_block, next_block_size);
next_is_used = (next_block == the_heap->final) ||
115b08: 88 c1 mov %al,%cl
_Heap_Is_prev_used(next_next_block);
/* See _Heap_Size_of_user_area() source for explanations */
old_user_size = _Addresses_Subtract(next_block, starting_address)
115b0a: 89 f8 mov %edi,%eax
115b0c: 2b 45 0c sub 0xc(%ebp),%eax
115b0f: 83 c0 04 add $0x4,%eax
+ HEAP_BLOCK_HEADER_OFFSET;
*old_mem_size = old_user_size;
115b12: 8b 55 14 mov 0x14(%ebp),%edx
115b15: 89 02 mov %eax,(%edx)
if (size > old_user_size) {
115b17: 39 45 10 cmp %eax,0x10(%ebp)
115b1a: 76 50 jbe 115b6c <_Heap_Resize_block+0x118>
/* Need to extend the block: allocate part of the next block and then
merge 'the_block' and allocated block together. */
if (next_is_used) /* Next block is in use, -- no way to extend */
115b1c: 84 c9 test %cl,%cl
115b1e: 0f 85 12 01 00 00 jne 115c36 <_Heap_Resize_block+0x1e2>
return HEAP_RESIZE_UNSATISFIED;
else {
uint32_t add_block_size = size - old_user_size;
115b24: 8b 4d 10 mov 0x10(%ebp),%ecx
115b27: 29 c1 sub %eax,%ecx
115b29: 89 c8 mov %ecx,%eax
115b2b: 31 d2 xor %edx,%edx
115b2d: f7 f6 div %esi
115b2f: 85 d2 test %edx,%edx
115b31: 74 04 je 115b37 <_Heap_Resize_block+0xe3><== NEVER TAKEN
115b33: 01 f1 add %esi,%ecx
115b35: 29 d1 sub %edx,%ecx
115b37: 89 c8 mov %ecx,%eax
115b39: 3b 4d ec cmp -0x14(%ebp),%ecx
115b3c: 73 03 jae 115b41 <_Heap_Resize_block+0xed><== NEVER TAKEN
115b3e: 8b 45 ec mov -0x14(%ebp),%eax
_Heap_Align_up(&add_block_size, page_size);
if (add_block_size < min_block_size)
add_block_size = min_block_size;
if (add_block_size > next_block_size)
115b41: 3b 45 dc cmp -0x24(%ebp),%eax
115b44: 0f 87 ec 00 00 00 ja 115c36 <_Heap_Resize_block+0x1e2><== NEVER TAKEN
return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */
add_block_size =
115b4a: 53 push %ebx
115b4b: 50 push %eax
115b4c: 57 push %edi
115b4d: ff 75 08 pushl 0x8(%ebp)
115b50: e8 23 46 ff ff call 10a178 <_Heap_Block_allocate>
_Heap_Block_allocate(the_heap, next_block, add_block_size);
/* Merge two subsequent blocks */
the_block->size = (old_block_size + add_block_size) | prev_used_flag;
115b55: 03 45 e4 add -0x1c(%ebp),%eax
115b58: 0b 45 e8 or -0x18(%ebp),%eax
115b5b: 8b 55 f0 mov -0x10(%ebp),%edx
115b5e: 89 42 04 mov %eax,0x4(%edx)
--stats->used_blocks;
115b61: 8b 4d 08 mov 0x8(%ebp),%ecx
115b64: ff 49 40 decl 0x40(%ecx)
115b67: e9 b6 00 00 00 jmp 115c22 <_Heap_Resize_block+0x1ce>
}
} else {
/* Calculate how much memory we could free */
uint32_t free_block_size = old_user_size - size;
115b6c: 89 c3 mov %eax,%ebx
115b6e: 2b 5d 10 sub 0x10(%ebp),%ebx
115b71: 89 d8 mov %ebx,%eax
115b73: 31 d2 xor %edx,%edx
115b75: f7 f6 div %esi
_Heap_Align_down(&free_block_size, page_size);
if (free_block_size > 0) {
115b77: 89 de mov %ebx,%esi
115b79: 29 d6 sub %edx,%esi
115b7b: 0f 84 a4 00 00 00 je 115c25 <_Heap_Resize_block+0x1d1>
/* To free some memory the block should be shortened so that it can
can hold 'size' user bytes and still remain not shorter than
'min_block_size'. */
uint32_t new_block_size = old_block_size - free_block_size;
115b81: 8b 5d e4 mov -0x1c(%ebp),%ebx
115b84: 29 f3 sub %esi,%ebx
if (new_block_size < min_block_size) {
115b86: 3b 5d ec cmp -0x14(%ebp),%ebx
115b89: 73 16 jae 115ba1 <_Heap_Resize_block+0x14d>
uint32_t delta = min_block_size - new_block_size;
115b8b: 8b 45 ec mov -0x14(%ebp),%eax
115b8e: 29 d8 sub %ebx,%eax
_HAssert(free_block_size >= delta);
free_block_size -= delta;
if (free_block_size == 0) {
115b90: 29 c6 sub %eax,%esi
115b92: 75 0b jne 115b9f <_Heap_Resize_block+0x14b><== NEVER TAKEN
++stats->resizes;
115b94: 8b 55 08 mov 0x8(%ebp),%edx
115b97: ff 42 54 incl 0x54(%edx)
115b9a: e9 8c 00 00 00 jmp 115c2b <_Heap_Resize_block+0x1d7>
return HEAP_RESIZE_SUCCESSFUL;
}
new_block_size += delta;
115b9f: 01 c3 add %eax,%ebx <== NOT EXECUTED
_HAssert(new_block_size >= min_block_size);
_HAssert(new_block_size + free_block_size == old_block_size);
_HAssert(_Heap_Is_aligned(new_block_size, page_size));
_HAssert(_Heap_Is_aligned(free_block_size, page_size));
if (!next_is_used) {
115ba1: 84 c9 test %cl,%cl
115ba3: 75 43 jne 115be8 <_Heap_Resize_block+0x194><== NEVER TAKEN
115ba5: 8b 55 f0 mov -0x10(%ebp),%edx
115ba8: 01 da add %ebx,%edx
/* Extend the next block to the low addresses by 'free_block_size' */
Heap_Block *const new_next_block =
_Heap_Block_at(the_block, new_block_size);
uint32_t const new_next_block_size =
next_block_size + free_block_size;
115baa: 8b 45 dc mov -0x24(%ebp),%eax
115bad: 8d 0c 06 lea (%esi,%eax,1),%ecx
_HAssert(_Heap_Is_block_in(the_heap, next_next_block));
the_block->size = new_block_size | prev_used_flag;
115bb0: 0b 5d e8 or -0x18(%ebp),%ebx
115bb3: 8b 45 f0 mov -0x10(%ebp),%eax
115bb6: 89 58 04 mov %ebx,0x4(%eax)
new_next_block->size = new_next_block_size | HEAP_PREV_USED;
115bb9: 89 c8 mov %ecx,%eax
115bbb: 83 c8 01 or $0x1,%eax
115bbe: 89 42 04 mov %eax,0x4(%edx)
next_next_block->prev_size = new_next_block_size;
115bc1: 8b 45 e0 mov -0x20(%ebp),%eax
115bc4: 89 08 mov %ecx,(%eax)
{
return (state == SYSTEM_STATE_FAILED);
}
/**@}*/
115bc6: 8b 5f 08 mov 0x8(%edi),%ebx
#endif
115bc9: 8b 47 0c mov 0xc(%edi),%eax
/* end of include file */
115bcc: 89 5a 08 mov %ebx,0x8(%edx)
115bcf: 89 42 0c mov %eax,0xc(%edx)
115bd2: 89 50 08 mov %edx,0x8(%eax)
115bd5: 89 53 0c mov %edx,0xc(%ebx)
_Heap_Block_replace(next_block, new_next_block);
the_heap->stats.free_size += free_block_size;
115bd8: 8b 55 08 mov 0x8(%ebp),%edx
115bdb: 01 72 30 add %esi,0x30(%edx)
*avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD;
115bde: 83 e9 04 sub $0x4,%ecx
115be1: 8b 45 18 mov 0x18(%ebp),%eax
115be4: 89 08 mov %ecx,(%eax)
115be6: eb 3d jmp 115c25 <_Heap_Resize_block+0x1d1>
} else if (free_block_size >= min_block_size) {
115be8: 3b 75 ec cmp -0x14(%ebp),%esi <== NOT EXECUTED
115beb: 72 38 jb 115c25 <_Heap_Resize_block+0x1d1><== NOT EXECUTED
/* Split the block into 2 used parts, then free the second one. */
the_block->size = new_block_size | prev_used_flag;
115bed: 09 5d e8 or %ebx,-0x18(%ebp) <== NOT EXECUTED
115bf0: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED
115bf3: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED
115bf6: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED
115bf9: 89 d0 mov %edx,%eax <== NOT EXECUTED
115bfb: 01 d8 add %ebx,%eax <== NOT EXECUTED
next_block = _Heap_Block_at(the_block, new_block_size);
next_block->size = free_block_size | HEAP_PREV_USED;
115bfd: 89 f2 mov %esi,%edx <== NOT EXECUTED
115bff: 83 ca 01 or $0x1,%edx <== NOT EXECUTED
115c02: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED
++stats->used_blocks; /* We have created used block */
115c05: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
115c08: ff 42 40 incl 0x40(%edx) <== NOT EXECUTED
--stats->frees; /* Don't count next call in stats */
115c0b: ff 4a 50 decl 0x50(%edx) <== NOT EXECUTED
_Heap_Free(the_heap, _Heap_User_area(next_block));
115c0e: 51 push %ecx <== NOT EXECUTED
115c0f: 51 push %ecx <== NOT EXECUTED
115c10: 83 c0 08 add $0x8,%eax <== NOT EXECUTED
115c13: 50 push %eax <== NOT EXECUTED
115c14: 52 push %edx <== NOT EXECUTED
115c15: e8 e2 83 ff ff call 10dffc <_Heap_Free> <== NOT EXECUTED
*avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD;
115c1a: 8d 46 fc lea -0x4(%esi),%eax <== NOT EXECUTED
115c1d: 8b 4d 18 mov 0x18(%ebp),%ecx <== NOT EXECUTED
115c20: 89 01 mov %eax,(%ecx) <== NOT EXECUTED
115c22: 83 c4 10 add $0x10,%esp
}
}
}
++stats->resizes;
115c25: 8b 45 08 mov 0x8(%ebp),%eax
115c28: ff 40 54 incl 0x54(%eax)
115c2b: 31 c0 xor %eax,%eax
115c2d: eb 0c jmp 115c3b <_Heap_Resize_block+0x1e7>
return HEAP_RESIZE_SUCCESSFUL;
115c2f: b8 02 00 00 00 mov $0x2,%eax
115c34: eb 05 jmp 115c3b <_Heap_Resize_block+0x1e7>
115c36: b8 01 00 00 00 mov $0x1,%eax
}
115c3b: 8d 65 f4 lea -0xc(%ebp),%esp
115c3e: 5b pop %ebx
115c3f: 5e pop %esi
115c40: 5f pop %edi
115c41: c9 leave
115c42: c3 ret
00115c44 <_Heap_Size_of_user_area>:
bool _Heap_Size_of_user_area(
Heap_Control *the_heap,
void *starting_address,
size_t *size
)
{
115c44: 55 push %ebp
115c45: 89 e5 mov %esp,%ebp
115c47: 57 push %edi
115c48: 56 push %esi
115c49: 53 push %ebx
115c4a: 8b 75 08 mov 0x8(%ebp),%esi
Heap_Block *the_block;
Heap_Block *next_block;
uint32_t the_size;
if ( !_Addresses_Is_in_range(
115c4d: 8b 7e 24 mov 0x24(%esi),%edi
115c50: 8b 5e 20 mov 0x20(%esi),%ebx
115c53: 39 5d 0c cmp %ebx,0xc(%ebp)
115c56: 0f 93 c2 setae %dl
115c59: 39 7d 0c cmp %edi,0xc(%ebp)
115c5c: 0f 96 c0 setbe %al
115c5f: 84 d0 test %dl,%al
115c61: 74 49 je 115cac <_Heap_Size_of_user_area+0x68>
115c63: 8b 4d 0c mov 0xc(%ebp),%ecx
115c66: 83 e9 08 sub $0x8,%ecx
115c69: 8b 45 0c mov 0xc(%ebp),%eax
115c6c: 31 d2 xor %edx,%edx
115c6e: f7 76 10 divl 0x10(%esi)
115c71: 29 d1 sub %edx,%ecx
return( FALSE );
_Heap_Start_of_block( the_heap, starting_address, &the_block );
_HAssert(_Heap_Is_block_in( the_heap, the_block ));
if ( !_Heap_Is_block_in( the_heap, the_block ) )
115c73: 39 d9 cmp %ebx,%ecx
115c75: 0f 93 c2 setae %dl
115c78: 39 f9 cmp %edi,%ecx
115c7a: 0f 96 c0 setbe %al
115c7d: 84 d0 test %dl,%al
115c7f: 74 2b je 115cac <_Heap_Size_of_user_area+0x68><== NEVER TAKEN
115c81: 8b 41 04 mov 0x4(%ecx),%eax
115c84: 83 e0 fe and $0xfffffffe,%eax
115c87: 01 c1 add %eax,%ecx
the_size = _Heap_Block_size( the_block );
next_block = _Heap_Block_at( the_block, the_size );
_HAssert(_Heap_Is_block_in( the_heap, next_block ));
_HAssert(_Heap_Is_prev_used( next_block ));
if (
115c89: 39 d9 cmp %ebx,%ecx
115c8b: 0f 93 c2 setae %dl
115c8e: 39 f9 cmp %edi,%ecx
115c90: 0f 96 c0 setbe %al
115c93: 84 d0 test %dl,%al
115c95: 74 15 je 115cac <_Heap_Size_of_user_area+0x68><== NEVER TAKEN
115c97: f6 41 04 01 testb $0x1,0x4(%ecx)
115c9b: 74 0f je 115cac <_Heap_Size_of_user_area+0x68><== NEVER TAKEN
and then add correction equal to the offset of the 'size' field of the
'Heap_Block' structure. The correction is due to the fact that
'prev_size' field of the next block is actually used as user accessible
area of 'the_block'. */
*size = _Addresses_Subtract ( next_block, starting_address )
115c9d: 2b 4d 0c sub 0xc(%ebp),%ecx
115ca0: 8d 51 04 lea 0x4(%ecx),%edx
115ca3: 8b 45 10 mov 0x10(%ebp),%eax
115ca6: 89 10 mov %edx,(%eax)
115ca8: b0 01 mov $0x1,%al
115caa: eb 02 jmp 115cae <_Heap_Size_of_user_area+0x6a>
+ HEAP_BLOCK_HEADER_OFFSET;
return( TRUE );
115cac: 31 c0 xor %eax,%eax
}
115cae: 5b pop %ebx
115caf: 5e pop %esi
115cb0: 5f pop %edi
115cb1: c9 leave
115cb2: c3 ret
00110110 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
110110: 55 push %ebp
110111: 89 e5 mov %esp,%ebp
110113: 57 push %edi
110114: 56 push %esi
110115: 53 push %ebx
110116: 83 ec 1c sub $0x1c,%esp
110119: 8b 5d 0c mov 0xc(%ebp),%ebx
Heap_Block *the_block = the_heap->start;
11011c: 8b 45 08 mov 0x8(%ebp),%eax
11011f: 8b 70 20 mov 0x20(%eax),%esi
Heap_Block *const end = the_heap->final;
110122: 8b 50 24 mov 0x24(%eax),%edx
110125: 89 55 e8 mov %edx,-0x18(%ebp)
/*
if ( !_System_state_Is_up( _System_state_Get() ) )
return TRUE;
*/
if (source < 0)
110128: 85 db test %ebx,%ebx
11012a: 79 03 jns 11012f <_Heap_Walk+0x1f> <== ALWAYS TAKEN
source = the_heap->stats.instance;
11012c: 8b 58 28 mov 0x28(%eax),%ebx <== NOT EXECUTED
/*
* Handle the 1st block
*/
if (!_Heap_Is_prev_used(the_block)) {
11012f: 31 c9 xor %ecx,%ecx
110131: f6 46 04 01 testb $0x1,0x4(%esi)
110135: 75 15 jne 11014c <_Heap_Walk+0x3c> <== ALWAYS TAKEN
printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source);
110137: 50 push %eax <== NOT EXECUTED
110138: 50 push %eax <== NOT EXECUTED
110139: 53 push %ebx <== NOT EXECUTED
11013a: 68 18 bb 11 00 push $0x11bb18 <== NOT EXECUTED
11013f: e8 92 83 ff ff call 1084d6 <printk> <== NOT EXECUTED
110144: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
110149: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
error = 1;
}
if (the_block->prev_size != the_heap->page_size) {
11014c: 8b 06 mov (%esi),%eax
11014e: 8b 7d 08 mov 0x8(%ebp),%edi
110151: 3b 47 10 cmp 0x10(%edi),%eax
110154: 0f 84 38 01 00 00 je 110292 <_Heap_Walk+0x182> <== ALWAYS TAKEN
printk("PASS: %d !prev_size of 1st block isn't page_size\n", source);
11015a: 50 push %eax <== NOT EXECUTED
11015b: 50 push %eax <== NOT EXECUTED
11015c: 53 push %ebx <== NOT EXECUTED
11015d: 68 4e bb 11 00 push $0x11bb4e <== NOT EXECUTED
110162: e8 6f 83 ff ff call 1084d6 <printk> <== NOT EXECUTED
110167: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
11016c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
11016f: e9 1e 01 00 00 jmp 110292 <_Heap_Walk+0x182> <== NOT EXECUTED
110174: 8b 46 04 mov 0x4(%esi),%eax
110177: 89 45 f0 mov %eax,-0x10(%ebp)
11017a: 83 e0 fe and $0xfffffffe,%eax
11017d: 89 45 ec mov %eax,-0x14(%ebp)
/** @brief _Thread_Is_proxy_blocking
*
* status which indicates that a proxy is blocking, and FALSE otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking (
uint32_t code
110180: 01 f0 add %esi,%eax
110182: 89 45 e0 mov %eax,-0x20(%ebp)
printk(" prev_size %d", the_block->prev_size);
else
printk(" (prev_size) %d", the_block->prev_size);
}
if (!_Heap_Is_block_in(the_heap, next_block)) {
110185: 8b 55 08 mov 0x8(%ebp),%edx
110188: 3b 42 20 cmp 0x20(%edx),%eax
11018b: 0f 93 c2 setae %dl
11018e: 8b 7d 08 mov 0x8(%ebp),%edi
110191: 3b 47 24 cmp 0x24(%edi),%eax
110194: 0f 96 c0 setbe %al
110197: 84 d0 test %dl,%al
110199: 75 0f jne 1101aa <_Heap_Walk+0x9a> <== ALWAYS TAKEN
if (do_dump) printk("\n");
printk("PASS: %d !block %p is out of heap\n", source, next_block);
11019b: 50 push %eax <== NOT EXECUTED
11019c: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED
11019f: 53 push %ebx <== NOT EXECUTED
1101a0: 68 80 bb 11 00 push $0x11bb80 <== NOT EXECUTED
1101a5: e9 d7 00 00 00 jmp 110281 <_Heap_Walk+0x171> <== NOT EXECUTED
error = 1;
break;
}
if (!_Heap_Is_prev_used(next_block)) {
1101aa: 8b 45 e0 mov -0x20(%ebp),%eax
1101ad: f6 40 04 01 testb $0x1,0x4(%eax)
1101b1: 0f 85 85 00 00 00 jne 11023c <_Heap_Walk+0x12c>
if (do_dump)
printk( " prev %p next %p", the_block->prev, the_block->next);
if (_Heap_Block_size(the_block) != next_block->prev_size) {
1101b7: 8b 55 ec mov -0x14(%ebp),%edx
1101ba: 3b 10 cmp (%eax),%edx
1101bc: 74 15 je 1101d3 <_Heap_Walk+0xc3> <== ALWAYS TAKEN
if (do_dump) printk("\n");
printk("PASS: %d !front and back sizes don't match", source);
1101be: 50 push %eax <== NOT EXECUTED
1101bf: 50 push %eax <== NOT EXECUTED
1101c0: 53 push %ebx <== NOT EXECUTED
1101c1: 68 a3 bb 11 00 push $0x11bba3 <== NOT EXECUTED
1101c6: e8 0b 83 ff ff call 1084d6 <printk> <== NOT EXECUTED
1101cb: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
1101d0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
error = 1;
}
if (!prev_used) {
1101d3: f6 45 f0 01 testb $0x1,-0x10(%ebp)
1101d7: 75 29 jne 110202 <_Heap_Walk+0xf2> <== ALWAYS TAKEN
if (do_dump || error) printk("\n");
1101d9: 85 c9 test %ecx,%ecx <== NOT EXECUTED
1101db: 74 10 je 1101ed <_Heap_Walk+0xdd> <== NOT EXECUTED
1101dd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1101e0: 68 75 b6 11 00 push $0x11b675 <== NOT EXECUTED
1101e5: e8 ec 82 ff ff call 1084d6 <printk> <== NOT EXECUTED
1101ea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
printk("PASS: %d !two consecutive blocks are free", source);
1101ed: 57 push %edi <== NOT EXECUTED
1101ee: 57 push %edi <== NOT EXECUTED
1101ef: 53 push %ebx <== NOT EXECUTED
1101f0: 68 ce bb 11 00 push $0x11bbce <== NOT EXECUTED
1101f5: e8 dc 82 ff ff call 1084d6 <printk> <== NOT EXECUTED
1101fa: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
1101ff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
)
{
return ( the_thread == _Thread_Heir );
}
/**
110202: 8b 7d 08 mov 0x8(%ebp),%edi
110205: 8b 47 08 mov 0x8(%edi),%eax
110208: eb 03 jmp 11020d <_Heap_Walk+0xfd>
}
{ /* Check if 'the_block' is in the free block list */
Heap_Block* block = _Heap_First(the_heap);
while(block != the_block && block != tail)
block = block->next;
11020a: 8b 40 08 mov 0x8(%eax),%eax
error = 1;
}
{ /* Check if 'the_block' is in the free block list */
Heap_Block* block = _Heap_First(the_heap);
while(block != the_block && block != tail)
11020d: 39 f0 cmp %esi,%eax
11020f: 74 2b je 11023c <_Heap_Walk+0x12c>
110211: 3b 45 08 cmp 0x8(%ebp),%eax
110214: 75 f4 jne 11020a <_Heap_Walk+0xfa> <== ALWAYS TAKEN
block = block->next;
if(block != the_block) {
if (do_dump || error) printk("\n");
110216: 85 c9 test %ecx,%ecx <== NOT EXECUTED
110218: 74 10 je 11022a <_Heap_Walk+0x11a> <== NOT EXECUTED
11021a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
11021d: 68 75 b6 11 00 push $0x11b675 <== NOT EXECUTED
110222: e8 af 82 ff ff call 1084d6 <printk> <== NOT EXECUTED
110227: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
printk("PASS: %d !the_block not in the free list", source);
11022a: 51 push %ecx <== NOT EXECUTED
11022b: 51 push %ecx <== NOT EXECUTED
11022c: 53 push %ebx <== NOT EXECUTED
11022d: 68 f8 bb 11 00 push $0x11bbf8 <== NOT EXECUTED
110232: e8 9f 82 ff ff call 1084d6 <printk> <== NOT EXECUTED
110237: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
11023a: eb 04 jmp 110240 <_Heap_Walk+0x130> <== NOT EXECUTED
error = 1;
}
}
}
if (do_dump || error) printk("\n");
11023c: 85 c9 test %ecx,%ecx
11023e: 74 15 je 110255 <_Heap_Walk+0x145> <== ALWAYS TAKEN
110240: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
110243: 68 75 b6 11 00 push $0x11b675 <== NOT EXECUTED
110248: e8 89 82 ff ff call 1084d6 <printk> <== NOT EXECUTED
11024d: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
110252: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if (the_size < the_heap->min_block_size) {
110255: 8b 55 ec mov -0x14(%ebp),%edx
110258: 8b 45 08 mov 0x8(%ebp),%eax
11025b: 3b 50 14 cmp 0x14(%eax),%edx
11025e: 73 0a jae 11026a <_Heap_Walk+0x15a> <== ALWAYS TAKEN
printk("PASS: %d !block size is too small\n", source);
110260: 52 push %edx <== NOT EXECUTED
110261: 52 push %edx <== NOT EXECUTED
110262: 53 push %ebx <== NOT EXECUTED
110263: 68 21 bc 11 00 push $0x11bc21 <== NOT EXECUTED
110268: eb 17 jmp 110281 <_Heap_Walk+0x171> <== NOT EXECUTED
error = 1;
break;
}
if (!_Heap_Is_aligned( the_size, the_heap->page_size)) {
11026a: 8b 45 ec mov -0x14(%ebp),%eax
11026d: 8b 7d 08 mov 0x8(%ebp),%edi
110270: 31 d2 xor %edx,%edx
110272: f7 77 10 divl 0x10(%edi)
110275: 85 d2 test %edx,%edx
110277: 74 12 je 11028b <_Heap_Walk+0x17b> <== ALWAYS TAKEN
printk("PASS: %d !block size is misaligned\n", source);
110279: 50 push %eax <== NOT EXECUTED
11027a: 50 push %eax <== NOT EXECUTED
11027b: 53 push %ebx <== NOT EXECUTED
11027c: 68 44 bc 11 00 push $0x11bc44 <== NOT EXECUTED
110281: e8 50 82 ff ff call 1084d6 <printk> <== NOT EXECUTED
110286: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
110289: eb 12 jmp 11029d <_Heap_Walk+0x18d> <== NOT EXECUTED
error = 1;
}
if (++passes > (do_dump ? 10 : 0) && error)
11028b: 85 c9 test %ecx,%ecx
11028d: 75 0e jne 11029d <_Heap_Walk+0x18d> <== NEVER TAKEN
break;
11028f: 8b 75 e0 mov -0x20(%ebp),%esi
if (the_block->prev_size != the_heap->page_size) {
printk("PASS: %d !prev_size of 1st block isn't page_size\n", source);
error = 1;
}
while ( the_block != end ) {
110292: 3b 75 e8 cmp -0x18(%ebp),%esi
110295: 0f 85 d9 fe ff ff jne 110174 <_Heap_Walk+0x64>
11029b: eb 17 jmp 1102b4 <_Heap_Walk+0x1a4>
the_block = next_block;
}
if (the_block != end) {
printk("PASS: %d !last block address isn't equal to 'final' %p %p\n",
11029d: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED
1102a0: 56 push %esi <== NOT EXECUTED
1102a1: 53 push %ebx <== NOT EXECUTED
1102a2: 68 68 bc 11 00 push $0x11bc68 <== NOT EXECUTED
1102a7: e8 2a 82 ff ff call 1084d6 <printk> <== NOT EXECUTED
1102ac: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
1102b1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1102b4: 8b 46 04 mov 0x4(%esi),%eax
1102b7: 83 e0 fe and $0xfffffffe,%eax
source, the_block, end);
error = 1;
}
if (_Heap_Block_size(the_block) != the_heap->page_size) {
1102ba: 8b 75 08 mov 0x8(%ebp),%esi
1102bd: 8b 56 10 mov 0x10(%esi),%edx
1102c0: 39 d0 cmp %edx,%eax
1102c2: 74 15 je 1102d9 <_Heap_Walk+0x1c9> <== ALWAYS TAKEN
printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source,
1102c4: 52 push %edx <== NOT EXECUTED
1102c5: 50 push %eax <== NOT EXECUTED
1102c6: 53 push %ebx <== NOT EXECUTED
1102c7: 68 a3 bc 11 00 push $0x11bca3 <== NOT EXECUTED
1102cc: e8 05 82 ff ff call 1084d6 <printk> <== NOT EXECUTED
1102d1: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
1102d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1102d9: 88 c8 mov %cl,%al
if(do_dump && error)
_Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 );
return error;
}
1102db: 8d 65 f4 lea -0xc(%ebp),%esp
1102de: 5b pop %ebx
1102df: 5e pop %esi
1102e0: 5f pop %edi
1102e1: c9 leave
1102e2: c3 ret
0010a1f4 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
uint32_t the_error
)
{
10a1f4: 55 push %ebp
10a1f5: 89 e5 mov %esp,%ebp
10a1f7: 53 push %ebx
10a1f8: 83 ec 08 sub $0x8,%esp
10a1fb: 8b 55 08 mov 0x8(%ebp),%edx
10a1fe: 8b 45 0c mov 0xc(%ebp),%eax
10a201: 8b 5d 10 mov 0x10(%ebp),%ebx
_Internal_errors_What_happened.the_source = the_source;
10a204: 89 15 40 d8 11 00 mov %edx,0x11d840
_Internal_errors_What_happened.is_internal = is_internal;
10a20a: a2 44 d8 11 00 mov %al,0x11d844
_Internal_errors_What_happened.the_error = the_error;
10a20f: 89 1d 48 d8 11 00 mov %ebx,0x11d848
_User_extensions_Fatal( the_source, is_internal, the_error );
10a215: 53 push %ebx
10a216: 0f b6 c0 movzbl %al,%eax
10a219: 50 push %eax
10a21a: 52 push %edx
10a21b: e8 eb 18 00 00 call 10bb0b <_User_extensions_Fatal>
* @param[in] page_size is the size in bytes of the allocation unit
*
* @return This method returns the maximum memory available. If
* unsuccessful, 0 will be returned.
*/
static inline uint32_t _Protected_heap_Initialize(
10a220: c7 05 38 d9 11 00 05 movl $0x5,0x11d938 <== NOT EXECUTED
10a227: 00 00 00
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
10a22a: fa cli <== NOT EXECUTED
10a22b: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10a22d: f4 hlt <== NOT EXECUTED
10a22e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a231: eb fe jmp 10a231 <_Internal_error_Occurred+0x3d><== NOT EXECUTED
0010a288 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
10a288: 55 push %ebp
10a289: 89 e5 mov %esp,%ebp
10a28b: 56 push %esi
10a28c: 53 push %ebx
10a28d: 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 )
10a290: 31 c9 xor %ecx,%ecx
10a292: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
10a296: 74 59 je 10a2f1 <_Objects_Allocate+0x69><== NEVER TAKEN
/*
* 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 );
10a298: 8d 73 20 lea 0x20(%ebx),%esi
10a29b: 83 ec 0c sub $0xc,%esp
10a29e: 56 push %esi
10a29f: e8 6c f8 ff ff call 109b10 <_Chain_Get>
10a2a4: 89 c1 mov %eax,%ecx
if ( information->auto_extend ) {
10a2a6: 83 c4 10 add $0x10,%esp
10a2a9: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10a2ad: 74 42 je 10a2f1 <_Objects_Allocate+0x69>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
10a2af: 85 c0 test %eax,%eax
10a2b1: 75 1a jne 10a2cd <_Objects_Allocate+0x45>
_Objects_Extend_information( information );
10a2b3: 83 ec 0c sub $0xc,%esp
10a2b6: 53 push %ebx
10a2b7: e8 64 00 00 00 call 10a320 <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10a2bc: 89 34 24 mov %esi,(%esp)
10a2bf: e8 4c f8 ff ff call 109b10 <_Chain_Get>
10a2c4: 89 c1 mov %eax,%ecx
}
if ( the_object ) {
10a2c6: 83 c4 10 add $0x10,%esp
10a2c9: 85 c0 test %eax,%eax
10a2cb: 74 24 je 10a2f1 <_Objects_Allocate+0x69><== NEVER TAKEN
uint32_t block;
block = _Objects_Get_index( the_object->id ) -
10a2cd: 8b 41 08 mov 0x8(%ecx),%eax
10a2d0: 25 ff ff 00 00 and $0xffff,%eax
10a2d5: 8b 53 08 mov 0x8(%ebx),%edx
10a2d8: 81 e2 ff ff 00 00 and $0xffff,%edx
10a2de: 29 d0 sub %edx,%eax
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
10a2e0: 31 d2 xor %edx,%edx
10a2e2: f7 73 14 divl 0x14(%ebx)
10a2e5: c1 e0 02 shl $0x2,%eax
10a2e8: 03 43 30 add 0x30(%ebx),%eax
10a2eb: ff 08 decl (%eax)
information->inactive--;
10a2ed: 66 ff 4b 2c decw 0x2c(%ebx)
}
}
return the_object;
}
10a2f1: 89 c8 mov %ecx,%eax
10a2f3: 8d 65 f8 lea -0x8(%ebp),%esp
10a2f6: 5b pop %ebx
10a2f7: 5e pop %esi
10a2f8: c9 leave
10a2f9: c3 ret
0010a320 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
10a320: 55 push %ebp
10a321: 89 e5 mov %esp,%ebp
10a323: 57 push %edi
10a324: 56 push %esi
10a325: 53 push %ebx
10a326: 83 ec 5c sub $0x5c,%esp
10a329: 8b 5d 08 mov 0x8(%ebp),%ebx
* alignments are possible.
* Returns pointer to the start of the memory block if success, NULL if
* failure.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
10a32c: 8b 43 08 mov 0x8(%ebx),%eax
10a32f: 25 ff ff 00 00 and $0xffff,%eax
10a334: 89 45 c8 mov %eax,-0x38(%ebp)
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
if ( information->maximum < minimum_index )
10a337: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx
10a33b: 39 c1 cmp %eax,%ecx
10a33d: 73 13 jae 10a352 <_Objects_Extend_information+0x32>
10a33f: 89 45 c4 mov %eax,-0x3c(%ebp)
10a342: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%ebp)
10a349: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp)
10a350: eb 35 jmp 10a387 <_Objects_Extend_information+0x67>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
10a352: 8b 7b 14 mov 0x14(%ebx),%edi
10a355: 89 c8 mov %ecx,%eax
10a357: 31 d2 xor %edx,%edx
10a359: f7 f7 div %edi
10a35b: 89 c6 mov %eax,%esi
10a35d: 89 45 bc mov %eax,-0x44(%ebp)
10a360: 8b 45 c8 mov -0x38(%ebp),%eax
10a363: 89 45 c4 mov %eax,-0x3c(%ebp)
10a366: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp)
10a36d: eb 13 jmp 10a382 <_Objects_Extend_information+0x62>
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL )
10a36f: 8b 43 34 mov 0x34(%ebx),%eax
10a372: 8b 55 c0 mov -0x40(%ebp),%edx
10a375: 83 3c 90 00 cmpl $0x0,(%eax,%edx,4)
10a379: 74 0c je 10a387 <_Objects_Extend_information+0x67>
break;
else
index_base += information->allocation_size;
10a37b: 01 7d c4 add %edi,-0x3c(%ebp)
if ( information->maximum < minimum_index )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
10a37e: 42 inc %edx
10a37f: 89 55 c0 mov %edx,-0x40(%ebp)
10a382: 39 75 c0 cmp %esi,-0x40(%ebp)
10a385: 72 e8 jb 10a36f <_Objects_Extend_information+0x4f>
/*
* If the index_base is the maximum we need to grow the tables.
*/
if (index_base >= information->maximum ) {
10a387: 39 4d c4 cmp %ecx,-0x3c(%ebp)
10a38a: 0f 82 30 01 00 00 jb 10a4c0 <_Objects_Extend_information+0x1a0>
/*
* Up the block count and maximum
*/
block_count++;
10a390: 8b 75 bc mov -0x44(%ebp),%esi
10a393: 46 inc %esi
maximum = information->maximum + information->allocation_size;
10a394: 03 4b 14 add 0x14(%ebx),%ecx
10a397: 89 4d d0 mov %ecx,-0x30(%ebp)
/*
* Allocate the tables and break it up.
*/
if ( information->auto_extend ) {
10a39a: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10a39e: 8b 7d c8 mov -0x38(%ebp),%edi
10a3a1: 8d 14 39 lea (%ecx,%edi,1),%edx
10a3a4: 74 21 je 10a3c7 <_Objects_Extend_information+0xa7>
object_blocks = (void**)
10a3a6: 83 ec 0c sub $0xc,%esp
10a3a9: 8d 04 76 lea (%esi,%esi,2),%eax
10a3ac: 8d 04 02 lea (%edx,%eax,1),%eax
10a3af: c1 e0 02 shl $0x2,%eax
10a3b2: 50 push %eax
10a3b3: e8 71 1a 00 00 call 10be29 <_Workspace_Allocate>
10a3b8: 89 45 a0 mov %eax,-0x60(%ebp)
block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *))
);
if ( !object_blocks )
10a3bb: 83 c4 10 add $0x10,%esp
10a3be: 85 c0 test %eax,%eax
10a3c0: 75 1d jne 10a3df <_Objects_Extend_information+0xbf><== ALWAYS TAKEN
10a3c2: e9 c9 01 00 00 jmp 10a590 <_Objects_Extend_information+0x270><== NOT EXECUTED
return;
}
else {
object_blocks = (void**)
10a3c7: 83 ec 0c sub $0xc,%esp
10a3ca: 8d 04 76 lea (%esi,%esi,2),%eax
10a3cd: 8d 04 02 lea (%edx,%eax,1),%eax
10a3d0: c1 e0 02 shl $0x2,%eax
10a3d3: 50 push %eax
10a3d4: e8 65 1a 00 00 call 10be3e <_Workspace_Allocate_or_fatal_error>
10a3d9: 89 45 a0 mov %eax,-0x60(%ebp)
10a3dc: 83 c4 10 add $0x10,%esp
/*
* Break the block into the various sections.
*
*/
inactive_per_block = (uint32_t *) _Addresses_Add_offset(
10a3df: 8b 45 a0 mov -0x60(%ebp),%eax
10a3e2: 8d 04 b0 lea (%eax,%esi,4),%eax
10a3e5: 89 45 cc mov %eax,-0x34(%ebp)
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory for
* the heap
10a3e8: 8b 55 a0 mov -0x60(%ebp),%edx
10a3eb: 8d 34 f2 lea (%edx,%esi,8),%esi
10a3ee: 89 75 d4 mov %esi,-0x2c(%ebp)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
10a3f1: 0f b7 43 10 movzwl 0x10(%ebx),%eax
10a3f5: 31 d2 xor %edx,%edx
10a3f7: 3b 45 c8 cmp -0x38(%ebp),%eax
10a3fa: 76 39 jbe 10a435 <_Objects_Extend_information+0x115>
/*
* 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,
10a3fc: 8b 45 bc mov -0x44(%ebp),%eax
10a3ff: c1 e0 02 shl $0x2,%eax
10a402: 8b 73 34 mov 0x34(%ebx),%esi
10a405: 8b 7d a0 mov -0x60(%ebp),%edi
10a408: 89 c1 mov %eax,%ecx
10a40a: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
10a40c: 8b 73 30 mov 0x30(%ebx),%esi
10a40f: 8b 7d cc mov -0x34(%ebp),%edi
10a412: 89 c1 mov %eax,%ecx
10a414: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
10a416: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx
10a41a: 03 4d c8 add -0x38(%ebp),%ecx
10a41d: c1 e1 02 shl $0x2,%ecx
10a420: 8b 73 1c mov 0x1c(%ebx),%esi
10a423: 8b 7d d4 mov -0x2c(%ebp),%edi
10a426: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
10a428: eb 10 jmp 10a43a <_Objects_Extend_information+0x11a>
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
local_table[ index ] = NULL;
10a42a: 8b 45 d4 mov -0x2c(%ebp),%eax
10a42d: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4)
else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
10a434: 42 inc %edx
10a435: 3b 55 c8 cmp -0x38(%ebp),%edx
10a438: 72 f0 jb 10a42a <_Objects_Extend_information+0x10a>
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
10a43a: 8b 55 bc mov -0x44(%ebp),%edx
10a43d: 8b 4d a0 mov -0x60(%ebp),%ecx
10a440: c7 04 91 00 00 00 00 movl $0x0,(%ecx,%edx,4)
inactive_per_block[block_count] = 0;
10a447: 8b 75 cc mov -0x34(%ebp),%esi
10a44a: c7 04 96 00 00 00 00 movl $0x0,(%esi,%edx,4)
for ( index=index_base ;
index < ( information->allocation_size + index_base );
10a451: 8b 4d c4 mov -0x3c(%ebp),%ecx
10a454: 03 4b 14 add 0x14(%ebx),%ecx
10a457: 8b 7d c4 mov -0x3c(%ebp),%edi
10a45a: 8b 45 d4 mov -0x2c(%ebp),%eax
10a45d: 8d 14 b8 lea (%eax,%edi,4),%edx
10a460: 89 f8 mov %edi,%eax
10a462: eb 0a jmp 10a46e <_Objects_Extend_information+0x14e>
index++ ) {
local_table[ index ] = NULL;
10a464: c7 02 00 00 00 00 movl $0x0,(%edx)
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
10a46a: 40 inc %eax
10a46b: 83 c2 04 add $0x4,%edx
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
10a46e: 39 c8 cmp %ecx,%eax
10a470: 72 f2 jb 10a464 <_Objects_Extend_information+0x144>
index++ ) {
local_table[ index ] = NULL;
}
_ISR_Disable( level );
10a472: 9c pushf
10a473: fa cli
10a474: 59 pop %ecx
old_tables = information->object_blocks;
10a475: 8b 73 34 mov 0x34(%ebx),%esi
information->object_blocks = object_blocks;
10a478: 8b 55 a0 mov -0x60(%ebp),%edx
10a47b: 89 53 34 mov %edx,0x34(%ebx)
information->inactive_per_block = inactive_per_block;
10a47e: 8b 7d cc mov -0x34(%ebp),%edi
10a481: 89 7b 30 mov %edi,0x30(%ebx)
information->local_table = local_table;
10a484: 8b 45 d4 mov -0x2c(%ebp),%eax
10a487: 89 43 1c mov %eax,0x1c(%ebx)
information->maximum = maximum;
10a48a: 8b 55 d0 mov -0x30(%ebp),%edx
10a48d: 66 89 53 10 mov %dx,0x10(%ebx)
information->maximum_id = _Objects_Build_id(
10a491: 8b 13 mov (%ebx),%edx
10a493: c1 e2 18 shl $0x18,%edx
10a496: 81 ca 00 00 01 00 or $0x10000,%edx
10a49c: 0f b7 43 04 movzwl 0x4(%ebx),%eax
10a4a0: c1 e0 1b shl $0x1b,%eax
10a4a3: 09 c2 or %eax,%edx
10a4a5: 0f b7 45 d0 movzwl -0x30(%ebp),%eax
10a4a9: 09 c2 or %eax,%edx
10a4ab: 89 53 0c mov %edx,0xc(%ebx)
information->the_class,
_Objects_Local_node,
information->maximum
);
_ISR_Enable( level );
10a4ae: 51 push %ecx
10a4af: 9d popf
if ( old_tables )
10a4b0: 85 f6 test %esi,%esi
10a4b2: 74 0c je 10a4c0 <_Objects_Extend_information+0x1a0>
_Workspace_Free( old_tables );
10a4b4: 83 ec 0c sub $0xc,%esp
10a4b7: 56 push %esi
10a4b8: e8 57 19 00 00 call 10be14 <_Workspace_Free>
10a4bd: 83 c4 10 add $0x10,%esp
/*
* Allocate the name table, and the objects
*/
if ( information->auto_extend ) {
10a4c0: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10a4c4: 8b 43 18 mov 0x18(%ebx),%eax
10a4c7: 74 32 je 10a4fb <_Objects_Extend_information+0x1db>
information->object_blocks[ block ] =
10a4c9: 8b 4d c0 mov -0x40(%ebp),%ecx
10a4cc: 8b 73 34 mov 0x34(%ebx),%esi
10a4cf: 8d 0c 8e lea (%esi,%ecx,4),%ecx
10a4d2: 89 4d d8 mov %ecx,-0x28(%ebp)
10a4d5: 83 ec 0c sub $0xc,%esp
10a4d8: 0f af 43 14 imul 0x14(%ebx),%eax
10a4dc: 50 push %eax
10a4dd: e8 47 19 00 00 call 10be29 <_Workspace_Allocate>
10a4e2: 8b 7d d8 mov -0x28(%ebp),%edi
10a4e5: 89 07 mov %eax,(%edi)
_Workspace_Allocate(
(information->allocation_size * information->size)
);
if ( !information->object_blocks[ block ] )
10a4e7: 8b 43 34 mov 0x34(%ebx),%eax
10a4ea: 83 c4 10 add $0x10,%esp
10a4ed: 8b 55 c0 mov -0x40(%ebp),%edx
10a4f0: 83 3c 90 00 cmpl $0x0,(%eax,%edx,4)
10a4f4: 75 26 jne 10a51c <_Objects_Extend_information+0x1fc><== ALWAYS TAKEN
10a4f6: e9 95 00 00 00 jmp 10a590 <_Objects_Extend_information+0x270><== NOT EXECUTED
return;
}
else {
information->object_blocks[ block ] =
10a4fb: 8b 4d c0 mov -0x40(%ebp),%ecx
10a4fe: 8b 73 34 mov 0x34(%ebx),%esi
10a501: 8d 0c 8e lea (%esi,%ecx,4),%ecx
10a504: 89 4d dc mov %ecx,-0x24(%ebp)
10a507: 83 ec 0c sub $0xc,%esp
10a50a: 0f af 43 14 imul 0x14(%ebx),%eax
10a50e: 50 push %eax
10a50f: e8 2a 19 00 00 call 10be3e <_Workspace_Allocate_or_fatal_error>
10a514: 8b 7d dc mov -0x24(%ebp),%edi
10a517: 89 07 mov %eax,(%edi)
10a519: 83 c4 10 add $0x10,%esp
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
10a51c: 8b 45 c0 mov -0x40(%ebp),%eax
10a51f: c1 e0 02 shl $0x2,%eax
10a522: 89 45 e0 mov %eax,-0x20(%ebp)
10a525: ff 73 18 pushl 0x18(%ebx)
10a528: ff 73 14 pushl 0x14(%ebx)
10a52b: 8b 43 34 mov 0x34(%ebx),%eax
10a52e: 8b 55 c0 mov -0x40(%ebp),%edx
10a531: ff 34 90 pushl (%eax,%edx,4)
10a534: 8d 7d e8 lea -0x18(%ebp),%edi
10a537: 57 push %edi
10a538: e8 1f 38 00 00 call 10dd5c <_Chain_Initialize>
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10a53d: 8d 4b 20 lea 0x20(%ebx),%ecx
10a540: 89 4d b8 mov %ecx,-0x48(%ebp)
10a543: 8b 75 c4 mov -0x3c(%ebp),%esi
10a546: eb 24 jmp 10a56c <_Objects_Extend_information+0x24c>
index = index_base;
while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) {
the_object->id = _Objects_Build_id(
10a548: 8b 03 mov (%ebx),%eax
10a54a: c1 e0 18 shl $0x18,%eax
10a54d: 0d 00 00 01 00 or $0x10000,%eax
10a552: 0f b7 53 04 movzwl 0x4(%ebx),%edx
10a556: c1 e2 1b shl $0x1b,%edx
10a559: 09 d0 or %edx,%eax
10a55b: 09 f0 or %esi,%eax
10a55d: 89 41 08 mov %eax,0x8(%ecx)
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10a560: 50 push %eax
10a561: 50 push %eax
10a562: 51 push %ecx
10a563: ff 75 b8 pushl -0x48(%ebp)
10a566: e8 81 f5 ff ff call 109aec <_Chain_Append>
index++;
10a56b: 46 inc %esi
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) {
10a56c: 89 3c 24 mov %edi,(%esp)
10a56f: e8 9c f5 ff ff call 109b10 <_Chain_Get>
10a574: 89 c1 mov %eax,%ecx
10a576: 83 c4 10 add $0x10,%esp
10a579: 85 c0 test %eax,%eax
10a57b: 75 cb jne 10a548 <_Objects_Extend_information+0x228>
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
10a57d: 8b 43 30 mov 0x30(%ebx),%eax
10a580: 8b 53 14 mov 0x14(%ebx),%edx
10a583: 8b 75 e0 mov -0x20(%ebp),%esi
10a586: 89 14 30 mov %edx,(%eax,%esi,1)
information->inactive += information->allocation_size;
10a589: 8b 43 14 mov 0x14(%ebx),%eax
10a58c: 66 01 43 2c add %ax,0x2c(%ebx)
}
10a590: 8d 65 f4 lea -0xc(%ebp),%esp
10a593: 5b pop %ebx
10a594: 5e pop %esi
10a595: 5f pop %edi
10a596: c9 leave
10a597: c3 ret
0010a62c <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint32_t the_class
)
{
10a62c: 55 push %ebp
10a62d: 89 e5 mov %esp,%ebp
10a62f: 56 push %esi
10a630: 53 push %ebx
10a631: 8b 5d 08 mov 0x8(%ebp),%ebx
10a634: 8b 75 0c mov 0xc(%ebp),%esi
/**
* This function sets @a *size to the size of the block of user memory
* which begins at @a starting_address. The size returned in @a *size could
* be greater than the size requested for allocation.
* Returns TRUE if the @a starting_address is in the heap, and FALSE
* otherwise.
10a637: 8d 43 ff lea -0x1(%ebx),%eax
10a63a: 83 f8 03 cmp $0x3,%eax
10a63d: 77 2f ja 10a66e <_Objects_Get_information+0x42>
10a63f: eb 36 jmp 10a677 <_Objects_Get_information+0x4b>
return NULL;
if ( !the_class )
return NULL;
the_class_api_maximum = _Objects_API_maximum_class( the_api );
10a641: 83 ec 0c sub $0xc,%esp
10a644: 53 push %ebx
10a645: e8 1a 3b 00 00 call 10e164 <_Objects_API_maximum_class>
if ( the_class_api_maximum < 0 ||
10a64a: 83 c4 10 add $0x10,%esp
10a64d: 85 c0 test %eax,%eax
10a64f: 78 1d js 10a66e <_Objects_Get_information+0x42><== NEVER TAKEN
10a651: 39 c6 cmp %eax,%esi
10a653: 77 19 ja 10a66e <_Objects_Get_information+0x42><== NEVER TAKEN
the_class > (uint32_t) the_class_api_maximum )
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10a655: 8b 04 9d 6c d7 11 00 mov 0x11d76c(,%ebx,4),%eax
10a65c: 85 c0 test %eax,%eax
10a65e: 74 0e je 10a66e <_Objects_Get_information+0x42><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
10a660: 8b 04 b0 mov (%eax,%esi,4),%eax
if ( !info )
10a663: 85 c0 test %eax,%eax
10a665: 74 09 je 10a670 <_Objects_Get_information+0x44><== NEVER TAKEN
* In a multprocessing configuration, we may access remote objects.
* Thus we may have 0 local instances and still have a valid object
* pointer.
*/
#if !defined(RTEMS_MULTIPROCESSING)
if ( info->maximum == 0 )
10a667: 66 83 78 10 00 cmpw $0x0,0x10(%eax)
10a66c: 75 02 jne 10a670 <_Objects_Get_information+0x44>
10a66e: 31 c0 xor %eax,%eax
return NULL;
#endif
return info;
}
10a670: 8d 65 f8 lea -0x8(%ebp),%esp
10a673: 5b pop %ebx
10a674: 5e pop %esi
10a675: c9 leave
10a676: c3 ret
int the_class_api_maximum;
if ( !_Objects_Is_api_valid( the_api ) )
return NULL;
if ( !the_class )
10a677: 85 f6 test %esi,%esi
10a679: 74 f3 je 10a66e <_Objects_Get_information+0x42>
10a67b: eb c4 jmp 10a641 <_Objects_Get_information+0x15>
00114fbc <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
114fbc: 55 push %ebp
114fbd: 89 e5 mov %esp,%ebp
114fbf: 53 push %ebx
114fc0: 8b 4d 08 mov 0x8(%ebp),%ecx
114fc3: 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;
114fc6: ba 01 00 00 00 mov $0x1,%edx
114fcb: 2b 51 08 sub 0x8(%ecx),%edx
114fce: 03 55 0c add 0xc(%ebp),%edx
if ( information->maximum >= index ) {
114fd1: 0f b7 41 10 movzwl 0x10(%ecx),%eax
114fd5: 39 d0 cmp %edx,%eax
114fd7: 72 12 jb 114feb <_Objects_Get_no_protection+0x2f>
if ( (the_object = information->local_table[ index ]) != NULL ) {
114fd9: 8b 41 1c mov 0x1c(%ecx),%eax
114fdc: 8b 04 90 mov (%eax,%edx,4),%eax
114fdf: 85 c0 test %eax,%eax
114fe1: 74 08 je 114feb <_Objects_Get_no_protection+0x2f><== NEVER TAKEN
*location = OBJECTS_LOCAL;
114fe3: c7 03 00 00 00 00 movl $0x0,(%ebx)
114fe9: eb 08 jmp 114ff3 <_Objects_Get_no_protection+0x37>
/*
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
*location = OBJECTS_ERROR;
114feb: c7 03 01 00 00 00 movl $0x1,(%ebx)
114ff1: 31 c0 xor %eax,%eax
return NULL;
}
114ff3: 5b pop %ebx
114ff4: c9 leave
114ff5: c3 ret
0010b66c <_Objects_Id_to_name>:
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
10b66c: 55 push %ebp
10b66d: 89 e5 mov %esp,%ebp
10b66f: 53 push %ebx
10b670: 83 ec 14 sub $0x14,%esp
10b673: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Id tmpId;
Objects_Information *information;
Objects_Control *the_object = (Objects_Control *) 0;
Objects_Locations ignored_location;
if ( !name )
10b676: b8 01 00 00 00 mov $0x1,%eax
10b67b: 85 db test %ebx,%ebx
10b67d: 74 59 je 10b6d8 <_Objects_Id_to_name+0x6c><== NEVER TAKEN
return OBJECTS_INVALID_NAME;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10b67f: 8b 4d 08 mov 0x8(%ebp),%ecx
10b682: 85 c9 test %ecx,%ecx
10b684: 75 08 jne 10b68e <_Objects_Id_to_name+0x22>
10b686: a1 44 15 12 00 mov 0x121544,%eax
10b68b: 8b 48 08 mov 0x8(%eax),%ecx
uint32_t page_size
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
10b68e: 89 ca mov %ecx,%edx
10b690: c1 ea 18 shr $0x18,%edx
10b693: 83 e2 07 and $0x7,%edx
/**
* This function sets @a *size to the size of the block of user memory
* which begins at @a starting_address. The size returned in @a *size could
* be greater than the size requested for allocation.
* Returns TRUE if the @a starting_address is in the heap, and FALSE
* otherwise.
10b696: 8d 42 ff lea -0x1(%edx),%eax
10b699: 83 f8 03 cmp $0x3,%eax
10b69c: 77 35 ja 10b6d3 <_Objects_Id_to_name+0x67>
10b69e: eb 3d jmp 10b6dd <_Objects_Id_to_name+0x71>
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
10b6a0: 89 c8 mov %ecx,%eax
10b6a2: c1 e8 1b shr $0x1b,%eax
10b6a5: 8b 14 82 mov (%edx,%eax,4),%edx
if ( !information )
10b6a8: 85 d2 test %edx,%edx
10b6aa: 74 27 je 10b6d3 <_Objects_Id_to_name+0x67><== NEVER TAKEN
return OBJECTS_INVALID_ID;
if ( information->is_string )
10b6ac: 80 7a 38 00 cmpb $0x0,0x38(%edx)
10b6b0: 75 21 jne 10b6d3 <_Objects_Id_to_name+0x67><== NEVER TAKEN
return OBJECTS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &ignored_location );
10b6b2: 50 push %eax
10b6b3: 8d 45 f8 lea -0x8(%ebp),%eax
10b6b6: 50 push %eax
10b6b7: 51 push %ecx
10b6b8: 52 push %edx
10b6b9: e8 56 ff ff ff call 10b614 <_Objects_Get>
if ( !the_object )
10b6be: 83 c4 10 add $0x10,%esp
10b6c1: 85 c0 test %eax,%eax
10b6c3: 74 0e je 10b6d3 <_Objects_Id_to_name+0x67>
return OBJECTS_INVALID_ID;
*name = the_object->name;
10b6c5: 8b 40 0c mov 0xc(%eax),%eax
10b6c8: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10b6ca: e8 85 07 00 00 call 10be54 <_Thread_Enable_dispatch>
10b6cf: 31 c0 xor %eax,%eax
10b6d1: eb 05 jmp 10b6d8 <_Objects_Id_to_name+0x6c>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10b6d3: b8 03 00 00 00 mov $0x3,%eax
}
10b6d8: 8b 5d fc mov -0x4(%ebp),%ebx
10b6db: c9 leave
10b6dc: c3 ret
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
10b6dd: 8b 14 95 58 14 12 00 mov 0x121458(,%edx,4),%edx
10b6e4: 85 d2 test %edx,%edx
10b6e6: 75 b8 jne 10b6a0 <_Objects_Id_to_name+0x34><== ALWAYS TAKEN
10b6e8: eb e9 jmp 10b6d3 <_Objects_Id_to_name+0x67><== NOT EXECUTED
001132d0 <_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
)
{
1132d0: 55 push %ebp
1132d1: 89 e5 mov %esp,%ebp
1132d3: 57 push %edi
1132d4: 56 push %esi
1132d5: 53 push %ebx
1132d6: 83 ec 0c sub $0xc,%esp
1132d9: 8b 7d 08 mov 0x8(%ebp),%edi
uint32_t index;
uint32_t name_length;
/* ASSERT: information->is_string == TRUE */
if ( !id )
1132dc: b8 02 00 00 00 mov $0x2,%eax
1132e1: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
1132e5: 74 59 je 113340 <_Objects_Name_to_id_string+0x70><== NEVER TAKEN
return OBJECTS_INVALID_ADDRESS;
if ( !name )
1132e7: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
1132eb: 74 4e je 11333b <_Objects_Name_to_id_string+0x6b><== NEVER TAKEN
return OBJECTS_INVALID_NAME;
if ( information->maximum != 0 ) {
1132ed: 8b 47 10 mov 0x10(%edi),%eax
1132f0: 66 85 c0 test %ax,%ax
1132f3: 74 46 je 11333b <_Objects_Name_to_id_string+0x6b><== NEVER TAKEN
1132f5: be 01 00 00 00 mov $0x1,%esi
name_length = information->name_length;
for ( index = 1; index <= information->maximum; index++ ) {
1132fa: 0f b7 c0 movzwl %ax,%eax
1132fd: 89 45 f0 mov %eax,-0x10(%ebp)
113300: eb 34 jmp 113336 <_Objects_Name_to_id_string+0x66>
the_object = information->local_table[ index ];
113302: 8b 47 1c mov 0x1c(%edi),%eax
113305: 8b 1c b0 mov (%eax,%esi,4),%ebx
if ( !the_object )
113308: 85 db test %ebx,%ebx
11330a: 74 29 je 113335 <_Objects_Name_to_id_string+0x65>
continue;
if ( !the_object->name.name_p )
11330c: 8b 53 0c mov 0xc(%ebx),%edx
11330f: 85 d2 test %edx,%edx
113311: 74 22 je 113335 <_Objects_Name_to_id_string+0x65>
continue;
if (!strncmp( name, the_object->name.name_p, information->name_length)) {
113313: 50 push %eax
113314: 0f b7 47 3a movzwl 0x3a(%edi),%eax
113318: 50 push %eax
113319: 52 push %edx
11331a: ff 75 0c pushl 0xc(%ebp)
11331d: e8 5e 25 00 00 call 115880 <strncmp>
113322: 83 c4 10 add $0x10,%esp
113325: 85 c0 test %eax,%eax
113327: 75 0c jne 113335 <_Objects_Name_to_id_string+0x65>
*id = the_object->id;
113329: 8b 43 08 mov 0x8(%ebx),%eax
11332c: 8b 55 10 mov 0x10(%ebp),%edx
11332f: 89 02 mov %eax,(%edx)
113331: 31 c0 xor %eax,%eax
113333: eb 0b jmp 113340 <_Objects_Name_to_id_string+0x70>
return OBJECTS_INVALID_NAME;
if ( information->maximum != 0 ) {
name_length = information->name_length;
for ( index = 1; index <= information->maximum; index++ ) {
113335: 46 inc %esi
113336: 3b 75 f0 cmp -0x10(%ebp),%esi
113339: 76 c7 jbe 113302 <_Objects_Name_to_id_string+0x32>
11333b: b8 01 00 00 00 mov $0x1,%eax
}
}
}
return OBJECTS_INVALID_NAME;
}
113340: 8d 65 f4 lea -0xc(%ebp),%esp
113343: 5b pop %ebx
113344: 5e pop %esi
113345: 5f pop %edi
113346: c9 leave
113347: c3 ret
0010a814 <_Objects_Name_to_id_u32>:
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
10a814: 55 push %ebp
10a815: 89 e5 mov %esp,%ebp
10a817: 57 push %edi
10a818: 56 push %esi
10a819: 53 push %ebx
10a81a: 8b 7d 08 mov 0x8(%ebp),%edi
10a81d: 8b 5d 0c mov 0xc(%ebp),%ebx
10a820: 8b 55 10 mov 0x10(%ebp),%edx
10a823: 8b 75 14 mov 0x14(%ebp),%esi
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == FALSE */
if ( !id )
10a826: b8 02 00 00 00 mov $0x2,%eax
10a82b: 85 f6 test %esi,%esi
10a82d: 74 49 je 10a878 <_Objects_Name_to_id_u32+0x64>
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
10a82f: 85 db test %ebx,%ebx
10a831: 74 40 je 10a873 <_Objects_Name_to_id_u32+0x5f>
return OBJECTS_INVALID_NAME;
search_local_node = FALSE;
if ( information->maximum != 0 &&
10a833: 8b 47 10 mov 0x10(%edi),%eax
10a836: 66 85 c0 test %ax,%ax
10a839: 74 38 je 10a873 <_Objects_Name_to_id_u32+0x5f><== NEVER TAKEN
10a83b: 85 d2 test %edx,%edx
10a83d: 74 28 je 10a867 <_Objects_Name_to_id_u32+0x53>
10a83f: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx
10a845: 74 20 je 10a867 <_Objects_Name_to_id_u32+0x53>
10a847: 4a dec %edx
10a848: 75 29 jne 10a873 <_Objects_Name_to_id_u32+0x5f>
10a84a: eb 1b jmp 10a867 <_Objects_Name_to_id_u32+0x53>
if ( search_local_node ) {
name_length = information->name_length;
for ( index = 1; index <= information->maximum; index++ ) {
the_object = information->local_table[ index ];
10a84c: 8b 47 1c mov 0x1c(%edi),%eax
10a84f: 8b 04 90 mov (%eax,%edx,4),%eax
if ( !the_object )
10a852: 85 c0 test %eax,%eax
10a854: 74 0e je 10a864 <_Objects_Name_to_id_u32+0x50>
continue;
if ( name == the_object->name.name_u32 ) {
10a856: 3b 58 0c cmp 0xc(%eax),%ebx
10a859: 75 09 jne 10a864 <_Objects_Name_to_id_u32+0x50>
*id = the_object->id;
10a85b: 8b 40 08 mov 0x8(%eax),%eax
10a85e: 89 06 mov %eax,(%esi)
10a860: 31 c0 xor %eax,%eax
10a862: eb 14 jmp 10a878 <_Objects_Name_to_id_u32+0x64>
search_local_node = TRUE;
if ( search_local_node ) {
name_length = information->name_length;
for ( index = 1; index <= information->maximum; index++ ) {
10a864: 42 inc %edx
10a865: eb 08 jmp 10a86f <_Objects_Name_to_id_u32+0x5b>
10a867: ba 01 00 00 00 mov $0x1,%edx
10a86c: 0f b7 c8 movzwl %ax,%ecx
10a86f: 39 ca cmp %ecx,%edx
10a871: 76 d9 jbe 10a84c <_Objects_Name_to_id_u32+0x38>
10a873: b8 01 00 00 00 mov $0x1,%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
}
10a878: 5b pop %ebx
10a879: 5e pop %esi
10a87a: 5f pop %edi
10a87b: c9 leave
10a87c: c3 ret
0010ae7c <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
10ae7c: 55 push %ebp
10ae7d: 89 e5 mov %esp,%ebp
10ae7f: 57 push %edi
10ae80: 56 push %esi
10ae81: 53 push %ebx
10ae82: 83 ec 14 sub $0x14,%esp
10ae85: 8b 5d 08 mov 0x8(%ebp),%ebx
10ae88: 8b 7d 10 mov 0x10(%ebp),%edi
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length ) + 1;
10ae8b: 0f b7 43 3a movzwl 0x3a(%ebx),%eax
10ae8f: 50 push %eax
10ae90: 57 push %edi
10ae91: e8 a6 63 00 00 call 11123c <strnlen>
10ae96: 89 45 f0 mov %eax,-0x10(%ebp)
10ae99: 89 c6 mov %eax,%esi
10ae9b: 46 inc %esi
if ( information->is_string ) {
10ae9c: 83 c4 10 add $0x10,%esp
10ae9f: 80 7b 38 00 cmpb $0x0,0x38(%ebx)
10aea3: 74 56 je 10aefb <_Objects_Set_name+0x7f>
char *d;
d = _Workspace_Allocate( length );
10aea5: 83 ec 0c sub $0xc,%esp
10aea8: 56 push %esi
10aea9: e8 4f 16 00 00 call 10c4fd <_Workspace_Allocate>
10aeae: 89 c3 mov %eax,%ebx
if ( !d )
10aeb0: 83 c4 10 add $0x10,%esp
10aeb3: 31 c0 xor %eax,%eax
10aeb5: 85 db test %ebx,%ebx
10aeb7: 0f 84 81 00 00 00 je 10af3e <_Objects_Set_name+0xc2><== NEVER TAKEN
return FALSE;
if ( the_object->name.name_p ) {
10aebd: 8b 55 0c mov 0xc(%ebp),%edx
10aec0: 8b 42 0c mov 0xc(%edx),%eax
10aec3: 85 c0 test %eax,%eax
10aec5: 74 16 je 10aedd <_Objects_Set_name+0x61>
_Workspace_Free( (void *)the_object->name.name_p );
10aec7: 83 ec 0c sub $0xc,%esp
10aeca: 50 push %eax
10aecb: e8 18 16 00 00 call 10c4e8 <_Workspace_Free>
the_object->name.name_p = NULL;
10aed0: 8b 45 0c mov 0xc(%ebp),%eax
10aed3: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
10aeda: 83 c4 10 add $0x10,%esp
}
strncpy( d, name, length );
10aedd: 50 push %eax
10aede: 56 push %esi
10aedf: 57 push %edi
10aee0: 53 push %ebx
10aee1: e8 ce 62 00 00 call 1111b4 <strncpy>
d[ length ] = '\0';
10aee6: 8b 55 f0 mov -0x10(%ebp),%edx
10aee9: c6 44 13 01 00 movb $0x0,0x1(%ebx,%edx,1)
the_object->name.name_p = d;
10aeee: 8b 45 0c mov 0xc(%ebp),%eax
10aef1: 89 58 0c mov %ebx,0xc(%eax)
10aef4: b0 01 mov $0x1,%al
10aef6: 83 c4 10 add $0x10,%esp
10aef9: eb 43 jmp 10af3e <_Objects_Set_name+0xc2>
} else {
the_object->name.name_u32 = _Objects_Build_name(
10aefb: b8 00 00 00 20 mov $0x20000000,%eax
10af00: 85 f6 test %esi,%esi
10af02: 74 4e je 10af52 <_Objects_Set_name+0xd6><== NEVER TAKEN
10af04: 0f be 07 movsbl (%edi),%eax
10af07: c1 e0 18 shl $0x18,%eax
10af0a: 83 fe 01 cmp $0x1,%esi
10af0d: 74 43 je 10af52 <_Objects_Set_name+0xd6>
10af0f: 0f be 5f 01 movsbl 0x1(%edi),%ebx
10af13: c1 e3 10 shl $0x10,%ebx
10af16: 83 fe 02 cmp $0x2,%esi
10af19: 76 2b jbe 10af46 <_Objects_Set_name+0xca>
10af1b: 0f be 57 02 movsbl 0x2(%edi),%edx
10af1f: c1 e2 08 shl $0x8,%edx
10af22: b9 20 00 00 00 mov $0x20,%ecx
10af27: 83 fe 03 cmp $0x3,%esi
10af2a: 76 04 jbe 10af30 <_Objects_Set_name+0xb4>
10af2c: 0f be 4f 03 movsbl 0x3(%edi),%ecx
10af30: 09 d8 or %ebx,%eax
10af32: 09 d0 or %edx,%eax
10af34: 09 c8 or %ecx,%eax
10af36: 8b 55 0c mov 0xc(%ebp),%edx
10af39: 89 42 0c mov %eax,0xc(%edx)
10af3c: b0 01 mov $0x1,%al
);
}
return TRUE;
}
10af3e: 8d 65 f4 lea -0xc(%ebp),%esp
10af41: 5b pop %ebx
10af42: 5e pop %esi
10af43: 5f pop %edi
10af44: c9 leave
10af45: c3 ret
strncpy( d, name, length );
d[ length ] = '\0';
the_object->name.name_p = d;
} else {
the_object->name.name_u32 = _Objects_Build_name(
10af46: b9 20 00 00 00 mov $0x20,%ecx
10af4b: ba 00 20 00 00 mov $0x2000,%edx
10af50: eb de jmp 10af30 <_Objects_Set_name+0xb4>
10af52: bb 00 00 20 00 mov $0x200000,%ebx
10af57: eb ed jmp 10af46 <_Objects_Set_name+0xca>
0010a888 <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
10a888: 55 push %ebp
10a889: 89 e5 mov %esp,%ebp
10a88b: 57 push %edi
10a88c: 56 push %esi
10a88d: 53 push %ebx
10a88e: 83 ec 0c sub $0xc,%esp
10a891: 8b 75 08 mov 0x8(%ebp),%esi
* alignments are possible.
* Returns pointer to the start of the memory block if success, NULL if
* failure.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
10a894: 8b 46 08 mov 0x8(%esi),%eax
10a897: 0f b7 f8 movzwl %ax,%edi
/*
* Search the list to find block or chunnk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
block_count = ( information->maximum - index_base ) / information->allocation_size;
10a89a: 8b 4e 14 mov 0x14(%esi),%ecx
10a89d: 0f b7 46 10 movzwl 0x10(%esi),%eax
10a8a1: 29 f8 sub %edi,%eax
10a8a3: 31 d2 xor %edx,%edx
10a8a5: f7 f1 div %ecx
10a8a7: 89 c3 mov %eax,%ebx
10a8a9: 31 d2 xor %edx,%edx
10a8ab: eb 7c jmp 10a929 <_Objects_Shrink_information+0xa1>
for ( block = 0; block < block_count; block++ ) {
10a8ad: 8d 04 95 00 00 00 00 lea 0x0(,%edx,4),%eax
10a8b4: 89 45 f0 mov %eax,-0x10(%ebp)
if ( information->inactive_per_block[ block ] == information->allocation_size ) {
10a8b7: 8b 46 30 mov 0x30(%esi),%eax
10a8ba: 39 0c 90 cmp %ecx,(%eax,%edx,4)
10a8bd: 75 67 jne 10a926 <_Objects_Shrink_information+0x9e>
/*
* XXX - Not to sure how to use a chain where you need to iterate and
* and remove elements.
*/
the_object = (Objects_Control *) information->Inactive.first;
10a8bf: 8b 56 20 mov 0x20(%esi),%edx
10a8c2: 8b 42 08 mov 0x8(%edx),%eax
10a8c5: 0f b7 c8 movzwl %ax,%ecx
*/
do {
index = _Objects_Get_index( the_object->id );
if ((index >= index_base) &&
10a8c8: 39 f9 cmp %edi,%ecx
10a8ca: 72 1b jb 10a8e7 <_Objects_Shrink_information+0x5f>
10a8cc: 89 f8 mov %edi,%eax
10a8ce: 03 46 14 add 0x14(%esi),%eax
10a8d1: 39 c1 cmp %eax,%ecx
10a8d3: 73 12 jae 10a8e7 <_Objects_Shrink_information+0x5f>
* @param[in] start_address is the starting address of the user block
* to free
* @return TRUE if successfully freed, FALSE otherwise
*/
bool _Protected_heap_Free(
Heap_Control *the_heap,
10a8d5: 8b 1a mov (%edx),%ebx
if ( !_Chain_Is_last( &the_object->Node ) )
the_object = (Objects_Control *) the_object->Node.next;
else
the_object = NULL;
_Chain_Extract( &extract_me->Node );
10a8d7: 83 ec 0c sub $0xc,%esp
10a8da: 52 push %edx
10a8db: e8 64 34 00 00 call 10dd44 <_Chain_Extract>
10a8e0: 89 da mov %ebx,%edx
10a8e2: 83 c4 10 add $0x10,%esp
10a8e5: eb 02 jmp 10a8e9 <_Objects_Shrink_information+0x61>
}
else {
the_object = (Objects_Control *) the_object->Node.next;
10a8e7: 8b 12 mov (%edx),%edx
}
}
while ( the_object && !_Chain_Is_last( &the_object->Node ) );
10a8e9: 85 d2 test %edx,%edx
10a8eb: 74 05 je 10a8f2 <_Objects_Shrink_information+0x6a><== NEVER TAKEN
10a8ed: 83 3a 00 cmpl $0x0,(%edx)
10a8f0: 75 d0 jne 10a8c2 <_Objects_Shrink_information+0x3a>
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
10a8f2: 83 ec 0c sub $0xc,%esp
10a8f5: 8b 46 34 mov 0x34(%esi),%eax
10a8f8: 8b 55 f0 mov -0x10(%ebp),%edx
10a8fb: ff 34 10 pushl (%eax,%edx,1)
10a8fe: e8 11 15 00 00 call 10be14 <_Workspace_Free>
information->object_blocks[ block ] = NULL;
10a903: 8b 46 34 mov 0x34(%esi),%eax
10a906: 8b 55 f0 mov -0x10(%ebp),%edx
10a909: c7 04 10 00 00 00 00 movl $0x0,(%eax,%edx,1)
information->inactive_per_block[ block ] = 0;
10a910: 8b 46 30 mov 0x30(%esi),%eax
10a913: c7 04 10 00 00 00 00 movl $0x0,(%eax,%edx,1)
information->inactive -= information->allocation_size;
10a91a: 8b 46 14 mov 0x14(%esi),%eax
10a91d: 66 29 46 2c sub %ax,0x2c(%esi)
10a921: 83 c4 10 add $0x10,%esp
10a924: eb 07 jmp 10a92d <_Objects_Shrink_information+0xa5>
return;
}
index_base += information->allocation_size;
10a926: 01 cf add %ecx,%edi
*/
index_base = _Objects_Get_index( information->minimum_id );
block_count = ( information->maximum - index_base ) / information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
10a928: 42 inc %edx
10a929: 39 da cmp %ebx,%edx
10a92b: 72 80 jb 10a8ad <_Objects_Shrink_information+0x25>
return;
}
index_base += information->allocation_size;
}
}
10a92d: 8d 65 f4 lea -0xc(%ebp),%esp
10a930: 5b pop %ebx
10a931: 5e pop %esi
10a932: 5f pop %edi
10a933: c9 leave
10a934: c3 ret
00109844 <_POSIX_API_Initialize>:
void _POSIX_API_Initialize(
rtems_configuration_table *configuration_table
)
{
109844: 55 push %ebp
109845: 89 e5 mov %esp,%ebp
109847: 53 push %ebx
109848: 83 ec 04 sub $0x4,%esp
/* XXX need to assert here based on size assumptions */
assert( sizeof(pthread_t) == sizeof(Objects_Id) );
api_configuration = configuration_table->POSIX_api_configuration;
10984b: 8b 45 08 mov 0x8(%ebp),%eax
10984e: 8b 58 44 mov 0x44(%eax),%ebx
if ( !api_configuration )
109851: 85 db test %ebx,%ebx
109853: 75 05 jne 10985a <_POSIX_API_Initialize+0x16><== ALWAYS TAKEN
109855: bb e8 72 11 00 mov $0x1172e8,%ebx <== NOT EXECUTED
api_configuration = &_POSIX_Default_configuration;
_Objects_Information_table[OBJECTS_POSIX_API] = _POSIX_Objects;
10985a: c7 05 78 d7 11 00 4c movl $0x11dc4c,0x11d778
109861: dc 11 00
_POSIX_signals_Manager_Initialization(
109864: 83 ec 0c sub $0xc,%esp
109867: ff 73 14 pushl 0x14(%ebx)
10986a: e8 f5 3b 00 00 call 10d464 <_POSIX_signals_Manager_Initialization>
api_configuration->maximum_queued_signals
);
_POSIX_Threads_Manager_initialization(
10986f: 83 c4 0c add $0xc,%esp
109872: ff 73 30 pushl 0x30(%ebx)
109875: ff 73 2c pushl 0x2c(%ebx)
109878: ff 33 pushl (%ebx)
10987a: e8 67 3d 00 00 call 10d5e6 <_POSIX_Threads_Manager_initialization>
api_configuration->maximum_threads,
api_configuration->number_of_initialization_threads,
api_configuration->User_initialization_threads_table
);
_POSIX_Condition_variables_Manager_initialization(
10987f: 58 pop %eax
109880: ff 73 08 pushl 0x8(%ebx)
109883: e8 cc 3a 00 00 call 10d354 <_POSIX_Condition_variables_Manager_initialization>
api_configuration->maximum_condition_variables
);
_POSIX_Key_Manager_initialization( api_configuration->maximum_keys );
109888: 58 pop %eax
109889: ff 73 0c pushl 0xc(%ebx)
10988c: e8 eb 3a 00 00 call 10d37c <_POSIX_Key_Manager_initialization>
_POSIX_Mutex_Manager_initialization(
109891: 58 pop %eax
109892: ff 73 04 pushl 0x4(%ebx)
109895: e8 52 3b 00 00 call 10d3ec <_POSIX_Mutex_Manager_initialization>
api_configuration->maximum_mutexes
);
_POSIX_Message_queue_Manager_initialization(
10989a: 58 pop %eax
10989b: ff 73 18 pushl 0x18(%ebx)
10989e: e8 01 3b 00 00 call 10d3a4 <_POSIX_Message_queue_Manager_initialization>
api_configuration->maximum_message_queues
);
_POSIX_Semaphore_Manager_initialization(
1098a3: 58 pop %eax
1098a4: ff 73 1c pushl 0x1c(%ebx)
1098a7: e8 40 40 00 00 call 10d8ec <_POSIX_Semaphore_Manager_initialization>
api_configuration->maximum_semaphores
);
_POSIX_Timer_Manager_initialization( api_configuration->maximum_timers );
1098ac: 59 pop %ecx
1098ad: ff 73 10 pushl 0x10(%ebx)
1098b0: e8 0f 40 00 00 call 10d8c4 <_POSIX_Timer_Manager_initialization>
_POSIX_Barrier_Manager_initialization( api_configuration->maximum_barriers );
1098b5: 5a pop %edx
1098b6: ff 73 20 pushl 0x20(%ebx)
1098b9: e8 56 3b 00 00 call 10d414 <_POSIX_Barrier_Manager_initialization>
_POSIX_RWLock_Manager_initialization( api_configuration->maximum_rwlocks );
1098be: 58 pop %eax
1098bf: ff 73 24 pushl 0x24(%ebx)
1098c2: e8 75 3b 00 00 call 10d43c <_POSIX_RWLock_Manager_initialization>
_POSIX_Spinlock_Manager_initialization(api_configuration->maximum_spinlocks);
1098c7: 83 c4 10 add $0x10,%esp
1098ca: 8b 43 28 mov 0x28(%ebx),%eax
1098cd: 89 45 08 mov %eax,0x8(%ebp)
}
1098d0: 8b 5d fc mov -0x4(%ebp),%ebx
1098d3: c9 leave
_POSIX_Barrier_Manager_initialization( api_configuration->maximum_barriers );
_POSIX_RWLock_Manager_initialization( api_configuration->maximum_rwlocks );
_POSIX_Spinlock_Manager_initialization(api_configuration->maximum_spinlocks);
1098d4: e9 d3 3c 00 00 jmp 10d5ac <_POSIX_Spinlock_Manager_initialization>
00109a50 <_POSIX_Condition_variables_Get>:
POSIX_Condition_variables_Control *_POSIX_Condition_variables_Get (
pthread_cond_t *cond,
Objects_Locations *location
)
{
109a50: 55 push %ebp
109a51: 89 e5 mov %esp,%ebp
109a53: 56 push %esi
109a54: 53 push %ebx
109a55: 8b 5d 08 mov 0x8(%ebp),%ebx
109a58: 8b 75 0c mov 0xc(%ebp),%esi
Objects_Id *id = (Objects_Id *)cond;
int status;
if ( !id ) {
109a5b: 85 db test %ebx,%ebx
109a5d: 74 16 je 109a75 <_POSIX_Condition_variables_Get+0x25>
*location = OBJECTS_ERROR;
return (POSIX_Condition_variables_Control *) 0;
}
if ( *id == PTHREAD_COND_INITIALIZER ) {
109a5f: 83 3b ff cmpl $0xffffffff,(%ebx)
109a62: 75 1b jne 109a7f <_POSIX_Condition_variables_Get+0x2f><== ALWAYS TAKEN
/*
* Do an "auto-create" here.
*/
status = pthread_cond_init( (pthread_cond_t *)id, 0 );
109a64: 52 push %edx <== NOT EXECUTED
109a65: 52 push %edx <== NOT EXECUTED
109a66: 6a 00 push $0x0 <== NOT EXECUTED
109a68: 53 push %ebx <== NOT EXECUTED
109a69: e8 2a 00 00 00 call 109a98 <pthread_cond_init> <== NOT EXECUTED
if ( status ) {
109a6e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109a71: 85 c0 test %eax,%eax <== NOT EXECUTED
109a73: 74 0a je 109a7f <_POSIX_Condition_variables_Get+0x2f><== NOT EXECUTED
*location = OBJECTS_ERROR;
109a75: c7 06 01 00 00 00 movl $0x1,(%esi)
109a7b: 31 c0 xor %eax,%eax
109a7d: eb 11 jmp 109a90 <_POSIX_Condition_variables_Get+0x40>
/*
* Now call Objects_Get()
*/
return (POSIX_Condition_variables_Control *)
109a7f: 50 push %eax
109a80: 56 push %esi
109a81: ff 33 pushl (%ebx)
109a83: 68 d4 14 12 00 push $0x1214d4
109a88: e8 3b 29 00 00 call 10c3c8 <_Objects_Get>
109a8d: 83 c4 10 add $0x10,%esp
_Objects_Get( &_POSIX_Condition_variables_Information, *id, location );
}
109a90: 8d 65 f8 lea -0x8(%ebp),%esp
109a93: 5b pop %ebx
109a94: 5e pop %esi
109a95: c9 leave
109a96: c3 ret
00109c00 <_POSIX_Condition_variables_Wait_support>:
pthread_cond_t *cond,
pthread_mutex_t *mutex,
Watchdog_Interval timeout,
bool already_timedout
)
{
109c00: 55 push %ebp
109c01: 89 e5 mov %esp,%ebp
109c03: 57 push %edi
109c04: 56 push %esi
109c05: 53 push %ebx
109c06: 83 ec 24 sub $0x24,%esp
109c09: 8b 7d 08 mov 0x8(%ebp),%edi
109c0c: 8b 75 0c mov 0xc(%ebp),%esi
109c0f: 8a 45 14 mov 0x14(%ebp),%al
109c12: 88 45 e3 mov %al,-0x1d(%ebp)
register POSIX_Condition_variables_Control *the_cond;
Objects_Locations location;
int status;
int mutex_status;
if ( !_POSIX_Mutex_Get( mutex, &location ) ) {
109c15: 8d 5d f0 lea -0x10(%ebp),%ebx
109c18: 53 push %ebx
109c19: 56 push %esi
109c1a: e8 82 01 00 00 call 109da1 <_POSIX_Mutex_Get>
109c1f: 83 c4 10 add $0x10,%esp
109c22: 85 c0 test %eax,%eax
109c24: 0f 84 af 00 00 00 je 109cd9 <_POSIX_Condition_variables_Wait_support+0xd9>
109c2a: a1 60 10 12 00 mov 0x121060,%eax
109c2f: 48 dec %eax
109c30: a3 60 10 12 00 mov %eax,0x121060
return EINVAL;
}
_Thread_Unnest_dispatch();
the_cond = _POSIX_Condition_variables_Get( cond, &location );
109c35: 52 push %edx
109c36: 52 push %edx
109c37: 53 push %ebx
109c38: 57 push %edi
109c39: e8 12 fe ff ff call 109a50 <_POSIX_Condition_variables_Get>
109c3e: 89 c3 mov %eax,%ebx
switch ( location ) {
109c40: 83 c4 10 add $0x10,%esp
109c43: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
109c47: 0f 85 8c 00 00 00 jne 109cd9 <_POSIX_Condition_variables_Wait_support+0xd9>
case OBJECTS_LOCAL:
if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) {
109c4d: 8b 40 14 mov 0x14(%eax),%eax
109c50: 85 c0 test %eax,%eax
109c52: 74 0b je 109c5f <_POSIX_Condition_variables_Wait_support+0x5f>
109c54: 3b 06 cmp (%esi),%eax
109c56: 74 07 je 109c5f <_POSIX_Condition_variables_Wait_support+0x5f><== ALWAYS TAKEN
_Thread_Enable_dispatch();
109c58: e8 2b 2f 00 00 call 10cb88 <_Thread_Enable_dispatch><== NOT EXECUTED
109c5d: eb 7a jmp 109cd9 <_POSIX_Condition_variables_Wait_support+0xd9><== NOT EXECUTED
return EINVAL;
}
(void) pthread_mutex_unlock( mutex );
109c5f: 83 ec 0c sub $0xc,%esp
109c62: 56 push %esi
109c63: e8 10 03 00 00 call 109f78 <pthread_mutex_unlock>
_Thread_Enable_dispatch();
return EINVAL;
}
*/
if ( !already_timedout ) {
109c68: 83 c4 10 add $0x10,%esp
109c6b: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
109c6f: 75 4e jne 109cbf <_POSIX_Condition_variables_Wait_support+0xbf>
the_cond->Mutex = *mutex;
109c71: 8b 06 mov (%esi),%eax
109c73: 89 43 14 mov %eax,0x14(%ebx)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
* This routine grows @a the_heap memory area using the size bytes which
109c76: c7 43 48 01 00 00 00 movl $0x1,0x48(%ebx)
_Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
_Thread_Executing->Wait.return_code = 0;
109c7d: 8b 15 20 11 12 00 mov 0x121120,%edx
109c83: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
_Thread_Executing->Wait.queue = &the_cond->Wait_queue;
109c8a: 8d 4b 18 lea 0x18(%ebx),%ecx
109c8d: 89 4a 44 mov %ecx,0x44(%edx)
_Thread_Executing->Wait.id = *cond;
109c90: 8b 07 mov (%edi),%eax
109c92: 89 42 20 mov %eax,0x20(%edx)
_Thread_queue_Enqueue( &the_cond->Wait_queue, timeout );
109c95: 50 push %eax
109c96: 68 28 d3 10 00 push $0x10d328
109c9b: ff 75 10 pushl 0x10(%ebp)
109c9e: 51 push %ecx
109c9f: e8 34 33 00 00 call 10cfd8 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
109ca4: e8 df 2e 00 00 call 10cb88 <_Thread_Enable_dispatch>
/*
* Switch ourself out because we blocked as a result of the
* _Thread_queue_Enqueue.
*/
status = _Thread_Executing->Wait.return_code;
109ca9: a1 20 11 12 00 mov 0x121120,%eax
109cae: 8b 58 34 mov 0x34(%eax),%ebx
if ( status && status != ETIMEDOUT )
109cb1: 83 c4 10 add $0x10,%esp
109cb4: 85 db test %ebx,%ebx
109cb6: 74 11 je 109cc9 <_POSIX_Condition_variables_Wait_support+0xc9>
109cb8: 83 fb 74 cmp $0x74,%ebx
109cbb: 75 21 jne 109cde <_POSIX_Condition_variables_Wait_support+0xde><== NEVER TAKEN
109cbd: eb 0a jmp 109cc9 <_POSIX_Condition_variables_Wait_support+0xc9>
return status;
} else {
_Thread_Enable_dispatch();
109cbf: e8 c4 2e 00 00 call 10cb88 <_Thread_Enable_dispatch>
109cc4: bb 74 00 00 00 mov $0x74,%ebx
/*
* When we get here the dispatch disable level is 0.
*/
mutex_status = pthread_mutex_lock( mutex );
109cc9: 83 ec 0c sub $0xc,%esp
109ccc: 56 push %esi
109ccd: e8 26 02 00 00 call 109ef8 <pthread_mutex_lock>
if ( mutex_status )
109cd2: 83 c4 10 add $0x10,%esp
109cd5: 85 c0 test %eax,%eax
109cd7: 74 05 je 109cde <_POSIX_Condition_variables_Wait_support+0xde>
109cd9: bb 16 00 00 00 mov $0x16,%ebx
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
109cde: 89 d8 mov %ebx,%eax
109ce0: 8d 65 f4 lea -0xc(%ebp),%esp
109ce3: 5b pop %ebx
109ce4: 5e pop %esi
109ce5: 5f pop %edi
109ce6: c9 leave
109ce7: c3 ret
0010ea38 <_POSIX_Keys_Run_destructors>:
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
10ea38: 55 push %ebp
10ea39: 89 e5 mov %esp,%ebp
10ea3b: 57 push %edi
10ea3c: 56 push %esi
10ea3d: 53 push %ebx
10ea3e: 83 ec 0c sub $0xc,%esp
uint32_t iterations;
bool are_all_null;
POSIX_Keys_Control *the_key;
void *value;
thread_index = _Objects_Get_index( thread->Object.id );
10ea41: 8b 45 08 mov 0x8(%ebp),%eax
10ea44: 8b 40 08 mov 0x8(%eax),%eax
uint32_t page_size
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
10ea47: 89 c2 mov %eax,%edx
10ea49: c1 ea 18 shr $0x18,%edx
10ea4c: 83 e2 07 and $0x7,%edx
the_key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table[ index ];
if ( the_key && the_key->is_active && the_key->destructor ) {
value = the_key->Values[ thread_api ][ thread_index ];
10ea4f: 25 ff ff 00 00 and $0xffff,%eax
10ea54: c1 e0 02 shl $0x2,%eax
10ea57: 89 45 ec mov %eax,-0x14(%ebp)
10ea5a: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
10ea61: 83 c2 04 add $0x4,%edx
10ea64: 89 55 e8 mov %edx,-0x18(%ebp)
10ea67: be 01 00 00 00 mov $0x1,%esi
10ea6c: bf 01 00 00 00 mov $0x1,%edi
10ea71: eb 49 jmp 10eabc <_POSIX_Keys_Run_destructors+0x84>
are_all_null = TRUE;
for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) {
the_key = (POSIX_Keys_Control *)
10ea73: a1 e8 db 11 00 mov 0x11dbe8,%eax
10ea78: 8b 1c b0 mov (%eax,%esi,4),%ebx
_POSIX_Keys_Information.local_table[ index ];
if ( the_key && the_key->is_active && the_key->destructor ) {
10ea7b: 85 db test %ebx,%ebx
10ea7d: 74 3c je 10eabb <_POSIX_Keys_Run_destructors+0x83>
10ea7f: 80 7b 10 00 cmpb $0x0,0x10(%ebx)
10ea83: 74 36 je 10eabb <_POSIX_Keys_Run_destructors+0x83><== NEVER TAKEN
10ea85: 8b 53 14 mov 0x14(%ebx),%edx
10ea88: 85 d2 test %edx,%edx
10ea8a: 74 2f je 10eabb <_POSIX_Keys_Run_destructors+0x83><== NEVER TAKEN
value = the_key->Values[ thread_api ][ thread_index ];
10ea8c: 8b 4d e8 mov -0x18(%ebp),%ecx
10ea8f: 8b 44 8b 08 mov 0x8(%ebx,%ecx,4),%eax
10ea93: 8b 4d ec mov -0x14(%ebp),%ecx
10ea96: 8b 04 08 mov (%eax,%ecx,1),%eax
if ( value ) {
10ea99: 85 c0 test %eax,%eax
10ea9b: 74 1e je 10eabb <_POSIX_Keys_Run_destructors+0x83><== NEVER TAKEN
(*the_key->destructor)( value );
10ea9d: 83 ec 0c sub $0xc,%esp
10eaa0: 50 push %eax
10eaa1: ff d2 call *%edx
if ( the_key->Values[ thread_api ][ thread_index ] )
10eaa3: 8b 55 e8 mov -0x18(%ebp),%edx
10eaa6: 8b 44 93 08 mov 0x8(%ebx,%edx,4),%eax
10eaaa: 83 c4 10 add $0x10,%esp
10eaad: 8b 4d ec mov -0x14(%ebp),%ecx
10eab0: 83 3c 08 00 cmpl $0x0,(%eax,%ecx,1)
10eab4: 0f 94 c0 sete %al
10eab7: f7 d8 neg %eax
10eab9: 21 c7 and %eax,%edi
for ( ; ; ) {
are_all_null = TRUE;
for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) {
10eabb: 46 inc %esi
10eabc: 0f b7 05 dc db 11 00 movzwl 0x11dbdc,%eax
10eac3: 39 c6 cmp %eax,%esi
10eac5: 76 ac jbe 10ea73 <_POSIX_Keys_Run_destructors+0x3b>
are_all_null = FALSE;
}
}
}
if ( are_all_null == TRUE )
10eac7: 89 f8 mov %edi,%eax
10eac9: 84 c0 test %al,%al
10eacb: 75 09 jne 10ead6 <_POSIX_Keys_Run_destructors+0x9e>
return;
iterations++;
10eacd: ff 45 f0 incl -0x10(%ebp)
* loop. It seems rude to unnecessarily lock up a system.
*
* Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99.
*/
if ( iterations >= PTHREAD_DESTRUCTOR_ITERATIONS )
10ead0: 83 7d f0 04 cmpl $0x4,-0x10(%ebp)
10ead4: 75 91 jne 10ea67 <_POSIX_Keys_Run_destructors+0x2f>
return;
}
}
10ead6: 8d 65 f4 lea -0xc(%ebp),%esp
10ead9: 5b pop %ebx
10eada: 5e pop %esi
10eadb: 5f pop %edi
10eadc: c9 leave
10eadd: c3 ret
001123e4 <_POSIX_Message_queue_Create_support>:
const char *name_arg,
int pshared,
struct mq_attr *attr_ptr,
POSIX_Message_queue_Control **message_queue
)
{
1123e4: 55 push %ebp
1123e5: 89 e5 mov %esp,%ebp
1123e7: 57 push %edi
1123e8: 56 push %esi
1123e9: 53 push %ebx
1123ea: 83 ec 24 sub $0x24,%esp
1123ed: 8b 75 10 mov 0x10(%ebp),%esi
CORE_message_queue_Attributes *the_mq_attr;
struct mq_attr attr;
char *name;
size_t n;
n = strnlen( name_arg, NAME_MAX );
1123f0: 68 ff 00 00 00 push $0xff
1123f5: ff 75 08 pushl 0x8(%ebp)
1123f8: e8 b7 35 00 00 call 1159b4 <strnlen>
1123fd: 89 c3 mov %eax,%ebx
if ( n > NAME_MAX )
1123ff: 83 c4 10 add $0x10,%esp
112402: b8 5b 00 00 00 mov $0x5b,%eax
112407: 81 fb ff 00 00 00 cmp $0xff,%ebx
11240d: 0f 87 34 01 00 00 ja 112547 <_POSIX_Message_queue_Create_support+0x163><== NEVER TAKEN
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
112413: a1 58 63 12 00 mov 0x126358,%eax
112418: 40 inc %eax
112419: a3 58 63 12 00 mov %eax,0x126358
* 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 ) {
11241e: 85 f6 test %esi,%esi
112420: 75 0d jne 11242f <_POSIX_Message_queue_Create_support+0x4b>
112422: c7 45 e0 10 00 00 00 movl $0x10,-0x20(%ebp)
112429: 66 be 0a 00 mov $0xa,%si
11242d: eb 31 jmp 112460 <_POSIX_Message_queue_Create_support+0x7c>
attr.mq_maxmsg = 10;
attr.mq_msgsize = 16;
} else {
if ( attr_ptr->mq_maxmsg <= 0 ){
11242f: 83 7e 04 00 cmpl $0x0,0x4(%esi)
112433: 7e 06 jle 11243b <_POSIX_Message_queue_Create_support+0x57>
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( attr_ptr->mq_msgsize <= 0 ){
112435: 83 7e 08 00 cmpl $0x0,0x8(%esi)
112439: 7f 12 jg 11244d <_POSIX_Message_queue_Create_support+0x69>
_Thread_Enable_dispatch();
11243b: e8 f4 d8 ff ff call 10fd34 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EINVAL );
112440: e8 c7 1f 00 00 call 11440c <__errno>
112445: c7 00 16 00 00 00 movl $0x16,(%eax)
11244b: eb 39 jmp 112486 <_POSIX_Message_queue_Create_support+0xa2>
}
attr = *attr_ptr;
11244d: 8d 7d e4 lea -0x1c(%ebp),%edi
112450: b9 04 00 00 00 mov $0x4,%ecx
112455: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
112457: 8b 45 ec mov -0x14(%ebp),%eax
11245a: 89 45 e0 mov %eax,-0x20(%ebp)
11245d: 8b 75 e8 mov -0x18(%ebp),%esi
* allocation mutex being used for protection.
*/
/**@{*/
#ifdef __cplusplus
extern "C" {
112460: 83 ec 0c sub $0xc,%esp
112463: 68 c8 66 12 00 push $0x1266c8
112468: e8 77 cc ff ff call 10f0e4 <_Objects_Allocate>
11246d: 89 c7 mov %eax,%edi
}
the_mq = _POSIX_Message_queue_Allocate();
if ( !the_mq ) {
11246f: 83 c4 10 add $0x10,%esp
112472: 85 c0 test %eax,%eax
112474: 75 18 jne 11248e <_POSIX_Message_queue_Create_support+0xaa><== ALWAYS TAKEN
_Thread_Enable_dispatch();
112476: e8 b9 d8 ff ff call 10fd34 <_Thread_Enable_dispatch><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENFILE );
11247b: e8 8c 1f 00 00 call 11440c <__errno> <== NOT EXECUTED
112480: c7 00 17 00 00 00 movl $0x17,(%eax) <== NOT EXECUTED
112486: 83 c8 ff or $0xffffffff,%eax
112489: e9 b9 00 00 00 jmp 112547 <_POSIX_Message_queue_Create_support+0x163>
}
the_mq->process_shared = pshared;
11248e: 8b 45 0c mov 0xc(%ebp),%eax
112491: 89 47 10 mov %eax,0x10(%edi)
the_mq->named = TRUE;
112494: c6 47 14 01 movb $0x1,0x14(%edi)
the_mq->open_count = 1;
112498: c7 47 18 01 00 00 00 movl $0x1,0x18(%edi)
the_mq->linked = TRUE;
11249f: c6 47 15 01 movb $0x1,0x15(%edi)
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
name = _Workspace_Allocate(n);
1124a3: 83 ec 0c sub $0xc,%esp
1124a6: 53 push %ebx
1124a7: e8 01 e9 ff ff call 110dad <_Workspace_Allocate>
1124ac: 89 c3 mov %eax,%ebx
if (!name) {
1124ae: 83 c4 10 add $0x10,%esp
1124b1: 85 c0 test %eax,%eax
1124b3: 75 1f jne 1124d4 <_POSIX_Message_queue_Create_support+0xf0><== ALWAYS TAKEN
Heap_Control *the_heap,
void *starting_address,
size_t size,
uint32_t page_size
)
{
1124b5: 51 push %ecx <== NOT EXECUTED
1124b6: 51 push %ecx <== NOT EXECUTED
1124b7: 57 push %edi <== NOT EXECUTED
1124b8: 68 c8 66 12 00 push $0x1266c8 <== NOT EXECUTED
1124bd: e8 32 cf ff ff call 10f3f4 <_Objects_Free> <== NOT EXECUTED
_POSIX_Message_queue_Free( the_mq );
_Thread_Enable_dispatch();
1124c2: e8 6d d8 ff ff call 10fd34 <_Thread_Enable_dispatch><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
1124c7: e8 40 1f 00 00 call 11440c <__errno> <== NOT EXECUTED
1124cc: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
1124d2: eb 4f jmp 112523 <_POSIX_Message_queue_Create_support+0x13f><== NOT EXECUTED
}
strcpy( name, name_arg );
1124d4: 52 push %edx
1124d5: 52 push %edx
1124d6: ff 75 08 pushl 0x8(%ebp)
1124d9: 50 push %eax
1124da: e8 b9 30 00 00 call 115598 <strcpy>
* Note that thread blocking discipline should be based on the
* current scheduling policy.
*/
the_mq_attr = &the_mq->Message_queue.Attributes;
the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
1124df: c7 47 5c 00 00 00 00 movl $0x0,0x5c(%edi)
if ( ! _CORE_message_queue_Initialize(
1124e6: ff 75 e0 pushl -0x20(%ebp)
1124e9: 56 push %esi
1124ea: 8d 47 5c lea 0x5c(%edi),%eax
1124ed: 50 push %eax
1124ee: 8d 47 1c lea 0x1c(%edi),%eax
1124f1: 50 push %eax
1124f2: e8 d1 09 00 00 call 112ec8 <_CORE_message_queue_Initialize>
1124f7: 83 c4 20 add $0x20,%esp
1124fa: 84 c0 test %al,%al
1124fc: 75 2d jne 11252b <_POSIX_Message_queue_Create_support+0x147><== ALWAYS TAKEN
1124fe: 50 push %eax <== NOT EXECUTED
1124ff: 50 push %eax <== NOT EXECUTED
112500: 57 push %edi <== NOT EXECUTED
112501: 68 c8 66 12 00 push $0x1266c8 <== NOT EXECUTED
112506: e8 e9 ce ff ff call 10f3f4 <_Objects_Free> <== NOT EXECUTED
attr.mq_maxmsg,
attr.mq_msgsize
) ) {
_POSIX_Message_queue_Free( the_mq );
_Workspace_Free(name);
11250b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
11250e: e8 85 e8 ff ff call 110d98 <_Workspace_Free> <== NOT EXECUTED
_Thread_Enable_dispatch();
112513: e8 1c d8 ff ff call 10fd34 <_Thread_Enable_dispatch><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
112518: e8 ef 1e 00 00 call 11440c <__errno> <== NOT EXECUTED
11251d: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED
112523: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
112526: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
112529: eb 1c jmp 112547 <_POSIX_Message_queue_Create_support+0x163><== NOT EXECUTED
11252b: 0f b7 47 08 movzwl 0x8(%edi),%eax
11252f: 8b 15 e4 66 12 00 mov 0x1266e4,%edx
112535: 89 3c 82 mov %edi,(%edx,%eax,4)
112538: 89 5f 0c mov %ebx,0xc(%edi)
&_POSIX_Message_queue_Information,
&the_mq->Object,
name
);
*message_queue = the_mq;
11253b: 8b 45 14 mov 0x14(%ebp),%eax
11253e: 89 38 mov %edi,(%eax)
_Thread_Enable_dispatch();
112540: e8 ef d7 ff ff call 10fd34 <_Thread_Enable_dispatch>
112545: 31 c0 xor %eax,%eax
return 0;
}
112547: 8d 65 f4 lea -0xc(%ebp),%esp
11254a: 5b pop %ebx
11254b: 5e pop %esi
11254c: 5f pop %edi
11254d: c9 leave
11254e: c3 ret
0010c4fc <_POSIX_Message_queue_Delete>:
*/
void _POSIX_Message_queue_Delete(
POSIX_Message_queue_Control *the_mq
)
{
10c4fc: 55 push %ebp
10c4fd: 89 e5 mov %esp,%ebp
10c4ff: 53 push %ebx
10c500: 83 ec 04 sub $0x4,%esp
10c503: 8b 5d 08 mov 0x8(%ebp),%ebx
if ( !the_mq->linked && !the_mq->open_count ) {
10c506: 80 7b 15 00 cmpb $0x0,0x15(%ebx)
10c50a: 75 46 jne 10c552 <_POSIX_Message_queue_Delete+0x56>
10c50c: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
10c510: 75 40 jne 10c552 <_POSIX_Message_queue_Delete+0x56>
/* the name memory may have been freed by unlink. */
Objects_Control *the_object = &the_mq->Object;
if ( the_object->name.name_p )
10c512: 8b 43 0c mov 0xc(%ebx),%eax
10c515: 85 c0 test %eax,%eax
10c517: 74 0c je 10c525 <_POSIX_Message_queue_Delete+0x29><== ALWAYS TAKEN
_Workspace_Free( (void *)the_object->name.name_p );
10c519: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c51c: 50 push %eax <== NOT EXECUTED
10c51d: e8 76 48 00 00 call 110d98 <_Workspace_Free> <== NOT EXECUTED
10c522: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
_Objects_Close( &_POSIX_Message_queue_Information, the_object );
10c525: 51 push %ecx
10c526: 51 push %ecx
10c527: 53 push %ebx
10c528: 68 c8 66 12 00 push $0x1266c8
10c52d: e8 26 2c 00 00 call 10f158 <_Objects_Close>
_CORE_message_queue_Close(
10c532: 83 c4 0c add $0xc,%esp
10c535: 6a 05 push $0x5
10c537: 6a 00 push $0x0
10c539: 8d 43 1c lea 0x1c(%ebx),%eax
10c53c: 50 push %eax
10c53d: e8 32 22 00 00 call 10e774 <_CORE_message_queue_Close>
Heap_Control *the_heap,
void *starting_address,
size_t size,
uint32_t page_size
)
{
10c542: 58 pop %eax
10c543: 5a pop %edx
10c544: 53 push %ebx
10c545: 68 c8 66 12 00 push $0x1266c8
10c54a: e8 a5 2e 00 00 call 10f3f4 <_Objects_Free>
10c54f: 83 c4 10 add $0x10,%esp
);
_POSIX_Message_queue_Free( the_mq );
}
}
10c552: 8b 5d fc mov -0x4(%ebp),%ebx
10c555: c9 leave
10c556: c3 ret
0010c820 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
10c820: 55 push %ebp
10c821: 89 e5 mov %esp,%ebp
10c823: 57 push %edi
10c824: 56 push %esi
10c825: 53 push %ebx
10c826: 83 ec 20 sub $0x20,%esp
10c829: 8b 7d 08 mov 0x8(%ebp),%edi
10c82c: 8b 75 14 mov 0x14(%ebp),%esi
10c82f: 8a 5d 18 mov 0x18(%ebp),%bl
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
);
10c832: 8d 45 f0 lea -0x10(%ebp),%eax
10c835: 50 push %eax
10c836: 57 push %edi
10c837: 68 44 68 12 00 push $0x126844
10c83c: e8 e7 2c 00 00 call 10f528 <_Objects_Get>
10c841: 89 c1 mov %eax,%ecx
Objects_Locations location;
size_t length_out;
bool do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
10c843: 83 c4 10 add $0x10,%esp
10c846: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
10c84a: 0f 85 b0 00 00 00 jne 10c900 <_POSIX_Message_queue_Receive_support+0xe0>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
10c850: 8b 50 14 mov 0x14(%eax),%edx
10c853: 89 d0 mov %edx,%eax
10c855: 83 e0 03 and $0x3,%eax
10c858: 48 dec %eax
10c859: 75 0a jne 10c865 <_POSIX_Message_queue_Receive_support+0x45>
_Thread_Enable_dispatch();
10c85b: e8 d4 34 00 00 call 10fd34 <_Thread_Enable_dispatch>
10c860: e9 9b 00 00 00 jmp 10c900 <_POSIX_Message_queue_Receive_support+0xe0>
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
10c865: 8b 49 10 mov 0x10(%ecx),%ecx
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
10c868: 8b 45 10 mov 0x10(%ebp),%eax
10c86b: 3b 41 68 cmp 0x68(%ecx),%eax
10c86e: 73 15 jae 10c885 <_POSIX_Message_queue_Receive_support+0x65>
_Thread_Enable_dispatch();
10c870: e8 bf 34 00 00 call 10fd34 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
10c875: e8 92 7b 00 00 call 11440c <__errno>
10c87a: c7 00 7a 00 00 00 movl $0x7a,(%eax)
10c880: e9 86 00 00 00 jmp 10c90b <_POSIX_Message_queue_Receive_support+0xeb>
length_out = -1;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
10c885: 31 c0 xor %eax,%eax
10c887: 84 db test %bl,%bl
10c889: 74 0b je 10c896 <_POSIX_Message_queue_Receive_support+0x76><== NEVER TAKEN
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE;
10c88b: c1 ea 0e shr $0xe,%edx
10c88e: 83 f2 01 xor $0x1,%edx
10c891: 88 d0 mov %dl,%al
10c893: 83 e0 01 and $0x1,%eax
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
10c896: c7 45 ec ff ff ff ff movl $0xffffffff,-0x14(%ebp)
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
10c89d: 52 push %edx
10c89e: 52 push %edx
10c89f: ff 75 1c pushl 0x1c(%ebp)
10c8a2: 0f b6 c0 movzbl %al,%eax
10c8a5: 50 push %eax
10c8a6: 8d 45 ec lea -0x14(%ebp),%eax
10c8a9: 50 push %eax
10c8aa: ff 75 0c pushl 0xc(%ebp)
10c8ad: 57 push %edi
10c8ae: 8d 41 1c lea 0x1c(%ecx),%eax
10c8b1: 50 push %eax
10c8b2: e8 41 1f 00 00 call 10e7f8 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
10c8b7: 83 c4 20 add $0x20,%esp
10c8ba: e8 75 34 00 00 call 10fd34 <_Thread_Enable_dispatch>
*msg_prio =
10c8bf: 8b 0d 18 64 12 00 mov 0x126418,%ecx
10c8c5: 8b 41 24 mov 0x24(%ecx),%eax
10c8c8: c1 f8 1f sar $0x1f,%eax
10c8cb: 89 c2 mov %eax,%edx
10c8cd: 33 51 24 xor 0x24(%ecx),%edx
10c8d0: 89 16 mov %edx,(%esi)
10c8d2: 29 06 sub %eax,(%esi)
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
if ( !_Thread_Executing->Wait.return_code )
10c8d4: 83 79 34 00 cmpl $0x0,0x34(%ecx)
10c8d8: 75 05 jne 10c8df <_POSIX_Message_queue_Receive_support+0xbf>
return length_out;
10c8da: 8b 45 ec mov -0x14(%ebp),%eax
10c8dd: eb 2f jmp 10c90e <_POSIX_Message_queue_Receive_support+0xee>
rtems_set_errno_and_return_minus_one(
10c8df: e8 28 7b 00 00 call 11440c <__errno>
10c8e4: 89 c3 mov %eax,%ebx
10c8e6: 83 ec 0c sub $0xc,%esp
10c8e9: a1 18 64 12 00 mov 0x126418,%eax
10c8ee: ff 70 34 pushl 0x34(%eax)
10c8f1: e8 fa 01 00 00 call 10caf0 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
10c8f6: 89 03 mov %eax,(%ebx)
10c8f8: 83 c8 ff or $0xffffffff,%eax
10c8fb: 83 c4 10 add $0x10,%esp
10c8fe: eb 0e jmp 10c90e <_POSIX_Message_queue_Receive_support+0xee>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
10c900: e8 07 7b 00 00 call 11440c <__errno>
10c905: c7 00 09 00 00 00 movl $0x9,(%eax)
10c90b: 83 c8 ff or $0xffffffff,%eax
}
10c90e: 8d 65 f4 lea -0xc(%ebp),%esp
10c911: 5b pop %ebx
10c912: 5e pop %esi
10c913: 5f pop %edi
10c914: c9 leave
10c915: c3 ret
0010c938 <_POSIX_Message_queue_Send_support>:
size_t msg_len,
uint32_t msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
10c938: 55 push %ebp
10c939: 89 e5 mov %esp,%ebp
10c93b: 56 push %esi
10c93c: 53 push %ebx
10c93d: 83 ec 20 sub $0x20,%esp
10c940: 8b 75 08 mov 0x8(%ebp),%esi
10c943: 8b 5d 14 mov 0x14(%ebp),%ebx
10c946: 8a 45 18 mov 0x18(%ebp),%al
10c949: 88 45 e7 mov %al,-0x19(%ebp)
/*
* Validate the priority.
* XXX - Do not validate msg_prio is not less than 0.
*/
if ( msg_prio > MQ_PRIO_MAX )
10c94c: 83 fb 20 cmp $0x20,%ebx
10c94f: 76 10 jbe 10c961 <_POSIX_Message_queue_Send_support+0x29>
rtems_set_errno_and_return_minus_one( EINVAL );
10c951: e8 b6 7a 00 00 call 11440c <__errno>
10c956: c7 00 16 00 00 00 movl $0x16,(%eax)
10c95c: e9 9c 00 00 00 jmp 10c9fd <_POSIX_Message_queue_Send_support+0xc5>
10c961: 50 push %eax
10c962: 8d 45 f4 lea -0xc(%ebp),%eax
10c965: 50 push %eax
10c966: 56 push %esi
10c967: 68 44 68 12 00 push $0x126844
10c96c: e8 b7 2b 00 00 call 10f528 <_Objects_Get>
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
10c971: 83 c4 10 add $0x10,%esp
10c974: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10c978: 75 78 jne 10c9f2 <_POSIX_Message_queue_Send_support+0xba>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) {
10c97a: 8b 50 14 mov 0x14(%eax),%edx
10c97d: f6 c2 03 test $0x3,%dl
10c980: 75 07 jne 10c989 <_POSIX_Message_queue_Send_support+0x51>
_Thread_Enable_dispatch();
10c982: e8 ad 33 00 00 call 10fd34 <_Thread_Enable_dispatch>
10c987: eb 69 jmp 10c9f2 <_POSIX_Message_queue_Send_support+0xba>
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
10c989: 8b 48 10 mov 0x10(%eax),%ecx
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
10c98c: 31 c0 xor %eax,%eax
10c98e: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
10c992: 74 0b je 10c99f <_POSIX_Message_queue_Send_support+0x67><== NEVER TAKEN
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE;
10c994: c1 ea 0e shr $0xe,%edx
10c997: 83 f2 01 xor $0x1,%edx
10c99a: 88 d0 mov %dl,%al
10c99c: 83 e0 01 and $0x1,%eax
do_wait = wait;
/*
* Now perform the actual message receive
*/
msg_status = _CORE_message_queue_Submit(
10c99f: ff 75 1c pushl 0x1c(%ebp)
10c9a2: 0f b6 c0 movzbl %al,%eax
10c9a5: 50 push %eax
10c9a6: f7 db neg %ebx
10c9a8: 53 push %ebx
10c9a9: 6a 00 push $0x0
10c9ab: 56 push %esi
10c9ac: ff 75 10 pushl 0x10(%ebp)
10c9af: ff 75 0c pushl 0xc(%ebp)
10c9b2: 8d 41 1c lea 0x1c(%ecx),%eax
10c9b5: 50 push %eax
10c9b6: e8 85 1f 00 00 call 10e940 <_CORE_message_queue_Submit>
10c9bb: 89 c6 mov %eax,%esi
_POSIX_Message_queue_Priority_to_core( msg_prio ),
do_wait,
timeout /* no timeout */
);
_Thread_Enable_dispatch();
10c9bd: 83 c4 20 add $0x20,%esp
10c9c0: e8 6f 33 00 00 call 10fd34 <_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 )
10c9c5: 83 fe 07 cmp $0x7,%esi
10c9c8: 75 08 jne 10c9d2 <_POSIX_Message_queue_Send_support+0x9a>
msg_status = _Thread_Executing->Wait.return_code;
10c9ca: a1 18 64 12 00 mov 0x126418,%eax
10c9cf: 8b 70 34 mov 0x34(%eax),%esi
if ( !msg_status )
10c9d2: 31 c0 xor %eax,%eax
10c9d4: 85 f6 test %esi,%esi
10c9d6: 74 28 je 10ca00 <_POSIX_Message_queue_Send_support+0xc8>
return msg_status;
rtems_set_errno_and_return_minus_one(
10c9d8: e8 2f 7a 00 00 call 11440c <__errno>
10c9dd: 89 c3 mov %eax,%ebx
10c9df: 83 ec 0c sub $0xc,%esp
10c9e2: 56 push %esi
10c9e3: e8 08 01 00 00 call 10caf0 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
10c9e8: 89 03 mov %eax,(%ebx)
10c9ea: 83 c8 ff or $0xffffffff,%eax
10c9ed: 83 c4 10 add $0x10,%esp
10c9f0: eb 0e jmp 10ca00 <_POSIX_Message_queue_Send_support+0xc8>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
10c9f2: e8 15 7a 00 00 call 11440c <__errno>
10c9f7: c7 00 09 00 00 00 movl $0x9,(%eax)
10c9fd: 83 c8 ff or $0xffffffff,%eax
}
10ca00: 8d 65 f8 lea -0x8(%ebp),%esp
10ca03: 5b pop %ebx
10ca04: 5e pop %esi
10ca05: c9 leave
10ca06: c3 ret
0010a80d <_POSIX_Mutex_Get>:
POSIX_Mutex_Control *_POSIX_Mutex_Get (
pthread_mutex_t *mutex,
Objects_Locations *location
)
{
10a80d: 55 push %ebp
10a80e: 89 e5 mov %esp,%ebp
10a810: 56 push %esi
10a811: 53 push %ebx
10a812: 8b 5d 08 mov 0x8(%ebp),%ebx
10a815: 8b 75 0c mov 0xc(%ebp),%esi
Objects_Id *id = (Objects_Id *)mutex;
___POSIX_Mutex_Get_support( id, location );
10a818: 85 db test %ebx,%ebx
10a81a: 74 16 je 10a832 <_POSIX_Mutex_Get+0x25>
10a81c: 83 3b ff cmpl $0xffffffff,(%ebx)
10a81f: 75 1b jne 10a83c <_POSIX_Mutex_Get+0x2f> <== ALWAYS TAKEN
10a821: 51 push %ecx <== NOT EXECUTED
10a822: 51 push %ecx <== NOT EXECUTED
10a823: 6a 00 push $0x0 <== NOT EXECUTED
10a825: 53 push %ebx <== NOT EXECUTED
10a826: e8 6d 00 00 00 call 10a898 <pthread_mutex_init> <== NOT EXECUTED
10a82b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a82e: 85 c0 test %eax,%eax <== NOT EXECUTED
10a830: 74 0a je 10a83c <_POSIX_Mutex_Get+0x2f> <== NOT EXECUTED
10a832: c7 06 01 00 00 00 movl $0x1,(%esi)
10a838: 31 c0 xor %eax,%eax
10a83a: eb 11 jmp 10a84d <_POSIX_Mutex_Get+0x40>
return (POSIX_Mutex_Control *)
10a83c: 52 push %edx
10a83d: 56 push %esi
10a83e: ff 33 pushl (%ebx)
10a840: 68 18 2f 12 00 push $0x122f18
10a845: e8 1a 29 00 00 call 10d164 <_Objects_Get>
10a84a: 83 c4 10 add $0x10,%esp
_Objects_Get( &_POSIX_Mutex_Information, *id, location );
}
10a84d: 8d 65 f8 lea -0x8(%ebp),%esp
10a850: 5b pop %ebx
10a851: 5e pop %esi
10a852: c9 leave
10a853: c3 ret
0010a7c4 <_POSIX_Mutex_Get_interrupt_disable>:
POSIX_Mutex_Control *_POSIX_Mutex_Get_interrupt_disable (
pthread_mutex_t *mutex,
Objects_Locations *location,
ISR_Level *level
)
{
10a7c4: 55 push %ebp
10a7c5: 89 e5 mov %esp,%ebp
10a7c7: 56 push %esi
10a7c8: 53 push %ebx
10a7c9: 8b 5d 08 mov 0x8(%ebp),%ebx
10a7cc: 8b 75 0c mov 0xc(%ebp),%esi
Objects_Id *id = (Objects_Id *)mutex;
___POSIX_Mutex_Get_support( id, location );
10a7cf: 85 db test %ebx,%ebx
10a7d1: 74 16 je 10a7e9 <_POSIX_Mutex_Get_interrupt_disable+0x25><== NEVER TAKEN
10a7d3: 83 3b ff cmpl $0xffffffff,(%ebx)
10a7d6: 75 1b jne 10a7f3 <_POSIX_Mutex_Get_interrupt_disable+0x2f><== ALWAYS TAKEN
10a7d8: 50 push %eax <== NOT EXECUTED
10a7d9: 50 push %eax <== NOT EXECUTED
10a7da: 6a 00 push $0x0 <== NOT EXECUTED
10a7dc: 53 push %ebx <== NOT EXECUTED
10a7dd: e8 b6 00 00 00 call 10a898 <pthread_mutex_init> <== NOT EXECUTED
10a7e2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a7e5: 85 c0 test %eax,%eax <== NOT EXECUTED
10a7e7: 74 0a je 10a7f3 <_POSIX_Mutex_Get_interrupt_disable+0x2f><== NOT EXECUTED
10a7e9: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED
10a7ef: 31 c0 xor %eax,%eax <== NOT EXECUTED
10a7f1: eb 13 jmp 10a806 <_POSIX_Mutex_Get_interrupt_disable+0x42><== NOT EXECUTED
return (POSIX_Mutex_Control *)
10a7f3: ff 75 10 pushl 0x10(%ebp)
10a7f6: 56 push %esi
10a7f7: ff 33 pushl (%ebx)
10a7f9: 68 18 2f 12 00 push $0x122f18
10a7fe: e8 15 29 00 00 call 10d118 <_Objects_Get_isr_disable>
10a803: 83 c4 10 add $0x10,%esp
_Objects_Get_isr_disable( &_POSIX_Mutex_Information, *id, location, level );
}
10a806: 8d 65 f8 lea -0x8(%ebp),%esp
10a809: 5b pop %ebx
10a80a: 5e pop %esi
10a80b: c9 leave
10a80c: c3 ret
00110ae0 <_POSIX_Semaphore_Create_support>:
const char *name,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
110ae0: 55 push %ebp
110ae1: 89 e5 mov %esp,%ebp
110ae3: 57 push %edi
110ae4: 56 push %esi
110ae5: 53 push %ebx
110ae6: 83 ec 0c sub $0xc,%esp
110ae9: 8b 75 08 mov 0x8(%ebp),%esi
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
110aec: a1 10 35 12 00 mov 0x123510,%eax
110af1: 40 inc %eax
110af2: a3 10 35 12 00 mov %eax,0x123510
char *name_p = (char *)name;
_Thread_Disable_dispatch();
/* Sharing semaphores among processes is not currently supported */
if (pshared != 0) {
110af7: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
110afb: 74 12 je 110b0f <_POSIX_Semaphore_Create_support+0x2f>
_Thread_Enable_dispatch();
110afd: e8 e6 d1 ff ff call 10dce8 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSYS );
110b02: e8 5d 1b 00 00 call 112664 <__errno>
110b07: c7 00 58 00 00 00 movl $0x58,(%eax)
110b0d: eb 28 jmp 110b37 <_POSIX_Semaphore_Create_support+0x57>
}
if ( name ) {
110b0f: 85 f6 test %esi,%esi
110b11: 74 2c je 110b3f <_POSIX_Semaphore_Create_support+0x5f>
if( strlen(name) > PATH_MAX ) {
110b13: 31 c0 xor %eax,%eax
110b15: 83 c9 ff or $0xffffffff,%ecx
110b18: 89 f7 mov %esi,%edi
110b1a: f2 ae repnz scas %es:(%edi),%al
110b1c: f7 d1 not %ecx
110b1e: 49 dec %ecx
110b1f: 81 f9 ff 00 00 00 cmp $0xff,%ecx
110b25: 76 18 jbe 110b3f <_POSIX_Semaphore_Create_support+0x5f><== ALWAYS TAKEN
_Thread_Enable_dispatch();
110b27: e8 bc d1 ff ff call 10dce8 <_Thread_Enable_dispatch><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
110b2c: e8 33 1b 00 00 call 112664 <__errno> <== NOT EXECUTED
110b31: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED
110b37: 83 c8 ff or $0xffffffff,%eax
110b3a: e9 90 00 00 00 jmp 110bcf <_POSIX_Semaphore_Create_support+0xef>
* It is a simple wrapper for the help with the addition of the
* allocation mutex being used for protection.
*/
/**@{*/
#ifdef __cplusplus
110b3f: 83 ec 0c sub $0xc,%esp
110b42: 68 00 38 12 00 push $0x123800
110b47: e8 98 c5 ff ff call 10d0e4 <_Objects_Allocate>
110b4c: 89 c3 mov %eax,%ebx
}
}
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
110b4e: 83 c4 10 add $0x10,%esp
110b51: 85 c0 test %eax,%eax
110b53: 75 12 jne 110b67 <_POSIX_Semaphore_Create_support+0x87>
_Thread_Enable_dispatch();
110b55: e8 8e d1 ff ff call 10dce8 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSPC );
110b5a: e8 05 1b 00 00 call 112664 <__errno>
110b5f: c7 00 1c 00 00 00 movl $0x1c,(%eax)
110b65: eb d0 jmp 110b37 <_POSIX_Semaphore_Create_support+0x57>
}
the_semaphore->process_shared = pshared;
110b67: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
if ( name ) {
110b6e: 85 f6 test %esi,%esi
110b70: 74 11 je 110b83 <_POSIX_Semaphore_Create_support+0xa3>
the_semaphore->named = TRUE;
110b72: c6 40 14 01 movb $0x1,0x14(%eax)
the_semaphore->open_count = 1;
110b76: c7 40 18 01 00 00 00 movl $0x1,0x18(%eax)
the_semaphore->linked = TRUE;
110b7d: c6 40 15 01 movb $0x1,0x15(%eax)
110b81: eb 0f jmp 110b92 <_POSIX_Semaphore_Create_support+0xb2>
} else {
the_semaphore->named = FALSE;
110b83: c6 40 14 00 movb $0x0,0x14(%eax)
the_semaphore->open_count = 0;
110b87: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_semaphore->linked = FALSE;
110b8e: c6 40 15 00 movb $0x0,0x15(%eax)
* 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;
110b92: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
110b99: c7 43 5c ff ff ff ff movl $0xffffffff,0x5c(%ebx)
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
110ba0: 50 push %eax
110ba1: ff 75 10 pushl 0x10(%ebp)
110ba4: 8d 43 5c lea 0x5c(%ebx),%eax
110ba7: 50 push %eax
110ba8: 8d 43 1c lea 0x1c(%ebx),%eax
110bab: 50 push %eax
110bac: e8 6f c1 ff ff call 10cd20 <_CORE_semaphore_Initialize>
110bb1: 0f b7 53 08 movzwl 0x8(%ebx),%edx
110bb5: a1 1c 38 12 00 mov 0x12381c,%eax
110bba: 89 1c 90 mov %ebx,(%eax,%edx,4)
110bbd: 89 73 0c mov %esi,0xc(%ebx)
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name_p
);
*the_sem = the_semaphore;
110bc0: 8b 45 14 mov 0x14(%ebp),%eax
110bc3: 89 18 mov %ebx,(%eax)
_Thread_Enable_dispatch();
110bc5: e8 1e d1 ff ff call 10dce8 <_Thread_Enable_dispatch>
110bca: 31 c0 xor %eax,%eax
110bcc: 83 c4 10 add $0x10,%esp
return 0;
}
110bcf: 8d 65 f4 lea -0xc(%ebp),%esp
110bd2: 5b pop %ebx
110bd3: 5e pop %esi
110bd4: 5f pop %edi
110bd5: c9 leave
110bd6: c3 ret
0010d6cd <_POSIX_Threads_Create_extension>:
bool _POSIX_Threads_Create_extension(
Thread_Control *executing,
Thread_Control *created
)
{
10d6cd: 55 push %ebp
10d6ce: 89 e5 mov %esp,%ebp
10d6d0: 57 push %edi
10d6d1: 56 push %esi
10d6d2: 53 push %ebx
10d6d3: 83 ec 18 sub $0x18,%esp
POSIX_API_Control *api;
POSIX_API_Control *executing_api;
api = _Workspace_Allocate( sizeof( POSIX_API_Control ) );
10d6d6: 68 e4 00 00 00 push $0xe4
10d6db: e8 49 e7 ff ff call 10be29 <_Workspace_Allocate>
10d6e0: 89 c3 mov %eax,%ebx
if ( !api )
10d6e2: 83 c4 10 add $0x10,%esp
10d6e5: 31 c0 xor %eax,%eax
10d6e7: 85 db test %ebx,%ebx
10d6e9: 0f 84 05 01 00 00 je 10d7f4 <_POSIX_Threads_Create_extension+0x127><== NEVER TAKEN
return false;
created->API_Extensions[ THREAD_API_POSIX ] = api;
10d6ef: 8b 45 0c mov 0xc(%ebp),%eax
10d6f2: 89 98 f8 00 00 00 mov %ebx,0xf8(%eax)
/* XXX check all fields are touched */
api->Attributes = _POSIX_Threads_Default_attributes;
10d6f8: be 38 79 11 00 mov $0x117938,%esi
10d6fd: b9 0e 00 00 00 mov $0xe,%ecx
10d702: 89 df mov %ebx,%edi
10d704: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
api->detachstate = _POSIX_Threads_Default_attributes.detachstate;
10d706: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx)
api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy;
10d70d: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx)
api->schedparam = _POSIX_Threads_Default_attributes.schedparam;
10d714: be 50 79 11 00 mov $0x117950,%esi
10d719: 8d bb 80 00 00 00 lea 0x80(%ebx),%edi
10d71f: b1 06 mov $0x6,%cl
10d721: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
api->schedparam.sched_priority =
10d723: b8 ff 00 00 00 mov $0xff,%eax
10d728: 8b 55 0c mov 0xc(%ebp),%edx
10d72b: 2b 42 14 sub 0x14(%edx),%eax
10d72e: 89 83 80 00 00 00 mov %eax,0x80(%ebx)
_POSIX_Priority_From_core( created->current_priority );
/*
* POSIX 1003.1 1996, 18.2.2.2
*/
api->cancelation_requested = 0;
10d734: c7 83 d4 00 00 00 00 movl $0x0,0xd4(%ebx)
10d73b: 00 00 00
api->cancelability_state = PTHREAD_CANCEL_ENABLE;
10d73e: c7 83 cc 00 00 00 00 movl $0x0,0xcc(%ebx)
10d745: 00 00 00
api->cancelability_type = PTHREAD_CANCEL_DEFERRED;
10d748: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx)
10d74f: 00 00 00
10d752: 8d 83 dc 00 00 00 lea 0xdc(%ebx),%eax
10d758: 89 83 d8 00 00 00 mov %eax,0xd8(%ebx)
10d75e: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx)
10d765: 00 00 00
10d768: 8d 83 d8 00 00 00 lea 0xd8(%ebx),%eax
10d76e: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx)
* If the thread is not a posix thread, then all posix signals are blocked
* by default.
*/
/* XXX use signal constants */
api->signals_pending = 0;
10d774: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx)
10d77b: 00 00 00
if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API &&
10d77e: 8b 52 08 mov 0x8(%edx),%edx
10d781: 89 d0 mov %edx,%eax
10d783: c1 e8 18 shr $0x18,%eax
10d786: 83 e0 07 and $0x7,%eax
10d789: 83 f8 03 cmp $0x3,%eax
10d78c: 75 1f jne 10d7ad <_POSIX_Threads_Create_extension+0xe0>
10d78e: c1 ea 1b shr $0x1b,%edx
10d791: 4a dec %edx
10d792: 75 19 jne 10d7ad <_POSIX_Threads_Create_extension+0xe0><== NEVER TAKEN
_Objects_Get_class( created->Object.id ) == 1 ) {
executing_api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
api->signals_blocked = executing_api->signals_blocked;
10d794: a1 58 d8 11 00 mov 0x11d858,%eax
10d799: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax
10d79f: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax
10d7a5: 89 83 c4 00 00 00 mov %eax,0xc4(%ebx)
10d7ab: eb 0a jmp 10d7b7 <_POSIX_Threads_Create_extension+0xea>
} else {
api->signals_blocked = 0xffffffff;
10d7ad: c7 83 c4 00 00 00 ff movl $0xffffffff,0xc4(%ebx)
10d7b4: ff ff ff
}
_Thread_queue_Initialize(
10d7b7: 6a 00 push $0x0
10d7b9: 68 00 10 00 00 push $0x1000
10d7be: 6a 00 push $0x0
10d7c0: 8d 43 3c lea 0x3c(%ebx),%eax
10d7c3: 50 push %eax
10d7c4: e8 47 dd ff ff call 10b510 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_JOIN_AT_EXIT,
0
);
_Watchdog_Initialize(
10d7c9: 8b 55 0c mov 0xc(%ebp),%edx
10d7cc: 8b 42 08 mov 0x8(%edx),%eax
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
10d7cf: c7 83 a4 00 00 00 00 movl $0x0,0xa4(%ebx)
10d7d6: 00 00 00
* @param[in] the_heap is the heap to operate upon
10d7d9: c7 83 b8 00 00 00 3a movl $0x10d83a,0xb8(%ebx)
10d7e0: d8 10 00
* @param[in] starting_address is the starting address of the memory for
10d7e3: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx)
* the heap
10d7e9: 89 93 c0 00 00 00 mov %edx,0xc0(%ebx)
10d7ef: b0 01 mov $0x1,%al
10d7f1: 83 c4 10 add $0x10,%esp
created->Object.id,
created
);
return true;
}
10d7f4: 8d 65 f4 lea -0xc(%ebp),%esp
10d7f7: 5b pop %ebx
10d7f8: 5e pop %esi
10d7f9: 5f pop %edi
10d7fa: c9 leave
10d7fb: c3 ret
00109d4c <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body( void )
{
109d4c: 55 push %ebp
109d4d: 89 e5 mov %esp,%ebp
109d4f: 57 push %edi
109d50: 56 push %esi
109d51: 53 push %ebx
109d52: 83 ec 4c sub $0x4c,%esp
uint32_t maximum;
posix_initialization_threads_table *user_threads;
pthread_t thread_id;
pthread_attr_t attr;
user_threads = _POSIX_Threads_User_initialization_threads;
109d55: 8b 35 20 15 12 00 mov 0x121520,%esi
maximum = _POSIX_Threads_Number_of_initialization_threads;
109d5b: a1 d8 15 12 00 mov 0x1215d8,%eax
109d60: 89 45 b0 mov %eax,-0x50(%ebp)
if ( !user_threads || maximum == 0 )
109d63: 85 f6 test %esi,%esi
109d65: 74 51 je 109db8 <_POSIX_Threads_Initialize_user_threads_body+0x6c><== NEVER TAKEN
109d67: 85 c0 test %eax,%eax
109d69: 74 4d je 109db8 <_POSIX_Threads_Initialize_user_threads_body+0x6c><== NEVER TAKEN
return;
109d6b: 31 db xor %ebx,%ebx
for ( index=0 ; index < maximum ; index++ ) {
/*
* There is no way for these calls to fail in this situation.
*/
(void) pthread_attr_init( &attr );
109d6d: 8d 7d b8 lea -0x48(%ebp),%edi
109d70: eb 41 jmp 109db3 <_POSIX_Threads_Initialize_user_threads_body+0x67>
109d72: 83 ec 0c sub $0xc,%esp
109d75: 57 push %edi
109d76: e8 cd 54 00 00 call 10f248 <pthread_attr_init>
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
109d7b: 58 pop %eax
109d7c: 5a pop %edx
109d7d: 6a 02 push $0x2
109d7f: 57 push %edi
109d80: e8 eb 54 00 00 call 10f270 <pthread_attr_setinheritsched>
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
109d85: 59 pop %ecx
109d86: 58 pop %eax
109d87: ff 74 de 04 pushl 0x4(%esi,%ebx,8)
109d8b: 57 push %edi
109d8c: e8 13 55 00 00 call 10f2a4 <pthread_attr_setstacksize>
status = pthread_create(
109d91: 6a 00 push $0x0
109d93: ff 34 de pushl (%esi,%ebx,8)
109d96: 57 push %edi
109d97: 8d 45 f0 lea -0x10(%ebp),%eax
109d9a: 50 push %eax
109d9b: e8 84 fc ff ff call 109a24 <pthread_create>
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
109da0: 83 c4 20 add $0x20,%esp
109da3: 85 c0 test %eax,%eax
109da5: 74 0b je 109db2 <_POSIX_Threads_Initialize_user_threads_body+0x66>
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, TRUE, status );
109da7: 52 push %edx
109da8: 50 push %eax
109da9: 6a 01 push $0x1
109dab: 6a 02 push $0x2
109dad: e8 36 1e 00 00 call 10bbe8 <_Internal_error_Occurred>
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
109db2: 43 inc %ebx
109db3: 3b 5d b0 cmp -0x50(%ebp),%ebx
109db6: 72 ba jb 109d72 <_POSIX_Threads_Initialize_user_threads_body+0x26>
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, TRUE, status );
}
}
109db8: 8d 65 f4 lea -0xc(%ebp),%esp
109dbb: 5b pop %ebx
109dbc: 5e pop %esi
109dbd: 5f pop %edi
109dbe: c9 leave
109dbf: c3 ret
0010d83a <_POSIX_Threads_Sporadic_budget_TSR>:
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id,
void *argument
)
{
10d83a: 55 push %ebp
10d83b: 89 e5 mov %esp,%ebp
10d83d: 56 push %esi
10d83e: 53 push %ebx
10d83f: 8b 5d 0c mov 0xc(%ebp),%ebx
Thread_Control *the_thread;
POSIX_API_Control *api;
the_thread = argument;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10d842: 8b b3 f8 00 00 00 mov 0xf8(%ebx),%esi
ticks = _Timespec_To_ticks( &api->schedparam.ss_initial_budget );
10d848: 83 ec 0c sub $0xc,%esp
10d84b: 8d 86 90 00 00 00 lea 0x90(%esi),%eax
10d851: 50 push %eax
10d852: e8 99 0c 00 00 call 10e4f0 <_Timespec_To_ticks>
if ( !ticks )
10d857: 83 c4 10 add $0x10,%esp
10d85a: 85 c0 test %eax,%eax
10d85c: 75 02 jne 10d860 <_POSIX_Threads_Sporadic_budget_TSR+0x26><== ALWAYS TAKEN
10d85e: b0 01 mov $0x1,%al <== NOT EXECUTED
ticks = 1;
the_thread->cpu_time_budget = ticks;
10d860: 89 43 78 mov %eax,0x78(%ebx)
10d863: b8 ff 00 00 00 mov $0xff,%eax
10d868: 2b 86 98 00 00 00 sub 0x98(%esi),%eax
new_priority = _POSIX_Priority_To_core( api->ss_high_priority );
the_thread->real_priority = new_priority;
10d86e: 89 43 18 mov %eax,0x18(%ebx)
if ( the_thread->resource_count == 0 ||
10d871: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx)
10d875: 74 05 je 10d87c <_POSIX_Threads_Sporadic_budget_TSR+0x42>
10d877: 39 43 14 cmp %eax,0x14(%ebx)
10d87a: 76 0d jbe 10d889 <_POSIX_Threads_Sporadic_budget_TSR+0x4f><== NEVER TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, TRUE );
10d87c: 52 push %edx
10d87d: 6a 01 push $0x1
10d87f: 50 push %eax
10d880: 53 push %ebx
10d881: e8 66 d1 ff ff call 10a9ec <_Thread_Change_priority>
10d886: 83 c4 10 add $0x10,%esp
ticks = _Timespec_To_ticks( &api->schedparam.ss_replenish_period );
10d889: 83 ec 0c sub $0xc,%esp
10d88c: 8d 86 88 00 00 00 lea 0x88(%esi),%eax
10d892: 50 push %eax
10d893: e8 58 0c 00 00 call 10e4f0 <_Timespec_To_ticks>
if ( !ticks )
10d898: 83 c4 10 add $0x10,%esp
10d89b: 85 c0 test %eax,%eax
10d89d: 75 02 jne 10d8a1 <_POSIX_Threads_Sporadic_budget_TSR+0x67><== ALWAYS TAKEN
10d89f: b0 01 mov $0x1,%al <== NOT EXECUTED
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
Heap_Control *the_heap,
10d8a1: 89 86 a8 00 00 00 mov %eax,0xa8(%esi)
void *starting_address,
size_t *size
10d8a7: 8d 86 9c 00 00 00 lea 0x9c(%esi),%eax
10d8ad: 89 45 0c mov %eax,0xc(%ebp)
10d8b0: c7 45 08 78 d8 11 00 movl $0x11d878,0x8(%ebp)
ticks = 1;
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
}
10d8b7: 8d 65 f8 lea -0x8(%ebp),%esp
10d8ba: 5b pop %ebx
10d8bb: 5e pop %esi
10d8bc: c9 leave
10d8bd: e9 66 e3 ff ff jmp 10bc28 <_Watchdog_Insert>
0010d7fc <_POSIX_Threads_Sporadic_budget_callout>:
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
10d7fc: 55 push %ebp
10d7fd: 89 e5 mov %esp,%ebp
10d7ff: 83 ec 08 sub $0x8,%esp
10d802: 8b 4d 08 mov 0x8(%ebp),%ecx
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10d805: 8b 81 f8 00 00 00 mov 0xf8(%ecx),%eax
* 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 */
10d80b: c7 41 78 ff ff ff ff movl $0xffffffff,0x78(%ecx)
/**
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
10d812: ba ff 00 00 00 mov $0xff,%edx
10d817: 2b 90 84 00 00 00 sub 0x84(%eax),%edx
new_priority = _POSIX_Priority_To_core( api->schedparam.ss_low_priority );
the_thread->real_priority = new_priority;
10d81d: 89 51 18 mov %edx,0x18(%ecx)
if ( the_thread->resource_count == 0 ||
10d820: 83 79 1c 00 cmpl $0x0,0x1c(%ecx)
10d824: 74 05 je 10d82b <_POSIX_Threads_Sporadic_budget_callout+0x2f><== ALWAYS TAKEN
10d826: 39 51 14 cmp %edx,0x14(%ecx) <== NOT EXECUTED
10d829: 76 0d jbe 10d838 <_POSIX_Threads_Sporadic_budget_callout+0x3c><== NOT EXECUTED
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, TRUE );
10d82b: 50 push %eax
10d82c: 6a 01 push $0x1
10d82e: 52 push %edx
10d82f: 51 push %ecx
10d830: e8 b7 d1 ff ff call 10a9ec <_Thread_Change_priority>
10d835: 83 c4 10 add $0x10,%esp
}
10d838: c9 leave
10d839: c3 ret
0010e9dc <_POSIX_Threads_cancel_run>:
#include <rtems/posix/threadsup.h>
void _POSIX_Threads_cancel_run(
Thread_Control *the_thread
)
{
10e9dc: 55 push %ebp
10e9dd: 89 e5 mov %esp,%ebp
10e9df: 57 push %edi
10e9e0: 56 push %esi
10e9e1: 53 push %ebx
10e9e2: 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 ];
10e9e5: 8b 45 08 mov 0x8(%ebp),%eax
10e9e8: 8b b0 f8 00 00 00 mov 0xf8(%eax),%esi
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
10e9ee: c7 86 cc 00 00 00 01 movl $0x1,0xcc(%esi)
10e9f5: 00 00 00
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
10e9f8: 8d be dc 00 00 00 lea 0xdc(%esi),%edi
10e9fe: eb 26 jmp 10ea26 <_POSIX_Threads_cancel_run+0x4a>
while ( !_Chain_Is_empty( handler_stack ) ) {
_ISR_Disable( level );
10ea00: 9c pushf <== NOT EXECUTED
10ea01: fa cli <== NOT EXECUTED
10ea02: 59 pop %ecx <== NOT EXECUTED
handler = (POSIX_Cancel_Handler_control *)
10ea03: 8b 5f 04 mov 0x4(%edi),%ebx <== NOT EXECUTED
10ea06: 8b 13 mov (%ebx),%edx <== NOT EXECUTED
10ea08: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED
10ea0b: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED
10ea0e: 89 10 mov %edx,(%eax) <== NOT EXECUTED
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
10ea10: 51 push %ecx <== NOT EXECUTED
10ea11: 9d popf <== NOT EXECUTED
(*handler->routine)( handler->arg );
10ea12: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ea15: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED
10ea18: ff 53 08 call *0x8(%ebx) <== NOT EXECUTED
_Workspace_Free( handler );
10ea1b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10ea1e: e8 f1 d3 ff ff call 10be14 <_Workspace_Free> <== NOT EXECUTED
10ea23: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
handler_stack = &thread_support->Cancellation_Handlers;
thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE;
while ( !_Chain_Is_empty( handler_stack ) ) {
10ea26: 39 be d8 00 00 00 cmp %edi,0xd8(%esi)
10ea2c: 75 d2 jne 10ea00 <_POSIX_Threads_cancel_run+0x24><== NEVER TAKEN
(*handler->routine)( handler->arg );
_Workspace_Free( handler );
}
}
10ea2e: 8d 65 f4 lea -0xc(%ebp),%esp
10ea31: 5b pop %ebx
10ea32: 5e pop %esi
10ea33: 5f pop %edi
10ea34: c9 leave
10ea35: c3 ret
0010f508 <_POSIX_Timer_Insert_helper>:
Watchdog_Interval ticks,
Objects_Id id,
Watchdog_Service_routine_entry TSR,
void *arg
)
{
10f508: 55 push %ebp
10f509: 89 e5 mov %esp,%ebp
10f50b: 56 push %esi
10f50c: 53 push %ebx
10f50d: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level;
(void) _Watchdog_Remove( timer );
10f510: 83 ec 0c sub $0xc,%esp
10f513: 53 push %ebx
10f514: e8 4b e2 ff ff call 10d764 <_Watchdog_Remove>
_ISR_Disable( level );
10f519: 9c pushf
10f51a: fa cli
10f51b: 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 ) {
10f51c: 83 c4 10 add $0x10,%esp
10f51f: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10f523: 74 06 je 10f52b <_POSIX_Timer_Insert_helper+0x23><== ALWAYS TAKEN
_ISR_Enable( level );
10f525: 56 push %esi <== NOT EXECUTED
10f526: 9d popf <== NOT EXECUTED
10f527: 31 c0 xor %eax,%eax <== NOT EXECUTED
10f529: eb 33 jmp 10f55e <_POSIX_Timer_Insert_helper+0x56><== NOT EXECUTED
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
10f52b: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
* @param[in] the_heap is the heap to operate upon
10f532: 8b 45 14 mov 0x14(%ebp),%eax
10f535: 89 43 1c mov %eax,0x1c(%ebx)
* @param[in] starting_address is the starting address of the memory for
10f538: 8b 45 10 mov 0x10(%ebp),%eax
10f53b: 89 43 20 mov %eax,0x20(%ebx)
* the heap
10f53e: 8b 45 18 mov 0x18(%ebp),%eax
10f541: 89 43 24 mov %eax,0x24(%ebx)
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
Heap_Control *the_heap,
10f544: 8b 45 0c mov 0xc(%ebp),%eax
10f547: 89 43 0c mov %eax,0xc(%ebx)
void *starting_address,
size_t *size
10f54a: 50 push %eax
10f54b: 50 push %eax
10f54c: 53 push %ebx
10f54d: 68 30 1b 12 00 push $0x121b30
10f552: e8 f5 e0 ff ff call 10d64c <_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 );
10f557: 56 push %esi
10f558: 9d popf
10f559: b0 01 mov $0x1,%al
10f55b: 83 c4 10 add $0x10,%esp
return true;
}
10f55e: 8d 65 f8 lea -0x8(%ebp),%esp
10f561: 5b pop %ebx
10f562: 5e pop %esi
10f563: c9 leave
10f564: c3 ret
0010a310 <_POSIX_Timer_TSR>:
/*
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR(Objects_Id timer, void *data)
{
10a310: 55 push %ebp
10a311: 89 e5 mov %esp,%ebp
10a313: 53 push %ebx
10a314: 83 ec 04 sub $0x4,%esp
10a317: 8b 5d 0c mov 0xc(%ebp),%ebx
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
10a31a: ff 43 68 incl 0x68(%ebx)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
10a31d: 83 7b 54 00 cmpl $0x0,0x54(%ebx)
10a321: 75 06 jne 10a329 <_POSIX_Timer_TSR+0x19> <== ALWAYS TAKEN
10a323: 83 7b 58 00 cmpl $0x0,0x58(%ebx) <== NOT EXECUTED
10a327: 74 34 je 10a35d <_POSIX_Timer_TSR+0x4d> <== NOT EXECUTED
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
10a329: 83 ec 0c sub $0xc,%esp
10a32c: 53 push %ebx
10a32d: 68 10 a3 10 00 push $0x10a310
10a332: ff 73 08 pushl 0x8(%ebx)
10a335: ff 73 64 pushl 0x64(%ebx)
10a338: 8d 43 10 lea 0x10(%ebx),%eax
10a33b: 50 push %eax
10a33c: e8 c7 51 00 00 call 10f508 <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
10a341: 83 c4 20 add $0x20,%esp
10a344: 84 c0 test %al,%al
10a346: 74 30 je 10a378 <_POSIX_Timer_TSR+0x68> <== NEVER TAKEN
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
10a348: 83 ec 0c sub $0xc,%esp
10a34b: 8d 43 6c lea 0x6c(%ebx),%eax
10a34e: 50 push %eax
10a34f: e8 28 15 00 00 call 10b87c <_TOD_Get>
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10a354: c6 43 3c 03 movb $0x3,0x3c(%ebx)
10a358: 83 c4 10 add $0x10,%esp
10a35b: eb 04 jmp 10a361 <_POSIX_Timer_TSR+0x51>
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10a35d: 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 ) ) {
10a361: 50 push %eax
10a362: 50 push %eax
10a363: ff 73 44 pushl 0x44(%ebx)
10a366: ff 73 38 pushl 0x38(%ebx)
10a369: e8 0a 4f 00 00 call 10f278 <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
10a36e: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
10a375: 83 c4 10 add $0x10,%esp
}
10a378: 8b 5d fc mov -0x4(%ebp),%ebx
10a37b: c9 leave
10a37c: c3 ret
0010eae0 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
10eae0: 55 push %ebp
10eae1: 89 e5 mov %esp,%ebp
10eae3: 57 push %edi
10eae4: 56 push %esi
10eae5: 53 push %ebx
10eae6: 83 ec 28 sub $0x28,%esp
10eae9: 8b 7d 08 mov 0x8(%ebp),%edi
10eaec: 8b 75 0c mov 0xc(%ebp),%esi
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
10eaef: 6a 01 push $0x1
10eaf1: 0f b6 45 10 movzbl 0x10(%ebp),%eax
10eaf5: 50 push %eax
10eaf6: 8d 45 e8 lea -0x18(%ebp),%eax
10eaf9: 50 push %eax
10eafa: 56 push %esi
10eafb: 57 push %edi
10eafc: e8 5f 00 00 00 call 10eb60 <_POSIX_signals_Clear_signals>
10eb01: 83 c4 20 add $0x20,%esp
10eb04: 84 c0 test %al,%al
10eb06: 74 4e je 10eb56 <_POSIX_signals_Check_signal+0x76>
#endif
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
10eb08: 6b d6 0c imul $0xc,%esi,%edx
10eb0b: 8b 8a 44 dd 11 00 mov 0x11dd44(%edx),%ecx
10eb11: 83 f9 01 cmp $0x1,%ecx
10eb14: 74 40 je 10eb56 <_POSIX_signals_Check_signal+0x76><== NEVER TAKEN
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
10eb16: 8b 9f c4 00 00 00 mov 0xc4(%edi),%ebx
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
10eb1c: 89 d8 mov %ebx,%eax
10eb1e: 0b 82 40 dd 11 00 or 0x11dd40(%edx),%eax
10eb24: 89 87 c4 00 00 00 mov %eax,0xc4(%edi)
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
10eb2a: 83 ba 3c dd 11 00 02 cmpl $0x2,0x11dd3c(%edx)
10eb31: 75 10 jne 10eb43 <_POSIX_signals_Check_signal+0x63>
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
10eb33: 50 push %eax
10eb34: 6a 00 push $0x0
10eb36: 8d 45 e8 lea -0x18(%ebp),%eax
10eb39: 50 push %eax
10eb3a: 56 push %esi
10eb3b: ff 92 44 dd 11 00 call *0x11dd44(%edx)
10eb41: eb 06 jmp 10eb49 <_POSIX_signals_Check_signal+0x69>
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
10eb43: 83 ec 0c sub $0xc,%esp
10eb46: 56 push %esi
10eb47: ff d1 call *%ecx
10eb49: 83 c4 10 add $0x10,%esp
}
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
10eb4c: 89 9f c4 00 00 00 mov %ebx,0xc4(%edi)
10eb52: b0 01 mov $0x1,%al
10eb54: eb 02 jmp 10eb58 <_POSIX_signals_Check_signal+0x78>
return true;
10eb56: 31 c0 xor %eax,%eax
}
10eb58: 8d 65 f4 lea -0xc(%ebp),%esp
10eb5b: 5b pop %ebx
10eb5c: 5e pop %esi
10eb5d: 5f pop %edi
10eb5e: c9 leave
10eb5f: c3 ret
0010f0ec <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
sigset_t mask
)
{
10f0ec: 55 push %ebp
10f0ed: 89 e5 mov %esp,%ebp
10f0ef: 8b 45 08 mov 0x8(%ebp),%eax
ISR_Level level;
_ISR_Disable( level );
10f0f2: 9c pushf
10f0f3: fa cli
10f0f4: 5a pop %edx
_POSIX_signals_Pending &= ~mask;
10f0f5: f7 d0 not %eax
10f0f7: 23 05 08 df 11 00 and 0x11df08,%eax
10f0fd: a3 08 df 11 00 mov %eax,0x11df08
if ( !_POSIX_signals_Pending )
10f102: 85 c0 test %eax,%eax
10f104: 75 06 jne 10f10c <_POSIX_signals_Clear_process_signals+0x20><== NEVER TAKEN
_Thread_Do_post_task_switch_extension--;
10f106: ff 0d 3c d8 11 00 decl 0x11d83c
_ISR_Enable( level );
10f10c: 52 push %edx
10f10d: 9d popf
}
10f10e: c9 leave
10f10f: c3 ret
0010eb60 <_POSIX_signals_Clear_signals>:
int signo,
siginfo_t *info,
bool is_global,
bool check_blocked
)
{
10eb60: 55 push %ebp
10eb61: 89 e5 mov %esp,%ebp
10eb63: 57 push %edi
10eb64: 56 push %esi
10eb65: 53 push %ebx
10eb66: 83 ec 0c sub $0xc,%esp
10eb69: 8b 5d 08 mov 0x8(%ebp),%ebx
10eb6c: 8b 7d 0c mov 0xc(%ebp),%edi
10eb6f: 8a 45 14 mov 0x14(%ebp),%al
sigset_t signals_blocked;
ISR_Level level;
bool do_callout;
POSIX_signals_Siginfo_node *psiginfo;
mask = signo_to_mask( signo );
10eb72: 8d 4f ff lea -0x1(%edi),%ecx
10eb75: be 01 00 00 00 mov $0x1,%esi
10eb7a: d3 e6 shl %cl,%esi
/* 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 )
10eb7c: 83 ca ff or $0xffffffff,%edx
10eb7f: 80 7d 18 00 cmpb $0x0,0x18(%ebp)
10eb83: 74 08 je 10eb8d <_POSIX_signals_Clear_signals+0x2d>
signals_blocked = ~api->signals_blocked;
10eb85: 8b 93 c4 00 00 00 mov 0xc4(%ebx),%edx
10eb8b: f7 d2 not %edx
signals_blocked = SIGNAL_ALL_MASK;
/* XXX this is not right for siginfo type signals yet */
/* XXX since they can't be cleared the same way */
_ISR_Disable( level );
10eb8d: 9c pushf
10eb8e: fa cli
10eb8f: 8f 45 f0 popl -0x10(%ebp)
if ( is_global ) {
10eb92: 84 c0 test %al,%al
10eb94: 0f 84 8d 00 00 00 je 10ec27 <_POSIX_signals_Clear_signals+0xc7>
if ( mask & (_POSIX_signals_Pending & signals_blocked) ) {
10eb9a: 89 f0 mov %esi,%eax
10eb9c: 23 05 08 df 11 00 and 0x11df08,%eax
10eba2: 85 d0 test %edx,%eax
10eba4: 0f 84 9b 00 00 00 je 10ec45 <_POSIX_signals_Clear_signals+0xe5>
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
10ebaa: 6b d7 0c imul $0xc,%edi,%edx
10ebad: 83 ba 3c dd 11 00 02 cmpl $0x2,0x11dd3c(%edx)
10ebb4: 75 61 jne 10ec17 <_POSIX_signals_Clear_signals+0xb7>
psiginfo = (POSIX_signals_Siginfo_node *)
10ebb6: 8d 8a 0c df 11 00 lea 0x11df0c(%edx),%ecx
* to obtain the size of
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
10ebbc: 8b 9a 0c df 11 00 mov 0x11df0c(%edx),%ebx
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
10ebc2: 8d 79 04 lea 0x4(%ecx),%edi
10ebc5: 39 fb cmp %edi,%ebx
10ebc7: 75 04 jne 10ebcd <_POSIX_signals_Clear_signals+0x6d><== ALWAYS TAKEN
10ebc9: 31 db xor %ebx,%ebx
10ebcb: eb 0b jmp 10ebd8 <_POSIX_signals_Clear_signals+0x78><== NOT EXECUTED
10ebcd: 8b 03 mov (%ebx),%eax
10ebcf: 89 82 0c df 11 00 mov %eax,0x11df0c(%edx)
10ebd5: 89 48 04 mov %ecx,0x4(%eax)
_Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] );
if ( _Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
10ebd8: 39 ba 0c df 11 00 cmp %edi,0x11df0c(%edx)
10ebde: 75 0c jne 10ebec <_POSIX_signals_Clear_signals+0x8c><== NEVER TAKEN
_POSIX_signals_Clear_process_signals( mask );
10ebe0: 83 ec 0c sub $0xc,%esp
10ebe3: 56 push %esi
10ebe4: e8 03 05 00 00 call 10f0ec <_POSIX_signals_Clear_process_signals>
10ebe9: 83 c4 10 add $0x10,%esp
if ( psiginfo ) {
10ebec: b0 01 mov $0x1,%al
10ebee: 85 db test %ebx,%ebx
10ebf0: 74 55 je 10ec47 <_POSIX_signals_Clear_signals+0xe7><== NEVER TAKEN
*info = psiginfo->Info;
10ebf2: 8d 73 08 lea 0x8(%ebx),%esi
10ebf5: b9 03 00 00 00 mov $0x3,%ecx
10ebfa: 8b 7d 10 mov 0x10(%ebp),%edi
10ebfd: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10ebff: c7 03 c0 de 11 00 movl $0x11dec0,(%ebx)
10ec05: a1 c4 de 11 00 mov 0x11dec4,%eax
10ec0a: 89 1d c4 de 11 00 mov %ebx,0x11dec4
10ec10: 89 18 mov %ebx,(%eax)
10ec12: 89 43 04 mov %eax,0x4(%ebx)
10ec15: eb 2a jmp 10ec41 <_POSIX_signals_Clear_signals+0xe1>
&psiginfo->Node
);
} else
do_callout = false;
} else
_POSIX_signals_Clear_process_signals( mask );
10ec17: 83 ec 0c sub $0xc,%esp
10ec1a: 56 push %esi
10ec1b: e8 cc 04 00 00 call 10f0ec <_POSIX_signals_Clear_process_signals>
10ec20: b0 01 mov $0x1,%al
10ec22: 83 c4 10 add $0x10,%esp
10ec25: eb 20 jmp 10ec47 <_POSIX_signals_Clear_signals+0xe7>
do_callout = true;
}
} else {
if ( mask & (api->signals_pending & signals_blocked) ) {
10ec27: 8b 8b c8 00 00 00 mov 0xc8(%ebx),%ecx
10ec2d: 89 f0 mov %esi,%eax
10ec2f: 21 c8 and %ecx,%eax
10ec31: 85 d0 test %edx,%eax
10ec33: 74 10 je 10ec45 <_POSIX_signals_Clear_signals+0xe5>
api->signals_pending &= ~mask;
10ec35: 89 f0 mov %esi,%eax
10ec37: f7 d0 not %eax
10ec39: 21 c8 and %ecx,%eax
10ec3b: 89 83 c8 00 00 00 mov %eax,0xc8(%ebx)
10ec41: b0 01 mov $0x1,%al
10ec43: eb 02 jmp 10ec47 <_POSIX_signals_Clear_signals+0xe7>
10ec45: 31 c0 xor %eax,%eax
do_callout = true;
}
}
_ISR_Enable( level );
10ec47: ff 75 f0 pushl -0x10(%ebp)
10ec4a: 9d popf
return do_callout;
}
10ec4b: 8d 65 f4 lea -0xc(%ebp),%esp
10ec4e: 5b pop %ebx
10ec4f: 5e pop %esi
10ec50: 5f pop %edi
10ec51: c9 leave
10ec52: c3 ret
001099f8 <_POSIX_signals_Get_highest>:
#include <rtems/score/isr.h>
int _POSIX_signals_Get_highest(
sigset_t set
)
{
1099f8: 55 push %ebp
1099f9: 89 e5 mov %esp,%ebp
1099fb: 56 push %esi
1099fc: 53 push %ebx
1099fd: 8b 5d 08 mov 0x8(%ebp),%ebx
109a00: b8 1b 00 00 00 mov $0x1b,%eax
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) )
109a05: ba 01 00 00 00 mov $0x1,%edx
109a0a: 8d 48 ff lea -0x1(%eax),%ecx
109a0d: 89 d6 mov %edx,%esi
109a0f: d3 e6 shl %cl,%esi
109a11: 85 de test %ebx,%esi
109a13: 75 20 jne 109a35 <_POSIX_signals_Get_highest+0x3d><== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
109a15: 40 inc %eax
109a16: 83 f8 20 cmp $0x20,%eax
109a19: 75 ef jne 109a0a <_POSIX_signals_Get_highest+0x12>
109a1b: b0 01 mov $0x1,%al
}
/* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
if ( set & signo_to_mask( signo ) )
109a1d: ba 01 00 00 00 mov $0x1,%edx
109a22: 8d 48 ff lea -0x1(%eax),%ecx
109a25: 89 d6 mov %edx,%esi
109a27: d3 e6 shl %cl,%esi
109a29: 85 de test %ebx,%esi
109a2b: 75 08 jne 109a35 <_POSIX_signals_Get_highest+0x3d>
return signo;
}
/* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
109a2d: 40 inc %eax
109a2e: 83 f8 1b cmp $0x1b,%eax
109a31: 75 ef jne 109a22 <_POSIX_signals_Get_highest+0x2a><== ALWAYS TAKEN
109a33: 30 c0 xor %al,%al <== NOT EXECUTED
if ( set & signo_to_mask( signo ) )
return signo;
}
return 0;
}
109a35: 5b pop %ebx
109a36: 5e pop %esi
109a37: c9 leave
109a38: c3 ret
0010d509 <_POSIX_signals_Post_switch_extension>:
*/
void _POSIX_signals_Post_switch_extension(
Thread_Control *the_thread
)
{
10d509: 55 push %ebp
10d50a: 89 e5 mov %esp,%ebp
10d50c: 56 push %esi
10d50d: 53 push %ebx
POSIX_API_Control *api;
int signo;
ISR_Level level;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10d50e: 8b 45 08 mov 0x8(%ebp),%eax
10d511: 8b b0 f8 00 00 00 mov 0xf8(%eax),%esi
if ( !api )
10d517: 85 f6 test %esi,%esi
10d519: 74 7a je 10d595 <_POSIX_signals_Post_switch_extension+0x8c><== NEVER TAKEN
* The first thing done is to check there are any signals to be
* processed at all. No point in doing this loop otherwise.
*/
while (1) {
restart:
_ISR_Disable( level );
10d51b: 9c pushf
10d51c: fa cli
10d51d: 59 pop %ecx
if ( !(~api->signals_blocked &
10d51e: 8b 15 08 df 11 00 mov 0x11df08,%edx
10d524: 0b 96 c8 00 00 00 or 0xc8(%esi),%edx
10d52a: 8b 86 c4 00 00 00 mov 0xc4(%esi),%eax
10d530: f7 d0 not %eax
10d532: 85 c2 test %eax,%edx
10d534: 75 04 jne 10d53a <_POSIX_signals_Post_switch_extension+0x31>
(api->signals_pending | _POSIX_signals_Pending)) ) {
_ISR_Enable( level );
10d536: 51 push %ecx
10d537: 9d popf
10d538: eb 5b jmp 10d595 <_POSIX_signals_Post_switch_extension+0x8c>
break;
}
_ISR_Enable( level );
10d53a: 51 push %ecx
10d53b: 9d popf
10d53c: bb 1b 00 00 00 mov $0x1b,%ebx
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( _POSIX_signals_Check_signal( api, signo, false ) )
10d541: 50 push %eax
10d542: 6a 00 push $0x0
10d544: 53 push %ebx
10d545: 56 push %esi
10d546: e8 95 15 00 00 call 10eae0 <_POSIX_signals_Check_signal>
10d54b: 83 c4 10 add $0x10,%esp
10d54e: 84 c0 test %al,%al
10d550: 75 c9 jne 10d51b <_POSIX_signals_Post_switch_extension+0x12><== NEVER TAKEN
goto restart;
if ( _POSIX_signals_Check_signal( api, signo, true ) )
10d552: 51 push %ecx
10d553: 6a 01 push $0x1
10d555: 53 push %ebx
10d556: 56 push %esi
10d557: e8 84 15 00 00 call 10eae0 <_POSIX_signals_Check_signal>
10d55c: 83 c4 10 add $0x10,%esp
10d55f: 84 c0 test %al,%al
10d561: 75 b8 jne 10d51b <_POSIX_signals_Post_switch_extension+0x12><== NEVER TAKEN
_ISR_Enable( level );
break;
}
_ISR_Enable( level );
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10d563: 43 inc %ebx
10d564: 83 fb 20 cmp $0x20,%ebx
10d567: 75 d8 jne 10d541 <_POSIX_signals_Post_switch_extension+0x38>
10d569: b3 01 mov $0x1,%bl
/* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
if ( _POSIX_signals_Check_signal( api, signo, false ) )
10d56b: 52 push %edx
10d56c: 6a 00 push $0x0
10d56e: 53 push %ebx
10d56f: 56 push %esi
10d570: e8 6b 15 00 00 call 10eae0 <_POSIX_signals_Check_signal>
10d575: 83 c4 10 add $0x10,%esp
10d578: 84 c0 test %al,%al
10d57a: 75 9f jne 10d51b <_POSIX_signals_Post_switch_extension+0x12>
goto restart;
if ( _POSIX_signals_Check_signal( api, signo, true ) )
10d57c: 50 push %eax
10d57d: 6a 01 push $0x1
10d57f: 53 push %ebx
10d580: 56 push %esi
10d581: e8 5a 15 00 00 call 10eae0 <_POSIX_signals_Check_signal>
10d586: 83 c4 10 add $0x10,%esp
10d589: 84 c0 test %al,%al
10d58b: 75 8e jne 10d51b <_POSIX_signals_Post_switch_extension+0x12>
}
/* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
10d58d: 43 inc %ebx
10d58e: 83 fb 1b cmp $0x1b,%ebx
10d591: 75 d8 jne 10d56b <_POSIX_signals_Post_switch_extension+0x62><== ALWAYS TAKEN
10d593: eb 86 jmp 10d51b <_POSIX_signals_Post_switch_extension+0x12><== NOT EXECUTED
goto restart;
}
}
return;
}
10d595: 8d 65 f8 lea -0x8(%ebp),%esp
10d598: 5b pop %ebx
10d599: 5e pop %esi
10d59a: c9 leave
10d59b: c3 ret
0011868c <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
11868c: 55 push %ebp
11868d: 89 e5 mov %esp,%ebp
11868f: 57 push %edi
118690: 56 push %esi
118691: 53 push %ebx
118692: 83 ec 0c sub $0xc,%esp
118695: 8b 5d 08 mov 0x8(%ebp),%ebx
118698: 8b 75 10 mov 0x10(%ebp),%esi
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
11869b: 8b bb f8 00 00 00 mov 0xf8(%ebx),%edi
mask = signo_to_mask( signo );
1186a1: 8b 4d 0c mov 0xc(%ebp),%ecx
1186a4: 49 dec %ecx
1186a5: ba 01 00 00 00 mov $0x1,%edx
1186aa: d3 e2 shl %cl,%edx
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
1186ac: 8b 4b 10 mov 0x10(%ebx),%ecx
1186af: 89 c8 mov %ecx,%eax
1186b1: 25 00 80 00 10 and $0x10008000,%eax
1186b6: 3d 00 80 00 10 cmp $0x10008000,%eax
1186bb: 75 4c jne 118709 <_POSIX_signals_Unblock_thread+0x7d>
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
1186bd: 85 53 30 test %edx,0x30(%ebx)
1186c0: 75 10 jne 1186d2 <_POSIX_signals_Unblock_thread+0x46>
1186c2: 8b 87 c4 00 00 00 mov 0xc4(%edi),%eax
1186c8: f7 d0 not %eax
1186ca: 85 c2 test %eax,%edx
1186cc: 0f 84 a0 00 00 00 je 118772 <_POSIX_signals_Unblock_thread+0xe6><== ALWAYS TAKEN
the_thread->Wait.return_code = EINTR;
1186d2: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx)
the_info = (siginfo_t *) the_thread->Wait.return_argument;
1186d9: 8b 7b 28 mov 0x28(%ebx),%edi
if ( !info ) {
1186dc: 85 f6 test %esi,%esi
1186de: 75 15 jne 1186f5 <_POSIX_signals_Unblock_thread+0x69>
the_info->si_signo = signo;
1186e0: 8b 45 0c mov 0xc(%ebp),%eax
1186e3: 89 07 mov %eax,(%edi)
the_info->si_code = SI_USER;
1186e5: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
1186ec: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
1186f3: eb 07 jmp 1186fc <_POSIX_signals_Unblock_thread+0x70>
} else {
*the_info = *info;
1186f5: b9 03 00 00 00 mov $0x3,%ecx
1186fa: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
_Thread_queue_Extract_with_proxy( the_thread );
1186fc: 83 ec 0c sub $0xc,%esp
1186ff: 53 push %ebx
118700: e8 67 41 ff ff call 10c86c <_Thread_queue_Extract_with_proxy>
118705: b0 01 mov $0x1,%al
118707: eb 48 jmp 118751 <_POSIX_signals_Unblock_thread+0xc5>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
118709: 8b 87 c4 00 00 00 mov 0xc4(%edi),%eax
11870f: f7 d0 not %eax
118711: 85 c2 test %eax,%edx
118713: 74 5d je 118772 <_POSIX_signals_Unblock_thread+0xe6>
* it is not blocked, THEN
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
the_thread->do_post_task_switch_extension = true;
118715: c6 43 75 01 movb $0x1,0x75(%ebx)
if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) {
118719: f7 c1 00 00 00 10 test $0x10000000,%ecx
11871f: 74 35 je 118756 <_POSIX_signals_Unblock_thread+0xca>
the_thread->Wait.return_code = EINTR;
118721: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx)
#if 0
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
_Thread_queue_Extract_with_proxy( the_thread );
else
#endif
if ( _States_Is_delaying(the_thread->current_state) ){
118728: 80 e1 08 and $0x8,%cl
11872b: 74 45 je 118772 <_POSIX_signals_Unblock_thread+0xe6><== NEVER TAKEN
if ( _Watchdog_Is_active( &the_thread->Timer ) )
11872d: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
118731: 75 0f jne 118742 <_POSIX_signals_Unblock_thread+0xb6><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
118733: 83 ec 0c sub $0xc,%esp
118736: 8d 43 48 lea 0x48(%ebx),%eax
118739: 50 push %eax
11873a: e8 a5 4c ff ff call 10d3e4 <_Watchdog_Remove>
11873f: 83 c4 10 add $0x10,%esp
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
118742: 50 push %eax
118743: 50 push %eax
118744: 68 f8 ff 03 10 push $0x1003fff8
118749: 53 push %ebx
11874a: e8 3d 37 ff ff call 10be8c <_Thread_Clear_state>
11874f: 31 c0 xor %eax,%eax
118751: 83 c4 10 add $0x10,%esp
118754: eb 1e jmp 118774 <_POSIX_signals_Unblock_thread+0xe8>
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
118756: 85 c9 test %ecx,%ecx
118758: 75 18 jne 118772 <_POSIX_signals_Unblock_thread+0xe6><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
11875a: a1 30 93 12 00 mov 0x129330,%eax
11875f: 85 c0 test %eax,%eax
118761: 74 0f je 118772 <_POSIX_signals_Unblock_thread+0xe6>
118763: 3b 1d 54 93 12 00 cmp 0x129354,%ebx
118769: 75 07 jne 118772 <_POSIX_signals_Unblock_thread+0xe6><== NEVER TAKEN
_ISR_Signals_to_thread_executing = TRUE;
11876b: c6 05 e8 93 12 00 01 movb $0x1,0x1293e8
118772: 31 c0 xor %eax,%eax
}
}
return false;
}
118774: 8d 65 f4 lea -0xc(%ebp),%esp
118777: 5b pop %ebx
118778: 5e pop %esi
118779: 5f pop %edi
11877a: c9 leave
11877b: c3 ret
0010c788 <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
10c788: 55 push %ebp
10c789: 89 e5 mov %esp,%ebp
10c78b: 56 push %esi
10c78c: 53 push %ebx
10c78d: 8b 75 08 mov 0x8(%ebp),%esi
10c790: 8b 5d 0c mov 0xc(%ebp),%ebx
Heap_Get_information_status status;
if ( !the_heap )
10c793: 85 f6 test %esi,%esi
10c795: 74 33 je 10c7ca <_Protected_heap_Get_information+0x42><== NEVER TAKEN
return false;
if ( !the_info )
10c797: 85 db test %ebx,%ebx
10c799: 74 2f je 10c7ca <_Protected_heap_Get_information+0x42><== NEVER TAKEN
return false;
_RTEMS_Lock_allocator();
10c79b: 83 ec 0c sub $0xc,%esp
10c79e: ff 35 3c 2b 12 00 pushl 0x122b3c
10c7a4: e8 3f ea ff ff call 10b1e8 <_API_Mutex_Lock>
status = _Heap_Get_information( the_heap, the_info );
10c7a9: 5a pop %edx
10c7aa: 59 pop %ecx
10c7ab: 53 push %ebx
10c7ac: 56 push %esi
10c7ad: e8 6e 38 00 00 call 110020 <_Heap_Get_information>
10c7b2: 89 c3 mov %eax,%ebx
_RTEMS_Unlock_allocator();
10c7b4: 58 pop %eax
10c7b5: ff 35 3c 2b 12 00 pushl 0x122b3c
10c7bb: e8 70 ea ff ff call 10b230 <_API_Mutex_Unlock>
if ( status == HEAP_GET_INFORMATION_SUCCESSFUL )
10c7c0: 83 c4 10 add $0x10,%esp
10c7c3: 85 db test %ebx,%ebx
10c7c5: 0f 94 c0 sete %al
10c7c8: eb 02 jmp 10c7cc <_Protected_heap_Get_information+0x44>
10c7ca: 31 c0 xor %eax,%eax
return true;
return false;
}
10c7cc: 8d 65 f8 lea -0x8(%ebp),%esp
10c7cf: 5b pop %ebx
10c7d0: 5e pop %esi
10c7d1: c9 leave
10c7d2: c3 ret
0010dbf3 <_RTEMS_tasks_Create_extension>:
bool _RTEMS_tasks_Create_extension(
Thread_Control *executing,
Thread_Control *created
)
{
10dbf3: 55 push %ebp
10dbf4: 89 e5 mov %esp,%ebp
10dbf6: 53 push %ebx
10dbf7: 83 ec 10 sub $0x10,%esp
10dbfa: 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 );
if ( !rtems_configuration_get_notepads_enabled() )
10dbfd: a1 30 d8 11 00 mov 0x11d830,%eax
10dc02: 8b 40 40 mov 0x40(%eax),%eax
10dc05: 80 78 04 01 cmpb $0x1,0x4(%eax)
10dc09: 19 c0 sbb %eax,%eax
10dc0b: 83 e0 c0 and $0xffffffc0,%eax
10dc0e: 83 c0 60 add $0x60,%eax
to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));
api = _Workspace_Allocate( to_allocate );
10dc11: 50 push %eax
10dc12: e8 12 e2 ff ff call 10be29 <_Workspace_Allocate>
10dc17: 89 c2 mov %eax,%edx
if ( !api )
10dc19: 83 c4 10 add $0x10,%esp
10dc1c: 31 c0 xor %eax,%eax
10dc1e: 85 d2 test %edx,%edx
10dc20: 74 5d je 10dc7f <_RTEMS_tasks_Create_extension+0x8c><== NEVER TAKEN
return false;
created->API_Extensions[ THREAD_API_RTEMS ] = api;
10dc22: 89 93 f4 00 00 00 mov %edx,0xf4(%ebx)
api->pending_events = EVENT_SETS_NONE_PENDING;
10dc28: c7 02 00 00 00 00 movl $0x0,(%edx)
#endif
/**
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
10dc2e: c6 42 08 01 movb $0x1,0x8(%edx)
* @a page_size byte units. If @a page_size is 0 or is not multiple of
10dc32: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
10dc39: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx)
*
10dc40: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx)
* @param[in] the_heap is the heap to operate upon
10dc47: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
* @param[in] starting_address is the starting address of the memory for
10dc4e: c7 42 1c 00 00 00 00 movl $0x0,0x1c(%edx)
_ASR_Initialize( &api->Signal );
created->task_variables = NULL;
10dc55: c7 83 04 01 00 00 00 movl $0x0,0x104(%ebx)
10dc5c: 00 00 00
if ( rtems_configuration_get_notepads_enabled() ) {
10dc5f: a1 30 d8 11 00 mov 0x11d830,%eax
10dc64: 8b 40 40 mov 0x40(%eax),%eax
10dc67: 80 78 04 00 cmpb $0x0,0x4(%eax)
10dc6b: 74 10 je 10dc7d <_RTEMS_tasks_Create_extension+0x8a>
10dc6d: 31 c0 xor %eax,%eax
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
api->Notepads[i] = 0;
10dc6f: c7 44 82 20 00 00 00 movl $0x0,0x20(%edx,%eax,4)
10dc76: 00
api->pending_events = EVENT_SETS_NONE_PENDING;
_ASR_Initialize( &api->Signal );
created->task_variables = NULL;
if ( rtems_configuration_get_notepads_enabled() ) {
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
10dc77: 40 inc %eax
10dc78: 83 f8 10 cmp $0x10,%eax
10dc7b: 75 f2 jne 10dc6f <_RTEMS_tasks_Create_extension+0x7c>
10dc7d: b0 01 mov $0x1,%al
api->Notepads[i] = 0;
}
return true;
}
10dc7f: 8b 5d fc mov -0x4(%ebp),%ebx
10dc82: c9 leave
10dc83: c3 ret
001094e4 <_RTEMS_tasks_Initialize_user_tasks_body>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
1094e4: 55 push %ebp
1094e5: 89 e5 mov %esp,%ebp
1094e7: 57 push %edi
1094e8: 56 push %esi
1094e9: 53 push %ebx
1094ea: 83 ec 1c sub $0x1c,%esp
rtems_status_code return_value;
rtems_initialization_tasks_table *user_tasks;
rtems_api_configuration_table *api_configuration;
api_configuration = _Configuration_Table->RTEMS_api_configuration;
1094ed: a1 30 d8 11 00 mov 0x11d830,%eax
1094f2: 8b 40 40 mov 0x40(%eax),%eax
/*
* NOTE: This is slightly different from the Ada implementation.
*/
user_tasks = api_configuration->User_initialization_tasks_table;
1094f5: 8b 50 2c mov 0x2c(%eax),%edx
maximum = api_configuration->number_of_initialization_tasks;
1094f8: 8b 78 28 mov 0x28(%eax),%edi
if ( !user_tasks || maximum == 0 )
1094fb: 85 d2 test %edx,%edx
1094fd: 74 53 je 109552 <_RTEMS_tasks_Initialize_user_tasks_body+0x6e><== NEVER TAKEN
1094ff: 85 ff test %edi,%edi
109501: 74 4f je 109552 <_RTEMS_tasks_Initialize_user_tasks_body+0x6e><== NEVER TAKEN
return;
109503: 89 d3 mov %edx,%ebx
109505: 31 f6 xor %esi,%esi
109507: eb 45 jmp 10954e <_RTEMS_tasks_Initialize_user_tasks_body+0x6a>
for ( index=0 ; index < maximum ; index++ ) {
return_value = rtems_task_create(
109509: 50 push %eax
10950a: 50 push %eax
10950b: 8d 45 f0 lea -0x10(%ebp),%eax
10950e: 50 push %eax
10950f: ff 73 0c pushl 0xc(%ebx)
109512: ff 73 14 pushl 0x14(%ebx)
109515: ff 73 04 pushl 0x4(%ebx)
109518: ff 73 08 pushl 0x8(%ebx)
10951b: ff 33 pushl (%ebx)
10951d: e8 ca fd ff ff call 1092ec <rtems_task_create>
user_tasks[ index ].mode_set,
user_tasks[ index ].attribute_set,
&id
);
if ( !rtems_is_status_successful( return_value ) )
109522: 83 c4 20 add $0x20,%esp
109525: 85 c0 test %eax,%eax
109527: 75 19 jne 109542 <_RTEMS_tasks_Initialize_user_tasks_body+0x5e>
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
return_value = rtems_task_start(
109529: 51 push %ecx
10952a: ff 73 18 pushl 0x18(%ebx)
10952d: ff 73 10 pushl 0x10(%ebx)
109530: ff 75 f0 pushl -0x10(%ebp)
109533: e8 24 00 00 00 call 10955c <rtems_task_start>
109538: 83 c3 1c add $0x1c,%ebx
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
10953b: 83 c4 10 add $0x10,%esp
10953e: 85 c0 test %eax,%eax
109540: 74 0b je 10954d <_RTEMS_tasks_Initialize_user_tasks_body+0x69>
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
109542: 52 push %edx
109543: 50 push %eax
109544: 6a 01 push $0x1
109546: 6a 01 push $0x1
109548: e8 a7 0c 00 00 call 10a1f4 <_Internal_error_Occurred>
maximum = api_configuration->number_of_initialization_tasks;
if ( !user_tasks || maximum == 0 )
return;
for ( index=0 ; index < maximum ; index++ ) {
10954d: 46 inc %esi
10954e: 39 fe cmp %edi,%esi
109550: 72 b7 jb 109509 <_RTEMS_tasks_Initialize_user_tasks_body+0x25>
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
}
}
109552: 8d 65 f4 lea -0xc(%ebp),%esp
109555: 5b pop %ebx
109556: 5e pop %esi
109557: 5f pop %edi
109558: c9 leave
109559: c3 ret
0010db40 <_RTEMS_tasks_Post_switch_extension>:
*/
void _RTEMS_tasks_Post_switch_extension(
Thread_Control *executing
)
{
10db40: 55 push %ebp
10db41: 89 e5 mov %esp,%ebp
10db43: 57 push %edi
10db44: 56 push %esi
10db45: 53 push %ebx
10db46: 83 ec 1c sub $0x1c,%esp
RTEMS_API_Control *api;
ASR_Information *asr;
rtems_signal_set signal_set;
Modes_Control prev_mode;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
10db49: 8b 45 08 mov 0x8(%ebp),%eax
10db4c: 8b b0 f4 00 00 00 mov 0xf4(%eax),%esi
if ( !api )
10db52: 85 f6 test %esi,%esi
10db54: 74 45 je 10db9b <_RTEMS_tasks_Post_switch_extension+0x5b><== NEVER TAKEN
* Signal Processing
*/
asr = &api->Signal;
_ISR_Disable( level );
10db56: 9c pushf
10db57: fa cli
10db58: 58 pop %eax
signal_set = asr->signals_posted;
10db59: 8b 7e 14 mov 0x14(%esi),%edi
asr->signals_posted = 0;
10db5c: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi)
_ISR_Enable( level );
10db63: 50 push %eax
10db64: 9d popf
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
10db65: 85 ff test %edi,%edi
10db67: 74 32 je 10db9b <_RTEMS_tasks_Post_switch_extension+0x5b>
return;
asr->nest_level += 1;
10db69: ff 46 1c incl 0x1c(%esi)
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
10db6c: 50 push %eax
10db6d: 8d 5d f0 lea -0x10(%ebp),%ebx
10db70: 53 push %ebx
10db71: 68 ff ff 00 00 push $0xffff
10db76: ff 76 10 pushl 0x10(%esi)
10db79: e8 56 11 00 00 call 10ecd4 <rtems_task_mode>
(*asr->handler)( signal_set );
10db7e: 89 3c 24 mov %edi,(%esp)
10db81: ff 56 0c call *0xc(%esi)
asr->nest_level -= 1;
10db84: ff 4e 1c decl 0x1c(%esi)
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
10db87: 83 c4 0c add $0xc,%esp
10db8a: 53 push %ebx
10db8b: 68 ff ff 00 00 push $0xffff
10db90: ff 75 f0 pushl -0x10(%ebp)
10db93: e8 3c 11 00 00 call 10ecd4 <rtems_task_mode>
10db98: 83 c4 10 add $0x10,%esp
}
10db9b: 8d 65 f4 lea -0xc(%ebp),%esp
10db9e: 5b pop %ebx
10db9f: 5e pop %esi
10dba0: 5f pop %edi
10dba1: c9 leave
10dba2: c3 ret
0010a314 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
10a314: 55 push %ebp
10a315: 89 e5 mov %esp,%ebp
10a317: 53 push %ebx
10a318: 83 ec 18 sub $0x18,%esp
10a31b: 8d 45 f8 lea -0x8(%ebp),%eax
10a31e: 50 push %eax
10a31f: ff 75 08 pushl 0x8(%ebp)
10a322: 68 44 1b 12 00 push $0x121b44
10a327: e8 98 1a 00 00 call 10bdc4 <_Objects_Get>
10a32c: 89 c3 mov %eax,%ebx
/*
* 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 );
switch ( location ) {
10a32e: 83 c4 10 add $0x10,%esp
10a331: 83 7d f8 00 cmpl $0x0,-0x8(%ebp)
10a335: 75 64 jne 10a39b <_Rate_monotonic_Timeout+0x87><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
10a337: 8b 50 50 mov 0x50(%eax),%edx
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
10a33a: f6 42 11 40 testb $0x40,0x11(%edx)
10a33e: 74 18 je 10a358 <_Rate_monotonic_Timeout+0x44>
10a340: 8b 42 20 mov 0x20(%edx),%eax
10a343: 3b 43 08 cmp 0x8(%ebx),%eax
10a346: 75 10 jne 10a358 <_Rate_monotonic_Timeout+0x44><== NEVER TAKEN
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
10a348: 50 push %eax
10a349: 50 push %eax
10a34a: 68 f8 ff 03 10 push $0x1003fff8
10a34f: 52 push %edx
10a350: e8 af 1e 00 00 call 10c204 <_Thread_Clear_state>
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
10a355: 59 pop %ecx
10a356: eb 10 jmp 10a368 <_Rate_monotonic_Timeout+0x54>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
10a358: 83 7b 38 01 cmpl $0x1,0x38(%ebx)
10a35c: 75 2b jne 10a389 <_Rate_monotonic_Timeout+0x75><== ALWAYS TAKEN
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
10a35e: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
10a365: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a368: 53 push %ebx
10a369: e8 6a fa ff ff call 109dd8 <_Rate_monotonic_Initiate_statistics>
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
Heap_Control *the_heap,
10a36e: 8b 43 4c mov 0x4c(%ebx),%eax
10a371: 89 43 1c mov %eax,0x1c(%ebx)
void *starting_address,
size_t *size
10a374: 58 pop %eax
10a375: 5a pop %edx
10a376: 8d 43 10 lea 0x10(%ebx),%eax
10a379: 50 push %eax
10a37a: 68 1c 1d 12 00 push $0x121d1c
10a37f: e8 5c 31 00 00 call 10d4e0 <_Watchdog_Insert>
10a384: 83 c4 10 add $0x10,%esp
10a387: eb 07 jmp 10a390 <_Rate_monotonic_Timeout+0x7c>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
10a389: c7 43 38 04 00 00 00 movl $0x4,0x38(%ebx)
10a390: a1 3c 1c 12 00 mov 0x121c3c,%eax
10a395: 48 dec %eax
10a396: a3 3c 1c 12 00 mov %eax,0x121c3c
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10a39b: 8b 5d fc mov -0x4(%ebp),%ebx
10a39e: c9 leave
10a39f: c3 ret
00109a64 <_TOD_Validate>:
*/
bool _TOD_Validate(
rtems_time_of_day *the_tod
)
{
109a64: 55 push %ebp
109a65: 89 e5 mov %esp,%ebp
109a67: 53 push %ebx
109a68: 83 ec 04 sub $0x4,%esp
109a6b: 8b 5d 08 mov 0x8(%ebp),%ebx
uint32_t days_in_month;
if ((!the_tod) ||
109a6e: 85 db test %ebx,%ebx
109a70: 74 5d je 109acf <_TOD_Validate+0x6b> <== NEVER TAKEN
109a72: b8 40 42 0f 00 mov $0xf4240,%eax
109a77: 31 d2 xor %edx,%edx
109a79: f7 35 30 94 12 00 divl 0x129430
109a7f: 39 43 18 cmp %eax,0x18(%ebx)
109a82: 73 4b jae 109acf <_TOD_Validate+0x6b>
109a84: 83 7b 14 3b cmpl $0x3b,0x14(%ebx)
109a88: 77 45 ja 109acf <_TOD_Validate+0x6b>
109a8a: 83 7b 10 3b cmpl $0x3b,0x10(%ebx)
109a8e: 77 3f ja 109acf <_TOD_Validate+0x6b>
109a90: 83 7b 0c 17 cmpl $0x17,0xc(%ebx)
109a94: 77 39 ja 109acf <_TOD_Validate+0x6b>
109a96: 8b 43 04 mov 0x4(%ebx),%eax
109a99: 85 c0 test %eax,%eax
109a9b: 74 32 je 109acf <_TOD_Validate+0x6b> <== NEVER TAKEN
109a9d: 83 f8 0c cmp $0xc,%eax
109aa0: 77 2d ja 109acf <_TOD_Validate+0x6b>
109aa2: 8b 0b mov (%ebx),%ecx
109aa4: 81 f9 c3 07 00 00 cmp $0x7c3,%ecx
109aaa: 76 23 jbe 109acf <_TOD_Validate+0x6b>
109aac: 8b 53 08 mov 0x8(%ebx),%edx
109aaf: 85 d2 test %edx,%edx
109ab1: 74 1c je 109acf <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
109ab3: 80 e1 03 and $0x3,%cl
109ab6: 75 09 jne 109ac1 <_TOD_Validate+0x5d>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
109ab8: 8b 04 85 64 a7 11 00 mov 0x11a764(,%eax,4),%eax
109abf: eb 07 jmp 109ac8 <_TOD_Validate+0x64>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
109ac1: 8b 04 85 30 a7 11 00 mov 0x11a730(,%eax,4),%eax
109ac8: 39 c2 cmp %eax,%edx
109aca: 0f 96 c0 setbe %al
109acd: eb 02 jmp 109ad1 <_TOD_Validate+0x6d>
109acf: 31 c0 xor %eax,%eax
if ( the_tod->day > days_in_month )
return false;
return true;
}
109ad1: 5a pop %edx
109ad2: 5b pop %ebx
109ad3: c9 leave
109ad4: c3 ret
0010a9ec <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
10a9ec: 55 push %ebp
10a9ed: 89 e5 mov %esp,%ebp
10a9ef: 57 push %edi
10a9f0: 56 push %esi
10a9f1: 53 push %ebx
10a9f2: 83 ec 18 sub $0x18,%esp
10a9f5: 8b 5d 08 mov 0x8(%ebp),%ebx
10a9f8: 8b 75 0c mov 0xc(%ebp),%esi
10a9fb: 8a 45 10 mov 0x10(%ebp),%al
10a9fe: 88 45 f3 mov %al,-0xd(%ebp)
*/
/*
* Save original state
*/
original_state = the_thread->current_state;
10aa01: 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 );
10aa04: 53 push %ebx
10aa05: e8 3e 0d 00 00 call 10b748 <_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 )
10aa0a: 83 c4 10 add $0x10,%esp
10aa0d: 39 73 14 cmp %esi,0x14(%ebx)
10aa10: 74 0c je 10aa1e <_Thread_Change_priority+0x32>
_Thread_Set_priority( the_thread, new_priority );
10aa12: 50 push %eax
10aa13: 50 push %eax
10aa14: 56 push %esi
10aa15: 53 push %ebx
10aa16: e8 f9 0b 00 00 call 10b614 <_Thread_Set_priority>
10aa1b: 83 c4 10 add $0x10,%esp
_ISR_Disable( level );
10aa1e: 9c pushf
10aa1f: fa cli
10aa20: 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;
10aa21: 8b 53 10 mov 0x10(%ebx),%edx
if ( state != STATES_TRANSIENT ) {
10aa24: 83 fa 04 cmp $0x4,%edx
10aa27: 74 30 je 10aa59 <_Thread_Change_priority+0x6d>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
10aa29: 83 e7 04 and $0x4,%edi
10aa2c: 75 08 jne 10aa36 <_Thread_Change_priority+0x4a><== NEVER TAKEN
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
10aa2e: 89 d0 mov %edx,%eax
10aa30: 83 e0 fb and $0xfffffffb,%eax
10aa33: 89 43 10 mov %eax,0x10(%ebx)
_ISR_Enable( level );
10aa36: 56 push %esi
10aa37: 9d popf
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10aa38: 81 e2 e0 be 03 00 and $0x3bee0,%edx
10aa3e: 0f 84 c0 00 00 00 je 10ab04 <_Thread_Change_priority+0x118>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
10aa44: 89 5d 0c mov %ebx,0xc(%ebp)
10aa47: 8b 43 44 mov 0x44(%ebx),%eax
10aa4a: 89 45 08 mov %eax,0x8(%ebp)
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Context_Switch_necessary = TRUE;
_ISR_Enable( level );
}
10aa4d: 8d 65 f4 lea -0xc(%ebp),%esp
10aa50: 5b pop %ebx
10aa51: 5e pop %esi
10aa52: 5f pop %edi
10aa53: 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 );
10aa54: e9 33 0b 00 00 jmp 10b58c <_Thread_queue_Requeue>
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
10aa59: 83 e7 04 and $0x4,%edi
10aa5c: 75 53 jne 10aab1 <_Thread_Change_priority+0xc5><== NEVER TAKEN
* Interrupts are STILL disabled.
* We now know the thread will be in the READY state when we remove
* the TRANSIENT state. So we have to place it on the appropriate
* Ready Queue with interrupts off.
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
10aa5e: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
* otherwise.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the user block
* to obtain the size of
* @param[in] size points to a user area to return the size in
10aa65: 8b 93 90 00 00 00 mov 0x90(%ebx),%edx
10aa6b: 66 8b 83 96 00 00 00 mov 0x96(%ebx),%ax
10aa72: 66 09 02 or %ax,(%edx)
* @return TRUE if successfully able to determine the size, FALSE otherwise
10aa75: 66 a1 4c d8 11 00 mov 0x11d84c,%ax
10aa7b: 0b 83 94 00 00 00 or 0x94(%ebx),%eax
10aa81: 66 a3 4c d8 11 00 mov %ax,0x11d84c
_Priority_Add_to_bit_map( &the_thread->Priority_map );
if ( prepend_it )
10aa87: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
10aa8b: 8b 93 8c 00 00 00 mov 0x8c(%ebx),%edx
10aa91: 74 0e je 10aaa1 <_Thread_Change_priority+0xb5>
10aa93: 89 53 04 mov %edx,0x4(%ebx)
10aa96: 8b 02 mov (%edx),%eax
10aa98: 89 1a mov %ebx,(%edx)
10aa9a: 89 03 mov %eax,(%ebx)
10aa9c: 89 58 04 mov %ebx,0x4(%eax)
10aa9f: eb 10 jmp 10aab1 <_Thread_Change_priority+0xc5>
10aaa1: 8d 42 04 lea 0x4(%edx),%eax
10aaa4: 89 03 mov %eax,(%ebx)
10aaa6: 8b 42 08 mov 0x8(%edx),%eax
10aaa9: 89 5a 08 mov %ebx,0x8(%edx)
10aaac: 89 18 mov %ebx,(%eax)
10aaae: 89 43 04 mov %eax,0x4(%ebx)
_Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node );
else
_Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node );
}
_ISR_Flash( level );
10aab1: 56 push %esi
10aab2: 9d popf
10aab3: fa cli
void *starting_address,
size_t size
);
/**
* This routine returns the block of memory which begins
10aab4: 66 8b 0d 4c d8 11 00 mov 0x11d84c,%cx
10aabb: 31 d2 xor %edx,%edx
10aabd: 89 d0 mov %edx,%eax
10aabf: 66 0f bc c1 bsf %cx,%ax
* at @a starting_address to @a the_heap. Any coalescing which is
10aac3: 0f b7 c0 movzwl %ax,%eax
10aac6: 66 8b 8c 00 c4 d8 11 mov 0x11d8c4(%eax,%eax,1),%cx
10aacd: 00
10aace: 66 0f bc d1 bsf %cx,%dx
/**
* This function sets @a *size to the size of the block of user memory
* which begins at @a starting_address. The size returned in @a *size could
* be greater than the size requested for allocation.
* Returns TRUE if the @a starting_address is in the heap, and FALSE
* otherwise.
10aad2: c1 e0 04 shl $0x4,%eax
10aad5: 0f b7 d2 movzwl %dx,%edx
10aad8: 01 d0 add %edx,%eax
10aada: 6b c0 0c imul $0xc,%eax,%eax
10aadd: 8b 15 60 d7 11 00 mov 0x11d760,%edx
10aae3: 8b 04 10 mov (%eax,%edx,1),%eax
10aae6: a3 24 d8 11 00 mov %eax,0x11d824
void *starting_address,
size_t size
);
/**
* This function attempts to allocate a block of @a size bytes from
10aaeb: 8b 15 58 d8 11 00 mov 0x11d858,%edx
* We altered the set of thread priorities. So let's figure out
* who is the heir and if we need to switch to them.
*/
_Thread_Calculate_heir();
if ( !_Thread_Is_executing_also_the_heir() &&
10aaf1: 39 c2 cmp %eax,%edx
10aaf3: 74 0d je 10ab02 <_Thread_Change_priority+0x116>
10aaf5: 80 7a 76 00 cmpb $0x0,0x76(%edx)
10aaf9: 74 07 je 10ab02 <_Thread_Change_priority+0x116><== NEVER TAKEN
_Thread_Executing->is_preemptible )
_Context_Switch_necessary = TRUE;
10aafb: c6 05 68 d8 11 00 01 movb $0x1,0x11d868
_ISR_Enable( level );
10ab02: 56 push %esi
10ab03: 9d popf
}
10ab04: 8d 65 f4 lea -0xc(%ebp),%esp
10ab07: 5b pop %ebx
10ab08: 5e pop %esi
10ab09: 5f pop %edi
10ab0a: c9 leave
10ab0b: c3 ret
0010ab0c <_Thread_Clear_state>:
void _Thread_Clear_state(
Thread_Control *the_thread,
States_Control state
)
{
10ab0c: 55 push %ebp
10ab0d: 89 e5 mov %esp,%ebp
10ab0f: 53 push %ebx
10ab10: 8b 4d 08 mov 0x8(%ebp),%ecx
10ab13: 8b 45 0c mov 0xc(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10ab16: 9c pushf
10ab17: fa cli
10ab18: 5b pop %ebx
current_state = the_thread->current_state;
10ab19: 8b 51 10 mov 0x10(%ecx),%edx
if ( current_state & state ) {
10ab1c: 85 d0 test %edx,%eax
10ab1e: 74 6f je 10ab8f <_Thread_Clear_state+0x83>
* @param[in] page_size is the size in bytes of the allocation unit
*
* @return This method returns the maximum memory available. If
* unsuccessful, 0 will be returned.
*/
static inline uint32_t _Protected_heap_Initialize(
10ab20: f7 d0 not %eax
10ab22: 21 d0 and %edx,%eax
current_state =
10ab24: 89 41 10 mov %eax,0x10(%ecx)
the_thread->current_state = _States_Clear( state, current_state );
if ( _States_Is_ready( current_state ) ) {
10ab27: 85 c0 test %eax,%eax
10ab29: 75 64 jne 10ab8f <_Thread_Clear_state+0x83>
* otherwise.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the user block
* to obtain the size of
* @param[in] size points to a user area to return the size in
10ab2b: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx
10ab31: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax
10ab38: 66 09 02 or %ax,(%edx)
* @return TRUE if successfully able to determine the size, FALSE otherwise
10ab3b: 66 a1 4c d8 11 00 mov 0x11d84c,%ax
10ab41: 0b 81 94 00 00 00 or 0x94(%ecx),%eax
10ab47: 66 a3 4c d8 11 00 mov %ax,0x11d84c
_Priority_Add_to_bit_map( &the_thread->Priority_map );
_Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
10ab4d: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax
10ab53: 8d 50 04 lea 0x4(%eax),%edx
10ab56: 89 11 mov %edx,(%ecx)
10ab58: 8b 50 08 mov 0x8(%eax),%edx
10ab5b: 89 48 08 mov %ecx,0x8(%eax)
10ab5e: 89 0a mov %ecx,(%edx)
10ab60: 89 51 04 mov %edx,0x4(%ecx)
_ISR_Flash( level );
10ab63: 53 push %ebx
10ab64: 9d popf
10ab65: fa cli
* 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 ) {
10ab66: 8b 51 14 mov 0x14(%ecx),%edx
10ab69: a1 24 d8 11 00 mov 0x11d824,%eax
10ab6e: 3b 50 14 cmp 0x14(%eax),%edx
10ab71: 73 1c jae 10ab8f <_Thread_Clear_state+0x83>
_Thread_Heir = the_thread;
10ab73: 89 0d 24 d8 11 00 mov %ecx,0x11d824
if ( _Thread_Executing->is_preemptible ||
10ab79: a1 58 d8 11 00 mov 0x11d858,%eax
10ab7e: 80 78 76 00 cmpb $0x0,0x76(%eax)
10ab82: 75 04 jne 10ab88 <_Thread_Clear_state+0x7c>
10ab84: 85 d2 test %edx,%edx
10ab86: 75 07 jne 10ab8f <_Thread_Clear_state+0x83><== ALWAYS TAKEN
the_thread->current_priority == 0 )
_Context_Switch_necessary = TRUE;
10ab88: c6 05 68 d8 11 00 01 movb $0x1,0x11d868
}
}
}
_ISR_Enable( level );
10ab8f: 53 push %ebx
10ab90: 9d popf
}
10ab91: 5b pop %ebx
10ab92: c9 leave
10ab93: c3 ret
0010ac74 <_Thread_Create_idle>:
*
* _Thread_Create_idle
*/
void _Thread_Create_idle( void )
{
10ac74: 55 push %ebp
10ac75: 89 e5 mov %esp,%ebp
10ac77: 83 ec 14 sub $0x14,%esp
10ac7a: 68 f4 d8 11 00 push $0x11d8f4
10ac7f: e8 04 f6 ff ff call 10a288 <_Objects_Allocate>
/*
* The entire workspace is zeroed during its initialization. Thus, all
* fields not explicitly assigned were explicitly zeroed by
* _Workspace_Initialization.
*/
_Thread_Idle = _Thread_Internal_allocate();
10ac84: a3 40 d9 11 00 mov %eax,0x11d940
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10ac89: a1 98 d7 11 00 mov 0x11d798,%eax
10ac8e: 40 inc %eax
10ac8f: a3 98 d7 11 00 mov %eax,0x11d798
* that when _Thread_Initialize unnests dispatch that we do not
* do anything stupid.
*/
_Thread_Disable_dispatch();
_Thread_Initialize(
10ac94: a1 30 d8 11 00 mov 0x11d830,%eax
10ac99: 8b 50 18 mov 0x18(%eax),%edx
10ac9c: 83 c4 0c add $0xc,%esp
10ac9f: 68 40 73 11 00 push $0x117340
10aca4: 6a 00 push $0x0
10aca6: 6a 00 push $0x0
10aca8: 6a 00 push $0x0
10acaa: 6a 01 push $0x1
10acac: 0f b6 05 84 93 11 00 movzbl 0x119384,%eax
10acb3: 50 push %eax
10acb4: 6a 00 push $0x0
10acb6: a1 80 93 11 00 mov 0x119380,%eax
10acbb: 39 d0 cmp %edx,%eax
10acbd: 73 02 jae 10acc1 <_Thread_Create_idle+0x4d><== ALWAYS TAKEN
10acbf: 89 d0 mov %edx,%eax <== NOT EXECUTED
10acc1: 50 push %eax
10acc2: 6a 00 push $0x0
10acc4: ff 35 40 d9 11 00 pushl 0x11d940
10acca: 68 f4 d8 11 00 push $0x11d8f4
10accf: e8 50 02 00 00 call 10af24 <_Thread_Initialize>
10acd4: a1 98 d7 11 00 mov 0x11d798,%eax
10acd9: 48 dec %eax
10acda: a3 98 d7 11 00 mov %eax,0x11d798
/*
* WARNING!!! This is necessary to "kick" start the system and
* MUST be done before _Thread_Start is invoked.
*/
_Thread_Heir =
10acdf: 8b 15 40 d9 11 00 mov 0x11d940,%edx
10ace5: 89 15 58 d8 11 00 mov %edx,0x11d858
10aceb: 89 15 24 d8 11 00 mov %edx,0x11d824
_Thread_Executing = _Thread_Idle;
_Thread_Start(
10acf1: 83 c4 24 add $0x24,%esp
10acf4: 6a 00 push $0x0
10acf6: 6a 00 push $0x0
10acf8: a1 30 d8 11 00 mov 0x11d830,%eax
10acfd: ff 70 14 pushl 0x14(%eax)
10ad00: 6a 00 push $0x0
10ad02: 52 push %edx
10ad03: e8 8c 0b 00 00 call 10b894 <_Thread_Start>
10ad08: 83 c4 20 add $0x20,%esp
_Configuration_Table->idle_task,
NULL,
0
);
}
10ad0b: c9 leave
10ad0c: c3 ret
0010ad10 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored
)
{
10ad10: 55 push %ebp
10ad11: 89 e5 mov %esp,%ebp
10ad13: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10ad16: 8d 45 fc lea -0x4(%ebp),%eax
10ad19: 50 push %eax
10ad1a: ff 75 08 pushl 0x8(%ebp)
10ad1d: e8 8a 01 00 00 call 10aeac <_Thread_Get>
switch ( location ) {
10ad22: 83 c4 10 add $0x10,%esp
10ad25: 83 7d fc 00 cmpl $0x0,-0x4(%ebp)
10ad29: 75 1b jne 10ad46 <_Thread_Delay_ended+0x36><== NEVER TAKEN
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
10ad2b: 52 push %edx
10ad2c: 52 push %edx
10ad2d: 68 f8 ff 03 10 push $0x1003fff8
10ad32: 50 push %eax
10ad33: e8 d4 fd ff ff call 10ab0c <_Thread_Clear_state>
10ad38: a1 98 d7 11 00 mov 0x11d798,%eax
10ad3d: 48 dec %eax
10ad3e: a3 98 d7 11 00 mov %eax,0x11d798
10ad43: 83 c4 10 add $0x10,%esp
case OBJECTS_LOCAL:
_Thread_Unblock( the_thread );
_Thread_Unnest_dispatch();
break;
}
}
10ad46: c9 leave
10ad47: c3 ret
0010ad48 <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
10ad48: 55 push %ebp
10ad49: 89 e5 mov %esp,%ebp
10ad4b: 57 push %edi
10ad4c: 56 push %esi
10ad4d: 53 push %ebx
10ad4e: 83 ec 1c sub $0x1c,%esp
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
10ad51: 8b 1d 58 d8 11 00 mov 0x11d858,%ebx
_ISR_Disable( level );
10ad57: 9c pushf
10ad58: fa cli
10ad59: 5a pop %edx
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
{
struct timespec uptime, ran;
_TOD_Get_uptime( &uptime );
_Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
10ad5a: 8d 7d e4 lea -0x1c(%ebp),%edi
10ad5d: e9 f1 00 00 00 jmp 10ae53 <_Thread_Dispatch+0x10b>
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Context_Switch_necessary == TRUE ) {
heir = _Thread_Heir;
10ad62: 8b 35 24 d8 11 00 mov 0x11d824,%esi
_Thread_Dispatch_disable_level = 1;
10ad68: c7 05 98 d7 11 00 01 movl $0x1,0x11d798
10ad6f: 00 00 00
_Context_Switch_necessary = FALSE;
10ad72: c6 05 68 d8 11 00 00 movb $0x0,0x11d868
_Thread_Executing = heir;
10ad79: 89 35 58 d8 11 00 mov %esi,0x11d858
#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 )
10ad7f: 83 7e 7c 01 cmpl $0x1,0x7c(%esi)
10ad83: 75 08 jne 10ad8d <_Thread_Dispatch+0x45>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
10ad85: a1 64 d7 11 00 mov 0x11d764,%eax
10ad8a: 89 46 78 mov %eax,0x78(%esi)
_ISR_Enable( level );
10ad8d: 52 push %edx
10ad8e: 9d popf
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
{
struct timespec uptime, ran;
_TOD_Get_uptime( &uptime );
10ad8f: 83 ec 0c sub $0xc,%esp
10ad92: 8d 45 ec lea -0x14(%ebp),%eax
10ad95: 50 push %eax
10ad96: e8 a1 31 00 00 call 10df3c <_TOD_Get_uptime>
_Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
10ad9b: 83 c4 0c add $0xc,%esp
10ad9e: 57 push %edi
10ad9f: 8d 45 ec lea -0x14(%ebp),%eax
10ada2: 50 push %eax
10ada3: 68 60 d8 11 00 push $0x11d860
10ada8: e8 37 0c 00 00 call 10b9e4 <_Timespec_Subtract>
_Timespec_Add_to( &executing->cpu_time_used, &ran );
10adad: 58 pop %eax
10adae: 5a pop %edx
10adaf: 57 push %edi
10adb0: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax
10adb6: 50 push %eax
10adb7: e8 f8 0b 00 00 call 10b9b4 <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
10adbc: 8b 45 ec mov -0x14(%ebp),%eax
10adbf: 8b 55 f0 mov -0x10(%ebp),%edx
10adc2: a3 60 d8 11 00 mov %eax,0x11d860
10adc7: 89 15 64 d8 11 00 mov %edx,0x11d864
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
10adcd: 8b 15 20 d8 11 00 mov 0x11d820,%edx
10add3: 83 c4 10 add $0x10,%esp
10add6: 85 d2 test %edx,%edx
10add8: 74 10 je 10adea <_Thread_Dispatch+0xa2> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
10adda: 8b 02 mov (%edx),%eax
10addc: 89 83 f0 00 00 00 mov %eax,0xf0(%ebx)
*_Thread_libc_reent = heir->libc_reent;
10ade2: 8b 86 f0 00 00 00 mov 0xf0(%esi),%eax
10ade8: 89 02 mov %eax,(%edx)
}
_User_extensions_Thread_switch( executing, heir );
10adea: 51 push %ecx
10adeb: 51 push %ecx
10adec: 56 push %esi
10aded: 53 push %ebx
10adee: e8 01 0e 00 00 call 10bbf4 <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
10adf3: 58 pop %eax
10adf4: 5a pop %edx
10adf5: 8d 86 d4 00 00 00 lea 0xd4(%esi),%eax
10adfb: 50 push %eax
10adfc: 8d 83 d4 00 00 00 lea 0xd4(%ebx),%eax
10ae02: 50 push %eax
10ae03: e8 b8 10 00 00 call 10bec0 <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
10ae08: 83 c4 10 add $0x10,%esp
10ae0b: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx)
10ae12: 74 36 je 10ae4a <_Thread_Dispatch+0x102>
Heap_Control *the_heap,
void *starting_address,
size_t *size
);
/**
10ae14: a1 1c d8 11 00 mov 0x11d81c,%eax
10ae19: 39 c3 cmp %eax,%ebx
10ae1b: 74 2d je 10ae4a <_Thread_Dispatch+0x102>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
10ae1d: 85 c0 test %eax,%eax
10ae1f: 74 11 je 10ae32 <_Thread_Dispatch+0xea>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10ae21: 83 ec 0c sub $0xc,%esp
10ae24: 05 ec 00 00 00 add $0xec,%eax
10ae29: 50 push %eax
10ae2a: e8 c5 10 00 00 call 10bef4 <_CPU_Context_save_fp>
10ae2f: 83 c4 10 add $0x10,%esp
_Context_Restore_fp( &executing->fp_context );
10ae32: 83 ec 0c sub $0xc,%esp
10ae35: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax
10ae3b: 50 push %eax
10ae3c: e8 bd 10 00 00 call 10befe <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
10ae41: 89 1d 1c d8 11 00 mov %ebx,0x11d81c
10ae47: 83 c4 10 add $0x10,%esp
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
10ae4a: 8b 1d 58 d8 11 00 mov 0x11d858,%ebx
_ISR_Disable( level );
10ae50: 9c pushf
10ae51: fa cli
10ae52: 5a pop %edx
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Context_Switch_necessary == TRUE ) {
10ae53: a0 68 d8 11 00 mov 0x11d868,%al
10ae58: 84 c0 test %al,%al
10ae5a: 0f 85 02 ff ff ff jne 10ad62 <_Thread_Dispatch+0x1a>
executing = _Thread_Executing;
_ISR_Disable( level );
}
_Thread_Dispatch_disable_level = 0;
10ae60: c7 05 98 d7 11 00 00 movl $0x0,0x11d798
10ae67: 00 00 00
_ISR_Enable( level );
10ae6a: 52 push %edx
10ae6b: 9d popf
if ( _Thread_Do_post_task_switch_extension ||
10ae6c: 83 3d 3c d8 11 00 00 cmpl $0x0,0x11d83c
10ae73: 75 06 jne 10ae7b <_Thread_Dispatch+0x133>
10ae75: 80 7b 75 00 cmpb $0x0,0x75(%ebx)
10ae79: 74 09 je 10ae84 <_Thread_Dispatch+0x13c>
executing->do_post_task_switch_extension ) {
executing->do_post_task_switch_extension = false;
10ae7b: c6 43 75 00 movb $0x0,0x75(%ebx)
_API_extensions_Run_postswitch();
10ae7f: e8 4b eb ff ff call 1099cf <_API_extensions_Run_postswitch>
}
}
10ae84: 8d 65 f4 lea -0xc(%ebp),%esp
10ae87: 5b pop %ebx
10ae88: 5e pop %esi
10ae89: 5f pop %edi
10ae8a: c9 leave
10ae8b: c3 ret
0010ef3c <_Thread_Evaluate_mode>:
*
* XXX
*/
bool _Thread_Evaluate_mode( void )
{
10ef3c: 55 push %ebp
10ef3d: 89 e5 mov %esp,%ebp
Thread_Control *executing;
executing = _Thread_Executing;
10ef3f: a1 58 d8 11 00 mov 0x11d858,%eax
if ( !_States_Is_ready( executing->current_state ) ||
10ef44: 83 78 10 00 cmpl $0x0,0x10(%eax)
10ef48: 75 0e jne 10ef58 <_Thread_Evaluate_mode+0x1c><== NEVER TAKEN
10ef4a: 3b 05 24 d8 11 00 cmp 0x11d824,%eax
10ef50: 74 11 je 10ef63 <_Thread_Evaluate_mode+0x27>
10ef52: 80 78 76 00 cmpb $0x0,0x76(%eax)
10ef56: 74 0b je 10ef63 <_Thread_Evaluate_mode+0x27><== NEVER TAKEN
( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) {
_Context_Switch_necessary = TRUE;
10ef58: c6 05 68 d8 11 00 01 movb $0x1,0x11d868
10ef5f: b0 01 mov $0x1,%al
10ef61: eb 02 jmp 10ef65 <_Thread_Evaluate_mode+0x29>
return TRUE;
10ef63: 31 c0 xor %eax,%eax
}
return FALSE;
}
10ef65: c9 leave
10ef66: c3 ret
0010aeac <_Thread_Get>:
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
10aeac: 55 push %ebp
10aead: 89 e5 mov %esp,%ebp
10aeaf: 53 push %ebx
10aeb0: 83 ec 04 sub $0x4,%esp
10aeb3: 8b 5d 08 mov 0x8(%ebp),%ebx
10aeb6: 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 ) ) {
10aeb9: 85 db test %ebx,%ebx
10aebb: 75 18 jne 10aed5 <_Thread_Get+0x29>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10aebd: a1 98 d7 11 00 mov 0x11d798,%eax
10aec2: 40 inc %eax
10aec3: a3 98 d7 11 00 mov %eax,0x11d798
_Thread_Disable_dispatch();
*location = OBJECTS_LOCAL;
10aec8: c7 01 00 00 00 00 movl $0x0,(%ecx)
tp = _Thread_Executing;
10aece: a1 58 d8 11 00 mov 0x11d858,%eax
10aed3: eb 40 jmp 10af15 <_Thread_Get+0x69>
uint32_t page_size
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
10aed5: 89 da mov %ebx,%edx
10aed7: c1 ea 18 shr $0x18,%edx
10aeda: 83 e2 07 and $0x7,%edx
/**
* This function sets @a *size to the size of the block of user memory
* which begins at @a starting_address. The size returned in @a *size could
* be greater than the size requested for allocation.
* Returns TRUE if the @a starting_address is in the heap, and FALSE
* otherwise.
10aedd: 8d 42 ff lea -0x1(%edx),%eax
10aee0: 83 f8 03 cmp $0x3,%eax
10aee3: 76 35 jbe 10af1a <_Thread_Get+0x6e>
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
10aee5: c7 01 01 00 00 00 movl $0x1,(%ecx)
10aeeb: 31 c0 xor %eax,%eax
10aeed: eb 26 jmp 10af15 <_Thread_Get+0x69>
goto done;
}
api_information = _Objects_Information_table[ the_api ];
10aeef: 8b 04 95 6c d7 11 00 mov 0x11d76c(,%edx,4),%eax
if ( !api_information ) {
10aef6: 85 c0 test %eax,%eax
10aef8: 74 07 je 10af01 <_Thread_Get+0x55>
*location = OBJECTS_ERROR;
goto done;
}
information = api_information[ the_class ];
10aefa: 8b 40 04 mov 0x4(%eax),%eax
if ( !information ) {
10aefd: 85 c0 test %eax,%eax
10aeff: 75 08 jne 10af09 <_Thread_Get+0x5d> <== ALWAYS TAKEN
*location = OBJECTS_ERROR;
10af01: c7 01 01 00 00 00 movl $0x1,(%ecx)
10af07: eb 0c jmp 10af15 <_Thread_Get+0x69>
goto done;
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
10af09: 52 push %edx
10af0a: 51 push %ecx
10af0b: 53 push %ebx
10af0c: 50 push %eax
10af0d: e8 ba f7 ff ff call 10a6cc <_Objects_Get>
10af12: 83 c4 10 add $0x10,%esp
done:
return tp;
}
10af15: 8b 5d fc mov -0x4(%ebp),%ebx
10af18: c9 leave
10af19: c3 ret
*location = OBJECTS_ERROR;
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
10af1a: 89 d8 mov %ebx,%eax
10af1c: c1 e8 1b shr $0x1b,%eax
10af1f: 48 dec %eax
10af20: 74 cd je 10aeef <_Thread_Get+0x43>
10af22: eb c1 jmp 10aee5 <_Thread_Get+0x39>
0010ef68 <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
10ef68: 55 push %ebp
10ef69: 89 e5 mov %esp,%ebp
10ef6b: 53 push %ebx
10ef6c: 83 ec 04 sub $0x4,%esp
#if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
10ef6f: 8b 1d 58 d8 11 00 mov 0x11d858,%ebx
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
10ef75: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
_ISR_Set_level(level);
10ef7b: 85 c0 test %eax,%eax
10ef7d: 74 03 je 10ef82 <_Thread_Handler+0x1a>
10ef7f: fa cli
10ef80: eb 01 jmp 10ef83 <_Thread_Handler+0x1b>
10ef82: fb sti
#if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__)
doneCons = doneConstructors;
10ef83: a0 90 d5 11 00 mov 0x11d590,%al
10ef88: 88 45 fb mov %al,-0x5(%ebp)
doneConstructors = 1;
10ef8b: c6 05 90 d5 11 00 01 movb $0x1,0x11d590
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) && !_Thread_Is_allocated_fp( executing ) ) {
10ef92: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx)
10ef99: 74 24 je 10efbf <_Thread_Handler+0x57>
Heap_Control *the_heap,
void *starting_address,
size_t *size
);
/**
10ef9b: a1 1c d8 11 00 mov 0x11d81c,%eax
10efa0: 39 c3 cmp %eax,%ebx
10efa2: 74 1b je 10efbf <_Thread_Handler+0x57>
if ( _Thread_Allocated_fp != NULL )
10efa4: 85 c0 test %eax,%eax
10efa6: 74 11 je 10efb9 <_Thread_Handler+0x51>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10efa8: 83 ec 0c sub $0xc,%esp
10efab: 05 ec 00 00 00 add $0xec,%eax
10efb0: 50 push %eax
10efb1: e8 3e cf ff ff call 10bef4 <_CPU_Context_save_fp>
10efb6: 83 c4 10 add $0x10,%esp
_Thread_Allocated_fp = executing;
10efb9: 89 1d 1c d8 11 00 mov %ebx,0x11d81c
* 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 );
10efbf: 83 ec 0c sub $0xc,%esp
10efc2: 53 push %ebx
10efc3: e8 e0 ca ff ff call 10baa8 <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
10efc8: e8 bf be ff ff call 10ae8c <_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) */
10efcd: 83 c4 10 add $0x10,%esp
10efd0: 80 7d fb 00 cmpb $0x0,-0x5(%ebp)
10efd4: 75 05 jne 10efdb <_Thread_Handler+0x73>
{
_init ();
10efd6: e8 85 6e 00 00 call 115e60 <__start_set_sysctl_set>
#if defined(__USE__MAIN__)
if (!doneCons && _main)
__main ();
#endif
switch ( executing->Start.prototype ) {
10efdb: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax
10efe1: 83 f8 01 cmp $0x1,%eax
10efe4: 74 13 je 10eff9 <_Thread_Handler+0x91>
10efe6: 72 0c jb 10eff4 <_Thread_Handler+0x8c> <== ALWAYS TAKEN
10efe8: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED
10efeb: 74 11 je 10effe <_Thread_Handler+0x96> <== NOT EXECUTED
10efed: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED
10eff0: 75 36 jne 10f028 <_Thread_Handler+0xc0> <== NOT EXECUTED
10eff2: eb 1a jmp 10f00e <_Thread_Handler+0xa6> <== NOT EXECUTED
case THREAD_START_NUMERIC:
executing->Wait.return_argument =
10eff4: 83 ec 0c sub $0xc,%esp
10eff7: eb 1d jmp 10f016 <_Thread_Handler+0xae>
(*(Thread_Entry_numeric) executing->Start.entry_point)(
executing->Start.numeric_argument
);
break;
case THREAD_START_POINTER:
executing->Wait.return_argument =
10eff9: 83 ec 0c sub $0xc,%esp
10effc: eb 08 jmp 10f006 <_Thread_Handler+0x9e>
(*(Thread_Entry_pointer) executing->Start.entry_point)(
executing->Start.pointer_argument
);
break;
case THREAD_START_BOTH_POINTER_FIRST:
executing->Wait.return_argument =
10effe: 52 push %edx <== NOT EXECUTED
10efff: 52 push %edx <== NOT EXECUTED
10f000: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED
10f006: ff b3 a4 00 00 00 pushl 0xa4(%ebx)
10f00c: eb 0e jmp 10f01c <_Thread_Handler+0xb4>
executing->Start.pointer_argument,
executing->Start.numeric_argument
);
break;
case THREAD_START_BOTH_NUMERIC_FIRST:
executing->Wait.return_argument =
10f00e: 50 push %eax <== NOT EXECUTED
10f00f: 50 push %eax <== NOT EXECUTED
10f010: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED
10f016: ff b3 a8 00 00 00 pushl 0xa8(%ebx)
10f01c: ff 93 9c 00 00 00 call *0x9c(%ebx)
10f022: 89 43 28 mov %eax,0x28(%ebx)
10f025: 83 c4 10 add $0x10,%esp
* 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 );
10f028: 83 ec 0c sub $0xc,%esp
10f02b: 53 push %ebx
10f02c: e8 a8 ca ff ff call 10bad9 <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
10f031: 83 c4 0c add $0xc,%esp
10f034: 6a 06 push $0x6
10f036: 6a 01 push $0x1
10f038: 6a 00 push $0x0
10f03a: e8 b5 b1 ff ff call 10a1f4 <_Internal_error_Occurred>
0010af24 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
10af24: 55 push %ebp
10af25: 89 e5 mov %esp,%ebp
10af27: 57 push %edi
10af28: 56 push %esi
10af29: 53 push %ebx
10af2a: 83 ec 0c sub $0xc,%esp
10af2d: 8b 5d 0c mov 0xc(%ebp),%ebx
10af30: 8b 55 10 mov 0x10(%ebp),%edx
10af33: 8b 75 14 mov 0x14(%ebp),%esi
10af36: 8a 45 18 mov 0x18(%ebp),%al
10af39: 88 45 f3 mov %al,-0xd(%ebp)
10af3c: 8a 45 20 mov 0x20(%ebp),%al
10af3f: 88 45 f2 mov %al,-0xe(%ebp)
/*
* Allocate and Initialize the stack for this thread.
*/
if ( !stack_area ) {
10af42: 85 d2 test %edx,%edx
10af44: 75 2a jne 10af70 <_Thread_Initialize+0x4c><== NEVER TAKEN
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
10af46: 51 push %ecx
10af47: 51 push %ecx
10af48: 56 push %esi
10af49: 53 push %ebx
10af4a: e8 69 08 00 00 call 10b7b8 <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
10af4f: 83 c4 10 add $0x10,%esp
10af52: 85 c0 test %eax,%eax
10af54: 74 04 je 10af5a <_Thread_Initialize+0x36>
10af56: 39 f0 cmp %esi,%eax
10af58: 73 07 jae 10af61 <_Thread_Initialize+0x3d><== ALWAYS TAKEN
10af5a: 31 d2 xor %edx,%edx
10af5c: e9 8c 01 00 00 jmp 10b0ed <_Thread_Initialize+0x1c9>
return FALSE; /* stack allocation failed */
stack = the_thread->Start.stack;
10af61: 8b 93 d0 00 00 00 mov 0xd0(%ebx),%edx
the_thread->Start.core_allocated_stack = TRUE;
10af67: c6 83 c0 00 00 00 01 movb $0x1,0xc0(%ebx)
10af6e: eb 09 jmp 10af79 <_Thread_Initialize+0x55>
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = FALSE;
10af70: c6 83 c0 00 00 00 00 movb $0x0,0xc0(%ebx) <== NOT EXECUTED
10af77: 89 f0 mov %esi,%eax <== NOT EXECUTED
/**
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
10af79: 89 93 c8 00 00 00 mov %edx,0xc8(%ebx)
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
10af7f: 89 83 c4 00 00 00 mov %eax,0xc4(%ebx)
if ( is_fp ) {
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
if ( !fp_area ) {
_Thread_Stack_Free( the_thread );
return FALSE;
10af85: 31 f6 xor %esi,%esi
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
10af87: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
10af8b: 74 17 je 10afa4 <_Thread_Initialize+0x80>
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
10af8d: 83 ec 0c sub $0xc,%esp
10af90: 6a 6c push $0x6c
10af92: e8 92 0e 00 00 call 10be29 <_Workspace_Allocate>
10af97: 89 c6 mov %eax,%esi
if ( !fp_area ) {
10af99: 83 c4 10 add $0x10,%esp
10af9c: 85 c0 test %eax,%eax
10af9e: 0f 84 3b 01 00 00 je 10b0df <_Thread_Initialize+0x1bb><== NEVER TAKEN
fp_area = _Context_Fp_start( fp_area, 0 );
} else
fp_area = NULL;
the_thread->fp_context = fp_area;
10afa4: 89 b3 ec 00 00 00 mov %esi,0xec(%ebx)
the_thread->Start.fp_context = fp_area;
10afaa: 89 b3 cc 00 00 00 mov %esi,0xcc(%ebx)
*
10afb0: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
* @param[in] the_heap is the heap to operate upon
10afb7: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
* @param[in] starting_address is the starting address of the memory for
10afbe: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
* the heap
10afc5: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
/*
* Clear the libc reent hook.
*/
the_thread->libc_reent = NULL;
10afcc: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx)
10afd3: 00 00 00
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10afd6: a1 38 d8 11 00 mov 0x11d838,%eax
(void) _Workspace_Free( fp_area );
#endif
_Thread_Stack_Free( the_thread );
return FALSE;
10afdb: 31 ff xor %edi,%edi
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10afdd: 85 c0 test %eax,%eax
10afdf: 74 1d je 10affe <_Thread_Initialize+0xda>
extensions_area = _Workspace_Allocate(
10afe1: 83 ec 0c sub $0xc,%esp
10afe4: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax
10afeb: 50 push %eax
10afec: e8 38 0e 00 00 call 10be29 <_Workspace_Allocate>
10aff1: 89 c7 mov %eax,%edi
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area ) {
10aff3: 83 c4 10 add $0x10,%esp
10aff6: 85 c0 test %eax,%eax
10aff8: 0f 84 d1 00 00 00 je 10b0cf <_Thread_Initialize+0x1ab><== NEVER TAKEN
return FALSE;
}
} else
extensions_area = NULL;
the_thread->extensions = (void **) extensions_area;
10affe: 89 bb 00 01 00 00 mov %edi,0x100(%ebx)
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
10b004: 31 d2 xor %edx,%edx
10b006: 85 ff test %edi,%edi
10b008: 75 10 jne 10b01a <_Thread_Initialize+0xf6>
10b00a: eb 18 jmp 10b024 <_Thread_Initialize+0x100>
uint32_t i;
for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ )
the_thread->extensions[i] = NULL;
10b00c: 8b 83 00 01 00 00 mov 0x100(%ebx),%eax
10b012: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4)
* call.
*/
if ( the_thread->extensions ) {
uint32_t i;
for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ )
10b019: 42 inc %edx
10b01a: a1 38 d8 11 00 mov 0x11d838,%eax
10b01f: 40 inc %eax
10b020: 39 c2 cmp %eax,%edx
10b022: 72 e8 jb 10b00c <_Thread_Initialize+0xe8>
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
10b024: 8a 45 f2 mov -0xe(%ebp),%al
10b027: 88 83 ac 00 00 00 mov %al,0xac(%ebx)
the_thread->Start.budget_algorithm = budget_algorithm;
10b02d: 8b 45 24 mov 0x24(%ebp),%eax
10b030: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx)
the_thread->Start.budget_callout = budget_callout;
10b036: 8b 45 28 mov 0x28(%ebp),%eax
10b039: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx)
switch ( budget_algorithm ) {
10b03f: 83 7d 24 02 cmpl $0x2,0x24(%ebp)
10b043: 75 08 jne 10b04d <_Thread_Initialize+0x129><== ALWAYS TAKEN
case THREAD_CPU_BUDGET_ALGORITHM_NONE:
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
break;
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
10b045: a1 64 d7 11 00 mov 0x11d764,%eax <== NOT EXECUTED
10b04a: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED
break;
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
}
the_thread->Start.isr_level = isr_level;
10b04d: 8b 45 2c mov 0x2c(%ebp),%eax
10b050: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
the_thread->current_state = STATES_DORMANT;
10b056: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
the_thread->Wait.queue = NULL;
10b05d: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
the_thread->resource_count = 0;
10b064: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->suspend_count = 0;
10b06b: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx)
the_thread->real_priority = priority;
10b072: 8b 45 1c mov 0x1c(%ebp),%eax
10b075: 89 43 18 mov %eax,0x18(%ebx)
the_thread->Start.initial_priority = priority;
10b078: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx)
_Thread_Set_priority( the_thread, priority );
10b07e: 52 push %edx
10b07f: 52 push %edx
10b080: 50 push %eax
10b081: 53 push %ebx
10b082: e8 8d 05 00 00 call 10b614 <_Thread_Set_priority>
/*
* Initialize the CPU usage statistics
*/
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
the_thread->cpu_time_used.tv_sec = 0;
10b087: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx)
10b08e: 00 00 00
the_thread->cpu_time_used.tv_nsec = 0;
10b091: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx)
10b098: 00 00 00
10b09b: 0f b7 53 08 movzwl 0x8(%ebx),%edx
10b09f: 8b 45 08 mov 0x8(%ebp),%eax
10b0a2: 8b 40 1c mov 0x1c(%eax),%eax
10b0a5: 89 1c 90 mov %ebx,(%eax,%edx,4)
10b0a8: 8b 45 30 mov 0x30(%ebp),%eax
10b0ab: 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 );
10b0ae: 89 1c 24 mov %ebx,(%esp)
10b0b1: e8 92 0a 00 00 call 10bb48 <_User_extensions_Thread_create>
if ( !extension_status ) {
10b0b6: 83 c4 10 add $0x10,%esp
10b0b9: b2 01 mov $0x1,%dl
10b0bb: 84 c0 test %al,%al
10b0bd: 75 2e jne 10b0ed <_Thread_Initialize+0x1c9>
if ( extensions_area )
10b0bf: 85 ff test %edi,%edi
10b0c1: 74 0c je 10b0cf <_Thread_Initialize+0x1ab><== ALWAYS TAKEN
(void) _Workspace_Free( extensions_area );
10b0c3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b0c6: 57 push %edi <== NOT EXECUTED
10b0c7: e8 48 0d 00 00 call 10be14 <_Workspace_Free> <== NOT EXECUTED
10b0cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( fp_area )
10b0cf: 85 f6 test %esi,%esi
10b0d1: 74 0c je 10b0df <_Thread_Initialize+0x1bb><== ALWAYS TAKEN
(void) _Workspace_Free( fp_area );
10b0d3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b0d6: 56 push %esi <== NOT EXECUTED
10b0d7: e8 38 0d 00 00 call 10be14 <_Workspace_Free> <== NOT EXECUTED
10b0dc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
#endif
_Thread_Stack_Free( the_thread );
10b0df: 83 ec 0c sub $0xc,%esp
10b0e2: 53 push %ebx
10b0e3: e8 20 07 00 00 call 10b808 <_Thread_Stack_Free>
10b0e8: 31 d2 xor %edx,%edx
10b0ea: 83 c4 10 add $0x10,%esp
return FALSE;
}
return TRUE;
}
10b0ed: 88 d0 mov %dl,%al
10b0ef: 8d 65 f4 lea -0xc(%ebp),%esp
10b0f2: 5b pop %ebx
10b0f3: 5e pop %esi
10b0f4: 5f pop %edi
10b0f5: c9 leave
10b0f6: c3 ret
0010ef70 <_Thread_Reset>:
void _Thread_Reset(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
10ef70: 55 push %ebp
10ef71: 89 e5 mov %esp,%ebp
10ef73: 53 push %ebx
10ef74: 83 ec 10 sub $0x10,%esp
10ef77: 8b 5d 08 mov 0x8(%ebp),%ebx
the_thread->resource_count = 0;
10ef7a: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->suspend_count = 0;
10ef81: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx)
the_thread->is_preemptible = the_thread->Start.is_preemptible;
10ef88: 8a 83 ac 00 00 00 mov 0xac(%ebx),%al
10ef8e: 88 43 76 mov %al,0x76(%ebx)
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
10ef91: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax
10ef97: 89 43 7c mov %eax,0x7c(%ebx)
the_thread->budget_callout = the_thread->Start.budget_callout;
10ef9a: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax
10efa0: 89 83 80 00 00 00 mov %eax,0x80(%ebx)
the_thread->Start.pointer_argument = pointer_argument;
10efa6: 8b 45 0c mov 0xc(%ebp),%eax
10efa9: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
the_thread->Start.numeric_argument = numeric_argument;
10efaf: 8b 45 10 mov 0x10(%ebp),%eax
10efb2: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx)
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
10efb8: 53 push %ebx
10efb9: e8 9e ce ff ff call 10be5c <_Thread_queue_Extract_with_proxy>
10efbe: 83 c4 10 add $0x10,%esp
10efc1: 84 c0 test %al,%al
10efc3: 75 15 jne 10efda <_Thread_Reset+0x6a> <== NEVER TAKEN
if ( _Watchdog_Is_active( &the_thread->Timer ) )
10efc5: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10efc9: 75 0f jne 10efda <_Thread_Reset+0x6a> <== ALWAYS TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
10efcb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10efce: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED
10efd1: 50 push %eax <== NOT EXECUTED
10efd2: e8 c5 d7 ff ff call 10c79c <_Watchdog_Remove> <== NOT EXECUTED
10efd7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
10efda: 8b 83 bc 00 00 00 mov 0xbc(%ebx),%eax
10efe0: 39 43 14 cmp %eax,0x14(%ebx)
10efe3: 74 12 je 10eff7 <_Thread_Reset+0x87>
the_thread->real_priority = the_thread->Start.initial_priority;
10efe5: 89 43 18 mov %eax,0x18(%ebx)
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
10efe8: 89 45 0c mov %eax,0xc(%ebp)
10efeb: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
10efee: 8b 5d fc mov -0x4(%ebp),%ebx
10eff1: 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 );
10eff2: e9 41 d0 ff ff jmp 10c038 <_Thread_Set_priority>
}
}
10eff7: 8b 5d fc mov -0x4(%ebp),%ebx
10effa: c9 leave
10effb: c3 ret
0010e498 <_Thread_Reset_timeslice>:
* ready chain
* select heir
*/
void _Thread_Reset_timeslice( void )
{
10e498: 55 push %ebp
10e499: 89 e5 mov %esp,%ebp
10e49b: 56 push %esi
10e49c: 53 push %ebx
ISR_Level level;
Thread_Control *executing;
Chain_Control *ready;
executing = _Thread_Executing;
10e49d: 8b 0d 58 d8 11 00 mov 0x11d858,%ecx
ready = executing->ready;
10e4a3: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx
_ISR_Disable( level );
10e4a9: 9c pushf
10e4aa: fa cli
10e4ab: 5e pop %esi
if ( _Chain_Has_only_one_node( ready ) ) {
10e4ac: 8b 03 mov (%ebx),%eax
10e4ae: 3b 43 08 cmp 0x8(%ebx),%eax
10e4b1: 75 04 jne 10e4b7 <_Thread_Reset_timeslice+0x1f>
_ISR_Enable( level );
10e4b3: 56 push %esi
10e4b4: 9d popf
10e4b5: eb 35 jmp 10e4ec <_Thread_Reset_timeslice+0x54>
10e4b7: 8b 11 mov (%ecx),%edx
10e4b9: 8b 41 04 mov 0x4(%ecx),%eax
10e4bc: 89 42 04 mov %eax,0x4(%edx)
10e4bf: 89 10 mov %edx,(%eax)
10e4c1: 8d 43 04 lea 0x4(%ebx),%eax
10e4c4: 89 01 mov %eax,(%ecx)
10e4c6: 8b 43 08 mov 0x8(%ebx),%eax
10e4c9: 89 4b 08 mov %ecx,0x8(%ebx)
10e4cc: 89 08 mov %ecx,(%eax)
10e4ce: 89 41 04 mov %eax,0x4(%ecx)
return;
}
_Chain_Extract_unprotected( &executing->Object.Node );
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
10e4d1: 56 push %esi
10e4d2: 9d popf
10e4d3: fa cli
if ( _Thread_Is_heir( executing ) )
10e4d4: 3b 0d 24 d8 11 00 cmp 0x11d824,%ecx
10e4da: 75 07 jne 10e4e3 <_Thread_Reset_timeslice+0x4b><== NEVER TAKEN
_Thread_Heir = (Thread_Control *) ready->first;
10e4dc: 8b 03 mov (%ebx),%eax
10e4de: a3 24 d8 11 00 mov %eax,0x11d824
_Context_Switch_necessary = TRUE;
10e4e3: c6 05 68 d8 11 00 01 movb $0x1,0x11d868
_ISR_Enable( level );
10e4ea: 56 push %esi
10e4eb: 9d popf
}
10e4ec: 5b pop %ebx
10e4ed: 5e pop %esi
10e4ee: c9 leave
10e4ef: c3 ret
0010bfb0 <_Thread_Restart>:
bool _Thread_Restart(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
10bfb0: 55 push %ebp
10bfb1: 89 e5 mov %esp,%ebp
10bfb3: 53 push %ebx
10bfb4: 83 ec 04 sub $0x4,%esp
10bfb7: 8b 5d 08 mov 0x8(%ebp),%ebx
if ( !_States_Is_dormant( the_thread->current_state ) ) {
10bfba: 31 c0 xor %eax,%eax
10bfbc: f6 43 10 01 testb $0x1,0x10(%ebx)
10bfc0: 75 70 jne 10c032 <_Thread_Restart+0x82>
_Thread_Set_transient( the_thread );
10bfc2: 83 ec 0c sub $0xc,%esp
10bfc5: 53 push %ebx
10bfc6: e8 a1 01 00 00 call 10c16c <_Thread_Set_transient>
_Thread_Reset( the_thread, pointer_argument, numeric_argument );
10bfcb: 83 c4 0c add $0xc,%esp
10bfce: ff 75 10 pushl 0x10(%ebp)
10bfd1: ff 75 0c pushl 0xc(%ebp)
10bfd4: 53 push %ebx
10bfd5: e8 96 2f 00 00 call 10ef70 <_Thread_Reset>
_Thread_Load_environment( the_thread );
10bfda: 89 1c 24 mov %ebx,(%esp)
10bfdd: e8 8a 2c 00 00 call 10ec6c <_Thread_Load_environment>
_Thread_Ready( the_thread );
10bfe2: 89 1c 24 mov %ebx,(%esp)
10bfe5: e8 e6 2e 00 00 call 10eed0 <_Thread_Ready>
_User_extensions_Thread_restart( the_thread );
10bfea: 89 1c 24 mov %ebx,(%esp)
10bfed: e8 ee 05 00 00 call 10c5e0 <_User_extensions_Thread_restart>
if ( _Thread_Is_executing ( the_thread ) )
10bff2: 83 c4 10 add $0x10,%esp
10bff5: b0 01 mov $0x1,%al
10bff7: 3b 1d c4 0c 12 00 cmp 0x120cc4,%ebx
10bffd: 75 33 jne 10c032 <_Thread_Restart+0x82>
* Returns pointer to the start of the memory block if success, NULL if
* failure.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
* @param[in] alignment the required alignment
10bfff: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx)
10c006: 74 12 je 10c01a <_Thread_Restart+0x6a>
* @return NULL if unsuccessful and a pointer to the block if successful
10c008: 83 ec 0c sub $0xc,%esp
10c00b: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax
10c011: 50 push %eax
10c012: e8 47 09 00 00 call 10c95e <_CPU_Context_restore_fp>
10c017: 83 c4 10 add $0x10,%esp
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
10c01a: 83 ec 0c sub $0xc,%esp
10c01d: a1 c4 0c 12 00 mov 0x120cc4,%eax
10c022: 05 d4 00 00 00 add $0xd4,%eax
10c027: 50 push %eax
10c028: e8 20 09 00 00 call 10c94d <_CPU_Context_restore>
10c02d: b0 01 mov $0x1,%al <== NOT EXECUTED
10c02f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return TRUE;
}
return FALSE;
}
10c032: 8b 5d fc mov -0x4(%ebp),%ebx
10c035: c9 leave
10c036: c3 ret
0010c9c0 <_Thread_Resume>:
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
10c9c0: 55 push %ebp
10c9c1: 89 e5 mov %esp,%ebp
10c9c3: 53 push %ebx
10c9c4: 8b 4d 08 mov 0x8(%ebp),%ecx
10c9c7: 8a 45 0c mov 0xc(%ebp),%al
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10c9ca: 9c pushf
10c9cb: fa cli
10c9cc: 5b pop %ebx
if ( force == TRUE )
10c9cd: 84 c0 test %al,%al
10c9cf: 74 09 je 10c9da <_Thread_Resume+0x1a> <== NEVER TAKEN
the_thread->suspend_count = 0;
10c9d1: c7 41 70 00 00 00 00 movl $0x0,0x70(%ecx)
10c9d8: eb 03 jmp 10c9dd <_Thread_Resume+0x1d>
else
the_thread->suspend_count--;
10c9da: ff 49 70 decl 0x70(%ecx) <== NOT EXECUTED
if ( the_thread->suspend_count > 0 ) {
10c9dd: 83 79 70 00 cmpl $0x0,0x70(%ecx)
10c9e1: 74 04 je 10c9e7 <_Thread_Resume+0x27> <== ALWAYS TAKEN
_ISR_Enable( level );
10c9e3: 53 push %ebx <== NOT EXECUTED
10c9e4: 9d popf <== NOT EXECUTED
10c9e5: eb 77 jmp 10ca5e <_Thread_Resume+0x9e> <== NOT EXECUTED
return;
}
current_state = the_thread->current_state;
10c9e7: 8b 41 10 mov 0x10(%ecx),%eax
if ( current_state & STATES_SUSPENDED ) {
10c9ea: a8 02 test $0x2,%al
10c9ec: 74 6e je 10ca5c <_Thread_Resume+0x9c> <== NEVER TAKEN
* @param[in] page_size is the size in bytes of the allocation unit
*
* @return This method returns the maximum memory available. If
* unsuccessful, 0 will be returned.
*/
static inline uint32_t _Protected_heap_Initialize(
10c9ee: 83 e0 fd and $0xfffffffd,%eax
current_state =
10c9f1: 89 41 10 mov %eax,0x10(%ecx)
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
if ( _States_Is_ready( current_state ) ) {
10c9f4: 85 c0 test %eax,%eax
10c9f6: 75 64 jne 10ca5c <_Thread_Resume+0x9c> <== NEVER TAKEN
* otherwise.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the user block
* to obtain the size of
* @param[in] size points to a user area to return the size in
10c9f8: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx
10c9fe: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax
10ca05: 66 09 02 or %ax,(%edx)
* @return TRUE if successfully able to determine the size, FALSE otherwise
10ca08: 66 a1 48 93 12 00 mov 0x129348,%ax
10ca0e: 0b 81 94 00 00 00 or 0x94(%ecx),%eax
10ca14: 66 a3 48 93 12 00 mov %ax,0x129348
_Priority_Add_to_bit_map( &the_thread->Priority_map );
_Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
10ca1a: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax
10ca20: 8d 50 04 lea 0x4(%eax),%edx
10ca23: 89 11 mov %edx,(%ecx)
10ca25: 8b 50 08 mov 0x8(%eax),%edx
10ca28: 89 48 08 mov %ecx,0x8(%eax)
10ca2b: 89 0a mov %ecx,(%edx)
10ca2d: 89 51 04 mov %edx,0x4(%ecx)
_ISR_Flash( level );
10ca30: 53 push %ebx
10ca31: 9d popf
10ca32: fa cli
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
10ca33: 8b 51 14 mov 0x14(%ecx),%edx
10ca36: a1 20 93 12 00 mov 0x129320,%eax
10ca3b: 3b 50 14 cmp 0x14(%eax),%edx
10ca3e: 73 1c jae 10ca5c <_Thread_Resume+0x9c>
_Thread_Heir = the_thread;
10ca40: 89 0d 20 93 12 00 mov %ecx,0x129320
if ( _Thread_Executing->is_preemptible ||
10ca46: a1 54 93 12 00 mov 0x129354,%eax
10ca4b: 80 78 76 00 cmpb $0x0,0x76(%eax)
10ca4f: 75 04 jne 10ca55 <_Thread_Resume+0x95>
10ca51: 85 d2 test %edx,%edx
10ca53: 75 07 jne 10ca5c <_Thread_Resume+0x9c> <== ALWAYS TAKEN
the_thread->current_priority == 0 )
_Context_Switch_necessary = TRUE;
10ca55: c6 05 64 93 12 00 01 movb $0x1,0x129364
}
}
}
_ISR_Enable( level );
10ca5c: 53 push %ebx
10ca5d: 9d popf
}
10ca5e: 5b pop %ebx
10ca5f: c9 leave
10ca60: c3 ret
0010b7b8 <_Thread_Stack_Allocate>:
size_t _Thread_Stack_Allocate(
Thread_Control *the_thread,
size_t stack_size
)
{
10b7b8: 55 push %ebp
10b7b9: 89 e5 mov %esp,%ebp
10b7bb: 53 push %ebx
10b7bc: 83 ec 04 sub $0x4,%esp
10b7bf: a1 80 93 11 00 mov 0x119380,%eax
10b7c4: 8b 5d 0c mov 0xc(%ebp),%ebx
10b7c7: 39 c3 cmp %eax,%ebx
10b7c9: 73 02 jae 10b7cd <_Thread_Stack_Allocate+0x15>
10b7cb: 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_Table->stack_allocate_hook ) {
10b7cd: a1 30 d8 11 00 mov 0x11d830,%eax
10b7d2: 8b 40 20 mov 0x20(%eax),%eax
10b7d5: 85 c0 test %eax,%eax
10b7d7: 74 08 je 10b7e1 <_Thread_Stack_Allocate+0x29><== ALWAYS TAKEN
stack_addr = (*_Configuration_Table->stack_allocate_hook)( the_stack_size );
10b7d9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b7dc: 53 push %ebx <== NOT EXECUTED
10b7dd: ff d0 call *%eax <== NOT EXECUTED
10b7df: eb 09 jmp 10b7ea <_Thread_Stack_Allocate+0x32><== NOT EXECUTED
* 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 );
10b7e1: 83 ec 0c sub $0xc,%esp
10b7e4: 53 push %ebx
10b7e5: e8 3f 06 00 00 call 10be29 <_Workspace_Allocate>
10b7ea: 89 c1 mov %eax,%ecx
10b7ec: 83 c4 10 add $0x10,%esp
}
if ( !stack_addr )
10b7ef: 31 c0 xor %eax,%eax
10b7f1: 85 c9 test %ecx,%ecx
10b7f3: 0f 95 c0 setne %al
10b7f6: f7 d8 neg %eax
10b7f8: 21 d8 and %ebx,%eax
the_stack_size = 0;
the_thread->Start.stack = stack_addr;
10b7fa: 8b 55 08 mov 0x8(%ebp),%edx
10b7fd: 89 8a d0 00 00 00 mov %ecx,0xd0(%edx)
return the_stack_size;
}
10b803: 8b 5d fc mov -0x4(%ebp),%ebx
10b806: c9 leave
10b807: c3 ret
0010b808 <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
10b808: 55 push %ebp
10b809: 89 e5 mov %esp,%ebp
10b80b: 8b 55 08 mov 0x8(%ebp),%edx
/*
* If the API provided the stack space, then don't free it.
*/
if ( !the_thread->Start.core_allocated_stack )
10b80e: 80 ba c0 00 00 00 00 cmpb $0x0,0xc0(%edx)
10b815: 74 21 je 10b838 <_Thread_Stack_Free+0x30><== NEVER TAKEN
* 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_Table->stack_free_hook )
10b817: a1 30 d8 11 00 mov 0x11d830,%eax
10b81c: 8b 48 24 mov 0x24(%eax),%ecx
10b81f: 85 c9 test %ecx,%ecx
10b821: 8b 82 c8 00 00 00 mov 0xc8(%edx),%eax
10b827: 74 06 je 10b82f <_Thread_Stack_Free+0x27><== ALWAYS TAKEN
(*_Configuration_Table->stack_free_hook)(
10b829: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
the_thread->Start.Initial_stack.area
);
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
10b82c: c9 leave <== NOT EXECUTED
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
if ( _Configuration_Table->stack_free_hook )
(*_Configuration_Table->stack_free_hook)(
10b82d: ff e1 jmp *%ecx <== NOT EXECUTED
the_thread->Start.Initial_stack.area
);
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
10b82f: 89 45 08 mov %eax,0x8(%ebp)
}
10b832: c9 leave
if ( _Configuration_Table->stack_free_hook )
(*_Configuration_Table->stack_free_hook)(
the_thread->Start.Initial_stack.area
);
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
10b833: e9 dc 05 00 00 jmp 10be14 <_Workspace_Free>
}
10b838: c9 leave <== NOT EXECUTED
10b839: c3 ret <== NOT EXECUTED
0010b8f0 <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
10b8f0: 55 push %ebp
10b8f1: 89 e5 mov %esp,%ebp
10b8f3: 53 push %ebx
10b8f4: 83 ec 04 sub $0x4,%esp
Thread_Control *executing;
executing = _Thread_Executing;
10b8f7: 8b 1d 58 d8 11 00 mov 0x11d858,%ebx
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
10b8fd: 80 7b 76 00 cmpb $0x0,0x76(%ebx)
10b901: 74 4c je 10b94f <_Thread_Tickle_timeslice+0x5f>
return;
if ( !_States_Is_ready( executing->current_state ) )
10b903: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10b907: 75 46 jne 10b94f <_Thread_Tickle_timeslice+0x5f><== NEVER TAKEN
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
10b909: 8b 43 7c mov 0x7c(%ebx),%eax
10b90c: 83 f8 01 cmp $0x1,%eax
10b90f: 72 3e jb 10b94f <_Thread_Tickle_timeslice+0x5f>
10b911: 83 f8 02 cmp $0x2,%eax
10b914: 76 07 jbe 10b91d <_Thread_Tickle_timeslice+0x2d>
10b916: 83 f8 03 cmp $0x3,%eax
10b919: 75 34 jne 10b94f <_Thread_Tickle_timeslice+0x5f><== NEVER TAKEN
10b91b: eb 1a jmp 10b937 <_Thread_Tickle_timeslice+0x47>
case THREAD_CPU_BUDGET_ALGORITHM_NONE:
break;
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
if ( (int)(--executing->cpu_time_budget) <= 0 ) {
10b91d: 8b 43 78 mov 0x78(%ebx),%eax
10b920: 48 dec %eax
10b921: 89 43 78 mov %eax,0x78(%ebx)
10b924: 85 c0 test %eax,%eax
10b926: 7f 27 jg 10b94f <_Thread_Tickle_timeslice+0x5f>
_Thread_Reset_timeslice();
10b928: e8 6b 2b 00 00 call 10e498 <_Thread_Reset_timeslice>
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
10b92d: a1 64 d7 11 00 mov 0x11d764,%eax
10b932: 89 43 78 mov %eax,0x78(%ebx)
10b935: eb 18 jmp 10b94f <_Thread_Tickle_timeslice+0x5f>
}
break;
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
10b937: 8b 43 78 mov 0x78(%ebx),%eax
10b93a: 48 dec %eax
10b93b: 89 43 78 mov %eax,0x78(%ebx)
10b93e: 85 c0 test %eax,%eax
10b940: 75 0d jne 10b94f <_Thread_Tickle_timeslice+0x5f>
(*executing->budget_callout)( executing );
10b942: 83 ec 0c sub $0xc,%esp
10b945: 53 push %ebx
10b946: ff 93 80 00 00 00 call *0x80(%ebx)
10b94c: 83 c4 10 add $0x10,%esp
break;
}
}
10b94f: 8b 5d fc mov -0x4(%ebp),%ebx
10b952: c9 leave
10b953: c3 ret
0010b954 <_Thread_Yield_processor>:
* ready chain
* select heir
*/
void _Thread_Yield_processor( void )
{
10b954: 55 push %ebp
10b955: 89 e5 mov %esp,%ebp
10b957: 56 push %esi
10b958: 53 push %ebx
ISR_Level level;
Thread_Control *executing;
Chain_Control *ready;
executing = _Thread_Executing;
10b959: 8b 0d 58 d8 11 00 mov 0x11d858,%ecx
ready = executing->ready;
10b95f: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx
_ISR_Disable( level );
10b965: 9c pushf
10b966: fa cli
10b967: 5e pop %esi
if ( !_Chain_Has_only_one_node( ready ) ) {
10b968: 8b 03 mov (%ebx),%eax
10b96a: 3b 43 08 cmp 0x8(%ebx),%eax
10b96d: 74 2e je 10b99d <_Thread_Yield_processor+0x49>
10b96f: 8b 11 mov (%ecx),%edx
10b971: 8b 41 04 mov 0x4(%ecx),%eax
10b974: 89 42 04 mov %eax,0x4(%edx)
10b977: 89 10 mov %edx,(%eax)
10b979: 8d 43 04 lea 0x4(%ebx),%eax
10b97c: 89 01 mov %eax,(%ecx)
10b97e: 8b 43 08 mov 0x8(%ebx),%eax
10b981: 89 4b 08 mov %ecx,0x8(%ebx)
10b984: 89 08 mov %ecx,(%eax)
10b986: 89 41 04 mov %eax,0x4(%ecx)
_Chain_Extract_unprotected( &executing->Object.Node );
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
10b989: 56 push %esi
10b98a: 9d popf
10b98b: fa cli
if ( _Thread_Is_heir( executing ) )
10b98c: 3b 0d 24 d8 11 00 cmp 0x11d824,%ecx
10b992: 75 11 jne 10b9a5 <_Thread_Yield_processor+0x51><== NEVER TAKEN
_Thread_Heir = (Thread_Control *) ready->first;
10b994: 8b 03 mov (%ebx),%eax
10b996: a3 24 d8 11 00 mov %eax,0x11d824
10b99b: eb 08 jmp 10b9a5 <_Thread_Yield_processor+0x51>
_Context_Switch_necessary = TRUE;
}
else if ( !_Thread_Is_heir( executing ) )
10b99d: 3b 0d 24 d8 11 00 cmp 0x11d824,%ecx
10b9a3: 74 07 je 10b9ac <_Thread_Yield_processor+0x58><== ALWAYS TAKEN
_Context_Switch_necessary = TRUE;
10b9a5: c6 05 68 d8 11 00 01 movb $0x1,0x11d868
_ISR_Enable( level );
10b9ac: 56 push %esi
10b9ad: 9d popf
}
10b9ae: 5b pop %ebx
10b9af: 5e pop %esi
10b9b0: c9 leave
10b9b1: c3 ret
0010b368 <_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
)
{
10b368: 55 push %ebp
10b369: 89 e5 mov %esp,%ebp
10b36b: 57 push %edi
10b36c: 56 push %esi
10b36d: 53 push %ebx
10b36e: 83 ec 18 sub $0x18,%esp
10b371: 8b 4d 0c mov 0xc(%ebp),%ecx
10b374: 8d 41 3c lea 0x3c(%ecx),%eax
10b377: 89 41 38 mov %eax,0x38(%ecx)
10b37a: c7 41 3c 00 00 00 00 movl $0x0,0x3c(%ecx)
10b381: 8d 41 38 lea 0x38(%ecx),%eax
10b384: 89 41 40 mov %eax,0x40(%ecx)
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
10b387: 8b 79 14 mov 0x14(%ecx),%edi
extern "C" {
#endif
/**
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
10b38a: 89 f8 mov %edi,%eax
10b38c: c1 e8 06 shr $0x6,%eax
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
10b38f: 6b c0 0c imul $0xc,%eax,%eax
10b392: 8b 5d 08 mov 0x8(%ebp),%ebx
10b395: 01 c3 add %eax,%ebx
block_state = the_thread_queue->state;
10b397: 8b 55 08 mov 0x8(%ebp),%edx
10b39a: 8b 52 38 mov 0x38(%edx),%edx
10b39d: 89 55 e8 mov %edx,-0x18(%ebp)
if ( _Thread_queue_Is_reverse_search( priority ) )
10b3a0: f7 c7 20 00 00 00 test $0x20,%edi
10b3a6: 75 77 jne 10b41f <_Thread_queue_Enqueue_priority+0xb7>
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
10b3a8: 83 c3 04 add $0x4,%ebx
10b3ab: 89 5d ec mov %ebx,-0x14(%ebp)
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
10b3ae: 89 45 dc mov %eax,-0x24(%ebp)
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
10b3b1: 9c pushf
10b3b2: fa cli
10b3b3: 5e pop %esi
search_thread = (Thread_Control *) header->first;
10b3b4: 8b 45 dc mov -0x24(%ebp),%eax
10b3b7: 8b 5d 08 mov 0x8(%ebp),%ebx
10b3ba: 8b 14 18 mov (%eax,%ebx,1),%edx
10b3bd: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp)
10b3c4: eb 1b jmp 10b3e1 <_Thread_queue_Enqueue_priority+0x79>
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
search_priority = search_thread->current_priority;
10b3c6: 8b 5a 14 mov 0x14(%edx),%ebx
10b3c9: 89 5d e0 mov %ebx,-0x20(%ebp)
if ( priority <= search_priority )
10b3cc: 39 df cmp %ebx,%edi
10b3ce: 76 16 jbe 10b3e6 <_Thread_queue_Enqueue_priority+0x7e>
break;
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
10b3d0: 56 push %esi
10b3d1: 9d popf
10b3d2: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10b3d3: 8b 45 e8 mov -0x18(%ebp),%eax
10b3d6: 85 42 10 test %eax,0x10(%edx)
10b3d9: 75 04 jne 10b3df <_Thread_queue_Enqueue_priority+0x77><== ALWAYS TAKEN
_ISR_Enable( level );
10b3db: 56 push %esi <== NOT EXECUTED
10b3dc: 9d popf <== NOT EXECUTED
10b3dd: eb d2 jmp 10b3b1 <_Thread_queue_Enqueue_priority+0x49><== NOT EXECUTED
goto restart_forward_search;
}
search_thread =
10b3df: 8b 12 mov (%edx),%edx
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
10b3e1: 3b 55 ec cmp -0x14(%ebp),%edx
10b3e4: 75 e0 jne 10b3c6 <_Thread_queue_Enqueue_priority+0x5e>
10b3e6: 89 55 f0 mov %edx,-0x10(%ebp)
10b3e9: 89 f3 mov %esi,%ebx
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
10b3eb: 8b 45 08 mov 0x8(%ebp),%eax
10b3ee: 83 78 30 01 cmpl $0x1,0x30(%eax)
10b3f2: 0f 85 b4 00 00 00 jne 10b4ac <_Thread_queue_Enqueue_priority+0x144><== NEVER TAKEN
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10b3f8: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
if ( priority == search_priority )
10b3ff: 3b 7d e0 cmp -0x20(%ebp),%edi
10b402: 0f 84 87 00 00 00 je 10b48f <_Thread_queue_Enqueue_priority+0x127>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
10b408: 8b 42 04 mov 0x4(%edx),%eax
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
10b40b: 89 11 mov %edx,(%ecx)
the_node->previous = previous_node;
10b40d: 89 41 04 mov %eax,0x4(%ecx)
previous_node->next = the_node;
10b410: 89 08 mov %ecx,(%eax)
search_node->previous = the_node;
10b412: 89 4a 04 mov %ecx,0x4(%edx)
the_thread->Wait.queue = the_thread_queue;
10b415: 8b 55 08 mov 0x8(%ebp),%edx
10b418: 89 51 44 mov %edx,0x44(%ecx)
_ISR_Enable( level );
10b41b: 56 push %esi
10b41c: 9d popf
10b41d: eb 69 jmp 10b488 <_Thread_queue_Enqueue_priority+0x120>
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
10b41f: 8d 43 08 lea 0x8(%ebx),%eax
10b422: 89 45 e4 mov %eax,-0x1c(%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;
10b425: 0f b6 05 84 93 11 00 movzbl 0x119384,%eax
10b42c: 40 inc %eax
10b42d: 89 45 e0 mov %eax,-0x20(%ebp)
_ISR_Disable( level );
10b430: 9c pushf
10b431: fa cli
10b432: 5e pop %esi
search_thread = (Thread_Control *) header->last;
10b433: 8b 45 e4 mov -0x1c(%ebp),%eax
10b436: 8b 10 mov (%eax),%edx
10b438: eb 1c jmp 10b456 <_Thread_queue_Enqueue_priority+0xee>
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
search_priority = search_thread->current_priority;
10b43a: 8b 42 14 mov 0x14(%edx),%eax
10b43d: 89 45 e0 mov %eax,-0x20(%ebp)
if ( priority >= search_priority )
10b440: 39 c7 cmp %eax,%edi
10b442: 73 16 jae 10b45a <_Thread_queue_Enqueue_priority+0xf2>
break;
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
10b444: 56 push %esi
10b445: 9d popf
10b446: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10b447: 8b 45 e8 mov -0x18(%ebp),%eax
10b44a: 85 42 10 test %eax,0x10(%edx)
10b44d: 75 04 jne 10b453 <_Thread_queue_Enqueue_priority+0xeb><== ALWAYS TAKEN
_ISR_Enable( level );
10b44f: 56 push %esi <== NOT EXECUTED
10b450: 9d popf <== NOT EXECUTED
10b451: eb d2 jmp 10b425 <_Thread_queue_Enqueue_priority+0xbd><== NOT EXECUTED
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
10b453: 8b 52 04 mov 0x4(%edx),%edx
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
10b456: 39 da cmp %ebx,%edx
10b458: 75 e0 jne 10b43a <_Thread_queue_Enqueue_priority+0xd2>
10b45a: 89 55 f0 mov %edx,-0x10(%ebp)
10b45d: 89 f3 mov %esi,%ebx
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
10b45f: 8b 45 08 mov 0x8(%ebp),%eax
10b462: 83 78 30 01 cmpl $0x1,0x30(%eax)
10b466: 75 44 jne 10b4ac <_Thread_queue_Enqueue_priority+0x144><== NEVER TAKEN
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10b468: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
if ( priority == search_priority )
10b46f: 3b 7d e0 cmp -0x20(%ebp),%edi
10b472: 74 1b je 10b48f <_Thread_queue_Enqueue_priority+0x127>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
10b474: 8b 02 mov (%edx),%eax
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
10b476: 89 01 mov %eax,(%ecx)
the_node->previous = search_node;
10b478: 89 51 04 mov %edx,0x4(%ecx)
search_node->next = the_node;
10b47b: 89 0a mov %ecx,(%edx)
next_node->previous = the_node;
10b47d: 89 48 04 mov %ecx,0x4(%eax)
the_thread->Wait.queue = the_thread_queue;
10b480: 8b 55 08 mov 0x8(%ebp),%edx
10b483: 89 51 44 mov %edx,0x44(%ecx)
_ISR_Enable( level );
10b486: 56 push %esi
10b487: 9d popf
10b488: b8 01 00 00 00 mov $0x1,%eax
10b48d: eb 28 jmp 10b4b7 <_Thread_queue_Enqueue_priority+0x14f>
10b48f: 8b 45 f0 mov -0x10(%ebp),%eax
10b492: 83 c0 3c add $0x3c,%eax
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;
10b495: 8b 50 04 mov 0x4(%eax),%edx
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
10b498: 89 01 mov %eax,(%ecx)
the_node->previous = previous_node;
10b49a: 89 51 04 mov %edx,0x4(%ecx)
previous_node->next = the_node;
10b49d: 89 0a mov %ecx,(%edx)
search_node->previous = the_node;
10b49f: 89 48 04 mov %ecx,0x4(%eax)
the_thread->Wait.queue = the_thread_queue;
10b4a2: 8b 45 08 mov 0x8(%ebp),%eax
10b4a5: 89 41 44 mov %eax,0x44(%ecx)
_ISR_Enable( level );
10b4a8: 53 push %ebx
10b4a9: 9d popf
10b4aa: eb dc jmp 10b488 <_Thread_queue_Enqueue_priority+0x120>
* 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;
10b4ac: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
10b4af: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
return the_thread_queue->sync_state;
10b4b1: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
10b4b4: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED
}
10b4b7: 83 c4 18 add $0x18,%esp
10b4ba: 5b pop %ebx
10b4bb: 5e pop %esi
10b4bc: 5f pop %edi
10b4bd: c9 leave
10b4be: c3 ret
0010f040 <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10f040: 55 push %ebp
10f041: 89 e5 mov %esp,%ebp
10f043: 53 push %ebx
10f044: 83 ec 04 sub $0x4,%esp
10f047: 8b 5d 0c mov 0xc(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
10f04a: 9c pushf
10f04b: fa cli
10f04c: 59 pop %ecx
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10f04d: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx)
10f054: 75 07 jne 10f05d <_Thread_queue_Extract_fifo+0x1d><== ALWAYS TAKEN
_ISR_Enable( level );
10f056: 51 push %ecx <== NOT EXECUTED
10f057: 9d popf <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
10f058: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10f05b: c9 leave <== NOT EXECUTED
10f05c: c3 ret <== NOT EXECUTED
10f05d: 8b 13 mov (%ebx),%edx
10f05f: 8b 43 04 mov 0x4(%ebx),%eax
10f062: 89 42 04 mov %eax,0x4(%edx)
10f065: 89 10 mov %edx,(%eax)
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
10f067: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10f06e: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10f072: 74 04 je 10f078 <_Thread_queue_Extract_fifo+0x38>
_ISR_Enable( level );
10f074: 51 push %ecx
10f075: 9d popf
10f076: eb 18 jmp 10f090 <_Thread_queue_Extract_fifo+0x50>
* a block of the requested size, then NULL is returned.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
* @return NULL if unsuccessful and a pointer to the block if successful
*/
10f078: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
10f07f: 51 push %ecx
10f080: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
10f081: 83 ec 0c sub $0xc,%esp
10f084: 8d 43 48 lea 0x48(%ebx),%eax
10f087: 50 push %eax
10f088: e8 b3 cc ff ff call 10bd40 <_Watchdog_Remove>
10f08d: 83 c4 10 add $0x10,%esp
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
10f090: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp)
10f097: 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
}
10f09a: 8b 5d fc mov -0x4(%ebp),%ebx
10f09d: c9 leave
10f09e: e9 69 ba ff ff jmp 10ab0c <_Thread_Clear_state>
0010e2f0 <_Thread_queue_Extract_priority_helper>:
void _Thread_queue_Extract_priority_helper(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
bool requeuing
)
{
10e2f0: 55 push %ebp
10e2f1: 89 e5 mov %esp,%ebp
10e2f3: 57 push %edi
10e2f4: 56 push %esi
10e2f5: 53 push %ebx
10e2f6: 83 ec 0c sub $0xc,%esp
10e2f9: 8b 5d 0c mov 0xc(%ebp),%ebx
10e2fc: 8a 45 10 mov 0x10(%ebp),%al
10e2ff: 88 45 eb mov %al,-0x15(%ebp)
Chain_Node *new_first_node;
Chain_Node *new_second_node;
Chain_Node *last_node;
the_node = (Chain_Node *) the_thread;
_ISR_Disable( level );
10e302: 9c pushf
10e303: fa cli
10e304: 8f 45 ec popl -0x14(%ebp)
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10e307: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx)
10e30e: 75 09 jne 10e319 <_Thread_queue_Extract_priority_helper+0x29><== ALWAYS TAKEN
_ISR_Enable( level );
10e310: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED
10e313: 9d popf <== NOT EXECUTED
10e314: e9 8f 00 00 00 jmp 10e3a8 <_Thread_queue_Extract_priority_helper+0xb8><== NOT EXECUTED
/*
* The thread was actually waiting on a thread queue so let's remove it.
*/
next_node = the_node->next;
10e319: 8b 33 mov (%ebx),%esi
previous_node = the_node->previous;
10e31b: 8b 4b 04 mov 0x4(%ebx),%ecx
* to obtain the size of
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
10e31e: 8b 53 38 mov 0x38(%ebx),%edx
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
10e321: 8d 43 3c lea 0x3c(%ebx),%eax
10e324: 39 c2 cmp %eax,%edx
10e326: 74 33 je 10e35b <_Thread_queue_Extract_priority_helper+0x6b>
new_first_node = the_thread->Wait.Block2n.first;
new_first_thread = (Thread_Control *) new_first_node;
last_node = the_thread->Wait.Block2n.last;
10e328: 8b 43 40 mov 0x40(%ebx),%eax
10e32b: 89 45 f0 mov %eax,-0x10(%ebp)
new_second_node = new_first_node->next;
10e32e: 8b 3a mov (%edx),%edi
previous_node->next = new_first_node;
10e330: 89 11 mov %edx,(%ecx)
next_node->previous = new_first_node;
10e332: 89 56 04 mov %edx,0x4(%esi)
new_first_node->next = next_node;
10e335: 89 32 mov %esi,(%edx)
new_first_node->previous = previous_node;
10e337: 89 4a 04 mov %ecx,0x4(%edx)
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
10e33a: 8b 43 38 mov 0x38(%ebx),%eax
10e33d: 3b 43 40 cmp 0x40(%ebx),%eax
10e340: 74 1e je 10e360 <_Thread_queue_Extract_priority_helper+0x70>
/* > two threads on 2-n */
new_second_node->previous =
10e342: 8d 42 38 lea 0x38(%edx),%eax
10e345: 89 47 04 mov %eax,0x4(%edi)
_Chain_Head( &new_first_thread->Wait.Block2n );
new_first_thread->Wait.Block2n.first = new_second_node;
10e348: 89 7a 38 mov %edi,0x38(%edx)
new_first_thread->Wait.Block2n.last = last_node;
10e34b: 8b 45 f0 mov -0x10(%ebp),%eax
10e34e: 89 42 40 mov %eax,0x40(%edx)
last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
10e351: 8d 42 3c lea 0x3c(%edx),%eax
10e354: 8b 55 f0 mov -0x10(%ebp),%edx
10e357: 89 02 mov %eax,(%edx)
10e359: eb 05 jmp 10e360 <_Thread_queue_Extract_priority_helper+0x70>
}
} else {
previous_node->next = next_node;
10e35b: 89 31 mov %esi,(%ecx)
next_node->previous = previous_node;
10e35d: 89 4e 04 mov %ecx,0x4(%esi)
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
10e360: 80 7d eb 00 cmpb $0x0,-0x15(%ebp)
10e364: 74 06 je 10e36c <_Thread_queue_Extract_priority_helper+0x7c>
_ISR_Enable( level );
10e366: ff 75 ec pushl -0x14(%ebp)
10e369: 9d popf
10e36a: eb 3c jmp 10e3a8 <_Thread_queue_Extract_priority_helper+0xb8>
return;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10e36c: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10e370: 74 06 je 10e378 <_Thread_queue_Extract_priority_helper+0x88>
_ISR_Enable( level );
10e372: ff 75 ec pushl -0x14(%ebp)
10e375: 9d popf
10e376: eb 1a jmp 10e392 <_Thread_queue_Extract_priority_helper+0xa2>
* a block of the requested size, then NULL is returned.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
* @return NULL if unsuccessful and a pointer to the block if successful
*/
10e378: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
10e37f: ff 75 ec pushl -0x14(%ebp)
10e382: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
10e383: 83 ec 0c sub $0xc,%esp
10e386: 8d 43 48 lea 0x48(%ebx),%eax
10e389: 50 push %eax
10e38a: e8 b1 d9 ff ff call 10bd40 <_Watchdog_Remove>
10e38f: 83 c4 10 add $0x10,%esp
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
10e392: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp)
10e399: 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
}
10e39c: 8d 65 f4 lea -0xc(%ebp),%esp
10e39f: 5b pop %ebx
10e3a0: 5e pop %esi
10e3a1: 5f pop %edi
10e3a2: c9 leave
10e3a3: e9 64 c7 ff ff jmp 10ab0c <_Thread_Clear_state>
10e3a8: 8d 65 f4 lea -0xc(%ebp),%esp
10e3ab: 5b pop %ebx
10e3ac: 5e pop %esi
10e3ad: 5f pop %edi
10e3ae: c9 leave
10e3af: c3 ret
0010e3b0 <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
10e3b0: 55 push %ebp
10e3b1: 89 e5 mov %esp,%ebp
10e3b3: 83 ec 08 sub $0x8,%esp
10e3b6: 8b 4d 08 mov 0x8(%ebp),%ecx
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
10e3b9: 8b 51 44 mov 0x44(%ecx),%edx
* If it is not satisfied, then it is "nothing happened" and
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
10e3bc: 8b 42 30 mov 0x30(%edx),%eax
10e3bf: 85 c0 test %eax,%eax
10e3c1: 74 1c je 10e3df <_Thread_queue_Process_timeout+0x2f>
10e3c3: 3b 0d 58 d8 11 00 cmp 0x11d858,%ecx
10e3c9: 75 14 jne 10e3df <_Thread_queue_Process_timeout+0x2f><== NEVER TAKEN
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
10e3cb: 83 f8 03 cmp $0x3,%eax
10e3ce: 74 23 je 10e3f3 <_Thread_queue_Process_timeout+0x43><== NEVER TAKEN
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
10e3d0: 8b 42 3c mov 0x3c(%edx),%eax
10e3d3: 89 41 34 mov %eax,0x34(%ecx)
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
10e3d6: c7 42 30 02 00 00 00 movl $0x2,0x30(%edx)
10e3dd: eb 14 jmp 10e3f3 <_Thread_queue_Process_timeout+0x43>
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
10e3df: 8b 42 3c mov 0x3c(%edx),%eax
10e3e2: 89 41 34 mov %eax,0x34(%ecx)
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
10e3e5: 50 push %eax
10e3e6: 50 push %eax
10e3e7: 51 push %ecx
10e3e8: ff 71 44 pushl 0x44(%ecx)
10e3eb: e8 d0 fe ff ff call 10e2c0 <_Thread_queue_Extract>
10e3f0: 83 c4 10 add $0x10,%esp
}
}
10e3f3: c9 leave
10e3f4: c3 ret
0010b58c <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10b58c: 55 push %ebp
10b58d: 89 e5 mov %esp,%ebp
10b58f: 57 push %edi
10b590: 56 push %esi
10b591: 53 push %ebx
10b592: 83 ec 1c sub $0x1c,%esp
10b595: 8b 5d 08 mov 0x8(%ebp),%ebx
10b598: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Just in case the thread really wasn't blocked on a thread queue
* when we get here.
*/
if ( !the_thread_queue )
10b59b: 85 db test %ebx,%ebx
10b59d: 74 36 je 10b5d5 <_Thread_queue_Requeue+0x49><== 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 ) {
10b59f: 83 7b 34 01 cmpl $0x1,0x34(%ebx)
10b5a3: 75 30 jne 10b5d5 <_Thread_queue_Requeue+0x49><== NEVER TAKEN
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
10b5a5: 9c pushf
10b5a6: fa cli
10b5a7: 5f pop %edi
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10b5a8: f7 46 10 e0 be 03 00 testl $0x3bee0,0x10(%esi)
10b5af: 74 22 je 10b5d3 <_Thread_queue_Requeue+0x47><== NEVER TAKEN
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
* This routine grows @a the_heap memory area using the size bytes which
10b5b1: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx)
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, TRUE );
10b5b8: 50 push %eax
10b5b9: 6a 01 push $0x1
10b5bb: 56 push %esi
10b5bc: 53 push %ebx
10b5bd: e8 2e 2d 00 00 call 10e2f0 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
10b5c2: 83 c4 0c add $0xc,%esp
10b5c5: 8d 45 f0 lea -0x10(%ebp),%eax
10b5c8: 50 push %eax
10b5c9: 56 push %esi
10b5ca: 53 push %ebx
10b5cb: e8 98 fd ff ff call 10b368 <_Thread_queue_Enqueue_priority>
10b5d0: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10b5d3: 57 push %edi
10b5d4: 9d popf
}
}
10b5d5: 8d 65 f4 lea -0xc(%ebp),%esp
10b5d8: 5b pop %ebx
10b5d9: 5e pop %esi
10b5da: 5f pop %edi
10b5db: c9 leave
10b5dc: c3 ret
0010b5e0 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored
)
{
10b5e0: 55 push %ebp
10b5e1: 89 e5 mov %esp,%ebp
10b5e3: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10b5e6: 8d 45 fc lea -0x4(%ebp),%eax
10b5e9: 50 push %eax
10b5ea: ff 75 08 pushl 0x8(%ebp)
10b5ed: e8 ba f8 ff ff call 10aeac <_Thread_Get>
switch ( location ) {
10b5f2: 83 c4 10 add $0x10,%esp
10b5f5: 83 7d fc 00 cmpl $0x0,-0x4(%ebp)
10b5f9: 75 17 jne 10b612 <_Thread_queue_Timeout+0x32><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
10b5fb: 83 ec 0c sub $0xc,%esp
10b5fe: 50 push %eax
10b5ff: e8 ac 2d 00 00 call 10e3b0 <_Thread_queue_Process_timeout>
10b604: a1 98 d7 11 00 mov 0x11d798,%eax
10b609: 48 dec %eax
10b60a: a3 98 d7 11 00 mov %eax,0x11d798
10b60f: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10b612: c9 leave
10b613: c3 ret
00113240 <_Timer_Server_body>:
* @param[in] ignored is the the task argument that is ignored
*/
Thread _Timer_Server_body(
uint32_t ignored
)
{
113240: 55 push %ebp
113241: 89 e5 mov %esp,%ebp
113243: 57 push %edi
113244: 56 push %esi
113245: 53 push %ebx
113246: 83 ec 1c sub $0x1c,%esp
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
113249: 8d 75 e8 lea -0x18(%ebp),%esi
11324c: 8d 45 ec lea -0x14(%ebp),%eax
11324f: 89 45 e0 mov %eax,-0x20(%ebp)
113252: 89 45 e8 mov %eax,-0x18(%ebp)
113255: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
11325c: 89 75 f0 mov %esi,-0x10(%ebp)
/*
* Initialize the "last time" markers to indicate the timer that
* the server was initiated.
*/
_Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot;
11325f: a1 88 42 13 00 mov 0x134288,%eax
113264: a3 bc 40 13 00 mov %eax,0x1340bc
_Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch;
113269: a1 c8 41 13 00 mov 0x1341c8,%eax
11326e: a3 b8 40 13 00 mov %eax,0x1340b8
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
113273: a1 38 41 13 00 mov 0x134138,%eax
113278: 40 inc %eax
113279: a3 38 41 13 00 mov %eax,0x134138
/*
* Insert the timers that were inserted before we got to run.
* This should be done with dispatching disabled.
*/
_Thread_Disable_dispatch();
_Timer_Server_process_insertions();
11327e: e8 6d ff ff ff call 1131f0 <_Timer_Server_process_insertions>
_Thread_Enable_dispatch();
113283: e8 30 25 00 00 call 1157b8 <_Thread_Enable_dispatch>
ticks = snapshot - _Timer_Server_ticks_last_time;
else
ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot;
_Timer_Server_ticks_last_time = snapshot;
_Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire );
113288: 89 f7 mov %esi,%edi
11328a: a1 38 41 13 00 mov 0x134138,%eax
11328f: 40 inc %eax
113290: a3 38 41 13 00 mov %eax,0x134138
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( _Timer_Server, STATES_DELAYING );
113295: 51 push %ecx
113296: 51 push %ecx
113297: 6a 08 push $0x8
113299: ff 35 bc 4a 13 00 pushl 0x134abc
11329f: e8 30 2e 00 00 call 1160d4 <_Thread_Set_state>
* to obtain the size of
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
1132a4: 8b 15 ac 40 13 00 mov 0x1340ac,%edx
_Timer_Server_reset_ticks_timer();
1132aa: 83 c4 10 add $0x10,%esp
1132ad: 81 fa b0 40 13 00 cmp $0x1340b0,%edx
1132b3: 74 1e je 1132d3 <_Timer_Server_body+0x93>
1132b5: a1 bc 4a 13 00 mov 0x134abc,%eax
Heap_Control *the_heap,
1132ba: 8b 52 10 mov 0x10(%edx),%edx
1132bd: 89 50 54 mov %edx,0x54(%eax)
void *starting_address,
size_t *size
1132c0: 52 push %edx
1132c1: 52 push %edx
1132c2: 83 c0 48 add $0x48,%eax
1132c5: 50 push %eax
1132c6: 68 18 42 13 00 push $0x134218
1132cb: e8 04 36 00 00 call 1168d4 <_Watchdog_Insert>
1132d0: 83 c4 10 add $0x10,%esp
* to obtain the size of
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
1132d3: a1 c0 40 13 00 mov 0x1340c0,%eax
_Timer_Server_reset_seconds_timer();
1132d8: 3d c4 40 13 00 cmp $0x1340c4,%eax
1132dd: 74 1c je 1132fb <_Timer_Server_body+0xbb>
* @return TRUE if successfully able to resize the block.
* FALSE if the block can't be resized in place.
*/
bool _Protected_heap_Resize_block(
Heap_Control *the_heap,
void *starting_address,
1132df: 8b 40 10 mov 0x10(%eax),%eax
1132e2: a3 e4 40 13 00 mov %eax,0x1340e4
size_t size
);
1132e7: 50 push %eax
1132e8: 50 push %eax
1132e9: 68 d8 40 13 00 push $0x1340d8
1132ee: 68 0c 42 13 00 push $0x13420c
1132f3: e8 dc 35 00 00 call 1168d4 <_Watchdog_Insert>
1132f8: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
1132fb: e8 b8 24 00 00 call 1157b8 <_Thread_Enable_dispatch>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
113300: a1 38 41 13 00 mov 0x134138,%eax
113305: 40 inc %eax
113306: a3 38 41 13 00 mov %eax,0x134138
/*
* At this point, at least one of the timers this task relies
* upon has fired. Stop them both while we process any outstanding
* timers. Before we block, we will restart them.
*/
_Timer_Server_stop_ticks_timer();
11330b: 83 ec 0c sub $0xc,%esp
11330e: a1 bc 4a 13 00 mov 0x134abc,%eax
113313: 83 c0 48 add $0x48,%eax
113316: 50 push %eax
113317: e8 d0 36 00 00 call 1169ec <_Watchdog_Remove>
_Timer_Server_stop_seconds_timer();
11331c: c7 04 24 d8 40 13 00 movl $0x1340d8,(%esp)
113323: e8 c4 36 00 00 call 1169ec <_Watchdog_Remove>
)
{
Watchdog_Interval snapshot;
Watchdog_Interval ticks;
snapshot = _Watchdog_Ticks_since_boot;
113328: 8b 15 88 42 13 00 mov 0x134288,%edx
if ( snapshot >= _Timer_Server_ticks_last_time )
11332e: a1 bc 40 13 00 mov 0x1340bc,%eax
113333: 83 c4 10 add $0x10,%esp
113336: 39 c2 cmp %eax,%edx
113338: 72 08 jb 113342 <_Timer_Server_body+0x102><== NEVER TAKEN
ticks = snapshot - _Timer_Server_ticks_last_time;
11333a: 89 d1 mov %edx,%ecx
11333c: 29 c1 sub %eax,%ecx
11333e: 89 c8 mov %ecx,%eax
113340: eb 04 jmp 113346 <_Timer_Server_body+0x106>
else
ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot;
113342: f7 d0 not %eax <== NOT EXECUTED
113344: 01 d0 add %edx,%eax <== NOT EXECUTED
_Timer_Server_ticks_last_time = snapshot;
113346: 89 15 bc 40 13 00 mov %edx,0x1340bc
_Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire );
11334c: 53 push %ebx
11334d: 57 push %edi
11334e: 50 push %eax
11334f: 68 ac 40 13 00 push $0x1340ac
113354: e8 eb 34 00 00 call 116844 <_Watchdog_Adjust_to_chain>
/*
* 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 _Timer_Seconds_chain to indicate this.
*/
snapshot = _TOD_Seconds_since_epoch;
113359: 8b 1d c8 41 13 00 mov 0x1341c8,%ebx
if ( snapshot > _Timer_Server_seconds_last_time ) {
11335f: a1 b8 40 13 00 mov 0x1340b8,%eax
113364: 83 c4 10 add $0x10,%esp
113367: 39 c3 cmp %eax,%ebx
113369: 76 13 jbe 11337e <_Timer_Server_body+0x13e>
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
ticks = snapshot - _Timer_Server_seconds_last_time;
_Watchdog_Adjust_to_chain( &_Timer_Seconds_chain, ticks, to_fire );
11336b: 51 push %ecx
11336c: 57 push %edi
11336d: 89 da mov %ebx,%edx
11336f: 29 c2 sub %eax,%edx
113371: 52 push %edx
113372: 68 c0 40 13 00 push $0x1340c0
113377: e8 c8 34 00 00 call 116844 <_Watchdog_Adjust_to_chain>
11337c: eb 12 jmp 113390 <_Timer_Server_body+0x150>
} else if ( snapshot < _Timer_Server_seconds_last_time ) {
11337e: 73 13 jae 113393 <_Timer_Server_body+0x153>
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
ticks = _Timer_Server_seconds_last_time - snapshot;
_Watchdog_Adjust( &_Timer_Seconds_chain, WATCHDOG_BACKWARD, ticks );
113380: 52 push %edx
113381: 29 d8 sub %ebx,%eax
113383: 50 push %eax
113384: 6a 01 push $0x1
113386: 68 c0 40 13 00 push $0x1340c0
11338b: e8 48 34 00 00 call 1167d8 <_Watchdog_Adjust>
113390: 83 c4 10 add $0x10,%esp
}
_Timer_Server_seconds_last_time = snapshot;
113393: 89 1d b8 40 13 00 mov %ebx,0x1340b8
_Timer_Server_process_seconds_chain( &to_fire );
/*
* Insert the timers that have been requested to be inserted.
*/
_Timer_Server_process_insertions();
113399: e8 52 fe ff ff call 1131f0 <_Timer_Server_process_insertions>
/*
* Enable dispatching to process the set that are ready "to fire."
*/
_Thread_Enable_dispatch();
11339e: e8 15 24 00 00 call 1157b8 <_Thread_Enable_dispatch>
*/
while (1) {
Watchdog_Control *watch;
ISR_Level level;
_ISR_Disable( level );
1133a3: 9c pushf
1133a4: fa cli
1133a5: 59 pop %ecx
* to obtain the size of
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
1133a6: 8b 55 e8 mov -0x18(%ebp),%edx
1133a9: 3b 55 e0 cmp -0x20(%ebp),%edx
1133ac: 74 0c je 1133ba <_Timer_Server_body+0x17a>
1133ae: 8b 02 mov (%edx),%eax
1133b0: 89 45 e8 mov %eax,-0x18(%ebp)
1133b3: 89 70 04 mov %esi,0x4(%eax)
watch = (Watchdog_Control *) _Chain_Get_unprotected( &to_fire );
if ( watch == NULL ) {
1133b6: 85 d2 test %edx,%edx
1133b8: 75 07 jne 1133c1 <_Timer_Server_body+0x181><== ALWAYS TAKEN
_ISR_Enable( level );
1133ba: 51 push %ecx
1133bb: 9d popf
1133bc: e9 c9 fe ff ff jmp 11328a <_Timer_Server_body+0x4a>
break;
}
watch->state = WATCHDOG_INACTIVE;
1133c1: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
_ISR_Enable( level );
1133c8: 51 push %ecx
1133c9: 9d popf
(*watch->routine)( watch->id, watch->user_data );
1133ca: 53 push %ebx
1133cb: 53 push %ebx
1133cc: ff 72 24 pushl 0x24(%edx)
1133cf: ff 72 20 pushl 0x20(%edx)
1133d2: ff 52 1c call *0x1c(%edx)
1133d5: 83 c4 10 add $0x10,%esp
1133d8: eb c9 jmp 1133a3 <_Timer_Server_body+0x163>
001131f0 <_Timer_Server_process_insertions>:
* onto one of the Timer Server chains.
*
* @note It is only to be called from the Timer Server task.
*/
static void _Timer_Server_process_insertions(void)
{
1131f0: 55 push %ebp
1131f1: 89 e5 mov %esp,%ebp
1131f3: 83 ec 08 sub $0x8,%esp
Timer_Control *the_timer;
while ( 1 ) {
the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted );
1131f6: 83 ec 0c sub $0xc,%esp
1131f9: 68 cc 40 13 00 push $0x1340cc
1131fe: e8 a5 08 00 00 call 113aa8 <_Chain_Get>
if ( the_timer == NULL )
113203: 83 c4 10 add $0x10,%esp
113206: 85 c0 test %eax,%eax
113208: 74 34 je 11323e <_Timer_Server_process_insertions+0x4e>
break;
if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
11320a: 8b 50 38 mov 0x38(%eax),%edx
11320d: 83 fa 01 cmp $0x1,%edx
113210: 75 0d jne 11321f <_Timer_Server_process_insertions+0x2f>
_Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker );
113212: 51 push %ecx
113213: 51 push %ecx
113214: 83 c0 10 add $0x10,%eax
113217: 50 push %eax
113218: 68 ac 40 13 00 push $0x1340ac
11321d: eb 10 jmp 11322f <_Timer_Server_process_insertions+0x3f>
} else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
11321f: 83 fa 03 cmp $0x3,%edx
113222: 75 13 jne 113237 <_Timer_Server_process_insertions+0x47><== NEVER TAKEN
_Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker );
113224: 52 push %edx
113225: 52 push %edx
113226: 83 c0 10 add $0x10,%eax
113229: 50 push %eax
11322a: 68 c0 40 13 00 push $0x1340c0
11322f: e8 a0 36 00 00 call 1168d4 <_Watchdog_Insert>
113234: 83 c4 10 add $0x10,%esp
}
/*
* Insert the timers that have been requested to be inserted.
*/
_Timer_Server_process_insertions();
113237: e8 b4 ff ff ff call 1131f0 <_Timer_Server_process_insertions>
11323c: eb b8 jmp 1131f6 <_Timer_Server_process_insertions+0x6>
}
}
11323e: c9 leave
11323f: c3 ret
0010cf04 <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
10cf04: 55 push %ebp
10cf05: 89 e5 mov %esp,%ebp
10cf07: 57 push %edi
10cf08: 56 push %esi
10cf09: 53 push %ebx
10cf0a: 83 ec 1c sub $0x1c,%esp
10cf0d: 8b 45 08 mov 0x8(%ebp),%eax
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
10cf10: 8b 18 mov (%eax),%ebx
left += lhs->tv_nsec;
10cf12: 8b 40 04 mov 0x4(%eax),%eax
10cf15: 89 45 e4 mov %eax,-0x1c(%ebp)
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
10cf18: b8 00 ca 9a 3b mov $0x3b9aca00,%eax
10cf1d: 8b 4d 0c mov 0xc(%ebp),%ecx
10cf20: f7 29 imull (%ecx)
10cf22: 89 c6 mov %eax,%esi
10cf24: 89 d7 mov %edx,%edi
right += rhs->tv_nsec;
10cf26: 8b 41 04 mov 0x4(%ecx),%eax
10cf29: 99 cltd
10cf2a: 01 c6 add %eax,%esi
10cf2c: 11 d7 adc %edx,%edi
if ( right == 0 ) {
10cf2e: 89 f8 mov %edi,%eax
10cf30: 09 f0 or %esi,%eax
10cf32: 75 14 jne 10cf48 <_Timespec_Divide+0x44> <== ALWAYS TAKEN
*ival_percentage = 0;
10cf34: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
10cf37: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED
*fval_percentage = 0;
10cf3d: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED
10cf40: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED
10cf46: eb 70 jmp 10cfb8 <_Timespec_Divide+0xb4> <== NOT EXECUTED
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
10cf48: b8 00 ca 9a 3b mov $0x3b9aca00,%eax
10cf4d: f7 eb imul %ebx
10cf4f: 89 45 e8 mov %eax,-0x18(%ebp)
10cf52: 89 55 ec mov %edx,-0x14(%ebp)
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
10cf55: 8b 45 e4 mov -0x1c(%ebp),%eax
10cf58: 99 cltd
10cf59: 01 45 e8 add %eax,-0x18(%ebp)
10cf5c: 11 55 ec adc %edx,-0x14(%ebp)
10cf5f: 69 5d ec a0 86 01 00 imul $0x186a0,-0x14(%ebp),%ebx
10cf66: b9 a0 86 01 00 mov $0x186a0,%ecx
10cf6b: 8b 45 e8 mov -0x18(%ebp),%eax
10cf6e: f7 e1 mul %ecx
10cf70: 89 45 d8 mov %eax,-0x28(%ebp)
10cf73: 01 da add %ebx,%edx
10cf75: 89 55 dc mov %edx,-0x24(%ebp)
10cf78: 57 push %edi
10cf79: 56 push %esi
10cf7a: ff 75 dc pushl -0x24(%ebp)
10cf7d: ff 75 d8 pushl -0x28(%ebp)
10cf80: e8 33 ae 00 00 call 117db8 <__udivdi3>
10cf85: 83 c4 10 add $0x10,%esp
10cf88: 89 c3 mov %eax,%ebx
10cf8a: 89 d6 mov %edx,%esi
*ival_percentage = answer / 1000;
10cf8c: 6a 00 push $0x0
10cf8e: 68 e8 03 00 00 push $0x3e8
10cf93: 52 push %edx
10cf94: 50 push %eax
10cf95: e8 1e ae 00 00 call 117db8 <__udivdi3>
10cf9a: 83 c4 10 add $0x10,%esp
10cf9d: 8b 4d 10 mov 0x10(%ebp),%ecx
10cfa0: 89 01 mov %eax,(%ecx)
*fval_percentage = answer % 1000;
10cfa2: 6a 00 push $0x0
10cfa4: 68 e8 03 00 00 push $0x3e8
10cfa9: 56 push %esi
10cfaa: 53 push %ebx
10cfab: e8 14 af 00 00 call 117ec4 <__umoddi3>
10cfb0: 83 c4 10 add $0x10,%esp
10cfb3: 8b 4d 14 mov 0x14(%ebp),%ecx
10cfb6: 89 01 mov %eax,(%ecx)
}
10cfb8: 8d 65 f4 lea -0xc(%ebp),%esp
10cfbb: 5b pop %ebx
10cfbc: 5e pop %esi
10cfbd: 5f pop %edi
10cfbe: c9 leave
10cfbf: c3 ret
0010d510 <_User_extensions_Remove_set>:
*/
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
10d510: 55 push %ebp
10d511: 89 e5 mov %esp,%ebp
10d513: 53 push %ebx
10d514: 83 ec 10 sub $0x10,%esp
10d517: 8b 5d 08 mov 0x8(%ebp),%ebx
_Chain_Extract( &the_extension->Node );
10d51a: 53 push %ebx
10d51b: e8 6c 23 00 00 call 10f88c <_Chain_Extract>
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
10d520: 83 c4 10 add $0x10,%esp
10d523: 83 7b 24 00 cmpl $0x0,0x24(%ebx)
10d527: 74 0f je 10d538 <_User_extensions_Remove_set+0x28><== ALWAYS TAKEN
_Chain_Extract( &the_extension->Switch.Node );
10d529: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED
10d52c: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
10d52f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10d532: c9 leave <== NOT EXECUTED
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
_Chain_Extract( &the_extension->Switch.Node );
10d533: e9 54 23 00 00 jmp 10f88c <_Chain_Extract> <== NOT EXECUTED
}
10d538: 8b 5d fc mov -0x4(%ebp),%ebx
10d53b: c9 leave
10d53c: c3 ret
0010d260 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
10d260: 55 push %ebp
10d261: 89 e5 mov %esp,%ebp
10d263: 57 push %edi
10d264: 56 push %esi
10d265: 53 push %ebx
10d266: 83 ec 0c sub $0xc,%esp
10d269: 8b 7d 08 mov 0x8(%ebp),%edi
10d26c: 8b 4d 0c mov 0xc(%ebp),%ecx
10d26f: 8b 75 10 mov 0x10(%ebp),%esi
ISR_Level level;
_ISR_Disable( level );
10d272: 9c pushf
10d273: fa cli
10d274: 5a pop %edx
* to obtain the size of
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
10d275: 8b 07 mov (%edi),%eax
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
10d277: 8d 5f 04 lea 0x4(%edi),%ebx
10d27a: 89 5d f0 mov %ebx,-0x10(%ebp)
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
10d27d: 39 d8 cmp %ebx,%eax
10d27f: 74 41 je 10d2c2 <_Watchdog_Adjust+0x62>
switch ( direction ) {
10d281: 85 c9 test %ecx,%ecx
10d283: 74 39 je 10d2be <_Watchdog_Adjust+0x5e>
10d285: 49 dec %ecx
10d286: 75 3a jne 10d2c2 <_Watchdog_Adjust+0x62> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
10d288: 01 70 10 add %esi,0x10(%eax)
10d28b: eb 35 jmp 10d2c2 <_Watchdog_Adjust+0x62>
10d28d: 8b 07 mov (%edi),%eax
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
10d28f: 8b 58 10 mov 0x10(%eax),%ebx
10d292: 39 de cmp %ebx,%esi
10d294: 73 07 jae 10d29d <_Watchdog_Adjust+0x3d>
_Watchdog_First( header )->delta_interval -= units;
10d296: 29 f3 sub %esi,%ebx
10d298: 89 58 10 mov %ebx,0x10(%eax)
10d29b: eb 25 jmp 10d2c2 <_Watchdog_Adjust+0x62>
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
10d29d: c7 40 10 01 00 00 00 movl $0x1,0x10(%eax)
_ISR_Enable( level );
10d2a4: 52 push %edx
10d2a5: 9d popf
_Watchdog_Tickle( header );
10d2a6: 83 ec 0c sub $0xc,%esp
10d2a9: 57 push %edi
10d2aa: e8 9d 01 00 00 call 10d44c <_Watchdog_Tickle>
_ISR_Disable( level );
10d2af: 9c pushf
10d2b0: fa cli
10d2b1: 5a pop %edx
if ( _Chain_Is_empty( header ) )
10d2b2: 83 c4 10 add $0x10,%esp
10d2b5: 8b 45 f0 mov -0x10(%ebp),%eax
10d2b8: 39 07 cmp %eax,(%edi)
10d2ba: 74 06 je 10d2c2 <_Watchdog_Adjust+0x62>
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
10d2bc: 29 de sub %ebx,%esi
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
10d2be: 85 f6 test %esi,%esi
10d2c0: 75 cb jne 10d28d <_Watchdog_Adjust+0x2d> <== ALWAYS TAKEN
}
break;
}
}
_ISR_Enable( level );
10d2c2: 52 push %edx
10d2c3: 9d popf
}
10d2c4: 8d 65 f4 lea -0xc(%ebp),%esp
10d2c7: 5b pop %ebx
10d2c8: 5e pop %esi
10d2c9: 5f pop %edi
10d2ca: c9 leave
10d2cb: c3 ret
00116844 <_Watchdog_Adjust_to_chain>:
Chain_Control *header,
Watchdog_Interval units_arg,
Chain_Control *to_fire
)
{
116844: 55 push %ebp
116845: 89 e5 mov %esp,%ebp
116847: 57 push %edi
116848: 56 push %esi
116849: 53 push %ebx
11684a: 83 ec 0c sub $0xc,%esp
11684d: 8b 75 08 mov 0x8(%ebp),%esi
116850: 8b 45 0c mov 0xc(%ebp),%eax
Watchdog_Interval units = units_arg;
ISR_Level level;
Chain_Node *node;
if ( !units ) {
116853: 85 c0 test %eax,%eax
116855: 74 74 je 1168cb <_Watchdog_Adjust_to_chain+0x87>
return;
}
_ISR_Disable( level );
116857: 9c pushf
116858: fa cli
116859: 8f 45 ec popl -0x14(%ebp)
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
11685c: 8d 7e 04 lea 0x4(%esi),%edi
if ( !_Chain_Is_empty( header ) ) {
11685f: 39 3e cmp %edi,(%esi)
116861: 74 64 je 1168c7 <_Watchdog_Adjust_to_chain+0x83>
116863: 8b 55 10 mov 0x10(%ebp),%edx
116866: 83 c2 04 add $0x4,%edx
116869: 89 55 f0 mov %edx,-0x10(%ebp)
11686c: 89 c3 mov %eax,%ebx
11686e: 8b 06 mov (%esi),%eax
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
116870: 8b 48 10 mov 0x10(%eax),%ecx
116873: 39 cb cmp %ecx,%ebx
116875: 73 07 jae 11687e <_Watchdog_Adjust_to_chain+0x3a>
_Watchdog_First( header )->delta_interval -= units;
116877: 29 d9 sub %ebx,%ecx
116879: 89 48 10 mov %ecx,0x10(%eax)
11687c: eb 49 jmp 1168c7 <_Watchdog_Adjust_to_chain+0x83>
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 0;
11687e: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
* to obtain the size of
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
116885: 8b 16 mov (%esi),%edx
116887: 39 fa cmp %edi,%edx
116889: 75 04 jne 11688f <_Watchdog_Adjust_to_chain+0x4b><== ALWAYS TAKEN
11688b: 31 d2 xor %edx,%edx <== NOT EXECUTED
11688d: eb 07 jmp 116896 <_Watchdog_Adjust_to_chain+0x52><== NOT EXECUTED
11688f: 8b 02 mov (%edx),%eax
116891: 89 06 mov %eax,(%esi)
116893: 89 70 04 mov %esi,0x4(%eax)
116896: 8b 45 f0 mov -0x10(%ebp),%eax
116899: 89 02 mov %eax,(%edx)
11689b: 8b 45 10 mov 0x10(%ebp),%eax
11689e: 8b 40 08 mov 0x8(%eax),%eax
1168a1: 89 45 e8 mov %eax,-0x18(%ebp)
1168a4: 8b 45 10 mov 0x10(%ebp),%eax
1168a7: 89 50 08 mov %edx,0x8(%eax)
1168aa: 8b 45 e8 mov -0x18(%ebp),%eax
1168ad: 89 10 mov %edx,(%eax)
1168af: 89 42 04 mov %eax,0x4(%edx)
do {
node = _Chain_Get_unprotected( header );
_Chain_Append_unprotected( to_fire, node );
_ISR_Flash( level );
1168b2: ff 75 ec pushl -0x14(%ebp)
1168b5: 9d popf
1168b6: fa cli
* to obtain the size of
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
1168b7: 8b 06 mov (%esi),%eax
} while ( !_Chain_Is_empty( header ) &&
_Watchdog_First( header )->delta_interval == 0 );
1168b9: 39 f8 cmp %edi,%eax
1168bb: 74 0a je 1168c7 <_Watchdog_Adjust_to_chain+0x83>
1168bd: 83 78 10 00 cmpl $0x0,0x10(%eax)
1168c1: 74 c2 je 116885 <_Watchdog_Adjust_to_chain+0x41>
return;
}
_ISR_Disable( level );
if ( !_Chain_Is_empty( header ) ) {
while ( units ) {
1168c3: 29 cb sub %ecx,%ebx
1168c5: 75 a7 jne 11686e <_Watchdog_Adjust_to_chain+0x2a><== NEVER TAKEN
break;
}
}
}
_ISR_Enable( level );
1168c7: ff 75 ec pushl -0x14(%ebp)
1168ca: 9d popf
}
1168cb: 83 c4 0c add $0xc,%esp
1168ce: 5b pop %ebx
1168cf: 5e pop %esi
1168d0: 5f pop %edi
1168d1: c9 leave
1168d2: c3 ret
0010bc28 <_Watchdog_Insert>:
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
10bc28: 55 push %ebp
10bc29: 89 e5 mov %esp,%ebp
10bc2b: 57 push %edi
10bc2c: 56 push %esi
10bc2d: 53 push %ebx
10bc2e: 83 ec 04 sub $0x4,%esp
10bc31: 8b 75 0c mov 0xc(%ebp),%esi
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
10bc34: 8b 3d 34 d8 11 00 mov 0x11d834,%edi
_ISR_Disable( level );
10bc3a: 9c pushf
10bc3b: fa cli
10bc3c: 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 ) {
10bc3f: 83 7e 08 00 cmpl $0x0,0x8(%esi)
10bc43: 74 09 je 10bc4e <_Watchdog_Insert+0x26> <== ALWAYS TAKEN
_ISR_Enable( level );
10bc45: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED
10bc48: 9d popf <== NOT EXECUTED
10bc49: e9 89 00 00 00 jmp 10bcd7 <_Watchdog_Insert+0xaf> <== NOT EXECUTED
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
10bc4e: c7 46 08 01 00 00 00 movl $0x1,0x8(%esi)
_Watchdog_Sync_count++;
10bc55: a1 e4 d8 11 00 mov 0x11d8e4,%eax
10bc5a: 40 inc %eax
10bc5b: a3 e4 d8 11 00 mov %eax,0x11d8e4
restart:
delta_interval = the_watchdog->initial;
10bc60: 8b 4e 0c mov 0xc(%esi),%ecx
* cache *header!!
*
* Till Straumann, 7/2003 (gcc-3.2.2 -O4 on powerpc)
*
*/
for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ;
10bc63: 8b 45 08 mov 0x8(%ebp),%eax
10bc66: 8b 18 mov (%eax),%ebx
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
10bc68: 85 c9 test %ecx,%ecx
10bc6a: 74 35 je 10bca1 <_Watchdog_Insert+0x79>
10bc6c: 83 3b 00 cmpl $0x0,(%ebx)
10bc6f: 74 30 je 10bca1 <_Watchdog_Insert+0x79>
break;
if ( delta_interval < after->delta_interval ) {
10bc71: 8b 53 10 mov 0x10(%ebx),%edx
10bc74: 39 d1 cmp %edx,%ecx
10bc76: 73 07 jae 10bc7f <_Watchdog_Insert+0x57>
after->delta_interval -= delta_interval;
10bc78: 29 ca sub %ecx,%edx
10bc7a: 89 53 10 mov %edx,0x10(%ebx)
10bc7d: eb 22 jmp 10bca1 <_Watchdog_Insert+0x79>
* used around this flash point allowed interrupts to execute
* which violated the design assumptions. The critical section
* mechanism used here WAS redesigned to address this.
*/
_ISR_Flash( level );
10bc7f: ff 75 f0 pushl -0x10(%ebp)
10bc82: 9d popf
10bc83: fa cli
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
10bc84: 83 7e 08 01 cmpl $0x1,0x8(%esi)
10bc88: 75 38 jne 10bcc2 <_Watchdog_Insert+0x9a> <== NEVER TAKEN
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
10bc8a: a1 54 d8 11 00 mov 0x11d854,%eax
10bc8f: 39 f8 cmp %edi,%eax
10bc91: 76 08 jbe 10bc9b <_Watchdog_Insert+0x73>
_Watchdog_Sync_level = insert_isr_nest_level;
10bc93: 89 3d 54 d8 11 00 mov %edi,0x11d854
10bc99: eb c5 jmp 10bc60 <_Watchdog_Insert+0x38>
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
10bc9b: 29 d1 sub %edx,%ecx
);
#ifdef __cplusplus
}
#endif
10bc9d: 8b 1b mov (%ebx),%ebx
10bc9f: eb c7 jmp 10bc68 <_Watchdog_Insert+0x40>
* @param[in] starting_address is the starting address of the memory
* to add to the heap
* @param[in] size is the size in bytes of the memory area to add
* @return a status indicating success or the reason for failure
*/
bool _Protected_heap_Extend(
10bca1: c7 46 08 02 00 00 00 movl $0x2,0x8(%esi)
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
10bca8: 89 4e 10 mov %ecx,0x10(%esi)
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
10bcab: 8b 43 04 mov 0x4(%ebx),%eax
10bcae: 89 46 04 mov %eax,0x4(%esi)
10bcb1: 8b 10 mov (%eax),%edx
10bcb3: 89 30 mov %esi,(%eax)
10bcb5: 89 16 mov %edx,(%esi)
10bcb7: 89 72 04 mov %esi,0x4(%edx)
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
10bcba: a1 e8 d8 11 00 mov 0x11d8e8,%eax
10bcbf: 89 46 14 mov %eax,0x14(%esi)
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
10bcc2: 89 3d 54 d8 11 00 mov %edi,0x11d854
_Watchdog_Sync_count--;
10bcc8: a1 e4 d8 11 00 mov 0x11d8e4,%eax
10bccd: 48 dec %eax
10bcce: a3 e4 d8 11 00 mov %eax,0x11d8e4
_ISR_Enable( level );
10bcd3: ff 75 f0 pushl -0x10(%ebp)
10bcd6: 9d popf
}
10bcd7: 58 pop %eax
10bcd8: 5b pop %ebx
10bcd9: 5e pop %esi
10bcda: 5f pop %edi
10bcdb: c9 leave
10bcdc: c3 ret
0010bd40 <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
10bd40: 55 push %ebp
10bd41: 89 e5 mov %esp,%ebp
10bd43: 56 push %esi
10bd44: 53 push %ebx
10bd45: 8b 4d 08 mov 0x8(%ebp),%ecx
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
10bd48: 9c pushf
10bd49: fa cli
10bd4a: 5e pop %esi
previous_state = the_watchdog->state;
10bd4b: 8b 59 08 mov 0x8(%ecx),%ebx
switch ( previous_state ) {
10bd4e: 83 fb 01 cmp $0x1,%ebx
10bd51: 74 09 je 10bd5c <_Watchdog_Remove+0x1c> <== NEVER TAKEN
10bd53: 72 41 jb 10bd96 <_Watchdog_Remove+0x56>
10bd55: 83 fb 03 cmp $0x3,%ebx
10bd58: 77 3c ja 10bd96 <_Watchdog_Remove+0x56> <== NEVER TAKEN
10bd5a: eb 09 jmp 10bd65 <_Watchdog_Remove+0x25>
/*
* 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;
10bd5c: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED
10bd63: eb 31 jmp 10bd96 <_Watchdog_Remove+0x56> <== NOT EXECUTED
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
10bd65: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx)
);
#ifdef __cplusplus
}
#endif
10bd6c: 8b 11 mov (%ecx),%edx
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
10bd6e: 83 3a 00 cmpl $0x0,(%edx)
10bd71: 74 06 je 10bd79 <_Watchdog_Remove+0x39>
next_watchdog->delta_interval += the_watchdog->delta_interval;
10bd73: 8b 41 10 mov 0x10(%ecx),%eax
10bd76: 01 42 10 add %eax,0x10(%edx)
if ( _Watchdog_Sync_count )
10bd79: a1 e4 d8 11 00 mov 0x11d8e4,%eax
10bd7e: 85 c0 test %eax,%eax
10bd80: 74 0a je 10bd8c <_Watchdog_Remove+0x4c> <== ALWAYS TAKEN
_Watchdog_Sync_level = _ISR_Nest_level;
10bd82: a1 34 d8 11 00 mov 0x11d834,%eax <== NOT EXECUTED
10bd87: a3 54 d8 11 00 mov %eax,0x11d854 <== NOT EXECUTED
10bd8c: 8b 11 mov (%ecx),%edx
10bd8e: 8b 41 04 mov 0x4(%ecx),%eax
10bd91: 89 42 04 mov %eax,0x4(%edx)
10bd94: 89 10 mov %edx,(%eax)
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
10bd96: a1 e8 d8 11 00 mov 0x11d8e8,%eax
10bd9b: 89 41 18 mov %eax,0x18(%ecx)
_ISR_Enable( level );
10bd9e: 56 push %esi
10bd9f: 9d popf
return( previous_state );
}
10bda0: 89 d8 mov %ebx,%eax
10bda2: 5b pop %ebx
10bda3: 5e pop %esi
10bda4: c9 leave
10bda5: c3 ret
0010bda8 <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
10bda8: 55 push %ebp
10bda9: 89 e5 mov %esp,%ebp
10bdab: 57 push %edi
10bdac: 56 push %esi
10bdad: 53 push %ebx
10bdae: 83 ec 0c sub $0xc,%esp
10bdb1: 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 );
10bdb4: 9c pushf
10bdb5: fa cli
10bdb6: 5e pop %esi
* to obtain the size of
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
10bdb7: 8b 17 mov (%edi),%edx
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
10bdb9: 8d 47 04 lea 0x4(%edi),%eax
10bdbc: 89 45 f0 mov %eax,-0x10(%ebp)
if ( _Chain_Is_empty( header ) )
10bdbf: 39 c2 cmp %eax,%edx
10bdc1: 74 44 je 10be07 <_Watchdog_Tickle+0x5f>
10bdc3: 89 d3 mov %edx,%ebx
* 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) {
10bdc5: 8b 42 10 mov 0x10(%edx),%eax
10bdc8: 85 c0 test %eax,%eax
10bdca: 74 08 je 10bdd4 <_Watchdog_Tickle+0x2c> <== NEVER TAKEN
the_watchdog->delta_interval--;
10bdcc: 48 dec %eax
10bdcd: 89 42 10 mov %eax,0x10(%edx)
if ( the_watchdog->delta_interval != 0 )
10bdd0: 85 c0 test %eax,%eax
10bdd2: 75 33 jne 10be07 <_Watchdog_Tickle+0x5f>
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
10bdd4: 83 ec 0c sub $0xc,%esp
10bdd7: 53 push %ebx
10bdd8: e8 63 ff ff ff call 10bd40 <_Watchdog_Remove>
_ISR_Enable( level );
10bddd: 56 push %esi
10bdde: 9d popf
switch( watchdog_state ) {
10bddf: 83 c4 10 add $0x10,%esp
10bde2: 83 f8 02 cmp $0x2,%eax
10bde5: 75 0e jne 10bdf5 <_Watchdog_Tickle+0x4d> <== NEVER TAKEN
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
10bde7: 50 push %eax
10bde8: 50 push %eax
10bde9: ff 73 24 pushl 0x24(%ebx)
10bdec: ff 73 20 pushl 0x20(%ebx)
10bdef: ff 53 1c call *0x1c(%ebx)
10bdf2: 83 c4 10 add $0x10,%esp
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
10bdf5: 9c pushf
10bdf6: fa cli
10bdf7: 5e pop %esi
10bdf8: 8b 07 mov (%edi),%eax
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
10bdfa: 3b 45 f0 cmp -0x10(%ebp),%eax
10bdfd: 74 08 je 10be07 <_Watchdog_Tickle+0x5f>
10bdff: 89 c3 mov %eax,%ebx
10be01: 83 78 10 00 cmpl $0x0,0x10(%eax)
10be05: eb cb jmp 10bdd2 <_Watchdog_Tickle+0x2a>
leave:
_ISR_Enable(level);
10be07: 56 push %esi
10be08: 9d popf
}
10be09: 8d 65 f4 lea -0xc(%ebp),%esp
10be0c: 5b pop %ebx
10be0d: 5e pop %esi
10be0e: 5f pop %edi
10be0f: c9 leave
10be10: c3 ret
0010be66 <_Workspace_Handler_initialization>:
*/
void _Workspace_Handler_initialization(
void *starting_address,
size_t size
)
{
10be66: 55 push %ebp
10be67: 89 e5 mov %esp,%ebp
10be69: 57 push %edi
10be6a: 83 ec 14 sub $0x14,%esp
10be6d: 8b 55 08 mov 0x8(%ebp),%edx
uint32_t memory_available;
if ( !starting_address || !_Addresses_Is_aligned( starting_address ) )
10be70: 85 d2 test %edx,%edx
10be72: 74 05 je 10be79 <_Workspace_Handler_initialization+0x13>
10be74: f6 c2 03 test $0x3,%dl
10be77: 74 05 je 10be7e <_Workspace_Handler_initialization+0x18><== ALWAYS TAKEN
_Internal_error_Occurred(
10be79: 51 push %ecx
10be7a: 6a 02 push $0x2
10be7c: eb 2e jmp 10beac <_Workspace_Handler_initialization+0x46>
INTERNAL_ERROR_CORE,
TRUE,
INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS
);
if ( _Configuration_Table->do_zero_of_workspace )
10be7e: a1 30 d8 11 00 mov 0x11d830,%eax
10be83: 80 78 28 00 cmpb $0x0,0x28(%eax)
10be87: 74 09 je 10be92 <_Workspace_Handler_initialization+0x2c><== ALWAYS TAKEN
memset( starting_address, 0, size );
10be89: 31 c0 xor %eax,%eax
10be8b: 89 d7 mov %edx,%edi <== NOT EXECUTED
10be8d: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
10be90: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED
memory_available = _Heap_Initialize(
10be92: 6a 04 push $0x4
10be94: ff 75 0c pushl 0xc(%ebp)
10be97: 52 push %edx
10be98: 68 bc d7 11 00 push $0x11d7bc
10be9d: e8 8a e1 ff ff call 10a02c <_Heap_Initialize>
starting_address,
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
10bea2: 83 c4 10 add $0x10,%esp
10bea5: 85 c0 test %eax,%eax
10bea7: 75 0c jne 10beb5 <_Workspace_Handler_initialization+0x4f><== ALWAYS TAKEN
_Internal_error_Occurred(
10bea9: 52 push %edx <== NOT EXECUTED
10beaa: 6a 03 push $0x3 <== NOT EXECUTED
10beac: 6a 01 push $0x1
10beae: 6a 00 push $0x0
10beb0: e8 3f e3 ff ff call 10a1f4 <_Internal_error_Occurred>
INTERNAL_ERROR_CORE,
TRUE,
INTERNAL_ERROR_TOO_LITTLE_WORKSPACE
);
}
10beb5: 8b 7d fc mov -0x4(%ebp),%edi
10beb8: c9 leave
10beb9: c3 ret
001062c2 <__assert>:
void __assert(
const char *file,
int line,
const char *failedexpr
)
{
1062c2: 55 push %ebp <== NOT EXECUTED
1062c3: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1062c5: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
__assert_func (file, line, NULL, failedexpr);
1062c8: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED
1062cb: 6a 00 push $0x0 <== NOT EXECUTED
1062cd: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
1062d0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
1062d3: e8 b0 ff ff ff call 106288 <__assert_func> <== NOT EXECUTED
1062d8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
1062db: c9 leave <== NOT EXECUTED
1062dc: c3 ret <== NOT EXECUTED
00106288 <__assert_func>:
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
106288: 55 push %ebp
106289: 89 e5 mov %esp,%ebp
10628b: 83 ec 08 sub $0x8,%esp
10628e: 8b 45 10 mov 0x10(%ebp),%eax
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
106291: ba bd 71 11 00 mov $0x1171bd,%edx
106296: 85 c0 test %eax,%eax
106298: 75 07 jne 1062a1 <__assert_func+0x19> <== ALWAYS TAKEN
10629a: ba 55 72 11 00 mov $0x117255,%edx <== NOT EXECUTED
10629f: 89 d0 mov %edx,%eax <== NOT EXECUTED
1062a1: 51 push %ecx
1062a2: 51 push %ecx
1062a3: 50 push %eax
1062a4: 52 push %edx
1062a5: ff 75 0c pushl 0xc(%ebp)
1062a8: ff 75 08 pushl 0x8(%ebp)
1062ab: ff 75 14 pushl 0x14(%ebp)
1062ae: 68 ca 71 11 00 push $0x1171ca
1062b3: e8 a6 0d 00 00 call 10705e <printk>
file,
line,
(func) ? ", function: " : "",
(func) ? func : ""
);
rtems_fatal_error_occurred(0);
1062b8: 83 c4 14 add $0x14,%esp
1062bb: 6a 00 push $0x0
1062bd: e8 d2 34 00 00 call 109794 <rtems_fatal_error_occurred>
0011573a <_exit>:
/*
* If the toolset uses init/fini sections, then we need to
* run the global destructors now.
*/
#if defined(__USE_INIT_FINI__)
_fini();
11573a: 55 push %ebp
11573b: 89 e5 mov %esp,%ebp
11573d: 83 ec 08 sub $0x8,%esp
115740: e8 28 07 00 00 call 115e6d <_fini>
* We need to do the exit processing on the global reentrancy structure.
* This has already been done on the per task reentrancy structure
* associated with this task.
*/
libc_wrapup();
115745: e8 8a ff ff ff call 1156d4 <libc_wrapup>
rtems_shutdown_executive(status);
11574a: 83 ec 0c sub $0xc,%esp
11574d: ff 75 08 pushl 0x8(%ebp)
115750: e8 d7 00 00 00 call 11582c <rtems_shutdown_executive>
115755: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
115758: eb fe jmp 115758 <_exit+0x1e> <== NOT EXECUTED
001071f6 <_fcntl_r>:
struct _reent *ptr,
int fd,
int cmd,
int arg
)
{
1071f6: 55 push %ebp <== NOT EXECUTED
1071f7: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1071f9: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
1071fc: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
return fcntl( fd, cmd, arg );
1071ff: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
107202: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED
107205: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED
107208: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED
}
10720b: c9 leave <== NOT EXECUTED
int fd,
int cmd,
int arg
)
{
return fcntl( fd, cmd, arg );
10720c: e9 9f fe ff ff jmp 1070b0 <fcntl> <== NOT EXECUTED
001180b6 <_getpid_r>:
#include <reent.h>
pid_t _getpid_r(
struct _reent *ptr
)
{
1180b6: 55 push %ebp <== NOT EXECUTED
1180b7: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return getpid();
}
1180b9: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
1180be: c9 leave <== NOT EXECUTED
1180bf: c3 ret <== NOT EXECUTED
0010cea4 <_gettimeofday>:
int _gettimeofday(
struct timeval *tp,
struct timezone *tzp
)
{
10cea4: 55 push %ebp <== NOT EXECUTED
10cea5: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return gettimeofday( tp, tzp );
}
10cea7: c9 leave <== NOT EXECUTED
int _gettimeofday(
struct timeval *tp,
struct timezone *tzp
)
{
return gettimeofday( tp, tzp );
10cea8: e9 a7 ff ff ff jmp 10ce54 <gettimeofday> <== NOT EXECUTED
00107b86 <_link_r>:
int _link_r(
struct _reent *ptr,
const char *existing,
const char *new
)
{
107b86: 55 push %ebp <== NOT EXECUTED
107b87: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107b89: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
return link( existing, new );
107b8c: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
107b8f: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED
107b92: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED
}
107b95: c9 leave <== NOT EXECUTED
struct _reent *ptr,
const char *existing,
const char *new
)
{
return link( existing, new );
107b96: e9 3d fe ff ff jmp 1079d8 <link> <== NOT EXECUTED
001157f8 <_realloc_r>:
void *_realloc_r(
struct _reent *ignored,
void *ptr,
size_t size
)
{
1157f8: 55 push %ebp <== NOT EXECUTED
1157f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1157fb: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
return realloc( ptr, size );
1157fe: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
115801: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED
115804: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED
}
115807: c9 leave <== NOT EXECUTED
struct _reent *ignored,
void *ptr,
size_t size
)
{
return realloc( ptr, size );
115808: e9 4f 00 00 00 jmp 11585c <realloc> <== NOT EXECUTED
0010841f <_stat_r>:
int _STAT_R_NAME(
struct _reent *ptr,
const char *path,
struct stat *buf
)
{
10841f: 55 push %ebp <== NOT EXECUTED
108420: 89 e5 mov %esp,%ebp <== NOT EXECUTED
108422: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
return _STAT_NAME( path, buf );
108425: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
108428: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED
10842b: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED
}
10842e: c9 leave <== NOT EXECUTED
struct _reent *ptr,
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
10842f: e9 4c ff ff ff jmp 108380 <stat> <== NOT EXECUTED
0010b218 <_unlink_r>:
int _unlink_r(
struct _reent *ptr,
const char *path
)
{
10b218: 55 push %ebp <== NOT EXECUTED
10b219: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return unlink( path );
10b21b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10b21e: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
10b221: c9 leave <== NOT EXECUTED
int _unlink_r(
struct _reent *ptr,
const char *path
)
{
return unlink( path );
10b222: e9 e9 fe ff ff jmp 10b110 <unlink> <== NOT EXECUTED
00108dc4 <adjtime>:
int adjtime(
struct timeval *delta,
struct timeval *olddelta
)
{
108dc4: 55 push %ebp
108dc5: 89 e5 mov %esp,%ebp
108dc7: 57 push %edi
108dc8: 56 push %esi
108dc9: 53 push %ebx
108dca: 83 ec 1c sub $0x1c,%esp
108dcd: 8b 5d 08 mov 0x8(%ebp),%ebx
108dd0: 8b 75 0c mov 0xc(%ebp),%esi
long adjustment;
/*
* Simple validations
*/
if ( !delta )
108dd3: 85 db test %ebx,%ebx
108dd5: 74 09 je 108de0 <adjtime+0x1c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND )
108dd7: 81 7b 04 3f 42 0f 00 cmpl $0xf423f,0x4(%ebx)
108dde: 76 13 jbe 108df3 <adjtime+0x2f>
rtems_set_errno_and_return_minus_one( EINVAL );
108de0: e8 47 6a 00 00 call 10f82c <__errno>
108de5: c7 00 16 00 00 00 movl $0x16,(%eax)
108deb: 83 c8 ff or $0xffffffff,%eax
108dee: e9 9e 00 00 00 jmp 108e91 <adjtime+0xcd>
if ( olddelta ) {
108df3: 85 f6 test %esi,%esi
108df5: 74 0d je 108e04 <adjtime+0x40>
olddelta->tv_sec = 0;
108df7: c7 06 00 00 00 00 movl $0x0,(%esi)
olddelta->tv_usec = 0;
108dfd: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi)
}
/* convert delta to microseconds */
adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND);
108e04: 69 03 40 42 0f 00 imul $0xf4240,(%ebx),%eax
adjustment += delta->tv_usec;
/* too small to account for */
if ( adjustment < _TOD_Microseconds_per_tick )
108e0a: 03 43 04 add 0x4(%ebx),%eax
108e0d: 3b 05 74 e7 11 00 cmp 0x11e774,%eax
108e13: 72 7a jb 108e8f <adjtime+0xcb>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
108e15: a1 d8 e5 11 00 mov 0x11e5d8,%eax
108e1a: 40 inc %eax
108e1b: a3 d8 e5 11 00 mov %eax,0x11e5d8
* This prevents context switches while we are adjusting the TOD
*/
_Thread_Disable_dispatch();
_TOD_Get( &ts );
108e20: 83 ec 0c sub $0xc,%esp
108e23: 8d 45 ec lea -0x14(%ebp),%eax
108e26: 50 push %eax
108e27: e8 30 17 00 00 call 10a55c <_TOD_Get>
ts.tv_sec += delta->tv_sec;
ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND;
108e2c: 69 7b 04 e8 03 00 00 imul $0x3e8,0x4(%ebx),%edi
108e33: 03 7d f0 add -0x10(%ebp),%edi
int adjtime(
struct timeval *delta,
struct timeval *olddelta
)
{
108e36: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx
108e3b: 89 f8 mov %edi,%eax
108e3d: 31 d2 xor %edx,%edx
108e3f: f7 f1 div %ecx
108e41: 89 45 dc mov %eax,-0x24(%ebp)
108e44: 89 c1 mov %eax,%ecx
108e46: 03 0b add (%ebx),%ecx
108e48: 03 4d ec add -0x14(%ebp),%ecx
108e4b: 69 c0 00 36 65 c4 imul $0xc4653600,%eax,%eax
108e51: 01 f8 add %edi,%eax
108e53: 83 c4 10 add $0x10,%esp
108e56: eb 05 jmp 108e5d <adjtime+0x99>
108e58: 05 00 ca 9a 3b add $0x3b9aca00,%eax
108e5d: 89 ca mov %ecx,%edx
108e5f: 49 dec %ecx
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) ) {
108e60: 3d 00 36 65 c4 cmp $0xc4653600,%eax
108e65: 76 f1 jbe 108e58 <adjtime+0x94>
108e67: 89 55 ec mov %edx,-0x14(%ebp)
108e6a: 89 45 f0 mov %eax,-0x10(%ebp)
ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND;
ts.tv_sec--;
}
_TOD_Set( &ts );
108e6d: 83 ec 0c sub $0xc,%esp
108e70: 8d 45 ec lea -0x14(%ebp),%eax
108e73: 50 push %eax
108e74: e8 73 17 00 00 call 10a5ec <_TOD_Set>
_Thread_Enable_dispatch();
108e79: e8 8a 26 00 00 call 10b508 <_Thread_Enable_dispatch>
/* set the user's output */
if ( olddelta )
108e7e: 83 c4 10 add $0x10,%esp
108e81: 85 f6 test %esi,%esi
108e83: 74 0a je 108e8f <adjtime+0xcb> <== NEVER TAKEN
*olddelta = *delta;
108e85: 8b 13 mov (%ebx),%edx
108e87: 8b 43 04 mov 0x4(%ebx),%eax
108e8a: 89 46 04 mov %eax,0x4(%esi)
108e8d: 89 16 mov %edx,(%esi)
108e8f: 31 c0 xor %eax,%eax
return 0;
}
108e91: 8d 65 f4 lea -0xc(%ebp),%esp
108e94: 5b pop %ebx
108e95: 5e pop %esi
108e96: 5f pop %edi
108e97: c9 leave
108e98: c3 ret
0010a708 <alarm>:
}
unsigned int alarm(
unsigned int seconds
)
{
10a708: 55 push %ebp
10a709: 89 e5 mov %esp,%ebp
10a70b: 53 push %ebx
10a70c: 83 ec 14 sub $0x14,%esp
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
10a70f: 83 3d 04 29 12 00 00 cmpl $0x0,0x122904
10a716: 75 2c jne 10a744 <alarm+0x3c>
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
10a718: c7 05 f0 28 12 00 00 movl $0x0,0x1228f0
10a71f: 00 00 00
* @param[in] the_heap is the heap to operate upon
10a722: c7 05 04 29 12 00 a7 movl $0x10a7a7,0x122904
10a729: a7 10 00
* @param[in] starting_address is the starting address of the memory for
10a72c: c7 05 08 29 12 00 00 movl $0x0,0x122908
10a733: 00 00 00
* the heap
10a736: c7 05 0c 29 12 00 00 movl $0x0,0x12290c
10a73d: 00 00 00
10a740: 31 db xor %ebx,%ebx
10a742: eb 43 jmp 10a787 <alarm+0x7f>
_Watchdog_Initialize( the_timer, _POSIX_signals_Alarm_TSR, 0, NULL );
} else {
switch ( _Watchdog_Remove( the_timer ) ) {
10a744: 83 ec 0c sub $0xc,%esp
10a747: 68 e8 28 12 00 push $0x1228e8
10a74c: e8 e3 41 00 00 call 10e934 <_Watchdog_Remove>
10a751: 83 c4 10 add $0x10,%esp
10a754: 83 e8 02 sub $0x2,%eax
10a757: 31 db xor %ebx,%ebx
10a759: 83 f8 01 cmp $0x1,%eax
10a75c: 77 29 ja 10a787 <alarm+0x7f> <== NEVER TAKEN
* The stop_time and start_time fields are snapshots of ticks since
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
remaining = the_timer->initial -
10a75e: 8b 0d 00 29 12 00 mov 0x122900,%ecx
10a764: 2b 0d fc 28 12 00 sub 0x1228fc,%ecx
10a76a: b8 40 42 0f 00 mov $0xf4240,%eax
10a76f: 31 d2 xor %edx,%edx
10a771: f7 35 64 2b 12 00 divl 0x122b64
10a777: 89 c3 mov %eax,%ebx
10a779: 89 c8 mov %ecx,%eax
10a77b: 31 d2 xor %edx,%edx
10a77d: f7 f3 div %ebx
10a77f: 8b 1d f4 28 12 00 mov 0x1228f4,%ebx
10a785: 29 c3 sub %eax,%ebx
* @return TRUE if successfully able to resize the block.
* FALSE if the block can't be resized in place.
*/
bool _Protected_heap_Resize_block(
Heap_Control *the_heap,
void *starting_address,
10a787: 8b 45 08 mov 0x8(%ebp),%eax
10a78a: a3 f4 28 12 00 mov %eax,0x1228f4
size_t size
);
10a78f: 50 push %eax
10a790: 50 push %eax
10a791: 68 e8 28 12 00 push $0x1228e8
10a796: 68 9c 2a 12 00 push $0x122a9c
10a79b: e8 7c 40 00 00 call 10e81c <_Watchdog_Insert>
}
_Watchdog_Insert_seconds( the_timer, seconds );
return remaining;
}
10a7a0: 89 d8 mov %ebx,%eax
10a7a2: 8b 5d fc mov -0x4(%ebp),%ebx
10a7a5: c9 leave
10a7a6: c3 ret
00108e24 <alphasort>:
*/
int
alphasort(
const void *d1,
const void *d2 )
{
108e24: 55 push %ebp <== NOT EXECUTED
108e25: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return(strcmp((*(struct dirent **)d1)->d_name,
108e27: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
108e2a: 8b 00 mov (%eax),%eax <== NOT EXECUTED
108e2c: 83 c0 0c add $0xc,%eax <== NOT EXECUTED
108e2f: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED
108e32: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
108e35: 8b 00 mov (%eax),%eax <== NOT EXECUTED
108e37: 83 c0 0c add $0xc,%eax <== NOT EXECUTED
108e3a: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
(*(struct dirent **)d2)->d_name));
}
108e3d: c9 leave <== NOT EXECUTED
int
alphasort(
const void *d1,
const void *d2 )
{
return(strcmp((*(struct dirent **)d1)->d_name,
108e3e: e9 55 a8 00 00 jmp 113698 <strcmp> <== NOT EXECUTED
0010ccd0 <calloc>:
)
{
register char *cptr;
int length;
MSBUMP(calloc_calls, 1);
10ccd0: 55 push %ebp
10ccd1: 89 e5 mov %esp,%ebp
10ccd3: 57 push %edi
10ccd4: 53 push %ebx
10ccd5: 83 ec 1c sub $0x1c,%esp
10ccd8: 8b 5d 0c mov 0xc(%ebp),%ebx
10ccdb: ff 05 bc d6 11 00 incl 0x11d6bc
length = nelem * elsize;
10cce1: 0f af 5d 08 imul 0x8(%ebp),%ebx
cptr = malloc( length );
10cce5: 53 push %ebx
10cce6: e8 89 99 ff ff call 106674 <malloc>
10cceb: 89 c2 mov %eax,%edx
if ( cptr )
10cced: 83 c4 10 add $0x10,%esp
10ccf0: 85 c0 test %eax,%eax
10ccf2: 74 08 je 10ccfc <calloc+0x2c> <== NEVER TAKEN
memset( cptr, '\0', length );
10ccf4: 31 c0 xor %eax,%eax
10ccf6: 89 d7 mov %edx,%edi
10ccf8: 89 d9 mov %ebx,%ecx
10ccfa: f3 aa rep stos %al,%es:(%edi)
MSBUMP(malloc_calls, -1); /* subtract off the malloc */
10ccfc: ff 0d ac d6 11 00 decl 0x11d6ac
return cptr;
}
10cd02: 89 d0 mov %edx,%eax
10cd04: 8d 65 f8 lea -0x8(%ebp),%esp
10cd07: 5b pop %ebx
10cd08: 5f pop %edi
10cd09: c9 leave
10cd0a: c3 ret
0010dc74 <chdir>:
#include <rtems/seterr.h>
int chdir(
const char *pathname
)
{
10dc74: 55 push %ebp
10dc75: 89 e5 mov %esp,%ebp
10dc77: 57 push %edi
10dc78: 56 push %esi
10dc79: 83 ec 10 sub $0x10,%esp
/*
* Get the node where we wish to go.
*/
result = rtems_filesystem_evaluate_path(
10dc7c: 6a 01 push $0x1
10dc7e: 8d 75 e8 lea -0x18(%ebp),%esi
10dc81: 56 push %esi
10dc82: 6a 01 push $0x1
10dc84: ff 75 08 pushl 0x8(%ebp)
10dc87: e8 26 8e ff ff call 106ab2 <rtems_filesystem_evaluate_path>
pathname, RTEMS_LIBIO_PERMS_SEARCH, &loc, true );
if ( result != 0 )
10dc8c: 83 c4 10 add $0x10,%esp
10dc8f: 83 ca ff or $0xffffffff,%edx
10dc92: 85 c0 test %eax,%eax
10dc94: 0f 85 8d 00 00 00 jne 10dd27 <chdir+0xb3>
/*
* Verify you can change directory into this node.
*/
if ( !loc.ops->node_type_h ) {
10dc9a: 8b 45 f0 mov -0x10(%ebp),%eax
10dc9d: 8b 50 10 mov 0x10(%eax),%edx
10dca0: 85 d2 test %edx,%edx
10dca2: 75 1d jne 10dcc1 <chdir+0x4d> <== ALWAYS TAKEN
rtems_filesystem_freenode( &loc );
10dca4: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
10dca7: 85 c0 test %eax,%eax <== NOT EXECUTED
10dca9: 74 09 je 10dcb4 <chdir+0x40> <== NOT EXECUTED
10dcab: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10dcae: 56 push %esi <== NOT EXECUTED
10dcaf: ff d0 call *%eax <== NOT EXECUTED
10dcb1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
10dcb4: e8 f7 2c 00 00 call 1109b0 <__errno> <== NOT EXECUTED
10dcb9: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10dcbf: eb 2e jmp 10dcef <chdir+0x7b> <== NOT EXECUTED
}
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
10dcc1: 83 ec 0c sub $0xc,%esp
10dcc4: 56 push %esi
10dcc5: ff d2 call *%edx
10dcc7: 83 c4 10 add $0x10,%esp
10dcca: 48 dec %eax
10dccb: 74 27 je 10dcf4 <chdir+0x80>
rtems_filesystem_freenode( &loc );
10dccd: 8b 45 f0 mov -0x10(%ebp),%eax
10dcd0: 85 c0 test %eax,%eax
10dcd2: 74 10 je 10dce4 <chdir+0x70> <== NEVER TAKEN
10dcd4: 8b 40 1c mov 0x1c(%eax),%eax
10dcd7: 85 c0 test %eax,%eax
10dcd9: 74 09 je 10dce4 <chdir+0x70> <== NEVER TAKEN
10dcdb: 83 ec 0c sub $0xc,%esp
10dcde: 56 push %esi
10dcdf: ff d0 call *%eax
10dce1: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( ENOTDIR );
10dce4: e8 c7 2c 00 00 call 1109b0 <__errno>
10dce9: c7 00 14 00 00 00 movl $0x14,(%eax)
10dcef: 83 ca ff or $0xffffffff,%edx
10dcf2: eb 33 jmp 10dd27 <chdir+0xb3>
}
rtems_filesystem_freenode( &rtems_filesystem_current );
10dcf4: a1 ac e3 11 00 mov 0x11e3ac,%eax
10dcf9: 8b 50 0c mov 0xc(%eax),%edx
10dcfc: 85 d2 test %edx,%edx
10dcfe: 74 13 je 10dd13 <chdir+0x9f> <== NEVER TAKEN
10dd00: 8b 52 1c mov 0x1c(%edx),%edx
10dd03: 85 d2 test %edx,%edx
10dd05: 74 0c je 10dd13 <chdir+0x9f> <== NEVER TAKEN
10dd07: 83 ec 0c sub $0xc,%esp
10dd0a: 83 c0 04 add $0x4,%eax
10dd0d: 50 push %eax
10dd0e: ff d2 call *%edx
10dd10: 83 c4 10 add $0x10,%esp
rtems_filesystem_current = loc;
10dd13: a1 ac e3 11 00 mov 0x11e3ac,%eax
10dd18: 8d 78 04 lea 0x4(%eax),%edi
10dd1b: 8d 75 e8 lea -0x18(%ebp),%esi
10dd1e: b9 04 00 00 00 mov $0x4,%ecx
10dd23: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10dd25: 31 d2 xor %edx,%edx
return 0;
}
10dd27: 89 d0 mov %edx,%eax
10dd29: 8d 65 f8 lea -0x8(%ebp),%esp
10dd2c: 5e pop %esi
10dd2d: 5f pop %edi
10dd2e: c9 leave
10dd2f: c3 ret
00108000 <chmod>:
int chmod(
const char *path,
mode_t mode
)
{
108000: 55 push %ebp
108001: 89 e5 mov %esp,%ebp
108003: 56 push %esi
108004: 53 push %ebx
108005: 83 ec 10 sub $0x10,%esp
int status;
rtems_filesystem_location_info_t loc;
int result;
status = rtems_filesystem_evaluate_path( path, 0, &loc, true );
108008: 6a 01 push $0x1
10800a: 8d 75 e8 lea -0x18(%ebp),%esi
10800d: 56 push %esi
10800e: 6a 00 push $0x0
108010: ff 75 08 pushl 0x8(%ebp)
108013: e8 92 01 00 00 call 1081aa <rtems_filesystem_evaluate_path>
if ( status != 0 )
108018: 83 c4 10 add $0x10,%esp
10801b: 83 cb ff or $0xffffffff,%ebx
10801e: 85 c0 test %eax,%eax
108020: 75 7d jne 10809f <chmod+0x9f>
return -1;
if ( !loc.handlers ){
108022: 8b 45 ec mov -0x14(%ebp),%eax
108025: 85 c0 test %eax,%eax
108027: 75 24 jne 10804d <chmod+0x4d> <== ALWAYS TAKEN
rtems_filesystem_freenode( &loc );
108029: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED
10802c: 85 c0 test %eax,%eax <== NOT EXECUTED
10802e: 74 10 je 108040 <chmod+0x40> <== NOT EXECUTED
108030: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
108033: 85 c0 test %eax,%eax <== NOT EXECUTED
108035: 74 09 je 108040 <chmod+0x40> <== NOT EXECUTED
108037: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10803a: 56 push %esi <== NOT EXECUTED
10803b: ff d0 call *%eax <== NOT EXECUTED
10803d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
108040: e8 2b a6 00 00 call 112670 <__errno> <== NOT EXECUTED
108045: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
10804b: eb 29 jmp 108076 <chmod+0x76> <== NOT EXECUTED
}
if ( !loc.handlers->fchmod_h ){
10804d: 8b 40 1c mov 0x1c(%eax),%eax
108050: 85 c0 test %eax,%eax
108052: 75 27 jne 10807b <chmod+0x7b> <== ALWAYS TAKEN
rtems_filesystem_freenode( &loc );
108054: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED
108057: 85 c0 test %eax,%eax <== NOT EXECUTED
108059: 74 10 je 10806b <chmod+0x6b> <== NOT EXECUTED
10805b: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
10805e: 85 c0 test %eax,%eax <== NOT EXECUTED
108060: 74 09 je 10806b <chmod+0x6b> <== NOT EXECUTED
108062: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108065: 56 push %esi <== NOT EXECUTED
108066: ff d0 call *%eax <== NOT EXECUTED
108068: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
10806b: e8 00 a6 00 00 call 112670 <__errno> <== NOT EXECUTED
108070: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
108076: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED
108079: eb 24 jmp 10809f <chmod+0x9f> <== NOT EXECUTED
}
result = (*loc.handlers->fchmod_h)( &loc, mode );
10807b: 52 push %edx
10807c: 52 push %edx
10807d: ff 75 0c pushl 0xc(%ebp)
108080: 56 push %esi
108081: ff d0 call *%eax
108083: 89 c3 mov %eax,%ebx
rtems_filesystem_freenode( &loc );
108085: 8b 45 f0 mov -0x10(%ebp),%eax
108088: 83 c4 10 add $0x10,%esp
10808b: 85 c0 test %eax,%eax
10808d: 74 10 je 10809f <chmod+0x9f> <== NEVER TAKEN
10808f: 8b 40 1c mov 0x1c(%eax),%eax
108092: 85 c0 test %eax,%eax
108094: 74 09 je 10809f <chmod+0x9f> <== NEVER TAKEN
108096: 83 ec 0c sub $0xc,%esp
108099: 56 push %esi
10809a: ff d0 call *%eax
10809c: 83 c4 10 add $0x10,%esp
return result;
}
10809f: 89 d8 mov %ebx,%eax
1080a1: 8d 65 f8 lea -0x8(%ebp),%esp
1080a4: 5b pop %ebx
1080a5: 5e pop %esi
1080a6: c9 leave
1080a7: c3 ret
001080a8 <chown>:
int chown(
const char *path,
uid_t owner,
gid_t group
)
{
1080a8: 55 push %ebp
1080a9: 89 e5 mov %esp,%ebp
1080ab: 57 push %edi
1080ac: 56 push %esi
1080ad: 53 push %ebx
1080ae: 83 ec 1c sub $0x1c,%esp
1080b1: 8b 45 0c mov 0xc(%ebp),%eax
1080b4: 66 89 45 e2 mov %ax,-0x1e(%ebp)
1080b8: 8b 7d 10 mov 0x10(%ebp),%edi
rtems_filesystem_location_info_t loc;
int result;
if ( rtems_filesystem_evaluate_path( path, 0x00, &loc, true ) )
1080bb: 6a 01 push $0x1
1080bd: 8d 75 e4 lea -0x1c(%ebp),%esi
1080c0: 56 push %esi
1080c1: 6a 00 push $0x0
1080c3: ff 75 08 pushl 0x8(%ebp)
1080c6: e8 df 00 00 00 call 1081aa <rtems_filesystem_evaluate_path>
1080cb: 83 c4 10 add $0x10,%esp
1080ce: 83 cb ff or $0xffffffff,%ebx
1080d1: 85 c0 test %eax,%eax
1080d3: 75 53 jne 108128 <chown+0x80>
return -1;
if ( !loc.ops->chown_h ) {
1080d5: 8b 45 ec mov -0x14(%ebp),%eax
1080d8: 8b 50 18 mov 0x18(%eax),%edx
1080db: 85 d2 test %edx,%edx
1080dd: 75 20 jne 1080ff <chown+0x57> <== ALWAYS TAKEN
rtems_filesystem_freenode( &loc );
1080df: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
1080e2: 85 c0 test %eax,%eax <== NOT EXECUTED
1080e4: 74 09 je 1080ef <chown+0x47> <== NOT EXECUTED
1080e6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1080e9: 56 push %esi <== NOT EXECUTED
1080ea: ff d0 call *%eax <== NOT EXECUTED
1080ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
1080ef: e8 7c a5 00 00 call 112670 <__errno> <== NOT EXECUTED
1080f4: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
1080fa: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED
1080fd: eb 29 jmp 108128 <chown+0x80> <== NOT EXECUTED
}
result = (*loc.ops->chown_h)( &loc, owner, group );
1080ff: 50 push %eax
108100: 0f b7 c7 movzwl %di,%eax
108103: 50 push %eax
108104: 0f b7 45 e2 movzwl -0x1e(%ebp),%eax
108108: 50 push %eax
108109: 56 push %esi
10810a: ff d2 call *%edx
10810c: 89 c3 mov %eax,%ebx
rtems_filesystem_freenode( &loc );
10810e: 8b 45 ec mov -0x14(%ebp),%eax
108111: 83 c4 10 add $0x10,%esp
108114: 85 c0 test %eax,%eax
108116: 74 10 je 108128 <chown+0x80> <== NEVER TAKEN
108118: 8b 40 1c mov 0x1c(%eax),%eax
10811b: 85 c0 test %eax,%eax
10811d: 74 09 je 108128 <chown+0x80> <== NEVER TAKEN
10811f: 83 ec 0c sub $0xc,%esp
108122: 56 push %esi
108123: ff d0 call *%eax
108125: 83 c4 10 add $0x10,%esp
return result;
}
108128: 89 d8 mov %ebx,%eax
10812a: 8d 65 f4 lea -0xc(%ebp),%esp
10812d: 5b pop %ebx
10812e: 5e pop %esi
10812f: 5f pop %edi
108130: c9 leave
108131: c3 ret
00106908 <chroot>:
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
106908: 55 push %ebp
106909: 89 e5 mov %esp,%ebp
10690b: 57 push %edi
10690c: 56 push %esi
10690d: 53 push %ebx
10690e: 83 ec 1c sub $0x1c,%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) {
106911: 81 3d ac e3 11 00 00 cmpl $0x120a00,0x11e3ac
106918: 0a 12 00
10691b: 75 1e jne 10693b <chroot+0x33> <== NEVER TAKEN
rtems_libio_set_private_env(); /* try to set a new private env*/
10691d: e8 47 12 00 00 call 107b69 <rtems_libio_set_private_env>
if (rtems_current_user_env == &rtems_global_user_env) /* not ok */
106922: 81 3d ac e3 11 00 00 cmpl $0x120a00,0x11e3ac
106929: 0a 12 00
10692c: 75 0d jne 10693b <chroot+0x33> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
10692e: e8 7d a0 00 00 call 1109b0 <__errno> <== NOT EXECUTED
106933: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
106939: eb 22 jmp 10695d <chroot+0x55> <== NOT EXECUTED
}
result = chdir(pathname);
10693b: 83 ec 0c sub $0xc,%esp
10693e: ff 75 08 pushl 0x8(%ebp)
106941: e8 2e 73 00 00 call 10dc74 <chdir>
if (result) {
106946: 83 c4 10 add $0x10,%esp
106949: 85 c0 test %eax,%eax
10694b: 74 15 je 106962 <chroot+0x5a> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( errno );
10694d: e8 5e a0 00 00 call 1109b0 <__errno> <== NOT EXECUTED
106952: 89 c3 mov %eax,%ebx <== NOT EXECUTED
106954: e8 57 a0 00 00 call 1109b0 <__errno> <== NOT EXECUTED
106959: 8b 00 mov (%eax),%eax <== NOT EXECUTED
10695b: 89 03 mov %eax,(%ebx) <== NOT EXECUTED
10695d: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106960: eb 4c jmp 1069ae <chroot+0xa6> <== NOT EXECUTED
}
/* clone the new root location */
if (rtems_filesystem_evaluate_path(".", 0, &loc, 0)) {
106962: 6a 00 push $0x0
106964: 8d 45 e4 lea -0x1c(%ebp),%eax
106967: 50 push %eax
106968: 6a 00 push $0x0
10696a: 68 f9 9c 11 00 push $0x119cf9
10696f: e8 3e 01 00 00 call 106ab2 <rtems_filesystem_evaluate_path>
106974: 83 c4 10 add $0x10,%esp
106977: 85 c0 test %eax,%eax
106979: 75 d2 jne 10694d <chroot+0x45> <== 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);
10697b: a1 ac e3 11 00 mov 0x11e3ac,%eax
106980: 8b 50 1c mov 0x1c(%eax),%edx
106983: 85 d2 test %edx,%edx
106985: 74 13 je 10699a <chroot+0x92> <== NEVER TAKEN
106987: 8b 52 1c mov 0x1c(%edx),%edx
10698a: 85 d2 test %edx,%edx
10698c: 74 0c je 10699a <chroot+0x92> <== NEVER TAKEN
10698e: 83 ec 0c sub $0xc,%esp
106991: 83 c0 14 add $0x14,%eax
106994: 50 push %eax
106995: ff d2 call *%edx
106997: 83 c4 10 add $0x10,%esp
rtems_filesystem_root = loc;
10699a: a1 ac e3 11 00 mov 0x11e3ac,%eax
10699f: 8d 78 14 lea 0x14(%eax),%edi
1069a2: 8d 75 e4 lea -0x1c(%ebp),%esi
1069a5: b9 04 00 00 00 mov $0x4,%ecx
1069aa: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
1069ac: 31 c0 xor %eax,%eax
return 0;
}
1069ae: 8d 65 f4 lea -0xc(%ebp),%esp
1069b1: 5b pop %ebx
1069b2: 5e pop %esi
1069b3: 5f pop %edi
1069b4: c9 leave
1069b5: c3 ret
0010985c <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
10985c: 55 push %ebp
10985d: 89 e5 mov %esp,%ebp
10985f: 83 ec 08 sub $0x8,%esp
109862: 8b 45 08 mov 0x8(%ebp),%eax
109865: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
109868: 85 d2 test %edx,%edx
10986a: 74 3c je 1098a8 <clock_gettime+0x4c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME )
10986c: 83 f8 01 cmp $0x1,%eax
10986f: 75 0b jne 10987c <clock_gettime+0x20>
_TOD_Get(tp);
109871: 83 ec 0c sub $0xc,%esp
109874: 52 push %edx
109875: e8 06 20 00 00 call 10b880 <_TOD_Get>
10987a: eb 13 jmp 10988f <clock_gettime+0x33>
#ifdef CLOCK_MONOTONIC
else if ( clock_id == CLOCK_MONOTONIC )
10987c: 83 f8 04 cmp $0x4,%eax
10987f: 74 05 je 109886 <clock_gettime+0x2a> <== NEVER TAKEN
_TOD_Get_uptime(tp);
#endif
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
109881: 83 f8 02 cmp $0x2,%eax
109884: 75 10 jne 109896 <clock_gettime+0x3a>
_TOD_Get_uptime(tp);
109886: 83 ec 0c sub $0xc,%esp
109889: 52 push %edx
10988a: e8 45 20 00 00 call 10b8d4 <_TOD_Get_uptime>
10988f: 31 c0 xor %eax,%eax
109891: 83 c4 10 add $0x10,%esp
109894: eb 20 jmp 1098b6 <clock_gettime+0x5a>
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
109896: 83 f8 03 cmp $0x3,%eax
109899: 75 0d jne 1098a8 <clock_gettime+0x4c>
rtems_set_errno_and_return_minus_one( ENOSYS );
10989b: e8 60 6f 00 00 call 110800 <__errno>
1098a0: c7 00 58 00 00 00 movl $0x58,(%eax)
1098a6: eb 0b jmp 1098b3 <clock_gettime+0x57>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
1098a8: e8 53 6f 00 00 call 110800 <__errno>
1098ad: c7 00 16 00 00 00 movl $0x16,(%eax)
1098b3: 83 c8 ff or $0xffffffff,%eax
return 0;
}
1098b6: c9 leave
1098b7: c3 ret
001098b8 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
1098b8: 55 push %ebp
1098b9: 89 e5 mov %esp,%ebp
1098bb: 83 ec 08 sub $0x8,%esp
1098be: 8b 45 08 mov 0x8(%ebp),%eax
1098c1: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
1098c4: 85 d2 test %edx,%edx
1098c6: 74 44 je 10990c <clock_settime+0x54> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
1098c8: 83 f8 01 cmp $0x1,%eax
1098cb: 75 28 jne 1098f5 <clock_settime+0x3d>
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
1098cd: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx)
1098d3: 76 37 jbe 10990c <clock_settime+0x54>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
1098d5: a1 f0 10 12 00 mov 0x1210f0,%eax
1098da: 40 inc %eax
1098db: a3 f0 10 12 00 mov %eax,0x1210f0
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
1098e0: 83 ec 0c sub $0xc,%esp
1098e3: 52 push %edx
1098e4: e8 7b 20 00 00 call 10b964 <_TOD_Set>
_Thread_Enable_dispatch();
1098e9: e8 92 2f 00 00 call 10c880 <_Thread_Enable_dispatch>
1098ee: 31 c0 xor %eax,%eax
1098f0: 83 c4 10 add $0x10,%esp
1098f3: eb 25 jmp 10991a <clock_settime+0x62>
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
1098f5: 83 f8 02 cmp $0x2,%eax
1098f8: 74 05 je 1098ff <clock_settime+0x47>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
1098fa: 83 f8 03 cmp $0x3,%eax
1098fd: 75 0d jne 10990c <clock_settime+0x54>
rtems_set_errno_and_return_minus_one( ENOSYS );
1098ff: e8 fc 6e 00 00 call 110800 <__errno>
109904: c7 00 58 00 00 00 movl $0x58,(%eax)
10990a: eb 0b jmp 109917 <clock_settime+0x5f>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
10990c: e8 ef 6e 00 00 call 110800 <__errno>
109911: c7 00 16 00 00 00 movl $0x16,(%eax)
109917: 83 c8 ff or $0xffffffff,%eax
return 0;
}
10991a: c9 leave
10991b: c3 ret
0010cd0c <close>:
#include <rtems/libio_.h>
int close(
int fd
)
{
10cd0c: 55 push %ebp
10cd0d: 89 e5 mov %esp,%ebp
10cd0f: 56 push %esi
10cd10: 53 push %ebx
10cd11: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_t *iop;
rtems_status_code rc;
rtems_libio_check_fd(fd);
10cd14: 3b 05 d8 92 11 00 cmp 0x1192d8,%eax
10cd1a: 73 0f jae 10cd2b <close+0x1f>
iop = rtems_libio_iop(fd);
10cd1c: 6b d8 34 imul $0x34,%eax,%ebx
10cd1f: 03 1d 38 d6 11 00 add 0x11d638,%ebx
rtems_libio_check_is_open(iop);
10cd25: f6 43 0d 01 testb $0x1,0xd(%ebx)
10cd29: 75 10 jne 10cd3b <close+0x2f>
10cd2b: e8 f8 23 00 00 call 10f128 <__errno>
10cd30: c7 00 09 00 00 00 movl $0x9,(%eax)
10cd36: 83 c8 ff or $0xffffffff,%eax
10cd39: eb 3f jmp 10cd7a <close+0x6e>
rc = RTEMS_SUCCESSFUL;
if ( iop->handlers->close_h )
10cd3b: 8b 43 30 mov 0x30(%ebx),%eax
10cd3e: 8b 40 04 mov 0x4(%eax),%eax
10cd41: 31 f6 xor %esi,%esi
10cd43: 85 c0 test %eax,%eax
10cd45: 74 0b je 10cd52 <close+0x46> <== NEVER TAKEN
rc = (*iop->handlers->close_h)( iop );
10cd47: 83 ec 0c sub $0xc,%esp
10cd4a: 53 push %ebx
10cd4b: ff d0 call *%eax
10cd4d: 89 c6 mov %eax,%esi
10cd4f: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( &iop->pathinfo );
10cd52: 8b 43 18 mov 0x18(%ebx),%eax
10cd55: 85 c0 test %eax,%eax
10cd57: 74 13 je 10cd6c <close+0x60> <== NEVER TAKEN
10cd59: 8b 50 1c mov 0x1c(%eax),%edx
10cd5c: 85 d2 test %edx,%edx
10cd5e: 74 0c je 10cd6c <close+0x60>
10cd60: 83 ec 0c sub $0xc,%esp
10cd63: 8d 43 10 lea 0x10(%ebx),%eax
10cd66: 50 push %eax
10cd67: ff d2 call *%edx
10cd69: 83 c4 10 add $0x10,%esp
rtems_libio_free( iop );
10cd6c: 83 ec 0c sub $0xc,%esp
10cd6f: 53 push %ebx
10cd70: e8 47 02 00 00 call 10cfbc <rtems_libio_free>
return rc;
10cd75: 89 f0 mov %esi,%eax
10cd77: 83 c4 10 add $0x10,%esp
}
10cd7a: 8d 65 f8 lea -0x8(%ebp),%esp
10cd7d: 5b pop %ebx
10cd7e: 5e pop %esi
10cd7f: c9 leave
10cd80: c3 ret
001073e4 <closedir>:
* close a directory.
*/
int
closedir(
DIR *dirp )
{
1073e4: 55 push %ebp
1073e5: 89 e5 mov %esp,%ebp
1073e7: 56 push %esi
1073e8: 53 push %ebx
1073e9: 8b 75 08 mov 0x8(%ebp),%esi
int fd;
if ( !dirp )
1073ec: 85 f6 test %esi,%esi
1073ee: 75 15 jne 107405 <closedir+0x21> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EBADF );
1073f0: e8 bb a1 00 00 call 1115b0 <__errno> <== NOT EXECUTED
1073f5: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
dirp->dd_fd = -1;
dirp->dd_loc = 0;
(void)free((void *)dirp->dd_buf);
(void)free((void *)dirp);
return(close(fd));
}
1073fb: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
1073fe: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
107401: 5b pop %ebx <== NOT EXECUTED
107402: 5e pop %esi <== NOT EXECUTED
107403: c9 leave <== NOT EXECUTED
107404: c3 ret <== NOT EXECUTED
int fd;
if ( !dirp )
rtems_set_errno_and_return_minus_one( EBADF );
fd = dirp->dd_fd;
107405: 8b 1e mov (%esi),%ebx
dirp->dd_fd = -1;
107407: c7 06 ff ff ff ff movl $0xffffffff,(%esi)
dirp->dd_loc = 0;
10740d: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi)
(void)free((void *)dirp->dd_buf);
107414: 83 ec 0c sub $0xc,%esp
107417: ff 76 0c pushl 0xc(%esi)
10741a: e8 35 02 00 00 call 107654 <free>
(void)free((void *)dirp);
10741f: 89 34 24 mov %esi,(%esp)
107422: e8 2d 02 00 00 call 107654 <free>
return(close(fd));
107427: 83 c4 10 add $0x10,%esp
10742a: 89 5d 08 mov %ebx,0x8(%ebp)
}
10742d: 8d 65 f8 lea -0x8(%ebp),%esp
107430: 5b pop %ebx
107431: 5e pop %esi
107432: c9 leave
fd = dirp->dd_fd;
dirp->dd_fd = -1;
dirp->dd_loc = 0;
(void)free((void *)dirp->dd_buf);
(void)free((void *)dirp);
return(close(fd));
107433: e9 00 00 00 00 jmp 107438 <close>
0010e6f2 <device_close>:
*/
int device_close(
rtems_libio_t *iop
)
{
10e6f2: 55 push %ebp
10e6f3: 89 e5 mov %esp,%ebp
10e6f5: 83 ec 1c sub $0x1c,%esp
10e6f8: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_open_close_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
10e6fb: 8b 50 2c mov 0x2c(%eax),%edx
args.iop = iop;
10e6fe: 89 45 f4 mov %eax,-0xc(%ebp)
args.flags = 0;
10e701: c7 45 f8 00 00 00 00 movl $0x0,-0x8(%ebp)
args.mode = 0;
10e708: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
status = rtems_io_close(
10e70f: 8d 45 f4 lea -0xc(%ebp),%eax
10e712: 50 push %eax
10e713: ff 72 54 pushl 0x54(%edx)
10e716: ff 72 50 pushl 0x50(%edx)
10e719: e8 de 06 00 00 call 10edfc <rtems_io_close>
10e71e: 89 c2 mov %eax,%edx
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status ) {
10e720: 83 c4 10 add $0x10,%esp
10e723: 31 c0 xor %eax,%eax
10e725: 85 d2 test %edx,%edx
10e727: 74 07 je 10e730 <device_close+0x3e> <== ALWAYS TAKEN
return rtems_deviceio_errno(status);
10e729: 89 d0 mov %edx,%eax <== NOT EXECUTED
10e72b: e8 bb fe ff ff call 10e5eb <rtems_deviceio_errno> <== NOT EXECUTED
}
return 0;
}
10e730: c9 leave
10e731: c3 ret
0010e615 <device_ioctl>:
int device_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
10e615: 55 push %ebp <== NOT EXECUTED
10e616: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10e618: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED
10e61b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
rtems_libio_ioctl_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
args.iop = iop;
10e61e: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED
args.command = command;
10e621: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10e624: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED
args.buffer = buffer;
10e627: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
10e62a: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED
the_jnode = iop->file_info;
10e62d: 8b 52 2c mov 0x2c(%edx),%edx <== NOT EXECUTED
status = rtems_io_control(
10e630: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED
10e633: 50 push %eax <== NOT EXECUTED
10e634: ff 72 54 pushl 0x54(%edx) <== NOT EXECUTED
10e637: ff 72 50 pushl 0x50(%edx) <== NOT EXECUTED
10e63a: e8 fd 07 00 00 call 10ee3c <rtems_io_control> <== NOT EXECUTED
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
10e63f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10e642: 85 c0 test %eax,%eax <== NOT EXECUTED
10e644: 74 07 je 10e64d <device_ioctl+0x38> <== NOT EXECUTED
return rtems_deviceio_errno(status);
10e646: e8 a0 ff ff ff call 10e5eb <rtems_deviceio_errno> <== NOT EXECUTED
10e64b: eb 03 jmp 10e650 <device_ioctl+0x3b> <== NOT EXECUTED
return args.ioctl_return;
10e64d: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED
}
10e650: c9 leave <== NOT EXECUTED
10e651: c3 ret <== NOT EXECUTED
0010e732 <device_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
10e732: 55 push %ebp
10e733: 89 e5 mov %esp,%ebp
10e735: 83 ec 1c sub $0x1c,%esp
10e738: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_open_close_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
10e73b: 8b 50 2c mov 0x2c(%eax),%edx
args.iop = iop;
10e73e: 89 45 f4 mov %eax,-0xc(%ebp)
args.flags = iop->flags;
10e741: 8b 40 0c mov 0xc(%eax),%eax
10e744: 89 45 f8 mov %eax,-0x8(%ebp)
args.mode = mode;
10e747: 8b 45 14 mov 0x14(%ebp),%eax
10e74a: 89 45 fc mov %eax,-0x4(%ebp)
status = rtems_io_open(
10e74d: 8d 45 f4 lea -0xc(%ebp),%eax
10e750: 50 push %eax
10e751: ff 72 54 pushl 0x54(%edx)
10e754: ff 72 50 pushl 0x50(%edx)
10e757: e8 20 07 00 00 call 10ee7c <rtems_io_open>
10e75c: 89 c2 mov %eax,%edx
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
10e75e: 83 c4 10 add $0x10,%esp
10e761: 31 c0 xor %eax,%eax
10e763: 85 d2 test %edx,%edx
10e765: 74 07 je 10e76e <device_open+0x3c> <== ALWAYS TAKEN
return rtems_deviceio_errno(status);
10e767: 89 d0 mov %edx,%eax <== NOT EXECUTED
10e769: e8 7d fe ff ff call 10e5eb <rtems_deviceio_errno> <== NOT EXECUTED
return 0;
}
10e76e: c9 leave
10e76f: c3 ret
0010e6a2 <device_read>:
ssize_t device_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
10e6a2: 55 push %ebp <== NOT EXECUTED
10e6a3: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10e6a5: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED
10e6a8: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
rtems_libio_rw_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
10e6ab: 8b 4a 2c mov 0x2c(%edx),%ecx <== NOT EXECUTED
args.iop = iop;
10e6ae: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED
args.offset = iop->offset;
10e6b1: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED
10e6b4: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED
args.buffer = buffer;
10e6b7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10e6ba: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED
args.count = count;
10e6bd: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
10e6c0: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED
args.flags = iop->flags;
10e6c3: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED
10e6c6: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED
args.bytes_moved = 0;
10e6c9: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED
status = rtems_io_read(
10e6d0: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED
10e6d3: 50 push %eax <== NOT EXECUTED
10e6d4: ff 71 54 pushl 0x54(%ecx) <== NOT EXECUTED
10e6d7: ff 71 50 pushl 0x50(%ecx) <== NOT EXECUTED
10e6da: e8 dd 07 00 00 call 10eebc <rtems_io_read> <== NOT EXECUTED
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
10e6df: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10e6e2: 85 c0 test %eax,%eax <== NOT EXECUTED
10e6e4: 74 07 je 10e6ed <device_read+0x4b> <== NOT EXECUTED
return rtems_deviceio_errno(status);
10e6e6: e8 00 ff ff ff call 10e5eb <rtems_deviceio_errno> <== NOT EXECUTED
10e6eb: eb 03 jmp 10e6f0 <device_read+0x4e> <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
10e6ed: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED
}
10e6f0: c9 leave <== NOT EXECUTED
10e6f1: c3 ret <== NOT EXECUTED
0010e652 <device_write>:
ssize_t device_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
10e652: 55 push %ebp
10e653: 89 e5 mov %esp,%ebp
10e655: 83 ec 2c sub $0x2c,%esp
10e658: 8b 55 08 mov 0x8(%ebp),%edx
rtems_libio_rw_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
10e65b: 8b 4a 2c mov 0x2c(%edx),%ecx
args.iop = iop;
10e65e: 89 55 e8 mov %edx,-0x18(%ebp)
args.offset = iop->offset;
10e661: 8b 42 08 mov 0x8(%edx),%eax
10e664: 89 45 ec mov %eax,-0x14(%ebp)
args.buffer = (void *) buffer;
10e667: 8b 45 0c mov 0xc(%ebp),%eax
10e66a: 89 45 f0 mov %eax,-0x10(%ebp)
args.count = count;
10e66d: 8b 45 10 mov 0x10(%ebp),%eax
10e670: 89 45 f4 mov %eax,-0xc(%ebp)
args.flags = iop->flags;
10e673: 8b 42 0c mov 0xc(%edx),%eax
10e676: 89 45 f8 mov %eax,-0x8(%ebp)
args.bytes_moved = 0;
10e679: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
status = rtems_io_write(
10e680: 8d 45 e8 lea -0x18(%ebp),%eax
10e683: 50 push %eax
10e684: ff 71 54 pushl 0x54(%ecx)
10e687: ff 71 50 pushl 0x50(%ecx)
10e68a: e8 6d 08 00 00 call 10eefc <rtems_io_write>
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
10e68f: 83 c4 10 add $0x10,%esp
10e692: 85 c0 test %eax,%eax
10e694: 74 07 je 10e69d <device_write+0x4b> <== ALWAYS TAKEN
return rtems_deviceio_errno(status);
10e696: e8 50 ff ff ff call 10e5eb <rtems_deviceio_errno> <== NOT EXECUTED
10e69b: eb 03 jmp 10e6a0 <device_write+0x4e> <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
10e69d: 8b 45 fc mov -0x4(%ebp),%eax
}
10e6a0: c9 leave
10e6a1: c3 ret
00107c82 <drainOutput>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
107c82: 55 push %ebp
107c83: 89 e5 mov %esp,%ebp
107c85: 53 push %ebx
107c86: 83 ec 04 sub $0x4,%esp
107c89: 89 c3 mov %eax,%ebx
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
107c8b: 83 b8 b4 00 00 00 00 cmpl $0x0,0xb4(%eax)
107c92: 74 46 je 107cda <drainOutput+0x58> <== NEVER TAKEN
rtems_interrupt_disable (level);
107c94: 9c pushf
107c95: fa cli
107c96: 59 pop %ecx
107c97: eb 2f jmp 107cc8 <drainOutput+0x46>
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
107c99: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx)
107ca0: 00 00 00
rtems_interrupt_enable (level);
107ca3: 51 push %ecx
107ca4: 9d popf
sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
107ca5: 51 push %ecx
107ca6: 6a 00 push $0x0
107ca8: 6a 00 push $0x0
107caa: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
107cb0: e8 bf 14 00 00 call 109174 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
107cb5: 83 c4 10 add $0x10,%esp
107cb8: 85 c0 test %eax,%eax
107cba: 74 09 je 107cc5 <drainOutput+0x43> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
107cbc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107cbf: 50 push %eax <== NOT EXECUTED
107cc0: e8 cf 1a 00 00 call 109794 <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_interrupt_disable (level);
107cc5: 9c pushf
107cc6: fa cli
107cc7: 59 pop %ecx
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) {
107cc8: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx
107cce: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
107cd4: 39 c2 cmp %eax,%edx
107cd6: 75 c1 jne 107c99 <drainOutput+0x17>
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
rtems_interrupt_enable (level);
107cd8: 51 push %ecx
107cd9: 9d popf
}
}
107cda: 8b 5d fc mov -0x4(%ebp),%ebx
107cdd: c9 leave
107cde: c3 ret
00106ebc <dup2>:
int dup2(
int fildes,
int fildes2
)
{
106ebc: 55 push %ebp
106ebd: 89 e5 mov %esp,%ebp
106ebf: 57 push %edi
106ec0: 56 push %esi
106ec1: 53 push %ebx
106ec2: 83 ec 64 sub $0x64,%esp
106ec5: 8b 7d 08 mov 0x8(%ebp),%edi
106ec8: 8b 75 0c mov 0xc(%ebp),%esi
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
106ecb: 8d 5d a8 lea -0x58(%ebp),%ebx
106ece: 53 push %ebx
106ecf: 57 push %edi
106ed0: e8 9b 04 00 00 call 107370 <fstat>
if ( status == -1 )
106ed5: 83 c4 10 add $0x10,%esp
106ed8: 40 inc %eax
106ed9: 74 1e je 106ef9 <dup2+0x3d> <== NEVER TAKEN
/*
* If fildes2 is not valid, then we should not do anything either.
*/
status = fstat( fildes2, &buf );
106edb: 52 push %edx
106edc: 52 push %edx
106edd: 53 push %ebx
106ede: 56 push %esi
106edf: e8 8c 04 00 00 call 107370 <fstat>
if ( status == -1 )
106ee4: 83 c4 10 add $0x10,%esp
106ee7: 40 inc %eax
106ee8: 74 0f je 106ef9 <dup2+0x3d> <== ALWAYS TAKEN
/*
* This fcntl handles everything else.
*/
return fcntl( fildes, F_DUPFD, fildes2 );
106eea: 50 push %eax <== NOT EXECUTED
106eeb: 56 push %esi <== NOT EXECUTED
106eec: 6a 00 push $0x0 <== NOT EXECUTED
106eee: 57 push %edi <== NOT EXECUTED
106eef: e8 bc 01 00 00 call 1070b0 <fcntl> <== NOT EXECUTED
106ef4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106ef7: eb 03 jmp 106efc <dup2+0x40> <== NOT EXECUTED
106ef9: 83 c8 ff or $0xffffffff,%eax
}
106efc: 8d 65 f4 lea -0xc(%ebp),%esp
106eff: 5b pop %ebx
106f00: 5e pop %esi
106f01: 5f pop %edi
106f02: c9 leave
106f03: c3 ret
001078b7 <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
1078b7: 55 push %ebp <== NOT EXECUTED
1078b8: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1078ba: 53 push %ebx <== NOT EXECUTED
1078bb: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED
1078be: 89 d3 mov %edx,%ebx <== NOT EXECUTED
1078c0: 88 c1 mov %al,%cl <== NOT EXECUTED
if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
1078c2: f6 42 3d 02 testb $0x2,0x3d(%edx) <== NOT EXECUTED
1078c6: 74 38 je 107900 <echo+0x49> <== NOT EXECUTED
1078c8: 0f b6 d0 movzbl %al,%edx <== NOT EXECUTED
1078cb: a1 00 b7 11 00 mov 0x11b700,%eax <== NOT EXECUTED
1078d0: f6 04 10 20 testb $0x20,(%eax,%edx,1) <== NOT EXECUTED
1078d4: 74 2a je 107900 <echo+0x49> <== NOT EXECUTED
1078d6: 80 f9 09 cmp $0x9,%cl <== NOT EXECUTED
1078d9: 74 25 je 107900 <echo+0x49> <== NOT EXECUTED
1078db: 80 f9 0a cmp $0xa,%cl <== NOT EXECUTED
1078de: 74 20 je 107900 <echo+0x49> <== NOT EXECUTED
char echobuf[2];
echobuf[0] = '^';
1078e0: c6 45 fa 5e movb $0x5e,-0x6(%ebp) <== NOT EXECUTED
echobuf[1] = c ^ 0x40;
1078e4: 83 f1 40 xor $0x40,%ecx <== NOT EXECUTED
1078e7: 88 4d fb mov %cl,-0x5(%ebp) <== NOT EXECUTED
rtems_termios_puts (echobuf, 2, tty);
1078ea: 50 push %eax <== NOT EXECUTED
1078eb: 53 push %ebx <== NOT EXECUTED
1078ec: 6a 02 push $0x2 <== NOT EXECUTED
1078ee: 8d 45 fa lea -0x6(%ebp),%eax <== NOT EXECUTED
1078f1: 50 push %eax <== NOT EXECUTED
1078f2: e8 9c fd ff ff call 107693 <rtems_termios_puts> <== NOT EXECUTED
tty->column += 2;
1078f7: 83 43 28 02 addl $0x2,0x28(%ebx) <== NOT EXECUTED
1078fb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1078fe: eb 0a jmp 10790a <echo+0x53> <== NOT EXECUTED
}
else {
oproc (c, tty);
107900: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED
107903: 89 da mov %ebx,%edx <== NOT EXECUTED
107905: e8 9e fe ff ff call 1077a8 <oproc> <== NOT EXECUTED
}
}
10790a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10790d: c9 leave <== NOT EXECUTED
10790e: c3 ret <== NOT EXECUTED
0010790f <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)
{
10790f: 55 push %ebp <== NOT EXECUTED
107910: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107912: 57 push %edi <== NOT EXECUTED
107913: 56 push %esi <== NOT EXECUTED
107914: 53 push %ebx <== NOT EXECUTED
107915: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107918: 89 c3 mov %eax,%ebx <== NOT EXECUTED
10791a: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED
if (tty->ccount == 0)
10791d: 83 78 20 00 cmpl $0x0,0x20(%eax) <== NOT EXECUTED
107921: 0f 84 4d 01 00 00 je 107a74 <erase+0x165> <== NOT EXECUTED
return;
if (lineFlag) {
107927: 85 d2 test %edx,%edx <== NOT EXECUTED
107929: 0f 84 3a 01 00 00 je 107a69 <erase+0x15a> <== NOT EXECUTED
if (!(tty->termios.c_lflag & ECHO)) {
10792f: 8b 40 3c mov 0x3c(%eax),%eax <== NOT EXECUTED
107932: a8 08 test $0x8,%al <== NOT EXECUTED
107934: 75 0c jne 107942 <erase+0x33> <== NOT EXECUTED
tty->ccount = 0;
107936: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED
10793d: e9 32 01 00 00 jmp 107a74 <erase+0x165> <== NOT EXECUTED
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
107942: a8 10 test $0x10,%al <== NOT EXECUTED
107944: 0f 85 1f 01 00 00 jne 107a69 <erase+0x15a> <== NOT EXECUTED
tty->ccount = 0;
10794a: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
107951: 0f b6 43 44 movzbl 0x44(%ebx),%eax <== NOT EXECUTED
107955: 89 da mov %ebx,%edx <== NOT EXECUTED
107957: e8 5b ff ff ff call 1078b7 <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
10795c: f6 43 3c 20 testb $0x20,0x3c(%ebx) <== NOT EXECUTED
107960: 0f 84 0e 01 00 00 je 107a74 <erase+0x165> <== NOT EXECUTED
echo ('\n', tty);
107966: 89 da mov %ebx,%edx <== NOT EXECUTED
107968: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
10796d: eb 28 jmp 107997 <erase+0x88> <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
10796f: 8b 53 1c mov 0x1c(%ebx),%edx <== NOT EXECUTED
107972: 8d 41 ff lea -0x1(%ecx),%eax <== NOT EXECUTED
107975: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED
107978: 8a 54 0a ff mov -0x1(%edx,%ecx,1),%dl <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
10797c: 8b 43 3c mov 0x3c(%ebx),%eax <== NOT EXECUTED
10797f: a8 08 test $0x8,%al <== NOT EXECUTED
107981: 0f 84 dc 00 00 00 je 107a63 <erase+0x154> <== NOT EXECUTED
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
107987: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED
10798b: 75 16 jne 1079a3 <erase+0x94> <== NOT EXECUTED
10798d: a8 10 test $0x10,%al <== NOT EXECUTED
10798f: 75 12 jne 1079a3 <erase+0x94> <== NOT EXECUTED
echo (tty->termios.c_cc[VERASE], tty);
107991: 0f b6 43 43 movzbl 0x43(%ebx),%eax <== NOT EXECUTED
107995: 89 da mov %ebx,%edx <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
107997: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10799a: 5b pop %ebx <== NOT EXECUTED
10799b: 5e pop %esi <== NOT EXECUTED
10799c: 5f pop %edi <== NOT EXECUTED
10799d: 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);
10799e: e9 14 ff ff ff jmp 1078b7 <echo> <== NOT EXECUTED
}
else if (c == '\t') {
1079a3: 80 fa 09 cmp $0x9,%dl <== NOT EXECUTED
1079a6: 8b 3d 00 b7 11 00 mov 0x11b700,%edi <== NOT EXECUTED
1079ac: 75 5e jne 107a0c <erase+0xfd> <== NOT EXECUTED
int col = tty->read_start_column;
1079ae: 8b 73 2c mov 0x2c(%ebx),%esi <== NOT EXECUTED
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
}
else if (iscntrl (c)) {
1079b1: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOCTL)
1079b6: 25 00 02 00 00 and $0x200,%eax <== NOT EXECUTED
1079bb: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED
1079be: eb 2b jmp 1079eb <erase+0xdc> <== NOT EXECUTED
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
1079c0: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED
1079c3: 8a 44 10 ff mov -0x1(%eax,%edx,1),%al <== NOT EXECUTED
if (c == '\t') {
1079c7: 3c 09 cmp $0x9,%al <== NOT EXECUTED
1079c9: 75 0a jne 1079d5 <erase+0xc6> <== NOT EXECUTED
col = (col | 7) + 1;
1079cb: 89 f0 mov %esi,%eax <== NOT EXECUTED
1079cd: 83 c8 07 or $0x7,%eax <== NOT EXECUTED
1079d0: 8d 70 01 lea 0x1(%eax),%esi <== NOT EXECUTED
1079d3: eb 15 jmp 1079ea <erase+0xdb> <== NOT EXECUTED
}
else if (iscntrl (c)) {
1079d5: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
1079d8: f6 04 07 20 testb $0x20,(%edi,%eax,1) <== NOT EXECUTED
1079dc: 74 0b je 1079e9 <erase+0xda> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOCTL)
1079de: 83 7d ec 00 cmpl $0x0,-0x14(%ebp) <== NOT EXECUTED
1079e2: 74 06 je 1079ea <erase+0xdb> <== NOT EXECUTED
col += 2;
1079e4: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
1079e7: eb 01 jmp 1079ea <erase+0xdb> <== NOT EXECUTED
}
else {
col++;
1079e9: 46 inc %esi <== NOT EXECUTED
1079ea: 42 inc %edx <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
1079eb: 39 ca cmp %ecx,%edx <== NOT EXECUTED
1079ed: 75 d1 jne 1079c0 <erase+0xb1> <== NOT EXECUTED
1079ef: eb 14 jmp 107a05 <erase+0xf6> <== NOT EXECUTED
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
1079f1: 50 push %eax <== NOT EXECUTED
1079f2: 53 push %ebx <== NOT EXECUTED
1079f3: 6a 01 push $0x1 <== NOT EXECUTED
1079f5: 68 54 72 11 00 push $0x117254 <== NOT EXECUTED
1079fa: e8 94 fc ff ff call 107693 <rtems_termios_puts> <== NOT EXECUTED
tty->column--;
1079ff: ff 4b 28 decl 0x28(%ebx) <== NOT EXECUTED
107a02: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
107a05: 39 73 28 cmp %esi,0x28(%ebx) <== NOT EXECUTED
107a08: 7f e7 jg 1079f1 <erase+0xe2> <== NOT EXECUTED
107a0a: eb 57 jmp 107a63 <erase+0x154> <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
107a0c: 0f b6 f2 movzbl %dl,%esi <== NOT EXECUTED
107a0f: f6 04 37 20 testb $0x20,(%edi,%esi,1) <== NOT EXECUTED
107a13: 74 21 je 107a36 <erase+0x127> <== NOT EXECUTED
107a15: f6 c4 02 test $0x2,%ah <== NOT EXECUTED
107a18: 74 1c je 107a36 <erase+0x127> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
107a1a: 50 push %eax <== NOT EXECUTED
107a1b: 53 push %ebx <== NOT EXECUTED
107a1c: 6a 03 push $0x3 <== NOT EXECUTED
107a1e: 68 52 72 11 00 push $0x117252 <== NOT EXECUTED
107a23: e8 6b fc ff ff call 107693 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
107a28: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
107a2b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107a2e: 85 c0 test %eax,%eax <== NOT EXECUTED
107a30: 74 04 je 107a36 <erase+0x127> <== NOT EXECUTED
tty->column--;
107a32: 48 dec %eax <== NOT EXECUTED
107a33: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
107a36: a1 00 b7 11 00 mov 0x11b700,%eax <== NOT EXECUTED
107a3b: f6 04 30 20 testb $0x20,(%eax,%esi,1) <== NOT EXECUTED
107a3f: 74 06 je 107a47 <erase+0x138> <== NOT EXECUTED
107a41: f6 43 3d 02 testb $0x2,0x3d(%ebx) <== NOT EXECUTED
107a45: 74 1c je 107a63 <erase+0x154> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
107a47: 50 push %eax <== NOT EXECUTED
107a48: 53 push %ebx <== NOT EXECUTED
107a49: 6a 03 push $0x3 <== NOT EXECUTED
107a4b: 68 52 72 11 00 push $0x117252 <== NOT EXECUTED
107a50: e8 3e fc ff ff call 107693 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
107a55: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
107a58: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107a5b: 85 c0 test %eax,%eax <== NOT EXECUTED
107a5d: 74 04 je 107a63 <erase+0x154> <== NOT EXECUTED
tty->column--;
107a5f: 48 dec %eax <== NOT EXECUTED
107a60: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
}
}
}
if (!lineFlag)
107a63: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED
107a67: 74 0b je 107a74 <erase+0x165> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
107a69: 8b 4b 20 mov 0x20(%ebx),%ecx <== NOT EXECUTED
107a6c: 85 c9 test %ecx,%ecx <== NOT EXECUTED
107a6e: 0f 85 fb fe ff ff jne 10796f <erase+0x60> <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
107a74: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
107a77: 5b pop %ebx <== NOT EXECUTED
107a78: 5e pop %esi <== NOT EXECUTED
107a79: 5f pop %edi <== NOT EXECUTED
107a7a: c9 leave <== NOT EXECUTED
107a7b: c3 ret <== NOT EXECUTED
001070b0 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
1070b0: 55 push %ebp
1070b1: 89 e5 mov %esp,%ebp
1070b3: 57 push %edi
1070b4: 56 push %esi
1070b5: 53 push %ebx
1070b6: 83 ec 0c sub $0xc,%esp
1070b9: 8b 45 08 mov 0x8(%ebp),%eax
1070bc: 8d 55 10 lea 0x10(%ebp),%edx
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
1070bf: 8b 0d 38 d0 11 00 mov 0x11d038,%ecx
1070c5: 39 c8 cmp %ecx,%eax
1070c7: 73 14 jae 1070dd <fcntl+0x2d> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
1070c9: 8b 35 68 13 12 00 mov 0x121368,%esi
1070cf: 6b c0 34 imul $0x34,%eax,%eax
1070d2: 8d 1c 06 lea (%esi,%eax,1),%ebx
rtems_libio_check_is_open(iop);
1070d5: 8b 43 0c mov 0xc(%ebx),%eax
1070d8: f6 c4 01 test $0x1,%ah
1070db: 75 10 jne 1070ed <fcntl+0x3d> <== ALWAYS TAKEN
1070dd: e8 fe 9e 00 00 call 110fe0 <__errno> <== NOT EXECUTED
1070e2: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
1070e8: e9 fc 00 00 00 jmp 1071e9 <fcntl+0x139> <== NOT EXECUTED
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
1070ed: 83 7d 0c 09 cmpl $0x9,0xc(%ebp)
1070f1: 0f 87 bf 00 00 00 ja 1071b6 <fcntl+0x106>
1070f7: 8b 7d 0c mov 0xc(%ebp),%edi
1070fa: ff 24 bd 08 ad 11 00 jmp *0x11ad08(,%edi,4)
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
107101: 8b 02 mov (%edx),%eax
if ( fd2 )
107103: 85 c0 test %eax,%eax
107105: 74 0e je 107115 <fcntl+0x65> <== ALWAYS TAKEN
diop = rtems_libio_iop( fd2 );
107107: 31 d2 xor %edx,%edx <== NOT EXECUTED
107109: 39 c8 cmp %ecx,%eax <== NOT EXECUTED
10710b: 73 1a jae 107127 <fcntl+0x77> <== NOT EXECUTED
10710d: 6b c0 34 imul $0x34,%eax,%eax <== NOT EXECUTED
107110: 8d 14 06 lea (%esi,%eax,1),%edx <== NOT EXECUTED
107113: eb 12 jmp 107127 <fcntl+0x77> <== NOT EXECUTED
else {
/* allocate a file control block */
diop = rtems_libio_allocate();
107115: e8 93 05 00 00 call 1076ad <rtems_libio_allocate>
10711a: 89 c2 mov %eax,%edx
if ( diop == 0 ) {
10711c: 83 ce ff or $0xffffffff,%esi
10711f: 85 c0 test %eax,%eax
107121: 0f 84 c5 00 00 00 je 1071ec <fcntl+0x13c> <== NEVER TAKEN
ret = -1;
break;
}
}
diop->handlers = iop->handlers;
107127: 8b 43 30 mov 0x30(%ebx),%eax
10712a: 89 42 30 mov %eax,0x30(%edx)
diop->file_info = iop->file_info;
10712d: 8b 43 2c mov 0x2c(%ebx),%eax
107130: 89 42 2c mov %eax,0x2c(%edx)
diop->flags = iop->flags;
107133: 8b 43 0c mov 0xc(%ebx),%eax
107136: 89 42 0c mov %eax,0xc(%edx)
diop->pathinfo = iop->pathinfo;
107139: 8d 7a 10 lea 0x10(%edx),%edi
10713c: 8d 73 10 lea 0x10(%ebx),%esi
10713f: b9 04 00 00 00 mov $0x4,%ecx
107144: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
ret = (int) (diop - rtems_libio_iops);
107146: 2b 15 68 13 12 00 sub 0x121368,%edx
10714c: c1 fa 02 sar $0x2,%edx
10714f: 69 f2 c5 4e ec c4 imul $0xc4ec4ec5,%edx,%esi
107155: eb 6c jmp 1071c3 <fcntl+0x113>
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
107157: 89 c6 mov %eax,%esi
107159: c1 ee 0b shr $0xb,%esi
10715c: 83 e6 01 and $0x1,%esi
10715f: eb 66 jmp 1071c7 <fcntl+0x117>
* 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 ) )
107161: 83 3a 00 cmpl $0x0,(%edx)
107164: 74 05 je 10716b <fcntl+0xbb> <== NEVER TAKEN
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
107166: 80 cc 08 or $0x8,%ah
107169: eb 03 jmp 10716e <fcntl+0xbe>
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
10716b: 80 e4 f7 and $0xf7,%ah <== NOT EXECUTED
10716e: 89 43 0c mov %eax,0xc(%ebx)
107171: 31 f6 xor %esi,%esi
107173: eb 52 jmp 1071c7 <fcntl+0x117>
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
107175: 83 ec 0c sub $0xc,%esp
107178: 50 push %eax
107179: e8 e2 03 00 00 call 107560 <rtems_libio_to_fcntl_flags>
10717e: 89 c6 mov %eax,%esi
107180: 83 c4 10 add $0x10,%esp
107183: eb 3e jmp 1071c3 <fcntl+0x113>
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
107185: 83 ec 0c sub $0xc,%esp
107188: ff 32 pushl (%edx)
10718a: e8 b0 05 00 00 call 10773f <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
10718f: 25 01 02 00 00 and $0x201,%eax
107194: 8b 53 0c mov 0xc(%ebx),%edx
107197: 81 e2 fe fd ff ff and $0xfffffdfe,%edx
10719d: 09 c2 or %eax,%edx
10719f: 89 53 0c mov %edx,0xc(%ebx)
1071a2: 31 f6 xor %esi,%esi
1071a4: 83 c4 10 add $0x10,%esp
1071a7: eb 1e jmp 1071c7 <fcntl+0x117>
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
1071a9: e8 32 9e 00 00 call 110fe0 <__errno>
1071ae: c7 00 86 00 00 00 movl $0x86,(%eax)
1071b4: eb 33 jmp 1071e9 <fcntl+0x139>
ret = -1;
break;
default:
errno = EINVAL;
1071b6: e8 25 9e 00 00 call 110fe0 <__errno>
1071bb: c7 00 16 00 00 00 movl $0x16,(%eax)
1071c1: eb 26 jmp 1071e9 <fcntl+0x139>
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
1071c3: 85 f6 test %esi,%esi
1071c5: 78 25 js 1071ec <fcntl+0x13c> <== NEVER TAKEN
if (iop->handlers->fcntl_h) {
1071c7: 8b 43 30 mov 0x30(%ebx),%eax
1071ca: 8b 40 30 mov 0x30(%eax),%eax
1071cd: 85 c0 test %eax,%eax
1071cf: 74 1b je 1071ec <fcntl+0x13c> <== NEVER TAKEN
int err = (*iop->handlers->fcntl_h)( cmd, iop );
1071d1: 52 push %edx
1071d2: 52 push %edx
1071d3: 53 push %ebx
1071d4: ff 75 0c pushl 0xc(%ebp)
1071d7: ff d0 call *%eax
1071d9: 89 c3 mov %eax,%ebx
if (err) {
1071db: 83 c4 10 add $0x10,%esp
1071de: 85 c0 test %eax,%eax
1071e0: 74 0a je 1071ec <fcntl+0x13c> <== ALWAYS TAKEN
errno = err;
1071e2: e8 f9 9d 00 00 call 110fe0 <__errno> <== NOT EXECUTED
1071e7: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
1071e9: 83 ce ff or $0xffffffff,%esi
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
1071ec: 89 f0 mov %esi,%eax
1071ee: 8d 65 f4 lea -0xc(%ebp),%esp
1071f1: 5b pop %ebx
1071f2: 5e pop %esi
1071f3: 5f pop %edi
1071f4: c9 leave
1071f5: c3 ret
00107214 <fdatasync>:
#include <rtems/seterr.h>
int fdatasync(
int fd
)
{
107214: 55 push %ebp
107215: 89 e5 mov %esp,%ebp
107217: 83 ec 08 sub $0x8,%esp
10721a: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
10721d: 3b 05 38 d0 11 00 cmp 0x11d038,%eax
107223: 73 15 jae 10723a <fdatasync+0x26> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
107225: 6b d0 34 imul $0x34,%eax,%edx
107228: 03 15 68 13 12 00 add 0x121368,%edx
rtems_libio_check_is_open(iop);
10722e: 8b 42 0c mov 0xc(%edx),%eax
107231: f6 c4 01 test $0x1,%ah
107234: 74 04 je 10723a <fdatasync+0x26> <== NEVER TAKEN
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
107236: a8 04 test $0x4,%al
107238: 75 0d jne 107247 <fdatasync+0x33>
10723a: e8 a1 9d 00 00 call 110fe0 <__errno>
10723f: c7 00 09 00 00 00 movl $0x9,(%eax)
107245: eb 1d jmp 107264 <fdatasync+0x50>
/*
* Now process the fdatasync().
*/
if ( !iop->handlers->fdatasync_h )
107247: 8b 42 30 mov 0x30(%edx),%eax
10724a: 8b 48 2c mov 0x2c(%eax),%ecx
10724d: 85 c9 test %ecx,%ecx
10724f: 75 0d jne 10725e <fdatasync+0x4a> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
107251: e8 8a 9d 00 00 call 110fe0 <__errno>
107256: c7 00 86 00 00 00 movl $0x86,(%eax)
10725c: eb 06 jmp 107264 <fdatasync+0x50>
return (*iop->handlers->fdatasync_h)( iop );
10725e: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED
}
107261: c9 leave <== NOT EXECUTED
*/
if ( !iop->handlers->fdatasync_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
return (*iop->handlers->fdatasync_h)( iop );
107262: ff e1 jmp *%ecx <== NOT EXECUTED
}
107264: 83 c8 ff or $0xffffffff,%eax
107267: c9 leave
107268: c3 ret
0010a432 <file_systems_below_this_mountpoint>:
bool file_systems_below_this_mountpoint(
const char *path,
rtems_filesystem_location_info_t *fs_root_loc,
rtems_filesystem_mount_table_entry_t *fs_to_unmount
)
{
10a432: 55 push %ebp <== NOT EXECUTED
10a433: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10a435: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
/*
* Search the mount table for any mount entries referencing this
* mount entry.
*/
for ( the_node = rtems_filesystem_mount_table_control.first;
10a438: 8b 15 94 29 12 00 mov 0x122994,%edx <== NOT EXECUTED
10a43e: eb 0e jmp 10a44e <file_systems_below_this_mountpoint+0x1c><== NOT EXECUTED
!rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
the_node = the_node->next ) {
the_mount_entry = ( rtems_filesystem_mount_table_entry_t * )the_node;
if (the_mount_entry->mt_point_node.mt_entry == fs_root_loc->mt_entry ) {
10a440: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED
10a443: 3b 41 0c cmp 0xc(%ecx),%eax <== NOT EXECUTED
10a446: 75 04 jne 10a44c <file_systems_below_this_mountpoint+0x1a><== NOT EXECUTED
10a448: b0 01 mov $0x1,%al <== NOT EXECUTED
10a44a: eb 0c jmp 10a458 <file_systems_below_this_mountpoint+0x26><== NOT EXECUTED
* mount entry.
*/
for ( the_node = rtems_filesystem_mount_table_control.first;
!rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
the_node = the_node->next ) {
10a44c: 8b 12 mov (%edx),%edx <== NOT EXECUTED
* Search the mount table for any mount entries referencing this
* mount entry.
*/
for ( the_node = rtems_filesystem_mount_table_control.first;
!rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
10a44e: 81 fa 98 29 12 00 cmp $0x122998,%edx <== NOT EXECUTED
10a454: 75 ea jne 10a440 <file_systems_below_this_mountpoint+0xe><== NOT EXECUTED
10a456: 31 c0 xor %eax,%eax <== NOT EXECUTED
return true;
}
}
return false;
}
10a458: c9 leave <== NOT EXECUTED
10a459: c3 ret <== NOT EXECUTED
0010726c <fpathconf>:
long fpathconf(
int fd,
int name
)
{
10726c: 55 push %ebp
10726d: 89 e5 mov %esp,%ebp
10726f: 83 ec 08 sub $0x8,%esp
107272: 8b 45 08 mov 0x8(%ebp),%eax
107275: 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);
107278: 3b 05 38 d0 11 00 cmp 0x11d038,%eax
10727e: 73 0f jae 10728f <fpathconf+0x23>
iop = rtems_libio_iop(fd);
107280: 6b c0 34 imul $0x34,%eax,%eax
107283: 03 05 68 13 12 00 add 0x121368,%eax
rtems_libio_check_is_open(iop);
107289: f6 40 0d 01 testb $0x1,0xd(%eax)
10728d: 75 0d jne 10729c <fpathconf+0x30> <== ALWAYS TAKEN
10728f: e8 4c 9d 00 00 call 110fe0 <__errno>
107294: c7 00 09 00 00 00 movl $0x9,(%eax)
10729a: eb 56 jmp 1072f2 <fpathconf+0x86>
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
10729c: 8b 40 1c mov 0x1c(%eax),%eax
switch ( name ) {
10729f: 83 fa 0b cmp $0xb,%edx
1072a2: 77 43 ja 1072e7 <fpathconf+0x7b>
1072a4: ff 24 95 30 ad 11 00 jmp *0x11ad30(,%edx,4)
case _PC_LINK_MAX:
return_value = the_limits->link_max;
1072ab: 8b 40 30 mov 0x30(%eax),%eax
1072ae: eb 45 jmp 1072f5 <fpathconf+0x89>
break;
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
1072b0: 8b 40 34 mov 0x34(%eax),%eax
1072b3: eb 40 jmp 1072f5 <fpathconf+0x89>
break;
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
1072b5: 8b 40 38 mov 0x38(%eax),%eax
1072b8: eb 3b jmp 1072f5 <fpathconf+0x89>
break;
case _PC_NAME_MAX:
return_value = the_limits->name_max;
1072ba: 8b 40 3c mov 0x3c(%eax),%eax
1072bd: eb 36 jmp 1072f5 <fpathconf+0x89>
break;
case _PC_PATH_MAX:
return_value = the_limits->path_max;
1072bf: 8b 40 40 mov 0x40(%eax),%eax
1072c2: eb 31 jmp 1072f5 <fpathconf+0x89>
break;
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
1072c4: 8b 40 44 mov 0x44(%eax),%eax
1072c7: eb 2c jmp 1072f5 <fpathconf+0x89>
break;
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
1072c9: 8b 40 4c mov 0x4c(%eax),%eax
1072cc: eb 27 jmp 1072f5 <fpathconf+0x89>
break;
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
1072ce: 8b 40 50 mov 0x50(%eax),%eax
1072d1: eb 22 jmp 1072f5 <fpathconf+0x89>
break;
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
1072d3: 8b 40 5c mov 0x5c(%eax),%eax
1072d6: eb 1d jmp 1072f5 <fpathconf+0x89>
break;
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
1072d8: 8b 40 48 mov 0x48(%eax),%eax
1072db: eb 18 jmp 1072f5 <fpathconf+0x89>
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
1072dd: 8b 40 54 mov 0x54(%eax),%eax
1072e0: eb 13 jmp 1072f5 <fpathconf+0x89>
break;
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
1072e2: 8b 40 58 mov 0x58(%eax),%eax
1072e5: eb 0e jmp 1072f5 <fpathconf+0x89>
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
1072e7: e8 f4 9c 00 00 call 110fe0 <__errno>
1072ec: c7 00 16 00 00 00 movl $0x16,(%eax)
1072f2: 83 c8 ff or $0xffffffff,%eax
break;
}
return return_value;
}
1072f5: c9 leave
1072f6: c3 ret
00106478 <free>:
void free(
void *ptr
)
{
MSBUMP(free_calls, 1);
106478: 55 push %ebp
106479: 89 e5 mov %esp,%ebp
10647b: 53 push %ebx
10647c: 83 ec 04 sub $0x4,%esp
10647f: 8b 5d 08 mov 0x8(%ebp),%ebx
106482: ff 05 b4 d6 11 00 incl 0x11d6b4
if ( !ptr )
106488: 85 db test %ebx,%ebx
10648a: 74 5f je 1064eb <free+0x73>
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
10648c: 83 3d 38 d9 11 00 03 cmpl $0x3,0x11d938
106493: 75 15 jne 1064aa <free+0x32> <== NEVER TAKEN
106495: e8 de 00 00 00 call 106578 <malloc_is_system_state_OK>
10649a: 84 c0 test %al,%al
10649c: 75 0c jne 1064aa <free+0x32> <== ALWAYS TAKEN
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
10649e: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED
RTEMS_Malloc_Heap.begin,
RTEMS_Malloc_Heap.end
);
}
}
1064a1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
1064a4: c9 leave <== NOT EXECUTED
* 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);
1064a5: e9 0d 01 00 00 jmp 1065b7 <malloc_deferred_free> <== NOT EXECUTED
#endif
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
1064aa: a1 d4 bb 11 00 mov 0x11bbd4,%eax
1064af: 85 c0 test %eax,%eax
1064b1: 74 0a je 1064bd <free+0x45> <== ALWAYS TAKEN
(*rtems_malloc_statistics_helpers->at_free)(ptr);
1064b3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1064b6: 53 push %ebx <== NOT EXECUTED
1064b7: ff 50 08 call *0x8(%eax) <== NOT EXECUTED
1064ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if ( !_Protected_heap_Free( &RTEMS_Malloc_Heap, ptr ) ) {
1064bd: 50 push %eax
1064be: 50 push %eax
1064bf: 53 push %ebx
1064c0: 68 50 d6 11 00 push $0x11d650
1064c5: e8 a2 44 00 00 call 10a96c <_Protected_heap_Free>
1064ca: 83 c4 10 add $0x10,%esp
1064cd: 84 c0 test %al,%al
1064cf: 75 1a jne 1064eb <free+0x73> <== ALWAYS TAKEN
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
1064d1: ff 35 6c d6 11 00 pushl 0x11d66c <== NOT EXECUTED
1064d7: ff 35 68 d6 11 00 pushl 0x11d668 <== NOT EXECUTED
1064dd: 53 push %ebx <== NOT EXECUTED
1064de: 68 fc 71 11 00 push $0x1171fc <== NOT EXECUTED
1064e3: e8 76 0b 00 00 call 10705e <printk> <== NOT EXECUTED
1064e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
RTEMS_Malloc_Heap.begin,
RTEMS_Malloc_Heap.end
);
}
}
1064eb: 8b 5d fc mov -0x4(%ebp),%ebx
1064ee: c9 leave
1064ef: c3 ret
00107a74 <free_user_env>:
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
107a74: 55 push %ebp <== NOT EXECUTED
107a75: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107a77: 53 push %ebx <== NOT EXECUTED
107a78: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED
107a7b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
107a7e: 81 fb 00 0a 12 00 cmp $0x120a00,%ebx <== NOT EXECUTED
107a84: 74 40 je 107ac6 <free_user_env+0x52> <== NOT EXECUTED
#ifdef HAVE_USERENV_REFCNT
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
107a86: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED
107a89: 85 c0 test %eax,%eax <== NOT EXECUTED
107a8b: 74 13 je 107aa0 <free_user_env+0x2c> <== NOT EXECUTED
107a8d: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED
107a90: 85 d2 test %edx,%edx <== NOT EXECUTED
107a92: 74 0c je 107aa0 <free_user_env+0x2c> <== NOT EXECUTED
107a94: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107a97: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED
107a9a: 50 push %eax <== NOT EXECUTED
107a9b: ff d2 call *%edx <== NOT EXECUTED
107a9d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_filesystem_freenode( &env->root_directory);
107aa0: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED
107aa3: 85 c0 test %eax,%eax <== NOT EXECUTED
107aa5: 74 13 je 107aba <free_user_env+0x46> <== NOT EXECUTED
107aa7: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED
107aaa: 85 d2 test %edx,%edx <== NOT EXECUTED
107aac: 74 0c je 107aba <free_user_env+0x46> <== NOT EXECUTED
107aae: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107ab1: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED
107ab4: 50 push %eax <== NOT EXECUTED
107ab5: ff d2 call *%edx <== NOT EXECUTED
107ab7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
free(env);
107aba: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED
}
}
107abd: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
107ac0: c9 leave <== NOT EXECUTED
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
rtems_filesystem_freenode( &env->root_directory);
free(env);
107ac1: e9 0e f1 ff ff jmp 106bd4 <free> <== NOT EXECUTED
}
}
107ac6: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
107ac9: c9 leave <== NOT EXECUTED
107aca: c3 ret <== NOT EXECUTED
00115538 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
115538: 55 push %ebp
115539: 89 e5 mov %esp,%ebp
11553b: 57 push %edi
11553c: 56 push %esi
11553d: 53 push %ebx
11553e: 83 ec 0c sub $0xc,%esp
115541: 8b 45 08 mov 0x8(%ebp),%eax
115544: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
115547: 85 f6 test %esi,%esi
115549: 75 0d jne 115558 <fstat+0x20>
rtems_set_errno_and_return_minus_one( EFAULT );
11554b: e8 d8 9b ff ff call 10f128 <__errno>
115550: c7 00 0e 00 00 00 movl $0xe,(%eax)
115556: eb 54 jmp 1155ac <fstat+0x74>
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
115558: 3b 05 d8 92 11 00 cmp 0x1192d8,%eax
11555e: 73 57 jae 1155b7 <fstat+0x7f>
115560: 6b d8 34 imul $0x34,%eax,%ebx
115563: 03 1d 38 d6 11 00 add 0x11d638,%ebx
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
115569: f6 43 0d 01 testb $0x1,0xd(%ebx)
11556d: 74 48 je 1155b7 <fstat+0x7f> <== NEVER TAKEN
if ( !iop->handlers )
11556f: 8b 43 30 mov 0x30(%ebx),%eax
115572: 85 c0 test %eax,%eax
115574: 74 41 je 1155b7 <fstat+0x7f> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EBADF );
if ( !iop->handlers->fstat_h )
115576: 83 78 18 00 cmpl $0x0,0x18(%eax)
11557a: 75 0d jne 115589 <fstat+0x51> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
11557c: e8 a7 9b ff ff call 10f128 <__errno> <== NOT EXECUTED
115581: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
115587: eb 23 jmp 1155ac <fstat+0x74> <== NOT EXECUTED
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
115589: b9 13 00 00 00 mov $0x13,%ecx
11558e: 31 c0 xor %eax,%eax
115590: 89 f7 mov %esi,%edi
115592: f3 ab rep stos %eax,%es:(%edi)
return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf );
115594: 8b 53 30 mov 0x30(%ebx),%edx
115597: 89 75 0c mov %esi,0xc(%ebp)
11559a: 8d 43 10 lea 0x10(%ebx),%eax
11559d: 89 45 08 mov %eax,0x8(%ebp)
1155a0: 8b 4a 18 mov 0x18(%edx),%ecx
}
1155a3: 83 c4 0c add $0xc,%esp
1155a6: 5b pop %ebx
1155a7: 5e pop %esi
1155a8: 5f pop %edi
1155a9: 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->handlers->fstat_h)( &iop->pathinfo, sbuf );
1155aa: ff e1 jmp *%ecx
}
1155ac: 83 c8 ff or $0xffffffff,%eax
1155af: 83 c4 0c add $0xc,%esp
1155b2: 5b pop %ebx
1155b3: 5e pop %esi
1155b4: 5f pop %edi
1155b5: c9 leave
1155b6: c3 ret
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
rtems_libio_check_fd( fd );
1155b7: e8 6c 9b ff ff call 10f128 <__errno>
1155bc: c7 00 09 00 00 00 movl $0x9,(%eax)
1155c2: eb e8 jmp 1155ac <fstat+0x74>
00107414 <fsync>:
#include <rtems/seterr.h>
int fsync(
int fd
)
{
107414: 55 push %ebp
107415: 89 e5 mov %esp,%ebp
107417: 83 ec 08 sub $0x8,%esp
10741a: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
10741d: 3b 05 38 d0 11 00 cmp 0x11d038,%eax
107423: 73 16 jae 10743b <fsync+0x27> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
107425: 6b c0 34 imul $0x34,%eax,%eax
107428: 03 05 68 13 12 00 add 0x121368,%eax
rtems_libio_check_is_open(iop);
10742e: f6 40 0d 01 testb $0x1,0xd(%eax)
107432: 74 07 je 10743b <fsync+0x27> <== NEVER TAKEN
/*
* Now process the fsync().
*/
if ( !iop->handlers )
107434: 8b 50 30 mov 0x30(%eax),%edx
107437: 85 d2 test %edx,%edx
107439: 75 0d jne 107448 <fsync+0x34> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EBADF );
10743b: e8 a0 9b 00 00 call 110fe0 <__errno> <== NOT EXECUTED
107440: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
107446: eb 1a jmp 107462 <fsync+0x4e> <== NOT EXECUTED
if ( !iop->handlers->fsync_h )
107448: 8b 4a 28 mov 0x28(%edx),%ecx
10744b: 85 c9 test %ecx,%ecx
10744d: 75 0d jne 10745c <fsync+0x48>
rtems_set_errno_and_return_minus_one( ENOTSUP );
10744f: e8 8c 9b 00 00 call 110fe0 <__errno>
107454: c7 00 86 00 00 00 movl $0x86,(%eax)
10745a: eb 06 jmp 107462 <fsync+0x4e>
return (*iop->handlers->fsync_h)( iop );
10745c: 89 45 08 mov %eax,0x8(%ebp)
}
10745f: c9 leave
rtems_set_errno_and_return_minus_one( EBADF );
if ( !iop->handlers->fsync_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
return (*iop->handlers->fsync_h)( iop );
107460: ff e1 jmp *%ecx
}
107462: 83 c8 ff or $0xffffffff,%eax
107465: c9 leave
107466: c3 ret
0010cd90 <ftruncate>:
int ftruncate(
int fd,
off_t length
)
{
10cd90: 55 push %ebp
10cd91: 89 e5 mov %esp,%ebp
10cd93: 57 push %edi
10cd94: 56 push %esi
10cd95: 53 push %ebx
10cd96: 83 ec 1c sub $0x1c,%esp
10cd99: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
10cd9c: 3b 05 d8 92 11 00 cmp 0x1192d8,%eax
10cda2: 73 0f jae 10cdb3 <ftruncate+0x23> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
10cda4: 6b d8 34 imul $0x34,%eax,%ebx
10cda7: 03 1d 38 d6 11 00 add 0x11d638,%ebx
rtems_libio_check_is_open(iop);
10cdad: f6 43 0d 01 testb $0x1,0xd(%ebx)
10cdb1: 75 0d jne 10cdc0 <ftruncate+0x30> <== ALWAYS TAKEN
10cdb3: e8 70 23 00 00 call 10f128 <__errno> <== NOT EXECUTED
10cdb8: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
10cdbe: eb 5b jmp 10ce1b <ftruncate+0x8b> <== NOT EXECUTED
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
10cdc0: 8d 7d e4 lea -0x1c(%ebp),%edi
10cdc3: 8d 73 10 lea 0x10(%ebx),%esi
10cdc6: b9 04 00 00 00 mov $0x4,%ecx
10cdcb: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !loc.ops->node_type_h )
10cdcd: 8b 45 ec mov -0x14(%ebp),%eax
10cdd0: 8b 50 10 mov 0x10(%eax),%edx
10cdd3: 85 d2 test %edx,%edx
10cdd5: 74 39 je 10ce10 <ftruncate+0x80> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
10cdd7: 83 ec 0c sub $0xc,%esp
10cdda: 8d 45 e4 lea -0x1c(%ebp),%eax
10cddd: 50 push %eax
10cdde: ff d2 call *%edx
10cde0: 83 c4 10 add $0x10,%esp
10cde3: 48 dec %eax
10cde4: 75 0d jne 10cdf3 <ftruncate+0x63>
rtems_set_errno_and_return_minus_one( EISDIR );
10cde6: e8 3d 23 00 00 call 10f128 <__errno>
10cdeb: c7 00 15 00 00 00 movl $0x15,(%eax)
10cdf1: eb 28 jmp 10ce1b <ftruncate+0x8b>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
10cdf3: f6 43 0c 04 testb $0x4,0xc(%ebx)
10cdf7: 75 0d jne 10ce06 <ftruncate+0x76> <== ALWAYS TAKEN
10cdf9: e8 2a 23 00 00 call 10f128 <__errno> <== NOT EXECUTED
10cdfe: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
10ce04: eb 15 jmp 10ce1b <ftruncate+0x8b> <== NOT EXECUTED
if ( !iop->handlers->ftruncate_h )
10ce06: 8b 43 30 mov 0x30(%ebx),%eax
10ce09: 8b 40 20 mov 0x20(%eax),%eax
10ce0c: 85 c0 test %eax,%eax
10ce0e: 75 10 jne 10ce20 <ftruncate+0x90> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
10ce10: e8 13 23 00 00 call 10f128 <__errno> <== NOT EXECUTED
10ce15: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10ce1b: 83 c8 ff or $0xffffffff,%eax
10ce1e: eb 0b jmp 10ce2b <ftruncate+0x9b>
return (*iop->handlers->ftruncate_h)( iop, length );
10ce20: 52 push %edx
10ce21: 52 push %edx
10ce22: ff 75 0c pushl 0xc(%ebp)
10ce25: 53 push %ebx
10ce26: ff d0 call *%eax
10ce28: 83 c4 10 add $0x10,%esp
}
10ce2b: 8d 65 f4 lea -0xc(%ebp),%esp
10ce2e: 5b pop %ebx
10ce2f: 5e pop %esi
10ce30: 5f pop %edi
10ce31: c9 leave
10ce32: c3 ret
0010efcc <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
10efcc: 55 push %ebp
10efcd: 89 e5 mov %esp,%ebp
10efcf: 57 push %edi
10efd0: 56 push %esi
10efd1: 53 push %ebx
10efd2: 83 ec 1c sub $0x1c,%esp
10efd5: 8b 45 08 mov 0x8(%ebp),%eax
/*
* Get the file control block structure associated with the file descriptor
*/
iop = rtems_libio_iop( dd_fd );
10efd8: 31 db xor %ebx,%ebx
10efda: 3b 05 18 e2 11 00 cmp 0x11e218,%eax
10efe0: 73 09 jae 10efeb <getdents+0x1f> <== NEVER TAKEN
10efe2: 6b d8 34 imul $0x34,%eax,%ebx
10efe5: 03 1d 18 26 12 00 add 0x122618,%ebx
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
10efeb: 8d 7d e4 lea -0x1c(%ebp),%edi
10efee: 8d 73 10 lea 0x10(%ebx),%esi
10eff1: b9 04 00 00 00 mov $0x4,%ecx
10eff6: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !loc.ops->node_type_h )
10eff8: 8b 45 ec mov -0x14(%ebp),%eax
10effb: 8b 50 10 mov 0x10(%eax),%edx
10effe: 85 d2 test %edx,%edx
10f000: 74 29 je 10f02b <getdents+0x5f> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
10f002: 83 ec 0c sub $0xc,%esp
10f005: 8d 45 e4 lea -0x1c(%ebp),%eax
10f008: 50 push %eax
10f009: ff d2 call *%edx
10f00b: 83 c4 10 add $0x10,%esp
10f00e: 48 dec %eax
10f00f: 74 10 je 10f021 <getdents+0x55>
rtems_set_errno_and_return_minus_one( ENOTDIR );
10f011: e8 ca 2d 00 00 call 111de0 <__errno>
10f016: c7 00 14 00 00 00 movl $0x14,(%eax)
10f01c: 83 c8 ff or $0xffffffff,%eax
10f01f: eb 24 jmp 10f045 <getdents+0x79>
/*
* Return the number of bytes that were actually transfered as a result
* of the read attempt.
*/
if ( !iop->handlers->read_h )
10f021: 8b 43 30 mov 0x30(%ebx),%eax
10f024: 8b 40 08 mov 0x8(%eax),%eax
10f027: 85 c0 test %eax,%eax
10f029: 75 0d jne 10f038 <getdents+0x6c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
10f02b: e8 b0 2d 00 00 call 111de0 <__errno> <== NOT EXECUTED
10f030: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10f036: eb e4 jmp 10f01c <getdents+0x50> <== NOT EXECUTED
return (*iop->handlers->read_h)( iop, dd_buf, dd_len );
10f038: 52 push %edx
10f039: ff 75 10 pushl 0x10(%ebp)
10f03c: ff 75 0c pushl 0xc(%ebp)
10f03f: 53 push %ebx
10f040: ff d0 call *%eax
10f042: 83 c4 10 add $0x10,%esp
}
10f045: 8d 65 f4 lea -0xc(%ebp),%esp
10f048: 5b pop %ebx
10f049: 5e pop %esi
10f04a: 5f pop %edi
10f04b: c9 leave
10f04c: c3 ret
0010ce54 <gettimeofday>:
int gettimeofday(
struct timeval *tp,
void * __tz
)
{
10ce54: 55 push %ebp
10ce55: 89 e5 mov %esp,%ebp
10ce57: 56 push %esi
10ce58: 53 push %ebx
10ce59: 83 ec 20 sub $0x20,%esp
10ce5c: 8b 75 08 mov 0x8(%ebp),%esi
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp ) {
10ce5f: 85 f6 test %esi,%esi
10ce61: 75 10 jne 10ce73 <gettimeofday+0x1f> <== ALWAYS TAKEN
errno = EFAULT;
10ce63: e8 c0 22 00 00 call 10f128 <__errno> <== NOT EXECUTED
10ce68: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED
10ce6e: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10ce71: eb 2a jmp 10ce9d <gettimeofday+0x49> <== NOT EXECUTED
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
10ce73: 9c pushf
10ce74: fa cli
10ce75: 5b pop %ebx
* This routine grows @a the_heap memory area using the size bytes which
10ce76: 83 ec 0c sub $0xc,%esp
10ce79: 8d 45 f0 lea -0x10(%ebp),%eax
10ce7c: 50 push %eax
10ce7d: e8 ba d0 ff ff call 109f3c <_TOD_Get>
* begin at @a starting_address.
10ce82: 53 push %ebx
10ce83: 9d popf
*
* @param[in] the_heap is the heap to operate upon
10ce84: 8b 45 f0 mov -0x10(%ebp),%eax
10ce87: 89 06 mov %eax,(%esi)
* @param[in] starting_address is the starting address of the memory
10ce89: 8b 45 f4 mov -0xc(%ebp),%eax
10ce8c: b9 e8 03 00 00 mov $0x3e8,%ecx
10ce91: 31 d2 xor %edx,%edx
10ce93: f7 f1 div %ecx
10ce95: 89 46 04 mov %eax,0x4(%esi)
10ce98: 31 c0 xor %eax,%eax
10ce9a: 83 c4 10 add $0x10,%esp
* with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X
* do it. This puts us in good company.
*/
return 0;
}
10ce9d: 8d 65 f8 lea -0x8(%ebp),%esp
10cea0: 5b pop %ebx
10cea1: 5e pop %esi
10cea2: c9 leave
10cea3: c3 ret
0011052c <imfs_dir_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
11052c: 55 push %ebp
11052d: 89 e5 mov %esp,%ebp
11052f: 8b 4d 08 mov 0x8(%ebp),%ecx
IMFS_jnode_t *the_jnode;
/* Is the node a directory ? */
the_jnode = (IMFS_jnode_t *) iop->file_info;
if ( the_jnode->type != IMFS_DIRECTORY )
110532: 8b 41 2c mov 0x2c(%ecx),%eax
110535: 83 ca ff or $0xffffffff,%edx
110538: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
11053c: 75 09 jne 110547 <imfs_dir_open+0x1b> <== NEVER TAKEN
return -1; /* It wasn't a directory --> return error */
iop->offset = 0;
11053e: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx)
110545: 31 d2 xor %edx,%edx
return 0;
}
110547: 89 d0 mov %edx,%eax
110549: c9 leave
11054a: c3 ret
00110615 <imfs_dir_rmnod>:
*/
int imfs_dir_rmnod(
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
110615: 55 push %ebp
110616: 89 e5 mov %esp,%ebp
110618: 56 push %esi
110619: 53 push %ebx
11061a: 83 ec 10 sub $0x10,%esp
11061d: 8b 75 08 mov 0x8(%ebp),%esi
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
110620: 8b 1e mov (%esi),%ebx
/*
* You cannot remove a node that still has children
*/
if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) )
110622: 8d 43 54 lea 0x54(%ebx),%eax
110625: 39 43 50 cmp %eax,0x50(%ebx)
110628: 74 0d je 110637 <imfs_dir_rmnod+0x22>
rtems_set_errno_and_return_minus_one( ENOTEMPTY );
11062a: e8 b1 09 00 00 call 110fe0 <__errno>
11062f: c7 00 5a 00 00 00 movl $0x5a,(%eax)
110635: eb 19 jmp 110650 <imfs_dir_rmnod+0x3b>
/*
* You cannot remove the file system root node.
*/
if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access )
110637: 8b 46 0c mov 0xc(%esi),%eax
11063a: 39 58 18 cmp %ebx,0x18(%eax)
11063d: 74 06 je 110645 <imfs_dir_rmnod+0x30>
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
11063f: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx)
110643: 74 10 je 110655 <imfs_dir_rmnod+0x40> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EBUSY );
110645: e8 96 09 00 00 call 110fe0 <__errno>
11064a: c7 00 10 00 00 00 movl $0x10,(%eax)
110650: 83 c8 ff or $0xffffffff,%eax
110653: eb 6c jmp 1106c1 <imfs_dir_rmnod+0xac>
/*
* Take the node out of the parent's chain that contains this node
*/
if ( the_jnode->Parent != NULL ) {
110655: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
110659: 74 13 je 11066e <imfs_dir_rmnod+0x59>
11065b: 83 ec 0c sub $0xc,%esp
11065e: 53 push %ebx
11065f: e8 d0 e9 ff ff call 10f034 <_Chain_Extract>
rtems_chain_extract( (rtems_chain_node *) the_jnode );
the_jnode->Parent = NULL;
110664: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
11066b: 83 c4 10 add $0x10,%esp
/*
* Decrement the link counter and see if we can free the space.
*/
the_jnode->st_nlink--;
11066e: 66 ff 4b 34 decw 0x34(%ebx)
IMFS_update_ctime( the_jnode );
110672: 51 push %ecx
110673: 51 push %ecx
110674: 6a 00 push $0x0
110676: 8d 45 f0 lea -0x10(%ebp),%eax
110679: 50 push %eax
11067a: e8 e9 6d ff ff call 107468 <gettimeofday>
11067f: 8b 45 f0 mov -0x10(%ebp),%eax
110682: 89 43 48 mov %eax,0x48(%ebx)
/*
* The file cannot be open and the link must be less than 1 to free.
*/
if ( !rtems_libio_is_file_open( the_jnode ) && (the_jnode->st_nlink < 1) ) {
110685: 89 1c 24 mov %ebx,(%esp)
110688: e8 13 6f ff ff call 1075a0 <rtems_libio_is_file_open>
11068d: 83 c4 10 add $0x10,%esp
110690: 85 c0 test %eax,%eax
110692: 75 2b jne 1106bf <imfs_dir_rmnod+0xaa>
110694: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx)
110699: 75 24 jne 1106bf <imfs_dir_rmnod+0xaa>
/*
* Is the rtems_filesystem_current is this node?
*/
if ( rtems_filesystem_current.node_access == pathloc->node_access )
11069b: 8b 15 cc f3 11 00 mov 0x11f3cc,%edx
1106a1: 8b 42 04 mov 0x4(%edx),%eax
1106a4: 3b 06 cmp (%esi),%eax
1106a6: 75 07 jne 1106af <imfs_dir_rmnod+0x9a> <== ALWAYS TAKEN
rtems_filesystem_current.node_access = NULL;
1106a8: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED
/*
* Free memory associated with a memory file.
*/
free( the_jnode );
1106af: 83 ec 0c sub $0xc,%esp
1106b2: 53 push %ebx
1106b3: e8 40 6c ff ff call 1072f8 <free>
1106b8: 31 c0 xor %eax,%eax
1106ba: 83 c4 10 add $0x10,%esp
1106bd: eb 02 jmp 1106c1 <imfs_dir_rmnod+0xac>
1106bf: 31 c0 xor %eax,%eax
}
return 0;
}
1106c1: 8d 65 f8 lea -0x8(%ebp),%esp
1106c4: 5b pop %ebx
1106c5: 5e pop %esi
1106c6: c9 leave
1106c7: c3 ret
0010f8e0 <ioctl>:
int ioctl(
int fd,
ioctl_command_t command,
...
)
{
10f8e0: 55 push %ebp
10f8e1: 89 e5 mov %esp,%ebp
10f8e3: 83 ec 08 sub $0x8,%esp
10f8e6: 8b 45 08 mov 0x8(%ebp),%eax
va_list ap;
rtems_status_code rc;
rtems_libio_t *iop;
void *buffer;
rtems_libio_check_fd( fd );
10f8e9: 3b 05 38 f0 11 00 cmp 0x11f038,%eax
10f8ef: 73 19 jae 10f90a <ioctl+0x2a> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
10f8f1: 6b c0 34 imul $0x34,%eax,%eax
10f8f4: 03 05 a8 3b 12 00 add 0x123ba8,%eax
rtems_libio_check_is_open(iop);
10f8fa: f6 40 0d 01 testb $0x1,0xd(%eax)
10f8fe: 74 0a je 10f90a <ioctl+0x2a> <== NEVER TAKEN
va_start(ap, command);
buffer = va_arg(ap, void *);
10f900: 8b 4d 10 mov 0x10(%ebp),%ecx
/*
* Now process the ioctl().
*/
if ( !iop->handlers )
10f903: 8b 50 30 mov 0x30(%eax),%edx
10f906: 85 d2 test %edx,%edx
10f908: 75 0d jne 10f917 <ioctl+0x37> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EBADF );
10f90a: e8 e9 29 00 00 call 1122f8 <__errno> <== NOT EXECUTED
10f90f: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
10f915: eb 12 jmp 10f929 <ioctl+0x49> <== NOT EXECUTED
if ( !iop->handlers->ioctl_h )
10f917: 8b 52 10 mov 0x10(%edx),%edx
10f91a: 85 d2 test %edx,%edx
10f91c: 75 10 jne 10f92e <ioctl+0x4e> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
10f91e: e8 d5 29 00 00 call 1122f8 <__errno> <== NOT EXECUTED
10f923: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10f929: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10f92c: eb 0d jmp 10f93b <ioctl+0x5b> <== NOT EXECUTED
rc = (*iop->handlers->ioctl_h)( iop, command, buffer );
10f92e: 83 ec 04 sub $0x4,%esp
10f931: 51 push %ecx
10f932: ff 75 0c pushl 0xc(%ebp)
10f935: 50 push %eax
10f936: ff d2 call *%edx
10f938: 83 c4 10 add $0x10,%esp
return rc;
}
10f93b: c9 leave
10f93c: c3 ret
00107a7c <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
107a7c: 55 push %ebp <== NOT EXECUTED
107a7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107a7f: 56 push %esi <== NOT EXECUTED
107a80: 53 push %ebx <== NOT EXECUTED
107a81: 89 d6 mov %edx,%esi <== NOT EXECUTED
107a83: 88 c3 mov %al,%bl <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP)
107a85: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED
107a88: f6 c1 20 test $0x20,%cl <== NOT EXECUTED
107a8b: 74 03 je 107a90 <iproc+0x14> <== NOT EXECUTED
c &= 0x7f;
107a8d: 83 e3 7f and $0x7f,%ebx <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
107a90: f6 c5 02 test $0x2,%ch <== NOT EXECUTED
107a93: 74 13 je 107aa8 <iproc+0x2c> <== NOT EXECUTED
c = tolower (c);
107a95: 0f b6 d3 movzbl %bl,%edx <== NOT EXECUTED
107a98: a1 00 b7 11 00 mov 0x11b700,%eax <== NOT EXECUTED
107a9d: f6 04 10 01 testb $0x1,(%eax,%edx,1) <== NOT EXECUTED
107aa1: 74 03 je 107aa6 <iproc+0x2a> <== NOT EXECUTED
107aa3: 83 c2 20 add $0x20,%edx <== NOT EXECUTED
107aa6: 88 d3 mov %dl,%bl <== NOT EXECUTED
if (c == '\r') {
107aa8: 80 fb 0d cmp $0xd,%bl <== NOT EXECUTED
107aab: 75 11 jne 107abe <iproc+0x42> <== NOT EXECUTED
if (tty->termios.c_iflag & IGNCR)
107aad: 84 c9 test %cl,%cl <== NOT EXECUTED
107aaf: 0f 88 c9 00 00 00 js 107b7e <iproc+0x102> <== NOT EXECUTED
return 0;
if (tty->termios.c_iflag & ICRNL)
107ab5: 80 e5 01 and $0x1,%ch <== NOT EXECUTED
107ab8: 74 1c je 107ad6 <iproc+0x5a> <== NOT EXECUTED
107aba: b3 0a mov $0xa,%bl <== NOT EXECUTED
107abc: eb 18 jmp 107ad6 <iproc+0x5a> <== NOT EXECUTED
c = '\n';
}
else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
107abe: 80 fb 0a cmp $0xa,%bl <== NOT EXECUTED
107ac1: 75 0b jne 107ace <iproc+0x52> <== NOT EXECUTED
107ac3: 80 e1 40 and $0x40,%cl <== NOT EXECUTED
107ac6: 0f 85 b8 00 00 00 jne 107b84 <iproc+0x108> <== NOT EXECUTED
107acc: eb 08 jmp 107ad6 <iproc+0x5a> <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
107ace: 84 db test %bl,%bl <== NOT EXECUTED
107ad0: 0f 84 80 00 00 00 je 107b56 <iproc+0xda> <== NOT EXECUTED
107ad6: 8b 56 3c mov 0x3c(%esi),%edx <== NOT EXECUTED
107ad9: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
107adc: 74 78 je 107b56 <iproc+0xda> <== NOT EXECUTED
if (c == tty->termios.c_cc[VERASE]) {
107ade: 3a 5e 43 cmp 0x43(%esi),%bl <== NOT EXECUTED
107ae1: 75 04 jne 107ae7 <iproc+0x6b> <== NOT EXECUTED
erase (tty, 0);
107ae3: 31 d2 xor %edx,%edx <== NOT EXECUTED
107ae5: eb 0a jmp 107af1 <iproc+0x75> <== NOT EXECUTED
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
107ae7: 3a 5e 44 cmp 0x44(%esi),%bl <== NOT EXECUTED
107aea: 75 11 jne 107afd <iproc+0x81> <== NOT EXECUTED
erase (tty, 1);
107aec: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED
107af1: 89 f0 mov %esi,%eax <== NOT EXECUTED
107af3: e8 17 fe ff ff call 10790f <erase> <== NOT EXECUTED
107af8: e9 81 00 00 00 jmp 107b7e <iproc+0x102> <== NOT EXECUTED
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
107afd: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
107b02: 3a 5e 45 cmp 0x45(%esi),%bl <== NOT EXECUTED
107b05: 74 79 je 107b80 <iproc+0x104> <== NOT EXECUTED
return 1;
}
else if (c == '\n') {
107b07: 80 fb 0a cmp $0xa,%bl <== NOT EXECUTED
107b0a: 75 1d jne 107b29 <iproc+0xad> <== NOT EXECUTED
if (tty->termios.c_lflag & (ECHO | ECHONL))
107b0c: 80 e2 48 and $0x48,%dl <== NOT EXECUTED
107b0f: 74 0c je 107b1d <iproc+0xa1> <== NOT EXECUTED
echo (c, tty);
107b11: 89 f2 mov %esi,%edx <== NOT EXECUTED
107b13: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
107b18: e8 9a fd ff ff call 1078b7 <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
107b1d: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED
107b20: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED
107b23: c6 04 02 0a movb $0xa,(%edx,%eax,1) <== NOT EXECUTED
107b27: eb 22 jmp 107b4b <iproc+0xcf> <== NOT EXECUTED
return 1;
}
else if ((c == tty->termios.c_cc[VEOL])
107b29: 3a 5e 4c cmp 0x4c(%esi),%bl <== NOT EXECUTED
107b2c: 74 05 je 107b33 <iproc+0xb7> <== NOT EXECUTED
107b2e: 3a 5e 51 cmp 0x51(%esi),%bl <== NOT EXECUTED
107b31: 75 23 jne 107b56 <iproc+0xda> <== NOT EXECUTED
|| (c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
107b33: 80 e2 08 and $0x8,%dl <== NOT EXECUTED
107b36: 74 0a je 107b42 <iproc+0xc6> <== NOT EXECUTED
echo (c, tty);
107b38: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED
107b3b: 89 f2 mov %esi,%edx <== NOT EXECUTED
107b3d: e8 75 fd ff ff call 1078b7 <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
107b42: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED
107b45: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED
107b48: 88 1c 02 mov %bl,(%edx,%eax,1) <== NOT EXECUTED
107b4b: 40 inc %eax <== NOT EXECUTED
107b4c: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED
107b4f: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
107b54: eb 2a jmp 107b80 <iproc+0x104> <== NOT EXECUTED
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
107b56: a1 3c b6 11 00 mov 0x11b63c,%eax <== NOT EXECUTED
107b5b: 48 dec %eax <== NOT EXECUTED
107b5c: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED
107b5f: 7d 1d jge 107b7e <iproc+0x102> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO)
107b61: f6 46 3c 08 testb $0x8,0x3c(%esi) <== NOT EXECUTED
107b65: 74 0a je 107b71 <iproc+0xf5> <== NOT EXECUTED
echo (c, tty);
107b67: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED
107b6a: 89 f2 mov %esi,%edx <== NOT EXECUTED
107b6c: e8 46 fd ff ff call 1078b7 <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
107b71: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED
107b74: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED
107b77: 88 1c 02 mov %bl,(%edx,%eax,1) <== NOT EXECUTED
107b7a: 40 inc %eax <== NOT EXECUTED
107b7b: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED
107b7e: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
return 0;
}
107b80: 5b pop %ebx <== NOT EXECUTED
107b81: 5e pop %esi <== NOT EXECUTED
107b82: c9 leave <== NOT EXECUTED
107b83: c3 ret <== NOT EXECUTED
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
107b84: b3 0d mov $0xd,%bl <== NOT EXECUTED
107b86: e9 4b ff ff ff jmp 107ad6 <iproc+0x5a> <== NOT EXECUTED
001155dc <isatty>:
#include <sys/stat.h>
int isatty(
int fd
)
{
1155dc: 55 push %ebp
1155dd: 89 e5 mov %esp,%ebp
1155df: 83 ec 60 sub $0x60,%esp
struct stat buf;
if (fstat (fd, &buf) < 0)
1155e2: 8d 45 b4 lea -0x4c(%ebp),%eax
1155e5: 50 push %eax
1155e6: ff 75 08 pushl 0x8(%ebp)
1155e9: e8 4a ff ff ff call 115538 <fstat>
1155ee: 83 c4 10 add $0x10,%esp
1155f1: 31 d2 xor %edx,%edx
1155f3: 85 c0 test %eax,%eax
1155f5: 78 12 js 115609 <isatty+0x2d> <== NEVER TAKEN
1155f7: 8b 45 c0 mov -0x40(%ebp),%eax
1155fa: 25 00 f0 00 00 and $0xf000,%eax
1155ff: 31 d2 xor %edx,%edx
115601: 3d 00 20 00 00 cmp $0x2000,%eax
115606: 0f 94 c2 sete %dl
if (S_ISCHR (buf.st_mode))
return 1;
return 0;
}
115609: 89 d0 mov %edx,%eax
11560b: c9 leave
11560c: c3 ret
0011841c <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
11841c: 55 push %ebp
11841d: 89 e5 mov %esp,%ebp
11841f: 57 push %edi
118420: 56 push %esi
118421: 53 push %ebx
118422: 83 ec 2c sub $0x2c,%esp
118425: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
118428: e8 7f fc ff ff call 1180ac <getpid>
11842d: 39 45 08 cmp %eax,0x8(%ebp)
118430: 74 0d je 11843f <killinfo+0x23> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ESRCH );
118432: e8 e5 81 ff ff call 11061c <__errno> <== NOT EXECUTED
118437: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED
11843d: eb 11 jmp 118450 <killinfo+0x34> <== NOT EXECUTED
/*
* Validate the signal passed.
*/
if ( !sig )
11843f: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
118443: 75 13 jne 118458 <killinfo+0x3c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
118445: e8 d2 81 ff ff call 11061c <__errno> <== NOT EXECUTED
11844a: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
118450: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED
118453: e9 05 02 00 00 jmp 11865d <killinfo+0x241> <== NOT EXECUTED
if ( !is_valid_signo(sig) )
118458: 8b 4d 0c mov 0xc(%ebp),%ecx
11845b: 49 dec %ecx
11845c: 83 f9 1f cmp $0x1f,%ecx
11845f: 77 e4 ja 118445 <killinfo+0x29> <== NEVER TAKEN
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
118461: 6b 45 0c 0c imul $0xc,0xc(%ebp),%eax
118465: 31 d2 xor %edx,%edx
118467: 83 b8 88 98 12 00 01 cmpl $0x1,0x129888(%eax)
11846e: 0f 84 e9 01 00 00 je 11865d <killinfo+0x241>
* 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 ) )
118474: 83 7d 0c 08 cmpl $0x8,0xc(%ebp)
118478: 74 0c je 118486 <killinfo+0x6a>
11847a: 83 7d 0c 04 cmpl $0x4,0xc(%ebp)
11847e: 74 06 je 118486 <killinfo+0x6a>
118480: 83 7d 0c 0b cmpl $0xb,0xc(%ebp)
118484: 75 1a jne 1184a0 <killinfo+0x84>
return pthread_kill( pthread_self(), sig );
118486: e8 99 03 00 00 call 118824 <pthread_self>
11848b: 53 push %ebx
11848c: 53 push %ebx
11848d: ff 75 0c pushl 0xc(%ebp)
118490: 50 push %eax
118491: e8 e6 02 00 00 call 11877c <pthread_kill>
118496: 89 c2 mov %eax,%edx
118498: 83 c4 10 add $0x10,%esp
11849b: e9 bd 01 00 00 jmp 11865d <killinfo+0x241>
mask = signo_to_mask( sig );
1184a0: bb 01 00 00 00 mov $0x1,%ebx
1184a5: d3 e3 shl %cl,%ebx
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
1184a7: 8b 45 0c mov 0xc(%ebp),%eax
1184aa: 89 45 e8 mov %eax,-0x18(%ebp)
siginfo->si_code = SI_USER;
1184ad: c7 45 ec 01 00 00 00 movl $0x1,-0x14(%ebp)
if ( !value ) {
1184b4: 85 f6 test %esi,%esi
1184b6: 75 09 jne 1184c1 <killinfo+0xa5>
siginfo->si_value.sival_int = 0;
1184b8: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
1184bf: eb 05 jmp 1184c6 <killinfo+0xaa>
} else {
siginfo->si_value = *value;
1184c1: 8b 06 mov (%esi),%eax
1184c3: 89 45 f0 mov %eax,-0x10(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
1184c6: a1 94 92 12 00 mov 0x129294,%eax
1184cb: 40 inc %eax
1184cc: a3 94 92 12 00 mov %eax,0x129294
/*
* 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;
1184d1: 8b 35 54 93 12 00 mov 0x129354,%esi
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
1184d7: 8b 86 f8 00 00 00 mov 0xf8(%esi),%eax
1184dd: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax
1184e3: f7 d0 not %eax
1184e5: 85 c3 test %eax,%ebx
1184e7: 0f 85 f4 00 00 00 jne 1185e1 <killinfo+0x1c5>
goto process_it;
1184ed: b9 0c 9a 12 00 mov $0x129a0c,%ecx
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ];
for ( the_node = the_chain->first ;
1184f2: 8b 11 mov (%ecx),%edx
_Context_Restore_fp( &_Thread_Executing->fp_context );
#endif
_CPU_Context_Restart_self( &_Thread_Executing->Registers );
}
1184f4: 8d 79 04 lea 0x4(%ecx),%edi
1184f7: eb 23 jmp 11851c <killinfo+0x100>
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
1184f9: 89 d6 mov %edx,%esi
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
1184fb: 8b 82 f8 00 00 00 mov 0xf8(%edx),%eax
if ((the_thread->Wait.option & mask) || (~api->signals_blocked & mask)) {
118501: 85 5a 30 test %ebx,0x30(%edx)
118504: 0f 85 d7 00 00 00 jne 1185e1 <killinfo+0x1c5> <== ALWAYS TAKEN
11850a: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED
118510: f7 d0 not %eax <== NOT EXECUTED
118512: 85 c3 test %eax,%ebx <== NOT EXECUTED
118514: 0f 85 c7 00 00 00 jne 1185e1 <killinfo+0x1c5> <== NOT EXECUTED
the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ];
for ( the_node = the_chain->first ;
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
11851a: 8b 12 mov (%edx),%edx <== NOT EXECUTED
index++ ) {
the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ];
for ( the_node = the_chain->first ;
!_Chain_Is_tail( the_chain, the_node ) ;
11851c: 39 fa cmp %edi,%edx
11851e: 75 d9 jne 1184f9 <killinfo+0xdd>
118520: 83 c1 0c add $0xc,%ecx
*/
/* XXX violation of visibility -- need to define thread queue support */
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
118523: 81 f9 3c 9a 12 00 cmp $0x129a3c,%ecx
118529: 75 c7 jne 1184f2 <killinfo+0xd6>
*
* + rtems internal threads do not receive signals.
*/
interested_thread = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
11852b: 0f b6 05 e4 d0 11 00 movzbl 0x11d0e4,%eax
118532: 40 inc %eax
118533: 89 45 e0 mov %eax,-0x20(%ebp)
118536: c7 45 d0 02 00 00 00 movl $0x2,-0x30(%ebp)
11853d: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
the_api++ ) {
/*
* Thie can occur when no one is interested and ITRON is not configured.
*/
if ( !_Objects_Information_table[ the_api ] )
118544: 8b 55 d0 mov -0x30(%ebp),%edx
118547: 8b 04 95 68 92 12 00 mov 0x129268(,%edx,4),%eax
11854e: 85 c0 test %eax,%eax
118550: 74 79 je 1185cb <killinfo+0x1af>
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
118552: 8b 40 04 mov 0x4(%eax),%eax
/*
* This cannot happen in the current (as of Dec 2007) implementation
* of initialization but at some point, the object information
* structure for a particular manager may not be installed.
*/
if ( !the_info )
118555: 85 c0 test %eax,%eax
118557: 74 72 je 1185cb <killinfo+0x1af> <== NEVER TAKEN
continue;
maximum = the_info->maximum;
118559: 0f b7 50 10 movzwl 0x10(%eax),%edx
11855d: 89 55 d4 mov %edx,-0x2c(%ebp)
object_table = the_info->local_table;
118560: 8b 40 1c mov 0x1c(%eax),%eax
118563: 89 45 d8 mov %eax,-0x28(%ebp)
118566: bf 01 00 00 00 mov $0x1,%edi
11856b: eb 59 jmp 1185c6 <killinfo+0x1aa>
for ( index = 1 ; index <= maximum ; index++ ) {
the_thread = (Thread_Control *) object_table[ index ];
11856d: 8b 45 d8 mov -0x28(%ebp),%eax
118570: 8b 14 b8 mov (%eax,%edi,4),%edx
if ( !the_thread )
118573: 85 d2 test %edx,%edx
118575: 74 43 je 1185ba <killinfo+0x19e>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
118577: 8b 72 14 mov 0x14(%edx),%esi
11857a: 3b 75 e0 cmp -0x20(%ebp),%esi
11857d: 77 3b ja 1185ba <killinfo+0x19e> <== NEVER TAKEN
/*
* If this thread is not interested, then go on to the next thread.
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
11857f: 8b 82 f8 00 00 00 mov 0xf8(%edx),%eax
if ( !api || !_POSIX_signals_Is_interested( api, mask ) )
118585: 85 c0 test %eax,%eax
118587: 74 31 je 1185ba <killinfo+0x19e> <== NEVER TAKEN
118589: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax
11858f: f7 d0 not %eax
118591: 85 c3 test %eax,%ebx
118593: 74 25 je 1185ba <killinfo+0x19e>
* Now we know the thread under connsideration is interested.
* If the thread under consideration is of higher priority, then
* it becomes the interested thread.
*/
if ( the_thread->current_priority < interested_priority ) {
118595: 3b 75 e0 cmp -0x20(%ebp),%esi
118598: 72 25 jb 1185bf <killinfo+0x1a3> <== ALWAYS TAKEN
* Now the thread and the interested thread have the same priority.
* If the interested thread is ready, then we don't need to send it
* to a blocked thread.
*/
if ( _States_Is_ready( interested_thread->current_state ) )
11859a: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED
11859d: 8b 48 10 mov 0x10(%eax),%ecx <== NOT EXECUTED
1185a0: 85 c9 test %ecx,%ecx <== NOT EXECUTED
1185a2: 74 16 je 1185ba <killinfo+0x19e> <== NOT EXECUTED
* Now the interested thread is blocked.
* If the thread we are considering is not, the it becomes the
* interested thread.
*/
if ( _States_Is_ready( the_thread->current_state ) ) {
1185a4: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED
1185a7: 85 c0 test %eax,%eax <== NOT EXECUTED
1185a9: 74 14 je 1185bf <killinfo+0x1a3> <== NOT EXECUTED
* Now we know both threads are blocked.
* If the interested thread is interruptible, then just use it.
*/
/* XXX need a new states macro */
if ( interested_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL )
1185ab: 81 e1 00 00 00 10 and $0x10000000,%ecx <== NOT EXECUTED
1185b1: 75 07 jne 1185ba <killinfo+0x19e> <== NOT EXECUTED
* If the thread under consideration is interruptible by a signal,
* then it becomes the interested thread.
*/
/* XXX need a new states macro */
if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) {
1185b3: a9 00 00 00 10 test $0x10000000,%eax <== NOT EXECUTED
1185b8: 75 05 jne 1185bf <killinfo+0x1a3> <== NOT EXECUTED
1185ba: 8b 75 e0 mov -0x20(%ebp),%esi
1185bd: eb 03 jmp 1185c2 <killinfo+0x1a6>
1185bf: 89 55 dc mov %edx,-0x24(%ebp)
continue;
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
1185c2: 47 inc %edi
1185c3: 89 75 e0 mov %esi,-0x20(%ebp)
1185c6: 3b 7d d4 cmp -0x2c(%ebp),%edi
1185c9: 76 a2 jbe 11856d <killinfo+0x151>
interested_thread = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
for ( the_api = OBJECTS_CLASSIC_API;
the_api <= OBJECTS_APIS_LAST;
the_api++ ) {
1185cb: ff 45 d0 incl -0x30(%ebp)
interested_thread = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
for ( the_api = OBJECTS_CLASSIC_API;
the_api <= OBJECTS_APIS_LAST;
1185ce: 83 7d d0 05 cmpl $0x5,-0x30(%ebp)
1185d2: 0f 85 6c ff ff ff jne 118544 <killinfo+0x128>
interested_priority = the_thread->current_priority;
}
}
}
if ( interested_thread ) {
1185d8: 83 7d dc 00 cmpl $0x0,-0x24(%ebp)
1185dc: 74 1c je 1185fa <killinfo+0x1de>
1185de: 8b 75 dc mov -0x24(%ebp),%esi
* evaluate the signals pending.
*/
process_it:
the_thread->do_post_task_switch_extension = true;
1185e1: c6 46 75 01 movb $0x1,0x75(%esi)
/*
* 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 ) ) {
1185e5: 51 push %ecx
1185e6: 8d 45 e8 lea -0x18(%ebp),%eax
1185e9: 50 push %eax
1185ea: ff 75 0c pushl 0xc(%ebp)
1185ed: 56 push %esi
1185ee: e8 99 00 00 00 call 11868c <_POSIX_signals_Unblock_thread>
1185f3: 83 c4 10 add $0x10,%esp
1185f6: 84 c0 test %al,%al
1185f8: 75 5c jne 118656 <killinfo+0x23a>
/*
* 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 );
1185fa: 83 ec 0c sub $0xc,%esp
1185fd: 53 push %ebx
1185fe: e8 65 00 00 00 call 118668 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
118603: 6b 5d 0c 0c imul $0xc,0xc(%ebp),%ebx
118607: 83 c4 10 add $0x10,%esp
11860a: 83 bb 80 98 12 00 02 cmpl $0x2,0x129880(%ebx)
118611: 75 43 jne 118656 <killinfo+0x23a>
psiginfo = (POSIX_signals_Siginfo_node *)
118613: 83 ec 0c sub $0xc,%esp
118616: 68 00 9a 12 00 push $0x129a00
11861b: e8 90 26 ff ff call 10acb0 <_Chain_Get>
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
118620: 83 c4 10 add $0x10,%esp
118623: 85 c0 test %eax,%eax
118625: 75 10 jne 118637 <killinfo+0x21b> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EAGAIN );
118627: e8 f0 7f ff ff call 11061c <__errno> <== NOT EXECUTED
11862c: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
118632: e9 19 fe ff ff jmp 118450 <killinfo+0x34> <== NOT EXECUTED
}
psiginfo->Info = *siginfo;
118637: 8d 78 08 lea 0x8(%eax),%edi
11863a: 8d 75 e8 lea -0x18(%ebp),%esi
11863d: b9 03 00 00 00 mov $0x3,%ecx
118642: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
118644: 52 push %edx
118645: 52 push %edx
118646: 50 push %eax
118647: 8d 83 50 9a 12 00 lea 0x129a50(%ebx),%eax
11864d: 50 push %eax
11864e: e8 39 26 ff ff call 10ac8c <_Chain_Append>
118653: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
118656: e8 b1 3b ff ff call 10c20c <_Thread_Enable_dispatch>
11865b: 31 d2 xor %edx,%edx
return 0;
}
11865d: 89 d0 mov %edx,%eax
11865f: 8d 65 f4 lea -0xc(%ebp),%esp
118662: 5b pop %ebx
118663: 5e pop %esi
118664: 5f pop %edi
118665: c9 leave
118666: c3 ret
00106844 <libc_delete_hook>:
rtems_extension libc_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
106844: 55 push %ebp
106845: 89 e5 mov %esp,%ebp
106847: 57 push %edi
106848: 56 push %esi
106849: 53 push %ebx
10684a: 83 ec 0c sub $0xc,%esp
10684d: 8b 7d 08 mov 0x8(%ebp),%edi
106850: 8b 75 0c mov 0xc(%ebp),%esi
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
106853: 39 f7 cmp %esi,%edi
106855: 75 08 jne 10685f <libc_delete_hook+0x1b>
ptr = _REENT;
106857: 8b 1d 20 b7 11 00 mov 0x11b720,%ebx
10685d: eb 06 jmp 106865 <libc_delete_hook+0x21>
} else {
ptr = deleted_task->libc_reent;
10685f: 8b 9e f0 00 00 00 mov 0xf0(%esi),%ebx
}
if (ptr && ptr != &libc_global_reent) {
106865: 85 db test %ebx,%ebx
106867: 74 20 je 106889 <libc_delete_hook+0x45> <== NEVER TAKEN
106869: 81 fb 38 b2 11 00 cmp $0x11b238,%ebx
10686f: 74 18 je 106889 <libc_delete_hook+0x45>
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
106871: 50 push %eax
106872: 50 push %eax
106873: 68 a9 68 10 00 push $0x1068a9
106878: 53 push %ebx
106879: e8 62 8f 00 00 call 10f7e0 <_fwalk>
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
10687e: 89 1c 24 mov %ebx,(%esp)
106881: e8 8e 55 00 00 call 10be14 <_Workspace_Free>
106886: 83 c4 10 add $0x10,%esp
#endif
}
deleted_task->libc_reent = NULL;
106889: c7 86 f0 00 00 00 00 movl $0x0,0xf0(%esi)
106890: 00 00 00
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
106893: 39 f7 cmp %esi,%edi
106895: 75 0a jne 1068a1 <libc_delete_hook+0x5d>
_REENT = 0;
106897: c7 05 20 b7 11 00 00 movl $0x0,0x11b720
10689e: 00 00 00
}
}
1068a1: 8d 65 f4 lea -0xc(%ebp),%esp
1068a4: 5b pop %ebx
1068a5: 5e pop %esi
1068a6: 5f pop %edi
1068a7: c9 leave
1068a8: c3 ret
001156d4 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
1156d4: 55 push %ebp
1156d5: 89 e5 mov %esp,%ebp
1156d7: 83 ec 08 sub $0x8,%esp
/*
* In case RTEMS is already down, don't do this. It could be
* dangerous.
*/
if (!_System_state_Is_up(_System_state_Get()))
1156da: 83 3d 38 d9 11 00 03 cmpl $0x3,0x11d938
1156e1: 75 55 jne 115738 <libc_wrapup+0x64> <== NEVER TAKEN
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != &libc_global_reent) {
1156e3: 81 3d 20 b7 11 00 38 cmpl $0x11b238,0x11b720
1156ea: b2 11 00
1156ed: 74 1a je 115709 <libc_wrapup+0x35>
_wrapup_reent(&libc_global_reent);
1156ef: 83 ec 0c sub $0xc,%esp
1156f2: 68 38 b2 11 00 push $0x11b238
1156f7: e8 b8 05 00 00 call 115cb4 <_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 = &libc_global_reent;
1156fc: c7 05 20 b7 11 00 38 movl $0x11b238,0x11b720
115703: b2 11 00
115706: 83 c4 10 add $0x10,%esp
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
115709: 83 ec 0c sub $0xc,%esp
11570c: a1 20 b7 11 00 mov 0x11b720,%eax
115711: ff 70 04 pushl 0x4(%eax)
115714: e8 5b 9b ff ff call 10f274 <fclose>
fclose (stdout);
115719: 5a pop %edx
11571a: a1 20 b7 11 00 mov 0x11b720,%eax
11571f: ff 70 08 pushl 0x8(%eax)
115722: e8 4d 9b ff ff call 10f274 <fclose>
fclose (stderr);
115727: 58 pop %eax
115728: a1 20 b7 11 00 mov 0x11b720,%eax
11572d: ff 70 0c pushl 0xc(%eax)
115730: e8 3f 9b ff ff call 10f274 <fclose>
115735: 83 c4 10 add $0x10,%esp
}
115738: c9 leave
115739: c3 ret
001079d8 <link>:
int link(
const char *existing,
const char *new
)
{
1079d8: 55 push %ebp
1079d9: 89 e5 mov %esp,%ebp
1079db: 57 push %edi
1079dc: 56 push %esi
1079dd: 53 push %ebx
1079de: 83 ec 3c sub $0x3c,%esp
1079e1: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Get the node we are linking to.
*/
result = rtems_filesystem_evaluate_path( existing, 0, &existing_loc, true );
1079e4: 6a 01 push $0x1
1079e6: 8d 45 e0 lea -0x20(%ebp),%eax
1079e9: 50 push %eax
1079ea: 6a 00 push $0x0
1079ec: ff 75 08 pushl 0x8(%ebp)
1079ef: e8 3e fb ff ff call 107532 <rtems_filesystem_evaluate_path>
if ( result != 0 )
1079f4: 83 c4 10 add $0x10,%esp
1079f7: 83 ce ff or $0xffffffff,%esi
1079fa: 85 c0 test %eax,%eax
1079fc: 0f 85 7a 01 00 00 jne 107b7c <link+0x1a4>
/*
* Get the parent of the node we are creating.
*/
rtems_filesystem_get_start_loc( new, &i, &parent_loc );
107a02: 8a 03 mov (%ebx),%al
107a04: 3c 2f cmp $0x2f,%al
107a06: 74 08 je 107a10 <link+0x38>
107a08: 3c 5c cmp $0x5c,%al
107a0a: 74 04 je 107a10 <link+0x38> <== NEVER TAKEN
107a0c: 84 c0 test %al,%al
107a0e: 75 16 jne 107a26 <link+0x4e> <== ALWAYS TAKEN
107a10: 8d 7d d0 lea -0x30(%ebp),%edi
107a13: a1 4c 09 12 00 mov 0x12094c,%eax
107a18: 8d 70 14 lea 0x14(%eax),%esi
107a1b: b9 04 00 00 00 mov $0x4,%ecx
107a20: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
107a22: b1 01 mov $0x1,%cl
107a24: eb 12 jmp 107a38 <link+0x60>
107a26: 8d 7d d0 lea -0x30(%ebp),%edi
107a29: a1 4c 09 12 00 mov 0x12094c,%eax
107a2e: 8d 70 04 lea 0x4(%eax),%esi
107a31: b9 04 00 00 00 mov $0x4,%ecx
107a36: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !parent_loc.ops->evalformake_h ) {
107a38: 8b 45 d8 mov -0x28(%ebp),%eax
107a3b: 8b 50 04 mov 0x4(%eax),%edx
107a3e: 85 d2 test %edx,%edx
107a40: 75 21 jne 107a63 <link+0x8b> <== ALWAYS TAKEN
rtems_filesystem_freenode( &existing_loc );
107a42: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED
107a45: 85 c0 test %eax,%eax <== NOT EXECUTED
107a47: 0f 84 de 00 00 00 je 107b2b <link+0x153> <== NOT EXECUTED
107a4d: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED
107a50: 85 d2 test %edx,%edx <== NOT EXECUTED
107a52: 0f 84 d3 00 00 00 je 107b2b <link+0x153> <== NOT EXECUTED
107a58: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107a5b: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED
107a5e: e9 c2 00 00 00 jmp 107b25 <link+0x14d> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start );
107a63: 56 push %esi
107a64: 8d 45 f0 lea -0x10(%ebp),%eax
107a67: 50 push %eax
107a68: 8d 7d d0 lea -0x30(%ebp),%edi
107a6b: 57 push %edi
107a6c: 8d 04 0b lea (%ebx,%ecx,1),%eax
107a6f: 50 push %eax
107a70: ff d2 call *%edx
107a72: 89 c6 mov %eax,%esi
if ( result != 0 ) {
107a74: 83 c4 10 add $0x10,%esp
107a77: 85 c0 test %eax,%eax
107a79: 74 29 je 107aa4 <link+0xcc>
rtems_filesystem_freenode( &existing_loc );
107a7b: 8b 45 e8 mov -0x18(%ebp),%eax
107a7e: 85 c0 test %eax,%eax
107a80: 74 13 je 107a95 <link+0xbd> <== NEVER TAKEN
107a82: 8b 50 1c mov 0x1c(%eax),%edx
107a85: 85 d2 test %edx,%edx
107a87: 74 0c je 107a95 <link+0xbd> <== NEVER TAKEN
107a89: 83 ec 0c sub $0xc,%esp
107a8c: 8d 45 e0 lea -0x20(%ebp),%eax
107a8f: 50 push %eax
107a90: ff d2 call *%edx
107a92: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( result );
107a95: e8 16 9b 00 00 call 1115b0 <__errno>
107a9a: 89 30 mov %esi,(%eax)
107a9c: 83 ce ff or $0xffffffff,%esi
107a9f: e9 d8 00 00 00 jmp 107b7c <link+0x1a4>
/*
* Check to see if the caller is trying to link across file system
* boundaries.
*/
if ( parent_loc.mt_entry != existing_loc.mt_entry ) {
107aa4: 8b 45 dc mov -0x24(%ebp),%eax
107aa7: 3b 45 ec cmp -0x14(%ebp),%eax
107aaa: 74 41 je 107aed <link+0x115>
rtems_filesystem_freenode( &existing_loc );
107aac: 8b 45 e8 mov -0x18(%ebp),%eax
107aaf: 85 c0 test %eax,%eax
107ab1: 74 13 je 107ac6 <link+0xee> <== NEVER TAKEN
107ab3: 8b 50 1c mov 0x1c(%eax),%edx
107ab6: 85 d2 test %edx,%edx
107ab8: 74 0c je 107ac6 <link+0xee> <== NEVER TAKEN
107aba: 83 ec 0c sub $0xc,%esp
107abd: 8d 45 e0 lea -0x20(%ebp),%eax
107ac0: 50 push %eax
107ac1: ff d2 call *%edx
107ac3: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( &parent_loc );
107ac6: 8b 45 d8 mov -0x28(%ebp),%eax
107ac9: 85 c0 test %eax,%eax
107acb: 74 13 je 107ae0 <link+0x108> <== NEVER TAKEN
107acd: 8b 50 1c mov 0x1c(%eax),%edx
107ad0: 85 d2 test %edx,%edx
107ad2: 74 0c je 107ae0 <link+0x108> <== NEVER TAKEN
107ad4: 83 ec 0c sub $0xc,%esp
107ad7: 8d 45 d0 lea -0x30(%ebp),%eax
107ada: 50 push %eax
107adb: ff d2 call *%edx
107add: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( EXDEV );
107ae0: e8 cb 9a 00 00 call 1115b0 <__errno>
107ae5: c7 00 12 00 00 00 movl $0x12,(%eax)
107aeb: eb af jmp 107a9c <link+0xc4>
}
if ( !parent_loc.ops->link_h ) {
107aed: 8b 45 d8 mov -0x28(%ebp),%eax
107af0: 8b 40 08 mov 0x8(%eax),%eax
107af3: 85 c0 test %eax,%eax
107af5: 75 44 jne 107b3b <link+0x163> <== ALWAYS TAKEN
rtems_filesystem_freenode( &existing_loc );
107af7: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED
107afa: 85 c0 test %eax,%eax <== NOT EXECUTED
107afc: 74 13 je 107b11 <link+0x139> <== NOT EXECUTED
107afe: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED
107b01: 85 d2 test %edx,%edx <== NOT EXECUTED
107b03: 74 0c je 107b11 <link+0x139> <== NOT EXECUTED
107b05: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107b08: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED
107b0b: 50 push %eax <== NOT EXECUTED
107b0c: ff d2 call *%edx <== NOT EXECUTED
107b0e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_filesystem_freenode( &parent_loc );
107b11: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED
107b14: 85 c0 test %eax,%eax <== NOT EXECUTED
107b16: 74 13 je 107b2b <link+0x153> <== NOT EXECUTED
107b18: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED
107b1b: 85 d2 test %edx,%edx <== NOT EXECUTED
107b1d: 74 0c je 107b2b <link+0x153> <== NOT EXECUTED
107b1f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107b22: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED
107b25: 50 push %eax <== NOT EXECUTED
107b26: ff d2 call *%edx <== NOT EXECUTED
107b28: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
107b2b: e8 80 9a 00 00 call 1115b0 <__errno> <== NOT EXECUTED
107b30: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
107b36: e9 61 ff ff ff jmp 107a9c <link+0xc4> <== NOT EXECUTED
}
result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start );
107b3b: 52 push %edx
107b3c: ff 75 f0 pushl -0x10(%ebp)
107b3f: 57 push %edi
107b40: 8d 7d e0 lea -0x20(%ebp),%edi
107b43: 57 push %edi
107b44: ff d0 call *%eax
107b46: 89 c6 mov %eax,%esi
rtems_filesystem_freenode( &existing_loc );
107b48: 8b 45 e8 mov -0x18(%ebp),%eax
107b4b: 83 c4 10 add $0x10,%esp
107b4e: 85 c0 test %eax,%eax
107b50: 74 10 je 107b62 <link+0x18a> <== NEVER TAKEN
107b52: 8b 40 1c mov 0x1c(%eax),%eax
107b55: 85 c0 test %eax,%eax
107b57: 74 09 je 107b62 <link+0x18a> <== NEVER TAKEN
107b59: 83 ec 0c sub $0xc,%esp
107b5c: 57 push %edi
107b5d: ff d0 call *%eax
107b5f: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( &parent_loc );
107b62: 8b 45 d8 mov -0x28(%ebp),%eax
107b65: 85 c0 test %eax,%eax
107b67: 74 13 je 107b7c <link+0x1a4> <== NEVER TAKEN
107b69: 8b 50 1c mov 0x1c(%eax),%edx
107b6c: 85 d2 test %edx,%edx
107b6e: 74 0c je 107b7c <link+0x1a4> <== NEVER TAKEN
107b70: 83 ec 0c sub $0xc,%esp
107b73: 8d 45 d0 lea -0x30(%ebp),%eax
107b76: 50 push %eax
107b77: ff d2 call *%edx
107b79: 83 c4 10 add $0x10,%esp
return result;
}
107b7c: 89 f0 mov %esi,%eax
107b7e: 8d 65 f4 lea -0xc(%ebp),%esp
107b81: 5b pop %ebx
107b82: 5e pop %esi
107b83: 5f pop %edi
107b84: c9 leave
107b85: c3 ret
00115610 <lseek>:
off_t lseek(
int fd,
off_t offset,
int whence
)
{
115610: 55 push %ebp
115611: 89 e5 mov %esp,%ebp
115613: 56 push %esi
115614: 53 push %ebx
115615: 8b 45 08 mov 0x8(%ebp),%eax
115618: 8b 4d 0c mov 0xc(%ebp),%ecx
11561b: 8b 55 10 mov 0x10(%ebp),%edx
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
11561e: 3b 05 d8 92 11 00 cmp 0x1192d8,%eax
115624: 73 0f jae 115635 <lseek+0x25> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
115626: 6b d8 34 imul $0x34,%eax,%ebx
115629: 03 1d 38 d6 11 00 add 0x11d638,%ebx
rtems_libio_check_is_open(iop);
11562f: f6 43 0d 01 testb $0x1,0xd(%ebx)
115633: 75 0d jne 115642 <lseek+0x32> <== ALWAYS TAKEN
115635: e8 ee 9a ff ff call 10f128 <__errno> <== NOT EXECUTED
11563a: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
115640: eb 46 jmp 115688 <lseek+0x78> <== NOT EXECUTED
/*
* Check as many errors as possible before touching iop->offset.
*/
if ( !iop->handlers->lseek_h )
115642: 8b 43 30 mov 0x30(%ebx),%eax
115645: 83 78 14 00 cmpl $0x0,0x14(%eax)
115649: 75 0d jne 115658 <lseek+0x48> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
11564b: e8 d8 9a ff ff call 10f128 <__errno> <== NOT EXECUTED
115650: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
115656: eb 30 jmp 115688 <lseek+0x78> <== NOT EXECUTED
/*
* Now process the lseek().
*/
old_offset = iop->offset;
115658: 8b 73 08 mov 0x8(%ebx),%esi
switch ( whence ) {
11565b: 83 fa 01 cmp $0x1,%edx
11565e: 74 0e je 11566e <lseek+0x5e>
115660: 83 fa 02 cmp $0x2,%edx
115663: 74 0e je 115673 <lseek+0x63>
115665: 85 d2 test %edx,%edx
115667: 75 14 jne 11567d <lseek+0x6d>
case SEEK_SET:
iop->offset = offset;
115669: 89 4b 08 mov %ecx,0x8(%ebx)
11566c: eb 1f jmp 11568d <lseek+0x7d>
break;
case SEEK_CUR:
iop->offset += offset;
11566e: 8d 04 31 lea (%ecx,%esi,1),%eax
115671: eb 05 jmp 115678 <lseek+0x68>
break;
case SEEK_END:
iop->offset = iop->size + offset;
115673: 89 c8 mov %ecx,%eax
115675: 03 43 04 add 0x4(%ebx),%eax
115678: 89 43 08 mov %eax,0x8(%ebx)
11567b: eb 10 jmp 11568d <lseek+0x7d>
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
11567d: e8 a6 9a ff ff call 10f128 <__errno>
115682: c7 00 16 00 00 00 movl $0x16,(%eax)
115688: 83 c8 ff or $0xffffffff,%eax
11568b: eb 15 jmp 1156a2 <lseek+0x92>
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->handlers->lseek_h)( iop, offset, whence );
11568d: 50 push %eax
11568e: 8b 43 30 mov 0x30(%ebx),%eax
115691: 52 push %edx
115692: 51 push %ecx
115693: 53 push %ebx
115694: ff 50 14 call *0x14(%eax)
if ( status == (off_t) -1 )
115697: 83 c4 10 add $0x10,%esp
11569a: 83 f8 ff cmp $0xffffffff,%eax
11569d: 75 03 jne 1156a2 <lseek+0x92>
iop->offset = old_offset;
11569f: 89 73 08 mov %esi,0x8(%ebx)
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
1156a2: 8d 65 f8 lea -0x8(%ebp),%esp
1156a5: 5b pop %ebx
1156a6: 5e pop %esi
1156a7: c9 leave
1156a8: c3 ret
00106674 <malloc>:
size_t size
)
{
void *return_this;
MSBUMP(malloc_calls, 1);
106674: 55 push %ebp
106675: 89 e5 mov %esp,%ebp
106677: 56 push %esi
106678: 53 push %ebx
106679: 8b 75 08 mov 0x8(%ebp),%esi
10667c: ff 05 ac d6 11 00 incl 0x11d6ac
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
106682: e8 48 ff ff ff call 1065cf <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
106687: 85 f6 test %esi,%esi
106689: 74 75 je 106700 <malloc+0x8c> <== NEVER TAKEN
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
10668b: 83 3d 38 d9 11 00 03 cmpl $0x3,0x11d938
106692: 75 09 jne 10669d <malloc+0x29>
106694: e8 df fe ff ff call 106578 <malloc_is_system_state_OK>
106699: 84 c0 test %al,%al
10669b: 74 63 je 106700 <malloc+0x8c> <== NEVER TAKEN
* Try to give a segment in the current heap if there is not
* enough space then try to grow the heap.
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( &RTEMS_Malloc_Heap, size );
10669d: 51 push %ecx
10669e: 51 push %ecx
10669f: 56 push %esi
1066a0: 68 50 d6 11 00 push $0x11d650
1066a5: e8 8e 42 00 00 call 10a938 <_Protected_heap_Allocate>
1066aa: 89 c3 mov %eax,%ebx
if ( !return_this ) {
1066ac: 83 c4 10 add $0x10,%esp
1066af: 85 c0 test %eax,%eax
1066b1: 75 26 jne 1066d9 <malloc+0x65> <== ALWAYS TAKEN
if (rtems_malloc_sbrk_helpers)
1066b3: a1 d8 bb 11 00 mov 0x11bbd8,%eax <== NOT EXECUTED
1066b8: 85 c0 test %eax,%eax <== NOT EXECUTED
1066ba: 74 0e je 1066ca <malloc+0x56> <== NOT EXECUTED
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
1066bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1066bf: 56 push %esi <== NOT EXECUTED
1066c0: ff 50 04 call *0x4(%eax) <== NOT EXECUTED
if ( !return_this ) {
1066c3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1066c6: 85 c0 test %eax,%eax <== NOT EXECUTED
1066c8: 75 0d jne 1066d7 <malloc+0x63> <== NOT EXECUTED
errno = ENOMEM;
1066ca: e8 59 8a 00 00 call 10f128 <__errno> <== NOT EXECUTED
1066cf: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
1066d5: eb 2b jmp 106702 <malloc+0x8e> <== NOT EXECUTED
return (void *) 0;
1066d7: 89 c3 mov %eax,%ebx <== NOT EXECUTED
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
1066d9: a1 dc bb 11 00 mov 0x11bbdc,%eax
1066de: 85 c0 test %eax,%eax
1066e0: 74 09 je 1066eb <malloc+0x77> <== ALWAYS TAKEN
(*rtems_malloc_dirty_helper)( return_this, size );
1066e2: 52 push %edx <== NOT EXECUTED
1066e3: 52 push %edx <== NOT EXECUTED
1066e4: 56 push %esi <== NOT EXECUTED
1066e5: 53 push %ebx <== NOT EXECUTED
1066e6: ff d0 call *%eax <== NOT EXECUTED
1066e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
1066eb: a1 d4 bb 11 00 mov 0x11bbd4,%eax
1066f0: 85 c0 test %eax,%eax
1066f2: 74 0e je 106702 <malloc+0x8e> <== ALWAYS TAKEN
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
1066f4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1066f7: 53 push %ebx <== NOT EXECUTED
1066f8: ff 50 04 call *0x4(%eax) <== NOT EXECUTED
1066fb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1066fe: eb 02 jmp 106702 <malloc+0x8e> <== NOT EXECUTED
106700: 31 db xor %ebx,%ebx
if (rtems_malloc_boundary_helpers)
(*rtems_malloc_boundary_helpers->at_malloc)(return_this, size);
#endif
return return_this;
}
106702: 89 d8 mov %ebx,%eax
106704: 8d 65 f8 lea -0x8(%ebp),%esp
106707: 5b pop %ebx
106708: 5e pop %esi
106709: c9 leave
10670a: c3 ret
001065b7 <malloc_deferred_free>:
}
void malloc_deferred_free(
void *pointer
)
{
1065b7: 55 push %ebp <== NOT EXECUTED
1065b8: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1065ba: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
1065bd: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
1065c0: 68 44 d6 11 00 push $0x11d644 <== NOT EXECUTED
1065c5: e8 22 35 00 00 call 109aec <_Chain_Append> <== NOT EXECUTED
1065ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_chain_append(&RTEMS_Malloc_GC_list, (rtems_chain_node *)pointer);
}
1065cd: c9 leave <== NOT EXECUTED
1065ce: c3 ret <== NOT EXECUTED
001065cf <malloc_deferred_frees_process>:
{
rtems_chain_initialize_empty(&RTEMS_Malloc_GC_list);
}
void malloc_deferred_frees_process(void)
{
1065cf: 55 push %ebp
1065d0: 89 e5 mov %esp,%ebp
1065d2: 83 ec 08 sub $0x8,%esp
1065d5: eb 0c jmp 1065e3 <malloc_deferred_frees_process+0x14>
/*
* If some free's have been deferred, then do them now.
*/
while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL)
free(to_be_freed);
1065d7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1065da: 50 push %eax <== NOT EXECUTED
1065db: e8 98 fe ff ff call 106478 <free> <== NOT EXECUTED
1065e0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1065e3: 83 ec 0c sub $0xc,%esp
1065e6: 68 44 d6 11 00 push $0x11d644
1065eb: e8 20 35 00 00 call 109b10 <_Chain_Get>
rtems_chain_node *to_be_freed;
/*
* If some free's have been deferred, then do them now.
*/
while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL)
1065f0: 83 c4 10 add $0x10,%esp
1065f3: 85 c0 test %eax,%eax
1065f5: 75 e0 jne 1065d7 <malloc_deferred_frees_process+0x8><== NEVER TAKEN
free(to_be_freed);
}
1065f7: c9 leave
1065f8: c3 ret
00106578 <malloc_is_system_state_OK>:
#include "malloc_p.h"
rtems_chain_control RTEMS_Malloc_GC_list;
bool malloc_is_system_state_OK(void)
{
106578: 55 push %ebp
106579: 89 e5 mov %esp,%ebp
if ( _Thread_Dispatch_disable_level > 0 )
10657b: a1 98 d7 11 00 mov 0x11d798,%eax
106580: 31 d2 xor %edx,%edx
106582: 85 c0 test %eax,%eax
106584: 75 0a jne 106590 <malloc_is_system_state_OK+0x18><== NEVER TAKEN
return false;
if ( _ISR_Nest_level > 0 )
106586: a1 34 d8 11 00 mov 0x11d834,%eax
10658b: 85 c0 test %eax,%eax
10658d: 0f 94 c2 sete %dl
return false;
return true;
}
106590: 88 d0 mov %dl,%al
106592: c9 leave
106593: c3 ret
0010f8ec <memfile_alloc_block>:
*/
int memfile_blocks_allocated = 0;
void *memfile_alloc_block(void)
{
10f8ec: 55 push %ebp
10f8ed: 89 e5 mov %esp,%ebp
10f8ef: 83 ec 10 sub $0x10,%esp
void *memory;
memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK);
10f8f2: ff 35 ac 11 12 00 pushl 0x1211ac
10f8f8: 6a 01 push $0x1
10f8fa: e8 fd 74 ff ff call 106dfc <calloc>
if ( memory )
10f8ff: 83 c4 10 add $0x10,%esp
10f902: 85 c0 test %eax,%eax
10f904: 74 06 je 10f90c <memfile_alloc_block+0x20><== NEVER TAKEN
memfile_blocks_allocated++;
10f906: ff 05 b8 12 12 00 incl 0x1212b8
return memory;
}
10f90c: c9 leave
10f90d: c3 ret
0010fc6d <memfile_check_rmnod>:
return memfile_check_rmnod( the_jnode );
}
int memfile_check_rmnod( IMFS_jnode_t *the_jnode ){
10fc6d: 55 push %ebp
10fc6e: 89 e5 mov %esp,%ebp
10fc70: 53 push %ebx
10fc71: 83 ec 10 sub $0x10,%esp
10fc74: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* The file cannot be open and the link must be less than 1 to free.
*/
if ( !rtems_libio_is_file_open( the_jnode ) && (the_jnode->st_nlink < 1) ) {
10fc77: 53 push %ebx
10fc78: e8 23 79 ff ff call 1075a0 <rtems_libio_is_file_open>
10fc7d: 83 c4 10 add $0x10,%esp
10fc80: 85 c0 test %eax,%eax
10fc82: 75 36 jne 10fcba <memfile_check_rmnod+0x4d>
10fc84: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx)
10fc89: 75 2f jne 10fcba <memfile_check_rmnod+0x4d><== NEVER TAKEN
/*
* Is the rtems_filesystem_current is this node?
*/
if ( rtems_filesystem_current.node_access == the_jnode )
10fc8b: a1 cc f3 11 00 mov 0x11f3cc,%eax
10fc90: 39 58 04 cmp %ebx,0x4(%eax)
10fc93: 75 07 jne 10fc9c <memfile_check_rmnod+0x2f><== ALWAYS TAKEN
rtems_filesystem_current.node_access = NULL;
10fc95: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) <== NOT EXECUTED
/*
* Free memory associated with a memory file.
*/
if (the_jnode->type != IMFS_LINEAR_FILE)
10fc9c: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx)
10fca0: 74 0c je 10fcae <memfile_check_rmnod+0x41><== NEVER TAKEN
IMFS_memfile_remove( the_jnode );
10fca2: 83 ec 0c sub $0xc,%esp
10fca5: 53 push %ebx
10fca6: e8 7b fe ff ff call 10fb26 <IMFS_memfile_remove>
10fcab: 83 c4 10 add $0x10,%esp
free( the_jnode );
10fcae: 83 ec 0c sub $0xc,%esp
10fcb1: 53 push %ebx
10fcb2: e8 41 76 ff ff call 1072f8 <free>
10fcb7: 83 c4 10 add $0x10,%esp
}
return 0;
}
10fcba: 31 c0 xor %eax,%eax
10fcbc: 8b 5d fc mov -0x4(%ebp),%ebx
10fcbf: c9 leave
10fcc0: c3 ret
0010fabc <memfile_free_blocks_in_table>:
void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
10fabc: 55 push %ebp
10fabd: 89 e5 mov %esp,%ebp
10fabf: 57 push %edi
10fac0: 56 push %esi
10fac1: 53 push %ebx
10fac2: 83 ec 0c sub $0xc,%esp
10fac5: 8b 75 08 mov 0x8(%ebp),%esi
/*
* Perform internal consistency checks
*/
assert( block_table );
10fac8: 85 f6 test %esi,%esi
10faca: 75 19 jne 10fae5 <memfile_free_blocks_in_table+0x29><== ALWAYS TAKEN
10facc: 68 36 b6 11 00 push $0x11b636 <== NOT EXECUTED
10fad1: 68 28 b7 11 00 push $0x11b728 <== NOT EXECUTED
10fad6: 68 b1 01 00 00 push $0x1b1 <== NOT EXECUTED
10fadb: 68 c6 b5 11 00 push $0x11b5c6 <== NOT EXECUTED
10fae0: e8 bf 72 ff ff call 106da4 <__assert_func> <== NOT EXECUTED
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
10fae5: 8b 3e mov (%esi),%edi
10fae7: 31 db xor %ebx,%ebx
10fae9: eb 1b jmp 10fb06 <memfile_free_blocks_in_table+0x4a>
for ( i=0 ; i<entries ; i++ ) {
if ( b[i] ) {
10faeb: 8b 04 9f mov (%edi,%ebx,4),%eax
10faee: 85 c0 test %eax,%eax
10faf0: 74 13 je 10fb05 <memfile_free_blocks_in_table+0x49>
memfile_free_block( b[i] );
10faf2: 83 ec 0c sub $0xc,%esp
10faf5: 50 push %eax
10faf6: e8 d8 fd ff ff call 10f8d3 <memfile_free_block>
b[i] = 0;
10fafb: c7 04 9f 00 00 00 00 movl $0x0,(%edi,%ebx,4)
10fb02: 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++ ) {
10fb05: 43 inc %ebx
10fb06: 3b 5d 0c cmp 0xc(%ebp),%ebx
10fb09: 7c e0 jl 10faeb <memfile_free_blocks_in_table+0x2f>
/*
* Now that all the blocks in the block table are free, we can
* free the block table itself.
*/
memfile_free_block( *block_table );
10fb0b: 83 ec 0c sub $0xc,%esp
10fb0e: ff 36 pushl (%esi)
10fb10: e8 be fd ff ff call 10f8d3 <memfile_free_block>
*block_table = 0;
10fb15: c7 06 00 00 00 00 movl $0x0,(%esi)
10fb1b: 83 c4 10 add $0x10,%esp
}
10fb1e: 8d 65 f4 lea -0xc(%ebp),%esp
10fb21: 5b pop %ebx
10fb22: 5e pop %esi
10fb23: 5f pop %edi
10fb24: c9 leave
10fb25: c3 ret
0010fe71 <memfile_ftruncate>:
int memfile_ftruncate(
rtems_libio_t *iop,
off_t length
)
{
10fe71: 55 push %ebp
10fe72: 89 e5 mov %esp,%ebp
10fe74: 53 push %ebx
10fe75: 83 ec 14 sub $0x14,%esp
10fe78: 8b 55 08 mov 0x8(%ebp),%edx
10fe7b: 8b 45 0c mov 0xc(%ebp),%eax
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
10fe7e: 8b 5a 2c mov 0x2c(%edx),%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 )
10fe81: 3b 43 50 cmp 0x50(%ebx),%eax
10fe84: 7e 0b jle 10fe91 <memfile_ftruncate+0x20><== ALWAYS TAKEN
return IMFS_memfile_extend( the_jnode, length );
10fe86: 52 push %edx <== NOT EXECUTED
10fe87: 52 push %edx <== NOT EXECUTED
10fe88: 50 push %eax <== NOT EXECUTED
10fe89: 53 push %ebx <== NOT EXECUTED
10fe8a: e8 0f ff ff ff call 10fd9e <IMFS_memfile_extend> <== NOT EXECUTED
10fe8f: eb 1b jmp 10feac <memfile_ftruncate+0x3b><== NOT EXECUTED
* 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;
10fe91: 89 43 50 mov %eax,0x50(%ebx)
iop->size = the_jnode->info.file.size;
10fe94: 89 42 04 mov %eax,0x4(%edx)
IMFS_update_atime( the_jnode );
10fe97: 50 push %eax
10fe98: 50 push %eax
10fe99: 6a 00 push $0x0
10fe9b: 8d 45 f4 lea -0xc(%ebp),%eax
10fe9e: 50 push %eax
10fe9f: e8 c4 75 ff ff call 107468 <gettimeofday>
10fea4: 8b 45 f4 mov -0xc(%ebp),%eax
10fea7: 89 43 40 mov %eax,0x40(%ebx)
10feaa: 31 c0 xor %eax,%eax
10feac: 83 c4 10 add $0x10,%esp
return 0;
}
10feaf: 8b 5d fc mov -0x4(%ebp),%ebx
10feb2: c9 leave
10feb3: c3 ret
0010feb4 <memfile_lseek>:
off_t memfile_lseek(
rtems_libio_t *iop,
off_t offset,
int whence
)
{
10feb4: 55 push %ebp
10feb5: 89 e5 mov %esp,%ebp
10feb7: 56 push %esi
10feb8: 53 push %ebx
10feb9: 8b 75 08 mov 0x8(%ebp),%esi
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
10febc: 8b 5e 2c mov 0x2c(%esi),%ebx
if (the_jnode->type == IMFS_LINEAR_FILE) {
10febf: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx)
10fec3: 75 0d jne 10fed2 <memfile_lseek+0x1e> <== ALWAYS TAKEN
if (iop->offset > the_jnode->info.linearfile.size)
10fec5: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED
10fec8: 39 46 08 cmp %eax,0x8(%esi) <== NOT EXECUTED
10fecb: 7e 2d jle 10fefa <memfile_lseek+0x46> <== NOT EXECUTED
iop->offset = the_jnode->info.linearfile.size;
10fecd: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED
10fed0: eb 28 jmp 10fefa <memfile_lseek+0x46> <== NOT EXECUTED
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
10fed2: 51 push %ecx
10fed3: 51 push %ecx
10fed4: ff 76 08 pushl 0x8(%esi)
10fed7: 53 push %ebx
10fed8: e8 c1 fe ff ff call 10fd9e <IMFS_memfile_extend>
10fedd: 83 c4 10 add $0x10,%esp
10fee0: 85 c0 test %eax,%eax
10fee2: 74 10 je 10fef4 <memfile_lseek+0x40> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOSPC );
10fee4: e8 f7 10 00 00 call 110fe0 <__errno> <== NOT EXECUTED
10fee9: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED
10feef: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10fef2: eb 09 jmp 10fefd <memfile_lseek+0x49> <== NOT EXECUTED
iop->size = the_jnode->info.file.size;
10fef4: 8b 43 50 mov 0x50(%ebx),%eax
10fef7: 89 46 04 mov %eax,0x4(%esi)
}
return iop->offset;
10fefa: 8b 46 08 mov 0x8(%esi),%eax
}
10fefd: 8d 65 f8 lea -0x8(%ebp),%esp
10ff00: 5b pop %ebx
10ff01: 5e pop %esi
10ff02: c9 leave
10ff03: c3 ret
001100fb <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
1100fb: 55 push %ebp
1100fc: 89 e5 mov %esp,%ebp
1100fe: 56 push %esi
1100ff: 53 push %ebx
110100: 8b 75 08 mov 0x8(%ebp),%esi
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
110103: 8b 5e 2c mov 0x2c(%esi),%ebx
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
110106: f7 46 0c 04 02 00 00 testl $0x204,0xc(%esi)
11010d: 74 46 je 110155 <memfile_open+0x5a>
11010f: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx)
110113: 75 40 jne 110155 <memfile_open+0x5a> <== ALWAYS TAKEN
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
110115: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
110118: 8b 53 54 mov 0x54(%ebx),%edx <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
11011b: c7 43 4c 05 00 00 00 movl $0x5,0x4c(%ebx) <== NOT EXECUTED
the_jnode->info.file.size = 0;
110122: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
110129: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
110130: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
110137: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED
if ((count != 0)
11013e: 85 c0 test %eax,%eax <== NOT EXECUTED
110140: 74 13 je 110155 <memfile_open+0x5a> <== NOT EXECUTED
110142: 50 push %eax <== NOT EXECUTED
110143: 52 push %edx <== NOT EXECUTED
110144: 6a 00 push $0x0 <== NOT EXECUTED
110146: 53 push %ebx <== NOT EXECUTED
110147: e8 b8 fd ff ff call 10ff04 <IMFS_memfile_write> <== NOT EXECUTED
11014c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
11014f: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED
110152: 40 inc %eax <== NOT EXECUTED
110153: 74 14 je 110169 <memfile_open+0x6e> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
110155: f6 46 0d 02 testb $0x2,0xd(%esi)
110159: 74 06 je 110161 <memfile_open+0x66>
iop->offset = the_jnode->info.file.size;
11015b: 8b 43 50 mov 0x50(%ebx),%eax
11015e: 89 46 08 mov %eax,0x8(%esi)
iop->size = the_jnode->info.file.size;
110161: 8b 43 50 mov 0x50(%ebx),%eax
110164: 89 46 04 mov %eax,0x4(%esi)
110167: 31 d2 xor %edx,%edx
return 0;
}
110169: 89 d0 mov %edx,%eax
11016b: 8d 65 f8 lea -0x8(%ebp),%esp
11016e: 5b pop %ebx
11016f: 5e pop %esi
110170: c9 leave
110171: c3 ret
0010fcc1 <memfile_rmnod>:
*/
int memfile_rmnod(
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
10fcc1: 55 push %ebp
10fcc2: 89 e5 mov %esp,%ebp
10fcc4: 53 push %ebx
10fcc5: 83 ec 14 sub $0x14,%esp
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
10fcc8: 8b 45 08 mov 0x8(%ebp),%eax
10fccb: 8b 18 mov (%eax),%ebx
/*
* Take the node out of the parent's chain that contains this node
*/
if ( the_jnode->Parent != NULL ) {
10fccd: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10fcd1: 74 13 je 10fce6 <memfile_rmnod+0x25> <== NEVER TAKEN
10fcd3: 83 ec 0c sub $0xc,%esp
10fcd6: 53 push %ebx
10fcd7: e8 58 f3 ff ff call 10f034 <_Chain_Extract>
rtems_chain_extract( (rtems_chain_node *) the_jnode );
the_jnode->Parent = NULL;
10fcdc: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
10fce3: 83 c4 10 add $0x10,%esp
/*
* Decrement the link counter and see if we can free the space.
*/
the_jnode->st_nlink--;
10fce6: 66 ff 4b 34 decw 0x34(%ebx)
IMFS_update_ctime( the_jnode );
10fcea: 50 push %eax
10fceb: 50 push %eax
10fcec: 6a 00 push $0x0
10fcee: 8d 45 f4 lea -0xc(%ebp),%eax
10fcf1: 50 push %eax
10fcf2: e8 71 77 ff ff call 107468 <gettimeofday>
10fcf7: 8b 45 f4 mov -0xc(%ebp),%eax
10fcfa: 89 43 48 mov %eax,0x48(%ebx)
return memfile_check_rmnod( the_jnode );
10fcfd: 89 1c 24 mov %ebx,(%esp)
10fd00: e8 68 ff ff ff call 10fc6d <memfile_check_rmnod>
}
10fd05: 8b 5d fc mov -0x4(%ebp),%ebx
10fd08: c9 leave
10fd09: c3 ret
0010670c <mknod>:
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
10670c: 55 push %ebp
10670d: 89 e5 mov %esp,%ebp
10670f: 57 push %edi
106710: 56 push %esi
106711: 53 push %ebx
106712: 83 ec 2c sub $0x2c,%esp
106715: 8b 5d 08 mov 0x8(%ebp),%ebx
106718: 8b 45 10 mov 0x10(%ebp),%eax
10671b: 8b 55 14 mov 0x14(%ebp),%edx
10671e: 89 45 c8 mov %eax,-0x38(%ebp)
106721: 89 55 cc mov %edx,-0x34(%ebp)
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT) {
106724: 8b 45 0c mov 0xc(%ebp),%eax
106727: 25 00 f0 00 00 and $0xf000,%eax
10672c: 3d 00 40 00 00 cmp $0x4000,%eax
106731: 74 2b je 10675e <mknod+0x52>
106733: 77 0e ja 106743 <mknod+0x37>
106735: 3d 00 10 00 00 cmp $0x1000,%eax
10673a: 74 29 je 106765 <mknod+0x59>
10673c: 3d 00 20 00 00 cmp $0x2000,%eax
106741: eb 0c jmp 10674f <mknod+0x43>
106743: 3d 00 60 00 00 cmp $0x6000,%eax
106748: 74 14 je 10675e <mknod+0x52> <== NEVER TAKEN
10674a: 3d 00 80 00 00 cmp $0x8000,%eax
10674f: 74 0d je 10675e <mknod+0x52> <== ALWAYS TAKEN
case S_IFBLK:
case S_IFREG:
case S_IFIFO:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
106751: e8 d2 89 00 00 call 10f128 <__errno> <== NOT EXECUTED
106756: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
10675c: eb 12 jmp 106770 <mknod+0x64> <== NOT EXECUTED
}
if ( S_ISFIFO(mode) )
10675e: 3d 00 10 00 00 cmp $0x1000,%eax
106763: 75 13 jne 106778 <mknod+0x6c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
106765: e8 be 89 00 00 call 10f128 <__errno>
10676a: c7 00 86 00 00 00 movl $0x86,(%eax)
106770: 83 ce ff or $0xffffffff,%esi
106773: e9 a6 00 00 00 jmp 10681e <mknod+0x112>
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
106778: 8a 03 mov (%ebx),%al
10677a: 3c 2f cmp $0x2f,%al
10677c: 74 08 je 106786 <mknod+0x7a>
10677e: 3c 5c cmp $0x5c,%al
106780: 74 04 je 106786 <mknod+0x7a> <== NEVER TAKEN
106782: 84 c0 test %al,%al
106784: 75 16 jne 10679c <mknod+0x90> <== ALWAYS TAKEN
106786: 8d 7d dc lea -0x24(%ebp),%edi
106789: a1 6c b6 11 00 mov 0x11b66c,%eax
10678e: 8d 70 14 lea 0x14(%eax),%esi
106791: b9 04 00 00 00 mov $0x4,%ecx
106796: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
106798: b1 01 mov $0x1,%cl
10679a: eb 12 jmp 1067ae <mknod+0xa2>
10679c: 8d 7d dc lea -0x24(%ebp),%edi
10679f: a1 6c b6 11 00 mov 0x11b66c,%eax
1067a4: 8d 70 04 lea 0x4(%eax),%esi
1067a7: b9 04 00 00 00 mov $0x4,%ecx
1067ac: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !temp_loc.ops->evalformake_h ) {
1067ae: 8b 45 e4 mov -0x1c(%ebp),%eax
1067b1: 8b 50 04 mov 0x4(%eax),%edx
1067b4: 85 d2 test %edx,%edx
1067b6: 74 ad je 106765 <mknod+0x59> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*temp_loc.ops->evalformake_h)(
1067b8: 50 push %eax
1067b9: 8d 45 ec lea -0x14(%ebp),%eax
1067bc: 50 push %eax
1067bd: 8d 7d dc lea -0x24(%ebp),%edi
1067c0: 57 push %edi
1067c1: 8d 04 0b lea (%ebx,%ecx,1),%eax
1067c4: 50 push %eax
1067c5: ff d2 call *%edx
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
1067c7: 83 c4 10 add $0x10,%esp
1067ca: 83 ce ff or $0xffffffff,%esi
1067cd: 85 c0 test %eax,%eax
1067cf: 75 4d jne 10681e <mknod+0x112>
return -1;
if ( !temp_loc.ops->mknod_h ) {
1067d1: 8b 45 e4 mov -0x1c(%ebp),%eax
1067d4: 8b 50 14 mov 0x14(%eax),%edx
1067d7: 85 d2 test %edx,%edx
1067d9: 75 15 jne 1067f0 <mknod+0xe4> <== ALWAYS TAKEN
rtems_filesystem_freenode( &temp_loc );
1067db: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
1067de: 85 c0 test %eax,%eax <== NOT EXECUTED
1067e0: 74 83 je 106765 <mknod+0x59> <== NOT EXECUTED
1067e2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1067e5: 57 push %edi <== NOT EXECUTED
1067e6: ff d0 call *%eax <== NOT EXECUTED
1067e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1067eb: e9 75 ff ff ff jmp 106765 <mknod+0x59> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
1067f0: 83 ec 0c sub $0xc,%esp
1067f3: 57 push %edi
1067f4: ff 75 cc pushl -0x34(%ebp)
1067f7: ff 75 c8 pushl -0x38(%ebp)
1067fa: ff 75 0c pushl 0xc(%ebp)
1067fd: ff 75 ec pushl -0x14(%ebp)
106800: ff d2 call *%edx
106802: 89 c6 mov %eax,%esi
rtems_filesystem_freenode( &temp_loc );
106804: 8b 45 e4 mov -0x1c(%ebp),%eax
106807: 83 c4 20 add $0x20,%esp
10680a: 85 c0 test %eax,%eax
10680c: 74 10 je 10681e <mknod+0x112> <== NEVER TAKEN
10680e: 8b 40 1c mov 0x1c(%eax),%eax
106811: 85 c0 test %eax,%eax
106813: 74 09 je 10681e <mknod+0x112>
106815: 83 ec 0c sub $0xc,%esp
106818: 57 push %edi
106819: ff d0 call *%eax
10681b: 83 c4 10 add $0x10,%esp
return result;
}
10681e: 89 f0 mov %esi,%eax
106820: 8d 65 f4 lea -0xc(%ebp),%esp
106823: 5b pop %ebx
106824: 5e pop %esi
106825: 5f pop %edi
106826: c9 leave
106827: c3 ret
0010d119 <mount>:
const rtems_filesystem_operations_table *fs_ops,
rtems_filesystem_options_t options,
const char *device,
const char *mount_point
)
{
10d119: 55 push %ebp
10d11a: 89 e5 mov %esp,%ebp
10d11c: 57 push %edi
10d11d: 56 push %esi
10d11e: 53 push %ebx
10d11f: 83 ec 1c sub $0x1c,%esp
10d122: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Is there a file system operations table?
*/
if ( fs_ops == NULL ) {
10d125: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10d129: 74 05 je 10d130 <mount+0x17>
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
10d12b: 83 fe 01 cmp $0x1,%esi
10d12e: 76 10 jbe 10d140 <mount+0x27>
options != RTEMS_FILESYSTEM_READ_WRITE ) {
errno = EINVAL;
10d130: e8 f3 1f 00 00 call 10f128 <__errno>
10d135: c7 00 16 00 00 00 movl $0x16,(%eax)
10d13b: e9 e4 01 00 00 jmp 10d324 <mount+0x20b>
return -1;
}
/* Do they support being mounted at all ? */
if ( !fs_ops->fsmount_me_h ) {
10d140: 8b 45 0c mov 0xc(%ebp),%eax
10d143: 83 78 24 00 cmpl $0x0,0x24(%eax)
10d147: 75 17 jne 10d160 <mount+0x47> <== ALWAYS TAKEN
errno = ENOTSUP;
10d149: e8 da 1f 00 00 call 10f128 <__errno> <== NOT EXECUTED
10d14e: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10d154: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
10d15b: e9 94 01 00 00 jmp 10d2f4 <mount+0x1db> <== NOT EXECUTED
/*
* Allocate a mount table entry
*/
size = sizeof(rtems_filesystem_mount_table_entry_t);
if ( device )
10d160: b8 64 00 00 00 mov $0x64,%eax
10d165: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10d169: 74 0f je 10d17a <mount+0x61> <== ALWAYS TAKEN
size += strlen( device ) + 1;
10d16b: 31 c0 xor %eax,%eax
10d16d: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED
10d170: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED
10d173: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED
10d175: f7 d1 not %ecx <== NOT EXECUTED
10d177: 8d 41 64 lea 0x64(%ecx),%eax <== NOT EXECUTED
temp_mt_entry = malloc( size );
10d17a: 83 ec 0c sub $0xc,%esp
10d17d: 50 push %eax
10d17e: e8 f1 94 ff ff call 106674 <malloc>
10d183: 89 c3 mov %eax,%ebx
10d185: 89 45 e0 mov %eax,-0x20(%ebp)
if ( !temp_mt_entry ) {
10d188: 83 c4 10 add $0x10,%esp
10d18b: 85 c0 test %eax,%eax
10d18d: 75 10 jne 10d19f <mount+0x86> <== ALWAYS TAKEN
errno = ENOMEM;
10d18f: e8 94 1f 00 00 call 10f128 <__errno> <== NOT EXECUTED
10d194: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
10d19a: e9 85 01 00 00 jmp 10d324 <mount+0x20b> <== NOT EXECUTED
return -1;
}
temp_mt_entry->mt_fs_root.mt_entry = temp_mt_entry;
10d19f: 89 43 24 mov %eax,0x24(%ebx)
temp_mt_entry->options = options;
10d1a2: 89 70 28 mov %esi,0x28(%eax)
if ( device ) {
10d1a5: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10d1a9: 74 16 je 10d1c1 <mount+0xa8> <== ALWAYS TAKEN
temp_mt_entry->dev =
10d1ab: 8d 40 64 lea 0x64(%eax),%eax <== NOT EXECUTED
10d1ae: 89 43 60 mov %eax,0x60(%ebx) <== NOT EXECUTED
(char *)temp_mt_entry + sizeof( rtems_filesystem_mount_table_entry_t );
strcpy( temp_mt_entry->dev, device );
10d1b1: 52 push %edx <== NOT EXECUTED
10d1b2: 52 push %edx <== NOT EXECUTED
10d1b3: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED
10d1b6: 50 push %eax <== NOT EXECUTED
10d1b7: e8 cc 30 00 00 call 110288 <strcpy> <== NOT EXECUTED
10d1bc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10d1bf: eb 07 jmp 10d1c8 <mount+0xaf> <== NOT EXECUTED
} else
temp_mt_entry->dev = 0;
10d1c1: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( mount_point ) {
10d1c8: 83 7d 18 00 cmpl $0x0,0x18(%ebp)
10d1cc: 0f 84 a8 00 00 00 je 10d27a <mount+0x161>
if ( rtems_filesystem_evaluate_path(
10d1d2: 6a 01 push $0x1
10d1d4: 8d 75 e4 lea -0x1c(%ebp),%esi
10d1d7: 56 push %esi
10d1d8: 6a 07 push $0x7
10d1da: ff 75 18 pushl 0x18(%ebp)
10d1dd: e8 74 91 ff ff call 106356 <rtems_filesystem_evaluate_path>
10d1e2: 83 c4 10 add $0x10,%esp
10d1e5: 40 inc %eax
10d1e6: 0f 84 08 01 00 00 je 10d2f4 <mount+0x1db> <== NEVER TAKEN
/*
* Test for node_type_h
*/
if (!loc.ops->node_type_h) {
10d1ec: 8b 45 ec mov -0x14(%ebp),%eax
10d1ef: 8b 40 10 mov 0x10(%eax),%eax
10d1f2: 85 c0 test %eax,%eax
10d1f4: 75 10 jne 10d206 <mount+0xed> <== ALWAYS TAKEN
errno = ENOTSUP;
10d1f6: e8 2d 1f 00 00 call 10f128 <__errno> <== NOT EXECUTED
10d1fb: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10d201: e9 f0 00 00 00 jmp 10d2f6 <mount+0x1dd> <== NOT EXECUTED
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
10d206: 83 ec 0c sub $0xc,%esp
10d209: 56 push %esi
10d20a: ff d0 call *%eax
10d20c: 83 c4 10 add $0x10,%esp
10d20f: 48 dec %eax
10d210: 74 10 je 10d222 <mount+0x109>
errno = ENOTDIR;
10d212: e8 11 1f 00 00 call 10f128 <__errno>
10d217: c7 00 14 00 00 00 movl $0x14,(%eax)
10d21d: e9 d4 00 00 00 jmp 10d2f6 <mount+0x1dd>
/*
* For each mount table entry
*/
for ( the_node = rtems_filesystem_mount_table_control.first;
10d222: a1 30 dd 11 00 mov 0x11dd30,%eax
!rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
the_node = the_node->next ) {
the_mount_entry = (rtems_filesystem_mount_table_entry_t *) the_node;
if ( the_mount_entry->mt_fs_root.node_access == loc->node_access )
10d227: 8b 55 e4 mov -0x1c(%ebp),%edx
10d22a: eb 07 jmp 10d233 <mount+0x11a>
10d22c: 39 50 18 cmp %edx,0x18(%eax)
10d22f: 74 0e je 10d23f <mount+0x126>
* For each mount table entry
*/
for ( the_node = rtems_filesystem_mount_table_control.first;
!rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
the_node = the_node->next ) {
10d231: 8b 00 mov (%eax),%eax
/*
* For each mount table entry
*/
for ( the_node = rtems_filesystem_mount_table_control.first;
!rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
10d233: 3d 34 dd 11 00 cmp $0x11dd34,%eax
10d238: 75 f2 jne 10d22c <mount+0x113>
10d23a: e9 f0 00 00 00 jmp 10d32f <mount+0x216>
/*
* You can only mount one file system onto a single mount point.
*/
if ( Is_node_fs_root( &loc ) ){
errno = EBUSY;
10d23f: e8 e4 1e 00 00 call 10f128 <__errno>
10d244: c7 00 10 00 00 00 movl $0x10,(%eax)
10d24a: eb 0b jmp 10d257 <mount+0x13e>
* This link to the parent is only done when we are dealing with system
* below the base file system
*/
if ( !loc.ops->mount_h ){
errno = ENOTSUP;
10d24c: e8 d7 1e 00 00 call 10f128 <__errno> <== NOT EXECUTED
10d251: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10d257: 8d 75 e4 lea -0x1c(%ebp),%esi
10d25a: e9 97 00 00 00 jmp 10d2f6 <mount+0x1dd>
goto cleanup_and_bail;
}
if ( loc.ops->mount_h( temp_mt_entry ) ) {
10d25f: 83 ec 0c sub $0xc,%esp
10d262: 53 push %ebx
10d263: ff d0 call *%eax
10d265: 83 c4 10 add $0x10,%esp
10d268: 85 c0 test %eax,%eax
10d26a: 8d 45 e4 lea -0x1c(%ebp),%eax
10d26d: 74 07 je 10d276 <mount+0x15d> <== ALWAYS TAKEN
10d26f: 89 c6 mov %eax,%esi <== NOT EXECUTED
10d271: e9 80 00 00 00 jmp 10d2f6 <mount+0x1dd> <== NOT EXECUTED
10d276: 89 c6 mov %eax,%esi
10d278: eb 33 jmp 10d2ad <mount+0x194>
* This is a mount of the base file system --> The
* mt_point_node.node_access will be set to null to indicate that this
* is the root of the entire file system.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
10d27a: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
temp_mt_entry->mt_fs_root.handlers = NULL;
10d281: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
temp_mt_entry->mt_fs_root.ops = NULL;
10d288: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
temp_mt_entry->mt_point_node.node_access = NULL;
10d28f: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
temp_mt_entry->mt_point_node.handlers = NULL;
10d296: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
temp_mt_entry->mt_point_node.ops = NULL;
10d29d: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
temp_mt_entry->mt_point_node.mt_entry = NULL;
10d2a4: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
10d2ab: 31 f6 xor %esi,%esi
}
if ( fs_ops->fsmount_me_h( temp_mt_entry ) ) {
10d2ad: 83 ec 0c sub $0xc,%esp
10d2b0: 53 push %ebx
10d2b1: 8b 55 0c mov 0xc(%ebp),%edx
10d2b4: ff 52 24 call *0x24(%edx)
10d2b7: 83 c4 10 add $0x10,%esp
10d2ba: 85 c0 test %eax,%eax
10d2bc: 74 15 je 10d2d3 <mount+0x1ba> <== ALWAYS TAKEN
/* try to undo the mount operation */
if ( loc.ops->unmount_h ) {
10d2be: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
10d2c1: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED
10d2c4: 85 c0 test %eax,%eax <== NOT EXECUTED
10d2c6: 74 2e je 10d2f6 <mount+0x1dd> <== NOT EXECUTED
loc.ops->unmount_h( temp_mt_entry );
10d2c8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10d2cb: 53 push %ebx <== NOT EXECUTED
10d2cc: ff d0 call *%eax <== NOT EXECUTED
10d2ce: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10d2d1: eb 23 jmp 10d2f6 <mount+0x1dd> <== NOT EXECUTED
10d2d3: 50 push %eax
10d2d4: 50 push %eax
10d2d5: 53 push %ebx
10d2d6: 68 30 dd 11 00 push $0x11dd30
10d2db: e8 0c c8 ff ff call 109aec <_Chain_Append>
*/
rtems_chain_append( &rtems_filesystem_mount_table_control,
&temp_mt_entry->Node );
if ( mt_entry )
10d2e0: 83 c4 10 add $0x10,%esp
10d2e3: 31 c0 xor %eax,%eax
10d2e5: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
10d2e9: 74 3c je 10d327 <mount+0x20e> <== NEVER TAKEN
*mt_entry = temp_mt_entry;
10d2eb: 8b 7d 08 mov 0x8(%ebp),%edi
10d2ee: 89 1f mov %ebx,(%edi)
10d2f0: 31 c0 xor %eax,%eax
10d2f2: eb 33 jmp 10d327 <mount+0x20e>
10d2f4: 31 f6 xor %esi,%esi
return 0;
cleanup_and_bail:
free( temp_mt_entry );
10d2f6: 83 ec 0c sub $0xc,%esp
10d2f9: ff 75 e0 pushl -0x20(%ebp)
10d2fc: e8 77 91 ff ff call 106478 <free>
if ( loc_to_free )
10d301: 83 c4 10 add $0x10,%esp
10d304: 85 f6 test %esi,%esi
10d306: 74 1c je 10d324 <mount+0x20b> <== NEVER TAKEN
rtems_filesystem_freenode( loc_to_free );
10d308: 8b 46 08 mov 0x8(%esi),%eax
10d30b: 85 c0 test %eax,%eax
10d30d: 74 15 je 10d324 <mount+0x20b> <== NEVER TAKEN
10d30f: 8b 40 1c mov 0x1c(%eax),%eax
10d312: 85 c0 test %eax,%eax
10d314: 74 0e je 10d324 <mount+0x20b> <== NEVER TAKEN
10d316: 83 ec 0c sub $0xc,%esp
10d319: 56 push %esi
10d31a: ff d0 call *%eax
10d31c: 83 c8 ff or $0xffffffff,%eax
10d31f: 83 c4 10 add $0x10,%esp
10d322: eb 03 jmp 10d327 <mount+0x20e>
10d324: 83 c8 ff or $0xffffffff,%eax
return -1;
}
10d327: 8d 65 f4 lea -0xc(%ebp),%esp
10d32a: 5b pop %ebx
10d32b: 5e pop %esi
10d32c: 5f pop %edi
10d32d: c9 leave
10d32e: c3 ret
* 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.
*/
temp_mt_entry->mt_point_node.node_access = loc.node_access;
10d32f: 89 53 08 mov %edx,0x8(%ebx)
temp_mt_entry->mt_point_node.handlers = loc.handlers;
10d332: 8b 45 e8 mov -0x18(%ebp),%eax
10d335: 89 43 0c mov %eax,0xc(%ebx)
temp_mt_entry->mt_point_node.ops = loc.ops;
10d338: 8b 55 ec mov -0x14(%ebp),%edx
10d33b: 89 53 10 mov %edx,0x10(%ebx)
temp_mt_entry->mt_point_node.mt_entry = loc.mt_entry;
10d33e: 8b 45 f0 mov -0x10(%ebp),%eax
10d341: 89 43 14 mov %eax,0x14(%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 ){
10d344: 8b 42 20 mov 0x20(%edx),%eax
10d347: 85 c0 test %eax,%eax
10d349: 0f 85 10 ff ff ff jne 10d25f <mount+0x146> <== ALWAYS TAKEN
10d34f: e9 f8 fe ff ff jmp 10d24c <mount+0x133> <== NOT EXECUTED
0010cb00 <mq_unlink>:
*/
int mq_unlink(
const char *name
)
{
10cb00: 55 push %ebp
10cb01: 89 e5 mov %esp,%ebp
10cb03: 53 push %ebx
10cb04: 83 ec 1c sub $0x1c,%esp
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10cb07: a1 58 63 12 00 mov 0x126358,%eax
10cb0c: 40 inc %eax
10cb0d: a3 58 63 12 00 mov %eax,0x126358
register POSIX_Message_queue_Control *the_mq;
Objects_Id the_mq_id;
_Thread_Disable_dispatch();
status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id );
10cb12: 8d 45 f8 lea -0x8(%ebp),%eax
10cb15: 50 push %eax
10cb16: ff 75 08 pushl 0x8(%ebp)
10cb19: e8 32 5a 00 00 call 112550 <_POSIX_Message_queue_Name_to_id>
10cb1e: 89 c3 mov %eax,%ebx
if ( status != 0 ) {
10cb20: 83 c4 10 add $0x10,%esp
10cb23: 85 c0 test %eax,%eax
10cb25: 74 11 je 10cb38 <mq_unlink+0x38>
_Thread_Enable_dispatch();
10cb27: e8 08 32 00 00 call 10fd34 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( status );
10cb2c: e8 db 78 00 00 call 11440c <__errno>
10cb31: 89 18 mov %ebx,(%eax)
10cb33: 83 c8 ff or $0xffffffff,%eax
10cb36: eb 3c jmp 10cb74 <mq_unlink+0x74>
}
the_mq = (POSIX_Message_queue_Control *) _Objects_Get_local_object(
10cb38: 8b 45 f8 mov -0x8(%ebp),%eax
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
);
/**
10cb3b: 31 db xor %ebx,%ebx
10cb3d: 66 3b 05 d8 66 12 00 cmp 0x1266d8,%ax
10cb44: 77 0b ja 10cb51 <mq_unlink+0x51> <== NEVER TAKEN
* This heap routine returns information about the free blocks
* in the specified heap.
10cb46: 0f b7 d0 movzwl %ax,%edx
10cb49: a1 e4 66 12 00 mov 0x1266e4,%eax
10cb4e: 8b 1c 90 mov (%eax,%edx,4),%ebx
&_POSIX_Message_queue_Information,
_Objects_Get_index( the_mq_id )
);
the_mq->linked = FALSE;
10cb51: c6 43 15 00 movb $0x0,0x15(%ebx)
/**
* This function attempts to allocate a block of @a size bytes from
* @a the_heap. If insufficient memory is free in @a the_heap to allocate
* a block of the requested size, then NULL is returned.
*
10cb55: 50 push %eax
10cb56: 50 push %eax
10cb57: 53 push %ebx
10cb58: 68 c8 66 12 00 push $0x1266c8
10cb5d: e8 da 2a 00 00 call 10f63c <_Objects_Namespace_remove>
_POSIX_Message_queue_Namespace_remove( the_mq );
_POSIX_Message_queue_Delete( the_mq );
10cb62: 89 1c 24 mov %ebx,(%esp)
10cb65: e8 92 f9 ff ff call 10c4fc <_POSIX_Message_queue_Delete>
_Thread_Enable_dispatch();
10cb6a: e8 c5 31 00 00 call 10fd34 <_Thread_Enable_dispatch>
10cb6f: 31 c0 xor %eax,%eax
10cb71: 83 c4 10 add $0x10,%esp
return 0;
}
10cb74: 8b 5d fc mov -0x4(%ebp),%ebx
10cb77: c9 leave
10cb78: c3 ret
0010d834 <nanosleep>:
int nanosleep(
const struct timespec *rqtp,
struct timespec *rmtp
)
{
10d834: 55 push %ebp
10d835: 89 e5 mov %esp,%ebp
10d837: 56 push %esi
10d838: 53 push %ebx
10d839: 8b 5d 08 mov 0x8(%ebp),%ebx
10d83c: 8b 75 0c mov 0xc(%ebp),%esi
Watchdog_Interval ticks;
if ( !_Timespec_Is_valid( rqtp ) )
10d83f: 83 ec 0c sub $0xc,%esp
10d842: 53 push %ebx
10d843: e8 a8 11 00 00 call 10e9f0 <_Timespec_Is_valid>
10d848: 83 c4 10 add $0x10,%esp
10d84b: 84 c0 test %al,%al
10d84d: 74 0b je 10d85a <nanosleep+0x26>
* Return EINVAL if the delay interval is negative.
*
* NOTE: This behavior is beyond the POSIX specification.
* FSU and GNU/Linux pthreads shares this behavior.
*/
if ( rqtp->tv_sec < 0 || rqtp->tv_nsec < 0 )
10d84f: 83 3b 00 cmpl $0x0,(%ebx)
10d852: 78 06 js 10d85a <nanosleep+0x26> <== NEVER TAKEN
10d854: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10d858: 79 10 jns 10d86a <nanosleep+0x36> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10d85a: e8 0d 1e 00 00 call 10f66c <__errno>
10d85f: c7 00 16 00 00 00 movl $0x16,(%eax)
10d865: e9 c3 00 00 00 jmp 10d92d <nanosleep+0xf9>
ticks = _Timespec_To_ticks( rqtp );
10d86a: 83 ec 0c sub $0xc,%esp
10d86d: 53 push %ebx
10d86e: e8 a1 11 00 00 call 10ea14 <_Timespec_To_ticks>
10d873: 89 c3 mov %eax,%ebx
* A nanosleep for zero time is implemented as a yield.
* This behavior is also beyond the POSIX specification but is
* consistent with the RTEMS API and yields desirable behavior.
*/
if ( !ticks ) {
10d875: 83 c4 10 add $0x10,%esp
10d878: 85 c0 test %eax,%eax
10d87a: 75 2f jne 10d8ab <nanosleep+0x77>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10d87c: a1 98 de 11 00 mov 0x11de98,%eax
10d881: 40 inc %eax
10d882: a3 98 de 11 00 mov %eax,0x11de98
_Thread_Disable_dispatch();
_Thread_Yield_processor();
10d887: e8 7c e4 ff ff call 10bd08 <_Thread_Yield_processor>
_Thread_Enable_dispatch();
10d88c: e8 af d9 ff ff call 10b240 <_Thread_Enable_dispatch>
if ( rmtp ) {
10d891: 85 f6 test %esi,%esi
10d893: 0f 84 99 00 00 00 je 10d932 <nanosleep+0xfe> <== NEVER TAKEN
rmtp->tv_sec = 0;
10d899: c7 06 00 00 00 00 movl $0x0,(%esi)
rmtp->tv_nsec = 0;
10d89f: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi)
10d8a6: e9 87 00 00 00 jmp 10d932 <nanosleep+0xfe>
10d8ab: a1 98 de 11 00 mov 0x11de98,%eax
10d8b0: 40 inc %eax
10d8b1: a3 98 de 11 00 mov %eax,0x11de98
/*
* Block for the desired amount of time
*/
_Thread_Disable_dispatch();
_Thread_Set_state(
10d8b6: 50 push %eax
10d8b7: 50 push %eax
10d8b8: 68 08 00 00 10 push $0x10000008
10d8bd: ff 35 58 df 11 00 pushl 0x11df58
10d8c3: e8 68 e1 ff ff call 10ba30 <_Thread_Set_state>
_Thread_Executing,
STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Watchdog_Initialize(
10d8c8: a1 58 df 11 00 mov 0x11df58,%eax
10d8cd: 8b 50 08 mov 0x8(%eax),%edx
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
10d8d0: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
* @param[in] the_heap is the heap to operate upon
10d8d7: c7 40 64 c4 b0 10 00 movl $0x10b0c4,0x64(%eax)
* @param[in] starting_address is the starting address of the memory for
10d8de: 89 50 68 mov %edx,0x68(%eax)
* the heap
10d8e1: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax)
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
Heap_Control *the_heap,
10d8e8: 89 58 54 mov %ebx,0x54(%eax)
void *starting_address,
size_t *size
10d8eb: 5a pop %edx
10d8ec: 59 pop %ecx
10d8ed: 83 c0 48 add $0x48,%eax
10d8f0: 50 push %eax
10d8f1: 68 78 df 11 00 push $0x11df78
10d8f6: e8 4d e7 ff ff call 10c048 <_Watchdog_Insert>
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
_Thread_Enable_dispatch();
10d8fb: e8 40 d9 ff ff call 10b240 <_Thread_Enable_dispatch>
/* calculate time remaining */
if ( rmtp ) {
10d900: 83 c4 10 add $0x10,%esp
10d903: 85 f6 test %esi,%esi
10d905: 74 2b je 10d932 <nanosleep+0xfe> <== NEVER TAKEN
ticks -=
10d907: a1 58 df 11 00 mov 0x11df58,%eax
10d90c: 03 58 5c add 0x5c(%eax),%ebx
10d90f: 2b 58 60 sub 0x60(%eax),%ebx
_Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time;
_Timespec_From_ticks( ticks, rmtp );
10d912: 50 push %eax
10d913: 50 push %eax
10d914: 56 push %esi
10d915: 53 push %ebx
10d916: e8 a9 10 00 00 call 10e9c4 <_Timespec_From_ticks>
/*
* If there is time remaining, then we were interrupted by a signal.
*/
if ( ticks )
10d91b: 83 c4 10 add $0x10,%esp
10d91e: 85 db test %ebx,%ebx
10d920: 74 10 je 10d932 <nanosleep+0xfe>
rtems_set_errno_and_return_minus_one( EINTR );
10d922: e8 45 1d 00 00 call 10f66c <__errno>
10d927: c7 00 04 00 00 00 movl $0x4,(%eax)
10d92d: 83 c8 ff or $0xffffffff,%eax
10d930: eb 02 jmp 10d934 <nanosleep+0x100>
10d932: 31 c0 xor %eax,%eax
}
return 0;
}
10d934: 8d 65 f8 lea -0x8(%ebp),%esp
10d937: 5b pop %ebx
10d938: 5e pop %esi
10d939: c9 leave
10d93a: c3 ret
001068a9 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
1068a9: 55 push %ebp
1068aa: 89 e5 mov %esp,%ebp
1068ac: 53 push %ebx
1068ad: 83 ec 10 sub $0x10,%esp
1068b0: 8b 5d 08 mov 0x8(%ebp),%ebx
switch ( fileno(fp) ) {
1068b3: 53 push %ebx
1068b4: e8 5b 8b 00 00 call 10f414 <fileno>
1068b9: 83 c4 10 add $0x10,%esp
1068bc: 83 f8 02 cmp $0x2,%eax
1068bf: 77 26 ja 1068e7 <newlib_free_buffers+0x3e><== NEVER TAKEN
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
1068c1: 80 7b 0c 00 cmpb $0x0,0xc(%ebx)
1068c5: 79 2c jns 1068f3 <newlib_free_buffers+0x4a>
free( fp->_bf._base );
1068c7: 83 ec 0c sub $0xc,%esp
1068ca: ff 73 10 pushl 0x10(%ebx)
1068cd: e8 a6 fb ff ff call 106478 <free>
fp->_flags &= ~__SMBF;
1068d2: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx)
fp->_bf._base = fp->_p = (unsigned char *) NULL;
1068d8: c7 03 00 00 00 00 movl $0x0,(%ebx)
1068de: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
1068e5: eb 09 jmp 1068f0 <newlib_free_buffers+0x47>
}
break;
default:
fclose(fp);
1068e7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1068ea: 53 push %ebx <== NOT EXECUTED
1068eb: e8 84 89 00 00 call 10f274 <fclose> <== NOT EXECUTED
1068f0: 83 c4 10 add $0x10,%esp
}
return 0;
}
1068f3: 31 c0 xor %eax,%eax
1068f5: 8b 5d fc mov -0x4(%ebp),%ebx
1068f8: c9 leave
1068f9: c3 ret
00106a98 <null_initialize>:
rtems_device_driver null_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *pargp
)
{
106a98: 55 push %ebp
106a99: 89 e5 mov %esp,%ebp
106a9b: 53 push %ebx
106a9c: 83 ec 04 sub $0x4,%esp
106a9f: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_device_driver status;
if ( !initialized ) {
106aa2: 80 3d 64 0f 12 00 00 cmpb $0x0,0x120f64
106aa9: 75 2b jne 106ad6 <null_initialize+0x3e>
initialized = 1;
106aab: c6 05 64 0f 12 00 01 movb $0x1,0x120f64
status = rtems_io_register_name(
106ab2: 50 push %eax
106ab3: 6a 00 push $0x0
106ab5: 53 push %ebx
106ab6: 68 01 9d 11 00 push $0x119d01
106abb: e8 f5 00 00 00 call 106bb5 <rtems_io_register_name>
"/dev/null",
major,
(rtems_device_minor_number) 0
);
if (status != RTEMS_SUCCESSFUL)
106ac0: 83 c4 10 add $0x10,%esp
106ac3: 85 c0 test %eax,%eax
106ac5: 74 09 je 106ad0 <null_initialize+0x38> <== ALWAYS TAKEN
rtems_fatal_error_occurred(status);
106ac7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106aca: 50 push %eax <== NOT EXECUTED
106acb: e8 3c 38 00 00 call 10a30c <rtems_fatal_error_occurred><== NOT EXECUTED
NULL_major = major;
106ad0: 89 1d 78 11 12 00 mov %ebx,0x121178
}
return RTEMS_SUCCESSFUL;
}
106ad6: 31 c0 xor %eax,%eax
106ad8: 8b 5d fc mov -0x4(%ebp),%ebx
106adb: c9 leave
106adc: c3 ret
00106a7d <null_write>:
rtems_device_driver null_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *pargp
)
{
106a7d: 55 push %ebp
106a7e: 89 e5 mov %esp,%ebp
106a80: 8b 55 10 mov 0x10(%ebp),%edx
rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) pargp;
if ( rw_args )
106a83: 85 d2 test %edx,%edx
106a85: 74 06 je 106a8d <null_write+0x10> <== ALWAYS TAKEN
rw_args->bytes_moved = rw_args->count;
106a87: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED
106a8a: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED
return NULL_SUCCESSFUL;
}
106a8d: 31 c0 xor %eax,%eax
106a8f: c9 leave
106a90: c3 ret
00106bb0 <open>:
int open(
const char *pathname,
int flags,
...
)
{
106bb0: 55 push %ebp
106bb1: 89 e5 mov %esp,%ebp
106bb3: 57 push %edi
106bb4: 56 push %esi
106bb5: 53 push %ebx
106bb6: 83 ec 1c sub $0x1c,%esp
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
106bb9: 8b 45 0c mov 0xc(%ebp),%eax
106bbc: 40 inc %eax
if ( ( status & _FREAD ) == _FREAD )
106bbd: 89 c3 mov %eax,%ebx
106bbf: 83 e3 01 and $0x1,%ebx
106bc2: f7 db neg %ebx
106bc4: 83 e3 04 and $0x4,%ebx
eval_flags |= RTEMS_LIBIO_PERMS_READ;
if ( ( status & _FWRITE ) == _FWRITE )
106bc7: a8 02 test $0x2,%al
106bc9: 74 03 je 106bce <open+0x1e>
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
106bcb: 83 cb 02 or $0x2,%ebx
va_start(ap, flags);
mode = va_arg( ap, int );
106bce: 8b 45 10 mov 0x10(%ebp),%eax
106bd1: 89 45 dc mov %eax,-0x24(%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();
106bd4: e8 38 64 00 00 call 10d011 <rtems_libio_allocate>
106bd9: 89 45 e0 mov %eax,-0x20(%ebp)
if ( iop == 0 ) {
106bdc: be 17 00 00 00 mov $0x17,%esi
106be1: 85 c0 test %eax,%eax
106be3: 0f 84 8e 01 00 00 je 106d77 <open+0x1c7>
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
106be9: 6a 01 push $0x1
106beb: 8d 7d e4 lea -0x1c(%ebp),%edi
106bee: 57 push %edi
106bef: 53 push %ebx
106bf0: ff 75 08 pushl 0x8(%ebp)
106bf3: e8 5e f7 ff ff call 106356 <rtems_filesystem_evaluate_path>
pathname, eval_flags, &loc, true );
if ( status == -1 ) {
106bf8: 83 c4 10 add $0x10,%esp
106bfb: 40 inc %eax
106bfc: 75 61 jne 106c5f <open+0xaf>
if ( errno != ENOENT ) {
106bfe: e8 25 85 00 00 call 10f128 <__errno>
106c03: 83 38 02 cmpl $0x2,(%eax)
106c06: 75 2c jne 106c34 <open+0x84>
rc = errno;
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
106c08: be 02 00 00 00 mov $0x2,%esi
106c0d: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
106c14: 0f 84 2c 01 00 00 je 106d46 <open+0x196>
rc = ENOENT;
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
106c1a: 6a 00 push $0x0
106c1c: 6a 00 push $0x0
106c1e: 8b 45 dc mov -0x24(%ebp),%eax
106c21: 80 cc 80 or $0x80,%ah
106c24: 50 push %eax
106c25: ff 75 08 pushl 0x8(%ebp)
106c28: e8 df fa ff ff call 10670c <mknod>
if ( rc ) {
106c2d: 83 c4 10 add $0x10,%esp
106c30: 85 c0 test %eax,%eax
106c32: 74 0c je 106c40 <open+0x90> <== ALWAYS TAKEN
rc = errno;
106c34: e8 ef 84 00 00 call 10f128 <__errno>
106c39: 8b 30 mov (%eax),%esi
106c3b: e9 02 01 00 00 jmp 106d42 <open+0x192>
goto done;
}
/* Sanity check to see if the file name exists after the mknod() */
status = rtems_filesystem_evaluate_path( pathname, 0x0, &loc, true );
106c40: 6a 01 push $0x1
106c42: 57 push %edi
106c43: 6a 00 push $0x0
106c45: ff 75 08 pushl 0x8(%ebp)
106c48: e8 09 f7 ff ff call 106356 <rtems_filesystem_evaluate_path>
if ( status != 0 ) { /* The file did not exist */
106c4d: 83 c4 10 add $0x10,%esp
106c50: be 0d 00 00 00 mov $0xd,%esi
106c55: 85 c0 test %eax,%eax
106c57: 0f 85 e9 00 00 00 jne 106d46 <open+0x196> <== NEVER TAKEN
106c5d: eb 1b jmp 106c7a <open+0xca>
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
106c5f: 8b 45 0c mov 0xc(%ebp),%eax
106c62: 25 00 0a 00 00 and $0xa00,%eax
106c67: 3d 00 0a 00 00 cmp $0xa00,%eax
106c6c: 75 0c jne 106c7a <open+0xca>
106c6e: be 11 00 00 00 mov $0x11,%esi
106c73: 89 fb mov %edi,%ebx
106c75: e9 ce 00 00 00 jmp 106d48 <open+0x198>
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->handlers = loc.handlers;
106c7a: 8b 45 e8 mov -0x18(%ebp),%eax
106c7d: 8b 55 e0 mov -0x20(%ebp),%edx
106c80: 89 42 30 mov %eax,0x30(%edx)
iop->file_info = loc.node_access;
106c83: 8b 45 e4 mov -0x1c(%ebp),%eax
106c86: 89 42 2c mov %eax,0x2c(%edx)
iop->flags |= rtems_libio_fcntl_flags( flags );
106c89: 8b 5a 0c mov 0xc(%edx),%ebx
106c8c: 83 ec 0c sub $0xc,%esp
106c8f: ff 75 0c pushl 0xc(%ebp)
106c92: e8 0c 64 00 00 call 10d0a3 <rtems_libio_fcntl_flags>
106c97: 09 c3 or %eax,%ebx
106c99: 8b 45 e0 mov -0x20(%ebp),%eax
106c9c: 89 58 0c mov %ebx,0xc(%eax)
iop->pathinfo = loc;
106c9f: 89 c7 mov %eax,%edi
106ca1: 83 c7 10 add $0x10,%edi
106ca4: 8d 75 e4 lea -0x1c(%ebp),%esi
106ca7: b9 04 00 00 00 mov $0x4,%ecx
106cac: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !iop->handlers->open_h ) {
106cae: 89 c2 mov %eax,%edx
106cb0: 8b 40 30 mov 0x30(%eax),%eax
106cb3: 8b 00 mov (%eax),%eax
106cb5: 83 c4 10 add $0x10,%esp
106cb8: 85 c0 test %eax,%eax
106cba: 0f 84 df 00 00 00 je 106d9f <open+0x1ef> <== NEVER TAKEN
rc = ENOTSUP;
goto done;
}
rc = (*iop->handlers->open_h)( iop, pathname, flags, mode );
106cc0: ff 75 dc pushl -0x24(%ebp)
106cc3: ff 75 0c pushl 0xc(%ebp)
106cc6: ff 75 08 pushl 0x8(%ebp)
106cc9: 52 push %edx
106cca: ff d0 call *%eax
106ccc: 89 c6 mov %eax,%esi
if ( rc )
106cce: 83 c4 10 add $0x10,%esp
106cd1: 85 c0 test %eax,%eax
106cd3: 0f 85 cb 00 00 00 jne 106da4 <open+0x1f4> <== NEVER TAKEN
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
106cd9: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
106ce0: 0f 84 9d 00 00 00 je 106d83 <open+0x1d3>
rc = ftruncate( iop - rtems_libio_iops, 0 );
106ce6: 50 push %eax
106ce7: 50 push %eax
106ce8: 6a 00 push $0x0
106cea: 8b 45 e0 mov -0x20(%ebp),%eax
106ced: 2b 05 38 d6 11 00 sub 0x11d638,%eax
106cf3: c1 f8 02 sar $0x2,%eax
106cf6: 69 c0 c5 4e ec c4 imul $0xc4ec4ec5,%eax,%eax
106cfc: 50 push %eax
106cfd: e8 8e 60 00 00 call 10cd90 <ftruncate>
106d02: 89 c6 mov %eax,%esi
if ( rc ) {
106d04: 83 c4 10 add $0x10,%esp
106d07: 85 c0 test %eax,%eax
106d09: 74 78 je 106d83 <open+0x1d3> <== ALWAYS TAKEN
if(errno) rc = errno;
106d0b: e8 18 84 00 00 call 10f128 <__errno> <== NOT EXECUTED
106d10: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED
106d13: 74 07 je 106d1c <open+0x16c> <== NOT EXECUTED
106d15: e8 0e 84 00 00 call 10f128 <__errno> <== NOT EXECUTED
106d1a: 8b 30 mov (%eax),%esi <== NOT EXECUTED
close( iop - rtems_libio_iops );
106d1c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106d1f: a1 38 d6 11 00 mov 0x11d638,%eax <== NOT EXECUTED
106d24: 29 45 e0 sub %eax,-0x20(%ebp) <== NOT EXECUTED
106d27: c1 7d e0 02 sarl $0x2,-0x20(%ebp) <== NOT EXECUTED
106d2b: 69 45 e0 c5 4e ec c4 imul $0xc4ec4ec5,-0x20(%ebp),%eax <== NOT EXECUTED
106d32: 50 push %eax <== NOT EXECUTED
106d33: e8 d4 5f 00 00 call 10cd0c <close> <== NOT EXECUTED
106d38: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
106d3f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
*/
done:
va_end(ap);
if ( rc ) {
106d42: 85 f6 test %esi,%esi
106d44: 74 3d je 106d83 <open+0x1d3> <== NEVER TAKEN
106d46: 31 db xor %ebx,%ebx
if ( iop )
106d48: 83 7d e0 00 cmpl $0x0,-0x20(%ebp)
106d4c: 74 0e je 106d5c <open+0x1ac> <== NEVER TAKEN
rtems_libio_free( iop );
106d4e: 83 ec 0c sub $0xc,%esp
106d51: ff 75 e0 pushl -0x20(%ebp)
106d54: e8 63 62 00 00 call 10cfbc <rtems_libio_free>
106d59: 83 c4 10 add $0x10,%esp
if ( loc_to_free )
106d5c: 85 db test %ebx,%ebx
106d5e: 74 17 je 106d77 <open+0x1c7>
rtems_filesystem_freenode( loc_to_free );
106d60: 8b 43 08 mov 0x8(%ebx),%eax
106d63: 85 c0 test %eax,%eax
106d65: 74 10 je 106d77 <open+0x1c7> <== NEVER TAKEN
106d67: 8b 40 1c mov 0x1c(%eax),%eax
106d6a: 85 c0 test %eax,%eax
106d6c: 74 09 je 106d77 <open+0x1c7> <== NEVER TAKEN
106d6e: 83 ec 0c sub $0xc,%esp
106d71: 53 push %ebx
106d72: ff d0 call *%eax
106d74: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( rc );
106d77: e8 ac 83 00 00 call 10f128 <__errno>
106d7c: 89 30 mov %esi,(%eax)
106d7e: 83 c8 ff or $0xffffffff,%eax
106d81: eb 14 jmp 106d97 <open+0x1e7>
}
return iop - rtems_libio_iops;
106d83: 8b 15 38 d6 11 00 mov 0x11d638,%edx
106d89: 29 55 e0 sub %edx,-0x20(%ebp)
106d8c: c1 7d e0 02 sarl $0x2,-0x20(%ebp)
106d90: 69 45 e0 c5 4e ec c4 imul $0xc4ec4ec5,-0x20(%ebp),%eax
}
106d97: 8d 65 f4 lea -0xc(%ebp),%esp
106d9a: 5b pop %ebx
106d9b: 5e pop %esi
106d9c: 5f pop %edi
106d9d: c9 leave
106d9e: c3 ret
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
rtems_set_errno_and_return_minus_one( rc );
}
return iop - rtems_libio_iops;
106d9f: be 86 00 00 00 mov $0x86,%esi <== NOT EXECUTED
106da4: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED
106da7: eb 9f jmp 106d48 <open+0x198> <== NOT EXECUTED
00106b50 <open_dev_console>:
/*
* This is a replaceable stub
*/
void open_dev_console(void)
{
106b50: 55 push %ebp
106b51: 89 e5 mov %esp,%ebp
106b53: 83 ec 0c sub $0xc,%esp
int error_code = 'S' << 24 | 'T' << 16 | 'D' << 8;
/*
* Attempt to open /dev/console.
*/
if ((stdin_fd = open("/dev/console", O_RDONLY, 0)) == -1) {
106b56: 6a 00 push $0x0
106b58: 6a 00 push $0x0
106b5a: 68 73 60 11 00 push $0x116073
106b5f: e8 4c 00 00 00 call 106bb0 <open>
106b64: 83 c4 10 add $0x10,%esp
106b67: 40 inc %eax
106b68: 74 41 je 106bab <open_dev_console+0x5b>
/*
* But if we find /dev/console once, we better find it twice more
* or something is REALLY wrong.
*/
if ((stdout_fd = open("/dev/console", O_WRONLY, 0)) == -1)
106b6a: 52 push %edx
106b6b: 6a 00 push $0x0
106b6d: 6a 01 push $0x1
106b6f: 68 73 60 11 00 push $0x116073
106b74: e8 37 00 00 00 call 106bb0 <open>
106b79: 83 c4 10 add $0x10,%esp
106b7c: 40 inc %eax
106b7d: 75 0a jne 106b89 <open_dev_console+0x39> <== ALWAYS TAKEN
rtems_fatal_error_occurred( error_code | '1' );
106b7f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106b82: 68 31 44 54 53 push $0x53544431 <== NOT EXECUTED
106b87: eb 1d jmp 106ba6 <open_dev_console+0x56> <== NOT EXECUTED
if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1)
106b89: 50 push %eax
106b8a: 6a 00 push $0x0
106b8c: 6a 01 push $0x1
106b8e: 68 73 60 11 00 push $0x116073
106b93: e8 18 00 00 00 call 106bb0 <open>
106b98: 83 c4 10 add $0x10,%esp
106b9b: 40 inc %eax
106b9c: 75 0d jne 106bab <open_dev_console+0x5b> <== ALWAYS TAKEN
rtems_fatal_error_occurred( error_code | '2' );
106b9e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106ba1: 68 32 44 54 53 push $0x53544432 <== NOT EXECUTED
106ba6: e8 e9 2b 00 00 call 109794 <rtems_fatal_error_occurred><== NOT EXECUTED
}
106bab: c9 leave
106bac: c3 ret
00108450 <opendir>:
* open a directory.
*/
DIR *
opendir(
const char *name )
{
108450: 55 push %ebp
108451: 89 e5 mov %esp,%ebp
108453: 56 push %esi
108454: 53 push %ebx
register DIR *dirp;
register int fd;
if ((fd = open(name, 0)) == -1)
108455: 52 push %edx
108456: 52 push %edx
108457: 6a 00 push $0x0
108459: ff 75 08 pushl 0x8(%ebp)
10845c: e8 77 00 00 00 call 1084d8 <open>
108461: 89 c6 mov %eax,%esi
108463: 83 c4 10 add $0x10,%esp
108466: 31 db xor %ebx,%ebx
108468: 83 f8 ff cmp $0xffffffff,%eax
10846b: 74 62 je 1084cf <opendir+0x7f> <== NEVER TAKEN
return NULL;
if (fcntl(fd, F_SETFD, 1) == -1 ||
10846d: 50 push %eax
10846e: 6a 01 push $0x1
108470: 6a 02 push $0x2
108472: 56 push %esi
108473: e8 8c 65 00 00 call 10ea04 <fcntl>
108478: 83 c4 10 add $0x10,%esp
10847b: 40 inc %eax
10847c: 74 31 je 1084af <opendir+0x5f> <== NEVER TAKEN
10847e: 83 ec 0c sub $0xc,%esp
108481: 6a 18 push $0x18
108483: e8 10 f8 ff ff call 107c98 <malloc>
108488: 89 c3 mov %eax,%ebx
10848a: 83 c4 10 add $0x10,%esp
10848d: 85 c0 test %eax,%eax
10848f: 74 1e je 1084af <opendir+0x5f> <== NEVER TAKEN
* If CLSIZE is an exact multiple of DIRBLKSIZ, use a CLSIZE
* buffer that it cluster boundary aligned.
* Hopefully this can be a big win someday by allowing page trades
* to user space to be done by getdirentries()
*/
dirp->dd_buf = malloc (512);
108491: 83 ec 0c sub $0xc,%esp
108494: 68 00 02 00 00 push $0x200
108499: e8 fa f7 ff ff call 107c98 <malloc>
10849e: 89 43 0c mov %eax,0xc(%ebx)
dirp->dd_len = 512;
1084a1: c7 43 10 00 02 00 00 movl $0x200,0x10(%ebx)
if (dirp->dd_buf == NULL) {
1084a8: 83 c4 10 add $0x10,%esp
1084ab: 85 c0 test %eax,%eax
1084ad: 75 10 jne 1084bf <opendir+0x6f> <== ALWAYS TAKEN
close (fd);
1084af: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1084b2: 56 push %esi <== NOT EXECUTED
1084b3: e8 80 ef ff ff call 107438 <close> <== NOT EXECUTED
1084b8: 31 db xor %ebx,%ebx <== NOT EXECUTED
1084ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1084bd: eb 10 jmp 1084cf <opendir+0x7f> <== NOT EXECUTED
return NULL;
}
dirp->dd_fd = fd;
1084bf: 89 33 mov %esi,(%ebx)
dirp->dd_loc = 0;
1084c1: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
dirp->dd_seek = 0;
1084c8: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
/*
* Set up seek point for rewinddir.
*/
return dirp;
}
1084cf: 89 d8 mov %ebx,%eax
1084d1: 8d 65 f8 lea -0x8(%ebp),%esp
1084d4: 5b pop %ebx
1084d5: 5e pop %esi
1084d6: c9 leave
1084d7: c3 ret
001077a8 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
1077a8: 55 push %ebp
1077a9: 89 e5 mov %esp,%ebp
1077ab: 56 push %esi
1077ac: 53 push %ebx
1077ad: 83 ec 10 sub $0x10,%esp
1077b0: 89 d3 mov %edx,%ebx
1077b2: 88 45 f4 mov %al,-0xc(%ebp)
int i;
if (tty->termios.c_oflag & OPOST) {
1077b5: 8b 4a 34 mov 0x34(%edx),%ecx
1077b8: f6 c1 01 test $0x1,%cl
1077bb: 0f 84 df 00 00 00 je 1078a0 <oproc+0xf8> <== NEVER TAKEN
switch (c) {
1077c1: 3c 09 cmp $0x9,%al
1077c3: 74 76 je 10783b <oproc+0x93>
1077c5: 77 0d ja 1077d4 <oproc+0x2c> <== ALWAYS TAKEN
1077c7: 3c 08 cmp $0x8,%al <== NOT EXECUTED
1077c9: 0f 85 a6 00 00 00 jne 107875 <oproc+0xcd> <== NOT EXECUTED
1077cf: e9 94 00 00 00 jmp 107868 <oproc+0xc0> <== NOT EXECUTED
1077d4: 3c 0a cmp $0xa,%al
1077d6: 74 0a je 1077e2 <oproc+0x3a>
1077d8: 3c 0d cmp $0xd,%al
1077da: 0f 85 95 00 00 00 jne 107875 <oproc+0xcd> <== ALWAYS TAKEN
1077e0: eb 33 jmp 107815 <oproc+0x6d> <== NOT EXECUTED
case '\n':
if (tty->termios.c_oflag & ONLRET)
1077e2: 80 e1 20 and $0x20,%cl
1077e5: 74 07 je 1077ee <oproc+0x46> <== ALWAYS TAKEN
tty->column = 0;
1077e7: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLCR) {
1077ee: f6 43 34 04 testb $0x4,0x34(%ebx)
1077f2: 0f 84 a8 00 00 00 je 1078a0 <oproc+0xf8> <== NEVER TAKEN
rtems_termios_puts ("\r", 1, tty);
1077f8: 50 push %eax
1077f9: 53 push %ebx
1077fa: 6a 01 push $0x1
1077fc: 68 47 72 11 00 push $0x117247
107801: e8 8d fe ff ff call 107693 <rtems_termios_puts>
tty->column = 0;
107806: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx)
10780d: 83 c4 10 add $0x10,%esp
107810: e9 8b 00 00 00 jmp 1078a0 <oproc+0xf8>
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
107815: f6 c1 10 test $0x10,%cl <== NOT EXECUTED
107818: 74 0a je 107824 <oproc+0x7c> <== NOT EXECUTED
10781a: 83 7a 28 00 cmpl $0x0,0x28(%edx) <== NOT EXECUTED
10781e: 0f 84 8c 00 00 00 je 1078b0 <oproc+0x108> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
107824: f6 c1 08 test $0x8,%cl <== NOT EXECUTED
107827: 74 09 je 107832 <oproc+0x8a> <== NOT EXECUTED
c = '\n';
107829: c6 45 f4 0a movb $0xa,-0xc(%ebp) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
10782d: 80 e1 20 and $0x20,%cl <== NOT EXECUTED
107830: 74 6e je 1078a0 <oproc+0xf8> <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
107832: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED
107839: eb 65 jmp 1078a0 <oproc+0xf8> <== NOT EXECUTED
break;
case '\t':
i = 8 - (tty->column & 7);
10783b: 8b 52 28 mov 0x28(%edx),%edx
10783e: 89 d0 mov %edx,%eax
107840: 83 e0 07 and $0x7,%eax
107843: be 08 00 00 00 mov $0x8,%esi
107848: 29 c6 sub %eax,%esi
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
10784a: 81 e1 00 18 00 00 and $0x1800,%ecx
107850: 81 f9 00 18 00 00 cmp $0x1800,%ecx
107856: 8d 04 16 lea (%esi,%edx,1),%eax
107859: 75 15 jne 107870 <oproc+0xc8> <== NEVER TAKEN
tty->column += i;
10785b: 89 43 28 mov %eax,0x28(%ebx)
rtems_termios_puts ( " ", i, tty);
10785e: 50 push %eax
10785f: 53 push %ebx
107860: 56 push %esi
107861: 68 49 72 11 00 push $0x117249
107866: eb 40 jmp 1078a8 <oproc+0x100>
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
107868: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED
10786b: 85 c0 test %eax,%eax <== NOT EXECUTED
10786d: 7e 31 jle 1078a0 <oproc+0xf8> <== NOT EXECUTED
tty->column--;
10786f: 48 dec %eax <== NOT EXECUTED
107870: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
107873: eb 2b jmp 1078a0 <oproc+0xf8> <== NOT EXECUTED
break;
default:
if (tty->termios.c_oflag & OLCUC)
107875: 80 e1 02 and $0x2,%cl
107878: 74 14 je 10788e <oproc+0xe6> <== ALWAYS TAKEN
c = toupper(c);
10787a: 0f b6 d0 movzbl %al,%edx <== NOT EXECUTED
10787d: a1 00 b7 11 00 mov 0x11b700,%eax <== NOT EXECUTED
107882: f6 04 10 02 testb $0x2,(%eax,%edx,1) <== NOT EXECUTED
107886: 74 03 je 10788b <oproc+0xe3> <== NOT EXECUTED
107888: 83 ea 20 sub $0x20,%edx <== NOT EXECUTED
10788b: 88 55 f4 mov %dl,-0xc(%ebp) <== NOT EXECUTED
if (!iscntrl(c))
10788e: 0f b6 55 f4 movzbl -0xc(%ebp),%edx
107892: a1 00 b7 11 00 mov 0x11b700,%eax
107897: f6 04 10 20 testb $0x20,(%eax,%edx,1)
10789b: 75 03 jne 1078a0 <oproc+0xf8> <== NEVER TAKEN
tty->column++;
10789d: ff 43 28 incl 0x28(%ebx)
break;
}
}
rtems_termios_puts (&c, 1, tty);
1078a0: 56 push %esi
1078a1: 53 push %ebx
1078a2: 6a 01 push $0x1
1078a4: 8d 45 f4 lea -0xc(%ebp),%eax
1078a7: 50 push %eax
1078a8: e8 e6 fd ff ff call 107693 <rtems_termios_puts>
1078ad: 83 c4 10 add $0x10,%esp
}
1078b0: 8d 65 f8 lea -0x8(%ebp),%esp
1078b3: 5b pop %ebx
1078b4: 5e pop %esi
1078b5: c9 leave
1078b6: c3 ret
00108204 <posix_memalign>:
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
108204: 55 push %ebp
108205: 89 e5 mov %esp,%ebp
108207: 53 push %ebx
108208: 8b 5d 08 mov 0x8(%ebp),%ebx
10820b: 8b 55 0c mov 0xc(%ebp),%edx
10820e: 8b 4d 10 mov 0x10(%ebp),%ecx
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
108211: ff 05 9c 29 12 00 incl 0x12299c
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
108217: 8d 42 ff lea -0x1(%edx),%eax
10821a: 85 d0 test %edx,%eax
10821c: 75 05 jne 108223 <posix_memalign+0x1f> <== NEVER TAKEN
10821e: 83 fa 03 cmp $0x3,%edx
108221: 77 08 ja 10822b <posix_memalign+0x27>
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
}
108223: b8 16 00 00 00 mov $0x16,%eax
108228: 5b pop %ebx
108229: c9 leave
10822a: c3 ret
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
10822b: 89 4d 10 mov %ecx,0x10(%ebp)
10822e: 89 55 0c mov %edx,0xc(%ebp)
108231: 89 5d 08 mov %ebx,0x8(%ebp)
}
108234: 5b pop %ebx
108235: c9 leave
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
108236: e9 c1 03 00 00 jmp 1085fc <rtems_memalign>
001091cc <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
1091cc: 55 push %ebp
1091cd: 89 e5 mov %esp,%ebp
1091cf: 57 push %edi
1091d0: 56 push %esi
1091d1: 53 push %ebx
1091d2: 83 ec 1c sub $0x1c,%esp
1091d5: 8b 7d 08 mov 0x8(%ebp),%edi
1091d8: 8b 75 10 mov 0x10(%ebp),%esi
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
1091db: 85 ff test %edi,%edi
1091dd: 0f 84 94 00 00 00 je 109277 <pthread_barrier_init+0xab>
return EINVAL;
if ( count == 0 )
1091e3: 85 f6 test %esi,%esi
1091e5: 0f 84 8c 00 00 00 je 109277 <pthread_barrier_init+0xab>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
1091eb: 8b 45 0c mov 0xc(%ebp),%eax
1091ee: 85 c0 test %eax,%eax
1091f0: 75 11 jne 109203 <pthread_barrier_init+0x37>
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
1091f2: 83 ec 0c sub $0xc,%esp
1091f5: 8d 5d e4 lea -0x1c(%ebp),%ebx
1091f8: 53 push %ebx
1091f9: e8 1a ff ff ff call 109118 <pthread_barrierattr_init>
1091fe: 89 d8 mov %ebx,%eax
109200: 83 c4 10 add $0x10,%esp
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
109203: 83 38 00 cmpl $0x0,(%eax)
109206: 74 6f je 109277 <pthread_barrier_init+0xab>
return EINVAL;
switch ( the_attr->process_shared ) {
109208: 83 78 04 00 cmpl $0x0,0x4(%eax)
10920c: 75 69 jne 109277 <pthread_barrier_init+0xab><== NEVER TAKEN
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
10920e: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
the_attributes.maximum_count = count;
109215: 89 75 f0 mov %esi,-0x10(%ebp)
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
109218: a1 90 ec 11 00 mov 0x11ec90,%eax
10921d: 40 inc %eax
10921e: a3 90 ec 11 00 mov %eax,0x11ec90
*/
/**@{*/
#ifdef __cplusplus
extern "C" {
#endif
109223: 83 ec 0c sub $0xc,%esp
109226: 68 80 f0 11 00 push $0x11f080
10922b: e8 d4 1f 00 00 call 10b204 <_Objects_Allocate>
109230: 89 c3 mov %eax,%ebx
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
109232: 83 c4 10 add $0x10,%esp
109235: 85 c0 test %eax,%eax
109237: 75 0c jne 109245 <pthread_barrier_init+0x79>
_Thread_Enable_dispatch();
109239: e8 ca 2b 00 00 call 10be08 <_Thread_Enable_dispatch>
10923e: b8 0b 00 00 00 mov $0xb,%eax
109243: eb 37 jmp 10927c <pthread_barrier_init+0xb0>
return EAGAIN;
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
109245: 50 push %eax
109246: 50 push %eax
109247: 8d 45 ec lea -0x14(%ebp),%eax
10924a: 50 push %eax
10924b: 8d 43 10 lea 0x10(%ebx),%eax
10924e: 50 push %eax
10924f: e8 ac 17 00 00 call 10aa00 <_CORE_barrier_Initialize>
109254: 8b 4b 08 mov 0x8(%ebx),%ecx
109257: 0f b7 d1 movzwl %cx,%edx
10925a: a1 9c f0 11 00 mov 0x11f09c,%eax
10925f: 89 1c 90 mov %ebx,(%eax,%edx,4)
109262: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
109269: 89 0f mov %ecx,(%edi)
_Thread_Enable_dispatch();
10926b: e8 98 2b 00 00 call 10be08 <_Thread_Enable_dispatch>
109270: 31 c0 xor %eax,%eax
109272: 83 c4 10 add $0x10,%esp
109275: eb 05 jmp 10927c <pthread_barrier_init+0xb0>
return 0;
109277: b8 16 00 00 00 mov $0x16,%eax
}
10927c: 8d 65 f4 lea -0xc(%ebp),%esp
10927f: 5b pop %ebx
109280: 5e pop %esi
109281: 5f pop %edi
109282: c9 leave
109283: c3 ret
00108a54 <pthread_cancel>:
*/
int pthread_cancel(
pthread_t thread
)
{
108a54: 55 push %ebp
108a55: 89 e5 mov %esp,%ebp
108a57: 56 push %esi
108a58: 53 push %ebx
108a59: 83 ec 10 sub $0x10,%esp
/*
* Don't even think about deleting a resource from an ISR.
*/
if ( _ISR_Is_in_progress() )
108a5c: a1 84 f5 11 00 mov 0x11f584,%eax
108a61: ba 47 00 00 00 mov $0x47,%edx
108a66: 85 c0 test %eax,%eax
108a68: 75 5d jne 108ac7 <pthread_cancel+0x73> <== NEVER TAKEN
return EPROTO;
the_thread = _Thread_Get( thread, &location );
108a6a: 52 push %edx
108a6b: 52 push %edx
108a6c: 8d 45 f4 lea -0xc(%ebp),%eax
108a6f: 50 push %eax
108a70: ff 75 08 pushl 0x8(%ebp)
108a73: e8 74 2d 00 00 call 10b7ec <_Thread_Get>
108a78: 89 c6 mov %eax,%esi
switch ( location ) {
108a7a: 83 c4 10 add $0x10,%esp
108a7d: ba 16 00 00 00 mov $0x16,%edx
108a82: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
108a86: 75 3f jne 108ac7 <pthread_cancel+0x73> <== NEVER TAKEN
case OBJECTS_LOCAL:
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
108a88: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax
thread_support->cancelation_requested = 1;
108a8e: c7 80 d4 00 00 00 01 movl $0x1,0xd4(%eax)
108a95: 00 00 00
if (thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
108a98: 31 db xor %ebx,%ebx
108a9a: 83 b8 cc 00 00 00 00 cmpl $0x0,0xcc(%eax)
108aa1: 75 0a jne 108aad <pthread_cancel+0x59> <== NEVER TAKEN
108aa3: 83 b8 d0 00 00 00 01 cmpl $0x1,0xd0(%eax)
108aaa: 0f 94 c3 sete %bl
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS)
cancel = true;
_Thread_Enable_dispatch();
108aad: e8 1a 2d 00 00 call 10b7cc <_Thread_Enable_dispatch>
if ( cancel )
108ab2: 31 d2 xor %edx,%edx
108ab4: 84 db test %bl,%bl
108ab6: 74 0f je 108ac7 <pthread_cancel+0x73>
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
108ab8: 50 push %eax
108ab9: 50 push %eax
108aba: 6a ff push $0xffffffff
108abc: 56 push %esi
108abd: e8 a2 02 00 00 call 108d64 <_POSIX_Thread_Exit>
108ac2: 31 d2 xor %edx,%edx
108ac4: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
108ac7: 89 d0 mov %edx,%eax
108ac9: 8d 65 f8 lea -0x8(%ebp),%esp
108acc: 5b pop %ebx
108acd: 5e pop %esi
108ace: c9 leave
108acf: c3 ret
00108ed4 <pthread_cleanup_pop>:
*/
void pthread_cleanup_pop(
int execute
)
{
108ed4: 55 push %ebp
108ed5: 89 e5 mov %esp,%ebp
108ed7: 57 push %edi
108ed8: 56 push %esi
108ed9: 53 push %ebx
108eda: 83 ec 1c sub $0x1c,%esp
108edd: 8b 45 08 mov 0x8(%ebp),%eax
108ee0: 89 45 e0 mov %eax,-0x20(%ebp)
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 ];
108ee3: a1 40 0d 12 00 mov 0x120d40,%eax
108ee8: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
108eee: a1 80 0c 12 00 mov 0x120c80,%eax
108ef3: 40 inc %eax
108ef4: a3 80 0c 12 00 mov %eax,0x120c80
* 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 );
108ef9: 9c pushf
108efa: fa cli
108efb: 5f pop %edi
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
108efc: 8d 82 dc 00 00 00 lea 0xdc(%edx),%eax
if ( _Chain_Is_empty( handler_stack ) ) {
108f02: 39 82 d8 00 00 00 cmp %eax,0xd8(%edx)
108f08: 75 09 jne 108f13 <pthread_cleanup_pop+0x3f>
_Thread_Enable_dispatch();
108f0a: e8 29 30 00 00 call 10bf38 <_Thread_Enable_dispatch>
_ISR_Enable( level );
108f0f: 57 push %edi
108f10: 9d popf
108f11: eb 4c jmp 108f5f <pthread_cleanup_pop+0x8b>
return;
}
handler = (POSIX_Cancel_Handler_control *)
108f13: 8b 40 04 mov 0x4(%eax),%eax
108f16: 89 45 d8 mov %eax,-0x28(%ebp)
108f19: 8b 10 mov (%eax),%edx
108f1b: 8b 40 04 mov 0x4(%eax),%eax
108f1e: 89 42 04 mov %eax,0x4(%edx)
108f21: 89 10 mov %edx,(%eax)
_Chain_Tail( handler_stack )->previous;
_Chain_Extract_unprotected( &handler->Node );
_ISR_Enable( level );
108f23: 57 push %edi
108f24: 9d popf
tmp_handler = *handler;
108f25: 8d 7d e4 lea -0x1c(%ebp),%edi
108f28: b9 04 00 00 00 mov $0x4,%ecx
108f2d: 8b 75 d8 mov -0x28(%ebp),%esi
108f30: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
108f32: 8b 5d ec mov -0x14(%ebp),%ebx
108f35: 8b 7d f0 mov -0x10(%ebp),%edi
_Workspace_Free( handler );
108f38: 83 ec 0c sub $0xc,%esp
108f3b: ff 75 d8 pushl -0x28(%ebp)
108f3e: e8 0d 40 00 00 call 10cf50 <_Workspace_Free>
_Thread_Enable_dispatch();
108f43: e8 f0 2f 00 00 call 10bf38 <_Thread_Enable_dispatch>
if ( execute )
108f48: 83 c4 10 add $0x10,%esp
108f4b: 83 7d e0 00 cmpl $0x0,-0x20(%ebp)
108f4f: 74 0e je 108f5f <pthread_cleanup_pop+0x8b><== NEVER TAKEN
(*tmp_handler.routine)( tmp_handler.arg );
108f51: 89 7d 08 mov %edi,0x8(%ebp)
108f54: 89 d9 mov %ebx,%ecx
}
108f56: 8d 65 f4 lea -0xc(%ebp),%esp
108f59: 5b pop %ebx
108f5a: 5e pop %esi
108f5b: 5f pop %edi
108f5c: c9 leave
_Workspace_Free( handler );
_Thread_Enable_dispatch();
if ( execute )
(*tmp_handler.routine)( tmp_handler.arg );
108f5d: ff e1 jmp *%ecx
}
108f5f: 8d 65 f4 lea -0xc(%ebp),%esp
108f62: 5b pop %ebx
108f63: 5e pop %esi
108f64: 5f pop %edi
108f65: c9 leave
108f66: c3 ret
00108f68 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
108f68: 55 push %ebp
108f69: 89 e5 mov %esp,%ebp
108f6b: 56 push %esi
108f6c: 53 push %ebx
108f6d: 8b 5d 08 mov 0x8(%ebp),%ebx
108f70: 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 )
108f73: 85 db test %ebx,%ebx
108f75: 74 4b je 108fc2 <pthread_cleanup_push+0x5a>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
108f77: a1 80 0c 12 00 mov 0x120c80,%eax
108f7c: 40 inc %eax
108f7d: a3 80 0c 12 00 mov %eax,0x120c80
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
108f82: 83 ec 0c sub $0xc,%esp
108f85: 6a 10 push $0x10
108f87: e8 d9 3f 00 00 call 10cf65 <_Workspace_Allocate>
108f8c: 89 c2 mov %eax,%edx
if ( handler ) {
108f8e: 83 c4 10 add $0x10,%esp
108f91: 85 c0 test %eax,%eax
108f93: 74 22 je 108fb7 <pthread_cleanup_push+0x4f><== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
handler_stack = &thread_support->Cancellation_Handlers;
108f95: a1 40 0d 12 00 mov 0x120d40,%eax
108f9a: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax
108fa0: 05 d8 00 00 00 add $0xd8,%eax
handler->routine = routine;
108fa5: 89 5a 08 mov %ebx,0x8(%edx)
handler->arg = arg;
108fa8: 89 72 0c mov %esi,0xc(%edx)
_Chain_Append( handler_stack, &handler->Node );
108fab: 51 push %ecx
108fac: 51 push %ecx
108fad: 52 push %edx
108fae: 50 push %eax
108faf: e8 e4 1b 00 00 call 10ab98 <_Chain_Append>
108fb4: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
}
108fb7: 8d 65 f8 lea -0x8(%ebp),%esp
108fba: 5b pop %ebx
108fbb: 5e pop %esi
108fbc: c9 leave
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
}
_Thread_Enable_dispatch();
108fbd: e9 76 2f 00 00 jmp 10bf38 <_Thread_Enable_dispatch>
}
108fc2: 8d 65 f8 lea -0x8(%ebp),%esp
108fc5: 5b pop %ebx
108fc6: 5e pop %esi
108fc7: c9 leave
108fc8: c3 ret
00109a98 <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
109a98: 55 push %ebp
109a99: 89 e5 mov %esp,%ebp
109a9b: 56 push %esi
109a9c: 53 push %ebx
109a9d: 8b 45 0c mov 0xc(%ebp),%eax
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
109aa0: be c8 a8 11 00 mov $0x11a8c8,%esi
109aa5: 85 c0 test %eax,%eax
109aa7: 74 02 je 109aab <pthread_cond_init+0x13>
109aa9: 89 c6 mov %eax,%esi
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
109aab: 83 7e 04 01 cmpl $0x1,0x4(%esi)
109aaf: 74 77 je 109b28 <pthread_cond_init+0x90><== NEVER TAKEN
return EINVAL;
if ( !the_attr->is_initialized )
109ab1: 83 3e 00 cmpl $0x0,(%esi)
109ab4: 74 72 je 109b28 <pthread_cond_init+0x90>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
109ab6: a1 60 10 12 00 mov 0x121060,%eax
109abb: 40 inc %eax
109abc: a3 60 10 12 00 mov %eax,0x121060
/**@{*/
#ifdef __cplusplus
extern "C" {
#endif
109ac1: 83 ec 0c sub $0xc,%esp
109ac4: 68 d4 14 12 00 push $0x1214d4
109ac9: e8 b6 24 00 00 call 10bf84 <_Objects_Allocate>
109ace: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
109ad0: 83 c4 10 add $0x10,%esp
109ad3: 85 c0 test %eax,%eax
109ad5: 75 0c jne 109ae3 <pthread_cond_init+0x4b>
_Thread_Enable_dispatch();
109ad7: e8 ac 30 00 00 call 10cb88 <_Thread_Enable_dispatch>
109adc: b8 0c 00 00 00 mov $0xc,%eax
109ae1: eb 4a jmp 109b2d <pthread_cond_init+0x95>
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
109ae3: 8b 46 04 mov 0x4(%esi),%eax
109ae6: 89 43 10 mov %eax,0x10(%ebx)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
109ae9: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
/* XXX some more initialization might need to go here */
_Thread_queue_Initialize(
109af0: 6a 74 push $0x74
109af2: 68 00 08 00 00 push $0x800
109af7: 6a 00 push $0x0
109af9: 8d 43 18 lea 0x18(%ebx),%eax
109afc: 50 push %eax
109afd: e8 56 37 00 00 call 10d258 <_Thread_queue_Initialize>
109b02: 8b 4b 08 mov 0x8(%ebx),%ecx
109b05: 0f b7 d1 movzwl %cx,%edx
109b08: a1 f0 14 12 00 mov 0x1214f0,%eax
109b0d: 89 1c 90 mov %ebx,(%eax,%edx,4)
109b10: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
109b17: 8b 45 08 mov 0x8(%ebp),%eax
109b1a: 89 08 mov %ecx,(%eax)
_Thread_Enable_dispatch();
109b1c: e8 67 30 00 00 call 10cb88 <_Thread_Enable_dispatch>
109b21: 31 c0 xor %eax,%eax
109b23: 83 c4 10 add $0x10,%esp
109b26: eb 05 jmp 109b2d <pthread_cond_init+0x95>
return 0;
109b28: b8 16 00 00 00 mov $0x16,%eax
}
109b2d: 8d 65 f8 lea -0x8(%ebp),%esp
109b30: 5b pop %ebx
109b31: 5e pop %esi
109b32: c9 leave
109b33: c3 ret
00109950 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
109950: 55 push %ebp
109951: 89 e5 mov %esp,%ebp
109953: 8b 45 08 mov 0x8(%ebp),%eax
if ( !attr || attr->is_initialized == FALSE )
109956: 85 c0 test %eax,%eax
109958: 74 0f je 109969 <pthread_condattr_destroy+0x19>
10995a: 83 38 00 cmpl $0x0,(%eax)
10995d: 74 0a je 109969 <pthread_condattr_destroy+0x19><== NEVER TAKEN
return EINVAL;
attr->is_initialized = FALSE;
10995f: c7 00 00 00 00 00 movl $0x0,(%eax)
109965: 31 c0 xor %eax,%eax
109967: eb 05 jmp 10996e <pthread_condattr_destroy+0x1e>
return 0;
109969: b8 16 00 00 00 mov $0x16,%eax
}
10996e: c9 leave
10996f: c3 ret
00109a24 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
109a24: 55 push %ebp
109a25: 89 e5 mov %esp,%ebp
109a27: 57 push %edi
109a28: 56 push %esi
109a29: 53 push %ebx
109a2a: 83 ec 2c sub $0x2c,%esp
109a2d: 8b 75 0c mov 0xc(%ebp),%esi
POSIX_API_Control *api;
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
if ( !start_routine )
109a30: b8 0e 00 00 00 mov $0xe,%eax
109a35: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
109a39: 0f 84 6e 02 00 00 je 109cad <pthread_create+0x289>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
109a3f: c7 45 c8 4c a9 11 00 movl $0x11a94c,-0x38(%ebp)
109a46: 85 f6 test %esi,%esi
109a48: 74 03 je 109a4d <pthread_create+0x29>
109a4a: 89 75 c8 mov %esi,-0x38(%ebp)
if ( !the_attr->is_initialized )
109a4d: 8b 45 c8 mov -0x38(%ebp),%eax
109a50: 83 38 00 cmpl $0x0,(%eax)
109a53: 0f 84 4f 02 00 00 je 109ca8 <pthread_create+0x284>
* 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) )
109a59: 83 78 04 00 cmpl $0x0,0x4(%eax)
109a5d: 74 0f je 109a6e <pthread_create+0x4a>
109a5f: 8b 40 08 mov 0x8(%eax),%eax
109a62: 3b 05 00 cd 11 00 cmp 0x11cd00,%eax
109a68: 0f 82 3a 02 00 00 jb 109ca8 <pthread_create+0x284> <== ALWAYS TAKEN
* 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 ) {
109a6e: 8b 55 c8 mov -0x38(%ebp),%edx
109a71: 8b 42 10 mov 0x10(%edx),%eax
109a74: 83 f8 01 cmp $0x1,%eax
109a77: 74 0b je 109a84 <pthread_create+0x60>
109a79: 83 f8 02 cmp $0x2,%eax
109a7c: 0f 85 26 02 00 00 jne 109ca8 <pthread_create+0x284>
109a82: eb 1c jmp 109aa0 <pthread_create+0x7c>
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
109a84: a1 b0 11 12 00 mov 0x1211b0,%eax
109a89: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax
schedpolicy = api->schedpolicy;
109a8f: 8b 50 7c mov 0x7c(%eax),%edx
109a92: 89 55 d0 mov %edx,-0x30(%ebp)
schedparam = api->schedparam;
109a95: 8d 7d dc lea -0x24(%ebp),%edi
109a98: 8d b0 80 00 00 00 lea 0x80(%eax),%esi
109a9e: eb 12 jmp 109ab2 <pthread_create+0x8e>
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
109aa0: 8b 45 c8 mov -0x38(%ebp),%eax
109aa3: 8b 40 14 mov 0x14(%eax),%eax
109aa6: 89 45 d0 mov %eax,-0x30(%ebp)
schedparam = the_attr->schedparam;
109aa9: 8d 7d dc lea -0x24(%ebp),%edi
109aac: 8b 75 c8 mov -0x38(%ebp),%esi
109aaf: 83 c6 18 add $0x18,%esi
109ab2: b9 06 00 00 00 mov $0x6,%ecx
109ab7: 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 )
109ab9: b8 86 00 00 00 mov $0x86,%eax
109abe: 8b 55 c8 mov -0x38(%ebp),%edx
109ac1: 83 7a 0c 00 cmpl $0x0,0xc(%edx)
109ac5: 0f 85 e2 01 00 00 jne 109cad <pthread_create+0x289>
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
109acb: 8b 7d dc mov -0x24(%ebp),%edi
109ace: 8d 47 ff lea -0x1(%edi),%eax
109ad1: 3d fd 00 00 00 cmp $0xfd,%eax
109ad6: 0f 87 cc 01 00 00 ja 109ca8 <pthread_create+0x284> <== NEVER TAKEN
*/
budget_callout = NULL;
budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
switch ( schedpolicy ) {
109adc: 83 7d d0 01 cmpl $0x1,-0x30(%ebp)
109ae0: 74 24 je 109b06 <pthread_create+0xe2>
109ae2: 7f 10 jg 109af4 <pthread_create+0xd0>
109ae4: be 01 00 00 00 mov $0x1,%esi
109ae9: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
109aed: 74 19 je 109b08 <pthread_create+0xe4>
109aef: e9 b4 01 00 00 jmp 109ca8 <pthread_create+0x284>
109af4: 83 7d d0 02 cmpl $0x2,-0x30(%ebp)
109af8: 74 12 je 109b0c <pthread_create+0xe8> <== NEVER TAKEN
109afa: 83 7d d0 03 cmpl $0x3,-0x30(%ebp)
109afe: 0f 85 a4 01 00 00 jne 109ca8 <pthread_create+0x284> <== NEVER TAKEN
109b04: eb 0d jmp 109b13 <pthread_create+0xef>
109b06: 31 f6 xor %esi,%esi
109b08: 31 db xor %ebx,%ebx
109b0a: eb 44 jmp 109b50 <pthread_create+0x12c>
109b0c: be 02 00 00 00 mov $0x2,%esi <== NOT EXECUTED
109b11: eb f5 jmp 109b08 <pthread_create+0xe4> <== NOT EXECUTED
case SCHED_SPORADIC:
budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
budget_callout = _POSIX_Threads_Sporadic_budget_callout;
if ( _Timespec_To_ticks( &schedparam.ss_replenish_period ) <
109b13: 83 ec 0c sub $0xc,%esp
109b16: 8d 45 e4 lea -0x1c(%ebp),%eax
109b19: 50 push %eax
109b1a: e8 6d 39 00 00 call 10d48c <_Timespec_To_ticks>
109b1f: 89 c3 mov %eax,%ebx
109b21: 8d 45 ec lea -0x14(%ebp),%eax
109b24: 89 04 24 mov %eax,(%esp)
109b27: e8 60 39 00 00 call 10d48c <_Timespec_To_ticks>
109b2c: 83 c4 10 add $0x10,%esp
109b2f: 39 c3 cmp %eax,%ebx
109b31: 0f 82 71 01 00 00 jb 109ca8 <pthread_create+0x284> <== NEVER TAKEN
_Timespec_To_ticks( &schedparam.ss_initial_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( schedparam.ss_low_priority ) )
109b37: 8b 45 e0 mov -0x20(%ebp),%eax
109b3a: 48 dec %eax
109b3b: 3d fd 00 00 00 cmp $0xfd,%eax
109b40: 0f 87 62 01 00 00 ja 109ca8 <pthread_create+0x284> <== NEVER TAKEN
109b46: be 03 00 00 00 mov $0x3,%esi
109b4b: bb e8 9f 10 00 mov $0x109fe8,%ebx
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
109b50: 83 ec 0c sub $0xc,%esp
109b53: ff 35 a8 11 12 00 pushl 0x1211a8
109b59: e8 5e 18 00 00 call 10b3bc <_API_Mutex_Lock>
* It is a simple wrapper for the help with the addition of the
* allocation mutex being used for protection.
*/
/**@{*/
#ifdef __cplusplus
109b5e: c7 04 24 60 13 12 00 movl $0x121360,(%esp)
109b65: e8 12 21 00 00 call 10bc7c <_Objects_Allocate>
109b6a: 89 45 cc mov %eax,-0x34(%ebp)
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
109b6d: 83 c4 10 add $0x10,%esp
109b70: 85 c0 test %eax,%eax
109b72: 75 05 jne 109b79 <pthread_create+0x155>
_RTEMS_Unlock_allocator();
109b74: 83 ec 0c sub $0xc,%esp
109b77: eb 51 jmp 109bca <pthread_create+0x1a6>
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
109b79: 8b 45 c8 mov -0x38(%ebp),%eax
109b7c: 8b 50 08 mov 0x8(%eax),%edx
109b7f: 50 push %eax
109b80: 6a 00 push $0x0
109b82: 6a 00 push $0x0
109b84: 53 push %ebx
109b85: 56 push %esi
109b86: 6a 01 push $0x1
109b88: b8 ff 00 00 00 mov $0xff,%eax
109b8d: 29 f8 sub %edi,%eax
109b8f: 50 push %eax
109b90: 6a 01 push $0x1
109b92: a1 00 cd 11 00 mov 0x11cd00,%eax
109b97: d1 e0 shl %eax
109b99: 39 d0 cmp %edx,%eax
109b9b: 73 02 jae 109b9f <pthread_create+0x17b>
109b9d: 89 d0 mov %edx,%eax
109b9f: 50 push %eax
109ba0: 8b 55 c8 mov -0x38(%ebp),%edx
109ba3: ff 72 04 pushl 0x4(%edx)
109ba6: ff 75 cc pushl -0x34(%ebp)
109ba9: 68 60 13 12 00 push $0x121360
109bae: e8 91 2d 00 00 call 10c944 <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
109bb3: 83 c4 30 add $0x30,%esp
109bb6: 84 c0 test %al,%al
109bb8: 75 25 jne 109bdf <pthread_create+0x1bb>
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory for
109bba: 50 push %eax
109bbb: 50 push %eax
109bbc: ff 75 cc pushl -0x34(%ebp)
109bbf: 68 60 13 12 00 push $0x121360
109bc4: e8 c3 23 00 00 call 10bf8c <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
109bc9: 58 pop %eax
109bca: ff 35 a8 11 12 00 pushl 0x1211a8
109bd0: e8 2f 18 00 00 call 10b404 <_API_Mutex_Unlock>
109bd5: b8 0b 00 00 00 mov $0xb,%eax
109bda: e9 c4 00 00 00 jmp 109ca3 <pthread_create+0x27f>
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
109bdf: 8b 45 cc mov -0x34(%ebp),%eax
109be2: 8b 98 f8 00 00 00 mov 0xf8(%eax),%ebx
api->Attributes = *the_attr;
109be8: b9 0e 00 00 00 mov $0xe,%ecx
109bed: 89 df mov %ebx,%edi
109bef: 8b 75 c8 mov -0x38(%ebp),%esi
109bf2: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
api->detachstate = the_attr->detachstate;
109bf4: 8b 55 c8 mov -0x38(%ebp),%edx
109bf7: 8b 42 34 mov 0x34(%edx),%eax
109bfa: 89 43 38 mov %eax,0x38(%ebx)
api->schedpolicy = schedpolicy;
109bfd: 8b 45 d0 mov -0x30(%ebp),%eax
109c00: 89 43 7c mov %eax,0x7c(%ebx)
api->schedparam = schedparam;
109c03: 8d bb 80 00 00 00 lea 0x80(%ebx),%edi
109c09: 8d 75 dc lea -0x24(%ebp),%esi
109c0c: b1 06 mov $0x6,%cl
109c0e: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
* first run.
*
* NOTE: Since the thread starts with all unblocked, this is necessary.
*/
the_thread->do_post_task_switch_extension = true;
109c10: 8b 55 cc mov -0x34(%ebp),%edx
109c13: c6 42 75 01 movb $0x1,0x75(%edx)
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
109c17: 83 ec 0c sub $0xc,%esp
109c1a: 6a 00 push $0x0
109c1c: ff 75 14 pushl 0x14(%ebp)
109c1f: ff 75 10 pushl 0x10(%ebp)
109c22: 6a 01 push $0x1
109c24: 52 push %edx
109c25: e8 8a 36 00 00 call 10d2b4 <_Thread_Start>
109c2a: 89 c6 mov %eax,%esi
start_routine,
arg,
0 /* unused */
);
if ( schedpolicy == SCHED_SPORADIC ) {
109c2c: 83 c4 20 add $0x20,%esp
109c2f: 83 7d d0 03 cmpl $0x3,-0x30(%ebp)
109c33: 75 2b jne 109c60 <pthread_create+0x23c>
_Watchdog_Insert_ticks(
109c35: 83 ec 0c sub $0xc,%esp
109c38: 8d 83 88 00 00 00 lea 0x88(%ebx),%eax
109c3e: 50 push %eax
109c3f: e8 48 38 00 00 call 10d48c <_Timespec_To_ticks>
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
Heap_Control *the_heap,
109c44: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx)
void *starting_address,
size_t *size
109c4a: 59 pop %ecx
109c4b: 5f pop %edi
109c4c: 8d 83 9c 00 00 00 lea 0x9c(%ebx),%eax
109c52: 50 push %eax
109c53: 68 d0 11 12 00 push $0x1211d0
109c58: e8 37 3b 00 00 call 10d794 <_Watchdog_Insert>
109c5d: 83 c4 10 add $0x10,%esp
*
* NOTE: This can only happen if someone slips in and touches the
* thread while we are creating it.
*/
if ( !status ) {
109c60: 89 f0 mov %esi,%eax
109c62: 84 c0 test %al,%al
109c64: 75 22 jne 109c88 <pthread_create+0x264> <== ALWAYS TAKEN
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory for
109c66: 52 push %edx <== NOT EXECUTED
109c67: 52 push %edx <== NOT EXECUTED
109c68: ff 75 cc pushl -0x34(%ebp) <== NOT EXECUTED
109c6b: 68 60 13 12 00 push $0x121360 <== NOT EXECUTED
109c70: e8 17 23 00 00 call 10bf8c <_Objects_Free> <== NOT EXECUTED
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
109c75: 58 pop %eax <== NOT EXECUTED
109c76: ff 35 a8 11 12 00 pushl 0x1211a8 <== NOT EXECUTED
109c7c: e8 83 17 00 00 call 10b404 <_API_Mutex_Unlock> <== NOT EXECUTED
109c81: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED
109c86: eb 1b jmp 109ca3 <pthread_create+0x27f> <== NOT EXECUTED
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
109c88: 8b 45 cc mov -0x34(%ebp),%eax
109c8b: 8b 50 08 mov 0x8(%eax),%edx
109c8e: 8b 45 08 mov 0x8(%ebp),%eax
109c91: 89 10 mov %edx,(%eax)
_RTEMS_Unlock_allocator();
109c93: 83 ec 0c sub $0xc,%esp
109c96: ff 35 a8 11 12 00 pushl 0x1211a8
109c9c: e8 63 17 00 00 call 10b404 <_API_Mutex_Unlock>
109ca1: 31 c0 xor %eax,%eax
109ca3: 83 c4 10 add $0x10,%esp
109ca6: eb 05 jmp 109cad <pthread_create+0x289>
return 0;
109ca8: b8 16 00 00 00 mov $0x16,%eax
}
109cad: 8d 65 f4 lea -0xc(%ebp),%esp
109cb0: 5b pop %ebx
109cb1: 5e pop %esi
109cb2: 5f pop %edi
109cb3: c9 leave
109cb4: c3 ret
0010ecb8 <pthread_exit>:
}
void pthread_exit(
void *value_ptr
)
{
10ecb8: 55 push %ebp
10ecb9: 89 e5 mov %esp,%ebp
10ecbb: 83 ec 10 sub $0x10,%esp
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
10ecbe: ff 75 08 pushl 0x8(%ebp)
10ecc1: ff 35 58 d8 11 00 pushl 0x11d858
10ecc7: e8 88 ff ff ff call 10ec54 <_POSIX_Thread_Exit>
10eccc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
10eccf: c9 leave <== NOT EXECUTED
10ecd0: c3 ret <== NOT EXECUTED
0010aecc <pthread_getschedparam>:
int pthread_getschedparam(
pthread_t thread,
int *policy,
struct sched_param *param
)
{
10aecc: 55 push %ebp
10aecd: 89 e5 mov %esp,%ebp
10aecf: 57 push %edi
10aed0: 56 push %esi
10aed1: 53 push %ebx
10aed2: 83 ec 1c sub $0x1c,%esp
10aed5: 8b 75 0c mov 0xc(%ebp),%esi
Objects_Locations location;
POSIX_API_Control *api;
register Thread_Control *the_thread;
if ( !policy || !param )
10aed8: 85 f6 test %esi,%esi
10aeda: 74 06 je 10aee2 <pthread_getschedparam+0x16>
10aedc: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10aee0: 75 07 jne 10aee9 <pthread_getschedparam+0x1d>
10aee2: b8 16 00 00 00 mov $0x16,%eax
10aee7: eb 4d jmp 10af36 <pthread_getschedparam+0x6a>
return EINVAL;
the_thread = _Thread_Get( thread, &location );
10aee9: 50 push %eax
10aeea: 50 push %eax
10aeeb: 8d 45 f0 lea -0x10(%ebp),%eax
10aeee: 50 push %eax
10aeef: ff 75 08 pushl 0x8(%ebp)
10aef2: e8 4d 2a 00 00 call 10d944 <_Thread_Get>
10aef7: 89 c3 mov %eax,%ebx
switch ( location ) {
10aef9: 83 c4 10 add $0x10,%esp
10aefc: b8 03 00 00 00 mov $0x3,%eax
10af01: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
10af05: 75 2f jne 10af36 <pthread_getschedparam+0x6a><== NEVER TAKEN
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10af07: 8b 93 f8 00 00 00 mov 0xf8(%ebx),%edx
if ( policy )
*policy = api->schedpolicy;
10af0d: 8b 42 7c mov 0x7c(%edx),%eax
10af10: 89 06 mov %eax,(%esi)
if ( param ) {
*param = api->schedparam;
10af12: 8d b2 80 00 00 00 lea 0x80(%edx),%esi
10af18: b9 06 00 00 00 mov $0x6,%ecx
10af1d: 8b 7d 10 mov 0x10(%ebp),%edi
10af20: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
param->sched_priority =
10af22: b8 ff 00 00 00 mov $0xff,%eax
10af27: 2b 43 14 sub 0x14(%ebx),%eax
10af2a: 8b 55 10 mov 0x10(%ebp),%edx
10af2d: 89 02 mov %eax,(%edx)
_POSIX_Priority_From_core( the_thread->current_priority );
}
_Thread_Enable_dispatch();
10af2f: e8 f0 29 00 00 call 10d924 <_Thread_Enable_dispatch>
10af34: 31 c0 xor %eax,%eax
break;
}
return ESRCH;
}
10af36: 8d 65 f4 lea -0xc(%ebp),%esp
10af39: 5b pop %ebx
10af3a: 5e pop %esi
10af3b: 5f pop %edi
10af3c: c9 leave
10af3d: c3 ret
00108ec8 <pthread_key_create>:
int pthread_key_create(
pthread_key_t *key,
void (*destructor)( void * )
)
{
108ec8: 55 push %ebp
108ec9: 89 e5 mov %esp,%ebp
108ecb: 57 push %edi
108ecc: 56 push %esi
108ecd: 53 push %ebx
108ece: 83 ec 18 sub $0x18,%esp
108ed1: a1 a8 00 12 00 mov 0x1200a8,%eax
108ed6: 40 inc %eax
108ed7: a3 a8 00 12 00 mov %eax,0x1200a8
* It is a simple wrapper for the help with the addition of the
* allocation mutex being used for protection.
*/
/**@{*/
#ifdef __cplusplus
108edc: 68 dc 04 12 00 push $0x1204dc
108ee1: e8 7e 21 00 00 call 10b064 <_Objects_Allocate>
108ee6: 89 45 f0 mov %eax,-0x10(%ebp)
_Thread_Disable_dispatch();
the_key = _POSIX_Keys_Allocate();
if ( !the_key ) {
108ee9: 83 c4 10 add $0x10,%esp
108eec: 85 c0 test %eax,%eax
108eee: 75 0f jne 108eff <pthread_key_create+0x37>
_Thread_Enable_dispatch();
108ef0: e8 73 2d 00 00 call 10bc68 <_Thread_Enable_dispatch>
108ef5: b8 0b 00 00 00 mov $0xb,%eax
108efa: e9 c4 00 00 00 jmp 108fc3 <pthread_key_create+0xfb>
return EAGAIN;
}
the_key->destructor = destructor;
108eff: 8b 45 0c mov 0xc(%ebp),%eax
108f02: 8b 55 f0 mov -0x10(%ebp),%edx
108f05: 89 42 14 mov %eax,0x14(%edx)
108f08: bb 01 00 00 00 mov $0x1,%ebx
for ( the_api = 1;
the_api <= OBJECTS_APIS_LAST;
the_api++ ) {
if ( _Objects_Information_table[ the_api ] ) {
108f0d: 8b 04 9d 7c 00 12 00 mov 0x12007c(,%ebx,4),%eax
108f14: 85 c0 test %eax,%eax
108f16: 74 6e je 108f86 <pthread_key_create+0xbe>
INTERNAL_ERROR_CORE,
TRUE,
INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY
);
#endif
bytes_to_allocate = sizeof( void * ) *
108f18: 8b 40 04 mov 0x4(%eax),%eax
108f1b: 0f b7 40 10 movzwl 0x10(%eax),%eax
108f1f: 8d 34 85 04 00 00 00 lea 0x4(,%eax,4),%esi
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
table = _Workspace_Allocate( bytes_to_allocate );
108f26: 83 ec 0c sub $0xc,%esp
108f29: 56 push %esi
108f2a: e8 d2 3d 00 00 call 10cd01 <_Workspace_Allocate>
108f2f: 89 c7 mov %eax,%edi
if ( !table ) {
108f31: 83 c4 10 add $0x10,%esp
108f34: 85 c0 test %eax,%eax
108f36: 75 3f jne 108f77 <pthread_key_create+0xaf>
for ( --the_api;
108f38: 8d 73 ff lea -0x1(%ebx),%esi
108f3b: 8b 45 f0 mov -0x10(%ebp),%eax
108f3e: 8d 5c 98 14 lea 0x14(%eax,%ebx,4),%ebx
108f42: eb 11 jmp 108f55 <pthread_key_create+0x8d>
the_api >= 1;
the_api-- )
_Workspace_Free( the_key->Values[ the_api ] );
108f44: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108f47: ff 33 pushl (%ebx) <== NOT EXECUTED
108f49: e8 9e 3d 00 00 call 10ccec <_Workspace_Free> <== NOT EXECUTED
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
table = _Workspace_Allocate( bytes_to_allocate );
if ( !table ) {
for ( --the_api;
the_api >= 1;
the_api-- )
108f4e: 4e dec %esi <== NOT EXECUTED
108f4f: 83 eb 04 sub $0x4,%ebx <== NOT EXECUTED
108f52: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
bytes_to_allocate = sizeof( void * ) *
(_Objects_Information_table[ the_api ][ 1 ]->maximum + 1);
table = _Workspace_Allocate( bytes_to_allocate );
if ( !table ) {
for ( --the_api;
the_api >= 1;
108f55: 85 f6 test %esi,%esi
108f57: 75 eb jne 108f44 <pthread_key_create+0x7c><== NEVER TAKEN
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory for
108f59: 50 push %eax
108f5a: 50 push %eax
108f5b: ff 75 f0 pushl -0x10(%ebp)
108f5e: 68 dc 04 12 00 push $0x1204dc
108f63: e8 0c 24 00 00 call 10b374 <_Objects_Free>
the_api-- )
_Workspace_Free( the_key->Values[ the_api ] );
_POSIX_Keys_Free( the_key );
_Thread_Enable_dispatch();
108f68: e8 fb 2c 00 00 call 10bc68 <_Thread_Enable_dispatch>
108f6d: b8 0c 00 00 00 mov $0xc,%eax
108f72: 83 c4 10 add $0x10,%esp
108f75: eb 4c jmp 108fc3 <pthread_key_create+0xfb>
return ENOMEM;
}
the_key->Values[ the_api ] = table;
108f77: 8b 55 f0 mov -0x10(%ebp),%edx
108f7a: 89 44 9a 18 mov %eax,0x18(%edx,%ebx,4)
memset( table, '\0', bytes_to_allocate );
108f7e: 89 f1 mov %esi,%ecx
108f80: 31 c0 xor %eax,%eax
108f82: f3 aa rep stos %al,%es:(%edi)
108f84: eb 0b jmp 108f91 <pthread_key_create+0xc9>
} else {
the_key->Values[ the_api ] = NULL;
108f86: 8b 55 f0 mov -0x10(%ebp),%edx
108f89: c7 44 9a 18 00 00 00 movl $0x0,0x18(%edx,%ebx,4)
108f90: 00
* for. [NOTE: Currently RTEMS Classic API tasks are always enabled.]
*/
for ( the_api = 1;
the_api <= OBJECTS_APIS_LAST;
the_api++ ) {
108f91: 43 inc %ebx
* APIs are optional. Thus there may be no ITRON tasks to have keys
* for. [NOTE: Currently RTEMS Classic API tasks are always enabled.]
*/
for ( the_api = 1;
the_api <= OBJECTS_APIS_LAST;
108f92: 83 fb 05 cmp $0x5,%ebx
108f95: 0f 85 72 ff ff ff jne 108f0d <pthread_key_create+0x45>
}
}
the_key->is_active = TRUE;
108f9b: 8b 5d f0 mov -0x10(%ebp),%ebx
108f9e: c6 43 10 01 movb $0x1,0x10(%ebx)
108fa2: 8b 4b 08 mov 0x8(%ebx),%ecx
108fa5: 0f b7 d1 movzwl %cx,%edx
108fa8: a1 f8 04 12 00 mov 0x1204f8,%eax
108fad: 89 1c 90 mov %ebx,(%eax,%edx,4)
108fb0: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
_Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 );
*key = the_key->Object.id;
108fb7: 8b 45 08 mov 0x8(%ebp),%eax
108fba: 89 08 mov %ecx,(%eax)
_Thread_Enable_dispatch();
108fbc: e8 a7 2c 00 00 call 10bc68 <_Thread_Enable_dispatch>
108fc1: 31 c0 xor %eax,%eax
return 0;
}
108fc3: 8d 65 f4 lea -0xc(%ebp),%esp
108fc6: 5b pop %ebx
108fc7: 5e pop %esi
108fc8: 5f pop %edi
108fc9: c9 leave
108fca: c3 ret
00108fcc <pthread_key_delete>:
*/
int pthread_key_delete(
pthread_key_t key
)
{
108fcc: 55 push %ebp
108fcd: 89 e5 mov %esp,%ebp
108fcf: 53 push %ebx
108fd0: 83 ec 18 sub $0x18,%esp
static inline uint32_t _Protected_heap_Initialize(
Heap_Control *the_heap,
void *starting_address,
size_t size,
uint32_t page_size
)
108fd3: 8d 45 f8 lea -0x8(%ebp),%eax
108fd6: 50 push %eax
108fd7: ff 75 08 pushl 0x8(%ebp)
108fda: 68 dc 04 12 00 push $0x1204dc
108fdf: e8 c4 24 00 00 call 10b4a8 <_Objects_Get>
108fe4: 89 c3 mov %eax,%ebx
register POSIX_Keys_Control *the_key;
Objects_Locations location;
uint32_t the_api;
the_key = _POSIX_Keys_Get( key, &location );
switch ( location ) {
108fe6: 83 c4 10 add $0x10,%esp
108fe9: b8 16 00 00 00 mov $0x16,%eax
108fee: 83 7d f8 00 cmpl $0x0,-0x8(%ebp)
108ff2: 75 77 jne 10906b <pthread_key_delete+0x9f><== NEVER TAKEN
case OBJECTS_LOCAL:
_Objects_Close( &_POSIX_Keys_Information, &the_key->Object );
108ff4: 52 push %edx
108ff5: 52 push %edx
108ff6: 53 push %ebx
108ff7: 68 dc 04 12 00 push $0x1204dc
108ffc: e8 d7 20 00 00 call 10b0d8 <_Objects_Close>
the_key->is_active = FALSE;
109001: c6 43 10 00 movb $0x0,0x10(%ebx)
for ( the_api = 1;
the_api <= OBJECTS_APIS_LAST;
the_api++ )
if ( the_key->Values[ the_api ] )
109005: 8b 43 1c mov 0x1c(%ebx),%eax
109008: 83 c4 10 add $0x10,%esp
10900b: 85 c0 test %eax,%eax
10900d: 74 0c je 10901b <pthread_key_delete+0x4f><== NEVER TAKEN
_Workspace_Free( the_key->Values[ the_api ] );
10900f: 83 ec 0c sub $0xc,%esp
109012: 50 push %eax
109013: e8 d4 3c 00 00 call 10ccec <_Workspace_Free>
109018: 83 c4 10 add $0x10,%esp
the_key->is_active = FALSE;
for ( the_api = 1;
the_api <= OBJECTS_APIS_LAST;
the_api++ )
if ( the_key->Values[ the_api ] )
10901b: 8b 43 20 mov 0x20(%ebx),%eax
10901e: 85 c0 test %eax,%eax
109020: 74 0c je 10902e <pthread_key_delete+0x62><== NEVER TAKEN
_Workspace_Free( the_key->Values[ the_api ] );
109022: 83 ec 0c sub $0xc,%esp
109025: 50 push %eax
109026: e8 c1 3c 00 00 call 10ccec <_Workspace_Free>
10902b: 83 c4 10 add $0x10,%esp
the_key->is_active = FALSE;
for ( the_api = 1;
the_api <= OBJECTS_APIS_LAST;
the_api++ )
if ( the_key->Values[ the_api ] )
10902e: 8b 43 24 mov 0x24(%ebx),%eax
109031: 85 c0 test %eax,%eax
109033: 74 0c je 109041 <pthread_key_delete+0x75><== NEVER TAKEN
_Workspace_Free( the_key->Values[ the_api ] );
109035: 83 ec 0c sub $0xc,%esp
109038: 50 push %eax
109039: e8 ae 3c 00 00 call 10ccec <_Workspace_Free>
10903e: 83 c4 10 add $0x10,%esp
the_key->is_active = FALSE;
for ( the_api = 1;
the_api <= OBJECTS_APIS_LAST;
the_api++ )
if ( the_key->Values[ the_api ] )
109041: 8b 43 28 mov 0x28(%ebx),%eax
109044: 85 c0 test %eax,%eax
109046: 74 0c je 109054 <pthread_key_delete+0x88><== ALWAYS TAKEN
_Workspace_Free( the_key->Values[ the_api ] );
109048: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10904b: 50 push %eax <== NOT EXECUTED
10904c: e8 9b 3c 00 00 call 10ccec <_Workspace_Free> <== NOT EXECUTED
109051: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory for
109054: 50 push %eax
109055: 50 push %eax
109056: 53 push %ebx
109057: 68 dc 04 12 00 push $0x1204dc
10905c: e8 13 23 00 00 call 10b374 <_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();
109061: e8 02 2c 00 00 call 10bc68 <_Thread_Enable_dispatch>
109066: 31 c0 xor %eax,%eax
109068: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10906b: 8b 5d fc mov -0x4(%ebp),%ebx
10906e: c9 leave
10906f: c3 ret
0011877c <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
11877c: 55 push %ebp
11877d: 89 e5 mov %esp,%ebp
11877f: 57 push %edi
118780: 56 push %esi
118781: 53 push %ebx
118782: 83 ec 1c sub $0x1c,%esp
118785: 8b 75 0c mov 0xc(%ebp),%esi
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
118788: 85 f6 test %esi,%esi
11878a: 74 08 je 118794 <pthread_kill+0x18> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
11878c: 8d 7e ff lea -0x1(%esi),%edi
11878f: 83 ff 1f cmp $0x1f,%edi
118792: 76 0d jbe 1187a1 <pthread_kill+0x25>
rtems_set_errno_and_return_minus_one( EINVAL );
118794: e8 83 7e ff ff call 11061c <__errno>
118799: c7 00 16 00 00 00 movl $0x16,(%eax)
11879f: eb 77 jmp 118818 <pthread_kill+0x9c>
the_thread = _Thread_Get( thread, &location );
1187a1: 52 push %edx
1187a2: 52 push %edx
1187a3: 8d 45 f0 lea -0x10(%ebp),%eax
1187a6: 50 push %eax
1187a7: ff 75 08 pushl 0x8(%ebp)
1187aa: e8 a9 3a ff ff call 10c258 <_Thread_Get>
1187af: 89 c3 mov %eax,%ebx
switch ( location ) {
1187b1: 83 c4 10 add $0x10,%esp
1187b4: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
1187b8: 75 53 jne 11880d <pthread_kill+0x91> <== NEVER TAKEN
case OBJECTS_LOCAL:
/*
* If sig == 0 then just validate arguments
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
1187ba: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
1187c0: 6b c6 0c imul $0xc,%esi,%eax
1187c3: 83 b8 88 98 12 00 01 cmpl $0x1,0x129888(%eax)
1187ca: 74 38 je 118804 <pthread_kill+0x88> <== NEVER TAKEN
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
1187cc: b8 01 00 00 00 mov $0x1,%eax
1187d1: 89 f9 mov %edi,%ecx
1187d3: d3 e0 shl %cl,%eax
1187d5: 09 82 c8 00 00 00 or %eax,0xc8(%edx)
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
1187db: 50 push %eax
1187dc: 6a 00 push $0x0
1187de: 56 push %esi
1187df: 53 push %ebx
1187e0: e8 a7 fe ff ff call 11868c <_POSIX_signals_Unblock_thread>
the_thread->do_post_task_switch_extension = true;
1187e5: c6 43 75 01 movb $0x1,0x75(%ebx)
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
1187e9: a1 30 93 12 00 mov 0x129330,%eax
1187ee: 83 c4 10 add $0x10,%esp
1187f1: 85 c0 test %eax,%eax
1187f3: 74 0f je 118804 <pthread_kill+0x88>
1187f5: 3b 1d 54 93 12 00 cmp 0x129354,%ebx
1187fb: 75 07 jne 118804 <pthread_kill+0x88> <== ALWAYS TAKEN
_ISR_Signals_to_thread_executing = TRUE;
1187fd: c6 05 e8 93 12 00 01 movb $0x1,0x1293e8 <== NOT EXECUTED
}
_Thread_Enable_dispatch();
118804: e8 03 3a ff ff call 10c20c <_Thread_Enable_dispatch>
118809: 31 c0 xor %eax,%eax
11880b: eb 0e jmp 11881b <pthread_kill+0x9f>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
11880d: e8 0a 7e ff ff call 11061c <__errno> <== NOT EXECUTED
118812: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED
118818: 83 c8 ff or $0xffffffff,%eax
}
11881b: 8d 65 f4 lea -0xc(%ebp),%esp
11881e: 5b pop %ebx
11881f: 5e pop %esi
118820: 5f pop %edi
118821: c9 leave
118822: c3 ret
0010a898 <pthread_mutex_init>:
int pthread_mutex_init(
pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr
)
{
10a898: 55 push %ebp
10a899: 89 e5 mov %esp,%ebp
10a89b: 57 push %edi
10a89c: 56 push %esi
10a89d: 53 push %ebx
10a89e: 83 ec 0c sub $0xc,%esp
10a8a1: 8b 45 0c mov 0xc(%ebp),%eax
#if 0
register POSIX_Mutex_Control *mutex_in_use;
Objects_Locations location;
#endif
if ( attr ) the_attr = attr;
10a8a4: be 60 c3 11 00 mov $0x11c360,%esi
10a8a9: 85 c0 test %eax,%eax
10a8ab: 74 02 je 10a8af <pthread_mutex_init+0x17>
10a8ad: 89 c6 mov %eax,%esi
else the_attr = &_POSIX_Mutex_Default_attributes;
/* Check for NULL mutex */
if ( !mutex )
10a8af: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
10a8b3: 0f 84 df 00 00 00 je 10a998 <pthread_mutex_init+0x100>
break;
}
}
#endif
if ( !the_attr->is_initialized )
10a8b9: 83 3e 00 cmpl $0x0,(%esi)
10a8bc: 0f 84 d6 00 00 00 je 10a998 <pthread_mutex_init+0x100>
/*
* XXX: Be careful about attributes when global!!!
*/
assert( the_attr->process_shared == PTHREAD_PROCESS_PRIVATE );
10a8c2: 83 7e 04 00 cmpl $0x0,0x4(%esi)
10a8c6: 74 16 je 10a8de <pthread_mutex_init+0x46><== ALWAYS TAKEN
10a8c8: 68 74 c3 11 00 push $0x11c374 <== NOT EXECUTED
10a8cd: 68 f4 c3 11 00 push $0x11c3f4 <== NOT EXECUTED
10a8d2: 6a 68 push $0x68 <== NOT EXECUTED
10a8d4: 68 a8 c3 11 00 push $0x11c3a8 <== NOT EXECUTED
10a8d9: e8 6a d5 ff ff call 107e48 <__assert_func> <== NOT EXECUTED
/*
* Determine the discipline of the mutex
*/
switch ( the_attr->protocol ) {
10a8de: 8b 46 0c mov 0xc(%esi),%eax
10a8e1: 83 f8 01 cmp $0x1,%eax
10a8e4: 74 10 je 10a8f6 <pthread_mutex_init+0x5e>
10a8e6: 83 f8 02 cmp $0x2,%eax
10a8e9: 74 12 je 10a8fd <pthread_mutex_init+0x65>
10a8eb: 31 ff xor %edi,%edi
10a8ed: 85 c0 test %eax,%eax
10a8ef: 74 11 je 10a902 <pthread_mutex_init+0x6a>
10a8f1: e9 a2 00 00 00 jmp 10a998 <pthread_mutex_init+0x100>
10a8f6: bf 02 00 00 00 mov $0x2,%edi
10a8fb: eb 05 jmp 10a902 <pthread_mutex_init+0x6a>
10a8fd: bf 03 00 00 00 mov $0x3,%edi
break;
default:
return EINVAL;
}
if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) )
10a902: 8b 46 08 mov 0x8(%esi),%eax
10a905: 48 dec %eax
10a906: 3d fd 00 00 00 cmp $0xfd,%eax
10a90b: 0f 87 87 00 00 00 ja 10a998 <pthread_mutex_init+0x100>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10a911: a1 68 2b 12 00 mov 0x122b68,%eax
10a916: 40 inc %eax
10a917: a3 68 2b 12 00 mov %eax,0x122b68
* It is a simple wrapper for the help with the addition of the
* allocation mutex being used for protection.
*/
/**@{*/
#ifdef __cplusplus
10a91c: 83 ec 0c sub $0xc,%esp
10a91f: 68 18 2f 12 00 push $0x122f18
10a924: e8 f7 23 00 00 call 10cd20 <_Objects_Allocate>
10a929: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch();
the_mutex = _POSIX_Mutex_Allocate();
if ( !the_mutex ) {
10a92b: 83 c4 10 add $0x10,%esp
10a92e: 85 c0 test %eax,%eax
10a930: 75 0c jne 10a93e <pthread_mutex_init+0xa6>
_Thread_Enable_dispatch();
10a932: e8 ed 2f 00 00 call 10d924 <_Thread_Enable_dispatch>
10a937: b8 0b 00 00 00 mov $0xb,%eax
10a93c: eb 5f jmp 10a99d <pthread_mutex_init+0x105>
return EAGAIN;
}
the_mutex->process_shared = the_attr->process_shared;
10a93e: 8b 46 04 mov 0x4(%esi),%eax
10a941: 89 43 10 mov %eax,0x10(%ebx)
the_mutex_attr = &the_mutex->Mutex.Attributes;
if ( the_attr->recursive )
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
10a944: 31 c0 xor %eax,%eax
10a946: 83 7e 10 00 cmpl $0x0,0x10(%esi)
10a94a: 0f 94 c0 sete %al
10a94d: 89 43 54 mov %eax,0x54(%ebx)
else
the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR;
the_mutex_attr->only_owner_release = TRUE;
10a950: c6 43 58 01 movb $0x1,0x58(%ebx)
the_mutex_attr->priority_ceiling =
10a954: b8 ff 00 00 00 mov $0xff,%eax
10a959: 2b 46 08 sub 0x8(%esi),%eax
10a95c: 89 43 60 mov %eax,0x60(%ebx)
_POSIX_Priority_To_core( the_attr->prio_ceiling );
the_mutex_attr->discipline = the_discipline;
10a95f: 89 7b 5c mov %edi,0x5c(%ebx)
/*
* Must be initialized to unlocked.
*/
_CORE_mutex_Initialize(
10a962: 50 push %eax
10a963: 6a 01 push $0x1
10a965: 8d 43 54 lea 0x54(%ebx),%eax
10a968: 50 push %eax
10a969: 8d 43 14 lea 0x14(%ebx),%eax
10a96c: 50 push %eax
10a96d: e8 12 1d 00 00 call 10c684 <_CORE_mutex_Initialize>
10a972: 8b 4b 08 mov 0x8(%ebx),%ecx
10a975: 0f b7 d1 movzwl %cx,%edx
10a978: a1 34 2f 12 00 mov 0x122f34,%eax
10a97d: 89 1c 90 mov %ebx,(%eax,%edx,4)
10a980: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
CORE_MUTEX_UNLOCKED
);
_Objects_Open_u32( &_POSIX_Mutex_Information, &the_mutex->Object, 0 );
*mutex = the_mutex->Object.id;
10a987: 8b 45 08 mov 0x8(%ebp),%eax
10a98a: 89 08 mov %ecx,(%eax)
_Thread_Enable_dispatch();
10a98c: e8 93 2f 00 00 call 10d924 <_Thread_Enable_dispatch>
10a991: 31 c0 xor %eax,%eax
10a993: 83 c4 10 add $0x10,%esp
10a996: eb 05 jmp 10a99d <pthread_mutex_init+0x105>
return 0;
10a998: b8 16 00 00 00 mov $0x16,%eax
}
10a99d: 8d 65 f4 lea -0xc(%ebp),%esp
10a9a0: 5b pop %ebx
10a9a1: 5e pop %esi
10a9a2: 5f pop %edi
10a9a3: c9 leave
10a9a4: c3 ret
0010aa18 <pthread_mutex_setprioceiling>:
int pthread_mutex_setprioceiling(
pthread_mutex_t *mutex,
int prioceiling,
int *old_ceiling
)
{
10aa18: 55 push %ebp
10aa19: 89 e5 mov %esp,%ebp
10aa1b: 57 push %edi
10aa1c: 56 push %esi
10aa1d: 53 push %ebx
10aa1e: 83 ec 1c sub $0x1c,%esp
10aa21: 8b 75 08 mov 0x8(%ebp),%esi
10aa24: 8b 7d 10 mov 0x10(%ebp),%edi
register POSIX_Mutex_Control *the_mutex;
Objects_Locations location;
Priority_Control the_priority;
int status;
if ( !old_ceiling )
10aa27: 85 ff test %edi,%edi
10aa29: 74 5f je 10aa8a <pthread_mutex_setprioceiling+0x72>
return EINVAL;
if ( !_POSIX_Priority_Is_valid( prioceiling ) )
10aa2b: 8b 45 0c mov 0xc(%ebp),%eax
10aa2e: 48 dec %eax
10aa2f: 3d fd 00 00 00 cmp $0xfd,%eax
10aa34: 77 54 ja 10aa8a <pthread_mutex_setprioceiling+0x72>
/*
* Must acquire the mutex before we can change it's ceiling
*/
status = pthread_mutex_lock( mutex );
10aa36: 83 ec 0c sub $0xc,%esp
10aa39: 56 push %esi
10aa3a: e8 69 ff ff ff call 10a9a8 <pthread_mutex_lock>
10aa3f: 89 c3 mov %eax,%ebx
if ( status )
10aa41: 83 c4 10 add $0x10,%esp
10aa44: 85 c0 test %eax,%eax
10aa46: 75 47 jne 10aa8f <pthread_mutex_setprioceiling+0x77>
return status;
the_mutex = _POSIX_Mutex_Get( mutex, &location );
10aa48: 52 push %edx
10aa49: 52 push %edx
10aa4a: 8d 45 f0 lea -0x10(%ebp),%eax
10aa4d: 50 push %eax
10aa4e: 56 push %esi
10aa4f: e8 b9 fd ff ff call 10a80d <_POSIX_Mutex_Get>
10aa54: 89 c1 mov %eax,%ecx
switch ( location ) {
10aa56: 83 c4 10 add $0x10,%esp
10aa59: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
10aa5d: 75 2b jne 10aa8a <pthread_mutex_setprioceiling+0x72><== NEVER TAKEN
case OBJECTS_LOCAL:
*old_ceiling = _POSIX_Priority_From_core(
10aa5f: b8 ff 00 00 00 mov $0xff,%eax
10aa64: 89 c2 mov %eax,%edx
10aa66: 2b 51 60 sub 0x60(%ecx),%edx
10aa69: 89 17 mov %edx,(%edi)
the_mutex->Mutex.Attributes.priority_ceiling
);
the_mutex->Mutex.Attributes.priority_ceiling = the_priority;
10aa6b: 2b 45 0c sub 0xc(%ebp),%eax
10aa6e: 89 41 60 mov %eax,0x60(%ecx)
_CORE_mutex_Surrender(
10aa71: 50 push %eax
10aa72: 6a 00 push $0x0
10aa74: ff 71 08 pushl 0x8(%ecx)
10aa77: 8d 41 14 lea 0x14(%ecx),%eax
10aa7a: 50 push %eax
10aa7b: e8 80 1d 00 00 call 10c800 <_CORE_mutex_Surrender>
&the_mutex->Mutex,
the_mutex->Object.id,
NULL
);
_Thread_Enable_dispatch();
10aa80: e8 9f 2e 00 00 call 10d924 <_Thread_Enable_dispatch>
10aa85: 83 c4 10 add $0x10,%esp
10aa88: eb 05 jmp 10aa8f <pthread_mutex_setprioceiling+0x77>
return 0;
10aa8a: bb 16 00 00 00 mov $0x16,%ebx
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10aa8f: 89 d8 mov %ebx,%eax
10aa91: 8d 65 f4 lea -0xc(%ebp),%esp
10aa94: 5b pop %ebx
10aa95: 5e pop %esi
10aa96: 5f pop %edi
10aa97: c9 leave
10aa98: c3 ret
0010aa9c <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
10aa9c: 55 push %ebp
10aa9d: 89 e5 mov %esp,%ebp
10aa9f: 83 ec 20 sub $0x20,%esp
* So we check the abstime provided, and hold on to whether it
* is valid or not. If it isn't correct and in the future,
* then we do a polling operation and convert the UNSATISFIED
* status into the appropriate error.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
10aaa2: 8d 45 fc lea -0x4(%ebp),%eax
10aaa5: 50 push %eax
10aaa6: ff 75 0c pushl 0xc(%ebp)
10aaa9: e8 96 00 00 00 call 10ab44 <_POSIX_Absolute_timeout_to_ticks>
switch ( status ) {
10aaae: 83 c4 10 add $0x10,%esp
10aab1: 31 d2 xor %edx,%edx
10aab3: 83 f8 02 cmp $0x2,%eax
10aab6: 76 07 jbe 10aabf <pthread_mutex_timedlock+0x23><== NEVER TAKEN
10aab8: 83 f8 03 cmp $0x3,%eax
10aabb: 75 02 jne 10aabf <pthread_mutex_timedlock+0x23><== NEVER TAKEN
10aabd: b2 01 mov $0x1,%dl
case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE:
do_wait = TRUE;
break;
}
lock_status = _POSIX_Mutex_Lock_support(
10aabf: 50 push %eax
10aac0: ff 75 fc pushl -0x4(%ebp)
10aac3: 0f b6 c2 movzbl %dl,%eax
10aac6: 50 push %eax
10aac7: ff 75 08 pushl 0x8(%ebp)
10aaca: e8 ed fe ff ff call 10a9bc <_POSIX_Mutex_Lock_support>
break;
}
}
return lock_status;
}
10aacf: c9 leave
10aad0: c3 ret
0010a72c <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
10a72c: 55 push %ebp
10a72d: 89 e5 mov %esp,%ebp
10a72f: 8b 45 08 mov 0x8(%ebp),%eax
10a732: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr || !attr->is_initialized )
10a735: 85 c0 test %eax,%eax
10a737: 74 11 je 10a74a <pthread_mutexattr_setpshared+0x1e>
10a739: 83 38 00 cmpl $0x0,(%eax)
10a73c: 74 0c je 10a74a <pthread_mutexattr_setpshared+0x1e>
return EINVAL;
switch ( pshared ) {
10a73e: 83 fa 01 cmp $0x1,%edx
10a741: 77 07 ja 10a74a <pthread_mutexattr_setpshared+0x1e><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10a743: 89 50 04 mov %edx,0x4(%eax)
10a746: 31 c0 xor %eax,%eax
10a748: eb 05 jmp 10a74f <pthread_mutexattr_setpshared+0x23>
return 0;
10a74a: b8 16 00 00 00 mov $0x16,%eax
default:
return EINVAL;
}
}
10a74f: c9 leave
10a750: c3 ret
0010a0b0 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
10a0b0: 55 push %ebp
10a0b1: 89 e5 mov %esp,%ebp
10a0b3: 56 push %esi
10a0b4: 53 push %ebx
10a0b5: 83 ec 10 sub $0x10,%esp
10a0b8: 8b 5d 08 mov 0x8(%ebp),%ebx
10a0bb: 8b 75 0c mov 0xc(%ebp),%esi
if ( !once_control || !init_routine )
10a0be: 85 db test %ebx,%ebx
10a0c0: 74 04 je 10a0c6 <pthread_once+0x16>
10a0c2: 85 f6 test %esi,%esi
10a0c4: 75 07 jne 10a0cd <pthread_once+0x1d>
10a0c6: b8 16 00 00 00 mov $0x16,%eax
10a0cb: eb 4b jmp 10a118 <pthread_once+0x68>
return EINVAL;
if ( !once_control->init_executed ) {
10a0cd: 31 c0 xor %eax,%eax
10a0cf: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a0d3: 75 43 jne 10a118 <pthread_once+0x68>
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
10a0d5: 52 push %edx
10a0d6: 8d 45 f4 lea -0xc(%ebp),%eax
10a0d9: 50 push %eax
10a0da: 68 00 01 00 00 push $0x100
10a0df: 68 00 01 00 00 push $0x100
10a0e4: e8 8f 0c 00 00 call 10ad78 <rtems_task_mode>
if ( !once_control->init_executed ) {
10a0e9: 83 c4 10 add $0x10,%esp
10a0ec: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a0f0: 75 0f jne 10a101 <pthread_once+0x51> <== NEVER TAKEN
once_control->is_initialized = TRUE;
10a0f2: c7 03 01 00 00 00 movl $0x1,(%ebx)
once_control->init_executed = TRUE;
10a0f8: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx)
(*init_routine)();
10a0ff: ff d6 call *%esi
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
10a101: 50 push %eax
10a102: 8d 45 f4 lea -0xc(%ebp),%eax
10a105: 50 push %eax
10a106: 68 00 01 00 00 push $0x100
10a10b: ff 75 f4 pushl -0xc(%ebp)
10a10e: e8 65 0c 00 00 call 10ad78 <rtems_task_mode>
10a113: 31 c0 xor %eax,%eax
10a115: 83 c4 10 add $0x10,%esp
}
return 0;
}
10a118: 8d 65 f8 lea -0x8(%ebp),%esp
10a11b: 5b pop %ebx
10a11c: 5e pop %esi
10a11d: c9 leave
10a11e: c3 ret
001097cc <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
1097cc: 55 push %ebp
1097cd: 89 e5 mov %esp,%ebp
1097cf: 56 push %esi
1097d0: 53 push %ebx
1097d1: 83 ec 10 sub $0x10,%esp
1097d4: 8b 75 08 mov 0x8(%ebp),%esi
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
1097d7: 85 f6 test %esi,%esi
1097d9: 0f 84 82 00 00 00 je 109861 <pthread_rwlock_init+0x95>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
1097df: 8b 45 0c mov 0xc(%ebp),%eax
1097e2: 85 c0 test %eax,%eax
1097e4: 75 11 jne 1097f7 <pthread_rwlock_init+0x2b><== ALWAYS TAKEN
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
1097e6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1097e9: 8d 5d ec lea -0x14(%ebp),%ebx <== NOT EXECUTED
1097ec: 53 push %ebx <== NOT EXECUTED
1097ed: e8 9a 09 00 00 call 10a18c <pthread_rwlockattr_init><== NOT EXECUTED
1097f2: 89 d8 mov %ebx,%eax <== NOT EXECUTED
1097f4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
1097f7: 83 38 00 cmpl $0x0,(%eax)
1097fa: 74 65 je 109861 <pthread_rwlock_init+0x95><== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
1097fc: 83 78 04 00 cmpl $0x0,0x4(%eax)
109800: 75 5f jne 109861 <pthread_rwlock_init+0x95><== NEVER TAKEN
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
109802: a1 d0 fb 11 00 mov 0x11fbd0,%eax
109807: 40 inc %eax
109808: a3 d0 fb 11 00 mov %eax,0x11fbd0
*/
/**@{*/
#ifdef __cplusplus
extern "C" {
#endif
10980d: 83 ec 0c sub $0xc,%esp
109810: 68 00 fe 11 00 push $0x11fe00
109815: e8 2e 25 00 00 call 10bd48 <_Objects_Allocate>
10981a: 89 c3 mov %eax,%ebx
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
10981c: 83 c4 10 add $0x10,%esp
10981f: 85 c0 test %eax,%eax
109821: 75 0c jne 10982f <pthread_rwlock_init+0x63>
_Thread_Enable_dispatch();
109823: e8 24 31 00 00 call 10c94c <_Thread_Enable_dispatch>
109828: b8 0b 00 00 00 mov $0xb,%eax
10982d: eb 37 jmp 109866 <pthread_rwlock_init+0x9a>
return EAGAIN;
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
10982f: 50 push %eax
109830: 50 push %eax
109831: 8d 45 f4 lea -0xc(%ebp),%eax
109834: 50 push %eax
109835: 8d 43 10 lea 0x10(%ebx),%eax
109838: 50 push %eax
109839: e8 ae 1e 00 00 call 10b6ec <_CORE_RWLock_Initialize>
10983e: 8b 4b 08 mov 0x8(%ebx),%ecx
109841: 0f b7 d1 movzwl %cx,%edx
109844: a1 1c fe 11 00 mov 0x11fe1c,%eax
109849: 89 1c 90 mov %ebx,(%eax,%edx,4)
10984c: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
109853: 89 0e mov %ecx,(%esi)
_Thread_Enable_dispatch();
109855: e8 f2 30 00 00 call 10c94c <_Thread_Enable_dispatch>
10985a: 31 c0 xor %eax,%eax
10985c: 83 c4 10 add $0x10,%esp
10985f: eb 05 jmp 109866 <pthread_rwlock_init+0x9a>
return 0;
109861: b8 16 00 00 00 mov $0x16,%eax
}
109866: 8d 65 f8 lea -0x8(%ebp),%esp
109869: 5b pop %ebx
10986a: 5e pop %esi
10986b: c9 leave
10986c: c3 ret
001098d4 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
1098d4: 55 push %ebp
1098d5: 89 e5 mov %esp,%ebp
1098d7: 57 push %edi
1098d8: 56 push %esi
1098d9: 53 push %ebx
1098da: 83 ec 1c sub $0x1c,%esp
1098dd: 8b 7d 08 mov 0x8(%ebp),%edi
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
1098e0: 85 ff test %edi,%edi
1098e2: 0f 84 8e 00 00 00 je 109976 <pthread_rwlock_timedrdlock+0xa2>
* So we check the abstime provided, and hold on to whether it
* is valid or not. If it isn't correct and in the future,
* then we do a polling operation and convert the UNSATISFIED
* status into the appropriate error.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
1098e8: 52 push %edx
1098e9: 52 push %edx
1098ea: 8d 45 ec lea -0x14(%ebp),%eax
1098ed: 50 push %eax
1098ee: ff 75 0c pushl 0xc(%ebp)
1098f1: e8 22 5a 00 00 call 10f318 <_POSIX_Absolute_timeout_to_ticks>
1098f6: 89 c6 mov %eax,%esi
switch (status) {
1098f8: 83 c4 10 add $0x10,%esp
1098fb: 31 db xor %ebx,%ebx
1098fd: 83 f8 02 cmp $0x2,%eax
109900: 76 07 jbe 109909 <pthread_rwlock_timedrdlock+0x35>
109902: 83 f8 03 cmp $0x3,%eax
109905: 75 02 jne 109909 <pthread_rwlock_timedrdlock+0x35><== NEVER TAKEN
109907: b3 01 mov $0x1,%bl
109909: 50 push %eax
10990a: 8d 45 f0 lea -0x10(%ebp),%eax
10990d: 50 push %eax
10990e: ff 37 pushl (%edi)
109910: 68 00 fe 11 00 push $0x11fe00
109915: e8 72 28 00 00 call 10c18c <_Objects_Get>
10991a: 89 c2 mov %eax,%edx
do_wait = TRUE;
break;
}
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
10991c: 83 c4 10 add $0x10,%esp
10991f: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
109923: 75 51 jne 109976 <pthread_rwlock_timedrdlock+0xa2>
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
109925: 83 ec 0c sub $0xc,%esp
109928: 6a 00 push $0x0
10992a: ff 75 ec pushl -0x14(%ebp)
10992d: 0f b6 c3 movzbl %bl,%eax
109930: 50 push %eax
109931: ff 37 pushl (%edi)
109933: 8d 42 10 lea 0x10(%edx),%eax
109936: 50 push %eax
109937: e8 e4 1d 00 00 call 10b720 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10993c: 83 c4 20 add $0x20,%esp
10993f: e8 08 30 00 00 call 10c94c <_Thread_Enable_dispatch>
if ( !do_wait &&
109944: 84 db test %bl,%bl
109946: 75 19 jne 109961 <pthread_rwlock_timedrdlock+0x8d><== ALWAYS TAKEN
109948: a1 90 fc 11 00 mov 0x11fc90,%eax <== NOT EXECUTED
10994d: 83 78 34 02 cmpl $0x2,0x34(%eax) <== NOT EXECUTED
109951: 75 0e jne 109961 <pthread_rwlock_timedrdlock+0x8d><== NOT EXECUTED
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
switch (status) {
109953: 85 f6 test %esi,%esi <== NOT EXECUTED
109955: 74 1f je 109976 <pthread_rwlock_timedrdlock+0xa2><== NOT EXECUTED
109957: b8 74 00 00 00 mov $0x74,%eax <== NOT EXECUTED
10995c: 83 fe 02 cmp $0x2,%esi <== NOT EXECUTED
10995f: 76 1a jbe 10997b <pthread_rwlock_timedrdlock+0xa7><== NOT EXECUTED
case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE:
break;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
109961: 83 ec 0c sub $0xc,%esp
109964: a1 90 fc 11 00 mov 0x11fc90,%eax
109969: ff 70 34 pushl 0x34(%eax)
10996c: e8 c3 00 00 00 call 109a34 <_POSIX_RWLock_Translate_core_RWLock_return_code>
109971: 83 c4 10 add $0x10,%esp
109974: eb 05 jmp 10997b <pthread_rwlock_timedrdlock+0xa7>
109976: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10997b: 8d 65 f4 lea -0xc(%ebp),%esp
10997e: 5b pop %ebx
10997f: 5e pop %esi
109980: 5f pop %edi
109981: c9 leave
109982: c3 ret
00109984 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
109984: 55 push %ebp
109985: 89 e5 mov %esp,%ebp
109987: 57 push %edi
109988: 56 push %esi
109989: 53 push %ebx
10998a: 83 ec 1c sub $0x1c,%esp
10998d: 8b 7d 08 mov 0x8(%ebp),%edi
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
109990: 85 ff test %edi,%edi
109992: 0f 84 8e 00 00 00 je 109a26 <pthread_rwlock_timedwrlock+0xa2>
* So we check the abstime provided, and hold on to whether it
* is valid or not. If it isn't correct and in the future,
* then we do a polling operation and convert the UNSATISFIED
* status into the appropriate error.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
109998: 52 push %edx
109999: 52 push %edx
10999a: 8d 45 ec lea -0x14(%ebp),%eax
10999d: 50 push %eax
10999e: ff 75 0c pushl 0xc(%ebp)
1099a1: e8 72 59 00 00 call 10f318 <_POSIX_Absolute_timeout_to_ticks>
1099a6: 89 c6 mov %eax,%esi
switch (status) {
1099a8: 83 c4 10 add $0x10,%esp
1099ab: 31 db xor %ebx,%ebx
1099ad: 83 f8 02 cmp $0x2,%eax
1099b0: 76 07 jbe 1099b9 <pthread_rwlock_timedwrlock+0x35>
1099b2: 83 f8 03 cmp $0x3,%eax
1099b5: 75 02 jne 1099b9 <pthread_rwlock_timedwrlock+0x35><== NEVER TAKEN
1099b7: b3 01 mov $0x1,%bl
1099b9: 50 push %eax
1099ba: 8d 45 f0 lea -0x10(%ebp),%eax
1099bd: 50 push %eax
1099be: ff 37 pushl (%edi)
1099c0: 68 00 fe 11 00 push $0x11fe00
1099c5: e8 c2 27 00 00 call 10c18c <_Objects_Get>
1099ca: 89 c2 mov %eax,%edx
do_wait = TRUE;
break;
}
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
1099cc: 83 c4 10 add $0x10,%esp
1099cf: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
1099d3: 75 51 jne 109a26 <pthread_rwlock_timedwrlock+0xa2>
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
1099d5: 83 ec 0c sub $0xc,%esp
1099d8: 6a 00 push $0x0
1099da: ff 75 ec pushl -0x14(%ebp)
1099dd: 0f b6 c3 movzbl %bl,%eax
1099e0: 50 push %eax
1099e1: ff 37 pushl (%edi)
1099e3: 8d 42 10 lea 0x10(%edx),%eax
1099e6: 50 push %eax
1099e7: e8 e8 1d 00 00 call 10b7d4 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
1099ec: 83 c4 20 add $0x20,%esp
1099ef: e8 58 2f 00 00 call 10c94c <_Thread_Enable_dispatch>
if ( !do_wait &&
1099f4: 84 db test %bl,%bl
1099f6: 75 19 jne 109a11 <pthread_rwlock_timedwrlock+0x8d><== ALWAYS TAKEN
1099f8: a1 90 fc 11 00 mov 0x11fc90,%eax <== NOT EXECUTED
1099fd: 83 78 34 02 cmpl $0x2,0x34(%eax) <== NOT EXECUTED
109a01: 75 0e jne 109a11 <pthread_rwlock_timedwrlock+0x8d><== NOT EXECUTED
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
switch (status) {
109a03: 85 f6 test %esi,%esi <== NOT EXECUTED
109a05: 74 1f je 109a26 <pthread_rwlock_timedwrlock+0xa2><== NOT EXECUTED
109a07: b8 74 00 00 00 mov $0x74,%eax <== NOT EXECUTED
109a0c: 83 fe 02 cmp $0x2,%esi <== NOT EXECUTED
109a0f: 76 1a jbe 109a2b <pthread_rwlock_timedwrlock+0xa7><== NOT EXECUTED
case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE:
break;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
109a11: 83 ec 0c sub $0xc,%esp
109a14: a1 90 fc 11 00 mov 0x11fc90,%eax
109a19: ff 70 34 pushl 0x34(%eax)
109a1c: e8 13 00 00 00 call 109a34 <_POSIX_RWLock_Translate_core_RWLock_return_code>
109a21: 83 c4 10 add $0x10,%esp
109a24: eb 05 jmp 109a2b <pthread_rwlock_timedwrlock+0xa7>
109a26: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
109a2b: 8d 65 f4 lea -0xc(%ebp),%esp
109a2e: 5b pop %ebx
109a2f: 5e pop %esi
109a30: 5f pop %edi
109a31: c9 leave
109a32: c3 ret
0010a1ac <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
10a1ac: 55 push %ebp
10a1ad: 89 e5 mov %esp,%ebp
10a1af: 8b 45 08 mov 0x8(%ebp),%eax
10a1b2: 8b 55 0c mov 0xc(%ebp),%edx
if ( !attr )
10a1b5: 85 c0 test %eax,%eax
10a1b7: 74 11 je 10a1ca <pthread_rwlockattr_setpshared+0x1e>
return EINVAL;
if ( !attr->is_initialized )
10a1b9: 83 38 00 cmpl $0x0,(%eax)
10a1bc: 74 0c je 10a1ca <pthread_rwlockattr_setpshared+0x1e>
return EINVAL;
switch ( pshared ) {
10a1be: 83 fa 01 cmp $0x1,%edx
10a1c1: 77 07 ja 10a1ca <pthread_rwlockattr_setpshared+0x1e><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10a1c3: 89 50 04 mov %edx,0x4(%eax)
10a1c6: 31 c0 xor %eax,%eax
10a1c8: eb 05 jmp 10a1cf <pthread_rwlockattr_setpshared+0x23>
return 0;
10a1ca: b8 16 00 00 00 mov $0x16,%eax
default:
return EINVAL;
}
}
10a1cf: c9 leave
10a1d0: c3 ret
00109164 <pthread_setcancelstate>:
int pthread_setcancelstate(
int state,
int *oldstate
)
{
109164: 55 push %ebp
109165: 89 e5 mov %esp,%ebp
109167: 53 push %ebx
109168: 83 ec 04 sub $0x4,%esp
10916b: 8b 4d 08 mov 0x8(%ebp),%ecx
10916e: 8b 5d 0c mov 0xc(%ebp),%ebx
* 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() )
109171: a1 84 f5 11 00 mov 0x11f584,%eax
109176: ba 47 00 00 00 mov $0x47,%edx
10917b: 85 c0 test %eax,%eax
10917d: 75 6e jne 1091ed <pthread_setcancelstate+0x89><== NEVER TAKEN
return EPROTO;
if ( !oldstate )
10917f: 85 db test %ebx,%ebx
109181: 74 65 je 1091e8 <pthread_setcancelstate+0x84><== NEVER TAKEN
return EINVAL;
if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE )
109183: 83 f9 01 cmp $0x1,%ecx
109186: 77 60 ja 1091e8 <pthread_setcancelstate+0x84><== NEVER TAKEN
return EINVAL;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
109188: a1 a8 f5 11 00 mov 0x11f5a8,%eax
10918d: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
109193: a1 e8 f4 11 00 mov 0x11f4e8,%eax
109198: 40 inc %eax
109199: a3 e8 f4 11 00 mov %eax,0x11f4e8
_Thread_Disable_dispatch();
*oldstate = thread_support->cancelability_state;
10919e: 8b 82 cc 00 00 00 mov 0xcc(%edx),%eax
1091a4: 89 03 mov %eax,(%ebx)
thread_support->cancelability_state = state;
1091a6: 89 8a cc 00 00 00 mov %ecx,0xcc(%edx)
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
1091ac: 85 c9 test %ecx,%ecx
1091ae: 75 15 jne 1091c5 <pthread_setcancelstate+0x61><== NEVER TAKEN
1091b0: 83 ba d0 00 00 00 01 cmpl $0x1,0xd0(%edx)
1091b7: 75 0c jne 1091c5 <pthread_setcancelstate+0x61><== ALWAYS TAKEN
1091b9: 83 ba d4 00 00 00 00 cmpl $0x0,0xd4(%edx) <== NOT EXECUTED
1091c0: 0f 95 c3 setne %bl <== NOT EXECUTED
1091c3: eb 02 jmp 1091c7 <pthread_setcancelstate+0x63><== NOT EXECUTED
1091c5: 31 db xor %ebx,%ebx
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
1091c7: e8 00 26 00 00 call 10b7cc <_Thread_Enable_dispatch>
if ( cancel )
1091cc: 31 d2 xor %edx,%edx
1091ce: 84 db test %bl,%bl
1091d0: 74 1b je 1091ed <pthread_setcancelstate+0x89><== ALWAYS TAKEN
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
1091d2: 50 push %eax <== NOT EXECUTED
1091d3: 50 push %eax <== NOT EXECUTED
1091d4: 6a ff push $0xffffffff <== NOT EXECUTED
1091d6: ff 35 a8 f5 11 00 pushl 0x11f5a8 <== NOT EXECUTED
1091dc: e8 83 fb ff ff call 108d64 <_POSIX_Thread_Exit> <== NOT EXECUTED
1091e1: 31 d2 xor %edx,%edx <== NOT EXECUTED
1091e3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1091e6: eb 05 jmp 1091ed <pthread_setcancelstate+0x89><== NOT EXECUTED
1091e8: ba 16 00 00 00 mov $0x16,%edx <== NOT EXECUTED
return 0;
}
1091ed: 89 d0 mov %edx,%eax
1091ef: 8b 5d fc mov -0x4(%ebp),%ebx
1091f2: c9 leave
1091f3: c3 ret
001091f4 <pthread_setcanceltype>:
int pthread_setcanceltype(
int type,
int *oldtype
)
{
1091f4: 55 push %ebp
1091f5: 89 e5 mov %esp,%ebp
1091f7: 53 push %ebx
1091f8: 83 ec 04 sub $0x4,%esp
1091fb: 8b 4d 08 mov 0x8(%ebp),%ecx
1091fe: 8b 5d 0c mov 0xc(%ebp),%ebx
* 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() )
109201: a1 84 f5 11 00 mov 0x11f584,%eax
109206: ba 47 00 00 00 mov $0x47,%edx
10920b: 85 c0 test %eax,%eax
10920d: 75 6d jne 10927c <pthread_setcanceltype+0x88><== NEVER TAKEN
return EPROTO;
if ( !oldtype )
10920f: 85 db test %ebx,%ebx
109211: 74 64 je 109277 <pthread_setcanceltype+0x83><== NEVER TAKEN
return EINVAL;
if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS )
109213: 83 f9 01 cmp $0x1,%ecx
109216: 77 5f ja 109277 <pthread_setcanceltype+0x83><== NEVER TAKEN
return EINVAL;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
109218: a1 a8 f5 11 00 mov 0x11f5a8,%eax
10921d: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx
109223: a1 e8 f4 11 00 mov 0x11f4e8,%eax
109228: 40 inc %eax
109229: a3 e8 f4 11 00 mov %eax,0x11f4e8
_Thread_Disable_dispatch();
*oldtype = thread_support->cancelability_type;
10922e: 8b 82 d0 00 00 00 mov 0xd0(%edx),%eax
109234: 89 03 mov %eax,(%ebx)
thread_support->cancelability_type = type;
109236: 89 8a d0 00 00 00 mov %ecx,0xd0(%edx)
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
10923c: 83 ba cc 00 00 00 00 cmpl $0x0,0xcc(%edx)
109243: 75 0f jne 109254 <pthread_setcanceltype+0x60><== NEVER TAKEN
109245: 49 dec %ecx
109246: 75 0c jne 109254 <pthread_setcanceltype+0x60>
109248: 83 ba d4 00 00 00 00 cmpl $0x0,0xd4(%edx)
10924f: 0f 95 c3 setne %bl
109252: eb 02 jmp 109256 <pthread_setcanceltype+0x62>
109254: 31 db xor %ebx,%ebx
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
109256: e8 71 25 00 00 call 10b7cc <_Thread_Enable_dispatch>
if ( cancel )
10925b: 31 d2 xor %edx,%edx
10925d: 84 db test %bl,%bl
10925f: 74 1b je 10927c <pthread_setcanceltype+0x88><== ALWAYS TAKEN
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
109261: 50 push %eax <== NOT EXECUTED
109262: 50 push %eax <== NOT EXECUTED
109263: 6a ff push $0xffffffff <== NOT EXECUTED
109265: ff 35 a8 f5 11 00 pushl 0x11f5a8 <== NOT EXECUTED
10926b: e8 f4 fa ff ff call 108d64 <_POSIX_Thread_Exit> <== NOT EXECUTED
109270: 31 d2 xor %edx,%edx <== NOT EXECUTED
109272: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109275: eb 05 jmp 10927c <pthread_setcanceltype+0x88><== NOT EXECUTED
109277: ba 16 00 00 00 mov $0x16,%edx <== NOT EXECUTED
return 0;
}
10927c: 89 d0 mov %edx,%eax
10927e: 8b 5d fc mov -0x4(%ebp),%ebx
109281: c9 leave
109282: c3 ret
0010b2b4 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
10b2b4: 55 push %ebp
10b2b5: 89 e5 mov %esp,%ebp
10b2b7: 57 push %edi
10b2b8: 56 push %esi
10b2b9: 53 push %ebx
10b2ba: 83 ec 2c sub $0x2c,%esp
/*
* Check all the parameters
*/
if ( !param )
10b2bd: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10b2c1: 0f 84 7e 01 00 00 je 10b445 <pthread_setschedparam+0x191>
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
10b2c7: 8b 55 10 mov 0x10(%ebp),%edx
10b2ca: 8b 02 mov (%edx),%eax
10b2cc: 48 dec %eax
10b2cd: 3d fd 00 00 00 cmp $0xfd,%eax
10b2d2: 0f 87 6d 01 00 00 ja 10b445 <pthread_setschedparam+0x191><== NEVER TAKEN
return EINVAL;
budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
budget_callout = NULL;
switch ( policy ) {
10b2d8: 83 7d 0c 01 cmpl $0x1,0xc(%ebp)
10b2dc: 74 1f je 10b2fd <pthread_setschedparam+0x49>
10b2de: 7f 0b jg 10b2eb <pthread_setschedparam+0x37>
10b2e0: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10b2e4: 74 20 je 10b306 <pthread_setschedparam+0x52>
10b2e6: e9 5a 01 00 00 jmp 10b445 <pthread_setschedparam+0x191>
10b2eb: 83 7d 0c 02 cmpl $0x2,0xc(%ebp)
10b2ef: 74 25 je 10b316 <pthread_setschedparam+0x62>
10b2f1: 83 7d 0c 03 cmpl $0x3,0xc(%ebp)
10b2f5: 0f 85 4a 01 00 00 jne 10b445 <pthread_setschedparam+0x191><== NEVER TAKEN
10b2fb: eb 22 jmp 10b31f <pthread_setschedparam+0x6b>
10b2fd: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
10b304: eb 07 jmp 10b30d <pthread_setschedparam+0x59>
10b306: c7 45 dc 01 00 00 00 movl $0x1,-0x24(%ebp)
10b30d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
10b314: eb 53 jmp 10b369 <pthread_setschedparam+0xb5>
10b316: c7 45 dc 02 00 00 00 movl $0x2,-0x24(%ebp)
10b31d: eb ee jmp 10b30d <pthread_setschedparam+0x59>
case SCHED_SPORADIC:
budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
budget_callout = _POSIX_Threads_Sporadic_budget_callout;
if ( _Timespec_To_ticks( ¶m->ss_replenish_period ) <
10b31f: 83 ec 0c sub $0xc,%esp
10b322: 8b 45 10 mov 0x10(%ebp),%eax
10b325: 83 c0 08 add $0x8,%eax
10b328: 50 push %eax
10b329: e8 d2 31 00 00 call 10e500 <_Timespec_To_ticks>
10b32e: 89 c3 mov %eax,%ebx
10b330: 8b 45 10 mov 0x10(%ebp),%eax
10b333: 83 c0 10 add $0x10,%eax
10b336: 89 04 24 mov %eax,(%esp)
10b339: e8 c2 31 00 00 call 10e500 <_Timespec_To_ticks>
10b33e: 83 c4 10 add $0x10,%esp
10b341: 39 c3 cmp %eax,%ebx
10b343: 0f 82 fc 00 00 00 jb 10b445 <pthread_setschedparam+0x191><== NEVER TAKEN
_Timespec_To_ticks( ¶m->ss_initial_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->ss_low_priority ) )
10b349: 8b 75 10 mov 0x10(%ebp),%esi
10b34c: 8b 46 04 mov 0x4(%esi),%eax
10b34f: 48 dec %eax
10b350: 3d fd 00 00 00 cmp $0xfd,%eax
10b355: 0f 87 ea 00 00 00 ja 10b445 <pthread_setschedparam+0x191>
10b35b: c7 45 dc 03 00 00 00 movl $0x3,-0x24(%ebp)
10b362: c7 45 e0 dc b1 10 00 movl $0x10b1dc,-0x20(%ebp)
static inline uint32_t _Protected_heap_Initialize(
Heap_Control *the_heap,
void *starting_address,
size_t size,
uint32_t page_size
)
10b369: 53 push %ebx
10b36a: 8d 45 f0 lea -0x10(%ebp),%eax
10b36d: 50 push %eax
10b36e: ff 75 08 pushl 0x8(%ebp)
10b371: 68 d8 2d 12 00 push $0x122dd8
10b376: e8 e9 1d 00 00 call 10d164 <_Objects_Get>
10b37b: 89 45 d4 mov %eax,-0x2c(%ebp)
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _POSIX_Threads_Get( thread, &location );
switch ( location ) {
10b37e: 83 c4 10 add $0x10,%esp
10b381: b8 03 00 00 00 mov $0x3,%eax
10b386: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
10b38a: 0f 85 ba 00 00 00 jne 10b44a <pthread_setschedparam+0x196>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10b390: 8b 45 d4 mov -0x2c(%ebp),%eax
10b393: 8b 98 f8 00 00 00 mov 0xf8(%eax),%ebx
if ( api->schedpolicy == SCHED_SPORADIC )
10b399: 83 7b 7c 03 cmpl $0x3,0x7c(%ebx)
10b39d: 75 12 jne 10b3b1 <pthread_setschedparam+0xfd>
(void) _Watchdog_Remove( &api->Sporadic_timer );
10b39f: 83 ec 0c sub $0xc,%esp
10b3a2: 8d 83 9c 00 00 00 lea 0x9c(%ebx),%eax
10b3a8: 50 push %eax
10b3a9: e8 72 35 00 00 call 10e920 <_Watchdog_Remove>
10b3ae: 83 c4 10 add $0x10,%esp
api->schedpolicy = policy;
10b3b1: 8b 55 0c mov 0xc(%ebp),%edx
10b3b4: 89 53 7c mov %edx,0x7c(%ebx)
api->schedparam = *param;
10b3b7: 8d bb 80 00 00 00 lea 0x80(%ebx),%edi
10b3bd: b9 06 00 00 00 mov $0x6,%ecx
10b3c2: 8b 75 10 mov 0x10(%ebp),%esi
10b3c5: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_thread->budget_algorithm = budget_algorithm;
10b3c7: 8b 55 dc mov -0x24(%ebp),%edx
10b3ca: 8b 45 d4 mov -0x2c(%ebp),%eax
10b3cd: 89 50 7c mov %edx,0x7c(%eax)
the_thread->budget_callout = budget_callout;
10b3d0: 8b 75 e0 mov -0x20(%ebp),%esi
10b3d3: 89 b0 80 00 00 00 mov %esi,0x80(%eax)
switch ( api->schedpolicy ) {
10b3d9: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10b3dd: 78 5d js 10b43c <pthread_setschedparam+0x188><== NEVER TAKEN
10b3df: 83 7d 0c 02 cmpl $0x2,0xc(%ebp)
10b3e3: 7e 08 jle 10b3ed <pthread_setschedparam+0x139>
10b3e5: 83 7d 0c 03 cmpl $0x3,0xc(%ebp)
10b3e9: 75 51 jne 10b43c <pthread_setschedparam+0x188><== NEVER TAKEN
10b3eb: eb 25 jmp 10b412 <pthread_setschedparam+0x15e>
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
10b3ed: a1 34 2b 12 00 mov 0x122b34,%eax
10b3f2: 8b 55 d4 mov -0x2c(%ebp),%edx
10b3f5: 89 42 78 mov %eax,0x78(%edx)
/**
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
10b3f8: b8 ff 00 00 00 mov $0xff,%eax
10b3fd: 2b 83 80 00 00 00 sub 0x80(%ebx),%eax
the_thread->real_priority =
10b403: 89 42 18 mov %eax,0x18(%edx)
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
10b406: 51 push %ecx
10b407: 6a 01 push $0x1
10b409: 50 push %eax
10b40a: 52 push %edx
10b40b: e8 74 20 00 00 call 10d484 <_Thread_Change_priority>
10b410: eb 27 jmp 10b439 <pthread_setschedparam+0x185>
TRUE
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
10b412: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
10b418: 89 83 98 00 00 00 mov %eax,0x98(%ebx)
_Watchdog_Remove( &api->Sporadic_timer );
10b41e: 83 ec 0c sub $0xc,%esp
10b421: 8d 83 9c 00 00 00 lea 0x9c(%ebx),%eax
10b427: 50 push %eax
10b428: e8 f3 34 00 00 call 10e920 <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
10b42d: 58 pop %eax
10b42e: 5a pop %edx
10b42f: ff 75 d4 pushl -0x2c(%ebp)
10b432: 6a 00 push $0x0
10b434: e8 e1 fd ff ff call 10b21a <_POSIX_Threads_Sporadic_budget_TSR>
10b439: 83 c4 10 add $0x10,%esp
break;
}
_Thread_Enable_dispatch();
10b43c: e8 e3 24 00 00 call 10d924 <_Thread_Enable_dispatch>
10b441: 31 c0 xor %eax,%eax
10b443: eb 05 jmp 10b44a <pthread_setschedparam+0x196>
return 0;
10b445: b8 16 00 00 00 mov $0x16,%eax
case OBJECTS_ERROR:
break;
}
return ESRCH;
}
10b44a: 8d 65 f4 lea -0xc(%ebp),%esp
10b44d: 5b pop %ebx
10b44e: 5e pop %esi
10b44f: 5f pop %edi
10b450: c9 leave
10b451: c3 ret
0010e898 <pthread_sigmask>:
int pthread_sigmask(
int how,
const sigset_t *set,
sigset_t *oset
)
{
10e898: 55 push %ebp
10e899: 89 e5 mov %esp,%ebp
10e89b: 57 push %edi
10e89c: 56 push %esi
10e89d: 53 push %ebx
10e89e: 83 ec 0c sub $0xc,%esp
10e8a1: 8b 75 08 mov 0x8(%ebp),%esi
10e8a4: 8b 5d 0c mov 0xc(%ebp),%ebx
10e8a7: 8b 55 10 mov 0x10(%ebp),%edx
POSIX_API_Control *api;
if ( !set && !oset )
10e8aa: 85 db test %ebx,%ebx
10e8ac: 0f 94 45 f3 sete -0xd(%ebp)
10e8b0: 75 04 jne 10e8b6 <pthread_sigmask+0x1e>
10e8b2: 85 d2 test %edx,%edx
10e8b4: 74 4e je 10e904 <pthread_sigmask+0x6c> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10e8b6: 8b 3d b8 01 12 00 mov 0x1201b8,%edi
10e8bc: 8b 8f f8 00 00 00 mov 0xf8(%edi),%ecx
if ( oset )
10e8c2: 85 d2 test %edx,%edx
10e8c4: 74 08 je 10e8ce <pthread_sigmask+0x36>
*oset = api->signals_blocked;
10e8c6: 8b 81 c4 00 00 00 mov 0xc4(%ecx),%eax
10e8cc: 89 02 mov %eax,(%edx)
if ( !set )
10e8ce: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
10e8d2: 75 61 jne 10e935 <pthread_sigmask+0x9d> <== NEVER TAKEN
return 0;
switch ( how ) {
10e8d4: 83 fe 01 cmp $0x1,%esi
10e8d7: 74 0b je 10e8e4 <pthread_sigmask+0x4c>
10e8d9: 83 fe 02 cmp $0x2,%esi
10e8dc: 74 10 je 10e8ee <pthread_sigmask+0x56>
10e8de: 85 f6 test %esi,%esi
10e8e0: 74 18 je 10e8fa <pthread_sigmask+0x62>
10e8e2: eb 20 jmp 10e904 <pthread_sigmask+0x6c>
case SIG_BLOCK:
api->signals_blocked |= *set;
10e8e4: 8b 03 mov (%ebx),%eax
10e8e6: 09 81 c4 00 00 00 or %eax,0xc4(%ecx)
10e8ec: eb 26 jmp 10e914 <pthread_sigmask+0x7c>
break;
case SIG_UNBLOCK:
api->signals_blocked &= ~*set;
10e8ee: 8b 03 mov (%ebx),%eax
10e8f0: f7 d0 not %eax
10e8f2: 21 81 c4 00 00 00 and %eax,0xc4(%ecx)
10e8f8: eb 1a jmp 10e914 <pthread_sigmask+0x7c>
break;
case SIG_SETMASK:
api->signals_blocked = *set;
10e8fa: 8b 03 mov (%ebx),%eax
10e8fc: 89 81 c4 00 00 00 mov %eax,0xc4(%ecx)
10e902: eb 10 jmp 10e914 <pthread_sigmask+0x7c>
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10e904: e8 07 16 00 00 call 10ff10 <__errno>
10e909: c7 00 16 00 00 00 movl $0x16,(%eax)
10e90f: 83 c8 ff or $0xffffffff,%eax
10e912: eb 23 jmp 10e937 <pthread_sigmask+0x9f>
/* XXX are there critical section problems here? */
/* XXX evaluate the new set */
if ( ~api->signals_blocked &
10e914: 8b 15 68 08 12 00 mov 0x120868,%edx
10e91a: 0b 91 c8 00 00 00 or 0xc8(%ecx),%edx
10e920: 8b 81 c4 00 00 00 mov 0xc4(%ecx),%eax
10e926: f7 d0 not %eax
10e928: 85 c2 test %eax,%edx
10e92a: 74 09 je 10e935 <pthread_sigmask+0x9d>
(api->signals_pending | _POSIX_signals_Pending) ) {
_Thread_Executing->do_post_task_switch_extension = true;
10e92c: c6 47 75 01 movb $0x1,0x75(%edi)
_Thread_Dispatch();
10e930: e8 6b d2 ff ff call 10bba0 <_Thread_Dispatch>
10e935: 31 c0 xor %eax,%eax
}
return 0;
}
10e937: 83 c4 0c add $0xc,%esp
10e93a: 5b pop %ebx
10e93b: 5e pop %esi
10e93c: 5f pop %edi
10e93d: c9 leave
10e93e: c3 ret
001092ac <pthread_testcancel>:
*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
1092ac: 55 push %ebp
1092ad: 89 e5 mov %esp,%ebp
1092af: 53 push %ebx
1092b0: 83 ec 04 sub $0x4,%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() )
1092b3: a1 84 f5 11 00 mov 0x11f584,%eax
1092b8: 85 c0 test %eax,%eax
1092ba: 75 46 jne 109302 <pthread_testcancel+0x56><== NEVER TAKEN
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
1092bc: a1 a8 f5 11 00 mov 0x11f5a8,%eax
1092c1: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx
1092c7: a1 e8 f4 11 00 mov 0x11f4e8,%eax
1092cc: 40 inc %eax
1092cd: a3 e8 f4 11 00 mov %eax,0x11f4e8
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
1092d2: 31 db xor %ebx,%ebx
1092d4: 83 ba cc 00 00 00 00 cmpl $0x0,0xcc(%edx)
1092db: 75 0a jne 1092e7 <pthread_testcancel+0x3b><== NEVER TAKEN
1092dd: 83 ba d4 00 00 00 00 cmpl $0x0,0xd4(%edx)
1092e4: 0f 95 c3 setne %bl
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
1092e7: e8 e0 24 00 00 call 10b7cc <_Thread_Enable_dispatch>
if ( cancel )
1092ec: 84 db test %bl,%bl
1092ee: 74 12 je 109302 <pthread_testcancel+0x56>
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
1092f0: 50 push %eax
1092f1: 50 push %eax
1092f2: 6a ff push $0xffffffff
1092f4: ff 35 a8 f5 11 00 pushl 0x11f5a8
1092fa: e8 65 fa ff ff call 108d64 <_POSIX_Thread_Exit>
1092ff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
109302: 8b 5d fc mov -0x4(%ebp),%ebx
109305: c9 leave
109306: c3 ret
0011575c <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
11575c: 55 push %ebp
11575d: 89 e5 mov %esp,%ebp
11575f: 56 push %esi
115760: 53 push %ebx
115761: 8b 45 08 mov 0x8(%ebp),%eax
115764: 8b 75 0c mov 0xc(%ebp),%esi
115767: 8b 4d 10 mov 0x10(%ebp),%ecx
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
11576a: 3b 05 d8 92 11 00 cmp 0x1192d8,%eax
115770: 73 2d jae 11579f <read+0x43> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
115772: 6b d8 34 imul $0x34,%eax,%ebx
115775: 03 1d 38 d6 11 00 add 0x11d638,%ebx
rtems_libio_check_is_open( iop );
11577b: 8b 53 0c mov 0xc(%ebx),%edx
11577e: f6 c6 01 test $0x1,%dh
115781: 74 1c je 11579f <read+0x43> <== NEVER TAKEN
rtems_libio_check_buffer( buffer );
115783: 85 f6 test %esi,%esi
115785: 75 0d jne 115794 <read+0x38> <== ALWAYS TAKEN
115787: e8 9c 99 ff ff call 10f128 <__errno> <== NOT EXECUTED
11578c: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
115792: eb 2d jmp 1157c1 <read+0x65> <== NOT EXECUTED
rtems_libio_check_count( count );
115794: 31 c0 xor %eax,%eax
115796: 85 c9 test %ecx,%ecx
115798: 74 3c je 1157d6 <read+0x7a> <== NEVER TAKEN
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
11579a: 80 e2 02 and $0x2,%dl
11579d: 75 0d jne 1157ac <read+0x50> <== ALWAYS TAKEN
11579f: e8 84 99 ff ff call 10f128 <__errno> <== NOT EXECUTED
1157a4: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
1157aa: eb 15 jmp 1157c1 <read+0x65> <== NOT EXECUTED
/*
* Now process the read().
*/
if ( !iop->handlers->read_h )
1157ac: 8b 43 30 mov 0x30(%ebx),%eax
1157af: 8b 40 08 mov 0x8(%eax),%eax
1157b2: 85 c0 test %eax,%eax
1157b4: 75 10 jne 1157c6 <read+0x6a> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
1157b6: e8 6d 99 ff ff call 10f128 <__errno> <== NOT EXECUTED
1157bb: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
1157c1: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
1157c4: eb 10 jmp 1157d6 <read+0x7a> <== NOT EXECUTED
rc = (*iop->handlers->read_h)( iop, buffer, count );
1157c6: 52 push %edx
1157c7: 51 push %ecx
1157c8: 56 push %esi
1157c9: 53 push %ebx
1157ca: ff d0 call *%eax
if ( rc > 0 )
1157cc: 83 c4 10 add $0x10,%esp
1157cf: 85 c0 test %eax,%eax
1157d1: 7e 03 jle 1157d6 <read+0x7a>
iop->offset += rc;
1157d3: 01 43 08 add %eax,0x8(%ebx)
return rc;
}
1157d6: 8d 65 f8 lea -0x8(%ebp),%esp
1157d9: 5b pop %ebx
1157da: 5e pop %esi
1157db: c9 leave
1157dc: c3 ret
00108c94 <readdir>:
/*
* get next entry in a directory.
*/
struct dirent *
readdir( DIR *dirp )
{
108c94: 55 push %ebp
108c95: 89 e5 mov %esp,%ebp
108c97: 56 push %esi
108c98: 53 push %ebx
108c99: 8b 5d 08 mov 0x8(%ebp),%ebx
register struct dirent *dp;
if ( !dirp )
108c9c: 85 db test %ebx,%ebx
108c9e: 74 5b je 108cfb <readdir+0x67> <== NEVER TAKEN
return NULL;
for (;;) {
if (dirp->dd_loc == 0) {
108ca0: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
108ca4: 75 18 jne 108cbe <readdir+0x2a>
dirp->dd_size = getdents (dirp->dd_fd,
108ca6: 50 push %eax
108ca7: ff 73 10 pushl 0x10(%ebx)
108caa: ff 73 0c pushl 0xc(%ebx)
108cad: ff 33 pushl (%ebx)
108caf: e8 18 63 00 00 call 10efcc <getdents>
108cb4: 89 43 08 mov %eax,0x8(%ebx)
dirp->dd_buf,
dirp->dd_len);
if (dirp->dd_size <= 0)
108cb7: 83 c4 10 add $0x10,%esp
108cba: 85 c0 test %eax,%eax
108cbc: 7e 3d jle 108cfb <readdir+0x67>
return NULL;
}
if (dirp->dd_loc >= dirp->dd_size) {
108cbe: 8b 4b 04 mov 0x4(%ebx),%ecx
108cc1: 3b 4b 08 cmp 0x8(%ebx),%ecx
108cc4: 7c 09 jl 108ccf <readdir+0x3b>
dirp->dd_loc = 0;
108cc6: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
108ccd: eb d1 jmp 108ca0 <readdir+0xc>
continue;
}
dp = (struct dirent *)(dirp->dd_buf + dirp->dd_loc);
108ccf: 89 ca mov %ecx,%edx
108cd1: 03 53 0c add 0xc(%ebx),%edx
if ((intptr_t)dp & 03) /* bogus pointer check */
108cd4: f6 c2 03 test $0x3,%dl
108cd7: 75 22 jne 108cfb <readdir+0x67> <== NEVER TAKEN
return NULL;
if (dp->d_reclen <= 0 ||
108cd9: 8b 42 08 mov 0x8(%edx),%eax
108cdc: 66 85 c0 test %ax,%ax
108cdf: 74 1a je 108cfb <readdir+0x67> <== NEVER TAKEN
108ce1: 0f b7 f0 movzwl %ax,%esi
108ce4: 8b 43 10 mov 0x10(%ebx),%eax
108ce7: 40 inc %eax
108ce8: 29 c8 sub %ecx,%eax
108cea: 39 c6 cmp %eax,%esi
108cec: 7f 0d jg 108cfb <readdir+0x67> <== NEVER TAKEN
dp->d_reclen > dirp->dd_len + 1 - dirp->dd_loc)
return NULL;
dirp->dd_loc += dp->d_reclen;
108cee: 8d 04 0e lea (%esi,%ecx,1),%eax
108cf1: 89 43 04 mov %eax,0x4(%ebx)
if (dp->d_ino == 0)
108cf4: 83 3a 00 cmpl $0x0,(%edx)
108cf7: 74 a7 je 108ca0 <readdir+0xc> <== NEVER TAKEN
108cf9: eb 02 jmp 108cfd <readdir+0x69>
108cfb: 31 d2 xor %edx,%edx
continue;
return (dp);
}
}
108cfd: 89 d0 mov %edx,%eax
108cff: 8d 65 f8 lea -0x8(%ebp),%esp
108d02: 5b pop %ebx
108d03: 5e pop %esi
108d04: c9 leave
108d05: c3 ret
00109440 <readlink>:
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
109440: 55 push %ebp
109441: 89 e5 mov %esp,%ebp
109443: 57 push %edi
109444: 56 push %esi
109445: 53 push %ebx
109446: 83 ec 1c sub $0x1c,%esp
109449: 8b 7d 0c mov 0xc(%ebp),%edi
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
10944c: 85 ff test %edi,%edi
10944e: 75 0d jne 10945d <readlink+0x1d> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EFAULT );
109450: e8 1b 92 00 00 call 112670 <__errno> <== NOT EXECUTED
109455: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED
10945b: eb 43 jmp 1094a0 <readlink+0x60> <== NOT EXECUTED
result = rtems_filesystem_evaluate_path( pathname, 0, &loc, false );
10945d: 6a 00 push $0x0
10945f: 8d 75 e4 lea -0x1c(%ebp),%esi
109462: 56 push %esi
109463: 6a 00 push $0x0
109465: ff 75 08 pushl 0x8(%ebp)
109468: e8 3d ed ff ff call 1081aa <rtems_filesystem_evaluate_path>
if ( result != 0 )
10946d: 83 c4 10 add $0x10,%esp
109470: 83 cb ff or $0xffffffff,%ebx
109473: 85 c0 test %eax,%eax
109475: 0f 85 87 00 00 00 jne 109502 <readlink+0xc2> <== NEVER TAKEN
return -1;
if ( !loc.ops->node_type_h ){
10947b: 8b 45 ec mov -0x14(%ebp),%eax
10947e: 8b 50 10 mov 0x10(%eax),%edx
109481: 85 d2 test %edx,%edx
109483: 75 20 jne 1094a5 <readlink+0x65> <== ALWAYS TAKEN
rtems_filesystem_freenode( &loc );
109485: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
109488: 85 c0 test %eax,%eax <== NOT EXECUTED
10948a: 74 09 je 109495 <readlink+0x55> <== NOT EXECUTED
10948c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10948f: 56 push %esi <== NOT EXECUTED
109490: ff d0 call *%eax <== NOT EXECUTED
109492: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
109495: e8 d6 91 00 00 call 112670 <__errno> <== NOT EXECUTED
10949a: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
1094a0: 83 cb ff or $0xffffffff,%ebx
1094a3: eb 5d jmp 109502 <readlink+0xc2>
}
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
1094a5: 83 ec 0c sub $0xc,%esp
1094a8: 56 push %esi
1094a9: ff d2 call *%edx
1094ab: 83 c4 10 add $0x10,%esp
1094ae: 83 f8 04 cmp $0x4,%eax
1094b1: 8b 45 ec mov -0x14(%ebp),%eax
1094b4: 74 21 je 1094d7 <readlink+0x97>
rtems_filesystem_freenode( &loc );
1094b6: 85 c0 test %eax,%eax
1094b8: 74 10 je 1094ca <readlink+0x8a> <== NEVER TAKEN
1094ba: 8b 40 1c mov 0x1c(%eax),%eax
1094bd: 85 c0 test %eax,%eax
1094bf: 74 09 je 1094ca <readlink+0x8a> <== NEVER TAKEN
1094c1: 83 ec 0c sub $0xc,%esp
1094c4: 56 push %esi
1094c5: ff d0 call *%eax
1094c7: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( EINVAL );
1094ca: e8 a1 91 00 00 call 112670 <__errno>
1094cf: c7 00 16 00 00 00 movl $0x16,(%eax)
1094d5: eb c9 jmp 1094a0 <readlink+0x60>
}
if ( !loc.ops->readlink_h ){
1094d7: 8b 50 3c mov 0x3c(%eax),%edx
1094da: 85 d2 test %edx,%edx
1094dc: 74 a7 je 109485 <readlink+0x45> <== NEVER TAKEN
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
1094de: 50 push %eax
1094df: ff 75 10 pushl 0x10(%ebp)
1094e2: 57 push %edi
1094e3: 56 push %esi
1094e4: ff d2 call *%edx
1094e6: 89 c3 mov %eax,%ebx
rtems_filesystem_freenode( &loc );
1094e8: 8b 45 ec mov -0x14(%ebp),%eax
1094eb: 83 c4 10 add $0x10,%esp
1094ee: 85 c0 test %eax,%eax
1094f0: 74 10 je 109502 <readlink+0xc2> <== NEVER TAKEN
1094f2: 8b 40 1c mov 0x1c(%eax),%eax
1094f5: 85 c0 test %eax,%eax
1094f7: 74 09 je 109502 <readlink+0xc2> <== NEVER TAKEN
1094f9: 83 ec 0c sub $0xc,%esp
1094fc: 56 push %esi
1094fd: ff d0 call *%eax
1094ff: 83 c4 10 add $0x10,%esp
return result;
}
109502: 89 d8 mov %ebx,%eax
109504: 8d 65 f4 lea -0xc(%ebp),%esp
109507: 5b pop %ebx
109508: 5e pop %esi
109509: 5f pop %edi
10950a: c9 leave
10950b: c3 ret
0011585c <realloc>:
{
size_t old_size;
char *new_area;
size_t resize;
MSBUMP(realloc_calls, 1);
11585c: 55 push %ebp
11585d: 89 e5 mov %esp,%ebp
11585f: 57 push %edi
115860: 56 push %esi
115861: 53 push %ebx
115862: 83 ec 1c sub $0x1c,%esp
115865: 8b 5d 0c mov 0xc(%ebp),%ebx
115868: ff 05 b8 d6 11 00 incl 0x11d6b8
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
11586e: 83 3d 38 d9 11 00 03 cmpl $0x3,0x11d938
115875: 75 1a jne 115891 <realloc+0x35> <== NEVER TAKEN
if (_Thread_Dispatch_disable_level > 0)
115877: a1 98 d7 11 00 mov 0x11d798,%eax
11587c: 85 c0 test %eax,%eax
11587e: 0f 85 b7 00 00 00 jne 11593b <realloc+0xdf> <== NEVER TAKEN
return (void *) 0;
if (_ISR_Nest_level > 0)
115884: a1 34 d8 11 00 mov 0x11d834,%eax
115889: 85 c0 test %eax,%eax
11588b: 0f 85 aa 00 00 00 jne 11593b <realloc+0xdf> <== NEVER TAKEN
}
/*
* Continue with realloc().
*/
if ( !ptr )
115891: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
115895: 75 0e jne 1158a5 <realloc+0x49> <== ALWAYS TAKEN
return malloc( size );
115897: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
11589a: 53 push %ebx <== NOT EXECUTED
11589b: e8 d4 0d ff ff call 106674 <malloc> <== NOT EXECUTED
1158a0: e9 8e 00 00 00 jmp 115933 <realloc+0xd7> <== NOT EXECUTED
if ( !size ) {
1158a5: 85 db test %ebx,%ebx
1158a7: 75 14 jne 1158bd <realloc+0x61> <== ALWAYS TAKEN
free( ptr );
1158a9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1158ac: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
1158af: e8 c4 0b ff ff call 106478 <free> <== NOT EXECUTED
1158b4: c7 45 08 00 00 00 00 movl $0x0,0x8(%ebp) <== NOT EXECUTED
1158bb: eb 79 jmp 115936 <realloc+0xda> <== NOT EXECUTED
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) {
1158bd: 52 push %edx
1158be: 8d 45 f0 lea -0x10(%ebp),%eax
1158c1: 50 push %eax
1158c2: ff 75 08 pushl 0x8(%ebp)
1158c5: 68 50 d6 11 00 push $0x11d650
1158ca: e8 05 01 00 00 call 1159d4 <_Protected_heap_Get_block_size>
1158cf: 83 c4 10 add $0x10,%esp
1158d2: 84 c0 test %al,%al
1158d4: 75 0d jne 1158e3 <realloc+0x87>
errno = EINVAL;
1158d6: e8 4d 98 ff ff call 10f128 <__errno>
1158db: c7 00 16 00 00 00 movl $0x16,(%eax)
1158e1: eb 58 jmp 11593b <realloc+0xdf>
#if defined(RTEMS_MALLOC_BOUNDARY_HELPERS)
if (rtems_malloc_boundary_helpers)
resize += (*rtems_malloc_boundary_helpers->overhead)();
#endif
if ( _Protected_heap_Resize_block( &RTEMS_Malloc_Heap, ptr, resize ) ) {
1158e3: 50 push %eax
1158e4: 53 push %ebx
1158e5: ff 75 08 pushl 0x8(%ebp)
1158e8: 68 50 d6 11 00 push $0x11d650
1158ed: e8 1a 01 00 00 call 115a0c <_Protected_heap_Resize_block>
1158f2: 83 c4 10 add $0x10,%esp
1158f5: 84 c0 test %al,%al
1158f7: 75 49 jne 115942 <realloc+0xe6>
* 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 );
1158f9: 83 ec 0c sub $0xc,%esp
1158fc: 53 push %ebx
1158fd: e8 72 0d ff ff call 106674 <malloc>
115902: 89 45 d8 mov %eax,-0x28(%ebp)
MSBUMP(malloc_calls, -1); /* subtract off the malloc */
115905: ff 0d ac d6 11 00 decl 0x11d6ac
if ( !new_area ) {
11590b: 83 c4 10 add $0x10,%esp
11590e: 85 c0 test %eax,%eax
115910: 74 29 je 11593b <realloc+0xdf> <== NEVER TAKEN
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
115912: 8b 45 f0 mov -0x10(%ebp),%eax
115915: 89 d9 mov %ebx,%ecx
115917: 39 c3 cmp %eax,%ebx
115919: 76 02 jbe 11591d <realloc+0xc1> <== NEVER TAKEN
11591b: 89 c1 mov %eax,%ecx
11591d: 8b 7d d8 mov -0x28(%ebp),%edi
115920: 8b 75 08 mov 0x8(%ebp),%esi
115923: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
free( ptr );
115925: 83 ec 0c sub $0xc,%esp
115928: ff 75 08 pushl 0x8(%ebp)
11592b: e8 48 0b ff ff call 106478 <free>
115930: 8b 45 d8 mov -0x28(%ebp),%eax
115933: 89 45 08 mov %eax,0x8(%ebp)
115936: 83 c4 10 add $0x10,%esp
115939: eb 07 jmp 115942 <realloc+0xe6>
return new_area;
11593b: c7 45 08 00 00 00 00 movl $0x0,0x8(%ebp)
}
115942: 8b 45 08 mov 0x8(%ebp),%eax
115945: 8d 65 f4 lea -0xc(%ebp),%esp
115948: 5b pop %ebx
115949: 5e pop %esi
11594a: 5f pop %edi
11594b: c9 leave
11594c: c3 ret
00108d08 <rewinddir>:
#include <unistd.h>
void rewinddir(
DIR *dirp
)
{
108d08: 55 push %ebp
108d09: 89 e5 mov %esp,%ebp
108d0b: 53 push %ebx
108d0c: 83 ec 04 sub $0x4,%esp
108d0f: 8b 5d 08 mov 0x8(%ebp),%ebx
off_t status;
if ( !dirp )
108d12: 85 db test %ebx,%ebx
108d14: 74 19 je 108d2f <rewinddir+0x27>
return;
status = lseek( dirp->dd_fd, 0, SEEK_SET );
108d16: 50 push %eax
108d17: 6a 00 push $0x0
108d19: 6a 00 push $0x0
108d1b: ff 33 pushl (%ebx)
108d1d: e8 ba f0 ff ff call 107ddc <lseek>
if( status == -1 )
108d22: 83 c4 10 add $0x10,%esp
108d25: 40 inc %eax
108d26: 74 07 je 108d2f <rewinddir+0x27> <== NEVER TAKEN
return;
dirp->dd_loc = 0;
108d28: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
}
108d2f: 8b 5d fc mov -0x4(%ebp),%ebx
108d32: c9 leave
108d33: c3 ret
0010960c <rmdir>:
#include <rtems/seterr.h>
int rmdir(
const char *pathname
)
{
10960c: 55 push %ebp
10960d: 89 e5 mov %esp,%ebp
10960f: 56 push %esi
109610: 53 push %ebx
109611: 83 ec 10 sub $0x10,%esp
/*
* Get the node where we wish to go.
*/
result = rtems_filesystem_evaluate_path( pathname, 0, &loc, false );
109614: 6a 00 push $0x0
109616: 8d 75 e8 lea -0x18(%ebp),%esi
109619: 56 push %esi
10961a: 6a 00 push $0x0
10961c: ff 75 08 pushl 0x8(%ebp)
10961f: e8 5a ec ff ff call 10827e <rtems_filesystem_evaluate_path>
if ( result != 0 )
109624: 83 c4 10 add $0x10,%esp
109627: 85 c0 test %eax,%eax
109629: 0f 85 be 00 00 00 jne 1096ed <rmdir+0xe1>
return -1;
result = rtems_filesystem_evaluate_parent(RTEMS_LIBIO_PERMS_WRITE, &loc );
10962f: 50 push %eax
109630: 50 push %eax
109631: 56 push %esi
109632: 6a 02 push $0x2
109634: e8 cf eb ff ff call 108208 <rtems_filesystem_evaluate_parent>
if (result != 0) {
109639: 83 c4 10 add $0x10,%esp
10963c: 85 c0 test %eax,%eax
10963e: 8b 45 f0 mov -0x10(%ebp),%eax
109641: 74 21 je 109664 <rmdir+0x58> <== ALWAYS TAKEN
rtems_filesystem_freenode( &loc );
109643: 85 c0 test %eax,%eax <== NOT EXECUTED
109645: 0f 84 a2 00 00 00 je 1096ed <rmdir+0xe1> <== NOT EXECUTED
10964b: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
10964e: 85 c0 test %eax,%eax <== NOT EXECUTED
109650: 0f 84 97 00 00 00 je 1096ed <rmdir+0xe1> <== NOT EXECUTED
109656: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109659: 56 push %esi <== NOT EXECUTED
10965a: ff d0 call *%eax <== NOT EXECUTED
10965c: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED
10965f: e9 84 00 00 00 jmp 1096e8 <rmdir+0xdc> <== NOT EXECUTED
/*
* Verify you can remove this node as a directory.
*/
if ( !loc.ops->node_type_h ){
109664: 8b 50 10 mov 0x10(%eax),%edx
109667: 85 d2 test %edx,%edx
109669: 74 41 je 1096ac <rmdir+0xa0> <== NEVER TAKEN
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ){
10966b: 83 ec 0c sub $0xc,%esp
10966e: 56 push %esi
10966f: ff d2 call *%edx
109671: 83 c4 10 add $0x10,%esp
109674: 48 dec %eax
109675: 74 24 je 10969b <rmdir+0x8f>
rtems_filesystem_freenode( &loc );
109677: 8b 45 f0 mov -0x10(%ebp),%eax
10967a: 85 c0 test %eax,%eax
10967c: 74 10 je 10968e <rmdir+0x82> <== NEVER TAKEN
10967e: 8b 40 1c mov 0x1c(%eax),%eax
109681: 85 c0 test %eax,%eax
109683: 74 09 je 10968e <rmdir+0x82> <== NEVER TAKEN
109685: 83 ec 0c sub $0xc,%esp
109688: 56 push %esi
109689: ff d0 call *%eax
10968b: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( ENOTDIR );
10968e: e8 65 8c 00 00 call 1122f8 <__errno>
109693: c7 00 14 00 00 00 movl $0x14,(%eax)
109699: eb 52 jmp 1096ed <rmdir+0xe1>
/*
* Use the filesystems rmnod to remove the node.
*/
if ( !loc.handlers->rmnod_h ){
10969b: 8b 45 ec mov -0x14(%ebp),%eax
10969e: 8b 40 34 mov 0x34(%eax),%eax
1096a1: 85 c0 test %eax,%eax
1096a3: 75 24 jne 1096c9 <rmdir+0xbd> <== ALWAYS TAKEN
rtems_filesystem_freenode( &loc );
1096a5: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED
1096a8: 85 c0 test %eax,%eax <== NOT EXECUTED
1096aa: 74 10 je 1096bc <rmdir+0xb0> <== NOT EXECUTED
1096ac: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
1096af: 85 c0 test %eax,%eax <== NOT EXECUTED
1096b1: 74 09 je 1096bc <rmdir+0xb0> <== NOT EXECUTED
1096b3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1096b6: 56 push %esi <== NOT EXECUTED
1096b7: ff d0 call *%eax <== NOT EXECUTED
1096b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
1096bc: e8 37 8c 00 00 call 1122f8 <__errno> <== NOT EXECUTED
1096c1: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
1096c7: eb 24 jmp 1096ed <rmdir+0xe1> <== NOT EXECUTED
}
result = (*loc.handlers->rmnod_h)( &loc );
1096c9: 83 ec 0c sub $0xc,%esp
1096cc: 56 push %esi
1096cd: ff d0 call *%eax
1096cf: 89 c3 mov %eax,%ebx
rtems_filesystem_freenode( &loc );
1096d1: 8b 45 f0 mov -0x10(%ebp),%eax
1096d4: 83 c4 10 add $0x10,%esp
1096d7: 85 c0 test %eax,%eax
1096d9: 74 15 je 1096f0 <rmdir+0xe4> <== NEVER TAKEN
1096db: 8b 40 1c mov 0x1c(%eax),%eax
1096de: 85 c0 test %eax,%eax
1096e0: 74 0e je 1096f0 <rmdir+0xe4> <== NEVER TAKEN
1096e2: 83 ec 0c sub $0xc,%esp
1096e5: 56 push %esi
1096e6: ff d0 call *%eax
1096e8: 83 c4 10 add $0x10,%esp
1096eb: eb 03 jmp 1096f0 <rmdir+0xe4>
1096ed: 83 cb ff or $0xffffffff,%ebx
return result;
}
1096f0: 89 d8 mov %ebx,%eax
1096f2: 8d 65 f8 lea -0x8(%ebp),%esp
1096f5: 5b pop %ebx
1096f6: 5e pop %esi
1096f7: c9 leave
1096f8: c3 ret
0010ffd8 <rtems_assoc_name_bad>:
const char *
rtems_assoc_name_bad(
uint32_t bad_value
)
{
10ffd8: 55 push %ebp <== NOT EXECUTED
10ffd9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
sprintf(bad_buffer, "< %" PRId32 "[0x%" PRIx32 " ] >", bad_value, bad_value);
#else
static char bad_buffer[40] = "<assocnamebad.c: : BAD NAME>";
#endif
return bad_buffer;
}
10ffdb: b8 80 f4 11 00 mov $0x11f480,%eax <== NOT EXECUTED
10ffe0: c9 leave <== NOT EXECUTED
10ffe1: c3 ret <== NOT EXECUTED
0010e288 <rtems_assoc_name_by_local>:
const char *rtems_assoc_name_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
10e288: 55 push %ebp <== NOT EXECUTED
10e289: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10e28b: 53 push %ebx <== NOT EXECUTED
10e28c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10e28f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
10e292: 53 push %ebx <== NOT EXECUTED
10e293: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
10e296: e8 1d 00 00 00 call 10e2b8 <rtems_assoc_ptr_by_local><== NOT EXECUTED
if (nap)
10e29b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10e29e: 85 c0 test %eax,%eax <== NOT EXECUTED
10e2a0: 74 07 je 10e2a9 <rtems_assoc_name_by_local+0x21><== NOT EXECUTED
return nap->name;
10e2a2: 8b 00 mov (%eax),%eax <== NOT EXECUTED
return rtems_assoc_name_bad(local_value);
}
10e2a4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10e2a7: c9 leave <== NOT EXECUTED
10e2a8: c3 ret <== NOT EXECUTED
nap = rtems_assoc_ptr_by_local(ap, local_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(local_value);
10e2a9: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED
}
10e2ac: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10e2af: c9 leave <== NOT EXECUTED
nap = rtems_assoc_ptr_by_local(ap, local_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(local_value);
10e2b0: e9 23 1d 00 00 jmp 10ffd8 <rtems_assoc_name_bad> <== NOT EXECUTED
0010f0a4 <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
10f0a4: 55 push %ebp
10f0a5: 89 e5 mov %esp,%ebp
10f0a7: 56 push %esi
10f0a8: 53 push %ebx
10f0a9: 8b 5d 08 mov 0x8(%ebp),%ebx
10f0ac: 8b 75 0c mov 0xc(%ebp),%esi
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
10f0af: 8b 03 mov (%ebx),%eax
10f0b1: 85 c0 test %eax,%eax
10f0b3: 74 1b je 10f0d0 <rtems_assoc_ptr_by_local+0x2c><== NEVER TAKEN
10f0b5: 52 push %edx
10f0b6: 52 push %edx
10f0b7: 68 09 7b 11 00 push $0x117b09
10f0bc: 50 push %eax
10f0bd: e8 62 11 00 00 call 110224 <strcmp>
10f0c2: 83 c4 10 add $0x10,%esp
10f0c5: 85 c0 test %eax,%eax
10f0c7: 75 07 jne 10f0d0 <rtems_assoc_ptr_by_local+0x2c><== ALWAYS TAKEN
default_ap = ap++;
10f0c9: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10f0cb: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED
10f0ce: eb 0c jmp 10f0dc <rtems_assoc_ptr_by_local+0x38><== NOT EXECUTED
10f0d0: 31 c0 xor %eax,%eax
10f0d2: eb 08 jmp 10f0dc <rtems_assoc_ptr_by_local+0x38>
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
10f0d4: 39 73 04 cmp %esi,0x4(%ebx)
10f0d7: 74 0a je 10f0e3 <rtems_assoc_ptr_by_local+0x3f>
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
10f0d9: 83 c3 0c add $0xc,%ebx
10f0dc: 83 3b 00 cmpl $0x0,(%ebx)
10f0df: 75 f3 jne 10f0d4 <rtems_assoc_ptr_by_local+0x30>
10f0e1: 89 c3 mov %eax,%ebx
if (ap->local_value == local_value)
return ap;
return default_ap;
}
10f0e3: 89 d8 mov %ebx,%eax
10f0e5: 8d 65 f8 lea -0x8(%ebp),%esp
10f0e8: 5b pop %ebx
10f0e9: 5e pop %esi
10f0ea: c9 leave
10f0eb: c3 ret
0010e970 <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
10e970: 55 push %ebp
10e971: 89 e5 mov %esp,%ebp
10e973: 56 push %esi
10e974: 53 push %ebx
10e975: 8b 5d 08 mov 0x8(%ebp),%ebx
10e978: 8b 75 0c mov 0xc(%ebp),%esi
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
10e97b: 8b 03 mov (%ebx),%eax
10e97d: 85 c0 test %eax,%eax
10e97f: 74 1b je 10e99c <rtems_assoc_ptr_by_remote+0x2c><== NEVER TAKEN
10e981: 52 push %edx
10e982: 52 push %edx
10e983: 68 09 7b 11 00 push $0x117b09
10e988: 50 push %eax
10e989: e8 96 18 00 00 call 110224 <strcmp>
10e98e: 83 c4 10 add $0x10,%esp
10e991: 85 c0 test %eax,%eax
10e993: 75 07 jne 10e99c <rtems_assoc_ptr_by_remote+0x2c><== ALWAYS TAKEN
default_ap = ap++;
10e995: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10e997: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED
10e99a: eb 0c jmp 10e9a8 <rtems_assoc_ptr_by_remote+0x38><== NOT EXECUTED
10e99c: 31 c0 xor %eax,%eax
10e99e: eb 08 jmp 10e9a8 <rtems_assoc_ptr_by_remote+0x38>
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
10e9a0: 39 73 08 cmp %esi,0x8(%ebx)
10e9a3: 74 0a je 10e9af <rtems_assoc_ptr_by_remote+0x3f>
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
10e9a5: 83 c3 0c add $0xc,%ebx
10e9a8: 83 3b 00 cmpl $0x0,(%ebx)
10e9ab: 75 f3 jne 10e9a0 <rtems_assoc_ptr_by_remote+0x30>
10e9ad: 89 c3 mov %eax,%ebx
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
10e9af: 89 d8 mov %ebx,%eax
10e9b1: 8d 65 f8 lea -0x8(%ebp),%esp
10e9b4: 5b pop %ebx
10e9b5: 5e pop %esi
10e9b6: c9 leave
10e9b7: c3 ret
0010e9b8 <rtems_assoc_remote_by_local>:
uint32_t rtems_assoc_remote_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
10e9b8: 55 push %ebp <== NOT EXECUTED
10e9b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10e9bb: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
10e9be: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
10e9c1: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
10e9c4: e8 db 06 00 00 call 10f0a4 <rtems_assoc_ptr_by_local><== NOT EXECUTED
10e9c9: 89 c2 mov %eax,%edx <== NOT EXECUTED
if (nap)
10e9cb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10e9ce: 31 c0 xor %eax,%eax <== NOT EXECUTED
10e9d0: 85 d2 test %edx,%edx <== NOT EXECUTED
10e9d2: 74 03 je 10e9d7 <rtems_assoc_remote_by_local+0x1f><== NOT EXECUTED
return nap->remote_value;
10e9d4: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED
return 0;
}
10e9d7: c9 leave <== NOT EXECUTED
10e9d8: c3 ret <== NOT EXECUTED
00109568 <rtems_barrier_create>:
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
109568: 55 push %ebp
109569: 89 e5 mov %esp,%ebp
10956b: 57 push %edi
10956c: 56 push %esi
10956d: 53 push %ebx
10956e: 83 ec 1c sub $0x1c,%esp
109571: 8b 75 0c mov 0xc(%ebp),%esi
109574: 8b 55 10 mov 0x10(%ebp),%edx
109577: 8b 7d 14 mov 0x14(%ebp),%edi
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
10957a: b8 03 00 00 00 mov $0x3,%eax
10957f: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
109583: 0f 84 90 00 00 00 je 109619 <rtems_barrier_create+0xb1><== NEVER TAKEN
return RTEMS_INVALID_NAME;
if ( !id )
109589: b8 09 00 00 00 mov $0x9,%eax
10958e: 85 ff test %edi,%edi
109590: 0f 84 83 00 00 00 je 109619 <rtems_barrier_create+0xb1><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
109596: f7 c6 10 00 00 00 test $0x10,%esi
10959c: 74 12 je 1095b0 <rtems_barrier_create+0x48>
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
if ( maximum_waiters == 0 )
10959e: b8 0a 00 00 00 mov $0xa,%eax
1095a3: 85 d2 test %edx,%edx
1095a5: 74 72 je 109619 <rtems_barrier_create+0xb1>
if ( !id )
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
1095a7: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
1095ae: eb 07 jmp 1095b7 <rtems_barrier_create+0x4f>
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
1095b0: c7 45 ec 01 00 00 00 movl $0x1,-0x14(%ebp)
the_attributes.maximum_count = maximum_waiters;
1095b7: 89 55 f0 mov %edx,-0x10(%ebp)
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
1095ba: a1 cc 12 12 00 mov 0x1212cc,%eax
1095bf: 40 inc %eax
1095c0: a3 cc 12 12 00 mov %eax,0x1212cc
#ifdef __cplusplus
extern "C" {
#endif
/**
1095c5: 83 ec 0c sub $0xc,%esp
1095c8: 68 d4 11 12 00 push $0x1211d4
1095cd: e8 62 1b 00 00 call 10b134 <_Objects_Allocate>
1095d2: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
1095d4: 83 c4 10 add $0x10,%esp
1095d7: 85 c0 test %eax,%eax
1095d9: 75 0c jne 1095e7 <rtems_barrier_create+0x7f>
_Thread_Enable_dispatch();
1095db: e8 58 27 00 00 call 10bd38 <_Thread_Enable_dispatch>
1095e0: b8 05 00 00 00 mov $0x5,%eax
1095e5: eb 32 jmp 109619 <rtems_barrier_create+0xb1>
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
1095e7: 89 70 10 mov %esi,0x10(%eax)
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
1095ea: 50 push %eax
1095eb: 50 push %eax
1095ec: 8d 45 ec lea -0x14(%ebp),%eax
1095ef: 50 push %eax
1095f0: 8d 43 14 lea 0x14(%ebx),%eax
1095f3: 50 push %eax
1095f4: e8 07 13 00 00 call 10a900 <_CORE_barrier_Initialize>
1095f9: 8b 4b 08 mov 0x8(%ebx),%ecx
1095fc: 0f b7 d1 movzwl %cx,%edx
1095ff: a1 f0 11 12 00 mov 0x1211f0,%eax
109604: 89 1c 90 mov %ebx,(%eax,%edx,4)
109607: 8b 45 08 mov 0x8(%ebp),%eax
10960a: 89 43 0c mov %eax,0xc(%ebx)
&_Barrier_Information,
&the_barrier->Object,
(Objects_Name) name
);
*id = the_barrier->Object.id;
10960d: 89 0f mov %ecx,(%edi)
_Thread_Enable_dispatch();
10960f: e8 24 27 00 00 call 10bd38 <_Thread_Enable_dispatch>
109614: 31 c0 xor %eax,%eax
109616: 83 c4 10 add $0x10,%esp
return RTEMS_SUCCESSFUL;
}
109619: 8d 65 f4 lea -0xc(%ebp),%esp
10961c: 5b pop %ebx
10961d: 5e pop %esi
10961e: 5f pop %edi
10961f: c9 leave
109620: c3 ret
001096a8 <rtems_barrier_release>:
rtems_status_code rtems_barrier_release(
rtems_id id,
uint32_t *released
)
{
1096a8: 55 push %ebp
1096a9: 89 e5 mov %esp,%ebp
1096ab: 56 push %esi
1096ac: 53 push %ebx
1096ad: 83 ec 10 sub $0x10,%esp
1096b0: 8b 5d 08 mov 0x8(%ebp),%ebx
1096b3: 8b 75 0c mov 0xc(%ebp),%esi
Barrier_Control *the_barrier;
Objects_Locations location;
if ( !released )
1096b6: b8 09 00 00 00 mov $0x9,%eax
1096bb: 85 f6 test %esi,%esi
1096bd: 74 39 je 1096f8 <rtems_barrier_release+0x50><== NEVER TAKEN
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory
* to add to the heap
1096bf: 52 push %edx
1096c0: 8d 45 f4 lea -0xc(%ebp),%eax
1096c3: 50 push %eax
1096c4: 53 push %ebx
1096c5: 68 d4 11 12 00 push $0x1211d4
1096ca: e8 a9 1e 00 00 call 10b578 <_Objects_Get>
1096cf: 89 c2 mov %eax,%edx
return RTEMS_INVALID_ADDRESS;
the_barrier = _Barrier_Get( id, &location );
switch ( location ) {
1096d1: 83 c4 10 add $0x10,%esp
1096d4: b8 04 00 00 00 mov $0x4,%eax
1096d9: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
1096dd: 75 19 jne 1096f8 <rtems_barrier_release+0x50>
case OBJECTS_LOCAL:
*released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL );
1096df: 50 push %eax
1096e0: 6a 00 push $0x0
1096e2: 53 push %ebx
1096e3: 8d 42 14 lea 0x14(%edx),%eax
1096e6: 50 push %eax
1096e7: e8 48 12 00 00 call 10a934 <_CORE_barrier_Release>
1096ec: 89 06 mov %eax,(%esi)
_Thread_Enable_dispatch();
1096ee: e8 45 26 00 00 call 10bd38 <_Thread_Enable_dispatch>
1096f3: 31 c0 xor %eax,%eax
1096f5: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1096f8: 8d 65 f8 lea -0x8(%ebp),%esp
1096fb: 5b pop %ebx
1096fc: 5e pop %esi
1096fd: c9 leave
1096fe: c3 ret
00108984 <rtems_clock_get>:
rtems_status_code rtems_clock_get(
rtems_clock_get_options option,
void *time_buffer
)
{
108984: 55 push %ebp
108985: 89 e5 mov %esp,%ebp
108987: 53 push %ebx
108988: 83 ec 04 sub $0x4,%esp
10898b: 8b 55 08 mov 0x8(%ebp),%edx
10898e: 8b 5d 0c mov 0xc(%ebp),%ebx
if ( !time_buffer )
108991: b8 09 00 00 00 mov $0x9,%eax
108996: 85 db test %ebx,%ebx
108998: 74 44 je 1089de <rtems_clock_get+0x5a> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
switch ( option ) {
10899a: b8 0a 00 00 00 mov $0xa,%eax
10899f: 83 fa 04 cmp $0x4,%edx
1089a2: 77 3a ja 1089de <rtems_clock_get+0x5a>
1089a4: ff 24 95 58 72 11 00 jmp *0x117258(,%edx,4)
case RTEMS_CLOCK_GET_TOD:
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
1089ab: 89 5d 08 mov %ebx,0x8(%ebp)
break;
}
return RTEMS_INVALID_NUMBER;
}
1089ae: 58 pop %eax
1089af: 5b pop %ebx
1089b0: c9 leave
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
switch ( option ) {
case RTEMS_CLOCK_GET_TOD:
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
1089b1: e9 76 00 00 00 jmp 108a2c <rtems_clock_get_tod>
case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH:
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
1089b6: 89 5d 08 mov %ebx,0x8(%ebp)
break;
}
return RTEMS_INVALID_NUMBER;
}
1089b9: 5b pop %ebx
1089ba: 5b pop %ebx
1089bb: c9 leave
switch ( option ) {
case RTEMS_CLOCK_GET_TOD:
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH:
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
1089bc: e9 23 00 00 00 jmp 1089e4 <rtems_clock_get_seconds_since_epoch>
case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_since_boot();
1089c1: e8 5a 00 00 00 call 108a20 <rtems_clock_get_ticks_since_boot>
1089c6: eb 05 jmp 1089cd <rtems_clock_get+0x49>
return RTEMS_SUCCESSFUL;
}
case RTEMS_CLOCK_GET_TICKS_PER_SECOND: {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_per_second();
1089c8: e8 3f 00 00 00 call 108a0c <rtems_clock_get_ticks_per_second>
1089cd: 89 03 mov %eax,(%ebx)
1089cf: 31 c0 xor %eax,%eax
1089d1: eb 0b jmp 1089de <rtems_clock_get+0x5a>
return RTEMS_SUCCESSFUL;
}
case RTEMS_CLOCK_GET_TIME_VALUE:
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
1089d3: 89 5d 08 mov %ebx,0x8(%ebp)
break;
}
return RTEMS_INVALID_NUMBER;
}
1089d6: 59 pop %ecx
1089d7: 5b pop %ebx
1089d8: c9 leave
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
case RTEMS_CLOCK_GET_TIME_VALUE:
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
1089d9: e9 ea 00 00 00 jmp 108ac8 <rtems_clock_get_tod_timeval>
break;
}
return RTEMS_INVALID_NUMBER;
}
1089de: 5a pop %edx
1089df: 5b pop %ebx
1089e0: c9 leave
1089e1: c3 ret
001089e4 <rtems_clock_get_seconds_since_epoch>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
1089e4: 55 push %ebp
1089e5: 89 e5 mov %esp,%ebp
1089e7: 8b 55 08 mov 0x8(%ebp),%edx
if ( !the_interval )
1089ea: b8 09 00 00 00 mov $0x9,%eax
1089ef: 85 d2 test %edx,%edx
1089f1: 74 17 je 108a0a <rtems_clock_get_seconds_since_epoch+0x26><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
1089f3: b8 0b 00 00 00 mov $0xb,%eax
1089f8: 80 3d ac d7 11 00 00 cmpb $0x0,0x11d7ac
1089ff: 74 09 je 108a0a <rtems_clock_get_seconds_since_epoch+0x26>
return RTEMS_NOT_DEFINED;
*the_interval = _TOD_Seconds_since_epoch;
108a01: a1 28 d8 11 00 mov 0x11d828,%eax
108a06: 89 02 mov %eax,(%edx)
108a08: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
108a0a: c9 leave
108a0b: c3 ret
00108a2c <rtems_clock_get_tod>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod(
rtems_time_of_day *time_buffer
)
{
108a2c: 55 push %ebp
108a2d: 89 e5 mov %esp,%ebp
108a2f: 56 push %esi
108a30: 53 push %ebx
108a31: 83 ec 50 sub $0x50,%esp
108a34: 8b 75 08 mov 0x8(%ebp),%esi
rtems_time_of_day *tmbuf = time_buffer;
struct tm time;
struct timeval now;
if ( !time_buffer )
108a37: b8 09 00 00 00 mov $0x9,%eax
108a3c: 85 f6 test %esi,%esi
108a3e: 74 7f je 108abf <rtems_clock_get_tod+0x93><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
108a40: b8 0b 00 00 00 mov $0xb,%eax
108a45: 80 3d ac d7 11 00 00 cmpb $0x0,0x11d7ac
108a4c: 74 71 je 108abf <rtems_clock_get_tod+0x93>
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
108a4e: 9c pushf
108a4f: fa cli
108a50: 5b pop %ebx
* This routine grows @a the_heap memory area using the size bytes which
108a51: 83 ec 0c sub $0xc,%esp
108a54: 8d 45 e8 lea -0x18(%ebp),%eax
108a57: 50 push %eax
108a58: e8 df 14 00 00 call 109f3c <_TOD_Get>
* begin at @a starting_address.
108a5d: 53 push %ebx
108a5e: 9d popf
*
* @param[in] the_heap is the heap to operate upon
108a5f: 8b 45 e8 mov -0x18(%ebp),%eax
108a62: 89 45 f0 mov %eax,-0x10(%ebp)
* @param[in] starting_address is the starting address of the memory
108a65: 8b 45 ec mov -0x14(%ebp),%eax
108a68: b9 e8 03 00 00 mov $0x3e8,%ecx
108a6d: 31 d2 xor %edx,%edx
108a6f: f7 f1 div %ecx
108a71: 89 45 f4 mov %eax,-0xc(%ebp)
/* Obtain the current time */
_TOD_Get_timeval( &now );
/* Split it into a closer format */
gmtime_r( &now.tv_sec, &time );
108a74: 58 pop %eax
108a75: 5a pop %edx
108a76: 8d 45 c4 lea -0x3c(%ebp),%eax
108a79: 50 push %eax
108a7a: 8d 45 f0 lea -0x10(%ebp),%eax
108a7d: 50 push %eax
108a7e: e8 ed 6d 00 00 call 10f870 <gmtime_r>
/* Now adjust it to the RTEMS format */
tmbuf->year = time.tm_year + 1900;
108a83: 8b 45 d8 mov -0x28(%ebp),%eax
108a86: 05 6c 07 00 00 add $0x76c,%eax
108a8b: 89 06 mov %eax,(%esi)
tmbuf->month = time.tm_mon + 1;
108a8d: 8b 45 d4 mov -0x2c(%ebp),%eax
108a90: 40 inc %eax
108a91: 89 46 04 mov %eax,0x4(%esi)
tmbuf->day = time.tm_mday;
108a94: 8b 45 d0 mov -0x30(%ebp),%eax
108a97: 89 46 08 mov %eax,0x8(%esi)
tmbuf->hour = time.tm_hour;
108a9a: 8b 45 cc mov -0x34(%ebp),%eax
108a9d: 89 46 0c mov %eax,0xc(%esi)
tmbuf->minute = time.tm_min;
108aa0: 8b 45 c8 mov -0x38(%ebp),%eax
108aa3: 89 46 10 mov %eax,0x10(%esi)
tmbuf->second = time.tm_sec;
108aa6: 8b 45 c4 mov -0x3c(%ebp),%eax
108aa9: 89 46 14 mov %eax,0x14(%esi)
tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick;
108aac: 8b 45 f4 mov -0xc(%ebp),%eax
108aaf: 31 d2 xor %edx,%edx
108ab1: f7 35 34 d9 11 00 divl 0x11d934
108ab7: 89 46 18 mov %eax,0x18(%esi)
108aba: 31 c0 xor %eax,%eax
108abc: 83 c4 10 add $0x10,%esp
return RTEMS_SUCCESSFUL;
}
108abf: 8d 65 f8 lea -0x8(%ebp),%esp
108ac2: 5b pop %ebx
108ac3: 5e pop %esi
108ac4: c9 leave
108ac5: c3 ret
00108ac8 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
108ac8: 55 push %ebp
108ac9: 89 e5 mov %esp,%ebp
108acb: 56 push %esi
108acc: 53 push %ebx
108acd: 83 ec 20 sub $0x20,%esp
108ad0: 8b 75 08 mov 0x8(%ebp),%esi
if ( !time )
108ad3: b8 09 00 00 00 mov $0x9,%eax
108ad8: 85 f6 test %esi,%esi
108ada: 74 38 je 108b14 <rtems_clock_get_tod_timeval+0x4c><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
108adc: b8 0b 00 00 00 mov $0xb,%eax
108ae1: 80 3d ac d7 11 00 00 cmpb $0x0,0x11d7ac
108ae8: 74 2a je 108b14 <rtems_clock_get_tod_timeval+0x4c>
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
108aea: 9c pushf
108aeb: fa cli
108aec: 5b pop %ebx
* This routine grows @a the_heap memory area using the size bytes which
108aed: 83 ec 0c sub $0xc,%esp
108af0: 8d 45 f0 lea -0x10(%ebp),%eax
108af3: 50 push %eax
108af4: e8 43 14 00 00 call 109f3c <_TOD_Get>
* begin at @a starting_address.
108af9: 53 push %ebx
108afa: 9d popf
*
* @param[in] the_heap is the heap to operate upon
108afb: 8b 45 f0 mov -0x10(%ebp),%eax
108afe: 89 06 mov %eax,(%esi)
* @param[in] starting_address is the starting address of the memory
108b00: 8b 45 f4 mov -0xc(%ebp),%eax
108b03: b9 e8 03 00 00 mov $0x3e8,%ecx
108b08: 31 d2 xor %edx,%edx
108b0a: f7 f1 div %ecx
108b0c: 89 46 04 mov %eax,0x4(%esi)
108b0f: 31 c0 xor %eax,%eax
108b11: 83 c4 10 add $0x10,%esp
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
}
108b14: 8d 65 f8 lea -0x8(%ebp),%esp
108b17: 5b pop %ebx
108b18: 5e pop %esi
108b19: c9 leave
108b1a: c3 ret
00108cf4 <rtems_clock_get_uptime>:
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
108cf4: 55 push %ebp
108cf5: 89 e5 mov %esp,%ebp
108cf7: 83 ec 08 sub $0x8,%esp
108cfa: 8b 55 08 mov 0x8(%ebp),%edx
if ( !uptime )
108cfd: b8 09 00 00 00 mov $0x9,%eax
108d02: 85 d2 test %edx,%edx
108d04: 74 0e je 108d14 <rtems_clock_get_uptime+0x20><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
_TOD_Get_uptime( uptime );
108d06: 83 ec 0c sub $0xc,%esp
108d09: 52 push %edx
108d0a: e8 85 15 00 00 call 10a294 <_TOD_Get_uptime>
108d0f: 31 c0 xor %eax,%eax
108d11: 83 c4 10 add $0x10,%esp
return RTEMS_SUCCESSFUL;
}
108d14: c9 leave
108d15: c3 ret
00109950 <rtems_clock_set>:
*/
rtems_status_code rtems_clock_set(
rtems_time_of_day *time_buffer
)
{
109950: 55 push %ebp
109951: 89 e5 mov %esp,%ebp
109953: 53 push %ebx
109954: 83 ec 14 sub $0x14,%esp
109957: 8b 5d 08 mov 0x8(%ebp),%ebx
struct timespec newtime;
if ( !time_buffer )
10995a: ba 09 00 00 00 mov $0x9,%edx
10995f: 85 db test %ebx,%ebx
109961: 74 54 je 1099b7 <rtems_clock_set+0x67> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( time_buffer ) ) {
109963: 83 ec 0c sub $0xc,%esp
109966: 53 push %ebx
109967: e8 f8 00 00 00 call 109a64 <_TOD_Validate>
10996c: 83 c4 10 add $0x10,%esp
10996f: ba 14 00 00 00 mov $0x14,%edx
109974: 84 c0 test %al,%al
109976: 74 3f je 1099b7 <rtems_clock_set+0x67>
newtime.tv_sec = _TOD_To_seconds( time_buffer );
109978: 83 ec 0c sub $0xc,%esp
10997b: 53 push %ebx
10997c: e8 7b 00 00 00 call 1099fc <_TOD_To_seconds>
109981: 89 45 f4 mov %eax,-0xc(%ebp)
newtime.tv_nsec = time_buffer->ticks *
109984: 8b 43 18 mov 0x18(%ebx),%eax
109987: 0f af 05 30 94 12 00 imul 0x129430,%eax
10998e: 69 c0 e8 03 00 00 imul $0x3e8,%eax,%eax
109994: 89 45 f8 mov %eax,-0x8(%ebp)
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
109997: a1 94 92 12 00 mov 0x129294,%eax
10999c: 40 inc %eax
10999d: a3 94 92 12 00 mov %eax,0x129294
(_TOD_Microseconds_per_tick * TOD_NANOSECONDS_PER_MICROSECOND);
_Thread_Disable_dispatch();
_TOD_Set( &newtime );
1099a2: 8d 45 f4 lea -0xc(%ebp),%eax
1099a5: 89 04 24 mov %eax,(%esp)
1099a8: e8 13 18 00 00 call 10b1c0 <_TOD_Set>
_Thread_Enable_dispatch();
1099ad: e8 5a 28 00 00 call 10c20c <_Thread_Enable_dispatch>
1099b2: 31 d2 xor %edx,%edx
1099b4: 83 c4 10 add $0x10,%esp
return RTEMS_SUCCESSFUL;
}
return RTEMS_INVALID_CLOCK;
}
1099b7: 89 d0 mov %edx,%eax
1099b9: 8b 5d fc mov -0x4(%ebp),%ebx
1099bc: c9 leave
1099bd: c3 ret
00108b1c <rtems_clock_set_nanoseconds_extension>:
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_set_nanoseconds_extension(
rtems_nanoseconds_extension_routine routine
)
{
108b1c: 55 push %ebp
108b1d: 89 e5 mov %esp,%ebp
108b1f: 8b 55 08 mov 0x8(%ebp),%edx
if ( !routine )
108b22: b8 09 00 00 00 mov $0x9,%eax
108b27: 85 d2 test %edx,%edx
108b29: 74 08 je 108b33 <rtems_clock_set_nanoseconds_extension+0x17><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
_Watchdog_Nanoseconds_since_tick_handler = routine;
108b2b: 89 15 3c d9 11 00 mov %edx,0x11d93c
108b31: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
108b33: c9 leave
108b34: c3 ret
00106b88 <rtems_cpu_usage_report_with_plugin>:
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
106b88: 55 push %ebp
106b89: 89 e5 mov %esp,%ebp
106b8b: 57 push %edi
106b8c: 56 push %esi
106b8d: 53 push %ebx
106b8e: 83 ec 4c sub $0x4c,%esp
struct timespec uptime, total, ran;
#else
uint32_t total_units = 0;
#endif
if ( !print )
106b91: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
106b95: 0f 84 43 01 00 00 je 106cde <rtems_cpu_usage_report_with_plugin+0x156><== 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.
*/
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
_TOD_Get_uptime( &uptime );
106b9b: 83 ec 0c sub $0xc,%esp
106b9e: 8d 5d e4 lea -0x1c(%ebp),%ebx
106ba1: 53 push %ebx
106ba2: e8 89 45 00 00 call 10b130 <_TOD_Get_uptime>
_Timespec_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total );
106ba7: 83 c4 0c add $0xc,%esp
106baa: 8d 45 dc lea -0x24(%ebp),%eax
106bad: 50 push %eax
106bae: 53 push %ebx
106baf: 68 2c 98 12 00 push $0x12982c
106bb4: e8 07 64 00 00 call 10cfc0 <_Timespec_Subtract>
}
}
}
#endif
(*print)( context, "CPU Usage by thread\n"
106bb9: 58 pop %eax
106bba: 5a pop %edx
106bbb: 68 2a a1 11 00 push $0x11a12a
106bc0: ff 75 08 pushl 0x8(%ebp)
106bc3: ff 55 0c call *0xc(%ebp)
106bc6: bf 01 00 00 00 mov $0x1,%edi
106bcb: 83 c4 10 add $0x10,%esp
);
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
106bce: 8b 04 bd 68 92 12 00 mov 0x129268(,%edi,4),%eax
106bd5: 85 c0 test %eax,%eax
106bd7: 0f 84 d9 00 00 00 je 106cb6 <rtems_cpu_usage_report_with_plugin+0x12e>
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
106bdd: 8b 40 04 mov 0x4(%eax),%eax
106be0: 89 45 b0 mov %eax,-0x50(%ebp)
if ( information ) {
106be3: be 01 00 00 00 mov $0x1,%esi
106be8: 85 c0 test %eax,%eax
106bea: 0f 85 b7 00 00 00 jne 106ca7 <rtems_cpu_usage_report_with_plugin+0x11f><== ALWAYS TAKEN
106bf0: e9 c1 00 00 00 jmp 106cb6 <rtems_cpu_usage_report_with_plugin+0x12e><== NOT EXECUTED
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
106bf5: 8b 55 b0 mov -0x50(%ebp),%edx
106bf8: 8b 42 1c mov 0x1c(%edx),%eax
106bfb: 8b 1c b0 mov (%eax,%esi,4),%ebx
if ( !the_thread )
106bfe: 85 db test %ebx,%ebx
106c00: 0f 84 a0 00 00 00 je 106ca6 <rtems_cpu_usage_report_with_plugin+0x11e><== NEVER TAKEN
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
106c06: 50 push %eax
106c07: 8d 45 bf lea -0x41(%ebp),%eax
106c0a: 50 push %eax
106c0b: 6a 0d push $0xd
106c0d: ff 73 08 pushl 0x8(%ebx)
106c10: e8 8f 32 00 00 call 109ea4 <rtems_object_get_name>
(*print)(
106c15: 8d 55 bf lea -0x41(%ebp),%edx
106c18: 52 push %edx
106c19: ff 73 08 pushl 0x8(%ebx)
106c1c: 68 6f a1 11 00 push $0x11a16f
106c21: ff 75 08 pushl 0x8(%ebp)
106c24: ff 55 0c call *0xc(%ebp)
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
106c27: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx
106c2d: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax
106c33: 89 45 d8 mov %eax,-0x28(%ebp)
106c36: 89 55 d4 mov %edx,-0x2c(%ebp)
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
106c39: 83 c4 20 add $0x20,%esp
106c3c: a1 54 93 12 00 mov 0x129354,%eax
106c41: 8b 40 08 mov 0x8(%eax),%eax
106c44: 3b 43 08 cmp 0x8(%ebx),%eax
106c47: 75 22 jne 106c6b <rtems_cpu_usage_report_with_plugin+0xe3>
struct timespec used;
_Timespec_Subtract(
106c49: 50 push %eax
106c4a: 8d 5d cc lea -0x34(%ebp),%ebx
106c4d: 53 push %ebx
106c4e: 8d 45 e4 lea -0x1c(%ebp),%eax
106c51: 50 push %eax
106c52: 68 5c 93 12 00 push $0x12935c
106c57: e8 64 63 00 00 call 10cfc0 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch, &uptime, &used
);
_Timespec_Add_to( &ran, &used );
106c5c: 59 pop %ecx
106c5d: 58 pop %eax
106c5e: 53 push %ebx
106c5f: 8d 45 d4 lea -0x2c(%ebp),%eax
106c62: 50 push %eax
106c63: e8 6c 62 00 00 call 10ced4 <_Timespec_Add_to>
106c68: 83 c4 10 add $0x10,%esp
};
_Timespec_Divide( &ran, &total, &ival, &fval );
106c6b: 8d 45 ec lea -0x14(%ebp),%eax
106c6e: 50 push %eax
106c6f: 8d 45 f0 lea -0x10(%ebp),%eax
106c72: 50 push %eax
106c73: 8d 45 dc lea -0x24(%ebp),%eax
106c76: 50 push %eax
106c77: 8d 45 d4 lea -0x2c(%ebp),%eax
106c7a: 50 push %eax
106c7b: e8 84 62 00 00 call 10cf04 <_Timespec_Divide>
/*
* Print the information
*/
(*print)( context,
106c80: 58 pop %eax
106c81: 5a pop %edx
106c82: ff 75 ec pushl -0x14(%ebp)
106c85: ff 75 f0 pushl -0x10(%ebp)
106c88: 8b 45 d8 mov -0x28(%ebp),%eax
106c8b: b9 e8 03 00 00 mov $0x3e8,%ecx
106c90: 31 d2 xor %edx,%edx
106c92: f7 f1 div %ecx
106c94: 50 push %eax
106c95: ff 75 d4 pushl -0x2c(%ebp)
106c98: 68 82 a1 11 00 push $0x11a182
106c9d: ff 75 08 pushl 0x8(%ebp)
106ca0: ff 55 0c call *0xc(%ebp)
106ca3: 83 c4 20 add $0x20,%esp
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
106ca6: 46 inc %esi
106ca7: 8b 55 b0 mov -0x50(%ebp),%edx
106caa: 0f b7 42 10 movzwl 0x10(%edx),%eax
106cae: 39 c6 cmp %eax,%esi
106cb0: 0f 86 3f ff ff ff jbe 106bf5 <rtems_cpu_usage_report_with_plugin+0x6d>
#endif
);
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
api_index++ ) {
106cb6: 47 inc %edi
" ID NAME TICKS PERCENT\n"
#endif
);
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
106cb7: 83 ff 05 cmp $0x5,%edi
106cba: 0f 85 0e ff ff ff jne 106bce <rtems_cpu_usage_report_with_plugin+0x46>
}
}
}
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
(*print)( context, "Time since last CPU Usage reset %" PRId32
106cc0: 8b 45 e0 mov -0x20(%ebp),%eax
106cc3: b9 e8 03 00 00 mov $0x3e8,%ecx
106cc8: 31 d2 xor %edx,%edx
106cca: f7 f1 div %ecx
106ccc: 50 push %eax
106ccd: ff 75 dc pushl -0x24(%ebp)
106cd0: 68 9a a1 11 00 push $0x11a19a
106cd5: ff 75 08 pushl 0x8(%ebp)
106cd8: ff 55 0c call *0xc(%ebp)
106cdb: 83 c4 10 add $0x10,%esp
"Ticks since last reset = %" PRId32 "\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset
);
(*print)( context, "Total Units = %" PRId32 "\n", total_units );
#endif
}
106cde: 8d 65 f4 lea -0xc(%ebp),%esp
106ce1: 5b pop %ebx
106ce2: 5e pop %esi
106ce3: 5f pop %edi
106ce4: c9 leave
106ce5: c3 ret
0010e5eb <rtems_deviceio_errno>:
{ 0, 0, 0 },
};
static int
rtems_deviceio_errno(rtems_status_code code)
{
10e5eb: 55 push %ebp <== NOT EXECUTED
10e5ec: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10e5ee: 53 push %ebx <== NOT EXECUTED
10e5ef: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
int rc;
if ((rc = rtems_assoc_remote_by_local(errno_assoc, (uint32_t) code)))
10e5f2: 50 push %eax <== NOT EXECUTED
10e5f3: 68 dc 79 11 00 push $0x1179dc <== NOT EXECUTED
10e5f8: e8 bb 03 00 00 call 10e9b8 <rtems_assoc_remote_by_local><== NOT EXECUTED
10e5fd: 89 c3 mov %eax,%ebx <== NOT EXECUTED
10e5ff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10e602: 85 c0 test %eax,%eax <== NOT EXECUTED
10e604: 74 07 je 10e60d <rtems_deviceio_errno+0x22><== NOT EXECUTED
{
errno = rc;
10e606: e8 1d 0b 00 00 call 10f128 <__errno> <== NOT EXECUTED
10e60b: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
return -1;
}
return -1;
}
10e60d: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10e610: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10e613: c9 leave <== NOT EXECUTED
10e614: c3 ret <== NOT EXECUTED
00107040 <rtems_error>:
int rtems_error(
int error_flag,
const char *printf_format,
...
)
{
107040: 55 push %ebp <== NOT EXECUTED
107041: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107043: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
107046: 8d 4d 10 lea 0x10(%ebp),%ecx <== NOT EXECUTED
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
chars_written = rtems_verror(error_flag, printf_format, arglist);
107049: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
10704c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10704f: e8 6d fe ff ff call 106ec1 <rtems_verror> <== NOT EXECUTED
va_end(arglist);
return chars_written;
}
107054: c9 leave <== NOT EXECUTED
107055: c3 ret <== NOT EXECUTED
00108b74 <rtems_event_receive>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
108b74: 55 push %ebp
108b75: 89 e5 mov %esp,%ebp
108b77: 83 ec 08 sub $0x8,%esp
108b7a: 8b 4d 08 mov 0x8(%ebp),%ecx
108b7d: 8b 55 14 mov 0x14(%ebp),%edx
RTEMS_API_Control *api;
if ( !event_out )
108b80: b8 09 00 00 00 mov $0x9,%eax
108b85: 85 d2 test %edx,%edx
108b87: 74 3f je 108bc8 <rtems_event_receive+0x54><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
108b89: a1 58 d8 11 00 mov 0x11d858,%eax
108b8e: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
if ( _Event_sets_Is_empty( event_in ) ) {
108b94: 85 c9 test %ecx,%ecx
108b96: 75 08 jne 108ba0 <rtems_event_receive+0x2c>
*event_out = api->pending_events;
108b98: 8b 00 mov (%eax),%eax
108b9a: 89 02 mov %eax,(%edx)
108b9c: 31 c0 xor %eax,%eax
108b9e: eb 28 jmp 108bc8 <rtems_event_receive+0x54>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
108ba0: a1 98 d7 11 00 mov 0x11d798,%eax
108ba5: 40 inc %eax
108ba6: a3 98 d7 11 00 mov %eax,0x11d798
return RTEMS_SUCCESSFUL;
}
_Thread_Disable_dispatch();
_Event_Seize( event_in, option_set, ticks, event_out );
108bab: 52 push %edx
108bac: ff 75 10 pushl 0x10(%ebp)
108baf: ff 75 0c pushl 0xc(%ebp)
108bb2: 51 push %ecx
108bb3: e8 14 00 00 00 call 108bcc <_Event_Seize>
_Thread_Enable_dispatch();
108bb8: e8 cf 22 00 00 call 10ae8c <_Thread_Enable_dispatch>
return( _Thread_Executing->Wait.return_code );
108bbd: a1 58 d8 11 00 mov 0x11d858,%eax
108bc2: 8b 40 34 mov 0x34(%eax),%eax
108bc5: 83 c4 10 add $0x10,%esp
}
108bc8: c9 leave
108bc9: c3 ret
001062e0 <rtems_filesystem_evaluate_parent>:
int rtems_filesystem_evaluate_parent(
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
1062e0: 55 push %ebp
1062e1: 89 e5 mov %esp,%ebp
1062e3: 57 push %edi
1062e4: 56 push %esi
1062e5: 83 ec 10 sub $0x10,%esp
1062e8: 8b 75 0c mov 0xc(%ebp),%esi
rtems_filesystem_location_info_t parent;
int result;
if ( !pathloc )
1062eb: 85 f6 test %esi,%esi
1062ed: 75 0d jne 1062fc <rtems_filesystem_evaluate_parent+0x1c><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
1062ef: e8 34 8e 00 00 call 10f128 <__errno> <== NOT EXECUTED
1062f4: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
1062fa: eb 13 jmp 10630f <rtems_filesystem_evaluate_parent+0x2f><== NOT EXECUTED
if ( !pathloc->ops->evalpath_h )
1062fc: 8b 46 08 mov 0x8(%esi),%eax
1062ff: 83 38 00 cmpl $0x0,(%eax)
106302: 75 10 jne 106314 <rtems_filesystem_evaluate_parent+0x34><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
106304: e8 1f 8e 00 00 call 10f128 <__errno> <== NOT EXECUTED
106309: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10630f: 83 cf ff or $0xffffffff,%edi <== NOT EXECUTED
106312: eb 39 jmp 10634d <rtems_filesystem_evaluate_parent+0x6d><== NOT EXECUTED
parent = *pathloc;
106314: 8d 7d e8 lea -0x18(%ebp),%edi
106317: b9 04 00 00 00 mov $0x4,%ecx
10631c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
result = (*pathloc->ops->evalpath_h)( "..", flags, &parent );
10631e: 52 push %edx
10631f: 8d 75 e8 lea -0x18(%ebp),%esi
106322: 56 push %esi
106323: ff 75 08 pushl 0x8(%ebp)
106326: 68 f9 71 11 00 push $0x1171f9
10632b: ff 10 call *(%eax)
10632d: 89 c7 mov %eax,%edi
if (result != 0){
10632f: 83 c4 10 add $0x10,%esp
106332: 85 c0 test %eax,%eax
106334: 75 d9 jne 10630f <rtems_filesystem_evaluate_parent+0x2f><== NEVER TAKEN
return -1;
}
rtems_filesystem_freenode( &parent );
106336: 8b 45 f0 mov -0x10(%ebp),%eax
106339: 85 c0 test %eax,%eax
10633b: 74 10 je 10634d <rtems_filesystem_evaluate_parent+0x6d><== NEVER TAKEN
10633d: 8b 40 1c mov 0x1c(%eax),%eax
106340: 85 c0 test %eax,%eax
106342: 74 09 je 10634d <rtems_filesystem_evaluate_parent+0x6d><== NEVER TAKEN
106344: 83 ec 0c sub $0xc,%esp
106347: 56 push %esi
106348: ff d0 call *%eax
10634a: 83 c4 10 add $0x10,%esp
return result;
}
10634d: 89 f8 mov %edi,%eax
10634f: 8d 65 f8 lea -0x8(%ebp),%esp
106352: 5e pop %esi
106353: 5f pop %edi
106354: c9 leave
106355: c3 ret
00106356 <rtems_filesystem_evaluate_path>:
const char *pathname,
int flags,
rtems_filesystem_location_info_t *pathloc,
int follow_link
)
{
106356: 55 push %ebp
106357: 89 e5 mov %esp,%ebp
106359: 57 push %edi
10635a: 56 push %esi
10635b: 53 push %ebx
10635c: 83 ec 1c sub $0x1c,%esp
10635f: 8b 5d 08 mov 0x8(%ebp),%ebx
106362: 8b 45 0c mov 0xc(%ebp),%eax
106365: 89 45 f0 mov %eax,-0x10(%ebp)
106368: 8b 55 10 mov 0x10(%ebp),%edx
10636b: 89 55 e0 mov %edx,-0x20(%ebp)
10636e: 8b 7d 14 mov 0x14(%ebp),%edi
106371: 89 7d ec mov %edi,-0x14(%ebp)
/*
* Verify Input parameters.
*/
if ( !pathname )
106374: 85 db test %ebx,%ebx
106376: 75 0d jne 106385 <rtems_filesystem_evaluate_path+0x2f>
rtems_set_errno_and_return_minus_one( EFAULT );
106378: e8 ab 8d 00 00 call 10f128 <__errno>
10637d: c7 00 0e 00 00 00 movl $0xe,(%eax)
106383: eb 11 jmp 106396 <rtems_filesystem_evaluate_path+0x40>
if ( !pathloc )
106385: 83 7d e0 00 cmpl $0x0,-0x20(%ebp)
106389: 75 13 jne 10639e <rtems_filesystem_evaluate_path+0x48><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
10638b: e8 98 8d 00 00 call 10f128 <__errno> <== NOT EXECUTED
106390: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
106396: 83 ce ff or $0xffffffff,%esi
106399: e9 cd 00 00 00 jmp 10646b <rtems_filesystem_evaluate_path+0x115>
/*
* Evaluate the path using the optable evalpath.
*/
rtems_filesystem_get_start_loc( pathname, &i, pathloc );
10639e: 8a 03 mov (%ebx),%al
1063a0: 3c 2f cmp $0x2f,%al
1063a2: 74 08 je 1063ac <rtems_filesystem_evaluate_path+0x56>
1063a4: 3c 5c cmp $0x5c,%al
1063a6: 74 04 je 1063ac <rtems_filesystem_evaluate_path+0x56><== NEVER TAKEN
1063a8: 84 c0 test %al,%al
1063aa: 75 16 jne 1063c2 <rtems_filesystem_evaluate_path+0x6c><== ALWAYS TAKEN
1063ac: a1 6c b6 11 00 mov 0x11b66c,%eax
1063b1: 8d 70 14 lea 0x14(%eax),%esi
1063b4: b9 04 00 00 00 mov $0x4,%ecx
1063b9: 8b 7d e0 mov -0x20(%ebp),%edi
1063bc: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
1063be: b1 01 mov $0x1,%cl
1063c0: eb 12 jmp 1063d4 <rtems_filesystem_evaluate_path+0x7e>
1063c2: a1 6c b6 11 00 mov 0x11b66c,%eax
1063c7: 8d 70 04 lea 0x4(%eax),%esi
1063ca: b9 04 00 00 00 mov $0x4,%ecx
1063cf: 8b 7d e0 mov -0x20(%ebp),%edi
1063d2: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !pathloc->ops->evalpath_h )
1063d4: 8b 55 e0 mov -0x20(%ebp),%edx
1063d7: 8b 42 08 mov 0x8(%edx),%eax
1063da: 8b 10 mov (%eax),%edx
1063dc: 85 d2 test %edx,%edx
1063de: 74 66 je 106446 <rtems_filesystem_evaluate_path+0xf0><== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
result = (*pathloc->ops->evalpath_h)( &pathname[i], flags, pathloc );
1063e0: 56 push %esi
1063e1: ff 75 e0 pushl -0x20(%ebp)
1063e4: ff 75 f0 pushl -0x10(%ebp)
1063e7: 8d 04 0b lea (%ebx,%ecx,1),%eax
1063ea: 50 push %eax
1063eb: ff d2 call *%edx
1063ed: 89 c6 mov %eax,%esi
/*
* Get the Node type and determine if you need to follow the link or
* not.
*/
if ( (result == 0) && follow_link ) {
1063ef: 83 c4 10 add $0x10,%esp
1063f2: 85 c0 test %eax,%eax
1063f4: 75 75 jne 10646b <rtems_filesystem_evaluate_path+0x115>
1063f6: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
1063fa: 74 6f je 10646b <rtems_filesystem_evaluate_path+0x115>
if ( !pathloc->ops->node_type_h ){
1063fc: 8b 7d e0 mov -0x20(%ebp),%edi
1063ff: 8b 47 08 mov 0x8(%edi),%eax
106402: 8b 50 10 mov 0x10(%eax),%edx
106405: 85 d2 test %edx,%edx
106407: 75 0d jne 106416 <rtems_filesystem_evaluate_path+0xc0><== ALWAYS TAKEN
rtems_filesystem_freenode( pathloc );
106409: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
10640c: 85 c0 test %eax,%eax <== NOT EXECUTED
10640e: 74 36 je 106446 <rtems_filesystem_evaluate_path+0xf0><== NOT EXECUTED
106410: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106413: 57 push %edi <== NOT EXECUTED
106414: eb 2b jmp 106441 <rtems_filesystem_evaluate_path+0xeb><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
type = (*pathloc->ops->node_type_h)( pathloc );
106416: 83 ec 0c sub $0xc,%esp
106419: ff 75 e0 pushl -0x20(%ebp)
10641c: ff d2 call *%edx
if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) ||
10641e: 83 e8 03 sub $0x3,%eax
106421: 83 c4 10 add $0x10,%esp
106424: 83 f8 01 cmp $0x1,%eax
106427: 77 42 ja 10646b <rtems_filesystem_evaluate_path+0x115>
( type == RTEMS_FILESYSTEM_SYM_LINK ) ) {
if ( !pathloc->ops->eval_link_h ){
106429: 8b 55 e0 mov -0x20(%ebp),%edx
10642c: 8b 42 08 mov 0x8(%edx),%eax
10642f: 8b 48 34 mov 0x34(%eax),%ecx
106432: 85 c9 test %ecx,%ecx
106434: 75 20 jne 106456 <rtems_filesystem_evaluate_path+0x100><== ALWAYS TAKEN
rtems_filesystem_freenode( pathloc );
106436: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
106439: 85 c0 test %eax,%eax <== NOT EXECUTED
10643b: 74 09 je 106446 <rtems_filesystem_evaluate_path+0xf0><== NOT EXECUTED
10643d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106440: 52 push %edx <== NOT EXECUTED
106441: ff d0 call *%eax <== NOT EXECUTED
106443: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
106446: e8 dd 8c 00 00 call 10f128 <__errno> <== NOT EXECUTED
10644b: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
106451: e9 40 ff ff ff jmp 106396 <rtems_filesystem_evaluate_path+0x40><== NOT EXECUTED
* pathloc will be passed up (and eventually released).
* Hence, the (valid) originial node that we submit to
* eval_link_h() should be released by the handler.
*/
result = (*pathloc->ops->eval_link_h)( pathloc, flags );
106456: 8b 7d f0 mov -0x10(%ebp),%edi
106459: 89 7d 0c mov %edi,0xc(%ebp)
10645c: 8b 45 e0 mov -0x20(%ebp),%eax
10645f: 89 45 08 mov %eax,0x8(%ebp)
}
}
return result;
}
106462: 8d 65 f4 lea -0xc(%ebp),%esp
106465: 5b pop %ebx
106466: 5e pop %esi
106467: 5f pop %edi
106468: c9 leave
* pathloc will be passed up (and eventually released).
* Hence, the (valid) originial node that we submit to
* eval_link_h() should be released by the handler.
*/
result = (*pathloc->ops->eval_link_h)( pathloc, flags );
106469: ff e1 jmp *%ecx
}
}
return result;
}
10646b: 89 f0 mov %esi,%eax
10646d: 8d 65 f4 lea -0xc(%ebp),%esp
106470: 5b pop %ebx
106471: 5e pop %esi
106472: 5f pop %edi
106473: c9 leave
106474: c3 ret
0010cbe8 <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 )
{
10cbe8: 55 push %ebp
10cbe9: 89 e5 mov %esp,%ebp
10cbeb: 57 push %edi
10cbec: 56 push %esi
10cbed: 53 push %ebx
10cbee: 83 ec 2c sub $0x2c,%esp
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
10cbf1: a1 6c b6 11 00 mov 0x11b66c,%eax
10cbf6: c7 40 24 12 00 00 00 movl $0x12,0x24(%eax)
init_fs_mount_table();
10cbfd: e8 f2 04 00 00 call 10d0f4 <init_fs_mount_table>
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
10cc02: 83 3d e8 5e 11 00 00 cmpl $0x0,0x115ee8
10cc09: 75 0a jne 10cc15 <rtems_filesystem_initialize+0x2d><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0001 );
10cc0b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10cc0e: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED
10cc13: eb 2a jmp 10cc3f <rtems_filesystem_initialize+0x57><== NOT EXECUTED
mt = &rtems_filesystem_mount_table[0];
10cc15: a1 e0 92 11 00 mov 0x1192e0,%eax
status = mount(
10cc1a: 83 ec 0c sub $0xc,%esp
10cc1d: ff 70 0c pushl 0xc(%eax)
10cc20: ff 70 08 pushl 0x8(%eax)
10cc23: ff 70 04 pushl 0x4(%eax)
10cc26: ff 30 pushl (%eax)
10cc28: 8d 45 f0 lea -0x10(%ebp),%eax
10cc2b: 50 push %eax
10cc2c: e8 e8 04 00 00 call 10d119 <mount>
&entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point );
if ( status == -1 )
10cc31: 83 c4 20 add $0x20,%esp
10cc34: 40 inc %eax
10cc35: 75 0d jne 10cc44 <rtems_filesystem_initialize+0x5c><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0002 );
10cc37: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10cc3a: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED
10cc3f: e8 50 cb ff ff call 109794 <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_filesystem_link_counts = 0;
10cc44: a1 6c b6 11 00 mov 0x11b66c,%eax
10cc49: 66 c7 40 28 00 00 movw $0x0,0x28(%eax)
* set_private_env() - but then: that's
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
rtems_filesystem_root = entry->mt_fs_root;
10cc4f: 8d 78 14 lea 0x14(%eax),%edi
10cc52: 8b 45 f0 mov -0x10(%ebp),%eax
10cc55: 8d 70 18 lea 0x18(%eax),%esi
10cc58: b9 04 00 00 00 mov $0x4,%ecx
10cc5d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
10cc5f: 6a 00 push $0x0
10cc61: 8d 5d e0 lea -0x20(%ebp),%ebx
10cc64: 53 push %ebx
10cc65: 6a 00 push $0x0
10cc67: 68 28 77 11 00 push $0x117728
10cc6c: e8 e5 96 ff ff call 106356 <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
10cc71: a1 6c b6 11 00 mov 0x11b66c,%eax
10cc76: 8d 78 14 lea 0x14(%eax),%edi
10cc79: b9 04 00 00 00 mov $0x4,%ecx
10cc7e: 89 de mov %ebx,%esi
10cc80: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
10cc82: 6a 00 push $0x0
10cc84: 53 push %ebx
10cc85: 6a 00 push $0x0
10cc87: 68 28 77 11 00 push $0x117728
10cc8c: e8 c5 96 ff ff call 106356 <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
10cc91: a1 6c b6 11 00 mov 0x11b66c,%eax
10cc96: 8d 78 04 lea 0x4(%eax),%edi
10cc99: b9 04 00 00 00 mov $0x4,%ecx
10cc9e: 89 de mov %ebx,%esi
10cca0: 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);
10cca2: 83 c4 18 add $0x18,%esp
10cca5: 68 ff 01 00 00 push $0x1ff
10ccaa: 68 2a 77 11 00 push $0x11772a
10ccaf: e8 24 04 00 00 call 10d0d8 <mkdir>
if ( status != 0 )
10ccb4: 83 c4 10 add $0x10,%esp
10ccb7: 85 c0 test %eax,%eax
10ccb9: 74 0d je 10ccc8 <rtems_filesystem_initialize+0xe0><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0003 );
10ccbb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ccbe: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED
10ccc3: e9 77 ff ff ff jmp 10cc3f <rtems_filesystem_initialize+0x57><== NOT EXECUTED
* before device drivers are initialized. So we return via a base
* filesystem image and nothing auto-mounted at this point.
*/
#endif
}
10ccc8: 8d 65 f4 lea -0xc(%ebp),%esp
10cccb: 5b pop %ebx
10cccc: 5e pop %esi
10cccd: 5f pop %edi
10ccce: c9 leave
10cccf: c3 ret
0010a420 <rtems_filesystem_nodes_equal>:
);
bool rtems_filesystem_nodes_equal(
const rtems_filesystem_location_info_t *loc1,
const rtems_filesystem_location_info_t *loc2
){
10a420: 55 push %ebp <== NOT EXECUTED
10a421: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10a423: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10a426: 8b 10 mov (%eax),%edx <== NOT EXECUTED
10a428: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10a42b: 3b 10 cmp (%eax),%edx <== NOT EXECUTED
10a42d: 0f 94 c0 sete %al <== NOT EXECUTED
return ( loc1->node_access == loc2->node_access );
}
10a430: c9 leave <== NOT EXECUTED
10a431: c3 ret <== NOT EXECUTED
001094d0 <rtems_interrupt_catch>:
rtems_status_code rtems_interrupt_catch(
rtems_isr_entry new_isr_handler,
rtems_vector_number vector,
rtems_isr_entry *old_isr_handler
)
{
1094d0: 55 push %ebp <== NOT EXECUTED
1094d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1094d3: 53 push %ebx <== NOT EXECUTED
1094d4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED
1094d7: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
1094da: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED
1094dd: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
if ( !_ISR_Is_vector_number_valid( vector ) )
1094e0: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
1094e5: 81 fb ff 00 00 00 cmp $0xff,%ebx <== NOT EXECUTED
1094eb: 77 1d ja 10950a <rtems_interrupt_catch+0x3a><== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
if ( !_ISR_Is_valid_user_handler( (void *) new_isr_handler ) )
1094ed: 85 c9 test %ecx,%ecx <== NOT EXECUTED
1094ef: 74 14 je 109505 <rtems_interrupt_catch+0x35><== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_ISR_Is_valid_user_handler( (void *) old_isr_handler ) )
1094f1: 85 d2 test %edx,%edx <== NOT EXECUTED
1094f3: 74 10 je 109505 <rtems_interrupt_catch+0x35><== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_ISR_Install_vector(
1094f5: 50 push %eax <== NOT EXECUTED
1094f6: 52 push %edx <== NOT EXECUTED
1094f7: 51 push %ecx <== NOT EXECUTED
1094f8: 53 push %ebx <== NOT EXECUTED
1094f9: e8 44 cc ff ff call 106142 <_CPU_ISR_install_vector><== NOT EXECUTED
1094fe: 31 c0 xor %eax,%eax <== NOT EXECUTED
109500: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109503: eb 05 jmp 10950a <rtems_interrupt_catch+0x3a><== NOT EXECUTED
vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler );
return RTEMS_SUCCESSFUL;
109505: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
}
10950a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10950d: c9 leave <== NOT EXECUTED
10950e: c3 ret <== NOT EXECUTED
00106188 <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
106188: 55 push %ebp <== NOT EXECUTED
106189: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10618b: 57 push %edi <== NOT EXECUTED
10618c: 56 push %esi <== NOT EXECUTED
10618d: 53 push %ebx <== NOT EXECUTED
10618e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED
106191: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED
106194: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED
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( name, 0x00, &loc, true );
106197: 6a 01 push $0x1 <== NOT EXECUTED
106199: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED
10619c: 50 push %eax <== NOT EXECUTED
10619d: 6a 00 push $0x0 <== NOT EXECUTED
10619f: 57 push %edi <== NOT EXECUTED
1061a0: e8 b1 01 00 00 call 106356 <rtems_filesystem_evaluate_path><== NOT EXECUTED
1061a5: 89 c3 mov %eax,%ebx <== NOT EXECUTED
the_jnode = loc.node_access;
1061a7: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
1061aa: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED
if ( !loc.ops->node_type_h ) {
1061ad: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
1061b0: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED
1061b3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1061b6: 85 d2 test %edx,%edx <== NOT EXECUTED
1061b8: 75 23 jne 1061dd <rtems_io_lookup_name+0x55><== NOT EXECUTED
rtems_filesystem_freenode( &loc );
1061ba: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
1061bd: 85 c0 test %eax,%eax <== NOT EXECUTED
1061bf: 74 0c je 1061cd <rtems_io_lookup_name+0x45><== NOT EXECUTED
1061c1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1061c4: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED
1061c7: 52 push %edx <== NOT EXECUTED
1061c8: ff d0 call *%eax <== NOT EXECUTED
1061ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
1061cd: e8 56 8f 00 00 call 10f128 <__errno> <== NOT EXECUTED
1061d2: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
1061d8: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
1061db: eb 78 jmp 106255 <rtems_io_lookup_name+0xcd><== NOT EXECUTED
}
node_type = (*loc.ops->node_type_h)( &loc );
1061dd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1061e0: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED
1061e3: 50 push %eax <== NOT EXECUTED
1061e4: ff d2 call *%edx <== NOT EXECUTED
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
1061e6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1061e9: 85 db test %ebx,%ebx <== NOT EXECUTED
1061eb: 75 05 jne 1061f2 <rtems_io_lookup_name+0x6a><== NOT EXECUTED
1061ed: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED
1061f0: 74 1e je 106210 <rtems_io_lookup_name+0x88><== NOT EXECUTED
rtems_filesystem_freenode( &loc );
1061f2: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
1061f5: 85 c0 test %eax,%eax <== NOT EXECUTED
1061f7: 74 53 je 10624c <rtems_io_lookup_name+0xc4><== NOT EXECUTED
1061f9: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED
1061fc: 85 d2 test %edx,%edx <== NOT EXECUTED
1061fe: 74 4c je 10624c <rtems_io_lookup_name+0xc4><== NOT EXECUTED
106200: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106203: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED
106206: 50 push %eax <== NOT EXECUTED
106207: ff d2 call *%edx <== NOT EXECUTED
106209: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED
10620e: eb 37 jmp 106247 <rtems_io_lookup_name+0xbf><== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
device_info->device_name = (char *) name;
106210: 89 3e mov %edi,(%esi) <== NOT EXECUTED
device_info->device_name_length = strlen( name );
106212: 31 c0 xor %eax,%eax <== NOT EXECUTED
106214: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED
106217: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED
106219: f7 d1 not %ecx <== NOT EXECUTED
10621b: 49 dec %ecx <== NOT EXECUTED
10621c: 89 4e 04 mov %ecx,0x4(%esi) <== NOT EXECUTED
device_info->major = the_jnode->info.device.major;
10621f: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED
106222: 8b 42 50 mov 0x50(%edx),%eax <== NOT EXECUTED
106225: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED
device_info->minor = the_jnode->info.device.minor;
106228: 8b 42 54 mov 0x54(%edx),%eax <== NOT EXECUTED
10622b: 89 46 0c mov %eax,0xc(%esi) <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
10622e: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
106231: 85 c0 test %eax,%eax <== NOT EXECUTED
106233: 74 1e je 106253 <rtems_io_lookup_name+0xcb><== NOT EXECUTED
106235: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
106238: 85 c0 test %eax,%eax <== NOT EXECUTED
10623a: 74 17 je 106253 <rtems_io_lookup_name+0xcb><== NOT EXECUTED
10623c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10623f: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED
106242: 52 push %edx <== NOT EXECUTED
106243: ff d0 call *%eax <== NOT EXECUTED
106245: 31 c0 xor %eax,%eax <== NOT EXECUTED
106247: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10624a: eb 09 jmp 106255 <rtems_io_lookup_name+0xcd><== NOT EXECUTED
10624c: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED
106251: eb 02 jmp 106255 <rtems_io_lookup_name+0xcd><== NOT EXECUTED
106253: 31 c0 xor %eax,%eax <== NOT EXECUTED
#endif
return RTEMS_SUCCESSFUL;
}
106255: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
106258: 5b pop %ebx <== NOT EXECUTED
106259: 5e pop %esi <== NOT EXECUTED
10625a: 5f pop %edi <== NOT EXECUTED
10625b: c9 leave <== NOT EXECUTED
10625c: c3 ret <== NOT EXECUTED
0010a4fc <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
)
{
10a4fc: 55 push %ebp
10a4fd: 89 e5 mov %esp,%ebp
10a4ff: 57 push %edi
10a500: 56 push %esi
10a501: 53 push %ebx
10a502: 83 ec 08 sub $0x8,%esp
10a505: 8b 5d 08 mov 0x8(%ebp),%ebx
10a508: 8b 75 0c mov 0xc(%ebp),%esi
10a50b: 8b 45 10 mov 0x10(%ebp),%eax
10a50e: 89 45 f0 mov %eax,-0x10(%ebp)
/*
* Validate the pointer data and contents passed in
*/
if ( !driver_table )
10a511: 85 f6 test %esi,%esi
10a513: 0f 84 9a 00 00 00 je 10a5b3 <rtems_io_register_driver+0xb7>
return RTEMS_INVALID_ADDRESS;
if ( !registered_major )
10a519: 85 c0 test %eax,%eax
10a51b: 0f 84 92 00 00 00 je 10a5b3 <rtems_io_register_driver+0xb7>
return RTEMS_INVALID_ADDRESS;
if ( !driver_table->initialization_entry && !driver_table->open_entry )
10a521: 83 3e 00 cmpl $0x0,(%esi)
10a524: 75 0a jne 10a530 <rtems_io_register_driver+0x34>
10a526: 83 7e 04 00 cmpl $0x0,0x4(%esi)
10a52a: 0f 84 83 00 00 00 je 10a5b3 <rtems_io_register_driver+0xb7><== ALWAYS TAKEN
return RTEMS_INVALID_ADDRESS;
*registered_major = 0;
10a530: 8b 45 f0 mov -0x10(%ebp),%eax
10a533: c7 00 00 00 00 00 movl $0x0,(%eax)
/*
* The requested major number is higher than what is configured.
*/
if ( major >= _IO_Number_of_drivers )
10a539: 8b 15 10 15 12 00 mov 0x121510,%edx
10a53f: b8 0a 00 00 00 mov $0xa,%eax
10a544: 39 d3 cmp %edx,%ebx
10a546: 73 77 jae 10a5bf <rtems_io_register_driver+0xc3>
/*
* Test for initialise/open being present to indicate the driver slot is
* in use.
*/
if ( major == 0 ) {
10a548: 85 db test %ebx,%ebx
10a54a: 75 2b jne 10a577 <rtems_io_register_driver+0x7b>
bool found = false;
for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) {
10a54c: 8d 5a ff lea -0x1(%edx),%ebx
10a54f: 6b c2 18 imul $0x18,%edx,%eax
10a552: 83 e8 18 sub $0x18,%eax
10a555: 03 05 14 15 12 00 add 0x121514,%eax
10a55b: eb 0f jmp 10a56c <rtems_io_register_driver+0x70>
if ( !_IO_Driver_address_table[major].initialization_entry &&
10a55d: 83 38 00 cmpl $0x0,(%eax)
10a560: 75 06 jne 10a568 <rtems_io_register_driver+0x6c>
10a562: 83 78 04 00 cmpl $0x0,0x4(%eax)
10a566: 74 0f je 10a577 <rtems_io_register_driver+0x7b><== ALWAYS TAKEN
* in use.
*/
if ( major == 0 ) {
bool found = false;
for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) {
10a568: 4b dec %ebx
10a569: 83 e8 18 sub $0x18,%eax
10a56c: 85 db test %ebx,%ebx
10a56e: 75 ed jne 10a55d <rtems_io_register_driver+0x61>
10a570: b8 05 00 00 00 mov $0x5,%eax
10a575: eb 48 jmp 10a5bf <rtems_io_register_driver+0xc3>
if ( !found )
return RTEMS_TOO_MANY;
}
if ( _IO_Driver_address_table[major].initialization_entry ||
10a577: 6b fb 18 imul $0x18,%ebx,%edi
10a57a: 03 3d 14 15 12 00 add 0x121514,%edi
10a580: 83 3f 00 cmpl $0x0,(%edi)
10a583: 75 35 jne 10a5ba <rtems_io_register_driver+0xbe>
10a585: 83 7f 04 00 cmpl $0x0,0x4(%edi)
10a589: 75 2f jne 10a5ba <rtems_io_register_driver+0xbe><== NEVER TAKEN
_IO_Driver_address_table[major].open_entry )
return RTEMS_RESOURCE_IN_USE;
_IO_Driver_address_table[major] = *driver_table;
10a58b: b9 06 00 00 00 mov $0x6,%ecx
10a590: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*registered_major = major;
10a592: 8b 45 f0 mov -0x10(%ebp),%eax
10a595: 89 18 mov %ebx,(%eax)
return rtems_io_initialize( major, 0, NULL );
10a597: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp)
10a59e: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp)
10a5a5: 89 5d 08 mov %ebx,0x8(%ebp)
}
10a5a8: 5b pop %ebx
10a5a9: 5e pop %esi
10a5aa: 5b pop %ebx
10a5ab: 5e pop %esi
10a5ac: 5f pop %edi
10a5ad: c9 leave
_IO_Driver_address_table[major] = *driver_table;
*registered_major = major;
return rtems_io_initialize( major, 0, NULL );
10a5ae: e9 ed fd ff ff jmp 10a3a0 <rtems_io_initialize>
10a5b3: b8 09 00 00 00 mov $0x9,%eax
10a5b8: eb 05 jmp 10a5bf <rtems_io_register_driver+0xc3>
10a5ba: b8 0c 00 00 00 mov $0xc,%eax
}
10a5bf: 5a pop %edx
10a5c0: 59 pop %ecx
10a5c1: 5b pop %ebx
10a5c2: 5e pop %esi
10a5c3: 5f pop %edi
10a5c4: c9 leave
10a5c5: c3 ret
0010a5c8 <rtems_io_unregister_driver>:
*/
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
10a5c8: 55 push %ebp
10a5c9: 89 e5 mov %esp,%ebp
10a5cb: 57 push %edi
10a5cc: 83 ec 04 sub $0x4,%esp
10a5cf: 8b 55 08 mov 0x8(%ebp),%edx
if ( major < _IO_Number_of_drivers ) {
10a5d2: b8 0d 00 00 00 mov $0xd,%eax
10a5d7: 3b 15 10 15 12 00 cmp 0x121510,%edx
10a5dd: 73 12 jae 10a5f1 <rtems_io_unregister_driver+0x29><== NEVER TAKEN
memset(
10a5df: 6b fa 18 imul $0x18,%edx,%edi
10a5e2: 03 3d 14 15 12 00 add 0x121514,%edi
10a5e8: b9 06 00 00 00 mov $0x6,%ecx
10a5ed: 31 c0 xor %eax,%eax
10a5ef: f3 ab rep stos %eax,%es:(%edi)
sizeof( rtems_driver_address_table )
);
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
}
10a5f1: 5a pop %edx
10a5f2: 5f pop %edi
10a5f3: c9 leave
10a5f4: c3 ret
0010b4d8 <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)
{
10b4d8: 55 push %ebp
10b4d9: 89 e5 mov %esp,%ebp
10b4db: 57 push %edi
10b4dc: 56 push %esi
10b4dd: 53 push %ebx
10b4de: 83 ec 0c sub $0xc,%esp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
10b4e1: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
10b4e5: 74 41 je 10b528 <rtems_iterate_over_all_threads+0x50><== NEVER TAKEN
return;
10b4e7: bf 01 00 00 00 mov $0x1,%edi
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
10b4ec: 8b 04 bd 68 92 12 00 mov 0x129268(,%edi,4),%eax
10b4f3: 85 c0 test %eax,%eax
10b4f5: 74 2b je 10b522 <rtems_iterate_over_all_threads+0x4a>
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
10b4f7: 8b 70 04 mov 0x4(%eax),%esi
if ( information ) {
10b4fa: bb 01 00 00 00 mov $0x1,%ebx
10b4ff: 85 f6 test %esi,%esi
10b501: 75 17 jne 10b51a <rtems_iterate_over_all_threads+0x42><== ALWAYS TAKEN
10b503: eb 1d jmp 10b522 <rtems_iterate_over_all_threads+0x4a><== NOT EXECUTED
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
10b505: 8b 46 1c mov 0x1c(%esi),%eax
10b508: 8b 04 98 mov (%eax,%ebx,4),%eax
if ( !the_thread )
10b50b: 85 c0 test %eax,%eax
10b50d: 74 0a je 10b519 <rtems_iterate_over_all_threads+0x41><== NEVER TAKEN
continue;
(*routine)(the_thread);
10b50f: 83 ec 0c sub $0xc,%esp
10b512: 50 push %eax
10b513: ff 55 08 call *0x8(%ebp)
10b516: 83 c4 10 add $0x10,%esp
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
10b519: 43 inc %ebx
10b51a: 0f b7 46 10 movzwl 0x10(%esi),%eax
10b51e: 39 c3 cmp %eax,%ebx
10b520: 76 e3 jbe 10b505 <rtems_iterate_over_all_threads+0x2d>
if ( !routine )
return;
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
api_index++ ) {
10b522: 47 inc %edi
if ( !routine )
return;
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
10b523: 83 ff 05 cmp $0x5,%edi
10b526: 75 c4 jne 10b4ec <rtems_iterate_over_all_threads+0x14>
(*routine)(the_thread);
}
}
}
}
10b528: 8d 65 f4 lea -0xc(%ebp),%esp
10b52b: 5b pop %ebx
10b52c: 5e pop %esi
10b52d: 5f pop %edi
10b52e: c9 leave
10b52f: c3 ret
0010d011 <rtems_libio_allocate>:
* This routine searches the IOP Table for an unused entry. If it
* finds one, it returns it. Otherwise, it returns NULL.
*/
rtems_libio_t *rtems_libio_allocate( void )
{
10d011: 55 push %ebp
10d012: 89 e5 mov %esp,%ebp
10d014: 57 push %edi
10d015: 53 push %ebx
10d016: 83 ec 24 sub $0x24,%esp
rtems_libio_t *iop, *next;
rtems_status_code rc;
rtems_id sema;
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
10d019: 6a 00 push $0x0
10d01b: 6a 00 push $0x0
10d01d: ff 35 40 d6 11 00 pushl 0x11d640
10d023: e8 4c c1 ff ff call 109174 <rtems_semaphore_obtain>
if (rtems_libio_iop_freelist) {
10d028: 8b 15 3c d6 11 00 mov 0x11d63c,%edx
10d02e: 83 c4 10 add $0x10,%esp
10d031: 85 d2 test %edx,%edx
10d033: 74 55 je 10d08a <rtems_libio_allocate+0x79>
rc = rtems_semaphore_create(
10d035: 83 ec 0c sub $0xc,%esp
10d038: 8d 45 f4 lea -0xc(%ebp),%eax
10d03b: 50 push %eax
10d03c: 6a 00 push $0x0
10d03e: 6a 54 push $0x54
10d040: 6a 01 push $0x1
10d042: 2b 15 38 d6 11 00 sub 0x11d638,%edx
10d048: c1 fa 02 sar $0x2,%edx
10d04b: 69 c2 c5 4e ec c4 imul $0xc4ec4ec5,%edx,%eax
10d051: 0d 00 49 42 4c or $0x4c424900,%eax
10d056: 50 push %eax
10d057: e8 e4 be ff ff call 108f40 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&sema
);
if (rc != RTEMS_SUCCESSFUL)
10d05c: 83 c4 20 add $0x20,%esp
10d05f: 85 c0 test %eax,%eax
10d061: 75 27 jne 10d08a <rtems_libio_allocate+0x79><== NEVER TAKEN
goto failed;
iop = rtems_libio_iop_freelist;
10d063: 8b 1d 3c d6 11 00 mov 0x11d63c,%ebx
next = iop->data1;
10d069: 8b 53 28 mov 0x28(%ebx),%edx
(void) memset( iop, 0, sizeof(rtems_libio_t) );
10d06c: b9 0d 00 00 00 mov $0xd,%ecx
10d071: 89 df mov %ebx,%edi
10d073: f3 ab rep stos %eax,%es:(%edi)
iop->flags = LIBIO_FLAGS_OPEN;
10d075: c7 43 0c 00 01 00 00 movl $0x100,0xc(%ebx)
iop->sem = sema;
10d07c: 8b 45 f4 mov -0xc(%ebp),%eax
10d07f: 89 43 20 mov %eax,0x20(%ebx)
rtems_libio_iop_freelist = next;
10d082: 89 15 3c d6 11 00 mov %edx,0x11d63c
10d088: eb 02 jmp 10d08c <rtems_libio_allocate+0x7b>
}
failed:
iop = 0;
done:
10d08a: 31 db xor %ebx,%ebx
rtems_semaphore_release( rtems_libio_semaphore );
10d08c: 83 ec 0c sub $0xc,%esp
10d08f: ff 35 40 d6 11 00 pushl 0x11d640
10d095: e8 c2 c1 ff ff call 10925c <rtems_semaphore_release>
return iop;
}
10d09a: 89 d8 mov %ebx,%eax
10d09c: 8d 65 f8 lea -0x8(%ebp),%esp
10d09f: 5b pop %ebx
10d0a0: 5f pop %edi
10d0a1: c9 leave
10d0a2: c3 ret
0010cfbc <rtems_libio_free>:
*/
void rtems_libio_free(
rtems_libio_t *iop
)
{
10cfbc: 55 push %ebp
10cfbd: 89 e5 mov %esp,%ebp
10cfbf: 53 push %ebx
10cfc0: 83 ec 08 sub $0x8,%esp
10cfc3: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
10cfc6: 6a 00 push $0x0
10cfc8: 6a 00 push $0x0
10cfca: ff 35 40 d6 11 00 pushl 0x11d640
10cfd0: e8 9f c1 ff ff call 109174 <rtems_semaphore_obtain>
if (iop->sem)
10cfd5: 8b 43 20 mov 0x20(%ebx),%eax
10cfd8: 83 c4 10 add $0x10,%esp
10cfdb: 85 c0 test %eax,%eax
10cfdd: 74 0c je 10cfeb <rtems_libio_free+0x2f> <== NEVER TAKEN
rtems_semaphore_delete(iop->sem);
10cfdf: 83 ec 0c sub $0xc,%esp
10cfe2: 50 push %eax
10cfe3: e8 fc c0 ff ff call 1090e4 <rtems_semaphore_delete>
10cfe8: 83 c4 10 add $0x10,%esp
iop->flags &= ~LIBIO_FLAGS_OPEN;
10cfeb: 81 63 0c ff fe ff ff andl $0xfffffeff,0xc(%ebx)
iop->data1 = rtems_libio_iop_freelist;
10cff2: a1 3c d6 11 00 mov 0x11d63c,%eax
10cff7: 89 43 28 mov %eax,0x28(%ebx)
rtems_libio_iop_freelist = iop;
10cffa: 89 1d 3c d6 11 00 mov %ebx,0x11d63c
rtems_semaphore_release(rtems_libio_semaphore);
10d000: a1 40 d6 11 00 mov 0x11d640,%eax
10d005: 89 45 08 mov %eax,0x8(%ebp)
}
10d008: 8b 5d fc mov -0x4(%ebp),%ebx
10d00b: c9 leave
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
rtems_semaphore_release(rtems_libio_semaphore);
10d00c: e9 4b c2 ff ff jmp 10925c <rtems_semaphore_release>
001064f0 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
1064f0: 55 push %ebp
1064f1: 89 e5 mov %esp,%ebp
1064f3: 53 push %ebx
1064f4: 83 ec 04 sub $0x4,%esp
rtems_status_code rc;
int i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
1064f7: a1 d8 92 11 00 mov 0x1192d8,%eax
1064fc: 85 c0 test %eax,%eax
1064fe: 74 46 je 106546 <rtems_libio_init+0x56>
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
106500: 52 push %edx
106501: 52 push %edx
106502: 6a 34 push $0x34
106504: 50 push %eax
106505: e8 c6 67 00 00 call 10ccd0 <calloc>
10650a: 89 c1 mov %eax,%ecx
10650c: a3 38 d6 11 00 mov %eax,0x11d638
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
106511: 83 c4 10 add $0x10,%esp
106514: 85 c0 test %eax,%eax
106516: 75 07 jne 10651f <rtems_libio_init+0x2f> <== ALWAYS TAKEN
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
106518: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10651b: 6a 1a push $0x1a <== NOT EXECUTED
10651d: eb 4a jmp 106569 <rtems_libio_init+0x79> <== NOT EXECUTED
iop = rtems_libio_iop_freelist = rtems_libio_iops;
10651f: a3 3c d6 11 00 mov %eax,0x11d63c
for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++)
106524: 8b 1d d8 92 11 00 mov 0x1192d8,%ebx
10652a: 89 c2 mov %eax,%edx
10652c: 31 c0 xor %eax,%eax
10652e: eb 03 jmp 106533 <rtems_libio_init+0x43>
iop->data1 = iop + 1;
106530: 89 52 f4 mov %edx,-0xc(%edx)
106533: 40 inc %eax
106534: 83 c2 34 add $0x34,%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 < (rtems_libio_number_iops - 1) ; i++, iop++)
106537: 39 d8 cmp %ebx,%eax
106539: 75 f5 jne 106530 <rtems_libio_init+0x40>
iop->data1 = iop + 1;
iop->data1 = NULL;
10653b: 6b c0 34 imul $0x34,%eax,%eax
10653e: c7 44 01 f4 00 00 00 movl $0x0,-0xc(%ecx,%eax,1)
106545: 00
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
106546: 83 ec 0c sub $0xc,%esp
106549: 68 40 d6 11 00 push $0x11d640
10654e: 6a 00 push $0x0
106550: 6a 54 push $0x54
106552: 6a 01 push $0x1
106554: 68 4f 49 42 4c push $0x4c42494f
106559: e8 e2 29 00 00 call 108f40 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
10655e: 83 c4 20 add $0x20,%esp
106561: 85 c0 test %eax,%eax
106563: 74 09 je 10656e <rtems_libio_init+0x7e> <== ALWAYS TAKEN
rtems_fatal_error_occurred( rc );
106565: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106568: 50 push %eax <== NOT EXECUTED
106569: e8 26 32 00 00 call 109794 <rtems_fatal_error_occurred><== NOT EXECUTED
/*
* Initialize the base file system infrastructure.
*/
rtems_filesystem_initialize();
}
10656e: 8b 5d fc mov -0x4(%ebp),%ebx
106571: c9 leave
/*
* Initialize the base file system infrastructure.
*/
rtems_filesystem_initialize();
106572: e9 71 66 00 00 jmp 10cbe8 <rtems_filesystem_initialize>
00107b69 <rtems_libio_set_private_env>:
rtems_filesystem_freenode( &env->root_directory);
free(env);
}
}
rtems_status_code rtems_libio_set_private_env(void) {
107b69: 55 push %ebp
107b6a: 89 e5 mov %esp,%ebp
107b6c: 57 push %edi
107b6d: 56 push %esi
107b6e: 53 push %ebx
107b6f: 83 ec 30 sub $0x30,%esp
rtems_status_code sc;
rtems_id task_id;
rtems_filesystem_location_info_t loc;
sc=rtems_task_ident(RTEMS_SELF,0,&task_id);
107b72: 8d 45 f0 lea -0x10(%ebp),%eax
107b75: 50 push %eax
107b76: 6a 00 push $0x0
107b78: 6a 00 push $0x0
107b7a: e8 c9 25 00 00 call 10a148 <rtems_task_ident>
107b7f: 89 c3 mov %eax,%ebx
if (sc != RTEMS_SUCCESSFUL) return sc;
107b81: 83 c4 10 add $0x10,%esp
107b84: 85 c0 test %eax,%eax
107b86: 0f 85 d4 00 00 00 jne 107c60 <rtems_libio_set_private_env+0xf7><== NEVER TAKEN
/* Only for the first time a malloc is necesary */
if (rtems_current_user_env==&rtems_global_user_env) {
107b8c: 81 3d ac e3 11 00 00 cmpl $0x120a00,0x11e3ac
107b93: 0a 12 00
107b96: 75 4e jne 107be6 <rtems_libio_set_private_env+0x7d>
rtems_user_env_t *tmp = malloc(sizeof(rtems_user_env_t));
107b98: 83 ec 0c sub $0xc,%esp
107b9b: 6a 40 push $0x40
107b9d: e8 b2 f4 ff ff call 107054 <malloc>
107ba2: 89 c6 mov %eax,%esi
if (!tmp)
107ba4: 83 c4 10 add $0x10,%esp
107ba7: 85 c0 test %eax,%eax
107ba9: 75 07 jne 107bb2 <rtems_libio_set_private_env+0x49><== ALWAYS TAKEN
107bab: b3 1a mov $0x1a,%bl <== NOT EXECUTED
107bad: e9 ae 00 00 00 jmp 107c60 <rtems_libio_set_private_env+0xf7><== NOT EXECUTED
#ifdef HAVE_USERENV_REFCNT
tmp->refcnt = 1;
#endif
sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,(void(*)(void *))free_user_env);
107bb2: 57 push %edi
107bb3: 68 74 7a 10 00 push $0x107a74
107bb8: 68 ac e3 11 00 push $0x11e3ac
107bbd: 6a 00 push $0x0
107bbf: e8 a4 26 00 00 call 10a268 <rtems_task_variable_add>
107bc4: 89 c7 mov %eax,%edi
if (sc != RTEMS_SUCCESSFUL) {
107bc6: 83 c4 10 add $0x10,%esp
107bc9: 85 c0 test %eax,%eax
107bcb: 74 13 je 107be0 <rtems_libio_set_private_env+0x77><== ALWAYS TAKEN
/* don't use free_user_env because the pathlocs are
* not initialized yet
*/
free(tmp);
107bcd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107bd0: 56 push %esi <== NOT EXECUTED
107bd1: e8 fe ef ff ff call 106bd4 <free> <== NOT EXECUTED
107bd6: 89 fb mov %edi,%ebx <== NOT EXECUTED
107bd8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107bdb: e9 80 00 00 00 jmp 107c60 <rtems_libio_set_private_env+0xf7><== NOT EXECUTED
return sc;
}
rtems_current_user_env = tmp;
107be0: 89 35 ac e3 11 00 mov %esi,0x11e3ac
};
*rtems_current_user_env = rtems_global_user_env; /* get the global values*/
107be6: 8b 3d ac e3 11 00 mov 0x11e3ac,%edi
107bec: be 00 0a 12 00 mov $0x120a00,%esi
107bf1: b9 10 00 00 00 mov $0x10,%ecx
107bf6: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rtems_current_user_env->task_id=task_id; /* mark the local values*/
107bf8: 8b 15 ac e3 11 00 mov 0x11e3ac,%edx
107bfe: 8b 45 f0 mov -0x10(%ebp),%eax
107c01: 89 02 mov %eax,(%edx)
/* get a clean root */
rtems_filesystem_root = THE_ROOT_FS_LOC;
107c03: 8d 7a 14 lea 0x14(%edx),%edi
107c06: a1 40 0a 12 00 mov 0x120a40,%eax
107c0b: 8d 70 18 lea 0x18(%eax),%esi
107c0e: b1 04 mov $0x4,%cl
107c10: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
* code we must _not_ free the original locs because
* what we are trying to do here is forking off
* clones.
*/
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
107c12: 6a 00 push $0x0
107c14: 8d 45 e0 lea -0x20(%ebp),%eax
107c17: 89 45 c8 mov %eax,-0x38(%ebp)
107c1a: 50 push %eax
107c1b: 6a 00 push $0x0
107c1d: 68 cf 9d 11 00 push $0x119dcf
107c22: e8 8b ee ff ff call 106ab2 <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
107c27: a1 ac e3 11 00 mov 0x11e3ac,%eax
107c2c: 8d 78 14 lea 0x14(%eax),%edi
107c2f: b9 04 00 00 00 mov $0x4,%ecx
107c34: 8b 75 c8 mov -0x38(%ebp),%esi
107c37: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
107c39: 6a 00 push $0x0
107c3b: 8d 45 e0 lea -0x20(%ebp),%eax
107c3e: 50 push %eax
107c3f: 6a 00 push $0x0
107c41: 68 cf 9d 11 00 push $0x119dcf
107c46: e8 67 ee ff ff call 106ab2 <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
107c4b: a1 ac e3 11 00 mov 0x11e3ac,%eax
107c50: 8d 78 04 lea 0x4(%eax),%edi
107c53: b9 04 00 00 00 mov $0x4,%ecx
107c58: 8b 75 c8 mov -0x38(%ebp),%esi
107c5b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
107c5d: 83 c4 20 add $0x20,%esp
return RTEMS_SUCCESSFUL;
}
107c60: 89 d8 mov %ebx,%eax
107c62: 8d 65 f4 lea -0xc(%ebp),%esp
107c65: 5b pop %ebx
107c66: 5e pop %esi
107c67: 5f pop %edi
107c68: c9 leave
107c69: c3 ret
00107acb <rtems_libio_share_private_env>:
* b) mutex access to rtems_filesystem_current, rtems_filesytem_root
* while changing any of those (chdir(), chroot()).
*/
#ifndef HAVE_USERENV_REFCNT
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) {
107acb: 55 push %ebp <== NOT EXECUTED
107acc: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107ace: 53 push %ebx <== NOT EXECUTED
107acf: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED
rtems_status_code sc;
rtems_user_env_t * shared_user_env;
rtems_id current_task_id;
sc=rtems_task_ident(RTEMS_SELF,0,¤t_task_id);
107ad2: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED
107ad5: 50 push %eax <== NOT EXECUTED
107ad6: 6a 00 push $0x0 <== NOT EXECUTED
107ad8: 6a 00 push $0x0 <== NOT EXECUTED
107ada: e8 69 26 00 00 call 10a148 <rtems_task_ident> <== NOT EXECUTED
107adf: 89 c2 mov %eax,%edx <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) return sc;
107ae1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107ae4: 85 c0 test %eax,%eax <== NOT EXECUTED
107ae6: 75 7a jne 107b62 <rtems_libio_share_private_env+0x97><== NOT EXECUTED
if (rtems_current_user_env->task_id==current_task_id) {
107ae8: 8b 1d ac e3 11 00 mov 0x11e3ac,%ebx <== NOT EXECUTED
107aee: 8b 03 mov (%ebx),%eax <== NOT EXECUTED
107af0: 3b 45 f4 cmp -0xc(%ebp),%eax <== NOT EXECUTED
107af3: 75 23 jne 107b18 <rtems_libio_share_private_env+0x4d><== NOT EXECUTED
/* kill the current user env & task_var*/
rtems_user_env_t *tmp = rtems_current_user_env;
sc = rtems_task_variable_delete(RTEMS_SELF,(void*)&rtems_current_user_env);
107af5: 51 push %ecx <== NOT EXECUTED
107af6: 51 push %ecx <== NOT EXECUTED
107af7: 68 ac e3 11 00 push $0x11e3ac <== NOT EXECUTED
107afc: 6a 00 push $0x0 <== NOT EXECUTED
107afe: e8 fd 27 00 00 call 10a300 <rtems_task_variable_delete><== NOT EXECUTED
107b03: 89 c2 mov %eax,%edx <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) return sc;
107b05: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107b08: 85 c0 test %eax,%eax <== NOT EXECUTED
107b0a: 75 56 jne 107b62 <rtems_libio_share_private_env+0x97><== NOT EXECUTED
free_user_env(tmp);
107b0c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107b0f: 53 push %ebx <== NOT EXECUTED
107b10: e8 5f ff ff ff call 107a74 <free_user_env> <== NOT EXECUTED
107b15: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
};
/* AT THIS POINT, rtems_current_user_env is DANGLING */
sc = rtems_task_variable_get(task_id,(void*)&rtems_current_user_env,
107b18: 52 push %edx <== NOT EXECUTED
107b19: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED
107b1c: 50 push %eax <== NOT EXECUTED
107b1d: 68 ac e3 11 00 push $0x11e3ac <== NOT EXECUTED
107b22: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
107b25: e8 56 28 00 00 call 10a380 <rtems_task_variable_get><== NOT EXECUTED
107b2a: 89 c2 mov %eax,%edx <== NOT EXECUTED
(void*)&shared_user_env );
if (sc != RTEMS_SUCCESSFUL)
107b2c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107b2f: 85 c0 test %eax,%eax <== NOT EXECUTED
107b31: 75 25 jne 107b58 <rtems_libio_share_private_env+0x8d><== NOT EXECUTED
goto bailout;
sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,free_user_env);
107b33: 50 push %eax <== NOT EXECUTED
107b34: 68 74 7a 10 00 push $0x107a74 <== NOT EXECUTED
107b39: 68 ac e3 11 00 push $0x11e3ac <== NOT EXECUTED
107b3e: 6a 00 push $0x0 <== NOT EXECUTED
107b40: e8 23 27 00 00 call 10a268 <rtems_task_variable_add><== NOT EXECUTED
107b45: 89 c2 mov %eax,%edx <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
107b47: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107b4a: 85 c0 test %eax,%eax <== NOT EXECUTED
107b4c: 75 0a jne 107b58 <rtems_libio_share_private_env+0x8d><== NOT EXECUTED
goto bailout;
/* the current_user_env is the same pointer that remote env */
rtems_current_user_env = shared_user_env;
107b4e: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED
107b51: a3 ac e3 11 00 mov %eax,0x11e3ac <== NOT EXECUTED
107b56: eb 0a jmp 107b62 <rtems_libio_share_private_env+0x97><== NOT EXECUTED
return RTEMS_SUCCESSFUL;
bailout:
/* fallback to the global env */
rtems_current_user_env = &rtems_global_user_env;
107b58: c7 05 ac e3 11 00 00 movl $0x120a00,0x11e3ac <== NOT EXECUTED
107b5f: 0a 12 00
return sc;
}
107b62: 89 d0 mov %edx,%eax <== NOT EXECUTED
107b64: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
107b67: c9 leave <== NOT EXECUTED
107b68: c3 ret <== NOT EXECUTED
0010cec4 <rtems_libio_to_fcntl_flags>:
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
10cec4: 55 push %ebp
10cec5: 89 e5 mov %esp,%ebp
10cec7: 8b 4d 08 mov 0x8(%ebp),%ecx
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
10ceca: 89 c8 mov %ecx,%eax
10cecc: 83 e0 06 and $0x6,%eax
10cecf: ba 02 00 00 00 mov $0x2,%edx
10ced4: 83 f8 06 cmp $0x6,%eax
10ced7: 74 0f je 10cee8 <rtems_libio_to_fcntl_flags+0x24><== NEVER TAKEN
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
10ced9: 31 d2 xor %edx,%edx
10cedb: f6 c1 02 test $0x2,%cl
10cede: 75 08 jne 10cee8 <rtems_libio_to_fcntl_flags+0x24><== ALWAYS TAKEN
10cee0: 89 ca mov %ecx,%edx <== NOT EXECUTED
10cee2: c1 ea 02 shr $0x2,%edx <== NOT EXECUTED
10cee5: 83 e2 01 and $0x1,%edx <== 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 ) {
10cee8: f6 c1 01 test $0x1,%cl
10ceeb: 74 03 je 10cef0 <rtems_libio_to_fcntl_flags+0x2c>
fcntl_flags |= O_NONBLOCK;
10ceed: 80 ce 40 or $0x40,%dh
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
10cef0: f6 c5 02 test $0x2,%ch
10cef3: 74 03 je 10cef8 <rtems_libio_to_fcntl_flags+0x34>
fcntl_flags |= O_APPEND;
10cef5: 83 ca 08 or $0x8,%edx
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
10cef8: 80 e5 04 and $0x4,%ch
10cefb: 74 03 je 10cf00 <rtems_libio_to_fcntl_flags+0x3c>
fcntl_flags |= O_CREAT;
10cefd: 80 ce 02 or $0x2,%dh
}
return fcntl_flags;
}
10cf00: 89 d0 mov %edx,%eax
10cf02: c9 leave
10cf03: c3 ret
001085fc <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
1085fc: 55 push %ebp
1085fd: 89 e5 mov %esp,%ebp
1085ff: 56 push %esi
108600: 53 push %ebx
108601: 8b 75 08 mov 0x8(%ebp),%esi
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
108604: 85 f6 test %esi,%esi
108606: 74 55 je 10865d <rtems_memalign+0x61>
return EINVAL;
*pointer = NULL;
108608: c7 06 00 00 00 00 movl $0x0,(%esi)
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
10860e: 83 3d 24 2c 12 00 03 cmpl $0x3,0x122c24
108615: 75 09 jne 108620 <rtems_memalign+0x24> <== NEVER TAKEN
108617: e8 f8 f1 ff ff call 107814 <malloc_is_system_state_OK>
10861c: 84 c0 test %al,%al
10861e: 74 3d je 10865d <rtems_memalign+0x61> <== NEVER TAKEN
/*
*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
108620: e8 46 f2 ff ff call 10786b <malloc_deferred_frees_process>
/*
* Perform the aligned allocation requested
*/
return_this = _Protected_heap_Allocate_aligned(
108625: 50 push %eax
108626: ff 75 0c pushl 0xc(%ebp)
108629: ff 75 10 pushl 0x10(%ebp)
10862c: 68 3c 29 12 00 push $0x12293c
108631: e8 06 40 00 00 call 10c63c <_Protected_heap_Allocate_aligned>
108636: 89 c3 mov %eax,%ebx
&RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
108638: 83 c4 10 add $0x10,%esp
10863b: b8 0c 00 00 00 mov $0xc,%eax
108640: 85 db test %ebx,%ebx
108642: 74 1e je 108662 <rtems_memalign+0x66>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
108644: a1 34 0a 12 00 mov 0x120a34,%eax
108649: 85 c0 test %eax,%eax
10864b: 74 0a je 108657 <rtems_memalign+0x5b> <== ALWAYS TAKEN
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
10864d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108650: 56 push %esi <== NOT EXECUTED
108651: ff 50 04 call *0x4(%eax) <== NOT EXECUTED
108654: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
*/
if (rtems_malloc_boundary_helpers)
(*rtems_malloc_boundary_helpers->at_malloc)(return_this, size);
#endif
*pointer = return_this;
108657: 89 1e mov %ebx,(%esi)
108659: 31 c0 xor %eax,%eax
10865b: eb 05 jmp 108662 <rtems_memalign+0x66>
return 0;
10865d: b8 16 00 00 00 mov $0x16,%eax
}
108662: 8d 65 f8 lea -0x8(%ebp),%esp
108665: 5b pop %ebx
108666: 5e pop %esi
108667: c9 leave
108668: c3 ret
00110d44 <rtems_message_queue_create>:
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
Objects_Id *id
)
{
110d44: 55 push %ebp
110d45: 89 e5 mov %esp,%ebp
110d47: 57 push %edi
110d48: 56 push %esi
110d49: 53 push %ebx
110d4a: 83 ec 1c sub $0x1c,%esp
110d4d: 8b 7d 10 mov 0x10(%ebp),%edi
110d50: 8b 75 14 mov 0x14(%ebp),%esi
CORE_message_queue_Attributes the_msgq_attributes;
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !rtems_is_name_valid( name ) )
110d53: b8 03 00 00 00 mov $0x3,%eax
110d58: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
110d5c: 0f 84 b2 00 00 00 je 110e14 <rtems_message_queue_create+0xd0>
return RTEMS_INVALID_NAME;
if ( !id )
110d62: b8 09 00 00 00 mov $0x9,%eax
110d67: 83 7d 18 00 cmpl $0x0,0x18(%ebp)
110d6b: 0f 84 a3 00 00 00 je 110e14 <rtems_message_queue_create+0xd0><== NEVER TAKEN
if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
110d71: b8 0a 00 00 00 mov $0xa,%eax
110d76: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
110d7a: 0f 84 94 00 00 00 je 110e14 <rtems_message_queue_create+0xd0><== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
110d80: b8 08 00 00 00 mov $0x8,%eax
110d85: 85 ff test %edi,%edi
110d87: 0f 84 87 00 00 00 je 110e14 <rtems_message_queue_create+0xd0><== NEVER TAKEN
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
110d8d: a1 38 41 13 00 mov 0x134138,%eax
110d92: 40 inc %eax
110d93: a3 38 41 13 00 mov %eax,0x134138
#endif
#endif
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
110d98: e8 4f 79 00 00 call 1186ec <_Message_queue_Allocate>
110d9d: 89 c3 mov %eax,%ebx
if ( !the_message_queue ) {
110d9f: 85 c0 test %eax,%eax
110da1: 75 0c jne 110daf <rtems_message_queue_create+0x6b>
_Thread_Enable_dispatch();
110da3: e8 10 4a 00 00 call 1157b8 <_Thread_Enable_dispatch>
110da8: b8 05 00 00 00 mov $0x5,%eax
110dad: eb 65 jmp 110e14 <rtems_message_queue_create+0xd0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_message_queue->attribute_set = attribute_set;
110daf: 89 70 10 mov %esi,0x10(%eax)
if (_Attributes_Is_priority( attribute_set ) )
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
110db2: 31 c0 xor %eax,%eax
110db4: f7 c6 04 00 00 00 test $0x4,%esi
110dba: 0f 95 c0 setne %al
110dbd: 89 45 f0 mov %eax,-0x10(%ebp)
else
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
if ( ! _CORE_message_queue_Initialize(
110dc0: 57 push %edi
110dc1: ff 75 0c pushl 0xc(%ebp)
110dc4: 8d 45 f0 lea -0x10(%ebp),%eax
110dc7: 50 push %eax
110dc8: 8d 43 14 lea 0x14(%ebx),%eax
110dcb: 50 push %eax
110dcc: e8 3b 2e 00 00 call 113c0c <_CORE_message_queue_Initialize>
110dd1: 83 c4 10 add $0x10,%esp
110dd4: 84 c0 test %al,%al
110dd6: 75 1c jne 110df4 <rtems_message_queue_create+0xb0>
* @return This method returns the maximum memory available. If
* unsuccessful, 0 will be returned.
*/
static inline uint32_t _Protected_heap_Initialize(
Heap_Control *the_heap,
void *starting_address,
110dd8: 50 push %eax
110dd9: 50 push %eax
110dda: 53 push %ebx
110ddb: 68 38 4a 13 00 push $0x134a38
110de0: e8 a3 40 00 00 call 114e88 <_Objects_Free>
_Objects_MP_Close(
&_Message_queue_Information, the_message_queue->Object.id);
#endif
_Message_queue_Free( the_message_queue );
_Thread_Enable_dispatch();
110de5: e8 ce 49 00 00 call 1157b8 <_Thread_Enable_dispatch>
110dea: b8 0d 00 00 00 mov $0xd,%eax
110def: 83 c4 10 add $0x10,%esp
110df2: eb 20 jmp 110e14 <rtems_message_queue_create+0xd0>
110df4: 8b 4b 08 mov 0x8(%ebx),%ecx
110df7: 0f b7 d1 movzwl %cx,%edx
110dfa: a1 54 4a 13 00 mov 0x134a54,%eax
110dff: 89 1c 90 mov %ebx,(%eax,%edx,4)
110e02: 8b 45 08 mov 0x8(%ebp),%eax
110e05: 89 43 0c mov %eax,0xc(%ebx)
&_Message_queue_Information,
&the_message_queue->Object,
(Objects_Name) name
);
*id = the_message_queue->Object.id;
110e08: 8b 45 18 mov 0x18(%ebp),%eax
110e0b: 89 08 mov %ecx,(%eax)
name,
0
);
#endif
_Thread_Enable_dispatch();
110e0d: e8 a6 49 00 00 call 1157b8 <_Thread_Enable_dispatch>
110e12: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
110e14: 8d 65 f4 lea -0xc(%ebp),%esp
110e17: 5b pop %ebx
110e18: 5e pop %esi
110e19: 5f pop %edi
110e1a: c9 leave
110e1b: c3 ret
00110e80 <rtems_message_queue_flush>:
rtems_status_code rtems_message_queue_flush(
Objects_Id id,
uint32_t *count
)
{
110e80: 55 push %ebp
110e81: 89 e5 mov %esp,%ebp
110e83: 53 push %ebx
110e84: 83 ec 14 sub $0x14,%esp
110e87: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
110e8a: b8 09 00 00 00 mov $0x9,%eax
110e8f: 85 db test %ebx,%ebx
110e91: 74 3a je 110ecd <rtems_message_queue_flush+0x4d><== NEVER TAKEN
* @param[in] size is the size in bytes of the memory area to add
* @return a status indicating success or the reason for failure
*/
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
110e93: 50 push %eax
110e94: 8d 45 f8 lea -0x8(%ebp),%eax
110e97: 50 push %eax
110e98: ff 75 08 pushl 0x8(%ebp)
110e9b: 68 38 4a 13 00 push $0x134a38
110ea0: e8 53 41 00 00 call 114ff8 <_Objects_Get>
110ea5: 89 c2 mov %eax,%edx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
110ea7: 83 c4 10 add $0x10,%esp
110eaa: b8 04 00 00 00 mov $0x4,%eax
110eaf: 83 7d f8 00 cmpl $0x0,-0x8(%ebp)
110eb3: 75 18 jne 110ecd <rtems_message_queue_flush+0x4d>
case OBJECTS_LOCAL:
*count = _CORE_message_queue_Flush( &the_message_queue->message_queue );
110eb5: 83 ec 0c sub $0xc,%esp
110eb8: 8d 42 14 lea 0x14(%edx),%eax
110ebb: 50 push %eax
110ebc: e8 e7 2c 00 00 call 113ba8 <_CORE_message_queue_Flush>
110ec1: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
110ec3: e8 f0 48 00 00 call 1157b8 <_Thread_Enable_dispatch>
110ec8: 31 c0 xor %eax,%eax
110eca: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
110ecd: 8b 5d fc mov -0x4(%ebp),%ebx
110ed0: c9 leave
110ed1: c3 ret
00110ed4 <rtems_message_queue_get_number_pending>:
rtems_status_code rtems_message_queue_get_number_pending(
Objects_Id id,
uint32_t *count
)
{
110ed4: 55 push %ebp
110ed5: 89 e5 mov %esp,%ebp
110ed7: 53 push %ebx
110ed8: 83 ec 14 sub $0x14,%esp
110edb: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
110ede: b8 09 00 00 00 mov $0x9,%eax
110ee3: 85 db test %ebx,%ebx
110ee5: 74 2e je 110f15 <rtems_message_queue_get_number_pending+0x41><== NEVER TAKEN
110ee7: 50 push %eax
110ee8: 8d 45 f8 lea -0x8(%ebp),%eax
110eeb: 50 push %eax
110eec: ff 75 08 pushl 0x8(%ebp)
110eef: 68 38 4a 13 00 push $0x134a38
110ef4: e8 ff 40 00 00 call 114ff8 <_Objects_Get>
110ef9: 89 c2 mov %eax,%edx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
110efb: 83 c4 10 add $0x10,%esp
110efe: b8 04 00 00 00 mov $0x4,%eax
110f03: 83 7d f8 00 cmpl $0x0,-0x8(%ebp)
110f07: 75 0c jne 110f15 <rtems_message_queue_get_number_pending+0x41>
case OBJECTS_LOCAL:
*count = the_message_queue->message_queue.number_of_pending_messages;
110f09: 8b 42 5c mov 0x5c(%edx),%eax
110f0c: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
110f0e: e8 a5 48 00 00 call 1157b8 <_Thread_Enable_dispatch>
110f13: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
110f15: 8b 5d fc mov -0x4(%ebp),%ebx
110f18: c9 leave
110f19: c3 ret
00108ec0 <rtems_message_queue_send>:
rtems_status_code rtems_message_queue_send(
Objects_Id id,
const void *buffer,
size_t size
)
{
108ec0: 55 push %ebp
108ec1: 89 e5 mov %esp,%ebp
108ec3: 56 push %esi
108ec4: 53 push %ebx
108ec5: 83 ec 10 sub $0x10,%esp
108ec8: 8b 5d 08 mov 0x8(%ebp),%ebx
108ecb: 8b 75 0c mov 0xc(%ebp),%esi
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
108ece: b8 09 00 00 00 mov $0x9,%eax
108ed3: 85 f6 test %esi,%esi
108ed5: 74 4f je 108f26 <rtems_message_queue_send+0x66><== NEVER TAKEN
* @param[in] size is the size in bytes of the memory area to add
* @return a status indicating success or the reason for failure
*/
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
108ed7: 50 push %eax
108ed8: 8d 45 f4 lea -0xc(%ebp),%eax
108edb: 50 push %eax
108edc: 53 push %ebx
108edd: 68 90 e0 11 00 push $0x11e090
108ee2: e8 e5 17 00 00 call 10a6cc <_Objects_Get>
108ee7: 89 c2 mov %eax,%edx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
108ee9: 83 c4 10 add $0x10,%esp
108eec: b8 04 00 00 00 mov $0x4,%eax
108ef1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
108ef5: 75 2f jne 108f26 <rtems_message_queue_send+0x66><== NEVER TAKEN
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory for
* the heap
108ef7: 6a 00 push $0x0
108ef9: 6a 00 push $0x0
108efb: 68 ff ff ff 7f push $0x7fffffff
108f00: 6a 00 push $0x0
108f02: 53 push %ebx
108f03: ff 75 10 pushl 0x10(%ebp)
108f06: 56 push %esi
108f07: 8d 42 14 lea 0x14(%edx),%eax
108f0a: 50 push %eax
108f0b: e8 28 0c 00 00 call 109b38 <_CORE_message_queue_Submit>
108f10: 89 c3 mov %eax,%ebx
MESSAGE_QUEUE_MP_HANDLER,
FALSE, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
108f12: 83 c4 20 add $0x20,%esp
108f15: e8 72 1f 00 00 call 10ae8c <_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);
108f1a: 83 ec 0c sub $0xc,%esp
108f1d: 53 push %ebx
108f1e: e8 0d 00 00 00 call 108f30 <_Message_queue_Translate_core_message_queue_return_code>
108f23: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
108f26: 8d 65 f8 lea -0x8(%ebp),%esp
108f29: 5b pop %ebx
108f2a: 5e pop %esi
108f2b: c9 leave
108f2c: c3 ret
00111040 <rtems_message_queue_urgent>:
rtems_status_code rtems_message_queue_urgent(
Objects_Id id,
const void *buffer,
size_t size
)
{
111040: 55 push %ebp
111041: 89 e5 mov %esp,%ebp
111043: 56 push %esi
111044: 53 push %ebx
111045: 83 ec 10 sub $0x10,%esp
111048: 8b 5d 08 mov 0x8(%ebp),%ebx
11104b: 8b 75 0c mov 0xc(%ebp),%esi
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
11104e: b8 09 00 00 00 mov $0x9,%eax
111053: 85 f6 test %esi,%esi
111055: 74 4f je 1110a6 <rtems_message_queue_urgent+0x66><== NEVER TAKEN
* @param[in] size is the size in bytes of the memory area to add
* @return a status indicating success or the reason for failure
*/
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
111057: 50 push %eax
111058: 8d 45 f4 lea -0xc(%ebp),%eax
11105b: 50 push %eax
11105c: 53 push %ebx
11105d: 68 38 4a 13 00 push $0x134a38
111062: e8 91 3f 00 00 call 114ff8 <_Objects_Get>
111067: 89 c2 mov %eax,%edx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
111069: 83 c4 10 add $0x10,%esp
11106c: b8 04 00 00 00 mov $0x4,%eax
111071: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
111075: 75 2f jne 1110a6 <rtems_message_queue_urgent+0x66>
size_t size
111077: 6a 00 push $0x0
111079: 6a 00 push $0x0
11107b: 68 00 00 00 80 push $0x80000000
111080: 6a 00 push $0x0
111082: 53 push %ebx
111083: ff 75 10 pushl 0x10(%ebp)
111086: 56 push %esi
111087: 8d 42 14 lea 0x14(%edx),%eax
11108a: 50 push %eax
11108b: e8 6c 2d 00 00 call 113dfc <_CORE_message_queue_Submit>
111090: 89 c3 mov %eax,%ebx
id,
MESSAGE_QUEUE_MP_HANDLER,
FALSE, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
111092: 83 c4 20 add $0x20,%esp
111095: e8 1e 47 00 00 call 1157b8 <_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);
11109a: 83 ec 0c sub $0xc,%esp
11109d: 53 push %ebx
11109e: e8 8d ff ff ff call 111030 <_Message_queue_Translate_core_message_queue_return_code>
1110a3: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1110a6: 8d 65 f8 lea -0x8(%ebp),%esp
1110a9: 5b pop %ebx
1110aa: 5e pop %esi
1110ab: c9 leave
1110ac: c3 ret
00109448 <rtems_object_set_name>:
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
109448: 55 push %ebp
109449: 89 e5 mov %esp,%ebp
10944b: 57 push %edi
10944c: 56 push %esi
10944d: 53 push %ebx
10944e: 83 ec 1c sub $0x1c,%esp
109451: 8b 7d 0c mov 0xc(%ebp),%edi
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
109454: b8 09 00 00 00 mov $0x9,%eax
109459: 85 ff test %edi,%edi
10945b: 74 50 je 1094ad <rtems_object_set_name+0x65><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10945d: 8b 5d 08 mov 0x8(%ebp),%ebx
109460: 85 db test %ebx,%ebx
109462: 75 08 jne 10946c <rtems_object_set_name+0x24>
109464: a1 4c 0d 12 00 mov 0x120d4c,%eax
109469: 8b 58 08 mov 0x8(%eax),%ebx
information = _Objects_Get_information_id( tmpId );
10946c: 83 ec 0c sub $0xc,%esp
10946f: 53 push %ebx
109470: e8 b3 16 00 00 call 10ab28 <_Objects_Get_information_id>
109475: 89 c6 mov %eax,%esi
if ( !information )
109477: 83 c4 10 add $0x10,%esp
10947a: 85 c0 test %eax,%eax
10947c: 74 2a je 1094a8 <rtems_object_set_name+0x60>
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
10947e: 51 push %ecx
10947f: 8d 45 f0 lea -0x10(%ebp),%eax
109482: 50 push %eax
109483: 53 push %ebx
109484: 56 push %esi
109485: e8 36 18 00 00 call 10acc0 <_Objects_Get>
switch ( location ) {
10948a: 83 c4 10 add $0x10,%esp
10948d: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
109491: 75 15 jne 1094a8 <rtems_object_set_name+0x60>
case OBJECTS_LOCAL:
_Objects_Set_name( information, the_object, name );
109493: 52 push %edx
109494: 57 push %edi
109495: 50 push %eax
109496: 56 push %esi
109497: e8 e0 19 00 00 call 10ae7c <_Objects_Set_name>
_Thread_Enable_dispatch();
10949c: e8 bf 20 00 00 call 10b560 <_Thread_Enable_dispatch>
1094a1: 31 c0 xor %eax,%eax
1094a3: 83 c4 10 add $0x10,%esp
1094a6: eb 05 jmp 1094ad <rtems_object_set_name+0x65>
return RTEMS_SUCCESSFUL;
1094a8: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1094ad: 8d 65 f4 lea -0xc(%ebp),%esp
1094b0: 5b pop %ebx
1094b1: 5e pop %esi
1094b2: 5f pop %edi
1094b3: c9 leave
1094b4: c3 ret
00107028 <rtems_panic>:
void rtems_panic(
const char *printf_format,
...
)
{
107028: 55 push %ebp <== NOT EXECUTED
107029: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10702b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10702e: 8d 4d 0c lea 0xc(%ebp),%ecx <== NOT EXECUTED
va_list arglist;
va_start(arglist, printf_format);
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
107031: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
107034: b8 00 00 00 20 mov $0x20000000,%eax <== NOT EXECUTED
107039: e8 83 fe ff ff call 106ec1 <rtems_verror> <== NOT EXECUTED
va_end(arglist);
}
10703e: c9 leave <== NOT EXECUTED
10703f: c3 ret <== NOT EXECUTED
001110b0 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
Objects_Id *id
)
{
1110b0: 55 push %ebp
1110b1: 89 e5 mov %esp,%ebp
1110b3: 57 push %edi
1110b4: 56 push %esi
1110b5: 53 push %ebx
1110b6: 83 ec 0c sub $0xc,%esp
1110b9: 8b 7d 10 mov 0x10(%ebp),%edi
1110bc: 8b 75 14 mov 0x14(%ebp),%esi
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
1110bf: b8 03 00 00 00 mov $0x3,%eax
1110c4: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
1110c8: 0f 84 c9 00 00 00 je 111197 <rtems_partition_create+0xe7>
return RTEMS_INVALID_NAME;
if ( !starting_address )
1110ce: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
1110d2: 0f 84 b3 00 00 00 je 11118b <rtems_partition_create+0xdb><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !id )
1110d8: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp)
1110dc: 0f 84 a9 00 00 00 je 11118b <rtems_partition_create+0xdb><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
1110e2: 85 ff test %edi,%edi
1110e4: 0f 84 a8 00 00 00 je 111192 <rtems_partition_create+0xe2>
1110ea: 85 f6 test %esi,%esi
1110ec: 0f 84 a0 00 00 00 je 111192 <rtems_partition_create+0xe2>
1110f2: 39 f7 cmp %esi,%edi
1110f4: 0f 82 98 00 00 00 jb 111192 <rtems_partition_create+0xe2>
1110fa: f7 c6 03 00 00 00 test $0x3,%esi
111100: 0f 85 8c 00 00 00 jne 111192 <rtems_partition_create+0xe2>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
111106: f6 45 0c 03 testb $0x3,0xc(%ebp)
11110a: 75 7f jne 11118b <rtems_partition_create+0xdb>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
11110c: a1 38 41 13 00 mov 0x134138,%eax
111111: 40 inc %eax
111112: a3 38 41 13 00 mov %eax,0x134138
* Returns TRUE if the @a starting_address is in the heap, and FALSE
* otherwise.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the user block
* to obtain the size of
111117: 83 ec 0c sub $0xc,%esp
11111a: 68 6c 3f 13 00 push $0x133f6c
11111f: e8 54 3a 00 00 call 114b78 <_Objects_Allocate>
111124: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
111126: 83 c4 10 add $0x10,%esp
111129: 85 c0 test %eax,%eax
11112b: 75 0c jne 111139 <rtems_partition_create+0x89>
_Thread_Enable_dispatch();
11112d: e8 86 46 00 00 call 1157b8 <_Thread_Enable_dispatch>
111132: b8 05 00 00 00 mov $0x5,%eax
111137: eb 5e jmp 111197 <rtems_partition_create+0xe7>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
111139: 8b 45 0c mov 0xc(%ebp),%eax
11113c: 89 43 10 mov %eax,0x10(%ebx)
the_partition->length = length;
11113f: 89 7b 14 mov %edi,0x14(%ebx)
the_partition->buffer_size = buffer_size;
111142: 89 73 18 mov %esi,0x18(%ebx)
the_partition->attribute_set = attribute_set;
111145: 8b 45 18 mov 0x18(%ebp),%eax
111148: 89 43 1c mov %eax,0x1c(%ebx)
the_partition->number_of_used_blocks = 0;
11114b: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
_Chain_Initialize( &the_partition->Memory, starting_address,
111152: 56 push %esi
111153: 89 f8 mov %edi,%eax
111155: 31 d2 xor %edx,%edx
111157: f7 f6 div %esi
111159: 50 push %eax
11115a: ff 75 0c pushl 0xc(%ebp)
11115d: 8d 43 24 lea 0x24(%ebx),%eax
111160: 50 push %eax
111161: e8 6a 29 00 00 call 113ad0 <_Chain_Initialize>
111166: 8b 4b 08 mov 0x8(%ebx),%ecx
111169: 0f b7 d1 movzwl %cx,%edx
11116c: a1 88 3f 13 00 mov 0x133f88,%eax
111171: 89 1c 90 mov %ebx,(%eax,%edx,4)
111174: 8b 45 08 mov 0x8(%ebp),%eax
111177: 89 43 0c mov %eax,0xc(%ebx)
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
11117a: 8b 45 1c mov 0x1c(%ebp),%eax
11117d: 89 08 mov %ecx,(%eax)
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
11117f: e8 34 46 00 00 call 1157b8 <_Thread_Enable_dispatch>
111184: 31 c0 xor %eax,%eax
111186: 83 c4 10 add $0x10,%esp
111189: eb 0c jmp 111197 <rtems_partition_create+0xe7>
return RTEMS_SUCCESSFUL;
11118b: b8 09 00 00 00 mov $0x9,%eax
111190: eb 05 jmp 111197 <rtems_partition_create+0xe7>
111192: b8 08 00 00 00 mov $0x8,%eax
}
111197: 8d 65 f4 lea -0xc(%ebp),%esp
11119a: 5b pop %ebx
11119b: 5e pop %esi
11119c: 5f pop %edi
11119d: c9 leave
11119e: c3 ret
00111204 <rtems_partition_get_buffer>:
rtems_status_code rtems_partition_get_buffer(
Objects_Id id,
void **buffer
)
{
111204: 55 push %ebp
111205: 89 e5 mov %esp,%ebp
111207: 57 push %edi
111208: 56 push %esi
111209: 53 push %ebx
11120a: 83 ec 1c sub $0x1c,%esp
11120d: 8b 7d 0c mov 0xc(%ebp),%edi
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
111210: b8 09 00 00 00 mov $0x9,%eax
111215: 85 ff test %edi,%edi
111217: 74 4f je 111268 <rtems_partition_get_buffer+0x64><== NEVER TAKEN
);
/**
* This routine returns the block of memory which begins
* at @a starting_address to @a the_heap. Any coalescing which is
* possible with the freeing of this routine is performed.
111219: 50 push %eax
11121a: 8d 45 f0 lea -0x10(%ebp),%eax
11121d: 50 push %eax
11121e: ff 75 08 pushl 0x8(%ebp)
111221: 68 6c 3f 13 00 push $0x133f6c
111226: e8 cd 3d 00 00 call 114ff8 <_Objects_Get>
11122b: 89 c3 mov %eax,%ebx
return RTEMS_INVALID_ADDRESS;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
11122d: 83 c4 10 add $0x10,%esp
111230: b8 04 00 00 00 mov $0x4,%eax
111235: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
111239: 75 2d jne 111268 <rtems_partition_get_buffer+0x64>
#endif
/**
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
11123b: 83 ec 0c sub $0xc,%esp
11123e: 8d 43 24 lea 0x24(%ebx),%eax
111241: 50 push %eax
111242: e8 61 28 00 00 call 113aa8 <_Chain_Get>
111247: 89 c6 mov %eax,%esi
case OBJECTS_LOCAL:
the_buffer = _Partition_Allocate_buffer( the_partition );
if ( the_buffer ) {
111249: 83 c4 10 add $0x10,%esp
11124c: 85 c0 test %eax,%eax
11124e: 74 0e je 11125e <rtems_partition_get_buffer+0x5a>
the_partition->number_of_used_blocks += 1;
111250: ff 43 20 incl 0x20(%ebx)
_Thread_Enable_dispatch();
111253: e8 60 45 00 00 call 1157b8 <_Thread_Enable_dispatch>
*buffer = the_buffer;
111258: 89 37 mov %esi,(%edi)
11125a: 31 c0 xor %eax,%eax
11125c: eb 0a jmp 111268 <rtems_partition_get_buffer+0x64>
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
11125e: e8 55 45 00 00 call 1157b8 <_Thread_Enable_dispatch>
111263: b8 0d 00 00 00 mov $0xd,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
111268: 8d 65 f4 lea -0xc(%ebp),%esp
11126b: 5b pop %ebx
11126c: 5e pop %esi
11126d: 5f pop %edi
11126e: c9 leave
11126f: c3 ret
001107e4 <rtems_port_create>:
void *internal_start,
void *external_start,
uint32_t length,
Objects_Id *id
)
{
1107e4: 55 push %ebp
1107e5: 89 e5 mov %esp,%ebp
1107e7: 57 push %edi
1107e8: 56 push %esi
1107e9: 53 push %ebx
1107ea: 83 ec 0c sub $0xc,%esp
1107ed: 8b 75 0c mov 0xc(%ebp),%esi
1107f0: 8b 7d 10 mov 0x10(%ebp),%edi
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name) )
1107f3: b8 03 00 00 00 mov $0x3,%eax
1107f8: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
1107fc: 74 6f je 11086d <rtems_port_create+0x89>
return RTEMS_INVALID_NAME;
if ( !id )
1107fe: 83 7d 18 00 cmpl $0x0,0x18(%ebp)
110802: 74 64 je 110868 <rtems_port_create+0x84><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( internal_start ) ||
110804: 89 f8 mov %edi,%eax
110806: 09 f0 or %esi,%eax
110808: a8 03 test $0x3,%al
11080a: 75 5c jne 110868 <rtems_port_create+0x84>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
11080c: a1 38 41 13 00 mov 0x134138,%eax
110811: 40 inc %eax
110812: a3 38 41 13 00 mov %eax,0x134138
#ifdef __cplusplus
extern "C" {
#endif
/**
* This routine initializes @a the_heap record to manage the
110817: 83 ec 0c sub $0xc,%esp
11081a: 68 2c 3f 13 00 push $0x133f2c
11081f: e8 54 43 00 00 call 114b78 <_Objects_Allocate>
110824: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
110826: 83 c4 10 add $0x10,%esp
110829: 85 c0 test %eax,%eax
11082b: 75 0c jne 110839 <rtems_port_create+0x55>
_Thread_Enable_dispatch();
11082d: e8 86 4f 00 00 call 1157b8 <_Thread_Enable_dispatch>
110832: b8 05 00 00 00 mov $0x5,%eax
110837: eb 34 jmp 11086d <rtems_port_create+0x89>
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
110839: 89 70 10 mov %esi,0x10(%eax)
the_port->external_base = external_start;
11083c: 89 78 14 mov %edi,0x14(%eax)
the_port->length = length - 1;
11083f: 8b 45 14 mov 0x14(%ebp),%eax
110842: 48 dec %eax
110843: 89 43 18 mov %eax,0x18(%ebx)
110846: 8b 4b 08 mov 0x8(%ebx),%ecx
110849: 0f b7 d1 movzwl %cx,%edx
11084c: a1 48 3f 13 00 mov 0x133f48,%eax
110851: 89 1c 90 mov %ebx,(%eax,%edx,4)
110854: 8b 45 08 mov 0x8(%ebp),%eax
110857: 89 43 0c mov %eax,0xc(%ebx)
&_Dual_ported_memory_Information,
&the_port->Object,
(Objects_Name) name
);
*id = the_port->Object.id;
11085a: 8b 45 18 mov 0x18(%ebp),%eax
11085d: 89 08 mov %ecx,(%eax)
_Thread_Enable_dispatch();
11085f: e8 54 4f 00 00 call 1157b8 <_Thread_Enable_dispatch>
110864: 31 c0 xor %eax,%eax
110866: eb 05 jmp 11086d <rtems_port_create+0x89>
return RTEMS_SUCCESSFUL;
110868: b8 09 00 00 00 mov $0x9,%eax
}
11086d: 8d 65 f4 lea -0xc(%ebp),%esp
110870: 5b pop %ebx
110871: 5e pop %esi
110872: 5f pop %edi
110873: c9 leave
110874: c3 ret
001108cc <rtems_port_external_to_internal>:
rtems_status_code rtems_port_external_to_internal(
Objects_Id id,
void *external,
void **internal
)
{
1108cc: 55 push %ebp
1108cd: 89 e5 mov %esp,%ebp
1108cf: 56 push %esi
1108d0: 53 push %ebx
1108d1: 83 ec 10 sub $0x10,%esp
1108d4: 8b 75 0c mov 0xc(%ebp),%esi
1108d7: 8b 5d 10 mov 0x10(%ebp),%ebx
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !internal )
1108da: b8 09 00 00 00 mov $0x9,%eax
1108df: 85 db test %ebx,%ebx
1108e1: 74 3c je 11091f <rtems_port_external_to_internal+0x53><== NEVER TAKEN
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory
* to add to the heap
* @param[in] size is the size in bytes of the memory area to add
1108e3: 50 push %eax
1108e4: 8d 45 f4 lea -0xc(%ebp),%eax
1108e7: 50 push %eax
1108e8: ff 75 08 pushl 0x8(%ebp)
1108eb: 68 2c 3f 13 00 push $0x133f2c
1108f0: e8 03 47 00 00 call 114ff8 <_Objects_Get>
1108f5: 89 c1 mov %eax,%ecx
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
1108f7: 83 c4 10 add $0x10,%esp
1108fa: b8 04 00 00 00 mov $0x4,%eax
1108ff: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
110903: 75 1a jne 11091f <rtems_port_external_to_internal+0x53>
* a block of the requested size, then NULL is returned.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
* @return NULL if unsuccessful and a pointer to the block if successful
*/
110905: 89 f2 mov %esi,%edx
110907: 2b 51 14 sub 0x14(%ecx),%edx
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( external, the_port->external_base );
if ( ending > the_port->length )
11090a: 3b 51 18 cmp 0x18(%ecx),%edx
11090d: 76 04 jbe 110913 <rtems_port_external_to_internal+0x47>
*internal = external;
11090f: 89 33 mov %esi,(%ebx)
110911: eb 05 jmp 110918 <rtems_port_external_to_internal+0x4c>
else
*internal = _Addresses_Add_offset( the_port->internal_base,
110913: 03 51 10 add 0x10(%ecx),%edx
110916: 89 13 mov %edx,(%ebx)
ending );
_Thread_Enable_dispatch();
110918: e8 9b 4e 00 00 call 1157b8 <_Thread_Enable_dispatch>
11091d: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11091f: 8d 65 f8 lea -0x8(%ebp),%esp
110922: 5b pop %ebx
110923: 5e pop %esi
110924: c9 leave
110925: c3 ret
0011094c <rtems_port_internal_to_external>:
rtems_status_code rtems_port_internal_to_external(
Objects_Id id,
void *internal,
void **external
)
{
11094c: 55 push %ebp
11094d: 89 e5 mov %esp,%ebp
11094f: 56 push %esi
110950: 53 push %ebx
110951: 83 ec 10 sub $0x10,%esp
110954: 8b 75 0c mov 0xc(%ebp),%esi
110957: 8b 5d 10 mov 0x10(%ebp),%ebx
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
11095a: b8 09 00 00 00 mov $0x9,%eax
11095f: 85 db test %ebx,%ebx
110961: 74 3c je 11099f <rtems_port_internal_to_external+0x53><== NEVER TAKEN
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory
* to add to the heap
* @param[in] size is the size in bytes of the memory area to add
110963: 50 push %eax
110964: 8d 45 f4 lea -0xc(%ebp),%eax
110967: 50 push %eax
110968: ff 75 08 pushl 0x8(%ebp)
11096b: 68 2c 3f 13 00 push $0x133f2c
110970: e8 83 46 00 00 call 114ff8 <_Objects_Get>
110975: 89 c1 mov %eax,%ecx
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
110977: 83 c4 10 add $0x10,%esp
11097a: b8 04 00 00 00 mov $0x4,%eax
11097f: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
110983: 75 1a jne 11099f <rtems_port_internal_to_external+0x53>
* a block of the requested size, then NULL is returned.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
* @return NULL if unsuccessful and a pointer to the block if successful
*/
110985: 89 f2 mov %esi,%edx
110987: 2b 51 10 sub 0x10(%ecx),%edx
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( internal, the_port->internal_base );
if ( ending > the_port->length )
11098a: 3b 51 18 cmp 0x18(%ecx),%edx
11098d: 76 04 jbe 110993 <rtems_port_internal_to_external+0x47>
*external = internal;
11098f: 89 33 mov %esi,(%ebx)
110991: eb 05 jmp 110998 <rtems_port_internal_to_external+0x4c>
else
*external = _Addresses_Add_offset( the_port->external_base,
110993: 03 51 14 add 0x14(%ecx),%edx
110996: 89 13 mov %edx,(%ebx)
ending );
_Thread_Enable_dispatch();
110998: e8 1b 4e 00 00 call 1157b8 <_Thread_Enable_dispatch>
11099d: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11099f: 8d 65 f8 lea -0x8(%ebp),%esp
1109a2: 5b pop %ebx
1109a3: 5e pop %esi
1109a4: c9 leave
1109a5: c3 ret
00109ce4 <rtems_rate_monotonic_create>:
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
Objects_Id *id
)
{
109ce4: 55 push %ebp
109ce5: 89 e5 mov %esp,%ebp
109ce7: 57 push %edi
109ce8: 56 push %esi
109ce9: 53 push %ebx
109cea: 83 ec 0c sub $0xc,%esp
109ced: 8b 75 08 mov 0x8(%ebp),%esi
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
109cf0: b8 03 00 00 00 mov $0x3,%eax
109cf5: 85 f6 test %esi,%esi
109cf7: 0f 84 ac 00 00 00 je 109da9 <rtems_rate_monotonic_create+0xc5>
return RTEMS_INVALID_NAME;
if ( !id )
109cfd: b8 09 00 00 00 mov $0x9,%eax
109d02: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
109d06: 0f 84 9d 00 00 00 je 109da9 <rtems_rate_monotonic_create+0xc5><== NEVER TAKEN
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
109d0c: a1 3c 1c 12 00 mov 0x121c3c,%eax
109d11: 40 inc %eax
109d12: a3 3c 1c 12 00 mov %eax,0x121c3c
#ifdef __cplusplus
extern "C" {
#endif
/**
109d17: 83 ec 0c sub $0xc,%esp
109d1a: 68 44 1b 12 00 push $0x121b44
109d1f: e8 84 1b 00 00 call 10b8a8 <_Objects_Allocate>
109d24: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
109d26: 83 c4 10 add $0x10,%esp
109d29: 85 c0 test %eax,%eax
109d2b: 75 0c jne 109d39 <rtems_rate_monotonic_create+0x55>
_Thread_Enable_dispatch();
109d2d: e8 52 28 00 00 call 10c584 <_Thread_Enable_dispatch>
109d32: b8 05 00 00 00 mov $0x5,%eax
109d37: eb 70 jmp 109da9 <rtems_rate_monotonic_create+0xc5>
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
109d39: a1 fc 1c 12 00 mov 0x121cfc,%eax
109d3e: 89 43 50 mov %eax,0x50(%ebx)
the_period->state = RATE_MONOTONIC_INACTIVE;
109d41: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx)
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
109d48: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
* @param[in] the_heap is the heap to operate upon
109d4f: c7 43 2c 00 00 00 00 movl $0x0,0x2c(%ebx)
* @param[in] starting_address is the starting address of the memory for
109d56: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx)
* the heap
109d5d: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx)
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
109d64: 8d 7b 54 lea 0x54(%ebx),%edi
109d67: b9 0e 00 00 00 mov $0xe,%ecx
109d6c: 31 c0 xor %eax,%eax
109d6e: f3 ab rep stos %eax,%es:(%edi)
109d70: c7 43 5c ff ff ff 7f movl $0x7fffffff,0x5c(%ebx)
109d77: c7 43 60 ff ff ff 7f movl $0x7fffffff,0x60(%ebx)
109d7e: c7 43 74 ff ff ff 7f movl $0x7fffffff,0x74(%ebx)
109d85: c7 43 78 ff ff ff 7f movl $0x7fffffff,0x78(%ebx)
109d8c: 8b 4b 08 mov 0x8(%ebx),%ecx
109d8f: 0f b7 d1 movzwl %cx,%edx
109d92: a1 60 1b 12 00 mov 0x121b60,%eax
109d97: 89 1c 90 mov %ebx,(%eax,%edx,4)
109d9a: 89 73 0c mov %esi,0xc(%ebx)
&_Rate_monotonic_Information,
&the_period->Object,
(Objects_Name) name
);
*id = the_period->Object.id;
109d9d: 8b 45 0c mov 0xc(%ebp),%eax
109da0: 89 08 mov %ecx,(%eax)
_Thread_Enable_dispatch();
109da2: e8 dd 27 00 00 call 10c584 <_Thread_Enable_dispatch>
109da7: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
109da9: 8d 65 f4 lea -0xc(%ebp),%esp
109dac: 5b pop %ebx
109dad: 5e pop %esi
109dae: 5f pop %edi
109daf: c9 leave
109db0: c3 ret
0010f338 <rtems_rate_monotonic_get_statistics>:
rtems_status_code rtems_rate_monotonic_get_statistics(
Objects_Id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
10f338: 55 push %ebp
10f339: 89 e5 mov %esp,%ebp
10f33b: 57 push %edi
10f33c: 56 push %esi
10f33d: 83 ec 20 sub $0x20,%esp
10f340: 8b 7d 0c mov 0xc(%ebp),%edi
Objects_Locations location;
Rate_monotonic_Control *the_period;
if ( !statistics )
10f343: b8 09 00 00 00 mov $0x9,%eax
10f348: 85 ff test %edi,%edi
10f34a: 74 33 je 10f37f <rtems_rate_monotonic_get_statistics+0x47><== NEVER TAKEN
/**
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory
10f34c: 50 push %eax
10f34d: 8d 45 f4 lea -0xc(%ebp),%eax
10f350: 50 push %eax
10f351: ff 75 08 pushl 0x8(%ebp)
10f354: 68 44 1b 12 00 push $0x121b44
10f359: e8 66 ca ff ff call 10bdc4 <_Objects_Get>
10f35e: 89 c2 mov %eax,%edx
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
10f360: 83 c4 10 add $0x10,%esp
10f363: b8 04 00 00 00 mov $0x4,%eax
10f368: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10f36c: 75 11 jne 10f37f <rtems_rate_monotonic_get_statistics+0x47>
case OBJECTS_LOCAL:
*statistics = the_period->Statistics;
10f36e: 8d 72 54 lea 0x54(%edx),%esi
10f371: b9 0e 00 00 00 mov $0xe,%ecx
10f376: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Thread_Enable_dispatch();
10f378: e8 07 d2 ff ff call 10c584 <_Thread_Enable_dispatch>
10f37d: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10f37f: 8d 65 f8 lea -0x8(%ebp),%esp
10f382: 5e pop %esi
10f383: 5f pop %edi
10f384: c9 leave
10f385: c3 ret
0010f388 <rtems_rate_monotonic_get_status>:
rtems_status_code rtems_rate_monotonic_get_status(
Objects_Id id,
rtems_rate_monotonic_period_status *status
)
{
10f388: 55 push %ebp
10f389: 89 e5 mov %esp,%ebp
10f38b: 57 push %edi
10f38c: 56 push %esi
10f38d: 53 push %ebx
10f38e: 83 ec 1c sub $0x1c,%esp
10f391: 8b 75 0c mov 0xc(%ebp),%esi
Objects_Locations location;
Rate_monotonic_Control *the_period;
if ( !status )
10f394: b8 09 00 00 00 mov $0x9,%eax
10f399: 85 f6 test %esi,%esi
10f39b: 0f 84 91 00 00 00 je 10f432 <rtems_rate_monotonic_get_status+0xaa><== NEVER TAKEN
10f3a1: 50 push %eax
10f3a2: 8d 45 f0 lea -0x10(%ebp),%eax
10f3a5: 50 push %eax
10f3a6: ff 75 08 pushl 0x8(%ebp)
10f3a9: 68 44 1b 12 00 push $0x121b44
10f3ae: e8 11 ca ff ff call 10bdc4 <_Objects_Get>
10f3b3: 89 c7 mov %eax,%edi
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
10f3b5: 83 c4 10 add $0x10,%esp
10f3b8: b8 04 00 00 00 mov $0x4,%eax
10f3bd: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
10f3c1: 75 6f jne 10f432 <rtems_rate_monotonic_get_status+0xaa>
case OBJECTS_LOCAL:
status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0);
10f3c3: 8b 47 50 mov 0x50(%edi),%eax
10f3c6: 31 d2 xor %edx,%edx
10f3c8: 85 c0 test %eax,%eax
10f3ca: 74 03 je 10f3cf <rtems_rate_monotonic_get_status+0x47><== NEVER TAKEN
10f3cc: 8b 50 08 mov 0x8(%eax),%edx
10f3cf: 89 16 mov %edx,(%esi)
status->state = the_period->state;
10f3d1: 8b 47 38 mov 0x38(%edi),%eax
10f3d4: 89 46 04 mov %eax,0x4(%esi)
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
10f3d7: 85 c0 test %eax,%eax
10f3d9: 75 1e jne 10f3f9 <rtems_rate_monotonic_get_status+0x71>
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
status->since_last_period.tv_sec = 0;
10f3db: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi)
status->since_last_period.tv_nsec = 0;
10f3e2: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
#else
status->since_last_period = 0;
#endif
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
status->executed_since_last_period.tv_sec = 0;
10f3e9: c7 46 10 00 00 00 00 movl $0x0,0x10(%esi)
status->executed_since_last_period.tv_nsec = 0;
10f3f0: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi)
10f3f7: eb 32 jmp 10f42b <rtems_rate_monotonic_get_status+0xa3>
* This lets them share one single invocation of _TOD_Get_uptime().
*/
#if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \
defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS)
struct timespec uptime;
_TOD_Get_uptime( &uptime );
10f3f9: 83 ec 0c sub $0xc,%esp
10f3fc: 8d 5d e8 lea -0x18(%ebp),%ebx
10f3ff: 53 push %ebx
10f400: e8 57 c1 ff ff call 10b55c <_TOD_Get_uptime>
#endif
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
_Timespec_Subtract(
10f405: 83 c4 0c add $0xc,%esp
10f408: 8d 46 08 lea 0x8(%esi),%eax
10f40b: 50 push %eax
10f40c: 53 push %ebx
10f40d: 8d 47 44 lea 0x44(%edi),%eax
10f410: 50 push %eax
10f411: e8 86 de ff ff call 10d29c <_Timespec_Subtract>
status->since_last_period =
_Watchdog_Ticks_since_boot - the_period->time_at_period;
#endif
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
_Timespec_Subtract(
10f416: 83 c4 0c add $0xc,%esp
10f419: 8d 46 10 lea 0x10(%esi),%eax
10f41c: 50 push %eax
10f41d: 53 push %ebx
10f41e: 68 04 1d 12 00 push $0x121d04
10f423: e8 74 de ff ff call 10d29c <_Timespec_Subtract>
10f428: 83 c4 10 add $0x10,%esp
the_period->owner->cpu_time_used -
the_period->owner_executed_at_period;
#endif
}
_Thread_Enable_dispatch();
10f42b: e8 54 d1 ff ff call 10c584 <_Thread_Enable_dispatch>
10f430: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10f432: 8d 65 f4 lea -0xc(%ebp),%esp
10f435: 5b pop %ebx
10f436: 5e pop %esi
10f437: 5f pop %edi
10f438: c9 leave
10f439: c3 ret
00109f7e <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
Objects_Id id,
rtems_interval length
)
{
109f7e: 55 push %ebp
109f7f: 89 e5 mov %esp,%ebp
109f81: 57 push %edi
109f82: 56 push %esi
109f83: 53 push %ebx
109f84: 83 ec 20 sub $0x20,%esp
109f87: 8b 7d 0c mov 0xc(%ebp),%edi
/**
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory
109f8a: 8d 45 f0 lea -0x10(%ebp),%eax
109f8d: 50 push %eax
109f8e: ff 75 08 pushl 0x8(%ebp)
109f91: 68 44 1b 12 00 push $0x121b44
109f96: e8 29 1e 00 00 call 10bdc4 <_Objects_Get>
109f9b: 89 c3 mov %eax,%ebx
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
109f9d: 83 c4 10 add $0x10,%esp
109fa0: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
109fa4: 0f 85 44 01 00 00 jne 10a0ee <rtems_rate_monotonic_period+0x170>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
109faa: 8b 40 50 mov 0x50(%eax),%eax
109fad: 3b 05 fc 1c 12 00 cmp 0x121cfc,%eax
109fb3: 74 0f je 109fc4 <rtems_rate_monotonic_period+0x46>
_Thread_Enable_dispatch();
109fb5: e8 ca 25 00 00 call 10c584 <_Thread_Enable_dispatch>
109fba: bb 17 00 00 00 mov $0x17,%ebx
109fbf: e9 2f 01 00 00 jmp 10a0f3 <rtems_rate_monotonic_period+0x175>
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
109fc4: 85 ff test %edi,%edi
109fc6: 75 21 jne 109fe9 <rtems_rate_monotonic_period+0x6b>
switch ( the_period->state ) {
109fc8: 8b 43 38 mov 0x38(%ebx),%eax
109fcb: bb 0b 00 00 00 mov $0xb,%ebx
109fd0: 85 c0 test %eax,%eax
109fd2: 74 0b je 109fdf <rtems_rate_monotonic_period+0x61>
109fd4: 83 e8 03 sub $0x3,%eax
109fd7: 83 f8 02 cmp $0x2,%eax
109fda: 19 db sbb %ebx,%ebx
109fdc: 83 e3 06 and $0x6,%ebx
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
109fdf: e8 a0 25 00 00 call 10c584 <_Thread_Enable_dispatch>
109fe4: e9 0a 01 00 00 jmp 10a0f3 <rtems_rate_monotonic_period+0x175>
return( return_value );
}
_ISR_Disable( level );
109fe9: 9c pushf
109fea: fa cli
109feb: 5e pop %esi
switch ( the_period->state ) {
109fec: 8b 43 38 mov 0x38(%ebx),%eax
109fef: 83 f8 02 cmp $0x2,%eax
109ff2: 74 60 je 10a054 <rtems_rate_monotonic_period+0xd6>
109ff4: 83 f8 04 cmp $0x4,%eax
109ff7: 0f 84 ba 00 00 00 je 10a0b7 <rtems_rate_monotonic_period+0x139>
109ffd: 85 c0 test %eax,%eax
109fff: 0f 85 e9 00 00 00 jne 10a0ee <rtems_rate_monotonic_period+0x170><== NEVER TAKEN
case RATE_MONOTONIC_INACTIVE: {
_ISR_Enable( level );
10a005: 56 push %esi
10a006: 9d popf
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
10a007: 83 ec 0c sub $0xc,%esp
10a00a: 53 push %ebx
10a00b: e8 c8 fd ff ff call 109dd8 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
10a010: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx)
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
10a017: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
* @param[in] the_heap is the heap to operate upon
10a01e: c7 43 2c 14 a3 10 00 movl $0x10a314,0x2c(%ebx)
* @param[in] starting_address is the starting address of the memory for
10a025: 8b 45 08 mov 0x8(%ebp),%eax
10a028: 89 43 30 mov %eax,0x30(%ebx)
* the heap
10a02b: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx)
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
10a032: 89 7b 4c mov %edi,0x4c(%ebx)
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
Heap_Control *the_heap,
10a035: 89 7b 1c mov %edi,0x1c(%ebx)
void *starting_address,
size_t *size
10a038: 58 pop %eax
10a039: 5a pop %edx
10a03a: 8d 43 10 lea 0x10(%ebx),%eax
10a03d: 50 push %eax
10a03e: 68 1c 1d 12 00 push $0x121d1c
10a043: e8 98 34 00 00 call 10d4e0 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
10a048: e8 37 25 00 00 call 10c584 <_Thread_Enable_dispatch>
10a04d: 31 db xor %ebx,%ebx
10a04f: e9 95 00 00 00 jmp 10a0e9 <rtems_rate_monotonic_period+0x16b>
case RATE_MONOTONIC_ACTIVE:
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
10a054: 83 ec 0c sub $0xc,%esp
10a057: 53 push %ebx
10a058: e8 e3 fd ff ff call 109e40 <_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;
10a05d: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx)
the_period->next_length = length;
10a064: 89 7b 4c mov %edi,0x4c(%ebx)
_ISR_Enable( level );
10a067: 56 push %esi
10a068: 9d popf
_Thread_Executing->Wait.id = the_period->Object.id;
10a069: 8b 15 fc 1c 12 00 mov 0x121cfc,%edx
10a06f: 8b 43 08 mov 0x8(%ebx),%eax
10a072: 89 42 20 mov %eax,0x20(%edx)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10a075: 5e pop %esi
10a076: 5f pop %edi
10a077: 68 00 40 00 00 push $0x4000
10a07c: 52 push %edx
10a07d: e8 1e 2d 00 00 call 10cda0 <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
10a082: 9c pushf
10a083: fa cli
10a084: 58 pop %eax
local_state = the_period->state;
10a085: 8b 53 38 mov 0x38(%ebx),%edx
the_period->state = RATE_MONOTONIC_ACTIVE;
10a088: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx)
_ISR_Enable( level );
10a08f: 50 push %eax
10a090: 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 )
10a091: 83 c4 10 add $0x10,%esp
10a094: 83 fa 03 cmp $0x3,%edx
10a097: 75 15 jne 10a0ae <rtems_rate_monotonic_period+0x130><== ALWAYS TAKEN
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10a099: 51 push %ecx <== NOT EXECUTED
10a09a: 51 push %ecx <== NOT EXECUTED
10a09b: 68 00 40 00 00 push $0x4000 <== NOT EXECUTED
10a0a0: ff 35 fc 1c 12 00 pushl 0x121cfc <== NOT EXECUTED
10a0a6: e8 59 21 00 00 call 10c204 <_Thread_Clear_state> <== NOT EXECUTED
10a0ab: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
_Thread_Enable_dispatch();
10a0ae: e8 d1 24 00 00 call 10c584 <_Thread_Enable_dispatch>
10a0b3: 31 db xor %ebx,%ebx
10a0b5: eb 3c jmp 10a0f3 <rtems_rate_monotonic_period+0x175>
case RATE_MONOTONIC_EXPIRED:
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
10a0b7: 83 ec 0c sub $0xc,%esp
10a0ba: 53 push %ebx
10a0bb: e8 80 fd ff ff call 109e40 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
10a0c0: 56 push %esi
10a0c1: 9d popf
the_period->state = RATE_MONOTONIC_ACTIVE;
10a0c2: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx)
the_period->next_length = length;
10a0c9: 89 7b 4c mov %edi,0x4c(%ebx)
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
Heap_Control *the_heap,
10a0cc: 89 7b 1c mov %edi,0x1c(%ebx)
void *starting_address,
size_t *size
10a0cf: 58 pop %eax
10a0d0: 5a pop %edx
10a0d1: 8d 43 10 lea 0x10(%ebx),%eax
10a0d4: 50 push %eax
10a0d5: 68 1c 1d 12 00 push $0x121d1c
10a0da: e8 01 34 00 00 call 10d4e0 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
10a0df: e8 a0 24 00 00 call 10c584 <_Thread_Enable_dispatch>
10a0e4: bb 06 00 00 00 mov $0x6,%ebx
10a0e9: 83 c4 10 add $0x10,%esp
10a0ec: eb 05 jmp 10a0f3 <rtems_rate_monotonic_period+0x175>
return RTEMS_TIMEOUT;
10a0ee: bb 04 00 00 00 mov $0x4,%ebx
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a0f3: 89 d8 mov %ebx,%eax
10a0f5: 8d 65 f4 lea -0xc(%ebp),%esp
10a0f8: 5b pop %ebx
10a0f9: 5e pop %esi
10a0fa: 5f pop %edi
10a0fb: c9 leave
10a0fc: c3 ret
0010a100 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
10a100: 55 push %ebp
10a101: 89 e5 mov %esp,%ebp
10a103: 57 push %edi
10a104: 56 push %esi
10a105: 53 push %ebx
10a106: 83 ec 6c sub $0x6c,%esp
10a109: 8b 75 0c mov 0xc(%ebp),%esi
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
10a10c: 85 f6 test %esi,%esi
10a10e: 0f 84 44 01 00 00 je 10a258 <rtems_rate_monotonic_report_statistics_with_plugin+0x158><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
10a114: 51 push %ecx
10a115: 51 push %ecx
10a116: 68 e4 a9 11 00 push $0x11a9e4
10a11b: ff 75 08 pushl 0x8(%ebp)
10a11e: ff d6 call *%esi
#if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS)
(*print)( context, "--- CPU times are in seconds ---\n" );
10a120: 58 pop %eax
10a121: 5a pop %edx
10a122: 68 02 aa 11 00 push $0x11aa02
10a127: ff 75 08 pushl 0x8(%ebp)
10a12a: ff d6 call *%esi
#endif
#if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS)
(*print)( context, "--- Wall times are in seconds ---\n" );
10a12c: 5f pop %edi
10a12d: 58 pop %eax
10a12e: 68 24 aa 11 00 push $0x11aa24
10a133: ff 75 08 pushl 0x8(%ebp)
10a136: ff d6 call *%esi
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
10a138: 59 pop %ecx
10a139: 5b pop %ebx
10a13a: 68 47 aa 11 00 push $0x11aa47
10a13f: ff 75 08 pushl 0x8(%ebp)
10a142: ff d6 call *%esi
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
10a144: 58 pop %eax
10a145: 5a pop %edx
10a146: 68 92 aa 11 00 push $0x11aa92
10a14b: ff 75 08 pushl 0x8(%ebp)
10a14e: ff d6 call *%esi
/*
* 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 ;
10a150: 8b 3d 4c 1b 12 00 mov 0x121b4c,%edi
10a156: 83 c4 10 add $0x10,%esp
10a159: e9 ee 00 00 00 jmp 10a24c <rtems_rate_monotonic_report_statistics_with_plugin+0x14c>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
10a15e: 50 push %eax
10a15f: 50 push %eax
10a160: 8d 45 94 lea -0x6c(%ebp),%eax
10a163: 50 push %eax
10a164: 57 push %edi
10a165: e8 ce 51 00 00 call 10f338 <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
10a16a: 83 c4 10 add $0x10,%esp
10a16d: 85 c0 test %eax,%eax
10a16f: 0f 85 d6 00 00 00 jne 10a24b <rtems_rate_monotonic_report_statistics_with_plugin+0x14b>
continue;
/* If the above passed, so should this but check it anyway */
status = rtems_rate_monotonic_get_status( id, &the_status );
10a175: 50 push %eax
10a176: 50 push %eax
10a177: 8d 55 cc lea -0x34(%ebp),%edx
10a17a: 52 push %edx
10a17b: 57 push %edi
10a17c: e8 07 52 00 00 call 10f388 <rtems_rate_monotonic_get_status>
#if defined(RTEMS_DEBUG)
if ( status != RTEMS_SUCCESSFUL )
continue;
#endif
name[ 0 ] = '\0';
10a181: c6 45 ef 00 movb $0x0,-0x11(%ebp)
if ( the_status.owner ) {
10a185: 8b 55 cc mov -0x34(%ebp),%edx
10a188: 83 c4 10 add $0x10,%esp
10a18b: 85 d2 test %edx,%edx
10a18d: 74 10 je 10a19f <rtems_rate_monotonic_report_statistics_with_plugin+0x9f><== NEVER TAKEN
rtems_object_get_name( the_status.owner, sizeof(name), name );
10a18f: 50 push %eax
10a190: 8d 45 ef lea -0x11(%ebp),%eax
10a193: 50 push %eax
10a194: 6a 05 push $0x5
10a196: 52 push %edx
10a197: e8 04 02 00 00 call 10a3a0 <rtems_object_get_name>
10a19c: 83 c4 10 add $0x10,%esp
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
10a19f: 53 push %ebx
10a1a0: 53 push %ebx
10a1a1: ff 75 98 pushl -0x68(%ebp)
10a1a4: ff 75 94 pushl -0x6c(%ebp)
10a1a7: 8d 45 ef lea -0x11(%ebp),%eax
10a1aa: 50 push %eax
10a1ab: 57 push %edi
10a1ac: 68 de aa 11 00 push $0x11aade
10a1b1: ff 75 08 pushl 0x8(%ebp)
10a1b4: ff d6 call *%esi
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
10a1b6: 8b 45 94 mov -0x6c(%ebp),%eax
10a1b9: 83 c4 20 add $0x20,%esp
10a1bc: 85 c0 test %eax,%eax
10a1be: 75 11 jne 10a1d1 <rtems_rate_monotonic_report_statistics_with_plugin+0xd1>
(*print)( context, "\n" );
10a1c0: 51 push %ecx
10a1c1: 51 push %ecx
10a1c2: 68 91 ad 11 00 push $0x11ad91
10a1c7: ff 75 08 pushl 0x8(%ebp)
10a1ca: ff d6 call *%esi
10a1cc: 83 c4 10 add $0x10,%esp
10a1cf: eb 7a jmp 10a24b <rtems_rate_monotonic_report_statistics_with_plugin+0x14b>
*/
{
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
struct timespec cpu_average;
_Timespec_Divide_by_integer(
10a1d1: 52 push %edx
10a1d2: 8d 55 e4 lea -0x1c(%ebp),%edx
10a1d5: 52 push %edx
10a1d6: 50 push %eax
10a1d7: 8d 45 ac lea -0x54(%ebp),%eax
10a1da: 50 push %eax
10a1db: e8 f8 2f 00 00 call 10d1d8 <_Timespec_Divide_by_integer>
&the_stats.total_cpu_time,
the_stats.count,
&cpu_average
);
(*print)( context,
10a1e0: 8b 45 e8 mov -0x18(%ebp),%eax
10a1e3: bb e8 03 00 00 mov $0x3e8,%ebx
10a1e8: 99 cltd
10a1e9: f7 fb idiv %ebx
10a1eb: 50 push %eax
10a1ec: ff 75 e4 pushl -0x1c(%ebp)
10a1ef: 8b 45 a8 mov -0x58(%ebp),%eax
10a1f2: 99 cltd
10a1f3: f7 fb idiv %ebx
10a1f5: 50 push %eax
10a1f6: ff 75 a4 pushl -0x5c(%ebp)
10a1f9: 8b 45 a0 mov -0x60(%ebp),%eax
10a1fc: 99 cltd
10a1fd: f7 fb idiv %ebx
10a1ff: 50 push %eax
10a200: ff 75 9c pushl -0x64(%ebp)
10a203: 68 f5 aa 11 00 push $0x11aaf5
10a208: ff 75 08 pushl 0x8(%ebp)
10a20b: ff d6 call *%esi
* print Wall time part of statistics
*/
{
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
struct timespec wall_average;
_Timespec_Divide_by_integer(
10a20d: 83 c4 2c add $0x2c,%esp
10a210: 8d 45 e4 lea -0x1c(%ebp),%eax
10a213: 50 push %eax
10a214: ff 75 94 pushl -0x6c(%ebp)
10a217: 8d 45 c4 lea -0x3c(%ebp),%eax
10a21a: 50 push %eax
10a21b: e8 b8 2f 00 00 call 10d1d8 <_Timespec_Divide_by_integer>
&the_stats.total_wall_time,
the_stats.count,
&wall_average
);
(*print)( context,
10a220: 8b 45 e8 mov -0x18(%ebp),%eax
10a223: 99 cltd
10a224: f7 fb idiv %ebx
10a226: 50 push %eax
10a227: ff 75 e4 pushl -0x1c(%ebp)
10a22a: 8b 45 c0 mov -0x40(%ebp),%eax
10a22d: 99 cltd
10a22e: f7 fb idiv %ebx
10a230: 50 push %eax
10a231: ff 75 bc pushl -0x44(%ebp)
10a234: 8b 45 b8 mov -0x48(%ebp),%eax
10a237: 99 cltd
10a238: f7 fb idiv %ebx
10a23a: 50 push %eax
10a23b: ff 75 b4 pushl -0x4c(%ebp)
10a23e: 68 14 ab 11 00 push $0x11ab14
10a243: ff 75 08 pushl 0x8(%ebp)
10a246: ff d6 call *%esi
10a248: 83 c4 30 add $0x30,%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++ ) {
10a24b: 47 inc %edi
/*
* 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 ;
10a24c: 3b 3d 50 1b 12 00 cmp 0x121b50,%edi
10a252: 0f 86 06 ff ff ff jbe 10a15e <rtems_rate_monotonic_report_statistics_with_plugin+0x5e>
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
10a258: 8d 65 f4 lea -0xc(%ebp),%esp
10a25b: 5b pop %ebx
10a25c: 5e pop %esi
10a25d: 5f pop %edi
10a25e: c9 leave
10a25f: c3 ret
00111ac0 <rtems_region_extend>:
rtems_status_code rtems_region_extend(
Objects_Id id,
void *starting_address,
uint32_t length
)
{
111ac0: 55 push %ebp
111ac1: 89 e5 mov %esp,%ebp
111ac3: 57 push %edi
111ac4: 56 push %esi
111ac5: 53 push %ebx
111ac6: 83 ec 1c sub $0x1c,%esp
111ac9: 8b 7d 0c mov 0xc(%ebp),%edi
Heap_Extend_status heap_status;
Objects_Locations location;
rtems_status_code return_status = RTEMS_INTERNAL_ERROR;
Region_Control *the_region;
if ( !starting_address )
111acc: bb 09 00 00 00 mov $0x9,%ebx
111ad1: 85 ff test %edi,%edi
111ad3: 0f 84 82 00 00 00 je 111b5b <rtems_region_extend+0x9b><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
111ad9: 83 ec 0c sub $0xc,%esp
111adc: ff 35 f0 41 13 00 pushl 0x1341f0
111ae2: e8 29 1f 00 00 call 113a10 <_API_Mutex_Lock>
/**
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
111ae7: 83 c4 0c add $0xc,%esp
111aea: 8d 45 ec lea -0x14(%ebp),%eax
111aed: 50 push %eax
111aee: ff 75 08 pushl 0x8(%ebp)
111af1: 68 ec 3f 13 00 push $0x133fec
111af6: e8 c1 34 00 00 call 114fbc <_Objects_Get_no_protection>
111afb: 89 c6 mov %eax,%esi
the_region = _Region_Get( id, &location );
switch ( location ) {
111afd: 83 c4 10 add $0x10,%esp
111b00: 8b 45 ec mov -0x14(%ebp),%eax
111b03: 85 c0 test %eax,%eax
111b05: 74 08 je 111b0f <rtems_region_extend+0x4f>
111b07: bb 04 00 00 00 mov $0x4,%ebx
111b0c: 48 dec %eax
111b0d: eb 25 jmp 111b34 <rtems_region_extend+0x74>
case OBJECTS_LOCAL:
heap_status = _Heap_Extend(
111b0f: 8d 45 f0 lea -0x10(%ebp),%eax
111b12: 50 push %eax
111b13: ff 75 10 pushl 0x10(%ebp)
111b16: 57 push %edi
111b17: 8d 46 68 lea 0x68(%esi),%eax
111b1a: 50 push %eax
111b1b: e8 ec 28 00 00 call 11440c <_Heap_Extend>
starting_address,
length,
&amount_extended
);
switch ( heap_status ) {
111b20: 83 c4 10 add $0x10,%esp
111b23: bb 09 00 00 00 mov $0x9,%ebx
111b28: 83 f8 01 cmp $0x1,%eax
111b2b: 74 1d je 111b4a <rtems_region_extend+0x8a>
111b2d: 72 09 jb 111b38 <rtems_region_extend+0x78>
case HEAP_EXTEND_SUCCESSFUL:
the_region->length += amount_extended;
the_region->maximum_segment_size += amount_extended;
return_status = RTEMS_SUCCESSFUL;
break;
111b2f: b3 18 mov $0x18,%bl
starting_address,
length,
&amount_extended
);
switch ( heap_status ) {
111b31: 83 f8 02 cmp $0x2,%eax
111b34: 75 0f jne 111b45 <rtems_region_extend+0x85><== NEVER TAKEN
111b36: eb 12 jmp 111b4a <rtems_region_extend+0x8a>
case HEAP_EXTEND_SUCCESSFUL:
the_region->length += amount_extended;
111b38: 8b 45 f0 mov -0x10(%ebp),%eax
111b3b: 01 46 54 add %eax,0x54(%esi)
the_region->maximum_segment_size += amount_extended;
111b3e: 01 46 5c add %eax,0x5c(%esi)
111b41: 31 db xor %ebx,%ebx
111b43: eb 05 jmp 111b4a <rtems_region_extend+0x8a>
return_status = RTEMS_SUCCESSFUL;
break;
111b45: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
111b4a: 83 ec 0c sub $0xc,%esp
111b4d: ff 35 f0 41 13 00 pushl 0x1341f0
111b53: e8 00 1f 00 00 call 113a58 <_API_Mutex_Unlock>
111b58: 83 c4 10 add $0x10,%esp
return return_status;
}
111b5b: 89 d8 mov %ebx,%eax
111b5d: 8d 65 f4 lea -0xc(%ebp),%esp
111b60: 5b pop %ebx
111b61: 5e pop %esi
111b62: 5f pop %edi
111b63: c9 leave
111b64: c3 ret
00111c80 <rtems_region_get_segment>:
uint32_t size,
rtems_option option_set,
rtems_interval timeout,
void **segment
)
{
111c80: 55 push %ebp
111c81: 89 e5 mov %esp,%ebp
111c83: 57 push %edi
111c84: 56 push %esi
111c85: 53 push %ebx
111c86: 83 ec 1c sub $0x1c,%esp
Objects_Locations location;
rtems_status_code return_status = RTEMS_INTERNAL_ERROR;
register Region_Control *the_region;
void *the_segment;
if ( !segment )
111c89: bb 09 00 00 00 mov $0x9,%ebx
111c8e: 83 7d 18 00 cmpl $0x0,0x18(%ebp)
111c92: 0f 84 fd 00 00 00 je 111d95 <rtems_region_get_segment+0x115><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
*segment = NULL;
111c98: 8b 45 18 mov 0x18(%ebp),%eax
111c9b: c7 00 00 00 00 00 movl $0x0,(%eax)
if ( size == 0 )
111ca1: bb 08 00 00 00 mov $0x8,%ebx
111ca6: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
111caa: 0f 84 e5 00 00 00 je 111d95 <rtems_region_get_segment+0x115><== NEVER TAKEN
return RTEMS_INVALID_SIZE;
_RTEMS_Lock_allocator();
111cb0: 83 ec 0c sub $0xc,%esp
111cb3: ff 35 f0 41 13 00 pushl 0x1341f0
111cb9: e8 52 1d 00 00 call 113a10 <_API_Mutex_Lock>
executing = _Thread_Executing;
111cbe: 8b 3d f8 41 13 00 mov 0x1341f8,%edi
111cc4: 83 c4 0c add $0xc,%esp
111cc7: 8d 45 f0 lea -0x10(%ebp),%eax
111cca: 50 push %eax
111ccb: ff 75 08 pushl 0x8(%ebp)
111cce: 68 ec 3f 13 00 push $0x133fec
111cd3: e8 e4 32 00 00 call 114fbc <_Objects_Get_no_protection>
111cd8: 89 c6 mov %eax,%esi
the_region = _Region_Get( id, &location );
switch ( location ) {
111cda: 83 c4 10 add $0x10,%esp
111cdd: 8b 45 f0 mov -0x10(%ebp),%eax
111ce0: 85 c0 test %eax,%eax
111ce2: 74 14 je 111cf8 <rtems_region_get_segment+0x78>
111ce4: 31 db xor %ebx,%ebx
111ce6: 83 f8 01 cmp $0x1,%eax
111ce9: 0f 95 c3 setne %bl
111cec: 4b dec %ebx
111ced: 83 e3 eb and $0xffffffeb,%ebx
111cf0: 83 c3 19 add $0x19,%ebx
111cf3: e9 8c 00 00 00 jmp 111d84 <rtems_region_get_segment+0x104>
case OBJECTS_LOCAL:
if ( size > the_region->maximum_segment_size )
111cf8: bb 08 00 00 00 mov $0x8,%ebx
111cfd: 8b 55 0c mov 0xc(%ebp),%edx
111d00: 3b 56 5c cmp 0x5c(%esi),%edx
111d03: 77 7f ja 111d84 <rtems_region_get_segment+0x104>
/**
* This function attempts to allocate a block of @a size bytes from
* @a the_heap. If insufficient memory is free in @a the_heap to allocate
* a block of the requested size, then NULL is returned.
*
111d05: 50 push %eax
111d06: 50 push %eax
111d07: ff 75 0c pushl 0xc(%ebp)
111d0a: 8d 46 68 lea 0x68(%esi),%eax
111d0d: 50 push %eax
111d0e: e8 8d 26 00 00 call 1143a0 <_Heap_Allocate>
the_segment = _Region_Allocate_segment( the_region, size );
_Region_Debug_Walk( the_region, 2 );
if ( the_segment ) {
111d13: 83 c4 10 add $0x10,%esp
111d16: 85 c0 test %eax,%eax
111d18: 74 0c je 111d26 <rtems_region_get_segment+0xa6>
the_region->number_of_used_blocks += 1;
111d1a: ff 46 64 incl 0x64(%esi)
*segment = the_segment;
111d1d: 8b 55 18 mov 0x18(%ebp),%edx
111d20: 89 02 mov %eax,(%edx)
111d22: 31 db xor %ebx,%ebx
111d24: eb 5e jmp 111d84 <rtems_region_get_segment+0x104>
return_status = RTEMS_SUCCESSFUL;
}
else if ( _Options_Is_no_wait( option_set ) ) {
111d26: bb 0d 00 00 00 mov $0xd,%ebx
111d2b: f6 45 10 01 testb $0x1,0x10(%ebp)
111d2f: 75 53 jne 111d84 <rtems_region_get_segment+0x104>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
111d31: a1 38 41 13 00 mov 0x134138,%eax
111d36: 40 inc %eax
111d37: a3 38 41 13 00 mov %eax,0x134138
* 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();
111d3c: 83 ec 0c sub $0xc,%esp
111d3f: ff 35 f0 41 13 00 pushl 0x1341f0
111d45: e8 0e 1d 00 00 call 113a58 <_API_Mutex_Unlock>
executing->Wait.queue = &the_region->Wait_queue;
111d4a: 8d 46 10 lea 0x10(%esi),%eax
111d4d: 89 47 44 mov %eax,0x44(%edi)
executing->Wait.id = id;
111d50: 8b 55 08 mov 0x8(%ebp),%edx
111d53: 89 57 20 mov %edx,0x20(%edi)
executing->Wait.count = size;
111d56: 8b 55 0c mov 0xc(%ebp),%edx
111d59: 89 57 24 mov %edx,0x24(%edi)
executing->Wait.return_argument = segment;
111d5c: 8b 55 18 mov 0x18(%ebp),%edx
111d5f: 89 57 28 mov %edx,0x28(%edi)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
* This routine grows @a the_heap memory area using the size bytes which
111d62: c7 46 40 01 00 00 00 movl $0x1,0x40(%esi)
_Thread_queue_Enter_critical_section( &the_region->Wait_queue );
_Thread_queue_Enqueue( &the_region->Wait_queue, timeout );
111d69: 83 c4 0c add $0xc,%esp
111d6c: 68 0c 5f 11 00 push $0x115f0c
111d71: ff 75 14 pushl 0x14(%ebp)
111d74: 50 push %eax
111d75: e8 8e 3e 00 00 call 115c08 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
111d7a: e8 39 3a 00 00 call 1157b8 <_Thread_Enable_dispatch>
return (rtems_status_code) executing->Wait.return_code;
111d7f: 8b 5f 34 mov 0x34(%edi),%ebx
111d82: eb 0e jmp 111d92 <rtems_region_get_segment+0x112>
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
111d84: 83 ec 0c sub $0xc,%esp
111d87: ff 35 f0 41 13 00 pushl 0x1341f0
111d8d: e8 c6 1c 00 00 call 113a58 <_API_Mutex_Unlock>
111d92: 83 c4 10 add $0x10,%esp
return return_status;
}
111d95: 89 d8 mov %ebx,%eax
111d97: 8d 65 f4 lea -0xc(%ebp),%esp
111d9a: 5b pop %ebx
111d9b: 5e pop %esi
111d9c: 5f pop %edi
111d9d: c9 leave
111d9e: c3 ret
00111e50 <rtems_region_resize_segment>:
Objects_Id id,
void *segment,
size_t size,
size_t *old_size
)
{
111e50: 55 push %ebp
111e51: 89 e5 mov %esp,%ebp
111e53: 57 push %edi
111e54: 56 push %esi
111e55: 53 push %ebx
111e56: 83 ec 1c sub $0x1c,%esp
111e59: 8b 7d 14 mov 0x14(%ebp),%edi
uint32_t osize;
rtems_status_code return_status = RTEMS_INTERNAL_ERROR;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
111e5c: 85 ff test %edi,%edi
111e5e: 0f 84 aa 00 00 00 je 111f0e <rtems_region_resize_segment+0xbe>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
111e64: 83 ec 0c sub $0xc,%esp
111e67: ff 35 f0 41 13 00 pushl 0x1341f0
111e6d: e8 9e 1b 00 00 call 113a10 <_API_Mutex_Lock>
111e72: 83 c4 0c add $0xc,%esp
111e75: 8d 45 ec lea -0x14(%ebp),%eax
111e78: 50 push %eax
111e79: ff 75 08 pushl 0x8(%ebp)
111e7c: 68 ec 3f 13 00 push $0x133fec
111e81: e8 36 31 00 00 call 114fbc <_Objects_Get_no_protection>
111e86: 89 c3 mov %eax,%ebx
the_region = _Region_Get( id, &location );
switch ( location ) {
111e88: 83 c4 10 add $0x10,%esp
111e8b: 8b 45 ec mov -0x14(%ebp),%eax
111e8e: 85 c0 test %eax,%eax
111e90: 74 1f je 111eb1 <rtems_region_resize_segment+0x61>
111e92: 31 db xor %ebx,%ebx
111e94: 83 f8 01 cmp $0x1,%eax
111e97: 0f 95 c3 setne %bl
111e9a: 4b dec %ebx
111e9b: 83 e3 eb and $0xffffffeb,%ebx
111e9e: 83 c3 19 add $0x19,%ebx
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
111ea1: 83 ec 0c sub $0xc,%esp
111ea4: ff 35 f0 41 13 00 pushl 0x1341f0
111eaa: e8 a9 1b 00 00 call 113a58 <_API_Mutex_Unlock>
111eaf: eb 39 jmp 111eea <rtems_region_resize_segment+0x9a>
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 7 );
status = _Heap_Resize_block(
111eb1: 83 ec 0c sub $0xc,%esp
111eb4: 8d 45 f0 lea -0x10(%ebp),%eax
111eb7: 50 push %eax
111eb8: 8d 45 e8 lea -0x18(%ebp),%eax
111ebb: 50 push %eax
111ebc: ff 75 10 pushl 0x10(%ebp)
111ebf: ff 75 0c pushl 0xc(%ebp)
111ec2: 8d 43 68 lea 0x68(%ebx),%eax
111ec5: 50 push %eax
111ec6: e8 b9 29 00 00 call 114884 <_Heap_Resize_block>
111ecb: 89 c6 mov %eax,%esi
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
111ecd: 8b 45 e8 mov -0x18(%ebp),%eax
111ed0: 89 07 mov %eax,(%edi)
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 )
111ed2: 83 c4 20 add $0x20,%esp
111ed5: 85 f6 test %esi,%esi
111ed7: 75 16 jne 111eef <rtems_region_resize_segment+0x9f><== ALWAYS TAKEN
111ed9: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED
111edd: 74 10 je 111eef <rtems_region_resize_segment+0x9f><== NOT EXECUTED
_Region_Process_queue( the_region ); /* unlocks allocator */
111edf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
111ee2: 53 push %ebx <== NOT EXECUTED
111ee3: e8 8c 68 00 00 call 118774 <_Region_Process_queue> <== NOT EXECUTED
111ee8: 31 db xor %ebx,%ebx <== NOT EXECUTED
111eea: 83 c4 10 add $0x10,%esp
111eed: eb 24 jmp 111f13 <rtems_region_resize_segment+0xc3>
else
_RTEMS_Unlock_allocator();
111eef: 83 ec 0c sub $0xc,%esp
111ef2: ff 35 f0 41 13 00 pushl 0x1341f0
111ef8: e8 5b 1b 00 00 call 113a58 <_API_Mutex_Unlock>
return
111efd: 83 c4 10 add $0x10,%esp
111f00: 31 db xor %ebx,%ebx
111f02: 85 f6 test %esi,%esi
111f04: 74 0d je 111f13 <rtems_region_resize_segment+0xc3><== NEVER TAKEN
111f06: bb 0d 00 00 00 mov $0xd,%ebx
111f0b: 4e dec %esi
111f0c: 74 05 je 111f13 <rtems_region_resize_segment+0xc3><== NEVER TAKEN
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
return return_status;
111f0e: bb 09 00 00 00 mov $0x9,%ebx
}
111f13: 89 d8 mov %ebx,%eax
111f15: 8d 65 f4 lea -0xc(%ebp),%esp
111f18: 5b pop %ebx
111f19: 5e pop %esi
111f1a: 5f pop %edi
111f1b: c9 leave
111f1c: c3 ret
00108f40 <rtems_semaphore_create>:
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
108f40: 55 push %ebp
108f41: 89 e5 mov %esp,%ebp
108f43: 57 push %edi
108f44: 56 push %esi
108f45: 53 push %ebx
108f46: 83 ec 2c sub $0x2c,%esp
108f49: 8b 5d 10 mov 0x10(%ebp),%ebx
register Semaphore_Control *the_semaphore;
CORE_mutex_Attributes the_mutex_attributes;
CORE_semaphore_Attributes the_semaphore_attributes;
if ( !rtems_is_name_valid( name ) )
108f4c: b8 03 00 00 00 mov $0x3,%eax
108f51: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
108f55: 0f 84 7f 01 00 00 je 1090da <rtems_semaphore_create+0x19a><== NEVER TAKEN
return RTEMS_INVALID_NAME;
if ( !id )
108f5b: b8 09 00 00 00 mov $0x9,%eax
108f60: 83 7d 18 00 cmpl $0x0,0x18(%ebp)
108f64: 0f 84 70 01 00 00 je 1090da <rtems_semaphore_create+0x19a><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
} else
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
108f6a: 89 da mov %ebx,%edx
108f6c: 81 e2 c0 00 00 00 and $0xc0,%edx
108f72: 74 28 je 108f9c <rtems_semaphore_create+0x5c>
* @param[in] alignment the required alignment
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
108f74: 89 d8 mov %ebx,%eax
108f76: 83 e0 30 and $0x30,%eax
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) ||
108f79: 83 f8 10 cmp $0x10,%eax
108f7c: 74 09 je 108f87 <rtems_semaphore_create+0x47>
108f7e: 83 f8 20 cmp $0x20,%eax
108f81: 0f 85 4e 01 00 00 jne 1090d5 <rtems_semaphore_create+0x195><== NEVER TAKEN
108f87: f6 c3 04 test $0x4,%bl
108f8a: 0f 84 45 01 00 00 je 1090d5 <rtems_semaphore_create+0x195><== NEVER TAKEN
_Attributes_Is_priority( attribute_set ) ) )
return RTEMS_NOT_DEFINED;
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
108f90: 81 fa c0 00 00 00 cmp $0xc0,%edx
108f96: 0f 84 39 01 00 00 je 1090d5 <rtems_semaphore_create+0x195>
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
108f9c: 89 df mov %ebx,%edi
108f9e: 83 e7 30 and $0x30,%edi
108fa1: 74 0f je 108fb2 <rtems_semaphore_create+0x72>
108fa3: b8 0a 00 00 00 mov $0xa,%eax
108fa8: 83 7d 0c 01 cmpl $0x1,0xc(%ebp)
108fac: 0f 87 28 01 00 00 ja 1090da <rtems_semaphore_create+0x19a>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
108fb2: a1 98 d7 11 00 mov 0x11d798,%eax
108fb7: 40 inc %eax
108fb8: a3 98 d7 11 00 mov %eax,0x11d798
#ifdef __cplusplus
extern "C" {
#endif
/**
108fbd: 83 ec 0c sub $0xc,%esp
108fc0: 68 e0 d6 11 00 push $0x11d6e0
108fc5: e8 be 12 00 00 call 10a288 <_Objects_Allocate>
108fca: 89 c6 mov %eax,%esi
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
108fcc: 83 c4 10 add $0x10,%esp
108fcf: 85 c0 test %eax,%eax
108fd1: 75 0f jne 108fe2 <rtems_semaphore_create+0xa2>
_Thread_Enable_dispatch();
108fd3: e8 b4 1e 00 00 call 10ae8c <_Thread_Enable_dispatch>
108fd8: b8 05 00 00 00 mov $0x5,%eax
108fdd: e9 f8 00 00 00 jmp 1090da <rtems_semaphore_create+0x19a>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_semaphore->attribute_set = attribute_set;
108fe2: 89 58 10 mov %ebx,0x10(%eax)
* If it is not a counting semaphore, then it is either a
* simple binary semaphore or a more powerful mutex style binary
* semaphore.
*/
if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
108fe5: 85 ff test %edi,%edi
108fe7: 0f 84 92 00 00 00 je 10907f <rtems_semaphore_create+0x13f>
CORE_mutex_Status mutex_status;
if ( _Attributes_Is_inherit_priority( attribute_set ) )
108fed: f6 c3 40 test $0x40,%bl
108ff0: 74 09 je 108ffb <rtems_semaphore_create+0xbb>
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
108ff2: c7 45 e4 02 00 00 00 movl $0x2,-0x1c(%ebp)
108ff9: eb 18 jmp 109013 <rtems_semaphore_create+0xd3>
else if ( _Attributes_Is_priority_ceiling( attribute_set ) )
108ffb: 84 db test %bl,%bl
108ffd: 79 09 jns 109008 <rtems_semaphore_create+0xc8>
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
108fff: c7 45 e4 03 00 00 00 movl $0x3,-0x1c(%ebp)
109006: eb 0b jmp 109013 <rtems_semaphore_create+0xd3>
else if ( _Attributes_Is_priority( attribute_set ) )
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
109008: 31 c0 xor %eax,%eax
10900a: f6 c3 04 test $0x4,%bl
10900d: 0f 95 c0 setne %al
109010: 89 45 e4 mov %eax,-0x1c(%ebp)
else
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
109013: 83 ff 10 cmp $0x10,%edi
109016: 75 1a jne 109032 <rtems_semaphore_create+0xf2>
the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
109018: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
switch ( the_mutex_attributes.discipline ) {
10901f: 8b 45 e4 mov -0x1c(%ebp),%eax
109022: 83 f8 01 cmp $0x1,%eax
109025: 76 12 jbe 109039 <rtems_semaphore_create+0xf9>
109027: 83 f8 03 cmp $0x3,%eax
10902a: 77 11 ja 10903d <rtems_semaphore_create+0xfd><== NEVER TAKEN
case CORE_MUTEX_DISCIPLINES_PRIORITY:
the_mutex_attributes.only_owner_release = FALSE;
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
the_mutex_attributes.only_owner_release = TRUE;
10902c: c6 45 e0 01 movb $0x1,-0x20(%ebp)
109030: eb 0b jmp 10903d <rtems_semaphore_create+0xfd>
break;
}
} else {
the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
109032: c7 45 dc 02 00 00 00 movl $0x2,-0x24(%ebp)
the_mutex_attributes.only_owner_release = FALSE;
109039: c6 45 e0 00 movb $0x0,-0x20(%ebp)
}
the_mutex_attributes.priority_ceiling = priority_ceiling;
10903d: 8b 45 14 mov 0x14(%ebp),%eax
109040: 89 45 e8 mov %eax,-0x18(%ebp)
mutex_status = _CORE_mutex_Initialize(
109043: 51 push %ecx
109044: 31 c0 xor %eax,%eax
109046: 83 7d 0c 01 cmpl $0x1,0xc(%ebp)
10904a: 0f 94 c0 sete %al
10904d: 50 push %eax
10904e: 8d 45 dc lea -0x24(%ebp),%eax
109051: 50 push %eax
109052: 8d 46 14 lea 0x14(%esi),%eax
109055: 50 push %eax
109056: e8 ed 0b 00 00 call 109c48 <_CORE_mutex_Initialize>
&the_semaphore->Core_control.mutex,
&the_mutex_attributes,
(count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED
);
if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {
10905b: 83 c4 10 add $0x10,%esp
10905e: 83 f8 06 cmp $0x6,%eax
109061: 75 50 jne 1090b3 <rtems_semaphore_create+0x173><== ALWAYS TAKEN
* @param[in] starting_address is the starting address of the memory for
* the heap
* @param[in] size is the size in bytes of the memory area for the heap
* @param[in] page_size is the size in bytes of the allocation unit
*
* @return This method returns the maximum memory available. If
109063: 52 push %edx <== NOT EXECUTED
109064: 52 push %edx <== NOT EXECUTED
109065: 56 push %esi <== NOT EXECUTED
109066: 68 e0 d6 11 00 push $0x11d6e0 <== NOT EXECUTED
10906b: e8 28 15 00 00 call 10a598 <_Objects_Free> <== NOT EXECUTED
_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
109070: e8 17 1e 00 00 call 10ae8c <_Thread_Enable_dispatch><== NOT EXECUTED
109075: b8 13 00 00 00 mov $0x13,%eax <== NOT EXECUTED
10907a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10907d: eb 5b jmp 1090da <rtems_semaphore_create+0x19a><== NOT EXECUTED
return RTEMS_INVALID_PRIORITY;
}
} else {
if ( _Attributes_Is_priority( attribute_set ) )
the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
10907f: 31 c0 xor %eax,%eax
109081: f6 c3 04 test $0x4,%bl
109084: 0f 95 c0 setne %al
109087: 89 45 f0 mov %eax,-0x10(%ebp)
/*
* This effectively disables limit checking.
*/
the_semaphore_attributes.maximum_count = 0xFFFFFFFF;
10908a: c7 45 ec ff ff ff ff movl $0xffffffff,-0x14(%ebp)
/*
* The following are just to make Purify happy.
*/
the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
109091: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM;
109098: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp)
_CORE_semaphore_Initialize(
10909f: 50 push %eax
1090a0: ff 75 0c pushl 0xc(%ebp)
1090a3: 8d 45 ec lea -0x14(%ebp),%eax
1090a6: 50 push %eax
1090a7: 8d 46 14 lea 0x14(%esi),%eax
1090aa: 50 push %eax
1090ab: e8 14 0e 00 00 call 109ec4 <_CORE_semaphore_Initialize>
1090b0: 83 c4 10 add $0x10,%esp
1090b3: 8b 4e 08 mov 0x8(%esi),%ecx
1090b6: 0f b7 d1 movzwl %cx,%edx
1090b9: a1 fc d6 11 00 mov 0x11d6fc,%eax
1090be: 89 34 90 mov %esi,(%eax,%edx,4)
1090c1: 8b 45 08 mov 0x8(%ebp),%eax
1090c4: 89 46 0c mov %eax,0xc(%esi)
&_Semaphore_Information,
&the_semaphore->Object,
(Objects_Name) name
);
*id = the_semaphore->Object.id;
1090c7: 8b 45 18 mov 0x18(%ebp),%eax
1090ca: 89 08 mov %ecx,(%eax)
the_semaphore->Object.id,
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
1090cc: e8 bb 1d 00 00 call 10ae8c <_Thread_Enable_dispatch>
1090d1: 31 c0 xor %eax,%eax
1090d3: eb 05 jmp 1090da <rtems_semaphore_create+0x19a>
return RTEMS_SUCCESSFUL;
1090d5: b8 0b 00 00 00 mov $0xb,%eax
}
1090da: 8d 65 f4 lea -0xc(%ebp),%esp
1090dd: 5b pop %ebx
1090de: 5e pop %esi
1090df: 5f pop %edi
1090e0: c9 leave
1090e1: c3 ret
001121dc <rtems_semaphore_flush>:
#endif
rtems_status_code rtems_semaphore_flush(
rtems_id id
)
{
1121dc: 55 push %ebp
1121dd: 89 e5 mov %esp,%ebp
1121df: 83 ec 1c sub $0x1c,%esp
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory
* to add to the heap
1121e2: 8d 45 fc lea -0x4(%ebp),%eax
1121e5: 50 push %eax
1121e6: ff 75 08 pushl 0x8(%ebp)
1121e9: 68 2c 40 13 00 push $0x13402c
1121ee: e8 05 2e 00 00 call 114ff8 <_Objects_Get>
1121f3: 89 c2 mov %eax,%edx
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
1121f5: 83 c4 10 add $0x10,%esp
1121f8: b8 04 00 00 00 mov $0x4,%eax
1121fd: 83 7d fc 00 cmpl $0x0,-0x4(%ebp)
112201: 75 2b jne 11222e <rtems_semaphore_flush+0x52>
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
112203: f6 42 10 30 testb $0x30,0x10(%edx)
112207: 8d 42 14 lea 0x14(%edx),%eax
11220a: 74 0d je 112219 <rtems_semaphore_flush+0x3d><== NEVER TAKEN
_CORE_mutex_Flush(
11220c: 51 push %ecx
11220d: 6a 01 push $0x1
11220f: 6a 00 push $0x0
112211: 50 push %eax
112212: e8 e9 1c 00 00 call 113f00 <_CORE_mutex_Flush>
112217: eb 0b jmp 112224 <rtems_semaphore_flush+0x48>
&the_semaphore->Core_control.mutex,
SEND_OBJECT_WAS_DELETED,
CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT
);
} else {
_CORE_semaphore_Flush(
112219: 52 push %edx <== NOT EXECUTED
11221a: 6a 01 push $0x1 <== NOT EXECUTED
11221c: 6a 00 push $0x0 <== NOT EXECUTED
11221e: 50 push %eax <== NOT EXECUTED
11221f: e8 58 1f 00 00 call 11417c <_CORE_semaphore_Flush> <== NOT EXECUTED
112224: 83 c4 10 add $0x10,%esp
&the_semaphore->Core_control.semaphore,
SEND_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT
);
}
_Thread_Enable_dispatch();
112227: e8 8c 35 00 00 call 1157b8 <_Thread_Enable_dispatch>
11222c: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11222e: c9 leave
11222f: c3 ret
0011582c <rtems_shutdown_executive>:
*/
void rtems_shutdown_executive(
uint32_t result
)
{
11582c: 55 push %ebp
11582d: 89 e5 mov %esp,%ebp
11582f: 83 ec 28 sub $0x28,%esp
if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) {
115832: 83 3d 38 d9 11 00 04 cmpl $0x4,0x11d938
115839: 74 1d je 115858 <rtems_shutdown_executive+0x2c><== NEVER TAKEN
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
11583b: c7 05 38 d9 11 00 04 movl $0x4,0x11d938
115842: 00 00 00
#endif
}
/**
* This routine sets the current system state to that specified by
* the called.
115845: 50 push %eax
115846: 50 push %eax
115847: 68 80 d7 11 00 push $0x11d780
11584c: 8d 45 e8 lea -0x18(%ebp),%eax
11584f: 50 push %eax
115850: e8 6b 66 ff ff call 10bec0 <_CPU_Context_switch>
115855: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_SHUTDOWN );
_Thread_Stop_multitasking();
}
}
115858: c9 leave <== NOT EXECUTED
115859: c3 ret <== NOT EXECUTED
00109ef0 <rtems_signal_catch>:
rtems_status_code rtems_signal_catch(
rtems_asr_entry asr_handler,
rtems_mode mode_set
)
{
109ef0: 55 push %ebp
109ef1: 89 e5 mov %esp,%ebp
109ef3: 83 ec 08 sub $0x8,%esp
109ef6: 8b 4d 08 mov 0x8(%ebp),%ecx
RTEMS_API_Control *api;
ASR_Information *asr;
/* XXX normalize mode */
executing = _Thread_Executing;
api = (RTEMS_API_Control*)executing->API_Extensions[ THREAD_API_RTEMS ];
109ef9: a1 c4 12 12 00 mov 0x1212c4,%eax
109efe: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
109f04: a1 04 12 12 00 mov 0x121204,%eax
109f09: 40 inc %eax
109f0a: a3 04 12 12 00 mov %eax,0x121204
asr = &api->Signal;
_Thread_Disable_dispatch(); /* cannot reschedule while */
/* the thread is inconsistent */
if ( !_ASR_Is_null_handler( asr_handler ) ) {
109f0f: 85 c9 test %ecx,%ecx
109f11: 74 0b je 109f1e <rtems_signal_catch+0x2e><== NEVER TAKEN
asr->mode_set = mode_set;
109f13: 8b 45 0c mov 0xc(%ebp),%eax
109f16: 89 42 10 mov %eax,0x10(%edx)
asr->handler = asr_handler;
109f19: 89 4a 0c mov %ecx,0xc(%edx)
109f1c: eb 27 jmp 109f45 <rtems_signal_catch+0x55>
#endif
/**
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
109f1e: c6 42 08 01 movb $0x1,0x8(%edx) <== NOT EXECUTED
* @a page_size byte units. If @a page_size is 0 or is not multiple of
109f22: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) <== NOT EXECUTED
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
109f29: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) <== NOT EXECUTED
*
109f30: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx) <== NOT EXECUTED
* @param[in] the_heap is the heap to operate upon
109f37: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) <== NOT EXECUTED
* @param[in] starting_address is the starting address of the memory for
109f3e: c7 42 1c 00 00 00 00 movl $0x0,0x1c(%edx) <== NOT EXECUTED
}
else
_ASR_Initialize( asr );
_Thread_Enable_dispatch();
109f45: e8 8e 1e 00 00 call 10bdd8 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
}
109f4a: 31 c0 xor %eax,%eax
109f4c: c9 leave
109f4d: c3 ret
001123cc <rtems_signal_send>:
rtems_status_code rtems_signal_send(
Objects_Id id,
rtems_signal_set signal_set
)
{
1123cc: 55 push %ebp
1123cd: 89 e5 mov %esp,%ebp
1123cf: 53 push %ebx
1123d0: 83 ec 14 sub $0x14,%esp
1123d3: 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 )
1123d6: b8 0a 00 00 00 mov $0xa,%eax
1123db: 85 db test %ebx,%ebx
1123dd: 74 71 je 112450 <rtems_signal_send+0x84><== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
1123df: 50 push %eax
1123e0: 50 push %eax
1123e1: 8d 45 f8 lea -0x8(%ebp),%eax
1123e4: 50 push %eax
1123e5: ff 75 08 pushl 0x8(%ebp)
1123e8: e8 eb 33 00 00 call 1157d8 <_Thread_Get>
1123ed: 89 c1 mov %eax,%ecx
switch ( location ) {
1123ef: 83 c4 10 add $0x10,%esp
1123f2: b8 04 00 00 00 mov $0x4,%eax
1123f7: 83 7d f8 00 cmpl $0x0,-0x8(%ebp)
1123fb: 75 53 jne 112450 <rtems_signal_send+0x84>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
1123fd: 8b 91 f4 00 00 00 mov 0xf4(%ecx),%edx
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
112403: 83 7a 0c 00 cmpl $0x0,0xc(%edx)
112407: 74 3d je 112446 <rtems_signal_send+0x7a>
if ( asr->is_enabled ) {
112409: 80 7a 08 00 cmpb $0x0,0x8(%edx)
11240d: 74 26 je 112435 <rtems_signal_send+0x69><== NEVER TAKEN
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
11240f: 9c pushf
112410: fa cli
112411: 58 pop %eax
);
112412: 09 5a 14 or %ebx,0x14(%edx)
112415: 50 push %eax
112416: 9d popf
_ASR_Post_signals( signal_set, &asr->signals_posted );
the_thread->do_post_task_switch_extension = true;
112417: c6 41 75 01 movb $0x1,0x75(%ecx)
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
11241b: a1 d4 41 13 00 mov 0x1341d4,%eax
112420: 85 c0 test %eax,%eax
112422: 74 19 je 11243d <rtems_signal_send+0x71>
112424: 3b 0d f8 41 13 00 cmp 0x1341f8,%ecx
11242a: 75 11 jne 11243d <rtems_signal_send+0x71><== NEVER TAKEN
_ISR_Signals_to_thread_executing = TRUE;
11242c: c6 05 8c 42 13 00 01 movb $0x1,0x13428c
112433: eb 08 jmp 11243d <rtems_signal_send+0x71>
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
112435: 9c pushf <== NOT EXECUTED
112436: fa cli <== NOT EXECUTED
112437: 58 pop %eax <== NOT EXECUTED
);
112438: 09 5a 18 or %ebx,0x18(%edx) <== NOT EXECUTED
11243b: 50 push %eax <== NOT EXECUTED
11243c: 9d popf <== NOT EXECUTED
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
11243d: e8 76 33 00 00 call 1157b8 <_Thread_Enable_dispatch>
112442: 31 c0 xor %eax,%eax
112444: eb 0a jmp 112450 <rtems_signal_send+0x84>
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
112446: e8 6d 33 00 00 call 1157b8 <_Thread_Enable_dispatch>
11244b: b8 0b 00 00 00 mov $0xb,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112450: 8b 5d fc mov -0x4(%ebp),%ebx
112453: c9 leave
112454: c3 ret
001066f8 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
1066f8: 55 push %ebp
1066f9: 89 e5 mov %esp,%ebp
1066fb: 57 push %edi
1066fc: 56 push %esi
1066fd: 8b 45 08 mov 0x8(%ebp),%eax
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
106700: 83 78 08 00 cmpl $0x0,0x8(%eax)
106704: 74 15 je 10671b <rtems_stack_checker_begin_extension+0x23><== NEVER TAKEN
return;
the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
*the_pattern = Stack_check_Pattern;
106706: 8b 80 c8 00 00 00 mov 0xc8(%eax),%eax
10670c: 8d 78 08 lea 0x8(%eax),%edi
10670f: be 08 10 12 00 mov $0x121008,%esi
106714: b9 04 00 00 00 mov $0x4,%ecx
106719: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
10671b: 5e pop %esi
10671c: 5f pop %edi
10671d: c9 leave
10671e: c3 ret
00106a80 <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running,
Thread_Control *the_thread
)
{
106a80: 55 push %ebp
106a81: 89 e5 mov %esp,%ebp
106a83: 57 push %edi
106a84: 83 ec 04 sub $0x4,%esp
106a87: 8b 7d 0c mov 0xc(%ebp),%edi
Stack_check_Initialize();
106a8a: e8 84 ff ff ff call 106a13 <Stack_check_Initialize>
if (the_thread)
106a8f: 85 ff test %edi,%edi
106a91: 74 10 je 106aa3 <rtems_stack_checker_create_extension+0x23><== NEVER TAKEN
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
106a93: 8b 8f c4 00 00 00 mov 0xc4(%edi),%ecx
106a99: 8b bf c8 00 00 00 mov 0xc8(%edi),%edi
106a9f: b0 a5 mov $0xa5,%al
106aa1: f3 aa rep stos %al,%es:(%edi)
return true;
}
106aa3: b0 01 mov $0x1,%al
106aa5: 5a pop %edx
106aa6: 5f pop %edi
106aa7: c9 leave
106aa8: c3 ret
00106941 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
106941: 55 push %ebp <== NOT EXECUTED
106942: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106944: 53 push %ebx <== NOT EXECUTED
106945: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
106948: a1 44 12 12 00 mov 0x121244,%eax <== NOT EXECUTED
)
{
void *sp = __builtin_frame_address(0);
#if defined(__GNUC__)
if ( sp < the_stack->area ) {
10694d: 8b 90 c8 00 00 00 mov 0xc8(%eax),%edx <== NOT EXECUTED
106953: 31 db xor %ebx,%ebx <== NOT EXECUTED
106955: 39 d5 cmp %edx,%ebp <== NOT EXECUTED
106957: 72 0e jb 106967 <rtems_stack_checker_is_blown+0x26><== NOT EXECUTED
106959: 8b 88 c4 00 00 00 mov 0xc4(%eax),%ecx <== NOT EXECUTED
10695f: 8d 04 0a lea (%edx,%ecx,1),%eax <== NOT EXECUTED
106962: 39 c5 cmp %eax,%ebp <== NOT EXECUTED
106964: 0f 96 c3 setbe %bl <== NOT EXECUTED
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
106967: b0 01 mov $0x1,%al <== NOT EXECUTED
106969: 83 3d ec 0d 12 00 00 cmpl $0x0,0x120dec <== NOT EXECUTED
106970: 74 19 je 10698b <rtems_stack_checker_is_blown+0x4a><== NOT EXECUTED
pattern_ok = (!memcmp(
106972: 51 push %ecx <== NOT EXECUTED
106973: 6a 10 push $0x10 <== NOT EXECUTED
106975: 68 08 10 12 00 push $0x121008 <== NOT EXECUTED
10697a: 8d 42 08 lea 0x8(%edx),%eax <== NOT EXECUTED
10697d: 50 push %eax <== NOT EXECUTED
10697e: e8 c5 9e 00 00 call 110848 <memcmp> <== NOT EXECUTED
106983: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106986: 85 c0 test %eax,%eax <== NOT EXECUTED
106988: 0f 94 c0 sete %al <== NOT EXECUTED
}
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
if ( sp_ok && pattern_ok )
10698b: 84 db test %bl,%bl <== NOT EXECUTED
10698d: 74 06 je 106995 <rtems_stack_checker_is_blown+0x54><== NOT EXECUTED
10698f: 31 d2 xor %edx,%edx <== NOT EXECUTED
106991: 84 c0 test %al,%al <== NOT EXECUTED
106993: 75 16 jne 1069ab <rtems_stack_checker_is_blown+0x6a><== NOT EXECUTED
return false;
/*
* Let's report as much as we can.
*/
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
106995: 52 push %edx <== NOT EXECUTED
106996: 52 push %edx <== NOT EXECUTED
106997: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
10699a: 50 push %eax <== NOT EXECUTED
10699b: ff 35 44 12 12 00 pushl 0x121244 <== NOT EXECUTED
1069a1: e8 34 ff ff ff call 1068da <Stack_check_report_blown_task><== NOT EXECUTED
1069a6: b2 01 mov $0x1,%dl <== NOT EXECUTED
1069a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return true;
}
1069ab: 88 d0 mov %dl,%al <== NOT EXECUTED
1069ad: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
1069b0: c9 leave <== NOT EXECUTED
1069b1: c3 ret <== NOT EXECUTED
001068c3 <rtems_stack_checker_report_usage>:
void rtems_stack_checker_report_usage( void )
{
1068c3: 55 push %ebp <== NOT EXECUTED
1068c4: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1068c6: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
1068c9: 68 d0 7b 10 00 push $0x107bd0 <== NOT EXECUTED
1068ce: 6a 00 push $0x0 <== NOT EXECUTED
1068d0: e8 8d ff ff ff call 106862 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
1068d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
1068d8: c9 leave <== NOT EXECUTED
1068d9: c3 ret <== NOT EXECUTED
00106862 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
106862: 55 push %ebp <== NOT EXECUTED
106863: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106865: 56 push %esi <== NOT EXECUTED
106866: 53 push %ebx <== NOT EXECUTED
106867: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
10686a: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED
print_context = context;
10686d: 89 1d f0 0d 12 00 mov %ebx,0x120df0 <== NOT EXECUTED
print_handler = print;
106873: 89 35 f4 0d 12 00 mov %esi,0x120df4 <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
106879: 51 push %ecx <== NOT EXECUTED
10687a: 51 push %ecx <== NOT EXECUTED
10687b: 68 25 9a 11 00 push $0x119a25 <== NOT EXECUTED
106880: 53 push %ebx <== NOT EXECUTED
106881: ff d6 call *%esi <== NOT EXECUTED
(*print)( context,
106883: 58 pop %eax <== NOT EXECUTED
106884: 5a pop %edx <== NOT EXECUTED
106885: 68 3c 9a 11 00 push $0x119a3c <== NOT EXECUTED
10688a: 53 push %ebx <== NOT EXECUTED
10688b: ff d6 call *%esi <== 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 );
10688d: c7 04 24 4a 67 10 00 movl $0x10674a,(%esp) <== NOT EXECUTED
106894: e8 43 47 00 00 call 10afdc <rtems_iterate_over_all_threads><== NOT EXECUTED
/* dump interrupt stack info if any */
Stack_check_Dump_threads_usage((Thread_Control *) -1);
106899: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED
1068a0: e8 a5 fe ff ff call 10674a <Stack_check_Dump_threads_usage><== NOT EXECUTED
print_context = NULL;
1068a5: c7 05 f0 0d 12 00 00 movl $0x0,0x120df0 <== NOT EXECUTED
1068ac: 00 00 00
print_handler = NULL;
1068af: c7 05 f4 0d 12 00 00 movl $0x0,0x120df4 <== NOT EXECUTED
1068b6: 00 00 00
1068b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
1068bc: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
1068bf: 5b pop %ebx <== NOT EXECUTED
1068c0: 5e pop %esi <== NOT EXECUTED
1068c1: c9 leave <== NOT EXECUTED
1068c2: c3 ret <== NOT EXECUTED
001069b2 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running,
Thread_Control *heir
)
{
1069b2: 55 push %ebp
1069b3: 89 e5 mov %esp,%ebp
1069b5: 56 push %esi
1069b6: 53 push %ebx
1069b7: 8b 5d 08 mov 0x8(%ebp),%ebx
Stack_Control *the_stack = &running->Start.Initial_stack;
void *pattern;
bool sp_ok;
bool pattern_ok = true;
pattern = (void *) Stack_check_Get_pattern_area(the_stack)->pattern;
1069ba: 8b 93 c8 00 00 00 mov 0xc8(%ebx),%edx
)
{
void *sp = __builtin_frame_address(0);
#if defined(__GNUC__)
if ( sp < the_stack->area ) {
1069c0: 31 f6 xor %esi,%esi
1069c2: 39 d5 cmp %edx,%ebp
1069c4: 72 0f jb 1069d5 <rtems_stack_checker_switch_extension+0x23><== NEVER TAKEN
1069c6: 89 d0 mov %edx,%eax
1069c8: 03 83 c4 00 00 00 add 0xc4(%ebx),%eax
1069ce: 39 c5 cmp %eax,%ebp
1069d0: 0f 96 c0 setbe %al
1069d3: 89 c6 mov %eax,%esi
/*
* 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,
1069d5: 50 push %eax
1069d6: 6a 10 push $0x10
1069d8: 68 08 10 12 00 push $0x121008
1069dd: 8d 42 08 lea 0x8(%edx),%eax
1069e0: 50 push %eax
1069e1: e8 62 9e 00 00 call 110848 <memcmp>
1069e6: 83 c4 10 add $0x10,%esp
1069e9: 85 c0 test %eax,%eax
1069eb: 0f 94 c0 sete %al
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
1069ee: 89 f2 mov %esi,%edx
1069f0: 84 d2 test %dl,%dl
1069f2: 74 04 je 1069f8 <rtems_stack_checker_switch_extension+0x46><== NEVER TAKEN
1069f4: 84 c0 test %al,%al
1069f6: 75 14 jne 106a0c <rtems_stack_checker_switch_extension+0x5a>
Stack_check_report_blown_task( running, pattern_ok );
1069f8: 0f b6 c0 movzbl %al,%eax
1069fb: 89 45 0c mov %eax,0xc(%ebp)
1069fe: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
106a01: 8d 65 f8 lea -0x8(%ebp),%esp
106a04: 5b pop %ebx
106a05: 5e pop %esi
106a06: c9 leave
pattern_ok = (!memcmp( pattern,
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( running, pattern_ok );
106a07: e9 ce fe ff ff jmp 1068da <Stack_check_report_blown_task>
}
}
106a0c: 8d 65 f8 lea -0x8(%ebp),%esp
106a0f: 5b pop %ebx
106a10: 5e pop %esi
106a11: c9 leave
106a12: c3 ret
00106eac <rtems_status_text>:
const char *
rtems_status_text(
rtems_status_code status
)
{
106eac: 55 push %ebp <== NOT EXECUTED
106ead: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106eaf: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
return rtems_assoc_name_by_local(rtems_status_assoc, status);
106eb2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
106eb5: 68 18 a5 11 00 push $0x11a518 <== NOT EXECUTED
106eba: e8 c9 73 00 00 call 10e288 <rtems_assoc_name_by_local><== NOT EXECUTED
}
106ebf: c9 leave <== NOT EXECUTED
106ec0: c3 ret <== NOT EXECUTED
001092ec <rtems_task_create>:
size_t stack_size,
rtems_mode initial_modes,
rtems_attribute attribute_set,
Objects_Id *id
)
{
1092ec: 55 push %ebp
1092ed: 89 e5 mov %esp,%ebp
1092ef: 57 push %edi
1092f0: 56 push %esi
1092f1: 53 push %ebx
1092f2: 83 ec 0c sub $0xc,%esp
1092f5: 8b 5d 14 mov 0x14(%ebp),%ebx
1092f8: 8b 7d 18 mov 0x18(%ebp),%edi
Priority_Control core_priority;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
1092fb: b8 09 00 00 00 mov $0x9,%eax
109300: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp)
109304: 0f 84 08 01 00 00 je 109412 <rtems_task_create+0x126><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
10930a: b8 03 00 00 00 mov $0x3,%eax
10930f: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
109313: 0f 84 f9 00 00 00 je 109412 <rtems_task_create+0x126>
/*
* Validate the RTEMS API priority and convert it to the core priority range.
*/
if ( !_Attributes_Is_system_task( the_attribute_set ) ) {
109319: 66 85 ff test %di,%di
10931c: 78 24 js 109342 <rtems_task_create+0x56>
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
size_t size
);
10931e: 31 d2 xor %edx,%edx
109320: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
109324: 74 0f je 109335 <rtems_task_create+0x49>
109326: 0f b6 05 84 93 11 00 movzbl 0x119384,%eax
10932d: 31 d2 xor %edx,%edx
10932f: 39 45 0c cmp %eax,0xc(%ebp)
109332: 0f 96 c2 setbe %dl
if ( !_RTEMS_tasks_Priority_is_valid( initial_priority ) )
109335: b8 13 00 00 00 mov $0x13,%eax
10933a: 85 d2 test %edx,%edx
10933c: 0f 84 d0 00 00 00 je 109412 <rtems_task_create+0x126>
*/
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
109342: 83 ec 0c sub $0xc,%esp
109345: ff 35 50 d8 11 00 pushl 0x11d850
10934b: e8 28 07 00 00 call 109a78 <_API_Mutex_Lock>
#ifdef __cplusplus
extern "C" {
#endif
/**
109350: c7 04 24 20 d7 11 00 movl $0x11d720,(%esp)
109357: e8 2c 0f 00 00 call 10a288 <_Objects_Allocate>
10935c: 89 c6 mov %eax,%esi
* the event of an error.
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
10935e: 83 c4 10 add $0x10,%esp
109361: 85 c0 test %eax,%eax
109363: 75 18 jne 10937d <rtems_task_create+0x91>
_RTEMS_Unlock_allocator();
109365: 83 ec 0c sub $0xc,%esp
109368: ff 35 50 d8 11 00 pushl 0x11d850
10936e: e8 4d 07 00 00 call 109ac0 <_API_Mutex_Unlock>
109373: b8 05 00 00 00 mov $0x5,%eax
109378: e9 92 00 00 00 jmp 10940f <rtems_task_create+0x123>
/*
* Initialize the core thread for this task.
*/
status = _Thread_Initialize(
10937d: 50 push %eax
10937e: ff 75 08 pushl 0x8(%ebp)
109381: 89 d8 mov %ebx,%eax
109383: 83 e0 01 and $0x1,%eax
109386: 50 push %eax
109387: 6a 00 push $0x0
109389: 89 d8 mov %ebx,%eax
10938b: c1 e8 09 shr $0x9,%eax
10938e: 83 e0 01 and $0x1,%eax
109391: 50 push %eax
109392: 89 d8 mov %ebx,%eax
109394: c1 e8 08 shr $0x8,%eax
109397: 83 f0 01 xor $0x1,%eax
10939a: 83 e0 01 and $0x1,%eax
10939d: 50 push %eax
10939e: ff 75 0c pushl 0xc(%ebp)
1093a1: 83 e7 01 and $0x1,%edi
1093a4: 57 push %edi
1093a5: ff 75 10 pushl 0x10(%ebp)
1093a8: 6a 00 push $0x0
1093aa: 56 push %esi
1093ab: 68 20 d7 11 00 push $0x11d720
1093b0: e8 6f 1b 00 00 call 10af24 <_Thread_Initialize>
NULL, /* no budget algorithm callout */
_Modes_Get_interrupt_level(initial_modes),
(Objects_Name) name
);
if ( !status ) {
1093b5: 83 c4 30 add $0x30,%esp
1093b8: 84 c0 test %al,%al
1093ba: 75 27 jne 1093e3 <rtems_task_create+0xf7>
* @param[in] starting_address is the starting address of the memory for
* the heap
* @param[in] size is the size in bytes of the memory area for the heap
* @param[in] page_size is the size in bytes of the allocation unit
*
* @return This method returns the maximum memory available. If
1093bc: 83 ec 0c sub $0xc,%esp
1093bf: ff 76 08 pushl 0x8(%esi)
1093c2: e8 45 12 00 00 call 10a60c <_Objects_Get_information_id>
1093c7: 5a pop %edx
1093c8: 59 pop %ecx
1093c9: 56 push %esi
1093ca: 50 push %eax
1093cb: e8 c8 11 00 00 call 10a598 <_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();
1093d0: 58 pop %eax
1093d1: ff 35 50 d8 11 00 pushl 0x11d850
1093d7: e8 e4 06 00 00 call 109ac0 <_API_Mutex_Unlock>
1093dc: b8 0d 00 00 00 mov $0xd,%eax
1093e1: eb 2c jmp 10940f <rtems_task_create+0x123>
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
1093e3: 8b 86 f4 00 00 00 mov 0xf4(%esi),%eax
1093e9: c1 eb 0a shr $0xa,%ebx
1093ec: 83 f3 01 xor $0x1,%ebx
1093ef: 88 da mov %bl,%dl
1093f1: 83 e2 01 and $0x1,%edx
1093f4: 88 50 08 mov %dl,0x8(%eax)
*id = the_thread->Object.id;
1093f7: 8b 46 08 mov 0x8(%esi),%eax
1093fa: 8b 55 1c mov 0x1c(%ebp),%edx
1093fd: 89 02 mov %eax,(%edx)
);
}
#endif
_RTEMS_Unlock_allocator();
1093ff: 83 ec 0c sub $0xc,%esp
109402: ff 35 50 d8 11 00 pushl 0x11d850
109408: e8 b3 06 00 00 call 109ac0 <_API_Mutex_Unlock>
10940d: 31 c0 xor %eax,%eax
10940f: 83 c4 10 add $0x10,%esp
return RTEMS_SUCCESSFUL;
}
109412: 8d 65 f4 lea -0xc(%ebp),%esp
109415: 5b pop %ebx
109416: 5e pop %esi
109417: 5f pop %edi
109418: c9 leave
109419: c3 ret
0010aa24 <rtems_task_get_note>:
rtems_status_code rtems_task_get_note(
Objects_Id id,
uint32_t notepad,
uint32_t *note
)
{
10aa24: 55 push %ebp
10aa25: 89 e5 mov %esp,%ebp
10aa27: 56 push %esi
10aa28: 53 push %ebx
10aa29: 83 ec 10 sub $0x10,%esp
10aa2c: 8b 4d 08 mov 0x8(%ebp),%ecx
10aa2f: 8b 5d 0c mov 0xc(%ebp),%ebx
10aa32: 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() )
10aa35: a1 a4 28 12 00 mov 0x1228a4,%eax
10aa3a: 8b 40 40 mov 0x40(%eax),%eax
10aa3d: ba 16 00 00 00 mov $0x16,%edx
10aa42: 80 78 04 00 cmpb $0x0,0x4(%eax)
10aa46: 74 61 je 10aaa9 <rtems_task_get_note+0x85><== NEVER TAKEN
return RTEMS_NOT_CONFIGURED;
if ( !note )
10aa48: ba 09 00 00 00 mov $0x9,%edx
10aa4d: 85 f6 test %esi,%esi
10aa4f: 74 58 je 10aaa9 <rtems_task_get_note+0x85><== NEVER TAKEN
/*
* 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 )
10aa51: ba 0a 00 00 00 mov $0xa,%edx
10aa56: 83 fb 0f cmp $0xf,%ebx
10aa59: 77 4e ja 10aaa9 <rtems_task_get_note+0x85>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10aa5b: 85 c9 test %ecx,%ecx
10aa5d: 74 0a je 10aa69 <rtems_task_get_note+0x45>
10aa5f: a1 cc 28 12 00 mov 0x1228cc,%eax
10aa64: 3b 48 08 cmp 0x8(%eax),%ecx
10aa67: 75 13 jne 10aa7c <rtems_task_get_note+0x58>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
10aa69: a1 cc 28 12 00 mov 0x1228cc,%eax
10aa6e: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
10aa74: 8b 44 98 20 mov 0x20(%eax,%ebx,4),%eax
10aa78: 89 06 mov %eax,(%esi)
10aa7a: eb 2b jmp 10aaa7 <rtems_task_get_note+0x83>
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
10aa7c: 50 push %eax
10aa7d: 50 push %eax
10aa7e: 8d 45 f4 lea -0xc(%ebp),%eax
10aa81: 50 push %eax
10aa82: 51 push %ecx
10aa83: e8 d8 1c 00 00 call 10c760 <_Thread_Get>
switch ( location ) {
10aa88: 83 c4 10 add $0x10,%esp
10aa8b: ba 04 00 00 00 mov $0x4,%edx
10aa90: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10aa94: 75 13 jne 10aaa9 <rtems_task_get_note+0x85><== ALWAYS TAKEN
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
10aa96: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED
10aa9c: 8b 44 98 20 mov 0x20(%eax,%ebx,4),%eax <== NOT EXECUTED
10aaa0: 89 06 mov %eax,(%esi) <== NOT EXECUTED
_Thread_Enable_dispatch();
10aaa2: e8 99 1c 00 00 call 10c740 <_Thread_Enable_dispatch><== NOT EXECUTED
10aaa7: 31 d2 xor %edx,%edx
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10aaa9: 89 d0 mov %edx,%eax
10aaab: 8d 65 f8 lea -0x8(%ebp),%esp
10aaae: 5b pop %ebx
10aaaf: 5e pop %esi
10aab0: c9 leave
10aab1: c3 ret
001094a0 <rtems_task_ident>:
rtems_status_code rtems_task_ident(
rtems_name name,
uint32_t node,
Objects_Id *id
)
{
1094a0: 55 push %ebp
1094a1: 89 e5 mov %esp,%ebp
1094a3: 83 ec 08 sub $0x8,%esp
1094a6: 8b 4d 08 mov 0x8(%ebp),%ecx
1094a9: 8b 55 10 mov 0x10(%ebp),%edx
Objects_Name_or_id_lookup_errors status;
if ( !id )
1094ac: b8 09 00 00 00 mov $0x9,%eax
1094b1: 85 d2 test %edx,%edx
1094b3: 74 2b je 1094e0 <rtems_task_ident+0x40> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( name == OBJECTS_ID_OF_SELF ) {
1094b5: 85 c9 test %ecx,%ecx
1094b7: 75 0e jne 1094c7 <rtems_task_ident+0x27>
*id = _Thread_Executing->Object.id;
1094b9: a1 58 d8 11 00 mov 0x11d858,%eax
1094be: 8b 40 08 mov 0x8(%eax),%eax
1094c1: 89 02 mov %eax,(%edx)
1094c3: 31 c0 xor %eax,%eax
1094c5: eb 19 jmp 1094e0 <rtems_task_ident+0x40>
return RTEMS_SUCCESSFUL;
}
status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
1094c7: 52 push %edx
1094c8: ff 75 0c pushl 0xc(%ebp)
1094cb: 51 push %ecx
1094cc: 68 20 d7 11 00 push $0x11d720
1094d1: e8 3e 13 00 00 call 10a814 <_Objects_Name_to_id_u32>
return _Status_Object_name_errors_to_status[ status ];
1094d6: 8b 04 85 1c 73 11 00 mov 0x11731c(,%eax,4),%eax
1094dd: 83 c4 10 add $0x10,%esp
}
1094e0: c9 leave
1094e1: c3 ret
001099ec <rtems_task_is_suspended>:
*/
rtems_status_code rtems_task_is_suspended(
Objects_Id id
)
{
1099ec: 55 push %ebp
1099ed: 89 e5 mov %esp,%ebp
1099ef: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
1099f2: 8d 45 fc lea -0x4(%ebp),%eax
1099f5: 50 push %eax
1099f6: ff 75 08 pushl 0x8(%ebp)
1099f9: e8 46 1a 00 00 call 10b444 <_Thread_Get>
1099fe: 89 c2 mov %eax,%edx
switch ( location ) {
109a00: 83 c4 10 add $0x10,%esp
109a03: b8 04 00 00 00 mov $0x4,%eax
109a08: 83 7d fc 00 cmpl $0x0,-0x4(%ebp)
109a0c: 75 19 jne 109a27 <rtems_task_is_suspended+0x3b><== NEVER TAKEN
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
109a0e: f6 42 10 02 testb $0x2,0x10(%edx)
109a12: 75 09 jne 109a1d <rtems_task_is_suspended+0x31>
_Thread_Enable_dispatch();
109a14: e8 0b 1a 00 00 call 10b424 <_Thread_Enable_dispatch>
109a19: 31 c0 xor %eax,%eax
109a1b: eb 0a jmp 109a27 <rtems_task_is_suspended+0x3b>
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
109a1d: e8 02 1a 00 00 call 10b424 <_Thread_Enable_dispatch>
109a22: b8 0f 00 00 00 mov $0xf,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
109a27: c9 leave
109a28: c3 ret
0010ecd4 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
10ecd4: 55 push %ebp
10ecd5: 89 e5 mov %esp,%ebp
10ecd7: 57 push %edi
10ecd8: 56 push %esi
10ecd9: 53 push %ebx
10ecda: 83 ec 0c sub $0xc,%esp
10ecdd: 8b 7d 08 mov 0x8(%ebp),%edi
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
10ece0: b8 09 00 00 00 mov $0x9,%eax
10ece5: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10ece9: 0f 84 04 01 00 00 je 10edf3 <rtems_task_mode+0x11f> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
10ecef: a1 58 d8 11 00 mov 0x11d858,%eax
10ecf4: 89 45 ec mov %eax,-0x14(%ebp)
api = executing->API_Extensions[ THREAD_API_RTEMS ];
10ecf7: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx
10ecfd: 89 55 f0 mov %edx,-0x10(%ebp)
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
10ed00: 80 78 76 01 cmpb $0x1,0x76(%eax)
10ed04: 19 f6 sbb %esi,%esi
10ed06: 81 e6 00 01 00 00 and $0x100,%esi
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
10ed0c: 83 78 7c 00 cmpl $0x0,0x7c(%eax)
10ed10: 74 06 je 10ed18 <rtems_task_mode+0x44>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
10ed12: 81 ce 00 02 00 00 or $0x200,%esi
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
10ed18: 8b 5d f0 mov -0x10(%ebp),%ebx
10ed1b: 80 7b 08 01 cmpb $0x1,0x8(%ebx)
10ed1f: 19 db sbb %ebx,%ebx
10ed21: 81 e3 00 04 00 00 and $0x400,%ebx
old_mode |= _ISR_Get_level();
10ed27: e8 6f d3 ff ff call 10c09b <_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;
10ed2c: 09 c3 or %eax,%ebx
old_mode |= _ISR_Get_level();
*previous_mode_set = old_mode;
10ed2e: 09 f3 or %esi,%ebx
10ed30: 8b 45 10 mov 0x10(%ebp),%eax
10ed33: 89 18 mov %ebx,(%eax)
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
10ed35: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp)
10ed3c: 74 11 je 10ed4f <rtems_task_mode+0x7b>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE;
10ed3e: 89 f8 mov %edi,%eax
10ed40: c1 e8 08 shr $0x8,%eax
10ed43: 83 f0 01 xor $0x1,%eax
10ed46: 83 e0 01 and $0x1,%eax
10ed49: 8b 55 ec mov -0x14(%ebp),%edx
10ed4c: 88 42 76 mov %al,0x76(%edx)
if ( mask & RTEMS_TIMESLICE_MASK ) {
10ed4f: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
10ed56: 74 26 je 10ed7e <rtems_task_mode+0xaa>
if ( _Modes_Is_timeslice(mode_set) ) {
10ed58: f7 c7 00 02 00 00 test $0x200,%edi
10ed5e: 74 14 je 10ed74 <rtems_task_mode+0xa0>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
10ed60: 8b 5d ec mov -0x14(%ebp),%ebx
10ed63: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
10ed6a: a1 64 d7 11 00 mov 0x11d764,%eax
10ed6f: 89 43 78 mov %eax,0x78(%ebx)
10ed72: eb 0a jmp 10ed7e <rtems_task_mode+0xaa>
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
10ed74: 8b 45 ec mov -0x14(%ebp),%eax
10ed77: c7 40 7c 00 00 00 00 movl $0x0,0x7c(%eax)
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
10ed7e: f6 45 0c 01 testb $0x1,0xc(%ebp)
10ed82: 74 0c je 10ed90 <rtems_task_mode+0xbc>
* Returns pointer to the start of the memory block if success, NULL if
* failure.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
* @param[in] alignment the required alignment
10ed84: f7 c7 01 00 00 00 test $0x1,%edi
10ed8a: 74 03 je 10ed8f <rtems_task_mode+0xbb>
10ed8c: fa cli
10ed8d: eb 01 jmp 10ed90 <rtems_task_mode+0xbc>
10ed8f: fb sti
*/
is_asr_enabled = FALSE;
needs_asr_dispatching = FALSE;
if ( mask & RTEMS_ASR_MASK ) {
10ed90: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
10ed97: 74 3b je 10edd4 <rtems_task_mode+0x100>
10ed99: c1 ef 0a shr $0xa,%edi
10ed9c: 83 f7 01 xor $0x1,%edi
10ed9f: 89 f8 mov %edi,%eax
10eda1: 83 e0 01 and $0x1,%eax
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
10eda4: 8b 55 f0 mov -0x10(%ebp),%edx
10eda7: 3a 42 08 cmp 0x8(%edx),%al
10edaa: 74 28 je 10edd4 <rtems_task_mode+0x100>
asr->is_enabled = is_asr_enabled;
10edac: 88 42 08 mov %al,0x8(%edx)
uint32_t page_size
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
10edaf: 9c pushf
10edb0: fa cli
10edb1: 59 pop %ecx
/**
10edb2: 8b 5d f0 mov -0x10(%ebp),%ebx
10edb5: 8b 53 18 mov 0x18(%ebx),%edx
* This routine grows @a the_heap memory area using the size bytes which
10edb8: 8b 43 14 mov 0x14(%ebx),%eax
10edbb: 89 43 18 mov %eax,0x18(%ebx)
* begin at @a starting_address.
10edbe: 89 53 14 mov %edx,0x14(%ebx)
*
10edc1: 51 push %ecx
10edc2: 9d popf
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
10edc3: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10edc7: 74 0b je 10edd4 <rtems_task_mode+0x100> <== ALWAYS TAKEN
needs_asr_dispatching = true;
executing->do_post_task_switch_extension = true;
10edc9: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
10edcc: c6 40 75 01 movb $0x1,0x75(%eax) <== NOT EXECUTED
10edd0: b3 01 mov $0x1,%bl <== NOT EXECUTED
10edd2: eb 02 jmp 10edd6 <rtems_task_mode+0x102> <== NOT EXECUTED
10edd4: 31 db xor %ebx,%ebx
}
}
}
if ( _System_state_Is_up(_System_state_Current) )
10edd6: 83 3d 38 d9 11 00 03 cmpl $0x3,0x11d938
10eddd: 75 12 jne 10edf1 <rtems_task_mode+0x11d> <== NEVER TAKEN
if ( _Thread_Evaluate_mode() || needs_asr_dispatching )
10eddf: e8 58 01 00 00 call 10ef3c <_Thread_Evaluate_mode>
10ede4: 84 c0 test %al,%al
10ede6: 75 04 jne 10edec <rtems_task_mode+0x118>
10ede8: 84 db test %bl,%bl
10edea: 74 05 je 10edf1 <rtems_task_mode+0x11d> <== ALWAYS TAKEN
_Thread_Dispatch();
10edec: e8 57 bf ff ff call 10ad48 <_Thread_Dispatch>
10edf1: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
10edf3: 83 c4 0c add $0xc,%esp
10edf6: 5b pop %ebx
10edf7: 5e pop %esi
10edf8: 5f pop %edi
10edf9: c9 leave
10edfa: c3 ret
0010ab88 <rtems_task_set_note>:
rtems_status_code rtems_task_set_note(
Objects_Id id,
uint32_t notepad,
uint32_t note
)
{
10ab88: 55 push %ebp
10ab89: 89 e5 mov %esp,%ebp
10ab8b: 56 push %esi
10ab8c: 53 push %ebx
10ab8d: 83 ec 10 sub $0x10,%esp
10ab90: 8b 4d 08 mov 0x8(%ebp),%ecx
10ab93: 8b 5d 0c mov 0xc(%ebp),%ebx
10ab96: 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() )
10ab99: a1 a4 28 12 00 mov 0x1228a4,%eax
10ab9e: 8b 40 40 mov 0x40(%eax),%eax
10aba1: ba 16 00 00 00 mov $0x16,%edx
10aba6: 80 78 04 00 cmpb $0x0,0x4(%eax)
10abaa: 74 54 je 10ac00 <rtems_task_set_note+0x78><== NEVER TAKEN
/*
* 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 )
10abac: ba 0a 00 00 00 mov $0xa,%edx
10abb1: 83 fb 0f cmp $0xf,%ebx
10abb4: 77 4a ja 10ac00 <rtems_task_set_note+0x78>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10abb6: 85 c9 test %ecx,%ecx
10abb8: 74 0a je 10abc4 <rtems_task_set_note+0x3c>
10abba: a1 cc 28 12 00 mov 0x1228cc,%eax
10abbf: 3b 48 08 cmp 0x8(%eax),%ecx
10abc2: 75 11 jne 10abd5 <rtems_task_set_note+0x4d><== ALWAYS TAKEN
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
10abc4: a1 cc 28 12 00 mov 0x1228cc,%eax
10abc9: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
10abcf: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4)
10abd3: eb 29 jmp 10abfe <rtems_task_set_note+0x76>
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
10abd5: 50 push %eax
10abd6: 50 push %eax
10abd7: 8d 45 f4 lea -0xc(%ebp),%eax
10abda: 50 push %eax
10abdb: 51 push %ecx
10abdc: e8 7f 1b 00 00 call 10c760 <_Thread_Get>
switch ( location ) {
10abe1: 83 c4 10 add $0x10,%esp
10abe4: ba 04 00 00 00 mov $0x4,%edx
10abe9: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10abed: 75 11 jne 10ac00 <rtems_task_set_note+0x78>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
10abef: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
10abf5: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4)
_Thread_Enable_dispatch();
10abf9: e8 42 1b 00 00 call 10c740 <_Thread_Enable_dispatch>
10abfe: 31 d2 xor %edx,%edx
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ac00: 89 d0 mov %edx,%eax
10ac02: 8d 65 f8 lea -0x8(%ebp),%esp
10ac05: 5b pop %ebx
10ac06: 5e pop %esi
10ac07: c9 leave
10ac08: c3 ret
0010a3a8 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
Objects_Id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
10a3a8: 55 push %ebp
10a3a9: 89 e5 mov %esp,%ebp
10a3ab: 56 push %esi
10a3ac: 53 push %ebx
10a3ad: 83 ec 10 sub $0x10,%esp
10a3b0: 8b 5d 0c mov 0xc(%ebp),%ebx
10a3b3: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10a3b6: 85 db test %ebx,%ebx
10a3b8: 74 10 je 10a3ca <rtems_task_set_priority+0x22>
10a3ba: 0f b6 05 24 d0 11 00 movzbl 0x11d024,%eax
10a3c1: ba 13 00 00 00 mov $0x13,%edx
10a3c6: 39 c3 cmp %eax,%ebx
10a3c8: 77 52 ja 10a41c <rtems_task_set_priority+0x74>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
10a3ca: ba 09 00 00 00 mov $0x9,%edx
10a3cf: 85 f6 test %esi,%esi
10a3d1: 74 49 je 10a41c <rtems_task_set_priority+0x74><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10a3d3: 52 push %edx
10a3d4: 52 push %edx
10a3d5: 8d 45 f4 lea -0xc(%ebp),%eax
10a3d8: 50 push %eax
10a3d9: ff 75 08 pushl 0x8(%ebp)
10a3dc: e8 93 1a 00 00 call 10be74 <_Thread_Get>
10a3e1: 89 c1 mov %eax,%ecx
switch ( location ) {
10a3e3: 83 c4 10 add $0x10,%esp
10a3e6: ba 04 00 00 00 mov $0x4,%edx
10a3eb: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10a3ef: 75 2b jne 10a41c <rtems_task_set_priority+0x74>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
10a3f1: 8b 40 14 mov 0x14(%eax),%eax
10a3f4: 89 06 mov %eax,(%esi)
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
10a3f6: 85 db test %ebx,%ebx
10a3f8: 74 1b je 10a415 <rtems_task_set_priority+0x6d>
the_thread->real_priority = new_priority;
10a3fa: 89 59 18 mov %ebx,0x18(%ecx)
if ( the_thread->resource_count == 0 ||
10a3fd: 83 79 1c 00 cmpl $0x0,0x1c(%ecx)
10a401: 74 05 je 10a408 <rtems_task_set_priority+0x60>
10a403: 39 59 14 cmp %ebx,0x14(%ecx)
10a406: 76 0d jbe 10a415 <rtems_task_set_priority+0x6d><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, FALSE );
10a408: 50 push %eax
10a409: 6a 00 push $0x0
10a40b: 53 push %ebx
10a40c: 51 push %ecx
10a40d: e8 a2 15 00 00 call 10b9b4 <_Thread_Change_priority>
10a412: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10a415: e8 3a 1a 00 00 call 10be54 <_Thread_Enable_dispatch>
10a41a: 31 d2 xor %edx,%edx
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a41c: 89 d0 mov %edx,%eax
10a41e: 8d 65 f8 lea -0x8(%ebp),%esp
10a421: 5b pop %ebx
10a422: 5e pop %esi
10a423: c9 leave
10a424: c3 ret
0010a268 <rtems_task_variable_add>:
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
10a268: 55 push %ebp
10a269: 89 e5 mov %esp,%ebp
10a26b: 57 push %edi
10a26c: 56 push %esi
10a26d: 53 push %ebx
10a26e: 83 ec 1c sub $0x1c,%esp
10a271: 8b 75 0c mov 0xc(%ebp),%esi
10a274: 8b 7d 10 mov 0x10(%ebp),%edi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
10a277: b8 09 00 00 00 mov $0x9,%eax
10a27c: 85 f6 test %esi,%esi
10a27e: 74 75 je 10a2f5 <rtems_task_variable_add+0x8d><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
10a280: 50 push %eax
10a281: 50 push %eax
10a282: 8d 45 f0 lea -0x10(%ebp),%eax
10a285: 50 push %eax
10a286: ff 75 08 pushl 0x8(%ebp)
10a289: e8 86 1a 00 00 call 10bd14 <_Thread_Get>
10a28e: 89 c3 mov %eax,%ebx
switch (location) {
10a290: 83 c4 10 add $0x10,%esp
10a293: b8 04 00 00 00 mov $0x4,%eax
10a298: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
10a29c: 75 57 jne 10a2f5 <rtems_task_variable_add+0x8d><== NEVER TAKEN
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
10a29e: 8b 83 04 01 00 00 mov 0x104(%ebx),%eax
10a2a4: eb 0c jmp 10a2b2 <rtems_task_variable_add+0x4a>
while (tvp) {
if (tvp->ptr == ptr) {
10a2a6: 39 70 04 cmp %esi,0x4(%eax)
10a2a9: 75 05 jne 10a2b0 <rtems_task_variable_add+0x48>
tvp->dtor = dtor;
10a2ab: 89 78 10 mov %edi,0x10(%eax)
10a2ae: eb 3e jmp 10a2ee <rtems_task_variable_add+0x86>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
10a2b0: 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) {
10a2b2: 85 c0 test %eax,%eax
10a2b4: 75 f0 jne 10a2a6 <rtems_task_variable_add+0x3e>
}
/*
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
10a2b6: 83 ec 0c sub $0xc,%esp
10a2b9: 6a 14 push $0x14
10a2bb: e8 d1 29 00 00 call 10cc91 <_Workspace_Allocate>
10a2c0: 89 c2 mov %eax,%edx
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
10a2c2: 83 c4 10 add $0x10,%esp
10a2c5: 85 c0 test %eax,%eax
10a2c7: 75 0c jne 10a2d5 <rtems_task_variable_add+0x6d>
_Thread_Enable_dispatch();
10a2c9: e8 26 1a 00 00 call 10bcf4 <_Thread_Enable_dispatch>
10a2ce: b8 1a 00 00 00 mov $0x1a,%eax
10a2d3: eb 20 jmp 10a2f5 <rtems_task_variable_add+0x8d>
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
10a2d5: 8b 06 mov (%esi),%eax
10a2d7: 89 42 08 mov %eax,0x8(%edx)
new->ptr = ptr;
10a2da: 89 72 04 mov %esi,0x4(%edx)
new->dtor = dtor;
10a2dd: 89 7a 10 mov %edi,0x10(%edx)
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
10a2e0: 8b 83 04 01 00 00 mov 0x104(%ebx),%eax
10a2e6: 89 02 mov %eax,(%edx)
the_thread->task_variables = new;
10a2e8: 89 93 04 01 00 00 mov %edx,0x104(%ebx)
_Thread_Enable_dispatch();
10a2ee: e8 01 1a 00 00 call 10bcf4 <_Thread_Enable_dispatch>
10a2f3: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a2f5: 8d 65 f4 lea -0xc(%ebp),%esp
10a2f8: 5b pop %ebx
10a2f9: 5e pop %esi
10a2fa: 5f pop %edi
10a2fb: c9 leave
10a2fc: c3 ret
0010a300 <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
10a300: 55 push %ebp
10a301: 89 e5 mov %esp,%ebp
10a303: 56 push %esi
10a304: 53 push %ebx
10a305: 83 ec 10 sub $0x10,%esp
10a308: 8b 75 0c mov 0xc(%ebp),%esi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
10a30b: b8 09 00 00 00 mov $0x9,%eax
10a310: 85 f6 test %esi,%esi
10a312: 74 64 je 10a378 <rtems_task_variable_delete+0x78>
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
10a314: 52 push %edx
10a315: 52 push %edx
10a316: 8d 45 f4 lea -0xc(%ebp),%eax
10a319: 50 push %eax
10a31a: ff 75 08 pushl 0x8(%ebp)
10a31d: e8 f2 19 00 00 call 10bd14 <_Thread_Get>
10a322: 89 c3 mov %eax,%ebx
switch (location) {
10a324: 83 c4 10 add $0x10,%esp
10a327: b8 04 00 00 00 mov $0x4,%eax
10a32c: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10a330: 75 46 jne 10a378 <rtems_task_variable_delete+0x78><== NEVER TAKEN
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
10a332: 8b 93 04 01 00 00 mov 0x104(%ebx),%edx
10a338: 31 c0 xor %eax,%eax
10a33a: eb 2e jmp 10a36a <rtems_task_variable_delete+0x6a>
while (tvp) {
if (tvp->ptr == ptr) {
10a33c: 39 72 04 cmp %esi,0x4(%edx)
10a33f: 75 25 jne 10a366 <rtems_task_variable_delete+0x66>
if (prev)
10a341: 85 c0 test %eax,%eax
10a343: 8b 0a mov (%edx),%ecx
10a345: 74 04 je 10a34b <rtems_task_variable_delete+0x4b>
prev->next = tvp->next;
10a347: 89 08 mov %ecx,(%eax)
10a349: eb 06 jmp 10a351 <rtems_task_variable_delete+0x51>
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
10a34b: 89 8b 04 01 00 00 mov %ecx,0x104(%ebx)
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
10a351: 50 push %eax
10a352: 50 push %eax
10a353: 52 push %edx
10a354: 53 push %ebx
10a355: e8 8e 00 00 00 call 10a3e8 <_RTEMS_Tasks_Invoke_task_variable_dtor>
_Thread_Enable_dispatch();
10a35a: e8 95 19 00 00 call 10bcf4 <_Thread_Enable_dispatch>
10a35f: 31 c0 xor %eax,%eax
10a361: 83 c4 10 add $0x10,%esp
10a364: eb 12 jmp 10a378 <rtems_task_variable_delete+0x78>
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
10a366: 89 d0 mov %edx,%eax
10a368: 8b 12 mov (%edx),%edx
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
10a36a: 85 d2 test %edx,%edx
10a36c: 75 ce jne 10a33c <rtems_task_variable_delete+0x3c>
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
10a36e: e8 81 19 00 00 call 10bcf4 <_Thread_Enable_dispatch>
10a373: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a378: 8d 65 f8 lea -0x8(%ebp),%esp
10a37b: 5b pop %ebx
10a37c: 5e pop %esi
10a37d: c9 leave
10a37e: c3 ret
0010a380 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
10a380: 55 push %ebp
10a381: 89 e5 mov %esp,%ebp
10a383: 56 push %esi
10a384: 53 push %ebx
10a385: 83 ec 10 sub $0x10,%esp
10a388: 8b 5d 0c mov 0xc(%ebp),%ebx
10a38b: 8b 75 10 mov 0x10(%ebp),%esi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
10a38e: 85 db test %ebx,%ebx
10a390: 74 48 je 10a3da <rtems_task_variable_get+0x5a>
return RTEMS_INVALID_ADDRESS;
if ( !result )
10a392: 85 f6 test %esi,%esi
10a394: 74 44 je 10a3da <rtems_task_variable_get+0x5a>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
10a396: 50 push %eax
10a397: 50 push %eax
10a398: 8d 45 f4 lea -0xc(%ebp),%eax
10a39b: 50 push %eax
10a39c: ff 75 08 pushl 0x8(%ebp)
10a39f: e8 70 19 00 00 call 10bd14 <_Thread_Get>
10a3a4: 89 c2 mov %eax,%edx
switch (location) {
10a3a6: 83 c4 10 add $0x10,%esp
10a3a9: b8 04 00 00 00 mov $0x4,%eax
10a3ae: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10a3b2: 75 2b jne 10a3df <rtems_task_variable_get+0x5f><== NEVER TAKEN
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
10a3b4: 8b 82 04 01 00 00 mov 0x104(%edx),%eax
10a3ba: eb 15 jmp 10a3d1 <rtems_task_variable_get+0x51>
while (tvp) {
if (tvp->ptr == ptr) {
10a3bc: 39 58 04 cmp %ebx,0x4(%eax)
10a3bf: 75 0e jne 10a3cf <rtems_task_variable_get+0x4f>
/*
* Should this return the current (i.e not the
* saved) value if `tid' is the current task?
*/
*result = tvp->tval;
10a3c1: 8b 40 0c mov 0xc(%eax),%eax
10a3c4: 89 06 mov %eax,(%esi)
_Thread_Enable_dispatch();
10a3c6: e8 29 19 00 00 call 10bcf4 <_Thread_Enable_dispatch>
10a3cb: 31 c0 xor %eax,%eax
10a3cd: eb 10 jmp 10a3df <rtems_task_variable_get+0x5f>
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
10a3cf: 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) {
10a3d1: 85 c0 test %eax,%eax
10a3d3: 75 e7 jne 10a3bc <rtems_task_variable_get+0x3c>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
10a3d5: e8 1a 19 00 00 call 10bcf4 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
10a3da: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a3df: 8d 65 f8 lea -0x8(%ebp),%esp
10a3e2: 5b pop %ebx
10a3e3: 5e pop %esi
10a3e4: c9 leave
10a3e5: c3 ret
0010a150 <rtems_task_wake_when>:
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
10a150: 55 push %ebp
10a151: 89 e5 mov %esp,%ebp
10a153: 53 push %ebx
10a154: 83 ec 04 sub $0x4,%esp
10a157: 8b 5d 08 mov 0x8(%ebp),%ebx
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
10a15a: b8 0b 00 00 00 mov $0xb,%eax
10a15f: 80 3d d0 0d 12 00 00 cmpb $0x0,0x120dd0
10a166: 0f 84 9e 00 00 00 je 10a20a <rtems_task_wake_when+0xba>
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
10a16c: b8 09 00 00 00 mov $0x9,%eax
10a171: 85 db test %ebx,%ebx
10a173: 0f 84 91 00 00 00 je 10a20a <rtems_task_wake_when+0xba><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
10a179: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
if ( !_TOD_Validate( time_buffer ) )
10a180: 83 ec 0c sub $0xc,%esp
10a183: 53 push %ebx
10a184: e8 d7 f4 ff ff call 109660 <_TOD_Validate>
10a189: 83 c4 10 add $0x10,%esp
10a18c: 84 c0 test %al,%al
10a18e: 74 75 je 10a205 <rtems_task_wake_when+0xb5>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
10a190: 83 ec 0c sub $0xc,%esp
10a193: 53 push %ebx
10a194: e8 5f f4 ff ff call 1095f8 <_TOD_To_seconds>
10a199: 89 c3 mov %eax,%ebx
if ( seconds <= _TOD_Seconds_since_epoch )
10a19b: 83 c4 10 add $0x10,%esp
10a19e: 3b 05 4c 0e 12 00 cmp 0x120e4c,%eax
10a1a4: 76 5f jbe 10a205 <rtems_task_wake_when+0xb5>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10a1a6: a1 bc 0d 12 00 mov 0x120dbc,%eax
10a1ab: 40 inc %eax
10a1ac: a3 bc 0d 12 00 mov %eax,0x120dbc
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
10a1b1: 50 push %eax
10a1b2: 50 push %eax
10a1b3: 6a 10 push $0x10
10a1b5: ff 35 7c 0e 12 00 pushl 0x120e7c
10a1bb: e8 24 21 00 00 call 10c2e4 <_Thread_Set_state>
_Watchdog_Initialize(
10a1c0: a1 7c 0e 12 00 mov 0x120e7c,%eax
10a1c5: 8b 50 08 mov 0x8(%eax),%edx
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
10a1c8: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
* @param[in] the_heap is the heap to operate upon
10a1cf: c7 40 64 78 b9 10 00 movl $0x10b978,0x64(%eax)
* @param[in] starting_address is the starting address of the memory for
10a1d6: 89 50 68 mov %edx,0x68(%eax)
* the heap
10a1d9: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax)
* @return TRUE if successfully able to resize the block.
* FALSE if the block can't be resized in place.
*/
bool _Protected_heap_Resize_block(
Heap_Control *the_heap,
void *starting_address,
10a1e0: 2b 1d 4c 0e 12 00 sub 0x120e4c,%ebx
10a1e6: 89 58 54 mov %ebx,0x54(%eax)
size_t size
);
10a1e9: 5a pop %edx
10a1ea: 59 pop %ecx
10a1eb: 83 c0 48 add $0x48,%eax
10a1ee: 50 push %eax
10a1ef: 68 90 0e 12 00 push $0x120e90
10a1f4: e8 03 27 00 00 call 10c8fc <_Watchdog_Insert>
);
_Watchdog_Insert_seconds(
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch
);
_Thread_Enable_dispatch();
10a1f9: e8 f6 18 00 00 call 10baf4 <_Thread_Enable_dispatch>
10a1fe: 31 c0 xor %eax,%eax
10a200: 83 c4 10 add $0x10,%esp
10a203: eb 05 jmp 10a20a <rtems_task_wake_when+0xba>
return RTEMS_SUCCESSFUL;
10a205: b8 14 00 00 00 mov $0x14,%eax
}
10a20a: 8b 5d fc mov -0x4(%ebp),%ebx
10a20d: c9 leave
10a20e: c3 ret
001071a0 <rtems_termios_bufsize>:
rtems_status_code rtems_termios_bufsize (
int cbufsize,
int raw_input,
int raw_output
)
{
1071a0: 55 push %ebp <== NOT EXECUTED
1071a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
rtems_termios_cbufsize = cbufsize;
1071a3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
1071a6: a3 3c b6 11 00 mov %eax,0x11b63c <== NOT EXECUTED
rtems_termios_raw_input_size = raw_input;
1071ab: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
1071ae: a3 40 b6 11 00 mov %eax,0x11b640 <== NOT EXECUTED
rtems_termios_raw_output_size = raw_output;
1071b3: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
1071b6: a3 44 b6 11 00 mov %eax,0x11b644 <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
1071bb: 31 c0 xor %eax,%eax <== NOT EXECUTED
1071bd: c9 leave <== NOT EXECUTED
1071be: c3 ret <== NOT EXECUTED
0010833e <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
10833e: 55 push %ebp
10833f: 89 e5 mov %esp,%ebp
108341: 56 push %esi
108342: 53 push %ebx
108343: 8b 75 08 mov 0x8(%ebp),%esi
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
108346: 8b 06 mov (%esi),%eax
108348: 8b 58 28 mov 0x28(%eax),%ebx
rtems_status_code sc;
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
10834b: 50 push %eax
10834c: 6a 00 push $0x0
10834e: 6a 00 push $0x0
108350: ff 35 d4 d6 11 00 pushl 0x11d6d4
108356: e8 19 0e 00 00 call 109174 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
10835b: 83 c4 10 add $0x10,%esp
10835e: 85 c0 test %eax,%eax
108360: 75 69 jne 1083cb <rtems_termios_close+0x8d><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
108362: 8b 43 08 mov 0x8(%ebx),%eax
108365: 48 dec %eax
108366: 89 43 08 mov %eax,0x8(%ebx)
108369: 85 c0 test %eax,%eax
10836b: 0f 85 1f 01 00 00 jne 108490 <rtems_termios_close+0x152>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
108371: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
108377: c1 e0 05 shl $0x5,%eax
10837a: 8b 80 50 d4 11 00 mov 0x11d450(%eax),%eax
108380: 85 c0 test %eax,%eax
108382: 74 0b je 10838f <rtems_termios_close+0x51><== ALWAYS TAKEN
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
108384: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108387: 53 push %ebx <== NOT EXECUTED
108388: ff d0 call *%eax <== NOT EXECUTED
10838a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10838d: eb 07 jmp 108396 <rtems_termios_close+0x58><== NOT EXECUTED
}
else {
/*
* default: just flush output buffer
*/
drainOutput (tty);
10838f: 89 d8 mov %ebx,%eax
108391: e8 ec f8 ff ff call 107c82 <drainOutput>
}
if (tty->device.outputUsesInterrupts
108396: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
10839d: 75 35 jne 1083d4 <rtems_termios_close+0x96><== ALWAYS TAKEN
== TERMIOS_TASK_DRIVEN) {
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send(
10839f: 50 push %eax <== NOT EXECUTED
1083a0: 50 push %eax <== NOT EXECUTED
1083a1: 6a 01 push $0x1 <== NOT EXECUTED
1083a3: ff b3 c4 00 00 00 pushl 0xc4(%ebx) <== NOT EXECUTED
1083a9: e8 36 09 00 00 call 108ce4 <rtems_event_send> <== NOT EXECUTED
tty->rxTaskId,
TERMIOS_RX_TERMINATE_EVENT);
if (sc != RTEMS_SUCCESSFUL)
1083ae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1083b1: 85 c0 test %eax,%eax <== NOT EXECUTED
1083b3: 75 16 jne 1083cb <rtems_termios_close+0x8d><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_event_send(
1083b5: 51 push %ecx <== NOT EXECUTED
1083b6: 51 push %ecx <== NOT EXECUTED
1083b7: 6a 01 push $0x1 <== NOT EXECUTED
1083b9: ff b3 c8 00 00 00 pushl 0xc8(%ebx) <== NOT EXECUTED
1083bf: e8 20 09 00 00 call 108ce4 <rtems_event_send> <== NOT EXECUTED
tty->txTaskId,
TERMIOS_TX_TERMINATE_EVENT);
if (sc != RTEMS_SUCCESSFUL)
1083c4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1083c7: 85 c0 test %eax,%eax <== NOT EXECUTED
1083c9: 74 09 je 1083d4 <rtems_termios_close+0x96><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
1083cb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1083ce: 50 push %eax <== NOT EXECUTED
1083cf: e8 c0 13 00 00 call 109794 <rtems_fatal_error_occurred><== NOT EXECUTED
}
if (tty->device.lastClose)
1083d4: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax
1083da: 85 c0 test %eax,%eax
1083dc: 74 0d je 1083eb <rtems_termios_close+0xad><== NEVER TAKEN
(*tty->device.lastClose)(tty->major, tty->minor, arg);
1083de: 52 push %edx
1083df: 56 push %esi
1083e0: ff 73 10 pushl 0x10(%ebx)
1083e3: ff 73 0c pushl 0xc(%ebx)
1083e6: ff d0 call *%eax
1083e8: 83 c4 10 add $0x10,%esp
if (tty->forw == NULL) {
1083eb: 8b 13 mov (%ebx),%edx
1083ed: 85 d2 test %edx,%edx
1083ef: 8b 43 04 mov 0x4(%ebx),%eax
1083f2: 75 11 jne 108405 <rtems_termios_close+0xc7><== NEVER TAKEN
rtems_termios_ttyTail = tty->back;
1083f4: a3 d8 d6 11 00 mov %eax,0x11d6d8
if ( rtems_termios_ttyTail != NULL ) {
1083f9: 85 c0 test %eax,%eax
1083fb: 74 0b je 108408 <rtems_termios_close+0xca><== ALWAYS TAKEN
rtems_termios_ttyTail->forw = NULL;
1083fd: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
108403: eb 03 jmp 108408 <rtems_termios_close+0xca><== NOT EXECUTED
}
}
else {
tty->forw->back = tty->back;
108405: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED
}
if (tty->back == NULL) {
108408: 8b 53 04 mov 0x4(%ebx),%edx
10840b: 85 d2 test %edx,%edx
10840d: 8b 03 mov (%ebx),%eax
10840f: 75 12 jne 108423 <rtems_termios_close+0xe5><== NEVER TAKEN
rtems_termios_ttyHead = tty->forw;
108411: a3 dc d6 11 00 mov %eax,0x11d6dc
if ( rtems_termios_ttyHead != NULL ) {
108416: 85 c0 test %eax,%eax
108418: 74 0b je 108425 <rtems_termios_close+0xe7><== ALWAYS TAKEN
rtems_termios_ttyHead->back = NULL;
10841a: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) <== NOT EXECUTED
108421: eb 02 jmp 108425 <rtems_termios_close+0xe7><== NOT EXECUTED
}
}
else {
tty->back->forw = tty->forw;
108423: 89 02 mov %eax,(%edx) <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
108425: 83 ec 0c sub $0xc,%esp
108428: ff 73 14 pushl 0x14(%ebx)
10842b: e8 b4 0c 00 00 call 1090e4 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
108430: 58 pop %eax
108431: ff 73 18 pushl 0x18(%ebx)
108434: e8 ab 0c 00 00 call 1090e4 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
108439: 58 pop %eax
10843a: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
108440: e8 9f 0c 00 00 call 1090e4 <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
108445: 83 c4 10 add $0x10,%esp
108448: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx)
10844f: 74 09 je 10845a <rtems_termios_close+0x11c><== ALWAYS TAKEN
108451: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) <== NOT EXECUTED
108458: 75 0e jne 108468 <rtems_termios_close+0x12a><== NOT EXECUTED
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
10845a: 83 ec 0c sub $0xc,%esp
10845d: ff 73 68 pushl 0x68(%ebx)
108460: e8 7f 0c 00 00 call 1090e4 <rtems_semaphore_delete>
108465: 83 c4 10 add $0x10,%esp
free (tty->rawInBuf.theBuf);
108468: 83 ec 0c sub $0xc,%esp
10846b: ff 73 58 pushl 0x58(%ebx)
10846e: e8 05 e0 ff ff call 106478 <free>
free (tty->rawOutBuf.theBuf);
108473: 5e pop %esi
108474: ff 73 7c pushl 0x7c(%ebx)
108477: e8 fc df ff ff call 106478 <free>
free (tty->cbuf);
10847c: 59 pop %ecx
10847d: ff 73 1c pushl 0x1c(%ebx)
108480: e8 f3 df ff ff call 106478 <free>
free (tty);
108485: 89 1c 24 mov %ebx,(%esp)
108488: e8 eb df ff ff call 106478 <free>
10848d: 83 c4 10 add $0x10,%esp
}
rtems_semaphore_release (rtems_termios_ttyMutex);
108490: 83 ec 0c sub $0xc,%esp
108493: ff 35 d4 d6 11 00 pushl 0x11d6d4
108499: e8 be 0d 00 00 call 10925c <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
10849e: 31 c0 xor %eax,%eax
1084a0: 8d 65 f8 lea -0x8(%ebp),%esp
1084a3: 5b pop %ebx
1084a4: 5e pop %esi
1084a5: c9 leave
1084a6: c3 ret
001073a7 <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)
{
1073a7: 55 push %ebp
1073a8: 89 e5 mov %esp,%ebp
1073aa: 83 ec 08 sub $0x8,%esp
1073ad: 8b 55 08 mov 0x8(%ebp),%edx
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
1073b0: 8b 45 0c mov 0xc(%ebp),%eax
1073b3: 01 82 90 00 00 00 add %eax,0x90(%edx)
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
1073b9: 83 ba b4 00 00 00 02 cmpl $0x2,0xb4(%edx)
1073c0: 75 1f jne 1073e1 <rtems_termios_dequeue_characters+0x3a><== ALWAYS TAKEN
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId,
1073c2: 50 push %eax <== NOT EXECUTED
1073c3: 50 push %eax <== NOT EXECUTED
1073c4: 6a 02 push $0x2 <== NOT EXECUTED
1073c6: ff b2 c8 00 00 00 pushl 0xc8(%edx) <== NOT EXECUTED
1073cc: e8 13 19 00 00 call 108ce4 <rtems_event_send> <== NOT EXECUTED
TERMIOS_TX_START_EVENT);
if (sc != RTEMS_SUCCESSFUL)
1073d1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1073d4: 85 c0 test %eax,%eax <== NOT EXECUTED
1073d6: 74 2f je 107407 <rtems_termios_dequeue_characters+0x60><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
1073d8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1073db: 50 push %eax <== NOT EXECUTED
1073dc: e8 b3 23 00 00 call 109794 <rtems_fatal_error_occurred><== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
else if (tty->t_line == PPPDISC ) {
1073e1: 83 ba cc 00 00 00 05 cmpl $0x5,0xcc(%edx)
1073e8: 75 14 jne 1073fe <rtems_termios_dequeue_characters+0x57><== ALWAYS TAKEN
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
1073ea: a1 00 d5 11 00 mov 0x11d500,%eax <== NOT EXECUTED
1073ef: 85 c0 test %eax,%eax <== NOT EXECUTED
1073f1: 74 14 je 107407 <rtems_termios_dequeue_characters+0x60><== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
1073f3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1073f6: 52 push %edx <== NOT EXECUTED
1073f7: ff d0 call *%eax <== NOT EXECUTED
1073f9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1073fc: eb 09 jmp 107407 <rtems_termios_dequeue_characters+0x60><== NOT EXECUTED
}
return 0; /* nothing to output in IRQ... */
}
else {
return rtems_termios_refill_transmitter(tty);
1073fe: 89 55 08 mov %edx,0x8(%ebp)
}
}
107401: c9 leave
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
else {
return rtems_termios_refill_transmitter(tty);
107402: e9 d3 fd ff ff jmp 1071da <rtems_termios_refill_transmitter>
}
}
107407: 31 c0 xor %eax,%eax
107409: c9 leave <== NOT EXECUTED
10740a: c3 ret <== NOT EXECUTED
0010740b <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)
{
10740b: 55 push %ebp <== NOT EXECUTED
10740c: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10740e: 57 push %edi <== NOT EXECUTED
10740f: 56 push %esi <== NOT EXECUTED
107410: 53 push %ebx <== NOT EXECUTED
107411: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED
107414: 8b 5d 08 mov 0x8(%ebp),%ebx <== 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) {
107417: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED
10741d: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
107420: 83 b8 5c d4 11 00 00 cmpl $0x0,0x11d45c(%eax) <== NOT EXECUTED
107427: 75 37 jne 107460 <rtems_termios_enqueue_raw_characters+0x55><== NOT EXECUTED
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,
107429: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED
10742c: 89 45 e4 mov %eax,-0x1c(%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);
10742f: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED
107432: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED
107435: 31 ff xor %edi,%edi <== NOT EXECUTED
107437: c6 45 ea 00 movb $0x0,-0x16(%ebp) <== NOT EXECUTED
10743b: e9 27 02 00 00 jmp 107667 <rtems_termios_enqueue_raw_characters+0x25c><== NOT EXECUTED
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--) {
c = *buf++;
107440: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
107443: 0f be 11 movsbl (%ecx),%edx <== NOT EXECUTED
107446: 41 inc %ecx <== NOT EXECUTED
107447: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
10744a: 56 push %esi <== NOT EXECUTED
10744b: 56 push %esi <== NOT EXECUTED
10744c: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED
107452: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
107455: 53 push %ebx <== NOT EXECUTED
107456: 52 push %edx <== NOT EXECUTED
107457: ff 90 5c d4 11 00 call *0x11d45c(%eax) <== NOT EXECUTED
10745d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
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--) {
107460: ff 4d 10 decl 0x10(%ebp) <== NOT EXECUTED
107463: 83 7d 10 ff cmpl $0xffffffff,0x10(%ebp) <== NOT EXECUTED
107467: 75 d7 jne 107440 <rtems_termios_enqueue_raw_characters+0x35><== NOT EXECUTED
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
107469: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx) <== NOT EXECUTED
107470: 0f 85 11 02 00 00 jne 107687 <rtems_termios_enqueue_raw_characters+0x27c><== NOT EXECUTED
107476: 8b 93 dc 00 00 00 mov 0xdc(%ebx),%edx <== NOT EXECUTED
10747c: 85 d2 test %edx,%edx <== NOT EXECUTED
10747e: 0f 84 03 02 00 00 je 107687 <rtems_termios_enqueue_raw_characters+0x27c><== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
107484: 51 push %ecx <== NOT EXECUTED
107485: 51 push %ecx <== NOT EXECUTED
107486: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED
10748c: 8d 43 30 lea 0x30(%ebx),%eax <== NOT EXECUTED
10748f: 50 push %eax <== NOT EXECUTED
107490: ff d2 call *%edx <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
107492: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED
107499: 00 00 00
10749c: 31 ff xor %edi,%edi <== NOT EXECUTED
10749e: e9 df 01 00 00 jmp 107682 <rtems_termios_enqueue_raw_characters+0x277><== NOT EXECUTED
}
return 0;
}
while (len--) {
c = *buf++;
1074a3: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
1074a6: 8a 00 mov (%eax),%al <== NOT EXECUTED
1074a8: 88 45 eb mov %al,-0x15(%ebp) <== NOT EXECUTED
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
1074ab: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1074b1: f6 c4 02 test $0x2,%ah <== NOT EXECUTED
1074b4: 74 43 je 1074f9 <rtems_termios_enqueue_raw_characters+0xee><== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
1074b6: 0f be 55 eb movsbl -0x15(%ebp),%edx <== NOT EXECUTED
1074ba: 0f b6 43 4a movzbl 0x4a(%ebx),%eax <== NOT EXECUTED
1074be: 39 c2 cmp %eax,%edx <== NOT EXECUTED
1074c0: 75 1e jne 1074e0 <rtems_termios_enqueue_raw_characters+0xd5><== NOT EXECUTED
if (c == tty->termios.c_cc[VSTART]) {
1074c2: 0f b6 43 49 movzbl 0x49(%ebx),%eax <== NOT EXECUTED
1074c6: 39 c2 cmp %eax,%edx <== NOT EXECUTED
1074c8: 75 0b jne 1074d5 <rtems_termios_enqueue_raw_characters+0xca><== NOT EXECUTED
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
1074ca: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1074d0: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED
1074d3: eb 1c jmp 1074f1 <rtems_termios_enqueue_raw_characters+0xe6><== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
1074d5: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1074db: 83 c8 10 or $0x10,%eax <== NOT EXECUTED
1074de: eb 11 jmp 1074f1 <rtems_termios_enqueue_raw_characters+0xe6><== NOT EXECUTED
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
1074e0: 0f b6 43 49 movzbl 0x49(%ebx),%eax <== NOT EXECUTED
1074e4: 39 c2 cmp %eax,%edx <== NOT EXECUTED
1074e6: 75 11 jne 1074f9 <rtems_termios_enqueue_raw_characters+0xee><== NOT EXECUTED
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
1074e8: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1074ee: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED
1074f1: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
1074f7: eb 06 jmp 1074ff <rtems_termios_enqueue_raw_characters+0xf4><== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
1074f9: 80 7d ea 00 cmpb $0x0,-0x16(%ebp) <== NOT EXECUTED
1074fd: 74 55 je 107554 <rtems_termios_enqueue_raw_characters+0x149><== NOT EXECUTED
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
1074ff: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
107505: 83 e0 30 and $0x30,%eax <== NOT EXECUTED
107508: c6 45 ea 01 movb $0x1,-0x16(%ebp) <== NOT EXECUTED
10750c: 83 f8 20 cmp $0x20,%eax <== NOT EXECUTED
10750f: 0f 85 4f 01 00 00 jne 107664 <rtems_termios_enqueue_raw_characters+0x259><== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
107515: 9c pushf <== NOT EXECUTED
107516: fa cli <== NOT EXECUTED
107517: 5e pop %esi <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
107518: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10751e: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
107521: 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) {
107527: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
10752e: 74 19 je 107549 <rtems_termios_enqueue_raw_characters+0x13e><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
107530: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED
107536: 52 push %edx <== NOT EXECUTED
107537: 6a 01 push $0x1 <== NOT EXECUTED
107539: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED
10753c: 50 push %eax <== NOT EXECUTED
10753d: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
107540: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
107546: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
107549: 56 push %esi <== NOT EXECUTED
10754a: 9d popf <== NOT EXECUTED
10754b: c6 45 ea 01 movb $0x1,-0x16(%ebp) <== NOT EXECUTED
10754f: e9 10 01 00 00 jmp 107664 <rtems_termios_enqueue_raw_characters+0x259><== NOT EXECUTED
}
}
else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
107554: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED
107557: 8b 4b 64 mov 0x64(%ebx),%ecx <== NOT EXECUTED
10755a: 40 inc %eax <== NOT EXECUTED
10755b: 31 d2 xor %edx,%edx <== NOT EXECUTED
10755d: f7 f1 div %ecx <== NOT EXECUTED
10755f: 89 d6 mov %edx,%esi <== NOT EXECUTED
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
107561: 9c pushf <== NOT EXECUTED
107562: fa cli <== NOT EXECUTED
107563: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
107566: 8b 4b 5c mov 0x5c(%ebx),%ecx <== NOT EXECUTED
107569: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED
10756c: 8b 53 64 mov 0x64(%ebx),%edx <== NOT EXECUTED
10756f: 29 c8 sub %ecx,%eax <== NOT EXECUTED
107571: 01 f0 add %esi,%eax <== NOT EXECUTED
107573: 89 d1 mov %edx,%ecx <== NOT EXECUTED
107575: 31 d2 xor %edx,%edx <== NOT EXECUTED
107577: f7 f1 div %ecx <== NOT EXECUTED
107579: 3b 93 c0 00 00 00 cmp 0xc0(%ebx),%edx <== NOT EXECUTED
10757f: 0f 86 98 00 00 00 jbe 10761d <rtems_termios_enqueue_raw_characters+0x212><== NOT EXECUTED
107585: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10758b: a8 01 test $0x1,%al <== NOT EXECUTED
10758d: 0f 85 8a 00 00 00 jne 10761d <rtems_termios_enqueue_raw_characters+0x212><== NOT EXECUTED
% tty->rawInBuf.Size)
> tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
107593: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
107599: 83 c8 01 or $0x1,%eax <== NOT EXECUTED
10759c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
1075a2: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1075a8: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED
1075ad: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED
1075b2: 75 33 jne 1075e7 <rtems_termios_enqueue_raw_characters+0x1dc><== NOT EXECUTED
== (FL_MDXOF ) ){
if ((tty->flow_ctrl & FL_OSTOP) ||
1075b4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1075ba: a8 20 test $0x20,%al <== NOT EXECUTED
1075bc: 75 09 jne 1075c7 <rtems_termios_enqueue_raw_characters+0x1bc><== NOT EXECUTED
1075be: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
1075c5: 75 56 jne 10761d <rtems_termios_enqueue_raw_characters+0x212><== 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;
1075c7: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1075cd: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
1075d0: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
(*tty->device.write)(tty->minor,
1075d6: 51 push %ecx <== NOT EXECUTED
1075d7: 6a 01 push $0x1 <== NOT EXECUTED
1075d9: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED
1075dc: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
1075df: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
1075e5: eb 33 jmp 10761a <rtems_termios_enqueue_raw_characters+0x20f><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]),
1);
}
}
else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF))
1075e7: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1075ed: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED
1075f2: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED
1075f7: 75 24 jne 10761d <rtems_termios_enqueue_raw_characters+0x212><== NOT EXECUTED
== (FL_MDRTS ) ) {
tty->flow_ctrl |= FL_IRTSOFF;
1075f9: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1075ff: 83 c8 04 or $0x4,%eax <== NOT EXECUTED
107602: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
107608: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax <== NOT EXECUTED
10760e: 85 c0 test %eax,%eax <== NOT EXECUTED
107610: 74 0b je 10761d <rtems_termios_enqueue_raw_characters+0x212><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
107612: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107615: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
107618: ff d0 call *%eax <== NOT EXECUTED
10761a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
10761d: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED
107620: 9d popf <== NOT EXECUTED
if (newTail == tty->rawInBuf.Head) {
107621: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED
107624: 39 c6 cmp %eax,%esi <== NOT EXECUTED
107626: 75 03 jne 10762b <rtems_termios_enqueue_raw_characters+0x220><== NOT EXECUTED
dropped++;
107628: 47 inc %edi <== NOT EXECUTED
107629: eb 39 jmp 107664 <rtems_termios_enqueue_raw_characters+0x259><== NOT EXECUTED
}
else {
tty->rawInBuf.theBuf[newTail] = c;
10762b: 8b 43 58 mov 0x58(%ebx),%eax <== NOT EXECUTED
10762e: 8a 55 eb mov -0x15(%ebp),%dl <== NOT EXECUTED
107631: 88 14 30 mov %dl,(%eax,%esi,1) <== NOT EXECUTED
tty->rawInBuf.Tail = newTail;
107634: 89 73 60 mov %esi,0x60(%ebx) <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
107637: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx) <== NOT EXECUTED
10763e: 75 24 jne 107664 <rtems_termios_enqueue_raw_characters+0x259><== NOT EXECUTED
107640: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax <== NOT EXECUTED
107646: 85 c0 test %eax,%eax <== NOT EXECUTED
107648: 74 1a je 107664 <rtems_termios_enqueue_raw_characters+0x259><== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
10764a: 52 push %edx <== NOT EXECUTED
10764b: 52 push %edx <== NOT EXECUTED
10764c: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED
107652: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED
107655: ff d0 call *%eax <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
107657: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED
10765e: 00 00 00
107661: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
return 0;
}
while (len--) {
c = *buf++;
107664: ff 45 0c incl 0xc(%ebp) <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
107667: ff 4d 10 decl 0x10(%ebp) <== NOT EXECUTED
10766a: 83 7d 10 ff cmpl $0xffffffff,0x10(%ebp) <== NOT EXECUTED
10766e: 0f 85 2f fe ff ff jne 1074a3 <rtems_termios_enqueue_raw_characters+0x98><== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
}
}
}
tty->rawInBufDropped += dropped;
107674: 01 7b 78 add %edi,0x78(%ebx) <== NOT EXECUTED
rtems_semaphore_release (tty->rawInBuf.Semaphore);
107677: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10767a: ff 73 68 pushl 0x68(%ebx) <== NOT EXECUTED
10767d: e8 da 1b 00 00 call 10925c <rtems_semaphore_release><== NOT EXECUTED
107682: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107685: eb 02 jmp 107689 <rtems_termios_enqueue_raw_characters+0x27e><== NOT EXECUTED
return dropped;
107687: 31 ff xor %edi,%edi <== NOT EXECUTED
}
107689: 89 f8 mov %edi,%eax <== NOT EXECUTED
10768b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10768e: 5b pop %ebx <== NOT EXECUTED
10768f: 5e pop %esi <== NOT EXECUTED
107690: 5f pop %edi <== NOT EXECUTED
107691: c9 leave <== NOT EXECUTED
107692: c3 ret <== NOT EXECUTED
00107164 <rtems_termios_initialize>:
struct rtems_termios_tty *rtems_termios_ttyTail;
rtems_id rtems_termios_ttyMutex;
void
rtems_termios_initialize (void)
{
107164: 55 push %ebp
107165: 89 e5 mov %esp,%ebp
107167: 83 ec 08 sub $0x8,%esp
rtems_status_code sc;
/*
* Create the mutex semaphore for the tty list
*/
if (!rtems_termios_ttyMutex) {
10716a: 83 3d d4 d6 11 00 00 cmpl $0x0,0x11d6d4
107171: 75 28 jne 10719b <rtems_termios_initialize+0x37><== NEVER TAKEN
sc = rtems_semaphore_create (
107173: 83 ec 0c sub $0xc,%esp
107176: 68 d4 d6 11 00 push $0x11d6d4
10717b: 6a 00 push $0x0
10717d: 6a 54 push $0x54
10717f: 6a 01 push $0x1
107181: 68 69 6d 52 54 push $0x54526d69
107186: e8 b5 1d 00 00 call 108f40 <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)
10718b: 83 c4 20 add $0x20,%esp
10718e: 85 c0 test %eax,%eax
107190: 74 09 je 10719b <rtems_termios_initialize+0x37><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
107192: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107195: 50 push %eax <== NOT EXECUTED
107196: e8 f9 25 00 00 call 109794 <rtems_fatal_error_occurred><== NOT EXECUTED
}
}
10719b: c9 leave
10719c: c3 ret
00107fe9 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
107fe9: 55 push %ebp <== NOT EXECUTED
107fea: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107fec: 57 push %edi <== NOT EXECUTED
107fed: 56 push %esi <== NOT EXECUTED
107fee: 53 push %ebx <== NOT EXECUTED
107fef: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
107ff2: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
107ff5: 8b 02 mov (%edx),%eax <== NOT EXECUTED
107ff7: 8b 58 28 mov 0x28(%eax),%ebx <== NOT EXECUTED
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
107ffa: 8b 72 08 mov 0x8(%edx),%esi <== NOT EXECUTED
rtems_status_code sc;
args->ioctl_return = 0;
107ffd: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
108004: 6a 00 push $0x0 <== NOT EXECUTED
108006: 6a 00 push $0x0 <== NOT EXECUTED
108008: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED
10800b: e8 64 11 00 00 call 109174 <rtems_semaphore_obtain><== NOT EXECUTED
108010: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
108013: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108016: 85 c0 test %eax,%eax <== NOT EXECUTED
108018: 74 0b je 108025 <rtems_termios_ioctl+0x3c><== NOT EXECUTED
args->ioctl_return = sc;
10801a: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
10801d: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED
108020: e9 0e 03 00 00 jmp 108333 <rtems_termios_ioctl+0x34a><== NOT EXECUTED
return sc;
}
switch (args->command) {
108025: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
108028: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED
10802b: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED
10802e: 0f 84 56 02 00 00 je 10828a <rtems_termios_ioctl+0x2a1><== NOT EXECUTED
108034: 77 10 ja 108046 <rtems_termios_ioctl+0x5d><== NOT EXECUTED
108036: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED
108039: 74 75 je 1080b0 <rtems_termios_ioctl+0xc7><== NOT EXECUTED
10803b: 0f 87 27 02 00 00 ja 108268 <rtems_termios_ioctl+0x27f><== NOT EXECUTED
108041: 48 dec %eax <== NOT EXECUTED
108042: 75 2f jne 108073 <rtems_termios_ioctl+0x8a><== NOT EXECUTED
108044: eb 55 jmp 10809b <rtems_termios_ioctl+0xb2><== NOT EXECUTED
108046: 3d 7f 66 04 40 cmp $0x4004667f,%eax <== NOT EXECUTED
10804b: 0f 84 ae 02 00 00 je 1082ff <rtems_termios_ioctl+0x316><== NOT EXECUTED
108051: 77 0a ja 10805d <rtems_termios_ioctl+0x74><== NOT EXECUTED
108053: 83 f8 05 cmp $0x5,%eax <== NOT EXECUTED
108056: 75 1b jne 108073 <rtems_termios_ioctl+0x8a><== NOT EXECUTED
108058: e9 17 02 00 00 jmp 108274 <rtems_termios_ioctl+0x28b><== NOT EXECUTED
10805d: 3d 1a 74 04 40 cmp $0x4004741a,%eax <== NOT EXECUTED
108062: 0f 84 87 02 00 00 je 1082ef <rtems_termios_ioctl+0x306><== NOT EXECUTED
108068: 3d 1b 74 04 80 cmp $0x8004741b,%eax <== NOT EXECUTED
10806d: 0f 84 2a 02 00 00 je 10829d <rtems_termios_ioctl+0x2b4><== NOT EXECUTED
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
108073: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED
108079: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
10807c: 8b 80 64 d4 11 00 mov 0x11d464(%eax),%eax <== NOT EXECUTED
108082: c7 45 e0 0a 00 00 00 movl $0xa,-0x20(%ebp) <== NOT EXECUTED
108089: 85 c0 test %eax,%eax <== NOT EXECUTED
10808b: 0f 84 8b 02 00 00 je 10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
108091: 52 push %edx <== NOT EXECUTED
108092: 52 push %edx <== NOT EXECUTED
108093: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
108096: e9 49 02 00 00 jmp 1082e4 <rtems_termios_ioctl+0x2fb><== NOT EXECUTED
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
10809b: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
10809e: 8b 79 08 mov 0x8(%ecx),%edi <== NOT EXECUTED
1080a1: 8d 73 30 lea 0x30(%ebx),%esi <== NOT EXECUTED
1080a4: b9 09 00 00 00 mov $0x9,%ecx <== NOT EXECUTED
1080a9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
1080ab: e9 6c 02 00 00 jmp 10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
1080b0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
1080b3: 8b 70 08 mov 0x8(%eax),%esi <== NOT EXECUTED
1080b6: 8d 7b 30 lea 0x30(%ebx),%edi <== NOT EXECUTED
1080b9: b9 09 00 00 00 mov $0x9,%ecx <== NOT EXECUTED
1080be: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
1080c0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1080c6: f6 c4 02 test $0x2,%ah <== NOT EXECUTED
1080c9: 74 57 je 108122 <rtems_termios_ioctl+0x139><== NOT EXECUTED
1080cb: f6 43 31 04 testb $0x4,0x31(%ebx) <== NOT EXECUTED
1080cf: 75 51 jne 108122 <rtems_termios_ioctl+0x139><== NOT EXECUTED
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
1080d1: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1080d7: 25 ef fd ff ff and $0xfffffdef,%eax <== NOT EXECUTED
1080dc: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
1080e2: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1080e8: a8 20 test $0x20,%al <== NOT EXECUTED
1080ea: 74 36 je 108122 <rtems_termios_ioctl+0x139><== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
1080ec: 9c pushf <== NOT EXECUTED
1080ed: fa cli <== NOT EXECUTED
1080ee: 5e pop %esi <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
1080ef: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1080f5: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
1080f8: 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) {
1080fe: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
108105: 74 19 je 108120 <rtems_termios_ioctl+0x137><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
108107: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED
10810d: 57 push %edi <== NOT EXECUTED
10810e: 6a 01 push $0x1 <== NOT EXECUTED
108110: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED
108113: 50 push %eax <== NOT EXECUTED
108114: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
108117: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
10811d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
108120: 56 push %esi <== NOT EXECUTED
108121: 9d popf <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) &&
108122: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108128: f6 c4 04 test $0x4,%ah <== NOT EXECUTED
10812b: 74 24 je 108151 <rtems_termios_ioctl+0x168><== NOT EXECUTED
10812d: f6 43 31 10 testb $0x10,0x31(%ebx) <== NOT EXECUTED
108131: 75 1e jne 108151 <rtems_termios_ioctl+0x168><== NOT EXECUTED
!(tty->termios.c_iflag & IXOFF)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
108133: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108139: 80 e4 fb and $0xfb,%ah <== NOT EXECUTED
10813c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
108142: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108148: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED
10814b: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) &&
108151: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108157: f6 c4 01 test $0x1,%ah <== NOT EXECUTED
10815a: 74 43 je 10819f <rtems_termios_ioctl+0x1b6><== NOT EXECUTED
10815c: 83 7b 38 00 cmpl $0x0,0x38(%ebx) <== NOT EXECUTED
108160: 78 3d js 10819f <rtems_termios_ioctl+0x1b6><== NOT EXECUTED
!(tty->termios.c_cflag & CRTSCTS)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
108162: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108168: 80 e4 fe and $0xfe,%ah <== NOT EXECUTED
10816b: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) &&
108171: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108177: a8 04 test $0x4,%al <== NOT EXECUTED
108179: 74 15 je 108190 <rtems_termios_ioctl+0x1a7><== NOT EXECUTED
10817b: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED
108181: 85 c0 test %eax,%eax <== NOT EXECUTED
108183: 74 0b je 108190 <rtems_termios_ioctl+0x1a7><== NOT EXECUTED
(tty->device.startRemoteTx != NULL)) {
tty->device.startRemoteTx(tty->minor);
108185: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108188: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10818b: ff d0 call *%eax <== NOT EXECUTED
10818d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
108190: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108196: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED
108199: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== 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) {
10819f: 83 7b 38 00 cmpl $0x0,0x38(%ebx) <== NOT EXECUTED
1081a3: 79 0f jns 1081b4 <rtems_termios_ioctl+0x1cb><== NOT EXECUTED
tty->flow_ctrl |= FL_MDRTS;
1081a5: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1081ab: 80 cc 01 or $0x1,%ah <== NOT EXECUTED
1081ae: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
1081b4: f6 43 31 10 testb $0x10,0x31(%ebx) <== NOT EXECUTED
1081b8: 74 0f je 1081c9 <rtems_termios_ioctl+0x1e0><== NOT EXECUTED
tty->flow_ctrl |= FL_MDXOF;
1081ba: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1081c0: 80 cc 04 or $0x4,%ah <== NOT EXECUTED
1081c3: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
1081c9: f6 43 31 04 testb $0x4,0x31(%ebx) <== NOT EXECUTED
1081cd: 74 0f je 1081de <rtems_termios_ioctl+0x1f5><== NOT EXECUTED
tty->flow_ctrl |= FL_MDXON;
1081cf: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1081d5: 80 cc 02 or $0x2,%ah <== NOT EXECUTED
1081d8: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
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) {
1081de: f6 43 3c 02 testb $0x2,0x3c(%ebx) <== NOT EXECUTED
1081e2: 75 45 jne 108229 <rtems_termios_ioctl+0x240><== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
}
else {
rtems_interval ticksPerSecond;
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_PER_SECOND, &ticksPerSecond);
1081e4: 56 push %esi <== NOT EXECUTED
1081e5: 56 push %esi <== NOT EXECUTED
1081e6: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED
1081e9: 50 push %eax <== NOT EXECUTED
1081ea: 6a 03 push $0x3 <== NOT EXECUTED
1081ec: e8 93 07 00 00 call 108984 <rtems_clock_get> <== NOT EXECUTED
tty->vtimeTicks = tty->termios.c_cc[VTIME] * ticksPerSecond / 10;
1081f1: 0f b6 43 46 movzbl 0x46(%ebx),%eax <== NOT EXECUTED
1081f5: 0f af 45 f0 imul -0x10(%ebp),%eax <== NOT EXECUTED
1081f9: b9 0a 00 00 00 mov $0xa,%ecx <== NOT EXECUTED
1081fe: 31 d2 xor %edx,%edx <== NOT EXECUTED
108200: f7 f1 div %ecx <== NOT EXECUTED
108202: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED
if (tty->termios.c_cc[VTIME]) {
108205: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108208: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED
10820c: 74 15 je 108223 <rtems_termios_ioctl+0x23a><== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
10820e: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
108215: 89 43 70 mov %eax,0x70(%ebx) <== NOT EXECUTED
if (tty->termios.c_cc[VMIN])
108218: 80 7b 47 00 cmpb $0x0,0x47(%ebx) <== NOT EXECUTED
10821c: 75 19 jne 108237 <rtems_termios_ioctl+0x24e><== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
10821e: 89 43 74 mov %eax,0x74(%ebx) <== NOT EXECUTED
108221: eb 24 jmp 108247 <rtems_termios_ioctl+0x25e><== NOT EXECUTED
}
else {
if (tty->termios.c_cc[VMIN]) {
108223: 80 7b 47 00 cmpb $0x0,0x47(%ebx) <== NOT EXECUTED
108227: 74 17 je 108240 <rtems_termios_ioctl+0x257><== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
108229: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
108230: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
108237: c7 43 74 00 00 00 00 movl $0x0,0x74(%ebx) <== NOT EXECUTED
10823e: eb 07 jmp 108247 <rtems_termios_ioctl+0x25e><== NOT EXECUTED
}
else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
108240: c7 43 6c 01 00 00 00 movl $0x1,0x6c(%ebx) <== NOT EXECUTED
}
}
}
if (tty->device.setAttributes)
108247: 8b 93 a8 00 00 00 mov 0xa8(%ebx),%edx <== NOT EXECUTED
10824d: 85 d2 test %edx,%edx <== NOT EXECUTED
10824f: 0f 84 c7 00 00 00 je 10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
(*tty->device.setAttributes)(tty->minor, &tty->termios);
108255: 51 push %ecx <== NOT EXECUTED
108256: 51 push %ecx <== NOT EXECUTED
108257: 8d 43 30 lea 0x30(%ebx),%eax <== NOT EXECUTED
10825a: 50 push %eax <== NOT EXECUTED
10825b: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10825e: ff d2 call *%edx <== NOT EXECUTED
108260: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108263: e9 b4 00 00 00 jmp 10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
108268: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10826a: e8 13 fa ff ff call 107c82 <drainOutput> <== NOT EXECUTED
10826f: e9 a8 00 00 00 jmp 10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
108274: 8b 16 mov (%esi),%edx <== NOT EXECUTED
108276: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED
108279: 89 83 d8 00 00 00 mov %eax,0xd8(%ebx) <== NOT EXECUTED
10827f: 89 93 d4 00 00 00 mov %edx,0xd4(%ebx) <== NOT EXECUTED
108285: e9 92 00 00 00 jmp 10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
break;
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
10828a: 8b 16 mov (%esi),%edx <== NOT EXECUTED
10828c: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED
10828f: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx) <== NOT EXECUTED
108295: 89 93 dc 00 00 00 mov %edx,0xdc(%ebx) <== NOT EXECUTED
10829b: eb 7f jmp 10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
10829d: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED
1082a3: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
1082a6: 8b 80 50 d4 11 00 mov 0x11d450(%eax),%eax <== NOT EXECUTED
1082ac: 85 c0 test %eax,%eax <== NOT EXECUTED
1082ae: 74 0c je 1082bc <rtems_termios_ioctl+0x2d3><== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
1082b0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1082b3: 53 push %ebx <== NOT EXECUTED
1082b4: ff d0 call *%eax <== NOT EXECUTED
1082b6: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED
1082b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
tty->t_line=*(int*)(args->buffer);
1082bc: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
1082bf: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED
1082c2: 8b 00 mov (%eax),%eax <== NOT EXECUTED
1082c4: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx) <== NOT EXECUTED
tty->t_sc = NULL; /* ensure that no more valid data */
1082ca: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx) <== NOT EXECUTED
1082d1: 00 00 00
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
1082d4: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
1082d7: 8b 80 4c d4 11 00 mov 0x11d44c(%eax),%eax <== NOT EXECUTED
1082dd: 85 c0 test %eax,%eax <== NOT EXECUTED
1082df: 74 3b je 10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
1082e1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1082e4: 53 push %ebx <== NOT EXECUTED
1082e5: ff d0 call *%eax <== NOT EXECUTED
1082e7: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED
1082ea: e9 71 ff ff ff jmp 108260 <rtems_termios_ioctl+0x277><== NOT EXECUTED
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
1082ef: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
1082f2: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED
1082f5: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED
1082fb: 89 02 mov %eax,(%edx) <== NOT EXECUTED
1082fd: eb 1d jmp 10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
break;
#endif
case FIONREAD:
{
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
1082ff: 8b 53 60 mov 0x60(%ebx),%edx <== NOT EXECUTED
108302: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED
if ( rawnc < 0 )
108305: 29 c2 sub %eax,%edx <== NOT EXECUTED
108307: 79 05 jns 10830e <rtems_termios_ioctl+0x325><== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
108309: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED
10830c: 01 c2 add %eax,%edx <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
10830e: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
108311: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED
108314: 03 53 20 add 0x20(%ebx),%edx <== NOT EXECUTED
108317: 2b 53 24 sub 0x24(%ebx),%edx <== NOT EXECUTED
10831a: 89 10 mov %edx,(%eax) <== NOT EXECUTED
}
break;
}
rtems_semaphore_release (tty->osem);
10831c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10831f: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED
108322: e8 35 0f 00 00 call 10925c <rtems_semaphore_release><== NOT EXECUTED
args->ioctl_return = sc;
108327: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED
10832a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10832d: 89 50 0c mov %edx,0xc(%eax) <== NOT EXECUTED
108330: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return sc;
}
108333: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
108336: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
108339: 5b pop %ebx <== NOT EXECUTED
10833a: 5e pop %esi <== NOT EXECUTED
10833b: 5f pop %edi <== NOT EXECUTED
10833c: c9 leave <== NOT EXECUTED
10833d: c3 ret <== NOT EXECUTED
001084a7 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
1084a7: 55 push %ebp
1084a8: 89 e5 mov %esp,%ebp
1084aa: 57 push %edi
1084ab: 56 push %esi
1084ac: 53 push %ebx
1084ad: 83 ec 10 sub $0x10,%esp
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,
1084b0: 6a 00 push $0x0
1084b2: 6a 00 push $0x0
1084b4: ff 35 d4 d6 11 00 pushl 0x11d6d4
1084ba: e8 b5 0c 00 00 call 109174 <rtems_semaphore_obtain>
1084bf: 89 45 f0 mov %eax,-0x10(%ebp)
RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
1084c2: 83 c4 10 add $0x10,%esp
1084c5: 85 c0 test %eax,%eax
1084c7: 0f 85 c0 03 00 00 jne 10888d <rtems_termios_open+0x3e6><== NEVER TAKEN
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
1084cd: a1 dc d6 11 00 mov 0x11d6dc,%eax
1084d2: eb 1c jmp 1084f0 <rtems_termios_open+0x49>
if ((tty->major == major) && (tty->minor == minor))
1084d4: 8b 4d 08 mov 0x8(%ebp),%ecx
1084d7: 8b 55 e8 mov -0x18(%ebp),%edx
1084da: 39 4a 0c cmp %ecx,0xc(%edx)
1084dd: 75 0c jne 1084eb <rtems_termios_open+0x44><== NEVER TAKEN
1084df: 8b 75 0c mov 0xc(%ebp),%esi
1084e2: 39 72 10 cmp %esi,0x10(%edx)
1084e5: 0f 84 14 03 00 00 je 1087ff <rtems_termios_open+0x358><== ALWAYS TAKEN
*/
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,
RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
1084eb: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED
1084ee: 8b 00 mov (%eax),%eax <== NOT EXECUTED
1084f0: 89 45 e8 mov %eax,-0x18(%ebp)
1084f3: 83 7d e8 00 cmpl $0x0,-0x18(%ebp)
1084f7: 75 db jne 1084d4 <rtems_termios_open+0x2d>
1084f9: e9 9a 03 00 00 jmp 108898 <rtems_termios_open+0x3f1>
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
if (tty == NULL) {
rtems_semaphore_release (rtems_termios_ttyMutex);
1084fe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108501: e9 9d 00 00 00 jmp 1085a3 <rtems_termios_open+0xfc><== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
108506: a1 40 b6 11 00 mov 0x11b640,%eax
10850b: 8b 55 e8 mov -0x18(%ebp),%edx
10850e: 89 42 64 mov %eax,0x64(%edx)
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
108511: 8b 42 64 mov 0x64(%edx),%eax
108514: 83 ec 0c sub $0xc,%esp
108517: 50 push %eax
108518: e8 57 e1 ff ff call 106674 <malloc>
10851d: 8b 4d e8 mov -0x18(%ebp),%ecx
108520: 89 41 58 mov %eax,0x58(%ecx)
if (tty->rawInBuf.theBuf == NULL) {
108523: 83 c4 10 add $0x10,%esp
108526: 85 c0 test %eax,%eax
108528: 75 06 jne 108530 <rtems_termios_open+0x89><== ALWAYS TAKEN
free(tty);
10852a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10852d: 51 push %ecx <== NOT EXECUTED
10852e: eb 6d jmp 10859d <rtems_termios_open+0xf6><== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
108530: a1 44 b6 11 00 mov 0x11b644,%eax
108535: 8b 75 e8 mov -0x18(%ebp),%esi
108538: 89 86 88 00 00 00 mov %eax,0x88(%esi)
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
10853e: 8b 86 88 00 00 00 mov 0x88(%esi),%eax
108544: 83 ec 0c sub $0xc,%esp
108547: 50 push %eax
108548: e8 27 e1 ff ff call 106674 <malloc>
10854d: 89 46 7c mov %eax,0x7c(%esi)
if (tty->rawOutBuf.theBuf == NULL) {
108550: 83 c4 10 add $0x10,%esp
108553: 85 c0 test %eax,%eax
108555: 75 10 jne 108567 <rtems_termios_open+0xc0><== ALWAYS TAKEN
free((void *)(tty->rawInBuf.theBuf));
108557: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10855a: ff 76 58 pushl 0x58(%esi) <== NOT EXECUTED
10855d: e8 16 df ff ff call 106478 <free> <== NOT EXECUTED
free(tty);
108562: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
108565: eb 36 jmp 10859d <rtems_termios_open+0xf6><== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
108567: 83 ec 0c sub $0xc,%esp
10856a: ff 35 3c b6 11 00 pushl 0x11b63c
108570: e8 ff e0 ff ff call 106674 <malloc>
108575: 8b 55 e8 mov -0x18(%ebp),%edx
108578: 89 42 1c mov %eax,0x1c(%edx)
if (tty->cbuf == NULL) {
10857b: 83 c4 10 add $0x10,%esp
10857e: 85 c0 test %eax,%eax
108580: 75 38 jne 1085ba <rtems_termios_open+0x113><== ALWAYS TAKEN
free((void *)(tty->rawOutBuf.theBuf));
108582: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108585: ff 72 7c pushl 0x7c(%edx) <== NOT EXECUTED
108588: e8 eb de ff ff call 106478 <free> <== NOT EXECUTED
free((void *)(tty->rawInBuf.theBuf));
10858d: 58 pop %eax <== NOT EXECUTED
10858e: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED
108591: ff 71 58 pushl 0x58(%ecx) <== NOT EXECUTED
108594: e8 df de ff ff call 106478 <free> <== NOT EXECUTED
free(tty);
108599: 58 pop %eax <== NOT EXECUTED
10859a: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED
10859d: e8 d6 de ff ff call 106478 <free> <== NOT EXECUTED
rtems_semaphore_release (rtems_termios_ttyMutex);
1085a2: 5f pop %edi <== NOT EXECUTED
1085a3: ff 35 d4 d6 11 00 pushl 0x11d6d4 <== NOT EXECUTED
1085a9: e8 ae 0c 00 00 call 10925c <rtems_semaphore_release><== NOT EXECUTED
1085ae: c7 45 f0 1a 00 00 00 movl $0x1a,-0x10(%ebp) <== NOT EXECUTED
1085b5: e9 d0 02 00 00 jmp 10888a <rtems_termios_open+0x3e3><== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
1085ba: 8b 75 e8 mov -0x18(%ebp),%esi
1085bd: c7 86 d4 00 00 00 00 movl $0x0,0xd4(%esi)
1085c4: 00 00 00
tty->tty_snd.sw_arg = NULL;
1085c7: c7 86 d8 00 00 00 00 movl $0x0,0xd8(%esi)
1085ce: 00 00 00
tty->tty_rcv.sw_pfn = NULL;
1085d1: c7 86 dc 00 00 00 00 movl $0x0,0xdc(%esi)
1085d8: 00 00 00
tty->tty_rcv.sw_arg = NULL;
1085db: c7 86 e0 00 00 00 00 movl $0x0,0xe0(%esi)
1085e2: 00 00 00
tty->tty_rcvwakeup = 0;
1085e5: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi)
1085ec: 00 00 00
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
1085ef: a1 dc d6 11 00 mov 0x11d6dc,%eax
1085f4: 89 06 mov %eax,(%esi)
tty->back = NULL;
1085f6: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi)
if (rtems_termios_ttyHead != NULL)
1085fd: 85 c0 test %eax,%eax
1085ff: 74 03 je 108604 <rtems_termios_open+0x15d><== ALWAYS TAKEN
rtems_termios_ttyHead->back = tty;
108601: 89 70 04 mov %esi,0x4(%eax) <== NOT EXECUTED
rtems_termios_ttyHead = tty;
108604: 89 1d dc d6 11 00 mov %ebx,0x11d6dc
if (rtems_termios_ttyTail == NULL)
10860a: 83 3d d8 d6 11 00 00 cmpl $0x0,0x11d6d8
108611: 75 06 jne 108619 <rtems_termios_open+0x172><== NEVER TAKEN
rtems_termios_ttyTail = tty;
108613: 89 1d d8 d6 11 00 mov %ebx,0x11d6d8
tty->minor = minor;
108619: 8b 45 0c mov 0xc(%ebp),%eax
10861c: 89 43 10 mov %eax,0x10(%ebx)
tty->major = major;
10861f: 8b 55 08 mov 0x8(%ebp),%edx
108622: 89 53 0c mov %edx,0xc(%ebx)
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
108625: 83 ec 0c sub $0xc,%esp
108628: 8d 43 14 lea 0x14(%ebx),%eax
10862b: 50 push %eax
10862c: 6a 00 push $0x0
10862e: 6a 54 push $0x54
108630: 6a 01 push $0x1
108632: 0f be 05 48 b6 11 00 movsbl 0x11b648,%eax
108639: 0d 00 69 52 54 or $0x54526900,%eax
10863e: 50 push %eax
10863f: e8 fc 08 00 00 call 108f40 <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)
108644: 83 c4 20 add $0x20,%esp
108647: 85 c0 test %eax,%eax
108649: 0f 85 24 02 00 00 jne 108873 <rtems_termios_open+0x3cc><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
10864f: 83 ec 0c sub $0xc,%esp
108652: 8d 43 18 lea 0x18(%ebx),%eax
108655: 50 push %eax
108656: 6a 00 push $0x0
108658: 6a 54 push $0x54
10865a: 6a 01 push $0x1
10865c: 0f be 05 48 b6 11 00 movsbl 0x11b648,%eax
108663: 0d 00 6f 52 54 or $0x54526f00,%eax
108668: 50 push %eax
108669: e8 d2 08 00 00 call 108f40 <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)
10866e: 83 c4 20 add $0x20,%esp
108671: 85 c0 test %eax,%eax
108673: 0f 85 fa 01 00 00 jne 108873 <rtems_termios_open+0x3cc><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
108679: 83 ec 0c sub $0xc,%esp
10867c: 8d 83 8c 00 00 00 lea 0x8c(%ebx),%eax
108682: 50 push %eax
108683: 6a 00 push $0x0
108685: 6a 20 push $0x20
108687: 6a 00 push $0x0
108689: 0f be 05 48 b6 11 00 movsbl 0x11b648,%eax
108690: 0d 00 78 52 54 or $0x54527800,%eax
108695: 50 push %eax
108696: e8 a5 08 00 00 call 108f40 <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)
10869b: 83 c4 20 add $0x20,%esp
10869e: 85 c0 test %eax,%eax
1086a0: 0f 85 cd 01 00 00 jne 108873 <rtems_termios_open+0x3cc><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
1086a6: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx)
1086ad: 00 00 00
/*
* Set callbacks
*/
tty->device = *callbacks;
1086b0: 8d bb 98 00 00 00 lea 0x98(%ebx),%edi
1086b6: b9 08 00 00 00 mov $0x8,%ecx
1086bb: 8b 75 14 mov 0x14(%ebp),%esi
1086be: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
1086c0: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
1086c7: 75 68 jne 108731 <rtems_termios_open+0x28a><== ALWAYS TAKEN
sc = rtems_task_create (
1086c9: 56 push %esi <== NOT EXECUTED
1086ca: 56 push %esi <== NOT EXECUTED
1086cb: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax <== NOT EXECUTED
1086d1: 50 push %eax <== NOT EXECUTED
1086d2: 6a 00 push $0x0 <== NOT EXECUTED
1086d4: 68 00 05 00 00 push $0x500 <== NOT EXECUTED
1086d9: 68 00 04 00 00 push $0x400 <== NOT EXECUTED
1086de: 6a 0a push $0xa <== NOT EXECUTED
1086e0: 0f be 05 48 b6 11 00 movsbl 0x11b648,%eax <== NOT EXECUTED
1086e7: 0d 00 54 78 54 or $0x54785400,%eax <== NOT EXECUTED
1086ec: 50 push %eax <== NOT EXECUTED
1086ed: e8 fa 0b 00 00 call 1092ec <rtems_task_create> <== NOT EXECUTED
TERMIOS_TXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
1086f2: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
1086f5: 85 c0 test %eax,%eax <== NOT EXECUTED
1086f7: 0f 85 76 01 00 00 jne 108873 <rtems_termios_open+0x3cc><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
1086fd: 51 push %ecx <== NOT EXECUTED
1086fe: 51 push %ecx <== NOT EXECUTED
1086ff: 8d 83 c4 00 00 00 lea 0xc4(%ebx),%eax <== NOT EXECUTED
108705: 50 push %eax <== NOT EXECUTED
108706: 6a 00 push $0x0 <== NOT EXECUTED
108708: 68 00 05 00 00 push $0x500 <== NOT EXECUTED
10870d: 68 00 04 00 00 push $0x400 <== NOT EXECUTED
108712: 6a 09 push $0x9 <== NOT EXECUTED
108714: 0f be 05 48 b6 11 00 movsbl 0x11b648,%eax <== NOT EXECUTED
10871b: 0d 00 54 78 52 or $0x52785400,%eax <== NOT EXECUTED
108720: 50 push %eax <== NOT EXECUTED
108721: e8 c6 0b 00 00 call 1092ec <rtems_task_create> <== NOT EXECUTED
TERMIOS_RXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
108726: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
108729: 85 c0 test %eax,%eax <== NOT EXECUTED
10872b: 0f 85 42 01 00 00 jne 108873 <rtems_termios_open+0x3cc><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
108731: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx)
108738: 74 09 je 108743 <rtems_termios_open+0x29c><== ALWAYS TAKEN
10873a: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) <== NOT EXECUTED
108741: 75 2a jne 10876d <rtems_termios_open+0x2c6><== NOT EXECUTED
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
108743: 83 ec 0c sub $0xc,%esp
108746: 8d 43 68 lea 0x68(%ebx),%eax
108749: 50 push %eax
10874a: 6a 00 push $0x0
10874c: 6a 24 push $0x24
10874e: 6a 00 push $0x0
108750: 0f be 05 48 b6 11 00 movsbl 0x11b648,%eax
108757: 0d 00 72 52 54 or $0x54527200,%eax
10875c: 50 push %eax
10875d: e8 de 07 00 00 call 108f40 <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)
108762: 83 c4 20 add $0x20,%esp
108765: 85 c0 test %eax,%eax
108767: 0f 85 06 01 00 00 jne 108873 <rtems_termios_open+0x3cc><== NEVER TAKEN
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
10876d: c7 43 30 02 25 00 00 movl $0x2502,0x30(%ebx)
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
108774: c7 43 34 05 18 00 00 movl $0x1805,0x34(%ebx)
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
10877b: c7 43 38 bd 08 00 00 movl $0x8bd,0x38(%ebx)
tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
108782: c7 43 3c 3b 82 00 00 movl $0x823b,0x3c(%ebx)
tty->termios.c_cc[VINTR] = '\003';
108789: c6 43 41 03 movb $0x3,0x41(%ebx)
tty->termios.c_cc[VQUIT] = '\034';
10878d: c6 43 42 1c movb $0x1c,0x42(%ebx)
tty->termios.c_cc[VERASE] = '\177';
108791: c6 43 43 7f movb $0x7f,0x43(%ebx)
tty->termios.c_cc[VKILL] = '\025';
108795: c6 43 44 15 movb $0x15,0x44(%ebx)
tty->termios.c_cc[VEOF] = '\004';
108799: c6 43 45 04 movb $0x4,0x45(%ebx)
tty->termios.c_cc[VEOL] = '\000';
10879d: c6 43 4c 00 movb $0x0,0x4c(%ebx)
tty->termios.c_cc[VEOL2] = '\000';
1087a1: c6 43 51 00 movb $0x0,0x51(%ebx)
tty->termios.c_cc[VSTART] = '\021';
1087a5: c6 43 49 11 movb $0x11,0x49(%ebx)
tty->termios.c_cc[VSTOP] = '\023';
1087a9: c6 43 4a 13 movb $0x13,0x4a(%ebx)
tty->termios.c_cc[VSUSP] = '\032';
1087ad: c6 43 4b 1a movb $0x1a,0x4b(%ebx)
tty->termios.c_cc[VREPRINT] = '\022';
1087b1: c6 43 4d 12 movb $0x12,0x4d(%ebx)
tty->termios.c_cc[VDISCARD] = '\017';
1087b5: c6 43 4e 0f movb $0xf,0x4e(%ebx)
tty->termios.c_cc[VWERASE] = '\027';
1087b9: c6 43 4f 17 movb $0x17,0x4f(%ebx)
tty->termios.c_cc[VLNEXT] = '\026';
1087bd: c6 43 50 16 movb $0x16,0x50(%ebx)
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
1087c1: c7 83 b8 00 00 00 00 movl $0x0,0xb8(%ebx)
1087c8: 00 00 00
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
1087cb: 8b 43 64 mov 0x64(%ebx),%eax
1087ce: d1 e8 shr %eax
1087d0: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx)
tty->highwater = tty->rawInBuf.Size * 3/4;
1087d6: 8b 43 64 mov 0x64(%ebx),%eax
1087d9: 8d 04 40 lea (%eax,%eax,2),%eax
1087dc: c1 e8 02 shr $0x2,%eax
1087df: 89 83 c0 00 00 00 mov %eax,0xc0(%ebx)
/*
* Bump name characer
*/
if (c++ == 'z')
1087e5: 8a 15 48 b6 11 00 mov 0x11b648,%dl
1087eb: 8d 42 01 lea 0x1(%edx),%eax
1087ee: a2 48 b6 11 00 mov %al,0x11b648
1087f3: 80 fa 7a cmp $0x7a,%dl
1087f6: 75 07 jne 1087ff <rtems_termios_open+0x358><== ALWAYS TAKEN
c = 'a';
1087f8: c6 05 48 b6 11 00 61 movb $0x61,0x11b648 <== NOT EXECUTED
}
args->iop->data1 = tty;
1087ff: 8b 55 10 mov 0x10(%ebp),%edx
108802: 8b 02 mov (%edx),%eax
108804: 8b 4d e8 mov -0x18(%ebp),%ecx
108807: 89 48 28 mov %ecx,0x28(%eax)
if (!tty->refcount++) {
10880a: 8b 51 08 mov 0x8(%ecx),%edx
10880d: 8d 42 01 lea 0x1(%edx),%eax
108810: 89 41 08 mov %eax,0x8(%ecx)
108813: 85 d2 test %edx,%edx
108815: 75 65 jne 10887c <rtems_termios_open+0x3d5>
if (tty->device.firstOpen)
108817: 8b 81 98 00 00 00 mov 0x98(%ecx),%eax
10881d: 85 c0 test %eax,%eax
10881f: 74 0f je 108830 <rtems_termios_open+0x389><== NEVER TAKEN
(*tty->device.firstOpen)(major, minor, arg);
108821: 52 push %edx
108822: ff 75 10 pushl 0x10(%ebp)
108825: ff 75 0c pushl 0xc(%ebp)
108828: ff 75 08 pushl 0x8(%ebp)
10882b: ff d0 call *%eax
10882d: 83 c4 10 add $0x10,%esp
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
108830: 8b 75 e8 mov -0x18(%ebp),%esi
108833: 83 be b4 00 00 00 02 cmpl $0x2,0xb4(%esi)
10883a: 75 40 jne 10887c <rtems_termios_open+0x3d5><== ALWAYS TAKEN
sc = rtems_task_start(tty->rxTaskId,
10883c: 50 push %eax <== NOT EXECUTED
10883d: 56 push %esi <== NOT EXECUTED
10883e: 68 1e 89 10 00 push $0x10891e <== NOT EXECUTED
108843: ff b6 c4 00 00 00 pushl 0xc4(%esi) <== NOT EXECUTED
108849: e8 0e 0d 00 00 call 10955c <rtems_task_start> <== NOT EXECUTED
rtems_termios_rxdaemon,
(rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
10884e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108851: 85 c0 test %eax,%eax <== NOT EXECUTED
108853: 75 1e jne 108873 <rtems_termios_open+0x3cc><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(tty->txTaskId,
108855: 50 push %eax <== NOT EXECUTED
108856: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED
108859: 68 bb 88 10 00 push $0x1088bb <== NOT EXECUTED
10885e: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED
108861: ff b0 c8 00 00 00 pushl 0xc8(%eax) <== NOT EXECUTED
108867: e8 f0 0c 00 00 call 10955c <rtems_task_start> <== NOT EXECUTED
rtems_termios_txdaemon,
(rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
10886c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10886f: 85 c0 test %eax,%eax <== NOT EXECUTED
108871: 74 09 je 10887c <rtems_termios_open+0x3d5><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
108873: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108876: 50 push %eax <== NOT EXECUTED
108877: e8 18 0f 00 00 call 109794 <rtems_fatal_error_occurred><== NOT EXECUTED
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
10887c: 83 ec 0c sub $0xc,%esp
10887f: ff 35 d4 d6 11 00 pushl 0x11d6d4
108885: e8 d2 09 00 00 call 10925c <rtems_semaphore_release>
10888a: 83 c4 10 add $0x10,%esp
return RTEMS_SUCCESSFUL;
}
10888d: 8b 45 f0 mov -0x10(%ebp),%eax
108890: 8d 65 f4 lea -0xc(%ebp),%esp
108893: 5b pop %ebx
108894: 5e pop %esi
108895: 5f pop %edi
108896: c9 leave
108897: c3 ret
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
108898: 50 push %eax
108899: 50 push %eax
10889a: 68 e8 00 00 00 push $0xe8
10889f: 6a 01 push $0x1
1088a1: e8 2a 44 00 00 call 10ccd0 <calloc>
1088a6: 89 45 e8 mov %eax,-0x18(%ebp)
1088a9: 89 c3 mov %eax,%ebx
if (tty == NULL) {
1088ab: 83 c4 10 add $0x10,%esp
1088ae: 85 c0 test %eax,%eax
1088b0: 0f 85 50 fc ff ff jne 108506 <rtems_termios_open+0x5f><== ALWAYS TAKEN
1088b6: e9 43 fc ff ff jmp 1084fe <rtems_termios_open+0x57><== NOT EXECUTED
00107693 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
107693: 55 push %ebp
107694: 89 e5 mov %esp,%ebp
107696: 57 push %edi
107697: 56 push %esi
107698: 53 push %ebx
107699: 83 ec 1c sub $0x1c,%esp
10769c: 8b 45 08 mov 0x8(%ebp),%eax
10769f: 8b 55 0c mov 0xc(%ebp),%edx
1076a2: 89 55 e8 mov %edx,-0x18(%ebp)
1076a5: 8b 5d 10 mov 0x10(%ebp),%ebx
const unsigned char *buf = _buf;
1076a8: 89 45 ec mov %eax,-0x14(%ebp)
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
1076ab: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx)
1076b2: 75 1b jne 1076cf <rtems_termios_puts+0x3c><== ALWAYS TAKEN
(*tty->device.write)(tty->minor, (void *)buf, len);
1076b4: 89 55 10 mov %edx,0x10(%ebp) <== NOT EXECUTED
1076b7: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED
1076ba: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED
1076bd: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
1076c0: 8b 8b a4 00 00 00 mov 0xa4(%ebx),%ecx <== NOT EXECUTED
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
1076c6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1076c9: 5b pop %ebx <== NOT EXECUTED
1076ca: 5e pop %esi <== NOT EXECUTED
1076cb: 5f pop %edi <== NOT EXECUTED
1076cc: c9 leave <== NOT EXECUTED
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);
1076cd: ff e1 jmp *%ecx <== NOT EXECUTED
return;
}
newHead = tty->rawOutBuf.Head;
1076cf: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
1076d5: 89 45 f0 mov %eax,-0x10(%ebp)
1076d8: e9 b9 00 00 00 jmp 107796 <rtems_termios_puts+0x103>
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
1076dd: 8b 75 f0 mov -0x10(%ebp),%esi
1076e0: 46 inc %esi
1076e1: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx
1076e7: 89 f0 mov %esi,%eax
1076e9: 31 d2 xor %edx,%edx
1076eb: f7 f1 div %ecx
1076ed: 89 d6 mov %edx,%esi
1076ef: 89 55 f0 mov %edx,-0x10(%ebp)
rtems_interrupt_disable (level);
1076f2: 9c pushf
1076f3: fa cli
1076f4: 5f pop %edi
1076f5: eb 2f jmp 107726 <rtems_termios_puts+0x93>
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
1076f7: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx)
1076fe: 00 00 00
rtems_interrupt_enable (level);
107701: 57 push %edi
107702: 9d popf
sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
107703: 51 push %ecx
107704: 6a 00 push $0x0
107706: 6a 00 push $0x0
107708: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
10770e: e8 61 1a 00 00 call 109174 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
107713: 83 c4 10 add $0x10,%esp
107716: 85 c0 test %eax,%eax
107718: 74 09 je 107723 <rtems_termios_puts+0x90><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
10771a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10771d: 50 push %eax <== NOT EXECUTED
10771e: e8 71 20 00 00 call 109794 <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_interrupt_disable (level);
107723: 9c pushf
107724: fa cli
107725: 5f pop %edi
* 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) {
107726: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
10772c: 39 c6 cmp %eax,%esi
10772e: 74 c7 je 1076f7 <rtems_termios_puts+0x64>
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
107730: 8b 8b 80 00 00 00 mov 0x80(%ebx),%ecx
107736: 8b 53 7c mov 0x7c(%ebx),%edx
107739: 8b 45 ec mov -0x14(%ebp),%eax
10773c: 8a 00 mov (%eax),%al
10773e: 88 04 0a mov %al,(%edx,%ecx,1)
tty->rawOutBuf.Head = newHead;
107741: 89 b3 80 00 00 00 mov %esi,0x80(%ebx)
if (tty->rawOutBufState == rob_idle) {
107747: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx)
10774e: 75 3e jne 10778e <rtems_termios_puts+0xfb>
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
107750: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
107756: a8 10 test $0x10,%al
107758: 75 1b jne 107775 <rtems_termios_puts+0xe2><== NEVER TAKEN
(*tty->device.write)(tty->minor,
10775a: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
107760: 52 push %edx
107761: 6a 01 push $0x1
107763: 03 43 7c add 0x7c(%ebx),%eax
107766: 50 push %eax
107767: ff 73 10 pushl 0x10(%ebx)
10776a: ff 93 a4 00 00 00 call *0xa4(%ebx)
107770: 83 c4 10 add $0x10,%esp
107773: eb 0f jmp 107784 <rtems_termios_puts+0xf1>
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
107775: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10777b: 83 c8 20 or $0x20,%eax <== NOT EXECUTED
10777e: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
107784: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx)
10778b: 00 00 00
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
10778e: ff 45 ec incl -0x14(%ebp)
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
}
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
107791: 57 push %edi
107792: 9d popf
len--;
107793: ff 4d e8 decl -0x18(%ebp)
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
107796: 83 7d e8 00 cmpl $0x0,-0x18(%ebp)
10779a: 0f 85 3d ff ff ff jne 1076dd <rtems_termios_puts+0x4a>
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
1077a0: 8d 65 f4 lea -0xc(%ebp),%esp
1077a3: 5b pop %ebx
1077a4: 5e pop %esi
1077a5: 5f pop %edi
1077a6: c9 leave
1077a7: c3 ret
00107cdf <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
107cdf: 55 push %ebp <== NOT EXECUTED
107ce0: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107ce2: 57 push %edi <== NOT EXECUTED
107ce3: 56 push %esi <== NOT EXECUTED
107ce4: 53 push %ebx <== NOT EXECUTED
107ce5: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
107ce8: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
107ceb: 8b 02 mov (%edx),%eax <== NOT EXECUTED
107ced: 8b 70 28 mov 0x28(%eax),%esi <== NOT EXECUTED
uint32_t count = args->count;
107cf0: 8b 4a 0c mov 0xc(%edx),%ecx <== NOT EXECUTED
107cf3: 89 4d d0 mov %ecx,-0x30(%ebp) <== NOT EXECUTED
char *buffer = args->buffer;
107cf6: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED
107cf9: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
107cfc: 6a 00 push $0x0 <== NOT EXECUTED
107cfe: 6a 00 push $0x0 <== NOT EXECUTED
107d00: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED
107d03: e8 6c 14 00 00 call 109174 <rtems_semaphore_obtain><== NOT EXECUTED
107d08: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
107d0b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107d0e: 85 c0 test %eax,%eax <== NOT EXECUTED
107d10: 0f 85 c8 02 00 00 jne 107fde <rtems_termios_read+0x2ff><== NOT EXECUTED
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
107d16: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED
107d1c: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
107d1f: 8b 80 54 d4 11 00 mov 0x11d454(%eax),%eax <== NOT EXECUTED
107d25: 85 c0 test %eax,%eax <== NOT EXECUTED
107d27: 74 1b je 107d44 <rtems_termios_read+0x65><== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
107d29: 52 push %edx <== NOT EXECUTED
107d2a: 52 push %edx <== NOT EXECUTED
107d2b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
107d2e: 56 push %esi <== NOT EXECUTED
107d2f: ff d0 call *%eax <== NOT EXECUTED
107d31: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
107d34: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi) <== NOT EXECUTED
107d3b: 00 00 00
rtems_semaphore_release (tty->isem);
107d3e: 58 pop %eax <== NOT EXECUTED
107d3f: e9 8f 02 00 00 jmp 107fd3 <rtems_termios_read+0x2f4><== NOT EXECUTED
return sc;
}
if (tty->cindex == tty->ccount) {
107d44: 8b 46 24 mov 0x24(%esi),%eax <== NOT EXECUTED
107d47: 3b 46 20 cmp 0x20(%esi),%eax <== NOT EXECUTED
107d4a: 0f 85 5c 02 00 00 jne 107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
tty->cindex = tty->ccount = 0;
107d50: c7 46 20 00 00 00 00 movl $0x0,0x20(%esi) <== NOT EXECUTED
107d57: c7 46 24 00 00 00 00 movl $0x0,0x24(%esi) <== NOT EXECUTED
tty->read_start_column = tty->column;
107d5e: 8b 46 28 mov 0x28(%esi),%eax <== NOT EXECUTED
107d61: 89 46 2c mov %eax,0x2c(%esi) <== NOT EXECUTED
if (tty->device.pollRead != NULL
107d64: 83 be a0 00 00 00 00 cmpl $0x0,0xa0(%esi) <== NOT EXECUTED
107d6b: 0f 84 f8 00 00 00 je 107e69 <rtems_termios_read+0x18a><== NOT EXECUTED
107d71: 83 be b4 00 00 00 00 cmpl $0x0,0xb4(%esi) <== NOT EXECUTED
107d78: 0f 85 eb 00 00 00 jne 107e69 <rtems_termios_read+0x18a><== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
107d7e: f6 46 3c 02 testb $0x2,0x3c(%esi) <== NOT EXECUTED
107d82: 74 35 je 107db9 <rtems_termios_read+0xda><== NOT EXECUTED
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
107d84: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107d87: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
107d8a: ff 96 a0 00 00 00 call *0xa0(%esi) <== NOT EXECUTED
if (n < 0) {
107d90: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107d93: 85 c0 test %eax,%eax <== NOT EXECUTED
107d95: 79 0f jns 107da6 <rtems_termios_read+0xc7><== NOT EXECUTED
rtems_task_wake_after (1);
107d97: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107d9a: 6a 01 push $0x1 <== NOT EXECUTED
107d9c: e8 1f 18 00 00 call 1095c0 <rtems_task_wake_after> <== NOT EXECUTED
107da1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107da4: eb de jmp 107d84 <rtems_termios_read+0xa5><== NOT EXECUTED
}
else {
if (siproc (n, tty))
107da6: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
107da9: 89 f2 mov %esi,%edx <== NOT EXECUTED
107dab: e8 db fd ff ff call 107b8b <siproc> <== NOT EXECUTED
107db0: 85 c0 test %eax,%eax <== NOT EXECUTED
107db2: 74 d0 je 107d84 <rtems_termios_read+0xa5><== NOT EXECUTED
107db4: e9 f3 01 00 00 jmp 107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
}
}
}
else {
rtems_interval then, now;
if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
107db9: 80 7e 47 00 cmpb $0x0,0x47(%esi) <== NOT EXECUTED
107dbd: 75 16 jne 107dd5 <rtems_termios_read+0xf6><== NOT EXECUTED
107dbf: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED
107dc3: 74 10 je 107dd5 <rtems_termios_read+0xf6><== NOT EXECUTED
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);
107dc5: 50 push %eax <== NOT EXECUTED
107dc6: 50 push %eax <== NOT EXECUTED
107dc7: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED
107dca: 50 push %eax <== NOT EXECUTED
107dcb: 6a 02 push $0x2 <== NOT EXECUTED
107dcd: e8 b2 0b 00 00 call 108984 <rtems_clock_get> <== NOT EXECUTED
107dd2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
else {
siproc (n, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);
107dd5: 8d 7d f0 lea -0x10(%ebp),%edi <== NOT EXECUTED
}
}
else {
if (!tty->termios.c_cc[VTIME])
break;
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now);
107dd8: 8d 5d ec lea -0x14(%ebp),%ebx <== NOT EXECUTED
else {
rtems_interval then, now;
if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
107ddb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107dde: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
107de1: ff 96 a0 00 00 00 call *0xa0(%esi) <== NOT EXECUTED
if (n < 0) {
107de7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107dea: 85 c0 test %eax,%eax <== NOT EXECUTED
107dec: 79 46 jns 107e34 <rtems_termios_read+0x155><== NOT EXECUTED
if (tty->termios.c_cc[VMIN]) {
107dee: 80 7e 47 00 cmpb $0x0,0x47(%esi) <== NOT EXECUTED
107df2: 74 0e je 107e02 <rtems_termios_read+0x123><== NOT EXECUTED
if (tty->termios.c_cc[VTIME] && tty->ccount) {
107df4: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED
107df8: 74 2e je 107e28 <rtems_termios_read+0x149><== NOT EXECUTED
107dfa: 83 7e 20 00 cmpl $0x0,0x20(%esi) <== NOT EXECUTED
107dfe: 74 28 je 107e28 <rtems_termios_read+0x149><== NOT EXECUTED
107e00: eb 0a jmp 107e0c <rtems_termios_read+0x12d><== NOT EXECUTED
break;
}
}
}
else {
if (!tty->termios.c_cc[VTIME])
107e02: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED
107e06: 0f 84 a0 01 00 00 je 107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
break;
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now);
107e0c: 50 push %eax <== NOT EXECUTED
107e0d: 50 push %eax <== NOT EXECUTED
107e0e: 53 push %ebx <== NOT EXECUTED
107e0f: 6a 02 push $0x2 <== NOT EXECUTED
107e11: e8 6e 0b 00 00 call 108984 <rtems_clock_get> <== NOT EXECUTED
if ((now - then) > tty->vtimeTicks) {
107e16: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
107e19: 2b 45 f0 sub -0x10(%ebp),%eax <== NOT EXECUTED
107e1c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107e1f: 3b 46 54 cmp 0x54(%esi),%eax <== NOT EXECUTED
107e22: 0f 87 84 01 00 00 ja 107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
break;
}
}
rtems_task_wake_after (1);
107e28: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107e2b: 6a 01 push $0x1 <== NOT EXECUTED
107e2d: e8 8e 17 00 00 call 1095c0 <rtems_task_wake_after> <== NOT EXECUTED
107e32: eb 2d jmp 107e61 <rtems_termios_read+0x182><== NOT EXECUTED
}
else {
siproc (n, tty);
107e34: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
107e37: 89 f2 mov %esi,%edx <== NOT EXECUTED
107e39: e8 4d fd ff ff call 107b8b <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
107e3e: 8a 56 47 mov 0x47(%esi),%dl <== NOT EXECUTED
107e41: 0f b6 c2 movzbl %dl,%eax <== NOT EXECUTED
107e44: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED
107e47: 0f 8d 5f 01 00 00 jge 107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
107e4d: 84 d2 test %dl,%dl <== NOT EXECUTED
107e4f: 74 8a je 107ddb <rtems_termios_read+0xfc><== NOT EXECUTED
107e51: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED
107e55: 74 84 je 107ddb <rtems_termios_read+0xfc><== NOT EXECUTED
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);
107e57: 50 push %eax <== NOT EXECUTED
107e58: 50 push %eax <== NOT EXECUTED
107e59: 57 push %edi <== NOT EXECUTED
107e5a: 6a 02 push $0x2 <== NOT EXECUTED
107e5c: e8 23 0b 00 00 call 108984 <rtems_clock_get> <== NOT EXECUTED
107e61: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107e64: e9 72 ff ff ff jmp 107ddb <rtems_termios_read+0xfc><== NOT EXECUTED
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
107e69: 8b 7e 74 mov 0x74(%esi),%edi <== NOT EXECUTED
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)(tty->minor,
107e6c: 8d 56 49 lea 0x49(%esi),%edx <== NOT EXECUTED
107e6f: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED
107e72: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED
107e77: e9 11 01 00 00 jmp 107f8d <rtems_termios_read+0x2ae><== NOT EXECUTED
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
107e7c: 8b 46 5c mov 0x5c(%esi),%eax <== NOT EXECUTED
107e7f: 8b 56 64 mov 0x64(%esi),%edx <== NOT EXECUTED
107e82: 40 inc %eax <== NOT EXECUTED
107e83: 89 d1 mov %edx,%ecx <== NOT EXECUTED
107e85: 31 d2 xor %edx,%edx <== NOT EXECUTED
107e87: f7 f1 div %ecx <== NOT EXECUTED
c = tty->rawInBuf.theBuf[newHead];
107e89: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED
107e8c: 0f b6 3c 10 movzbl (%eax,%edx,1),%edi <== NOT EXECUTED
tty->rawInBuf.Head = newHead;
107e90: 89 56 5c mov %edx,0x5c(%esi) <== NOT EXECUTED
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
107e93: 8b 5e 60 mov 0x60(%esi),%ebx <== NOT EXECUTED
107e96: 8b 46 64 mov 0x64(%esi),%eax <== NOT EXECUTED
107e99: 8b 4e 64 mov 0x64(%esi),%ecx <== NOT EXECUTED
107e9c: 01 d8 add %ebx,%eax <== NOT EXECUTED
107e9e: 29 d0 sub %edx,%eax <== NOT EXECUTED
107ea0: 31 d2 xor %edx,%edx <== NOT EXECUTED
107ea2: f7 f1 div %ecx <== NOT EXECUTED
107ea4: 3b 96 bc 00 00 00 cmp 0xbc(%esi),%edx <== NOT EXECUTED
107eaa: 73 74 jae 107f20 <rtems_termios_read+0x241><== NOT EXECUTED
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
107eac: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
107eb2: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED
107eb5: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
107ebb: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
107ec1: 25 02 02 00 00 and $0x202,%eax <== NOT EXECUTED
107ec6: 3d 02 02 00 00 cmp $0x202,%eax <== NOT EXECUTED
107ecb: 75 24 jne 107ef1 <rtems_termios_read+0x212><== NOT EXECUTED
107ecd: 83 be 94 00 00 00 00 cmpl $0x0,0x94(%esi) <== NOT EXECUTED
107ed4: 74 0a je 107ee0 <rtems_termios_read+0x201><== NOT EXECUTED
107ed6: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
107edc: a8 20 test $0x20,%al <== NOT EXECUTED
107ede: 74 11 je 107ef1 <rtems_termios_read+0x212><== NOT EXECUTED
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(tty->minor,
107ee0: 50 push %eax <== NOT EXECUTED
107ee1: 6a 01 push $0x1 <== NOT EXECUTED
107ee3: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED
107ee6: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
107ee9: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED
107eef: eb 2c jmp 107f1d <rtems_termios_read+0x23e><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTART]),
1);
}
else if (tty->flow_ctrl & FL_MDRTS) {
107ef1: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
107ef7: f6 c4 01 test $0x1,%ah <== NOT EXECUTED
107efa: 74 24 je 107f20 <rtems_termios_read+0x241><== NOT EXECUTED
tty->flow_ctrl &= ~FL_IRTSOFF;
107efc: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
107f02: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED
107f05: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
107f0b: 8b 86 b0 00 00 00 mov 0xb0(%esi),%eax <== NOT EXECUTED
107f11: 85 c0 test %eax,%eax <== NOT EXECUTED
107f13: 74 0b je 107f20 <rtems_termios_read+0x241><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
107f15: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107f18: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
107f1b: ff d0 call *%eax <== NOT EXECUTED
107f1d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
107f20: f6 46 3c 02 testb $0x2,0x3c(%esi) <== NOT EXECUTED
107f24: 74 12 je 107f38 <rtems_termios_read+0x259><== NOT EXECUTED
if (siproc (c, tty))
107f26: 89 fa mov %edi,%edx <== NOT EXECUTED
107f28: 0f b6 c2 movzbl %dl,%eax <== NOT EXECUTED
107f2b: 89 f2 mov %esi,%edx <== NOT EXECUTED
107f2d: e8 59 fc ff ff call 107b8b <siproc> <== NOT EXECUTED
107f32: 85 c0 test %eax,%eax <== NOT EXECUTED
107f34: 75 17 jne 107f4d <rtems_termios_read+0x26e><== NOT EXECUTED
107f36: eb 1c jmp 107f54 <rtems_termios_read+0x275><== NOT EXECUTED
wait = 0;
}
else {
siproc (c, tty);
107f38: 89 f9 mov %edi,%ecx <== NOT EXECUTED
107f3a: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED
107f3d: 89 f2 mov %esi,%edx <== NOT EXECUTED
107f3f: e8 47 fc ff ff call 107b8b <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
107f44: 0f b6 46 47 movzbl 0x47(%esi),%eax <== NOT EXECUTED
107f48: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED
107f4b: 7c 07 jl 107f54 <rtems_termios_read+0x275><== NOT EXECUTED
107f4d: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
107f54: 8b 4e 70 mov 0x70(%esi),%ecx <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
107f57: 8b 56 5c mov 0x5c(%esi),%edx <== NOT EXECUTED
107f5a: 8b 46 60 mov 0x60(%esi),%eax <== NOT EXECUTED
107f5d: 39 c2 cmp %eax,%edx <== NOT EXECUTED
107f5f: 74 0f je 107f70 <rtems_termios_read+0x291><== NOT EXECUTED
107f61: a1 3c b6 11 00 mov 0x11b63c,%eax <== NOT EXECUTED
107f66: 48 dec %eax <== NOT EXECUTED
107f67: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED
107f6a: 0f 8c 0c ff ff ff jl 107e7c <rtems_termios_read+0x19d><== NOT EXECUTED
107f70: 8b 5d dc mov -0x24(%ebp),%ebx <== NOT EXECUTED
107f73: 89 cf mov %ecx,%edi <== NOT EXECUTED
}
/*
* Wait for characters
*/
if ( wait ) {
107f75: 85 db test %ebx,%ebx <== NOT EXECUTED
107f77: 74 33 je 107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->rawInBuf.Semaphore,
107f79: 50 push %eax <== NOT EXECUTED
107f7a: 51 push %ecx <== NOT EXECUTED
107f7b: ff 76 6c pushl 0x6c(%esi) <== NOT EXECUTED
107f7e: ff 76 68 pushl 0x68(%esi) <== NOT EXECUTED
107f81: e8 ee 11 00 00 call 109174 <rtems_semaphore_obtain><== NOT EXECUTED
tty->rawInBufSemaphoreOptions,
timeout);
if (sc != RTEMS_SUCCESSFUL)
107f86: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107f89: 85 c0 test %eax,%eax <== NOT EXECUTED
107f8b: 75 1f jne 107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
rtems_status_code sc;
int wait = (int)1;
while ( wait ) {
107f8d: 89 5d dc mov %ebx,-0x24(%ebp) <== NOT EXECUTED
107f90: 89 f9 mov %edi,%ecx <== NOT EXECUTED
107f92: eb c3 jmp 107f57 <rtems_termios_read+0x278><== NOT EXECUTED
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
107f94: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED
107f97: 8a 04 10 mov (%eax,%edx,1),%al <== NOT EXECUTED
107f9a: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED
107f9d: 88 01 mov %al,(%ecx) <== NOT EXECUTED
107f9f: 41 inc %ecx <== NOT EXECUTED
107fa0: 89 4d d4 mov %ecx,-0x2c(%ebp) <== NOT EXECUTED
107fa3: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED
107fa6: 89 46 24 mov %eax,0x24(%esi) <== NOT EXECUTED
count--;
107fa9: ff 4d d0 decl -0x30(%ebp) <== NOT EXECUTED
else
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
107fac: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) <== NOT EXECUTED
107fb0: 74 08 je 107fba <rtems_termios_read+0x2db><== NOT EXECUTED
107fb2: 8b 56 24 mov 0x24(%esi),%edx <== NOT EXECUTED
107fb5: 3b 56 20 cmp 0x20(%esi),%edx <== NOT EXECUTED
107fb8: 7c da jl 107f94 <rtems_termios_read+0x2b5><== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
107fba: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
107fbd: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED
107fc0: 2b 45 d0 sub -0x30(%ebp),%eax <== NOT EXECUTED
107fc3: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
107fc6: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi) <== NOT EXECUTED
107fcd: 00 00 00
rtems_semaphore_release (tty->isem);
107fd0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107fd3: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED
107fd6: e8 81 12 00 00 call 10925c <rtems_semaphore_release><== NOT EXECUTED
107fdb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return sc;
}
107fde: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED
107fe1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
107fe4: 5b pop %ebx <== NOT EXECUTED
107fe5: 5e pop %esi <== NOT EXECUTED
107fe6: 5f pop %edi <== NOT EXECUTED
107fe7: c9 leave <== NOT EXECUTED
107fe8: c3 ret <== NOT EXECUTED
001071da <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)
{
1071da: 55 push %ebp
1071db: 89 e5 mov %esp,%ebp
1071dd: 57 push %edi
1071de: 56 push %esi
1071df: 53 push %ebx
1071e0: 83 ec 0c sub $0xc,%esp
1071e3: 8b 75 08 mov 0x8(%ebp),%esi
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
1071e6: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax
1071ec: 25 03 04 00 00 and $0x403,%eax
1071f1: 3d 01 04 00 00 cmp $0x401,%eax
1071f6: 75 2c jne 107224 <rtems_termios_refill_transmitter+0x4a><== ALWAYS TAKEN
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor,
1071f8: 57 push %edi <== NOT EXECUTED
1071f9: 6a 01 push $0x1 <== NOT EXECUTED
1071fb: 8d 46 4a lea 0x4a(%esi),%eax <== NOT EXECUTED
1071fe: 50 push %eax <== NOT EXECUTED
1071ff: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
107202: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
107208: 9c pushf <== NOT EXECUTED
107209: fa cli <== NOT EXECUTED
10720a: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
10720b: ff 8e 90 00 00 00 decl 0x90(%esi) <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
107211: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
107217: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
10721a: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED
rtems_interrupt_enable(level);
107220: 52 push %edx <== NOT EXECUTED
107221: 9d popf <== NOT EXECUTED
107222: eb 38 jmp 10725c <rtems_termios_refill_transmitter+0x82><== NOT EXECUTED
nToSend = 1;
}
else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF))
107224: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax
10722a: 83 e0 03 and $0x3,%eax
10722d: 83 f8 02 cmp $0x2,%eax
107230: 75 37 jne 107269 <rtems_termios_refill_transmitter+0x8f><== ALWAYS TAKEN
* 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,
107232: 53 push %ebx <== NOT EXECUTED
107233: 6a 01 push $0x1 <== NOT EXECUTED
107235: 8d 46 49 lea 0x49(%esi),%eax <== NOT EXECUTED
107238: 50 push %eax <== NOT EXECUTED
107239: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
10723c: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
107242: 9c pushf <== NOT EXECUTED
107243: fa cli <== NOT EXECUTED
107244: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
107245: ff 8e 90 00 00 00 decl 0x90(%esi) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
10724b: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
107251: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED
107254: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED
rtems_interrupt_enable(level);
10725a: 52 push %edx <== NOT EXECUTED
10725b: 9d popf <== NOT EXECUTED
10725c: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED
107261: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107264: e9 34 01 00 00 jmp 10739d <rtems_termios_refill_transmitter+0x1c3><== NOT EXECUTED
nToSend = 1;
}
else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
107269: 8b 96 80 00 00 00 mov 0x80(%esi),%edx
10726f: 8b 86 84 00 00 00 mov 0x84(%esi),%eax
107275: 39 c2 cmp %eax,%edx
107277: 75 21 jne 10729a <rtems_termios_refill_transmitter+0xc0><== ALWAYS TAKEN
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
107279: 31 db xor %ebx,%ebx
10727b: 83 be 94 00 00 00 02 cmpl $0x2,0x94(%esi) <== NOT EXECUTED
107282: 0f 85 15 01 00 00 jne 10739d <rtems_termios_refill_transmitter+0x1c3><== NOT EXECUTED
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
107288: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10728b: ff b6 8c 00 00 00 pushl 0x8c(%esi) <== NOT EXECUTED
107291: e8 c6 1f 00 00 call 10925c <rtems_semaphore_release><== NOT EXECUTED
107296: 31 db xor %ebx,%ebx <== NOT EXECUTED
107298: eb c7 jmp 107261 <rtems_termios_refill_transmitter+0x87><== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
10729a: 9c pushf
10729b: fa cli
10729c: 58 pop %eax
len = tty->t_dqlen;
10729d: 8b 8e 90 00 00 00 mov 0x90(%esi),%ecx
tty->t_dqlen = 0;
1072a3: c7 86 90 00 00 00 00 movl $0x0,0x90(%esi)
1072aa: 00 00 00
rtems_interrupt_enable(level);
1072ad: 50 push %eax
1072ae: 9d popf
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
1072af: 8b 96 84 00 00 00 mov 0x84(%esi),%edx
1072b5: 8b 9e 88 00 00 00 mov 0x88(%esi),%ebx
1072bb: 01 d1 add %edx,%ecx
1072bd: 89 c8 mov %ecx,%eax
1072bf: 31 d2 xor %edx,%edx
1072c1: f7 f3 div %ebx
1072c3: 89 d7 mov %edx,%edi
tty->rawOutBuf.Tail = newTail;
1072c5: 89 96 84 00 00 00 mov %edx,0x84(%esi)
if (tty->rawOutBufState == rob_wait) {
1072cb: 83 be 94 00 00 00 02 cmpl $0x2,0x94(%esi)
1072d2: 75 11 jne 1072e5 <rtems_termios_refill_transmitter+0x10b>
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
1072d4: 83 ec 0c sub $0xc,%esp
1072d7: ff b6 8c 00 00 00 pushl 0x8c(%esi)
1072dd: e8 7a 1f 00 00 call 10925c <rtems_semaphore_release>
1072e2: 83 c4 10 add $0x10,%esp
}
if (newTail == tty->rawOutBuf.Head) {
1072e5: 8b 86 80 00 00 00 mov 0x80(%esi),%eax
1072eb: 39 c7 cmp %eax,%edi
1072ed: 75 2c jne 10731b <rtems_termios_refill_transmitter+0x141>
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
1072ef: c7 86 94 00 00 00 00 movl $0x0,0x94(%esi)
1072f6: 00 00 00
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
1072f9: 8b 96 d4 00 00 00 mov 0xd4(%esi),%edx
1072ff: 31 db xor %ebx,%ebx
107301: 85 d2 test %edx,%edx
107303: 0f 84 8e 00 00 00 je 107397 <rtems_termios_refill_transmitter+0x1bd><== ALWAYS TAKEN
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
107309: 51 push %ecx <== NOT EXECUTED
10730a: 51 push %ecx <== NOT EXECUTED
10730b: ff b6 d8 00 00 00 pushl 0xd8(%esi) <== NOT EXECUTED
107311: 8d 46 30 lea 0x30(%esi),%eax <== NOT EXECUTED
107314: 50 push %eax <== NOT EXECUTED
107315: ff d2 call *%edx <== NOT EXECUTED
107317: 31 db xor %ebx,%ebx <== NOT EXECUTED
107319: eb 79 jmp 107394 <rtems_termios_refill_transmitter+0x1ba><== NOT EXECUTED
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
10731b: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax
107321: 25 10 02 00 00 and $0x210,%eax
107326: 3d 10 02 00 00 cmp $0x210,%eax
10732b: 75 22 jne 10734f <rtems_termios_refill_transmitter+0x175><== ALWAYS TAKEN
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
10732d: 9c pushf <== NOT EXECUTED
10732e: fa cli <== NOT EXECUTED
10732f: 5a pop %edx <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
107330: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
107336: 83 c8 20 or $0x20,%eax <== NOT EXECUTED
107339: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
10733f: c7 86 94 00 00 00 01 movl $0x1,0x94(%esi) <== NOT EXECUTED
107346: 00 00 00
rtems_interrupt_enable(level);
107349: 52 push %edx <== NOT EXECUTED
10734a: 9d popf <== NOT EXECUTED
10734b: 31 db xor %ebx,%ebx <== NOT EXECUTED
10734d: eb 48 jmp 107397 <rtems_termios_refill_transmitter+0x1bd><== NOT EXECUTED
}
else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
10734f: 8b 86 80 00 00 00 mov 0x80(%esi),%eax
107355: 39 c7 cmp %eax,%edi
107357: 76 08 jbe 107361 <rtems_termios_refill_transmitter+0x187>
nToSend = tty->rawOutBuf.Size - newTail;
107359: 8b 9e 88 00 00 00 mov 0x88(%esi),%ebx
10735f: eb 06 jmp 107367 <rtems_termios_refill_transmitter+0x18d>
else
nToSend = tty->rawOutBuf.Head - newTail;
107361: 8b 9e 80 00 00 00 mov 0x80(%esi),%ebx
107367: 29 fb sub %edi,%ebx
/* 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)) {
107369: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax
10736f: f6 c4 06 test $0x6,%ah
107372: 74 05 je 107379 <rtems_termios_refill_transmitter+0x19f><== ALWAYS TAKEN
107374: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
107379: c7 86 94 00 00 00 01 movl $0x1,0x94(%esi)
107380: 00 00 00
(*tty->device.write)(tty->minor,
107383: 50 push %eax
107384: 53 push %ebx
107385: 8b 46 7c mov 0x7c(%esi),%eax
107388: 01 f8 add %edi,%eax
10738a: 50 push %eax
10738b: ff 76 10 pushl 0x10(%esi)
10738e: ff 96 a4 00 00 00 call *0xa4(%esi)
107394: 83 c4 10 add $0x10,%esp
&tty->rawOutBuf.theBuf[newTail],
nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
107397: 89 be 84 00 00 00 mov %edi,0x84(%esi)
}
return nToSend;
}
10739d: 89 d8 mov %ebx,%eax
10739f: 8d 65 f4 lea -0xc(%ebp),%esp
1073a2: 5b pop %ebx
1073a3: 5e pop %esi
1073a4: 5f pop %edi
1073a5: c9 leave
1073a6: c3 ret
0010891e <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
10891e: 55 push %ebp <== NOT EXECUTED
10891f: 89 e5 mov %esp,%ebp <== NOT EXECUTED
108921: 57 push %edi <== NOT EXECUTED
108922: 56 push %esi <== NOT EXECUTED
108923: 53 push %ebx <== NOT EXECUTED
108924: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED
108927: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
char c_buf;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_RX_PROC_EVENT |
10892a: 8d 7d ec lea -0x14(%ebp),%edi <== NOT EXECUTED
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters (
10892d: 8d 75 f3 lea -0xd(%ebp),%esi <== NOT EXECUTED
char c_buf;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_RX_PROC_EVENT |
108930: 57 push %edi <== NOT EXECUTED
108931: 6a 00 push $0x0 <== NOT EXECUTED
108933: 6a 02 push $0x2 <== NOT EXECUTED
108935: 6a 03 push $0x3 <== NOT EXECUTED
108937: e8 38 02 00 00 call 108b74 <rtems_event_receive> <== NOT EXECUTED
TERMIOS_RX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
10893c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10893f: f6 45 ec 01 testb $0x1,-0x14(%ebp) <== NOT EXECUTED
108943: 74 16 je 10895b <rtems_termios_rxdaemon+0x3d><== NOT EXECUTED
tty->rxTaskId = 0;
108945: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) <== NOT EXECUTED
10894c: 00 00 00
rtems_task_delete(RTEMS_SELF);
10894f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108952: 6a 00 push $0x0 <== NOT EXECUTED
108954: e8 c3 0a 00 00 call 10941c <rtems_task_delete> <== NOT EXECUTED
108959: eb 21 jmp 10897c <rtems_termios_rxdaemon+0x5e><== NOT EXECUTED
}
else {
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
10895b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10895e: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
108961: ff 93 a0 00 00 00 call *0xa0(%ebx) <== NOT EXECUTED
if (c != EOF) {
108967: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10896a: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED
10896d: 74 c1 je 108930 <rtems_termios_rxdaemon+0x12><== NOT EXECUTED
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
10896f: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED
rtems_termios_enqueue_raw_characters (
108972: 50 push %eax <== NOT EXECUTED
108973: 6a 01 push $0x1 <== NOT EXECUTED
108975: 56 push %esi <== NOT EXECUTED
108976: 53 push %ebx <== NOT EXECUTED
108977: e8 8f ea ff ff call 10740b <rtems_termios_enqueue_raw_characters><== NOT EXECUTED
10897c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10897f: eb af jmp 108930 <rtems_termios_rxdaemon+0x12><== NOT EXECUTED
001071bf <rtems_termios_rxirq_occured>:
* signal receive interrupt to rx daemon
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
*/
void rtems_termios_rxirq_occured(struct rtems_termios_tty *tty)
{
1071bf: 55 push %ebp <== NOT EXECUTED
1071c0: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1071c2: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
/*
* send event to rx daemon task
*/
rtems_event_send(tty->rxTaskId,TERMIOS_RX_PROC_EVENT);
1071c5: 6a 02 push $0x2 <== NOT EXECUTED
1071c7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
1071ca: ff b0 c4 00 00 00 pushl 0xc4(%eax) <== NOT EXECUTED
1071d0: e8 0f 1b 00 00 call 108ce4 <rtems_event_send> <== NOT EXECUTED
1071d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
1071d8: c9 leave <== NOT EXECUTED
1071d9: c3 ret <== NOT EXECUTED
001088bb <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
1088bb: 55 push %ebp <== NOT EXECUTED
1088bc: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1088be: 56 push %esi <== NOT EXECUTED
1088bf: 53 push %ebx <== NOT EXECUTED
1088c0: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
1088c3: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_TX_START_EVENT |
1088c6: 8d 75 f4 lea -0xc(%ebp),%esi <== NOT EXECUTED
1088c9: 56 push %esi <== NOT EXECUTED
1088ca: 6a 00 push $0x0 <== NOT EXECUTED
1088cc: 6a 02 push $0x2 <== NOT EXECUTED
1088ce: 6a 03 push $0x3 <== NOT EXECUTED
1088d0: e8 9f 02 00 00 call 108b74 <rtems_event_receive> <== NOT EXECUTED
TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
1088d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1088d8: f6 45 f4 01 testb $0x1,-0xc(%ebp) <== NOT EXECUTED
1088dc: 74 16 je 1088f4 <rtems_termios_txdaemon+0x39><== NOT EXECUTED
tty->txTaskId = 0;
1088de: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED
1088e5: 00 00 00
rtems_task_delete(RTEMS_SELF);
1088e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1088eb: 6a 00 push $0x0 <== NOT EXECUTED
1088ed: e8 2a 0b 00 00 call 10941c <rtems_task_delete> <== NOT EXECUTED
1088f2: eb 25 jmp 108919 <rtems_termios_txdaemon+0x5e><== NOT EXECUTED
}
else {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
1088f4: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED
1088fa: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
1088fd: 8b 80 60 d4 11 00 mov 0x11d460(%eax),%eax <== NOT EXECUTED
108903: 85 c0 test %eax,%eax <== NOT EXECUTED
108905: 74 09 je 108910 <rtems_termios_txdaemon+0x55><== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
108907: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10890a: 53 push %ebx <== NOT EXECUTED
10890b: ff d0 call *%eax <== NOT EXECUTED
10890d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
108910: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108913: 53 push %ebx <== NOT EXECUTED
108914: e8 c1 e8 ff ff call 1071da <rtems_termios_refill_transmitter><== NOT EXECUTED
108919: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10891c: eb ab jmp 1088c9 <rtems_termios_txdaemon+0xe><== NOT EXECUTED
00107bd9 <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
107bd9: 55 push %ebp
107bda: 89 e5 mov %esp,%ebp
107bdc: 57 push %edi
107bdd: 56 push %esi
107bde: 53 push %ebx
107bdf: 83 ec 10 sub $0x10,%esp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
107be2: 8b 55 08 mov 0x8(%ebp),%edx
107be5: 8b 02 mov (%edx),%eax
107be7: 8b 78 28 mov 0x28(%eax),%edi
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
107bea: 6a 00 push $0x0
107bec: 6a 00 push $0x0
107bee: ff 77 18 pushl 0x18(%edi)
107bf1: e8 7e 15 00 00 call 109174 <rtems_semaphore_obtain>
107bf6: 89 45 f0 mov %eax,-0x10(%ebp)
if (sc != RTEMS_SUCCESSFUL)
107bf9: 83 c4 10 add $0x10,%esp
107bfc: 85 c0 test %eax,%eax
107bfe: 75 77 jne 107c77 <rtems_termios_write+0x9e><== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
107c00: 8b 87 cc 00 00 00 mov 0xcc(%edi),%eax
107c06: c1 e0 05 shl $0x5,%eax
107c09: 8b 80 58 d4 11 00 mov 0x11d458(%eax),%eax
107c0f: 85 c0 test %eax,%eax
107c11: 74 0e je 107c21 <rtems_termios_write+0x48><== ALWAYS TAKEN
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
107c13: 52 push %edx <== NOT EXECUTED
107c14: 52 push %edx <== NOT EXECUTED
107c15: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
107c18: 57 push %edi <== NOT EXECUTED
107c19: ff d0 call *%eax <== NOT EXECUTED
107c1b: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
107c1e: 5e pop %esi <== NOT EXECUTED
107c1f: eb 4b jmp 107c6c <rtems_termios_write+0x93><== NOT EXECUTED
return sc;
}
if (tty->termios.c_oflag & OPOST) {
107c21: f6 47 34 01 testb $0x1,0x34(%edi)
107c25: 74 26 je 107c4d <rtems_termios_write+0x74><== NEVER TAKEN
uint32_t count = args->count;
107c27: 8b 45 08 mov 0x8(%ebp),%eax
107c2a: 8b 70 0c mov 0xc(%eax),%esi
char *buffer = args->buffer;
107c2d: 8b 58 08 mov 0x8(%eax),%ebx
107c30: eb 0c jmp 107c3e <rtems_termios_write+0x65>
while (count--)
oproc (*buffer++, tty);
107c32: 0f b6 03 movzbl (%ebx),%eax
107c35: 43 inc %ebx
107c36: 89 fa mov %edi,%edx
107c38: e8 6b fb ff ff call 1077a8 <oproc>
107c3d: 4e dec %esi
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
107c3e: 85 f6 test %esi,%esi
107c40: 75 f0 jne 107c32 <rtems_termios_write+0x59>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
107c42: 8b 55 08 mov 0x8(%ebp),%edx
107c45: 8b 42 0c mov 0xc(%edx),%eax
107c48: 89 42 14 mov %eax,0x14(%edx)
107c4b: eb 1c jmp 107c69 <rtems_termios_write+0x90>
}
else {
rtems_termios_puts (args->buffer, args->count, tty);
107c4d: 53 push %ebx <== NOT EXECUTED
107c4e: 57 push %edi <== NOT EXECUTED
107c4f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
107c52: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
107c55: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
107c58: e8 36 fa ff ff call 107693 <rtems_termios_puts> <== NOT EXECUTED
args->bytes_moved = args->count;
107c5d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
107c60: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED
107c63: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED
107c66: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
rtems_semaphore_release (tty->osem);
107c69: 83 ec 0c sub $0xc,%esp
107c6c: ff 77 18 pushl 0x18(%edi)
107c6f: e8 e8 15 00 00 call 10925c <rtems_semaphore_release>
107c74: 83 c4 10 add $0x10,%esp
return sc;
}
107c77: 8b 45 f0 mov -0x10(%ebp),%eax
107c7a: 8d 65 f4 lea -0xc(%ebp),%esp
107c7d: 5b pop %ebx
107c7e: 5e pop %esi
107c7f: 5f pop %edi
107c80: c9 leave
107c81: c3 ret
00112ad8 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
Objects_Id id
)
{
112ad8: 55 push %ebp
112ad9: 89 e5 mov %esp,%ebp
112adb: 83 ec 1c sub $0x1c,%esp
/**
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
112ade: 8d 45 fc lea -0x4(%ebp),%eax
112ae1: 50 push %eax
112ae2: ff 75 08 pushl 0x8(%ebp)
112ae5: 68 78 4a 13 00 push $0x134a78
112aea: e8 09 25 00 00 call 114ff8 <_Objects_Get>
112aef: 89 c2 mov %eax,%edx
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
112af1: 83 c4 10 add $0x10,%esp
112af4: b8 04 00 00 00 mov $0x4,%eax
112af9: 83 7d fc 00 cmpl $0x0,-0x4(%ebp)
112afd: 75 1c jne 112b1b <rtems_timer_cancel+0x43>
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
112aff: 83 7a 38 04 cmpl $0x4,0x38(%edx)
112b03: 74 0f je 112b14 <rtems_timer_cancel+0x3c><== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
112b05: 83 ec 0c sub $0xc,%esp
112b08: 8d 42 10 lea 0x10(%edx),%eax
112b0b: 50 push %eax
112b0c: e8 db 3e 00 00 call 1169ec <_Watchdog_Remove>
112b11: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
112b14: e8 9f 2c 00 00 call 1157b8 <_Thread_Enable_dispatch>
112b19: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112b1b: c9 leave
112b1c: c3 ret
0010a038 <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
Objects_Id *id
)
{
10a038: 55 push %ebp
10a039: 89 e5 mov %esp,%ebp
10a03b: 57 push %edi
10a03c: 56 push %esi
10a03d: 53 push %ebx
10a03e: 83 ec 0c sub $0xc,%esp
10a041: 8b 75 08 mov 0x8(%ebp),%esi
10a044: 8b 7d 0c mov 0xc(%ebp),%edi
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
10a047: b8 03 00 00 00 mov $0x3,%eax
10a04c: 85 f6 test %esi,%esi
10a04e: 74 73 je 10a0c3 <rtems_timer_create+0x8b>
return RTEMS_INVALID_NAME;
if ( !id )
10a050: b8 09 00 00 00 mov $0x9,%eax
10a055: 85 ff test %edi,%edi
10a057: 74 6a je 10a0c3 <rtems_timer_create+0x8b><== NEVER TAKEN
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10a059: a1 98 0a 12 00 mov 0x120a98,%eax
10a05e: 40 inc %eax
10a05f: a3 98 0a 12 00 mov %eax,0x120a98
#ifdef __cplusplus
extern "C" {
#endif
/**
10a064: 83 ec 0c sub $0xc,%esp
10a067: 68 80 10 12 00 push $0x121080
10a06c: e8 f7 0d 00 00 call 10ae68 <_Objects_Allocate>
10a071: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
10a073: 83 c4 10 add $0x10,%esp
10a076: 85 c0 test %eax,%eax
10a078: 75 0c jne 10a086 <rtems_timer_create+0x4e>
_Thread_Enable_dispatch();
10a07a: e8 ed 19 00 00 call 10ba6c <_Thread_Enable_dispatch>
10a07f: b8 05 00 00 00 mov $0x5,%eax
10a084: eb 3d jmp 10a0c3 <rtems_timer_create+0x8b>
return RTEMS_TOO_MANY;
}
the_timer->the_class = TIMER_DORMANT;
10a086: c7 40 38 04 00 00 00 movl $0x4,0x38(%eax)
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
10a08d: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
* @param[in] the_heap is the heap to operate upon
10a094: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
* @param[in] starting_address is the starting address of the memory for
10a09b: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
* the heap
10a0a2: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
10a0a9: 8b 48 08 mov 0x8(%eax),%ecx
10a0ac: 0f b7 d1 movzwl %cx,%edx
10a0af: a1 9c 10 12 00 mov 0x12109c,%eax
10a0b4: 89 1c 90 mov %ebx,(%eax,%edx,4)
10a0b7: 89 73 0c mov %esi,0xc(%ebx)
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
10a0ba: 89 0f mov %ecx,(%edi)
_Thread_Enable_dispatch();
10a0bc: e8 ab 19 00 00 call 10ba6c <_Thread_Enable_dispatch>
10a0c1: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
10a0c3: 8d 65 f4 lea -0xc(%ebp),%esp
10a0c6: 5b pop %ebx
10a0c7: 5e pop %esi
10a0c8: 5f pop %edi
10a0c9: c9 leave
10a0ca: c3 ret
0010a0cc <rtems_timer_fire_after>:
Objects_Id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
10a0cc: 55 push %ebp
10a0cd: 89 e5 mov %esp,%ebp
10a0cf: 57 push %edi
10a0d0: 56 push %esi
10a0d1: 53 push %ebx
10a0d2: 83 ec 1c sub $0x1c,%esp
10a0d5: 8b 7d 10 mov 0x10(%ebp),%edi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
10a0d8: b8 0a 00 00 00 mov $0xa,%eax
10a0dd: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10a0e1: 0f 84 8e 00 00 00 je 10a175 <rtems_timer_fire_after+0xa9>
return RTEMS_INVALID_NUMBER;
if ( !routine )
10a0e7: b8 09 00 00 00 mov $0x9,%eax
10a0ec: 85 ff test %edi,%edi
10a0ee: 0f 84 81 00 00 00 je 10a175 <rtems_timer_fire_after+0xa9><== NEVER TAKEN
/**
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
10a0f4: 52 push %edx
10a0f5: 8d 45 f0 lea -0x10(%ebp),%eax
10a0f8: 50 push %eax
10a0f9: ff 75 08 pushl 0x8(%ebp)
10a0fc: 68 80 10 12 00 push $0x121080
10a101: e8 a6 11 00 00 call 10b2ac <_Objects_Get>
10a106: 89 c3 mov %eax,%ebx
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
10a108: 83 c4 10 add $0x10,%esp
10a10b: b8 04 00 00 00 mov $0x4,%eax
10a110: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
10a114: 75 5f jne 10a175 <rtems_timer_fire_after+0xa9>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
10a116: 8d 73 10 lea 0x10(%ebx),%esi
10a119: 83 ec 0c sub $0xc,%esp
10a11c: 56 push %esi
10a11d: e8 6a 28 00 00 call 10c98c <_Watchdog_Remove>
_ISR_Disable( level );
10a122: 9c pushf
10a123: fa cli
10a124: 5a pop %edx
/*
* 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 ) {
10a125: 83 c4 10 add $0x10,%esp
10a128: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
10a12c: 74 0b je 10a139 <rtems_timer_fire_after+0x6d><== ALWAYS TAKEN
_ISR_Enable( level );
10a12e: 52 push %edx <== NOT EXECUTED
10a12f: 9d popf <== NOT EXECUTED
_Thread_Enable_dispatch();
10a130: e8 37 19 00 00 call 10ba6c <_Thread_Enable_dispatch><== NOT EXECUTED
10a135: 31 c0 xor %eax,%eax <== NOT EXECUTED
10a137: eb 3c jmp 10a175 <rtems_timer_fire_after+0xa9><== NOT EXECUTED
/*
* 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;
10a139: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx)
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
10a140: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
* @param[in] the_heap is the heap to operate upon
10a147: 89 7b 2c mov %edi,0x2c(%ebx)
* @param[in] starting_address is the starting address of the memory for
10a14a: 8b 45 08 mov 0x8(%ebp),%eax
10a14d: 89 43 30 mov %eax,0x30(%ebx)
* the heap
10a150: 8b 45 14 mov 0x14(%ebp),%eax
10a153: 89 43 34 mov %eax,0x34(%ebx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_ISR_Enable( level );
10a156: 52 push %edx
10a157: 9d popf
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
Heap_Control *the_heap,
10a158: 8b 45 0c mov 0xc(%ebp),%eax
10a15b: 89 43 1c mov %eax,0x1c(%ebx)
void *starting_address,
size_t *size
10a15e: 50 push %eax
10a15f: 50 push %eax
10a160: 56 push %esi
10a161: 68 78 0b 12 00 push $0x120b78
10a166: e8 09 27 00 00 call 10c874 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
_Thread_Enable_dispatch();
10a16b: e8 fc 18 00 00 call 10ba6c <_Thread_Enable_dispatch>
10a170: 31 c0 xor %eax,%eax
10a172: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a175: 8d 65 f4 lea -0xc(%ebp),%esp
10a178: 5b pop %ebx
10a179: 5e pop %esi
10a17a: 5f pop %edi
10a17b: c9 leave
10a17c: c3 ret
00112cc4 <rtems_timer_fire_when>:
Objects_Id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
112cc4: 55 push %ebp
112cc5: 89 e5 mov %esp,%ebp
112cc7: 57 push %edi
112cc8: 56 push %esi
112cc9: 53 push %ebx
112cca: 83 ec 1c sub $0x1c,%esp
112ccd: 8b 5d 0c mov 0xc(%ebp),%ebx
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
112cd0: b8 0b 00 00 00 mov $0xb,%eax
112cd5: 80 3d 4c 41 13 00 00 cmpb $0x0,0x13414c
112cdc: 0f 84 ae 00 00 00 je 112d90 <rtems_timer_fire_when+0xcc>
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
112ce2: 83 ec 0c sub $0xc,%esp
112ce5: 53 push %ebx
112ce6: e8 85 da ff ff call 110770 <_TOD_Validate>
112ceb: 83 c4 10 add $0x10,%esp
112cee: 84 c0 test %al,%al
112cf0: 0f 84 95 00 00 00 je 112d8b <rtems_timer_fire_when+0xc7>
return RTEMS_INVALID_CLOCK;
if ( !routine )
112cf6: b8 09 00 00 00 mov $0x9,%eax
112cfb: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
112cff: 0f 84 8b 00 00 00 je 112d90 <rtems_timer_fire_when+0xcc><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
112d05: 83 ec 0c sub $0xc,%esp
112d08: 53 push %ebx
112d09: e8 fa d9 ff ff call 110708 <_TOD_To_seconds>
112d0e: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch )
112d10: 83 c4 10 add $0x10,%esp
112d13: 3b 05 c8 41 13 00 cmp 0x1341c8,%eax
112d19: 76 70 jbe 112d8b <rtems_timer_fire_when+0xc7>
/**
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
112d1b: 51 push %ecx
112d1c: 8d 45 f0 lea -0x10(%ebp),%eax
112d1f: 50 push %eax
112d20: ff 75 08 pushl 0x8(%ebp)
112d23: 68 78 4a 13 00 push $0x134a78
112d28: e8 cb 22 00 00 call 114ff8 <_Objects_Get>
112d2d: 89 c6 mov %eax,%esi
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
112d2f: 83 c4 10 add $0x10,%esp
112d32: b8 04 00 00 00 mov $0x4,%eax
112d37: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
112d3b: 75 53 jne 112d90 <rtems_timer_fire_when+0xcc>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
112d3d: 8d 5e 10 lea 0x10(%esi),%ebx
112d40: 83 ec 0c sub $0xc,%esp
112d43: 53 push %ebx
112d44: e8 a3 3c 00 00 call 1169ec <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY;
112d49: c7 46 38 02 00 00 00 movl $0x2,0x38(%esi)
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
112d50: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi)
* @param[in] the_heap is the heap to operate upon
112d57: 8b 45 10 mov 0x10(%ebp),%eax
112d5a: 89 46 2c mov %eax,0x2c(%esi)
* @param[in] starting_address is the starting address of the memory for
112d5d: 8b 45 08 mov 0x8(%ebp),%eax
112d60: 89 46 30 mov %eax,0x30(%esi)
* the heap
112d63: 8b 45 14 mov 0x14(%ebp),%eax
112d66: 89 46 34 mov %eax,0x34(%esi)
* @return TRUE if successfully able to resize the block.
* FALSE if the block can't be resized in place.
*/
bool _Protected_heap_Resize_block(
Heap_Control *the_heap,
void *starting_address,
112d69: 2b 3d c8 41 13 00 sub 0x1341c8,%edi
112d6f: 89 7e 1c mov %edi,0x1c(%esi)
size_t size
);
112d72: 58 pop %eax
112d73: 5a pop %edx
112d74: 53 push %ebx
112d75: 68 0c 42 13 00 push $0x13420c
112d7a: e8 55 3b 00 00 call 1168d4 <_Watchdog_Insert>
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_Watchdog_Insert_seconds(
&the_timer->Ticker,
seconds - _TOD_Seconds_since_epoch
);
_Thread_Enable_dispatch();
112d7f: e8 34 2a 00 00 call 1157b8 <_Thread_Enable_dispatch>
112d84: 31 c0 xor %eax,%eax
112d86: 83 c4 10 add $0x10,%esp
112d89: eb 05 jmp 112d90 <rtems_timer_fire_when+0xcc>
return RTEMS_SUCCESSFUL;
112d8b: b8 14 00 00 00 mov $0x14,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112d90: 8d 65 f4 lea -0xc(%ebp),%esp
112d93: 5b pop %ebx
112d94: 5e pop %esi
112d95: 5f pop %edi
112d96: c9 leave
112d97: c3 ret
00112d98 <rtems_timer_get_information>:
rtems_status_code rtems_timer_get_information(
Objects_Id id,
rtems_timer_information *the_info
)
{
112d98: 55 push %ebp
112d99: 89 e5 mov %esp,%ebp
112d9b: 53 push %ebx
112d9c: 83 ec 14 sub $0x14,%esp
112d9f: 8b 5d 0c mov 0xc(%ebp),%ebx
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
112da2: b8 09 00 00 00 mov $0x9,%eax
112da7: 85 db test %ebx,%ebx
112da9: 74 40 je 112deb <rtems_timer_get_information+0x53><== NEVER TAKEN
/**
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
112dab: 50 push %eax
112dac: 8d 45 f8 lea -0x8(%ebp),%eax
112daf: 50 push %eax
112db0: ff 75 08 pushl 0x8(%ebp)
112db3: 68 78 4a 13 00 push $0x134a78
112db8: e8 3b 22 00 00 call 114ff8 <_Objects_Get>
112dbd: 89 c2 mov %eax,%edx
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
112dbf: 83 c4 10 add $0x10,%esp
112dc2: b8 04 00 00 00 mov $0x4,%eax
112dc7: 83 7d f8 00 cmpl $0x0,-0x8(%ebp)
112dcb: 75 1e jne 112deb <rtems_timer_get_information+0x53>
case OBJECTS_LOCAL:
the_info->the_class = the_timer->the_class;
112dcd: 8b 42 38 mov 0x38(%edx),%eax
112dd0: 89 03 mov %eax,(%ebx)
the_info->initial = the_timer->Ticker.initial;
112dd2: 8b 42 1c mov 0x1c(%edx),%eax
112dd5: 89 43 04 mov %eax,0x4(%ebx)
the_info->start_time = the_timer->Ticker.start_time;
112dd8: 8b 42 24 mov 0x24(%edx),%eax
112ddb: 89 43 08 mov %eax,0x8(%ebx)
the_info->stop_time = the_timer->Ticker.stop_time;
112dde: 8b 42 28 mov 0x28(%edx),%eax
112de1: 89 43 0c mov %eax,0xc(%ebx)
_Thread_Enable_dispatch();
112de4: e8 cf 29 00 00 call 1157b8 <_Thread_Enable_dispatch>
112de9: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112deb: 8b 5d fc mov -0x4(%ebp),%ebx
112dee: c9 leave
112def: c3 ret
00113048 <rtems_timer_initiate_server>:
rtems_status_code rtems_timer_initiate_server(
uint32_t priority,
uint32_t stack_size,
rtems_attribute attribute_set
)
{
113048: 55 push %ebp
113049: 89 e5 mov %esp,%ebp
11304b: 57 push %edi
11304c: 56 push %esi
11304d: 53 push %ebx
11304e: 83 ec 1c sub $0x1c,%esp
113051: 8b 55 08 mov 0x8(%ebp),%edx
113054: 8b 75 10 mov 0x10(%ebp),%esi
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
size_t size
);
113057: 31 c0 xor %eax,%eax
113059: 85 d2 test %edx,%edx
11305b: 74 0f je 11306c <rtems_timer_initiate_server+0x24>
11305d: 0f b6 05 c4 b9 12 00 movzbl 0x12b9c4,%eax
113064: 39 c2 cmp %eax,%edx
113066: 0f 96 c0 setbe %al
113069: 0f b6 c0 movzbl %al,%eax
* Make sure the requested priority is valid. The if is
* 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 ) ) {
11306c: 89 d7 mov %edx,%edi
11306e: 85 c0 test %eax,%eax
113070: 75 0e jne 113080 <rtems_timer_initiate_server+0x38><== NEVER TAKEN
if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
113072: b8 13 00 00 00 mov $0x13,%eax
113077: 42 inc %edx
113078: 0f 85 31 01 00 00 jne 1131af <rtems_timer_initiate_server+0x167>
11307e: 31 ff xor %edi,%edi
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
113080: a1 38 41 13 00 mov 0x134138,%eax
113085: 40 inc %eax
113086: a3 38 41 13 00 mov %eax,0x134138
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
11308b: 8a 1d ac fb 12 00 mov 0x12fbac,%bl
initialized = true;
113091: c6 05 ac fb 12 00 01 movb $0x1,0x12fbac
_Thread_Enable_dispatch();
113098: e8 1b 27 00 00 call 1157b8 <_Thread_Enable_dispatch>
if ( tmpInitialized )
11309d: b8 0e 00 00 00 mov $0xe,%eax
1130a2: 84 db test %bl,%bl
1130a4: 0f 85 05 01 00 00 jne 1131af <rtems_timer_initiate_server+0x167>
1130aa: c7 05 cc 40 13 00 d0 movl $0x1340d0,0x1340cc
1130b1: 40 13 00
1130b4: c7 05 d0 40 13 00 00 movl $0x0,0x1340d0
1130bb: 00 00 00
1130be: c7 05 d4 40 13 00 cc movl $0x1340cc,0x1340d4
1130c5: 40 13 00
* 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(
1130c8: 52 push %edx
1130c9: 52 push %edx
1130ca: 8d 45 f0 lea -0x10(%ebp),%eax
1130cd: 50 push %eax
1130ce: 81 ce 00 80 00 00 or $0x8000,%esi
1130d4: 56 push %esi
1130d5: 68 00 01 00 00 push $0x100
1130da: ff 75 0c pushl 0xc(%ebp)
1130dd: 57 push %edi
1130de: 68 45 4d 49 54 push $0x54494d45
1130e3: e8 70 f3 ff ff call 112458 <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) {
1130e8: 83 c4 20 add $0x20,%esp
1130eb: 85 c0 test %eax,%eax
1130ed: 0f 85 b5 00 00 00 jne 1131a8 <rtems_timer_initiate_server+0x160>
* to a TCB pointer from here out.
*
* NOTE: Setting the pointer to the Timer Server TCB to a value other than
* NULL indicates that task-based timer support is initialized.
*/
_Timer_Server = (Thread_Control *)_Objects_Get_local_object(
1130f3: 8b 4d f0 mov -0x10(%ebp),%ecx
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
);
/**
1130f6: 31 c0 xor %eax,%eax
1130f8: 66 3b 0d 7c 40 13 00 cmp 0x13407c,%cx
1130ff: 77 0b ja 11310c <rtems_timer_initiate_server+0xc4><== NEVER TAKEN
* This heap routine returns information about the free blocks
* in the specified heap.
113101: 0f b7 d1 movzwl %cx,%edx
113104: a1 88 40 13 00 mov 0x134088,%eax
113109: 8b 04 90 mov (%eax,%edx,4),%eax
11310c: a3 bc 4a 13 00 mov %eax,0x134abc
113111: c7 05 ac 40 13 00 b0 movl $0x1340b0,0x1340ac
113118: 40 13 00
11311b: c7 05 b0 40 13 00 00 movl $0x0,0x1340b0
113122: 00 00 00
113125: c7 05 b4 40 13 00 ac movl $0x1340ac,0x1340b4
11312c: 40 13 00
11312f: c7 05 c0 40 13 00 c4 movl $0x1340c4,0x1340c0
113136: 40 13 00
113139: c7 05 c4 40 13 00 00 movl $0x0,0x1340c4
113140: 00 00 00
113143: c7 05 c8 40 13 00 c0 movl $0x1340c0,0x1340c8
11314a: 40 13 00
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
11314d: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
* @param[in] the_heap is the heap to operate upon
113154: c7 40 64 3c 56 11 00 movl $0x11563c,0x64(%eax)
* @param[in] starting_address is the starting address of the memory for
11315b: 89 48 68 mov %ecx,0x68(%eax)
* the heap
11315e: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax)
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
113165: c7 05 e0 40 13 00 00 movl $0x0,0x1340e0
11316c: 00 00 00
* @param[in] the_heap is the heap to operate upon
11316f: c7 05 f4 40 13 00 3c movl $0x11563c,0x1340f4
113176: 56 11 00
* @param[in] starting_address is the starting address of the memory for
113179: 89 0d f8 40 13 00 mov %ecx,0x1340f8
* the heap
11317f: c7 05 fc 40 13 00 00 movl $0x0,0x1340fc
113186: 00 00 00
/*
* Initialize the pointer to the timer reset method so applications
* that do not use the Timer Server do not have to pull it in.
*/
_Timer_Server_schedule_operation = _Timer_Server_schedule_operation_method;
113189: c7 05 b8 4a 13 00 b7 movl $0x1131b7,0x134ab8
113190: 31 11 00
/*
* Start the timer server
*/
status = rtems_task_start(
113193: 50 push %eax
113194: 6a 00 push $0x0
113196: 68 40 32 11 00 push $0x113240
11319b: 51 push %ecx
11319c: e8 53 f7 ff ff call 1128f4 <rtems_task_start>
id, /* the id from create */
(rtems_task_entry) _Timer_Server_body, /* the timer server entry point */
0 /* there is no argument */
);
if (status) {
1131a1: 83 c4 10 add $0x10,%esp
1131a4: 85 c0 test %eax,%eax
1131a6: 74 07 je 1131af <rtems_timer_initiate_server+0x167><== ALWAYS TAKEN
* but there is actually no way (in normal circumstances) that the
* start can fail. The id and starting address are known to be
* be good. If this service fails, something is weirdly wrong on the
* target such as a stray write in an ISR or incorrect memory layout.
*/
initialized = false;
1131a8: c6 05 ac fb 12 00 00 movb $0x0,0x12fbac
}
return status;
}
1131af: 8d 65 f4 lea -0xc(%ebp),%esp
1131b2: 5b pop %ebx
1131b3: 5e pop %esi
1131b4: 5f pop %edi
1131b5: c9 leave
1131b6: c3 ret
00112e14 <rtems_timer_reset>:
*/
rtems_status_code rtems_timer_reset(
Objects_Id id
)
{
112e14: 55 push %ebp
112e15: 89 e5 mov %esp,%ebp
112e17: 53 push %ebx
112e18: 83 ec 18 sub $0x18,%esp
112e1b: 8d 45 f8 lea -0x8(%ebp),%eax
112e1e: 50 push %eax
112e1f: ff 75 08 pushl 0x8(%ebp)
112e22: 68 78 4a 13 00 push $0x134a78
112e27: e8 cc 21 00 00 call 114ff8 <_Objects_Get>
112e2c: 89 c3 mov %eax,%ebx
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
112e2e: 83 c4 10 add $0x10,%esp
112e31: b8 04 00 00 00 mov $0x4,%eax
112e36: 83 7d f8 00 cmpl $0x0,-0x8(%ebp)
112e3a: 75 6e jne 112eaa <rtems_timer_reset+0x96>
case OBJECTS_LOCAL:
switch ( the_timer->the_class ) {
112e3c: 8b 43 38 mov 0x38(%ebx),%eax
112e3f: 83 f8 01 cmp $0x1,%eax
112e42: 74 24 je 112e68 <rtems_timer_reset+0x54>
112e44: 72 07 jb 112e4d <rtems_timer_reset+0x39>
112e46: 83 f8 04 cmp $0x4,%eax
112e49: 77 58 ja 112ea3 <rtems_timer_reset+0x8f><== NEVER TAKEN
112e4b: eb 4a jmp 112e97 <rtems_timer_reset+0x83>
case TIMER_INTERVAL:
_Watchdog_Remove( &the_timer->Ticker );
112e4d: 83 c3 10 add $0x10,%ebx
112e50: 83 ec 0c sub $0xc,%esp
112e53: 53 push %ebx
112e54: e8 93 3b 00 00 call 1169ec <_Watchdog_Remove>
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
112e59: 58 pop %eax
112e5a: 5a pop %edx
112e5b: 53 push %ebx
112e5c: 68 18 42 13 00 push $0x134218
112e61: e8 6e 3a 00 00 call 1168d4 <_Watchdog_Insert>
112e66: eb 2a jmp 112e92 <rtems_timer_reset+0x7e>
break;
case TIMER_INTERVAL_ON_TASK:
if ( !_Timer_Server_schedule_operation ) {
112e68: 83 3d b8 4a 13 00 00 cmpl $0x0,0x134ab8
112e6f: 75 0c jne 112e7d <rtems_timer_reset+0x69><== ALWAYS TAKEN
_Thread_Enable_dispatch();
112e71: e8 42 29 00 00 call 1157b8 <_Thread_Enable_dispatch><== NOT EXECUTED
112e76: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED
112e7b: eb 2d jmp 112eaa <rtems_timer_reset+0x96><== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
}
_Watchdog_Remove( &the_timer->Ticker );
112e7d: 83 ec 0c sub $0xc,%esp
112e80: 8d 43 10 lea 0x10(%ebx),%eax
112e83: 50 push %eax
112e84: e8 63 3b 00 00 call 1169ec <_Watchdog_Remove>
(*_Timer_Server_schedule_operation)( the_timer );
112e89: 89 1c 24 mov %ebx,(%esp)
112e8c: ff 15 b8 4a 13 00 call *0x134ab8
112e92: 83 c4 10 add $0x10,%esp
112e95: eb 0c jmp 112ea3 <rtems_timer_reset+0x8f>
break;
case TIMER_TIME_OF_DAY:
case TIMER_TIME_OF_DAY_ON_TASK:
case TIMER_DORMANT:
_Thread_Enable_dispatch();
112e97: e8 1c 29 00 00 call 1157b8 <_Thread_Enable_dispatch>
112e9c: b8 0b 00 00 00 mov $0xb,%eax
112ea1: eb 07 jmp 112eaa <rtems_timer_reset+0x96>
return RTEMS_NOT_DEFINED;
}
_Thread_Enable_dispatch();
112ea3: e8 10 29 00 00 call 1157b8 <_Thread_Enable_dispatch>
112ea8: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112eaa: 8b 5d fc mov -0x4(%ebp),%ebx
112ead: c9 leave
112eae: c3 ret
00112eb0 <rtems_timer_server_fire_after>:
Objects_Id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
112eb0: 55 push %ebp
112eb1: 89 e5 mov %esp,%ebp
112eb3: 57 push %edi
112eb4: 56 push %esi
112eb5: 53 push %ebx
112eb6: 83 ec 1c sub $0x1c,%esp
112eb9: 8b 7d 08 mov 0x8(%ebp),%edi
112ebc: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( !_Timer_Server )
112ebf: b8 0e 00 00 00 mov $0xe,%eax
112ec4: 83 3d bc 4a 13 00 00 cmpl $0x0,0x134abc
112ecb: 0f 84 91 00 00 00 je 112f62 <rtems_timer_server_fire_after+0xb2>
return RTEMS_INCORRECT_STATE;
if ( !routine )
112ed1: b8 09 00 00 00 mov $0x9,%eax
112ed6: 85 f6 test %esi,%esi
112ed8: 0f 84 84 00 00 00 je 112f62 <rtems_timer_server_fire_after+0xb2><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
112ede: b8 0a 00 00 00 mov $0xa,%eax
112ee3: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
112ee7: 74 79 je 112f62 <rtems_timer_server_fire_after+0xb2>
112ee9: 50 push %eax
112eea: 8d 45 f0 lea -0x10(%ebp),%eax
112eed: 50 push %eax
112eee: 57 push %edi
112eef: 68 78 4a 13 00 push $0x134a78
112ef4: e8 ff 20 00 00 call 114ff8 <_Objects_Get>
112ef9: 89 c3 mov %eax,%ebx
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
112efb: 83 c4 10 add $0x10,%esp
112efe: b8 04 00 00 00 mov $0x4,%eax
112f03: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
112f07: 75 59 jne 112f62 <rtems_timer_server_fire_after+0xb2>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
112f09: 83 ec 0c sub $0xc,%esp
112f0c: 8d 43 10 lea 0x10(%ebx),%eax
112f0f: 50 push %eax
112f10: e8 d7 3a 00 00 call 1169ec <_Watchdog_Remove>
_ISR_Disable( level );
112f15: 9c pushf
112f16: fa cli
112f17: 5a pop %edx
/*
* 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 ) {
112f18: 83 c4 10 add $0x10,%esp
112f1b: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
112f1f: 74 0b je 112f2c <rtems_timer_server_fire_after+0x7c><== ALWAYS TAKEN
_ISR_Enable( level );
112f21: 52 push %edx <== NOT EXECUTED
112f22: 9d popf <== NOT EXECUTED
_Thread_Enable_dispatch();
112f23: e8 90 28 00 00 call 1157b8 <_Thread_Enable_dispatch><== NOT EXECUTED
112f28: 31 c0 xor %eax,%eax <== NOT EXECUTED
112f2a: eb 36 jmp 112f62 <rtems_timer_server_fire_after+0xb2><== NOT EXECUTED
/*
* 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;
112f2c: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx)
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
112f33: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
* @param[in] the_heap is the heap to operate upon
112f3a: 89 73 2c mov %esi,0x2c(%ebx)
* @param[in] starting_address is the starting address of the memory for
112f3d: 89 7b 30 mov %edi,0x30(%ebx)
* the heap
112f40: 8b 45 14 mov 0x14(%ebp),%eax
112f43: 89 43 34 mov %eax,0x34(%ebx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = ticks;
112f46: 8b 45 0c mov 0xc(%ebp),%eax
112f49: 89 43 1c mov %eax,0x1c(%ebx)
_ISR_Enable( level );
112f4c: 52 push %edx
112f4d: 9d popf
/*
* _Timer_Server_schedule_operation != NULL because we checked that
* _Timer_Server was != NULL above. Both are set at the same time.
*/
(*_Timer_Server_schedule_operation)( the_timer );
112f4e: 83 ec 0c sub $0xc,%esp
112f51: 53 push %ebx
112f52: ff 15 b8 4a 13 00 call *0x134ab8
_Thread_Enable_dispatch();
112f58: e8 5b 28 00 00 call 1157b8 <_Thread_Enable_dispatch>
112f5d: 31 c0 xor %eax,%eax
112f5f: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112f62: 8d 65 f4 lea -0xc(%ebp),%esp
112f65: 5b pop %ebx
112f66: 5e pop %esi
112f67: 5f pop %edi
112f68: c9 leave
112f69: c3 ret
00112f6c <rtems_timer_server_fire_when>:
Objects_Id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
112f6c: 55 push %ebp
112f6d: 89 e5 mov %esp,%ebp
112f6f: 57 push %edi
112f70: 56 push %esi
112f71: 53 push %ebx
112f72: 83 ec 1c sub $0x1c,%esp
112f75: 8b 5d 0c mov 0xc(%ebp),%ebx
112f78: 8b 7d 10 mov 0x10(%ebp),%edi
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_Timer_Server )
112f7b: b8 0e 00 00 00 mov $0xe,%eax
112f80: 83 3d bc 4a 13 00 00 cmpl $0x0,0x134abc
112f87: 0f 84 b3 00 00 00 je 113040 <rtems_timer_server_fire_when+0xd4><== NEVER TAKEN
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
112f8d: b8 0b 00 00 00 mov $0xb,%eax
112f92: 80 3d 4c 41 13 00 00 cmpb $0x0,0x13414c
112f99: 0f 84 a1 00 00 00 je 113040 <rtems_timer_server_fire_when+0xd4><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
112f9f: b8 09 00 00 00 mov $0x9,%eax
112fa4: 85 ff test %edi,%edi
112fa6: 0f 84 94 00 00 00 je 113040 <rtems_timer_server_fire_when+0xd4><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
112fac: 83 ec 0c sub $0xc,%esp
112faf: 53 push %ebx
112fb0: e8 bb d7 ff ff call 110770 <_TOD_Validate>
112fb5: 83 c4 10 add $0x10,%esp
112fb8: 84 c0 test %al,%al
112fba: 74 7f je 11303b <rtems_timer_server_fire_when+0xcf><== NEVER TAKEN
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
112fbc: 83 ec 0c sub $0xc,%esp
112fbf: 53 push %ebx
112fc0: e8 43 d7 ff ff call 110708 <_TOD_To_seconds>
112fc5: 89 c6 mov %eax,%esi
if ( seconds <= _TOD_Seconds_since_epoch )
112fc7: 83 c4 10 add $0x10,%esp
112fca: 3b 05 c8 41 13 00 cmp 0x1341c8,%eax
112fd0: 76 69 jbe 11303b <rtems_timer_server_fire_when+0xcf><== NEVER TAKEN
/**
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
112fd2: 50 push %eax
112fd3: 8d 45 f0 lea -0x10(%ebp),%eax
112fd6: 50 push %eax
112fd7: ff 75 08 pushl 0x8(%ebp)
112fda: 68 78 4a 13 00 push $0x134a78
112fdf: e8 14 20 00 00 call 114ff8 <_Objects_Get>
112fe4: 89 c3 mov %eax,%ebx
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
112fe6: 83 c4 10 add $0x10,%esp
112fe9: b8 04 00 00 00 mov $0x4,%eax
112fee: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
112ff2: 75 4c jne 113040 <rtems_timer_server_fire_when+0xd4><== NEVER TAKEN
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
112ff4: 83 ec 0c sub $0xc,%esp
112ff7: 8d 43 10 lea 0x10(%ebx),%eax
112ffa: 50 push %eax
112ffb: e8 ec 39 00 00 call 1169ec <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
113000: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx)
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
113007: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
* @param[in] the_heap is the heap to operate upon
11300e: 89 7b 2c mov %edi,0x2c(%ebx)
* @param[in] starting_address is the starting address of the memory for
113011: 8b 45 08 mov 0x8(%ebp),%eax
113014: 89 43 30 mov %eax,0x30(%ebx)
* the heap
113017: 8b 45 14 mov 0x14(%ebp),%eax
11301a: 89 43 34 mov %eax,0x34(%ebx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch;
11301d: 2b 35 c8 41 13 00 sub 0x1341c8,%esi
113023: 89 73 1c mov %esi,0x1c(%ebx)
/*
* _Timer_Server_schedule_operation != NULL because we checked that
* _Timer_Server was != NULL above. Both are set at the same time.
*/
(*_Timer_Server_schedule_operation)( the_timer );
113026: 89 1c 24 mov %ebx,(%esp)
113029: ff 15 b8 4a 13 00 call *0x134ab8
_Thread_Enable_dispatch();
11302f: e8 84 27 00 00 call 1157b8 <_Thread_Enable_dispatch>
113034: 31 c0 xor %eax,%eax
113036: 83 c4 10 add $0x10,%esp
113039: eb 05 jmp 113040 <rtems_timer_server_fire_when+0xd4>
return RTEMS_SUCCESSFUL;
11303b: b8 14 00 00 00 mov $0x14,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
113040: 8d 65 f4 lea -0xc(%ebp),%esp
113043: 5b pop %ebx
113044: 5e pop %esi
113045: 5f pop %edi
113046: c9 leave
113047: c3 ret
00106ec1 <rtems_verror>:
static int rtems_verror(
uint32_t error_flag,
const char *printf_format,
va_list arglist
)
{
106ec1: 55 push %ebp <== NOT EXECUTED
106ec2: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106ec4: 57 push %edi <== NOT EXECUTED
106ec5: 56 push %esi <== NOT EXECUTED
106ec6: 53 push %ebx <== NOT EXECUTED
106ec7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106eca: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED
106ecd: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED
106ed0: 89 cb mov %ecx,%ebx <== NOT EXECUTED
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC)
106ed2: 25 00 00 00 20 and $0x20000000,%eax <== NOT EXECUTED
106ed7: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED
106eda: 74 2a je 106f06 <rtems_verror+0x45> <== NOT EXECUTED
{
if (rtems_panic_in_progress++)
106edc: 8b 15 30 91 12 00 mov 0x129130,%edx <== NOT EXECUTED
106ee2: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED
106ee5: a3 30 91 12 00 mov %eax,0x129130 <== NOT EXECUTED
106eea: 85 d2 test %edx,%edx <== NOT EXECUTED
106eec: 74 0b je 106ef9 <rtems_verror+0x38> <== NOT EXECUTED
106eee: a1 94 92 12 00 mov 0x129294,%eax <== NOT EXECUTED
106ef3: 40 inc %eax <== NOT EXECUTED
106ef4: a3 94 92 12 00 mov %eax,0x129294 <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
106ef9: 83 3d 30 91 12 00 02 cmpl $0x2,0x129130 <== NOT EXECUTED
106f00: 0f 8f 18 01 00 00 jg 10701e <rtems_verror+0x15d> <== NOT EXECUTED
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
106f06: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106f09: a1 c0 f4 11 00 mov 0x11f4c0,%eax <== NOT EXECUTED
106f0e: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
106f11: e8 b6 99 00 00 call 1108cc <fflush> <== NOT EXECUTED
status = error_flag & ~RTEMS_ERROR_MASK;
106f16: 8b 75 ec mov -0x14(%ebp),%esi <== NOT EXECUTED
106f19: 81 e6 ff ff ff 8f and $0x8fffffff,%esi <== NOT EXECUTED
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
106f1f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106f22: 31 ff xor %edi,%edi <== NOT EXECUTED
106f24: f7 45 ec 00 00 00 40 testl $0x40000000,-0x14(%ebp) <== NOT EXECUTED
106f2b: 74 07 je 106f34 <rtems_verror+0x73> <== NOT EXECUTED
local_errno = errno;
106f2d: e8 ea 96 00 00 call 11061c <__errno> <== NOT EXECUTED
106f32: 8b 38 mov (%eax),%edi <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
106f34: 50 push %eax <== NOT EXECUTED
106f35: 53 push %ebx <== NOT EXECUTED
106f36: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED
106f39: a1 c0 f4 11 00 mov 0x11f4c0,%eax <== NOT EXECUTED
106f3e: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
106f41: e8 6e e3 00 00 call 1152b4 <vfprintf> <== NOT EXECUTED
106f46: 89 c3 mov %eax,%ebx <== NOT EXECUTED
if (status)
106f48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106f4b: 85 f6 test %esi,%esi <== NOT EXECUTED
106f4d: 74 28 je 106f77 <rtems_verror+0xb6> <== NOT EXECUTED
const char *
rtems_status_text(
rtems_status_code status
)
{
return rtems_assoc_name_by_local(rtems_status_assoc, status);
106f4f: 50 push %eax <== NOT EXECUTED
106f50: 50 push %eax <== NOT EXECUTED
106f51: 56 push %esi <== NOT EXECUTED
106f52: 68 18 a5 11 00 push $0x11a518 <== NOT EXECUTED
106f57: e8 2c 73 00 00 call 10e288 <rtems_assoc_name_by_local><== NOT EXECUTED
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status));
106f5c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
106f5f: 50 push %eax <== NOT EXECUTED
106f60: 68 09 a2 11 00 push $0x11a209 <== NOT EXECUTED
106f65: a1 c0 f4 11 00 mov 0x11f4c0,%eax <== NOT EXECUTED
106f6a: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
106f6d: e8 0a 9d 00 00 call 110c7c <fprintf> <== NOT EXECUTED
106f72: 01 c3 add %eax,%ebx <== NOT EXECUTED
106f74: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if (local_errno)
106f77: 83 ff 00 cmp $0x0,%edi <== NOT EXECUTED
106f7a: 74 40 je 106fbc <rtems_verror+0xfb> <== NOT EXECUTED
{
if ((local_errno > 0) && *strerror(local_errno))
106f7c: 7e 25 jle 106fa3 <rtems_verror+0xe2> <== NOT EXECUTED
106f7e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106f81: 57 push %edi <== NOT EXECUTED
106f82: e8 d1 a9 00 00 call 111958 <strerror> <== NOT EXECUTED
106f87: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106f8a: 80 38 00 cmpb $0x0,(%eax) <== NOT EXECUTED
106f8d: 74 14 je 106fa3 <rtems_verror+0xe2> <== NOT EXECUTED
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
106f8f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106f92: 57 push %edi <== NOT EXECUTED
106f93: e8 c0 a9 00 00 call 111958 <strerror> <== NOT EXECUTED
106f98: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
106f9b: 50 push %eax <== NOT EXECUTED
106f9c: 68 17 a2 11 00 push $0x11a217 <== NOT EXECUTED
106fa1: eb 07 jmp 106faa <rtems_verror+0xe9> <== NOT EXECUTED
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
106fa3: 50 push %eax <== NOT EXECUTED
106fa4: 57 push %edi <== NOT EXECUTED
106fa5: 68 24 a2 11 00 push $0x11a224 <== NOT EXECUTED
106faa: a1 c0 f4 11 00 mov 0x11f4c0,%eax <== NOT EXECUTED
106faf: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
106fb2: e8 c5 9c 00 00 call 110c7c <fprintf> <== NOT EXECUTED
106fb7: 01 c3 add %eax,%ebx <== NOT EXECUTED
106fb9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
chars_written += fprintf(stderr, "\n");
106fbc: 56 push %esi <== NOT EXECUTED
106fbd: 56 push %esi <== NOT EXECUTED
106fbe: 68 f5 a9 11 00 push $0x11a9f5 <== NOT EXECUTED
106fc3: a1 c0 f4 11 00 mov 0x11f4c0,%eax <== NOT EXECUTED
106fc8: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
106fcb: e8 ac 9c 00 00 call 110c7c <fprintf> <== NOT EXECUTED
106fd0: 89 c6 mov %eax,%esi <== NOT EXECUTED
(void) fflush(stderr);
106fd2: 59 pop %ecx <== NOT EXECUTED
106fd3: a1 c0 f4 11 00 mov 0x11f4c0,%eax <== NOT EXECUTED
106fd8: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
106fdb: e8 ec 98 00 00 call 1108cc <fflush> <== NOT EXECUTED
if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT))
106fe0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
}
chars_written += fprintf(stderr, "\n");
106fe3: 8d 04 1e lea (%esi,%ebx,1),%eax <== NOT EXECUTED
(void) fflush(stderr);
if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT))
106fe6: f7 45 ec 00 00 00 30 testl $0x30000000,-0x14(%ebp) <== NOT EXECUTED
106fed: 74 31 je 107020 <rtems_verror+0x15f> <== NOT EXECUTED
{
if (error_flag & RTEMS_ERROR_PANIC)
106fef: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED
106ff3: 74 16 je 10700b <rtems_verror+0x14a> <== NOT EXECUTED
{
rtems_error(0, "fatal error, exiting");
106ff5: 52 push %edx <== NOT EXECUTED
106ff6: 52 push %edx <== NOT EXECUTED
106ff7: 68 38 a2 11 00 push $0x11a238 <== NOT EXECUTED
106ffc: 6a 00 push $0x0 <== NOT EXECUTED
106ffe: e8 3d 00 00 00 call 107040 <rtems_error> <== NOT EXECUTED
_exit(local_errno);
107003: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
107006: e8 fb 05 00 00 call 107606 <_exit> <== NOT EXECUTED
}
else
{
rtems_error(0, "fatal error, aborting");
10700b: 50 push %eax <== NOT EXECUTED
10700c: 50 push %eax <== NOT EXECUTED
10700d: 68 4d a2 11 00 push $0x11a24d <== NOT EXECUTED
107012: 6a 00 push $0x0 <== NOT EXECUTED
107014: e8 27 00 00 00 call 107040 <rtems_error> <== NOT EXECUTED
abort();
107019: e8 ca 95 00 00 call 1105e8 <abort> <== NOT EXECUTED
10701e: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
}
return chars_written;
}
107020: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
107023: 5b pop %ebx <== NOT EXECUTED
107024: 5e pop %esi <== NOT EXECUTED
107025: 5f pop %edi <== NOT EXECUTED
107026: c9 leave <== NOT EXECUTED
107027: c3 ret <== NOT EXECUTED
00109d5d <rtems_workspace_allocate>:
*/
bool rtems_workspace_allocate(
uintptr_t bytes,
void **pointer
)
{
109d5d: 55 push %ebp
109d5e: 89 e5 mov %esp,%ebp
109d60: 53 push %ebx
109d61: 83 ec 04 sub $0x4,%esp
109d64: 8b 45 08 mov 0x8(%ebp),%eax
109d67: 8b 5d 0c mov 0xc(%ebp),%ebx
void *ptr;
/*
* check the arguments
*/
if ( !pointer )
109d6a: 85 db test %ebx,%ebx
109d6c: 74 1e je 109d8c <rtems_workspace_allocate+0x2f><== NEVER TAKEN
return false;
if ( !bytes )
109d6e: 85 c0 test %eax,%eax
109d70: 74 1a je 109d8c <rtems_workspace_allocate+0x2f><== NEVER TAKEN
return false;
/*
* Allocate the memory
*/
ptr = _Protected_heap_Allocate( &_Workspace_Area, (intptr_t) bytes );
109d72: 52 push %edx
109d73: 52 push %edx
109d74: 50 push %eax
109d75: 68 c8 19 12 00 push $0x1219c8
109d7a: e8 c5 13 00 00 call 10b144 <_Protected_heap_Allocate>
if (!ptr)
109d7f: 83 c4 10 add $0x10,%esp
109d82: 85 c0 test %eax,%eax
109d84: 74 06 je 109d8c <rtems_workspace_allocate+0x2f><== NEVER TAKEN
return false;
*pointer = ptr;
109d86: 89 03 mov %eax,(%ebx)
109d88: b0 01 mov $0x1,%al
109d8a: eb 02 jmp 109d8e <rtems_workspace_allocate+0x31>
return true;
109d8c: 31 c0 xor %eax,%eax
}
109d8e: 8b 5d fc mov -0x4(%ebp),%ebx
109d91: c9 leave
109d92: c3 ret
00109d48 <rtems_workspace_free>:
* _Workspace_Allocate
*/
bool rtems_workspace_free(
void *pointer
)
{
109d48: 55 push %ebp <== NOT EXECUTED
109d49: 89 e5 mov %esp,%ebp <== NOT EXECUTED
109d4b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
return _Protected_heap_Free( &_Workspace_Area, pointer );
109d4e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
109d51: 68 c8 19 12 00 push $0x1219c8 <== NOT EXECUTED
109d56: e8 1d 14 00 00 call 10b178 <_Protected_heap_Free> <== NOT EXECUTED
}
109d5b: c9 leave <== NOT EXECUTED
109d5c: c3 ret <== NOT EXECUTED
00109d93 <rtems_workspace_get_information>:
#include <string.h> /* for memset */
bool rtems_workspace_get_information(
Heap_Information_block *the_info
)
{
109d93: 55 push %ebp
109d94: 89 e5 mov %esp,%ebp
109d96: 83 ec 08 sub $0x8,%esp
109d99: 8b 55 08 mov 0x8(%ebp),%edx
if ( !the_info )
109d9c: 31 c0 xor %eax,%eax
109d9e: 85 d2 test %edx,%edx
109da0: 74 10 je 109db2 <rtems_workspace_get_information+0x1f><== NEVER TAKEN
return false;
return _Protected_heap_Get_information( &_Workspace_Area, the_info );
109da2: 51 push %ecx
109da3: 51 push %ecx
109da4: 52 push %edx
109da5: 68 c8 19 12 00 push $0x1219c8
109daa: e8 fd 13 00 00 call 10b1ac <_Protected_heap_Get_information>
109daf: 83 c4 10 add $0x10,%esp
}
109db2: c9 leave
109db3: c3 ret
00108e43 <scandir>:
scandir(
const char *dirname,
struct dirent ***namelist,
int (*select)(struct dirent *),
int (*dcomp)(const struct dirent **, const struct dirent **))
{
108e43: 55 push %ebp
108e44: 89 e5 mov %esp,%ebp
108e46: 57 push %edi
108e47: 56 push %esi
108e48: 53 push %ebx
108e49: 83 ec 78 sub $0x78,%esp
struct stat stb;
long arraysz;
DIR *dirp = NULL;
int i;
if ((dirp = opendir(dirname)) == NULL)
108e4c: ff 75 08 pushl 0x8(%ebp)
108e4f: e8 f0 f8 ff ff call 108744 <opendir>
108e54: 89 45 a0 mov %eax,-0x60(%ebp)
108e57: 83 c4 10 add $0x10,%esp
108e5a: 85 c0 test %eax,%eax
108e5c: 0f 84 99 01 00 00 je 108ffb <scandir+0x1b8> <== NEVER TAKEN
return(-1);
if (fstat(dirp->dd_fd, &stb) < 0)
108e62: 51 push %ecx
108e63: 51 push %ecx
108e64: 8d 5d a8 lea -0x58(%ebp),%ebx
108e67: 53 push %ebx
108e68: ff 30 pushl (%eax)
108e6a: e8 15 60 00 00 call 10ee84 <fstat>
108e6f: 83 c4 10 add $0x10,%esp
108e72: 85 c0 test %eax,%eax
108e74: 0f 88 3d 01 00 00 js 108fb7 <scandir+0x174> <== NEVER TAKEN
/*
* estimate the array size by taking the size of the directory file
* and dividing it by a multiple of the minimum size entry.
*/
arraysz = (stb.st_size / 24);
108e7a: 8b 45 c8 mov -0x38(%ebp),%eax
108e7d: b9 18 00 00 00 mov $0x18,%ecx
108e82: 99 cltd
108e83: f7 f9 idiv %ecx
108e85: 89 45 9c mov %eax,-0x64(%ebp)
names = (struct dirent **)malloc(arraysz * sizeof(struct dirent *));
108e88: 83 ec 0c sub $0xc,%esp
108e8b: c1 e0 02 shl $0x2,%eax
108e8e: 50 push %eax
108e8f: e8 f8 f0 ff ff call 107f8c <malloc>
108e94: 89 c6 mov %eax,%esi
if (names == NULL)
108e96: 83 c4 10 add $0x10,%esp
108e99: c7 45 98 00 00 00 00 movl $0x0,-0x68(%ebp)
108ea0: 85 c0 test %eax,%eax
108ea2: 0f 85 c2 00 00 00 jne 108f6a <scandir+0x127>
108ea8: 89 45 98 mov %eax,-0x68(%ebp)
108eab: e9 10 01 00 00 jmp 108fc0 <scandir+0x17d>
goto cleanup_and_bail;
while ((d = readdir(dirp)) != NULL) {
if (select != NULL && !(*select)(d))
108eb0: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
108eb4: 74 12 je 108ec8 <scandir+0x85> <== NEVER TAKEN
108eb6: 83 ec 0c sub $0xc,%esp
108eb9: 53 push %ebx
108eba: ff 55 10 call *0x10(%ebp)
108ebd: 83 c4 10 add $0x10,%esp
108ec0: 85 c0 test %eax,%eax
108ec2: 0f 84 a2 00 00 00 je 108f6a <scandir+0x127>
continue; /* just selected names */
/*
* Make a minimum size copy of the data
*/
p = (struct dirent *)malloc(DIRSIZ(d));
108ec8: 83 ec 0c sub $0xc,%esp
108ecb: 0f b7 43 0a movzwl 0xa(%ebx),%eax
108ecf: 83 c0 04 add $0x4,%eax
108ed2: 83 e0 fc and $0xfffffffc,%eax
108ed5: 83 c0 0c add $0xc,%eax
108ed8: 50 push %eax
108ed9: e8 ae f0 ff ff call 107f8c <malloc>
108ede: 89 c7 mov %eax,%edi
if (p == NULL)
108ee0: 83 c4 10 add $0x10,%esp
108ee3: 85 c0 test %eax,%eax
108ee5: 0f 84 d5 00 00 00 je 108fc0 <scandir+0x17d> <== NEVER TAKEN
goto cleanup_and_bail;
p->d_ino = d->d_ino;
108eeb: 8b 03 mov (%ebx),%eax
108eed: 89 07 mov %eax,(%edi)
p->d_reclen = d->d_reclen;
108eef: 8b 43 08 mov 0x8(%ebx),%eax
108ef2: 66 89 47 08 mov %ax,0x8(%edi)
p->d_namlen = d->d_namlen;
108ef6: 0f b7 43 0a movzwl 0xa(%ebx),%eax
108efa: 66 89 47 0a mov %ax,0xa(%edi)
strncpy(p->d_name, d->d_name, p->d_namlen + 1);
108efe: 52 push %edx
108eff: 40 inc %eax
108f00: 50 push %eax
108f01: 8d 43 0c lea 0xc(%ebx),%eax
108f04: 50 push %eax
108f05: 8d 47 0c lea 0xc(%edi),%eax
108f08: 50 push %eax
108f09: e8 6e a9 00 00 call 11387c <strncpy>
/*
* Check to make sure the array has space left and
* realloc the maximum size.
*/
if (++nitems >= arraysz) {
108f0e: ff 45 98 incl -0x68(%ebp)
108f11: 83 c4 10 add $0x10,%esp
108f14: 8b 45 9c mov -0x64(%ebp),%eax
108f17: 39 45 98 cmp %eax,-0x68(%ebp)
108f1a: 72 40 jb 108f5c <scandir+0x119> <== ALWAYS TAKEN
if (fstat(dirp->dd_fd, &stb) < 0)
108f1c: 51 push %ecx <== NOT EXECUTED
108f1d: 51 push %ecx <== NOT EXECUTED
108f1e: 8d 55 a8 lea -0x58(%ebp),%edx <== NOT EXECUTED
108f21: 52 push %edx <== NOT EXECUTED
108f22: 8b 45 a0 mov -0x60(%ebp),%eax <== NOT EXECUTED
108f25: ff 30 pushl (%eax) <== NOT EXECUTED
108f27: e8 58 5f 00 00 call 10ee84 <fstat> <== NOT EXECUTED
108f2c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108f2f: 85 c0 test %eax,%eax <== NOT EXECUTED
108f31: 0f 88 89 00 00 00 js 108fc0 <scandir+0x17d> <== NOT EXECUTED
goto cleanup_and_bail; /* just might have grown */
arraysz = stb.st_size / 12;
108f37: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED
108f3a: bb 0c 00 00 00 mov $0xc,%ebx <== NOT EXECUTED
108f3f: 89 c8 mov %ecx,%eax <== NOT EXECUTED
108f41: 99 cltd <== NOT EXECUTED
108f42: f7 fb idiv %ebx <== NOT EXECUTED
108f44: 89 45 9c mov %eax,-0x64(%ebp) <== NOT EXECUTED
names = (struct dirent **)realloc((char *)names,
108f47: 52 push %edx <== NOT EXECUTED
108f48: 52 push %edx <== NOT EXECUTED
108f49: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED
108f4c: 50 push %eax <== NOT EXECUTED
108f4d: 56 push %esi <== NOT EXECUTED
108f4e: e8 1d 61 00 00 call 10f070 <realloc> <== NOT EXECUTED
108f53: 89 c6 mov %eax,%esi <== NOT EXECUTED
arraysz * sizeof(struct dirent *));
if (names == NULL)
108f55: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108f58: 85 c0 test %eax,%eax <== NOT EXECUTED
108f5a: 74 64 je 108fc0 <scandir+0x17d> <== NOT EXECUTED
goto cleanup_and_bail;
}
names[nitems-1] = p;
108f5c: b8 01 00 00 00 mov $0x1,%eax
108f61: 2b 45 98 sub -0x68(%ebp),%eax
108f64: 6b c0 fc imul $0xfffffffc,%eax,%eax
108f67: 89 3c 30 mov %edi,(%eax,%esi,1)
arraysz = (stb.st_size / 24);
names = (struct dirent **)malloc(arraysz * sizeof(struct dirent *));
if (names == NULL)
goto cleanup_and_bail;
while ((d = readdir(dirp)) != NULL) {
108f6a: 83 ec 0c sub $0xc,%esp
108f6d: ff 75 a0 pushl -0x60(%ebp)
108f70: e8 1f fd ff ff call 108c94 <readdir>
108f75: 89 c3 mov %eax,%ebx
108f77: 83 c4 10 add $0x10,%esp
108f7a: 85 c0 test %eax,%eax
108f7c: 0f 85 2e ff ff ff jne 108eb0 <scandir+0x6d>
if (names == NULL)
goto cleanup_and_bail;
}
names[nitems-1] = p;
}
closedir(dirp);
108f82: 83 ec 0c sub $0xc,%esp
108f85: ff 75 a0 pushl -0x60(%ebp)
108f88: e8 f7 e6 ff ff call 107684 <closedir>
if (nitems && dcomp != NULL){
108f8d: 83 c4 10 add $0x10,%esp
108f90: 83 7d 98 00 cmpl $0x0,-0x68(%ebp)
108f94: 74 17 je 108fad <scandir+0x16a> <== NEVER TAKEN
108f96: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
108f9a: 74 11 je 108fad <scandir+0x16a>
qsort(names, nitems, sizeof(struct dirent *),
108f9c: ff 75 14 pushl 0x14(%ebp)
108f9f: 6a 04 push $0x4
108fa1: ff 75 98 pushl -0x68(%ebp)
108fa4: 56 push %esi
108fa5: e8 46 9d 00 00 call 112cf0 <qsort>
108faa: 83 c4 10 add $0x10,%esp
(int (*)(const void *, const void *)) dcomp);
}
*namelist = names;
108fad: 8b 45 0c mov 0xc(%ebp),%eax
108fb0: 89 30 mov %esi,(%eax)
return(nitems);
108fb2: 8b 45 98 mov -0x68(%ebp),%eax
108fb5: eb 47 jmp 108ffe <scandir+0x1bb>
108fb7: 31 f6 xor %esi,%esi
108fb9: c7 45 98 00 00 00 00 movl $0x0,-0x68(%ebp) <== NOT EXECUTED
cleanup_and_bail:
if ( dirp )
closedir( dirp );
108fc0: 83 ec 0c sub $0xc,%esp
108fc3: ff 75 a0 pushl -0x60(%ebp)
108fc6: e8 b9 e6 ff ff call 107684 <closedir>
if ( names ) {
108fcb: 83 c4 10 add $0x10,%esp
108fce: 31 db xor %ebx,%ebx
108fd0: 85 f6 test %esi,%esi
108fd2: 74 27 je 108ffb <scandir+0x1b8> <== ALWAYS TAKEN
108fd4: eb 0f jmp 108fe5 <scandir+0x1a2> <== NOT EXECUTED
for (i=0; i < nitems; i++ )
free( names[i] );
108fd6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108fd9: ff 34 9e pushl (%esi,%ebx,4) <== NOT EXECUTED
108fdc: e8 77 ea ff ff call 107a58 <free> <== NOT EXECUTED
if ( dirp )
closedir( dirp );
if ( names ) {
for (i=0; i < nitems; i++ )
108fe1: 43 inc %ebx <== NOT EXECUTED
108fe2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108fe5: 3b 5d 98 cmp -0x68(%ebp),%ebx <== NOT EXECUTED
108fe8: 72 ec jb 108fd6 <scandir+0x193> <== NOT EXECUTED
free( names[i] );
free( names );
108fea: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108fed: 56 push %esi <== NOT EXECUTED
108fee: e8 65 ea ff ff call 107a58 <free> <== NOT EXECUTED
108ff3: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
108ff6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108ff9: eb 03 jmp 108ffe <scandir+0x1bb> <== NOT EXECUTED
108ffb: 83 c8 ff or $0xffffffff,%eax
}
return(-1);
}
108ffe: 8d 65 f4 lea -0xc(%ebp),%esp
109001: 5b pop %ebx
109002: 5e pop %esi
109003: 5f pop %edi
109004: c9 leave
109005: c3 ret
0010a178 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
10a178: 55 push %ebp
10a179: 89 e5 mov %esp,%ebp
10a17b: 56 push %esi
10a17c: 53 push %ebx
10a17d: 8b 5d 08 mov 0x8(%ebp),%ebx
10a180: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
10a183: 85 db test %ebx,%ebx
10a185: 74 16 je 10a19d <sched_rr_get_interval+0x25><== NEVER TAKEN
10a187: e8 54 d1 ff ff call 1072e0 <getpid>
10a18c: 39 c3 cmp %eax,%ebx
10a18e: 74 0d je 10a19d <sched_rr_get_interval+0x25>
rtems_set_errno_and_return_minus_one( ESRCH );
10a190: e8 6b 66 00 00 call 110800 <__errno>
10a195: c7 00 03 00 00 00 movl $0x3,(%eax)
10a19b: eb 0f jmp 10a1ac <sched_rr_get_interval+0x34>
if ( !interval )
10a19d: 85 f6 test %esi,%esi
10a19f: 75 10 jne 10a1b1 <sched_rr_get_interval+0x39>
rtems_set_errno_and_return_minus_one( EINVAL );
10a1a1: e8 5a 66 00 00 call 110800 <__errno>
10a1a6: c7 00 16 00 00 00 movl $0x16,(%eax)
10a1ac: 83 c8 ff or $0xffffffff,%eax
10a1af: eb 13 jmp 10a1c4 <sched_rr_get_interval+0x4c>
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
10a1b1: 50 push %eax
10a1b2: 50 push %eax
10a1b3: 56 push %esi
10a1b4: ff 35 bc 10 12 00 pushl 0x1210bc
10a1ba: e8 45 32 00 00 call 10d404 <_Timespec_From_ticks>
10a1bf: 31 c0 xor %eax,%eax
10a1c1: 83 c4 10 add $0x10,%esp
return 0;
}
10a1c4: 8d 65 f8 lea -0x8(%ebp),%esp
10a1c7: 5b pop %ebx
10a1c8: 5e pop %esi
10a1c9: c9 leave
10a1ca: c3 ret
00109008 <seekdir>:
void seekdir(
DIR *dirp,
long loc
)
{
109008: 55 push %ebp
109009: 89 e5 mov %esp,%ebp
10900b: 53 push %ebx
10900c: 83 ec 04 sub $0x4,%esp
10900f: 8b 5d 08 mov 0x8(%ebp),%ebx
off_t status;
if ( !dirp )
109012: 85 db test %ebx,%ebx
109014: 74 1a je 109030 <seekdir+0x28>
return;
status = lseek( dirp->dd_fd, loc, SEEK_SET );
109016: 50 push %eax
109017: 6a 00 push $0x0
109019: ff 75 0c pushl 0xc(%ebp)
10901c: ff 33 pushl (%ebx)
10901e: e8 b9 ed ff ff call 107ddc <lseek>
/*
* This is not a nice way to error out, but we have no choice here.
*/
if ( status == -1 )
109023: 83 c4 10 add $0x10,%esp
109026: 40 inc %eax
109027: 74 07 je 109030 <seekdir+0x28> <== NEVER TAKEN
return;
dirp->dd_loc = 0;
109029: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
}
109030: 8b 5d fc mov -0x4(%ebp),%ebx
109033: c9 leave
109034: c3 ret
0010b5c4 <sem_destroy>:
*/
int sem_destroy(
sem_t *sem
)
{
10b5c4: 55 push %ebp
10b5c5: 89 e5 mov %esp,%ebp
10b5c7: 83 ec 1c sub $0x1c,%esp
10b5ca: 8d 45 fc lea -0x4(%ebp),%eax
10b5cd: 50 push %eax
10b5ce: 8b 45 08 mov 0x8(%ebp),%eax
10b5d1: ff 30 pushl (%eax)
10b5d3: 68 00 38 12 00 push $0x123800
10b5d8: e8 4b 1f 00 00 call 10d528 <_Objects_Get>
register POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _POSIX_Semaphore_Get( sem, &location );
switch ( location ) {
10b5dd: 83 c4 10 add $0x10,%esp
10b5e0: 83 7d fc 00 cmpl $0x0,-0x4(%ebp)
10b5e4: 75 22 jne 10b608 <sem_destroy+0x44>
case OBJECTS_LOCAL:
/*
* Undefined operation on a named semaphore.
*/
if ( the_semaphore->named == TRUE ) {
10b5e6: 80 78 14 00 cmpb $0x0,0x14(%eax)
10b5ea: 74 07 je 10b5f3 <sem_destroy+0x2f> <== ALWAYS TAKEN
_Thread_Enable_dispatch();
10b5ec: e8 f7 26 00 00 call 10dce8 <_Thread_Enable_dispatch><== NOT EXECUTED
10b5f1: eb 15 jmp 10b608 <sem_destroy+0x44> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
_POSIX_Semaphore_Delete( the_semaphore );
10b5f3: 83 ec 0c sub $0xc,%esp
10b5f6: 50 push %eax
10b5f7: e8 dc 55 00 00 call 110bd8 <_POSIX_Semaphore_Delete>
_Thread_Enable_dispatch();
10b5fc: e8 e7 26 00 00 call 10dce8 <_Thread_Enable_dispatch>
10b601: 31 c0 xor %eax,%eax
10b603: 83 c4 10 add $0x10,%esp
10b606: eb 0e jmp 10b616 <sem_destroy+0x52>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10b608: e8 57 70 00 00 call 112664 <__errno>
10b60d: c7 00 16 00 00 00 movl $0x16,(%eax)
10b613: 83 c8 ff or $0xffffffff,%eax
}
10b616: c9 leave
10b617: c3 ret
0010b65c <sem_init>:
int sem_init(
sem_t *sem,
int pshared,
unsigned int value
)
{
10b65c: 55 push %ebp
10b65d: 89 e5 mov %esp,%ebp
10b65f: 53 push %ebx
10b660: 83 ec 14 sub $0x14,%esp
10b663: 8b 5d 08 mov 0x8(%ebp),%ebx
int status;
POSIX_Semaphore_Control *the_semaphore;
if ( !sem )
10b666: 85 db test %ebx,%ebx
10b668: 75 10 jne 10b67a <sem_init+0x1e> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10b66a: e8 f5 6f 00 00 call 112664 <__errno> <== NOT EXECUTED
10b66f: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
10b675: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED
10b678: eb 23 jmp 10b69d <sem_init+0x41> <== NOT EXECUTED
status = _POSIX_Semaphore_Create_support(
10b67a: 8d 45 f8 lea -0x8(%ebp),%eax
10b67d: 50 push %eax
10b67e: ff 75 10 pushl 0x10(%ebp)
10b681: ff 75 0c pushl 0xc(%ebp)
10b684: 6a 00 push $0x0
10b686: e8 55 54 00 00 call 110ae0 <_POSIX_Semaphore_Create_support>
10b68b: 89 c2 mov %eax,%edx
pshared,
value,
&the_semaphore
);
if ( status != -1 )
10b68d: 83 c4 10 add $0x10,%esp
10b690: 83 f8 ff cmp $0xffffffff,%eax
10b693: 74 08 je 10b69d <sem_init+0x41>
*sem = the_semaphore->Object.id;
10b695: 8b 45 f8 mov -0x8(%ebp),%eax
10b698: 8b 40 08 mov 0x8(%eax),%eax
10b69b: 89 03 mov %eax,(%ebx)
return status;
}
10b69d: 89 d0 mov %edx,%eax
10b69f: 8b 5d fc mov -0x4(%ebp),%ebx
10b6a2: c9 leave
10b6a3: c3 ret
0010b6a4 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
10b6a4: 55 push %ebp
10b6a5: 89 e5 mov %esp,%ebp
10b6a7: 57 push %edi
10b6a8: 56 push %esi
10b6a9: 53 push %ebx
10b6aa: 83 ec 1c sub $0x1c,%esp
10b6ad: 8b 75 0c mov 0xc(%ebp),%esi
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10b6b0: a1 10 35 12 00 mov 0x123510,%eax
10b6b5: 40 inc %eax
10b6b6: a3 10 35 12 00 mov %eax,0x123510
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
10b6bb: 89 f0 mov %esi,%eax
10b6bd: 25 00 02 00 00 and $0x200,%eax
10b6c2: 89 45 e0 mov %eax,-0x20(%ebp)
10b6c5: 75 04 jne 10b6cb <sem_open+0x27>
10b6c7: 31 ff xor %edi,%edi
10b6c9: eb 03 jmp 10b6ce <sem_open+0x2a>
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
10b6cb: 8b 7d 14 mov 0x14(%ebp),%edi
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
10b6ce: 52 push %edx
10b6cf: 52 push %edx
10b6d0: 8d 45 f0 lea -0x10(%ebp),%eax
10b6d3: 50 push %eax
10b6d4: ff 75 08 pushl 0x8(%ebp)
10b6d7: e8 44 55 00 00 call 110c20 <_POSIX_Semaphore_Name_to_id>
10b6dc: 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 ) {
10b6de: 83 c4 10 add $0x10,%esp
10b6e1: 85 c0 test %eax,%eax
10b6e3: 74 19 je 10b6fe <sem_open+0x5a>
/*
* 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) ) ) {
10b6e5: 83 f8 02 cmp $0x2,%eax
10b6e8: 75 06 jne 10b6f0 <sem_open+0x4c> <== NEVER TAKEN
10b6ea: 83 7d e0 00 cmpl $0x0,-0x20(%ebp)
10b6ee: 75 5e jne 10b74e <sem_open+0xaa>
_Thread_Enable_dispatch();
10b6f0: e8 f3 25 00 00 call 10dce8 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
10b6f5: e8 6a 6f 00 00 call 112664 <__errno>
10b6fa: 89 18 mov %ebx,(%eax)
10b6fc: eb 1e jmp 10b71c <sem_open+0x78>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
10b6fe: 81 e6 00 0a 00 00 and $0xa00,%esi
10b704: 81 fe 00 0a 00 00 cmp $0xa00,%esi
10b70a: 75 15 jne 10b721 <sem_open+0x7d>
_Thread_Enable_dispatch();
10b70c: e8 d7 25 00 00 call 10dce8 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
10b711: e8 4e 6f 00 00 call 112664 <__errno>
10b716: c7 00 11 00 00 00 movl $0x11,(%eax)
10b71c: 83 c8 ff or $0xffffffff,%eax
10b71f: eb 52 jmp 10b773 <sem_open+0xcf>
* to add to the heap
* @param[in] size is the size in bytes of the memory area to add
* @return a status indicating success or the reason for failure
*/
bool _Protected_heap_Extend(
Heap_Control *the_heap,
10b721: 50 push %eax
10b722: 8d 45 e8 lea -0x18(%ebp),%eax
10b725: 50 push %eax
10b726: ff 75 f0 pushl -0x10(%ebp)
10b729: 68 00 38 12 00 push $0x123800
10b72e: e8 f5 1d 00 00 call 10d528 <_Objects_Get>
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
10b733: 89 45 ec mov %eax,-0x14(%ebp)
the_semaphore->open_count += 1;
10b736: ff 40 18 incl 0x18(%eax)
_Thread_Enable_dispatch();
10b739: e8 aa 25 00 00 call 10dce8 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
10b73e: e8 a5 25 00 00 call 10dce8 <_Thread_Enable_dispatch>
id = &the_semaphore->Object.id;
return (sem_t *)id;
10b743: 8b 45 ec mov -0x14(%ebp),%eax
10b746: 83 c0 08 add $0x8,%eax
10b749: 83 c4 10 add $0x10,%esp
10b74c: eb 25 jmp 10b773 <sem_open+0xcf>
/*
* 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(
10b74e: 8d 45 ec lea -0x14(%ebp),%eax
10b751: 50 push %eax
10b752: 57 push %edi
10b753: 6a 00 push $0x0
10b755: ff 75 08 pushl 0x8(%ebp)
10b758: e8 83 53 00 00 call 110ae0 <_POSIX_Semaphore_Create_support>
10b75d: 89 c3 mov %eax,%ebx
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
10b75f: e8 84 25 00 00 call 10dce8 <_Thread_Enable_dispatch>
if ( status == -1 )
10b764: 83 c4 10 add $0x10,%esp
10b767: 83 c8 ff or $0xffffffff,%eax
10b76a: 43 inc %ebx
10b76b: 74 06 je 10b773 <sem_open+0xcf> <== NEVER TAKEN
return SEM_FAILED;
id = &the_semaphore->Object.id;
return (sem_t *)id;
10b76d: 8b 45 ec mov -0x14(%ebp),%eax
10b770: 83 c0 08 add $0x8,%eax
}
10b773: 8d 65 f4 lea -0xc(%ebp),%esp
10b776: 5b pop %ebx
10b777: 5e pop %esi
10b778: 5f pop %edi
10b779: c9 leave
10b77a: c3 ret
0010b80c <sem_unlink>:
*/
int sem_unlink(
const char *name
)
{
10b80c: 55 push %ebp
10b80d: 89 e5 mov %esp,%ebp
10b80f: 53 push %ebx
10b810: 83 ec 1c sub $0x1c,%esp
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10b813: a1 10 35 12 00 mov 0x123510,%eax
10b818: 40 inc %eax
10b819: a3 10 35 12 00 mov %eax,0x123510
register POSIX_Semaphore_Control *the_semaphore;
sem_t the_semaphore_id;
_Thread_Disable_dispatch();
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
10b81e: 8d 45 f8 lea -0x8(%ebp),%eax
10b821: 50 push %eax
10b822: ff 75 08 pushl 0x8(%ebp)
10b825: e8 f6 53 00 00 call 110c20 <_POSIX_Semaphore_Name_to_id>
10b82a: 89 c3 mov %eax,%ebx
if ( status != 0 ) {
10b82c: 83 c4 10 add $0x10,%esp
10b82f: 85 c0 test %eax,%eax
10b831: 74 11 je 10b844 <sem_unlink+0x38>
_Thread_Enable_dispatch();
10b833: e8 b0 24 00 00 call 10dce8 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( status );
10b838: e8 27 6e 00 00 call 112664 <__errno>
10b83d: 89 18 mov %ebx,(%eax)
10b83f: 83 c8 ff or $0xffffffff,%eax
10b842: eb 3c jmp 10b880 <sem_unlink+0x74>
}
the_semaphore = (POSIX_Semaphore_Control *) _Objects_Get_local_object(
10b844: 8b 45 f8 mov -0x8(%ebp),%eax
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
);
/**
10b847: 31 db xor %ebx,%ebx
10b849: 66 3b 05 10 38 12 00 cmp 0x123810,%ax
10b850: 77 0b ja 10b85d <sem_unlink+0x51> <== NEVER TAKEN
* This heap routine returns information about the free blocks
* in the specified heap.
10b852: 0f b7 d0 movzwl %ax,%edx
10b855: a1 1c 38 12 00 mov 0x12381c,%eax
10b85a: 8b 1c 90 mov (%eax,%edx,4),%ebx
&_POSIX_Semaphore_Information,
_Objects_Get_index( the_semaphore_id )
);
the_semaphore->linked = FALSE;
10b85d: c6 43 15 00 movb $0x0,0x15(%ebx)
static inline uint32_t _Protected_heap_Initialize(
Heap_Control *the_heap,
void *starting_address,
size_t size,
uint32_t page_size
)
10b861: 50 push %eax
10b862: 50 push %eax
10b863: 53 push %ebx
10b864: 68 00 38 12 00 push $0x123800
10b869: e8 ce 1d 00 00 call 10d63c <_Objects_Namespace_remove>
_POSIX_Semaphore_Namespace_remove( the_semaphore );
_POSIX_Semaphore_Delete( the_semaphore );
10b86e: 89 1c 24 mov %ebx,(%esp)
10b871: e8 62 53 00 00 call 110bd8 <_POSIX_Semaphore_Delete>
_Thread_Enable_dispatch();
10b876: e8 6d 24 00 00 call 10dce8 <_Thread_Enable_dispatch>
10b87b: 31 c0 xor %eax,%eax
10b87d: 83 c4 10 add $0x10,%esp
return 0;
}
10b880: 8b 5d fc mov -0x4(%ebp),%ebx
10b883: c9 leave
10b884: c3 ret
0010966c <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
10966c: 55 push %ebp
10966d: 89 e5 mov %esp,%ebp
10966f: 57 push %edi
109670: 56 push %esi
109671: 53 push %ebx
109672: 83 ec 0c sub $0xc,%esp
109675: 8b 5d 08 mov 0x8(%ebp),%ebx
109678: 8b 7d 10 mov 0x10(%ebp),%edi
ISR_Level level;
if ( oact )
10967b: 85 ff test %edi,%edi
10967d: 74 10 je 10968f <sigaction+0x23>
*oact = _POSIX_signals_Vectors[ sig ];
10967f: 6b c3 0c imul $0xc,%ebx,%eax
109682: 8d b0 9c 06 12 00 lea 0x12069c(%eax),%esi
109688: b9 03 00 00 00 mov $0x3,%ecx
10968d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !sig )
10968f: 85 db test %ebx,%ebx
109691: 74 0d je 1096a0 <sigaction+0x34>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
109693: 8d 4b ff lea -0x1(%ebx),%ecx
109696: 83 f9 1f cmp $0x1f,%ecx
109699: 77 05 ja 1096a0 <sigaction+0x34>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
10969b: 83 fb 09 cmp $0x9,%ebx
10969e: 75 10 jne 1096b0 <sigaction+0x44>
rtems_set_errno_and_return_minus_one( EINVAL );
1096a0: e8 6b 68 00 00 call 10ff10 <__errno>
1096a5: c7 00 16 00 00 00 movl $0x16,(%eax)
1096ab: 83 c8 ff or $0xffffffff,%eax
1096ae: eb 5a jmp 10970a <sigaction+0x9e>
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
1096b0: 31 c0 xor %eax,%eax
1096b2: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
1096b6: 74 52 je 10970a <sigaction+0x9e> <== 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 );
1096b8: 9c pushf
1096b9: fa cli
1096ba: 8f 45 f0 popl -0x10(%ebp)
if ( act->sa_handler == SIG_DFL ) {
1096bd: 8b 45 0c mov 0xc(%ebp),%eax
1096c0: 83 78 08 00 cmpl $0x0,0x8(%eax)
1096c4: 75 18 jne 1096de <sigaction+0x72>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
1096c6: 6b c3 0c imul $0xc,%ebx,%eax
1096c9: 8d b8 9c 06 12 00 lea 0x12069c(%eax),%edi
1096cf: 8d b0 e0 9e 11 00 lea 0x119ee0(%eax),%esi
1096d5: b9 03 00 00 00 mov $0x3,%ecx
1096da: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
1096dc: eb 26 jmp 109704 <sigaction+0x98>
} else {
_POSIX_signals_Clear_process_signals( signo_to_mask(sig) );
1096de: 83 ec 0c sub $0xc,%esp
1096e1: b8 01 00 00 00 mov $0x1,%eax
1096e6: d3 e0 shl %cl,%eax
1096e8: 50 push %eax
1096e9: e8 1a 4e 00 00 call 10e508 <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
1096ee: 6b c3 0c imul $0xc,%ebx,%eax
1096f1: 8d b8 9c 06 12 00 lea 0x12069c(%eax),%edi
1096f7: b9 03 00 00 00 mov $0x3,%ecx
1096fc: 8b 75 0c mov 0xc(%ebp),%esi
1096ff: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
109701: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
109704: ff 75 f0 pushl -0x10(%ebp)
109707: 9d popf
109708: 31 c0 xor %eax,%eax
* + If we are now ignoring a signal that was previously pending,
* we clear the pending signal indicator.
*/
return 0;
}
10970a: 8d 65 f4 lea -0xc(%ebp),%esp
10970d: 5b pop %ebx
10970e: 5e pop %esi
10970f: 5f pop %edi
109710: c9 leave
109711: c3 ret
0010b250 <sigsuspend>:
#include <rtems/seterr.h>
int sigsuspend(
const sigset_t *sigmask
)
{
10b250: 55 push %ebp
10b251: 89 e5 mov %esp,%ebp
10b253: 56 push %esi
10b254: 53 push %ebx
10b255: 83 ec 14 sub $0x14,%esp
int status;
POSIX_API_Control *api;
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
status = sigprocmask( SIG_BLOCK, sigmask, &saved_signals_blocked );
10b258: 8d 5d f4 lea -0xc(%ebp),%ebx
10b25b: 53 push %ebx
10b25c: ff 75 08 pushl 0x8(%ebp)
10b25f: 6a 01 push $0x1
10b261: e8 c6 ff ff ff call 10b22c <sigprocmask>
(void) sigfillset( &all_signals );
10b266: 8d 75 f0 lea -0x10(%ebp),%esi
10b269: 89 34 24 mov %esi,(%esp)
10b26c: e8 13 ff ff ff call 10b184 <sigfillset>
status = sigtimedwait( &all_signals, NULL, NULL );
10b271: 83 c4 0c add $0xc,%esp
10b274: 6a 00 push $0x0
10b276: 6a 00 push $0x0
10b278: 56 push %esi
10b279: e8 6b 00 00 00 call 10b2e9 <sigtimedwait>
10b27e: 89 c6 mov %eax,%esi
(void) sigprocmask( SIG_SETMASK, &saved_signals_blocked, NULL );
10b280: 83 c4 0c add $0xc,%esp
10b283: 6a 00 push $0x0
10b285: 53 push %ebx
10b286: 6a 00 push $0x0
10b288: e8 9f ff ff ff call 10b22c <sigprocmask>
/*
* sigtimedwait() returns the signal number while sigsuspend()
* is supposed to return -1 and EINTR when a signal is caught.
*/
if ( status != -1 )
10b28d: 83 c4 10 add $0x10,%esp
10b290: 46 inc %esi
10b291: 74 0b je 10b29e <sigsuspend+0x4e> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINTR );
10b293: e8 78 6b 00 00 call 111e10 <__errno>
10b298: c7 00 04 00 00 00 movl $0x4,(%eax)
return status;
}
10b29e: 83 c8 ff or $0xffffffff,%eax
10b2a1: 8d 65 f8 lea -0x8(%ebp),%esp
10b2a4: 5b pop %ebx
10b2a5: 5e pop %esi
10b2a6: c9 leave
10b2a7: c3 ret
00109a39 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
109a39: 55 push %ebp
109a3a: 89 e5 mov %esp,%ebp
109a3c: 57 push %edi
109a3d: 56 push %esi
109a3e: 53 push %ebx
109a3f: 83 ec 1c sub $0x1c,%esp
109a42: 8b 5d 10 mov 0x10(%ebp),%ebx
* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
109a45: 85 db test %ebx,%ebx
109a47: 74 35 je 109a7e <sigtimedwait+0x45>
if ( !_Timespec_Is_valid( timeout ) )
109a49: 83 ec 0c sub $0xc,%esp
109a4c: 53 push %ebx
109a4d: e8 92 31 00 00 call 10cbe4 <_Timespec_Is_valid>
109a52: 83 c4 10 add $0x10,%esp
109a55: 84 c0 test %al,%al
109a57: 74 12 je 109a6b <sigtimedwait+0x32>
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
109a59: 83 ec 0c sub $0xc,%esp
109a5c: 53 push %ebx
109a5d: e8 de 31 00 00 call 10cc40 <_Timespec_To_ticks>
109a62: 89 c3 mov %eax,%ebx
if ( !interval )
109a64: 83 c4 10 add $0x10,%esp
109a67: 85 c0 test %eax,%eax
109a69: 75 15 jne 109a80 <sigtimedwait+0x47> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
109a6b: e8 10 6a 00 00 call 110480 <__errno>
109a70: c7 00 16 00 00 00 movl $0x16,(%eax)
109a76: 83 cb ff or $0xffffffff,%ebx
109a79: e9 05 01 00 00 jmp 109b83 <sigtimedwait+0x14a>
109a7e: 31 db xor %ebx,%ebx
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
109a80: 8b 75 0c mov 0xc(%ebp),%esi
109a83: 85 f6 test %esi,%esi
109a85: 75 03 jne 109a8a <sigtimedwait+0x51>
109a87: 8d 75 e8 lea -0x18(%ebp),%esi
the_thread = _Thread_Executing;
109a8a: 8b 15 f8 07 12 00 mov 0x1207f8,%edx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
109a90: 8b ba f8 00 00 00 mov 0xf8(%edx),%edi
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
109a96: 9c pushf
109a97: fa cli
109a98: 8f 45 e0 popl -0x20(%ebp)
if ( *set & api->signals_pending ) {
109a9b: 8b 45 08 mov 0x8(%ebp),%eax
109a9e: 8b 08 mov (%eax),%ecx
109aa0: 8b 87 c8 00 00 00 mov 0xc8(%edi),%eax
109aa6: 85 c1 test %eax,%ecx
109aa8: 74 2c je 109ad6 <sigtimedwait+0x9d>
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_highest( api->signals_pending );
109aaa: 50 push %eax
109aab: e8 48 ff ff ff call 1099f8 <_POSIX_signals_Get_highest>
109ab0: 89 06 mov %eax,(%esi)
_POSIX_signals_Clear_signals(
109ab2: 51 push %ecx
109ab3: 51 push %ecx
109ab4: 6a 00 push $0x0
109ab6: 6a 00 push $0x0
109ab8: 56 push %esi
109ab9: 50 push %eax
109aba: 57 push %edi
109abb: e8 38 50 00 00 call 10eaf8 <_POSIX_signals_Clear_signals>
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
109ac0: ff 75 e0 pushl -0x20(%ebp)
109ac3: 9d popf
the_info->si_code = SI_USER;
109ac4: c7 46 04 01 00 00 00 movl $0x1,0x4(%esi)
the_info->si_value.sival_int = 0;
109acb: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi)
return the_info->si_signo;
109ad2: 8b 1e mov (%esi),%ebx
109ad4: eb 33 jmp 109b09 <sigtimedwait+0xd0>
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
109ad6: a1 a8 0e 12 00 mov 0x120ea8,%eax
109adb: 85 c1 test %eax,%ecx
109add: 74 2f je 109b0e <sigtimedwait+0xd5>
signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending );
109adf: 50 push %eax
109ae0: e8 13 ff ff ff call 1099f8 <_POSIX_signals_Get_highest>
109ae5: 89 c3 mov %eax,%ebx
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
109ae7: 52 push %edx
109ae8: 52 push %edx
109ae9: 6a 00 push $0x0
109aeb: 6a 01 push $0x1
109aed: 56 push %esi
109aee: 50 push %eax
109aef: 57 push %edi
109af0: e8 03 50 00 00 call 10eaf8 <_POSIX_signals_Clear_signals>
_ISR_Enable( level );
109af5: ff 75 e0 pushl -0x20(%ebp)
109af8: 9d popf
the_info->si_signo = signo;
109af9: 89 1e mov %ebx,(%esi)
the_info->si_code = SI_USER;
109afb: c7 46 04 01 00 00 00 movl $0x1,0x4(%esi)
the_info->si_value.sival_int = 0;
109b02: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi)
109b09: 83 c4 20 add $0x20,%esp
109b0c: eb 75 jmp 109b83 <sigtimedwait+0x14a>
return signo;
}
the_info->si_signo = -1;
109b0e: c7 06 ff ff ff ff movl $0xffffffff,(%esi)
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
109b14: a1 38 07 12 00 mov 0x120738,%eax
109b19: 40 inc %eax
109b1a: a3 38 07 12 00 mov %eax,0x120738
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
109b1f: c7 42 44 68 0e 12 00 movl $0x120e68,0x44(%edx)
the_thread->Wait.return_code = EINTR;
109b26: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx)
the_thread->Wait.option = *set;
109b2d: 8b 4d 08 mov 0x8(%ebp),%ecx
109b30: 8b 01 mov (%ecx),%eax
109b32: 89 42 30 mov %eax,0x30(%edx)
the_thread->Wait.return_argument = the_info;
109b35: 89 72 28 mov %esi,0x28(%edx)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
* This routine grows @a the_heap memory area using the size bytes which
109b38: c7 05 98 0e 12 00 01 movl $0x1,0x120e98
109b3f: 00 00 00
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
109b42: ff 75 e0 pushl -0x20(%ebp)
109b45: 9d popf
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
109b46: 50 push %eax
109b47: 68 e0 c7 10 00 push $0x10c7e0
109b4c: 53 push %ebx
109b4d: 68 68 0e 12 00 push $0x120e68
109b52: e8 85 29 00 00 call 10c4dc <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
109b57: e8 30 25 00 00 call 10c08c <_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 );
109b5c: c7 04 24 00 00 00 00 movl $0x0,(%esp)
109b63: 6a 00 push $0x0
109b65: 56 push %esi
109b66: ff 36 pushl (%esi)
109b68: 57 push %edi
109b69: e8 8a 4f 00 00 call 10eaf8 <_POSIX_signals_Clear_signals>
errno = _Thread_Executing->Wait.return_code;
109b6e: 83 c4 20 add $0x20,%esp
109b71: e8 0a 69 00 00 call 110480 <__errno>
109b76: 8b 15 f8 07 12 00 mov 0x1207f8,%edx
109b7c: 8b 52 34 mov 0x34(%edx),%edx
109b7f: 89 10 mov %edx,(%eax)
return the_info->si_signo;
109b81: 8b 1e mov (%esi),%ebx
}
109b83: 89 d8 mov %ebx,%eax
109b85: 8d 65 f4 lea -0xc(%ebp),%esp
109b88: 5b pop %ebx
109b89: 5e pop %esi
109b8a: 5f pop %edi
109b8b: c9 leave
109b8c: c3 ret
0010b458 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
10b458: 55 push %ebp
10b459: 89 e5 mov %esp,%ebp
10b45b: 53 push %ebx
10b45c: 83 ec 08 sub $0x8,%esp
10b45f: 8b 5d 0c mov 0xc(%ebp),%ebx
int status;
status = sigtimedwait( set, NULL, NULL );
10b462: 6a 00 push $0x0
10b464: 6a 00 push $0x0
10b466: ff 75 08 pushl 0x8(%ebp)
10b469: e8 7b fe ff ff call 10b2e9 <sigtimedwait>
10b46e: 89 c2 mov %eax,%edx
if ( status != -1 ) {
10b470: 83 c4 10 add $0x10,%esp
10b473: 83 f8 ff cmp $0xffffffff,%eax
10b476: 74 0c je 10b484 <sigwait+0x2c> <== NEVER TAKEN
if ( sig )
10b478: 31 c0 xor %eax,%eax
10b47a: 85 db test %ebx,%ebx
10b47c: 74 0d je 10b48b <sigwait+0x33> <== NEVER TAKEN
*sig = status;
10b47e: 89 13 mov %edx,(%ebx)
10b480: 31 c0 xor %eax,%eax
10b482: eb 07 jmp 10b48b <sigwait+0x33>
return 0;
}
return errno;
10b484: e8 87 69 00 00 call 111e10 <__errno> <== NOT EXECUTED
10b489: 8b 00 mov (%eax),%eax <== NOT EXECUTED
}
10b48b: 8b 5d fc mov -0x4(%ebp),%ebx
10b48e: c9 leave
10b48f: c3 ret
00107b8b <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
107b8b: 55 push %ebp <== NOT EXECUTED
107b8c: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107b8e: 56 push %esi <== NOT EXECUTED
107b8f: 53 push %ebx <== NOT EXECUTED
107b90: 89 d6 mov %edx,%esi <== NOT EXECUTED
107b92: 88 c3 mov %al,%bl <== NOT EXECUTED
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
107b94: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx) <== NOT EXECUTED
107b9b: 74 2e je 107bcb <siproc+0x40> <== NOT EXECUTED
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
107b9d: 51 push %ecx <== NOT EXECUTED
107b9e: 6a 00 push $0x0 <== NOT EXECUTED
107ba0: 6a 00 push $0x0 <== NOT EXECUTED
107ba2: ff 72 18 pushl 0x18(%edx) <== NOT EXECUTED
107ba5: e8 ca 15 00 00 call 109174 <rtems_semaphore_obtain><== NOT EXECUTED
i = iproc (c, tty);
107baa: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED
107bad: 89 f2 mov %esi,%edx <== NOT EXECUTED
107baf: e8 c8 fe ff ff call 107a7c <iproc> <== NOT EXECUTED
107bb4: 89 c3 mov %eax,%ebx <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
107bb6: 5a pop %edx <== NOT EXECUTED
107bb7: ff 76 18 pushl 0x18(%esi) <== NOT EXECUTED
107bba: e8 9d 16 00 00 call 10925c <rtems_semaphore_release><== NOT EXECUTED
107bbf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
else {
i = iproc (c, tty);
}
return i;
}
107bc2: 89 d8 mov %ebx,%eax <== NOT EXECUTED
107bc4: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
107bc7: 5b pop %ebx <== NOT EXECUTED
107bc8: 5e pop %esi <== NOT EXECUTED
107bc9: c9 leave <== NOT EXECUTED
107bca: c3 ret <== 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);
107bcb: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
}
return i;
}
107bce: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
107bd1: 5b pop %ebx <== NOT EXECUTED
107bd2: 5e pop %esi <== NOT EXECUTED
107bd3: 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);
107bd4: e9 a3 fe ff ff jmp 107a7c <iproc> <== NOT EXECUTED
00108380 <stat>:
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
108380: 55 push %ebp
108381: 89 e5 mov %esp,%ebp
108383: 57 push %edi
108384: 56 push %esi
108385: 53 push %ebx
108386: 83 ec 1c sub $0x1c,%esp
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
108389: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10838d: 75 0d jne 10839c <stat+0x1c>
rtems_set_errno_and_return_minus_one( EFAULT );
10838f: e8 4c 8c 00 00 call 110fe0 <__errno>
108394: c7 00 0e 00 00 00 movl $0xe,(%eax)
10839a: eb 45 jmp 1083e1 <stat+0x61>
status = rtems_filesystem_evaluate_path( path, 0, &loc, _STAT_FOLLOW_LINKS );
10839c: 6a 01 push $0x1
10839e: 8d 75 e4 lea -0x1c(%ebp),%esi
1083a1: 56 push %esi
1083a2: 6a 00 push $0x0
1083a4: ff 75 08 pushl 0x8(%ebp)
1083a7: e8 e2 eb ff ff call 106f8e <rtems_filesystem_evaluate_path>
if ( status != 0 )
1083ac: 83 c4 10 add $0x10,%esp
1083af: 83 cb ff or $0xffffffff,%ebx
1083b2: 85 c0 test %eax,%eax
1083b4: 75 5f jne 108415 <stat+0x95>
return -1;
if ( !loc.handlers->fstat_h ){
1083b6: 8b 55 e8 mov -0x18(%ebp),%edx
1083b9: 83 7a 18 00 cmpl $0x0,0x18(%edx)
1083bd: 75 27 jne 1083e6 <stat+0x66> <== ALWAYS TAKEN
rtems_filesystem_freenode( &loc );
1083bf: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
1083c2: 85 c0 test %eax,%eax <== NOT EXECUTED
1083c4: 74 10 je 1083d6 <stat+0x56> <== NOT EXECUTED
1083c6: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
1083c9: 85 c0 test %eax,%eax <== NOT EXECUTED
1083cb: 74 09 je 1083d6 <stat+0x56> <== NOT EXECUTED
1083cd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1083d0: 56 push %esi <== NOT EXECUTED
1083d1: ff d0 call *%eax <== NOT EXECUTED
1083d3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
1083d6: e8 05 8c 00 00 call 110fe0 <__errno> <== NOT EXECUTED
1083db: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
1083e1: 83 cb ff or $0xffffffff,%ebx
1083e4: eb 2f jmp 108415 <stat+0x95>
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
1083e6: b9 13 00 00 00 mov $0x13,%ecx
1083eb: 8b 7d 0c mov 0xc(%ebp),%edi
1083ee: f3 ab rep stos %eax,%es:(%edi)
status = (*loc.handlers->fstat_h)( &loc, buf );
1083f0: 50 push %eax
1083f1: 50 push %eax
1083f2: ff 75 0c pushl 0xc(%ebp)
1083f5: 56 push %esi
1083f6: ff 52 18 call *0x18(%edx)
1083f9: 89 c3 mov %eax,%ebx
rtems_filesystem_freenode( &loc );
1083fb: 8b 45 ec mov -0x14(%ebp),%eax
1083fe: 83 c4 10 add $0x10,%esp
108401: 85 c0 test %eax,%eax
108403: 74 10 je 108415 <stat+0x95> <== NEVER TAKEN
108405: 8b 40 1c mov 0x1c(%eax),%eax
108408: 85 c0 test %eax,%eax
10840a: 74 09 je 108415 <stat+0x95> <== NEVER TAKEN
10840c: 83 ec 0c sub $0xc,%esp
10840f: 56 push %esi
108410: ff d0 call *%eax
108412: 83 c4 10 add $0x10,%esp
return status;
}
108415: 89 d8 mov %ebx,%eax
108417: 8d 65 f4 lea -0xc(%ebp),%esp
10841a: 5b pop %ebx
10841b: 5e pop %esi
10841c: 5f pop %edi
10841d: c9 leave
10841e: c3 ret
00108a54 <symlink>:
int symlink(
const char *actualpath,
const char *sympath
)
{
108a54: 55 push %ebp
108a55: 89 e5 mov %esp,%ebp
108a57: 57 push %edi
108a58: 56 push %esi
108a59: 53 push %ebx
108a5a: 83 ec 2c sub $0x2c,%esp
108a5d: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_filesystem_location_info_t loc;
int i;
const char *name_start;
int result;
rtems_filesystem_get_start_loc( sympath, &i, &loc );
108a60: 8a 03 mov (%ebx),%al
108a62: 3c 2f cmp $0x2f,%al
108a64: 74 08 je 108a6e <symlink+0x1a>
108a66: 3c 5c cmp $0x5c,%al
108a68: 74 04 je 108a6e <symlink+0x1a> <== NEVER TAKEN
108a6a: 84 c0 test %al,%al
108a6c: 75 19 jne 108a87 <symlink+0x33> <== ALWAYS TAKEN
108a6e: 8d 7d e0 lea -0x20(%ebp),%edi
108a71: a1 4c 09 12 00 mov 0x12094c,%eax
108a76: 8d 70 14 lea 0x14(%eax),%esi
108a79: b9 04 00 00 00 mov $0x4,%ecx
108a7e: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
108a80: ba 01 00 00 00 mov $0x1,%edx
108a85: eb 14 jmp 108a9b <symlink+0x47>
108a87: 8d 7d e0 lea -0x20(%ebp),%edi
108a8a: a1 4c 09 12 00 mov 0x12094c,%eax
108a8f: 8d 70 04 lea 0x4(%eax),%esi
108a92: b9 04 00 00 00 mov $0x4,%ecx
108a97: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
108a99: 31 d2 xor %edx,%edx
result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start );
108a9b: 51 push %ecx
108a9c: 8d 45 f0 lea -0x10(%ebp),%eax
108a9f: 50 push %eax
108aa0: 8d 7d e0 lea -0x20(%ebp),%edi
108aa3: 57 push %edi
108aa4: 8d 04 13 lea (%ebx,%edx,1),%eax
108aa7: 50 push %eax
108aa8: 8b 45 e8 mov -0x18(%ebp),%eax
108aab: ff 50 04 call *0x4(%eax)
if ( result != 0 )
108aae: 83 c4 10 add $0x10,%esp
108ab1: 83 ce ff or $0xffffffff,%esi
108ab4: 85 c0 test %eax,%eax
108ab6: 75 50 jne 108b08 <symlink+0xb4>
return -1;
if ( !loc.ops->symlink_h ) {
108ab8: 8b 45 e8 mov -0x18(%ebp),%eax
108abb: 8b 50 38 mov 0x38(%eax),%edx
108abe: 85 d2 test %edx,%edx
108ac0: 75 20 jne 108ae2 <symlink+0x8e> <== ALWAYS TAKEN
rtems_filesystem_freenode( &loc );
108ac2: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
108ac5: 85 c0 test %eax,%eax <== NOT EXECUTED
108ac7: 74 09 je 108ad2 <symlink+0x7e> <== NOT EXECUTED
108ac9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108acc: 57 push %edi <== NOT EXECUTED
108acd: ff d0 call *%eax <== NOT EXECUTED
108acf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
108ad2: e8 d9 8a 00 00 call 1115b0 <__errno> <== NOT EXECUTED
108ad7: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
108add: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED
108ae0: eb 26 jmp 108b08 <symlink+0xb4> <== NOT EXECUTED
}
result = (*loc.ops->symlink_h)( &loc, actualpath, name_start);
108ae2: 50 push %eax
108ae3: ff 75 f0 pushl -0x10(%ebp)
108ae6: ff 75 08 pushl 0x8(%ebp)
108ae9: 57 push %edi
108aea: ff d2 call *%edx
108aec: 89 c6 mov %eax,%esi
rtems_filesystem_freenode( &loc );
108aee: 8b 45 e8 mov -0x18(%ebp),%eax
108af1: 83 c4 10 add $0x10,%esp
108af4: 85 c0 test %eax,%eax
108af6: 74 10 je 108b08 <symlink+0xb4> <== NEVER TAKEN
108af8: 8b 40 1c mov 0x1c(%eax),%eax
108afb: 85 c0 test %eax,%eax
108afd: 74 09 je 108b08 <symlink+0xb4> <== NEVER TAKEN
108aff: 83 ec 0c sub $0xc,%esp
108b02: 57 push %edi
108b03: ff d0 call *%eax
108b05: 83 c4 10 add $0x10,%esp
return result;
}
108b08: 89 f0 mov %esi,%eax
108b0a: 8d 65 f4 lea -0xc(%ebp),%esp
108b0d: 5b pop %ebx
108b0e: 5e pop %esi
108b0f: 5f pop %edi
108b10: c9 leave
108b11: c3 ret
00108434 <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
108434: 55 push %ebp
108435: 89 e5 mov %esp,%ebp
108437: 53 push %ebx
108438: 83 ec 04 sub $0x4,%esp
10843b: 8b 4d 08 mov 0x8(%ebp),%ecx
/*
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
10843e: 8b 91 f0 00 00 00 mov 0xf0(%ecx),%edx
if ( this_reent ) {
108444: 85 d2 test %edx,%edx
108446: 74 31 je 108479 <sync_per_thread+0x45> <== NEVER TAKEN
current_reent = _Thread_Executing->libc_reent;
108448: a1 88 15 12 00 mov 0x121588,%eax
10844d: 8b 98 f0 00 00 00 mov 0xf0(%eax),%ebx
_Thread_Executing->libc_reent = this_reent;
108453: 89 90 f0 00 00 00 mov %edx,0xf0(%eax)
_fwalk (t->libc_reent, sync_wrapper);
108459: 50 push %eax
10845a: 50 push %eax
10845b: 68 a4 84 10 00 push $0x1084a4
108460: ff b1 f0 00 00 00 pushl 0xf0(%ecx)
108466: e8 dd 97 00 00 call 111c48 <_fwalk>
_Thread_Executing->libc_reent = current_reent;
10846b: a1 88 15 12 00 mov 0x121588,%eax
108470: 89 98 f0 00 00 00 mov %ebx,0xf0(%eax)
108476: 83 c4 10 add $0x10,%esp
}
}
108479: 8b 5d fc mov -0x4(%ebp),%ebx
10847c: c9 leave
10847d: c3 ret
001090ec <telldir>:
#include <rtems/seterr.h>
long telldir(
DIR *dirp
)
{
1090ec: 55 push %ebp
1090ed: 89 e5 mov %esp,%ebp
1090ef: 83 ec 08 sub $0x8,%esp
1090f2: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_t *iop;
if ( !dirp )
1090f5: 85 c0 test %eax,%eax
1090f7: 75 10 jne 109109 <telldir+0x1d> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EBADF );
1090f9: e8 e2 8c 00 00 call 111de0 <__errno> <== NOT EXECUTED
1090fe: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
109104: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
109107: eb 2e jmp 109137 <telldir+0x4b> <== NOT EXECUTED
/*
* Get the file control block structure associated with the
* file descriptor
*/
iop = rtems_libio_iop( dirp->dd_fd );
109109: 8b 00 mov (%eax),%eax
10910b: 3b 05 18 e2 11 00 cmp 0x11e218,%eax
109111: 73 0b jae 10911e <telldir+0x32> <== NEVER TAKEN
109113: 6b c0 34 imul $0x34,%eax,%eax
if (iop == NULL)
109116: 03 05 18 26 12 00 add 0x122618,%eax
10911c: 75 16 jne 109134 <telldir+0x48> <== ALWAYS TAKEN
assert(0);
10911e: 68 a7 b6 11 00 push $0x11b6a7 <== NOT EXECUTED
109123: 68 a8 be 11 00 push $0x11bea8 <== NOT EXECUTED
109128: 6a 2c push $0x2c <== NOT EXECUTED
10912a: 68 5b be 11 00 push $0x11be5b <== NOT EXECUTED
10912f: e8 00 e4 ff ff call 107534 <__assert_func> <== NOT EXECUTED
return (long)( iop->offset );
109134: 8b 40 08 mov 0x8(%eax),%eax
}
109137: c9 leave
109138: c3 ret
00107078 <termios_baud_to_number>:
#include <sys/termios.h>
int termios_baud_to_number(
int termios_baud
)
{
107078: 55 push %ebp <== NOT EXECUTED
107079: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10707b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
case B110: baud = 110; break;
case B134: baud = 135; break;
case B150: baud = 150; break;
case B200: baud = 200; break;
case B300: baud = 300; break;
case B600: baud = 600; break;
10707e: b8 b0 04 00 00 mov $0x4b0,%eax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107083: 83 fa 09 cmp $0x9,%edx <== NOT EXECUTED
107086: 0f 84 d6 00 00 00 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
10708c: 7f 65 jg 1070f3 <termios_baud_to_number+0x7b><== NOT EXECUTED
case B0: baud = 0; break;
case B50: baud = 50; break;
case B75: baud = 75; break;
case B110: baud = 110; break;
10708e: 66 b8 87 00 mov $0x87,%ax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107092: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED
107095: 0f 84 c7 00 00 00 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
10709b: 7f 2e jg 1070cb <termios_baud_to_number+0x53><== NOT EXECUTED
10709d: b0 32 mov $0x32,%al <== NOT EXECUTED
10709f: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED
1070a2: 0f 84 ba 00 00 00 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
1070a8: 7f 09 jg 1070b3 <termios_baud_to_number+0x3b><== NOT EXECUTED
1070aa: 30 c0 xor %al,%al <== NOT EXECUTED
1070ac: 85 d2 test %edx,%edx <== NOT EXECUTED
1070ae: e9 aa 00 00 00 jmp 10715d <termios_baud_to_number+0xe5><== NOT EXECUTED
1070b3: b8 4b 00 00 00 mov $0x4b,%eax <== NOT EXECUTED
1070b8: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED
1070bb: 0f 84 a1 00 00 00 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B0: baud = 0; break;
case B50: baud = 50; break;
case B75: baud = 75; break;
1070c1: b0 6e mov $0x6e,%al <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
1070c3: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED
1070c6: e9 92 00 00 00 jmp 10715d <termios_baud_to_number+0xe5><== NOT EXECUTED
case B0: baud = 0; break;
case B50: baud = 50; break;
case B75: baud = 75; break;
case B110: baud = 110; break;
case B134: baud = 135; break;
case B150: baud = 150; break;
1070cb: b8 c8 00 00 00 mov $0xc8,%eax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
1070d0: 83 fa 06 cmp $0x6,%edx <== NOT EXECUTED
1070d3: 0f 84 89 00 00 00 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B0: baud = 0; break;
case B50: baud = 50; break;
case B75: baud = 75; break;
case B110: baud = 110; break;
case B134: baud = 135; break;
1070d9: b0 96 mov $0x96,%al <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
1070db: 0f 8c 81 00 00 00 jl 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B50: baud = 50; break;
case B75: baud = 75; break;
case B110: baud = 110; break;
case B134: baud = 135; break;
case B150: baud = 150; break;
case B200: baud = 200; break;
1070e1: 66 b8 2c 01 mov $0x12c,%ax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
1070e5: 83 fa 07 cmp $0x7,%edx <== NOT EXECUTED
1070e8: 74 78 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B75: baud = 75; break;
case B110: baud = 110; break;
case B134: baud = 135; break;
case B150: baud = 150; break;
case B200: baud = 200; break;
case B300: baud = 300; break;
1070ea: 66 b8 58 02 mov $0x258,%ax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
1070ee: 83 fa 08 cmp $0x8,%edx <== NOT EXECUTED
1070f1: eb 6a jmp 10715d <termios_baud_to_number+0xe5><== NOT EXECUTED
case B600: baud = 600; break;
case B1200: baud = 1200; break;
case B1800: baud = 1800; break;
case B2400: baud = 2400; break;
case B4800: baud = 4800; break;
case B9600: baud = 9600; break;
1070f3: b8 00 4b 00 00 mov $0x4b00,%eax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
1070f8: 83 fa 0e cmp $0xe,%edx <== NOT EXECUTED
1070fb: 74 65 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
1070fd: 7f 21 jg 107120 <termios_baud_to_number+0xa8><== NOT EXECUTED
case B150: baud = 150; break;
case B200: baud = 200; break;
case B300: baud = 300; break;
case B600: baud = 600; break;
case B1200: baud = 1200; break;
case B1800: baud = 1800; break;
1070ff: 66 b8 60 09 mov $0x960,%ax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107103: 83 fa 0b cmp $0xb,%edx <== NOT EXECUTED
107106: 74 5a je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B134: baud = 135; break;
case B150: baud = 150; break;
case B200: baud = 200; break;
case B300: baud = 300; break;
case B600: baud = 600; break;
case B1200: baud = 1200; break;
107108: 66 b8 08 07 mov $0x708,%ax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
10710c: 7c 54 jl 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B200: baud = 200; break;
case B300: baud = 300; break;
case B600: baud = 600; break;
case B1200: baud = 1200; break;
case B1800: baud = 1800; break;
case B2400: baud = 2400; break;
10710e: 66 b8 c0 12 mov $0x12c0,%ax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107112: 83 fa 0c cmp $0xc,%edx <== NOT EXECUTED
107115: 74 4b je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B300: baud = 300; break;
case B600: baud = 600; break;
case B1200: baud = 1200; break;
case B1800: baud = 1800; break;
case B2400: baud = 2400; break;
case B4800: baud = 4800; break;
107117: 66 b8 80 25 mov $0x2580,%ax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
10711b: 83 fa 0d cmp $0xd,%edx <== NOT EXECUTED
10711e: eb 3d jmp 10715d <termios_baud_to_number+0xe5><== NOT EXECUTED
case B2400: baud = 2400; break;
case B4800: baud = 4800; break;
case B9600: baud = 9600; break;
case B19200: baud = 19200; break;
case B38400: baud = 38400; break;
case B57600: baud = 57600; break;
107120: b8 00 c2 01 00 mov $0x1c200,%eax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107125: 81 fa 02 10 00 00 cmp $0x1002,%edx <== NOT EXECUTED
10712b: 74 35 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
10712d: 7f 16 jg 107145 <termios_baud_to_number+0xcd><== NOT EXECUTED
case B1200: baud = 1200; break;
case B1800: baud = 1800; break;
case B2400: baud = 2400; break;
case B4800: baud = 4800; break;
case B9600: baud = 9600; break;
case B19200: baud = 19200; break;
10712f: b8 00 96 00 00 mov $0x9600,%eax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107134: 83 fa 0f cmp $0xf,%edx <== NOT EXECUTED
107137: 74 29 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B1800: baud = 1800; break;
case B2400: baud = 2400; break;
case B4800: baud = 4800; break;
case B9600: baud = 9600; break;
case B19200: baud = 19200; break;
case B38400: baud = 38400; break;
107139: 66 b8 00 e1 mov $0xe100,%ax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
10713d: 81 fa 01 10 00 00 cmp $0x1001,%edx <== NOT EXECUTED
107143: eb 18 jmp 10715d <termios_baud_to_number+0xe5><== NOT EXECUTED
case B4800: baud = 4800; break;
case B9600: baud = 9600; break;
case B19200: baud = 19200; break;
case B38400: baud = 38400; break;
case B57600: baud = 57600; break;
case B115200: baud = 115200; break;
107145: b8 00 84 03 00 mov $0x38400,%eax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
10714a: 81 fa 03 10 00 00 cmp $0x1003,%edx <== NOT EXECUTED
107150: 74 10 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B9600: baud = 9600; break;
case B19200: baud = 19200; break;
case B38400: baud = 38400; break;
case B57600: baud = 57600; break;
case B115200: baud = 115200; break;
case B230400: baud = 230400; break;
107152: b8 00 08 07 00 mov $0x70800,%eax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107157: 81 fa 04 10 00 00 cmp $0x1004,%edx <== NOT EXECUTED
10715d: 74 03 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B19200: baud = 19200; break;
case B38400: baud = 38400; break;
case B57600: baud = 57600; break;
case B115200: baud = 115200; break;
case B230400: baud = 230400; break;
case B460800: baud = 460800; break;
10715f: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
default: baud = -1; break;
}
return baud;
}
107162: c9 leave <== NOT EXECUTED
107163: c3 ret <== NOT EXECUTED
0010d50c <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
10d50c: 55 push %ebp
10d50d: 89 e5 mov %esp,%ebp
10d50f: 57 push %edi
10d510: 56 push %esi
10d511: 53 push %ebx
10d512: 83 ec 0c sub $0xc,%esp
10d515: 8b 75 0c mov 0xc(%ebp),%esi
10d518: 8b 7d 10 mov 0x10(%ebp),%edi
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
10d51b: 83 7d 08 01 cmpl $0x1,0x8(%ebp)
10d51f: 75 1d jne 10d53e <timer_create+0x32>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
10d521: 85 ff test %edi,%edi
10d523: 74 19 je 10d53e <timer_create+0x32>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
10d525: 85 f6 test %esi,%esi
10d527: 74 22 je 10d54b <timer_create+0x3f>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
10d529: 8b 06 mov (%esi),%eax
10d52b: 48 dec %eax
10d52c: 83 f8 01 cmp $0x1,%eax
10d52f: 77 0d ja 10d53e <timer_create+0x32> <== 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 )
10d531: 8b 46 04 mov 0x4(%esi),%eax
10d534: 85 c0 test %eax,%eax
10d536: 74 06 je 10d53e <timer_create+0x32> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
10d538: 48 dec %eax
10d539: 83 f8 1f cmp $0x1f,%eax
10d53c: 76 0d jbe 10d54b <timer_create+0x3f> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10d53e: e8 c9 6e 00 00 call 11440c <__errno>
10d543: c7 00 16 00 00 00 movl $0x16,(%eax)
10d549: eb 31 jmp 10d57c <timer_create+0x70>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10d54b: a1 58 63 12 00 mov 0x126358,%eax
10d550: 40 inc %eax
10d551: a3 58 63 12 00 mov %eax,0x126358
#ifdef __cplusplus
extern "C" {
#endif
/**
* This routine initializes @a the_heap record to manage the
10d556: 83 ec 0c sub $0xc,%esp
10d559: 68 88 66 12 00 push $0x126688
10d55e: e8 81 1b 00 00 call 10f0e4 <_Objects_Allocate>
10d563: 89 c3 mov %eax,%ebx
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
10d565: 83 c4 10 add $0x10,%esp
10d568: 85 c0 test %eax,%eax
10d56a: 75 18 jne 10d584 <timer_create+0x78>
_Thread_Enable_dispatch();
10d56c: e8 c3 27 00 00 call 10fd34 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
10d571: e8 96 6e 00 00 call 11440c <__errno>
10d576: c7 00 0b 00 00 00 movl $0xb,(%eax)
10d57c: 83 c8 ff or $0xffffffff,%eax
10d57f: e9 81 00 00 00 jmp 10d605 <timer_create+0xf9>
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
10d584: c6 40 3c 02 movb $0x2,0x3c(%eax)
ptimer->thread_id = _Thread_Executing->Object.id;
10d588: a1 18 64 12 00 mov 0x126418,%eax
10d58d: 8b 40 08 mov 0x8(%eax),%eax
10d590: 89 43 38 mov %eax,0x38(%ebx)
if ( evp != NULL ) {
10d593: 85 f6 test %esi,%esi
10d595: 74 11 je 10d5a8 <timer_create+0x9c>
ptimer->inf.sigev_notify = evp->sigev_notify;
10d597: 8b 06 mov (%esi),%eax
10d599: 89 43 40 mov %eax,0x40(%ebx)
ptimer->inf.sigev_signo = evp->sigev_signo;
10d59c: 8b 46 04 mov 0x4(%esi),%eax
10d59f: 89 43 44 mov %eax,0x44(%ebx)
ptimer->inf.sigev_value = evp->sigev_value;
10d5a2: 8b 46 08 mov 0x8(%esi),%eax
10d5a5: 89 43 48 mov %eax,0x48(%ebx)
}
ptimer->overrun = 0;
10d5a8: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
ptimer->timer_data.it_value.tv_sec = 0;
10d5af: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
ptimer->timer_data.it_value.tv_nsec = 0;
10d5b6: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
ptimer->timer_data.it_interval.tv_sec = 0;
10d5bd: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx)
ptimer->timer_data.it_interval.tv_nsec = 0;
10d5c4: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx)
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
10d5cb: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
* @param[in] the_heap is the heap to operate upon
10d5d2: c7 43 2c 00 00 00 00 movl $0x0,0x2c(%ebx)
* @param[in] starting_address is the starting address of the memory for
10d5d9: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx)
* the heap
10d5e0: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx)
10d5e7: 8b 4b 08 mov 0x8(%ebx),%ecx
10d5ea: 0f b7 d1 movzwl %cx,%edx
10d5ed: a1 a4 66 12 00 mov 0x1266a4,%eax
10d5f2: 89 1c 90 mov %ebx,(%eax,%edx,4)
10d5f5: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
_Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL );
_Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);
*timerid = ptimer->Object.id;
10d5fc: 89 0f mov %ecx,(%edi)
_Thread_Enable_dispatch();
10d5fe: e8 31 27 00 00 call 10fd34 <_Thread_Enable_dispatch>
10d603: 31 c0 xor %eax,%eax
return 0;
}
10d605: 8d 65 f4 lea -0xc(%ebp),%esp
10d608: 5b pop %ebx
10d609: 5e pop %esi
10d60a: 5f pop %edi
10d60b: c9 leave
10d60c: c3 ret
0010a198 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
10a198: 55 push %ebp
10a199: 89 e5 mov %esp,%ebp
10a19b: 57 push %edi
10a19c: 56 push %esi
10a19d: 53 push %ebx
10a19e: 83 ec 2c sub $0x2c,%esp
10a1a1: 8b 55 0c mov 0xc(%ebp),%edx
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
10a1a4: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a1a8: 0f 84 4c 01 00 00 je 10a2fa <timer_settime+0x162> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
/* First, it verifies if the structure "value" is correct */
if ( ( value->it_value.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) ||
10a1ae: 8b 45 10 mov 0x10(%ebp),%eax
10a1b1: 81 78 0c ff c9 9a 3b cmpl $0x3b9ac9ff,0xc(%eax)
10a1b8: 0f 87 3c 01 00 00 ja 10a2fa <timer_settime+0x162>
10a1be: 8b 40 04 mov 0x4(%eax),%eax
10a1c1: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax
10a1c6: 0f 87 2e 01 00 00 ja 10a2fa <timer_settime+0x162> <== NEVER TAKEN
10a1cc: 85 c0 test %eax,%eax
10a1ce: 0f 88 26 01 00 00 js 10a2fa <timer_settime+0x162> <== NEVER TAKEN
( value->it_interval.tv_nsec < 0 )) {
/* The number of nanoseconds is not correct */
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
10a1d4: 83 fa 04 cmp $0x4,%edx
10a1d7: 74 08 je 10a1e1 <timer_settime+0x49>
10a1d9: 85 d2 test %edx,%edx
10a1db: 0f 85 19 01 00 00 jne 10a2fa <timer_settime+0x162>
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
10a1e1: 8d 7d e0 lea -0x20(%ebp),%edi
10a1e4: b9 04 00 00 00 mov $0x4,%ecx
10a1e9: 8b 75 10 mov 0x10(%ebp),%esi
10a1ec: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
10a1ee: 83 fa 04 cmp $0x4,%edx
10a1f1: 75 2b jne 10a21e <timer_settime+0x86>
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &_TOD_Now, &normalize.it_value ) )
10a1f3: 51 push %ecx
10a1f4: 51 push %ecx
10a1f5: 8d 5d e8 lea -0x18(%ebp),%ebx
10a1f8: 53 push %ebx
10a1f9: 68 e0 1a 12 00 push $0x121ae0
10a1fe: e8 4d 31 00 00 call 10d350 <_Timespec_Greater_than>
10a203: 83 c4 10 add $0x10,%esp
10a206: 84 c0 test %al,%al
10a208: 0f 85 ec 00 00 00 jne 10a2fa <timer_settime+0x162>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &_TOD_Now, &normalize.it_value, &normalize.it_value );
10a20e: 52 push %edx
10a20f: 53 push %ebx
10a210: 53 push %ebx
10a211: 68 e0 1a 12 00 push $0x121ae0
10a216: e8 5d 31 00 00 call 10d378 <_Timespec_Subtract>
10a21b: 83 c4 10 add $0x10,%esp
10a21e: 50 push %eax
10a21f: 8d 45 f0 lea -0x10(%ebp),%eax
10a222: 50 push %eax
10a223: ff 75 08 pushl 0x8(%ebp)
10a226: 68 80 1d 12 00 push $0x121d80
10a22b: e8 dc 1d 00 00 call 10c00c <_Objects_Get>
10a230: 89 c3 mov %eax,%ebx
* something with the structure of times of the timer: to stop, start
* or start it again
*/
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
10a232: 83 c4 10 add $0x10,%esp
10a235: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
10a239: 0f 85 bb 00 00 00 jne 10a2fa <timer_settime+0x162> <== NEVER TAKEN
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 ) {
10a23f: 83 7d e8 00 cmpl $0x0,-0x18(%ebp)
10a243: 75 3b jne 10a280 <timer_settime+0xe8>
10a245: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
10a249: 75 35 jne 10a280 <timer_settime+0xe8> <== NEVER TAKEN
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
10a24b: 83 ec 0c sub $0xc,%esp
10a24e: 8d 40 10 lea 0x10(%eax),%eax
10a251: 50 push %eax
10a252: e8 0d 35 00 00 call 10d764 <_Watchdog_Remove>
/* The old data of the timer are returned */
if ( ovalue )
10a257: 83 c4 10 add $0x10,%esp
10a25a: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10a25e: 74 0d je 10a26d <timer_settime+0xd5> <== ALWAYS TAKEN
*ovalue = ptimer->timer_data;
10a260: 8d 73 54 lea 0x54(%ebx),%esi <== NOT EXECUTED
10a263: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
10a268: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED
10a26b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
/* The new data are set */
ptimer->timer_data = normalize;
10a26d: 8d 7b 54 lea 0x54(%ebx),%edi
10a270: 8d 75 e0 lea -0x20(%ebp),%esi
10a273: b9 04 00 00 00 mov $0x4,%ecx
10a278: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10a27a: c6 43 3c 04 movb $0x4,0x3c(%ebx)
10a27e: eb 35 jmp 10a2b5 <timer_settime+0x11d>
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
10a280: 83 ec 0c sub $0xc,%esp
10a283: ff 75 10 pushl 0x10(%ebp)
10a286: e8 25 31 00 00 call 10d3b0 <_Timespec_To_ticks>
10a28b: 89 43 64 mov %eax,0x64(%ebx)
initial_period = _Timespec_To_ticks( &normalize.it_value );
10a28e: 8d 45 e8 lea -0x18(%ebp),%eax
10a291: 89 04 24 mov %eax,(%esp)
10a294: e8 17 31 00 00 call 10d3b0 <_Timespec_To_ticks>
activated = _POSIX_Timer_Insert_helper(
10a299: 89 1c 24 mov %ebx,(%esp)
10a29c: 68 10 a3 10 00 push $0x10a310
10a2a1: ff 73 08 pushl 0x8(%ebx)
10a2a4: 50 push %eax
10a2a5: 8d 43 10 lea 0x10(%ebx),%eax
10a2a8: 50 push %eax
10a2a9: e8 5a 52 00 00 call 10f508 <_POSIX_Timer_Insert_helper>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
10a2ae: 83 c4 20 add $0x20,%esp
10a2b1: 84 c0 test %al,%al
10a2b3: 75 09 jne 10a2be <timer_settime+0x126> <== ALWAYS TAKEN
_Thread_Enable_dispatch();
10a2b5: e8 12 25 00 00 call 10c7cc <_Thread_Enable_dispatch>
10a2ba: 31 c0 xor %eax,%eax
10a2bc: eb 4a jmp 10a308 <timer_settime+0x170>
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
10a2be: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10a2c2: 74 0d je 10a2d1 <timer_settime+0x139>
*ovalue = ptimer->timer_data;
10a2c4: 8d 73 54 lea 0x54(%ebx),%esi
10a2c7: b9 04 00 00 00 mov $0x4,%ecx
10a2cc: 8b 7d 14 mov 0x14(%ebp),%edi
10a2cf: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
ptimer->timer_data = normalize;
10a2d1: 8d 7b 54 lea 0x54(%ebx),%edi
10a2d4: 8d 75 e0 lea -0x20(%ebp),%esi
10a2d7: b9 04 00 00 00 mov $0x4,%ecx
10a2dc: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10a2de: c6 43 3c 03 movb $0x3,0x3c(%ebx)
_TOD_Get( &ptimer->time );
10a2e2: 83 ec 0c sub $0xc,%esp
10a2e5: 8d 43 6c lea 0x6c(%ebx),%eax
10a2e8: 50 push %eax
10a2e9: e8 8e 15 00 00 call 10b87c <_TOD_Get>
_Thread_Enable_dispatch();
10a2ee: e8 d9 24 00 00 call 10c7cc <_Thread_Enable_dispatch>
10a2f3: 31 c0 xor %eax,%eax
10a2f5: 83 c4 10 add $0x10,%esp
10a2f8: eb 0e jmp 10a308 <timer_settime+0x170>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10a2fa: e8 71 69 00 00 call 110c70 <__errno>
10a2ff: c7 00 16 00 00 00 movl $0x16,(%eax)
10a305: 83 c8 ff or $0xffffffff,%eax
}
10a308: 8d 65 f4 lea -0xc(%ebp),%esp
10a30b: 5b pop %ebx
10a30c: 5e pop %esi
10a30d: 5f pop %edi
10a30e: c9 leave
10a30f: c3 ret
00108da8 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
108da8: 55 push %ebp
108da9: 89 e5 mov %esp,%ebp
108dab: 56 push %esi
108dac: 53 push %ebx
108dad: 83 ec 20 sub $0x20,%esp
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
108db0: 83 3d ec fe 11 00 00 cmpl $0x0,0x11feec
108db7: 75 2c jne 108de5 <ualarm+0x3d>
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
108db9: c7 05 d8 fe 11 00 00 movl $0x0,0x11fed8
108dc0: 00 00 00
* @param[in] the_heap is the heap to operate upon
108dc3: c7 05 ec fe 11 00 88 movl $0x108e88,0x11feec
108dca: 8e 10 00
* @param[in] starting_address is the starting address of the memory for
108dcd: c7 05 f0 fe 11 00 00 movl $0x0,0x11fef0
108dd4: 00 00 00
* the heap
108dd7: c7 05 f4 fe 11 00 00 movl $0x0,0x11fef4
108dde: 00 00 00
108de1: 31 f6 xor %esi,%esi
108de3: eb 4f jmp 108e34 <ualarm+0x8c>
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
switch ( _Watchdog_Remove( the_timer ) ) {
108de5: 83 ec 0c sub $0xc,%esp
108de8: 68 d0 fe 11 00 push $0x11fed0
108ded: e8 16 35 00 00 call 10c308 <_Watchdog_Remove>
108df2: 83 c4 10 add $0x10,%esp
108df5: 83 e8 02 sub $0x2,%eax
108df8: 31 f6 xor %esi,%esi
108dfa: 83 f8 01 cmp $0x1,%eax
108dfd: 77 35 ja 108e34 <ualarm+0x8c> <== NEVER TAKEN
* 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);
108dff: a1 e4 fe 11 00 mov 0x11fee4,%eax
108e04: 03 05 dc fe 11 00 add 0x11fedc,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
108e0a: 51 push %ecx
108e0b: 51 push %ecx
108e0c: 8d 55 f0 lea -0x10(%ebp),%edx
108e0f: 52 push %edx
108e10: 2b 05 e8 fe 11 00 sub 0x11fee8,%eax
108e16: 50 push %eax
108e17: e8 a4 30 00 00 call 10bec0 <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
108e1c: 69 4d f0 40 42 0f 00 imul $0xf4240,-0x10(%ebp),%ecx
remaining += tp.tv_nsec / 1000;
108e23: 8b 45 f4 mov -0xc(%ebp),%eax
108e26: bb e8 03 00 00 mov $0x3e8,%ebx
108e2b: 99 cltd
108e2c: f7 fb idiv %ebx
108e2e: 8d 34 08 lea (%eax,%ecx,1),%esi
108e31: 83 c4 10 add $0x10,%esp
/*
* 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 ) {
108e34: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
108e38: 74 45 je 108e7f <ualarm+0xd7>
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
108e3a: b9 40 42 0f 00 mov $0xf4240,%ecx
108e3f: 8b 45 08 mov 0x8(%ebp),%eax
108e42: 31 d2 xor %edx,%edx
108e44: f7 f1 div %ecx
108e46: 89 45 f0 mov %eax,-0x10(%ebp)
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
108e49: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx
108e4f: 89 55 f4 mov %edx,-0xc(%ebp)
ticks = _Timespec_To_ticks( &tp );
108e52: 83 ec 0c sub $0xc,%esp
108e55: 8d 5d f0 lea -0x10(%ebp),%ebx
108e58: 53 push %ebx
108e59: e8 c6 30 00 00 call 10bf24 <_Timespec_To_ticks>
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
108e5e: 89 1c 24 mov %ebx,(%esp)
108e61: e8 be 30 00 00 call 10bf24 <_Timespec_To_ticks>
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
Heap_Control *the_heap,
108e66: a3 dc fe 11 00 mov %eax,0x11fedc
void *starting_address,
size_t *size
108e6b: 58 pop %eax
108e6c: 5a pop %edx
108e6d: 68 d0 fe 11 00 push $0x11fed0
108e72: 68 90 00 12 00 push $0x120090
108e77: e8 74 33 00 00 call 10c1f0 <_Watchdog_Insert>
108e7c: 83 c4 10 add $0x10,%esp
}
return remaining;
}
108e7f: 89 f0 mov %esi,%eax
108e81: 8d 65 f8 lea -0x8(%ebp),%esp
108e84: 5b pop %ebx
108e85: 5e pop %esi
108e86: c9 leave
108e87: c3 ret
0010b110 <unlink>:
#include <rtems/seterr.h>
int unlink(
const char *path
)
{
10b110: 55 push %ebp
10b111: 89 e5 mov %esp,%ebp
10b113: 56 push %esi
10b114: 53 push %ebx
10b115: 83 ec 10 sub $0x10,%esp
/*
* Get the node to be unlinked.
*/
result = rtems_filesystem_evaluate_path( path, 0, &loc, false );
10b118: 6a 00 push $0x0
10b11a: 8d 5d e8 lea -0x18(%ebp),%ebx
10b11d: 53 push %ebx
10b11e: 6a 00 push $0x0
10b120: ff 75 08 pushl 0x8(%ebp)
10b123: e8 56 d1 ff ff call 10827e <rtems_filesystem_evaluate_path>
if ( result != 0 )
10b128: 83 c4 10 add $0x10,%esp
10b12b: 85 c0 test %eax,%eax
10b12d: 0f 85 d9 00 00 00 jne 10b20c <unlink+0xfc>
return -1;
result = rtems_filesystem_evaluate_parent(RTEMS_LIBIO_PERMS_WRITE, &loc );
10b133: 50 push %eax
10b134: 50 push %eax
10b135: 53 push %ebx
10b136: 6a 02 push $0x2
10b138: e8 cb d0 ff ff call 108208 <rtems_filesystem_evaluate_parent>
if (result != 0 && errno != ENOTSUP) {
10b13d: 83 c4 10 add $0x10,%esp
10b140: 85 c0 test %eax,%eax
10b142: 74 31 je 10b175 <unlink+0x65> <== ALWAYS TAKEN
10b144: e8 af 71 00 00 call 1122f8 <__errno> <== NOT EXECUTED
10b149: 81 38 86 00 00 00 cmpl $0x86,(%eax) <== NOT EXECUTED
10b14f: 74 24 je 10b175 <unlink+0x65> <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
10b151: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED
10b154: 85 c0 test %eax,%eax <== NOT EXECUTED
10b156: 0f 84 b0 00 00 00 je 10b20c <unlink+0xfc> <== NOT EXECUTED
10b15c: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
10b15f: 85 c0 test %eax,%eax <== NOT EXECUTED
10b161: 0f 84 a5 00 00 00 je 10b20c <unlink+0xfc> <== NOT EXECUTED
10b167: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b16a: 53 push %ebx <== NOT EXECUTED
10b16b: ff d0 call *%eax <== NOT EXECUTED
10b16d: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED
10b170: e9 92 00 00 00 jmp 10b207 <unlink+0xf7> <== NOT EXECUTED
return -1;
}
if ( !loc.ops->node_type_h ) {
10b175: 8b 45 f0 mov -0x10(%ebp),%eax
10b178: 8b 50 10 mov 0x10(%eax),%edx
10b17b: 85 d2 test %edx,%edx
10b17d: 75 12 jne 10b191 <unlink+0x81> <== ALWAYS TAKEN
rtems_filesystem_freenode( &loc );
10b17f: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED
10b182: 85 d2 test %edx,%edx <== NOT EXECUTED
10b184: 74 55 je 10b1db <unlink+0xcb> <== NOT EXECUTED
10b186: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b189: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED
10b18c: 50 push %eax <== NOT EXECUTED
10b18d: ff d2 call *%edx <== NOT EXECUTED
10b18f: eb 47 jmp 10b1d8 <unlink+0xc8> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
10b191: 83 ec 0c sub $0xc,%esp
10b194: 8d 75 e8 lea -0x18(%ebp),%esi
10b197: 56 push %esi
10b198: ff d2 call *%edx
10b19a: 83 c4 10 add $0x10,%esp
10b19d: 48 dec %eax
10b19e: 8b 45 f0 mov -0x10(%ebp),%eax
10b1a1: 75 21 jne 10b1c4 <unlink+0xb4>
rtems_filesystem_freenode( &loc );
10b1a3: 85 c0 test %eax,%eax
10b1a5: 74 10 je 10b1b7 <unlink+0xa7> <== NEVER TAKEN
10b1a7: 8b 40 1c mov 0x1c(%eax),%eax
10b1aa: 85 c0 test %eax,%eax
10b1ac: 74 09 je 10b1b7 <unlink+0xa7> <== NEVER TAKEN
10b1ae: 83 ec 0c sub $0xc,%esp
10b1b1: 56 push %esi
10b1b2: ff d0 call *%eax
10b1b4: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( EISDIR );
10b1b7: e8 3c 71 00 00 call 1122f8 <__errno>
10b1bc: c7 00 15 00 00 00 movl $0x15,(%eax)
10b1c2: eb 48 jmp 10b20c <unlink+0xfc>
}
if ( !loc.ops->unlink_h ) {
10b1c4: 8b 50 0c mov 0xc(%eax),%edx
10b1c7: 85 d2 test %edx,%edx
10b1c9: 75 1d jne 10b1e8 <unlink+0xd8> <== ALWAYS TAKEN
rtems_filesystem_freenode( &loc );
10b1cb: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
10b1ce: 85 c0 test %eax,%eax <== NOT EXECUTED
10b1d0: 74 09 je 10b1db <unlink+0xcb> <== NOT EXECUTED
10b1d2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b1d5: 56 push %esi <== NOT EXECUTED
10b1d6: ff d0 call *%eax <== NOT EXECUTED
10b1d8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
10b1db: e8 18 71 00 00 call 1122f8 <__errno> <== NOT EXECUTED
10b1e0: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10b1e6: eb 24 jmp 10b20c <unlink+0xfc> <== NOT EXECUTED
}
result = (*loc.ops->unlink_h)( &loc );
10b1e8: 83 ec 0c sub $0xc,%esp
10b1eb: 56 push %esi
10b1ec: ff d2 call *%edx
10b1ee: 89 c3 mov %eax,%ebx
rtems_filesystem_freenode( &loc );
10b1f0: 8b 45 f0 mov -0x10(%ebp),%eax
10b1f3: 83 c4 10 add $0x10,%esp
10b1f6: 85 c0 test %eax,%eax
10b1f8: 74 15 je 10b20f <unlink+0xff> <== NEVER TAKEN
10b1fa: 8b 40 1c mov 0x1c(%eax),%eax
10b1fd: 85 c0 test %eax,%eax
10b1ff: 74 0e je 10b20f <unlink+0xff> <== NEVER TAKEN
10b201: 83 ec 0c sub $0xc,%esp
10b204: 56 push %esi
10b205: ff d0 call *%eax
10b207: 83 c4 10 add $0x10,%esp
10b20a: eb 03 jmp 10b20f <unlink+0xff>
10b20c: 83 cb ff or $0xffffffff,%ebx
return result;
}
10b20f: 89 d8 mov %ebx,%eax
10b211: 8d 65 f8 lea -0x8(%ebp),%esp
10b214: 5b pop %ebx
10b215: 5e pop %esi
10b216: c9 leave
10b217: c3 ret
0010a45a <unmount>:
*/
int unmount(
const char *path
)
{
10a45a: 55 push %ebp
10a45b: 89 e5 mov %esp,%ebp
10a45d: 56 push %esi
10a45e: 53 push %ebx
10a45f: 83 ec 10 sub $0x10,%esp
* 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, 0x0, &loc, true ) )
10a462: 6a 01 push $0x1
10a464: 8d 75 e8 lea -0x18(%ebp),%esi
10a467: 56 push %esi
10a468: 6a 00 push $0x0
10a46a: ff 75 08 pushl 0x8(%ebp)
10a46d: e8 c0 d0 ff ff call 107532 <rtems_filesystem_evaluate_path>
10a472: 83 c4 10 add $0x10,%esp
10a475: 85 c0 test %eax,%eax
10a477: 0f 85 11 01 00 00 jne 10a58e <unmount+0x134>
return -1;
mt_entry = loc.mt_entry;
10a47d: 8b 5d f4 mov -0xc(%ebp),%ebx
/*
* Verify this is the root node for the file system to be unmounted.
*/
if ( !rtems_filesystem_nodes_equal( fs_root_loc, &loc) ){
10a480: 8b 43 18 mov 0x18(%ebx),%eax
10a483: 3b 45 e8 cmp -0x18(%ebp),%eax
10a486: 8b 45 f0 mov -0x10(%ebp),%eax
10a489: 74 24 je 10a4af <unmount+0x55>
rtems_filesystem_freenode( &loc );
10a48b: 85 c0 test %eax,%eax
10a48d: 74 10 je 10a49f <unmount+0x45> <== NEVER TAKEN
10a48f: 8b 40 1c mov 0x1c(%eax),%eax
10a492: 85 c0 test %eax,%eax
10a494: 74 09 je 10a49f <unmount+0x45> <== NEVER TAKEN
10a496: 83 ec 0c sub $0xc,%esp
10a499: 56 push %esi
10a49a: ff d0 call *%eax
10a49c: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( EACCES );
10a49f: e8 0c 71 00 00 call 1115b0 <__errno>
10a4a4: c7 00 0d 00 00 00 movl $0xd,(%eax)
10a4aa: e9 df 00 00 00 jmp 10a58e <unmount+0x134>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
10a4af: 85 c0 test %eax,%eax
10a4b1: 74 10 je 10a4c3 <unmount+0x69> <== NEVER TAKEN
10a4b3: 8b 40 1c mov 0x1c(%eax),%eax
10a4b6: 85 c0 test %eax,%eax
10a4b8: 74 09 je 10a4c3 <unmount+0x69> <== NEVER TAKEN
10a4ba: 83 ec 0c sub $0xc,%esp
10a4bd: 56 push %esi
10a4be: ff d0 call *%eax
10a4c0: 83 c4 10 add $0x10,%esp
/*
* Verify Unmount is supported by both filesystems.
*/
if ( !fs_mount_loc->ops->unmount_h )
10a4c3: 8b 43 10 mov 0x10(%ebx),%eax
10a4c6: 83 78 28 00 cmpl $0x0,0x28(%eax)
10a4ca: 74 09 je 10a4d5 <unmount+0x7b> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
if ( !fs_root_loc->ops->fsunmount_me_h )
10a4cc: 8b 43 20 mov 0x20(%ebx),%eax
10a4cf: 83 78 2c 00 cmpl $0x0,0x2c(%eax)
10a4d3: 75 10 jne 10a4e5 <unmount+0x8b> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
10a4d5: e8 d6 70 00 00 call 1115b0 <__errno> <== NOT EXECUTED
10a4da: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10a4e0: e9 a9 00 00 00 jmp 10a58e <unmount+0x134> <== NOT EXECUTED
* 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 )
10a4e5: a1 4c 09 12 00 mov 0x12094c,%eax
10a4ea: 39 58 10 cmp %ebx,0x10(%eax)
10a4ed: 74 1f je 10a50e <unmount+0xb4>
/*
* Search the mount table for any mount entries referencing this
* mount entry.
*/
for ( the_node = rtems_filesystem_mount_table_control.first;
10a4ef: 8b 15 94 29 12 00 mov 0x122994,%edx
10a4f5: eb 0a jmp 10a501 <unmount+0xa7>
!rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
the_node = the_node->next ) {
the_mount_entry = ( rtems_filesystem_mount_table_entry_t * )the_node;
if (the_mount_entry->mt_point_node.mt_entry == fs_root_loc->mt_entry ) {
10a4f7: 8b 42 14 mov 0x14(%edx),%eax
10a4fa: 3b 43 24 cmp 0x24(%ebx),%eax
10a4fd: 74 0f je 10a50e <unmount+0xb4>
* mount entry.
*/
for ( the_node = rtems_filesystem_mount_table_control.first;
!rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
the_node = the_node->next ) {
10a4ff: 8b 12 mov (%edx),%edx
* Search the mount table for any mount entries referencing this
* mount entry.
*/
for ( the_node = rtems_filesystem_mount_table_control.first;
!rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
10a501: 81 fa 98 29 12 00 cmp $0x122998,%edx
10a507: 75 ee jne 10a4f7 <unmount+0x9d>
10a509: e9 8a 00 00 00 jmp 10a598 <unmount+0x13e>
* 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 );
10a50e: e8 9d 70 00 00 call 1115b0 <__errno>
10a513: c7 00 10 00 00 00 movl $0x10,(%eax)
10a519: eb 73 jmp 10a58e <unmount+0x134>
* 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 )
10a51b: 83 ec 0c sub $0xc,%esp
10a51e: 8b 43 10 mov 0x10(%ebx),%eax
10a521: 53 push %ebx
10a522: ff 50 28 call *0x28(%eax)
10a525: 83 c4 10 add $0x10,%esp
10a528: 85 c0 test %eax,%eax
10a52a: 75 62 jne 10a58e <unmount+0x134> <== NEVER TAKEN
* 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){
10a52c: 83 ec 0c sub $0xc,%esp
10a52f: 8b 43 20 mov 0x20(%ebx),%eax
10a532: 53 push %ebx
10a533: ff 50 2c call *0x2c(%eax)
10a536: 83 c4 10 add $0x10,%esp
10a539: 85 c0 test %eax,%eax
10a53b: 74 1b je 10a558 <unmount+0xfe> <== ALWAYS TAKEN
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
10a53d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a540: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED
10a543: 53 push %ebx <== NOT EXECUTED
10a544: ff 50 20 call *0x20(%eax) <== NOT EXECUTED
10a547: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a54a: 85 c0 test %eax,%eax <== NOT EXECUTED
10a54c: 74 40 je 10a58e <unmount+0x134> <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
10a54e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a551: 6a 00 push $0x0 <== NOT EXECUTED
10a553: e8 24 0e 00 00 call 10b37c <rtems_fatal_error_occurred><== NOT EXECUTED
10a558: 83 ec 0c sub $0xc,%esp
10a55b: 53 push %ebx
10a55c: e8 97 11 00 00 call 10b6f8 <_Chain_Extract>
/*
* 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 );
10a561: 8b 43 10 mov 0x10(%ebx),%eax
10a564: 83 c4 10 add $0x10,%esp
10a567: 85 c0 test %eax,%eax
10a569: 74 13 je 10a57e <unmount+0x124> <== NEVER TAKEN
10a56b: 8b 50 1c mov 0x1c(%eax),%edx
10a56e: 85 d2 test %edx,%edx
10a570: 74 0c je 10a57e <unmount+0x124> <== NEVER TAKEN
10a572: 83 ec 0c sub $0xc,%esp
10a575: 8d 43 08 lea 0x8(%ebx),%eax
10a578: 50 push %eax
10a579: ff d2 call *%edx
10a57b: 83 c4 10 add $0x10,%esp
free( mt_entry );
10a57e: 83 ec 0c sub $0xc,%esp
10a581: 53 push %ebx
10a582: e8 cd d0 ff ff call 107654 <free>
10a587: 31 c0 xor %eax,%eax
10a589: 83 c4 10 add $0x10,%esp
10a58c: eb 03 jmp 10a591 <unmount+0x137>
return 0;
10a58e: 83 c8 ff or $0xffffffff,%eax
}
10a591: 8d 65 f8 lea -0x8(%ebp),%esp
10a594: 5b pop %ebx
10a595: 5e pop %esi
10a596: c9 leave
10a597: c3 ret
* 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 )
10a598: 83 ec 0c sub $0xc,%esp
10a59b: 53 push %ebx
10a59c: e8 bf d2 ff ff call 107860 <rtems_libio_is_open_files_in_fs>
10a5a1: 83 c4 10 add $0x10,%esp
10a5a4: 48 dec %eax
10a5a5: 0f 85 70 ff ff ff jne 10a51b <unmount+0xc1>
10a5ab: e9 5e ff ff ff jmp 10a50e <unmount+0xb4>
00109dec <utime>:
int utime(
const char *path,
const struct utimbuf *times
)
{
109dec: 55 push %ebp
109ded: 89 e5 mov %esp,%ebp
109def: 57 push %edi
109df0: 56 push %esi
109df1: 53 push %ebx
109df2: 83 ec 1c sub $0x1c,%esp
109df5: 8b 7d 0c mov 0xc(%ebp),%edi
rtems_filesystem_location_info_t temp_loc;
int result;
if ( rtems_filesystem_evaluate_path( path, 0x00, &temp_loc, true ) )
109df8: 6a 01 push $0x1
109dfa: 8d 75 e4 lea -0x1c(%ebp),%esi
109dfd: 56 push %esi
109dfe: 6a 00 push $0x0
109e00: ff 75 08 pushl 0x8(%ebp)
109e03: e8 86 d1 ff ff call 106f8e <rtems_filesystem_evaluate_path>
109e08: 83 c4 10 add $0x10,%esp
109e0b: 83 cb ff or $0xffffffff,%ebx
109e0e: 85 c0 test %eax,%eax
109e10: 75 4f jne 109e61 <utime+0x75>
return -1;
if ( !temp_loc.ops->utime_h ){
109e12: 8b 45 ec mov -0x14(%ebp),%eax
109e15: 8b 50 30 mov 0x30(%eax),%edx
109e18: 85 d2 test %edx,%edx
109e1a: 75 20 jne 109e3c <utime+0x50> <== ALWAYS TAKEN
rtems_filesystem_freenode( &temp_loc );
109e1c: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
109e1f: 85 c0 test %eax,%eax <== NOT EXECUTED
109e21: 74 09 je 109e2c <utime+0x40> <== NOT EXECUTED
109e23: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109e26: 56 push %esi <== NOT EXECUTED
109e27: ff d0 call *%eax <== NOT EXECUTED
109e29: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
109e2c: e8 af 71 00 00 call 110fe0 <__errno> <== NOT EXECUTED
109e31: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
109e37: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED
109e3a: eb 25 jmp 109e61 <utime+0x75> <== NOT EXECUTED
}
result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime );
109e3c: 50 push %eax
109e3d: ff 77 04 pushl 0x4(%edi)
109e40: ff 37 pushl (%edi)
109e42: 56 push %esi
109e43: ff d2 call *%edx
109e45: 89 c3 mov %eax,%ebx
rtems_filesystem_freenode( &temp_loc );
109e47: 8b 45 ec mov -0x14(%ebp),%eax
109e4a: 83 c4 10 add $0x10,%esp
109e4d: 85 c0 test %eax,%eax
109e4f: 74 10 je 109e61 <utime+0x75> <== NEVER TAKEN
109e51: 8b 40 1c mov 0x1c(%eax),%eax
109e54: 85 c0 test %eax,%eax
109e56: 74 09 je 109e61 <utime+0x75> <== NEVER TAKEN
109e58: 83 ec 0c sub $0xc,%esp
109e5b: 56 push %esi
109e5c: ff d0 call *%eax
109e5e: 83 c4 10 add $0x10,%esp
return result;
}
109e61: 89 d8 mov %ebx,%eax
109e63: 8d 65 f4 lea -0xc(%ebp),%esp
109e66: 5b pop %ebx
109e67: 5e pop %esi
109e68: 5f pop %edi
109e69: c9 leave
109e6a: c3 ret
00106dc4 <vprintk>:
*/
void vprintk(
const char *fmt,
va_list ap
)
{
106dc4: 55 push %ebp
106dc5: 89 e5 mov %esp,%ebp
106dc7: 57 push %edi
106dc8: 56 push %esi
106dc9: 53 push %ebx
106dca: 83 ec 4c sub $0x4c,%esp
106dcd: 8b 7d 08 mov 0x8(%ebp),%edi
106dd0: e9 6d 02 00 00 jmp 107042 <vprintk+0x27e>
base = 0;
sign = 0;
width = 0;
minus = 0;
lead = ' ';
if (*fmt == '%') {
106dd5: 3c 25 cmp $0x25,%al
106dd7: 0f 85 54 02 00 00 jne 107031 <vprintk+0x26d>
fmt++;
106ddd: 47 inc %edi
if (*fmt == '0' ) {
106dde: c7 45 c8 20 00 00 00 movl $0x20,-0x38(%ebp)
106de5: 80 3f 30 cmpb $0x30,(%edi)
106de8: 75 08 jne 106df2 <vprintk+0x2e>
lead = '0';
fmt++;
106dea: 47 inc %edi
106deb: c7 45 c8 30 00 00 00 movl $0x30,-0x38(%ebp)
}
if (*fmt == '-' ) {
106df2: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp)
106df9: 80 3f 2d cmpb $0x2d,(%edi)
106dfc: 75 08 jne 106e06 <vprintk+0x42>
minus = 1;
fmt++;
106dfe: 47 inc %edi
106dff: c7 45 cc 01 00 00 00 movl $0x1,-0x34(%ebp)
106e06: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
106e0d: eb 0f jmp 106e1e <vprintk+0x5a>
}
while (*fmt >= '0' && *fmt <= '9' ) {
width *= 10;
106e0f: 6b 55 c4 0a imul $0xa,-0x3c(%ebp),%edx
width += (*fmt - '0');
106e13: 0f be c1 movsbl %cl,%eax
106e16: 8d 44 02 d0 lea -0x30(%edx,%eax,1),%eax
106e1a: 89 45 c4 mov %eax,-0x3c(%ebp)
fmt++;
106e1d: 47 inc %edi
}
if (*fmt == '-' ) {
minus = 1;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
106e1e: 8a 0f mov (%edi),%cl
106e20: 8d 41 d0 lea -0x30(%ecx),%eax
106e23: 3c 09 cmp $0x9,%al
106e25: 76 e8 jbe 106e0f <vprintk+0x4b>
width *= 10;
width += (*fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
106e27: 31 d2 xor %edx,%edx
106e29: 80 f9 6c cmp $0x6c,%cl
106e2c: 75 08 jne 106e36 <vprintk+0x72>
lflag = 1;
c = *++fmt;
106e2e: 47 inc %edi
106e2f: 8a 0f mov (%edi),%cl
106e31: ba 01 00 00 00 mov $0x1,%edx
}
switch (c) {
106e36: 80 f9 64 cmp $0x64,%cl
106e39: 74 71 je 106eac <vprintk+0xe8>
106e3b: 7f 38 jg 106e75 <vprintk+0xb1>
106e3d: 80 f9 4f cmp $0x4f,%cl
106e40: 0f 84 32 01 00 00 je 106f78 <vprintk+0x1b4> <== NEVER TAKEN
106e46: 7f 10 jg 106e58 <vprintk+0x94> <== NEVER TAKEN
106e48: 80 f9 44 cmp $0x44,%cl
106e4b: 74 5f je 106eac <vprintk+0xe8> <== NEVER TAKEN
106e4d: 80 f9 49 cmp $0x49,%cl
106e50: 0f 85 17 01 00 00 jne 106f6d <vprintk+0x1a9> <== ALWAYS TAKEN
106e56: eb 54 jmp 106eac <vprintk+0xe8> <== NOT EXECUTED
106e58: 80 f9 58 cmp $0x58,%cl <== NOT EXECUTED
106e5b: 0f 84 20 01 00 00 je 106f81 <vprintk+0x1bd> <== NOT EXECUTED
106e61: 80 f9 63 cmp $0x63,%cl <== NOT EXECUTED
106e64: 0f 84 e5 00 00 00 je 106f4f <vprintk+0x18b> <== NOT EXECUTED
106e6a: 80 f9 55 cmp $0x55,%cl <== NOT EXECUTED
106e6d: 0f 85 fa 00 00 00 jne 106f6d <vprintk+0x1a9> <== NOT EXECUTED
106e73: eb 3e jmp 106eb3 <vprintk+0xef> <== NOT EXECUTED
106e75: 80 f9 70 cmp $0x70,%cl
106e78: 0f 84 03 01 00 00 je 106f81 <vprintk+0x1bd>
106e7e: 7f 13 jg 106e93 <vprintk+0xcf> <== ALWAYS TAKEN
106e80: 80 f9 69 cmp $0x69,%cl <== NOT EXECUTED
106e83: 74 27 je 106eac <vprintk+0xe8> <== NOT EXECUTED
106e85: 80 f9 6f cmp $0x6f,%cl <== NOT EXECUTED
106e88: 0f 85 df 00 00 00 jne 106f6d <vprintk+0x1a9> <== NOT EXECUTED
106e8e: e9 e5 00 00 00 jmp 106f78 <vprintk+0x1b4> <== NOT EXECUTED
106e93: 80 f9 75 cmp $0x75,%cl
106e96: 74 1b je 106eb3 <vprintk+0xef>
106e98: 80 f9 78 cmp $0x78,%cl
106e9b: 0f 84 e0 00 00 00 je 106f81 <vprintk+0x1bd>
106ea1: 80 f9 73 cmp $0x73,%cl
106ea4: 0f 85 c3 00 00 00 jne 106f6d <vprintk+0x1a9> <== NEVER TAKEN
106eaa: eb 13 jmp 106ebf <vprintk+0xfb>
106eac: b8 01 00 00 00 mov $0x1,%eax
106eb1: eb 02 jmp 106eb5 <vprintk+0xf1>
106eb3: 31 c0 xor %eax,%eax
106eb5: be 0a 00 00 00 mov $0xa,%esi
106eba: e9 c9 00 00 00 jmp 106f88 <vprintk+0x1c4>
case 'p': base = 16; sign = 0; break;
case 's':
{ int i, len;
char *s;
str = va_arg(ap, char *);
106ebf: 8b 45 0c mov 0xc(%ebp),%eax
106ec2: 83 c0 04 add $0x4,%eax
106ec5: 89 45 d0 mov %eax,-0x30(%ebp)
106ec8: 8b 55 0c mov 0xc(%ebp),%edx
106ecb: 8b 12 mov (%edx),%edx
106ecd: 89 55 c0 mov %edx,-0x40(%ebp)
106ed0: 31 f6 xor %esi,%esi
106ed2: eb 01 jmp 106ed5 <vprintk+0x111>
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
106ed4: 46 inc %esi
106ed5: 8b 4d c0 mov -0x40(%ebp),%ecx
106ed8: 80 3c 31 00 cmpb $0x0,(%ecx,%esi,1)
106edc: 75 f6 jne 106ed4 <vprintk+0x110>
;
/* leading spaces */
if ( !minus )
106ede: 89 f3 mov %esi,%ebx
106ee0: 83 7d cc 00 cmpl $0x0,-0x34(%ebp)
106ee4: 74 11 je 106ef7 <vprintk+0x133>
106ee6: eb 14 jmp 106efc <vprintk+0x138>
for ( i=len ; i<width ; i++ )
BSP_output_char(' ');
106ee8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106eeb: 6a 20 push $0x20 <== NOT EXECUTED
106eed: ff 15 fc 93 11 00 call *0x1193fc <== NOT EXECUTED
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
106ef3: 43 inc %ebx <== NOT EXECUTED
106ef4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106ef7: 3b 5d c4 cmp -0x3c(%ebp),%ebx
106efa: 7c ec jl 106ee8 <vprintk+0x124> <== NEVER TAKEN
BSP_output_char(' ');
/* no width option */
if (width == 0) {
106efc: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
106f00: 75 03 jne 106f05 <vprintk+0x141>
106f02: 89 75 c4 mov %esi,-0x3c(%ebp)
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
106f05: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
106f09: 7e 1e jle 106f29 <vprintk+0x165> <== NEVER TAKEN
106f0b: eb 13 jmp 106f20 <vprintk+0x15c>
BSP_output_char(*str);
106f0d: 83 ec 0c sub $0xc,%esp
106f10: 0f be c0 movsbl %al,%eax
106f13: 50 push %eax
106f14: ff 15 fc 93 11 00 call *0x1193fc
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
106f1a: ff 45 c0 incl -0x40(%ebp)
106f1d: 83 c4 10 add $0x10,%esp
106f20: 8b 55 c0 mov -0x40(%ebp),%edx
106f23: 8a 02 mov (%edx),%al
106f25: 84 c0 test %al,%al
106f27: 75 e4 jne 106f0d <vprintk+0x149>
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
106f29: 89 f3 mov %esi,%ebx
106f2b: 83 7d cc 00 cmpl $0x0,-0x34(%ebp)
106f2f: 75 14 jne 106f45 <vprintk+0x181>
106f31: e9 18 01 00 00 jmp 10704e <vprintk+0x28a>
for ( i=len ; i<width ; i++ )
BSP_output_char(' ');
106f36: 83 ec 0c sub $0xc,%esp
106f39: 6a 20 push $0x20
106f3b: ff 15 fc 93 11 00 call *0x1193fc
for ( i=0 ; i<width && *str ; str++ )
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
106f41: 43 inc %ebx
106f42: 83 c4 10 add $0x10,%esp
106f45: 3b 5d c4 cmp -0x3c(%ebp),%ebx
106f48: 7c ec jl 106f36 <vprintk+0x172>
106f4a: e9 ff 00 00 00 jmp 10704e <vprintk+0x28a>
BSP_output_char(' ');
}
break;
case 'c':
BSP_output_char(va_arg(ap, int));
106f4f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED
106f52: 83 c3 04 add $0x4,%ebx <== NOT EXECUTED
106f55: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106f58: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
106f5b: 0f be 01 movsbl (%ecx),%eax <== NOT EXECUTED
106f5e: 50 push %eax <== NOT EXECUTED
106f5f: ff 15 fc 93 11 00 call *0x1193fc <== NOT EXECUTED
106f65: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED
106f68: e9 d1 00 00 00 jmp 10703e <vprintk+0x27a> <== NOT EXECUTED
break;
default:
BSP_output_char(c);
106f6d: 83 ec 0c sub $0xc,%esp
106f70: 0f be c1 movsbl %cl,%eax
106f73: e9 bf 00 00 00 jmp 107037 <vprintk+0x273>
106f78: 31 c0 xor %eax,%eax
106f7a: be 08 00 00 00 mov $0x8,%esi <== NOT EXECUTED
106f7f: eb 07 jmp 106f88 <vprintk+0x1c4> <== NOT EXECUTED
106f81: 31 c0 xor %eax,%eax
106f83: be 10 00 00 00 mov $0x10,%esi
break;
} /* switch*/
if (base)
printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int),
106f88: 85 d2 test %edx,%edx
106f8a: 8b 4d 0c mov 0xc(%ebp),%ecx
106f8d: 8d 51 04 lea 0x4(%ecx),%edx
106f90: 75 03 jne 106f95 <vprintk+0x1d1>
106f92: 8b 4d 0c mov 0xc(%ebp),%ecx
106f95: 8b 19 mov (%ecx),%ebx
106f97: 89 55 0c mov %edx,0xc(%ebp)
{
long unsigned int n;
int count;
char toPrint[20];
if ( (sign == 1) && ((long)num < 0) ) {
106f9a: 48 dec %eax
106f9b: 75 1c jne 106fb9 <vprintk+0x1f5>
106f9d: 85 db test %ebx,%ebx
106f9f: 79 18 jns 106fb9 <vprintk+0x1f5> <== ALWAYS TAKEN
BSP_output_char('-');
106fa1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106fa4: 6a 2d push $0x2d <== NOT EXECUTED
106fa6: ff 15 fc 93 11 00 call *0x1193fc <== NOT EXECUTED
num = -num;
106fac: f7 db neg %ebx <== NOT EXECUTED
if (maxwidth) maxwidth--;
106fae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106fb1: 83 7d c4 01 cmpl $0x1,-0x3c(%ebp) <== NOT EXECUTED
106fb5: 83 55 c4 ff adcl $0xffffffff,-0x3c(%ebp) <== NOT EXECUTED
106fb9: 31 c9 xor %ecx,%ecx
106fbb: eb 12 jmp 106fcf <vprintk+0x20b>
}
count = 0;
while ((n = num / base) > 0) {
toPrint[count++] = (num - (n*base));
106fbd: 8b 45 b4 mov -0x4c(%ebp),%eax
106fc0: 0f af c6 imul %esi,%eax
106fc3: 28 c3 sub %al,%bl
106fc5: 88 5c 0d e0 mov %bl,-0x20(%ebp,%ecx,1)
106fc9: 8b 4d b8 mov -0x48(%ebp),%ecx
106fcc: 8b 5d b4 mov -0x4c(%ebp),%ebx
num = -num;
if (maxwidth) maxwidth--;
}
count = 0;
while ((n = num / base) > 0) {
106fcf: 89 d8 mov %ebx,%eax
106fd1: 31 d2 xor %edx,%edx
106fd3: f7 f6 div %esi
106fd5: 89 45 b4 mov %eax,-0x4c(%ebp)
106fd8: 85 c0 test %eax,%eax
106fda: 8d 41 01 lea 0x1(%ecx),%eax
106fdd: 89 45 b8 mov %eax,-0x48(%ebp)
106fe0: 75 db jne 106fbd <vprintk+0x1f9>
toPrint[count++] = (num - (n*base));
num = n;
}
toPrint[count++] = num;
106fe2: 88 5c 0d e0 mov %bl,-0x20(%ebp,%ecx,1)
for (n=maxwidth ; n > count; n-- )
106fe6: 8b 5d c4 mov -0x3c(%ebp),%ebx
BSP_output_char(lead);
106fe9: 0f be 75 c8 movsbl -0x38(%ebp),%esi
106fed: eb 0e jmp 106ffd <vprintk+0x239>
106fef: 83 ec 0c sub $0xc,%esp
106ff2: 56 push %esi
106ff3: ff 15 fc 93 11 00 call *0x1193fc
toPrint[count++] = (num - (n*base));
num = n;
}
toPrint[count++] = num;
for (n=maxwidth ; n > count; n-- )
106ff9: 4b dec %ebx
106ffa: 83 c4 10 add $0x10,%esp
106ffd: 3b 5d b8 cmp -0x48(%ebp),%ebx
107000: 77 ed ja 106fef <vprintk+0x22b>
107002: 31 db xor %ebx,%ebx
BSP_output_char(lead);
for (n = 0; n < count; n++) {
BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
107004: 8d 75 f4 lea -0xc(%ebp),%esi
107007: 03 75 b8 add -0x48(%ebp),%esi
10700a: eb 1e jmp 10702a <vprintk+0x266>
10700c: 83 ec 0c sub $0xc,%esp
10700f: 89 d8 mov %ebx,%eax
107011: f7 d0 not %eax
107013: 0f be 44 30 ec movsbl -0x14(%eax,%esi,1),%eax
107018: 0f be 80 36 72 11 00 movsbl 0x117236(%eax),%eax
10701f: 50 push %eax
107020: ff 15 fc 93 11 00 call *0x1193fc
toPrint[count++] = num;
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
107026: 43 inc %ebx
107027: 83 c4 10 add $0x10,%esp
10702a: 3b 5d b8 cmp -0x48(%ebp),%ebx
10702d: 72 dd jb 10700c <vprintk+0x248>
10702f: eb 10 jmp 107041 <vprintk+0x27d>
if (base)
printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int),
base, sign, width, lead);
} else {
BSP_output_char(*fmt);
107031: 83 ec 0c sub $0xc,%esp
107034: 0f be c0 movsbl %al,%eax
107037: 50 push %eax
107038: ff 15 fc 93 11 00 call *0x1193fc
10703e: 83 c4 10 add $0x10,%esp
)
{
char c, *str;
int lflag, base, sign, width, lead, minus;
for (; *fmt != '\0'; fmt++) {
107041: 47 inc %edi
107042: 8a 07 mov (%edi),%al
107044: 84 c0 test %al,%al
107046: 0f 85 89 fd ff ff jne 106dd5 <vprintk+0x11>
10704c: eb 08 jmp 107056 <vprintk+0x292>
base, sign, width, lead);
} else {
BSP_output_char(*fmt);
}
}
}
10704e: 8b 55 d0 mov -0x30(%ebp),%edx
107051: 89 55 0c mov %edx,0xc(%ebp)
107054: eb eb jmp 107041 <vprintk+0x27d>
107056: 8d 65 f4 lea -0xc(%ebp),%esp
107059: 5b pop %ebx
10705a: 5e pop %esi
10705b: 5f pop %edi
10705c: c9 leave
10705d: c3 ret
00115950 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
115950: 55 push %ebp
115951: 89 e5 mov %esp,%ebp
115953: 56 push %esi
115954: 53 push %ebx
115955: 8b 45 08 mov 0x8(%ebp),%eax
115958: 8b 75 0c mov 0xc(%ebp),%esi
11595b: 8b 4d 10 mov 0x10(%ebp),%ecx
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
11595e: 3b 05 d8 92 11 00 cmp 0x1192d8,%eax
115964: 73 2d jae 115993 <write+0x43> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
115966: 6b d8 34 imul $0x34,%eax,%ebx
115969: 03 1d 38 d6 11 00 add 0x11d638,%ebx
rtems_libio_check_is_open( iop );
11596f: 8b 53 0c mov 0xc(%ebx),%edx
115972: f6 c6 01 test $0x1,%dh
115975: 74 1c je 115993 <write+0x43> <== NEVER TAKEN
rtems_libio_check_buffer( buffer );
115977: 85 f6 test %esi,%esi
115979: 75 0d jne 115988 <write+0x38> <== ALWAYS TAKEN
11597b: e8 a8 97 ff ff call 10f128 <__errno> <== NOT EXECUTED
115980: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
115986: eb 2d jmp 1159b5 <write+0x65> <== NOT EXECUTED
rtems_libio_check_count( count );
115988: 31 c0 xor %eax,%eax
11598a: 85 c9 test %ecx,%ecx
11598c: 74 3c je 1159ca <write+0x7a>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
11598e: 80 e2 04 and $0x4,%dl
115991: 75 0d jne 1159a0 <write+0x50> <== ALWAYS TAKEN
115993: e8 90 97 ff ff call 10f128 <__errno> <== NOT EXECUTED
115998: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
11599e: eb 15 jmp 1159b5 <write+0x65> <== NOT EXECUTED
/*
* Now process the write() request.
*/
if ( !iop->handlers->write_h )
1159a0: 8b 43 30 mov 0x30(%ebx),%eax
1159a3: 8b 40 0c mov 0xc(%eax),%eax
1159a6: 85 c0 test %eax,%eax
1159a8: 75 10 jne 1159ba <write+0x6a> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
1159aa: e8 79 97 ff ff call 10f128 <__errno> <== NOT EXECUTED
1159af: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
1159b5: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
1159b8: eb 10 jmp 1159ca <write+0x7a> <== NOT EXECUTED
rc = (*iop->handlers->write_h)( iop, buffer, count );
1159ba: 52 push %edx
1159bb: 51 push %ecx
1159bc: 56 push %esi
1159bd: 53 push %ebx
1159be: ff d0 call *%eax
if ( rc > 0 )
1159c0: 83 c4 10 add $0x10,%esp
1159c3: 85 c0 test %eax,%eax
1159c5: 7e 03 jle 1159ca <write+0x7a> <== NEVER TAKEN
iop->offset += rc;
1159c7: 01 43 08 add %eax,0x8(%ebx)
return rc;
}
1159ca: 8d 65 f8 lea -0x8(%ebp),%esp
1159cd: 5b pop %ebx
1159ce: 5e pop %esi
1159cf: c9 leave
1159d0: c3 ret