RTEMS 4.9.6Annotated Report
Sun Jul 24 20:38:11 2011
0010d840 <IMFS_Set_handlers>:
#define MAXSYMLINK 5
int IMFS_Set_handlers(
rtems_filesystem_location_info_t *loc
)
{
10d840: 55 push %ebp
10d841: 89 e5 mov %esp,%ebp
10d843: 8b 55 08 mov 0x8(%ebp),%edx
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
10d846: 8b 42 0c mov 0xc(%edx),%eax
10d849: 8b 48 2c mov 0x2c(%eax),%ecx
switch( node->type ) {
10d84c: 8b 02 mov (%edx),%eax
10d84e: 83 78 4c 06 cmpl $0x6,0x4c(%eax)
10d852: 77 12 ja 10d866 <IMFS_Set_handlers+0x26><== NEVER TAKEN
10d854: 8b 40 4c mov 0x4c(%eax),%eax
10d857: ff 24 85 40 89 11 00 jmp *0x118940(,%eax,4)
10d85e: 66 90 xchg %ax,%ax
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
10d860: 8b 41 08 mov 0x8(%ecx),%eax
10d863: 89 42 04 mov %eax,0x4(%edx)
loc->handlers = fs_info->memfile_handlers;
break;
}
return 0;
}
10d866: 31 c0 xor %eax,%eax
10d868: c9 leave
10d869: c3 ret
10d86a: 66 90 xchg %ax,%ax
break;
case IMFS_LINEAR_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
10d86c: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED
10d86f: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED
break;
}
return 0;
}
10d872: 31 c0 xor %eax,%eax <== NOT EXECUTED
10d874: c9 leave <== NOT EXECUTED
10d875: c3 ret <== NOT EXECUTED
10d876: 66 90 xchg %ax,%ax <== NOT EXECUTED
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
break;
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
10d878: c7 42 04 80 8a 11 00 movl $0x118a80,0x4(%edx) <== NOT EXECUTED
loc->handlers = fs_info->memfile_handlers;
break;
}
return 0;
}
10d87f: 31 c0 xor %eax,%eax <== NOT EXECUTED
10d881: c9 leave <== NOT EXECUTED
10d882: c3 ret <== NOT EXECUTED
10d883: 90 nop <== NOT EXECUTED
switch( node->type ) {
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
10d884: c7 42 04 40 8a 11 00 movl $0x118a40,0x4(%edx)
loc->handlers = fs_info->memfile_handlers;
break;
}
return 0;
}
10d88b: 31 c0 xor %eax,%eax
10d88d: c9 leave
10d88e: c3 ret
0010fac4 <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
10fac4: 55 push %ebp
10fac5: 89 e5 mov %esp,%ebp
10fac7: 57 push %edi
10fac8: 56 push %esi
10fac9: 53 push %ebx
10faca: 83 ec 1c sub $0x1c,%esp
10facd: 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 )
10fad0: 8b 5d 08 mov 0x8(%ebp),%ebx
10fad3: 85 db test %ebx,%ebx
10fad5: 0f 84 29 01 00 00 je 10fc04 <IMFS_create_node+0x140>
parent = parent_loc->node_access;
10fadb: 8b 45 08 mov 0x8(%ebp),%eax
10fade: 8b 38 mov (%eax),%edi
/*
* Allocate an IMFS jnode
*/
node = calloc( 1, sizeof( IMFS_jnode_t ) );
10fae0: 83 ec 08 sub $0x8,%esp
10fae3: 6a 60 push $0x60
10fae5: 6a 01 push $0x1
10fae7: e8 d0 e9 ff ff call 10e4bc <calloc>
10faec: 89 c3 mov %eax,%ebx
if ( !node )
10faee: 83 c4 10 add $0x10,%esp
10faf1: 85 c0 test %eax,%eax
10faf3: 0f 84 9f 00 00 00 je 10fb98 <IMFS_create_node+0xd4> <== NEVER TAKEN
/*
* Fill in the basic information
*/
node->st_nlink = 1;
10faf9: 66 c7 40 34 01 00 movw $0x1,0x34(%eax)
node->type = type;
10faff: 8b 55 0c mov 0xc(%ebp),%edx
10fb02: 89 50 4c mov %edx,0x4c(%eax)
strncpy( node->name, name, IMFS_NAME_MAX );
10fb05: 51 push %ecx
10fb06: 6a 20 push $0x20
10fb08: ff 75 10 pushl 0x10(%ebp)
10fb0b: 8d 40 0c lea 0xc(%eax),%eax
10fb0e: 50 push %eax
10fb0f: e8 94 18 00 00 call 1113a8 <strncpy>
/*
* Fill in the mode and permission information for the jnode structure.
*/
node->st_mode = mode & ~rtems_filesystem_umask;
10fb14: a1 b4 c4 11 00 mov 0x11c4b4,%eax
10fb19: 8b 40 24 mov 0x24(%eax),%eax
10fb1c: f7 d0 not %eax
10fb1e: 21 c6 and %eax,%esi
10fb20: 89 73 30 mov %esi,0x30(%ebx)
#if defined(RTEMS_POSIX_API)
node->st_uid = geteuid();
node->st_gid = getegid();
#else
node->st_uid = 0;
10fb23: 66 c7 43 3c 00 00 movw $0x0,0x3c(%ebx)
node->st_gid = 0;
10fb29: 66 c7 43 3e 00 00 movw $0x0,0x3e(%ebx)
/*
* Now set all the times.
*/
gettimeofday( &tv, 0 );
10fb2f: 58 pop %eax
10fb30: 5a pop %edx
10fb31: 6a 00 push $0x0
10fb33: 8d 45 ec lea -0x14(%ebp),%eax
10fb36: 50 push %eax
10fb37: e8 18 eb ff ff call 10e654 <gettimeofday>
node->stat_atime = (time_t) tv.tv_sec;
10fb3c: 8b 45 ec mov -0x14(%ebp),%eax
10fb3f: 89 43 40 mov %eax,0x40(%ebx)
node->stat_mtime = (time_t) tv.tv_sec;
10fb42: 89 43 44 mov %eax,0x44(%ebx)
node->stat_ctime = (time_t) tv.tv_sec;
10fb45: 89 43 48 mov %eax,0x48(%ebx)
/*
* Set the type specific information
*/
switch (type) {
10fb48: 83 c4 10 add $0x10,%esp
10fb4b: 83 7d 0c 06 cmpl $0x6,0xc(%ebp)
10fb4f: 76 53 jbe 10fba4 <IMFS_create_node+0xe0> <== ALWAYS TAKEN
node->info.file.doubly_indirect = 0;
node->info.file.triply_indirect = 0;
break;
default:
assert(0);
10fb51: 68 c8 82 11 00 push $0x1182c8 <== NOT EXECUTED
10fb56: 68 1c 8d 11 00 push $0x118d1c <== NOT EXECUTED
10fb5b: 6a 74 push $0x74 <== NOT EXECUTED
10fb5d: 68 b0 8c 11 00 push $0x118cb0 <== NOT EXECUTED
10fb62: e8 21 73 ff ff call 106e88 <__assert_func> <== NOT EXECUTED
10fb67: 90 nop <== NOT EXECUTED
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;
10fb68: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED
10fb6b: 8b 02 mov (%edx),%eax <== NOT EXECUTED
10fb6d: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED
/*
* If this node has a parent, then put it in that directory list.
*/
if ( parent ) {
10fb70: 85 ff test %edi,%edi
10fb72: 74 24 je 10fb98 <IMFS_create_node+0xd4>
10fb74: 83 ec 08 sub $0x8,%esp
10fb77: 53 push %ebx
10fb78: 8d 47 50 lea 0x50(%edi),%eax
10fb7b: 50 push %eax
10fb7c: e8 fb b1 ff ff call 10ad7c <_Chain_Append>
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
node->Parent = parent;
10fb81: 89 7b 08 mov %edi,0x8(%ebx)
fs_info = parent_loc->mt_entry->fs_info;
10fb84: 8b 55 08 mov 0x8(%ebp),%edx
10fb87: 8b 42 0c mov 0xc(%edx),%eax
10fb8a: 8b 50 2c mov 0x2c(%eax),%edx
node->st_ino = ++fs_info->ino_count;
10fb8d: 8b 02 mov (%edx),%eax
10fb8f: 40 inc %eax
10fb90: 89 02 mov %eax,(%edx)
10fb92: 89 43 38 mov %eax,0x38(%ebx)
10fb95: 83 c4 10 add $0x10,%esp
}
return node;
}
10fb98: 89 d8 mov %ebx,%eax
10fb9a: 8d 65 f4 lea -0xc(%ebp),%esp
10fb9d: 5b pop %ebx
10fb9e: 5e pop %esi
10fb9f: 5f pop %edi
10fba0: c9 leave
10fba1: c3 ret
10fba2: 66 90 xchg %ax,%ax
/*
* Set the type specific information
*/
switch (type) {
10fba4: 8b 45 0c mov 0xc(%ebp),%eax
10fba7: ff 24 85 00 8d 11 00 jmp *0x118d00(,%eax,4)
10fbae: 66 90 xchg %ax,%ax
node->info.device.major = info->device.major;
node->info.device.minor = info->device.minor;
break;
case IMFS_LINEAR_FILE:
node->info.linearfile.size = 0;
10fbb0: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED
node->info.linearfile.direct = 0;
10fbb7: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED
case IMFS_MEMORY_FILE:
node->info.file.size = 0;
10fbbe: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED
node->info.file.indirect = 0;
10fbc5: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED
node->info.file.doubly_indirect = 0;
10fbcc: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED
node->info.file.triply_indirect = 0;
10fbd3: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED
10fbda: eb 94 jmp 10fb70 <IMFS_create_node+0xac> <== NOT EXECUTED
case IMFS_SYM_LINK:
node->info.sym_link.name = info->sym_link.name;
break;
case IMFS_DEVICE:
node->info.device.major = info->device.major;
10fbdc: 8b 55 18 mov 0x18(%ebp),%edx
10fbdf: 8b 02 mov (%edx),%eax
10fbe1: 89 43 50 mov %eax,0x50(%ebx)
node->info.device.minor = info->device.minor;
10fbe4: 8b 42 04 mov 0x4(%edx),%eax
10fbe7: 89 43 54 mov %eax,0x54(%ebx)
10fbea: eb 84 jmp 10fb70 <IMFS_create_node+0xac>
10fbec: 8d 43 54 lea 0x54(%ebx),%eax
10fbef: 89 43 50 mov %eax,0x50(%ebx)
10fbf2: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx)
10fbf9: 8d 43 50 lea 0x50(%ebx),%eax
10fbfc: 89 43 58 mov %eax,0x58(%ebx)
10fbff: e9 6c ff ff ff jmp 10fb70 <IMFS_create_node+0xac>
IMFS_jnode_t *node;
struct timeval tv;
IMFS_jnode_t *parent = NULL;
IMFS_fs_info_t *fs_info;
if ( parent_loc != NULL )
10fc04: 31 ff xor %edi,%edi
10fc06: e9 d5 fe ff ff jmp 10fae0 <IMFS_create_node+0x1c>
0010d9e0 <IMFS_eval_path>:
int IMFS_eval_path(
const char *pathname, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
10d9e0: 55 push %ebp
10d9e1: 89 e5 mov %esp,%ebp
10d9e3: 57 push %edi
10d9e4: 56 push %esi
10d9e5: 53 push %ebx
10d9e6: 83 ec 5c sub $0x5c,%esp
char token[ IMFS_NAME_MAX + 1 ];
rtems_filesystem_location_info_t newloc;
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
10d9e9: f7 45 0c f8 ff ff ff testl $0xfffffff8,0xc(%ebp)
10d9f0: 0f 85 0a 02 00 00 jne 10dc00 <IMFS_eval_path+0x220> <== NEVER TAKEN
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
10d9f6: 8b 45 10 mov 0x10(%ebp),%eax
10d9f9: 8b 30 mov (%eax),%esi
10d9fb: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp)
* 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 );
10da02: 50 push %eax
10da03: 8d 55 f0 lea -0x10(%ebp),%edx
10da06: 52 push %edx
10da07: 8d 4d bf lea -0x41(%ebp),%ecx
10da0a: 51 push %ecx
10da0b: 8b 45 08 mov 0x8(%ebp),%eax
10da0e: 03 45 a4 add -0x5c(%ebp),%eax
10da11: 50 push %eax
10da12: e8 15 06 00 00 call 10e02c <IMFS_get_token>
10da17: 89 c3 mov %eax,%ebx
i += len;
10da19: 8b 45 f0 mov -0x10(%ebp),%eax
if ( !pathloc->node_access )
10da1c: 8b 7d 10 mov 0x10(%ebp),%edi
10da1f: 8b 17 mov (%edi),%edx
10da21: 83 c4 10 add $0x10,%esp
10da24: 85 d2 test %edx,%edx
10da26: 0f 84 94 01 00 00 je 10dbc0 <IMFS_eval_path+0x1e0> <== NEVER TAKEN
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], token, &len );
i += len;
10da2c: 01 45 a4 add %eax,-0x5c(%ebp)
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
10da2f: 85 db test %ebx,%ebx
10da31: 75 51 jne 10da84 <IMFS_eval_path+0xa4>
* 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 ) {
10da33: 83 7a 4c 01 cmpl $0x1,0x4c(%edx)
10da37: 0f 85 2f 01 00 00 jne 10db6c <IMFS_eval_path+0x18c>
if ( node->info.directory.mt_fs != NULL ) {
10da3d: 8b 52 5c mov 0x5c(%edx),%edx
10da40: 85 d2 test %edx,%edx
10da42: 0f 84 24 01 00 00 je 10db6c <IMFS_eval_path+0x18c> <== ALWAYS TAKEN
newloc = node->info.directory.mt_fs->mt_fs_root;
10da48: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED
10da4b: 8d 72 18 lea 0x18(%edx),%esi <== NOT EXECUTED
10da4e: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
10da53: 89 c7 mov %eax,%edi <== NOT EXECUTED
10da55: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
*pathloc = newloc;
10da57: 89 c6 mov %eax,%esi <== NOT EXECUTED
10da59: b1 04 mov $0x4,%cl <== NOT EXECUTED
10da5b: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED
10da5e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc );
10da60: 57 push %edi <== NOT EXECUTED
10da61: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
10da64: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED
10da67: 50 push %eax <== NOT EXECUTED
10da68: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
10da6b: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED
10da6e: 29 4d a4 sub %ecx,-0x5c(%ebp) <== NOT EXECUTED
10da71: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10da74: 03 45 a4 add -0x5c(%ebp),%eax <== NOT EXECUTED
10da77: 50 push %eax <== NOT EXECUTED
10da78: ff 12 call *(%edx) <== NOT EXECUTED
10da7a: 89 c3 mov %eax,%ebx <== NOT EXECUTED
10da7c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10da7f: e9 bc 00 00 00 jmp 10db40 <IMFS_eval_path+0x160> <== NOT EXECUTED
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
10da84: 83 7e 4c 01 cmpl $0x1,0x4c(%esi)
10da88: 0f 84 be 00 00 00 je 10db4c <IMFS_eval_path+0x16c> <== ALWAYS TAKEN
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
10da8e: 89 d6 mov %edx,%esi
switch( type ) {
10da90: 83 fb 03 cmp $0x3,%ebx
10da93: 74 1b je 10dab0 <IMFS_eval_path+0xd0>
10da95: 83 fb 04 cmp $0x4,%ebx
10da98: 0f 84 92 00 00 00 je 10db30 <IMFS_eval_path+0x150> <== NEVER TAKEN
10da9e: 83 fb 02 cmp $0x2,%ebx
10daa1: 74 59 je 10dafc <IMFS_eval_path+0x11c> <== NEVER TAKEN
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
10daa3: 83 fb 04 cmp $0x4,%ebx
10daa6: 0f 85 56 ff ff ff jne 10da02 <IMFS_eval_path+0x22> <== ALWAYS TAKEN
10daac: eb 85 jmp 10da33 <IMFS_eval_path+0x53> <== NOT EXECUTED
10daae: 66 90 xchg %ax,%ax <== NOT EXECUTED
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
10dab0: 8b 42 4c mov 0x4c(%edx),%eax
10dab3: 83 f8 03 cmp $0x3,%eax
10dab6: 0f 84 e0 00 00 00 je 10db9c <IMFS_eval_path+0x1bc> <== NEVER TAKEN
node = pathloc->node_access;
if ( !node )
rtems_set_errno_and_return_minus_one( ENOTDIR );
} else if ( node->type == IMFS_SYM_LINK ) {
10dabc: 83 f8 04 cmp $0x4,%eax
10dabf: 0f 84 54 01 00 00 je 10dc19 <IMFS_eval_path+0x239> <== NEVER TAKEN
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10dac5: 48 dec %eax
10dac6: 0f 85 09 01 00 00 jne 10dbd5 <IMFS_eval_path+0x1f5> <== NEVER TAKEN
/*
* 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 ) {
10dacc: 8b 46 5c mov 0x5c(%esi),%eax
10dacf: 85 c0 test %eax,%eax
10dad1: 0f 85 13 01 00 00 jne 10dbea <IMFS_eval_path+0x20a> <== NEVER TAKEN
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10dad7: 83 ec 08 sub $0x8,%esp
10dada: 8d 7d bf lea -0x41(%ebp),%edi
10dadd: 57 push %edi
10dade: 56 push %esi
10dadf: e8 a4 04 00 00 call 10df88 <IMFS_find_match_in_dir>
10dae4: 89 c6 mov %eax,%esi
if ( !node )
10dae6: 83 c4 10 add $0x10,%esp
10dae9: 85 c0 test %eax,%eax
10daeb: 0f 84 cf 00 00 00 je 10dbc0 <IMFS_eval_path+0x1e0> <== NEVER TAKEN
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
10daf1: 8b 45 10 mov 0x10(%ebp),%eax
10daf4: 89 30 mov %esi,(%eax)
10daf6: e9 07 ff ff ff jmp 10da02 <IMFS_eval_path+0x22>
10dafb: 90 nop
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
10dafc: a1 b4 c4 11 00 mov 0x11c4b4,%eax <== NOT EXECUTED
10db01: 39 50 14 cmp %edx,0x14(%eax) <== NOT EXECUTED
10db04: 0f 84 f8 fe ff ff je 10da02 <IMFS_eval_path+0x22> <== NOT EXECUTED
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
10db0a: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED
10db0d: 8b 41 0c mov 0xc(%ecx),%eax <== NOT EXECUTED
10db10: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED
10db13: 0f 84 27 01 00 00 je 10dc40 <IMFS_eval_path+0x260> <== NOT EXECUTED
*pathloc = newloc;
return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),flags,pathloc);
}
} else {
if ( !node->Parent )
10db19: 8b 72 08 mov 0x8(%edx),%esi <== NOT EXECUTED
10db1c: 85 f6 test %esi,%esi <== NOT EXECUTED
10db1e: 0f 84 9c 00 00 00 je 10dbc0 <IMFS_eval_path+0x1e0> <== NOT EXECUTED
node = node->Parent;
pathloc->node_access = node;
}
pathloc->node_access = node;
10db24: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED
10db27: 89 37 mov %esi,(%edi) <== NOT EXECUTED
10db29: e9 d4 fe ff ff jmp 10da02 <IMFS_eval_path+0x22> <== NOT EXECUTED
10db2e: 66 90 xchg %ax,%ax <== NOT EXECUTED
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
10db30: e8 eb 26 00 00 call 110220 <__errno> <== NOT EXECUTED
10db35: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED
10db3b: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
if ( !IMFS_evaluate_permission( pathloc, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10db40: 89 d8 mov %ebx,%eax
10db42: 8d 65 f4 lea -0xc(%ebp),%esp
10db45: 5b pop %ebx
10db46: 5e pop %esi
10db47: 5f pop %edi
10db48: c9 leave
10db49: c3 ret
10db4a: 66 90 xchg %ax,%ax
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
10db4c: 83 ec 08 sub $0x8,%esp
10db4f: 6a 01 push $0x1
10db51: ff 75 10 pushl 0x10(%ebp)
10db54: e8 37 fd ff ff call 10d890 <IMFS_evaluate_permission>
10db59: 83 c4 10 add $0x10,%esp
10db5c: 85 c0 test %eax,%eax
10db5e: 74 29 je 10db89 <IMFS_eval_path+0x1a9> <== NEVER TAKEN
10db60: 8b 45 10 mov 0x10(%ebp),%eax
10db63: 8b 10 mov (%eax),%edx
10db65: e9 24 ff ff ff jmp 10da8e <IMFS_eval_path+0xae>
10db6a: 66 90 xchg %ax,%ax
return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
10db6c: ff 75 10 pushl 0x10(%ebp)
10db6f: e8 cc fc ff ff call 10d840 <IMFS_Set_handlers>
10db74: 89 c3 mov %eax,%ebx
10db76: 56 push %esi
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
10db77: ff 75 0c pushl 0xc(%ebp)
10db7a: ff 75 10 pushl 0x10(%ebp)
10db7d: e8 0e fd ff ff call 10d890 <IMFS_evaluate_permission>
10db82: 83 c4 10 add $0x10,%esp
10db85: 85 c0 test %eax,%eax
10db87: 75 b7 jne 10db40 <IMFS_eval_path+0x160> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EACCES );
10db89: e8 92 26 00 00 call 110220 <__errno> <== NOT EXECUTED
10db8e: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED
10db94: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
10db99: eb a5 jmp 10db40 <IMFS_eval_path+0x160> <== NOT EXECUTED
10db9b: 90 nop <== NOT EXECUTED
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
IMFS_evaluate_hard_link( pathloc, 0 );
10db9c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10db9f: 6a 00 push $0x0 <== NOT EXECUTED
10dba1: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED
10dba4: e8 27 fd ff ff call 10d8d0 <IMFS_evaluate_hard_link><== NOT EXECUTED
node = pathloc->node_access;
10dba9: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
10dbac: 8b 30 mov (%eax),%esi <== NOT EXECUTED
if ( !node )
10dbae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10dbb1: 85 f6 test %esi,%esi <== NOT EXECUTED
10dbb3: 74 20 je 10dbd5 <IMFS_eval_path+0x1f5> <== NOT EXECUTED
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
node = pathloc->node_access;
10dbb5: 8b 46 4c mov 0x4c(%esi),%eax <== NOT EXECUTED
10dbb8: e9 08 ff ff ff jmp 10dac5 <IMFS_eval_path+0xe5> <== NOT EXECUTED
10dbbd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
if ( !node )
rtems_set_errno_and_return_minus_one( ENOENT );
10dbc0: e8 5b 26 00 00 call 110220 <__errno> <== NOT EXECUTED
10dbc5: c7 00 02 00 00 00 movl $0x2,(%eax) <== NOT EXECUTED
10dbcb: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
10dbd0: e9 6b ff ff ff jmp 10db40 <IMFS_eval_path+0x160> <== NOT EXECUTED
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
10dbd5: e8 46 26 00 00 call 110220 <__errno> <== NOT EXECUTED
10dbda: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
10dbe0: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
10dbe5: e9 56 ff ff ff jmp 10db40 <IMFS_eval_path+0x160> <== NOT EXECUTED
* If we are at a node that is a mount point. Set loc to the
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
10dbea: 8d 55 e0 lea -0x20(%ebp),%edx <== NOT EXECUTED
10dbed: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED
10dbf0: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
10dbf5: 89 d7 mov %edx,%edi <== NOT EXECUTED
10dbf7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
*pathloc = newloc;
10dbf9: 89 d6 mov %edx,%esi <== NOT EXECUTED
10dbfb: e9 59 fe ff ff jmp 10da59 <IMFS_eval_path+0x79> <== NOT EXECUTED
rtems_filesystem_location_info_t newloc;
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
assert( 0 );
10dc00: 68 c8 82 11 00 push $0x1182c8 <== NOT EXECUTED
10dc05: 68 5c 89 11 00 push $0x11895c <== NOT EXECUTED
10dc0a: 68 ea 01 00 00 push $0x1ea <== NOT EXECUTED
10dc0f: 68 6c 89 11 00 push $0x11896c <== NOT EXECUTED
10dc14: e8 6f 92 ff ff call 106e88 <__assert_func> <== NOT EXECUTED
if ( !node )
rtems_set_errno_and_return_minus_one( ENOTDIR );
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
10dc19: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10dc1c: 6a 00 push $0x0 <== NOT EXECUTED
10dc1e: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED
10dc21: e8 02 fd ff ff call 10d928 <IMFS_evaluate_sym_link><== NOT EXECUTED
10dc26: 89 c3 mov %eax,%ebx <== NOT EXECUTED
node = pathloc->node_access;
10dc28: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
10dc2b: 8b 02 mov (%edx),%eax <== NOT EXECUTED
if ( result == -1 )
10dc2d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10dc30: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED
10dc33: 0f 84 07 ff ff ff je 10db40 <IMFS_eval_path+0x160> <== NOT EXECUTED
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
node = pathloc->node_access;
10dc39: 89 c6 mov %eax,%esi <== NOT EXECUTED
10dc3b: e9 75 ff ff ff jmp 10dbb5 <IMFS_eval_path+0x1d5> <== NOT EXECUTED
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
newloc = pathloc->mt_entry->mt_point_node;
10dc40: 8d 55 e0 lea -0x20(%ebp),%edx <== NOT EXECUTED
10dc43: 8d 70 08 lea 0x8(%eax),%esi <== NOT EXECUTED
10dc46: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
10dc4b: 89 d7 mov %edx,%edi <== NOT EXECUTED
10dc4d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
*pathloc = newloc;
10dc4f: 89 d6 mov %edx,%esi <== NOT EXECUTED
10dc51: e9 03 fe ff ff jmp 10da59 <IMFS_eval_path+0x79> <== NOT EXECUTED
0010dd04 <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 */
)
{
10dd04: 55 push %ebp
10dd05: 89 e5 mov %esp,%ebp
10dd07: 57 push %edi
10dd08: 56 push %esi
10dd09: 53 push %ebx
10dd0a: 83 ec 4c sub $0x4c,%esp
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
10dd0d: 8b 45 0c mov 0xc(%ebp),%eax
10dd10: 8b 18 mov (%eax),%ebx
10dd12: 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 );
10dd19: 56 push %esi
10dd1a: 8d 55 f0 lea -0x10(%ebp),%edx
10dd1d: 52 push %edx
10dd1e: 8d 4d bf lea -0x41(%ebp),%ecx
10dd21: 51 push %ecx
10dd22: 8b 45 08 mov 0x8(%ebp),%eax
10dd25: 03 45 b0 add -0x50(%ebp),%eax
10dd28: 50 push %eax
10dd29: e8 fe 02 00 00 call 10e02c <IMFS_get_token>
10dd2e: 89 c6 mov %eax,%esi
i += len;
10dd30: 8b 7d f0 mov -0x10(%ebp),%edi
if ( !pathloc->node_access )
10dd33: 8b 45 0c mov 0xc(%ebp),%eax
10dd36: 8b 10 mov (%eax),%edx
10dd38: 83 c4 10 add $0x10,%esp
10dd3b: 85 d2 test %edx,%edx
10dd3d: 0f 84 1f 01 00 00 je 10de62 <IMFS_evaluate_for_make+0x15e><== NEVER TAKEN
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
10dd43: 85 f6 test %esi,%esi
10dd45: 75 1d jne 10dd64 <IMFS_evaluate_for_make+0x60><== ALWAYS TAKEN
pathloc->node_access = node;
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
10dd47: e8 d4 24 00 00 call 110220 <__errno> <== NOT EXECUTED
10dd4c: c7 00 11 00 00 00 movl $0x11,(%eax) <== NOT EXECUTED
10dd52: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10dd57: 89 d8 mov %ebx,%eax
10dd59: 8d 65 f4 lea -0xc(%ebp),%esp
10dd5c: 5b pop %ebx
10dd5d: 5e pop %esi
10dd5e: 5f pop %edi
10dd5f: c9 leave
10dd60: c3 ret
10dd61: 8d 76 00 lea 0x0(%esi),%esi
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
10dd64: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10dd68: 0f 84 0e 01 00 00 je 10de7c <IMFS_evaluate_for_make+0x178><== ALWAYS TAKEN
*/
while( !done ) {
type = IMFS_get_token( &path[i], token, &len );
i += len;
10dd6e: 01 7d b0 add %edi,-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;
10dd71: 89 d3 mov %edx,%ebx
switch( type ) {
10dd73: 83 fe 02 cmp $0x2,%esi
10dd76: 0f 84 88 00 00 00 je 10de04 <IMFS_evaluate_for_make+0x100><== NEVER TAKEN
10dd7c: 76 26 jbe 10dda4 <IMFS_evaluate_for_make+0xa0>
10dd7e: 83 fe 03 cmp $0x3,%esi
10dd81: 74 2d je 10ddb0 <IMFS_evaluate_for_make+0xac><== ALWAYS TAKEN
10dd83: 83 fe 04 cmp $0x4,%esi <== NOT EXECUTED
10dd86: 75 91 jne 10dd19 <IMFS_evaluate_for_make+0x15><== NOT EXECUTED
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
10dd88: e8 93 24 00 00 call 110220 <__errno> <== NOT EXECUTED
10dd8d: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED
10dd93: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10dd98: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10dd9a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10dd9d: 5b pop %ebx <== NOT EXECUTED
10dd9e: 5e pop %esi <== NOT EXECUTED
10dd9f: 5f pop %edi <== NOT EXECUTED
10dda0: c9 leave <== NOT EXECUTED
10dda1: c3 ret <== NOT EXECUTED
10dda2: 66 90 xchg %ax,%ax <== NOT EXECUTED
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
10dda4: 85 f6 test %esi,%esi
10dda6: 74 9f je 10dd47 <IMFS_evaluate_for_make+0x43><== NEVER TAKEN
10dda8: e9 6c ff ff ff jmp 10dd19 <IMFS_evaluate_for_make+0x15>
10ddad: 8d 76 00 lea 0x0(%esi),%esi
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
10ddb0: 8b 42 4c mov 0x4c(%edx),%eax
10ddb3: 83 f8 03 cmp $0x3,%eax
10ddb6: 0f 84 74 01 00 00 je 10df30 <IMFS_evaluate_for_make+0x22c><== NEVER TAKEN
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
10ddbc: 83 f8 04 cmp $0x4,%eax
10ddbf: 0f 84 90 01 00 00 je 10df55 <IMFS_evaluate_for_make+0x251><== NEVER TAKEN
if ( result == -1 )
return -1;
}
node = pathloc->node_access;
if ( !node )
10ddc5: 85 db test %ebx,%ebx
10ddc7: 0f 84 12 01 00 00 je 10dedf <IMFS_evaluate_for_make+0x1db><== NEVER TAKEN
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10ddcd: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10ddd1: 0f 85 08 01 00 00 jne 10dedf <IMFS_evaluate_for_make+0x1db><== NEVER TAKEN
/*
* 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 ) {
10ddd7: 8b 43 5c mov 0x5c(%ebx),%eax
10ddda: 85 c0 test %eax,%eax
10dddc: 0f 85 12 01 00 00 jne 10def4 <IMFS_evaluate_for_make+0x1f0><== NEVER TAKEN
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10dde2: 83 ec 08 sub $0x8,%esp
10dde5: 8d 45 bf lea -0x41(%ebp),%eax
10dde8: 50 push %eax
10dde9: 53 push %ebx
10ddea: e8 99 01 00 00 call 10df88 <IMFS_find_match_in_dir>
10ddef: 89 c3 mov %eax,%ebx
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
10ddf1: 83 c4 10 add $0x10,%esp
10ddf4: 85 c0 test %eax,%eax
10ddf6: 74 3c je 10de34 <IMFS_evaluate_for_make+0x130>
done = true;
else
pathloc->node_access = node;
10ddf8: 8b 55 0c mov 0xc(%ebp),%edx
10ddfb: 89 02 mov %eax,(%edx)
10ddfd: e9 17 ff ff ff jmp 10dd19 <IMFS_evaluate_for_make+0x15>
10de02: 66 90 xchg %ax,%ax
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
10de04: a1 b4 c4 11 00 mov 0x11c4b4,%eax <== NOT EXECUTED
10de09: 39 50 14 cmp %edx,0x14(%eax) <== NOT EXECUTED
10de0c: 0f 84 07 ff ff ff je 10dd19 <IMFS_evaluate_for_make+0x15><== NOT EXECUTED
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){
10de12: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
10de15: 8b 41 0c mov 0xc(%ecx),%eax <== NOT EXECUTED
10de18: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED
10de1b: 0f 84 5b 01 00 00 je 10df7c <IMFS_evaluate_for_make+0x278><== NOT EXECUTED
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
10de21: 8b 5a 08 mov 0x8(%edx),%ebx <== NOT EXECUTED
10de24: 85 db test %ebx,%ebx <== NOT EXECUTED
10de26: 74 3a je 10de62 <IMFS_evaluate_for_make+0x15e><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOENT );
node = node->Parent;
}
pathloc->node_access = node;
10de28: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10de2b: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
10de2d: e9 e7 fe ff ff jmp 10dd19 <IMFS_evaluate_for_make+0x15><== NOT EXECUTED
10de32: 66 90 xchg %ax,%ax <== NOT EXECUTED
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
10de34: 8b 45 b0 mov -0x50(%ebp),%eax
10de37: 2b 45 f0 sub -0x10(%ebp),%eax
10de3a: 03 45 08 add 0x8(%ebp),%eax
10de3d: 8b 4d 10 mov 0x10(%ebp),%ecx
10de40: 89 01 mov %eax,(%ecx)
/*
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++) {
10de42: 8b 45 08 mov 0x8(%ebp),%eax
10de45: 03 45 b0 add -0x50(%ebp),%eax
10de48: 8a 10 mov (%eax),%dl
10de4a: 84 d2 test %dl,%dl
10de4c: 75 0a jne 10de58 <IMFS_evaluate_for_make+0x154><== NEVER TAKEN
10de4e: eb 4c jmp 10de9c <IMFS_evaluate_for_make+0x198>
10de50: 8a 50 01 mov 0x1(%eax),%dl <== NOT EXECUTED
10de53: 40 inc %eax <== NOT EXECUTED
10de54: 84 d2 test %dl,%dl <== NOT EXECUTED
10de56: 74 44 je 10de9c <IMFS_evaluate_for_make+0x198><== NOT EXECUTED
if ( !IMFS_is_separator( path[ i ] ) )
10de58: 80 fa 2f cmp $0x2f,%dl <== NOT EXECUTED
10de5b: 74 f3 je 10de50 <IMFS_evaluate_for_make+0x14c><== NOT EXECUTED
10de5d: 80 fa 5c cmp $0x5c,%dl <== NOT EXECUTED
10de60: 74 ee je 10de50 <IMFS_evaluate_for_make+0x14c><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOENT );
10de62: e8 b9 23 00 00 call 110220 <__errno> <== NOT EXECUTED
10de67: c7 00 02 00 00 00 movl $0x2,(%eax) <== NOT EXECUTED
10de6d: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10de72: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10de74: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10de77: 5b pop %ebx <== NOT EXECUTED
10de78: 5e pop %esi <== NOT EXECUTED
10de79: 5f pop %edi <== NOT EXECUTED
10de7a: c9 leave <== NOT EXECUTED
10de7b: c3 ret <== NOT EXECUTED
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
10de7c: 83 ec 08 sub $0x8,%esp
10de7f: 6a 01 push $0x1
10de81: ff 75 0c pushl 0xc(%ebp)
10de84: e8 07 fa ff ff call 10d890 <IMFS_evaluate_permission>
10de89: 83 c4 10 add $0x10,%esp
10de8c: 85 c0 test %eax,%eax
10de8e: 74 3a je 10deca <IMFS_evaluate_for_make+0x1c6><== NEVER TAKEN
10de90: 8b 4d 0c mov 0xc(%ebp),%ecx
10de93: 8b 11 mov (%ecx),%edx
10de95: e9 d4 fe ff ff jmp 10dd6e <IMFS_evaluate_for_make+0x6a>
10de9a: 66 90 xchg %ax,%ax
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
10de9c: ff 75 0c pushl 0xc(%ebp)
10de9f: e8 9c f9 ff ff call 10d840 <IMFS_Set_handlers>
10dea4: 89 c3 mov %eax,%ebx
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
10dea6: 8b 55 0c mov 0xc(%ebp),%edx
10dea9: 8b 02 mov (%edx),%eax
10deab: 5a pop %edx
10deac: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
10deb0: 75 2d jne 10dedf <IMFS_evaluate_for_make+0x1db><== NEVER TAKEN
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
10deb2: 83 ec 08 sub $0x8,%esp
10deb5: 6a 03 push $0x3
10deb7: ff 75 0c pushl 0xc(%ebp)
10deba: e8 d1 f9 ff ff call 10d890 <IMFS_evaluate_permission>
10debf: 83 c4 10 add $0x10,%esp
10dec2: 85 c0 test %eax,%eax
10dec4: 0f 85 8d fe ff ff jne 10dd57 <IMFS_evaluate_for_make+0x53><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EACCES );
10deca: e8 51 23 00 00 call 110220 <__errno> <== NOT EXECUTED
10decf: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED
10ded5: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
10deda: e9 78 fe ff ff jmp 10dd57 <IMFS_evaluate_for_make+0x53><== NOT EXECUTED
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
10dedf: e8 3c 23 00 00 call 110220 <__errno> <== NOT EXECUTED
10dee4: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
10deea: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED
10deef: e9 63 fe ff ff jmp 10dd57 <IMFS_evaluate_for_make+0x53><== NOT EXECUTED
* If we are at a node that is a mount point. Set loc to the
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
10def4: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED
10def7: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED
10defa: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
10deff: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
*pathloc = newloc;
10df01: 8d 75 e0 lea -0x20(%ebp),%esi <== NOT EXECUTED
10df04: b1 04 mov $0x4,%cl <== NOT EXECUTED
10df06: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED
10df09: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
10df0b: 51 push %ecx <== NOT EXECUTED
10df0c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10df0f: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED
10df12: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED
10df15: 50 push %eax <== NOT EXECUTED
10df16: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED
10df19: 29 4d b0 sub %ecx,-0x50(%ebp) <== NOT EXECUTED
10df1c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10df1f: 03 45 b0 add -0x50(%ebp),%eax <== NOT EXECUTED
10df22: 50 push %eax <== NOT EXECUTED
10df23: ff 52 04 call *0x4(%edx) <== NOT EXECUTED
10df26: 89 c3 mov %eax,%ebx <== NOT EXECUTED
10df28: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10df2b: e9 27 fe ff ff jmp 10dd57 <IMFS_evaluate_for_make+0x53><== NOT EXECUTED
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
10df30: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10df33: 6a 00 push $0x0 <== NOT EXECUTED
10df35: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
10df38: e8 1b fd ff ff call 10dc58 <IMFS_evaluate_link> <== NOT EXECUTED
10df3d: 89 c3 mov %eax,%ebx <== NOT EXECUTED
if ( result == -1 )
10df3f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10df42: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED
10df45: 0f 84 0c fe ff ff je 10dd57 <IMFS_evaluate_for_make+0x53><== NOT EXECUTED
10df4b: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
10df4e: 8b 1a mov (%edx),%ebx <== NOT EXECUTED
10df50: e9 70 fe ff ff jmp 10ddc5 <IMFS_evaluate_for_make+0xc1><== NOT EXECUTED
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
10df55: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10df58: 6a 00 push $0x0 <== NOT EXECUTED
10df5a: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
10df5d: e8 f6 fc ff ff call 10dc58 <IMFS_evaluate_link> <== NOT EXECUTED
10df62: 89 c3 mov %eax,%ebx <== NOT EXECUTED
if ( result == -1 )
10df64: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10df67: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED
10df6a: 0f 84 e7 fd ff ff je 10dd57 <IMFS_evaluate_for_make+0x53><== NOT EXECUTED
10df70: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
10df73: 8b 19 mov (%ecx),%ebx <== NOT EXECUTED
10df75: e9 4b fe ff ff jmp 10ddc5 <IMFS_evaluate_for_make+0xc1><== NOT EXECUTED
10df7a: 66 90 xchg %ax,%ax <== NOT EXECUTED
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
10df7c: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED
10df7f: 8d 70 08 lea 0x8(%eax),%esi <== NOT EXECUTED
10df82: e9 73 ff ff ff jmp 10defa <IMFS_evaluate_for_make+0x1f6><== NOT EXECUTED
0010d8d0 <IMFS_evaluate_hard_link>:
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
10d8d0: 55 push %ebp <== NOT EXECUTED
10d8d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10d8d3: 53 push %ebx <== NOT EXECUTED
10d8d4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED
10d8d7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
IMFS_jnode_t *jnode = node->node_access;
10d8da: 8b 03 mov (%ebx),%eax <== NOT EXECUTED
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_HARD_LINK )
10d8dc: 83 78 4c 03 cmpl $0x3,0x4c(%eax) <== NOT EXECUTED
10d8e0: 75 38 jne 10d91a <IMFS_evaluate_hard_link+0x4a><== NOT EXECUTED
/*
* Set the hard link value and the handlers.
*/
node->node_access = jnode->info.hard_link.link_node;
10d8e2: 8b 40 50 mov 0x50(%eax),%eax <== NOT EXECUTED
10d8e5: 89 03 mov %eax,(%ebx) <== NOT EXECUTED
IMFS_Set_handlers( node );
10d8e7: 53 push %ebx <== NOT EXECUTED
10d8e8: e8 53 ff ff ff call 10d840 <IMFS_Set_handlers> <== NOT EXECUTED
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
10d8ed: 50 push %eax <== NOT EXECUTED
10d8ee: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
10d8f1: 53 push %ebx <== NOT EXECUTED
10d8f2: e8 99 ff ff ff call 10d890 <IMFS_evaluate_permission><== NOT EXECUTED
10d8f7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10d8fa: 85 c0 test %eax,%eax <== NOT EXECUTED
10d8fc: 74 0a je 10d908 <IMFS_evaluate_hard_link+0x38><== NOT EXECUTED
10d8fe: 31 c0 xor %eax,%eax <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10d900: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10d903: c9 leave <== NOT EXECUTED
10d904: c3 ret <== NOT EXECUTED
10d905: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
10d908: e8 13 29 00 00 call 110220 <__errno> <== NOT EXECUTED
10d90d: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED
10d913: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10d918: eb e6 jmp 10d900 <IMFS_evaluate_hard_link+0x30><== NOT EXECUTED
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_HARD_LINK )
rtems_fatal_error_occurred (0xABCD0000);
10d91a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10d91d: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED
10d922: e8 5d d1 ff ff call 10aa84 <rtems_fatal_error_occurred><== NOT EXECUTED
0010dc58 <IMFS_evaluate_link>:
int IMFS_evaluate_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
10dc58: 55 push %ebp <== NOT EXECUTED
10dc59: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10dc5b: 57 push %edi <== NOT EXECUTED
10dc5c: 56 push %esi <== NOT EXECUTED
10dc5d: 53 push %ebx <== NOT EXECUTED
10dc5e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10dc61: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
10dc64: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED
10dc67: 8b 15 b4 c4 11 00 mov 0x11c4b4,%edx <== NOT EXECUTED
10dc6d: eb 0e jmp 10dc7d <IMFS_evaluate_link+0x25><== NOT EXECUTED
10dc6f: 90 nop <== NOT EXECUTED
*/
if ( jnode->type == IMFS_HARD_LINK )
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
10dc70: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED
10dc73: 74 53 je 10dcc8 <IMFS_evaluate_link+0x70><== NOT EXECUTED
result = IMFS_evaluate_sym_link( node, flags );
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
( jnode->type == IMFS_HARD_LINK ) ) );
10dc75: 83 e8 03 sub $0x3,%eax <== NOT EXECUTED
10dc78: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED
10dc7b: 77 3a ja 10dcb7 <IMFS_evaluate_link+0x5f><== NOT EXECUTED
{
IMFS_jnode_t *jnode;
int result = 0;
do {
jnode = node->node_access;
10dc7d: 8b 1e mov (%esi),%ebx <== NOT EXECUTED
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
10dc7f: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED
10dc82: 40 inc %eax <== NOT EXECUTED
10dc83: 66 89 42 28 mov %ax,0x28(%edx) <== NOT EXECUTED
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
10dc87: 66 83 f8 05 cmp $0x5,%ax <== NOT EXECUTED
10dc8b: 77 57 ja 10dce4 <IMFS_evaluate_link+0x8c><== NOT EXECUTED
/*
* Follow the Link node.
*/
if ( jnode->type == IMFS_HARD_LINK )
10dc8d: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED
10dc90: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED
10dc93: 75 db jne 10dc70 <IMFS_evaluate_link+0x18><== NOT EXECUTED
result = IMFS_evaluate_hard_link( node, flags );
10dc95: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10dc98: 57 push %edi <== NOT EXECUTED
10dc99: 56 push %esi <== NOT EXECUTED
10dc9a: e8 31 fc ff ff call 10d8d0 <IMFS_evaluate_hard_link><== NOT EXECUTED
10dc9f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
else if (jnode->type == IMFS_SYM_LINK )
result = IMFS_evaluate_sym_link( node, flags );
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
( jnode->type == IMFS_HARD_LINK ) ) );
10dca2: 85 c0 test %eax,%eax <== NOT EXECUTED
10dca4: 75 33 jne 10dcd9 <IMFS_evaluate_link+0x81><== NOT EXECUTED
10dca6: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED
10dca9: 8b 15 b4 c4 11 00 mov 0x11c4b4,%edx <== NOT EXECUTED
10dcaf: 83 e8 03 sub $0x3,%eax <== NOT EXECUTED
10dcb2: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED
10dcb5: 76 c6 jbe 10dc7d <IMFS_evaluate_link+0x25><== NOT EXECUTED
10dcb7: 31 c0 xor %eax,%eax <== NOT EXECUTED
/*
* Clear link counter.
*/
rtems_filesystem_link_counts = 0;
10dcb9: 66 c7 42 28 00 00 movw $0x0,0x28(%edx) <== NOT EXECUTED
return result;
}
10dcbf: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10dcc2: 5b pop %ebx <== NOT EXECUTED
10dcc3: 5e pop %esi <== NOT EXECUTED
10dcc4: 5f pop %edi <== NOT EXECUTED
10dcc5: c9 leave <== NOT EXECUTED
10dcc6: c3 ret <== NOT EXECUTED
10dcc7: 90 nop <== NOT EXECUTED
if ( jnode->type == IMFS_HARD_LINK )
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
result = IMFS_evaluate_sym_link( node, flags );
10dcc8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10dccb: 57 push %edi <== NOT EXECUTED
10dccc: 56 push %esi <== NOT EXECUTED
10dccd: e8 56 fc ff ff call 10d928 <IMFS_evaluate_sym_link><== NOT EXECUTED
10dcd2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
( jnode->type == IMFS_HARD_LINK ) ) );
10dcd5: 85 c0 test %eax,%eax <== NOT EXECUTED
10dcd7: 74 cd je 10dca6 <IMFS_evaluate_link+0x4e><== NOT EXECUTED
10dcd9: 8b 15 b4 c4 11 00 mov 0x11c4b4,%edx <== NOT EXECUTED
10dcdf: eb d8 jmp 10dcb9 <IMFS_evaluate_link+0x61><== NOT EXECUTED
10dce1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
rtems_filesystem_link_counts = 0;
10dce4: 66 c7 42 28 00 00 movw $0x0,0x28(%edx) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ELOOP );
10dcea: e8 31 25 00 00 call 110220 <__errno> <== NOT EXECUTED
10dcef: c7 00 5c 00 00 00 movl $0x5c,(%eax) <== NOT EXECUTED
10dcf5: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
*/
rtems_filesystem_link_counts = 0;
return result;
}
10dcfa: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10dcfd: 5b pop %ebx <== NOT EXECUTED
10dcfe: 5e pop %esi <== NOT EXECUTED
10dcff: 5f pop %edi <== NOT EXECUTED
10dd00: c9 leave <== NOT EXECUTED
10dd01: c3 ret <== NOT EXECUTED
0010d890 <IMFS_evaluate_permission>:
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
10d890: 55 push %ebp
10d891: 89 e5 mov %esp,%ebp
10d893: 83 ec 08 sub $0x8,%esp
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
10d896: f7 45 0c f8 ff ff ff testl $0xfffffff8,0xc(%ebp)
10d89d: 75 1d jne 10d8bc <IMFS_evaluate_permission+0x2c><== NEVER TAKEN
/*
* If all of the flags are set we have permission
* to do this.
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
10d89f: 8b 55 0c mov 0xc(%ebp),%edx
10d8a2: c1 e2 06 shl $0x6,%edx
10d8a5: 8b 4d 08 mov 0x8(%ebp),%ecx
10d8a8: 8b 01 mov (%ecx),%eax
10d8aa: 8b 40 30 mov 0x30(%eax),%eax
10d8ad: 21 d0 and %edx,%eax
10d8af: 39 c2 cmp %eax,%edx
10d8b1: 0f 94 c0 sete %al
10d8b4: 0f b6 c0 movzbl %al,%eax
return 1;
return 0;
}
10d8b7: c9 leave
10d8b8: c3 ret
10d8b9: 8d 76 00 lea 0x0(%esi),%esi
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
10d8bc: e8 5f 29 00 00 call 110220 <__errno> <== NOT EXECUTED
10d8c1: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
10d8c7: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
return 1;
return 0;
}
10d8cc: c9 leave <== NOT EXECUTED
10d8cd: c3 ret <== NOT EXECUTED
0010d928 <IMFS_evaluate_sym_link>:
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
10d928: 55 push %ebp <== NOT EXECUTED
10d929: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10d92b: 57 push %edi <== NOT EXECUTED
10d92c: 56 push %esi <== NOT EXECUTED
10d92d: 53 push %ebx <== NOT EXECUTED
10d92e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10d931: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED
IMFS_jnode_t *jnode = node->node_access;
10d934: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
10d937: 8b 02 mov (%edx),%eax <== NOT EXECUTED
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_SYM_LINK )
10d939: 83 78 4c 04 cmpl $0x4,0x4c(%eax) <== NOT EXECUTED
10d93d: 0f 85 83 00 00 00 jne 10d9c6 <IMFS_evaluate_sym_link+0x9e><== NOT EXECUTED
rtems_fatal_error_occurred (0xABCD0000);
if ( !jnode->Parent )
10d943: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED
10d946: 85 d2 test %edx,%edx <== NOT EXECUTED
10d948: 0f 84 85 00 00 00 je 10d9d3 <IMFS_evaluate_sym_link+0xab><== 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;
10d94e: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
10d951: 89 11 mov %edx,(%ecx) <== NOT EXECUTED
rtems_filesystem_get_sym_start_loc(
10d953: 8b 50 50 mov 0x50(%eax),%edx <== NOT EXECUTED
10d956: 8a 02 mov (%edx),%al <== NOT EXECUTED
10d958: 3c 2f cmp $0x2f,%al <== NOT EXECUTED
10d95a: 74 0c je 10d968 <IMFS_evaluate_sym_link+0x40><== NOT EXECUTED
10d95c: 3c 5c cmp $0x5c,%al <== NOT EXECUTED
10d95e: 74 08 je 10d968 <IMFS_evaluate_sym_link+0x40><== NOT EXECUTED
10d960: 84 c0 test %al,%al <== NOT EXECUTED
10d962: 74 04 je 10d968 <IMFS_evaluate_sym_link+0x40><== NOT EXECUTED
10d964: 31 c0 xor %eax,%eax <== NOT EXECUTED
10d966: eb 17 jmp 10d97f <IMFS_evaluate_sym_link+0x57><== NOT EXECUTED
10d968: a1 b4 c4 11 00 mov 0x11c4b4,%eax <== NOT EXECUTED
10d96d: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED
10d970: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
10d975: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED
10d978: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
10d97a: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
/*
* Use eval path to evaluate the path of the symbolic link.
*/
result = IMFS_eval_path(
10d97f: 51 push %ecx <== NOT EXECUTED
10d980: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
10d983: 53 push %ebx <== NOT EXECUTED
10d984: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED
10d987: 50 push %eax <== NOT EXECUTED
10d988: e8 53 00 00 00 call 10d9e0 <IMFS_eval_path> <== NOT EXECUTED
10d98d: 89 c6 mov %eax,%esi <== NOT EXECUTED
&jnode->info.sym_link.name[i],
flags,
node
);
IMFS_Set_handlers( node );
10d98f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
10d992: e8 a9 fe ff ff call 10d840 <IMFS_Set_handlers> <== NOT EXECUTED
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
10d997: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10d99a: 53 push %ebx <== NOT EXECUTED
10d99b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
10d99e: e8 ed fe ff ff call 10d890 <IMFS_evaluate_permission><== NOT EXECUTED
10d9a3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10d9a6: 85 c0 test %eax,%eax <== NOT EXECUTED
10d9a8: 74 0a je 10d9b4 <IMFS_evaluate_sym_link+0x8c><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10d9aa: 89 f0 mov %esi,%eax <== NOT EXECUTED
10d9ac: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10d9af: 5b pop %ebx <== NOT EXECUTED
10d9b0: 5e pop %esi <== NOT EXECUTED
10d9b1: 5f pop %edi <== NOT EXECUTED
10d9b2: c9 leave <== NOT EXECUTED
10d9b3: c3 ret <== NOT EXECUTED
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
10d9b4: e8 67 28 00 00 call 110220 <__errno> <== NOT EXECUTED
10d9b9: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED
10d9bf: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED
10d9c4: eb e4 jmp 10d9aa <IMFS_evaluate_sym_link+0x82><== NOT EXECUTED
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_SYM_LINK )
rtems_fatal_error_occurred (0xABCD0000);
10d9c6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10d9c9: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED
10d9ce: e8 b1 d0 ff ff call 10aa84 <rtems_fatal_error_occurred><== NOT EXECUTED
if ( !jnode->Parent )
rtems_fatal_error_occurred( 0xBAD00000 );
10d9d3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10d9d6: 68 00 00 d0 ba push $0xbad00000 <== NOT EXECUTED
10d9db: e8 a4 d0 ff ff call 10aa84 <rtems_fatal_error_occurred><== NOT EXECUTED
0010fc0c <IMFS_fchmod>:
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
10fc0c: 55 push %ebp <== NOT EXECUTED
10fc0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10fc0f: 53 push %ebx <== NOT EXECUTED
10fc10: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED
10fc13: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = loc->node_access;
10fc16: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10fc19: 8b 18 mov (%eax),%ebx <== NOT EXECUTED
#endif
/*
* Change only the RWX permissions on the jnode to mode.
*/
if ( mode & (~ (S_IRWXU | S_IRWXG | S_IRWXO ) ) )
10fc1b: f7 c2 00 fe ff ff test $0xfffffe00,%edx <== NOT EXECUTED
10fc21: 75 2d jne 10fc50 <IMFS_fchmod+0x44> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO);
jnode->st_mode |= mode;
10fc23: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED
10fc26: 25 00 fe ff ff and $0xfffffe00,%eax <== NOT EXECUTED
10fc2b: 09 c2 or %eax,%edx <== NOT EXECUTED
10fc2d: 89 53 30 mov %edx,0x30(%ebx) <== NOT EXECUTED
IMFS_update_ctime( jnode );
10fc30: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10fc33: 6a 00 push $0x0 <== NOT EXECUTED
10fc35: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED
10fc38: 50 push %eax <== NOT EXECUTED
10fc39: e8 16 ea ff ff call 10e654 <gettimeofday> <== NOT EXECUTED
10fc3e: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED
10fc41: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED
10fc44: 31 c0 xor %eax,%eax <== NOT EXECUTED
10fc46: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return 0;
}
10fc49: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10fc4c: c9 leave <== NOT EXECUTED
10fc4d: c3 ret <== NOT EXECUTED
10fc4e: 66 90 xchg %ax,%ax <== NOT EXECUTED
/*
* Change only the RWX permissions on the jnode to mode.
*/
if ( mode & (~ (S_IRWXU | S_IRWXG | S_IRWXO ) ) )
rtems_set_errno_and_return_minus_one( EPERM );
10fc50: e8 cb 05 00 00 call 110220 <__errno> <== NOT EXECUTED
10fc55: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
10fc5b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10fc60: eb e7 jmp 10fc49 <IMFS_fchmod+0x3d> <== NOT EXECUTED
0010df88 <IMFS_find_match_in_dir>:
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
10df88: 55 push %ebp
10df89: 89 e5 mov %esp,%ebp
10df8b: 57 push %edi
10df8c: 56 push %esi
10df8d: 53 push %ebx
10df8e: 83 ec 0c sub $0xc,%esp
10df91: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Check for fatal errors. A NULL directory show a problem in the
* the IMFS code.
*/
assert( directory );
10df94: 85 db test %ebx,%ebx
10df96: 74 50 je 10dfe8 <IMFS_find_match_in_dir+0x60><== NEVER TAKEN
if ( !name )
10df98: 8b 45 0c mov 0xc(%ebp),%eax
10df9b: 85 c0 test %eax,%eax
10df9d: 74 3d je 10dfdc <IMFS_find_match_in_dir+0x54><== NEVER TAKEN
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
10df9f: bf 16 8a 11 00 mov $0x118a16,%edi
10dfa4: b9 02 00 00 00 mov $0x2,%ecx
10dfa9: 8b 75 0c mov 0xc(%ebp),%esi
10dfac: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10dfae: 75 0c jne 10dfbc <IMFS_find_match_in_dir+0x34><== ALWAYS TAKEN
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
10dfb0: 89 d8 mov %ebx,%eax
10dfb2: 8d 65 f4 lea -0xc(%ebp),%esp
10dfb5: 5b pop %ebx
10dfb6: 5e pop %esi
10dfb7: 5f pop %edi
10dfb8: c9 leave
10dfb9: c3 ret
10dfba: 66 90 xchg %ax,%ax
*/
if ( !strcmp( name, dotname ) )
return directory;
if ( !strcmp( name, dotdotname ) )
10dfbc: bf 18 8a 11 00 mov $0x118a18,%edi
10dfc1: b9 03 00 00 00 mov $0x3,%ecx
10dfc6: 8b 75 0c mov 0xc(%ebp),%esi
10dfc9: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10dfcb: 75 31 jne 10dffe <IMFS_find_match_in_dir+0x76><== ALWAYS TAKEN
return directory->Parent;
10dfcd: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
10dfd0: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10dfd2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10dfd5: 5b pop %ebx <== NOT EXECUTED
10dfd6: 5e pop %esi <== NOT EXECUTED
10dfd7: 5f pop %edi <== NOT EXECUTED
10dfd8: c9 leave <== NOT EXECUTED
10dfd9: c3 ret <== NOT EXECUTED
10dfda: 66 90 xchg %ax,%ax <== NOT EXECUTED
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
!rtems_chain_is_tail( the_chain, the_node );
10dfdc: 31 db xor %ebx,%ebx
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
10dfde: 89 d8 mov %ebx,%eax
10dfe0: 8d 65 f4 lea -0xc(%ebp),%esp
10dfe3: 5b pop %ebx
10dfe4: 5e pop %esi
10dfe5: 5f pop %edi
10dfe6: c9 leave
10dfe7: c3 ret
/*
* Check for fatal errors. A NULL directory show a problem in the
* the IMFS code.
*/
assert( directory );
10dfe8: 68 ba 89 11 00 push $0x1189ba <== NOT EXECUTED
10dfed: 68 1b 8a 11 00 push $0x118a1b <== NOT EXECUTED
10dff2: 6a 2a push $0x2a <== NOT EXECUTED
10dff4: 68 c4 89 11 00 push $0x1189c4 <== NOT EXECUTED
10dff9: e8 8a 8e ff ff call 106e88 <__assert_func> <== NOT EXECUTED
if ( !strcmp( name, dotdotname ) )
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
10dffe: 8b 7b 50 mov 0x50(%ebx),%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
10e001: 83 c3 54 add $0x54,%ebx
!rtems_chain_is_tail( the_chain, the_node );
10e004: 39 df cmp %ebx,%edi
10e006: 75 0a jne 10e012 <IMFS_find_match_in_dir+0x8a>
10e008: eb d2 jmp 10dfdc <IMFS_find_match_in_dir+0x54>
10e00a: 66 90 xchg %ax,%ax
the_node = the_node->next ) {
10e00c: 8b 3f mov (%edi),%edi
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
!rtems_chain_is_tail( the_chain, the_node );
10e00e: 39 df cmp %ebx,%edi
10e010: 74 ca je 10dfdc <IMFS_find_match_in_dir+0x54><== ALWAYS TAKEN
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
if ( !strcmp( name, the_jnode->name ) )
10e012: 8d 47 0c lea 0xc(%edi),%eax
10e015: 83 ec 08 sub $0x8,%esp
10e018: 50 push %eax
10e019: ff 75 0c pushl 0xc(%ebp)
10e01c: e8 a7 32 00 00 call 1112c8 <strcmp>
10e021: 83 c4 10 add $0x10,%esp
10e024: 85 c0 test %eax,%eax
10e026: 75 e4 jne 10e00c <IMFS_find_match_in_dir+0x84>
10e028: 89 fb mov %edi,%ebx
10e02a: eb 84 jmp 10dfb0 <IMFS_find_match_in_dir+0x28>
0010e02c <IMFS_get_token>:
IMFS_token_types IMFS_get_token(
const char *path,
char *token,
int *token_len
)
{
10e02c: 55 push %ebp
10e02d: 89 e5 mov %esp,%ebp
10e02f: 57 push %edi
10e030: 56 push %esi
10e031: 53 push %ebx
10e032: 83 ec 08 sub $0x8,%esp
10e035: 8b 4d 08 mov 0x8(%ebp),%ecx
10e038: 8b 5d 0c mov 0xc(%ebp),%ebx
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
10e03b: 8a 01 mov (%ecx),%al
while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) {
10e03d: 3c 2f cmp $0x2f,%al
10e03f: 0f 84 99 00 00 00 je 10e0de <IMFS_get_token+0xb2>
10e045: 3c 5c cmp $0x5c,%al
10e047: 0f 84 91 00 00 00 je 10e0de <IMFS_get_token+0xb2> <== NEVER TAKEN
10e04d: 84 c0 test %al,%al
10e04f: 0f 84 a2 00 00 00 je 10e0f7 <IMFS_get_token+0xcb>
token[i] = c;
10e055: 88 03 mov %al,(%ebx)
10e057: 31 d2 xor %edx,%edx
10e059: eb 06 jmp 10e061 <IMFS_get_token+0x35>
10e05b: 90 nop
10e05c: 88 04 13 mov %al,(%ebx,%edx,1)
if ( i == IMFS_NAME_MAX )
10e05f: 74 3f je 10e0a0 <IMFS_get_token+0x74> <== NEVER TAKEN
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
10e061: 42 inc %edx
10e062: 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) ) {
10e065: 3c 2f cmp $0x2f,%al
10e067: 74 0d je 10e076 <IMFS_get_token+0x4a>
10e069: 3c 5c cmp $0x5c,%al
10e06b: 74 09 je 10e076 <IMFS_get_token+0x4a> <== NEVER TAKEN
10e06d: 84 c0 test %al,%al
10e06f: 74 05 je 10e076 <IMFS_get_token+0x4a>
10e071: 83 fa 20 cmp $0x20,%edx
10e074: 7e e6 jle 10e05c <IMFS_get_token+0x30> <== ALWAYS TAKEN
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
10e076: 80 7c 13 ff 00 cmpb $0x0,-0x1(%ebx,%edx,1)
10e07b: 75 33 jne 10e0b0 <IMFS_get_token+0x84> <== ALWAYS TAKEN
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
10e07d: 8b 45 10 mov 0x10(%ebp),%eax
10e080: 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 ) {
if ( strcmp( token, "..") == 0 )
10e082: bf 93 84 11 00 mov $0x118493,%edi
10e087: b9 03 00 00 00 mov $0x3,%ecx
10e08c: 89 de mov %ebx,%esi
10e08e: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10e090: 75 26 jne 10e0b8 <IMFS_get_token+0x8c> <== ALWAYS TAKEN
10e092: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
}
return type;
}
10e097: 83 c4 08 add $0x8,%esp
10e09a: 5b pop %ebx
10e09b: 5e pop %esi
10e09c: 5f pop %edi
10e09d: c9 leave
10e09e: c3 ret
10e09f: 90 nop
c = path[i];
while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) {
token[i] = c;
if ( i == IMFS_NAME_MAX )
10e0a0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
}
return type;
}
10e0a5: 83 c4 08 add $0x8,%esp <== NOT EXECUTED
10e0a8: 5b pop %ebx <== NOT EXECUTED
10e0a9: 5e pop %esi <== NOT EXECUTED
10e0aa: 5f pop %edi <== NOT EXECUTED
10e0ab: c9 leave <== NOT EXECUTED
10e0ac: c3 ret <== NOT EXECUTED
10e0ad: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
token[i] = '\0';
10e0b0: c6 04 13 00 movb $0x0,(%ebx,%edx,1)
10e0b4: eb c7 jmp 10e07d <IMFS_get_token+0x51>
10e0b6: 66 90 xchg %ax,%ax
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
10e0b8: bf 94 84 11 00 mov $0x118494,%edi
10e0bd: b9 02 00 00 00 mov $0x2,%ecx
10e0c2: 89 de mov %ebx,%esi
10e0c4: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10e0c6: 0f 97 c0 seta %al
10e0c9: 0f 92 c2 setb %dl
10e0cc: 28 d0 sub %dl,%al
10e0ce: 0f be c0 movsbl %al,%eax
10e0d1: 83 f8 01 cmp $0x1,%eax
10e0d4: 19 c0 sbb %eax,%eax
10e0d6: 83 e0 fe and $0xfffffffe,%eax
10e0d9: 83 c0 03 add $0x3,%eax
10e0dc: eb b9 jmp 10e097 <IMFS_get_token+0x6b>
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
token[i] = c;
10e0de: 88 03 mov %al,(%ebx)
10e0e0: ba 01 00 00 00 mov $0x1,%edx
10e0e5: b8 01 00 00 00 mov $0x1,%eax
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
10e0ea: 8b 4d 10 mov 0x10(%ebp),%ecx
10e0ed: 89 11 mov %edx,(%ecx)
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
}
return type;
}
10e0ef: 83 c4 08 add $0x8,%esp
10e0f2: 5b pop %ebx
10e0f3: 5e pop %esi
10e0f4: 5f pop %edi
10e0f5: c9 leave
10e0f6: c3 ret
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
token[i] = c;
10e0f7: c6 03 00 movb $0x0,(%ebx)
10e0fa: 31 d2 xor %edx,%edx
10e0fc: 31 c0 xor %eax,%eax
10e0fe: eb ea jmp 10e0ea <IMFS_get_token+0xbe>
0010e100 <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
)
{
10e100: 55 push %ebp
10e101: 89 e5 mov %esp,%ebp
10e103: 57 push %edi
10e104: 56 push %esi
10e105: 53 push %ebx
10e106: 83 ec 0c sub $0xc,%esp
10e109: 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,
10e10c: 8b 0d 44 a0 11 00 mov 0x11a044,%ecx
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16;
!is_valid && (bit_mask <= 512);
bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
10e112: 83 f9 10 cmp $0x10,%ecx
10e115: 74 18 je 10e12f <IMFS_initialize_support+0x2f><== NEVER TAKEN
10e117: ba 20 00 00 00 mov $0x20,%edx
10e11c: 31 c0 xor %eax,%eax
10e11e: 39 d1 cmp %edx,%ecx
10e120: 74 0d je 10e12f <IMFS_initialize_support+0x2f>
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16;
!is_valid && (bit_mask <= 512);
bit_mask <<= 1) {
10e122: d1 e2 shl %edx
10e124: 40 inc %eax
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16;
!is_valid && (bit_mask <= 512);
10e125: 83 f8 05 cmp $0x5,%eax
10e128: 75 f4 jne 10e11e <IMFS_initialize_support+0x1e><== ALWAYS TAKEN
10e12a: b9 80 00 00 00 mov $0x80,%ecx <== NOT EXECUTED
bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
is_valid = true;
}
}
*dest_bytes_per_block = ((is_valid)
10e12f: 89 0d c8 e3 11 00 mov %ecx,0x11e3c8
* 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(
10e135: 83 ec 0c sub $0xc,%esp
10e138: 6a 00 push $0x0
10e13a: 68 ed 41 00 00 push $0x41ed
10e13f: 68 c6 85 11 00 push $0x1185c6
10e144: 6a 01 push $0x1
10e146: 6a 00 push $0x0
10e148: e8 77 19 00 00 call 10fac4 <IMFS_create_node>
10e14d: 89 43 18 mov %eax,0x18(%ebx)
"",
( S_IFDIR | 0755 ),
NULL
);
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
10e150: 8b 45 14 mov 0x14(%ebp),%eax
10e153: 89 43 1c mov %eax,0x1c(%ebx)
temp_mt_entry->mt_fs_root.ops = op_table;
10e156: 8b 45 0c mov 0xc(%ebp),%eax
10e159: 89 43 20 mov %eax,0x20(%ebx)
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
10e15c: 8d 7b 30 lea 0x30(%ebx),%edi
10e15f: be 80 8c 11 00 mov $0x118c80,%esi
10e164: b9 0c 00 00 00 mov $0xc,%ecx
10e169: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
10e16b: 83 c4 18 add $0x18,%esp
10e16e: 6a 0c push $0xc
10e170: 6a 01 push $0x1
10e172: e8 45 03 00 00 call 10e4bc <calloc>
if ( !fs_info ){
10e177: 83 c4 10 add $0x10,%esp
10e17a: 85 c0 test %eax,%eax
10e17c: 74 29 je 10e1a7 <IMFS_initialize_support+0xa7><== NEVER TAKEN
free(temp_mt_entry->mt_fs_root.node_access);
rtems_set_errno_and_return_minus_one(ENOMEM);
}
temp_mt_entry->fs_info = fs_info;
10e17e: 89 43 2c mov %eax,0x2c(%ebx)
/*
* Set st_ino for the root to 1.
*/
fs_info->ino_count = 1;
10e181: c7 00 01 00 00 00 movl $0x1,(%eax)
fs_info->memfile_handlers = memfile_handlers;
10e187: 8b 55 10 mov 0x10(%ebp),%edx
10e18a: 89 50 04 mov %edx,0x4(%eax)
fs_info->directory_handlers = directory_handlers;
10e18d: 8b 55 14 mov 0x14(%ebp),%edx
10e190: 89 50 08 mov %edx,0x8(%eax)
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
10e193: 8b 43 18 mov 0x18(%ebx),%eax
10e196: c7 40 38 01 00 00 00 movl $0x1,0x38(%eax)
10e19d: 31 c0 xor %eax,%eax
return 0;
}
10e19f: 8d 65 f4 lea -0xc(%ebp),%esp
10e1a2: 5b pop %ebx
10e1a3: 5e pop %esi
10e1a4: 5f pop %edi
10e1a5: c9 leave
10e1a6: c3 ret
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
if ( !fs_info ){
free(temp_mt_entry->mt_fs_root.node_access);
10e1a7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10e1aa: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED
10e1ad: e8 0e 8f ff ff call 1070c0 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
10e1b2: e8 69 20 00 00 call 110220 <__errno> <== NOT EXECUTED
10e1b7: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
10e1bd: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10e1c2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10e1c5: eb d8 jmp 10e19f <IMFS_initialize_support+0x9f><== NOT EXECUTED
0010e1c8 <IMFS_mknod>:
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
10e1c8: 55 push %ebp
10e1c9: 89 e5 mov %esp,%ebp
10e1cb: 57 push %edi
10e1cc: 56 push %esi
10e1cd: 53 push %ebx
10e1ce: 83 ec 50 sub $0x50,%esp
10e1d1: 8b 5d 10 mov 0x10(%ebp),%ebx
10e1d4: 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 );
10e1d7: 8d 45 f0 lea -0x10(%ebp),%eax
10e1da: 50 push %eax
10e1db: 8d 7d bf lea -0x41(%ebp),%edi
10e1de: 57 push %edi
10e1df: ff 75 08 pushl 0x8(%ebp)
10e1e2: e8 45 fe ff ff call 10e02c <IMFS_get_token>
/*
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
10e1e7: 8b 45 0c mov 0xc(%ebp),%eax
10e1ea: 25 00 f0 00 00 and $0xf000,%eax
10e1ef: 83 c4 10 add $0x10,%esp
10e1f2: 3d 00 40 00 00 cmp $0x4000,%eax
10e1f7: 74 4f je 10e248 <IMFS_mknod+0x80>
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
10e1f9: 3d 00 80 00 00 cmp $0x8000,%eax
10e1fe: 74 40 je 10e240 <IMFS_mknod+0x78> <== NEVER TAKEN
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
10e200: 3d 00 60 00 00 cmp $0x6000,%eax
10e205: 74 07 je 10e20e <IMFS_mknod+0x46> <== NEVER TAKEN
10e207: 3d 00 20 00 00 cmp $0x2000,%eax
10e20c: 75 42 jne 10e250 <IMFS_mknod+0x88> <== NEVER TAKEN
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
10e20e: 89 5d e0 mov %ebx,-0x20(%ebp)
10e211: 89 75 e4 mov %esi,-0x1c(%ebp)
10e214: ba 02 00 00 00 mov $0x2,%edx
/*
* Allocate and fill in an IMFS jnode
*/
new_node = IMFS_create_node(
10e219: 83 ec 0c sub $0xc,%esp
10e21c: 8d 45 e0 lea -0x20(%ebp),%eax
10e21f: 50 push %eax
10e220: ff 75 0c pushl 0xc(%ebp)
10e223: 57 push %edi
10e224: 52 push %edx
10e225: ff 75 18 pushl 0x18(%ebp)
10e228: e8 97 18 00 00 call 10fac4 <IMFS_create_node>
new_name,
mode,
&info
);
if ( !new_node )
10e22d: 83 c4 20 add $0x20,%esp
10e230: 85 c0 test %eax,%eax
10e232: 74 2e je 10e262 <IMFS_mknod+0x9a> <== NEVER TAKEN
10e234: 31 c0 xor %eax,%eax
rtems_set_errno_and_return_minus_one( ENOMEM );
return 0;
}
10e236: 8d 65 f4 lea -0xc(%ebp),%esp
10e239: 5b pop %ebx
10e23a: 5e pop %esi
10e23b: 5f pop %edi
10e23c: c9 leave
10e23d: c3 ret
10e23e: 66 90 xchg %ax,%ax
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
10e240: ba 05 00 00 00 mov $0x5,%edx <== NOT EXECUTED
10e245: eb d2 jmp 10e219 <IMFS_mknod+0x51> <== NOT EXECUTED
10e247: 90 nop <== NOT EXECUTED
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
} else {
rtems_set_errno_and_return_minus_one( EINVAL );
10e248: ba 01 00 00 00 mov $0x1,%edx
10e24d: eb ca jmp 10e219 <IMFS_mknod+0x51>
10e24f: 90 nop
10e250: e8 cb 1f 00 00 call 110220 <__errno> <== NOT EXECUTED
10e255: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
10e25b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10e260: eb d4 jmp 10e236 <IMFS_mknod+0x6e> <== NOT EXECUTED
mode,
&info
);
if ( !new_node )
rtems_set_errno_and_return_minus_one( ENOMEM );
10e262: e8 b9 1f 00 00 call 110220 <__errno> <== NOT EXECUTED
10e267: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
10e26d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10e272: eb c2 jmp 10e236 <IMFS_mknod+0x6e> <== NOT EXECUTED
0010e284 <IMFS_rmnod>:
*/
int IMFS_rmnod(
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
10e284: 55 push %ebp <== NOT EXECUTED
10e285: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10e287: 56 push %esi <== NOT EXECUTED
10e288: 53 push %ebx <== NOT EXECUTED
10e289: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
10e28c: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
10e28f: 8b 1e mov (%esi),%ebx <== NOT EXECUTED
/*
* Take the node out of the parent's chain that contains this node
*/
if ( the_jnode->Parent != NULL ) {
10e291: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED
10e294: 85 c0 test %eax,%eax <== NOT EXECUTED
10e296: 74 13 je 10e2ab <IMFS_rmnod+0x27> <== NOT EXECUTED
10e298: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10e29b: 53 push %ebx <== NOT EXECUTED
10e29c: e8 a3 0d 00 00 call 10f044 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract( (rtems_chain_node *) the_jnode );
the_jnode->Parent = NULL;
10e2a1: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED
10e2a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
/*
* Decrement the link counter and see if we can free the space.
*/
the_jnode->st_nlink--;
10e2ab: 66 ff 4b 34 decw 0x34(%ebx) <== NOT EXECUTED
IMFS_update_ctime( the_jnode );
10e2af: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10e2b2: 6a 00 push $0x0 <== NOT EXECUTED
10e2b4: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED
10e2b7: 50 push %eax <== NOT EXECUTED
10e2b8: e8 97 03 00 00 call 10e654 <gettimeofday> <== NOT EXECUTED
10e2bd: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED
10e2c0: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED
/*
* 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) ) {
10e2c3: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10e2c6: e8 41 04 00 00 call 10e70c <rtems_libio_is_file_open><== NOT EXECUTED
10e2cb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10e2ce: 85 c0 test %eax,%eax <== NOT EXECUTED
10e2d0: 75 26 jne 10e2f8 <IMFS_rmnod+0x74> <== NOT EXECUTED
10e2d2: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) <== NOT EXECUTED
10e2d7: 75 1f jne 10e2f8 <IMFS_rmnod+0x74> <== NOT EXECUTED
/*
* Is rtems_filesystem_current this node?
*/
if ( rtems_filesystem_current.node_access == pathloc->node_access )
10e2d9: 8b 15 b4 c4 11 00 mov 0x11c4b4,%edx <== NOT EXECUTED
10e2df: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED
10e2e2: 3b 06 cmp (%esi),%eax <== NOT EXECUTED
10e2e4: 74 36 je 10e31c <IMFS_rmnod+0x98> <== NOT EXECUTED
/*
* Free memory associated with a memory file.
*/
if ( the_jnode->type == IMFS_SYM_LINK ) {
10e2e6: 83 7b 4c 04 cmpl $0x4,0x4c(%ebx) <== NOT EXECUTED
10e2ea: 74 18 je 10e304 <IMFS_rmnod+0x80> <== NOT EXECUTED
if ( the_jnode->info.sym_link.name )
free( (void*) the_jnode->info.sym_link.name );
}
free( the_jnode );
10e2ec: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10e2ef: 53 push %ebx <== NOT EXECUTED
10e2f0: e8 cb 8d ff ff call 1070c0 <free> <== NOT EXECUTED
10e2f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
return 0;
}
10e2f8: 31 c0 xor %eax,%eax <== NOT EXECUTED
10e2fa: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10e2fd: 5b pop %ebx <== NOT EXECUTED
10e2fe: 5e pop %esi <== NOT EXECUTED
10e2ff: c9 leave <== NOT EXECUTED
10e300: c3 ret <== NOT EXECUTED
10e301: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
/*
* Free memory associated with a memory file.
*/
if ( the_jnode->type == IMFS_SYM_LINK ) {
if ( the_jnode->info.sym_link.name )
10e304: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED
10e307: 85 c0 test %eax,%eax <== NOT EXECUTED
10e309: 74 e1 je 10e2ec <IMFS_rmnod+0x68> <== NOT EXECUTED
free( (void*) the_jnode->info.sym_link.name );
10e30b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10e30e: 50 push %eax <== NOT EXECUTED
10e30f: e8 ac 8d ff ff call 1070c0 <free> <== NOT EXECUTED
10e314: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10e317: eb d3 jmp 10e2ec <IMFS_rmnod+0x68> <== NOT EXECUTED
10e319: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
/*
* Is rtems_filesystem_current this node?
*/
if ( rtems_filesystem_current.node_access == pathloc->node_access )
rtems_filesystem_current.node_access = NULL;
10e31c: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED
10e323: eb c1 jmp 10e2e6 <IMFS_rmnod+0x62> <== NOT EXECUTED
0010e328 <IMFS_stat>:
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
10e328: 55 push %ebp
10e329: 89 e5 mov %esp,%ebp
10e32b: 53 push %ebx
10e32c: 83 ec 04 sub $0x4,%esp
10e32f: 8b 5d 0c mov 0xc(%ebp),%ebx
IMFS_jnode_t *the_jnode;
IMFS_device_t *io;
the_jnode = loc->node_access;
10e332: 8b 45 08 mov 0x8(%ebp),%eax
10e335: 8b 08 mov (%eax),%ecx
switch ( the_jnode->type ) {
10e337: 8b 41 4c mov 0x4c(%ecx),%eax
10e33a: 83 f8 04 cmp $0x4,%eax
10e33d: 74 6d je 10e3ac <IMFS_stat+0x84> <== NEVER TAKEN
10e33f: 7f 1b jg 10e35c <IMFS_stat+0x34> <== NEVER TAKEN
10e341: 83 f8 02 cmp $0x2,%eax
10e344: 74 72 je 10e3b8 <IMFS_stat+0x90> <== ALWAYS TAKEN
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
10e346: e8 d5 1e 00 00 call 110220 <__errno> <== NOT EXECUTED
10e34b: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10e351: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
buf->st_ctime = the_jnode->stat_ctime;
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
return 0;
}
10e356: 5a pop %edx <== NOT EXECUTED
10e357: 5b pop %ebx <== NOT EXECUTED
10e358: c9 leave <== NOT EXECUTED
10e359: c3 ret <== NOT EXECUTED
10e35a: 66 90 xchg %ax,%ax <== NOT EXECUTED
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
10e35c: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED
10e35f: 7f e5 jg 10e346 <IMFS_stat+0x1e> <== NOT EXECUTED
buf->st_dev = rtems_filesystem_make_dev_t( io->major, io->minor );
break;
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
10e361: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED
10e364: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
break;
}
buf->st_mode = the_jnode->st_mode;
10e367: 8b 41 30 mov 0x30(%ecx),%eax
10e36a: 89 43 0c mov %eax,0xc(%ebx)
buf->st_nlink = the_jnode->st_nlink;
10e36d: 8b 41 34 mov 0x34(%ecx),%eax
10e370: 66 89 43 10 mov %ax,0x10(%ebx)
buf->st_ino = the_jnode->st_ino;
10e374: 8b 41 38 mov 0x38(%ecx),%eax
10e377: 89 43 08 mov %eax,0x8(%ebx)
buf->st_uid = the_jnode->st_uid;
10e37a: 8b 41 3c mov 0x3c(%ecx),%eax
10e37d: 66 89 43 12 mov %ax,0x12(%ebx)
buf->st_gid = the_jnode->st_gid;
10e381: 66 8b 41 3e mov 0x3e(%ecx),%ax
10e385: 66 89 43 14 mov %ax,0x14(%ebx)
buf->st_atime = the_jnode->stat_atime;
10e389: 8b 41 40 mov 0x40(%ecx),%eax
10e38c: 89 43 24 mov %eax,0x24(%ebx)
buf->st_mtime = the_jnode->stat_mtime;
10e38f: 8b 41 44 mov 0x44(%ecx),%eax
10e392: 89 43 2c mov %eax,0x2c(%ebx)
buf->st_ctime = the_jnode->stat_ctime;
10e395: 8b 41 48 mov 0x48(%ecx),%eax
10e398: 89 43 34 mov %eax,0x34(%ebx)
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
10e39b: a1 44 a0 11 00 mov 0x11a044,%eax
10e3a0: 89 43 3c mov %eax,0x3c(%ebx)
10e3a3: 31 c0 xor %eax,%eax
return 0;
}
10e3a5: 5a pop %edx
10e3a6: 5b pop %ebx
10e3a7: c9 leave
10e3a8: c3 ret
10e3a9: 8d 76 00 lea 0x0(%esi),%esi
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
break;
case IMFS_SYM_LINK:
buf->st_size = 0;
10e3ac: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED
10e3b3: eb b2 jmp 10e367 <IMFS_stat+0x3f> <== NOT EXECUTED
10e3b5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
switch ( the_jnode->type ) {
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_dev = rtems_filesystem_make_dev_t( io->major, io->minor );
10e3b8: 8b 51 54 mov 0x54(%ecx),%edx
10e3bb: 8b 41 50 mov 0x50(%ecx),%eax
10e3be: 89 03 mov %eax,(%ebx)
10e3c0: 89 53 04 mov %edx,0x4(%ebx)
10e3c3: eb a2 jmp 10e367 <IMFS_stat+0x3f>
0010725c <RTEMS_Malloc_Initialize>:
void RTEMS_Malloc_Initialize(
void *start,
size_t length,
size_t sbrk_amount
)
{
10725c: 55 push %ebp
10725d: 89 e5 mov %esp,%ebp
10725f: 57 push %edi
107260: 53 push %ebx
107261: 8b 5d 0c mov 0xc(%ebp),%ebx
#endif
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers )
107264: a1 e4 c9 11 00 mov 0x11c9e4,%eax
107269: 85 c0 test %eax,%eax
10726b: 74 02 je 10726f <RTEMS_Malloc_Initialize+0x13><== ALWAYS TAKEN
(*rtems_malloc_statistics_helpers->initialize)();
10726d: ff 10 call *(%eax) <== NOT EXECUTED
/*
* Initialize the garbage collection list to start with nothing on it.
*/
malloc_deferred_frees_initialize();
10726f: e8 80 ff ff ff call 1071f4 <malloc_deferred_frees_initialize>
starting_address = start;
/*
* Initialize the optional sbrk support for extending the heap
*/
if (rtems_malloc_sbrk_helpers) {
107274: a1 e8 c9 11 00 mov 0x11c9e8,%eax
107279: 85 c0 test %eax,%eax
10727b: 74 4b je 1072c8 <RTEMS_Malloc_Initialize+0x6c><== ALWAYS TAKEN
starting_address = (*rtems_malloc_sbrk_helpers->initialize)(
10727d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
107280: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED
107283: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
107286: ff 10 call *(%eax) <== NOT EXECUTED
107288: 89 c2 mov %eax,%edx <== NOT EXECUTED
10728a: 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() )
10728d: a1 f4 e6 11 00 mov 0x11e6f4,%eax
107292: 80 78 28 00 cmpb $0x0,0x28(%eax)
107296: 75 24 jne 1072bc <RTEMS_Malloc_Initialize+0x60><== NEVER TAKEN
void *starting_address,
size_t size,
uint32_t page_size
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
107298: 6a 04 push $0x4
10729a: 53 push %ebx
10729b: 52 push %edx
10729c: 68 00 e5 11 00 push $0x11e500
1072a1: e8 92 40 00 00 call 10b338 <_Heap_Initialize>
&RTEMS_Malloc_Heap,
starting_address,
length,
CPU_HEAP_ALIGNMENT
);
if ( !status )
1072a6: 83 c4 10 add $0x10,%esp
1072a9: 85 c0 test %eax,%eax
1072ab: 74 20 je 1072cd <RTEMS_Malloc_Initialize+0x71><== NEVER TAKEN
rtems_print_buffer( (start + length) - 48, 48 );
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
}
#endif
MSBUMP(space_available, length);
1072ad: 01 1d 60 e5 11 00 add %ebx,0x11e560
}
1072b3: 8d 65 f8 lea -0x8(%ebp),%esp
1072b6: 5b pop %ebx
1072b7: 5f pop %edi
1072b8: c9 leave
1072b9: c3 ret
1072ba: 66 90 xchg %ax,%ax
* 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() )
memset( starting_address, 0, length );
1072bc: 31 c0 xor %eax,%eax
1072be: 89 d7 mov %edx,%edi <== NOT EXECUTED
1072c0: 89 d9 mov %ebx,%ecx <== NOT EXECUTED
1072c2: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED
1072c4: eb d2 jmp 107298 <RTEMS_Malloc_Initialize+0x3c><== NOT EXECUTED
1072c6: 66 90 xchg %ax,%ax <== NOT EXECUTED
starting_address = start;
/*
* Initialize the optional sbrk support for extending the heap
*/
if (rtems_malloc_sbrk_helpers) {
1072c8: 8b 55 08 mov 0x8(%ebp),%edx
1072cb: eb c0 jmp 10728d <RTEMS_Malloc_Initialize+0x31>
starting_address,
length,
CPU_HEAP_ALIGNMENT
);
if ( !status )
rtems_fatal_error_occurred( status );
1072cd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1072d0: 6a 00 push $0x0 <== NOT EXECUTED
1072d2: e8 ad 37 00 00 call 10aa84 <rtems_fatal_error_occurred><== NOT EXECUTED
0010737c <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
10737c: 55 push %ebp <== NOT EXECUTED
10737d: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10737f: 57 push %edi <== NOT EXECUTED
107380: 56 push %esi <== NOT EXECUTED
107381: 53 push %ebx <== NOT EXECUTED
107382: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED
107385: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
void *high_water_mark;
void *current;
Stack_Control *stack;
char name[5];
if ( !the_thread )
107388: 85 db test %ebx,%ebx <== NOT EXECUTED
10738a: 0f 84 c0 00 00 00 je 107450 <Stack_check_Dump_threads_usage+0xd4><== NOT EXECUTED
return;
if ( !print_handler )
107390: a1 18 13 12 00 mov 0x121318,%eax <== NOT EXECUTED
107395: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED
107398: 85 c0 test %eax,%eax <== NOT EXECUTED
10739a: 0f 84 b0 00 00 00 je 107450 <Stack_check_Dump_threads_usage+0xd4><== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
if (the_thread == (Thread_Control *) -1) {
1073a0: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED
1073a3: 0f 84 cf 00 00 00 je 107478 <Stack_check_Dump_threads_usage+0xfc><== NOT EXECUTED
current = 0;
}
else
return;
} else {
stack = &the_thread->Start.Initial_stack;
1073a9: 8d bb c4 00 00 00 lea 0xc4(%ebx),%edi <== NOT EXECUTED
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
1073af: 8b 83 d8 00 00 00 mov 0xd8(%ebx),%eax <== NOT EXECUTED
1073b5: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED
}
low = Stack_check_usable_stack_start(stack);
1073b8: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED
1073bb: 8d 70 10 lea 0x10(%eax),%esi <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
1073be: 8b 07 mov (%edi),%eax <== NOT EXECUTED
1073c0: 83 e8 10 sub $0x10,%eax <== NOT EXECUTED
1073c3: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED
high_water_mark = Stack_check_find_high_water_mark(low, size);
1073c6: 50 push %eax <== NOT EXECUTED
1073c7: 56 push %esi <== NOT EXECUTED
1073c8: e8 73 ff ff ff call 107340 <Stack_check_find_high_water_mark><== NOT EXECUTED
if ( high_water_mark )
1073cd: 5a pop %edx <== NOT EXECUTED
1073ce: 59 pop %ecx <== NOT EXECUTED
1073cf: 85 c0 test %eax,%eax <== NOT EXECUTED
1073d1: 0f 84 dd 00 00 00 je 1074b4 <Stack_check_Dump_threads_usage+0x138><== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
1073d7: 03 75 dc add -0x24(%ebp),%esi <== NOT EXECUTED
1073da: 29 c6 sub %eax,%esi <== NOT EXECUTED
else
used = 0;
if ( the_thread ) {
1073dc: 85 db test %ebx,%ebx <== NOT EXECUTED
1073de: 0f 84 b4 00 00 00 je 107498 <Stack_check_Dump_threads_usage+0x11c><== NOT EXECUTED
(*print_handler)(
1073e4: 50 push %eax <== NOT EXECUTED
1073e5: 8d 45 ef lea -0x11(%ebp),%eax <== NOT EXECUTED
1073e8: 50 push %eax <== NOT EXECUTED
1073e9: 6a 05 push $0x5 <== NOT EXECUTED
1073eb: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
1073ee: e8 59 3b 00 00 call 10af4c <rtems_object_get_name> <== NOT EXECUTED
1073f3: 50 push %eax <== NOT EXECUTED
1073f4: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
1073f7: 68 d7 a9 11 00 push $0x11a9d7 <== NOT EXECUTED
1073fc: ff 35 14 13 12 00 pushl 0x121314 <== NOT EXECUTED
107402: ff 55 d8 call *-0x28(%ebp) <== NOT EXECUTED
107405: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
);
} else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
(*print_handler)(
107408: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED
10740b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10740e: ff 75 dc pushl -0x24(%ebp) <== NOT EXECUTED
107411: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED
107414: 8b 17 mov (%edi),%edx <== NOT EXECUTED
107416: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED
10741a: 52 push %edx <== NOT EXECUTED
10741b: 50 push %eax <== NOT EXECUTED
10741c: 68 f2 a9 11 00 push $0x11a9f2 <== NOT EXECUTED
107421: ff 35 14 13 12 00 pushl 0x121314 <== NOT EXECUTED
107427: ff 15 18 13 12 00 call *0x121318 <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
10742d: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
107430: 8b 1d 10 13 12 00 mov 0x121310,%ebx <== NOT EXECUTED
107436: 85 db test %ebx,%ebx <== NOT EXECUTED
107438: 74 1e je 107458 <Stack_check_Dump_threads_usage+0xdc><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
10743a: 51 push %ecx <== NOT EXECUTED
10743b: 56 push %esi <== NOT EXECUTED
10743c: 68 1d aa 11 00 push $0x11aa1d <== NOT EXECUTED
107441: ff 35 14 13 12 00 pushl 0x121314 <== NOT EXECUTED
107447: ff 15 18 13 12 00 call *0x121318 <== NOT EXECUTED
10744d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
107450: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
107453: 5b pop %ebx <== NOT EXECUTED
107454: 5e pop %esi <== NOT EXECUTED
107455: 5f pop %edi <== NOT EXECUTED
107456: c9 leave <== NOT EXECUTED
107457: c3 ret <== NOT EXECUTED
current,
size
);
if (Stack_check_Initialized == 0) {
(*print_handler)( print_context, "Unavailable\n" );
107458: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10745b: 68 10 aa 11 00 push $0x11aa10 <== NOT EXECUTED
107460: ff 35 14 13 12 00 pushl 0x121314 <== NOT EXECUTED
107466: ff 15 18 13 12 00 call *0x121318 <== NOT EXECUTED
10746c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
}
}
10746f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
107472: 5b pop %ebx <== NOT EXECUTED
107473: 5e pop %esi <== NOT EXECUTED
107474: 5f pop %edi <== NOT EXECUTED
107475: c9 leave <== NOT EXECUTED
107476: c3 ret <== NOT EXECUTED
107477: 90 nop <== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
if (the_thread == (Thread_Control *) -1) {
if (Stack_check_Interrupt_stack.area) {
107478: 8b 1d 64 15 12 00 mov 0x121564,%ebx <== NOT EXECUTED
10747e: 85 db test %ebx,%ebx <== NOT EXECUTED
107480: 74 ce je 107450 <Stack_check_Dump_threads_usage+0xd4><== NOT EXECUTED
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
current = 0;
}
else
return;
107482: 31 db xor %ebx,%ebx <== NOT EXECUTED
107484: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
10748b: bf 60 15 12 00 mov $0x121560,%edi <== NOT EXECUTED
107490: e9 23 ff ff ff jmp 1073b8 <Stack_check_Dump_threads_usage+0x3c><== NOT EXECUTED
107495: 8d 76 00 lea 0x0(%esi),%esi <== 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 );
107498: 50 push %eax <== NOT EXECUTED
107499: 6a ff push $0xffffffff <== NOT EXECUTED
10749b: 68 e4 a9 11 00 push $0x11a9e4 <== NOT EXECUTED
1074a0: ff 35 14 13 12 00 pushl 0x121314 <== NOT EXECUTED
1074a6: ff 55 d8 call *-0x28(%ebp) <== NOT EXECUTED
1074a9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1074ac: e9 57 ff ff ff jmp 107408 <Stack_check_Dump_threads_usage+0x8c><== NOT EXECUTED
1074b1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
1074b4: 31 f6 xor %esi,%esi <== NOT EXECUTED
1074b6: e9 21 ff ff ff jmp 1073dc <Stack_check_Dump_threads_usage+0x60><== NOT EXECUTED
00107690 <Stack_check_Initialize>:
/*
* Stack_check_Initialize
*/
void Stack_check_Initialize( void )
{
107690: 55 push %ebp
107691: 89 e5 mov %esp,%ebp
107693: 57 push %edi
107694: 83 ec 04 sub $0x4,%esp
uint32_t *p;
if (Stack_check_Initialized)
107697: a1 10 13 12 00 mov 0x121310,%eax
10769c: 85 c0 test %eax,%eax
10769e: 75 59 jne 1076f9 <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 */
1076a0: c7 05 50 15 12 00 0d movl $0xfeedf00d,0x121550
1076a7: f0 ed fe
p[1] = 0x0BAD0D06;
1076aa: c7 05 54 15 12 00 06 movl $0xbad0d06,0x121554
1076b1: 0d ad 0b
p[2] = 0xDEADF00D; /* DEAD FOOD GOOD DOG */
1076b4: c7 05 58 15 12 00 0d movl $0xdeadf00d,0x121558
1076bb: f0 ad de
p[3] = 0x600D0D06;
1076be: c7 05 5c 15 12 00 06 movl $0x600d0d06,0x12155c
1076c5: 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) {
1076c8: 8b 3d 08 17 12 00 mov 0x121708,%edi
1076ce: 85 ff test %edi,%edi
1076d0: 74 1d je 1076ef <Stack_check_Initialize+0x5f><== NEVER TAKEN
1076d2: a1 c8 16 12 00 mov 0x1216c8,%eax
1076d7: 85 c0 test %eax,%eax
1076d9: 74 14 je 1076ef <Stack_check_Initialize+0x5f><== NEVER TAKEN
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
1076db: 89 3d 64 15 12 00 mov %edi,0x121564
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
1076e1: 89 c1 mov %eax,%ecx
1076e3: 29 f9 sub %edi,%ecx
1076e5: 89 0d 60 15 12 00 mov %ecx,0x121560
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
1076eb: b0 a5 mov $0xa5,%al
1076ed: f3 aa rep stos %al,%es:(%edi)
}
#endif
Stack_check_Initialized = 1;
1076ef: c7 05 10 13 12 00 01 movl $0x1,0x121310
1076f6: 00 00 00
}
1076f9: 5f pop %edi
1076fa: 5f pop %edi
1076fb: c9 leave
1076fc: c3 ret
00107340 <Stack_check_find_high_water_mark>:
*/
void *Stack_check_find_high_water_mark(
const void *s,
size_t n
)
{
107340: 55 push %ebp <== NOT EXECUTED
107341: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107343: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
107346: 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;
107349: 8d 51 10 lea 0x10(%ecx),%edx <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
10734c: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED
10734f: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED
107352: 39 c2 cmp %eax,%edx <== NOT EXECUTED
107354: 73 1d jae 107373 <Stack_check_find_high_water_mark+0x33><== NOT EXECUTED
if (*base != U32_PATTERN)
107356: 81 79 10 a5 a5 a5 a5 cmpl $0xa5a5a5a5,0x10(%ecx) <== NOT EXECUTED
10735d: 74 0d je 10736c <Stack_check_find_high_water_mark+0x2c><== NOT EXECUTED
10735f: eb 17 jmp 107378 <Stack_check_find_high_water_mark+0x38><== NOT EXECUTED
107361: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
107364: 81 3a a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%edx) <== NOT EXECUTED
10736a: 75 0c jne 107378 <Stack_check_find_high_water_mark+0x38><== 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++)
10736c: 83 c2 04 add $0x4,%edx <== NOT EXECUTED
10736f: 39 d0 cmp %edx,%eax <== NOT EXECUTED
107371: 77 f1 ja 107364 <Stack_check_find_high_water_mark+0x24><== NOT EXECUTED
107373: 31 c0 xor %eax,%eax <== NOT EXECUTED
if (*base != U32_PATTERN)
return (void *) base;
#endif
return (void *)0;
}
107375: c9 leave <== NOT EXECUTED
107376: c3 ret <== NOT EXECUTED
107377: 90 nop <== NOT EXECUTED
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
if (*base != U32_PATTERN)
return (void *) base;
107378: 89 d0 mov %edx,%eax <== NOT EXECUTED
#endif
return (void *)0;
}
10737a: c9 leave <== NOT EXECUTED
10737b: c3 ret <== NOT EXECUTED
00107538 <Stack_check_report_blown_task>:
*/
void Stack_check_report_blown_task(
Thread_Control *running,
bool pattern_ok
)
{
107538: 55 push %ebp <== NOT EXECUTED
107539: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10753b: 56 push %esi <== NOT EXECUTED
10753c: 53 push %ebx <== NOT EXECUTED
10753d: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
107540: 8a 5d 0c mov 0xc(%ebp),%bl <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack;
printk(
107543: ff 76 0c pushl 0xc(%esi) <== NOT EXECUTED
107546: ff 76 08 pushl 0x8(%esi) <== NOT EXECUTED
107549: 56 push %esi <== NOT EXECUTED
10754a: 68 88 aa 11 00 push $0x11aa88 <== NOT EXECUTED
10754f: e8 24 15 00 00 call 108a78 <printk> <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
printk(
107554: 8b 96 c8 00 00 00 mov 0xc8(%esi),%edx <== NOT EXECUTED
10755a: 8b 86 c4 00 00 00 mov 0xc4(%esi),%eax <== NOT EXECUTED
107560: 50 push %eax <== NOT EXECUTED
107561: 8d 44 02 ff lea -0x1(%edx,%eax,1),%eax <== NOT EXECUTED
107565: 50 push %eax <== NOT EXECUTED
107566: 52 push %edx <== NOT EXECUTED
107567: 68 c8 aa 11 00 push $0x11aac8 <== NOT EXECUTED
10756c: e8 07 15 00 00 call 108a78 <printk> <== NOT EXECUTED
stack->area,
stack->area + stack->size - 1,
stack->size
);
if ( !pattern_ok ) {
107571: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
107574: 84 db test %bl,%bl <== NOT EXECUTED
107576: 74 10 je 107588 <Stack_check_report_blown_task+0x50><== NOT EXECUTED
" 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 );
107578: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10757b: 68 81 00 00 00 push $0x81 <== NOT EXECUTED
107580: e8 17 43 00 00 call 10b89c <rtems_fatal_error_occurred><== NOT EXECUTED
107585: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
stack->area + stack->size - 1,
stack->size
);
if ( !pattern_ok ) {
printk(
107588: 51 push %ecx <== NOT EXECUTED
107589: 6a 10 push $0x10 <== NOT EXECUTED
10758b: 8b 86 c8 00 00 00 mov 0xc8(%esi),%eax <== NOT EXECUTED
107591: 83 c0 08 add $0x8,%eax <== NOT EXECUTED
107594: 50 push %eax <== NOT EXECUTED
107595: 68 f8 aa 11 00 push $0x11aaf8 <== NOT EXECUTED
10759a: e8 d9 14 00 00 call 108a78 <printk> <== NOT EXECUTED
10759f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1075a2: eb d4 jmp 107578 <Stack_check_report_blown_task+0x40><== NOT EXECUTED
0010ac28 <_API_extensions_Run_postdriver>:
*
* _API_extensions_Run_postdriver
*/
void _API_extensions_Run_postdriver( void )
{
10ac28: 55 push %ebp
10ac29: 89 e5 mov %esp,%ebp
10ac2b: 53 push %ebx
10ac2c: 83 ec 04 sub $0x4,%esp
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
10ac2f: 8b 1d b8 e8 11 00 mov 0x11e8b8,%ebx
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
10ac35: 81 fb bc e8 11 00 cmp $0x11e8bc,%ebx
10ac3b: 74 16 je 10ac53 <_API_extensions_Run_postdriver+0x2b><== NEVER TAKEN
10ac3d: 8d 76 00 lea 0x0(%esi),%esi
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->postdriver_hook )
10ac40: 8b 43 0c mov 0xc(%ebx),%eax
10ac43: 85 c0 test %eax,%eax
10ac45: 74 02 je 10ac49 <_API_extensions_Run_postdriver+0x21><== NEVER TAKEN
(*the_extension->postdriver_hook)();
10ac47: 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 ) {
10ac49: 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 ) ;
10ac4b: 81 fb bc e8 11 00 cmp $0x11e8bc,%ebx
10ac51: 75 ed jne 10ac40 <_API_extensions_Run_postdriver+0x18><== NEVER TAKEN
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->postdriver_hook )
(*the_extension->postdriver_hook)();
}
}
10ac53: 5a pop %edx
10ac54: 5b pop %ebx
10ac55: c9 leave
10ac56: c3 ret
0010ac58 <_API_extensions_Run_postswitch>:
*
* _API_extensions_Run_postswitch
*/
void _API_extensions_Run_postswitch( void )
{
10ac58: 55 push %ebp
10ac59: 89 e5 mov %esp,%ebp
10ac5b: 53 push %ebx
10ac5c: 83 ec 04 sub $0x4,%esp
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
10ac5f: 8b 1d b8 e8 11 00 mov 0x11e8b8,%ebx
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
10ac65: 81 fb bc e8 11 00 cmp $0x11e8bc,%ebx
10ac6b: 74 22 je 10ac8f <_API_extensions_Run_postswitch+0x37><== NEVER TAKEN
10ac6d: 8d 76 00 lea 0x0(%esi),%esi
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->postswitch_hook )
10ac70: 8b 43 10 mov 0x10(%ebx),%eax
10ac73: 85 c0 test %eax,%eax
10ac75: 74 0e je 10ac85 <_API_extensions_Run_postswitch+0x2d><== NEVER TAKEN
(*the_extension->postswitch_hook)( _Thread_Executing );
10ac77: 83 ec 0c sub $0xc,%esp
10ac7a: ff 35 1c e7 11 00 pushl 0x11e71c
10ac80: ff d0 call *%eax
10ac82: 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 ) {
10ac85: 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 ) ;
10ac87: 81 fb bc e8 11 00 cmp $0x11e8bc,%ebx
10ac8d: 75 e1 jne 10ac70 <_API_extensions_Run_postswitch+0x18><== NEVER TAKEN
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->postswitch_hook )
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10ac8f: 8b 5d fc mov -0x4(%ebp),%ebx
10ac92: c9 leave
10ac93: c3 ret
0010abf8 <_API_extensions_Run_predriver>:
*
* _API_extensions_Run_predriver
*/
void _API_extensions_Run_predriver( void )
{
10abf8: 55 push %ebp
10abf9: 89 e5 mov %esp,%ebp
10abfb: 53 push %ebx
10abfc: 83 ec 04 sub $0x4,%esp
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
10abff: 8b 1d b8 e8 11 00 mov 0x11e8b8,%ebx
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
10ac05: 81 fb bc e8 11 00 cmp $0x11e8bc,%ebx
10ac0b: 74 16 je 10ac23 <_API_extensions_Run_predriver+0x2b><== NEVER TAKEN
10ac0d: 8d 76 00 lea 0x0(%esi),%esi
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->predriver_hook )
10ac10: 8b 43 08 mov 0x8(%ebx),%eax
10ac13: 85 c0 test %eax,%eax
10ac15: 74 02 je 10ac19 <_API_extensions_Run_predriver+0x21><== ALWAYS TAKEN
(*the_extension->predriver_hook)();
10ac17: 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 ) {
10ac19: 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 ) ;
10ac1b: 81 fb bc e8 11 00 cmp $0x11e8bc,%ebx
10ac21: 75 ed jne 10ac10 <_API_extensions_Run_predriver+0x18><== NEVER TAKEN
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->predriver_hook )
(*the_extension->predriver_hook)();
}
}
10ac23: 58 pop %eax
10ac24: 5b pop %ebx
10ac25: c9 leave
10ac26: c3 ret
0010bcc4 <_CORE_barrier_Wait>:
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
10bcc4: 55 push %ebp
10bcc5: 89 e5 mov %esp,%ebp
10bcc7: 57 push %edi
10bcc8: 56 push %esi
10bcc9: 53 push %ebx
10bcca: 83 ec 04 sub $0x4,%esp
10bccd: 8b 55 08 mov 0x8(%ebp),%edx
10bcd0: 8b 7d 0c mov 0xc(%ebp),%edi
10bcd3: 8b 75 14 mov 0x14(%ebp),%esi
10bcd6: 8b 45 18 mov 0x18(%ebp),%eax
10bcd9: 89 45 f0 mov %eax,-0x10(%ebp)
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
10bcdc: 8b 0d bc 17 12 00 mov 0x1217bc,%ecx
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
10bce2: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx)
_ISR_Disable( level );
10bce9: 9c pushf
10bcea: fa cli
10bceb: 5b pop %ebx
the_barrier->number_of_waiting_threads++;
10bcec: 8b 42 48 mov 0x48(%edx),%eax
10bcef: 40 inc %eax
10bcf0: 89 42 48 mov %eax,0x48(%edx)
if ( the_barrier->number_of_waiting_threads ==
10bcf3: 3b 42 44 cmp 0x44(%edx),%eax
10bcf6: 75 07 jne 10bcff <_CORE_barrier_Wait+0x3b>
the_barrier->Attributes.maximum_count) {
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
10bcf8: 8b 42 40 mov 0x40(%edx),%eax
10bcfb: 85 c0 test %eax,%eax
10bcfd: 74 29 je 10bd28 <_CORE_barrier_Wait+0x64><== ALWAYS TAKEN
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
* This routine grows @a the_heap memory area using the size bytes which
10bcff: 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;
10bd06: 89 51 44 mov %edx,0x44(%ecx)
executing->Wait.id = id;
10bd09: 89 79 20 mov %edi,0x20(%ecx)
_ISR_Enable( level );
10bd0c: 53 push %ebx
10bd0d: 9d popf
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
10bd0e: c7 45 10 7c da 10 00 movl $0x10da7c,0x10(%ebp)
10bd15: 89 75 0c mov %esi,0xc(%ebp)
10bd18: 89 55 08 mov %edx,0x8(%ebp)
}
10bd1b: 58 pop %eax
10bd1c: 5b pop %ebx
10bd1d: 5e pop %esi
10bd1e: 5f pop %edi
10bd1f: 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 );
10bd20: e9 07 1a 00 00 jmp 10d72c <_Thread_queue_Enqueue_with_handler>
10bd25: 8d 76 00 lea 0x0(%esi),%esi
_ISR_Disable( level );
the_barrier->number_of_waiting_threads++;
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;
10bd28: c7 41 34 01 00 00 00 movl $0x1,0x34(%ecx)
_ISR_Enable( level );
10bd2f: 53 push %ebx
10bd30: 9d popf
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
10bd31: 8b 45 f0 mov -0x10(%ebp),%eax
10bd34: 89 45 10 mov %eax,0x10(%ebp)
10bd37: 89 7d 0c mov %edi,0xc(%ebp)
10bd3a: 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 );
}
10bd3d: 5a pop %edx
10bd3e: 5b pop %ebx
10bd3f: 5e pop %esi
10bd40: 5f pop %edi
10bd41: 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 );
10bd42: e9 4d ff ff ff jmp 10bc94 <_CORE_barrier_Release>
0011553c <_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
)
{
11553c: 55 push %ebp
11553d: 89 e5 mov %esp,%ebp
11553f: 57 push %edi
115540: 56 push %esi
115541: 53 push %ebx
115542: 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 ) {
115545: 8b 55 10 mov 0x10(%ebp),%edx
115548: 8b 45 08 mov 0x8(%ebp),%eax
11554b: 39 50 4c cmp %edx,0x4c(%eax)
11554e: 72 58 jb 1155a8 <_CORE_message_queue_Broadcast+0x6c><== NEVER TAKEN
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
115550: 8b 75 08 mov 0x8(%ebp),%esi
115553: 8b 46 48 mov 0x48(%esi),%eax
115556: 85 c0 test %eax,%eax
115558: 75 3a jne 115594 <_CORE_message_queue_Broadcast+0x58><== 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))) {
11555a: 31 db xor %ebx,%ebx
11555c: eb 16 jmp 115574 <_CORE_message_queue_Broadcast+0x38>
11555e: 66 90 xchg %ax,%ax
waitp = &the_thread->Wait;
number_broadcasted += 1;
115560: 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
115561: 8b 78 2c mov 0x2c(%eax),%edi
115564: 8b 75 0c mov 0xc(%ebp),%esi
115567: 8b 4d 10 mov 0x10(%ebp),%ecx
11556a: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
11556c: 8b 40 28 mov 0x28(%eax),%eax
11556f: 8b 55 10 mov 0x10(%ebp),%edx
115572: 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))) {
115574: 83 ec 0c sub $0xc,%esp
115577: ff 75 08 pushl 0x8(%ebp)
11557a: e8 29 22 00 00 call 1177a8 <_Thread_queue_Dequeue>
11557f: 83 c4 10 add $0x10,%esp
115582: 85 c0 test %eax,%eax
115584: 75 da jne 115560 <_CORE_message_queue_Broadcast+0x24>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
115586: 8b 75 1c mov 0x1c(%ebp),%esi
115589: 89 1e mov %ebx,(%esi)
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
11558b: 8d 65 f4 lea -0xc(%ebp),%esp
11558e: 5b pop %ebx
11558f: 5e pop %esi
115590: 5f pop %edi
115591: c9 leave
115592: c3 ret
115593: 90 nop
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
*count = 0;
115594: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED
115597: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
11559d: 31 c0 xor %eax,%eax <== NOT EXECUTED
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
11559f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1155a2: 5b pop %ebx <== NOT EXECUTED
1155a3: 5e pop %esi <== NOT EXECUTED
1155a4: 5f pop %edi <== NOT EXECUTED
1155a5: c9 leave <== NOT EXECUTED
1155a6: c3 ret <== NOT EXECUTED
1155a7: 90 nop <== NOT EXECUTED
{
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
1155a8: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
1155ad: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1155b0: 5b pop %ebx <== NOT EXECUTED
1155b1: 5e pop %esi <== NOT EXECUTED
1155b2: 5f pop %edi <== NOT EXECUTED
1155b3: c9 leave <== NOT EXECUTED
1155b4: c3 ret <== NOT EXECUTED
001155f4 <_CORE_message_queue_Flush>:
*/
uint32_t _CORE_message_queue_Flush(
CORE_message_queue_Control *the_message_queue
)
{
1155f4: 55 push %ebp
1155f5: 89 e5 mov %esp,%ebp
1155f7: 8b 45 08 mov 0x8(%ebp),%eax
if ( the_message_queue->number_of_pending_messages != 0 )
1155fa: 8b 50 48 mov 0x48(%eax),%edx
1155fd: 85 d2 test %edx,%edx
1155ff: 75 07 jne 115608 <_CORE_message_queue_Flush+0x14>
return _CORE_message_queue_Flush_support( the_message_queue );
else
return 0;
}
115601: 31 c0 xor %eax,%eax
115603: c9 leave
115604: c3 ret
115605: 8d 76 00 lea 0x0(%esi),%esi
uint32_t _CORE_message_queue_Flush(
CORE_message_queue_Control *the_message_queue
)
{
if ( the_message_queue->number_of_pending_messages != 0 )
return _CORE_message_queue_Flush_support( the_message_queue );
115608: 89 45 08 mov %eax,0x8(%ebp)
else
return 0;
}
11560b: c9 leave
uint32_t _CORE_message_queue_Flush(
CORE_message_queue_Control *the_message_queue
)
{
if ( the_message_queue->number_of_pending_messages != 0 )
return _CORE_message_queue_Flush_support( the_message_queue );
11560c: e9 03 00 00 00 jmp 115614 <_CORE_message_queue_Flush_support>
0011565c <_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
)
{
11565c: 55 push %ebp
11565d: 89 e5 mov %esp,%ebp
11565f: 57 push %edi
115660: 56 push %esi
115661: 53 push %ebx
115662: 83 ec 0c sub $0xc,%esp
115665: 8b 5d 08 mov 0x8(%ebp),%ebx
115668: 8b 7d 10 mov 0x10(%ebp),%edi
11566b: 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;
11566e: 89 7b 44 mov %edi,0x44(%ebx)
the_message_queue->number_of_pending_messages = 0;
115671: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
the_message_queue->maximum_message_size = maximum_message_size;
115678: 89 53 4c mov %edx,0x4c(%ebx)
11567b: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
115682: 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)) {
115689: f6 c2 03 test $0x3,%dl
11568c: 75 1a jne 1156a8 <_CORE_message_queue_Initialize+0x4c>
11568e: 89 d0 mov %edx,%eax
/*
* 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 *
115690: 8d 70 14 lea 0x14(%eax),%esi
115693: 89 f2 mov %esi,%edx
115695: 0f af d7 imul %edi,%edx
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
115698: 39 c2 cmp %eax,%edx
11569a: 73 18 jae 1156b4 <_CORE_message_queue_Initialize+0x58><== ALWAYS TAKEN
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
11569c: 31 c0 xor %eax,%eax
}
11569e: 8d 65 f4 lea -0xc(%ebp),%esp
1156a1: 5b pop %ebx
1156a2: 5e pop %esi
1156a3: 5f pop %edi
1156a4: c9 leave
1156a5: c3 ret
1156a6: 66 90 xchg %ax,%ax
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
allocated_message_size += sizeof(uint32_t);
1156a8: 8d 42 04 lea 0x4(%edx),%eax
allocated_message_size &= ~(sizeof(uint32_t) - 1);
1156ab: 83 e0 fc and $0xfffffffc,%eax
}
if (allocated_message_size < maximum_message_size)
1156ae: 39 c2 cmp %eax,%edx
1156b0: 77 ea ja 11569c <_CORE_message_queue_Initialize+0x40><== NEVER TAKEN
1156b2: eb dc jmp 115690 <_CORE_message_queue_Initialize+0x34>
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
1156b4: 83 ec 0c sub $0xc,%esp
1156b7: 52 push %edx
1156b8: e8 53 32 00 00 call 118910 <_Workspace_Allocate>
1156bd: 89 43 5c mov %eax,0x5c(%ebx)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
1156c0: 83 c4 10 add $0x10,%esp
1156c3: 85 c0 test %eax,%eax
1156c5: 74 d5 je 11569c <_CORE_message_queue_Initialize+0x40>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
1156c7: 56 push %esi
1156c8: 57 push %edi
1156c9: 50 push %eax
1156ca: 8d 43 68 lea 0x68(%ebx),%eax
1156cd: 50 push %eax
1156ce: e8 1d fe ff ff call 1154f0 <_Chain_Initialize>
1156d3: 8d 43 54 lea 0x54(%ebx),%eax
1156d6: 89 43 50 mov %eax,0x50(%ebx)
1156d9: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx)
1156e0: 8d 43 50 lea 0x50(%ebx),%eax
1156e3: 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(
1156e6: 6a 06 push $0x6
1156e8: 68 80 00 00 00 push $0x80
1156ed: 8b 45 0c mov 0xc(%ebp),%eax
1156f0: 83 38 01 cmpl $0x1,(%eax)
1156f3: 0f 94 c0 sete %al
1156f6: 0f b6 c0 movzbl %al,%eax
1156f9: 50 push %eax
1156fa: 53 push %ebx
1156fb: e8 58 24 00 00 call 117b58 <_Thread_queue_Initialize>
115700: b0 01 mov $0x1,%al
115702: 83 c4 20 add $0x20,%esp
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
}
115705: 8d 65 f4 lea -0xc(%ebp),%esp
115708: 5b pop %ebx
115709: 5e pop %esi
11570a: 5f pop %edi
11570b: c9 leave
11570c: c3 ret
0010f0a8 <_CORE_message_queue_Insert_message>:
void _CORE_message_queue_Insert_message(
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Buffer_control *the_message,
CORE_message_queue_Submit_types submit_type
)
{
10f0a8: 55 push %ebp
10f0a9: 89 e5 mov %esp,%ebp
10f0ab: 57 push %edi
10f0ac: 56 push %esi
10f0ad: 53 push %ebx
10f0ae: 83 ec 04 sub $0x4,%esp
10f0b1: 8b 75 08 mov 0x8(%ebp),%esi
10f0b4: 8b 7d 0c mov 0xc(%ebp),%edi
10f0b7: 8b 45 10 mov 0x10(%ebp),%eax
ISR_Level level;
bool notify = false;
the_message->priority = submit_type;
10f0ba: 89 47 08 mov %eax,0x8(%edi)
switch ( submit_type ) {
10f0bd: 3d 00 00 00 80 cmp $0x80000000,%eax
10f0c2: 0f 84 94 00 00 00 je 10f15c <_CORE_message_queue_Insert_message+0xb4>
10f0c8: 3d ff ff ff 7f cmp $0x7fffffff,%eax
10f0cd: 74 65 je 10f134 <_CORE_message_queue_Insert_message+0x8c><== ALWAYS TAKEN
CORE_message_queue_Buffer_control *this_message;
Chain_Node *the_node;
Chain_Control *the_header;
the_header = &the_message_queue->Pending_messages;
the_node = the_header->first;
10f0cf: 8b 5e 50 mov 0x50(%esi),%ebx <== NOT EXECUTED
* @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
10f0d2: 8d 56 54 lea 0x54(%esi),%edx <== NOT EXECUTED
while ( !_Chain_Is_tail( the_header, the_node ) ) {
10f0d5: 39 da cmp %ebx,%edx <== NOT EXECUTED
10f0d7: 75 49 jne 10f122 <_CORE_message_queue_Insert_message+0x7a><== NOT EXECUTED
10f0d9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
10f0dc: 89 d3 mov %edx,%ebx <== NOT EXECUTED
continue;
}
break;
}
_ISR_Disable( level );
10f0de: 9c pushf <== NOT EXECUTED
10f0df: fa cli <== NOT EXECUTED
10f0e0: 59 pop %ecx <== NOT EXECUTED
if ( the_message_queue->number_of_pending_messages++ == 0 )
10f0e1: 8b 56 48 mov 0x48(%esi),%edx <== NOT EXECUTED
10f0e4: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED
10f0e7: 89 46 48 mov %eax,0x48(%esi) <== NOT EXECUTED
10f0ea: 85 d2 test %edx,%edx <== NOT EXECUTED
10f0ec: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED
notify = true;
_Chain_Insert_unprotected( the_node->previous, &the_message->Node );
10f0f0: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED
10f0f3: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED
10f0f6: 8b 10 mov (%eax),%edx <== NOT EXECUTED
10f0f8: 89 38 mov %edi,(%eax) <== NOT EXECUTED
10f0fa: 89 17 mov %edx,(%edi) <== NOT EXECUTED
10f0fc: 89 7a 04 mov %edi,0x4(%edx) <== NOT EXECUTED
_ISR_Enable( level );
10f0ff: 51 push %ecx <== NOT EXECUTED
10f100: 9d popf <== NOT EXECUTED
* According to POSIX, does this happen before or after the message
* is actually enqueued. It is logical to think afterwards, because
* the message is actually in the queue at this point.
*/
if ( notify && the_message_queue->notify_handler )
10f101: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
10f105: 74 25 je 10f12c <_CORE_message_queue_Insert_message+0x84>
10f107: 8b 4e 60 mov 0x60(%esi),%ecx
10f10a: 85 c9 test %ecx,%ecx
10f10c: 74 1e je 10f12c <_CORE_message_queue_Insert_message+0x84><== ALWAYS TAKEN
(*the_message_queue->notify_handler)( the_message_queue->notify_argument );
10f10e: 8b 46 64 mov 0x64(%esi),%eax <== NOT EXECUTED
10f111: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
10f114: 5a pop %edx <== NOT EXECUTED
10f115: 5b pop %ebx <== NOT EXECUTED
10f116: 5e pop %esi <== NOT EXECUTED
10f117: 5f pop %edi <== NOT EXECUTED
10f118: c9 leave <== NOT EXECUTED
* is actually enqueued. It is logical to think afterwards, because
* the message is actually in the queue at this point.
*/
if ( notify && the_message_queue->notify_handler )
(*the_message_queue->notify_handler)( the_message_queue->notify_argument );
10f119: ff e1 jmp *%ecx <== NOT EXECUTED
10f11b: 90 nop <== NOT EXECUTED
while ( !_Chain_Is_tail( the_header, the_node ) ) {
this_message = (CORE_message_queue_Buffer_control *) the_node;
if ( this_message->priority <= the_message->priority ) {
the_node = the_node->next;
10f11c: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED
Chain_Node *the_node;
Chain_Control *the_header;
the_header = &the_message_queue->Pending_messages;
the_node = the_header->first;
while ( !_Chain_Is_tail( the_header, the_node ) ) {
10f11e: 39 da cmp %ebx,%edx <== NOT EXECUTED
10f120: 74 ba je 10f0dc <_CORE_message_queue_Insert_message+0x34><== NOT EXECUTED
this_message = (CORE_message_queue_Buffer_control *) the_node;
if ( this_message->priority <= the_message->priority ) {
10f122: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED
10f125: 7d f5 jge 10f11c <_CORE_message_queue_Insert_message+0x74><== NOT EXECUTED
10f127: eb b5 jmp 10f0de <_CORE_message_queue_Insert_message+0x36><== NOT EXECUTED
10f129: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
* the message is actually in the queue at this point.
*/
if ( notify && the_message_queue->notify_handler )
(*the_message_queue->notify_handler)( the_message_queue->notify_argument );
}
10f12c: 58 pop %eax
10f12d: 5b pop %ebx
10f12e: 5e pop %esi
10f12f: 5f pop %edi
10f130: c9 leave
10f131: c3 ret
10f132: 66 90 xchg %ax,%ax
the_message->priority = submit_type;
switch ( submit_type ) {
case CORE_MESSAGE_QUEUE_SEND_REQUEST:
_ISR_Disable( level );
10f134: 9c pushf
10f135: fa cli
10f136: 59 pop %ecx
if ( the_message_queue->number_of_pending_messages++ == 0 )
10f137: 8b 56 48 mov 0x48(%esi),%edx
10f13a: 8d 42 01 lea 0x1(%edx),%eax
10f13d: 89 46 48 mov %eax,0x48(%esi)
10f140: 85 d2 test %edx,%edx
10f142: 0f 94 45 f3 sete -0xd(%ebp)
10f146: 8d 46 54 lea 0x54(%esi),%eax
10f149: 89 07 mov %eax,(%edi)
10f14b: 8b 46 58 mov 0x58(%esi),%eax
10f14e: 89 7e 58 mov %edi,0x58(%esi)
10f151: 89 38 mov %edi,(%eax)
10f153: 89 47 04 mov %eax,0x4(%edi)
notify = true;
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
10f156: 51 push %ecx
10f157: 9d popf
10f158: eb a7 jmp 10f101 <_CORE_message_queue_Insert_message+0x59>
10f15a: 66 90 xchg %ax,%ax
break;
case CORE_MESSAGE_QUEUE_URGENT_REQUEST:
_ISR_Disable( level );
10f15c: 9c pushf
10f15d: fa cli
10f15e: 59 pop %ecx
if ( the_message_queue->number_of_pending_messages++ == 0 )
10f15f: 8b 56 48 mov 0x48(%esi),%edx
10f162: 8d 42 01 lea 0x1(%edx),%eax
10f165: 89 46 48 mov %eax,0x48(%esi)
10f168: 85 d2 test %edx,%edx
10f16a: 0f 94 45 f3 sete -0xd(%ebp)
size_t size
);
/**
* 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
10f16e: 8d 46 50 lea 0x50(%esi),%eax
10f171: 89 47 04 mov %eax,0x4(%edi)
10f174: 8b 46 50 mov 0x50(%esi),%eax
10f177: 89 7e 50 mov %edi,0x50(%esi)
10f17a: 89 07 mov %eax,(%edi)
10f17c: 89 78 04 mov %edi,0x4(%eax)
notify = true;
_CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
10f17f: 51 push %ecx
10f180: 9d popf
10f181: e9 7b ff ff ff jmp 10f101 <_CORE_message_queue_Insert_message+0x59>
00115710 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
115710: 55 push %ebp
115711: 89 e5 mov %esp,%ebp
115713: 57 push %edi
115714: 56 push %esi
115715: 53 push %ebx
115716: 83 ec 1c sub $0x1c,%esp
115719: 8b 45 08 mov 0x8(%ebp),%eax
11571c: 89 45 f0 mov %eax,-0x10(%ebp)
11571f: 8b 7d 0c mov 0xc(%ebp),%edi
115722: 8b 45 10 mov 0x10(%ebp),%eax
115725: 89 45 ec mov %eax,-0x14(%ebp)
115728: 8b 4d 14 mov 0x14(%ebp),%ecx
11572b: 8b 45 1c mov 0x1c(%ebp),%eax
11572e: 89 45 e4 mov %eax,-0x1c(%ebp)
115731: 8a 45 18 mov 0x18(%ebp),%al
115734: 88 45 eb mov %al,-0x15(%ebp)
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
Thread_Control *the_thread;
executing = _Thread_Executing;
115737: 8b 15 fc 5a 13 00 mov 0x135afc,%edx
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
11573d: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
_ISR_Disable( level );
115744: 9c pushf
115745: fa cli
115746: 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(
115747: 8b 45 f0 mov -0x10(%ebp),%eax
11574a: 8b 58 50 mov 0x50(%eax),%ebx
11574d: 83 c0 54 add $0x54,%eax
115750: 39 c3 cmp %eax,%ebx
115752: 74 7c je 1157d0 <_CORE_message_queue_Seize+0xc0>
115754: 8b 13 mov (%ebx),%edx
115756: 8b 7d f0 mov -0x10(%ebp),%edi
115759: 89 57 50 mov %edx,0x50(%edi)
11575c: 89 f8 mov %edi,%eax
11575e: 83 c0 50 add $0x50,%eax
115761: 89 42 04 mov %eax,0x4(%edx)
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
the_message_queue->number_of_pending_messages -= 1;
115764: ff 4f 48 decl 0x48(%edi)
_ISR_Enable( level );
115767: 56 push %esi
115768: 9d popf
*size_p = the_message->Contents.size;
115769: 8b 43 0c mov 0xc(%ebx),%eax
11576c: 89 01 mov %eax,(%ecx)
_Thread_Executing->Wait.count = the_message->priority;
11576e: 8b 53 08 mov 0x8(%ebx),%edx
115771: a1 fc 5a 13 00 mov 0x135afc,%eax
115776: 89 50 24 mov %edx,0x24(%eax)
_CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size_p);
115779: 8d 43 10 lea 0x10(%ebx),%eax
11577c: 89 45 d8 mov %eax,-0x28(%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
11577f: 8b 09 mov (%ecx),%ecx
115781: 8b 7d ec mov -0x14(%ebp),%edi
115784: 89 c6 mov %eax,%esi
115786: 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 );
115788: 83 ec 0c sub $0xc,%esp
11578b: ff 75 f0 pushl -0x10(%ebp)
11578e: e8 15 20 00 00 call 1177a8 <_Thread_queue_Dequeue>
115793: 89 c2 mov %eax,%edx
if ( !the_thread ) {
115795: 83 c4 10 add $0x10,%esp
115798: 85 c0 test %eax,%eax
11579a: 0f 84 84 00 00 00 je 115824 <_CORE_message_queue_Seize+0x114><== ALWAYS TAKEN
* 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;
1157a0: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED
1157a3: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED
the_message->Contents.size = (size_t) the_thread->Wait.option;
1157a6: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED
1157a9: 89 4b 0c mov %ecx,0xc(%ebx) <== NOT EXECUTED
1157ac: 8b 72 2c mov 0x2c(%edx),%esi <== NOT EXECUTED
1157af: 8b 7d d8 mov -0x28(%ebp),%edi <== NOT EXECUTED
1157b2: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
1157b4: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED
1157b7: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED
1157ba: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED
1157bd: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED
1157c0: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
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 );
}
1157c3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1157c6: 5b pop %ebx <== NOT EXECUTED
1157c7: 5e pop %esi <== NOT EXECUTED
1157c8: 5f pop %edi <== NOT EXECUTED
1157c9: c9 leave <== NOT EXECUTED
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
1157ca: e9 29 4e 00 00 jmp 11a5f8 <_CORE_message_queue_Insert_message><== NOT EXECUTED
1157cf: 90 nop <== NOT EXECUTED
the_message->priority
);
return;
}
if ( !wait ) {
1157d0: 80 7d eb 00 cmpb $0x0,-0x15(%ebp)
1157d4: 75 12 jne 1157e8 <_CORE_message_queue_Seize+0xd8>
_ISR_Enable( level );
1157d6: 56 push %esi
1157d7: 9d popf
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
1157d8: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx)
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 );
}
1157df: 8d 65 f4 lea -0xc(%ebp),%esp
1157e2: 5b pop %ebx
1157e3: 5e pop %esi
1157e4: 5f pop %edi
1157e5: c9 leave
1157e6: c3 ret
1157e7: 90 nop
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
* This routine grows @a the_heap memory area using the size bytes which
1157e8: 8b 45 f0 mov -0x10(%ebp),%eax
1157eb: c7 40 30 01 00 00 00 movl $0x1,0x30(%eax)
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;
1157f2: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
1157f5: 89 7a 20 mov %edi,0x20(%edx)
executing->Wait.return_argument_second.mutable_object = buffer;
1157f8: 8b 7d ec mov -0x14(%ebp),%edi
1157fb: 89 7a 2c mov %edi,0x2c(%edx)
executing->Wait.return_argument = size_p;
1157fe: 89 4a 28 mov %ecx,0x28(%edx)
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
115801: 56 push %esi
115802: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
115803: c7 45 10 34 7c 11 00 movl $0x117c34,0x10(%ebp)
11580a: 8b 45 e4 mov -0x1c(%ebp),%eax
11580d: 89 45 0c mov %eax,0xc(%ebp)
115810: 8b 7d f0 mov -0x10(%ebp),%edi
115813: 89 7d 08 mov %edi,0x8(%ebp)
}
115816: 8d 65 f4 lea -0xc(%ebp),%esp
115819: 5b pop %ebx
11581a: 5e pop %esi
11581b: 5f pop %edi
11581c: 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 );
11581d: e9 c2 20 00 00 jmp 1178e4 <_Thread_queue_Enqueue_with_handler>
115822: 66 90 xchg %ax,%ax
* @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
115824: 89 5d 0c mov %ebx,0xc(%ebp)
115827: 8b 45 f0 mov -0x10(%ebp),%eax
11582a: 83 c0 68 add $0x68,%eax
11582d: 89 45 08 mov %eax,0x8(%ebp)
}
115830: 8d 65 f4 lea -0xc(%ebp),%esp
115833: 5b pop %ebx
115834: 5e pop %esi
115835: 5f pop %edi
115836: c9 leave
115837: e9 68 fc ff ff jmp 1154a4 <_Chain_Append>
0010adc8 <_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
)
{
10adc8: 55 push %ebp
10adc9: 89 e5 mov %esp,%ebp
10adcb: 57 push %edi
10adcc: 56 push %esi
10adcd: 53 push %ebx
10adce: 83 ec 1c sub $0x1c,%esp
10add1: 8b 5d 08 mov 0x8(%ebp),%ebx
10add4: 8a 45 20 mov 0x20(%ebp),%al
10add7: 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 ) {
10adda: 8b 55 10 mov 0x10(%ebp),%edx
10addd: 39 53 4c cmp %edx,0x4c(%ebx)
10ade0: 72 6e jb 10ae50 <_CORE_message_queue_Submit+0x88>
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
10ade2: 8b 43 48 mov 0x48(%ebx),%eax
10ade5: 85 c0 test %eax,%eax
10ade7: 74 77 je 10ae60 <_CORE_message_queue_Submit+0x98>
/*
* 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 <
10ade9: 39 43 44 cmp %eax,0x44(%ebx)
10adec: 0f 87 be 00 00 00 ja 10aeb0 <_CORE_message_queue_Submit+0xe8>
* 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 ) {
10adf2: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
10adf6: 0f 84 9c 00 00 00 je 10ae98 <_CORE_message_queue_Submit+0xd0><== ALWAYS TAKEN
/*
* 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() ) {
10adfc: a1 f8 e6 11 00 mov 0x11e6f8,%eax <== NOT EXECUTED
10ae01: 85 c0 test %eax,%eax <== NOT EXECUTED
10ae03: 0f 85 97 00 00 00 jne 10aea0 <_CORE_message_queue_Submit+0xd8><== NOT EXECUTED
* it as a variable. Doing this emphasizes how dangerous it
* would be to use this variable prior to here.
*/
{
Thread_Control *executing = _Thread_Executing;
10ae09: a1 1c e7 11 00 mov 0x11e71c,%eax <== NOT EXECUTED
_ISR_Disable( level );
10ae0e: 9c pushf <== NOT EXECUTED
10ae0f: fa cli <== NOT EXECUTED
10ae10: 5a pop %edx <== NOT EXECUTED
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
* This routine grows @a the_heap memory area using the size bytes which
10ae11: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) <== NOT EXECUTED
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
10ae18: 89 58 44 mov %ebx,0x44(%eax) <== NOT EXECUTED
executing->Wait.id = id;
10ae1b: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED
10ae1e: 89 70 20 mov %esi,0x20(%eax) <== NOT EXECUTED
executing->Wait.return_argument_second.immutable_object = buffer;
10ae21: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
10ae24: 89 48 2c mov %ecx,0x2c(%eax) <== NOT EXECUTED
executing->Wait.option = (uint32_t) size;
10ae27: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED
10ae2a: 89 70 30 mov %esi,0x30(%eax) <== NOT EXECUTED
executing->Wait.count = submit_type;
10ae2d: 8b 4d 1c mov 0x1c(%ebp),%ecx <== NOT EXECUTED
10ae30: 89 48 24 mov %ecx,0x24(%eax) <== NOT EXECUTED
_ISR_Enable( level );
10ae33: 52 push %edx <== NOT EXECUTED
10ae34: 9d popf <== NOT EXECUTED
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
10ae35: 50 push %eax <== NOT EXECUTED
10ae36: 68 fc ca 10 00 push $0x10cafc <== NOT EXECUTED
10ae3b: ff 75 24 pushl 0x24(%ebp) <== NOT EXECUTED
10ae3e: 53 push %ebx <== NOT EXECUTED
10ae3f: e8 68 19 00 00 call 10c7ac <_Thread_queue_Enqueue_with_handler><== NOT EXECUTED
10ae44: b8 07 00 00 00 mov $0x7,%eax <== NOT EXECUTED
10ae49: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ae4c: eb 07 jmp 10ae55 <_CORE_message_queue_Submit+0x8d><== NOT EXECUTED
10ae4e: 66 90 xchg %ax,%ax <== NOT EXECUTED
{
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
10ae50: b8 01 00 00 00 mov $0x1,%eax
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
}
10ae55: 8d 65 f4 lea -0xc(%ebp),%esp
10ae58: 5b pop %ebx
10ae59: 5e pop %esi
10ae5a: 5f pop %edi
10ae5b: c9 leave
10ae5c: c3 ret
10ae5d: 8d 76 00 lea 0x0(%esi),%esi
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
10ae60: 83 ec 0c sub $0xc,%esp
10ae63: 53 push %ebx
10ae64: e8 07 18 00 00 call 10c670 <_Thread_queue_Dequeue>
10ae69: 89 c2 mov %eax,%edx
if ( the_thread ) {
10ae6b: 83 c4 10 add $0x10,%esp
10ae6e: 85 c0 test %eax,%eax
10ae70: 74 7e je 10aef0 <_CORE_message_queue_Submit+0x128>
* 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
10ae72: 8b 78 2c mov 0x2c(%eax),%edi
10ae75: 8b 75 0c mov 0xc(%ebp),%esi
10ae78: 8b 4d 10 mov 0x10(%ebp),%ecx
10ae7b: 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;
10ae7d: 8b 40 28 mov 0x28(%eax),%eax
10ae80: 8b 4d 10 mov 0x10(%ebp),%ecx
10ae83: 89 08 mov %ecx,(%eax)
the_thread->Wait.count = submit_type;
10ae85: 8b 75 1c mov 0x1c(%ebp),%esi
10ae88: 89 72 24 mov %esi,0x24(%edx)
10ae8b: 31 c0 xor %eax,%eax
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
}
10ae8d: 8d 65 f4 lea -0xc(%ebp),%esp
10ae90: 5b pop %ebx
10ae91: 5e pop %esi
10ae92: 5f pop %edi
10ae93: c9 leave
10ae94: c3 ret
10ae95: 8d 76 00 lea 0x0(%esi),%esi
* No message buffers were available so we may need to return an
* overflow error or block the sender until the message is placed
* on the queue.
*/
if ( !wait ) {
10ae98: b8 02 00 00 00 mov $0x2,%eax
10ae9d: eb b6 jmp 10ae55 <_CORE_message_queue_Submit+0x8d>
10ae9f: 90 nop
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
10aea0: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED
}
10aea5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10aea8: 5b pop %ebx <== NOT EXECUTED
10aea9: 5e pop %esi <== NOT EXECUTED
10aeaa: 5f pop %edi <== NOT EXECUTED
10aeab: c9 leave <== NOT EXECUTED
10aeac: c3 ret <== NOT EXECUTED
10aead: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
);
/**
* 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.
10aeb0: 83 ec 0c sub $0xc,%esp
10aeb3: 8d 43 68 lea 0x68(%ebx),%eax
10aeb6: 50 push %eax
10aeb7: e8 e4 fe ff ff call 10ada0 <_Chain_Get>
/*
* NOTE: If the system is consistent, this error should never occur.
*/
if ( !the_message ) {
10aebc: 83 c4 10 add $0x10,%esp
10aebf: 85 c0 test %eax,%eax
10aec1: 74 dd je 10aea0 <_CORE_message_queue_Submit+0xd8><== 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
10aec3: 8d 78 10 lea 0x10(%eax),%edi
10aec6: 8b 75 0c mov 0xc(%ebp),%esi
10aec9: 8b 4d 10 mov 0x10(%ebp),%ecx
10aecc: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
_CORE_message_queue_Copy_buffer(
buffer,
the_message->Contents.buffer,
size
);
the_message->Contents.size = size;
10aece: 8b 55 10 mov 0x10(%ebp),%edx
10aed1: 89 50 0c mov %edx,0xc(%eax)
the_message->priority = submit_type;
10aed4: 8b 4d 1c mov 0x1c(%ebp),%ecx
10aed7: 89 48 08 mov %ecx,0x8(%eax)
_CORE_message_queue_Insert_message(
10aeda: 52 push %edx
10aedb: 51 push %ecx
10aedc: 50 push %eax
10aedd: 53 push %ebx
10aede: e8 c5 41 00 00 call 10f0a8 <_CORE_message_queue_Insert_message>
10aee3: 31 c0 xor %eax,%eax
10aee5: 83 c4 10 add $0x10,%esp
10aee8: e9 68 ff ff ff jmp 10ae55 <_CORE_message_queue_Submit+0x8d>
10aeed: 8d 76 00 lea 0x0(%esi),%esi
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
if ( the_thread ) {
10aef0: 8b 43 48 mov 0x48(%ebx),%eax
10aef3: e9 f1 fe ff ff jmp 10ade9 <_CORE_message_queue_Submit+0x21>
0010af04 <_CORE_mutex_Initialize>:
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
10af04: 55 push %ebp
10af05: 89 e5 mov %esp,%ebp
10af07: 57 push %edi
10af08: 56 push %esi
10af09: 83 ec 10 sub $0x10,%esp
10af0c: 8b 55 08 mov 0x8(%ebp),%edx
10af0f: 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;
10af12: 8d 7a 40 lea 0x40(%edx),%edi
10af15: b9 04 00 00 00 mov $0x4,%ecx
10af1a: 8b 75 0c mov 0xc(%ebp),%esi
10af1d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_mutex->lock = initial_lock;
10af1f: 89 42 50 mov %eax,0x50(%edx)
the_mutex->blocked_count = 0;
10af22: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx)
if ( initial_lock == CORE_MUTEX_LOCKED ) {
10af29: 85 c0 test %eax,%eax
10af2b: 75 33 jne 10af60 <_CORE_mutex_Initialize+0x5c>
the_mutex->nest_count = 1;
10af2d: c7 42 54 01 00 00 00 movl $0x1,0x54(%edx)
the_mutex->holder = _Thread_Executing;
10af34: 8b 0d 1c e7 11 00 mov 0x11e71c,%ecx
10af3a: 89 4a 5c mov %ecx,0x5c(%edx)
the_mutex->holder_id = _Thread_Executing->Object.id;
10af3d: 8b 41 08 mov 0x8(%ecx),%eax
10af40: 89 42 60 mov %eax,0x60(%edx)
/**
* 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
10af43: 8b 42 48 mov 0x48(%edx),%eax
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
10af46: 83 f8 02 cmp $0x2,%eax
10af49: 74 05 je 10af50 <_CORE_mutex_Initialize+0x4c>
10af4b: 83 f8 03 cmp $0x3,%eax
10af4e: 75 25 jne 10af75 <_CORE_mutex_Initialize+0x71><== ALWAYS TAKEN
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
10af50: 8b 41 14 mov 0x14(%ecx),%eax
10af53: 3b 42 4c cmp 0x4c(%edx),%eax
10af56: 72 48 jb 10afa0 <_CORE_mutex_Initialize+0x9c><== 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++;
10af58: ff 41 1c incl 0x1c(%ecx)
10af5b: eb 18 jmp 10af75 <_CORE_mutex_Initialize+0x71>
10af5d: 8d 76 00 lea 0x0(%esi),%esi
}
} else {
the_mutex->nest_count = 0;
10af60: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx)
the_mutex->holder = NULL;
10af67: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx)
the_mutex->holder_id = 0;
10af6e: c7 42 60 00 00 00 00 movl $0x0,0x60(%edx)
}
_Thread_queue_Initialize(
10af75: 6a 05 push $0x5
10af77: 68 00 04 00 00 push $0x400
10af7c: 8b 45 0c mov 0xc(%ebp),%eax
10af7f: 8b 40 08 mov 0x8(%eax),%eax
10af82: 85 c0 test %eax,%eax
10af84: 0f 95 c0 setne %al
10af87: 0f b6 c0 movzbl %al,%eax
10af8a: 50 push %eax
10af8b: 52 push %edx
10af8c: e8 8f 1a 00 00 call 10ca20 <_Thread_queue_Initialize>
10af91: 31 c0 xor %eax,%eax
10af93: 83 c4 10 add $0x10,%esp
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10af96: 8d 65 f8 lea -0x8(%ebp),%esp
10af99: 5e pop %esi
10af9a: 5f pop %edi
10af9b: c9 leave
10af9c: c3 ret
10af9d: 8d 76 00 lea 0x0(%esi),%esi
the_mutex->holder = _Thread_Executing;
the_mutex->holder_id = _Thread_Executing->Object.id;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
10afa0: b8 06 00 00 00 mov $0x6,%eax <== NOT EXECUTED
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10afa5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10afa8: 5e pop %esi <== NOT EXECUTED
10afa9: 5f pop %edi <== NOT EXECUTED
10afaa: c9 leave <== NOT EXECUTED
10afab: c3 ret <== NOT EXECUTED
0010affc <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
10affc: 55 push %ebp
10affd: 89 e5 mov %esp,%ebp
10afff: 56 push %esi
10b000: 53 push %ebx
10b001: 8b 75 08 mov 0x8(%ebp),%esi
10b004: 8a 5d 10 mov 0x10(%ebp),%bl
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10b007: a1 58 e6 11 00 mov 0x11e658,%eax
10b00c: 85 c0 test %eax,%eax
10b00e: 74 04 je 10b014 <_CORE_mutex_Seize+0x18>
10b010: 84 db test %bl,%bl
10b012: 75 30 jne 10b044 <_CORE_mutex_Seize+0x48><== ALWAYS TAKEN
10b014: 83 ec 08 sub $0x8,%esp
10b017: 8d 45 18 lea 0x18(%ebp),%eax
10b01a: 50 push %eax
10b01b: 56 push %esi
10b01c: e8 67 41 00 00 call 10f188 <_CORE_mutex_Seize_interrupt_trylock>
10b021: 83 c4 10 add $0x10,%esp
10b024: 85 c0 test %eax,%eax
10b026: 74 14 je 10b03c <_CORE_mutex_Seize+0x40>
10b028: 84 db test %bl,%bl
10b02a: 75 30 jne 10b05c <_CORE_mutex_Seize+0x60>
10b02c: ff 75 18 pushl 0x18(%ebp)
10b02f: 9d popf
10b030: a1 1c e7 11 00 mov 0x11e71c,%eax
10b035: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax)
}
10b03c: 8d 65 f8 lea -0x8(%ebp),%esp
10b03f: 5b pop %ebx
10b040: 5e pop %esi
10b041: c9 leave
10b042: c3 ret
10b043: 90 nop
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10b044: 83 3d 24 e8 11 00 01 cmpl $0x1,0x11e824
10b04b: 76 c7 jbe 10b014 <_CORE_mutex_Seize+0x18>
10b04d: 53 push %ebx
10b04e: 6a 13 push $0x13
10b050: 6a 00 push $0x0
10b052: 6a 00 push $0x0
10b054: e8 c7 04 00 00 call 10b520 <_Internal_error_Occurred>
10b059: 8d 76 00 lea 0x0(%esi),%esi
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
* This routine grows @a the_heap memory area using the size bytes which
10b05c: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi)
10b063: a1 1c e7 11 00 mov 0x11e71c,%eax
10b068: 89 70 44 mov %esi,0x44(%eax)
10b06b: 8b 55 0c mov 0xc(%ebp),%edx
10b06e: 89 50 20 mov %edx,0x20(%eax)
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10b071: a1 58 e6 11 00 mov 0x11e658,%eax
10b076: 40 inc %eax
10b077: a3 58 e6 11 00 mov %eax,0x11e658
10b07c: ff 75 18 pushl 0x18(%ebp)
10b07f: 9d popf
10b080: 83 ec 08 sub $0x8,%esp
10b083: ff 75 14 pushl 0x14(%ebp)
10b086: 56 push %esi
10b087: e8 20 ff ff ff call 10afac <_CORE_mutex_Seize_interrupt_blocking>
10b08c: 83 c4 10 add $0x10,%esp
}
10b08f: 8d 65 f8 lea -0x8(%ebp),%esp
10b092: 5b pop %ebx
10b093: 5e pop %esi
10b094: c9 leave
10b095: c3 ret
0010f188 <_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
)
{
10f188: 55 push %ebp
10f189: 89 e5 mov %esp,%ebp
10f18b: 53 push %ebx
10f18c: 83 ec 04 sub $0x4,%esp
10f18f: 8b 4d 08 mov 0x8(%ebp),%ecx
bool _Protected_heap_Get_block_size(
Heap_Control *the_heap,
void *starting_address,
size_t *size
);
10f192: 8b 45 0c mov 0xc(%ebp),%eax
10f195: 8b 18 mov (%eax),%ebx
/**
* This function tries to resize in place the block that is pointed to by the
* @a starting_address to the new @a size.
*
10f197: 8b 15 1c e7 11 00 mov 0x11e71c,%edx
* @param[in] the_heap is the heap to operate upon
10f19d: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
* @param[in] starting_address is the starting address of the user block
10f1a4: 8b 41 50 mov 0x50(%ecx),%eax
10f1a7: 85 c0 test %eax,%eax
10f1a9: 74 2d je 10f1d8 <_CORE_mutex_Seize_interrupt_trylock+0x50>
* to be resized
10f1ab: c7 41 50 00 00 00 00 movl $0x0,0x50(%ecx)
* @param[in] size is the new size
10f1b2: 89 51 5c mov %edx,0x5c(%ecx)
*
10f1b5: 8b 42 08 mov 0x8(%edx),%eax
10f1b8: 89 41 60 mov %eax,0x60(%ecx)
* @return TRUE if successfully able to resize the block.
10f1bb: 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
10f1c2: 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.
10f1c5: 83 f8 02 cmp $0x2,%eax
10f1c8: 74 1e je 10f1e8 <_CORE_mutex_Seize_interrupt_trylock+0x60><== ALWAYS TAKEN
10f1ca: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED
10f1cd: 74 19 je 10f1e8 <_CORE_mutex_Seize_interrupt_trylock+0x60><== NOT EXECUTED
/**
* 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.
*
* @param[in] the_heap is the heap to operate upon
10f1cf: 53 push %ebx
10f1d0: 9d popf
10f1d1: 31 c0 xor %eax,%eax
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}
10f1d3: 8b 5d fc mov -0x4(%ebp),%ebx
10f1d6: c9 leave
10f1d7: c3 ret
* 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.
10f1d8: 3b 51 5c cmp 0x5c(%ecx),%edx
10f1db: 74 3f je 10f21c <_CORE_mutex_Seize_interrupt_trylock+0x94>
Heap_Control *the_heap,
Heap_Information *info
);
#ifdef __cplusplus
}
10f1dd: b8 01 00 00 00 mov $0x1,%eax
10f1e2: 8b 5d fc mov -0x4(%ebp),%ebx
10f1e5: c9 leave
10f1e6: c3 ret
10f1e7: 90 nop
void *starting_address,
size_t size
);
/**
* This routine returns the block of memory which begins
10f1e8: 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.
*
10f1eb: 83 79 48 03 cmpl $0x3,0x48(%ecx)
10f1ef: 75 de jne 10f1cf <_CORE_mutex_Seize_interrupt_trylock+0x47><== ALWAYS TAKEN
void *start_address
);
/**
* This routine walks the heap to verify its integrity.
*
10f1f1: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED
* @param[in] the_heap is the heap to operate upon
10f1f4: 39 41 4c cmp %eax,0x4c(%ecx) <== NOT EXECUTED
10f1f7: 74 47 je 10f240 <_CORE_mutex_Seize_interrupt_trylock+0xb8><== NOT EXECUTED
* @param[in] source is a user specified integer which may be used to
* 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.
*/
10f1f9: 72 4d jb 10f248 <_CORE_mutex_Seize_interrupt_trylock+0xc0><== NOT EXECUTED
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
* @param[in] the_info pointer to a status information area
10f1fb: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) <== NOT EXECUTED
*
10f202: c7 41 50 01 00 00 00 movl $0x1,0x50(%ecx) <== NOT EXECUTED
* @return true if successfully able to return information
10f209: c7 41 54 00 00 00 00 movl $0x0,0x54(%ecx) <== NOT EXECUTED
*/
10f210: ff 4a 1c decl 0x1c(%edx) <== NOT EXECUTED
bool _Protected_heap_Get_information(
10f213: 53 push %ebx <== NOT EXECUTED
10f214: 9d popf <== NOT EXECUTED
10f215: 31 c0 xor %eax,%eax <== NOT EXECUTED
10f217: eb c9 jmp 10f1e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a><== NOT EXECUTED
10f219: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
*
* @param[in] the_heap pointer to heap header.
* @param[in] info pointer to the free block information.
*
* @return free block information filled in.
*/
10f21c: 8b 41 40 mov 0x40(%ecx),%eax
10f21f: 85 c0 test %eax,%eax
10f221: 74 11 je 10f234 <_CORE_mutex_Seize_interrupt_trylock+0xac>
10f223: 48 dec %eax
10f224: 75 b7 jne 10f1dd <_CORE_mutex_Seize_interrupt_trylock+0x55>
bool _Protected_heap_Get_free_information(
Heap_Control *the_heap,
Heap_Information *info
);
#ifdef __cplusplus
10f226: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx)
}
10f22d: 53 push %ebx
10f22e: 9d popf
10f22f: 31 c0 xor %eax,%eax
10f231: eb af jmp 10f1e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a>
10f233: 90 nop
* @param[in] info pointer to the free block information.
*
* @return free block information filled in.
*/
bool _Protected_heap_Get_free_information(
Heap_Control *the_heap,
10f234: ff 41 54 incl 0x54(%ecx)
Heap_Information *info
10f237: 53 push %ebx
10f238: 9d popf
10f239: 31 c0 xor %eax,%eax
10f23b: eb a5 jmp 10f1e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a>
10f23d: 8d 76 00 lea 0x0(%esi),%esi
/**
* This routine walks the heap to verify its integrity.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] source is a user specified integer which may be used to
10f240: 53 push %ebx <== NOT EXECUTED
10f241: 9d popf <== NOT EXECUTED
10f242: 31 c0 xor %eax,%eax <== NOT EXECUTED
10f244: eb 9c jmp 10f1e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a><== NOT EXECUTED
10f246: 66 90 xchg %ax,%ax <== NOT EXECUTED
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10f248: a1 58 e6 11 00 mov 0x11e658,%eax <== NOT EXECUTED
10f24d: 40 inc %eax <== NOT EXECUTED
10f24e: a3 58 e6 11 00 mov %eax,0x11e658 <== 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.
*/
bool _Protected_heap_Walk(
Heap_Control *the_heap,
10f253: 53 push %ebx <== NOT EXECUTED
10f254: 9d popf <== NOT EXECUTED
int source,
10f255: 50 push %eax <== NOT EXECUTED
10f256: 6a 00 push $0x0 <== NOT EXECUTED
10f258: ff 71 4c pushl 0x4c(%ecx) <== NOT EXECUTED
10f25b: ff 71 5c pushl 0x5c(%ecx) <== NOT EXECUTED
10f25e: e8 ad cb ff ff call 10be10 <_Thread_Change_priority><== NOT EXECUTED
bool do_dump
);
/**
* This routine walks the heap and tots up the free and allocated
10f263: e8 84 d0 ff ff call 10c2ec <_Thread_Enable_dispatch><== NOT EXECUTED
10f268: 31 c0 xor %eax,%eax <== NOT EXECUTED
10f26a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10f26d: e9 70 ff ff ff jmp 10f1e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a><== NOT EXECUTED
0010b098 <_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
)
{
10b098: 55 push %ebp
10b099: 89 e5 mov %esp,%ebp
10b09b: 53 push %ebx
10b09c: 83 ec 04 sub $0x4,%esp
10b09f: 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;
10b0a2: 8b 53 5c mov 0x5c(%ebx),%edx
* 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 ) {
10b0a5: 80 7b 44 00 cmpb $0x0,0x44(%ebx)
10b0a9: 74 15 je 10b0c0 <_CORE_mutex_Surrender+0x28>
if ( !_Thread_Is_executing( holder ) )
10b0ab: 3b 15 1c e7 11 00 cmp 0x11e71c,%edx
10b0b1: 74 0d je 10b0c0 <_CORE_mutex_Surrender+0x28>
10b0b3: b8 03 00 00 00 mov $0x3,%eax
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10b0b8: 8b 5d fc mov -0x4(%ebp),%ebx
10b0bb: c9 leave
10b0bc: c3 ret
10b0bd: 8d 76 00 lea 0x0(%esi),%esi
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
}
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
10b0c0: 8b 43 54 mov 0x54(%ebx),%eax
10b0c3: 85 c0 test %eax,%eax
10b0c5: 74 69 je 10b130 <_CORE_mutex_Surrender+0x98>
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
10b0c7: 48 dec %eax
10b0c8: 89 43 54 mov %eax,0x54(%ebx)
if ( the_mutex->nest_count != 0 ) {
10b0cb: 85 c0 test %eax,%eax
10b0cd: 75 69 jne 10b138 <_CORE_mutex_Surrender+0xa0>
/**
* 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
10b0cf: 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 ) ||
10b0d2: 83 f8 02 cmp $0x2,%eax
10b0d5: 0f 84 91 00 00 00 je 10b16c <_CORE_mutex_Surrender+0xd4>
10b0db: 83 f8 03 cmp $0x3,%eax
10b0de: 0f 84 88 00 00 00 je 10b16c <_CORE_mutex_Surrender+0xd4><== NEVER TAKEN
}
first_node = _Chain_Get_first_unprotected(&holder->lock_mutex);
#endif
holder->resource_count--;
}
the_mutex->holder = NULL;
10b0e4: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
the_mutex->holder_id = 0;
10b0eb: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
/*
* 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 ) ||
10b0f2: 83 f8 02 cmp $0x2,%eax
10b0f5: 74 55 je 10b14c <_CORE_mutex_Surrender+0xb4>
10b0f7: 83 f8 03 cmp $0x3,%eax
10b0fa: 74 50 je 10b14c <_CORE_mutex_Surrender+0xb4><== NEVER TAKEN
/*
* 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 ) ) ) {
10b0fc: 83 ec 0c sub $0xc,%esp
10b0ff: 53 push %ebx
10b100: e8 6b 15 00 00 call 10c670 <_Thread_queue_Dequeue>
10b105: 89 c2 mov %eax,%edx
10b107: 83 c4 10 add $0x10,%esp
10b10a: 85 c0 test %eax,%eax
10b10c: 0f 84 8e 00 00 00 je 10b1a0 <_CORE_mutex_Surrender+0x108>
} else
#endif
{
the_mutex->holder = the_thread;
10b112: 89 43 5c mov %eax,0x5c(%ebx)
the_mutex->holder_id = the_thread->Object.id;
10b115: 8b 40 08 mov 0x8(%eax),%eax
10b118: 89 43 60 mov %eax,0x60(%ebx)
the_mutex->nest_count = 1;
10b11b: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx)
switch ( the_mutex->Attributes.discipline ) {
10b122: 8b 43 48 mov 0x48(%ebx),%eax
10b125: 83 f8 02 cmp $0x2,%eax
10b128: 74 6a je 10b194 <_CORE_mutex_Surrender+0xfc>
10b12a: 83 f8 03 cmp $0x3,%eax
10b12d: 74 45 je 10b174 <_CORE_mutex_Surrender+0xdc><== NEVER TAKEN
10b12f: 90 nop
}
break;
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
10b130: 31 c0 xor %eax,%eax
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
10b132: 8b 5d fc mov -0x4(%ebp),%ebx
10b135: c9 leave
10b136: c3 ret
10b137: 90 nop
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
if ( the_mutex->nest_count != 0 ) {
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
10b138: 8b 43 40 mov 0x40(%ebx),%eax
10b13b: 85 c0 test %eax,%eax
10b13d: 74 f1 je 10b130 <_CORE_mutex_Surrender+0x98><== ALWAYS TAKEN
10b13f: 48 dec %eax <== NOT EXECUTED
10b140: 75 8d jne 10b0cf <_CORE_mutex_Surrender+0x37><== NOT EXECUTED
10b142: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED
10b147: e9 6c ff ff ff jmp 10b0b8 <_CORE_mutex_Surrender+0x20><== NOT EXECUTED
_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 &&
10b14c: 8b 42 1c mov 0x1c(%edx),%eax
10b14f: 85 c0 test %eax,%eax
10b151: 75 a9 jne 10b0fc <_CORE_mutex_Surrender+0x64>
10b153: 8b 42 18 mov 0x18(%edx),%eax
10b156: 3b 42 14 cmp 0x14(%edx),%eax
10b159: 74 a1 je 10b0fc <_CORE_mutex_Surrender+0x64>
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, TRUE );
10b15b: 51 push %ecx
10b15c: 6a 01 push $0x1
10b15e: 50 push %eax
10b15f: 52 push %edx
10b160: e8 ab 0c 00 00 call 10be10 <_Thread_Change_priority>
10b165: 83 c4 10 add $0x10,%esp
10b168: eb 92 jmp 10b0fc <_CORE_mutex_Surrender+0x64>
10b16a: 66 90 xchg %ax,%ax
the_mutex->nest_count++;
return CORE_MUTEX_RELEASE_NOT_ORDER;
}
first_node = _Chain_Get_first_unprotected(&holder->lock_mutex);
#endif
holder->resource_count--;
10b16c: ff 4a 1c decl 0x1c(%edx)
10b16f: e9 70 ff ff ff jmp 10b0e4 <_CORE_mutex_Surrender+0x4c>
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++;
10b174: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
10b177: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED
10b17a: 3b 42 14 cmp 0x14(%edx),%eax <== NOT EXECUTED
10b17d: 73 b1 jae 10b130 <_CORE_mutex_Surrender+0x98><== NOT EXECUTED
the_thread->current_priority){
_Thread_Change_priority(
10b17f: 51 push %ecx <== NOT EXECUTED
10b180: 6a 00 push $0x0 <== NOT EXECUTED
10b182: 50 push %eax <== NOT EXECUTED
10b183: 52 push %edx <== NOT EXECUTED
10b184: e8 87 0c 00 00 call 10be10 <_Thread_Change_priority><== NOT EXECUTED
10b189: 31 c0 xor %eax,%eax <== NOT EXECUTED
10b18b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10b18e: e9 25 ff ff ff jmp 10b0b8 <_CORE_mutex_Surrender+0x20><== NOT EXECUTED
10b193: 90 nop <== NOT EXECUTED
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++;
10b194: ff 42 1c incl 0x1c(%edx)
10b197: 31 c0 xor %eax,%eax
10b199: e9 1a ff ff ff jmp 10b0b8 <_CORE_mutex_Surrender+0x20>
10b19e: 66 90 xchg %ax,%ax
}
break;
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
10b1a0: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx)
10b1a7: 31 c0 xor %eax,%eax
10b1a9: e9 0a ff ff ff jmp 10b0b8 <_CORE_mutex_Surrender+0x20>
0010b1fc <_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
)
{
10b1fc: 55 push %ebp
10b1fd: 89 e5 mov %esp,%ebp
10b1ff: 53 push %ebx
10b200: 83 ec 10 sub $0x10,%esp
10b203: 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)) ) {
10b206: 53 push %ebx
10b207: e8 64 14 00 00 call 10c670 <_Thread_queue_Dequeue>
10b20c: 83 c4 10 add $0x10,%esp
10b20f: 85 c0 test %eax,%eax
10b211: 74 09 je 10b21c <_CORE_semaphore_Surrender+0x20>
10b213: 31 c0 xor %eax,%eax
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
10b215: 8b 5d fc mov -0x4(%ebp),%ebx
10b218: c9 leave
10b219: c3 ret
10b21a: 66 90 xchg %ax,%ax
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
10b21c: 9c pushf
10b21d: fa cli
10b21e: 5a pop %edx
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
10b21f: 8b 43 48 mov 0x48(%ebx),%eax
10b222: 3b 43 40 cmp 0x40(%ebx),%eax
10b225: 72 0d jb 10b234 <_CORE_semaphore_Surrender+0x38><== ALWAYS TAKEN
10b227: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
10b22c: 52 push %edx
10b22d: 9d popf
}
return status;
}
10b22e: 8b 5d fc mov -0x4(%ebp),%ebx
10b231: c9 leave
10b232: c3 ret
10b233: 90 nop
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
10b234: 40 inc %eax
10b235: 89 43 48 mov %eax,0x48(%ebx)
10b238: 31 c0 xor %eax,%eax
10b23a: eb f0 jmp 10b22c <_CORE_semaphore_Surrender+0x30>
0010ada0 <_Chain_Get>:
*/
Chain_Node *_Chain_Get(
Chain_Control *the_chain
)
{
10ada0: 55 push %ebp
10ada1: 89 e5 mov %esp,%ebp
10ada3: 53 push %ebx
10ada4: 8b 4d 08 mov 0x8(%ebp),%ecx
ISR_Level level;
Chain_Node *return_node;
return_node = NULL;
_ISR_Disable( level );
10ada7: 9c pushf
10ada8: fa cli
10ada9: 5b pop %ebx
* 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(
10adaa: 8b 11 mov (%ecx),%edx
if ( !_Chain_Is_empty( the_chain ) )
10adac: 8d 41 04 lea 0x4(%ecx),%eax
10adaf: 39 c2 cmp %eax,%edx
10adb1: 74 11 je 10adc4 <_Chain_Get+0x24>
10adb3: 8b 02 mov (%edx),%eax
10adb5: 89 01 mov %eax,(%ecx)
10adb7: 89 48 04 mov %ecx,0x4(%eax)
return_node = _Chain_Get_first_unprotected( the_chain );
_ISR_Enable( level );
10adba: 53 push %ebx
10adbb: 9d popf
return return_node;
}
10adbc: 89 d0 mov %edx,%eax
10adbe: 5b pop %ebx
10adbf: c9 leave
10adc0: c3 ret
10adc1: 8d 76 00 lea 0x0(%esi),%esi
ISR_Level level;
Chain_Node *return_node;
return_node = NULL;
_ISR_Disable( level );
if ( !_Chain_Is_empty( the_chain ) )
10adc4: 31 d2 xor %edx,%edx
10adc6: eb f2 jmp 10adba <_Chain_Get+0x1a>
0010f05c <_Chain_Initialize>:
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
10f05c: 55 push %ebp
10f05d: 89 e5 mov %esp,%ebp
10f05f: 57 push %edi
10f060: 56 push %esi
10f061: 53 push %ebx
10f062: 8b 75 08 mov 0x8(%ebp),%esi
10f065: 8b 45 10 mov 0x10(%ebp),%eax
10f068: 8b 5d 14 mov 0x14(%ebp),%ebx
size_t size
);
/**
* 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
10f06b: 89 f1 mov %esi,%ecx
Chain_Node *current;
Chain_Node *next;
count = number_nodes;
current = _Chain_Head( the_chain );
the_chain->permanent_null = NULL;
10f06d: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi)
next = starting_address;
while ( count-- ) {
10f074: 85 c0 test %eax,%eax
10f076: 74 22 je 10f09a <_Chain_Initialize+0x3e><== NEVER TAKEN
10f078: 8d 50 ff lea -0x1(%eax),%edx
10f07b: 89 d7 mov %edx,%edi
10f07d: 8b 45 0c mov 0xc(%ebp),%eax
10f080: eb 03 jmp 10f085 <_Chain_Initialize+0x29>
10f082: 66 90 xchg %ax,%ax
10f084: 4a dec %edx
current->next = next;
10f085: 89 01 mov %eax,(%ecx)
next->previous = current;
10f087: 89 48 04 mov %ecx,0x4(%eax)
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
10f08a: 89 c1 mov %eax,%ecx
10f08c: 01 d8 add %ebx,%eax
count = number_nodes;
current = _Chain_Head( the_chain );
the_chain->permanent_null = NULL;
next = starting_address;
while ( count-- ) {
10f08e: 85 d2 test %edx,%edx
10f090: 75 f2 jne 10f084 <_Chain_Initialize+0x28>
10f092: 0f af df imul %edi,%ebx
10f095: 8b 4d 0c mov 0xc(%ebp),%ecx
10f098: 01 d9 add %ebx,%ecx
next->previous = current;
current = next;
next = (Chain_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
current->next = _Chain_Tail( the_chain );
10f09a: 8d 46 04 lea 0x4(%esi),%eax
10f09d: 89 01 mov %eax,(%ecx)
the_chain->last = current;
10f09f: 89 4e 08 mov %ecx,0x8(%esi)
}
10f0a2: 5b pop %ebx
10f0a3: 5e pop %esi
10f0a4: 5f pop %edi
10f0a5: c9 leave
10f0a6: c3 ret
0010eff0 <_Debug_Is_enabled>:
*/
bool _Debug_Is_enabled(
rtems_debug_control level
)
{
10eff0: 55 push %ebp <== NOT EXECUTED
10eff1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10eff3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10eff6: 85 05 20 e7 11 00 test %eax,0x11e720 <== NOT EXECUTED
10effc: 0f 95 c0 setne %al <== NOT EXECUTED
return (_Debug_Level & level) ? true : false;
}
10efff: c9 leave <== NOT EXECUTED
10f000: c3 ret <== NOT EXECUTED
00109d94 <_Event_Seize>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
109d94: 55 push %ebp
109d95: 89 e5 mov %esp,%ebp
109d97: 57 push %edi
109d98: 56 push %esi
109d99: 53 push %ebx
109d9a: 83 ec 0c sub $0xc,%esp
109d9d: 8b 45 08 mov 0x8(%ebp),%eax
109da0: 8b 75 0c mov 0xc(%ebp),%esi
109da3: 8b 55 10 mov 0x10(%ebp),%edx
109da6: 89 55 ec mov %edx,-0x14(%ebp)
109da9: 8b 55 14 mov 0x14(%ebp),%edx
109dac: 89 55 e8 mov %edx,-0x18(%ebp)
rtems_event_set pending_events;
ISR_Level level;
RTEMS_API_Control *api;
Thread_blocking_operation_States sync_state;
executing = _Thread_Executing;
109daf: 8b 1d 1c e7 11 00 mov 0x11e71c,%ebx
executing->Wait.return_code = RTEMS_SUCCESSFUL;
109db5: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx)
api = executing->API_Extensions[ THREAD_API_RTEMS ];
109dbc: 8b bb f4 00 00 00 mov 0xf4(%ebx),%edi
_ISR_Disable( level );
109dc2: 9c pushf
109dc3: fa cli
109dc4: 8f 45 f0 popl -0x10(%ebp)
pending_events = api->pending_events;
109dc7: 8b 17 mov (%edi),%edx
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
109dc9: 89 c1 mov %eax,%ecx
109dcb: 21 d1 and %edx,%ecx
109dcd: 74 14 je 109de3 <_Event_Seize+0x4f>
109dcf: 39 c8 cmp %ecx,%eax
109dd1: 0f 84 91 00 00 00 je 109e68 <_Event_Seize+0xd4>
109dd7: f7 c6 02 00 00 00 test $0x2,%esi
109ddd: 0f 85 85 00 00 00 jne 109e68 <_Event_Seize+0xd4> <== ALWAYS TAKEN
_ISR_Enable( level );
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
109de3: f7 c6 01 00 00 00 test $0x1,%esi
109de9: 75 65 jne 109e50 <_Event_Seize+0xbc>
executing->Wait.return_code = RTEMS_UNSATISFIED;
*event_out = seized_events;
return;
}
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
109deb: c7 05 6c e9 11 00 01 movl $0x1,0x11e96c
109df2: 00 00 00
executing->Wait.option = (uint32_t) option_set;
109df5: 89 73 30 mov %esi,0x30(%ebx)
executing->Wait.count = (uint32_t) event_in;
109df8: 89 43 24 mov %eax,0x24(%ebx)
executing->Wait.return_argument = event_out;
109dfb: 8b 45 e8 mov -0x18(%ebp),%eax
109dfe: 89 43 28 mov %eax,0x28(%ebx)
_ISR_Enable( level );
109e01: ff 75 f0 pushl -0x10(%ebp)
109e04: 9d popf
if ( ticks ) {
109e05: 8b 45 ec mov -0x14(%ebp),%eax
109e08: 85 c0 test %eax,%eax
109e0a: 0f 85 80 00 00 00 jne 109e90 <_Event_Seize+0xfc>
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
}
_Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
109e10: 83 ec 08 sub $0x8,%esp
109e13: 68 00 01 00 00 push $0x100
109e18: 53 push %ebx
109e19: e8 82 2d 00 00 call 10cba0 <_Thread_Set_state>
_ISR_Disable( level );
109e1e: 9c pushf
109e1f: fa cli
109e20: 5a pop %edx
sync_state = _Event_Sync_state;
109e21: a1 6c e9 11 00 mov 0x11e96c,%eax
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
109e26: c7 05 6c e9 11 00 00 movl $0x0,0x11e96c
109e2d: 00 00 00
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
109e30: 83 c4 10 add $0x10,%esp
109e33: 83 f8 01 cmp $0x1,%eax
109e36: 74 4c je 109e84 <_Event_Seize+0xf0>
* 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 );
109e38: 89 55 10 mov %edx,0x10(%ebp)
109e3b: 89 5d 0c mov %ebx,0xc(%ebp)
109e3e: 89 45 08 mov %eax,0x8(%ebp)
}
109e41: 8d 65 f4 lea -0xc(%ebp),%esp
109e44: 5b pop %ebx
109e45: 5e pop %esi
109e46: 5f pop %edi
109e47: 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 );
109e48: e9 77 1f 00 00 jmp 10bdc4 <_Thread_blocking_operation_Cancel>
109e4d: 8d 76 00 lea 0x0(%esi),%esi
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
_ISR_Enable( level );
109e50: ff 75 f0 pushl -0x10(%ebp)
109e53: 9d popf
executing->Wait.return_code = RTEMS_UNSATISFIED;
109e54: c7 43 34 0d 00 00 00 movl $0xd,0x34(%ebx)
*event_out = seized_events;
109e5b: 8b 55 e8 mov -0x18(%ebp),%edx
109e5e: 89 0a mov %ecx,(%edx)
* The blocking thread was satisfied by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
_Thread_blocking_operation_Cancel( sync_state, executing, level );
}
109e60: 8d 65 f4 lea -0xc(%ebp),%esp
109e63: 5b pop %ebx
109e64: 5e pop %esi
109e65: 5f pop %edi
109e66: c9 leave
109e67: c3 ret
pending_events = api->pending_events;
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
(seized_events == event_in || _Options_Is_any( option_set )) ) {
api->pending_events =
109e68: 89 c8 mov %ecx,%eax
109e6a: f7 d0 not %eax
109e6c: 21 d0 and %edx,%eax
109e6e: 89 07 mov %eax,(%edi)
_Event_sets_Clear( pending_events, seized_events );
_ISR_Enable( level );
109e70: ff 75 f0 pushl -0x10(%ebp)
109e73: 9d popf
*event_out = seized_events;
109e74: 8b 45 e8 mov -0x18(%ebp),%eax
109e77: 89 08 mov %ecx,(%eax)
* The blocking thread was satisfied by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
_Thread_blocking_operation_Cancel( sync_state, executing, level );
}
109e79: 8d 65 f4 lea -0xc(%ebp),%esp
109e7c: 5b pop %ebx
109e7d: 5e pop %esi
109e7e: 5f pop %edi
109e7f: c9 leave
109e80: c3 ret
109e81: 8d 76 00 lea 0x0(%esi),%esi
_ISR_Disable( level );
sync_state = _Event_Sync_state;
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
_ISR_Enable( level );
109e84: 52 push %edx
109e85: 9d popf
* The blocking thread was satisfied by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
_Thread_blocking_operation_Cancel( sync_state, executing, level );
}
109e86: 8d 65 f4 lea -0xc(%ebp),%esp
109e89: 5b pop %ebx
109e8a: 5e pop %esi
109e8b: 5f pop %edi
109e8c: c9 leave
109e8d: c3 ret
109e8e: 66 90 xchg %ax,%ax
executing->Wait.return_argument = event_out;
_ISR_Enable( level );
if ( ticks ) {
_Watchdog_Initialize(
109e90: 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.
*
109e93: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
* @param[in] the_heap is the heap to operate upon
109e9a: c7 43 64 38 a0 10 00 movl $0x10a038,0x64(%ebx)
* @param[in] starting_address is the starting address of the memory for
109ea1: 89 43 68 mov %eax,0x68(%ebx)
* the heap
109ea4: 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,
109eab: 8b 55 ec mov -0x14(%ebp),%edx
109eae: 89 53 54 mov %edx,0x54(%ebx)
void *starting_address,
size_t *size
109eb1: 83 ec 08 sub $0x8,%esp
109eb4: 8d 43 48 lea 0x48(%ebx),%eax
109eb7: 50 push %eax
109eb8: 68 3c e7 11 00 push $0x11e73c
109ebd: e8 3a 33 00 00 call 10d1fc <_Watchdog_Insert>
109ec2: 83 c4 10 add $0x10,%esp
109ec5: e9 46 ff ff ff jmp 109e10 <_Event_Seize+0x7c>
00109f20 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
109f20: 55 push %ebp
109f21: 89 e5 mov %esp,%ebp
109f23: 57 push %edi
109f24: 56 push %esi
109f25: 53 push %ebx
109f26: 83 ec 0c sub $0xc,%esp
109f29: 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 ];
109f2c: 8b b3 f4 00 00 00 mov 0xf4(%ebx),%esi
option_set = (rtems_option) the_thread->Wait.option;
109f32: 8b 43 30 mov 0x30(%ebx),%eax
109f35: 89 45 f0 mov %eax,-0x10(%ebp)
_ISR_Disable( level );
109f38: 9c pushf
109f39: fa cli
109f3a: 8f 45 ec popl -0x14(%ebp)
pending_events = api->pending_events;
109f3d: 8b 0e mov (%esi),%ecx
event_condition = (rtems_event_set) the_thread->Wait.count;
109f3f: 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 ) ) {
109f42: 89 d7 mov %edx,%edi
109f44: 21 cf and %ecx,%edi
109f46: 74 70 je 109fb8 <_Event_Surrender+0x98>
/*
* 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() &&
109f48: a1 f8 e6 11 00 mov 0x11e6f8,%eax
109f4d: 85 c0 test %eax,%eax
109f4f: 74 0c je 109f5d <_Event_Surrender+0x3d>
109f51: 3b 1d 1c e7 11 00 cmp 0x11e71c,%ebx
109f57: 0f 84 93 00 00 00 je 109ff0 <_Event_Surrender+0xd0>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
109f5d: f6 43 11 01 testb $0x1,0x11(%ebx)
109f61: 75 0d jne 109f70 <_Event_Surrender+0x50> <== ALWAYS TAKEN
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
109f63: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED
109f66: 9d popf <== NOT EXECUTED
}
109f67: 8d 65 f4 lea -0xc(%ebp),%esp
109f6a: 5b pop %ebx
109f6b: 5e pop %esi
109f6c: 5f pop %edi
109f6d: c9 leave
109f6e: c3 ret
109f6f: 90 nop
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
109f70: 39 fa cmp %edi,%edx
109f72: 74 06 je 109f7a <_Event_Surrender+0x5a>
109f74: f6 45 f0 02 testb $0x2,-0x10(%ebp)
109f78: 74 e9 je 109f63 <_Event_Surrender+0x43> <== NEVER TAKEN
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
109f7a: 89 f8 mov %edi,%eax
109f7c: f7 d0 not %eax
109f7e: 21 c8 and %ecx,%eax
109f80: 89 06 mov %eax,(%esi)
the_thread->Wait.count = 0;
109f82: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
109f89: 8b 43 28 mov 0x28(%ebx),%eax
109f8c: 89 38 mov %edi,(%eax)
_ISR_Flash( level );
109f8e: ff 75 ec pushl -0x14(%ebp)
109f91: 9d popf
109f92: fa cli
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
109f93: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
109f97: 74 2b je 109fc4 <_Event_Surrender+0xa4>
_ISR_Enable( level );
109f99: ff 75 ec pushl -0x14(%ebp)
109f9c: 9d popf
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
109f9d: 83 ec 08 sub $0x8,%esp
109fa0: 68 f8 ff 03 10 push $0x1003fff8
109fa5: 53 push %ebx
109fa6: e8 99 1f 00 00 call 10bf44 <_Thread_Clear_state>
109fab: 83 c4 10 add $0x10,%esp
}
return;
}
}
_ISR_Enable( level );
}
109fae: 8d 65 f4 lea -0xc(%ebp),%esp
109fb1: 5b pop %ebx
109fb2: 5e pop %esi
109fb3: 5f pop %edi
109fb4: c9 leave
109fb5: c3 ret
109fb6: 66 90 xchg %ax,%ax
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
_ISR_Enable( level );
109fb8: ff 75 ec pushl -0x14(%ebp)
109fbb: 9d popf
}
return;
}
}
_ISR_Enable( level );
}
109fbc: 8d 65 f4 lea -0xc(%ebp),%esp
109fbf: 5b pop %ebx
109fc0: 5e pop %esi
109fc1: 5f pop %edi
109fc2: c9 leave
109fc3: c3 ret
* 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
*/
109fc4: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
109fcb: ff 75 ec pushl -0x14(%ebp)
109fce: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
109fcf: 83 ec 0c sub $0xc,%esp
109fd2: 8d 43 48 lea 0x48(%ebx),%eax
109fd5: 50 push %eax
109fd6: e8 51 33 00 00 call 10d32c <_Watchdog_Remove>
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
109fdb: 58 pop %eax
109fdc: 5a pop %edx
109fdd: 68 f8 ff 03 10 push $0x1003fff8
109fe2: 53 push %ebx
109fe3: e8 5c 1f 00 00 call 10bf44 <_Thread_Clear_state>
109fe8: 83 c4 10 add $0x10,%esp
109feb: e9 77 ff ff ff jmp 109f67 <_Event_Surrender+0x47>
/*
* 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() &&
109ff0: a1 6c e9 11 00 mov 0x11e96c,%eax
109ff5: 48 dec %eax
109ff6: 74 0e je 10a006 <_Event_Surrender+0xe6> <== ALWAYS TAKEN
109ff8: a1 6c e9 11 00 mov 0x11e96c,%eax <== NOT EXECUTED
109ffd: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED
10a000: 0f 85 57 ff ff ff jne 109f5d <_Event_Surrender+0x3d> <== 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) ) {
10a006: 39 fa cmp %edi,%edx
10a008: 74 06 je 10a010 <_Event_Surrender+0xf0> <== ALWAYS TAKEN
10a00a: f6 45 f0 02 testb $0x2,-0x10(%ebp) <== NOT EXECUTED
10a00e: 74 1e je 10a02e <_Event_Surrender+0x10e><== NOT EXECUTED
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
10a010: 89 f8 mov %edi,%eax
10a012: f7 d0 not %eax
10a014: 21 c8 and %ecx,%eax
10a016: 89 06 mov %eax,(%esi)
the_thread->Wait.count = 0;
10a018: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
10a01f: 8b 43 28 mov 0x28(%ebx),%eax
10a022: 89 38 mov %edi,(%eax)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
10a024: c7 05 6c e9 11 00 03 movl $0x3,0x11e96c
10a02b: 00 00 00
}
_ISR_Enable( level );
10a02e: ff 75 ec pushl -0x14(%ebp)
10a031: 9d popf
10a032: e9 30 ff ff ff jmp 109f67 <_Event_Surrender+0x47>
0010a038 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
10a038: 55 push %ebp
10a039: 89 e5 mov %esp,%ebp
10a03b: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
10a03e: 8d 45 fc lea -0x4(%ebp),%eax
10a041: 50 push %eax
10a042: ff 75 08 pushl 0x8(%ebp)
10a045: e8 c6 22 00 00 call 10c310 <_Thread_Get>
10a04a: 89 c2 mov %eax,%edx
switch ( location ) {
10a04c: 83 c4 10 add $0x10,%esp
10a04f: 8b 4d fc mov -0x4(%ebp),%ecx
10a052: 85 c9 test %ecx,%ecx
10a054: 75 3e jne 10a094 <_Event_Timeout+0x5c> <== NEVER TAKEN
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
_ISR_Disable( level );
10a056: 9c pushf
10a057: fa cli
10a058: 59 pop %ecx
if ( !the_thread->Wait.count ) { /* verify thread is waiting */
10a059: 8b 40 24 mov 0x24(%eax),%eax
10a05c: 85 c0 test %eax,%eax
10a05e: 74 38 je 10a098 <_Event_Timeout+0x60> <== NEVER TAKEN
_Thread_Unnest_dispatch();
_ISR_Enable( level );
return;
}
the_thread->Wait.count = 0;
10a060: c7 42 24 00 00 00 00 movl $0x0,0x24(%edx)
if ( _Thread_Is_executing( the_thread ) ) {
10a067: 3b 15 1c e7 11 00 cmp 0x11e71c,%edx
10a06d: 74 39 je 10a0a8 <_Event_Timeout+0x70>
(sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
10a06f: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx)
_ISR_Enable( level );
10a076: 51 push %ecx
10a077: 9d popf
10a078: 83 ec 08 sub $0x8,%esp
10a07b: 68 f8 ff 03 10 push $0x1003fff8
10a080: 52 push %edx
10a081: e8 be 1e 00 00 call 10bf44 <_Thread_Clear_state>
10a086: a1 58 e6 11 00 mov 0x11e658,%eax
10a08b: 48 dec %eax
10a08c: a3 58 e6 11 00 mov %eax,0x11e658
10a091: 83 c4 10 add $0x10,%esp
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10a094: c9 leave
10a095: c3 ret
10a096: 66 90 xchg %ax,%ax
10a098: a1 58 e6 11 00 mov 0x11e658,%eax <== NOT EXECUTED
10a09d: 48 dec %eax <== NOT EXECUTED
10a09e: a3 58 e6 11 00 mov %eax,0x11e658 <== NOT EXECUTED
_ISR_Disable( level );
if ( !the_thread->Wait.count ) { /* verify thread is waiting */
_Thread_Unnest_dispatch();
_ISR_Enable( level );
10a0a3: 51 push %ecx <== NOT EXECUTED
10a0a4: 9d popf <== NOT EXECUTED
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10a0a5: c9 leave <== NOT EXECUTED
10a0a6: c3 ret <== NOT EXECUTED
10a0a7: 90 nop <== NOT EXECUTED
return;
}
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
Thread_blocking_operation_States sync = _Event_Sync_state;
10a0a8: a1 6c e9 11 00 mov 0x11e96c,%eax
if ( (sync == THREAD_BLOCKING_OPERATION_SYNCHRONIZED) ||
10a0ad: 83 f8 01 cmp $0x1,%eax
10a0b0: 77 bd ja 10a06f <_Event_Timeout+0x37> <== NEVER TAKEN
(sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
10a0b2: c7 05 6c e9 11 00 02 movl $0x2,0x11e96c
10a0b9: 00 00 00
10a0bc: eb b1 jmp 10a06f <_Event_Timeout+0x37>
0010f2c8 <_Heap_Allocate>:
void *_Heap_Allocate(
Heap_Control *the_heap,
size_t size
)
{
10f2c8: 55 push %ebp
10f2c9: 89 e5 mov %esp,%ebp
10f2cb: 57 push %edi
10f2cc: 56 push %esi
10f2cd: 53 push %ebx
10f2ce: 83 ec 10 sub $0x10,%esp
10f2d1: 8b 7d 08 mov 0x8(%ebp),%edi
Heap_Block *the_block;
void *ptr = NULL;
Heap_Statistics *const stats = &the_heap->stats;
Heap_Block *const tail = _Heap_Tail(the_heap);
the_size =
10f2d4: ff 77 14 pushl 0x14(%edi)
10f2d7: ff 77 10 pushl 0x10(%edi)
10f2da: ff 75 0c pushl 0xc(%ebp)
10f2dd: e8 86 c1 ff ff call 10b468 <_Heap_Calc_block_size>
_Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size);
if(the_size == 0)
10f2e2: 83 c4 10 add $0x10,%esp
10f2e5: 85 c0 test %eax,%eax
10f2e7: 74 3b je 10f324 <_Heap_Allocate+0x5c> <== 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(
10f2e9: 8b 5f 08 mov 0x8(%edi),%ebx
return NULL;
/* Find large enough free block. */
for(the_block = _Heap_First(the_heap), search_count = 0;
the_block != tail;
10f2ec: 39 df cmp %ebx,%edi
10f2ee: 74 34 je 10f324 <_Heap_Allocate+0x5c>
/* 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) {
10f2f0: 3b 43 04 cmp 0x4(%ebx),%eax
10f2f3: 76 5c jbe 10f351 <_Heap_Allocate+0x89>
stats->allocs += 1;
stats->searches += search_count + 1;
_HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size));
break;
10f2f5: 31 f6 xor %esi,%esi
10f2f7: eb 08 jmp 10f301 <_Heap_Allocate+0x39>
10f2f9: 8d 76 00 lea 0x0(%esi),%esi
/* 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) {
10f2fc: 3b 43 04 cmp 0x4(%ebx),%eax
10f2ff: 76 2f jbe 10f330 <_Heap_Allocate+0x68>
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)
10f301: 8b 5b 08 mov 0x8(%ebx),%ebx
10f304: 46 inc %esi
if(the_size == 0)
return NULL;
/* Find large enough free block. */
for(the_block = _Heap_First(the_heap), search_count = 0;
the_block != tail;
10f305: 39 df cmp %ebx,%edi
10f307: 75 f3 jne 10f2fc <_Heap_Allocate+0x34>
10f309: 89 75 f0 mov %esi,-0x10(%ebp)
10f30c: 31 d2 xor %edx,%edx
_HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size));
break;
}
}
if(stats->max_search < search_count)
10f30e: 8b 45 f0 mov -0x10(%ebp),%eax
10f311: 39 47 44 cmp %eax,0x44(%edi)
10f314: 73 03 jae 10f319 <_Heap_Allocate+0x51>
stats->max_search = search_count;
10f316: 89 47 44 mov %eax,0x44(%edi)
return ptr;
}
10f319: 89 d0 mov %edx,%eax
10f31b: 8d 65 f4 lea -0xc(%ebp),%esp
10f31e: 5b pop %ebx
10f31f: 5e pop %esi
10f320: 5f pop %edi
10f321: c9 leave
10f322: c3 ret
10f323: 90 nop
break;
}
}
if(stats->max_search < search_count)
stats->max_search = search_count;
10f324: 31 d2 xor %edx,%edx
return ptr;
}
10f326: 89 d0 mov %edx,%eax
10f328: 8d 65 f4 lea -0xc(%ebp),%esp
10f32b: 5b pop %ebx
10f32c: 5e pop %esi
10f32d: 5f pop %edi
10f32e: c9 leave
10f32f: c3 ret
/* 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) {
10f330: 89 75 f0 mov %esi,-0x10(%ebp)
(void)_Heap_Block_allocate(the_heap, the_block, the_size );
10f333: 52 push %edx
10f334: 50 push %eax
10f335: 53 push %ebx
10f336: 57 push %edi
10f337: e8 60 c1 ff ff call 10b49c <_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
10f33c: 8d 53 08 lea 0x8(%ebx),%edx
ptr = _Heap_User_area(the_block);
stats->allocs += 1;
10f33f: ff 47 48 incl 0x48(%edi)
stats->searches += search_count + 1;
10f342: 8b 47 4c mov 0x4c(%edi),%eax
10f345: 8d 44 06 01 lea 0x1(%esi,%eax,1),%eax
10f349: 89 47 4c mov %eax,0x4c(%edi)
10f34c: 83 c4 10 add $0x10,%esp
10f34f: eb bd jmp 10f30e <_Heap_Allocate+0x46>
/* 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) {
10f351: 31 f6 xor %esi,%esi
10f353: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
10f35a: eb d7 jmp 10f333 <_Heap_Allocate+0x6b>
0010cc60 <_Heap_Allocate_aligned>:
void *_Heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
)
{
10cc60: 55 push %ebp
10cc61: 89 e5 mov %esp,%ebp
10cc63: 57 push %edi
10cc64: 56 push %esi
10cc65: 53 push %ebx
10cc66: 83 ec 20 sub $0x20,%esp
10cc69: 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;
10cc6c: 8b 55 08 mov 0x8(%ebp),%edx
10cc6f: 8b 52 10 mov 0x10(%edx),%edx
10cc72: 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;
10cc75: 8d 48 fc lea -0x4(%eax),%ecx
10cc78: 89 4d e0 mov %ecx,-0x20(%ebp)
uint32_t const the_size =
_Heap_Calc_block_size(size, page_size, the_heap->min_block_size);
10cc7b: 8b 7d 08 mov 0x8(%ebp),%edi
10cc7e: ff 77 14 pushl 0x14(%edi)
10cc81: 52 push %edx
10cc82: 50 push %eax
10cc83: e8 8c 04 00 00 call 10d114 <_Heap_Calc_block_size>
10cc88: 89 45 e4 mov %eax,-0x1c(%ebp)
if(the_size == 0)
10cc8b: 83 c4 10 add $0x10,%esp
10cc8e: 85 c0 test %eax,%eax
10cc90: 0f 84 1a 01 00 00 je 10cdb0 <_Heap_Allocate_aligned+0x150><== NEVER TAKEN
return NULL;
if(alignment == 0)
10cc96: 8b 45 10 mov 0x10(%ebp),%eax
10cc99: 85 c0 test %eax,%eax
10cc9b: 0f 84 03 01 00 00 je 10cda4 <_Heap_Allocate_aligned+0x144>
)
{
return ( the_thread == _Thread_Heir );
}
/**
10cca1: 8b 45 08 mov 0x8(%ebp),%eax
10cca4: 8b 48 08 mov 0x8(%eax),%ecx
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;
10cca7: 39 c8 cmp %ecx,%eax
10cca9: 0f 84 01 01 00 00 je 10cdb0 <_Heap_Allocate_aligned+0x150><== NEVER TAKEN
10ccaf: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
10ccb6: eb 17 jmp 10cccf <_Heap_Allocate_aligned+0x6f>
'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) {
10ccb8: 89 f2 mov %esi,%edx <== NOT EXECUTED
aligned_user_addr = 0;
}
}
}
if(aligned_user_addr) {
10ccba: 85 ff test %edi,%edi
10ccbc: 75 7a jne 10cd38 <_Heap_Allocate_aligned+0xd8><== ALWAYS TAKEN
10ccbe: 66 90 xchg %ax,%ax
/* 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)
10ccc0: 8b 49 08 mov 0x8(%ecx),%ecx
10ccc3: ff 45 f0 incl -0x10(%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;
10ccc6: 39 4d 08 cmp %ecx,0x8(%ebp)
10ccc9: 0f 84 ed 00 00 00 je 10cdbc <_Heap_Allocate_aligned+0x15c>
10cccf: 8b 59 04 mov 0x4(%ecx),%ebx
10ccd2: 83 e3 fe and $0xfffffffe,%ebx
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. */
10ccd5: 39 5d e4 cmp %ebx,-0x1c(%ebp)
10ccd8: 77 e6 ja 10ccc0 <_Heap_Allocate_aligned+0x60>
_H_uptr_t user_addr;
_H_uptr_t aligned_user_addr;
_H_uptr_t const user_area = _H_p2u(_Heap_User_area(the_block));
10ccda: 8d 71 08 lea 0x8(%ecx),%esi
/* 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;
10ccdd: 8d 14 19 lea (%ecx,%ebx,1),%edx
10cce0: 89 55 e8 mov %edx,-0x18(%ebp)
aligned_user_addr = block_end - end_to_user_offs;
10cce3: 89 d7 mov %edx,%edi
10cce5: 2b 7d e0 sub -0x20(%ebp),%edi
RTEMS_INLINE_ROUTINE void _Thread_Dispatch_initialization( void )
{
_Thread_Dispatch_disable_level = 1;
}
10cce8: 89 f8 mov %edi,%eax
10ccea: 31 d2 xor %edx,%edx
10ccec: f7 75 10 divl 0x10(%ebp)
10ccef: 29 d7 sub %edx,%edi
10ccf1: 89 f8 mov %edi,%eax
10ccf3: 31 d2 xor %edx,%edx
10ccf5: f7 75 dc divl -0x24(%ebp)
10ccf8: 89 f8 mov %edi,%eax
10ccfa: 29 d0 sub %edx,%eax
10ccfc: 89 c2 mov %eax,%edx
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) {
10ccfe: 39 c6 cmp %eax,%esi
10cd00: 77 be ja 10ccc0 <_Heap_Allocate_aligned+0x60>
/* 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) {
10cd02: 8b 45 08 mov 0x8(%ebp),%eax
10cd05: 8b 40 14 mov 0x14(%eax),%eax
10cd08: 89 45 ec mov %eax,-0x14(%ebp)
10cd0b: 89 d0 mov %edx,%eax
10cd0d: 29 f0 sub %esi,%eax
10cd0f: 3b 45 ec cmp -0x14(%ebp),%eax
10cd12: 73 a6 jae 10ccba <_Heap_Allocate_aligned+0x5a>
'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) {
10cd14: 89 f8 mov %edi,%eax
10cd16: 29 f0 sub %esi,%eax
10cd18: 39 45 dc cmp %eax,-0x24(%ebp)
10cd1b: 77 9b ja 10ccb8 <_Heap_Allocate_aligned+0x58><== NEVER TAKEN
RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void )
{
return ( _Thread_Dispatch_disable_level == 0 );
}
/**
10cd1d: 89 f0 mov %esi,%eax
10cd1f: 31 d2 xor %edx,%edx
10cd21: f7 75 10 divl 0x10(%ebp)
* This function returns TRUE if dispatching is disabled, and FALSE
10cd24: 85 d2 test %edx,%edx
10cd26: 75 6c jne 10cd94 <_Heap_Allocate_aligned+0x134>
10cd28: 89 f0 mov %esi,%eax
/* 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) {
10cd2a: 39 55 dc cmp %edx,-0x24(%ebp)
10cd2d: 76 91 jbe 10ccc0 <_Heap_Allocate_aligned+0x60>
10cd2f: 89 f2 mov %esi,%edx
10cd31: 89 c7 mov %eax,%edi
aligned_user_addr = 0;
}
}
}
if(aligned_user_addr) {
10cd33: 85 ff test %edi,%edi
10cd35: 74 89 je 10ccc0 <_Heap_Allocate_aligned+0x60><== NEVER TAKEN
10cd37: 90 nop
/* 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;
10cd38: 8b 75 e8 mov -0x18(%ebp),%esi
10cd3b: 83 c6 08 add $0x8,%esi
10cd3e: 29 d6 sub %edx,%esi
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;
10cd40: 89 da mov %ebx,%edx
10cd42: 29 f2 sub %esi,%edx
_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) {
10cd44: 3b 55 ec cmp -0x14(%ebp),%edx
10cd47: 0f 82 87 00 00 00 jb 10cdd4 <_Heap_Allocate_aligned+0x174>
/* Split the block so that lower part is still free, and upper part
becomes used. */
the_block->size = the_rest | HEAP_PREV_USED;
10cd4d: 89 d0 mov %edx,%eax
10cd4f: 83 c8 01 or $0x1,%eax
10cd52: 89 41 04 mov %eax,0x4(%ecx)
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 );
10cd55: 8d 04 11 lea (%ecx,%edx,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
10cd58: 89 c1 mov %eax,%ecx
the_block = _Heap_Block_at(the_block, the_rest);
the_block->prev_size = the_rest;
10cd5a: 89 10 mov %edx,(%eax)
the_block->size = alloc_size;
10cd5c: 89 70 04 mov %esi,0x4(%eax)
_Heap_Block_remove(the_block);
alloc_size = block_size;
stats->free_blocks -= 1;
}
/* Mark the block as used (in the next block). */
_Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED;
10cd5f: 83 4c 31 04 01 orl $0x1,0x4(%ecx,%esi,1)
/* Update statistics */
stats->free_size -= alloc_size;
10cd64: 8b 55 08 mov 0x8(%ebp),%edx
10cd67: 8b 42 30 mov 0x30(%edx),%eax
10cd6a: 29 f0 sub %esi,%eax
10cd6c: 89 42 30 mov %eax,0x30(%edx)
if(stats->min_free_size > stats->free_size)
10cd6f: 3b 42 34 cmp 0x34(%edx),%eax
10cd72: 73 03 jae 10cd77 <_Heap_Allocate_aligned+0x117>
stats->min_free_size = stats->free_size;
10cd74: 89 42 34 mov %eax,0x34(%edx)
stats->used_blocks += 1;
10cd77: 8b 4d 08 mov 0x8(%ebp),%ecx
10cd7a: ff 41 40 incl 0x40(%ecx)
_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;
10cd7d: 8b 41 4c mov 0x4c(%ecx),%eax
10cd80: 8b 55 f0 mov -0x10(%ebp),%edx
10cd83: 8d 44 02 01 lea 0x1(%edx,%eax,1),%eax
10cd87: 89 41 4c mov %eax,0x4c(%ecx)
stats->allocs += 1;
10cd8a: ff 41 48 incl 0x48(%ecx)
check_result(the_heap, the_block, user_addr,
aligned_user_addr, size);
user_ptr = (void*)aligned_user_addr;
10cd8d: 89 f8 mov %edi,%eax
10cd8f: eb 2d jmp 10cdbe <_Heap_Allocate_aligned+0x15e>
10cd91: 8d 76 00 lea 0x0(%esi),%esi
{
return ( _Thread_Dispatch_disable_level == 0 );
}
/**
* This function returns TRUE if dispatching is disabled, and FALSE
10cd94: 8b 7d 10 mov 0x10(%ebp),%edi
10cd97: 8d 04 3e lea (%esi,%edi,1),%eax
10cd9a: 29 d0 sub %edx,%eax
10cd9c: 89 c2 mov %eax,%edx
10cd9e: 29 f2 sub %esi,%edx
10cda0: eb 88 jmp 10cd2a <_Heap_Allocate_aligned+0xca>
10cda2: 66 90 xchg %ax,%ax
_Heap_Calc_block_size(size, page_size, the_heap->min_block_size);
if(the_size == 0)
return NULL;
if(alignment == 0)
10cda4: c7 45 10 04 00 00 00 movl $0x4,0x10(%ebp)
10cdab: e9 f1 fe ff ff jmp 10cca1 <_Heap_Allocate_aligned+0x41>
}
}
}
if(stats->max_search < search_count)
stats->max_search = search_count;
10cdb0: 31 c0 xor %eax,%eax
return user_ptr;
}
10cdb2: 8d 65 f4 lea -0xc(%ebp),%esp
10cdb5: 5b pop %ebx
10cdb6: 5e pop %esi
10cdb7: 5f pop %edi
10cdb8: c9 leave
10cdb9: c3 ret
10cdba: 66 90 xchg %ax,%ax
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;
10cdbc: 31 c0 xor %eax,%eax
}
}
}
}
if(stats->max_search < search_count)
10cdbe: 8b 4d f0 mov -0x10(%ebp),%ecx
10cdc1: 8b 7d 08 mov 0x8(%ebp),%edi
10cdc4: 39 4f 44 cmp %ecx,0x44(%edi)
10cdc7: 73 e9 jae 10cdb2 <_Heap_Allocate_aligned+0x152>
stats->max_search = search_count;
10cdc9: 89 4f 44 mov %ecx,0x44(%edi)
return user_ptr;
}
10cdcc: 8d 65 f4 lea -0xc(%ebp),%esp
10cdcf: 5b pop %ebx
10cdd0: 5e pop %esi
10cdd1: 5f pop %edi
10cdd2: c9 leave
10cdd3: c3 ret
* This routine resets the current context of the calling thread
* to that of its initial state.
*/
RTEMS_INLINE_ROUTINE void _Thread_Restart_self( void )
{
10cdd4: 8b 51 08 mov 0x8(%ecx),%edx
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
10cdd7: 8b 41 0c mov 0xc(%ecx),%eax
if ( _Thread_Executing->fp_context != NULL )
10cdda: 89 50 08 mov %edx,0x8(%eax)
_Context_Restore_fp( &_Thread_Executing->fp_context );
10cddd: 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;
10cde0: 8b 45 08 mov 0x8(%ebp),%eax
10cde3: ff 48 38 decl 0x38(%eax)
10cde6: 89 de mov %ebx,%esi
10cde8: e9 72 ff ff ff jmp 10cd5f <_Heap_Allocate_aligned+0xff>
0010b49c <_Heap_Block_allocate>:
uint32_t _Heap_Block_allocate(
Heap_Control* the_heap,
Heap_Block* the_block,
uint32_t alloc_size
)
{
10b49c: 55 push %ebp
10b49d: 89 e5 mov %esp,%ebp
10b49f: 57 push %edi
10b4a0: 56 push %esi
10b4a1: 53 push %ebx
10b4a2: 8b 75 0c mov 0xc(%ebp),%esi
10b4a5: 8b 7d 10 mov 0x10(%ebp),%edi
10b4a8: 8b 4e 04 mov 0x4(%esi),%ecx
10b4ab: 83 e1 fe and $0xfffffffe,%ecx
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;
10b4ae: 89 cb mov %ecx,%ebx
10b4b0: 29 fb sub %edi,%ebx
_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) {
10b4b2: 8b 45 08 mov 0x8(%ebp),%eax
10b4b5: 3b 58 14 cmp 0x14(%eax),%ebx
10b4b8: 72 4a jb 10b504 <_Heap_Block_allocate+0x68>
10b4ba: 8d 14 3e lea (%esi,%edi,1),%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
*/
10b4bd: 8b 4e 08 mov 0x8(%esi),%ecx
bool _Protected_heap_Get_block_size(
10b4c0: 8b 46 0c mov 0xc(%esi),%eax
Heap_Control *the_heap,
void *starting_address,
size_t *size
10b4c3: 89 4a 08 mov %ecx,0x8(%edx)
);
10b4c6: 89 42 0c mov %eax,0xc(%edx)
10b4c9: 89 50 08 mov %edx,0x8(%eax)
10b4cc: 89 51 0c mov %edx,0xc(%ecx)
becomes used. This is slightly less optimal than leaving lower part
free as it requires replacing block in the free blocks list, but it
makes it possible to reuse this code in the _Heap_Resize_block(). */
Heap_Block *next_block = _Heap_Block_at(the_block, alloc_size);
_Heap_Block_replace(the_block, next_block);
the_block->size = alloc_size | HEAP_PREV_USED;
10b4cf: 89 f8 mov %edi,%eax
10b4d1: 83 c8 01 or $0x1,%eax
10b4d4: 89 46 04 mov %eax,0x4(%esi)
next_block->size = the_rest | HEAP_PREV_USED;
10b4d7: 89 d8 mov %ebx,%eax
10b4d9: 83 c8 01 or $0x1,%eax
10b4dc: 89 42 04 mov %eax,0x4(%edx)
_Heap_Block_at(next_block, the_rest)->prev_size = the_rest;
10b4df: 89 1c 1a mov %ebx,(%edx,%ebx,1)
alloc_size = block_size;
_Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED;
stats->free_blocks -= 1;
}
/* Update statistics */
stats->free_size -= alloc_size;
10b4e2: 8b 55 08 mov 0x8(%ebp),%edx
10b4e5: 8b 42 30 mov 0x30(%edx),%eax
10b4e8: 29 f8 sub %edi,%eax
10b4ea: 89 42 30 mov %eax,0x30(%edx)
if(stats->min_free_size > stats->free_size)
10b4ed: 3b 42 34 cmp 0x34(%edx),%eax
10b4f0: 73 03 jae 10b4f5 <_Heap_Block_allocate+0x59>
stats->min_free_size = stats->free_size;
10b4f2: 89 42 34 mov %eax,0x34(%edx)
stats->used_blocks += 1;
10b4f5: 8b 45 08 mov 0x8(%ebp),%eax
10b4f8: ff 40 40 incl 0x40(%eax)
return alloc_size;
}
10b4fb: 89 f8 mov %edi,%eax
10b4fd: 5b pop %ebx
10b4fe: 5e pop %esi
10b4ff: 5f pop %edi
10b500: c9 leave
10b501: c3 ret
10b502: 66 90 xchg %ax,%ax
* 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
10b504: 8b 56 08 mov 0x8(%esi),%edx
* @param[in] size is the amount of memory to allocate in bytes
10b507: 8b 46 0c mov 0xc(%esi),%eax
* @param[in] alignment the required alignment
10b50a: 89 50 08 mov %edx,0x8(%eax)
* @return NULL if unsuccessful and a pointer to the block if successful
10b50d: 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;
_Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED;
10b510: 83 4c 0e 04 01 orl $0x1,0x4(%esi,%ecx,1)
stats->free_blocks -= 1;
10b515: 8b 55 08 mov 0x8(%ebp),%edx
10b518: ff 4a 38 decl 0x38(%edx)
10b51b: 89 cf mov %ecx,%edi
10b51d: eb c3 jmp 10b4e2 <_Heap_Block_allocate+0x46>
0010b468 <_Heap_Calc_block_size>:
*/
size_t _Heap_Calc_block_size(
size_t size,
uint32_t page_size,
uint32_t min_size)
{
10b468: 55 push %ebp
10b469: 89 e5 mov %esp,%ebp
10b46b: 53 push %ebx
10b46c: 83 ec 04 sub $0x4,%esp
10b46f: 8b 4d 08 mov 0x8(%ebp),%ecx
uint32_t block_size = size + HEAP_BLOCK_USED_OVERHEAD;
10b472: 8d 59 04 lea 0x4(%ecx),%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
10b475: 89 d8 mov %ebx,%eax
10b477: 31 d2 xor %edx,%edx
10b479: f7 75 0c divl 0xc(%ebp)
*/
10b47c: 85 d2 test %edx,%edx
10b47e: 74 05 je 10b485 <_Heap_Calc_block_size+0x1d>
10b480: 03 5d 0c add 0xc(%ebp),%ebx
10b483: 29 d3 sub %edx,%ebx
10b485: 89 d8 mov %ebx,%eax
10b487: 3b 5d 10 cmp 0x10(%ebp),%ebx
10b48a: 73 03 jae 10b48f <_Heap_Calc_block_size+0x27>
10b48c: 8b 45 10 mov 0x10(%ebp),%eax
_Heap_Align_up(&block_size, page_size);
if (block_size < min_size) block_size = min_size;
/* 'block_size' becomes <= 'size' if and only if overflow occured. */
return (block_size > size) ? block_size : 0;
10b48f: 39 c1 cmp %eax,%ecx
10b491: 72 02 jb 10b495 <_Heap_Calc_block_size+0x2d><== ALWAYS TAKEN
10b493: 31 c0 xor %eax,%eax
}
10b495: 5a pop %edx
10b496: 5b pop %ebx
10b497: c9 leave
10b498: c3 ret
00111460 <_Heap_Extend>:
Heap_Control *the_heap,
void *starting_address,
size_t size,
uint32_t *amount_extended
)
{
111460: 55 push %ebp
111461: 89 e5 mov %esp,%ebp
111463: 56 push %esi
111464: 53 push %ebx
111465: 83 ec 10 sub $0x10,%esp
111468: 8b 4d 08 mov 0x8(%ebp),%ecx
11146b: 8b 45 0c mov 0xc(%ebp),%eax
* 5. non-contiguous higher address (NOT SUPPORTED)
*
* As noted, this code only supports (4).
*/
if ( starting_address >= the_heap->begin && /* case 3 */
11146e: 39 41 18 cmp %eax,0x18(%ecx)
111471: 76 15 jbe 111488 <_Heap_Extend+0x28>
111473: 8b 51 1c mov 0x1c(%ecx),%edx
starting_address < the_heap->end
)
return HEAP_EXTEND_ERROR;
if ( starting_address != the_heap->end )
111476: 39 d0 cmp %edx,%eax
111478: 74 22 je 11149c <_Heap_Extend+0x3c>
11147a: b8 02 00 00 00 mov $0x2,%eax
stats->frees -= 1; /* Don't count subsequent call as actual free() */
_Heap_Free( the_heap, _Heap_User_area( old_final ) );
return HEAP_EXTEND_SUCCESSFUL;
}
11147f: 8d 65 f8 lea -0x8(%ebp),%esp
111482: 5b pop %ebx
111483: 5e pop %esi
111484: c9 leave
111485: c3 ret
111486: 66 90 xchg %ax,%ax
* 5. non-contiguous higher address (NOT SUPPORTED)
*
* As noted, this code only supports (4).
*/
if ( starting_address >= the_heap->begin && /* case 3 */
111488: 8b 51 1c mov 0x1c(%ecx),%edx
11148b: 39 d0 cmp %edx,%eax
11148d: 73 e7 jae 111476 <_Heap_Extend+0x16>
11148f: b8 01 00 00 00 mov $0x1,%eax
stats->frees -= 1; /* Don't count subsequent call as actual free() */
_Heap_Free( the_heap, _Heap_User_area( old_final ) );
return HEAP_EXTEND_SUCCESSFUL;
}
111494: 8d 65 f8 lea -0x8(%ebp),%esp
111497: 5b pop %ebx
111498: 5e pop %esi
111499: c9 leave
11149a: c3 ret
11149b: 90 nop
* 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;
11149c: 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 );
11149f: 03 45 10 add 0x10(%ebp),%eax
the_heap->end = _Addresses_Add_offset( the_heap->end, size );
1114a2: 89 41 1c mov %eax,0x1c(%ecx)
the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD;
1114a5: 29 d8 sub %ebx,%eax
1114a7: 8d 70 f8 lea -0x8(%eax),%esi
* 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) || \
1114aa: 89 f0 mov %esi,%eax
1114ac: 31 d2 xor %edx,%edx
1114ae: f7 71 10 divl 0x10(%ecx)
1114b1: 29 d6 sub %edx,%esi
1114b3: 89 f2 mov %esi,%edx
_Heap_Align_down( &the_size, the_heap->page_size );
*amount_extended = size;
1114b5: 8b 45 10 mov 0x10(%ebp),%eax
1114b8: 8b 75 14 mov 0x14(%ebp),%esi
1114bb: 89 06 mov %eax,(%esi)
if( the_size < the_heap->min_block_size )
1114bd: 39 51 14 cmp %edx,0x14(%ecx)
1114c0: 76 06 jbe 1114c8 <_Heap_Extend+0x68> <== ALWAYS TAKEN
1114c2: 31 c0 xor %eax,%eax
1114c4: eb b9 jmp 11147f <_Heap_Extend+0x1f> <== NOT EXECUTED
1114c6: 66 90 xchg %ax,%ax <== NOT EXECUTED
return HEAP_EXTEND_SUCCESSFUL;
old_final->size = the_size | (old_final->size & HEAP_PREV_USED);
1114c8: 8b 43 04 mov 0x4(%ebx),%eax
1114cb: 83 e0 01 and $0x1,%eax
1114ce: 09 d0 or %edx,%eax
1114d0: 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
1114d3: 8d 04 13 lea (%ebx,%edx,1),%eax
new_final = _Heap_Block_at( old_final, the_size );
new_final->size = HEAP_PREV_USED;
1114d6: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
the_heap->final = new_final;
1114dd: 89 41 24 mov %eax,0x24(%ecx)
stats->size += size;
1114e0: 8b 55 10 mov 0x10(%ebp),%edx
1114e3: 01 51 2c add %edx,0x2c(%ecx)
stats->used_blocks += 1;
1114e6: ff 41 40 incl 0x40(%ecx)
stats->frees -= 1; /* Don't count subsequent call as actual free() */
1114e9: ff 49 50 decl 0x50(%ecx)
_Heap_Free( the_heap, _Heap_User_area( old_final ) );
1114ec: 83 ec 08 sub $0x8,%esp
1114ef: 8d 43 08 lea 0x8(%ebx),%eax
1114f2: 50 push %eax
1114f3: 51 push %ecx
1114f4: e8 8b b9 ff ff call 10ce84 <_Heap_Free>
1114f9: 31 c0 xor %eax,%eax
1114fb: 83 c4 10 add $0x10,%esp
1114fe: e9 7c ff ff ff jmp 11147f <_Heap_Extend+0x1f>
0010f35c <_Heap_Free>:
bool _Heap_Free(
Heap_Control *the_heap,
void *starting_address
)
{
10f35c: 55 push %ebp
10f35d: 89 e5 mov %esp,%ebp
10f35f: 57 push %edi
10f360: 56 push %esi
10f361: 53 push %ebx
10f362: 83 ec 18 sub $0x18,%esp
10f365: 8b 7d 08 mov 0x8(%ebp),%edi
10f368: 8b 45 0c mov 0xc(%ebp),%eax
uint32_t the_size;
uint32_t next_size;
Heap_Statistics *const stats = &the_heap->stats;
bool next_is_free;
if ( !_Addresses_Is_in_range(
10f36b: 8b 77 24 mov 0x24(%edi),%esi
10f36e: 8b 4f 20 mov 0x20(%edi),%ecx
Heap_Control *the_heap,
void *starting_address,
size_t *size
);
/**
10f371: 39 c1 cmp %eax,%ecx
10f373: 77 04 ja 10f379 <_Heap_Free+0x1d>
10f375: 39 c6 cmp %eax,%esi
10f377: 73 0b jae 10f384 <_Heap_Free+0x28> <== ALWAYS TAKEN
stats->used_blocks -= 1;
stats->free_size += the_size;
stats->frees += 1;
return( TRUE );
10f379: 31 c0 xor %eax,%eax
}
10f37b: 83 c4 18 add $0x18,%esp
10f37e: 5b pop %ebx
10f37f: 5e pop %esi
10f380: 5f pop %edi
10f381: c9 leave
10f382: c3 ret
10f383: 90 nop
10f384: 8d 58 f8 lea -0x8(%eax),%ebx
10f387: 31 d2 xor %edx,%edx
10f389: f7 77 10 divl 0x10(%edi)
10f38c: 29 d3 sub %edx,%ebx
Heap_Control *the_heap,
void *starting_address,
size_t *size
);
/**
10f38e: 39 d9 cmp %ebx,%ecx
10f390: 77 e7 ja 10f379 <_Heap_Free+0x1d> <== NEVER TAKEN
10f392: 39 de cmp %ebx,%esi
10f394: 72 e3 jb 10f379 <_Heap_Free+0x1d> <== NEVER TAKEN
10f396: 8b 43 04 mov 0x4(%ebx),%eax
10f399: 89 45 dc mov %eax,-0x24(%ebp)
10f39c: 83 e0 fe and $0xfffffffe,%eax
10f39f: 89 45 e8 mov %eax,-0x18(%ebp)
10f3a2: 01 d8 add %ebx,%eax
10f3a4: 89 45 e4 mov %eax,-0x1c(%ebp)
Heap_Control *the_heap,
void *starting_address,
size_t *size
);
/**
10f3a7: 39 c1 cmp %eax,%ecx
10f3a9: 77 ce ja 10f379 <_Heap_Free+0x1d> <== NEVER TAKEN
10f3ab: 39 c6 cmp %eax,%esi
10f3ad: 72 ca jb 10f379 <_Heap_Free+0x1d> <== NEVER TAKEN
10f3af: 8b 50 04 mov 0x4(%eax),%edx
10f3b2: 89 55 e0 mov %edx,-0x20(%ebp)
if ( !_Heap_Is_block_in( the_heap, next_block ) ) {
_HAssert( FALSE );
return( FALSE );
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10f3b5: f6 c2 01 test $0x1,%dl
10f3b8: 74 bf je 10f379 <_Heap_Free+0x1d> <== NEVER TAKEN
10f3ba: 83 e2 fe and $0xfffffffe,%edx
10f3bd: 89 55 ec mov %edx,-0x14(%ebp)
_HAssert( FALSE );
return( FALSE );
}
next_size = _Heap_Block_size( next_block );
next_is_free = next_block < the_heap->final &&
10f3c0: 39 c6 cmp %eax,%esi
10f3c2: 76 74 jbe 10f438 <_Heap_Free+0xdc>
10f3c4: 8b 55 e4 mov -0x1c(%ebp),%edx
10f3c7: 8b 45 ec mov -0x14(%ebp),%eax
10f3ca: 8b 44 02 04 mov 0x4(%edx,%eax,1),%eax
10f3ce: 83 f0 01 xor $0x1,%eax
10f3d1: 89 45 e0 mov %eax,-0x20(%ebp)
10f3d4: 8a 45 e0 mov -0x20(%ebp),%al
10f3d7: 83 e0 01 and $0x1,%eax
!_Heap_Is_prev_used(_Heap_Block_at(next_block, next_size));
if ( !_Heap_Is_prev_used( the_block ) ) {
10f3da: f6 45 dc 01 testb $0x1,-0x24(%ebp)
10f3de: 75 5c jne 10f43c <_Heap_Free+0xe0>
uint32_t const prev_size = the_block->prev_size;
10f3e0: 8b 13 mov (%ebx),%edx
10f3e2: 89 55 f0 mov %edx,-0x10(%ebp)
10f3e5: 29 d3 sub %edx,%ebx
Heap_Control *the_heap,
void *starting_address,
size_t *size
);
/**
10f3e7: 39 d9 cmp %ebx,%ecx
10f3e9: 77 8e ja 10f379 <_Heap_Free+0x1d> <== NEVER TAKEN
10f3eb: 39 de cmp %ebx,%esi
10f3ed: 72 8a jb 10f379 <_Heap_Free+0x1d> <== 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) ) {
10f3ef: f6 43 04 01 testb $0x1,0x4(%ebx)
10f3f3: 74 84 je 10f379 <_Heap_Free+0x1d> <== NEVER TAKEN
_HAssert( FALSE );
return( FALSE );
}
if ( next_is_free ) { /* coalesce both */
10f3f5: 84 c0 test %al,%al
10f3f7: 0f 84 a0 00 00 00 je 10f49d <_Heap_Free+0x141>
uint32_t const size = the_size + prev_size + next_size;
10f3fd: 8b 55 e8 mov -0x18(%ebp),%edx
10f400: 03 55 ec add -0x14(%ebp),%edx
10f403: 03 55 f0 add -0x10(%ebp),%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
10f406: 8b 75 e4 mov -0x1c(%ebp),%esi
10f409: 8b 4e 08 mov 0x8(%esi),%ecx
* @param[in] size is the amount of memory to allocate in bytes
10f40c: 8b 46 0c mov 0xc(%esi),%eax
* @param[in] alignment the required alignment
10f40f: 89 48 08 mov %ecx,0x8(%eax)
* @return NULL if unsuccessful and a pointer to the block if successful
10f412: 89 41 0c mov %eax,0xc(%ecx)
_Heap_Block_remove( next_block );
stats->free_blocks -= 1;
10f415: ff 4f 38 decl 0x38(%edi)
prev_block->size = size | HEAP_PREV_USED;
10f418: 89 d0 mov %edx,%eax
10f41a: 83 c8 01 or $0x1,%eax
10f41d: 89 43 04 mov %eax,0x4(%ebx)
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
10f420: 89 14 13 mov %edx,(%ebx,%edx,1)
10f423: 90 nop
stats->free_blocks += 1;
if ( stats->max_free_blocks < stats->free_blocks )
stats->max_free_blocks = stats->free_blocks;
}
stats->used_blocks -= 1;
10f424: ff 4f 40 decl 0x40(%edi)
stats->free_size += the_size;
10f427: 8b 75 e8 mov -0x18(%ebp),%esi
10f42a: 01 77 30 add %esi,0x30(%edi)
stats->frees += 1;
10f42d: ff 47 50 incl 0x50(%edi)
10f430: b0 01 mov $0x1,%al
10f432: e9 44 ff ff ff jmp 10f37b <_Heap_Free+0x1f>
10f437: 90 nop
_HAssert( FALSE );
return( FALSE );
}
next_size = _Heap_Block_size( next_block );
next_is_free = next_block < the_heap->final &&
10f438: 31 c0 xor %eax,%eax
10f43a: eb 9e jmp 10f3da <_Heap_Free+0x7e>
prev_block->size = size | HEAP_PREV_USED;
next_block->size &= ~HEAP_PREV_USED;
next_block->prev_size = size;
}
}
else if ( next_is_free ) { /* coalesce next */
10f43c: 84 c0 test %al,%al
10f43e: 74 28 je 10f468 <_Heap_Free+0x10c>
uint32_t const size = the_size + next_size;
10f440: 8b 55 ec mov -0x14(%ebp),%edx
10f443: 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
*/
10f446: 8b 75 e4 mov -0x1c(%ebp),%esi
10f449: 8b 4e 08 mov 0x8(%esi),%ecx
bool _Protected_heap_Get_block_size(
10f44c: 8b 46 0c mov 0xc(%esi),%eax
Heap_Control *the_heap,
void *starting_address,
size_t *size
10f44f: 89 4b 08 mov %ecx,0x8(%ebx)
);
10f452: 89 43 0c mov %eax,0xc(%ebx)
10f455: 89 58 08 mov %ebx,0x8(%eax)
10f458: 89 59 0c mov %ebx,0xc(%ecx)
_Heap_Block_replace( next_block, the_block );
the_block->size = size | HEAP_PREV_USED;
10f45b: 89 d0 mov %edx,%eax
10f45d: 83 c8 01 or $0x1,%eax
10f460: 89 43 04 mov %eax,0x4(%ebx)
next_block = _Heap_Block_at( the_block, size );
next_block->prev_size = size;
10f463: 89 14 13 mov %edx,(%ebx,%edx,1)
10f466: eb bc jmp 10f424 <_Heap_Free+0xc8>
bool _Protected_heap_Resize_block(
Heap_Control *the_heap,
void *starting_address,
size_t size
);
10f468: 8b 47 08 mov 0x8(%edi),%eax
/**
10f46b: 89 43 08 mov %eax,0x8(%ebx)
* This routine returns the block of memory which begins
10f46e: 89 7b 0c mov %edi,0xc(%ebx)
* at @a starting_address to @a the_heap. Any coalescing which is
10f471: 89 5f 08 mov %ebx,0x8(%edi)
10f474: 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;
10f477: 8b 45 e8 mov -0x18(%ebp),%eax
10f47a: 83 c8 01 or $0x1,%eax
10f47d: 89 43 04 mov %eax,0x4(%ebx)
next_block->size &= ~HEAP_PREV_USED;
10f480: 8b 45 e4 mov -0x1c(%ebp),%eax
10f483: 83 60 04 fe andl $0xfffffffe,0x4(%eax)
next_block->prev_size = the_size;
10f487: 8b 55 e8 mov -0x18(%ebp),%edx
10f48a: 89 10 mov %edx,(%eax)
stats->free_blocks += 1;
10f48c: 8b 47 38 mov 0x38(%edi),%eax
10f48f: 40 inc %eax
10f490: 89 47 38 mov %eax,0x38(%edi)
if ( stats->max_free_blocks < stats->free_blocks )
10f493: 3b 47 3c cmp 0x3c(%edi),%eax
10f496: 76 8c jbe 10f424 <_Heap_Free+0xc8>
stats->max_free_blocks = stats->free_blocks;
10f498: 89 47 3c mov %eax,0x3c(%edi)
10f49b: eb 87 jmp 10f424 <_Heap_Free+0xc8>
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;
10f49d: 8b 55 e8 mov -0x18(%ebp),%edx
10f4a0: 03 55 f0 add -0x10(%ebp),%edx
prev_block->size = size | HEAP_PREV_USED;
10f4a3: 89 d0 mov %edx,%eax
10f4a5: 83 c8 01 or $0x1,%eax
10f4a8: 89 43 04 mov %eax,0x4(%ebx)
next_block->size &= ~HEAP_PREV_USED;
10f4ab: 8b 45 e4 mov -0x1c(%ebp),%eax
10f4ae: 83 60 04 fe andl $0xfffffffe,0x4(%eax)
next_block->prev_size = size;
10f4b2: 89 10 mov %edx,(%eax)
10f4b4: e9 6b ff ff ff jmp 10f424 <_Heap_Free+0xc8>
00111504 <_Heap_Get_free_information>:
void _Heap_Get_free_information(
Heap_Control *the_heap,
Heap_Information *info
)
{
111504: 55 push %ebp
111505: 89 e5 mov %esp,%ebp
111507: 53 push %ebx
111508: 8b 5d 08 mov 0x8(%ebp),%ebx
11150b: 8b 4d 0c mov 0xc(%ebp),%ecx
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Tail(the_heap);
info->number = 0;
11150e: c7 01 00 00 00 00 movl $0x0,(%ecx)
info->largest = 0;
111514: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx)
info->total = 0;
11151b: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx)
)
{
return ( the_thread == _Thread_Heir );
}
/**
111522: 8b 53 08 mov 0x8(%ebx),%edx
for(the_block = _Heap_First(the_heap);
the_block != tail;
111525: 39 d3 cmp %edx,%ebx
111527: 74 1d je 111546 <_Heap_Get_free_information+0x42><== NEVER TAKEN
111529: 8d 76 00 lea 0x0(%esi),%esi
11152c: 8b 42 04 mov 0x4(%edx),%eax
11152f: 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++;
111532: ff 01 incl (%ecx)
info->total += the_size;
111534: 01 41 08 add %eax,0x8(%ecx)
if ( info->largest < the_size )
111537: 39 41 04 cmp %eax,0x4(%ecx)
11153a: 73 03 jae 11153f <_Heap_Get_free_information+0x3b><== NEVER TAKEN
info->largest = the_size;
11153c: 89 41 04 mov %eax,0x4(%ecx)
info->largest = 0;
info->total = 0;
for(the_block = _Heap_First(the_heap);
the_block != tail;
the_block = the_block->next)
11153f: 8b 52 08 mov 0x8(%edx),%edx
info->number = 0;
info->largest = 0;
info->total = 0;
for(the_block = _Heap_First(the_heap);
the_block != tail;
111542: 39 d3 cmp %edx,%ebx
111544: 75 e6 jne 11152c <_Heap_Get_free_information+0x28>
info->number++;
info->total += the_size;
if ( info->largest < the_size )
info->largest = the_size;
}
}
111546: 5b pop %ebx
111547: c9 leave
111548: c3 ret
0011154c <_Heap_Get_information>:
Heap_Get_information_status _Heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
11154c: 55 push %ebp
11154d: 89 e5 mov %esp,%ebp
11154f: 56 push %esi
111550: 53 push %ebx
111551: 8b 45 08 mov 0x8(%ebp),%eax
111554: 8b 4d 0c mov 0xc(%ebp),%ecx
Heap_Block *the_block = the_heap->start;
111557: 8b 50 20 mov 0x20(%eax),%edx
Heap_Block *const end = the_heap->final;
11155a: 8b 70 24 mov 0x24(%eax),%esi
_HAssert(the_block->prev_size == HEAP_PREV_USED);
_HAssert(_Heap_Is_prev_used(the_block));
the_info->Free.number = 0;
11155d: c7 01 00 00 00 00 movl $0x0,(%ecx)
the_info->Free.total = 0;
111563: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx)
the_info->Free.largest = 0;
11156a: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx)
the_info->Used.number = 0;
111571: c7 41 0c 00 00 00 00 movl $0x0,0xc(%ecx)
the_info->Used.total = 0;
111578: c7 41 14 00 00 00 00 movl $0x0,0x14(%ecx)
the_info->Used.largest = 0;
11157f: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx)
while ( the_block != end ) {
111586: 39 f2 cmp %esi,%edx
111588: 74 42 je 1115cc <_Heap_Get_information+0x80><== NEVER TAKEN
11158a: 8b 5a 04 mov 0x4(%edx),%ebx
11158d: eb 13 jmp 1115a2 <_Heap_Get_information+0x56>
11158f: 90 nop
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) ) {
the_info->Used.number++;
111590: ff 41 0c incl 0xc(%ecx)
the_info->Used.total += the_size;
111593: 01 41 14 add %eax,0x14(%ecx)
if ( the_info->Used.largest < the_size )
111596: 39 41 10 cmp %eax,0x10(%ecx)
111599: 73 03 jae 11159e <_Heap_Get_information+0x52>
the_info->Used.largest = the_size;
11159b: 89 41 10 mov %eax,0x10(%ecx)
the_info->Free.largest = 0;
the_info->Used.number = 0;
the_info->Used.total = 0;
the_info->Used.largest = 0;
while ( the_block != end ) {
11159e: 39 d6 cmp %edx,%esi
1115a0: 74 2a je 1115cc <_Heap_Get_information+0x80>
1115a2: 89 d8 mov %ebx,%eax
1115a4: 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
1115a7: 01 c2 add %eax,%edx
1115a9: 8b 5a 04 mov 0x4(%edx),%ebx
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) ) {
1115ac: f6 c3 01 test $0x1,%bl
1115af: 75 df jne 111590 <_Heap_Get_information+0x44>
the_info->Used.number++;
the_info->Used.total += the_size;
if ( the_info->Used.largest < the_size )
the_info->Used.largest = the_size;
} else {
the_info->Free.number++;
1115b1: ff 01 incl (%ecx)
the_info->Free.total += the_size;
1115b3: 01 41 08 add %eax,0x8(%ecx)
if ( the_info->Free.largest < the_size )
1115b6: 39 41 04 cmp %eax,0x4(%ecx)
1115b9: 73 03 jae 1115be <_Heap_Get_information+0x72><== NEVER TAKEN
the_info->Free.largest = the_size;
1115bb: 89 41 04 mov %eax,0x4(%ecx)
if ( the_size != next_block->prev_size )
1115be: 39 02 cmp %eax,(%edx)
1115c0: 74 dc je 11159e <_Heap_Get_information+0x52><== ALWAYS TAKEN
1115c2: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
"used" as client never allocated it. Make 'Used.total' contain this
blocks' overhead though. */
the_info->Used.total += HEAP_OVERHEAD;
return HEAP_GET_INFORMATION_SUCCESSFUL;
}
1115c7: 5b pop %ebx <== NOT EXECUTED
1115c8: 5e pop %esi <== NOT EXECUTED
1115c9: c9 leave <== NOT EXECUTED
1115ca: c3 ret <== NOT EXECUTED
1115cb: 90 nop <== NOT EXECUTED
}
/* 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;
1115cc: 83 41 14 08 addl $0x8,0x14(%ecx)
1115d0: 31 c0 xor %eax,%eax
return HEAP_GET_INFORMATION_SUCCESSFUL;
}
1115d2: 5b pop %ebx
1115d3: 5e pop %esi
1115d4: c9 leave
1115d5: c3 ret
0010b338 <_Heap_Initialize>:
Heap_Control *the_heap,
void *starting_address,
size_t size,
uint32_t page_size
)
{
10b338: 55 push %ebp
10b339: 89 e5 mov %esp,%ebp
10b33b: 57 push %edi
10b33c: 56 push %esi
10b33d: 53 push %ebx
10b33e: 83 ec 08 sub $0x8,%esp
10b341: 8b 7d 08 mov 0x8(%ebp),%edi
10b344: 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)
10b347: 85 c9 test %ecx,%ecx
10b349: 0f 85 fd 00 00 00 jne 10b44c <_Heap_Initialize+0x114>
10b34f: b1 04 mov $0x4,%cl
10b351: 31 f6 xor %esi,%esi
/* 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;
10b353: 8b 5d 0c mov 0xc(%ebp),%ebx
10b356: 83 c3 08 add $0x8,%ebx
10b359: 89 d8 mov %ebx,%eax
10b35b: 31 d2 xor %edx,%edx
10b35d: f7 f1 div %ecx
10b35f: 85 d2 test %edx,%edx
10b361: 74 05 je 10b368 <_Heap_Initialize+0x30>
10b363: 8d 1c 19 lea (%ecx,%ebx,1),%ebx
10b366: 29 d3 sub %edx,%ebx
_Heap_Align_up_uptr ( &aligned_start, page_size );
aligned_start -= HEAP_BLOCK_USER_OFFSET;
10b368: 83 eb 08 sub $0x8,%ebx
*
* @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
*/
10b36b: 85 f6 test %esi,%esi
10b36d: 0f 85 cd 00 00 00 jne 10b440 <_Heap_Initialize+0x108>
10b373: b8 10 00 00 00 mov $0x10,%eax
10b378: 89 47 14 mov %eax,0x14(%edi)
/* 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);
10b37b: 89 d8 mov %ebx,%eax
10b37d: 2b 45 0c sub 0xc(%ebp),%eax
10b380: 83 c0 08 add $0x8,%eax
if ( size < overhead )
10b383: 3b 45 10 cmp 0x10(%ebp),%eax
10b386: 0f 87 a8 00 00 00 ja 10b434 <_Heap_Initialize+0xfc> <== NEVER TAKEN
return 0; /* Too small area for the heap */
the_size = size - overhead;
10b38c: 8b 75 10 mov 0x10(%ebp),%esi
10b38f: 29 c6 sub %eax,%esi
*
* @return free block information filled in.
*/
bool _Protected_heap_Get_free_information(
Heap_Control *the_heap,
Heap_Information *info
10b391: 89 f0 mov %esi,%eax
10b393: 31 d2 xor %edx,%edx
10b395: f7 f1 div %ecx
_Heap_Align_down ( &the_size, page_size );
if ( the_size == 0 )
10b397: 29 d6 sub %edx,%esi
10b399: 0f 84 95 00 00 00 je 10b434 <_Heap_Initialize+0xfc>
return 0; /* Too small area for the heap */
the_heap->page_size = page_size;
10b39f: 89 4f 10 mov %ecx,0x10(%edi)
the_heap->begin = starting_address;
10b3a2: 8b 45 0c mov 0xc(%ebp),%eax
10b3a5: 89 47 18 mov %eax,0x18(%edi)
the_heap->end = starting_address + size;
10b3a8: 8b 45 0c mov 0xc(%ebp),%eax
10b3ab: 03 45 10 add 0x10(%ebp),%eax
10b3ae: 89 47 1c mov %eax,0x1c(%edi)
the_block = (Heap_Block *) aligned_start;
the_block->prev_size = page_size;
10b3b1: 89 0b mov %ecx,(%ebx)
the_block->size = the_size | HEAP_PREV_USED;
10b3b3: 89 f0 mov %esi,%eax
10b3b5: 83 c8 01 or $0x1,%eax
10b3b8: 89 43 04 mov %eax,0x4(%ebx)
the_block->next = _Heap_Tail( the_heap );
10b3bb: 89 7b 08 mov %edi,0x8(%ebx)
the_block->prev = _Heap_Head( the_heap );
10b3be: 89 7b 0c mov %edi,0xc(%ebx)
_Heap_Head(the_heap)->next = the_block;
10b3c1: 89 5f 08 mov %ebx,0x8(%edi)
_Heap_Tail(the_heap)->prev = the_block;
10b3c4: 89 5f 0c mov %ebx,0xc(%edi)
the_heap->start = the_block;
10b3c7: 89 5f 20 mov %ebx,0x20(%edi)
* @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
10b3ca: 8d 04 33 lea (%ebx,%esi,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 */
10b3cd: 89 47 24 mov %eax,0x24(%edi)
the_block->prev_size = the_size; /* Previous block is free */
10b3d0: 89 30 mov %esi,(%eax)
the_block->size = page_size;
10b3d2: 89 48 04 mov %ecx,0x4(%eax)
stats->size = size;
10b3d5: 8b 45 10 mov 0x10(%ebp),%eax
10b3d8: 89 47 2c mov %eax,0x2c(%edi)
stats->free_size = the_size;
10b3db: 89 77 30 mov %esi,0x30(%edi)
stats->min_free_size = the_size;
10b3de: 89 77 34 mov %esi,0x34(%edi)
stats->free_blocks = 1;
10b3e1: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi)
stats->max_free_blocks = 1;
10b3e8: c7 47 3c 01 00 00 00 movl $0x1,0x3c(%edi)
stats->used_blocks = 0;
10b3ef: c7 47 40 00 00 00 00 movl $0x0,0x40(%edi)
stats->max_search = 0;
10b3f6: c7 47 44 00 00 00 00 movl $0x0,0x44(%edi)
stats->allocs = 0;
10b3fd: c7 47 48 00 00 00 00 movl $0x0,0x48(%edi)
stats->searches = 0;
10b404: c7 47 4c 00 00 00 00 movl $0x0,0x4c(%edi)
stats->frees = 0;
10b40b: c7 47 50 00 00 00 00 movl $0x0,0x50(%edi)
stats->resizes = 0;
10b412: c7 47 54 00 00 00 00 movl $0x0,0x54(%edi)
stats->instance = instance++;
10b419: a1 c0 e3 11 00 mov 0x11e3c0,%eax
10b41e: 89 47 28 mov %eax,0x28(%edi)
10b421: 40 inc %eax
10b422: a3 c0 e3 11 00 mov %eax,0x11e3c0
return ( the_size - HEAP_BLOCK_USED_OVERHEAD );
10b427: 8d 46 fc lea -0x4(%esi),%eax
}
10b42a: 83 c4 08 add $0x8,%esp
10b42d: 5b pop %ebx
10b42e: 5e pop %esi
10b42f: 5f pop %edi
10b430: c9 leave
10b431: c3 ret
10b432: 66 90 xchg %ax,%ax
stats->searches = 0;
stats->frees = 0;
stats->resizes = 0;
stats->instance = instance++;
return ( the_size - HEAP_BLOCK_USED_OVERHEAD );
10b434: 31 c0 xor %eax,%eax
}
10b436: 83 c4 08 add $0x8,%esp
10b439: 5b pop %ebx
10b43a: 5e pop %esi
10b43b: 5f pop %edi
10b43c: c9 leave
10b43d: c3 ret
10b43e: 66 90 xchg %ax,%ax
*
* @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
*/
10b440: 8d 41 10 lea 0x10(%ecx),%eax
10b443: 29 f0 sub %esi,%eax
10b445: e9 2e ff ff ff jmp 10b378 <_Heap_Initialize+0x40>
10b44a: 66 90 xchg %ax,%ax
10b44c: 89 c8 mov %ecx,%eax
10b44e: 83 e0 03 and $0x3,%eax
10b451: 74 05 je 10b458 <_Heap_Initialize+0x120>
10b453: 83 c1 04 add $0x4,%ecx
10b456: 29 c1 sub %eax,%ecx
10b458: b8 10 00 00 00 mov $0x10,%eax
10b45d: 31 d2 xor %edx,%edx
10b45f: f7 f1 div %ecx
10b461: 89 d6 mov %edx,%esi
10b463: e9 eb fe ff ff jmp 10b353 <_Heap_Initialize+0x1b>
00116ac8 <_Heap_Resize_block>:
void *starting_address,
size_t size,
uint32_t *old_mem_size,
uint32_t *avail_mem_size
)
{
116ac8: 55 push %ebp
116ac9: 89 e5 mov %esp,%ebp
116acb: 57 push %edi
116acc: 56 push %esi
116acd: 53 push %ebx
116ace: 83 ec 3c sub $0x3c,%esp
116ad1: 8b 75 08 mov 0x8(%ebp),%esi
116ad4: 8b 4d 0c mov 0xc(%ebp),%ecx
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;
116ad7: 8b 46 14 mov 0x14(%esi),%eax
116ada: 89 45 e0 mov %eax,-0x20(%ebp)
uint32_t const page_size = the_heap->page_size;
116add: 8b 56 10 mov 0x10(%esi),%edx
116ae0: 89 55 e4 mov %edx,-0x1c(%ebp)
*old_mem_size = 0;
116ae3: 8b 7d 14 mov 0x14(%ebp),%edi
116ae6: c7 07 00 00 00 00 movl $0x0,(%edi)
*avail_mem_size = 0;
116aec: 8b 45 18 mov 0x18(%ebp),%eax
116aef: c7 00 00 00 00 00 movl $0x0,(%eax)
116af5: 8d 59 f8 lea -0x8(%ecx),%ebx
116af8: 89 c8 mov %ecx,%eax
116afa: 31 d2 xor %edx,%edx
116afc: f7 76 10 divl 0x10(%esi)
116aff: 29 d3 sub %edx,%ebx
116b01: 8b 56 24 mov 0x24(%esi),%edx
116b04: 8b 46 20 mov 0x20(%esi),%eax
/* end of include file */
116b07: 39 c3 cmp %eax,%ebx
116b09: 72 04 jb 116b0f <_Heap_Resize_block+0x47><== NEVER TAKEN
116b0b: 39 d3 cmp %edx,%ebx
116b0d: 76 0d jbe 116b1c <_Heap_Resize_block+0x54>
}
}
}
++stats->resizes;
return HEAP_RESIZE_SUCCESSFUL;
116b0f: b8 02 00 00 00 mov $0x2,%eax
}
116b14: 8d 65 f4 lea -0xc(%ebp),%esp
116b17: 5b pop %ebx
116b18: 5e pop %esi
116b19: 5f pop %edi
116b1a: c9 leave
116b1b: c3 ret
_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;
116b1c: 8b 7b 04 mov 0x4(%ebx),%edi
116b1f: 89 7d cc mov %edi,-0x34(%ebp)
116b22: 83 e7 fe and $0xfffffffe,%edi
116b25: 89 7d d8 mov %edi,-0x28(%ebp)
116b28: 01 df add %ebx,%edi
116b2a: 89 7d c0 mov %edi,-0x40(%ebp)
/* end of include file */
116b2d: 39 f8 cmp %edi,%eax
116b2f: 77 de ja 116b0f <_Heap_Resize_block+0x47><== NEVER TAKEN
116b31: 39 fa cmp %edi,%edx
116b33: 72 da jb 116b0f <_Heap_Resize_block+0x47><== NEVER TAKEN
116b35: 8b 47 04 mov 0x4(%edi),%eax
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) ||
116b38: a8 01 test $0x1,%al
116b3a: 74 d3 je 116b0f <_Heap_Resize_block+0x47><== NEVER TAKEN
116b3c: 83 e0 fe and $0xfffffffe,%eax
116b3f: 89 45 d0 mov %eax,-0x30(%ebp)
116b42: 01 f8 add %edi,%eax
116b44: 89 45 d4 mov %eax,-0x2c(%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) ||
116b47: 39 fa cmp %edi,%edx
116b49: 0f 84 11 01 00 00 je 116c60 <_Heap_Resize_block+0x198><== NEVER TAKEN
116b4f: 8b 55 d4 mov -0x2c(%ebp),%edx
116b52: 8b 42 04 mov 0x4(%edx),%eax
116b55: 83 e0 01 and $0x1,%eax
116b58: 88 45 f3 mov %al,-0xd(%ebp)
_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;
116b5b: 8b 7d cc mov -0x34(%ebp),%edi
116b5e: 83 e7 01 and $0x1,%edi
116b61: 89 7d dc mov %edi,-0x24(%ebp)
next_next_block = _Heap_Block_at(next_block, next_block_size);
next_is_used = (next_block == the_heap->final) ||
_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)
116b64: 8b 45 c0 mov -0x40(%ebp),%eax
116b67: 29 c8 sub %ecx,%eax
116b69: 83 c0 04 add $0x4,%eax
+ HEAP_BLOCK_HEADER_OFFSET;
*old_mem_size = old_user_size;
116b6c: 8b 55 14 mov 0x14(%ebp),%edx
116b6f: 89 02 mov %eax,(%edx)
if (size > old_user_size) {
116b71: 3b 45 10 cmp 0x10(%ebp),%eax
116b74: 73 3a jae 116bb0 <_Heap_Resize_block+0xe8>
/* 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 */
116b76: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
116b7a: 75 29 jne 116ba5 <_Heap_Resize_block+0xdd>
return HEAP_RESIZE_UNSATISFIED;
else {
uint32_t add_block_size = size - old_user_size;
116b7c: 8b 4d 10 mov 0x10(%ebp),%ecx
116b7f: 29 c1 sub %eax,%ecx
116b81: 89 c8 mov %ecx,%eax
116b83: 31 d2 xor %edx,%edx
116b85: f7 75 e4 divl -0x1c(%ebp)
116b88: 85 d2 test %edx,%edx
116b8a: 74 05 je 116b91 <_Heap_Resize_block+0xc9><== NEVER TAKEN
116b8c: 03 4d e4 add -0x1c(%ebp),%ecx
116b8f: 29 d1 sub %edx,%ecx
116b91: 89 c8 mov %ecx,%eax
116b93: 3b 4d e0 cmp -0x20(%ebp),%ecx
116b96: 0f 82 a0 00 00 00 jb 116c3c <_Heap_Resize_block+0x174><== ALWAYS TAKEN
_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)
116b9c: 39 45 d0 cmp %eax,-0x30(%ebp)
116b9f: 0f 83 9f 00 00 00 jae 116c44 <_Heap_Resize_block+0x17c><== ALWAYS TAKEN
}
}
}
++stats->resizes;
return HEAP_RESIZE_SUCCESSFUL;
116ba5: b8 01 00 00 00 mov $0x1,%eax
116baa: e9 65 ff ff ff jmp 116b14 <_Heap_Resize_block+0x4c>
116baf: 90 nop
--stats->used_blocks;
}
} else {
/* Calculate how much memory we could free */
uint32_t free_block_size = old_user_size - size;
116bb0: 89 c1 mov %eax,%ecx
116bb2: 2b 4d 10 sub 0x10(%ebp),%ecx
116bb5: 89 c8 mov %ecx,%eax
116bb7: 31 d2 xor %edx,%edx
116bb9: f7 75 e4 divl -0x1c(%ebp)
_Heap_Align_down(&free_block_size, page_size);
if (free_block_size > 0) {
116bbc: 29 d1 sub %edx,%ecx
116bbe: 89 4d e8 mov %ecx,-0x18(%ebp)
116bc1: 74 69 je 116c2c <_Heap_Resize_block+0x164>
/* 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;
116bc3: 8b 55 d8 mov -0x28(%ebp),%edx
116bc6: 29 ca sub %ecx,%edx
116bc8: 89 55 ec mov %edx,-0x14(%ebp)
if (new_block_size < min_block_size) {
116bcb: 39 55 e0 cmp %edx,-0x20(%ebp)
116bce: 76 0d jbe 116bdd <_Heap_Resize_block+0x115>
uint32_t delta = min_block_size - new_block_size;
116bd0: 8b 45 e0 mov -0x20(%ebp),%eax
116bd3: 29 d0 sub %edx,%eax
_HAssert(free_block_size >= delta);
free_block_size -= delta;
if (free_block_size == 0) {
116bd5: 29 45 e8 sub %eax,-0x18(%ebp)
116bd8: 74 52 je 116c2c <_Heap_Resize_block+0x164><== ALWAYS TAKEN
++stats->resizes;
return HEAP_RESIZE_SUCCESSFUL;
}
new_block_size += delta;
116bda: 01 45 ec add %eax,-0x14(%ebp) <== 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) {
116bdd: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
116be1: 0f 85 85 00 00 00 jne 116c6c <_Heap_Resize_block+0x1a4><== NEVER TAKEN
116be7: 8b 7d ec mov -0x14(%ebp),%edi
116bea: 8d 14 3b lea (%ebx,%edi,1),%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;
116bed: 8b 4d e8 mov -0x18(%ebp),%ecx
116bf0: 03 4d d0 add -0x30(%ebp),%ecx
_HAssert(_Heap_Is_block_in(the_heap, next_next_block));
the_block->size = new_block_size | prev_used_flag;
116bf3: 8b 45 dc mov -0x24(%ebp),%eax
116bf6: 09 c7 or %eax,%edi
116bf8: 89 7b 04 mov %edi,0x4(%ebx)
new_next_block->size = new_next_block_size | HEAP_PREV_USED;
116bfb: 89 c8 mov %ecx,%eax
116bfd: 83 c8 01 or $0x1,%eax
116c00: 89 42 04 mov %eax,0x4(%edx)
next_next_block->prev_size = new_next_block_size;
116c03: 8b 7d d4 mov -0x2c(%ebp),%edi
116c06: 89 0f mov %ecx,(%edi)
{
return (state == SYSTEM_STATE_FAILED);
}
/**@}*/
116c08: 8b 45 c0 mov -0x40(%ebp),%eax
116c0b: 8b 58 08 mov 0x8(%eax),%ebx
#endif
116c0e: 8b 40 0c mov 0xc(%eax),%eax
/* end of include file */
116c11: 89 5a 08 mov %ebx,0x8(%edx)
116c14: 89 42 0c mov %eax,0xc(%edx)
116c17: 89 50 08 mov %edx,0x8(%eax)
116c1a: 89 53 0c mov %edx,0xc(%ebx)
_Heap_Block_replace(next_block, new_next_block);
the_heap->stats.free_size += free_block_size;
116c1d: 8b 45 e8 mov -0x18(%ebp),%eax
116c20: 01 46 30 add %eax,0x30(%esi)
*avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD;
116c23: 83 e9 04 sub $0x4,%ecx
116c26: 8b 55 18 mov 0x18(%ebp),%edx
116c29: 89 0a mov %ecx,(%edx)
116c2b: 90 nop
*avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD;
}
}
}
++stats->resizes;
116c2c: ff 46 54 incl 0x54(%esi)
116c2f: 31 c0 xor %eax,%eax
return HEAP_RESIZE_SUCCESSFUL;
}
116c31: 8d 65 f4 lea -0xc(%ebp),%esp
116c34: 5b pop %ebx
116c35: 5e pop %esi
116c36: 5f pop %edi
116c37: c9 leave
116c38: c3 ret
116c39: 8d 76 00 lea 0x0(%esi),%esi
116c3c: 8b 45 e0 mov -0x20(%ebp),%eax
116c3f: e9 58 ff ff ff jmp 116b9c <_Heap_Resize_block+0xd4>
_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)
return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */
add_block_size =
116c44: 52 push %edx
116c45: 50 push %eax
116c46: ff 75 c0 pushl -0x40(%ebp)
116c49: 56 push %esi
116c4a: e8 4d 48 ff ff call 10b49c <_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;
116c4f: 03 45 d8 add -0x28(%ebp),%eax
116c52: 0b 45 dc or -0x24(%ebp),%eax
116c55: 89 43 04 mov %eax,0x4(%ebx)
--stats->used_blocks;
116c58: ff 4e 40 decl 0x40(%esi)
116c5b: 83 c4 10 add $0x10,%esp
116c5e: eb cc jmp 116c2c <_Heap_Resize_block+0x164>
!_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) ||
116c60: c6 45 f3 01 movb $0x1,-0xd(%ebp) <== NOT EXECUTED
116c64: e9 f2 fe ff ff jmp 116b5b <_Heap_Resize_block+0x93><== NOT EXECUTED
116c69: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
next_next_block->prev_size = new_next_block_size;
_Heap_Block_replace(next_block, new_next_block);
the_heap->stats.free_size += free_block_size;
*avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD;
} else if (free_block_size >= min_block_size) {
116c6c: 8b 7d e8 mov -0x18(%ebp),%edi <== NOT EXECUTED
116c6f: 39 7d e0 cmp %edi,-0x20(%ebp) <== NOT EXECUTED
116c72: 77 b8 ja 116c2c <_Heap_Resize_block+0x164><== NOT EXECUTED
/* Split the block into 2 used parts, then free the second one. */
the_block->size = new_block_size | prev_used_flag;
116c74: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
116c77: 09 45 dc or %eax,-0x24(%ebp) <== NOT EXECUTED
116c7a: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED
116c7d: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED
116c80: 8d 04 03 lea (%ebx,%eax,1),%eax <== NOT EXECUTED
next_block = _Heap_Block_at(the_block, new_block_size);
next_block->size = free_block_size | HEAP_PREV_USED;
116c83: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED
116c86: 83 ca 01 or $0x1,%edx <== NOT EXECUTED
116c89: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED
++stats->used_blocks; /* We have created used block */
116c8c: ff 46 40 incl 0x40(%esi) <== NOT EXECUTED
--stats->frees; /* Don't count next call in stats */
116c8f: ff 4e 50 decl 0x50(%esi) <== NOT EXECUTED
_Heap_Free(the_heap, _Heap_User_area(next_block));
116c92: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
116c95: 83 c0 08 add $0x8,%eax <== NOT EXECUTED
116c98: 50 push %eax <== NOT EXECUTED
116c99: 56 push %esi <== NOT EXECUTED
116c9a: e8 bd 86 ff ff call 10f35c <_Heap_Free> <== NOT EXECUTED
*avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD;
116c9f: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED
116ca2: 83 e8 04 sub $0x4,%eax <== NOT EXECUTED
116ca5: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED
116ca8: 89 02 mov %eax,(%edx) <== NOT EXECUTED
116caa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
116cad: e9 7a ff ff ff jmp 116c2c <_Heap_Resize_block+0x164><== NOT EXECUTED
00116cb4 <_Heap_Size_of_user_area>:
bool _Heap_Size_of_user_area(
Heap_Control *the_heap,
void *starting_address,
size_t *size
)
{
116cb4: 55 push %ebp
116cb5: 89 e5 mov %esp,%ebp
116cb7: 57 push %edi
116cb8: 56 push %esi
116cb9: 53 push %ebx
116cba: 83 ec 0c sub $0xc,%esp
116cbd: 8b 7d 0c mov 0xc(%ebp),%edi
Heap_Block *the_block;
Heap_Block *next_block;
uint32_t the_size;
if ( !_Addresses_Is_in_range(
116cc0: 8b 45 08 mov 0x8(%ebp),%eax
116cc3: 8b 70 24 mov 0x24(%eax),%esi
116cc6: 8b 48 20 mov 0x20(%eax),%ecx
/* end of include file */
116cc9: 39 f9 cmp %edi,%ecx
116ccb: 77 04 ja 116cd1 <_Heap_Size_of_user_area+0x1d>
116ccd: 39 fe cmp %edi,%esi
116ccf: 73 0b jae 116cdc <_Heap_Size_of_user_area+0x28><== ALWAYS TAKEN
area of 'the_block'. */
*size = _Addresses_Subtract ( next_block, starting_address )
+ HEAP_BLOCK_HEADER_OFFSET;
return( TRUE );
116cd1: 31 c0 xor %eax,%eax
}
116cd3: 83 c4 0c add $0xc,%esp
116cd6: 5b pop %ebx
116cd7: 5e pop %esi
116cd8: 5f pop %edi
116cd9: c9 leave
116cda: c3 ret
116cdb: 90 nop
116cdc: 8d 57 f8 lea -0x8(%edi),%edx
116cdf: 89 55 e8 mov %edx,-0x18(%ebp)
116ce2: 89 f8 mov %edi,%eax
116ce4: 8b 5d 08 mov 0x8(%ebp),%ebx
116ce7: 31 d2 xor %edx,%edx
116ce9: f7 73 10 divl 0x10(%ebx)
116cec: 29 55 e8 sub %edx,-0x18(%ebp)
/* end of include file */
116cef: 3b 4d e8 cmp -0x18(%ebp),%ecx
116cf2: 77 dd ja 116cd1 <_Heap_Size_of_user_area+0x1d><== NEVER TAKEN
116cf4: 3b 75 e8 cmp -0x18(%ebp),%esi
116cf7: 72 d8 jb 116cd1 <_Heap_Size_of_user_area+0x1d><== NEVER TAKEN
116cf9: 8b 55 e8 mov -0x18(%ebp),%edx
116cfc: 8b 42 04 mov 0x4(%edx),%eax
116cff: 83 e0 fe and $0xfffffffe,%eax
116d02: 01 d0 add %edx,%eax
/* end of include file */
116d04: 39 c1 cmp %eax,%ecx
116d06: 77 c9 ja 116cd1 <_Heap_Size_of_user_area+0x1d><== NEVER TAKEN
116d08: 39 c6 cmp %eax,%esi
116d0a: 72 c5 jb 116cd1 <_Heap_Size_of_user_area+0x1d><== NEVER TAKEN
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 (
116d0c: f6 40 04 01 testb $0x1,0x4(%eax)
116d10: 74 bf je 116cd1 <_Heap_Size_of_user_area+0x1d><== 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 )
116d12: 29 f8 sub %edi,%eax
116d14: 83 c0 04 add $0x4,%eax
116d17: 8b 5d 10 mov 0x10(%ebp),%ebx
116d1a: 89 03 mov %eax,(%ebx)
116d1c: b0 01 mov $0x1,%al
116d1e: eb b3 jmp 116cd3 <_Heap_Size_of_user_area+0x1f>
00111644 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
111644: 55 push %ebp
111645: 89 e5 mov %esp,%ebp
111647: 57 push %edi
111648: 56 push %esi
111649: 53 push %ebx
11164a: 83 ec 1c sub $0x1c,%esp
11164d: 8b 75 08 mov 0x8(%ebp),%esi
Heap_Block *the_block = the_heap->start;
111650: 8b 7e 20 mov 0x20(%esi),%edi
Heap_Block *const end = the_heap->final;
111653: 8b 46 24 mov 0x24(%esi),%eax
111656: 89 45 e4 mov %eax,-0x1c(%ebp)
/*
if ( !_System_state_Is_up( _System_state_Get() ) )
return TRUE;
*/
if (source < 0)
111659: 8b 45 0c mov 0xc(%ebp),%eax
11165c: 85 c0 test %eax,%eax
11165e: 0f 88 67 02 00 00 js 1118cb <_Heap_Walk+0x287> <== NEVER TAKEN
/*
* Handle the 1st block
*/
if (!_Heap_Is_prev_used(the_block)) {
111664: f6 47 04 01 testb $0x1,0x4(%edi)
111668: 0f 84 3e 02 00 00 je 1118ac <_Heap_Walk+0x268> <== NEVER TAKEN
11166e: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp)
printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source);
error = 1;
}
if (the_block->prev_size != the_heap->page_size) {
111675: 8b 07 mov (%edi),%eax
111677: 3b 46 10 cmp 0x10(%esi),%eax
11167a: 74 1a je 111696 <_Heap_Walk+0x52> <== ALWAYS TAKEN
printk("PASS: %d !prev_size of 1st block isn't page_size\n", source);
11167c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
11167f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
111682: 68 e8 cb 11 00 push $0x11cbe8 <== NOT EXECUTED
111687: e8 38 7d ff ff call 1093c4 <printk> <== NOT EXECUTED
11168c: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED
111693: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
error = 1;
}
while ( the_block != end ) {
111696: 3b 7d e4 cmp -0x1c(%ebp),%edi
111699: 0f 84 37 02 00 00 je 1118d6 <_Heap_Walk+0x292> <== NEVER TAKEN
11169f: 8b 57 04 mov 0x4(%edi),%edx
1116a2: 89 d3 mov %edx,%ebx
1116a4: 83 e3 fe and $0xfffffffe,%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
1116a7: 8d 04 1f lea (%edi,%ebx,1),%eax
1116aa: 89 45 ec mov %eax,-0x14(%ebp)
1116ad: 8b 46 24 mov 0x24(%esi),%eax
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
1116b0: 8b 4d ec mov -0x14(%ebp),%ecx
1116b3: 39 4e 20 cmp %ecx,0x20(%esi)
1116b6: 0f 87 14 01 00 00 ja 1117d0 <_Heap_Walk+0x18c> <== NEVER TAKEN
1116bc: 39 c1 cmp %eax,%ecx
1116be: 0f 87 0c 01 00 00 ja 1117d0 <_Heap_Walk+0x18c> <== NEVER TAKEN
1116c4: 83 e2 01 and $0x1,%edx
1116c7: 88 55 f3 mov %dl,-0xd(%ebp)
1116ca: 66 90 xchg %ax,%ax
printk("PASS: %d !block %p is out of heap\n", source, next_block);
error = 1;
break;
}
if (!_Heap_Is_prev_used(next_block)) {
1116cc: 8b 4d ec mov -0x14(%ebp),%ecx
1116cf: f6 41 04 01 testb $0x1,0x4(%ecx)
1116d3: 0f 85 53 01 00 00 jne 11182c <_Heap_Walk+0x1e8>
if (do_dump)
printk( " prev %p next %p", the_block->prev, the_block->next);
if (_Heap_Block_size(the_block) != next_block->prev_size) {
1116d9: 8b 45 ec mov -0x14(%ebp),%eax
1116dc: 39 18 cmp %ebx,(%eax)
1116de: 74 1a je 1116fa <_Heap_Walk+0xb6> <== ALWAYS TAKEN
if (do_dump) printk("\n");
printk("PASS: %d !front and back sizes don't match", source);
1116e0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
1116e3: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
1116e6: 68 40 cc 11 00 push $0x11cc40 <== NOT EXECUTED
1116eb: e8 d4 7c ff ff call 1093c4 <printk> <== NOT EXECUTED
1116f0: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED
1116f7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
error = 1;
}
if (!prev_used) {
1116fa: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
1116fe: 75 25 jne 111725 <_Heap_Walk+0xe1> <== ALWAYS TAKEN
if (do_dump || error) printk("\n");
111700: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED
111703: 85 c0 test %eax,%eax <== NOT EXECUTED
111705: 0f 85 81 01 00 00 jne 11188c <_Heap_Walk+0x248> <== NOT EXECUTED
printk("PASS: %d !two consecutive blocks are free", source);
11170b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
11170e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
111711: 68 6c cc 11 00 push $0x11cc6c <== NOT EXECUTED
111716: e8 a9 7c ff ff call 1093c4 <printk> <== NOT EXECUTED
11171b: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED
111722: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
)
{
return ( the_thread == _Thread_Heir );
}
/**
111725: 8b 46 08 mov 0x8(%esi),%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)
111728: 39 c7 cmp %eax,%edi
11172a: 75 13 jne 11173f <_Heap_Walk+0xfb>
11172c: e9 fb 00 00 00 jmp 11182c <_Heap_Walk+0x1e8>
111731: 8d 76 00 lea 0x0(%esi),%esi
block = block->next;
111734: 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)
111737: 39 f8 cmp %edi,%eax
111739: 0f 84 ed 00 00 00 je 11182c <_Heap_Walk+0x1e8>
11173f: 39 c6 cmp %eax,%esi
111741: 75 f1 jne 111734 <_Heap_Walk+0xf0> <== ALWAYS TAKEN
block = block->next;
if(block != the_block) {
if (do_dump || error) printk("\n");
111743: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED
111746: 85 c9 test %ecx,%ecx <== NOT EXECUTED
111748: 74 10 je 11175a <_Heap_Walk+0x116> <== NOT EXECUTED
11174a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
11174d: 68 4b a7 11 00 push $0x11a74b <== NOT EXECUTED
111752: e8 6d 7c ff ff call 1093c4 <printk> <== NOT EXECUTED
111757: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
printk("PASS: %d !the_block not in the free list", source);
11175a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
11175d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
111760: 68 98 cc 11 00 push $0x11cc98 <== NOT EXECUTED
111765: e8 5a 7c ff ff call 1093c4 <printk> <== NOT EXECUTED
11176a: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED
111771: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
error = 1;
}
}
}
if (do_dump || error) printk("\n");
111774: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
111777: 68 4b a7 11 00 push $0x11a74b <== NOT EXECUTED
11177c: e8 43 7c ff ff call 1093c4 <printk> <== NOT EXECUTED
111781: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if (the_size < the_heap->min_block_size) {
111784: 3b 5e 14 cmp 0x14(%esi),%ebx <== NOT EXECUTED
111787: 0f 82 b3 00 00 00 jb 111840 <_Heap_Walk+0x1fc> <== NOT EXECUTED
printk("PASS: %d !block size is too small\n", source);
error = 1;
break;
}
if (!_Heap_Is_aligned( the_size, the_heap->page_size)) {
11178d: 89 d8 mov %ebx,%eax
11178f: 31 d2 xor %edx,%edx
111791: f7 76 10 divl 0x10(%esi)
111794: 85 d2 test %edx,%edx
111796: 0f 85 d8 00 00 00 jne 111874 <_Heap_Walk+0x230> <== NEVER TAKEN
printk("PASS: %d !block size is misaligned\n", source);
error = 1;
}
if (++passes > (do_dump ? 10 : 0) && error)
11179c: 8b 45 e8 mov -0x18(%ebp),%eax
11179f: 85 c0 test %eax,%eax
1117a1: 75 41 jne 1117e4 <_Heap_Walk+0x1a0> <== NEVER TAKEN
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 ) {
1117a3: 8b 4d ec mov -0x14(%ebp),%ecx
1117a6: 39 4d e4 cmp %ecx,-0x1c(%ebp)
1117a9: 0f 84 27 01 00 00 je 1118d6 <_Heap_Walk+0x292>
1117af: 8b 45 ec mov -0x14(%ebp),%eax
1117b2: 8b 48 04 mov 0x4(%eax),%ecx
1117b5: 89 cb mov %ecx,%ebx
1117b7: 83 e3 fe and $0xfffffffe,%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 );
1117ba: 01 d8 add %ebx,%eax
1117bc: 8b 56 24 mov 0x24(%esi),%edx
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
1117bf: 3b 46 20 cmp 0x20(%esi),%eax
1117c2: 0f 83 90 00 00 00 jae 111858 <_Heap_Walk+0x214> <== ALWAYS TAKEN
printk("PASS: %d !block %p is out of heap\n", source, next_block);
error = 1;
break;
}
if (!_Heap_Is_prev_used(next_block)) {
1117c8: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED
1117cb: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED
1117ce: 66 90 xchg %ax,%ax <== NOT EXECUTED
printk(" (prev_size) %d", the_block->prev_size);
}
if (!_Heap_Is_block_in(the_heap, next_block)) {
if (do_dump) printk("\n");
printk("PASS: %d !block %p is out of heap\n", source, next_block);
1117d0: 50 push %eax <== NOT EXECUTED
1117d1: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED
1117d4: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
1117d7: 68 1c cc 11 00 push $0x11cc1c <== NOT EXECUTED
1117dc: e8 e3 7b ff ff call 1093c4 <printk> <== NOT EXECUTED
1117e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
the_block = next_block;
}
if (the_block != end) {
printk("PASS: %d !last block address isn't equal to 'final' %p %p\n",
1117e4: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED
1117e7: 57 push %edi <== NOT EXECUTED
1117e8: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
1117eb: 68 0c cd 11 00 push $0x11cd0c <== NOT EXECUTED
1117f0: e8 cf 7b ff ff call 1093c4 <printk> <== NOT EXECUTED
1117f5: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED
1117fc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1117ff: 8b 47 04 mov 0x4(%edi),%eax
111802: 83 e0 fe and $0xfffffffe,%eax
source, the_block, end);
error = 1;
}
if (_Heap_Block_size(the_block) != the_heap->page_size) {
111805: 8b 56 10 mov 0x10(%esi),%edx
111808: 39 c2 cmp %eax,%edx
11180a: 0f 84 91 00 00 00 je 1118a1 <_Heap_Walk+0x25d> <== ALWAYS TAKEN
printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source,
111810: 52 push %edx <== NOT EXECUTED
111811: 50 push %eax <== NOT EXECUTED
111812: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
111815: 68 48 cd 11 00 push $0x11cd48 <== NOT EXECUTED
11181a: e8 a5 7b ff ff call 1093c4 <printk> <== NOT EXECUTED
11181f: b0 01 mov $0x1,%al <== NOT EXECUTED
111821: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if(do_dump && error)
_Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 );
return error;
}
111824: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
111827: 5b pop %ebx <== NOT EXECUTED
111828: 5e pop %esi <== NOT EXECUTED
111829: 5f pop %edi <== NOT EXECUTED
11182a: c9 leave <== NOT EXECUTED
11182b: c3 ret <== NOT EXECUTED
error = 1;
}
}
}
if (do_dump || error) printk("\n");
11182c: 8b 55 e8 mov -0x18(%ebp),%edx
11182f: 85 d2 test %edx,%edx
111831: 0f 85 3d ff ff ff jne 111774 <_Heap_Walk+0x130> <== NEVER TAKEN
if (the_size < the_heap->min_block_size) {
111837: 3b 5e 14 cmp 0x14(%esi),%ebx
11183a: 0f 83 4d ff ff ff jae 11178d <_Heap_Walk+0x149> <== ALWAYS TAKEN
printk("PASS: %d !block size is too small\n", source);
111840: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
111843: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
111846: 68 c4 cc 11 00 push $0x11ccc4 <== NOT EXECUTED
11184b: e8 74 7b ff ff call 1093c4 <printk> <== NOT EXECUTED
111850: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
111853: eb 8f jmp 1117e4 <_Heap_Walk+0x1a0> <== NOT EXECUTED
111855: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
111858: 39 d0 cmp %edx,%eax
11185a: 0f 87 68 ff ff ff ja 1117c8 <_Heap_Walk+0x184> <== NEVER TAKEN
111860: 83 e1 01 and $0x1,%ecx
111863: 88 4d f3 mov %cl,-0xd(%ebp)
111866: 8b 7d ec mov -0x14(%ebp),%edi
111869: 89 45 ec mov %eax,-0x14(%ebp)
11186c: e9 5b fe ff ff jmp 1116cc <_Heap_Walk+0x88>
111871: 8d 76 00 lea 0x0(%esi),%esi
error = 1;
break;
}
if (!_Heap_Is_aligned( the_size, the_heap->page_size)) {
printk("PASS: %d !block size is misaligned\n", source);
111874: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
111877: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
11187a: 68 e8 cc 11 00 push $0x11cce8 <== NOT EXECUTED
11187f: e8 40 7b ff ff call 1093c4 <printk> <== NOT EXECUTED
111884: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
111887: e9 58 ff ff ff jmp 1117e4 <_Heap_Walk+0x1a0> <== NOT EXECUTED
if (do_dump) printk("\n");
printk("PASS: %d !front and back sizes don't match", source);
error = 1;
}
if (!prev_used) {
if (do_dump || error) printk("\n");
11188c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
11188f: 68 4b a7 11 00 push $0x11a74b <== NOT EXECUTED
111894: e8 2b 7b ff ff call 1093c4 <printk> <== NOT EXECUTED
111899: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
11189c: e9 6a fe ff ff jmp 11170b <_Heap_Walk+0xc7> <== NOT EXECUTED
printk("PASS: %d !last block address isn't equal to 'final' %p %p\n",
source, the_block, end);
error = 1;
}
if (_Heap_Block_size(the_block) != the_heap->page_size) {
1118a1: 8a 45 e8 mov -0x18(%ebp),%al
if(do_dump && error)
_Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 );
return error;
}
1118a4: 8d 65 f4 lea -0xc(%ebp),%esp
1118a7: 5b pop %ebx
1118a8: 5e pop %esi
1118a9: 5f pop %edi
1118aa: c9 leave
1118ab: c3 ret
/*
* Handle the 1st block
*/
if (!_Heap_Is_prev_used(the_block)) {
printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source);
1118ac: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
1118af: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
1118b2: 68 b0 cb 11 00 push $0x11cbb0 <== NOT EXECUTED
1118b7: e8 08 7b ff ff call 1093c4 <printk> <== NOT EXECUTED
1118bc: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED
1118c3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1118c6: e9 aa fd ff ff jmp 111675 <_Heap_Walk+0x31> <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) )
return TRUE;
*/
if (source < 0)
source = the_heap->stats.instance;
1118cb: 8b 4e 28 mov 0x28(%esi),%ecx <== NOT EXECUTED
1118ce: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED
1118d1: e9 8e fd ff ff jmp 111664 <_Heap_Walk+0x20> <== NOT EXECUTED
source, the_block, end);
error = 1;
}
if (_Heap_Block_size(the_block) != the_heap->page_size) {
printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source,
1118d6: 8b 7d e4 mov -0x1c(%ebp),%edi
1118d9: e9 21 ff ff ff jmp 1117ff <_Heap_Walk+0x1bb>
0010aa98 <_IO_Initialize_all_drivers>:
*
* Output Parameters: NONE
*/
void _IO_Initialize_all_drivers( void )
{
10aa98: 55 push %ebp
10aa99: 89 e5 mov %esp,%ebp
10aa9b: 53 push %ebx
10aa9c: 83 ec 04 sub $0x4,%esp
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
10aa9f: 8b 15 00 ea 11 00 mov 0x11ea00,%edx
10aaa5: 85 d2 test %edx,%edx
10aaa7: 74 1a je 10aac3 <_IO_Initialize_all_drivers+0x2b><== NEVER TAKEN
10aaa9: 31 db xor %ebx,%ebx
10aaab: 90 nop
(void) rtems_io_initialize( major, 0, NULL );
10aaac: 50 push %eax
10aaad: 6a 00 push $0x0
10aaaf: 6a 00 push $0x0
10aab1: 53 push %ebx
10aab2: e8 4d 45 00 00 call 10f004 <rtems_io_initialize>
void _IO_Initialize_all_drivers( void )
{
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
10aab7: 43 inc %ebx
10aab8: 83 c4 10 add $0x10,%esp
10aabb: 39 1d 00 ea 11 00 cmp %ebx,0x11ea00
10aac1: 77 e9 ja 10aaac <_IO_Initialize_all_drivers+0x14>
(void) rtems_io_initialize( major, 0, NULL );
}
10aac3: 8b 5d fc mov -0x4(%ebp),%ebx
10aac6: c9 leave
10aac7: c3 ret
0010aac8 <_IO_Manager_initialization>:
void _IO_Manager_initialization(
rtems_driver_address_table *driver_table,
uint32_t drivers_in_table,
uint32_t number_of_drivers
)
{
10aac8: 55 push %ebp
10aac9: 89 e5 mov %esp,%ebp
10aacb: 57 push %edi
10aacc: 56 push %esi
10aacd: 53 push %ebx
10aace: 83 ec 0c sub $0xc,%esp
10aad1: 8b 75 10 mov 0x10(%ebp),%esi
/*
* If the user claims there are less drivers than are actually in
* the table, then let's just go with the table's count.
*/
if ( number_of_drivers <= drivers_in_table )
10aad4: 3b 75 0c cmp 0xc(%ebp),%esi
10aad7: 76 5b jbe 10ab34 <_IO_Manager_initialization+0x6c>
/*
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
10aad9: 8d 04 76 lea (%esi,%esi,2),%eax
10aadc: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx
10aae3: 83 ec 0c sub $0xc,%esp
10aae6: 53 push %ebx
10aae7: e8 4c 29 00 00 call 10d438 <_Workspace_Allocate_or_fatal_error>
10aaec: 89 c7 mov %eax,%edi
10aaee: a3 04 ea 11 00 mov %eax,0x11ea04
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
10aaf3: 89 35 00 ea 11 00 mov %esi,0x11ea00
memset(
10aaf9: 31 c0 xor %eax,%eax
10aafb: 89 d9 mov %ebx,%ecx
10aafd: f3 aa rep stos %al,%es:(%edi)
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
10aaff: 83 c4 10 add $0x10,%esp
10ab02: 8b 4d 0c mov 0xc(%ebp),%ecx
10ab05: 85 c9 test %ecx,%ecx
10ab07: 74 23 je 10ab2c <_IO_Manager_initialization+0x64><== NEVER TAKEN
_IO_Driver_address_table[index] = driver_table[index];
10ab09: 8b 1d 04 ea 11 00 mov 0x11ea04,%ebx
10ab0f: 31 d2 xor %edx,%edx
10ab11: 31 c0 xor %eax,%eax
10ab13: 90 nop
10ab14: 8d 3c 03 lea (%ebx,%eax,1),%edi
10ab17: 8b 75 08 mov 0x8(%ebp),%esi
10ab1a: 01 c6 add %eax,%esi
10ab1c: b9 06 00 00 00 mov $0x6,%ecx
10ab21: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
memset(
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
10ab23: 42 inc %edx
10ab24: 83 c0 18 add $0x18,%eax
10ab27: 39 55 0c cmp %edx,0xc(%ebp)
10ab2a: 77 e8 ja 10ab14 <_IO_Manager_initialization+0x4c>
_IO_Driver_address_table[index] = driver_table[index];
number_of_drivers = drivers_in_table;
}
10ab2c: 8d 65 f4 lea -0xc(%ebp),%esp
10ab2f: 5b pop %ebx
10ab30: 5e pop %esi
10ab31: 5f pop %edi
10ab32: c9 leave
10ab33: c3 ret
* If the maximum number of driver is the same as the number in the
* table, then we do not have to copy the driver table. They can't
* register any dynamically.
*/
if ( number_of_drivers == drivers_in_table ) {
_IO_Driver_address_table = driver_table;
10ab34: 8b 45 08 mov 0x8(%ebp),%eax
10ab37: a3 04 ea 11 00 mov %eax,0x11ea04
_IO_Number_of_drivers = number_of_drivers;
10ab3c: 8b 4d 0c mov 0xc(%ebp),%ecx
10ab3f: 89 0d 00 ea 11 00 mov %ecx,0x11ea00
);
for ( index = 0 ; index < drivers_in_table ; index++ )
_IO_Driver_address_table[index] = driver_table[index];
number_of_drivers = drivers_in_table;
}
10ab45: 8d 65 f4 lea -0xc(%ebp),%esp
10ab48: 5b pop %ebx
10ab49: 5e pop %esi
10ab4a: 5f pop %edi
10ab4b: c9 leave
10ab4c: c3 ret
0010b520 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
uint32_t the_error
)
{
10b520: 55 push %ebp
10b521: 89 e5 mov %esp,%ebp
10b523: 53 push %ebx
10b524: 83 ec 08 sub $0x8,%esp
10b527: 8b 55 08 mov 0x8(%ebp),%edx
10b52a: 8b 45 0c mov 0xc(%ebp),%eax
10b52d: 8b 5d 10 mov 0x10(%ebp),%ebx
_Internal_errors_What_happened.the_source = the_source;
10b530: 89 15 04 e7 11 00 mov %edx,0x11e704
_Internal_errors_What_happened.is_internal = is_internal;
10b536: a2 08 e7 11 00 mov %al,0x11e708
_Internal_errors_What_happened.the_error = the_error;
10b53b: 89 1d 0c e7 11 00 mov %ebx,0x11e70c
_User_extensions_Fatal( the_source, is_internal, the_error );
10b541: 53 push %ebx
10b542: 0f b6 c0 movzbl %al,%eax
10b545: 50 push %eax
10b546: 52 push %edx
10b547: e8 60 1b 00 00 call 10d0ac <_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(
10b54c: c7 05 24 e8 11 00 05 movl $0x5,0x11e824 <== NOT EXECUTED
10b553: 00 00 00
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
10b556: fa cli <== NOT EXECUTED
10b557: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10b559: f4 hlt <== NOT EXECUTED
10b55a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10b55d: eb fe jmp 10b55d <_Internal_error_Occurred+0x3d><== NOT EXECUTED
0010f4bc <_Objects_API_maximum_class>:
#include <rtems/score/object.h>
int _Objects_API_maximum_class(
uint32_t api
)
{
10f4bc: 55 push %ebp
10f4bd: 89 e5 mov %esp,%ebp
switch (api) {
10f4bf: 83 7d 08 02 cmpl $0x2,0x8(%ebp)
10f4c3: 74 2f je 10f4f4 <_Objects_API_maximum_class+0x38>
10f4c5: 76 15 jbe 10f4dc <_Objects_API_maximum_class+0x20>
10f4c7: 83 7d 08 03 cmpl $0x3,0x8(%ebp)
10f4cb: 74 1f je 10f4ec <_Objects_API_maximum_class+0x30><== NEVER TAKEN
10f4cd: 83 7d 08 04 cmpl $0x4,0x8(%ebp)
10f4d1: 75 0f jne 10f4e2 <_Objects_API_maximum_class+0x26>
case OBJECTS_INTERNAL_API:
return OBJECTS_INTERNAL_CLASSES_LAST;
case OBJECTS_CLASSIC_API:
return OBJECTS_RTEMS_CLASSES_LAST;
case OBJECTS_POSIX_API:
return OBJECTS_POSIX_CLASSES_LAST;
10f4d3: b8 08 00 00 00 mov $0x8,%eax
case OBJECTS_NO_API:
default:
break;
}
return -1;
}
10f4d8: c9 leave
10f4d9: c3 ret
10f4da: 66 90 xchg %ax,%ax
int _Objects_API_maximum_class(
uint32_t api
)
{
switch (api) {
10f4dc: 83 7d 08 01 cmpl $0x1,0x8(%ebp)
10f4e0: 74 1a je 10f4fc <_Objects_API_maximum_class+0x40>
case OBJECTS_CLASSIC_API:
return OBJECTS_RTEMS_CLASSES_LAST;
case OBJECTS_POSIX_API:
return OBJECTS_POSIX_CLASSES_LAST;
case OBJECTS_ITRON_API:
return OBJECTS_ITRON_CLASSES_LAST;
10f4e2: b8 ff ff ff ff mov $0xffffffff,%eax
case OBJECTS_NO_API:
default:
break;
}
return -1;
}
10f4e7: c9 leave
10f4e8: c3 ret
10f4e9: 8d 76 00 lea 0x0(%esi),%esi
int _Objects_API_maximum_class(
uint32_t api
)
{
switch (api) {
10f4ec: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED
case OBJECTS_NO_API:
default:
break;
}
return -1;
}
10f4f1: c9 leave <== NOT EXECUTED
10f4f2: c3 ret <== NOT EXECUTED
10f4f3: 90 nop <== NOT EXECUTED
int _Objects_API_maximum_class(
uint32_t api
)
{
switch (api) {
10f4f4: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_NO_API:
default:
break;
}
return -1;
}
10f4f9: c9 leave
10f4fa: c3 ret
10f4fb: 90 nop
int _Objects_API_maximum_class(
uint32_t api
)
{
switch (api) {
10f4fc: b8 02 00 00 00 mov $0x2,%eax
case OBJECTS_NO_API:
default:
break;
}
return -1;
}
10f501: c9 leave
10f502: c3 ret
0010b5b4 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
10b5b4: 55 push %ebp
10b5b5: 89 e5 mov %esp,%ebp
10b5b7: 56 push %esi
10b5b8: 53 push %ebx
10b5b9: 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 )
10b5bc: 8b 43 18 mov 0x18(%ebx),%eax
10b5bf: 85 c0 test %eax,%eax
10b5c1: 75 0d jne 10b5d0 <_Objects_Allocate+0x1c><== ALWAYS TAKEN
10b5c3: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
information->inactive--;
}
}
return the_object;
}
10b5c5: 89 c8 mov %ecx,%eax
10b5c7: 8d 65 f8 lea -0x8(%ebp),%esp
10b5ca: 5b pop %ebx
10b5cb: 5e pop %esi
10b5cc: c9 leave
10b5cd: c3 ret
10b5ce: 66 90 xchg %ax,%ax
/*
* OK. The manager should be initialized and configured to have objects.
* With any luck, it is safe to attempt to allocate an object.
*/
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10b5d0: 8d 73 20 lea 0x20(%ebx),%esi
10b5d3: 83 ec 0c sub $0xc,%esp
10b5d6: 56 push %esi
10b5d7: e8 c4 f7 ff ff call 10ada0 <_Chain_Get>
10b5dc: 89 c1 mov %eax,%ecx
if ( information->auto_extend ) {
10b5de: 83 c4 10 add $0x10,%esp
10b5e1: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10b5e5: 74 de je 10b5c5 <_Objects_Allocate+0x11>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
10b5e7: 85 c0 test %eax,%eax
10b5e9: 74 2d je 10b618 <_Objects_Allocate+0x64>
}
if ( the_object ) {
uint32_t block;
block = _Objects_Get_index( the_object->id ) -
10b5eb: 8b 41 08 mov 0x8(%ecx),%eax
10b5ee: 25 ff ff 00 00 and $0xffff,%eax
10b5f3: 8b 53 08 mov 0x8(%ebx),%edx
10b5f6: 81 e2 ff ff 00 00 and $0xffff,%edx
10b5fc: 29 d0 sub %edx,%eax
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
10b5fe: 31 d2 xor %edx,%edx
10b600: f7 73 14 divl 0x14(%ebx)
10b603: c1 e0 02 shl $0x2,%eax
10b606: 03 43 30 add 0x30(%ebx),%eax
10b609: ff 08 decl (%eax)
information->inactive--;
10b60b: 66 ff 4b 2c decw 0x2c(%ebx)
}
}
return the_object;
}
10b60f: 89 c8 mov %ecx,%eax
10b611: 8d 65 f8 lea -0x8(%ebp),%esp
10b614: 5b pop %ebx
10b615: 5e pop %esi
10b616: c9 leave
10b617: c3 ret
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
_Objects_Extend_information( information );
10b618: 83 ec 0c sub $0xc,%esp
10b61b: 53 push %ebx
10b61c: e8 37 00 00 00 call 10b658 <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10b621: 89 34 24 mov %esi,(%esp)
10b624: e8 77 f7 ff ff call 10ada0 <_Chain_Get>
10b629: 89 c1 mov %eax,%ecx
}
if ( the_object ) {
10b62b: 83 c4 10 add $0x10,%esp
10b62e: 85 c0 test %eax,%eax
10b630: 74 93 je 10b5c5 <_Objects_Allocate+0x11><== NEVER TAKEN
10b632: eb b7 jmp 10b5eb <_Objects_Allocate+0x37>
0010b658 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
10b658: 55 push %ebp
10b659: 89 e5 mov %esp,%ebp
10b65b: 57 push %edi
10b65c: 56 push %esi
10b65d: 53 push %ebx
10b65e: 83 ec 5c sub $0x5c,%esp
* 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
10b661: 8b 55 08 mov 0x8(%ebp),%edx
10b664: 8b 42 08 mov 0x8(%edx),%eax
10b667: 25 ff ff 00 00 and $0xffff,%eax
10b66c: 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 )
10b66f: 0f b7 72 10 movzwl 0x10(%edx),%esi
10b673: 39 c6 cmp %eax,%esi
10b675: 0f 83 e9 01 00 00 jae 10b864 <_Objects_Extend_information+0x20c>
10b67b: 8b 4a 14 mov 0x14(%edx),%ecx
10b67e: 89 4d a8 mov %ecx,-0x58(%ebp)
10b681: 89 45 c4 mov %eax,-0x3c(%ebp)
10b684: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp)
10b68b: 31 db xor %ebx,%ebx
10b68d: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp)
10b694: ba 03 00 00 00 mov $0x3,%edx
* Up the block count and maximum
*/
block_count++;
maximum = information->maximum + information->allocation_size;
10b699: 03 75 a8 add -0x58(%ebp),%esi
10b69c: 89 75 d4 mov %esi,-0x2c(%ebp)
/*
* Allocate the tables and break it up.
*/
if ( information->auto_extend ) {
10b69f: 8b 45 08 mov 0x8(%ebp),%eax
10b6a2: 80 78 12 00 cmpb $0x0,0x12(%eax)
10b6a6: 0f 85 1c 02 00 00 jne 10b8c8 <_Objects_Extend_information+0x270>
if ( !object_blocks )
return;
}
else {
object_blocks = (void**)
10b6ac: 83 ec 0c sub $0xc,%esp
10b6af: 8b 75 c8 mov -0x38(%ebp),%esi
10b6b2: 8d 04 32 lea (%edx,%esi,1),%eax
10b6b5: 03 45 d4 add -0x2c(%ebp),%eax
10b6b8: c1 e0 02 shl $0x2,%eax
10b6bb: 50 push %eax
10b6bc: e8 77 1d 00 00 call 10d438 <_Workspace_Allocate_or_fatal_error>
10b6c1: 89 45 cc mov %eax,-0x34(%ebp)
10b6c4: 83 c4 10 add $0x10,%esp
/*
* Break the block into the various sections.
*
*/
inactive_per_block = (uint32_t *) _Addresses_Add_offset(
10b6c7: 8b 7d e0 mov -0x20(%ebp),%edi
10b6ca: 8b 45 cc mov -0x34(%ebp),%eax
10b6cd: 8d 3c b8 lea (%eax,%edi,4),%edi
10b6d0: 89 7d d0 mov %edi,-0x30(%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
10b6d3: 8b 55 e0 mov -0x20(%ebp),%edx
10b6d6: 8d 14 d0 lea (%eax,%edx,8),%edx
10b6d9: 89 55 d8 mov %edx,-0x28(%ebp)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
10b6dc: 8b 4d 08 mov 0x8(%ebp),%ecx
10b6df: 0f b7 41 10 movzwl 0x10(%ecx),%eax
10b6e3: 3b 45 c8 cmp -0x38(%ebp),%eax
10b6e6: 0f 87 38 02 00 00 ja 10b924 <_Objects_Extend_information+0x2cc>
else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
10b6ec: 8b 45 c8 mov -0x38(%ebp),%eax
10b6ef: 85 c0 test %eax,%eax
10b6f1: 74 15 je 10b708 <_Objects_Extend_information+0xb0><== NEVER TAKEN
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
10b6f3: 31 c0 xor %eax,%eax
10b6f5: 8d 76 00 lea 0x0(%esi),%esi
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
local_table[ index ] = NULL;
10b6f8: 8b 55 d8 mov -0x28(%ebp),%edx
10b6fb: c7 04 82 00 00 00 00 movl $0x0,(%edx,%eax,4)
else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
10b702: 40 inc %eax
10b703: 3b 45 c8 cmp -0x38(%ebp),%eax
10b706: 72 f0 jb 10b6f8 <_Objects_Extend_information+0xa0><== NEVER TAKEN
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
10b708: 8b 45 c0 mov -0x40(%ebp),%eax
10b70b: c1 e0 02 shl $0x2,%eax
10b70e: 8b 4d cc mov -0x34(%ebp),%ecx
10b711: c7 04 01 00 00 00 00 movl $0x0,(%ecx,%eax,1)
inactive_per_block[block_count] = 0;
10b718: 8b 75 d0 mov -0x30(%ebp),%esi
10b71b: c7 04 06 00 00 00 00 movl $0x0,(%esi,%eax,1)
for ( index=index_base ;
index < ( information->allocation_size + index_base );
10b722: 8b 4d c4 mov -0x3c(%ebp),%ecx
10b725: 8b 7d 08 mov 0x8(%ebp),%edi
10b728: 03 4f 14 add 0x14(%edi),%ecx
10b72b: 3b 4d c4 cmp -0x3c(%ebp),%ecx
10b72e: 76 1a jbe 10b74a <_Objects_Extend_information+0xf2><== NEVER TAKEN
10b730: 8b 45 c4 mov -0x3c(%ebp),%eax
10b733: 8b 75 d8 mov -0x28(%ebp),%esi
10b736: 8d 14 86 lea (%esi,%eax,4),%edx
10b739: 8d 76 00 lea 0x0(%esi),%esi
index++ ) {
local_table[ index ] = NULL;
10b73c: 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++ ) {
10b742: 40 inc %eax
10b743: 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 );
10b746: 39 c1 cmp %eax,%ecx
10b748: 77 f2 ja 10b73c <_Objects_Extend_information+0xe4>
index++ ) {
local_table[ index ] = NULL;
}
_ISR_Disable( level );
10b74a: 9c pushf
10b74b: fa cli
10b74c: 59 pop %ecx
old_tables = information->object_blocks;
10b74d: 8b 7d 08 mov 0x8(%ebp),%edi
10b750: 8b 77 34 mov 0x34(%edi),%esi
information->object_blocks = object_blocks;
10b753: 8b 45 cc mov -0x34(%ebp),%eax
10b756: 89 47 34 mov %eax,0x34(%edi)
information->inactive_per_block = inactive_per_block;
10b759: 8b 55 d0 mov -0x30(%ebp),%edx
10b75c: 89 57 30 mov %edx,0x30(%edi)
information->local_table = local_table;
10b75f: 8b 45 d8 mov -0x28(%ebp),%eax
10b762: 89 47 1c mov %eax,0x1c(%edi)
information->maximum = maximum;
10b765: 8b 55 d4 mov -0x2c(%ebp),%edx
10b768: 66 89 57 10 mov %dx,0x10(%edi)
information->maximum_id = _Objects_Build_id(
10b76c: 8b 17 mov (%edi),%edx
10b76e: c1 e2 18 shl $0x18,%edx
10b771: 81 ca 00 00 01 00 or $0x10000,%edx
10b777: 0f b7 47 04 movzwl 0x4(%edi),%eax
10b77b: c1 e0 1b shl $0x1b,%eax
10b77e: 09 c2 or %eax,%edx
10b780: 0f b7 45 d4 movzwl -0x2c(%ebp),%eax
10b784: 09 c2 or %eax,%edx
10b786: 89 57 0c mov %edx,0xc(%edi)
information->the_class,
_Objects_Local_node,
information->maximum
);
_ISR_Enable( level );
10b789: 51 push %ecx
10b78a: 9d popf
if ( old_tables )
10b78b: 85 f6 test %esi,%esi
10b78d: 0f 84 c9 01 00 00 je 10b95c <_Objects_Extend_information+0x304>
_Workspace_Free( old_tables );
10b793: 83 ec 0c sub $0xc,%esp
10b796: 56 push %esi
10b797: e8 6c 1c 00 00 call 10d408 <_Workspace_Free>
10b79c: 8b 75 08 mov 0x8(%ebp),%esi
10b79f: 8b 76 14 mov 0x14(%esi),%esi
10b7a2: 89 75 a8 mov %esi,-0x58(%ebp)
10b7a5: 83 c4 10 add $0x10,%esp
/*
* Allocate the name table, and the objects
*/
if ( information->auto_extend ) {
10b7a8: 8b 7d 08 mov 0x8(%ebp),%edi
10b7ab: 80 7f 12 00 cmpb $0x0,0x12(%edi)
10b7af: 0f 84 3b 01 00 00 je 10b8f0 <_Objects_Extend_information+0x298>
information->object_blocks[ block ] =
10b7b5: c1 e3 02 shl $0x2,%ebx
10b7b8: 89 5d dc mov %ebx,-0x24(%ebp)
10b7bb: 03 5f 34 add 0x34(%edi),%ebx
10b7be: 83 ec 0c sub $0xc,%esp
10b7c1: 8b 45 a8 mov -0x58(%ebp),%eax
10b7c4: 0f af 47 18 imul 0x18(%edi),%eax
10b7c8: 50 push %eax
10b7c9: e8 52 1c 00 00 call 10d420 <_Workspace_Allocate>
10b7ce: 89 03 mov %eax,(%ebx)
_Workspace_Allocate(
(information->allocation_size * information->size)
);
if ( !information->object_blocks[ block ] )
10b7d0: 8b 47 34 mov 0x34(%edi),%eax
10b7d3: 8b 55 dc mov -0x24(%ebp),%edx
10b7d6: 8b 04 10 mov (%eax,%edx,1),%eax
10b7d9: 83 c4 10 add $0x10,%esp
10b7dc: 85 c0 test %eax,%eax
10b7de: 74 7a je 10b85a <_Objects_Extend_information+0x202><== NEVER TAKEN
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
10b7e0: 8b 4d 08 mov 0x8(%ebp),%ecx
10b7e3: ff 71 18 pushl 0x18(%ecx)
10b7e6: ff 71 14 pushl 0x14(%ecx)
10b7e9: 50 push %eax
10b7ea: 8d 75 e8 lea -0x18(%ebp),%esi
10b7ed: 56 push %esi
10b7ee: e8 69 38 00 00 call 10f05c <_Chain_Initialize>
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10b7f3: 8b 75 08 mov 0x8(%ebp),%esi
10b7f6: 83 c6 20 add $0x20,%esi
10b7f9: 8b 5d c4 mov -0x3c(%ebp),%ebx
10b7fc: 83 c4 10 add $0x10,%esp
10b7ff: eb 2c jmp 10b82d <_Objects_Extend_information+0x1d5>
10b801: 8d 76 00 lea 0x0(%esi),%esi
index = index_base;
while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) {
the_object->id = _Objects_Build_id(
10b804: 8b 7d 08 mov 0x8(%ebp),%edi
10b807: 8b 07 mov (%edi),%eax
10b809: c1 e0 18 shl $0x18,%eax
10b80c: 0d 00 00 01 00 or $0x10000,%eax
10b811: 0f b7 57 04 movzwl 0x4(%edi),%edx
10b815: c1 e2 1b shl $0x1b,%edx
10b818: 09 d0 or %edx,%eax
10b81a: 09 d8 or %ebx,%eax
10b81c: 89 41 08 mov %eax,0x8(%ecx)
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10b81f: 83 ec 08 sub $0x8,%esp
10b822: 51 push %ecx
10b823: 56 push %esi
10b824: e8 53 f5 ff ff call 10ad7c <_Chain_Append>
index++;
10b829: 43 inc %ebx
10b82a: 83 c4 10 add $0x10,%esp
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) {
10b82d: 83 ec 0c sub $0xc,%esp
10b830: 8d 45 e8 lea -0x18(%ebp),%eax
10b833: 50 push %eax
10b834: e8 67 f5 ff ff call 10ada0 <_Chain_Get>
10b839: 89 c1 mov %eax,%ecx
10b83b: 83 c4 10 add $0x10,%esp
10b83e: 85 c0 test %eax,%eax
10b840: 75 c2 jne 10b804 <_Objects_Extend_information+0x1ac>
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
10b842: 8b 55 08 mov 0x8(%ebp),%edx
10b845: 8b 42 30 mov 0x30(%edx),%eax
10b848: 89 d1 mov %edx,%ecx
10b84a: 8b 52 14 mov 0x14(%edx),%edx
10b84d: 8b 75 dc mov -0x24(%ebp),%esi
10b850: 89 14 30 mov %edx,(%eax,%esi,1)
information->inactive += information->allocation_size;
10b853: 8b 41 14 mov 0x14(%ecx),%eax
10b856: 66 01 41 2c add %ax,0x2c(%ecx)
}
10b85a: 8d 65 f4 lea -0xc(%ebp),%esp
10b85d: 5b pop %ebx
10b85e: 5e pop %esi
10b85f: 5f pop %edi
10b860: c9 leave
10b861: c3 ret
10b862: 66 90 xchg %ax,%ax
block = 0;
if ( information->maximum < minimum_index )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
10b864: 8b 7d 08 mov 0x8(%ebp),%edi
10b867: 8b 7f 14 mov 0x14(%edi),%edi
10b86a: 89 7d a8 mov %edi,-0x58(%ebp)
10b86d: 89 f0 mov %esi,%eax
10b86f: 31 d2 xor %edx,%edx
10b871: f7 f7 div %edi
10b873: 89 45 a4 mov %eax,-0x5c(%ebp)
10b876: 89 45 c0 mov %eax,-0x40(%ebp)
for ( ; block < block_count; block++ ) {
10b879: 85 c0 test %eax,%eax
10b87b: 0f 84 e6 00 00 00 je 10b967 <_Objects_Extend_information+0x30f><== NEVER TAKEN
if ( information->object_blocks[ block ] == NULL )
10b881: 8b 7d 08 mov 0x8(%ebp),%edi
10b884: 8b 4f 34 mov 0x34(%edi),%ecx
10b887: 8b 19 mov (%ecx),%ebx
10b889: 85 db test %ebx,%ebx
10b88b: 0f 84 d6 00 00 00 je 10b967 <_Objects_Extend_information+0x30f><== NEVER TAKEN
10b891: 8b 45 c8 mov -0x38(%ebp),%eax
10b894: 89 45 c4 mov %eax,-0x3c(%ebp)
10b897: 31 db xor %ebx,%ebx
10b899: eb 08 jmp 10b8a3 <_Objects_Extend_information+0x24b>
10b89b: 90 nop
10b89c: 8b 14 99 mov (%ecx,%ebx,4),%edx
10b89f: 85 d2 test %edx,%edx
10b8a1: 74 0c je 10b8af <_Objects_Extend_information+0x257>
break;
else
index_base += information->allocation_size;
10b8a3: 8b 55 a8 mov -0x58(%ebp),%edx
10b8a6: 01 55 c4 add %edx,-0x3c(%ebp)
if ( information->maximum < minimum_index )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
10b8a9: 43 inc %ebx
10b8aa: 39 5d a4 cmp %ebx,-0x5c(%ebp)
10b8ad: 77 ed ja 10b89c <_Objects_Extend_information+0x244>
/*
* If the index_base is the maximum we need to grow the tables.
*/
if (index_base >= information->maximum ) {
10b8af: 39 75 c4 cmp %esi,-0x3c(%ebp)
10b8b2: 0f 82 f0 fe ff ff jb 10b7a8 <_Objects_Extend_information+0x150>
10b8b8: 8b 7d a4 mov -0x5c(%ebp),%edi
10b8bb: 47 inc %edi
10b8bc: 89 7d e0 mov %edi,-0x20(%ebp)
10b8bf: 8d 14 7f lea (%edi,%edi,2),%edx
10b8c2: e9 d2 fd ff ff jmp 10b699 <_Objects_Extend_information+0x41>
10b8c7: 90 nop
/*
* Allocate the tables and break it up.
*/
if ( information->auto_extend ) {
object_blocks = (void**)
10b8c8: 83 ec 0c sub $0xc,%esp
10b8cb: 8b 4d c8 mov -0x38(%ebp),%ecx
10b8ce: 8d 04 0a lea (%edx,%ecx,1),%eax
10b8d1: 01 f0 add %esi,%eax
10b8d3: c1 e0 02 shl $0x2,%eax
10b8d6: 50 push %eax
10b8d7: e8 44 1b 00 00 call 10d420 <_Workspace_Allocate>
10b8dc: 89 45 cc mov %eax,-0x34(%ebp)
block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *))
);
if ( !object_blocks )
10b8df: 83 c4 10 add $0x10,%esp
10b8e2: 85 c0 test %eax,%eax
10b8e4: 0f 85 dd fd ff ff jne 10b6c7 <_Objects_Extend_information+0x6f><== ALWAYS TAKEN
10b8ea: e9 6b ff ff ff jmp 10b85a <_Objects_Extend_information+0x202><== NOT EXECUTED
10b8ef: 90 nop <== NOT EXECUTED
if ( !information->object_blocks[ block ] )
return;
}
else {
information->object_blocks[ block ] =
10b8f0: c1 e3 02 shl $0x2,%ebx
10b8f3: 89 5d dc mov %ebx,-0x24(%ebp)
10b8f6: 8b 4d 08 mov 0x8(%ebp),%ecx
10b8f9: 03 59 34 add 0x34(%ecx),%ebx
10b8fc: 83 ec 0c sub $0xc,%esp
10b8ff: 8b 75 a8 mov -0x58(%ebp),%esi
10b902: 0f af 71 18 imul 0x18(%ecx),%esi
10b906: 56 push %esi
10b907: e8 2c 1b 00 00 call 10d438 <_Workspace_Allocate_or_fatal_error>
10b90c: 89 03 mov %eax,(%ebx)
10b90e: 8b 7d 08 mov 0x8(%ebp),%edi
10b911: 8b 47 34 mov 0x34(%edi),%eax
10b914: 8b 55 dc mov -0x24(%ebp),%edx
10b917: 8b 04 10 mov (%eax,%edx,1),%eax
10b91a: 83 c4 10 add $0x10,%esp
10b91d: e9 be fe ff ff jmp 10b7e0 <_Objects_Extend_information+0x188>
10b922: 66 90 xchg %ax,%ax
/*
* 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,
10b924: 8b 45 c0 mov -0x40(%ebp),%eax
10b927: c1 e0 02 shl $0x2,%eax
10b92a: 8b 7d 08 mov 0x8(%ebp),%edi
10b92d: 8b 77 34 mov 0x34(%edi),%esi
10b930: 8b 7d cc mov -0x34(%ebp),%edi
10b933: 89 c1 mov %eax,%ecx
10b935: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
10b937: 8b 55 08 mov 0x8(%ebp),%edx
10b93a: 8b 72 30 mov 0x30(%edx),%esi
10b93d: 8b 7d d0 mov -0x30(%ebp),%edi
10b940: 89 c1 mov %eax,%ecx
10b942: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
10b944: 0f b7 4a 10 movzwl 0x10(%edx),%ecx
10b948: 03 4d c8 add -0x38(%ebp),%ecx
10b94b: c1 e1 02 shl $0x2,%ecx
10b94e: 8b 72 1c mov 0x1c(%edx),%esi
10b951: 8b 7d d8 mov -0x28(%ebp),%edi
10b954: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
10b956: e9 ad fd ff ff jmp 10b708 <_Objects_Extend_information+0xb0>
10b95b: 90 nop
information->maximum
);
_ISR_Enable( level );
if ( old_tables )
10b95c: 8b 4f 14 mov 0x14(%edi),%ecx
10b95f: 89 4d a8 mov %ecx,-0x58(%ebp)
10b962: e9 41 fe ff ff jmp 10b7a8 <_Objects_Extend_information+0x150>
if ( information->maximum < minimum_index )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
10b967: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED
10b96a: 89 4d c4 mov %ecx,-0x3c(%ebp) <== NOT EXECUTED
10b96d: 31 db xor %ebx,%ebx <== NOT EXECUTED
10b96f: e9 3b ff ff ff jmp 10b8af <_Objects_Extend_information+0x257><== NOT EXECUTED
0010b974 <_Objects_Free>:
void _Objects_Free(
Objects_Information *information,
Objects_Control *the_object
)
{
10b974: 55 push %ebp
10b975: 89 e5 mov %esp,%ebp
10b977: 57 push %edi
10b978: 56 push %esi
10b979: 53 push %ebx
10b97a: 83 ec 14 sub $0x14,%esp
10b97d: 8b 5d 08 mov 0x8(%ebp),%ebx
10b980: 8b 75 0c mov 0xc(%ebp),%esi
uint32_t allocation_size = information->allocation_size;
10b983: 8b 7b 14 mov 0x14(%ebx),%edi
_Chain_Append( &information->Inactive, &the_object->Node );
10b986: 56 push %esi
10b987: 8d 43 20 lea 0x20(%ebx),%eax
10b98a: 50 push %eax
10b98b: e8 ec f3 ff ff call 10ad7c <_Chain_Append>
if ( information->auto_extend ) {
10b990: 83 c4 10 add $0x10,%esp
10b993: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10b997: 74 35 je 10b9ce <_Objects_Free+0x5a>
uint32_t block;
block =
10b999: 8b 46 08 mov 0x8(%esi),%eax
10b99c: 25 ff ff 00 00 and $0xffff,%eax
10b9a1: 8b 53 08 mov 0x8(%ebx),%edx
10b9a4: 81 e2 ff ff 00 00 and $0xffff,%edx
10b9aa: 29 d0 sub %edx,%eax
_Objects_Get_index( the_object->id ) - _Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]++;
10b9ac: 31 d2 xor %edx,%edx
10b9ae: f7 73 14 divl 0x14(%ebx)
10b9b1: c1 e0 02 shl $0x2,%eax
10b9b4: 03 43 30 add 0x30(%ebx),%eax
10b9b7: ff 00 incl (%eax)
information->inactive++;
10b9b9: 8b 53 2c mov 0x2c(%ebx),%edx
10b9bc: 42 inc %edx
10b9bd: 66 89 53 2c mov %dx,0x2c(%ebx)
/*
* Check if the threshold level has been met of
* 1.5 x allocation_size are free.
*/
if ( information->inactive > ( allocation_size + ( allocation_size >> 1 ) ) ) {
10b9c1: 0f b7 d2 movzwl %dx,%edx
10b9c4: 89 f8 mov %edi,%eax
10b9c6: d1 e8 shr %eax
10b9c8: 01 f8 add %edi,%eax
10b9ca: 39 c2 cmp %eax,%edx
10b9cc: 77 0a ja 10b9d8 <_Objects_Free+0x64>
_Objects_Shrink_information( information );
}
}
}
10b9ce: 8d 65 f4 lea -0xc(%ebp),%esp
10b9d1: 5b pop %ebx
10b9d2: 5e pop %esi
10b9d3: 5f pop %edi
10b9d4: c9 leave
10b9d5: c3 ret
10b9d6: 66 90 xchg %ax,%ax
* Check if the threshold level has been met of
* 1.5 x allocation_size are free.
*/
if ( information->inactive > ( allocation_size + ( allocation_size >> 1 ) ) ) {
_Objects_Shrink_information( information );
10b9d8: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
}
10b9db: 8d 65 f4 lea -0xc(%ebp),%esp
10b9de: 5b pop %ebx
10b9df: 5e pop %esi
10b9e0: 5f pop %edi
10b9e1: c9 leave
* Check if the threshold level has been met of
* 1.5 x allocation_size are free.
*/
if ( information->inactive > ( allocation_size + ( allocation_size >> 1 ) ) ) {
_Objects_Shrink_information( information );
10b9e2: e9 a5 02 00 00 jmp 10bc8c <_Objects_Shrink_information>
0010baa8 <_Objects_Get>:
Objects_Control *_Objects_Get(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
10baa8: 55 push %ebp
10baa9: 89 e5 mov %esp,%ebp
10baab: 53 push %ebx
10baac: 83 ec 04 sub $0x4,%esp
10baaf: 8b 4d 08 mov 0x8(%ebp),%ecx
* always NULL.
*
* If the Id is valid but the object has not been created yet, then
* the local_table entry will be NULL.
*/
index = id - information->minimum_id + 1;
10bab2: ba 01 00 00 00 mov $0x1,%edx
10bab7: 2b 51 08 sub 0x8(%ecx),%edx
10baba: 03 55 0c add 0xc(%ebp),%edx
/*
* If the index is less than maximum, then it is OK to use it to
* index into the local_table array.
*/
if ( index <= information->maximum ) {
10babd: 0f b7 41 10 movzwl 0x10(%ecx),%eax
10bac1: 39 c2 cmp %eax,%edx
10bac3: 77 27 ja 10baec <_Objects_Get+0x44>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10bac5: a1 58 e6 11 00 mov 0x11e658,%eax
10baca: 40 inc %eax
10bacb: a3 58 e6 11 00 mov %eax,0x11e658
_Thread_Disable_dispatch();
if ( (the_object = information->local_table[ index ]) != NULL ) {
10bad0: 8b 41 1c mov 0x1c(%ecx),%eax
10bad3: 8b 1c 90 mov (%eax,%edx,4),%ebx
10bad6: 85 db test %ebx,%ebx
10bad8: 74 1f je 10baf9 <_Objects_Get+0x51>
*location = OBJECTS_LOCAL;
10bada: 8b 45 10 mov 0x10(%ebp),%eax
10badd: c7 00 00 00 00 00 movl $0x0,(%eax)
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
#endif
}
10bae3: 89 d8 mov %ebx,%eax
10bae5: 5a pop %edx
10bae6: 5b pop %ebx
10bae7: c9 leave
10bae8: c3 ret
10bae9: 8d 76 00 lea 0x0(%esi),%esi
/*
* Object Id is not within this API and Class on this node. So
* it may be global in a multiprocessing system. But it is clearly
* invalid on a single processor system.
*/
*location = OBJECTS_ERROR;
10baec: 8b 45 10 mov 0x10(%ebp),%eax
10baef: c7 00 01 00 00 00 movl $0x1,(%eax)
10baf5: 31 db xor %ebx,%ebx
10baf7: eb ea jmp 10bae3 <_Objects_Get+0x3b>
/*
* Valid Id for this API, Class and Node but the object has not
* been allocated yet.
*/
_Thread_Enable_dispatch();
10baf9: e8 ee 07 00 00 call 10c2ec <_Thread_Enable_dispatch>
*location = OBJECTS_ERROR;
10bafe: 8b 45 10 mov 0x10(%ebp),%eax
10bb01: c7 00 01 00 00 00 movl $0x1,(%eax)
10bb07: eb da jmp 10bae3 <_Objects_Get+0x3b>
0010ba08 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint32_t the_class
)
{
10ba08: 55 push %ebp
10ba09: 89 e5 mov %esp,%ebp
10ba0b: 53 push %ebx
10ba0c: 83 ec 04 sub $0x4,%esp
10ba0f: 8b 5d 08 mov 0x8(%ebp),%ebx
/**
* 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.
10ba12: 8d 43 ff lea -0x1(%ebx),%eax
10ba15: 83 f8 03 cmp $0x3,%eax
10ba18: 77 07 ja 10ba21 <_Objects_Get_information+0x19>
int the_class_api_maximum;
if ( !_Objects_Is_api_valid( the_api ) )
return NULL;
if ( !the_class )
10ba1a: 8b 45 0c mov 0xc(%ebp),%eax
10ba1d: 85 c0 test %eax,%eax
10ba1f: 75 07 jne 10ba28 <_Objects_Get_information+0x20>
* 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 )
10ba21: 31 c0 xor %eax,%eax
return NULL;
#endif
return info;
}
10ba23: 8b 5d fc mov -0x4(%ebp),%ebx
10ba26: c9 leave
10ba27: c3 ret
return NULL;
if ( !the_class )
return NULL;
the_class_api_maximum = _Objects_API_maximum_class( the_api );
10ba28: 83 ec 0c sub $0xc,%esp
10ba2b: 53 push %ebx
10ba2c: e8 8b 3a 00 00 call 10f4bc <_Objects_API_maximum_class>
if ( the_class_api_maximum < 0 ||
10ba31: 83 c4 10 add $0x10,%esp
10ba34: 85 c0 test %eax,%eax
10ba36: 78 e9 js 10ba21 <_Objects_Get_information+0x19><== NEVER TAKEN
10ba38: 39 45 0c cmp %eax,0xc(%ebp)
10ba3b: 77 e4 ja 10ba21 <_Objects_Get_information+0x19><== NEVER TAKEN
the_class > (uint32_t) the_class_api_maximum )
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10ba3d: 8b 04 9d 2c e6 11 00 mov 0x11e62c(,%ebx,4),%eax
10ba44: 85 c0 test %eax,%eax
10ba46: 74 d9 je 10ba21 <_Objects_Get_information+0x19><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
10ba48: 8b 55 0c mov 0xc(%ebp),%edx
10ba4b: 8b 04 90 mov (%eax,%edx,4),%eax
if ( !info )
10ba4e: 85 c0 test %eax,%eax
10ba50: 74 d1 je 10ba23 <_Objects_Get_information+0x1b><== 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 )
10ba52: 66 83 78 10 00 cmpw $0x0,0x10(%eax)
10ba57: 75 ca jne 10ba23 <_Objects_Get_information+0x1b>
10ba59: eb c6 jmp 10ba21 <_Objects_Get_information+0x19>
0010ba5c <_Objects_Get_isr_disable>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location,
ISR_Level *level_p
)
{
10ba5c: 55 push %ebp
10ba5d: 89 e5 mov %esp,%ebp
10ba5f: 56 push %esi
10ba60: 53 push %ebx
10ba61: 8b 5d 08 mov 0x8(%ebp),%ebx
10ba64: 8b 75 10 mov 0x10(%ebp),%esi
#if defined(RTEMS_MULTIPROCESSING)
index = id - information->minimum_id + 1;
#else
/* index = _Objects_Get_index( id ); */
index = id & 0x0000ffff;
10ba67: 0f b7 55 0c movzwl 0xc(%ebp),%edx
/* This should work but doesn't always :( */
/* index = (uint16_t ) id; */
#endif
_ISR_Disable( level );
10ba6b: 9c pushf
10ba6c: fa cli
10ba6d: 59 pop %ecx
if ( information->maximum >= index ) {
10ba6e: 0f b7 43 10 movzwl 0x10(%ebx),%eax
10ba72: 39 c2 cmp %eax,%edx
10ba74: 77 1a ja 10ba90 <_Objects_Get_isr_disable+0x34>
if ( (the_object = information->local_table[ index ]) != NULL ) {
10ba76: 8b 43 1c mov 0x1c(%ebx),%eax
10ba79: 8b 04 90 mov (%eax,%edx,4),%eax
10ba7c: 85 c0 test %eax,%eax
10ba7e: 74 1c je 10ba9c <_Objects_Get_isr_disable+0x40><== NEVER TAKEN
*location = OBJECTS_LOCAL;
10ba80: c7 06 00 00 00 00 movl $0x0,(%esi)
*level_p = level;
10ba86: 8b 55 14 mov 0x14(%ebp),%edx
10ba89: 89 0a mov %ecx,(%edx)
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
#endif
}
10ba8b: 5b pop %ebx
10ba8c: 5e pop %esi
10ba8d: c9 leave
10ba8e: c3 ret
10ba8f: 90 nop
}
_ISR_Enable( level );
*location = OBJECTS_ERROR;
return NULL;
}
_ISR_Enable( level );
10ba90: 51 push %ecx
10ba91: 9d popf
*location = OBJECTS_ERROR;
10ba92: c7 06 01 00 00 00 movl $0x1,(%esi)
10ba98: 31 c0 xor %eax,%eax
10ba9a: eb ef jmp 10ba8b <_Objects_Get_isr_disable+0x2f>
if ( (the_object = information->local_table[ index ]) != NULL ) {
*location = OBJECTS_LOCAL;
*level_p = level;
return the_object;
}
_ISR_Enable( level );
10ba9c: 51 push %ecx <== NOT EXECUTED
10ba9d: 9d popf <== NOT EXECUTED
*location = OBJECTS_ERROR;
10ba9e: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED
10baa4: eb e5 jmp 10ba8b <_Objects_Get_isr_disable+0x2f><== NOT EXECUTED
0010ce74 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
10ce74: 55 push %ebp
10ce75: 89 e5 mov %esp,%ebp
10ce77: 57 push %edi
10ce78: 56 push %esi
10ce79: 53 push %ebx
10ce7a: 83 ec 1c sub $0x1c,%esp
10ce7d: 8b 75 0c mov 0xc(%ebp),%esi
10ce80: 8b 5d 10 mov 0x10(%ebp),%ebx
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
10ce83: 85 f6 test %esi,%esi
10ce85: 75 0d jne 10ce94 <_Objects_Get_name_as_string+0x20>
}
}
*d = '\0';
_Thread_Enable_dispatch();
return name;
10ce87: 31 db xor %ebx,%ebx
}
return NULL; /* unreachable path */
}
10ce89: 89 d8 mov %ebx,%eax
10ce8b: 8d 65 f4 lea -0xc(%ebp),%esp
10ce8e: 5b pop %ebx
10ce8f: 5e pop %esi
10ce90: 5f pop %edi
10ce91: c9 leave
10ce92: c3 ret
10ce93: 90 nop
Objects_Id tmpId;
if ( length == 0 )
return NULL;
if ( name == NULL )
10ce94: 85 db test %ebx,%ebx
10ce96: 74 f1 je 10ce89 <_Objects_Get_name_as_string+0x15>
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10ce98: 8b 7d 08 mov 0x8(%ebp),%edi
10ce9b: 85 ff test %edi,%edi
10ce9d: 0f 84 8d 00 00 00 je 10cf30 <_Objects_Get_name_as_string+0xbc>
10cea3: 8b 45 08 mov 0x8(%ebp),%eax
10cea6: 89 45 e0 mov %eax,-0x20(%ebp)
information = _Objects_Get_information_id( tmpId );
10cea9: 83 ec 0c sub $0xc,%esp
10ceac: ff 75 e0 pushl -0x20(%ebp)
10ceaf: e8 00 ff ff ff call 10cdb4 <_Objects_Get_information_id>
10ceb4: 89 c7 mov %eax,%edi
if ( !information )
10ceb6: 83 c4 10 add $0x10,%esp
10ceb9: 85 c0 test %eax,%eax
10cebb: 74 ca je 10ce87 <_Objects_Get_name_as_string+0x13>
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
10cebd: 51 push %ecx
10cebe: 8d 45 f0 lea -0x10(%ebp),%eax
10cec1: 50 push %eax
10cec2: ff 75 e0 pushl -0x20(%ebp)
10cec5: 57 push %edi
10cec6: e8 a9 00 00 00 call 10cf74 <_Objects_Get>
switch ( location ) {
10cecb: 83 c4 10 add $0x10,%esp
10cece: 8b 55 f0 mov -0x10(%ebp),%edx
10ced1: 85 d2 test %edx,%edx
10ced3: 75 b2 jne 10ce87 <_Objects_Get_name_as_string+0x13>
case OBJECTS_ERROR:
return NULL;
case OBJECTS_LOCAL:
if ( information->is_string ) {
10ced5: 80 7f 38 00 cmpb $0x0,0x38(%edi)
10ced9: 74 65 je 10cf40 <_Objects_Get_name_as_string+0xcc>
s = the_object->name.name_p;
10cedb: 8b 40 0c mov 0xc(%eax),%eax
10cede: 89 45 dc mov %eax,-0x24(%ebp)
lname[ 4 ] = '\0';
s = lname;
}
d = name;
if ( s ) {
10cee1: 85 c0 test %eax,%eax
10cee3: 0f 84 84 00 00 00 je 10cf6d <_Objects_Get_name_as_string+0xf9><== NEVER TAKEN
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10cee9: 4e dec %esi
10ceea: 89 75 d8 mov %esi,-0x28(%ebp)
10ceed: 74 7e je 10cf6d <_Objects_Get_name_as_string+0xf9><== NEVER TAKEN
10ceef: 8b 45 dc mov -0x24(%ebp),%eax
10cef2: 8a 08 mov (%eax),%cl
10cef4: 84 c9 test %cl,%cl
10cef6: 74 75 je 10cf6d <_Objects_Get_name_as_string+0xf9>
10cef8: 89 df mov %ebx,%edi
10cefa: 31 f6 xor %esi,%esi
10cefc: eb 0c jmp 10cf0a <_Objects_Get_name_as_string+0x96>
10cefe: 66 90 xchg %ax,%ax
10cf00: 8b 45 dc mov -0x24(%ebp),%eax
10cf03: 8a 0c 30 mov (%eax,%esi,1),%cl
10cf06: 84 c9 test %cl,%cl
10cf08: 74 19 je 10cf23 <_Objects_Get_name_as_string+0xaf>
*d = (isprint(*s)) ? *s : '*';
10cf0a: 0f be d1 movsbl %cl,%edx
10cf0d: a1 c8 07 12 00 mov 0x1207c8,%eax
10cf12: f6 04 10 97 testb $0x97,(%eax,%edx,1)
10cf16: 75 02 jne 10cf1a <_Objects_Get_name_as_string+0xa6>
10cf18: b1 2a mov $0x2a,%cl
10cf1a: 88 0f mov %cl,(%edi)
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10cf1c: 46 inc %esi
10cf1d: 47 inc %edi
10cf1e: 3b 75 d8 cmp -0x28(%ebp),%esi
10cf21: 72 dd jb 10cf00 <_Objects_Get_name_as_string+0x8c>
*d = (isprint(*s)) ? *s : '*';
}
}
*d = '\0';
10cf23: c6 07 00 movb $0x0,(%edi)
_Thread_Enable_dispatch();
10cf26: e8 8d 08 00 00 call 10d7b8 <_Thread_Enable_dispatch>
10cf2b: e9 59 ff ff ff jmp 10ce89 <_Objects_Get_name_as_string+0x15>
return NULL;
if ( name == NULL )
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10cf30: a1 3c a7 12 00 mov 0x12a73c,%eax
10cf35: 8b 40 08 mov 0x8(%eax),%eax
10cf38: 89 45 e0 mov %eax,-0x20(%ebp)
10cf3b: e9 69 ff ff ff jmp 10cea9 <_Objects_Get_name_as_string+0x35>
case OBJECTS_LOCAL:
if ( information->is_string ) {
s = the_object->name.name_p;
} else {
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
10cf40: 8b 50 0c mov 0xc(%eax),%edx
lname[ 0 ] = (u32_name >> 24) & 0xff;
10cf43: 89 d0 mov %edx,%eax
10cf45: c1 e8 18 shr $0x18,%eax
10cf48: 88 45 eb mov %al,-0x15(%ebp)
lname[ 1 ] = (u32_name >> 16) & 0xff;
10cf4b: 89 d0 mov %edx,%eax
10cf4d: c1 e8 10 shr $0x10,%eax
10cf50: 88 45 ec mov %al,-0x14(%ebp)
lname[ 2 ] = (u32_name >> 8) & 0xff;
10cf53: 89 d0 mov %edx,%eax
10cf55: c1 e8 08 shr $0x8,%eax
10cf58: 88 45 ed mov %al,-0x13(%ebp)
lname[ 3 ] = (u32_name >> 0) & 0xff;
10cf5b: 88 55 ee mov %dl,-0x12(%ebp)
lname[ 4 ] = '\0';
10cf5e: c6 45 ef 00 movb $0x0,-0x11(%ebp)
10cf62: 8d 45 eb lea -0x15(%ebp),%eax
10cf65: 89 45 dc mov %eax,-0x24(%ebp)
10cf68: e9 7c ff ff ff jmp 10cee9 <_Objects_Get_name_as_string+0x75>
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10cf6d: 89 df mov %ebx,%edi
10cf6f: eb b2 jmp 10cf23 <_Objects_Get_name_as_string+0xaf>
00116ba0 <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
116ba0: 55 push %ebp
116ba1: 89 e5 mov %esp,%ebp
116ba3: 8b 4d 08 mov 0x8(%ebp),%ecx
/*
* 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;
116ba6: ba 01 00 00 00 mov $0x1,%edx
116bab: 2b 51 08 sub 0x8(%ecx),%edx
116bae: 03 55 0c add 0xc(%ebp),%edx
if ( information->maximum >= index ) {
116bb1: 0f b7 41 10 movzwl 0x10(%ecx),%eax
116bb5: 39 c2 cmp %eax,%edx
116bb7: 77 17 ja 116bd0 <_Objects_Get_no_protection+0x30>
if ( (the_object = information->local_table[ index ]) != NULL ) {
116bb9: 8b 41 1c mov 0x1c(%ecx),%eax
116bbc: 8b 04 90 mov (%eax,%edx,4),%eax
116bbf: 85 c0 test %eax,%eax
116bc1: 74 0d je 116bd0 <_Objects_Get_no_protection+0x30><== NEVER TAKEN
*location = OBJECTS_LOCAL;
116bc3: 8b 55 10 mov 0x10(%ebp),%edx
116bc6: c7 02 00 00 00 00 movl $0x0,(%edx)
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
*location = OBJECTS_ERROR;
return NULL;
}
116bcc: c9 leave
116bcd: c3 ret
116bce: 66 90 xchg %ax,%ax
/*
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
*location = OBJECTS_ERROR;
116bd0: 8b 45 10 mov 0x10(%ebp),%eax
116bd3: c7 00 01 00 00 00 movl $0x1,(%eax)
116bd9: 31 c0 xor %eax,%eax
return NULL;
}
116bdb: c9 leave
116bdc: c3 ret
0010cb3c <_Objects_Id_to_name>:
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
10cb3c: 55 push %ebp
10cb3d: 89 e5 mov %esp,%ebp
10cb3f: 53 push %ebx
10cb40: 83 ec 14 sub $0x14,%esp
10cb43: 8b 45 08 mov 0x8(%ebp),%eax
10cb46: 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 )
10cb49: 85 db test %ebx,%ebx
10cb4b: 74 7b je 10cbc8 <_Objects_Id_to_name+0x8c><== NEVER TAKEN
return OBJECTS_INVALID_NAME;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10cb4d: 85 c0 test %eax,%eax
10cb4f: 74 53 je 10cba4 <_Objects_Id_to_name+0x68>
10cb51: 89 c1 mov %eax,%ecx
uint32_t page_size
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
10cb53: 89 ca mov %ecx,%edx
10cb55: c1 ea 18 shr $0x18,%edx
10cb58: 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.
10cb5b: 8d 42 ff lea -0x1(%edx),%eax
10cb5e: 83 f8 03 cmp $0x3,%eax
10cb61: 77 59 ja 10cbbc <_Objects_Id_to_name+0x80>
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
10cb63: 8b 14 95 8c 16 12 00 mov 0x12168c(,%edx,4),%edx
10cb6a: 85 d2 test %edx,%edx
10cb6c: 74 4e je 10cbbc <_Objects_Id_to_name+0x80><== NEVER TAKEN
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
10cb6e: 89 c8 mov %ecx,%eax
10cb70: c1 e8 1b shr $0x1b,%eax
10cb73: 8b 14 82 mov (%edx,%eax,4),%edx
if ( !information )
10cb76: 85 d2 test %edx,%edx
10cb78: 74 42 je 10cbbc <_Objects_Id_to_name+0x80><== NEVER TAKEN
return OBJECTS_INVALID_ID;
if ( information->is_string )
10cb7a: 80 7a 38 00 cmpb $0x0,0x38(%edx)
10cb7e: 75 3c jne 10cbbc <_Objects_Id_to_name+0x80><== NEVER TAKEN
return OBJECTS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &ignored_location );
10cb80: 50 push %eax
10cb81: 8d 45 f8 lea -0x8(%ebp),%eax
10cb84: 50 push %eax
10cb85: 51 push %ecx
10cb86: 52 push %edx
10cb87: e8 4c ff ff ff call 10cad8 <_Objects_Get>
if ( !the_object )
10cb8c: 83 c4 10 add $0x10,%esp
10cb8f: 85 c0 test %eax,%eax
10cb91: 74 29 je 10cbbc <_Objects_Id_to_name+0x80>
return OBJECTS_INVALID_ID;
*name = the_object->name;
10cb93: 8b 40 0c mov 0xc(%eax),%eax
10cb96: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10cb98: e8 13 08 00 00 call 10d3b0 <_Thread_Enable_dispatch>
10cb9d: 31 c0 xor %eax,%eax
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
10cb9f: 8b 5d fc mov -0x4(%ebp),%ebx
10cba2: c9 leave
10cba3: c3 ret
Objects_Locations ignored_location;
if ( !name )
return OBJECTS_INVALID_NAME;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10cba4: a1 7c 17 12 00 mov 0x12177c,%eax
10cba9: 8b 48 08 mov 0x8(%eax),%ecx
uint32_t page_size
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
10cbac: 89 ca mov %ecx,%edx
10cbae: c1 ea 18 shr $0x18,%edx
10cbb1: 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.
10cbb4: 8d 42 ff lea -0x1(%edx),%eax
10cbb7: 83 f8 03 cmp $0x3,%eax
10cbba: 76 a7 jbe 10cb63 <_Objects_Id_to_name+0x27><== ALWAYS TAKEN
if ( !the_object )
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10cbbc: b8 03 00 00 00 mov $0x3,%eax
}
10cbc1: 8b 5d fc mov -0x4(%ebp),%ebx
10cbc4: c9 leave
10cbc5: c3 ret
10cbc6: 66 90 xchg %ax,%ax
Objects_Id tmpId;
Objects_Information *information;
Objects_Control *the_object = (Objects_Control *) 0;
Objects_Locations ignored_location;
if ( !name )
10cbc8: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
10cbcd: eb f2 jmp 10cbc1 <_Objects_Id_to_name+0x85><== NOT EXECUTED
0010bb0c <_Objects_Initialize_information>:
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
10bb0c: 55 push %ebp
10bb0d: 89 e5 mov %esp,%ebp
10bb0f: 57 push %edi
10bb10: 56 push %esi
10bb11: 53 push %ebx
10bb12: 8b 7d 08 mov 0x8(%ebp),%edi
10bb15: 8b 55 0c mov 0xc(%ebp),%edx
10bb18: 8b 5d 10 mov 0x10(%ebp),%ebx
10bb1b: 8b 75 20 mov 0x20(%ebp),%esi
10bb1e: 0f b7 4d 18 movzwl 0x18(%ebp),%ecx
uint32_t name_length;
#if defined(RTEMS_MULTIPROCESSING)
uint32_t index;
#endif
information->the_api = the_api;
10bb22: 89 17 mov %edx,(%edi)
information->the_class = the_class;
10bb24: 66 89 5f 04 mov %bx,0x4(%edi)
information->is_string = is_string;
10bb28: 8b 45 1c mov 0x1c(%ebp),%eax
10bb2b: 88 47 38 mov %al,0x38(%edi)
information->local_table = 0;
information->inactive_per_block = 0;
10bb2e: c7 47 30 00 00 00 00 movl $0x0,0x30(%edi)
information->object_blocks = 0;
10bb35: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi)
information->inactive = 0;
10bb3c: 66 c7 47 2c 00 00 movw $0x0,0x2c(%edi)
/*
* Set the entry in the object information table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
10bb42: 8b 04 95 2c e6 11 00 mov 0x11e62c(,%edx,4),%eax
10bb49: 89 3c 98 mov %edi,(%eax,%ebx,4)
/*
* Set the size of the object
*/
information->size = size;
10bb4c: 89 4f 18 mov %ecx,0x18(%edi)
/*
* Are we operating in unlimited, or auto-extend mode
*/
information->auto_extend =
10bb4f: 8b 45 14 mov 0x14(%ebp),%eax
10bb52: c1 e8 1f shr $0x1f,%eax
10bb55: 88 47 12 mov %al,0x12(%edi)
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE;
maximum &= ~OBJECTS_UNLIMITED_OBJECTS;
10bb58: 8b 4d 14 mov 0x14(%ebp),%ecx
10bb5b: 81 e1 ff ff ff 7f and $0x7fffffff,%ecx
/*
* The allocation unit is the maximum value
*/
information->allocation_size = maximum;
10bb61: 89 4f 14 mov %ecx,0x14(%edi)
/*
* Provide a null local table entry for the case of any empty table.
*/
information->local_table = &null_local_table;
10bb64: c7 47 1c c4 e3 11 00 movl $0x11e3c4,0x1c(%edi)
*/
if ( maximum == 0 ) minimum_index = 0;
else minimum_index = 1;
information->minimum_id =
10bb6b: c1 e2 18 shl $0x18,%edx
10bb6e: 81 ca 00 00 01 00 or $0x10000,%edx
10bb74: c1 e3 1b shl $0x1b,%ebx
10bb77: 09 da or %ebx,%edx
10bb79: 31 c0 xor %eax,%eax
10bb7b: 85 c9 test %ecx,%ecx
10bb7d: 0f 95 c0 setne %al
10bb80: 09 c2 or %eax,%edx
10bb82: 89 57 08 mov %edx,0x8(%edi)
* Calculate the maximum name length
*/
name_length = maximum_name_length;
if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
10bb85: f7 c6 03 00 00 00 test $0x3,%esi
10bb8b: 75 23 jne 10bbb0 <_Objects_Initialize_information+0xa4><== NEVER TAKEN
10bb8d: 89 f0 mov %esi,%eax
name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
~(OBJECTS_NAME_ALIGNMENT-1);
information->name_length = name_length;
10bb8f: 66 89 47 3a mov %ax,0x3a(%edi)
10bb93: 8d 47 24 lea 0x24(%edi),%eax
10bb96: 89 47 20 mov %eax,0x20(%edi)
10bb99: c7 47 24 00 00 00 00 movl $0x0,0x24(%edi)
10bba0: 8d 47 20 lea 0x20(%edi),%eax
10bba3: 89 47 28 mov %eax,0x28(%edi)
/*
* Initialize objects .. if there are any
*/
if ( maximum ) {
10bba6: 85 c9 test %ecx,%ecx
10bba8: 75 0e jne 10bbb8 <_Objects_Initialize_information+0xac>
_Chain_Initialize_empty( &information->global_table[ index ] );
}
else
information->global_table = NULL;
#endif
}
10bbaa: 5b pop %ebx
10bbab: 5e pop %esi
10bbac: 5f pop %edi
10bbad: c9 leave
10bbae: c3 ret
10bbaf: 90 nop
*/
name_length = maximum_name_length;
if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
10bbb0: 8d 46 04 lea 0x4(%esi),%eax <== NOT EXECUTED
10bbb3: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED
10bbb6: eb d7 jmp 10bb8f <_Objects_Initialize_information+0x83><== NOT EXECUTED
/*
* Reset the maximum value. It will be updated when the information is
* extended.
*/
information->maximum = 0;
10bbb8: 66 c7 47 10 00 00 movw $0x0,0x10(%edi)
* Always have the maximum size available so the current performance
* figures are create are met. If the user moves past the maximum
* number then a performance hit is taken.
*/
_Objects_Extend_information( information );
10bbbe: 89 7d 08 mov %edi,0x8(%ebp)
_Chain_Initialize_empty( &information->global_table[ index ] );
}
else
information->global_table = NULL;
#endif
}
10bbc1: 5b pop %ebx
10bbc2: 5e pop %esi
10bbc3: 5f pop %edi
10bbc4: c9 leave
* Always have the maximum size available so the current performance
* figures are create are met. If the user moves past the maximum
* number then a performance hit is taken.
*/
_Objects_Extend_information( information );
10bbc5: e9 8e fa ff ff jmp 10b658 <_Objects_Extend_information>
0010bc00 <_Objects_Name_to_id_u32>:
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
10bc00: 55 push %ebp
10bc01: 89 e5 mov %esp,%ebp
10bc03: 57 push %edi
10bc04: 56 push %esi
10bc05: 53 push %ebx
10bc06: 8b 75 0c mov 0xc(%ebp),%esi
10bc09: 8b 7d 14 mov 0x14(%ebp),%edi
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == FALSE */
if ( !id )
10bc0c: 85 ff test %edi,%edi
10bc0e: 74 5c je 10bc6c <_Objects_Name_to_id_u32+0x6c>
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
10bc10: 85 f6 test %esi,%esi
10bc12: 74 38 je 10bc4c <_Objects_Name_to_id_u32+0x4c>
return OBJECTS_INVALID_NAME;
search_local_node = FALSE;
if ( information->maximum != 0 &&
10bc14: 8b 55 08 mov 0x8(%ebp),%edx
10bc17: 8b 42 10 mov 0x10(%edx),%eax
10bc1a: 66 85 c0 test %ax,%ax
10bc1d: 74 2d je 10bc4c <_Objects_Name_to_id_u32+0x4c><== NEVER TAKEN
10bc1f: 8b 55 10 mov 0x10(%ebp),%edx
10bc22: 85 d2 test %edx,%edx
10bc24: 75 32 jne 10bc58 <_Objects_Name_to_id_u32+0x58>
search_local_node = TRUE;
if ( search_local_node ) {
name_length = information->name_length;
for ( index = 1; index <= information->maximum; index++ ) {
10bc26: 0f b7 d8 movzwl %ax,%ebx
10bc29: 85 db test %ebx,%ebx
10bc2b: 74 1f je 10bc4c <_Objects_Name_to_id_u32+0x4c><== NEVER TAKEN
if ( name == 0 )
return OBJECTS_INVALID_NAME;
search_local_node = FALSE;
if ( information->maximum != 0 &&
10bc2d: 8b 45 08 mov 0x8(%ebp),%eax
10bc30: 8b 48 1c mov 0x1c(%eax),%ecx
10bc33: ba 01 00 00 00 mov $0x1,%edx
if ( search_local_node ) {
name_length = information->name_length;
for ( index = 1; index <= information->maximum; index++ ) {
the_object = information->local_table[ index ];
10bc38: 8b 04 91 mov (%ecx,%edx,4),%eax
if ( !the_object )
10bc3b: 85 c0 test %eax,%eax
10bc3d: 74 05 je 10bc44 <_Objects_Name_to_id_u32+0x44>
continue;
if ( name == the_object->name.name_u32 ) {
10bc3f: 39 70 0c cmp %esi,0xc(%eax)
10bc42: 74 34 je 10bc78 <_Objects_Name_to_id_u32+0x78>
search_local_node = TRUE;
if ( search_local_node ) {
name_length = information->name_length;
for ( index = 1; index <= information->maximum; index++ ) {
10bc44: 42 inc %edx
10bc45: 39 da cmp %ebx,%edx
10bc47: 76 ef jbe 10bc38 <_Objects_Name_to_id_u32+0x38>
10bc49: 8d 76 00 lea 0x0(%esi),%esi
10bc4c: 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
}
10bc51: 5b pop %ebx
10bc52: 5e pop %esi
10bc53: 5f pop %edi
10bc54: c9 leave
10bc55: c3 ret
10bc56: 66 90 xchg %ax,%ax
if ( name == 0 )
return OBJECTS_INVALID_NAME;
search_local_node = FALSE;
if ( information->maximum != 0 &&
10bc58: 81 7d 10 ff ff ff 7f cmpl $0x7fffffff,0x10(%ebp)
10bc5f: 74 c5 je 10bc26 <_Objects_Name_to_id_u32+0x26>
10bc61: 83 7d 10 01 cmpl $0x1,0x10(%ebp)
10bc65: 75 e5 jne 10bc4c <_Objects_Name_to_id_u32+0x4c>
10bc67: eb bd jmp 10bc26 <_Objects_Name_to_id_u32+0x26>
10bc69: 8d 76 00 lea 0x0(%esi),%esi
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == FALSE */
if ( !id )
10bc6c: b8 02 00 00 00 mov $0x2,%eax
name_for_mp.name_u32 = name;
return _Objects_MP_Global_name_search( information, name_for_mp, node, id );
#else
return OBJECTS_INVALID_NAME;
#endif
}
10bc71: 5b pop %ebx
10bc72: 5e pop %esi
10bc73: 5f pop %edi
10bc74: c9 leave
10bc75: c3 ret
10bc76: 66 90 xchg %ax,%ax
the_object = information->local_table[ index ];
if ( !the_object )
continue;
if ( name == the_object->name.name_u32 ) {
*id = the_object->id;
10bc78: 8b 40 08 mov 0x8(%eax),%eax
10bc7b: 89 07 mov %eax,(%edi)
10bc7d: 31 c0 xor %eax,%eax
name_for_mp.name_u32 = name;
return _Objects_MP_Global_name_search( information, name_for_mp, node, id );
#else
return OBJECTS_INVALID_NAME;
#endif
}
10bc7f: 5b pop %ebx
10bc80: 5e pop %esi
10bc81: 5f pop %edi
10bc82: c9 leave
10bc83: c3 ret
0010bbcc <_Objects_Namespace_remove>:
void _Objects_Namespace_remove(
Objects_Information *information,
Objects_Control *the_object
)
{
10bbcc: 55 push %ebp
10bbcd: 89 e5 mov %esp,%ebp
10bbcf: 53 push %ebx
10bbd0: 83 ec 04 sub $0x4,%esp
10bbd3: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* If this is a string format name, then free the memory.
*/
if ( information->is_string && the_object->name.name_p )
10bbd6: 8b 45 08 mov 0x8(%ebp),%eax
10bbd9: 80 78 38 00 cmpb $0x0,0x38(%eax)
10bbdd: 74 13 je 10bbf2 <_Objects_Namespace_remove+0x26><== ALWAYS TAKEN
10bbdf: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED
10bbe2: 85 c0 test %eax,%eax <== NOT EXECUTED
10bbe4: 74 0c je 10bbf2 <_Objects_Namespace_remove+0x26><== NOT EXECUTED
_Workspace_Free( (void *)the_object->name.name_p );
10bbe6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10bbe9: 50 push %eax <== NOT EXECUTED
10bbea: e8 19 18 00 00 call 10d408 <_Workspace_Free> <== NOT EXECUTED
10bbef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
/*
* Clear out either format.
*/
the_object->name.name_p = NULL;
the_object->name.name_u32 = 0;
10bbf2: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
}
10bbf9: 8b 5d fc mov -0x4(%ebp),%ebx
10bbfc: c9 leave
10bbfd: c3 ret
0010d624 <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
10d624: 55 push %ebp
10d625: 89 e5 mov %esp,%ebp
10d627: 57 push %edi
10d628: 56 push %esi
10d629: 53 push %ebx
10d62a: 83 ec 14 sub $0x14,%esp
10d62d: 8b 5d 08 mov 0x8(%ebp),%ebx
10d630: 8b 7d 10 mov 0x10(%ebp),%edi
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length ) + 1;
10d633: 0f b7 43 3a movzwl 0x3a(%ebx),%eax
10d637: 50 push %eax
10d638: 57 push %edi
10d639: e8 7e 5c 00 00 call 1132bc <strnlen>
10d63e: 8d 70 01 lea 0x1(%eax),%esi
if ( information->is_string ) {
10d641: 83 c4 10 add $0x10,%esp
10d644: 80 7b 38 00 cmpb $0x0,0x38(%ebx)
10d648: 75 5a jne 10d6a4 <_Objects_Set_name+0x80><== NEVER TAKEN
strncpy( d, name, length );
d[ length ] = '\0';
the_object->name.name_p = d;
} else {
the_object->name.name_u32 = _Objects_Build_name(
10d64a: 85 f6 test %esi,%esi
10d64c: 74 3e je 10d68c <_Objects_Set_name+0x68><== NEVER TAKEN
10d64e: 0f be 17 movsbl (%edi),%edx
10d651: c1 e2 18 shl $0x18,%edx
10d654: 83 fe 01 cmp $0x1,%esi
10d657: 0f 84 ae 00 00 00 je 10d70b <_Objects_Set_name+0xe7>
10d65d: 0f be 47 01 movsbl 0x1(%edi),%eax
10d661: c1 e0 10 shl $0x10,%eax
10d664: 09 d0 or %edx,%eax
10d666: 83 fe 02 cmp $0x2,%esi
10d669: 0f 84 89 00 00 00 je 10d6f8 <_Objects_Set_name+0xd4>
10d66f: 0f be 57 02 movsbl 0x2(%edi),%edx
10d673: c1 e2 08 shl $0x8,%edx
10d676: 09 c2 or %eax,%edx
10d678: 83 fe 03 cmp $0x3,%esi
10d67b: 0f 84 83 00 00 00 je 10d704 <_Objects_Set_name+0xe0>
10d681: 0f be 47 03 movsbl 0x3(%edi),%eax
10d685: 09 d0 or %edx,%eax
10d687: eb 08 jmp 10d691 <_Objects_Set_name+0x6d>
10d689: 8d 76 00 lea 0x0(%esi),%esi
10d68c: b8 20 20 20 20 mov $0x20202020,%eax <== NOT EXECUTED
10d691: 8b 55 0c mov 0xc(%ebp),%edx
10d694: 89 42 0c mov %eax,0xc(%edx)
10d697: b0 01 mov $0x1,%al
);
}
return TRUE;
}
10d699: 8d 65 f4 lea -0xc(%ebp),%esp
10d69c: 5b pop %ebx
10d69d: 5e pop %esi
10d69e: 5f pop %edi
10d69f: c9 leave
10d6a0: c3 ret
10d6a1: 8d 76 00 lea 0x0(%esi),%esi
length = strnlen( name, information->name_length ) + 1;
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length );
10d6a4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10d6a7: 56 push %esi <== NOT EXECUTED
10d6a8: e8 ff 17 00 00 call 10eeac <_Workspace_Allocate> <== NOT EXECUTED
10d6ad: 89 c3 mov %eax,%ebx <== NOT EXECUTED
if ( !d )
10d6af: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10d6b2: 85 c0 test %eax,%eax <== NOT EXECUTED
10d6b4: 74 4a je 10d700 <_Objects_Set_name+0xdc><== NOT EXECUTED
return FALSE;
if ( the_object->name.name_p ) {
10d6b6: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
10d6b9: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED
10d6bc: 85 c0 test %eax,%eax <== NOT EXECUTED
10d6be: 74 16 je 10d6d6 <_Objects_Set_name+0xb2><== NOT EXECUTED
_Workspace_Free( (void *)the_object->name.name_p );
10d6c0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10d6c3: 50 push %eax <== NOT EXECUTED
10d6c4: e8 cb 17 00 00 call 10ee94 <_Workspace_Free> <== NOT EXECUTED
the_object->name.name_p = NULL;
10d6c9: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10d6cc: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) <== NOT EXECUTED
10d6d3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
strncpy( d, name, length );
10d6d6: 50 push %eax <== NOT EXECUTED
10d6d7: 56 push %esi <== NOT EXECUTED
10d6d8: 57 push %edi <== NOT EXECUTED
10d6d9: 53 push %ebx <== NOT EXECUTED
10d6da: e8 55 5b 00 00 call 113234 <strncpy> <== NOT EXECUTED
d[ length ] = '\0';
10d6df: c6 04 33 00 movb $0x0,(%ebx,%esi,1) <== NOT EXECUTED
the_object->name.name_p = d;
10d6e3: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
10d6e6: 89 5a 0c mov %ebx,0xc(%edx) <== NOT EXECUTED
10d6e9: b0 01 mov $0x1,%al <== NOT EXECUTED
10d6eb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
);
}
return TRUE;
}
10d6ee: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10d6f1: 5b pop %ebx <== NOT EXECUTED
10d6f2: 5e pop %esi <== NOT EXECUTED
10d6f3: 5f pop %edi <== NOT EXECUTED
10d6f4: c9 leave <== NOT EXECUTED
10d6f5: c3 ret <== NOT EXECUTED
10d6f6: 66 90 xchg %ax,%ax <== NOT EXECUTED
strncpy( d, name, length );
d[ length ] = '\0';
the_object->name.name_p = d;
} else {
the_object->name.name_u32 = _Objects_Build_name(
10d6f8: 0d 20 20 00 00 or $0x2020,%eax
10d6fd: eb 92 jmp 10d691 <_Objects_Set_name+0x6d>
10d6ff: 90 nop
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length );
if ( !d )
10d700: 31 c0 xor %eax,%eax
10d702: eb 95 jmp 10d699 <_Objects_Set_name+0x75><== NOT EXECUTED
strncpy( d, name, length );
d[ length ] = '\0';
the_object->name.name_p = d;
} else {
the_object->name.name_u32 = _Objects_Build_name(
10d704: 89 d0 mov %edx,%eax
10d706: 83 c8 20 or $0x20,%eax
10d709: eb 86 jmp 10d691 <_Objects_Set_name+0x6d>
10d70b: 89 d0 mov %edx,%eax
10d70d: 0d 20 20 20 00 or $0x202020,%eax
10d712: e9 7a ff ff ff jmp 10d691 <_Objects_Set_name+0x6d>
0010bc8c <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
10bc8c: 55 push %ebp
10bc8d: 89 e5 mov %esp,%ebp
10bc8f: 57 push %edi
10bc90: 56 push %esi
10bc91: 53 push %ebx
10bc92: 83 ec 0c sub $0xc,%esp
* 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
10bc95: 8b 55 08 mov 0x8(%ebp),%edx
10bc98: 8b 42 08 mov 0x8(%edx),%eax
10bc9b: 0f b7 f0 movzwl %ax,%esi
/*
* 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;
10bc9e: 8b 4a 14 mov 0x14(%edx),%ecx
10bca1: 0f b7 42 10 movzwl 0x10(%edx),%eax
10bca5: 29 f0 sub %esi,%eax
10bca7: 31 d2 xor %edx,%edx
10bca9: f7 f1 div %ecx
for ( block = 0; block < block_count; block++ ) {
10bcab: 85 c0 test %eax,%eax
10bcad: 74 24 je 10bcd3 <_Objects_Shrink_information+0x47><== NEVER TAKEN
if ( information->inactive_per_block[ block ] == information->allocation_size ) {
10bcaf: 8b 55 08 mov 0x8(%ebp),%edx
10bcb2: 8b 5a 30 mov 0x30(%edx),%ebx
10bcb5: 3b 0b cmp (%ebx),%ecx
10bcb7: 74 22 je 10bcdb <_Objects_Shrink_information+0x4f><== NEVER TAKEN
information->object_blocks[ block ] = NULL;
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
return;
10bcb9: 31 d2 xor %edx,%edx
10bcbb: eb 11 jmp 10bcce <_Objects_Shrink_information+0x42>
10bcbd: 8d 76 00 lea 0x0(%esi),%esi
}
index_base += information->allocation_size;
10bcc0: 01 ce add %ecx,%esi
10bcc2: 8d 3c 95 00 00 00 00 lea 0x0(,%edx,4),%edi
index_base = _Objects_Get_index( information->minimum_id );
block_count = ( information->maximum - index_base ) / information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] == information->allocation_size ) {
10bcc9: 3b 0c 93 cmp (%ebx,%edx,4),%ecx
10bccc: 74 12 je 10bce0 <_Objects_Shrink_information+0x54>
*/
index_base = _Objects_Get_index( information->minimum_id );
block_count = ( information->maximum - index_base ) / information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
10bcce: 42 inc %edx
10bccf: 39 d0 cmp %edx,%eax
10bcd1: 77 ed ja 10bcc0 <_Objects_Shrink_information+0x34>
return;
}
index_base += information->allocation_size;
}
}
10bcd3: 8d 65 f4 lea -0xc(%ebp),%esp
10bcd6: 5b pop %ebx
10bcd7: 5e pop %esi
10bcd8: 5f pop %edi
10bcd9: c9 leave
10bcda: c3 ret
index_base = _Objects_Get_index( information->minimum_id );
block_count = ( information->maximum - index_base ) / information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] == information->allocation_size ) {
10bcdb: 31 ff xor %edi,%edi <== NOT EXECUTED
10bcdd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
/*
* 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;
10bce0: 8b 5d 08 mov 0x8(%ebp),%ebx
10bce3: 8b 4b 20 mov 0x20(%ebx),%ecx
10bce6: eb 26 jmp 10bd0e <_Objects_Shrink_information+0x82>
*/
do {
index = _Objects_Get_index( the_object->id );
if ((index >= index_base) &&
10bce8: 89 f0 mov %esi,%eax
10bcea: 8b 5d 08 mov 0x8(%ebp),%ebx
10bced: 03 43 14 add 0x14(%ebx),%eax
10bcf0: 39 d0 cmp %edx,%eax
10bcf2: 76 24 jbe 10bd18 <_Objects_Shrink_information+0x8c>
* @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,
10bcf4: 8b 19 mov (%ecx),%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 );
10bcf6: 83 ec 0c sub $0xc,%esp
10bcf9: 51 push %ecx
10bcfa: e8 45 33 00 00 call 10f044 <_Chain_Extract>
10bcff: 83 c4 10 add $0x10,%esp
}
else {
the_object = (Objects_Control *) the_object->Node.next;
}
}
while ( the_object && !_Chain_Is_last( &the_object->Node ) );
10bd02: 85 db test %ebx,%ebx
10bd04: 74 1a je 10bd20 <_Objects_Shrink_information+0x94><== NEVER TAKEN
10bd06: 8b 03 mov (%ebx),%eax
10bd08: 85 c0 test %eax,%eax
10bd0a: 74 14 je 10bd20 <_Objects_Shrink_information+0x94>
10bd0c: 89 d9 mov %ebx,%ecx
* 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
10bd0e: 8b 41 08 mov 0x8(%ecx),%eax
10bd11: 0f b7 d0 movzwl %ax,%edx
*/
do {
index = _Objects_Get_index( the_object->id );
if ((index >= index_base) &&
10bd14: 39 f2 cmp %esi,%edx
10bd16: 73 d0 jae 10bce8 <_Objects_Shrink_information+0x5c>
the_object = NULL;
_Chain_Extract( &extract_me->Node );
}
else {
the_object = (Objects_Control *) the_object->Node.next;
10bd18: 8b 19 mov (%ecx),%ebx
}
}
while ( the_object && !_Chain_Is_last( &the_object->Node ) );
10bd1a: 85 db test %ebx,%ebx
10bd1c: 75 e8 jne 10bd06 <_Objects_Shrink_information+0x7a><== ALWAYS TAKEN
10bd1e: 66 90 xchg %ax,%ax
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
10bd20: 83 ec 0c sub $0xc,%esp
10bd23: 8b 55 08 mov 0x8(%ebp),%edx
10bd26: 8b 42 34 mov 0x34(%edx),%eax
10bd29: ff 34 38 pushl (%eax,%edi,1)
10bd2c: e8 d7 16 00 00 call 10d408 <_Workspace_Free>
information->object_blocks[ block ] = NULL;
10bd31: 8b 5d 08 mov 0x8(%ebp),%ebx
10bd34: 8b 43 34 mov 0x34(%ebx),%eax
10bd37: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1)
information->inactive_per_block[ block ] = 0;
10bd3e: 8b 43 30 mov 0x30(%ebx),%eax
10bd41: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1)
information->inactive -= information->allocation_size;
10bd48: 8b 43 14 mov 0x14(%ebx),%eax
10bd4b: 66 29 43 2c sub %ax,0x2c(%ebx)
10bd4f: 83 c4 10 add $0x10,%esp
return;
}
index_base += information->allocation_size;
}
}
10bd52: 8d 65 f4 lea -0xc(%ebp),%esp
10bd55: 5b pop %ebx
10bd56: 5e pop %esi
10bd57: 5f pop %edi
10bd58: c9 leave
10bd59: c3 ret
0010dd40 <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
10dd40: 55 push %ebp
10dd41: 89 e5 mov %esp,%ebp
10dd43: 56 push %esi
10dd44: 53 push %ebx
10dd45: 8b 75 08 mov 0x8(%ebp),%esi
10dd48: 8b 5d 0c mov 0xc(%ebp),%ebx
Heap_Get_information_status status;
if ( !the_heap )
10dd4b: 85 f6 test %esi,%esi
10dd4d: 74 39 je 10dd88 <_Protected_heap_Get_information+0x48><== NEVER TAKEN
return false;
if ( !the_info )
10dd4f: 85 db test %ebx,%ebx
10dd51: 74 35 je 10dd88 <_Protected_heap_Get_information+0x48><== NEVER TAKEN
return false;
_RTEMS_Lock_allocator();
10dd53: 83 ec 0c sub $0xc,%esp
10dd56: ff 35 b4 3d 12 00 pushl 0x123db4
10dd5c: e8 63 e8 ff ff call 10c5c4 <_API_Mutex_Lock>
status = _Heap_Get_information( the_heap, the_info );
10dd61: 5a pop %edx
10dd62: 59 pop %ecx
10dd63: 53 push %ebx
10dd64: 56 push %esi
10dd65: e8 e2 37 00 00 call 11154c <_Heap_Get_information>
10dd6a: 89 c3 mov %eax,%ebx
_RTEMS_Unlock_allocator();
10dd6c: 58 pop %eax
10dd6d: ff 35 b4 3d 12 00 pushl 0x123db4
10dd73: e8 94 e8 ff ff call 10c60c <_API_Mutex_Unlock>
if ( status == HEAP_GET_INFORMATION_SUCCESSFUL )
10dd78: 83 c4 10 add $0x10,%esp
10dd7b: 85 db test %ebx,%ebx
10dd7d: 0f 94 c0 sete %al
return true;
return false;
}
10dd80: 8d 65 f8 lea -0x8(%ebp),%esp
10dd83: 5b pop %ebx
10dd84: 5e pop %esi
10dd85: c9 leave
10dd86: c3 ret
10dd87: 90 nop
_RTEMS_Lock_allocator();
status = _Heap_Get_information( the_heap, the_info );
_RTEMS_Unlock_allocator();
if ( status == HEAP_GET_INFORMATION_SUCCESSFUL )
10dd88: 31 c0 xor %eax,%eax
return true;
return false;
}
10dd8a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10dd8d: 5b pop %ebx <== NOT EXECUTED
10dd8e: 5e pop %esi <== NOT EXECUTED
10dd8f: c9 leave <== NOT EXECUTED
10dd90: c3 ret <== NOT EXECUTED
0010eee4 <_RTEMS_tasks_Create_extension>:
bool _RTEMS_tasks_Create_extension(
Thread_Control *executing,
Thread_Control *created
)
{
10eee4: 55 push %ebp
10eee5: 89 e5 mov %esp,%ebp
10eee7: 53 push %ebx
10eee8: 83 ec 10 sub $0x10,%esp
10eeeb: 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() )
10eeee: a1 f4 e6 11 00 mov 0x11e6f4,%eax
10eef3: 8b 40 40 mov 0x40(%eax),%eax
10eef6: 80 78 04 01 cmpb $0x1,0x4(%eax)
10eefa: 19 c0 sbb %eax,%eax
10eefc: 83 e0 c0 and $0xffffffc0,%eax
10eeff: 83 c0 60 add $0x60,%eax
to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));
api = _Workspace_Allocate( to_allocate );
10ef02: 50 push %eax
10ef03: e8 18 e5 ff ff call 10d420 <_Workspace_Allocate>
10ef08: 89 c2 mov %eax,%edx
if ( !api )
10ef0a: 83 c4 10 add $0x10,%esp
10ef0d: 85 c0 test %eax,%eax
10ef0f: 74 67 je 10ef78 <_RTEMS_tasks_Create_extension+0x94><== NEVER TAKEN
return false;
created->API_Extensions[ THREAD_API_RTEMS ] = api;
10ef11: 89 83 f4 00 00 00 mov %eax,0xf4(%ebx)
api->pending_events = EVENT_SETS_NONE_PENDING;
10ef17: c7 00 00 00 00 00 movl $0x0,(%eax)
#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
10ef1d: c6 40 08 01 movb $0x1,0x8(%eax)
* @a page_size byte units. If @a page_size is 0 or is not multiple of
10ef21: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
10ef28: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
*
10ef2f: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax)
* @param[in] the_heap is the heap to operate upon
10ef36: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
* @param[in] starting_address is the starting address of the memory for
10ef3d: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
_ASR_Initialize( &api->Signal );
created->task_variables = NULL;
10ef44: c7 83 04 01 00 00 00 movl $0x0,0x104(%ebx)
10ef4b: 00 00 00
if ( rtems_configuration_get_notepads_enabled() ) {
10ef4e: a1 f4 e6 11 00 mov 0x11e6f4,%eax
10ef53: 8b 40 40 mov 0x40(%eax),%eax
10ef56: 80 78 04 00 cmpb $0x0,0x4(%eax)
10ef5a: 74 12 je 10ef6e <_RTEMS_tasks_Create_extension+0x8a>
10ef5c: 31 c0 xor %eax,%eax
10ef5e: 66 90 xchg %ax,%ax
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
api->Notepads[i] = 0;
10ef60: c7 44 82 20 00 00 00 movl $0x0,0x20(%edx,%eax,4)
10ef67: 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++)
10ef68: 40 inc %eax
10ef69: 83 f8 10 cmp $0x10,%eax
10ef6c: 75 f2 jne 10ef60 <_RTEMS_tasks_Create_extension+0x7c>
10ef6e: b0 01 mov $0x1,%al
api->Notepads[i] = 0;
}
return true;
}
10ef70: 8b 5d fc mov -0x4(%ebp),%ebx
10ef73: c9 leave
10ef74: c3 ret
10ef75: 8d 76 00 lea 0x0(%esi),%esi
if ( !rtems_configuration_get_notepads_enabled() )
to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));
api = _Workspace_Allocate( to_allocate );
if ( !api )
10ef78: 31 c0 xor %eax,%eax
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
api->Notepads[i] = 0;
}
return true;
}
10ef7a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10ef7d: c9 leave <== NOT EXECUTED
10ef7e: c3 ret <== NOT EXECUTED
0010a7b0 <_RTEMS_tasks_Initialize_user_tasks_body>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
10a7b0: 55 push %ebp
10a7b1: 89 e5 mov %esp,%ebp
10a7b3: 57 push %edi
10a7b4: 56 push %esi
10a7b5: 53 push %ebx
10a7b6: 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;
10a7b9: a1 f4 e6 11 00 mov 0x11e6f4,%eax
10a7be: 8b 40 40 mov 0x40(%eax),%eax
/*
* NOTE: This is slightly different from the Ada implementation.
*/
user_tasks = api_configuration->User_initialization_tasks_table;
10a7c1: 8b 50 2c mov 0x2c(%eax),%edx
maximum = api_configuration->number_of_initialization_tasks;
10a7c4: 8b 78 28 mov 0x28(%eax),%edi
if ( !user_tasks || maximum == 0 )
10a7c7: 85 d2 test %edx,%edx
10a7c9: 74 48 je 10a813 <_RTEMS_tasks_Initialize_user_tasks_body+0x63><== NEVER TAKEN
10a7cb: 85 ff test %edi,%edi
10a7cd: 74 44 je 10a813 <_RTEMS_tasks_Initialize_user_tasks_body+0x63><== NEVER TAKEN
10a7cf: 89 d3 mov %edx,%ebx
10a7d1: 31 f6 xor %esi,%esi
10a7d3: 90 nop
return;
for ( index=0 ; index < maximum ; index++ ) {
return_value = rtems_task_create(
10a7d4: 83 ec 08 sub $0x8,%esp
10a7d7: 8d 45 f0 lea -0x10(%ebp),%eax
10a7da: 50 push %eax
10a7db: ff 73 0c pushl 0xc(%ebx)
10a7de: ff 73 14 pushl 0x14(%ebx)
10a7e1: ff 73 04 pushl 0x4(%ebx)
10a7e4: ff 73 08 pushl 0x8(%ebx)
10a7e7: ff 33 pushl (%ebx)
10a7e9: e8 9a fd ff ff call 10a588 <rtems_task_create>
user_tasks[ index ].mode_set,
user_tasks[ index ].attribute_set,
&id
);
if ( !rtems_is_status_successful( return_value ) )
10a7ee: 83 c4 20 add $0x20,%esp
10a7f1: 85 c0 test %eax,%eax
10a7f3: 75 27 jne 10a81c <_RTEMS_tasks_Initialize_user_tasks_body+0x6c>
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
return_value = rtems_task_start(
10a7f5: 51 push %ecx
10a7f6: ff 73 18 pushl 0x18(%ebx)
10a7f9: ff 73 10 pushl 0x10(%ebx)
10a7fc: ff 75 f0 pushl -0x10(%ebp)
10a7ff: e8 24 00 00 00 call 10a828 <rtems_task_start>
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
10a804: 83 c4 10 add $0x10,%esp
10a807: 85 c0 test %eax,%eax
10a809: 75 11 jne 10a81c <_RTEMS_tasks_Initialize_user_tasks_body+0x6c>
maximum = api_configuration->number_of_initialization_tasks;
if ( !user_tasks || maximum == 0 )
return;
for ( index=0 ; index < maximum ; index++ ) {
10a80b: 46 inc %esi
10a80c: 83 c3 1c add $0x1c,%ebx
10a80f: 39 f7 cmp %esi,%edi
10a811: 77 c1 ja 10a7d4 <_RTEMS_tasks_Initialize_user_tasks_body+0x24><== NEVER TAKEN
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
}
}
10a813: 8d 65 f4 lea -0xc(%ebp),%esp
10a816: 5b pop %ebx
10a817: 5e pop %esi
10a818: 5f pop %edi
10a819: c9 leave
10a81a: c3 ret
10a81b: 90 nop
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
10a81c: 52 push %edx
10a81d: 50 push %eax
10a81e: 6a 01 push $0x1
10a820: 6a 01 push $0x1
10a822: e8 f9 0c 00 00 call 10b520 <_Internal_error_Occurred>
0010ee2c <_RTEMS_tasks_Post_switch_extension>:
*/
void _RTEMS_tasks_Post_switch_extension(
Thread_Control *executing
)
{
10ee2c: 55 push %ebp
10ee2d: 89 e5 mov %esp,%ebp
10ee2f: 57 push %edi
10ee30: 56 push %esi
10ee31: 53 push %ebx
10ee32: 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 ];
10ee35: 8b 45 08 mov 0x8(%ebp),%eax
10ee38: 8b b0 f4 00 00 00 mov 0xf4(%eax),%esi
if ( !api )
10ee3e: 85 f6 test %esi,%esi
10ee40: 74 45 je 10ee87 <_RTEMS_tasks_Post_switch_extension+0x5b><== NEVER TAKEN
* Signal Processing
*/
asr = &api->Signal;
_ISR_Disable( level );
10ee42: 9c pushf
10ee43: fa cli
10ee44: 58 pop %eax
signal_set = asr->signals_posted;
10ee45: 8b 7e 14 mov 0x14(%esi),%edi
asr->signals_posted = 0;
10ee48: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi)
_ISR_Enable( level );
10ee4f: 50 push %eax
10ee50: 9d popf
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
10ee51: 85 ff test %edi,%edi
10ee53: 74 32 je 10ee87 <_RTEMS_tasks_Post_switch_extension+0x5b><== NEVER TAKEN
return;
asr->nest_level += 1;
10ee55: ff 46 1c incl 0x1c(%esi)
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
10ee58: 50 push %eax
10ee59: 8d 5d f0 lea -0x10(%ebp),%ebx
10ee5c: 53 push %ebx
10ee5d: 68 ff ff 00 00 push $0xffff
10ee62: ff 76 10 pushl 0x10(%esi)
10ee65: e8 e6 0e 00 00 call 10fd50 <rtems_task_mode>
(*asr->handler)( signal_set );
10ee6a: 89 3c 24 mov %edi,(%esp)
10ee6d: ff 56 0c call *0xc(%esi)
asr->nest_level -= 1;
10ee70: ff 4e 1c decl 0x1c(%esi)
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
10ee73: 83 c4 0c add $0xc,%esp
10ee76: 53 push %ebx
10ee77: 68 ff ff 00 00 push $0xffff
10ee7c: ff 75 f0 pushl -0x10(%ebp)
10ee7f: e8 cc 0e 00 00 call 10fd50 <rtems_task_mode>
10ee84: 83 c4 10 add $0x10,%esp
}
10ee87: 8d 65 f4 lea -0xc(%ebp),%esp
10ee8a: 5b pop %ebx
10ee8b: 5e pop %esi
10ee8c: 5f pop %edi
10ee8d: c9 leave
10ee8e: c3 ret
0010ed90 <_RTEMS_tasks_Switch_extension>:
void _RTEMS_tasks_Switch_extension(
Thread_Control *executing,
Thread_Control *heir
)
{
10ed90: 55 push %ebp
10ed91: 89 e5 mov %esp,%ebp
/*
* Per Task Variables
*/
tvp = executing->task_variables;
10ed93: 8b 45 08 mov 0x8(%ebp),%eax
10ed96: 8b 88 04 01 00 00 mov 0x104(%eax),%ecx
while (tvp) {
10ed9c: 85 c9 test %ecx,%ecx
10ed9e: 74 13 je 10edb3 <_RTEMS_tasks_Switch_extension+0x23>
tvp->tval = *tvp->ptr;
10eda0: 8b 41 04 mov 0x4(%ecx),%eax
10eda3: 8b 10 mov (%eax),%edx
10eda5: 89 51 0c mov %edx,0xc(%ecx)
*tvp->ptr = tvp->gval;
10eda8: 8b 51 08 mov 0x8(%ecx),%edx
10edab: 89 10 mov %edx,(%eax)
tvp = (rtems_task_variable_t *)tvp->next;
10edad: 8b 09 mov (%ecx),%ecx
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
10edaf: 85 c9 test %ecx,%ecx
10edb1: 75 ed jne 10eda0 <_RTEMS_tasks_Switch_extension+0x10><== NEVER TAKEN
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
10edb3: 8b 45 0c mov 0xc(%ebp),%eax
10edb6: 8b 88 04 01 00 00 mov 0x104(%eax),%ecx
while (tvp) {
10edbc: 85 c9 test %ecx,%ecx
10edbe: 74 13 je 10edd3 <_RTEMS_tasks_Switch_extension+0x43>
tvp->gval = *tvp->ptr;
10edc0: 8b 41 04 mov 0x4(%ecx),%eax
10edc3: 8b 10 mov (%eax),%edx
10edc5: 89 51 08 mov %edx,0x8(%ecx)
*tvp->ptr = tvp->tval;
10edc8: 8b 51 0c mov 0xc(%ecx),%edx
10edcb: 89 10 mov %edx,(%eax)
tvp = (rtems_task_variable_t *)tvp->next;
10edcd: 8b 09 mov (%ecx),%ecx
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
10edcf: 85 c9 test %ecx,%ecx
10edd1: 75 ed jne 10edc0 <_RTEMS_tasks_Switch_extension+0x30><== NEVER TAKEN
tvp->gval = *tvp->ptr;
*tvp->ptr = tvp->tval;
tvp = (rtems_task_variable_t *)tvp->next;
}
}
10edd3: c9 leave
10edd4: c3 ret
0010b0f0 <_Rate_monotonic_Initiate_statistics>:
#endif
void _Rate_monotonic_Initiate_statistics(
Rate_monotonic_Control *the_period
)
{
10b0f0: 55 push %ebp
10b0f1: 89 e5 mov %esp,%ebp
10b0f3: 57 push %edi
10b0f4: 56 push %esi
10b0f5: 53 push %ebx
10b0f6: 83 ec 28 sub $0x28,%esp
10b0f9: 8b 75 08 mov 0x8(%ebp),%esi
Thread_Control *owning_thread = the_period->owner;
10b0fc: 8b 5e 50 mov 0x50(%esi),%ebx
#if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \
defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS)
struct timespec uptime;
_TOD_Get_uptime( &uptime );
10b0ff: 8d 7d ec lea -0x14(%ebp),%edi
10b102: 57 push %edi
10b103: e8 6c 19 00 00 call 10ca74 <_TOD_Get_uptime>
/*
* Set the starting point and the CPU time used for the statistics.
*/
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
the_period->time_at_period = uptime;
10b108: 8b 45 ec mov -0x14(%ebp),%eax
10b10b: 8b 55 f0 mov -0x10(%ebp),%edx
10b10e: 89 46 44 mov %eax,0x44(%esi)
10b111: 89 56 48 mov %edx,0x48(%esi)
#else
the_period->time_at_period = _Watchdog_Ticks_since_boot;
#endif
the_period->owner_executed_at_period = owning_thread->cpu_time_used;
10b114: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx
10b11a: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax
10b120: 89 46 40 mov %eax,0x40(%esi)
10b123: 89 56 3c mov %edx,0x3c(%esi)
* context switch. When this routine is invoked from
* rtems_rate_monotonic_period, the owner will be the executing thread.
* When this routine is invoked from _Rate_monotonic_Timeout, it will not.
*/
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
if (owning_thread == _Thread_Executing) {
10b126: 83 c4 10 add $0x10,%esp
10b129: 3b 1d 3c 28 12 00 cmp 0x12283c,%ebx
10b12f: 74 0b je 10b13c <_Rate_monotonic_Initiate_statistics+0x4c>
);
_Timespec_Add_to( &the_period->owner_executed_at_period, &ran );
}
#endif
}
10b131: 8d 65 f4 lea -0xc(%ebp),%esp
10b134: 5b pop %ebx
10b135: 5e pop %esi
10b136: 5f pop %edi
10b137: c9 leave
10b138: c3 ret
10b139: 8d 76 00 lea 0x0(%esi),%esi
/*
* Adjust the CPU time used to account for the time since last
* context switch.
*/
_Timespec_Subtract(
10b13c: 51 push %ecx
10b13d: 8d 5d e4 lea -0x1c(%ebp),%ebx
10b140: 53 push %ebx
10b141: 57 push %edi
10b142: 68 44 28 12 00 push $0x122844
10b147: e8 04 39 00 00 call 10ea50 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch, &uptime, &ran
);
_Timespec_Add_to( &the_period->owner_executed_at_period, &ran );
10b14c: 58 pop %eax
10b14d: 5a pop %edx
10b14e: 53 push %ebx
10b14f: 8d 46 3c lea 0x3c(%esi),%eax
10b152: 50 push %eax
10b153: e8 04 38 00 00 call 10e95c <_Timespec_Add_to>
10b158: 83 c4 10 add $0x10,%esp
10b15b: eb d4 jmp 10b131 <_Rate_monotonic_Initiate_statistics+0x41>
0010b724 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
10b724: 55 push %ebp
10b725: 89 e5 mov %esp,%ebp
10b727: 53 push %ebx
10b728: 83 ec 18 sub $0x18,%esp
10b72b: 8d 45 f8 lea -0x8(%ebp),%eax
10b72e: 50 push %eax
10b72f: ff 75 08 pushl 0x8(%ebp)
10b732: 68 80 26 12 00 push $0x122680
10b737: e8 a4 1c 00 00 call 10d3e0 <_Objects_Get>
10b73c: 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 ) {
10b73e: 83 c4 10 add $0x10,%esp
10b741: 8b 45 f8 mov -0x8(%ebp),%eax
10b744: 85 c0 test %eax,%eax
10b746: 75 21 jne 10b769 <_Rate_monotonic_Timeout+0x45><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
10b748: 8b 53 50 mov 0x50(%ebx),%edx
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
10b74b: f6 42 11 40 testb $0x40,0x11(%edx)
10b74f: 75 1f jne 10b770 <_Rate_monotonic_Timeout+0x4c>
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
10b751: 83 7b 38 01 cmpl $0x1,0x38(%ebx)
10b755: 74 35 je 10b78c <_Rate_monotonic_Timeout+0x68><== NEVER TAKEN
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
10b757: c7 43 38 04 00 00 00 movl $0x4,0x38(%ebx)
10b75e: a1 78 27 12 00 mov 0x122778,%eax
10b763: 48 dec %eax
10b764: a3 78 27 12 00 mov %eax,0x122778
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10b769: 8b 5d fc mov -0x4(%ebp),%ebx
10b76c: c9 leave
10b76d: c3 ret
10b76e: 66 90 xchg %ax,%ax
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_thread = the_period->owner;
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
10b770: 8b 42 20 mov 0x20(%edx),%eax
10b773: 3b 43 08 cmp 0x8(%ebx),%eax
10b776: 75 d9 jne 10b751 <_Rate_monotonic_Timeout+0x2d><== NEVER TAKEN
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
10b778: 83 ec 08 sub $0x8,%esp
10b77b: 68 f8 ff 03 10 push $0x1003fff8
10b780: 52 push %edx
10b781: e8 f6 20 00 00 call 10d87c <_Thread_Clear_state>
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
10b786: 59 pop %ecx
10b787: eb 0d jmp 10b796 <_Rate_monotonic_Timeout+0x72>
10b789: 8d 76 00 lea 0x0(%esi),%esi
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
10b78c: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
10b793: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b796: 53 push %ebx
10b797: e8 54 f9 ff ff call 10b0f0 <_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,
10b79c: 8b 43 4c mov 0x4c(%ebx),%eax
10b79f: 89 43 1c mov %eax,0x1c(%ebx)
void *starting_address,
size_t *size
10b7a2: 58 pop %eax
10b7a3: 5a pop %edx
10b7a4: 8d 43 10 lea 0x10(%ebx),%eax
10b7a7: 50 push %eax
10b7a8: 68 5c 28 12 00 push $0x12285c
10b7ad: e8 46 35 00 00 call 10ecf8 <_Watchdog_Insert>
10b7b2: 83 c4 10 add $0x10,%esp
10b7b5: eb a7 jmp 10b75e <_Rate_monotonic_Timeout+0x3a>
0010b2cc <_TOD_Tickle_ticks>:
*
* Output parameters: NONE
*/
void _TOD_Tickle_ticks( void )
{
10b2cc: 55 push %ebp
10b2cd: 89 e5 mov %esp,%ebp
10b2cf: 53 push %ebx
10b2d0: 83 ec 1c sub $0x1c,%esp
struct timespec tick;
uint32_t seconds;
/* Convert the tick quantum to a timespec */
tick.tv_nsec = _TOD_Microseconds_per_tick * 1000;
10b2d3: a1 20 e8 11 00 mov 0x11e820,%eax
10b2d8: 8d 04 80 lea (%eax,%eax,4),%eax
10b2db: 8d 04 80 lea (%eax,%eax,4),%eax
10b2de: 8d 04 80 lea (%eax,%eax,4),%eax
10b2e1: c1 e0 03 shl $0x3,%eax
10b2e4: 89 45 f8 mov %eax,-0x8(%ebp)
tick.tv_sec = 0;
10b2e7: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
10b2ee: a1 c4 e7 11 00 mov 0x11e7c4,%eax
10b2f3: 40 inc %eax
10b2f4: a3 c4 e7 11 00 mov %eax,0x11e7c4
/* Update the timespec format uptime */
(void) _Timespec_Add_to( &_TOD_Uptime, &tick );
10b2f9: 8d 5d f4 lea -0xc(%ebp),%ebx
10b2fc: 53 push %ebx
10b2fd: 68 d8 e6 11 00 push $0x11e6d8
10b302: e8 15 1c 00 00 call 10cf1c <_Timespec_Add_to>
/* we do not care how much the uptime changed */
/* Update the timespec format TOD */
seconds = _Timespec_Add_to( &_TOD_Now, &tick );
10b307: 58 pop %eax
10b308: 5a pop %edx
10b309: 53 push %ebx
10b30a: 68 ec e6 11 00 push $0x11e6ec
10b30f: e8 08 1c 00 00 call 10cf1c <_Timespec_Add_to>
10b314: 89 c3 mov %eax,%ebx
while ( seconds ) {
10b316: 83 c4 10 add $0x10,%esp
10b319: 85 c0 test %eax,%eax
10b31b: 74 16 je 10b333 <_TOD_Tickle_ticks+0x67>
10b31d: 8d 76 00 lea 0x0(%esi),%esi
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
);
10b320: 83 ec 0c sub $0xc,%esp
10b323: 68 30 e7 11 00 push $0x11e730
10b328: e8 6b 20 00 00 call 10d398 <_Watchdog_Tickle>
10b32d: 83 c4 10 add $0x10,%esp
10b330: 4b dec %ebx
10b331: 75 ed jne 10b320 <_TOD_Tickle_ticks+0x54><== NEVER TAKEN
_Watchdog_Tickle_seconds();
seconds--;
}
}
10b333: 8b 5d fc mov -0x4(%ebp),%ebx
10b336: c9 leave
10b337: c3 ret
0010ac64 <_TOD_To_seconds>:
*/
uint32_t _TOD_To_seconds(
rtems_time_of_day *the_tod
)
{
10ac64: 55 push %ebp
10ac65: 89 e5 mov %esp,%ebp
10ac67: 57 push %edi
10ac68: 56 push %esi
10ac69: 53 push %ebx
10ac6a: 8b 5d 08 mov 0x8(%ebp),%ebx
uint32_t time;
uint32_t year_mod_4;
time = the_tod->day - 1;
10ac6d: 8b 43 08 mov 0x8(%ebx),%eax
10ac70: 8d 48 ff lea -0x1(%eax),%ecx
year_mod_4 = the_tod->year & 3;
10ac73: 8b 13 mov (%ebx),%edx
if ( year_mod_4 == 0 )
10ac75: 89 d6 mov %edx,%esi
10ac77: 83 e6 03 and $0x3,%esi
10ac7a: 74 68 je 10ace4 <_TOD_To_seconds+0x80>
time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
else
time += _TOD_Days_to_date[ 0 ][ the_tod->month ];
10ac7c: 8b 43 04 mov 0x4(%ebx),%eax
10ac7f: 0f b7 84 00 00 b8 11 movzwl 0x11b800(%eax,%eax,1),%eax
10ac86: 00
10ac87: 8d 3c 08 lea (%eax,%ecx,1),%edi
time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
10ac8a: 0f b7 8c 36 34 b8 11 movzwl 0x11b834(%esi,%esi,1),%ecx
10ac91: 00
10ac92: 81 ea c4 07 00 00 sub $0x7c4,%edx
10ac98: c1 ea 02 shr $0x2,%edx
10ac9b: 8d 04 d2 lea (%edx,%edx,8),%eax
10ac9e: 8d 04 c2 lea (%edx,%eax,8),%eax
10aca1: 8d 04 80 lea (%eax,%eax,4),%eax
10aca4: 8d 04 82 lea (%edx,%eax,4),%eax
10aca7: 01 c1 add %eax,%ecx
( (TOD_DAYS_PER_YEAR * 4) + 1);
time += _TOD_Days_since_last_leap_year[ year_mod_4 ];
10aca9: 01 f9 add %edi,%ecx
time *= TOD_SECONDS_PER_DAY;
10acab: 8d 14 89 lea (%ecx,%ecx,4),%edx
10acae: 8d 14 91 lea (%ecx,%edx,4),%edx
10acb1: 8d 14 d1 lea (%ecx,%edx,8),%edx
10acb4: c1 e2 02 shl $0x2,%edx
10acb7: 29 ca sub %ecx,%edx
10acb9: c1 e2 07 shl $0x7,%edx
time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
10acbc: 8b 4b 14 mov 0x14(%ebx),%ecx
* TOD_SECONDS_PER_MINUTE;
time += the_tod->second;
10acbf: 8b 43 0c mov 0xc(%ebx),%eax
10acc2: 8d 04 40 lea (%eax,%eax,2),%eax
10acc5: 8d 04 80 lea (%eax,%eax,4),%eax
10acc8: c1 e0 02 shl $0x2,%eax
10accb: 03 43 10 add 0x10(%ebx),%eax
10acce: 8d 04 40 lea (%eax,%eax,2),%eax
10acd1: 8d 04 80 lea (%eax,%eax,4),%eax
10acd4: 8d 84 81 00 e5 da 21 lea 0x21dae500(%ecx,%eax,4),%eax
10acdb: 01 d0 add %edx,%eax
time += TOD_SECONDS_1970_THROUGH_1988;
return( time );
}
10acdd: 5b pop %ebx
10acde: 5e pop %esi
10acdf: 5f pop %edi
10ace0: c9 leave
10ace1: c3 ret
10ace2: 66 90 xchg %ax,%ax
time = the_tod->day - 1;
year_mod_4 = the_tod->year & 3;
if ( year_mod_4 == 0 )
time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
10ace4: 8b 43 04 mov 0x4(%ebx),%eax
10ace7: 0f b7 84 00 1a b8 11 movzwl 0x11b81a(%eax,%eax,1),%eax
10acee: 00
10acef: 8d 3c 08 lea (%eax,%ecx,1),%edi
10acf2: eb 96 jmp 10ac8a <_TOD_To_seconds+0x26>
0010acf4 <_TOD_Validate>:
*/
bool _TOD_Validate(
rtems_time_of_day *the_tod
)
{
10acf4: 55 push %ebp
10acf5: 89 e5 mov %esp,%ebp
10acf7: 53 push %ebx
10acf8: 83 ec 04 sub $0x4,%esp
10acfb: 8b 5d 08 mov 0x8(%ebp),%ebx
uint32_t days_in_month;
if ((!the_tod) ||
10acfe: 85 db test %ebx,%ebx
10ad00: 74 56 je 10ad58 <_TOD_Validate+0x64> <== NEVER TAKEN
10ad02: b8 40 42 0f 00 mov $0xf4240,%eax
10ad07: 31 d2 xor %edx,%edx
10ad09: f7 35 40 a8 12 00 divl 0x12a840
10ad0f: 39 43 18 cmp %eax,0x18(%ebx)
10ad12: 73 44 jae 10ad58 <_TOD_Validate+0x64>
10ad14: 83 7b 14 3b cmpl $0x3b,0x14(%ebx)
10ad18: 77 3e ja 10ad58 <_TOD_Validate+0x64>
10ad1a: 83 7b 10 3b cmpl $0x3b,0x10(%ebx)
10ad1e: 77 38 ja 10ad58 <_TOD_Validate+0x64>
10ad20: 83 7b 0c 17 cmpl $0x17,0xc(%ebx)
10ad24: 77 32 ja 10ad58 <_TOD_Validate+0x64>
10ad26: 8b 43 04 mov 0x4(%ebx),%eax
10ad29: 85 c0 test %eax,%eax
10ad2b: 74 2b je 10ad58 <_TOD_Validate+0x64> <== NEVER TAKEN
10ad2d: 83 f8 0c cmp $0xc,%eax
10ad30: 77 26 ja 10ad58 <_TOD_Validate+0x64>
10ad32: 8b 0b mov (%ebx),%ecx
10ad34: 81 f9 c3 07 00 00 cmp $0x7c3,%ecx
10ad3a: 76 1c jbe 10ad58 <_TOD_Validate+0x64>
10ad3c: 8b 53 08 mov 0x8(%ebx),%edx
10ad3f: 85 d2 test %edx,%edx
10ad41: 74 15 je 10ad58 <_TOD_Validate+0x64> <== 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 )
10ad43: 83 e1 03 and $0x3,%ecx
10ad46: 75 16 jne 10ad5e <_TOD_Validate+0x6a>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
10ad48: 8b 04 85 74 b8 11 00 mov 0x11b874(,%eax,4),%eax
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
10ad4f: 39 d0 cmp %edx,%eax
10ad51: 0f 93 c0 setae %al
10ad54: eb 04 jmp 10ad5a <_TOD_Validate+0x66>
10ad56: 66 90 xchg %ax,%ax
10ad58: 31 c0 xor %eax,%eax
if ( the_tod->day > days_in_month )
return false;
return true;
}
10ad5a: 5a pop %edx
10ad5b: 5b pop %ebx
10ad5c: c9 leave
10ad5d: c3 ret
return false;
if ( (the_tod->year % 4) == 0 )
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
10ad5e: 8b 04 85 40 b8 11 00 mov 0x11b840(,%eax,4),%eax
10ad65: eb e8 jmp 10ad4f <_TOD_Validate+0x5b>
0010be10 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
10be10: 55 push %ebp
10be11: 89 e5 mov %esp,%ebp
10be13: 57 push %edi
10be14: 56 push %esi
10be15: 53 push %ebx
10be16: 83 ec 18 sub $0x18,%esp
10be19: 8b 5d 08 mov 0x8(%ebp),%ebx
10be1c: 8b 75 0c mov 0xc(%ebp),%esi
10be1f: 8a 45 10 mov 0x10(%ebp),%al
10be22: 88 45 f3 mov %al,-0xd(%ebp)
*/
/*
* Save original state
*/
original_state = the_thread->current_state;
10be25: 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 );
10be28: 53 push %ebx
10be29: e8 4a 0e 00 00 call 10cc78 <_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 )
10be2e: 83 c4 10 add $0x10,%esp
10be31: 39 73 14 cmp %esi,0x14(%ebx)
10be34: 74 0d je 10be43 <_Thread_Change_priority+0x33>
_Thread_Set_priority( the_thread, new_priority );
10be36: 83 ec 08 sub $0x8,%esp
10be39: 56 push %esi
10be3a: 53 push %ebx
10be3b: e8 f4 0c 00 00 call 10cb34 <_Thread_Set_priority>
10be40: 83 c4 10 add $0x10,%esp
_ISR_Disable( level );
10be43: 9c pushf
10be44: fa cli
10be45: 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;
10be46: 8b 53 10 mov 0x10(%ebx),%edx
if ( state != STATES_TRANSIENT ) {
10be49: 83 fa 04 cmp $0x4,%edx
10be4c: 74 3a je 10be88 <_Thread_Change_priority+0x78>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
10be4e: 83 e7 04 and $0x4,%edi
10be51: 75 08 jne 10be5b <_Thread_Change_priority+0x4b><== NEVER TAKEN
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
10be53: 89 d0 mov %edx,%eax
10be55: 83 e0 fb and $0xfffffffb,%eax
10be58: 89 43 10 mov %eax,0x10(%ebx)
_ISR_Enable( level );
10be5b: 56 push %esi
10be5c: 9d popf
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10be5d: 81 e2 e0 be 03 00 and $0x3bee0,%edx
10be63: 75 0b jne 10be70 <_Thread_Change_priority+0x60>
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Context_Switch_necessary = TRUE;
_ISR_Enable( level );
}
10be65: 8d 65 f4 lea -0xc(%ebp),%esp
10be68: 5b pop %ebx
10be69: 5e pop %esi
10be6a: 5f pop %edi
10be6b: c9 leave
10be6c: c3 ret
10be6d: 8d 76 00 lea 0x0(%esi),%esi
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
if ( _States_Is_waiting_on_thread_queue( state ) ) {
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
10be70: 89 5d 0c mov %ebx,0xc(%ebp)
10be73: 8b 43 44 mov 0x44(%ebx),%eax
10be76: 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 );
}
10be79: 8d 65 f4 lea -0xc(%ebp),%esp
10be7c: 5b pop %ebx
10be7d: 5e pop %esi
10be7e: 5f pop %edi
10be7f: 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 );
10be80: e9 1b 0c 00 00 jmp 10caa0 <_Thread_queue_Requeue>
10be85: 8d 76 00 lea 0x0(%esi),%esi
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
10be88: 83 e7 04 and $0x4,%edi
10be8b: 75 41 jne 10bece <_Thread_Change_priority+0xbe><== 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 );
10be8d: 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
10be94: 8b 93 90 00 00 00 mov 0x90(%ebx),%edx
10be9a: 66 8b 83 96 00 00 00 mov 0x96(%ebx),%ax
10bea1: 66 09 02 or %ax,(%edx)
* @return TRUE if successfully able to determine the size, FALSE otherwise
10bea4: 66 a1 10 e7 11 00 mov 0x11e710,%ax
10beaa: 0b 83 94 00 00 00 or 0x94(%ebx),%eax
10beb0: 66 a3 10 e7 11 00 mov %ax,0x11e710
_Priority_Add_to_bit_map( &the_thread->Priority_map );
if ( prepend_it )
10beb6: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
10beba: 74 70 je 10bf2c <_Thread_Change_priority+0x11c>
size_t size
);
/**
* 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
10bebc: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax
10bec2: 89 43 04 mov %eax,0x4(%ebx)
10bec5: 8b 10 mov (%eax),%edx
10bec7: 89 18 mov %ebx,(%eax)
10bec9: 89 13 mov %edx,(%ebx)
10becb: 89 5a 04 mov %ebx,0x4(%edx)
_Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node );
else
_Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node );
}
_ISR_Flash( level );
10bece: 56 push %esi
10becf: 9d popf
10bed0: fa cli
void *starting_address,
size_t size
);
/**
* This routine returns the block of memory which begins
10bed1: 66 8b 0d 10 e7 11 00 mov 0x11e710,%cx
10bed8: 31 d2 xor %edx,%edx
10beda: 89 d0 mov %edx,%eax
10bedc: 66 0f bc c1 bsf %cx,%ax
* at @a starting_address to @a the_heap. Any coalescing which is
10bee0: 0f b7 c0 movzwl %ax,%eax
10bee3: 66 8b 8c 00 a0 e7 11 mov 0x11e7a0(%eax,%eax,1),%cx
10beea: 00
10beeb: 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.
10beef: c1 e0 04 shl $0x4,%eax
10bef2: 0f b7 d2 movzwl %dx,%edx
10bef5: 01 d0 add %edx,%eax
10bef7: 8d 04 40 lea (%eax,%eax,2),%eax
10befa: 8b 15 20 e6 11 00 mov 0x11e620,%edx
10bf00: 8b 04 82 mov (%edx,%eax,4),%eax
10bf03: a3 e8 e6 11 00 mov %eax,0x11e6e8
void *starting_address,
size_t size
);
/**
* This function attempts to allocate a block of @a size bytes from
10bf08: 8b 15 1c e7 11 00 mov 0x11e71c,%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() &&
10bf0e: 39 d0 cmp %edx,%eax
10bf10: 74 0d je 10bf1f <_Thread_Change_priority+0x10f>
10bf12: 80 7a 76 00 cmpb $0x0,0x76(%edx)
10bf16: 74 07 je 10bf1f <_Thread_Change_priority+0x10f><== NEVER TAKEN
_Thread_Executing->is_preemptible )
_Context_Switch_necessary = TRUE;
10bf18: c6 05 2c e7 11 00 01 movb $0x1,0x11e72c
_ISR_Enable( level );
10bf1f: 56 push %esi
10bf20: 9d popf
}
10bf21: 8d 65 f4 lea -0xc(%ebp),%esp
10bf24: 5b pop %ebx
10bf25: 5e pop %esi
10bf26: 5f pop %edi
10bf27: c9 leave
10bf28: c3 ret
10bf29: 8d 76 00 lea 0x0(%esi),%esi
_Priority_Add_to_bit_map( &the_thread->Priority_map );
if ( prepend_it )
_Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node );
else
_Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node );
10bf2c: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax
10bf32: 8d 50 04 lea 0x4(%eax),%edx
10bf35: 89 13 mov %edx,(%ebx)
10bf37: 8b 50 08 mov 0x8(%eax),%edx
10bf3a: 89 58 08 mov %ebx,0x8(%eax)
10bf3d: 89 1a mov %ebx,(%edx)
10bf3f: 89 53 04 mov %edx,0x4(%ebx)
10bf42: eb 8a jmp 10bece <_Thread_Change_priority+0xbe>
0010bf44 <_Thread_Clear_state>:
void _Thread_Clear_state(
Thread_Control *the_thread,
States_Control state
)
{
10bf44: 55 push %ebp
10bf45: 89 e5 mov %esp,%ebp
10bf47: 53 push %ebx
10bf48: 8b 4d 08 mov 0x8(%ebp),%ecx
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10bf4b: 9c pushf
10bf4c: fa cli
10bf4d: 5b pop %ebx
current_state = the_thread->current_state;
10bf4e: 8b 51 10 mov 0x10(%ecx),%edx
if ( current_state & state ) {
10bf51: 85 55 0c test %edx,0xc(%ebp)
10bf54: 74 72 je 10bfc8 <_Thread_Clear_state+0x84>
* @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(
10bf56: 8b 45 0c mov 0xc(%ebp),%eax
10bf59: f7 d0 not %eax
10bf5b: 21 d0 and %edx,%eax
current_state =
10bf5d: 89 41 10 mov %eax,0x10(%ecx)
the_thread->current_state = _States_Clear( state, current_state );
if ( _States_Is_ready( current_state ) ) {
10bf60: 85 c0 test %eax,%eax
10bf62: 75 64 jne 10bfc8 <_Thread_Clear_state+0x84>
* 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
10bf64: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx
10bf6a: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax
10bf71: 66 09 02 or %ax,(%edx)
* @return TRUE if successfully able to determine the size, FALSE otherwise
10bf74: 66 a1 10 e7 11 00 mov 0x11e710,%ax
10bf7a: 0b 81 94 00 00 00 or 0x94(%ecx),%eax
10bf80: 66 a3 10 e7 11 00 mov %ax,0x11e710
_Priority_Add_to_bit_map( &the_thread->Priority_map );
_Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
10bf86: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax
10bf8c: 8d 50 04 lea 0x4(%eax),%edx
10bf8f: 89 11 mov %edx,(%ecx)
10bf91: 8b 50 08 mov 0x8(%eax),%edx
10bf94: 89 48 08 mov %ecx,0x8(%eax)
10bf97: 89 0a mov %ecx,(%edx)
10bf99: 89 51 04 mov %edx,0x4(%ecx)
_ISR_Flash( level );
10bf9c: 53 push %ebx
10bf9d: 9d popf
10bf9e: 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 ) {
10bf9f: 8b 51 14 mov 0x14(%ecx),%edx
10bfa2: a1 e8 e6 11 00 mov 0x11e6e8,%eax
10bfa7: 3b 50 14 cmp 0x14(%eax),%edx
10bfaa: 73 1c jae 10bfc8 <_Thread_Clear_state+0x84>
_Thread_Heir = the_thread;
10bfac: 89 0d e8 e6 11 00 mov %ecx,0x11e6e8
if ( _Thread_Executing->is_preemptible ||
10bfb2: a1 1c e7 11 00 mov 0x11e71c,%eax
10bfb7: 80 78 76 00 cmpb $0x0,0x76(%eax)
10bfbb: 75 04 jne 10bfc1 <_Thread_Clear_state+0x7d>
10bfbd: 85 d2 test %edx,%edx
10bfbf: 75 07 jne 10bfc8 <_Thread_Clear_state+0x84><== ALWAYS TAKEN
the_thread->current_priority == 0 )
_Context_Switch_necessary = TRUE;
10bfc1: c6 05 2c e7 11 00 01 movb $0x1,0x11e72c
}
}
}
_ISR_Enable( level );
10bfc8: 53 push %ebx
10bfc9: 9d popf
}
10bfca: 5b pop %ebx
10bfcb: c9 leave
10bfcc: c3 ret
0010bfd0 <_Thread_Close>:
void _Thread_Close(
Objects_Information *information,
Thread_Control *the_thread
)
{
10bfd0: 55 push %ebp
10bfd1: 89 e5 mov %esp,%ebp
10bfd3: 56 push %esi
10bfd4: 53 push %ebx
10bfd5: 8b 5d 08 mov 0x8(%ebp),%ebx
10bfd8: 8b 75 0c mov 0xc(%ebp),%esi
10bfdb: 0f b7 56 08 movzwl 0x8(%esi),%edx
10bfdf: 8b 43 1c mov 0x1c(%ebx),%eax
10bfe2: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4)
10bfe9: a1 58 e6 11 00 mov 0x11e658,%eax
10bfee: 48 dec %eax
10bfef: a3 58 e6 11 00 mov %eax,0x11e658
* disappear and set a transient state on it. So we temporarily
* unnest dispatching.
*/
_Thread_Unnest_dispatch();
_User_extensions_Thread_delete( the_thread );
10bff4: 83 ec 0c sub $0xc,%esp
10bff7: 56 push %esi
10bff8: e8 3f 11 00 00 call 10d13c <_User_extensions_Thread_delete>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10bffd: a1 58 e6 11 00 mov 0x11e658,%eax
10c002: 40 inc %eax
10c003: a3 58 e6 11 00 mov %eax,0x11e658
/*
* Now we are in a dispatching critical section again and we
* can take the thread OUT of the published set. It is invalid
* to use this thread's Id OR name after this call.
*/
_Objects_Close( information, &the_thread->Object );
10c008: 59 pop %ecx
10c009: 58 pop %eax
10c00a: 56 push %esi
10c00b: 53 push %ebx
10c00c: e8 23 f6 ff ff call 10b634 <_Objects_Close>
/*
* By setting the dormant state, the thread will not be considered
* for scheduling when we remove any blocking states.
*/
_Thread_Set_state( the_thread, STATES_DORMANT );
10c011: 58 pop %eax
10c012: 5a pop %edx
10c013: 6a 01 push $0x1
10c015: 56 push %esi
10c016: e8 85 0b 00 00 call 10cba0 <_Thread_Set_state>
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
10c01b: 89 34 24 mov %esi,(%esp)
10c01e: e8 a5 09 00 00 call 10c9c8 <_Thread_queue_Extract_with_proxy>
10c023: 83 c4 10 add $0x10,%esp
10c026: 84 c0 test %al,%al
10c028: 75 06 jne 10c030 <_Thread_Close+0x60>
if ( _Watchdog_Is_active( &the_thread->Timer ) )
10c02a: 83 7e 50 02 cmpl $0x2,0x50(%esi)
10c02e: 74 68 je 10c098 <_Thread_Close+0xc8>
/*
* The thread might have been FP. So deal with that.
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( _Thread_Is_allocated_fp( the_thread ) )
10c030: 3b 35 e0 e6 11 00 cmp 0x11e6e0,%esi
10c036: 74 74 je 10c0ac <_Thread_Close+0xdc>
_Thread_Deallocate_fp();
#endif
the_thread->fp_context = NULL;
10c038: c7 86 ec 00 00 00 00 movl $0x0,0xec(%esi)
10c03f: 00 00 00
if ( the_thread->Start.fp_context )
10c042: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax
10c048: 85 c0 test %eax,%eax
10c04a: 74 0c je 10c058 <_Thread_Close+0x88>
(void) _Workspace_Free( the_thread->Start.fp_context );
10c04c: 83 ec 0c sub $0xc,%esp
10c04f: 50 push %eax
10c050: e8 b3 13 00 00 call 10d408 <_Workspace_Free>
10c055: 83 c4 10 add $0x10,%esp
/*
* Free the rest of the memory associated with this task
* and set the associated pointers to NULL for safety.
*/
_Thread_Stack_Free( the_thread );
10c058: 83 ec 0c sub $0xc,%esp
10c05b: 56 push %esi
10c05c: e8 ef 0c 00 00 call 10cd50 <_Thread_Stack_Free>
the_thread->Start.stack = NULL;
10c061: c7 86 d0 00 00 00 00 movl $0x0,0xd0(%esi)
10c068: 00 00 00
if ( the_thread->extensions )
10c06b: 8b 86 00 01 00 00 mov 0x100(%esi),%eax
10c071: 83 c4 10 add $0x10,%esp
10c074: 85 c0 test %eax,%eax
10c076: 74 0c je 10c084 <_Thread_Close+0xb4>
(void) _Workspace_Free( the_thread->extensions );
10c078: 83 ec 0c sub $0xc,%esp
10c07b: 50 push %eax
10c07c: e8 87 13 00 00 call 10d408 <_Workspace_Free>
10c081: 83 c4 10 add $0x10,%esp
the_thread->extensions = NULL;
10c084: c7 86 00 01 00 00 00 movl $0x0,0x100(%esi)
10c08b: 00 00 00
}
10c08e: 8d 65 f8 lea -0x8(%ebp),%esp
10c091: 5b pop %ebx
10c092: 5e pop %esi
10c093: c9 leave
10c094: c3 ret
10c095: 8d 76 00 lea 0x0(%esi),%esi
*/
_Thread_Set_state( the_thread, STATES_DORMANT );
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
if ( _Watchdog_Is_active( &the_thread->Timer ) )
(void) _Watchdog_Remove( &the_thread->Timer );
10c098: 83 ec 0c sub $0xc,%esp
10c09b: 8d 46 48 lea 0x48(%esi),%eax
10c09e: 50 push %eax
10c09f: e8 88 12 00 00 call 10d32c <_Watchdog_Remove>
10c0a4: 83 c4 10 add $0x10,%esp
10c0a7: eb 87 jmp 10c030 <_Thread_Close+0x60>
10c0a9: 8d 76 00 lea 0x0(%esi),%esi
* @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.
*/
bool _Protected_heap_Resize_block(
10c0ac: c7 05 e0 e6 11 00 00 movl $0x0,0x11e6e0
10c0b3: 00 00 00
10c0b6: eb 80 jmp 10c038 <_Thread_Close+0x68>
0010c0b8 <_Thread_Create_idle>:
*
* _Thread_Create_idle
*/
void _Thread_Create_idle( void )
{
10c0b8: 55 push %ebp
10c0b9: 89 e5 mov %esp,%ebp
10c0bb: 83 ec 14 sub $0x14,%esp
10c0be: 68 e0 e7 11 00 push $0x11e7e0
10c0c3: e8 ec f4 ff ff call 10b5b4 <_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();
10c0c8: a3 2c e8 11 00 mov %eax,0x11e82c
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10c0cd: a1 58 e6 11 00 mov 0x11e658,%eax
10c0d2: 40 inc %eax
10c0d3: a3 58 e6 11 00 mov %eax,0x11e658
* that when _Thread_Initialize unnests dispatch that we do not
* do anything stupid.
*/
_Thread_Disable_dispatch();
_Thread_Initialize(
10c0d8: a1 f4 e6 11 00 mov 0x11e6f4,%eax
10c0dd: 8b 50 18 mov 0x18(%eax),%edx
10c0e0: 83 c4 0c add $0xc,%esp
10c0e3: 68 90 86 11 00 push $0x118690
10c0e8: 6a 00 push $0x0
10c0ea: 6a 00 push $0x0
10c0ec: 6a 00 push $0x0
10c0ee: 6a 01 push $0x1
10c0f0: 0f b6 05 14 a1 11 00 movzbl 0x11a114,%eax
10c0f7: 50 push %eax
10c0f8: 6a 00 push $0x0
10c0fa: a1 10 a1 11 00 mov 0x11a110,%eax
10c0ff: 39 d0 cmp %edx,%eax
10c101: 73 02 jae 10c105 <_Thread_Create_idle+0x4d><== ALWAYS TAKEN
10c103: 89 d0 mov %edx,%eax <== NOT EXECUTED
10c105: 50 push %eax
10c106: 6a 00 push $0x0
10c108: ff 35 2c e8 11 00 pushl 0x11e82c
10c10e: 68 e0 e7 11 00 push $0x11e7e0
10c113: e8 78 02 00 00 call 10c390 <_Thread_Initialize>
10c118: a1 58 e6 11 00 mov 0x11e658,%eax
10c11d: 48 dec %eax
10c11e: a3 58 e6 11 00 mov %eax,0x11e658
/*
* WARNING!!! This is necessary to "kick" start the system and
* MUST be done before _Thread_Start is invoked.
*/
_Thread_Heir =
10c123: 8b 15 2c e8 11 00 mov 0x11e82c,%edx
10c129: 89 15 1c e7 11 00 mov %edx,0x11e71c
10c12f: 89 15 e8 e6 11 00 mov %edx,0x11e6e8
_Thread_Executing = _Thread_Idle;
_Thread_Start(
10c135: 83 c4 24 add $0x24,%esp
10c138: 6a 00 push $0x0
10c13a: 6a 00 push $0x0
10c13c: a1 f4 e6 11 00 mov 0x11e6f4,%eax
10c141: ff 70 14 pushl 0x14(%eax)
10c144: 6a 00 push $0x0
10c146: 52 push %edx
10c147: e8 9c 0c 00 00 call 10cde8 <_Thread_Start>
10c14c: 83 c4 20 add $0x20,%esp
_Configuration_Table->idle_task,
NULL,
0
);
}
10c14f: c9 leave
10c150: c3 ret
0010c154 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored
)
{
10c154: 55 push %ebp
10c155: 89 e5 mov %esp,%ebp
10c157: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10c15a: 8d 45 fc lea -0x4(%ebp),%eax
10c15d: 50 push %eax
10c15e: ff 75 08 pushl 0x8(%ebp)
10c161: e8 aa 01 00 00 call 10c310 <_Thread_Get>
switch ( location ) {
10c166: 83 c4 10 add $0x10,%esp
10c169: 8b 55 fc mov -0x4(%ebp),%edx
10c16c: 85 d2 test %edx,%edx
10c16e: 75 1c jne 10c18c <_Thread_Delay_ended+0x38><== NEVER TAKEN
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
10c170: 83 ec 08 sub $0x8,%esp
10c173: 68 f8 ff 03 10 push $0x1003fff8
10c178: 50 push %eax
10c179: e8 c6 fd ff ff call 10bf44 <_Thread_Clear_state>
10c17e: a1 58 e6 11 00 mov 0x11e658,%eax
10c183: 48 dec %eax
10c184: a3 58 e6 11 00 mov %eax,0x11e658
10c189: 83 c4 10 add $0x10,%esp
case OBJECTS_LOCAL:
_Thread_Unblock( the_thread );
_Thread_Unnest_dispatch();
break;
}
}
10c18c: c9 leave
10c18d: c3 ret
0010c190 <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
10c190: 55 push %ebp
10c191: 89 e5 mov %esp,%ebp
10c193: 57 push %edi
10c194: 56 push %esi
10c195: 53 push %ebx
10c196: 83 ec 1c sub $0x1c,%esp
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
10c199: 8b 35 1c e7 11 00 mov 0x11e71c,%esi
_ISR_Disable( level );
10c19f: 9c pushf
10c1a0: fa cli
10c1a1: 5a pop %edx
while ( _Context_Switch_necessary == TRUE ) {
10c1a2: a0 2c e7 11 00 mov 0x11e72c,%al
10c1a7: 84 c0 test %al,%al
10c1a9: 0f 84 11 01 00 00 je 10c2c0 <_Thread_Dispatch+0x130>
10c1af: 8d 7d e4 lea -0x1c(%ebp),%edi
10c1b2: e9 d2 00 00 00 jmp 10c289 <_Thread_Dispatch+0xf9>
10c1b7: 90 nop
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 )
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
_ISR_Enable( level );
10c1b8: 52 push %edx
10c1b9: 9d popf
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
{
struct timespec uptime, ran;
_TOD_Get_uptime( &uptime );
10c1ba: 83 ec 0c sub $0xc,%esp
10c1bd: 8d 45 ec lea -0x14(%ebp),%eax
10c1c0: 50 push %eax
10c1c1: e8 ae 30 00 00 call 10f274 <_TOD_Get_uptime>
_Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
10c1c6: 83 c4 0c add $0xc,%esp
10c1c9: 57 push %edi
10c1ca: 8d 45 ec lea -0x14(%ebp),%eax
10c1cd: 50 push %eax
10c1ce: 68 24 e7 11 00 push $0x11e724
10c1d3: e8 7c 0d 00 00 call 10cf54 <_Timespec_Subtract>
_Timespec_Add_to( &executing->cpu_time_used, &ran );
10c1d8: 58 pop %eax
10c1d9: 5a pop %edx
10c1da: 57 push %edi
10c1db: 8d 86 84 00 00 00 lea 0x84(%esi),%eax
10c1e1: 50 push %eax
10c1e2: e8 35 0d 00 00 call 10cf1c <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
10c1e7: 8b 45 ec mov -0x14(%ebp),%eax
10c1ea: 8b 55 f0 mov -0x10(%ebp),%edx
10c1ed: a3 24 e7 11 00 mov %eax,0x11e724
10c1f2: 89 15 28 e7 11 00 mov %edx,0x11e728
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
10c1f8: 8b 15 e4 e6 11 00 mov 0x11e6e4,%edx
10c1fe: 83 c4 10 add $0x10,%esp
10c201: 85 d2 test %edx,%edx
10c203: 74 10 je 10c215 <_Thread_Dispatch+0x85> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
10c205: 8b 02 mov (%edx),%eax
10c207: 89 86 f0 00 00 00 mov %eax,0xf0(%esi)
*_Thread_libc_reent = heir->libc_reent;
10c20d: 8b 83 f0 00 00 00 mov 0xf0(%ebx),%eax
10c213: 89 02 mov %eax,(%edx)
}
_User_extensions_Thread_switch( executing, heir );
10c215: 83 ec 08 sub $0x8,%esp
10c218: 53 push %ebx
10c219: 56 push %esi
10c21a: e8 9d 0f 00 00 call 10d1bc <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
10c21f: 59 pop %ecx
10c220: 58 pop %eax
10c221: 8d 83 d4 00 00 00 lea 0xd4(%ebx),%eax
10c227: 50 push %eax
10c228: 8d 86 d4 00 00 00 lea 0xd4(%esi),%eax
10c22e: 50 push %eax
10c22f: e8 8c 12 00 00 call 10d4c0 <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
10c234: 83 c4 10 add $0x10,%esp
10c237: 8b 96 ec 00 00 00 mov 0xec(%esi),%edx
10c23d: 85 d2 test %edx,%edx
10c23f: 74 36 je 10c277 <_Thread_Dispatch+0xe7>
Heap_Control *the_heap,
void *starting_address,
size_t *size
);
/**
10c241: a1 e0 e6 11 00 mov 0x11e6e0,%eax
10c246: 39 c6 cmp %eax,%esi
10c248: 74 2d je 10c277 <_Thread_Dispatch+0xe7>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
10c24a: 85 c0 test %eax,%eax
10c24c: 74 11 je 10c25f <_Thread_Dispatch+0xcf>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10c24e: 83 ec 0c sub $0xc,%esp
10c251: 05 ec 00 00 00 add $0xec,%eax
10c256: 50 push %eax
10c257: e8 98 12 00 00 call 10d4f4 <_CPU_Context_save_fp>
10c25c: 83 c4 10 add $0x10,%esp
_Context_Restore_fp( &executing->fp_context );
10c25f: 83 ec 0c sub $0xc,%esp
10c262: 8d 86 ec 00 00 00 lea 0xec(%esi),%eax
10c268: 50 push %eax
10c269: e8 90 12 00 00 call 10d4fe <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
10c26e: 89 35 e0 e6 11 00 mov %esi,0x11e6e0
10c274: 83 c4 10 add $0x10,%esp
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
10c277: 8b 35 1c e7 11 00 mov 0x11e71c,%esi
_ISR_Disable( level );
10c27d: 9c pushf
10c27e: fa cli
10c27f: 5a pop %edx
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Context_Switch_necessary == TRUE ) {
10c280: a0 2c e7 11 00 mov 0x11e72c,%al
10c285: 84 c0 test %al,%al
10c287: 74 37 je 10c2c0 <_Thread_Dispatch+0x130>
heir = _Thread_Heir;
10c289: 8b 1d e8 e6 11 00 mov 0x11e6e8,%ebx
_Thread_Dispatch_disable_level = 1;
10c28f: c7 05 58 e6 11 00 01 movl $0x1,0x11e658
10c296: 00 00 00
_Context_Switch_necessary = FALSE;
10c299: c6 05 2c e7 11 00 00 movb $0x0,0x11e72c
_Thread_Executing = heir;
10c2a0: 89 1d 1c e7 11 00 mov %ebx,0x11e71c
#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 )
10c2a6: 83 7b 7c 01 cmpl $0x1,0x7c(%ebx)
10c2aa: 0f 85 08 ff ff ff jne 10c1b8 <_Thread_Dispatch+0x28>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
10c2b0: a1 24 e6 11 00 mov 0x11e624,%eax
10c2b5: 89 43 78 mov %eax,0x78(%ebx)
10c2b8: e9 fb fe ff ff jmp 10c1b8 <_Thread_Dispatch+0x28>
10c2bd: 8d 76 00 lea 0x0(%esi),%esi
executing = _Thread_Executing;
_ISR_Disable( level );
}
_Thread_Dispatch_disable_level = 0;
10c2c0: c7 05 58 e6 11 00 00 movl $0x0,0x11e658
10c2c7: 00 00 00
_ISR_Enable( level );
10c2ca: 52 push %edx
10c2cb: 9d popf
if ( _Thread_Do_post_task_switch_extension ||
10c2cc: a1 00 e7 11 00 mov 0x11e700,%eax
10c2d1: 85 c0 test %eax,%eax
10c2d3: 75 06 jne 10c2db <_Thread_Dispatch+0x14b><== NEVER TAKEN
10c2d5: 80 7e 75 00 cmpb $0x0,0x75(%esi)
10c2d9: 74 09 je 10c2e4 <_Thread_Dispatch+0x154>
executing->do_post_task_switch_extension ) {
executing->do_post_task_switch_extension = false;
10c2db: c6 46 75 00 movb $0x0,0x75(%esi)
_API_extensions_Run_postswitch();
10c2df: e8 74 e9 ff ff call 10ac58 <_API_extensions_Run_postswitch>
}
}
10c2e4: 8d 65 f4 lea -0xc(%ebp),%esp
10c2e7: 5b pop %ebx
10c2e8: 5e pop %esi
10c2e9: 5f pop %edi
10c2ea: c9 leave
10c2eb: c3 ret
0010c2ec <_Thread_Enable_dispatch>:
*/
#if ( (CPU_INLINE_ENABLE_DISPATCH == FALSE) || \
(__RTEMS_DO_NOT_INLINE_THREAD_ENABLE_DISPATCH__ == 1) )
void _Thread_Enable_dispatch( void )
{
10c2ec: 55 push %ebp
10c2ed: 89 e5 mov %esp,%ebp
if ( --_Thread_Dispatch_disable_level )
10c2ef: a1 58 e6 11 00 mov 0x11e658,%eax
10c2f4: 48 dec %eax
10c2f5: a3 58 e6 11 00 mov %eax,0x11e658
10c2fa: a1 58 e6 11 00 mov 0x11e658,%eax
10c2ff: 85 c0 test %eax,%eax
10c301: 74 05 je 10c308 <_Thread_Enable_dispatch+0x1c>
return;
_Thread_Dispatch();
}
10c303: c9 leave
10c304: c3 ret
10c305: 8d 76 00 lea 0x0(%esi),%esi
10c308: c9 leave
(__RTEMS_DO_NOT_INLINE_THREAD_ENABLE_DISPATCH__ == 1) )
void _Thread_Enable_dispatch( void )
{
if ( --_Thread_Dispatch_disable_level )
return;
_Thread_Dispatch();
10c309: e9 82 fe ff ff jmp 10c190 <_Thread_Dispatch>
0010ffe8 <_Thread_Evaluate_mode>:
*
* XXX
*/
bool _Thread_Evaluate_mode( void )
{
10ffe8: 55 push %ebp
10ffe9: 89 e5 mov %esp,%ebp
Thread_Control *executing;
executing = _Thread_Executing;
10ffeb: a1 1c e7 11 00 mov 0x11e71c,%eax
if ( !_States_Is_ready( executing->current_state ) ||
10fff0: 8b 50 10 mov 0x10(%eax),%edx
10fff3: 85 d2 test %edx,%edx
10fff5: 75 0e jne 110005 <_Thread_Evaluate_mode+0x1d><== NEVER TAKEN
10fff7: 3b 05 e8 e6 11 00 cmp 0x11e6e8,%eax
10fffd: 74 11 je 110010 <_Thread_Evaluate_mode+0x28>
10ffff: 80 78 76 00 cmpb $0x0,0x76(%eax)
110003: 74 0b je 110010 <_Thread_Evaluate_mode+0x28><== NEVER TAKEN
( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) {
_Context_Switch_necessary = TRUE;
110005: c6 05 2c e7 11 00 01 movb $0x1,0x11e72c
11000c: b0 01 mov $0x1,%al
return TRUE;
}
return FALSE;
}
11000e: c9 leave
11000f: c3 ret
executing = _Thread_Executing;
if ( !_States_Is_ready( executing->current_state ) ||
( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) {
_Context_Switch_necessary = TRUE;
return TRUE;
110010: 31 c0 xor %eax,%eax
}
return FALSE;
}
110012: c9 leave
110013: c3 ret
0010c310 <_Thread_Get>:
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
10c310: 55 push %ebp
10c311: 89 e5 mov %esp,%ebp
10c313: 53 push %ebx
10c314: 83 ec 04 sub $0x4,%esp
10c317: 8b 4d 08 mov 0x8(%ebp),%ecx
10c31a: 8b 5d 0c mov 0xc(%ebp),%ebx
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 ) ) {
10c31d: 85 c9 test %ecx,%ecx
10c31f: 74 4b je 10c36c <_Thread_Get+0x5c>
uint32_t page_size
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
10c321: 89 ca mov %ecx,%edx
10c323: c1 ea 18 shr $0x18,%edx
10c326: 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.
10c329: 8d 42 ff lea -0x1(%edx),%eax
10c32c: 83 f8 03 cmp $0x3,%eax
10c32f: 77 2b ja 10c35c <_Thread_Get+0x4c>
*location = OBJECTS_ERROR;
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
10c331: 89 c8 mov %ecx,%eax
10c333: c1 e8 1b shr $0x1b,%eax
10c336: 48 dec %eax
10c337: 75 23 jne 10c35c <_Thread_Get+0x4c>
*location = OBJECTS_ERROR;
goto done;
}
api_information = _Objects_Information_table[ the_api ];
10c339: 8b 04 95 2c e6 11 00 mov 0x11e62c(,%edx,4),%eax
if ( !api_information ) {
10c340: 85 c0 test %eax,%eax
10c342: 74 44 je 10c388 <_Thread_Get+0x78>
*location = OBJECTS_ERROR;
goto done;
}
information = api_information[ the_class ];
10c344: 8b 40 04 mov 0x4(%eax),%eax
if ( !information ) {
10c347: 85 c0 test %eax,%eax
10c349: 74 3d je 10c388 <_Thread_Get+0x78> <== NEVER TAKEN
*location = OBJECTS_ERROR;
goto done;
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
10c34b: 52 push %edx
10c34c: 53 push %ebx
10c34d: 51 push %ecx
10c34e: 50 push %eax
10c34f: e8 54 f7 ff ff call 10baa8 <_Objects_Get>
10c354: 83 c4 10 add $0x10,%esp
done:
return tp;
}
10c357: 8b 5d fc mov -0x4(%ebp),%ebx
10c35a: c9 leave
10c35b: c3 ret
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
10c35c: c7 03 01 00 00 00 movl $0x1,(%ebx)
10c362: 31 c0 xor %eax,%eax
tp = (Thread_Control *) _Objects_Get( information, id, location );
done:
return tp;
}
10c364: 8b 5d fc mov -0x4(%ebp),%ebx
10c367: c9 leave
10c368: c3 ret
10c369: 8d 76 00 lea 0x0(%esi),%esi
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10c36c: a1 58 e6 11 00 mov 0x11e658,%eax
10c371: 40 inc %eax
10c372: a3 58 e6 11 00 mov %eax,0x11e658
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
_Thread_Disable_dispatch();
*location = OBJECTS_LOCAL;
10c377: c7 03 00 00 00 00 movl $0x0,(%ebx)
tp = _Thread_Executing;
10c37d: a1 1c e7 11 00 mov 0x11e71c,%eax
tp = (Thread_Control *) _Objects_Get( information, id, location );
done:
return tp;
}
10c382: 8b 5d fc mov -0x4(%ebp),%ebx
10c385: c9 leave
10c386: c3 ret
10c387: 90 nop
goto done;
}
information = api_information[ the_class ];
if ( !information ) {
*location = OBJECTS_ERROR;
10c388: c7 03 01 00 00 00 movl $0x1,(%ebx)
10c38e: eb d4 jmp 10c364 <_Thread_Get+0x54>
00110014 <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
110014: 55 push %ebp
110015: 89 e5 mov %esp,%ebp
110017: 53 push %ebx
110018: 83 ec 04 sub $0x4,%esp
#if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
11001b: 8b 1d 1c e7 11 00 mov 0x11e71c,%ebx
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
110021: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
_ISR_Set_level(level);
110027: 85 c0 test %eax,%eax
110029: 0f 84 91 00 00 00 je 1100c0 <_Thread_Handler+0xac>
11002f: fa cli
#if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__)
doneCons = doneConstructors;
110030: a0 18 e4 11 00 mov 0x11e418,%al
110035: 88 45 fb mov %al,-0x5(%ebp)
doneConstructors = 1;
110038: c6 05 18 e4 11 00 01 movb $0x1,0x11e418
#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 ) ) {
11003f: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax
110045: 85 c0 test %eax,%eax
110047: 74 24 je 11006d <_Thread_Handler+0x59>
Heap_Control *the_heap,
void *starting_address,
size_t *size
);
/**
110049: a1 e0 e6 11 00 mov 0x11e6e0,%eax
11004e: 39 c3 cmp %eax,%ebx
110050: 74 1b je 11006d <_Thread_Handler+0x59>
if ( _Thread_Allocated_fp != NULL )
110052: 85 c0 test %eax,%eax
110054: 74 11 je 110067 <_Thread_Handler+0x53>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
110056: 83 ec 0c sub $0xc,%esp
110059: 05 ec 00 00 00 add $0xec,%eax
11005e: 50 push %eax
11005f: e8 90 d4 ff ff call 10d4f4 <_CPU_Context_save_fp>
110064: 83 c4 10 add $0x10,%esp
_Thread_Allocated_fp = executing;
110067: 89 1d e0 e6 11 00 mov %ebx,0x11e6e0
* 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 );
11006d: 83 ec 0c sub $0xc,%esp
110070: 53 push %ebx
110071: e8 be cf ff ff call 10d034 <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
110076: e8 71 c2 ff ff call 10c2ec <_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) */
11007b: 83 c4 10 add $0x10,%esp
11007e: 80 7d fb 00 cmpb $0x0,-0x5(%ebp)
110082: 74 6c je 1100f0 <_Thread_Handler+0xdc>
#if defined(__USE__MAIN__)
if (!doneCons && _main)
__main ();
#endif
switch ( executing->Start.prototype ) {
110084: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax
11008a: 83 f8 01 cmp $0x1,%eax
11008d: 74 71 je 110100 <_Thread_Handler+0xec> <== NEVER TAKEN
11008f: 73 37 jae 1100c8 <_Thread_Handler+0xb4> <== NEVER TAKEN
case THREAD_START_NUMERIC:
executing->Wait.return_argument =
110091: 83 ec 0c sub $0xc,%esp
110094: ff b3 a8 00 00 00 pushl 0xa8(%ebx)
11009a: ff 93 9c 00 00 00 call *0x9c(%ebx)
1100a0: 89 43 28 mov %eax,0x28(%ebx)
1100a3: 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 );
1100a6: 83 ec 0c sub $0xc,%esp
1100a9: 53 push %ebx
1100aa: e8 c1 cf ff ff call 10d070 <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
1100af: 83 c4 0c add $0xc,%esp
1100b2: 6a 06 push $0x6
1100b4: 6a 01 push $0x1
1100b6: 6a 00 push $0x0
1100b8: e8 63 b4 ff ff call 10b520 <_Internal_error_Occurred>
1100bd: 8d 76 00 lea 0x0(%esi),%esi
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
_ISR_Set_level(level);
1100c0: fb sti
1100c1: e9 6a ff ff ff jmp 110030 <_Thread_Handler+0x1c>
1100c6: 66 90 xchg %ax,%ax
#if defined(__USE__MAIN__)
if (!doneCons && _main)
__main ();
#endif
switch ( executing->Start.prototype ) {
1100c8: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED
1100cb: 74 4b je 110118 <_Thread_Handler+0x104> <== NOT EXECUTED
1100cd: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED
1100d0: 75 d4 jne 1100a6 <_Thread_Handler+0x92> <== NOT EXECUTED
executing->Start.pointer_argument,
executing->Start.numeric_argument
);
break;
case THREAD_START_BOTH_NUMERIC_FIRST:
executing->Wait.return_argument =
1100d2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
1100d5: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED
1100db: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED
1100e1: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED
1100e7: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
1100ea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1100ed: eb b7 jmp 1100a6 <_Thread_Handler+0x92> <== NOT EXECUTED
1100ef: 90 nop <== NOT EXECUTED
* in any configuration I know of and it generates a warning on every
* RTEMS target configuration. --joel (12 May 2007)
*/
if (!doneCons) /* && (volatile void *)_init) */
{
_init ();
1100f0: e8 db 6d 00 00 call 116ed0 <__start_set_sysctl_set>
#if defined(__USE__MAIN__)
if (!doneCons && _main)
__main ();
#endif
switch ( executing->Start.prototype ) {
1100f5: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax
1100fb: 83 f8 01 cmp $0x1,%eax
1100fe: 75 8f jne 11008f <_Thread_Handler+0x7b> <== ALWAYS TAKEN
(*(Thread_Entry_numeric) executing->Start.entry_point)(
executing->Start.numeric_argument
);
break;
case THREAD_START_POINTER:
executing->Wait.return_argument =
110100: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
110103: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED
110109: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED
11010f: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
110112: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
110115: eb 8f jmp 1100a6 <_Thread_Handler+0x92> <== NOT EXECUTED
110117: 90 nop <== NOT EXECUTED
(*(Thread_Entry_pointer) executing->Start.entry_point)(
executing->Start.pointer_argument
);
break;
case THREAD_START_BOTH_POINTER_FIRST:
executing->Wait.return_argument =
110118: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
11011b: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED
110121: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED
110127: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED
11012d: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
110130: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
110133: e9 6e ff ff ff jmp 1100a6 <_Thread_Handler+0x92> <== NOT EXECUTED
0010c390 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
10c390: 55 push %ebp
10c391: 89 e5 mov %esp,%ebp
10c393: 57 push %edi
10c394: 56 push %esi
10c395: 53 push %ebx
10c396: 83 ec 0c sub $0xc,%esp
10c399: 8b 5d 0c mov 0xc(%ebp),%ebx
10c39c: 8b 55 10 mov 0x10(%ebp),%edx
10c39f: 8a 45 18 mov 0x18(%ebp),%al
10c3a2: 88 45 f3 mov %al,-0xd(%ebp)
10c3a5: 8a 4d 20 mov 0x20(%ebp),%cl
10c3a8: 88 4d f2 mov %cl,-0xe(%ebp)
/*
* Allocate and Initialize the stack for this thread.
*/
if ( !stack_area ) {
10c3ab: 85 d2 test %edx,%edx
10c3ad: 0f 84 b2 01 00 00 je 10c565 <_Thread_Initialize+0x1d5><== ALWAYS TAKEN
stack = the_thread->Start.stack;
the_thread->Start.core_allocated_stack = TRUE;
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = FALSE;
10c3b3: c6 83 c0 00 00 00 00 movb $0x0,0xc0(%ebx) <== NOT EXECUTED
10c3ba: 8b 45 14 mov 0x14(%ebp),%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
10c3bd: 89 93 c8 00 00 00 mov %edx,0xc8(%ebx)
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
10c3c3: 89 83 c4 00 00 00 mov %eax,0xc4(%ebx)
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
10c3c9: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
10c3cd: 0f 85 2d 01 00 00 jne 10c500 <_Thread_Initialize+0x170>
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
if ( !fp_area ) {
_Thread_Stack_Free( the_thread );
return FALSE;
10c3d3: 31 ff xor %edi,%edi
10c3d5: 31 c0 xor %eax,%eax
fp_area = _Context_Fp_start( fp_area, 0 );
} else
fp_area = NULL;
the_thread->fp_context = fp_area;
10c3d7: 89 83 ec 00 00 00 mov %eax,0xec(%ebx)
the_thread->Start.fp_context = fp_area;
10c3dd: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx)
*
10c3e3: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
* @param[in] the_heap is the heap to operate upon
10c3ea: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
* @param[in] starting_address is the starting address of the memory for
10c3f1: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
* the heap
10c3f8: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
/*
* Clear the libc reent hook.
*/
the_thread->libc_reent = NULL;
10c3ff: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx)
10c406: 00 00 00
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10c409: a1 fc e6 11 00 mov 0x11e6fc,%eax
10c40e: 85 c0 test %eax,%eax
10c410: 0f 85 06 01 00 00 jne 10c51c <_Thread_Initialize+0x18c>
return FALSE;
}
} else
extensions_area = NULL;
the_thread->extensions = (void **) extensions_area;
10c416: c7 83 00 01 00 00 00 movl $0x0,0x100(%ebx)
10c41d: 00 00 00
10c420: 31 f6 xor %esi,%esi
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
10c422: 8a 45 f2 mov -0xe(%ebp),%al
10c425: 88 83 ac 00 00 00 mov %al,0xac(%ebx)
the_thread->Start.budget_algorithm = budget_algorithm;
10c42b: 8b 4d 24 mov 0x24(%ebp),%ecx
10c42e: 89 8b b0 00 00 00 mov %ecx,0xb0(%ebx)
the_thread->Start.budget_callout = budget_callout;
10c434: 8b 45 28 mov 0x28(%ebp),%eax
10c437: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx)
switch ( budget_algorithm ) {
10c43d: 83 f9 02 cmp $0x2,%ecx
10c440: 75 08 jne 10c44a <_Thread_Initialize+0xba><== 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;
10c442: a1 24 e6 11 00 mov 0x11e624,%eax <== NOT EXECUTED
10c447: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED
break;
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
}
the_thread->Start.isr_level = isr_level;
10c44a: 8b 4d 2c mov 0x2c(%ebp),%ecx
10c44d: 89 8b b8 00 00 00 mov %ecx,0xb8(%ebx)
the_thread->current_state = STATES_DORMANT;
10c453: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
the_thread->Wait.queue = NULL;
10c45a: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
the_thread->resource_count = 0;
10c461: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->suspend_count = 0;
10c468: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx)
the_thread->real_priority = priority;
10c46f: 8b 45 1c mov 0x1c(%ebp),%eax
10c472: 89 43 18 mov %eax,0x18(%ebx)
the_thread->Start.initial_priority = priority;
10c475: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx)
_Thread_Set_priority( the_thread, priority );
10c47b: 83 ec 08 sub $0x8,%esp
10c47e: 50 push %eax
10c47f: 53 push %ebx
10c480: e8 af 06 00 00 call 10cb34 <_Thread_Set_priority>
/*
* Initialize the CPU usage statistics
*/
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
the_thread->cpu_time_used.tv_sec = 0;
10c485: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx)
10c48c: 00 00 00
the_thread->cpu_time_used.tv_nsec = 0;
10c48f: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx)
10c496: 00 00 00
10c499: 0f b7 53 08 movzwl 0x8(%ebx),%edx
10c49d: 8b 4d 08 mov 0x8(%ebp),%ecx
10c4a0: 8b 41 1c mov 0x1c(%ecx),%eax
10c4a3: 89 1c 90 mov %ebx,(%eax,%edx,4)
10c4a6: 8b 45 30 mov 0x30(%ebp),%eax
10c4a9: 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 );
10c4ac: 89 1c 24 mov %ebx,(%esp)
10c4af: e8 40 0c 00 00 call 10d0f4 <_User_extensions_Thread_create>
if ( !extension_status ) {
10c4b4: 83 c4 10 add $0x10,%esp
10c4b7: 84 c0 test %al,%al
10c4b9: 75 39 jne 10c4f4 <_Thread_Initialize+0x164><== ALWAYS TAKEN
if ( extensions_area )
10c4bb: 85 f6 test %esi,%esi <== NOT EXECUTED
10c4bd: 74 0c je 10c4cb <_Thread_Initialize+0x13b><== NOT EXECUTED
(void) _Workspace_Free( extensions_area );
10c4bf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c4c2: 56 push %esi <== NOT EXECUTED
10c4c3: e8 40 0f 00 00 call 10d408 <_Workspace_Free> <== NOT EXECUTED
10c4c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( fp_area )
10c4cb: 85 ff test %edi,%edi <== NOT EXECUTED
10c4cd: 74 0c je 10c4db <_Thread_Initialize+0x14b><== NOT EXECUTED
(void) _Workspace_Free( fp_area );
10c4cf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c4d2: 57 push %edi <== NOT EXECUTED
10c4d3: e8 30 0f 00 00 call 10d408 <_Workspace_Free> <== NOT EXECUTED
10c4d8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
#endif
_Thread_Stack_Free( the_thread );
10c4db: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c4de: 53 push %ebx <== NOT EXECUTED
10c4df: e8 6c 08 00 00 call 10cd50 <_Thread_Stack_Free> <== NOT EXECUTED
10c4e4: 31 c0 xor %eax,%eax <== NOT EXECUTED
10c4e6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return FALSE;
}
return TRUE;
}
10c4e9: 8d 65 f4 lea -0xc(%ebp),%esp
10c4ec: 5b pop %ebx
10c4ed: 5e pop %esi
10c4ee: 5f pop %edi
10c4ef: c9 leave
10c4f0: c3 ret
10c4f1: 8d 76 00 lea 0x0(%esi),%esi
* Mutex provides sufficient protection to let the user extensions
* run safely.
*/
extension_status = _User_extensions_Thread_create( the_thread );
if ( !extension_status ) {
10c4f4: b0 01 mov $0x1,%al
return FALSE;
}
return TRUE;
}
10c4f6: 8d 65 f4 lea -0xc(%ebp),%esp
10c4f9: 5b pop %ebx
10c4fa: 5e pop %esi
10c4fb: 5f pop %edi
10c4fc: c9 leave
10c4fd: c3 ret
10c4fe: 66 90 xchg %ax,%ax
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
10c500: 83 ec 0c sub $0xc,%esp
10c503: 6a 6c push $0x6c
10c505: e8 16 0f 00 00 call 10d420 <_Workspace_Allocate>
10c50a: 89 c7 mov %eax,%edi
if ( !fp_area ) {
10c50c: 83 c4 10 add $0x10,%esp
10c50f: 85 c0 test %eax,%eax
10c511: 0f 85 c0 fe ff ff jne 10c3d7 <_Thread_Initialize+0x47><== ALWAYS TAKEN
10c517: eb c2 jmp 10c4db <_Thread_Initialize+0x14b><== NOT EXECUTED
10c519: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
extensions_area = _Workspace_Allocate(
10c51c: 83 ec 0c sub $0xc,%esp
10c51f: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax
10c526: 50 push %eax
10c527: e8 f4 0e 00 00 call 10d420 <_Workspace_Allocate>
10c52c: 89 c6 mov %eax,%esi
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area ) {
10c52e: 83 c4 10 add $0x10,%esp
10c531: 85 c0 test %eax,%eax
10c533: 74 96 je 10c4cb <_Thread_Initialize+0x13b><== NEVER TAKEN
return FALSE;
}
} else
extensions_area = NULL;
the_thread->extensions = (void **) extensions_area;
10c535: 89 83 00 01 00 00 mov %eax,0x100(%ebx)
* call.
*/
if ( the_thread->extensions ) {
uint32_t i;
for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ )
10c53b: 83 3d fc e6 11 00 ff cmpl $0xffffffff,0x11e6fc
10c542: 0f 84 da fe ff ff je 10c422 <_Thread_Initialize+0x92><== NEVER TAKEN
10c548: 31 d2 xor %edx,%edx
10c54a: 89 c1 mov %eax,%ecx
10c54c: a1 fc e6 11 00 mov 0x11e6fc,%eax
10c551: 40 inc %eax
10c552: 66 90 xchg %ax,%ax
the_thread->extensions[i] = NULL;
10c554: c7 04 91 00 00 00 00 movl $0x0,(%ecx,%edx,4)
* call.
*/
if ( the_thread->extensions ) {
uint32_t i;
for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ )
10c55b: 42 inc %edx
10c55c: 39 d0 cmp %edx,%eax
10c55e: 77 f4 ja 10c554 <_Thread_Initialize+0x1c4>
10c560: e9 bd fe ff ff jmp 10c422 <_Thread_Initialize+0x92>
*/
if ( !stack_area ) {
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
10c565: 83 ec 08 sub $0x8,%esp
10c568: ff 75 14 pushl 0x14(%ebp)
10c56b: 53 push %ebx
10c56c: e8 7b 07 00 00 call 10ccec <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
10c571: 83 c4 10 add $0x10,%esp
10c574: 85 c0 test %eax,%eax
10c576: 74 17 je 10c58f <_Thread_Initialize+0x1ff>
10c578: 39 45 14 cmp %eax,0x14(%ebp)
10c57b: 77 12 ja 10c58f <_Thread_Initialize+0x1ff><== NEVER TAKEN
return FALSE; /* stack allocation failed */
stack = the_thread->Start.stack;
10c57d: 8b 93 d0 00 00 00 mov 0xd0(%ebx),%edx
the_thread->Start.core_allocated_stack = TRUE;
10c583: c6 83 c0 00 00 00 01 movb $0x1,0xc0(%ebx)
10c58a: e9 2e fe ff ff jmp 10c3bd <_Thread_Initialize+0x2d>
(void) _Workspace_Free( fp_area );
#endif
_Thread_Stack_Free( the_thread );
return FALSE;
10c58f: 31 c0 xor %eax,%eax
10c591: e9 53 ff ff ff jmp 10c4e9 <_Thread_Initialize+0x159>
001103d0 <_Thread_Reset>:
void _Thread_Reset(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
1103d0: 55 push %ebp
1103d1: 89 e5 mov %esp,%ebp
1103d3: 53 push %ebx
1103d4: 83 ec 10 sub $0x10,%esp
1103d7: 8b 5d 08 mov 0x8(%ebp),%ebx
the_thread->resource_count = 0;
1103da: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->suspend_count = 0;
1103e1: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx)
the_thread->is_preemptible = the_thread->Start.is_preemptible;
1103e8: 8a 83 ac 00 00 00 mov 0xac(%ebx),%al
1103ee: 88 43 76 mov %al,0x76(%ebx)
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
1103f1: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax
1103f7: 89 43 7c mov %eax,0x7c(%ebx)
the_thread->budget_callout = the_thread->Start.budget_callout;
1103fa: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax
110400: 89 83 80 00 00 00 mov %eax,0x80(%ebx)
the_thread->Start.pointer_argument = pointer_argument;
110406: 8b 45 0c mov 0xc(%ebp),%eax
110409: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
the_thread->Start.numeric_argument = numeric_argument;
11040f: 8b 45 10 mov 0x10(%ebp),%eax
110412: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx)
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
110418: 53 push %ebx
110419: e8 e2 cf ff ff call 10d400 <_Thread_queue_Extract_with_proxy>
11041e: 83 c4 10 add $0x10,%esp
110421: 84 c0 test %al,%al
110423: 75 06 jne 11042b <_Thread_Reset+0x5b> <== NEVER TAKEN
if ( _Watchdog_Is_active( &the_thread->Timer ) )
110425: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
110429: 74 25 je 110450 <_Thread_Reset+0x80>
(void) _Watchdog_Remove( &the_thread->Timer );
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
11042b: 8b 83 bc 00 00 00 mov 0xbc(%ebx),%eax
110431: 39 43 14 cmp %eax,0x14(%ebx)
110434: 74 12 je 110448 <_Thread_Reset+0x78>
the_thread->real_priority = the_thread->Start.initial_priority;
110436: 89 43 18 mov %eax,0x18(%ebx)
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
110439: 89 45 0c mov %eax,0xc(%ebp)
11043c: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
11043f: 8b 5d fc mov -0x4(%ebp),%ebx
110442: 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 );
110443: e9 b8 d1 ff ff jmp 10d600 <_Thread_Set_priority>
}
}
110448: 8b 5d fc mov -0x4(%ebp),%ebx
11044b: c9 leave
11044c: c3 ret
11044d: 8d 76 00 lea 0x0(%esi),%esi
the_thread->Start.numeric_argument = numeric_argument;
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
if ( _Watchdog_Is_active( &the_thread->Timer ) )
(void) _Watchdog_Remove( &the_thread->Timer );
110450: 83 ec 0c sub $0xc,%esp
110453: 8d 43 48 lea 0x48(%ebx),%eax
110456: 50 push %eax
110457: e8 dc d9 ff ff call 10de38 <_Watchdog_Remove>
11045c: 83 c4 10 add $0x10,%esp
11045f: eb ca jmp 11042b <_Thread_Reset+0x5b>
0010f828 <_Thread_Reset_timeslice>:
* ready chain
* select heir
*/
void _Thread_Reset_timeslice( void )
{
10f828: 55 push %ebp
10f829: 89 e5 mov %esp,%ebp
10f82b: 56 push %esi
10f82c: 53 push %ebx
ISR_Level level;
Thread_Control *executing;
Chain_Control *ready;
executing = _Thread_Executing;
10f82d: 8b 0d 1c e7 11 00 mov 0x11e71c,%ecx
ready = executing->ready;
10f833: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx
_ISR_Disable( level );
10f839: 9c pushf
10f83a: fa cli
10f83b: 5e pop %esi
if ( _Chain_Has_only_one_node( ready ) ) {
10f83c: 8b 03 mov (%ebx),%eax
10f83e: 3b 43 08 cmp 0x8(%ebx),%eax
10f841: 74 35 je 10f878 <_Thread_Reset_timeslice+0x50>
10f843: 8b 11 mov (%ecx),%edx
10f845: 8b 41 04 mov 0x4(%ecx),%eax
10f848: 89 42 04 mov %eax,0x4(%edx)
10f84b: 89 10 mov %edx,(%eax)
10f84d: 8d 43 04 lea 0x4(%ebx),%eax
10f850: 89 01 mov %eax,(%ecx)
10f852: 8b 43 08 mov 0x8(%ebx),%eax
10f855: 89 4b 08 mov %ecx,0x8(%ebx)
10f858: 89 08 mov %ecx,(%eax)
10f85a: 89 41 04 mov %eax,0x4(%ecx)
return;
}
_Chain_Extract_unprotected( &executing->Object.Node );
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
10f85d: 56 push %esi
10f85e: 9d popf
10f85f: fa cli
if ( _Thread_Is_heir( executing ) )
10f860: 3b 0d e8 e6 11 00 cmp 0x11e6e8,%ecx
10f866: 74 18 je 10f880 <_Thread_Reset_timeslice+0x58><== ALWAYS TAKEN
_Thread_Heir = (Thread_Control *) ready->first;
_Context_Switch_necessary = TRUE;
10f868: c6 05 2c e7 11 00 01 movb $0x1,0x11e72c
_ISR_Enable( level );
10f86f: 56 push %esi
10f870: 9d popf
}
10f871: 5b pop %ebx
10f872: 5e pop %esi
10f873: c9 leave
10f874: c3 ret
10f875: 8d 76 00 lea 0x0(%esi),%esi
executing = _Thread_Executing;
ready = executing->ready;
_ISR_Disable( level );
if ( _Chain_Has_only_one_node( ready ) ) {
_ISR_Enable( level );
10f878: 56 push %esi
10f879: 9d popf
_Thread_Heir = (Thread_Control *) ready->first;
_Context_Switch_necessary = TRUE;
_ISR_Enable( level );
}
10f87a: 5b pop %ebx
10f87b: 5e pop %esi
10f87c: c9 leave
10f87d: c3 ret
10f87e: 66 90 xchg %ax,%ax
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
if ( _Thread_Is_heir( executing ) )
_Thread_Heir = (Thread_Control *) ready->first;
10f880: 8b 03 mov (%ebx),%eax
10f882: a3 e8 e6 11 00 mov %eax,0x11e6e8
10f887: eb df jmp 10f868 <_Thread_Reset_timeslice+0x40>
0010d56c <_Thread_Restart>:
bool _Thread_Restart(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
10d56c: 55 push %ebp
10d56d: 89 e5 mov %esp,%ebp
10d56f: 53 push %ebx
10d570: 83 ec 04 sub $0x4,%esp
10d573: 8b 5d 08 mov 0x8(%ebp),%ebx
if ( !_States_Is_dormant( the_thread->current_state ) ) {
10d576: f6 43 10 01 testb $0x1,0x10(%ebx)
10d57a: 74 08 je 10d584 <_Thread_Restart+0x18>
10d57c: 31 c0 xor %eax,%eax
return TRUE;
}
return FALSE;
}
10d57e: 8b 5d fc mov -0x4(%ebp),%ebx
10d581: c9 leave
10d582: c3 ret
10d583: 90 nop
Thread_Entry_numeric_type numeric_argument
)
{
if ( !_States_Is_dormant( the_thread->current_state ) ) {
_Thread_Set_transient( the_thread );
10d584: 83 ec 0c sub $0xc,%esp
10d587: 53 push %ebx
10d588: e8 b7 01 00 00 call 10d744 <_Thread_Set_transient>
_Thread_Reset( the_thread, pointer_argument, numeric_argument );
10d58d: 83 c4 0c add $0xc,%esp
10d590: ff 75 10 pushl 0x10(%ebp)
10d593: ff 75 0c pushl 0xc(%ebp)
10d596: 53 push %ebx
10d597: e8 34 2e 00 00 call 1103d0 <_Thread_Reset>
_Thread_Load_environment( the_thread );
10d59c: 89 1c 24 mov %ebx,(%esp)
10d59f: e8 08 2b 00 00 call 1100ac <_Thread_Load_environment>
_Thread_Ready( the_thread );
10d5a4: 89 1c 24 mov %ebx,(%esp)
10d5a7: e8 84 2d 00 00 call 110330 <_Thread_Ready>
_User_extensions_Thread_restart( the_thread );
10d5ac: 89 1c 24 mov %ebx,(%esp)
10d5af: e8 94 06 00 00 call 10dc48 <_User_extensions_Thread_restart>
if ( _Thread_Is_executing ( the_thread ) )
10d5b4: 83 c4 10 add $0x10,%esp
10d5b7: 3b 1d 7c 17 12 00 cmp 0x12177c,%ebx
10d5bd: 74 09 je 10d5c8 <_Thread_Restart+0x5c>
10d5bf: b0 01 mov $0x1,%al
return TRUE;
}
return FALSE;
}
10d5c1: 8b 5d fc mov -0x4(%ebp),%ebx
10d5c4: c9 leave
10d5c5: c3 ret
10d5c6: 66 90 xchg %ax,%ax
* 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
10d5c8: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax
10d5ce: 85 c0 test %eax,%eax
10d5d0: 74 12 je 10d5e4 <_Thread_Restart+0x78>
* @return NULL if unsuccessful and a pointer to the block if successful
10d5d2: 83 ec 0c sub $0xc,%esp
10d5d5: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax
10d5db: 50 push %eax
10d5dc: e8 2d 0a 00 00 call 10e00e <_CPU_Context_restore_fp>
10d5e1: 83 c4 10 add $0x10,%esp
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
10d5e4: 83 ec 0c sub $0xc,%esp
10d5e7: a1 7c 17 12 00 mov 0x12177c,%eax
10d5ec: 05 d4 00 00 00 add $0xd4,%eax
10d5f1: 50 push %eax
10d5f2: e8 06 0a 00 00 call 10dffd <_CPU_Context_restore>
10d5f7: b0 01 mov $0x1,%al <== NOT EXECUTED
10d5f9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10d5fc: eb 80 jmp 10d57e <_Thread_Restart+0x12> <== NOT EXECUTED
0010e02c <_Thread_Resume>:
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
10e02c: 55 push %ebp
10e02d: 89 e5 mov %esp,%ebp
10e02f: 53 push %ebx
10e030: 8b 4d 08 mov 0x8(%ebp),%ecx
10e033: 8a 45 0c mov 0xc(%ebp),%al
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10e036: 9c pushf
10e037: fa cli
10e038: 5b pop %ebx
if ( force == TRUE )
10e039: 84 c0 test %al,%al
10e03b: 74 13 je 10e050 <_Thread_Resume+0x24> <== NEVER TAKEN
the_thread->suspend_count = 0;
10e03d: c7 41 70 00 00 00 00 movl $0x0,0x70(%ecx)
if ( the_thread->suspend_count > 0 ) {
_ISR_Enable( level );
return;
}
current_state = the_thread->current_state;
10e044: 8b 41 10 mov 0x10(%ecx),%eax
if ( current_state & STATES_SUSPENDED ) {
10e047: a8 02 test $0x2,%al
10e049: 75 15 jne 10e060 <_Thread_Resume+0x34> <== ALWAYS TAKEN
_Context_Switch_necessary = TRUE;
}
}
}
_ISR_Enable( level );
10e04b: 53 push %ebx
10e04c: 9d popf
}
10e04d: 5b pop %ebx
10e04e: c9 leave
10e04f: c3 ret
_ISR_Disable( level );
if ( force == TRUE )
the_thread->suspend_count = 0;
else
the_thread->suspend_count--;
10e050: 8b 41 70 mov 0x70(%ecx),%eax <== NOT EXECUTED
10e053: 48 dec %eax <== NOT EXECUTED
10e054: 89 41 70 mov %eax,0x70(%ecx) <== NOT EXECUTED
if ( the_thread->suspend_count > 0 ) {
10e057: 85 c0 test %eax,%eax <== NOT EXECUTED
10e059: 74 e9 je 10e044 <_Thread_Resume+0x18> <== NOT EXECUTED
_ISR_Enable( level );
10e05b: 53 push %ebx <== NOT EXECUTED
10e05c: 9d popf <== NOT EXECUTED
}
}
}
_ISR_Enable( level );
}
10e05d: 5b pop %ebx <== NOT EXECUTED
10e05e: c9 leave <== NOT EXECUTED
10e05f: c3 ret <== NOT EXECUTED
* @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(
10e060: 83 e0 fd and $0xfffffffd,%eax
return;
}
current_state = the_thread->current_state;
if ( current_state & STATES_SUSPENDED ) {
current_state =
10e063: 89 41 10 mov %eax,0x10(%ecx)
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
if ( _States_Is_ready( current_state ) ) {
10e066: 85 c0 test %eax,%eax
10e068: 75 e1 jne 10e04b <_Thread_Resume+0x1f>
* 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
10e06a: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx
10e070: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax
10e077: 66 09 02 or %ax,(%edx)
* @return TRUE if successfully able to determine the size, FALSE otherwise
10e07a: 66 a1 30 a7 12 00 mov 0x12a730,%ax
10e080: 0b 81 94 00 00 00 or 0x94(%ecx),%eax
10e086: 66 a3 30 a7 12 00 mov %ax,0x12a730
_Priority_Add_to_bit_map( &the_thread->Priority_map );
_Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
10e08c: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax
10e092: 8d 50 04 lea 0x4(%eax),%edx
10e095: 89 11 mov %edx,(%ecx)
10e097: 8b 50 08 mov 0x8(%eax),%edx
10e09a: 89 48 08 mov %ecx,0x8(%eax)
10e09d: 89 0a mov %ecx,(%edx)
10e09f: 89 51 04 mov %edx,0x4(%ecx)
_ISR_Flash( level );
10e0a2: 53 push %ebx
10e0a3: 9d popf
10e0a4: fa cli
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
10e0a5: 8b 51 14 mov 0x14(%ecx),%edx
10e0a8: a1 08 a7 12 00 mov 0x12a708,%eax
10e0ad: 3b 50 14 cmp 0x14(%eax),%edx
10e0b0: 73 99 jae 10e04b <_Thread_Resume+0x1f>
_Thread_Heir = the_thread;
10e0b2: 89 0d 08 a7 12 00 mov %ecx,0x12a708
if ( _Thread_Executing->is_preemptible ||
10e0b8: a1 3c a7 12 00 mov 0x12a73c,%eax
10e0bd: 80 78 76 00 cmpb $0x0,0x76(%eax)
10e0c1: 74 0d je 10e0d0 <_Thread_Resume+0xa4>
the_thread->current_priority == 0 )
_Context_Switch_necessary = TRUE;
10e0c3: c6 05 4c a7 12 00 01 movb $0x1,0x12a74c
10e0ca: e9 7c ff ff ff jmp 10e04b <_Thread_Resume+0x1f>
10e0cf: 90 nop
_ISR_Flash( level );
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
10e0d0: 85 d2 test %edx,%edx
10e0d2: 0f 85 73 ff ff ff jne 10e04b <_Thread_Resume+0x1f> <== ALWAYS TAKEN
10e0d8: eb e9 jmp 10e0c3 <_Thread_Resume+0x97> <== NOT EXECUTED
0010cba0 <_Thread_Set_state>:
void _Thread_Set_state(
Thread_Control *the_thread,
States_Control state
)
{
10cba0: 55 push %ebp
10cba1: 89 e5 mov %esp,%ebp
10cba3: 56 push %esi
10cba4: 53 push %ebx
10cba5: 8b 5d 08 mov 0x8(%ebp),%ebx
10cba8: 8b 4d 0c mov 0xc(%ebp),%ecx
ISR_Level level;
Chain_Control *ready;
ready = the_thread->ready;
10cbab: 8b 93 8c 00 00 00 mov 0x8c(%ebx),%edx
_ISR_Disable( level );
10cbb1: 9c pushf
10cbb2: fa cli
10cbb3: 5e pop %esi
if ( !_States_Is_ready( the_thread->current_state ) ) {
10cbb4: 8b 43 10 mov 0x10(%ebx),%eax
10cbb7: 85 c0 test %eax,%eax
10cbb9: 75 2d jne 10cbe8 <_Thread_Set_state+0x48>
_States_Set( state, the_thread->current_state );
_ISR_Enable( level );
return;
}
the_thread->current_state = state;
10cbbb: 89 4b 10 mov %ecx,0x10(%ebx)
if ( _Chain_Has_only_one_node( ready ) ) {
10cbbe: 8b 02 mov (%edx),%eax
10cbc0: 3b 42 08 cmp 0x8(%edx),%eax
10cbc3: 74 2f je 10cbf4 <_Thread_Set_state+0x54>
10cbc5: 8b 13 mov (%ebx),%edx
10cbc7: 8b 43 04 mov 0x4(%ebx),%eax
10cbca: 89 42 04 mov %eax,0x4(%edx)
10cbcd: 89 10 mov %edx,(%eax)
_Priority_Remove_from_bit_map( &the_thread->Priority_map );
} else
_Chain_Extract_unprotected( &the_thread->Object.Node );
_ISR_Flash( level );
10cbcf: 56 push %esi
10cbd0: 9d popf
10cbd1: fa cli
if ( _Thread_Is_heir( the_thread ) )
10cbd2: 3b 1d e8 e6 11 00 cmp 0x11e6e8,%ebx
10cbd8: 74 62 je 10cc3c <_Thread_Set_state+0x9c>
_Thread_Calculate_heir();
if ( _Thread_Is_executing( the_thread ) )
10cbda: 3b 1d 1c e7 11 00 cmp 0x11e71c,%ebx
10cbe0: 74 4e je 10cc30 <_Thread_Set_state+0x90>
_Context_Switch_necessary = TRUE;
_ISR_Enable( level );
10cbe2: 56 push %esi
10cbe3: 9d popf
}
10cbe4: 5b pop %ebx
10cbe5: 5e pop %esi
10cbe6: c9 leave
10cbe7: c3 ret
Chain_Control *ready;
ready = the_thread->ready;
_ISR_Disable( level );
if ( !_States_Is_ready( the_thread->current_state ) ) {
the_thread->current_state =
10cbe8: 09 c1 or %eax,%ecx
10cbea: 89 4b 10 mov %ecx,0x10(%ebx)
_States_Set( state, the_thread->current_state );
_ISR_Enable( level );
10cbed: 56 push %esi
10cbee: 9d popf
if ( _Thread_Is_executing( the_thread ) )
_Context_Switch_necessary = TRUE;
_ISR_Enable( level );
}
10cbef: 5b pop %ebx
10cbf0: 5e pop %esi
10cbf1: c9 leave
10cbf2: c3 ret
10cbf3: 90 nop
10cbf4: 8d 42 04 lea 0x4(%edx),%eax
10cbf7: 89 02 mov %eax,(%edx)
10cbf9: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
10cc00: 89 52 08 mov %edx,0x8(%edx)
/**
* This function tries to resize in place the block that is pointed to by the
* @a starting_address to the new @a size.
*
* @param[in] the_heap is the heap to operate upon
10cc03: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax
10cc09: 66 8b 93 9a 00 00 00 mov 0x9a(%ebx),%dx
10cc10: 66 21 10 and %dx,(%eax)
* @param[in] starting_address is the starting address of the user block
10cc13: 66 83 38 00 cmpw $0x0,(%eax)
10cc17: 75 b6 jne 10cbcf <_Thread_Set_state+0x2f>
* to be resized
10cc19: 66 a1 10 e7 11 00 mov 0x11e710,%ax
10cc1f: 23 83 98 00 00 00 and 0x98(%ebx),%eax
10cc25: 66 a3 10 e7 11 00 mov %ax,0x11e710
10cc2b: eb a2 jmp 10cbcf <_Thread_Set_state+0x2f>
10cc2d: 8d 76 00 lea 0x0(%esi),%esi
if ( _Thread_Is_heir( the_thread ) )
_Thread_Calculate_heir();
if ( _Thread_Is_executing( the_thread ) )
_Context_Switch_necessary = TRUE;
10cc30: c6 05 2c e7 11 00 01 movb $0x1,0x11e72c
10cc37: eb a9 jmp 10cbe2 <_Thread_Set_state+0x42>
10cc39: 8d 76 00 lea 0x0(%esi),%esi
void *starting_address,
size_t size
);
/**
* This routine returns the block of memory which begins
10cc3c: 66 8b 0d 10 e7 11 00 mov 0x11e710,%cx
10cc43: 31 d2 xor %edx,%edx
10cc45: 89 d0 mov %edx,%eax
10cc47: 66 0f bc c1 bsf %cx,%ax
* at @a starting_address to @a the_heap. Any coalescing which is
10cc4b: 0f b7 c0 movzwl %ax,%eax
10cc4e: 66 8b 8c 00 a0 e7 11 mov 0x11e7a0(%eax,%eax,1),%cx
10cc55: 00
10cc56: 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.
10cc5a: c1 e0 04 shl $0x4,%eax
10cc5d: 0f b7 d2 movzwl %dx,%edx
10cc60: 01 d0 add %edx,%eax
10cc62: 8d 04 40 lea (%eax,%eax,2),%eax
10cc65: 8b 15 20 e6 11 00 mov 0x11e620,%edx
10cc6b: 8b 04 82 mov (%edx,%eax,4),%eax
10cc6e: a3 e8 e6 11 00 mov %eax,0x11e6e8
10cc73: e9 62 ff ff ff jmp 10cbda <_Thread_Set_state+0x3a>
0010ccec <_Thread_Stack_Allocate>:
size_t _Thread_Stack_Allocate(
Thread_Control *the_thread,
size_t stack_size
)
{
10ccec: 55 push %ebp
10cced: 89 e5 mov %esp,%ebp
10ccef: 53 push %ebx
10ccf0: 83 ec 04 sub $0x4,%esp
10ccf3: a1 10 a1 11 00 mov 0x11a110,%eax
10ccf8: 8b 5d 0c mov 0xc(%ebp),%ebx
10ccfb: 39 c3 cmp %eax,%ebx
10ccfd: 73 02 jae 10cd01 <_Thread_Stack_Allocate+0x15>
10ccff: 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 ) {
10cd01: a1 f4 e6 11 00 mov 0x11e6f4,%eax
10cd06: 8b 40 20 mov 0x20(%eax),%eax
10cd09: 85 c0 test %eax,%eax
10cd0b: 74 33 je 10cd40 <_Thread_Stack_Allocate+0x54><== ALWAYS TAKEN
stack_addr = (*_Configuration_Table->stack_allocate_hook)( the_stack_size );
10cd0d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10cd10: 53 push %ebx <== NOT EXECUTED
10cd11: ff d0 call *%eax <== NOT EXECUTED
10cd13: 89 c2 mov %eax,%edx <== NOT EXECUTED
10cd15: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
the_stack_size = _Stack_Adjust_size( the_stack_size );
stack_addr = _Workspace_Allocate( the_stack_size );
}
if ( !stack_addr )
10cd18: 85 d2 test %edx,%edx
10cd1a: 74 10 je 10cd2c <_Thread_Stack_Allocate+0x40>
the_stack_size = 0;
the_thread->Start.stack = stack_addr;
10cd1c: 8b 45 08 mov 0x8(%ebp),%eax
10cd1f: 89 90 d0 00 00 00 mov %edx,0xd0(%eax)
return the_stack_size;
}
10cd25: 89 d8 mov %ebx,%eax
10cd27: 8b 5d fc mov -0x4(%ebp),%ebx
10cd2a: c9 leave
10cd2b: c3 ret
the_stack_size = _Stack_Adjust_size( the_stack_size );
stack_addr = _Workspace_Allocate( the_stack_size );
}
if ( !stack_addr )
10cd2c: 31 db xor %ebx,%ebx
the_stack_size = 0;
the_thread->Start.stack = stack_addr;
10cd2e: 8b 45 08 mov 0x8(%ebp),%eax
10cd31: 89 90 d0 00 00 00 mov %edx,0xd0(%eax)
return the_stack_size;
}
10cd37: 89 d8 mov %ebx,%eax
10cd39: 8b 5d fc mov -0x4(%ebp),%ebx
10cd3c: c9 leave
10cd3d: c3 ret
10cd3e: 66 90 xchg %ax,%ax
* 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 );
10cd40: 83 ec 0c sub $0xc,%esp
10cd43: 53 push %ebx
10cd44: e8 d7 06 00 00 call 10d420 <_Workspace_Allocate>
10cd49: 89 c2 mov %eax,%edx
10cd4b: 83 c4 10 add $0x10,%esp
10cd4e: eb c8 jmp 10cd18 <_Thread_Stack_Allocate+0x2c>
0010cd50 <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
10cd50: 55 push %ebp
10cd51: 89 e5 mov %esp,%ebp
10cd53: 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 )
10cd56: 80 ba c0 00 00 00 00 cmpb $0x0,0xc0(%edx)
10cd5d: 74 19 je 10cd78 <_Thread_Stack_Free+0x28><== 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 )
10cd5f: a1 f4 e6 11 00 mov 0x11e6f4,%eax
10cd64: 8b 48 24 mov 0x24(%eax),%ecx
10cd67: 85 c9 test %ecx,%ecx
10cd69: 74 11 je 10cd7c <_Thread_Stack_Free+0x2c><== ALWAYS TAKEN
(*_Configuration_Table->stack_free_hook)(
10cd6b: 8b 82 c8 00 00 00 mov 0xc8(%edx),%eax <== NOT EXECUTED
10cd71: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
the_thread->Start.Initial_stack.area
);
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
10cd74: 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)(
10cd75: ff e1 jmp *%ecx <== NOT EXECUTED
10cd77: 90 nop <== NOT EXECUTED
the_thread->Start.Initial_stack.area
);
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
10cd78: c9 leave <== NOT EXECUTED
10cd79: c3 ret <== NOT EXECUTED
10cd7a: 66 90 xchg %ax,%ax <== NOT EXECUTED
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 );
10cd7c: 8b 82 c8 00 00 00 mov 0xc8(%edx),%eax
10cd82: 89 45 08 mov %eax,0x8(%ebp)
}
10cd85: 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 );
10cd86: e9 7d 06 00 00 jmp 10d408 <_Workspace_Free>
0010e3f0 <_Thread_Suspend>:
*/
void _Thread_Suspend(
Thread_Control *the_thread
)
{
10e3f0: 55 push %ebp
10e3f1: 89 e5 mov %esp,%ebp
10e3f3: 56 push %esi
10e3f4: 53 push %ebx
10e3f5: 8b 4d 08 mov 0x8(%ebp),%ecx
ISR_Level level;
Chain_Control *ready;
ready = the_thread->ready;
10e3f8: 8b 91 8c 00 00 00 mov 0x8c(%ecx),%edx
_ISR_Disable( level );
10e3fe: 9c pushf
10e3ff: fa cli
10e400: 5b pop %ebx
the_thread->suspend_count++;
10e401: ff 41 70 incl 0x70(%ecx)
if ( !_States_Is_ready( the_thread->current_state ) ) {
10e404: 8b 41 10 mov 0x10(%ecx),%eax
10e407: 85 c0 test %eax,%eax
10e409: 75 31 jne 10e43c <_Thread_Suspend+0x4c>
_States_Set( STATES_SUSPENDED, the_thread->current_state );
_ISR_Enable( level );
return;
}
the_thread->current_state = STATES_SUSPENDED;
10e40b: c7 41 10 02 00 00 00 movl $0x2,0x10(%ecx)
if ( _Chain_Has_only_one_node( ready ) ) {
10e412: 8b 02 mov (%edx),%eax
10e414: 3b 42 08 cmp 0x8(%edx),%eax
10e417: 74 2f je 10e448 <_Thread_Suspend+0x58>
10e419: 8b 11 mov (%ecx),%edx
10e41b: 8b 41 04 mov 0x4(%ecx),%eax
10e41e: 89 42 04 mov %eax,0x4(%edx)
10e421: 89 10 mov %edx,(%eax)
_Priority_Remove_from_bit_map( &the_thread->Priority_map );
} else
_Chain_Extract_unprotected( &the_thread->Object.Node );
_ISR_Flash( level );
10e423: 53 push %ebx
10e424: 9d popf
10e425: fa cli
if ( _Thread_Is_heir( the_thread ) )
10e426: 3b 0d 08 a7 12 00 cmp 0x12a708,%ecx
10e42c: 74 62 je 10e490 <_Thread_Suspend+0xa0>
_Thread_Calculate_heir();
if ( _Thread_Is_executing( the_thread ) )
10e42e: 3b 0d 3c a7 12 00 cmp 0x12a73c,%ecx
10e434: 74 4e je 10e484 <_Thread_Suspend+0x94>
_Context_Switch_necessary = TRUE;
_ISR_Enable( level );
10e436: 53 push %ebx
10e437: 9d popf
}
10e438: 5b pop %ebx
10e439: 5e pop %esi
10e43a: c9 leave
10e43b: c3 ret
ready = the_thread->ready;
_ISR_Disable( level );
the_thread->suspend_count++;
if ( !_States_Is_ready( the_thread->current_state ) ) {
the_thread->current_state =
10e43c: 83 c8 02 or $0x2,%eax
10e43f: 89 41 10 mov %eax,0x10(%ecx)
_States_Set( STATES_SUSPENDED, the_thread->current_state );
_ISR_Enable( level );
10e442: 53 push %ebx
10e443: 9d popf
if ( _Thread_Is_executing( the_thread ) )
_Context_Switch_necessary = TRUE;
_ISR_Enable( level );
}
10e444: 5b pop %ebx
10e445: 5e pop %esi
10e446: c9 leave
10e447: c3 ret
10e448: 8d 42 04 lea 0x4(%edx),%eax
10e44b: 89 02 mov %eax,(%edx)
10e44d: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
10e454: 89 52 08 mov %edx,0x8(%edx)
/**
* This function tries to resize in place the block that is pointed to by the
* @a starting_address to the new @a size.
*
* @param[in] the_heap is the heap to operate upon
10e457: 8b 81 90 00 00 00 mov 0x90(%ecx),%eax
10e45d: 66 8b 91 9a 00 00 00 mov 0x9a(%ecx),%dx
10e464: 66 21 10 and %dx,(%eax)
* @param[in] starting_address is the starting address of the user block
10e467: 66 83 38 00 cmpw $0x0,(%eax)
10e46b: 75 b6 jne 10e423 <_Thread_Suspend+0x33>
* to be resized
10e46d: 66 a1 30 a7 12 00 mov 0x12a730,%ax
10e473: 23 81 98 00 00 00 and 0x98(%ecx),%eax
10e479: 66 a3 30 a7 12 00 mov %ax,0x12a730
10e47f: eb a2 jmp 10e423 <_Thread_Suspend+0x33>
10e481: 8d 76 00 lea 0x0(%esi),%esi
if ( _Thread_Is_heir( the_thread ) )
_Thread_Calculate_heir();
if ( _Thread_Is_executing( the_thread ) )
_Context_Switch_necessary = TRUE;
10e484: c6 05 4c a7 12 00 01 movb $0x1,0x12a74c
10e48b: eb a9 jmp 10e436 <_Thread_Suspend+0x46>
10e48d: 8d 76 00 lea 0x0(%esi),%esi
void *starting_address,
size_t size
);
/**
* This routine returns the block of memory which begins
10e490: 66 8b 35 30 a7 12 00 mov 0x12a730,%si
10e497: 31 d2 xor %edx,%edx
10e499: 89 d0 mov %edx,%eax
10e49b: 66 0f bc c6 bsf %si,%ax
* at @a starting_address to @a the_heap. Any coalescing which is
10e49f: 0f b7 c0 movzwl %ax,%eax
10e4a2: 66 8b b4 00 c0 a7 12 mov 0x12a7c0(%eax,%eax,1),%si
10e4a9: 00
10e4aa: 66 0f bc d6 bsf %si,%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.
10e4ae: c1 e0 04 shl $0x4,%eax
10e4b1: 0f b7 d2 movzwl %dx,%edx
10e4b4: 01 d0 add %edx,%eax
10e4b6: 8d 04 40 lea (%eax,%eax,2),%eax
10e4b9: 8b 15 40 a6 12 00 mov 0x12a640,%edx
10e4bf: 8b 04 82 mov (%edx,%eax,4),%eax
10e4c2: a3 08 a7 12 00 mov %eax,0x12a708
10e4c7: e9 62 ff ff ff jmp 10e42e <_Thread_Suspend+0x3e>
0010ce48 <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
10ce48: 55 push %ebp
10ce49: 89 e5 mov %esp,%ebp
10ce4b: 53 push %ebx
10ce4c: 83 ec 04 sub $0x4,%esp
Thread_Control *executing;
executing = _Thread_Executing;
10ce4f: 8b 1d 1c e7 11 00 mov 0x11e71c,%ebx
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
10ce55: 80 7b 76 00 cmpb $0x0,0x76(%ebx)
10ce59: 74 19 je 10ce74 <_Thread_Tickle_timeslice+0x2c>
return;
if ( !_States_Is_ready( executing->current_state ) )
10ce5b: 8b 43 10 mov 0x10(%ebx),%eax
10ce5e: 85 c0 test %eax,%eax
10ce60: 75 12 jne 10ce74 <_Thread_Tickle_timeslice+0x2c>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
10ce62: 8b 43 7c mov 0x7c(%ebx),%eax
10ce65: 83 f8 01 cmp $0x1,%eax
10ce68: 72 0a jb 10ce74 <_Thread_Tickle_timeslice+0x2c>
10ce6a: 83 f8 02 cmp $0x2,%eax
10ce6d: 76 29 jbe 10ce98 <_Thread_Tickle_timeslice+0x50><== ALWAYS TAKEN
10ce6f: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED
10ce72: 74 08 je 10ce7c <_Thread_Tickle_timeslice+0x34><== NOT EXECUTED
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
(*executing->budget_callout)( executing );
break;
}
}
10ce74: 8b 5d fc mov -0x4(%ebp),%ebx
10ce77: c9 leave
10ce78: c3 ret
10ce79: 8d 76 00 lea 0x0(%esi),%esi
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
}
break;
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
10ce7c: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED
10ce7f: 48 dec %eax <== NOT EXECUTED
10ce80: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED
10ce83: 85 c0 test %eax,%eax <== NOT EXECUTED
10ce85: 75 ed jne 10ce74 <_Thread_Tickle_timeslice+0x2c><== NOT EXECUTED
(*executing->budget_callout)( executing );
10ce87: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ce8a: 53 push %ebx <== NOT EXECUTED
10ce8b: ff 93 80 00 00 00 call *0x80(%ebx) <== NOT EXECUTED
10ce91: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ce94: eb de jmp 10ce74 <_Thread_Tickle_timeslice+0x2c><== NOT EXECUTED
10ce96: 66 90 xchg %ax,%ax <== NOT EXECUTED
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 ) {
10ce98: 8b 43 78 mov 0x78(%ebx),%eax
10ce9b: 48 dec %eax
10ce9c: 89 43 78 mov %eax,0x78(%ebx)
10ce9f: 85 c0 test %eax,%eax
10cea1: 7f d1 jg 10ce74 <_Thread_Tickle_timeslice+0x2c>
_Thread_Reset_timeslice();
10cea3: e8 80 29 00 00 call 10f828 <_Thread_Reset_timeslice>
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
10cea8: a1 24 e6 11 00 mov 0x11e624,%eax
10cead: 89 43 78 mov %eax,0x78(%ebx)
10ceb0: eb c2 jmp 10ce74 <_Thread_Tickle_timeslice+0x2c>
0010ceb4 <_Thread_Yield_processor>:
* ready chain
* select heir
*/
void _Thread_Yield_processor( void )
{
10ceb4: 55 push %ebp
10ceb5: 89 e5 mov %esp,%ebp
10ceb7: 56 push %esi
10ceb8: 53 push %ebx
ISR_Level level;
Thread_Control *executing;
Chain_Control *ready;
executing = _Thread_Executing;
10ceb9: 8b 0d 1c e7 11 00 mov 0x11e71c,%ecx
ready = executing->ready;
10cebf: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx
_ISR_Disable( level );
10cec5: 9c pushf
10cec6: fa cli
10cec7: 5e pop %esi
if ( !_Chain_Has_only_one_node( ready ) ) {
10cec8: 8b 03 mov (%ebx),%eax
10ceca: 3b 43 08 cmp 0x8(%ebx),%eax
10cecd: 74 35 je 10cf04 <_Thread_Yield_processor+0x50>
10cecf: 8b 11 mov (%ecx),%edx
10ced1: 8b 41 04 mov 0x4(%ecx),%eax
10ced4: 89 42 04 mov %eax,0x4(%edx)
10ced7: 89 10 mov %edx,(%eax)
10ced9: 8d 43 04 lea 0x4(%ebx),%eax
10cedc: 89 01 mov %eax,(%ecx)
10cede: 8b 43 08 mov 0x8(%ebx),%eax
10cee1: 89 4b 08 mov %ecx,0x8(%ebx)
10cee4: 89 08 mov %ecx,(%eax)
10cee6: 89 41 04 mov %eax,0x4(%ecx)
_Chain_Extract_unprotected( &executing->Object.Node );
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
10cee9: 56 push %esi
10ceea: 9d popf
10ceeb: fa cli
if ( _Thread_Is_heir( executing ) )
10ceec: 3b 0d e8 e6 11 00 cmp 0x11e6e8,%ecx
10cef2: 74 1c je 10cf10 <_Thread_Yield_processor+0x5c><== ALWAYS TAKEN
_Thread_Heir = (Thread_Control *) ready->first;
_Context_Switch_necessary = TRUE;
}
else if ( !_Thread_Is_heir( executing ) )
_Context_Switch_necessary = TRUE;
10cef4: c6 05 2c e7 11 00 01 movb $0x1,0x11e72c
_ISR_Enable( level );
10cefb: 56 push %esi
10cefc: 9d popf
}
10cefd: 5b pop %ebx
10cefe: 5e pop %esi
10ceff: c9 leave
10cf00: c3 ret
10cf01: 8d 76 00 lea 0x0(%esi),%esi
if ( _Thread_Is_heir( executing ) )
_Thread_Heir = (Thread_Control *) ready->first;
_Context_Switch_necessary = TRUE;
}
else if ( !_Thread_Is_heir( executing ) )
10cf04: 3b 0d e8 e6 11 00 cmp 0x11e6e8,%ecx
10cf0a: 75 e8 jne 10cef4 <_Thread_Yield_processor+0x40><== NEVER TAKEN
10cf0c: eb ed jmp 10cefb <_Thread_Yield_processor+0x47>
10cf0e: 66 90 xchg %ax,%ax
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
if ( _Thread_Is_heir( executing ) )
_Thread_Heir = (Thread_Control *) ready->first;
10cf10: 8b 03 mov (%ebx),%eax
10cf12: a3 e8 e6 11 00 mov %eax,0x11e6e8
10cf17: eb db jmp 10cef4 <_Thread_Yield_processor+0x40>
0010f58c <_Thread_queue_Dequeue_fifo>:
*/
Thread_Control *_Thread_queue_Dequeue_fifo(
Thread_queue_Control *the_thread_queue
)
{
10f58c: 55 push %ebp
10f58d: 89 e5 mov %esp,%ebp
10f58f: 56 push %esi
10f590: 53 push %ebx
10f591: 8b 4d 08 mov 0x8(%ebp),%ecx
ISR_Level level;
Thread_Control *the_thread;
_ISR_Disable( level );
10f594: 9c pushf
10f595: fa cli
10f596: 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(
10f597: 8b 11 mov (%ecx),%edx
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) {
10f599: 8d 41 04 lea 0x4(%ecx),%eax
10f59c: 39 c2 cmp %eax,%edx
10f59e: 74 62 je 10f602 <_Thread_queue_Dequeue_fifo+0x76>
10f5a0: 8b 02 mov (%edx),%eax
10f5a2: 89 01 mov %eax,(%ecx)
10f5a4: 89 48 04 mov %ecx,0x4(%eax)
the_thread = (Thread_Control *)
10f5a7: 89 d3 mov %edx,%ebx
_Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo );
the_thread->Wait.queue = NULL;
10f5a9: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10f5b0: 83 7a 50 02 cmpl $0x2,0x50(%edx)
10f5b4: 74 1e je 10f5d4 <_Thread_queue_Dequeue_fifo+0x48>
_ISR_Enable( level );
10f5b6: 56 push %esi
10f5b7: 9d popf
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
10f5b8: 83 ec 08 sub $0x8,%esp
10f5bb: 68 f8 ff 03 10 push $0x1003fff8
10f5c0: 52 push %edx
10f5c1: e8 7e c9 ff ff call 10bf44 <_Thread_Clear_state>
10f5c6: 83 c4 10 add $0x10,%esp
return the_thread;
}
_ISR_Enable( level );
return NULL;
}
10f5c9: 89 d8 mov %ebx,%eax
10f5cb: 8d 65 f8 lea -0x8(%ebp),%esp
10f5ce: 5b pop %ebx
10f5cf: 5e pop %esi
10f5d0: c9 leave
10f5d1: c3 ret
10f5d2: 66 90 xchg %ax,%ax
* 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
*/
10f5d4: c7 42 50 03 00 00 00 movl $0x3,0x50(%edx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
10f5db: 56 push %esi
10f5dc: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
10f5dd: 83 ec 0c sub $0xc,%esp
10f5e0: 8d 42 48 lea 0x48(%edx),%eax
10f5e3: 50 push %eax
10f5e4: e8 43 dd ff ff call 10d32c <_Watchdog_Remove>
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
10f5e9: 58 pop %eax
10f5ea: 5a pop %edx
10f5eb: 68 f8 ff 03 10 push $0x1003fff8
10f5f0: 53 push %ebx
10f5f1: e8 4e c9 ff ff call 10bf44 <_Thread_Clear_state>
10f5f6: 83 c4 10 add $0x10,%esp
return the_thread;
}
_ISR_Enable( level );
return NULL;
}
10f5f9: 89 d8 mov %ebx,%eax
10f5fb: 8d 65 f8 lea -0x8(%ebp),%esp
10f5fe: 5b pop %ebx
10f5ff: 5e pop %esi
10f600: c9 leave
10f601: c3 ret
#endif
return the_thread;
}
_ISR_Enable( level );
10f602: 56 push %esi
10f603: 9d popf
10f604: 31 db xor %ebx,%ebx
10f606: eb c1 jmp 10f5c9 <_Thread_queue_Dequeue_fifo+0x3d>
0010c6c0 <_Thread_queue_Dequeue_priority>:
*/
Thread_Control *_Thread_queue_Dequeue_priority(
Thread_queue_Control *the_thread_queue
)
{
10c6c0: 55 push %ebp
10c6c1: 89 e5 mov %esp,%ebp
10c6c3: 57 push %edi
10c6c4: 56 push %esi
10c6c5: 53 push %ebx
10c6c6: 83 ec 0c sub $0xc,%esp
10c6c9: 8b 75 08 mov 0x8(%ebp),%esi
Chain_Node *new_second_node;
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
10c6cc: 9c pushf
10c6cd: fa cli
10c6ce: 5f pop %edi
10c6cf: 31 d2 xor %edx,%edx
10c6d1: 31 c9 xor %ecx,%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(
10c6d3: 8b 1c 0e mov (%esi,%ecx,1),%ebx
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
10c6d6: 8d 04 52 lea (%edx,%edx,2),%eax
10c6d9: 8d 44 86 04 lea 0x4(%esi,%eax,4),%eax
10c6dd: 39 c3 cmp %eax,%ebx
10c6df: 75 1f jne 10c700 <_Thread_queue_Dequeue_priority+0x40>
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
10c6e1: 42 inc %edx
10c6e2: 83 c1 0c add $0xc,%ecx
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
10c6e5: 83 fa 04 cmp $0x4,%edx
10c6e8: 75 e9 jne 10c6d3 <_Thread_queue_Dequeue_priority+0x13>
}
/*
* We did not find a thread to unblock.
*/
_ISR_Enable( level );
10c6ea: 57 push %edi
10c6eb: 9d popf
10c6ec: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp)
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
10c6f3: 8b 45 e8 mov -0x18(%ebp),%eax
10c6f6: 8d 65 f4 lea -0xc(%ebp),%esp
10c6f9: 5b pop %ebx
10c6fa: 5e pop %esi
10c6fb: 5f pop %edi
10c6fc: c9 leave
10c6fd: c3 ret
10c6fe: 66 90 xchg %ax,%ax
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
the_thread = (Thread_Control *)
10c700: 89 5d e8 mov %ebx,-0x18(%ebp)
*/
_ISR_Enable( level );
return NULL;
dequeue:
the_thread->Wait.queue = NULL;
10c703: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
new_first_node = the_thread->Wait.Block2n.first;
10c70a: 8b 53 38 mov 0x38(%ebx),%edx
new_first_thread = (Thread_Control *) new_first_node;
next_node = the_thread->Object.Node.next;
10c70d: 8b 33 mov (%ebx),%esi
previous_node = the_thread->Object.Node.previous;
10c70f: 8b 4b 04 mov 0x4(%ebx),%ecx
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
10c712: 8d 43 3c lea 0x3c(%ebx),%eax
10c715: 39 c2 cmp %eax,%edx
10c717: 0f 84 85 00 00 00 je 10c7a2 <_Thread_queue_Dequeue_priority+0xe2>
last_node = the_thread->Wait.Block2n.last;
10c71d: 8b 43 40 mov 0x40(%ebx),%eax
10c720: 89 45 f0 mov %eax,-0x10(%ebp)
new_second_node = new_first_node->next;
10c723: 8b 02 mov (%edx),%eax
10c725: 89 45 ec mov %eax,-0x14(%ebp)
previous_node->next = new_first_node;
10c728: 89 11 mov %edx,(%ecx)
next_node->previous = new_first_node;
10c72a: 89 56 04 mov %edx,0x4(%esi)
new_first_node->next = next_node;
10c72d: 89 32 mov %esi,(%edx)
new_first_node->previous = previous_node;
10c72f: 89 4a 04 mov %ecx,0x4(%edx)
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
10c732: 8b 43 38 mov 0x38(%ebx),%eax
10c735: 3b 43 40 cmp 0x40(%ebx),%eax
10c738: 74 1a je 10c754 <_Thread_queue_Dequeue_priority+0x94>
/* > two threads on 2-n */
new_second_node->previous =
10c73a: 8d 42 38 lea 0x38(%edx),%eax
10c73d: 8b 4d ec mov -0x14(%ebp),%ecx
10c740: 89 41 04 mov %eax,0x4(%ecx)
_Chain_Head( &new_first_thread->Wait.Block2n );
new_first_thread->Wait.Block2n.first = new_second_node;
10c743: 89 4a 38 mov %ecx,0x38(%edx)
new_first_thread->Wait.Block2n.last = last_node;
10c746: 8b 45 f0 mov -0x10(%ebp),%eax
10c749: 89 42 40 mov %eax,0x40(%edx)
last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
10c74c: 8d 42 3c lea 0x3c(%edx),%eax
10c74f: 8b 55 f0 mov -0x10(%ebp),%edx
10c752: 89 02 mov %eax,(%edx)
} else {
previous_node->next = next_node;
next_node->previous = previous_node;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10c754: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10c758: 74 1e je 10c778 <_Thread_queue_Dequeue_priority+0xb8>
_ISR_Enable( level );
10c75a: 57 push %edi
10c75b: 9d popf
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
10c75c: 83 ec 08 sub $0x8,%esp
10c75f: 68 f8 ff 03 10 push $0x1003fff8
10c764: 53 push %ebx
10c765: e8 da f7 ff ff call 10bf44 <_Thread_Clear_state>
10c76a: 83 c4 10 add $0x10,%esp
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
10c76d: 8b 45 e8 mov -0x18(%ebp),%eax
10c770: 8d 65 f4 lea -0xc(%ebp),%esp
10c773: 5b pop %ebx
10c774: 5e pop %esi
10c775: 5f pop %edi
10c776: c9 leave
10c777: c3 ret
* 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
*/
10c778: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
10c77f: 57 push %edi
10c780: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
10c781: 83 ec 0c sub $0xc,%esp
10c784: 8d 43 48 lea 0x48(%ebx),%eax
10c787: 50 push %eax
10c788: e8 9f 0b 00 00 call 10d32c <_Watchdog_Remove>
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
10c78d: 58 pop %eax
10c78e: 5a pop %edx
10c78f: 68 f8 ff 03 10 push $0x1003fff8
10c794: 53 push %ebx
10c795: e8 aa f7 ff ff call 10bf44 <_Thread_Clear_state>
10c79a: 83 c4 10 add $0x10,%esp
10c79d: e9 51 ff ff ff jmp 10c6f3 <_Thread_queue_Dequeue_priority+0x33>
new_first_thread->Wait.Block2n.last = last_node;
last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
}
} else {
previous_node->next = next_node;
10c7a2: 89 31 mov %esi,(%ecx)
next_node->previous = previous_node;
10c7a4: 89 4e 04 mov %ecx,0x4(%esi)
10c7a7: eb ab jmp 10c754 <_Thread_queue_Dequeue_priority+0x94>
0010c844 <_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
)
{
10c844: 55 push %ebp
10c845: 89 e5 mov %esp,%ebp
10c847: 57 push %edi
10c848: 56 push %esi
10c849: 53 push %ebx
10c84a: 83 ec 0c sub $0xc,%esp
10c84d: 8b 45 0c mov 0xc(%ebp),%eax
10c850: 83 c0 3c add $0x3c,%eax
10c853: 8b 55 0c mov 0xc(%ebp),%edx
10c856: 89 42 38 mov %eax,0x38(%edx)
10c859: c7 42 3c 00 00 00 00 movl $0x0,0x3c(%edx)
10c860: 89 d0 mov %edx,%eax
10c862: 83 c0 38 add $0x38,%eax
10c865: 89 42 40 mov %eax,0x40(%edx)
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
10c868: 8b 5a 14 mov 0x14(%edx),%ebx
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.
10c86b: 89 d8 mov %ebx,%eax
10c86d: c1 e8 06 shr $0x6,%eax
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
10c870: 8b 4d 08 mov 0x8(%ebp),%ecx
10c873: 8b 49 38 mov 0x38(%ecx),%ecx
10c876: 89 4d f0 mov %ecx,-0x10(%ebp)
if ( _Thread_queue_Is_reverse_search( priority ) )
10c879: f6 c3 20 test $0x20,%bl
10c87c: 75 66 jne 10c8e4 <_Thread_queue_Enqueue_priority+0xa0>
* @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
10c87e: 8d 04 40 lea (%eax,%eax,2),%eax
10c881: c1 e0 02 shl $0x2,%eax
10c884: 8b 55 08 mov 0x8(%ebp),%edx
10c887: 8d 7c 02 04 lea 0x4(%edx,%eax,1),%edi
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
10c88b: 89 45 e8 mov %eax,-0x18(%ebp)
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
10c88e: 9c pushf
10c88f: fa cli
10c890: 5e pop %esi
search_thread = (Thread_Control *) header->first;
10c891: 8b 45 e8 mov -0x18(%ebp),%eax
10c894: 8b 4d 08 mov 0x8(%ebp),%ecx
10c897: 8b 14 08 mov (%eax,%ecx,1),%edx
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
10c89a: 39 fa cmp %edi,%edx
10c89c: 75 1b jne 10c8b9 <_Thread_queue_Enqueue_priority+0x75>
10c89e: e9 1a 01 00 00 jmp 10c9bd <_Thread_queue_Enqueue_priority+0x179>
10c8a3: 90 nop
break;
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
10c8a4: 56 push %esi
10c8a5: 9d popf
10c8a6: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10c8a7: 8b 45 f0 mov -0x10(%ebp),%eax
10c8aa: 85 42 10 test %eax,0x10(%edx)
10c8ad: 0f 84 ad 00 00 00 je 10c960 <_Thread_queue_Enqueue_priority+0x11c><== NEVER TAKEN
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
10c8b3: 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 ) ) {
10c8b5: 39 fa cmp %edi,%edx
10c8b7: 74 07 je 10c8c0 <_Thread_queue_Enqueue_priority+0x7c>
search_priority = search_thread->current_priority;
10c8b9: 8b 4a 14 mov 0x14(%edx),%ecx
if ( priority <= search_priority )
10c8bc: 39 cb cmp %ecx,%ebx
10c8be: 77 e4 ja 10c8a4 <_Thread_queue_Enqueue_priority+0x60>
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 ) ) {
10c8c0: 89 d7 mov %edx,%edi
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
10c8c2: 8b 45 08 mov 0x8(%ebp),%eax
10c8c5: 83 78 30 01 cmpl $0x1,0x30(%eax)
10c8c9: 0f 84 99 00 00 00 je 10c968 <_Thread_queue_Enqueue_priority+0x124><== ALWAYS TAKEN
* 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;
10c8cf: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
10c8d2: 89 30 mov %esi,(%eax) <== NOT EXECUTED
return the_thread_queue->sync_state;
10c8d4: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
10c8d7: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED
}
10c8da: 83 c4 0c add $0xc,%esp
10c8dd: 5b pop %ebx
10c8de: 5e pop %esi
10c8df: 5f pop %edi
10c8e0: c9 leave
10c8e1: c3 ret
10c8e2: 66 90 xchg %ax,%ax
the_node->previous = previous_node;
previous_node->next = the_node;
search_node->previous = the_node;
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10c8e4: 8d 04 40 lea (%eax,%eax,2),%eax
10c8e7: 8b 55 08 mov 0x8(%ebp),%edx
10c8ea: 8d 0c 82 lea (%edx,%eax,4),%ecx
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
10c8ed: 8d 79 08 lea 0x8(%ecx),%edi
10c8f0: 89 7d ec mov %edi,-0x14(%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;
10c8f3: 0f b6 05 14 a1 11 00 movzbl 0x11a114,%eax
10c8fa: 40 inc %eax
_ISR_Disable( level );
10c8fb: 9c pushf
10c8fc: fa cli
10c8fd: 5e pop %esi
search_thread = (Thread_Control *) header->last;
10c8fe: 8b 7d ec mov -0x14(%ebp),%edi
10c901: 8b 17 mov (%edi),%edx
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
10c903: 39 d1 cmp %edx,%ecx
10c905: 75 17 jne 10c91e <_Thread_queue_Enqueue_priority+0xda>
10c907: eb 1c jmp 10c925 <_Thread_queue_Enqueue_priority+0xe1>
10c909: 8d 76 00 lea 0x0(%esi),%esi
break;
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
10c90c: 56 push %esi
10c90d: 9d popf
10c90e: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10c90f: 8b 7d f0 mov -0x10(%ebp),%edi
10c912: 85 7a 10 test %edi,0x10(%edx)
10c915: 74 45 je 10c95c <_Thread_queue_Enqueue_priority+0x118><== NEVER TAKEN
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
10c917: 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 ) ) {
10c91a: 39 ca cmp %ecx,%edx
10c91c: 74 07 je 10c925 <_Thread_queue_Enqueue_priority+0xe1>
search_priority = search_thread->current_priority;
10c91e: 8b 42 14 mov 0x14(%edx),%eax
if ( priority >= search_priority )
10c921: 39 c3 cmp %eax,%ebx
10c923: 72 e7 jb 10c90c <_Thread_queue_Enqueue_priority+0xc8>
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 ) ) {
10c925: 89 d7 mov %edx,%edi
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
10c927: 8b 4d 08 mov 0x8(%ebp),%ecx
10c92a: 83 79 30 01 cmpl $0x1,0x30(%ecx)
10c92e: 75 9f jne 10c8cf <_Thread_queue_Enqueue_priority+0x8b><== NEVER TAKEN
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10c930: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx)
if ( priority == search_priority )
10c937: 39 c3 cmp %eax,%ebx
10c939: 74 5d je 10c998 <_Thread_queue_Enqueue_priority+0x154>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
10c93b: 8b 02 mov (%edx),%eax
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
10c93d: 8b 7d 0c mov 0xc(%ebp),%edi
10c940: 89 07 mov %eax,(%edi)
the_node->previous = search_node;
10c942: 89 57 04 mov %edx,0x4(%edi)
search_node->next = the_node;
10c945: 89 3a mov %edi,(%edx)
next_node->previous = the_node;
10c947: 89 78 04 mov %edi,0x4(%eax)
the_thread->Wait.queue = the_thread_queue;
10c94a: 89 4f 44 mov %ecx,0x44(%edi)
_ISR_Enable( level );
10c94d: 56 push %esi
10c94e: 9d popf
10c94f: b8 01 00 00 00 mov $0x1,%eax
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
10c954: 83 c4 0c add $0xc,%esp
10c957: 5b pop %ebx
10c958: 5e pop %esi
10c959: 5f pop %edi
10c95a: c9 leave
10c95b: c3 ret
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
_ISR_Enable( level );
10c95c: 56 push %esi <== NOT EXECUTED
10c95d: 9d popf <== NOT EXECUTED
10c95e: eb 93 jmp 10c8f3 <_Thread_queue_Enqueue_priority+0xaf><== NOT EXECUTED
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
_ISR_Enable( level );
10c960: 56 push %esi <== NOT EXECUTED
10c961: 9d popf <== NOT EXECUTED
10c962: e9 27 ff ff ff jmp 10c88e <_Thread_queue_Enqueue_priority+0x4a><== NOT EXECUTED
10c967: 90 nop <== NOT EXECUTED
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10c968: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
if ( priority == search_priority )
10c96f: 39 cb cmp %ecx,%ebx
10c971: 74 25 je 10c998 <_Thread_queue_Enqueue_priority+0x154>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
10c973: 8b 42 04 mov 0x4(%edx),%eax
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
10c976: 8b 4d 0c mov 0xc(%ebp),%ecx
10c979: 89 11 mov %edx,(%ecx)
the_node->previous = previous_node;
10c97b: 89 41 04 mov %eax,0x4(%ecx)
previous_node->next = the_node;
10c97e: 89 08 mov %ecx,(%eax)
search_node->previous = the_node;
10c980: 89 4a 04 mov %ecx,0x4(%edx)
the_thread->Wait.queue = the_thread_queue;
10c983: 8b 7d 08 mov 0x8(%ebp),%edi
10c986: 89 79 44 mov %edi,0x44(%ecx)
_ISR_Enable( level );
10c989: 56 push %esi
10c98a: 9d popf
10c98b: b8 01 00 00 00 mov $0x1,%eax
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
10c990: 83 c4 0c add $0xc,%esp
10c993: 5b pop %ebx
10c994: 5e pop %esi
10c995: 5f pop %edi
10c996: c9 leave
10c997: c3 ret
10c998: 8d 47 3c lea 0x3c(%edi),%eax
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
10c99b: 8b 50 04 mov 0x4(%eax),%edx
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
10c99e: 8b 4d 0c mov 0xc(%ebp),%ecx
10c9a1: 89 01 mov %eax,(%ecx)
the_node->previous = previous_node;
10c9a3: 89 51 04 mov %edx,0x4(%ecx)
previous_node->next = the_node;
10c9a6: 89 0a mov %ecx,(%edx)
search_node->previous = the_node;
10c9a8: 89 48 04 mov %ecx,0x4(%eax)
the_thread->Wait.queue = the_thread_queue;
10c9ab: 8b 7d 08 mov 0x8(%ebp),%edi
10c9ae: 89 79 44 mov %edi,0x44(%ecx)
_ISR_Enable( level );
10c9b1: 56 push %esi
10c9b2: 9d popf
10c9b3: b8 01 00 00 00 mov $0x1,%eax
10c9b8: e9 1d ff ff ff jmp 10c8da <_Thread_queue_Enqueue_priority+0x96>
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 ) ) {
10c9bd: b9 ff ff ff ff mov $0xffffffff,%ecx
10c9c2: e9 fb fe ff ff jmp 10c8c2 <_Thread_queue_Enqueue_priority+0x7e>
0010f64c <_Thread_queue_Extract>:
void _Thread_queue_Extract(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10f64c: 55 push %ebp
10f64d: 89 e5 mov %esp,%ebp
10f64f: 83 ec 08 sub $0x8,%esp
10f652: 8b 45 08 mov 0x8(%ebp),%eax
10f655: 8b 55 0c mov 0xc(%ebp),%edx
/*
* Can not use indirect function pointer here since Extract priority
* is a macro and the underlying methods do not have the same signature.
*/
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
10f658: 83 78 34 01 cmpl $0x1,0x34(%eax)
10f65c: 74 0e je 10f66c <_Thread_queue_Extract+0x20>
_Thread_queue_Extract_priority( the_thread_queue, the_thread );
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
_Thread_queue_Extract_fifo( the_thread_queue, the_thread );
10f65e: 89 55 0c mov %edx,0xc(%ebp)
10f661: 89 45 08 mov %eax,0x8(%ebp)
}
10f664: c9 leave
* is a macro and the underlying methods do not have the same signature.
*/
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
_Thread_queue_Extract_priority( the_thread_queue, the_thread );
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
_Thread_queue_Extract_fifo( the_thread_queue, the_thread );
10f665: e9 ce 0a 00 00 jmp 110138 <_Thread_queue_Extract_fifo>
10f66a: 66 90 xchg %ax,%ax
/*
* Can not use indirect function pointer here since Extract priority
* is a macro and the underlying methods do not have the same signature.
*/
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
_Thread_queue_Extract_priority( the_thread_queue, the_thread );
10f66c: 51 push %ecx
10f66d: 6a 00 push $0x0
10f66f: 52 push %edx
10f670: 50 push %eax
10f671: e8 06 00 00 00 call 10f67c <_Thread_queue_Extract_priority_helper>
10f676: 83 c4 10 add $0x10,%esp
else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
_Thread_queue_Extract_fifo( the_thread_queue, the_thread );
}
10f679: c9 leave
10f67a: c3 ret
00110138 <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
110138: 55 push %ebp
110139: 89 e5 mov %esp,%ebp
11013b: 53 push %ebx
11013c: 83 ec 04 sub $0x4,%esp
11013f: 8b 5d 0c mov 0xc(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
110142: 9c pushf
110143: fa cli
110144: 59 pop %ecx
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
110145: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx)
11014c: 74 2e je 11017c <_Thread_queue_Extract_fifo+0x44><== NEVER TAKEN
11014e: 8b 13 mov (%ebx),%edx
110150: 8b 43 04 mov 0x4(%ebx),%eax
110153: 89 42 04 mov %eax,0x4(%edx)
110156: 89 10 mov %edx,(%eax)
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
110158: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
11015f: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
110163: 74 1f je 110184 <_Thread_queue_Extract_fifo+0x4c>
_ISR_Enable( level );
110165: 51 push %ecx
110166: 9d popf
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
110167: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp)
11016e: 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
}
110171: 8b 5d fc mov -0x4(%ebp),%ebx
110174: c9 leave
110175: e9 ca bd ff ff jmp 10bf44 <_Thread_Clear_state>
11017a: 66 90 xchg %ax,%ax
ISR_Level level;
_ISR_Disable( level );
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
_ISR_Enable( level );
11017c: 51 push %ecx <== NOT EXECUTED
11017d: 9d popf <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
11017e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
110181: c9 leave <== NOT EXECUTED
110182: c3 ret <== NOT EXECUTED
110183: 90 nop <== NOT EXECUTED
* 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
*/
110184: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
11018b: 51 push %ecx
11018c: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
11018d: 83 ec 0c sub $0xc,%esp
110190: 8d 43 48 lea 0x48(%ebx),%eax
110193: 50 push %eax
110194: e8 93 d1 ff ff call 10d32c <_Watchdog_Remove>
110199: 83 c4 10 add $0x10,%esp
11019c: eb c9 jmp 110167 <_Thread_queue_Extract_fifo+0x2f>
0010f67c <_Thread_queue_Extract_priority_helper>:
void _Thread_queue_Extract_priority_helper(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
bool requeuing
)
{
10f67c: 55 push %ebp
10f67d: 89 e5 mov %esp,%ebp
10f67f: 57 push %edi
10f680: 56 push %esi
10f681: 53 push %ebx
10f682: 83 ec 0c sub $0xc,%esp
10f685: 8b 5d 0c mov 0xc(%ebp),%ebx
10f688: 8a 45 10 mov 0x10(%ebp),%al
10f68b: 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 );
10f68e: 9c pushf
10f68f: fa cli
10f690: 8f 45 ec popl -0x14(%ebp)
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10f693: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx)
10f69a: 74 68 je 10f704 <_Thread_queue_Extract_priority_helper+0x88><== NEVER TAKEN
/*
* The thread was actually waiting on a thread queue so let's remove it.
*/
next_node = the_node->next;
10f69c: 8b 33 mov (%ebx),%esi
previous_node = the_node->previous;
10f69e: 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(
10f6a1: 8b 53 38 mov 0x38(%ebx),%edx
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
10f6a4: 8d 43 3c lea 0x3c(%ebx),%eax
10f6a7: 39 c2 cmp %eax,%edx
10f6a9: 74 71 je 10f71c <_Thread_queue_Extract_priority_helper+0xa0>
new_first_node = the_thread->Wait.Block2n.first;
new_first_thread = (Thread_Control *) new_first_node;
last_node = the_thread->Wait.Block2n.last;
10f6ab: 8b 43 40 mov 0x40(%ebx),%eax
10f6ae: 89 45 f0 mov %eax,-0x10(%ebp)
new_second_node = new_first_node->next;
10f6b1: 8b 3a mov (%edx),%edi
previous_node->next = new_first_node;
10f6b3: 89 11 mov %edx,(%ecx)
next_node->previous = new_first_node;
10f6b5: 89 56 04 mov %edx,0x4(%esi)
new_first_node->next = next_node;
10f6b8: 89 32 mov %esi,(%edx)
new_first_node->previous = previous_node;
10f6ba: 89 4a 04 mov %ecx,0x4(%edx)
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
10f6bd: 8b 43 38 mov 0x38(%ebx),%eax
10f6c0: 3b 43 40 cmp 0x40(%ebx),%eax
10f6c3: 74 17 je 10f6dc <_Thread_queue_Extract_priority_helper+0x60>
/* > two threads on 2-n */
new_second_node->previous =
10f6c5: 8d 42 38 lea 0x38(%edx),%eax
10f6c8: 89 47 04 mov %eax,0x4(%edi)
_Chain_Head( &new_first_thread->Wait.Block2n );
new_first_thread->Wait.Block2n.first = new_second_node;
10f6cb: 89 7a 38 mov %edi,0x38(%edx)
new_first_thread->Wait.Block2n.last = last_node;
10f6ce: 8b 45 f0 mov -0x10(%ebp),%eax
10f6d1: 89 42 40 mov %eax,0x40(%edx)
last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
10f6d4: 8d 42 3c lea 0x3c(%edx),%eax
10f6d7: 8b 55 f0 mov -0x10(%ebp),%edx
10f6da: 89 02 mov %eax,(%edx)
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
10f6dc: 80 7d eb 00 cmpb $0x0,-0x15(%ebp)
10f6e0: 75 2e jne 10f710 <_Thread_queue_Extract_priority_helper+0x94>
_ISR_Enable( level );
return;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10f6e2: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10f6e6: 74 3c je 10f724 <_Thread_queue_Extract_priority_helper+0xa8><== NEVER TAKEN
_ISR_Enable( level );
10f6e8: ff 75 ec pushl -0x14(%ebp)
10f6eb: 9d popf
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
10f6ec: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp)
10f6f3: 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
}
10f6f6: 8d 65 f4 lea -0xc(%ebp),%esp
10f6f9: 5b pop %ebx
10f6fa: 5e pop %esi
10f6fb: 5f pop %edi
10f6fc: c9 leave
10f6fd: e9 42 c8 ff ff jmp 10bf44 <_Thread_Clear_state>
10f702: 66 90 xchg %ax,%ax
Chain_Node *last_node;
the_node = (Chain_Node *) the_thread;
_ISR_Disable( level );
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
_ISR_Enable( level );
10f704: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED
10f707: 9d popf <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
10f708: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10f70b: 5b pop %ebx <== NOT EXECUTED
10f70c: 5e pop %esi <== NOT EXECUTED
10f70d: 5f pop %edi <== NOT EXECUTED
10f70e: c9 leave <== NOT EXECUTED
10f70f: c3 ret <== NOT EXECUTED
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
_ISR_Enable( level );
10f710: ff 75 ec pushl -0x14(%ebp)
10f713: 9d popf
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
10f714: 8d 65 f4 lea -0xc(%ebp),%esp
10f717: 5b pop %ebx
10f718: 5e pop %esi
10f719: 5f pop %edi
10f71a: c9 leave
10f71b: c3 ret
new_first_thread->Wait.Block2n.last = last_node;
last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
}
} else {
previous_node->next = next_node;
10f71c: 89 31 mov %esi,(%ecx)
next_node->previous = previous_node;
10f71e: 89 4e 04 mov %ecx,0x4(%esi)
10f721: eb b9 jmp 10f6dc <_Thread_queue_Extract_priority_helper+0x60>
10f723: 90 nop
* 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
*/
10f724: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
10f72b: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED
10f72e: 9d popf <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
10f72f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10f732: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED
10f735: 50 push %eax <== NOT EXECUTED
10f736: e8 f1 db ff ff call 10d32c <_Watchdog_Remove> <== NOT EXECUTED
10f73b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10f73e: eb ac jmp 10f6ec <_Thread_queue_Extract_priority_helper+0x70><== NOT EXECUTED
0010c9c8 <_Thread_queue_Extract_with_proxy>:
*/
bool _Thread_queue_Extract_with_proxy(
Thread_Control *the_thread
)
{
10c9c8: 55 push %ebp
10c9c9: 89 e5 mov %esp,%ebp
10c9cb: 83 ec 08 sub $0x8,%esp
10c9ce: 8b 45 08 mov 0x8(%ebp),%eax
States_Control state;
state = the_thread->current_state;
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10c9d1: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax)
10c9d8: 75 06 jne 10c9e0 <_Thread_queue_Extract_with_proxy+0x18>
10c9da: 31 c0 xor %eax,%eax
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
return TRUE;
}
return FALSE;
}
10c9dc: c9 leave
10c9dd: c3 ret
10c9de: 66 90 xchg %ax,%ax
if ( proxy_extract_callout )
(*proxy_extract_callout)( the_thread );
}
#endif
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
10c9e0: 83 ec 08 sub $0x8,%esp
10c9e3: 50 push %eax
10c9e4: ff 70 44 pushl 0x44(%eax)
10c9e7: e8 60 2c 00 00 call 10f64c <_Thread_queue_Extract>
10c9ec: b0 01 mov $0x1,%al
10c9ee: 83 c4 10 add $0x10,%esp
return TRUE;
}
return FALSE;
}
10c9f1: c9 leave
10c9f2: c3 ret
0011aa6c <_Thread_queue_First_priority>:
*/
Thread_Control *_Thread_queue_First_priority (
Thread_queue_Control *the_thread_queue
)
{
11aa6c: 55 push %ebp
11aa6d: 89 e5 mov %esp,%ebp
11aa6f: 56 push %esi
11aa70: 53 push %ebx
11aa71: 8b 75 08 mov 0x8(%ebp),%esi
11aa74: 31 d2 xor %edx,%edx
11aa76: 31 c9 xor %ecx,%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(
11aa78: 8b 1c 0e mov (%esi,%ecx,1),%ebx
uint32_t index;
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
11aa7b: 8d 04 52 lea (%edx,%edx,2),%eax
11aa7e: 8d 44 86 04 lea 0x4(%esi,%eax,4),%eax
11aa82: 39 c3 cmp %eax,%ebx
11aa84: 75 12 jne 11aa98 <_Thread_queue_First_priority+0x2c>
{
uint32_t index;
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
11aa86: 42 inc %edx
11aa87: 83 c1 0c add $0xc,%ecx
)
{
uint32_t index;
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
11aa8a: 83 fa 04 cmp $0x4,%edx
11aa8d: 75 e9 jne 11aa78 <_Thread_queue_First_priority+0xc>
11aa8f: 31 c0 xor %eax,%eax
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
return (Thread_Control *)
the_thread_queue->Queues.Priority[ index ].first;
}
return NULL;
}
11aa91: 5b pop %ebx
11aa92: 5e pop %esi
11aa93: c9 leave
11aa94: c3 ret
11aa95: 8d 76 00 lea 0x0(%esi),%esi
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
return (Thread_Control *)
11aa98: 89 d8 mov %ebx,%eax
the_thread_queue->Queues.Priority[ index ].first;
}
return NULL;
}
11aa9a: 5b pop %ebx
11aa9b: 5e pop %esi
11aa9c: c9 leave
11aa9d: c3 ret
0010c9f4 <_Thread_queue_Flush>:
void _Thread_queue_Flush(
Thread_queue_Control *the_thread_queue,
Thread_queue_Flush_callout remote_extract_callout,
uint32_t status
)
{
10c9f4: 55 push %ebp
10c9f5: 89 e5 mov %esp,%ebp
10c9f7: 56 push %esi
10c9f8: 53 push %ebx
10c9f9: 8b 75 08 mov 0x8(%ebp),%esi
10c9fc: 8b 5d 10 mov 0x10(%ebp),%ebx
10c9ff: eb 06 jmp 10ca07 <_Thread_queue_Flush+0x13>
10ca01: 8d 76 00 lea 0x0(%esi),%esi
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
( *remote_extract_callout )( the_thread );
else
#endif
the_thread->Wait.return_code = status;
10ca04: 89 58 34 mov %ebx,0x34(%eax)
uint32_t status
)
{
Thread_Control *the_thread;
while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) {
10ca07: 83 ec 0c sub $0xc,%esp
10ca0a: 56 push %esi
10ca0b: e8 60 fc ff ff call 10c670 <_Thread_queue_Dequeue>
10ca10: 83 c4 10 add $0x10,%esp
10ca13: 85 c0 test %eax,%eax
10ca15: 75 ed jne 10ca04 <_Thread_queue_Flush+0x10>
( *remote_extract_callout )( the_thread );
else
#endif
the_thread->Wait.return_code = status;
}
}
10ca17: 8d 65 f8 lea -0x8(%ebp),%esp
10ca1a: 5b pop %ebx
10ca1b: 5e pop %esi
10ca1c: c9 leave
10ca1d: c3 ret
0010f740 <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
10f740: 55 push %ebp
10f741: 89 e5 mov %esp,%ebp
10f743: 83 ec 08 sub $0x8,%esp
10f746: 8b 4d 08 mov 0x8(%ebp),%ecx
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
10f749: 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 &&
10f74c: 8b 42 30 mov 0x30(%edx),%eax
10f74f: 85 c0 test %eax,%eax
10f751: 74 08 je 10f75b <_Thread_queue_Process_timeout+0x1b>
10f753: 3b 0d 1c e7 11 00 cmp 0x11e71c,%ecx
10f759: 74 19 je 10f774 <_Thread_queue_Process_timeout+0x34><== ALWAYS TAKEN
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
10f75b: 8b 42 3c mov 0x3c(%edx),%eax
10f75e: 89 41 34 mov %eax,0x34(%ecx)
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
10f761: 83 ec 08 sub $0x8,%esp
10f764: 51 push %ecx
10f765: ff 71 44 pushl 0x44(%ecx)
10f768: e8 df fe ff ff call 10f64c <_Thread_queue_Extract>
10f76d: 83 c4 10 add $0x10,%esp
}
}
10f770: c9 leave
10f771: c3 ret
10f772: 66 90 xchg %ax,%ax
* a timeout is not allowed to occur.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
10f774: 83 f8 03 cmp $0x3,%eax
10f777: 74 f7 je 10f770 <_Thread_queue_Process_timeout+0x30><== NEVER TAKEN
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
10f779: 8b 42 3c mov 0x3c(%edx),%eax
10f77c: 89 41 34 mov %eax,0x34(%ecx)
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
10f77f: c7 42 30 02 00 00 00 movl $0x2,0x30(%edx)
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
}
}
10f786: c9 leave
10f787: c3 ret
0010caa0 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10caa0: 55 push %ebp
10caa1: 89 e5 mov %esp,%ebp
10caa3: 56 push %esi
10caa4: 53 push %ebx
10caa5: 83 ec 10 sub $0x10,%esp
10caa8: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Just in case the thread really wasn't blocked on a thread queue
* when we get here.
*/
if ( !the_thread_queue )
10caab: 85 db test %ebx,%ebx
10caad: 74 06 je 10cab5 <_Thread_queue_Requeue+0x15><== 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 ) {
10caaf: 83 7b 34 01 cmpl $0x1,0x34(%ebx)
10cab3: 74 07 je 10cabc <_Thread_queue_Requeue+0x1c><== ALWAYS TAKEN
_Thread_queue_Extract_priority_helper( tq, the_thread, TRUE );
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
}
_ISR_Enable( level );
}
}
10cab5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10cab8: 5b pop %ebx <== NOT EXECUTED
10cab9: 5e pop %esi <== NOT EXECUTED
10caba: c9 leave <== NOT EXECUTED
10cabb: c3 ret <== NOT EXECUTED
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
10cabc: 9c pushf
10cabd: fa cli
10cabe: 5e pop %esi
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10cabf: 8b 45 0c mov 0xc(%ebp),%eax
10cac2: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax)
10cac9: 75 09 jne 10cad4 <_Thread_queue_Requeue+0x34><== ALWAYS TAKEN
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, TRUE );
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
}
_ISR_Enable( level );
10cacb: 56 push %esi
10cacc: 9d popf
}
}
10cacd: 8d 65 f8 lea -0x8(%ebp),%esp
10cad0: 5b pop %ebx
10cad1: 5e pop %esi
10cad2: c9 leave
10cad3: 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
10cad4: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx)
ISR_Level level_ignored;
_ISR_Disable( level );
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, TRUE );
10cadb: 52 push %edx
10cadc: 6a 01 push $0x1
10cade: 50 push %eax
10cadf: 53 push %ebx
10cae0: e8 97 2b 00 00 call 10f67c <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
10cae5: 83 c4 0c add $0xc,%esp
10cae8: 8d 45 f4 lea -0xc(%ebp),%eax
10caeb: 50 push %eax
10caec: ff 75 0c pushl 0xc(%ebp)
10caef: 53 push %ebx
10caf0: e8 4f fd ff ff call 10c844 <_Thread_queue_Enqueue_priority>
10caf5: 83 c4 10 add $0x10,%esp
10caf8: eb d1 jmp 10cacb <_Thread_queue_Requeue+0x2b>
0010cafc <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored
)
{
10cafc: 55 push %ebp
10cafd: 89 e5 mov %esp,%ebp
10caff: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10cb02: 8d 45 fc lea -0x4(%ebp),%eax
10cb05: 50 push %eax
10cb06: ff 75 08 pushl 0x8(%ebp)
10cb09: e8 02 f8 ff ff call 10c310 <_Thread_Get>
switch ( location ) {
10cb0e: 83 c4 10 add $0x10,%esp
10cb11: 8b 55 fc mov -0x4(%ebp),%edx
10cb14: 85 d2 test %edx,%edx
10cb16: 75 17 jne 10cb2f <_Thread_queue_Timeout+0x33><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
10cb18: 83 ec 0c sub $0xc,%esp
10cb1b: 50 push %eax
10cb1c: e8 1f 2c 00 00 call 10f740 <_Thread_queue_Process_timeout>
10cb21: a1 58 e6 11 00 mov 0x11e658,%eax
10cb26: 48 dec %eax
10cb27: a3 58 e6 11 00 mov %eax,0x11e658
10cb2c: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10cb2f: c9 leave
10cb30: c3 ret
00114ca0 <_Timer_Server_body>:
* @param[in] ignored is the the task argument that is ignored
*/
Thread _Timer_Server_body(
uint32_t ignored
)
{
114ca0: 55 push %ebp
114ca1: 89 e5 mov %esp,%ebp
114ca3: 57 push %edi
114ca4: 56 push %esi
114ca5: 53 push %ebx
114ca6: 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
114ca9: 8d 7d e8 lea -0x18(%ebp),%edi
114cac: 8d 75 ec lea -0x14(%ebp),%esi
114caf: 89 75 e8 mov %esi,-0x18(%ebp)
114cb2: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
114cb9: 89 7d f0 mov %edi,-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;
114cbc: a1 a4 5b 13 00 mov 0x135ba4,%eax
114cc1: a3 90 59 13 00 mov %eax,0x135990
_Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch;
114cc6: a1 cc 5a 13 00 mov 0x135acc,%eax
114ccb: a3 8c 59 13 00 mov %eax,0x13598c
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
114cd0: a1 38 5a 13 00 mov 0x135a38,%eax
114cd5: 40 inc %eax
114cd6: a3 38 5a 13 00 mov %eax,0x135a38
/*
* 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();
114cdb: e8 60 ff ff ff call 114c40 <_Timer_Server_process_insertions>
_Thread_Enable_dispatch();
114ce0: e8 3f 27 00 00 call 117424 <_Thread_Enable_dispatch>
114ce5: 8d 76 00 lea 0x0(%esi),%esi
114ce8: a1 38 5a 13 00 mov 0x135a38,%eax
114ced: 40 inc %eax
114cee: a3 38 5a 13 00 mov %eax,0x135a38
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( _Timer_Server, STATES_DELAYING );
114cf3: 83 ec 08 sub $0x8,%esp
114cf6: 6a 08 push $0x8
114cf8: ff 35 e4 5d 13 00 pushl 0x135de4
114cfe: e8 19 31 00 00 call 117e1c <_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(
114d03: 8b 15 80 59 13 00 mov 0x135980,%edx
_Timer_Server_reset_ticks_timer();
114d09: 83 c4 10 add $0x10,%esp
114d0c: 81 fa 84 59 13 00 cmp $0x135984,%edx
114d12: 74 1f je 114d33 <_Timer_Server_body+0x93>
114d14: a1 e4 5d 13 00 mov 0x135de4,%eax
Heap_Control *the_heap,
114d19: 8b 52 10 mov 0x10(%edx),%edx
114d1c: 89 50 54 mov %edx,0x54(%eax)
void *starting_address,
size_t *size
114d1f: 83 ec 08 sub $0x8,%esp
114d22: 83 c0 48 add $0x48,%eax
114d25: 50 push %eax
114d26: 68 1c 5b 13 00 push $0x135b1c
114d2b: e8 bc 39 00 00 call 1186ec <_Watchdog_Insert>
114d30: 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(
114d33: a1 94 59 13 00 mov 0x135994,%eax
_Timer_Server_reset_seconds_timer();
114d38: 3d 98 59 13 00 cmp $0x135998,%eax
114d3d: 74 1d je 114d5c <_Timer_Server_body+0xbc>
* @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,
114d3f: 8b 40 10 mov 0x10(%eax),%eax
114d42: a3 cc 59 13 00 mov %eax,0x1359cc
size_t size
);
114d47: 83 ec 08 sub $0x8,%esp
114d4a: 68 c0 59 13 00 push $0x1359c0
114d4f: 68 10 5b 13 00 push $0x135b10
114d54: e8 93 39 00 00 call 1186ec <_Watchdog_Insert>
114d59: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
114d5c: e8 c3 26 00 00 call 117424 <_Thread_Enable_dispatch>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
114d61: a1 38 5a 13 00 mov 0x135a38,%eax
114d66: 40 inc %eax
114d67: a3 38 5a 13 00 mov %eax,0x135a38
/*
* 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();
114d6c: 83 ec 0c sub $0xc,%esp
114d6f: a1 e4 5d 13 00 mov 0x135de4,%eax
114d74: 83 c0 48 add $0x48,%eax
114d77: 50 push %eax
114d78: e8 9f 3a 00 00 call 11881c <_Watchdog_Remove>
_Timer_Server_stop_seconds_timer();
114d7d: c7 04 24 c0 59 13 00 movl $0x1359c0,(%esp)
114d84: e8 93 3a 00 00 call 11881c <_Watchdog_Remove>
)
{
Watchdog_Interval snapshot;
Watchdog_Interval ticks;
snapshot = _Watchdog_Ticks_since_boot;
114d89: 8b 15 a4 5b 13 00 mov 0x135ba4,%edx
if ( snapshot >= _Timer_Server_ticks_last_time )
114d8f: a1 90 59 13 00 mov 0x135990,%eax
114d94: 83 c4 10 add $0x10,%esp
114d97: 39 c2 cmp %eax,%edx
114d99: 72 7d jb 114e18 <_Timer_Server_body+0x178><== NEVER TAKEN
ticks = snapshot - _Timer_Server_ticks_last_time;
114d9b: 89 d1 mov %edx,%ecx
114d9d: 29 c1 sub %eax,%ecx
114d9f: 89 c8 mov %ecx,%eax
else
ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot;
_Timer_Server_ticks_last_time = snapshot;
114da1: 89 15 90 59 13 00 mov %edx,0x135990
_Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire );
114da7: 53 push %ebx
114da8: 57 push %edi
114da9: 50 push %eax
114daa: 68 80 59 13 00 push $0x135980
114daf: e8 a4 38 00 00 call 118658 <_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;
114db4: 8b 1d cc 5a 13 00 mov 0x135acc,%ebx
if ( snapshot > _Timer_Server_seconds_last_time ) {
114dba: a1 8c 59 13 00 mov 0x13598c,%eax
114dbf: 83 c4 10 add $0x10,%esp
114dc2: 39 c3 cmp %eax,%ebx
114dc4: 77 5a ja 114e20 <_Timer_Server_body+0x180>
* TOD has been set forward.
*/
ticks = snapshot - _Timer_Server_seconds_last_time;
_Watchdog_Adjust_to_chain( &_Timer_Seconds_chain, ticks, to_fire );
} else if ( snapshot < _Timer_Server_seconds_last_time ) {
114dc6: 72 70 jb 114e38 <_Timer_Server_body+0x198>
* TOD has been set backwards.
*/
ticks = _Timer_Server_seconds_last_time - snapshot;
_Watchdog_Adjust( &_Timer_Seconds_chain, WATCHDOG_BACKWARD, ticks );
}
_Timer_Server_seconds_last_time = snapshot;
114dc8: 89 1d 8c 59 13 00 mov %ebx,0x13598c
_Timer_Server_process_seconds_chain( &to_fire );
/*
* Insert the timers that have been requested to be inserted.
*/
_Timer_Server_process_insertions();
114dce: e8 6d fe ff ff call 114c40 <_Timer_Server_process_insertions>
/*
* Enable dispatching to process the set that are ready "to fire."
*/
_Thread_Enable_dispatch();
114dd3: e8 4c 26 00 00 call 117424 <_Thread_Enable_dispatch>
*/
while (1) {
Watchdog_Control *watch;
ISR_Level level;
_ISR_Disable( level );
114dd8: 9c pushf
114dd9: fa cli
114dda: 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(
114ddb: 8b 55 e8 mov -0x18(%ebp),%edx
114dde: 39 d6 cmp %edx,%esi
114de0: 74 2c je 114e0e <_Timer_Server_body+0x16e>
114de2: 66 90 xchg %ax,%ax
114de4: 8b 02 mov (%edx),%eax
114de6: 89 45 e8 mov %eax,-0x18(%ebp)
114de9: 89 78 04 mov %edi,0x4(%eax)
if ( watch == NULL ) {
_ISR_Enable( level );
break;
}
watch->state = WATCHDOG_INACTIVE;
114dec: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
_ISR_Enable( level );
114df3: 51 push %ecx
114df4: 9d popf
(*watch->routine)( watch->id, watch->user_data );
114df5: 83 ec 08 sub $0x8,%esp
114df8: ff 72 24 pushl 0x24(%edx)
114dfb: ff 72 20 pushl 0x20(%edx)
114dfe: ff 52 1c call *0x1c(%edx)
*/
while (1) {
Watchdog_Control *watch;
ISR_Level level;
_ISR_Disable( level );
114e01: 9c pushf
114e02: fa cli
114e03: 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(
114e04: 8b 55 e8 mov -0x18(%ebp),%edx
114e07: 83 c4 10 add $0x10,%esp
114e0a: 39 d6 cmp %edx,%esi
114e0c: 75 d6 jne 114de4 <_Timer_Server_body+0x144>
watch = (Watchdog_Control *) _Chain_Get_unprotected( &to_fire );
if ( watch == NULL ) {
_ISR_Enable( level );
114e0e: 51 push %ecx
114e0f: 9d popf
114e10: e9 d3 fe ff ff jmp 114ce8 <_Timer_Server_body+0x48>
114e15: 8d 76 00 lea 0x0(%esi),%esi
snapshot = _Watchdog_Ticks_since_boot;
if ( snapshot >= _Timer_Server_ticks_last_time )
ticks = snapshot - _Timer_Server_ticks_last_time;
else
ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot;
114e18: f7 d0 not %eax <== NOT EXECUTED
114e1a: 01 d0 add %edx,%eax <== NOT EXECUTED
114e1c: eb 83 jmp 114da1 <_Timer_Server_body+0x101><== NOT EXECUTED
114e1e: 66 90 xchg %ax,%ax <== NOT EXECUTED
/*
* 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 );
114e20: 51 push %ecx
114e21: 57 push %edi
114e22: 89 da mov %ebx,%edx
114e24: 29 c2 sub %eax,%edx
114e26: 52 push %edx
114e27: 68 94 59 13 00 push $0x135994
114e2c: e8 27 38 00 00 call 118658 <_Watchdog_Adjust_to_chain>
114e31: 83 c4 10 add $0x10,%esp
114e34: eb 92 jmp 114dc8 <_Timer_Server_body+0x128>
114e36: 66 90 xchg %ax,%ax
/*
* 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 );
114e38: 52 push %edx
114e39: 29 d8 sub %ebx,%eax
114e3b: 50 push %eax
114e3c: 6a 01 push $0x1
114e3e: 68 94 59 13 00 push $0x135994
114e43: e8 94 37 00 00 call 1185dc <_Watchdog_Adjust>
114e48: 83 c4 10 add $0x10,%esp
114e4b: e9 78 ff ff ff jmp 114dc8 <_Timer_Server_body+0x128>
00114c40 <_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)
{
114c40: 55 push %ebp
114c41: 89 e5 mov %esp,%ebp
114c43: 83 ec 08 sub $0x8,%esp
114c46: eb 0a jmp 114c52 <_Timer_Server_process_insertions+0x12>
if ( the_timer == NULL )
break;
if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker );
} else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
114c48: 83 fa 03 cmp $0x3,%edx
114c4b: 74 37 je 114c84 <_Timer_Server_process_insertions+0x44><== ALWAYS TAKEN
}
/*
* Insert the timers that have been requested to be inserted.
*/
_Timer_Server_process_insertions();
114c4d: e8 ee ff ff ff call 114c40 <_Timer_Server_process_insertions>
static void _Timer_Server_process_insertions(void)
{
Timer_Control *the_timer;
while ( 1 ) {
the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted );
114c52: 83 ec 0c sub $0xc,%esp
114c55: 68 a0 59 13 00 push $0x1359a0
114c5a: e8 69 08 00 00 call 1154c8 <_Chain_Get>
if ( the_timer == NULL )
114c5f: 83 c4 10 add $0x10,%esp
114c62: 85 c0 test %eax,%eax
114c64: 74 36 je 114c9c <_Timer_Server_process_insertions+0x5c>
break;
if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
114c66: 8b 50 38 mov 0x38(%eax),%edx
114c69: 83 fa 01 cmp $0x1,%edx
114c6c: 75 da jne 114c48 <_Timer_Server_process_insertions+0x8>
_Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker );
114c6e: 83 ec 08 sub $0x8,%esp
114c71: 83 c0 10 add $0x10,%eax
114c74: 50 push %eax
114c75: 68 80 59 13 00 push $0x135980
114c7a: e8 6d 3a 00 00 call 1186ec <_Watchdog_Insert>
114c7f: 83 c4 10 add $0x10,%esp
114c82: eb c9 jmp 114c4d <_Timer_Server_process_insertions+0xd>
} else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
_Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker );
114c84: 83 ec 08 sub $0x8,%esp
114c87: 83 c0 10 add $0x10,%eax
114c8a: 50 push %eax
114c8b: 68 94 59 13 00 push $0x135994
114c90: e8 57 3a 00 00 call 1186ec <_Watchdog_Insert>
114c95: 83 c4 10 add $0x10,%esp
114c98: eb b3 jmp 114c4d <_Timer_Server_process_insertions+0xd>
114c9a: 66 90 xchg %ax,%ax
* Insert the timers that have been requested to be inserted.
*/
_Timer_Server_process_insertions();
}
}
114c9c: c9 leave
114c9d: c3 ret
0010e5d8 <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
10e5d8: 55 push %ebp
10e5d9: 89 e5 mov %esp,%ebp
10e5db: 57 push %edi
10e5dc: 56 push %esi
10e5dd: 53 push %ebx
10e5de: 83 ec 2c sub $0x2c,%esp
10e5e1: 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;
10e5e4: 8b 10 mov (%eax),%edx
10e5e6: 89 55 ec mov %edx,-0x14(%ebp)
left += lhs->tv_nsec;
10e5e9: 8b 40 04 mov 0x4(%eax),%eax
10e5ec: 89 45 dc mov %eax,-0x24(%ebp)
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
10e5ef: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx
10e5f4: 8b 5d 0c mov 0xc(%ebp),%ebx
10e5f7: 8b 03 mov (%ebx),%eax
10e5f9: f7 e9 imul %ecx
10e5fb: 89 c6 mov %eax,%esi
10e5fd: 89 d7 mov %edx,%edi
right += rhs->tv_nsec;
10e5ff: 8b 43 04 mov 0x4(%ebx),%eax
10e602: 99 cltd
10e603: 01 c6 add %eax,%esi
10e605: 11 d7 adc %edx,%edi
if ( right == 0 ) {
10e607: 89 f8 mov %edi,%eax
10e609: 09 f0 or %esi,%eax
10e60b: 74 77 je 10e684 <_Timespec_Divide+0xac> <== NEVER TAKEN
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
10e60d: 8b 45 ec mov -0x14(%ebp),%eax
10e610: f7 e9 imul %ecx
10e612: 89 45 e0 mov %eax,-0x20(%ebp)
10e615: 89 55 e4 mov %edx,-0x1c(%ebp)
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
10e618: 8b 45 dc mov -0x24(%ebp),%eax
10e61b: 99 cltd
10e61c: 01 45 e0 add %eax,-0x20(%ebp)
10e61f: 11 55 e4 adc %edx,-0x1c(%ebp)
10e622: 69 5d e4 a0 86 01 00 imul $0x186a0,-0x1c(%ebp),%ebx
10e629: b9 a0 86 01 00 mov $0x186a0,%ecx
10e62e: 8b 45 e0 mov -0x20(%ebp),%eax
10e631: f7 e1 mul %ecx
10e633: 89 45 d0 mov %eax,-0x30(%ebp)
10e636: 01 da add %ebx,%edx
10e638: 89 55 d4 mov %edx,-0x2c(%ebp)
10e63b: 57 push %edi
10e63c: 56 push %esi
10e63d: ff 75 d4 pushl -0x2c(%ebp)
10e640: ff 75 d0 pushl -0x30(%ebp)
10e643: e8 c0 a8 00 00 call 118f08 <__udivdi3>
10e648: 83 c4 10 add $0x10,%esp
10e64b: 89 c3 mov %eax,%ebx
10e64d: 89 d6 mov %edx,%esi
*ival_percentage = answer / 1000;
10e64f: 6a 00 push $0x0
10e651: 68 e8 03 00 00 push $0x3e8
10e656: 52 push %edx
10e657: 50 push %eax
10e658: e8 ab a8 00 00 call 118f08 <__udivdi3>
10e65d: 83 c4 10 add $0x10,%esp
10e660: 8b 4d 10 mov 0x10(%ebp),%ecx
10e663: 89 01 mov %eax,(%ecx)
*fval_percentage = answer % 1000;
10e665: 6a 00 push $0x0
10e667: 68 e8 03 00 00 push $0x3e8
10e66c: 56 push %esi
10e66d: 53 push %ebx
10e66e: e8 a1 a9 00 00 call 119014 <__umoddi3>
10e673: 83 c4 10 add $0x10,%esp
10e676: 8b 5d 14 mov 0x14(%ebp),%ebx
10e679: 89 03 mov %eax,(%ebx)
}
10e67b: 8d 65 f4 lea -0xc(%ebp),%esp
10e67e: 5b pop %ebx
10e67f: 5e pop %esi
10e680: 5f pop %edi
10e681: c9 leave
10e682: c3 ret
10e683: 90 nop
left += lhs->tv_nsec;
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
right += rhs->tv_nsec;
if ( right == 0 ) {
*ival_percentage = 0;
10e684: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
10e687: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED
*fval_percentage = 0;
10e68d: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED
10e690: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED
answer = (left * 100000) / right;
*ival_percentage = answer / 1000;
*fval_percentage = answer % 1000;
}
10e696: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10e699: 5b pop %ebx <== NOT EXECUTED
10e69a: 5e pop %esi <== NOT EXECUTED
10e69b: 5f pop %edi <== NOT EXECUTED
10e69c: c9 leave <== NOT EXECUTED
10e69d: c3 ret <== NOT EXECUTED
0010ea08 <_Timespec_Greater_than>:
bool _Timespec_Greater_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
10ea08: 55 push %ebp
10ea09: 89 e5 mov %esp,%ebp
10ea0b: 8b 55 08 mov 0x8(%ebp),%edx
10ea0e: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( lhs->tv_sec > rhs->tv_sec )
10ea11: 8b 01 mov (%ecx),%eax
10ea13: 39 02 cmp %eax,(%edx)
10ea15: 7f 11 jg 10ea28 <_Timespec_Greater_than+0x20><== NEVER TAKEN
return TRUE;
if ( lhs->tv_sec < rhs->tv_sec )
10ea17: 7c 0b jl 10ea24 <_Timespec_Greater_than+0x1c><== NEVER TAKEN
return FALSE;
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec > rhs->tv_nsec )
10ea19: 8b 42 04 mov 0x4(%edx),%eax
10ea1c: 3b 41 04 cmp 0x4(%ecx),%eax
10ea1f: 0f 9f c0 setg %al
return TRUE;
return FALSE;
}
10ea22: c9 leave
10ea23: c3 ret
)
{
if ( lhs->tv_sec > rhs->tv_sec )
return TRUE;
if ( lhs->tv_sec < rhs->tv_sec )
10ea24: 31 c0 xor %eax,%eax
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec > rhs->tv_nsec )
return TRUE;
return FALSE;
}
10ea26: c9 leave <== NOT EXECUTED
10ea27: c3 ret <== NOT EXECUTED
bool _Timespec_Greater_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec > rhs->tv_sec )
10ea28: b0 01 mov $0x1,%al <== NOT EXECUTED
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec > rhs->tv_nsec )
return TRUE;
return FALSE;
}
10ea2a: c9 leave <== NOT EXECUTED
10ea2b: c3 ret <== NOT EXECUTED
0010ea2c <_Timespec_Less_than>:
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
10ea2c: 55 push %ebp
10ea2d: 89 e5 mov %esp,%ebp
10ea2f: 8b 55 08 mov 0x8(%ebp),%edx
10ea32: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( lhs->tv_sec < rhs->tv_sec )
10ea35: 8b 01 mov (%ecx),%eax
10ea37: 39 02 cmp %eax,(%edx)
10ea39: 7c 11 jl 10ea4c <_Timespec_Less_than+0x20>
return TRUE;
if ( lhs->tv_sec > rhs->tv_sec )
10ea3b: 7f 0b jg 10ea48 <_Timespec_Less_than+0x1c><== NEVER TAKEN
return FALSE;
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec < rhs->tv_nsec )
10ea3d: 8b 42 04 mov 0x4(%edx),%eax
10ea40: 3b 41 04 cmp 0x4(%ecx),%eax
10ea43: 0f 9c c0 setl %al
return TRUE;
return FALSE;
}
10ea46: c9 leave
10ea47: c3 ret
)
{
if ( lhs->tv_sec < rhs->tv_sec )
return TRUE;
if ( lhs->tv_sec > rhs->tv_sec )
10ea48: 31 c0 xor %eax,%eax
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec < rhs->tv_nsec )
return TRUE;
return FALSE;
}
10ea4a: c9 leave <== NOT EXECUTED
10ea4b: c3 ret <== NOT EXECUTED
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
10ea4c: b0 01 mov $0x1,%al
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec < rhs->tv_nsec )
return TRUE;
return FALSE;
}
10ea4e: c9 leave
10ea4f: c3 ret
0010f88c <_User_extensions_Add_API_set>:
*/
void _User_extensions_Add_API_set (
User_extensions_Control *the_extension
)
{
10f88c: 55 push %ebp
10f88d: 89 e5 mov %esp,%ebp
10f88f: 53 push %ebx
10f890: 83 ec 0c sub $0xc,%esp
10f893: 8b 5d 08 mov 0x8(%ebp),%ebx
_Chain_Append( &_User_extensions_List, &the_extension->Node );
10f896: 53 push %ebx
10f897: 68 ac e8 11 00 push $0x11e8ac
10f89c: e8 db b4 ff ff call 10ad7c <_Chain_Append>
/*
* If a switch handler is present, append it to the switch chain.
*/
if ( the_extension->Callouts.thread_switch != NULL ) {
10f8a1: 8b 43 24 mov 0x24(%ebx),%eax
10f8a4: 83 c4 10 add $0x10,%esp
10f8a7: 85 c0 test %eax,%eax
10f8a9: 74 17 je 10f8c2 <_User_extensions_Add_API_set+0x36><== NEVER TAKEN
the_extension->Switch.thread_switch = the_extension->Callouts.thread_switch;
10f8ab: 89 43 10 mov %eax,0x10(%ebx)
_Chain_Append(
10f8ae: 83 ec 08 sub $0x8,%esp
10f8b1: 8d 43 08 lea 0x8(%ebx),%eax
10f8b4: 50 push %eax
10f8b5: 68 5c e6 11 00 push $0x11e65c
10f8ba: e8 bd b4 ff ff call 10ad7c <_Chain_Append>
10f8bf: 83 c4 10 add $0x10,%esp
&_User_extensions_Switches_list, &the_extension->Switch.Node );
}
}
10f8c2: 8b 5d fc mov -0x4(%ebp),%ebx
10f8c5: c9 leave
10f8c6: c3 ret
0010f8c8 <_User_extensions_Add_set>:
void _User_extensions_Add_set (
User_extensions_Control *the_extension,
User_extensions_Table *extension_table
)
{
10f8c8: 55 push %ebp
10f8c9: 89 e5 mov %esp,%ebp
10f8cb: 57 push %edi
10f8cc: 56 push %esi
10f8cd: 53 push %ebx
10f8ce: 83 ec 14 sub $0x14,%esp
10f8d1: 8b 5d 08 mov 0x8(%ebp),%ebx
10f8d4: 8b 45 0c mov 0xc(%ebp),%eax
10f8d7: 89 45 ec mov %eax,-0x14(%ebp)
the_extension->Callouts = *extension_table;
10f8da: 8d 7b 14 lea 0x14(%ebx),%edi
10f8dd: b9 08 00 00 00 mov $0x8,%ecx
10f8e2: 89 c6 mov %eax,%esi
10f8e4: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Chain_Append( &_User_extensions_List, &the_extension->Node );
10f8e6: 53 push %ebx
10f8e7: 68 ac e8 11 00 push $0x11e8ac
10f8ec: e8 8b b4 ff ff call 10ad7c <_Chain_Append>
/*
* If a switch handler is present, append it to the switch chain.
*/
if ( extension_table->thread_switch != NULL ) {
10f8f1: 8b 55 ec mov -0x14(%ebp),%edx
10f8f4: 8b 42 10 mov 0x10(%edx),%eax
10f8f7: 83 c4 10 add $0x10,%esp
10f8fa: 85 c0 test %eax,%eax
10f8fc: 74 1e je 10f91c <_User_extensions_Add_set+0x54>
the_extension->Switch.thread_switch = extension_table->thread_switch;
10f8fe: 89 43 10 mov %eax,0x10(%ebx)
_Chain_Append(
10f901: 8d 43 08 lea 0x8(%ebx),%eax
10f904: 89 45 0c mov %eax,0xc(%ebp)
10f907: c7 45 08 5c e6 11 00 movl $0x11e65c,0x8(%ebp)
&_User_extensions_Switches_list,
&the_extension->Switch.Node
);
}
}
10f90e: 8d 65 f4 lea -0xc(%ebp),%esp
10f911: 5b pop %ebx
10f912: 5e pop %esi
10f913: 5f pop %edi
10f914: c9 leave
* If a switch handler is present, append it to the switch chain.
*/
if ( extension_table->thread_switch != NULL ) {
the_extension->Switch.thread_switch = extension_table->thread_switch;
_Chain_Append(
10f915: e9 62 b4 ff ff jmp 10ad7c <_Chain_Append>
10f91a: 66 90 xchg %ax,%ax
&_User_extensions_Switches_list,
&the_extension->Switch.Node
);
}
}
10f91c: 8d 65 f4 lea -0xc(%ebp),%esp
10f91f: 5b pop %ebx
10f920: 5e pop %esi
10f921: 5f pop %edi
10f922: c9 leave
10f923: c3 ret
0010d0ac <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
uint32_t the_error
)
{
10d0ac: 55 push %ebp
10d0ad: 89 e5 mov %esp,%ebp
10d0af: 57 push %edi
10d0b0: 56 push %esi
10d0b1: 53 push %ebx
10d0b2: 83 ec 0c sub $0xc,%esp
10d0b5: 8b 7d 10 mov 0x10(%ebp),%edi
10d0b8: 8a 45 0c mov 0xc(%ebp),%al
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
10d0bb: 8b 1d b4 e8 11 00 mov 0x11e8b4,%ebx
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
10d0c1: 81 fb ac e8 11 00 cmp $0x11e8ac,%ebx
10d0c7: 74 20 je 10d0e9 <_User_extensions_Fatal+0x3d><== NEVER TAKEN
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10d0c9: 0f b6 f0 movzbl %al,%esi
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
10d0cc: 8b 43 30 mov 0x30(%ebx),%eax
10d0cf: 85 c0 test %eax,%eax
10d0d1: 74 0b je 10d0de <_User_extensions_Fatal+0x32>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10d0d3: 52 push %edx
10d0d4: 57 push %edi
10d0d5: 56 push %esi
10d0d6: ff 75 08 pushl 0x8(%ebp)
10d0d9: ff d0 call *%eax
10d0db: 83 c4 10 add $0x10,%esp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
10d0de: 8b 5b 04 mov 0x4(%ebx),%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
10d0e1: 81 fb ac e8 11 00 cmp $0x11e8ac,%ebx
10d0e7: 75 e3 jne 10d0cc <_User_extensions_Fatal+0x20>
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
10d0e9: 8d 65 f4 lea -0xc(%ebp),%esp
10d0ec: 5b pop %ebx
10d0ed: 5e pop %esi
10d0ee: 5f pop %edi
10d0ef: c9 leave
10d0f0: c3 ret
0010cf90 <_User_extensions_Handler_initialization>:
void _User_extensions_Handler_initialization (
uint32_t number_of_extensions,
User_extensions_Table *initial_extensions
)
{
10cf90: 55 push %ebp
10cf91: 89 e5 mov %esp,%ebp
10cf93: 57 push %edi
10cf94: 56 push %esi
10cf95: 53 push %ebx
10cf96: 83 ec 0c sub $0xc,%esp
10cf99: 8b 75 0c mov 0xc(%ebp),%esi
10cf9c: c7 05 ac e8 11 00 b0 movl $0x11e8b0,0x11e8ac
10cfa3: e8 11 00
10cfa6: c7 05 b0 e8 11 00 00 movl $0x0,0x11e8b0
10cfad: 00 00 00
10cfb0: c7 05 b4 e8 11 00 ac movl $0x11e8ac,0x11e8b4
10cfb7: e8 11 00
10cfba: c7 05 5c e6 11 00 60 movl $0x11e660,0x11e65c
10cfc1: e6 11 00
10cfc4: c7 05 60 e6 11 00 00 movl $0x0,0x11e660
10cfcb: 00 00 00
10cfce: c7 05 64 e6 11 00 5c movl $0x11e65c,0x11e664
10cfd5: e6 11 00
uint32_t i;
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
10cfd8: 85 f6 test %esi,%esi
10cfda: 74 50 je 10d02c <_User_extensions_Handler_initialization+0x9c>
extension = (User_extensions_Control *)
10cfdc: 8b 55 08 mov 0x8(%ebp),%edx
10cfdf: 8d 04 52 lea (%edx,%edx,2),%eax
10cfe2: 8d 04 82 lea (%edx,%eax,4),%eax
10cfe5: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx
10cfec: 83 ec 0c sub $0xc,%esp
10cfef: 53 push %ebx
10cff0: e8 43 04 00 00 call 10d438 <_Workspace_Allocate_or_fatal_error>
10cff5: 89 45 ec mov %eax,-0x14(%ebp)
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
10cff8: 31 c0 xor %eax,%eax
10cffa: 8b 7d ec mov -0x14(%ebp),%edi
10cffd: 89 d9 mov %ebx,%ecx
10cfff: f3 aa rep stos %al,%es:(%edi)
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10d001: 83 c4 10 add $0x10,%esp
10d004: 8b 45 08 mov 0x8(%ebp),%eax
10d007: 85 c0 test %eax,%eax
10d009: 74 21 je 10d02c <_User_extensions_Handler_initialization+0x9c><== NEVER TAKEN
10d00b: 31 db xor %ebx,%ebx
10d00d: 8d 76 00 lea 0x0(%esi),%esi
_User_extensions_Add_set (extension, &initial_extensions[i]);
10d010: 83 ec 08 sub $0x8,%esp
10d013: 56 push %esi
10d014: ff 75 ec pushl -0x14(%ebp)
10d017: e8 ac 28 00 00 call 10f8c8 <_User_extensions_Add_set>
extension++;
10d01c: 83 45 ec 34 addl $0x34,-0x14(%ebp)
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10d020: 43 inc %ebx
10d021: 83 c6 20 add $0x20,%esi
10d024: 83 c4 10 add $0x10,%esp
10d027: 39 5d 08 cmp %ebx,0x8(%ebp)
10d02a: 77 e4 ja 10d010 <_User_extensions_Handler_initialization+0x80>
_User_extensions_Add_set (extension, &initial_extensions[i]);
extension++;
}
}
}
10d02c: 8d 65 f4 lea -0xc(%ebp),%esp
10d02f: 5b pop %ebx
10d030: 5e pop %esi
10d031: 5f pop %edi
10d032: c9 leave
10d033: c3 ret
0010ec54 <_User_extensions_Remove_set>:
*/
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
10ec54: 55 push %ebp
10ec55: 89 e5 mov %esp,%ebp
10ec57: 53 push %ebx
10ec58: 83 ec 10 sub $0x10,%esp
10ec5b: 8b 5d 08 mov 0x8(%ebp),%ebx
_Chain_Extract( &the_extension->Node );
10ec5e: 53 push %ebx
10ec5f: e8 18 21 00 00 call 110d7c <_Chain_Extract>
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
10ec64: 83 c4 10 add $0x10,%esp
10ec67: 8b 43 24 mov 0x24(%ebx),%eax
10ec6a: 85 c0 test %eax,%eax
10ec6c: 74 12 je 10ec80 <_User_extensions_Remove_set+0x2c><== ALWAYS TAKEN
_Chain_Extract( &the_extension->Switch.Node );
10ec6e: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED
10ec71: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
10ec74: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10ec77: 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 );
10ec78: e9 ff 20 00 00 jmp 110d7c <_Chain_Extract> <== NOT EXECUTED
10ec7d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
}
10ec80: 8b 5d fc mov -0x4(%ebp),%ebx
10ec83: c9 leave
10ec84: c3 ret
0010d034 <_User_extensions_Thread_begin>:
*/
void _User_extensions_Thread_begin (
Thread_Control *executing
)
{
10d034: 55 push %ebp
10d035: 89 e5 mov %esp,%ebp
10d037: 56 push %esi
10d038: 53 push %ebx
10d039: 8b 75 08 mov 0x8(%ebp),%esi
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.first ;
10d03c: 8b 1d ac e8 11 00 mov 0x11e8ac,%ebx
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
10d042: 81 fb b0 e8 11 00 cmp $0x11e8b0,%ebx
10d048: 74 1c je 10d066 <_User_extensions_Thread_begin+0x32><== NEVER TAKEN
10d04a: 66 90 xchg %ax,%ax
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_begin != NULL )
10d04c: 8b 43 28 mov 0x28(%ebx),%eax
10d04f: 85 c0 test %eax,%eax
10d051: 74 09 je 10d05c <_User_extensions_Thread_begin+0x28>
(*the_extension->Callouts.thread_begin)( executing );
10d053: 83 ec 0c sub $0xc,%esp
10d056: 56 push %esi
10d057: ff d0 call *%eax
10d059: 83 c4 10 add $0x10,%esp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.first ;
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
10d05c: 8b 1b mov (%ebx),%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.first ;
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
10d05e: 81 fb b0 e8 11 00 cmp $0x11e8b0,%ebx
10d064: 75 e6 jne 10d04c <_User_extensions_Thread_begin+0x18>
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_begin != NULL )
(*the_extension->Callouts.thread_begin)( executing );
}
}
10d066: 8d 65 f8 lea -0x8(%ebp),%esp
10d069: 5b pop %ebx
10d06a: 5e pop %esi
10d06b: c9 leave
10d06c: c3 ret
0010d0f4 <_User_extensions_Thread_create>:
*/
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
10d0f4: 55 push %ebp
10d0f5: 89 e5 mov %esp,%ebp
10d0f7: 56 push %esi
10d0f8: 53 push %ebx
10d0f9: 8b 75 08 mov 0x8(%ebp),%esi
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _User_extensions_List.first ;
10d0fc: 8b 1d ac e8 11 00 mov 0x11e8ac,%ebx
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
10d102: 81 fb b0 e8 11 00 cmp $0x11e8b0,%ebx
10d108: 74 26 je 10d130 <_User_extensions_Thread_create+0x3c><== NEVER TAKEN
10d10a: 66 90 xchg %ax,%ax
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
10d10c: 8b 43 14 mov 0x14(%ebx),%eax
10d10f: 85 c0 test %eax,%eax
10d111: 74 13 je 10d126 <_User_extensions_Thread_create+0x32>
status = (*the_extension->Callouts.thread_create)(
10d113: 83 ec 08 sub $0x8,%esp
10d116: 56 push %esi
10d117: ff 35 1c e7 11 00 pushl 0x11e71c
10d11d: ff d0 call *%eax
_Thread_Executing,
the_thread
);
if ( !status )
10d11f: 83 c4 10 add $0x10,%esp
10d122: 84 c0 test %al,%al
10d124: 74 0c je 10d132 <_User_extensions_Thread_create+0x3e><== NEVER TAKEN
User_extensions_Control *the_extension;
bool status;
for ( the_node = _User_extensions_List.first ;
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
10d126: 8b 1b mov (%ebx),%ebx
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _User_extensions_List.first ;
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
10d128: 81 fb b0 e8 11 00 cmp $0x11e8b0,%ebx
10d12e: 75 dc jne 10d10c <_User_extensions_Thread_create+0x18>
10d130: b0 01 mov $0x1,%al
return FALSE;
}
}
return TRUE;
}
10d132: 8d 65 f8 lea -0x8(%ebp),%esp
10d135: 5b pop %ebx
10d136: 5e pop %esi
10d137: c9 leave
10d138: c3 ret
0010d13c <_User_extensions_Thread_delete>:
*/
void _User_extensions_Thread_delete (
Thread_Control *the_thread
)
{
10d13c: 55 push %ebp
10d13d: 89 e5 mov %esp,%ebp
10d13f: 56 push %esi
10d140: 53 push %ebx
10d141: 8b 75 08 mov 0x8(%ebp),%esi
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
10d144: 8b 1d b4 e8 11 00 mov 0x11e8b4,%ebx
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
10d14a: 81 fb ac e8 11 00 cmp $0x11e8ac,%ebx
10d150: 74 23 je 10d175 <_User_extensions_Thread_delete+0x39><== NEVER TAKEN
10d152: 66 90 xchg %ax,%ax
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_delete != NULL )
10d154: 8b 43 20 mov 0x20(%ebx),%eax
10d157: 85 c0 test %eax,%eax
10d159: 74 0f je 10d16a <_User_extensions_Thread_delete+0x2e>
(*the_extension->Callouts.thread_delete)(
10d15b: 83 ec 08 sub $0x8,%esp
10d15e: 56 push %esi
10d15f: ff 35 1c e7 11 00 pushl 0x11e71c
10d165: ff d0 call *%eax
10d167: 83 c4 10 add $0x10,%esp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
10d16a: 8b 5b 04 mov 0x4(%ebx),%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
10d16d: 81 fb ac e8 11 00 cmp $0x11e8ac,%ebx
10d173: 75 df jne 10d154 <_User_extensions_Thread_delete+0x18>
(*the_extension->Callouts.thread_delete)(
_Thread_Executing,
the_thread
);
}
}
10d175: 8d 65 f8 lea -0x8(%ebp),%esp
10d178: 5b pop %ebx
10d179: 5e pop %esi
10d17a: c9 leave
10d17b: c3 ret
0010d070 <_User_extensions_Thread_exitted>:
*/
void _User_extensions_Thread_exitted (
Thread_Control *executing
)
{
10d070: 55 push %ebp
10d071: 89 e5 mov %esp,%ebp
10d073: 56 push %esi
10d074: 53 push %ebx
10d075: 8b 75 08 mov 0x8(%ebp),%esi
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
10d078: 8b 1d b4 e8 11 00 mov 0x11e8b4,%ebx
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
10d07e: 81 fb ac e8 11 00 cmp $0x11e8ac,%ebx
10d084: 74 1d je 10d0a3 <_User_extensions_Thread_exitted+0x33><== NEVER TAKEN
10d086: 66 90 xchg %ax,%ax
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_exitted != NULL )
10d088: 8b 43 2c mov 0x2c(%ebx),%eax
10d08b: 85 c0 test %eax,%eax
10d08d: 74 09 je 10d098 <_User_extensions_Thread_exitted+0x28>
(*the_extension->Callouts.thread_exitted)( executing );
10d08f: 83 ec 0c sub $0xc,%esp
10d092: 56 push %esi
10d093: ff d0 call *%eax
10d095: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
10d098: 8b 5b 04 mov 0x4(%ebx),%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
10d09b: 81 fb ac e8 11 00 cmp $0x11e8ac,%ebx
10d0a1: 75 e5 jne 10d088 <_User_extensions_Thread_exitted+0x18>
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_exitted != NULL )
(*the_extension->Callouts.thread_exitted)( executing );
}
}
10d0a3: 8d 65 f8 lea -0x8(%ebp),%esp
10d0a6: 5b pop %ebx
10d0a7: 5e pop %esi
10d0a8: c9 leave
10d0a9: c3 ret
0010dc48 <_User_extensions_Thread_restart>:
*/
void _User_extensions_Thread_restart (
Thread_Control *the_thread
)
{
10dc48: 55 push %ebp
10dc49: 89 e5 mov %esp,%ebp
10dc4b: 56 push %esi
10dc4c: 53 push %ebx
10dc4d: 8b 75 08 mov 0x8(%ebp),%esi
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.first ;
10dc50: 8b 1d 0c 19 12 00 mov 0x12190c,%ebx
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
10dc56: 81 fb 10 19 12 00 cmp $0x121910,%ebx
10dc5c: 74 22 je 10dc80 <_User_extensions_Thread_restart+0x38><== NEVER TAKEN
10dc5e: 66 90 xchg %ax,%ax
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_restart != NULL )
10dc60: 8b 43 1c mov 0x1c(%ebx),%eax
10dc63: 85 c0 test %eax,%eax
10dc65: 74 0f je 10dc76 <_User_extensions_Thread_restart+0x2e>
(*the_extension->Callouts.thread_restart)(
10dc67: 83 ec 08 sub $0x8,%esp
10dc6a: 56 push %esi
10dc6b: ff 35 7c 17 12 00 pushl 0x12177c
10dc71: ff d0 call *%eax
10dc73: 83 c4 10 add $0x10,%esp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.first ;
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
10dc76: 8b 1b mov (%ebx),%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.first ;
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
10dc78: 81 fb 10 19 12 00 cmp $0x121910,%ebx
10dc7e: 75 e0 jne 10dc60 <_User_extensions_Thread_restart+0x18>
(*the_extension->Callouts.thread_restart)(
_Thread_Executing,
the_thread
);
}
}
10dc80: 8d 65 f8 lea -0x8(%ebp),%esp
10dc83: 5b pop %ebx
10dc84: 5e pop %esi
10dc85: c9 leave
10dc86: c3 ret
0010d17c <_User_extensions_Thread_start>:
*/
void _User_extensions_Thread_start (
Thread_Control *the_thread
)
{
10d17c: 55 push %ebp
10d17d: 89 e5 mov %esp,%ebp
10d17f: 56 push %esi
10d180: 53 push %ebx
10d181: 8b 75 08 mov 0x8(%ebp),%esi
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.first ;
10d184: 8b 1d ac e8 11 00 mov 0x11e8ac,%ebx
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
10d18a: 81 fb b0 e8 11 00 cmp $0x11e8b0,%ebx
10d190: 74 22 je 10d1b4 <_User_extensions_Thread_start+0x38><== NEVER TAKEN
10d192: 66 90 xchg %ax,%ax
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_start != NULL )
10d194: 8b 43 18 mov 0x18(%ebx),%eax
10d197: 85 c0 test %eax,%eax
10d199: 74 0f je 10d1aa <_User_extensions_Thread_start+0x2e>
(*the_extension->Callouts.thread_start)(
10d19b: 83 ec 08 sub $0x8,%esp
10d19e: 56 push %esi
10d19f: ff 35 1c e7 11 00 pushl 0x11e71c
10d1a5: ff d0 call *%eax
10d1a7: 83 c4 10 add $0x10,%esp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.first ;
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
10d1aa: 8b 1b mov (%ebx),%ebx
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.first ;
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
10d1ac: 81 fb b0 e8 11 00 cmp $0x11e8b0,%ebx
10d1b2: 75 e0 jne 10d194 <_User_extensions_Thread_start+0x18>
(*the_extension->Callouts.thread_start)(
_Thread_Executing,
the_thread
);
}
}
10d1b4: 8d 65 f8 lea -0x8(%ebp),%esp
10d1b7: 5b pop %ebx
10d1b8: 5e pop %esi
10d1b9: c9 leave
10d1ba: c3 ret
0010d1bc <_User_extensions_Thread_switch>:
*/
void _User_extensions_Thread_switch (
Thread_Control *executing,
Thread_Control *heir
)
{
10d1bc: 55 push %ebp
10d1bd: 89 e5 mov %esp,%ebp
10d1bf: 57 push %edi
10d1c0: 56 push %esi
10d1c1: 53 push %ebx
10d1c2: 83 ec 0c sub $0xc,%esp
10d1c5: 8b 7d 08 mov 0x8(%ebp),%edi
10d1c8: 8b 75 0c mov 0xc(%ebp),%esi
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _User_extensions_Switches_list.first ;
10d1cb: 8b 1d 5c e6 11 00 mov 0x11e65c,%ebx
!_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
10d1d1: 81 fb 60 e6 11 00 cmp $0x11e660,%ebx
10d1d7: 74 18 je 10d1f1 <_User_extensions_Thread_switch+0x35><== NEVER TAKEN
10d1d9: 8d 76 00 lea 0x0(%esi),%esi
the_node = the_node->next ) {
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
10d1dc: 83 ec 08 sub $0x8,%esp
10d1df: 56 push %esi
10d1e0: 57 push %edi
10d1e1: ff 53 08 call *0x8(%ebx)
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _User_extensions_Switches_list.first ;
!_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
the_node = the_node->next ) {
10d1e4: 8b 1b mov (%ebx),%ebx
{
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _User_extensions_Switches_list.first ;
!_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
10d1e6: 83 c4 10 add $0x10,%esp
10d1e9: 81 fb 60 e6 11 00 cmp $0x11e660,%ebx
10d1ef: 75 eb jne 10d1dc <_User_extensions_Thread_switch+0x20>
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
}
}
10d1f1: 8d 65 f4 lea -0xc(%ebp),%esp
10d1f4: 5b pop %ebx
10d1f5: 5e pop %esi
10d1f6: 5f pop %edi
10d1f7: c9 leave
10d1f8: c3 ret
0010e9a4 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
10e9a4: 55 push %ebp
10e9a5: 89 e5 mov %esp,%ebp
10e9a7: 57 push %edi
10e9a8: 56 push %esi
10e9a9: 53 push %ebx
10e9aa: 83 ec 0c sub $0xc,%esp
10e9ad: 8b 7d 08 mov 0x8(%ebp),%edi
10e9b0: 8b 4d 0c mov 0xc(%ebp),%ecx
10e9b3: 8b 75 10 mov 0x10(%ebp),%esi
ISR_Level level;
_ISR_Disable( level );
10e9b6: 9c pushf
10e9b7: fa cli
10e9b8: 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(
10e9b9: 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
10e9bb: 8d 5f 04 lea 0x4(%edi),%ebx
10e9be: 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 ) ) {
10e9c1: 39 d8 cmp %ebx,%eax
10e9c3: 74 3f je 10ea04 <_Watchdog_Adjust+0x60>
switch ( direction ) {
10e9c5: 85 c9 test %ecx,%ecx
10e9c7: 75 47 jne 10ea10 <_Watchdog_Adjust+0x6c>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
10e9c9: 85 f6 test %esi,%esi
10e9cb: 74 37 je 10ea04 <_Watchdog_Adjust+0x60> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
10e9cd: 8b 58 10 mov 0x10(%eax),%ebx
10e9d0: 39 de cmp %ebx,%esi
10e9d2: 73 0f jae 10e9e3 <_Watchdog_Adjust+0x3f> <== ALWAYS TAKEN
10e9d4: eb 42 jmp 10ea18 <_Watchdog_Adjust+0x74> <== NOT EXECUTED
10e9d6: 66 90 xchg %ax,%ax <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
10e9d8: 29 de sub %ebx,%esi
10e9da: 74 28 je 10ea04 <_Watchdog_Adjust+0x60> <== NEVER TAKEN
if ( units < _Watchdog_First( header )->delta_interval ) {
10e9dc: 8b 58 10 mov 0x10(%eax),%ebx
10e9df: 39 f3 cmp %esi,%ebx
10e9e1: 77 35 ja 10ea18 <_Watchdog_Adjust+0x74>
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
10e9e3: c7 40 10 01 00 00 00 movl $0x1,0x10(%eax)
_ISR_Enable( level );
10e9ea: 52 push %edx
10e9eb: 9d popf
_Watchdog_Tickle( header );
10e9ec: 83 ec 0c sub $0xc,%esp
10e9ef: 57 push %edi
10e9f0: e8 c7 01 00 00 call 10ebbc <_Watchdog_Tickle>
_ISR_Disable( level );
10e9f5: 9c pushf
10e9f6: fa cli
10e9f7: 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(
10e9f8: 8b 07 mov (%edi),%eax
if ( _Chain_Is_empty( header ) )
10e9fa: 83 c4 10 add $0x10,%esp
10e9fd: 39 45 f0 cmp %eax,-0x10(%ebp)
10ea00: 75 d6 jne 10e9d8 <_Watchdog_Adjust+0x34>
10ea02: 66 90 xchg %ax,%ax
}
break;
}
}
_ISR_Enable( level );
10ea04: 52 push %edx
10ea05: 9d popf
}
10ea06: 8d 65 f4 lea -0xc(%ebp),%esp
10ea09: 5b pop %ebx
10ea0a: 5e pop %esi
10ea0b: 5f pop %edi
10ea0c: c9 leave
10ea0d: c3 ret
10ea0e: 66 90 xchg %ax,%ax
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
10ea10: 49 dec %ecx
10ea11: 75 f1 jne 10ea04 <_Watchdog_Adjust+0x60> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
10ea13: 01 70 10 add %esi,0x10(%eax)
10ea16: eb ec jmp 10ea04 <_Watchdog_Adjust+0x60>
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
10ea18: 29 f3 sub %esi,%ebx
10ea1a: 89 58 10 mov %ebx,0x10(%eax)
10ea1d: eb e5 jmp 10ea04 <_Watchdog_Adjust+0x60>
00118658 <_Watchdog_Adjust_to_chain>:
Chain_Control *header,
Watchdog_Interval units_arg,
Chain_Control *to_fire
)
{
118658: 55 push %ebp
118659: 89 e5 mov %esp,%ebp
11865b: 57 push %edi
11865c: 56 push %esi
11865d: 53 push %ebx
11865e: 83 ec 0c sub $0xc,%esp
118661: 8b 5d 08 mov 0x8(%ebp),%ebx
118664: 8b 7d 10 mov 0x10(%ebp),%edi
Watchdog_Interval units = units_arg;
ISR_Level level;
Chain_Node *node;
if ( !units ) {
118667: 8b 45 0c mov 0xc(%ebp),%eax
11866a: 85 c0 test %eax,%eax
11866c: 74 6a je 1186d8 <_Watchdog_Adjust_to_chain+0x80>
return;
}
_ISR_Disable( level );
11866e: 9c pushf
11866f: fa cli
118670: 8f 45 ec popl -0x14(%ebp)
118673: 8b 13 mov (%ebx),%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
118675: 8d 4b 04 lea 0x4(%ebx),%ecx
if ( !_Chain_Is_empty( header ) ) {
118678: 39 ca cmp %ecx,%edx
11867a: 74 58 je 1186d4 <_Watchdog_Adjust_to_chain+0x7c>
11867c: 8b 72 10 mov 0x10(%edx),%esi
11867f: 8d 47 04 lea 0x4(%edi),%eax
118682: 89 45 f0 mov %eax,-0x10(%ebp)
118685: 8b 45 0c mov 0xc(%ebp),%eax
118688: 89 45 e8 mov %eax,-0x18(%ebp)
11868b: 90 nop
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
11868c: 3b 75 e8 cmp -0x18(%ebp),%esi
11868f: 77 3c ja 1186cd <_Watchdog_Adjust_to_chain+0x75>
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 0;
118691: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx)
118698: eb 2b jmp 1186c5 <_Watchdog_Adjust_to_chain+0x6d>
11869a: 66 90 xchg %ax,%ax
11869c: 8b 02 mov (%edx),%eax
11869e: 89 03 mov %eax,(%ebx)
1186a0: 89 58 04 mov %ebx,0x4(%eax)
1186a3: 8b 45 f0 mov -0x10(%ebp),%eax
1186a6: 89 02 mov %eax,(%edx)
1186a8: 8b 47 08 mov 0x8(%edi),%eax
1186ab: 89 57 08 mov %edx,0x8(%edi)
1186ae: 89 10 mov %edx,(%eax)
1186b0: 89 42 04 mov %eax,0x4(%edx)
do {
node = _Chain_Get_unprotected( header );
_Chain_Append_unprotected( to_fire, node );
_ISR_Flash( level );
1186b3: ff 75 ec pushl -0x14(%ebp)
1186b6: 9d popf
1186b7: 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(
1186b8: 8b 13 mov (%ebx),%edx
} while ( !_Chain_Is_empty( header ) &&
_Watchdog_First( header )->delta_interval == 0 );
1186ba: 39 d1 cmp %edx,%ecx
1186bc: 74 16 je 1186d4 <_Watchdog_Adjust_to_chain+0x7c>
1186be: 8b 42 10 mov 0x10(%edx),%eax
1186c1: 85 c0 test %eax,%eax
1186c3: 75 1b jne 1186e0 <_Watchdog_Adjust_to_chain+0x88>
1186c5: 39 d1 cmp %edx,%ecx
1186c7: 75 d3 jne 11869c <_Watchdog_Adjust_to_chain+0x44><== ALWAYS TAKEN
1186c9: 31 d2 xor %edx,%edx <== NOT EXECUTED
1186cb: eb d6 jmp 1186a3 <_Watchdog_Adjust_to_chain+0x4b><== NOT EXECUTED
_ISR_Disable( level );
if ( !_Chain_Is_empty( header ) ) {
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
1186cd: 2b 75 e8 sub -0x18(%ebp),%esi
1186d0: 89 72 10 mov %esi,0x10(%edx)
1186d3: 90 nop
break;
}
}
}
_ISR_Enable( level );
1186d4: ff 75 ec pushl -0x14(%ebp)
1186d7: 9d popf
}
1186d8: 83 c4 0c add $0xc,%esp
1186db: 5b pop %ebx
1186dc: 5e pop %esi
1186dd: 5f pop %edi
1186de: c9 leave
1186df: c3 ret
return;
}
_ISR_Disable( level );
if ( !_Chain_Is_empty( header ) ) {
while ( units ) {
1186e0: 29 75 e8 sub %esi,-0x18(%ebp)
1186e3: 74 ef je 1186d4 <_Watchdog_Adjust_to_chain+0x7c><== ALWAYS TAKEN
1186e5: 89 c6 mov %eax,%esi <== NOT EXECUTED
1186e7: eb a3 jmp 11868c <_Watchdog_Adjust_to_chain+0x34><== NOT EXECUTED
0010d1fc <_Watchdog_Insert>:
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
10d1fc: 55 push %ebp
10d1fd: 89 e5 mov %esp,%ebp
10d1ff: 57 push %edi
10d200: 56 push %esi
10d201: 53 push %ebx
10d202: 83 ec 04 sub $0x4,%esp
10d205: 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;
10d208: 8b 3d f8 e6 11 00 mov 0x11e6f8,%edi
_ISR_Disable( level );
10d20e: 9c pushf
10d20f: fa cli
10d210: 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 ) {
10d213: 8b 46 08 mov 0x8(%esi),%eax
10d216: 85 c0 test %eax,%eax
10d218: 75 72 jne 10d28c <_Watchdog_Insert+0x90> <== NEVER TAKEN
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
10d21a: c7 46 08 01 00 00 00 movl $0x1,0x8(%esi)
_Watchdog_Sync_count++;
10d221: a1 c0 e7 11 00 mov 0x11e7c0,%eax
10d226: 40 inc %eax
10d227: a3 c0 e7 11 00 mov %eax,0x11e7c0
restart:
delta_interval = the_watchdog->initial;
10d22c: 8b 5e 0c mov 0xc(%esi),%ebx
* cache *header!!
*
* Till Straumann, 7/2003 (gcc-3.2.2 -O4 on powerpc)
*
*/
for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ;
10d22f: 8b 45 08 mov 0x8(%ebp),%eax
10d232: 8b 08 mov (%eax),%ecx
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
10d234: 85 db test %ebx,%ebx
10d236: 74 65 je 10d29d <_Watchdog_Insert+0xa1> <== NEVER TAKEN
10d238: 8b 01 mov (%ecx),%eax
10d23a: 85 c0 test %eax,%eax
10d23c: 74 5f je 10d29d <_Watchdog_Insert+0xa1>
break;
if ( delta_interval < after->delta_interval ) {
10d23e: 8b 51 10 mov 0x10(%ecx),%edx
10d241: 39 d3 cmp %edx,%ebx
10d243: 73 21 jae 10d266 <_Watchdog_Insert+0x6a>
10d245: eb 51 jmp 10d298 <_Watchdog_Insert+0x9c>
10d247: 90 nop
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
10d248: a1 18 e7 11 00 mov 0x11e718,%eax
10d24d: 39 c7 cmp %eax,%edi
10d24f: 72 6f jb 10d2c0 <_Watchdog_Insert+0xc4>
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
10d251: 29 d3 sub %edx,%ebx
);
#ifdef __cplusplus
}
#endif
10d253: 8b 09 mov (%ecx),%ecx
*/
for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
10d255: 85 db test %ebx,%ebx
10d257: 74 44 je 10d29d <_Watchdog_Insert+0xa1>
10d259: 8b 11 mov (%ecx),%edx
10d25b: 85 d2 test %edx,%edx
10d25d: 74 3e je 10d29d <_Watchdog_Insert+0xa1>
break;
if ( delta_interval < after->delta_interval ) {
10d25f: 8b 51 10 mov 0x10(%ecx),%edx
10d262: 39 da cmp %ebx,%edx
10d264: 77 32 ja 10d298 <_Watchdog_Insert+0x9c>
* 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 );
10d266: ff 75 f0 pushl -0x10(%ebp)
10d269: 9d popf
10d26a: fa cli
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
10d26b: 83 7e 08 01 cmpl $0x1,0x8(%esi)
10d26f: 74 d7 je 10d248 <_Watchdog_Insert+0x4c> <== ALWAYS TAKEN
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
10d271: 89 3d 18 e7 11 00 mov %edi,0x11e718
_Watchdog_Sync_count--;
10d277: a1 c0 e7 11 00 mov 0x11e7c0,%eax
10d27c: 48 dec %eax
10d27d: a3 c0 e7 11 00 mov %eax,0x11e7c0
_ISR_Enable( level );
10d282: ff 75 f0 pushl -0x10(%ebp)
10d285: 9d popf
}
10d286: 58 pop %eax
10d287: 5b pop %ebx
10d288: 5e pop %esi
10d289: 5f pop %edi
10d28a: c9 leave
10d28b: c3 ret
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
10d28c: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED
10d28f: 9d popf <== NOT EXECUTED
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
10d290: 58 pop %eax <== NOT EXECUTED
10d291: 5b pop %ebx <== NOT EXECUTED
10d292: 5e pop %esi <== NOT EXECUTED
10d293: 5f pop %edi <== NOT EXECUTED
10d294: c9 leave <== NOT EXECUTED
10d295: c3 ret <== NOT EXECUTED
10d296: 66 90 xchg %ax,%ax <== NOT EXECUTED
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
break;
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
10d298: 29 da sub %ebx,%edx
10d29a: 89 51 10 mov %edx,0x10(%ecx)
* @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(
10d29d: c7 46 08 02 00 00 00 movl $0x2,0x8(%esi)
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
10d2a4: 89 5e 10 mov %ebx,0x10(%esi)
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
10d2a7: 8b 41 04 mov 0x4(%ecx),%eax
10d2aa: 89 46 04 mov %eax,0x4(%esi)
10d2ad: 8b 10 mov (%eax),%edx
10d2af: 89 30 mov %esi,(%eax)
10d2b1: 89 16 mov %edx,(%esi)
10d2b3: 89 72 04 mov %esi,0x4(%edx)
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
10d2b6: a1 c4 e7 11 00 mov 0x11e7c4,%eax
10d2bb: 89 46 14 mov %eax,0x14(%esi)
10d2be: eb b1 jmp 10d271 <_Watchdog_Insert+0x75>
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
_Watchdog_Sync_level = insert_isr_nest_level;
10d2c0: 89 3d 18 e7 11 00 mov %edi,0x11e718
10d2c6: e9 61 ff ff ff jmp 10d22c <_Watchdog_Insert+0x30>
0010d32c <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
10d32c: 55 push %ebp
10d32d: 89 e5 mov %esp,%ebp
10d32f: 56 push %esi
10d330: 53 push %ebx
10d331: 8b 4d 08 mov 0x8(%ebp),%ecx
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
10d334: 9c pushf
10d335: fa cli
10d336: 5e pop %esi
previous_state = the_watchdog->state;
10d337: 8b 59 08 mov 0x8(%ecx),%ebx
switch ( previous_state ) {
10d33a: 83 fb 01 cmp $0x1,%ebx
10d33d: 74 4d je 10d38c <_Watchdog_Remove+0x60> <== NEVER TAKEN
10d33f: 73 13 jae 10d354 <_Watchdog_Remove+0x28>
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
10d341: a1 c4 e7 11 00 mov 0x11e7c4,%eax
10d346: 89 41 18 mov %eax,0x18(%ecx)
_ISR_Enable( level );
10d349: 56 push %esi
10d34a: 9d popf
return( previous_state );
}
10d34b: 89 d8 mov %ebx,%eax
10d34d: 5b pop %ebx
10d34e: 5e pop %esi
10d34f: c9 leave
10d350: c3 ret
10d351: 8d 76 00 lea 0x0(%esi),%esi
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
previous_state = the_watchdog->state;
switch ( previous_state ) {
10d354: 83 fb 03 cmp $0x3,%ebx
10d357: 77 e8 ja 10d341 <_Watchdog_Remove+0x15> <== NEVER TAKEN
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
10d359: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx)
);
#ifdef __cplusplus
}
#endif
10d360: 8b 11 mov (%ecx),%edx
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
10d362: 8b 02 mov (%edx),%eax
10d364: 85 c0 test %eax,%eax
10d366: 74 06 je 10d36e <_Watchdog_Remove+0x42>
next_watchdog->delta_interval += the_watchdog->delta_interval;
10d368: 8b 41 10 mov 0x10(%ecx),%eax
10d36b: 01 42 10 add %eax,0x10(%edx)
if ( _Watchdog_Sync_count )
10d36e: a1 c0 e7 11 00 mov 0x11e7c0,%eax
10d373: 85 c0 test %eax,%eax
10d375: 74 0a je 10d381 <_Watchdog_Remove+0x55> <== ALWAYS TAKEN
_Watchdog_Sync_level = _ISR_Nest_level;
10d377: a1 f8 e6 11 00 mov 0x11e6f8,%eax <== NOT EXECUTED
10d37c: a3 18 e7 11 00 mov %eax,0x11e718 <== NOT EXECUTED
10d381: 8b 41 04 mov 0x4(%ecx),%eax
10d384: 89 42 04 mov %eax,0x4(%edx)
10d387: 89 10 mov %edx,(%eax)
10d389: eb b6 jmp 10d341 <_Watchdog_Remove+0x15>
10d38b: 90 nop
/*
* 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;
10d38c: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED
10d393: eb ac jmp 10d341 <_Watchdog_Remove+0x15> <== NOT EXECUTED
0010d398 <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
10d398: 55 push %ebp
10d399: 89 e5 mov %esp,%ebp
10d39b: 57 push %edi
10d39c: 56 push %esi
10d39d: 53 push %ebx
10d39e: 83 ec 0c sub $0xc,%esp
10d3a1: 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 );
10d3a4: 9c pushf
10d3a5: fa cli
10d3a6: 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(
10d3a7: 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
10d3a9: 8d 47 04 lea 0x4(%edi),%eax
10d3ac: 89 45 f0 mov %eax,-0x10(%ebp)
if ( _Chain_Is_empty( header ) )
10d3af: 39 c2 cmp %eax,%edx
10d3b1: 74 11 je 10d3c4 <_Watchdog_Tickle+0x2c>
10d3b3: 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) {
10d3b5: 8b 42 10 mov 0x10(%edx),%eax
10d3b8: 85 c0 test %eax,%eax
10d3ba: 74 34 je 10d3f0 <_Watchdog_Tickle+0x58> <== NEVER TAKEN
the_watchdog->delta_interval--;
10d3bc: 48 dec %eax
10d3bd: 89 42 10 mov %eax,0x10(%edx)
if ( the_watchdog->delta_interval != 0 )
10d3c0: 85 c0 test %eax,%eax
10d3c2: 74 2c je 10d3f0 <_Watchdog_Tickle+0x58>
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
10d3c4: 56 push %esi
10d3c5: 9d popf
}
10d3c6: 8d 65 f4 lea -0xc(%ebp),%esp
10d3c9: 5b pop %ebx
10d3ca: 5e pop %esi
10d3cb: 5f pop %edi
10d3cc: c9 leave
10d3cd: c3 ret
_ISR_Enable( level );
switch( watchdog_state ) {
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
10d3ce: 83 ec 08 sub $0x8,%esp
10d3d1: ff 73 24 pushl 0x24(%ebx)
10d3d4: ff 73 20 pushl 0x20(%ebx)
10d3d7: ff 53 1c call *0x1c(%ebx)
10d3da: 83 c4 10 add $0x10,%esp
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
10d3dd: 9c pushf
10d3de: fa cli
10d3df: 5e pop %esi
10d3e0: 8b 07 mov (%edi),%eax
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
10d3e2: 39 45 f0 cmp %eax,-0x10(%ebp)
10d3e5: 74 dd je 10d3c4 <_Watchdog_Tickle+0x2c>
10d3e7: 89 c3 mov %eax,%ebx
10d3e9: 8b 40 10 mov 0x10(%eax),%eax
10d3ec: 85 c0 test %eax,%eax
10d3ee: 75 d4 jne 10d3c4 <_Watchdog_Tickle+0x2c>
if ( the_watchdog->delta_interval != 0 )
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
10d3f0: 83 ec 0c sub $0xc,%esp
10d3f3: 53 push %ebx
10d3f4: e8 33 ff ff ff call 10d32c <_Watchdog_Remove>
_ISR_Enable( level );
10d3f9: 56 push %esi
10d3fa: 9d popf
switch( watchdog_state ) {
10d3fb: 83 c4 10 add $0x10,%esp
10d3fe: 83 f8 02 cmp $0x2,%eax
10d401: 75 da jne 10d3dd <_Watchdog_Tickle+0x45> <== NEVER TAKEN
10d403: eb c9 jmp 10d3ce <_Watchdog_Tickle+0x36>
0010d460 <_Workspace_Handler_initialization>:
*/
void _Workspace_Handler_initialization(
void *starting_address,
size_t size
)
{
10d460: 55 push %ebp
10d461: 89 e5 mov %esp,%ebp
10d463: 57 push %edi
10d464: 83 ec 04 sub $0x4,%esp
10d467: 8b 55 08 mov 0x8(%ebp),%edx
uint32_t memory_available;
if ( !starting_address || !_Addresses_Is_aligned( starting_address ) )
10d46a: 85 d2 test %edx,%edx
10d46c: 74 2e je 10d49c <_Workspace_Handler_initialization+0x3c>
10d46e: f6 c2 03 test $0x3,%dl
10d471: 75 29 jne 10d49c <_Workspace_Handler_initialization+0x3c><== NEVER TAKEN
INTERNAL_ERROR_CORE,
TRUE,
INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS
);
if ( _Configuration_Table->do_zero_of_workspace )
10d473: a1 f4 e6 11 00 mov 0x11e6f4,%eax
10d478: 80 78 28 00 cmpb $0x0,0x28(%eax)
10d47c: 75 2a jne 10d4a8 <_Workspace_Handler_initialization+0x48><== NEVER TAKEN
memset( starting_address, 0, size );
memory_available = _Heap_Initialize(
10d47e: 6a 04 push $0x4
10d480: ff 75 0c pushl 0xc(%ebp)
10d483: 52 push %edx
10d484: 68 80 e6 11 00 push $0x11e680
10d489: e8 aa de ff ff call 10b338 <_Heap_Initialize>
starting_address,
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
10d48e: 83 c4 10 add $0x10,%esp
10d491: 85 c0 test %eax,%eax
10d493: 74 1e je 10d4b3 <_Workspace_Handler_initialization+0x53><== NEVER TAKEN
_Internal_error_Occurred(
INTERNAL_ERROR_CORE,
TRUE,
INTERNAL_ERROR_TOO_LITTLE_WORKSPACE
);
}
10d495: 8b 7d fc mov -0x4(%ebp),%edi
10d498: c9 leave
10d499: c3 ret
10d49a: 66 90 xchg %ax,%ax
)
{
uint32_t memory_available;
if ( !starting_address || !_Addresses_Is_aligned( starting_address ) )
_Internal_error_Occurred(
10d49c: 51 push %ecx
10d49d: 6a 02 push $0x2
10d49f: 6a 01 push $0x1
10d4a1: 6a 00 push $0x0
10d4a3: e8 78 e0 ff ff call 10b520 <_Internal_error_Occurred>
TRUE,
INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS
);
if ( _Configuration_Table->do_zero_of_workspace )
memset( starting_address, 0, size );
10d4a8: 31 c0 xor %eax,%eax
10d4aa: 89 d7 mov %edx,%edi <== NOT EXECUTED
10d4ac: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
10d4af: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED
10d4b1: eb cb jmp 10d47e <_Workspace_Handler_initialization+0x1e><== NOT EXECUTED
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
_Internal_error_Occurred(
10d4b3: 52 push %edx <== NOT EXECUTED
10d4b4: 6a 03 push $0x3 <== NOT EXECUTED
10d4b6: 6a 01 push $0x1 <== NOT EXECUTED
10d4b8: 6a 00 push $0x0 <== NOT EXECUTED
10d4ba: e8 61 e0 ff ff call 10b520 <_Internal_error_Occurred><== NOT EXECUTED
00106ec8 <__assert>:
void __assert(
const char *file,
int line,
const char *failedexpr
)
{
106ec8: 55 push %ebp <== NOT EXECUTED
106ec9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106ecb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
__assert_func (file, line, NULL, failedexpr);
106ece: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED
106ed1: 6a 00 push $0x0 <== NOT EXECUTED
106ed3: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
106ed6: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
106ed9: e8 aa ff ff ff call 106e88 <__assert_func> <== NOT EXECUTED
106ede: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
106ee1: c9 leave <== NOT EXECUTED
106ee2: c3 ret <== NOT EXECUTED
00106e88 <__assert_func>:
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
106e88: 55 push %ebp <== NOT EXECUTED
106e89: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106e8b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
106e8e: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
106e91: 85 c0 test %eax,%eax <== NOT EXECUTED
106e93: 74 27 je 106ebc <__assert_func+0x34> <== NOT EXECUTED
106e95: ba 57 84 11 00 mov $0x118457,%edx <== NOT EXECUTED
106e9a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
106e9d: 50 push %eax <== NOT EXECUTED
106e9e: 52 push %edx <== NOT EXECUTED
106e9f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
106ea2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
106ea5: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED
106ea8: 68 64 84 11 00 push $0x118464 <== NOT EXECUTED
106ead: e8 86 0f 00 00 call 107e38 <printk> <== NOT EXECUTED
file,
line,
(func) ? ", function: " : "",
(func) ? func : ""
);
rtems_fatal_error_occurred(0);
106eb2: 83 c4 14 add $0x14,%esp <== NOT EXECUTED
106eb5: 6a 00 push $0x0 <== NOT EXECUTED
106eb7: e8 c8 3b 00 00 call 10aa84 <rtems_fatal_error_occurred><== NOT EXECUTED
int line,
const char *func,
const char *failedexpr
)
{
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
106ebc: ba c6 85 11 00 mov $0x1185c6,%edx <== NOT EXECUTED
106ec1: 89 d0 mov %edx,%eax <== NOT EXECUTED
106ec3: eb d5 jmp 106e9a <__assert_func+0x12> <== NOT EXECUTED
00119350 <__kill>:
#endif
#endif
int __kill( pid_t pid, int sig )
{
119350: 55 push %ebp <== NOT EXECUTED
119351: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return 0;
}
119353: 31 c0 xor %eax,%eax <== NOT EXECUTED
119355: c9 leave <== NOT EXECUTED
119356: c3 ret <== NOT EXECUTED
00116774 <_exit>:
/*
* If the toolset uses init/fini sections, then we need to
* run the global destructors now.
*/
#if defined(__USE_INIT_FINI__)
_fini();
116774: 55 push %ebp
116775: 89 e5 mov %esp,%ebp
116777: 83 ec 08 sub $0x8,%esp
11677a: e8 5e 07 00 00 call 116edd <_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();
11677f: e8 84 ff ff ff call 116708 <libc_wrapup>
rtems_shutdown_executive(status);
116784: 83 ec 0c sub $0xc,%esp
116787: ff 75 08 pushl 0x8(%ebp)
11678a: e8 f9 00 00 00 call 116888 <rtems_shutdown_executive>
11678f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
116792: eb fe jmp 116792 <_exit+0x1e> <== NOT EXECUTED
00119218 <_getpid_r>:
#include <reent.h>
pid_t _getpid_r(
struct _reent *ptr
)
{
119218: 55 push %ebp <== NOT EXECUTED
119219: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return getpid();
}
11921b: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
119220: c9 leave <== NOT EXECUTED
119221: c3 ret <== NOT EXECUTED
0010e6a8 <_gettimeofday>:
int _gettimeofday(
struct timeval *tp,
struct timezone *tzp
)
{
10e6a8: 55 push %ebp <== NOT EXECUTED
10e6a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return gettimeofday( tp, tzp );
}
10e6ab: c9 leave <== NOT EXECUTED
int _gettimeofday(
struct timeval *tp,
struct timezone *tzp
)
{
return gettimeofday( tp, tzp );
10e6ac: e9 a3 ff ff ff jmp 10e654 <gettimeofday> <== NOT EXECUTED
00119348 <_kill_r>:
#if defined(RTEMS_NEWLIB)
#include <reent.h>
int _kill_r( struct _reent *ptr, pid_t pid, int sig )
{
119348: 55 push %ebp <== NOT EXECUTED
119349: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return 0;
}
11934b: 31 c0 xor %eax,%eax <== NOT EXECUTED
11934d: c9 leave <== NOT EXECUTED
11934e: c3 ret <== NOT EXECUTED
001166dc <_lseek_r>:
struct _reent *ptr,
int fd,
off_t offset,
int whence
)
{
1166dc: 55 push %ebp <== NOT EXECUTED
1166dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1166df: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
1166e2: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
return lseek( fd, offset, whence );
1166e5: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
1166e8: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED
1166eb: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED
1166ee: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED
}
1166f1: c9 leave <== NOT EXECUTED
int fd,
off_t offset,
int whence
)
{
return lseek( fd, offset, whence );
1166f2: e9 29 ff ff ff jmp 116620 <lseek> <== NOT EXECUTED
00107b04 <_open_r>:
struct _reent *ptr,
const char *buf,
int flags,
int mode
)
{
107b04: 55 push %ebp <== NOT EXECUTED
107b05: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107b07: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
107b0a: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
return open( buf, flags, mode );
107b0d: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
107b10: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED
107b13: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED
107b16: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED
}
107b19: c9 leave <== NOT EXECUTED
const char *buf,
int flags,
int mode
)
{
return open( buf, flags, mode );
107b1a: e9 61 fd ff ff jmp 107880 <open> <== NOT EXECUTED
00116838 <_read_r>:
struct _reent *ptr,
int fd,
void *buf,
size_t nbytes
)
{
116838: 55 push %ebp <== NOT EXECUTED
116839: 89 e5 mov %esp,%ebp <== NOT EXECUTED
11683b: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
11683e: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
return read( fd, buf, nbytes );
116841: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
116844: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED
116847: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED
11684a: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED
}
11684d: c9 leave <== NOT EXECUTED
int fd,
void *buf,
size_t nbytes
)
{
return read( fd, buf, nbytes );
11684e: e9 41 ff ff ff jmp 116794 <read> <== NOT EXECUTED
00116854 <_realloc_r>:
void *_realloc_r(
struct _reent *ignored,
void *ptr,
size_t size
)
{
116854: 55 push %ebp <== NOT EXECUTED
116855: 89 e5 mov %esp,%ebp <== NOT EXECUTED
116857: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
return realloc( ptr, size );
11685a: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
11685d: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED
116860: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED
}
116863: c9 leave <== NOT EXECUTED
struct _reent *ignored,
void *ptr,
size_t size
)
{
return realloc( ptr, size );
116864: e9 4f 00 00 00 jmp 1168b8 <realloc> <== NOT EXECUTED
0010e4bc <calloc>:
)
{
register char *cptr;
int length;
MSBUMP(calloc_calls, 1);
10e4bc: 55 push %ebp
10e4bd: 89 e5 mov %esp,%ebp
10e4bf: 57 push %edi
10e4c0: 53 push %ebx
10e4c1: 8b 5d 0c mov 0xc(%ebp),%ebx
10e4c4: ff 05 74 e5 11 00 incl 0x11e574
length = nelem * elsize;
10e4ca: 0f af 5d 08 imul 0x8(%ebp),%ebx
cptr = malloc( length );
10e4ce: 83 ec 0c sub $0xc,%esp
10e4d1: 53 push %ebx
10e4d2: e8 01 8e ff ff call 1072d8 <malloc>
10e4d7: 89 c2 mov %eax,%edx
if ( cptr )
10e4d9: 83 c4 10 add $0x10,%esp
10e4dc: 85 c0 test %eax,%eax
10e4de: 74 08 je 10e4e8 <calloc+0x2c> <== NEVER TAKEN
memset( cptr, '\0', length );
10e4e0: 31 c0 xor %eax,%eax
10e4e2: 89 d7 mov %edx,%edi
10e4e4: 89 d9 mov %ebx,%ecx
10e4e6: f3 aa rep stos %al,%es:(%edi)
MSBUMP(malloc_calls, -1); /* subtract off the malloc */
10e4e8: ff 0d 64 e5 11 00 decl 0x11e564
return cptr;
}
10e4ee: 89 d0 mov %edx,%eax
10e4f0: 8d 65 f8 lea -0x8(%ebp),%esp
10e4f3: 5b pop %ebx
10e4f4: 5f pop %edi
10e4f5: c9 leave
10e4f6: c3 ret
0010e4f8 <close>:
#include <rtems/libio_.h>
int close(
int fd
)
{
10e4f8: 55 push %ebp
10e4f9: 89 e5 mov %esp,%ebp
10e4fb: 56 push %esi
10e4fc: 53 push %ebx
10e4fd: 8b 55 08 mov 0x8(%ebp),%edx
rtems_libio_t *iop;
rtems_status_code rc;
rtems_libio_check_fd(fd);
10e500: 3b 15 40 a0 11 00 cmp 0x11a040,%edx
10e506: 73 64 jae 10e56c <close+0x74> <== NEVER TAKEN
iop = rtems_libio_iop(fd);
10e508: 8d 04 52 lea (%edx,%edx,2),%eax
10e50b: 8d 04 82 lea (%edx,%eax,4),%eax
10e50e: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx
10e515: 03 1d d0 e4 11 00 add 0x11e4d0,%ebx
rtems_libio_check_is_open(iop);
10e51b: f6 43 0d 01 testb $0x1,0xd(%ebx)
10e51f: 74 4b je 10e56c <close+0x74> <== NEVER TAKEN
rc = RTEMS_SUCCESSFUL;
if ( iop->handlers->close_h )
10e521: 8b 43 30 mov 0x30(%ebx),%eax
10e524: 8b 40 04 mov 0x4(%eax),%eax
10e527: 85 c0 test %eax,%eax
10e529: 74 3d je 10e568 <close+0x70> <== NEVER TAKEN
rc = (*iop->handlers->close_h)( iop );
10e52b: 83 ec 0c sub $0xc,%esp
10e52e: 53 push %ebx
10e52f: ff d0 call *%eax
10e531: 89 c6 mov %eax,%esi
10e533: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( &iop->pathinfo );
10e536: 8b 43 18 mov 0x18(%ebx),%eax
10e539: 85 c0 test %eax,%eax
10e53b: 74 13 je 10e550 <close+0x58> <== NEVER TAKEN
10e53d: 8b 50 1c mov 0x1c(%eax),%edx
10e540: 85 d2 test %edx,%edx
10e542: 74 0c je 10e550 <close+0x58> <== ALWAYS TAKEN
10e544: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10e547: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED
10e54a: 50 push %eax <== NOT EXECUTED
10e54b: ff d2 call *%edx <== NOT EXECUTED
10e54d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_libio_free( iop );
10e550: 83 ec 0c sub $0xc,%esp
10e553: 53 push %ebx
10e554: e8 7b 02 00 00 call 10e7d4 <rtems_libio_free>
10e559: 83 c4 10 add $0x10,%esp
return rc;
}
10e55c: 89 f0 mov %esi,%eax
10e55e: 8d 65 f8 lea -0x8(%ebp),%esp
10e561: 5b pop %ebx
10e562: 5e pop %esi
10e563: c9 leave
10e564: c3 ret
10e565: 8d 76 00 lea 0x0(%esi),%esi
rtems_libio_check_fd(fd);
iop = rtems_libio_iop(fd);
rtems_libio_check_is_open(iop);
rc = RTEMS_SUCCESSFUL;
if ( iop->handlers->close_h )
10e568: 31 f6 xor %esi,%esi
10e56a: eb ca jmp 10e536 <close+0x3e> <== NOT EXECUTED
rtems_libio_t *iop;
rtems_status_code rc;
rtems_libio_check_fd(fd);
iop = rtems_libio_iop(fd);
rtems_libio_check_is_open(iop);
10e56c: e8 af 1c 00 00 call 110220 <__errno> <== NOT EXECUTED
10e571: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
10e577: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED
10e57c: eb de jmp 10e55c <close+0x64> <== NOT EXECUTED
0010fa48 <device_close>:
*/
int device_close(
rtems_libio_t *iop
)
{
10fa48: 55 push %ebp
10fa49: 89 e5 mov %esp,%ebp
10fa4b: 83 ec 1c sub $0x1c,%esp
10fa4e: 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;
10fa51: 8b 50 2c mov 0x2c(%eax),%edx
args.iop = iop;
10fa54: 89 45 f4 mov %eax,-0xc(%ebp)
args.flags = 0;
10fa57: c7 45 f8 00 00 00 00 movl $0x0,-0x8(%ebp)
args.mode = 0;
10fa5e: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
status = rtems_io_close(
10fa65: 8d 45 f4 lea -0xc(%ebp),%eax
10fa68: 50 push %eax
10fa69: ff 72 54 pushl 0x54(%edx)
10fa6c: ff 72 50 pushl 0x50(%edx)
10fa6f: e8 34 04 00 00 call 10fea8 <rtems_io_close>
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status ) {
10fa74: 83 c4 10 add $0x10,%esp
10fa77: 85 c0 test %eax,%eax
10fa79: 75 05 jne 10fa80 <device_close+0x38> <== NEVER TAKEN
return rtems_deviceio_errno(status);
}
return 0;
}
10fa7b: c9 leave
10fa7c: c3 ret
10fa7d: 8d 76 00 lea 0x0(%esi),%esi
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status ) {
return rtems_deviceio_errno(status);
10fa80: e8 af fe ff ff call 10f934 <rtems_deviceio_errno> <== NOT EXECUTED
}
return 0;
}
10fa85: c9 leave <== NOT EXECUTED
10fa86: c3 ret <== NOT EXECUTED
0010f92c <device_ftruncate>:
int device_ftruncate(
rtems_libio_t *iop,
off_t length
)
{
10f92c: 55 push %ebp <== NOT EXECUTED
10f92d: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return 0;
}
10f92f: 31 c0 xor %eax,%eax <== NOT EXECUTED
10f931: c9 leave <== NOT EXECUTED
10f932: c3 ret <== NOT EXECUTED
0010f960 <device_ioctl>:
int device_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
10f960: 55 push %ebp <== NOT EXECUTED
10f961: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10f963: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED
10f966: 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;
10f969: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED
args.command = command;
10f96c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10f96f: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED
args.buffer = buffer;
10f972: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
10f975: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED
the_jnode = iop->file_info;
10f978: 8b 52 2c mov 0x2c(%edx),%edx <== NOT EXECUTED
status = rtems_io_control(
10f97b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED
10f97e: 50 push %eax <== NOT EXECUTED
10f97f: ff 72 54 pushl 0x54(%edx) <== NOT EXECUTED
10f982: ff 72 50 pushl 0x50(%edx) <== NOT EXECUTED
10f985: e8 5e 05 00 00 call 10fee8 <rtems_io_control> <== NOT EXECUTED
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
10f98a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10f98d: 85 c0 test %eax,%eax <== NOT EXECUTED
10f98f: 75 07 jne 10f998 <device_ioctl+0x38> <== NOT EXECUTED
return rtems_deviceio_errno(status);
return args.ioctl_return;
10f991: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED
}
10f994: c9 leave <== NOT EXECUTED
10f995: c3 ret <== NOT EXECUTED
10f996: 66 90 xchg %ax,%ax <== NOT EXECUTED
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
10f998: e8 97 ff ff ff call 10f934 <rtems_deviceio_errno> <== NOT EXECUTED
return args.ioctl_return;
}
10f99d: c9 leave <== NOT EXECUTED
10f99e: c3 ret <== NOT EXECUTED
0010f924 <device_lseek>:
off_t device_lseek(
rtems_libio_t *iop,
off_t offset,
int whence
)
{
10f924: 55 push %ebp <== NOT EXECUTED
10f925: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return offset;
}
10f927: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10f92a: c9 leave <== NOT EXECUTED
10f92b: c3 ret <== NOT EXECUTED
0010fa88 <device_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
10fa88: 55 push %ebp
10fa89: 89 e5 mov %esp,%ebp
10fa8b: 83 ec 1c sub $0x1c,%esp
10fa8e: 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;
10fa91: 8b 50 2c mov 0x2c(%eax),%edx
args.iop = iop;
10fa94: 89 45 f4 mov %eax,-0xc(%ebp)
args.flags = iop->flags;
10fa97: 8b 40 0c mov 0xc(%eax),%eax
10fa9a: 89 45 f8 mov %eax,-0x8(%ebp)
args.mode = mode;
10fa9d: 8b 45 14 mov 0x14(%ebp),%eax
10faa0: 89 45 fc mov %eax,-0x4(%ebp)
status = rtems_io_open(
10faa3: 8d 45 f4 lea -0xc(%ebp),%eax
10faa6: 50 push %eax
10faa7: ff 72 54 pushl 0x54(%edx)
10faaa: ff 72 50 pushl 0x50(%edx)
10faad: e8 76 04 00 00 call 10ff28 <rtems_io_open>
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
10fab2: 83 c4 10 add $0x10,%esp
10fab5: 85 c0 test %eax,%eax
10fab7: 75 03 jne 10fabc <device_open+0x34> <== NEVER TAKEN
return rtems_deviceio_errno(status);
return 0;
}
10fab9: c9 leave
10faba: c3 ret
10fabb: 90 nop
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
10fabc: e8 73 fe ff ff call 10f934 <rtems_deviceio_errno> <== NOT EXECUTED
return 0;
}
10fac1: c9 leave <== NOT EXECUTED
10fac2: c3 ret <== NOT EXECUTED
0010f9f4 <device_read>:
ssize_t device_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
10f9f4: 55 push %ebp <== NOT EXECUTED
10f9f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10f9f7: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED
10f9fa: 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;
10f9fd: 8b 4a 2c mov 0x2c(%edx),%ecx <== NOT EXECUTED
args.iop = iop;
10fa00: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED
args.offset = iop->offset;
10fa03: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED
10fa06: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED
args.buffer = buffer;
10fa09: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10fa0c: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED
args.count = count;
10fa0f: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
10fa12: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED
args.flags = iop->flags;
10fa15: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED
10fa18: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED
args.bytes_moved = 0;
10fa1b: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED
status = rtems_io_read(
10fa22: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED
10fa25: 50 push %eax <== NOT EXECUTED
10fa26: ff 71 54 pushl 0x54(%ecx) <== NOT EXECUTED
10fa29: ff 71 50 pushl 0x50(%ecx) <== NOT EXECUTED
10fa2c: e8 37 05 00 00 call 10ff68 <rtems_io_read> <== NOT EXECUTED
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
10fa31: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10fa34: 85 c0 test %eax,%eax <== NOT EXECUTED
10fa36: 75 08 jne 10fa40 <device_read+0x4c> <== NOT EXECUTED
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
10fa38: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED
}
10fa3b: c9 leave <== NOT EXECUTED
10fa3c: c3 ret <== NOT EXECUTED
10fa3d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
10fa40: e8 ef fe ff ff call 10f934 <rtems_deviceio_errno> <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
}
10fa45: c9 leave <== NOT EXECUTED
10fa46: c3 ret <== NOT EXECUTED
0010f9a0 <device_write>:
ssize_t device_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
10f9a0: 55 push %ebp
10f9a1: 89 e5 mov %esp,%ebp
10f9a3: 83 ec 2c sub $0x2c,%esp
10f9a6: 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;
10f9a9: 8b 4a 2c mov 0x2c(%edx),%ecx
args.iop = iop;
10f9ac: 89 55 e8 mov %edx,-0x18(%ebp)
args.offset = iop->offset;
10f9af: 8b 42 08 mov 0x8(%edx),%eax
10f9b2: 89 45 ec mov %eax,-0x14(%ebp)
args.buffer = (void *) buffer;
10f9b5: 8b 45 0c mov 0xc(%ebp),%eax
10f9b8: 89 45 f0 mov %eax,-0x10(%ebp)
args.count = count;
10f9bb: 8b 45 10 mov 0x10(%ebp),%eax
10f9be: 89 45 f4 mov %eax,-0xc(%ebp)
args.flags = iop->flags;
10f9c1: 8b 42 0c mov 0xc(%edx),%eax
10f9c4: 89 45 f8 mov %eax,-0x8(%ebp)
args.bytes_moved = 0;
10f9c7: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
status = rtems_io_write(
10f9ce: 8d 45 e8 lea -0x18(%ebp),%eax
10f9d1: 50 push %eax
10f9d2: ff 71 54 pushl 0x54(%ecx)
10f9d5: ff 71 50 pushl 0x50(%ecx)
10f9d8: e8 cb 05 00 00 call 10ffa8 <rtems_io_write>
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
10f9dd: 83 c4 10 add $0x10,%esp
10f9e0: 85 c0 test %eax,%eax
10f9e2: 75 08 jne 10f9ec <device_write+0x4c> <== NEVER TAKEN
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
10f9e4: 8b 45 fc mov -0x4(%ebp),%eax
}
10f9e7: c9 leave
10f9e8: c3 ret
10f9e9: 8d 76 00 lea 0x0(%esi),%esi
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
10f9ec: e8 43 ff ff ff call 10f934 <rtems_deviceio_errno> <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
}
10f9f1: c9 leave <== NOT EXECUTED
10f9f2: c3 ret <== NOT EXECUTED
00108c54 <drainOutput>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
108c54: 55 push %ebp
108c55: 89 e5 mov %esp,%ebp
108c57: 53 push %ebx
108c58: 83 ec 04 sub $0x4,%esp
108c5b: 89 c3 mov %eax,%ebx
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
108c5d: 8b 80 b4 00 00 00 mov 0xb4(%eax),%eax
108c63: 85 c0 test %eax,%eax
108c65: 74 4d je 108cb4 <drainOutput+0x60> <== NEVER TAKEN
rtems_interrupt_disable (level);
108c67: 9c pushf
108c68: fa cli
108c69: 59 pop %ecx
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
108c6a: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx
108c70: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
108c76: 39 c2 cmp %eax,%edx
108c78: 74 38 je 108cb2 <drainOutput+0x5e>
108c7a: 66 90 xchg %ax,%ax
tty->rawOutBufState = rob_wait;
108c7c: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx)
108c83: 00 00 00
rtems_interrupt_enable (level);
108c86: 51 push %ecx
108c87: 9d popf
sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
108c88: 50 push %eax
108c89: 6a 00 push $0x0
108c8b: 6a 00 push $0x0
108c8d: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
108c93: e8 58 17 00 00 call 10a3f0 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
108c98: 83 c4 10 add $0x10,%esp
108c9b: 85 c0 test %eax,%eax
108c9d: 75 1d jne 108cbc <drainOutput+0x68> <== NEVER TAKEN
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
108c9f: 9c pushf
108ca0: fa cli
108ca1: 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) {
108ca2: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx
108ca8: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
108cae: 39 c2 cmp %eax,%edx
108cb0: 75 ca jne 108c7c <drainOutput+0x28> <== NEVER TAKEN
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
rtems_interrupt_enable (level);
108cb2: 51 push %ecx
108cb3: 9d popf
}
}
108cb4: 8b 5d fc mov -0x4(%ebp),%ebx
108cb7: c9 leave
108cb8: c3 ret
108cb9: 8d 76 00 lea 0x0(%esi),%esi
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
108cbc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108cbf: 50 push %eax <== NOT EXECUTED
108cc0: e8 bf 1d 00 00 call 10aa84 <rtems_fatal_error_occurred><== NOT EXECUTED
001087f0 <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
1087f0: 55 push %ebp <== NOT EXECUTED
1087f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1087f3: 53 push %ebx <== NOT EXECUTED
1087f4: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED
1087f7: 89 d3 mov %edx,%ebx <== NOT EXECUTED
1087f9: 88 c1 mov %al,%cl <== NOT EXECUTED
if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
1087fb: f6 42 3d 02 testb $0x2,0x3d(%edx) <== NOT EXECUTED
1087ff: 74 0e je 10880f <echo+0x1f> <== NOT EXECUTED
108801: 0f b6 d0 movzbl %al,%edx <== NOT EXECUTED
108804: a1 14 c5 11 00 mov 0x11c514,%eax <== NOT EXECUTED
108809: f6 04 10 20 testb $0x20,(%eax,%edx,1) <== NOT EXECUTED
10880d: 75 11 jne 108820 <echo+0x30> <== NOT EXECUTED
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
}
else {
oproc (c, tty);
10880f: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED
108812: 89 da mov %ebx,%edx <== NOT EXECUTED
108814: e8 a7 fe ff ff call 1086c0 <oproc> <== NOT EXECUTED
}
}
108819: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10881c: c9 leave <== NOT EXECUTED
10881d: c3 ret <== NOT EXECUTED
10881e: 66 90 xchg %ax,%ax <== NOT EXECUTED
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
108820: 80 f9 09 cmp $0x9,%cl <== NOT EXECUTED
108823: 74 ea je 10880f <echo+0x1f> <== NOT EXECUTED
108825: 80 f9 0a cmp $0xa,%cl <== NOT EXECUTED
108828: 74 e5 je 10880f <echo+0x1f> <== NOT EXECUTED
char echobuf[2];
echobuf[0] = '^';
10882a: c6 45 fa 5e movb $0x5e,-0x6(%ebp) <== NOT EXECUTED
echobuf[1] = c ^ 0x40;
10882e: 83 f1 40 xor $0x40,%ecx <== NOT EXECUTED
108831: 88 4d fb mov %cl,-0x5(%ebp) <== NOT EXECUTED
rtems_termios_puts (echobuf, 2, tty);
108834: 50 push %eax <== NOT EXECUTED
108835: 53 push %ebx <== NOT EXECUTED
108836: 6a 02 push $0x2 <== NOT EXECUTED
108838: 8d 45 fa lea -0x6(%ebp),%eax <== NOT EXECUTED
10883b: 50 push %eax <== NOT EXECUTED
10883c: e8 4f fd ff ff call 108590 <rtems_termios_puts> <== NOT EXECUTED
tty->column += 2;
108841: 83 43 28 02 addl $0x2,0x28(%ebx) <== NOT EXECUTED
108845: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
else {
oproc (c, tty);
}
}
108848: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10884b: c9 leave <== NOT EXECUTED
10884c: c3 ret <== NOT EXECUTED
00108850 <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)
{
108850: 55 push %ebp <== NOT EXECUTED
108851: 89 e5 mov %esp,%ebp <== NOT EXECUTED
108853: 57 push %edi <== NOT EXECUTED
108854: 56 push %esi <== NOT EXECUTED
108855: 53 push %ebx <== NOT EXECUTED
108856: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED
108859: 89 c3 mov %eax,%ebx <== NOT EXECUTED
10885b: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED
if (tty->ccount == 0)
10885e: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED
108861: 85 c0 test %eax,%eax <== NOT EXECUTED
108863: 74 57 je 1088bc <erase+0x6c> <== NOT EXECUTED
return;
if (lineFlag) {
108865: 85 d2 test %edx,%edx <== NOT EXECUTED
108867: 0f 85 bb 00 00 00 jne 108928 <erase+0xd8> <== NOT EXECUTED
10886d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
108870: 8b 4b 3c mov 0x3c(%ebx),%ecx <== NOT EXECUTED
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
108873: 8b 53 1c mov 0x1c(%ebx),%edx <== NOT EXECUTED
108876: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED
108879: 8d 78 ff lea -0x1(%eax),%edi <== NOT EXECUTED
10887c: 89 7b 20 mov %edi,0x20(%ebx) <== NOT EXECUTED
10887f: 8a 04 3a mov (%edx,%edi,1),%al <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
108882: f6 c1 08 test $0x8,%cl <== NOT EXECUTED
108885: 74 25 je 1088ac <erase+0x5c> <== NOT EXECUTED
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
108887: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED
10888a: 85 d2 test %edx,%edx <== NOT EXECUTED
10888c: 74 36 je 1088c4 <erase+0x74> <== NOT EXECUTED
echo (tty->termios.c_cc[VERASE], tty);
}
else if (c == '\t') {
10888e: 3c 09 cmp $0x9,%al <== NOT EXECUTED
108890: 0f 84 d2 00 00 00 je 108968 <erase+0x118> <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
108896: 0f b6 f0 movzbl %al,%esi <== NOT EXECUTED
108899: a1 14 c5 11 00 mov 0x11c514,%eax <== NOT EXECUTED
10889e: f6 04 30 20 testb $0x20,(%eax,%esi,1) <== NOT EXECUTED
1088a2: 74 65 je 108909 <erase+0xb9> <== NOT EXECUTED
1088a4: 80 e5 02 and $0x2,%ch <== NOT EXECUTED
1088a7: 75 33 jne 1088dc <erase+0x8c> <== NOT EXECUTED
1088a9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
1088ac: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
1088af: 85 c0 test %eax,%eax <== NOT EXECUTED
1088b1: 74 09 je 1088bc <erase+0x6c> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
1088b3: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED
1088b6: 85 c0 test %eax,%eax <== NOT EXECUTED
1088b8: 75 b6 jne 108870 <erase+0x20> <== NOT EXECUTED
1088ba: 66 90 xchg %ax,%ax <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
1088bc: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1088bf: 5b pop %ebx <== NOT EXECUTED
1088c0: 5e pop %esi <== NOT EXECUTED
1088c1: 5f pop %edi <== NOT EXECUTED
1088c2: c9 leave <== NOT EXECUTED
1088c3: c3 ret <== 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)) {
1088c4: f6 c1 10 test $0x10,%cl <== NOT EXECUTED
1088c7: 75 c5 jne 10888e <erase+0x3e> <== NOT EXECUTED
echo (tty->termios.c_cc[VERASE], tty);
1088c9: 0f b6 43 43 movzbl 0x43(%ebx),%eax <== NOT EXECUTED
1088cd: 89 da mov %ebx,%edx <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
1088cf: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1088d2: 5b pop %ebx <== NOT EXECUTED
1088d3: 5e pop %esi <== NOT EXECUTED
1088d4: 5f pop %edi <== NOT EXECUTED
1088d5: 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);
1088d6: e9 15 ff ff ff jmp 1087f0 <echo> <== NOT EXECUTED
1088db: 90 nop <== NOT EXECUTED
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
1088dc: 52 push %edx <== NOT EXECUTED
1088dd: 53 push %ebx <== NOT EXECUTED
1088de: 6a 03 push $0x3 <== NOT EXECUTED
1088e0: 68 c3 85 11 00 push $0x1185c3 <== NOT EXECUTED
1088e5: e8 a6 fc ff ff call 108590 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
1088ea: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
1088ed: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1088f0: 85 c0 test %eax,%eax <== NOT EXECUTED
1088f2: 74 04 je 1088f8 <erase+0xa8> <== NOT EXECUTED
tty->column--;
1088f4: 48 dec %eax <== NOT EXECUTED
1088f5: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
1088f8: a1 14 c5 11 00 mov 0x11c514,%eax <== NOT EXECUTED
1088fd: f6 04 30 20 testb $0x20,(%eax,%esi,1) <== NOT EXECUTED
108901: 74 06 je 108909 <erase+0xb9> <== NOT EXECUTED
108903: f6 43 3d 02 testb $0x2,0x3d(%ebx) <== NOT EXECUTED
108907: 74 a3 je 1088ac <erase+0x5c> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
108909: 50 push %eax <== NOT EXECUTED
10890a: 53 push %ebx <== NOT EXECUTED
10890b: 6a 03 push $0x3 <== NOT EXECUTED
10890d: 68 c3 85 11 00 push $0x1185c3 <== NOT EXECUTED
108912: e8 79 fc ff ff call 108590 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
108917: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
10891a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10891d: 85 c0 test %eax,%eax <== NOT EXECUTED
10891f: 74 8b je 1088ac <erase+0x5c> <== NOT EXECUTED
tty->column--;
108921: 48 dec %eax <== NOT EXECUTED
108922: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
108925: eb 85 jmp 1088ac <erase+0x5c> <== NOT EXECUTED
108927: 90 nop <== NOT EXECUTED
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
108928: 8b 4b 3c mov 0x3c(%ebx),%ecx <== NOT EXECUTED
10892b: f6 c1 08 test $0x8,%cl <== NOT EXECUTED
10892e: 0f 84 b4 00 00 00 je 1089e8 <erase+0x198> <== NOT EXECUTED
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
108934: f6 c1 10 test $0x10,%cl <== NOT EXECUTED
108937: 0f 85 36 ff ff ff jne 108873 <erase+0x23> <== NOT EXECUTED
tty->ccount = 0;
10893d: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
108944: 0f b6 43 44 movzbl 0x44(%ebx),%eax <== NOT EXECUTED
108948: 89 da mov %ebx,%edx <== NOT EXECUTED
10894a: e8 a1 fe ff ff call 1087f0 <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
10894f: f6 43 3c 20 testb $0x20,0x3c(%ebx) <== NOT EXECUTED
108953: 0f 84 63 ff ff ff je 1088bc <erase+0x6c> <== NOT EXECUTED
echo ('\n', tty);
108959: 89 da mov %ebx,%edx <== NOT EXECUTED
10895b: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
108960: e9 6a ff ff ff jmp 1088cf <erase+0x7f> <== NOT EXECUTED
108965: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
}
else if (c == '\t') {
int col = tty->read_start_column;
108968: 8b 73 2c mov 0x2c(%ebx),%esi <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
10896b: 85 ff test %edi,%edi <== NOT EXECUTED
10896d: 74 3f je 1089ae <erase+0x15e> <== NOT EXECUTED
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
}
else if (iscntrl (c)) {
10896f: a1 14 c5 11 00 mov 0x11c514,%eax <== NOT EXECUTED
108974: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED
108977: 31 d2 xor %edx,%edx <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOCTL)
108979: 81 e1 00 02 00 00 and $0x200,%ecx <== NOT EXECUTED
10897f: 89 4d e4 mov %ecx,-0x1c(%ebp) <== NOT EXECUTED
108982: eb 0e jmp 108992 <erase+0x142> <== NOT EXECUTED
108984: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
108987: 85 c0 test %eax,%eax <== NOT EXECUTED
108989: 74 03 je 10898e <erase+0x13e> <== NOT EXECUTED
col += 2;
10898b: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
10898e: 39 d7 cmp %edx,%edi <== NOT EXECUTED
108990: 74 1c je 1089ae <erase+0x15e> <== NOT EXECUTED
c = tty->cbuf[i++];
108992: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED
108995: 8a 04 11 mov (%ecx,%edx,1),%al <== NOT EXECUTED
108998: 42 inc %edx <== NOT EXECUTED
if (c == '\t') {
108999: 3c 09 cmp $0x9,%al <== NOT EXECUTED
10899b: 74 3f je 1089dc <erase+0x18c> <== NOT EXECUTED
col = (col | 7) + 1;
}
else if (iscntrl (c)) {
10899d: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
1089a0: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED
1089a3: f6 04 01 20 testb $0x20,(%ecx,%eax,1) <== NOT EXECUTED
1089a7: 75 db jne 108984 <erase+0x134> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOCTL)
col += 2;
}
else {
col++;
1089a9: 46 inc %esi <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
1089aa: 39 d7 cmp %edx,%edi <== NOT EXECUTED
1089ac: 75 e4 jne 108992 <erase+0x142> <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
1089ae: 39 73 28 cmp %esi,0x28(%ebx) <== NOT EXECUTED
1089b1: 0f 8e f5 fe ff ff jle 1088ac <erase+0x5c> <== NOT EXECUTED
1089b7: 90 nop <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
1089b8: 51 push %ecx <== NOT EXECUTED
1089b9: 53 push %ebx <== NOT EXECUTED
1089ba: 6a 01 push $0x1 <== NOT EXECUTED
1089bc: 68 c5 85 11 00 push $0x1185c5 <== NOT EXECUTED
1089c1: e8 ca fb ff ff call 108590 <rtems_termios_puts> <== NOT EXECUTED
tty->column--;
1089c6: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
1089c9: 48 dec %eax <== NOT EXECUTED
1089ca: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
1089cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1089d0: 39 f0 cmp %esi,%eax <== NOT EXECUTED
1089d2: 7f e4 jg 1089b8 <erase+0x168> <== NOT EXECUTED
1089d4: e9 d3 fe ff ff jmp 1088ac <erase+0x5c> <== NOT EXECUTED
1089d9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
1089dc: 89 f0 mov %esi,%eax <== NOT EXECUTED
1089de: 83 c8 07 or $0x7,%eax <== NOT EXECUTED
1089e1: 8d 70 01 lea 0x1(%eax),%esi <== NOT EXECUTED
1089e4: eb a8 jmp 10898e <erase+0x13e> <== NOT EXECUTED
1089e6: 66 90 xchg %ax,%ax <== NOT EXECUTED
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
tty->ccount = 0;
1089e8: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
1089ef: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1089f2: 5b pop %ebx <== NOT EXECUTED
1089f3: 5e pop %esi <== NOT EXECUTED
1089f4: 5f pop %edi <== NOT EXECUTED
1089f5: c9 leave <== NOT EXECUTED
1089f6: c3 ret <== NOT EXECUTED
001070c0 <free>:
void free(
void *ptr
)
{
MSBUMP(free_calls, 1);
1070c0: 55 push %ebp
1070c1: 89 e5 mov %esp,%ebp
1070c3: 53 push %ebx
1070c4: 83 ec 04 sub $0x4,%esp
1070c7: 8b 5d 08 mov 0x8(%ebp),%ebx
1070ca: ff 05 6c e5 11 00 incl 0x11e56c
if ( !ptr )
1070d0: 85 db test %ebx,%ebx
1070d2: 74 4b je 10711f <free+0x5f>
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
1070d4: 83 3d 24 e8 11 00 03 cmpl $0x3,0x11e824
1070db: 74 47 je 107124 <free+0x64> <== ALWAYS TAKEN
#endif
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
1070dd: a1 e4 c9 11 00 mov 0x11c9e4,%eax
1070e2: 85 c0 test %eax,%eax
1070e4: 74 0a je 1070f0 <free+0x30> <== ALWAYS TAKEN
(*rtems_malloc_statistics_helpers->at_free)(ptr);
1070e6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1070e9: 53 push %ebx <== NOT EXECUTED
1070ea: ff 50 08 call *0x8(%eax) <== NOT EXECUTED
1070ed: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if ( !_Protected_heap_Free( &RTEMS_Malloc_Heap, ptr ) ) {
1070f0: 83 ec 08 sub $0x8,%esp
1070f3: 53 push %ebx
1070f4: 68 00 e5 11 00 push $0x11e500
1070f9: e8 92 4c 00 00 call 10bd90 <_Protected_heap_Free>
1070fe: 83 c4 10 add $0x10,%esp
107101: 84 c0 test %al,%al
107103: 75 1a jne 10711f <free+0x5f> <== ALWAYS TAKEN
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
107105: ff 35 1c e5 11 00 pushl 0x11e51c <== NOT EXECUTED
10710b: ff 35 18 e5 11 00 pushl 0x11e518 <== NOT EXECUTED
107111: 53 push %ebx <== NOT EXECUTED
107112: 68 98 84 11 00 push $0x118498 <== NOT EXECUTED
107117: e8 1c 0d 00 00 call 107e38 <printk> <== NOT EXECUTED
10711c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
RTEMS_Malloc_Heap.begin,
RTEMS_Malloc_Heap.end
);
}
}
10711f: 8b 5d fc mov -0x4(%ebp),%ebx
107122: c9 leave
107123: c3 ret
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
107124: e8 af 00 00 00 call 1071d8 <malloc_is_system_state_OK>
107129: 84 c0 test %al,%al
10712b: 75 b0 jne 1070dd <free+0x1d> <== ALWAYS TAKEN
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
10712d: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED
RTEMS_Malloc_Heap.begin,
RTEMS_Malloc_Heap.end
);
}
}
107130: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
107133: 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);
107134: e9 df 00 00 00 jmp 107218 <malloc_deferred_free> <== NOT EXECUTED
00116538 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
116538: 55 push %ebp
116539: 89 e5 mov %esp,%ebp
11653b: 57 push %edi
11653c: 56 push %esi
11653d: 53 push %ebx
11653e: 83 ec 0c sub $0xc,%esp
116541: 8b 55 08 mov 0x8(%ebp),%edx
116544: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
116547: 85 f6 test %esi,%esi
116549: 74 7a je 1165c5 <fstat+0x8d> <== NEVER TAKEN
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
11654b: 3b 15 40 a0 11 00 cmp 0x11a040,%edx
116551: 73 4d jae 1165a0 <fstat+0x68> <== NEVER TAKEN
116553: 8d 04 52 lea (%edx,%edx,2),%eax
116556: 8d 04 82 lea (%edx,%eax,4),%eax
116559: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx
116560: 03 1d d0 e4 11 00 add 0x11e4d0,%ebx
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
116566: f6 43 0d 01 testb $0x1,0xd(%ebx)
11656a: 74 34 je 1165a0 <fstat+0x68> <== NEVER TAKEN
if ( !iop->handlers )
11656c: 8b 43 30 mov 0x30(%ebx),%eax
11656f: 85 c0 test %eax,%eax
116571: 74 2d je 1165a0 <fstat+0x68> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EBADF );
if ( !iop->handlers->fstat_h )
116573: 8b 40 18 mov 0x18(%eax),%eax
116576: 85 c0 test %eax,%eax
116578: 74 3e je 1165b8 <fstat+0x80> <== NEVER TAKEN
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
11657a: b9 4c 00 00 00 mov $0x4c,%ecx
11657f: 31 c0 xor %eax,%eax
116581: 89 f7 mov %esi,%edi
116583: f3 aa rep stos %al,%es:(%edi)
return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf );
116585: 8b 53 30 mov 0x30(%ebx),%edx
116588: 89 75 0c mov %esi,0xc(%ebp)
11658b: 8d 43 10 lea 0x10(%ebx),%eax
11658e: 89 45 08 mov %eax,0x8(%ebp)
116591: 8b 4a 18 mov 0x18(%edx),%ecx
}
116594: 83 c4 0c add $0xc,%esp
116597: 5b pop %ebx
116598: 5e pop %esi
116599: 5f pop %edi
11659a: 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 );
11659b: ff e1 jmp *%ecx
11659d: 8d 76 00 lea 0x0(%esi),%esi
iop = rtems_libio_iop( fd );
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
if ( !iop->handlers )
rtems_set_errno_and_return_minus_one( EBADF );
1165a0: e8 7b 9c ff ff call 110220 <__errno> <== NOT EXECUTED
1165a5: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf );
}
1165ab: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
1165b0: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
1165b3: 5b pop %ebx <== NOT EXECUTED
1165b4: 5e pop %esi <== NOT EXECUTED
1165b5: 5f pop %edi <== NOT EXECUTED
1165b6: c9 leave <== NOT EXECUTED
1165b7: c3 ret <== NOT EXECUTED
if ( !iop->handlers )
rtems_set_errno_and_return_minus_one( EBADF );
if ( !iop->handlers->fstat_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
1165b8: e8 63 9c ff ff call 110220 <__errno> <== NOT EXECUTED
1165bd: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
1165c3: eb e6 jmp 1165ab <fstat+0x73> <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
rtems_set_errno_and_return_minus_one( EFAULT );
1165c5: e8 56 9c ff ff call 110220 <__errno> <== NOT EXECUTED
1165ca: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED
1165d0: eb d9 jmp 1165ab <fstat+0x73> <== NOT EXECUTED
0010e590 <ftruncate>:
int ftruncate(
int fd,
off_t length
)
{
10e590: 55 push %ebp <== NOT EXECUTED
10e591: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10e593: 57 push %edi <== NOT EXECUTED
10e594: 56 push %esi <== NOT EXECUTED
10e595: 53 push %ebx <== NOT EXECUTED
10e596: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED
10e599: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
10e59c: 3b 15 40 a0 11 00 cmp 0x11a040,%edx <== NOT EXECUTED
10e5a2: 73 64 jae 10e608 <ftruncate+0x78> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
10e5a4: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED
10e5a7: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED
10e5aa: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED
10e5b1: 03 1d d0 e4 11 00 add 0x11e4d0,%ebx <== NOT EXECUTED
rtems_libio_check_is_open(iop);
10e5b7: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED
10e5bb: 74 4b je 10e608 <ftruncate+0x78> <== NOT EXECUTED
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
10e5bd: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED
10e5c0: 8d 73 10 lea 0x10(%ebx),%esi <== NOT EXECUTED
10e5c3: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
10e5c8: 89 d7 mov %edx,%edi <== NOT EXECUTED
10e5ca: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
if ( !loc.ops->node_type_h )
10e5cc: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
10e5cf: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED
10e5d2: 85 c0 test %eax,%eax <== NOT EXECUTED
10e5d4: 74 5a je 10e630 <ftruncate+0xa0> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
10e5d6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10e5d9: 52 push %edx <== NOT EXECUTED
10e5da: ff d0 call *%eax <== NOT EXECUTED
10e5dc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10e5df: 48 dec %eax <== NOT EXECUTED
10e5e0: 74 60 je 10e642 <ftruncate+0xb2> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EISDIR );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
10e5e2: f6 43 0c 04 testb $0x4,0xc(%ebx) <== NOT EXECUTED
10e5e6: 74 34 je 10e61c <ftruncate+0x8c> <== NOT EXECUTED
if ( !iop->handlers->ftruncate_h )
10e5e8: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED
10e5eb: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED
10e5ee: 85 c0 test %eax,%eax <== NOT EXECUTED
10e5f0: 74 3e je 10e630 <ftruncate+0xa0> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
return (*iop->handlers->ftruncate_h)( iop, length );
10e5f2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10e5f5: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
10e5f8: 53 push %ebx <== NOT EXECUTED
10e5f9: ff d0 call *%eax <== NOT EXECUTED
10e5fb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
10e5fe: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10e601: 5b pop %ebx <== NOT EXECUTED
10e602: 5e pop %esi <== NOT EXECUTED
10e603: 5f pop %edi <== NOT EXECUTED
10e604: c9 leave <== NOT EXECUTED
10e605: c3 ret <== NOT EXECUTED
10e606: 66 90 xchg %ax,%ax <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
10e608: e8 13 1c 00 00 call 110220 <__errno> <== NOT EXECUTED
10e60d: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
10e613: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10e618: eb e4 jmp 10e5fe <ftruncate+0x6e> <== NOT EXECUTED
10e61a: 66 90 xchg %ax,%ax <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
rtems_set_errno_and_return_minus_one( EISDIR );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
10e61c: e8 ff 1b 00 00 call 110220 <__errno> <== NOT EXECUTED
10e621: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
10e627: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10e62c: eb d0 jmp 10e5fe <ftruncate+0x6e> <== NOT EXECUTED
10e62e: 66 90 xchg %ax,%ax <== NOT EXECUTED
if ( !iop->handlers->ftruncate_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
10e630: e8 eb 1b 00 00 call 110220 <__errno> <== NOT EXECUTED
10e635: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10e63b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10e640: eb bc jmp 10e5fe <ftruncate+0x6e> <== NOT EXECUTED
loc = iop->pathinfo;
if ( !loc.ops->node_type_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
rtems_set_errno_and_return_minus_one( EISDIR );
10e642: e8 d9 1b 00 00 call 110220 <__errno> <== NOT EXECUTED
10e647: c7 00 15 00 00 00 movl $0x15,(%eax) <== NOT EXECUTED
10e64d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10e652: eb aa jmp 10e5fe <ftruncate+0x6e> <== NOT EXECUTED
0011920c <getpid>:
*
* 4.1.1 Get Process and Parent Process IDs, P1003.1b-1993, p. 83
*/
pid_t getpid( void )
{
11920c: 55 push %ebp <== NOT EXECUTED
11920d: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return _Objects_Local_node;
}
11920f: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
119214: c9 leave <== NOT EXECUTED
119215: c3 ret <== NOT EXECUTED
0010e654 <gettimeofday>:
int gettimeofday(
struct timeval *tp,
void * __tz
)
{
10e654: 55 push %ebp
10e655: 89 e5 mov %esp,%ebp
10e657: 56 push %esi
10e658: 53 push %ebx
10e659: 83 ec 10 sub $0x10,%esp
10e65c: 8b 75 08 mov 0x8(%ebp),%esi
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp ) {
10e65f: 85 f6 test %esi,%esi
10e661: 74 30 je 10e693 <gettimeofday+0x3f> <== NEVER TAKEN
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
10e663: 9c pushf
10e664: fa cli
10e665: 5b pop %ebx
* This routine grows @a the_heap memory area using the size bytes which
10e666: 83 ec 0c sub $0xc,%esp
10e669: 8d 45 f0 lea -0x10(%ebp),%eax
10e66c: 50 push %eax
10e66d: e8 ca cb ff ff call 10b23c <_TOD_Get>
* begin at @a starting_address.
10e672: 53 push %ebx
10e673: 9d popf
*
* @param[in] the_heap is the heap to operate upon
10e674: 8b 45 f0 mov -0x10(%ebp),%eax
10e677: 89 06 mov %eax,(%esi)
* @param[in] starting_address is the starting address of the memory
10e679: b8 d3 4d 62 10 mov $0x10624dd3,%eax
10e67e: f7 65 f4 mull -0xc(%ebp)
10e681: c1 ea 06 shr $0x6,%edx
10e684: 89 56 04 mov %edx,0x4(%esi)
10e687: 31 c0 xor %eax,%eax
10e689: 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;
}
10e68c: 8d 65 f8 lea -0x8(%ebp),%esp
10e68f: 5b pop %ebx
10e690: 5e pop %esi
10e691: c9 leave
10e692: c3 ret
void * __tz
)
{
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp ) {
errno = EFAULT;
10e693: e8 88 1b 00 00 call 110220 <__errno> <== NOT EXECUTED
10e698: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED
10e69e: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10e6a3: eb e7 jmp 10e68c <gettimeofday+0x38> <== NOT EXECUTED
001089f8 <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
1089f8: 55 push %ebp <== NOT EXECUTED
1089f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1089fb: 56 push %esi <== NOT EXECUTED
1089fc: 53 push %ebx <== NOT EXECUTED
1089fd: 89 d6 mov %edx,%esi <== NOT EXECUTED
1089ff: 88 c3 mov %al,%bl <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP)
108a01: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED
108a04: f6 c1 20 test $0x20,%cl <== NOT EXECUTED
108a07: 74 03 je 108a0c <iproc+0x14> <== NOT EXECUTED
c &= 0x7f;
108a09: 83 e3 7f and $0x7f,%ebx <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
108a0c: f6 c5 02 test $0x2,%ch <== NOT EXECUTED
108a0f: 74 10 je 108a21 <iproc+0x29> <== NOT EXECUTED
c = tolower (c);
108a11: 0f b6 d3 movzbl %bl,%edx <== NOT EXECUTED
108a14: a1 14 c5 11 00 mov 0x11c514,%eax <== NOT EXECUTED
108a19: f6 04 10 01 testb $0x1,(%eax,%edx,1) <== NOT EXECUTED
108a1d: 75 3d jne 108a5c <iproc+0x64> <== NOT EXECUTED
108a1f: 88 d3 mov %dl,%bl <== NOT EXECUTED
if (c == '\r') {
108a21: 80 fb 0d cmp $0xd,%bl <== NOT EXECUTED
108a24: 0f 84 8a 00 00 00 je 108ab4 <iproc+0xbc> <== NOT EXECUTED
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
}
else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
108a2a: 80 fb 0a cmp $0xa,%bl <== NOT EXECUTED
108a2d: 74 35 je 108a64 <iproc+0x6c> <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
108a2f: 84 db test %bl,%bl <== NOT EXECUTED
108a31: 75 36 jne 108a69 <iproc+0x71> <== NOT EXECUTED
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
108a33: 8b 56 20 mov 0x20(%esi),%edx <== NOT EXECUTED
108a36: a1 84 c4 11 00 mov 0x11c484,%eax <== NOT EXECUTED
108a3b: 48 dec %eax <== NOT EXECUTED
108a3c: 39 c2 cmp %eax,%edx <== NOT EXECUTED
108a3e: 7d 78 jge 108ab8 <iproc+0xc0> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO)
108a40: f6 46 3c 08 testb $0x8,0x3c(%esi) <== NOT EXECUTED
108a44: 0f 85 86 00 00 00 jne 108ad0 <iproc+0xd8> <== NOT EXECUTED
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
108a4a: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED
108a4d: 88 1c 10 mov %bl,(%eax,%edx,1) <== NOT EXECUTED
108a50: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED
108a53: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED
108a56: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
return 0;
}
108a58: 5b pop %ebx <== NOT EXECUTED
108a59: 5e pop %esi <== NOT EXECUTED
108a5a: c9 leave <== NOT EXECUTED
108a5b: c3 ret <== NOT EXECUTED
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
108a5c: 83 c2 20 add $0x20,%edx <== NOT EXECUTED
108a5f: eb be jmp 108a1f <iproc+0x27> <== NOT EXECUTED
108a61: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
}
else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
108a64: 83 e1 40 and $0x40,%ecx <== NOT EXECUTED
108a67: 75 63 jne 108acc <iproc+0xd4> <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
108a69: 8b 46 3c mov 0x3c(%esi),%eax <== NOT EXECUTED
108a6c: a8 02 test $0x2,%al <== NOT EXECUTED
108a6e: 74 c3 je 108a33 <iproc+0x3b> <== NOT EXECUTED
if (c == tty->termios.c_cc[VERASE]) {
108a70: 38 5e 43 cmp %bl,0x43(%esi) <== NOT EXECUTED
108a73: 74 6f je 108ae4 <iproc+0xec> <== NOT EXECUTED
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
108a75: 38 5e 44 cmp %bl,0x44(%esi) <== NOT EXECUTED
108a78: 0f 84 9e 00 00 00 je 108b1c <iproc+0x124> <== NOT EXECUTED
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
108a7e: 38 5e 45 cmp %bl,0x45(%esi) <== NOT EXECUTED
108a81: 74 2a je 108aad <iproc+0xb5> <== NOT EXECUTED
return 1;
}
else if (c == '\n') {
108a83: 80 fb 0a cmp $0xa,%bl <== NOT EXECUTED
108a86: 74 6c je 108af4 <iproc+0xfc> <== NOT EXECUTED
if (tty->termios.c_lflag & (ECHO | ECHONL))
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
return 1;
}
else if ((c == tty->termios.c_cc[VEOL])
108a88: 38 5e 4c cmp %bl,0x4c(%esi) <== NOT EXECUTED
108a8b: 74 05 je 108a92 <iproc+0x9a> <== NOT EXECUTED
108a8d: 38 5e 51 cmp %bl,0x51(%esi) <== NOT EXECUTED
108a90: 75 a1 jne 108a33 <iproc+0x3b> <== NOT EXECUTED
|| (c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
108a92: a8 08 test $0x8,%al <== NOT EXECUTED
108a94: 74 0a je 108aa0 <iproc+0xa8> <== NOT EXECUTED
echo (c, tty);
108a96: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED
108a99: 89 f2 mov %esi,%edx <== NOT EXECUTED
108a9b: e8 50 fd ff ff call 1087f0 <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
108aa0: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED
108aa3: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED
108aa6: 88 1c 02 mov %bl,(%edx,%eax,1) <== NOT EXECUTED
108aa9: 40 inc %eax <== NOT EXECUTED
108aaa: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED
108aad: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
108ab2: eb a4 jmp 108a58 <iproc+0x60> <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
108ab4: 84 c9 test %cl,%cl <== NOT EXECUTED
108ab6: 79 08 jns 108ac0 <iproc+0xc8> <== 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;
108ab8: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
return 0;
}
108aba: 5b pop %ebx <== NOT EXECUTED
108abb: 5e pop %esi <== NOT EXECUTED
108abc: c9 leave <== NOT EXECUTED
108abd: c3 ret <== NOT EXECUTED
108abe: 66 90 xchg %ax,%ax <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
108ac0: 80 e5 01 and $0x1,%ch <== NOT EXECUTED
108ac3: 74 a4 je 108a69 <iproc+0x71> <== NOT EXECUTED
108ac5: b3 0a mov $0xa,%bl <== NOT EXECUTED
108ac7: eb a0 jmp 108a69 <iproc+0x71> <== NOT EXECUTED
108ac9: 8d 76 00 lea 0x0(%esi),%esi <== 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;
108acc: b3 0d mov $0xd,%bl <== NOT EXECUTED
108ace: eb 99 jmp 108a69 <iproc+0x71> <== NOT EXECUTED
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
108ad0: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED
108ad3: 89 f2 mov %esi,%edx <== NOT EXECUTED
108ad5: e8 16 fd ff ff call 1087f0 <echo> <== NOT EXECUTED
108ada: 8b 56 20 mov 0x20(%esi),%edx <== NOT EXECUTED
108add: e9 68 ff ff ff jmp 108a4a <iproc+0x52> <== NOT EXECUTED
108ae2: 66 90 xchg %ax,%ax <== NOT EXECUTED
else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
108ae4: 31 d2 xor %edx,%edx <== NOT EXECUTED
108ae6: 89 f0 mov %esi,%eax <== NOT EXECUTED
108ae8: e8 63 fd ff ff call 108850 <erase> <== NOT EXECUTED
108aed: 31 c0 xor %eax,%eax <== NOT EXECUTED
108aef: e9 64 ff ff ff jmp 108a58 <iproc+0x60> <== NOT EXECUTED
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
}
else if (c == '\n') {
if (tty->termios.c_lflag & (ECHO | ECHONL))
108af4: a8 48 test $0x48,%al <== NOT EXECUTED
108af6: 74 0c je 108b04 <iproc+0x10c> <== NOT EXECUTED
echo (c, tty);
108af8: 89 f2 mov %esi,%edx <== NOT EXECUTED
108afa: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
108aff: e8 ec fc ff ff call 1087f0 <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
108b04: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED
108b07: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED
108b0a: c6 04 02 0a movb $0xa,(%edx,%eax,1) <== NOT EXECUTED
108b0e: 40 inc %eax <== NOT EXECUTED
108b0f: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED
108b12: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
108b17: e9 3c ff ff ff jmp 108a58 <iproc+0x60> <== NOT EXECUTED
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
108b1c: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED
108b21: 89 f0 mov %esi,%eax <== NOT EXECUTED
108b23: e8 28 fd ff ff call 108850 <erase> <== NOT EXECUTED
108b28: 31 c0 xor %eax,%eax <== NOT EXECUTED
108b2a: e9 29 ff ff ff jmp 108a58 <iproc+0x60> <== NOT EXECUTED
001165ec <isatty>:
#include <sys/stat.h>
int isatty(
int fd
)
{
1165ec: 55 push %ebp
1165ed: 89 e5 mov %esp,%ebp
1165ef: 83 ec 60 sub $0x60,%esp
struct stat buf;
if (fstat (fd, &buf) < 0)
1165f2: 8d 45 b4 lea -0x4c(%ebp),%eax
1165f5: 50 push %eax
1165f6: ff 75 08 pushl 0x8(%ebp)
1165f9: e8 3a ff ff ff call 116538 <fstat>
1165fe: 83 c4 10 add $0x10,%esp
116601: 85 c0 test %eax,%eax
116603: 78 17 js 11661c <isatty+0x30> <== NEVER TAKEN
116605: 8b 45 c0 mov -0x40(%ebp),%eax
116608: 25 00 f0 00 00 and $0xf000,%eax
11660d: 3d 00 20 00 00 cmp $0x2000,%eax
116612: 0f 94 c0 sete %al
116615: 0f b6 c0 movzbl %al,%eax
if (S_ISCHR (buf.st_mode))
return 1;
return 0;
}
116618: c9 leave
116619: c3 ret
11661a: 66 90 xchg %ax,%ax
int fd
)
{
struct stat buf;
if (fstat (fd, &buf) < 0)
11661c: 31 c0 xor %eax,%eax
if (S_ISCHR (buf.st_mode))
return 1;
return 0;
}
11661e: c9 leave <== NOT EXECUTED
11661f: c3 ret <== NOT EXECUTED
00119340 <kill>:
* These are directly supported (and completely correct) in the posix api.
*/
#if !defined(RTEMS_POSIX_API)
int kill( pid_t pid, int sig )
{
119340: 55 push %ebp <== NOT EXECUTED
119341: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return 0;
}
119343: 31 c0 xor %eax,%eax <== NOT EXECUTED
119345: c9 leave <== NOT EXECUTED
119346: c3 ret <== NOT EXECUTED
001075c4 <libc_create_hook>:
*/
bool libc_create_hook(
rtems_tcb *current_task,
rtems_tcb *creating_task
)
{
1075c4: 55 push %ebp
1075c5: 89 e5 mov %esp,%ebp
1075c7: 57 push %edi
1075c8: 56 push %esi
1075c9: 53 push %ebx
1075ca: 83 ec 18 sub $0x18,%esp
ptr = (struct _reent *) calloc(1, sizeof(struct _reent));
#else
/* It is OK to allocate from the workspace because these
* hooks run with thread dispatching disabled.
*/
ptr = (struct _reent *) _Workspace_Allocate(sizeof(struct _reent));
1075cd: 68 00 04 00 00 push $0x400
1075d2: e8 49 5e 00 00 call 10d420 <_Workspace_Allocate>
1075d7: 89 c6 mov %eax,%esi
#endif
if (ptr) {
1075d9: 83 c4 10 add $0x10,%esp
1075dc: 85 c0 test %eax,%eax
1075de: 0f 84 30 02 00 00 je 107814 <libc_create_hook+0x250><== NEVER TAKEN
_REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */
1075e4: c7 00 00 00 00 00 movl $0x0,(%eax)
1075ea: 8d 90 ec 02 00 00 lea 0x2ec(%eax),%edx
1075f0: 89 50 04 mov %edx,0x4(%eax)
1075f3: 8d 80 48 03 00 00 lea 0x348(%eax),%eax
1075f9: 89 46 08 mov %eax,0x8(%esi)
1075fc: 8d 86 a4 03 00 00 lea 0x3a4(%esi),%eax
107602: 89 46 0c mov %eax,0xc(%esi)
107605: c7 46 10 00 00 00 00 movl $0x0,0x10(%esi)
10760c: 8d 7e 14 lea 0x14(%esi),%edi
10760f: 31 c0 xor %eax,%eax
107611: bb 19 00 00 00 mov $0x19,%ebx
107616: 89 d9 mov %ebx,%ecx
107618: f3 aa rep stos %al,%es:(%edi)
10761a: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi)
107621: c7 46 34 d0 84 11 00 movl $0x1184d0,0x34(%esi)
107628: c7 46 38 00 00 00 00 movl $0x0,0x38(%esi)
10762f: c7 46 3c 00 00 00 00 movl $0x0,0x3c(%esi)
107636: c7 46 40 00 00 00 00 movl $0x0,0x40(%esi)
10763d: c7 46 44 00 00 00 00 movl $0x0,0x44(%esi)
107644: c7 46 48 00 00 00 00 movl $0x0,0x48(%esi)
10764b: c7 46 4c 00 00 00 00 movl $0x0,0x4c(%esi)
107652: c7 46 50 00 00 00 00 movl $0x0,0x50(%esi)
107659: c7 46 54 00 00 00 00 movl $0x0,0x54(%esi)
107660: c7 46 58 00 00 00 00 movl $0x0,0x58(%esi)
107667: c7 46 5c 00 00 00 00 movl $0x0,0x5c(%esi)
10766e: c6 46 60 00 movb $0x0,0x60(%esi)
107672: 8d 7e 7c lea 0x7c(%esi),%edi
107675: b3 24 mov $0x24,%bl
107677: 89 d9 mov %ebx,%ecx
107679: f3 aa rep stos %al,%es:(%edi)
10767b: c7 86 a0 00 00 00 00 movl $0x0,0xa0(%esi)
107682: 00 00 00
107685: c7 86 a4 00 00 00 01 movl $0x1,0xa4(%esi)
10768c: 00 00 00
10768f: c7 86 a8 00 00 00 00 movl $0x0,0xa8(%esi)
107696: 00 00 00
107699: 66 c7 86 ac 00 00 00 movw $0x330e,0xac(%esi)
1076a0: 0e 33
1076a2: 66 c7 86 ae 00 00 00 movw $0xabcd,0xae(%esi)
1076a9: cd ab
1076ab: 66 c7 86 b0 00 00 00 movw $0x1234,0xb0(%esi)
1076b2: 34 12
1076b4: 66 c7 86 b2 00 00 00 movw $0xe66d,0xb2(%esi)
1076bb: 6d e6
1076bd: 66 c7 86 b4 00 00 00 movw $0xdeec,0xb4(%esi)
1076c4: ec de
1076c6: 66 c7 86 b6 00 00 00 movw $0x5,0xb6(%esi)
1076cd: 05 00
1076cf: 66 c7 86 b8 00 00 00 movw $0xb,0xb8(%esi)
1076d6: 0b 00
1076d8: c7 86 bc 00 00 00 00 movl $0x0,0xbc(%esi)
1076df: 00 00 00
1076e2: c7 86 c0 00 00 00 00 movl $0x0,0xc0(%esi)
1076e9: 00 00 00
1076ec: c7 86 c4 00 00 00 00 movl $0x0,0xc4(%esi)
1076f3: 00 00 00
1076f6: c7 86 c8 00 00 00 00 movl $0x0,0xc8(%esi)
1076fd: 00 00 00
107700: c7 86 cc 00 00 00 00 movl $0x0,0xcc(%esi)
107707: 00 00 00
10770a: c7 86 d0 00 00 00 00 movl $0x0,0xd0(%esi)
107711: 00 00 00
107714: c7 86 f8 00 00 00 00 movl $0x0,0xf8(%esi)
10771b: 00 00 00
10771e: c7 86 fc 00 00 00 00 movl $0x0,0xfc(%esi)
107725: 00 00 00
107728: c7 86 00 01 00 00 00 movl $0x0,0x100(%esi)
10772f: 00 00 00
107732: c7 86 04 01 00 00 00 movl $0x0,0x104(%esi)
107739: 00 00 00
10773c: c7 86 08 01 00 00 00 movl $0x0,0x108(%esi)
107743: 00 00 00
107746: c7 86 0c 01 00 00 00 movl $0x0,0x10c(%esi)
10774d: 00 00 00
107750: c7 86 10 01 00 00 00 movl $0x0,0x110(%esi)
107757: 00 00 00
10775a: c7 86 14 01 00 00 00 movl $0x0,0x114(%esi)
107761: 00 00 00
107764: c7 86 18 01 00 00 00 movl $0x0,0x118(%esi)
10776b: 00 00 00
10776e: c7 86 1c 01 00 00 00 movl $0x0,0x11c(%esi)
107775: 00 00 00
107778: c6 86 d4 00 00 00 00 movb $0x0,0xd4(%esi)
10777f: c6 86 dc 00 00 00 00 movb $0x0,0xdc(%esi)
107786: c7 86 f4 00 00 00 00 movl $0x0,0xf4(%esi)
10778d: 00 00 00
107790: c7 86 48 01 00 00 00 movl $0x0,0x148(%esi)
107797: 00 00 00
10779a: c7 86 4c 01 00 00 00 movl $0x0,0x14c(%esi)
1077a1: 00 00 00
1077a4: c7 86 50 01 00 00 00 movl $0x0,0x150(%esi)
1077ab: 00 00 00
1077ae: c7 86 54 01 00 00 00 movl $0x0,0x154(%esi)
1077b5: 00 00 00
1077b8: c7 86 d4 02 00 00 00 movl $0x0,0x2d4(%esi)
1077bf: 00 00 00
1077c2: c7 86 d4 01 00 00 00 movl $0x0,0x1d4(%esi)
1077c9: 00 00 00
1077cc: c7 86 dc 02 00 00 00 movl $0x0,0x2dc(%esi)
1077d3: 00 00 00
1077d6: c7 86 e0 02 00 00 00 movl $0x0,0x2e0(%esi)
1077dd: 00 00 00
1077e0: c7 86 e4 02 00 00 00 movl $0x0,0x2e4(%esi)
1077e7: 00 00 00
1077ea: c7 86 e8 02 00 00 00 movl $0x0,0x2e8(%esi)
1077f1: 00 00 00
1077f4: 66 bb 14 01 mov $0x114,%bx
1077f8: 89 d7 mov %edx,%edi
1077fa: 89 d9 mov %ebx,%ecx
1077fc: f3 aa rep stos %al,%es:(%edi)
creating_task->libc_reent = ptr;
1077fe: 8b 45 0c mov 0xc(%ebp),%eax
107801: 89 b0 f0 00 00 00 mov %esi,0xf0(%eax)
107807: b0 01 mov $0x1,%al
return true;
}
else
return false;
}
107809: 8d 65 f4 lea -0xc(%ebp),%esp
10780c: 5b pop %ebx
10780d: 5e pop %esi
10780e: 5f pop %edi
10780f: c9 leave
107810: c3 ret
107811: 8d 76 00 lea 0x0(%esi),%esi
* hooks run with thread dispatching disabled.
*/
ptr = (struct _reent *) _Workspace_Allocate(sizeof(struct _reent));
#endif
if (ptr) {
107814: 31 c0 xor %eax,%eax
creating_task->libc_reent = ptr;
return true;
}
else
return false;
}
107816: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
107819: 5b pop %ebx <== NOT EXECUTED
10781a: 5e pop %esi <== NOT EXECUTED
10781b: 5f pop %edi <== NOT EXECUTED
10781c: c9 leave <== NOT EXECUTED
10781d: c3 ret <== NOT EXECUTED
001074f8 <libc_delete_hook>:
rtems_extension libc_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
1074f8: 55 push %ebp
1074f9: 89 e5 mov %esp,%ebp
1074fb: 57 push %edi
1074fc: 56 push %esi
1074fd: 53 push %ebx
1074fe: 83 ec 0c sub $0xc,%esp
107501: 8b 7d 08 mov 0x8(%ebp),%edi
107504: 8b 75 0c mov 0xc(%ebp),%esi
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
107507: 39 f7 cmp %esi,%edi
107509: 74 55 je 107560 <libc_delete_hook+0x68>
ptr = _REENT;
} else {
ptr = deleted_task->libc_reent;
10750b: 8b 9e f0 00 00 00 mov 0xf0(%esi),%ebx
}
if (ptr && ptr != &libc_global_reent) {
107511: 85 db test %ebx,%ebx
107513: 74 21 je 107536 <libc_delete_hook+0x3e> <== NEVER TAKEN
107515: 81 fb 80 c0 11 00 cmp $0x11c080,%ebx
10751b: 74 19 je 107536 <libc_delete_hook+0x3e>
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
10751d: 83 ec 08 sub $0x8,%esp
107520: 68 68 75 10 00 push $0x107568
107525: 53 push %ebx
107526: e8 ad 93 00 00 call 1108d8 <_fwalk>
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
10752b: 89 1c 24 mov %ebx,(%esp)
10752e: e8 d5 5e 00 00 call 10d408 <_Workspace_Free>
107533: 83 c4 10 add $0x10,%esp
#endif
}
deleted_task->libc_reent = NULL;
107536: c7 86 f0 00 00 00 00 movl $0x0,0xf0(%esi)
10753d: 00 00 00
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
107540: 39 f7 cmp %esi,%edi
107542: 74 08 je 10754c <libc_delete_hook+0x54>
_REENT = 0;
}
}
107544: 8d 65 f4 lea -0xc(%ebp),%esp
107547: 5b pop %ebx
107548: 5e pop %esi
107549: 5f pop %edi
10754a: c9 leave
10754b: c3 ret
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
_REENT = 0;
10754c: c7 05 20 c5 11 00 00 movl $0x0,0x11c520
107553: 00 00 00
}
}
107556: 8d 65 f4 lea -0xc(%ebp),%esp
107559: 5b pop %ebx
10755a: 5e pop %esi
10755b: 5f pop %edi
10755c: c9 leave
10755d: c3 ret
10755e: 66 90 xchg %ax,%ax
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ptr = _REENT;
107560: 8b 1d 20 c5 11 00 mov 0x11c520,%ebx
107566: eb a9 jmp 107511 <libc_delete_hook+0x19>
00116708 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
116708: 55 push %ebp
116709: 89 e5 mov %esp,%ebp
11670b: 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()))
11670e: 83 3d 24 e8 11 00 03 cmpl $0x3,0x11e824
116715: 74 05 je 11671c <libc_wrapup+0x14> <== ALWAYS TAKEN
*/
fclose (stdin);
fclose (stdout);
fclose (stderr);
}
116717: c9 leave <== NOT EXECUTED
116718: c3 ret <== NOT EXECUTED
116719: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != &libc_global_reent) {
11671c: 81 3d 20 c5 11 00 80 cmpl $0x11c080,0x11c520
116723: c0 11 00
116726: 74 1a je 116742 <libc_wrapup+0x3a>
_wrapup_reent(&libc_global_reent);
116728: 83 ec 0c sub $0xc,%esp
11672b: 68 80 c0 11 00 push $0x11c080
116730: e8 eb 05 00 00 call 116d20 <_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;
116735: c7 05 20 c5 11 00 80 movl $0x11c080,0x11c520
11673c: c0 11 00
11673f: 83 c4 10 add $0x10,%esp
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
116742: 83 ec 0c sub $0xc,%esp
116745: a1 20 c5 11 00 mov 0x11c520,%eax
11674a: ff 70 04 pushl 0x4(%eax)
11674d: e8 1a 9c ff ff call 11036c <fclose>
fclose (stdout);
116752: 5a pop %edx
116753: a1 20 c5 11 00 mov 0x11c520,%eax
116758: ff 70 08 pushl 0x8(%eax)
11675b: e8 0c 9c ff ff call 11036c <fclose>
fclose (stderr);
116760: 58 pop %eax
116761: a1 20 c5 11 00 mov 0x11c520,%eax
116766: ff 70 0c pushl 0xc(%eax)
116769: e8 fe 9b ff ff call 11036c <fclose>
11676e: 83 c4 10 add $0x10,%esp
}
116771: c9 leave
116772: c3 ret
00116620 <lseek>:
off_t lseek(
int fd,
off_t offset,
int whence
)
{
116620: 55 push %ebp <== NOT EXECUTED
116621: 89 e5 mov %esp,%ebp <== NOT EXECUTED
116623: 57 push %edi <== NOT EXECUTED
116624: 56 push %esi <== NOT EXECUTED
116625: 53 push %ebx <== NOT EXECUTED
116626: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
116629: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
11662c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED
11662f: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
116632: 3b 15 40 a0 11 00 cmp 0x11a040,%edx <== NOT EXECUTED
116638: 73 7e jae 1166b8 <lseek+0x98> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
11663a: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED
11663d: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED
116640: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED
116647: 03 1d d0 e4 11 00 add 0x11e4d0,%ebx <== NOT EXECUTED
rtems_libio_check_is_open(iop);
11664d: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED
116651: 74 65 je 1166b8 <lseek+0x98> <== NOT EXECUTED
/*
* Check as many errors as possible before touching iop->offset.
*/
if ( !iop->handlers->lseek_h )
116653: 8b 53 30 mov 0x30(%ebx),%edx <== NOT EXECUTED
116656: 8b 7a 14 mov 0x14(%edx),%edi <== NOT EXECUTED
116659: 85 ff test %edi,%edi <== NOT EXECUTED
11665b: 74 6d je 1166ca <lseek+0xaa> <== NOT EXECUTED
/*
* Now process the lseek().
*/
old_offset = iop->offset;
11665d: 8b 7b 08 mov 0x8(%ebx),%edi <== NOT EXECUTED
switch ( whence ) {
116660: 83 f9 01 cmp $0x1,%ecx <== NOT EXECUTED
116663: 74 4b je 1166b0 <lseek+0x90> <== NOT EXECUTED
116665: 83 f9 02 cmp $0x2,%ecx <== NOT EXECUTED
116668: 74 22 je 11668c <lseek+0x6c> <== NOT EXECUTED
11666a: 85 c9 test %ecx,%ecx <== NOT EXECUTED
11666c: 75 2a jne 116698 <lseek+0x78> <== NOT EXECUTED
case SEEK_SET:
iop->offset = offset;
11666e: 89 73 08 mov %esi,0x8(%ebx) <== NOT EXECUTED
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->handlers->lseek_h)( iop, offset, whence );
116671: 50 push %eax <== NOT EXECUTED
116672: 51 push %ecx <== NOT EXECUTED
116673: 56 push %esi <== NOT EXECUTED
116674: 53 push %ebx <== NOT EXECUTED
116675: ff 52 14 call *0x14(%edx) <== NOT EXECUTED
if ( status == (off_t) -1 )
116678: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
11667b: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED
11667e: 75 03 jne 116683 <lseek+0x63> <== NOT EXECUTED
iop->offset = old_offset;
116680: 89 7b 08 mov %edi,0x8(%ebx) <== NOT EXECUTED
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
116683: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
116686: 5b pop %ebx <== NOT EXECUTED
116687: 5e pop %esi <== NOT EXECUTED
116688: 5f pop %edi <== NOT EXECUTED
116689: c9 leave <== NOT EXECUTED
11668a: c3 ret <== NOT EXECUTED
11668b: 90 nop <== NOT EXECUTED
case SEEK_CUR:
iop->offset += offset;
break;
case SEEK_END:
iop->offset = iop->size + offset;
11668c: 89 f0 mov %esi,%eax <== NOT EXECUTED
11668e: 03 43 04 add 0x4(%ebx),%eax <== NOT EXECUTED
116691: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED
116694: eb db jmp 116671 <lseek+0x51> <== NOT EXECUTED
116696: 66 90 xchg %ax,%ax <== NOT EXECUTED
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
116698: e8 83 9b ff ff call 110220 <__errno> <== NOT EXECUTED
11669d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
1166a3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
1166a8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1166ab: 5b pop %ebx <== NOT EXECUTED
1166ac: 5e pop %esi <== NOT EXECUTED
1166ad: 5f pop %edi <== NOT EXECUTED
1166ae: c9 leave <== NOT EXECUTED
1166af: c3 ret <== NOT EXECUTED
case SEEK_SET:
iop->offset = offset;
break;
case SEEK_CUR:
iop->offset += offset;
1166b0: 8d 04 3e lea (%esi,%edi,1),%eax <== NOT EXECUTED
1166b3: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED
1166b6: eb b9 jmp 116671 <lseek+0x51> <== NOT EXECUTED
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
1166b8: e8 63 9b ff ff call 110220 <__errno> <== NOT EXECUTED
1166bd: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
1166c3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
1166c8: eb b9 jmp 116683 <lseek+0x63> <== NOT EXECUTED
/*
* Check as many errors as possible before touching iop->offset.
*/
if ( !iop->handlers->lseek_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
1166ca: e8 51 9b ff ff call 110220 <__errno> <== NOT EXECUTED
1166cf: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
1166d5: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
1166da: eb a7 jmp 116683 <lseek+0x63> <== NOT EXECUTED
001072d8 <malloc>:
size_t size
)
{
void *return_this;
MSBUMP(malloc_calls, 1);
1072d8: 55 push %ebp
1072d9: 89 e5 mov %esp,%ebp
1072db: 57 push %edi
1072dc: 56 push %esi
1072dd: 53 push %ebx
1072de: 83 ec 0c sub $0xc,%esp
1072e1: 8b 7d 08 mov 0x8(%ebp),%edi
1072e4: ff 05 64 e5 11 00 incl 0x11e564
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
1072ea: e8 41 ff ff ff call 107230 <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
1072ef: 85 ff test %edi,%edi
1072f1: 74 5d je 107350 <malloc+0x78> <== 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()) &&
1072f3: 83 3d 24 e8 11 00 03 cmpl $0x3,0x11e824
1072fa: 74 4b je 107347 <malloc+0x6f>
* 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 );
1072fc: 83 ec 08 sub $0x8,%esp
1072ff: 57 push %edi
107300: 68 00 e5 11 00 push $0x11e500
107305: e8 52 4a 00 00 call 10bd5c <_Protected_heap_Allocate>
10730a: 89 c3 mov %eax,%ebx
if ( !return_this ) {
10730c: 83 c4 10 add $0x10,%esp
10730f: 85 c0 test %eax,%eax
107311: 74 49 je 10735c <malloc+0x84> <== NEVER TAKEN
if (rtems_malloc_sbrk_helpers)
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
if ( !return_this ) {
errno = ENOMEM;
return (void *) 0;
107313: 89 c6 mov %eax,%esi
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
107315: a1 ec c9 11 00 mov 0x11c9ec,%eax
10731a: 85 c0 test %eax,%eax
10731c: 74 0a je 107328 <malloc+0x50> <== ALWAYS TAKEN
(*rtems_malloc_dirty_helper)( return_this, size );
10731e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
107321: 57 push %edi <== NOT EXECUTED
107322: 56 push %esi <== NOT EXECUTED
107323: ff d0 call *%eax <== NOT EXECUTED
107325: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
107328: a1 e4 c9 11 00 mov 0x11c9e4,%eax
10732d: 85 c0 test %eax,%eax
10732f: 74 53 je 107384 <malloc+0xac> <== ALWAYS TAKEN
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
107331: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107334: 56 push %esi <== NOT EXECUTED
107335: ff 50 04 call *0x4(%eax) <== NOT EXECUTED
107338: 89 f3 mov %esi,%ebx <== NOT EXECUTED
10733a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if (rtems_malloc_boundary_helpers)
(*rtems_malloc_boundary_helpers->at_malloc)(return_this, size);
#endif
return return_this;
}
10733d: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10733f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
107342: 5b pop %ebx <== NOT EXECUTED
107343: 5e pop %esi <== NOT EXECUTED
107344: 5f pop %edi <== NOT EXECUTED
107345: c9 leave <== NOT EXECUTED
107346: c3 ret <== NOT EXECUTED
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
107347: e8 8c fe ff ff call 1071d8 <malloc_is_system_state_OK>
10734c: 84 c0 test %al,%al
10734e: 75 ac jne 1072fc <malloc+0x24> <== ALWAYS TAKEN
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
107350: 31 db xor %ebx,%ebx
if (rtems_malloc_boundary_helpers)
(*rtems_malloc_boundary_helpers->at_malloc)(return_this, size);
#endif
return return_this;
}
107352: 89 d8 mov %ebx,%eax <== NOT EXECUTED
107354: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
107357: 5b pop %ebx <== NOT EXECUTED
107358: 5e pop %esi <== NOT EXECUTED
107359: 5f pop %edi <== NOT EXECUTED
10735a: c9 leave <== NOT EXECUTED
10735b: c3 ret <== NOT EXECUTED
*/
return_this = _Protected_heap_Allocate( &RTEMS_Malloc_Heap, size );
if ( !return_this ) {
if (rtems_malloc_sbrk_helpers)
10735c: a1 e8 c9 11 00 mov 0x11c9e8,%eax <== NOT EXECUTED
107361: 85 c0 test %eax,%eax <== NOT EXECUTED
107363: 74 10 je 107375 <malloc+0x9d> <== NOT EXECUTED
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
107365: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107368: 57 push %edi <== NOT EXECUTED
107369: ff 50 04 call *0x4(%eax) <== NOT EXECUTED
10736c: 89 c6 mov %eax,%esi <== NOT EXECUTED
if ( !return_this ) {
10736e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107371: 85 c0 test %eax,%eax <== NOT EXECUTED
107373: 75 a0 jne 107315 <malloc+0x3d> <== NOT EXECUTED
errno = ENOMEM;
107375: e8 a6 8e 00 00 call 110220 <__errno> <== NOT EXECUTED
10737a: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
107380: eb bb jmp 10733d <malloc+0x65> <== NOT EXECUTED
107382: 66 90 xchg %ax,%ax <== NOT EXECUTED
(*rtems_malloc_dirty_helper)( return_this, size );
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
107384: 89 f3 mov %esi,%ebx
if (rtems_malloc_boundary_helpers)
(*rtems_malloc_boundary_helpers->at_malloc)(return_this, size);
#endif
return return_this;
}
107386: 89 d8 mov %ebx,%eax
107388: 8d 65 f4 lea -0xc(%ebp),%esp
10738b: 5b pop %ebx
10738c: 5e pop %esi
10738d: 5f pop %edi
10738e: c9 leave
10738f: c3 ret
00107218 <malloc_deferred_free>:
}
void malloc_deferred_free(
void *pointer
)
{
107218: 55 push %ebp <== NOT EXECUTED
107219: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10721b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
10721e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
107221: 68 dc e4 11 00 push $0x11e4dc <== NOT EXECUTED
107226: e8 51 3b 00 00 call 10ad7c <_Chain_Append> <== NOT EXECUTED
10722b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_chain_append(&RTEMS_Malloc_GC_list, (rtems_chain_node *)pointer);
}
10722e: c9 leave <== NOT EXECUTED
10722f: c3 ret <== NOT EXECUTED
00107230 <malloc_deferred_frees_process>:
{
rtems_chain_initialize_empty(&RTEMS_Malloc_GC_list);
}
void malloc_deferred_frees_process(void)
{
107230: 55 push %ebp
107231: 89 e5 mov %esp,%ebp
107233: 83 ec 08 sub $0x8,%esp
107236: eb 0c jmp 107244 <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);
107238: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10723b: 50 push %eax <== NOT EXECUTED
10723c: e8 7f fe ff ff call 1070c0 <free> <== NOT EXECUTED
107241: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107244: 83 ec 0c sub $0xc,%esp
107247: 68 dc e4 11 00 push $0x11e4dc
10724c: e8 4f 3b 00 00 call 10ada0 <_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)
107251: 83 c4 10 add $0x10,%esp
107254: 85 c0 test %eax,%eax
107256: 75 e0 jne 107238 <malloc_deferred_frees_process+0x8><== NEVER TAKEN
free(to_be_freed);
}
107258: c9 leave
107259: c3 ret
00108618 <malloc_info>:
*/
int malloc_info(
Heap_Information_block *the_info
)
{
108618: 55 push %ebp
108619: 89 e5 mov %esp,%ebp
10861b: 83 ec 08 sub $0x8,%esp
10861e: 8b 45 08 mov 0x8(%ebp),%eax
if ( !the_info )
108621: 85 c0 test %eax,%eax
108623: 74 17 je 10863c <malloc_info+0x24>
return -1;
_Protected_heap_Get_information( &RTEMS_Malloc_Heap, the_info );
108625: 83 ec 08 sub $0x8,%esp
108628: 50 push %eax
108629: 68 a0 3b 12 00 push $0x123ba0
10862e: e8 0d 57 00 00 call 10dd40 <_Protected_heap_Get_information>
108633: 31 c0 xor %eax,%eax
108635: 83 c4 10 add $0x10,%esp
return 0;
}
108638: c9 leave
108639: c3 ret
10863a: 66 90 xchg %ax,%ax
int malloc_info(
Heap_Information_block *the_info
)
{
if ( !the_info )
10863c: b8 ff ff ff ff mov $0xffffffff,%eax
return -1;
_Protected_heap_Get_information( &RTEMS_Malloc_Heap, the_info );
return 0;
}
108641: c9 leave
108642: c3 ret
001071d8 <malloc_is_system_state_OK>:
#include "malloc_p.h"
rtems_chain_control RTEMS_Malloc_GC_list;
bool malloc_is_system_state_OK(void)
{
1071d8: 55 push %ebp
1071d9: 89 e5 mov %esp,%ebp
if ( _Thread_Dispatch_disable_level > 0 )
1071db: a1 58 e6 11 00 mov 0x11e658,%eax
1071e0: 85 c0 test %eax,%eax
1071e2: 75 0c jne 1071f0 <malloc_is_system_state_OK+0x18><== NEVER TAKEN
return false;
if ( _ISR_Nest_level > 0 )
1071e4: a1 f8 e6 11 00 mov 0x11e6f8,%eax
1071e9: 85 c0 test %eax,%eax
1071eb: 0f 94 c0 sete %al
return false;
return true;
}
1071ee: c9 leave
1071ef: c3 ret
rtems_chain_control RTEMS_Malloc_GC_list;
bool malloc_is_system_state_OK(void)
{
if ( _Thread_Dispatch_disable_level > 0 )
1071f0: 31 c0 xor %eax,%eax
if ( _ISR_Nest_level > 0 )
return false;
return true;
}
1071f2: c9 leave <== NOT EXECUTED
1071f3: c3 ret <== NOT EXECUTED
00107390 <mknod>:
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
107390: 55 push %ebp
107391: 89 e5 mov %esp,%ebp
107393: 57 push %edi
107394: 56 push %esi
107395: 53 push %ebx
107396: 83 ec 3c sub $0x3c,%esp
107399: 8b 5d 08 mov 0x8(%ebp),%ebx
10739c: 8b 45 10 mov 0x10(%ebp),%eax
10739f: 8b 55 14 mov 0x14(%ebp),%edx
1073a2: 89 45 c8 mov %eax,-0x38(%ebp)
1073a5: 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) {
1073a8: 8b 45 0c mov 0xc(%ebp),%eax
1073ab: 25 00 f0 00 00 and $0xf000,%eax
1073b0: 3d 00 40 00 00 cmp $0x4000,%eax
1073b5: 74 35 je 1073ec <mknod+0x5c>
1073b7: 76 23 jbe 1073dc <mknod+0x4c> <== ALWAYS TAKEN
1073b9: 3d 00 60 00 00 cmp $0x6000,%eax <== NOT EXECUTED
1073be: 74 2c je 1073ec <mknod+0x5c> <== NOT EXECUTED
1073c0: 3d 00 80 00 00 cmp $0x8000,%eax <== NOT EXECUTED
1073c5: 74 25 je 1073ec <mknod+0x5c> <== NOT EXECUTED
case S_IFBLK:
case S_IFREG:
case S_IFIFO:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
1073c7: e8 54 8e 00 00 call 110220 <__errno> <== NOT EXECUTED
1073cc: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
1073d2: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED
1073d7: eb 5b jmp 107434 <mknod+0xa4> <== NOT EXECUTED
1073d9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT) {
1073dc: 3d 00 10 00 00 cmp $0x1000,%eax
1073e1: 74 41 je 107424 <mknod+0x94> <== NEVER TAKEN
1073e3: 3d 00 20 00 00 cmp $0x2000,%eax
1073e8: 75 dd jne 1073c7 <mknod+0x37> <== NEVER TAKEN
1073ea: 66 90 xchg %ax,%ax
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( S_ISFIFO(mode) )
1073ec: 3d 00 10 00 00 cmp $0x1000,%eax
1073f1: 74 31 je 107424 <mknod+0x94> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
1073f3: 8a 03 mov (%ebx),%al
1073f5: 3c 2f cmp $0x2f,%al
1073f7: 74 47 je 107440 <mknod+0xb0> <== ALWAYS TAKEN
1073f9: 3c 5c cmp $0x5c,%al <== NOT EXECUTED
1073fb: 74 43 je 107440 <mknod+0xb0> <== NOT EXECUTED
1073fd: 84 c0 test %al,%al <== NOT EXECUTED
1073ff: 74 3f je 107440 <mknod+0xb0> <== NOT EXECUTED
107401: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED
107404: 89 45 bc mov %eax,-0x44(%ebp) <== NOT EXECUTED
107407: a1 b4 c4 11 00 mov 0x11c4b4,%eax <== NOT EXECUTED
10740c: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED
10740f: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
107414: 8b 7d bc mov -0x44(%ebp),%edi <== NOT EXECUTED
107417: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
if ( !temp_loc.ops->evalformake_h ) {
107419: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
10741c: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED
10741f: 85 d2 test %edx,%edx <== NOT EXECUTED
107421: 75 40 jne 107463 <mknod+0xd3> <== NOT EXECUTED
107423: 90 nop <== NOT EXECUTED
if ( result != 0 )
return -1;
if ( !temp_loc.ops->mknod_h ) {
rtems_filesystem_freenode( &temp_loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
107424: e8 f7 8d 00 00 call 110220 <__errno> <== NOT EXECUTED
107429: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10742f: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
rtems_filesystem_freenode( &temp_loc );
return result;
}
107434: 89 f0 mov %esi,%eax
107436: 8d 65 f4 lea -0xc(%ebp),%esp
107439: 5b pop %ebx
10743a: 5e pop %esi
10743b: 5f pop %edi
10743c: c9 leave
10743d: c3 ret
10743e: 66 90 xchg %ax,%ax
}
if ( S_ISFIFO(mode) )
rtems_set_errno_and_return_minus_one( ENOTSUP );
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
107440: 8d 55 dc lea -0x24(%ebp),%edx
107443: 89 55 bc mov %edx,-0x44(%ebp)
107446: a1 b4 c4 11 00 mov 0x11c4b4,%eax
10744b: 8d 70 14 lea 0x14(%eax),%esi
10744e: b9 04 00 00 00 mov $0x4,%ecx
107453: 89 d7 mov %edx,%edi
107455: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
107457: b1 01 mov $0x1,%cl
if ( !temp_loc.ops->evalformake_h ) {
107459: 8b 45 e4 mov -0x1c(%ebp),%eax
10745c: 8b 50 04 mov 0x4(%eax),%edx
10745f: 85 d2 test %edx,%edx
107461: 74 c1 je 107424 <mknod+0x94> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*temp_loc.ops->evalformake_h)(
107463: 50 push %eax
107464: 8d 45 ec lea -0x14(%ebp),%eax
107467: 50 push %eax
107468: ff 75 bc pushl -0x44(%ebp)
10746b: 8d 04 0b lea (%ebx,%ecx,1),%eax
10746e: 50 push %eax
10746f: ff d2 call *%edx
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
107471: 83 c4 10 add $0x10,%esp
107474: 85 c0 test %eax,%eax
107476: 75 b7 jne 10742f <mknod+0x9f> <== NEVER TAKEN
return -1;
if ( !temp_loc.ops->mknod_h ) {
107478: 8b 45 e4 mov -0x1c(%ebp),%eax
10747b: 8b 50 14 mov 0x14(%eax),%edx
10747e: 85 d2 test %edx,%edx
107480: 74 3c je 1074be <mknod+0x12e> <== NEVER TAKEN
rtems_filesystem_freenode( &temp_loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
107482: 83 ec 0c sub $0xc,%esp
107485: ff 75 bc pushl -0x44(%ebp)
107488: ff 75 cc pushl -0x34(%ebp)
10748b: ff 75 c8 pushl -0x38(%ebp)
10748e: ff 75 0c pushl 0xc(%ebp)
107491: ff 75 ec pushl -0x14(%ebp)
107494: ff d2 call *%edx
107496: 89 c6 mov %eax,%esi
rtems_filesystem_freenode( &temp_loc );
107498: 8b 45 e4 mov -0x1c(%ebp),%eax
10749b: 83 c4 20 add $0x20,%esp
10749e: 85 c0 test %eax,%eax
1074a0: 74 92 je 107434 <mknod+0xa4> <== NEVER TAKEN
1074a2: 8b 40 1c mov 0x1c(%eax),%eax
1074a5: 85 c0 test %eax,%eax
1074a7: 74 8b je 107434 <mknod+0xa4> <== ALWAYS TAKEN
1074a9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1074ac: ff 75 bc pushl -0x44(%ebp) <== NOT EXECUTED
1074af: ff d0 call *%eax <== NOT EXECUTED
1074b1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return result;
}
1074b4: 89 f0 mov %esi,%eax <== NOT EXECUTED
1074b6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1074b9: 5b pop %ebx <== NOT EXECUTED
1074ba: 5e pop %esi <== NOT EXECUTED
1074bb: 5f pop %edi <== NOT EXECUTED
1074bc: c9 leave <== NOT EXECUTED
1074bd: c3 ret <== NOT EXECUTED
);
if ( result != 0 )
return -1;
if ( !temp_loc.ops->mknod_h ) {
rtems_filesystem_freenode( &temp_loc );
1074be: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
1074c1: 85 c0 test %eax,%eax <== NOT EXECUTED
1074c3: 0f 84 5b ff ff ff je 107424 <mknod+0x94> <== NOT EXECUTED
1074c9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1074cc: ff 75 bc pushl -0x44(%ebp) <== NOT EXECUTED
1074cf: ff d0 call *%eax <== NOT EXECUTED
1074d1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1074d4: e9 4b ff ff ff jmp 107424 <mknod+0x94> <== NOT EXECUTED
0010e964 <mount>:
const rtems_filesystem_operations_table *fs_ops,
rtems_filesystem_options_t options,
const char *device,
const char *mount_point
)
{
10e964: 55 push %ebp
10e965: 89 e5 mov %esp,%ebp
10e967: 57 push %edi
10e968: 56 push %esi
10e969: 53 push %ebx
10e96a: 83 ec 1c sub $0x1c,%esp
10e96d: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Is there a file system operations table?
*/
if ( fs_ops == NULL ) {
10e970: 8b 45 0c mov 0xc(%ebp),%eax
10e973: 85 c0 test %eax,%eax
10e975: 0f 84 75 02 00 00 je 10ebf0 <mount+0x28c> <== NEVER TAKEN
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
10e97b: 83 fe 01 cmp $0x1,%esi
10e97e: 0f 87 6c 02 00 00 ja 10ebf0 <mount+0x28c> <== NEVER TAKEN
errno = EINVAL;
return -1;
}
/* Do they support being mounted at all ? */
if ( !fs_ops->fsmount_me_h ) {
10e984: 8b 45 0c mov 0xc(%ebp),%eax
10e987: 8b 78 24 mov 0x24(%eax),%edi
10e98a: 85 ff test %edi,%edi
10e98c: 0f 84 cb 00 00 00 je 10ea5d <mount+0xf9> <== NEVER TAKEN
/*
* Allocate a mount table entry
*/
size = sizeof(rtems_filesystem_mount_table_entry_t);
if ( device )
10e992: 8b 5d 14 mov 0x14(%ebp),%ebx
10e995: 85 db test %ebx,%ebx
10e997: 0f 84 ef 00 00 00 je 10ea8c <mount+0x128> <== ALWAYS TAKEN
size += strlen( device ) + 1;
10e99d: 31 c0 xor %eax,%eax
10e99f: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED
10e9a4: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED
10e9a7: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED
10e9a9: f7 d1 not %ecx <== NOT EXECUTED
10e9ab: 8d 41 64 lea 0x64(%ecx),%eax <== NOT EXECUTED
temp_mt_entry = malloc( size );
10e9ae: 83 ec 0c sub $0xc,%esp
10e9b1: 50 push %eax
10e9b2: e8 21 89 ff ff call 1072d8 <malloc>
10e9b7: 89 c3 mov %eax,%ebx
10e9b9: 89 45 e0 mov %eax,-0x20(%ebp)
if ( !temp_mt_entry ) {
10e9bc: 83 c4 10 add $0x10,%esp
10e9bf: 85 c0 test %eax,%eax
10e9c1: 0f 84 3e 02 00 00 je 10ec05 <mount+0x2a1> <== NEVER TAKEN
errno = ENOMEM;
return -1;
}
temp_mt_entry->mt_fs_root.mt_entry = temp_mt_entry;
10e9c7: 89 43 24 mov %eax,0x24(%ebx)
temp_mt_entry->options = options;
10e9ca: 89 70 28 mov %esi,0x28(%eax)
if ( device ) {
10e9cd: 8b 4d 14 mov 0x14(%ebp),%ecx
10e9d0: 85 c9 test %ecx,%ecx
10e9d2: 0f 84 3c 01 00 00 je 10eb14 <mount+0x1b0> <== ALWAYS TAKEN
temp_mt_entry->dev =
10e9d8: 8d 40 64 lea 0x64(%eax),%eax <== NOT EXECUTED
10e9db: 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 );
10e9de: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10e9e1: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED
10e9e4: 50 push %eax <== NOT EXECUTED
10e9e5: e8 42 29 00 00 call 11132c <strcpy> <== NOT EXECUTED
10e9ea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( mount_point ) {
10e9ed: 8b 55 18 mov 0x18(%ebp),%edx
10e9f0: 85 d2 test %edx,%edx
10e9f2: 0f 84 a0 00 00 00 je 10ea98 <mount+0x134> <== ALWAYS TAKEN
if ( rtems_filesystem_evaluate_path(
10e9f8: 6a 01 push $0x1 <== NOT EXECUTED
10e9fa: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED
10e9fd: 56 push %esi <== NOT EXECUTED
10e9fe: 6a 07 push $0x7 <== NOT EXECUTED
10ea00: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED
10ea03: e8 74 85 ff ff call 106f7c <rtems_filesystem_evaluate_path><== NOT EXECUTED
10ea08: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ea0b: 40 inc %eax <== NOT EXECUTED
10ea0c: 74 62 je 10ea70 <mount+0x10c> <== NOT EXECUTED
/*
* Test for node_type_h
*/
if (!loc.ops->node_type_h) {
10ea0e: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
10ea11: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED
10ea14: 85 c0 test %eax,%eax <== NOT EXECUTED
10ea16: 0f 84 9c 01 00 00 je 10ebb8 <mount+0x254> <== NOT EXECUTED
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
10ea1c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ea1f: 56 push %esi <== NOT EXECUTED
10ea20: ff d0 call *%eax <== NOT EXECUTED
10ea22: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ea25: 48 dec %eax <== NOT EXECUTED
10ea26: 0f 84 f4 00 00 00 je 10eb20 <mount+0x1bc> <== NOT EXECUTED
errno = ENOTDIR;
10ea2c: e8 ef 17 00 00 call 110220 <__errno> <== NOT EXECUTED
10ea31: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( temp_mt_entry );
10ea37: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ea3a: 53 push %ebx <== NOT EXECUTED
10ea3b: e8 80 86 ff ff call 1070c0 <free> <== NOT EXECUTED
10ea40: 89 f7 mov %esi,%edi <== NOT EXECUTED
10ea42: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
10ea45: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED
10ea48: 85 c0 test %eax,%eax <== NOT EXECUTED
10ea4a: 0f 85 78 01 00 00 jne 10ebc8 <mount+0x264> <== NOT EXECUTED
10ea50: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
return -1;
}
10ea55: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10ea58: 5b pop %ebx <== NOT EXECUTED
10ea59: 5e pop %esi <== NOT EXECUTED
10ea5a: 5f pop %edi <== NOT EXECUTED
10ea5b: c9 leave <== NOT EXECUTED
10ea5c: c3 ret <== NOT EXECUTED
return -1;
}
/* Do they support being mounted at all ? */
if ( !fs_ops->fsmount_me_h ) {
errno = ENOTSUP;
10ea5d: e8 be 17 00 00 call 110220 <__errno> <== NOT EXECUTED
10ea62: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10ea68: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
10ea6f: 90 nop <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( temp_mt_entry );
10ea70: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ea73: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED
10ea76: e8 45 86 ff ff call 1070c0 <free> <== NOT EXECUTED
10ea7b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10ea80: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
}
10ea83: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10ea86: 5b pop %ebx <== NOT EXECUTED
10ea87: 5e pop %esi <== NOT EXECUTED
10ea88: 5f pop %edi <== NOT EXECUTED
10ea89: c9 leave <== NOT EXECUTED
10ea8a: c3 ret <== NOT EXECUTED
10ea8b: 90 nop <== NOT EXECUTED
/*
* Allocate a mount table entry
*/
size = sizeof(rtems_filesystem_mount_table_entry_t);
if ( device )
10ea8c: b8 64 00 00 00 mov $0x64,%eax
10ea91: e9 18 ff ff ff jmp 10e9ae <mount+0x4a>
10ea96: 66 90 xchg %ax,%ax
* 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;
10ea98: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
temp_mt_entry->mt_fs_root.handlers = NULL;
10ea9f: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
temp_mt_entry->mt_fs_root.ops = NULL;
10eaa6: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
temp_mt_entry->mt_point_node.node_access = NULL;
10eaad: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
temp_mt_entry->mt_point_node.handlers = NULL;
10eab4: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
temp_mt_entry->mt_point_node.ops = NULL;
10eabb: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
temp_mt_entry->mt_point_node.mt_entry = NULL;
10eac2: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
10eac9: 31 ff xor %edi,%edi
}
if ( fs_ops->fsmount_me_h( temp_mt_entry ) ) {
10eacb: 83 ec 0c sub $0xc,%esp
10eace: 53 push %ebx
10eacf: 8b 55 0c mov 0xc(%ebp),%edx
10ead2: ff 52 24 call *0x24(%edx)
10ead5: 83 c4 10 add $0x10,%esp
10ead8: 85 c0 test %eax,%eax
10eada: 0f 84 a0 00 00 00 je 10eb80 <mount+0x21c> <== ALWAYS TAKEN
/* try to undo the mount operation */
if ( loc.ops->unmount_h ) {
10eae0: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
10eae3: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED
10eae6: 85 c0 test %eax,%eax <== NOT EXECUTED
10eae8: 74 09 je 10eaf3 <mount+0x18f> <== NOT EXECUTED
loc.ops->unmount_h( temp_mt_entry );
10eaea: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10eaed: 53 push %ebx <== NOT EXECUTED
10eaee: ff d0 call *%eax <== NOT EXECUTED
10eaf0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( temp_mt_entry );
10eaf3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10eaf6: 53 push %ebx <== NOT EXECUTED
10eaf7: e8 c4 85 ff ff call 1070c0 <free> <== NOT EXECUTED
if ( loc_to_free )
10eafc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10eaff: 85 ff test %edi,%edi <== NOT EXECUTED
10eb01: 0f 85 3e ff ff ff jne 10ea45 <mount+0xe1> <== NOT EXECUTED
rtems_filesystem_freenode( loc_to_free );
10eb07: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10eb0c: e9 44 ff ff ff jmp 10ea55 <mount+0xf1> <== NOT EXECUTED
10eb11: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if ( device ) {
temp_mt_entry->dev =
(char *)temp_mt_entry + sizeof( rtems_filesystem_mount_table_entry_t );
strcpy( temp_mt_entry->dev, device );
} else
temp_mt_entry->dev = 0;
10eb14: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
10eb1b: e9 cd fe ff ff jmp 10e9ed <mount+0x89>
/*
* For each mount table entry
*/
for ( the_node = rtems_filesystem_mount_table_control.first;
10eb20: a1 60 e9 11 00 mov 0x11e960,%eax <== NOT EXECUTED
!rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
10eb25: 3d 64 e9 11 00 cmp $0x11e964,%eax <== NOT EXECUTED
10eb2a: 0f 84 b6 00 00 00 je 10ebe6 <mount+0x282> <== NOT EXECUTED
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 )
10eb30: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
10eb33: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED
10eb36: 75 09 jne 10eb41 <mount+0x1dd> <== NOT EXECUTED
10eb38: eb 6e jmp 10eba8 <mount+0x244> <== NOT EXECUTED
10eb3a: 66 90 xchg %ax,%ax <== NOT EXECUTED
10eb3c: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED
10eb3f: 74 67 je 10eba8 <mount+0x244> <== NOT EXECUTED
* 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 ) {
10eb41: 8b 00 mov (%eax),%eax <== NOT EXECUTED
/*
* 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 );
10eb43: 3d 64 e9 11 00 cmp $0x11e964,%eax <== NOT EXECUTED
10eb48: 75 f2 jne 10eb3c <mount+0x1d8> <== NOT EXECUTED
* 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;
10eb4a: 89 53 08 mov %edx,0x8(%ebx) <== NOT EXECUTED
temp_mt_entry->mt_point_node.handlers = loc.handlers;
10eb4d: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED
10eb50: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED
temp_mt_entry->mt_point_node.ops = loc.ops;
10eb53: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED
10eb56: 89 53 10 mov %edx,0x10(%ebx) <== NOT EXECUTED
temp_mt_entry->mt_point_node.mt_entry = loc.mt_entry;
10eb59: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED
10eb5c: 89 43 14 mov %eax,0x14(%ebx) <== NOT EXECUTED
/*
* This link to the parent is only done when we are dealing with system
* below the base file system
*/
if ( !loc.ops->mount_h ){
10eb5f: 8b 42 20 mov 0x20(%edx),%eax <== NOT EXECUTED
10eb62: 85 c0 test %eax,%eax <== NOT EXECUTED
10eb64: 74 52 je 10ebb8 <mount+0x254> <== NOT EXECUTED
errno = ENOTSUP;
goto cleanup_and_bail;
}
if ( loc.ops->mount_h( temp_mt_entry ) ) {
10eb66: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10eb69: 53 push %ebx <== NOT EXECUTED
10eb6a: ff d0 call *%eax <== NOT EXECUTED
10eb6c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10eb6f: 85 c0 test %eax,%eax <== NOT EXECUTED
10eb71: 0f 85 c0 fe ff ff jne 10ea37 <mount+0xd3> <== NOT EXECUTED
goto cleanup_and_bail;
10eb77: 89 f7 mov %esi,%edi <== NOT EXECUTED
10eb79: e9 4d ff ff ff jmp 10eacb <mount+0x167> <== NOT EXECUTED
10eb7e: 66 90 xchg %ax,%ax <== NOT EXECUTED
10eb80: 83 ec 08 sub $0x8,%esp
10eb83: 53 push %ebx
10eb84: 68 60 e9 11 00 push $0x11e960
10eb89: e8 ee c1 ff ff call 10ad7c <_Chain_Append>
*/
rtems_chain_append( &rtems_filesystem_mount_table_control,
&temp_mt_entry->Node );
if ( mt_entry )
10eb8e: 83 c4 10 add $0x10,%esp
10eb91: 8b 45 08 mov 0x8(%ebp),%eax
10eb94: 85 c0 test %eax,%eax
10eb96: 74 05 je 10eb9d <mount+0x239> <== NEVER TAKEN
*mt_entry = temp_mt_entry;
10eb98: 8b 7d 08 mov 0x8(%ebp),%edi
10eb9b: 89 1f mov %ebx,(%edi)
10eb9d: 31 c0 xor %eax,%eax
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
}
10eb9f: 8d 65 f4 lea -0xc(%ebp),%esp
10eba2: 5b pop %ebx
10eba3: 5e pop %esi
10eba4: 5f pop %edi
10eba5: c9 leave
10eba6: c3 ret
10eba7: 90 nop
/*
* You can only mount one file system onto a single mount point.
*/
if ( Is_node_fs_root( &loc ) ){
errno = EBUSY;
10eba8: e8 73 16 00 00 call 110220 <__errno> <== NOT EXECUTED
10ebad: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED
10ebb3: e9 7f fe ff ff jmp 10ea37 <mount+0xd3> <== NOT EXECUTED
* 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;
10ebb8: e8 63 16 00 00 call 110220 <__errno> <== NOT EXECUTED
10ebbd: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10ebc3: e9 6f fe ff ff jmp 10ea37 <mount+0xd3> <== NOT EXECUTED
cleanup_and_bail:
free( temp_mt_entry );
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
10ebc8: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
10ebcb: 85 c0 test %eax,%eax <== NOT EXECUTED
10ebcd: 0f 84 7d fe ff ff je 10ea50 <mount+0xec> <== NOT EXECUTED
10ebd3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ebd6: 57 push %edi <== NOT EXECUTED
10ebd7: ff d0 call *%eax <== NOT EXECUTED
10ebd9: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10ebde: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ebe1: e9 9d fe ff ff jmp 10ea83 <mount+0x11f> <== NOT EXECUTED
10ebe6: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
10ebe9: e9 5c ff ff ff jmp 10eb4a <mount+0x1e6> <== NOT EXECUTED
10ebee: 66 90 xchg %ax,%ax <== NOT EXECUTED
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
options != RTEMS_FILESYSTEM_READ_WRITE ) {
errno = EINVAL;
10ebf0: e8 2b 16 00 00 call 110220 <__errno> <== NOT EXECUTED
10ebf5: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
10ebfb: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10ec00: e9 7e fe ff ff jmp 10ea83 <mount+0x11f> <== NOT EXECUTED
if ( device )
size += strlen( device ) + 1;
temp_mt_entry = malloc( size );
if ( !temp_mt_entry ) {
errno = ENOMEM;
10ec05: e8 16 16 00 00 call 110220 <__errno> <== NOT EXECUTED
10ec0a: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
10ec10: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10ec15: e9 69 fe ff ff jmp 10ea83 <mount+0x11f> <== NOT EXECUTED
00107568 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
107568: 55 push %ebp
107569: 89 e5 mov %esp,%ebp
10756b: 53 push %ebx
10756c: 83 ec 10 sub $0x10,%esp
10756f: 8b 5d 08 mov 0x8(%ebp),%ebx
switch ( fileno(fp) ) {
107572: 53 push %ebx
107573: e8 94 8f 00 00 call 11050c <fileno>
107578: 83 c4 10 add $0x10,%esp
10757b: 83 f8 02 cmp $0x2,%eax
10757e: 76 14 jbe 107594 <newlib_free_buffers+0x2c><== ALWAYS TAKEN
fp->_flags &= ~__SMBF;
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
107580: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107583: 53 push %ebx <== NOT EXECUTED
107584: e8 e3 8d 00 00 call 11036c <fclose> <== NOT EXECUTED
107589: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
return 0;
}
10758c: 31 c0 xor %eax,%eax
10758e: 8b 5d fc mov -0x4(%ebp),%ebx
107591: c9 leave
107592: c3 ret
107593: 90 nop
{
switch ( fileno(fp) ) {
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
107594: 80 7b 0c 00 cmpb $0x0,0xc(%ebx)
107598: 79 f2 jns 10758c <newlib_free_buffers+0x24>
free( fp->_bf._base );
10759a: 83 ec 0c sub $0xc,%esp
10759d: ff 73 10 pushl 0x10(%ebx)
1075a0: e8 1b fb ff ff call 1070c0 <free>
fp->_flags &= ~__SMBF;
1075a5: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx)
fp->_bf._base = fp->_p = (unsigned char *) NULL;
1075ab: c7 03 00 00 00 00 movl $0x0,(%ebx)
1075b1: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
1075b8: 83 c4 10 add $0x10,%esp
break;
default:
fclose(fp);
}
return 0;
}
1075bb: 31 c0 xor %eax,%eax
1075bd: 8b 5d fc mov -0x4(%ebp),%ebx
1075c0: c9 leave
1075c1: c3 ret
001076fc <null_initialize>:
rtems_device_driver null_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *pargp
)
{
1076fc: 55 push %ebp
1076fd: 89 e5 mov %esp,%ebp
1076ff: 83 ec 08 sub $0x8,%esp
rtems_device_driver status;
if ( !initialized ) {
107702: 80 3d 50 13 12 00 00 cmpb $0x0,0x121350
107709: 74 05 je 107710 <null_initialize+0x14>
NULL_major = major;
}
return RTEMS_SUCCESSFUL;
}
10770b: 31 c0 xor %eax,%eax
10770d: c9 leave
10770e: c3 ret
10770f: 90 nop
)
{
rtems_device_driver status;
if ( !initialized ) {
initialized = 1;
107710: c6 05 50 13 12 00 01 movb $0x1,0x121350
status = rtems_io_register_name(
107717: 50 push %eax
107718: 6a 00 push $0x0
10771a: ff 75 08 pushl 0x8(%ebp)
10771d: 68 b7 ac 11 00 push $0x11acb7
107722: e8 11 01 00 00 call 107838 <rtems_io_register_name>
"/dev/null",
major,
(rtems_device_minor_number) 0
);
if (status != RTEMS_SUCCESSFUL)
107727: 83 c4 10 add $0x10,%esp
10772a: 85 c0 test %eax,%eax
10772c: 75 0c jne 10773a <null_initialize+0x3e> <== NEVER TAKEN
rtems_fatal_error_occurred(status);
NULL_major = major;
10772e: 8b 45 08 mov 0x8(%ebp),%eax
107731: a3 90 15 12 00 mov %eax,0x121590
}
return RTEMS_SUCCESSFUL;
}
107736: 31 c0 xor %eax,%eax
107738: c9 leave
107739: c3 ret
major,
(rtems_device_minor_number) 0
);
if (status != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred(status);
10773a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10773d: 50 push %eax <== NOT EXECUTED
10773e: e8 81 3f 00 00 call 10b6c4 <rtems_fatal_error_occurred><== NOT EXECUTED
001076e0 <null_write>:
rtems_device_driver null_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *pargp
)
{
1076e0: 55 push %ebp
1076e1: 89 e5 mov %esp,%ebp
1076e3: 8b 55 10 mov 0x10(%ebp),%edx
rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) pargp;
if ( rw_args )
1076e6: 85 d2 test %edx,%edx
1076e8: 74 06 je 1076f0 <null_write+0x10> <== ALWAYS TAKEN
rw_args->bytes_moved = rw_args->count;
1076ea: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED
1076ed: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED
return NULL_SUCCESSFUL;
}
1076f0: 31 c0 xor %eax,%eax
1076f2: c9 leave
1076f3: c3 ret
00107880 <open>:
int open(
const char *pathname,
int flags,
...
)
{
107880: 55 push %ebp
107881: 89 e5 mov %esp,%ebp
107883: 57 push %edi
107884: 56 push %esi
107885: 53 push %ebx
107886: 83 ec 2c sub $0x2c,%esp
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
107889: 8b 45 0c mov 0xc(%ebp),%eax
10788c: 40 inc %eax
if ( ( status & _FREAD ) == _FREAD )
10788d: 89 c3 mov %eax,%ebx
10788f: 83 e3 01 and $0x1,%ebx
107892: f7 db neg %ebx
107894: 83 e3 04 and $0x4,%ebx
eval_flags |= RTEMS_LIBIO_PERMS_READ;
if ( ( status & _FWRITE ) == _FWRITE )
107897: a8 02 test $0x2,%al
107899: 74 03 je 10789e <open+0x1e>
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
10789b: 83 cb 02 or $0x2,%ebx
va_start(ap, flags);
mode = va_arg( ap, int );
10789e: 8b 45 10 mov 0x10(%ebp),%eax
1078a1: 89 45 e0 mov %eax,-0x20(%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();
1078a4: e8 83 6f 00 00 call 10e82c <rtems_libio_allocate>
1078a9: 89 45 d4 mov %eax,-0x2c(%ebp)
if ( iop == 0 ) {
1078ac: 85 c0 test %eax,%eax
1078ae: 0f 84 bc 00 00 00 je 107970 <open+0xf0>
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
1078b4: 6a 01 push $0x1
1078b6: 8d 55 e4 lea -0x1c(%ebp),%edx
1078b9: 89 55 d8 mov %edx,-0x28(%ebp)
1078bc: 52 push %edx
1078bd: 53 push %ebx
1078be: ff 75 08 pushl 0x8(%ebp)
1078c1: e8 b6 f6 ff ff call 106f7c <rtems_filesystem_evaluate_path>
pathname, eval_flags, &loc, true );
if ( status == -1 ) {
1078c6: 83 c4 10 add $0x10,%esp
1078c9: 40 inc %eax
1078ca: 0f 84 14 01 00 00 je 1079e4 <open+0x164> <== NEVER TAKEN
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
1078d0: 8b 45 0c mov 0xc(%ebp),%eax
1078d3: 25 00 0a 00 00 and $0xa00,%eax
1078d8: 3d 00 0a 00 00 cmp $0xa00,%eax
1078dd: 0f 84 a9 00 00 00 je 10798c <open+0x10c> <== NEVER TAKEN
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->handlers = loc.handlers;
1078e3: 8b 45 e8 mov -0x18(%ebp),%eax
1078e6: 8b 55 d4 mov -0x2c(%ebp),%edx
1078e9: 89 42 30 mov %eax,0x30(%edx)
iop->file_info = loc.node_access;
1078ec: 8b 45 e4 mov -0x1c(%ebp),%eax
1078ef: 89 42 2c mov %eax,0x2c(%edx)
iop->flags |= rtems_libio_fcntl_flags( flags );
1078f2: 8b 5a 0c mov 0xc(%edx),%ebx
1078f5: 83 ec 0c sub $0xc,%esp
1078f8: ff 75 0c pushl 0xc(%ebp)
1078fb: e8 e8 6f 00 00 call 10e8e8 <rtems_libio_fcntl_flags>
107900: 09 c3 or %eax,%ebx
107902: 8b 75 d4 mov -0x2c(%ebp),%esi
107905: 89 5e 0c mov %ebx,0xc(%esi)
iop->pathinfo = loc;
107908: 89 f7 mov %esi,%edi
10790a: 83 c7 10 add $0x10,%edi
10790d: b9 04 00 00 00 mov $0x4,%ecx
107912: 8b 75 d8 mov -0x28(%ebp),%esi
107915: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !iop->handlers->open_h ) {
107917: 8b 55 d4 mov -0x2c(%ebp),%edx
10791a: 8b 42 30 mov 0x30(%edx),%eax
10791d: 8b 00 mov (%eax),%eax
10791f: 83 c4 10 add $0x10,%esp
107922: 85 c0 test %eax,%eax
107924: 0f 84 d6 00 00 00 je 107a00 <open+0x180> <== NEVER TAKEN
rc = ENOTSUP;
goto done;
}
rc = (*iop->handlers->open_h)( iop, pathname, flags, mode );
10792a: ff 75 e0 pushl -0x20(%ebp)
10792d: ff 75 0c pushl 0xc(%ebp)
107930: ff 75 08 pushl 0x8(%ebp)
107933: 52 push %edx
107934: ff d0 call *%eax
107936: 89 c7 mov %eax,%edi
if ( rc )
107938: 83 c4 10 add $0x10,%esp
10793b: 85 c0 test %eax,%eax
10793d: 74 61 je 1079a0 <open+0x120> <== ALWAYS TAKEN
10793f: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED
done:
va_end(ap);
if ( rc ) {
if ( iop )
rtems_libio_free( iop );
107942: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107945: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED
107948: e8 87 6e 00 00 call 10e7d4 <rtems_libio_free> <== NOT EXECUTED
10794d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if ( loc_to_free )
107950: 85 db test %ebx,%ebx <== NOT EXECUTED
107952: 74 21 je 107975 <open+0xf5> <== NOT EXECUTED
rtems_filesystem_freenode( loc_to_free );
107954: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED
107957: 85 c0 test %eax,%eax <== NOT EXECUTED
107959: 74 1a je 107975 <open+0xf5> <== NOT EXECUTED
10795b: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
10795e: 85 c0 test %eax,%eax <== NOT EXECUTED
107960: 74 13 je 107975 <open+0xf5> <== NOT EXECUTED
107962: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107965: 53 push %ebx <== NOT EXECUTED
107966: ff d0 call *%eax <== NOT EXECUTED
107968: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10796b: eb 08 jmp 107975 <open+0xf5> <== NOT EXECUTED
10796d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
* descriptors are obtained using socket(), not open().
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
if ( iop == 0 ) {
107970: bf 17 00 00 00 mov $0x17,%edi
if ( rc ) {
if ( iop )
rtems_libio_free( iop );
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
rtems_set_errno_and_return_minus_one( rc );
107975: e8 a6 88 00 00 call 110220 <__errno>
10797a: 89 38 mov %edi,(%eax)
10797c: b8 ff ff ff ff mov $0xffffffff,%eax
}
return iop - rtems_libio_iops;
}
107981: 8d 65 f4 lea -0xc(%ebp),%esp
107984: 5b pop %ebx
107985: 5e pop %esi
107986: 5f pop %edi
107987: c9 leave
107988: c3 ret
107989: 8d 76 00 lea 0x0(%esi),%esi
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
10798c: bf 11 00 00 00 mov $0x11,%edi <== NOT EXECUTED
107991: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED
done:
va_end(ap);
if ( rc ) {
if ( iop )
107994: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED
107997: 85 c0 test %eax,%eax <== NOT EXECUTED
107999: 74 b5 je 107950 <open+0xd0> <== NOT EXECUTED
10799b: eb a5 jmp 107942 <open+0xc2> <== NOT EXECUTED
10799d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
1079a0: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
1079a7: 0f 85 b7 00 00 00 jne 107a64 <open+0x1e4> <== NEVER TAKEN
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
rtems_set_errno_and_return_minus_one( rc );
}
return iop - rtems_libio_iops;
1079ad: 8b 4d d4 mov -0x2c(%ebp),%ecx
1079b0: 2b 0d d0 e4 11 00 sub 0x11e4d0,%ecx
1079b6: c1 f9 02 sar $0x2,%ecx
1079b9: 8d 14 89 lea (%ecx,%ecx,4),%edx
1079bc: 8d 14 92 lea (%edx,%edx,4),%edx
1079bf: 89 d0 mov %edx,%eax
1079c1: c1 e0 06 shl $0x6,%eax
1079c4: 29 d0 sub %edx,%eax
1079c6: 89 c2 mov %eax,%edx
1079c8: c1 e2 0c shl $0xc,%edx
1079cb: 01 d0 add %edx,%eax
1079cd: 8d 04 81 lea (%ecx,%eax,4),%eax
1079d0: 8d 04 41 lea (%ecx,%eax,2),%eax
1079d3: c1 e0 04 shl $0x4,%eax
1079d6: 01 c8 add %ecx,%eax
1079d8: 8d 04 81 lea (%ecx,%eax,4),%eax
}
1079db: 8d 65 f4 lea -0xc(%ebp),%esp
1079de: 5b pop %ebx
1079df: 5e pop %esi
1079e0: 5f pop %edi
1079e1: c9 leave
1079e2: c3 ret
1079e3: 90 nop
status = rtems_filesystem_evaluate_path(
pathname, eval_flags, &loc, true );
if ( status == -1 ) {
if ( errno != ENOENT ) {
1079e4: e8 37 88 00 00 call 110220 <__errno> <== NOT EXECUTED
1079e9: 83 38 02 cmpl $0x2,(%eax) <== NOT EXECUTED
1079ec: 75 1e jne 107a0c <open+0x18c> <== NOT EXECUTED
rc = errno;
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
1079ee: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) <== NOT EXECUTED
1079f5: 75 29 jne 107a20 <open+0x1a0> <== NOT EXECUTED
1079f7: bf 02 00 00 00 mov $0x2,%edi <== NOT EXECUTED
1079fc: 31 db xor %ebx,%ebx <== NOT EXECUTED
1079fe: eb 94 jmp 107994 <open+0x114> <== NOT EXECUTED
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
rtems_set_errno_and_return_minus_one( rc );
}
return iop - rtems_libio_iops;
107a00: bf 86 00 00 00 mov $0x86,%edi <== NOT EXECUTED
107a05: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED
107a08: eb 8a jmp 107994 <open+0x114> <== NOT EXECUTED
107a0a: 66 90 xchg %ax,%ax <== NOT EXECUTED
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
if ( rc ) {
rc = errno;
107a0c: e8 0f 88 00 00 call 110220 <__errno> <== NOT EXECUTED
107a11: 8b 38 mov (%eax),%edi <== NOT EXECUTED
*/
done:
va_end(ap);
if ( rc ) {
107a13: 85 ff test %edi,%edi <== NOT EXECUTED
107a15: 74 96 je 1079ad <open+0x12d> <== NOT EXECUTED
107a17: 31 db xor %ebx,%ebx <== NOT EXECUTED
107a19: e9 76 ff ff ff jmp 107994 <open+0x114> <== NOT EXECUTED
107a1e: 66 90 xchg %ax,%ax <== NOT EXECUTED
rc = ENOENT;
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
107a20: 6a 00 push $0x0 <== NOT EXECUTED
107a22: 6a 00 push $0x0 <== NOT EXECUTED
107a24: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
107a27: 80 cc 80 or $0x80,%ah <== NOT EXECUTED
107a2a: 50 push %eax <== NOT EXECUTED
107a2b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
107a2e: e8 5d f9 ff ff call 107390 <mknod> <== NOT EXECUTED
if ( rc ) {
107a33: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107a36: 85 c0 test %eax,%eax <== NOT EXECUTED
107a38: 75 d2 jne 107a0c <open+0x18c> <== NOT EXECUTED
rc = errno;
goto done;
}
/* Sanity check to see if the file name exists after the mknod() */
status = rtems_filesystem_evaluate_path( pathname, 0x0, &loc, true );
107a3a: 6a 01 push $0x1 <== NOT EXECUTED
107a3c: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED
107a3f: 50 push %eax <== NOT EXECUTED
107a40: 6a 00 push $0x0 <== NOT EXECUTED
107a42: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
107a45: e8 32 f5 ff ff call 106f7c <rtems_filesystem_evaluate_path><== NOT EXECUTED
if ( status != 0 ) { /* The file did not exist */
107a4a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107a4d: 85 c0 test %eax,%eax <== NOT EXECUTED
107a4f: 0f 84 8e fe ff ff je 1078e3 <open+0x63> <== NOT EXECUTED
107a55: bf 0d 00 00 00 mov $0xd,%edi <== NOT EXECUTED
107a5a: 31 db xor %ebx,%ebx <== NOT EXECUTED
107a5c: e9 33 ff ff ff jmp 107994 <open+0x114> <== NOT EXECUTED
107a61: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
107a64: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
107a67: 6a 00 push $0x0 <== NOT EXECUTED
107a69: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED
107a6c: 2b 0d d0 e4 11 00 sub 0x11e4d0,%ecx <== NOT EXECUTED
107a72: c1 f9 02 sar $0x2,%ecx <== NOT EXECUTED
107a75: 8d 14 89 lea (%ecx,%ecx,4),%edx <== NOT EXECUTED
107a78: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED
107a7b: 89 d0 mov %edx,%eax <== NOT EXECUTED
107a7d: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED
107a80: 29 d0 sub %edx,%eax <== NOT EXECUTED
107a82: 89 c2 mov %eax,%edx <== NOT EXECUTED
107a84: c1 e2 0c shl $0xc,%edx <== NOT EXECUTED
107a87: 01 d0 add %edx,%eax <== NOT EXECUTED
107a89: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED
107a8c: 8d 04 41 lea (%ecx,%eax,2),%eax <== NOT EXECUTED
107a8f: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED
107a92: 01 c8 add %ecx,%eax <== NOT EXECUTED
107a94: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED
107a97: 50 push %eax <== NOT EXECUTED
107a98: e8 f3 6a 00 00 call 10e590 <ftruncate> <== NOT EXECUTED
107a9d: 89 c7 mov %eax,%edi <== NOT EXECUTED
if ( rc ) {
107a9f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107aa2: 85 c0 test %eax,%eax <== NOT EXECUTED
107aa4: 0f 84 03 ff ff ff je 1079ad <open+0x12d> <== NOT EXECUTED
if(errno) rc = errno;
107aaa: e8 71 87 00 00 call 110220 <__errno> <== NOT EXECUTED
107aaf: 8b 10 mov (%eax),%edx <== NOT EXECUTED
107ab1: 85 d2 test %edx,%edx <== NOT EXECUTED
107ab3: 75 46 jne 107afb <open+0x27b> <== NOT EXECUTED
close( iop - rtems_libio_iops );
107ab5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107ab8: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED
107abb: 2b 0d d0 e4 11 00 sub 0x11e4d0,%ecx <== NOT EXECUTED
107ac1: c1 f9 02 sar $0x2,%ecx <== NOT EXECUTED
107ac4: 8d 14 89 lea (%ecx,%ecx,4),%edx <== NOT EXECUTED
107ac7: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED
107aca: 89 d0 mov %edx,%eax <== NOT EXECUTED
107acc: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED
107acf: 29 d0 sub %edx,%eax <== NOT EXECUTED
107ad1: 89 c2 mov %eax,%edx <== NOT EXECUTED
107ad3: c1 e2 0c shl $0xc,%edx <== NOT EXECUTED
107ad6: 01 d0 add %edx,%eax <== NOT EXECUTED
107ad8: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED
107adb: 8d 04 41 lea (%ecx,%eax,2),%eax <== NOT EXECUTED
107ade: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED
107ae1: 01 c8 add %ecx,%eax <== NOT EXECUTED
107ae3: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED
107ae6: 50 push %eax <== NOT EXECUTED
107ae7: e8 0c 6a 00 00 call 10e4f8 <close> <== NOT EXECUTED
107aec: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED
107af3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107af6: e9 18 ff ff ff jmp 107a13 <open+0x193> <== NOT EXECUTED
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
if ( rc ) {
if(errno) rc = errno;
107afb: e8 20 87 00 00 call 110220 <__errno> <== NOT EXECUTED
107b00: 8b 38 mov (%eax),%edi <== NOT EXECUTED
107b02: eb b1 jmp 107ab5 <open+0x235> <== NOT EXECUTED
00107820 <open_dev_console>:
/*
* This is a replaceable stub
*/
void open_dev_console(void)
{
107820: 55 push %ebp
107821: 89 e5 mov %esp,%ebp
107823: 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) {
107826: 6a 00 push $0x0
107828: 6a 00 push $0x0
10782a: 68 b0 70 11 00 push $0x1170b0
10782f: e8 4c 00 00 00 call 107880 <open>
107834: 83 c4 10 add $0x10,%esp
107837: 40 inc %eax
107838: 74 2a je 107864 <open_dev_console+0x44>
/*
* 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)
10783a: 52 push %edx
10783b: 6a 00 push $0x0
10783d: 6a 01 push $0x1
10783f: 68 b0 70 11 00 push $0x1170b0
107844: e8 37 00 00 00 call 107880 <open>
107849: 83 c4 10 add $0x10,%esp
10784c: 40 inc %eax
10784d: 74 24 je 107873 <open_dev_console+0x53> <== NEVER TAKEN
rtems_fatal_error_occurred( error_code | '1' );
if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1)
10784f: 50 push %eax
107850: 6a 00 push $0x0
107852: 6a 01 push $0x1
107854: 68 b0 70 11 00 push $0x1170b0
107859: e8 22 00 00 00 call 107880 <open>
10785e: 83 c4 10 add $0x10,%esp
107861: 40 inc %eax
107862: 74 02 je 107866 <open_dev_console+0x46> <== NEVER TAKEN
rtems_fatal_error_occurred( error_code | '2' );
}
107864: c9 leave
107865: c3 ret
*/
if ((stdout_fd = open("/dev/console", O_WRONLY, 0)) == -1)
rtems_fatal_error_occurred( error_code | '1' );
if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1)
rtems_fatal_error_occurred( error_code | '2' );
107866: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107869: 68 32 44 54 53 push $0x53544432 <== NOT EXECUTED
10786e: e8 11 32 00 00 call 10aa84 <rtems_fatal_error_occurred><== NOT EXECUTED
/*
* 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)
rtems_fatal_error_occurred( error_code | '1' );
107873: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107876: 68 31 44 54 53 push $0x53544431 <== NOT EXECUTED
10787b: e8 04 32 00 00 call 10aa84 <rtems_fatal_error_occurred><== NOT EXECUTED
001086c0 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
1086c0: 55 push %ebp
1086c1: 89 e5 mov %esp,%ebp
1086c3: 56 push %esi
1086c4: 53 push %ebx
1086c5: 83 ec 10 sub $0x10,%esp
1086c8: 89 d3 mov %edx,%ebx
1086ca: 88 45 f4 mov %al,-0xc(%ebp)
int i;
if (tty->termios.c_oflag & OPOST) {
1086cd: 8b 52 34 mov 0x34(%edx),%edx
1086d0: f6 c2 01 test $0x1,%dl
1086d3: 74 17 je 1086ec <oproc+0x2c> <== NEVER TAKEN
switch (c) {
1086d5: 3c 09 cmp $0x9,%al
1086d7: 74 53 je 10872c <oproc+0x6c>
1086d9: 77 29 ja 108704 <oproc+0x44> <== ALWAYS TAKEN
1086db: 3c 08 cmp $0x8,%al <== NOT EXECUTED
1086dd: 75 2d jne 10870c <oproc+0x4c> <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
1086df: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
1086e2: 85 c0 test %eax,%eax <== NOT EXECUTED
1086e4: 7e 06 jle 1086ec <oproc+0x2c> <== NOT EXECUTED
tty->column--;
1086e6: 48 dec %eax <== NOT EXECUTED
1086e7: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
1086ea: 66 90 xchg %ax,%ax <== NOT EXECUTED
if (!iscntrl(c))
tty->column++;
break;
}
}
rtems_termios_puts (&c, 1, tty);
1086ec: 56 push %esi
1086ed: 53 push %ebx
1086ee: 6a 01 push $0x1
1086f0: 8d 45 f4 lea -0xc(%ebp),%eax
1086f3: 50 push %eax
1086f4: e8 97 fe ff ff call 108590 <rtems_termios_puts>
1086f9: 83 c4 10 add $0x10,%esp
}
1086fc: 8d 65 f8 lea -0x8(%ebp),%esp
1086ff: 5b pop %ebx
108700: 5e pop %esi
108701: c9 leave
108702: c3 ret
108703: 90 nop
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
108704: 3c 0a cmp $0xa,%al
108706: 74 50 je 108758 <oproc+0x98>
108708: 3c 0d cmp $0xd,%al
10870a: 74 7c je 108788 <oproc+0xc8> <== NEVER TAKEN
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
10870c: 83 e2 02 and $0x2,%edx
10870f: 0f 85 a3 00 00 00 jne 1087b8 <oproc+0xf8> <== NEVER TAKEN
108715: 8b 15 14 c5 11 00 mov 0x11c514,%edx
c = toupper(c);
if (!iscntrl(c))
10871b: 0f b6 45 f4 movzbl -0xc(%ebp),%eax
10871f: f6 04 02 20 testb $0x20,(%edx,%eax,1)
108723: 75 c7 jne 1086ec <oproc+0x2c> <== NEVER TAKEN
tty->column++;
108725: ff 43 28 incl 0x28(%ebx)
108728: eb c2 jmp 1086ec <oproc+0x2c>
10872a: 66 90 xchg %ax,%ax
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
10872c: 8b 73 28 mov 0x28(%ebx),%esi
10872f: 89 f0 mov %esi,%eax
108731: 83 e0 07 and $0x7,%eax
108734: b9 08 00 00 00 mov $0x8,%ecx
108739: 29 c1 sub %eax,%ecx
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
10873b: 81 e2 00 18 00 00 and $0x1800,%edx
108741: 81 fa 00 18 00 00 cmp $0x1800,%edx
108747: 0f 84 87 00 00 00 je 1087d4 <oproc+0x114> <== ALWAYS TAKEN
tty->column += i;
rtems_termios_puts ( " ", i, tty);
return;
}
tty->column += i;
10874d: 8d 04 31 lea (%ecx,%esi,1),%eax <== NOT EXECUTED
108750: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
108753: eb 97 jmp 1086ec <oproc+0x2c> <== NOT EXECUTED
108755: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
case '\n':
if (tty->termios.c_oflag & ONLRET)
108758: f6 c2 20 test $0x20,%dl
10875b: 74 07 je 108764 <oproc+0xa4> <== ALWAYS TAKEN
tty->column = 0;
10875d: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLCR) {
108764: 83 e2 04 and $0x4,%edx
108767: 74 83 je 1086ec <oproc+0x2c> <== NEVER TAKEN
rtems_termios_puts ("\r", 1, tty);
108769: 50 push %eax
10876a: 53 push %ebx
10876b: 6a 01 push $0x1
10876d: 68 b8 85 11 00 push $0x1185b8
108772: e8 19 fe ff ff call 108590 <rtems_termios_puts>
tty->column = 0;
108777: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx)
10877e: 83 c4 10 add $0x10,%esp
108781: e9 66 ff ff ff jmp 1086ec <oproc+0x2c>
108786: 66 90 xchg %ax,%ax
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
108788: f6 c2 10 test $0x10,%dl <== NOT EXECUTED
10878b: 74 0b je 108798 <oproc+0xd8> <== NOT EXECUTED
10878d: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
108790: 85 c0 test %eax,%eax <== NOT EXECUTED
108792: 0f 84 64 ff ff ff je 1086fc <oproc+0x3c> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
108798: f6 c2 08 test $0x8,%dl <== NOT EXECUTED
10879b: 74 0d je 1087aa <oproc+0xea> <== NOT EXECUTED
c = '\n';
10879d: c6 45 f4 0a movb $0xa,-0xc(%ebp) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
1087a1: 83 e2 20 and $0x20,%edx <== NOT EXECUTED
1087a4: 0f 84 42 ff ff ff je 1086ec <oproc+0x2c> <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
1087aa: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED
1087b1: e9 36 ff ff ff jmp 1086ec <oproc+0x2c> <== NOT EXECUTED
1087b6: 66 90 xchg %ax,%ax <== NOT EXECUTED
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
c = toupper(c);
1087b8: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
1087bb: 8b 15 14 c5 11 00 mov 0x11c514,%edx <== NOT EXECUTED
1087c1: f6 04 02 02 testb $0x2,(%edx,%eax,1) <== NOT EXECUTED
1087c5: 74 03 je 1087ca <oproc+0x10a> <== NOT EXECUTED
1087c7: 83 e8 20 sub $0x20,%eax <== NOT EXECUTED
1087ca: 88 45 f4 mov %al,-0xc(%ebp) <== NOT EXECUTED
1087cd: e9 49 ff ff ff jmp 10871b <oproc+0x5b> <== NOT EXECUTED
1087d2: 66 90 xchg %ax,%ax <== NOT EXECUTED
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
1087d4: 8d 04 31 lea (%ecx,%esi,1),%eax
1087d7: 89 43 28 mov %eax,0x28(%ebx)
rtems_termios_puts ( " ", i, tty);
1087da: 50 push %eax
1087db: 53 push %ebx
1087dc: 51 push %ecx
1087dd: 68 ba 85 11 00 push $0x1185ba
1087e2: e8 a9 fd ff ff call 108590 <rtems_termios_puts>
1087e7: 83 c4 10 add $0x10,%esp
1087ea: e9 0d ff ff ff jmp 1086fc <oproc+0x3c>
00109080 <posix_memalign>:
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
109080: 55 push %ebp
109081: 89 e5 mov %esp,%ebp
109083: 53 push %ebx
109084: 8b 55 0c mov 0xc(%ebp),%edx
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
109087: ff 05 08 3c 12 00 incl 0x123c08
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
10908d: 8d 42 ff lea -0x1(%edx),%eax
109090: 85 d0 test %edx,%eax
109092: 75 05 jne 109099 <posix_memalign+0x19> <== NEVER TAKEN
109094: 83 fa 03 cmp $0x3,%edx
109097: 77 0b ja 1090a4 <posix_memalign+0x24>
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
}
109099: b8 16 00 00 00 mov $0x16,%eax
10909e: 5b pop %ebx
10909f: c9 leave
1090a0: c3 ret
1090a1: 8d 76 00 lea 0x0(%esi),%esi
1090a4: 5b pop %ebx
1090a5: c9 leave
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
1090a6: e9 35 04 00 00 jmp 1094e0 <rtems_memalign>
00116794 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
116794: 55 push %ebp <== NOT EXECUTED
116795: 89 e5 mov %esp,%ebp <== NOT EXECUTED
116797: 56 push %esi <== NOT EXECUTED
116798: 53 push %ebx <== NOT EXECUTED
116799: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
11679c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED
11679f: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
1167a2: 3b 15 40 a0 11 00 cmp 0x11a040,%edx <== NOT EXECUTED
1167a8: 73 56 jae 116800 <read+0x6c> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
1167aa: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED
1167ad: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED
1167b0: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED
1167b7: 03 1d d0 e4 11 00 add 0x11e4d0,%ebx <== NOT EXECUTED
rtems_libio_check_is_open( iop );
1167bd: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED
1167c0: f6 c4 01 test $0x1,%ah <== NOT EXECUTED
1167c3: 74 3b je 116800 <read+0x6c> <== NOT EXECUTED
rtems_libio_check_buffer( buffer );
1167c5: 85 f6 test %esi,%esi <== NOT EXECUTED
1167c7: 74 5b je 116824 <read+0x90> <== NOT EXECUTED
rtems_libio_check_count( count );
1167c9: 85 c9 test %ecx,%ecx <== NOT EXECUTED
1167cb: 74 27 je 1167f4 <read+0x60> <== NOT EXECUTED
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
1167cd: a8 02 test $0x2,%al <== NOT EXECUTED
1167cf: 74 2f je 116800 <read+0x6c> <== NOT EXECUTED
/*
* Now process the read().
*/
if ( !iop->handlers->read_h )
1167d1: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED
1167d4: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
1167d7: 85 c0 test %eax,%eax <== NOT EXECUTED
1167d9: 74 37 je 116812 <read+0x7e> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
rc = (*iop->handlers->read_h)( iop, buffer, count );
1167db: 52 push %edx <== NOT EXECUTED
1167dc: 51 push %ecx <== NOT EXECUTED
1167dd: 56 push %esi <== NOT EXECUTED
1167de: 53 push %ebx <== NOT EXECUTED
1167df: ff d0 call *%eax <== NOT EXECUTED
if ( rc > 0 )
1167e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1167e4: 85 c0 test %eax,%eax <== NOT EXECUTED
1167e6: 7e 03 jle 1167eb <read+0x57> <== NOT EXECUTED
iop->offset += rc;
1167e8: 01 43 08 add %eax,0x8(%ebx) <== NOT EXECUTED
return rc;
}
1167eb: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
1167ee: 5b pop %ebx <== NOT EXECUTED
1167ef: 5e pop %esi <== NOT EXECUTED
1167f0: c9 leave <== NOT EXECUTED
1167f1: c3 ret <== NOT EXECUTED
1167f2: 66 90 xchg %ax,%ax <== NOT EXECUTED
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
1167f4: 31 c0 xor %eax,%eax <== NOT EXECUTED
if ( rc > 0 )
iop->offset += rc;
return rc;
}
1167f6: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
1167f9: 5b pop %ebx <== NOT EXECUTED
1167fa: 5e pop %esi <== NOT EXECUTED
1167fb: c9 leave <== NOT EXECUTED
1167fc: c3 ret <== NOT EXECUTED
1167fd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
116800: e8 1b 9a ff ff call 110220 <__errno> <== NOT EXECUTED
116805: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
11680b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
116810: eb d9 jmp 1167eb <read+0x57> <== NOT EXECUTED
/*
* Now process the read().
*/
if ( !iop->handlers->read_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
116812: e8 09 9a ff ff call 110220 <__errno> <== NOT EXECUTED
116817: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
11681d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
116822: eb c7 jmp 1167eb <read+0x57> <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
116824: e8 f7 99 ff ff call 110220 <__errno> <== NOT EXECUTED
116829: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
11682f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
116834: eb b5 jmp 1167eb <read+0x57> <== NOT EXECUTED
001168b8 <realloc>:
{
size_t old_size;
char *new_area;
size_t resize;
MSBUMP(realloc_calls, 1);
1168b8: 55 push %ebp
1168b9: 89 e5 mov %esp,%ebp
1168bb: 57 push %edi
1168bc: 56 push %esi
1168bd: 53 push %ebx
1168be: 83 ec 1c sub $0x1c,%esp
1168c1: 8b 5d 08 mov 0x8(%ebp),%ebx
1168c4: 8b 75 0c mov 0xc(%ebp),%esi
1168c7: ff 05 70 e5 11 00 incl 0x11e570
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
1168cd: 83 3d 24 e8 11 00 03 cmpl $0x3,0x11e824
1168d4: 74 6e je 116944 <realloc+0x8c> <== ALWAYS TAKEN
}
/*
* Continue with realloc().
*/
if ( !ptr )
1168d6: 85 db test %ebx,%ebx
1168d8: 74 3a je 116914 <realloc+0x5c> <== NEVER TAKEN
return malloc( size );
if ( !size ) {
1168da: 85 f6 test %esi,%esi
1168dc: 74 46 je 116924 <realloc+0x6c> <== NEVER TAKEN
free( ptr );
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) {
1168de: 52 push %edx
1168df: 8d 45 f0 lea -0x10(%ebp),%eax
1168e2: 50 push %eax
1168e3: 53 push %ebx
1168e4: 68 00 e5 11 00 push $0x11e500
1168e9: e8 5a 01 00 00 call 116a48 <_Protected_heap_Get_block_size>
1168ee: 83 c4 10 add $0x10,%esp
1168f1: 84 c0 test %al,%al
1168f3: 74 3f je 116934 <realloc+0x7c>
#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 ) ) {
1168f5: 50 push %eax
1168f6: 56 push %esi
1168f7: 53 push %ebx
1168f8: 68 00 e5 11 00 push $0x11e500
1168fd: e8 7e 01 00 00 call 116a80 <_Protected_heap_Resize_block>
116902: 83 c4 10 add $0x10,%esp
116905: 84 c0 test %al,%al
116907: 74 5b je 116964 <realloc+0xac>
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
116909: 89 d8 mov %ebx,%eax
11690b: 8d 65 f4 lea -0xc(%ebp),%esp
11690e: 5b pop %ebx
11690f: 5e pop %esi
116910: 5f pop %edi
116911: c9 leave
116912: c3 ret
116913: 90 nop
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
116914: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
116917: 56 push %esi <== NOT EXECUTED
116918: e8 bb 09 ff ff call 1072d8 <malloc> <== NOT EXECUTED
11691d: 89 c3 mov %eax,%ebx <== NOT EXECUTED
11691f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
116922: eb e5 jmp 116909 <realloc+0x51> <== NOT EXECUTED
if ( !size ) {
free( ptr );
116924: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
116927: 53 push %ebx <== NOT EXECUTED
116928: e8 93 07 ff ff call 1070c0 <free> <== NOT EXECUTED
11692d: 31 db xor %ebx,%ebx <== NOT EXECUTED
11692f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
116932: eb d5 jmp 116909 <realloc+0x51> <== NOT EXECUTED
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
116934: e8 e7 98 ff ff call 110220 <__errno>
116939: c7 00 16 00 00 00 movl $0x16,(%eax)
11693f: 31 db xor %ebx,%ebx
116941: eb c6 jmp 116909 <realloc+0x51>
116943: 90 nop
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_disable_level > 0)
116944: a1 58 e6 11 00 mov 0x11e658,%eax
116949: 85 c0 test %eax,%eax
11694b: 74 04 je 116951 <realloc+0x99> <== ALWAYS TAKEN
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
11694d: 31 db xor %ebx,%ebx
11694f: eb b8 jmp 116909 <realloc+0x51> <== NOT EXECUTED
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_disable_level > 0)
return (void *) 0;
if (_ISR_Nest_level > 0)
116951: a1 f8 e6 11 00 mov 0x11e6f8,%eax
116956: 85 c0 test %eax,%eax
116958: 0f 84 78 ff ff ff je 1168d6 <realloc+0x1e> <== ALWAYS TAKEN
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
11695e: 31 db xor %ebx,%ebx
116960: eb a7 jmp 116909 <realloc+0x51> <== NOT EXECUTED
116962: 66 90 xchg %ax,%ax <== NOT EXECUTED
* There used to be a free on this error case but it is wrong to
* free the memory per OpenGroup Single UNIX Specification V2
* and the C Standard.
*/
new_area = malloc( size );
116964: 83 ec 0c sub $0xc,%esp
116967: 56 push %esi
116968: e8 6b 09 ff ff call 1072d8 <malloc>
11696d: 89 45 dc mov %eax,-0x24(%ebp)
MSBUMP(malloc_calls, -1); /* subtract off the malloc */
116970: ff 0d 64 e5 11 00 decl 0x11e564
if ( !new_area ) {
116976: 83 c4 10 add $0x10,%esp
116979: 85 c0 test %eax,%eax
11697b: 74 d0 je 11694d <realloc+0x95> <== NEVER TAKEN
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
11697d: 8b 45 f0 mov -0x10(%ebp),%eax
116980: 89 f1 mov %esi,%ecx
116982: 39 c6 cmp %eax,%esi
116984: 76 02 jbe 116988 <realloc+0xd0> <== NEVER TAKEN
116986: 89 c1 mov %eax,%ecx
116988: 8b 7d dc mov -0x24(%ebp),%edi
11698b: 89 de mov %ebx,%esi
11698d: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
free( ptr );
11698f: 83 ec 0c sub $0xc,%esp
116992: 53 push %ebx
116993: e8 28 07 ff ff call 1070c0 <free>
116998: 8b 5d dc mov -0x24(%ebp),%ebx
11699b: 83 c4 10 add $0x10,%esp
11699e: e9 66 ff ff ff jmp 116909 <realloc+0x51>
0010fca8 <rtems_assoc_local_by_remote>:
uint32_t rtems_assoc_local_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
10fca8: 55 push %ebp
10fca9: 89 e5 mov %esp,%ebp
10fcab: 83 ec 10 sub $0x10,%esp
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
10fcae: ff 75 0c pushl 0xc(%ebp)
10fcb1: ff 75 08 pushl 0x8(%ebp)
10fcb4: e8 0f 00 00 00 call 10fcc8 <rtems_assoc_ptr_by_remote>
if (nap)
10fcb9: 83 c4 10 add $0x10,%esp
10fcbc: 85 c0 test %eax,%eax
10fcbe: 74 03 je 10fcc3 <rtems_assoc_local_by_remote+0x1b><== NEVER TAKEN
return nap->local_value;
10fcc0: 8b 40 04 mov 0x4(%eax),%eax
return 0;
}
10fcc3: c9 leave
10fcc4: c3 ret
0010fc64 <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
10fc64: 55 push %ebp
10fc65: 89 e5 mov %esp,%ebp
10fc67: 57 push %edi
10fc68: 56 push %esi
10fc69: 53 push %ebx
10fc6a: 83 ec 0c sub $0xc,%esp
10fc6d: be 01 00 00 00 mov $0x1,%esi
10fc72: 31 ff xor %edi,%edi
10fc74: 31 db xor %ebx,%ebx
10fc76: eb 08 jmp 10fc80 <rtems_assoc_local_by_remote_bitfield+0x1c>
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
10fc78: d1 e6 shl %esi
10fc7a: 43 inc %ebx
10fc7b: 83 fb 20 cmp $0x20,%ebx
10fc7e: 74 1e je 10fc9e <rtems_assoc_local_by_remote_bitfield+0x3a>
if (b & remote_value)
10fc80: 85 75 0c test %esi,0xc(%ebp)
10fc83: 74 f3 je 10fc78 <rtems_assoc_local_by_remote_bitfield+0x14><== ALWAYS TAKEN
local_value |= rtems_assoc_local_by_remote(ap, b);
10fc85: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10fc88: 56 push %esi <== NOT EXECUTED
10fc89: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
10fc8c: e8 17 00 00 00 call 10fca8 <rtems_assoc_local_by_remote><== NOT EXECUTED
10fc91: 09 c7 or %eax,%edi <== NOT EXECUTED
10fc93: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
)
{
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
10fc96: d1 e6 shl %esi <== NOT EXECUTED
10fc98: 43 inc %ebx <== NOT EXECUTED
10fc99: 83 fb 20 cmp $0x20,%ebx <== NOT EXECUTED
10fc9c: 75 e2 jne 10fc80 <rtems_assoc_local_by_remote_bitfield+0x1c><== NOT EXECUTED
if (b & remote_value)
local_value |= rtems_assoc_local_by_remote(ap, b);
}
return local_value;
}
10fc9e: 89 f8 mov %edi,%eax
10fca0: 8d 65 f4 lea -0xc(%ebp),%esp
10fca3: 5b pop %ebx
10fca4: 5e pop %esi
10fca5: 5f pop %edi
10fca6: c9 leave
10fca7: c3 ret
001114e0 <rtems_assoc_name_bad>:
const char *
rtems_assoc_name_bad(
uint32_t bad_value
)
{
1114e0: 55 push %ebp <== NOT EXECUTED
1114e1: 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;
}
1114e3: b8 a0 07 12 00 mov $0x1207a0,%eax <== NOT EXECUTED
1114e8: c9 leave <== NOT EXECUTED
1114e9: c3 ret <== NOT EXECUTED
0010fbf8 <rtems_assoc_name_by_local>:
const char *rtems_assoc_name_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
10fbf8: 55 push %ebp <== NOT EXECUTED
10fbf9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10fbfb: 53 push %ebx <== NOT EXECUTED
10fbfc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10fbff: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
10fc02: 53 push %ebx <== NOT EXECUTED
10fc03: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
10fc06: e8 1d 00 00 00 call 10fc28 <rtems_assoc_ptr_by_local><== NOT EXECUTED
if (nap)
10fc0b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10fc0e: 85 c0 test %eax,%eax <== NOT EXECUTED
10fc10: 74 0a je 10fc1c <rtems_assoc_name_by_local+0x24><== NOT EXECUTED
return nap->name;
10fc12: 8b 00 mov (%eax),%eax <== NOT EXECUTED
return rtems_assoc_name_bad(local_value);
}
10fc14: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10fc17: c9 leave <== NOT EXECUTED
10fc18: c3 ret <== NOT EXECUTED
10fc19: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
nap = rtems_assoc_ptr_by_local(ap, local_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(local_value);
10fc1c: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED
}
10fc1f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10fc22: 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);
10fc23: e9 b8 18 00 00 jmp 1114e0 <rtems_assoc_name_bad> <== NOT EXECUTED
001101a0 <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
1101a0: 55 push %ebp
1101a1: 89 e5 mov %esp,%ebp
1101a3: 57 push %edi
1101a4: 56 push %esi
1101a5: 53 push %ebx
1101a6: 83 ec 04 sub $0x4,%esp
1101a9: 8b 5d 08 mov 0x8(%ebp),%ebx
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
1101ac: 8b 33 mov (%ebx),%esi
1101ae: 85 f6 test %esi,%esi
1101b0: 74 4a je 1101fc <rtems_assoc_ptr_by_local+0x5c><== NEVER TAKEN
1101b2: bf 2d 8d 11 00 mov $0x118d2d,%edi
1101b7: b9 0a 00 00 00 mov $0xa,%ecx
1101bc: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
1101be: 74 20 je 1101e0 <rtems_assoc_ptr_by_local+0x40><== NEVER TAKEN
1101c0: 31 d2 xor %edx,%edx
1101c2: eb 09 jmp 1101cd <rtems_assoc_ptr_by_local+0x2d>
default_ap = ap++;
for ( ; ap->name; ap++)
1101c4: 83 c3 0c add $0xc,%ebx
1101c7: 8b 0b mov (%ebx),%ecx
1101c9: 85 c9 test %ecx,%ecx
1101cb: 74 23 je 1101f0 <rtems_assoc_ptr_by_local+0x50>
if (ap->local_value == local_value)
1101cd: 8b 45 0c mov 0xc(%ebp),%eax
1101d0: 39 43 04 cmp %eax,0x4(%ebx)
1101d3: 75 ef jne 1101c4 <rtems_assoc_ptr_by_local+0x24>
return ap;
return default_ap;
}
1101d5: 89 d8 mov %ebx,%eax
1101d7: 5a pop %edx
1101d8: 5b pop %ebx
1101d9: 5e pop %esi
1101da: 5f pop %edi
1101db: c9 leave
1101dc: c3 ret
1101dd: 8d 76 00 lea 0x0(%esi),%esi
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
1101e0: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED
for ( ; ap->name; ap++)
1101e3: 8b 73 0c mov 0xc(%ebx),%esi <== NOT EXECUTED
1101e6: 85 f6 test %esi,%esi <== NOT EXECUTED
1101e8: 74 eb je 1101d5 <rtems_assoc_ptr_by_local+0x35><== NOT EXECUTED
1101ea: 89 da mov %ebx,%edx <== NOT EXECUTED
1101ec: 89 c3 mov %eax,%ebx <== NOT EXECUTED
1101ee: eb dd jmp 1101cd <rtems_assoc_ptr_by_local+0x2d><== NOT EXECUTED
1101f0: 89 d3 mov %edx,%ebx
if (ap->local_value == local_value)
return ap;
return default_ap;
}
1101f2: 89 d8 mov %ebx,%eax
1101f4: 5a pop %edx
1101f5: 5b pop %ebx
1101f6: 5e pop %esi
1101f7: 5f pop %edi
1101f8: c9 leave
1101f9: c3 ret
1101fa: 66 90 xchg %ax,%ax
uint32_t local_value
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
1101fc: 31 db xor %ebx,%ebx
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
return ap;
return default_ap;
}
1101fe: 89 d8 mov %ebx,%eax <== NOT EXECUTED
110200: 5a pop %edx <== NOT EXECUTED
110201: 5b pop %ebx <== NOT EXECUTED
110202: 5e pop %esi <== NOT EXECUTED
110203: 5f pop %edi <== NOT EXECUTED
110204: c9 leave <== NOT EXECUTED
110205: c3 ret <== NOT EXECUTED
0010fcc8 <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
10fcc8: 55 push %ebp
10fcc9: 89 e5 mov %esp,%ebp
10fccb: 57 push %edi
10fccc: 56 push %esi
10fccd: 53 push %ebx
10fcce: 83 ec 04 sub $0x4,%esp
10fcd1: 8b 5d 08 mov 0x8(%ebp),%ebx
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
10fcd4: 8b 33 mov (%ebx),%esi
10fcd6: 85 f6 test %esi,%esi
10fcd8: 74 4a je 10fd24 <rtems_assoc_ptr_by_remote+0x5c><== NEVER TAKEN
10fcda: bf 2d 8d 11 00 mov $0x118d2d,%edi
10fcdf: b9 0a 00 00 00 mov $0xa,%ecx
10fce4: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
10fce6: 74 20 je 10fd08 <rtems_assoc_ptr_by_remote+0x40><== NEVER TAKEN
10fce8: 31 d2 xor %edx,%edx
10fcea: eb 09 jmp 10fcf5 <rtems_assoc_ptr_by_remote+0x2d>
default_ap = ap++;
for ( ; ap->name; ap++)
10fcec: 83 c3 0c add $0xc,%ebx
10fcef: 8b 0b mov (%ebx),%ecx
10fcf1: 85 c9 test %ecx,%ecx
10fcf3: 74 23 je 10fd18 <rtems_assoc_ptr_by_remote+0x50><== NEVER TAKEN
if (ap->remote_value == remote_value)
10fcf5: 8b 45 0c mov 0xc(%ebp),%eax
10fcf8: 39 43 08 cmp %eax,0x8(%ebx)
10fcfb: 75 ef jne 10fcec <rtems_assoc_ptr_by_remote+0x24>
return ap;
return default_ap;
}
10fcfd: 89 d8 mov %ebx,%eax
10fcff: 5a pop %edx
10fd00: 5b pop %ebx
10fd01: 5e pop %esi
10fd02: 5f pop %edi
10fd03: c9 leave
10fd04: c3 ret
10fd05: 8d 76 00 lea 0x0(%esi),%esi
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
10fd08: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED
for ( ; ap->name; ap++)
10fd0b: 8b 73 0c mov 0xc(%ebx),%esi <== NOT EXECUTED
10fd0e: 85 f6 test %esi,%esi <== NOT EXECUTED
10fd10: 74 eb je 10fcfd <rtems_assoc_ptr_by_remote+0x35><== NOT EXECUTED
10fd12: 89 da mov %ebx,%edx <== NOT EXECUTED
10fd14: 89 c3 mov %eax,%ebx <== NOT EXECUTED
10fd16: eb dd jmp 10fcf5 <rtems_assoc_ptr_by_remote+0x2d><== NOT EXECUTED
10fd18: 89 d3 mov %edx,%ebx <== NOT EXECUTED
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
10fd1a: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10fd1c: 5a pop %edx <== NOT EXECUTED
10fd1d: 5b pop %ebx <== NOT EXECUTED
10fd1e: 5e pop %esi <== NOT EXECUTED
10fd1f: 5f pop %edi <== NOT EXECUTED
10fd20: c9 leave <== NOT EXECUTED
10fd21: c3 ret <== NOT EXECUTED
10fd22: 66 90 xchg %ax,%ax <== NOT EXECUTED
uint32_t remote_value
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
10fd24: 31 db xor %ebx,%ebx <== NOT EXECUTED
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
10fd26: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10fd28: 5a pop %edx <== NOT EXECUTED
10fd29: 5b pop %ebx <== NOT EXECUTED
10fd2a: 5e pop %esi <== NOT EXECUTED
10fd2b: 5f pop %edi <== NOT EXECUTED
10fd2c: c9 leave <== NOT EXECUTED
10fd2d: c3 ret <== NOT EXECUTED
0010fd30 <rtems_assoc_remote_by_local>:
uint32_t rtems_assoc_remote_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
10fd30: 55 push %ebp <== NOT EXECUTED
10fd31: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10fd33: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
10fd36: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
10fd39: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
10fd3c: e8 5f 04 00 00 call 1101a0 <rtems_assoc_ptr_by_local><== NOT EXECUTED
if (nap)
10fd41: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10fd44: 85 c0 test %eax,%eax <== NOT EXECUTED
10fd46: 74 03 je 10fd4b <rtems_assoc_remote_by_local+0x1b><== NOT EXECUTED
return nap->remote_value;
10fd48: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
return 0;
}
10fd4b: c9 leave <== NOT EXECUTED
10fd4c: c3 ret <== NOT EXECUTED
0010a78c <rtems_barrier_create>:
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
10a78c: 55 push %ebp
10a78d: 89 e5 mov %esp,%ebp
10a78f: 56 push %esi
10a790: 53 push %ebx
10a791: 83 ec 10 sub $0x10,%esp
10a794: 8b 75 08 mov 0x8(%ebp),%esi
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
10a797: 85 f6 test %esi,%esi
10a799: 0f 84 8d 00 00 00 je 10a82c <rtems_barrier_create+0xa0><== NEVER TAKEN
return RTEMS_INVALID_NAME;
if ( !id )
10a79f: 8b 55 14 mov 0x14(%ebp),%edx
10a7a2: 85 d2 test %edx,%edx
10a7a4: 0f 84 ba 00 00 00 je 10a864 <rtems_barrier_create+0xd8><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
10a7aa: f6 45 0c 10 testb $0x10,0xc(%ebp)
10a7ae: 0f 84 84 00 00 00 je 10a838 <rtems_barrier_create+0xac>
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
if ( maximum_waiters == 0 )
10a7b4: 8b 45 10 mov 0x10(%ebp),%eax
10a7b7: 85 c0 test %eax,%eax
10a7b9: 0f 84 85 00 00 00 je 10a844 <rtems_barrier_create+0xb8>
if ( !id )
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
10a7bf: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
the_attributes.maximum_count = maximum_waiters;
10a7c6: 8b 45 10 mov 0x10(%ebp),%eax
10a7c9: 89 45 f4 mov %eax,-0xc(%ebp)
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10a7cc: a1 f8 16 12 00 mov 0x1216f8,%eax
10a7d1: 40 inc %eax
10a7d2: a3 f8 16 12 00 mov %eax,0x1216f8
#ifdef __cplusplus
extern "C" {
#endif
/**
10a7d7: 83 ec 0c sub $0xc,%esp
10a7da: 68 00 16 12 00 push $0x121600
10a7df: e8 50 1d 00 00 call 10c534 <_Objects_Allocate>
10a7e4: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
10a7e6: 83 c4 10 add $0x10,%esp
10a7e9: 85 c0 test %eax,%eax
10a7eb: 74 63 je 10a850 <rtems_barrier_create+0xc4>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
10a7ed: 8b 45 0c mov 0xc(%ebp),%eax
10a7f0: 89 43 10 mov %eax,0x10(%ebx)
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
10a7f3: 83 ec 08 sub $0x8,%esp
10a7f6: 8d 45 f0 lea -0x10(%ebp),%eax
10a7f9: 50 push %eax
10a7fa: 8d 43 14 lea 0x14(%ebx),%eax
10a7fd: 50 push %eax
10a7fe: e8 5d 14 00 00 call 10bc60 <_CORE_barrier_Initialize>
10a803: 8b 4b 08 mov 0x8(%ebx),%ecx
10a806: 0f b7 d1 movzwl %cx,%edx
10a809: a1 1c 16 12 00 mov 0x12161c,%eax
10a80e: 89 1c 90 mov %ebx,(%eax,%edx,4)
10a811: 89 73 0c mov %esi,0xc(%ebx)
&_Barrier_Information,
&the_barrier->Object,
(Objects_Name) name
);
*id = the_barrier->Object.id;
10a814: 8b 45 14 mov 0x14(%ebp),%eax
10a817: 89 08 mov %ecx,(%eax)
_Thread_Enable_dispatch();
10a819: e8 4e 2a 00 00 call 10d26c <_Thread_Enable_dispatch>
10a81e: 31 c0 xor %eax,%eax
10a820: 83 c4 10 add $0x10,%esp
return RTEMS_SUCCESSFUL;
}
10a823: 8d 65 f8 lea -0x8(%ebp),%esp
10a826: 5b pop %ebx
10a827: 5e pop %esi
10a828: c9 leave
10a829: c3 ret
10a82a: 66 90 xchg %ax,%ax
)
{
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
10a82c: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10a831: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10a834: 5b pop %ebx <== NOT EXECUTED
10a835: 5e pop %esi <== NOT EXECUTED
10a836: c9 leave <== NOT EXECUTED
10a837: c3 ret <== NOT EXECUTED
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
10a838: c7 45 f0 01 00 00 00 movl $0x1,-0x10(%ebp)
10a83f: eb 85 jmp 10a7c6 <rtems_barrier_create+0x3a>
10a841: 8d 76 00 lea 0x0(%esi),%esi
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
if ( maximum_waiters == 0 )
10a844: b8 0a 00 00 00 mov $0xa,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10a849: 8d 65 f8 lea -0x8(%ebp),%esp
10a84c: 5b pop %ebx
10a84d: 5e pop %esi
10a84e: c9 leave
10a84f: c3 ret
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
10a850: e8 17 2a 00 00 call 10d26c <_Thread_Enable_dispatch>
10a855: b8 05 00 00 00 mov $0x5,%eax
*id = the_barrier->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10a85a: 8d 65 f8 lea -0x8(%ebp),%esp
10a85d: 5b pop %ebx
10a85e: 5e pop %esi
10a85f: c9 leave
10a860: c3 ret
10a861: 8d 76 00 lea 0x0(%esi),%esi
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
10a864: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
10a869: eb b8 jmp 10a823 <rtems_barrier_create+0x97><== NOT EXECUTED
0010a8f8 <rtems_barrier_release>:
rtems_status_code rtems_barrier_release(
rtems_id id,
uint32_t *released
)
{
10a8f8: 55 push %ebp
10a8f9: 89 e5 mov %esp,%ebp
10a8fb: 56 push %esi
10a8fc: 53 push %ebx
10a8fd: 83 ec 10 sub $0x10,%esp
10a900: 8b 5d 08 mov 0x8(%ebp),%ebx
10a903: 8b 75 0c mov 0xc(%ebp),%esi
Barrier_Control *the_barrier;
Objects_Locations location;
if ( !released )
10a906: 85 f6 test %esi,%esi
10a908: 74 46 je 10a950 <rtems_barrier_release+0x58><== 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
10a90a: 50 push %eax
10a90b: 8d 45 f4 lea -0xc(%ebp),%eax
10a90e: 50 push %eax
10a90f: 53 push %ebx
10a910: 68 00 16 12 00 push $0x121600
10a915: e8 0e 21 00 00 call 10ca28 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_barrier = _Barrier_Get( id, &location );
switch ( location ) {
10a91a: 83 c4 10 add $0x10,%esp
10a91d: 8b 4d f4 mov -0xc(%ebp),%ecx
10a920: 85 c9 test %ecx,%ecx
10a922: 74 0c je 10a930 <rtems_barrier_release+0x38>
10a924: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a929: 8d 65 f8 lea -0x8(%ebp),%esp
10a92c: 5b pop %ebx
10a92d: 5e pop %esi
10a92e: c9 leave
10a92f: c3 ret
the_barrier = _Barrier_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
*released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL );
10a930: 52 push %edx
10a931: 6a 00 push $0x0
10a933: 53 push %ebx
10a934: 83 c0 14 add $0x14,%eax
10a937: 50 push %eax
10a938: e8 57 13 00 00 call 10bc94 <_CORE_barrier_Release>
10a93d: 89 06 mov %eax,(%esi)
_Thread_Enable_dispatch();
10a93f: e8 28 29 00 00 call 10d26c <_Thread_Enable_dispatch>
10a944: 31 c0 xor %eax,%eax
10a946: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a949: 8d 65 f8 lea -0x8(%ebp),%esp
10a94c: 5b pop %ebx
10a94d: 5e pop %esi
10a94e: c9 leave
10a94f: c3 ret
)
{
Barrier_Control *the_barrier;
Objects_Locations location;
if ( !released )
10a950: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a955: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10a958: 5b pop %ebx <== NOT EXECUTED
10a959: 5e pop %esi <== NOT EXECUTED
10a95a: c9 leave <== NOT EXECUTED
10a95b: c3 ret <== NOT EXECUTED
00109b10 <rtems_clock_get>:
rtems_status_code rtems_clock_get(
rtems_clock_get_options option,
void *time_buffer
)
{
109b10: 55 push %ebp
109b11: 89 e5 mov %esp,%ebp
109b13: 53 push %ebx
109b14: 83 ec 04 sub $0x4,%esp
109b17: 8b 45 08 mov 0x8(%ebp),%eax
109b1a: 8b 5d 0c mov 0xc(%ebp),%ebx
if ( !time_buffer )
109b1d: 85 db test %ebx,%ebx
109b1f: 74 5b je 109b7c <rtems_clock_get+0x6c> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
switch ( option ) {
109b21: 83 f8 04 cmp $0x4,%eax
109b24: 76 0a jbe 109b30 <rtems_clock_get+0x20>
109b26: b8 0a 00 00 00 mov $0xa,%eax
break;
}
return RTEMS_INVALID_NUMBER;
}
109b2b: 5a pop %edx
109b2c: 5b pop %ebx
109b2d: c9 leave
109b2e: c3 ret
109b2f: 90 nop
)
{
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
switch ( option ) {
109b30: ff 24 85 c8 85 11 00 jmp *0x1185c8(,%eax,4)
109b37: 90 nop
*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 );
109b38: 89 5d 08 mov %ebx,0x8(%ebp)
break;
}
return RTEMS_INVALID_NUMBER;
}
109b3b: 59 pop %ecx
109b3c: 5b pop %ebx
109b3d: 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 );
109b3e: e9 3d 01 00 00 jmp 109c80 <rtems_clock_get_tod_timeval>
109b43: 90 nop
return RTEMS_SUCCESSFUL;
}
case RTEMS_CLOCK_GET_TICKS_PER_SECOND: {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_per_second();
109b44: e8 6b 00 00 00 call 109bb4 <rtems_clock_get_ticks_per_second>
109b49: 89 03 mov %eax,(%ebx)
109b4b: 31 c0 xor %eax,%eax
break;
}
return RTEMS_INVALID_NUMBER;
}
109b4d: 5a pop %edx
109b4e: 5b pop %ebx
109b4f: c9 leave
109b50: c3 ret
109b51: 8d 76 00 lea 0x0(%esi),%esi
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_since_boot();
109b54: e8 6f 00 00 00 call 109bc8 <rtems_clock_get_ticks_since_boot>
109b59: 89 03 mov %eax,(%ebx)
109b5b: 31 c0 xor %eax,%eax
break;
}
return RTEMS_INVALID_NUMBER;
}
109b5d: 5a pop %edx
109b5e: 5b pop %ebx
109b5f: c9 leave
109b60: c3 ret
109b61: 8d 76 00 lea 0x0(%esi),%esi
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);
109b64: 89 5d 08 mov %ebx,0x8(%ebp)
break;
}
return RTEMS_INVALID_NUMBER;
}
109b67: 5b pop %ebx
109b68: 5b pop %ebx
109b69: 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);
109b6a: e9 15 00 00 00 jmp 109b84 <rtems_clock_get_seconds_since_epoch>
109b6f: 90 nop
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 );
109b70: 89 5d 08 mov %ebx,0x8(%ebp)
break;
}
return RTEMS_INVALID_NUMBER;
}
109b73: 58 pop %eax
109b74: 5b pop %ebx
109b75: 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 );
109b76: e9 59 00 00 00 jmp 109bd4 <rtems_clock_get_tod>
109b7b: 90 nop
rtems_status_code rtems_clock_get(
rtems_clock_get_options option,
void *time_buffer
)
{
if ( !time_buffer )
109b7c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
109b81: eb a8 jmp 109b2b <rtems_clock_get+0x1b> <== NOT EXECUTED
00109b84 <rtems_clock_get_seconds_since_epoch>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
109b84: 55 push %ebp
109b85: 89 e5 mov %esp,%ebp
109b87: 8b 55 08 mov 0x8(%ebp),%edx
if ( !the_interval )
109b8a: 85 d2 test %edx,%edx
109b8c: 74 1e je 109bac <rtems_clock_get_seconds_since_epoch+0x28><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
109b8e: 80 3d 6c e6 11 00 00 cmpb $0x0,0x11e66c
109b95: 74 0d je 109ba4 <rtems_clock_get_seconds_since_epoch+0x20>
return RTEMS_NOT_DEFINED;
*the_interval = _TOD_Seconds_since_epoch;
109b97: a1 ec e6 11 00 mov 0x11e6ec,%eax
109b9c: 89 02 mov %eax,(%edx)
109b9e: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
109ba0: c9 leave
109ba1: c3 ret
109ba2: 66 90 xchg %ax,%ax
)
{
if ( !the_interval )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
109ba4: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_NOT_DEFINED;
*the_interval = _TOD_Seconds_since_epoch;
return RTEMS_SUCCESSFUL;
}
109ba9: c9 leave
109baa: c3 ret
109bab: 90 nop
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
if ( !the_interval )
109bac: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
*the_interval = _TOD_Seconds_since_epoch;
return RTEMS_SUCCESSFUL;
}
109bb1: c9 leave <== NOT EXECUTED
109bb2: c3 ret <== NOT EXECUTED
00109bd4 <rtems_clock_get_tod>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod(
rtems_time_of_day *time_buffer
)
{
109bd4: 55 push %ebp
109bd5: 89 e5 mov %esp,%ebp
109bd7: 56 push %esi
109bd8: 53 push %ebx
109bd9: 83 ec 40 sub $0x40,%esp
109bdc: 8b 75 08 mov 0x8(%ebp),%esi
rtems_time_of_day *tmbuf = time_buffer;
struct tm time;
struct timeval now;
if ( !time_buffer )
109bdf: 85 f6 test %esi,%esi
109be1: 0f 84 8d 00 00 00 je 109c74 <rtems_clock_get_tod+0xa0><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
109be7: 80 3d 6c e6 11 00 00 cmpb $0x0,0x11e66c
109bee: 75 0c jne 109bfc <rtems_clock_get_tod+0x28>
109bf0: b8 0b 00 00 00 mov $0xb,%eax
tmbuf->minute = time.tm_min;
tmbuf->second = time.tm_sec;
tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick;
return RTEMS_SUCCESSFUL;
}
109bf5: 8d 65 f8 lea -0x8(%ebp),%esp
109bf8: 5b pop %ebx
109bf9: 5e pop %esi
109bfa: c9 leave
109bfb: c3 ret
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
109bfc: 9c pushf
109bfd: fa cli
109bfe: 5b pop %ebx
* This routine grows @a the_heap memory area using the size bytes which
109bff: 83 ec 0c sub $0xc,%esp
109c02: 8d 45 e8 lea -0x18(%ebp),%eax
109c05: 50 push %eax
109c06: e8 31 16 00 00 call 10b23c <_TOD_Get>
* begin at @a starting_address.
109c0b: 53 push %ebx
109c0c: 9d popf
*
* @param[in] the_heap is the heap to operate upon
109c0d: 8b 45 e8 mov -0x18(%ebp),%eax
109c10: 89 45 f0 mov %eax,-0x10(%ebp)
* @param[in] starting_address is the starting address of the memory
109c13: b8 d3 4d 62 10 mov $0x10624dd3,%eax
109c18: f7 65 ec mull -0x14(%ebp)
109c1b: c1 ea 06 shr $0x6,%edx
109c1e: 89 55 f4 mov %edx,-0xc(%ebp)
/* Obtain the current time */
_TOD_Get_timeval( &now );
/* Split it into a closer format */
gmtime_r( &now.tv_sec, &time );
109c21: 58 pop %eax
109c22: 5a pop %edx
109c23: 8d 45 c4 lea -0x3c(%ebp),%eax
109c26: 50 push %eax
109c27: 8d 45 f0 lea -0x10(%ebp),%eax
109c2a: 50 push %eax
109c2b: e8 38 6d 00 00 call 110968 <gmtime_r>
/* Now adjust it to the RTEMS format */
tmbuf->year = time.tm_year + 1900;
109c30: 8b 45 d8 mov -0x28(%ebp),%eax
109c33: 05 6c 07 00 00 add $0x76c,%eax
109c38: 89 06 mov %eax,(%esi)
tmbuf->month = time.tm_mon + 1;
109c3a: 8b 45 d4 mov -0x2c(%ebp),%eax
109c3d: 40 inc %eax
109c3e: 89 46 04 mov %eax,0x4(%esi)
tmbuf->day = time.tm_mday;
109c41: 8b 45 d0 mov -0x30(%ebp),%eax
109c44: 89 46 08 mov %eax,0x8(%esi)
tmbuf->hour = time.tm_hour;
109c47: 8b 45 cc mov -0x34(%ebp),%eax
109c4a: 89 46 0c mov %eax,0xc(%esi)
tmbuf->minute = time.tm_min;
109c4d: 8b 45 c8 mov -0x38(%ebp),%eax
109c50: 89 46 10 mov %eax,0x10(%esi)
tmbuf->second = time.tm_sec;
109c53: 8b 45 c4 mov -0x3c(%ebp),%eax
109c56: 89 46 14 mov %eax,0x14(%esi)
tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick;
109c59: 8b 45 f4 mov -0xc(%ebp),%eax
109c5c: 31 d2 xor %edx,%edx
109c5e: f7 35 20 e8 11 00 divl 0x11e820
109c64: 89 46 18 mov %eax,0x18(%esi)
109c67: 31 c0 xor %eax,%eax
109c69: 83 c4 10 add $0x10,%esp
return RTEMS_SUCCESSFUL;
}
109c6c: 8d 65 f8 lea -0x8(%ebp),%esp
109c6f: 5b pop %ebx
109c70: 5e pop %esi
109c71: c9 leave
109c72: c3 ret
109c73: 90 nop
{
rtems_time_of_day *tmbuf = time_buffer;
struct tm time;
struct timeval now;
if ( !time_buffer )
109c74: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
109c79: e9 77 ff ff ff jmp 109bf5 <rtems_clock_get_tod+0x21><== NOT EXECUTED
00109c80 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
109c80: 55 push %ebp
109c81: 89 e5 mov %esp,%ebp
109c83: 56 push %esi
109c84: 53 push %ebx
109c85: 83 ec 10 sub $0x10,%esp
109c88: 8b 75 08 mov 0x8(%ebp),%esi
if ( !time )
109c8b: 85 f6 test %esi,%esi
109c8d: 74 45 je 109cd4 <rtems_clock_get_tod_timeval+0x54><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
109c8f: 80 3d 6c e6 11 00 00 cmpb $0x0,0x11e66c
109c96: 75 0c jne 109ca4 <rtems_clock_get_tod_timeval+0x24>
109c98: b8 0b 00 00 00 mov $0xb,%eax
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
}
109c9d: 8d 65 f8 lea -0x8(%ebp),%esp
109ca0: 5b pop %ebx
109ca1: 5e pop %esi
109ca2: c9 leave
109ca3: c3 ret
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
109ca4: 9c pushf
109ca5: fa cli
109ca6: 5b pop %ebx
* This routine grows @a the_heap memory area using the size bytes which
109ca7: 83 ec 0c sub $0xc,%esp
109caa: 8d 45 f0 lea -0x10(%ebp),%eax
109cad: 50 push %eax
109cae: e8 89 15 00 00 call 10b23c <_TOD_Get>
* begin at @a starting_address.
109cb3: 53 push %ebx
109cb4: 9d popf
*
* @param[in] the_heap is the heap to operate upon
109cb5: 8b 45 f0 mov -0x10(%ebp),%eax
109cb8: 89 06 mov %eax,(%esi)
* @param[in] starting_address is the starting address of the memory
109cba: b8 d3 4d 62 10 mov $0x10624dd3,%eax
109cbf: f7 65 f4 mull -0xc(%ebp)
109cc2: c1 ea 06 shr $0x6,%edx
109cc5: 89 56 04 mov %edx,0x4(%esi)
109cc8: 31 c0 xor %eax,%eax
109cca: 83 c4 10 add $0x10,%esp
109ccd: 8d 65 f8 lea -0x8(%ebp),%esp
109cd0: 5b pop %ebx
109cd1: 5e pop %esi
109cd2: c9 leave
109cd3: c3 ret
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
if ( !time )
109cd4: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
109cd9: eb c2 jmp 109c9d <rtems_clock_get_tod_timeval+0x1d><== NOT EXECUTED
00109efc <rtems_clock_get_uptime>:
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
109efc: 55 push %ebp
109efd: 89 e5 mov %esp,%ebp
109eff: 83 ec 08 sub $0x8,%esp
109f02: 8b 45 08 mov 0x8(%ebp),%eax
if ( !uptime )
109f05: 85 c0 test %eax,%eax
109f07: 74 13 je 109f1c <rtems_clock_get_uptime+0x20><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
_TOD_Get_uptime( uptime );
109f09: 83 ec 0c sub $0xc,%esp
109f0c: 50 push %eax
109f0d: e8 fe 16 00 00 call 10b610 <_TOD_Get_uptime>
109f12: 31 c0 xor %eax,%eax
109f14: 83 c4 10 add $0x10,%esp
return RTEMS_SUCCESSFUL;
}
109f17: c9 leave
109f18: c3 ret
109f19: 8d 76 00 lea 0x0(%esi),%esi
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
if ( !uptime )
109f1c: b0 09 mov $0x9,%al <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_TOD_Get_uptime( uptime );
return RTEMS_SUCCESSFUL;
}
109f1e: c9 leave <== NOT EXECUTED
109f1f: c3 ret <== NOT EXECUTED
0010aba0 <rtems_clock_set>:
*/
rtems_status_code rtems_clock_set(
rtems_time_of_day *time_buffer
)
{
10aba0: 55 push %ebp
10aba1: 89 e5 mov %esp,%ebp
10aba3: 53 push %ebx
10aba4: 83 ec 14 sub $0x14,%esp
10aba7: 8b 5d 08 mov 0x8(%ebp),%ebx
struct timespec newtime;
if ( !time_buffer )
10abaa: 85 db test %ebx,%ebx
10abac: 74 66 je 10ac14 <rtems_clock_set+0x74> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( time_buffer ) ) {
10abae: 83 ec 0c sub $0xc,%esp
10abb1: 53 push %ebx
10abb2: e8 3d 01 00 00 call 10acf4 <_TOD_Validate>
10abb7: 83 c4 10 add $0x10,%esp
10abba: 84 c0 test %al,%al
10abbc: 75 0a jne 10abc8 <rtems_clock_set+0x28>
10abbe: b8 14 00 00 00 mov $0x14,%eax
_TOD_Set( &newtime );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_INVALID_CLOCK;
}
10abc3: 8b 5d fc mov -0x4(%ebp),%ebx
10abc6: c9 leave
10abc7: c3 ret
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( time_buffer ) ) {
newtime.tv_sec = _TOD_To_seconds( time_buffer );
10abc8: 83 ec 0c sub $0xc,%esp
10abcb: 53 push %ebx
10abcc: e8 93 00 00 00 call 10ac64 <_TOD_To_seconds>
10abd1: 89 45 f4 mov %eax,-0xc(%ebp)
newtime.tv_nsec = time_buffer->ticks *
10abd4: 8b 43 18 mov 0x18(%ebx),%eax
10abd7: 0f af 05 40 a8 12 00 imul 0x12a840,%eax
10abde: 8d 04 80 lea (%eax,%eax,4),%eax
10abe1: 8d 04 80 lea (%eax,%eax,4),%eax
10abe4: 8d 04 80 lea (%eax,%eax,4),%eax
10abe7: c1 e0 03 shl $0x3,%eax
10abea: 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
10abed: a1 78 a6 12 00 mov 0x12a678,%eax
10abf2: 40 inc %eax
10abf3: a3 78 a6 12 00 mov %eax,0x12a678
(_TOD_Microseconds_per_tick * TOD_NANOSECONDS_PER_MICROSECOND);
_Thread_Disable_dispatch();
_TOD_Set( &newtime );
10abf8: 8d 45 f4 lea -0xc(%ebp),%eax
10abfb: 89 04 24 mov %eax,(%esp)
10abfe: e8 c9 19 00 00 call 10c5cc <_TOD_Set>
_Thread_Enable_dispatch();
10ac03: e8 b0 2b 00 00 call 10d7b8 <_Thread_Enable_dispatch>
10ac08: 31 c0 xor %eax,%eax
10ac0a: 83 c4 10 add $0x10,%esp
return RTEMS_SUCCESSFUL;
}
return RTEMS_INVALID_CLOCK;
}
10ac0d: 8b 5d fc mov -0x4(%ebp),%ebx
10ac10: c9 leave
10ac11: c3 ret
10ac12: 66 90 xchg %ax,%ax
rtems_time_of_day *time_buffer
)
{
struct timespec newtime;
if ( !time_buffer )
10ac14: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
_TOD_Set( &newtime );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_INVALID_CLOCK;
}
10ac19: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10ac1c: c9 leave <== NOT EXECUTED
10ac1d: c3 ret <== NOT EXECUTED
00109cdc <rtems_clock_set_nanoseconds_extension>:
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_set_nanoseconds_extension(
rtems_nanoseconds_extension_routine routine
)
{
109cdc: 55 push %ebp
109cdd: 89 e5 mov %esp,%ebp
109cdf: 8b 45 08 mov 0x8(%ebp),%eax
if ( !routine )
109ce2: 85 c0 test %eax,%eax
109ce4: 74 0a je 109cf0 <rtems_clock_set_nanoseconds_extension+0x14><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
_Watchdog_Nanoseconds_since_tick_handler = routine;
109ce6: a3 28 e8 11 00 mov %eax,0x11e828
109ceb: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
109ced: c9 leave
109cee: c3 ret
109cef: 90 nop
*/
rtems_status_code rtems_clock_set_nanoseconds_extension(
rtems_nanoseconds_extension_routine routine
)
{
if ( !routine )
109cf0: b0 09 mov $0x9,%al <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_Watchdog_Nanoseconds_since_tick_handler = routine;
return RTEMS_SUCCESSFUL;
}
109cf2: c9 leave <== NOT EXECUTED
109cf3: c3 ret <== NOT EXECUTED
00109cf4 <rtems_clock_tick>:
*
* NOTE: This routine only works for leap-years through 2099.
*/
rtems_status_code rtems_clock_tick( void )
{
109cf4: 55 push %ebp
109cf5: 89 e5 mov %esp,%ebp
109cf7: 83 ec 08 sub $0x8,%esp
_TOD_Tickle_ticks();
109cfa: e8 cd 15 00 00 call 10b2cc <_TOD_Tickle_ticks>
* 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
* alignments are possible.
* Returns pointer to the start of the memory block if success, NULL if
109cff: 83 ec 0c sub $0xc,%esp
109d02: 68 3c e7 11 00 push $0x11e73c
109d07: e8 8c 36 00 00 call 10d398 <_Watchdog_Tickle>
_Watchdog_Tickle_ticks();
_Thread_Tickle_timeslice();
109d0c: e8 37 31 00 00 call 10ce48 <_Thread_Tickle_timeslice>
109d11: a0 2c e7 11 00 mov 0x11e72c,%al
if ( _Thread_Is_context_switch_necessary() &&
109d16: 83 c4 10 add $0x10,%esp
109d19: 84 c0 test %al,%al
109d1b: 74 09 je 109d26 <rtems_clock_tick+0x32>
109d1d: a1 58 e6 11 00 mov 0x11e658,%eax
109d22: 85 c0 test %eax,%eax
109d24: 74 06 je 109d2c <rtems_clock_tick+0x38>
_Thread_Is_dispatching_enabled() )
_Thread_Dispatch();
return RTEMS_SUCCESSFUL;
}
109d26: 31 c0 xor %eax,%eax
109d28: c9 leave
109d29: c3 ret
109d2a: 66 90 xchg %ax,%ax
_Thread_Tickle_timeslice();
if ( _Thread_Is_context_switch_necessary() &&
_Thread_Is_dispatching_enabled() )
_Thread_Dispatch();
109d2c: e8 5f 24 00 00 call 10c190 <_Thread_Dispatch>
return RTEMS_SUCCESSFUL;
}
109d31: 31 c0 xor %eax,%eax
109d33: c9 leave
109d34: c3 ret
001077a8 <rtems_cpu_usage_report_with_plugin>:
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
1077a8: 55 push %ebp
1077a9: 89 e5 mov %esp,%ebp
1077ab: 57 push %edi
1077ac: 56 push %esi
1077ad: 53 push %ebx
1077ae: 83 ec 4c sub $0x4c,%esp
struct timespec uptime, total, ran;
#else
uint32_t total_units = 0;
#endif
if ( !print )
1077b1: 8b 4d 0c mov 0xc(%ebp),%ecx
1077b4: 85 c9 test %ecx,%ecx
1077b6: 0f 84 4e 01 00 00 je 10790a <rtems_cpu_usage_report_with_plugin+0x162><== 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 );
1077bc: 83 ec 0c sub $0xc,%esp
1077bf: 8d 45 e4 lea -0x1c(%ebp),%eax
1077c2: 50 push %eax
1077c3: e8 74 4d 00 00 call 10c53c <_TOD_Get_uptime>
_Timespec_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total );
1077c8: 83 c4 0c add $0xc,%esp
1077cb: 8d 55 dc lea -0x24(%ebp),%edx
1077ce: 52 push %edx
1077cf: 8d 45 e4 lea -0x1c(%ebp),%eax
1077d2: 50 push %eax
1077d3: 68 6c a9 12 00 push $0x12a96c
1077d8: e8 c3 6e 00 00 call 10e6a0 <_Timespec_Subtract>
}
}
}
#endif
(*print)( context, "CPU Usage by thread\n"
1077dd: 58 pop %eax
1077de: 5a pop %edx
1077df: 68 34 b1 11 00 push $0x11b134
1077e4: ff 75 08 pushl 0x8(%ebp)
1077e7: ff 55 0c call *0xc(%ebp)
1077ea: c7 45 b0 01 00 00 00 movl $0x1,-0x50(%ebp)
1077f1: 83 c4 10 add $0x10,%esp
);
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
1077f4: 8b 55 b0 mov -0x50(%ebp),%edx
1077f7: 8b 04 95 4c a6 12 00 mov 0x12a64c(,%edx,4),%eax
1077fe: 85 c0 test %eax,%eax
107800: 0f 84 da 00 00 00 je 1078e0 <rtems_cpu_usage_report_with_plugin+0x138>
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
107806: 8b 78 04 mov 0x4(%eax),%edi
if ( information ) {
107809: 85 ff test %edi,%edi
10780b: 0f 84 cf 00 00 00 je 1078e0 <rtems_cpu_usage_report_with_plugin+0x138><== NEVER TAKEN
for ( i=1 ; i <= information->maximum ; i++ ) {
107811: 66 83 7f 10 00 cmpw $0x0,0x10(%edi)
107816: 0f 84 c4 00 00 00 je 1078e0 <rtems_cpu_usage_report_with_plugin+0x138><== NEVER TAKEN
10781c: be 01 00 00 00 mov $0x1,%esi
107821: eb 44 jmp 107867 <rtems_cpu_usage_report_with_plugin+0xbf>
107823: 90 nop
107824: 8d 5d d4 lea -0x2c(%ebp),%ebx
_Timespec_Subtract(
&_Thread_Time_of_last_context_switch, &uptime, &used
);
_Timespec_Add_to( &ran, &used );
};
_Timespec_Divide( &ran, &total, &ival, &fval );
107827: 8d 55 ec lea -0x14(%ebp),%edx
10782a: 52 push %edx
10782b: 8d 45 f0 lea -0x10(%ebp),%eax
10782e: 50 push %eax
10782f: 8d 45 dc lea -0x24(%ebp),%eax
107832: 50 push %eax
107833: 53 push %ebx
107834: e8 9f 6d 00 00 call 10e5d8 <_Timespec_Divide>
/*
* Print the information
*/
(*print)( context,
107839: 58 pop %eax
10783a: 5a pop %edx
10783b: ff 75 ec pushl -0x14(%ebp)
10783e: ff 75 f0 pushl -0x10(%ebp)
107841: b8 d3 4d 62 10 mov $0x10624dd3,%eax
107846: f7 65 d8 mull -0x28(%ebp)
107849: c1 ea 06 shr $0x6,%edx
10784c: 52 push %edx
10784d: ff 75 d4 pushl -0x2c(%ebp)
107850: 68 c2 b1 11 00 push $0x11b1c2
107855: ff 75 08 pushl 0x8(%ebp)
107858: ff 55 0c call *0xc(%ebp)
10785b: 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++ ) {
10785e: 46 inc %esi
10785f: 0f b7 47 10 movzwl 0x10(%edi),%eax
107863: 39 f0 cmp %esi,%eax
107865: 72 79 jb 1078e0 <rtems_cpu_usage_report_with_plugin+0x138>
the_thread = (Thread_Control *)information->local_table[ i ];
107867: 8b 47 1c mov 0x1c(%edi),%eax
10786a: 8b 1c b0 mov (%eax,%esi,4),%ebx
if ( !the_thread )
10786d: 85 db test %ebx,%ebx
10786f: 74 ed je 10785e <rtems_cpu_usage_report_with_plugin+0xb6><== NEVER TAKEN
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
107871: 50 push %eax
107872: 8d 45 bf lea -0x41(%ebp),%eax
107875: 50 push %eax
107876: 6a 0d push $0xd
107878: ff 73 08 pushl 0x8(%ebx)
10787b: e8 20 39 00 00 call 10b1a0 <rtems_object_get_name>
(*print)(
107880: 8d 55 bf lea -0x41(%ebp),%edx
107883: 52 push %edx
107884: ff 73 08 pushl 0x8(%ebx)
107887: 68 af b1 11 00 push $0x11b1af
10788c: ff 75 08 pushl 0x8(%ebp)
10788f: 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;
107892: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx
107898: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax
10789e: 89 45 d8 mov %eax,-0x28(%ebp)
1078a1: 89 55 d4 mov %edx,-0x2c(%ebp)
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
1078a4: 83 c4 20 add $0x20,%esp
1078a7: a1 3c a7 12 00 mov 0x12a73c,%eax
1078ac: 8b 40 08 mov 0x8(%eax),%eax
1078af: 3b 43 08 cmp 0x8(%ebx),%eax
1078b2: 0f 85 6c ff ff ff jne 107824 <rtems_cpu_usage_report_with_plugin+0x7c>
struct timespec used;
_Timespec_Subtract(
1078b8: 50 push %eax
1078b9: 8d 5d cc lea -0x34(%ebp),%ebx
1078bc: 53 push %ebx
1078bd: 8d 45 e4 lea -0x1c(%ebp),%eax
1078c0: 50 push %eax
1078c1: 68 44 a7 12 00 push $0x12a744
1078c6: e8 d5 6d 00 00 call 10e6a0 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch, &uptime, &used
);
_Timespec_Add_to( &ran, &used );
1078cb: 59 pop %ecx
1078cc: 58 pop %eax
1078cd: 53 push %ebx
1078ce: 8d 5d d4 lea -0x2c(%ebp),%ebx
1078d1: 53 push %ebx
1078d2: e8 c9 6c 00 00 call 10e5a0 <_Timespec_Add_to>
1078d7: 83 c4 10 add $0x10,%esp
1078da: e9 48 ff ff ff jmp 107827 <rtems_cpu_usage_report_with_plugin+0x7f>
1078df: 90 nop
#endif
);
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
api_index++ ) {
1078e0: ff 45 b0 incl -0x50(%ebp)
" ID NAME TICKS PERCENT\n"
#endif
);
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
1078e3: 83 7d b0 05 cmpl $0x5,-0x50(%ebp)
1078e7: 0f 85 07 ff ff ff jne 1077f4 <rtems_cpu_usage_report_with_plugin+0x4c>
}
}
}
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
(*print)( context, "Time since last CPU Usage reset %" PRId32
1078ed: b8 d3 4d 62 10 mov $0x10624dd3,%eax
1078f2: f7 65 e0 mull -0x20(%ebp)
1078f5: c1 ea 06 shr $0x6,%edx
1078f8: 52 push %edx
1078f9: ff 75 dc pushl -0x24(%ebp)
1078fc: 68 7c b1 11 00 push $0x11b17c
107901: ff 75 08 pushl 0x8(%ebp)
107904: ff 55 0c call *0xc(%ebp)
107907: 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
}
10790a: 8d 65 f4 lea -0xc(%ebp),%esp
10790d: 5b pop %ebx
10790e: 5e pop %esi
10790f: 5f pop %edi
107910: c9 leave
107911: c3 ret
0010f934 <rtems_deviceio_errno>:
{ 0, 0, 0 },
};
static int
rtems_deviceio_errno(rtems_status_code code)
{
10f934: 55 push %ebp <== NOT EXECUTED
10f935: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10f937: 53 push %ebx <== NOT EXECUTED
10f938: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
int rc;
if ((rc = rtems_assoc_remote_by_local(errno_assoc, (uint32_t) code)))
10f93b: 50 push %eax <== NOT EXECUTED
10f93c: 68 e0 8b 11 00 push $0x118be0 <== NOT EXECUTED
10f941: e8 ea 03 00 00 call 10fd30 <rtems_assoc_remote_by_local><== NOT EXECUTED
10f946: 89 c3 mov %eax,%ebx <== NOT EXECUTED
10f948: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10f94b: 85 c0 test %eax,%eax <== NOT EXECUTED
10f94d: 74 07 je 10f956 <rtems_deviceio_errno+0x22><== NOT EXECUTED
{
errno = rc;
10f94f: e8 cc 08 00 00 call 110220 <__errno> <== NOT EXECUTED
10f954: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
return -1;
}
return -1;
}
10f956: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
10f95b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10f95e: c9 leave <== NOT EXECUTED
10f95f: c3 ret <== NOT EXECUTED
00107cd4 <rtems_error>:
int rtems_error(
int error_flag,
const char *printf_format,
...
)
{
107cd4: 55 push %ebp <== NOT EXECUTED
107cd5: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107cd7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
107cda: 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);
107cdd: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
107ce0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
107ce3: e8 2c fe ff ff call 107b14 <rtems_verror> <== NOT EXECUTED
va_end(arglist);
return chars_written;
}
107ce8: c9 leave <== NOT EXECUTED
107ce9: c3 ret <== NOT EXECUTED
00109d38 <rtems_event_receive>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
109d38: 55 push %ebp
109d39: 89 e5 mov %esp,%ebp
109d3b: 83 ec 08 sub $0x8,%esp
109d3e: 8b 4d 08 mov 0x8(%ebp),%ecx
109d41: 8b 55 14 mov 0x14(%ebp),%edx
RTEMS_API_Control *api;
if ( !event_out )
109d44: 85 d2 test %edx,%edx
109d46: 74 44 je 109d8c <rtems_event_receive+0x54><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
109d48: a1 1c e7 11 00 mov 0x11e71c,%eax
109d4d: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
if ( _Event_sets_Is_empty( event_in ) ) {
109d53: 85 c9 test %ecx,%ecx
109d55: 75 09 jne 109d60 <rtems_event_receive+0x28>
*event_out = api->pending_events;
109d57: 8b 00 mov (%eax),%eax
109d59: 89 02 mov %eax,(%edx)
109d5b: 31 c0 xor %eax,%eax
_Thread_Disable_dispatch();
_Event_Seize( event_in, option_set, ticks, event_out );
_Thread_Enable_dispatch();
return( _Thread_Executing->Wait.return_code );
}
109d5d: c9 leave
109d5e: c3 ret
109d5f: 90 nop
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
109d60: a1 58 e6 11 00 mov 0x11e658,%eax
109d65: 40 inc %eax
109d66: a3 58 e6 11 00 mov %eax,0x11e658
*event_out = api->pending_events;
return RTEMS_SUCCESSFUL;
}
_Thread_Disable_dispatch();
_Event_Seize( event_in, option_set, ticks, event_out );
109d6b: 52 push %edx
109d6c: ff 75 10 pushl 0x10(%ebp)
109d6f: ff 75 0c pushl 0xc(%ebp)
109d72: 51 push %ecx
109d73: e8 1c 00 00 00 call 109d94 <_Event_Seize>
_Thread_Enable_dispatch();
109d78: e8 6f 25 00 00 call 10c2ec <_Thread_Enable_dispatch>
return( _Thread_Executing->Wait.return_code );
109d7d: a1 1c e7 11 00 mov 0x11e71c,%eax
109d82: 8b 40 34 mov 0x34(%eax),%eax
109d85: 83 c4 10 add $0x10,%esp
}
109d88: c9 leave
109d89: c3 ret
109d8a: 66 90 xchg %ax,%ax
rtems_event_set *event_out
)
{
RTEMS_API_Control *api;
if ( !event_out )
109d8c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
_Thread_Disable_dispatch();
_Event_Seize( event_in, option_set, ticks, event_out );
_Thread_Enable_dispatch();
return( _Thread_Executing->Wait.return_code );
}
109d91: c9 leave <== NOT EXECUTED
109d92: c3 ret <== NOT EXECUTED
0010bc7c <rtems_extension_create>:
rtems_status_code rtems_extension_create(
rtems_name name,
rtems_extensions_table *extension_table,
Objects_Id *id
)
{
10bc7c: 55 push %ebp
10bc7d: 89 e5 mov %esp,%ebp
10bc7f: 57 push %edi
10bc80: 56 push %esi
10bc81: 53 push %ebx
10bc82: 83 ec 0c sub $0xc,%esp
10bc85: 8b 7d 08 mov 0x8(%ebp),%edi
10bc88: 8b 75 10 mov 0x10(%ebp),%esi
Extension_Control *the_extension;
if ( !id )
10bc8b: 85 f6 test %esi,%esi
10bc8d: 74 75 je 10bd04 <rtems_extension_create+0x88>
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
10bc8f: 85 ff test %edi,%edi
10bc91: 75 0d jne 10bca0 <rtems_extension_create+0x24>
10bc93: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_extension->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10bc98: 8d 65 f4 lea -0xc(%ebp),%esp
10bc9b: 5b pop %ebx
10bc9c: 5e pop %esi
10bc9d: 5f pop %edi
10bc9e: c9 leave
10bc9f: c3 ret
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10bca0: a1 78 a6 12 00 mov 0x12a678,%eax
10bca5: 40 inc %eax
10bca6: a3 78 a6 12 00 mov %eax,0x12a678
* It is a simple wrapper for the help with the addition of the
* allocation mutex being used for protection.
*/
/**@{*/
#ifdef __cplusplus
10bcab: 83 ec 0c sub $0xc,%esp
10bcae: 68 00 a9 12 00 push $0x12a900
10bcb3: e8 c8 0c 00 00 call 10c980 <_Objects_Allocate>
10bcb8: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* to prevent deletion */
the_extension = _Extension_Allocate();
if ( !the_extension ) {
10bcba: 83 c4 10 add $0x10,%esp
10bcbd: 85 c0 test %eax,%eax
10bcbf: 74 37 je 10bcf8 <rtems_extension_create+0x7c>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
_User_extensions_Add_set( &the_extension->Extension, extension_table );
10bcc1: 83 ec 08 sub $0x8,%esp
10bcc4: ff 75 0c pushl 0xc(%ebp)
10bcc7: 8d 40 10 lea 0x10(%eax),%eax
10bcca: 50 push %eax
10bccb: e8 0c 2a 00 00 call 10e6dc <_User_extensions_Add_set>
10bcd0: 8b 4b 08 mov 0x8(%ebx),%ecx
10bcd3: 0f b7 d1 movzwl %cx,%edx
10bcd6: a1 1c a9 12 00 mov 0x12a91c,%eax
10bcdb: 89 1c 90 mov %ebx,(%eax,%edx,4)
10bcde: 89 7b 0c mov %edi,0xc(%ebx)
&_Extension_Information,
&the_extension->Object,
(Objects_Name) name
);
*id = the_extension->Object.id;
10bce1: 89 0e mov %ecx,(%esi)
_Thread_Enable_dispatch();
10bce3: e8 d0 1a 00 00 call 10d7b8 <_Thread_Enable_dispatch>
10bce8: 31 c0 xor %eax,%eax
10bcea: 83 c4 10 add $0x10,%esp
return RTEMS_SUCCESSFUL;
}
10bced: 8d 65 f4 lea -0xc(%ebp),%esp
10bcf0: 5b pop %ebx
10bcf1: 5e pop %esi
10bcf2: 5f pop %edi
10bcf3: c9 leave
10bcf4: c3 ret
10bcf5: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* to prevent deletion */
the_extension = _Extension_Allocate();
if ( !the_extension ) {
_Thread_Enable_dispatch();
10bcf8: e8 bb 1a 00 00 call 10d7b8 <_Thread_Enable_dispatch>
10bcfd: b8 05 00 00 00 mov $0x5,%eax
10bd02: eb 94 jmp 10bc98 <rtems_extension_create+0x1c>
Objects_Id *id
)
{
Extension_Control *the_extension;
if ( !id )
10bd04: b8 09 00 00 00 mov $0x9,%eax
10bd09: eb 8d jmp 10bc98 <rtems_extension_create+0x1c>
0010c428 <rtems_extension_delete>:
*/
rtems_status_code rtems_extension_delete(
Objects_Id id
)
{
10c428: 55 push %ebp
10c429: 89 e5 mov %esp,%ebp
10c42b: 53 push %ebx
10c42c: 83 ec 18 sub $0x18,%esp
*
* @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
* @return a status indicating success or the reason for failure
10c42f: 8d 45 f8 lea -0x8(%ebp),%eax
10c432: 50 push %eax
10c433: ff 75 08 pushl 0x8(%ebp)
10c436: 68 20 3c 12 00 push $0x123c20
10c43b: e8 bc 10 00 00 call 10d4fc <_Objects_Get>
10c440: 89 c3 mov %eax,%ebx
Extension_Control *the_extension;
Objects_Locations location;
the_extension = _Extension_Get( id, &location );
switch ( location ) {
10c442: 83 c4 10 add $0x10,%esp
10c445: 8b 45 f8 mov -0x8(%ebp),%eax
10c448: 85 c0 test %eax,%eax
10c44a: 75 38 jne 10c484 <rtems_extension_delete+0x5c>
case OBJECTS_LOCAL:
_User_extensions_Remove_set( &the_extension->Extension );
10c44c: 83 ec 0c sub $0xc,%esp
10c44f: 8d 43 10 lea 0x10(%ebx),%eax
10c452: 50 push %eax
10c453: e8 fc 27 00 00 call 10ec54 <_User_extensions_Remove_set>
_Objects_Close( &_Extension_Information, &the_extension->Object );
10c458: 59 pop %ecx
10c459: 58 pop %eax
10c45a: 53 push %ebx
10c45b: 68 20 3c 12 00 push $0x123c20
10c460: e8 23 0c 00 00 call 10d088 <_Objects_Close>
* @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
10c465: 58 pop %eax
10c466: 5a pop %edx
10c467: 53 push %ebx
10c468: 68 20 3c 12 00 push $0x123c20
10c46d: e8 56 0f 00 00 call 10d3c8 <_Objects_Free>
_Extension_Free( the_extension );
_Thread_Enable_dispatch();
10c472: e8 c9 18 00 00 call 10dd40 <_Thread_Enable_dispatch>
10c477: 31 c0 xor %eax,%eax
10c479: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c47c: 8b 5d fc mov -0x4(%ebp),%ebx
10c47f: c9 leave
10c480: c3 ret
10c481: 8d 76 00 lea 0x0(%esi),%esi
{
Extension_Control *the_extension;
Objects_Locations location;
the_extension = _Extension_Get( id, &location );
switch ( location ) {
10c484: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c489: 8b 5d fc mov -0x4(%ebp),%ebx
10c48c: c9 leave
10c48d: c3 ret
00106ee4 <rtems_filesystem_evaluate_parent>:
int rtems_filesystem_evaluate_parent(
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
106ee4: 55 push %ebp <== NOT EXECUTED
106ee5: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106ee7: 57 push %edi <== NOT EXECUTED
106ee8: 56 push %esi <== NOT EXECUTED
106ee9: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
106eec: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED
rtems_filesystem_location_info_t parent;
int result;
if ( !pathloc )
106eef: 85 f6 test %esi,%esi <== NOT EXECUTED
106ef1: 74 76 je 106f69 <rtems_filesystem_evaluate_parent+0x85><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
if ( !pathloc->ops->evalpath_h )
106ef3: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED
106ef6: 8b 08 mov (%eax),%ecx <== NOT EXECUTED
106ef8: 85 c9 test %ecx,%ecx <== NOT EXECUTED
106efa: 74 54 je 106f50 <rtems_filesystem_evaluate_parent+0x6c><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
parent = *pathloc;
106efc: 8d 7d e8 lea -0x18(%ebp),%edi <== NOT EXECUTED
106eff: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
106f04: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
result = (*pathloc->ops->evalpath_h)( "..", flags, &parent );
106f06: 52 push %edx <== NOT EXECUTED
106f07: 8d 7d e8 lea -0x18(%ebp),%edi <== NOT EXECUTED
106f0a: 57 push %edi <== NOT EXECUTED
106f0b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
106f0e: 68 93 84 11 00 push $0x118493 <== NOT EXECUTED
106f13: ff 10 call *(%eax) <== NOT EXECUTED
106f15: 89 c6 mov %eax,%esi <== NOT EXECUTED
if (result != 0){
106f17: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106f1a: 85 c0 test %eax,%eax <== NOT EXECUTED
106f1c: 75 22 jne 106f40 <rtems_filesystem_evaluate_parent+0x5c><== NOT EXECUTED
return -1;
}
rtems_filesystem_freenode( &parent );
106f1e: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED
106f21: 85 c0 test %eax,%eax <== NOT EXECUTED
106f23: 74 10 je 106f35 <rtems_filesystem_evaluate_parent+0x51><== NOT EXECUTED
106f25: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
106f28: 85 c0 test %eax,%eax <== NOT EXECUTED
106f2a: 74 09 je 106f35 <rtems_filesystem_evaluate_parent+0x51><== NOT EXECUTED
106f2c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106f2f: 57 push %edi <== NOT EXECUTED
106f30: ff d0 call *%eax <== NOT EXECUTED
106f32: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return result;
}
106f35: 89 f0 mov %esi,%eax <== NOT EXECUTED
106f37: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
106f3a: 5e pop %esi <== NOT EXECUTED
106f3b: 5f pop %edi <== NOT EXECUTED
106f3c: c9 leave <== NOT EXECUTED
106f3d: c3 ret <== NOT EXECUTED
106f3e: 66 90 xchg %ax,%ax <== NOT EXECUTED
if ( !pathloc->ops->evalpath_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
parent = *pathloc;
result = (*pathloc->ops->evalpath_h)( "..", flags, &parent );
if (result != 0){
106f40: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED
return -1;
}
rtems_filesystem_freenode( &parent );
return result;
}
106f45: 89 f0 mov %esi,%eax <== NOT EXECUTED
106f47: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
106f4a: 5e pop %esi <== NOT EXECUTED
106f4b: 5f pop %edi <== NOT EXECUTED
106f4c: c9 leave <== NOT EXECUTED
106f4d: c3 ret <== NOT EXECUTED
106f4e: 66 90 xchg %ax,%ax <== NOT EXECUTED
if ( !pathloc )
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
if ( !pathloc->ops->evalpath_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
106f50: e8 cb 92 00 00 call 110220 <__errno> <== NOT EXECUTED
106f55: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
106f5b: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED
return -1;
}
rtems_filesystem_freenode( &parent );
return result;
}
106f60: 89 f0 mov %esi,%eax <== NOT EXECUTED
106f62: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
106f65: 5e pop %esi <== NOT EXECUTED
106f66: 5f pop %edi <== NOT EXECUTED
106f67: c9 leave <== NOT EXECUTED
106f68: c3 ret <== NOT EXECUTED
{
rtems_filesystem_location_info_t parent;
int result;
if ( !pathloc )
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
106f69: e8 b2 92 00 00 call 110220 <__errno> <== NOT EXECUTED
106f6e: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
106f74: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED
106f79: eb ba jmp 106f35 <rtems_filesystem_evaluate_parent+0x51><== NOT EXECUTED
00106f7c <rtems_filesystem_evaluate_path>:
const char *pathname,
int flags,
rtems_filesystem_location_info_t *pathloc,
int follow_link
)
{
106f7c: 55 push %ebp
106f7d: 89 e5 mov %esp,%ebp
106f7f: 57 push %edi
106f80: 56 push %esi
106f81: 53 push %ebx
106f82: 83 ec 1c sub $0x1c,%esp
106f85: 8b 5d 08 mov 0x8(%ebp),%ebx
106f88: 8b 45 0c mov 0xc(%ebp),%eax
106f8b: 89 45 f0 mov %eax,-0x10(%ebp)
106f8e: 8b 55 10 mov 0x10(%ebp),%edx
106f91: 89 55 e0 mov %edx,-0x20(%ebp)
106f94: 8b 7d 14 mov 0x14(%ebp),%edi
106f97: 89 7d ec mov %edi,-0x14(%ebp)
/*
* Verify Input parameters.
*/
if ( !pathname )
106f9a: 85 db test %ebx,%ebx
106f9c: 0f 84 08 01 00 00 je 1070aa <rtems_filesystem_evaluate_path+0x12e><== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EFAULT );
if ( !pathloc )
106fa2: 8b 7d e0 mov -0x20(%ebp),%edi
106fa5: 85 ff test %edi,%edi
106fa7: 0f 84 eb 00 00 00 je 107098 <rtems_filesystem_evaluate_path+0x11c><== NEVER TAKEN
/*
* Evaluate the path using the optable evalpath.
*/
rtems_filesystem_get_start_loc( pathname, &i, pathloc );
106fad: 8a 03 mov (%ebx),%al
106faf: 3c 2f cmp $0x2f,%al
106fb1: 74 1d je 106fd0 <rtems_filesystem_evaluate_path+0x54><== ALWAYS TAKEN
106fb3: 3c 5c cmp $0x5c,%al <== NOT EXECUTED
106fb5: 74 19 je 106fd0 <rtems_filesystem_evaluate_path+0x54><== NOT EXECUTED
106fb7: 84 c0 test %al,%al <== NOT EXECUTED
106fb9: 74 15 je 106fd0 <rtems_filesystem_evaluate_path+0x54><== NOT EXECUTED
106fbb: a1 b4 c4 11 00 mov 0x11c4b4,%eax <== NOT EXECUTED
106fc0: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED
106fc3: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
106fc8: 8b 7d e0 mov -0x20(%ebp),%edi <== NOT EXECUTED
106fcb: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
106fcd: eb 15 jmp 106fe4 <rtems_filesystem_evaluate_path+0x68><== NOT EXECUTED
106fcf: 90 nop <== NOT EXECUTED
106fd0: a1 b4 c4 11 00 mov 0x11c4b4,%eax
106fd5: 8d 70 14 lea 0x14(%eax),%esi
106fd8: b9 04 00 00 00 mov $0x4,%ecx
106fdd: 8b 7d e0 mov -0x20(%ebp),%edi
106fe0: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
106fe2: b1 01 mov $0x1,%cl
if ( !pathloc->ops->evalpath_h )
106fe4: 8b 55 e0 mov -0x20(%ebp),%edx
106fe7: 8b 42 08 mov 0x8(%edx),%eax
106fea: 8b 10 mov (%eax),%edx
106fec: 85 d2 test %edx,%edx
106fee: 0f 84 80 00 00 00 je 107074 <rtems_filesystem_evaluate_path+0xf8><== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
result = (*pathloc->ops->evalpath_h)( &pathname[i], flags, pathloc );
106ff4: 56 push %esi
106ff5: ff 75 e0 pushl -0x20(%ebp)
106ff8: ff 75 f0 pushl -0x10(%ebp)
106ffb: 8d 04 0b lea (%ebx,%ecx,1),%eax
106ffe: 50 push %eax
106fff: ff d2 call *%edx
107001: 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 ) {
107003: 83 c4 10 add $0x10,%esp
107006: 85 c0 test %eax,%eax
107008: 75 2a jne 107034 <rtems_filesystem_evaluate_path+0xb8><== NEVER TAKEN
10700a: 8b 5d ec mov -0x14(%ebp),%ebx
10700d: 85 db test %ebx,%ebx
10700f: 74 23 je 107034 <rtems_filesystem_evaluate_path+0xb8>
if ( !pathloc->ops->node_type_h ){
107011: 8b 7d e0 mov -0x20(%ebp),%edi
107014: 8b 57 08 mov 0x8(%edi),%edx
107017: 8b 42 10 mov 0x10(%edx),%eax
10701a: 85 c0 test %eax,%eax
10701c: 74 68 je 107086 <rtems_filesystem_evaluate_path+0x10a><== NEVER TAKEN
rtems_filesystem_freenode( pathloc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
type = (*pathloc->ops->node_type_h)( pathloc );
10701e: 83 ec 0c sub $0xc,%esp
107021: ff 75 e0 pushl -0x20(%ebp)
107024: ff d0 call *%eax
if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) ||
107026: 83 e8 03 sub $0x3,%eax
107029: 83 c4 10 add $0x10,%esp
10702c: 83 f8 01 cmp $0x1,%eax
10702f: 76 0f jbe 107040 <rtems_filesystem_evaluate_path+0xc4><== NEVER TAKEN
107031: 8d 76 00 lea 0x0(%esi),%esi
}
}
return result;
}
107034: 89 f0 mov %esi,%eax
107036: 8d 65 f4 lea -0xc(%ebp),%esp
107039: 5b pop %ebx
10703a: 5e pop %esi
10703b: 5f pop %edi
10703c: c9 leave
10703d: c3 ret
10703e: 66 90 xchg %ax,%ax
type = (*pathloc->ops->node_type_h)( pathloc );
if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) ||
( type == RTEMS_FILESYSTEM_SYM_LINK ) ) {
if ( !pathloc->ops->eval_link_h ){
107040: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED
107043: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED
107046: 8b 48 34 mov 0x34(%eax),%ecx <== NOT EXECUTED
107049: 85 c9 test %ecx,%ecx <== NOT EXECUTED
10704b: 74 15 je 107062 <rtems_filesystem_evaluate_path+0xe6><== 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 );
10704d: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED
107050: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED
107053: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
107056: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
}
return result;
}
107059: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10705c: 5b pop %ebx <== NOT EXECUTED
10705d: 5e pop %esi <== NOT EXECUTED
10705e: 5f pop %edi <== NOT EXECUTED
10705f: c9 leave <== 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 );
107060: ff e1 jmp *%ecx <== NOT EXECUTED
if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) ||
( type == RTEMS_FILESYSTEM_SYM_LINK ) ) {
if ( !pathloc->ops->eval_link_h ){
rtems_filesystem_freenode( pathloc );
107062: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
107065: 85 c0 test %eax,%eax <== NOT EXECUTED
107067: 74 0b je 107074 <rtems_filesystem_evaluate_path+0xf8><== NOT EXECUTED
107069: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10706c: 52 push %edx <== NOT EXECUTED
10706d: ff d0 call *%eax <== NOT EXECUTED
10706f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107072: 66 90 xchg %ax,%ax <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
107074: e8 a7 91 00 00 call 110220 <__errno> <== NOT EXECUTED
107079: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10707f: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED
107084: eb ae jmp 107034 <rtems_filesystem_evaluate_path+0xb8><== NOT EXECUTED
*/
if ( (result == 0) && follow_link ) {
if ( !pathloc->ops->node_type_h ){
rtems_filesystem_freenode( pathloc );
107086: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED
107089: 85 c0 test %eax,%eax <== NOT EXECUTED
10708b: 74 e7 je 107074 <rtems_filesystem_evaluate_path+0xf8><== NOT EXECUTED
10708d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107090: 57 push %edi <== NOT EXECUTED
107091: ff d0 call *%eax <== NOT EXECUTED
107093: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107096: eb dc jmp 107074 <rtems_filesystem_evaluate_path+0xf8><== NOT EXECUTED
if ( !pathname )
rtems_set_errno_and_return_minus_one( EFAULT );
if ( !pathloc )
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
107098: e8 83 91 00 00 call 110220 <__errno> <== NOT EXECUTED
10709d: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
1070a3: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED
1070a8: eb 8a jmp 107034 <rtems_filesystem_evaluate_path+0xb8><== NOT EXECUTED
/*
* Verify Input parameters.
*/
if ( !pathname )
rtems_set_errno_and_return_minus_one( EFAULT );
1070aa: e8 71 91 00 00 call 110220 <__errno> <== NOT EXECUTED
1070af: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED
1070b5: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED
1070ba: e9 75 ff ff ff jmp 107034 <rtems_filesystem_evaluate_path+0xb8><== NOT EXECUTED
0010e3c8 <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 )
{
10e3c8: 55 push %ebp
10e3c9: 89 e5 mov %esp,%ebp
10e3cb: 57 push %edi
10e3cc: 56 push %esi
10e3cd: 53 push %ebx
10e3ce: 83 ec 2c sub $0x2c,%esp
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
10e3d1: a1 b4 c4 11 00 mov 0x11c4b4,%eax
10e3d6: c7 40 24 12 00 00 00 movl $0x12,0x24(%eax)
init_fs_mount_table();
10e3dd: e8 5a 05 00 00 call 10e93c <init_fs_mount_table>
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
10e3e2: a1 6c 6f 11 00 mov 0x116f6c,%eax
10e3e7: 85 c0 test %eax,%eax
10e3e9: 0f 84 a5 00 00 00 je 10e494 <rtems_filesystem_initialize+0xcc><== NEVER TAKEN
rtems_fatal_error_occurred( 0xABCD0001 );
mt = &rtems_filesystem_mount_table[0];
10e3ef: a1 48 a0 11 00 mov 0x11a048,%eax
status = mount(
10e3f4: 83 ec 0c sub $0xc,%esp
10e3f7: ff 70 0c pushl 0xc(%eax)
10e3fa: ff 70 08 pushl 0x8(%eax)
10e3fd: ff 70 04 pushl 0x4(%eax)
10e400: ff 30 pushl (%eax)
10e402: 8d 45 f0 lea -0x10(%ebp),%eax
10e405: 50 push %eax
10e406: e8 59 05 00 00 call 10e964 <mount>
&entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point );
if ( status == -1 )
10e40b: 83 c4 20 add $0x20,%esp
10e40e: 40 inc %eax
10e40f: 0f 84 8c 00 00 00 je 10e4a1 <rtems_filesystem_initialize+0xd9><== NEVER TAKEN
rtems_fatal_error_occurred( 0xABCD0002 );
rtems_filesystem_link_counts = 0;
10e415: a1 b4 c4 11 00 mov 0x11c4b4,%eax
10e41a: 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;
10e420: 8d 78 14 lea 0x14(%eax),%edi
10e423: 8b 45 f0 mov -0x10(%ebp),%eax
10e426: 8d 70 18 lea 0x18(%eax),%esi
10e429: b9 04 00 00 00 mov $0x4,%ecx
10e42e: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
10e430: 6a 00 push $0x0
10e432: 8d 5d e0 lea -0x20(%ebp),%ebx
10e435: 53 push %ebx
10e436: 6a 00 push $0x0
10e438: 68 b8 8a 11 00 push $0x118ab8
10e43d: e8 3a 8b ff ff call 106f7c <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
10e442: a1 b4 c4 11 00 mov 0x11c4b4,%eax
10e447: 8d 78 14 lea 0x14(%eax),%edi
10e44a: b9 04 00 00 00 mov $0x4,%ecx
10e44f: 89 de mov %ebx,%esi
10e451: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
10e453: 6a 00 push $0x0
10e455: 53 push %ebx
10e456: 6a 00 push $0x0
10e458: 68 b8 8a 11 00 push $0x118ab8
10e45d: e8 1a 8b ff ff call 106f7c <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
10e462: a1 b4 c4 11 00 mov 0x11c4b4,%eax
10e467: 8d 78 04 lea 0x4(%eax),%edi
10e46a: b9 04 00 00 00 mov $0x4,%ecx
10e46f: 89 de mov %ebx,%esi
10e471: 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);
10e473: 83 c4 18 add $0x18,%esp
10e476: 68 ff 01 00 00 push $0x1ff
10e47b: 68 ba 8a 11 00 push $0x118aba
10e480: e8 9b 04 00 00 call 10e920 <mkdir>
if ( status != 0 )
10e485: 83 c4 10 add $0x10,%esp
10e488: 85 c0 test %eax,%eax
10e48a: 75 22 jne 10e4ae <rtems_filesystem_initialize+0xe6><== NEVER TAKEN
* before device drivers are initialized. So we return via a base
* filesystem image and nothing auto-mounted at this point.
*/
#endif
}
10e48c: 8d 65 f4 lea -0xc(%ebp),%esp
10e48f: 5b pop %ebx
10e490: 5e pop %esi
10e491: 5f pop %edi
10e492: c9 leave
10e493: c3 ret
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
rtems_fatal_error_occurred( 0xABCD0001 );
10e494: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10e497: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED
10e49c: e8 e3 c5 ff ff call 10aa84 <rtems_fatal_error_occurred><== NOT EXECUTED
status = mount(
&entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point );
if ( status == -1 )
rtems_fatal_error_occurred( 0xABCD0002 );
10e4a1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10e4a4: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED
10e4a9: e8 d6 c5 ff ff call 10aa84 <rtems_fatal_error_occurred><== NOT EXECUTED
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
if ( status != 0 )
rtems_fatal_error_occurred( 0xABCD0003 );
10e4ae: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10e4b1: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED
10e4b6: e8 c9 c5 ff ff call 10aa84 <rtems_fatal_error_occurred><== NOT EXECUTED
0010a74c <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
)
{
10a74c: 55 push %ebp <== NOT EXECUTED
10a74d: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10a74f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10a752: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
10a755: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
if ( !_ISR_Is_vector_number_valid( vector ) )
10a758: 81 7d 0c ff 00 00 00 cmpl $0xff,0xc(%ebp) <== NOT EXECUTED
10a75f: 77 23 ja 10a784 <rtems_interrupt_catch+0x38><== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
if ( !_ISR_Is_valid_user_handler( (void *) new_isr_handler ) )
10a761: 85 d2 test %edx,%edx <== NOT EXECUTED
10a763: 74 17 je 10a77c <rtems_interrupt_catch+0x30><== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_ISR_Is_valid_user_handler( (void *) old_isr_handler ) )
10a765: 85 c0 test %eax,%eax <== NOT EXECUTED
10a767: 74 13 je 10a77c <rtems_interrupt_catch+0x30><== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_ISR_Install_vector(
10a769: 51 push %ecx <== NOT EXECUTED
10a76a: 50 push %eax <== NOT EXECUTED
10a76b: 52 push %edx <== NOT EXECUTED
10a76c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
10a76f: e8 90 c5 ff ff call 106d04 <_CPU_ISR_install_vector><== NOT EXECUTED
10a774: 31 c0 xor %eax,%eax <== NOT EXECUTED
10a776: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler );
return RTEMS_SUCCESSFUL;
}
10a779: c9 leave <== NOT EXECUTED
10a77a: c3 ret <== NOT EXECUTED
10a77b: 90 nop <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_ISR_Install_vector(
vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler );
return RTEMS_SUCCESSFUL;
10a77c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
}
10a781: c9 leave <== NOT EXECUTED
10a782: c3 ret <== NOT EXECUTED
10a783: 90 nop <== NOT EXECUTED
rtems_isr_entry new_isr_handler,
rtems_vector_number vector,
rtems_isr_entry *old_isr_handler
)
{
if ( !_ISR_Is_vector_number_valid( vector ) )
10a784: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
_ISR_Install_vector(
vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler );
return RTEMS_SUCCESSFUL;
}
10a789: c9 leave <== NOT EXECUTED
10a78a: c3 ret <== NOT EXECUTED
00106d68 <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
106d68: 55 push %ebp <== NOT EXECUTED
106d69: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106d6b: 57 push %edi <== NOT EXECUTED
106d6c: 56 push %esi <== NOT EXECUTED
106d6d: 53 push %ebx <== NOT EXECUTED
106d6e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED
106d71: 8b 7d 08 mov 0x8(%ebp),%edi <== 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 );
106d74: 6a 01 push $0x1 <== NOT EXECUTED
106d76: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED
106d79: 56 push %esi <== NOT EXECUTED
106d7a: 6a 00 push $0x0 <== NOT EXECUTED
106d7c: 57 push %edi <== NOT EXECUTED
106d7d: e8 fa 01 00 00 call 106f7c <rtems_filesystem_evaluate_path><== NOT EXECUTED
106d82: 89 c3 mov %eax,%ebx <== NOT EXECUTED
the_jnode = loc.node_access;
106d84: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
106d87: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED
if ( !loc.ops->node_type_h ) {
106d8a: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
106d8d: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED
106d90: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106d93: 85 d2 test %edx,%edx <== NOT EXECUTED
106d95: 74 39 je 106dd0 <rtems_io_lookup_name+0x68><== NOT EXECUTED
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
node_type = (*loc.ops->node_type_h)( &loc );
106d97: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106d9a: 56 push %esi <== NOT EXECUTED
106d9b: ff d2 call *%edx <== NOT EXECUTED
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
106d9d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106da0: 85 db test %ebx,%ebx <== NOT EXECUTED
106da2: 74 54 je 106df8 <rtems_io_lookup_name+0x90><== NOT EXECUTED
rtems_filesystem_freenode( &loc );
106da4: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
106da7: 85 c0 test %eax,%eax <== NOT EXECUTED
106da9: 0f 84 95 00 00 00 je 106e44 <rtems_io_lookup_name+0xdc><== NOT EXECUTED
106daf: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
106db2: 85 c0 test %eax,%eax <== NOT EXECUTED
106db4: 0f 84 8a 00 00 00 je 106e44 <rtems_io_lookup_name+0xdc><== NOT EXECUTED
106dba: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106dbd: 56 push %esi <== NOT EXECUTED
106dbe: ff d0 call *%eax <== NOT EXECUTED
106dc0: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED
106dc5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
#endif
return RTEMS_SUCCESSFUL;
}
106dc8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
106dcb: 5b pop %ebx <== NOT EXECUTED
106dcc: 5e pop %esi <== NOT EXECUTED
106dcd: 5f pop %edi <== NOT EXECUTED
106dce: c9 leave <== NOT EXECUTED
106dcf: c3 ret <== NOT EXECUTED
result = rtems_filesystem_evaluate_path( name, 0x00, &loc, true );
the_jnode = loc.node_access;
if ( !loc.ops->node_type_h ) {
rtems_filesystem_freenode( &loc );
106dd0: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
106dd3: 85 c0 test %eax,%eax <== NOT EXECUTED
106dd5: 74 09 je 106de0 <rtems_io_lookup_name+0x78><== NOT EXECUTED
106dd7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106dda: 56 push %esi <== NOT EXECUTED
106ddb: ff d0 call *%eax <== NOT EXECUTED
106ddd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
106de0: e8 3b 94 00 00 call 110220 <__errno> <== NOT EXECUTED
106de5: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
106deb: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
#endif
return RTEMS_SUCCESSFUL;
}
106df0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
106df3: 5b pop %ebx <== NOT EXECUTED
106df4: 5e pop %esi <== NOT EXECUTED
106df5: 5f pop %edi <== NOT EXECUTED
106df6: c9 leave <== NOT EXECUTED
106df7: c3 ret <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
node_type = (*loc.ops->node_type_h)( &loc );
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
106df8: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED
106dfb: 75 a7 jne 106da4 <rtems_io_lookup_name+0x3c><== NOT EXECUTED
rtems_filesystem_freenode( &loc );
return RTEMS_UNSATISFIED;
}
device_info->device_name = (char *) name;
106dfd: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
106e00: 89 3a mov %edi,(%edx) <== NOT EXECUTED
device_info->device_name_length = strlen( name );
106e02: 31 c0 xor %eax,%eax <== NOT EXECUTED
106e04: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED
106e09: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED
106e0b: f7 d1 not %ecx <== NOT EXECUTED
106e0d: 49 dec %ecx <== NOT EXECUTED
106e0e: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED
device_info->major = the_jnode->info.device.major;
106e11: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED
106e14: 8b 42 50 mov 0x50(%edx),%eax <== NOT EXECUTED
106e17: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
106e1a: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED
device_info->minor = the_jnode->info.device.minor;
106e1d: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED
106e20: 8b 42 54 mov 0x54(%edx),%eax <== NOT EXECUTED
106e23: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
106e26: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
106e29: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
106e2c: 85 c0 test %eax,%eax <== NOT EXECUTED
106e2e: 74 24 je 106e54 <rtems_io_lookup_name+0xec><== NOT EXECUTED
106e30: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
106e33: 85 c0 test %eax,%eax <== NOT EXECUTED
106e35: 74 1d je 106e54 <rtems_io_lookup_name+0xec><== NOT EXECUTED
106e37: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106e3a: 56 push %esi <== NOT EXECUTED
106e3b: ff d0 call *%eax <== NOT EXECUTED
106e3d: 31 c0 xor %eax,%eax <== NOT EXECUTED
106e3f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106e42: eb 84 jmp 106dc8 <rtems_io_lookup_name+0x60><== NOT EXECUTED
106e44: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED
#endif
return RTEMS_SUCCESSFUL;
}
106e49: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
106e4c: 5b pop %ebx <== NOT EXECUTED
106e4d: 5e pop %esi <== NOT EXECUTED
106e4e: 5f pop %edi <== NOT EXECUTED
106e4f: c9 leave <== NOT EXECUTED
106e50: c3 ret <== NOT EXECUTED
106e51: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
device_info->device_name = (char *) name;
device_info->device_name_length = strlen( name );
device_info->major = the_jnode->info.device.major;
device_info->minor = the_jnode->info.device.minor;
rtems_filesystem_freenode( &loc );
106e54: 31 c0 xor %eax,%eax <== NOT EXECUTED
106e56: e9 6d ff ff ff jmp 106dc8 <rtems_io_lookup_name+0x60><== NOT EXECUTED
0010b8d0 <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
)
{
10b8d0: 55 push %ebp
10b8d1: 89 e5 mov %esp,%ebp
10b8d3: 57 push %edi
10b8d4: 56 push %esi
10b8d5: 53 push %ebx
10b8d6: 83 ec 04 sub $0x4,%esp
10b8d9: 8b 55 08 mov 0x8(%ebp),%edx
10b8dc: 8b 75 0c mov 0xc(%ebp),%esi
10b8df: 8b 5d 10 mov 0x10(%ebp),%ebx
/*
* Validate the pointer data and contents passed in
*/
if ( !driver_table )
10b8e2: 85 f6 test %esi,%esi
10b8e4: 0f 84 c6 00 00 00 je 10b9b0 <rtems_io_register_driver+0xe0>
return RTEMS_INVALID_ADDRESS;
if ( !registered_major )
10b8ea: 85 db test %ebx,%ebx
10b8ec: 0f 84 be 00 00 00 je 10b9b0 <rtems_io_register_driver+0xe0>
return RTEMS_INVALID_ADDRESS;
if ( !driver_table->initialization_entry && !driver_table->open_entry )
10b8f2: 8b 06 mov (%esi),%eax
10b8f4: 85 c0 test %eax,%eax
10b8f6: 0f 84 a8 00 00 00 je 10b9a4 <rtems_io_register_driver+0xd4>
return RTEMS_INVALID_ADDRESS;
*registered_major = 0;
10b8fc: c7 03 00 00 00 00 movl $0x0,(%ebx)
/*
* The requested major number is higher than what is configured.
*/
if ( major >= _IO_Number_of_drivers )
10b902: a1 84 19 12 00 mov 0x121984,%eax
10b907: 39 d0 cmp %edx,%eax
10b909: 76 5d jbe 10b968 <rtems_io_register_driver+0x98>
/*
* Test for initialise/open being present to indicate the driver slot is
* in use.
*/
if ( major == 0 ) {
10b90b: 85 d2 test %edx,%edx
10b90d: 75 65 jne 10b974 <rtems_io_register_driver+0xa4>
bool found = false;
for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) {
10b90f: 89 c2 mov %eax,%edx
10b911: 4a dec %edx
10b912: 0f 84 80 00 00 00 je 10b998 <rtems_io_register_driver+0xc8><== NEVER TAKEN
10b918: 8d 04 40 lea (%eax,%eax,2),%eax
10b91b: 8d 04 c5 e8 ff ff ff lea -0x18(,%eax,8),%eax
10b922: 03 05 88 19 12 00 add 0x121988,%eax
10b928: eb 08 jmp 10b932 <rtems_io_register_driver+0x62>
10b92a: 66 90 xchg %ax,%ax
10b92c: 83 e8 18 sub $0x18,%eax
10b92f: 4a dec %edx
10b930: 74 66 je 10b998 <rtems_io_register_driver+0xc8>
10b932: 89 c7 mov %eax,%edi
if ( !_IO_Driver_address_table[major].initialization_entry &&
10b934: 8b 08 mov (%eax),%ecx
10b936: 85 c9 test %ecx,%ecx
10b938: 75 f2 jne 10b92c <rtems_io_register_driver+0x5c>
10b93a: 8b 48 04 mov 0x4(%eax),%ecx
10b93d: 85 c9 test %ecx,%ecx
10b93f: 75 eb jne 10b92c <rtems_io_register_driver+0x5c><== NEVER TAKEN
if ( _IO_Driver_address_table[major].initialization_entry ||
_IO_Driver_address_table[major].open_entry )
return RTEMS_RESOURCE_IN_USE;
_IO_Driver_address_table[major] = *driver_table;
10b941: b8 06 00 00 00 mov $0x6,%eax
10b946: 89 c1 mov %eax,%ecx
10b948: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*registered_major = major;
10b94a: 89 13 mov %edx,(%ebx)
return rtems_io_initialize( major, 0, NULL );
10b94c: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp)
10b953: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp)
10b95a: 89 55 08 mov %edx,0x8(%ebp)
}
10b95d: 59 pop %ecx
10b95e: 5b pop %ebx
10b95f: 5e pop %esi
10b960: 5f pop %edi
10b961: c9 leave
_IO_Driver_address_table[major] = *driver_table;
*registered_major = major;
return rtems_io_initialize( major, 0, NULL );
10b962: e9 f1 fd ff ff jmp 10b758 <rtems_io_initialize>
10b967: 90 nop
*registered_major = 0;
/*
* The requested major number is higher than what is configured.
*/
if ( major >= _IO_Number_of_drivers )
10b968: b8 0a 00 00 00 mov $0xa,%eax
_IO_Driver_address_table[major] = *driver_table;
*registered_major = major;
return rtems_io_initialize( major, 0, NULL );
}
10b96d: 5a pop %edx
10b96e: 5b pop %ebx
10b96f: 5e pop %esi
10b970: 5f pop %edi
10b971: c9 leave
10b972: c3 ret
10b973: 90 nop
if ( !found )
return RTEMS_TOO_MANY;
}
if ( _IO_Driver_address_table[major].initialization_entry ||
10b974: 8d 04 52 lea (%edx,%edx,2),%eax
10b977: 8d 3c c5 00 00 00 00 lea 0x0(,%eax,8),%edi
10b97e: 03 3d 88 19 12 00 add 0x121988,%edi
10b984: 8b 07 mov (%edi),%eax
10b986: 85 c0 test %eax,%eax
10b988: 74 32 je 10b9bc <rtems_io_register_driver+0xec><== NEVER TAKEN
_IO_Driver_address_table[major] = *driver_table;
*registered_major = major;
return rtems_io_initialize( major, 0, NULL );
10b98a: b8 0c 00 00 00 mov $0xc,%eax
}
10b98f: 5a pop %edx
10b990: 5b pop %ebx
10b991: 5e pop %esi
10b992: 5f pop %edi
10b993: c9 leave
10b994: c3 ret
10b995: 8d 76 00 lea 0x0(%esi),%esi
_IO_Driver_address_table[major] = *driver_table;
*registered_major = major;
return rtems_io_initialize( major, 0, NULL );
10b998: b8 05 00 00 00 mov $0x5,%eax
}
10b99d: 5a pop %edx
10b99e: 5b pop %ebx
10b99f: 5e pop %esi
10b9a0: 5f pop %edi
10b9a1: c9 leave
10b9a2: c3 ret
10b9a3: 90 nop
return RTEMS_INVALID_ADDRESS;
if ( !registered_major )
return RTEMS_INVALID_ADDRESS;
if ( !driver_table->initialization_entry && !driver_table->open_entry )
10b9a4: 8b 7e 04 mov 0x4(%esi),%edi
10b9a7: 85 ff test %edi,%edi
10b9a9: 0f 85 4d ff ff ff jne 10b8fc <rtems_io_register_driver+0x2c><== NEVER TAKEN
10b9af: 90 nop
_IO_Driver_address_table[major] = *driver_table;
*registered_major = major;
return rtems_io_initialize( major, 0, NULL );
10b9b0: b8 09 00 00 00 mov $0x9,%eax
}
10b9b5: 5a pop %edx
10b9b6: 5b pop %ebx
10b9b7: 5e pop %esi
10b9b8: 5f pop %edi
10b9b9: c9 leave
10b9ba: c3 ret
10b9bb: 90 nop
if ( !found )
return RTEMS_TOO_MANY;
}
if ( _IO_Driver_address_table[major].initialization_entry ||
10b9bc: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED
10b9bf: 85 c0 test %eax,%eax <== NOT EXECUTED
10b9c1: 75 c7 jne 10b98a <rtems_io_register_driver+0xba><== NOT EXECUTED
10b9c3: e9 79 ff ff ff jmp 10b941 <rtems_io_register_driver+0x71><== NOT EXECUTED
0010b9c8 <rtems_io_unregister_driver>:
*/
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
10b9c8: 55 push %ebp
10b9c9: 89 e5 mov %esp,%ebp
10b9cb: 57 push %edi
10b9cc: 83 ec 04 sub $0x4,%esp
10b9cf: 8b 45 08 mov 0x8(%ebp),%eax
if ( major < _IO_Number_of_drivers ) {
10b9d2: 39 05 84 19 12 00 cmp %eax,0x121984
10b9d8: 77 0a ja 10b9e4 <rtems_io_unregister_driver+0x1c><== ALWAYS TAKEN
10b9da: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED
sizeof( rtems_driver_address_table )
);
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
}
10b9df: 5a pop %edx <== NOT EXECUTED
10b9e0: 5f pop %edi <== NOT EXECUTED
10b9e1: c9 leave <== NOT EXECUTED
10b9e2: c3 ret <== NOT EXECUTED
10b9e3: 90 nop <== NOT EXECUTED
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
if ( major < _IO_Number_of_drivers ) {
memset(
10b9e4: 8d 3c 40 lea (%eax,%eax,2),%edi
10b9e7: c1 e7 03 shl $0x3,%edi
10b9ea: 03 3d 88 19 12 00 add 0x121988,%edi
10b9f0: b9 18 00 00 00 mov $0x18,%ecx
10b9f5: 31 c0 xor %eax,%eax
10b9f7: f3 aa rep stos %al,%es:(%edi)
10b9f9: 31 c0 xor %eax,%eax
sizeof( rtems_driver_address_table )
);
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
}
10b9fb: 5a pop %edx
10b9fc: 5f pop %edi
10b9fd: c9 leave
10b9fe: c3 ret
0010c920 <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)
{
10c920: 55 push %ebp
10c921: 89 e5 mov %esp,%ebp
10c923: 57 push %edi
10c924: 56 push %esi
10c925: 53 push %ebx
10c926: 83 ec 0c sub $0xc,%esp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
10c929: 8b 45 08 mov 0x8(%ebp),%eax
10c92c: 85 c0 test %eax,%eax
10c92e: 74 47 je 10c977 <rtems_iterate_over_all_threads+0x57><== NEVER TAKEN
return;
10c930: 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 ] )
10c935: 8b 04 bd 4c a6 12 00 mov 0x12a64c(,%edi,4),%eax
10c93c: 85 c0 test %eax,%eax
10c93e: 74 31 je 10c971 <rtems_iterate_over_all_threads+0x51>
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
10c940: 8b 70 04 mov 0x4(%eax),%esi
if ( information ) {
10c943: 85 f6 test %esi,%esi
10c945: 74 2a je 10c971 <rtems_iterate_over_all_threads+0x51><== NEVER TAKEN
for ( i=1 ; i <= information->maximum ; i++ ) {
10c947: 66 83 7e 10 00 cmpw $0x0,0x10(%esi)
10c94c: 74 23 je 10c971 <rtems_iterate_over_all_threads+0x51><== NEVER TAKEN
10c94e: bb 01 00 00 00 mov $0x1,%ebx
10c953: 90 nop
the_thread = (Thread_Control *)information->local_table[ i ];
10c954: 8b 46 1c mov 0x1c(%esi),%eax
10c957: 8b 04 98 mov (%eax,%ebx,4),%eax
if ( !the_thread )
10c95a: 85 c0 test %eax,%eax
10c95c: 74 0a je 10c968 <rtems_iterate_over_all_threads+0x48><== NEVER TAKEN
continue;
(*routine)(the_thread);
10c95e: 83 ec 0c sub $0xc,%esp
10c961: 50 push %eax
10c962: ff 55 08 call *0x8(%ebp)
10c965: 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++ ) {
10c968: 43 inc %ebx
10c969: 0f b7 46 10 movzwl 0x10(%esi),%eax
10c96d: 39 d8 cmp %ebx,%eax
10c96f: 73 e3 jae 10c954 <rtems_iterate_over_all_threads+0x34>
if ( !routine )
return;
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
api_index++ ) {
10c971: 47 inc %edi
if ( !routine )
return;
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
10c972: 83 ff 05 cmp $0x5,%edi
10c975: 75 be jne 10c935 <rtems_iterate_over_all_threads+0x15>
(*routine)(the_thread);
}
}
}
}
10c977: 8d 65 f4 lea -0xc(%ebp),%esp
10c97a: 5b pop %ebx
10c97b: 5e pop %esi
10c97c: 5f pop %edi
10c97d: c9 leave
10c97e: c3 ret
0010e82c <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 )
{
10e82c: 55 push %ebp
10e82d: 89 e5 mov %esp,%ebp
10e82f: 57 push %edi
10e830: 56 push %esi
10e831: 53 push %ebx
10e832: 83 ec 20 sub $0x20,%esp
rtems_libio_t *iop, *next;
rtems_status_code rc;
rtems_id sema;
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
10e835: 6a 00 push $0x0
10e837: 6a 00 push $0x0
10e839: ff 35 d8 e4 11 00 pushl 0x11e4d8
10e83f: e8 ac bb ff ff call 10a3f0 <rtems_semaphore_obtain>
if (rtems_libio_iop_freelist) {
10e844: 8b 15 d4 e4 11 00 mov 0x11e4d4,%edx
10e84a: 83 c4 10 add $0x10,%esp
10e84d: 85 d2 test %edx,%edx
10e84f: 75 1b jne 10e86c <rtems_libio_allocate+0x40>
}
failed:
iop = 0;
done:
10e851: 31 db xor %ebx,%ebx
rtems_semaphore_release( rtems_libio_semaphore );
10e853: 83 ec 0c sub $0xc,%esp
10e856: ff 35 d8 e4 11 00 pushl 0x11e4d8
10e85c: e8 87 bc ff ff call 10a4e8 <rtems_semaphore_release>
return iop;
}
10e861: 89 d8 mov %ebx,%eax
10e863: 8d 65 f4 lea -0xc(%ebp),%esp
10e866: 5b pop %ebx
10e867: 5e pop %esi
10e868: 5f pop %edi
10e869: c9 leave
10e86a: c3 ret
10e86b: 90 nop
rtems_id sema;
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
if (rtems_libio_iop_freelist) {
rc = rtems_semaphore_create(
10e86c: 83 ec 0c sub $0xc,%esp
10e86f: 8d 45 f0 lea -0x10(%ebp),%eax
10e872: 50 push %eax
10e873: 6a 00 push $0x0
10e875: 6a 54 push $0x54
10e877: 6a 01 push $0x1
10e879: 89 d1 mov %edx,%ecx
10e87b: 2b 0d d0 e4 11 00 sub 0x11e4d0,%ecx
10e881: c1 f9 02 sar $0x2,%ecx
10e884: 8d 14 89 lea (%ecx,%ecx,4),%edx
10e887: 8d 14 92 lea (%edx,%edx,4),%edx
10e88a: 89 d0 mov %edx,%eax
10e88c: c1 e0 06 shl $0x6,%eax
10e88f: 29 d0 sub %edx,%eax
10e891: 89 c2 mov %eax,%edx
10e893: c1 e2 0c shl $0xc,%edx
10e896: 01 d0 add %edx,%eax
10e898: 8d 04 81 lea (%ecx,%eax,4),%eax
10e89b: 8d 04 41 lea (%ecx,%eax,2),%eax
10e89e: c1 e0 04 shl $0x4,%eax
10e8a1: 01 c8 add %ecx,%eax
10e8a3: 8d 04 81 lea (%ecx,%eax,4),%eax
10e8a6: 0d 00 49 42 4c or $0x4c424900,%eax
10e8ab: 50 push %eax
10e8ac: e8 bf b8 ff ff call 10a170 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&sema
);
if (rc != RTEMS_SUCCESSFUL)
10e8b1: 83 c4 20 add $0x20,%esp
10e8b4: 85 c0 test %eax,%eax
10e8b6: 75 99 jne 10e851 <rtems_libio_allocate+0x25><== NEVER TAKEN
goto failed;
iop = rtems_libio_iop_freelist;
10e8b8: 8b 1d d4 e4 11 00 mov 0x11e4d4,%ebx
next = iop->data1;
10e8be: 8b 73 28 mov 0x28(%ebx),%esi
(void) memset( iop, 0, sizeof(rtems_libio_t) );
10e8c1: b9 34 00 00 00 mov $0x34,%ecx
10e8c6: 31 d2 xor %edx,%edx
10e8c8: 89 df mov %ebx,%edi
10e8ca: 88 d0 mov %dl,%al
10e8cc: f3 aa rep stos %al,%es:(%edi)
iop->flags = LIBIO_FLAGS_OPEN;
10e8ce: c7 43 0c 00 01 00 00 movl $0x100,0xc(%ebx)
iop->sem = sema;
10e8d5: 8b 55 f0 mov -0x10(%ebp),%edx
10e8d8: 89 53 20 mov %edx,0x20(%ebx)
rtems_libio_iop_freelist = next;
10e8db: 89 35 d4 e4 11 00 mov %esi,0x11e4d4
10e8e1: e9 6d ff ff ff jmp 10e853 <rtems_libio_allocate+0x27>
0010e7d4 <rtems_libio_free>:
*/
void rtems_libio_free(
rtems_libio_t *iop
)
{
10e7d4: 55 push %ebp
10e7d5: 89 e5 mov %esp,%ebp
10e7d7: 53 push %ebx
10e7d8: 83 ec 08 sub $0x8,%esp
10e7db: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
10e7de: 6a 00 push $0x0
10e7e0: 6a 00 push $0x0
10e7e2: ff 35 d8 e4 11 00 pushl 0x11e4d8
10e7e8: e8 03 bc ff ff call 10a3f0 <rtems_semaphore_obtain>
if (iop->sem)
10e7ed: 8b 43 20 mov 0x20(%ebx),%eax
10e7f0: 83 c4 10 add $0x10,%esp
10e7f3: 85 c0 test %eax,%eax
10e7f5: 74 0c je 10e803 <rtems_libio_free+0x2f> <== NEVER TAKEN
rtems_semaphore_delete(iop->sem);
10e7f7: 83 ec 0c sub $0xc,%esp
10e7fa: 50 push %eax
10e7fb: e8 4c bb ff ff call 10a34c <rtems_semaphore_delete>
10e800: 83 c4 10 add $0x10,%esp
iop->flags &= ~LIBIO_FLAGS_OPEN;
10e803: 81 63 0c ff fe ff ff andl $0xfffffeff,0xc(%ebx)
iop->data1 = rtems_libio_iop_freelist;
10e80a: a1 d4 e4 11 00 mov 0x11e4d4,%eax
10e80f: 89 43 28 mov %eax,0x28(%ebx)
rtems_libio_iop_freelist = iop;
10e812: 89 1d d4 e4 11 00 mov %ebx,0x11e4d4
rtems_semaphore_release(rtems_libio_semaphore);
10e818: a1 d8 e4 11 00 mov 0x11e4d8,%eax
10e81d: 89 45 08 mov %eax,0x8(%ebp)
}
10e820: 8b 5d fc mov -0x4(%ebp),%ebx
10e823: c9 leave
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
rtems_semaphore_release(rtems_libio_semaphore);
10e824: e9 bf bc ff ff jmp 10a4e8 <rtems_semaphore_release>
0010713c <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
10713c: 55 push %ebp
10713d: 89 e5 mov %esp,%ebp
10713f: 53 push %ebx
107140: 83 ec 04 sub $0x4,%esp
rtems_status_code rc;
int i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
107143: a1 40 a0 11 00 mov 0x11a040,%eax
107148: 85 c0 test %eax,%eax
10714a: 74 50 je 10719c <rtems_libio_init+0x60>
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
10714c: 83 ec 08 sub $0x8,%esp
10714f: 6a 34 push $0x34
107151: 50 push %eax
107152: e8 65 73 00 00 call 10e4bc <calloc>
107157: 89 c3 mov %eax,%ebx
107159: 89 1d d0 e4 11 00 mov %ebx,0x11e4d0
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
10715f: 83 c4 10 add $0x10,%esp
107162: 85 db test %ebx,%ebx
107164: 74 5e je 1071c4 <rtems_libio_init+0x88> <== NEVER TAKEN
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
107166: 89 1d d4 e4 11 00 mov %ebx,0x11e4d4
for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++)
10716c: 8b 0d 40 a0 11 00 mov 0x11a040,%ecx
107172: 83 f9 01 cmp $0x1,%ecx
107175: 74 1e je 107195 <rtems_libio_init+0x59> <== NEVER TAKEN
107177: 8d 43 34 lea 0x34(%ebx),%eax
10717a: ba 01 00 00 00 mov $0x1,%edx
10717f: 90 nop
iop->data1 = iop + 1;
107180: 89 40 f4 mov %eax,-0xc(%eax)
107183: 42 inc %edx
107184: 83 c0 34 add $0x34,%eax
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++)
107187: 39 ca cmp %ecx,%edx
107189: 75 f5 jne 107180 <rtems_libio_init+0x44>
10718b: 8d 04 52 lea (%edx,%edx,2),%eax
10718e: 8d 04 82 lea (%edx,%eax,4),%eax
107191: 8d 44 83 cc lea -0x34(%ebx,%eax,4),%eax
iop->data1 = iop + 1;
iop->data1 = NULL;
107195: c7 40 28 00 00 00 00 movl $0x0,0x28(%eax)
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
10719c: 83 ec 0c sub $0xc,%esp
10719f: 68 d8 e4 11 00 push $0x11e4d8
1071a4: 6a 00 push $0x0
1071a6: 6a 54 push $0x54
1071a8: 6a 01 push $0x1
1071aa: 68 4f 49 42 4c push $0x4c42494f
1071af: e8 bc 2f 00 00 call 10a170 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
1071b4: 83 c4 20 add $0x20,%esp
1071b7: 85 c0 test %eax,%eax
1071b9: 75 13 jne 1071ce <rtems_libio_init+0x92> <== NEVER TAKEN
/*
* Initialize the base file system infrastructure.
*/
rtems_filesystem_initialize();
}
1071bb: 8b 5d fc mov -0x4(%ebp),%ebx
1071be: c9 leave
/*
* Initialize the base file system infrastructure.
*/
rtems_filesystem_initialize();
1071bf: e9 04 72 00 00 jmp 10e3c8 <rtems_filesystem_initialize>
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
1071c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1071c7: 6a 1a push $0x1a <== NOT EXECUTED
1071c9: e8 b6 38 00 00 call 10aa84 <rtems_fatal_error_occurred><== NOT EXECUTED
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
rtems_fatal_error_occurred( rc );
1071ce: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1071d1: 50 push %eax <== NOT EXECUTED
1071d2: e8 ad 38 00 00 call 10aa84 <rtems_fatal_error_occurred><== NOT EXECUTED
0010e70c <rtems_libio_is_file_open>:
*/
int rtems_libio_is_file_open(
void *node_access
)
{
10e70c: 55 push %ebp <== NOT EXECUTED
10e70d: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10e70f: 53 push %ebx <== NOT EXECUTED
10e710: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10e713: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
rtems_libio_t *iop;
int result=0;
int i;
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
10e716: 6a 00 push $0x0 <== NOT EXECUTED
10e718: 6a 00 push $0x0 <== NOT EXECUTED
10e71a: ff 35 d8 e4 11 00 pushl 0x11e4d8 <== NOT EXECUTED
10e720: e8 cb bc ff ff call 10a3f0 <rtems_semaphore_obtain><== NOT EXECUTED
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
10e725: 8b 15 d0 e4 11 00 mov 0x11e4d0,%edx <== NOT EXECUTED
10e72b: 8b 0d 40 a0 11 00 mov 0x11a040,%ecx <== NOT EXECUTED
10e731: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10e734: 85 c9 test %ecx,%ecx <== NOT EXECUTED
10e736: 74 17 je 10e74f <rtems_libio_is_file_open+0x43><== NOT EXECUTED
10e738: 31 c0 xor %eax,%eax <== NOT EXECUTED
10e73a: eb 03 jmp 10e73f <rtems_libio_is_file_open+0x33><== NOT EXECUTED
10e73c: 83 c2 34 add $0x34,%edx <== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {
10e73f: f6 42 0d 01 testb $0x1,0xd(%edx) <== NOT EXECUTED
10e743: 74 05 je 10e74a <rtems_libio_is_file_open+0x3e><== NOT EXECUTED
/*
* Check if this node is under the file system that we
* are trying to dismount.
*/
if ( iop->pathinfo.node_access == node_access ) {
10e745: 39 5a 10 cmp %ebx,0x10(%edx) <== NOT EXECUTED
10e748: 74 1e je 10e768 <rtems_libio_is_file_open+0x5c><== NOT EXECUTED
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
10e74a: 40 inc %eax <== NOT EXECUTED
10e74b: 39 c8 cmp %ecx,%eax <== NOT EXECUTED
10e74d: 72 ed jb 10e73c <rtems_libio_is_file_open+0x30><== NOT EXECUTED
10e74f: 31 db xor %ebx,%ebx <== NOT EXECUTED
break;
}
}
}
rtems_semaphore_release( rtems_libio_semaphore );
10e751: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10e754: ff 35 d8 e4 11 00 pushl 0x11e4d8 <== NOT EXECUTED
10e75a: e8 89 bd ff ff call 10a4e8 <rtems_semaphore_release><== NOT EXECUTED
return result;
}
10e75f: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10e761: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10e764: c9 leave <== NOT EXECUTED
10e765: c3 ret <== NOT EXECUTED
10e766: 66 90 xchg %ax,%ax <== NOT EXECUTED
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
10e768: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED
10e76d: eb e2 jmp 10e751 <rtems_libio_is_file_open+0x45><== NOT EXECUTED
0010e770 <rtems_libio_is_open_files_in_fs>:
*/
int rtems_libio_is_open_files_in_fs(
rtems_filesystem_mount_table_entry_t * fs_mt_entry
)
{
10e770: 55 push %ebp <== NOT EXECUTED
10e771: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10e773: 53 push %ebx <== NOT EXECUTED
10e774: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10e777: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
rtems_libio_t *iop;
int result = 0;
int i;
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
10e77a: 6a 00 push $0x0 <== NOT EXECUTED
10e77c: 6a 00 push $0x0 <== NOT EXECUTED
10e77e: ff 35 d8 e4 11 00 pushl 0x11e4d8 <== NOT EXECUTED
10e784: e8 67 bc ff ff call 10a3f0 <rtems_semaphore_obtain><== NOT EXECUTED
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
10e789: 8b 15 d0 e4 11 00 mov 0x11e4d0,%edx <== NOT EXECUTED
10e78f: 8b 0d 40 a0 11 00 mov 0x11a040,%ecx <== NOT EXECUTED
10e795: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10e798: 85 c9 test %ecx,%ecx <== NOT EXECUTED
10e79a: 74 17 je 10e7b3 <rtems_libio_is_open_files_in_fs+0x43><== NOT EXECUTED
10e79c: 31 c0 xor %eax,%eax <== NOT EXECUTED
10e79e: eb 03 jmp 10e7a3 <rtems_libio_is_open_files_in_fs+0x33><== NOT EXECUTED
10e7a0: 83 c2 34 add $0x34,%edx <== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {
10e7a3: f6 42 0d 01 testb $0x1,0xd(%edx) <== NOT EXECUTED
10e7a7: 74 05 je 10e7ae <rtems_libio_is_open_files_in_fs+0x3e><== NOT EXECUTED
/*
* Check if this node is under the file system that we
* are trying to dismount.
*/
if ( iop->pathinfo.mt_entry == fs_mt_entry ) {
10e7a9: 39 5a 1c cmp %ebx,0x1c(%edx) <== NOT EXECUTED
10e7ac: 74 1e je 10e7cc <rtems_libio_is_open_files_in_fs+0x5c><== NOT EXECUTED
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
10e7ae: 40 inc %eax <== NOT EXECUTED
10e7af: 39 c8 cmp %ecx,%eax <== NOT EXECUTED
10e7b1: 72 ed jb 10e7a0 <rtems_libio_is_open_files_in_fs+0x30><== NOT EXECUTED
10e7b3: 31 db xor %ebx,%ebx <== NOT EXECUTED
break;
}
}
}
rtems_semaphore_release( rtems_libio_semaphore );
10e7b5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10e7b8: ff 35 d8 e4 11 00 pushl 0x11e4d8 <== NOT EXECUTED
10e7be: e8 25 bd ff ff call 10a4e8 <rtems_semaphore_release><== NOT EXECUTED
return result;
}
10e7c3: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10e7c5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10e7c8: c9 leave <== NOT EXECUTED
10e7c9: c3 ret <== NOT EXECUTED
10e7ca: 66 90 xchg %ax,%ax <== NOT EXECUTED
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
10e7cc: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED
10e7d1: eb e2 jmp 10e7b5 <rtems_libio_is_open_files_in_fs+0x45><== NOT EXECUTED
0010e6cc <rtems_libio_to_fcntl_flags>:
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
10e6cc: 55 push %ebp <== NOT EXECUTED
10e6cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10e6cf: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
10e6d2: 89 d0 mov %edx,%eax <== NOT EXECUTED
10e6d4: 83 e0 06 and $0x6,%eax <== NOT EXECUTED
10e6d7: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED
10e6da: 74 2c je 10e708 <rtems_libio_to_fcntl_flags+0x3c><== NOT EXECUTED
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
10e6dc: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
10e6df: 75 23 jne 10e704 <rtems_libio_to_fcntl_flags+0x38><== NOT EXECUTED
10e6e1: 89 d0 mov %edx,%eax <== NOT EXECUTED
10e6e3: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED
10e6e6: 83 e0 01 and $0x1,%eax <== 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 ) {
10e6e9: f6 c2 01 test $0x1,%dl <== NOT EXECUTED
10e6ec: 74 03 je 10e6f1 <rtems_libio_to_fcntl_flags+0x25><== NOT EXECUTED
fcntl_flags |= O_NONBLOCK;
10e6ee: 80 cc 40 or $0x40,%ah <== NOT EXECUTED
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
10e6f1: f6 c6 02 test $0x2,%dh <== NOT EXECUTED
10e6f4: 74 03 je 10e6f9 <rtems_libio_to_fcntl_flags+0x2d><== NOT EXECUTED
fcntl_flags |= O_APPEND;
10e6f6: 83 c8 08 or $0x8,%eax <== NOT EXECUTED
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
10e6f9: 80 e6 04 and $0x4,%dh <== NOT EXECUTED
10e6fc: 74 03 je 10e701 <rtems_libio_to_fcntl_flags+0x35><== NOT EXECUTED
fcntl_flags |= O_CREAT;
10e6fe: 80 cc 02 or $0x2,%ah <== NOT EXECUTED
}
return fcntl_flags;
}
10e701: c9 leave <== NOT EXECUTED
10e702: c3 ret <== NOT EXECUTED
10e703: 90 nop <== NOT EXECUTED
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
10e704: 31 c0 xor %eax,%eax <== NOT EXECUTED
10e706: eb e1 jmp 10e6e9 <rtems_libio_to_fcntl_flags+0x1d><== NOT EXECUTED
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
10e708: b0 02 mov $0x2,%al <== NOT EXECUTED
10e70a: eb dd jmp 10e6e9 <rtems_libio_to_fcntl_flags+0x1d><== NOT EXECUTED
001094e0 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
1094e0: 55 push %ebp
1094e1: 89 e5 mov %esp,%ebp
1094e3: 56 push %esi
1094e4: 53 push %ebx
1094e5: 8b 75 08 mov 0x8(%ebp),%esi
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
1094e8: 85 f6 test %esi,%esi
1094ea: 74 55 je 109541 <rtems_memalign+0x61>
return EINVAL;
*pointer = NULL;
1094ec: 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()) &&
1094f2: 83 3d c4 3e 12 00 03 cmpl $0x3,0x123ec4
1094f9: 74 3d je 109538 <rtems_memalign+0x58> <== ALWAYS TAKEN
/*
*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
1094fb: e8 d0 f0 ff ff call 1085d0 <malloc_deferred_frees_process>
/*
* Perform the aligned allocation requested
*/
return_this = _Protected_heap_Allocate_aligned(
109500: 50 push %eax
109501: ff 75 0c pushl 0xc(%ebp)
109504: ff 75 10 pushl 0x10(%ebp)
109507: 68 a0 3b 12 00 push $0x123ba0
10950c: e8 e3 46 00 00 call 10dbf4 <_Protected_heap_Allocate_aligned>
109511: 89 c3 mov %eax,%ebx
&RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
109513: 83 c4 10 add $0x10,%esp
109516: 85 c0 test %eax,%eax
109518: 74 36 je 109550 <rtems_memalign+0x70>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
10951a: a1 e4 1b 12 00 mov 0x121be4,%eax
10951f: 85 c0 test %eax,%eax
109521: 74 0a je 10952d <rtems_memalign+0x4d> <== ALWAYS TAKEN
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
109523: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109526: 56 push %esi <== NOT EXECUTED
109527: ff 50 04 call *0x4(%eax) <== NOT EXECUTED
10952a: 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;
10952d: 89 1e mov %ebx,(%esi)
10952f: 31 c0 xor %eax,%eax
return 0;
}
109531: 8d 65 f8 lea -0x8(%ebp),%esp
109534: 5b pop %ebx
109535: 5e pop %esi
109536: c9 leave
109537: c3 ret
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
109538: e8 3b f0 ff ff call 108578 <malloc_is_system_state_OK>
10953d: 84 c0 test %al,%al
10953f: 75 ba jne 1094fb <rtems_memalign+0x1b> <== ALWAYS TAKEN
if (rtems_malloc_boundary_helpers)
(*rtems_malloc_boundary_helpers->at_malloc)(return_this, size);
#endif
*pointer = return_this;
return 0;
109541: b8 16 00 00 00 mov $0x16,%eax
}
109546: 8d 65 f8 lea -0x8(%ebp),%esp
109549: 5b pop %ebx
10954a: 5e pop %esi
10954b: c9 leave
10954c: c3 ret
10954d: 8d 76 00 lea 0x0(%esi),%esi
return_this = _Protected_heap_Allocate_aligned(
&RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
109550: b8 0c 00 00 00 mov $0xc,%eax
109555: eb da jmp 109531 <rtems_memalign+0x51>
0011236c <rtems_message_queue_broadcast>:
Objects_Id id,
const void *buffer,
size_t size,
uint32_t *count
)
{
11236c: 55 push %ebp
11236d: 89 e5 mov %esp,%ebp
11236f: 57 push %edi
112370: 56 push %esi
112371: 53 push %ebx
112372: 83 ec 1c sub $0x1c,%esp
112375: 8b 7d 08 mov 0x8(%ebp),%edi
112378: 8b 75 0c mov 0xc(%ebp),%esi
11237b: 8b 5d 14 mov 0x14(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status core_status;
if ( !buffer )
11237e: 85 f6 test %esi,%esi
112380: 74 62 je 1123e4 <rtems_message_queue_broadcast+0x78>
return RTEMS_INVALID_ADDRESS;
if ( !count )
112382: 85 db test %ebx,%ebx
112384: 74 5e je 1123e4 <rtems_message_queue_broadcast+0x78>
* @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,
112386: 51 push %ecx
112387: 8d 45 f0 lea -0x10(%ebp),%eax
11238a: 50 push %eax
11238b: 57 push %edi
11238c: 68 60 5d 13 00 push $0x135d60
112391: e8 4a 48 00 00 call 116be0 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
112396: 83 c4 10 add $0x10,%esp
112399: 8b 55 f0 mov -0x10(%ebp),%edx
11239c: 85 d2 test %edx,%edx
11239e: 74 10 je 1123b0 <rtems_message_queue_broadcast+0x44>
1123a0: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1123a5: 8d 65 f4 lea -0xc(%ebp),%esp
1123a8: 5b pop %ebx
1123a9: 5e pop %esi
1123aa: 5f pop %edi
1123ab: c9 leave
1123ac: c3 ret
1123ad: 8d 76 00 lea 0x0(%esi),%esi
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
core_status = _CORE_message_queue_Broadcast(
1123b0: 83 ec 08 sub $0x8,%esp
1123b3: 53 push %ebx
1123b4: 6a 00 push $0x0
1123b6: 57 push %edi
1123b7: ff 75 10 pushl 0x10(%ebp)
1123ba: 56 push %esi
1123bb: 83 c0 14 add $0x14,%eax
1123be: 50 push %eax
1123bf: e8 78 31 00 00 call 11553c <_CORE_message_queue_Broadcast>
1123c4: 89 c3 mov %eax,%ebx
NULL,
#endif
count
);
_Thread_Enable_dispatch();
1123c6: 83 c4 20 add $0x20,%esp
1123c9: e8 56 50 00 00 call 117424 <_Thread_Enable_dispatch>
return
1123ce: 83 ec 0c sub $0xc,%esp
1123d1: 53 push %ebx
1123d2: e8 5d 03 00 00 call 112734 <_Message_queue_Translate_core_message_queue_return_code>
1123d7: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1123da: 8d 65 f4 lea -0xc(%ebp),%esp
1123dd: 5b pop %ebx
1123de: 5e pop %esi
1123df: 5f pop %edi
1123e0: c9 leave
1123e1: c3 ret
1123e2: 66 90 xchg %ax,%ax
#endif
count
);
_Thread_Enable_dispatch();
return
1123e4: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1123e9: 8d 65 f4 lea -0xc(%ebp),%esp
1123ec: 5b pop %ebx
1123ed: 5e pop %esi
1123ee: 5f pop %edi
1123ef: c9 leave
1123f0: c3 ret
001123f4 <rtems_message_queue_create>:
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
Objects_Id *id
)
{
1123f4: 55 push %ebp
1123f5: 89 e5 mov %esp,%ebp
1123f7: 56 push %esi
1123f8: 53 push %ebx
1123f9: 83 ec 10 sub $0x10,%esp
1123fc: 8b 75 08 mov 0x8(%ebp),%esi
CORE_message_queue_Attributes the_msgq_attributes;
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !rtems_is_name_valid( name ) )
1123ff: 85 f6 test %esi,%esi
112401: 74 31 je 112434 <rtems_message_queue_create+0x40>
return RTEMS_INVALID_NAME;
if ( !id )
112403: 8b 4d 18 mov 0x18(%ebp),%ecx
112406: 85 c9 test %ecx,%ecx
112408: 0f 84 92 00 00 00 je 1124a0 <rtems_message_queue_create+0xac><== NEVER TAKEN
if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
11240e: 8b 55 0c mov 0xc(%ebp),%edx
112411: 85 d2 test %edx,%edx
112413: 74 13 je 112428 <rtems_message_queue_create+0x34><== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
112415: 8b 45 10 mov 0x10(%ebp),%eax
112418: 85 c0 test %eax,%eax
11241a: 75 24 jne 112440 <rtems_message_queue_create+0x4c><== ALWAYS TAKEN
11241c: b8 08 00 00 00 mov $0x8,%eax <== NOT EXECUTED
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
112421: 8d 65 f8 lea -0x8(%ebp),%esp
112424: 5b pop %ebx
112425: 5e pop %esi
112426: c9 leave
112427: c3 ret
if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
112428: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
11242d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
112430: 5b pop %ebx <== NOT EXECUTED
112431: 5e pop %esi <== NOT EXECUTED
112432: c9 leave <== NOT EXECUTED
112433: c3 ret <== NOT EXECUTED
CORE_message_queue_Attributes the_msgq_attributes;
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !rtems_is_name_valid( name ) )
112434: b8 03 00 00 00 mov $0x3,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
112439: 8d 65 f8 lea -0x8(%ebp),%esp
11243c: 5b pop %ebx
11243d: 5e pop %esi
11243e: c9 leave
11243f: c3 ret
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
112440: a1 38 5a 13 00 mov 0x135a38,%eax
112445: 40 inc %eax
112446: a3 38 5a 13 00 mov %eax,0x135a38
#endif
#endif
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
11244b: e8 dc 7d 00 00 call 11a22c <_Message_queue_Allocate>
112450: 89 c3 mov %eax,%ebx
if ( !the_message_queue ) {
112452: 85 c0 test %eax,%eax
112454: 74 7a je 1124d0 <rtems_message_queue_create+0xdc>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_message_queue->attribute_set = attribute_set;
112456: 8b 45 14 mov 0x14(%ebp),%eax
112459: 89 43 10 mov %eax,0x10(%ebx)
if (_Attributes_Is_priority( attribute_set ) )
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
11245c: a8 04 test $0x4,%al
11245e: 0f 95 c0 setne %al
112461: 0f b6 c0 movzbl %al,%eax
112464: 89 45 f4 mov %eax,-0xc(%ebp)
else
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
if ( ! _CORE_message_queue_Initialize(
112467: ff 75 10 pushl 0x10(%ebp)
11246a: ff 75 0c pushl 0xc(%ebp)
11246d: 8d 45 f4 lea -0xc(%ebp),%eax
112470: 50 push %eax
112471: 8d 43 14 lea 0x14(%ebx),%eax
112474: 50 push %eax
112475: e8 e2 31 00 00 call 11565c <_CORE_message_queue_Initialize>
11247a: 83 c4 10 add $0x10,%esp
11247d: 84 c0 test %al,%al
11247f: 75 2b jne 1124ac <rtems_message_queue_create+0xb8>
* @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,
112481: 83 ec 08 sub $0x8,%esp
112484: 53 push %ebx
112485: 68 60 5d 13 00 push $0x135d60
11248a: e8 dd 45 00 00 call 116a6c <_Objects_Free>
_Objects_MP_Close(
&_Message_queue_Information, the_message_queue->Object.id);
#endif
_Message_queue_Free( the_message_queue );
_Thread_Enable_dispatch();
11248f: e8 90 4f 00 00 call 117424 <_Thread_Enable_dispatch>
112494: b8 0d 00 00 00 mov $0xd,%eax
112499: 83 c4 10 add $0x10,%esp
11249c: eb 83 jmp 112421 <rtems_message_queue_create+0x2d>
11249e: 66 90 xchg %ax,%ax
#endif
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
1124a0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
1124a5: e9 77 ff ff ff jmp 112421 <rtems_message_queue_create+0x2d><== NOT EXECUTED
1124aa: 66 90 xchg %ax,%ax <== NOT EXECUTED
1124ac: 8b 4b 08 mov 0x8(%ebx),%ecx
1124af: 0f b7 d1 movzwl %cx,%edx
1124b2: a1 7c 5d 13 00 mov 0x135d7c,%eax
1124b7: 89 1c 90 mov %ebx,(%eax,%edx,4)
1124ba: 89 73 0c mov %esi,0xc(%ebx)
&_Message_queue_Information,
&the_message_queue->Object,
(Objects_Name) name
);
*id = the_message_queue->Object.id;
1124bd: 8b 45 18 mov 0x18(%ebp),%eax
1124c0: 89 08 mov %ecx,(%eax)
name,
0
);
#endif
_Thread_Enable_dispatch();
1124c2: e8 5d 4f 00 00 call 117424 <_Thread_Enable_dispatch>
1124c7: 31 c0 xor %eax,%eax
1124c9: e9 53 ff ff ff jmp 112421 <rtems_message_queue_create+0x2d>
1124ce: 66 90 xchg %ax,%ax
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
if ( !the_message_queue ) {
_Thread_Enable_dispatch();
1124d0: e8 4f 4f 00 00 call 117424 <_Thread_Enable_dispatch>
1124d5: b8 05 00 00 00 mov $0x5,%eax
1124da: e9 42 ff ff ff jmp 112421 <rtems_message_queue_create+0x2d>
001124e0 <rtems_message_queue_delete>:
*/
rtems_status_code rtems_message_queue_delete(
Objects_Id id
)
{
1124e0: 55 push %ebp
1124e1: 89 e5 mov %esp,%ebp
1124e3: 53 push %ebx
1124e4: 83 ec 18 sub $0x18,%esp
* @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,
1124e7: 8d 45 f8 lea -0x8(%ebp),%eax
1124ea: 50 push %eax
1124eb: ff 75 08 pushl 0x8(%ebp)
1124ee: 68 60 5d 13 00 push $0x135d60
1124f3: e8 e8 46 00 00 call 116be0 <_Objects_Get>
1124f8: 89 c3 mov %eax,%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
1124fa: 83 c4 10 add $0x10,%esp
1124fd: 8b 4d f8 mov -0x8(%ebp),%ecx
112500: 85 c9 test %ecx,%ecx
112502: 75 3c jne 112540 <rtems_message_queue_delete+0x60>
case OBJECTS_LOCAL:
_Objects_Close( &_Message_queue_Information,
112504: 83 ec 08 sub $0x8,%esp
112507: 50 push %eax
112508: 68 60 5d 13 00 push $0x135d60
11250d: e8 1a 42 00 00 call 11672c <_Objects_Close>
&the_message_queue->Object );
_CORE_message_queue_Close(
112512: 83 c4 0c add $0xc,%esp
112515: 6a 05 push $0x5
112517: 6a 00 push $0x0
112519: 8d 43 14 lea 0x14(%ebx),%eax
11251c: 50 push %eax
11251d: e8 96 30 00 00 call 1155b8 <_CORE_message_queue_Close>
* @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,
112522: 58 pop %eax
112523: 5a pop %edx
112524: 53 push %ebx
112525: 68 60 5d 13 00 push $0x135d60
11252a: e8 3d 45 00 00 call 116a6c <_Objects_Free>
0, /* Not used */
0
);
}
#endif
_Thread_Enable_dispatch();
11252f: e8 f0 4e 00 00 call 117424 <_Thread_Enable_dispatch>
112534: 31 c0 xor %eax,%eax
112536: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112539: 8b 5d fc mov -0x4(%ebp),%ebx
11253c: c9 leave
11253d: c3 ret
11253e: 66 90 xchg %ax,%ax
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
112540: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112545: 8b 5d fc mov -0x4(%ebp),%ebx
112548: c9 leave
112549: c3 ret
0011254c <rtems_message_queue_flush>:
rtems_status_code rtems_message_queue_flush(
Objects_Id id,
uint32_t *count
)
{
11254c: 55 push %ebp
11254d: 89 e5 mov %esp,%ebp
11254f: 53 push %ebx
112550: 83 ec 14 sub $0x14,%esp
112553: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
112556: 85 db test %ebx,%ebx
112558: 74 46 je 1125a0 <rtems_message_queue_flush+0x54><== 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,
11255a: 51 push %ecx
11255b: 8d 45 f8 lea -0x8(%ebp),%eax
11255e: 50 push %eax
11255f: ff 75 08 pushl 0x8(%ebp)
112562: 68 60 5d 13 00 push $0x135d60
112567: e8 74 46 00 00 call 116be0 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
11256c: 83 c4 10 add $0x10,%esp
11256f: 8b 55 f8 mov -0x8(%ebp),%edx
112572: 85 d2 test %edx,%edx
112574: 74 0a je 112580 <rtems_message_queue_flush+0x34>
112576: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11257b: 8b 5d fc mov -0x4(%ebp),%ebx
11257e: c9 leave
11257f: c3 ret
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
*count = _CORE_message_queue_Flush( &the_message_queue->message_queue );
112580: 83 ec 0c sub $0xc,%esp
112583: 83 c0 14 add $0x14,%eax
112586: 50 push %eax
112587: e8 68 30 00 00 call 1155f4 <_CORE_message_queue_Flush>
11258c: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
11258e: e8 91 4e 00 00 call 117424 <_Thread_Enable_dispatch>
112593: 31 c0 xor %eax,%eax
112595: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112598: 8b 5d fc mov -0x4(%ebp),%ebx
11259b: c9 leave
11259c: c3 ret
11259d: 8d 76 00 lea 0x0(%esi),%esi
)
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
1125a0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1125a5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
1125a8: c9 leave <== NOT EXECUTED
1125a9: c3 ret <== NOT EXECUTED
001125ac <rtems_message_queue_get_number_pending>:
rtems_status_code rtems_message_queue_get_number_pending(
Objects_Id id,
uint32_t *count
)
{
1125ac: 55 push %ebp
1125ad: 89 e5 mov %esp,%ebp
1125af: 53 push %ebx
1125b0: 83 ec 14 sub $0x14,%esp
1125b3: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
1125b6: 85 db test %ebx,%ebx
1125b8: 74 3a je 1125f4 <rtems_message_queue_get_number_pending+0x48><== NEVER TAKEN
1125ba: 51 push %ecx
1125bb: 8d 45 f8 lea -0x8(%ebp),%eax
1125be: 50 push %eax
1125bf: ff 75 08 pushl 0x8(%ebp)
1125c2: 68 60 5d 13 00 push $0x135d60
1125c7: e8 14 46 00 00 call 116be0 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
1125cc: 83 c4 10 add $0x10,%esp
1125cf: 8b 55 f8 mov -0x8(%ebp),%edx
1125d2: 85 d2 test %edx,%edx
1125d4: 74 0a je 1125e0 <rtems_message_queue_get_number_pending+0x34>
1125d6: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1125db: 8b 5d fc mov -0x4(%ebp),%ebx
1125de: c9 leave
1125df: c3 ret
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
*count = the_message_queue->message_queue.number_of_pending_messages;
1125e0: 8b 40 5c mov 0x5c(%eax),%eax
1125e3: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
1125e5: e8 3a 4e 00 00 call 117424 <_Thread_Enable_dispatch>
1125ea: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1125ec: 8b 5d fc mov -0x4(%ebp),%ebx
1125ef: c9 leave
1125f0: c3 ret
1125f1: 8d 76 00 lea 0x0(%esi),%esi
)
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
1125f4: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1125f9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
1125fc: c9 leave <== NOT EXECUTED
1125fd: c3 ret <== NOT EXECUTED
00112624 <rtems_message_queue_receive>:
void *buffer,
size_t *size,
rtems_option option_set,
rtems_interval timeout
)
{
112624: 55 push %ebp
112625: 89 e5 mov %esp,%ebp
112627: 57 push %edi
112628: 56 push %esi
112629: 53 push %ebx
11262a: 83 ec 1c sub $0x1c,%esp
11262d: 8b 7d 0c mov 0xc(%ebp),%edi
112630: 8b 75 10 mov 0x10(%ebp),%esi
112633: 8b 5d 14 mov 0x14(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
bool wait;
if ( !buffer )
112636: 85 ff test %edi,%edi
112638: 74 6e je 1126a8 <rtems_message_queue_receive+0x84>
return RTEMS_INVALID_ADDRESS;
if ( !size )
11263a: 85 f6 test %esi,%esi
11263c: 74 6a je 1126a8 <rtems_message_queue_receive+0x84>
11263e: 51 push %ecx
11263f: 8d 45 f0 lea -0x10(%ebp),%eax
112642: 50 push %eax
112643: ff 75 08 pushl 0x8(%ebp)
112646: 68 60 5d 13 00 push $0x135d60
11264b: e8 90 45 00 00 call 116be0 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
112650: 83 c4 10 add $0x10,%esp
112653: 8b 55 f0 mov -0x10(%ebp),%edx
112656: 85 d2 test %edx,%edx
112658: 75 3e jne 112698 <rtems_message_queue_receive+0x74>
if ( _Options_Is_no_wait( option_set ) )
wait = false;
else
wait = true;
_CORE_message_queue_Seize(
11265a: 83 ec 08 sub $0x8,%esp
11265d: ff 75 18 pushl 0x18(%ebp)
112660: 83 f3 01 xor $0x1,%ebx
112663: 83 e3 01 and $0x1,%ebx
112666: 53 push %ebx
112667: 56 push %esi
112668: 57 push %edi
112669: ff 70 08 pushl 0x8(%eax)
11266c: 83 c0 14 add $0x14,%eax
11266f: 50 push %eax
112670: e8 9b 30 00 00 call 115710 <_CORE_message_queue_Seize>
buffer,
size,
wait,
timeout
);
_Thread_Enable_dispatch();
112675: 83 c4 20 add $0x20,%esp
112678: e8 a7 4d 00 00 call 117424 <_Thread_Enable_dispatch>
return _Message_queue_Translate_core_message_queue_return_code(
11267d: 83 ec 0c sub $0xc,%esp
112680: a1 fc 5a 13 00 mov 0x135afc,%eax
112685: ff 70 34 pushl 0x34(%eax)
112688: e8 a7 00 00 00 call 112734 <_Message_queue_Translate_core_message_queue_return_code>
11268d: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112690: 8d 65 f4 lea -0xc(%ebp),%esp
112693: 5b pop %ebx
112694: 5e pop %esi
112695: 5f pop %edi
112696: c9 leave
112697: c3 ret
if ( !size )
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
112698: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11269d: 8d 65 f4 lea -0xc(%ebp),%esp
1126a0: 5b pop %ebx
1126a1: 5e pop %esi
1126a2: 5f pop %edi
1126a3: c9 leave
1126a4: c3 ret
1126a5: 8d 76 00 lea 0x0(%esi),%esi
size,
wait,
timeout
);
_Thread_Enable_dispatch();
return _Message_queue_Translate_core_message_queue_return_code(
1126a8: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1126ad: 8d 65 f4 lea -0xc(%ebp),%esp
1126b0: 5b pop %ebx
1126b1: 5e pop %esi
1126b2: 5f pop %edi
1126b3: c9 leave
1126b4: c3 ret
0010a0e4 <rtems_message_queue_send>:
rtems_status_code rtems_message_queue_send(
Objects_Id id,
const void *buffer,
size_t size
)
{
10a0e4: 55 push %ebp
10a0e5: 89 e5 mov %esp,%ebp
10a0e7: 56 push %esi
10a0e8: 53 push %ebx
10a0e9: 83 ec 10 sub $0x10,%esp
10a0ec: 8b 75 08 mov 0x8(%ebp),%esi
10a0ef: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
10a0f2: 85 db test %ebx,%ebx
10a0f4: 74 5e je 10a154 <rtems_message_queue_send+0x70><== 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,
10a0f6: 51 push %ecx
10a0f7: 8d 45 f4 lea -0xc(%ebp),%eax
10a0fa: 50 push %eax
10a0fb: 56 push %esi
10a0fc: 68 80 e9 11 00 push $0x11e980
10a101: e8 a2 19 00 00 call 10baa8 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
10a106: 83 c4 10 add $0x10,%esp
10a109: 8b 55 f4 mov -0xc(%ebp),%edx
10a10c: 85 d2 test %edx,%edx
10a10e: 74 0c je 10a11c <rtems_message_queue_send+0x38>
10a110: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a115: 8d 65 f8 lea -0x8(%ebp),%esp
10a118: 5b pop %ebx
10a119: 5e pop %esi
10a11a: c9 leave
10a11b: c3 ret
* @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
10a11c: 6a 00 push $0x0
10a11e: 6a 00 push $0x0
10a120: 68 ff ff ff 7f push $0x7fffffff
10a125: 6a 00 push $0x0
10a127: 56 push %esi
10a128: ff 75 10 pushl 0x10(%ebp)
10a12b: 53 push %ebx
10a12c: 83 c0 14 add $0x14,%eax
10a12f: 50 push %eax
10a130: e8 93 0c 00 00 call 10adc8 <_CORE_message_queue_Submit>
10a135: 89 c3 mov %eax,%ebx
MESSAGE_QUEUE_MP_HANDLER,
FALSE, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
10a137: 83 c4 20 add $0x20,%esp
10a13a: e8 ad 21 00 00 call 10c2ec <_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);
10a13f: 83 ec 0c sub $0xc,%esp
10a142: 53 push %ebx
10a143: e8 18 00 00 00 call 10a160 <_Message_queue_Translate_core_message_queue_return_code>
10a148: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a14b: 8d 65 f8 lea -0x8(%ebp),%esp
10a14e: 5b pop %ebx
10a14f: 5e pop %esi
10a150: c9 leave
10a151: c3 ret
10a152: 66 90 xchg %ax,%ax
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
10a154: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a159: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10a15c: 5b pop %ebx <== NOT EXECUTED
10a15d: 5e pop %esi <== NOT EXECUTED
10a15e: c9 leave <== NOT EXECUTED
10a15f: c3 ret <== NOT EXECUTED
00112744 <rtems_message_queue_urgent>:
rtems_status_code rtems_message_queue_urgent(
Objects_Id id,
const void *buffer,
size_t size
)
{
112744: 55 push %ebp
112745: 89 e5 mov %esp,%ebp
112747: 56 push %esi
112748: 53 push %ebx
112749: 83 ec 10 sub $0x10,%esp
11274c: 8b 75 08 mov 0x8(%ebp),%esi
11274f: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
112752: 85 db test %ebx,%ebx
112754: 74 5e je 1127b4 <rtems_message_queue_urgent+0x70><== 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,
112756: 51 push %ecx
112757: 8d 45 f4 lea -0xc(%ebp),%eax
11275a: 50 push %eax
11275b: 56 push %esi
11275c: 68 60 5d 13 00 push $0x135d60
112761: e8 7a 44 00 00 call 116be0 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
112766: 83 c4 10 add $0x10,%esp
112769: 8b 55 f4 mov -0xc(%ebp),%edx
11276c: 85 d2 test %edx,%edx
11276e: 74 0c je 11277c <rtems_message_queue_urgent+0x38>
112770: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112775: 8d 65 f8 lea -0x8(%ebp),%esp
112778: 5b pop %ebx
112779: 5e pop %esi
11277a: c9 leave
11277b: c3 ret
size_t size
11277c: 6a 00 push $0x0
11277e: 6a 00 push $0x0
112780: 68 00 00 00 80 push $0x80000000
112785: 6a 00 push $0x0
112787: 56 push %esi
112788: ff 75 10 pushl 0x10(%ebp)
11278b: 53 push %ebx
11278c: 83 c0 14 add $0x14,%eax
11278f: 50 push %eax
112790: e8 a7 30 00 00 call 11583c <_CORE_message_queue_Submit>
112795: 89 c3 mov %eax,%ebx
id,
MESSAGE_QUEUE_MP_HANDLER,
FALSE, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
112797: 83 c4 20 add $0x20,%esp
11279a: e8 85 4c 00 00 call 117424 <_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);
11279f: 83 ec 0c sub $0xc,%esp
1127a2: 53 push %ebx
1127a3: e8 8c ff ff ff call 112734 <_Message_queue_Translate_core_message_queue_return_code>
1127a8: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1127ab: 8d 65 f8 lea -0x8(%ebp),%esp
1127ae: 5b pop %ebx
1127af: 5e pop %esi
1127b0: c9 leave
1127b1: c3 ret
1127b2: 66 90 xchg %ax,%ax
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
1127b4: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1127b9: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
1127bc: 5b pop %ebx <== NOT EXECUTED
1127bd: 5e pop %esi <== NOT EXECUTED
1127be: c9 leave <== NOT EXECUTED
1127bf: c3 ret <== NOT EXECUTED
0010b720 <rtems_object_get_api_class_name>:
const char *rtems_object_get_api_class_name(
uint32_t the_api,
uint32_t the_class
)
{
10b720: 55 push %ebp
10b721: 89 e5 mov %esp,%ebp
10b723: 83 ec 08 sub $0x8,%esp
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
10b726: 83 7d 08 01 cmpl $0x1,0x8(%ebp)
10b72a: 74 2c je 10b758 <rtems_object_get_api_class_name+0x38>
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
10b72c: 83 7d 08 02 cmpl $0x2,0x8(%ebp)
10b730: 74 0a je 10b73c <rtems_object_get_api_class_name+0x1c>
10b732: b8 90 c5 11 00 mov $0x11c590,%eax
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
if ( class_assoc )
return class_assoc->name;
return "BAD CLASS";
}
10b737: c9 leave
10b738: c3 ret
10b739: 8d 76 00 lea 0x0(%esi),%esi
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
10b73c: b8 e0 14 12 00 mov $0x1214e0,%eax
else if ( the_api == OBJECTS_ITRON_API )
api_assoc = rtems_object_api_itron_assoc;
#endif
else
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
10b741: 83 ec 08 sub $0x8,%esp
10b744: ff 75 0c pushl 0xc(%ebp)
10b747: 50 push %eax
10b748: e8 3b 47 00 00 call 10fe88 <rtems_assoc_ptr_by_local>
if ( class_assoc )
10b74d: 83 c4 10 add $0x10,%esp
10b750: 85 c0 test %eax,%eax
10b752: 74 0c je 10b760 <rtems_object_get_api_class_name+0x40>
return class_assoc->name;
10b754: 8b 00 mov (%eax),%eax
return "BAD CLASS";
}
10b756: c9 leave
10b757: c3 ret
)
{
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
10b758: b8 c0 14 12 00 mov $0x1214c0,%eax
10b75d: eb e2 jmp 10b741 <rtems_object_get_api_class_name+0x21>
10b75f: 90 nop
api_assoc = rtems_object_api_itron_assoc;
#endif
else
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
if ( class_assoc )
10b760: b8 98 c5 11 00 mov $0x11c598,%eax
return class_assoc->name;
return "BAD CLASS";
}
10b765: c9 leave
10b766: c3 ret
0010b768 <rtems_object_get_api_name>:
};
const char *rtems_object_get_api_name(
uint32_t api
)
{
10b768: 55 push %ebp
10b769: 89 e5 mov %esp,%ebp
10b76b: 83 ec 10 sub $0x10,%esp
const rtems_assoc_t *api_assoc;
api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api );
10b76e: ff 75 08 pushl 0x8(%ebp)
10b771: 68 60 15 12 00 push $0x121560
10b776: e8 0d 47 00 00 call 10fe88 <rtems_assoc_ptr_by_local>
if ( api_assoc )
10b77b: 83 c4 10 add $0x10,%esp
10b77e: 85 c0 test %eax,%eax
10b780: 74 06 je 10b788 <rtems_object_get_api_name+0x20>
return api_assoc->name;
10b782: 8b 00 mov (%eax),%eax
return "BAD CLASS";
}
10b784: c9 leave
10b785: c3 ret
10b786: 66 90 xchg %ax,%ax
)
{
const rtems_assoc_t *api_assoc;
api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api );
if ( api_assoc )
10b788: b8 98 c5 11 00 mov $0x11c598,%eax
return api_assoc->name;
return "BAD CLASS";
}
10b78d: c9 leave
10b78e: c3 ret
0010b7d0 <rtems_object_get_class_information>:
rtems_status_code rtems_object_get_class_information(
uint32_t the_api,
uint32_t the_class,
rtems_object_api_class_information *info
)
{
10b7d0: 55 push %ebp
10b7d1: 89 e5 mov %esp,%ebp
10b7d3: 56 push %esi
10b7d4: 53 push %ebx
10b7d5: 8b 75 10 mov 0x10(%ebp),%esi
uint32_t i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
10b7d8: 85 f6 test %esi,%esi
10b7da: 74 58 je 10b834 <rtems_object_get_class_information+0x64>
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
10b7dc: 83 ec 08 sub $0x8,%esp
10b7df: ff 75 0c pushl 0xc(%ebp)
10b7e2: ff 75 08 pushl 0x8(%ebp)
10b7e5: e8 22 1a 00 00 call 10d20c <_Objects_Get_information>
10b7ea: 89 c2 mov %eax,%edx
if ( !obj_info )
10b7ec: 83 c4 10 add $0x10,%esp
10b7ef: 85 c0 test %eax,%eax
10b7f1: 74 4d je 10b840 <rtems_object_get_class_information+0x70>
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
10b7f3: 8b 40 08 mov 0x8(%eax),%eax
10b7f6: 89 06 mov %eax,(%esi)
info->maximum_id = obj_info->maximum_id;
10b7f8: 8b 42 0c mov 0xc(%edx),%eax
10b7fb: 89 46 04 mov %eax,0x4(%esi)
info->auto_extend = obj_info->auto_extend;
10b7fe: 8a 42 12 mov 0x12(%edx),%al
10b801: 88 46 0c mov %al,0xc(%esi)
info->maximum = obj_info->maximum;
10b804: 0f b7 42 10 movzwl 0x10(%edx),%eax
10b808: 89 46 08 mov %eax,0x8(%esi)
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
10b80b: 85 c0 test %eax,%eax
10b80d: 74 3d je 10b84c <rtems_object_get_class_information+0x7c><== NEVER TAKEN
10b80f: 8b 5a 1c mov 0x1c(%edx),%ebx
10b812: 31 c9 xor %ecx,%ecx
10b814: ba 01 00 00 00 mov $0x1,%edx
10b819: 8d 76 00 lea 0x0(%esi),%esi
if ( !obj_info->local_table[i] )
unallocated++;
10b81c: 83 3c 93 01 cmpl $0x1,(%ebx,%edx,4)
10b820: 83 d1 00 adc $0x0,%ecx
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
10b823: 42 inc %edx
10b824: 39 d0 cmp %edx,%eax
10b826: 73 f4 jae 10b81c <rtems_object_get_class_information+0x4c>
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
10b828: 89 4e 10 mov %ecx,0x10(%esi)
10b82b: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
10b82d: 8d 65 f8 lea -0x8(%ebp),%esp
10b830: 5b pop %ebx
10b831: 5e pop %esi
10b832: c9 leave
10b833: c3 ret
uint32_t i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
10b834: b8 09 00 00 00 mov $0x9,%eax
unallocated++;
info->unallocated = unallocated;
return RTEMS_SUCCESSFUL;
}
10b839: 8d 65 f8 lea -0x8(%ebp),%esp
10b83c: 5b pop %ebx
10b83d: 5e pop %esi
10b83e: c9 leave
10b83f: c3 ret
*/
if ( !info )
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
if ( !obj_info )
10b840: b8 0a 00 00 00 mov $0xa,%eax
unallocated++;
info->unallocated = unallocated;
return RTEMS_SUCCESSFUL;
}
10b845: 8d 65 f8 lea -0x8(%ebp),%esp
10b848: 5b pop %ebx
10b849: 5e pop %esi
10b84a: c9 leave
10b84b: c3 ret
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
10b84c: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
10b84e: eb d8 jmp 10b828 <rtems_object_get_class_information+0x58><== NOT EXECUTED
0010b04c <rtems_object_get_classic_name>:
rtems_status_code rtems_object_get_classic_name(
rtems_id id,
rtems_name *name
)
{
10b04c: 55 push %ebp
10b04d: 89 e5 mov %esp,%ebp
10b04f: 53 push %ebx
10b050: 83 ec 14 sub $0x14,%esp
10b053: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
10b056: 85 db test %ebx,%ebx
10b058: 74 26 je 10b080 <rtems_object_get_classic_name+0x34>
return RTEMS_INVALID_ADDRESS;
status = _Objects_Id_to_name( id, &name_u );
10b05a: 83 ec 08 sub $0x8,%esp
10b05d: 8d 45 f8 lea -0x8(%ebp),%eax
10b060: 50 push %eax
10b061: ff 75 08 pushl 0x8(%ebp)
10b064: e8 d3 1a 00 00 call 10cb3c <_Objects_Id_to_name>
*name = name_u.name_u32;
10b069: 8b 55 f8 mov -0x8(%ebp),%edx
10b06c: 89 13 mov %edx,(%ebx)
return _Status_Object_name_errors_to_status[ status ];
10b06e: 8b 04 85 4c b5 11 00 mov 0x11b54c(,%eax,4),%eax
10b075: 83 c4 10 add $0x10,%esp
}
10b078: 8b 5d fc mov -0x4(%ebp),%ebx
10b07b: c9 leave
10b07c: c3 ret
10b07d: 8d 76 00 lea 0x0(%esi),%esi
)
{
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
10b080: b8 09 00 00 00 mov $0x9,%eax
status = _Objects_Id_to_name( id, &name_u );
*name = name_u.name_u32;
return _Status_Object_name_errors_to_status[ status ];
}
10b085: 8b 5d fc mov -0x4(%ebp),%ebx
10b088: c9 leave
10b089: c3 ret
0010b8a8 <rtems_object_set_name>:
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
10b8a8: 55 push %ebp
10b8a9: 89 e5 mov %esp,%ebp
10b8ab: 57 push %edi
10b8ac: 56 push %esi
10b8ad: 53 push %ebx
10b8ae: 83 ec 1c sub $0x1c,%esp
10b8b1: 8b 45 08 mov 0x8(%ebp),%eax
10b8b4: 8b 7d 0c mov 0xc(%ebp),%edi
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
10b8b7: 85 ff test %edi,%edi
10b8b9: 74 65 je 10b920 <rtems_object_set_name+0x78><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10b8bb: 85 c0 test %eax,%eax
10b8bd: 74 45 je 10b904 <rtems_object_set_name+0x5c>
10b8bf: 89 c3 mov %eax,%ebx
information = _Objects_Get_information_id( tmpId );
10b8c1: 83 ec 0c sub $0xc,%esp
10b8c4: 53 push %ebx
10b8c5: e8 22 19 00 00 call 10d1ec <_Objects_Get_information_id>
10b8ca: 89 c6 mov %eax,%esi
if ( !information )
10b8cc: 83 c4 10 add $0x10,%esp
10b8cf: 85 c0 test %eax,%eax
10b8d1: 74 3d je 10b910 <rtems_object_set_name+0x68>
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
10b8d3: 50 push %eax
10b8d4: 8d 45 f0 lea -0x10(%ebp),%eax
10b8d7: 50 push %eax
10b8d8: 53 push %ebx
10b8d9: 56 push %esi
10b8da: e8 cd 1a 00 00 call 10d3ac <_Objects_Get>
switch ( location ) {
10b8df: 83 c4 10 add $0x10,%esp
10b8e2: 8b 4d f0 mov -0x10(%ebp),%ecx
10b8e5: 85 c9 test %ecx,%ecx
10b8e7: 75 27 jne 10b910 <rtems_object_set_name+0x68>
case OBJECTS_LOCAL:
_Objects_Set_name( information, the_object, name );
10b8e9: 52 push %edx
10b8ea: 57 push %edi
10b8eb: 50 push %eax
10b8ec: 56 push %esi
10b8ed: e8 32 1d 00 00 call 10d624 <_Objects_Set_name>
_Thread_Enable_dispatch();
10b8f2: e8 81 24 00 00 call 10dd78 <_Thread_Enable_dispatch>
10b8f7: 31 c0 xor %eax,%eax
10b8f9: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b8fc: 8d 65 f4 lea -0xc(%ebp),%esp
10b8ff: 5b pop %ebx
10b900: 5e pop %esi
10b901: 5f pop %edi
10b902: c9 leave
10b903: c3 ret
Objects_Id tmpId;
if ( !name )
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10b904: a1 5c 38 12 00 mov 0x12385c,%eax
10b909: 8b 58 08 mov 0x8(%eax),%ebx
10b90c: eb b3 jmp 10b8c1 <rtems_object_set_name+0x19>
10b90e: 66 90 xchg %ax,%ax
switch ( location ) {
case OBJECTS_LOCAL:
_Objects_Set_name( information, the_object, name );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
10b910: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b915: 8d 65 f4 lea -0xc(%ebp),%esp
10b918: 5b pop %ebx
10b919: 5e pop %esi
10b91a: 5f pop %edi
10b91b: c9 leave
10b91c: c3 ret
10b91d: 8d 76 00 lea 0x0(%esi),%esi
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
10b920: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
10b925: eb d5 jmp 10b8fc <rtems_object_set_name+0x54><== NOT EXECUTED
00107cbc <rtems_panic>:
void rtems_panic(
const char *printf_format,
...
)
{
107cbc: 55 push %ebp <== NOT EXECUTED
107cbd: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107cbf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
107cc2: 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);
107cc5: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
107cc8: b8 00 00 00 20 mov $0x20000000,%eax <== NOT EXECUTED
107ccd: e8 42 fe ff ff call 107b14 <rtems_verror> <== NOT EXECUTED
va_end(arglist);
}
107cd2: c9 leave <== NOT EXECUTED
107cd3: c3 ret <== NOT EXECUTED
001127c0 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
Objects_Id *id
)
{
1127c0: 55 push %ebp
1127c1: 89 e5 mov %esp,%ebp
1127c3: 56 push %esi
1127c4: 53 push %ebx
1127c5: 8b 75 08 mov 0x8(%ebp),%esi
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
1127c8: 85 f6 test %esi,%esi
1127ca: 74 48 je 112814 <rtems_partition_create+0x54>
return RTEMS_INVALID_NAME;
if ( !starting_address )
1127cc: 8b 5d 0c mov 0xc(%ebp),%ebx
1127cf: 85 db test %ebx,%ebx
1127d1: 74 27 je 1127fa <rtems_partition_create+0x3a><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !id )
1127d3: 8b 4d 1c mov 0x1c(%ebp),%ecx
1127d6: 85 c9 test %ecx,%ecx
1127d8: 74 20 je 1127fa <rtems_partition_create+0x3a><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
1127da: 8b 55 10 mov 0x10(%ebp),%edx
1127dd: 85 d2 test %edx,%edx
1127df: 74 27 je 112808 <rtems_partition_create+0x48>
1127e1: 8b 45 14 mov 0x14(%ebp),%eax
1127e4: 85 c0 test %eax,%eax
1127e6: 74 20 je 112808 <rtems_partition_create+0x48>
1127e8: 8b 45 14 mov 0x14(%ebp),%eax
1127eb: 39 45 10 cmp %eax,0x10(%ebp)
1127ee: 72 18 jb 112808 <rtems_partition_create+0x48>
1127f0: a8 03 test $0x3,%al
1127f2: 75 14 jne 112808 <rtems_partition_create+0x48>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
1127f4: f6 45 0c 03 testb $0x3,0xc(%ebp)
1127f8: 74 26 je 112820 <rtems_partition_create+0x60>
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
1127fa: b8 09 00 00 00 mov $0x9,%eax
}
1127ff: 8d 65 f8 lea -0x8(%ebp),%esp
112802: 5b pop %ebx
112803: 5e pop %esi
112804: c9 leave
112805: c3 ret
112806: 66 90 xchg %ax,%ax
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
112808: b8 08 00 00 00 mov $0x8,%eax
}
11280d: 8d 65 f8 lea -0x8(%ebp),%esp
112810: 5b pop %ebx
112811: 5e pop %esi
112812: c9 leave
112813: c3 ret
Objects_Id *id
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
112814: b8 03 00 00 00 mov $0x3,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
112819: 8d 65 f8 lea -0x8(%ebp),%esp
11281c: 5b pop %ebx
11281d: 5e pop %esi
11281e: c9 leave
11281f: c3 ret
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
112820: a1 38 5a 13 00 mov 0x135a38,%eax
112825: 40 inc %eax
112826: a3 38 5a 13 00 mov %eax,0x135a38
* 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
11282b: 83 ec 0c sub $0xc,%esp
11282e: 68 40 58 13 00 push $0x135840
112833: e8 74 3e 00 00 call 1166ac <_Objects_Allocate>
112838: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
11283a: 83 c4 10 add $0x10,%esp
11283d: 85 c0 test %eax,%eax
11283f: 74 5f je 1128a0 <rtems_partition_create+0xe0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
112841: 8b 45 0c mov 0xc(%ebp),%eax
112844: 89 43 10 mov %eax,0x10(%ebx)
the_partition->length = length;
112847: 8b 45 10 mov 0x10(%ebp),%eax
11284a: 89 43 14 mov %eax,0x14(%ebx)
the_partition->buffer_size = buffer_size;
11284d: 8b 45 14 mov 0x14(%ebp),%eax
112850: 89 43 18 mov %eax,0x18(%ebx)
the_partition->attribute_set = attribute_set;
112853: 8b 45 18 mov 0x18(%ebp),%eax
112856: 89 43 1c mov %eax,0x1c(%ebx)
the_partition->number_of_used_blocks = 0;
112859: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
_Chain_Initialize( &the_partition->Memory, starting_address,
112860: ff 75 14 pushl 0x14(%ebp)
112863: 8b 45 10 mov 0x10(%ebp),%eax
112866: 31 d2 xor %edx,%edx
112868: f7 75 14 divl 0x14(%ebp)
11286b: 50 push %eax
11286c: ff 75 0c pushl 0xc(%ebp)
11286f: 8d 43 24 lea 0x24(%ebx),%eax
112872: 50 push %eax
112873: e8 78 2c 00 00 call 1154f0 <_Chain_Initialize>
112878: 8b 4b 08 mov 0x8(%ebx),%ecx
11287b: 0f b7 d1 movzwl %cx,%edx
11287e: a1 5c 58 13 00 mov 0x13585c,%eax
112883: 89 1c 90 mov %ebx,(%eax,%edx,4)
112886: 89 73 0c mov %esi,0xc(%ebx)
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
112889: 8b 45 1c mov 0x1c(%ebp),%eax
11288c: 89 08 mov %ecx,(%eax)
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
11288e: e8 91 4b 00 00 call 117424 <_Thread_Enable_dispatch>
112893: 31 c0 xor %eax,%eax
112895: 83 c4 10 add $0x10,%esp
112898: e9 70 ff ff ff jmp 11280d <rtems_partition_create+0x4d>
11289d: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
_Thread_Enable_dispatch();
1128a0: e8 7f 4b 00 00 call 117424 <_Thread_Enable_dispatch>
1128a5: b8 05 00 00 00 mov $0x5,%eax
1128aa: e9 5e ff ff ff jmp 11280d <rtems_partition_create+0x4d>
001128b0 <rtems_partition_delete>:
*/
rtems_status_code rtems_partition_delete(
Objects_Id id
)
{
1128b0: 55 push %ebp
1128b1: 89 e5 mov %esp,%ebp
1128b3: 53 push %ebx
1128b4: 83 ec 18 sub $0x18,%esp
);
/**
* 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.
1128b7: 8d 45 f8 lea -0x8(%ebp),%eax
1128ba: 50 push %eax
1128bb: ff 75 08 pushl 0x8(%ebp)
1128be: 68 40 58 13 00 push $0x135840
1128c3: e8 18 43 00 00 call 116be0 <_Objects_Get>
1128c8: 89 c3 mov %eax,%ebx
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
1128ca: 83 c4 10 add $0x10,%esp
1128cd: 8b 45 f8 mov -0x8(%ebp),%eax
1128d0: 85 c0 test %eax,%eax
1128d2: 74 0c je 1128e0 <rtems_partition_delete+0x30>
1128d4: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1128d9: 8b 5d fc mov -0x4(%ebp),%ebx
1128dc: c9 leave
1128dd: c3 ret
1128de: 66 90 xchg %ax,%ax
the_partition = _Partition_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( the_partition->number_of_used_blocks == 0 ) {
1128e0: 8b 4b 20 mov 0x20(%ebx),%ecx
1128e3: 85 c9 test %ecx,%ecx
1128e5: 74 11 je 1128f8 <rtems_partition_delete+0x48>
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
1128e7: e8 38 4b 00 00 call 117424 <_Thread_Enable_dispatch>
1128ec: b8 0c 00 00 00 mov $0xc,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1128f1: 8b 5d fc mov -0x4(%ebp),%ebx
1128f4: c9 leave
1128f5: c3 ret
1128f6: 66 90 xchg %ax,%ax
the_partition = _Partition_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( the_partition->number_of_used_blocks == 0 ) {
_Objects_Close( &_Partition_Information, &the_partition->Object );
1128f8: 83 ec 08 sub $0x8,%esp
1128fb: 53 push %ebx
1128fc: 68 40 58 13 00 push $0x135840
112901: e8 26 3e 00 00 call 11672c <_Objects_Close>
size_t *size
);
/**
* This function tries to resize in place the block that is pointed to by the
* @a starting_address to the new @a size.
112906: 58 pop %eax
112907: 5a pop %edx
112908: 53 push %ebx
112909: 68 40 58 13 00 push $0x135840
11290e: e8 59 41 00 00 call 116a6c <_Objects_Free>
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
112913: e8 0c 4b 00 00 call 117424 <_Thread_Enable_dispatch>
112918: 31 c0 xor %eax,%eax
11291a: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11291d: 8b 5d fc mov -0x4(%ebp),%ebx
112920: c9 leave
112921: c3 ret
00112924 <rtems_partition_get_buffer>:
rtems_status_code rtems_partition_get_buffer(
Objects_Id id,
void **buffer
)
{
112924: 55 push %ebp
112925: 89 e5 mov %esp,%ebp
112927: 57 push %edi
112928: 56 push %esi
112929: 53 push %ebx
11292a: 83 ec 1c sub $0x1c,%esp
11292d: 8b 7d 0c mov 0xc(%ebp),%edi
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
112930: 85 ff test %edi,%edi
112932: 74 58 je 11298c <rtems_partition_get_buffer+0x68><== 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.
112934: 52 push %edx
112935: 8d 45 f0 lea -0x10(%ebp),%eax
112938: 50 push %eax
112939: ff 75 08 pushl 0x8(%ebp)
11293c: 68 40 58 13 00 push $0x135840
112941: e8 9a 42 00 00 call 116be0 <_Objects_Get>
112946: 89 c3 mov %eax,%ebx
return RTEMS_INVALID_ADDRESS;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
112948: 83 c4 10 add $0x10,%esp
11294b: 8b 45 f0 mov -0x10(%ebp),%eax
11294e: 85 c0 test %eax,%eax
112950: 75 2a jne 11297c <rtems_partition_get_buffer+0x58>
#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
112952: 83 ec 0c sub $0xc,%esp
112955: 8d 43 24 lea 0x24(%ebx),%eax
112958: 50 push %eax
112959: e8 6a 2b 00 00 call 1154c8 <_Chain_Get>
11295e: 89 c6 mov %eax,%esi
case OBJECTS_LOCAL:
the_buffer = _Partition_Allocate_buffer( the_partition );
if ( the_buffer ) {
112960: 83 c4 10 add $0x10,%esp
112963: 85 c0 test %eax,%eax
112965: 74 35 je 11299c <rtems_partition_get_buffer+0x78>
the_partition->number_of_used_blocks += 1;
112967: ff 43 20 incl 0x20(%ebx)
_Thread_Enable_dispatch();
11296a: e8 b5 4a 00 00 call 117424 <_Thread_Enable_dispatch>
*buffer = the_buffer;
11296f: 89 37 mov %esi,(%edi)
112971: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112973: 8d 65 f4 lea -0xc(%ebp),%esp
112976: 5b pop %ebx
112977: 5e pop %esi
112978: 5f pop %edi
112979: c9 leave
11297a: c3 ret
11297b: 90 nop
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
11297c: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112981: 8d 65 f4 lea -0xc(%ebp),%esp
112984: 5b pop %ebx
112985: 5e pop %esi
112986: 5f pop %edi
112987: c9 leave
112988: c3 ret
112989: 8d 76 00 lea 0x0(%esi),%esi
{
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
11298c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112991: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
112994: 5b pop %ebx <== NOT EXECUTED
112995: 5e pop %esi <== NOT EXECUTED
112996: 5f pop %edi <== NOT EXECUTED
112997: c9 leave <== NOT EXECUTED
112998: c3 ret <== NOT EXECUTED
112999: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
the_partition->number_of_used_blocks += 1;
_Thread_Enable_dispatch();
*buffer = the_buffer;
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
11299c: e8 83 4a 00 00 call 117424 <_Thread_Enable_dispatch>
1129a1: b8 0d 00 00 00 mov $0xd,%eax
1129a6: eb d9 jmp 112981 <rtems_partition_get_buffer+0x5d>
001129cc <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
Objects_Id id,
void *buffer
)
{
1129cc: 55 push %ebp
1129cd: 89 e5 mov %esp,%ebp
1129cf: 53 push %ebx
1129d0: 83 ec 18 sub $0x18,%esp
);
/**
* 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.
1129d3: 8d 45 f8 lea -0x8(%ebp),%eax
1129d6: 50 push %eax
1129d7: ff 75 08 pushl 0x8(%ebp)
1129da: 68 40 58 13 00 push $0x135840
1129df: e8 fc 41 00 00 call 116be0 <_Objects_Get>
1129e4: 89 c3 mov %eax,%ebx
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
1129e6: 83 c4 10 add $0x10,%esp
1129e9: 8b 45 f8 mov -0x8(%ebp),%eax
1129ec: 85 c0 test %eax,%eax
1129ee: 74 0c je 1129fc <rtems_partition_return_buffer+0x30>
1129f0: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1129f5: 8b 5d fc mov -0x4(%ebp),%ebx
1129f8: c9 leave
1129f9: c3 ret
1129fa: 66 90 xchg %ax,%ax
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
1129fc: 8b 53 10 mov 0x10(%ebx),%edx
1129ff: 8b 43 14 mov 0x14(%ebx),%eax
Heap_Control *the_heap,
void *starting_address,
size_t *size
);
/**
112a02: 39 55 0c cmp %edx,0xc(%ebp)
112a05: 73 11 jae 112a18 <rtems_partition_return_buffer+0x4c>
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
112a07: e8 18 4a 00 00 call 117424 <_Thread_Enable_dispatch>
112a0c: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112a11: 8b 5d fc mov -0x4(%ebp),%ebx
112a14: c9 leave
112a15: c3 ret
112a16: 66 90 xchg %ax,%ax
112a18: 8d 04 02 lea (%edx,%eax,1),%eax
112a1b: 39 45 0c cmp %eax,0xc(%ebp)
112a1e: 77 e7 ja 112a07 <rtems_partition_return_buffer+0x3b><== NEVER TAKEN
Heap_Control *the_heap,
size_t size
);
/**
* This function attempts to allocate a memory block of @a size bytes from
112a20: 8b 45 0c mov 0xc(%ebp),%eax
112a23: 29 d0 sub %edx,%eax
112a25: 31 d2 xor %edx,%edx
112a27: f7 73 18 divl 0x18(%ebx)
112a2a: 85 d2 test %edx,%edx
112a2c: 75 d9 jne 112a07 <rtems_partition_return_buffer+0x3b>
* @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(
112a2e: 83 ec 08 sub $0x8,%esp
112a31: ff 75 0c pushl 0xc(%ebp)
112a34: 8d 43 24 lea 0x24(%ebx),%eax
112a37: 50 push %eax
112a38: e8 67 2a 00 00 call 1154a4 <_Chain_Append>
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
112a3d: ff 4b 20 decl 0x20(%ebx)
_Thread_Enable_dispatch();
112a40: e8 df 49 00 00 call 117424 <_Thread_Enable_dispatch>
112a45: 31 c0 xor %eax,%eax
112a47: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112a4a: 8b 5d fc mov -0x4(%ebp),%ebx
112a4d: c9 leave
112a4e: c3 ret
00111df8 <rtems_port_create>:
void *internal_start,
void *external_start,
uint32_t length,
Objects_Id *id
)
{
111df8: 55 push %ebp
111df9: 89 e5 mov %esp,%ebp
111dfb: 56 push %esi
111dfc: 53 push %ebx
111dfd: 8b 75 08 mov 0x8(%ebp),%esi
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name) )
111e00: 85 f6 test %esi,%esi
111e02: 74 20 je 111e24 <rtems_port_create+0x2c>
return RTEMS_INVALID_NAME;
if ( !id )
111e04: 8b 45 18 mov 0x18(%ebp),%eax
111e07: 85 c0 test %eax,%eax
111e09: 74 0a je 111e15 <rtems_port_create+0x1d><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( internal_start ) ||
111e0b: 8b 45 10 mov 0x10(%ebp),%eax
111e0e: 0b 45 0c or 0xc(%ebp),%eax
111e11: a8 03 test $0x3,%al
111e13: 74 1b je 111e30 <rtems_port_create+0x38>
(Objects_Name) name
);
*id = the_port->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
111e15: b8 09 00 00 00 mov $0x9,%eax
}
111e1a: 8d 65 f8 lea -0x8(%ebp),%esp
111e1d: 5b pop %ebx
111e1e: 5e pop %esi
111e1f: c9 leave
111e20: c3 ret
111e21: 8d 76 00 lea 0x0(%esi),%esi
Objects_Id *id
)
{
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name) )
111e24: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_port->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
111e29: 8d 65 f8 lea -0x8(%ebp),%esp
111e2c: 5b pop %ebx
111e2d: 5e pop %esi
111e2e: c9 leave
111e2f: c3 ret
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
111e30: a1 38 5a 13 00 mov 0x135a38,%eax
111e35: 40 inc %eax
111e36: a3 38 5a 13 00 mov %eax,0x135a38
#ifdef __cplusplus
extern "C" {
#endif
/**
* This routine initializes @a the_heap record to manage the
111e3b: 83 ec 0c sub $0xc,%esp
111e3e: 68 00 58 13 00 push $0x135800
111e43: e8 64 48 00 00 call 1166ac <_Objects_Allocate>
111e48: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
111e4a: 83 c4 10 add $0x10,%esp
111e4d: 85 c0 test %eax,%eax
111e4f: 74 37 je 111e88 <rtems_port_create+0x90>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
111e51: 8b 45 0c mov 0xc(%ebp),%eax
111e54: 89 43 10 mov %eax,0x10(%ebx)
the_port->external_base = external_start;
111e57: 8b 45 10 mov 0x10(%ebp),%eax
111e5a: 89 43 14 mov %eax,0x14(%ebx)
the_port->length = length - 1;
111e5d: 8b 45 14 mov 0x14(%ebp),%eax
111e60: 48 dec %eax
111e61: 89 43 18 mov %eax,0x18(%ebx)
111e64: 8b 4b 08 mov 0x8(%ebx),%ecx
111e67: 0f b7 d1 movzwl %cx,%edx
111e6a: a1 1c 58 13 00 mov 0x13581c,%eax
111e6f: 89 1c 90 mov %ebx,(%eax,%edx,4)
111e72: 89 73 0c mov %esi,0xc(%ebx)
&_Dual_ported_memory_Information,
&the_port->Object,
(Objects_Name) name
);
*id = the_port->Object.id;
111e75: 8b 45 18 mov 0x18(%ebp),%eax
111e78: 89 08 mov %ecx,(%eax)
_Thread_Enable_dispatch();
111e7a: e8 a5 55 00 00 call 117424 <_Thread_Enable_dispatch>
111e7f: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
111e81: 8d 65 f8 lea -0x8(%ebp),%esp
111e84: 5b pop %ebx
111e85: 5e pop %esi
111e86: c9 leave
111e87: c3 ret
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
_Thread_Enable_dispatch();
111e88: e8 97 55 00 00 call 117424 <_Thread_Enable_dispatch>
111e8d: b8 05 00 00 00 mov $0x5,%eax
111e92: eb 86 jmp 111e1a <rtems_port_create+0x22>
00111e94 <rtems_port_delete>:
*/
rtems_status_code rtems_port_delete(
Objects_Id id
)
{
111e94: 55 push %ebp
111e95: 89 e5 mov %esp,%ebp
111e97: 53 push %ebx
111e98: 83 ec 18 sub $0x18,%esp
* 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
111e9b: 8d 45 f8 lea -0x8(%ebp),%eax
111e9e: 50 push %eax
111e9f: ff 75 08 pushl 0x8(%ebp)
111ea2: 68 00 58 13 00 push $0x135800
111ea7: e8 34 4d 00 00 call 116be0 <_Objects_Get>
111eac: 89 c3 mov %eax,%ebx
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
111eae: 83 c4 10 add $0x10,%esp
111eb1: 8b 4d f8 mov -0x8(%ebp),%ecx
111eb4: 85 c9 test %ecx,%ecx
111eb6: 75 2c jne 111ee4 <rtems_port_delete+0x50>
case OBJECTS_LOCAL:
_Objects_Close( &_Dual_ported_memory_Information, &the_port->Object );
111eb8: 83 ec 08 sub $0x8,%esp
111ebb: 50 push %eax
111ebc: 68 00 58 13 00 push $0x135800
111ec1: e8 66 48 00 00 call 11672c <_Objects_Close>
* @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
* unsuccessful, 0 will be returned.
*/
111ec6: 58 pop %eax
111ec7: 5a pop %edx
111ec8: 53 push %ebx
111ec9: 68 00 58 13 00 push $0x135800
111ece: e8 99 4b 00 00 call 116a6c <_Objects_Free>
_Dual_ported_memory_Free( the_port );
_Thread_Enable_dispatch();
111ed3: e8 4c 55 00 00 call 117424 <_Thread_Enable_dispatch>
111ed8: 31 c0 xor %eax,%eax
111eda: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
111edd: 8b 5d fc mov -0x4(%ebp),%ebx
111ee0: c9 leave
111ee1: c3 ret
111ee2: 66 90 xchg %ax,%ax
{
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
111ee4: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
111ee9: 8b 5d fc mov -0x4(%ebp),%ebx
111eec: c9 leave
111eed: c3 ret
00111ef0 <rtems_port_external_to_internal>:
rtems_status_code rtems_port_external_to_internal(
Objects_Id id,
void *external,
void **internal
)
{
111ef0: 55 push %ebp
111ef1: 89 e5 mov %esp,%ebp
111ef3: 53 push %ebx
111ef4: 83 ec 14 sub $0x14,%esp
111ef7: 8b 5d 10 mov 0x10(%ebp),%ebx
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !internal )
111efa: 85 db test %ebx,%ebx
111efc: 74 4e je 111f4c <rtems_port_external_to_internal+0x5c><== 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
111efe: 51 push %ecx
111eff: 8d 45 f8 lea -0x8(%ebp),%eax
111f02: 50 push %eax
111f03: ff 75 08 pushl 0x8(%ebp)
111f06: 68 00 58 13 00 push $0x135800
111f0b: e8 d0 4c 00 00 call 116be0 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
111f10: 83 c4 10 add $0x10,%esp
111f13: 8b 55 f8 mov -0x8(%ebp),%edx
111f16: 85 d2 test %edx,%edx
111f18: 75 1e jne 111f38 <rtems_port_external_to_internal+0x48>
* 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
*/
111f1a: 8b 55 0c mov 0xc(%ebp),%edx
111f1d: 2b 50 14 sub 0x14(%eax),%edx
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( external, the_port->external_base );
if ( ending > the_port->length )
111f20: 39 50 18 cmp %edx,0x18(%eax)
111f23: 73 1f jae 111f44 <rtems_port_external_to_internal+0x54>
*internal = external;
111f25: 8b 45 0c mov 0xc(%ebp),%eax
111f28: 89 03 mov %eax,(%ebx)
else
*internal = _Addresses_Add_offset( the_port->internal_base,
ending );
_Thread_Enable_dispatch();
111f2a: e8 f5 54 00 00 call 117424 <_Thread_Enable_dispatch>
111f2f: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
111f31: 8b 5d fc mov -0x4(%ebp),%ebx
111f34: c9 leave
111f35: c3 ret
111f36: 66 90 xchg %ax,%ax
if ( !internal )
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
111f38: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
111f3d: 8b 5d fc mov -0x4(%ebp),%ebx
111f40: c9 leave
111f41: c3 ret
111f42: 66 90 xchg %ax,%ax
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( external, the_port->external_base );
if ( ending > the_port->length )
*internal = external;
else
*internal = _Addresses_Add_offset( the_port->internal_base,
111f44: 03 50 10 add 0x10(%eax),%edx
111f47: 89 13 mov %edx,(%ebx)
111f49: eb df jmp 111f2a <rtems_port_external_to_internal+0x3a>
111f4b: 90 nop
{
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !internal )
111f4c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
111f51: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
111f54: c9 leave <== NOT EXECUTED
111f55: c3 ret <== NOT EXECUTED
00111f7c <rtems_port_internal_to_external>:
rtems_status_code rtems_port_internal_to_external(
Objects_Id id,
void *internal,
void **external
)
{
111f7c: 55 push %ebp
111f7d: 89 e5 mov %esp,%ebp
111f7f: 53 push %ebx
111f80: 83 ec 14 sub $0x14,%esp
111f83: 8b 5d 10 mov 0x10(%ebp),%ebx
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
111f86: 85 db test %ebx,%ebx
111f88: 74 4e je 111fd8 <rtems_port_internal_to_external+0x5c><== 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
111f8a: 51 push %ecx
111f8b: 8d 45 f8 lea -0x8(%ebp),%eax
111f8e: 50 push %eax
111f8f: ff 75 08 pushl 0x8(%ebp)
111f92: 68 00 58 13 00 push $0x135800
111f97: e8 44 4c 00 00 call 116be0 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
111f9c: 83 c4 10 add $0x10,%esp
111f9f: 8b 55 f8 mov -0x8(%ebp),%edx
111fa2: 85 d2 test %edx,%edx
111fa4: 75 1e jne 111fc4 <rtems_port_internal_to_external+0x48>
* 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
*/
111fa6: 8b 55 0c mov 0xc(%ebp),%edx
111fa9: 2b 50 10 sub 0x10(%eax),%edx
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( internal, the_port->internal_base );
if ( ending > the_port->length )
111fac: 39 50 18 cmp %edx,0x18(%eax)
111faf: 73 1f jae 111fd0 <rtems_port_internal_to_external+0x54>
*external = internal;
111fb1: 8b 45 0c mov 0xc(%ebp),%eax
111fb4: 89 03 mov %eax,(%ebx)
else
*external = _Addresses_Add_offset( the_port->external_base,
ending );
_Thread_Enable_dispatch();
111fb6: e8 69 54 00 00 call 117424 <_Thread_Enable_dispatch>
111fbb: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
111fbd: 8b 5d fc mov -0x4(%ebp),%ebx
111fc0: c9 leave
111fc1: c3 ret
111fc2: 66 90 xchg %ax,%ax
if ( !external )
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
111fc4: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
111fc9: 8b 5d fc mov -0x4(%ebp),%ebx
111fcc: c9 leave
111fcd: c3 ret
111fce: 66 90 xchg %ax,%ax
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( internal, the_port->internal_base );
if ( ending > the_port->length )
*external = internal;
else
*external = _Addresses_Add_offset( the_port->external_base,
111fd0: 03 50 14 add 0x14(%eax),%edx
111fd3: 89 13 mov %edx,(%ebx)
111fd5: eb df jmp 111fb6 <rtems_port_internal_to_external+0x3a>
111fd7: 90 nop
{
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
111fd8: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
111fdd: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
111fe0: c9 leave <== NOT EXECUTED
111fe1: c3 ret <== NOT EXECUTED
00112a50 <rtems_rate_monotonic_cancel>:
*/
rtems_status_code rtems_rate_monotonic_cancel(
Objects_Id id
)
{
112a50: 55 push %ebp
112a51: 89 e5 mov %esp,%ebp
112a53: 53 push %ebx
112a54: 83 ec 18 sub $0x18,%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
112a57: 8d 45 f8 lea -0x8(%ebp),%eax
112a5a: 50 push %eax
112a5b: ff 75 08 pushl 0x8(%ebp)
112a5e: 68 80 58 13 00 push $0x135880
112a63: e8 78 41 00 00 call 116be0 <_Objects_Get>
112a68: 89 c3 mov %eax,%ebx
Rate_monotonic_Control *the_period;
Objects_Locations location;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
112a6a: 83 c4 10 add $0x10,%esp
112a6d: 8b 45 f8 mov -0x8(%ebp),%eax
112a70: 85 c0 test %eax,%eax
112a72: 74 0c je 112a80 <rtems_rate_monotonic_cancel+0x30>
112a74: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112a79: 8b 5d fc mov -0x4(%ebp),%ebx
112a7c: c9 leave
112a7d: c3 ret
112a7e: 66 90 xchg %ax,%ax
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
112a80: 8b 43 50 mov 0x50(%ebx),%eax
112a83: 3b 05 fc 5a 13 00 cmp 0x135afc,%eax
112a89: 74 11 je 112a9c <rtems_rate_monotonic_cancel+0x4c>
_Thread_Enable_dispatch();
112a8b: e8 94 49 00 00 call 117424 <_Thread_Enable_dispatch>
112a90: b8 17 00 00 00 mov $0x17,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112a95: 8b 5d fc mov -0x4(%ebp),%ebx
112a98: c9 leave
112a99: c3 ret
112a9a: 66 90 xchg %ax,%ax
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
(void) _Watchdog_Remove( &the_period->Timer );
112a9c: 83 ec 0c sub $0xc,%esp
112a9f: 8d 43 10 lea 0x10(%ebx),%eax
112aa2: 50 push %eax
112aa3: e8 74 5d 00 00 call 11881c <_Watchdog_Remove>
the_period->state = RATE_MONOTONIC_INACTIVE;
112aa8: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx)
_Thread_Enable_dispatch();
112aaf: e8 70 49 00 00 call 117424 <_Thread_Enable_dispatch>
112ab4: 31 c0 xor %eax,%eax
112ab6: 83 c4 10 add $0x10,%esp
112ab9: eb be jmp 112a79 <rtems_rate_monotonic_cancel+0x29>
0010afdc <rtems_rate_monotonic_create>:
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
Objects_Id *id
)
{
10afdc: 55 push %ebp
10afdd: 89 e5 mov %esp,%ebp
10afdf: 57 push %edi
10afe0: 56 push %esi
10afe1: 53 push %ebx
10afe2: 83 ec 0c sub $0xc,%esp
10afe5: 8b 75 08 mov 0x8(%ebp),%esi
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
10afe8: 85 f6 test %esi,%esi
10afea: 0f 84 a8 00 00 00 je 10b098 <rtems_rate_monotonic_create+0xbc>
return RTEMS_INVALID_NAME;
if ( !id )
10aff0: 8b 45 0c mov 0xc(%ebp),%eax
10aff3: 85 c0 test %eax,%eax
10aff5: 0f 84 c1 00 00 00 je 10b0bc <rtems_rate_monotonic_create+0xe0><== NEVER TAKEN
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10affb: a1 78 27 12 00 mov 0x122778,%eax
10b000: 40 inc %eax
10b001: a3 78 27 12 00 mov %eax,0x122778
#ifdef __cplusplus
extern "C" {
#endif
/**
10b006: 83 ec 0c sub $0xc,%esp
10b009: 68 80 26 12 00 push $0x122680
10b00e: e8 d9 1d 00 00 call 10cdec <_Objects_Allocate>
10b013: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
10b015: 83 c4 10 add $0x10,%esp
10b018: 85 c0 test %eax,%eax
10b01a: 0f 84 88 00 00 00 je 10b0a8 <rtems_rate_monotonic_create+0xcc>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
10b020: a1 3c 28 12 00 mov 0x12283c,%eax
10b025: 89 43 50 mov %eax,0x50(%ebx)
the_period->state = RATE_MONOTONIC_INACTIVE;
10b028: 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.
*
10b02f: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
* @param[in] the_heap is the heap to operate upon
10b036: c7 43 2c 00 00 00 00 movl $0x0,0x2c(%ebx)
* @param[in] starting_address is the starting address of the memory for
10b03d: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx)
* the heap
10b044: 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 );
10b04b: 8d 7b 54 lea 0x54(%ebx),%edi
10b04e: b9 38 00 00 00 mov $0x38,%ecx
10b053: 31 c0 xor %eax,%eax
10b055: f3 aa rep stos %al,%es:(%edi)
10b057: c7 43 5c ff ff ff 7f movl $0x7fffffff,0x5c(%ebx)
10b05e: c7 43 60 ff ff ff 7f movl $0x7fffffff,0x60(%ebx)
10b065: c7 43 74 ff ff ff 7f movl $0x7fffffff,0x74(%ebx)
10b06c: c7 43 78 ff ff ff 7f movl $0x7fffffff,0x78(%ebx)
10b073: 8b 4b 08 mov 0x8(%ebx),%ecx
10b076: 0f b7 d1 movzwl %cx,%edx
10b079: a1 9c 26 12 00 mov 0x12269c,%eax
10b07e: 89 1c 90 mov %ebx,(%eax,%edx,4)
10b081: 89 73 0c mov %esi,0xc(%ebx)
&_Rate_monotonic_Information,
&the_period->Object,
(Objects_Name) name
);
*id = the_period->Object.id;
10b084: 8b 45 0c mov 0xc(%ebp),%eax
10b087: 89 08 mov %ecx,(%eax)
_Thread_Enable_dispatch();
10b089: e8 96 2b 00 00 call 10dc24 <_Thread_Enable_dispatch>
10b08e: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
10b090: 8d 65 f4 lea -0xc(%ebp),%esp
10b093: 5b pop %ebx
10b094: 5e pop %esi
10b095: 5f pop %edi
10b096: c9 leave
10b097: c3 ret
Objects_Id *id
)
{
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
10b098: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b09d: 8d 65 f4 lea -0xc(%ebp),%esp
10b0a0: 5b pop %ebx
10b0a1: 5e pop %esi
10b0a2: 5f pop %edi
10b0a3: c9 leave
10b0a4: c3 ret
10b0a5: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
_Thread_Enable_dispatch();
10b0a8: e8 77 2b 00 00 call 10dc24 <_Thread_Enable_dispatch>
10b0ad: b8 05 00 00 00 mov $0x5,%eax
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b0b2: 8d 65 f4 lea -0xc(%ebp),%esp
10b0b5: 5b pop %ebx
10b0b6: 5e pop %esi
10b0b7: 5f pop %edi
10b0b8: c9 leave
10b0b9: c3 ret
10b0ba: 66 90 xchg %ax,%ax
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
10b0bc: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b0c1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10b0c4: 5b pop %ebx <== NOT EXECUTED
10b0c5: 5e pop %esi <== NOT EXECUTED
10b0c6: 5f pop %edi <== NOT EXECUTED
10b0c7: c9 leave <== NOT EXECUTED
10b0c8: c3 ret <== NOT EXECUTED
00110878 <rtems_rate_monotonic_get_statistics>:
rtems_status_code rtems_rate_monotonic_get_statistics(
Objects_Id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
110878: 55 push %ebp
110879: 89 e5 mov %esp,%ebp
11087b: 57 push %edi
11087c: 56 push %esi
11087d: 83 ec 20 sub $0x20,%esp
110880: 8b 7d 0c mov 0xc(%ebp),%edi
Objects_Locations location;
Rate_monotonic_Control *the_period;
if ( !statistics )
110883: 85 ff test %edi,%edi
110885: 74 41 je 1108c8 <rtems_rate_monotonic_get_statistics+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
110887: 51 push %ecx
110888: 8d 45 f4 lea -0xc(%ebp),%eax
11088b: 50 push %eax
11088c: ff 75 08 pushl 0x8(%ebp)
11088f: 68 80 26 12 00 push $0x122680
110894: e8 47 cb ff ff call 10d3e0 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
110899: 83 c4 10 add $0x10,%esp
11089c: 8b 55 f4 mov -0xc(%ebp),%edx
11089f: 85 d2 test %edx,%edx
1108a1: 74 0d je 1108b0 <rtems_rate_monotonic_get_statistics+0x38>
1108a3: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1108a8: 8d 65 f8 lea -0x8(%ebp),%esp
1108ab: 5e pop %esi
1108ac: 5f pop %edi
1108ad: c9 leave
1108ae: c3 ret
1108af: 90 nop
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
*statistics = the_period->Statistics;
1108b0: 8d 70 54 lea 0x54(%eax),%esi
1108b3: b9 0e 00 00 00 mov $0xe,%ecx
1108b8: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Thread_Enable_dispatch();
1108ba: e8 65 d3 ff ff call 10dc24 <_Thread_Enable_dispatch>
1108bf: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1108c1: 8d 65 f8 lea -0x8(%ebp),%esp
1108c4: 5e pop %esi
1108c5: 5f pop %edi
1108c6: c9 leave
1108c7: c3 ret
)
{
Objects_Locations location;
Rate_monotonic_Control *the_period;
if ( !statistics )
1108c8: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1108cd: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
1108d0: 5e pop %esi <== NOT EXECUTED
1108d1: 5f pop %edi <== NOT EXECUTED
1108d2: c9 leave <== NOT EXECUTED
1108d3: c3 ret <== NOT EXECUTED
001108d4 <rtems_rate_monotonic_get_status>:
rtems_status_code rtems_rate_monotonic_get_status(
Objects_Id id,
rtems_rate_monotonic_period_status *status
)
{
1108d4: 55 push %ebp
1108d5: 89 e5 mov %esp,%ebp
1108d7: 57 push %edi
1108d8: 56 push %esi
1108d9: 53 push %ebx
1108da: 83 ec 1c sub $0x1c,%esp
1108dd: 8b 75 0c mov 0xc(%ebp),%esi
Objects_Locations location;
Rate_monotonic_Control *the_period;
if ( !status )
1108e0: 85 f6 test %esi,%esi
1108e2: 74 70 je 110954 <rtems_rate_monotonic_get_status+0x80><== NEVER TAKEN
1108e4: 52 push %edx
1108e5: 8d 45 f0 lea -0x10(%ebp),%eax
1108e8: 50 push %eax
1108e9: ff 75 08 pushl 0x8(%ebp)
1108ec: 68 80 26 12 00 push $0x122680
1108f1: e8 ea ca ff ff call 10d3e0 <_Objects_Get>
1108f6: 89 c7 mov %eax,%edi
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
1108f8: 83 c4 10 add $0x10,%esp
1108fb: 8b 45 f0 mov -0x10(%ebp),%eax
1108fe: 85 c0 test %eax,%eax
110900: 75 42 jne 110944 <rtems_rate_monotonic_get_status+0x70>
case OBJECTS_LOCAL:
status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0);
110902: 8b 47 50 mov 0x50(%edi),%eax
110905: 85 c0 test %eax,%eax
110907: 74 03 je 11090c <rtems_rate_monotonic_get_status+0x38><== NEVER TAKEN
110909: 8b 40 08 mov 0x8(%eax),%eax
11090c: 89 06 mov %eax,(%esi)
status->state = the_period->state;
11090e: 8b 47 38 mov 0x38(%edi),%eax
110911: 89 46 04 mov %eax,0x4(%esi)
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
110914: 85 c0 test %eax,%eax
110916: 75 4c jne 110964 <rtems_rate_monotonic_get_status+0x90>
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
status->since_last_period.tv_sec = 0;
110918: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi)
status->since_last_period.tv_nsec = 0;
11091f: 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;
110926: c7 46 10 00 00 00 00 movl $0x0,0x10(%esi)
status->executed_since_last_period.tv_nsec = 0;
11092d: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi)
the_period->owner->cpu_time_used -
the_period->owner_executed_at_period;
#endif
}
_Thread_Enable_dispatch();
110934: e8 eb d2 ff ff call 10dc24 <_Thread_Enable_dispatch>
110939: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11093b: 8d 65 f4 lea -0xc(%ebp),%esp
11093e: 5b pop %ebx
11093f: 5e pop %esi
110940: 5f pop %edi
110941: c9 leave
110942: c3 ret
110943: 90 nop
if ( !status )
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
110944: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
110949: 8d 65 f4 lea -0xc(%ebp),%esp
11094c: 5b pop %ebx
11094d: 5e pop %esi
11094e: 5f pop %edi
11094f: c9 leave
110950: c3 ret
110951: 8d 76 00 lea 0x0(%esi),%esi
)
{
Objects_Locations location;
Rate_monotonic_Control *the_period;
if ( !status )
110954: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
110959: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
11095c: 5b pop %ebx <== NOT EXECUTED
11095d: 5e pop %esi <== NOT EXECUTED
11095e: 5f pop %edi <== NOT EXECUTED
11095f: c9 leave <== NOT EXECUTED
110960: c3 ret <== NOT EXECUTED
110961: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
* 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 );
110964: 83 ec 0c sub $0xc,%esp
110967: 8d 5d e8 lea -0x18(%ebp),%ebx
11096a: 53 push %ebx
11096b: e8 04 c1 ff ff call 10ca74 <_TOD_Get_uptime>
#endif
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
_Timespec_Subtract(
110970: 83 c4 0c add $0xc,%esp
110973: 8d 46 08 lea 0x8(%esi),%eax
110976: 50 push %eax
110977: 53 push %ebx
110978: 8d 47 44 lea 0x44(%edi),%eax
11097b: 50 push %eax
11097c: e8 cf e0 ff ff call 10ea50 <_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(
110981: 83 c4 0c add $0xc,%esp
110984: 8d 46 10 lea 0x10(%esi),%eax
110987: 50 push %eax
110988: 53 push %ebx
110989: 68 44 28 12 00 push $0x122844
11098e: e8 bd e0 ff ff call 10ea50 <_Timespec_Subtract>
110993: 83 c4 10 add $0x10,%esp
110996: eb 9c jmp 110934 <rtems_rate_monotonic_get_status+0x60>
0010b2b4 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
Objects_Id id,
rtems_interval length
)
{
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 20 sub $0x20,%esp
10b2bd: 8b 75 08 mov 0x8(%ebp),%esi
/**
* 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
10b2c0: 8d 45 f0 lea -0x10(%ebp),%eax
10b2c3: 50 push %eax
10b2c4: 56 push %esi
10b2c5: 68 80 26 12 00 push $0x122680
10b2ca: e8 11 21 00 00 call 10d3e0 <_Objects_Get>
10b2cf: 89 c3 mov %eax,%ebx
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
10b2d1: 83 c4 10 add $0x10,%esp
10b2d4: 8b 45 f0 mov -0x10(%ebp),%eax
10b2d7: 85 c0 test %eax,%eax
10b2d9: 74 11 je 10b2ec <rtems_rate_monotonic_period+0x38>
the_period->state = RATE_MONOTONIC_ACTIVE;
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_TIMEOUT;
10b2db: bb 04 00 00 00 mov $0x4,%ebx
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b2e0: 89 d8 mov %ebx,%eax
10b2e2: 8d 65 f4 lea -0xc(%ebp),%esp
10b2e5: 5b pop %ebx
10b2e6: 5e pop %esi
10b2e7: 5f pop %edi
10b2e8: c9 leave
10b2e9: c3 ret
10b2ea: 66 90 xchg %ax,%ax
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
10b2ec: 8b 43 50 mov 0x50(%ebx),%eax
10b2ef: 3b 05 3c 28 12 00 cmp 0x12283c,%eax
10b2f5: 74 15 je 10b30c <rtems_rate_monotonic_period+0x58>
_Thread_Enable_dispatch();
10b2f7: e8 28 29 00 00 call 10dc24 <_Thread_Enable_dispatch>
10b2fc: bb 17 00 00 00 mov $0x17,%ebx
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b301: 89 d8 mov %ebx,%eax
10b303: 8d 65 f4 lea -0xc(%ebp),%esp
10b306: 5b pop %ebx
10b307: 5e pop %esi
10b308: 5f pop %edi
10b309: c9 leave
10b30a: c3 ret
10b30b: 90 nop
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
10b30c: 8b 45 0c mov 0xc(%ebp),%eax
10b30f: 85 c0 test %eax,%eax
10b311: 0f 84 c1 00 00 00 je 10b3d8 <rtems_rate_monotonic_period+0x124>
}
_Thread_Enable_dispatch();
return( return_value );
}
_ISR_Disable( level );
10b317: 9c pushf
10b318: fa cli
10b319: 5f pop %edi
switch ( the_period->state ) {
10b31a: 8b 43 38 mov 0x38(%ebx),%eax
10b31d: 83 f8 02 cmp $0x2,%eax
10b320: 74 62 je 10b384 <rtems_rate_monotonic_period+0xd0>
10b322: 83 f8 04 cmp $0x4,%eax
10b325: 0f 84 c5 00 00 00 je 10b3f0 <rtems_rate_monotonic_period+0x13c><== NEVER TAKEN
10b32b: 85 c0 test %eax,%eax
10b32d: 75 ac jne 10b2db <rtems_rate_monotonic_period+0x27><== NEVER TAKEN
case RATE_MONOTONIC_INACTIVE: {
_ISR_Enable( level );
10b32f: 57 push %edi
10b330: 9d popf
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
10b331: 83 ec 0c sub $0xc,%esp
10b334: 53 push %ebx
10b335: e8 b6 fd ff ff call 10b0f0 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
10b33a: 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.
*
10b341: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
* @param[in] the_heap is the heap to operate upon
10b348: c7 43 2c 24 b7 10 00 movl $0x10b724,0x2c(%ebx)
* @param[in] starting_address is the starting address of the memory for
10b34f: 89 73 30 mov %esi,0x30(%ebx)
* the heap
10b352: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx)
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
10b359: 8b 45 0c mov 0xc(%ebp),%eax
10b35c: 89 43 4c mov %eax,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,
10b35f: 89 43 1c mov %eax,0x1c(%ebx)
void *starting_address,
size_t *size
10b362: 5f pop %edi
10b363: 58 pop %eax
10b364: 8d 43 10 lea 0x10(%ebx),%eax
10b367: 50 push %eax
10b368: 68 5c 28 12 00 push $0x12285c
10b36d: e8 86 39 00 00 call 10ecf8 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
10b372: e8 ad 28 00 00 call 10dc24 <_Thread_Enable_dispatch>
10b377: 31 db xor %ebx,%ebx
10b379: 83 c4 10 add $0x10,%esp
10b37c: e9 5f ff ff ff jmp 10b2e0 <rtems_rate_monotonic_period+0x2c>
10b381: 8d 76 00 lea 0x0(%esi),%esi
case RATE_MONOTONIC_ACTIVE:
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
10b384: 83 ec 0c sub $0xc,%esp
10b387: 53 push %ebx
10b388: e8 d3 fd ff ff call 10b160 <_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;
10b38d: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx)
the_period->next_length = length;
10b394: 8b 45 0c mov 0xc(%ebp),%eax
10b397: 89 43 4c mov %eax,0x4c(%ebx)
_ISR_Enable( level );
10b39a: 57 push %edi
10b39b: 9d popf
_Thread_Executing->Wait.id = the_period->Object.id;
10b39c: 8b 15 3c 28 12 00 mov 0x12283c,%edx
10b3a2: 8b 43 08 mov 0x8(%ebx),%eax
10b3a5: 89 42 20 mov %eax,0x20(%edx)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10b3a8: 59 pop %ecx
10b3a9: 5e pop %esi
10b3aa: 68 00 40 00 00 push $0x4000
10b3af: 52 push %edx
10b3b0: e8 4f 31 00 00 call 10e504 <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
10b3b5: 9c pushf
10b3b6: fa cli
10b3b7: 58 pop %eax
local_state = the_period->state;
10b3b8: 8b 53 38 mov 0x38(%ebx),%edx
the_period->state = RATE_MONOTONIC_ACTIVE;
10b3bb: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx)
_ISR_Enable( level );
10b3c2: 50 push %eax
10b3c3: 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 )
10b3c4: 83 c4 10 add $0x10,%esp
10b3c7: 83 fa 03 cmp $0x3,%edx
10b3ca: 74 71 je 10b43d <rtems_rate_monotonic_period+0x189><== NEVER TAKEN
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
_Thread_Enable_dispatch();
10b3cc: e8 53 28 00 00 call 10dc24 <_Thread_Enable_dispatch>
10b3d1: 31 db xor %ebx,%ebx
10b3d3: e9 08 ff ff ff jmp 10b2e0 <rtems_rate_monotonic_period+0x2c>
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
switch ( the_period->state ) {
10b3d8: 8b 43 38 mov 0x38(%ebx),%eax
10b3db: 85 c0 test %eax,%eax
10b3dd: 75 51 jne 10b430 <rtems_rate_monotonic_period+0x17c><== NEVER TAKEN
10b3df: bb 0b 00 00 00 mov $0xb,%ebx
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
10b3e4: e8 3b 28 00 00 call 10dc24 <_Thread_Enable_dispatch>
10b3e9: e9 f2 fe ff ff jmp 10b2e0 <rtems_rate_monotonic_period+0x2c>
10b3ee: 66 90 xchg %ax,%ax
case RATE_MONOTONIC_EXPIRED:
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
10b3f0: 83 ec 0c sub $0xc,%esp
10b3f3: 53 push %ebx
10b3f4: e8 67 fd ff ff call 10b160 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
10b3f9: 57 push %edi
10b3fa: 9d popf
the_period->state = RATE_MONOTONIC_ACTIVE;
10b3fb: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx)
the_period->next_length = length;
10b402: 8b 45 0c mov 0xc(%ebp),%eax
10b405: 89 43 4c mov %eax,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,
10b408: 89 43 1c mov %eax,0x1c(%ebx)
void *starting_address,
size_t *size
10b40b: 58 pop %eax
10b40c: 5a pop %edx
10b40d: 8d 43 10 lea 0x10(%ebx),%eax
10b410: 50 push %eax
10b411: 68 5c 28 12 00 push $0x12285c
10b416: e8 dd 38 00 00 call 10ecf8 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
10b41b: e8 04 28 00 00 call 10dc24 <_Thread_Enable_dispatch>
10b420: bb 06 00 00 00 mov $0x6,%ebx
10b425: 83 c4 10 add $0x10,%esp
10b428: e9 b3 fe ff ff jmp 10b2e0 <rtems_rate_monotonic_period+0x2c>
10b42d: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
switch ( the_period->state ) {
10b430: 83 e8 03 sub $0x3,%eax
10b433: 83 f8 02 cmp $0x2,%eax
10b436: 19 db sbb %ebx,%ebx
10b438: 83 e3 06 and $0x6,%ebx
10b43b: eb a7 jmp 10b3e4 <rtems_rate_monotonic_period+0x130>
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10b43d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10b440: 68 00 40 00 00 push $0x4000 <== NOT EXECUTED
10b445: ff 35 3c 28 12 00 pushl 0x12283c <== NOT EXECUTED
10b44b: e8 2c 24 00 00 call 10d87c <_Thread_Clear_state> <== NOT EXECUTED
10b450: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10b453: e9 74 ff ff ff jmp 10b3cc <rtems_rate_monotonic_period+0x118><== NOT EXECUTED
0010b458 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
10b458: 55 push %ebp
10b459: 89 e5 mov %esp,%ebp
10b45b: 57 push %edi
10b45c: 56 push %esi
10b45d: 53 push %ebx
10b45e: 81 ec 9c 00 00 00 sub $0x9c,%esp
10b464: 8b 7d 0c mov 0xc(%ebp),%edi
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
10b467: 85 ff test %edi,%edi
10b469: 0f 84 c9 00 00 00 je 10b538 <rtems_rate_monotonic_report_statistics_with_plugin+0xe0><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
10b46f: 83 ec 08 sub $0x8,%esp
10b472: 68 70 bb 11 00 push $0x11bb70
10b477: ff 75 08 pushl 0x8(%ebp)
10b47a: ff d7 call *%edi
#if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS)
(*print)( context, "--- CPU times are in seconds ---\n" );
10b47c: 5e pop %esi
10b47d: 58 pop %eax
10b47e: 68 a8 bb 11 00 push $0x11bba8
10b483: ff 75 08 pushl 0x8(%ebp)
10b486: ff d7 call *%edi
#endif
#if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS)
(*print)( context, "--- Wall times are in seconds ---\n" );
10b488: 59 pop %ecx
10b489: 5b pop %ebx
10b48a: 68 cc bb 11 00 push $0x11bbcc
10b48f: ff 75 08 pushl 0x8(%ebp)
10b492: ff d7 call *%edi
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
10b494: 58 pop %eax
10b495: 5a pop %edx
10b496: 68 f0 bb 11 00 push $0x11bbf0
10b49b: ff 75 08 pushl 0x8(%ebp)
10b49e: ff d7 call *%edi
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
10b4a0: 5b pop %ebx
10b4a1: 5e pop %esi
10b4a2: 68 3c bc 11 00 push $0x11bc3c
10b4a7: ff 75 08 pushl 0x8(%ebp)
10b4aa: ff d7 call *%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 ;
10b4ac: 8b 35 88 26 12 00 mov 0x122688,%esi
id <= _Rate_monotonic_Information.maximum_id ;
10b4b2: 83 c4 10 add $0x10,%esp
10b4b5: 3b 35 8c 26 12 00 cmp 0x12268c,%esi
10b4bb: 76 0c jbe 10b4c9 <rtems_rate_monotonic_report_statistics_with_plugin+0x71><== ALWAYS TAKEN
10b4bd: eb 79 jmp 10b538 <rtems_rate_monotonic_report_statistics_with_plugin+0xe0><== NOT EXECUTED
10b4bf: 90 nop <== NOT EXECUTED
id++ ) {
10b4c0: 46 inc %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 ;
id <= _Rate_monotonic_Information.maximum_id ;
10b4c1: 39 35 8c 26 12 00 cmp %esi,0x12268c
10b4c7: 72 6f jb 10b538 <rtems_rate_monotonic_report_statistics_with_plugin+0xe0>
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
10b4c9: 83 ec 08 sub $0x8,%esp
10b4cc: 8d 45 90 lea -0x70(%ebp),%eax
10b4cf: 50 push %eax
10b4d0: 56 push %esi
10b4d1: e8 a2 53 00 00 call 110878 <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
10b4d6: 83 c4 10 add $0x10,%esp
10b4d9: 85 c0 test %eax,%eax
10b4db: 75 e3 jne 10b4c0 <rtems_rate_monotonic_report_statistics_with_plugin+0x68>
continue;
/* If the above passed, so should this but check it anyway */
status = rtems_rate_monotonic_get_status( id, &the_status );
10b4dd: 83 ec 08 sub $0x8,%esp
10b4e0: 8d 55 c8 lea -0x38(%ebp),%edx
10b4e3: 52 push %edx
10b4e4: 56 push %esi
10b4e5: e8 ea 53 00 00 call 1108d4 <rtems_rate_monotonic_get_status>
#if defined(RTEMS_DEBUG)
if ( status != RTEMS_SUCCESSFUL )
continue;
#endif
name[ 0 ] = '\0';
10b4ea: c6 45 eb 00 movb $0x0,-0x15(%ebp)
if ( the_status.owner ) {
10b4ee: 8b 45 c8 mov -0x38(%ebp),%eax
10b4f1: 83 c4 10 add $0x10,%esp
10b4f4: 85 c0 test %eax,%eax
10b4f6: 0f 85 54 01 00 00 jne 10b650 <rtems_rate_monotonic_report_statistics_with_plugin+0x1f8><== ALWAYS TAKEN
10b4fc: 8d 5d eb lea -0x15(%ebp),%ebx <== NOT EXECUTED
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
10b4ff: 83 ec 08 sub $0x8,%esp
10b502: ff 75 94 pushl -0x6c(%ebp)
10b505: ff 75 90 pushl -0x70(%ebp)
10b508: 53 push %ebx
10b509: 56 push %esi
10b50a: 68 8e bb 11 00 push $0x11bb8e
10b50f: ff 75 08 pushl 0x8(%ebp)
10b512: ff d7 call *%edi
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
10b514: 8b 45 90 mov -0x70(%ebp),%eax
10b517: 83 c4 20 add $0x20,%esp
10b51a: 85 c0 test %eax,%eax
10b51c: 75 22 jne 10b540 <rtems_rate_monotonic_report_statistics_with_plugin+0xe8>
(*print)( context, "\n" );
10b51e: 83 ec 08 sub $0x8,%esp
10b521: 68 f9 a0 11 00 push $0x11a0f9
10b526: ff 75 08 pushl 0x8(%ebp)
10b529: ff d7 call *%edi
10b52b: 83 c4 10 add $0x10,%esp
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
10b52e: 46 inc %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 ;
id <= _Rate_monotonic_Information.maximum_id ;
10b52f: 39 35 8c 26 12 00 cmp %esi,0x12268c
10b535: 73 92 jae 10b4c9 <rtems_rate_monotonic_report_statistics_with_plugin+0x71><== ALWAYS TAKEN
10b537: 90 nop
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
10b538: 8d 65 f4 lea -0xc(%ebp),%esp
10b53b: 5b pop %ebx
10b53c: 5e pop %esi
10b53d: 5f pop %edi
10b53e: c9 leave
10b53f: c3 ret
*/
{
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
struct timespec cpu_average;
_Timespec_Divide_by_integer(
10b540: 52 push %edx
10b541: 8d 55 e0 lea -0x20(%ebp),%edx
10b544: 52 push %edx
10b545: 50 push %eax
10b546: 8d 45 a8 lea -0x58(%ebp),%eax
10b549: 50 push %eax
10b54a: e8 45 34 00 00 call 10e994 <_Timespec_Divide_by_integer>
&the_stats.total_cpu_time,
the_stats.count,
&cpu_average
);
(*print)( context,
10b54f: 8b 4d e4 mov -0x1c(%ebp),%ecx
10b552: bb d3 4d 62 10 mov $0x10624dd3,%ebx
10b557: 89 c8 mov %ecx,%eax
10b559: f7 eb imul %ebx
10b55b: 89 45 88 mov %eax,-0x78(%ebp)
10b55e: 89 55 8c mov %edx,-0x74(%ebp)
10b561: 8b 45 8c mov -0x74(%ebp),%eax
10b564: c1 f8 06 sar $0x6,%eax
10b567: c1 f9 1f sar $0x1f,%ecx
10b56a: 29 c8 sub %ecx,%eax
10b56c: 50 push %eax
10b56d: ff 75 e0 pushl -0x20(%ebp)
10b570: 8b 4d a4 mov -0x5c(%ebp),%ecx
10b573: 89 c8 mov %ecx,%eax
10b575: f7 eb imul %ebx
10b577: 89 45 80 mov %eax,-0x80(%ebp)
10b57a: 89 55 84 mov %edx,-0x7c(%ebp)
10b57d: 8b 45 84 mov -0x7c(%ebp),%eax
10b580: c1 f8 06 sar $0x6,%eax
10b583: c1 f9 1f sar $0x1f,%ecx
10b586: 29 c8 sub %ecx,%eax
10b588: 50 push %eax
10b589: ff 75 a0 pushl -0x60(%ebp)
10b58c: 8b 4d 9c mov -0x64(%ebp),%ecx
10b58f: 89 c8 mov %ecx,%eax
10b591: f7 eb imul %ebx
10b593: 89 85 78 ff ff ff mov %eax,-0x88(%ebp)
10b599: 89 95 7c ff ff ff mov %edx,-0x84(%ebp)
10b59f: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax
10b5a5: c1 f8 06 sar $0x6,%eax
10b5a8: c1 f9 1f sar $0x1f,%ecx
10b5ab: 29 c8 sub %ecx,%eax
10b5ad: 50 push %eax
10b5ae: ff 75 98 pushl -0x68(%ebp)
10b5b1: 68 88 bc 11 00 push $0x11bc88
10b5b6: ff 75 08 pushl 0x8(%ebp)
10b5b9: ff d7 call *%edi
* print Wall time part of statistics
*/
{
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
struct timespec wall_average;
_Timespec_Divide_by_integer(
10b5bb: 83 c4 2c add $0x2c,%esp
10b5be: 8d 55 e0 lea -0x20(%ebp),%edx
10b5c1: 52 push %edx
10b5c2: ff 75 90 pushl -0x70(%ebp)
10b5c5: 8d 45 c0 lea -0x40(%ebp),%eax
10b5c8: 50 push %eax
10b5c9: e8 c6 33 00 00 call 10e994 <_Timespec_Divide_by_integer>
&the_stats.total_wall_time,
the_stats.count,
&wall_average
);
(*print)( context,
10b5ce: 8b 4d e4 mov -0x1c(%ebp),%ecx
10b5d1: 89 c8 mov %ecx,%eax
10b5d3: f7 eb imul %ebx
10b5d5: 89 85 70 ff ff ff mov %eax,-0x90(%ebp)
10b5db: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp)
10b5e1: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax
10b5e7: c1 f8 06 sar $0x6,%eax
10b5ea: c1 f9 1f sar $0x1f,%ecx
10b5ed: 29 c8 sub %ecx,%eax
10b5ef: 50 push %eax
10b5f0: ff 75 e0 pushl -0x20(%ebp)
10b5f3: 8b 4d bc mov -0x44(%ebp),%ecx
10b5f6: 89 c8 mov %ecx,%eax
10b5f8: f7 eb imul %ebx
10b5fa: 89 85 68 ff ff ff mov %eax,-0x98(%ebp)
10b600: 89 95 6c ff ff ff mov %edx,-0x94(%ebp)
10b606: 8b 85 6c ff ff ff mov -0x94(%ebp),%eax
10b60c: c1 f8 06 sar $0x6,%eax
10b60f: c1 f9 1f sar $0x1f,%ecx
10b612: 29 c8 sub %ecx,%eax
10b614: 50 push %eax
10b615: ff 75 b8 pushl -0x48(%ebp)
10b618: 8b 4d b4 mov -0x4c(%ebp),%ecx
10b61b: 89 c8 mov %ecx,%eax
10b61d: f7 eb imul %ebx
10b61f: 89 85 60 ff ff ff mov %eax,-0xa0(%ebp)
10b625: 89 95 64 ff ff ff mov %edx,-0x9c(%ebp)
10b62b: 8b 85 64 ff ff ff mov -0x9c(%ebp),%eax
10b631: c1 f8 06 sar $0x6,%eax
10b634: c1 f9 1f sar $0x1f,%ecx
10b637: 29 c8 sub %ecx,%eax
10b639: 50 push %eax
10b63a: ff 75 b0 pushl -0x50(%ebp)
10b63d: 68 a8 bc 11 00 push $0x11bca8
10b642: ff 75 08 pushl 0x8(%ebp)
10b645: ff d7 call *%edi
10b647: 83 c4 30 add $0x30,%esp
10b64a: e9 71 fe ff ff jmp 10b4c0 <rtems_rate_monotonic_report_statistics_with_plugin+0x68>
10b64f: 90 nop
#endif
name[ 0 ] = '\0';
if ( the_status.owner ) {
rtems_object_get_name( the_status.owner, sizeof(name), name );
10b650: 51 push %ecx
10b651: 8d 5d eb lea -0x15(%ebp),%ebx
10b654: 53 push %ebx
10b655: 6a 05 push $0x5
10b657: 50 push %eax
10b658: e8 5b 01 00 00 call 10b7b8 <rtems_object_get_name>
10b65d: 83 c4 10 add $0x10,%esp
10b660: e9 9a fe ff ff jmp 10b4ff <rtems_rate_monotonic_report_statistics_with_plugin+0xa7>
0010b680 <rtems_rate_monotonic_reset_all_statistics>:
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
10b680: 55 push %ebp
10b681: 89 e5 mov %esp,%ebp
10b683: 53 push %ebx
10b684: 83 ec 04 sub $0x4,%esp
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10b687: a1 78 27 12 00 mov 0x122778,%eax
10b68c: 40 inc %eax
10b68d: a3 78 27 12 00 mov %eax,0x122778
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10b692: 8b 1d 88 26 12 00 mov 0x122688,%ebx
id <= _Rate_monotonic_Information.maximum_id ;
10b698: 3b 1d 8c 26 12 00 cmp 0x12268c,%ebx
10b69e: 77 15 ja 10b6b5 <rtems_rate_monotonic_reset_all_statistics+0x35><== NEVER TAKEN
id++ ) {
status = rtems_rate_monotonic_reset_statistics( id );
10b6a0: 83 ec 0c sub $0xc,%esp
10b6a3: 53 push %ebx
10b6a4: e8 17 00 00 00 call 10b6c0 <rtems_rate_monotonic_reset_statistics>
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
10b6a9: 43 inc %ebx
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
10b6aa: 83 c4 10 add $0x10,%esp
10b6ad: 39 1d 8c 26 12 00 cmp %ebx,0x12268c
10b6b3: 73 eb jae 10b6a0 <rtems_rate_monotonic_reset_all_statistics+0x20>
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
}
10b6b5: 8b 5d fc mov -0x4(%ebp),%ebx
10b6b8: c9 leave
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
10b6b9: e9 66 25 00 00 jmp 10dc24 <_Thread_Enable_dispatch>
001130fc <rtems_region_create>:
uint32_t length,
uint32_t page_size,
rtems_attribute attribute_set,
Objects_Id *id
)
{
1130fc: 55 push %ebp
1130fd: 89 e5 mov %esp,%ebp
1130ff: 57 push %edi
113100: 56 push %esi
113101: 53 push %ebx
113102: 83 ec 0c sub $0xc,%esp
113105: 8b 7d 08 mov 0x8(%ebp),%edi
113108: 8b 75 0c mov 0xc(%ebp),%esi
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
11310b: 85 ff test %edi,%edi
11310d: 74 25 je 113134 <rtems_region_create+0x38>
return RTEMS_INVALID_NAME;
if ( !starting_address )
11310f: 85 f6 test %esi,%esi
113111: 74 0f je 113122 <rtems_region_create+0x26>
return RTEMS_INVALID_ADDRESS;
if ( !id )
113113: 8b 45 1c mov 0x1c(%ebp),%eax
113116: 85 c0 test %eax,%eax
113118: 74 08 je 113122 <rtems_region_create+0x26>
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( starting_address ) )
11311a: f7 c6 03 00 00 00 test $0x3,%esi
113120: 74 22 je 113144 <rtems_region_create+0x48>
return_status = RTEMS_SUCCESSFUL;
}
}
_RTEMS_Unlock_allocator();
return return_status;
113122: bb 09 00 00 00 mov $0x9,%ebx
}
113127: 89 d8 mov %ebx,%eax
113129: 8d 65 f4 lea -0xc(%ebp),%esp
11312c: 5b pop %ebx
11312d: 5e pop %esi
11312e: 5f pop %edi
11312f: c9 leave
113130: c3 ret
113131: 8d 76 00 lea 0x0(%esi),%esi
)
{
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
113134: bb 03 00 00 00 mov $0x3,%ebx
}
}
_RTEMS_Unlock_allocator();
return return_status;
}
113139: 89 d8 mov %ebx,%eax
11313b: 8d 65 f4 lea -0xc(%ebp),%esp
11313e: 5b pop %ebx
11313f: 5e pop %esi
113140: 5f pop %edi
113141: c9 leave
113142: c3 ret
113143: 90 nop
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( starting_address ) )
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
113144: 83 ec 0c sub $0xc,%esp
113147: ff 35 f4 5a 13 00 pushl 0x135af4
11314d: e8 de 22 00 00 call 115430 <_API_Mutex_Lock>
#ifdef __cplusplus
extern "C" {
#endif
/**
113152: c7 04 24 c0 58 13 00 movl $0x1358c0,(%esp)
113159: e8 4e 35 00 00 call 1166ac <_Objects_Allocate>
11315e: 89 c3 mov %eax,%ebx
the_region = _Region_Allocate();
if ( !the_region )
113160: 83 c4 10 add $0x10,%esp
113163: 85 c0 test %eax,%eax
113165: 0f 84 9d 00 00 00 je 113208 <rtems_region_create+0x10c>
return_status = RTEMS_TOO_MANY;
else {
the_region->maximum_segment_size = _Heap_Initialize(
11316b: ff 75 14 pushl 0x14(%ebp)
11316e: ff 75 10 pushl 0x10(%ebp)
113171: 56 push %esi
113172: 8d 40 68 lea 0x68(%eax),%eax
113175: 50 push %eax
113176: e8 5d 30 00 00 call 1161d8 <_Heap_Initialize>
11317b: 89 43 5c mov %eax,0x5c(%ebx)
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
11317e: 83 c4 10 add $0x10,%esp
113181: 85 c0 test %eax,%eax
113183: 75 33 jne 1131b8 <rtems_region_create+0xbc>
* @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
113185: 83 ec 08 sub $0x8,%esp
113188: 53 push %ebx
113189: 68 c0 58 13 00 push $0x1358c0
11318e: e8 d9 38 00 00 call 116a6c <_Objects_Free>
113193: bb 08 00 00 00 mov $0x8,%ebx
113198: 83 c4 10 add $0x10,%esp
*id = the_region->Object.id;
return_status = RTEMS_SUCCESSFUL;
}
}
_RTEMS_Unlock_allocator();
11319b: 83 ec 0c sub $0xc,%esp
11319e: ff 35 f4 5a 13 00 pushl 0x135af4
1131a4: e8 cf 22 00 00 call 115478 <_API_Mutex_Unlock>
1131a9: 83 c4 10 add $0x10,%esp
return return_status;
}
1131ac: 89 d8 mov %ebx,%eax
1131ae: 8d 65 f4 lea -0xc(%ebp),%esp
1131b1: 5b pop %ebx
1131b2: 5e pop %esi
1131b3: 5f pop %edi
1131b4: c9 leave
1131b5: c3 ret
1131b6: 66 90 xchg %ax,%ax
return_status = RTEMS_INVALID_SIZE;
}
else {
the_region->starting_address = starting_address;
1131b8: 89 73 50 mov %esi,0x50(%ebx)
the_region->length = length;
1131bb: 8b 45 10 mov 0x10(%ebp),%eax
1131be: 89 43 54 mov %eax,0x54(%ebx)
the_region->page_size = page_size;
1131c1: 8b 45 14 mov 0x14(%ebp),%eax
1131c4: 89 43 58 mov %eax,0x58(%ebx)
the_region->attribute_set = attribute_set;
1131c7: 8b 45 18 mov 0x18(%ebp),%eax
1131ca: 89 43 60 mov %eax,0x60(%ebx)
the_region->number_of_used_blocks = 0;
1131cd: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
_Thread_queue_Initialize(
1131d4: 6a 06 push $0x6
1131d6: 6a 40 push $0x40
1131d8: c1 e8 02 shr $0x2,%eax
1131db: 83 e0 01 and $0x1,%eax
1131de: 50 push %eax
1131df: 8d 43 10 lea 0x10(%ebx),%eax
1131e2: 50 push %eax
1131e3: e8 70 49 00 00 call 117b58 <_Thread_queue_Initialize>
1131e8: 8b 4b 08 mov 0x8(%ebx),%ecx
1131eb: 0f b7 d1 movzwl %cx,%edx
1131ee: a1 dc 58 13 00 mov 0x1358dc,%eax
1131f3: 89 1c 90 mov %ebx,(%eax,%edx,4)
1131f6: 89 7b 0c mov %edi,0xc(%ebx)
&_Region_Information,
&the_region->Object,
(Objects_Name) name
);
*id = the_region->Object.id;
1131f9: 8b 45 1c mov 0x1c(%ebp),%eax
1131fc: 89 08 mov %ecx,(%eax)
1131fe: 31 db xor %ebx,%ebx
113200: 83 c4 10 add $0x10,%esp
113203: eb 96 jmp 11319b <rtems_region_create+0x9f>
113205: 8d 76 00 lea 0x0(%esi),%esi
_RTEMS_Lock_allocator(); /* to prevent deletion */
the_region = _Region_Allocate();
if ( !the_region )
113208: b3 05 mov $0x5,%bl
11320a: eb 8f jmp 11319b <rtems_region_create+0x9f>
0011320c <rtems_region_delete>:
*/
rtems_status_code rtems_region_delete(
Objects_Id id
)
{
11320c: 55 push %ebp
11320d: 89 e5 mov %esp,%ebp
11320f: 53 push %ebx
113210: 83 ec 20 sub $0x20,%esp
Objects_Locations location;
rtems_status_code return_status = RTEMS_INTERNAL_ERROR;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
113213: ff 35 f4 5a 13 00 pushl 0x135af4
113219: e8 12 22 00 00 call 115430 <_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
11321e: 83 c4 0c add $0xc,%esp
113221: 8d 45 f8 lea -0x8(%ebp),%eax
113224: 50 push %eax
113225: ff 75 08 pushl 0x8(%ebp)
113228: 68 c0 58 13 00 push $0x1358c0
11322d: e8 6e 39 00 00 call 116ba0 <_Objects_Get_no_protection>
113232: 89 c3 mov %eax,%ebx
the_region = _Region_Get( id, &location );
switch ( location ) {
113234: 83 c4 10 add $0x10,%esp
113237: 8b 45 f8 mov -0x8(%ebp),%eax
11323a: 85 c0 test %eax,%eax
11323c: 75 0e jne 11324c <rtems_region_delete+0x40>
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 5 );
if ( the_region->number_of_used_blocks != 0 )
11323e: 8b 4b 64 mov 0x64(%ebx),%ecx
113241: 85 c9 test %ecx,%ecx
113243: 74 2f je 113274 <rtems_region_delete+0x68>
113245: bb 0c 00 00 00 mov $0xc,%ebx
11324a: eb 08 jmp 113254 <rtems_region_delete+0x48>
register Region_Control *the_region;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
11324c: 48 dec %eax
11324d: 74 1d je 11326c <rtems_region_delete+0x60><== ALWAYS TAKEN
11324f: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
113254: 83 ec 0c sub $0xc,%esp
113257: ff 35 f4 5a 13 00 pushl 0x135af4
11325d: e8 16 22 00 00 call 115478 <_API_Mutex_Unlock>
return return_status;
}
113262: 89 d8 mov %ebx,%eax
113264: 8b 5d fc mov -0x4(%ebp),%ebx
113267: c9 leave
113268: c3 ret
113269: 8d 76 00 lea 0x0(%esi),%esi
register Region_Control *the_region;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
11326c: bb 04 00 00 00 mov $0x4,%ebx
113271: eb e1 jmp 113254 <rtems_region_delete+0x48>
113273: 90 nop
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 5 );
if ( the_region->number_of_used_blocks != 0 )
return_status = RTEMS_RESOURCE_IN_USE;
else {
_Objects_Close( &_Region_Information, &the_region->Object );
113274: 83 ec 08 sub $0x8,%esp
113277: 53 push %ebx
113278: 68 c0 58 13 00 push $0x1358c0
11327d: e8 aa 34 00 00 call 11672c <_Objects_Close>
* @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
113282: 58 pop %eax
113283: 5a pop %edx
113284: 53 push %ebx
113285: 68 c0 58 13 00 push $0x1358c0
11328a: e8 dd 37 00 00 call 116a6c <_Objects_Free>
11328f: 31 db xor %ebx,%ebx
113291: 83 c4 10 add $0x10,%esp
113294: eb be jmp 113254 <rtems_region_delete+0x48>
00113298 <rtems_region_extend>:
rtems_status_code rtems_region_extend(
Objects_Id id,
void *starting_address,
uint32_t length
)
{
113298: 55 push %ebp
113299: 89 e5 mov %esp,%ebp
11329b: 56 push %esi
11329c: 53 push %ebx
11329d: 83 ec 10 sub $0x10,%esp
1132a0: 8b 75 0c mov 0xc(%ebp),%esi
Heap_Extend_status heap_status;
Objects_Locations location;
rtems_status_code return_status = RTEMS_INTERNAL_ERROR;
Region_Control *the_region;
if ( !starting_address )
1132a3: 85 f6 test %esi,%esi
1132a5: 74 79 je 113320 <rtems_region_extend+0x88><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
1132a7: 83 ec 0c sub $0xc,%esp
1132aa: ff 35 f4 5a 13 00 pushl 0x135af4
1132b0: e8 7b 21 00 00 call 115430 <_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
1132b5: 83 c4 0c add $0xc,%esp
1132b8: 8d 45 f0 lea -0x10(%ebp),%eax
1132bb: 50 push %eax
1132bc: ff 75 08 pushl 0x8(%ebp)
1132bf: 68 c0 58 13 00 push $0x1358c0
1132c4: e8 d7 38 00 00 call 116ba0 <_Objects_Get_no_protection>
1132c9: 89 c3 mov %eax,%ebx
the_region = _Region_Get( id, &location );
switch ( location ) {
1132cb: 83 c4 10 add $0x10,%esp
1132ce: 8b 45 f0 mov -0x10(%ebp),%eax
1132d1: 85 c0 test %eax,%eax
1132d3: 74 23 je 1132f8 <rtems_region_extend+0x60>
1132d5: 48 dec %eax
1132d6: 74 58 je 113330 <rtems_region_extend+0x98><== ALWAYS TAKEN
switch ( heap_status ) {
case HEAP_EXTEND_SUCCESSFUL:
the_region->length += amount_extended;
the_region->maximum_segment_size += amount_extended;
return_status = RTEMS_SUCCESSFUL;
break;
1132d8: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
1132dd: 83 ec 0c sub $0xc,%esp
1132e0: ff 35 f4 5a 13 00 pushl 0x135af4
1132e6: e8 8d 21 00 00 call 115478 <_API_Mutex_Unlock>
1132eb: 83 c4 10 add $0x10,%esp
return return_status;
}
1132ee: 89 d8 mov %ebx,%eax
1132f0: 8d 65 f8 lea -0x8(%ebp),%esp
1132f3: 5b pop %ebx
1132f4: 5e pop %esi
1132f5: c9 leave
1132f6: c3 ret
1132f7: 90 nop
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
heap_status = _Heap_Extend(
1132f8: 8d 45 f4 lea -0xc(%ebp),%eax
1132fb: 50 push %eax
1132fc: ff 75 10 pushl 0x10(%ebp)
1132ff: 56 push %esi
113300: 8d 43 68 lea 0x68(%ebx),%eax
113303: 50 push %eax
113304: e8 f7 2b 00 00 call 115f00 <_Heap_Extend>
starting_address,
length,
&amount_extended
);
switch ( heap_status ) {
113309: 83 c4 10 add $0x10,%esp
11330c: 83 f8 01 cmp $0x1,%eax
11330f: 74 27 je 113338 <rtems_region_extend+0xa0>
113311: 73 2d jae 113340 <rtems_region_extend+0xa8>
case HEAP_EXTEND_SUCCESSFUL:
the_region->length += amount_extended;
113313: 8b 45 f4 mov -0xc(%ebp),%eax
113316: 01 43 54 add %eax,0x54(%ebx)
the_region->maximum_segment_size += amount_extended;
113319: 01 43 5c add %eax,0x5c(%ebx)
11331c: 31 db xor %ebx,%ebx
11331e: eb bd jmp 1132dd <rtems_region_extend+0x45>
Heap_Extend_status heap_status;
Objects_Locations location;
rtems_status_code return_status = RTEMS_INTERNAL_ERROR;
Region_Control *the_region;
if ( !starting_address )
113320: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
113325: 89 d8 mov %ebx,%eax <== NOT EXECUTED
113327: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
11332a: 5b pop %ebx <== NOT EXECUTED
11332b: 5e pop %esi <== NOT EXECUTED
11332c: c9 leave <== NOT EXECUTED
11332d: c3 ret <== NOT EXECUTED
11332e: 66 90 xchg %ax,%ax <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
the_region = _Region_Get( id, &location );
switch ( location ) {
113330: bb 04 00 00 00 mov $0x4,%ebx
113335: eb a6 jmp 1132dd <rtems_region_extend+0x45>
113337: 90 nop
starting_address,
length,
&amount_extended
);
switch ( heap_status ) {
113338: bb 09 00 00 00 mov $0x9,%ebx
11333d: eb 9e jmp 1132dd <rtems_region_extend+0x45>
11333f: 90 nop
113340: 83 f8 02 cmp $0x2,%eax
113343: 75 93 jne 1132d8 <rtems_region_extend+0x40><== NEVER TAKEN
case HEAP_EXTEND_SUCCESSFUL:
the_region->length += amount_extended;
the_region->maximum_segment_size += amount_extended;
return_status = RTEMS_SUCCESSFUL;
break;
113345: bb 18 00 00 00 mov $0x18,%ebx
11334a: eb 91 jmp 1132dd <rtems_region_extend+0x45>
0011334c <rtems_region_get_free_information>:
rtems_status_code rtems_region_get_free_information(
Objects_Id id,
Heap_Information_block *the_info
)
{
11334c: 55 push %ebp
11334d: 89 e5 mov %esp,%ebp
11334f: 53 push %ebx
113350: 83 ec 14 sub $0x14,%esp
113353: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
rtems_status_code return_status = RTEMS_INTERNAL_ERROR;
register Region_Control *the_region;
if ( !the_info )
113356: 85 db test %ebx,%ebx
113358: 74 7a je 1133d4 <rtems_region_get_free_information+0x88>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
11335a: 83 ec 0c sub $0xc,%esp
11335d: ff 35 f4 5a 13 00 pushl 0x135af4
113363: e8 c8 20 00 00 call 115430 <_API_Mutex_Lock>
113368: 83 c4 0c add $0xc,%esp
11336b: 8d 45 f8 lea -0x8(%ebp),%eax
11336e: 50 push %eax
11336f: ff 75 08 pushl 0x8(%ebp)
113372: 68 c0 58 13 00 push $0x1358c0
113377: e8 24 38 00 00 call 116ba0 <_Objects_Get_no_protection>
the_region = _Region_Get( id, &location );
switch ( location ) {
11337c: 83 c4 10 add $0x10,%esp
11337f: 8b 55 f8 mov -0x8(%ebp),%edx
113382: 85 d2 test %edx,%edx
113384: 74 22 je 1133a8 <rtems_region_get_free_information+0x5c>
113386: 4a dec %edx
113387: 74 57 je 1133e0 <rtems_region_get_free_information+0x94><== ALWAYS TAKEN
113389: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
11338e: 83 ec 0c sub $0xc,%esp
113391: ff 35 f4 5a 13 00 pushl 0x135af4
113397: e8 dc 20 00 00 call 115478 <_API_Mutex_Unlock>
11339c: 83 c4 10 add $0x10,%esp
return return_status;
}
11339f: 89 d8 mov %ebx,%eax
1133a1: 8b 5d fc mov -0x4(%ebp),%ebx
1133a4: c9 leave
1133a5: c3 ret
1133a6: 66 90 xchg %ax,%ax
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_info->Used.number = 0;
1133a8: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
the_info->Used.total = 0;
1133af: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
the_info->Used.largest = 0;
1133b6: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
_Heap_Get_free_information( &the_region->Memory, &the_info->Free );
1133bd: 83 ec 08 sub $0x8,%esp
1133c0: 53 push %ebx
1133c1: 83 c0 68 add $0x68,%eax
1133c4: 50 push %eax
1133c5: e8 3a 2d 00 00 call 116104 <_Heap_Get_free_information>
1133ca: 31 db xor %ebx,%ebx
1133cc: 83 c4 10 add $0x10,%esp
1133cf: eb bd jmp 11338e <rtems_region_get_free_information+0x42>
1133d1: 8d 76 00 lea 0x0(%esi),%esi
{
Objects_Locations location;
rtems_status_code return_status = RTEMS_INTERNAL_ERROR;
register Region_Control *the_region;
if ( !the_info )
1133d4: b3 09 mov $0x9,%bl
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
1133d6: 89 d8 mov %ebx,%eax
1133d8: 8b 5d fc mov -0x4(%ebp),%ebx
1133db: c9 leave
1133dc: c3 ret
1133dd: 8d 76 00 lea 0x0(%esi),%esi
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
1133e0: bb 04 00 00 00 mov $0x4,%ebx
1133e5: eb a7 jmp 11338e <rtems_region_get_free_information+0x42>
001133e8 <rtems_region_get_information>:
rtems_status_code rtems_region_get_information(
Objects_Id id,
Heap_Information_block *the_info
)
{
1133e8: 55 push %ebp
1133e9: 89 e5 mov %esp,%ebp
1133eb: 53 push %ebx
1133ec: 83 ec 14 sub $0x14,%esp
1133ef: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
rtems_status_code return_status = RTEMS_INTERNAL_ERROR;
register Region_Control *the_region;
if ( !the_info )
1133f2: 85 db test %ebx,%ebx
1133f4: 74 6a je 113460 <rtems_region_get_information+0x78>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
1133f6: 83 ec 0c sub $0xc,%esp
1133f9: ff 35 f4 5a 13 00 pushl 0x135af4
1133ff: e8 2c 20 00 00 call 115430 <_API_Mutex_Lock>
113404: 83 c4 0c add $0xc,%esp
113407: 8d 45 f8 lea -0x8(%ebp),%eax
11340a: 50 push %eax
11340b: ff 75 08 pushl 0x8(%ebp)
11340e: 68 c0 58 13 00 push $0x1358c0
113413: e8 88 37 00 00 call 116ba0 <_Objects_Get_no_protection>
the_region = _Region_Get( id, &location );
switch ( location ) {
113418: 83 c4 10 add $0x10,%esp
11341b: 8b 55 f8 mov -0x8(%ebp),%edx
11341e: 85 d2 test %edx,%edx
113420: 74 22 je 113444 <rtems_region_get_information+0x5c>
113422: 4a dec %edx
113423: 74 47 je 11346c <rtems_region_get_information+0x84><== ALWAYS TAKEN
113425: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
11342a: 83 ec 0c sub $0xc,%esp
11342d: ff 35 f4 5a 13 00 pushl 0x135af4
113433: e8 40 20 00 00 call 115478 <_API_Mutex_Unlock>
113438: 83 c4 10 add $0x10,%esp
return return_status;
}
11343b: 89 d8 mov %ebx,%eax
11343d: 8b 5d fc mov -0x4(%ebp),%ebx
113440: c9 leave
113441: c3 ret
113442: 66 90 xchg %ax,%ax
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Heap_Get_information( &the_region->Memory, the_info ) !=
113444: 83 ec 08 sub $0x8,%esp
113447: 53 push %ebx
113448: 83 c0 68 add $0x68,%eax
11344b: 50 push %eax
11344c: e8 fb 2c 00 00 call 11614c <_Heap_Get_information>
113451: 83 c4 10 add $0x10,%esp
113454: 83 f8 01 cmp $0x1,%eax
113457: 19 db sbb %ebx,%ebx
113459: f7 d3 not %ebx
11345b: 83 e3 09 and $0x9,%ebx
11345e: eb ca jmp 11342a <rtems_region_get_information+0x42>
{
Objects_Locations location;
rtems_status_code return_status = RTEMS_INTERNAL_ERROR;
register Region_Control *the_region;
if ( !the_info )
113460: b3 09 mov $0x9,%bl
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
113462: 89 d8 mov %ebx,%eax
113464: 8b 5d fc mov -0x4(%ebp),%ebx
113467: c9 leave
113468: c3 ret
113469: 8d 76 00 lea 0x0(%esi),%esi
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
11346c: bb 04 00 00 00 mov $0x4,%ebx
113471: eb b7 jmp 11342a <rtems_region_get_information+0x42>
00113474 <rtems_region_get_segment>:
uint32_t size,
rtems_option option_set,
rtems_interval timeout,
void **segment
)
{
113474: 55 push %ebp
113475: 89 e5 mov %esp,%ebp
113477: 57 push %edi
113478: 56 push %esi
113479: 53 push %ebx
11347a: 83 ec 1c sub $0x1c,%esp
11347d: 8b 75 0c mov 0xc(%ebp),%esi
113480: 8b 5d 18 mov 0x18(%ebp),%ebx
Objects_Locations location;
rtems_status_code return_status = RTEMS_INTERNAL_ERROR;
register Region_Control *the_region;
void *the_segment;
if ( !segment )
113483: 85 db test %ebx,%ebx
113485: 0f 84 89 00 00 00 je 113514 <rtems_region_get_segment+0xa0><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
*segment = NULL;
11348b: c7 03 00 00 00 00 movl $0x0,(%ebx)
if ( size == 0 )
113491: 85 f6 test %esi,%esi
113493: 75 0f jne 1134a4 <rtems_region_get_segment+0x30><== ALWAYS TAKEN
113495: bb 08 00 00 00 mov $0x8,%ebx <== NOT EXECUTED
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
11349a: 89 d8 mov %ebx,%eax
11349c: 8d 65 f4 lea -0xc(%ebp),%esp
11349f: 5b pop %ebx
1134a0: 5e pop %esi
1134a1: 5f pop %edi
1134a2: c9 leave
1134a3: c3 ret
*segment = NULL;
if ( size == 0 )
return RTEMS_INVALID_SIZE;
_RTEMS_Lock_allocator();
1134a4: 83 ec 0c sub $0xc,%esp
1134a7: ff 35 f4 5a 13 00 pushl 0x135af4
1134ad: e8 7e 1f 00 00 call 115430 <_API_Mutex_Lock>
executing = _Thread_Executing;
1134b2: a1 fc 5a 13 00 mov 0x135afc,%eax
1134b7: 89 45 e0 mov %eax,-0x20(%ebp)
1134ba: 83 c4 0c add $0xc,%esp
1134bd: 8d 45 f0 lea -0x10(%ebp),%eax
1134c0: 50 push %eax
1134c1: ff 75 08 pushl 0x8(%ebp)
1134c4: 68 c0 58 13 00 push $0x1358c0
1134c9: e8 d2 36 00 00 call 116ba0 <_Objects_Get_no_protection>
1134ce: 89 c7 mov %eax,%edi
the_region = _Region_Get( id, &location );
switch ( location ) {
1134d0: 83 c4 10 add $0x10,%esp
1134d3: 8b 45 f0 mov -0x10(%ebp),%eax
1134d6: 85 c0 test %eax,%eax
1134d8: 74 26 je 113500 <rtems_region_get_segment+0x8c>
1134da: 48 dec %eax
1134db: 74 2f je 11350c <rtems_region_get_segment+0x98><== ALWAYS TAKEN
1134dd: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
1134e2: 83 ec 0c sub $0xc,%esp
1134e5: ff 35 f4 5a 13 00 pushl 0x135af4
1134eb: e8 88 1f 00 00 call 115478 <_API_Mutex_Unlock>
1134f0: 83 c4 10 add $0x10,%esp
return return_status;
}
1134f3: 89 d8 mov %ebx,%eax
1134f5: 8d 65 f4 lea -0xc(%ebp),%esp
1134f8: 5b pop %ebx
1134f9: 5e pop %esi
1134fa: 5f pop %edi
1134fb: c9 leave
1134fc: c3 ret
1134fd: 8d 76 00 lea 0x0(%esi),%esi
executing = _Thread_Executing;
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( size > the_region->maximum_segment_size )
113500: 3b 77 5c cmp 0x5c(%edi),%esi
113503: 76 13 jbe 113518 <rtems_region_get_segment+0xa4>
113505: bb 08 00 00 00 mov $0x8,%ebx
11350a: eb d6 jmp 1134e2 <rtems_region_get_segment+0x6e>
_Thread_queue_Enqueue( &the_region->Wait_queue, timeout );
_Thread_Enable_dispatch();
return (rtems_status_code) executing->Wait.return_code;
11350c: bb 04 00 00 00 mov $0x4,%ebx
113511: eb cf jmp 1134e2 <rtems_region_get_segment+0x6e>
113513: 90 nop
Objects_Locations location;
rtems_status_code return_status = RTEMS_INTERNAL_ERROR;
register Region_Control *the_region;
void *the_segment;
if ( !segment )
113514: b3 09 mov $0x9,%bl <== NOT EXECUTED
113516: eb 82 jmp 11349a <rtems_region_get_segment+0x26><== NOT EXECUTED
/**
* 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.
*
113518: 83 ec 08 sub $0x8,%esp
11351b: 56 push %esi
11351c: 8d 47 68 lea 0x68(%edi),%eax
11351f: 50 push %eax
113520: e8 47 29 00 00 call 115e6c <_Heap_Allocate>
the_segment = _Region_Allocate_segment( the_region, size );
_Region_Debug_Walk( the_region, 2 );
if ( the_segment ) {
113525: 83 c4 10 add $0x10,%esp
113528: 85 c0 test %eax,%eax
11352a: 74 09 je 113535 <rtems_region_get_segment+0xc1>
the_region->number_of_used_blocks += 1;
11352c: ff 47 64 incl 0x64(%edi)
*segment = the_segment;
11352f: 89 03 mov %eax,(%ebx)
113531: 31 db xor %ebx,%ebx
113533: eb ad jmp 1134e2 <rtems_region_get_segment+0x6e>
return_status = RTEMS_SUCCESSFUL;
}
else if ( _Options_Is_no_wait( option_set ) ) {
113535: f6 45 10 01 testb $0x1,0x10(%ebp)
113539: 74 07 je 113542 <rtems_region_get_segment+0xce>
11353b: bb 0d 00 00 00 mov $0xd,%ebx
113540: eb a0 jmp 1134e2 <rtems_region_get_segment+0x6e>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
113542: a1 38 5a 13 00 mov 0x135a38,%eax
113547: 40 inc %eax
113548: a3 38 5a 13 00 mov %eax,0x135a38
* 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();
11354d: 83 ec 0c sub $0xc,%esp
113550: ff 35 f4 5a 13 00 pushl 0x135af4
113556: e8 1d 1f 00 00 call 115478 <_API_Mutex_Unlock>
executing->Wait.queue = &the_region->Wait_queue;
11355b: 8d 47 10 lea 0x10(%edi),%eax
11355e: 8b 55 e0 mov -0x20(%ebp),%edx
113561: 89 42 44 mov %eax,0x44(%edx)
executing->Wait.id = id;
113564: 8b 4d 08 mov 0x8(%ebp),%ecx
113567: 89 4a 20 mov %ecx,0x20(%edx)
executing->Wait.count = size;
11356a: 89 72 24 mov %esi,0x24(%edx)
executing->Wait.return_argument = segment;
11356d: 89 5a 28 mov %ebx,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
113570: c7 47 40 01 00 00 00 movl $0x1,0x40(%edi)
_Thread_queue_Enter_critical_section( &the_region->Wait_queue );
_Thread_queue_Enqueue( &the_region->Wait_queue, timeout );
113577: 83 c4 0c add $0xc,%esp
11357a: 68 34 7c 11 00 push $0x117c34
11357f: ff 75 14 pushl 0x14(%ebp)
113582: 50 push %eax
113583: e8 5c 43 00 00 call 1178e4 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
113588: e8 97 3e 00 00 call 117424 <_Thread_Enable_dispatch>
return (rtems_status_code) executing->Wait.return_code;
11358d: 8b 45 e0 mov -0x20(%ebp),%eax
113590: 8b 58 34 mov 0x34(%eax),%ebx
113593: 83 c4 10 add $0x10,%esp
113596: e9 ff fe ff ff jmp 11349a <rtems_region_get_segment+0x26>
0011359c <rtems_region_get_segment_size>:
rtems_status_code rtems_region_get_segment_size(
Objects_Id id,
void *segment,
size_t *size
)
{
11359c: 55 push %ebp
11359d: 89 e5 mov %esp,%ebp
11359f: 56 push %esi
1135a0: 53 push %ebx
1135a1: 83 ec 10 sub $0x10,%esp
1135a4: 8b 75 0c mov 0xc(%ebp),%esi
1135a7: 8b 5d 10 mov 0x10(%ebp),%ebx
Objects_Locations location;
rtems_status_code return_status = RTEMS_INTERNAL_ERROR;
register Region_Control *the_region;
if ( !segment )
1135aa: 85 f6 test %esi,%esi
1135ac: 74 6a je 113618 <rtems_region_get_segment_size+0x7c>
return RTEMS_INVALID_ADDRESS;
if ( !size )
1135ae: 85 db test %ebx,%ebx
1135b0: 74 66 je 113618 <rtems_region_get_segment_size+0x7c>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
1135b2: 83 ec 0c sub $0xc,%esp
1135b5: ff 35 f4 5a 13 00 pushl 0x135af4
1135bb: e8 70 1e 00 00 call 115430 <_API_Mutex_Lock>
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
1135c0: 83 c4 0c add $0xc,%esp
1135c3: 8d 45 f4 lea -0xc(%ebp),%eax
1135c6: 50 push %eax
1135c7: ff 75 08 pushl 0x8(%ebp)
1135ca: 68 c0 58 13 00 push $0x1358c0
1135cf: e8 cc 35 00 00 call 116ba0 <_Objects_Get_no_protection>
the_region = _Region_Get( id, &location );
switch ( location ) {
1135d4: 83 c4 10 add $0x10,%esp
1135d7: 8b 55 f4 mov -0xc(%ebp),%edx
1135da: 85 d2 test %edx,%edx
1135dc: 74 22 je 113600 <rtems_region_get_segment_size+0x64>
1135de: 4a dec %edx
1135df: 74 47 je 113628 <rtems_region_get_segment_size+0x8c><== ALWAYS TAKEN
1135e1: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
1135e6: 83 ec 0c sub $0xc,%esp
1135e9: ff 35 f4 5a 13 00 pushl 0x135af4
1135ef: e8 84 1e 00 00 call 115478 <_API_Mutex_Unlock>
1135f4: 83 c4 10 add $0x10,%esp
return return_status;
}
1135f7: 89 d8 mov %ebx,%eax
1135f9: 8d 65 f8 lea -0x8(%ebp),%esp
1135fc: 5b pop %ebx
1135fd: 5e pop %esi
1135fe: c9 leave
1135ff: c3 ret
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Heap_Size_of_user_area( &the_region->Memory, segment, size ) )
113600: 52 push %edx
113601: 53 push %ebx
113602: 56 push %esi
113603: 83 c0 68 add $0x68,%eax
113606: 50 push %eax
113607: e8 a0 2f 00 00 call 1165ac <_Heap_Size_of_user_area>
11360c: 83 c4 10 add $0x10,%esp
11360f: 3c 01 cmp $0x1,%al
113611: 19 db sbb %ebx,%ebx
113613: 83 e3 09 and $0x9,%ebx
113616: eb ce jmp 1135e6 <rtems_region_get_segment_size+0x4a>
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
return return_status;
113618: bb 09 00 00 00 mov $0x9,%ebx
}
11361d: 89 d8 mov %ebx,%eax
11361f: 8d 65 f8 lea -0x8(%ebp),%esp
113622: 5b pop %ebx
113623: 5e pop %esi
113624: c9 leave
113625: c3 ret
113626: 66 90 xchg %ax,%ax
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
113628: bb 04 00 00 00 mov $0x4,%ebx
11362d: eb b7 jmp 1135e6 <rtems_region_get_segment_size+0x4a>
00113654 <rtems_region_resize_segment>:
Objects_Id id,
void *segment,
size_t size,
size_t *old_size
)
{
113654: 55 push %ebp
113655: 89 e5 mov %esp,%ebp
113657: 57 push %edi
113658: 56 push %esi
113659: 53 push %ebx
11365a: 83 ec 1c sub $0x1c,%esp
11365d: 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 )
113660: 85 ff test %edi,%edi
113662: 0f 84 bc 00 00 00 je 113724 <rtems_region_resize_segment+0xd0>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
113668: 83 ec 0c sub $0xc,%esp
11366b: ff 35 f4 5a 13 00 pushl 0x135af4
113671: e8 ba 1d 00 00 call 115430 <_API_Mutex_Lock>
113676: 83 c4 0c add $0xc,%esp
113679: 8d 45 ec lea -0x14(%ebp),%eax
11367c: 50 push %eax
11367d: ff 75 08 pushl 0x8(%ebp)
113680: 68 c0 58 13 00 push $0x1358c0
113685: e8 16 35 00 00 call 116ba0 <_Objects_Get_no_protection>
11368a: 89 c6 mov %eax,%esi
the_region = _Region_Get( id, &location );
switch ( location ) {
11368c: 83 c4 10 add $0x10,%esp
11368f: 8b 45 ec mov -0x14(%ebp),%eax
113692: 85 c0 test %eax,%eax
113694: 74 2a je 1136c0 <rtems_region_resize_segment+0x6c>
113696: 48 dec %eax
113697: 0f 84 97 00 00 00 je 113734 <rtems_region_resize_segment+0xe0><== ALWAYS TAKEN
11369d: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
1136a2: 83 ec 0c sub $0xc,%esp
1136a5: ff 35 f4 5a 13 00 pushl 0x135af4
1136ab: e8 c8 1d 00 00 call 115478 <_API_Mutex_Unlock>
1136b0: 83 c4 10 add $0x10,%esp
return return_status;
}
1136b3: 89 d8 mov %ebx,%eax
1136b5: 8d 65 f4 lea -0xc(%ebp),%esp
1136b8: 5b pop %ebx
1136b9: 5e pop %esi
1136ba: 5f pop %edi
1136bb: c9 leave
1136bc: c3 ret
1136bd: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 7 );
status = _Heap_Resize_block(
1136c0: 83 ec 0c sub $0xc,%esp
1136c3: 8d 45 f0 lea -0x10(%ebp),%eax
1136c6: 50 push %eax
1136c7: 8d 45 e8 lea -0x18(%ebp),%eax
1136ca: 50 push %eax
1136cb: ff 75 10 pushl 0x10(%ebp)
1136ce: ff 75 0c pushl 0xc(%ebp)
1136d1: 8d 46 68 lea 0x68(%esi),%eax
1136d4: 50 push %eax
1136d5: e8 e6 2c 00 00 call 1163c0 <_Heap_Resize_block>
1136da: 89 c3 mov %eax,%ebx
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
1136dc: 8b 45 e8 mov -0x18(%ebp),%eax
1136df: 89 07 mov %eax,(%edi)
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 )
1136e1: 83 c4 20 add $0x20,%esp
1136e4: 85 db test %ebx,%ebx
1136e6: 75 24 jne 11370c <rtems_region_resize_segment+0xb8><== ALWAYS TAKEN
1136e8: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED
1136eb: 85 c0 test %eax,%eax <== NOT EXECUTED
1136ed: 75 51 jne 113740 <rtems_region_resize_segment+0xec><== NOT EXECUTED
_Region_Process_queue( the_region ); /* unlocks allocator */
else
_RTEMS_Unlock_allocator();
1136ef: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1136f2: ff 35 f4 5a 13 00 pushl 0x135af4 <== NOT EXECUTED
1136f8: e8 7b 1d 00 00 call 115478 <_API_Mutex_Unlock> <== NOT EXECUTED
1136fd: 31 db xor %ebx,%ebx <== NOT EXECUTED
1136ff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
113702: 89 d8 mov %ebx,%eax <== NOT EXECUTED
113704: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
113707: 5b pop %ebx <== NOT EXECUTED
113708: 5e pop %esi <== NOT EXECUTED
113709: 5f pop %edi <== NOT EXECUTED
11370a: c9 leave <== NOT EXECUTED
11370b: c3 ret <== NOT EXECUTED
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 )
_Region_Process_queue( the_region ); /* unlocks allocator */
else
_RTEMS_Unlock_allocator();
11370c: 83 ec 0c sub $0xc,%esp
11370f: ff 35 f4 5a 13 00 pushl 0x135af4
113715: e8 5e 1d 00 00 call 115478 <_API_Mutex_Unlock>
return
11371a: 83 c4 10 add $0x10,%esp
11371d: 83 fb 01 cmp $0x1,%ebx
113720: 74 32 je 113754 <rtems_region_resize_segment+0x100><== NEVER TAKEN
113722: 66 90 xchg %ax,%ax
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
return return_status;
113724: bb 09 00 00 00 mov $0x9,%ebx
}
113729: 89 d8 mov %ebx,%eax
11372b: 8d 65 f4 lea -0xc(%ebp),%esp
11372e: 5b pop %ebx
11372f: 5e pop %esi
113730: 5f pop %edi
113731: c9 leave
113732: c3 ret
113733: 90 nop
if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 )
_Region_Process_queue( the_region ); /* unlocks allocator */
else
_RTEMS_Unlock_allocator();
return
113734: bb 04 00 00 00 mov $0x4,%ebx
113739: e9 64 ff ff ff jmp 1136a2 <rtems_region_resize_segment+0x4e>
11373e: 66 90 xchg %ax,%ax
*old_size = (uint32_t) osize;
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 )
_Region_Process_queue( the_region ); /* unlocks allocator */
113740: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
113743: 56 push %esi <== NOT EXECUTED
113744: e8 6b 6b 00 00 call 11a2b4 <_Region_Process_queue> <== NOT EXECUTED
113749: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
11374c: e9 62 ff ff ff jmp 1136b3 <rtems_region_resize_segment+0x5f><== NOT EXECUTED
113751: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
else
_RTEMS_Unlock_allocator();
return
113754: b3 0d mov $0xd,%bl <== NOT EXECUTED
113756: e9 58 ff ff ff jmp 1136b3 <rtems_region_resize_segment+0x5f><== NOT EXECUTED
0011375c <rtems_region_return_segment>:
rtems_status_code rtems_region_return_segment(
Objects_Id id,
void *segment
)
{
11375c: 55 push %ebp
11375d: 89 e5 mov %esp,%ebp
11375f: 53 push %ebx
113760: 83 ec 20 sub $0x20,%esp
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
113763: ff 35 f4 5a 13 00 pushl 0x135af4
113769: e8 c2 1c 00 00 call 115430 <_API_Mutex_Lock>
11376e: 83 c4 0c add $0xc,%esp
113771: 8d 45 f8 lea -0x8(%ebp),%eax
113774: 50 push %eax
113775: ff 75 08 pushl 0x8(%ebp)
113778: 68 c0 58 13 00 push $0x1358c0
11377d: e8 1e 34 00 00 call 116ba0 <_Objects_Get_no_protection>
113782: 89 c3 mov %eax,%ebx
the_region = _Region_Get( id, &location );
switch ( location ) {
113784: 83 c4 10 add $0x10,%esp
113787: 8b 45 f8 mov -0x8(%ebp),%eax
11378a: 85 c0 test %eax,%eax
11378c: 75 1e jne 1137ac <rtems_region_return_segment+0x50>
);
/**
* 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.
11378e: 83 ec 08 sub $0x8,%esp
113791: ff 75 0c pushl 0xc(%ebp)
113794: 8d 43 68 lea 0x68(%ebx),%eax
113797: 50 push %eax
113798: e8 07 28 00 00 call 115fa4 <_Heap_Free>
#endif
status = _Region_Free_segment( the_region, segment );
_Region_Debug_Walk( the_region, 4 );
if ( !status )
11379d: 83 c4 10 add $0x10,%esp
1137a0: 84 c0 test %al,%al
1137a2: 75 30 jne 1137d4 <rtems_region_return_segment+0x78>
else {
the_region->number_of_used_blocks -= 1;
_Region_Process_queue(the_region); /* unlocks allocator */
return RTEMS_SUCCESSFUL;
1137a4: bb 09 00 00 00 mov $0x9,%ebx
1137a9: eb 09 jmp 1137b4 <rtems_region_return_segment+0x58>
1137ab: 90 nop
register Region_Control *the_region;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
1137ac: 48 dec %eax
1137ad: 74 1d je 1137cc <rtems_region_return_segment+0x70><== ALWAYS TAKEN
1137af: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
1137b4: 83 ec 0c sub $0xc,%esp
1137b7: ff 35 f4 5a 13 00 pushl 0x135af4
1137bd: e8 b6 1c 00 00 call 115478 <_API_Mutex_Unlock>
1137c2: 83 c4 10 add $0x10,%esp
return return_status;
}
1137c5: 89 d8 mov %ebx,%eax
1137c7: 8b 5d fc mov -0x4(%ebp),%ebx
1137ca: c9 leave
1137cb: c3 ret
register Region_Control *the_region;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
1137cc: bb 04 00 00 00 mov $0x4,%ebx
1137d1: eb e1 jmp 1137b4 <rtems_region_return_segment+0x58>
1137d3: 90 nop
if ( !status )
return_status = RTEMS_INVALID_ADDRESS;
else {
the_region->number_of_used_blocks -= 1;
1137d4: ff 4b 64 decl 0x64(%ebx)
_Region_Process_queue(the_region); /* unlocks allocator */
1137d7: 83 ec 0c sub $0xc,%esp
1137da: 53 push %ebx
1137db: e8 d4 6a 00 00 call 11a2b4 <_Region_Process_queue>
1137e0: 31 db xor %ebx,%ebx
1137e2: 83 c4 10 add $0x10,%esp
1137e5: eb de jmp 1137c5 <rtems_region_return_segment+0x69>
0010a170 <rtems_semaphore_create>:
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
10a170: 55 push %ebp
10a171: 89 e5 mov %esp,%ebp
10a173: 57 push %edi
10a174: 56 push %esi
10a175: 53 push %ebx
10a176: 83 ec 2c sub $0x2c,%esp
10a179: 8b 7d 08 mov 0x8(%ebp),%edi
register Semaphore_Control *the_semaphore;
CORE_mutex_Attributes the_mutex_attributes;
CORE_semaphore_Attributes the_semaphore_attributes;
if ( !rtems_is_name_valid( name ) )
10a17c: 85 ff test %edi,%edi
10a17e: 74 64 je 10a1e4 <rtems_semaphore_create+0x74>
return RTEMS_INVALID_NAME;
if ( !id )
10a180: 8b 4d 18 mov 0x18(%ebp),%ecx
10a183: 85 c9 test %ecx,%ecx
10a185: 0f 84 01 01 00 00 je 10a28c <rtems_semaphore_create+0x11c><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
} else
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
10a18b: 8b 45 10 mov 0x10(%ebp),%eax
10a18e: 25 c0 00 00 00 and $0xc0,%eax
10a193: 74 1f je 10a1b4 <rtems_semaphore_create+0x44>
* @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,
10a195: 8b 5d 10 mov 0x10(%ebp),%ebx
10a198: 83 e3 30 and $0x30,%ebx
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) ||
10a19b: 83 fb 10 cmp $0x10,%ebx
10a19e: 74 34 je 10a1d4 <rtems_semaphore_create+0x64>
10a1a0: 83 fb 20 cmp $0x20,%ebx
10a1a3: 74 2f je 10a1d4 <rtems_semaphore_create+0x64>
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
10a1a5: b8 0b 00 00 00 mov $0xb,%eax
}
10a1aa: 8d 65 f4 lea -0xc(%ebp),%esp
10a1ad: 5b pop %ebx
10a1ae: 5e pop %esi
10a1af: 5f pop %edi
10a1b0: c9 leave
10a1b1: c3 ret
10a1b2: 66 90 xchg %ax,%ax
return RTEMS_NOT_DEFINED;
} else
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
10a1b4: 8b 5d 10 mov 0x10(%ebp),%ebx
10a1b7: 83 e3 30 and $0x30,%ebx
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
10a1ba: 85 db test %ebx,%ebx
10a1bc: 74 36 je 10a1f4 <rtems_semaphore_create+0x84>
10a1be: 83 7d 0c 01 cmpl $0x1,0xc(%ebp)
10a1c2: 76 30 jbe 10a1f4 <rtems_semaphore_create+0x84>
10a1c4: b8 0a 00 00 00 mov $0xa,%eax
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10a1c9: 8d 65 f4 lea -0xc(%ebp),%esp
10a1cc: 5b pop %ebx
10a1cd: 5e pop %esi
10a1ce: 5f pop %edi
10a1cf: c9 leave
10a1d0: c3 ret
10a1d1: 8d 76 00 lea 0x0(%esi),%esi
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) ||
10a1d4: f6 45 10 04 testb $0x4,0x10(%ebp)
10a1d8: 74 cb je 10a1a5 <rtems_semaphore_create+0x35>
_Attributes_Is_priority( attribute_set ) ) )
return RTEMS_NOT_DEFINED;
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
10a1da: 3d c0 00 00 00 cmp $0xc0,%eax
10a1df: 75 d9 jne 10a1ba <rtems_semaphore_create+0x4a>
10a1e1: eb c2 jmp 10a1a5 <rtems_semaphore_create+0x35>
10a1e3: 90 nop
{
register Semaphore_Control *the_semaphore;
CORE_mutex_Attributes the_mutex_attributes;
CORE_semaphore_Attributes the_semaphore_attributes;
if ( !rtems_is_name_valid( name ) )
10a1e4: b8 03 00 00 00 mov $0x3,%eax
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10a1e9: 8d 65 f4 lea -0xc(%ebp),%esp
10a1ec: 5b pop %ebx
10a1ed: 5e pop %esi
10a1ee: 5f pop %edi
10a1ef: c9 leave
10a1f0: c3 ret
10a1f1: 8d 76 00 lea 0x0(%esi),%esi
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10a1f4: a1 58 e6 11 00 mov 0x11e658,%eax
10a1f9: 40 inc %eax
10a1fa: a3 58 e6 11 00 mov %eax,0x11e658
#ifdef __cplusplus
extern "C" {
#endif
/**
10a1ff: 83 ec 0c sub $0xc,%esp
10a202: 68 a0 e5 11 00 push $0x11e5a0
10a207: e8 a8 13 00 00 call 10b5b4 <_Objects_Allocate>
10a20c: 89 c6 mov %eax,%esi
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
10a20e: 83 c4 10 add $0x10,%esp
10a211: 85 c0 test %eax,%eax
10a213: 0f 84 eb 00 00 00 je 10a304 <rtems_semaphore_create+0x194>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_semaphore->attribute_set = attribute_set;
10a219: 8b 45 10 mov 0x10(%ebp),%eax
10a21c: 89 46 10 mov %eax,0x10(%esi)
* 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 ) ) {
10a21f: 85 db test %ebx,%ebx
10a221: 74 75 je 10a298 <rtems_semaphore_create+0x128>
CORE_mutex_Status mutex_status;
if ( _Attributes_Is_inherit_priority( attribute_set ) )
10a223: a8 40 test $0x40,%al
10a225: 0f 84 c5 00 00 00 je 10a2f0 <rtems_semaphore_create+0x180>
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
10a22b: c7 45 e4 02 00 00 00 movl $0x2,-0x1c(%ebp)
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
else
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
10a232: 83 fb 10 cmp $0x10,%ebx
10a235: 0f 84 d9 00 00 00 je 10a314 <rtems_semaphore_create+0x1a4>
case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
the_mutex_attributes.only_owner_release = TRUE;
break;
}
} else {
the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
10a23b: c7 45 dc 02 00 00 00 movl $0x2,-0x24(%ebp)
the_mutex_attributes.only_owner_release = FALSE;
10a242: c6 45 e0 00 movb $0x0,-0x20(%ebp)
}
the_mutex_attributes.priority_ceiling = priority_ceiling;
10a246: 8b 45 14 mov 0x14(%ebp),%eax
10a249: 89 45 e8 mov %eax,-0x18(%ebp)
mutex_status = _CORE_mutex_Initialize(
10a24c: 52 push %edx
10a24d: 31 c0 xor %eax,%eax
10a24f: 83 7d 0c 01 cmpl $0x1,0xc(%ebp)
10a253: 0f 94 c0 sete %al
10a256: 50 push %eax
10a257: 8d 45 dc lea -0x24(%ebp),%eax
10a25a: 50 push %eax
10a25b: 8d 46 14 lea 0x14(%esi),%eax
10a25e: 50 push %eax
10a25f: e8 a0 0c 00 00 call 10af04 <_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 ) {
10a264: 83 c4 10 add $0x10,%esp
10a267: 83 f8 06 cmp $0x6,%eax
10a26a: 75 61 jne 10a2cd <rtems_semaphore_create+0x15d><== 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
10a26c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10a26f: 56 push %esi <== NOT EXECUTED
10a270: 68 a0 e5 11 00 push $0x11e5a0 <== NOT EXECUTED
10a275: e8 fa 16 00 00 call 10b974 <_Objects_Free> <== NOT EXECUTED
_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
10a27a: e8 6d 20 00 00 call 10c2ec <_Thread_Enable_dispatch><== NOT EXECUTED
10a27f: b8 13 00 00 00 mov $0x13,%eax <== NOT EXECUTED
10a284: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a287: e9 1e ff ff ff jmp 10a1aa <rtems_semaphore_create+0x3a><== NOT EXECUTED
CORE_semaphore_Attributes the_semaphore_attributes;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
10a28c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
10a291: e9 14 ff ff ff jmp 10a1aa <rtems_semaphore_create+0x3a><== NOT EXECUTED
10a296: 66 90 xchg %ax,%ax <== NOT EXECUTED
_Thread_Enable_dispatch();
return RTEMS_INVALID_PRIORITY;
}
} else {
if ( _Attributes_Is_priority( attribute_set ) )
the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
10a298: 31 c0 xor %eax,%eax
10a29a: f6 45 10 04 testb $0x4,0x10(%ebp)
10a29e: 0f 95 c0 setne %al
10a2a1: 89 45 f0 mov %eax,-0x10(%ebp)
/*
* This effectively disables limit checking.
*/
the_semaphore_attributes.maximum_count = 0xFFFFFFFF;
10a2a4: 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;
10a2ab: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM;
10a2b2: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp)
_CORE_semaphore_Initialize(
10a2b9: 50 push %eax
10a2ba: ff 75 0c pushl 0xc(%ebp)
10a2bd: 8d 45 ec lea -0x14(%ebp),%eax
10a2c0: 50 push %eax
10a2c1: 8d 46 14 lea 0x14(%esi),%eax
10a2c4: 50 push %eax
10a2c5: e8 f2 0e 00 00 call 10b1bc <_CORE_semaphore_Initialize>
10a2ca: 83 c4 10 add $0x10,%esp
10a2cd: 8b 4e 08 mov 0x8(%esi),%ecx
10a2d0: 0f b7 d1 movzwl %cx,%edx
10a2d3: a1 bc e5 11 00 mov 0x11e5bc,%eax
10a2d8: 89 34 90 mov %esi,(%eax,%edx,4)
10a2db: 89 7e 0c mov %edi,0xc(%esi)
&_Semaphore_Information,
&the_semaphore->Object,
(Objects_Name) name
);
*id = the_semaphore->Object.id;
10a2de: 8b 45 18 mov 0x18(%ebp),%eax
10a2e1: 89 08 mov %ecx,(%eax)
the_semaphore->Object.id,
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
10a2e3: e8 04 20 00 00 call 10c2ec <_Thread_Enable_dispatch>
10a2e8: 31 c0 xor %eax,%eax
10a2ea: e9 bb fe ff ff jmp 10a1aa <rtems_semaphore_create+0x3a>
10a2ef: 90 nop
if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
CORE_mutex_Status mutex_status;
if ( _Attributes_Is_inherit_priority( attribute_set ) )
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
else if ( _Attributes_Is_priority_ceiling( attribute_set ) )
10a2f0: 80 7d 10 00 cmpb $0x0,0x10(%ebp)
10a2f4: 79 43 jns 10a339 <rtems_semaphore_create+0x1c9>
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
10a2f6: c7 45 e4 03 00 00 00 movl $0x3,-0x1c(%ebp)
10a2fd: e9 30 ff ff ff jmp 10a232 <rtems_semaphore_create+0xc2>
10a302: 66 90 xchg %ax,%ax
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
10a304: e8 e3 1f 00 00 call 10c2ec <_Thread_Enable_dispatch>
10a309: b8 05 00 00 00 mov $0x5,%eax
10a30e: e9 97 fe ff ff jmp 10a1aa <rtems_semaphore_create+0x3a>
10a313: 90 nop
else
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
10a314: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
switch ( the_mutex_attributes.discipline ) {
10a31b: 8b 45 e4 mov -0x1c(%ebp),%eax
10a31e: 83 f8 01 cmp $0x1,%eax
10a321: 0f 86 1b ff ff ff jbe 10a242 <rtems_semaphore_create+0xd2>
10a327: 83 f8 03 cmp $0x3,%eax
10a32a: 0f 87 16 ff ff ff ja 10a246 <rtems_semaphore_create+0xd6><== 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;
10a330: c6 45 e0 01 movb $0x1,-0x20(%ebp)
10a334: e9 0d ff ff ff jmp 10a246 <rtems_semaphore_create+0xd6>
if ( _Attributes_Is_inherit_priority( attribute_set ) )
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
else if ( _Attributes_Is_priority_ceiling( attribute_set ) )
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
else if ( _Attributes_Is_priority( attribute_set ) )
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
10a339: 31 c0 xor %eax,%eax
10a33b: f6 45 10 04 testb $0x4,0x10(%ebp)
10a33f: 0f 95 c0 setne %al
10a342: 89 45 e4 mov %eax,-0x1c(%ebp)
10a345: e9 e8 fe ff ff jmp 10a232 <rtems_semaphore_create+0xc2>
0010a34c <rtems_semaphore_delete>:
#endif
rtems_status_code rtems_semaphore_delete(
rtems_id id
)
{
10a34c: 55 push %ebp
10a34d: 89 e5 mov %esp,%ebp
10a34f: 53 push %ebx
10a350: 83 ec 18 sub $0x18,%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
10a353: 8d 45 f8 lea -0x8(%ebp),%eax
10a356: 50 push %eax
10a357: ff 75 08 pushl 0x8(%ebp)
10a35a: 68 a0 e5 11 00 push $0x11e5a0
10a35f: e8 44 17 00 00 call 10baa8 <_Objects_Get>
10a364: 89 c3 mov %eax,%ebx
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
10a366: 83 c4 10 add $0x10,%esp
10a369: 8b 4d f8 mov -0x8(%ebp),%ecx
10a36c: 85 c9 test %ecx,%ecx
10a36e: 74 0c je 10a37c <rtems_semaphore_delete+0x30>
10a370: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a375: 8b 5d fc mov -0x4(%ebp),%ebx
10a378: c9 leave
10a379: c3 ret
10a37a: 66 90 xchg %ax,%ax
);
/**
* This function tries to resize in place the block that is pointed to by the
* @a starting_address to the new @a size.
*
10a37c: 8b 40 10 mov 0x10(%eax),%eax
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
10a37f: 83 e0 30 and $0x30,%eax
10a382: 74 58 je 10a3dc <rtems_semaphore_delete+0x90>
if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) &&
10a384: 8b 53 64 mov 0x64(%ebx),%edx
10a387: 85 d2 test %edx,%edx
10a389: 75 15 jne 10a3a0 <rtems_semaphore_delete+0x54>
10a38b: 83 f8 20 cmp $0x20,%eax
10a38e: 74 10 je 10a3a0 <rtems_semaphore_delete+0x54>
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
10a390: e8 57 1f 00 00 call 10c2ec <_Thread_Enable_dispatch>
10a395: b8 0c 00 00 00 mov $0xc,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a39a: 8b 5d fc mov -0x4(%ebp),%ebx
10a39d: c9 leave
10a39e: c3 ret
10a39f: 90 nop
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
_CORE_mutex_Flush(
10a3a0: 50 push %eax
10a3a1: 6a 04 push $0x4
10a3a3: 6a 00 push $0x0
10a3a5: 8d 43 14 lea 0x14(%ebx),%eax
10a3a8: 50 push %eax
10a3a9: e8 4a 0b 00 00 call 10aef8 <_CORE_mutex_Flush>
10a3ae: 83 c4 10 add $0x10,%esp
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_WAS_DELETED
);
}
_Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
10a3b1: 83 ec 08 sub $0x8,%esp
10a3b4: 53 push %ebx
10a3b5: 68 a0 e5 11 00 push $0x11e5a0
10a3ba: e8 75 12 00 00 call 10b634 <_Objects_Close>
* @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
10a3bf: 58 pop %eax
10a3c0: 5a pop %edx
10a3c1: 53 push %ebx
10a3c2: 68 a0 e5 11 00 push $0x11e5a0
10a3c7: e8 a8 15 00 00 call 10b974 <_Objects_Free>
0, /* Not used */
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
10a3cc: e8 1b 1f 00 00 call 10c2ec <_Thread_Enable_dispatch>
10a3d1: 31 c0 xor %eax,%eax
10a3d3: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a3d6: 8b 5d fc mov -0x4(%ebp),%ebx
10a3d9: c9 leave
10a3da: c3 ret
10a3db: 90 nop
&the_semaphore->Core_control.mutex,
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_MUTEX_WAS_DELETED
);
} else {
_CORE_semaphore_Flush(
10a3dc: 51 push %ecx
10a3dd: 6a 02 push $0x2
10a3df: 6a 00 push $0x0
10a3e1: 8d 43 14 lea 0x14(%ebx),%eax
10a3e4: 50 push %eax
10a3e5: e8 c6 0d 00 00 call 10b1b0 <_CORE_semaphore_Flush>
10a3ea: 83 c4 10 add $0x10,%esp
10a3ed: eb c2 jmp 10a3b1 <rtems_semaphore_delete+0x65>
00113a68 <rtems_semaphore_flush>:
#endif
rtems_status_code rtems_semaphore_flush(
rtems_id id
)
{
113a68: 55 push %ebp
113a69: 89 e5 mov %esp,%ebp
113a6b: 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
113a6e: 8d 45 fc lea -0x4(%ebp),%eax
113a71: 50 push %eax
113a72: ff 75 08 pushl 0x8(%ebp)
113a75: 68 00 59 13 00 push $0x135900
113a7a: e8 61 31 00 00 call 116be0 <_Objects_Get>
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
113a7f: 83 c4 10 add $0x10,%esp
113a82: 8b 55 fc mov -0x4(%ebp),%edx
113a85: 85 d2 test %edx,%edx
113a87: 74 07 je 113a90 <rtems_semaphore_flush+0x28>
113a89: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
113a8e: c9 leave
113a8f: c3 ret
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
113a90: f6 40 10 30 testb $0x30,0x10(%eax)
113a94: 75 1a jne 113ab0 <rtems_semaphore_flush+0x48><== ALWAYS TAKEN
&the_semaphore->Core_control.mutex,
SEND_OBJECT_WAS_DELETED,
CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT
);
} else {
_CORE_semaphore_Flush(
113a96: 52 push %edx <== NOT EXECUTED
113a97: 6a 01 push $0x1 <== NOT EXECUTED
113a99: 6a 00 push $0x0 <== NOT EXECUTED
113a9b: 83 c0 14 add $0x14,%eax <== NOT EXECUTED
113a9e: 50 push %eax <== NOT EXECUTED
113a9f: e8 80 21 00 00 call 115c24 <_CORE_semaphore_Flush> <== NOT EXECUTED
113aa4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
&the_semaphore->Core_control.semaphore,
SEND_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT
);
}
_Thread_Enable_dispatch();
113aa7: e8 78 39 00 00 call 117424 <_Thread_Enable_dispatch>
113aac: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
113aae: c9 leave
113aaf: c3 ret
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
_CORE_mutex_Flush(
113ab0: 51 push %ecx
113ab1: 6a 01 push $0x1
113ab3: 6a 00 push $0x0
113ab5: 83 c0 14 add $0x14,%eax
113ab8: 50 push %eax
113ab9: e8 ae 1e 00 00 call 11596c <_CORE_mutex_Flush>
113abe: 83 c4 10 add $0x10,%esp
113ac1: eb e4 jmp 113aa7 <rtems_semaphore_flush+0x3f>
0010a3f0 <rtems_semaphore_obtain>:
rtems_status_code rtems_semaphore_obtain(
rtems_id id,
rtems_option option_set,
rtems_interval timeout
)
{
10a3f0: 55 push %ebp
10a3f1: 89 e5 mov %esp,%ebp
10a3f3: 56 push %esi
10a3f4: 53 push %ebx
10a3f5: 83 ec 10 sub $0x10,%esp
10a3f8: 8b 5d 08 mov 0x8(%ebp),%ebx
* @param[in] size is the amount of memory to allocate in bytes
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
10a3fb: 8d 45 f0 lea -0x10(%ebp),%eax
10a3fe: 50 push %eax
10a3ff: 8d 45 f4 lea -0xc(%ebp),%eax
10a402: 50 push %eax
10a403: 53 push %ebx
10a404: 68 a0 e5 11 00 push $0x11e5a0
10a409: e8 4e 16 00 00 call 10ba5c <_Objects_Get_isr_disable>
10a40e: 89 c2 mov %eax,%edx
register Semaphore_Control *the_semaphore;
Objects_Locations location;
ISR_Level level;
the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
switch ( location ) {
10a410: 83 c4 10 add $0x10,%esp
10a413: 8b 4d f4 mov -0xc(%ebp),%ecx
10a416: 85 c9 test %ecx,%ecx
10a418: 74 0e je 10a428 <rtems_semaphore_obtain+0x38>
10a41a: b8 04 00 00 00 mov $0x4,%eax
break;
}
return RTEMS_INVALID_ID;
}
10a41f: 8d 65 f8 lea -0x8(%ebp),%esp
10a422: 5b pop %ebx
10a423: 5e pop %esi
10a424: c9 leave
10a425: c3 ret
10a426: 66 90 xchg %ax,%ax
the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
10a428: f6 40 10 30 testb $0x30,0x10(%eax)
10a42c: 74 3a je 10a468 <rtems_semaphore_obtain+0x78>
_CORE_mutex_Seize(
10a42e: 83 ec 0c sub $0xc,%esp
10a431: ff 75 f0 pushl -0x10(%ebp)
10a434: ff 75 10 pushl 0x10(%ebp)
10a437: 83 75 0c 01 xorl $0x1,0xc(%ebp)
10a43b: 83 65 0c 01 andl $0x1,0xc(%ebp)
10a43f: ff 75 0c pushl 0xc(%ebp)
10a442: 53 push %ebx
10a443: 8d 40 14 lea 0x14(%eax),%eax
10a446: 50 push %eax
10a447: e8 b0 0b 00 00 call 10affc <_CORE_mutex_Seize>
id,
((_Options_Is_no_wait( option_set )) ? FALSE : TRUE),
timeout,
level
);
return _Semaphore_Translate_core_mutex_return_code(
10a44c: 83 c4 14 add $0x14,%esp
10a44f: a1 1c e7 11 00 mov 0x11e71c,%eax
10a454: ff 70 34 pushl 0x34(%eax)
10a457: e8 0c 01 00 00 call 10a568 <_Semaphore_Translate_core_mutex_return_code>
10a45c: 83 c4 10 add $0x10,%esp
break;
}
return RTEMS_INVALID_ID;
}
10a45f: 8d 65 f8 lea -0x8(%ebp),%esp
10a462: 5b pop %ebx
10a463: 5e pop %esi
10a464: c9 leave
10a465: c3 ret
10a466: 66 90 xchg %ax,%ax
/**
* 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.
*
* @param[in] the_heap is the heap to operate upon
10a468: 8b 75 f0 mov -0x10(%ebp),%esi
* @param[in] size is the amount of memory to allocate in bytes
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate(
10a46b: 8b 0d 1c e7 11 00 mov 0x11e71c,%ecx
Heap_Control *the_heap,
10a471: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx)
size_t size
10a478: 8b 40 5c mov 0x5c(%eax),%eax
10a47b: 85 c0 test %eax,%eax
10a47d: 75 29 jne 10a4a8 <rtems_semaphore_obtain+0xb8>
);
/**
* 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.
10a47f: f6 45 0c 01 testb $0x1,0xc(%ebp)
10a483: 74 2b je 10a4b0 <rtems_semaphore_obtain+0xc0>
* Any other value of @a alignment is taken "as is", i.e., even odd
10a485: 56 push %esi
10a486: 9d popf
* alignments are possible.
10a487: c7 41 34 01 00 00 00 movl $0x1,0x34(%ecx)
id,
((_Options_Is_no_wait( option_set )) ? FALSE : TRUE),
timeout,
&level
);
return _Semaphore_Translate_core_semaphore_return_code(
10a48e: 83 ec 0c sub $0xc,%esp
10a491: a1 1c e7 11 00 mov 0x11e71c,%eax
10a496: ff 70 34 pushl 0x34(%eax)
10a499: e8 da 00 00 00 call 10a578 <_Semaphore_Translate_core_semaphore_return_code>
10a49e: 83 c4 10 add $0x10,%esp
break;
}
return RTEMS_INVALID_ID;
}
10a4a1: 8d 65 f8 lea -0x8(%ebp),%esp
10a4a4: 5b pop %ebx
10a4a5: 5e pop %esi
10a4a6: c9 leave
10a4a7: c3 ret
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
10a4a8: 48 dec %eax
10a4a9: 89 42 5c mov %eax,0x5c(%edx)
10a4ac: 56 push %esi
10a4ad: 9d popf
10a4ae: eb de jmp 10a48e <rtems_semaphore_obtain+0x9e>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10a4b0: a1 58 e6 11 00 mov 0x11e658,%eax
10a4b5: 40 inc %eax
10a4b6: a3 58 e6 11 00 mov %eax,0x11e658
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
* This routine grows @a the_heap memory area using the size bytes which
10a4bb: c7 42 44 01 00 00 00 movl $0x1,0x44(%edx)
* 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
10a4c2: 8d 42 14 lea 0x14(%edx),%eax
10a4c5: 89 41 44 mov %eax,0x44(%ecx)
* @return NULL if unsuccessful and a pointer to the block if successful
10a4c8: 89 59 20 mov %ebx,0x20(%ecx)
*/
10a4cb: 56 push %esi
10a4cc: 9d popf
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
10a4cd: 52 push %edx
10a4ce: 68 fc ca 10 00 push $0x10cafc
10a4d3: ff 75 10 pushl 0x10(%ebp)
10a4d6: 50 push %eax
10a4d7: e8 d0 22 00 00 call 10c7ac <_Thread_queue_Enqueue_with_handler>
size_t size,
10a4dc: e8 0b 1e 00 00 call 10c2ec <_Thread_Enable_dispatch>
10a4e1: 83 c4 10 add $0x10,%esp
10a4e4: eb a8 jmp 10a48e <rtems_semaphore_obtain+0x9e>
0010a4e8 <rtems_semaphore_release>:
#endif
rtems_status_code rtems_semaphore_release(
rtems_id id
)
{
10a4e8: 55 push %ebp
10a4e9: 89 e5 mov %esp,%ebp
10a4eb: 53 push %ebx
10a4ec: 83 ec 18 sub $0x18,%esp
10a4ef: 8b 5d 08 mov 0x8(%ebp),%ebx
* 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
10a4f2: 8d 45 f8 lea -0x8(%ebp),%eax
10a4f5: 50 push %eax
10a4f6: 53 push %ebx
10a4f7: 68 a0 e5 11 00 push $0x11e5a0
10a4fc: e8 a7 15 00 00 call 10baa8 <_Objects_Get>
Objects_Locations location;
CORE_mutex_Status mutex_status;
CORE_semaphore_Status semaphore_status;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
10a501: 83 c4 10 add $0x10,%esp
10a504: 8b 55 f8 mov -0x8(%ebp),%edx
10a507: 85 d2 test %edx,%edx
10a509: 74 0d je 10a518 <rtems_semaphore_release+0x30>
10a50b: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a510: 8b 5d fc mov -0x4(%ebp),%ebx
10a513: c9 leave
10a514: c3 ret
10a515: 8d 76 00 lea 0x0(%esi),%esi
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
10a518: f6 40 10 30 testb $0x30,0x10(%eax)
10a51c: 75 26 jne 10a544 <rtems_semaphore_release+0x5c>
MUTEX_MP_SUPPORT
);
_Thread_Enable_dispatch();
return _Semaphore_Translate_core_mutex_return_code( mutex_status );
} else {
semaphore_status = _CORE_semaphore_Surrender(
10a51e: 52 push %edx
10a51f: 6a 00 push $0x0
10a521: 53 push %ebx
10a522: 83 c0 14 add $0x14,%eax
10a525: 50 push %eax
10a526: e8 d1 0c 00 00 call 10b1fc <_CORE_semaphore_Surrender>
10a52b: 89 c3 mov %eax,%ebx
&the_semaphore->Core_control.semaphore,
id,
MUTEX_MP_SUPPORT
);
_Thread_Enable_dispatch();
10a52d: e8 ba 1d 00 00 call 10c2ec <_Thread_Enable_dispatch>
return
10a532: 89 1c 24 mov %ebx,(%esp)
10a535: e8 3e 00 00 00 call 10a578 <_Semaphore_Translate_core_semaphore_return_code>
10a53a: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a53d: 8b 5d fc mov -0x4(%ebp),%ebx
10a540: c9 leave
10a541: c3 ret
10a542: 66 90 xchg %ax,%ax
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
mutex_status = _CORE_mutex_Surrender(
10a544: 51 push %ecx
10a545: 6a 00 push $0x0
10a547: 53 push %ebx
10a548: 83 c0 14 add $0x14,%eax
10a54b: 50 push %eax
10a54c: e8 47 0b 00 00 call 10b098 <_CORE_mutex_Surrender>
10a551: 89 c3 mov %eax,%ebx
&the_semaphore->Core_control.mutex,
id,
MUTEX_MP_SUPPORT
);
_Thread_Enable_dispatch();
10a553: e8 94 1d 00 00 call 10c2ec <_Thread_Enable_dispatch>
return _Semaphore_Translate_core_mutex_return_code( mutex_status );
10a558: 89 1c 24 mov %ebx,(%esp)
10a55b: e8 08 00 00 00 call 10a568 <_Semaphore_Translate_core_mutex_return_code>
10a560: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a563: 8b 5d fc mov -0x4(%ebp),%ebx
10a566: c9 leave
10a567: c3 ret
00116888 <rtems_shutdown_executive>:
*/
void rtems_shutdown_executive(
uint32_t result
)
{
116888: 55 push %ebp
116889: 89 e5 mov %esp,%ebp
11688b: 83 ec 28 sub $0x28,%esp
if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) {
11688e: 83 3d 24 e8 11 00 04 cmpl $0x4,0x11e824
116895: 74 1e je 1168b5 <rtems_shutdown_executive+0x2d><== NEVER TAKEN
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
116897: c7 05 24 e8 11 00 04 movl $0x4,0x11e824
11689e: 00 00 00
#endif
}
/**
* This routine sets the current system state to that specified by
* the called.
1168a1: 83 ec 08 sub $0x8,%esp
1168a4: 68 40 e6 11 00 push $0x11e640
1168a9: 8d 45 e8 lea -0x18(%ebp),%eax
1168ac: 50 push %eax
1168ad: e8 0e 6c ff ff call 10d4c0 <_CPU_Context_switch>
1168b2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_SHUTDOWN );
_Thread_Stop_multitasking();
}
}
1168b5: c9 leave <== NOT EXECUTED
1168b6: c3 ret <== NOT EXECUTED
0010b224 <rtems_signal_catch>:
rtems_status_code rtems_signal_catch(
rtems_asr_entry asr_handler,
rtems_mode mode_set
)
{
10b224: 55 push %ebp
10b225: 89 e5 mov %esp,%ebp
10b227: 83 ec 08 sub $0x8,%esp
10b22a: 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 ];
10b22d: a1 9c 17 12 00 mov 0x12179c,%eax
10b232: 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
10b238: a1 d8 16 12 00 mov 0x1216d8,%eax
10b23d: 40 inc %eax
10b23e: a3 d8 16 12 00 mov %eax,0x1216d8
asr = &api->Signal;
_Thread_Disable_dispatch(); /* cannot reschedule while */
/* the thread is inconsistent */
if ( !_ASR_Is_null_handler( asr_handler ) ) {
10b243: 85 c9 test %ecx,%ecx
10b245: 74 15 je 10b25c <rtems_signal_catch+0x38><== NEVER TAKEN
asr->mode_set = mode_set;
10b247: 8b 45 0c mov 0xc(%ebp),%eax
10b24a: 89 42 10 mov %eax,0x10(%edx)
asr->handler = asr_handler;
10b24d: 89 4a 0c mov %ecx,0xc(%edx)
}
else
_ASR_Initialize( asr );
_Thread_Enable_dispatch();
10b250: e8 0b 21 00 00 call 10d360 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
}
10b255: 31 c0 xor %eax,%eax
10b257: c9 leave
10b258: c3 ret
10b259: 8d 76 00 lea 0x0(%esi),%esi
#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
10b25c: 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
10b260: 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.
10b267: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) <== NOT EXECUTED
*
10b26e: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx) <== NOT EXECUTED
* @param[in] the_heap is the heap to operate upon
10b275: 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
10b27c: c7 42 1c 00 00 00 00 movl $0x0,0x1c(%edx) <== NOT EXECUTED
asr->mode_set = mode_set;
asr->handler = asr_handler;
}
else
_ASR_Initialize( asr );
_Thread_Enable_dispatch();
10b283: e8 d8 20 00 00 call 10d360 <_Thread_Enable_dispatch><== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
10b288: 31 c0 xor %eax,%eax <== NOT EXECUTED
10b28a: c9 leave <== NOT EXECUTED
10b28b: c3 ret <== NOT EXECUTED
00113c80 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
Objects_Id id,
rtems_signal_set signal_set
)
{
113c80: 55 push %ebp
113c81: 89 e5 mov %esp,%ebp
113c83: 53 push %ebx
113c84: 83 ec 14 sub $0x14,%esp
113c87: 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 )
113c8a: 85 db test %ebx,%ebx
113c8c: 75 0a jne 113c98 <rtems_signal_send+0x18><== ALWAYS TAKEN
113c8e: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
113c93: 8b 5d fc mov -0x4(%ebp),%ebx
113c96: c9 leave
113c97: c3 ret
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
113c98: 83 ec 08 sub $0x8,%esp
113c9b: 8d 45 f8 lea -0x8(%ebp),%eax
113c9e: 50 push %eax
113c9f: ff 75 08 pushl 0x8(%ebp)
113ca2: e8 a1 37 00 00 call 117448 <_Thread_Get>
113ca7: 89 c1 mov %eax,%ecx
switch ( location ) {
113ca9: 83 c4 10 add $0x10,%esp
113cac: 8b 55 f8 mov -0x8(%ebp),%edx
113caf: 85 d2 test %edx,%edx
113cb1: 74 0d je 113cc0 <rtems_signal_send+0x40>
113cb3: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
113cb8: 8b 5d fc mov -0x4(%ebp),%ebx
113cbb: c9 leave
113cbc: c3 ret
113cbd: 8d 76 00 lea 0x0(%esi),%esi
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
113cc0: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
113cc6: 8b 42 0c mov 0xc(%edx),%eax
113cc9: 85 c0 test %eax,%eax
113ccb: 74 43 je 113d10 <rtems_signal_send+0x90>
if ( asr->is_enabled ) {
113ccd: 80 7a 08 00 cmpb $0x0,0x8(%edx)
113cd1: 74 29 je 113cfc <rtems_signal_send+0x7c><== 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
113cd3: 9c pushf
113cd4: fa cli
113cd5: 58 pop %eax
);
113cd6: 09 5a 14 or %ebx,0x14(%edx)
113cd9: 50 push %eax
113cda: 9d popf
_ASR_Post_signals( signal_set, &asr->signals_posted );
the_thread->do_post_task_switch_extension = true;
113cdb: c6 41 75 01 movb $0x1,0x75(%ecx)
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
113cdf: a1 d8 5a 13 00 mov 0x135ad8,%eax
113ce4: 85 c0 test %eax,%eax
113ce6: 74 1c je 113d04 <rtems_signal_send+0x84>
113ce8: 3b 0d fc 5a 13 00 cmp 0x135afc,%ecx
113cee: 75 14 jne 113d04 <rtems_signal_send+0x84><== NEVER TAKEN
_ISR_Signals_to_thread_executing = TRUE;
113cf0: c6 05 a8 5b 13 00 01 movb $0x1,0x135ba8
113cf7: eb 0b jmp 113d04 <rtems_signal_send+0x84>
113cf9: 8d 76 00 lea 0x0(%esi),%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
113cfc: 9c pushf <== NOT EXECUTED
113cfd: fa cli <== NOT EXECUTED
113cfe: 58 pop %eax <== NOT EXECUTED
);
113cff: 09 5a 18 or %ebx,0x18(%edx) <== NOT EXECUTED
113d02: 50 push %eax <== NOT EXECUTED
113d03: 9d popf <== NOT EXECUTED
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
113d04: e8 1b 37 00 00 call 117424 <_Thread_Enable_dispatch>
113d09: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
113d0b: 8b 5d fc mov -0x4(%ebp),%ebx
113d0e: c9 leave
113d0f: c3 ret
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
113d10: e8 0f 37 00 00 call 117424 <_Thread_Enable_dispatch>
113d15: b8 0b 00 00 00 mov $0xb,%eax
113d1a: e9 74 ff ff ff jmp 113c93 <rtems_signal_send+0x13>
00107318 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
107318: 55 push %ebp
107319: 89 e5 mov %esp,%ebp
10731b: 57 push %edi
10731c: 56 push %esi
10731d: 8b 45 08 mov 0x8(%ebp),%eax
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
107320: 8b 50 08 mov 0x8(%eax),%edx
107323: 85 d2 test %edx,%edx
107325: 74 15 je 10733c <rtems_stack_checker_begin_extension+0x24><== NEVER TAKEN
return;
the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
*the_pattern = Stack_check_Pattern;
107327: 8b 80 c8 00 00 00 mov 0xc8(%eax),%eax
10732d: 8d 78 08 lea 0x8(%eax),%edi
107330: be 50 15 12 00 mov $0x121550,%esi
107335: b9 04 00 00 00 mov $0x4,%ecx
10733a: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
10733c: 5e pop %esi
10733d: 5f pop %edi
10733e: c9 leave
10733f: c3 ret
00107700 <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running,
Thread_Control *the_thread
)
{
107700: 55 push %ebp
107701: 89 e5 mov %esp,%ebp
107703: 57 push %edi
107704: 83 ec 04 sub $0x4,%esp
107707: 8b 7d 0c mov 0xc(%ebp),%edi
Stack_check_Initialize();
10770a: e8 81 ff ff ff call 107690 <Stack_check_Initialize>
if (the_thread)
10770f: 85 ff test %edi,%edi
107711: 74 10 je 107723 <rtems_stack_checker_create_extension+0x23><== NEVER TAKEN
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
107713: 8b 8f c4 00 00 00 mov 0xc4(%edi),%ecx
107719: 8b bf c8 00 00 00 mov 0xc8(%edi),%edi
10771f: b0 a5 mov $0xa5,%al
107721: f3 aa rep stos %al,%es:(%edi)
return true;
}
107723: b0 01 mov $0x1,%al
107725: 5a pop %edx
107726: 5f pop %edi
107727: c9 leave
107728: c3 ret
001075a4 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
1075a4: 55 push %ebp <== NOT EXECUTED
1075a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1075a7: 57 push %edi <== NOT EXECUTED
1075a8: 56 push %esi <== NOT EXECUTED
1075a9: 53 push %ebx <== NOT EXECUTED
1075aa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
1075ad: a1 bc 17 12 00 mov 0x1217bc,%eax <== NOT EXECUTED
)
{
void *sp = __builtin_frame_address(0);
#if defined(__GNUC__)
if ( sp < the_stack->area ) {
1075b2: 8b 90 c8 00 00 00 mov 0xc8(%eax),%edx <== NOT EXECUTED
1075b8: 39 d5 cmp %edx,%ebp <== NOT EXECUTED
1075ba: 73 38 jae 1075f4 <rtems_stack_checker_is_blown+0x50><== NOT EXECUTED
1075bc: 31 db xor %ebx,%ebx <== NOT EXECUTED
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
1075be: 8b 35 10 13 12 00 mov 0x121310,%esi <== NOT EXECUTED
1075c4: 85 f6 test %esi,%esi <== NOT EXECUTED
1075c6: 75 44 jne 10760c <rtems_stack_checker_is_blown+0x68><== NOT EXECUTED
1075c8: b0 01 mov $0x1,%al <== NOT EXECUTED
}
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
if ( sp_ok && pattern_ok )
1075ca: 84 db test %bl,%bl <== NOT EXECUTED
1075cc: 74 04 je 1075d2 <rtems_stack_checker_is_blown+0x2e><== NOT EXECUTED
1075ce: 84 c0 test %al,%al <== NOT EXECUTED
1075d0: 75 4e jne 107620 <rtems_stack_checker_is_blown+0x7c><== NOT EXECUTED
return false;
/*
* Let's report as much as we can.
*/
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
1075d2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
1075d5: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
1075d8: 50 push %eax <== NOT EXECUTED
1075d9: ff 35 bc 17 12 00 pushl 0x1217bc <== NOT EXECUTED
1075df: e8 54 ff ff ff call 107538 <Stack_check_report_blown_task><== NOT EXECUTED
1075e4: b0 01 mov $0x1,%al <== NOT EXECUTED
1075e6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return true;
}
1075e9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1075ec: 5b pop %ebx <== NOT EXECUTED
1075ed: 5e pop %esi <== NOT EXECUTED
1075ee: 5f pop %edi <== NOT EXECUTED
1075ef: c9 leave <== NOT EXECUTED
1075f0: c3 ret <== NOT EXECUTED
1075f1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
)
{
void *sp = __builtin_frame_address(0);
#if defined(__GNUC__)
if ( sp < the_stack->area ) {
1075f4: 8b 88 c4 00 00 00 mov 0xc4(%eax),%ecx <== NOT EXECUTED
1075fa: 8d 04 0a lea (%edx,%ecx,1),%eax <== NOT EXECUTED
1075fd: 39 c5 cmp %eax,%ebp <== NOT EXECUTED
1075ff: 0f 96 c3 setbe %bl <== NOT EXECUTED
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
107602: 8b 35 10 13 12 00 mov 0x121310,%esi <== NOT EXECUTED
107608: 85 f6 test %esi,%esi <== NOT EXECUTED
10760a: 74 bc je 1075c8 <rtems_stack_checker_is_blown+0x24><== NOT EXECUTED
pattern_ok = (!memcmp(
10760c: 8d 72 08 lea 0x8(%edx),%esi <== NOT EXECUTED
10760f: bf 50 15 12 00 mov $0x121550,%edi <== NOT EXECUTED
107614: b9 10 00 00 00 mov $0x10,%ecx <== NOT EXECUTED
107619: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED
10761b: 0f 94 c0 sete %al <== NOT EXECUTED
10761e: eb aa jmp 1075ca <rtems_stack_checker_is_blown+0x26><== NOT EXECUTED
}
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
if ( sp_ok && pattern_ok )
107620: 31 c0 xor %eax,%eax <== NOT EXECUTED
/*
* Let's report as much as we can.
*/
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
return true;
}
107622: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
107625: 5b pop %ebx <== NOT EXECUTED
107626: 5e pop %esi <== NOT EXECUTED
107627: 5f pop %edi <== NOT EXECUTED
107628: c9 leave <== NOT EXECUTED
107629: c3 ret <== NOT EXECUTED
00107520 <rtems_stack_checker_report_usage>:
void rtems_stack_checker_report_usage( void )
{
107520: 55 push %ebp <== NOT EXECUTED
107521: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107523: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
107526: 68 90 8a 10 00 push $0x108a90 <== NOT EXECUTED
10752b: 6a 00 push $0x0 <== NOT EXECUTED
10752d: e8 8a ff ff ff call 1074bc <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
107532: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
107535: c9 leave <== NOT EXECUTED
107536: c3 ret <== NOT EXECUTED
001074bc <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
1074bc: 55 push %ebp <== NOT EXECUTED
1074bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1074bf: 56 push %esi <== NOT EXECUTED
1074c0: 53 push %ebx <== NOT EXECUTED
1074c1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
1074c4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED
print_context = context;
1074c7: 89 1d 14 13 12 00 mov %ebx,0x121314 <== NOT EXECUTED
print_handler = print;
1074cd: 89 35 18 13 12 00 mov %esi,0x121318 <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
1074d3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
1074d6: 68 23 aa 11 00 push $0x11aa23 <== NOT EXECUTED
1074db: 53 push %ebx <== NOT EXECUTED
1074dc: ff d6 call *%esi <== NOT EXECUTED
(*print)( context,
1074de: 58 pop %eax <== NOT EXECUTED
1074df: 5a pop %edx <== NOT EXECUTED
1074e0: 68 3c aa 11 00 push $0x11aa3c <== NOT EXECUTED
1074e5: 53 push %ebx <== NOT EXECUTED
1074e6: 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 );
1074e8: c7 04 24 7c 73 10 00 movl $0x10737c,(%esp) <== NOT EXECUTED
1074ef: e8 44 4f 00 00 call 10c438 <rtems_iterate_over_all_threads><== NOT EXECUTED
/* dump interrupt stack info if any */
Stack_check_Dump_threads_usage((Thread_Control *) -1);
1074f4: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED
1074fb: e8 7c fe ff ff call 10737c <Stack_check_Dump_threads_usage><== NOT EXECUTED
print_context = NULL;
107500: c7 05 14 13 12 00 00 movl $0x0,0x121314 <== NOT EXECUTED
107507: 00 00 00
print_handler = NULL;
10750a: c7 05 18 13 12 00 00 movl $0x0,0x121318 <== NOT EXECUTED
107511: 00 00 00
107514: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
107517: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10751a: 5b pop %ebx <== NOT EXECUTED
10751b: 5e pop %esi <== NOT EXECUTED
10751c: c9 leave <== NOT EXECUTED
10751d: c3 ret <== NOT EXECUTED
0010762c <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running,
Thread_Control *heir
)
{
10762c: 55 push %ebp
10762d: 89 e5 mov %esp,%ebp
10762f: 57 push %edi
107630: 56 push %esi
107631: 53 push %ebx
107632: 83 ec 08 sub $0x8,%esp
107635: 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;
107638: 8b 83 c8 00 00 00 mov 0xc8(%ebx),%eax
10763e: 8d 70 08 lea 0x8(%eax),%esi
)
{
void *sp = __builtin_frame_address(0);
#if defined(__GNUC__)
if ( sp < the_stack->area ) {
107641: 39 c5 cmp %eax,%ebp
107643: 72 0a jb 10764f <rtems_stack_checker_switch_extension+0x23><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
107645: 03 83 c4 00 00 00 add 0xc4(%ebx),%eax
10764b: 39 c5 cmp %eax,%ebp
10764d: 76 25 jbe 107674 <rtems_stack_checker_switch_extension+0x48><== ALWAYS TAKEN
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
10764f: bf 50 15 12 00 mov $0x121550,%edi <== NOT EXECUTED
107654: b9 10 00 00 00 mov $0x10,%ecx <== NOT EXECUTED
107659: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED
10765b: 0f 94 c0 sete %al <== NOT EXECUTED
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( running, pattern_ok );
10765e: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
107661: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED
107664: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED
}
}
107667: 83 c4 08 add $0x8,%esp <== NOT EXECUTED
10766a: 5b pop %ebx <== NOT EXECUTED
10766b: 5e pop %esi <== NOT EXECUTED
10766c: 5f pop %edi <== NOT EXECUTED
10766d: c9 leave <== NOT EXECUTED
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 );
10766e: e9 c5 fe ff ff jmp 107538 <Stack_check_report_blown_task><== NOT EXECUTED
107673: 90 nop <== NOT EXECUTED
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
107674: bf 50 15 12 00 mov $0x121550,%edi
107679: b9 10 00 00 00 mov $0x10,%ecx
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
10767e: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi)
107680: 74 06 je 107688 <rtems_stack_checker_switch_extension+0x5c><== ALWAYS TAKEN
107682: 31 c0 xor %eax,%eax
107684: eb d8 jmp 10765e <rtems_stack_checker_switch_extension+0x32><== NOT EXECUTED
107686: 66 90 xchg %ax,%ax <== NOT EXECUTED
Stack_check_report_blown_task( running, pattern_ok );
}
}
107688: 83 c4 08 add $0x8,%esp
10768b: 5b pop %ebx
10768c: 5e pop %esi
10768d: 5f pop %edi
10768e: c9 leave
10768f: c3 ret
00107afc <rtems_status_text>:
const char *
rtems_status_text(
rtems_status_code status
)
{
107afc: 55 push %ebp <== NOT EXECUTED
107afd: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107aff: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
return rtems_assoc_name_by_local(rtems_status_assoc, status);
107b02: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
107b05: 68 40 b5 11 00 push $0x11b540 <== NOT EXECUTED
107b0a: e8 e9 80 00 00 call 10fbf8 <rtems_assoc_name_by_local><== NOT EXECUTED
}
107b0f: c9 leave <== NOT EXECUTED
107b10: c3 ret <== NOT EXECUTED
0010a588 <rtems_task_create>:
size_t stack_size,
rtems_mode initial_modes,
rtems_attribute attribute_set,
Objects_Id *id
)
{
10a588: 55 push %ebp
10a589: 89 e5 mov %esp,%ebp
10a58b: 57 push %edi
10a58c: 56 push %esi
10a58d: 53 push %ebx
10a58e: 83 ec 0c sub $0xc,%esp
10a591: 8b 7d 08 mov 0x8(%ebp),%edi
10a594: 8b 5d 18 mov 0x18(%ebp),%ebx
Priority_Control core_priority;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
10a597: 8b 45 1c mov 0x1c(%ebp),%eax
10a59a: 85 c0 test %eax,%eax
10a59c: 0f 84 32 01 00 00 je 10a6d4 <rtems_task_create+0x14c><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
10a5a2: 85 ff test %edi,%edi
10a5a4: 0f 84 c2 00 00 00 je 10a66c <rtems_task_create+0xe4>
/*
* Validate the RTEMS API priority and convert it to the core priority range.
*/
if ( !_Attributes_Is_system_task( the_attribute_set ) ) {
10a5aa: 66 85 db test %bx,%bx
10a5ad: 78 1b js 10a5ca <rtems_task_create+0x42>
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
size_t size
);
10a5af: 8b 45 0c mov 0xc(%ebp),%eax
10a5b2: 85 c0 test %eax,%eax
10a5b4: 0f 84 f2 00 00 00 je 10a6ac <rtems_task_create+0x124>
10a5ba: 0f b6 05 14 a1 11 00 movzbl 0x11a114,%eax
10a5c1: 39 45 0c cmp %eax,0xc(%ebp)
10a5c4: 0f 87 e2 00 00 00 ja 10a6ac <rtems_task_create+0x124><== NEVER TAKEN
*/
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
10a5ca: 83 ec 0c sub $0xc,%esp
10a5cd: ff 35 14 e7 11 00 pushl 0x11e714
10a5d3: e8 30 07 00 00 call 10ad08 <_API_Mutex_Lock>
#ifdef __cplusplus
extern "C" {
#endif
/**
10a5d8: c7 04 24 e0 e5 11 00 movl $0x11e5e0,(%esp)
10a5df: e8 d0 0f 00 00 call 10b5b4 <_Objects_Allocate>
10a5e4: 89 c6 mov %eax,%esi
* the event of an error.
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
10a5e6: 83 c4 10 add $0x10,%esp
10a5e9: 85 c0 test %eax,%eax
10a5eb: 0f 84 cb 00 00 00 je 10a6bc <rtems_task_create+0x134>
/*
* Initialize the core thread for this task.
*/
status = _Thread_Initialize(
10a5f1: 50 push %eax
10a5f2: 57 push %edi
10a5f3: 8b 45 14 mov 0x14(%ebp),%eax
10a5f6: 83 e0 01 and $0x1,%eax
10a5f9: 50 push %eax
10a5fa: 6a 00 push $0x0
10a5fc: 8b 45 14 mov 0x14(%ebp),%eax
10a5ff: c1 e8 09 shr $0x9,%eax
10a602: 83 e0 01 and $0x1,%eax
10a605: 50 push %eax
10a606: 8b 45 14 mov 0x14(%ebp),%eax
10a609: c1 e8 08 shr $0x8,%eax
10a60c: 83 f0 01 xor $0x1,%eax
10a60f: 83 e0 01 and $0x1,%eax
10a612: 50 push %eax
10a613: ff 75 0c pushl 0xc(%ebp)
10a616: 83 e3 01 and $0x1,%ebx
10a619: 53 push %ebx
10a61a: ff 75 10 pushl 0x10(%ebp)
10a61d: 6a 00 push $0x0
10a61f: 56 push %esi
10a620: 68 e0 e5 11 00 push $0x11e5e0
10a625: e8 66 1d 00 00 call 10c390 <_Thread_Initialize>
NULL, /* no budget algorithm callout */
_Modes_Get_interrupt_level(initial_modes),
(Objects_Name) name
);
if ( !status ) {
10a62a: 83 c4 30 add $0x30,%esp
10a62d: 84 c0 test %al,%al
10a62f: 74 4b je 10a67c <rtems_task_create+0xf4>
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
10a631: 8b 86 f4 00 00 00 mov 0xf4(%esi),%eax
10a637: c1 6d 14 0a shrl $0xa,0x14(%ebp)
10a63b: 83 75 14 01 xorl $0x1,0x14(%ebp)
10a63f: 8a 55 14 mov 0x14(%ebp),%dl
10a642: 83 e2 01 and $0x1,%edx
10a645: 88 50 08 mov %dl,0x8(%eax)
*id = the_thread->Object.id;
10a648: 8b 46 08 mov 0x8(%esi),%eax
10a64b: 8b 55 1c mov 0x1c(%ebp),%edx
10a64e: 89 02 mov %eax,(%edx)
);
}
#endif
_RTEMS_Unlock_allocator();
10a650: 83 ec 0c sub $0xc,%esp
10a653: ff 35 14 e7 11 00 pushl 0x11e714
10a659: e8 f2 06 00 00 call 10ad50 <_API_Mutex_Unlock>
10a65e: 31 c0 xor %eax,%eax
10a660: 83 c4 10 add $0x10,%esp
return RTEMS_SUCCESSFUL;
}
10a663: 8d 65 f4 lea -0xc(%ebp),%esp
10a666: 5b pop %ebx
10a667: 5e pop %esi
10a668: 5f pop %edi
10a669: c9 leave
10a66a: c3 ret
10a66b: 90 nop
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
10a66c: b8 03 00 00 00 mov $0x3,%eax
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10a671: 8d 65 f4 lea -0xc(%ebp),%esp
10a674: 5b pop %ebx
10a675: 5e pop %esi
10a676: 5f pop %edi
10a677: c9 leave
10a678: c3 ret
10a679: 8d 76 00 lea 0x0(%esi),%esi
* @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
10a67c: 83 ec 0c sub $0xc,%esp
10a67f: ff 76 08 pushl 0x8(%esi)
10a682: e8 61 13 00 00 call 10b9e8 <_Objects_Get_information_id>
10a687: 5a pop %edx
10a688: 59 pop %ecx
10a689: 56 push %esi
10a68a: 50 push %eax
10a68b: e8 e4 12 00 00 call 10b974 <_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();
10a690: 58 pop %eax
10a691: ff 35 14 e7 11 00 pushl 0x11e714
10a697: e8 b4 06 00 00 call 10ad50 <_API_Mutex_Unlock>
10a69c: b8 0d 00 00 00 mov $0xd,%eax
10a6a1: 83 c4 10 add $0x10,%esp
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
}
10a6a4: 8d 65 f4 lea -0xc(%ebp),%esp
10a6a7: 5b pop %ebx
10a6a8: 5e pop %esi
10a6a9: 5f pop %edi
10a6aa: c9 leave
10a6ab: c3 ret
}
#endif
_RTEMS_Unlock_allocator();
return RTEMS_SUCCESSFUL;
10a6ac: b8 13 00 00 00 mov $0x13,%eax
}
10a6b1: 8d 65 f4 lea -0xc(%ebp),%esp
10a6b4: 5b pop %ebx
10a6b5: 5e pop %esi
10a6b6: 5f pop %edi
10a6b7: c9 leave
10a6b8: c3 ret
10a6b9: 8d 76 00 lea 0x0(%esi),%esi
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
_RTEMS_Unlock_allocator();
10a6bc: 83 ec 0c sub $0xc,%esp
10a6bf: ff 35 14 e7 11 00 pushl 0x11e714
10a6c5: e8 86 06 00 00 call 10ad50 <_API_Mutex_Unlock>
10a6ca: b8 05 00 00 00 mov $0x5,%eax
10a6cf: 83 c4 10 add $0x10,%esp
10a6d2: eb 9d jmp 10a671 <rtems_task_create+0xe9>
Priority_Control core_priority;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
10a6d4: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
10a6d9: eb 96 jmp 10a671 <rtems_task_create+0xe9><== NOT EXECUTED
0010a6dc <rtems_task_delete>:
*/
rtems_status_code rtems_task_delete(
Objects_Id id
)
{
10a6dc: 55 push %ebp
10a6dd: 89 e5 mov %esp,%ebp
10a6df: 53 push %ebx
10a6e0: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
10a6e3: ff 35 14 e7 11 00 pushl 0x11e714
10a6e9: e8 1a 06 00 00 call 10ad08 <_API_Mutex_Lock>
the_thread = _Thread_Get( id, &location );
10a6ee: 58 pop %eax
10a6ef: 5a pop %edx
10a6f0: 8d 45 f8 lea -0x8(%ebp),%eax
10a6f3: 50 push %eax
10a6f4: ff 75 08 pushl 0x8(%ebp)
10a6f7: e8 14 1c 00 00 call 10c310 <_Thread_Get>
10a6fc: 89 c3 mov %eax,%ebx
switch ( location ) {
10a6fe: 83 c4 10 add $0x10,%esp
10a701: 8b 45 f8 mov -0x8(%ebp),%eax
10a704: 85 c0 test %eax,%eax
10a706: 75 44 jne 10a74c <rtems_task_delete+0x70>
case OBJECTS_LOCAL:
the_information = _Objects_Get_information_id( the_thread->Object.id );
10a708: 83 ec 0c sub $0xc,%esp
10a70b: ff 73 08 pushl 0x8(%ebx)
10a70e: e8 d5 12 00 00 call 10b9e8 <_Objects_Get_information_id>
0 /* Not used */
);
}
#endif
_Thread_Close( the_information, the_thread );
10a713: 5a pop %edx
10a714: 59 pop %ecx
10a715: 53 push %ebx
10a716: 50 push %eax
10a717: e8 b4 18 00 00 call 10bfd0 <_Thread_Close>
10a71c: 58 pop %eax
10a71d: ff 73 08 pushl 0x8(%ebx)
10a720: e8 c3 12 00 00 call 10b9e8 <_Objects_Get_information_id>
10a725: 5a pop %edx
10a726: 59 pop %ecx
10a727: 53 push %ebx
10a728: 50 push %eax
10a729: e8 46 12 00 00 call 10b974 <_Objects_Free>
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
10a72e: 58 pop %eax
10a72f: ff 35 14 e7 11 00 pushl 0x11e714
10a735: e8 16 06 00 00 call 10ad50 <_API_Mutex_Unlock>
_Thread_Enable_dispatch();
10a73a: e8 ad 1b 00 00 call 10c2ec <_Thread_Enable_dispatch>
10a73f: 31 c0 xor %eax,%eax
10a741: 83 c4 10 add $0x10,%esp
break;
}
_RTEMS_Unlock_allocator();
return RTEMS_INVALID_ID;
}
10a744: 8b 5d fc mov -0x4(%ebp),%ebx
10a747: c9 leave
10a748: c3 ret
10a749: 8d 76 00 lea 0x0(%esi),%esi
case OBJECTS_ERROR:
break;
}
_RTEMS_Unlock_allocator();
10a74c: 83 ec 0c sub $0xc,%esp
10a74f: ff 35 14 e7 11 00 pushl 0x11e714
10a755: e8 f6 05 00 00 call 10ad50 <_API_Mutex_Unlock>
10a75a: b8 04 00 00 00 mov $0x4,%eax
10a75f: 83 c4 10 add $0x10,%esp
return RTEMS_INVALID_ID;
}
10a762: 8b 5d fc mov -0x4(%ebp),%ebx
10a765: c9 leave
10a766: c3 ret
0010be34 <rtems_task_get_note>:
rtems_status_code rtems_task_get_note(
Objects_Id id,
uint32_t notepad,
uint32_t *note
)
{
10be34: 55 push %ebp
10be35: 89 e5 mov %esp,%ebp
10be37: 83 ec 18 sub $0x18,%esp
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
10be3a: a1 34 3a 12 00 mov 0x123a34,%eax
10be3f: 8b 40 40 mov 0x40(%eax),%eax
10be42: 80 78 04 00 cmpb $0x0,0x4(%eax)
10be46: 74 64 je 10beac <rtems_task_get_note+0x78><== NEVER TAKEN
return RTEMS_NOT_CONFIGURED;
if ( !note )
10be48: 8b 45 10 mov 0x10(%ebp),%eax
10be4b: 85 c0 test %eax,%eax
10be4d: 0f 84 85 00 00 00 je 10bed8 <rtems_task_get_note+0xa4><== 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 )
10be53: 83 7d 0c 0f cmpl $0xf,0xc(%ebp)
10be57: 77 4b ja 10bea4 <rtems_task_get_note+0x70>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10be59: 8b 4d 08 mov 0x8(%ebp),%ecx
10be5c: 85 c9 test %ecx,%ecx
10be5e: 74 54 je 10beb4 <rtems_task_get_note+0x80>
10be60: a1 5c 3a 12 00 mov 0x123a5c,%eax
10be65: 8b 55 08 mov 0x8(%ebp),%edx
10be68: 3b 50 08 cmp 0x8(%eax),%edx
10be6b: 74 4c je 10beb9 <rtems_task_get_note+0x85>
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
10be6d: 83 ec 08 sub $0x8,%esp
10be70: 8d 45 fc lea -0x4(%ebp),%eax
10be73: 50 push %eax
10be74: ff 75 08 pushl 0x8(%ebp)
10be77: e8 e8 1e 00 00 call 10dd64 <_Thread_Get>
switch ( location ) {
10be7c: 83 c4 10 add $0x10,%esp
10be7f: 8b 55 fc mov -0x4(%ebp),%edx
10be82: 85 d2 test %edx,%edx
10be84: 75 4a jne 10bed0 <rtems_task_get_note+0x9c><== ALWAYS TAKEN
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
10be86: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED
10be8c: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
10be8f: 8b 44 90 20 mov 0x20(%eax,%edx,4),%eax <== NOT EXECUTED
10be93: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
10be96: 89 02 mov %eax,(%edx) <== NOT EXECUTED
_Thread_Enable_dispatch();
10be98: e8 a3 1e 00 00 call 10dd40 <_Thread_Enable_dispatch><== NOT EXECUTED
10be9d: 31 c0 xor %eax,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10be9f: c9 leave <== NOT EXECUTED
10bea0: c3 ret <== NOT EXECUTED
10bea1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
/*
* 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 )
10bea4: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bea9: c9 leave
10beaa: c3 ret
10beab: 90 nop
{
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
10beac: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10beb1: c9 leave <== NOT EXECUTED
10beb2: c3 ret <== NOT EXECUTED
10beb3: 90 nop <== NOT EXECUTED
10beb4: a1 5c 3a 12 00 mov 0x123a5c,%eax
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
10beb9: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
10bebf: 8b 55 0c mov 0xc(%ebp),%edx
10bec2: 8b 44 90 20 mov 0x20(%eax,%edx,4),%eax
10bec6: 8b 55 10 mov 0x10(%ebp),%edx
10bec9: 89 02 mov %eax,(%edx)
10becb: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10becd: c9 leave
10bece: c3 ret
10becf: 90 nop
*note = api->Notepads[ notepad ];
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
10bed0: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bed5: c9 leave
10bed6: c3 ret
10bed7: 90 nop
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
if ( !note )
10bed8: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bedd: c9 leave <== NOT EXECUTED
10bede: c3 ret <== NOT EXECUTED
0010a768 <rtems_task_ident>:
rtems_status_code rtems_task_ident(
rtems_name name,
uint32_t node,
Objects_Id *id
)
{
10a768: 55 push %ebp
10a769: 89 e5 mov %esp,%ebp
10a76b: 83 ec 08 sub $0x8,%esp
10a76e: 8b 45 08 mov 0x8(%ebp),%eax
10a771: 8b 55 10 mov 0x10(%ebp),%edx
Objects_Name_or_id_lookup_errors status;
if ( !id )
10a774: 85 d2 test %edx,%edx
10a776: 74 30 je 10a7a8 <rtems_task_ident+0x40> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( name == OBJECTS_ID_OF_SELF ) {
10a778: 85 c0 test %eax,%eax
10a77a: 75 10 jne 10a78c <rtems_task_ident+0x24>
*id = _Thread_Executing->Object.id;
10a77c: a1 1c e7 11 00 mov 0x11e71c,%eax
10a781: 8b 40 08 mov 0x8(%eax),%eax
10a784: 89 02 mov %eax,(%edx)
10a786: 31 c0 xor %eax,%eax
}
status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
return _Status_Object_name_errors_to_status[ status ];
}
10a788: c9 leave
10a789: c3 ret
10a78a: 66 90 xchg %ax,%ax
if ( name == OBJECTS_ID_OF_SELF ) {
*id = _Thread_Executing->Object.id;
return RTEMS_SUCCESSFUL;
}
status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
10a78c: 52 push %edx
10a78d: ff 75 0c pushl 0xc(%ebp)
10a790: 50 push %eax
10a791: 68 e0 e5 11 00 push $0x11e5e0
10a796: e8 65 14 00 00 call 10bc00 <_Objects_Name_to_id_u32>
return _Status_Object_name_errors_to_status[ status ];
10a79b: 8b 04 85 6c 86 11 00 mov 0x11866c(,%eax,4),%eax
10a7a2: 83 c4 10 add $0x10,%esp
}
10a7a5: c9 leave
10a7a6: c3 ret
10a7a7: 90 nop
Objects_Id *id
)
{
Objects_Name_or_id_lookup_errors status;
if ( !id )
10a7a8: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
}
status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
return _Status_Object_name_errors_to_status[ status ];
}
10a7ad: c9 leave <== NOT EXECUTED
10a7ae: c3 ret <== NOT EXECUTED
0010ad1c <rtems_task_is_suspended>:
*/
rtems_status_code rtems_task_is_suspended(
Objects_Id id
)
{
10ad1c: 55 push %ebp
10ad1d: 89 e5 mov %esp,%ebp
10ad1f: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10ad22: 8d 45 fc lea -0x4(%ebp),%eax
10ad25: 50 push %eax
10ad26: ff 75 08 pushl 0x8(%ebp)
10ad29: e8 ea 1b 00 00 call 10c918 <_Thread_Get>
switch ( location ) {
10ad2e: 83 c4 10 add $0x10,%esp
10ad31: 8b 55 fc mov -0x4(%ebp),%edx
10ad34: 85 d2 test %edx,%edx
10ad36: 74 08 je 10ad40 <rtems_task_is_suspended+0x24><== ALWAYS TAKEN
10ad38: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ad3d: c9 leave <== NOT EXECUTED
10ad3e: c3 ret <== NOT EXECUTED
10ad3f: 90 nop <== NOT EXECUTED
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
10ad40: f6 40 10 02 testb $0x2,0x10(%eax)
10ad44: 74 0e je 10ad54 <rtems_task_is_suspended+0x38>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
10ad46: e8 a9 1b 00 00 call 10c8f4 <_Thread_Enable_dispatch>
10ad4b: b8 0f 00 00 00 mov $0xf,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ad50: c9 leave
10ad51: c3 ret
10ad52: 66 90 xchg %ax,%ax
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
_Thread_Enable_dispatch();
10ad54: e8 9b 1b 00 00 call 10c8f4 <_Thread_Enable_dispatch>
10ad59: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ad5b: c9 leave
10ad5c: c3 ret
0010fd50 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
10fd50: 55 push %ebp
10fd51: 89 e5 mov %esp,%ebp
10fd53: 57 push %edi
10fd54: 56 push %esi
10fd55: 53 push %ebx
10fd56: 83 ec 0c sub $0xc,%esp
10fd59: 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 )
10fd5c: 8b 4d 10 mov 0x10(%ebp),%ecx
10fd5f: 85 c9 test %ecx,%ecx
10fd61: 0f 84 31 01 00 00 je 10fe98 <rtems_task_mode+0x148> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
10fd67: a1 1c e7 11 00 mov 0x11e71c,%eax
10fd6c: 89 45 ec mov %eax,-0x14(%ebp)
api = executing->API_Extensions[ THREAD_API_RTEMS ];
10fd6f: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx
10fd75: 89 55 f0 mov %edx,-0x10(%ebp)
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
10fd78: 80 78 76 01 cmpb $0x1,0x76(%eax)
10fd7c: 19 f6 sbb %esi,%esi
10fd7e: 81 e6 00 01 00 00 and $0x100,%esi
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
10fd84: 8b 50 7c mov 0x7c(%eax),%edx
10fd87: 85 d2 test %edx,%edx
10fd89: 0f 85 bd 00 00 00 jne 10fe4c <rtems_task_mode+0xfc>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
10fd8f: 8b 5d f0 mov -0x10(%ebp),%ebx
10fd92: 80 7b 08 01 cmpb $0x1,0x8(%ebx)
10fd96: 19 db sbb %ebx,%ebx
10fd98: 81 e3 00 04 00 00 and $0x400,%ebx
old_mode |= _ISR_Get_level();
10fd9e: e8 f9 d8 ff ff call 10d69c <_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;
10fda3: 09 c3 or %eax,%ebx
old_mode |= _ISR_Get_level();
*previous_mode_set = old_mode;
10fda5: 09 f3 or %esi,%ebx
10fda7: 8b 45 10 mov 0x10(%ebp),%eax
10fdaa: 89 18 mov %ebx,(%eax)
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
10fdac: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp)
10fdb3: 74 11 je 10fdc6 <rtems_task_mode+0x76>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE;
10fdb5: 89 f8 mov %edi,%eax
10fdb7: c1 e8 08 shr $0x8,%eax
10fdba: 83 f0 01 xor $0x1,%eax
10fdbd: 83 e0 01 and $0x1,%eax
10fdc0: 8b 55 ec mov -0x14(%ebp),%edx
10fdc3: 88 42 76 mov %al,0x76(%edx)
if ( mask & RTEMS_TIMESLICE_MASK ) {
10fdc6: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
10fdcd: 74 1e je 10fded <rtems_task_mode+0x9d>
if ( _Modes_Is_timeslice(mode_set) ) {
10fdcf: f7 c7 00 02 00 00 test $0x200,%edi
10fdd5: 0f 84 81 00 00 00 je 10fe5c <rtems_task_mode+0x10c>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
10fddb: 8b 5d ec mov -0x14(%ebp),%ebx
10fdde: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
10fde5: a1 24 e6 11 00 mov 0x11e624,%eax
10fdea: 89 43 78 mov %eax,0x78(%ebx)
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
10fded: f6 45 0c 01 testb $0x1,0xc(%ebp)
10fdf1: 74 09 je 10fdfc <rtems_task_mode+0xac>
* 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
10fdf3: f7 c7 01 00 00 00 test $0x1,%edi
10fdf9: 74 5d je 10fe58 <rtems_task_mode+0x108>
10fdfb: fa cli
*/
is_asr_enabled = FALSE;
needs_asr_dispatching = FALSE;
if ( mask & RTEMS_ASR_MASK ) {
10fdfc: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
10fe03: 74 31 je 10fe36 <rtems_task_mode+0xe6>
10fe05: c1 ef 0a shr $0xa,%edi
10fe08: 83 f7 01 xor $0x1,%edi
10fe0b: 89 f8 mov %edi,%eax
10fe0d: 83 e0 01 and $0x1,%eax
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
10fe10: 8b 55 f0 mov -0x10(%ebp),%edx
10fe13: 38 42 08 cmp %al,0x8(%edx)
10fe16: 74 1e je 10fe36 <rtems_task_mode+0xe6>
asr->is_enabled = is_asr_enabled;
10fe18: 88 42 08 mov %al,0x8(%edx)
uint32_t page_size
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
10fe1b: 9c pushf
10fe1c: fa cli
10fe1d: 59 pop %ecx
/**
10fe1e: 8b 5d f0 mov -0x10(%ebp),%ebx
10fe21: 8b 53 18 mov 0x18(%ebx),%edx
* This routine grows @a the_heap memory area using the size bytes which
10fe24: 8b 43 14 mov 0x14(%ebx),%eax
10fe27: 89 43 18 mov %eax,0x18(%ebx)
* begin at @a starting_address.
10fe2a: 89 53 14 mov %edx,0x14(%ebx)
*
10fe2d: 51 push %ecx
10fe2e: 9d popf
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
10fe2f: 8b 43 14 mov 0x14(%ebx),%eax
10fe32: 85 c0 test %eax,%eax
10fe34: 75 56 jne 10fe8c <rtems_task_mode+0x13c> <== NEVER TAKEN
needs_asr_dispatching = true;
executing->do_post_task_switch_extension = true;
10fe36: 31 db xor %ebx,%ebx
}
}
}
if ( _System_state_Is_up(_System_state_Current) )
10fe38: 83 3d 24 e8 11 00 03 cmpl $0x3,0x11e824
10fe3f: 74 2f je 10fe70 <rtems_task_mode+0x120> <== ALWAYS TAKEN
if ( _Thread_Evaluate_mode() || needs_asr_dispatching )
_Thread_Dispatch();
10fe41: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
10fe43: 83 c4 0c add $0xc,%esp
10fe46: 5b pop %ebx
10fe47: 5e pop %esi
10fe48: 5f pop %edi
10fe49: c9 leave
10fe4a: c3 ret
10fe4b: 90 nop
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
10fe4c: 81 ce 00 02 00 00 or $0x200,%esi
10fe52: e9 38 ff ff ff jmp 10fd8f <rtems_task_mode+0x3f>
10fe57: 90 nop
* 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
10fe58: fb sti
10fe59: eb a1 jmp 10fdfc <rtems_task_mode+0xac>
10fe5b: 90 nop
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
10fe5c: 8b 45 ec mov -0x14(%ebp),%eax
10fe5f: c7 40 7c 00 00 00 00 movl $0x0,0x7c(%eax)
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
10fe66: f6 45 0c 01 testb $0x1,0xc(%ebp)
10fe6a: 74 90 je 10fdfc <rtems_task_mode+0xac>
10fe6c: eb 85 jmp 10fdf3 <rtems_task_mode+0xa3>
10fe6e: 66 90 xchg %ax,%ax
}
}
}
if ( _System_state_Is_up(_System_state_Current) )
if ( _Thread_Evaluate_mode() || needs_asr_dispatching )
10fe70: e8 73 01 00 00 call 10ffe8 <_Thread_Evaluate_mode>
10fe75: 84 c0 test %al,%al
10fe77: 75 04 jne 10fe7d <rtems_task_mode+0x12d>
10fe79: 84 db test %bl,%bl
10fe7b: 74 c4 je 10fe41 <rtems_task_mode+0xf1> <== ALWAYS TAKEN
_Thread_Dispatch();
10fe7d: e8 0e c3 ff ff call 10c190 <_Thread_Dispatch>
10fe82: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
10fe84: 83 c4 0c add $0xc,%esp
10fe87: 5b pop %ebx
10fe88: 5e pop %esi
10fe89: 5f pop %edi
10fe8a: c9 leave
10fe8b: c3 ret
if ( is_asr_enabled != asr->is_enabled ) {
asr->is_enabled = is_asr_enabled;
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
needs_asr_dispatching = true;
executing->do_post_task_switch_extension = true;
10fe8c: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
10fe8f: c6 40 75 01 movb $0x1,0x75(%eax) <== NOT EXECUTED
10fe93: b3 01 mov $0x1,%bl <== NOT EXECUTED
10fe95: eb a1 jmp 10fe38 <rtems_task_mode+0xe8> <== NOT EXECUTED
10fe97: 90 nop <== NOT EXECUTED
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
10fe98: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
if ( _System_state_Is_up(_System_state_Current) )
if ( _Thread_Evaluate_mode() || needs_asr_dispatching )
_Thread_Dispatch();
return RTEMS_SUCCESSFUL;
}
10fe9d: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10fea0: 5b pop %ebx <== NOT EXECUTED
10fea1: 5e pop %esi <== NOT EXECUTED
10fea2: 5f pop %edi <== NOT EXECUTED
10fea3: c9 leave <== NOT EXECUTED
10fea4: c3 ret <== NOT EXECUTED
0010b974 <rtems_task_resume>:
*/
rtems_status_code rtems_task_resume(
Objects_Id id
)
{
10b974: 55 push %ebp
10b975: 89 e5 mov %esp,%ebp
10b977: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10b97a: 8d 45 fc lea -0x4(%ebp),%eax
10b97d: 50 push %eax
10b97e: ff 75 08 pushl 0x8(%ebp)
10b981: e8 82 1e 00 00 call 10d808 <_Thread_Get>
switch ( location ) {
10b986: 83 c4 10 add $0x10,%esp
10b989: 8b 55 fc mov -0x4(%ebp),%edx
10b98c: 85 d2 test %edx,%edx
10b98e: 74 08 je 10b998 <rtems_task_resume+0x24>
10b990: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b995: c9 leave
10b996: c3 ret
10b997: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _States_Is_suspended( the_thread->current_state ) ) {
10b998: f6 40 10 02 testb $0x2,0x10(%eax)
10b99c: 75 0e jne 10b9ac <rtems_task_resume+0x38>
_Thread_Resume( the_thread, TRUE );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
10b99e: e8 15 1e 00 00 call 10d7b8 <_Thread_Enable_dispatch>
10b9a3: b8 0e 00 00 00 mov $0xe,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b9a8: c9 leave
10b9a9: c3 ret
10b9aa: 66 90 xchg %ax,%ax
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _States_Is_suspended( the_thread->current_state ) ) {
_Thread_Resume( the_thread, TRUE );
10b9ac: 83 ec 08 sub $0x8,%esp
10b9af: 6a 01 push $0x1
10b9b1: 50 push %eax
10b9b2: e8 75 26 00 00 call 10e02c <_Thread_Resume>
_Thread_Enable_dispatch();
10b9b7: e8 fc 1d 00 00 call 10d7b8 <_Thread_Enable_dispatch>
10b9bc: 31 c0 xor %eax,%eax
10b9be: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b9c1: c9 leave
10b9c2: c3 ret
0010bfb8 <rtems_task_set_note>:
rtems_status_code rtems_task_set_note(
Objects_Id id,
uint32_t notepad,
uint32_t note
)
{
10bfb8: 55 push %ebp
10bfb9: 89 e5 mov %esp,%ebp
10bfbb: 83 ec 18 sub $0x18,%esp
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
10bfbe: a1 34 3a 12 00 mov 0x123a34,%eax
10bfc3: 8b 40 40 mov 0x40(%eax),%eax
10bfc6: 80 78 04 00 cmpb $0x0,0x4(%eax)
10bfca: 74 54 je 10c020 <rtems_task_set_note+0x68><== 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 )
10bfcc: 83 7d 0c 0f cmpl $0xf,0xc(%ebp)
10bfd0: 77 46 ja 10c018 <rtems_task_set_note+0x60>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10bfd2: 8b 4d 08 mov 0x8(%ebp),%ecx
10bfd5: 85 c9 test %ecx,%ecx
10bfd7: 74 4f je 10c028 <rtems_task_set_note+0x70><== NEVER TAKEN
10bfd9: a1 5c 3a 12 00 mov 0x123a5c,%eax
10bfde: 8b 55 08 mov 0x8(%ebp),%edx
10bfe1: 3b 50 08 cmp 0x8(%eax),%edx
10bfe4: 74 47 je 10c02d <rtems_task_set_note+0x75><== NEVER TAKEN
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
10bfe6: 83 ec 08 sub $0x8,%esp
10bfe9: 8d 45 fc lea -0x4(%ebp),%eax
10bfec: 50 push %eax
10bfed: ff 75 08 pushl 0x8(%ebp)
10bff0: e8 6f 1d 00 00 call 10dd64 <_Thread_Get>
switch ( location ) {
10bff5: 83 c4 10 add $0x10,%esp
10bff8: 8b 55 fc mov -0x4(%ebp),%edx
10bffb: 85 d2 test %edx,%edx
10bffd: 75 45 jne 10c044 <rtems_task_set_note+0x8c>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
10bfff: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
10c005: 8b 55 10 mov 0x10(%ebp),%edx
10c008: 8b 4d 0c mov 0xc(%ebp),%ecx
10c00b: 89 54 88 20 mov %edx,0x20(%eax,%ecx,4)
_Thread_Enable_dispatch();
10c00f: e8 2c 1d 00 00 call 10dd40 <_Thread_Enable_dispatch>
10c014: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c016: c9 leave
10c017: c3 ret
/*
* 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 )
10c018: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c01d: c9 leave
10c01e: c3 ret
10c01f: 90 nop
{
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
10c020: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c025: c9 leave <== NOT EXECUTED
10c026: c3 ret <== NOT EXECUTED
10c027: 90 nop <== NOT EXECUTED
10c028: a1 5c 3a 12 00 mov 0x123a5c,%eax
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
10c02d: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
10c033: 8b 55 10 mov 0x10(%ebp),%edx
10c036: 8b 4d 0c mov 0xc(%ebp),%ecx
10c039: 89 54 88 20 mov %edx,0x20(%eax,%ecx,4)
10c03d: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c03f: c9 leave
10c040: c3 ret
10c041: 8d 76 00 lea 0x0(%esi),%esi
api->Notepads[ notepad ] = note;
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
10c044: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10c049: c9 leave
10c04a: c3 ret
0010b744 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
Objects_Id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
10b744: 55 push %ebp
10b745: 89 e5 mov %esp,%ebp
10b747: 56 push %esi
10b748: 53 push %ebx
10b749: 83 ec 10 sub $0x10,%esp
10b74c: 8b 5d 0c mov 0xc(%ebp),%ebx
10b74f: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10b752: 85 db test %ebx,%ebx
10b754: 74 0b je 10b761 <rtems_task_set_priority+0x1d>
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
size_t size
);
10b756: 0f b6 05 14 d1 11 00 movzbl 0x11d114,%eax
10b75d: 39 c3 cmp %eax,%ebx
10b75f: 77 5f ja 10b7c0 <rtems_task_set_priority+0x7c>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
10b761: 85 f6 test %esi,%esi
10b763: 74 67 je 10b7cc <rtems_task_set_priority+0x88><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10b765: 83 ec 08 sub $0x8,%esp
10b768: 8d 45 f4 lea -0xc(%ebp),%eax
10b76b: 50 push %eax
10b76c: ff 75 08 pushl 0x8(%ebp)
10b76f: e8 60 1c 00 00 call 10d3d4 <_Thread_Get>
10b774: 89 c2 mov %eax,%edx
switch ( location ) {
10b776: 83 c4 10 add $0x10,%esp
10b779: 8b 45 f4 mov -0xc(%ebp),%eax
10b77c: 85 c0 test %eax,%eax
10b77e: 74 0c je 10b78c <rtems_task_set_priority+0x48>
10b780: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b785: 8d 65 f8 lea -0x8(%ebp),%esp
10b788: 5b pop %ebx
10b789: 5e pop %esi
10b78a: c9 leave
10b78b: c3 ret
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
10b78c: 8b 42 14 mov 0x14(%edx),%eax
10b78f: 89 06 mov %eax,(%esi)
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
10b791: 85 db test %ebx,%ebx
10b793: 74 1c je 10b7b1 <rtems_task_set_priority+0x6d>
the_thread->real_priority = new_priority;
10b795: 89 5a 18 mov %ebx,0x18(%edx)
if ( the_thread->resource_count == 0 ||
10b798: 8b 4a 1c mov 0x1c(%edx),%ecx
10b79b: 85 c9 test %ecx,%ecx
10b79d: 74 05 je 10b7a4 <rtems_task_set_priority+0x60>
10b79f: 3b 5a 14 cmp 0x14(%edx),%ebx
10b7a2: 73 0d jae 10b7b1 <rtems_task_set_priority+0x6d><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, FALSE );
10b7a4: 50 push %eax
10b7a5: 6a 00 push $0x0
10b7a7: 53 push %ebx
10b7a8: 52 push %edx
10b7a9: e8 26 17 00 00 call 10ced4 <_Thread_Change_priority>
10b7ae: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10b7b1: e8 fa 1b 00 00 call 10d3b0 <_Thread_Enable_dispatch>
10b7b6: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b7b8: 8d 65 f8 lea -0x8(%ebp),%esp
10b7bb: 5b pop %ebx
10b7bc: 5e pop %esi
10b7bd: c9 leave
10b7be: c3 ret
10b7bf: 90 nop
10b7c0: b8 13 00 00 00 mov $0x13,%eax
10b7c5: 8d 65 f8 lea -0x8(%ebp),%esp
10b7c8: 5b pop %ebx
10b7c9: 5e pop %esi
10b7ca: c9 leave
10b7cb: c3 ret
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
10b7cc: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b7d1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10b7d4: 5b pop %ebx <== NOT EXECUTED
10b7d5: 5e pop %esi <== NOT EXECUTED
10b7d6: c9 leave <== NOT EXECUTED
10b7d7: c3 ret <== NOT EXECUTED
0010a828 <rtems_task_start>:
rtems_status_code rtems_task_start(
rtems_id id,
rtems_task_entry entry_point,
rtems_task_argument argument
)
{
10a828: 55 push %ebp
10a829: 89 e5 mov %esp,%ebp
10a82b: 53 push %ebx
10a82c: 83 ec 14 sub $0x14,%esp
10a82f: 8b 5d 0c mov 0xc(%ebp),%ebx
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
10a832: 85 db test %ebx,%ebx
10a834: 74 5a je 10a890 <rtems_task_start+0x68>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10a836: 83 ec 08 sub $0x8,%esp
10a839: 8d 45 f8 lea -0x8(%ebp),%eax
10a83c: 50 push %eax
10a83d: ff 75 08 pushl 0x8(%ebp)
10a840: e8 cb 1a 00 00 call 10c310 <_Thread_Get>
switch ( location ) {
10a845: 83 c4 10 add $0x10,%esp
10a848: 8b 55 f8 mov -0x8(%ebp),%edx
10a84b: 85 d2 test %edx,%edx
10a84d: 74 0d je 10a85c <rtems_task_start+0x34>
10a84f: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a854: 8b 5d fc mov -0x4(%ebp),%ebx
10a857: c9 leave
10a858: c3 ret
10a859: 8d 76 00 lea 0x0(%esi),%esi
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Thread_Start(
10a85c: 83 ec 0c sub $0xc,%esp
10a85f: ff 75 10 pushl 0x10(%ebp)
10a862: 6a 00 push $0x0
10a864: 53 push %ebx
10a865: 6a 00 push $0x0
10a867: 50 push %eax
10a868: e8 7b 25 00 00 call 10cde8 <_Thread_Start>
10a86d: 83 c4 20 add $0x20,%esp
10a870: 84 c0 test %al,%al
10a872: 75 10 jne 10a884 <rtems_task_start+0x5c>
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
10a874: e8 73 1a 00 00 call 10c2ec <_Thread_Enable_dispatch>
10a879: b8 0e 00 00 00 mov $0xe,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a87e: 8b 5d fc mov -0x4(%ebp),%ebx
10a881: c9 leave
10a882: c3 ret
10a883: 90 nop
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Thread_Start(
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
10a884: e8 63 1a 00 00 call 10c2ec <_Thread_Enable_dispatch>
10a889: 31 c0 xor %eax,%eax
10a88b: eb c7 jmp 10a854 <rtems_task_start+0x2c>
10a88d: 8d 76 00 lea 0x0(%esi),%esi
)
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
10a890: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a895: 8b 5d fc mov -0x4(%ebp),%ebx
10a898: c9 leave
10a899: c3 ret
0010ba38 <rtems_task_suspend>:
*/
rtems_status_code rtems_task_suspend(
Objects_Id id
)
{
10ba38: 55 push %ebp
10ba39: 89 e5 mov %esp,%ebp
10ba3b: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10ba3e: 8d 45 fc lea -0x4(%ebp),%eax
10ba41: 50 push %eax
10ba42: ff 75 08 pushl 0x8(%ebp)
10ba45: e8 be 1d 00 00 call 10d808 <_Thread_Get>
switch ( location ) {
10ba4a: 83 c4 10 add $0x10,%esp
10ba4d: 8b 55 fc mov -0x4(%ebp),%edx
10ba50: 85 d2 test %edx,%edx
10ba52: 74 08 je 10ba5c <rtems_task_suspend+0x24>
10ba54: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ba59: c9 leave
10ba5a: c3 ret
10ba5b: 90 nop
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
10ba5c: f6 40 10 02 testb $0x2,0x10(%eax)
10ba60: 74 0e je 10ba70 <rtems_task_suspend+0x38>
_Thread_Suspend( the_thread );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
10ba62: e8 51 1d 00 00 call 10d7b8 <_Thread_Enable_dispatch>
10ba67: b8 0f 00 00 00 mov $0xf,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ba6c: c9 leave
10ba6d: c3 ret
10ba6e: 66 90 xchg %ax,%ax
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
_Thread_Suspend( the_thread );
10ba70: 83 ec 0c sub $0xc,%esp
10ba73: 50 push %eax
10ba74: e8 77 29 00 00 call 10e3f0 <_Thread_Suspend>
_Thread_Enable_dispatch();
10ba79: e8 3a 1d 00 00 call 10d7b8 <_Thread_Enable_dispatch>
10ba7e: 31 c0 xor %eax,%eax
10ba80: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ba83: c9 leave
10ba84: c3 ret
0010bce8 <rtems_task_variable_add>:
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
10bce8: 55 push %ebp
10bce9: 89 e5 mov %esp,%ebp
10bceb: 56 push %esi
10bcec: 53 push %ebx
10bced: 83 ec 10 sub $0x10,%esp
10bcf0: 8b 5d 0c mov 0xc(%ebp),%ebx
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
10bcf3: 85 db test %ebx,%ebx
10bcf5: 0f 84 a1 00 00 00 je 10bd9c <rtems_task_variable_add+0xb4><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
10bcfb: 83 ec 08 sub $0x8,%esp
10bcfe: 8d 45 f4 lea -0xc(%ebp),%eax
10bd01: 50 push %eax
10bd02: ff 75 08 pushl 0x8(%ebp)
10bd05: e8 9e 1c 00 00 call 10d9a8 <_Thread_Get>
10bd0a: 89 c6 mov %eax,%esi
switch (location) {
10bd0c: 83 c4 10 add $0x10,%esp
10bd0f: 8b 45 f4 mov -0xc(%ebp),%eax
10bd12: 85 c0 test %eax,%eax
10bd14: 75 2e jne 10bd44 <rtems_task_variable_add+0x5c><== NEVER TAKEN
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
10bd16: 8b 86 04 01 00 00 mov 0x104(%esi),%eax
while (tvp) {
10bd1c: 85 c0 test %eax,%eax
10bd1e: 75 0a jne 10bd2a <rtems_task_variable_add+0x42>
10bd20: eb 2e jmp 10bd50 <rtems_task_variable_add+0x68>
10bd22: 66 90 xchg %ax,%ax
if (tvp->ptr == ptr) {
tvp->dtor = dtor;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
10bd24: 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) {
10bd26: 85 c0 test %eax,%eax
10bd28: 74 26 je 10bd50 <rtems_task_variable_add+0x68>
if (tvp->ptr == ptr) {
10bd2a: 39 58 04 cmp %ebx,0x4(%eax)
10bd2d: 75 f5 jne 10bd24 <rtems_task_variable_add+0x3c>
tvp->dtor = dtor;
10bd2f: 8b 55 10 mov 0x10(%ebp),%edx
10bd32: 89 50 10 mov %edx,0x10(%eax)
_Thread_Enable_dispatch();
10bd35: e8 4a 1c 00 00 call 10d984 <_Thread_Enable_dispatch>
10bd3a: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bd3c: 8d 65 f8 lea -0x8(%ebp),%esp
10bd3f: 5b pop %ebx
10bd40: 5e pop %esi
10bd41: c9 leave
10bd42: c3 ret
10bd43: 90 nop
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
switch (location) {
10bd44: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bd49: 8d 65 f8 lea -0x8(%ebp),%esp
10bd4c: 5b pop %ebx
10bd4d: 5e pop %esi
10bd4e: c9 leave
10bd4f: c3 ret
}
/*
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
10bd50: 83 ec 0c sub $0xc,%esp
10bd53: 6a 14 push $0x14
10bd55: e8 3a 2e 00 00 call 10eb94 <_Workspace_Allocate>
10bd5a: 89 c2 mov %eax,%edx
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
10bd5c: 83 c4 10 add $0x10,%esp
10bd5f: 85 c0 test %eax,%eax
10bd61: 74 2d je 10bd90 <rtems_task_variable_add+0xa8>
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
10bd63: 8b 03 mov (%ebx),%eax
10bd65: 89 42 08 mov %eax,0x8(%edx)
new->ptr = ptr;
10bd68: 89 5a 04 mov %ebx,0x4(%edx)
new->dtor = dtor;
10bd6b: 8b 45 10 mov 0x10(%ebp),%eax
10bd6e: 89 42 10 mov %eax,0x10(%edx)
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
10bd71: 8b 86 04 01 00 00 mov 0x104(%esi),%eax
10bd77: 89 02 mov %eax,(%edx)
the_thread->task_variables = new;
10bd79: 89 96 04 01 00 00 mov %edx,0x104(%esi)
_Thread_Enable_dispatch();
10bd7f: e8 00 1c 00 00 call 10d984 <_Thread_Enable_dispatch>
10bd84: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bd86: 8d 65 f8 lea -0x8(%ebp),%esp
10bd89: 5b pop %ebx
10bd8a: 5e pop %esi
10bd8b: c9 leave
10bd8c: c3 ret
10bd8d: 8d 76 00 lea 0x0(%esi),%esi
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
10bd90: e8 ef 1b 00 00 call 10d984 <_Thread_Enable_dispatch>
10bd95: b8 1a 00 00 00 mov $0x1a,%eax
10bd9a: eb ad jmp 10bd49 <rtems_task_variable_add+0x61>
{
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
10bd9c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bda1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10bda4: 5b pop %ebx <== NOT EXECUTED
10bda5: 5e pop %esi <== NOT EXECUTED
10bda6: c9 leave <== NOT EXECUTED
10bda7: c3 ret <== NOT EXECUTED
0010bda8 <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
10bda8: 55 push %ebp
10bda9: 89 e5 mov %esp,%ebp
10bdab: 56 push %esi
10bdac: 53 push %ebx
10bdad: 83 ec 10 sub $0x10,%esp
10bdb0: 8b 5d 0c mov 0xc(%ebp),%ebx
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
10bdb3: 85 db test %ebx,%ebx
10bdb5: 74 3f je 10bdf6 <rtems_task_variable_delete+0x4e>
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
10bdb7: 83 ec 08 sub $0x8,%esp
10bdba: 8d 45 f4 lea -0xc(%ebp),%eax
10bdbd: 50 push %eax
10bdbe: ff 75 08 pushl 0x8(%ebp)
10bdc1: e8 e2 1b 00 00 call 10d9a8 <_Thread_Get>
10bdc6: 89 c6 mov %eax,%esi
switch (location) {
10bdc8: 83 c4 10 add $0x10,%esp
10bdcb: 8b 45 f4 mov -0xc(%ebp),%eax
10bdce: 85 c0 test %eax,%eax
10bdd0: 75 32 jne 10be04 <rtems_task_variable_delete+0x5c><== NEVER TAKEN
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
10bdd2: 8b 96 04 01 00 00 mov 0x104(%esi),%edx
while (tvp) {
10bdd8: 85 d2 test %edx,%edx
10bdda: 74 15 je 10bdf1 <rtems_task_variable_delete+0x49>
if (tvp->ptr == ptr) {
10bddc: 39 5a 04 cmp %ebx,0x4(%edx)
10bddf: 75 08 jne 10bde9 <rtems_task_variable_delete+0x41>
10bde1: eb 4c jmp 10be2f <rtems_task_variable_delete+0x87>
10bde3: 90 nop
10bde4: 39 5a 04 cmp %ebx,0x4(%edx)
10bde7: 74 27 je 10be10 <rtems_task_variable_delete+0x68>
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
10bde9: 89 d1 mov %edx,%ecx
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
10bdeb: 8b 12 mov (%edx),%edx
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
10bded: 85 d2 test %edx,%edx
10bdef: 75 f3 jne 10bde4 <rtems_task_variable_delete+0x3c><== ALWAYS TAKEN
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
10bdf1: e8 8e 1b 00 00 call 10d984 <_Thread_Enable_dispatch>
10bdf6: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bdfb: 8d 65 f8 lea -0x8(%ebp),%esp
10bdfe: 5b pop %ebx
10bdff: 5e pop %esi
10be00: c9 leave
10be01: c3 ret
10be02: 66 90 xchg %ax,%ax
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
switch (location) {
10be04: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10be09: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10be0c: 5b pop %ebx <== NOT EXECUTED
10be0d: 5e pop %esi <== NOT EXECUTED
10be0e: c9 leave <== NOT EXECUTED
10be0f: c3 ret <== NOT EXECUTED
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
10be10: 8b 02 mov (%edx),%eax
10be12: 89 01 mov %eax,(%ecx)
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
10be14: 83 ec 08 sub $0x8,%esp
10be17: 52 push %edx
10be18: 56 push %esi
10be19: e8 a6 00 00 00 call 10bec4 <_RTEMS_Tasks_Invoke_task_variable_dtor>
_Thread_Enable_dispatch();
10be1e: e8 61 1b 00 00 call 10d984 <_Thread_Enable_dispatch>
10be23: 31 c0 xor %eax,%eax
10be25: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10be28: 8d 65 f8 lea -0x8(%ebp),%esp
10be2b: 5b pop %ebx
10be2c: 5e pop %esi
10be2d: c9 leave
10be2e: c3 ret
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
10be2f: 8b 02 mov (%edx),%eax
10be31: 89 86 04 01 00 00 mov %eax,0x104(%esi)
10be37: eb db jmp 10be14 <rtems_task_variable_delete+0x6c>
0010be3c <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
10be3c: 55 push %ebp
10be3d: 89 e5 mov %esp,%ebp
10be3f: 56 push %esi
10be40: 53 push %ebx
10be41: 83 ec 10 sub $0x10,%esp
10be44: 8b 5d 0c mov 0xc(%ebp),%ebx
10be47: 8b 75 10 mov 0x10(%ebp),%esi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
10be4a: 85 db test %ebx,%ebx
10be4c: 74 56 je 10bea4 <rtems_task_variable_get+0x68>
return RTEMS_INVALID_ADDRESS;
if ( !result )
10be4e: 85 f6 test %esi,%esi
10be50: 74 52 je 10bea4 <rtems_task_variable_get+0x68>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
10be52: 83 ec 08 sub $0x8,%esp
10be55: 8d 45 f4 lea -0xc(%ebp),%eax
10be58: 50 push %eax
10be59: ff 75 08 pushl 0x8(%ebp)
10be5c: e8 47 1b 00 00 call 10d9a8 <_Thread_Get>
switch (location) {
10be61: 83 c4 10 add $0x10,%esp
10be64: 8b 55 f4 mov -0xc(%ebp),%edx
10be67: 85 d2 test %edx,%edx
10be69: 75 2d jne 10be98 <rtems_task_variable_get+0x5c><== NEVER TAKEN
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
10be6b: 8b 80 04 01 00 00 mov 0x104(%eax),%eax
while (tvp) {
10be71: 85 c0 test %eax,%eax
10be73: 75 09 jne 10be7e <rtems_task_variable_get+0x42>
10be75: eb 39 jmp 10beb0 <rtems_task_variable_get+0x74>
10be77: 90 nop
*/
*result = tvp->tval;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
10be78: 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) {
10be7a: 85 c0 test %eax,%eax
10be7c: 74 32 je 10beb0 <rtems_task_variable_get+0x74><== NEVER TAKEN
if (tvp->ptr == ptr) {
10be7e: 39 58 04 cmp %ebx,0x4(%eax)
10be81: 75 f5 jne 10be78 <rtems_task_variable_get+0x3c>
/*
* Should this return the current (i.e not the
* saved) value if `tid' is the current task?
*/
*result = tvp->tval;
10be83: 8b 40 0c mov 0xc(%eax),%eax
10be86: 89 06 mov %eax,(%esi)
_Thread_Enable_dispatch();
10be88: e8 f7 1a 00 00 call 10d984 <_Thread_Enable_dispatch>
10be8d: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10be8f: 8d 65 f8 lea -0x8(%ebp),%esp
10be92: 5b pop %ebx
10be93: 5e pop %esi
10be94: c9 leave
10be95: c3 ret
10be96: 66 90 xchg %ax,%ax
if ( !result )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
switch (location) {
10be98: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10be9d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10bea0: 5b pop %ebx <== NOT EXECUTED
10bea1: 5e pop %esi <== NOT EXECUTED
10bea2: c9 leave <== NOT EXECUTED
10bea3: c3 ret <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
return RTEMS_INVALID_ADDRESS;
10bea4: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10bea9: 8d 65 f8 lea -0x8(%ebp),%esp
10beac: 5b pop %ebx
10bead: 5e pop %esi
10beae: c9 leave
10beaf: c3 ret
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
10beb0: e8 cf 1a 00 00 call 10d984 <_Thread_Enable_dispatch>
10beb5: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10beba: 8d 65 f8 lea -0x8(%ebp),%esp
10bebd: 5b pop %ebx
10bebe: 5e pop %esi
10bebf: c9 leave
10bec0: c3 ret
0010b524 <rtems_task_wake_when>:
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
10b524: 55 push %ebp
10b525: 89 e5 mov %esp,%ebp
10b527: 53 push %ebx
10b528: 83 ec 04 sub $0x4,%esp
10b52b: 8b 5d 08 mov 0x8(%ebp),%ebx
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
10b52e: 80 3d cc 16 12 00 00 cmpb $0x0,0x1216cc
10b535: 0f 84 a1 00 00 00 je 10b5dc <rtems_task_wake_when+0xb8>
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
10b53b: 85 db test %ebx,%ebx
10b53d: 0f 84 a5 00 00 00 je 10b5e8 <rtems_task_wake_when+0xc4><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
10b543: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
if ( !_TOD_Validate( time_buffer ) )
10b54a: 83 ec 0c sub $0xc,%esp
10b54d: 53 push %ebx
10b54e: e8 c1 f3 ff ff call 10a914 <_TOD_Validate>
10b553: 83 c4 10 add $0x10,%esp
10b556: 84 c0 test %al,%al
10b558: 75 0a jne 10b564 <rtems_task_wake_when+0x40>
_Watchdog_Insert_seconds(
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
10b55a: b8 14 00 00 00 mov $0x14,%eax
}
10b55f: 8b 5d fc mov -0x4(%ebp),%ebx
10b562: c9 leave
10b563: c3 ret
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
10b564: 83 ec 0c sub $0xc,%esp
10b567: 53 push %ebx
10b568: e8 17 f3 ff ff call 10a884 <_TOD_To_seconds>
10b56d: 89 c3 mov %eax,%ebx
if ( seconds <= _TOD_Seconds_since_epoch )
10b56f: 83 c4 10 add $0x10,%esp
10b572: 3b 05 4c 17 12 00 cmp 0x12174c,%eax
10b578: 76 e0 jbe 10b55a <rtems_task_wake_when+0x36>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10b57a: a1 b8 16 12 00 mov 0x1216b8,%eax
10b57f: 40 inc %eax
10b580: a3 b8 16 12 00 mov %eax,0x1216b8
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
10b585: 83 ec 08 sub $0x8,%esp
10b588: 6a 10 push $0x10
10b58a: ff 35 7c 17 12 00 pushl 0x12177c
10b590: e8 7f 23 00 00 call 10d914 <_Thread_Set_state>
_Watchdog_Initialize(
10b595: a1 7c 17 12 00 mov 0x12177c,%eax
10b59a: 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.
*
10b59d: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
* @param[in] the_heap is the heap to operate upon
10b5a4: c7 40 64 c8 ce 10 00 movl $0x10cec8,0x64(%eax)
* @param[in] starting_address is the starting address of the memory for
10b5ab: 89 50 68 mov %edx,0x68(%eax)
* the heap
10b5ae: 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,
10b5b5: 2b 1d 4c 17 12 00 sub 0x12174c,%ebx
10b5bb: 89 58 54 mov %ebx,0x54(%eax)
size_t size
);
10b5be: 5a pop %edx
10b5bf: 59 pop %ecx
10b5c0: 83 c0 48 add $0x48,%eax
10b5c3: 50 push %eax
10b5c4: 68 90 17 12 00 push $0x121790
10b5c9: e8 1e 2a 00 00 call 10dfec <_Watchdog_Insert>
);
_Watchdog_Insert_seconds(
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch
);
_Thread_Enable_dispatch();
10b5ce: e8 8d 1a 00 00 call 10d060 <_Thread_Enable_dispatch>
10b5d3: 31 c0 xor %eax,%eax
10b5d5: 83 c4 10 add $0x10,%esp
10b5d8: eb 85 jmp 10b55f <rtems_task_wake_when+0x3b>
10b5da: 66 90 xchg %ax,%ax
rtems_time_of_day *time_buffer
)
{
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
10b5dc: b8 0b 00 00 00 mov $0xb,%eax
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b5e1: 8b 5d fc mov -0x4(%ebp),%ebx
10b5e4: c9 leave
10b5e5: c3 ret
10b5e6: 66 90 xchg %ax,%ax
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
10b5e8: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
10b5ed: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10b5f0: c9 leave <== NOT EXECUTED
10b5f1: c3 ret <== NOT EXECUTED
00107fd8 <rtems_termios_bufsize>:
rtems_status_code rtems_termios_bufsize (
int cbufsize,
int raw_input,
int raw_output
)
{
107fd8: 55 push %ebp <== NOT EXECUTED
107fd9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
rtems_termios_cbufsize = cbufsize;
107fdb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
107fde: a3 84 c4 11 00 mov %eax,0x11c484 <== NOT EXECUTED
rtems_termios_raw_input_size = raw_input;
107fe3: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
107fe6: a3 88 c4 11 00 mov %eax,0x11c488 <== NOT EXECUTED
rtems_termios_raw_output_size = raw_output;
107feb: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
107fee: a3 8c c4 11 00 mov %eax,0x11c48c <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
107ff3: 31 c0 xor %eax,%eax <== NOT EXECUTED
107ff5: c9 leave <== NOT EXECUTED
107ff6: c3 ret <== NOT EXECUTED
00109418 <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
109418: 55 push %ebp
109419: 89 e5 mov %esp,%ebp
10941b: 56 push %esi
10941c: 53 push %ebx
10941d: 8b 75 08 mov 0x8(%ebp),%esi
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
109420: 8b 06 mov (%esi),%eax
109422: 8b 58 28 mov 0x28(%eax),%ebx
rtems_status_code sc;
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
109425: 51 push %ecx
109426: 6a 00 push $0x0
109428: 6a 00 push $0x0
10942a: ff 35 8c e5 11 00 pushl 0x11e58c
109430: e8 bb 0f 00 00 call 10a3f0 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
109435: 83 c4 10 add $0x10,%esp
109438: 85 c0 test %eax,%eax
10943a: 0f 85 2c 01 00 00 jne 10956c <rtems_termios_close+0x154><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
109440: 8b 43 08 mov 0x8(%ebx),%eax
109443: 48 dec %eax
109444: 89 43 08 mov %eax,0x8(%ebx)
109447: 85 c0 test %eax,%eax
109449: 0f 85 bf 00 00 00 jne 10950e <rtems_termios_close+0xf6>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
10944f: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
109455: c1 e0 05 shl $0x5,%eax
109458: 8b 80 c4 e2 11 00 mov 0x11e2c4(%eax),%eax
10945e: 85 c0 test %eax,%eax
109460: 0f 84 12 01 00 00 je 109578 <rtems_termios_close+0x160><== ALWAYS TAKEN
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
109466: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109469: 53 push %ebx <== NOT EXECUTED
10946a: ff d0 call *%eax <== NOT EXECUTED
10946c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
* default: just flush output buffer
*/
drainOutput (tty);
}
if (tty->device.outputUsesInterrupts
10946f: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
109476: 0f 84 bc 00 00 00 je 109538 <rtems_termios_close+0x120><== NEVER TAKEN
tty->txTaskId,
TERMIOS_TX_TERMINATE_EVENT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
10947c: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax
109482: 85 c0 test %eax,%eax
109484: 74 0d je 109493 <rtems_termios_close+0x7b><== NEVER TAKEN
(*tty->device.lastClose)(tty->major, tty->minor, arg);
109486: 52 push %edx
109487: 56 push %esi
109488: ff 73 10 pushl 0x10(%ebx)
10948b: ff 73 0c pushl 0xc(%ebx)
10948e: ff d0 call *%eax
109490: 83 c4 10 add $0x10,%esp
if (tty->forw == NULL) {
109493: 8b 13 mov (%ebx),%edx
109495: 85 d2 test %edx,%edx
109497: 0f 84 e7 00 00 00 je 109584 <rtems_termios_close+0x16c><== ALWAYS TAKEN
if ( rtems_termios_ttyTail != NULL ) {
rtems_termios_ttyTail->forw = NULL;
}
}
else {
tty->forw->back = tty->back;
10949d: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED
1094a0: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED
}
if (tty->back == NULL) {
1094a3: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED
1094a6: 85 c0 test %eax,%eax <== NOT EXECUTED
1094a8: 0f 84 f2 00 00 00 je 1095a0 <rtems_termios_close+0x188><== NOT EXECUTED
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
}
}
else {
tty->back->forw = tty->forw;
1094ae: 89 10 mov %edx,(%eax) <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
1094b0: 83 ec 0c sub $0xc,%esp
1094b3: ff 73 14 pushl 0x14(%ebx)
1094b6: e8 91 0e 00 00 call 10a34c <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
1094bb: 58 pop %eax
1094bc: ff 73 18 pushl 0x18(%ebx)
1094bf: e8 88 0e 00 00 call 10a34c <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
1094c4: 58 pop %eax
1094c5: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
1094cb: e8 7c 0e 00 00 call 10a34c <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
1094d0: 83 c4 10 add $0x10,%esp
1094d3: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax
1094d9: 85 c0 test %eax,%eax
1094db: 74 4b je 109528 <rtems_termios_close+0x110><== ALWAYS TAKEN
1094dd: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) <== NOT EXECUTED
1094e4: 74 42 je 109528 <rtems_termios_close+0x110><== NOT EXECUTED
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
free (tty->rawInBuf.theBuf);
1094e6: 83 ec 0c sub $0xc,%esp
1094e9: ff 73 58 pushl 0x58(%ebx)
1094ec: e8 cf db ff ff call 1070c0 <free>
free (tty->rawOutBuf.theBuf);
1094f1: 58 pop %eax
1094f2: ff 73 7c pushl 0x7c(%ebx)
1094f5: e8 c6 db ff ff call 1070c0 <free>
free (tty->cbuf);
1094fa: 5e pop %esi
1094fb: ff 73 1c pushl 0x1c(%ebx)
1094fe: e8 bd db ff ff call 1070c0 <free>
free (tty);
109503: 89 1c 24 mov %ebx,(%esp)
109506: e8 b5 db ff ff call 1070c0 <free>
10950b: 83 c4 10 add $0x10,%esp
}
rtems_semaphore_release (rtems_termios_ttyMutex);
10950e: 83 ec 0c sub $0xc,%esp
109511: ff 35 8c e5 11 00 pushl 0x11e58c
109517: e8 cc 0f 00 00 call 10a4e8 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
10951c: 31 c0 xor %eax,%eax
10951e: 8d 65 f8 lea -0x8(%ebp),%esp
109521: 5b pop %ebx
109522: 5e pop %esi
109523: c9 leave
109524: c3 ret
109525: 8d 76 00 lea 0x0(%esi),%esi
rtems_semaphore_delete (tty->isem);
rtems_semaphore_delete (tty->osem);
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
109528: 83 ec 0c sub $0xc,%esp
10952b: ff 73 68 pushl 0x68(%ebx)
10952e: e8 19 0e 00 00 call 10a34c <rtems_semaphore_delete>
109533: 83 c4 10 add $0x10,%esp
109536: eb ae jmp 1094e6 <rtems_termios_close+0xce>
if (tty->device.outputUsesInterrupts
== TERMIOS_TASK_DRIVEN) {
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send(
109538: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10953b: 6a 01 push $0x1 <== NOT EXECUTED
10953d: ff b3 c4 00 00 00 pushl 0xc4(%ebx) <== NOT EXECUTED
109543: e8 84 09 00 00 call 109ecc <rtems_event_send> <== NOT EXECUTED
tty->rxTaskId,
TERMIOS_RX_TERMINATE_EVENT);
if (sc != RTEMS_SUCCESSFUL)
109548: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10954b: 85 c0 test %eax,%eax <== NOT EXECUTED
10954d: 75 1d jne 10956c <rtems_termios_close+0x154><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_event_send(
10954f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
109552: 6a 01 push $0x1 <== NOT EXECUTED
109554: ff b3 c8 00 00 00 pushl 0xc8(%ebx) <== NOT EXECUTED
10955a: e8 6d 09 00 00 call 109ecc <rtems_event_send> <== NOT EXECUTED
tty->txTaskId,
TERMIOS_TX_TERMINATE_EVENT);
if (sc != RTEMS_SUCCESSFUL)
10955f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109562: 85 c0 test %eax,%eax <== NOT EXECUTED
109564: 0f 84 12 ff ff ff je 10947c <rtems_termios_close+0x64><== NOT EXECUTED
10956a: 66 90 xchg %ax,%ax <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
10956c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10956f: 50 push %eax <== NOT EXECUTED
109570: e8 0f 15 00 00 call 10aa84 <rtems_fatal_error_occurred><== NOT EXECUTED
109575: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
}
else {
/*
* default: just flush output buffer
*/
drainOutput (tty);
109578: 89 d8 mov %ebx,%eax
10957a: e8 d5 f6 ff ff call 108c54 <drainOutput>
10957f: e9 eb fe ff ff jmp 10946f <rtems_termios_close+0x57>
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
rtems_termios_ttyTail = tty->back;
109584: 8b 43 04 mov 0x4(%ebx),%eax
109587: a3 90 e5 11 00 mov %eax,0x11e590
if ( rtems_termios_ttyTail != NULL ) {
10958c: 85 c0 test %eax,%eax
10958e: 74 2c je 1095bc <rtems_termios_close+0x1a4><== ALWAYS TAKEN
rtems_termios_ttyTail->forw = NULL;
109590: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
109596: 8b 13 mov (%ebx),%edx <== NOT EXECUTED
109598: e9 06 ff ff ff jmp 1094a3 <rtems_termios_close+0x8b><== NOT EXECUTED
10959d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
}
else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
1095a0: 89 15 94 e5 11 00 mov %edx,0x11e594 <== NOT EXECUTED
if ( rtems_termios_ttyHead != NULL ) {
1095a6: 85 d2 test %edx,%edx <== NOT EXECUTED
1095a8: 0f 84 02 ff ff ff je 1094b0 <rtems_termios_close+0x98><== NOT EXECUTED
rtems_termios_ttyHead->back = NULL;
1095ae: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED
1095b5: e9 f6 fe ff ff jmp 1094b0 <rtems_termios_close+0x98><== NOT EXECUTED
1095ba: 66 90 xchg %ax,%ax <== NOT EXECUTED
}
else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
1095bc: c7 05 94 e5 11 00 00 movl $0x0,0x11e594
1095c3: 00 00 00
1095c6: e9 e5 fe ff ff jmp 1094b0 <rtems_termios_close+0x98>
00108238 <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)
{
108238: 55 push %ebp
108239: 89 e5 mov %esp,%ebp
10823b: 83 ec 08 sub $0x8,%esp
10823e: 8b 55 08 mov 0x8(%ebp),%edx
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
108241: 8b 45 0c mov 0xc(%ebp),%eax
108244: 01 82 90 00 00 00 add %eax,0x90(%edx)
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
10824a: 83 ba b4 00 00 00 02 cmpl $0x2,0xb4(%edx)
108251: 74 2d je 108280 <rtems_termios_dequeue_characters+0x48><== NEVER TAKEN
TERMIOS_TX_START_EVENT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
}
else if (tty->t_line == PPPDISC ) {
108253: 83 ba cc 00 00 00 05 cmpl $0x5,0xcc(%edx)
10825a: 75 18 jne 108274 <rtems_termios_dequeue_characters+0x3c><== ALWAYS TAKEN
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
10825c: a1 74 e3 11 00 mov 0x11e374,%eax <== NOT EXECUTED
108261: 85 c0 test %eax,%eax <== NOT EXECUTED
108263: 74 09 je 10826e <rtems_termios_dequeue_characters+0x36><== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
108265: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108268: 52 push %edx <== NOT EXECUTED
108269: ff d0 call *%eax <== NOT EXECUTED
10826b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
else {
return rtems_termios_refill_transmitter(tty);
}
}
10826e: 31 c0 xor %eax,%eax <== NOT EXECUTED
108270: c9 leave <== NOT EXECUTED
108271: c3 ret <== NOT EXECUTED
108272: 66 90 xchg %ax,%ax <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
else {
return rtems_termios_refill_transmitter(tty);
108274: 89 55 08 mov %edx,0x8(%ebp)
}
}
108277: 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);
108278: e9 97 fd ff ff jmp 108014 <rtems_termios_refill_transmitter>
10827d: 8d 76 00 lea 0x0(%esi),%esi
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId,
108280: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
108283: 6a 02 push $0x2 <== NOT EXECUTED
108285: ff b2 c8 00 00 00 pushl 0xc8(%edx) <== NOT EXECUTED
10828b: e8 3c 1c 00 00 call 109ecc <rtems_event_send> <== NOT EXECUTED
TERMIOS_TX_START_EVENT);
if (sc != RTEMS_SUCCESSFUL)
108290: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108293: 85 c0 test %eax,%eax <== NOT EXECUTED
108295: 74 d7 je 10826e <rtems_termios_dequeue_characters+0x36><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
108297: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10829a: 50 push %eax <== NOT EXECUTED
10829b: e8 e4 27 00 00 call 10aa84 <rtems_fatal_error_occurred><== NOT EXECUTED
001082a0 <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)
{
1082a0: 55 push %ebp <== NOT EXECUTED
1082a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1082a3: 57 push %edi <== NOT EXECUTED
1082a4: 56 push %esi <== NOT EXECUTED
1082a5: 53 push %ebx <== NOT EXECUTED
1082a6: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED
1082a9: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
1082ac: 8b 7d 10 mov 0x10(%ebp),%edi <== 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) {
1082af: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED
1082b5: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
1082b8: 8b 90 d0 e2 11 00 mov 0x11e2d0(%eax),%edx <== NOT EXECUTED
1082be: 85 d2 test %edx,%edx <== NOT EXECUTED
1082c0: 0f 84 86 00 00 00 je 10834c <rtems_termios_enqueue_raw_characters+0xac><== NOT EXECUTED
while (len--) {
1082c6: 85 ff test %edi,%edi <== NOT EXECUTED
1082c8: 74 2b je 1082f5 <rtems_termios_enqueue_raw_characters+0x55><== NOT EXECUTED
1082ca: 31 db xor %ebx,%ebx <== NOT EXECUTED
1082cc: eb 11 jmp 1082df <rtems_termios_enqueue_raw_characters+0x3f><== NOT EXECUTED
1082ce: 66 90 xchg %ax,%ax <== NOT EXECUTED
1082d0: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED
1082d6: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
1082d9: 8b 90 d0 e2 11 00 mov 0x11e2d0(%eax),%edx <== NOT EXECUTED
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
1082df: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
1082e2: 56 push %esi <== NOT EXECUTED
1082e3: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
1082e6: 0f be 04 19 movsbl (%ecx,%ebx,1),%eax <== NOT EXECUTED
1082ea: 50 push %eax <== NOT EXECUTED
1082eb: ff d2 call *%edx <== NOT EXECUTED
1082ed: 43 inc %ebx <== 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--) {
1082ee: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1082f1: 39 fb cmp %edi,%ebx <== NOT EXECUTED
1082f3: 75 db jne 1082d0 <rtems_termios_enqueue_raw_characters+0x30><== NOT EXECUTED
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
1082f5: 8b 9e e4 00 00 00 mov 0xe4(%esi),%ebx <== NOT EXECUTED
1082fb: 85 db test %ebx,%ebx <== NOT EXECUTED
1082fd: 75 39 jne 108338 <rtems_termios_enqueue_raw_characters+0x98><== NOT EXECUTED
1082ff: 8b 96 dc 00 00 00 mov 0xdc(%esi),%edx <== NOT EXECUTED
108305: 85 d2 test %edx,%edx <== NOT EXECUTED
108307: 74 2f je 108338 <rtems_termios_enqueue_raw_characters+0x98><== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
108309: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10830c: ff b6 e0 00 00 00 pushl 0xe0(%esi) <== NOT EXECUTED
108312: 8d 46 30 lea 0x30(%esi),%eax <== NOT EXECUTED
108315: 50 push %eax <== NOT EXECUTED
108316: ff d2 call *%edx <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
108318: c7 86 e4 00 00 00 01 movl $0x1,0xe4(%esi) <== NOT EXECUTED
10831f: 00 00 00
108322: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) <== NOT EXECUTED
108329: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
tty->rawInBufDropped += dropped;
rtems_semaphore_release (tty->rawInBuf.Semaphore);
return dropped;
}
10832c: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
10832f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
108332: 5b pop %ebx <== NOT EXECUTED
108333: 5e pop %esi <== NOT EXECUTED
108334: 5f pop %edi <== NOT EXECUTED
108335: c9 leave <== NOT EXECUTED
108336: c3 ret <== NOT EXECUTED
108337: 90 nop <== NOT EXECUTED
}
}
}
tty->rawInBufDropped += dropped;
rtems_semaphore_release (tty->rawInBuf.Semaphore);
return dropped;
108338: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) <== NOT EXECUTED
}
10833f: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
108342: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
108345: 5b pop %ebx <== NOT EXECUTED
108346: 5e pop %esi <== NOT EXECUTED
108347: 5f pop %edi <== NOT EXECUTED
108348: c9 leave <== NOT EXECUTED
108349: c3 ret <== NOT EXECUTED
10834a: 66 90 xchg %ax,%ax <== 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,
10834c: 8d 46 4a lea 0x4a(%esi),%eax <== NOT EXECUTED
10834f: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
108352: 8d 56 30 lea 0x30(%esi),%edx <== NOT EXECUTED
108355: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED
108358: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) <== NOT EXECUTED
10835f: c6 45 ea 00 movb $0x0,-0x16(%ebp) <== NOT EXECUTED
108363: e9 c3 00 00 00 jmp 10842b <rtems_termios_enqueue_raw_characters+0x18b><== NOT EXECUTED
/* reenable interrupts */
rtems_interrupt_enable(level);
}
}
else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
108368: 8b 46 60 mov 0x60(%esi),%eax <== NOT EXECUTED
10836b: 8b 4e 64 mov 0x64(%esi),%ecx <== NOT EXECUTED
10836e: 40 inc %eax <== NOT EXECUTED
10836f: 31 d2 xor %edx,%edx <== NOT EXECUTED
108371: f7 f1 div %ecx <== NOT EXECUTED
108373: 89 d3 mov %edx,%ebx <== NOT EXECUTED
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
108375: 9c pushf <== NOT EXECUTED
108376: fa cli <== NOT EXECUTED
108377: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
10837a: 8b 4e 5c mov 0x5c(%esi),%ecx <== NOT EXECUTED
10837d: 8b 46 64 mov 0x64(%esi),%eax <== NOT EXECUTED
108380: 8b 56 64 mov 0x64(%esi),%edx <== NOT EXECUTED
108383: 29 c8 sub %ecx,%eax <== NOT EXECUTED
108385: 01 d8 add %ebx,%eax <== NOT EXECUTED
108387: 89 d1 mov %edx,%ecx <== NOT EXECUTED
108389: 31 d2 xor %edx,%edx <== NOT EXECUTED
10838b: f7 f1 div %ecx <== NOT EXECUTED
10838d: 3b 96 c0 00 00 00 cmp 0xc0(%esi),%edx <== NOT EXECUTED
108393: 76 47 jbe 1083dc <rtems_termios_enqueue_raw_characters+0x13c><== NOT EXECUTED
108395: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
10839b: a8 01 test $0x1,%al <== NOT EXECUTED
10839d: 75 3d jne 1083dc <rtems_termios_enqueue_raw_characters+0x13c><== NOT EXECUTED
% tty->rawInBuf.Size)
> tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
10839f: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
1083a5: 83 c8 01 or $0x1,%eax <== NOT EXECUTED
1083a8: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
1083ae: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
1083b4: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED
1083b9: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED
1083be: 0f 84 5e 01 00 00 je 108522 <rtems_termios_enqueue_raw_characters+0x282><== NOT EXECUTED
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]),
1);
}
}
else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF))
1083c4: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
1083ca: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED
1083cf: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED
1083d4: 0f 84 86 01 00 00 je 108560 <rtems_termios_enqueue_raw_characters+0x2c0><== NOT EXECUTED
1083da: 66 90 xchg %ax,%ax <== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
1083dc: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED
1083df: 9d popf <== NOT EXECUTED
if (newTail == tty->rawInBuf.Head) {
1083e0: 8b 46 5c mov 0x5c(%esi),%eax <== NOT EXECUTED
1083e3: 39 d8 cmp %ebx,%eax <== NOT EXECUTED
1083e5: 0f 84 91 00 00 00 je 10847c <rtems_termios_enqueue_raw_characters+0x1dc><== NOT EXECUTED
dropped++;
}
else {
tty->rawInBuf.theBuf[newTail] = c;
1083eb: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED
1083ee: 8a 55 eb mov -0x15(%ebp),%dl <== NOT EXECUTED
1083f1: 88 14 18 mov %dl,(%eax,%ebx,1) <== NOT EXECUTED
tty->rawInBuf.Tail = newTail;
1083f4: 89 5e 60 mov %ebx,0x60(%esi) <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
1083f7: 8b 9e e4 00 00 00 mov 0xe4(%esi),%ebx <== NOT EXECUTED
1083fd: 85 db test %ebx,%ebx <== NOT EXECUTED
1083ff: 75 27 jne 108428 <rtems_termios_enqueue_raw_characters+0x188><== NOT EXECUTED
108401: 8b 86 dc 00 00 00 mov 0xdc(%esi),%eax <== NOT EXECUTED
108407: 85 c0 test %eax,%eax <== NOT EXECUTED
108409: 74 1d je 108428 <rtems_termios_enqueue_raw_characters+0x188><== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
10840b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10840e: ff b6 e0 00 00 00 pushl 0xe0(%esi) <== NOT EXECUTED
108414: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED
108417: ff d0 call *%eax <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
108419: c7 86 e4 00 00 00 01 movl $0x1,0xe4(%esi) <== NOT EXECUTED
108420: 00 00 00
108423: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108426: 66 90 xchg %ax,%ax <== NOT EXECUTED
}
return 0;
}
while (len--) {
c = *buf++;
108428: ff 45 0c incl 0xc(%ebp) <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
10842b: 4f dec %edi <== NOT EXECUTED
10842c: 83 ff ff cmp $0xffffffff,%edi <== NOT EXECUTED
10842f: 0f 84 9f 00 00 00 je 1084d4 <rtems_termios_enqueue_raw_characters+0x234><== NOT EXECUTED
c = *buf++;
108435: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
108438: 8a 00 mov (%eax),%al <== NOT EXECUTED
10843a: 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) {
10843d: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
108443: f6 c4 02 test $0x2,%ah <== NOT EXECUTED
108446: 74 14 je 10845c <rtems_termios_enqueue_raw_characters+0x1bc><== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
108448: 0f be 55 eb movsbl -0x15(%ebp),%edx <== NOT EXECUTED
10844c: 0f b6 46 4a movzbl 0x4a(%esi),%eax <== NOT EXECUTED
108450: 39 c2 cmp %eax,%edx <== NOT EXECUTED
108452: 74 50 je 1084a4 <rtems_termios_enqueue_raw_characters+0x204><== NOT EXECUTED
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
108454: 0f b6 46 49 movzbl 0x49(%esi),%eax <== NOT EXECUTED
108458: 39 c2 cmp %eax,%edx <== NOT EXECUTED
10845a: 74 64 je 1084c0 <rtems_termios_enqueue_raw_characters+0x220><== NOT EXECUTED
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
flow_rcv = true;
}
}
if (flow_rcv) {
10845c: 80 7d ea 00 cmpb $0x0,-0x16(%ebp) <== NOT EXECUTED
108460: 0f 84 02 ff ff ff je 108368 <rtems_termios_enqueue_raw_characters+0xc8><== NOT EXECUTED
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
108466: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
10846c: 83 e0 30 and $0x30,%eax <== NOT EXECUTED
10846f: 83 f8 20 cmp $0x20,%eax <== NOT EXECUTED
108472: 74 10 je 108484 <rtems_termios_enqueue_raw_characters+0x1e4><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
108474: c6 45 ea 01 movb $0x1,-0x16(%ebp) <== NOT EXECUTED
108478: eb ae jmp 108428 <rtems_termios_enqueue_raw_characters+0x188><== NOT EXECUTED
10847a: 66 90 xchg %ax,%ax <== NOT EXECUTED
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
dropped++;
10847c: ff 45 e4 incl -0x1c(%ebp) <== NOT EXECUTED
10847f: eb a7 jmp 108428 <rtems_termios_enqueue_raw_characters+0x188><== NOT EXECUTED
108481: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
}
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
108484: 9c pushf <== NOT EXECUTED
108485: fa cli <== NOT EXECUTED
108486: 5b pop %ebx <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
108487: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
10848d: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
108490: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
108496: 8b 8e 94 00 00 00 mov 0x94(%esi),%ecx <== NOT EXECUTED
10849c: 85 c9 test %ecx,%ecx <== NOT EXECUTED
10849e: 75 53 jne 1084f3 <rtems_termios_enqueue_raw_characters+0x253><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
1084a0: 53 push %ebx <== NOT EXECUTED
1084a1: 9d popf <== NOT EXECUTED
1084a2: eb d0 jmp 108474 <rtems_termios_enqueue_raw_characters+0x1d4><== NOT EXECUTED
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
1084a4: 0f b6 46 49 movzbl 0x49(%esi),%eax <== NOT EXECUTED
1084a8: 39 c2 cmp %eax,%edx <== NOT EXECUTED
1084aa: 74 62 je 10850e <rtems_termios_enqueue_raw_characters+0x26e><== NOT EXECUTED
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
1084ac: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
1084b2: 83 c8 10 or $0x10,%eax <== NOT EXECUTED
1084b5: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED
1084bb: eb a9 jmp 108466 <rtems_termios_enqueue_raw_characters+0x1c6><== NOT EXECUTED
1084bd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
1084c0: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
1084c6: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED
1084c9: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED
1084cf: eb 95 jmp 108466 <rtems_termios_enqueue_raw_characters+0x1c6><== NOT EXECUTED
1084d1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
}
}
}
tty->rawInBufDropped += dropped;
1084d4: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED
1084d7: 01 4e 78 add %ecx,0x78(%esi) <== NOT EXECUTED
rtems_semaphore_release (tty->rawInBuf.Semaphore);
1084da: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1084dd: ff 76 68 pushl 0x68(%esi) <== NOT EXECUTED
1084e0: e8 03 20 00 00 call 10a4e8 <rtems_semaphore_release><== NOT EXECUTED
1084e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return dropped;
}
1084e8: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
1084eb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1084ee: 5b pop %ebx <== NOT EXECUTED
1084ef: 5e pop %esi <== NOT EXECUTED
1084f0: 5f pop %edi <== NOT EXECUTED
1084f1: c9 leave <== NOT EXECUTED
1084f2: c3 ret <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
1084f3: 8b 86 84 00 00 00 mov 0x84(%esi),%eax <== NOT EXECUTED
1084f9: 52 push %edx <== NOT EXECUTED
1084fa: 6a 01 push $0x1 <== NOT EXECUTED
1084fc: 03 46 7c add 0x7c(%esi),%eax <== NOT EXECUTED
1084ff: 50 push %eax <== NOT EXECUTED
108500: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
108503: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED
108509: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10850c: eb 92 jmp 1084a0 <rtems_termios_enqueue_raw_characters+0x200><== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
10850e: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
108514: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED
108517: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED
10851d: e9 44 ff ff ff jmp 108466 <rtems_termios_enqueue_raw_characters+0x1c6><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
== (FL_MDXOF ) ){
if ((tty->flow_ctrl & FL_OSTOP) ||
108522: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
108528: a8 20 test $0x20,%al <== NOT EXECUTED
10852a: 75 0e jne 10853a <rtems_termios_enqueue_raw_characters+0x29a><== NOT EXECUTED
10852c: 8b 86 94 00 00 00 mov 0x94(%esi),%eax <== NOT EXECUTED
108532: 85 c0 test %eax,%eax <== NOT EXECUTED
108534: 0f 85 a2 fe ff ff jne 1083dc <rtems_termios_enqueue_raw_characters+0x13c><== 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;
10853a: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
108540: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
108543: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED
(*tty->device.write)(tty->minor,
108549: 50 push %eax <== NOT EXECUTED
10854a: 6a 01 push $0x1 <== NOT EXECUTED
10854c: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED
10854f: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
108552: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED
108558: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10855b: e9 7c fe ff ff jmp 1083dc <rtems_termios_enqueue_raw_characters+0x13c><== NOT EXECUTED
1);
}
}
else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF))
== (FL_MDRTS ) ) {
tty->flow_ctrl |= FL_IRTSOFF;
108560: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
108566: 83 c8 04 or $0x4,%eax <== NOT EXECUTED
108569: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
10856f: 8b 86 ac 00 00 00 mov 0xac(%esi),%eax <== NOT EXECUTED
108575: 85 c0 test %eax,%eax <== NOT EXECUTED
108577: 0f 84 5f fe ff ff je 1083dc <rtems_termios_enqueue_raw_characters+0x13c><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
10857d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108580: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
108583: ff d0 call *%eax <== NOT EXECUTED
108585: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108588: e9 4f fe ff ff jmp 1083dc <rtems_termios_enqueue_raw_characters+0x13c><== NOT EXECUTED
00107f9c <rtems_termios_initialize>:
struct rtems_termios_tty *rtems_termios_ttyTail;
rtems_id rtems_termios_ttyMutex;
void
rtems_termios_initialize (void)
{
107f9c: 55 push %ebp
107f9d: 89 e5 mov %esp,%ebp
107f9f: 83 ec 08 sub $0x8,%esp
rtems_status_code sc;
/*
* Create the mutex semaphore for the tty list
*/
if (!rtems_termios_ttyMutex) {
107fa2: a1 8c e5 11 00 mov 0x11e58c,%eax
107fa7: 85 c0 test %eax,%eax
107fa9: 74 05 je 107fb0 <rtems_termios_initialize+0x14><== ALWAYS TAKEN
RTEMS_NO_PRIORITY,
&rtems_termios_ttyMutex);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
}
107fab: c9 leave
107fac: c3 ret
107fad: 8d 76 00 lea 0x0(%esi),%esi
/*
* Create the mutex semaphore for the tty list
*/
if (!rtems_termios_ttyMutex) {
sc = rtems_semaphore_create (
107fb0: 83 ec 0c sub $0xc,%esp
107fb3: 68 8c e5 11 00 push $0x11e58c
107fb8: 6a 00 push $0x0
107fba: 6a 54 push $0x54
107fbc: 6a 01 push $0x1
107fbe: 68 69 6d 52 54 push $0x54526d69
107fc3: e8 a8 21 00 00 call 10a170 <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)
107fc8: 83 c4 20 add $0x20,%esp
107fcb: 85 c0 test %eax,%eax
107fcd: 74 dc je 107fab <rtems_termios_initialize+0xf><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
107fcf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107fd2: 50 push %eax <== NOT EXECUTED
107fd3: e8 ac 2a 00 00 call 10aa84 <rtems_fatal_error_occurred><== NOT EXECUTED
00109060 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
109060: 55 push %ebp <== NOT EXECUTED
109061: 89 e5 mov %esp,%ebp <== NOT EXECUTED
109063: 57 push %edi <== NOT EXECUTED
109064: 56 push %esi <== NOT EXECUTED
109065: 53 push %ebx <== NOT EXECUTED
109066: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
109069: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
10906c: 8b 02 mov (%edx),%eax <== NOT EXECUTED
10906e: 8b 58 28 mov 0x28(%eax),%ebx <== NOT EXECUTED
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
109071: 8b 72 08 mov 0x8(%edx),%esi <== NOT EXECUTED
rtems_status_code sc;
args->ioctl_return = 0;
109074: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
10907b: 6a 00 push $0x0 <== NOT EXECUTED
10907d: 6a 00 push $0x0 <== NOT EXECUTED
10907f: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED
109082: e8 69 13 00 00 call 10a3f0 <rtems_semaphore_obtain><== NOT EXECUTED
109087: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
10908a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10908d: 85 c0 test %eax,%eax <== NOT EXECUTED
10908f: 75 4b jne 1090dc <rtems_termios_ioctl+0x7c><== NOT EXECUTED
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
109091: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED
109094: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED
109097: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED
10909a: 0f 84 8c 00 00 00 je 10912c <rtems_termios_ioctl+0xcc><== NOT EXECUTED
1090a0: 77 4e ja 1090f0 <rtems_termios_ioctl+0x90><== NOT EXECUTED
1090a2: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED
1090a5: 0f 84 71 01 00 00 je 10921c <rtems_termios_ioctl+0x1bc><== NOT EXECUTED
1090ab: 0f 86 27 01 00 00 jbe 1091d8 <rtems_termios_ioctl+0x178><== NOT EXECUTED
if (tty->device.setAttributes)
(*tty->device.setAttributes)(tty->minor, &tty->termios);
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
1090b1: 89 d8 mov %ebx,%eax <== NOT EXECUTED
1090b3: e8 9c fb ff ff call 108c54 <drainOutput> <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
}
break;
}
rtems_semaphore_release (tty->osem);
1090b8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1090bb: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED
1090be: e8 25 14 00 00 call 10a4e8 <rtems_semaphore_release><== NOT EXECUTED
args->ioctl_return = sc;
1090c3: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED
1090c6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
1090c9: 89 50 0c mov %edx,0xc(%eax) <== NOT EXECUTED
1090cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return sc;
}
1090cf: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED
1090d2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1090d5: 5b pop %ebx <== NOT EXECUTED
1090d6: 5e pop %esi <== NOT EXECUTED
1090d7: 5f pop %edi <== NOT EXECUTED
1090d8: c9 leave <== NOT EXECUTED
1090d9: c3 ret <== NOT EXECUTED
1090da: 66 90 xchg %ax,%ax <== NOT EXECUTED
rtems_status_code sc;
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
1090dc: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
1090df: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED
break;
}
rtems_semaphore_release (tty->osem);
args->ioctl_return = sc;
return sc;
}
1090e2: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED
1090e5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1090e8: 5b pop %ebx <== NOT EXECUTED
1090e9: 5e pop %esi <== NOT EXECUTED
1090ea: 5f pop %edi <== NOT EXECUTED
1090eb: c9 leave <== NOT EXECUTED
1090ec: c3 ret <== NOT EXECUTED
1090ed: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
1090f0: 3d 7f 66 04 40 cmp $0x4004667f,%eax <== NOT EXECUTED
1090f5: 0f 84 fd 00 00 00 je 1091f8 <rtems_termios_ioctl+0x198><== NOT EXECUTED
1090fb: 77 5f ja 10915c <rtems_termios_ioctl+0xfc><== NOT EXECUTED
1090fd: 83 f8 05 cmp $0x5,%eax <== NOT EXECUTED
109100: 74 42 je 109144 <rtems_termios_ioctl+0xe4><== NOT EXECUTED
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
109102: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED
109108: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
10910b: 8b 80 d8 e2 11 00 mov 0x11e2d8(%eax),%eax <== NOT EXECUTED
109111: 85 c0 test %eax,%eax <== NOT EXECUTED
109113: 0f 84 ab 02 00 00 je 1093c4 <rtems_termios_ioctl+0x364><== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
109119: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10911c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
10911f: 53 push %ebx <== NOT EXECUTED
109120: ff d0 call *%eax <== NOT EXECUTED
109122: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED
109125: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109128: eb 8e jmp 1090b8 <rtems_termios_ioctl+0x58><== NOT EXECUTED
10912a: 66 90 xchg %ax,%ax <== NOT EXECUTED
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
break;
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
10912c: 8b 16 mov (%esi),%edx <== NOT EXECUTED
10912e: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED
109131: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx) <== NOT EXECUTED
109137: 89 93 dc 00 00 00 mov %edx,0xdc(%ebx) <== NOT EXECUTED
10913d: e9 76 ff ff ff jmp 1090b8 <rtems_termios_ioctl+0x58><== NOT EXECUTED
109142: 66 90 xchg %ax,%ax <== NOT EXECUTED
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
109144: 8b 16 mov (%esi),%edx <== NOT EXECUTED
109146: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED
109149: 89 83 d8 00 00 00 mov %eax,0xd8(%ebx) <== NOT EXECUTED
10914f: 89 93 d4 00 00 00 mov %edx,0xd4(%ebx) <== NOT EXECUTED
109155: e9 5e ff ff ff jmp 1090b8 <rtems_termios_ioctl+0x58><== NOT EXECUTED
10915a: 66 90 xchg %ax,%ax <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
10915c: 3d 1a 74 04 40 cmp $0x4004741a,%eax <== NOT EXECUTED
109161: 74 61 je 1091c4 <rtems_termios_ioctl+0x164><== NOT EXECUTED
109163: 3d 1b 74 04 80 cmp $0x8004741b,%eax <== NOT EXECUTED
109168: 75 98 jne 109102 <rtems_termios_ioctl+0xa2><== NOT EXECUTED
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
10916a: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED
109170: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
109173: 8b 80 c4 e2 11 00 mov 0x11e2c4(%eax),%eax <== NOT EXECUTED
109179: 85 c0 test %eax,%eax <== NOT EXECUTED
10917b: 74 0c je 109189 <rtems_termios_ioctl+0x129><== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
10917d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109180: 53 push %ebx <== NOT EXECUTED
109181: ff d0 call *%eax <== NOT EXECUTED
109183: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED
109186: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
tty->t_line=*(int*)(args->buffer);
109189: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
10918c: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED
10918f: 8b 00 mov (%eax),%eax <== NOT EXECUTED
109191: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx) <== NOT EXECUTED
tty->t_sc = NULL; /* ensure that no more valid data */
109197: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx) <== NOT EXECUTED
10919e: 00 00 00
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
1091a1: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
1091a4: 8b 80 c0 e2 11 00 mov 0x11e2c0(%eax),%eax <== NOT EXECUTED
1091aa: 85 c0 test %eax,%eax <== NOT EXECUTED
1091ac: 0f 84 06 ff ff ff je 1090b8 <rtems_termios_ioctl+0x58><== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
1091b2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1091b5: 53 push %ebx <== NOT EXECUTED
1091b6: ff d0 call *%eax <== NOT EXECUTED
1091b8: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED
1091bb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1091be: e9 f5 fe ff ff jmp 1090b8 <rtems_termios_ioctl+0x58><== NOT EXECUTED
1091c3: 90 nop <== NOT EXECUTED
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
1091c4: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
1091c7: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED
1091ca: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED
1091d0: 89 02 mov %eax,(%edx) <== NOT EXECUTED
1091d2: e9 e1 fe ff ff jmp 1090b8 <rtems_termios_ioctl+0x58><== NOT EXECUTED
1091d7: 90 nop <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
1091d8: 48 dec %eax <== NOT EXECUTED
1091d9: 0f 85 23 ff ff ff jne 109102 <rtems_termios_ioctl+0xa2><== NOT EXECUTED
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
1091df: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
1091e2: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED
1091e5: 8d 73 30 lea 0x30(%ebx),%esi <== NOT EXECUTED
1091e8: b9 09 00 00 00 mov $0x9,%ecx <== NOT EXECUTED
1091ed: 89 c7 mov %eax,%edi <== NOT EXECUTED
1091ef: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
1091f1: e9 c2 fe ff ff jmp 1090b8 <rtems_termios_ioctl+0x58><== NOT EXECUTED
1091f6: 66 90 xchg %ax,%ax <== NOT EXECUTED
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD:
{
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
1091f8: 8b 53 60 mov 0x60(%ebx),%edx <== NOT EXECUTED
1091fb: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED
if ( rawnc < 0 )
1091fe: 29 c2 sub %eax,%edx <== NOT EXECUTED
109200: 0f 88 b2 01 00 00 js 1093b8 <rtems_termios_ioctl+0x358><== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
109206: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED
109209: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED
10920c: 03 53 20 add 0x20(%ebx),%edx <== NOT EXECUTED
10920f: 2b 53 24 sub 0x24(%ebx),%edx <== NOT EXECUTED
109212: 89 10 mov %edx,(%eax) <== NOT EXECUTED
109214: e9 9f fe ff ff jmp 1090b8 <rtems_termios_ioctl+0x58><== NOT EXECUTED
109219: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
10921c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10921f: 8b 70 08 mov 0x8(%eax),%esi <== NOT EXECUTED
109222: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED
109225: 89 55 d8 mov %edx,-0x28(%ebp) <== NOT EXECUTED
109228: b9 09 00 00 00 mov $0x9,%ecx <== NOT EXECUTED
10922d: 89 d7 mov %edx,%edi <== NOT EXECUTED
10922f: 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) &&
109231: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109237: f6 c4 02 test $0x2,%ah <== NOT EXECUTED
10923a: 74 44 je 109280 <rtems_termios_ioctl+0x220><== NOT EXECUTED
10923c: f6 43 31 04 testb $0x4,0x31(%ebx) <== NOT EXECUTED
109240: 75 3e jne 109280 <rtems_termios_ioctl+0x220><== NOT EXECUTED
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
109242: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109248: 25 ef fd ff ff and $0xfffffdef,%eax <== NOT EXECUTED
10924d: 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) {
109253: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109259: a8 20 test $0x20,%al <== NOT EXECUTED
10925b: 74 23 je 109280 <rtems_termios_ioctl+0x220><== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
10925d: 9c pushf <== NOT EXECUTED
10925e: fa cli <== NOT EXECUTED
10925f: 5e pop %esi <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
109260: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109266: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
109269: 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) {
10926f: 8b 8b 94 00 00 00 mov 0x94(%ebx),%ecx <== NOT EXECUTED
109275: 85 c9 test %ecx,%ecx <== NOT EXECUTED
109277: 0f 85 7d 01 00 00 jne 1093fa <rtems_termios_ioctl+0x39a><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
10927d: 56 push %esi <== NOT EXECUTED
10927e: 9d popf <== NOT EXECUTED
10927f: 90 nop <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) &&
109280: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109286: f6 c4 04 test $0x4,%ah <== NOT EXECUTED
109289: 74 24 je 1092af <rtems_termios_ioctl+0x24f><== NOT EXECUTED
10928b: f6 43 31 10 testb $0x10,0x31(%ebx) <== NOT EXECUTED
10928f: 75 1e jne 1092af <rtems_termios_ioctl+0x24f><== NOT EXECUTED
!(tty->termios.c_iflag & IXOFF)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
109291: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109297: 80 e4 fb and $0xfb,%ah <== NOT EXECUTED
10929a: 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);
1092a0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1092a6: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED
1092a9: 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) &&
1092af: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1092b5: f6 c4 01 test $0x1,%ah <== NOT EXECUTED
1092b8: 74 48 je 109302 <rtems_termios_ioctl+0x2a2><== NOT EXECUTED
1092ba: 8b 7b 38 mov 0x38(%ebx),%edi <== NOT EXECUTED
1092bd: 85 ff test %edi,%edi <== NOT EXECUTED
1092bf: 0f 88 0b 01 00 00 js 1093d0 <rtems_termios_ioctl+0x370><== NOT EXECUTED
!(tty->termios.c_cflag & CRTSCTS)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
1092c5: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1092cb: 80 e4 fe and $0xfe,%ah <== NOT EXECUTED
1092ce: 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) &&
1092d4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1092da: a8 04 test $0x4,%al <== NOT EXECUTED
1092dc: 74 15 je 1092f3 <rtems_termios_ioctl+0x293><== NOT EXECUTED
1092de: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED
1092e4: 85 c0 test %eax,%eax <== NOT EXECUTED
1092e6: 74 0b je 1092f3 <rtems_termios_ioctl+0x293><== NOT EXECUTED
(tty->device.startRemoteTx != NULL)) {
tty->device.startRemoteTx(tty->minor);
1092e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1092eb: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
1092ee: ff d0 call *%eax <== NOT EXECUTED
1092f0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
1092f3: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1092f9: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED
1092fc: 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) {
109302: 8b 73 38 mov 0x38(%ebx),%esi <== NOT EXECUTED
109305: 85 f6 test %esi,%esi <== NOT EXECUTED
109307: 0f 88 c3 00 00 00 js 1093d0 <rtems_termios_ioctl+0x370><== NOT EXECUTED
tty->flow_ctrl |= FL_MDRTS;
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
10930d: 8b 53 30 mov 0x30(%ebx),%edx <== NOT EXECUTED
109310: f6 c6 10 test $0x10,%dh <== NOT EXECUTED
109313: 74 0f je 109324 <rtems_termios_ioctl+0x2c4><== NOT EXECUTED
tty->flow_ctrl |= FL_MDXOF;
109315: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10931b: 80 cc 04 or $0x4,%ah <== NOT EXECUTED
10931e: 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) {
109324: 80 e6 04 and $0x4,%dh <== NOT EXECUTED
109327: 74 0f je 109338 <rtems_termios_ioctl+0x2d8><== NOT EXECUTED
tty->flow_ctrl |= FL_MDXON;
109329: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10932f: 80 cc 02 or $0x2,%ah <== NOT EXECUTED
109332: 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) {
109338: f6 43 3c 02 testb $0x2,0x3c(%ebx) <== NOT EXECUTED
10933c: 74 36 je 109374 <rtems_termios_ioctl+0x314><== NOT EXECUTED
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
}
else {
if (tty->termios.c_cc[VMIN]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
10933e: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
109345: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
10934c: c7 43 74 00 00 00 00 movl $0x0,0x74(%ebx) <== NOT EXECUTED
else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
}
}
}
if (tty->device.setAttributes)
109353: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax <== NOT EXECUTED
109359: 85 c0 test %eax,%eax <== NOT EXECUTED
10935b: 0f 84 57 fd ff ff je 1090b8 <rtems_termios_ioctl+0x58><== NOT EXECUTED
(*tty->device.setAttributes)(tty->minor, &tty->termios);
109361: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
109364: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED
109367: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10936a: ff d0 call *%eax <== NOT EXECUTED
10936c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10936f: e9 44 fd ff ff jmp 1090b8 <rtems_termios_ioctl+0x58><== 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);
109374: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
109377: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED
10937a: 50 push %eax <== NOT EXECUTED
10937b: 6a 03 push $0x3 <== NOT EXECUTED
10937d: e8 8e 07 00 00 call 109b10 <rtems_clock_get> <== NOT EXECUTED
tty->vtimeTicks = tty->termios.c_cc[VTIME] * ticksPerSecond / 10;
109382: 0f b6 43 46 movzbl 0x46(%ebx),%eax <== NOT EXECUTED
109386: 0f af 45 f0 imul -0x10(%ebp),%eax <== NOT EXECUTED
10938a: ba cd cc cc cc mov $0xcccccccd,%edx <== NOT EXECUTED
10938f: f7 e2 mul %edx <== NOT EXECUTED
109391: c1 ea 03 shr $0x3,%edx <== NOT EXECUTED
109394: 89 53 54 mov %edx,0x54(%ebx) <== NOT EXECUTED
if (tty->termios.c_cc[VTIME]) {
109397: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10939a: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED
10939e: 74 44 je 1093e4 <rtems_termios_ioctl+0x384><== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
1093a0: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
1093a7: 89 53 70 mov %edx,0x70(%ebx) <== NOT EXECUTED
if (tty->termios.c_cc[VMIN])
1093aa: 80 7b 47 00 cmpb $0x0,0x47(%ebx) <== NOT EXECUTED
1093ae: 75 9c jne 10934c <rtems_termios_ioctl+0x2ec><== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
1093b0: 89 53 74 mov %edx,0x74(%ebx) <== NOT EXECUTED
1093b3: eb 9e jmp 109353 <rtems_termios_ioctl+0x2f3><== NOT EXECUTED
1093b5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
#endif
case FIONREAD:
{
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
if ( rawnc < 0 )
rawnc += tty->rawInBuf.Size;
1093b8: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED
1093bb: 01 c2 add %eax,%edx <== NOT EXECUTED
1093bd: e9 44 fe ff ff jmp 109206 <rtems_termios_ioctl+0x1a6><== NOT EXECUTED
1093c2: 66 90 xchg %ax,%ax <== NOT EXECUTED
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
1093c4: c7 45 d4 0a 00 00 00 movl $0xa,-0x2c(%ebp) <== NOT EXECUTED
1093cb: e9 e8 fc ff ff jmp 1090b8 <rtems_termios_ioctl+0x58><== 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) {
tty->flow_ctrl |= FL_MDRTS;
1093d0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1093d6: 80 cc 01 or $0x1,%ah <== NOT EXECUTED
1093d9: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
1093df: e9 29 ff ff ff jmp 10930d <rtems_termios_ioctl+0x2ad><== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
}
else {
if (tty->termios.c_cc[VMIN]) {
1093e4: 80 7b 47 00 cmpb $0x0,0x47(%ebx) <== NOT EXECUTED
1093e8: 0f 85 50 ff ff ff jne 10933e <rtems_termios_ioctl+0x2de><== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
}
else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
1093ee: c7 43 6c 01 00 00 00 movl $0x1,0x6c(%ebx) <== NOT EXECUTED
1093f5: e9 59 ff ff ff jmp 109353 <rtems_termios_ioctl+0x2f3><== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
1093fa: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED
109400: 52 push %edx <== NOT EXECUTED
109401: 6a 01 push $0x1 <== NOT EXECUTED
109403: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED
109406: 50 push %eax <== NOT EXECUTED
109407: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10940a: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
109410: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109413: e9 65 fe ff ff jmp 10927d <rtems_termios_ioctl+0x21d><== NOT EXECUTED
001095cc <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
1095cc: 55 push %ebp
1095cd: 89 e5 mov %esp,%ebp
1095cf: 57 push %edi
1095d0: 56 push %esi
1095d1: 53 push %ebx
1095d2: 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,
1095d5: 6a 00 push $0x0
1095d7: 6a 00 push $0x0
1095d9: ff 35 8c e5 11 00 pushl 0x11e58c
1095df: e8 0c 0e 00 00 call 10a3f0 <rtems_semaphore_obtain>
1095e4: 89 45 f0 mov %eax,-0x10(%ebp)
RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
1095e7: 83 c4 10 add $0x10,%esp
1095ea: 85 c0 test %eax,%eax
1095ec: 75 6e jne 10965c <rtems_termios_open+0x90><== NEVER TAKEN
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
1095ee: 8b 1d 94 e5 11 00 mov 0x11e594,%ebx
1095f4: 85 db test %ebx,%ebx
1095f6: 75 0a jne 109602 <rtems_termios_open+0x36>
1095f8: eb 6e jmp 109668 <rtems_termios_open+0x9c>
1095fa: 66 90 xchg %ax,%ax
1095fc: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED
1095fe: 85 db test %ebx,%ebx <== NOT EXECUTED
109600: 74 66 je 109668 <rtems_termios_open+0x9c><== NOT EXECUTED
if ((tty->major == major) && (tty->minor == minor))
109602: 8b 45 08 mov 0x8(%ebp),%eax
109605: 39 43 0c cmp %eax,0xc(%ebx)
109608: 75 f2 jne 1095fc <rtems_termios_open+0x30><== NEVER TAKEN
10960a: 8b 55 0c mov 0xc(%ebp),%edx
10960d: 39 53 10 cmp %edx,0x10(%ebx)
109610: 75 ea jne 1095fc <rtems_termios_open+0x30><== NEVER TAKEN
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
109612: 8b 7d 10 mov 0x10(%ebp),%edi
109615: 8b 07 mov (%edi),%eax
109617: 89 58 28 mov %ebx,0x28(%eax)
if (!tty->refcount++) {
10961a: 8b 53 08 mov 0x8(%ebx),%edx
10961d: 8d 42 01 lea 0x1(%edx),%eax
109620: 89 43 08 mov %eax,0x8(%ebx)
109623: 85 d2 test %edx,%edx
109625: 75 24 jne 10964b <rtems_termios_open+0x7f>
if (tty->device.firstOpen)
109627: 8b 83 98 00 00 00 mov 0x98(%ebx),%eax
10962d: 85 c0 test %eax,%eax
10962f: 74 0d je 10963e <rtems_termios_open+0x72><== NEVER TAKEN
(*tty->device.firstOpen)(major, minor, arg);
109631: 52 push %edx
109632: 57 push %edi
109633: ff 75 0c pushl 0xc(%ebp)
109636: ff 75 08 pushl 0x8(%ebp)
109639: ff d0 call *%eax
10963b: 83 c4 10 add $0x10,%esp
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
10963e: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
109645: 0f 84 8d 02 00 00 je 1098d8 <rtems_termios_open+0x30c><== NEVER TAKEN
(rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
10964b: 83 ec 0c sub $0xc,%esp
10964e: ff 35 8c e5 11 00 pushl 0x11e58c
109654: e8 8f 0e 00 00 call 10a4e8 <rtems_semaphore_release>
109659: 83 c4 10 add $0x10,%esp
return RTEMS_SUCCESSFUL;
}
10965c: 8b 45 f0 mov -0x10(%ebp),%eax
10965f: 8d 65 f4 lea -0xc(%ebp),%esp
109662: 5b pop %ebx
109663: 5e pop %esi
109664: 5f pop %edi
109665: c9 leave
109666: c3 ret
109667: 90 nop
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
109668: 83 ec 08 sub $0x8,%esp
10966b: 68 e8 00 00 00 push $0xe8
109670: 6a 01 push $0x1
109672: e8 45 4e 00 00 call 10e4bc <calloc>
109677: 89 45 e8 mov %eax,-0x18(%ebp)
10967a: 89 c3 mov %eax,%ebx
if (tty == NULL) {
10967c: 83 c4 10 add $0x10,%esp
10967f: 85 c0 test %eax,%eax
109681: 0f 84 b5 02 00 00 je 10993c <rtems_termios_open+0x370><== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
109687: a1 88 c4 11 00 mov 0x11c488,%eax
10968c: 8b 75 e8 mov -0x18(%ebp),%esi
10968f: 89 46 64 mov %eax,0x64(%esi)
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
109692: 8b 46 64 mov 0x64(%esi),%eax
109695: 83 ec 0c sub $0xc,%esp
109698: 50 push %eax
109699: e8 3a dc ff ff call 1072d8 <malloc>
10969e: 89 46 58 mov %eax,0x58(%esi)
if (tty->rawInBuf.theBuf == NULL) {
1096a1: 83 c4 10 add $0x10,%esp
1096a4: 85 c0 test %eax,%eax
1096a6: 0f 84 6b 02 00 00 je 109917 <rtems_termios_open+0x34b><== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
1096ac: a1 8c c4 11 00 mov 0x11c48c,%eax
1096b1: 8b 7d e8 mov -0x18(%ebp),%edi
1096b4: 89 87 88 00 00 00 mov %eax,0x88(%edi)
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
1096ba: 8b 87 88 00 00 00 mov 0x88(%edi),%eax
1096c0: 83 ec 0c sub $0xc,%esp
1096c3: 50 push %eax
1096c4: e8 0f dc ff ff call 1072d8 <malloc>
1096c9: 89 47 7c mov %eax,0x7c(%edi)
if (tty->rawOutBuf.theBuf == NULL) {
1096cc: 83 c4 10 add $0x10,%esp
1096cf: 85 c0 test %eax,%eax
1096d1: 0f 84 82 02 00 00 je 109959 <rtems_termios_open+0x38d><== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
1096d7: 83 ec 0c sub $0xc,%esp
1096da: ff 35 84 c4 11 00 pushl 0x11c484
1096e0: e8 f3 db ff ff call 1072d8 <malloc>
1096e5: 8b 55 e8 mov -0x18(%ebp),%edx
1096e8: 89 42 1c mov %eax,0x1c(%edx)
if (tty->cbuf == NULL) {
1096eb: 83 c4 10 add $0x10,%esp
1096ee: 85 c0 test %eax,%eax
1096f0: 0f 84 a6 02 00 00 je 10999c <rtems_termios_open+0x3d0><== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
1096f6: 8b 7d e8 mov -0x18(%ebp),%edi
1096f9: c7 87 d4 00 00 00 00 movl $0x0,0xd4(%edi)
109700: 00 00 00
tty->tty_snd.sw_arg = NULL;
109703: c7 87 d8 00 00 00 00 movl $0x0,0xd8(%edi)
10970a: 00 00 00
tty->tty_rcv.sw_pfn = NULL;
10970d: c7 87 dc 00 00 00 00 movl $0x0,0xdc(%edi)
109714: 00 00 00
tty->tty_rcv.sw_arg = NULL;
109717: c7 87 e0 00 00 00 00 movl $0x0,0xe0(%edi)
10971e: 00 00 00
tty->tty_rcvwakeup = 0;
109721: c7 87 e4 00 00 00 00 movl $0x0,0xe4(%edi)
109728: 00 00 00
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
10972b: a1 94 e5 11 00 mov 0x11e594,%eax
109730: 89 07 mov %eax,(%edi)
tty->back = NULL;
109732: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi)
if (rtems_termios_ttyHead != NULL)
109739: 85 c0 test %eax,%eax
10973b: 74 03 je 109740 <rtems_termios_open+0x174><== ALWAYS TAKEN
rtems_termios_ttyHead->back = tty;
10973d: 89 78 04 mov %edi,0x4(%eax) <== NOT EXECUTED
rtems_termios_ttyHead = tty;
109740: 8b 45 e8 mov -0x18(%ebp),%eax
109743: a3 94 e5 11 00 mov %eax,0x11e594
if (rtems_termios_ttyTail == NULL)
109748: 8b 35 90 e5 11 00 mov 0x11e590,%esi
10974e: 85 f6 test %esi,%esi
109750: 0f 84 d6 02 00 00 je 109a2c <rtems_termios_open+0x460><== ALWAYS TAKEN
rtems_termios_ttyTail = tty;
tty->minor = minor;
109756: 8b 75 0c mov 0xc(%ebp),%esi
109759: 8b 55 e8 mov -0x18(%ebp),%edx
10975c: 89 72 10 mov %esi,0x10(%edx)
tty->major = major;
10975f: 8b 7d 08 mov 0x8(%ebp),%edi
109762: 89 7a 0c mov %edi,0xc(%edx)
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
109765: 83 ec 0c sub $0xc,%esp
109768: 89 d0 mov %edx,%eax
10976a: 83 c0 14 add $0x14,%eax
10976d: 50 push %eax
10976e: 6a 00 push $0x0
109770: 6a 54 push $0x54
109772: 6a 01 push $0x1
109774: 0f be 05 90 c4 11 00 movsbl 0x11c490,%eax
10977b: 0d 00 69 52 54 or $0x54526900,%eax
109780: 50 push %eax
109781: e8 ea 09 00 00 call 10a170 <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)
109786: 83 c4 20 add $0x20,%esp
109789: 85 c0 test %eax,%eax
10978b: 0f 85 7d 01 00 00 jne 10990e <rtems_termios_open+0x342><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
109791: 83 ec 0c sub $0xc,%esp
109794: 8b 45 e8 mov -0x18(%ebp),%eax
109797: 83 c0 18 add $0x18,%eax
10979a: 50 push %eax
10979b: 6a 00 push $0x0
10979d: 6a 54 push $0x54
10979f: 6a 01 push $0x1
1097a1: 0f be 05 90 c4 11 00 movsbl 0x11c490,%eax
1097a8: 0d 00 6f 52 54 or $0x54526f00,%eax
1097ad: 50 push %eax
1097ae: e8 bd 09 00 00 call 10a170 <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)
1097b3: 83 c4 20 add $0x20,%esp
1097b6: 85 c0 test %eax,%eax
1097b8: 0f 85 50 01 00 00 jne 10990e <rtems_termios_open+0x342><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
1097be: 83 ec 0c sub $0xc,%esp
1097c1: 8b 45 e8 mov -0x18(%ebp),%eax
1097c4: 05 8c 00 00 00 add $0x8c,%eax
1097c9: 50 push %eax
1097ca: 6a 00 push $0x0
1097cc: 6a 20 push $0x20
1097ce: 6a 00 push $0x0
1097d0: 0f be 05 90 c4 11 00 movsbl 0x11c490,%eax
1097d7: 0d 00 78 52 54 or $0x54527800,%eax
1097dc: 50 push %eax
1097dd: e8 8e 09 00 00 call 10a170 <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)
1097e2: 83 c4 20 add $0x20,%esp
1097e5: 85 c0 test %eax,%eax
1097e7: 0f 85 21 01 00 00 jne 10990e <rtems_termios_open+0x342><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
1097ed: 8b 45 e8 mov -0x18(%ebp),%eax
1097f0: c7 80 94 00 00 00 00 movl $0x0,0x94(%eax)
1097f7: 00 00 00
/*
* Set callbacks
*/
tty->device = *callbacks;
1097fa: 05 98 00 00 00 add $0x98,%eax
1097ff: b9 08 00 00 00 mov $0x8,%ecx
109804: 89 c7 mov %eax,%edi
109806: 8b 75 14 mov 0x14(%ebp),%esi
109809: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
10980b: 8b 45 e8 mov -0x18(%ebp),%eax
10980e: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax)
109815: 0f 84 a0 01 00 00 je 1099bb <rtems_termios_open+0x3ef><== NEVER TAKEN
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
10981b: 8b 55 e8 mov -0x18(%ebp),%edx
10981e: 8b 8a a0 00 00 00 mov 0xa0(%edx),%ecx
109824: 85 c9 test %ecx,%ecx
109826: 0f 84 3d 01 00 00 je 109969 <rtems_termios_open+0x39d><== ALWAYS TAKEN
10982c: 83 ba b4 00 00 00 02 cmpl $0x2,0xb4(%edx) <== NOT EXECUTED
109833: 0f 84 30 01 00 00 je 109969 <rtems_termios_open+0x39d><== NOT EXECUTED
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
109839: 8b 75 e8 mov -0x18(%ebp),%esi
10983c: c7 46 30 02 25 00 00 movl $0x2502,0x30(%esi)
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
109843: c7 46 34 05 18 00 00 movl $0x1805,0x34(%esi)
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
10984a: c7 46 38 bd 08 00 00 movl $0x8bd,0x38(%esi)
tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
109851: c7 46 3c 3b 82 00 00 movl $0x823b,0x3c(%esi)
tty->termios.c_cc[VINTR] = '\003';
109858: c6 46 41 03 movb $0x3,0x41(%esi)
tty->termios.c_cc[VQUIT] = '\034';
10985c: c6 46 42 1c movb $0x1c,0x42(%esi)
tty->termios.c_cc[VERASE] = '\177';
109860: c6 46 43 7f movb $0x7f,0x43(%esi)
tty->termios.c_cc[VKILL] = '\025';
109864: c6 46 44 15 movb $0x15,0x44(%esi)
tty->termios.c_cc[VEOF] = '\004';
109868: c6 46 45 04 movb $0x4,0x45(%esi)
tty->termios.c_cc[VEOL] = '\000';
10986c: c6 46 4c 00 movb $0x0,0x4c(%esi)
tty->termios.c_cc[VEOL2] = '\000';
109870: c6 46 51 00 movb $0x0,0x51(%esi)
tty->termios.c_cc[VSTART] = '\021';
109874: c6 46 49 11 movb $0x11,0x49(%esi)
tty->termios.c_cc[VSTOP] = '\023';
109878: c6 46 4a 13 movb $0x13,0x4a(%esi)
tty->termios.c_cc[VSUSP] = '\032';
10987c: c6 46 4b 1a movb $0x1a,0x4b(%esi)
tty->termios.c_cc[VREPRINT] = '\022';
109880: c6 46 4d 12 movb $0x12,0x4d(%esi)
tty->termios.c_cc[VDISCARD] = '\017';
109884: c6 46 4e 0f movb $0xf,0x4e(%esi)
tty->termios.c_cc[VWERASE] = '\027';
109888: c6 46 4f 17 movb $0x17,0x4f(%esi)
tty->termios.c_cc[VLNEXT] = '\026';
10988c: c6 46 50 16 movb $0x16,0x50(%esi)
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
109890: c7 86 b8 00 00 00 00 movl $0x0,0xb8(%esi)
109897: 00 00 00
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
10989a: 8b 46 64 mov 0x64(%esi),%eax
10989d: d1 e8 shr %eax
10989f: 89 86 bc 00 00 00 mov %eax,0xbc(%esi)
tty->highwater = tty->rawInBuf.Size * 3/4;
1098a5: 8b 46 64 mov 0x64(%esi),%eax
1098a8: 8d 04 40 lea (%eax,%eax,2),%eax
1098ab: c1 e8 02 shr $0x2,%eax
1098ae: 89 86 c0 00 00 00 mov %eax,0xc0(%esi)
/*
* Bump name characer
*/
if (c++ == 'z')
1098b4: 8a 15 90 c4 11 00 mov 0x11c490,%dl
1098ba: 8d 42 01 lea 0x1(%edx),%eax
1098bd: a2 90 c4 11 00 mov %al,0x11c490
1098c2: 80 fa 7a cmp $0x7a,%dl
1098c5: 0f 85 47 fd ff ff jne 109612 <rtems_termios_open+0x46><== ALWAYS TAKEN
c = 'a';
1098cb: c6 05 90 c4 11 00 61 movb $0x61,0x11c490 <== NOT EXECUTED
1098d2: e9 3b fd ff ff jmp 109612 <rtems_termios_open+0x46><== NOT EXECUTED
1098d7: 90 nop <== NOT EXECUTED
(*tty->device.firstOpen)(major, minor, arg);
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_start(tty->rxTaskId,
1098d8: 57 push %edi <== NOT EXECUTED
1098d9: 53 push %ebx <== NOT EXECUTED
1098da: 68 a4 9a 10 00 push $0x109aa4 <== NOT EXECUTED
1098df: ff b3 c4 00 00 00 pushl 0xc4(%ebx) <== NOT EXECUTED
1098e5: e8 3e 0f 00 00 call 10a828 <rtems_task_start> <== NOT EXECUTED
rtems_termios_rxdaemon,
(rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
1098ea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1098ed: 85 c0 test %eax,%eax <== NOT EXECUTED
1098ef: 75 1d jne 10990e <rtems_termios_open+0x342><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(tty->txTaskId,
1098f1: 56 push %esi <== NOT EXECUTED
1098f2: 53 push %ebx <== NOT EXECUTED
1098f3: 68 38 9a 10 00 push $0x109a38 <== NOT EXECUTED
1098f8: ff b3 c8 00 00 00 pushl 0xc8(%ebx) <== NOT EXECUTED
1098fe: e8 25 0f 00 00 call 10a828 <rtems_task_start> <== NOT EXECUTED
rtems_termios_txdaemon,
(rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
109903: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109906: 85 c0 test %eax,%eax <== NOT EXECUTED
109908: 0f 84 3d fd ff ff je 10964b <rtems_termios_open+0x7f><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
10990e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109911: 50 push %eax <== NOT EXECUTED
109912: e8 6d 11 00 00 call 10aa84 <rtems_fatal_error_occurred><== NOT EXECUTED
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
if (tty->rawInBuf.theBuf == NULL) {
free(tty);
109917: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10991a: 56 push %esi <== NOT EXECUTED
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
if (tty->rawOutBuf.theBuf == NULL) {
free((void *)(tty->rawInBuf.theBuf));
free(tty);
10991b: e8 a0 d7 ff ff call 1070c0 <free> <== NOT EXECUTED
rtems_semaphore_release (rtems_termios_ttyMutex);
109920: 58 pop %eax <== NOT EXECUTED
109921: ff 35 8c e5 11 00 pushl 0x11e58c <== NOT EXECUTED
109927: e8 bc 0b 00 00 call 10a4e8 <rtems_semaphore_release><== NOT EXECUTED
10992c: c7 45 f0 1a 00 00 00 movl $0x1a,-0x10(%ebp) <== NOT EXECUTED
109933: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109936: e9 21 fd ff ff jmp 10965c <rtems_termios_open+0x90><== NOT EXECUTED
10993b: 90 nop <== NOT EXECUTED
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
if (tty == NULL) {
rtems_semaphore_release (rtems_termios_ttyMutex);
10993c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10993f: ff 35 8c e5 11 00 pushl 0x11e58c <== NOT EXECUTED
109945: e8 9e 0b 00 00 call 10a4e8 <rtems_semaphore_release><== NOT EXECUTED
10994a: c7 45 f0 1a 00 00 00 movl $0x1a,-0x10(%ebp) <== NOT EXECUTED
109951: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109954: e9 03 fd ff ff jmp 10965c <rtems_termios_open+0x90><== NOT EXECUTED
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
if (tty->rawOutBuf.theBuf == NULL) {
free((void *)(tty->rawInBuf.theBuf));
109959: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10995c: ff 77 58 pushl 0x58(%edi) <== NOT EXECUTED
10995f: e8 5c d7 ff ff call 1070c0 <free> <== NOT EXECUTED
free(tty);
109964: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
109967: eb b2 jmp 10991b <rtems_termios_open+0x34f><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
109969: 83 ec 0c sub $0xc,%esp
10996c: 8b 45 e8 mov -0x18(%ebp),%eax
10996f: 83 c0 68 add $0x68,%eax
109972: 50 push %eax
109973: 6a 00 push $0x0
109975: 6a 24 push $0x24
109977: 6a 00 push $0x0
109979: 0f be 05 90 c4 11 00 movsbl 0x11c490,%eax
109980: 0d 00 72 52 54 or $0x54527200,%eax
109985: 50 push %eax
109986: e8 e5 07 00 00 call 10a170 <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)
10998b: 83 c4 20 add $0x20,%esp
10998e: 85 c0 test %eax,%eax
109990: 0f 84 a3 fe ff ff je 109839 <rtems_termios_open+0x26d><== ALWAYS TAKEN
109996: e9 73 ff ff ff jmp 10990e <rtems_termios_open+0x342><== NOT EXECUTED
10999b: 90 nop <== NOT EXECUTED
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
10999c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10999f: ff 72 7c pushl 0x7c(%edx) <== NOT EXECUTED
1099a2: e8 19 d7 ff ff call 1070c0 <free> <== NOT EXECUTED
free((void *)(tty->rawInBuf.theBuf));
1099a7: 5f pop %edi <== NOT EXECUTED
1099a8: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED
1099ab: ff 76 58 pushl 0x58(%esi) <== NOT EXECUTED
1099ae: e8 0d d7 ff ff call 1070c0 <free> <== NOT EXECUTED
free(tty);
1099b3: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
1099b6: e9 60 ff ff ff jmp 10991b <rtems_termios_open+0x34f><== NOT EXECUTED
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
1099bb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
1099be: 05 c8 00 00 00 add $0xc8,%eax <== NOT EXECUTED
1099c3: 50 push %eax <== NOT EXECUTED
1099c4: 6a 00 push $0x0 <== NOT EXECUTED
1099c6: 68 00 05 00 00 push $0x500 <== NOT EXECUTED
1099cb: 68 00 04 00 00 push $0x400 <== NOT EXECUTED
1099d0: 6a 0a push $0xa <== NOT EXECUTED
1099d2: 0f be 05 90 c4 11 00 movsbl 0x11c490,%eax <== NOT EXECUTED
1099d9: 0d 00 54 78 54 or $0x54785400,%eax <== NOT EXECUTED
1099de: 50 push %eax <== NOT EXECUTED
1099df: e8 a4 0b 00 00 call 10a588 <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)
1099e4: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
1099e7: 85 c0 test %eax,%eax <== NOT EXECUTED
1099e9: 0f 85 1f ff ff ff jne 10990e <rtems_termios_open+0x342><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
1099ef: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
1099f2: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED
1099f5: 05 c4 00 00 00 add $0xc4,%eax <== NOT EXECUTED
1099fa: 50 push %eax <== NOT EXECUTED
1099fb: 6a 00 push $0x0 <== NOT EXECUTED
1099fd: 68 00 05 00 00 push $0x500 <== NOT EXECUTED
109a02: 68 00 04 00 00 push $0x400 <== NOT EXECUTED
109a07: 6a 09 push $0x9 <== NOT EXECUTED
109a09: 0f be 05 90 c4 11 00 movsbl 0x11c490,%eax <== NOT EXECUTED
109a10: 0d 00 54 78 52 or $0x52785400,%eax <== NOT EXECUTED
109a15: 50 push %eax <== NOT EXECUTED
109a16: e8 6d 0b 00 00 call 10a588 <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)
109a1b: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
109a1e: 85 c0 test %eax,%eax <== NOT EXECUTED
109a20: 0f 84 f5 fd ff ff je 10981b <rtems_termios_open+0x24f><== NOT EXECUTED
109a26: e9 e3 fe ff ff jmp 10990e <rtems_termios_open+0x342><== NOT EXECUTED
109a2b: 90 nop <== NOT EXECUTED
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
109a2c: a3 90 e5 11 00 mov %eax,0x11e590
109a31: e9 20 fd ff ff jmp 109756 <rtems_termios_open+0x18a>
00108590 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
108590: 55 push %ebp
108591: 89 e5 mov %esp,%ebp
108593: 57 push %edi
108594: 56 push %esi
108595: 53 push %ebx
108596: 83 ec 1c sub $0x1c,%esp
108599: 8b 45 08 mov 0x8(%ebp),%eax
10859c: 8b 55 0c mov 0xc(%ebp),%edx
10859f: 89 55 e8 mov %edx,-0x18(%ebp)
1085a2: 8b 5d 10 mov 0x10(%ebp),%ebx
const unsigned char *buf = _buf;
1085a5: 89 45 ec mov %eax,-0x14(%ebp)
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
1085a8: 8b 8b b4 00 00 00 mov 0xb4(%ebx),%ecx
1085ae: 85 c9 test %ecx,%ecx
1085b0: 0f 84 e6 00 00 00 je 10869c <rtems_termios_puts+0x10c><== NEVER TAKEN
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
1085b6: 8b bb 80 00 00 00 mov 0x80(%ebx),%edi
1085bc: 89 7d f0 mov %edi,-0x10(%ebp)
while (len) {
1085bf: 8b 45 e8 mov -0x18(%ebp),%eax
1085c2: 85 c0 test %eax,%eax
1085c4: 0f 84 ed 00 00 00 je 1086b7 <rtems_termios_puts+0x127><== NEVER TAKEN
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
1085ca: 8b 75 f0 mov -0x10(%ebp),%esi
1085cd: 46 inc %esi
1085ce: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx
1085d4: 89 f0 mov %esi,%eax
1085d6: 31 d2 xor %edx,%edx
1085d8: f7 f1 div %ecx
1085da: 89 55 e4 mov %edx,-0x1c(%ebp)
1085dd: 89 55 f0 mov %edx,-0x10(%ebp)
rtems_interrupt_disable (level);
1085e0: 9c pushf
1085e1: fa cli
1085e2: 5e pop %esi
while (newHead == tty->rawOutBuf.Tail) {
1085e3: 8b bb 84 00 00 00 mov 0x84(%ebx),%edi
1085e9: 39 d7 cmp %edx,%edi
1085eb: 75 33 jne 108620 <rtems_termios_puts+0x90>
1085ed: 8d 76 00 lea 0x0(%esi),%esi
tty->rawOutBufState = rob_wait;
1085f0: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx)
1085f7: 00 00 00
rtems_interrupt_enable (level);
1085fa: 56 push %esi
1085fb: 9d popf
sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
1085fc: 50 push %eax
1085fd: 6a 00 push $0x0
1085ff: 6a 00 push $0x0
108601: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
108607: e8 e4 1d 00 00 call 10a3f0 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
10860c: 83 c4 10 add $0x10,%esp
10860f: 85 c0 test %eax,%eax
108611: 75 65 jne 108678 <rtems_termios_puts+0xe8><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
108613: 9c pushf
108614: fa cli
108615: 5e pop %esi
* 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) {
108616: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
10861c: 39 f8 cmp %edi,%eax
10861e: 74 d0 je 1085f0 <rtems_termios_puts+0x60><== NEVER TAKEN
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
108620: 8b 8b 80 00 00 00 mov 0x80(%ebx),%ecx
108626: 8b 53 7c mov 0x7c(%ebx),%edx
108629: 8b 7d ec mov -0x14(%ebp),%edi
10862c: 8a 07 mov (%edi),%al
10862e: 88 04 0a mov %al,(%edx,%ecx,1)
tty->rawOutBuf.Head = newHead;
108631: 8b 45 e4 mov -0x1c(%ebp),%eax
108634: 89 83 80 00 00 00 mov %eax,0x80(%ebx)
if (tty->rawOutBufState == rob_idle) {
10863a: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax
108640: 85 c0 test %eax,%eax
108642: 75 23 jne 108667 <rtems_termios_puts+0xd7>
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
108644: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10864a: a8 10 test $0x10,%al
10864c: 74 33 je 108681 <rtems_termios_puts+0xf1><== ALWAYS TAKEN
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
10864e: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108654: 83 c8 20 or $0x20,%eax <== NOT EXECUTED
108657: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
10865d: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx)
108664: 00 00 00
}
rtems_interrupt_enable (level);
108667: 56 push %esi
108668: 9d popf
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
108669: ff 4d e8 decl -0x18(%ebp)
10866c: 74 49 je 1086b7 <rtems_termios_puts+0x127>
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
10866e: ff 45 ec incl -0x14(%ebp)
108671: e9 54 ff ff ff jmp 1085ca <rtems_termios_puts+0x3a>
108676: 66 90 xchg %ax,%ax
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
108678: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10867b: 50 push %eax <== NOT EXECUTED
10867c: e8 03 24 00 00 call 10aa84 <rtems_fatal_error_occurred><== NOT EXECUTED
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(tty->minor,
108681: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
108687: 57 push %edi
108688: 6a 01 push $0x1
10868a: 03 43 7c add 0x7c(%ebx),%eax
10868d: 50 push %eax
10868e: ff 73 10 pushl 0x10(%ebx)
108691: ff 93 a4 00 00 00 call *0xa4(%ebx)
108697: 83 c4 10 add $0x10,%esp
10869a: eb c1 jmp 10865d <rtems_termios_puts+0xcd>
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);
10869c: 89 55 10 mov %edx,0x10(%ebp) <== NOT EXECUTED
10869f: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED
1086a2: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED
1086a5: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
1086a8: 8b 8b a4 00 00 00 mov 0xa4(%ebx),%ecx <== NOT EXECUTED
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
1086ae: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1086b1: 5b pop %ebx <== NOT EXECUTED
1086b2: 5e pop %esi <== NOT EXECUTED
1086b3: 5f pop %edi <== NOT EXECUTED
1086b4: 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);
1086b5: ff e1 jmp *%ecx <== NOT EXECUTED
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
1086b7: 8d 65 f4 lea -0xc(%ebp),%esp
1086ba: 5b pop %ebx
1086bb: 5e pop %esi
1086bc: 5f pop %edi
1086bd: c9 leave
1086be: c3 ret
00108cc8 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
108cc8: 55 push %ebp <== NOT EXECUTED
108cc9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
108ccb: 57 push %edi <== NOT EXECUTED
108ccc: 56 push %esi <== NOT EXECUTED
108ccd: 53 push %ebx <== NOT EXECUTED
108cce: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
108cd1: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
108cd4: 8b 02 mov (%edx),%eax <== NOT EXECUTED
108cd6: 8b 70 28 mov 0x28(%eax),%esi <== NOT EXECUTED
uint32_t count = args->count;
108cd9: 8b 4a 0c mov 0xc(%edx),%ecx <== NOT EXECUTED
108cdc: 89 4d d0 mov %ecx,-0x30(%ebp) <== NOT EXECUTED
char *buffer = args->buffer;
108cdf: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED
108ce2: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
108ce5: 6a 00 push $0x0 <== NOT EXECUTED
108ce7: 6a 00 push $0x0 <== NOT EXECUTED
108ce9: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED
108cec: e8 ff 16 00 00 call 10a3f0 <rtems_semaphore_obtain><== NOT EXECUTED
108cf1: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
108cf4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108cf7: 85 c0 test %eax,%eax <== NOT EXECUTED
108cf9: 75 35 jne 108d30 <rtems_termios_read+0x68><== NOT EXECUTED
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
108cfb: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED
108d01: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
108d04: 8b 80 c8 e2 11 00 mov 0x11e2c8(%eax),%eax <== NOT EXECUTED
108d0a: 85 c0 test %eax,%eax <== NOT EXECUTED
108d0c: 74 2e je 108d3c <rtems_termios_read+0x74><== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
108d0e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
108d11: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
108d14: 56 push %esi <== NOT EXECUTED
108d15: ff d0 call *%eax <== NOT EXECUTED
108d17: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
108d1a: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi) <== NOT EXECUTED
108d21: 00 00 00
rtems_semaphore_release (tty->isem);
108d24: 5b pop %ebx <== NOT EXECUTED
108d25: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED
108d28: e8 bb 17 00 00 call 10a4e8 <rtems_semaphore_release><== NOT EXECUTED
108d2d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
args->bytes_moved = args->count - count;
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
108d30: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED
108d33: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
108d36: 5b pop %ebx <== NOT EXECUTED
108d37: 5e pop %esi <== NOT EXECUTED
108d38: 5f pop %edi <== NOT EXECUTED
108d39: c9 leave <== NOT EXECUTED
108d3a: c3 ret <== NOT EXECUTED
108d3b: 90 nop <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
108d3c: 8b 46 24 mov 0x24(%esi),%eax <== NOT EXECUTED
108d3f: 3b 46 20 cmp 0x20(%esi),%eax <== NOT EXECUTED
108d42: 74 60 je 108da4 <rtems_termios_read+0xdc><== NOT EXECUTED
else
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
108d44: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED
108d47: 85 c0 test %eax,%eax <== NOT EXECUTED
108d49: 74 2a je 108d75 <rtems_termios_read+0xad><== NOT EXECUTED
108d4b: 8b 56 24 mov 0x24(%esi),%edx <== NOT EXECUTED
108d4e: 3b 56 20 cmp 0x20(%esi),%edx <== NOT EXECUTED
108d51: 7c 0a jl 108d5d <rtems_termios_read+0x95><== NOT EXECUTED
108d53: eb 20 jmp 108d75 <rtems_termios_read+0xad><== NOT EXECUTED
108d55: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
108d58: 39 56 20 cmp %edx,0x20(%esi) <== NOT EXECUTED
108d5b: 7e 18 jle 108d75 <rtems_termios_read+0xad><== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
108d5d: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED
108d60: 8a 04 10 mov (%eax,%edx,1),%al <== NOT EXECUTED
108d63: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED
108d66: 88 01 mov %al,(%ecx) <== NOT EXECUTED
108d68: 41 inc %ecx <== NOT EXECUTED
108d69: 89 4d d4 mov %ecx,-0x2c(%ebp) <== NOT EXECUTED
108d6c: 42 inc %edx <== NOT EXECUTED
108d6d: 89 56 24 mov %edx,0x24(%esi) <== NOT EXECUTED
else
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
108d70: ff 4d d0 decl -0x30(%ebp) <== NOT EXECUTED
108d73: 75 e3 jne 108d58 <rtems_termios_read+0x90><== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
108d75: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
108d78: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED
108d7b: 2b 45 d0 sub -0x30(%ebp),%eax <== NOT EXECUTED
108d7e: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
108d81: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi) <== NOT EXECUTED
108d88: 00 00 00
rtems_semaphore_release (tty->isem);
108d8b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108d8e: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED
108d91: e8 52 17 00 00 call 10a4e8 <rtems_semaphore_release><== NOT EXECUTED
108d96: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return sc;
}
108d99: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED
108d9c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
108d9f: 5b pop %ebx <== NOT EXECUTED
108da0: 5e pop %esi <== NOT EXECUTED
108da1: 5f pop %edi <== NOT EXECUTED
108da2: c9 leave <== NOT EXECUTED
108da3: c3 ret <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
108da4: c7 46 20 00 00 00 00 movl $0x0,0x20(%esi) <== NOT EXECUTED
108dab: c7 46 24 00 00 00 00 movl $0x0,0x24(%esi) <== NOT EXECUTED
tty->read_start_column = tty->column;
108db2: 8b 46 28 mov 0x28(%esi),%eax <== NOT EXECUTED
108db5: 89 46 2c mov %eax,0x2c(%esi) <== NOT EXECUTED
if (tty->device.pollRead != NULL
108db8: 8b 86 a0 00 00 00 mov 0xa0(%esi),%eax <== NOT EXECUTED
108dbe: 89 c2 mov %eax,%edx <== NOT EXECUTED
108dc0: 85 c0 test %eax,%eax <== NOT EXECUTED
108dc2: 74 0e je 108dd2 <rtems_termios_read+0x10a><== NOT EXECUTED
108dc4: 8b 8e b4 00 00 00 mov 0xb4(%esi),%ecx <== NOT EXECUTED
108dca: 85 c9 test %ecx,%ecx <== NOT EXECUTED
108dcc: 0f 84 69 01 00 00 je 108f3b <rtems_termios_read+0x273><== 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;
108dd2: 8b 5e 74 mov 0x74(%esi),%ebx <== 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,
108dd5: 8d 56 49 lea 0x49(%esi),%edx <== NOT EXECUTED
108dd8: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED
108ddb: c7 45 dc 01 00 00 00 movl $0x1,-0x24(%ebp) <== NOT EXECUTED
108de2: 66 90 xchg %ax,%ax <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
108de4: 8b 56 5c mov 0x5c(%esi),%edx <== NOT EXECUTED
108de7: 8b 46 60 mov 0x60(%esi),%eax <== NOT EXECUTED
108dea: 39 c2 cmp %eax,%edx <== NOT EXECUTED
108dec: 75 2e jne 108e1c <rtems_termios_read+0x154><== NOT EXECUTED
108dee: e9 f1 00 00 00 jmp 108ee4 <rtems_termios_read+0x21c><== NOT EXECUTED
108df3: 90 nop <== NOT EXECUTED
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
108df4: 89 fa mov %edi,%edx <== NOT EXECUTED
108df6: 0f b6 c2 movzbl %dl,%eax <== NOT EXECUTED
108df9: 89 f2 mov %esi,%edx <== NOT EXECUTED
108dfb: e8 30 fd ff ff call 108b30 <siproc> <== NOT EXECUTED
108e00: 85 c0 test %eax,%eax <== NOT EXECUTED
108e02: 74 07 je 108e0b <rtems_termios_read+0x143><== NOT EXECUTED
wait = 0;
}
else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
108e04: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
108e0b: 8b 5e 70 mov 0x70(%esi),%ebx <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
108e0e: 8b 56 5c mov 0x5c(%esi),%edx <== NOT EXECUTED
108e11: 8b 46 60 mov 0x60(%esi),%eax <== NOT EXECUTED
108e14: 39 c2 cmp %eax,%edx <== NOT EXECUTED
108e16: 0f 84 c8 00 00 00 je 108ee4 <rtems_termios_read+0x21c><== NOT EXECUTED
108e1c: a1 84 c4 11 00 mov 0x11c484,%eax <== NOT EXECUTED
108e21: 48 dec %eax <== NOT EXECUTED
108e22: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED
108e25: 0f 8d b9 00 00 00 jge 108ee4 <rtems_termios_read+0x21c><== NOT EXECUTED
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
108e2b: 8b 46 5c mov 0x5c(%esi),%eax <== NOT EXECUTED
108e2e: 8b 56 64 mov 0x64(%esi),%edx <== NOT EXECUTED
108e31: 40 inc %eax <== NOT EXECUTED
108e32: 89 d1 mov %edx,%ecx <== NOT EXECUTED
108e34: 31 d2 xor %edx,%edx <== NOT EXECUTED
108e36: f7 f1 div %ecx <== NOT EXECUTED
c = tty->rawInBuf.theBuf[newHead];
108e38: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED
108e3b: 0f b6 3c 10 movzbl (%eax,%edx,1),%edi <== NOT EXECUTED
tty->rawInBuf.Head = newHead;
108e3f: 89 56 5c mov %edx,0x5c(%esi) <== NOT EXECUTED
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
108e42: 8b 5e 60 mov 0x60(%esi),%ebx <== NOT EXECUTED
108e45: 8b 46 64 mov 0x64(%esi),%eax <== NOT EXECUTED
108e48: 8b 4e 64 mov 0x64(%esi),%ecx <== NOT EXECUTED
108e4b: 01 d8 add %ebx,%eax <== NOT EXECUTED
108e4d: 29 d0 sub %edx,%eax <== NOT EXECUTED
108e4f: 31 d2 xor %edx,%edx <== NOT EXECUTED
108e51: f7 f1 div %ecx <== NOT EXECUTED
108e53: 3b 96 bc 00 00 00 cmp 0xbc(%esi),%edx <== NOT EXECUTED
108e59: 73 55 jae 108eb0 <rtems_termios_read+0x1e8><== NOT EXECUTED
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
108e5b: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
108e61: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED
108e64: 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))
108e6a: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
108e70: 25 02 02 00 00 and $0x202,%eax <== NOT EXECUTED
108e75: 3d 02 02 00 00 cmp $0x202,%eax <== NOT EXECUTED
108e7a: 0f 84 8c 00 00 00 je 108f0c <rtems_termios_read+0x244><== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTART]),
1);
}
else if (tty->flow_ctrl & FL_MDRTS) {
108e80: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
108e86: f6 c4 01 test $0x1,%ah <== NOT EXECUTED
108e89: 74 25 je 108eb0 <rtems_termios_read+0x1e8><== NOT EXECUTED
tty->flow_ctrl &= ~FL_IRTSOFF;
108e8b: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
108e91: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED
108e94: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
108e9a: 8b 86 b0 00 00 00 mov 0xb0(%esi),%eax <== NOT EXECUTED
108ea0: 85 c0 test %eax,%eax <== NOT EXECUTED
108ea2: 74 0c je 108eb0 <rtems_termios_read+0x1e8><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
108ea4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108ea7: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
108eaa: ff d0 call *%eax <== NOT EXECUTED
108eac: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108eaf: 90 nop <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
108eb0: f6 46 3c 02 testb $0x2,0x3c(%esi) <== NOT EXECUTED
108eb4: 0f 85 3a ff ff ff jne 108df4 <rtems_termios_read+0x12c><== NOT EXECUTED
if (siproc (c, tty))
wait = 0;
}
else {
siproc (c, tty);
108eba: 89 f9 mov %edi,%ecx <== NOT EXECUTED
108ebc: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED
108ebf: 89 f2 mov %esi,%edx <== NOT EXECUTED
108ec1: e8 6a fc ff ff call 108b30 <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
108ec6: 0f b6 46 47 movzbl 0x47(%esi),%eax <== NOT EXECUTED
108eca: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED
108ecd: 0f 8d 31 ff ff ff jge 108e04 <rtems_termios_read+0x13c><== NOT EXECUTED
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
108ed3: 8b 5e 70 mov 0x70(%esi),%ebx <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
108ed6: 8b 56 5c mov 0x5c(%esi),%edx <== NOT EXECUTED
108ed9: 8b 46 60 mov 0x60(%esi),%eax <== NOT EXECUTED
108edc: 39 c2 cmp %eax,%edx <== NOT EXECUTED
108ede: 0f 85 38 ff ff ff jne 108e1c <rtems_termios_read+0x154><== NOT EXECUTED
}
/*
* Wait for characters
*/
if ( wait ) {
108ee4: 8b 4d dc mov -0x24(%ebp),%ecx <== NOT EXECUTED
108ee7: 85 c9 test %ecx,%ecx <== NOT EXECUTED
108ee9: 0f 84 55 fe ff ff je 108d44 <rtems_termios_read+0x7c><== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->rawInBuf.Semaphore,
108eef: 52 push %edx <== NOT EXECUTED
108ef0: 53 push %ebx <== NOT EXECUTED
108ef1: ff 76 6c pushl 0x6c(%esi) <== NOT EXECUTED
108ef4: ff 76 68 pushl 0x68(%esi) <== NOT EXECUTED
108ef7: e8 f4 14 00 00 call 10a3f0 <rtems_semaphore_obtain><== NOT EXECUTED
tty->rawInBufSemaphoreOptions,
timeout);
if (sc != RTEMS_SUCCESSFUL)
108efc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108eff: 85 c0 test %eax,%eax <== NOT EXECUTED
108f01: 0f 84 dd fe ff ff je 108de4 <rtems_termios_read+0x11c><== NOT EXECUTED
108f07: e9 38 fe ff ff jmp 108d44 <rtems_termios_read+0x7c><== NOT EXECUTED
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
108f0c: 8b 86 94 00 00 00 mov 0x94(%esi),%eax <== NOT EXECUTED
108f12: 85 c0 test %eax,%eax <== NOT EXECUTED
108f14: 74 0e je 108f24 <rtems_termios_read+0x25c><== NOT EXECUTED
108f16: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
108f1c: a8 20 test $0x20,%al <== NOT EXECUTED
108f1e: 0f 84 5c ff ff ff je 108e80 <rtems_termios_read+0x1b8><== 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,
108f24: 53 push %ebx <== NOT EXECUTED
108f25: 6a 01 push $0x1 <== NOT EXECUTED
108f27: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED
108f2a: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
108f2d: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED
108f33: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108f36: e9 75 ff ff ff jmp 108eb0 <rtems_termios_read+0x1e8><== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
108f3b: f6 46 3c 02 testb $0x2,0x3c(%esi) <== NOT EXECUTED
108f3f: 0f 85 bf 00 00 00 jne 109004 <rtems_termios_read+0x33c><== NOT EXECUTED
}
}
}
else {
rtems_interval then, now;
if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
108f45: 80 7e 47 00 cmpb $0x0,0x47(%esi) <== NOT EXECUTED
108f49: 75 1d jne 108f68 <rtems_termios_read+0x2a0><== NOT EXECUTED
108f4b: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED
108f4f: 74 17 je 108f68 <rtems_termios_read+0x2a0><== NOT EXECUTED
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);
108f51: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
108f54: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED
108f57: 50 push %eax <== NOT EXECUTED
108f58: 6a 02 push $0x2 <== NOT EXECUTED
108f5a: e8 b1 0b 00 00 call 109b10 <rtems_clock_get> <== NOT EXECUTED
108f5f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108f62: 8b 86 a0 00 00 00 mov 0xa0(%esi),%eax <== 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);
108f68: 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);
108f6b: 8d 5d ec lea -0x14(%ebp),%ebx <== NOT EXECUTED
108f6e: 66 90 xchg %ax,%ax <== 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);
108f70: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108f73: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
108f76: ff d0 call *%eax <== NOT EXECUTED
if (n < 0) {
108f78: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108f7b: 85 c0 test %eax,%eax <== NOT EXECUTED
108f7d: 79 3f jns 108fbe <rtems_termios_read+0x2f6><== NOT EXECUTED
if (tty->termios.c_cc[VMIN]) {
108f7f: 80 7e 47 00 cmpb $0x0,0x47(%esi) <== NOT EXECUTED
108f83: 0f 84 9b 00 00 00 je 109024 <rtems_termios_read+0x35c><== NOT EXECUTED
if (tty->termios.c_cc[VTIME] && tty->ccount) {
108f89: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED
108f8d: 74 0d je 108f9c <rtems_termios_read+0x2d4><== NOT EXECUTED
108f8f: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED
108f92: 85 c0 test %eax,%eax <== NOT EXECUTED
108f94: 0f 85 94 00 00 00 jne 10902e <rtems_termios_read+0x366><== NOT EXECUTED
108f9a: 66 90 xchg %ax,%ax <== NOT EXECUTED
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now);
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
108f9c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108f9f: 6a 01 push $0x1 <== NOT EXECUTED
108fa1: e8 f6 18 00 00 call 10a89c <rtems_task_wake_after> <== NOT EXECUTED
108fa6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108fa9: 8b 86 a0 00 00 00 mov 0xa0(%esi),%eax <== 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);
108faf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108fb2: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
108fb5: ff d0 call *%eax <== NOT EXECUTED
if (n < 0) {
108fb7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108fba: 85 c0 test %eax,%eax <== NOT EXECUTED
108fbc: 78 c1 js 108f7f <rtems_termios_read+0x2b7><== NOT EXECUTED
}
}
rtems_task_wake_after (1);
}
else {
siproc (n, tty);
108fbe: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
108fc1: 89 f2 mov %esi,%edx <== NOT EXECUTED
108fc3: e8 68 fb ff ff call 108b30 <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
108fc8: 8a 56 47 mov 0x47(%esi),%dl <== NOT EXECUTED
108fcb: 0f b6 c2 movzbl %dl,%eax <== NOT EXECUTED
108fce: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED
108fd1: 0f 8d 6d fd ff ff jge 108d44 <rtems_termios_read+0x7c><== NOT EXECUTED
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
108fd7: 84 d2 test %dl,%dl <== NOT EXECUTED
108fd9: 74 06 je 108fe1 <rtems_termios_read+0x319><== NOT EXECUTED
108fdb: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED
108fdf: 75 6f jne 109050 <rtems_termios_read+0x388><== NOT EXECUTED
108fe1: 8b 86 a0 00 00 00 mov 0xa0(%esi),%eax <== NOT EXECUTED
108fe7: eb 87 jmp 108f70 <rtems_termios_read+0x2a8><== NOT EXECUTED
108fe9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
rtems_task_wake_after (1);
}
else {
if (siproc (n, tty))
108fec: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
108fef: 89 f2 mov %esi,%edx <== NOT EXECUTED
108ff1: e8 3a fb ff ff call 108b30 <siproc> <== NOT EXECUTED
108ff6: 85 c0 test %eax,%eax <== NOT EXECUTED
108ff8: 0f 85 46 fd ff ff jne 108d44 <rtems_termios_read+0x7c><== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
108ffe: 8b 96 a0 00 00 00 mov 0xa0(%esi),%edx <== NOT EXECUTED
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
109004: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109007: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
10900a: ff d2 call *%edx <== NOT EXECUTED
if (n < 0) {
10900c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10900f: 85 c0 test %eax,%eax <== NOT EXECUTED
109011: 79 d9 jns 108fec <rtems_termios_read+0x324><== NOT EXECUTED
rtems_task_wake_after (1);
109013: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109016: 6a 01 push $0x1 <== NOT EXECUTED
109018: e8 7f 18 00 00 call 10a89c <rtems_task_wake_after> <== NOT EXECUTED
10901d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109020: eb dc jmp 108ffe <rtems_termios_read+0x336><== NOT EXECUTED
109022: 66 90 xchg %ax,%ax <== NOT EXECUTED
break;
}
}
}
else {
if (!tty->termios.c_cc[VTIME])
109024: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED
109028: 0f 84 16 fd ff ff je 108d44 <rtems_termios_read+0x7c><== NOT EXECUTED
break;
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now);
10902e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
109031: 53 push %ebx <== NOT EXECUTED
109032: 6a 02 push $0x2 <== NOT EXECUTED
109034: e8 d7 0a 00 00 call 109b10 <rtems_clock_get> <== NOT EXECUTED
if ((now - then) > tty->vtimeTicks) {
109039: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
10903c: 2b 45 f0 sub -0x10(%ebp),%eax <== NOT EXECUTED
10903f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109042: 3b 46 54 cmp 0x54(%esi),%eax <== NOT EXECUTED
109045: 0f 86 51 ff ff ff jbe 108f9c <rtems_termios_read+0x2d4><== NOT EXECUTED
10904b: e9 f4 fc ff ff jmp 108d44 <rtems_termios_read+0x7c><== 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);
109050: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
109053: 57 push %edi <== NOT EXECUTED
109054: 6a 02 push $0x2 <== NOT EXECUTED
109056: e8 b5 0a 00 00 call 109b10 <rtems_clock_get> <== NOT EXECUTED
10905b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10905e: eb 81 jmp 108fe1 <rtems_termios_read+0x319><== NOT EXECUTED
00108014 <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)
{
108014: 55 push %ebp
108015: 89 e5 mov %esp,%ebp
108017: 57 push %edi
108018: 56 push %esi
108019: 53 push %ebx
10801a: 83 ec 0c sub $0xc,%esp
10801d: 8b 5d 08 mov 0x8(%ebp),%ebx
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
108020: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
108026: 25 03 04 00 00 and $0x403,%eax
10802b: 3d 01 04 00 00 cmp $0x401,%eax
108030: 0f 84 02 01 00 00 je 108138 <rtems_termios_refill_transmitter+0x124><== NEVER TAKEN
tty->flow_ctrl |= FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
}
else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF))
108036: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10803c: 83 e0 03 and $0x3,%eax
10803f: 83 f8 02 cmp $0x2,%eax
108042: 0f 84 84 01 00 00 je 1081cc <rtems_termios_refill_transmitter+0x1b8><== NEVER TAKEN
rtems_interrupt_enable(level);
nToSend = 1;
}
else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
108048: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx
10804e: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
108054: 39 c2 cmp %eax,%edx
108056: 0f 84 b4 00 00 00 je 108110 <rtems_termios_refill_transmitter+0xfc><== NEVER TAKEN
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
}
rtems_interrupt_disable(level);
10805c: 9c pushf
10805d: fa cli
10805e: 58 pop %eax
len = tty->t_dqlen;
10805f: 8b 8b 90 00 00 00 mov 0x90(%ebx),%ecx
tty->t_dqlen = 0;
108065: c7 83 90 00 00 00 00 movl $0x0,0x90(%ebx)
10806c: 00 00 00
rtems_interrupt_enable(level);
10806f: 50 push %eax
108070: 9d popf
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
108071: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx
108077: 8b b3 88 00 00 00 mov 0x88(%ebx),%esi
10807d: 01 d1 add %edx,%ecx
10807f: 89 c8 mov %ecx,%eax
108081: 31 d2 xor %edx,%edx
108083: f7 f6 div %esi
108085: 89 d7 mov %edx,%edi
tty->rawOutBuf.Tail = newTail;
108087: 89 93 84 00 00 00 mov %edx,0x84(%ebx)
if (tty->rawOutBufState == rob_wait) {
10808d: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx)
108094: 0f 84 6e 01 00 00 je 108208 <rtems_termios_refill_transmitter+0x1f4>
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
if (newTail == tty->rawOutBuf.Head) {
10809a: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
1080a0: 39 f8 cmp %edi,%eax
1080a2: 0f 84 cc 00 00 00 je 108174 <rtems_termios_refill_transmitter+0x160>
if ( tty->tty_snd.sw_pfn != NULL) {
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
1080a8: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1080ae: 25 10 02 00 00 and $0x210,%eax
1080b3: 3d 10 02 00 00 cmp $0x210,%eax
1080b8: 0f 84 e6 00 00 00 je 1081a4 <rtems_termios_refill_transmitter+0x190><== NEVER TAKEN
}
else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
1080be: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
1080c4: 39 c7 cmp %eax,%edi
1080c6: 77 64 ja 10812c <rtems_termios_refill_transmitter+0x118>
nToSend = tty->rawOutBuf.Size - newTail;
else
nToSend = tty->rawOutBuf.Head - newTail;
1080c8: 8b b3 80 00 00 00 mov 0x80(%ebx),%esi
1080ce: 29 fe sub %edi,%esi
/* 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)) {
1080d0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1080d6: f6 c4 06 test $0x6,%ah
1080d9: 74 05 je 1080e0 <rtems_termios_refill_transmitter+0xcc><== ALWAYS TAKEN
1080db: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
1080e0: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx)
1080e7: 00 00 00
(*tty->device.write)(tty->minor,
1080ea: 50 push %eax
1080eb: 56 push %esi
1080ec: 8b 43 7c mov 0x7c(%ebx),%eax
1080ef: 01 f8 add %edi,%eax
1080f1: 50 push %eax
1080f2: ff 73 10 pushl 0x10(%ebx)
1080f5: ff 93 a4 00 00 00 call *0xa4(%ebx)
1080fb: 83 c4 10 add $0x10,%esp
&tty->rawOutBuf.theBuf[newTail],
nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
1080fe: 89 bb 84 00 00 00 mov %edi,0x84(%ebx)
}
return nToSend;
}
108104: 89 f0 mov %esi,%eax
108106: 8d 65 f4 lea -0xc(%ebp),%esp
108109: 5b pop %ebx
10810a: 5e pop %esi
10810b: 5f pop %edi
10810c: c9 leave
10810d: c3 ret
10810e: 66 90 xchg %ax,%ax
else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
108110: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx) <== NOT EXECUTED
108117: 0f 84 03 01 00 00 je 108220 <rtems_termios_refill_transmitter+0x20c><== NOT EXECUTED
10811d: 31 f6 xor %esi,%esi <== NOT EXECUTED
nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
10811f: 89 f0 mov %esi,%eax <== NOT EXECUTED
108121: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
108124: 5b pop %ebx <== NOT EXECUTED
108125: 5e pop %esi <== NOT EXECUTED
108126: 5f pop %edi <== NOT EXECUTED
108127: c9 leave <== NOT EXECUTED
108128: c3 ret <== NOT EXECUTED
108129: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
10812c: 8b b3 88 00 00 00 mov 0x88(%ebx),%esi
108132: 29 fe sub %edi,%esi
108134: eb 9a jmp 1080d0 <rtems_termios_refill_transmitter+0xbc>
108136: 66 90 xchg %ax,%ax
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor,
108138: 51 push %ecx <== NOT EXECUTED
108139: 6a 01 push $0x1 <== NOT EXECUTED
10813b: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED
10813e: 50 push %eax <== NOT EXECUTED
10813f: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
108142: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
108148: 9c pushf <== NOT EXECUTED
108149: fa cli <== NOT EXECUTED
10814a: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
10814b: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
108151: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108157: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
10815a: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
rtems_interrupt_enable(level);
108160: 52 push %edx <== NOT EXECUTED
108161: 9d popf <== NOT EXECUTED
108162: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED
108167: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
10816a: 89 f0 mov %esi,%eax <== NOT EXECUTED
10816c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10816f: 5b pop %ebx <== NOT EXECUTED
108170: 5e pop %esi <== NOT EXECUTED
108171: 5f pop %edi <== NOT EXECUTED
108172: c9 leave <== NOT EXECUTED
108173: c3 ret <== NOT EXECUTED
}
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
108174: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx)
10817b: 00 00 00
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
10817e: 8b 93 d4 00 00 00 mov 0xd4(%ebx),%edx
108184: 85 d2 test %edx,%edx
108186: 74 3a je 1081c2 <rtems_termios_refill_transmitter+0x1ae><== ALWAYS TAKEN
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
108188: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10818b: ff b3 d8 00 00 00 pushl 0xd8(%ebx) <== NOT EXECUTED
108191: 8d 43 30 lea 0x30(%ebx),%eax <== NOT EXECUTED
108194: 50 push %eax <== NOT EXECUTED
108195: ff d2 call *%edx <== NOT EXECUTED
108197: 31 f6 xor %esi,%esi <== NOT EXECUTED
108199: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10819c: e9 5d ff ff ff jmp 1080fe <rtems_termios_refill_transmitter+0xea><== NOT EXECUTED
1081a1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
1081a4: 9c pushf <== NOT EXECUTED
1081a5: fa cli <== NOT EXECUTED
1081a6: 5a pop %edx <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
1081a7: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1081ad: 83 c8 20 or $0x20,%eax <== NOT EXECUTED
1081b0: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
1081b6: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED
1081bd: 00 00 00
rtems_interrupt_enable(level);
1081c0: 52 push %edx <== NOT EXECUTED
1081c1: 9d popf <== NOT EXECUTED
1081c2: 31 f6 xor %esi,%esi
1081c4: e9 35 ff ff ff jmp 1080fe <rtems_termios_refill_transmitter+0xea>
1081c9: 8d 76 00 lea 0x0(%esi),%esi
* 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,
1081cc: 52 push %edx <== NOT EXECUTED
1081cd: 6a 01 push $0x1 <== NOT EXECUTED
1081cf: 8d 43 49 lea 0x49(%ebx),%eax <== NOT EXECUTED
1081d2: 50 push %eax <== NOT EXECUTED
1081d3: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
1081d6: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
1081dc: 9c pushf <== NOT EXECUTED
1081dd: fa cli <== NOT EXECUTED
1081de: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
1081df: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
1081e5: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1081eb: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED
1081ee: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
rtems_interrupt_enable(level);
1081f4: 52 push %edx <== NOT EXECUTED
1081f5: 9d popf <== NOT EXECUTED
1081f6: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED
1081fb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
1081fe: 89 f0 mov %esi,%eax <== NOT EXECUTED
108200: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
108203: 5b pop %ebx <== NOT EXECUTED
108204: 5e pop %esi <== NOT EXECUTED
108205: 5f pop %edi <== NOT EXECUTED
108206: c9 leave <== NOT EXECUTED
108207: c3 ret <== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
108208: 83 ec 0c sub $0xc,%esp
10820b: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
108211: e8 d2 22 00 00 call 10a4e8 <rtems_semaphore_release>
108216: 83 c4 10 add $0x10,%esp
108219: e9 7c fe ff ff jmp 10809a <rtems_termios_refill_transmitter+0x86>
10821e: 66 90 xchg %ax,%ax
*/
if (tty->rawOutBufState == rob_wait) {
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
108220: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108223: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED
108229: e8 ba 22 00 00 call 10a4e8 <rtems_semaphore_release><== NOT EXECUTED
10822e: 31 f6 xor %esi,%esi <== NOT EXECUTED
108230: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108233: e9 e7 fe ff ff jmp 10811f <rtems_termios_refill_transmitter+0x10b><== NOT EXECUTED
00109aa4 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
109aa4: 55 push %ebp <== NOT EXECUTED
109aa5: 89 e5 mov %esp,%ebp <== NOT EXECUTED
109aa7: 57 push %edi <== NOT EXECUTED
109aa8: 56 push %esi <== NOT EXECUTED
109aa9: 53 push %ebx <== NOT EXECUTED
109aaa: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED
109aad: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
109ab0: 8d 75 ec lea -0x14(%ebp),%esi <== NOT EXECUTED
109ab3: 8d 7d f3 lea -0xd(%ebp),%edi <== NOT EXECUTED
109ab6: 66 90 xchg %ax,%ax <== NOT EXECUTED
char c_buf;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_RX_PROC_EVENT |
109ab8: 56 push %esi <== NOT EXECUTED
109ab9: 6a 00 push $0x0 <== NOT EXECUTED
109abb: 6a 02 push $0x2 <== NOT EXECUTED
109abd: 6a 03 push $0x3 <== NOT EXECUTED
109abf: e8 74 02 00 00 call 109d38 <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) {
109ac4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109ac7: f6 45 ec 01 testb $0x1,-0x14(%ebp) <== NOT EXECUTED
109acb: 75 27 jne 109af4 <rtems_termios_rxdaemon+0x50><== NOT EXECUTED
}
else {
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
109acd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109ad0: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109ad3: ff 93 a0 00 00 00 call *0xa0(%ebx) <== NOT EXECUTED
if (c != EOF) {
109ad9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109adc: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED
109adf: 74 d7 je 109ab8 <rtems_termios_rxdaemon+0x14><== NOT EXECUTED
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
109ae1: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED
rtems_termios_enqueue_raw_characters (
109ae4: 50 push %eax <== NOT EXECUTED
109ae5: 6a 01 push $0x1 <== NOT EXECUTED
109ae7: 57 push %edi <== NOT EXECUTED
109ae8: 53 push %ebx <== NOT EXECUTED
109ae9: e8 b2 e7 ff ff call 1082a0 <rtems_termios_enqueue_raw_characters><== NOT EXECUTED
109aee: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109af1: eb c5 jmp 109ab8 <rtems_termios_rxdaemon+0x14><== NOT EXECUTED
109af3: 90 nop <== NOT EXECUTED
TERMIOS_RX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
tty->rxTaskId = 0;
109af4: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) <== NOT EXECUTED
109afb: 00 00 00
rtems_task_delete(RTEMS_SELF);
109afe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109b01: 6a 00 push $0x0 <== NOT EXECUTED
109b03: e8 d4 0b 00 00 call 10a6dc <rtems_task_delete> <== NOT EXECUTED
109b08: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109b0b: eb ab jmp 109ab8 <rtems_termios_rxdaemon+0x14><== NOT EXECUTED
00107ff8 <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)
{
107ff8: 55 push %ebp <== NOT EXECUTED
107ff9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107ffb: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
/*
* send event to rx daemon task
*/
rtems_event_send(tty->rxTaskId,TERMIOS_RX_PROC_EVENT);
107ffe: 6a 02 push $0x2 <== NOT EXECUTED
108000: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
108003: ff b0 c4 00 00 00 pushl 0xc4(%eax) <== NOT EXECUTED
108009: e8 be 1e 00 00 call 109ecc <rtems_event_send> <== NOT EXECUTED
10800e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
108011: c9 leave <== NOT EXECUTED
108012: c3 ret <== NOT EXECUTED
00109a38 <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
109a38: 55 push %ebp <== NOT EXECUTED
109a39: 89 e5 mov %esp,%ebp <== NOT EXECUTED
109a3b: 56 push %esi <== NOT EXECUTED
109a3c: 53 push %ebx <== NOT EXECUTED
109a3d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
109a40: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
109a43: 8d 75 f4 lea -0xc(%ebp),%esi <== NOT EXECUTED
109a46: 66 90 xchg %ax,%ax <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_TX_START_EVENT |
109a48: 56 push %esi <== NOT EXECUTED
109a49: 6a 00 push $0x0 <== NOT EXECUTED
109a4b: 6a 02 push $0x2 <== NOT EXECUTED
109a4d: 6a 03 push $0x3 <== NOT EXECUTED
109a4f: e8 e4 02 00 00 call 109d38 <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) {
109a54: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109a57: f6 45 f4 01 testb $0x1,-0xc(%ebp) <== NOT EXECUTED
109a5b: 75 2b jne 109a88 <rtems_termios_txdaemon+0x50><== NOT EXECUTED
}
else {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
109a5d: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED
109a63: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
109a66: 8b 80 d4 e2 11 00 mov 0x11e2d4(%eax),%eax <== NOT EXECUTED
109a6c: 85 c0 test %eax,%eax <== NOT EXECUTED
109a6e: 74 09 je 109a79 <rtems_termios_txdaemon+0x41><== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
109a70: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109a73: 53 push %ebx <== NOT EXECUTED
109a74: ff d0 call *%eax <== NOT EXECUTED
109a76: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
109a79: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109a7c: 53 push %ebx <== NOT EXECUTED
109a7d: e8 92 e5 ff ff call 108014 <rtems_termios_refill_transmitter><== NOT EXECUTED
109a82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109a85: eb c1 jmp 109a48 <rtems_termios_txdaemon+0x10><== NOT EXECUTED
109a87: 90 nop <== NOT EXECUTED
TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
tty->txTaskId = 0;
109a88: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED
109a8f: 00 00 00
rtems_task_delete(RTEMS_SELF);
109a92: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109a95: 6a 00 push $0x0 <== NOT EXECUTED
109a97: e8 40 0c 00 00 call 10a6dc <rtems_task_delete> <== NOT EXECUTED
109a9c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109a9f: eb a7 jmp 109a48 <rtems_termios_txdaemon+0x10><== NOT EXECUTED
00108b80 <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
108b80: 55 push %ebp
108b81: 89 e5 mov %esp,%ebp
108b83: 57 push %edi
108b84: 56 push %esi
108b85: 53 push %ebx
108b86: 83 ec 10 sub $0x10,%esp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
108b89: 8b 55 08 mov 0x8(%ebp),%edx
108b8c: 8b 02 mov (%edx),%eax
108b8e: 8b 70 28 mov 0x28(%eax),%esi
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
108b91: 6a 00 push $0x0
108b93: 6a 00 push $0x0
108b95: ff 76 18 pushl 0x18(%esi)
108b98: e8 53 18 00 00 call 10a3f0 <rtems_semaphore_obtain>
108b9d: 89 c7 mov %eax,%edi
if (sc != RTEMS_SUCCESSFUL)
108b9f: 83 c4 10 add $0x10,%esp
108ba2: 85 c0 test %eax,%eax
108ba4: 75 2a jne 108bd0 <rtems_termios_write+0x50><== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
108ba6: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax
108bac: c1 e0 05 shl $0x5,%eax
108baf: 8b 80 cc e2 11 00 mov 0x11e2cc(%eax),%eax
108bb5: 85 c0 test %eax,%eax
108bb7: 74 23 je 108bdc <rtems_termios_write+0x5c><== ALWAYS TAKEN
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
108bb9: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
108bbc: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
108bbf: 56 push %esi <== NOT EXECUTED
108bc0: ff d0 call *%eax <== NOT EXECUTED
108bc2: 89 c7 mov %eax,%edi <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
108bc4: 58 pop %eax <== NOT EXECUTED
108bc5: ff 76 18 pushl 0x18(%esi) <== NOT EXECUTED
108bc8: e8 1b 19 00 00 call 10a4e8 <rtems_semaphore_release><== NOT EXECUTED
108bcd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
}
rtems_semaphore_release (tty->osem);
return sc;
}
108bd0: 89 f8 mov %edi,%eax <== NOT EXECUTED
108bd2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
108bd5: 5b pop %ebx <== NOT EXECUTED
108bd6: 5e pop %esi <== NOT EXECUTED
108bd7: 5f pop %edi <== NOT EXECUTED
108bd8: c9 leave <== NOT EXECUTED
108bd9: c3 ret <== NOT EXECUTED
108bda: 66 90 xchg %ax,%ax <== NOT EXECUTED
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
108bdc: f6 46 34 01 testb $0x1,0x34(%esi)
108be0: 74 52 je 108c34 <rtems_termios_write+0xb4><== NEVER TAKEN
uint32_t count = args->count;
108be2: 8b 45 08 mov 0x8(%ebp),%eax
108be5: 8b 40 0c mov 0xc(%eax),%eax
108be8: 89 45 ec mov %eax,-0x14(%ebp)
char *buffer = args->buffer;
108beb: 8b 55 08 mov 0x8(%ebp),%edx
108bee: 8b 52 08 mov 0x8(%edx),%edx
108bf1: 89 55 f0 mov %edx,-0x10(%ebp)
while (count--)
108bf4: 85 c0 test %eax,%eax
108bf6: 74 1e je 108c16 <rtems_termios_write+0x96><== NEVER TAKEN
108bf8: 31 db xor %ebx,%ebx
108bfa: 66 90 xchg %ax,%ax
oproc (*buffer++, tty);
108bfc: 8b 55 f0 mov -0x10(%ebp),%edx
108bff: 0f b6 04 1a movzbl (%edx,%ebx,1),%eax
108c03: 89 f2 mov %esi,%edx
108c05: e8 b6 fa ff ff call 1086c0 <oproc>
108c0a: 43 inc %ebx
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
108c0b: 39 5d ec cmp %ebx,-0x14(%ebp)
108c0e: 75 ec jne 108bfc <rtems_termios_write+0x7c>
108c10: 8b 55 08 mov 0x8(%ebp),%edx
108c13: 8b 42 0c mov 0xc(%edx),%eax
oproc (*buffer++, tty);
args->bytes_moved = args->count;
108c16: 8b 55 08 mov 0x8(%ebp),%edx
108c19: 89 42 14 mov %eax,0x14(%edx)
}
else {
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
}
rtems_semaphore_release (tty->osem);
108c1c: 83 ec 0c sub $0xc,%esp
108c1f: ff 76 18 pushl 0x18(%esi)
108c22: e8 c1 18 00 00 call 10a4e8 <rtems_semaphore_release>
108c27: 83 c4 10 add $0x10,%esp
return sc;
}
108c2a: 89 f8 mov %edi,%eax
108c2c: 8d 65 f4 lea -0xc(%ebp),%esp
108c2f: 5b pop %ebx
108c30: 5e pop %esi
108c31: 5f pop %edi
108c32: c9 leave
108c33: c3 ret
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
}
else {
rtems_termios_puts (args->buffer, args->count, tty);
108c34: 50 push %eax <== NOT EXECUTED
108c35: 56 push %esi <== NOT EXECUTED
108c36: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
108c39: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
108c3c: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
108c3f: e8 4c f9 ff ff call 108590 <rtems_termios_puts> <== NOT EXECUTED
args->bytes_moved = args->count;
108c44: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
108c47: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED
108c4a: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED
108c4d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108c50: eb ca jmp 108c1c <rtems_termios_write+0x9c><== NOT EXECUTED
00114448 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
Objects_Id id
)
{
114448: 55 push %ebp
114449: 89 e5 mov %esp,%ebp
11444b: 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
11444e: 8d 45 fc lea -0x4(%ebp),%eax
114451: 50 push %eax
114452: ff 75 08 pushl 0x8(%ebp)
114455: 68 a0 5d 13 00 push $0x135da0
11445a: e8 81 27 00 00 call 116be0 <_Objects_Get>
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
11445f: 83 c4 10 add $0x10,%esp
114462: 8b 55 fc mov -0x4(%ebp),%edx
114465: 85 d2 test %edx,%edx
114467: 74 07 je 114470 <rtems_timer_cancel+0x28>
114469: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11446e: c9 leave
11446f: c3 ret
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
114470: 83 78 38 04 cmpl $0x4,0x38(%eax)
114474: 74 0f je 114485 <rtems_timer_cancel+0x3d><== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
114476: 83 ec 0c sub $0xc,%esp
114479: 83 c0 10 add $0x10,%eax
11447c: 50 push %eax
11447d: e8 9a 43 00 00 call 11881c <_Watchdog_Remove>
114482: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
114485: e8 9a 2f 00 00 call 117424 <_Thread_Enable_dispatch>
11448a: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11448c: c9 leave
11448d: c3 ret
00114490 <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
Objects_Id *id
)
{
114490: 55 push %ebp
114491: 89 e5 mov %esp,%ebp
114493: 57 push %edi
114494: 56 push %esi
114495: 53 push %ebx
114496: 83 ec 0c sub $0xc,%esp
114499: 8b 75 08 mov 0x8(%ebp),%esi
11449c: 8b 7d 0c mov 0xc(%ebp),%edi
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
11449f: 85 f6 test %esi,%esi
1144a1: 74 71 je 114514 <rtems_timer_create+0x84>
return RTEMS_INVALID_NAME;
if ( !id )
1144a3: 85 ff test %edi,%edi
1144a5: 0f 84 8d 00 00 00 je 114538 <rtems_timer_create+0xa8><== NEVER TAKEN
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
1144ab: a1 38 5a 13 00 mov 0x135a38,%eax
1144b0: 40 inc %eax
1144b1: a3 38 5a 13 00 mov %eax,0x135a38
#ifdef __cplusplus
extern "C" {
#endif
/**
1144b6: 83 ec 0c sub $0xc,%esp
1144b9: 68 a0 5d 13 00 push $0x135da0
1144be: e8 e9 21 00 00 call 1166ac <_Objects_Allocate>
1144c3: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
1144c5: 83 c4 10 add $0x10,%esp
1144c8: 85 c0 test %eax,%eax
1144ca: 74 58 je 114524 <rtems_timer_create+0x94>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_timer->the_class = TIMER_DORMANT;
1144cc: 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.
*
1144d3: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
* @param[in] the_heap is the heap to operate upon
1144da: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
* @param[in] starting_address is the starting address of the memory for
1144e1: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
* the heap
1144e8: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
1144ef: 8b 48 08 mov 0x8(%eax),%ecx
1144f2: 0f b7 d1 movzwl %cx,%edx
1144f5: a1 bc 5d 13 00 mov 0x135dbc,%eax
1144fa: 89 1c 90 mov %ebx,(%eax,%edx,4)
1144fd: 89 73 0c mov %esi,0xc(%ebx)
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
114500: 89 0f mov %ecx,(%edi)
_Thread_Enable_dispatch();
114502: e8 1d 2f 00 00 call 117424 <_Thread_Enable_dispatch>
114507: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
114509: 8d 65 f4 lea -0xc(%ebp),%esp
11450c: 5b pop %ebx
11450d: 5e pop %esi
11450e: 5f pop %edi
11450f: c9 leave
114510: c3 ret
114511: 8d 76 00 lea 0x0(%esi),%esi
Objects_Id *id
)
{
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
114514: b8 03 00 00 00 mov $0x3,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
114519: 8d 65 f4 lea -0xc(%ebp),%esp
11451c: 5b pop %ebx
11451d: 5e pop %esi
11451e: 5f pop %edi
11451f: c9 leave
114520: c3 ret
114521: 8d 76 00 lea 0x0(%esi),%esi
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
_Thread_Enable_dispatch();
114524: e8 fb 2e 00 00 call 117424 <_Thread_Enable_dispatch>
114529: b8 05 00 00 00 mov $0x5,%eax
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
11452e: 8d 65 f4 lea -0xc(%ebp),%esp
114531: 5b pop %ebx
114532: 5e pop %esi
114533: 5f pop %edi
114534: c9 leave
114535: c3 ret
114536: 66 90 xchg %ax,%ax
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
114538: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
11453d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
114540: 5b pop %ebx <== NOT EXECUTED
114541: 5e pop %esi <== NOT EXECUTED
114542: 5f pop %edi <== NOT EXECUTED
114543: c9 leave <== NOT EXECUTED
114544: c3 ret <== NOT EXECUTED
00114548 <rtems_timer_delete>:
*/
rtems_status_code rtems_timer_delete(
Objects_Id id
)
{
114548: 55 push %ebp
114549: 89 e5 mov %esp,%ebp
11454b: 53 push %ebx
11454c: 83 ec 18 sub $0x18,%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
11454f: 8d 45 f8 lea -0x8(%ebp),%eax
114552: 50 push %eax
114553: ff 75 08 pushl 0x8(%ebp)
114556: 68 a0 5d 13 00 push $0x135da0
11455b: e8 80 26 00 00 call 116be0 <_Objects_Get>
114560: 89 c3 mov %eax,%ebx
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
114562: 83 c4 10 add $0x10,%esp
114565: 8b 4d f8 mov -0x8(%ebp),%ecx
114568: 85 c9 test %ecx,%ecx
11456a: 75 38 jne 1145a4 <rtems_timer_delete+0x5c>
case OBJECTS_LOCAL:
_Objects_Close( &_Timer_Information, &the_timer->Object );
11456c: 83 ec 08 sub $0x8,%esp
11456f: 50 push %eax
114570: 68 a0 5d 13 00 push $0x135da0
114575: e8 b2 21 00 00 call 11672c <_Objects_Close>
(void) _Watchdog_Remove( &the_timer->Ticker );
11457a: 8d 43 10 lea 0x10(%ebx),%eax
11457d: 89 04 24 mov %eax,(%esp)
114580: e8 97 42 00 00 call 11881c <_Watchdog_Remove>
* @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
114585: 58 pop %eax
114586: 5a pop %edx
114587: 53 push %ebx
114588: 68 a0 5d 13 00 push $0x135da0
11458d: e8 da 24 00 00 call 116a6c <_Objects_Free>
_Timer_Free( the_timer );
_Thread_Enable_dispatch();
114592: e8 8d 2e 00 00 call 117424 <_Thread_Enable_dispatch>
114597: 31 c0 xor %eax,%eax
114599: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11459c: 8b 5d fc mov -0x4(%ebp),%ebx
11459f: c9 leave
1145a0: c3 ret
1145a1: 8d 76 00 lea 0x0(%esi),%esi
{
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
1145a4: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1145a9: 8b 5d fc mov -0x4(%ebp),%ebx
1145ac: c9 leave
1145ad: c3 ret
001145b0 <rtems_timer_fire_after>:
Objects_Id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
1145b0: 55 push %ebp
1145b1: 89 e5 mov %esp,%ebp
1145b3: 57 push %edi
1145b4: 56 push %esi
1145b5: 53 push %ebx
1145b6: 83 ec 1c sub $0x1c,%esp
1145b9: 8b 75 0c mov 0xc(%ebp),%esi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
1145bc: 85 f6 test %esi,%esi
1145be: 0f 84 98 00 00 00 je 11465c <rtems_timer_fire_after+0xac>
return RTEMS_INVALID_NUMBER;
if ( !routine )
1145c4: 8b 7d 10 mov 0x10(%ebp),%edi
1145c7: 85 ff test %edi,%edi
1145c9: 0f 84 9d 00 00 00 je 11466c <rtems_timer_fire_after+0xbc><== 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
1145cf: 53 push %ebx
1145d0: 8d 45 f0 lea -0x10(%ebp),%eax
1145d3: 50 push %eax
1145d4: ff 75 08 pushl 0x8(%ebp)
1145d7: 68 a0 5d 13 00 push $0x135da0
1145dc: e8 ff 25 00 00 call 116be0 <_Objects_Get>
1145e1: 89 c3 mov %eax,%ebx
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
1145e3: 83 c4 10 add $0x10,%esp
1145e6: 8b 4d f0 mov -0x10(%ebp),%ecx
1145e9: 85 c9 test %ecx,%ecx
1145eb: 75 5f jne 11464c <rtems_timer_fire_after+0x9c>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
1145ed: 8d 78 10 lea 0x10(%eax),%edi
1145f0: 83 ec 0c sub $0xc,%esp
1145f3: 57 push %edi
1145f4: e8 23 42 00 00 call 11881c <_Watchdog_Remove>
_ISR_Disable( level );
1145f9: 9c pushf
1145fa: fa cli
1145fb: 58 pop %eax
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
1145fc: 83 c4 10 add $0x10,%esp
1145ff: 8b 53 18 mov 0x18(%ebx),%edx
114602: 85 d2 test %edx,%edx
114604: 75 76 jne 11467c <rtems_timer_fire_after+0xcc><== NEVER TAKEN
/*
* 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;
114606: 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.
*
11460d: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
* @param[in] the_heap is the heap to operate upon
114614: 8b 55 10 mov 0x10(%ebp),%edx
114617: 89 53 2c mov %edx,0x2c(%ebx)
* @param[in] starting_address is the starting address of the memory for
11461a: 8b 55 08 mov 0x8(%ebp),%edx
11461d: 89 53 30 mov %edx,0x30(%ebx)
* the heap
114620: 8b 55 14 mov 0x14(%ebp),%edx
114623: 89 53 34 mov %edx,0x34(%ebx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_ISR_Enable( level );
114626: 50 push %eax
114627: 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,
114628: 89 73 1c mov %esi,0x1c(%ebx)
void *starting_address,
size_t *size
11462b: 83 ec 08 sub $0x8,%esp
11462e: 57 push %edi
11462f: 68 1c 5b 13 00 push $0x135b1c
114634: e8 b3 40 00 00 call 1186ec <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
_Thread_Enable_dispatch();
114639: e8 e6 2d 00 00 call 117424 <_Thread_Enable_dispatch>
11463e: 31 c0 xor %eax,%eax
114640: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
114643: 8d 65 f4 lea -0xc(%ebp),%esp
114646: 5b pop %ebx
114647: 5e pop %esi
114648: 5f pop %edi
114649: c9 leave
11464a: c3 ret
11464b: 90 nop
if ( !routine )
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
11464c: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
114651: 8d 65 f4 lea -0xc(%ebp),%esp
114654: 5b pop %ebx
114655: 5e pop %esi
114656: 5f pop %edi
114657: c9 leave
114658: c3 ret
114659: 8d 76 00 lea 0x0(%esi),%esi
{
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
11465c: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
114661: 8d 65 f4 lea -0xc(%ebp),%esp
114664: 5b pop %ebx
114665: 5e pop %esi
114666: 5f pop %edi
114667: c9 leave
114668: c3 ret
114669: 8d 76 00 lea 0x0(%esi),%esi
ISR_Level level;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
if ( !routine )
11466c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
114671: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
114674: 5b pop %ebx <== NOT EXECUTED
114675: 5e pop %esi <== NOT EXECUTED
114676: 5f pop %edi <== NOT EXECUTED
114677: c9 leave <== NOT EXECUTED
114678: c3 ret <== NOT EXECUTED
114679: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
11467c: 50 push %eax <== NOT EXECUTED
11467d: 9d popf <== NOT EXECUTED
_Thread_Enable_dispatch();
11467e: e8 a1 2d 00 00 call 117424 <_Thread_Enable_dispatch><== NOT EXECUTED
114683: 31 c0 xor %eax,%eax <== NOT EXECUTED
114685: eb ca jmp 114651 <rtems_timer_fire_after+0xa1><== NOT EXECUTED
00114688 <rtems_timer_fire_when>:
Objects_Id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
114688: 55 push %ebp
114689: 89 e5 mov %esp,%ebp
11468b: 57 push %edi
11468c: 56 push %esi
11468d: 53 push %ebx
11468e: 83 ec 1c sub $0x1c,%esp
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
114691: 80 3d 4c 5a 13 00 00 cmpb $0x0,0x135a4c
114698: 75 0e jne 1146a8 <rtems_timer_fire_when+0x20>
11469a: b8 0b 00 00 00 mov $0xb,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11469f: 8d 65 f4 lea -0xc(%ebp),%esp
1146a2: 5b pop %ebx
1146a3: 5e pop %esi
1146a4: 5f pop %edi
1146a5: c9 leave
1146a6: c3 ret
1146a7: 90 nop
rtems_interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
1146a8: 83 ec 0c sub $0xc,%esp
1146ab: ff 75 0c pushl 0xc(%ebp)
1146ae: e8 d1 d6 ff ff call 111d84 <_TOD_Validate>
1146b3: 83 c4 10 add $0x10,%esp
1146b6: 84 c0 test %al,%al
1146b8: 74 23 je 1146dd <rtems_timer_fire_when+0x55>
return RTEMS_INVALID_CLOCK;
if ( !routine )
1146ba: 8b 75 10 mov 0x10(%ebp),%esi
1146bd: 85 f6 test %esi,%esi
1146bf: 0f 84 a3 00 00 00 je 114768 <rtems_timer_fire_when+0xe0><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
1146c5: 83 ec 0c sub $0xc,%esp
1146c8: ff 75 0c pushl 0xc(%ebp)
1146cb: e8 24 d6 ff ff call 111cf4 <_TOD_To_seconds>
1146d0: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch )
1146d2: 83 c4 10 add $0x10,%esp
1146d5: 3b 05 cc 5a 13 00 cmp 0x135acc,%eax
1146db: 77 0f ja 1146ec <rtems_timer_fire_when+0x64>
_Watchdog_Insert_seconds(
&the_timer->Ticker,
seconds - _TOD_Seconds_since_epoch
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
1146dd: b8 14 00 00 00 mov $0x14,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1146e2: 8d 65 f4 lea -0xc(%ebp),%esp
1146e5: 5b pop %ebx
1146e6: 5e pop %esi
1146e7: 5f pop %edi
1146e8: c9 leave
1146e9: c3 ret
1146ea: 66 90 xchg %ax,%ax
/**
* 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
1146ec: 53 push %ebx
1146ed: 8d 45 f0 lea -0x10(%ebp),%eax
1146f0: 50 push %eax
1146f1: ff 75 08 pushl 0x8(%ebp)
1146f4: 68 a0 5d 13 00 push $0x135da0
1146f9: e8 e2 24 00 00 call 116be0 <_Objects_Get>
1146fe: 89 c6 mov %eax,%esi
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch )
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
114700: 83 c4 10 add $0x10,%esp
114703: 8b 4d f0 mov -0x10(%ebp),%ecx
114706: 85 c9 test %ecx,%ecx
114708: 75 52 jne 11475c <rtems_timer_fire_when+0xd4>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
11470a: 8d 58 10 lea 0x10(%eax),%ebx
11470d: 83 ec 0c sub $0xc,%esp
114710: 53 push %ebx
114711: e8 06 41 00 00 call 11881c <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY;
114716: 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.
*
11471d: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi)
* @param[in] the_heap is the heap to operate upon
114724: 8b 45 10 mov 0x10(%ebp),%eax
114727: 89 46 2c mov %eax,0x2c(%esi)
* @param[in] starting_address is the starting address of the memory for
11472a: 8b 45 08 mov 0x8(%ebp),%eax
11472d: 89 46 30 mov %eax,0x30(%esi)
* the heap
114730: 8b 45 14 mov 0x14(%ebp),%eax
114733: 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,
114736: 2b 3d cc 5a 13 00 sub 0x135acc,%edi
11473c: 89 7e 1c mov %edi,0x1c(%esi)
size_t size
);
11473f: 58 pop %eax
114740: 5a pop %edx
114741: 53 push %ebx
114742: 68 10 5b 13 00 push $0x135b10
114747: e8 a0 3f 00 00 call 1186ec <_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();
11474c: e8 d3 2c 00 00 call 117424 <_Thread_Enable_dispatch>
114751: 31 c0 xor %eax,%eax
114753: 83 c4 10 add $0x10,%esp
114756: e9 44 ff ff ff jmp 11469f <rtems_timer_fire_when+0x17>
11475b: 90 nop
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch )
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
11475c: b8 04 00 00 00 mov $0x4,%eax
114761: e9 39 ff ff ff jmp 11469f <rtems_timer_fire_when+0x17>
114766: 66 90 xchg %ax,%ax
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
if ( !routine )
114768: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
11476d: e9 2d ff ff ff jmp 11469f <rtems_timer_fire_when+0x17><== NOT EXECUTED
00114774 <rtems_timer_get_information>:
rtems_status_code rtems_timer_get_information(
Objects_Id id,
rtems_timer_information *the_info
)
{
114774: 55 push %ebp
114775: 89 e5 mov %esp,%ebp
114777: 53 push %ebx
114778: 83 ec 14 sub $0x14,%esp
11477b: 8b 5d 0c mov 0xc(%ebp),%ebx
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
11477e: 85 db test %ebx,%ebx
114780: 74 4e je 1147d0 <rtems_timer_get_information+0x5c><== 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
114782: 52 push %edx
114783: 8d 45 f8 lea -0x8(%ebp),%eax
114786: 50 push %eax
114787: ff 75 08 pushl 0x8(%ebp)
11478a: 68 a0 5d 13 00 push $0x135da0
11478f: e8 4c 24 00 00 call 116be0 <_Objects_Get>
114794: 89 c2 mov %eax,%edx
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
114796: 83 c4 10 add $0x10,%esp
114799: 8b 45 f8 mov -0x8(%ebp),%eax
11479c: 85 c0 test %eax,%eax
11479e: 74 0c je 1147ac <rtems_timer_get_information+0x38>
1147a0: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1147a5: 8b 5d fc mov -0x4(%ebp),%ebx
1147a8: c9 leave
1147a9: c3 ret
1147aa: 66 90 xchg %ax,%ax
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_info->the_class = the_timer->the_class;
1147ac: 8b 42 38 mov 0x38(%edx),%eax
1147af: 89 03 mov %eax,(%ebx)
the_info->initial = the_timer->Ticker.initial;
1147b1: 8b 42 1c mov 0x1c(%edx),%eax
1147b4: 89 43 04 mov %eax,0x4(%ebx)
the_info->start_time = the_timer->Ticker.start_time;
1147b7: 8b 42 24 mov 0x24(%edx),%eax
1147ba: 89 43 08 mov %eax,0x8(%ebx)
the_info->stop_time = the_timer->Ticker.stop_time;
1147bd: 8b 42 28 mov 0x28(%edx),%eax
1147c0: 89 43 0c mov %eax,0xc(%ebx)
_Thread_Enable_dispatch();
1147c3: e8 5c 2c 00 00 call 117424 <_Thread_Enable_dispatch>
1147c8: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1147ca: 8b 5d fc mov -0x4(%ebp),%ebx
1147cd: c9 leave
1147ce: c3 ret
1147cf: 90 nop
)
{
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
1147d0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1147d5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
1147d8: c9 leave <== NOT EXECUTED
1147d9: c3 ret <== NOT EXECUTED
00114a84 <rtems_timer_initiate_server>:
rtems_status_code rtems_timer_initiate_server(
uint32_t priority,
uint32_t stack_size,
rtems_attribute attribute_set
)
{
114a84: 55 push %ebp
114a85: 89 e5 mov %esp,%ebp
114a87: 56 push %esi
114a88: 53 push %ebx
114a89: 83 ec 10 sub $0x10,%esp
114a8c: 8b 55 08 mov 0x8(%ebp),%edx
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
size_t size
);
114a8f: 85 d2 test %edx,%edx
114a91: 75 0d jne 114aa0 <rtems_timer_initiate_server+0x1c>
* 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;
114a93: b8 13 00 00 00 mov $0x13,%eax
}
return status;
}
114a98: 8d 65 f8 lea -0x8(%ebp),%esp
114a9b: 5b pop %ebx
114a9c: 5e pop %esi
114a9d: c9 leave
114a9e: c3 ret
114a9f: 90 nop
114aa0: 0f b6 05 14 d1 12 00 movzbl 0x12d114,%eax
114aa7: 39 c2 cmp %eax,%edx
114aa9: 77 31 ja 114adc <rtems_timer_initiate_server+0x58><== ALWAYS TAKEN
114aab: 89 d6 mov %edx,%esi <== NOT EXECUTED
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
114aad: a1 38 5a 13 00 mov 0x135a38,%eax
114ab2: 40 inc %eax
114ab3: a3 38 5a 13 00 mov %eax,0x135a38
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
114ab8: 8a 1d 00 14 13 00 mov 0x131400,%bl
initialized = true;
114abe: c6 05 00 14 13 00 01 movb $0x1,0x131400
_Thread_Enable_dispatch();
114ac5: e8 5a 29 00 00 call 117424 <_Thread_Enable_dispatch>
if ( tmpInitialized )
114aca: 84 db test %bl,%bl
114acc: 74 16 je 114ae4 <rtems_timer_initiate_server+0x60>
114ace: b8 0e 00 00 00 mov $0xe,%eax
*/
initialized = false;
}
return status;
}
114ad3: 8d 65 f8 lea -0x8(%ebp),%esp
114ad6: 5b pop %ebx
114ad7: 5e pop %esi
114ad8: c9 leave
114ad9: c3 ret
114ada: 66 90 xchg %ax,%ax
* structured so we check it is invalid before looking for
* a specific invalid value as the default.
*/
_priority = priority;
if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
114adc: 42 inc %edx
114add: 75 b4 jne 114a93 <rtems_timer_initiate_server+0xf>
114adf: 31 f6 xor %esi,%esi
114ae1: eb ca jmp 114aad <rtems_timer_initiate_server+0x29>
114ae3: 90 nop
114ae4: c7 05 a0 59 13 00 a4 movl $0x1359a4,0x1359a0
114aeb: 59 13 00
114aee: c7 05 a4 59 13 00 00 movl $0x0,0x1359a4
114af5: 00 00 00
114af8: c7 05 a8 59 13 00 a0 movl $0x1359a0,0x1359a8
114aff: 59 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(
114b02: 83 ec 08 sub $0x8,%esp
114b05: 8d 45 f4 lea -0xc(%ebp),%eax
114b08: 50 push %eax
114b09: 81 4d 10 00 80 00 00 orl $0x8000,0x10(%ebp)
114b10: ff 75 10 pushl 0x10(%ebp)
114b13: 68 00 01 00 00 push $0x100
114b18: ff 75 0c pushl 0xc(%ebp)
114b1b: 56 push %esi
114b1c: 68 45 4d 49 54 push $0x54494d45
114b21: e8 fa f1 ff ff call 113d20 <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) {
114b26: 83 c4 20 add $0x20,%esp
114b29: 85 c0 test %eax,%eax
114b2b: 0f 85 b2 00 00 00 jne 114be3 <rtems_timer_initiate_server+0x15f>
* 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(
114b31: 8b 4d f4 mov -0xc(%ebp),%ecx
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
);
/**
114b34: 66 3b 0d 50 59 13 00 cmp 0x135950,%cx
114b3b: 0f 86 b3 00 00 00 jbe 114bf4 <rtems_timer_initiate_server+0x170><== ALWAYS TAKEN
114b41: 31 c0 xor %eax,%eax
114b43: a3 e4 5d 13 00 mov %eax,0x135de4
114b48: c7 05 80 59 13 00 84 movl $0x135984,0x135980
114b4f: 59 13 00
114b52: c7 05 84 59 13 00 00 movl $0x0,0x135984
114b59: 00 00 00
114b5c: c7 05 88 59 13 00 80 movl $0x135980,0x135988
114b63: 59 13 00
114b66: c7 05 94 59 13 00 98 movl $0x135998,0x135994
114b6d: 59 13 00
114b70: c7 05 98 59 13 00 00 movl $0x0,0x135998
114b77: 00 00 00
114b7a: c7 05 9c 59 13 00 94 movl $0x135994,0x13599c
114b81: 59 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.
*
114b84: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
* @param[in] the_heap is the heap to operate upon
114b8b: c7 40 64 8c 72 11 00 movl $0x11728c,0x64(%eax)
* @param[in] starting_address is the starting address of the memory for
114b92: 89 48 68 mov %ecx,0x68(%eax)
* the heap
114b95: 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.
*
114b9c: c7 05 c8 59 13 00 00 movl $0x0,0x1359c8
114ba3: 00 00 00
* @param[in] the_heap is the heap to operate upon
114ba6: c7 05 dc 59 13 00 8c movl $0x11728c,0x1359dc
114bad: 72 11 00
* @param[in] starting_address is the starting address of the memory for
114bb0: 89 0d e0 59 13 00 mov %ecx,0x1359e0
* the heap
114bb6: c7 05 e4 59 13 00 00 movl $0x0,0x1359e4
114bbd: 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;
114bc0: c7 05 e0 5d 13 00 04 movl $0x114c04,0x135de0
114bc7: 4c 11 00
/*
* Start the timer server
*/
status = rtems_task_start(
114bca: 50 push %eax
114bcb: 6a 00 push $0x0
114bcd: 68 a0 4c 11 00 push $0x114ca0
114bd2: 51 push %ecx
114bd3: e8 5c f6 ff ff call 114234 <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) {
114bd8: 83 c4 10 add $0x10,%esp
114bdb: 85 c0 test %eax,%eax
114bdd: 0f 84 b5 fe ff ff je 114a98 <rtems_timer_initiate_server+0x14><== 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;
114be3: c6 05 00 14 13 00 00 movb $0x0,0x131400
}
return status;
}
114bea: 8d 65 f8 lea -0x8(%ebp),%esp
114bed: 5b pop %ebx
114bee: 5e pop %esi
114bef: c9 leave
114bf0: c3 ret
114bf1: 8d 76 00 lea 0x0(%esi),%esi
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
);
/**
114bf4: 0f b7 d1 movzwl %cx,%edx
114bf7: a1 5c 59 13 00 mov 0x13595c,%eax
114bfc: 8b 04 90 mov (%eax,%edx,4),%eax
114bff: e9 3f ff ff ff jmp 114b43 <rtems_timer_initiate_server+0xbf>
00114800 <rtems_timer_reset>:
*/
rtems_status_code rtems_timer_reset(
Objects_Id id
)
{
114800: 55 push %ebp
114801: 89 e5 mov %esp,%ebp
114803: 53 push %ebx
114804: 83 ec 18 sub $0x18,%esp
114807: 8d 45 f8 lea -0x8(%ebp),%eax
11480a: 50 push %eax
11480b: ff 75 08 pushl 0x8(%ebp)
11480e: 68 a0 5d 13 00 push $0x135da0
114813: e8 c8 23 00 00 call 116be0 <_Objects_Get>
114818: 89 c3 mov %eax,%ebx
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
11481a: 83 c4 10 add $0x10,%esp
11481d: 8b 45 f8 mov -0x8(%ebp),%eax
114820: 85 c0 test %eax,%eax
114822: 74 0c je 114830 <rtems_timer_reset+0x30>
114824: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
114829: 8b 5d fc mov -0x4(%ebp),%ebx
11482c: c9 leave
11482d: c3 ret
11482e: 66 90 xchg %ax,%ax
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
switch ( the_timer->the_class ) {
114830: 8b 43 38 mov 0x38(%ebx),%eax
114833: 83 f8 01 cmp $0x1,%eax
114836: 74 40 je 114878 <rtems_timer_reset+0x78>
114838: 73 2a jae 114864 <rtems_timer_reset+0x64>
case TIMER_INTERVAL:
_Watchdog_Remove( &the_timer->Ticker );
11483a: 83 c3 10 add $0x10,%ebx
11483d: 83 ec 0c sub $0xc,%esp
114840: 53 push %ebx
114841: e8 d6 3f 00 00 call 11881c <_Watchdog_Remove>
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
114846: 5a pop %edx
114847: 59 pop %ecx
114848: 53 push %ebx
114849: 68 1c 5b 13 00 push $0x135b1c
11484e: e8 99 3e 00 00 call 1186ec <_Watchdog_Insert>
114853: 83 c4 10 add $0x10,%esp
case TIMER_TIME_OF_DAY_ON_TASK:
case TIMER_DORMANT:
_Thread_Enable_dispatch();
return RTEMS_NOT_DEFINED;
}
_Thread_Enable_dispatch();
114856: e8 c9 2b 00 00 call 117424 <_Thread_Enable_dispatch>
11485b: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11485d: 8b 5d fc mov -0x4(%ebp),%ebx
114860: c9 leave
114861: c3 ret
114862: 66 90 xchg %ax,%ax
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
switch ( the_timer->the_class ) {
114864: 83 f8 04 cmp $0x4,%eax
114867: 77 ed ja 114856 <rtems_timer_reset+0x56><== NEVER TAKEN
(*_Timer_Server_schedule_operation)( the_timer );
break;
case TIMER_TIME_OF_DAY:
case TIMER_TIME_OF_DAY_ON_TASK:
case TIMER_DORMANT:
_Thread_Enable_dispatch();
114869: e8 b6 2b 00 00 call 117424 <_Thread_Enable_dispatch>
11486e: b8 0b 00 00 00 mov $0xb,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
114873: 8b 5d fc mov -0x4(%ebp),%ebx
114876: c9 leave
114877: c3 ret
case TIMER_INTERVAL:
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
break;
case TIMER_INTERVAL_ON_TASK:
if ( !_Timer_Server_schedule_operation ) {
114878: a1 e0 5d 13 00 mov 0x135de0,%eax
11487d: 85 c0 test %eax,%eax
11487f: 74 1b je 11489c <rtems_timer_reset+0x9c><== NEVER TAKEN
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
_Watchdog_Remove( &the_timer->Ticker );
114881: 83 ec 0c sub $0xc,%esp
114884: 8d 43 10 lea 0x10(%ebx),%eax
114887: 50 push %eax
114888: e8 8f 3f 00 00 call 11881c <_Watchdog_Remove>
(*_Timer_Server_schedule_operation)( the_timer );
11488d: 89 1c 24 mov %ebx,(%esp)
114890: ff 15 e0 5d 13 00 call *0x135de0
114896: 83 c4 10 add $0x10,%esp
114899: eb bb jmp 114856 <rtems_timer_reset+0x56>
11489b: 90 nop
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
break;
case TIMER_INTERVAL_ON_TASK:
if ( !_Timer_Server_schedule_operation ) {
_Thread_Enable_dispatch();
11489c: e8 83 2b 00 00 call 117424 <_Thread_Enable_dispatch><== NOT EXECUTED
1148a1: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED
1148a6: eb 81 jmp 114829 <rtems_timer_reset+0x29><== NOT EXECUTED
001148a8 <rtems_timer_server_fire_after>:
Objects_Id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
1148a8: 55 push %ebp
1148a9: 89 e5 mov %esp,%ebp
1148ab: 53 push %ebx
1148ac: 83 ec 14 sub $0x14,%esp
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( !_Timer_Server )
1148af: a1 e4 5d 13 00 mov 0x135de4,%eax
1148b4: 85 c0 test %eax,%eax
1148b6: 0f 84 b0 00 00 00 je 11496c <rtems_timer_server_fire_after+0xc4>
return RTEMS_INCORRECT_STATE;
if ( !routine )
1148bc: 8b 45 10 mov 0x10(%ebp),%eax
1148bf: 85 c0 test %eax,%eax
1148c1: 0f 84 b1 00 00 00 je 114978 <rtems_timer_server_fire_after+0xd0><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
1148c7: 8b 45 0c mov 0xc(%ebp),%eax
1148ca: 85 c0 test %eax,%eax
1148cc: 75 0a jne 1148d8 <rtems_timer_server_fire_after+0x30>
1148ce: b8 0a 00 00 00 mov $0xa,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1148d3: 8b 5d fc mov -0x4(%ebp),%ebx
1148d6: c9 leave
1148d7: c3 ret
1148d8: 53 push %ebx
1148d9: 8d 45 f8 lea -0x8(%ebp),%eax
1148dc: 50 push %eax
1148dd: ff 75 08 pushl 0x8(%ebp)
1148e0: 68 a0 5d 13 00 push $0x135da0
1148e5: e8 f6 22 00 00 call 116be0 <_Objects_Get>
1148ea: 89 c3 mov %eax,%ebx
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
1148ec: 83 c4 10 add $0x10,%esp
1148ef: 8b 4d f8 mov -0x8(%ebp),%ecx
1148f2: 85 c9 test %ecx,%ecx
1148f4: 75 5a jne 114950 <rtems_timer_server_fire_after+0xa8>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
1148f6: 83 ec 0c sub $0xc,%esp
1148f9: 8d 40 10 lea 0x10(%eax),%eax
1148fc: 50 push %eax
1148fd: e8 1a 3f 00 00 call 11881c <_Watchdog_Remove>
_ISR_Disable( level );
114902: 9c pushf
114903: fa cli
114904: 58 pop %eax
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
114905: 83 c4 10 add $0x10,%esp
114908: 8b 53 18 mov 0x18(%ebx),%edx
11490b: 85 d2 test %edx,%edx
11490d: 75 4d jne 11495c <rtems_timer_server_fire_after+0xb4><== NEVER TAKEN
/*
* 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;
11490f: 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.
*
114916: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
* @param[in] the_heap is the heap to operate upon
11491d: 8b 55 10 mov 0x10(%ebp),%edx
114920: 89 53 2c mov %edx,0x2c(%ebx)
* @param[in] starting_address is the starting address of the memory for
114923: 8b 55 08 mov 0x8(%ebp),%edx
114926: 89 53 30 mov %edx,0x30(%ebx)
* the heap
114929: 8b 55 14 mov 0x14(%ebp),%edx
11492c: 89 53 34 mov %edx,0x34(%ebx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = ticks;
11492f: 8b 55 0c mov 0xc(%ebp),%edx
114932: 89 53 1c mov %edx,0x1c(%ebx)
_ISR_Enable( level );
114935: 50 push %eax
114936: 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 );
114937: 83 ec 0c sub $0xc,%esp
11493a: 53 push %ebx
11493b: ff 15 e0 5d 13 00 call *0x135de0
_Thread_Enable_dispatch();
114941: e8 de 2a 00 00 call 117424 <_Thread_Enable_dispatch>
114946: 31 c0 xor %eax,%eax
114948: 83 c4 10 add $0x10,%esp
11494b: eb 86 jmp 1148d3 <rtems_timer_server_fire_after+0x2b>
11494d: 8d 76 00 lea 0x0(%esi),%esi
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
114950: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
114955: 8b 5d fc mov -0x4(%ebp),%ebx
114958: c9 leave
114959: c3 ret
11495a: 66 90 xchg %ax,%ax
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
11495c: 50 push %eax <== NOT EXECUTED
11495d: 9d popf <== NOT EXECUTED
_Thread_Enable_dispatch();
11495e: e8 c1 2a 00 00 call 117424 <_Thread_Enable_dispatch><== NOT EXECUTED
114963: 31 c0 xor %eax,%eax <== NOT EXECUTED
114965: e9 69 ff ff ff jmp 1148d3 <rtems_timer_server_fire_after+0x2b><== NOT EXECUTED
11496a: 66 90 xchg %ax,%ax <== NOT EXECUTED
{
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( !_Timer_Server )
11496c: b8 0e 00 00 00 mov $0xe,%eax
114971: e9 5d ff ff ff jmp 1148d3 <rtems_timer_server_fire_after+0x2b>
114976: 66 90 xchg %ax,%ax
return RTEMS_INCORRECT_STATE;
if ( !routine )
114978: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
11497d: e9 51 ff ff ff jmp 1148d3 <rtems_timer_server_fire_after+0x2b><== NOT EXECUTED
00114984 <rtems_timer_server_fire_when>:
Objects_Id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
114984: 55 push %ebp
114985: 89 e5 mov %esp,%ebp
114987: 56 push %esi
114988: 53 push %ebx
114989: 83 ec 10 sub $0x10,%esp
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_Timer_Server )
11498c: 8b 1d e4 5d 13 00 mov 0x135de4,%ebx
114992: 85 db test %ebx,%ebx
114994: 0f 84 d2 00 00 00 je 114a6c <rtems_timer_server_fire_when+0xe8>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
11499a: 80 3d 4c 5a 13 00 00 cmpb $0x0,0x135a4c
1149a1: 0f 84 ad 00 00 00 je 114a54 <rtems_timer_server_fire_when+0xd0><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
1149a7: 8b 4d 10 mov 0x10(%ebp),%ecx
1149aa: 85 c9 test %ecx,%ecx
1149ac: 0f 84 ae 00 00 00 je 114a60 <rtems_timer_server_fire_when+0xdc><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
1149b2: 83 ec 0c sub $0xc,%esp
1149b5: ff 75 0c pushl 0xc(%ebp)
1149b8: e8 c7 d3 ff ff call 111d84 <_TOD_Validate>
1149bd: 83 c4 10 add $0x10,%esp
1149c0: 84 c0 test %al,%al
1149c2: 75 0c jne 1149d0 <rtems_timer_server_fire_when+0x4c>
*/
(*_Timer_Server_schedule_operation)( the_timer );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
1149c4: b8 14 00 00 00 mov $0x14,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1149c9: 8d 65 f8 lea -0x8(%ebp),%esp
1149cc: 5b pop %ebx
1149cd: 5e pop %esi
1149ce: c9 leave
1149cf: c3 ret
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
1149d0: 83 ec 0c sub $0xc,%esp
1149d3: ff 75 0c pushl 0xc(%ebp)
1149d6: e8 19 d3 ff ff call 111cf4 <_TOD_To_seconds>
1149db: 89 c6 mov %eax,%esi
if ( seconds <= _TOD_Seconds_since_epoch )
1149dd: 83 c4 10 add $0x10,%esp
1149e0: 3b 05 cc 5a 13 00 cmp 0x135acc,%eax
1149e6: 76 dc jbe 1149c4 <rtems_timer_server_fire_when+0x40>
/**
* 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
1149e8: 52 push %edx
1149e9: 8d 45 f4 lea -0xc(%ebp),%eax
1149ec: 50 push %eax
1149ed: ff 75 08 pushl 0x8(%ebp)
1149f0: 68 a0 5d 13 00 push $0x135da0
1149f5: e8 e6 21 00 00 call 116be0 <_Objects_Get>
1149fa: 89 c3 mov %eax,%ebx
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
1149fc: 83 c4 10 add $0x10,%esp
1149ff: 8b 45 f4 mov -0xc(%ebp),%eax
114a02: 85 c0 test %eax,%eax
114a04: 75 72 jne 114a78 <rtems_timer_server_fire_when+0xf4>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
114a06: 83 ec 0c sub $0xc,%esp
114a09: 8d 43 10 lea 0x10(%ebx),%eax
114a0c: 50 push %eax
114a0d: e8 0a 3e 00 00 call 11881c <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
114a12: 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.
*
114a19: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
* @param[in] the_heap is the heap to operate upon
114a20: 8b 45 10 mov 0x10(%ebp),%eax
114a23: 89 43 2c mov %eax,0x2c(%ebx)
* @param[in] starting_address is the starting address of the memory for
114a26: 8b 45 08 mov 0x8(%ebp),%eax
114a29: 89 43 30 mov %eax,0x30(%ebx)
* the heap
114a2c: 8b 45 14 mov 0x14(%ebp),%eax
114a2f: 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;
114a32: 2b 35 cc 5a 13 00 sub 0x135acc,%esi
114a38: 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 );
114a3b: 89 1c 24 mov %ebx,(%esp)
114a3e: ff 15 e0 5d 13 00 call *0x135de0
_Thread_Enable_dispatch();
114a44: e8 db 29 00 00 call 117424 <_Thread_Enable_dispatch>
114a49: 31 c0 xor %eax,%eax
114a4b: 83 c4 10 add $0x10,%esp
114a4e: e9 76 ff ff ff jmp 1149c9 <rtems_timer_server_fire_when+0x45>
114a53: 90 nop
rtems_interval seconds;
if ( !_Timer_Server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
114a54: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
114a59: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
114a5c: 5b pop %ebx <== NOT EXECUTED
114a5d: 5e pop %esi <== NOT EXECUTED
114a5e: c9 leave <== NOT EXECUTED
114a5f: c3 ret <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
114a60: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
114a65: e9 5f ff ff ff jmp 1149c9 <rtems_timer_server_fire_when+0x45><== NOT EXECUTED
114a6a: 66 90 xchg %ax,%ax <== NOT EXECUTED
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_Timer_Server )
114a6c: b8 0e 00 00 00 mov $0xe,%eax
114a71: e9 53 ff ff ff jmp 1149c9 <rtems_timer_server_fire_when+0x45>
114a76: 66 90 xchg %ax,%ax
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch )
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
114a78: b8 04 00 00 00 mov $0x4,%eax
114a7d: e9 47 ff ff ff jmp 1149c9 <rtems_timer_server_fire_when+0x45>
00107b14 <rtems_verror>:
static int rtems_verror(
uint32_t error_flag,
const char *printf_format,
va_list arglist
)
{
107b14: 55 push %ebp <== NOT EXECUTED
107b15: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107b17: 57 push %edi <== NOT EXECUTED
107b18: 56 push %esi <== NOT EXECUTED
107b19: 53 push %ebx <== NOT EXECUTED
107b1a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107b1d: 89 c6 mov %eax,%esi <== NOT EXECUTED
107b1f: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED
107b22: 89 cf mov %ecx,%edi <== NOT EXECUTED
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC)
107b24: 25 00 00 00 20 and $0x20000000,%eax <== NOT EXECUTED
107b29: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED
107b2c: 74 2a je 107b58 <rtems_verror+0x44> <== NOT EXECUTED
{
if (rtems_panic_in_progress++)
107b2e: 8b 15 f0 a4 12 00 mov 0x12a4f0,%edx <== NOT EXECUTED
107b34: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED
107b37: a3 f0 a4 12 00 mov %eax,0x12a4f0 <== NOT EXECUTED
107b3c: 85 d2 test %edx,%edx <== NOT EXECUTED
107b3e: 74 0b je 107b4b <rtems_verror+0x37> <== NOT EXECUTED
107b40: a1 78 a6 12 00 mov 0x12a678,%eax <== NOT EXECUTED
107b45: 40 inc %eax <== NOT EXECUTED
107b46: a3 78 a6 12 00 mov %eax,0x12a678 <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
107b4b: 83 3d f0 a4 12 00 02 cmpl $0x2,0x12a4f0 <== NOT EXECUTED
107b52: 0f 8f dc 00 00 00 jg 107c34 <rtems_verror+0x120> <== NOT EXECUTED
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
107b58: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107b5b: a1 e0 07 12 00 mov 0x1207e0,%eax <== NOT EXECUTED
107b60: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
107b63: e8 bc 9f 00 00 call 111b24 <fflush> <== NOT EXECUTED
status = error_flag & ~RTEMS_ERROR_MASK;
107b68: 89 f3 mov %esi,%ebx <== NOT EXECUTED
107b6a: 81 e3 ff ff ff 8f and $0x8fffffff,%ebx <== NOT EXECUTED
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
107b70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107b73: f7 c6 00 00 00 40 test $0x40000000,%esi <== NOT EXECUTED
107b79: 0f 85 c1 00 00 00 jne 107c40 <rtems_verror+0x12c> <== NOT EXECUTED
107b7f: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== 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);
107b86: 50 push %eax <== NOT EXECUTED
107b87: 57 push %edi <== NOT EXECUTED
107b88: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED
107b8b: a1 e0 07 12 00 mov 0x1207e0,%eax <== NOT EXECUTED
107b90: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
107b93: e8 74 e8 00 00 call 11640c <vfprintf> <== NOT EXECUTED
107b98: 89 c7 mov %eax,%edi <== NOT EXECUTED
if (status)
107b9a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107b9d: 85 db test %ebx,%ebx <== NOT EXECUTED
107b9f: 0f 85 b7 00 00 00 jne 107c5c <rtems_verror+0x148> <== NOT EXECUTED
chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno)
107ba5: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED
107ba9: 74 34 je 107bdf <rtems_verror+0xcb> <== NOT EXECUTED
{
if ((local_errno > 0) && *strerror(local_errno))
107bab: 7e 17 jle 107bc4 <rtems_verror+0xb0> <== NOT EXECUTED
107bad: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107bb0: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED
107bb3: e8 a4 af 00 00 call 112b5c <strerror> <== NOT EXECUTED
107bb8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107bbb: 80 38 00 cmpb $0x0,(%eax) <== NOT EXECUTED
107bbe: 0f 85 c8 00 00 00 jne 107c8c <rtems_verror+0x178> <== NOT EXECUTED
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
107bc4: 53 push %ebx <== NOT EXECUTED
107bc5: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED
107bc8: 68 32 b2 11 00 push $0x11b232 <== NOT EXECUTED
107bcd: a1 e0 07 12 00 mov 0x1207e0,%eax <== NOT EXECUTED
107bd2: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
107bd5: e8 fa a2 00 00 call 111ed4 <fprintf> <== NOT EXECUTED
107bda: 01 c7 add %eax,%edi <== NOT EXECUTED
107bdc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
chars_written += fprintf(stderr, "\n");
107bdf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
107be2: 68 ab a6 11 00 push $0x11a6ab <== NOT EXECUTED
107be7: a1 e0 07 12 00 mov 0x1207e0,%eax <== NOT EXECUTED
107bec: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
107bef: e8 e0 a2 00 00 call 111ed4 <fprintf> <== NOT EXECUTED
107bf4: 89 c3 mov %eax,%ebx <== NOT EXECUTED
(void) fflush(stderr);
107bf6: 59 pop %ecx <== NOT EXECUTED
107bf7: a1 e0 07 12 00 mov 0x1207e0,%eax <== NOT EXECUTED
107bfc: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
107bff: e8 20 9f 00 00 call 111b24 <fflush> <== NOT EXECUTED
if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT))
107c04: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107c07: 81 e6 00 00 00 30 and $0x30000000,%esi <== NOT EXECUTED
107c0d: 74 41 je 107c50 <rtems_verror+0x13c> <== NOT EXECUTED
{
if (error_flag & RTEMS_ERROR_PANIC)
107c0f: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED
107c12: 85 d2 test %edx,%edx <== NOT EXECUTED
107c14: 0f 84 8b 00 00 00 je 107ca5 <rtems_verror+0x191> <== NOT EXECUTED
{
rtems_error(0, "fatal error, exiting");
107c1a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
107c1d: 68 46 b2 11 00 push $0x11b246 <== NOT EXECUTED
107c22: 6a 00 push $0x0 <== NOT EXECUTED
107c24: e8 ab 00 00 00 call 107cd4 <rtems_error> <== NOT EXECUTED
_exit(local_errno);
107c29: 58 pop %eax <== NOT EXECUTED
107c2a: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED
107c2d: e8 1e 07 00 00 call 108350 <_exit> <== NOT EXECUTED
107c32: 66 90 xchg %ax,%ax <== NOT EXECUTED
}
else
{
rtems_error(0, "fatal error, aborting");
abort();
107c34: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
}
return chars_written;
}
107c36: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
107c39: 5b pop %ebx <== NOT EXECUTED
107c3a: 5e pop %esi <== NOT EXECUTED
107c3b: 5f pop %edi <== NOT EXECUTED
107c3c: c9 leave <== NOT EXECUTED
107c3d: c3 ret <== NOT EXECUTED
107c3e: 66 90 xchg %ax,%ax <== NOT EXECUTED
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
local_errno = errno;
107c40: e8 2f 9c 00 00 call 111874 <__errno> <== NOT EXECUTED
107c45: 8b 00 mov (%eax),%eax <== NOT EXECUTED
107c47: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED
107c4a: e9 37 ff ff ff jmp 107b86 <rtems_verror+0x72> <== NOT EXECUTED
107c4f: 90 nop <== 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");
107c50: 8d 04 3b lea (%ebx,%edi,1),%eax <== NOT EXECUTED
rtems_error(0, "fatal error, aborting");
abort();
}
}
return chars_written;
}
107c53: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
107c56: 5b pop %ebx <== NOT EXECUTED
107c57: 5e pop %esi <== NOT EXECUTED
107c58: 5f pop %edi <== NOT EXECUTED
107c59: c9 leave <== NOT EXECUTED
107c5a: c3 ret <== NOT EXECUTED
107c5b: 90 nop <== NOT EXECUTED
const char *
rtems_status_text(
rtems_status_code status
)
{
return rtems_assoc_name_by_local(rtems_status_assoc, status);
107c5c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
107c5f: 53 push %ebx <== NOT EXECUTED
107c60: 68 40 b5 11 00 push $0x11b540 <== NOT EXECUTED
107c65: e8 8e 7f 00 00 call 10fbf8 <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));
107c6a: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
107c6d: 50 push %eax <== NOT EXECUTED
107c6e: 68 17 b2 11 00 push $0x11b217 <== NOT EXECUTED
107c73: a1 e0 07 12 00 mov 0x1207e0,%eax <== NOT EXECUTED
107c78: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
107c7b: e8 54 a2 00 00 call 111ed4 <fprintf> <== NOT EXECUTED
107c80: 01 c7 add %eax,%edi <== NOT EXECUTED
107c82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107c85: e9 1b ff ff ff jmp 107ba5 <rtems_verror+0x91> <== NOT EXECUTED
107c8a: 66 90 xchg %ax,%ax <== NOT EXECUTED
if (local_errno)
{
if ((local_errno > 0) && *strerror(local_errno))
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
107c8c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107c8f: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED
107c92: e8 c5 ae 00 00 call 112b5c <strerror> <== NOT EXECUTED
107c97: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
107c9a: 50 push %eax <== NOT EXECUTED
107c9b: 68 25 b2 11 00 push $0x11b225 <== NOT EXECUTED
107ca0: e9 28 ff ff ff jmp 107bcd <rtems_verror+0xb9> <== NOT EXECUTED
rtems_error(0, "fatal error, exiting");
_exit(local_errno);
}
else
{
rtems_error(0, "fatal error, aborting");
107ca5: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
107ca8: 68 5b b2 11 00 push $0x11b25b <== NOT EXECUTED
107cad: 6a 00 push $0x0 <== NOT EXECUTED
107caf: e8 20 00 00 00 call 107cd4 <rtems_error> <== NOT EXECUTED
abort();
107cb4: e8 87 9b 00 00 call 111840 <abort> <== NOT EXECUTED
00108b30 <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
108b30: 55 push %ebp <== NOT EXECUTED
108b31: 89 e5 mov %esp,%ebp <== NOT EXECUTED
108b33: 56 push %esi <== NOT EXECUTED
108b34: 53 push %ebx <== NOT EXECUTED
108b35: 89 d6 mov %edx,%esi <== NOT EXECUTED
108b37: 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)) {
108b39: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx) <== NOT EXECUTED
108b40: 75 0e jne 108b50 <siproc+0x20> <== 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);
108b42: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
}
return i;
}
108b45: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
108b48: 5b pop %ebx <== NOT EXECUTED
108b49: 5e pop %esi <== NOT EXECUTED
108b4a: 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);
108b4b: e9 a8 fe ff ff jmp 1089f8 <iproc> <== NOT EXECUTED
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
108b50: 50 push %eax <== NOT EXECUTED
108b51: 6a 00 push $0x0 <== NOT EXECUTED
108b53: 6a 00 push $0x0 <== NOT EXECUTED
108b55: ff 72 18 pushl 0x18(%edx) <== NOT EXECUTED
108b58: e8 93 18 00 00 call 10a3f0 <rtems_semaphore_obtain><== NOT EXECUTED
i = iproc (c, tty);
108b5d: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED
108b60: 89 f2 mov %esi,%edx <== NOT EXECUTED
108b62: e8 91 fe ff ff call 1089f8 <iproc> <== NOT EXECUTED
108b67: 89 c3 mov %eax,%ebx <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
108b69: 59 pop %ecx <== NOT EXECUTED
108b6a: ff 76 18 pushl 0x18(%esi) <== NOT EXECUTED
108b6d: e8 76 19 00 00 call 10a4e8 <rtems_semaphore_release><== NOT EXECUTED
108b72: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
else {
i = iproc (c, tty);
}
return i;
}
108b75: 89 d8 mov %ebx,%eax <== NOT EXECUTED
108b77: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
108b7a: 5b pop %ebx <== NOT EXECUTED
108b7b: 5e pop %esi <== NOT EXECUTED
108b7c: c9 leave <== NOT EXECUTED
108b7d: c3 ret <== NOT EXECUTED
00107e50 <termios_baud_to_number>:
#include <sys/termios.h>
int termios_baud_to_number(
int termios_baud
)
{
107e50: 55 push %ebp <== NOT EXECUTED
107e51: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107e53: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
int baud;
switch (termios_baud) {
107e56: 83 f8 09 cmp $0x9,%eax <== NOT EXECUTED
107e59: 0f 84 f1 00 00 00 je 107f50 <termios_baud_to_number+0x100><== NOT EXECUTED
107e5f: 7e 37 jle 107e98 <termios_baud_to_number+0x48><== NOT EXECUTED
107e61: 83 f8 0e cmp $0xe,%eax <== NOT EXECUTED
107e64: 0f 84 f6 00 00 00 je 107f60 <termios_baud_to_number+0x110><== NOT EXECUTED
107e6a: 7e 5c jle 107ec8 <termios_baud_to_number+0x78><== NOT EXECUTED
107e6c: 3d 02 10 00 00 cmp $0x1002,%eax <== NOT EXECUTED
107e71: 0f 84 01 01 00 00 je 107f78 <termios_baud_to_number+0x128><== NOT EXECUTED
107e77: 0f 8e 97 00 00 00 jle 107f14 <termios_baud_to_number+0xc4><== NOT EXECUTED
107e7d: 3d 03 10 00 00 cmp $0x1003,%eax <== NOT EXECUTED
107e82: 0f 84 e0 00 00 00 je 107f68 <termios_baud_to_number+0x118><== NOT EXECUTED
107e88: 3d 04 10 00 00 cmp $0x1004,%eax <== NOT EXECUTED
107e8d: 75 51 jne 107ee0 <termios_baud_to_number+0x90><== 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;
107e8f: b8 00 08 07 00 mov $0x70800,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107e94: c9 leave <== NOT EXECUTED
107e95: c3 ret <== NOT EXECUTED
107e96: 66 90 xchg %ax,%ax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107e98: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED
107e9b: 0f 84 b7 00 00 00 je 107f58 <termios_baud_to_number+0x108><== NOT EXECUTED
107ea1: 7f 45 jg 107ee8 <termios_baud_to_number+0x98><== NOT EXECUTED
107ea3: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED
107ea6: 0f 84 8c 00 00 00 je 107f38 <termios_baud_to_number+0xe8><== NOT EXECUTED
107eac: 0f 8e de 00 00 00 jle 107f90 <termios_baud_to_number+0x140><== NOT EXECUTED
107eb2: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED
107eb5: 0f 84 c5 00 00 00 je 107f80 <termios_baud_to_number+0x130><== NOT EXECUTED
107ebb: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED
107ebe: 75 20 jne 107ee0 <termios_baud_to_number+0x90><== NOT EXECUTED
case B0: baud = 0; break;
case B50: baud = 50; break;
case B75: baud = 75; break;
107ec0: b8 6e 00 00 00 mov $0x6e,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107ec5: c9 leave <== NOT EXECUTED
107ec6: c3 ret <== NOT EXECUTED
107ec7: 90 nop <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107ec8: 83 f8 0b cmp $0xb,%eax <== NOT EXECUTED
107ecb: 0f 84 9f 00 00 00 je 107f70 <termios_baud_to_number+0x120><== NOT EXECUTED
107ed1: 7c 39 jl 107f0c <termios_baud_to_number+0xbc><== NOT EXECUTED
107ed3: 83 f8 0c cmp $0xc,%eax <== NOT EXECUTED
107ed6: 74 50 je 107f28 <termios_baud_to_number+0xd8><== NOT EXECUTED
107ed8: 83 f8 0d cmp $0xd,%eax <== NOT EXECUTED
107edb: 74 62 je 107f3f <termios_baud_to_number+0xef><== NOT EXECUTED
107edd: 8d 76 00 lea 0x0(%esi),%esi <== 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;
107ee0: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
default: baud = -1; break;
}
return baud;
}
107ee5: c9 leave <== NOT EXECUTED
107ee6: c3 ret <== NOT EXECUTED
107ee7: 90 nop <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107ee8: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED
107eeb: 74 43 je 107f30 <termios_baud_to_number+0xe0><== NOT EXECUTED
107eed: 7c 15 jl 107f04 <termios_baud_to_number+0xb4><== NOT EXECUTED
107eef: 83 f8 07 cmp $0x7,%eax <== NOT EXECUTED
107ef2: 0f 84 90 00 00 00 je 107f88 <termios_baud_to_number+0x138><== NOT EXECUTED
107ef8: 83 f8 08 cmp $0x8,%eax <== NOT EXECUTED
107efb: 75 e3 jne 107ee0 <termios_baud_to_number+0x90><== 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;
107efd: b8 58 02 00 00 mov $0x258,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107f02: c9 leave <== NOT EXECUTED
107f03: c3 ret <== NOT EXECUTED
switch (termios_baud) {
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;
107f04: b8 96 00 00 00 mov $0x96,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107f09: c9 leave <== NOT EXECUTED
107f0a: c3 ret <== NOT EXECUTED
107f0b: 90 nop <== 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;
107f0c: b8 08 07 00 00 mov $0x708,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107f11: c9 leave <== NOT EXECUTED
107f12: c3 ret <== NOT EXECUTED
107f13: 90 nop <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107f14: 83 f8 0f cmp $0xf,%eax <== NOT EXECUTED
107f17: 74 2f je 107f48 <termios_baud_to_number+0xf8><== NOT EXECUTED
107f19: 3d 01 10 00 00 cmp $0x1001,%eax <== NOT EXECUTED
107f1e: 75 c0 jne 107ee0 <termios_baud_to_number+0x90><== 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;
107f20: b8 00 e1 00 00 mov $0xe100,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107f25: c9 leave <== NOT EXECUTED
107f26: c3 ret <== NOT EXECUTED
107f27: 90 nop <== 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;
107f28: b8 c0 12 00 00 mov $0x12c0,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107f2d: c9 leave <== NOT EXECUTED
107f2e: c3 ret <== NOT EXECUTED
107f2f: 90 nop <== 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;
107f30: b8 c8 00 00 00 mov $0xc8,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107f35: c9 leave <== NOT EXECUTED
107f36: c3 ret <== NOT EXECUTED
107f37: 90 nop <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107f38: b8 32 00 00 00 mov $0x32,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107f3d: c9 leave <== NOT EXECUTED
107f3e: c3 ret <== 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;
107f3f: b8 80 25 00 00 mov $0x2580,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107f44: c9 leave <== NOT EXECUTED
107f45: c3 ret <== NOT EXECUTED
107f46: 66 90 xchg %ax,%ax <== 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;
107f48: b8 00 96 00 00 mov $0x9600,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107f4d: c9 leave <== NOT EXECUTED
107f4e: c3 ret <== NOT EXECUTED
107f4f: 90 nop <== 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;
107f50: b8 b0 04 00 00 mov $0x4b0,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107f55: c9 leave <== NOT EXECUTED
107f56: c3 ret <== NOT EXECUTED
107f57: 90 nop <== NOT EXECUTED
switch (termios_baud) {
case B0: baud = 0; break;
case B50: baud = 50; break;
case B75: baud = 75; break;
case B110: baud = 110; break;
107f58: b8 87 00 00 00 mov $0x87,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107f5d: c9 leave <== NOT EXECUTED
107f5e: c3 ret <== NOT EXECUTED
107f5f: 90 nop <== 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;
107f60: b8 00 4b 00 00 mov $0x4b00,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107f65: c9 leave <== NOT EXECUTED
107f66: c3 ret <== NOT EXECUTED
107f67: 90 nop <== 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;
107f68: b8 00 84 03 00 mov $0x38400,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107f6d: c9 leave <== NOT EXECUTED
107f6e: c3 ret <== NOT EXECUTED
107f6f: 90 nop <== 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;
107f70: b8 60 09 00 00 mov $0x960,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107f75: c9 leave <== NOT EXECUTED
107f76: c3 ret <== NOT EXECUTED
107f77: 90 nop <== 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;
107f78: b8 00 c2 01 00 mov $0x1c200,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107f7d: c9 leave <== NOT EXECUTED
107f7e: c3 ret <== NOT EXECUTED
107f7f: 90 nop <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107f80: b8 4b 00 00 00 mov $0x4b,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107f85: c9 leave <== NOT EXECUTED
107f86: c3 ret <== NOT EXECUTED
107f87: 90 nop <== 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;
107f88: b8 2c 01 00 00 mov $0x12c,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107f8d: c9 leave <== NOT EXECUTED
107f8e: c3 ret <== NOT EXECUTED
107f8f: 90 nop <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107f90: 85 c0 test %eax,%eax <== NOT EXECUTED
107f92: 0f 85 48 ff ff ff jne 107ee0 <termios_baud_to_number+0x90><== NOT EXECUTED
107f98: 31 c0 xor %eax,%eax <== NOT EXECUTED
case B460800: baud = 460800; break;
default: baud = -1; break;
}
return baud;
}
107f9a: c9 leave <== NOT EXECUTED
107f9b: c3 ret <== NOT EXECUTED
00107b20 <vprintk>:
*/
void vprintk(
const char *fmt,
va_list ap
)
{
107b20: 55 push %ebp
107b21: 89 e5 mov %esp,%ebp
107b23: 57 push %edi
107b24: 56 push %esi
107b25: 53 push %ebx
107b26: 83 ec 3c sub $0x3c,%esp
107b29: 8b 7d 0c mov 0xc(%ebp),%edi
char c, *str;
int lflag, base, sign, width, lead, minus;
for (; *fmt != '\0'; fmt++) {
107b2c: 8b 55 08 mov 0x8(%ebp),%edx
107b2f: 8a 02 mov (%edx),%al
107b31: 84 c0 test %al,%al
107b33: 0f 84 b9 00 00 00 je 107bf2 <vprintk+0xd2> <== NEVER TAKEN
base = 0;
sign = 0;
width = 0;
minus = 0;
lead = ' ';
if (*fmt == '%') {
107b39: 3c 25 cmp $0x25,%al
107b3b: 0f 85 92 00 00 00 jne 107bd3 <vprintk+0xb3>
107b41: 8d 76 00 lea 0x0(%esi),%esi
fmt++;
107b44: 8b 4d 08 mov 0x8(%ebp),%ecx
107b47: 41 inc %ecx
if (*fmt == '0' ) {
107b48: 8b 45 08 mov 0x8(%ebp),%eax
107b4b: 8a 50 01 mov 0x1(%eax),%dl
107b4e: 80 fa 30 cmp $0x30,%dl
107b51: 0f 84 91 02 00 00 je 107de8 <vprintk+0x2c8>
107b57: c7 45 c4 20 00 00 00 movl $0x20,-0x3c(%ebp)
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
107b5e: 80 fa 2d cmp $0x2d,%dl
107b61: 0f 84 59 02 00 00 je 107dc0 <vprintk+0x2a0>
107b67: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp)
minus = 1;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
107b6e: 8d 42 d0 lea -0x30(%edx),%eax
107b71: 3c 09 cmp $0x9,%al
107b73: 0f 87 5c 02 00 00 ja 107dd5 <vprintk+0x2b5>
107b79: 31 db xor %ebx,%ebx
107b7b: 90 nop
width *= 10;
width += (*fmt - '0');
107b7c: 8d 04 9b lea (%ebx,%ebx,4),%eax
107b7f: 0f be d2 movsbl %dl,%edx
107b82: 8d 5c 42 d0 lea -0x30(%edx,%eax,2),%ebx
fmt++;
107b86: 41 inc %ecx
}
if (*fmt == '-' ) {
minus = 1;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
107b87: 8a 11 mov (%ecx),%dl
107b89: 8d 42 d0 lea -0x30(%edx),%eax
107b8c: 3c 09 cmp $0x9,%al
107b8e: 76 ec jbe 107b7c <vprintk+0x5c>
107b90: 89 5d d0 mov %ebx,-0x30(%ebp)
107b93: 89 4d 08 mov %ecx,0x8(%ebp)
width *= 10;
width += (*fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
107b96: 80 fa 6c cmp $0x6c,%dl
107b99: 0f 84 11 02 00 00 je 107db0 <vprintk+0x290>
lflag = 1;
c = *++fmt;
}
switch (c) {
107b9f: 8d 42 bc lea -0x44(%edx),%eax
107ba2: 3c 34 cmp $0x34,%al
107ba4: 76 56 jbe 107bfc <vprintk+0xdc>
break;
case 'c':
BSP_output_char(va_arg(ap, int));
break;
default:
BSP_output_char(c);
107ba6: 83 ec 0c sub $0xc,%esp
107ba9: 0f be c2 movsbl %dl,%eax
107bac: 50 push %eax
107bad: ff 15 a4 a1 11 00 call *0x11a1a4
107bb3: 89 7d cc mov %edi,-0x34(%ebp)
107bb6: 83 c4 10 add $0x10,%esp
107bb9: 8d 76 00 lea 0x0(%esi),%esi
)
{
char c, *str;
int lflag, base, sign, width, lead, minus;
for (; *fmt != '\0'; fmt++) {
107bbc: ff 45 08 incl 0x8(%ebp)
107bbf: 8b 55 08 mov 0x8(%ebp),%edx
107bc2: 8a 02 mov (%edx),%al
107bc4: 84 c0 test %al,%al
107bc6: 74 2a je 107bf2 <vprintk+0xd2> <== NEVER TAKEN
107bc8: 8b 7d cc mov -0x34(%ebp),%edi
base = 0;
sign = 0;
width = 0;
minus = 0;
lead = ' ';
if (*fmt == '%') {
107bcb: 3c 25 cmp $0x25,%al
107bcd: 0f 84 71 ff ff ff je 107b44 <vprintk+0x24>
if (base)
printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int),
base, sign, width, lead);
} else {
BSP_output_char(*fmt);
107bd3: 83 ec 0c sub $0xc,%esp
107bd6: 0f be c0 movsbl %al,%eax
107bd9: 50 push %eax
107bda: ff 15 a4 a1 11 00 call *0x11a1a4
107be0: 89 7d cc mov %edi,-0x34(%ebp)
107be3: 83 c4 10 add $0x10,%esp
)
{
char c, *str;
int lflag, base, sign, width, lead, minus;
for (; *fmt != '\0'; fmt++) {
107be6: ff 45 08 incl 0x8(%ebp)
107be9: 8b 55 08 mov 0x8(%ebp),%edx
107bec: 8a 02 mov (%edx),%al
107bee: 84 c0 test %al,%al
107bf0: 75 d6 jne 107bc8 <vprintk+0xa8>
base, sign, width, lead);
} else {
BSP_output_char(*fmt);
}
}
}
107bf2: 8d 65 f4 lea -0xc(%ebp),%esp
107bf5: 5b pop %ebx
107bf6: 5e pop %esi
107bf7: 5f pop %edi
107bf8: c9 leave
107bf9: c3 ret
107bfa: 66 90 xchg %ax,%ax
if ((c = *fmt) == 'l') {
lflag = 1;
c = *++fmt;
}
switch (c) {
107bfc: 0f b6 c0 movzbl %al,%eax
107bff: ff 24 85 e4 84 11 00 jmp *0x1184e4(,%eax,4)
break;
case 'c':
BSP_output_char(va_arg(ap, int));
break;
default:
BSP_output_char(c);
107c06: 31 c0 xor %eax,%eax
107c08: be 08 00 00 00 mov $0x8,%esi <== NOT EXECUTED
break;
} /* switch*/
if (base)
printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int),
107c0d: 8d 57 04 lea 0x4(%edi),%edx
107c10: 89 55 cc mov %edx,-0x34(%ebp)
107c13: 8b 1f mov (%edi),%ebx
{
long unsigned int n;
int count;
char toPrint[20];
if ( (sign == 1) && ((long)num < 0) ) {
107c15: 48 dec %eax
107c16: 0f 84 a4 00 00 00 je 107cc0 <vprintk+0x1a0> <== NEVER TAKEN
num = -num;
if (maxwidth) maxwidth--;
}
count = 0;
while ((n = num / base) > 0) {
107c1c: 89 d8 mov %ebx,%eax
107c1e: 31 d2 xor %edx,%edx
107c20: f7 f6 div %esi
107c22: 85 c0 test %eax,%eax
107c24: 0f 84 c4 00 00 00 je 107cee <vprintk+0x1ce>
107c2a: 89 d9 mov %ebx,%ecx
107c2c: 89 c3 mov %eax,%ebx
107c2e: 31 ff xor %edi,%edi
107c30: eb 06 jmp 107c38 <vprintk+0x118>
107c32: 66 90 xchg %ax,%ax
107c34: 89 d9 mov %ebx,%ecx
107c36: 89 c3 mov %eax,%ebx
toPrint[count++] = (num - (n*base));
107c38: 89 d8 mov %ebx,%eax
107c3a: 0f af c6 imul %esi,%eax
107c3d: 28 c1 sub %al,%cl
107c3f: 88 4c 3d e0 mov %cl,-0x20(%ebp,%edi,1)
107c43: 47 inc %edi
num = -num;
if (maxwidth) maxwidth--;
}
count = 0;
while ((n = num / base) > 0) {
107c44: 89 d8 mov %ebx,%eax
107c46: 31 d2 xor %edx,%edx
107c48: f7 f6 div %esi
107c4a: 85 c0 test %eax,%eax
107c4c: 75 e6 jne 107c34 <vprintk+0x114>
107c4e: 8d 77 01 lea 0x1(%edi),%esi
toPrint[count++] = (num - (n*base));
num = n;
}
toPrint[count++] = num;
107c51: 88 5c 3d e0 mov %bl,-0x20(%ebp,%edi,1)
for (n=maxwidth ; n > count; n-- )
107c55: 8b 5d d0 mov -0x30(%ebp),%ebx
107c58: 39 f3 cmp %esi,%ebx
107c5a: 76 16 jbe 107c72 <vprintk+0x152>
107c5c: 0f be 7d c4 movsbl -0x3c(%ebp),%edi
BSP_output_char(lead);
107c60: 83 ec 0c sub $0xc,%esp
107c63: 57 push %edi
107c64: ff 15 a4 a1 11 00 call *0x11a1a4
toPrint[count++] = (num - (n*base));
num = n;
}
toPrint[count++] = num;
for (n=maxwidth ; n > count; n-- )
107c6a: 4b dec %ebx
107c6b: 83 c4 10 add $0x10,%esp
107c6e: 39 f3 cmp %esi,%ebx
107c70: 77 ee ja 107c60 <vprintk+0x140>
BSP_output_char(lead);
for (n = 0; n < count; n++) {
107c72: 85 f6 test %esi,%esi
107c74: 0f 84 42 ff ff ff je 107bbc <vprintk+0x9c> <== NEVER TAKEN
107c7a: 31 db xor %ebx,%ebx
107c7c: 8d 7c 35 f4 lea -0xc(%ebp,%esi,1),%edi
BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
107c80: 83 ec 0c sub $0xc,%esp
107c83: 89 d8 mov %ebx,%eax
107c85: f7 d0 not %eax
107c87: 0f be 44 38 ec movsbl -0x14(%eax,%edi,1),%eax
107c8c: 0f be 80 d2 84 11 00 movsbl 0x1184d2(%eax),%eax
107c93: 50 push %eax
107c94: ff 15 a4 a1 11 00 call *0x11a1a4
toPrint[count++] = num;
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
107c9a: 43 inc %ebx
107c9b: 83 c4 10 add $0x10,%esp
107c9e: 39 de cmp %ebx,%esi
107ca0: 77 de ja 107c80 <vprintk+0x160>
107ca2: e9 15 ff ff ff jmp 107bbc <vprintk+0x9c>
if ((c = *fmt) == 'l') {
lflag = 1;
c = *++fmt;
}
switch (c) {
107ca7: b8 01 00 00 00 mov $0x1,%eax
107cac: be 0a 00 00 00 mov $0xa,%esi
BSP_output_char(c);
break;
} /* switch*/
if (base)
printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int),
107cb1: 8d 57 04 lea 0x4(%edi),%edx
107cb4: 89 55 cc mov %edx,-0x34(%ebp)
107cb7: 8b 1f mov (%edi),%ebx
{
long unsigned int n;
int count;
char toPrint[20];
if ( (sign == 1) && ((long)num < 0) ) {
107cb9: 48 dec %eax
107cba: 0f 85 5c ff ff ff jne 107c1c <vprintk+0xfc> <== NEVER TAKEN
107cc0: 85 db test %ebx,%ebx
107cc2: 0f 89 54 ff ff ff jns 107c1c <vprintk+0xfc> <== ALWAYS TAKEN
BSP_output_char('-');
107cc8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107ccb: 6a 2d push $0x2d <== NOT EXECUTED
107ccd: ff 15 a4 a1 11 00 call *0x11a1a4 <== NOT EXECUTED
num = -num;
107cd3: f7 db neg %ebx <== NOT EXECUTED
if (maxwidth) maxwidth--;
107cd5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107cd8: 83 7d d0 01 cmpl $0x1,-0x30(%ebp) <== NOT EXECUTED
107cdc: 83 55 d0 ff adcl $0xffffffff,-0x30(%ebp) <== NOT EXECUTED
}
count = 0;
while ((n = num / base) > 0) {
107ce0: 89 d8 mov %ebx,%eax <== NOT EXECUTED
107ce2: 31 d2 xor %edx,%edx <== NOT EXECUTED
107ce4: f7 f6 div %esi <== NOT EXECUTED
107ce6: 85 c0 test %eax,%eax <== NOT EXECUTED
107ce8: 0f 85 3c ff ff ff jne 107c2a <vprintk+0x10a> <== NOT EXECUTED
107cee: 31 ff xor %edi,%edi
107cf0: be 01 00 00 00 mov $0x1,%esi
107cf5: e9 57 ff ff ff jmp 107c51 <vprintk+0x131>
case 'p': base = 16; sign = 0; break;
case 's':
{ int i, len;
char *s;
str = va_arg(ap, char *);
107cfa: 8d 47 04 lea 0x4(%edi),%eax
107cfd: 89 45 cc mov %eax,-0x34(%ebp)
107d00: 8b 3f mov (%edi),%edi
107d02: 89 7d c0 mov %edi,-0x40(%ebp)
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
107d05: 80 3f 00 cmpb $0x0,(%edi)
107d08: 0f 84 16 01 00 00 je 107e24 <vprintk+0x304> <== NEVER TAKEN
107d0e: 31 ff xor %edi,%edi
107d10: 47 inc %edi
107d11: 8b 55 c0 mov -0x40(%ebp),%edx
107d14: 80 3c 3a 00 cmpb $0x0,(%edx,%edi,1)
107d18: 75 f6 jne 107d10 <vprintk+0x1f0>
;
/* leading spaces */
if ( !minus )
107d1a: 8b 4d c8 mov -0x38(%ebp),%ecx
107d1d: 85 c9 test %ecx,%ecx
107d1f: 0f 84 db 00 00 00 je 107e00 <vprintk+0x2e0>
for ( i=len ; i<width ; i++ )
BSP_output_char(' ');
/* no width option */
if (width == 0) {
107d25: 85 db test %ebx,%ebx
107d27: 75 03 jne 107d2c <vprintk+0x20c>
107d29: 89 7d d0 mov %edi,-0x30(%ebp)
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
107d2c: 8b 55 d0 mov -0x30(%ebp),%edx
107d2f: 85 d2 test %edx,%edx
107d31: 7e 25 jle 107d58 <vprintk+0x238> <== NEVER TAKEN
107d33: 8b 55 c0 mov -0x40(%ebp),%edx
107d36: 8a 02 mov (%edx),%al
107d38: 84 c0 test %al,%al
107d3a: 74 1c je 107d58 <vprintk+0x238> <== NEVER TAKEN
BSP_output_char(*str);
107d3c: 83 ec 0c sub $0xc,%esp
107d3f: 0f be c0 movsbl %al,%eax
107d42: 50 push %eax
107d43: ff 15 a4 a1 11 00 call *0x11a1a4
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
107d49: ff 45 c0 incl -0x40(%ebp)
107d4c: 8b 55 c0 mov -0x40(%ebp),%edx
107d4f: 8a 02 mov (%edx),%al
107d51: 83 c4 10 add $0x10,%esp
107d54: 84 c0 test %al,%al
107d56: 75 e4 jne 107d3c <vprintk+0x21c>
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
107d58: 8b 45 c8 mov -0x38(%ebp),%eax
107d5b: 85 c0 test %eax,%eax
107d5d: 0f 84 59 fe ff ff je 107bbc <vprintk+0x9c>
for ( i=len ; i<width ; i++ )
107d63: 39 7d d0 cmp %edi,-0x30(%ebp)
107d66: 0f 8e 50 fe ff ff jle 107bbc <vprintk+0x9c> <== NEVER TAKEN
107d6c: 89 fb mov %edi,%ebx
107d6e: 66 90 xchg %ax,%ax
BSP_output_char(' ');
107d70: 83 ec 0c sub $0xc,%esp
107d73: 6a 20 push $0x20
107d75: ff 15 a4 a1 11 00 call *0x11a1a4
for ( i=0 ; i<width && *str ; str++ )
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
107d7b: 43 inc %ebx
107d7c: 83 c4 10 add $0x10,%esp
107d7f: 39 5d d0 cmp %ebx,-0x30(%ebp)
107d82: 7f ec jg 107d70 <vprintk+0x250>
107d84: e9 33 fe ff ff jmp 107bbc <vprintk+0x9c>
BSP_output_char(' ');
}
break;
case 'c':
BSP_output_char(va_arg(ap, int));
107d89: 8d 47 04 lea 0x4(%edi),%eax <== NOT EXECUTED
107d8c: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED
107d8f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107d92: 0f be 07 movsbl (%edi),%eax <== NOT EXECUTED
107d95: 50 push %eax <== NOT EXECUTED
107d96: ff 15 a4 a1 11 00 call *0x11a1a4 <== NOT EXECUTED
107d9c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107d9f: e9 18 fe ff ff jmp 107bbc <vprintk+0x9c> <== NOT EXECUTED
if ((c = *fmt) == 'l') {
lflag = 1;
c = *++fmt;
}
switch (c) {
107da4: 31 c0 xor %eax,%eax
107da6: be 0a 00 00 00 mov $0xa,%esi
107dab: e9 5d fe ff ff jmp 107c0d <vprintk+0xed>
fmt++;
}
if ((c = *fmt) == 'l') {
lflag = 1;
c = *++fmt;
107db0: 8d 51 01 lea 0x1(%ecx),%edx
107db3: 89 55 08 mov %edx,0x8(%ebp)
107db6: 8a 51 01 mov 0x1(%ecx),%dl
107db9: e9 e1 fd ff ff jmp 107b9f <vprintk+0x7f>
107dbe: 66 90 xchg %ax,%ax
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = 1;
fmt++;
107dc0: 41 inc %ecx
107dc1: 8a 11 mov (%ecx),%dl
107dc3: c7 45 c8 01 00 00 00 movl $0x1,-0x38(%ebp)
}
while (*fmt >= '0' && *fmt <= '9' ) {
107dca: 8d 42 d0 lea -0x30(%edx),%eax
107dcd: 3c 09 cmp $0x9,%al
107dcf: 0f 86 a4 fd ff ff jbe 107b79 <vprintk+0x59> <== ALWAYS TAKEN
107dd5: 89 4d 08 mov %ecx,0x8(%ebp)
107dd8: 31 db xor %ebx,%ebx
107dda: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
107de1: e9 b0 fd ff ff jmp 107b96 <vprintk+0x76>
107de6: 66 90 xchg %ax,%ax
lead = ' ';
if (*fmt == '%') {
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
107de8: 8b 4d 08 mov 0x8(%ebp),%ecx
107deb: 83 c1 02 add $0x2,%ecx
107dee: 8b 45 08 mov 0x8(%ebp),%eax
107df1: 8a 50 02 mov 0x2(%eax),%dl
107df4: c7 45 c4 30 00 00 00 movl $0x30,-0x3c(%ebp)
107dfb: e9 5e fd ff ff jmp 107b5e <vprintk+0x3e>
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
107e00: 39 fb cmp %edi,%ebx
107e02: 0f 8e 1d ff ff ff jle 107d25 <vprintk+0x205> <== ALWAYS TAKEN
107e08: 89 fe mov %edi,%esi <== NOT EXECUTED
107e0a: 66 90 xchg %ax,%ax <== NOT EXECUTED
BSP_output_char(' ');
107e0c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107e0f: 6a 20 push $0x20 <== NOT EXECUTED
107e11: ff 15 a4 a1 11 00 call *0x11a1a4 <== NOT EXECUTED
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
107e17: 46 inc %esi <== NOT EXECUTED
107e18: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107e1b: 39 de cmp %ebx,%esi <== NOT EXECUTED
107e1d: 7c ed jl 107e0c <vprintk+0x2ec> <== NOT EXECUTED
107e1f: e9 08 ff ff ff jmp 107d2c <vprintk+0x20c> <== NOT EXECUTED
char *s;
str = va_arg(ap, char *);
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
107e24: 31 ff xor %edi,%edi <== NOT EXECUTED
107e26: e9 ef fe ff ff jmp 107d1a <vprintk+0x1fa> <== NOT EXECUTED
break;
case 'c':
BSP_output_char(va_arg(ap, int));
break;
default:
BSP_output_char(c);
107e2b: 31 c0 xor %eax,%eax
107e2d: be 10 00 00 00 mov $0x10,%esi
107e32: e9 d6 fd ff ff jmp 107c0d <vprintk+0xed>
001169a4 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
1169a4: 55 push %ebp
1169a5: 89 e5 mov %esp,%ebp
1169a7: 56 push %esi
1169a8: 53 push %ebx
1169a9: 8b 55 08 mov 0x8(%ebp),%edx
1169ac: 8b 75 0c mov 0xc(%ebp),%esi
1169af: 8b 4d 10 mov 0x10(%ebp),%ecx
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
1169b2: 3b 15 40 a0 11 00 cmp 0x11a040,%edx
1169b8: 73 56 jae 116a10 <write+0x6c> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
1169ba: 8d 04 52 lea (%edx,%edx,2),%eax
1169bd: 8d 04 82 lea (%edx,%eax,4),%eax
1169c0: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx
1169c7: 03 1d d0 e4 11 00 add 0x11e4d0,%ebx
rtems_libio_check_is_open( iop );
1169cd: 8b 43 0c mov 0xc(%ebx),%eax
1169d0: f6 c4 01 test $0x1,%ah
1169d3: 74 3b je 116a10 <write+0x6c> <== NEVER TAKEN
rtems_libio_check_buffer( buffer );
1169d5: 85 f6 test %esi,%esi
1169d7: 74 5b je 116a34 <write+0x90> <== NEVER TAKEN
rtems_libio_check_count( count );
1169d9: 85 c9 test %ecx,%ecx
1169db: 74 27 je 116a04 <write+0x60> <== NEVER TAKEN
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
1169dd: a8 04 test $0x4,%al
1169df: 74 2f je 116a10 <write+0x6c> <== NEVER TAKEN
/*
* Now process the write() request.
*/
if ( !iop->handlers->write_h )
1169e1: 8b 43 30 mov 0x30(%ebx),%eax
1169e4: 8b 40 0c mov 0xc(%eax),%eax
1169e7: 85 c0 test %eax,%eax
1169e9: 74 37 je 116a22 <write+0x7e> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
rc = (*iop->handlers->write_h)( iop, buffer, count );
1169eb: 52 push %edx
1169ec: 51 push %ecx
1169ed: 56 push %esi
1169ee: 53 push %ebx
1169ef: ff d0 call *%eax
if ( rc > 0 )
1169f1: 83 c4 10 add $0x10,%esp
1169f4: 85 c0 test %eax,%eax
1169f6: 7e 03 jle 1169fb <write+0x57> <== NEVER TAKEN
iop->offset += rc;
1169f8: 01 43 08 add %eax,0x8(%ebx)
return rc;
}
1169fb: 8d 65 f8 lea -0x8(%ebp),%esp
1169fe: 5b pop %ebx
1169ff: 5e pop %esi
116a00: c9 leave
116a01: c3 ret
116a02: 66 90 xchg %ax,%ax
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
116a04: 31 c0 xor %eax,%eax
if ( rc > 0 )
iop->offset += rc;
return rc;
}
116a06: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
116a09: 5b pop %ebx <== NOT EXECUTED
116a0a: 5e pop %esi <== NOT EXECUTED
116a0b: c9 leave <== NOT EXECUTED
116a0c: c3 ret <== NOT EXECUTED
116a0d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
116a10: e8 0b 98 ff ff call 110220 <__errno> <== NOT EXECUTED
116a15: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
116a1b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
116a20: eb d9 jmp 1169fb <write+0x57> <== NOT EXECUTED
/*
* Now process the write() request.
*/
if ( !iop->handlers->write_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
116a22: e8 f9 97 ff ff call 110220 <__errno> <== NOT EXECUTED
116a27: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
116a2d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
116a32: eb c7 jmp 1169fb <write+0x57> <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
116a34: e8 e7 97 ff ff call 110220 <__errno> <== NOT EXECUTED
116a39: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
116a3f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
116a44: eb b5 jmp 1169fb <write+0x57> <== NOT EXECUTED