RTEMS 4.9.6Annotated Report
Sun Jul 24 19:34:40 2011
0010c198 <IMFS_Set_handlers>:
#define MAXSYMLINK 5
int IMFS_Set_handlers(
rtems_filesystem_location_info_t *loc
)
{
10c198: 55 push %ebp
10c199: 89 e5 mov %esp,%ebp
10c19b: 8b 4d 08 mov 0x8(%ebp),%ecx
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
10c19e: 8b 41 0c mov 0xc(%ecx),%eax
10c1a1: 8b 50 2c mov 0x2c(%eax),%edx
switch( node->type ) {
10c1a4: 8b 01 mov (%ecx),%eax
10c1a6: 8b 40 4c mov 0x4c(%eax),%eax
10c1a9: 48 dec %eax
10c1aa: 83 f8 05 cmp $0x5,%eax
10c1ad: 77 24 ja 10c1d3 <IMFS_Set_handlers+0x3b><== NEVER TAKEN
10c1af: ff 24 85 50 6b 11 00 jmp *0x116b50(,%eax,4)
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
10c1b6: 8b 42 08 mov 0x8(%edx),%eax
10c1b9: eb 15 jmp 10c1d0 <IMFS_Set_handlers+0x38>
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
10c1bb: c7 41 04 44 6c 11 00 movl $0x116c44,0x4(%ecx)
10c1c2: eb 0f jmp 10c1d3 <IMFS_Set_handlers+0x3b>
break;
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
10c1c4: c7 41 04 7c 6c 11 00 movl $0x116c7c,0x4(%ecx) <== NOT EXECUTED
10c1cb: eb 06 jmp 10c1d3 <IMFS_Set_handlers+0x3b><== NOT EXECUTED
break;
case IMFS_LINEAR_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
10c1cd: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED
10c1d0: 89 41 04 mov %eax,0x4(%ecx)
break;
}
return 0;
}
10c1d3: 31 c0 xor %eax,%eax
10c1d5: c9 leave
10c1d6: c3 ret
0010e048 <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
10e048: 55 push %ebp
10e049: 89 e5 mov %esp,%ebp
10e04b: 57 push %edi
10e04c: 56 push %esi
10e04d: 53 push %ebx
10e04e: 83 ec 1c sub $0x1c,%esp
10e051: 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 )
10e054: 31 ff xor %edi,%edi
10e056: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
10e05a: 74 05 je 10e061 <IMFS_create_node+0x19>
parent = parent_loc->node_access;
10e05c: 8b 45 08 mov 0x8(%ebp),%eax
10e05f: 8b 38 mov (%eax),%edi
/*
* Allocate an IMFS jnode
*/
node = calloc( 1, sizeof( IMFS_jnode_t ) );
10e061: 50 push %eax
10e062: 50 push %eax
10e063: 6a 60 push $0x60
10e065: 6a 01 push $0x1
10e067: e8 98 eb ff ff call 10cc04 <calloc>
10e06c: 89 c3 mov %eax,%ebx
if ( !node )
10e06e: 83 c4 10 add $0x10,%esp
10e071: 85 c0 test %eax,%eax
10e073: 0f 84 fa 00 00 00 je 10e173 <IMFS_create_node+0x12b><== NEVER TAKEN
/*
* Fill in the basic information
*/
node->st_nlink = 1;
10e079: 66 c7 40 34 01 00 movw $0x1,0x34(%eax)
node->type = type;
10e07f: 8b 55 0c mov 0xc(%ebp),%edx
10e082: 89 50 4c mov %edx,0x4c(%eax)
strncpy( node->name, name, IMFS_NAME_MAX );
10e085: 50 push %eax
10e086: 6a 20 push $0x20
10e088: ff 75 10 pushl 0x10(%ebp)
10e08b: 8d 43 0c lea 0xc(%ebx),%eax
10e08e: 50 push %eax
10e08f: e8 c4 18 00 00 call 10f958 <strncpy>
/*
* Fill in the mode and permission information for the jnode structure.
*/
node->st_mode = mode & ~rtems_filesystem_umask;
10e094: a1 4c aa 11 00 mov 0x11aa4c,%eax
10e099: 8b 40 24 mov 0x24(%eax),%eax
10e09c: f7 d0 not %eax
10e09e: 21 c6 and %eax,%esi
10e0a0: 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;
10e0a3: 66 c7 43 3c 00 00 movw $0x0,0x3c(%ebx)
node->st_gid = 0;
10e0a9: 66 c7 43 3e 00 00 movw $0x0,0x3e(%ebx)
/*
* Now set all the times.
*/
gettimeofday( &tv, 0 );
10e0af: 5a pop %edx
10e0b0: 59 pop %ecx
10e0b1: 6a 00 push $0x0
10e0b3: 8d 45 ec lea -0x14(%ebp),%eax
10e0b6: 50 push %eax
10e0b7: e8 ac ec ff ff call 10cd68 <gettimeofday>
node->stat_atime = (time_t) tv.tv_sec;
10e0bc: 8b 45 ec mov -0x14(%ebp),%eax
10e0bf: 89 43 40 mov %eax,0x40(%ebx)
node->stat_mtime = (time_t) tv.tv_sec;
10e0c2: 89 43 44 mov %eax,0x44(%ebx)
node->stat_ctime = (time_t) tv.tv_sec;
10e0c5: 89 43 48 mov %eax,0x48(%ebx)
/*
* Set the type specific information
*/
switch (type) {
10e0c8: 83 c4 10 add $0x10,%esp
10e0cb: 8b 45 0c mov 0xc(%ebp),%eax
10e0ce: 48 dec %eax
10e0cf: 83 f8 05 cmp $0x5,%eax
10e0d2: 77 62 ja 10e136 <IMFS_create_node+0xee> <== NEVER TAKEN
10e0d4: ff 24 85 b4 6e 11 00 jmp *0x116eb4(,%eax,4)
10e0db: 8d 43 54 lea 0x54(%ebx),%eax
10e0de: 89 43 50 mov %eax,0x50(%ebx)
10e0e1: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx)
10e0e8: 8d 43 50 lea 0x50(%ebx),%eax
10e0eb: 89 43 58 mov %eax,0x58(%ebx)
10e0ee: eb 5c jmp 10e14c <IMFS_create_node+0x104>
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;
10e0f0: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED
10e0f3: 8b 02 mov (%edx),%eax <== NOT EXECUTED
10e0f5: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED
10e0f8: eb 52 jmp 10e14c <IMFS_create_node+0x104><== NOT EXECUTED
break;
case IMFS_DEVICE:
node->info.device.major = info->device.major;
10e0fa: 8b 55 18 mov 0x18(%ebp),%edx
10e0fd: 8b 02 mov (%edx),%eax
10e0ff: 89 43 50 mov %eax,0x50(%ebx)
node->info.device.minor = info->device.minor;
10e102: 8b 42 04 mov 0x4(%edx),%eax
10e105: 89 43 54 mov %eax,0x54(%ebx)
10e108: eb 42 jmp 10e14c <IMFS_create_node+0x104>
break;
case IMFS_LINEAR_FILE:
node->info.linearfile.size = 0;
10e10a: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED
node->info.linearfile.direct = 0;
10e111: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED
case IMFS_MEMORY_FILE:
node->info.file.size = 0;
10e118: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED
node->info.file.indirect = 0;
10e11f: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED
node->info.file.doubly_indirect = 0;
10e126: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED
node->info.file.triply_indirect = 0;
10e12d: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED
10e134: eb 16 jmp 10e14c <IMFS_create_node+0x104><== NOT EXECUTED
break;
default:
assert(0);
10e136: 68 63 61 11 00 push $0x116163 <== NOT EXECUTED
10e13b: 68 cc 6e 11 00 push $0x116ecc <== NOT EXECUTED
10e140: 6a 74 push $0x74 <== NOT EXECUTED
10e142: 68 64 6e 11 00 push $0x116e64 <== NOT EXECUTED
10e147: e8 3c 81 ff ff call 106288 <__assert_func> <== NOT EXECUTED
/*
* If this node has a parent, then put it in that directory list.
*/
if ( parent ) {
10e14c: 85 ff test %edi,%edi
10e14e: 74 23 je 10e173 <IMFS_create_node+0x12b>
10e150: 50 push %eax
10e151: 50 push %eax
10e152: 53 push %ebx
10e153: 8d 47 50 lea 0x50(%edi),%eax
10e156: 50 push %eax
10e157: e8 f0 b8 ff ff call 109a4c <_Chain_Append>
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
node->Parent = parent;
10e15c: 89 7b 08 mov %edi,0x8(%ebx)
fs_info = parent_loc->mt_entry->fs_info;
10e15f: 8b 55 08 mov 0x8(%ebp),%edx
10e162: 8b 42 0c mov 0xc(%edx),%eax
10e165: 8b 50 2c mov 0x2c(%eax),%edx
node->st_ino = ++fs_info->ino_count;
10e168: 8b 02 mov (%edx),%eax
10e16a: 40 inc %eax
10e16b: 89 02 mov %eax,(%edx)
10e16d: 89 43 38 mov %eax,0x38(%ebx)
10e170: 83 c4 10 add $0x10,%esp
}
return node;
}
10e173: 89 d8 mov %ebx,%eax
10e175: 8d 65 f4 lea -0xc(%ebp),%esp
10e178: 5b pop %ebx
10e179: 5e pop %esi
10e17a: 5f pop %edi
10e17b: c9 leave
10e17c: c3 ret
0010c30c <IMFS_eval_path>:
int IMFS_eval_path(
const char *pathname, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
10c30c: 55 push %ebp
10c30d: 89 e5 mov %esp,%ebp
10c30f: 57 push %edi
10c310: 56 push %esi
10c311: 53 push %ebx
10c312: 83 ec 4c sub $0x4c,%esp
10c315: 8b 5d 10 mov 0x10(%ebp),%ebx
char token[ IMFS_NAME_MAX + 1 ];
rtems_filesystem_location_info_t newloc;
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
10c318: f7 45 0c f8 ff ff ff testl $0xfffffff8,0xc(%ebp)
10c31f: 74 19 je 10c33a <IMFS_eval_path+0x2e> <== ALWAYS TAKEN
assert( 0 );
10c321: 68 63 61 11 00 push $0x116163 <== NOT EXECUTED
10c326: 68 68 6b 11 00 push $0x116b68 <== NOT EXECUTED
10c32b: 68 ea 01 00 00 push $0x1ea <== NOT EXECUTED
10c330: 68 77 6b 11 00 push $0x116b77 <== NOT EXECUTED
10c335: e8 4e 9f ff ff call 106288 <__assert_func> <== NOT EXECUTED
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
10c33a: 8b 33 mov (%ebx),%esi
10c33c: c7 45 b0 00 00 00 00 movl $0x0,-0x50(%ebp)
10c343: bf 01 00 00 00 mov $0x1,%edi
10c348: e9 1d 01 00 00 jmp 10c46a <IMFS_eval_path+0x15e>
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], token, &len );
10c34d: 50 push %eax
10c34e: 8d 45 f0 lea -0x10(%ebp),%eax
10c351: 50 push %eax
10c352: 8d 45 bf lea -0x41(%ebp),%eax
10c355: 50 push %eax
10c356: 8b 45 08 mov 0x8(%ebp),%eax
10c359: 03 45 b0 add -0x50(%ebp),%eax
10c35c: 50 push %eax
10c35d: e8 72 04 00 00 call 10c7d4 <IMFS_get_token>
10c362: 89 c7 mov %eax,%edi
i += len;
10c364: 8b 45 f0 mov -0x10(%ebp),%eax
10c367: 89 45 ac mov %eax,-0x54(%ebp)
if ( !pathloc->node_access )
10c36a: 83 c4 10 add $0x10,%esp
10c36d: 83 3b 00 cmpl $0x0,(%ebx)
10c370: 0f 84 d0 00 00 00 je 10c446 <IMFS_eval_path+0x13a> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
10c376: 85 ff test %edi,%edi
10c378: 74 1b je 10c395 <IMFS_eval_path+0x89>
if ( node->type == IMFS_DIRECTORY )
10c37a: 83 7e 4c 01 cmpl $0x1,0x4c(%esi)
10c37e: 75 15 jne 10c395 <IMFS_eval_path+0x89> <== NEVER TAKEN
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
10c380: 50 push %eax
10c381: 50 push %eax
10c382: 6a 01 push $0x1
10c384: 53 push %ebx
10c385: e8 4d fe ff ff call 10c1d7 <IMFS_evaluate_permission>
10c38a: 83 c4 10 add $0x10,%esp
10c38d: 85 c0 test %eax,%eax
10c38f: 0f 84 3c 01 00 00 je 10c4d1 <IMFS_eval_path+0x1c5> <== NEVER TAKEN
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], token, &len );
i += len;
10c395: 8b 45 ac mov -0x54(%ebp),%eax
10c398: 01 45 b0 add %eax,-0x50(%ebp)
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
10c39b: 8b 33 mov (%ebx),%esi
switch( type ) {
10c39d: 83 ff 03 cmp $0x3,%edi
10c3a0: 74 34 je 10c3d6 <IMFS_eval_path+0xca>
10c3a2: 83 ff 04 cmp $0x4,%edi
10c3a5: 0f 84 b2 00 00 00 je 10c45d <IMFS_eval_path+0x151> <== NEVER TAKEN
10c3ab: 83 ff 02 cmp $0x2,%edi
10c3ae: 0f 85 b6 00 00 00 jne 10c46a <IMFS_eval_path+0x15e> <== ALWAYS TAKEN
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
10c3b4: a1 4c aa 11 00 mov 0x11aa4c,%eax <== NOT EXECUTED
10c3b9: 3b 70 14 cmp 0x14(%eax),%esi <== NOT EXECUTED
10c3bc: 74 8f je 10c34d <IMFS_eval_path+0x41> <== NOT EXECUTED
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
10c3be: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED
10c3c1: 3b 70 18 cmp 0x18(%eax),%esi <== NOT EXECUTED
10c3c4: 75 0b jne 10c3d1 <IMFS_eval_path+0xc5> <== 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;
10c3c6: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED
10c3c9: 8d 70 08 lea 0x8(%eax),%esi <== NOT EXECUTED
10c3cc: e9 b9 00 00 00 jmp 10c48a <IMFS_eval_path+0x17e> <== NOT EXECUTED
*pathloc = newloc;
return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),flags,pathloc);
}
} else {
if ( !node->Parent )
10c3d1: 8b 76 08 mov 0x8(%esi),%esi <== NOT EXECUTED
10c3d4: eb 6c jmp 10c442 <IMFS_eval_path+0x136> <== NOT EXECUTED
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
10c3d6: 8b 46 4c mov 0x4c(%esi),%eax
10c3d9: 83 f8 03 cmp $0x3,%eax
10c3dc: 75 15 jne 10c3f3 <IMFS_eval_path+0xe7> <== ALWAYS TAKEN
IMFS_evaluate_hard_link( pathloc, 0 );
10c3de: 50 push %eax <== NOT EXECUTED
10c3df: 50 push %eax <== NOT EXECUTED
10c3e0: 6a 00 push $0x0 <== NOT EXECUTED
10c3e2: 53 push %ebx <== NOT EXECUTED
10c3e3: e8 28 fe ff ff call 10c210 <IMFS_evaluate_hard_link><== NOT EXECUTED
node = pathloc->node_access;
10c3e8: 8b 33 mov (%ebx),%esi <== NOT EXECUTED
if ( !node )
10c3ea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c3ed: 85 f6 test %esi,%esi <== NOT EXECUTED
10c3ef: 75 23 jne 10c414 <IMFS_eval_path+0x108> <== NOT EXECUTED
10c3f1: eb 27 jmp 10c41a <IMFS_eval_path+0x10e> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTDIR );
} else if ( node->type == IMFS_SYM_LINK ) {
10c3f3: 83 f8 04 cmp $0x4,%eax
10c3f6: 75 1c jne 10c414 <IMFS_eval_path+0x108> <== ALWAYS TAKEN
result = IMFS_evaluate_sym_link( pathloc, 0 );
10c3f8: 50 push %eax <== NOT EXECUTED
10c3f9: 50 push %eax <== NOT EXECUTED
10c3fa: 6a 00 push $0x0 <== NOT EXECUTED
10c3fc: 53 push %ebx <== NOT EXECUTED
10c3fd: e8 60 fe ff ff call 10c262 <IMFS_evaluate_sym_link><== NOT EXECUTED
10c402: 89 c6 mov %eax,%esi <== NOT EXECUTED
node = pathloc->node_access;
10c404: 8b 03 mov (%ebx),%eax <== NOT EXECUTED
if ( result == -1 )
10c406: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c409: 83 fe ff cmp $0xffffffff,%esi <== NOT EXECUTED
10c40c: 0f 84 cd 00 00 00 je 10c4df <IMFS_eval_path+0x1d3> <== NOT EXECUTED
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
node = pathloc->node_access;
10c412: 89 c6 mov %eax,%esi <== NOT EXECUTED
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10c414: 83 7e 4c 01 cmpl $0x1,0x4c(%esi)
10c418: 74 10 je 10c42a <IMFS_eval_path+0x11e> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
10c41a: e8 b1 22 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10c41f: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
10c425: e9 b2 00 00 00 jmp 10c4dc <IMFS_eval_path+0x1d0> <== 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 ) {
10c42a: 8b 46 5c mov 0x5c(%esi),%eax
10c42d: 85 c0 test %eax,%eax
10c42f: 75 53 jne 10c484 <IMFS_eval_path+0x178> <== NEVER TAKEN
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10c431: 57 push %edi
10c432: 57 push %edi
10c433: 8d 45 bf lea -0x41(%ebp),%eax
10c436: 50 push %eax
10c437: 56 push %esi
10c438: e8 0b 03 00 00 call 10c748 <IMFS_find_match_in_dir>
10c43d: 89 c6 mov %eax,%esi
if ( !node )
10c43f: 83 c4 10 add $0x10,%esp
10c442: 85 f6 test %esi,%esi
10c444: 75 10 jne 10c456 <IMFS_eval_path+0x14a> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOENT );
10c446: e8 85 22 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10c44b: c7 00 02 00 00 00 movl $0x2,(%eax) <== NOT EXECUTED
10c451: e9 86 00 00 00 jmp 10c4dc <IMFS_eval_path+0x1d0> <== NOT EXECUTED
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
10c456: 89 33 mov %esi,(%ebx)
10c458: e9 f0 fe ff ff jmp 10c34d <IMFS_eval_path+0x41>
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
10c45d: e8 6e 22 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10c462: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED
10c468: eb 72 jmp 10c4dc <IMFS_eval_path+0x1d0> <== NOT EXECUTED
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
10c46a: 85 ff test %edi,%edi
10c46c: 74 09 je 10c477 <IMFS_eval_path+0x16b>
10c46e: 83 ff 04 cmp $0x4,%edi
10c471: 0f 85 d6 fe ff ff jne 10c34d <IMFS_eval_path+0x41> <== ALWAYS TAKEN
* new fs root node and let let the mounted filesystem set the handlers.
*
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
10c477: 83 7e 4c 01 cmpl $0x1,0x4c(%esi)
10c47b: 75 3b jne 10c4b8 <IMFS_eval_path+0x1ac>
if ( node->info.directory.mt_fs != NULL ) {
10c47d: 8b 46 5c mov 0x5c(%esi),%eax
10c480: 85 c0 test %eax,%eax
10c482: 74 34 je 10c4b8 <IMFS_eval_path+0x1ac> <== ALWAYS TAKEN
newloc = node->info.directory.mt_fs->mt_fs_root;
10c484: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED
10c487: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED
10c48a: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
10c48f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
*pathloc = newloc;
10c491: 8d 75 e0 lea -0x20(%ebp),%esi <== NOT EXECUTED
10c494: b1 04 mov $0x4,%cl <== NOT EXECUTED
10c496: 89 df mov %ebx,%edi <== NOT EXECUTED
10c498: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc );
10c49a: 56 push %esi <== NOT EXECUTED
10c49b: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED
10c49e: 53 push %ebx <== NOT EXECUTED
10c49f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
10c4a2: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED
10c4a5: 29 45 b0 sub %eax,-0x50(%ebp) <== NOT EXECUTED
10c4a8: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10c4ab: 03 45 b0 add -0x50(%ebp),%eax <== NOT EXECUTED
10c4ae: 50 push %eax <== NOT EXECUTED
10c4af: ff 12 call *(%edx) <== NOT EXECUTED
10c4b1: 89 c6 mov %eax,%esi <== NOT EXECUTED
10c4b3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c4b6: eb 27 jmp 10c4df <IMFS_eval_path+0x1d3> <== NOT EXECUTED
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
10c4b8: 53 push %ebx
10c4b9: e8 da fc ff ff call 10c198 <IMFS_Set_handlers>
10c4be: 89 c6 mov %eax,%esi
10c4c0: 51 push %ecx
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
10c4c1: ff 75 0c pushl 0xc(%ebp)
10c4c4: 53 push %ebx
10c4c5: e8 0d fd ff ff call 10c1d7 <IMFS_evaluate_permission>
10c4ca: 83 c4 10 add $0x10,%esp
10c4cd: 85 c0 test %eax,%eax
10c4cf: 75 0e jne 10c4df <IMFS_eval_path+0x1d3> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EACCES );
10c4d1: e8 fa 21 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10c4d6: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED
10c4dc: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED
return result;
}
10c4df: 89 f0 mov %esi,%eax
10c4e1: 8d 65 f4 lea -0xc(%ebp),%esp
10c4e4: 5b pop %ebx
10c4e5: 5e pop %esi
10c4e6: 5f pop %edi
10c4e7: c9 leave
10c4e8: c3 ret
0010c570 <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 */
)
{
10c570: 55 push %ebp
10c571: 89 e5 mov %esp,%ebp
10c573: 57 push %edi
10c574: 56 push %esi
10c575: 53 push %ebx
10c576: 83 ec 4c sub $0x4c,%esp
10c579: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
10c57c: 8b 33 mov (%ebx),%esi
10c57e: 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 );
10c585: 50 push %eax
10c586: 8d 45 f0 lea -0x10(%ebp),%eax
10c589: 50 push %eax
10c58a: 8d 55 bf lea -0x41(%ebp),%edx
10c58d: 52 push %edx
10c58e: 8b 45 08 mov 0x8(%ebp),%eax
10c591: 03 45 b0 add -0x50(%ebp),%eax
10c594: 50 push %eax
10c595: e8 3a 02 00 00 call 10c7d4 <IMFS_get_token>
10c59a: 89 c7 mov %eax,%edi
i += len;
10c59c: 8b 45 f0 mov -0x10(%ebp),%eax
10c59f: 89 45 ac mov %eax,-0x54(%ebp)
if ( !pathloc->node_access )
10c5a2: 83 c4 10 add $0x10,%esp
10c5a5: 83 3b 00 cmpl $0x0,(%ebx)
10c5a8: 0f 84 40 01 00 00 je 10c6ee <IMFS_evaluate_for_make+0x17e><== NEVER TAKEN
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
10c5ae: 85 ff test %edi,%edi
10c5b0: 74 1b je 10c5cd <IMFS_evaluate_for_make+0x5d><== NEVER TAKEN
if ( node->type == IMFS_DIRECTORY )
10c5b2: 83 7e 4c 01 cmpl $0x1,0x4c(%esi)
10c5b6: 75 15 jne 10c5cd <IMFS_evaluate_for_make+0x5d><== NEVER TAKEN
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
10c5b8: 50 push %eax
10c5b9: 50 push %eax
10c5ba: 6a 01 push $0x1
10c5bc: 53 push %ebx
10c5bd: e8 15 fc ff ff call 10c1d7 <IMFS_evaluate_permission>
10c5c2: 83 c4 10 add $0x10,%esp
10c5c5: 85 c0 test %eax,%eax
10c5c7: 0f 84 63 01 00 00 je 10c730 <IMFS_evaluate_for_make+0x1c0><== NEVER TAKEN
*/
while( !done ) {
type = IMFS_get_token( &path[i], token, &len );
i += len;
10c5cd: 8b 55 ac mov -0x54(%ebp),%edx
10c5d0: 01 55 b0 add %edx,-0x50(%ebp)
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
10c5d3: 8b 33 mov (%ebx),%esi
switch( type ) {
10c5d5: 83 ff 02 cmp $0x2,%edi
10c5d8: 74 1b je 10c5f5 <IMFS_evaluate_for_make+0x85><== NEVER TAKEN
10c5da: 77 0a ja 10c5e6 <IMFS_evaluate_for_make+0x76>
10c5dc: 85 ff test %edi,%edi
10c5de: 0f 84 cf 00 00 00 je 10c6b3 <IMFS_evaluate_for_make+0x143><== NEVER TAKEN
10c5e4: eb 9f jmp 10c585 <IMFS_evaluate_for_make+0x15>
10c5e6: 83 ff 03 cmp $0x3,%edi
10c5e9: 74 34 je 10c61f <IMFS_evaluate_for_make+0xaf><== ALWAYS TAKEN
10c5eb: 83 ff 04 cmp $0x4,%edi <== NOT EXECUTED
10c5ee: 75 95 jne 10c585 <IMFS_evaluate_for_make+0x15><== NOT EXECUTED
10c5f0: e9 cb 00 00 00 jmp 10c6c0 <IMFS_evaluate_for_make+0x150><== NOT EXECUTED
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
10c5f5: a1 4c aa 11 00 mov 0x11aa4c,%eax <== NOT EXECUTED
10c5fa: 3b 70 14 cmp 0x14(%eax),%esi <== NOT EXECUTED
10c5fd: 74 86 je 10c585 <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){
10c5ff: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED
10c602: 3b 70 18 cmp 0x18(%eax),%esi <== NOT EXECUTED
10c605: 75 08 jne 10c60f <IMFS_evaluate_for_make+0x9f><== NOT EXECUTED
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
10c607: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED
10c60a: 8d 70 08 lea 0x8(%eax),%esi <== NOT EXECUTED
10c60d: eb 56 jmp 10c665 <IMFS_evaluate_for_make+0xf5><== NOT EXECUTED
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
10c60f: 8b 76 08 mov 0x8(%esi),%esi <== NOT EXECUTED
10c612: 85 f6 test %esi,%esi <== NOT EXECUTED
10c614: 0f 85 92 00 00 00 jne 10c6ac <IMFS_evaluate_for_make+0x13c><== NOT EXECUTED
10c61a: e9 cf 00 00 00 jmp 10c6ee <IMFS_evaluate_for_make+0x17e><== NOT EXECUTED
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
10c61f: 8b 46 4c mov 0x4c(%esi),%eax
10c622: 83 f8 03 cmp $0x3,%eax
10c625: 74 05 je 10c62c <IMFS_evaluate_for_make+0xbc><== NEVER TAKEN
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
10c627: 83 f8 04 cmp $0x4,%eax
10c62a: 75 18 jne 10c644 <IMFS_evaluate_for_make+0xd4><== ALWAYS TAKEN
result = IMFS_evaluate_link( pathloc, 0 );
10c62c: 50 push %eax <== NOT EXECUTED
10c62d: 50 push %eax <== NOT EXECUTED
10c62e: 6a 00 push $0x0 <== NOT EXECUTED
10c630: 53 push %ebx <== NOT EXECUTED
10c631: e8 b3 fe ff ff call 10c4e9 <IMFS_evaluate_link> <== NOT EXECUTED
10c636: 89 c6 mov %eax,%esi <== NOT EXECUTED
if ( result == -1 )
10c638: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c63b: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED
10c63e: 0f 84 fa 00 00 00 je 10c73e <IMFS_evaluate_for_make+0x1ce><== NOT EXECUTED
return -1;
}
node = pathloc->node_access;
10c644: 8b 03 mov (%ebx),%eax
if ( !node )
10c646: 85 c0 test %eax,%eax
10c648: 0f 84 c4 00 00 00 je 10c712 <IMFS_evaluate_for_make+0x1a2><== NEVER TAKEN
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10c64e: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
10c652: 0f 85 ba 00 00 00 jne 10c712 <IMFS_evaluate_for_make+0x1a2><== 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 ) {
10c658: 8b 50 5c mov 0x5c(%eax),%edx
10c65b: 85 d2 test %edx,%edx
10c65d: 74 38 je 10c697 <IMFS_evaluate_for_make+0x127><== ALWAYS TAKEN
newloc = node->info.directory.mt_fs->mt_fs_root;
10c65f: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED
10c662: 8d 72 18 lea 0x18(%edx),%esi <== NOT EXECUTED
10c665: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
10c66a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
*pathloc = newloc;
10c66c: 8d 75 e0 lea -0x20(%ebp),%esi <== NOT EXECUTED
10c66f: b1 04 mov $0x4,%cl <== NOT EXECUTED
10c671: 89 df mov %ebx,%edi <== NOT EXECUTED
10c673: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
10c675: 57 push %edi <== NOT EXECUTED
10c676: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED
10c679: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED
10c67c: 53 push %ebx <== NOT EXECUTED
10c67d: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED
10c680: 29 45 b0 sub %eax,-0x50(%ebp) <== NOT EXECUTED
10c683: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10c686: 03 45 b0 add -0x50(%ebp),%eax <== NOT EXECUTED
10c689: 50 push %eax <== NOT EXECUTED
10c68a: ff 52 04 call *0x4(%edx) <== NOT EXECUTED
10c68d: 89 c6 mov %eax,%esi <== NOT EXECUTED
10c68f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c692: e9 a7 00 00 00 jmp 10c73e <IMFS_evaluate_for_make+0x1ce><== NOT EXECUTED
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10c697: 56 push %esi
10c698: 56 push %esi
10c699: 8d 55 bf lea -0x41(%ebp),%edx
10c69c: 52 push %edx
10c69d: 50 push %eax
10c69e: e8 a5 00 00 00 call 10c748 <IMFS_find_match_in_dir>
10c6a3: 89 c6 mov %eax,%esi
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
10c6a5: 83 c4 10 add $0x10,%esp
10c6a8: 85 c0 test %eax,%eax
10c6aa: 74 21 je 10c6cd <IMFS_evaluate_for_make+0x15d>
done = true;
else
pathloc->node_access = node;
10c6ac: 89 33 mov %esi,(%ebx)
10c6ae: e9 d2 fe ff ff jmp 10c585 <IMFS_evaluate_for_make+0x15>
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
10c6b3: e8 18 20 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10c6b8: c7 00 11 00 00 00 movl $0x11,(%eax) <== NOT EXECUTED
10c6be: eb 7b jmp 10c73b <IMFS_evaluate_for_make+0x1cb><== NOT EXECUTED
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
10c6c0: e8 0b 20 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10c6c5: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED
10c6cb: eb 6e jmp 10c73b <IMFS_evaluate_for_make+0x1cb><== NOT EXECUTED
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
10c6cd: 8b 45 b0 mov -0x50(%ebp),%eax
10c6d0: 2b 45 f0 sub -0x10(%ebp),%eax
10c6d3: 03 45 08 add 0x8(%ebp),%eax
10c6d6: 8b 55 10 mov 0x10(%ebp),%edx
10c6d9: 89 02 mov %eax,(%edx)
10c6db: 8b 45 08 mov 0x8(%ebp),%eax
10c6de: 03 45 b0 add -0x50(%ebp),%eax
10c6e1: eb 18 jmp 10c6fb <IMFS_evaluate_for_make+0x18b>
/*
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++) {
10c6e3: 40 inc %eax <== NOT EXECUTED
if ( !IMFS_is_separator( path[ i ] ) )
10c6e4: 80 fa 2f cmp $0x2f,%dl <== NOT EXECUTED
10c6e7: 74 12 je 10c6fb <IMFS_evaluate_for_make+0x18b><== NOT EXECUTED
10c6e9: 80 fa 5c cmp $0x5c,%dl <== NOT EXECUTED
10c6ec: 74 0d je 10c6fb <IMFS_evaluate_for_make+0x18b><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOENT );
10c6ee: e8 dd 1f 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10c6f3: c7 00 02 00 00 00 movl $0x2,(%eax) <== NOT EXECUTED
10c6f9: eb 40 jmp 10c73b <IMFS_evaluate_for_make+0x1cb><== NOT EXECUTED
/*
* 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++) {
10c6fb: 8a 10 mov (%eax),%dl
10c6fd: 84 d2 test %dl,%dl
10c6ff: 75 e2 jne 10c6e3 <IMFS_evaluate_for_make+0x173><== NEVER TAKEN
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
10c701: 53 push %ebx
10c702: e8 91 fa ff ff call 10c198 <IMFS_Set_handlers>
10c707: 89 c6 mov %eax,%esi
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
10c709: 8b 03 mov (%ebx),%eax
10c70b: 59 pop %ecx
10c70c: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
10c710: 74 0d je 10c71f <IMFS_evaluate_for_make+0x1af><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
10c712: e8 b9 1f 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10c717: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
10c71d: eb 1c jmp 10c73b <IMFS_evaluate_for_make+0x1cb><== NOT EXECUTED
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
10c71f: 52 push %edx
10c720: 52 push %edx
10c721: 6a 03 push $0x3
10c723: 53 push %ebx
10c724: e8 ae fa ff ff call 10c1d7 <IMFS_evaluate_permission>
10c729: 83 c4 10 add $0x10,%esp
10c72c: 85 c0 test %eax,%eax
10c72e: 75 0e jne 10c73e <IMFS_evaluate_for_make+0x1ce><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EACCES );
10c730: e8 9b 1f 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10c735: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED
10c73b: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED
return result;
}
10c73e: 89 f0 mov %esi,%eax
10c740: 8d 65 f4 lea -0xc(%ebp),%esp
10c743: 5b pop %ebx
10c744: 5e pop %esi
10c745: 5f pop %edi
10c746: c9 leave
10c747: c3 ret
0010c210 <IMFS_evaluate_hard_link>:
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
10c210: 55 push %ebp <== NOT EXECUTED
10c211: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10c213: 53 push %ebx <== NOT EXECUTED
10c214: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED
10c217: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
IMFS_jnode_t *jnode = node->node_access;
10c21a: 8b 03 mov (%ebx),%eax <== NOT EXECUTED
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_HARD_LINK )
10c21c: 83 78 4c 03 cmpl $0x3,0x4c(%eax) <== NOT EXECUTED
10c220: 74 0d je 10c22f <IMFS_evaluate_hard_link+0x1f><== NOT EXECUTED
rtems_fatal_error_occurred (0xABCD0000);
10c222: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c225: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED
10c22a: e8 5d d5 ff ff call 10978c <rtems_fatal_error_occurred><== NOT EXECUTED
/*
* Set the hard link value and the handlers.
*/
node->node_access = jnode->info.hard_link.link_node;
10c22f: 8b 40 50 mov 0x50(%eax),%eax <== NOT EXECUTED
10c232: 89 03 mov %eax,(%ebx) <== NOT EXECUTED
IMFS_Set_handlers( node );
10c234: 53 push %ebx <== NOT EXECUTED
10c235: e8 5e ff ff ff call 10c198 <IMFS_Set_handlers> <== NOT EXECUTED
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
10c23a: 50 push %eax <== NOT EXECUTED
10c23b: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
10c23e: 53 push %ebx <== NOT EXECUTED
10c23f: e8 93 ff ff ff call 10c1d7 <IMFS_evaluate_permission><== NOT EXECUTED
10c244: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c247: 31 d2 xor %edx,%edx <== NOT EXECUTED
10c249: 85 c0 test %eax,%eax <== NOT EXECUTED
10c24b: 75 0e jne 10c25b <IMFS_evaluate_hard_link+0x4b><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EACCES );
10c24d: e8 7e 24 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10c252: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED
10c258: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED
return result;
}
10c25b: 89 d0 mov %edx,%eax <== NOT EXECUTED
10c25d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10c260: c9 leave <== NOT EXECUTED
10c261: c3 ret <== NOT EXECUTED
0010c4e9 <IMFS_evaluate_link>:
int IMFS_evaluate_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
10c4e9: 55 push %ebp <== NOT EXECUTED
10c4ea: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10c4ec: 57 push %edi <== NOT EXECUTED
10c4ed: 56 push %esi <== NOT EXECUTED
10c4ee: 53 push %ebx <== NOT EXECUTED
10c4ef: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c4f2: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
10c4f5: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED
IMFS_jnode_t *jnode;
int result = 0;
do {
jnode = node->node_access;
10c4f8: 8b 33 mov (%ebx),%esi <== NOT EXECUTED
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
10c4fa: 8b 15 4c aa 11 00 mov 0x11aa4c,%edx <== NOT EXECUTED
10c500: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED
10c503: 40 inc %eax <== NOT EXECUTED
10c504: 66 89 42 28 mov %ax,0x28(%edx) <== NOT EXECUTED
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
10c508: 66 83 f8 05 cmp $0x5,%ax <== NOT EXECUTED
10c50c: 76 16 jbe 10c524 <IMFS_evaluate_link+0x3b><== NOT EXECUTED
rtems_filesystem_link_counts = 0;
10c50e: 66 c7 42 28 00 00 movw $0x0,0x28(%edx) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ELOOP );
10c514: e8 b7 21 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10c519: c7 00 5c 00 00 00 movl $0x5c,(%eax) <== NOT EXECUTED
10c51f: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED
10c522: eb 42 jmp 10c566 <IMFS_evaluate_link+0x7d><== NOT EXECUTED
/*
* Follow the Link node.
*/
if ( jnode->type == IMFS_HARD_LINK )
10c524: 8b 46 4c mov 0x4c(%esi),%eax <== NOT EXECUTED
10c527: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED
10c52a: 75 0b jne 10c537 <IMFS_evaluate_link+0x4e><== NOT EXECUTED
result = IMFS_evaluate_hard_link( node, flags );
10c52c: 50 push %eax <== NOT EXECUTED
10c52d: 50 push %eax <== NOT EXECUTED
10c52e: 57 push %edi <== NOT EXECUTED
10c52f: 53 push %ebx <== NOT EXECUTED
10c530: e8 db fc ff ff call 10c210 <IMFS_evaluate_hard_link><== NOT EXECUTED
10c535: eb 0e jmp 10c545 <IMFS_evaluate_link+0x5c><== NOT EXECUTED
else if (jnode->type == IMFS_SYM_LINK )
10c537: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED
10c53a: 75 12 jne 10c54e <IMFS_evaluate_link+0x65><== NOT EXECUTED
result = IMFS_evaluate_sym_link( node, flags );
10c53c: 50 push %eax <== NOT EXECUTED
10c53d: 50 push %eax <== NOT EXECUTED
10c53e: 57 push %edi <== NOT EXECUTED
10c53f: 53 push %ebx <== NOT EXECUTED
10c540: e8 1d fd ff ff call 10c262 <IMFS_evaluate_sym_link><== NOT EXECUTED
10c545: 89 c2 mov %eax,%edx <== NOT EXECUTED
10c547: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
( jnode->type == IMFS_HARD_LINK ) ) );
10c54a: 85 c0 test %eax,%eax <== NOT EXECUTED
10c54c: 75 0d jne 10c55b <IMFS_evaluate_link+0x72><== NOT EXECUTED
10c54e: 8b 46 4c mov 0x4c(%esi),%eax <== NOT EXECUTED
10c551: 83 e8 03 sub $0x3,%eax <== NOT EXECUTED
10c554: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED
10c557: 76 9f jbe 10c4f8 <IMFS_evaluate_link+0xf><== NOT EXECUTED
10c559: 31 d2 xor %edx,%edx <== NOT EXECUTED
/*
* Clear link counter.
*/
rtems_filesystem_link_counts = 0;
10c55b: a1 4c aa 11 00 mov 0x11aa4c,%eax <== NOT EXECUTED
10c560: 66 c7 40 28 00 00 movw $0x0,0x28(%eax) <== NOT EXECUTED
return result;
}
10c566: 89 d0 mov %edx,%eax <== NOT EXECUTED
10c568: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10c56b: 5b pop %ebx <== NOT EXECUTED
10c56c: 5e pop %esi <== NOT EXECUTED
10c56d: 5f pop %edi <== NOT EXECUTED
10c56e: c9 leave <== NOT EXECUTED
10c56f: c3 ret <== NOT EXECUTED
0010c1d7 <IMFS_evaluate_permission>:
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
10c1d7: 55 push %ebp
10c1d8: 89 e5 mov %esp,%ebp
10c1da: 83 ec 08 sub $0x8,%esp
10c1dd: 8b 45 0c mov 0xc(%ebp),%eax
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
10c1e0: a9 f8 ff ff ff test $0xfffffff8,%eax
10c1e5: 74 10 je 10c1f7 <IMFS_evaluate_permission+0x20><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
10c1e7: e8 e4 24 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10c1ec: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
10c1f2: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10c1f5: eb 17 jmp 10c20e <IMFS_evaluate_permission+0x37><== NOT EXECUTED
/*
* If all of the flags are set we have permission
* to do this.
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
10c1f7: 89 c2 mov %eax,%edx
10c1f9: c1 e2 06 shl $0x6,%edx
10c1fc: 8b 45 08 mov 0x8(%ebp),%eax
10c1ff: 8b 00 mov (%eax),%eax
10c201: 8b 40 30 mov 0x30(%eax),%eax
10c204: 21 d0 and %edx,%eax
10c206: 39 d0 cmp %edx,%eax
10c208: 0f 94 c0 sete %al
10c20b: 0f b6 c0 movzbl %al,%eax
return 1;
return 0;
}
10c20e: c9 leave
10c20f: c3 ret
0010c262 <IMFS_evaluate_sym_link>:
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
10c262: 55 push %ebp <== NOT EXECUTED
10c263: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10c265: 57 push %edi <== NOT EXECUTED
10c266: 56 push %esi <== NOT EXECUTED
10c267: 53 push %ebx <== NOT EXECUTED
10c268: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
IMFS_jnode_t *jnode = node->node_access;
10c26b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
10c26e: 8b 02 mov (%edx),%eax <== NOT EXECUTED
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_SYM_LINK )
10c270: 83 78 4c 04 cmpl $0x4,0x4c(%eax) <== NOT EXECUTED
10c274: 74 0a je 10c280 <IMFS_evaluate_sym_link+0x1e><== NOT EXECUTED
rtems_fatal_error_occurred (0xABCD0000);
10c276: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c279: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED
10c27e: eb 0f jmp 10c28f <IMFS_evaluate_sym_link+0x2d><== NOT EXECUTED
if ( !jnode->Parent )
10c280: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED
10c283: 85 d2 test %edx,%edx <== NOT EXECUTED
10c285: 75 0d jne 10c294 <IMFS_evaluate_sym_link+0x32><== NOT EXECUTED
rtems_fatal_error_occurred( 0xBAD00000 );
10c287: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c28a: 68 00 00 d0 ba push $0xbad00000 <== NOT EXECUTED
10c28f: e8 f8 d4 ff ff call 10978c <rtems_fatal_error_occurred><== NOT EXECUTED
/*
* Move the node_access to either the symbolic links parent or
* root depending on the symbolic links path.
*/
node->node_access = jnode->Parent;
10c294: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
10c297: 89 11 mov %edx,(%ecx) <== NOT EXECUTED
rtems_filesystem_get_sym_start_loc(
10c299: 8b 58 50 mov 0x50(%eax),%ebx <== NOT EXECUTED
10c29c: 8a 13 mov (%ebx),%dl <== NOT EXECUTED
10c29e: 80 fa 2f cmp $0x2f,%dl <== NOT EXECUTED
10c2a1: 74 0b je 10c2ae <IMFS_evaluate_sym_link+0x4c><== NOT EXECUTED
10c2a3: 80 fa 5c cmp $0x5c,%dl <== NOT EXECUTED
10c2a6: 74 06 je 10c2ae <IMFS_evaluate_sym_link+0x4c><== NOT EXECUTED
10c2a8: 31 c0 xor %eax,%eax <== NOT EXECUTED
10c2aa: 84 d2 test %dl,%dl <== NOT EXECUTED
10c2ac: 75 17 jne 10c2c5 <IMFS_evaluate_sym_link+0x63><== NOT EXECUTED
10c2ae: a1 4c aa 11 00 mov 0x11aa4c,%eax <== NOT EXECUTED
10c2b3: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED
10c2b6: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
10c2bb: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED
10c2be: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
10c2c0: 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(
10c2c5: 52 push %edx <== NOT EXECUTED
10c2c6: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
10c2c9: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
10c2cc: 8d 04 03 lea (%ebx,%eax,1),%eax <== NOT EXECUTED
10c2cf: 50 push %eax <== NOT EXECUTED
10c2d0: e8 37 00 00 00 call 10c30c <IMFS_eval_path> <== NOT EXECUTED
10c2d5: 89 c6 mov %eax,%esi <== NOT EXECUTED
&jnode->info.sym_link.name[i],
flags,
node
);
IMFS_Set_handlers( node );
10c2d7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
10c2da: e8 b9 fe ff ff call 10c198 <IMFS_Set_handlers> <== NOT EXECUTED
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
10c2df: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10c2e2: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
10c2e5: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
10c2e8: e8 ea fe ff ff call 10c1d7 <IMFS_evaluate_permission><== NOT EXECUTED
10c2ed: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c2f0: 85 c0 test %eax,%eax <== NOT EXECUTED
10c2f2: 75 0e jne 10c302 <IMFS_evaluate_sym_link+0xa0><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EACCES );
10c2f4: e8 d7 23 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10c2f9: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED
10c2ff: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED
return result;
}
10c302: 89 f0 mov %esi,%eax <== NOT EXECUTED
10c304: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10c307: 5b pop %ebx <== NOT EXECUTED
10c308: 5e pop %esi <== NOT EXECUTED
10c309: 5f pop %edi <== NOT EXECUTED
10c30a: c9 leave <== NOT EXECUTED
10c30b: c3 ret <== NOT EXECUTED
0010e180 <IMFS_fchmod>:
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
10e180: 55 push %ebp <== NOT EXECUTED
10e181: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10e183: 53 push %ebx <== NOT EXECUTED
10e184: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED
10e187: 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;
10e18a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10e18d: 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 ) ) )
10e18f: f7 c2 00 fe ff ff test $0xfffffe00,%edx <== NOT EXECUTED
10e195: 74 10 je 10e1a7 <IMFS_fchmod+0x27> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
10e197: e8 34 05 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10e19c: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
10e1a2: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10e1a5: eb 25 jmp 10e1cc <IMFS_fchmod+0x4c> <== NOT EXECUTED
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO);
jnode->st_mode |= mode;
10e1a7: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED
10e1aa: 25 00 fe ff ff and $0xfffffe00,%eax <== NOT EXECUTED
10e1af: 09 c2 or %eax,%edx <== NOT EXECUTED
10e1b1: 89 53 30 mov %edx,0x30(%ebx) <== NOT EXECUTED
IMFS_update_ctime( jnode );
10e1b4: 50 push %eax <== NOT EXECUTED
10e1b5: 50 push %eax <== NOT EXECUTED
10e1b6: 6a 00 push $0x0 <== NOT EXECUTED
10e1b8: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED
10e1bb: 50 push %eax <== NOT EXECUTED
10e1bc: e8 a7 eb ff ff call 10cd68 <gettimeofday> <== NOT EXECUTED
10e1c1: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED
10e1c4: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED
10e1c7: 31 c0 xor %eax,%eax <== NOT EXECUTED
10e1c9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return 0;
}
10e1cc: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10e1cf: c9 leave <== NOT EXECUTED
10e1d0: c3 ret <== NOT EXECUTED
0010c748 <IMFS_find_match_in_dir>:
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
10c748: 55 push %ebp
10c749: 89 e5 mov %esp,%ebp
10c74b: 57 push %edi
10c74c: 56 push %esi
10c74d: 53 push %ebx
10c74e: 83 ec 0c sub $0xc,%esp
10c751: 8b 5d 08 mov 0x8(%ebp),%ebx
10c754: 8b 7d 0c mov 0xc(%ebp),%edi
/*
* Check for fatal errors. A NULL directory show a problem in the
* the IMFS code.
*/
assert( directory );
10c757: 85 db test %ebx,%ebx
10c759: 75 16 jne 10c771 <IMFS_find_match_in_dir+0x29><== ALWAYS TAKEN
10c75b: 68 c5 6b 11 00 push $0x116bc5 <== NOT EXECUTED
10c760: 68 2c 6c 11 00 push $0x116c2c <== NOT EXECUTED
10c765: 6a 2a push $0x2a <== NOT EXECUTED
10c767: 68 cf 6b 11 00 push $0x116bcf <== NOT EXECUTED
10c76c: e8 17 9b ff ff call 106288 <__assert_func> <== NOT EXECUTED
if ( !name )
10c771: 85 ff test %edi,%edi
10c773: 74 52 je 10c7c7 <IMFS_find_match_in_dir+0x7f><== NEVER TAKEN
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
10c775: 51 push %ecx
10c776: 51 push %ecx
10c777: 68 24 6c 11 00 push $0x116c24
10c77c: 57 push %edi
10c77d: e8 4a 30 00 00 call 10f7cc <strcmp>
10c782: 83 c4 10 add $0x10,%esp
10c785: 85 c0 test %eax,%eax
10c787: 74 40 je 10c7c9 <IMFS_find_match_in_dir+0x81><== NEVER TAKEN
return directory;
if ( !strcmp( name, dotdotname ) )
10c789: 52 push %edx
10c78a: 52 push %edx
10c78b: 68 26 6c 11 00 push $0x116c26
10c790: 57 push %edi
10c791: e8 36 30 00 00 call 10f7cc <strcmp>
10c796: 83 c4 10 add $0x10,%esp
10c799: 85 c0 test %eax,%eax
10c79b: 75 05 jne 10c7a2 <IMFS_find_match_in_dir+0x5a><== ALWAYS TAKEN
return directory->Parent;
10c79d: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED
10c7a0: eb 27 jmp 10c7c9 <IMFS_find_match_in_dir+0x81><== NOT EXECUTED
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
10c7a2: 8b 73 50 mov 0x50(%ebx),%esi
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
10c7a5: 83 c3 54 add $0x54,%ebx
10c7a8: eb 19 jmp 10c7c3 <IMFS_find_match_in_dir+0x7b>
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
if ( !strcmp( name, the_jnode->name ) )
10c7aa: 50 push %eax
10c7ab: 50 push %eax
10c7ac: 8d 46 0c lea 0xc(%esi),%eax
10c7af: 50 push %eax
10c7b0: 57 push %edi
10c7b1: e8 16 30 00 00 call 10f7cc <strcmp>
10c7b6: 83 c4 10 add $0x10,%esp
10c7b9: 85 c0 test %eax,%eax
10c7bb: 75 04 jne 10c7c1 <IMFS_find_match_in_dir+0x79>
10c7bd: 89 f3 mov %esi,%ebx
10c7bf: eb 08 jmp 10c7c9 <IMFS_find_match_in_dir+0x81>
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
10c7c1: 8b 36 mov (%esi),%esi
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
!rtems_chain_is_tail( the_chain, the_node );
10c7c3: 39 de cmp %ebx,%esi
10c7c5: 75 e3 jne 10c7aa <IMFS_find_match_in_dir+0x62>
10c7c7: 31 db xor %ebx,%ebx
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
10c7c9: 89 d8 mov %ebx,%eax
10c7cb: 8d 65 f4 lea -0xc(%ebp),%esp
10c7ce: 5b pop %ebx
10c7cf: 5e pop %esi
10c7d0: 5f pop %edi
10c7d1: c9 leave
10c7d2: c3 ret
0010c7d4 <IMFS_get_token>:
IMFS_token_types IMFS_get_token(
const char *path,
char *token,
int *token_len
)
{
10c7d4: 55 push %ebp
10c7d5: 89 e5 mov %esp,%ebp
10c7d7: 56 push %esi
10c7d8: 53 push %ebx
10c7d9: 8b 4d 08 mov 0x8(%ebp),%ecx
10c7dc: 8b 75 0c mov 0xc(%ebp),%esi
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
10c7df: 8a 01 mov (%ecx),%al
10c7e1: 31 d2 xor %edx,%edx
10c7e3: eb 10 jmp 10c7f5 <IMFS_get_token+0x21>
while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) {
token[i] = c;
10c7e5: 88 04 16 mov %al,(%esi,%edx,1)
if ( i == IMFS_NAME_MAX )
10c7e8: 75 07 jne 10c7f1 <IMFS_get_token+0x1d> <== ALWAYS TAKEN
10c7ea: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED
10c7ef: eb 77 jmp 10c868 <IMFS_get_token+0x94> <== NOT EXECUTED
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
10c7f1: 42 inc %edx
10c7f2: 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) ) {
10c7f5: 3c 2f cmp $0x2f,%al
10c7f7: 74 0d je 10c806 <IMFS_get_token+0x32>
10c7f9: 3c 5c cmp $0x5c,%al
10c7fb: 74 09 je 10c806 <IMFS_get_token+0x32> <== NEVER TAKEN
10c7fd: 84 c0 test %al,%al
10c7ff: 74 05 je 10c806 <IMFS_get_token+0x32>
10c801: 83 fa 20 cmp $0x20,%edx
10c804: 7e df jle 10c7e5 <IMFS_get_token+0x11> <== ALWAYS TAKEN
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
10c806: 85 d2 test %edx,%edx
10c808: 75 0e jne 10c818 <IMFS_get_token+0x44>
token[i] = c;
10c80a: 88 06 mov %al,(%esi)
if ( token[i] != '\0' ) {
10c80c: 31 db xor %ebx,%ebx
10c80e: 84 c0 test %al,%al
10c810: 74 1b je 10c82d <IMFS_get_token+0x59>
10c812: b2 01 mov $0x1,%dl
10c814: b3 01 mov $0x1,%bl
10c816: eb 15 jmp 10c82d <IMFS_get_token+0x59>
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
10c818: bb 03 00 00 00 mov $0x3,%ebx
10c81d: 80 7c 16 ff 00 cmpb $0x0,-0x1(%esi,%edx,1)
10c822: 74 09 je 10c82d <IMFS_get_token+0x59> <== NEVER TAKEN
token[i] = '\0';
10c824: c6 04 16 00 movb $0x0,(%esi,%edx,1)
10c828: bb 03 00 00 00 mov $0x3,%ebx
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
10c82d: 8b 45 10 mov 0x10(%ebp),%eax
10c830: 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 ) {
10c832: 83 fb 03 cmp $0x3,%ebx
10c835: 75 31 jne 10c868 <IMFS_get_token+0x94>
if ( strcmp( token, "..") == 0 )
10c837: 52 push %edx
10c838: 52 push %edx
10c839: 68 b9 67 11 00 push $0x1167b9
10c83e: 56 push %esi
10c83f: e8 88 2f 00 00 call 10f7cc <strcmp>
10c844: 83 c4 10 add $0x10,%esp
10c847: 85 c0 test %eax,%eax
10c849: 75 04 jne 10c84f <IMFS_get_token+0x7b> <== ALWAYS TAKEN
10c84b: b3 02 mov $0x2,%bl <== NOT EXECUTED
10c84d: eb 19 jmp 10c868 <IMFS_get_token+0x94> <== NOT EXECUTED
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
10c84f: 50 push %eax
10c850: 50 push %eax
10c851: 68 ba 67 11 00 push $0x1167ba
10c856: 56 push %esi
10c857: e8 70 2f 00 00 call 10f7cc <strcmp>
10c85c: 83 c4 10 add $0x10,%esp
10c85f: 85 c0 test %eax,%eax
10c861: 75 05 jne 10c868 <IMFS_get_token+0x94> <== ALWAYS TAKEN
10c863: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED
type = IMFS_CURRENT_DIR;
}
return type;
}
10c868: 89 d8 mov %ebx,%eax
10c86a: 8d 65 f8 lea -0x8(%ebp),%esp
10c86d: 5b pop %ebx
10c86e: 5e pop %esi
10c86f: c9 leave
10c870: c3 ret
0010c874 <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
)
{
10c874: 55 push %ebp
10c875: 89 e5 mov %esp,%ebp
10c877: 57 push %edi
10c878: 56 push %esi
10c879: 53 push %ebx
10c87a: 83 ec 0c sub $0xc,%esp
10c87d: 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,
10c880: 8b 0d bc 86 11 00 mov 0x1186bc,%ecx
10c886: b8 10 00 00 00 mov $0x10,%eax
10c88b: 31 d2 xor %edx,%edx
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16;
!is_valid && (bit_mask <= 512);
10c88d: 39 c8 cmp %ecx,%eax
10c88f: 74 0d je 10c89e <IMFS_initialize_support+0x2a>
bit_mask <<= 1) {
10c891: d1 e0 shl %eax
10c893: 42 inc %edx
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16;
!is_valid && (bit_mask <= 512);
10c894: 83 fa 06 cmp $0x6,%edx
10c897: 75 f4 jne 10c88d <IMFS_initialize_support+0x19><== ALWAYS TAKEN
10c899: b8 80 00 00 00 mov $0x80,%eax <== NOT EXECUTED
bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
is_valid = true;
}
}
*dest_bytes_per_block = ((is_valid)
10c89e: a3 9c c8 11 00 mov %eax,0x11c89c
* 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(
10c8a3: 83 ec 0c sub $0xc,%esp
10c8a6: 6a 00 push $0x0
10c8a8: 68 ed 41 00 00 push $0x41ed
10c8ad: 68 15 68 11 00 push $0x116815
10c8b2: 6a 01 push $0x1
10c8b4: 6a 00 push $0x0
10c8b6: e8 8d 17 00 00 call 10e048 <IMFS_create_node>
10c8bb: 89 43 18 mov %eax,0x18(%ebx)
"",
( S_IFDIR | 0755 ),
NULL
);
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
10c8be: 8b 45 14 mov 0x14(%ebp),%eax
10c8c1: 89 43 1c mov %eax,0x1c(%ebx)
temp_mt_entry->mt_fs_root.ops = op_table;
10c8c4: 8b 45 0c mov 0xc(%ebp),%eax
10c8c7: 89 43 20 mov %eax,0x20(%ebx)
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
10c8ca: 8d 7b 30 lea 0x30(%ebx),%edi
10c8cd: be 34 6e 11 00 mov $0x116e34,%esi
10c8d2: b9 0c 00 00 00 mov $0xc,%ecx
10c8d7: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
10c8d9: 83 c4 18 add $0x18,%esp
10c8dc: 6a 0c push $0xc
10c8de: 6a 01 push $0x1
10c8e0: e8 1f 03 00 00 call 10cc04 <calloc>
10c8e5: 89 c2 mov %eax,%edx
if ( !fs_info ){
10c8e7: 83 c4 10 add $0x10,%esp
10c8ea: 85 c0 test %eax,%eax
10c8ec: 75 1e jne 10c90c <IMFS_initialize_support+0x98><== ALWAYS TAKEN
free(temp_mt_entry->mt_fs_root.node_access);
10c8ee: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c8f1: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED
10c8f4: e8 7f 9b ff ff call 106478 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
10c8f9: e8 d2 1d 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10c8fe: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
10c904: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10c907: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c90a: eb 21 jmp 10c92d <IMFS_initialize_support+0xb9><== NOT EXECUTED
}
temp_mt_entry->fs_info = fs_info;
10c90c: 89 43 2c mov %eax,0x2c(%ebx)
/*
* Set st_ino for the root to 1.
*/
fs_info->ino_count = 1;
10c90f: c7 00 01 00 00 00 movl $0x1,(%eax)
fs_info->memfile_handlers = memfile_handlers;
10c915: 8b 45 10 mov 0x10(%ebp),%eax
10c918: 89 42 04 mov %eax,0x4(%edx)
fs_info->directory_handlers = directory_handlers;
10c91b: 8b 45 14 mov 0x14(%ebp),%eax
10c91e: 89 42 08 mov %eax,0x8(%edx)
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
10c921: 8b 43 18 mov 0x18(%ebx),%eax
10c924: c7 40 38 01 00 00 00 movl $0x1,0x38(%eax)
10c92b: 31 c0 xor %eax,%eax
return 0;
}
10c92d: 8d 65 f4 lea -0xc(%ebp),%esp
10c930: 5b pop %ebx
10c931: 5e pop %esi
10c932: 5f pop %edi
10c933: c9 leave
10c934: c3 ret
0010c938 <IMFS_mknod>:
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
10c938: 55 push %ebp
10c939: 89 e5 mov %esp,%ebp
10c93b: 57 push %edi
10c93c: 56 push %esi
10c93d: 53 push %ebx
10c93e: 83 ec 50 sub $0x50,%esp
10c941: 8b 7d 0c mov 0xc(%ebp),%edi
10c944: 8b 5d 10 mov 0x10(%ebp),%ebx
10c947: 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 );
10c94a: 8d 45 f0 lea -0x10(%ebp),%eax
10c94d: 50 push %eax
10c94e: 8d 45 bf lea -0x41(%ebp),%eax
10c951: 50 push %eax
10c952: ff 75 08 pushl 0x8(%ebp)
10c955: e8 7a fe ff ff call 10c7d4 <IMFS_get_token>
/*
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
10c95a: 89 f8 mov %edi,%eax
10c95c: 25 00 f0 00 00 and $0xf000,%eax
10c961: 83 c4 10 add $0x10,%esp
10c964: 3d 00 40 00 00 cmp $0x4000,%eax
10c969: 74 34 je 10c99f <IMFS_mknod+0x67>
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
10c96b: ba 05 00 00 00 mov $0x5,%edx
10c970: 3d 00 80 00 00 cmp $0x8000,%eax
10c975: 74 2d je 10c9a4 <IMFS_mknod+0x6c> <== NEVER TAKEN
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
10c977: 3d 00 60 00 00 cmp $0x6000,%eax
10c97c: 74 07 je 10c985 <IMFS_mknod+0x4d> <== NEVER TAKEN
10c97e: 3d 00 20 00 00 cmp $0x2000,%eax
10c983: 75 0d jne 10c992 <IMFS_mknod+0x5a> <== NEVER TAKEN
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
10c985: 89 5d e0 mov %ebx,-0x20(%ebp)
10c988: 89 75 e4 mov %esi,-0x1c(%ebp)
10c98b: ba 02 00 00 00 mov $0x2,%edx
10c990: eb 12 jmp 10c9a4 <IMFS_mknod+0x6c>
} else {
rtems_set_errno_and_return_minus_one( EINVAL );
10c992: e8 39 1d 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10c997: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
10c99d: eb 2e jmp 10c9cd <IMFS_mknod+0x95> <== NOT EXECUTED
10c99f: ba 01 00 00 00 mov $0x1,%edx
/*
* Allocate and fill in an IMFS jnode
*/
new_node = IMFS_create_node(
10c9a4: 83 ec 0c sub $0xc,%esp
10c9a7: 8d 45 e0 lea -0x20(%ebp),%eax
10c9aa: 50 push %eax
10c9ab: 57 push %edi
10c9ac: 8d 45 bf lea -0x41(%ebp),%eax
10c9af: 50 push %eax
10c9b0: 52 push %edx
10c9b1: ff 75 18 pushl 0x18(%ebp)
10c9b4: e8 8f 16 00 00 call 10e048 <IMFS_create_node>
new_name,
mode,
&info
);
if ( !new_node )
10c9b9: 83 c4 20 add $0x20,%esp
10c9bc: 31 d2 xor %edx,%edx
10c9be: 85 c0 test %eax,%eax
10c9c0: 75 0e jne 10c9d0 <IMFS_mknod+0x98> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOMEM );
10c9c2: e8 09 1d 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10c9c7: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
10c9cd: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED
return 0;
}
10c9d0: 89 d0 mov %edx,%eax
10c9d2: 8d 65 f4 lea -0xc(%ebp),%esp
10c9d5: 5b pop %ebx
10c9d6: 5e pop %esi
10c9d7: 5f pop %edi
10c9d8: c9 leave
10c9d9: c3 ret
0010c9ec <IMFS_rmnod>:
*/
int IMFS_rmnod(
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
10c9ec: 55 push %ebp <== NOT EXECUTED
10c9ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10c9ef: 56 push %esi <== NOT EXECUTED
10c9f0: 53 push %ebx <== NOT EXECUTED
10c9f1: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
10c9f4: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
10c9f7: 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 ) {
10c9f9: 83 7b 08 00 cmpl $0x0,0x8(%ebx) <== NOT EXECUTED
10c9fd: 74 13 je 10ca12 <IMFS_rmnod+0x26> <== NOT EXECUTED
10c9ff: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ca02: 53 push %ebx <== NOT EXECUTED
10ca03: e8 68 0c 00 00 call 10d670 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract( (rtems_chain_node *) the_jnode );
the_jnode->Parent = NULL;
10ca08: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED
10ca0f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
/*
* Decrement the link counter and see if we can free the space.
*/
the_jnode->st_nlink--;
10ca12: 66 ff 4b 34 decw 0x34(%ebx) <== NOT EXECUTED
IMFS_update_ctime( the_jnode );
10ca16: 50 push %eax <== NOT EXECUTED
10ca17: 50 push %eax <== NOT EXECUTED
10ca18: 6a 00 push $0x0 <== NOT EXECUTED
10ca1a: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED
10ca1d: 50 push %eax <== NOT EXECUTED
10ca1e: e8 45 03 00 00 call 10cd68 <gettimeofday> <== NOT EXECUTED
10ca23: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED
10ca26: 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) ) {
10ca29: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10ca2c: e8 e7 03 00 00 call 10ce18 <rtems_libio_is_file_open><== NOT EXECUTED
10ca31: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ca34: 85 c0 test %eax,%eax <== NOT EXECUTED
10ca36: 75 40 jne 10ca78 <IMFS_rmnod+0x8c> <== NOT EXECUTED
10ca38: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) <== NOT EXECUTED
10ca3d: 75 39 jne 10ca78 <IMFS_rmnod+0x8c> <== NOT EXECUTED
/*
* Is rtems_filesystem_current this node?
*/
if ( rtems_filesystem_current.node_access == pathloc->node_access )
10ca3f: 8b 15 4c aa 11 00 mov 0x11aa4c,%edx <== NOT EXECUTED
10ca45: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED
10ca48: 3b 06 cmp (%esi),%eax <== NOT EXECUTED
10ca4a: 75 07 jne 10ca53 <IMFS_rmnod+0x67> <== NOT EXECUTED
rtems_filesystem_current.node_access = NULL;
10ca4c: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED
/*
* Free memory associated with a memory file.
*/
if ( the_jnode->type == IMFS_SYM_LINK ) {
10ca53: 83 7b 4c 04 cmpl $0x4,0x4c(%ebx) <== NOT EXECUTED
10ca57: 75 13 jne 10ca6c <IMFS_rmnod+0x80> <== NOT EXECUTED
if ( the_jnode->info.sym_link.name )
10ca59: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED
10ca5c: 85 c0 test %eax,%eax <== NOT EXECUTED
10ca5e: 74 0c je 10ca6c <IMFS_rmnod+0x80> <== NOT EXECUTED
free( (void*) the_jnode->info.sym_link.name );
10ca60: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ca63: 50 push %eax <== NOT EXECUTED
10ca64: e8 0f 9a ff ff call 106478 <free> <== NOT EXECUTED
10ca69: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
free( the_jnode );
10ca6c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ca6f: 53 push %ebx <== NOT EXECUTED
10ca70: e8 03 9a ff ff call 106478 <free> <== NOT EXECUTED
10ca75: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
return 0;
}
10ca78: 31 c0 xor %eax,%eax <== NOT EXECUTED
10ca7a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10ca7d: 5b pop %ebx <== NOT EXECUTED
10ca7e: 5e pop %esi <== NOT EXECUTED
10ca7f: c9 leave <== NOT EXECUTED
10ca80: c3 ret <== NOT EXECUTED
0010ca84 <IMFS_stat>:
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
10ca84: 55 push %ebp
10ca85: 89 e5 mov %esp,%ebp
10ca87: 53 push %ebx
10ca88: 83 ec 04 sub $0x4,%esp
10ca8b: 8b 5d 0c mov 0xc(%ebp),%ebx
IMFS_jnode_t *the_jnode;
IMFS_device_t *io;
the_jnode = loc->node_access;
10ca8e: 8b 45 08 mov 0x8(%ebp),%eax
10ca91: 8b 08 mov (%eax),%ecx
switch ( the_jnode->type ) {
10ca93: 8b 41 4c mov 0x4c(%ecx),%eax
10ca96: 83 f8 04 cmp $0x4,%eax
10ca99: 74 25 je 10cac0 <IMFS_stat+0x3c> <== NEVER TAKEN
10ca9b: 7f 07 jg 10caa4 <IMFS_stat+0x20> <== NEVER TAKEN
10ca9d: 83 f8 02 cmp $0x2,%eax
10caa0: 75 27 jne 10cac9 <IMFS_stat+0x45> <== NEVER TAKEN
10caa2: eb 07 jmp 10caab <IMFS_stat+0x27>
10caa4: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED
10caa7: 7f 20 jg 10cac9 <IMFS_stat+0x45> <== NOT EXECUTED
10caa9: eb 0d jmp 10cab8 <IMFS_stat+0x34> <== NOT EXECUTED
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_dev = rtems_filesystem_make_dev_t( io->major, io->minor );
10caab: 8b 51 54 mov 0x54(%ecx),%edx
10caae: 8b 41 50 mov 0x50(%ecx),%eax
10cab1: 89 03 mov %eax,(%ebx)
10cab3: 89 53 04 mov %edx,0x4(%ebx)
10cab6: eb 21 jmp 10cad9 <IMFS_stat+0x55>
break;
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
10cab8: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED
10cabb: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED
10cabe: eb 19 jmp 10cad9 <IMFS_stat+0x55> <== NOT EXECUTED
break;
case IMFS_SYM_LINK:
buf->st_size = 0;
10cac0: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED
10cac7: eb 10 jmp 10cad9 <IMFS_stat+0x55> <== NOT EXECUTED
break;
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
10cac9: e8 02 1c 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10cace: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10cad4: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10cad7: eb 3e jmp 10cb17 <IMFS_stat+0x93> <== NOT EXECUTED
break;
}
buf->st_mode = the_jnode->st_mode;
10cad9: 8b 41 30 mov 0x30(%ecx),%eax
10cadc: 89 43 0c mov %eax,0xc(%ebx)
buf->st_nlink = the_jnode->st_nlink;
10cadf: 8b 41 34 mov 0x34(%ecx),%eax
10cae2: 66 89 43 10 mov %ax,0x10(%ebx)
buf->st_ino = the_jnode->st_ino;
10cae6: 8b 41 38 mov 0x38(%ecx),%eax
10cae9: 89 43 08 mov %eax,0x8(%ebx)
buf->st_uid = the_jnode->st_uid;
10caec: 8b 41 3c mov 0x3c(%ecx),%eax
10caef: 66 89 43 12 mov %ax,0x12(%ebx)
buf->st_gid = the_jnode->st_gid;
10caf3: 66 8b 41 3e mov 0x3e(%ecx),%ax
10caf7: 66 89 43 14 mov %ax,0x14(%ebx)
buf->st_atime = the_jnode->stat_atime;
10cafb: 8b 41 40 mov 0x40(%ecx),%eax
10cafe: 89 43 24 mov %eax,0x24(%ebx)
buf->st_mtime = the_jnode->stat_mtime;
10cb01: 8b 41 44 mov 0x44(%ecx),%eax
10cb04: 89 43 2c mov %eax,0x2c(%ebx)
buf->st_ctime = the_jnode->stat_ctime;
10cb07: 8b 41 48 mov 0x48(%ecx),%eax
10cb0a: 89 43 34 mov %eax,0x34(%ebx)
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
10cb0d: a1 bc 86 11 00 mov 0x1186bc,%eax
10cb12: 89 43 3c mov %eax,0x3c(%ebx)
10cb15: 31 c0 xor %eax,%eax
return 0;
}
10cb17: 5a pop %edx
10cb18: 5b pop %ebx
10cb19: c9 leave
10cb1a: c3 ret
001065fc <RTEMS_Malloc_Initialize>:
void RTEMS_Malloc_Initialize(
void *start,
size_t length,
size_t sbrk_amount
)
{
1065fc: 55 push %ebp
1065fd: 89 e5 mov %esp,%ebp
1065ff: 57 push %edi
106600: 56 push %esi
106601: 53 push %ebx
106602: 83 ec 0c sub $0xc,%esp
106605: 8b 75 08 mov 0x8(%ebp),%esi
106608: 8b 5d 0c mov 0xc(%ebp),%ebx
#endif
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers )
10660b: a1 54 af 11 00 mov 0x11af54,%eax
106610: 85 c0 test %eax,%eax
106612: 74 02 je 106616 <RTEMS_Malloc_Initialize+0x1a><== ALWAYS TAKEN
(*rtems_malloc_statistics_helpers->initialize)();
106614: ff 10 call *(%eax) <== NOT EXECUTED
/*
* Initialize the garbage collection list to start with nothing on it.
*/
malloc_deferred_frees_initialize();
106616: e8 79 ff ff ff call 106594 <malloc_deferred_frees_initialize>
starting_address = start;
/*
* Initialize the optional sbrk support for extending the heap
*/
if (rtems_malloc_sbrk_helpers) {
10661b: a1 58 af 11 00 mov 0x11af58,%eax
106620: 89 f2 mov %esi,%edx
106622: 85 c0 test %eax,%eax
106624: 74 0d je 106633 <RTEMS_Malloc_Initialize+0x37><== ALWAYS TAKEN
starting_address = (*rtems_malloc_sbrk_helpers->initialize)(
106626: 52 push %edx <== NOT EXECUTED
106627: 52 push %edx <== NOT EXECUTED
106628: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED
10662b: 56 push %esi <== NOT EXECUTED
10662c: ff 10 call *(%eax) <== NOT EXECUTED
10662e: 89 c2 mov %eax,%edx <== NOT EXECUTED
106630: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
* of the time under UNIX because zero'ing memory when it is first
* given to a process eliminates the chance of a process seeing data
* left over from another process. This would be a security violation.
*/
if ( rtems_configuration_get_do_zero_of_workspace() )
106633: a1 78 cb 11 00 mov 0x11cb78,%eax
106638: 80 78 28 00 cmpb $0x0,0x28(%eax)
10663c: 74 08 je 106646 <RTEMS_Malloc_Initialize+0x4a><== ALWAYS TAKEN
memset( starting_address, 0, length );
10663e: 31 c0 xor %eax,%eax
106640: 89 d7 mov %edx,%edi <== NOT EXECUTED
106642: 89 d9 mov %ebx,%ecx <== NOT EXECUTED
106644: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED
void *starting_address,
size_t size,
uint32_t page_size
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
106646: 6a 04 push $0x4
106648: 53 push %ebx
106649: 52 push %edx
10664a: 68 98 c9 11 00 push $0x11c998
10664f: e8 38 39 00 00 call 109f8c <_Heap_Initialize>
&RTEMS_Malloc_Heap,
starting_address,
length,
CPU_HEAP_ALIGNMENT
);
if ( !status )
106654: 83 c4 10 add $0x10,%esp
106657: 85 c0 test %eax,%eax
106659: 75 0a jne 106665 <RTEMS_Malloc_Initialize+0x69><== ALWAYS TAKEN
rtems_fatal_error_occurred( status );
10665b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10665e: 6a 00 push $0x0 <== NOT EXECUTED
106660: e8 27 31 00 00 call 10978c <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_print_buffer( (start + length) - 48, 48 );
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
}
#endif
MSBUMP(space_available, length);
106665: 01 1d f0 c9 11 00 add %ebx,0x11c9f0
}
10666b: 8d 65 f4 lea -0xc(%ebp),%esp
10666e: 5b pop %ebx
10666f: 5e pop %esi
106670: 5f pop %edi
106671: c9 leave
106672: c3 ret
0010674a <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
10674a: 55 push %ebp <== NOT EXECUTED
10674b: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10674d: 57 push %edi <== NOT EXECUTED
10674e: 56 push %esi <== NOT EXECUTED
10674f: 53 push %ebx <== NOT EXECUTED
106750: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED
106753: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
void *high_water_mark;
void *current;
Stack_Control *stack;
char name[5];
if ( !the_thread )
106756: 85 db test %ebx,%ebx <== NOT EXECUTED
106758: 0f 84 fc 00 00 00 je 10685a <Stack_check_Dump_threads_usage+0x110><== NOT EXECUTED
return;
if ( !print_handler )
10675e: a1 7c f1 11 00 mov 0x11f17c,%eax <== NOT EXECUTED
106763: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED
106766: 85 c0 test %eax,%eax <== NOT EXECUTED
106768: 0f 84 ec 00 00 00 je 10685a <Stack_check_Dump_threads_usage+0x110><== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
if (the_thread == (Thread_Control *) -1) {
10676e: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED
106771: 75 1d jne 106790 <Stack_check_Dump_threads_usage+0x46><== NOT EXECUTED
if (Stack_check_Interrupt_stack.area) {
106773: 83 3d a4 f3 11 00 00 cmpl $0x0,0x11f3a4 <== NOT EXECUTED
10677a: 0f 84 da 00 00 00 je 10685a <Stack_check_Dump_threads_usage+0x110><== NOT EXECUTED
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
current = 0;
}
else
return;
106780: 31 db xor %ebx,%ebx <== NOT EXECUTED
106782: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
106789: be a0 f3 11 00 mov $0x11f3a0,%esi <== NOT EXECUTED
10678e: eb 0f jmp 10679f <Stack_check_Dump_threads_usage+0x55><== NOT EXECUTED
} else {
stack = &the_thread->Start.Initial_stack;
106790: 8d b3 c4 00 00 00 lea 0xc4(%ebx),%esi <== NOT EXECUTED
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
106796: 8b 83 d8 00 00 00 mov 0xd8(%ebx),%eax <== NOT EXECUTED
10679c: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED
}
low = Stack_check_usable_stack_start(stack);
10679f: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED
1067a2: 8d 78 10 lea 0x10(%eax),%edi <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
1067a5: 8b 06 mov (%esi),%eax <== NOT EXECUTED
1067a7: 83 e8 10 sub $0x10,%eax <== NOT EXECUTED
1067aa: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED
high_water_mark = Stack_check_find_high_water_mark(low, size);
1067ad: 50 push %eax <== NOT EXECUTED
1067ae: 57 push %edi <== NOT EXECUTED
1067af: e8 6b ff ff ff call 10671f <Stack_check_find_high_water_mark><== NOT EXECUTED
if ( high_water_mark )
1067b4: 5a pop %edx <== NOT EXECUTED
1067b5: 59 pop %ecx <== NOT EXECUTED
1067b6: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED
1067bd: 85 c0 test %eax,%eax <== NOT EXECUTED
1067bf: 74 09 je 1067ca <Stack_check_Dump_threads_usage+0x80><== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
1067c1: 03 7d d8 add -0x28(%ebp),%edi <== NOT EXECUTED
1067c4: 89 7d dc mov %edi,-0x24(%ebp) <== NOT EXECUTED
1067c7: 29 45 dc sub %eax,-0x24(%ebp) <== NOT EXECUTED
else
used = 0;
if ( the_thread ) {
1067ca: 85 db test %ebx,%ebx <== NOT EXECUTED
1067cc: 74 26 je 1067f4 <Stack_check_Dump_threads_usage+0xaa><== NOT EXECUTED
(*print_handler)(
1067ce: 50 push %eax <== NOT EXECUTED
1067cf: 8d 45 ef lea -0x11(%ebp),%eax <== NOT EXECUTED
1067d2: 50 push %eax <== NOT EXECUTED
1067d3: 6a 05 push $0x5 <== NOT EXECUTED
1067d5: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
1067d8: e8 1f 34 00 00 call 109bfc <rtems_object_get_name> <== NOT EXECUTED
1067dd: 50 push %eax <== NOT EXECUTED
1067de: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
1067e1: 68 79 8b 11 00 push $0x118b79 <== NOT EXECUTED
1067e6: ff 35 78 f1 11 00 pushl 0x11f178 <== NOT EXECUTED
1067ec: ff 55 d4 call *-0x2c(%ebp) <== NOT EXECUTED
1067ef: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
1067f2: eb 14 jmp 106808 <Stack_check_Dump_threads_usage+0xbe><== NOT EXECUTED
"0x%08" PRIx32 " %4s",
the_thread->Object.id,
rtems_object_get_name( the_thread->Object.id, sizeof(name), name )
);
} else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
1067f4: 57 push %edi <== NOT EXECUTED
1067f5: 6a ff push $0xffffffff <== NOT EXECUTED
1067f7: 68 86 8b 11 00 push $0x118b86 <== NOT EXECUTED
1067fc: ff 35 78 f1 11 00 pushl 0x11f178 <== NOT EXECUTED
106802: ff 55 d4 call *-0x2c(%ebp) <== NOT EXECUTED
106805: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
(*print_handler)(
106808: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED
10680b: 53 push %ebx <== NOT EXECUTED
10680c: 53 push %ebx <== NOT EXECUTED
10680d: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED
106810: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED
106813: 8b 16 mov (%esi),%edx <== NOT EXECUTED
106815: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED
106819: 52 push %edx <== NOT EXECUTED
10681a: 50 push %eax <== NOT EXECUTED
10681b: 68 94 8b 11 00 push $0x118b94 <== NOT EXECUTED
106820: ff 35 78 f1 11 00 pushl 0x11f178 <== NOT EXECUTED
106826: ff 15 7c f1 11 00 call *0x11f17c <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
10682c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
10682f: 83 3d 74 f1 11 00 00 cmpl $0x0,0x11f174 <== NOT EXECUTED
106836: a1 7c f1 11 00 mov 0x11f17c,%eax <== NOT EXECUTED
10683b: 75 09 jne 106846 <Stack_check_Dump_threads_usage+0xfc><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
10683d: 51 push %ecx <== NOT EXECUTED
10683e: 51 push %ecx <== NOT EXECUTED
10683f: 68 b2 8b 11 00 push $0x118bb2 <== NOT EXECUTED
106844: eb 09 jmp 10684f <Stack_check_Dump_threads_usage+0x105><== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
106846: 52 push %edx <== NOT EXECUTED
106847: ff 75 dc pushl -0x24(%ebp) <== NOT EXECUTED
10684a: 68 bf 8b 11 00 push $0x118bbf <== NOT EXECUTED
10684f: ff 35 78 f1 11 00 pushl 0x11f178 <== NOT EXECUTED
106855: ff d0 call *%eax <== NOT EXECUTED
106857: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
10685a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10685d: 5b pop %ebx <== NOT EXECUTED
10685e: 5e pop %esi <== NOT EXECUTED
10685f: 5f pop %edi <== NOT EXECUTED
106860: c9 leave <== NOT EXECUTED
106861: c3 ret <== NOT EXECUTED
00106a13 <Stack_check_Initialize>:
/*
* Stack_check_Initialize
*/
void Stack_check_Initialize( void )
{
106a13: 55 push %ebp
106a14: 89 e5 mov %esp,%ebp
106a16: 57 push %edi
106a17: 83 ec 04 sub $0x4,%esp
uint32_t *p;
if (Stack_check_Initialized)
106a1a: 83 3d 74 f1 11 00 00 cmpl $0x0,0x11f174
106a21: 75 59 jne 106a7c <Stack_check_Initialize+0x69>
for ( p = Stack_check_Pattern.pattern;
p < &Stack_check_Pattern.pattern[PATTERN_SIZE_WORDS];
p += 4
) {
p[0] = 0xFEEDF00D; /* FEED FOOD to BAD DOG */
106a23: c7 05 90 f3 11 00 0d movl $0xfeedf00d,0x11f390
106a2a: f0 ed fe
p[1] = 0x0BAD0D06;
106a2d: c7 05 94 f3 11 00 06 movl $0xbad0d06,0x11f394
106a34: 0d ad 0b
p[2] = 0xDEADF00D; /* DEAD FOOD GOOD DOG */
106a37: c7 05 98 f3 11 00 0d movl $0xdeadf00d,0x11f398
106a3e: f0 ad de
p[3] = 0x600D0D06;
106a41: c7 05 9c f3 11 00 06 movl $0x600d0d06,0x11f39c
106a48: 0d 0d 60
/*
* If appropriate, setup the interrupt stack for high water testing
* also.
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {
106a4b: 8b 3d 1c f5 11 00 mov 0x11f51c,%edi
106a51: 85 ff test %edi,%edi
106a53: 74 1d je 106a72 <Stack_check_Initialize+0x5f><== NEVER TAKEN
106a55: a1 dc f4 11 00 mov 0x11f4dc,%eax
106a5a: 85 c0 test %eax,%eax
106a5c: 74 14 je 106a72 <Stack_check_Initialize+0x5f><== NEVER TAKEN
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
106a5e: 89 3d a4 f3 11 00 mov %edi,0x11f3a4
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
106a64: 89 c1 mov %eax,%ecx
106a66: 29 f9 sub %edi,%ecx
106a68: 89 0d a0 f3 11 00 mov %ecx,0x11f3a0
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
106a6e: b0 a5 mov $0xa5,%al
106a70: f3 aa rep stos %al,%es:(%edi)
}
#endif
Stack_check_Initialized = 1;
106a72: c7 05 74 f1 11 00 01 movl $0x1,0x11f174
106a79: 00 00 00
}
106a7c: 58 pop %eax
106a7d: 5f pop %edi
106a7e: c9 leave
106a7f: c3 ret
0010671f <Stack_check_find_high_water_mark>:
*/
void *Stack_check_find_high_water_mark(
const void *s,
size_t n
)
{
10671f: 55 push %ebp <== NOT EXECUTED
106720: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106722: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
106725: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
106728: 83 c2 10 add $0x10,%edx <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
10672b: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED
10672e: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED
106731: eb 0f jmp 106742 <Stack_check_find_high_water_mark+0x23><== NOT EXECUTED
if (*base != U32_PATTERN)
106733: 81 3a a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%edx) <== NOT EXECUTED
106739: 74 04 je 10673f <Stack_check_find_high_water_mark+0x20><== NOT EXECUTED
return (void *) base;
10673b: 89 d0 mov %edx,%eax <== NOT EXECUTED
10673d: eb 09 jmp 106748 <Stack_check_find_high_water_mark+0x29><== NOT EXECUTED
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
10673f: 83 c2 04 add $0x4,%edx <== NOT EXECUTED
106742: 39 c2 cmp %eax,%edx <== NOT EXECUTED
106744: 72 ed jb 106733 <Stack_check_find_high_water_mark+0x14><== NOT EXECUTED
106746: 31 c0 xor %eax,%eax <== NOT EXECUTED
if (*base != U32_PATTERN)
return (void *) base;
#endif
return (void *)0;
}
106748: c9 leave <== NOT EXECUTED
106749: c3 ret <== NOT EXECUTED
001068da <Stack_check_report_blown_task>:
*/
void Stack_check_report_blown_task(
Thread_Control *running,
bool pattern_ok
)
{
1068da: 55 push %ebp <== NOT EXECUTED
1068db: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1068dd: 56 push %esi <== NOT EXECUTED
1068de: 53 push %ebx <== NOT EXECUTED
1068df: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
1068e2: 8a 5d 0c mov 0xc(%ebp),%bl <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack;
printk(
1068e5: ff 76 0c pushl 0xc(%esi) <== NOT EXECUTED
1068e8: ff 76 08 pushl 0x8(%esi) <== NOT EXECUTED
1068eb: 56 push %esi <== NOT EXECUTED
1068ec: 68 26 8c 11 00 push $0x118c26 <== NOT EXECUTED
1068f1: e8 c0 12 00 00 call 107bb6 <printk> <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
printk(
1068f6: 8b 96 c8 00 00 00 mov 0xc8(%esi),%edx <== NOT EXECUTED
1068fc: 8b 86 c4 00 00 00 mov 0xc4(%esi),%eax <== NOT EXECUTED
106902: 50 push %eax <== NOT EXECUTED
106903: 8d 44 02 ff lea -0x1(%edx,%eax,1),%eax <== NOT EXECUTED
106907: 50 push %eax <== NOT EXECUTED
106908: 52 push %edx <== NOT EXECUTED
106909: 68 64 8c 11 00 push $0x118c64 <== NOT EXECUTED
10690e: e8 a3 12 00 00 call 107bb6 <printk> <== NOT EXECUTED
stack->area,
stack->area + stack->size - 1,
stack->size
);
if ( !pattern_ok ) {
106913: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
106916: 84 db test %bl,%bl <== NOT EXECUTED
106918: 75 1a jne 106934 <Stack_check_report_blown_task+0x5a><== NOT EXECUTED
printk(
10691a: 53 push %ebx <== NOT EXECUTED
10691b: 6a 10 push $0x10 <== NOT EXECUTED
10691d: 8b 86 c8 00 00 00 mov 0xc8(%esi),%eax <== NOT EXECUTED
106923: 83 c0 08 add $0x8,%eax <== NOT EXECUTED
106926: 50 push %eax <== NOT EXECUTED
106927: 68 92 8c 11 00 push $0x118c92 <== NOT EXECUTED
10692c: e8 85 12 00 00 call 107bb6 <printk> <== NOT EXECUTED
106931: 83 c4 10 add $0x10,%esp <== 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 );
106934: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106937: 68 81 00 00 00 push $0x81 <== NOT EXECUTED
10693c: e8 43 3b 00 00 call 10a484 <rtems_fatal_error_occurred><== NOT EXECUTED
00109909 <_API_extensions_Run_postdriver>:
*
* _API_extensions_Run_postdriver
*/
void _API_extensions_Run_postdriver( void )
{
109909: 55 push %ebp
10990a: 89 e5 mov %esp,%ebp
10990c: 53 push %ebx
10990d: 83 ec 04 sub $0x4,%esp
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
109910: 8b 1d 04 cd 11 00 mov 0x11cd04,%ebx
109916: eb 0b jmp 109923 <_API_extensions_Run_postdriver+0x1a>
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->postdriver_hook )
109918: 8b 43 0c mov 0xc(%ebx),%eax
10991b: 85 c0 test %eax,%eax
10991d: 74 02 je 109921 <_API_extensions_Run_postdriver+0x18><== NEVER TAKEN
(*the_extension->postdriver_hook)();
10991f: 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 ) {
109921: 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 ) ;
109923: 81 fb 08 cd 11 00 cmp $0x11cd08,%ebx
109929: 75 ed jne 109918 <_API_extensions_Run_postdriver+0xf>
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->postdriver_hook )
(*the_extension->postdriver_hook)();
}
}
10992b: 5a pop %edx
10992c: 5b pop %ebx
10992d: c9 leave
10992e: c3 ret
0010992f <_API_extensions_Run_postswitch>:
*
* _API_extensions_Run_postswitch
*/
void _API_extensions_Run_postswitch( void )
{
10992f: 55 push %ebp
109930: 89 e5 mov %esp,%ebp
109932: 53 push %ebx
109933: 83 ec 04 sub $0x4,%esp
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
109936: 8b 1d 04 cd 11 00 mov 0x11cd04,%ebx
10993c: eb 17 jmp 109955 <_API_extensions_Run_postswitch+0x26>
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->postswitch_hook )
10993e: 8b 43 10 mov 0x10(%ebx),%eax
109941: 85 c0 test %eax,%eax
109943: 74 0e je 109953 <_API_extensions_Run_postswitch+0x24><== NEVER TAKEN
(*the_extension->postswitch_hook)( _Thread_Executing );
109945: 83 ec 0c sub $0xc,%esp
109948: ff 35 a0 cb 11 00 pushl 0x11cba0
10994e: ff d0 call *%eax
109950: 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 ) {
109953: 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 ) ;
109955: 81 fb 08 cd 11 00 cmp $0x11cd08,%ebx
10995b: 75 e1 jne 10993e <_API_extensions_Run_postswitch+0xf>
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->postswitch_hook )
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
10995d: 8b 5d fc mov -0x4(%ebp),%ebx
109960: c9 leave
109961: c3 ret
001098e3 <_API_extensions_Run_predriver>:
*
* _API_extensions_Run_predriver
*/
void _API_extensions_Run_predriver( void )
{
1098e3: 55 push %ebp
1098e4: 89 e5 mov %esp,%ebp
1098e6: 53 push %ebx
1098e7: 83 ec 04 sub $0x4,%esp
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
1098ea: 8b 1d 04 cd 11 00 mov 0x11cd04,%ebx
1098f0: eb 0b jmp 1098fd <_API_extensions_Run_predriver+0x1a>
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->predriver_hook )
1098f2: 8b 43 08 mov 0x8(%ebx),%eax
1098f5: 85 c0 test %eax,%eax
1098f7: 74 02 je 1098fb <_API_extensions_Run_predriver+0x18><== ALWAYS TAKEN
(*the_extension->predriver_hook)();
1098f9: 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 ) {
1098fb: 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 ) ;
1098fd: 81 fb 08 cd 11 00 cmp $0x11cd08,%ebx
109903: 75 ed jne 1098f2 <_API_extensions_Run_predriver+0xf>
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->predriver_hook )
(*the_extension->predriver_hook)();
}
}
109905: 58 pop %eax
109906: 5b pop %ebx
109907: c9 leave
109908: c3 ret
0010a8c4 <_CORE_barrier_Wait>:
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
10a8c4: 55 push %ebp
10a8c5: 89 e5 mov %esp,%ebp
10a8c7: 57 push %edi
10a8c8: 56 push %esi
10a8c9: 53 push %ebx
10a8ca: 83 ec 04 sub $0x4,%esp
10a8cd: 8b 55 08 mov 0x8(%ebp),%edx
10a8d0: 8b 75 0c mov 0xc(%ebp),%esi
10a8d3: 8b 45 14 mov 0x14(%ebp),%eax
10a8d6: 89 45 f0 mov %eax,-0x10(%ebp)
10a8d9: 8b 7d 18 mov 0x18(%ebp),%edi
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
10a8dc: 8b 0d b4 f5 11 00 mov 0x11f5b4,%ecx
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
10a8e2: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx)
_ISR_Disable( level );
10a8e9: 9c pushf
10a8ea: fa cli
10a8eb: 5b pop %ebx
the_barrier->number_of_waiting_threads++;
10a8ec: 8b 42 48 mov 0x48(%edx),%eax
10a8ef: 40 inc %eax
10a8f0: 89 42 48 mov %eax,0x48(%edx)
if ( the_barrier->number_of_waiting_threads ==
10a8f3: 3b 42 44 cmp 0x44(%edx),%eax
10a8f6: 75 22 jne 10a91a <_CORE_barrier_Wait+0x56>
the_barrier->Attributes.maximum_count) {
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
10a8f8: 83 7a 40 00 cmpl $0x0,0x40(%edx)
10a8fc: 75 1c jne 10a91a <_CORE_barrier_Wait+0x56><== NEVER TAKEN
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
10a8fe: c7 41 34 01 00 00 00 movl $0x1,0x34(%ecx)
_ISR_Enable( level );
10a905: 53 push %ebx
10a906: 9d popf
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
10a907: 89 7d 10 mov %edi,0x10(%ebp)
10a90a: 89 75 0c mov %esi,0xc(%ebp)
10a90d: 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 );
}
10a910: 5a pop %edx
10a911: 5b pop %ebx
10a912: 5e pop %esi
10a913: 5f pop %edi
10a914: 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 );
10a915: e9 7a ff ff ff jmp 10a894 <_CORE_barrier_Release>
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
* This routine grows @a the_heap memory area using the size bytes which
10a91a: 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;
10a921: 89 51 44 mov %edx,0x44(%ecx)
executing->Wait.id = id;
10a924: 89 71 20 mov %esi,0x20(%ecx)
_ISR_Enable( level );
10a927: 53 push %ebx
10a928: 9d popf
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
10a929: c7 45 10 ec c3 10 00 movl $0x10c3ec,0x10(%ebp)
10a930: 8b 45 f0 mov -0x10(%ebp),%eax
10a933: 89 45 0c mov %eax,0xc(%ebp)
10a936: 89 55 08 mov %edx,0x8(%ebp)
}
10a939: 58 pop %eax
10a93a: 5b pop %ebx
10a93b: 5e pop %esi
10a93c: 5f pop %edi
10a93d: 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 );
10a93e: e9 a5 17 00 00 jmp 10c0e8 <_Thread_queue_Enqueue_with_handler>
00113a68 <_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
)
{
113a68: 55 push %ebp
113a69: 89 e5 mov %esp,%ebp
113a6b: 57 push %edi
113a6c: 56 push %esi
113a6d: 53 push %ebx
113a6e: 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 ) {
113a71: b8 01 00 00 00 mov $0x1,%eax
113a76: 8b 4d 10 mov 0x10(%ebp),%ecx
113a79: 8b 55 08 mov 0x8(%ebp),%edx
113a7c: 3b 4a 4c cmp 0x4c(%edx),%ecx
113a7f: 77 43 ja 113ac4 <_CORE_message_queue_Broadcast+0x5c><== NEVER TAKEN
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
number_broadcasted = 0;
while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
113a81: 31 db xor %ebx,%ebx
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
113a83: 8b 75 08 mov 0x8(%ebp),%esi
113a86: 83 7e 48 00 cmpl $0x0,0x48(%esi)
113a8a: 74 21 je 113aad <_CORE_message_queue_Broadcast+0x45><== ALWAYS TAKEN
*count = 0;
113a8c: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED
113a8f: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
113a95: 31 c0 xor %eax,%eax <== NOT EXECUTED
113a97: eb 2b jmp 113ac4 <_CORE_message_queue_Broadcast+0x5c><== NOT EXECUTED
*/
number_broadcasted = 0;
while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
113a99: 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
113a9a: 8b 78 2c mov 0x2c(%eax),%edi
113a9d: 8b 75 0c mov 0xc(%ebp),%esi
113aa0: 8b 4d 10 mov 0x10(%ebp),%ecx
113aa3: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
113aa5: 8b 40 28 mov 0x28(%eax),%eax
113aa8: 8b 55 10 mov 0x10(%ebp),%edx
113aab: 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))) {
113aad: 83 ec 0c sub $0xc,%esp
113ab0: ff 75 08 pushl 0x8(%ebp)
113ab3: e8 98 1f 00 00 call 115a50 <_Thread_queue_Dequeue>
113ab8: 83 c4 10 add $0x10,%esp
113abb: 85 c0 test %eax,%eax
113abd: 75 da jne 113a99 <_CORE_message_queue_Broadcast+0x31>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
113abf: 8b 4d 1c mov 0x1c(%ebp),%ecx
113ac2: 89 19 mov %ebx,(%ecx)
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
113ac4: 8d 65 f4 lea -0xc(%ebp),%esp
113ac7: 5b pop %ebx
113ac8: 5e pop %esi
113ac9: 5f pop %edi
113aca: c9 leave
113acb: c3 ret
00113b6c <_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
)
{
113b6c: 55 push %ebp
113b6d: 89 e5 mov %esp,%ebp
113b6f: 57 push %edi
113b70: 56 push %esi
113b71: 53 push %ebx
113b72: 83 ec 0c sub $0xc,%esp
113b75: 8b 5d 08 mov 0x8(%ebp),%ebx
113b78: 8b 7d 10 mov 0x10(%ebp),%edi
113b7b: 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;
113b7e: 89 7b 44 mov %edi,0x44(%ebx)
the_message_queue->number_of_pending_messages = 0;
113b81: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
the_message_queue->maximum_message_size = maximum_message_size;
113b88: 89 53 4c mov %edx,0x4c(%ebx)
113b8b: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
113b92: 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)) {
113b99: 89 d0 mov %edx,%eax
113b9b: f6 c2 03 test $0x3,%dl
113b9e: 74 0a je 113baa <_CORE_message_queue_Initialize+0x3e>
allocated_message_size += sizeof(uint32_t);
113ba0: 8d 42 04 lea 0x4(%edx),%eax
allocated_message_size &= ~(sizeof(uint32_t) - 1);
113ba3: 83 e0 fc and $0xfffffffc,%eax
}
if (allocated_message_size < maximum_message_size)
113ba6: 39 d0 cmp %edx,%eax
113ba8: 72 5f jb 113c09 <_CORE_message_queue_Initialize+0x9d><== NEVER TAKEN
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
113baa: 8d 70 14 lea 0x14(%eax),%esi
113bad: 89 f2 mov %esi,%edx
113baf: 0f af d7 imul %edi,%edx
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
113bb2: 39 c2 cmp %eax,%edx
113bb4: 72 53 jb 113c09 <_CORE_message_queue_Initialize+0x9d><== NEVER TAKEN
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
113bb6: 83 ec 0c sub $0xc,%esp
113bb9: 52 push %edx
113bba: e8 76 2e 00 00 call 116a35 <_Workspace_Allocate>
113bbf: 89 43 5c mov %eax,0x5c(%ebx)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
113bc2: 83 c4 10 add $0x10,%esp
113bc5: 85 c0 test %eax,%eax
113bc7: 74 40 je 113c09 <_CORE_message_queue_Initialize+0x9d>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
113bc9: 56 push %esi
113bca: 57 push %edi
113bcb: 50 push %eax
113bcc: 8d 43 68 lea 0x68(%ebx),%eax
113bcf: 50 push %eax
113bd0: e8 5b fe ff ff call 113a30 <_Chain_Initialize>
113bd5: 8d 43 54 lea 0x54(%ebx),%eax
113bd8: 89 43 50 mov %eax,0x50(%ebx)
113bdb: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx)
113be2: 8d 43 50 lea 0x50(%ebx),%eax
113be5: 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(
113be8: 6a 06 push $0x6
113bea: 68 80 00 00 00 push $0x80
113bef: 8b 45 0c mov 0xc(%ebp),%eax
113bf2: 83 38 01 cmpl $0x1,(%eax)
113bf5: 0f 94 c0 sete %al
113bf8: 0f b6 c0 movzbl %al,%eax
113bfb: 50 push %eax
113bfc: 53 push %ebx
113bfd: e8 9a 21 00 00 call 115d9c <_Thread_queue_Initialize>
113c02: b0 01 mov $0x1,%al
113c04: 83 c4 20 add $0x20,%esp
113c07: eb 02 jmp 113c0b <_CORE_message_queue_Initialize+0x9f>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
113c09: 31 c0 xor %eax,%eax
}
113c0b: 8d 65 f4 lea -0xc(%ebp),%esp
113c0e: 5b pop %ebx
113c0f: 5e pop %esi
113c10: 5f pop %edi
113c11: c9 leave
113c12: c3 ret
0010d6c0 <_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
)
{
10d6c0: 55 push %ebp
10d6c1: 89 e5 mov %esp,%ebp
10d6c3: 57 push %edi
10d6c4: 56 push %esi
10d6c5: 53 push %ebx
10d6c6: 83 ec 08 sub $0x8,%esp
10d6c9: 8b 5d 08 mov 0x8(%ebp),%ebx
10d6cc: 8b 75 0c mov 0xc(%ebp),%esi
10d6cf: 8b 45 10 mov 0x10(%ebp),%eax
ISR_Level level;
bool notify = false;
the_message->priority = submit_type;
10d6d2: 89 46 08 mov %eax,0x8(%esi)
switch ( submit_type ) {
10d6d5: 3d 00 00 00 80 cmp $0x80000000,%eax
10d6da: 74 33 je 10d70f <_CORE_message_queue_Insert_message+0x4f>
10d6dc: 3d ff ff ff 7f cmp $0x7fffffff,%eax
10d6e1: 8d 53 54 lea 0x54(%ebx),%edx
10d6e4: 89 55 ec mov %edx,-0x14(%ebp)
10d6e7: 75 4d jne 10d736 <_CORE_message_queue_Insert_message+0x76><== NEVER TAKEN
case CORE_MESSAGE_QUEUE_SEND_REQUEST:
_ISR_Disable( level );
10d6e9: 9c pushf
10d6ea: fa cli
10d6eb: 59 pop %ecx
if ( the_message_queue->number_of_pending_messages++ == 0 )
10d6ec: 8b 53 48 mov 0x48(%ebx),%edx
10d6ef: 8d 42 01 lea 0x1(%edx),%eax
10d6f2: 89 43 48 mov %eax,0x48(%ebx)
10d6f5: 85 d2 test %edx,%edx
10d6f7: 0f 94 45 f3 sete -0xd(%ebp)
10d6fb: 8b 45 ec mov -0x14(%ebp),%eax
10d6fe: 89 06 mov %eax,(%esi)
10d700: 8b 43 58 mov 0x58(%ebx),%eax
10d703: 89 73 58 mov %esi,0x58(%ebx)
10d706: 89 30 mov %esi,(%eax)
10d708: 89 46 04 mov %eax,0x4(%esi)
notify = true;
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
10d70b: 51 push %ecx
10d70c: 9d popf
10d70d: eb 5b jmp 10d76a <_CORE_message_queue_Insert_message+0xaa>
break;
case CORE_MESSAGE_QUEUE_URGENT_REQUEST:
_ISR_Disable( level );
10d70f: 9c pushf
10d710: fa cli
10d711: 59 pop %ecx
if ( the_message_queue->number_of_pending_messages++ == 0 )
10d712: 8b 53 48 mov 0x48(%ebx),%edx
10d715: 8d 42 01 lea 0x1(%edx),%eax
10d718: 89 43 48 mov %eax,0x48(%ebx)
10d71b: 85 d2 test %edx,%edx
10d71d: 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
10d721: 8d 43 50 lea 0x50(%ebx),%eax
10d724: 89 46 04 mov %eax,0x4(%esi)
10d727: 8b 43 50 mov 0x50(%ebx),%eax
10d72a: 89 73 50 mov %esi,0x50(%ebx)
10d72d: 89 06 mov %eax,(%esi)
10d72f: 89 70 04 mov %esi,0x4(%eax)
notify = true;
_CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
10d732: 51 push %ecx
10d733: 9d popf
10d734: eb 34 jmp 10d76a <_CORE_message_queue_Insert_message+0xaa>
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;
10d736: 8b 7b 50 mov 0x50(%ebx),%edi <== NOT EXECUTED
10d739: eb 07 jmp 10d742 <_CORE_message_queue_Insert_message+0x82><== 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 ) {
10d73b: 39 47 08 cmp %eax,0x8(%edi) <== NOT EXECUTED
10d73e: 7f 07 jg 10d747 <_CORE_message_queue_Insert_message+0x87><== NOT EXECUTED
the_node = the_node->next;
10d740: 8b 3f mov (%edi),%edi <== 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 ) ) {
10d742: 3b 7d ec cmp -0x14(%ebp),%edi <== NOT EXECUTED
10d745: 75 f4 jne 10d73b <_CORE_message_queue_Insert_message+0x7b><== NOT EXECUTED
continue;
}
break;
}
_ISR_Disable( level );
10d747: 9c pushf <== NOT EXECUTED
10d748: fa cli <== NOT EXECUTED
10d749: 59 pop %ecx <== NOT EXECUTED
if ( the_message_queue->number_of_pending_messages++ == 0 )
10d74a: 8b 53 48 mov 0x48(%ebx),%edx <== NOT EXECUTED
10d74d: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED
10d750: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED
10d753: 85 d2 test %edx,%edx <== NOT EXECUTED
10d755: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED
notify = true;
_Chain_Insert_unprotected( the_node->previous, &the_message->Node );
10d759: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED
10d75c: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED
10d75f: 8b 10 mov (%eax),%edx <== NOT EXECUTED
10d761: 89 30 mov %esi,(%eax) <== NOT EXECUTED
10d763: 89 16 mov %edx,(%esi) <== NOT EXECUTED
10d765: 89 72 04 mov %esi,0x4(%edx) <== NOT EXECUTED
_ISR_Enable( level );
10d768: 51 push %ecx <== NOT EXECUTED
10d769: 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 )
10d76a: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
10d76e: 74 15 je 10d785 <_CORE_message_queue_Insert_message+0xc5>
10d770: 8b 4b 60 mov 0x60(%ebx),%ecx
10d773: 85 c9 test %ecx,%ecx
10d775: 74 0e je 10d785 <_CORE_message_queue_Insert_message+0xc5><== ALWAYS TAKEN
(*the_message_queue->notify_handler)( the_message_queue->notify_argument );
10d777: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED
10d77a: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
10d77d: 5b pop %ebx <== NOT EXECUTED
10d77e: 5e pop %esi <== NOT EXECUTED
10d77f: 5b pop %ebx <== NOT EXECUTED
10d780: 5e pop %esi <== NOT EXECUTED
10d781: 5f pop %edi <== NOT EXECUTED
10d782: 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 );
10d783: ff e1 jmp *%ecx <== NOT EXECUTED
}
10d785: 58 pop %eax
10d786: 5a pop %edx
10d787: 5b pop %ebx
10d788: 5e pop %esi
10d789: 5f pop %edi
10d78a: c9 leave
10d78b: c3 ret
00113c14 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
113c14: 55 push %ebp
113c15: 89 e5 mov %esp,%ebp
113c17: 57 push %edi
113c18: 56 push %esi
113c19: 53 push %ebx
113c1a: 83 ec 2c sub $0x2c,%esp
113c1d: 8b 45 08 mov 0x8(%ebp),%eax
113c20: 89 45 d0 mov %eax,-0x30(%ebp)
113c23: 8b 55 0c mov 0xc(%ebp),%edx
113c26: 89 55 ec mov %edx,-0x14(%ebp)
113c29: 8b 7d 10 mov 0x10(%ebp),%edi
113c2c: 89 7d e8 mov %edi,-0x18(%ebp)
113c2f: 8b 45 14 mov 0x14(%ebp),%eax
113c32: 89 45 e4 mov %eax,-0x1c(%ebp)
113c35: 8b 55 1c mov 0x1c(%ebp),%edx
113c38: 89 55 dc mov %edx,-0x24(%ebp)
113c3b: 8a 45 18 mov 0x18(%ebp),%al
113c3e: 88 45 e3 mov %al,-0x1d(%ebp)
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
Thread_Control *the_thread;
executing = _Thread_Executing;
113c41: 8b 35 a0 28 13 00 mov 0x1328a0,%esi
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
113c47: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi)
_ISR_Disable( level );
113c4e: 9c pushf
113c4f: fa cli
113c50: 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(
113c51: 8b 55 d0 mov -0x30(%ebp),%edx
113c54: 8b 5a 50 mov 0x50(%edx),%ebx
113c57: 89 d0 mov %edx,%eax
113c59: 83 c0 54 add $0x54,%eax
113c5c: 39 c3 cmp %eax,%ebx
113c5e: 0f 84 9e 00 00 00 je 113d02 <_CORE_message_queue_Seize+0xee>
113c64: 8b 13 mov (%ebx),%edx
113c66: 8b 7d d0 mov -0x30(%ebp),%edi
113c69: 89 57 50 mov %edx,0x50(%edi)
113c6c: 89 f8 mov %edi,%eax
113c6e: 83 c0 50 add $0x50,%eax
113c71: 89 42 04 mov %eax,0x4(%edx)
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
113c74: 85 db test %ebx,%ebx
113c76: 0f 84 86 00 00 00 je 113d02 <_CORE_message_queue_Seize+0xee><== NEVER TAKEN
the_message_queue->number_of_pending_messages -= 1;
113c7c: ff 4f 48 decl 0x48(%edi)
_ISR_Enable( level );
113c7f: 51 push %ecx
113c80: 9d popf
*size_p = the_message->Contents.size;
113c81: 8b 43 0c mov 0xc(%ebx),%eax
113c84: 8b 55 e4 mov -0x1c(%ebp),%edx
113c87: 89 02 mov %eax,(%edx)
_Thread_Executing->Wait.count = the_message->priority;
113c89: 8b 53 08 mov 0x8(%ebx),%edx
113c8c: a1 a0 28 13 00 mov 0x1328a0,%eax
113c91: 89 50 24 mov %edx,0x24(%eax)
_CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size_p);
113c94: 8d 7b 10 lea 0x10(%ebx),%edi
113c97: 89 7d f0 mov %edi,-0x10(%ebp)
* alignments are possible.
* Returns pointer to the start of the memory block if success, NULL if
* failure.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
113c9a: 8b 45 e4 mov -0x1c(%ebp),%eax
113c9d: 8b 08 mov (%eax),%ecx
113c9f: 8b 7d e8 mov -0x18(%ebp),%edi
113ca2: 8b 75 f0 mov -0x10(%ebp),%esi
113ca5: 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 );
113ca7: 83 ec 0c sub $0xc,%esp
113caa: ff 75 d0 pushl -0x30(%ebp)
113cad: e8 9e 1d 00 00 call 115a50 <_Thread_queue_Dequeue>
113cb2: 89 c2 mov %eax,%edx
if ( !the_thread ) {
113cb4: 83 c4 10 add $0x10,%esp
113cb7: 85 c0 test %eax,%eax
113cb9: 75 18 jne 113cd3 <_CORE_message_queue_Seize+0xbf><== NEVER TAKEN
* @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
113cbb: 89 5d 0c mov %ebx,0xc(%ebp)
113cbe: 8b 45 d0 mov -0x30(%ebp),%eax
113cc1: 83 c0 68 add $0x68,%eax
113cc4: 89 45 08 mov %eax,0x8(%ebp)
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
113cc7: 8d 65 f4 lea -0xc(%ebp),%esp
113cca: 5b pop %ebx
113ccb: 5e pop %esi
113ccc: 5f pop %edi
113ccd: c9 leave
113cce: e9 11 fd ff ff jmp 1139e4 <_Chain_Append>
* There was a thread waiting to send a message. This code
* puts the messages in the message queue on behalf of the
* waiting task.
*/
the_message->priority = the_thread->Wait.count;
113cd3: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED
113cd6: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED
the_message->Contents.size = (size_t) the_thread->Wait.option;
113cd9: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED
113cdc: 89 4b 0c mov %ecx,0xc(%ebx) <== NOT EXECUTED
* 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
113cdf: 8b 72 2c mov 0x2c(%edx),%esi <== NOT EXECUTED
113ce2: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED
113ce5: 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(
113ce7: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED
113cea: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED
113ced: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED
113cf0: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED
113cf3: 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 );
}
113cf6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
113cf9: 5b pop %ebx <== NOT EXECUTED
113cfa: 5e pop %esi <== NOT EXECUTED
113cfb: 5f pop %edi <== NOT EXECUTED
113cfc: 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(
113cfd: e9 ba 46 00 00 jmp 1183bc <_CORE_message_queue_Insert_message><== NOT EXECUTED
the_message->priority
);
return;
}
if ( !wait ) {
113d02: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
113d06: 75 11 jne 113d19 <_CORE_message_queue_Seize+0x105>
_ISR_Enable( level );
113d08: 51 push %ecx
113d09: 9d popf
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
113d0a: c7 46 34 04 00 00 00 movl $0x4,0x34(%esi)
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
113d11: 8d 65 f4 lea -0xc(%ebp),%esp
113d14: 5b pop %ebx
113d15: 5e pop %esi
113d16: 5f pop %edi
113d17: c9 leave
113d18: 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
113d19: 8b 55 d0 mov -0x30(%ebp),%edx
113d1c: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx)
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
return;
}
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
113d23: 89 56 44 mov %edx,0x44(%esi)
executing->Wait.id = id;
113d26: 8b 7d ec mov -0x14(%ebp),%edi
113d29: 89 7e 20 mov %edi,0x20(%esi)
executing->Wait.return_argument_second.mutable_object = buffer;
113d2c: 8b 45 e8 mov -0x18(%ebp),%eax
113d2f: 89 46 2c mov %eax,0x2c(%esi)
executing->Wait.return_argument = size_p;
113d32: 8b 55 e4 mov -0x1c(%ebp),%edx
113d35: 89 56 28 mov %edx,0x28(%esi)
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
113d38: 51 push %ecx
113d39: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
113d3a: c7 45 10 6c 5e 11 00 movl $0x115e6c,0x10(%ebp)
113d41: 8b 7d dc mov -0x24(%ebp),%edi
113d44: 89 7d 0c mov %edi,0xc(%ebp)
113d47: 8b 45 d0 mov -0x30(%ebp),%eax
113d4a: 89 45 08 mov %eax,0x8(%ebp)
}
113d4d: 8d 65 f4 lea -0xc(%ebp),%esp
113d50: 5b pop %ebx
113d51: 5e pop %esi
113d52: 5f pop %edi
113d53: 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 );
113d54: e9 0f 1e 00 00 jmp 115b68 <_Thread_queue_Enqueue_with_handler>
00109a98 <_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
)
{
109a98: 55 push %ebp
109a99: 89 e5 mov %esp,%ebp
109a9b: 57 push %edi
109a9c: 56 push %esi
109a9d: 53 push %ebx
109a9e: 83 ec 1c sub $0x1c,%esp
109aa1: 8b 5d 10 mov 0x10(%ebp),%ebx
109aa4: 8a 45 20 mov 0x20(%ebp),%al
109aa7: 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 ) {
109aaa: b8 01 00 00 00 mov $0x1,%eax
109aaf: 8b 55 08 mov 0x8(%ebp),%edx
109ab2: 3b 5a 4c cmp 0x4c(%edx),%ebx
109ab5: 0f 87 d9 00 00 00 ja 109b94 <_CORE_message_queue_Submit+0xfc><== NEVER TAKEN
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
109abb: 8b 75 08 mov 0x8(%ebp),%esi
109abe: 83 7e 48 00 cmpl $0x0,0x48(%esi)
109ac2: 75 2e jne 109af2 <_CORE_message_queue_Submit+0x5a>
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
109ac4: 83 ec 0c sub $0xc,%esp
109ac7: 56 push %esi
109ac8: e8 57 16 00 00 call 10b124 <_Thread_queue_Dequeue>
109acd: 89 c2 mov %eax,%edx
if ( the_thread ) {
109acf: 83 c4 10 add $0x10,%esp
109ad2: 85 c0 test %eax,%eax
109ad4: 74 1c je 109af2 <_CORE_message_queue_Submit+0x5a>
* alignments are possible.
* Returns pointer to the start of the memory block if success, NULL if
* failure.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
109ad6: 8b 78 2c mov 0x2c(%eax),%edi
109ad9: 8b 75 0c mov 0xc(%ebp),%esi
109adc: 89 d9 mov %ebx,%ecx
109ade: 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;
109ae0: 8b 40 28 mov 0x28(%eax),%eax
109ae3: 89 18 mov %ebx,(%eax)
the_thread->Wait.count = submit_type;
109ae5: 8b 45 1c mov 0x1c(%ebp),%eax
109ae8: 89 42 24 mov %eax,0x24(%edx)
109aeb: 31 c0 xor %eax,%eax
109aed: e9 a2 00 00 00 jmp 109b94 <_CORE_message_queue_Submit+0xfc>
/*
* No one waiting on the message queue at this time, so attempt to
* queue the message up for a future receive.
*/
if ( the_message_queue->number_of_pending_messages <
109af2: 8b 55 08 mov 0x8(%ebp),%edx
109af5: 8b 42 48 mov 0x48(%edx),%eax
109af8: 3b 42 44 cmp 0x44(%edx),%eax
109afb: 73 37 jae 109b34 <_CORE_message_queue_Submit+0x9c>
);
/**
* This function sets @a *size to the size of the block of user memory
* which begins at @a starting_address. The size returned in @a *size could
* be greater than the size requested for allocation.
109afd: 83 ec 0c sub $0xc,%esp
109b00: 89 d0 mov %edx,%eax
109b02: 83 c0 68 add $0x68,%eax
109b05: 50 push %eax
109b06: e8 65 ff ff ff call 109a70 <_Chain_Get>
/*
* NOTE: If the system is consistent, this error should never occur.
*/
if ( !the_message ) {
109b0b: 83 c4 10 add $0x10,%esp
109b0e: 85 c0 test %eax,%eax
109b10: 74 7d je 109b8f <_CORE_message_queue_Submit+0xf7><== NEVER TAKEN
* alignments are possible.
* Returns pointer to the start of the memory block if success, NULL if
* failure.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
109b12: 8d 78 10 lea 0x10(%eax),%edi
109b15: 8b 75 0c mov 0xc(%ebp),%esi
109b18: 89 d9 mov %ebx,%ecx
109b1a: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
_CORE_message_queue_Copy_buffer(
buffer,
the_message->Contents.buffer,
size
);
the_message->Contents.size = size;
109b1c: 89 58 0c mov %ebx,0xc(%eax)
the_message->priority = submit_type;
109b1f: 8b 55 1c mov 0x1c(%ebp),%edx
109b22: 89 50 08 mov %edx,0x8(%eax)
_CORE_message_queue_Insert_message(
109b25: 51 push %ecx
109b26: 52 push %edx
109b27: 50 push %eax
109b28: ff 75 08 pushl 0x8(%ebp)
109b2b: e8 90 3b 00 00 call 10d6c0 <_CORE_message_queue_Insert_message>
109b30: 31 c0 xor %eax,%eax
109b32: eb 56 jmp 109b8a <_CORE_message_queue_Submit+0xf2>
* No message buffers were available so we may need to return an
* overflow error or block the sender until the message is placed
* on the queue.
*/
if ( !wait ) {
109b34: b8 02 00 00 00 mov $0x2,%eax
109b39: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
109b3d: 74 55 je 109b94 <_CORE_message_queue_Submit+0xfc><== 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() ) {
109b3f: a1 7c cb 11 00 mov 0x11cb7c,%eax <== NOT EXECUTED
109b44: 85 c0 test %eax,%eax <== NOT EXECUTED
109b46: 75 47 jne 109b8f <_CORE_message_queue_Submit+0xf7><== 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;
109b48: a1 a0 cb 11 00 mov 0x11cba0,%eax <== NOT EXECUTED
_ISR_Disable( level );
109b4d: 9c pushf <== NOT EXECUTED
109b4e: fa cli <== NOT EXECUTED
109b4f: 59 pop %ecx <== 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
109b50: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
109b53: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi) <== NOT EXECUTED
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
109b5a: 89 70 44 mov %esi,0x44(%eax) <== NOT EXECUTED
executing->Wait.id = id;
109b5d: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED
109b60: 89 50 20 mov %edx,0x20(%eax) <== NOT EXECUTED
executing->Wait.return_argument_second.immutable_object = buffer;
109b63: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
109b66: 89 50 2c mov %edx,0x2c(%eax) <== NOT EXECUTED
executing->Wait.option = (uint32_t) size;
109b69: 89 58 30 mov %ebx,0x30(%eax) <== NOT EXECUTED
executing->Wait.count = submit_type;
109b6c: 8b 75 1c mov 0x1c(%ebp),%esi <== NOT EXECUTED
109b6f: 89 70 24 mov %esi,0x24(%eax) <== NOT EXECUTED
_ISR_Enable( level );
109b72: 51 push %ecx <== NOT EXECUTED
109b73: 9d popf <== NOT EXECUTED
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
109b74: 50 push %eax <== NOT EXECUTED
109b75: 68 40 b5 10 00 push $0x10b540 <== NOT EXECUTED
109b7a: ff 75 24 pushl 0x24(%ebp) <== NOT EXECUTED
109b7d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
109b80: e8 b7 16 00 00 call 10b23c <_Thread_queue_Enqueue_with_handler><== NOT EXECUTED
109b85: b8 07 00 00 00 mov $0x7,%eax <== NOT EXECUTED
109b8a: 83 c4 10 add $0x10,%esp
109b8d: eb 05 jmp 109b94 <_CORE_message_queue_Submit+0xfc>
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
109b8f: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED
}
109b94: 8d 65 f4 lea -0xc(%ebp),%esp
109b97: 5b pop %ebx
109b98: 5e pop %esi
109b99: 5f pop %edi
109b9a: c9 leave
109b9b: c3 ret
00109ba8 <_CORE_mutex_Initialize>:
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
109ba8: 55 push %ebp
109ba9: 89 e5 mov %esp,%ebp
109bab: 57 push %edi
109bac: 56 push %esi
109bad: 53 push %ebx
109bae: 83 ec 0c sub $0xc,%esp
109bb1: 8b 5d 08 mov 0x8(%ebp),%ebx
109bb4: 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;
109bb7: 8d 7b 40 lea 0x40(%ebx),%edi
109bba: b9 04 00 00 00 mov $0x4,%ecx
109bbf: 8b 75 0c mov 0xc(%ebp),%esi
109bc2: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_mutex->lock = initial_lock;
109bc4: 89 43 50 mov %eax,0x50(%ebx)
the_mutex->blocked_count = 0;
109bc7: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx)
if ( initial_lock == CORE_MUTEX_LOCKED ) {
109bce: 85 c0 test %eax,%eax
109bd0: 75 35 jne 109c07 <_CORE_mutex_Initialize+0x5f>
the_mutex->nest_count = 1;
109bd2: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx)
the_mutex->holder = _Thread_Executing;
109bd9: 8b 15 a0 cb 11 00 mov 0x11cba0,%edx
109bdf: 89 53 5c mov %edx,0x5c(%ebx)
the_mutex->holder_id = _Thread_Executing->Object.id;
109be2: 8b 42 08 mov 0x8(%edx),%eax
109be5: 89 43 60 mov %eax,0x60(%ebx)
/**
* This function attempts to allocate a memory block of @a size bytes from
* @a the_heap so that the start of the user memory is aligned on the
* @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT.
* Any other value of @a alignment is taken "as is", i.e., even odd
109be8: 8b 43 48 mov 0x48(%ebx),%eax
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
109beb: 83 f8 02 cmp $0x2,%eax
109bee: 74 05 je 109bf5 <_CORE_mutex_Initialize+0x4d>
109bf0: 83 f8 03 cmp $0x3,%eax
109bf3: 75 27 jne 109c1c <_CORE_mutex_Initialize+0x74><== ALWAYS TAKEN
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
109bf5: 8b 42 14 mov 0x14(%edx),%eax
109bf8: b9 06 00 00 00 mov $0x6,%ecx
109bfd: 3b 43 4c cmp 0x4c(%ebx),%eax
109c00: 72 3a jb 109c3c <_CORE_mutex_Initialize+0x94><== NEVER TAKEN
_Chain_Prepend_unprotected( &_Thread_Executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = _Thread_Executing->current_priority;
#endif
_Thread_Executing->resource_count++;
109c02: ff 42 1c incl 0x1c(%edx)
109c05: eb 15 jmp 109c1c <_CORE_mutex_Initialize+0x74>
}
} else {
the_mutex->nest_count = 0;
109c07: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx)
the_mutex->holder = NULL;
109c0e: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
the_mutex->holder_id = 0;
109c15: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
}
_Thread_queue_Initialize(
109c1c: 6a 05 push $0x5
109c1e: 68 00 04 00 00 push $0x400
109c23: 8b 45 0c mov 0xc(%ebp),%eax
109c26: 83 78 08 00 cmpl $0x0,0x8(%eax)
109c2a: 0f 95 c0 setne %al
109c2d: 0f b6 c0 movzbl %al,%eax
109c30: 50 push %eax
109c31: 53 push %ebx
109c32: e8 39 18 00 00 call 10b470 <_Thread_queue_Initialize>
109c37: 31 c9 xor %ecx,%ecx
109c39: 83 c4 10 add $0x10,%esp
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
109c3c: 89 c8 mov %ecx,%eax
109c3e: 8d 65 f4 lea -0xc(%ebp),%esp
109c41: 5b pop %ebx
109c42: 5e pop %esi
109c43: 5f pop %edi
109c44: c9 leave
109c45: c3 ret
00109c94 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
109c94: 55 push %ebp
109c95: 89 e5 mov %esp,%ebp
109c97: 56 push %esi
109c98: 53 push %ebx
109c99: 8b 75 08 mov 0x8(%ebp),%esi
109c9c: 8a 5d 10 mov 0x10(%ebp),%bl
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
109c9f: a1 e0 ca 11 00 mov 0x11cae0,%eax
109ca4: 85 c0 test %eax,%eax
109ca6: 74 19 je 109cc1 <_CORE_mutex_Seize+0x2d>
109ca8: 84 db test %bl,%bl
109caa: 74 15 je 109cc1 <_CORE_mutex_Seize+0x2d><== NEVER TAKEN
109cac: 83 3d 80 cc 11 00 01 cmpl $0x1,0x11cc80
109cb3: 76 0c jbe 109cc1 <_CORE_mutex_Seize+0x2d>
109cb5: 50 push %eax
109cb6: 6a 13 push $0x13
109cb8: 6a 00 push $0x0
109cba: 6a 00 push $0x0
109cbc: e8 93 04 00 00 call 10a154 <_Internal_error_Occurred>
109cc1: 50 push %eax
109cc2: 50 push %eax
109cc3: 8d 45 18 lea 0x18(%ebp),%eax
109cc6: 50 push %eax
109cc7: 56 push %esi
109cc8: e8 bf 3a 00 00 call 10d78c <_CORE_mutex_Seize_interrupt_trylock>
109ccd: 83 c4 10 add $0x10,%esp
109cd0: 85 c0 test %eax,%eax
109cd2: 74 49 je 109d1d <_CORE_mutex_Seize+0x89>
109cd4: 84 db test %bl,%bl
109cd6: 75 12 jne 109cea <_CORE_mutex_Seize+0x56>
109cd8: ff 75 18 pushl 0x18(%ebp)
109cdb: 9d popf
109cdc: a1 a0 cb 11 00 mov 0x11cba0,%eax
109ce1: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax)
109ce8: eb 33 jmp 109d1d <_CORE_mutex_Seize+0x89>
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
* This routine grows @a the_heap memory area using the size bytes which
109cea: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi)
109cf1: 8b 15 a0 cb 11 00 mov 0x11cba0,%edx
109cf7: 89 72 44 mov %esi,0x44(%edx)
109cfa: 8b 45 0c mov 0xc(%ebp),%eax
109cfd: 89 42 20 mov %eax,0x20(%edx)
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
109d00: a1 e0 ca 11 00 mov 0x11cae0,%eax
109d05: 40 inc %eax
109d06: a3 e0 ca 11 00 mov %eax,0x11cae0
109d0b: ff 75 18 pushl 0x18(%ebp)
109d0e: 9d popf
109d0f: 53 push %ebx
109d10: 53 push %ebx
109d11: ff 75 14 pushl 0x14(%ebp)
109d14: 56 push %esi
109d15: e8 2e ff ff ff call 109c48 <_CORE_mutex_Seize_interrupt_blocking>
109d1a: 83 c4 10 add $0x10,%esp
}
109d1d: 8d 65 f8 lea -0x8(%ebp),%esp
109d20: 5b pop %ebx
109d21: 5e pop %esi
109d22: c9 leave
109d23: c3 ret
0010d78c <_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
)
{
10d78c: 55 push %ebp
10d78d: 89 e5 mov %esp,%ebp
10d78f: 56 push %esi
10d790: 53 push %ebx
10d791: 8b 4d 08 mov 0x8(%ebp),%ecx
bool _Protected_heap_Get_block_size(
Heap_Control *the_heap,
void *starting_address,
size_t *size
);
10d794: 8b 45 0c mov 0xc(%ebp),%eax
10d797: 8b 30 mov (%eax),%esi
/**
* This function tries to resize in place the block that is pointed to by the
* @a starting_address to the new @a size.
*
10d799: 8b 15 a0 cb 11 00 mov 0x11cba0,%edx
* @param[in] the_heap is the heap to operate upon
10d79f: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
* @param[in] starting_address is the starting address of the user block
10d7a6: 83 79 50 00 cmpl $0x0,0x50(%ecx)
10d7aa: 0f 84 82 00 00 00 je 10d832 <_CORE_mutex_Seize_interrupt_trylock+0xa6>
* to be resized
10d7b0: c7 41 50 00 00 00 00 movl $0x0,0x50(%ecx)
* @param[in] size is the new size
10d7b7: 89 51 5c mov %edx,0x5c(%ecx)
*
10d7ba: 8b 42 08 mov 0x8(%edx),%eax
10d7bd: 89 41 60 mov %eax,0x60(%ecx)
* @return TRUE if successfully able to resize the block.
10d7c0: 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
10d7c7: 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.
10d7ca: 83 f8 02 cmp $0x2,%eax
10d7cd: 74 05 je 10d7d4 <_CORE_mutex_Seize_interrupt_trylock+0x48><== ALWAYS TAKEN
10d7cf: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED
10d7d2: 75 03 jne 10d7d7 <_CORE_mutex_Seize_interrupt_trylock+0x4b><== NOT EXECUTED
void *starting_address,
size_t size
);
/**
* This routine returns the block of memory which begins
10d7d4: 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.
*
10d7d7: 83 79 48 03 cmpl $0x3,0x48(%ecx)
10d7db: 74 04 je 10d7e1 <_CORE_mutex_Seize_interrupt_trylock+0x55><== NEVER TAKEN
* @param[in] the_heap is the heap to operate upon
10d7dd: 56 push %esi
10d7de: 9d popf
10d7df: eb 74 jmp 10d855 <_CORE_mutex_Seize_interrupt_trylock+0xc9>
void *start_address
);
/**
* This routine walks the heap to verify its integrity.
*
10d7e1: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED
* @param[in] the_heap is the heap to operate upon
10d7e4: 3b 41 4c cmp 0x4c(%ecx),%eax <== NOT EXECUTED
10d7e7: 75 04 jne 10d7ed <_CORE_mutex_Seize_interrupt_trylock+0x61><== NOT EXECUTED
* @param[in] source is a user specified integer which may be used to
10d7e9: 56 push %esi <== NOT EXECUTED
10d7ea: 9d popf <== NOT EXECUTED
10d7eb: eb 68 jmp 10d855 <_CORE_mutex_Seize_interrupt_trylock+0xc9><== NOT EXECUTED
* indicate where in the application this was invoked from
* @param[in] do_dump is set to TRUE if errors should be printed
* @return TRUE if the test passed fine, FALSE otherwise.
*/
10d7ed: 76 27 jbe 10d816 <_CORE_mutex_Seize_interrupt_trylock+0x8a><== NOT EXECUTED
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10d7ef: a1 e0 ca 11 00 mov 0x11cae0,%eax <== NOT EXECUTED
10d7f4: 40 inc %eax <== NOT EXECUTED
10d7f5: a3 e0 ca 11 00 mov %eax,0x11cae0 <== 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,
10d7fa: 56 push %esi <== NOT EXECUTED
10d7fb: 9d popf <== NOT EXECUTED
int source,
10d7fc: 50 push %eax <== NOT EXECUTED
10d7fd: 6a 00 push $0x0 <== NOT EXECUTED
10d7ff: ff 71 4c pushl 0x4c(%ecx) <== NOT EXECUTED
10d802: ff 71 5c pushl 0x5c(%ecx) <== NOT EXECUTED
10d805: e8 42 d1 ff ff call 10a94c <_Thread_Change_priority><== NOT EXECUTED
bool do_dump
);
/**
* This routine walks the heap and tots up the free and allocated
10d80a: e8 dd d5 ff ff call 10adec <_Thread_Enable_dispatch><== NOT EXECUTED
10d80f: 31 c0 xor %eax,%eax <== NOT EXECUTED
10d811: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10d814: eb 48 jmp 10d85e <_CORE_mutex_Seize_interrupt_trylock+0xd2><== NOT EXECUTED
* sizes.
*
* @param[in] the_heap pointer to heap header
* @param[in] the_info pointer to a status information area
10d816: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) <== NOT EXECUTED
*
10d81d: c7 41 50 01 00 00 00 movl $0x1,0x50(%ecx) <== NOT EXECUTED
* @return true if successfully able to return information
10d824: c7 41 54 00 00 00 00 movl $0x0,0x54(%ecx) <== NOT EXECUTED
*/
10d82b: ff 4a 1c decl 0x1c(%edx) <== NOT EXECUTED
bool _Protected_heap_Get_information(
10d82e: 56 push %esi <== NOT EXECUTED
10d82f: 9d popf <== NOT EXECUTED
10d830: eb 23 jmp 10d855 <_CORE_mutex_Seize_interrupt_trylock+0xc9><== NOT EXECUTED
* 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.
10d832: 8b 59 5c mov 0x5c(%ecx),%ebx
10d835: 39 d3 cmp %edx,%ebx
10d837: 75 20 jne 10d859 <_CORE_mutex_Seize_interrupt_trylock+0xcd>
*/
10d839: 8b 41 40 mov 0x40(%ecx),%eax
10d83c: 85 c0 test %eax,%eax
10d83e: 74 05 je 10d845 <_CORE_mutex_Seize_interrupt_trylock+0xb9>
10d840: 48 dec %eax
10d841: 75 16 jne 10d859 <_CORE_mutex_Seize_interrupt_trylock+0xcd>
10d843: eb 07 jmp 10d84c <_CORE_mutex_Seize_interrupt_trylock+0xc0>
bool _Protected_heap_Get_free_information(
Heap_Control *the_heap,
10d845: ff 41 54 incl 0x54(%ecx)
Heap_Information *info
10d848: 56 push %esi
10d849: 9d popf
10d84a: eb 09 jmp 10d855 <_CORE_mutex_Seize_interrupt_trylock+0xc9>
);
#ifdef __cplusplus
10d84c: c7 43 34 02 00 00 00 movl $0x2,0x34(%ebx)
}
10d853: 56 push %esi
10d854: 9d popf
10d855: 31 c0 xor %eax,%eax
10d857: eb 05 jmp 10d85e <_CORE_mutex_Seize_interrupt_trylock+0xd2>
10d859: b8 01 00 00 00 mov $0x1,%eax
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}
10d85e: 8d 65 f8 lea -0x8(%ebp),%esp
10d861: 5b pop %ebx
10d862: 5e pop %esi
10d863: c9 leave
10d864: c3 ret
00109d24 <_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
)
{
109d24: 55 push %ebp
109d25: 89 e5 mov %esp,%ebp
109d27: 53 push %ebx
109d28: 83 ec 04 sub $0x4,%esp
109d2b: 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;
109d2e: 8b 4b 5c mov 0x5c(%ebx),%ecx
* allowed when the mutex in quetion is FIFO or simple Priority
* discipline. But Priority Ceiling or Priority Inheritance mutexes
* must be released by the thread which acquired them.
*/
if ( the_mutex->Attributes.only_owner_release ) {
109d31: 80 7b 44 00 cmpb $0x0,0x44(%ebx)
109d35: 74 11 je 109d48 <_CORE_mutex_Surrender+0x24>
if ( !_Thread_Is_executing( holder ) )
109d37: b8 03 00 00 00 mov $0x3,%eax
109d3c: 3b 0d a0 cb 11 00 cmp 0x11cba0,%ecx
109d42: 0f 85 cb 00 00 00 jne 109e13 <_CORE_mutex_Surrender+0xef>
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
}
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
109d48: 8b 43 54 mov 0x54(%ebx),%eax
109d4b: 85 c0 test %eax,%eax
109d4d: 0f 84 be 00 00 00 je 109e11 <_CORE_mutex_Surrender+0xed>
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
109d53: 48 dec %eax
109d54: 89 43 54 mov %eax,0x54(%ebx)
if ( the_mutex->nest_count != 0 ) {
109d57: 85 c0 test %eax,%eax
109d59: 74 17 je 109d72 <_CORE_mutex_Surrender+0x4e>
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
109d5b: 8b 53 40 mov 0x40(%ebx),%edx
109d5e: 85 d2 test %edx,%edx
109d60: 0f 84 ab 00 00 00 je 109e11 <_CORE_mutex_Surrender+0xed><== ALWAYS TAKEN
109d66: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED
109d6b: 4a dec %edx <== NOT EXECUTED
109d6c: 0f 84 a1 00 00 00 je 109e13 <_CORE_mutex_Surrender+0xef><== NOT EXECUTED
/**
* This function attempts to allocate a memory block of @a size bytes from
* @a the_heap so that the start of the user memory is aligned on the
* @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT.
* Any other value of @a alignment is taken "as is", i.e., even odd
109d72: 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 ) ||
109d75: 83 f8 02 cmp $0x2,%eax
109d78: 74 05 je 109d7f <_CORE_mutex_Surrender+0x5b>
109d7a: 83 f8 03 cmp $0x3,%eax
109d7d: 75 03 jne 109d82 <_CORE_mutex_Surrender+0x5e><== ALWAYS TAKEN
the_mutex->nest_count++;
return CORE_MUTEX_RELEASE_NOT_ORDER;
}
first_node = _Chain_Get_first_unprotected(&holder->lock_mutex);
#endif
holder->resource_count--;
109d7f: ff 49 1c decl 0x1c(%ecx)
}
the_mutex->holder = NULL;
109d82: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
the_mutex->holder_id = 0;
109d89: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
109d90: 8b 43 48 mov 0x48(%ebx),%eax
/*
* Whether or not someone is waiting for the mutex, an
* inherited priority must be lowered if this is the last
* mutex (i.e. resource) this task has.
*/
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
109d93: 83 f8 02 cmp $0x2,%eax
109d96: 74 05 je 109d9d <_CORE_mutex_Surrender+0x79>
109d98: 83 f8 03 cmp $0x3,%eax
109d9b: 75 1b jne 109db8 <_CORE_mutex_Surrender+0x94><== ALWAYS TAKEN
_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 &&
109d9d: 83 79 1c 00 cmpl $0x0,0x1c(%ecx)
109da1: 75 15 jne 109db8 <_CORE_mutex_Surrender+0x94>
109da3: 8b 41 18 mov 0x18(%ecx),%eax
109da6: 3b 41 14 cmp 0x14(%ecx),%eax
109da9: 74 0d je 109db8 <_CORE_mutex_Surrender+0x94>
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, TRUE );
109dab: 52 push %edx
109dac: 6a 01 push $0x1
109dae: 50 push %eax
109daf: 51 push %ecx
109db0: e8 97 0b 00 00 call 10a94c <_Thread_Change_priority>
109db5: 83 c4 10 add $0x10,%esp
/*
* Now we check if another thread was waiting for this mutex. If so,
* transfer the mutex to that thread.
*/
if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) {
109db8: 83 ec 0c sub $0xc,%esp
109dbb: 53 push %ebx
109dbc: e8 63 13 00 00 call 10b124 <_Thread_queue_Dequeue>
109dc1: 89 c2 mov %eax,%edx
109dc3: 83 c4 10 add $0x10,%esp
109dc6: 85 c0 test %eax,%eax
109dc8: 74 40 je 109e0a <_CORE_mutex_Surrender+0xe6>
} else
#endif
{
the_mutex->holder = the_thread;
109dca: 89 43 5c mov %eax,0x5c(%ebx)
the_mutex->holder_id = the_thread->Object.id;
109dcd: 8b 40 08 mov 0x8(%eax),%eax
109dd0: 89 43 60 mov %eax,0x60(%ebx)
the_mutex->nest_count = 1;
109dd3: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx)
switch ( the_mutex->Attributes.discipline ) {
109dda: 8b 43 48 mov 0x48(%ebx),%eax
109ddd: 83 f8 02 cmp $0x2,%eax
109de0: 74 07 je 109de9 <_CORE_mutex_Surrender+0xc5>
109de2: 83 f8 03 cmp $0x3,%eax
109de5: 75 2a jne 109e11 <_CORE_mutex_Surrender+0xed><== ALWAYS TAKEN
109de7: eb 05 jmp 109dee <_CORE_mutex_Surrender+0xca><== 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++;
109de9: ff 42 1c incl 0x1c(%edx)
109dec: eb 23 jmp 109e11 <_CORE_mutex_Surrender+0xed>
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
#ifdef __RTEMS_STRICT_ORDER_MUTEX__
_Chain_Prepend_unprotected(&the_thread->lock_mutex,&the_mutex->queue.lock_queue);
the_mutex->queue.priority_before = the_thread->current_priority;
#endif
the_thread->resource_count++;
109dee: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
109df1: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED
109df4: 3b 42 14 cmp 0x14(%edx),%eax <== NOT EXECUTED
109df7: 73 18 jae 109e11 <_CORE_mutex_Surrender+0xed><== NOT EXECUTED
the_thread->current_priority){
_Thread_Change_priority(
109df9: 51 push %ecx <== NOT EXECUTED
109dfa: 6a 00 push $0x0 <== NOT EXECUTED
109dfc: 50 push %eax <== NOT EXECUTED
109dfd: 52 push %edx <== NOT EXECUTED
109dfe: e8 49 0b 00 00 call 10a94c <_Thread_Change_priority><== NOT EXECUTED
109e03: 31 c0 xor %eax,%eax <== NOT EXECUTED
109e05: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109e08: eb 09 jmp 109e13 <_CORE_mutex_Surrender+0xef><== NOT EXECUTED
}
break;
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
109e0a: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx)
109e11: 31 c0 xor %eax,%eax
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
109e13: 8b 5d fc mov -0x4(%ebp),%ebx
109e16: c9 leave
109e17: c3 ret
00109e64 <_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
)
{
109e64: 55 push %ebp
109e65: 89 e5 mov %esp,%ebp
109e67: 53 push %ebx
109e68: 83 ec 10 sub $0x10,%esp
109e6b: 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)) ) {
109e6e: 53 push %ebx
109e6f: e8 b0 12 00 00 call 10b124 <_Thread_queue_Dequeue>
109e74: 83 c4 10 add $0x10,%esp
109e77: 31 d2 xor %edx,%edx
109e79: 85 c0 test %eax,%eax
109e7b: 75 18 jne 109e95 <_CORE_semaphore_Surrender+0x31>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
109e7d: 9c pushf
109e7e: fa cli
109e7f: 59 pop %ecx
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
109e80: 8b 43 48 mov 0x48(%ebx),%eax
109e83: ba 04 00 00 00 mov $0x4,%edx
109e88: 3b 43 40 cmp 0x40(%ebx),%eax
109e8b: 73 06 jae 109e93 <_CORE_semaphore_Surrender+0x2f><== NEVER TAKEN
the_semaphore->count += 1;
109e8d: 40 inc %eax
109e8e: 89 43 48 mov %eax,0x48(%ebx)
109e91: 31 d2 xor %edx,%edx
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
109e93: 51 push %ecx
109e94: 9d popf
}
return status;
}
109e95: 89 d0 mov %edx,%eax
109e97: 8b 5d fc mov -0x4(%ebp),%ebx
109e9a: c9 leave
109e9b: c3 ret
0010d61d <_Debug_Is_enabled>:
*/
bool _Debug_Is_enabled(
rtems_debug_control level
)
{
10d61d: 55 push %ebp <== NOT EXECUTED
10d61e: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10d620: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10d623: 85 05 a4 cb 11 00 test %eax,0x11cba4 <== NOT EXECUTED
10d629: 0f 95 c0 setne %al <== NOT EXECUTED
return (_Debug_Level & level) ? true : false;
}
10d62c: c9 leave <== NOT EXECUTED
10d62d: c3 ret <== NOT EXECUTED
00108bcc <_Event_Seize>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
108bcc: 55 push %ebp
108bcd: 89 e5 mov %esp,%ebp
108bcf: 57 push %edi
108bd0: 56 push %esi
108bd1: 53 push %ebx
108bd2: 83 ec 0c sub $0xc,%esp
108bd5: 8b 45 08 mov 0x8(%ebp),%eax
108bd8: 8b 75 0c mov 0xc(%ebp),%esi
108bdb: 8b 55 10 mov 0x10(%ebp),%edx
108bde: 89 55 ec mov %edx,-0x14(%ebp)
108be1: 8b 4d 14 mov 0x14(%ebp),%ecx
108be4: 89 4d e8 mov %ecx,-0x18(%ebp)
rtems_event_set pending_events;
ISR_Level level;
RTEMS_API_Control *api;
Thread_blocking_operation_States sync_state;
executing = _Thread_Executing;
108be7: 8b 1d a0 cb 11 00 mov 0x11cba0,%ebx
executing->Wait.return_code = RTEMS_SUCCESSFUL;
108bed: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx)
api = executing->API_Extensions[ THREAD_API_RTEMS ];
108bf4: 8b 93 f4 00 00 00 mov 0xf4(%ebx),%edx
108bfa: 89 55 f0 mov %edx,-0x10(%ebp)
_ISR_Disable( level );
108bfd: 9c pushf
108bfe: fa cli
108bff: 5f pop %edi
pending_events = api->pending_events;
108c00: 8b 4d f0 mov -0x10(%ebp),%ecx
108c03: 8b 11 mov (%ecx),%edx
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
108c05: 89 c1 mov %eax,%ecx
108c07: 21 d1 and %edx,%ecx
108c09: 74 23 je 108c2e <_Event_Seize+0x62>
108c0b: 39 c1 cmp %eax,%ecx
108c0d: 74 08 je 108c17 <_Event_Seize+0x4b>
108c0f: f7 c6 02 00 00 00 test $0x2,%esi
108c15: 74 17 je 108c2e <_Event_Seize+0x62> <== NEVER TAKEN
(seized_events == event_in || _Options_Is_any( option_set )) ) {
api->pending_events =
108c17: 89 c8 mov %ecx,%eax
108c19: f7 d0 not %eax
108c1b: 21 d0 and %edx,%eax
108c1d: 8b 55 f0 mov -0x10(%ebp),%edx
108c20: 89 02 mov %eax,(%edx)
_Event_sets_Clear( pending_events, seized_events );
_ISR_Enable( level );
108c22: 57 push %edi
108c23: 9d popf
*event_out = seized_events;
108c24: 8b 45 e8 mov -0x18(%ebp),%eax
108c27: 89 08 mov %ecx,(%eax)
108c29: e9 ad 00 00 00 jmp 108cdb <_Event_Seize+0x10f>
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
108c2e: f7 c6 01 00 00 00 test $0x1,%esi
108c34: 74 13 je 108c49 <_Event_Seize+0x7d>
_ISR_Enable( level );
108c36: 57 push %edi
108c37: 9d popf
executing->Wait.return_code = RTEMS_UNSATISFIED;
108c38: c7 43 34 0d 00 00 00 movl $0xd,0x34(%ebx)
*event_out = seized_events;
108c3f: 8b 55 e8 mov -0x18(%ebp),%edx
108c42: 89 0a mov %ecx,(%edx)
108c44: e9 92 00 00 00 jmp 108cdb <_Event_Seize+0x10f>
return;
}
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
108c49: c7 05 88 cd 11 00 01 movl $0x1,0x11cd88
108c50: 00 00 00
executing->Wait.option = (uint32_t) option_set;
108c53: 89 73 30 mov %esi,0x30(%ebx)
executing->Wait.count = (uint32_t) event_in;
108c56: 89 43 24 mov %eax,0x24(%ebx)
executing->Wait.return_argument = event_out;
108c59: 8b 4d e8 mov -0x18(%ebp),%ecx
108c5c: 89 4b 28 mov %ecx,0x28(%ebx)
_ISR_Enable( level );
108c5f: 57 push %edi
108c60: 9d popf
if ( ticks ) {
108c61: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
108c65: 74 34 je 108c9b <_Event_Seize+0xcf>
_Watchdog_Initialize(
108c67: 8b 43 08 mov 0x8(%ebx),%eax
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
108c6a: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
* @param[in] the_heap is the heap to operate upon
108c71: c7 43 64 1c 8e 10 00 movl $0x108e1c,0x64(%ebx)
* @param[in] starting_address is the starting address of the memory for
108c78: 89 43 68 mov %eax,0x68(%ebx)
* the heap
108c7b: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
Heap_Control *the_heap,
108c82: 8b 45 ec mov -0x14(%ebp),%eax
108c85: 89 43 54 mov %eax,0x54(%ebx)
void *starting_address,
size_t *size
108c88: 52 push %edx
108c89: 52 push %edx
108c8a: 8d 43 48 lea 0x48(%ebx),%eax
108c8d: 50 push %eax
108c8e: 68 c0 cb 11 00 push $0x11cbc0
108c93: e8 f0 2e 00 00 call 10bb88 <_Watchdog_Insert>
108c98: 83 c4 10 add $0x10,%esp
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
}
_Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
108c9b: 50 push %eax
108c9c: 50 push %eax
108c9d: 68 00 01 00 00 push $0x100
108ca2: 53 push %ebx
108ca3: e8 34 29 00 00 call 10b5dc <_Thread_Set_state>
_ISR_Disable( level );
108ca8: 9c pushf
108ca9: fa cli
108caa: 5a pop %edx
sync_state = _Event_Sync_state;
108cab: a1 88 cd 11 00 mov 0x11cd88,%eax
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
108cb0: c7 05 88 cd 11 00 00 movl $0x0,0x11cd88
108cb7: 00 00 00
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
108cba: 83 c4 10 add $0x10,%esp
108cbd: 83 f8 01 cmp $0x1,%eax
108cc0: 75 04 jne 108cc6 <_Event_Seize+0xfa>
_ISR_Enable( level );
108cc2: 52 push %edx
108cc3: 9d popf
108cc4: eb 15 jmp 108cdb <_Event_Seize+0x10f>
* An interrupt completed the thread's blocking request.
* The blocking thread was satisfied by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
_Thread_blocking_operation_Cancel( sync_state, executing, level );
108cc6: 89 55 10 mov %edx,0x10(%ebp)
108cc9: 89 5d 0c mov %ebx,0xc(%ebp)
108ccc: 89 45 08 mov %eax,0x8(%ebp)
}
108ccf: 8d 65 f4 lea -0xc(%ebp),%esp
108cd2: 5b pop %ebx
108cd3: 5e pop %esi
108cd4: 5f pop %edi
108cd5: c9 leave
* An interrupt completed the thread's blocking request.
* The blocking thread was satisfied by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
_Thread_blocking_operation_Cancel( sync_state, executing, level );
108cd6: e9 25 1c 00 00 jmp 10a900 <_Thread_blocking_operation_Cancel>
}
108cdb: 8d 65 f4 lea -0xc(%ebp),%esp
108cde: 5b pop %ebx
108cdf: 5e pop %esi
108ce0: 5f pop %edi
108ce1: c9 leave
108ce2: c3 ret
00108d30 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
108d30: 55 push %ebp
108d31: 89 e5 mov %esp,%ebp
108d33: 57 push %edi
108d34: 56 push %esi
108d35: 53 push %ebx
108d36: 83 ec 0c sub $0xc,%esp
108d39: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_event_set event_condition;
rtems_event_set seized_events;
rtems_option option_set;
RTEMS_API_Control *api;
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
108d3c: 8b 83 f4 00 00 00 mov 0xf4(%ebx),%eax
108d42: 89 45 f0 mov %eax,-0x10(%ebp)
option_set = (rtems_option) the_thread->Wait.option;
108d45: 8b 53 30 mov 0x30(%ebx),%edx
108d48: 89 55 ec mov %edx,-0x14(%ebp)
_ISR_Disable( level );
108d4b: 9c pushf
108d4c: fa cli
108d4d: 5f pop %edi
pending_events = api->pending_events;
108d4e: 8b 30 mov (%eax),%esi
event_condition = (rtems_event_set) the_thread->Wait.count;
108d50: 8b 53 24 mov 0x24(%ebx),%edx
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
108d53: 89 d1 mov %edx,%ecx
108d55: 21 f1 and %esi,%ecx
108d57: 75 07 jne 108d60 <_Event_Surrender+0x30>
_ISR_Enable( level );
108d59: 57 push %edi
108d5a: 9d popf
108d5b: e9 b1 00 00 00 jmp 108e11 <_Event_Surrender+0xe1>
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
108d60: a1 7c cb 11 00 mov 0x11cb7c,%eax
108d65: 85 c0 test %eax,%eax
108d67: 74 49 je 108db2 <_Event_Surrender+0x82>
108d69: 3b 1d a0 cb 11 00 cmp 0x11cba0,%ebx
108d6f: 75 41 jne 108db2 <_Event_Surrender+0x82>
108d71: a1 88 cd 11 00 mov 0x11cd88,%eax
108d76: 48 dec %eax
108d77: 74 0a je 108d83 <_Event_Surrender+0x53> <== ALWAYS TAKEN
108d79: a1 88 cd 11 00 mov 0x11cd88,%eax <== NOT EXECUTED
108d7e: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED
108d81: 75 2f jne 108db2 <_Event_Surrender+0x82> <== NOT EXECUTED
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
108d83: 39 d1 cmp %edx,%ecx
108d85: 74 06 je 108d8d <_Event_Surrender+0x5d> <== ALWAYS TAKEN
108d87: f6 45 ec 02 testb $0x2,-0x14(%ebp) <== NOT EXECUTED
108d8b: 74 21 je 108dae <_Event_Surrender+0x7e> <== NOT EXECUTED
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
108d8d: 89 c8 mov %ecx,%eax
108d8f: f7 d0 not %eax
108d91: 21 f0 and %esi,%eax
108d93: 8b 55 f0 mov -0x10(%ebp),%edx
108d96: 89 02 mov %eax,(%edx)
the_thread->Wait.count = 0;
108d98: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
108d9f: 8b 43 28 mov 0x28(%ebx),%eax
108da2: 89 08 mov %ecx,(%eax)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
108da4: c7 05 88 cd 11 00 03 movl $0x3,0x11cd88
108dab: 00 00 00
}
_ISR_Enable( level );
108dae: 57 push %edi
108daf: 9d popf
108db0: eb 5f jmp 108e11 <_Event_Surrender+0xe1>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
108db2: f6 43 11 01 testb $0x1,0x11(%ebx)
108db6: 74 57 je 108e0f <_Event_Surrender+0xdf> <== NEVER TAKEN
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
108db8: 39 d1 cmp %edx,%ecx
108dba: 74 06 je 108dc2 <_Event_Surrender+0x92>
108dbc: f6 45 ec 02 testb $0x2,-0x14(%ebp)
108dc0: 74 4d je 108e0f <_Event_Surrender+0xdf> <== NEVER TAKEN
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
108dc2: 89 c8 mov %ecx,%eax
108dc4: f7 d0 not %eax
108dc6: 21 f0 and %esi,%eax
108dc8: 8b 55 f0 mov -0x10(%ebp),%edx
108dcb: 89 02 mov %eax,(%edx)
the_thread->Wait.count = 0;
108dcd: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
108dd4: 8b 43 28 mov 0x28(%ebx),%eax
108dd7: 89 08 mov %ecx,(%eax)
_ISR_Flash( level );
108dd9: 57 push %edi
108dda: 9d popf
108ddb: fa cli
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
108ddc: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
108de0: 74 06 je 108de8 <_Event_Surrender+0xb8>
_ISR_Enable( level );
108de2: 57 push %edi
108de3: 9d popf
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
108de4: 51 push %ecx
108de5: 51 push %ecx
108de6: eb 17 jmp 108dff <_Event_Surrender+0xcf>
* a block of the requested size, then NULL is returned.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
* @return NULL if unsuccessful and a pointer to the block if successful
*/
108de8: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
108def: 57 push %edi
108df0: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
108df1: 83 ec 0c sub $0xc,%esp
108df4: 8d 43 48 lea 0x48(%ebx),%eax
108df7: 50 push %eax
108df8: e8 a3 2e 00 00 call 10bca0 <_Watchdog_Remove>
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
108dfd: 58 pop %eax
108dfe: 5a pop %edx
108dff: 68 f8 ff 03 10 push $0x1003fff8
108e04: 53 push %ebx
108e05: e8 62 1c 00 00 call 10aa6c <_Thread_Clear_state>
108e0a: 83 c4 10 add $0x10,%esp
108e0d: eb 02 jmp 108e11 <_Event_Surrender+0xe1>
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
108e0f: 57 push %edi <== NOT EXECUTED
108e10: 9d popf <== NOT EXECUTED
}
108e11: 8d 65 f4 lea -0xc(%ebp),%esp
108e14: 5b pop %ebx
108e15: 5e pop %esi
108e16: 5f pop %edi
108e17: c9 leave
108e18: c3 ret
00108e1c <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
108e1c: 55 push %ebp
108e1d: 89 e5 mov %esp,%ebp
108e1f: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
108e22: 8d 45 fc lea -0x4(%ebp),%eax
108e25: 50 push %eax
108e26: ff 75 08 pushl 0x8(%ebp)
108e29: e8 de 1f 00 00 call 10ae0c <_Thread_Get>
108e2e: 89 c2 mov %eax,%edx
switch ( location ) {
108e30: 83 c4 10 add $0x10,%esp
108e33: 83 7d fc 00 cmpl $0x0,-0x4(%ebp)
108e37: 75 5f jne 108e98 <_Event_Timeout+0x7c> <== NEVER TAKEN
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
_ISR_Disable( level );
108e39: 9c pushf
108e3a: fa cli
108e3b: 59 pop %ecx
if ( !the_thread->Wait.count ) { /* verify thread is waiting */
108e3c: 83 78 24 00 cmpl $0x0,0x24(%eax)
108e40: 75 0f jne 108e51 <_Event_Timeout+0x35> <== ALWAYS TAKEN
108e42: a1 e0 ca 11 00 mov 0x11cae0,%eax <== NOT EXECUTED
108e47: 48 dec %eax <== NOT EXECUTED
108e48: a3 e0 ca 11 00 mov %eax,0x11cae0 <== NOT EXECUTED
_Thread_Unnest_dispatch();
_ISR_Enable( level );
108e4d: 51 push %ecx <== NOT EXECUTED
108e4e: 9d popf <== NOT EXECUTED
108e4f: eb 47 jmp 108e98 <_Event_Timeout+0x7c> <== NOT EXECUTED
return;
}
the_thread->Wait.count = 0;
108e51: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
if ( _Thread_Is_executing( the_thread ) ) {
108e58: 3b 05 a0 cb 11 00 cmp 0x11cba0,%eax
108e5e: 75 14 jne 108e74 <_Event_Timeout+0x58>
Thread_blocking_operation_States sync = _Event_Sync_state;
108e60: a1 88 cd 11 00 mov 0x11cd88,%eax
if ( (sync == THREAD_BLOCKING_OPERATION_SYNCHRONIZED) ||
108e65: 83 f8 01 cmp $0x1,%eax
108e68: 77 0a ja 108e74 <_Event_Timeout+0x58> <== NEVER TAKEN
(sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
108e6a: c7 05 88 cd 11 00 02 movl $0x2,0x11cd88
108e71: 00 00 00
}
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
108e74: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx)
_ISR_Enable( level );
108e7b: 51 push %ecx
108e7c: 9d popf
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
108e7d: 50 push %eax
108e7e: 50 push %eax
108e7f: 68 f8 ff 03 10 push $0x1003fff8
108e84: 52 push %edx
108e85: e8 e2 1b 00 00 call 10aa6c <_Thread_Clear_state>
108e8a: a1 e0 ca 11 00 mov 0x11cae0,%eax
108e8f: 48 dec %eax
108e90: a3 e0 ca 11 00 mov %eax,0x11cae0
108e95: 83 c4 10 add $0x10,%esp
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
108e98: c9 leave
108e99: c3 ret
0010d8bc <_Heap_Allocate>:
void *_Heap_Allocate(
Heap_Control *the_heap,
size_t size
)
{
10d8bc: 55 push %ebp
10d8bd: 89 e5 mov %esp,%ebp
10d8bf: 57 push %edi
10d8c0: 56 push %esi
10d8c1: 53 push %ebx
10d8c2: 83 ec 10 sub $0x10,%esp
10d8c5: 8b 75 08 mov 0x8(%ebp),%esi
Heap_Block *the_block;
void *ptr = NULL;
Heap_Statistics *const stats = &the_heap->stats;
Heap_Block *const tail = _Heap_Tail(the_heap);
the_size =
10d8c8: ff 76 14 pushl 0x14(%esi)
10d8cb: ff 76 10 pushl 0x10(%esi)
10d8ce: ff 75 0c pushl 0xc(%ebp)
10d8d1: e8 c5 c7 ff ff call 10a09b <_Heap_Calc_block_size>
_Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size);
if(the_size == 0)
10d8d6: 83 c4 10 add $0x10,%esp
10d8d9: 31 d2 xor %edx,%edx
10d8db: 85 c0 test %eax,%eax
10d8dd: 74 3c je 10d91b <_Heap_Allocate+0x5f> <== NEVER TAKEN
* @param[in] starting_address is the starting address of the memory
* to add to the heap
* @param[in] size is the size in bytes of the memory area to add
* @return a status indicating success or the reason for failure
*/
bool _Protected_heap_Extend(
10d8df: 8b 5e 08 mov 0x8(%esi),%ebx
10d8e2: 31 ff xor %edi,%edi
10d8e4: eb 27 jmp 10d90d <_Heap_Allocate+0x51>
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
/* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the
result of the comparison. */
if(the_block->size >= the_size) {
10d8e6: 39 43 04 cmp %eax,0x4(%ebx)
10d8e9: 72 1e jb 10d909 <_Heap_Allocate+0x4d>
(void)_Heap_Block_allocate(the_heap, the_block, the_size );
10d8eb: 52 push %edx
10d8ec: 50 push %eax
10d8ed: 53 push %ebx
10d8ee: 56 push %esi
10d8ef: e8 e4 c7 ff ff call 10a0d8 <_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
10d8f4: 8d 53 08 lea 0x8(%ebx),%edx
ptr = _Heap_User_area(the_block);
stats->allocs += 1;
10d8f7: ff 46 48 incl 0x48(%esi)
stats->searches += search_count + 1;
10d8fa: 8b 46 4c mov 0x4c(%esi),%eax
10d8fd: 8d 44 07 01 lea 0x1(%edi,%eax,1),%eax
10d901: 89 46 4c mov %eax,0x4c(%esi)
10d904: 83 c4 10 add $0x10,%esp
10d907: eb 0a jmp 10d913 <_Heap_Allocate+0x57>
return NULL;
/* Find large enough free block. */
for(the_block = _Heap_First(the_heap), search_count = 0;
the_block != tail;
the_block = the_block->next, ++search_count)
10d909: 8b 5b 08 mov 0x8(%ebx),%ebx
10d90c: 47 inc %edi
if(the_size == 0)
return NULL;
/* Find large enough free block. */
for(the_block = _Heap_First(the_heap), search_count = 0;
the_block != tail;
10d90d: 39 f3 cmp %esi,%ebx
10d90f: 75 d5 jne 10d8e6 <_Heap_Allocate+0x2a>
10d911: 31 d2 xor %edx,%edx
_HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size));
break;
}
}
if(stats->max_search < search_count)
10d913: 39 7e 44 cmp %edi,0x44(%esi)
10d916: 73 03 jae 10d91b <_Heap_Allocate+0x5f>
stats->max_search = search_count;
10d918: 89 7e 44 mov %edi,0x44(%esi)
return ptr;
}
10d91b: 89 d0 mov %edx,%eax
10d91d: 8d 65 f4 lea -0xc(%ebp),%esp
10d920: 5b pop %ebx
10d921: 5e pop %esi
10d922: 5f pop %edi
10d923: c9 leave
10d924: c3 ret
0010b758 <_Heap_Allocate_aligned>:
void *_Heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
)
{
10b758: 55 push %ebp
10b759: 89 e5 mov %esp,%ebp
10b75b: 57 push %edi
10b75c: 56 push %esi
10b75d: 53 push %ebx
10b75e: 83 ec 30 sub $0x30,%esp
10b761: 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;
10b764: 8b 55 08 mov 0x8(%ebp),%edx
10b767: 8b 52 10 mov 0x10(%edx),%edx
10b76a: 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;
10b76d: 8d 48 fc lea -0x4(%eax),%ecx
10b770: 89 4d e0 mov %ecx,-0x20(%ebp)
uint32_t const the_size =
_Heap_Calc_block_size(size, page_size, the_heap->min_block_size);
10b773: 8b 55 08 mov 0x8(%ebp),%edx
10b776: ff 72 14 pushl 0x14(%edx)
10b779: ff 75 dc pushl -0x24(%ebp)
10b77c: 50 push %eax
10b77d: e8 2d 04 00 00 call 10bbaf <_Heap_Calc_block_size>
10b782: 89 45 e4 mov %eax,-0x1c(%ebp)
if(the_size == 0)
10b785: 83 c4 10 add $0x10,%esp
10b788: 31 c0 xor %eax,%eax
10b78a: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b78e: 0f 84 30 01 00 00 je 10b8c4 <_Heap_Allocate_aligned+0x16c><== NEVER TAKEN
return NULL;
if(alignment == 0)
10b794: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10b798: 75 07 jne 10b7a1 <_Heap_Allocate_aligned+0x49>
10b79a: c7 45 10 04 00 00 00 movl $0x4,0x10(%ebp)
)
{
return ( the_thread == _Thread_Heir );
}
/**
10b7a1: 8b 4d 08 mov 0x8(%ebp),%ecx
10b7a4: 8b 59 08 mov 0x8(%ecx),%ebx
10b7a7: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp)
10b7ae: e9 f8 00 00 00 jmp 10b8ab <_Heap_Allocate_aligned+0x153>
10b7b3: 8b 43 04 mov 0x4(%ebx),%eax
10b7b6: 83 e0 fe and $0xfffffffe,%eax
10b7b9: 89 45 e8 mov %eax,-0x18(%ebp)
uint32_t const block_size = _Heap_Block_size(the_block);
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
if(block_size >= the_size) { /* the_block is large enough. */
10b7bc: 8b 55 e4 mov -0x1c(%ebp),%edx
10b7bf: 39 d0 cmp %edx,%eax
10b7c1: 0f 82 de 00 00 00 jb 10b8a5 <_Heap_Allocate_aligned+0x14d>
_H_uptr_t user_addr;
_H_uptr_t aligned_user_addr;
_H_uptr_t const user_area = _H_p2u(_Heap_User_area(the_block));
10b7c7: 8d 4b 08 lea 0x8(%ebx),%ecx
/* Calculate 'aligned_user_addr' that will become the user pointer we
return. It should be at least 'end_to_user_offs' bytes less than the
the 'block_end' and should be aligned on 'alignment' boundary.
Calculations are from the 'block_end' as we are going to split free
block so that the upper part of the block becomes used block. */
_H_uptr_t const block_end = _H_p2u(the_block) + block_size;
10b7ca: 01 d8 add %ebx,%eax
10b7cc: 89 45 ec mov %eax,-0x14(%ebp)
aligned_user_addr = block_end - end_to_user_offs;
10b7cf: 89 c6 mov %eax,%esi
10b7d1: 2b 75 e0 sub -0x20(%ebp),%esi
RTEMS_INLINE_ROUTINE void _Thread_Dispatch_initialization( void )
{
_Thread_Dispatch_disable_level = 1;
}
10b7d4: 89 f0 mov %esi,%eax
10b7d6: 31 d2 xor %edx,%edx
10b7d8: f7 75 10 divl 0x10(%ebp)
10b7db: 89 f7 mov %esi,%edi
10b7dd: 29 d7 sub %edx,%edi
10b7df: 89 f8 mov %edi,%eax
10b7e1: 31 d2 xor %edx,%edx
10b7e3: f7 75 dc divl -0x24(%ebp)
10b7e6: 89 fe mov %edi,%esi
10b7e8: 29 d6 sub %edx,%esi
only at 'page_size' aligned addresses */
user_addr = aligned_user_addr;
_Heap_Align_down_uptr(&user_addr, page_size);
/* Make sure 'user_addr' calculated didn't run out of 'the_block'. */
if(user_addr >= user_area) {
10b7ea: 39 ce cmp %ecx,%esi
10b7ec: 0f 82 b3 00 00 00 jb 10b8a5 <_Heap_Allocate_aligned+0x14d>
/* The block seems to be acceptable. Check if the remainder of
'the_block' is less than 'min_block_size' so that 'the_block' won't
actually be split at the address we assume. */
if(user_addr - user_area < the_heap->min_block_size) {
10b7f2: 8b 55 08 mov 0x8(%ebp),%edx
10b7f5: 8b 52 14 mov 0x14(%edx),%edx
10b7f8: 89 55 f0 mov %edx,-0x10(%ebp)
10b7fb: 89 f0 mov %esi,%eax
10b7fd: 29 c8 sub %ecx,%eax
10b7ff: 39 d0 cmp %edx,%eax
10b801: 73 2f jae 10b832 <_Heap_Allocate_aligned+0xda>
'aligned_user_addr' to be outside of [0,page_size) range. If we do,
we will need to store this distance somewhere to be able to
resurrect the block address from the user pointer. (Having the
distance within [0,page_size) range allows resurrection by
aligning user pointer down to the nearest 'page_size' boundary.) */
if(aligned_user_addr - user_addr >= page_size) {
10b803: 89 f8 mov %edi,%eax
10b805: 29 c8 sub %ecx,%eax
10b807: 89 ce mov %ecx,%esi
10b809: 3b 45 dc cmp -0x24(%ebp),%eax
10b80c: 72 24 jb 10b832 <_Heap_Allocate_aligned+0xda><== NEVER TAKEN
RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void )
{
return ( _Thread_Dispatch_disable_level == 0 );
}
/**
10b80e: 89 c8 mov %ecx,%eax
10b810: 31 d2 xor %edx,%edx
10b812: f7 75 10 divl 0x10(%ebp)
10b815: 89 d6 mov %edx,%esi
* This function returns TRUE if dispatching is disabled, and FALSE
10b817: 89 ca mov %ecx,%edx
10b819: 85 f6 test %esi,%esi
10b81b: 74 08 je 10b825 <_Heap_Allocate_aligned+0xcd>
10b81d: 8b 45 10 mov 0x10(%ebp),%eax
10b820: 8d 14 01 lea (%ecx,%eax,1),%edx
10b823: 29 f2 sub %esi,%edx
/* The user pointer will be too far from 'user_addr'. See if we
can make 'aligned_user_addr' to be close enough to the
'user_addr'. */
aligned_user_addr = user_addr;
_Heap_Align_up_uptr(&aligned_user_addr, alignment);
if(aligned_user_addr - user_addr >= page_size) {
10b825: 89 d0 mov %edx,%eax
10b827: 29 c8 sub %ecx,%eax
10b829: 3b 45 dc cmp -0x24(%ebp),%eax
10b82c: 73 77 jae 10b8a5 <_Heap_Allocate_aligned+0x14d>
10b82e: 89 ce mov %ecx,%esi
10b830: 89 d7 mov %edx,%edi
aligned_user_addr = 0;
}
}
}
if(aligned_user_addr) {
10b832: 85 ff test %edi,%edi
10b834: 74 6f je 10b8a5 <_Heap_Allocate_aligned+0x14d><== NEVER TAKEN
/* The block is indeed acceptable: calculate the size of the block
to be allocated and perform allocation. */
uint32_t const alloc_size =
block_end - user_addr + HEAP_BLOCK_USER_OFFSET;
10b836: 8b 55 ec mov -0x14(%ebp),%edx
10b839: 83 c2 08 add $0x8,%edx
10b83c: 29 f2 sub %esi,%edx
Heap_Block *the_block,
uint32_t alloc_size)
{
Heap_Statistics *const stats = &the_heap->stats;
uint32_t const block_size = _Heap_Block_size(the_block);
uint32_t const the_rest = block_size - alloc_size;
10b83e: 8b 4d e8 mov -0x18(%ebp),%ecx
10b841: 29 d1 sub %edx,%ecx
_HAssert(_Heap_Is_aligned(block_size, the_heap->page_size));
_HAssert(_Heap_Is_aligned(alloc_size, the_heap->page_size));
_HAssert(alloc_size <= block_size);
_HAssert(_Heap_Is_prev_used(the_block));
if(the_rest >= the_heap->min_block_size) {
10b843: 3b 4d f0 cmp -0x10(%ebp),%ecx
10b846: 72 14 jb 10b85c <_Heap_Allocate_aligned+0x104>
/* Split the block so that lower part is still free, and upper part
becomes used. */
the_block->size = the_rest | HEAP_PREV_USED;
10b848: 89 c8 mov %ecx,%eax
10b84a: 83 c8 01 or $0x1,%eax
10b84d: 89 43 04 mov %eax,0x4(%ebx)
Context_Control *context_p = &context_area;
if ( _System_state_Is_up(_System_state_Get ()) )
context_p = &_Thread_Executing->Registers;
_Context_Switch( context_p, &_Thread_BSP_context );
10b850: 8d 04 0b lea (%ebx,%ecx,1),%eax
/** @brief _Thread_Is_proxy_blocking
*
* status which indicates that a proxy is blocking, and FALSE otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking (
uint32_t code
10b853: 89 c3 mov %eax,%ebx
the_block = _Heap_Block_at(the_block, the_rest);
the_block->prev_size = the_rest;
10b855: 89 08 mov %ecx,(%eax)
the_block->size = alloc_size;
10b857: 89 50 04 mov %edx,0x4(%eax)
10b85a: eb 15 jmp 10b871 <_Heap_Allocate_aligned+0x119>
* This routine resets the current context of the calling thread
* to that of its initial state.
*/
RTEMS_INLINE_ROUTINE void _Thread_Restart_self( void )
{
10b85c: 8b 53 08 mov 0x8(%ebx),%edx
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
10b85f: 8b 43 0c mov 0xc(%ebx),%eax
if ( _Thread_Executing->fp_context != NULL )
10b862: 89 50 08 mov %edx,0x8(%eax)
_Context_Restore_fp( &_Thread_Executing->fp_context );
10b865: 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;
10b868: 8b 55 08 mov 0x8(%ebp),%edx
10b86b: ff 4a 38 decl 0x38(%edx)
10b86e: 8b 55 e8 mov -0x18(%ebp),%edx
}
/* Mark the block as used (in the next block). */
_Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED;
10b871: 83 4c 13 04 01 orl $0x1,0x4(%ebx,%edx,1)
/* Update statistics */
stats->free_size -= alloc_size;
10b876: 8b 4d 08 mov 0x8(%ebp),%ecx
10b879: 8b 41 30 mov 0x30(%ecx),%eax
10b87c: 29 d0 sub %edx,%eax
10b87e: 89 41 30 mov %eax,0x30(%ecx)
if(stats->min_free_size > stats->free_size)
10b881: 39 41 34 cmp %eax,0x34(%ecx)
10b884: 76 03 jbe 10b889 <_Heap_Allocate_aligned+0x131>
stats->min_free_size = stats->free_size;
10b886: 89 41 34 mov %eax,0x34(%ecx)
stats->used_blocks += 1;
10b889: 8b 45 08 mov 0x8(%ebp),%eax
10b88c: ff 40 40 incl 0x40(%eax)
_HAssert(_Heap_Is_aligned_ptr((void*)aligned_user_addr, alignment));
the_block = block_allocate(the_heap, the_block, alloc_size);
stats->searches += search_count + 1;
10b88f: 89 c2 mov %eax,%edx
10b891: 8b 40 4c mov 0x4c(%eax),%eax
10b894: 8b 4d d8 mov -0x28(%ebp),%ecx
10b897: 8d 44 01 01 lea 0x1(%ecx,%eax,1),%eax
10b89b: 89 42 4c mov %eax,0x4c(%edx)
stats->allocs += 1;
10b89e: ff 42 48 incl 0x48(%edx)
check_result(the_heap, the_block, user_addr,
aligned_user_addr, size);
user_ptr = (void*)aligned_user_addr;
10b8a1: 89 f8 mov %edi,%eax
10b8a3: eb 11 jmp 10b8b6 <_Heap_Allocate_aligned+0x15e>
/* Find large enough free block that satisfies the alignment requirements. */
for(the_block = _Heap_First(the_heap), search_count = 0;
the_block != tail;
the_block = the_block->next, ++search_count)
10b8a5: 8b 5b 08 mov 0x8(%ebx),%ebx
10b8a8: ff 45 d8 incl -0x28(%ebp)
alignment = CPU_ALIGNMENT;
/* Find large enough free block that satisfies the alignment requirements. */
for(the_block = _Heap_First(the_heap), search_count = 0;
the_block != tail;
10b8ab: 3b 5d 08 cmp 0x8(%ebp),%ebx
10b8ae: 0f 85 ff fe ff ff jne 10b7b3 <_Heap_Allocate_aligned+0x5b>
10b8b4: 31 c0 xor %eax,%eax
}
}
}
}
if(stats->max_search < search_count)
10b8b6: 8b 55 d8 mov -0x28(%ebp),%edx
10b8b9: 8b 4d 08 mov 0x8(%ebp),%ecx
10b8bc: 39 51 44 cmp %edx,0x44(%ecx)
10b8bf: 73 03 jae 10b8c4 <_Heap_Allocate_aligned+0x16c>
stats->max_search = search_count;
10b8c1: 89 51 44 mov %edx,0x44(%ecx)
return user_ptr;
}
10b8c4: 8d 65 f4 lea -0xc(%ebp),%esp
10b8c7: 5b pop %ebx
10b8c8: 5e pop %esi
10b8c9: 5f pop %edi
10b8ca: c9 leave
10b8cb: c3 ret
0010f884 <_Heap_Extend>:
Heap_Control *the_heap,
void *starting_address,
size_t size,
uint32_t *amount_extended
)
{
10f884: 55 push %ebp
10f885: 89 e5 mov %esp,%ebp
10f887: 57 push %edi
10f888: 56 push %esi
10f889: 53 push %ebx
10f88a: 83 ec 0c sub $0xc,%esp
10f88d: 8b 4d 08 mov 0x8(%ebp),%ecx
10f890: 8b 55 0c mov 0xc(%ebp),%edx
10f893: 8b 75 10 mov 0x10(%ebp),%esi
* 5. non-contiguous higher address (NOT SUPPORTED)
*
* As noted, this code only supports (4).
*/
if ( starting_address >= the_heap->begin && /* case 3 */
10f896: 3b 51 18 cmp 0x18(%ecx),%edx
10f899: 72 0a jb 10f8a5 <_Heap_Extend+0x21>
10f89b: b8 01 00 00 00 mov $0x1,%eax
10f8a0: 3b 51 1c cmp 0x1c(%ecx),%edx
10f8a3: 72 5f jb 10f904 <_Heap_Extend+0x80>
starting_address < the_heap->end
)
return HEAP_EXTEND_ERROR;
if ( starting_address != the_heap->end )
10f8a5: b8 02 00 00 00 mov $0x2,%eax
10f8aa: 3b 51 1c cmp 0x1c(%ecx),%edx
10f8ad: 75 55 jne 10f904 <_Heap_Extend+0x80>
* Currently only case 4 should make it to this point.
* The basic trick is to make the extend area look like a used
* block and free it.
*/
old_final = the_heap->final;
10f8af: 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 );
10f8b2: 8d 04 32 lea (%edx,%esi,1),%eax
the_heap->end = _Addresses_Add_offset( the_heap->end, size );
10f8b5: 89 41 1c mov %eax,0x1c(%ecx)
the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD;
10f8b8: 29 d8 sub %ebx,%eax
10f8ba: 8d 78 f8 lea -0x8(%eax),%edi
* the outer most dispatching critical section, then a dispatching
* operation will be performed and, if necessary, control of the
* processor will be transferred to the heir thread.
*/
#if ( (CPU_INLINE_ENABLE_DISPATCH == FALSE) || \
10f8bd: 89 f8 mov %edi,%eax
10f8bf: 31 d2 xor %edx,%edx
10f8c1: f7 71 10 divl 0x10(%ecx)
10f8c4: 29 d7 sub %edx,%edi
_Heap_Align_down( &the_size, the_heap->page_size );
*amount_extended = size;
10f8c6: 8b 45 14 mov 0x14(%ebp),%eax
10f8c9: 89 30 mov %esi,(%eax)
if( the_size < the_heap->min_block_size )
10f8cb: 31 c0 xor %eax,%eax
10f8cd: 3b 79 14 cmp 0x14(%ecx),%edi
10f8d0: 72 32 jb 10f904 <_Heap_Extend+0x80> <== NEVER TAKEN
return HEAP_EXTEND_SUCCESSFUL;
old_final->size = the_size | (old_final->size & HEAP_PREV_USED);
10f8d2: 8b 43 04 mov 0x4(%ebx),%eax
10f8d5: 83 e0 01 and $0x1,%eax
10f8d8: 09 f8 or %edi,%eax
10f8da: 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
10f8dd: 8d 04 3b lea (%ebx,%edi,1),%eax
new_final = _Heap_Block_at( old_final, the_size );
new_final->size = HEAP_PREV_USED;
10f8e0: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
the_heap->final = new_final;
10f8e7: 89 41 24 mov %eax,0x24(%ecx)
stats->size += size;
10f8ea: 01 71 2c add %esi,0x2c(%ecx)
stats->used_blocks += 1;
10f8ed: ff 41 40 incl 0x40(%ecx)
stats->frees -= 1; /* Don't count subsequent call as actual free() */
10f8f0: ff 49 50 decl 0x50(%ecx)
_Heap_Free( the_heap, _Heap_User_area( old_final ) );
10f8f3: 50 push %eax
10f8f4: 50 push %eax
10f8f5: 8d 43 08 lea 0x8(%ebx),%eax
10f8f8: 50 push %eax
10f8f9: 51 push %ecx
10f8fa: e8 39 c0 ff ff call 10b938 <_Heap_Free>
10f8ff: 31 c0 xor %eax,%eax
10f901: 83 c4 10 add $0x10,%esp
return HEAP_EXTEND_SUCCESSFUL;
}
10f904: 8d 65 f4 lea -0xc(%ebp),%esp
10f907: 5b pop %ebx
10f908: 5e pop %esi
10f909: 5f pop %edi
10f90a: c9 leave
10f90b: c3 ret
0010d928 <_Heap_Free>:
bool _Heap_Free(
Heap_Control *the_heap,
void *starting_address
)
{
10d928: 55 push %ebp
10d929: 89 e5 mov %esp,%ebp
10d92b: 57 push %edi
10d92c: 56 push %esi
10d92d: 53 push %ebx
10d92e: 83 ec 14 sub $0x14,%esp
10d931: 8b 7d 08 mov 0x8(%ebp),%edi
10d934: 8b 4d 0c mov 0xc(%ebp),%ecx
uint32_t the_size;
uint32_t next_size;
Heap_Statistics *const stats = &the_heap->stats;
bool next_is_free;
if ( !_Addresses_Is_in_range(
10d937: 8b 47 24 mov 0x24(%edi),%eax
10d93a: 89 45 e0 mov %eax,-0x20(%ebp)
10d93d: 8b 57 20 mov 0x20(%edi),%edx
10d940: 89 55 e4 mov %edx,-0x1c(%ebp)
10d943: 39 d1 cmp %edx,%ecx
10d945: 0f 93 c2 setae %dl
10d948: 39 c1 cmp %eax,%ecx
10d94a: 0f 96 c0 setbe %al
10d94d: 84 d0 test %dl,%al
10d94f: 0f 84 2f 01 00 00 je 10da84 <_Heap_Free+0x15c>
10d955: 8d 59 f8 lea -0x8(%ecx),%ebx
10d958: 89 c8 mov %ecx,%eax
10d95a: 31 d2 xor %edx,%edx
10d95c: f7 77 10 divl 0x10(%edi)
10d95f: 29 d3 sub %edx,%ebx
return( FALSE );
}
_Heap_Start_of_block( the_heap, starting_address, &the_block );
if ( !_Heap_Is_block_in( the_heap, the_block ) ) {
10d961: 3b 5d e4 cmp -0x1c(%ebp),%ebx
10d964: 0f 93 c2 setae %dl
10d967: 3b 5d e0 cmp -0x20(%ebp),%ebx
10d96a: 0f 96 c0 setbe %al
10d96d: 84 d0 test %dl,%al
10d96f: 0f 84 0f 01 00 00 je 10da84 <_Heap_Free+0x15c> <== NEVER TAKEN
10d975: 8b 4b 04 mov 0x4(%ebx),%ecx
10d978: 89 c8 mov %ecx,%eax
10d97a: 83 e0 fe and $0xfffffffe,%eax
10d97d: 89 45 e8 mov %eax,-0x18(%ebp)
10d980: 8d 34 03 lea (%ebx,%eax,1),%esi
}
the_size = _Heap_Block_size( the_block );
next_block = _Heap_Block_at( the_block, the_size );
if ( !_Heap_Is_block_in( the_heap, next_block ) ) {
10d983: 3b 75 e4 cmp -0x1c(%ebp),%esi
10d986: 0f 93 c2 setae %dl
10d989: 3b 75 e0 cmp -0x20(%ebp),%esi
10d98c: 0f 96 c0 setbe %al
10d98f: 84 d0 test %dl,%al
10d991: 0f 84 ed 00 00 00 je 10da84 <_Heap_Free+0x15c> <== NEVER TAKEN
10d997: 8b 46 04 mov 0x4(%esi),%eax
_HAssert( FALSE );
return( FALSE );
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10d99a: a8 01 test $0x1,%al
10d99c: 0f 84 e2 00 00 00 je 10da84 <_Heap_Free+0x15c> <== NEVER TAKEN
10d9a2: 83 e0 fe and $0xfffffffe,%eax
10d9a5: 89 45 ec mov %eax,-0x14(%ebp)
_HAssert( FALSE );
return( FALSE );
}
next_size = _Heap_Block_size( next_block );
next_is_free = next_block < the_heap->final &&
10d9a8: 31 c0 xor %eax,%eax
10d9aa: 3b 75 e0 cmp -0x20(%ebp),%esi
10d9ad: 73 0c jae 10d9bb <_Heap_Free+0x93>
10d9af: 8b 55 ec mov -0x14(%ebp),%edx
10d9b2: 8b 44 16 04 mov 0x4(%esi,%edx,1),%eax
10d9b6: f7 d0 not %eax
10d9b8: 83 e0 01 and $0x1,%eax
10d9bb: 88 45 f3 mov %al,-0xd(%ebp)
!_Heap_Is_prev_used(_Heap_Block_at(next_block, next_size));
if ( !_Heap_Is_prev_used( the_block ) ) {
10d9be: 80 e1 01 and $0x1,%cl
10d9c1: 75 56 jne 10da19 <_Heap_Free+0xf1>
uint32_t const prev_size = the_block->prev_size;
10d9c3: 8b 0b mov (%ebx),%ecx
10d9c5: 29 cb sub %ecx,%ebx
Heap_Block *const prev_block = _Heap_Block_at( the_block, -prev_size );
if ( !_Heap_Is_block_in( the_heap, prev_block ) ) {
10d9c7: 3b 5d e4 cmp -0x1c(%ebp),%ebx
10d9ca: 0f 93 c2 setae %dl
10d9cd: 3b 5d e0 cmp -0x20(%ebp),%ebx
10d9d0: 0f 96 c0 setbe %al
10d9d3: 84 d0 test %dl,%al
10d9d5: 0f 84 a9 00 00 00 je 10da84 <_Heap_Free+0x15c> <== NEVER TAKEN
return( FALSE );
}
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
10d9db: f6 43 04 01 testb $0x1,0x4(%ebx)
10d9df: 0f 84 9f 00 00 00 je 10da84 <_Heap_Free+0x15c> <== NEVER TAKEN
_HAssert( FALSE );
return( FALSE );
}
if ( next_is_free ) { /* coalesce both */
10d9e5: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
10d9e9: 74 19 je 10da04 <_Heap_Free+0xdc>
uint32_t const size = the_size + prev_size + next_size;
10d9eb: 8b 55 e8 mov -0x18(%ebp),%edx
10d9ee: 03 55 ec add -0x14(%ebp),%edx
10d9f1: 01 ca add %ecx,%edx
* Any other value of @a alignment is taken "as is", i.e., even odd
* alignments are possible.
* Returns pointer to the start of the memory block if success, NULL if
* failure.
*
* @param[in] the_heap is the heap to operate upon
10d9f3: 8b 4e 08 mov 0x8(%esi),%ecx
* @param[in] size is the amount of memory to allocate in bytes
10d9f6: 8b 46 0c mov 0xc(%esi),%eax
* @param[in] alignment the required alignment
10d9f9: 89 48 08 mov %ecx,0x8(%eax)
* @return NULL if unsuccessful and a pointer to the block if successful
10d9fc: 89 41 0c mov %eax,0xc(%ecx)
_Heap_Block_remove( next_block );
stats->free_blocks -= 1;
10d9ff: ff 4f 38 decl 0x38(%edi)
10da02: eb 33 jmp 10da37 <_Heap_Free+0x10f>
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
}
else { /* coalesce prev */
uint32_t const size = the_size + prev_size;
10da04: 8b 55 e8 mov -0x18(%ebp),%edx
10da07: 01 ca add %ecx,%edx
prev_block->size = size | HEAP_PREV_USED;
10da09: 89 d0 mov %edx,%eax
10da0b: 83 c8 01 or $0x1,%eax
10da0e: 89 43 04 mov %eax,0x4(%ebx)
next_block->size &= ~HEAP_PREV_USED;
10da11: 83 66 04 fe andl $0xfffffffe,0x4(%esi)
next_block->prev_size = size;
10da15: 89 16 mov %edx,(%esi)
10da17: eb 5b jmp 10da74 <_Heap_Free+0x14c>
}
}
else if ( next_is_free ) { /* coalesce next */
10da19: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
10da1d: 74 25 je 10da44 <_Heap_Free+0x11c>
uint32_t const size = the_size + next_size;
10da1f: 8b 55 ec mov -0x14(%ebp),%edx
10da22: 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
*/
10da25: 8b 4e 08 mov 0x8(%esi),%ecx
bool _Protected_heap_Get_block_size(
10da28: 8b 46 0c mov 0xc(%esi),%eax
Heap_Control *the_heap,
void *starting_address,
size_t *size
10da2b: 89 4b 08 mov %ecx,0x8(%ebx)
);
10da2e: 89 43 0c mov %eax,0xc(%ebx)
10da31: 89 58 08 mov %ebx,0x8(%eax)
10da34: 89 59 0c mov %ebx,0xc(%ecx)
_Heap_Block_replace( next_block, the_block );
the_block->size = size | HEAP_PREV_USED;
10da37: 89 d0 mov %edx,%eax
10da39: 83 c8 01 or $0x1,%eax
10da3c: 89 43 04 mov %eax,0x4(%ebx)
next_block = _Heap_Block_at( the_block, size );
next_block->prev_size = size;
10da3f: 89 14 13 mov %edx,(%ebx,%edx,1)
10da42: eb 30 jmp 10da74 <_Heap_Free+0x14c>
bool _Protected_heap_Resize_block(
Heap_Control *the_heap,
void *starting_address,
size_t size
);
10da44: 8b 47 08 mov 0x8(%edi),%eax
/**
10da47: 89 43 08 mov %eax,0x8(%ebx)
* This routine returns the block of memory which begins
10da4a: 89 7b 0c mov %edi,0xc(%ebx)
* at @a starting_address to @a the_heap. Any coalescing which is
10da4d: 89 5f 08 mov %ebx,0x8(%edi)
10da50: 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;
10da53: 8b 45 e8 mov -0x18(%ebp),%eax
10da56: 83 c8 01 or $0x1,%eax
10da59: 89 43 04 mov %eax,0x4(%ebx)
next_block->size &= ~HEAP_PREV_USED;
10da5c: 83 66 04 fe andl $0xfffffffe,0x4(%esi)
next_block->prev_size = the_size;
10da60: 8b 45 e8 mov -0x18(%ebp),%eax
10da63: 89 06 mov %eax,(%esi)
stats->free_blocks += 1;
10da65: 8b 47 38 mov 0x38(%edi),%eax
10da68: 40 inc %eax
10da69: 89 47 38 mov %eax,0x38(%edi)
if ( stats->max_free_blocks < stats->free_blocks )
10da6c: 39 47 3c cmp %eax,0x3c(%edi)
10da6f: 73 03 jae 10da74 <_Heap_Free+0x14c>
stats->max_free_blocks = stats->free_blocks;
10da71: 89 47 3c mov %eax,0x3c(%edi)
}
stats->used_blocks -= 1;
10da74: ff 4f 40 decl 0x40(%edi)
stats->free_size += the_size;
10da77: 8b 55 e8 mov -0x18(%ebp),%edx
10da7a: 01 57 30 add %edx,0x30(%edi)
stats->frees += 1;
10da7d: ff 47 50 incl 0x50(%edi)
10da80: b0 01 mov $0x1,%al
10da82: eb 02 jmp 10da86 <_Heap_Free+0x15e>
return( TRUE );
10da84: 31 c0 xor %eax,%eax
}
10da86: 83 c4 14 add $0x14,%esp
10da89: 5b pop %ebx
10da8a: 5e pop %esi
10da8b: 5f pop %edi
10da8c: c9 leave
10da8d: c3 ret
0010f90c <_Heap_Get_free_information>:
void _Heap_Get_free_information(
Heap_Control *the_heap,
Heap_Information *info
)
{
10f90c: 55 push %ebp
10f90d: 89 e5 mov %esp,%ebp
10f90f: 53 push %ebx
10f910: 8b 5d 08 mov 0x8(%ebp),%ebx
10f913: 8b 55 0c mov 0xc(%ebp),%edx
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Tail(the_heap);
info->number = 0;
10f916: c7 02 00 00 00 00 movl $0x0,(%edx)
info->largest = 0;
10f91c: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
info->total = 0;
10f923: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
)
{
return ( the_thread == _Thread_Heir );
}
/**
10f92a: 8b 4b 08 mov 0x8(%ebx),%ecx
10f92d: eb 16 jmp 10f945 <_Heap_Get_free_information+0x39>
10f92f: 8b 41 04 mov 0x4(%ecx),%eax
10f932: 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++;
10f935: ff 02 incl (%edx)
info->total += the_size;
10f937: 01 42 08 add %eax,0x8(%edx)
if ( info->largest < the_size )
10f93a: 39 42 04 cmp %eax,0x4(%edx)
10f93d: 73 03 jae 10f942 <_Heap_Get_free_information+0x36><== NEVER TAKEN
info->largest = the_size;
10f93f: 89 42 04 mov %eax,0x4(%edx)
info->largest = 0;
info->total = 0;
for(the_block = _Heap_First(the_heap);
the_block != tail;
the_block = the_block->next)
10f942: 8b 49 08 mov 0x8(%ecx),%ecx
info->number = 0;
info->largest = 0;
info->total = 0;
for(the_block = _Heap_First(the_heap);
the_block != tail;
10f945: 39 d9 cmp %ebx,%ecx
10f947: 75 e6 jne 10f92f <_Heap_Get_free_information+0x23>
info->number++;
info->total += the_size;
if ( info->largest < the_size )
info->largest = the_size;
}
}
10f949: 5b pop %ebx
10f94a: c9 leave
10f94b: c3 ret
0010f94c <_Heap_Get_information>:
Heap_Get_information_status _Heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
10f94c: 55 push %ebp
10f94d: 89 e5 mov %esp,%ebp
10f94f: 53 push %ebx
10f950: 8b 45 08 mov 0x8(%ebp),%eax
10f953: 8b 55 0c mov 0xc(%ebp),%edx
Heap_Block *the_block = the_heap->start;
10f956: 8b 48 20 mov 0x20(%eax),%ecx
Heap_Block *const end = the_heap->final;
10f959: 8b 58 24 mov 0x24(%eax),%ebx
_HAssert(the_block->prev_size == HEAP_PREV_USED);
_HAssert(_Heap_Is_prev_used(the_block));
the_info->Free.number = 0;
10f95c: c7 02 00 00 00 00 movl $0x0,(%edx)
the_info->Free.total = 0;
10f962: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
the_info->Free.largest = 0;
10f969: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
the_info->Used.number = 0;
10f970: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
the_info->Used.total = 0;
10f977: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx)
the_info->Used.largest = 0;
10f97e: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx)
10f985: eb 36 jmp 10f9bd <_Heap_Get_information+0x71>
10f987: 8b 41 04 mov 0x4(%ecx),%eax
10f98a: 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
10f98d: 01 c1 add %eax,%ecx
while ( the_block != end ) {
uint32_t const the_size = _Heap_Block_size(the_block);
Heap_Block *const next_block = _Heap_Block_at(the_block, the_size);
if ( _Heap_Is_prev_used(next_block) ) {
10f98f: f6 41 04 01 testb $0x1,0x4(%ecx)
10f993: 74 10 je 10f9a5 <_Heap_Get_information+0x59>
the_info->Used.number++;
10f995: ff 42 0c incl 0xc(%edx)
the_info->Used.total += the_size;
10f998: 01 42 14 add %eax,0x14(%edx)
if ( the_info->Used.largest < the_size )
10f99b: 39 42 10 cmp %eax,0x10(%edx)
10f99e: 73 1d jae 10f9bd <_Heap_Get_information+0x71>
the_info->Used.largest = the_size;
10f9a0: 89 42 10 mov %eax,0x10(%edx)
10f9a3: eb 18 jmp 10f9bd <_Heap_Get_information+0x71>
} else {
the_info->Free.number++;
10f9a5: ff 02 incl (%edx)
the_info->Free.total += the_size;
10f9a7: 01 42 08 add %eax,0x8(%edx)
if ( the_info->Free.largest < the_size )
10f9aa: 39 42 04 cmp %eax,0x4(%edx)
10f9ad: 73 03 jae 10f9b2 <_Heap_Get_information+0x66><== NEVER TAKEN
the_info->Free.largest = the_size;
10f9af: 89 42 04 mov %eax,0x4(%edx)
if ( the_size != next_block->prev_size )
10f9b2: 3b 01 cmp (%ecx),%eax
10f9b4: 74 07 je 10f9bd <_Heap_Get_information+0x71><== ALWAYS TAKEN
10f9b6: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
10f9bb: eb 0a jmp 10f9c7 <_Heap_Get_information+0x7b><== NOT EXECUTED
the_info->Free.largest = 0;
the_info->Used.number = 0;
the_info->Used.total = 0;
the_info->Used.largest = 0;
while ( the_block != end ) {
10f9bd: 39 d9 cmp %ebx,%ecx
10f9bf: 75 c6 jne 10f987 <_Heap_Get_information+0x3b>
}
/* Handle the last dummy block. Don't consider this block to be
"used" as client never allocated it. Make 'Used.total' contain this
blocks' overhead though. */
the_info->Used.total += HEAP_OVERHEAD;
10f9c1: 83 42 14 08 addl $0x8,0x14(%edx)
10f9c5: 31 c0 xor %eax,%eax
return HEAP_GET_INFORMATION_SUCCESSFUL;
}
10f9c7: 5b pop %ebx
10f9c8: c9 leave
10f9c9: c3 ret
00109f8c <_Heap_Initialize>:
Heap_Control *the_heap,
void *starting_address,
size_t size,
uint32_t page_size
)
{
109f8c: 55 push %ebp
109f8d: 89 e5 mov %esp,%ebp
109f8f: 57 push %edi
109f90: 56 push %esi
109f91: 53 push %ebx
109f92: 83 ec 0c sub $0xc,%esp
109f95: 8b 75 08 mov 0x8(%ebp),%esi
109f98: 8b 7d 0c mov 0xc(%ebp),%edi
109f9b: 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)
109f9e: 85 c9 test %ecx,%ecx
109fa0: 75 04 jne 109fa6 <_Heap_Initialize+0x1a>
109fa2: b1 04 mov $0x4,%cl
109fa4: eb 0c jmp 109fb2 <_Heap_Initialize+0x26>
*
* @param[in] the_heap pointer to heap header
* @param[in] the_info pointer to a status information area
*
* @return true if successfully able to return information
*/
109fa6: 89 c8 mov %ecx,%eax
109fa8: 83 e0 03 and $0x3,%eax
109fab: 74 05 je 109fb2 <_Heap_Initialize+0x26>
109fad: 83 c1 04 add $0x4,%ecx
109fb0: 29 c1 sub %eax,%ecx
/* Calculate aligned_start so that aligned_start + HEAP_BLOCK_USER_OFFSET
(value of user pointer) is aligned on 'page_size' boundary. Make sure
resulting 'aligned_start' is not below 'starting_address'. */
start = _H_p2u(starting_address);
aligned_start = start + HEAP_BLOCK_USER_OFFSET;
109fb2: 8d 5f 08 lea 0x8(%edi),%ebx
109fb5: 89 d8 mov %ebx,%eax
109fb7: 31 d2 xor %edx,%edx
109fb9: f7 f1 div %ecx
109fbb: 85 d2 test %edx,%edx
109fbd: 74 05 je 109fc4 <_Heap_Initialize+0x38>
109fbf: 8d 1c 19 lea (%ecx,%ebx,1),%ebx
109fc2: 29 d3 sub %edx,%ebx
_Heap_Align_up_uptr ( &aligned_start, page_size );
aligned_start -= HEAP_BLOCK_USER_OFFSET;
109fc4: 83 eb 08 sub $0x8,%ebx
* sizes.
*
* @param[in] the_heap pointer to heap header
* @param[in] the_info pointer to a status information area
*
* @return true if successfully able to return information
109fc7: b8 10 00 00 00 mov $0x10,%eax
109fcc: 31 d2 xor %edx,%edx
109fce: f7 f1 div %ecx
*/
109fd0: b8 10 00 00 00 mov $0x10,%eax
109fd5: 85 d2 test %edx,%edx
109fd7: 74 05 je 109fde <_Heap_Initialize+0x52>
109fd9: 8d 41 10 lea 0x10(%ecx),%eax
109fdc: 29 d0 sub %edx,%eax
109fde: 89 46 14 mov %eax,0x14(%esi)
/* Calculate 'the_size' -- size of the first block so that there is enough
space at the end for the permanent last block. It is equal to 'size'
minus total overhead aligned down to the nearest multiple of
'page_size'. */
overhead = HEAP_OVERHEAD + (aligned_start - start);
109fe1: 89 d8 mov %ebx,%eax
109fe3: 29 f8 sub %edi,%eax
109fe5: 83 c0 08 add $0x8,%eax
if ( size < overhead )
109fe8: 39 45 10 cmp %eax,0x10(%ebp)
109feb: 0f 82 a0 00 00 00 jb 10a091 <_Heap_Initialize+0x105><== NEVER TAKEN
return 0; /* Too small area for the heap */
the_size = size - overhead;
109ff1: 8b 55 10 mov 0x10(%ebp),%edx
109ff4: 29 c2 sub %eax,%edx
109ff6: 89 55 e8 mov %edx,-0x18(%ebp)
*
* @return free block information filled in.
*/
bool _Protected_heap_Get_free_information(
Heap_Control *the_heap,
Heap_Information *info
109ff9: 89 d0 mov %edx,%eax
109ffb: 31 d2 xor %edx,%edx
109ffd: f7 f1 div %ecx
_Heap_Align_down ( &the_size, page_size );
if ( the_size == 0 )
109fff: 8b 45 e8 mov -0x18(%ebp),%eax
10a002: 29 d0 sub %edx,%eax
10a004: 89 c2 mov %eax,%edx
10a006: 0f 84 85 00 00 00 je 10a091 <_Heap_Initialize+0x105>
return 0; /* Too small area for the heap */
the_heap->page_size = page_size;
10a00c: 89 4e 10 mov %ecx,0x10(%esi)
the_heap->begin = starting_address;
10a00f: 89 7e 18 mov %edi,0x18(%esi)
the_heap->end = starting_address + size;
10a012: 03 7d 10 add 0x10(%ebp),%edi
10a015: 89 7e 1c mov %edi,0x1c(%esi)
the_block = (Heap_Block *) aligned_start;
the_block->prev_size = page_size;
10a018: 89 0b mov %ecx,(%ebx)
the_block->size = the_size | HEAP_PREV_USED;
10a01a: 83 c8 01 or $0x1,%eax
10a01d: 89 43 04 mov %eax,0x4(%ebx)
the_block->next = _Heap_Tail( the_heap );
10a020: 89 73 08 mov %esi,0x8(%ebx)
the_block->prev = _Heap_Head( the_heap );
10a023: 89 73 0c mov %esi,0xc(%ebx)
_Heap_Head(the_heap)->next = the_block;
10a026: 89 5e 08 mov %ebx,0x8(%esi)
_Heap_Tail(the_heap)->prev = the_block;
10a029: 89 5e 0c mov %ebx,0xc(%esi)
the_heap->start = the_block;
10a02c: 89 5e 20 mov %ebx,0x20(%esi)
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory for
* the heap
10a02f: 8d 04 13 lea (%ebx,%edx,1),%eax
_HAssert(_Heap_Is_aligned(the_heap->page_size, CPU_ALIGNMENT));
_HAssert(_Heap_Is_aligned(the_heap->min_block_size, page_size));
_HAssert(_Heap_Is_aligned_ptr(_Heap_User_area(the_block), page_size));
the_block = _Heap_Block_at( the_block, the_size );
the_heap->final = the_block; /* Permanent final block of the heap */
10a032: 89 46 24 mov %eax,0x24(%esi)
the_block->prev_size = the_size; /* Previous block is free */
10a035: 89 10 mov %edx,(%eax)
the_block->size = page_size;
10a037: 89 48 04 mov %ecx,0x4(%eax)
stats->size = size;
10a03a: 8b 45 10 mov 0x10(%ebp),%eax
10a03d: 89 46 2c mov %eax,0x2c(%esi)
stats->free_size = the_size;
10a040: 89 56 30 mov %edx,0x30(%esi)
stats->min_free_size = the_size;
10a043: 89 56 34 mov %edx,0x34(%esi)
stats->free_blocks = 1;
10a046: c7 46 38 01 00 00 00 movl $0x1,0x38(%esi)
stats->max_free_blocks = 1;
10a04d: c7 46 3c 01 00 00 00 movl $0x1,0x3c(%esi)
stats->used_blocks = 0;
10a054: c7 46 40 00 00 00 00 movl $0x0,0x40(%esi)
stats->max_search = 0;
10a05b: c7 46 44 00 00 00 00 movl $0x0,0x44(%esi)
stats->allocs = 0;
10a062: c7 46 48 00 00 00 00 movl $0x0,0x48(%esi)
stats->searches = 0;
10a069: c7 46 4c 00 00 00 00 movl $0x0,0x4c(%esi)
stats->frees = 0;
10a070: c7 46 50 00 00 00 00 movl $0x0,0x50(%esi)
stats->resizes = 0;
10a077: c7 46 54 00 00 00 00 movl $0x0,0x54(%esi)
stats->instance = instance++;
10a07e: a1 94 c8 11 00 mov 0x11c894,%eax
10a083: 89 46 28 mov %eax,0x28(%esi)
10a086: 40 inc %eax
10a087: a3 94 c8 11 00 mov %eax,0x11c894
return ( the_size - HEAP_BLOCK_USED_OVERHEAD );
10a08c: 8d 42 fc lea -0x4(%edx),%eax
10a08f: eb 02 jmp 10a093 <_Heap_Initialize+0x107>
10a091: 31 c0 xor %eax,%eax
}
10a093: 83 c4 0c add $0xc,%esp
10a096: 5b pop %ebx
10a097: 5e pop %esi
10a098: 5f pop %edi
10a099: c9 leave
10a09a: c3 ret
00115004 <_Heap_Resize_block>:
void *starting_address,
size_t size,
uint32_t *old_mem_size,
uint32_t *avail_mem_size
)
{
115004: 55 push %ebp
115005: 89 e5 mov %esp,%ebp
115007: 57 push %edi
115008: 56 push %esi
115009: 53 push %ebx
11500a: 83 ec 2c sub $0x2c,%esp
Heap_Block *next_next_block;
uint32_t old_block_size;
uint32_t old_user_size;
uint32_t prev_used_flag;
Heap_Statistics *const stats = &the_heap->stats;
uint32_t const min_block_size = the_heap->min_block_size;
11500d: 8b 45 08 mov 0x8(%ebp),%eax
115010: 8b 40 14 mov 0x14(%eax),%eax
115013: 89 45 ec mov %eax,-0x14(%ebp)
uint32_t const page_size = the_heap->page_size;
115016: 8b 55 08 mov 0x8(%ebp),%edx
115019: 8b 72 10 mov 0x10(%edx),%esi
*old_mem_size = 0;
11501c: 8b 4d 14 mov 0x14(%ebp),%ecx
11501f: c7 01 00 00 00 00 movl $0x0,(%ecx)
*avail_mem_size = 0;
115025: 8b 45 18 mov 0x18(%ebp),%eax
115028: c7 00 00 00 00 00 movl $0x0,(%eax)
11502e: 8b 55 0c mov 0xc(%ebp),%edx
115031: 83 ea 08 sub $0x8,%edx
115034: 89 55 f0 mov %edx,-0x10(%ebp)
115037: 8b 45 0c mov 0xc(%ebp),%eax
11503a: 8b 4d 08 mov 0x8(%ebp),%ecx
11503d: 31 d2 xor %edx,%edx
11503f: f7 71 10 divl 0x10(%ecx)
115042: 29 55 f0 sub %edx,-0x10(%ebp)
115045: 89 c8 mov %ecx,%eax
115047: 8b 49 24 mov 0x24(%ecx),%ecx
11504a: 8b 58 20 mov 0x20(%eax),%ebx
_Heap_Start_of_block(the_heap, starting_address, &the_block);
_HAssert(_Heap_Is_block_in(the_heap, the_block));
if (!_Heap_Is_block_in(the_heap, the_block))
11504d: 39 5d f0 cmp %ebx,-0x10(%ebp)
115050: 0f 93 c2 setae %dl
115053: 39 4d f0 cmp %ecx,-0x10(%ebp)
115056: 0f 96 c0 setbe %al
115059: 84 d0 test %dl,%al
11505b: 0f 84 7e 01 00 00 je 1151df <_Heap_Resize_block+0x1db>
return HEAP_RESIZE_FATAL_ERROR;
prev_used_flag = the_block->size & HEAP_PREV_USED;
115061: 8b 55 f0 mov -0x10(%ebp),%edx
115064: 8b 52 04 mov 0x4(%edx),%edx
115067: 89 55 d8 mov %edx,-0x28(%ebp)
11506a: 83 e2 fe and $0xfffffffe,%edx
11506d: 89 55 e4 mov %edx,-0x1c(%ebp)
115070: 8b 7d f0 mov -0x10(%ebp),%edi
115073: 01 d7 add %edx,%edi
old_block_size = _Heap_Block_size(the_block);
next_block = _Heap_Block_at(the_block, old_block_size);
_HAssert(_Heap_Is_block_in(the_heap, next_block));
_HAssert(_Heap_Is_prev_used(next_block));
if ( !_Heap_Is_block_in(the_heap, next_block) ||
115075: 39 df cmp %ebx,%edi
115077: 0f 93 c2 setae %dl
11507a: 39 cf cmp %ecx,%edi
11507c: 0f 96 c0 setbe %al
11507f: 84 d0 test %dl,%al
115081: 0f 84 58 01 00 00 je 1151df <_Heap_Resize_block+0x1db><== NEVER TAKEN
115087: 8b 47 04 mov 0x4(%edi),%eax
11508a: a8 01 test $0x1,%al
11508c: 0f 84 4d 01 00 00 je 1151df <_Heap_Resize_block+0x1db><== NEVER TAKEN
115092: 83 e0 fe and $0xfffffffe,%eax
115095: 89 45 dc mov %eax,-0x24(%ebp)
115098: 01 f8 add %edi,%eax
11509a: 89 45 e0 mov %eax,-0x20(%ebp)
!_Heap_Is_prev_used(next_block))
return HEAP_RESIZE_FATAL_ERROR;
next_block_size = _Heap_Block_size(next_block);
next_next_block = _Heap_Block_at(next_block, next_block_size);
next_is_used = (next_block == the_heap->final) ||
11509d: b8 01 00 00 00 mov $0x1,%eax
1150a2: 39 cf cmp %ecx,%edi
1150a4: 74 09 je 1150af <_Heap_Resize_block+0xab><== NEVER TAKEN
1150a6: 8b 4d e0 mov -0x20(%ebp),%ecx
1150a9: 8b 41 04 mov 0x4(%ecx),%eax
1150ac: 83 e0 01 and $0x1,%eax
_Heap_Start_of_block(the_heap, starting_address, &the_block);
_HAssert(_Heap_Is_block_in(the_heap, the_block));
if (!_Heap_Is_block_in(the_heap, the_block))
return HEAP_RESIZE_FATAL_ERROR;
prev_used_flag = the_block->size & HEAP_PREV_USED;
1150af: 8b 55 d8 mov -0x28(%ebp),%edx
1150b2: 83 e2 01 and $0x1,%edx
1150b5: 89 55 e8 mov %edx,-0x18(%ebp)
!_Heap_Is_prev_used(next_block))
return HEAP_RESIZE_FATAL_ERROR;
next_block_size = _Heap_Block_size(next_block);
next_next_block = _Heap_Block_at(next_block, next_block_size);
next_is_used = (next_block == the_heap->final) ||
1150b8: 88 c1 mov %al,%cl
_Heap_Is_prev_used(next_next_block);
/* See _Heap_Size_of_user_area() source for explanations */
old_user_size = _Addresses_Subtract(next_block, starting_address)
1150ba: 89 f8 mov %edi,%eax
1150bc: 2b 45 0c sub 0xc(%ebp),%eax
1150bf: 83 c0 04 add $0x4,%eax
+ HEAP_BLOCK_HEADER_OFFSET;
*old_mem_size = old_user_size;
1150c2: 8b 55 14 mov 0x14(%ebp),%edx
1150c5: 89 02 mov %eax,(%edx)
if (size > old_user_size) {
1150c7: 39 45 10 cmp %eax,0x10(%ebp)
1150ca: 76 50 jbe 11511c <_Heap_Resize_block+0x118>
/* Need to extend the block: allocate part of the next block and then
merge 'the_block' and allocated block together. */
if (next_is_used) /* Next block is in use, -- no way to extend */
1150cc: 84 c9 test %cl,%cl
1150ce: 0f 85 12 01 00 00 jne 1151e6 <_Heap_Resize_block+0x1e2>
return HEAP_RESIZE_UNSATISFIED;
else {
uint32_t add_block_size = size - old_user_size;
1150d4: 8b 4d 10 mov 0x10(%ebp),%ecx
1150d7: 29 c1 sub %eax,%ecx
1150d9: 89 c8 mov %ecx,%eax
1150db: 31 d2 xor %edx,%edx
1150dd: f7 f6 div %esi
1150df: 85 d2 test %edx,%edx
1150e1: 74 04 je 1150e7 <_Heap_Resize_block+0xe3><== NEVER TAKEN
1150e3: 01 f1 add %esi,%ecx
1150e5: 29 d1 sub %edx,%ecx
1150e7: 89 c8 mov %ecx,%eax
1150e9: 3b 4d ec cmp -0x14(%ebp),%ecx
1150ec: 73 03 jae 1150f1 <_Heap_Resize_block+0xed><== NEVER TAKEN
1150ee: 8b 45 ec mov -0x14(%ebp),%eax
_Heap_Align_up(&add_block_size, page_size);
if (add_block_size < min_block_size)
add_block_size = min_block_size;
if (add_block_size > next_block_size)
1150f1: 3b 45 dc cmp -0x24(%ebp),%eax
1150f4: 0f 87 ec 00 00 00 ja 1151e6 <_Heap_Resize_block+0x1e2><== NEVER TAKEN
return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */
add_block_size =
1150fa: 53 push %ebx
1150fb: 50 push %eax
1150fc: 57 push %edi
1150fd: ff 75 08 pushl 0x8(%ebp)
115100: e8 d3 4f ff ff call 10a0d8 <_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;
115105: 03 45 e4 add -0x1c(%ebp),%eax
115108: 0b 45 e8 or -0x18(%ebp),%eax
11510b: 8b 55 f0 mov -0x10(%ebp),%edx
11510e: 89 42 04 mov %eax,0x4(%edx)
--stats->used_blocks;
115111: 8b 4d 08 mov 0x8(%ebp),%ecx
115114: ff 49 40 decl 0x40(%ecx)
115117: e9 b6 00 00 00 jmp 1151d2 <_Heap_Resize_block+0x1ce>
}
} else {
/* Calculate how much memory we could free */
uint32_t free_block_size = old_user_size - size;
11511c: 89 c3 mov %eax,%ebx
11511e: 2b 5d 10 sub 0x10(%ebp),%ebx
115121: 89 d8 mov %ebx,%eax
115123: 31 d2 xor %edx,%edx
115125: f7 f6 div %esi
_Heap_Align_down(&free_block_size, page_size);
if (free_block_size > 0) {
115127: 89 de mov %ebx,%esi
115129: 29 d6 sub %edx,%esi
11512b: 0f 84 a4 00 00 00 je 1151d5 <_Heap_Resize_block+0x1d1>
/* To free some memory the block should be shortened so that it can
can hold 'size' user bytes and still remain not shorter than
'min_block_size'. */
uint32_t new_block_size = old_block_size - free_block_size;
115131: 8b 5d e4 mov -0x1c(%ebp),%ebx
115134: 29 f3 sub %esi,%ebx
if (new_block_size < min_block_size) {
115136: 3b 5d ec cmp -0x14(%ebp),%ebx
115139: 73 16 jae 115151 <_Heap_Resize_block+0x14d>
uint32_t delta = min_block_size - new_block_size;
11513b: 8b 45 ec mov -0x14(%ebp),%eax
11513e: 29 d8 sub %ebx,%eax
_HAssert(free_block_size >= delta);
free_block_size -= delta;
if (free_block_size == 0) {
115140: 29 c6 sub %eax,%esi
115142: 75 0b jne 11514f <_Heap_Resize_block+0x14b><== NEVER TAKEN
++stats->resizes;
115144: 8b 55 08 mov 0x8(%ebp),%edx
115147: ff 42 54 incl 0x54(%edx)
11514a: e9 8c 00 00 00 jmp 1151db <_Heap_Resize_block+0x1d7>
return HEAP_RESIZE_SUCCESSFUL;
}
new_block_size += delta;
11514f: 01 c3 add %eax,%ebx <== NOT EXECUTED
_HAssert(new_block_size >= min_block_size);
_HAssert(new_block_size + free_block_size == old_block_size);
_HAssert(_Heap_Is_aligned(new_block_size, page_size));
_HAssert(_Heap_Is_aligned(free_block_size, page_size));
if (!next_is_used) {
115151: 84 c9 test %cl,%cl
115153: 75 43 jne 115198 <_Heap_Resize_block+0x194><== NEVER TAKEN
115155: 8b 55 f0 mov -0x10(%ebp),%edx
115158: 01 da add %ebx,%edx
/* Extend the next block to the low addresses by 'free_block_size' */
Heap_Block *const new_next_block =
_Heap_Block_at(the_block, new_block_size);
uint32_t const new_next_block_size =
next_block_size + free_block_size;
11515a: 8b 45 dc mov -0x24(%ebp),%eax
11515d: 8d 0c 06 lea (%esi,%eax,1),%ecx
_HAssert(_Heap_Is_block_in(the_heap, next_next_block));
the_block->size = new_block_size | prev_used_flag;
115160: 0b 5d e8 or -0x18(%ebp),%ebx
115163: 8b 45 f0 mov -0x10(%ebp),%eax
115166: 89 58 04 mov %ebx,0x4(%eax)
new_next_block->size = new_next_block_size | HEAP_PREV_USED;
115169: 89 c8 mov %ecx,%eax
11516b: 83 c8 01 or $0x1,%eax
11516e: 89 42 04 mov %eax,0x4(%edx)
next_next_block->prev_size = new_next_block_size;
115171: 8b 45 e0 mov -0x20(%ebp),%eax
115174: 89 08 mov %ecx,(%eax)
{
return (state == SYSTEM_STATE_FAILED);
}
/**@}*/
115176: 8b 5f 08 mov 0x8(%edi),%ebx
#endif
115179: 8b 47 0c mov 0xc(%edi),%eax
/* end of include file */
11517c: 89 5a 08 mov %ebx,0x8(%edx)
11517f: 89 42 0c mov %eax,0xc(%edx)
115182: 89 50 08 mov %edx,0x8(%eax)
115185: 89 53 0c mov %edx,0xc(%ebx)
_Heap_Block_replace(next_block, new_next_block);
the_heap->stats.free_size += free_block_size;
115188: 8b 55 08 mov 0x8(%ebp),%edx
11518b: 01 72 30 add %esi,0x30(%edx)
*avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD;
11518e: 83 e9 04 sub $0x4,%ecx
115191: 8b 45 18 mov 0x18(%ebp),%eax
115194: 89 08 mov %ecx,(%eax)
115196: eb 3d jmp 1151d5 <_Heap_Resize_block+0x1d1>
} else if (free_block_size >= min_block_size) {
115198: 3b 75 ec cmp -0x14(%ebp),%esi <== NOT EXECUTED
11519b: 72 38 jb 1151d5 <_Heap_Resize_block+0x1d1><== NOT EXECUTED
/* Split the block into 2 used parts, then free the second one. */
the_block->size = new_block_size | prev_used_flag;
11519d: 09 5d e8 or %ebx,-0x18(%ebp) <== NOT EXECUTED
1151a0: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED
1151a3: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED
1151a6: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED
1151a9: 89 d0 mov %edx,%eax <== NOT EXECUTED
1151ab: 01 d8 add %ebx,%eax <== NOT EXECUTED
next_block = _Heap_Block_at(the_block, new_block_size);
next_block->size = free_block_size | HEAP_PREV_USED;
1151ad: 89 f2 mov %esi,%edx <== NOT EXECUTED
1151af: 83 ca 01 or $0x1,%edx <== NOT EXECUTED
1151b2: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED
++stats->used_blocks; /* We have created used block */
1151b5: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
1151b8: ff 42 40 incl 0x40(%edx) <== NOT EXECUTED
--stats->frees; /* Don't count next call in stats */
1151bb: ff 4a 50 decl 0x50(%edx) <== NOT EXECUTED
_Heap_Free(the_heap, _Heap_User_area(next_block));
1151be: 51 push %ecx <== NOT EXECUTED
1151bf: 51 push %ecx <== NOT EXECUTED
1151c0: 83 c0 08 add $0x8,%eax <== NOT EXECUTED
1151c3: 50 push %eax <== NOT EXECUTED
1151c4: 52 push %edx <== NOT EXECUTED
1151c5: e8 5e 87 ff ff call 10d928 <_Heap_Free> <== NOT EXECUTED
*avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD;
1151ca: 8d 46 fc lea -0x4(%esi),%eax <== NOT EXECUTED
1151cd: 8b 4d 18 mov 0x18(%ebp),%ecx <== NOT EXECUTED
1151d0: 89 01 mov %eax,(%ecx) <== NOT EXECUTED
1151d2: 83 c4 10 add $0x10,%esp
}
}
}
++stats->resizes;
1151d5: 8b 45 08 mov 0x8(%ebp),%eax
1151d8: ff 40 54 incl 0x54(%eax)
1151db: 31 c0 xor %eax,%eax
1151dd: eb 0c jmp 1151eb <_Heap_Resize_block+0x1e7>
return HEAP_RESIZE_SUCCESSFUL;
1151df: b8 02 00 00 00 mov $0x2,%eax
1151e4: eb 05 jmp 1151eb <_Heap_Resize_block+0x1e7>
1151e6: b8 01 00 00 00 mov $0x1,%eax
}
1151eb: 8d 65 f4 lea -0xc(%ebp),%esp
1151ee: 5b pop %ebx
1151ef: 5e pop %esi
1151f0: 5f pop %edi
1151f1: c9 leave
1151f2: c3 ret
001151f4 <_Heap_Size_of_user_area>:
bool _Heap_Size_of_user_area(
Heap_Control *the_heap,
void *starting_address,
size_t *size
)
{
1151f4: 55 push %ebp
1151f5: 89 e5 mov %esp,%ebp
1151f7: 57 push %edi
1151f8: 56 push %esi
1151f9: 53 push %ebx
1151fa: 8b 75 08 mov 0x8(%ebp),%esi
Heap_Block *the_block;
Heap_Block *next_block;
uint32_t the_size;
if ( !_Addresses_Is_in_range(
1151fd: 8b 7e 24 mov 0x24(%esi),%edi
115200: 8b 5e 20 mov 0x20(%esi),%ebx
115203: 39 5d 0c cmp %ebx,0xc(%ebp)
115206: 0f 93 c2 setae %dl
115209: 39 7d 0c cmp %edi,0xc(%ebp)
11520c: 0f 96 c0 setbe %al
11520f: 84 d0 test %dl,%al
115211: 74 49 je 11525c <_Heap_Size_of_user_area+0x68>
115213: 8b 4d 0c mov 0xc(%ebp),%ecx
115216: 83 e9 08 sub $0x8,%ecx
115219: 8b 45 0c mov 0xc(%ebp),%eax
11521c: 31 d2 xor %edx,%edx
11521e: f7 76 10 divl 0x10(%esi)
115221: 29 d1 sub %edx,%ecx
return( FALSE );
_Heap_Start_of_block( the_heap, starting_address, &the_block );
_HAssert(_Heap_Is_block_in( the_heap, the_block ));
if ( !_Heap_Is_block_in( the_heap, the_block ) )
115223: 39 d9 cmp %ebx,%ecx
115225: 0f 93 c2 setae %dl
115228: 39 f9 cmp %edi,%ecx
11522a: 0f 96 c0 setbe %al
11522d: 84 d0 test %dl,%al
11522f: 74 2b je 11525c <_Heap_Size_of_user_area+0x68><== NEVER TAKEN
115231: 8b 41 04 mov 0x4(%ecx),%eax
115234: 83 e0 fe and $0xfffffffe,%eax
115237: 01 c1 add %eax,%ecx
the_size = _Heap_Block_size( the_block );
next_block = _Heap_Block_at( the_block, the_size );
_HAssert(_Heap_Is_block_in( the_heap, next_block ));
_HAssert(_Heap_Is_prev_used( next_block ));
if (
115239: 39 d9 cmp %ebx,%ecx
11523b: 0f 93 c2 setae %dl
11523e: 39 f9 cmp %edi,%ecx
115240: 0f 96 c0 setbe %al
115243: 84 d0 test %dl,%al
115245: 74 15 je 11525c <_Heap_Size_of_user_area+0x68><== NEVER TAKEN
115247: f6 41 04 01 testb $0x1,0x4(%ecx)
11524b: 74 0f je 11525c <_Heap_Size_of_user_area+0x68><== NEVER TAKEN
and then add correction equal to the offset of the 'size' field of the
'Heap_Block' structure. The correction is due to the fact that
'prev_size' field of the next block is actually used as user accessible
area of 'the_block'. */
*size = _Addresses_Subtract ( next_block, starting_address )
11524d: 2b 4d 0c sub 0xc(%ebp),%ecx
115250: 8d 51 04 lea 0x4(%ecx),%edx
115253: 8b 45 10 mov 0x10(%ebp),%eax
115256: 89 10 mov %edx,(%eax)
115258: b0 01 mov $0x1,%al
11525a: eb 02 jmp 11525e <_Heap_Size_of_user_area+0x6a>
+ HEAP_BLOCK_HEADER_OFFSET;
return( TRUE );
11525c: 31 c0 xor %eax,%eax
}
11525e: 5b pop %ebx
11525f: 5e pop %esi
115260: 5f pop %edi
115261: c9 leave
115262: c3 ret
0010fa3c <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
10fa3c: 55 push %ebp
10fa3d: 89 e5 mov %esp,%ebp
10fa3f: 57 push %edi
10fa40: 56 push %esi
10fa41: 53 push %ebx
10fa42: 83 ec 1c sub $0x1c,%esp
10fa45: 8b 5d 0c mov 0xc(%ebp),%ebx
Heap_Block *the_block = the_heap->start;
10fa48: 8b 45 08 mov 0x8(%ebp),%eax
10fa4b: 8b 70 20 mov 0x20(%eax),%esi
Heap_Block *const end = the_heap->final;
10fa4e: 8b 50 24 mov 0x24(%eax),%edx
10fa51: 89 55 e8 mov %edx,-0x18(%ebp)
/*
if ( !_System_state_Is_up( _System_state_Get() ) )
return TRUE;
*/
if (source < 0)
10fa54: 85 db test %ebx,%ebx
10fa56: 79 03 jns 10fa5b <_Heap_Walk+0x1f> <== ALWAYS TAKEN
source = the_heap->stats.instance;
10fa58: 8b 58 28 mov 0x28(%eax),%ebx <== NOT EXECUTED
/*
* Handle the 1st block
*/
if (!_Heap_Is_prev_used(the_block)) {
10fa5b: 31 c9 xor %ecx,%ecx
10fa5d: f6 46 04 01 testb $0x1,0x4(%esi)
10fa61: 75 15 jne 10fa78 <_Heap_Walk+0x3c> <== ALWAYS TAKEN
printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source);
10fa63: 50 push %eax <== NOT EXECUTED
10fa64: 50 push %eax <== NOT EXECUTED
10fa65: 53 push %ebx <== NOT EXECUTED
10fa66: 68 ec aa 11 00 push $0x11aaec <== NOT EXECUTED
10fa6b: e8 66 8a ff ff call 1084d6 <printk> <== NOT EXECUTED
10fa70: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
10fa75: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
error = 1;
}
if (the_block->prev_size != the_heap->page_size) {
10fa78: 8b 06 mov (%esi),%eax
10fa7a: 8b 7d 08 mov 0x8(%ebp),%edi
10fa7d: 3b 47 10 cmp 0x10(%edi),%eax
10fa80: 0f 84 38 01 00 00 je 10fbbe <_Heap_Walk+0x182> <== ALWAYS TAKEN
printk("PASS: %d !prev_size of 1st block isn't page_size\n", source);
10fa86: 50 push %eax <== NOT EXECUTED
10fa87: 50 push %eax <== NOT EXECUTED
10fa88: 53 push %ebx <== NOT EXECUTED
10fa89: 68 22 ab 11 00 push $0x11ab22 <== NOT EXECUTED
10fa8e: e8 43 8a ff ff call 1084d6 <printk> <== NOT EXECUTED
10fa93: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
10fa98: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10fa9b: e9 1e 01 00 00 jmp 10fbbe <_Heap_Walk+0x182> <== NOT EXECUTED
10faa0: 8b 46 04 mov 0x4(%esi),%eax
10faa3: 89 45 f0 mov %eax,-0x10(%ebp)
10faa6: 83 e0 fe and $0xfffffffe,%eax
10faa9: 89 45 ec mov %eax,-0x14(%ebp)
/** @brief _Thread_Is_proxy_blocking
*
* status which indicates that a proxy is blocking, and FALSE otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking (
uint32_t code
10faac: 01 f0 add %esi,%eax
10faae: 89 45 e0 mov %eax,-0x20(%ebp)
printk(" prev_size %d", the_block->prev_size);
else
printk(" (prev_size) %d", the_block->prev_size);
}
if (!_Heap_Is_block_in(the_heap, next_block)) {
10fab1: 8b 55 08 mov 0x8(%ebp),%edx
10fab4: 3b 42 20 cmp 0x20(%edx),%eax
10fab7: 0f 93 c2 setae %dl
10faba: 8b 7d 08 mov 0x8(%ebp),%edi
10fabd: 3b 47 24 cmp 0x24(%edi),%eax
10fac0: 0f 96 c0 setbe %al
10fac3: 84 d0 test %dl,%al
10fac5: 75 0f jne 10fad6 <_Heap_Walk+0x9a> <== ALWAYS TAKEN
if (do_dump) printk("\n");
printk("PASS: %d !block %p is out of heap\n", source, next_block);
10fac7: 50 push %eax <== NOT EXECUTED
10fac8: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED
10facb: 53 push %ebx <== NOT EXECUTED
10facc: 68 54 ab 11 00 push $0x11ab54 <== NOT EXECUTED
10fad1: e9 d7 00 00 00 jmp 10fbad <_Heap_Walk+0x171> <== NOT EXECUTED
error = 1;
break;
}
if (!_Heap_Is_prev_used(next_block)) {
10fad6: 8b 45 e0 mov -0x20(%ebp),%eax
10fad9: f6 40 04 01 testb $0x1,0x4(%eax)
10fadd: 0f 85 85 00 00 00 jne 10fb68 <_Heap_Walk+0x12c>
if (do_dump)
printk( " prev %p next %p", the_block->prev, the_block->next);
if (_Heap_Block_size(the_block) != next_block->prev_size) {
10fae3: 8b 55 ec mov -0x14(%ebp),%edx
10fae6: 3b 10 cmp (%eax),%edx
10fae8: 74 15 je 10faff <_Heap_Walk+0xc3> <== ALWAYS TAKEN
if (do_dump) printk("\n");
printk("PASS: %d !front and back sizes don't match", source);
10faea: 50 push %eax <== NOT EXECUTED
10faeb: 50 push %eax <== NOT EXECUTED
10faec: 53 push %ebx <== NOT EXECUTED
10faed: 68 77 ab 11 00 push $0x11ab77 <== NOT EXECUTED
10faf2: e8 df 89 ff ff call 1084d6 <printk> <== NOT EXECUTED
10faf7: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
10fafc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
error = 1;
}
if (!prev_used) {
10faff: f6 45 f0 01 testb $0x1,-0x10(%ebp)
10fb03: 75 29 jne 10fb2e <_Heap_Walk+0xf2> <== ALWAYS TAKEN
if (do_dump || error) printk("\n");
10fb05: 85 c9 test %ecx,%ecx <== NOT EXECUTED
10fb07: 74 10 je 10fb19 <_Heap_Walk+0xdd> <== NOT EXECUTED
10fb09: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10fb0c: 68 01 a8 11 00 push $0x11a801 <== NOT EXECUTED
10fb11: e8 c0 89 ff ff call 1084d6 <printk> <== NOT EXECUTED
10fb16: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
printk("PASS: %d !two consecutive blocks are free", source);
10fb19: 57 push %edi <== NOT EXECUTED
10fb1a: 57 push %edi <== NOT EXECUTED
10fb1b: 53 push %ebx <== NOT EXECUTED
10fb1c: 68 a2 ab 11 00 push $0x11aba2 <== NOT EXECUTED
10fb21: e8 b0 89 ff ff call 1084d6 <printk> <== NOT EXECUTED
10fb26: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
10fb2b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
)
{
return ( the_thread == _Thread_Heir );
}
/**
10fb2e: 8b 7d 08 mov 0x8(%ebp),%edi
10fb31: 8b 47 08 mov 0x8(%edi),%eax
10fb34: eb 03 jmp 10fb39 <_Heap_Walk+0xfd>
}
{ /* Check if 'the_block' is in the free block list */
Heap_Block* block = _Heap_First(the_heap);
while(block != the_block && block != tail)
block = block->next;
10fb36: 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)
10fb39: 39 f0 cmp %esi,%eax
10fb3b: 74 2b je 10fb68 <_Heap_Walk+0x12c>
10fb3d: 3b 45 08 cmp 0x8(%ebp),%eax
10fb40: 75 f4 jne 10fb36 <_Heap_Walk+0xfa> <== ALWAYS TAKEN
block = block->next;
if(block != the_block) {
if (do_dump || error) printk("\n");
10fb42: 85 c9 test %ecx,%ecx <== NOT EXECUTED
10fb44: 74 10 je 10fb56 <_Heap_Walk+0x11a> <== NOT EXECUTED
10fb46: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10fb49: 68 01 a8 11 00 push $0x11a801 <== NOT EXECUTED
10fb4e: e8 83 89 ff ff call 1084d6 <printk> <== NOT EXECUTED
10fb53: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
printk("PASS: %d !the_block not in the free list", source);
10fb56: 51 push %ecx <== NOT EXECUTED
10fb57: 51 push %ecx <== NOT EXECUTED
10fb58: 53 push %ebx <== NOT EXECUTED
10fb59: 68 cc ab 11 00 push $0x11abcc <== NOT EXECUTED
10fb5e: e8 73 89 ff ff call 1084d6 <printk> <== NOT EXECUTED
10fb63: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10fb66: eb 04 jmp 10fb6c <_Heap_Walk+0x130> <== NOT EXECUTED
error = 1;
}
}
}
if (do_dump || error) printk("\n");
10fb68: 85 c9 test %ecx,%ecx
10fb6a: 74 15 je 10fb81 <_Heap_Walk+0x145> <== ALWAYS TAKEN
10fb6c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10fb6f: 68 01 a8 11 00 push $0x11a801 <== NOT EXECUTED
10fb74: e8 5d 89 ff ff call 1084d6 <printk> <== NOT EXECUTED
10fb79: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
10fb7e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if (the_size < the_heap->min_block_size) {
10fb81: 8b 55 ec mov -0x14(%ebp),%edx
10fb84: 8b 45 08 mov 0x8(%ebp),%eax
10fb87: 3b 50 14 cmp 0x14(%eax),%edx
10fb8a: 73 0a jae 10fb96 <_Heap_Walk+0x15a> <== ALWAYS TAKEN
printk("PASS: %d !block size is too small\n", source);
10fb8c: 52 push %edx <== NOT EXECUTED
10fb8d: 52 push %edx <== NOT EXECUTED
10fb8e: 53 push %ebx <== NOT EXECUTED
10fb8f: 68 f5 ab 11 00 push $0x11abf5 <== NOT EXECUTED
10fb94: eb 17 jmp 10fbad <_Heap_Walk+0x171> <== NOT EXECUTED
error = 1;
break;
}
if (!_Heap_Is_aligned( the_size, the_heap->page_size)) {
10fb96: 8b 45 ec mov -0x14(%ebp),%eax
10fb99: 8b 7d 08 mov 0x8(%ebp),%edi
10fb9c: 31 d2 xor %edx,%edx
10fb9e: f7 77 10 divl 0x10(%edi)
10fba1: 85 d2 test %edx,%edx
10fba3: 74 12 je 10fbb7 <_Heap_Walk+0x17b> <== ALWAYS TAKEN
printk("PASS: %d !block size is misaligned\n", source);
10fba5: 50 push %eax <== NOT EXECUTED
10fba6: 50 push %eax <== NOT EXECUTED
10fba7: 53 push %ebx <== NOT EXECUTED
10fba8: 68 18 ac 11 00 push $0x11ac18 <== NOT EXECUTED
10fbad: e8 24 89 ff ff call 1084d6 <printk> <== NOT EXECUTED
10fbb2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10fbb5: eb 12 jmp 10fbc9 <_Heap_Walk+0x18d> <== NOT EXECUTED
error = 1;
}
if (++passes > (do_dump ? 10 : 0) && error)
10fbb7: 85 c9 test %ecx,%ecx
10fbb9: 75 0e jne 10fbc9 <_Heap_Walk+0x18d> <== NEVER TAKEN
break;
10fbbb: 8b 75 e0 mov -0x20(%ebp),%esi
if (the_block->prev_size != the_heap->page_size) {
printk("PASS: %d !prev_size of 1st block isn't page_size\n", source);
error = 1;
}
while ( the_block != end ) {
10fbbe: 3b 75 e8 cmp -0x18(%ebp),%esi
10fbc1: 0f 85 d9 fe ff ff jne 10faa0 <_Heap_Walk+0x64>
10fbc7: eb 17 jmp 10fbe0 <_Heap_Walk+0x1a4>
the_block = next_block;
}
if (the_block != end) {
printk("PASS: %d !last block address isn't equal to 'final' %p %p\n",
10fbc9: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED
10fbcc: 56 push %esi <== NOT EXECUTED
10fbcd: 53 push %ebx <== NOT EXECUTED
10fbce: 68 3c ac 11 00 push $0x11ac3c <== NOT EXECUTED
10fbd3: e8 fe 88 ff ff call 1084d6 <printk> <== NOT EXECUTED
10fbd8: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
10fbdd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10fbe0: 8b 46 04 mov 0x4(%esi),%eax
10fbe3: 83 e0 fe and $0xfffffffe,%eax
source, the_block, end);
error = 1;
}
if (_Heap_Block_size(the_block) != the_heap->page_size) {
10fbe6: 8b 75 08 mov 0x8(%ebp),%esi
10fbe9: 8b 56 10 mov 0x10(%esi),%edx
10fbec: 39 d0 cmp %edx,%eax
10fbee: 74 15 je 10fc05 <_Heap_Walk+0x1c9> <== ALWAYS TAKEN
printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source,
10fbf0: 52 push %edx <== NOT EXECUTED
10fbf1: 50 push %eax <== NOT EXECUTED
10fbf2: 53 push %ebx <== NOT EXECUTED
10fbf3: 68 77 ac 11 00 push $0x11ac77 <== NOT EXECUTED
10fbf8: e8 d9 88 ff ff call 1084d6 <printk> <== NOT EXECUTED
10fbfd: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
10fc02: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10fc05: 88 c8 mov %cl,%al
if(do_dump && error)
_Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 );
return error;
}
10fc07: 8d 65 f4 lea -0xc(%ebp),%esp
10fc0a: 5b pop %ebx
10fc0b: 5e pop %esi
10fc0c: 5f pop %edi
10fc0d: c9 leave
10fc0e: c3 ret
0010a154 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
uint32_t the_error
)
{
10a154: 55 push %ebp
10a155: 89 e5 mov %esp,%ebp
10a157: 53 push %ebx
10a158: 83 ec 08 sub $0x8,%esp
10a15b: 8b 55 08 mov 0x8(%ebp),%edx
10a15e: 8b 45 0c mov 0xc(%ebp),%eax
10a161: 8b 5d 10 mov 0x10(%ebp),%ebx
_Internal_errors_What_happened.the_source = the_source;
10a164: 89 15 88 cb 11 00 mov %edx,0x11cb88
_Internal_errors_What_happened.is_internal = is_internal;
10a16a: a2 8c cb 11 00 mov %al,0x11cb8c
_Internal_errors_What_happened.the_error = the_error;
10a16f: 89 1d 90 cb 11 00 mov %ebx,0x11cb90
_User_extensions_Fatal( the_source, is_internal, the_error );
10a175: 53 push %ebx
10a176: 0f b6 c0 movzbl %al,%eax
10a179: 50 push %eax
10a17a: 52 push %edx
10a17b: e8 eb 18 00 00 call 10ba6b <_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(
10a180: c7 05 80 cc 11 00 05 movl $0x5,0x11cc80 <== NOT EXECUTED
10a187: 00 00 00
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
10a18a: fa cli <== NOT EXECUTED
10a18b: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10a18d: f4 hlt <== NOT EXECUTED
10a18e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a191: eb fe jmp 10a191 <_Internal_error_Occurred+0x3d><== NOT EXECUTED
0010da90 <_Objects_API_maximum_class>:
#include <rtems/score/object.h>
int _Objects_API_maximum_class(
uint32_t api
)
{
10da90: 55 push %ebp
10da91: 89 e5 mov %esp,%ebp
10da93: 8b 55 08 mov 0x8(%ebp),%edx
switch (api) {
10da96: b8 0a 00 00 00 mov $0xa,%eax
10da9b: 83 fa 02 cmp $0x2,%edx
10da9e: 74 1b je 10dabb <_Objects_API_maximum_class+0x2b>
10daa0: 77 05 ja 10daa7 <_Objects_API_maximum_class+0x17>
10daa2: b0 02 mov $0x2,%al
10daa4: 4a dec %edx
10daa5: eb 0f jmp 10dab6 <_Objects_API_maximum_class+0x26>
10daa7: b8 0c 00 00 00 mov $0xc,%eax
10daac: 83 fa 03 cmp $0x3,%edx
10daaf: 74 0a je 10dabb <_Objects_API_maximum_class+0x2b><== NEVER TAKEN
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;
10dab1: b0 08 mov $0x8,%al
int _Objects_API_maximum_class(
uint32_t api
)
{
switch (api) {
10dab3: 83 fa 04 cmp $0x4,%edx
10dab6: 74 03 je 10dabb <_Objects_API_maximum_class+0x2b>
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;
10dab8: 83 c8 ff or $0xffffffff,%eax
case OBJECTS_NO_API:
default:
break;
}
return -1;
}
10dabb: c9 leave
10dabc: c3 ret
0010a1e8 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
10a1e8: 55 push %ebp
10a1e9: 89 e5 mov %esp,%ebp
10a1eb: 56 push %esi
10a1ec: 53 push %ebx
10a1ed: 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 )
10a1f0: 31 c9 xor %ecx,%ecx
10a1f2: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
10a1f6: 74 59 je 10a251 <_Objects_Allocate+0x69><== NEVER TAKEN
/*
* OK. The manager should be initialized and configured to have objects.
* With any luck, it is safe to attempt to allocate an object.
*/
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10a1f8: 8d 73 20 lea 0x20(%ebx),%esi
10a1fb: 83 ec 0c sub $0xc,%esp
10a1fe: 56 push %esi
10a1ff: e8 6c f8 ff ff call 109a70 <_Chain_Get>
10a204: 89 c1 mov %eax,%ecx
if ( information->auto_extend ) {
10a206: 83 c4 10 add $0x10,%esp
10a209: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10a20d: 74 42 je 10a251 <_Objects_Allocate+0x69>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
10a20f: 85 c0 test %eax,%eax
10a211: 75 1a jne 10a22d <_Objects_Allocate+0x45>
_Objects_Extend_information( information );
10a213: 83 ec 0c sub $0xc,%esp
10a216: 53 push %ebx
10a217: e8 64 00 00 00 call 10a280 <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10a21c: 89 34 24 mov %esi,(%esp)
10a21f: e8 4c f8 ff ff call 109a70 <_Chain_Get>
10a224: 89 c1 mov %eax,%ecx
}
if ( the_object ) {
10a226: 83 c4 10 add $0x10,%esp
10a229: 85 c0 test %eax,%eax
10a22b: 74 24 je 10a251 <_Objects_Allocate+0x69><== NEVER TAKEN
uint32_t block;
block = _Objects_Get_index( the_object->id ) -
10a22d: 8b 41 08 mov 0x8(%ecx),%eax
10a230: 25 ff ff 00 00 and $0xffff,%eax
10a235: 8b 53 08 mov 0x8(%ebx),%edx
10a238: 81 e2 ff ff 00 00 and $0xffff,%edx
10a23e: 29 d0 sub %edx,%eax
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
10a240: 31 d2 xor %edx,%edx
10a242: f7 73 14 divl 0x14(%ebx)
10a245: c1 e0 02 shl $0x2,%eax
10a248: 03 43 30 add 0x30(%ebx),%eax
10a24b: ff 08 decl (%eax)
information->inactive--;
10a24d: 66 ff 4b 2c decw 0x2c(%ebx)
}
}
return the_object;
}
10a251: 89 c8 mov %ecx,%eax
10a253: 8d 65 f8 lea -0x8(%ebp),%esp
10a256: 5b pop %ebx
10a257: 5e pop %esi
10a258: c9 leave
10a259: c3 ret
0010a280 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
10a280: 55 push %ebp
10a281: 89 e5 mov %esp,%ebp
10a283: 57 push %edi
10a284: 56 push %esi
10a285: 53 push %ebx
10a286: 83 ec 5c sub $0x5c,%esp
10a289: 8b 5d 08 mov 0x8(%ebp),%ebx
* alignments are possible.
* Returns pointer to the start of the memory block if success, NULL if
* failure.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
10a28c: 8b 43 08 mov 0x8(%ebx),%eax
10a28f: 25 ff ff 00 00 and $0xffff,%eax
10a294: 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 )
10a297: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx
10a29b: 39 c1 cmp %eax,%ecx
10a29d: 73 13 jae 10a2b2 <_Objects_Extend_information+0x32>
10a29f: 89 45 c4 mov %eax,-0x3c(%ebp)
10a2a2: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%ebp)
10a2a9: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp)
10a2b0: eb 35 jmp 10a2e7 <_Objects_Extend_information+0x67>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
10a2b2: 8b 7b 14 mov 0x14(%ebx),%edi
10a2b5: 89 c8 mov %ecx,%eax
10a2b7: 31 d2 xor %edx,%edx
10a2b9: f7 f7 div %edi
10a2bb: 89 c6 mov %eax,%esi
10a2bd: 89 45 bc mov %eax,-0x44(%ebp)
10a2c0: 8b 45 c8 mov -0x38(%ebp),%eax
10a2c3: 89 45 c4 mov %eax,-0x3c(%ebp)
10a2c6: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp)
10a2cd: eb 13 jmp 10a2e2 <_Objects_Extend_information+0x62>
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL )
10a2cf: 8b 43 34 mov 0x34(%ebx),%eax
10a2d2: 8b 55 c0 mov -0x40(%ebp),%edx
10a2d5: 83 3c 90 00 cmpl $0x0,(%eax,%edx,4)
10a2d9: 74 0c je 10a2e7 <_Objects_Extend_information+0x67>
break;
else
index_base += information->allocation_size;
10a2db: 01 7d c4 add %edi,-0x3c(%ebp)
if ( information->maximum < minimum_index )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
10a2de: 42 inc %edx
10a2df: 89 55 c0 mov %edx,-0x40(%ebp)
10a2e2: 39 75 c0 cmp %esi,-0x40(%ebp)
10a2e5: 72 e8 jb 10a2cf <_Objects_Extend_information+0x4f>
/*
* If the index_base is the maximum we need to grow the tables.
*/
if (index_base >= information->maximum ) {
10a2e7: 39 4d c4 cmp %ecx,-0x3c(%ebp)
10a2ea: 0f 82 30 01 00 00 jb 10a420 <_Objects_Extend_information+0x1a0>
/*
* Up the block count and maximum
*/
block_count++;
10a2f0: 8b 75 bc mov -0x44(%ebp),%esi
10a2f3: 46 inc %esi
maximum = information->maximum + information->allocation_size;
10a2f4: 03 4b 14 add 0x14(%ebx),%ecx
10a2f7: 89 4d d0 mov %ecx,-0x30(%ebp)
/*
* Allocate the tables and break it up.
*/
if ( information->auto_extend ) {
10a2fa: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10a2fe: 8b 7d c8 mov -0x38(%ebp),%edi
10a301: 8d 14 39 lea (%ecx,%edi,1),%edx
10a304: 74 21 je 10a327 <_Objects_Extend_information+0xa7>
object_blocks = (void**)
10a306: 83 ec 0c sub $0xc,%esp
10a309: 8d 04 76 lea (%esi,%esi,2),%eax
10a30c: 8d 04 02 lea (%edx,%eax,1),%eax
10a30f: c1 e0 02 shl $0x2,%eax
10a312: 50 push %eax
10a313: e8 71 1a 00 00 call 10bd89 <_Workspace_Allocate>
10a318: 89 45 a0 mov %eax,-0x60(%ebp)
block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *))
);
if ( !object_blocks )
10a31b: 83 c4 10 add $0x10,%esp
10a31e: 85 c0 test %eax,%eax
10a320: 75 1d jne 10a33f <_Objects_Extend_information+0xbf><== ALWAYS TAKEN
10a322: e9 c9 01 00 00 jmp 10a4f0 <_Objects_Extend_information+0x270><== NOT EXECUTED
return;
}
else {
object_blocks = (void**)
10a327: 83 ec 0c sub $0xc,%esp
10a32a: 8d 04 76 lea (%esi,%esi,2),%eax
10a32d: 8d 04 02 lea (%edx,%eax,1),%eax
10a330: c1 e0 02 shl $0x2,%eax
10a333: 50 push %eax
10a334: e8 65 1a 00 00 call 10bd9e <_Workspace_Allocate_or_fatal_error>
10a339: 89 45 a0 mov %eax,-0x60(%ebp)
10a33c: 83 c4 10 add $0x10,%esp
/*
* Break the block into the various sections.
*
*/
inactive_per_block = (uint32_t *) _Addresses_Add_offset(
10a33f: 8b 45 a0 mov -0x60(%ebp),%eax
10a342: 8d 04 b0 lea (%eax,%esi,4),%eax
10a345: 89 45 cc mov %eax,-0x34(%ebp)
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory for
* the heap
10a348: 8b 55 a0 mov -0x60(%ebp),%edx
10a34b: 8d 34 f2 lea (%edx,%esi,8),%esi
10a34e: 89 75 d4 mov %esi,-0x2c(%ebp)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
10a351: 0f b7 43 10 movzwl 0x10(%ebx),%eax
10a355: 31 d2 xor %edx,%edx
10a357: 3b 45 c8 cmp -0x38(%ebp),%eax
10a35a: 76 39 jbe 10a395 <_Objects_Extend_information+0x115>
/*
* Copy each section of the table over. This has to be performed as
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
10a35c: 8b 45 bc mov -0x44(%ebp),%eax
10a35f: c1 e0 02 shl $0x2,%eax
10a362: 8b 73 34 mov 0x34(%ebx),%esi
10a365: 8b 7d a0 mov -0x60(%ebp),%edi
10a368: 89 c1 mov %eax,%ecx
10a36a: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
10a36c: 8b 73 30 mov 0x30(%ebx),%esi
10a36f: 8b 7d cc mov -0x34(%ebp),%edi
10a372: 89 c1 mov %eax,%ecx
10a374: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
10a376: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx
10a37a: 03 4d c8 add -0x38(%ebp),%ecx
10a37d: c1 e1 02 shl $0x2,%ecx
10a380: 8b 73 1c mov 0x1c(%ebx),%esi
10a383: 8b 7d d4 mov -0x2c(%ebp),%edi
10a386: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
10a388: eb 10 jmp 10a39a <_Objects_Extend_information+0x11a>
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
local_table[ index ] = NULL;
10a38a: 8b 45 d4 mov -0x2c(%ebp),%eax
10a38d: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4)
else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
10a394: 42 inc %edx
10a395: 3b 55 c8 cmp -0x38(%ebp),%edx
10a398: 72 f0 jb 10a38a <_Objects_Extend_information+0x10a>
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
10a39a: 8b 55 bc mov -0x44(%ebp),%edx
10a39d: 8b 4d a0 mov -0x60(%ebp),%ecx
10a3a0: c7 04 91 00 00 00 00 movl $0x0,(%ecx,%edx,4)
inactive_per_block[block_count] = 0;
10a3a7: 8b 75 cc mov -0x34(%ebp),%esi
10a3aa: c7 04 96 00 00 00 00 movl $0x0,(%esi,%edx,4)
for ( index=index_base ;
index < ( information->allocation_size + index_base );
10a3b1: 8b 4d c4 mov -0x3c(%ebp),%ecx
10a3b4: 03 4b 14 add 0x14(%ebx),%ecx
10a3b7: 8b 7d c4 mov -0x3c(%ebp),%edi
10a3ba: 8b 45 d4 mov -0x2c(%ebp),%eax
10a3bd: 8d 14 b8 lea (%eax,%edi,4),%edx
10a3c0: 89 f8 mov %edi,%eax
10a3c2: eb 0a jmp 10a3ce <_Objects_Extend_information+0x14e>
index++ ) {
local_table[ index ] = NULL;
10a3c4: 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++ ) {
10a3ca: 40 inc %eax
10a3cb: 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 );
10a3ce: 39 c8 cmp %ecx,%eax
10a3d0: 72 f2 jb 10a3c4 <_Objects_Extend_information+0x144>
index++ ) {
local_table[ index ] = NULL;
}
_ISR_Disable( level );
10a3d2: 9c pushf
10a3d3: fa cli
10a3d4: 59 pop %ecx
old_tables = information->object_blocks;
10a3d5: 8b 73 34 mov 0x34(%ebx),%esi
information->object_blocks = object_blocks;
10a3d8: 8b 55 a0 mov -0x60(%ebp),%edx
10a3db: 89 53 34 mov %edx,0x34(%ebx)
information->inactive_per_block = inactive_per_block;
10a3de: 8b 7d cc mov -0x34(%ebp),%edi
10a3e1: 89 7b 30 mov %edi,0x30(%ebx)
information->local_table = local_table;
10a3e4: 8b 45 d4 mov -0x2c(%ebp),%eax
10a3e7: 89 43 1c mov %eax,0x1c(%ebx)
information->maximum = maximum;
10a3ea: 8b 55 d0 mov -0x30(%ebp),%edx
10a3ed: 66 89 53 10 mov %dx,0x10(%ebx)
information->maximum_id = _Objects_Build_id(
10a3f1: 8b 13 mov (%ebx),%edx
10a3f3: c1 e2 18 shl $0x18,%edx
10a3f6: 81 ca 00 00 01 00 or $0x10000,%edx
10a3fc: 0f b7 43 04 movzwl 0x4(%ebx),%eax
10a400: c1 e0 1b shl $0x1b,%eax
10a403: 09 c2 or %eax,%edx
10a405: 0f b7 45 d0 movzwl -0x30(%ebp),%eax
10a409: 09 c2 or %eax,%edx
10a40b: 89 53 0c mov %edx,0xc(%ebx)
information->the_class,
_Objects_Local_node,
information->maximum
);
_ISR_Enable( level );
10a40e: 51 push %ecx
10a40f: 9d popf
if ( old_tables )
10a410: 85 f6 test %esi,%esi
10a412: 74 0c je 10a420 <_Objects_Extend_information+0x1a0>
_Workspace_Free( old_tables );
10a414: 83 ec 0c sub $0xc,%esp
10a417: 56 push %esi
10a418: e8 57 19 00 00 call 10bd74 <_Workspace_Free>
10a41d: 83 c4 10 add $0x10,%esp
/*
* Allocate the name table, and the objects
*/
if ( information->auto_extend ) {
10a420: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10a424: 8b 43 18 mov 0x18(%ebx),%eax
10a427: 74 32 je 10a45b <_Objects_Extend_information+0x1db>
information->object_blocks[ block ] =
10a429: 8b 4d c0 mov -0x40(%ebp),%ecx
10a42c: 8b 73 34 mov 0x34(%ebx),%esi
10a42f: 8d 0c 8e lea (%esi,%ecx,4),%ecx
10a432: 89 4d d8 mov %ecx,-0x28(%ebp)
10a435: 83 ec 0c sub $0xc,%esp
10a438: 0f af 43 14 imul 0x14(%ebx),%eax
10a43c: 50 push %eax
10a43d: e8 47 19 00 00 call 10bd89 <_Workspace_Allocate>
10a442: 8b 7d d8 mov -0x28(%ebp),%edi
10a445: 89 07 mov %eax,(%edi)
_Workspace_Allocate(
(information->allocation_size * information->size)
);
if ( !information->object_blocks[ block ] )
10a447: 8b 43 34 mov 0x34(%ebx),%eax
10a44a: 83 c4 10 add $0x10,%esp
10a44d: 8b 55 c0 mov -0x40(%ebp),%edx
10a450: 83 3c 90 00 cmpl $0x0,(%eax,%edx,4)
10a454: 75 26 jne 10a47c <_Objects_Extend_information+0x1fc><== ALWAYS TAKEN
10a456: e9 95 00 00 00 jmp 10a4f0 <_Objects_Extend_information+0x270><== NOT EXECUTED
return;
}
else {
information->object_blocks[ block ] =
10a45b: 8b 4d c0 mov -0x40(%ebp),%ecx
10a45e: 8b 73 34 mov 0x34(%ebx),%esi
10a461: 8d 0c 8e lea (%esi,%ecx,4),%ecx
10a464: 89 4d dc mov %ecx,-0x24(%ebp)
10a467: 83 ec 0c sub $0xc,%esp
10a46a: 0f af 43 14 imul 0x14(%ebx),%eax
10a46e: 50 push %eax
10a46f: e8 2a 19 00 00 call 10bd9e <_Workspace_Allocate_or_fatal_error>
10a474: 8b 7d dc mov -0x24(%ebp),%edi
10a477: 89 07 mov %eax,(%edi)
10a479: 83 c4 10 add $0x10,%esp
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
10a47c: 8b 45 c0 mov -0x40(%ebp),%eax
10a47f: c1 e0 02 shl $0x2,%eax
10a482: 89 45 e0 mov %eax,-0x20(%ebp)
10a485: ff 73 18 pushl 0x18(%ebx)
10a488: ff 73 14 pushl 0x14(%ebx)
10a48b: 8b 43 34 mov 0x34(%ebx),%eax
10a48e: 8b 55 c0 mov -0x40(%ebp),%edx
10a491: ff 34 90 pushl (%eax,%edx,4)
10a494: 8d 7d e8 lea -0x18(%ebp),%edi
10a497: 57 push %edi
10a498: e8 eb 31 00 00 call 10d688 <_Chain_Initialize>
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10a49d: 8d 4b 20 lea 0x20(%ebx),%ecx
10a4a0: 89 4d b8 mov %ecx,-0x48(%ebp)
10a4a3: 8b 75 c4 mov -0x3c(%ebp),%esi
10a4a6: eb 24 jmp 10a4cc <_Objects_Extend_information+0x24c>
index = index_base;
while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) {
the_object->id = _Objects_Build_id(
10a4a8: 8b 03 mov (%ebx),%eax
10a4aa: c1 e0 18 shl $0x18,%eax
10a4ad: 0d 00 00 01 00 or $0x10000,%eax
10a4b2: 0f b7 53 04 movzwl 0x4(%ebx),%edx
10a4b6: c1 e2 1b shl $0x1b,%edx
10a4b9: 09 d0 or %edx,%eax
10a4bb: 09 f0 or %esi,%eax
10a4bd: 89 41 08 mov %eax,0x8(%ecx)
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
10a4c0: 50 push %eax
10a4c1: 50 push %eax
10a4c2: 51 push %ecx
10a4c3: ff 75 b8 pushl -0x48(%ebp)
10a4c6: e8 81 f5 ff ff call 109a4c <_Chain_Append>
index++;
10a4cb: 46 inc %esi
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) {
10a4cc: 89 3c 24 mov %edi,(%esp)
10a4cf: e8 9c f5 ff ff call 109a70 <_Chain_Get>
10a4d4: 89 c1 mov %eax,%ecx
10a4d6: 83 c4 10 add $0x10,%esp
10a4d9: 85 c0 test %eax,%eax
10a4db: 75 cb jne 10a4a8 <_Objects_Extend_information+0x228>
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
10a4dd: 8b 43 30 mov 0x30(%ebx),%eax
10a4e0: 8b 53 14 mov 0x14(%ebx),%edx
10a4e3: 8b 75 e0 mov -0x20(%ebp),%esi
10a4e6: 89 14 30 mov %edx,(%eax,%esi,1)
information->inactive += information->allocation_size;
10a4e9: 8b 43 14 mov 0x14(%ebx),%eax
10a4ec: 66 01 43 2c add %ax,0x2c(%ebx)
}
10a4f0: 8d 65 f4 lea -0xc(%ebp),%esp
10a4f3: 5b pop %ebx
10a4f4: 5e pop %esi
10a4f5: 5f pop %edi
10a4f6: c9 leave
10a4f7: c3 ret
0010a58c <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint32_t the_class
)
{
10a58c: 55 push %ebp
10a58d: 89 e5 mov %esp,%ebp
10a58f: 56 push %esi
10a590: 53 push %ebx
10a591: 8b 5d 08 mov 0x8(%ebp),%ebx
10a594: 8b 75 0c mov 0xc(%ebp),%esi
/**
* This function sets @a *size to the size of the block of user memory
* which begins at @a starting_address. The size returned in @a *size could
* be greater than the size requested for allocation.
* Returns TRUE if the @a starting_address is in the heap, and FALSE
* otherwise.
10a597: 8d 43 ff lea -0x1(%ebx),%eax
10a59a: 83 f8 03 cmp $0x3,%eax
10a59d: 77 2f ja 10a5ce <_Objects_Get_information+0x42>
10a59f: eb 36 jmp 10a5d7 <_Objects_Get_information+0x4b>
return NULL;
if ( !the_class )
return NULL;
the_class_api_maximum = _Objects_API_maximum_class( the_api );
10a5a1: 83 ec 0c sub $0xc,%esp
10a5a4: 53 push %ebx
10a5a5: e8 e6 34 00 00 call 10da90 <_Objects_API_maximum_class>
if ( the_class_api_maximum < 0 ||
10a5aa: 83 c4 10 add $0x10,%esp
10a5ad: 85 c0 test %eax,%eax
10a5af: 78 1d js 10a5ce <_Objects_Get_information+0x42><== NEVER TAKEN
10a5b1: 39 c6 cmp %eax,%esi
10a5b3: 77 19 ja 10a5ce <_Objects_Get_information+0x42><== NEVER TAKEN
the_class > (uint32_t) the_class_api_maximum )
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10a5b5: 8b 04 9d b4 ca 11 00 mov 0x11cab4(,%ebx,4),%eax
10a5bc: 85 c0 test %eax,%eax
10a5be: 74 0e je 10a5ce <_Objects_Get_information+0x42><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
10a5c0: 8b 04 b0 mov (%eax,%esi,4),%eax
if ( !info )
10a5c3: 85 c0 test %eax,%eax
10a5c5: 74 09 je 10a5d0 <_Objects_Get_information+0x44><== NEVER TAKEN
* In a multprocessing configuration, we may access remote objects.
* Thus we may have 0 local instances and still have a valid object
* pointer.
*/
#if !defined(RTEMS_MULTIPROCESSING)
if ( info->maximum == 0 )
10a5c7: 66 83 78 10 00 cmpw $0x0,0x10(%eax)
10a5cc: 75 02 jne 10a5d0 <_Objects_Get_information+0x44>
10a5ce: 31 c0 xor %eax,%eax
return NULL;
#endif
return info;
}
10a5d0: 8d 65 f8 lea -0x8(%ebp),%esp
10a5d3: 5b pop %ebx
10a5d4: 5e pop %esi
10a5d5: c9 leave
10a5d6: c3 ret
int the_class_api_maximum;
if ( !_Objects_Is_api_valid( the_api ) )
return NULL;
if ( !the_class )
10a5d7: 85 f6 test %esi,%esi
10a5d9: 74 f3 je 10a5ce <_Objects_Get_information+0x42>
10a5db: eb c4 jmp 10a5a1 <_Objects_Get_information+0x15>
0010a5e0 <_Objects_Get_isr_disable>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location,
ISR_Level *level_p
)
{
10a5e0: 55 push %ebp
10a5e1: 89 e5 mov %esp,%ebp
10a5e3: 56 push %esi
10a5e4: 53 push %ebx
10a5e5: 8b 75 08 mov 0x8(%ebp),%esi
10a5e8: 8b 5d 10 mov 0x10(%ebp),%ebx
#if defined(RTEMS_MULTIPROCESSING)
index = id - information->minimum_id + 1;
#else
/* index = _Objects_Get_index( id ); */
index = id & 0x0000ffff;
10a5eb: 0f b7 55 0c movzwl 0xc(%ebp),%edx
/* This should work but doesn't always :( */
/* index = (uint16_t ) id; */
#endif
_ISR_Disable( level );
10a5ef: 9c pushf
10a5f0: fa cli
10a5f1: 59 pop %ecx
if ( information->maximum >= index ) {
10a5f2: 0f b7 46 10 movzwl 0x10(%esi),%eax
10a5f6: 39 d0 cmp %edx,%eax
10a5f8: 72 21 jb 10a61b <_Objects_Get_isr_disable+0x3b>
if ( (the_object = information->local_table[ index ]) != NULL ) {
10a5fa: 8b 46 1c mov 0x1c(%esi),%eax
10a5fd: 8b 14 90 mov (%eax,%edx,4),%edx
10a600: 85 d2 test %edx,%edx
10a602: 74 0d je 10a611 <_Objects_Get_isr_disable+0x31><== NEVER TAKEN
*location = OBJECTS_LOCAL;
10a604: c7 03 00 00 00 00 movl $0x0,(%ebx)
*level_p = level;
10a60a: 8b 45 14 mov 0x14(%ebp),%eax
10a60d: 89 08 mov %ecx,(%eax)
10a60f: eb 14 jmp 10a625 <_Objects_Get_isr_disable+0x45>
return the_object;
}
_ISR_Enable( level );
10a611: 51 push %ecx <== NOT EXECUTED
10a612: 9d popf <== NOT EXECUTED
*location = OBJECTS_ERROR;
10a613: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED
10a619: eb 0a jmp 10a625 <_Objects_Get_isr_disable+0x45><== NOT EXECUTED
return NULL;
}
_ISR_Enable( level );
10a61b: 51 push %ecx
10a61c: 9d popf
*location = OBJECTS_ERROR;
10a61d: c7 03 01 00 00 00 movl $0x1,(%ebx)
10a623: 31 d2 xor %edx,%edx
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
#endif
}
10a625: 89 d0 mov %edx,%eax
10a627: 5b pop %ebx
10a628: 5e pop %esi
10a629: c9 leave
10a62a: c3 ret
0010b8d4 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
10b8d4: 55 push %ebp
10b8d5: 89 e5 mov %esp,%ebp
10b8d7: 57 push %edi
10b8d8: 56 push %esi
10b8d9: 53 push %ebx
10b8da: 83 ec 1c sub $0x1c,%esp
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
10b8dd: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10b8e1: 0f 84 b3 00 00 00 je 10b99a <_Objects_Get_name_as_string+0xc6>
return NULL;
if ( name == NULL )
10b8e7: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10b8eb: 0f 84 b0 00 00 00 je 10b9a1 <_Objects_Get_name_as_string+0xcd>
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10b8f1: 8b 5d 08 mov 0x8(%ebp),%ebx
10b8f4: 85 db test %ebx,%ebx
10b8f6: 75 08 jne 10b900 <_Objects_Get_name_as_string+0x2c>
10b8f8: a1 5c 85 12 00 mov 0x12855c,%eax
10b8fd: 8b 58 08 mov 0x8(%eax),%ebx
information = _Objects_Get_information_id( tmpId );
10b900: 83 ec 0c sub $0xc,%esp
10b903: 53 push %ebx
10b904: e8 0b ff ff ff call 10b814 <_Objects_Get_information_id>
10b909: 89 c6 mov %eax,%esi
if ( !information )
10b90b: 83 c4 10 add $0x10,%esp
10b90e: 85 c0 test %eax,%eax
10b910: 0f 84 84 00 00 00 je 10b99a <_Objects_Get_name_as_string+0xc6>
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
10b916: 50 push %eax
10b917: 8d 45 f0 lea -0x10(%ebp),%eax
10b91a: 50 push %eax
10b91b: 53 push %ebx
10b91c: 56 push %esi
10b91d: e8 8a 00 00 00 call 10b9ac <_Objects_Get>
switch ( location ) {
10b922: 83 c4 10 add $0x10,%esp
10b925: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
10b929: 75 6f jne 10b99a <_Objects_Get_name_as_string+0xc6>
case OBJECTS_ERROR:
return NULL;
case OBJECTS_LOCAL:
if ( information->is_string ) {
10b92b: 80 7e 38 00 cmpb $0x0,0x38(%esi)
10b92f: 74 0c je 10b93d <_Objects_Get_name_as_string+0x69>
s = the_object->name.name_p;
10b931: 8b 78 0c mov 0xc(%eax),%edi
lname[ 4 ] = '\0';
s = lname;
}
d = name;
if ( s ) {
10b934: 8b 75 10 mov 0x10(%ebp),%esi
10b937: 85 ff test %edi,%edi
10b939: 75 27 jne 10b962 <_Objects_Get_name_as_string+0x8e><== ALWAYS TAKEN
10b93b: eb 53 jmp 10b990 <_Objects_Get_name_as_string+0xbc><== NOT EXECUTED
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;
10b93d: 8b 50 0c mov 0xc(%eax),%edx
lname[ 0 ] = (u32_name >> 24) & 0xff;
10b940: 89 d0 mov %edx,%eax
10b942: c1 e8 18 shr $0x18,%eax
10b945: 88 45 eb mov %al,-0x15(%ebp)
lname[ 1 ] = (u32_name >> 16) & 0xff;
10b948: 89 d0 mov %edx,%eax
10b94a: c1 e8 10 shr $0x10,%eax
10b94d: 88 45 ec mov %al,-0x14(%ebp)
lname[ 2 ] = (u32_name >> 8) & 0xff;
10b950: 89 d0 mov %edx,%eax
10b952: c1 e8 08 shr $0x8,%eax
10b955: 88 45 ed mov %al,-0x13(%ebp)
lname[ 3 ] = (u32_name >> 0) & 0xff;
10b958: 88 55 ee mov %dl,-0x12(%ebp)
lname[ 4 ] = '\0';
10b95b: c6 45 ef 00 movb $0x0,-0x11(%ebp)
10b95f: 8d 7d eb lea -0x15(%ebp),%edi
10b962: 8b 75 10 mov 0x10(%ebp),%esi
10b965: 31 db xor %ebx,%ebx
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10b967: 8b 45 0c mov 0xc(%ebp),%eax
10b96a: 48 dec %eax
10b96b: 89 45 e0 mov %eax,-0x20(%ebp)
10b96e: eb 14 jmp 10b984 <_Objects_Get_name_as_string+0xb0>
*d = (isprint(*s)) ? *s : '*';
10b970: 0f be d1 movsbl %cl,%edx
10b973: a1 e0 e6 11 00 mov 0x11e6e0,%eax
10b978: f6 04 10 97 testb $0x97,(%eax,%edx,1)
10b97c: 75 02 jne 10b980 <_Objects_Get_name_as_string+0xac>
10b97e: b1 2a mov $0x2a,%cl
10b980: 88 0e mov %cl,(%esi)
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
10b982: 43 inc %ebx
10b983: 46 inc %esi
10b984: 3b 5d e0 cmp -0x20(%ebp),%ebx
10b987: 73 07 jae 10b990 <_Objects_Get_name_as_string+0xbc>
10b989: 8a 0c 1f mov (%edi,%ebx,1),%cl
10b98c: 84 c9 test %cl,%cl
10b98e: 75 e0 jne 10b970 <_Objects_Get_name_as_string+0x9c>
*d = (isprint(*s)) ? *s : '*';
}
}
*d = '\0';
10b990: c6 06 00 movb $0x0,(%esi)
_Thread_Enable_dispatch();
10b993: e8 d4 07 00 00 call 10c16c <_Thread_Enable_dispatch>
10b998: eb 07 jmp 10b9a1 <_Objects_Get_name_as_string+0xcd>
return name;
10b99a: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp)
}
return NULL; /* unreachable path */
}
10b9a1: 8b 45 10 mov 0x10(%ebp),%eax
10b9a4: 8d 65 f4 lea -0xc(%ebp),%esp
10b9a7: 5b pop %ebx
10b9a8: 5e pop %esi
10b9a9: 5f pop %edi
10b9aa: c9 leave
10b9ab: c3 ret
00114f1c <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
114f1c: 55 push %ebp
114f1d: 89 e5 mov %esp,%ebp
114f1f: 53 push %ebx
114f20: 8b 4d 08 mov 0x8(%ebp),%ecx
114f23: 8b 5d 10 mov 0x10(%ebp),%ebx
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
114f26: ba 01 00 00 00 mov $0x1,%edx
114f2b: 2b 51 08 sub 0x8(%ecx),%edx
114f2e: 03 55 0c add 0xc(%ebp),%edx
if ( information->maximum >= index ) {
114f31: 0f b7 41 10 movzwl 0x10(%ecx),%eax
114f35: 39 d0 cmp %edx,%eax
114f37: 72 12 jb 114f4b <_Objects_Get_no_protection+0x2f>
if ( (the_object = information->local_table[ index ]) != NULL ) {
114f39: 8b 41 1c mov 0x1c(%ecx),%eax
114f3c: 8b 04 90 mov (%eax,%edx,4),%eax
114f3f: 85 c0 test %eax,%eax
114f41: 74 08 je 114f4b <_Objects_Get_no_protection+0x2f><== NEVER TAKEN
*location = OBJECTS_LOCAL;
114f43: c7 03 00 00 00 00 movl $0x0,(%ebx)
114f49: eb 08 jmp 114f53 <_Objects_Get_no_protection+0x37>
/*
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
*location = OBJECTS_ERROR;
114f4b: c7 03 01 00 00 00 movl $0x1,(%ebx)
114f51: 31 c0 xor %eax,%eax
return NULL;
}
114f53: 5b pop %ebx
114f54: c9 leave
114f55: c3 ret
0010b5cc <_Objects_Id_to_name>:
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
10b5cc: 55 push %ebp
10b5cd: 89 e5 mov %esp,%ebp
10b5cf: 53 push %ebx
10b5d0: 83 ec 14 sub $0x14,%esp
10b5d3: 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 )
10b5d6: b8 01 00 00 00 mov $0x1,%eax
10b5db: 85 db test %ebx,%ebx
10b5dd: 74 59 je 10b638 <_Objects_Id_to_name+0x6c><== NEVER TAKEN
return OBJECTS_INVALID_NAME;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10b5df: 8b 4d 08 mov 0x8(%ebp),%ecx
10b5e2: 85 c9 test %ecx,%ecx
10b5e4: 75 08 jne 10b5ee <_Objects_Id_to_name+0x22>
10b5e6: a1 8c f5 11 00 mov 0x11f58c,%eax
10b5eb: 8b 48 08 mov 0x8(%eax),%ecx
uint32_t page_size
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
10b5ee: 89 ca mov %ecx,%edx
10b5f0: c1 ea 18 shr $0x18,%edx
10b5f3: 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.
10b5f6: 8d 42 ff lea -0x1(%edx),%eax
10b5f9: 83 f8 03 cmp $0x3,%eax
10b5fc: 77 35 ja 10b633 <_Objects_Id_to_name+0x67>
10b5fe: eb 3d jmp 10b63d <_Objects_Id_to_name+0x71>
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
10b600: 89 c8 mov %ecx,%eax
10b602: c1 e8 1b shr $0x1b,%eax
10b605: 8b 14 82 mov (%edx,%eax,4),%edx
if ( !information )
10b608: 85 d2 test %edx,%edx
10b60a: 74 27 je 10b633 <_Objects_Id_to_name+0x67><== NEVER TAKEN
return OBJECTS_INVALID_ID;
if ( information->is_string )
10b60c: 80 7a 38 00 cmpb $0x0,0x38(%edx)
10b610: 75 21 jne 10b633 <_Objects_Id_to_name+0x67><== NEVER TAKEN
return OBJECTS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &ignored_location );
10b612: 50 push %eax
10b613: 8d 45 f8 lea -0x8(%ebp),%eax
10b616: 50 push %eax
10b617: 51 push %ecx
10b618: 52 push %edx
10b619: e8 56 ff ff ff call 10b574 <_Objects_Get>
if ( !the_object )
10b61e: 83 c4 10 add $0x10,%esp
10b621: 85 c0 test %eax,%eax
10b623: 74 0e je 10b633 <_Objects_Id_to_name+0x67>
return OBJECTS_INVALID_ID;
*name = the_object->name;
10b625: 8b 40 0c mov 0xc(%eax),%eax
10b628: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10b62a: e8 85 07 00 00 call 10bdb4 <_Thread_Enable_dispatch>
10b62f: 31 c0 xor %eax,%eax
10b631: eb 05 jmp 10b638 <_Objects_Id_to_name+0x6c>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10b633: b8 03 00 00 00 mov $0x3,%eax
}
10b638: 8b 5d fc mov -0x4(%ebp),%ebx
10b63b: c9 leave
10b63c: c3 ret
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
10b63d: 8b 14 95 a0 f4 11 00 mov 0x11f4a0(,%edx,4),%edx
10b644: 85 d2 test %edx,%edx
10b646: 75 b8 jne 10b600 <_Objects_Id_to_name+0x34><== ALWAYS TAKEN
10b648: eb e9 jmp 10b633 <_Objects_Id_to_name+0x67><== NOT EXECUTED
0010a684 <_Objects_Initialize_information>:
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
10a684: 55 push %ebp
10a685: 89 e5 mov %esp,%ebp
10a687: 57 push %edi
10a688: 56 push %esi
10a689: 53 push %ebx
10a68a: 8b 7d 08 mov 0x8(%ebp),%edi
10a68d: 8b 55 0c mov 0xc(%ebp),%edx
10a690: 8b 5d 10 mov 0x10(%ebp),%ebx
10a693: 8b 75 20 mov 0x20(%ebp),%esi
10a696: 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;
10a69a: 89 17 mov %edx,(%edi)
information->the_class = the_class;
10a69c: 66 89 5f 04 mov %bx,0x4(%edi)
information->is_string = is_string;
10a6a0: 8b 45 1c mov 0x1c(%ebp),%eax
10a6a3: 88 47 38 mov %al,0x38(%edi)
information->local_table = 0;
information->inactive_per_block = 0;
10a6a6: c7 47 30 00 00 00 00 movl $0x0,0x30(%edi)
information->object_blocks = 0;
10a6ad: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi)
information->inactive = 0;
10a6b4: 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;
10a6ba: 8b 04 95 b4 ca 11 00 mov 0x11cab4(,%edx,4),%eax
10a6c1: 89 3c 98 mov %edi,(%eax,%ebx,4)
/*
* Set the size of the object
*/
information->size = size;
10a6c4: 89 4f 18 mov %ecx,0x18(%edi)
/*
* Are we operating in unlimited, or auto-extend mode
*/
information->auto_extend =
10a6c7: 8b 45 14 mov 0x14(%ebp),%eax
10a6ca: c1 e8 1f shr $0x1f,%eax
10a6cd: 88 47 12 mov %al,0x12(%edi)
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE;
maximum &= ~OBJECTS_UNLIMITED_OBJECTS;
10a6d0: 8b 4d 14 mov 0x14(%ebp),%ecx
10a6d3: 81 e1 ff ff ff 7f and $0x7fffffff,%ecx
/*
* The allocation unit is the maximum value
*/
information->allocation_size = maximum;
10a6d9: 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;
10a6dc: c7 47 1c 98 c8 11 00 movl $0x11c898,0x1c(%edi)
*/
if ( maximum == 0 ) minimum_index = 0;
else minimum_index = 1;
information->minimum_id =
10a6e3: c1 e2 18 shl $0x18,%edx
10a6e6: 81 ca 00 00 01 00 or $0x10000,%edx
10a6ec: c1 e3 1b shl $0x1b,%ebx
10a6ef: 09 da or %ebx,%edx
10a6f1: 31 c0 xor %eax,%eax
10a6f3: 85 c9 test %ecx,%ecx
10a6f5: 0f 95 c0 setne %al
10a6f8: 09 c2 or %eax,%edx
10a6fa: 89 57 08 mov %edx,0x8(%edi)
* Calculate the maximum name length
*/
name_length = maximum_name_length;
if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
10a6fd: 89 f0 mov %esi,%eax
10a6ff: f7 c6 03 00 00 00 test $0x3,%esi
10a705: 74 06 je 10a70d <_Objects_Initialize_information+0x89><== ALWAYS TAKEN
name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
10a707: 8d 46 04 lea 0x4(%esi),%eax <== NOT EXECUTED
10a70a: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED
~(OBJECTS_NAME_ALIGNMENT-1);
information->name_length = name_length;
10a70d: 66 89 47 3a mov %ax,0x3a(%edi)
10a711: 8d 47 24 lea 0x24(%edi),%eax
10a714: 89 47 20 mov %eax,0x20(%edi)
10a717: c7 47 24 00 00 00 00 movl $0x0,0x24(%edi)
10a71e: 8d 47 20 lea 0x20(%edi),%eax
10a721: 89 47 28 mov %eax,0x28(%edi)
/*
* Initialize objects .. if there are any
*/
if ( maximum ) {
10a724: 85 c9 test %ecx,%ecx
10a726: 74 12 je 10a73a <_Objects_Initialize_information+0xb6>
/*
* Reset the maximum value. It will be updated when the information is
* extended.
*/
information->maximum = 0;
10a728: 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 );
10a72e: 89 7d 08 mov %edi,0x8(%ebp)
_Chain_Initialize_empty( &information->global_table[ index ] );
}
else
information->global_table = NULL;
#endif
}
10a731: 5b pop %ebx
10a732: 5e pop %esi
10a733: 5f pop %edi
10a734: 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 );
10a735: e9 46 fb ff ff jmp 10a280 <_Objects_Extend_information>
_Chain_Initialize_empty( &information->global_table[ index ] );
}
else
information->global_table = NULL;
#endif
}
10a73a: 5b pop %ebx
10a73b: 5e pop %esi
10a73c: 5f pop %edi
10a73d: c9 leave
10a73e: c3 ret
0010a774 <_Objects_Name_to_id_u32>:
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
10a774: 55 push %ebp
10a775: 89 e5 mov %esp,%ebp
10a777: 57 push %edi
10a778: 56 push %esi
10a779: 53 push %ebx
10a77a: 8b 7d 08 mov 0x8(%ebp),%edi
10a77d: 8b 5d 0c mov 0xc(%ebp),%ebx
10a780: 8b 55 10 mov 0x10(%ebp),%edx
10a783: 8b 75 14 mov 0x14(%ebp),%esi
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == FALSE */
if ( !id )
10a786: b8 02 00 00 00 mov $0x2,%eax
10a78b: 85 f6 test %esi,%esi
10a78d: 74 49 je 10a7d8 <_Objects_Name_to_id_u32+0x64>
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
10a78f: 85 db test %ebx,%ebx
10a791: 74 40 je 10a7d3 <_Objects_Name_to_id_u32+0x5f>
return OBJECTS_INVALID_NAME;
search_local_node = FALSE;
if ( information->maximum != 0 &&
10a793: 8b 47 10 mov 0x10(%edi),%eax
10a796: 66 85 c0 test %ax,%ax
10a799: 74 38 je 10a7d3 <_Objects_Name_to_id_u32+0x5f><== NEVER TAKEN
10a79b: 85 d2 test %edx,%edx
10a79d: 74 28 je 10a7c7 <_Objects_Name_to_id_u32+0x53>
10a79f: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx
10a7a5: 74 20 je 10a7c7 <_Objects_Name_to_id_u32+0x53>
10a7a7: 4a dec %edx
10a7a8: 75 29 jne 10a7d3 <_Objects_Name_to_id_u32+0x5f>
10a7aa: eb 1b jmp 10a7c7 <_Objects_Name_to_id_u32+0x53>
if ( search_local_node ) {
name_length = information->name_length;
for ( index = 1; index <= information->maximum; index++ ) {
the_object = information->local_table[ index ];
10a7ac: 8b 47 1c mov 0x1c(%edi),%eax
10a7af: 8b 04 90 mov (%eax,%edx,4),%eax
if ( !the_object )
10a7b2: 85 c0 test %eax,%eax
10a7b4: 74 0e je 10a7c4 <_Objects_Name_to_id_u32+0x50>
continue;
if ( name == the_object->name.name_u32 ) {
10a7b6: 3b 58 0c cmp 0xc(%eax),%ebx
10a7b9: 75 09 jne 10a7c4 <_Objects_Name_to_id_u32+0x50>
*id = the_object->id;
10a7bb: 8b 40 08 mov 0x8(%eax),%eax
10a7be: 89 06 mov %eax,(%esi)
10a7c0: 31 c0 xor %eax,%eax
10a7c2: eb 14 jmp 10a7d8 <_Objects_Name_to_id_u32+0x64>
search_local_node = TRUE;
if ( search_local_node ) {
name_length = information->name_length;
for ( index = 1; index <= information->maximum; index++ ) {
10a7c4: 42 inc %edx
10a7c5: eb 08 jmp 10a7cf <_Objects_Name_to_id_u32+0x5b>
10a7c7: ba 01 00 00 00 mov $0x1,%edx
10a7cc: 0f b7 c8 movzwl %ax,%ecx
10a7cf: 39 ca cmp %ecx,%edx
10a7d1: 76 d9 jbe 10a7ac <_Objects_Name_to_id_u32+0x38>
10a7d3: 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
}
10a7d8: 5b pop %ebx
10a7d9: 5e pop %esi
10a7da: 5f pop %edi
10a7db: c9 leave
10a7dc: c3 ret
0010a740 <_Objects_Namespace_remove>:
void _Objects_Namespace_remove(
Objects_Information *information,
Objects_Control *the_object
)
{
10a740: 55 push %ebp
10a741: 89 e5 mov %esp,%ebp
10a743: 53 push %ebx
10a744: 83 ec 04 sub $0x4,%esp
10a747: 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 )
10a74a: 8b 45 08 mov 0x8(%ebp),%eax
10a74d: 80 78 38 00 cmpb $0x0,0x38(%eax)
10a751: 74 13 je 10a766 <_Objects_Namespace_remove+0x26><== ALWAYS TAKEN
10a753: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED
10a756: 85 c0 test %eax,%eax <== NOT EXECUTED
10a758: 74 0c je 10a766 <_Objects_Namespace_remove+0x26><== NOT EXECUTED
_Workspace_Free( (void *)the_object->name.name_p );
10a75a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a75d: 50 push %eax <== NOT EXECUTED
10a75e: e8 11 16 00 00 call 10bd74 <_Workspace_Free> <== NOT EXECUTED
10a763: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
/*
* Clear out either format.
*/
the_object->name.name_p = NULL;
the_object->name.name_u32 = 0;
10a766: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
}
10a76d: 8b 5d fc mov -0x4(%ebp),%ebx
10a770: c9 leave
10a771: c3 ret
0010bfb8 <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
10bfb8: 55 push %ebp
10bfb9: 89 e5 mov %esp,%ebp
10bfbb: 57 push %edi
10bfbc: 56 push %esi
10bfbd: 53 push %ebx
10bfbe: 83 ec 14 sub $0x14,%esp
10bfc1: 8b 5d 08 mov 0x8(%ebp),%ebx
10bfc4: 8b 7d 10 mov 0x10(%ebp),%edi
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length ) + 1;
10bfc7: 0f b7 43 3a movzwl 0x3a(%ebx),%eax
10bfcb: 50 push %eax
10bfcc: 57 push %edi
10bfcd: e8 d2 56 00 00 call 1116a4 <strnlen>
10bfd2: 89 45 f0 mov %eax,-0x10(%ebp)
10bfd5: 89 c6 mov %eax,%esi
10bfd7: 46 inc %esi
if ( information->is_string ) {
10bfd8: 83 c4 10 add $0x10,%esp
10bfdb: 80 7b 38 00 cmpb $0x0,0x38(%ebx)
10bfdf: 74 56 je 10c037 <_Objects_Set_name+0x7f>
char *d;
d = _Workspace_Allocate( length );
10bfe1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10bfe4: 56 push %esi <== NOT EXECUTED
10bfe5: e8 4f 16 00 00 call 10d639 <_Workspace_Allocate> <== NOT EXECUTED
10bfea: 89 c3 mov %eax,%ebx <== NOT EXECUTED
if ( !d )
10bfec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10bfef: 31 c0 xor %eax,%eax <== NOT EXECUTED
10bff1: 85 db test %ebx,%ebx <== NOT EXECUTED
10bff3: 0f 84 81 00 00 00 je 10c07a <_Objects_Set_name+0xc2><== NOT EXECUTED
return FALSE;
if ( the_object->name.name_p ) {
10bff9: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
10bffc: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED
10bfff: 85 c0 test %eax,%eax <== NOT EXECUTED
10c001: 74 16 je 10c019 <_Objects_Set_name+0x61><== NOT EXECUTED
_Workspace_Free( (void *)the_object->name.name_p );
10c003: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c006: 50 push %eax <== NOT EXECUTED
10c007: e8 18 16 00 00 call 10d624 <_Workspace_Free> <== NOT EXECUTED
the_object->name.name_p = NULL;
10c00c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10c00f: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) <== NOT EXECUTED
10c016: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
strncpy( d, name, length );
10c019: 50 push %eax <== NOT EXECUTED
10c01a: 56 push %esi <== NOT EXECUTED
10c01b: 57 push %edi <== NOT EXECUTED
10c01c: 53 push %ebx <== NOT EXECUTED
10c01d: e8 fa 55 00 00 call 11161c <strncpy> <== NOT EXECUTED
d[ length ] = '\0';
10c022: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED
10c025: c6 44 13 01 00 movb $0x0,0x1(%ebx,%edx,1) <== NOT EXECUTED
the_object->name.name_p = d;
10c02a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10c02d: 89 58 0c mov %ebx,0xc(%eax) <== NOT EXECUTED
10c030: b0 01 mov $0x1,%al <== NOT EXECUTED
10c032: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10c035: eb 43 jmp 10c07a <_Objects_Set_name+0xc2><== NOT EXECUTED
} else {
the_object->name.name_u32 = _Objects_Build_name(
10c037: b8 00 00 00 20 mov $0x20000000,%eax
10c03c: 85 f6 test %esi,%esi
10c03e: 74 4e je 10c08e <_Objects_Set_name+0xd6><== NEVER TAKEN
10c040: 0f be 07 movsbl (%edi),%eax
10c043: c1 e0 18 shl $0x18,%eax
10c046: 83 fe 01 cmp $0x1,%esi
10c049: 74 43 je 10c08e <_Objects_Set_name+0xd6>
10c04b: 0f be 5f 01 movsbl 0x1(%edi),%ebx
10c04f: c1 e3 10 shl $0x10,%ebx
10c052: 83 fe 02 cmp $0x2,%esi
10c055: 76 2b jbe 10c082 <_Objects_Set_name+0xca>
10c057: 0f be 57 02 movsbl 0x2(%edi),%edx
10c05b: c1 e2 08 shl $0x8,%edx
10c05e: b9 20 00 00 00 mov $0x20,%ecx
10c063: 83 fe 03 cmp $0x3,%esi
10c066: 76 04 jbe 10c06c <_Objects_Set_name+0xb4>
10c068: 0f be 4f 03 movsbl 0x3(%edi),%ecx
10c06c: 09 d8 or %ebx,%eax
10c06e: 09 d0 or %edx,%eax
10c070: 09 c8 or %ecx,%eax
10c072: 8b 55 0c mov 0xc(%ebp),%edx
10c075: 89 42 0c mov %eax,0xc(%edx)
10c078: b0 01 mov $0x1,%al
);
}
return TRUE;
}
10c07a: 8d 65 f4 lea -0xc(%ebp),%esp
10c07d: 5b pop %ebx
10c07e: 5e pop %esi
10c07f: 5f pop %edi
10c080: c9 leave
10c081: c3 ret
strncpy( d, name, length );
d[ length ] = '\0';
the_object->name.name_p = d;
} else {
the_object->name.name_u32 = _Objects_Build_name(
10c082: b9 20 00 00 00 mov $0x20,%ecx
10c087: ba 00 20 00 00 mov $0x2000,%edx
10c08c: eb de jmp 10c06c <_Objects_Set_name+0xb4>
10c08e: bb 00 00 20 00 mov $0x200000,%ebx
10c093: eb ed jmp 10c082 <_Objects_Set_name+0xca>
0010a7e8 <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
10a7e8: 55 push %ebp
10a7e9: 89 e5 mov %esp,%ebp
10a7eb: 57 push %edi
10a7ec: 56 push %esi
10a7ed: 53 push %ebx
10a7ee: 83 ec 0c sub $0xc,%esp
10a7f1: 8b 75 08 mov 0x8(%ebp),%esi
* alignments are possible.
* Returns pointer to the start of the memory block if success, NULL if
* failure.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
10a7f4: 8b 46 08 mov 0x8(%esi),%eax
10a7f7: 0f b7 f8 movzwl %ax,%edi
/*
* Search the list to find block or chunnk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
block_count = ( information->maximum - index_base ) / information->allocation_size;
10a7fa: 8b 4e 14 mov 0x14(%esi),%ecx
10a7fd: 0f b7 46 10 movzwl 0x10(%esi),%eax
10a801: 29 f8 sub %edi,%eax
10a803: 31 d2 xor %edx,%edx
10a805: f7 f1 div %ecx
10a807: 89 c3 mov %eax,%ebx
10a809: 31 d2 xor %edx,%edx
10a80b: eb 7c jmp 10a889 <_Objects_Shrink_information+0xa1>
for ( block = 0; block < block_count; block++ ) {
10a80d: 8d 04 95 00 00 00 00 lea 0x0(,%edx,4),%eax
10a814: 89 45 f0 mov %eax,-0x10(%ebp)
if ( information->inactive_per_block[ block ] == information->allocation_size ) {
10a817: 8b 46 30 mov 0x30(%esi),%eax
10a81a: 39 0c 90 cmp %ecx,(%eax,%edx,4)
10a81d: 75 67 jne 10a886 <_Objects_Shrink_information+0x9e>
/*
* XXX - Not to sure how to use a chain where you need to iterate and
* and remove elements.
*/
the_object = (Objects_Control *) information->Inactive.first;
10a81f: 8b 56 20 mov 0x20(%esi),%edx
10a822: 8b 42 08 mov 0x8(%edx),%eax
10a825: 0f b7 c8 movzwl %ax,%ecx
*/
do {
index = _Objects_Get_index( the_object->id );
if ((index >= index_base) &&
10a828: 39 f9 cmp %edi,%ecx
10a82a: 72 1b jb 10a847 <_Objects_Shrink_information+0x5f>
10a82c: 89 f8 mov %edi,%eax
10a82e: 03 46 14 add 0x14(%esi),%eax
10a831: 39 c1 cmp %eax,%ecx
10a833: 73 12 jae 10a847 <_Objects_Shrink_information+0x5f>
* @param[in] start_address is the starting address of the user block
* to free
* @return TRUE if successfully freed, FALSE otherwise
*/
bool _Protected_heap_Free(
Heap_Control *the_heap,
10a835: 8b 1a mov (%edx),%ebx
if ( !_Chain_Is_last( &the_object->Node ) )
the_object = (Objects_Control *) the_object->Node.next;
else
the_object = NULL;
_Chain_Extract( &extract_me->Node );
10a837: 83 ec 0c sub $0xc,%esp
10a83a: 52 push %edx
10a83b: e8 30 2e 00 00 call 10d670 <_Chain_Extract>
10a840: 89 da mov %ebx,%edx
10a842: 83 c4 10 add $0x10,%esp
10a845: eb 02 jmp 10a849 <_Objects_Shrink_information+0x61>
}
else {
the_object = (Objects_Control *) the_object->Node.next;
10a847: 8b 12 mov (%edx),%edx
}
}
while ( the_object && !_Chain_Is_last( &the_object->Node ) );
10a849: 85 d2 test %edx,%edx
10a84b: 74 05 je 10a852 <_Objects_Shrink_information+0x6a><== NEVER TAKEN
10a84d: 83 3a 00 cmpl $0x0,(%edx)
10a850: 75 d0 jne 10a822 <_Objects_Shrink_information+0x3a>
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
10a852: 83 ec 0c sub $0xc,%esp
10a855: 8b 46 34 mov 0x34(%esi),%eax
10a858: 8b 55 f0 mov -0x10(%ebp),%edx
10a85b: ff 34 10 pushl (%eax,%edx,1)
10a85e: e8 11 15 00 00 call 10bd74 <_Workspace_Free>
information->object_blocks[ block ] = NULL;
10a863: 8b 46 34 mov 0x34(%esi),%eax
10a866: 8b 55 f0 mov -0x10(%ebp),%edx
10a869: c7 04 10 00 00 00 00 movl $0x0,(%eax,%edx,1)
information->inactive_per_block[ block ] = 0;
10a870: 8b 46 30 mov 0x30(%esi),%eax
10a873: c7 04 10 00 00 00 00 movl $0x0,(%eax,%edx,1)
information->inactive -= information->allocation_size;
10a87a: 8b 46 14 mov 0x14(%esi),%eax
10a87d: 66 29 46 2c sub %ax,0x2c(%esi)
10a881: 83 c4 10 add $0x10,%esp
10a884: eb 07 jmp 10a88d <_Objects_Shrink_information+0xa5>
return;
}
index_base += information->allocation_size;
10a886: 01 cf add %ecx,%edi
*/
index_base = _Objects_Get_index( information->minimum_id );
block_count = ( information->maximum - index_base ) / information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
10a888: 42 inc %edx
10a889: 39 da cmp %ebx,%edx
10a88b: 72 80 jb 10a80d <_Objects_Shrink_information+0x25>
return;
}
index_base += information->allocation_size;
}
}
10a88d: 8d 65 f4 lea -0xc(%ebp),%esp
10a890: 5b pop %ebx
10a891: 5e pop %esi
10a892: 5f pop %edi
10a893: c9 leave
10a894: c3 ret
0010c6e8 <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
10c6e8: 55 push %ebp
10c6e9: 89 e5 mov %esp,%ebp
10c6eb: 56 push %esi
10c6ec: 53 push %ebx
10c6ed: 8b 75 08 mov 0x8(%ebp),%esi
10c6f0: 8b 5d 0c mov 0xc(%ebp),%ebx
Heap_Get_information_status status;
if ( !the_heap )
10c6f3: 85 f6 test %esi,%esi
10c6f5: 74 33 je 10c72a <_Protected_heap_Get_information+0x42><== NEVER TAKEN
return false;
if ( !the_info )
10c6f7: 85 db test %ebx,%ebx
10c6f9: 74 2f je 10c72a <_Protected_heap_Get_information+0x42><== NEVER TAKEN
return false;
_RTEMS_Lock_allocator();
10c6fb: 83 ec 0c sub $0xc,%esp
10c6fe: ff 35 a4 1a 12 00 pushl 0x121aa4
10c704: e8 3f ea ff ff call 10b148 <_API_Mutex_Lock>
status = _Heap_Get_information( the_heap, the_info );
10c709: 5a pop %edx
10c70a: 59 pop %ecx
10c70b: 53 push %ebx
10c70c: 56 push %esi
10c70d: e8 3a 32 00 00 call 10f94c <_Heap_Get_information>
10c712: 89 c3 mov %eax,%ebx
_RTEMS_Unlock_allocator();
10c714: 58 pop %eax
10c715: ff 35 a4 1a 12 00 pushl 0x121aa4
10c71b: e8 70 ea ff ff call 10b190 <_API_Mutex_Unlock>
if ( status == HEAP_GET_INFORMATION_SUCCESSFUL )
10c720: 83 c4 10 add $0x10,%esp
10c723: 85 db test %ebx,%ebx
10c725: 0f 94 c0 sete %al
10c728: eb 02 jmp 10c72c <_Protected_heap_Get_information+0x44>
10c72a: 31 c0 xor %eax,%eax
return true;
return false;
}
10c72c: 8d 65 f8 lea -0x8(%ebp),%esp
10c72f: 5b pop %ebx
10c730: 5e pop %esi
10c731: c9 leave
10c732: c3 ret
0010d51f <_RTEMS_tasks_Create_extension>:
bool _RTEMS_tasks_Create_extension(
Thread_Control *executing,
Thread_Control *created
)
{
10d51f: 55 push %ebp
10d520: 89 e5 mov %esp,%ebp
10d522: 53 push %ebx
10d523: 83 ec 10 sub $0x10,%esp
10d526: 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() )
10d529: a1 78 cb 11 00 mov 0x11cb78,%eax
10d52e: 8b 40 40 mov 0x40(%eax),%eax
10d531: 80 78 04 01 cmpb $0x1,0x4(%eax)
10d535: 19 c0 sbb %eax,%eax
10d537: 83 e0 c0 and $0xffffffc0,%eax
10d53a: 83 c0 60 add $0x60,%eax
to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));
api = _Workspace_Allocate( to_allocate );
10d53d: 50 push %eax
10d53e: e8 46 e8 ff ff call 10bd89 <_Workspace_Allocate>
10d543: 89 c2 mov %eax,%edx
if ( !api )
10d545: 83 c4 10 add $0x10,%esp
10d548: 31 c0 xor %eax,%eax
10d54a: 85 d2 test %edx,%edx
10d54c: 74 5d je 10d5ab <_RTEMS_tasks_Create_extension+0x8c><== NEVER TAKEN
return false;
created->API_Extensions[ THREAD_API_RTEMS ] = api;
10d54e: 89 93 f4 00 00 00 mov %edx,0xf4(%ebx)
api->pending_events = EVENT_SETS_NONE_PENDING;
10d554: c7 02 00 00 00 00 movl $0x0,(%edx)
#endif
/**
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
10d55a: c6 42 08 01 movb $0x1,0x8(%edx)
* @a page_size byte units. If @a page_size is 0 or is not multiple of
10d55e: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
10d565: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx)
*
10d56c: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx)
* @param[in] the_heap is the heap to operate upon
10d573: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx)
* @param[in] starting_address is the starting address of the memory for
10d57a: c7 42 1c 00 00 00 00 movl $0x0,0x1c(%edx)
_ASR_Initialize( &api->Signal );
created->task_variables = NULL;
10d581: c7 83 04 01 00 00 00 movl $0x0,0x104(%ebx)
10d588: 00 00 00
if ( rtems_configuration_get_notepads_enabled() ) {
10d58b: a1 78 cb 11 00 mov 0x11cb78,%eax
10d590: 8b 40 40 mov 0x40(%eax),%eax
10d593: 80 78 04 00 cmpb $0x0,0x4(%eax)
10d597: 74 10 je 10d5a9 <_RTEMS_tasks_Create_extension+0x8a>
10d599: 31 c0 xor %eax,%eax
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
api->Notepads[i] = 0;
10d59b: c7 44 82 20 00 00 00 movl $0x0,0x20(%edx,%eax,4)
10d5a2: 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++)
10d5a3: 40 inc %eax
10d5a4: 83 f8 10 cmp $0x10,%eax
10d5a7: 75 f2 jne 10d59b <_RTEMS_tasks_Create_extension+0x7c>
10d5a9: b0 01 mov $0x1,%al
api->Notepads[i] = 0;
}
return true;
}
10d5ab: 8b 5d fc mov -0x4(%ebp),%ebx
10d5ae: c9 leave
10d5af: c3 ret
001094e4 <_RTEMS_tasks_Initialize_user_tasks_body>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
1094e4: 55 push %ebp
1094e5: 89 e5 mov %esp,%ebp
1094e7: 57 push %edi
1094e8: 56 push %esi
1094e9: 53 push %ebx
1094ea: 83 ec 1c sub $0x1c,%esp
rtems_status_code return_value;
rtems_initialization_tasks_table *user_tasks;
rtems_api_configuration_table *api_configuration;
api_configuration = _Configuration_Table->RTEMS_api_configuration;
1094ed: a1 78 cb 11 00 mov 0x11cb78,%eax
1094f2: 8b 40 40 mov 0x40(%eax),%eax
/*
* NOTE: This is slightly different from the Ada implementation.
*/
user_tasks = api_configuration->User_initialization_tasks_table;
1094f5: 8b 50 2c mov 0x2c(%eax),%edx
maximum = api_configuration->number_of_initialization_tasks;
1094f8: 8b 78 28 mov 0x28(%eax),%edi
if ( !user_tasks || maximum == 0 )
1094fb: 85 d2 test %edx,%edx
1094fd: 74 53 je 109552 <_RTEMS_tasks_Initialize_user_tasks_body+0x6e><== NEVER TAKEN
1094ff: 85 ff test %edi,%edi
109501: 74 4f je 109552 <_RTEMS_tasks_Initialize_user_tasks_body+0x6e><== NEVER TAKEN
return;
109503: 89 d3 mov %edx,%ebx
109505: 31 f6 xor %esi,%esi
109507: eb 45 jmp 10954e <_RTEMS_tasks_Initialize_user_tasks_body+0x6a>
for ( index=0 ; index < maximum ; index++ ) {
return_value = rtems_task_create(
109509: 50 push %eax
10950a: 50 push %eax
10950b: 8d 45 f0 lea -0x10(%ebp),%eax
10950e: 50 push %eax
10950f: ff 73 0c pushl 0xc(%ebx)
109512: ff 73 14 pushl 0x14(%ebx)
109515: ff 73 04 pushl 0x4(%ebx)
109518: ff 73 08 pushl 0x8(%ebx)
10951b: ff 33 pushl (%ebx)
10951d: e8 ca fd ff ff call 1092ec <rtems_task_create>
user_tasks[ index ].mode_set,
user_tasks[ index ].attribute_set,
&id
);
if ( !rtems_is_status_successful( return_value ) )
109522: 83 c4 20 add $0x20,%esp
109525: 85 c0 test %eax,%eax
109527: 75 19 jne 109542 <_RTEMS_tasks_Initialize_user_tasks_body+0x5e>
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
return_value = rtems_task_start(
109529: 51 push %ecx
10952a: ff 73 18 pushl 0x18(%ebx)
10952d: ff 73 10 pushl 0x10(%ebx)
109530: ff 75 f0 pushl -0x10(%ebp)
109533: e8 24 00 00 00 call 10955c <rtems_task_start>
109538: 83 c3 1c add $0x1c,%ebx
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
10953b: 83 c4 10 add $0x10,%esp
10953e: 85 c0 test %eax,%eax
109540: 74 0b je 10954d <_RTEMS_tasks_Initialize_user_tasks_body+0x69>
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
109542: 52 push %edx
109543: 50 push %eax
109544: 6a 01 push $0x1
109546: 6a 01 push $0x1
109548: e8 07 0c 00 00 call 10a154 <_Internal_error_Occurred>
maximum = api_configuration->number_of_initialization_tasks;
if ( !user_tasks || maximum == 0 )
return;
for ( index=0 ; index < maximum ; index++ ) {
10954d: 46 inc %esi
10954e: 39 fe cmp %edi,%esi
109550: 72 b7 jb 109509 <_RTEMS_tasks_Initialize_user_tasks_body+0x25>
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
}
}
109552: 8d 65 f4 lea -0xc(%ebp),%esp
109555: 5b pop %ebx
109556: 5e pop %esi
109557: 5f pop %edi
109558: c9 leave
109559: c3 ret
0010d46c <_RTEMS_tasks_Post_switch_extension>:
*/
void _RTEMS_tasks_Post_switch_extension(
Thread_Control *executing
)
{
10d46c: 55 push %ebp
10d46d: 89 e5 mov %esp,%ebp
10d46f: 57 push %edi
10d470: 56 push %esi
10d471: 53 push %ebx
10d472: 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 ];
10d475: 8b 45 08 mov 0x8(%ebp),%eax
10d478: 8b b0 f4 00 00 00 mov 0xf4(%eax),%esi
if ( !api )
10d47e: 85 f6 test %esi,%esi
10d480: 74 45 je 10d4c7 <_RTEMS_tasks_Post_switch_extension+0x5b><== NEVER TAKEN
* Signal Processing
*/
asr = &api->Signal;
_ISR_Disable( level );
10d482: 9c pushf
10d483: fa cli
10d484: 58 pop %eax
signal_set = asr->signals_posted;
10d485: 8b 7e 14 mov 0x14(%esi),%edi
asr->signals_posted = 0;
10d488: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi)
_ISR_Enable( level );
10d48f: 50 push %eax
10d490: 9d popf
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
10d491: 85 ff test %edi,%edi
10d493: 74 32 je 10d4c7 <_RTEMS_tasks_Post_switch_extension+0x5b><== NEVER TAKEN
return;
asr->nest_level += 1;
10d495: ff 46 1c incl 0x1c(%esi)
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
10d498: 50 push %eax
10d499: 8d 5d f0 lea -0x10(%ebp),%ebx
10d49c: 53 push %ebx
10d49d: 68 ff ff 00 00 push $0xffff
10d4a2: ff 76 10 pushl 0x10(%esi)
10d4a5: e8 f6 0d 00 00 call 10e2a0 <rtems_task_mode>
(*asr->handler)( signal_set );
10d4aa: 89 3c 24 mov %edi,(%esp)
10d4ad: ff 56 0c call *0xc(%esi)
asr->nest_level -= 1;
10d4b0: ff 4e 1c decl 0x1c(%esi)
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
10d4b3: 83 c4 0c add $0xc,%esp
10d4b6: 53 push %ebx
10d4b7: 68 ff ff 00 00 push $0xffff
10d4bc: ff 75 f0 pushl -0x10(%ebp)
10d4bf: e8 dc 0d 00 00 call 10e2a0 <rtems_task_mode>
10d4c4: 83 c4 10 add $0x10,%esp
}
10d4c7: 8d 65 f4 lea -0xc(%ebp),%esp
10d4ca: 5b pop %ebx
10d4cb: 5e pop %esi
10d4cc: 5f pop %edi
10d4cd: c9 leave
10d4ce: c3 ret
0010a314 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
10a314: 55 push %ebp
10a315: 89 e5 mov %esp,%ebp
10a317: 53 push %ebx
10a318: 83 ec 18 sub $0x18,%esp
10a31b: 8d 45 f8 lea -0x8(%ebp),%eax
10a31e: 50 push %eax
10a31f: ff 75 08 pushl 0x8(%ebp)
10a322: 68 8c 04 12 00 push $0x12048c
10a327: e8 f8 19 00 00 call 10bd24 <_Objects_Get>
10a32c: 89 c3 mov %eax,%ebx
/*
* When we get here, the Timer is already off the chain so we do not
* have to worry about that -- hence no _Watchdog_Remove().
*/
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
10a32e: 83 c4 10 add $0x10,%esp
10a331: 83 7d f8 00 cmpl $0x0,-0x8(%ebp)
10a335: 75 64 jne 10a39b <_Rate_monotonic_Timeout+0x87><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
10a337: 8b 50 50 mov 0x50(%eax),%edx
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
10a33a: f6 42 11 40 testb $0x40,0x11(%edx)
10a33e: 74 18 je 10a358 <_Rate_monotonic_Timeout+0x44>
10a340: 8b 42 20 mov 0x20(%edx),%eax
10a343: 3b 43 08 cmp 0x8(%ebx),%eax
10a346: 75 10 jne 10a358 <_Rate_monotonic_Timeout+0x44><== NEVER TAKEN
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
10a348: 50 push %eax
10a349: 50 push %eax
10a34a: 68 f8 ff 03 10 push $0x1003fff8
10a34f: 52 push %edx
10a350: e8 0f 1e 00 00 call 10c164 <_Thread_Clear_state>
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
10a355: 59 pop %ecx
10a356: eb 10 jmp 10a368 <_Rate_monotonic_Timeout+0x54>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
10a358: 83 7b 38 01 cmpl $0x1,0x38(%ebx)
10a35c: 75 2b jne 10a389 <_Rate_monotonic_Timeout+0x75><== ALWAYS TAKEN
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
10a35e: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
10a365: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a368: 53 push %ebx
10a369: e8 6a fa ff ff call 109dd8 <_Rate_monotonic_Initiate_statistics>
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
Heap_Control *the_heap,
10a36e: 8b 43 4c mov 0x4c(%ebx),%eax
10a371: 89 43 1c mov %eax,0x1c(%ebx)
void *starting_address,
size_t *size
10a374: 58 pop %eax
10a375: 5a pop %edx
10a376: 8d 43 10 lea 0x10(%ebx),%eax
10a379: 50 push %eax
10a37a: 68 64 06 12 00 push $0x120664
10a37f: e8 bc 30 00 00 call 10d440 <_Watchdog_Insert>
10a384: 83 c4 10 add $0x10,%esp
10a387: eb 07 jmp 10a390 <_Rate_monotonic_Timeout+0x7c>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
10a389: c7 43 38 04 00 00 00 movl $0x4,0x38(%ebx)
10a390: a1 84 05 12 00 mov 0x120584,%eax
10a395: 48 dec %eax
10a396: a3 84 05 12 00 mov %eax,0x120584
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10a39b: 8b 5d fc mov -0x4(%ebp),%ebx
10a39e: c9 leave
10a39f: c3 ret
00109a64 <_TOD_Validate>:
*/
bool _TOD_Validate(
rtems_time_of_day *the_tod
)
{
109a64: 55 push %ebp
109a65: 89 e5 mov %esp,%ebp
109a67: 53 push %ebx
109a68: 83 ec 04 sub $0x4,%esp
109a6b: 8b 5d 08 mov 0x8(%ebp),%ebx
uint32_t days_in_month;
if ((!the_tod) ||
109a6e: 85 db test %ebx,%ebx
109a70: 74 5d je 109acf <_TOD_Validate+0x6b> <== NEVER TAKEN
109a72: b8 40 42 0f 00 mov $0xf4240,%eax
109a77: 31 d2 xor %edx,%edx
109a79: f7 35 38 86 12 00 divl 0x128638
109a7f: 39 43 18 cmp %eax,0x18(%ebx)
109a82: 73 4b jae 109acf <_TOD_Validate+0x6b>
109a84: 83 7b 14 3b cmpl $0x3b,0x14(%ebx)
109a88: 77 45 ja 109acf <_TOD_Validate+0x6b>
109a8a: 83 7b 10 3b cmpl $0x3b,0x10(%ebx)
109a8e: 77 3f ja 109acf <_TOD_Validate+0x6b>
109a90: 83 7b 0c 17 cmpl $0x17,0xc(%ebx)
109a94: 77 39 ja 109acf <_TOD_Validate+0x6b>
109a96: 8b 43 04 mov 0x4(%ebx),%eax
109a99: 85 c0 test %eax,%eax
109a9b: 74 32 je 109acf <_TOD_Validate+0x6b> <== NEVER TAKEN
109a9d: 83 f8 0c cmp $0xc,%eax
109aa0: 77 2d ja 109acf <_TOD_Validate+0x6b>
109aa2: 8b 0b mov (%ebx),%ecx
109aa4: 81 f9 c3 07 00 00 cmp $0x7c3,%ecx
109aaa: 76 23 jbe 109acf <_TOD_Validate+0x6b>
109aac: 8b 53 08 mov 0x8(%ebx),%edx
109aaf: 85 d2 test %edx,%edx
109ab1: 74 1c je 109acf <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
109ab3: 80 e1 03 and $0x3,%cl
109ab6: 75 09 jne 109ac1 <_TOD_Validate+0x5d>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
109ab8: 8b 04 85 24 99 11 00 mov 0x119924(,%eax,4),%eax
109abf: eb 07 jmp 109ac8 <_TOD_Validate+0x64>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
109ac1: 8b 04 85 f0 98 11 00 mov 0x1198f0(,%eax,4),%eax
109ac8: 39 c2 cmp %eax,%edx
109aca: 0f 96 c0 setbe %al
109acd: eb 02 jmp 109ad1 <_TOD_Validate+0x6d>
109acf: 31 c0 xor %eax,%eax
if ( the_tod->day > days_in_month )
return false;
return true;
}
109ad1: 5a pop %edx
109ad2: 5b pop %ebx
109ad3: c9 leave
109ad4: c3 ret
0010a94c <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
10a94c: 55 push %ebp
10a94d: 89 e5 mov %esp,%ebp
10a94f: 57 push %edi
10a950: 56 push %esi
10a951: 53 push %ebx
10a952: 83 ec 18 sub $0x18,%esp
10a955: 8b 5d 08 mov 0x8(%ebp),%ebx
10a958: 8b 75 0c mov 0xc(%ebp),%esi
10a95b: 8a 45 10 mov 0x10(%ebp),%al
10a95e: 88 45 f3 mov %al,-0xd(%ebp)
*/
/*
* Save original state
*/
original_state = the_thread->current_state;
10a961: 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 );
10a964: 53 push %ebx
10a965: e8 3e 0d 00 00 call 10b6a8 <_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 )
10a96a: 83 c4 10 add $0x10,%esp
10a96d: 39 73 14 cmp %esi,0x14(%ebx)
10a970: 74 0c je 10a97e <_Thread_Change_priority+0x32>
_Thread_Set_priority( the_thread, new_priority );
10a972: 50 push %eax
10a973: 50 push %eax
10a974: 56 push %esi
10a975: 53 push %ebx
10a976: e8 f9 0b 00 00 call 10b574 <_Thread_Set_priority>
10a97b: 83 c4 10 add $0x10,%esp
_ISR_Disable( level );
10a97e: 9c pushf
10a97f: fa cli
10a980: 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;
10a981: 8b 53 10 mov 0x10(%ebx),%edx
if ( state != STATES_TRANSIENT ) {
10a984: 83 fa 04 cmp $0x4,%edx
10a987: 74 30 je 10a9b9 <_Thread_Change_priority+0x6d>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
10a989: 83 e7 04 and $0x4,%edi
10a98c: 75 08 jne 10a996 <_Thread_Change_priority+0x4a><== NEVER TAKEN
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
10a98e: 89 d0 mov %edx,%eax
10a990: 83 e0 fb and $0xfffffffb,%eax
10a993: 89 43 10 mov %eax,0x10(%ebx)
_ISR_Enable( level );
10a996: 56 push %esi
10a997: 9d popf
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10a998: 81 e2 e0 be 03 00 and $0x3bee0,%edx
10a99e: 0f 84 c0 00 00 00 je 10aa64 <_Thread_Change_priority+0x118>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
10a9a4: 89 5d 0c mov %ebx,0xc(%ebp)
10a9a7: 8b 43 44 mov 0x44(%ebx),%eax
10a9aa: 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 );
}
10a9ad: 8d 65 f4 lea -0xc(%ebp),%esp
10a9b0: 5b pop %ebx
10a9b1: 5e pop %esi
10a9b2: 5f pop %edi
10a9b3: 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 );
10a9b4: e9 33 0b 00 00 jmp 10b4ec <_Thread_queue_Requeue>
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
10a9b9: 83 e7 04 and $0x4,%edi
10a9bc: 75 53 jne 10aa11 <_Thread_Change_priority+0xc5><== NEVER TAKEN
* Interrupts are STILL disabled.
* We now know the thread will be in the READY state when we remove
* the TRANSIENT state. So we have to place it on the appropriate
* Ready Queue with interrupts off.
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
10a9be: 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
10a9c5: 8b 93 90 00 00 00 mov 0x90(%ebx),%edx
10a9cb: 66 8b 83 96 00 00 00 mov 0x96(%ebx),%ax
10a9d2: 66 09 02 or %ax,(%edx)
* @return TRUE if successfully able to determine the size, FALSE otherwise
10a9d5: 66 a1 94 cb 11 00 mov 0x11cb94,%ax
10a9db: 0b 83 94 00 00 00 or 0x94(%ebx),%eax
10a9e1: 66 a3 94 cb 11 00 mov %ax,0x11cb94
_Priority_Add_to_bit_map( &the_thread->Priority_map );
if ( prepend_it )
10a9e7: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
10a9eb: 8b 93 8c 00 00 00 mov 0x8c(%ebx),%edx
10a9f1: 74 0e je 10aa01 <_Thread_Change_priority+0xb5>
10a9f3: 89 53 04 mov %edx,0x4(%ebx)
10a9f6: 8b 02 mov (%edx),%eax
10a9f8: 89 1a mov %ebx,(%edx)
10a9fa: 89 03 mov %eax,(%ebx)
10a9fc: 89 58 04 mov %ebx,0x4(%eax)
10a9ff: eb 10 jmp 10aa11 <_Thread_Change_priority+0xc5>
10aa01: 8d 42 04 lea 0x4(%edx),%eax
10aa04: 89 03 mov %eax,(%ebx)
10aa06: 8b 42 08 mov 0x8(%edx),%eax
10aa09: 89 5a 08 mov %ebx,0x8(%edx)
10aa0c: 89 18 mov %ebx,(%eax)
10aa0e: 89 43 04 mov %eax,0x4(%ebx)
_Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node );
else
_Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node );
}
_ISR_Flash( level );
10aa11: 56 push %esi
10aa12: 9d popf
10aa13: fa cli
void *starting_address,
size_t size
);
/**
* This routine returns the block of memory which begins
10aa14: 66 8b 0d 94 cb 11 00 mov 0x11cb94,%cx
10aa1b: 31 d2 xor %edx,%edx
10aa1d: 89 d0 mov %edx,%eax
10aa1f: 66 0f bc c1 bsf %cx,%ax
* at @a starting_address to @a the_heap. Any coalescing which is
10aa23: 0f b7 c0 movzwl %ax,%eax
10aa26: 66 8b 8c 00 0c cc 11 mov 0x11cc0c(%eax,%eax,1),%cx
10aa2d: 00
10aa2e: 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.
10aa32: c1 e0 04 shl $0x4,%eax
10aa35: 0f b7 d2 movzwl %dx,%edx
10aa38: 01 d0 add %edx,%eax
10aa3a: 6b c0 0c imul $0xc,%eax,%eax
10aa3d: 8b 15 a8 ca 11 00 mov 0x11caa8,%edx
10aa43: 8b 04 10 mov (%eax,%edx,1),%eax
10aa46: a3 6c cb 11 00 mov %eax,0x11cb6c
void *starting_address,
size_t size
);
/**
* This function attempts to allocate a block of @a size bytes from
10aa4b: 8b 15 a0 cb 11 00 mov 0x11cba0,%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() &&
10aa51: 39 c2 cmp %eax,%edx
10aa53: 74 0d je 10aa62 <_Thread_Change_priority+0x116>
10aa55: 80 7a 76 00 cmpb $0x0,0x76(%edx)
10aa59: 74 07 je 10aa62 <_Thread_Change_priority+0x116><== NEVER TAKEN
_Thread_Executing->is_preemptible )
_Context_Switch_necessary = TRUE;
10aa5b: c6 05 b0 cb 11 00 01 movb $0x1,0x11cbb0
_ISR_Enable( level );
10aa62: 56 push %esi
10aa63: 9d popf
}
10aa64: 8d 65 f4 lea -0xc(%ebp),%esp
10aa67: 5b pop %ebx
10aa68: 5e pop %esi
10aa69: 5f pop %edi
10aa6a: c9 leave
10aa6b: c3 ret
0010aa6c <_Thread_Clear_state>:
void _Thread_Clear_state(
Thread_Control *the_thread,
States_Control state
)
{
10aa6c: 55 push %ebp
10aa6d: 89 e5 mov %esp,%ebp
10aa6f: 53 push %ebx
10aa70: 8b 4d 08 mov 0x8(%ebp),%ecx
10aa73: 8b 45 0c mov 0xc(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10aa76: 9c pushf
10aa77: fa cli
10aa78: 5b pop %ebx
current_state = the_thread->current_state;
10aa79: 8b 51 10 mov 0x10(%ecx),%edx
if ( current_state & state ) {
10aa7c: 85 d0 test %edx,%eax
10aa7e: 74 6f je 10aaef <_Thread_Clear_state+0x83>
* @param[in] page_size is the size in bytes of the allocation unit
*
* @return This method returns the maximum memory available. If
* unsuccessful, 0 will be returned.
*/
static inline uint32_t _Protected_heap_Initialize(
10aa80: f7 d0 not %eax
10aa82: 21 d0 and %edx,%eax
current_state =
10aa84: 89 41 10 mov %eax,0x10(%ecx)
the_thread->current_state = _States_Clear( state, current_state );
if ( _States_Is_ready( current_state ) ) {
10aa87: 85 c0 test %eax,%eax
10aa89: 75 64 jne 10aaef <_Thread_Clear_state+0x83>
* otherwise.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the user block
* to obtain the size of
* @param[in] size points to a user area to return the size in
10aa8b: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx
10aa91: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax
10aa98: 66 09 02 or %ax,(%edx)
* @return TRUE if successfully able to determine the size, FALSE otherwise
10aa9b: 66 a1 94 cb 11 00 mov 0x11cb94,%ax
10aaa1: 0b 81 94 00 00 00 or 0x94(%ecx),%eax
10aaa7: 66 a3 94 cb 11 00 mov %ax,0x11cb94
_Priority_Add_to_bit_map( &the_thread->Priority_map );
_Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
10aaad: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax
10aab3: 8d 50 04 lea 0x4(%eax),%edx
10aab6: 89 11 mov %edx,(%ecx)
10aab8: 8b 50 08 mov 0x8(%eax),%edx
10aabb: 89 48 08 mov %ecx,0x8(%eax)
10aabe: 89 0a mov %ecx,(%edx)
10aac0: 89 51 04 mov %edx,0x4(%ecx)
_ISR_Flash( level );
10aac3: 53 push %ebx
10aac4: 9d popf
10aac5: 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 ) {
10aac6: 8b 51 14 mov 0x14(%ecx),%edx
10aac9: a1 6c cb 11 00 mov 0x11cb6c,%eax
10aace: 3b 50 14 cmp 0x14(%eax),%edx
10aad1: 73 1c jae 10aaef <_Thread_Clear_state+0x83>
_Thread_Heir = the_thread;
10aad3: 89 0d 6c cb 11 00 mov %ecx,0x11cb6c
if ( _Thread_Executing->is_preemptible ||
10aad9: a1 a0 cb 11 00 mov 0x11cba0,%eax
10aade: 80 78 76 00 cmpb $0x0,0x76(%eax)
10aae2: 75 04 jne 10aae8 <_Thread_Clear_state+0x7c>
10aae4: 85 d2 test %edx,%edx
10aae6: 75 07 jne 10aaef <_Thread_Clear_state+0x83><== ALWAYS TAKEN
the_thread->current_priority == 0 )
_Context_Switch_necessary = TRUE;
10aae8: c6 05 b0 cb 11 00 01 movb $0x1,0x11cbb0
}
}
}
_ISR_Enable( level );
10aaef: 53 push %ebx
10aaf0: 9d popf
}
10aaf1: 5b pop %ebx
10aaf2: c9 leave
10aaf3: c3 ret
0010abd4 <_Thread_Create_idle>:
*
* _Thread_Create_idle
*/
void _Thread_Create_idle( void )
{
10abd4: 55 push %ebp
10abd5: 89 e5 mov %esp,%ebp
10abd7: 83 ec 14 sub $0x14,%esp
10abda: 68 3c cc 11 00 push $0x11cc3c
10abdf: e8 04 f6 ff ff call 10a1e8 <_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();
10abe4: a3 88 cc 11 00 mov %eax,0x11cc88
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10abe9: a1 e0 ca 11 00 mov 0x11cae0,%eax
10abee: 40 inc %eax
10abef: a3 e0 ca 11 00 mov %eax,0x11cae0
* that when _Thread_Initialize unnests dispatch that we do not
* do anything stupid.
*/
_Thread_Disable_dispatch();
_Thread_Initialize(
10abf4: a1 78 cb 11 00 mov 0x11cb78,%eax
10abf9: 8b 50 18 mov 0x18(%eax),%edx
10abfc: 83 c4 0c add $0xc,%esp
10abff: 68 cc 68 11 00 push $0x1168cc
10ac04: 6a 00 push $0x0
10ac06: 6a 00 push $0x0
10ac08: 6a 00 push $0x0
10ac0a: 6a 01 push $0x1
10ac0c: 0f b6 05 64 87 11 00 movzbl 0x118764,%eax
10ac13: 50 push %eax
10ac14: 6a 00 push $0x0
10ac16: a1 60 87 11 00 mov 0x118760,%eax
10ac1b: 39 d0 cmp %edx,%eax
10ac1d: 73 02 jae 10ac21 <_Thread_Create_idle+0x4d><== ALWAYS TAKEN
10ac1f: 89 d0 mov %edx,%eax <== NOT EXECUTED
10ac21: 50 push %eax
10ac22: 6a 00 push $0x0
10ac24: ff 35 88 cc 11 00 pushl 0x11cc88
10ac2a: 68 3c cc 11 00 push $0x11cc3c
10ac2f: e8 50 02 00 00 call 10ae84 <_Thread_Initialize>
10ac34: a1 e0 ca 11 00 mov 0x11cae0,%eax
10ac39: 48 dec %eax
10ac3a: a3 e0 ca 11 00 mov %eax,0x11cae0
/*
* WARNING!!! This is necessary to "kick" start the system and
* MUST be done before _Thread_Start is invoked.
*/
_Thread_Heir =
10ac3f: 8b 15 88 cc 11 00 mov 0x11cc88,%edx
10ac45: 89 15 a0 cb 11 00 mov %edx,0x11cba0
10ac4b: 89 15 6c cb 11 00 mov %edx,0x11cb6c
_Thread_Executing = _Thread_Idle;
_Thread_Start(
10ac51: 83 c4 24 add $0x24,%esp
10ac54: 6a 00 push $0x0
10ac56: 6a 00 push $0x0
10ac58: a1 78 cb 11 00 mov 0x11cb78,%eax
10ac5d: ff 70 14 pushl 0x14(%eax)
10ac60: 6a 00 push $0x0
10ac62: 52 push %edx
10ac63: e8 8c 0b 00 00 call 10b7f4 <_Thread_Start>
10ac68: 83 c4 20 add $0x20,%esp
_Configuration_Table->idle_task,
NULL,
0
);
}
10ac6b: c9 leave
10ac6c: c3 ret
0010ac70 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored
)
{
10ac70: 55 push %ebp
10ac71: 89 e5 mov %esp,%ebp
10ac73: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10ac76: 8d 45 fc lea -0x4(%ebp),%eax
10ac79: 50 push %eax
10ac7a: ff 75 08 pushl 0x8(%ebp)
10ac7d: e8 8a 01 00 00 call 10ae0c <_Thread_Get>
switch ( location ) {
10ac82: 83 c4 10 add $0x10,%esp
10ac85: 83 7d fc 00 cmpl $0x0,-0x4(%ebp)
10ac89: 75 1b jne 10aca6 <_Thread_Delay_ended+0x36><== NEVER TAKEN
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
10ac8b: 52 push %edx
10ac8c: 52 push %edx
10ac8d: 68 f8 ff 03 10 push $0x1003fff8
10ac92: 50 push %eax
10ac93: e8 d4 fd ff ff call 10aa6c <_Thread_Clear_state>
10ac98: a1 e0 ca 11 00 mov 0x11cae0,%eax
10ac9d: 48 dec %eax
10ac9e: a3 e0 ca 11 00 mov %eax,0x11cae0
10aca3: 83 c4 10 add $0x10,%esp
case OBJECTS_LOCAL:
_Thread_Unblock( the_thread );
_Thread_Unnest_dispatch();
break;
}
}
10aca6: c9 leave
10aca7: c3 ret
0010aca8 <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
10aca8: 55 push %ebp
10aca9: 89 e5 mov %esp,%ebp
10acab: 57 push %edi
10acac: 56 push %esi
10acad: 53 push %ebx
10acae: 83 ec 1c sub $0x1c,%esp
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
10acb1: 8b 1d a0 cb 11 00 mov 0x11cba0,%ebx
_ISR_Disable( level );
10acb7: 9c pushf
10acb8: fa cli
10acb9: 5a pop %edx
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
{
struct timespec uptime, ran;
_TOD_Get_uptime( &uptime );
_Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
10acba: 8d 7d e4 lea -0x1c(%ebp),%edi
10acbd: e9 f1 00 00 00 jmp 10adb3 <_Thread_Dispatch+0x10b>
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Context_Switch_necessary == TRUE ) {
heir = _Thread_Heir;
10acc2: 8b 35 6c cb 11 00 mov 0x11cb6c,%esi
_Thread_Dispatch_disable_level = 1;
10acc8: c7 05 e0 ca 11 00 01 movl $0x1,0x11cae0
10accf: 00 00 00
_Context_Switch_necessary = FALSE;
10acd2: c6 05 b0 cb 11 00 00 movb $0x0,0x11cbb0
_Thread_Executing = heir;
10acd9: 89 35 a0 cb 11 00 mov %esi,0x11cba0
#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 )
10acdf: 83 7e 7c 01 cmpl $0x1,0x7c(%esi)
10ace3: 75 08 jne 10aced <_Thread_Dispatch+0x45>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
10ace5: a1 ac ca 11 00 mov 0x11caac,%eax
10acea: 89 46 78 mov %eax,0x78(%esi)
_ISR_Enable( level );
10aced: 52 push %edx
10acee: 9d popf
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
{
struct timespec uptime, ran;
_TOD_Get_uptime( &uptime );
10acef: 83 ec 0c sub $0xc,%esp
10acf2: 8d 45 ec lea -0x14(%ebp),%eax
10acf5: 50 push %eax
10acf6: e8 6d 2b 00 00 call 10d868 <_TOD_Get_uptime>
_Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
10acfb: 83 c4 0c add $0xc,%esp
10acfe: 57 push %edi
10acff: 8d 45 ec lea -0x14(%ebp),%eax
10ad02: 50 push %eax
10ad03: 68 a8 cb 11 00 push $0x11cba8
10ad08: e8 37 0c 00 00 call 10b944 <_Timespec_Subtract>
_Timespec_Add_to( &executing->cpu_time_used, &ran );
10ad0d: 58 pop %eax
10ad0e: 5a pop %edx
10ad0f: 57 push %edi
10ad10: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax
10ad16: 50 push %eax
10ad17: e8 f8 0b 00 00 call 10b914 <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
10ad1c: 8b 45 ec mov -0x14(%ebp),%eax
10ad1f: 8b 55 f0 mov -0x10(%ebp),%edx
10ad22: a3 a8 cb 11 00 mov %eax,0x11cba8
10ad27: 89 15 ac cb 11 00 mov %edx,0x11cbac
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
10ad2d: 8b 15 68 cb 11 00 mov 0x11cb68,%edx
10ad33: 83 c4 10 add $0x10,%esp
10ad36: 85 d2 test %edx,%edx
10ad38: 74 10 je 10ad4a <_Thread_Dispatch+0xa2> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
10ad3a: 8b 02 mov (%edx),%eax
10ad3c: 89 83 f0 00 00 00 mov %eax,0xf0(%ebx)
*_Thread_libc_reent = heir->libc_reent;
10ad42: 8b 86 f0 00 00 00 mov 0xf0(%esi),%eax
10ad48: 89 02 mov %eax,(%edx)
}
_User_extensions_Thread_switch( executing, heir );
10ad4a: 51 push %ecx
10ad4b: 51 push %ecx
10ad4c: 56 push %esi
10ad4d: 53 push %ebx
10ad4e: e8 01 0e 00 00 call 10bb54 <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
10ad53: 58 pop %eax
10ad54: 5a pop %edx
10ad55: 8d 86 d4 00 00 00 lea 0xd4(%esi),%eax
10ad5b: 50 push %eax
10ad5c: 8d 83 d4 00 00 00 lea 0xd4(%ebx),%eax
10ad62: 50 push %eax
10ad63: e8 b8 10 00 00 call 10be20 <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
10ad68: 83 c4 10 add $0x10,%esp
10ad6b: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx)
10ad72: 74 36 je 10adaa <_Thread_Dispatch+0x102>
Heap_Control *the_heap,
void *starting_address,
size_t *size
);
/**
10ad74: a1 64 cb 11 00 mov 0x11cb64,%eax
10ad79: 39 c3 cmp %eax,%ebx
10ad7b: 74 2d je 10adaa <_Thread_Dispatch+0x102>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
10ad7d: 85 c0 test %eax,%eax
10ad7f: 74 11 je 10ad92 <_Thread_Dispatch+0xea>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10ad81: 83 ec 0c sub $0xc,%esp
10ad84: 05 ec 00 00 00 add $0xec,%eax
10ad89: 50 push %eax
10ad8a: e8 c5 10 00 00 call 10be54 <_CPU_Context_save_fp>
10ad8f: 83 c4 10 add $0x10,%esp
_Context_Restore_fp( &executing->fp_context );
10ad92: 83 ec 0c sub $0xc,%esp
10ad95: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax
10ad9b: 50 push %eax
10ad9c: e8 bd 10 00 00 call 10be5e <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
10ada1: 89 1d 64 cb 11 00 mov %ebx,0x11cb64
10ada7: 83 c4 10 add $0x10,%esp
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
10adaa: 8b 1d a0 cb 11 00 mov 0x11cba0,%ebx
_ISR_Disable( level );
10adb0: 9c pushf
10adb1: fa cli
10adb2: 5a pop %edx
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Context_Switch_necessary == TRUE ) {
10adb3: a0 b0 cb 11 00 mov 0x11cbb0,%al
10adb8: 84 c0 test %al,%al
10adba: 0f 85 02 ff ff ff jne 10acc2 <_Thread_Dispatch+0x1a>
executing = _Thread_Executing;
_ISR_Disable( level );
}
_Thread_Dispatch_disable_level = 0;
10adc0: c7 05 e0 ca 11 00 00 movl $0x0,0x11cae0
10adc7: 00 00 00
_ISR_Enable( level );
10adca: 52 push %edx
10adcb: 9d popf
if ( _Thread_Do_post_task_switch_extension ||
10adcc: 83 3d 84 cb 11 00 00 cmpl $0x0,0x11cb84
10add3: 75 06 jne 10addb <_Thread_Dispatch+0x133><== NEVER TAKEN
10add5: 80 7b 75 00 cmpb $0x0,0x75(%ebx)
10add9: 74 09 je 10ade4 <_Thread_Dispatch+0x13c>
executing->do_post_task_switch_extension ) {
executing->do_post_task_switch_extension = false;
10addb: c6 43 75 00 movb $0x0,0x75(%ebx)
_API_extensions_Run_postswitch();
10addf: e8 4b eb ff ff call 10992f <_API_extensions_Run_postswitch>
}
}
10ade4: 8d 65 f4 lea -0xc(%ebp),%esp
10ade7: 5b pop %ebx
10ade8: 5e pop %esi
10ade9: 5f pop %edi
10adea: c9 leave
10adeb: c3 ret
0010e508 <_Thread_Evaluate_mode>:
*
* XXX
*/
bool _Thread_Evaluate_mode( void )
{
10e508: 55 push %ebp
10e509: 89 e5 mov %esp,%ebp
Thread_Control *executing;
executing = _Thread_Executing;
10e50b: a1 a0 cb 11 00 mov 0x11cba0,%eax
if ( !_States_Is_ready( executing->current_state ) ||
10e510: 83 78 10 00 cmpl $0x0,0x10(%eax)
10e514: 75 0e jne 10e524 <_Thread_Evaluate_mode+0x1c><== NEVER TAKEN
10e516: 3b 05 6c cb 11 00 cmp 0x11cb6c,%eax
10e51c: 74 11 je 10e52f <_Thread_Evaluate_mode+0x27>
10e51e: 80 78 76 00 cmpb $0x0,0x76(%eax)
10e522: 74 0b je 10e52f <_Thread_Evaluate_mode+0x27><== NEVER TAKEN
( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) {
_Context_Switch_necessary = TRUE;
10e524: c6 05 b0 cb 11 00 01 movb $0x1,0x11cbb0
10e52b: b0 01 mov $0x1,%al
10e52d: eb 02 jmp 10e531 <_Thread_Evaluate_mode+0x29>
return TRUE;
10e52f: 31 c0 xor %eax,%eax
}
return FALSE;
}
10e531: c9 leave
10e532: c3 ret
0010ae0c <_Thread_Get>:
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
10ae0c: 55 push %ebp
10ae0d: 89 e5 mov %esp,%ebp
10ae0f: 53 push %ebx
10ae10: 83 ec 04 sub $0x4,%esp
10ae13: 8b 5d 08 mov 0x8(%ebp),%ebx
10ae16: 8b 4d 0c mov 0xc(%ebp),%ecx
uint32_t the_class;
Objects_Information **api_information;
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
10ae19: 85 db test %ebx,%ebx
10ae1b: 75 18 jne 10ae35 <_Thread_Get+0x29>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10ae1d: a1 e0 ca 11 00 mov 0x11cae0,%eax
10ae22: 40 inc %eax
10ae23: a3 e0 ca 11 00 mov %eax,0x11cae0
_Thread_Disable_dispatch();
*location = OBJECTS_LOCAL;
10ae28: c7 01 00 00 00 00 movl $0x0,(%ecx)
tp = _Thread_Executing;
10ae2e: a1 a0 cb 11 00 mov 0x11cba0,%eax
10ae33: eb 40 jmp 10ae75 <_Thread_Get+0x69>
uint32_t page_size
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
10ae35: 89 da mov %ebx,%edx
10ae37: c1 ea 18 shr $0x18,%edx
10ae3a: 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.
10ae3d: 8d 42 ff lea -0x1(%edx),%eax
10ae40: 83 f8 03 cmp $0x3,%eax
10ae43: 76 35 jbe 10ae7a <_Thread_Get+0x6e>
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
10ae45: c7 01 01 00 00 00 movl $0x1,(%ecx)
10ae4b: 31 c0 xor %eax,%eax
10ae4d: eb 26 jmp 10ae75 <_Thread_Get+0x69>
goto done;
}
api_information = _Objects_Information_table[ the_api ];
10ae4f: 8b 04 95 b4 ca 11 00 mov 0x11cab4(,%edx,4),%eax
if ( !api_information ) {
10ae56: 85 c0 test %eax,%eax
10ae58: 74 07 je 10ae61 <_Thread_Get+0x55>
*location = OBJECTS_ERROR;
goto done;
}
information = api_information[ the_class ];
10ae5a: 8b 40 04 mov 0x4(%eax),%eax
if ( !information ) {
10ae5d: 85 c0 test %eax,%eax
10ae5f: 75 08 jne 10ae69 <_Thread_Get+0x5d> <== ALWAYS TAKEN
*location = OBJECTS_ERROR;
10ae61: c7 01 01 00 00 00 movl $0x1,(%ecx)
10ae67: eb 0c jmp 10ae75 <_Thread_Get+0x69>
goto done;
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
10ae69: 52 push %edx
10ae6a: 51 push %ecx
10ae6b: 53 push %ebx
10ae6c: 50 push %eax
10ae6d: e8 ba f7 ff ff call 10a62c <_Objects_Get>
10ae72: 83 c4 10 add $0x10,%esp
done:
return tp;
}
10ae75: 8b 5d fc mov -0x4(%ebp),%ebx
10ae78: c9 leave
10ae79: c3 ret
*location = OBJECTS_ERROR;
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
10ae7a: 89 d8 mov %ebx,%eax
10ae7c: c1 e8 1b shr $0x1b,%eax
10ae7f: 48 dec %eax
10ae80: 74 cd je 10ae4f <_Thread_Get+0x43>
10ae82: eb c1 jmp 10ae45 <_Thread_Get+0x39>
0010e534 <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
10e534: 55 push %ebp
10e535: 89 e5 mov %esp,%ebp
10e537: 53 push %ebx
10e538: 83 ec 04 sub $0x4,%esp
#if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
10e53b: 8b 1d a0 cb 11 00 mov 0x11cba0,%ebx
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
10e541: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
_ISR_Set_level(level);
10e547: 85 c0 test %eax,%eax
10e549: 74 03 je 10e54e <_Thread_Handler+0x1a>
10e54b: fa cli
10e54c: eb 01 jmp 10e54f <_Thread_Handler+0x1b>
10e54e: fb sti
#if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__)
doneCons = doneConstructors;
10e54f: a0 d8 c8 11 00 mov 0x11c8d8,%al
10e554: 88 45 fb mov %al,-0x5(%ebp)
doneConstructors = 1;
10e557: c6 05 d8 c8 11 00 01 movb $0x1,0x11c8d8
#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 ) ) {
10e55e: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx)
10e565: 74 24 je 10e58b <_Thread_Handler+0x57>
Heap_Control *the_heap,
void *starting_address,
size_t *size
);
/**
10e567: a1 64 cb 11 00 mov 0x11cb64,%eax
10e56c: 39 c3 cmp %eax,%ebx
10e56e: 74 1b je 10e58b <_Thread_Handler+0x57>
if ( _Thread_Allocated_fp != NULL )
10e570: 85 c0 test %eax,%eax
10e572: 74 11 je 10e585 <_Thread_Handler+0x51>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10e574: 83 ec 0c sub $0xc,%esp
10e577: 05 ec 00 00 00 add $0xec,%eax
10e57c: 50 push %eax
10e57d: e8 d2 d8 ff ff call 10be54 <_CPU_Context_save_fp>
10e582: 83 c4 10 add $0x10,%esp
_Thread_Allocated_fp = executing;
10e585: 89 1d 64 cb 11 00 mov %ebx,0x11cb64
* 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 );
10e58b: 83 ec 0c sub $0xc,%esp
10e58e: 53 push %ebx
10e58f: e8 74 d4 ff ff call 10ba08 <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
10e594: e8 53 c8 ff ff call 10adec <_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) */
10e599: 83 c4 10 add $0x10,%esp
10e59c: 80 7d fb 00 cmpb $0x0,-0x5(%ebp)
10e5a0: 75 05 jne 10e5a7 <_Thread_Handler+0x73>
{
_init ();
10e5a2: e8 69 6e 00 00 call 115410 <__start_set_sysctl_set>
#if defined(__USE__MAIN__)
if (!doneCons && _main)
__main ();
#endif
switch ( executing->Start.prototype ) {
10e5a7: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax
10e5ad: 83 f8 01 cmp $0x1,%eax
10e5b0: 74 13 je 10e5c5 <_Thread_Handler+0x91> <== NEVER TAKEN
10e5b2: 72 0c jb 10e5c0 <_Thread_Handler+0x8c> <== ALWAYS TAKEN
10e5b4: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED
10e5b7: 74 11 je 10e5ca <_Thread_Handler+0x96> <== NOT EXECUTED
10e5b9: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED
10e5bc: 75 36 jne 10e5f4 <_Thread_Handler+0xc0> <== NOT EXECUTED
10e5be: eb 1a jmp 10e5da <_Thread_Handler+0xa6> <== NOT EXECUTED
case THREAD_START_NUMERIC:
executing->Wait.return_argument =
10e5c0: 83 ec 0c sub $0xc,%esp
10e5c3: eb 1d jmp 10e5e2 <_Thread_Handler+0xae>
(*(Thread_Entry_numeric) executing->Start.entry_point)(
executing->Start.numeric_argument
);
break;
case THREAD_START_POINTER:
executing->Wait.return_argument =
10e5c5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10e5c8: eb 08 jmp 10e5d2 <_Thread_Handler+0x9e> <== NOT EXECUTED
(*(Thread_Entry_pointer) executing->Start.entry_point)(
executing->Start.pointer_argument
);
break;
case THREAD_START_BOTH_POINTER_FIRST:
executing->Wait.return_argument =
10e5ca: 52 push %edx <== NOT EXECUTED
10e5cb: 52 push %edx <== NOT EXECUTED
10e5cc: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED
10e5d2: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED
10e5d8: eb 0e jmp 10e5e8 <_Thread_Handler+0xb4> <== NOT EXECUTED
executing->Start.pointer_argument,
executing->Start.numeric_argument
);
break;
case THREAD_START_BOTH_NUMERIC_FIRST:
executing->Wait.return_argument =
10e5da: 50 push %eax <== NOT EXECUTED
10e5db: 50 push %eax <== NOT EXECUTED
10e5dc: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED
10e5e2: ff b3 a8 00 00 00 pushl 0xa8(%ebx)
10e5e8: ff 93 9c 00 00 00 call *0x9c(%ebx)
10e5ee: 89 43 28 mov %eax,0x28(%ebx)
10e5f1: 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 );
10e5f4: 83 ec 0c sub $0xc,%esp
10e5f7: 53 push %ebx
10e5f8: e8 3c d4 ff ff call 10ba39 <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
10e5fd: 83 c4 0c add $0xc,%esp
10e600: 6a 06 push $0x6
10e602: 6a 01 push $0x1
10e604: 6a 00 push $0x0
10e606: e8 49 bb ff ff call 10a154 <_Internal_error_Occurred>
0010ae84 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
10ae84: 55 push %ebp
10ae85: 89 e5 mov %esp,%ebp
10ae87: 57 push %edi
10ae88: 56 push %esi
10ae89: 53 push %ebx
10ae8a: 83 ec 0c sub $0xc,%esp
10ae8d: 8b 5d 0c mov 0xc(%ebp),%ebx
10ae90: 8b 55 10 mov 0x10(%ebp),%edx
10ae93: 8b 75 14 mov 0x14(%ebp),%esi
10ae96: 8a 45 18 mov 0x18(%ebp),%al
10ae99: 88 45 f3 mov %al,-0xd(%ebp)
10ae9c: 8a 45 20 mov 0x20(%ebp),%al
10ae9f: 88 45 f2 mov %al,-0xe(%ebp)
/*
* Allocate and Initialize the stack for this thread.
*/
if ( !stack_area ) {
10aea2: 85 d2 test %edx,%edx
10aea4: 75 2a jne 10aed0 <_Thread_Initialize+0x4c><== NEVER TAKEN
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
10aea6: 51 push %ecx
10aea7: 51 push %ecx
10aea8: 56 push %esi
10aea9: 53 push %ebx
10aeaa: e8 69 08 00 00 call 10b718 <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
10aeaf: 83 c4 10 add $0x10,%esp
10aeb2: 85 c0 test %eax,%eax
10aeb4: 74 04 je 10aeba <_Thread_Initialize+0x36>
10aeb6: 39 f0 cmp %esi,%eax
10aeb8: 73 07 jae 10aec1 <_Thread_Initialize+0x3d><== ALWAYS TAKEN
10aeba: 31 d2 xor %edx,%edx
10aebc: e9 8c 01 00 00 jmp 10b04d <_Thread_Initialize+0x1c9>
return FALSE; /* stack allocation failed */
stack = the_thread->Start.stack;
10aec1: 8b 93 d0 00 00 00 mov 0xd0(%ebx),%edx
the_thread->Start.core_allocated_stack = TRUE;
10aec7: c6 83 c0 00 00 00 01 movb $0x1,0xc0(%ebx)
10aece: eb 09 jmp 10aed9 <_Thread_Initialize+0x55>
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = FALSE;
10aed0: c6 83 c0 00 00 00 00 movb $0x0,0xc0(%ebx) <== NOT EXECUTED
10aed7: 89 f0 mov %esi,%eax <== NOT EXECUTED
/**
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
10aed9: 89 93 c8 00 00 00 mov %edx,0xc8(%ebx)
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
10aedf: 89 83 c4 00 00 00 mov %eax,0xc4(%ebx)
if ( is_fp ) {
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
if ( !fp_area ) {
_Thread_Stack_Free( the_thread );
return FALSE;
10aee5: 31 f6 xor %esi,%esi
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
10aee7: 80 7d f3 00 cmpb $0x0,-0xd(%ebp)
10aeeb: 74 17 je 10af04 <_Thread_Initialize+0x80>
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
10aeed: 83 ec 0c sub $0xc,%esp
10aef0: 6a 6c push $0x6c
10aef2: e8 92 0e 00 00 call 10bd89 <_Workspace_Allocate>
10aef7: 89 c6 mov %eax,%esi
if ( !fp_area ) {
10aef9: 83 c4 10 add $0x10,%esp
10aefc: 85 c0 test %eax,%eax
10aefe: 0f 84 3b 01 00 00 je 10b03f <_Thread_Initialize+0x1bb><== NEVER TAKEN
fp_area = _Context_Fp_start( fp_area, 0 );
} else
fp_area = NULL;
the_thread->fp_context = fp_area;
10af04: 89 b3 ec 00 00 00 mov %esi,0xec(%ebx)
the_thread->Start.fp_context = fp_area;
10af0a: 89 b3 cc 00 00 00 mov %esi,0xcc(%ebx)
*
10af10: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
* @param[in] the_heap is the heap to operate upon
10af17: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
* @param[in] starting_address is the starting address of the memory for
10af1e: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
* the heap
10af25: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
/*
* Clear the libc reent hook.
*/
the_thread->libc_reent = NULL;
10af2c: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx)
10af33: 00 00 00
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10af36: a1 80 cb 11 00 mov 0x11cb80,%eax
(void) _Workspace_Free( fp_area );
#endif
_Thread_Stack_Free( the_thread );
return FALSE;
10af3b: 31 ff xor %edi,%edi
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10af3d: 85 c0 test %eax,%eax
10af3f: 74 1d je 10af5e <_Thread_Initialize+0xda>
extensions_area = _Workspace_Allocate(
10af41: 83 ec 0c sub $0xc,%esp
10af44: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax
10af4b: 50 push %eax
10af4c: e8 38 0e 00 00 call 10bd89 <_Workspace_Allocate>
10af51: 89 c7 mov %eax,%edi
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area ) {
10af53: 83 c4 10 add $0x10,%esp
10af56: 85 c0 test %eax,%eax
10af58: 0f 84 d1 00 00 00 je 10b02f <_Thread_Initialize+0x1ab><== NEVER TAKEN
return FALSE;
}
} else
extensions_area = NULL;
the_thread->extensions = (void **) extensions_area;
10af5e: 89 bb 00 01 00 00 mov %edi,0x100(%ebx)
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
10af64: 31 d2 xor %edx,%edx
10af66: 85 ff test %edi,%edi
10af68: 75 10 jne 10af7a <_Thread_Initialize+0xf6>
10af6a: eb 18 jmp 10af84 <_Thread_Initialize+0x100>
uint32_t i;
for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ )
the_thread->extensions[i] = NULL;
10af6c: 8b 83 00 01 00 00 mov 0x100(%ebx),%eax
10af72: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4)
* call.
*/
if ( the_thread->extensions ) {
uint32_t i;
for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ )
10af79: 42 inc %edx
10af7a: a1 80 cb 11 00 mov 0x11cb80,%eax
10af7f: 40 inc %eax
10af80: 39 c2 cmp %eax,%edx
10af82: 72 e8 jb 10af6c <_Thread_Initialize+0xe8>
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
10af84: 8a 45 f2 mov -0xe(%ebp),%al
10af87: 88 83 ac 00 00 00 mov %al,0xac(%ebx)
the_thread->Start.budget_algorithm = budget_algorithm;
10af8d: 8b 45 24 mov 0x24(%ebp),%eax
10af90: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx)
the_thread->Start.budget_callout = budget_callout;
10af96: 8b 45 28 mov 0x28(%ebp),%eax
10af99: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx)
switch ( budget_algorithm ) {
10af9f: 83 7d 24 02 cmpl $0x2,0x24(%ebp)
10afa3: 75 08 jne 10afad <_Thread_Initialize+0x129><== ALWAYS TAKEN
case THREAD_CPU_BUDGET_ALGORITHM_NONE:
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
break;
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
10afa5: a1 ac ca 11 00 mov 0x11caac,%eax <== NOT EXECUTED
10afaa: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED
break;
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
}
the_thread->Start.isr_level = isr_level;
10afad: 8b 45 2c mov 0x2c(%ebp),%eax
10afb0: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
the_thread->current_state = STATES_DORMANT;
10afb6: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
the_thread->Wait.queue = NULL;
10afbd: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
the_thread->resource_count = 0;
10afc4: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->suspend_count = 0;
10afcb: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx)
the_thread->real_priority = priority;
10afd2: 8b 45 1c mov 0x1c(%ebp),%eax
10afd5: 89 43 18 mov %eax,0x18(%ebx)
the_thread->Start.initial_priority = priority;
10afd8: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx)
_Thread_Set_priority( the_thread, priority );
10afde: 52 push %edx
10afdf: 52 push %edx
10afe0: 50 push %eax
10afe1: 53 push %ebx
10afe2: e8 8d 05 00 00 call 10b574 <_Thread_Set_priority>
/*
* Initialize the CPU usage statistics
*/
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
the_thread->cpu_time_used.tv_sec = 0;
10afe7: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx)
10afee: 00 00 00
the_thread->cpu_time_used.tv_nsec = 0;
10aff1: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx)
10aff8: 00 00 00
10affb: 0f b7 53 08 movzwl 0x8(%ebx),%edx
10afff: 8b 45 08 mov 0x8(%ebp),%eax
10b002: 8b 40 1c mov 0x1c(%eax),%eax
10b005: 89 1c 90 mov %ebx,(%eax,%edx,4)
10b008: 8b 45 30 mov 0x30(%ebp),%eax
10b00b: 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 );
10b00e: 89 1c 24 mov %ebx,(%esp)
10b011: e8 92 0a 00 00 call 10baa8 <_User_extensions_Thread_create>
if ( !extension_status ) {
10b016: 83 c4 10 add $0x10,%esp
10b019: b2 01 mov $0x1,%dl
10b01b: 84 c0 test %al,%al
10b01d: 75 2e jne 10b04d <_Thread_Initialize+0x1c9><== ALWAYS TAKEN
if ( extensions_area )
10b01f: 85 ff test %edi,%edi <== NOT EXECUTED
10b021: 74 0c je 10b02f <_Thread_Initialize+0x1ab><== NOT EXECUTED
(void) _Workspace_Free( extensions_area );
10b023: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b026: 57 push %edi <== NOT EXECUTED
10b027: e8 48 0d 00 00 call 10bd74 <_Workspace_Free> <== NOT EXECUTED
10b02c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( fp_area )
10b02f: 85 f6 test %esi,%esi <== NOT EXECUTED
10b031: 74 0c je 10b03f <_Thread_Initialize+0x1bb><== NOT EXECUTED
(void) _Workspace_Free( fp_area );
10b033: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b036: 56 push %esi <== NOT EXECUTED
10b037: e8 38 0d 00 00 call 10bd74 <_Workspace_Free> <== NOT EXECUTED
10b03c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
#endif
_Thread_Stack_Free( the_thread );
10b03f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b042: 53 push %ebx <== NOT EXECUTED
10b043: e8 20 07 00 00 call 10b768 <_Thread_Stack_Free> <== NOT EXECUTED
10b048: 31 d2 xor %edx,%edx <== NOT EXECUTED
10b04a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return FALSE;
}
return TRUE;
}
10b04d: 88 d0 mov %dl,%al
10b04f: 8d 65 f4 lea -0xc(%ebp),%esp
10b052: 5b pop %ebx
10b053: 5e pop %esi
10b054: 5f pop %edi
10b055: c9 leave
10b056: c3 ret
0010e89c <_Thread_Reset>:
void _Thread_Reset(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
10e89c: 55 push %ebp
10e89d: 89 e5 mov %esp,%ebp
10e89f: 53 push %ebx
10e8a0: 83 ec 10 sub $0x10,%esp
10e8a3: 8b 5d 08 mov 0x8(%ebp),%ebx
the_thread->resource_count = 0;
10e8a6: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->suspend_count = 0;
10e8ad: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx)
the_thread->is_preemptible = the_thread->Start.is_preemptible;
10e8b4: 8a 83 ac 00 00 00 mov 0xac(%ebx),%al
10e8ba: 88 43 76 mov %al,0x76(%ebx)
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
10e8bd: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax
10e8c3: 89 43 7c mov %eax,0x7c(%ebx)
the_thread->budget_callout = the_thread->Start.budget_callout;
10e8c6: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax
10e8cc: 89 83 80 00 00 00 mov %eax,0x80(%ebx)
the_thread->Start.pointer_argument = pointer_argument;
10e8d2: 8b 45 0c mov 0xc(%ebp),%eax
10e8d5: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
the_thread->Start.numeric_argument = numeric_argument;
10e8db: 8b 45 10 mov 0x10(%ebp),%eax
10e8de: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx)
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
10e8e4: 53 push %ebx
10e8e5: e8 d2 d4 ff ff call 10bdbc <_Thread_queue_Extract_with_proxy>
10e8ea: 83 c4 10 add $0x10,%esp
10e8ed: 84 c0 test %al,%al
10e8ef: 75 15 jne 10e906 <_Thread_Reset+0x6a> <== NEVER TAKEN
if ( _Watchdog_Is_active( &the_thread->Timer ) )
10e8f1: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10e8f5: 75 0f jne 10e906 <_Thread_Reset+0x6a> <== ALWAYS TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
10e8f7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10e8fa: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED
10e8fd: 50 push %eax <== NOT EXECUTED
10e8fe: e8 f9 dd ff ff call 10c6fc <_Watchdog_Remove> <== NOT EXECUTED
10e903: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
10e906: 8b 83 bc 00 00 00 mov 0xbc(%ebx),%eax
10e90c: 39 43 14 cmp %eax,0x14(%ebx)
10e90f: 74 12 je 10e923 <_Thread_Reset+0x87>
the_thread->real_priority = the_thread->Start.initial_priority;
10e911: 89 43 18 mov %eax,0x18(%ebx)
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
10e914: 89 45 0c mov %eax,0xc(%ebp)
10e917: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
10e91a: 8b 5d fc mov -0x4(%ebp),%ebx
10e91d: 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 );
10e91e: e9 75 d6 ff ff jmp 10bf98 <_Thread_Set_priority>
}
}
10e923: 8b 5d fc mov -0x4(%ebp),%ebx
10e926: c9 leave
10e927: c3 ret
0010ddc4 <_Thread_Reset_timeslice>:
* ready chain
* select heir
*/
void _Thread_Reset_timeslice( void )
{
10ddc4: 55 push %ebp
10ddc5: 89 e5 mov %esp,%ebp
10ddc7: 56 push %esi
10ddc8: 53 push %ebx
ISR_Level level;
Thread_Control *executing;
Chain_Control *ready;
executing = _Thread_Executing;
10ddc9: 8b 0d a0 cb 11 00 mov 0x11cba0,%ecx
ready = executing->ready;
10ddcf: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx
_ISR_Disable( level );
10ddd5: 9c pushf
10ddd6: fa cli
10ddd7: 5e pop %esi
if ( _Chain_Has_only_one_node( ready ) ) {
10ddd8: 8b 03 mov (%ebx),%eax
10ddda: 3b 43 08 cmp 0x8(%ebx),%eax
10dddd: 75 04 jne 10dde3 <_Thread_Reset_timeslice+0x1f>
_ISR_Enable( level );
10dddf: 56 push %esi
10dde0: 9d popf
10dde1: eb 35 jmp 10de18 <_Thread_Reset_timeslice+0x54>
10dde3: 8b 11 mov (%ecx),%edx
10dde5: 8b 41 04 mov 0x4(%ecx),%eax
10dde8: 89 42 04 mov %eax,0x4(%edx)
10ddeb: 89 10 mov %edx,(%eax)
10dded: 8d 43 04 lea 0x4(%ebx),%eax
10ddf0: 89 01 mov %eax,(%ecx)
10ddf2: 8b 43 08 mov 0x8(%ebx),%eax
10ddf5: 89 4b 08 mov %ecx,0x8(%ebx)
10ddf8: 89 08 mov %ecx,(%eax)
10ddfa: 89 41 04 mov %eax,0x4(%ecx)
return;
}
_Chain_Extract_unprotected( &executing->Object.Node );
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
10ddfd: 56 push %esi
10ddfe: 9d popf
10ddff: fa cli
if ( _Thread_Is_heir( executing ) )
10de00: 3b 0d 6c cb 11 00 cmp 0x11cb6c,%ecx
10de06: 75 07 jne 10de0f <_Thread_Reset_timeslice+0x4b><== NEVER TAKEN
_Thread_Heir = (Thread_Control *) ready->first;
10de08: 8b 03 mov (%ebx),%eax
10de0a: a3 6c cb 11 00 mov %eax,0x11cb6c
_Context_Switch_necessary = TRUE;
10de0f: c6 05 b0 cb 11 00 01 movb $0x1,0x11cbb0
_ISR_Enable( level );
10de16: 56 push %esi
10de17: 9d popf
}
10de18: 5b pop %ebx
10de19: 5e pop %esi
10de1a: c9 leave
10de1b: c3 ret
0010bf10 <_Thread_Restart>:
bool _Thread_Restart(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
10bf10: 55 push %ebp
10bf11: 89 e5 mov %esp,%ebp
10bf13: 53 push %ebx
10bf14: 83 ec 04 sub $0x4,%esp
10bf17: 8b 5d 08 mov 0x8(%ebp),%ebx
if ( !_States_Is_dormant( the_thread->current_state ) ) {
10bf1a: 31 c0 xor %eax,%eax
10bf1c: f6 43 10 01 testb $0x1,0x10(%ebx)
10bf20: 75 70 jne 10bf92 <_Thread_Restart+0x82>
_Thread_Set_transient( the_thread );
10bf22: 83 ec 0c sub $0xc,%esp
10bf25: 53 push %ebx
10bf26: e8 a1 01 00 00 call 10c0cc <_Thread_Set_transient>
_Thread_Reset( the_thread, pointer_argument, numeric_argument );
10bf2b: 83 c4 0c add $0xc,%esp
10bf2e: ff 75 10 pushl 0x10(%ebp)
10bf31: ff 75 0c pushl 0xc(%ebp)
10bf34: 53 push %ebx
10bf35: e8 62 29 00 00 call 10e89c <_Thread_Reset>
_Thread_Load_environment( the_thread );
10bf3a: 89 1c 24 mov %ebx,(%esp)
10bf3d: e8 56 26 00 00 call 10e598 <_Thread_Load_environment>
_Thread_Ready( the_thread );
10bf42: 89 1c 24 mov %ebx,(%esp)
10bf45: e8 b2 28 00 00 call 10e7fc <_Thread_Ready>
_User_extensions_Thread_restart( the_thread );
10bf4a: 89 1c 24 mov %ebx,(%esp)
10bf4d: e8 ee 05 00 00 call 10c540 <_User_extensions_Thread_restart>
if ( _Thread_Is_executing ( the_thread ) )
10bf52: 83 c4 10 add $0x10,%esp
10bf55: b0 01 mov $0x1,%al
10bf57: 3b 1d 8c f5 11 00 cmp 0x11f58c,%ebx
10bf5d: 75 33 jne 10bf92 <_Thread_Restart+0x82>
* Returns pointer to the start of the memory block if success, NULL if
* failure.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
* @param[in] alignment the required alignment
10bf5f: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx)
10bf66: 74 12 je 10bf7a <_Thread_Restart+0x6a>
* @return NULL if unsuccessful and a pointer to the block if successful
10bf68: 83 ec 0c sub $0xc,%esp
10bf6b: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax
10bf71: 50 push %eax
10bf72: e8 47 09 00 00 call 10c8be <_CPU_Context_restore_fp>
10bf77: 83 c4 10 add $0x10,%esp
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
10bf7a: 83 ec 0c sub $0xc,%esp
10bf7d: a1 8c f5 11 00 mov 0x11f58c,%eax
10bf82: 05 d4 00 00 00 add $0xd4,%eax
10bf87: 50 push %eax
10bf88: e8 20 09 00 00 call 10c8ad <_CPU_Context_restore>
10bf8d: b0 01 mov $0x1,%al <== NOT EXECUTED
10bf8f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return TRUE;
}
return FALSE;
}
10bf92: 8b 5d fc mov -0x4(%ebp),%ebx
10bf95: c9 leave
10bf96: c3 ret
0010c920 <_Thread_Resume>:
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
10c920: 55 push %ebp
10c921: 89 e5 mov %esp,%ebp
10c923: 53 push %ebx
10c924: 8b 4d 08 mov 0x8(%ebp),%ecx
10c927: 8a 45 0c mov 0xc(%ebp),%al
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10c92a: 9c pushf
10c92b: fa cli
10c92c: 5b pop %ebx
if ( force == TRUE )
10c92d: 84 c0 test %al,%al
10c92f: 74 09 je 10c93a <_Thread_Resume+0x1a> <== NEVER TAKEN
the_thread->suspend_count = 0;
10c931: c7 41 70 00 00 00 00 movl $0x0,0x70(%ecx)
10c938: eb 03 jmp 10c93d <_Thread_Resume+0x1d>
else
the_thread->suspend_count--;
10c93a: ff 49 70 decl 0x70(%ecx) <== NOT EXECUTED
if ( the_thread->suspend_count > 0 ) {
10c93d: 83 79 70 00 cmpl $0x0,0x70(%ecx)
10c941: 74 04 je 10c947 <_Thread_Resume+0x27> <== ALWAYS TAKEN
_ISR_Enable( level );
10c943: 53 push %ebx <== NOT EXECUTED
10c944: 9d popf <== NOT EXECUTED
10c945: eb 77 jmp 10c9be <_Thread_Resume+0x9e> <== NOT EXECUTED
return;
}
current_state = the_thread->current_state;
10c947: 8b 41 10 mov 0x10(%ecx),%eax
if ( current_state & STATES_SUSPENDED ) {
10c94a: a8 02 test $0x2,%al
10c94c: 74 6e je 10c9bc <_Thread_Resume+0x9c> <== NEVER TAKEN
* @param[in] page_size is the size in bytes of the allocation unit
*
* @return This method returns the maximum memory available. If
* unsuccessful, 0 will be returned.
*/
static inline uint32_t _Protected_heap_Initialize(
10c94e: 83 e0 fd and $0xfffffffd,%eax
current_state =
10c951: 89 41 10 mov %eax,0x10(%ecx)
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
if ( _States_Is_ready( current_state ) ) {
10c954: 85 c0 test %eax,%eax
10c956: 75 64 jne 10c9bc <_Thread_Resume+0x9c>
* 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
10c958: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx
10c95e: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax
10c965: 66 09 02 or %ax,(%edx)
* @return TRUE if successfully able to determine the size, FALSE otherwise
10c968: 66 a1 50 85 12 00 mov 0x128550,%ax
10c96e: 0b 81 94 00 00 00 or 0x94(%ecx),%eax
10c974: 66 a3 50 85 12 00 mov %ax,0x128550
_Priority_Add_to_bit_map( &the_thread->Priority_map );
_Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
10c97a: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax
10c980: 8d 50 04 lea 0x4(%eax),%edx
10c983: 89 11 mov %edx,(%ecx)
10c985: 8b 50 08 mov 0x8(%eax),%edx
10c988: 89 48 08 mov %ecx,0x8(%eax)
10c98b: 89 0a mov %ecx,(%edx)
10c98d: 89 51 04 mov %edx,0x4(%ecx)
_ISR_Flash( level );
10c990: 53 push %ebx
10c991: 9d popf
10c992: fa cli
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
10c993: 8b 51 14 mov 0x14(%ecx),%edx
10c996: a1 28 85 12 00 mov 0x128528,%eax
10c99b: 3b 50 14 cmp 0x14(%eax),%edx
10c99e: 73 1c jae 10c9bc <_Thread_Resume+0x9c>
_Thread_Heir = the_thread;
10c9a0: 89 0d 28 85 12 00 mov %ecx,0x128528
if ( _Thread_Executing->is_preemptible ||
10c9a6: a1 5c 85 12 00 mov 0x12855c,%eax
10c9ab: 80 78 76 00 cmpb $0x0,0x76(%eax)
10c9af: 75 04 jne 10c9b5 <_Thread_Resume+0x95>
10c9b1: 85 d2 test %edx,%edx
10c9b3: 75 07 jne 10c9bc <_Thread_Resume+0x9c> <== ALWAYS TAKEN
the_thread->current_priority == 0 )
_Context_Switch_necessary = TRUE;
10c9b5: c6 05 6c 85 12 00 01 movb $0x1,0x12856c
}
}
}
_ISR_Enable( level );
10c9bc: 53 push %ebx
10c9bd: 9d popf
}
10c9be: 5b pop %ebx
10c9bf: c9 leave
10c9c0: c3 ret
0010b718 <_Thread_Stack_Allocate>:
size_t _Thread_Stack_Allocate(
Thread_Control *the_thread,
size_t stack_size
)
{
10b718: 55 push %ebp
10b719: 89 e5 mov %esp,%ebp
10b71b: 53 push %ebx
10b71c: 83 ec 04 sub $0x4,%esp
10b71f: a1 60 87 11 00 mov 0x118760,%eax
10b724: 8b 5d 0c mov 0xc(%ebp),%ebx
10b727: 39 c3 cmp %eax,%ebx
10b729: 73 02 jae 10b72d <_Thread_Stack_Allocate+0x15>
10b72b: 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 ) {
10b72d: a1 78 cb 11 00 mov 0x11cb78,%eax
10b732: 8b 40 20 mov 0x20(%eax),%eax
10b735: 85 c0 test %eax,%eax
10b737: 74 08 je 10b741 <_Thread_Stack_Allocate+0x29><== ALWAYS TAKEN
stack_addr = (*_Configuration_Table->stack_allocate_hook)( the_stack_size );
10b739: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b73c: 53 push %ebx <== NOT EXECUTED
10b73d: ff d0 call *%eax <== NOT EXECUTED
10b73f: eb 09 jmp 10b74a <_Thread_Stack_Allocate+0x32><== NOT EXECUTED
* get and keep the stack adjust factor, the stack alignment, and
* the context initialization sequence in sync.
*/
the_stack_size = _Stack_Adjust_size( the_stack_size );
stack_addr = _Workspace_Allocate( the_stack_size );
10b741: 83 ec 0c sub $0xc,%esp
10b744: 53 push %ebx
10b745: e8 3f 06 00 00 call 10bd89 <_Workspace_Allocate>
10b74a: 89 c1 mov %eax,%ecx
10b74c: 83 c4 10 add $0x10,%esp
}
if ( !stack_addr )
10b74f: 31 c0 xor %eax,%eax
10b751: 85 c9 test %ecx,%ecx
10b753: 0f 95 c0 setne %al
10b756: f7 d8 neg %eax
10b758: 21 d8 and %ebx,%eax
the_stack_size = 0;
the_thread->Start.stack = stack_addr;
10b75a: 8b 55 08 mov 0x8(%ebp),%edx
10b75d: 89 8a d0 00 00 00 mov %ecx,0xd0(%edx)
return the_stack_size;
}
10b763: 8b 5d fc mov -0x4(%ebp),%ebx
10b766: c9 leave
10b767: c3 ret
0010b768 <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
10b768: 55 push %ebp
10b769: 89 e5 mov %esp,%ebp
10b76b: 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 )
10b76e: 80 ba c0 00 00 00 00 cmpb $0x0,0xc0(%edx)
10b775: 74 21 je 10b798 <_Thread_Stack_Free+0x30><== NEVER TAKEN
* Call ONLY the CPU table stack free hook, or the
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
if ( _Configuration_Table->stack_free_hook )
10b777: a1 78 cb 11 00 mov 0x11cb78,%eax
10b77c: 8b 48 24 mov 0x24(%eax),%ecx
10b77f: 85 c9 test %ecx,%ecx
10b781: 8b 82 c8 00 00 00 mov 0xc8(%edx),%eax
10b787: 74 06 je 10b78f <_Thread_Stack_Free+0x27><== ALWAYS TAKEN
(*_Configuration_Table->stack_free_hook)(
10b789: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
the_thread->Start.Initial_stack.area
);
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
}
10b78c: 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)(
10b78d: ff e1 jmp *%ecx <== NOT EXECUTED
the_thread->Start.Initial_stack.area
);
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
10b78f: 89 45 08 mov %eax,0x8(%ebp)
}
10b792: 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 );
10b793: e9 dc 05 00 00 jmp 10bd74 <_Workspace_Free>
}
10b798: c9 leave <== NOT EXECUTED
10b799: c3 ret <== NOT EXECUTED
0010b850 <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
10b850: 55 push %ebp
10b851: 89 e5 mov %esp,%ebp
10b853: 53 push %ebx
10b854: 83 ec 04 sub $0x4,%esp
Thread_Control *executing;
executing = _Thread_Executing;
10b857: 8b 1d a0 cb 11 00 mov 0x11cba0,%ebx
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
10b85d: 80 7b 76 00 cmpb $0x0,0x76(%ebx)
10b861: 74 4c je 10b8af <_Thread_Tickle_timeslice+0x5f>
return;
if ( !_States_Is_ready( executing->current_state ) )
10b863: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10b867: 75 46 jne 10b8af <_Thread_Tickle_timeslice+0x5f><== NEVER TAKEN
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
10b869: 8b 43 7c mov 0x7c(%ebx),%eax
10b86c: 83 f8 01 cmp $0x1,%eax
10b86f: 72 3e jb 10b8af <_Thread_Tickle_timeslice+0x5f>
10b871: 83 f8 02 cmp $0x2,%eax
10b874: 76 07 jbe 10b87d <_Thread_Tickle_timeslice+0x2d><== ALWAYS TAKEN
10b876: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED
10b879: 75 34 jne 10b8af <_Thread_Tickle_timeslice+0x5f><== NOT EXECUTED
10b87b: eb 1a jmp 10b897 <_Thread_Tickle_timeslice+0x47><== 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 ) {
10b87d: 8b 43 78 mov 0x78(%ebx),%eax
10b880: 48 dec %eax
10b881: 89 43 78 mov %eax,0x78(%ebx)
10b884: 85 c0 test %eax,%eax
10b886: 7f 27 jg 10b8af <_Thread_Tickle_timeslice+0x5f>
_Thread_Reset_timeslice();
10b888: e8 37 25 00 00 call 10ddc4 <_Thread_Reset_timeslice>
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
10b88d: a1 ac ca 11 00 mov 0x11caac,%eax
10b892: 89 43 78 mov %eax,0x78(%ebx)
10b895: eb 18 jmp 10b8af <_Thread_Tickle_timeslice+0x5f>
}
break;
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
10b897: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED
10b89a: 48 dec %eax <== NOT EXECUTED
10b89b: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED
10b89e: 85 c0 test %eax,%eax <== NOT EXECUTED
10b8a0: 75 0d jne 10b8af <_Thread_Tickle_timeslice+0x5f><== NOT EXECUTED
(*executing->budget_callout)( executing );
10b8a2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b8a5: 53 push %ebx <== NOT EXECUTED
10b8a6: ff 93 80 00 00 00 call *0x80(%ebx) <== NOT EXECUTED
10b8ac: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
break;
}
}
10b8af: 8b 5d fc mov -0x4(%ebp),%ebx
10b8b2: c9 leave
10b8b3: c3 ret
0010b8b4 <_Thread_Yield_processor>:
* ready chain
* select heir
*/
void _Thread_Yield_processor( void )
{
10b8b4: 55 push %ebp
10b8b5: 89 e5 mov %esp,%ebp
10b8b7: 56 push %esi
10b8b8: 53 push %ebx
ISR_Level level;
Thread_Control *executing;
Chain_Control *ready;
executing = _Thread_Executing;
10b8b9: 8b 0d a0 cb 11 00 mov 0x11cba0,%ecx
ready = executing->ready;
10b8bf: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx
_ISR_Disable( level );
10b8c5: 9c pushf
10b8c6: fa cli
10b8c7: 5e pop %esi
if ( !_Chain_Has_only_one_node( ready ) ) {
10b8c8: 8b 03 mov (%ebx),%eax
10b8ca: 3b 43 08 cmp 0x8(%ebx),%eax
10b8cd: 74 2e je 10b8fd <_Thread_Yield_processor+0x49>
10b8cf: 8b 11 mov (%ecx),%edx
10b8d1: 8b 41 04 mov 0x4(%ecx),%eax
10b8d4: 89 42 04 mov %eax,0x4(%edx)
10b8d7: 89 10 mov %edx,(%eax)
10b8d9: 8d 43 04 lea 0x4(%ebx),%eax
10b8dc: 89 01 mov %eax,(%ecx)
10b8de: 8b 43 08 mov 0x8(%ebx),%eax
10b8e1: 89 4b 08 mov %ecx,0x8(%ebx)
10b8e4: 89 08 mov %ecx,(%eax)
10b8e6: 89 41 04 mov %eax,0x4(%ecx)
_Chain_Extract_unprotected( &executing->Object.Node );
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
10b8e9: 56 push %esi
10b8ea: 9d popf
10b8eb: fa cli
if ( _Thread_Is_heir( executing ) )
10b8ec: 3b 0d 6c cb 11 00 cmp 0x11cb6c,%ecx
10b8f2: 75 11 jne 10b905 <_Thread_Yield_processor+0x51><== NEVER TAKEN
_Thread_Heir = (Thread_Control *) ready->first;
10b8f4: 8b 03 mov (%ebx),%eax
10b8f6: a3 6c cb 11 00 mov %eax,0x11cb6c
10b8fb: eb 08 jmp 10b905 <_Thread_Yield_processor+0x51>
_Context_Switch_necessary = TRUE;
}
else if ( !_Thread_Is_heir( executing ) )
10b8fd: 3b 0d 6c cb 11 00 cmp 0x11cb6c,%ecx
10b903: 74 07 je 10b90c <_Thread_Yield_processor+0x58><== ALWAYS TAKEN
_Context_Switch_necessary = TRUE;
10b905: c6 05 b0 cb 11 00 01 movb $0x1,0x11cbb0
_ISR_Enable( level );
10b90c: 56 push %esi
10b90d: 9d popf
}
10b90e: 5b pop %ebx
10b90f: 5e pop %esi
10b910: c9 leave
10b911: c3 ret
0010b2c8 <_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
)
{
10b2c8: 55 push %ebp
10b2c9: 89 e5 mov %esp,%ebp
10b2cb: 57 push %edi
10b2cc: 56 push %esi
10b2cd: 53 push %ebx
10b2ce: 83 ec 18 sub $0x18,%esp
10b2d1: 8b 4d 0c mov 0xc(%ebp),%ecx
10b2d4: 8d 41 3c lea 0x3c(%ecx),%eax
10b2d7: 89 41 38 mov %eax,0x38(%ecx)
10b2da: c7 41 3c 00 00 00 00 movl $0x0,0x3c(%ecx)
10b2e1: 8d 41 38 lea 0x38(%ecx),%eax
10b2e4: 89 41 40 mov %eax,0x40(%ecx)
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
10b2e7: 8b 79 14 mov 0x14(%ecx),%edi
extern "C" {
#endif
/**
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
10b2ea: 89 f8 mov %edi,%eax
10b2ec: c1 e8 06 shr $0x6,%eax
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
10b2ef: 6b c0 0c imul $0xc,%eax,%eax
10b2f2: 8b 5d 08 mov 0x8(%ebp),%ebx
10b2f5: 01 c3 add %eax,%ebx
block_state = the_thread_queue->state;
10b2f7: 8b 55 08 mov 0x8(%ebp),%edx
10b2fa: 8b 52 38 mov 0x38(%edx),%edx
10b2fd: 89 55 e8 mov %edx,-0x18(%ebp)
if ( _Thread_queue_Is_reverse_search( priority ) )
10b300: f7 c7 20 00 00 00 test $0x20,%edi
10b306: 75 77 jne 10b37f <_Thread_queue_Enqueue_priority+0xb7>
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
10b308: 83 c3 04 add $0x4,%ebx
10b30b: 89 5d ec mov %ebx,-0x14(%ebp)
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
10b30e: 89 45 dc mov %eax,-0x24(%ebp)
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
10b311: 9c pushf
10b312: fa cli
10b313: 5e pop %esi
search_thread = (Thread_Control *) header->first;
10b314: 8b 45 dc mov -0x24(%ebp),%eax
10b317: 8b 5d 08 mov 0x8(%ebp),%ebx
10b31a: 8b 14 18 mov (%eax,%ebx,1),%edx
10b31d: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp)
10b324: eb 1b jmp 10b341 <_Thread_queue_Enqueue_priority+0x79>
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
search_priority = search_thread->current_priority;
10b326: 8b 5a 14 mov 0x14(%edx),%ebx
10b329: 89 5d e0 mov %ebx,-0x20(%ebp)
if ( priority <= search_priority )
10b32c: 39 df cmp %ebx,%edi
10b32e: 76 16 jbe 10b346 <_Thread_queue_Enqueue_priority+0x7e>
break;
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
10b330: 56 push %esi
10b331: 9d popf
10b332: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10b333: 8b 45 e8 mov -0x18(%ebp),%eax
10b336: 85 42 10 test %eax,0x10(%edx)
10b339: 75 04 jne 10b33f <_Thread_queue_Enqueue_priority+0x77><== ALWAYS TAKEN
_ISR_Enable( level );
10b33b: 56 push %esi <== NOT EXECUTED
10b33c: 9d popf <== NOT EXECUTED
10b33d: eb d2 jmp 10b311 <_Thread_queue_Enqueue_priority+0x49><== NOT EXECUTED
goto restart_forward_search;
}
search_thread =
10b33f: 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 ) ) {
10b341: 3b 55 ec cmp -0x14(%ebp),%edx
10b344: 75 e0 jne 10b326 <_Thread_queue_Enqueue_priority+0x5e>
10b346: 89 55 f0 mov %edx,-0x10(%ebp)
10b349: 89 f3 mov %esi,%ebx
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
10b34b: 8b 45 08 mov 0x8(%ebp),%eax
10b34e: 83 78 30 01 cmpl $0x1,0x30(%eax)
10b352: 0f 85 b4 00 00 00 jne 10b40c <_Thread_queue_Enqueue_priority+0x144><== NEVER TAKEN
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10b358: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
if ( priority == search_priority )
10b35f: 3b 7d e0 cmp -0x20(%ebp),%edi
10b362: 0f 84 87 00 00 00 je 10b3ef <_Thread_queue_Enqueue_priority+0x127>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
10b368: 8b 42 04 mov 0x4(%edx),%eax
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
10b36b: 89 11 mov %edx,(%ecx)
the_node->previous = previous_node;
10b36d: 89 41 04 mov %eax,0x4(%ecx)
previous_node->next = the_node;
10b370: 89 08 mov %ecx,(%eax)
search_node->previous = the_node;
10b372: 89 4a 04 mov %ecx,0x4(%edx)
the_thread->Wait.queue = the_thread_queue;
10b375: 8b 55 08 mov 0x8(%ebp),%edx
10b378: 89 51 44 mov %edx,0x44(%ecx)
_ISR_Enable( level );
10b37b: 56 push %esi
10b37c: 9d popf
10b37d: eb 69 jmp 10b3e8 <_Thread_queue_Enqueue_priority+0x120>
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
10b37f: 8d 43 08 lea 0x8(%ebx),%eax
10b382: 89 45 e4 mov %eax,-0x1c(%ebp)
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
10b385: 0f b6 05 64 87 11 00 movzbl 0x118764,%eax
10b38c: 40 inc %eax
10b38d: 89 45 e0 mov %eax,-0x20(%ebp)
_ISR_Disable( level );
10b390: 9c pushf
10b391: fa cli
10b392: 5e pop %esi
search_thread = (Thread_Control *) header->last;
10b393: 8b 45 e4 mov -0x1c(%ebp),%eax
10b396: 8b 10 mov (%eax),%edx
10b398: eb 1c jmp 10b3b6 <_Thread_queue_Enqueue_priority+0xee>
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
search_priority = search_thread->current_priority;
10b39a: 8b 42 14 mov 0x14(%edx),%eax
10b39d: 89 45 e0 mov %eax,-0x20(%ebp)
if ( priority >= search_priority )
10b3a0: 39 c7 cmp %eax,%edi
10b3a2: 73 16 jae 10b3ba <_Thread_queue_Enqueue_priority+0xf2>
break;
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
10b3a4: 56 push %esi
10b3a5: 9d popf
10b3a6: fa cli
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
10b3a7: 8b 45 e8 mov -0x18(%ebp),%eax
10b3aa: 85 42 10 test %eax,0x10(%edx)
10b3ad: 75 04 jne 10b3b3 <_Thread_queue_Enqueue_priority+0xeb><== ALWAYS TAKEN
_ISR_Enable( level );
10b3af: 56 push %esi <== NOT EXECUTED
10b3b0: 9d popf <== NOT EXECUTED
10b3b1: eb d2 jmp 10b385 <_Thread_queue_Enqueue_priority+0xbd><== NOT EXECUTED
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
10b3b3: 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 ) ) {
10b3b6: 39 da cmp %ebx,%edx
10b3b8: 75 e0 jne 10b39a <_Thread_queue_Enqueue_priority+0xd2>
10b3ba: 89 55 f0 mov %edx,-0x10(%ebp)
10b3bd: 89 f3 mov %esi,%ebx
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
10b3bf: 8b 45 08 mov 0x8(%ebp),%eax
10b3c2: 83 78 30 01 cmpl $0x1,0x30(%eax)
10b3c6: 75 44 jne 10b40c <_Thread_queue_Enqueue_priority+0x144><== NEVER TAKEN
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
10b3c8: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
if ( priority == search_priority )
10b3cf: 3b 7d e0 cmp -0x20(%ebp),%edi
10b3d2: 74 1b je 10b3ef <_Thread_queue_Enqueue_priority+0x127>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
10b3d4: 8b 02 mov (%edx),%eax
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
10b3d6: 89 01 mov %eax,(%ecx)
the_node->previous = search_node;
10b3d8: 89 51 04 mov %edx,0x4(%ecx)
search_node->next = the_node;
10b3db: 89 0a mov %ecx,(%edx)
next_node->previous = the_node;
10b3dd: 89 48 04 mov %ecx,0x4(%eax)
the_thread->Wait.queue = the_thread_queue;
10b3e0: 8b 55 08 mov 0x8(%ebp),%edx
10b3e3: 89 51 44 mov %edx,0x44(%ecx)
_ISR_Enable( level );
10b3e6: 56 push %esi
10b3e7: 9d popf
10b3e8: b8 01 00 00 00 mov $0x1,%eax
10b3ed: eb 28 jmp 10b417 <_Thread_queue_Enqueue_priority+0x14f>
10b3ef: 8b 45 f0 mov -0x10(%ebp),%eax
10b3f2: 83 c0 3c add $0x3c,%eax
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
10b3f5: 8b 50 04 mov 0x4(%eax),%edx
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
10b3f8: 89 01 mov %eax,(%ecx)
the_node->previous = previous_node;
10b3fa: 89 51 04 mov %edx,0x4(%ecx)
previous_node->next = the_node;
10b3fd: 89 0a mov %ecx,(%edx)
search_node->previous = the_node;
10b3ff: 89 48 04 mov %ecx,0x4(%eax)
the_thread->Wait.queue = the_thread_queue;
10b402: 8b 45 08 mov 0x8(%ebp),%eax
10b405: 89 41 44 mov %eax,0x44(%ecx)
_ISR_Enable( level );
10b408: 53 push %ebx
10b409: 9d popf
10b40a: eb dc jmp 10b3e8 <_Thread_queue_Enqueue_priority+0x120>
* For example, the blocking thread could have been given
* the mutex by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
10b40c: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
10b40f: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
return the_thread_queue->sync_state;
10b411: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
10b414: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED
}
10b417: 83 c4 18 add $0x18,%esp
10b41a: 5b pop %ebx
10b41b: 5e pop %esi
10b41c: 5f pop %edi
10b41d: c9 leave
10b41e: c3 ret
0010e60c <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10e60c: 55 push %ebp
10e60d: 89 e5 mov %esp,%ebp
10e60f: 53 push %ebx
10e610: 83 ec 04 sub $0x4,%esp
10e613: 8b 5d 0c mov 0xc(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
10e616: 9c pushf
10e617: fa cli
10e618: 59 pop %ecx
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10e619: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx)
10e620: 75 07 jne 10e629 <_Thread_queue_Extract_fifo+0x1d><== ALWAYS TAKEN
_ISR_Enable( level );
10e622: 51 push %ecx <== NOT EXECUTED
10e623: 9d popf <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
10e624: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10e627: c9 leave <== NOT EXECUTED
10e628: c3 ret <== NOT EXECUTED
10e629: 8b 13 mov (%ebx),%edx
10e62b: 8b 43 04 mov 0x4(%ebx),%eax
10e62e: 89 42 04 mov %eax,0x4(%edx)
10e631: 89 10 mov %edx,(%eax)
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
10e633: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10e63a: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10e63e: 74 04 je 10e644 <_Thread_queue_Extract_fifo+0x38>
_ISR_Enable( level );
10e640: 51 push %ecx
10e641: 9d popf
10e642: eb 18 jmp 10e65c <_Thread_queue_Extract_fifo+0x50>
* a block of the requested size, then NULL is returned.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
* @return NULL if unsuccessful and a pointer to the block if successful
*/
10e644: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
10e64b: 51 push %ecx
10e64c: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
10e64d: 83 ec 0c sub $0xc,%esp
10e650: 8d 43 48 lea 0x48(%ebx),%eax
10e653: 50 push %eax
10e654: e8 47 d6 ff ff call 10bca0 <_Watchdog_Remove>
10e659: 83 c4 10 add $0x10,%esp
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
10e65c: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp)
10e663: 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
}
10e666: 8b 5d fc mov -0x4(%ebp),%ebx
10e669: c9 leave
10e66a: e9 fd c3 ff ff jmp 10aa6c <_Thread_Clear_state>
0010dc1c <_Thread_queue_Extract_priority_helper>:
void _Thread_queue_Extract_priority_helper(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
bool requeuing
)
{
10dc1c: 55 push %ebp
10dc1d: 89 e5 mov %esp,%ebp
10dc1f: 57 push %edi
10dc20: 56 push %esi
10dc21: 53 push %ebx
10dc22: 83 ec 0c sub $0xc,%esp
10dc25: 8b 5d 0c mov 0xc(%ebp),%ebx
10dc28: 8a 45 10 mov 0x10(%ebp),%al
10dc2b: 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 );
10dc2e: 9c pushf
10dc2f: fa cli
10dc30: 8f 45 ec popl -0x14(%ebp)
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10dc33: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx)
10dc3a: 75 09 jne 10dc45 <_Thread_queue_Extract_priority_helper+0x29><== ALWAYS TAKEN
_ISR_Enable( level );
10dc3c: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED
10dc3f: 9d popf <== NOT EXECUTED
10dc40: e9 8f 00 00 00 jmp 10dcd4 <_Thread_queue_Extract_priority_helper+0xb8><== NOT EXECUTED
/*
* The thread was actually waiting on a thread queue so let's remove it.
*/
next_node = the_node->next;
10dc45: 8b 33 mov (%ebx),%esi
previous_node = the_node->previous;
10dc47: 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(
10dc4a: 8b 53 38 mov 0x38(%ebx),%edx
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
10dc4d: 8d 43 3c lea 0x3c(%ebx),%eax
10dc50: 39 c2 cmp %eax,%edx
10dc52: 74 33 je 10dc87 <_Thread_queue_Extract_priority_helper+0x6b>
new_first_node = the_thread->Wait.Block2n.first;
new_first_thread = (Thread_Control *) new_first_node;
last_node = the_thread->Wait.Block2n.last;
10dc54: 8b 43 40 mov 0x40(%ebx),%eax
10dc57: 89 45 f0 mov %eax,-0x10(%ebp)
new_second_node = new_first_node->next;
10dc5a: 8b 3a mov (%edx),%edi
previous_node->next = new_first_node;
10dc5c: 89 11 mov %edx,(%ecx)
next_node->previous = new_first_node;
10dc5e: 89 56 04 mov %edx,0x4(%esi)
new_first_node->next = next_node;
10dc61: 89 32 mov %esi,(%edx)
new_first_node->previous = previous_node;
10dc63: 89 4a 04 mov %ecx,0x4(%edx)
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
10dc66: 8b 43 38 mov 0x38(%ebx),%eax
10dc69: 3b 43 40 cmp 0x40(%ebx),%eax
10dc6c: 74 1e je 10dc8c <_Thread_queue_Extract_priority_helper+0x70>
/* > two threads on 2-n */
new_second_node->previous =
10dc6e: 8d 42 38 lea 0x38(%edx),%eax
10dc71: 89 47 04 mov %eax,0x4(%edi)
_Chain_Head( &new_first_thread->Wait.Block2n );
new_first_thread->Wait.Block2n.first = new_second_node;
10dc74: 89 7a 38 mov %edi,0x38(%edx)
new_first_thread->Wait.Block2n.last = last_node;
10dc77: 8b 45 f0 mov -0x10(%ebp),%eax
10dc7a: 89 42 40 mov %eax,0x40(%edx)
last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
10dc7d: 8d 42 3c lea 0x3c(%edx),%eax
10dc80: 8b 55 f0 mov -0x10(%ebp),%edx
10dc83: 89 02 mov %eax,(%edx)
10dc85: eb 05 jmp 10dc8c <_Thread_queue_Extract_priority_helper+0x70>
}
} else {
previous_node->next = next_node;
10dc87: 89 31 mov %esi,(%ecx)
next_node->previous = previous_node;
10dc89: 89 4e 04 mov %ecx,0x4(%esi)
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
10dc8c: 80 7d eb 00 cmpb $0x0,-0x15(%ebp)
10dc90: 74 06 je 10dc98 <_Thread_queue_Extract_priority_helper+0x7c>
_ISR_Enable( level );
10dc92: ff 75 ec pushl -0x14(%ebp)
10dc95: 9d popf
10dc96: eb 3c jmp 10dcd4 <_Thread_queue_Extract_priority_helper+0xb8>
return;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
10dc98: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
10dc9c: 74 06 je 10dca4 <_Thread_queue_Extract_priority_helper+0x88><== NEVER TAKEN
_ISR_Enable( level );
10dc9e: ff 75 ec pushl -0x14(%ebp)
10dca1: 9d popf
10dca2: eb 1a jmp 10dcbe <_Thread_queue_Extract_priority_helper+0xa2>
* a block of the requested size, then NULL is returned.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
* @return NULL if unsuccessful and a pointer to the block if successful
*/
10dca4: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
10dcab: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED
10dcae: 9d popf <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
10dcaf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10dcb2: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED
10dcb5: 50 push %eax <== NOT EXECUTED
10dcb6: e8 e5 df ff ff call 10bca0 <_Watchdog_Remove> <== NOT EXECUTED
10dcbb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
void *_Protected_heap_Allocate(
Heap_Control *the_heap,
size_t size
);
/**
10dcbe: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp)
10dcc5: 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
}
10dcc8: 8d 65 f4 lea -0xc(%ebp),%esp
10dccb: 5b pop %ebx
10dccc: 5e pop %esi
10dccd: 5f pop %edi
10dcce: c9 leave
10dccf: e9 98 cd ff ff jmp 10aa6c <_Thread_Clear_state>
10dcd4: 8d 65 f4 lea -0xc(%ebp),%esp
10dcd7: 5b pop %ebx
10dcd8: 5e pop %esi
10dcd9: 5f pop %edi
10dcda: c9 leave
10dcdb: c3 ret
0010dcdc <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
10dcdc: 55 push %ebp
10dcdd: 89 e5 mov %esp,%ebp
10dcdf: 83 ec 08 sub $0x8,%esp
10dce2: 8b 4d 08 mov 0x8(%ebp),%ecx
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
10dce5: 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 &&
10dce8: 8b 42 30 mov 0x30(%edx),%eax
10dceb: 85 c0 test %eax,%eax
10dced: 74 1c je 10dd0b <_Thread_queue_Process_timeout+0x2f>
10dcef: 3b 0d a0 cb 11 00 cmp 0x11cba0,%ecx
10dcf5: 75 14 jne 10dd0b <_Thread_queue_Process_timeout+0x2f><== NEVER TAKEN
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
10dcf7: 83 f8 03 cmp $0x3,%eax
10dcfa: 74 23 je 10dd1f <_Thread_queue_Process_timeout+0x43><== NEVER TAKEN
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
10dcfc: 8b 42 3c mov 0x3c(%edx),%eax
10dcff: 89 41 34 mov %eax,0x34(%ecx)
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
10dd02: c7 42 30 02 00 00 00 movl $0x2,0x30(%edx)
10dd09: eb 14 jmp 10dd1f <_Thread_queue_Process_timeout+0x43>
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
10dd0b: 8b 42 3c mov 0x3c(%edx),%eax
10dd0e: 89 41 34 mov %eax,0x34(%ecx)
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
10dd11: 50 push %eax
10dd12: 50 push %eax
10dd13: 51 push %ecx
10dd14: ff 71 44 pushl 0x44(%ecx)
10dd17: e8 d0 fe ff ff call 10dbec <_Thread_queue_Extract>
10dd1c: 83 c4 10 add $0x10,%esp
}
}
10dd1f: c9 leave
10dd20: c3 ret
0010b4ec <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10b4ec: 55 push %ebp
10b4ed: 89 e5 mov %esp,%ebp
10b4ef: 57 push %edi
10b4f0: 56 push %esi
10b4f1: 53 push %ebx
10b4f2: 83 ec 1c sub $0x1c,%esp
10b4f5: 8b 5d 08 mov 0x8(%ebp),%ebx
10b4f8: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Just in case the thread really wasn't blocked on a thread queue
* when we get here.
*/
if ( !the_thread_queue )
10b4fb: 85 db test %ebx,%ebx
10b4fd: 74 36 je 10b535 <_Thread_queue_Requeue+0x49><== NEVER TAKEN
/*
* If queueing by FIFO, there is nothing to do. This only applies to
* priority blocking discipline.
*/
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
10b4ff: 83 7b 34 01 cmpl $0x1,0x34(%ebx)
10b503: 75 30 jne 10b535 <_Thread_queue_Requeue+0x49><== NEVER TAKEN
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
10b505: 9c pushf
10b506: fa cli
10b507: 5f pop %edi
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10b508: f7 46 10 e0 be 03 00 testl $0x3bee0,0x10(%esi)
10b50f: 74 22 je 10b533 <_Thread_queue_Requeue+0x47><== NEVER TAKEN
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
* This routine grows @a the_heap memory area using the size bytes which
10b511: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx)
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, TRUE );
10b518: 50 push %eax
10b519: 6a 01 push $0x1
10b51b: 56 push %esi
10b51c: 53 push %ebx
10b51d: e8 fa 26 00 00 call 10dc1c <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
10b522: 83 c4 0c add $0xc,%esp
10b525: 8d 45 f0 lea -0x10(%ebp),%eax
10b528: 50 push %eax
10b529: 56 push %esi
10b52a: 53 push %ebx
10b52b: e8 98 fd ff ff call 10b2c8 <_Thread_queue_Enqueue_priority>
10b530: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10b533: 57 push %edi
10b534: 9d popf
}
}
10b535: 8d 65 f4 lea -0xc(%ebp),%esp
10b538: 5b pop %ebx
10b539: 5e pop %esi
10b53a: 5f pop %edi
10b53b: c9 leave
10b53c: c3 ret
0010b540 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored
)
{
10b540: 55 push %ebp
10b541: 89 e5 mov %esp,%ebp
10b543: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10b546: 8d 45 fc lea -0x4(%ebp),%eax
10b549: 50 push %eax
10b54a: ff 75 08 pushl 0x8(%ebp)
10b54d: e8 ba f8 ff ff call 10ae0c <_Thread_Get>
switch ( location ) {
10b552: 83 c4 10 add $0x10,%esp
10b555: 83 7d fc 00 cmpl $0x0,-0x4(%ebp)
10b559: 75 17 jne 10b572 <_Thread_queue_Timeout+0x32><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
10b55b: 83 ec 0c sub $0xc,%esp
10b55e: 50 push %eax
10b55f: e8 78 27 00 00 call 10dcdc <_Thread_queue_Process_timeout>
10b564: a1 e0 ca 11 00 mov 0x11cae0,%eax
10b569: 48 dec %eax
10b56a: a3 e0 ca 11 00 mov %eax,0x11cae0
10b56f: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10b572: c9 leave
10b573: c3 ret
00113240 <_Timer_Server_body>:
* @param[in] ignored is the the task argument that is ignored
*/
Thread _Timer_Server_body(
uint32_t ignored
)
{
113240: 55 push %ebp
113241: 89 e5 mov %esp,%ebp
113243: 57 push %edi
113244: 56 push %esi
113245: 53 push %ebx
113246: 83 ec 1c sub $0x1c,%esp
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
113249: 8d 75 e8 lea -0x18(%ebp),%esi
11324c: 8d 45 ec lea -0x14(%ebp),%eax
11324f: 89 45 e0 mov %eax,-0x20(%ebp)
113252: 89 45 e8 mov %eax,-0x18(%ebp)
113255: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
11325c: 89 75 f0 mov %esi,-0x10(%ebp)
/*
* Initialize the "last time" markers to indicate the timer that
* the server was initiated.
*/
_Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot;
11325f: a1 30 29 13 00 mov 0x132930,%eax
113264: a3 64 27 13 00 mov %eax,0x132764
_Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch;
113269: a1 70 28 13 00 mov 0x132870,%eax
11326e: a3 60 27 13 00 mov %eax,0x132760
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
113273: a1 e0 27 13 00 mov 0x1327e0,%eax
113278: 40 inc %eax
113279: a3 e0 27 13 00 mov %eax,0x1327e0
/*
* Insert the timers that were inserted before we got to run.
* This should be done with dispatching disabled.
*/
_Thread_Disable_dispatch();
_Timer_Server_process_insertions();
11327e: e8 6d ff ff ff call 1131f0 <_Timer_Server_process_insertions>
_Thread_Enable_dispatch();
113283: e8 90 24 00 00 call 115718 <_Thread_Enable_dispatch>
ticks = snapshot - _Timer_Server_ticks_last_time;
else
ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot;
_Timer_Server_ticks_last_time = snapshot;
_Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire );
113288: 89 f7 mov %esi,%edi
11328a: a1 e0 27 13 00 mov 0x1327e0,%eax
11328f: 40 inc %eax
113290: a3 e0 27 13 00 mov %eax,0x1327e0
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( _Timer_Server, STATES_DELAYING );
113295: 51 push %ecx
113296: 51 push %ecx
113297: 6a 08 push $0x8
113299: ff 35 18 2b 13 00 pushl 0x132b18
11329f: e8 90 2d 00 00 call 116034 <_Thread_Set_state>
* to obtain the size of
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
1132a4: 8b 15 54 27 13 00 mov 0x132754,%edx
_Timer_Server_reset_ticks_timer();
1132aa: 83 c4 10 add $0x10,%esp
1132ad: 81 fa 58 27 13 00 cmp $0x132758,%edx
1132b3: 74 1e je 1132d3 <_Timer_Server_body+0x93>
1132b5: a1 18 2b 13 00 mov 0x132b18,%eax
Heap_Control *the_heap,
1132ba: 8b 52 10 mov 0x10(%edx),%edx
1132bd: 89 50 54 mov %edx,0x54(%eax)
void *starting_address,
size_t *size
1132c0: 52 push %edx
1132c1: 52 push %edx
1132c2: 83 c0 48 add $0x48,%eax
1132c5: 50 push %eax
1132c6: 68 c0 28 13 00 push $0x1328c0
1132cb: e8 64 35 00 00 call 116834 <_Watchdog_Insert>
1132d0: 83 c4 10 add $0x10,%esp
* to obtain the size of
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
1132d3: a1 68 27 13 00 mov 0x132768,%eax
_Timer_Server_reset_seconds_timer();
1132d8: 3d 6c 27 13 00 cmp $0x13276c,%eax
1132dd: 74 1c je 1132fb <_Timer_Server_body+0xbb>
* @return TRUE if successfully able to resize the block.
* FALSE if the block can't be resized in place.
*/
bool _Protected_heap_Resize_block(
Heap_Control *the_heap,
void *starting_address,
1132df: 8b 40 10 mov 0x10(%eax),%eax
1132e2: a3 8c 27 13 00 mov %eax,0x13278c
size_t size
);
1132e7: 50 push %eax
1132e8: 50 push %eax
1132e9: 68 80 27 13 00 push $0x132780
1132ee: 68 b4 28 13 00 push $0x1328b4
1132f3: e8 3c 35 00 00 call 116834 <_Watchdog_Insert>
1132f8: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
1132fb: e8 18 24 00 00 call 115718 <_Thread_Enable_dispatch>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
113300: a1 e0 27 13 00 mov 0x1327e0,%eax
113305: 40 inc %eax
113306: a3 e0 27 13 00 mov %eax,0x1327e0
/*
* At this point, at least one of the timers this task relies
* upon has fired. Stop them both while we process any outstanding
* timers. Before we block, we will restart them.
*/
_Timer_Server_stop_ticks_timer();
11330b: 83 ec 0c sub $0xc,%esp
11330e: a1 18 2b 13 00 mov 0x132b18,%eax
113313: 83 c0 48 add $0x48,%eax
113316: 50 push %eax
113317: e8 30 36 00 00 call 11694c <_Watchdog_Remove>
_Timer_Server_stop_seconds_timer();
11331c: c7 04 24 80 27 13 00 movl $0x132780,(%esp)
113323: e8 24 36 00 00 call 11694c <_Watchdog_Remove>
)
{
Watchdog_Interval snapshot;
Watchdog_Interval ticks;
snapshot = _Watchdog_Ticks_since_boot;
113328: 8b 15 30 29 13 00 mov 0x132930,%edx
if ( snapshot >= _Timer_Server_ticks_last_time )
11332e: a1 64 27 13 00 mov 0x132764,%eax
113333: 83 c4 10 add $0x10,%esp
113336: 39 c2 cmp %eax,%edx
113338: 72 08 jb 113342 <_Timer_Server_body+0x102><== NEVER TAKEN
ticks = snapshot - _Timer_Server_ticks_last_time;
11333a: 89 d1 mov %edx,%ecx
11333c: 29 c1 sub %eax,%ecx
11333e: 89 c8 mov %ecx,%eax
113340: eb 04 jmp 113346 <_Timer_Server_body+0x106>
else
ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot;
113342: f7 d0 not %eax <== NOT EXECUTED
113344: 01 d0 add %edx,%eax <== NOT EXECUTED
_Timer_Server_ticks_last_time = snapshot;
113346: 89 15 64 27 13 00 mov %edx,0x132764
_Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire );
11334c: 53 push %ebx
11334d: 57 push %edi
11334e: 50 push %eax
11334f: 68 54 27 13 00 push $0x132754
113354: e8 4b 34 00 00 call 1167a4 <_Watchdog_Adjust_to_chain>
/*
* Process the seconds chain. Start by checking that the Time
* of Day (TOD) has not been set backwards. If it has then
* we want to adjust the _Timer_Seconds_chain to indicate this.
*/
snapshot = _TOD_Seconds_since_epoch;
113359: 8b 1d 70 28 13 00 mov 0x132870,%ebx
if ( snapshot > _Timer_Server_seconds_last_time ) {
11335f: a1 60 27 13 00 mov 0x132760,%eax
113364: 83 c4 10 add $0x10,%esp
113367: 39 c3 cmp %eax,%ebx
113369: 76 13 jbe 11337e <_Timer_Server_body+0x13e>
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
ticks = snapshot - _Timer_Server_seconds_last_time;
_Watchdog_Adjust_to_chain( &_Timer_Seconds_chain, ticks, to_fire );
11336b: 51 push %ecx
11336c: 57 push %edi
11336d: 89 da mov %ebx,%edx
11336f: 29 c2 sub %eax,%edx
113371: 52 push %edx
113372: 68 68 27 13 00 push $0x132768
113377: e8 28 34 00 00 call 1167a4 <_Watchdog_Adjust_to_chain>
11337c: eb 12 jmp 113390 <_Timer_Server_body+0x150>
} else if ( snapshot < _Timer_Server_seconds_last_time ) {
11337e: 73 13 jae 113393 <_Timer_Server_body+0x153>
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
ticks = _Timer_Server_seconds_last_time - snapshot;
_Watchdog_Adjust( &_Timer_Seconds_chain, WATCHDOG_BACKWARD, ticks );
113380: 52 push %edx
113381: 29 d8 sub %ebx,%eax
113383: 50 push %eax
113384: 6a 01 push $0x1
113386: 68 68 27 13 00 push $0x132768
11338b: e8 a8 33 00 00 call 116738 <_Watchdog_Adjust>
113390: 83 c4 10 add $0x10,%esp
}
_Timer_Server_seconds_last_time = snapshot;
113393: 89 1d 60 27 13 00 mov %ebx,0x132760
_Timer_Server_process_seconds_chain( &to_fire );
/*
* Insert the timers that have been requested to be inserted.
*/
_Timer_Server_process_insertions();
113399: e8 52 fe ff ff call 1131f0 <_Timer_Server_process_insertions>
/*
* Enable dispatching to process the set that are ready "to fire."
*/
_Thread_Enable_dispatch();
11339e: e8 75 23 00 00 call 115718 <_Thread_Enable_dispatch>
*/
while (1) {
Watchdog_Control *watch;
ISR_Level level;
_ISR_Disable( level );
1133a3: 9c pushf
1133a4: fa cli
1133a5: 59 pop %ecx
* to obtain the size of
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
1133a6: 8b 55 e8 mov -0x18(%ebp),%edx
1133a9: 3b 55 e0 cmp -0x20(%ebp),%edx
1133ac: 74 0c je 1133ba <_Timer_Server_body+0x17a>
1133ae: 8b 02 mov (%edx),%eax
1133b0: 89 45 e8 mov %eax,-0x18(%ebp)
1133b3: 89 70 04 mov %esi,0x4(%eax)
watch = (Watchdog_Control *) _Chain_Get_unprotected( &to_fire );
if ( watch == NULL ) {
1133b6: 85 d2 test %edx,%edx
1133b8: 75 07 jne 1133c1 <_Timer_Server_body+0x181><== ALWAYS TAKEN
_ISR_Enable( level );
1133ba: 51 push %ecx
1133bb: 9d popf
1133bc: e9 c9 fe ff ff jmp 11328a <_Timer_Server_body+0x4a>
break;
}
watch->state = WATCHDOG_INACTIVE;
1133c1: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
_ISR_Enable( level );
1133c8: 51 push %ecx
1133c9: 9d popf
(*watch->routine)( watch->id, watch->user_data );
1133ca: 53 push %ebx
1133cb: 53 push %ebx
1133cc: ff 72 24 pushl 0x24(%edx)
1133cf: ff 72 20 pushl 0x20(%edx)
1133d2: ff 52 1c call *0x1c(%edx)
1133d5: 83 c4 10 add $0x10,%esp
1133d8: eb c9 jmp 1133a3 <_Timer_Server_body+0x163>
001131f0 <_Timer_Server_process_insertions>:
* onto one of the Timer Server chains.
*
* @note It is only to be called from the Timer Server task.
*/
static void _Timer_Server_process_insertions(void)
{
1131f0: 55 push %ebp
1131f1: 89 e5 mov %esp,%ebp
1131f3: 83 ec 08 sub $0x8,%esp
Timer_Control *the_timer;
while ( 1 ) {
the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted );
1131f6: 83 ec 0c sub $0xc,%esp
1131f9: 68 74 27 13 00 push $0x132774
1131fe: e8 05 08 00 00 call 113a08 <_Chain_Get>
if ( the_timer == NULL )
113203: 83 c4 10 add $0x10,%esp
113206: 85 c0 test %eax,%eax
113208: 74 34 je 11323e <_Timer_Server_process_insertions+0x4e>
break;
if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
11320a: 8b 50 38 mov 0x38(%eax),%edx
11320d: 83 fa 01 cmp $0x1,%edx
113210: 75 0d jne 11321f <_Timer_Server_process_insertions+0x2f>
_Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker );
113212: 51 push %ecx
113213: 51 push %ecx
113214: 83 c0 10 add $0x10,%eax
113217: 50 push %eax
113218: 68 54 27 13 00 push $0x132754
11321d: eb 10 jmp 11322f <_Timer_Server_process_insertions+0x3f>
} else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
11321f: 83 fa 03 cmp $0x3,%edx
113222: 75 13 jne 113237 <_Timer_Server_process_insertions+0x47><== NEVER TAKEN
_Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker );
113224: 52 push %edx
113225: 52 push %edx
113226: 83 c0 10 add $0x10,%eax
113229: 50 push %eax
11322a: 68 68 27 13 00 push $0x132768
11322f: e8 00 36 00 00 call 116834 <_Watchdog_Insert>
113234: 83 c4 10 add $0x10,%esp
}
/*
* Insert the timers that have been requested to be inserted.
*/
_Timer_Server_process_insertions();
113237: e8 b4 ff ff ff call 1131f0 <_Timer_Server_process_insertions>
11323c: eb b8 jmp 1131f6 <_Timer_Server_process_insertions+0x6>
}
}
11323e: c9 leave
11323f: c3 ret
0010ce64 <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
10ce64: 55 push %ebp
10ce65: 89 e5 mov %esp,%ebp
10ce67: 57 push %edi
10ce68: 56 push %esi
10ce69: 53 push %ebx
10ce6a: 83 ec 1c sub $0x1c,%esp
10ce6d: 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;
10ce70: 8b 18 mov (%eax),%ebx
left += lhs->tv_nsec;
10ce72: 8b 40 04 mov 0x4(%eax),%eax
10ce75: 89 45 e4 mov %eax,-0x1c(%ebp)
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
10ce78: b8 00 ca 9a 3b mov $0x3b9aca00,%eax
10ce7d: 8b 4d 0c mov 0xc(%ebp),%ecx
10ce80: f7 29 imull (%ecx)
10ce82: 89 c6 mov %eax,%esi
10ce84: 89 d7 mov %edx,%edi
right += rhs->tv_nsec;
10ce86: 8b 41 04 mov 0x4(%ecx),%eax
10ce89: 99 cltd
10ce8a: 01 c6 add %eax,%esi
10ce8c: 11 d7 adc %edx,%edi
if ( right == 0 ) {
10ce8e: 89 f8 mov %edi,%eax
10ce90: 09 f0 or %esi,%eax
10ce92: 75 14 jne 10cea8 <_Timespec_Divide+0x44> <== ALWAYS TAKEN
*ival_percentage = 0;
10ce94: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
10ce97: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED
*fval_percentage = 0;
10ce9d: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED
10cea0: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED
10cea6: eb 70 jmp 10cf18 <_Timespec_Divide+0xb4> <== NOT EXECUTED
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
10cea8: b8 00 ca 9a 3b mov $0x3b9aca00,%eax
10cead: f7 eb imul %ebx
10ceaf: 89 45 e8 mov %eax,-0x18(%ebp)
10ceb2: 89 55 ec mov %edx,-0x14(%ebp)
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
10ceb5: 8b 45 e4 mov -0x1c(%ebp),%eax
10ceb8: 99 cltd
10ceb9: 01 45 e8 add %eax,-0x18(%ebp)
10cebc: 11 55 ec adc %edx,-0x14(%ebp)
10cebf: 69 5d ec a0 86 01 00 imul $0x186a0,-0x14(%ebp),%ebx
10cec6: b9 a0 86 01 00 mov $0x186a0,%ecx
10cecb: 8b 45 e8 mov -0x18(%ebp),%eax
10cece: f7 e1 mul %ecx
10ced0: 89 45 d8 mov %eax,-0x28(%ebp)
10ced3: 01 da add %ebx,%edx
10ced5: 89 55 dc mov %edx,-0x24(%ebp)
10ced8: 57 push %edi
10ced9: 56 push %esi
10ceda: ff 75 dc pushl -0x24(%ebp)
10cedd: ff 75 d8 pushl -0x28(%ebp)
10cee0: e8 73 a4 00 00 call 117358 <__udivdi3>
10cee5: 83 c4 10 add $0x10,%esp
10cee8: 89 c3 mov %eax,%ebx
10ceea: 89 d6 mov %edx,%esi
*ival_percentage = answer / 1000;
10ceec: 6a 00 push $0x0
10ceee: 68 e8 03 00 00 push $0x3e8
10cef3: 52 push %edx
10cef4: 50 push %eax
10cef5: e8 5e a4 00 00 call 117358 <__udivdi3>
10cefa: 83 c4 10 add $0x10,%esp
10cefd: 8b 4d 10 mov 0x10(%ebp),%ecx
10cf00: 89 01 mov %eax,(%ecx)
*fval_percentage = answer % 1000;
10cf02: 6a 00 push $0x0
10cf04: 68 e8 03 00 00 push $0x3e8
10cf09: 56 push %esi
10cf0a: 53 push %ebx
10cf0b: e8 54 a5 00 00 call 117464 <__umoddi3>
10cf10: 83 c4 10 add $0x10,%esp
10cf13: 8b 4d 14 mov 0x14(%ebp),%ecx
10cf16: 89 01 mov %eax,(%ecx)
}
10cf18: 8d 65 f4 lea -0xc(%ebp),%esp
10cf1b: 5b pop %ebx
10cf1c: 5e pop %esi
10cf1d: 5f pop %edi
10cf1e: c9 leave
10cf1f: c3 ret
0010d1ac <_Timespec_Greater_than>:
bool _Timespec_Greater_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
10d1ac: 55 push %ebp
10d1ad: 89 e5 mov %esp,%ebp
10d1af: 53 push %ebx
10d1b0: 8b 4d 08 mov 0x8(%ebp),%ecx
10d1b3: 8b 5d 0c mov 0xc(%ebp),%ebx
if ( lhs->tv_sec > rhs->tv_sec )
10d1b6: 8b 03 mov (%ebx),%eax
10d1b8: b2 01 mov $0x1,%dl
10d1ba: 39 01 cmp %eax,(%ecx)
10d1bc: 7f 0f jg 10d1cd <_Timespec_Greater_than+0x21><== NEVER TAKEN
return TRUE;
if ( lhs->tv_sec < rhs->tv_sec )
10d1be: 7d 04 jge 10d1c4 <_Timespec_Greater_than+0x18><== ALWAYS TAKEN
10d1c0: 31 d2 xor %edx,%edx <== NOT EXECUTED
10d1c2: eb 09 jmp 10d1cd <_Timespec_Greater_than+0x21><== NOT EXECUTED
return FALSE;
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec > rhs->tv_nsec )
10d1c4: 8b 41 04 mov 0x4(%ecx),%eax
10d1c7: 3b 43 04 cmp 0x4(%ebx),%eax
10d1ca: 0f 9f c2 setg %dl
return TRUE;
return FALSE;
}
10d1cd: 88 d0 mov %dl,%al
10d1cf: 5b pop %ebx
10d1d0: c9 leave
10d1d1: c3 ret
0010d1d4 <_Timespec_Less_than>:
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
10d1d4: 55 push %ebp
10d1d5: 89 e5 mov %esp,%ebp
10d1d7: 53 push %ebx
10d1d8: 8b 4d 08 mov 0x8(%ebp),%ecx
10d1db: 8b 5d 0c mov 0xc(%ebp),%ebx
if ( lhs->tv_sec < rhs->tv_sec )
10d1de: 8b 03 mov (%ebx),%eax
10d1e0: b2 01 mov $0x1,%dl
10d1e2: 39 01 cmp %eax,(%ecx)
10d1e4: 7c 0f jl 10d1f5 <_Timespec_Less_than+0x21>
return TRUE;
if ( lhs->tv_sec > rhs->tv_sec )
10d1e6: 7e 04 jle 10d1ec <_Timespec_Less_than+0x18><== ALWAYS TAKEN
10d1e8: 31 d2 xor %edx,%edx <== NOT EXECUTED
10d1ea: eb 09 jmp 10d1f5 <_Timespec_Less_than+0x21><== NOT EXECUTED
return FALSE;
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec < rhs->tv_nsec )
10d1ec: 8b 41 04 mov 0x4(%ecx),%eax
10d1ef: 3b 43 04 cmp 0x4(%ebx),%eax
10d1f2: 0f 9c c2 setl %dl
return TRUE;
return FALSE;
}
10d1f5: 88 d0 mov %dl,%al
10d1f7: 5b pop %ebx
10d1f8: c9 leave
10d1f9: c3 ret
0010de1c <_User_extensions_Add_API_set>:
*/
void _User_extensions_Add_API_set (
User_extensions_Control *the_extension
)
{
10de1c: 55 push %ebp
10de1d: 89 e5 mov %esp,%ebp
10de1f: 53 push %ebx
10de20: 83 ec 0c sub $0xc,%esp
10de23: 8b 5d 08 mov 0x8(%ebp),%ebx
_Chain_Append( &_User_extensions_List, &the_extension->Node );
10de26: 53 push %ebx
10de27: 68 f8 cc 11 00 push $0x11ccf8
10de2c: e8 1b bc ff ff call 109a4c <_Chain_Append>
/*
* If a switch handler is present, append it to the switch chain.
*/
if ( the_extension->Callouts.thread_switch != NULL ) {
10de31: 8b 43 24 mov 0x24(%ebx),%eax
10de34: 83 c4 10 add $0x10,%esp
10de37: 85 c0 test %eax,%eax
10de39: 74 16 je 10de51 <_User_extensions_Add_API_set+0x35><== NEVER TAKEN
the_extension->Switch.thread_switch = the_extension->Callouts.thread_switch;
10de3b: 89 43 10 mov %eax,0x10(%ebx)
_Chain_Append(
10de3e: 50 push %eax
10de3f: 50 push %eax
10de40: 8d 43 08 lea 0x8(%ebx),%eax
10de43: 50 push %eax
10de44: 68 e4 ca 11 00 push $0x11cae4
10de49: e8 fe bb ff ff call 109a4c <_Chain_Append>
10de4e: 83 c4 10 add $0x10,%esp
&_User_extensions_Switches_list, &the_extension->Switch.Node );
}
}
10de51: 8b 5d fc mov -0x4(%ebp),%ebx
10de54: c9 leave
10de55: c3 ret
0010d480 <_User_extensions_Remove_set>:
*/
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
10d480: 55 push %ebp
10d481: 89 e5 mov %esp,%ebp
10d483: 53 push %ebx
10d484: 83 ec 10 sub $0x10,%esp
10d487: 8b 5d 08 mov 0x8(%ebp),%ebx
_Chain_Extract( &the_extension->Node );
10d48a: 53 push %ebx
10d48b: e8 38 1d 00 00 call 10f1c8 <_Chain_Extract>
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
10d490: 83 c4 10 add $0x10,%esp
10d493: 83 7b 24 00 cmpl $0x0,0x24(%ebx)
10d497: 74 0f je 10d4a8 <_User_extensions_Remove_set+0x28><== ALWAYS TAKEN
_Chain_Extract( &the_extension->Switch.Node );
10d499: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED
10d49c: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
10d49f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10d4a2: 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 );
10d4a3: e9 20 1d 00 00 jmp 10f1c8 <_Chain_Extract> <== NOT EXECUTED
}
10d4a8: 8b 5d fc mov -0x4(%ebp),%ebx
10d4ab: c9 leave
10d4ac: c3 ret
0010baa8 <_User_extensions_Thread_create>:
*/
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
10baa8: 55 push %ebp
10baa9: 89 e5 mov %esp,%ebp
10baab: 56 push %esi
10baac: 53 push %ebx
10baad: 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 ;
10bab0: 8b 1d f8 cc 11 00 mov 0x11ccf8,%ebx
10bab6: eb 1b jmp 10bad3 <_User_extensions_Thread_create+0x2b>
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
10bab8: 8b 43 14 mov 0x14(%ebx),%eax
10babb: 85 c0 test %eax,%eax
10babd: 74 12 je 10bad1 <_User_extensions_Thread_create+0x29>
status = (*the_extension->Callouts.thread_create)(
10babf: 52 push %edx
10bac0: 52 push %edx
10bac1: 56 push %esi
10bac2: ff 35 a0 cb 11 00 pushl 0x11cba0
10bac8: ff d0 call *%eax
_Thread_Executing,
the_thread
);
if ( !status )
10baca: 83 c4 10 add $0x10,%esp
10bacd: 84 c0 test %al,%al
10bacf: 74 0c je 10badd <_User_extensions_Thread_create+0x35><== 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 ) {
10bad1: 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 ) ;
10bad3: 81 fb fc cc 11 00 cmp $0x11ccfc,%ebx
10bad9: 75 dd jne 10bab8 <_User_extensions_Thread_create+0x10>
10badb: b0 01 mov $0x1,%al
return FALSE;
}
}
return TRUE;
}
10badd: 8d 65 f8 lea -0x8(%ebp),%esp
10bae0: 5b pop %ebx
10bae1: 5e pop %esi
10bae2: c9 leave
10bae3: c3 ret
0010ba39 <_User_extensions_Thread_exitted>:
*/
void _User_extensions_Thread_exitted (
Thread_Control *executing
)
{
10ba39: 55 push %ebp
10ba3a: 89 e5 mov %esp,%ebp
10ba3c: 56 push %esi
10ba3d: 53 push %ebx
10ba3e: 8b 75 08 mov 0x8(%ebp),%esi
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
10ba41: 8b 1d 00 cd 11 00 mov 0x11cd00,%ebx
10ba47: eb 13 jmp 10ba5c <_User_extensions_Thread_exitted+0x23>
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_exitted != NULL )
10ba49: 8b 43 2c mov 0x2c(%ebx),%eax
10ba4c: 85 c0 test %eax,%eax
10ba4e: 74 09 je 10ba59 <_User_extensions_Thread_exitted+0x20>
(*the_extension->Callouts.thread_exitted)( executing );
10ba50: 83 ec 0c sub $0xc,%esp
10ba53: 56 push %esi
10ba54: ff d0 call *%eax
10ba56: 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 ) {
10ba59: 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 ) ;
10ba5c: 81 fb f8 cc 11 00 cmp $0x11ccf8,%ebx
10ba62: 75 e5 jne 10ba49 <_User_extensions_Thread_exitted+0x10>
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_exitted != NULL )
(*the_extension->Callouts.thread_exitted)( executing );
}
}
10ba64: 8d 65 f8 lea -0x8(%ebp),%esp
10ba67: 5b pop %ebx
10ba68: 5e pop %esi
10ba69: c9 leave
10ba6a: c3 ret
0010d1c0 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
10d1c0: 55 push %ebp
10d1c1: 89 e5 mov %esp,%ebp
10d1c3: 57 push %edi
10d1c4: 56 push %esi
10d1c5: 53 push %ebx
10d1c6: 83 ec 0c sub $0xc,%esp
10d1c9: 8b 7d 08 mov 0x8(%ebp),%edi
10d1cc: 8b 4d 0c mov 0xc(%ebp),%ecx
10d1cf: 8b 75 10 mov 0x10(%ebp),%esi
ISR_Level level;
_ISR_Disable( level );
10d1d2: 9c pushf
10d1d3: fa cli
10d1d4: 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(
10d1d5: 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
10d1d7: 8d 5f 04 lea 0x4(%edi),%ebx
10d1da: 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 ) ) {
10d1dd: 39 d8 cmp %ebx,%eax
10d1df: 74 41 je 10d222 <_Watchdog_Adjust+0x62>
switch ( direction ) {
10d1e1: 85 c9 test %ecx,%ecx
10d1e3: 74 39 je 10d21e <_Watchdog_Adjust+0x5e>
10d1e5: 49 dec %ecx
10d1e6: 75 3a jne 10d222 <_Watchdog_Adjust+0x62> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
10d1e8: 01 70 10 add %esi,0x10(%eax)
10d1eb: eb 35 jmp 10d222 <_Watchdog_Adjust+0x62>
10d1ed: 8b 07 mov (%edi),%eax
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
10d1ef: 8b 58 10 mov 0x10(%eax),%ebx
10d1f2: 39 de cmp %ebx,%esi
10d1f4: 73 07 jae 10d1fd <_Watchdog_Adjust+0x3d>
_Watchdog_First( header )->delta_interval -= units;
10d1f6: 29 f3 sub %esi,%ebx
10d1f8: 89 58 10 mov %ebx,0x10(%eax)
10d1fb: eb 25 jmp 10d222 <_Watchdog_Adjust+0x62>
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
10d1fd: c7 40 10 01 00 00 00 movl $0x1,0x10(%eax)
_ISR_Enable( level );
10d204: 52 push %edx
10d205: 9d popf
_Watchdog_Tickle( header );
10d206: 83 ec 0c sub $0xc,%esp
10d209: 57 push %edi
10d20a: e8 9d 01 00 00 call 10d3ac <_Watchdog_Tickle>
_ISR_Disable( level );
10d20f: 9c pushf
10d210: fa cli
10d211: 5a pop %edx
if ( _Chain_Is_empty( header ) )
10d212: 83 c4 10 add $0x10,%esp
10d215: 8b 45 f0 mov -0x10(%ebp),%eax
10d218: 39 07 cmp %eax,(%edi)
10d21a: 74 06 je 10d222 <_Watchdog_Adjust+0x62>
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
10d21c: 29 de sub %ebx,%esi
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
10d21e: 85 f6 test %esi,%esi
10d220: 75 cb jne 10d1ed <_Watchdog_Adjust+0x2d> <== ALWAYS TAKEN
}
break;
}
}
_ISR_Enable( level );
10d222: 52 push %edx
10d223: 9d popf
}
10d224: 8d 65 f4 lea -0xc(%ebp),%esp
10d227: 5b pop %ebx
10d228: 5e pop %esi
10d229: 5f pop %edi
10d22a: c9 leave
10d22b: c3 ret
001167a4 <_Watchdog_Adjust_to_chain>:
Chain_Control *header,
Watchdog_Interval units_arg,
Chain_Control *to_fire
)
{
1167a4: 55 push %ebp
1167a5: 89 e5 mov %esp,%ebp
1167a7: 57 push %edi
1167a8: 56 push %esi
1167a9: 53 push %ebx
1167aa: 83 ec 0c sub $0xc,%esp
1167ad: 8b 75 08 mov 0x8(%ebp),%esi
1167b0: 8b 45 0c mov 0xc(%ebp),%eax
Watchdog_Interval units = units_arg;
ISR_Level level;
Chain_Node *node;
if ( !units ) {
1167b3: 85 c0 test %eax,%eax
1167b5: 74 74 je 11682b <_Watchdog_Adjust_to_chain+0x87>
return;
}
_ISR_Disable( level );
1167b7: 9c pushf
1167b8: fa cli
1167b9: 8f 45 ec popl -0x14(%ebp)
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
1167bc: 8d 7e 04 lea 0x4(%esi),%edi
if ( !_Chain_Is_empty( header ) ) {
1167bf: 39 3e cmp %edi,(%esi)
1167c1: 74 64 je 116827 <_Watchdog_Adjust_to_chain+0x83>
1167c3: 8b 55 10 mov 0x10(%ebp),%edx
1167c6: 83 c2 04 add $0x4,%edx
1167c9: 89 55 f0 mov %edx,-0x10(%ebp)
1167cc: 89 c3 mov %eax,%ebx
1167ce: 8b 06 mov (%esi),%eax
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
1167d0: 8b 48 10 mov 0x10(%eax),%ecx
1167d3: 39 cb cmp %ecx,%ebx
1167d5: 73 07 jae 1167de <_Watchdog_Adjust_to_chain+0x3a>
_Watchdog_First( header )->delta_interval -= units;
1167d7: 29 d9 sub %ebx,%ecx
1167d9: 89 48 10 mov %ecx,0x10(%eax)
1167dc: eb 49 jmp 116827 <_Watchdog_Adjust_to_chain+0x83>
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 0;
1167de: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax)
* to obtain the size of
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
1167e5: 8b 16 mov (%esi),%edx
1167e7: 39 fa cmp %edi,%edx
1167e9: 75 04 jne 1167ef <_Watchdog_Adjust_to_chain+0x4b><== ALWAYS TAKEN
1167eb: 31 d2 xor %edx,%edx <== NOT EXECUTED
1167ed: eb 07 jmp 1167f6 <_Watchdog_Adjust_to_chain+0x52><== NOT EXECUTED
1167ef: 8b 02 mov (%edx),%eax
1167f1: 89 06 mov %eax,(%esi)
1167f3: 89 70 04 mov %esi,0x4(%eax)
1167f6: 8b 45 f0 mov -0x10(%ebp),%eax
1167f9: 89 02 mov %eax,(%edx)
1167fb: 8b 45 10 mov 0x10(%ebp),%eax
1167fe: 8b 40 08 mov 0x8(%eax),%eax
116801: 89 45 e8 mov %eax,-0x18(%ebp)
116804: 8b 45 10 mov 0x10(%ebp),%eax
116807: 89 50 08 mov %edx,0x8(%eax)
11680a: 8b 45 e8 mov -0x18(%ebp),%eax
11680d: 89 10 mov %edx,(%eax)
11680f: 89 42 04 mov %eax,0x4(%edx)
do {
node = _Chain_Get_unprotected( header );
_Chain_Append_unprotected( to_fire, node );
_ISR_Flash( level );
116812: ff 75 ec pushl -0x14(%ebp)
116815: 9d popf
116816: 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(
116817: 8b 06 mov (%esi),%eax
} while ( !_Chain_Is_empty( header ) &&
_Watchdog_First( header )->delta_interval == 0 );
116819: 39 f8 cmp %edi,%eax
11681b: 74 0a je 116827 <_Watchdog_Adjust_to_chain+0x83>
11681d: 83 78 10 00 cmpl $0x0,0x10(%eax)
116821: 74 c2 je 1167e5 <_Watchdog_Adjust_to_chain+0x41>
return;
}
_ISR_Disable( level );
if ( !_Chain_Is_empty( header ) ) {
while ( units ) {
116823: 29 cb sub %ecx,%ebx
116825: 75 a7 jne 1167ce <_Watchdog_Adjust_to_chain+0x2a><== NEVER TAKEN
break;
}
}
}
_ISR_Enable( level );
116827: ff 75 ec pushl -0x14(%ebp)
11682a: 9d popf
}
11682b: 83 c4 0c add $0xc,%esp
11682e: 5b pop %ebx
11682f: 5e pop %esi
116830: 5f pop %edi
116831: c9 leave
116832: c3 ret
0010bb88 <_Watchdog_Insert>:
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
10bb88: 55 push %ebp
10bb89: 89 e5 mov %esp,%ebp
10bb8b: 57 push %edi
10bb8c: 56 push %esi
10bb8d: 53 push %ebx
10bb8e: 83 ec 04 sub $0x4,%esp
10bb91: 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;
10bb94: 8b 3d 7c cb 11 00 mov 0x11cb7c,%edi
_ISR_Disable( level );
10bb9a: 9c pushf
10bb9b: fa cli
10bb9c: 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 ) {
10bb9f: 83 7e 08 00 cmpl $0x0,0x8(%esi)
10bba3: 74 09 je 10bbae <_Watchdog_Insert+0x26> <== ALWAYS TAKEN
_ISR_Enable( level );
10bba5: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED
10bba8: 9d popf <== NOT EXECUTED
10bba9: e9 89 00 00 00 jmp 10bc37 <_Watchdog_Insert+0xaf> <== NOT EXECUTED
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
10bbae: c7 46 08 01 00 00 00 movl $0x1,0x8(%esi)
_Watchdog_Sync_count++;
10bbb5: a1 2c cc 11 00 mov 0x11cc2c,%eax
10bbba: 40 inc %eax
10bbbb: a3 2c cc 11 00 mov %eax,0x11cc2c
restart:
delta_interval = the_watchdog->initial;
10bbc0: 8b 4e 0c mov 0xc(%esi),%ecx
* cache *header!!
*
* Till Straumann, 7/2003 (gcc-3.2.2 -O4 on powerpc)
*
*/
for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ;
10bbc3: 8b 45 08 mov 0x8(%ebp),%eax
10bbc6: 8b 18 mov (%eax),%ebx
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
10bbc8: 85 c9 test %ecx,%ecx
10bbca: 74 35 je 10bc01 <_Watchdog_Insert+0x79>
10bbcc: 83 3b 00 cmpl $0x0,(%ebx)
10bbcf: 74 30 je 10bc01 <_Watchdog_Insert+0x79>
break;
if ( delta_interval < after->delta_interval ) {
10bbd1: 8b 53 10 mov 0x10(%ebx),%edx
10bbd4: 39 d1 cmp %edx,%ecx
10bbd6: 73 07 jae 10bbdf <_Watchdog_Insert+0x57>
after->delta_interval -= delta_interval;
10bbd8: 29 ca sub %ecx,%edx
10bbda: 89 53 10 mov %edx,0x10(%ebx)
10bbdd: eb 22 jmp 10bc01 <_Watchdog_Insert+0x79>
* used around this flash point allowed interrupts to execute
* which violated the design assumptions. The critical section
* mechanism used here WAS redesigned to address this.
*/
_ISR_Flash( level );
10bbdf: ff 75 f0 pushl -0x10(%ebp)
10bbe2: 9d popf
10bbe3: fa cli
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
10bbe4: 83 7e 08 01 cmpl $0x1,0x8(%esi)
10bbe8: 75 38 jne 10bc22 <_Watchdog_Insert+0x9a> <== NEVER TAKEN
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
10bbea: a1 9c cb 11 00 mov 0x11cb9c,%eax
10bbef: 39 f8 cmp %edi,%eax
10bbf1: 76 08 jbe 10bbfb <_Watchdog_Insert+0x73>
_Watchdog_Sync_level = insert_isr_nest_level;
10bbf3: 89 3d 9c cb 11 00 mov %edi,0x11cb9c
10bbf9: eb c5 jmp 10bbc0 <_Watchdog_Insert+0x38>
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
10bbfb: 29 d1 sub %edx,%ecx
);
#ifdef __cplusplus
}
#endif
10bbfd: 8b 1b mov (%ebx),%ebx
10bbff: eb c7 jmp 10bbc8 <_Watchdog_Insert+0x40>
* @param[in] starting_address is the starting address of the memory
* to add to the heap
* @param[in] size is the size in bytes of the memory area to add
* @return a status indicating success or the reason for failure
*/
bool _Protected_heap_Extend(
10bc01: c7 46 08 02 00 00 00 movl $0x2,0x8(%esi)
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
10bc08: 89 4e 10 mov %ecx,0x10(%esi)
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
10bc0b: 8b 43 04 mov 0x4(%ebx),%eax
10bc0e: 89 46 04 mov %eax,0x4(%esi)
10bc11: 8b 10 mov (%eax),%edx
10bc13: 89 30 mov %esi,(%eax)
10bc15: 89 16 mov %edx,(%esi)
10bc17: 89 72 04 mov %esi,0x4(%edx)
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
10bc1a: a1 30 cc 11 00 mov 0x11cc30,%eax
10bc1f: 89 46 14 mov %eax,0x14(%esi)
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
10bc22: 89 3d 9c cb 11 00 mov %edi,0x11cb9c
_Watchdog_Sync_count--;
10bc28: a1 2c cc 11 00 mov 0x11cc2c,%eax
10bc2d: 48 dec %eax
10bc2e: a3 2c cc 11 00 mov %eax,0x11cc2c
_ISR_Enable( level );
10bc33: ff 75 f0 pushl -0x10(%ebp)
10bc36: 9d popf
}
10bc37: 58 pop %eax
10bc38: 5b pop %ebx
10bc39: 5e pop %esi
10bc3a: 5f pop %edi
10bc3b: c9 leave
10bc3c: c3 ret
0010bca0 <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
10bca0: 55 push %ebp
10bca1: 89 e5 mov %esp,%ebp
10bca3: 56 push %esi
10bca4: 53 push %ebx
10bca5: 8b 4d 08 mov 0x8(%ebp),%ecx
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
10bca8: 9c pushf
10bca9: fa cli
10bcaa: 5e pop %esi
previous_state = the_watchdog->state;
10bcab: 8b 59 08 mov 0x8(%ecx),%ebx
switch ( previous_state ) {
10bcae: 83 fb 01 cmp $0x1,%ebx
10bcb1: 74 09 je 10bcbc <_Watchdog_Remove+0x1c> <== NEVER TAKEN
10bcb3: 72 41 jb 10bcf6 <_Watchdog_Remove+0x56>
10bcb5: 83 fb 03 cmp $0x3,%ebx
10bcb8: 77 3c ja 10bcf6 <_Watchdog_Remove+0x56> <== NEVER TAKEN
10bcba: eb 09 jmp 10bcc5 <_Watchdog_Remove+0x25>
/*
* It is not actually on the chain so just change the state and
* the Insert operation we interrupted will be aborted.
*/
the_watchdog->state = WATCHDOG_INACTIVE;
10bcbc: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED
10bcc3: eb 31 jmp 10bcf6 <_Watchdog_Remove+0x56> <== NOT EXECUTED
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
10bcc5: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx)
);
#ifdef __cplusplus
}
#endif
10bccc: 8b 11 mov (%ecx),%edx
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
10bcce: 83 3a 00 cmpl $0x0,(%edx)
10bcd1: 74 06 je 10bcd9 <_Watchdog_Remove+0x39>
next_watchdog->delta_interval += the_watchdog->delta_interval;
10bcd3: 8b 41 10 mov 0x10(%ecx),%eax
10bcd6: 01 42 10 add %eax,0x10(%edx)
if ( _Watchdog_Sync_count )
10bcd9: a1 2c cc 11 00 mov 0x11cc2c,%eax
10bcde: 85 c0 test %eax,%eax
10bce0: 74 0a je 10bcec <_Watchdog_Remove+0x4c> <== ALWAYS TAKEN
_Watchdog_Sync_level = _ISR_Nest_level;
10bce2: a1 7c cb 11 00 mov 0x11cb7c,%eax <== NOT EXECUTED
10bce7: a3 9c cb 11 00 mov %eax,0x11cb9c <== NOT EXECUTED
10bcec: 8b 11 mov (%ecx),%edx
10bcee: 8b 41 04 mov 0x4(%ecx),%eax
10bcf1: 89 42 04 mov %eax,0x4(%edx)
10bcf4: 89 10 mov %edx,(%eax)
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
10bcf6: a1 30 cc 11 00 mov 0x11cc30,%eax
10bcfb: 89 41 18 mov %eax,0x18(%ecx)
_ISR_Enable( level );
10bcfe: 56 push %esi
10bcff: 9d popf
return( previous_state );
}
10bd00: 89 d8 mov %ebx,%eax
10bd02: 5b pop %ebx
10bd03: 5e pop %esi
10bd04: c9 leave
10bd05: c3 ret
0010bd08 <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
10bd08: 55 push %ebp
10bd09: 89 e5 mov %esp,%ebp
10bd0b: 57 push %edi
10bd0c: 56 push %esi
10bd0d: 53 push %ebx
10bd0e: 83 ec 0c sub $0xc,%esp
10bd11: 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 );
10bd14: 9c pushf
10bd15: fa cli
10bd16: 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(
10bd17: 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
10bd19: 8d 47 04 lea 0x4(%edi),%eax
10bd1c: 89 45 f0 mov %eax,-0x10(%ebp)
if ( _Chain_Is_empty( header ) )
10bd1f: 39 c2 cmp %eax,%edx
10bd21: 74 44 je 10bd67 <_Watchdog_Tickle+0x5f>
10bd23: 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) {
10bd25: 8b 42 10 mov 0x10(%edx),%eax
10bd28: 85 c0 test %eax,%eax
10bd2a: 74 08 je 10bd34 <_Watchdog_Tickle+0x2c> <== NEVER TAKEN
the_watchdog->delta_interval--;
10bd2c: 48 dec %eax
10bd2d: 89 42 10 mov %eax,0x10(%edx)
if ( the_watchdog->delta_interval != 0 )
10bd30: 85 c0 test %eax,%eax
10bd32: 75 33 jne 10bd67 <_Watchdog_Tickle+0x5f>
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
10bd34: 83 ec 0c sub $0xc,%esp
10bd37: 53 push %ebx
10bd38: e8 63 ff ff ff call 10bca0 <_Watchdog_Remove>
_ISR_Enable( level );
10bd3d: 56 push %esi
10bd3e: 9d popf
switch( watchdog_state ) {
10bd3f: 83 c4 10 add $0x10,%esp
10bd42: 83 f8 02 cmp $0x2,%eax
10bd45: 75 0e jne 10bd55 <_Watchdog_Tickle+0x4d> <== NEVER TAKEN
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
10bd47: 50 push %eax
10bd48: 50 push %eax
10bd49: ff 73 24 pushl 0x24(%ebx)
10bd4c: ff 73 20 pushl 0x20(%ebx)
10bd4f: ff 53 1c call *0x1c(%ebx)
10bd52: 83 c4 10 add $0x10,%esp
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
10bd55: 9c pushf
10bd56: fa cli
10bd57: 5e pop %esi
10bd58: 8b 07 mov (%edi),%eax
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
10bd5a: 3b 45 f0 cmp -0x10(%ebp),%eax
10bd5d: 74 08 je 10bd67 <_Watchdog_Tickle+0x5f>
10bd5f: 89 c3 mov %eax,%ebx
10bd61: 83 78 10 00 cmpl $0x0,0x10(%eax)
10bd65: eb cb jmp 10bd32 <_Watchdog_Tickle+0x2a>
leave:
_ISR_Enable(level);
10bd67: 56 push %esi
10bd68: 9d popf
}
10bd69: 8d 65 f4 lea -0xc(%ebp),%esp
10bd6c: 5b pop %ebx
10bd6d: 5e pop %esi
10bd6e: 5f pop %edi
10bd6f: c9 leave
10bd70: c3 ret
0010bdc6 <_Workspace_Handler_initialization>:
*/
void _Workspace_Handler_initialization(
void *starting_address,
size_t size
)
{
10bdc6: 55 push %ebp
10bdc7: 89 e5 mov %esp,%ebp
10bdc9: 57 push %edi
10bdca: 83 ec 14 sub $0x14,%esp
10bdcd: 8b 55 08 mov 0x8(%ebp),%edx
uint32_t memory_available;
if ( !starting_address || !_Addresses_Is_aligned( starting_address ) )
10bdd0: 85 d2 test %edx,%edx
10bdd2: 74 05 je 10bdd9 <_Workspace_Handler_initialization+0x13>
10bdd4: f6 c2 03 test $0x3,%dl
10bdd7: 74 05 je 10bdde <_Workspace_Handler_initialization+0x18><== ALWAYS TAKEN
_Internal_error_Occurred(
10bdd9: 51 push %ecx
10bdda: 6a 02 push $0x2
10bddc: eb 2e jmp 10be0c <_Workspace_Handler_initialization+0x46>
INTERNAL_ERROR_CORE,
TRUE,
INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS
);
if ( _Configuration_Table->do_zero_of_workspace )
10bdde: a1 78 cb 11 00 mov 0x11cb78,%eax
10bde3: 80 78 28 00 cmpb $0x0,0x28(%eax)
10bde7: 74 09 je 10bdf2 <_Workspace_Handler_initialization+0x2c><== ALWAYS TAKEN
memset( starting_address, 0, size );
10bde9: 31 c0 xor %eax,%eax
10bdeb: 89 d7 mov %edx,%edi <== NOT EXECUTED
10bded: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
10bdf0: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED
memory_available = _Heap_Initialize(
10bdf2: 6a 04 push $0x4
10bdf4: ff 75 0c pushl 0xc(%ebp)
10bdf7: 52 push %edx
10bdf8: 68 04 cb 11 00 push $0x11cb04
10bdfd: e8 8a e1 ff ff call 109f8c <_Heap_Initialize>
starting_address,
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
10be02: 83 c4 10 add $0x10,%esp
10be05: 85 c0 test %eax,%eax
10be07: 75 0c jne 10be15 <_Workspace_Handler_initialization+0x4f><== ALWAYS TAKEN
_Internal_error_Occurred(
10be09: 52 push %edx <== NOT EXECUTED
10be0a: 6a 03 push $0x3 <== NOT EXECUTED
10be0c: 6a 01 push $0x1
10be0e: 6a 00 push $0x0
10be10: e8 3f e3 ff ff call 10a154 <_Internal_error_Occurred>
INTERNAL_ERROR_CORE,
TRUE,
INTERNAL_ERROR_TOO_LITTLE_WORKSPACE
);
}
10be15: 8b 7d fc mov -0x4(%ebp),%edi
10be18: c9 leave
10be19: c3 ret
001062c2 <__assert>:
void __assert(
const char *file,
int line,
const char *failedexpr
)
{
1062c2: 55 push %ebp <== NOT EXECUTED
1062c3: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1062c5: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
__assert_func (file, line, NULL, failedexpr);
1062c8: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED
1062cb: 6a 00 push $0x0 <== NOT EXECUTED
1062cd: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
1062d0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
1062d3: e8 b0 ff ff ff call 106288 <__assert_func> <== NOT EXECUTED
1062d8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
1062db: c9 leave <== NOT EXECUTED
1062dc: c3 ret <== NOT EXECUTED
00106288 <__assert_func>:
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
106288: 55 push %ebp <== NOT EXECUTED
106289: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10628b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10628e: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
106291: ba 7d 67 11 00 mov $0x11677d,%edx <== NOT EXECUTED
106296: 85 c0 test %eax,%eax <== NOT EXECUTED
106298: 75 07 jne 1062a1 <__assert_func+0x19> <== NOT EXECUTED
10629a: ba 15 68 11 00 mov $0x116815,%edx <== NOT EXECUTED
10629f: 89 d0 mov %edx,%eax <== NOT EXECUTED
1062a1: 51 push %ecx <== NOT EXECUTED
1062a2: 51 push %ecx <== NOT EXECUTED
1062a3: 50 push %eax <== NOT EXECUTED
1062a4: 52 push %edx <== NOT EXECUTED
1062a5: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
1062a8: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
1062ab: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED
1062ae: 68 8a 67 11 00 push $0x11678a <== NOT EXECUTED
1062b3: e8 a6 0d 00 00 call 10705e <printk> <== NOT EXECUTED
file,
line,
(func) ? ", function: " : "",
(func) ? func : ""
);
rtems_fatal_error_occurred(0);
1062b8: 83 c4 14 add $0x14,%esp <== NOT EXECUTED
1062bb: 6a 00 push $0x0 <== NOT EXECUTED
1062bd: e8 ca 34 00 00 call 10978c <rtems_fatal_error_occurred><== NOT EXECUTED
00117766 <__kill>:
#endif
#endif
int __kill( pid_t pid, int sig )
{
117766: 55 push %ebp <== NOT EXECUTED
117767: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return 0;
}
117769: 31 c0 xor %eax,%eax <== NOT EXECUTED
11776b: c9 leave <== NOT EXECUTED
11776c: c3 ret <== NOT EXECUTED
00114cea <_exit>:
/*
* If the toolset uses init/fini sections, then we need to
* run the global destructors now.
*/
#if defined(__USE_INIT_FINI__)
_fini();
114cea: 55 push %ebp
114ceb: 89 e5 mov %esp,%ebp
114ced: 83 ec 08 sub $0x8,%esp
114cf0: e8 28 07 00 00 call 11541d <_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();
114cf5: e8 8a ff ff ff call 114c84 <libc_wrapup>
rtems_shutdown_executive(status);
114cfa: 83 ec 0c sub $0xc,%esp
114cfd: ff 75 08 pushl 0x8(%ebp)
114d00: e8 d7 00 00 00 call 114ddc <rtems_shutdown_executive>
114d05: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
114d08: eb fe jmp 114d08 <_exit+0x1e> <== NOT EXECUTED
00117656 <_getpid_r>:
#include <reent.h>
pid_t _getpid_r(
struct _reent *ptr
)
{
117656: 55 push %ebp <== NOT EXECUTED
117657: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return getpid();
}
117659: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
11765e: c9 leave <== NOT EXECUTED
11765f: c3 ret <== NOT EXECUTED
0010cdb8 <_gettimeofday>:
int _gettimeofday(
struct timeval *tp,
struct timezone *tzp
)
{
10cdb8: 55 push %ebp <== NOT EXECUTED
10cdb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return gettimeofday( tp, tzp );
}
10cdbb: c9 leave <== NOT EXECUTED
int _gettimeofday(
struct timeval *tp,
struct timezone *tzp
)
{
return gettimeofday( tp, tzp );
10cdbc: e9 a7 ff ff ff jmp 10cd68 <gettimeofday> <== NOT EXECUTED
0011775f <_kill_r>:
#if defined(RTEMS_NEWLIB)
#include <reent.h>
int _kill_r( struct _reent *ptr, pid_t pid, int sig )
{
11775f: 55 push %ebp <== NOT EXECUTED
117760: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return 0;
}
117762: 31 c0 xor %eax,%eax <== NOT EXECUTED
117764: c9 leave <== NOT EXECUTED
117765: c3 ret <== NOT EXECUTED
00114c59 <_lseek_r>:
struct _reent *ptr,
int fd,
off_t offset,
int whence
)
{
114c59: 55 push %ebp <== NOT EXECUTED
114c5a: 89 e5 mov %esp,%ebp <== NOT EXECUTED
114c5c: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
114c5f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
return lseek( fd, offset, whence );
114c62: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
114c65: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED
114c68: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED
114c6b: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED
}
114c6e: c9 leave <== NOT EXECUTED
int fd,
off_t offset,
int whence
)
{
return lseek( fd, offset, whence );
114c6f: e9 4c ff ff ff jmp 114bc0 <lseek> <== NOT EXECUTED
00106da9 <_open_r>:
struct _reent *ptr,
const char *buf,
int flags,
int mode
)
{
106da9: 55 push %ebp <== NOT EXECUTED
106daa: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106dac: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
106daf: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
return open( buf, flags, mode );
106db2: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
106db5: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED
106db8: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED
106dbb: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED
}
106dbe: c9 leave <== NOT EXECUTED
const char *buf,
int flags,
int mode
)
{
return open( buf, flags, mode );
106dbf: e9 ec fd ff ff jmp 106bb0 <open> <== NOT EXECUTED
00114d8d <_read_r>:
struct _reent *ptr,
int fd,
void *buf,
size_t nbytes
)
{
114d8d: 55 push %ebp <== NOT EXECUTED
114d8e: 89 e5 mov %esp,%ebp <== NOT EXECUTED
114d90: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
114d93: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
return read( fd, buf, nbytes );
114d96: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
114d99: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED
114d9c: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED
114d9f: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED
}
114da2: c9 leave <== NOT EXECUTED
int fd,
void *buf,
size_t nbytes
)
{
return read( fd, buf, nbytes );
114da3: e9 64 ff ff ff jmp 114d0c <read> <== NOT EXECUTED
00114da8 <_realloc_r>:
void *_realloc_r(
struct _reent *ignored,
void *ptr,
size_t size
)
{
114da8: 55 push %ebp <== NOT EXECUTED
114da9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
114dab: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
return realloc( ptr, size );
114dae: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
114db1: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED
114db4: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED
}
114db7: c9 leave <== NOT EXECUTED
struct _reent *ignored,
void *ptr,
size_t size
)
{
return realloc( ptr, size );
114db8: e9 4f 00 00 00 jmp 114e0c <realloc> <== NOT EXECUTED
0010cc04 <calloc>:
)
{
register char *cptr;
int length;
MSBUMP(calloc_calls, 1);
10cc04: 55 push %ebp
10cc05: 89 e5 mov %esp,%ebp
10cc07: 57 push %edi
10cc08: 53 push %ebx
10cc09: 83 ec 1c sub $0x1c,%esp
10cc0c: 8b 5d 0c mov 0xc(%ebp),%ebx
10cc0f: ff 05 04 ca 11 00 incl 0x11ca04
length = nelem * elsize;
10cc15: 0f af 5d 08 imul 0x8(%ebp),%ebx
cptr = malloc( length );
10cc19: 53 push %ebx
10cc1a: e8 55 9a ff ff call 106674 <malloc>
10cc1f: 89 c2 mov %eax,%edx
if ( cptr )
10cc21: 83 c4 10 add $0x10,%esp
10cc24: 85 c0 test %eax,%eax
10cc26: 74 08 je 10cc30 <calloc+0x2c> <== NEVER TAKEN
memset( cptr, '\0', length );
10cc28: 31 c0 xor %eax,%eax
10cc2a: 89 d7 mov %edx,%edi
10cc2c: 89 d9 mov %ebx,%ecx
10cc2e: f3 aa rep stos %al,%es:(%edi)
MSBUMP(malloc_calls, -1); /* subtract off the malloc */
10cc30: ff 0d f4 c9 11 00 decl 0x11c9f4
return cptr;
}
10cc36: 89 d0 mov %edx,%eax
10cc38: 8d 65 f8 lea -0x8(%ebp),%esp
10cc3b: 5b pop %ebx
10cc3c: 5f pop %edi
10cc3d: c9 leave
10cc3e: c3 ret
0010cc40 <close>:
#include <rtems/libio_.h>
int close(
int fd
)
{
10cc40: 55 push %ebp
10cc41: 89 e5 mov %esp,%ebp
10cc43: 56 push %esi
10cc44: 53 push %ebx
10cc45: 8b 45 08 mov 0x8(%ebp),%eax
rtems_libio_t *iop;
rtems_status_code rc;
rtems_libio_check_fd(fd);
10cc48: 3b 05 b8 86 11 00 cmp 0x1186b8,%eax
10cc4e: 73 0f jae 10cc5f <close+0x1f> <== NEVER TAKEN
iop = rtems_libio_iop(fd);
10cc50: 6b d8 34 imul $0x34,%eax,%ebx
10cc53: 03 1d 80 c9 11 00 add 0x11c980,%ebx
rtems_libio_check_is_open(iop);
10cc59: f6 43 0d 01 testb $0x1,0xd(%ebx)
10cc5d: 75 10 jne 10cc6f <close+0x2f> <== ALWAYS TAKEN
10cc5f: e8 6c 1a 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10cc64: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
10cc6a: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10cc6d: eb 3f jmp 10ccae <close+0x6e> <== NOT EXECUTED
rc = RTEMS_SUCCESSFUL;
if ( iop->handlers->close_h )
10cc6f: 8b 43 30 mov 0x30(%ebx),%eax
10cc72: 8b 40 04 mov 0x4(%eax),%eax
10cc75: 31 f6 xor %esi,%esi
10cc77: 85 c0 test %eax,%eax
10cc79: 74 0b je 10cc86 <close+0x46> <== NEVER TAKEN
rc = (*iop->handlers->close_h)( iop );
10cc7b: 83 ec 0c sub $0xc,%esp
10cc7e: 53 push %ebx
10cc7f: ff d0 call *%eax
10cc81: 89 c6 mov %eax,%esi
10cc83: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( &iop->pathinfo );
10cc86: 8b 43 18 mov 0x18(%ebx),%eax
10cc89: 85 c0 test %eax,%eax
10cc8b: 74 13 je 10cca0 <close+0x60> <== NEVER TAKEN
10cc8d: 8b 50 1c mov 0x1c(%eax),%edx
10cc90: 85 d2 test %edx,%edx
10cc92: 74 0c je 10cca0 <close+0x60> <== ALWAYS TAKEN
10cc94: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10cc97: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED
10cc9a: 50 push %eax <== NOT EXECUTED
10cc9b: ff d2 call *%edx <== NOT EXECUTED
10cc9d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_libio_free( iop );
10cca0: 83 ec 0c sub $0xc,%esp
10cca3: 53 push %ebx
10cca4: e8 27 02 00 00 call 10ced0 <rtems_libio_free>
return rc;
10cca9: 89 f0 mov %esi,%eax
10ccab: 83 c4 10 add $0x10,%esp
}
10ccae: 8d 65 f8 lea -0x8(%ebp),%esp
10ccb1: 5b pop %ebx
10ccb2: 5e pop %esi
10ccb3: c9 leave
10ccb4: c3 ret
0010dfca <device_close>:
*/
int device_close(
rtems_libio_t *iop
)
{
10dfca: 55 push %ebp
10dfcb: 89 e5 mov %esp,%ebp
10dfcd: 83 ec 1c sub $0x1c,%esp
10dfd0: 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;
10dfd3: 8b 50 2c mov 0x2c(%eax),%edx
args.iop = iop;
10dfd6: 89 45 f4 mov %eax,-0xc(%ebp)
args.flags = 0;
10dfd9: c7 45 f8 00 00 00 00 movl $0x0,-0x8(%ebp)
args.mode = 0;
10dfe0: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
status = rtems_io_close(
10dfe7: 8d 45 f4 lea -0xc(%ebp),%eax
10dfea: 50 push %eax
10dfeb: ff 72 54 pushl 0x54(%edx)
10dfee: ff 72 50 pushl 0x50(%edx)
10dff1: e8 d2 03 00 00 call 10e3c8 <rtems_io_close>
10dff6: 89 c2 mov %eax,%edx
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status ) {
10dff8: 83 c4 10 add $0x10,%esp
10dffb: 31 c0 xor %eax,%eax
10dffd: 85 d2 test %edx,%edx
10dfff: 74 07 je 10e008 <device_close+0x3e> <== ALWAYS TAKEN
return rtems_deviceio_errno(status);
10e001: 89 d0 mov %edx,%eax <== NOT EXECUTED
10e003: e8 bb fe ff ff call 10dec3 <rtems_deviceio_errno> <== NOT EXECUTED
}
return 0;
}
10e008: c9 leave
10e009: c3 ret
0010debc <device_ftruncate>:
int device_ftruncate(
rtems_libio_t *iop,
off_t length
)
{
10debc: 55 push %ebp <== NOT EXECUTED
10debd: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return 0;
}
10debf: 31 c0 xor %eax,%eax <== NOT EXECUTED
10dec1: c9 leave <== NOT EXECUTED
10dec2: c3 ret <== NOT EXECUTED
0010deed <device_ioctl>:
int device_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
10deed: 55 push %ebp <== NOT EXECUTED
10deee: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10def0: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED
10def3: 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;
10def6: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED
args.command = command;
10def9: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10defc: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED
args.buffer = buffer;
10deff: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
10df02: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED
the_jnode = iop->file_info;
10df05: 8b 52 2c mov 0x2c(%edx),%edx <== NOT EXECUTED
status = rtems_io_control(
10df08: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED
10df0b: 50 push %eax <== NOT EXECUTED
10df0c: ff 72 54 pushl 0x54(%edx) <== NOT EXECUTED
10df0f: ff 72 50 pushl 0x50(%edx) <== NOT EXECUTED
10df12: e8 f1 04 00 00 call 10e408 <rtems_io_control> <== NOT EXECUTED
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
10df17: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10df1a: 85 c0 test %eax,%eax <== NOT EXECUTED
10df1c: 74 07 je 10df25 <device_ioctl+0x38> <== NOT EXECUTED
return rtems_deviceio_errno(status);
10df1e: e8 a0 ff ff ff call 10dec3 <rtems_deviceio_errno> <== NOT EXECUTED
10df23: eb 03 jmp 10df28 <device_ioctl+0x3b> <== NOT EXECUTED
return args.ioctl_return;
10df25: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED
}
10df28: c9 leave <== NOT EXECUTED
10df29: c3 ret <== NOT EXECUTED
0010deb4 <device_lseek>:
off_t device_lseek(
rtems_libio_t *iop,
off_t offset,
int whence
)
{
10deb4: 55 push %ebp <== NOT EXECUTED
10deb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return offset;
}
10deb7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10deba: c9 leave <== NOT EXECUTED
10debb: c3 ret <== NOT EXECUTED
0010e00a <device_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
10e00a: 55 push %ebp
10e00b: 89 e5 mov %esp,%ebp
10e00d: 83 ec 1c sub $0x1c,%esp
10e010: 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;
10e013: 8b 50 2c mov 0x2c(%eax),%edx
args.iop = iop;
10e016: 89 45 f4 mov %eax,-0xc(%ebp)
args.flags = iop->flags;
10e019: 8b 40 0c mov 0xc(%eax),%eax
10e01c: 89 45 f8 mov %eax,-0x8(%ebp)
args.mode = mode;
10e01f: 8b 45 14 mov 0x14(%ebp),%eax
10e022: 89 45 fc mov %eax,-0x4(%ebp)
status = rtems_io_open(
10e025: 8d 45 f4 lea -0xc(%ebp),%eax
10e028: 50 push %eax
10e029: ff 72 54 pushl 0x54(%edx)
10e02c: ff 72 50 pushl 0x50(%edx)
10e02f: e8 14 04 00 00 call 10e448 <rtems_io_open>
10e034: 89 c2 mov %eax,%edx
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
10e036: 83 c4 10 add $0x10,%esp
10e039: 31 c0 xor %eax,%eax
10e03b: 85 d2 test %edx,%edx
10e03d: 74 07 je 10e046 <device_open+0x3c> <== ALWAYS TAKEN
return rtems_deviceio_errno(status);
10e03f: 89 d0 mov %edx,%eax <== NOT EXECUTED
10e041: e8 7d fe ff ff call 10dec3 <rtems_deviceio_errno> <== NOT EXECUTED
return 0;
}
10e046: c9 leave
10e047: c3 ret
0010df7a <device_read>:
ssize_t device_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
10df7a: 55 push %ebp <== NOT EXECUTED
10df7b: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10df7d: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED
10df80: 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;
10df83: 8b 4a 2c mov 0x2c(%edx),%ecx <== NOT EXECUTED
args.iop = iop;
10df86: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED
args.offset = iop->offset;
10df89: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED
10df8c: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED
args.buffer = buffer;
10df8f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10df92: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED
args.count = count;
10df95: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
10df98: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED
args.flags = iop->flags;
10df9b: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED
10df9e: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED
args.bytes_moved = 0;
10dfa1: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED
status = rtems_io_read(
10dfa8: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED
10dfab: 50 push %eax <== NOT EXECUTED
10dfac: ff 71 54 pushl 0x54(%ecx) <== NOT EXECUTED
10dfaf: ff 71 50 pushl 0x50(%ecx) <== NOT EXECUTED
10dfb2: e8 d1 04 00 00 call 10e488 <rtems_io_read> <== NOT EXECUTED
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
10dfb7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10dfba: 85 c0 test %eax,%eax <== NOT EXECUTED
10dfbc: 74 07 je 10dfc5 <device_read+0x4b> <== NOT EXECUTED
return rtems_deviceio_errno(status);
10dfbe: e8 00 ff ff ff call 10dec3 <rtems_deviceio_errno> <== NOT EXECUTED
10dfc3: eb 03 jmp 10dfc8 <device_read+0x4e> <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
10dfc5: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED
}
10dfc8: c9 leave <== NOT EXECUTED
10dfc9: c3 ret <== NOT EXECUTED
0010df2a <device_write>:
ssize_t device_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
10df2a: 55 push %ebp
10df2b: 89 e5 mov %esp,%ebp
10df2d: 83 ec 2c sub $0x2c,%esp
10df30: 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;
10df33: 8b 4a 2c mov 0x2c(%edx),%ecx
args.iop = iop;
10df36: 89 55 e8 mov %edx,-0x18(%ebp)
args.offset = iop->offset;
10df39: 8b 42 08 mov 0x8(%edx),%eax
10df3c: 89 45 ec mov %eax,-0x14(%ebp)
args.buffer = (void *) buffer;
10df3f: 8b 45 0c mov 0xc(%ebp),%eax
10df42: 89 45 f0 mov %eax,-0x10(%ebp)
args.count = count;
10df45: 8b 45 10 mov 0x10(%ebp),%eax
10df48: 89 45 f4 mov %eax,-0xc(%ebp)
args.flags = iop->flags;
10df4b: 8b 42 0c mov 0xc(%edx),%eax
10df4e: 89 45 f8 mov %eax,-0x8(%ebp)
args.bytes_moved = 0;
10df51: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
status = rtems_io_write(
10df58: 8d 45 e8 lea -0x18(%ebp),%eax
10df5b: 50 push %eax
10df5c: ff 71 54 pushl 0x54(%ecx)
10df5f: ff 71 50 pushl 0x50(%ecx)
10df62: e8 61 05 00 00 call 10e4c8 <rtems_io_write>
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
10df67: 83 c4 10 add $0x10,%esp
10df6a: 85 c0 test %eax,%eax
10df6c: 74 07 je 10df75 <device_write+0x4b> <== ALWAYS TAKEN
return rtems_deviceio_errno(status);
10df6e: e8 50 ff ff ff call 10dec3 <rtems_deviceio_errno> <== NOT EXECUTED
10df73: eb 03 jmp 10df78 <device_write+0x4e> <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
10df75: 8b 45 fc mov -0x4(%ebp),%eax
}
10df78: c9 leave
10df79: c3 ret
00107c82 <drainOutput>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
107c82: 55 push %ebp
107c83: 89 e5 mov %esp,%ebp
107c85: 53 push %ebx
107c86: 83 ec 04 sub $0x4,%esp
107c89: 89 c3 mov %eax,%ebx
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
107c8b: 83 b8 b4 00 00 00 00 cmpl $0x0,0xb4(%eax)
107c92: 74 46 je 107cda <drainOutput+0x58> <== NEVER TAKEN
rtems_interrupt_disable (level);
107c94: 9c pushf
107c95: fa cli
107c96: 59 pop %ecx
107c97: eb 2f jmp 107cc8 <drainOutput+0x46>
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
107c99: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx)
107ca0: 00 00 00
rtems_interrupt_enable (level);
107ca3: 51 push %ecx
107ca4: 9d popf
sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
107ca5: 51 push %ecx
107ca6: 6a 00 push $0x0
107ca8: 6a 00 push $0x0
107caa: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
107cb0: e8 bf 14 00 00 call 109174 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
107cb5: 83 c4 10 add $0x10,%esp
107cb8: 85 c0 test %eax,%eax
107cba: 74 09 je 107cc5 <drainOutput+0x43> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
107cbc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107cbf: 50 push %eax <== NOT EXECUTED
107cc0: e8 c7 1a 00 00 call 10978c <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_interrupt_disable (level);
107cc5: 9c pushf
107cc6: fa cli
107cc7: 59 pop %ecx
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
107cc8: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx
107cce: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
107cd4: 39 c2 cmp %eax,%edx
107cd6: 75 c1 jne 107c99 <drainOutput+0x17>
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
rtems_interrupt_enable (level);
107cd8: 51 push %ecx
107cd9: 9d popf
}
}
107cda: 8b 5d fc mov -0x4(%ebp),%ebx
107cdd: c9 leave
107cde: c3 ret
001078b7 <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
1078b7: 55 push %ebp <== NOT EXECUTED
1078b8: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1078ba: 53 push %ebx <== NOT EXECUTED
1078bb: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED
1078be: 89 d3 mov %edx,%ebx <== NOT EXECUTED
1078c0: 88 c1 mov %al,%cl <== NOT EXECUTED
if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
1078c2: f6 42 3d 02 testb $0x2,0x3d(%edx) <== NOT EXECUTED
1078c6: 74 38 je 107900 <echo+0x49> <== NOT EXECUTED
1078c8: 0f b6 d0 movzbl %al,%edx <== NOT EXECUTED
1078cb: a1 98 aa 11 00 mov 0x11aa98,%eax <== NOT EXECUTED
1078d0: f6 04 10 20 testb $0x20,(%eax,%edx,1) <== NOT EXECUTED
1078d4: 74 2a je 107900 <echo+0x49> <== NOT EXECUTED
1078d6: 80 f9 09 cmp $0x9,%cl <== NOT EXECUTED
1078d9: 74 25 je 107900 <echo+0x49> <== NOT EXECUTED
1078db: 80 f9 0a cmp $0xa,%cl <== NOT EXECUTED
1078de: 74 20 je 107900 <echo+0x49> <== NOT EXECUTED
char echobuf[2];
echobuf[0] = '^';
1078e0: c6 45 fa 5e movb $0x5e,-0x6(%ebp) <== NOT EXECUTED
echobuf[1] = c ^ 0x40;
1078e4: 83 f1 40 xor $0x40,%ecx <== NOT EXECUTED
1078e7: 88 4d fb mov %cl,-0x5(%ebp) <== NOT EXECUTED
rtems_termios_puts (echobuf, 2, tty);
1078ea: 50 push %eax <== NOT EXECUTED
1078eb: 53 push %ebx <== NOT EXECUTED
1078ec: 6a 02 push $0x2 <== NOT EXECUTED
1078ee: 8d 45 fa lea -0x6(%ebp),%eax <== NOT EXECUTED
1078f1: 50 push %eax <== NOT EXECUTED
1078f2: e8 9c fd ff ff call 107693 <rtems_termios_puts> <== NOT EXECUTED
tty->column += 2;
1078f7: 83 43 28 02 addl $0x2,0x28(%ebx) <== NOT EXECUTED
1078fb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1078fe: eb 0a jmp 10790a <echo+0x53> <== NOT EXECUTED
}
else {
oproc (c, tty);
107900: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED
107903: 89 da mov %ebx,%edx <== NOT EXECUTED
107905: e8 9e fe ff ff call 1077a8 <oproc> <== NOT EXECUTED
}
}
10790a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10790d: c9 leave <== NOT EXECUTED
10790e: c3 ret <== NOT EXECUTED
0010790f <erase>:
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
10790f: 55 push %ebp <== NOT EXECUTED
107910: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107912: 57 push %edi <== NOT EXECUTED
107913: 56 push %esi <== NOT EXECUTED
107914: 53 push %ebx <== NOT EXECUTED
107915: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107918: 89 c3 mov %eax,%ebx <== NOT EXECUTED
10791a: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED
if (tty->ccount == 0)
10791d: 83 78 20 00 cmpl $0x0,0x20(%eax) <== NOT EXECUTED
107921: 0f 84 4d 01 00 00 je 107a74 <erase+0x165> <== NOT EXECUTED
return;
if (lineFlag) {
107927: 85 d2 test %edx,%edx <== NOT EXECUTED
107929: 0f 84 3a 01 00 00 je 107a69 <erase+0x15a> <== NOT EXECUTED
if (!(tty->termios.c_lflag & ECHO)) {
10792f: 8b 40 3c mov 0x3c(%eax),%eax <== NOT EXECUTED
107932: a8 08 test $0x8,%al <== NOT EXECUTED
107934: 75 0c jne 107942 <erase+0x33> <== NOT EXECUTED
tty->ccount = 0;
107936: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED
10793d: e9 32 01 00 00 jmp 107a74 <erase+0x165> <== NOT EXECUTED
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
107942: a8 10 test $0x10,%al <== NOT EXECUTED
107944: 0f 85 1f 01 00 00 jne 107a69 <erase+0x15a> <== NOT EXECUTED
tty->ccount = 0;
10794a: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
107951: 0f b6 43 44 movzbl 0x44(%ebx),%eax <== NOT EXECUTED
107955: 89 da mov %ebx,%edx <== NOT EXECUTED
107957: e8 5b ff ff ff call 1078b7 <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
10795c: f6 43 3c 20 testb $0x20,0x3c(%ebx) <== NOT EXECUTED
107960: 0f 84 0e 01 00 00 je 107a74 <erase+0x165> <== NOT EXECUTED
echo ('\n', tty);
107966: 89 da mov %ebx,%edx <== NOT EXECUTED
107968: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
10796d: eb 28 jmp 107997 <erase+0x88> <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
10796f: 8b 53 1c mov 0x1c(%ebx),%edx <== NOT EXECUTED
107972: 8d 41 ff lea -0x1(%ecx),%eax <== NOT EXECUTED
107975: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED
107978: 8a 54 0a ff mov -0x1(%edx,%ecx,1),%dl <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
10797c: 8b 43 3c mov 0x3c(%ebx),%eax <== NOT EXECUTED
10797f: a8 08 test $0x8,%al <== NOT EXECUTED
107981: 0f 84 dc 00 00 00 je 107a63 <erase+0x154> <== NOT EXECUTED
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
107987: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED
10798b: 75 16 jne 1079a3 <erase+0x94> <== NOT EXECUTED
10798d: a8 10 test $0x10,%al <== NOT EXECUTED
10798f: 75 12 jne 1079a3 <erase+0x94> <== NOT EXECUTED
echo (tty->termios.c_cc[VERASE], tty);
107991: 0f b6 43 43 movzbl 0x43(%ebx),%eax <== NOT EXECUTED
107995: 89 da mov %ebx,%edx <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
107997: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10799a: 5b pop %ebx <== NOT EXECUTED
10799b: 5e pop %esi <== NOT EXECUTED
10799c: 5f pop %edi <== NOT EXECUTED
10799d: c9 leave <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
10799e: e9 14 ff ff ff jmp 1078b7 <echo> <== NOT EXECUTED
}
else if (c == '\t') {
1079a3: 80 fa 09 cmp $0x9,%dl <== NOT EXECUTED
1079a6: 8b 3d 98 aa 11 00 mov 0x11aa98,%edi <== NOT EXECUTED
1079ac: 75 5e jne 107a0c <erase+0xfd> <== NOT EXECUTED
int col = tty->read_start_column;
1079ae: 8b 73 2c mov 0x2c(%ebx),%esi <== NOT EXECUTED
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
}
else if (iscntrl (c)) {
1079b1: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOCTL)
1079b6: 25 00 02 00 00 and $0x200,%eax <== NOT EXECUTED
1079bb: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED
1079be: eb 2b jmp 1079eb <erase+0xdc> <== NOT EXECUTED
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
1079c0: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED
1079c3: 8a 44 10 ff mov -0x1(%eax,%edx,1),%al <== NOT EXECUTED
if (c == '\t') {
1079c7: 3c 09 cmp $0x9,%al <== NOT EXECUTED
1079c9: 75 0a jne 1079d5 <erase+0xc6> <== NOT EXECUTED
col = (col | 7) + 1;
1079cb: 89 f0 mov %esi,%eax <== NOT EXECUTED
1079cd: 83 c8 07 or $0x7,%eax <== NOT EXECUTED
1079d0: 8d 70 01 lea 0x1(%eax),%esi <== NOT EXECUTED
1079d3: eb 15 jmp 1079ea <erase+0xdb> <== NOT EXECUTED
}
else if (iscntrl (c)) {
1079d5: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
1079d8: f6 04 07 20 testb $0x20,(%edi,%eax,1) <== NOT EXECUTED
1079dc: 74 0b je 1079e9 <erase+0xda> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOCTL)
1079de: 83 7d ec 00 cmpl $0x0,-0x14(%ebp) <== NOT EXECUTED
1079e2: 74 06 je 1079ea <erase+0xdb> <== NOT EXECUTED
col += 2;
1079e4: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
1079e7: eb 01 jmp 1079ea <erase+0xdb> <== NOT EXECUTED
}
else {
col++;
1079e9: 46 inc %esi <== NOT EXECUTED
1079ea: 42 inc %edx <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
1079eb: 39 ca cmp %ecx,%edx <== NOT EXECUTED
1079ed: 75 d1 jne 1079c0 <erase+0xb1> <== NOT EXECUTED
1079ef: eb 14 jmp 107a05 <erase+0xf6> <== NOT EXECUTED
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
1079f1: 50 push %eax <== NOT EXECUTED
1079f2: 53 push %ebx <== NOT EXECUTED
1079f3: 6a 01 push $0x1 <== NOT EXECUTED
1079f5: 68 14 68 11 00 push $0x116814 <== NOT EXECUTED
1079fa: e8 94 fc ff ff call 107693 <rtems_termios_puts> <== NOT EXECUTED
tty->column--;
1079ff: ff 4b 28 decl 0x28(%ebx) <== NOT EXECUTED
107a02: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
107a05: 39 73 28 cmp %esi,0x28(%ebx) <== NOT EXECUTED
107a08: 7f e7 jg 1079f1 <erase+0xe2> <== NOT EXECUTED
107a0a: eb 57 jmp 107a63 <erase+0x154> <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
107a0c: 0f b6 f2 movzbl %dl,%esi <== NOT EXECUTED
107a0f: f6 04 37 20 testb $0x20,(%edi,%esi,1) <== NOT EXECUTED
107a13: 74 21 je 107a36 <erase+0x127> <== NOT EXECUTED
107a15: f6 c4 02 test $0x2,%ah <== NOT EXECUTED
107a18: 74 1c je 107a36 <erase+0x127> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
107a1a: 50 push %eax <== NOT EXECUTED
107a1b: 53 push %ebx <== NOT EXECUTED
107a1c: 6a 03 push $0x3 <== NOT EXECUTED
107a1e: 68 12 68 11 00 push $0x116812 <== NOT EXECUTED
107a23: e8 6b fc ff ff call 107693 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
107a28: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
107a2b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107a2e: 85 c0 test %eax,%eax <== NOT EXECUTED
107a30: 74 04 je 107a36 <erase+0x127> <== NOT EXECUTED
tty->column--;
107a32: 48 dec %eax <== NOT EXECUTED
107a33: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
107a36: a1 98 aa 11 00 mov 0x11aa98,%eax <== NOT EXECUTED
107a3b: f6 04 30 20 testb $0x20,(%eax,%esi,1) <== NOT EXECUTED
107a3f: 74 06 je 107a47 <erase+0x138> <== NOT EXECUTED
107a41: f6 43 3d 02 testb $0x2,0x3d(%ebx) <== NOT EXECUTED
107a45: 74 1c je 107a63 <erase+0x154> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
107a47: 50 push %eax <== NOT EXECUTED
107a48: 53 push %ebx <== NOT EXECUTED
107a49: 6a 03 push $0x3 <== NOT EXECUTED
107a4b: 68 12 68 11 00 push $0x116812 <== NOT EXECUTED
107a50: e8 3e fc ff ff call 107693 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
107a55: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
107a58: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107a5b: 85 c0 test %eax,%eax <== NOT EXECUTED
107a5d: 74 04 je 107a63 <erase+0x154> <== NOT EXECUTED
tty->column--;
107a5f: 48 dec %eax <== NOT EXECUTED
107a60: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
}
}
}
if (!lineFlag)
107a63: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED
107a67: 74 0b je 107a74 <erase+0x165> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
107a69: 8b 4b 20 mov 0x20(%ebx),%ecx <== NOT EXECUTED
107a6c: 85 c9 test %ecx,%ecx <== NOT EXECUTED
107a6e: 0f 85 fb fe ff ff jne 10796f <erase+0x60> <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
107a74: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
107a77: 5b pop %ebx <== NOT EXECUTED
107a78: 5e pop %esi <== NOT EXECUTED
107a79: 5f pop %edi <== NOT EXECUTED
107a7a: c9 leave <== NOT EXECUTED
107a7b: c3 ret <== NOT EXECUTED
00106478 <free>:
void free(
void *ptr
)
{
MSBUMP(free_calls, 1);
106478: 55 push %ebp
106479: 89 e5 mov %esp,%ebp
10647b: 53 push %ebx
10647c: 83 ec 04 sub $0x4,%esp
10647f: 8b 5d 08 mov 0x8(%ebp),%ebx
106482: ff 05 fc c9 11 00 incl 0x11c9fc
if ( !ptr )
106488: 85 db test %ebx,%ebx
10648a: 74 5f je 1064eb <free+0x73>
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
10648c: 83 3d 80 cc 11 00 03 cmpl $0x3,0x11cc80
106493: 75 15 jne 1064aa <free+0x32> <== NEVER TAKEN
106495: e8 de 00 00 00 call 106578 <malloc_is_system_state_OK>
10649a: 84 c0 test %al,%al
10649c: 75 0c jne 1064aa <free+0x32> <== ALWAYS TAKEN
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
10649e: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED
RTEMS_Malloc_Heap.begin,
RTEMS_Malloc_Heap.end
);
}
}
1064a1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
1064a4: c9 leave <== NOT EXECUTED
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
1064a5: e9 0d 01 00 00 jmp 1065b7 <malloc_deferred_free> <== NOT EXECUTED
#endif
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
1064aa: a1 54 af 11 00 mov 0x11af54,%eax
1064af: 85 c0 test %eax,%eax
1064b1: 74 0a je 1064bd <free+0x45> <== ALWAYS TAKEN
(*rtems_malloc_statistics_helpers->at_free)(ptr);
1064b3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1064b6: 53 push %ebx <== NOT EXECUTED
1064b7: ff 50 08 call *0x8(%eax) <== NOT EXECUTED
1064ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if ( !_Protected_heap_Free( &RTEMS_Malloc_Heap, ptr ) ) {
1064bd: 50 push %eax
1064be: 50 push %eax
1064bf: 53 push %ebx
1064c0: 68 98 c9 11 00 push $0x11c998
1064c5: e8 02 44 00 00 call 10a8cc <_Protected_heap_Free>
1064ca: 83 c4 10 add $0x10,%esp
1064cd: 84 c0 test %al,%al
1064cf: 75 1a jne 1064eb <free+0x73> <== ALWAYS TAKEN
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
1064d1: ff 35 b4 c9 11 00 pushl 0x11c9b4 <== NOT EXECUTED
1064d7: ff 35 b0 c9 11 00 pushl 0x11c9b0 <== NOT EXECUTED
1064dd: 53 push %ebx <== NOT EXECUTED
1064de: 68 bc 67 11 00 push $0x1167bc <== NOT EXECUTED
1064e3: e8 76 0b 00 00 call 10705e <printk> <== NOT EXECUTED
1064e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
RTEMS_Malloc_Heap.begin,
RTEMS_Malloc_Heap.end
);
}
}
1064eb: 8b 5d fc mov -0x4(%ebp),%ebx
1064ee: c9 leave
1064ef: c3 ret
00114ae8 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
114ae8: 55 push %ebp
114ae9: 89 e5 mov %esp,%ebp
114aeb: 57 push %edi
114aec: 56 push %esi
114aed: 53 push %ebx
114aee: 83 ec 0c sub $0xc,%esp
114af1: 8b 45 08 mov 0x8(%ebp),%eax
114af4: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
114af7: 85 f6 test %esi,%esi
114af9: 75 0d jne 114b08 <fstat+0x20> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EFAULT );
114afb: e8 d0 9b ff ff call 10e6d0 <__errno> <== NOT EXECUTED
114b00: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED
114b06: eb 54 jmp 114b5c <fstat+0x74> <== NOT EXECUTED
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
114b08: 3b 05 b8 86 11 00 cmp 0x1186b8,%eax
114b0e: 73 57 jae 114b67 <fstat+0x7f> <== NEVER TAKEN
114b10: 6b d8 34 imul $0x34,%eax,%ebx
114b13: 03 1d 80 c9 11 00 add 0x11c980,%ebx
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
114b19: f6 43 0d 01 testb $0x1,0xd(%ebx)
114b1d: 74 48 je 114b67 <fstat+0x7f> <== NEVER TAKEN
if ( !iop->handlers )
114b1f: 8b 43 30 mov 0x30(%ebx),%eax
114b22: 85 c0 test %eax,%eax
114b24: 74 41 je 114b67 <fstat+0x7f> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EBADF );
if ( !iop->handlers->fstat_h )
114b26: 83 78 18 00 cmpl $0x0,0x18(%eax)
114b2a: 75 0d jne 114b39 <fstat+0x51> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
114b2c: e8 9f 9b ff ff call 10e6d0 <__errno> <== NOT EXECUTED
114b31: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
114b37: eb 23 jmp 114b5c <fstat+0x74> <== NOT EXECUTED
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
114b39: b9 13 00 00 00 mov $0x13,%ecx
114b3e: 31 c0 xor %eax,%eax
114b40: 89 f7 mov %esi,%edi
114b42: f3 ab rep stos %eax,%es:(%edi)
return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf );
114b44: 8b 53 30 mov 0x30(%ebx),%edx
114b47: 89 75 0c mov %esi,0xc(%ebp)
114b4a: 8d 43 10 lea 0x10(%ebx),%eax
114b4d: 89 45 08 mov %eax,0x8(%ebp)
114b50: 8b 4a 18 mov 0x18(%edx),%ecx
}
114b53: 83 c4 0c add $0xc,%esp
114b56: 5b pop %ebx
114b57: 5e pop %esi
114b58: 5f pop %edi
114b59: 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 );
114b5a: ff e1 jmp *%ecx
}
114b5c: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
114b5f: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
114b62: 5b pop %ebx <== NOT EXECUTED
114b63: 5e pop %esi <== NOT EXECUTED
114b64: 5f pop %edi <== NOT EXECUTED
114b65: c9 leave <== NOT EXECUTED
114b66: c3 ret <== NOT EXECUTED
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
rtems_libio_check_fd( fd );
114b67: e8 64 9b ff ff call 10e6d0 <__errno> <== NOT EXECUTED
114b6c: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
114b72: eb e8 jmp 114b5c <fstat+0x74> <== NOT EXECUTED
0010ccc4 <ftruncate>:
int ftruncate(
int fd,
off_t length
)
{
10ccc4: 55 push %ebp <== NOT EXECUTED
10ccc5: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10ccc7: 57 push %edi <== NOT EXECUTED
10ccc8: 56 push %esi <== NOT EXECUTED
10ccc9: 53 push %ebx <== NOT EXECUTED
10ccca: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED
10cccd: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
10ccd0: 3b 05 b8 86 11 00 cmp 0x1186b8,%eax <== NOT EXECUTED
10ccd6: 73 0f jae 10cce7 <ftruncate+0x23> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
10ccd8: 6b d8 34 imul $0x34,%eax,%ebx <== NOT EXECUTED
10ccdb: 03 1d 80 c9 11 00 add 0x11c980,%ebx <== NOT EXECUTED
rtems_libio_check_is_open(iop);
10cce1: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED
10cce5: 75 0d jne 10ccf4 <ftruncate+0x30> <== NOT EXECUTED
10cce7: e8 e4 19 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10ccec: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
10ccf2: eb 5b jmp 10cd4f <ftruncate+0x8b> <== NOT EXECUTED
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
10ccf4: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED
10ccf7: 8d 73 10 lea 0x10(%ebx),%esi <== NOT EXECUTED
10ccfa: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
10ccff: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
if ( !loc.ops->node_type_h )
10cd01: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
10cd04: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED
10cd07: 85 d2 test %edx,%edx <== NOT EXECUTED
10cd09: 74 39 je 10cd44 <ftruncate+0x80> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
10cd0b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10cd0e: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED
10cd11: 50 push %eax <== NOT EXECUTED
10cd12: ff d2 call *%edx <== NOT EXECUTED
10cd14: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10cd17: 48 dec %eax <== NOT EXECUTED
10cd18: 75 0d jne 10cd27 <ftruncate+0x63> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EISDIR );
10cd1a: e8 b1 19 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10cd1f: c7 00 15 00 00 00 movl $0x15,(%eax) <== NOT EXECUTED
10cd25: eb 28 jmp 10cd4f <ftruncate+0x8b> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
10cd27: f6 43 0c 04 testb $0x4,0xc(%ebx) <== NOT EXECUTED
10cd2b: 75 0d jne 10cd3a <ftruncate+0x76> <== NOT EXECUTED
10cd2d: e8 9e 19 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10cd32: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
10cd38: eb 15 jmp 10cd4f <ftruncate+0x8b> <== NOT EXECUTED
if ( !iop->handlers->ftruncate_h )
10cd3a: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED
10cd3d: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED
10cd40: 85 c0 test %eax,%eax <== NOT EXECUTED
10cd42: 75 10 jne 10cd54 <ftruncate+0x90> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
10cd44: e8 87 19 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10cd49: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10cd4f: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10cd52: eb 0b jmp 10cd5f <ftruncate+0x9b> <== NOT EXECUTED
return (*iop->handlers->ftruncate_h)( iop, length );
10cd54: 52 push %edx <== NOT EXECUTED
10cd55: 52 push %edx <== NOT EXECUTED
10cd56: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
10cd59: 53 push %ebx <== NOT EXECUTED
10cd5a: ff d0 call *%eax <== NOT EXECUTED
10cd5c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
10cd5f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10cd62: 5b pop %ebx <== NOT EXECUTED
10cd63: 5e pop %esi <== NOT EXECUTED
10cd64: 5f pop %edi <== NOT EXECUTED
10cd65: c9 leave <== NOT EXECUTED
10cd66: c3 ret <== NOT EXECUTED
0011764c <getpid>:
*
* 4.1.1 Get Process and Parent Process IDs, P1003.1b-1993, p. 83
*/
pid_t getpid( void )
{
11764c: 55 push %ebp <== NOT EXECUTED
11764d: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return _Objects_Local_node;
}
11764f: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
117654: c9 leave <== NOT EXECUTED
117655: c3 ret <== NOT EXECUTED
0010cd68 <gettimeofday>:
int gettimeofday(
struct timeval *tp,
void * __tz
)
{
10cd68: 55 push %ebp
10cd69: 89 e5 mov %esp,%ebp
10cd6b: 56 push %esi
10cd6c: 53 push %ebx
10cd6d: 83 ec 20 sub $0x20,%esp
10cd70: 8b 75 08 mov 0x8(%ebp),%esi
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp ) {
10cd73: 85 f6 test %esi,%esi
10cd75: 75 10 jne 10cd87 <gettimeofday+0x1f> <== ALWAYS TAKEN
errno = EFAULT;
10cd77: e8 54 19 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10cd7c: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED
10cd82: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10cd85: eb 2a jmp 10cdb1 <gettimeofday+0x49> <== NOT EXECUTED
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
10cd87: 9c pushf
10cd88: fa cli
10cd89: 5b pop %ebx
* This routine grows @a the_heap memory area using the size bytes which
10cd8a: 83 ec 0c sub $0xc,%esp
10cd8d: 8d 45 f0 lea -0x10(%ebp),%eax
10cd90: 50 push %eax
10cd91: e8 06 d1 ff ff call 109e9c <_TOD_Get>
* begin at @a starting_address.
10cd96: 53 push %ebx
10cd97: 9d popf
*
* @param[in] the_heap is the heap to operate upon
10cd98: 8b 45 f0 mov -0x10(%ebp),%eax
10cd9b: 89 06 mov %eax,(%esi)
* @param[in] starting_address is the starting address of the memory
10cd9d: 8b 45 f4 mov -0xc(%ebp),%eax
10cda0: b9 e8 03 00 00 mov $0x3e8,%ecx
10cda5: 31 d2 xor %edx,%edx
10cda7: f7 f1 div %ecx
10cda9: 89 46 04 mov %eax,0x4(%esi)
10cdac: 31 c0 xor %eax,%eax
10cdae: 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;
}
10cdb1: 8d 65 f8 lea -0x8(%ebp),%esp
10cdb4: 5b pop %ebx
10cdb5: 5e pop %esi
10cdb6: c9 leave
10cdb7: c3 ret
00107a7c <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
107a7c: 55 push %ebp <== NOT EXECUTED
107a7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107a7f: 56 push %esi <== NOT EXECUTED
107a80: 53 push %ebx <== NOT EXECUTED
107a81: 89 d6 mov %edx,%esi <== NOT EXECUTED
107a83: 88 c3 mov %al,%bl <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP)
107a85: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED
107a88: f6 c1 20 test $0x20,%cl <== NOT EXECUTED
107a8b: 74 03 je 107a90 <iproc+0x14> <== NOT EXECUTED
c &= 0x7f;
107a8d: 83 e3 7f and $0x7f,%ebx <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
107a90: f6 c5 02 test $0x2,%ch <== NOT EXECUTED
107a93: 74 13 je 107aa8 <iproc+0x2c> <== NOT EXECUTED
c = tolower (c);
107a95: 0f b6 d3 movzbl %bl,%edx <== NOT EXECUTED
107a98: a1 98 aa 11 00 mov 0x11aa98,%eax <== NOT EXECUTED
107a9d: f6 04 10 01 testb $0x1,(%eax,%edx,1) <== NOT EXECUTED
107aa1: 74 03 je 107aa6 <iproc+0x2a> <== NOT EXECUTED
107aa3: 83 c2 20 add $0x20,%edx <== NOT EXECUTED
107aa6: 88 d3 mov %dl,%bl <== NOT EXECUTED
if (c == '\r') {
107aa8: 80 fb 0d cmp $0xd,%bl <== NOT EXECUTED
107aab: 75 11 jne 107abe <iproc+0x42> <== NOT EXECUTED
if (tty->termios.c_iflag & IGNCR)
107aad: 84 c9 test %cl,%cl <== NOT EXECUTED
107aaf: 0f 88 c9 00 00 00 js 107b7e <iproc+0x102> <== NOT EXECUTED
return 0;
if (tty->termios.c_iflag & ICRNL)
107ab5: 80 e5 01 and $0x1,%ch <== NOT EXECUTED
107ab8: 74 1c je 107ad6 <iproc+0x5a> <== NOT EXECUTED
107aba: b3 0a mov $0xa,%bl <== NOT EXECUTED
107abc: eb 18 jmp 107ad6 <iproc+0x5a> <== NOT EXECUTED
c = '\n';
}
else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
107abe: 80 fb 0a cmp $0xa,%bl <== NOT EXECUTED
107ac1: 75 0b jne 107ace <iproc+0x52> <== NOT EXECUTED
107ac3: 80 e1 40 and $0x40,%cl <== NOT EXECUTED
107ac6: 0f 85 b8 00 00 00 jne 107b84 <iproc+0x108> <== NOT EXECUTED
107acc: eb 08 jmp 107ad6 <iproc+0x5a> <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
107ace: 84 db test %bl,%bl <== NOT EXECUTED
107ad0: 0f 84 80 00 00 00 je 107b56 <iproc+0xda> <== NOT EXECUTED
107ad6: 8b 56 3c mov 0x3c(%esi),%edx <== NOT EXECUTED
107ad9: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
107adc: 74 78 je 107b56 <iproc+0xda> <== NOT EXECUTED
if (c == tty->termios.c_cc[VERASE]) {
107ade: 3a 5e 43 cmp 0x43(%esi),%bl <== NOT EXECUTED
107ae1: 75 04 jne 107ae7 <iproc+0x6b> <== NOT EXECUTED
erase (tty, 0);
107ae3: 31 d2 xor %edx,%edx <== NOT EXECUTED
107ae5: eb 0a jmp 107af1 <iproc+0x75> <== NOT EXECUTED
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
107ae7: 3a 5e 44 cmp 0x44(%esi),%bl <== NOT EXECUTED
107aea: 75 11 jne 107afd <iproc+0x81> <== NOT EXECUTED
erase (tty, 1);
107aec: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED
107af1: 89 f0 mov %esi,%eax <== NOT EXECUTED
107af3: e8 17 fe ff ff call 10790f <erase> <== NOT EXECUTED
107af8: e9 81 00 00 00 jmp 107b7e <iproc+0x102> <== NOT EXECUTED
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
107afd: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
107b02: 3a 5e 45 cmp 0x45(%esi),%bl <== NOT EXECUTED
107b05: 74 79 je 107b80 <iproc+0x104> <== NOT EXECUTED
return 1;
}
else if (c == '\n') {
107b07: 80 fb 0a cmp $0xa,%bl <== NOT EXECUTED
107b0a: 75 1d jne 107b29 <iproc+0xad> <== NOT EXECUTED
if (tty->termios.c_lflag & (ECHO | ECHONL))
107b0c: 80 e2 48 and $0x48,%dl <== NOT EXECUTED
107b0f: 74 0c je 107b1d <iproc+0xa1> <== NOT EXECUTED
echo (c, tty);
107b11: 89 f2 mov %esi,%edx <== NOT EXECUTED
107b13: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
107b18: e8 9a fd ff ff call 1078b7 <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
107b1d: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED
107b20: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED
107b23: c6 04 02 0a movb $0xa,(%edx,%eax,1) <== NOT EXECUTED
107b27: eb 22 jmp 107b4b <iproc+0xcf> <== NOT EXECUTED
return 1;
}
else if ((c == tty->termios.c_cc[VEOL])
107b29: 3a 5e 4c cmp 0x4c(%esi),%bl <== NOT EXECUTED
107b2c: 74 05 je 107b33 <iproc+0xb7> <== NOT EXECUTED
107b2e: 3a 5e 51 cmp 0x51(%esi),%bl <== NOT EXECUTED
107b31: 75 23 jne 107b56 <iproc+0xda> <== NOT EXECUTED
|| (c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
107b33: 80 e2 08 and $0x8,%dl <== NOT EXECUTED
107b36: 74 0a je 107b42 <iproc+0xc6> <== NOT EXECUTED
echo (c, tty);
107b38: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED
107b3b: 89 f2 mov %esi,%edx <== NOT EXECUTED
107b3d: e8 75 fd ff ff call 1078b7 <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
107b42: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED
107b45: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED
107b48: 88 1c 02 mov %bl,(%edx,%eax,1) <== NOT EXECUTED
107b4b: 40 inc %eax <== NOT EXECUTED
107b4c: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED
107b4f: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
107b54: eb 2a jmp 107b80 <iproc+0x104> <== NOT EXECUTED
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
107b56: a1 1c aa 11 00 mov 0x11aa1c,%eax <== NOT EXECUTED
107b5b: 48 dec %eax <== NOT EXECUTED
107b5c: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED
107b5f: 7d 1d jge 107b7e <iproc+0x102> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO)
107b61: f6 46 3c 08 testb $0x8,0x3c(%esi) <== NOT EXECUTED
107b65: 74 0a je 107b71 <iproc+0xf5> <== NOT EXECUTED
echo (c, tty);
107b67: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED
107b6a: 89 f2 mov %esi,%edx <== NOT EXECUTED
107b6c: e8 46 fd ff ff call 1078b7 <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
107b71: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED
107b74: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED
107b77: 88 1c 02 mov %bl,(%edx,%eax,1) <== NOT EXECUTED
107b7a: 40 inc %eax <== NOT EXECUTED
107b7b: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED
107b7e: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
return 0;
}
107b80: 5b pop %ebx <== NOT EXECUTED
107b81: 5e pop %esi <== NOT EXECUTED
107b82: c9 leave <== NOT EXECUTED
107b83: c3 ret <== NOT EXECUTED
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
107b84: b3 0d mov $0xd,%bl <== NOT EXECUTED
107b86: e9 4b ff ff ff jmp 107ad6 <iproc+0x5a> <== NOT EXECUTED
00114b8c <isatty>:
#include <sys/stat.h>
int isatty(
int fd
)
{
114b8c: 55 push %ebp
114b8d: 89 e5 mov %esp,%ebp
114b8f: 83 ec 60 sub $0x60,%esp
struct stat buf;
if (fstat (fd, &buf) < 0)
114b92: 8d 45 b4 lea -0x4c(%ebp),%eax
114b95: 50 push %eax
114b96: ff 75 08 pushl 0x8(%ebp)
114b99: e8 4a ff ff ff call 114ae8 <fstat>
114b9e: 83 c4 10 add $0x10,%esp
114ba1: 31 d2 xor %edx,%edx
114ba3: 85 c0 test %eax,%eax
114ba5: 78 12 js 114bb9 <isatty+0x2d> <== NEVER TAKEN
114ba7: 8b 45 c0 mov -0x40(%ebp),%eax
114baa: 25 00 f0 00 00 and $0xf000,%eax
114baf: 31 d2 xor %edx,%edx
114bb1: 3d 00 20 00 00 cmp $0x2000,%eax
114bb6: 0f 94 c2 sete %dl
if (S_ISCHR (buf.st_mode))
return 1;
return 0;
}
114bb9: 89 d0 mov %edx,%eax
114bbb: c9 leave
114bbc: c3 ret
00117758 <kill>:
* These are directly supported (and completely correct) in the posix api.
*/
#if !defined(RTEMS_POSIX_API)
int kill( pid_t pid, int sig )
{
117758: 55 push %ebp <== NOT EXECUTED
117759: 89 e5 mov %esp,%ebp <== NOT EXECUTED
return 0;
}
11775b: 31 c0 xor %eax,%eax <== NOT EXECUTED
11775d: c9 leave <== NOT EXECUTED
11775e: c3 ret <== NOT EXECUTED
001068fa <libc_create_hook>:
*/
bool libc_create_hook(
rtems_tcb *current_task,
rtems_tcb *creating_task
)
{
1068fa: 55 push %ebp
1068fb: 89 e5 mov %esp,%ebp
1068fd: 57 push %edi
1068fe: 56 push %esi
1068ff: 53 push %ebx
106900: 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));
106903: 68 00 04 00 00 push $0x400
106908: e8 7c 54 00 00 call 10bd89 <_Workspace_Allocate>
10690d: 89 c3 mov %eax,%ebx
#endif
if (ptr) {
10690f: 83 c4 10 add $0x10,%esp
106912: 31 c0 xor %eax,%eax
106914: 85 db test %ebx,%ebx
106916: 0f 84 2a 02 00 00 je 106b46 <libc_create_hook+0x24c><== NEVER TAKEN
_REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */
10691c: c7 03 00 00 00 00 movl $0x0,(%ebx)
106922: 8d 93 ec 02 00 00 lea 0x2ec(%ebx),%edx
106928: 89 53 04 mov %edx,0x4(%ebx)
10692b: 8d 83 48 03 00 00 lea 0x348(%ebx),%eax
106931: 89 43 08 mov %eax,0x8(%ebx)
106934: 8d 83 a4 03 00 00 lea 0x3a4(%ebx),%eax
10693a: 89 43 0c mov %eax,0xc(%ebx)
10693d: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
106944: 8d 7b 14 lea 0x14(%ebx),%edi
106947: be 19 00 00 00 mov $0x19,%esi
10694c: 31 c0 xor %eax,%eax
10694e: 89 f1 mov %esi,%ecx
106950: f3 aa rep stos %al,%es:(%edi)
106952: 89 ce mov %ecx,%esi
106954: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx)
10695b: c7 43 34 f4 67 11 00 movl $0x1167f4,0x34(%ebx)
106962: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx)
106969: c7 43 3c 00 00 00 00 movl $0x0,0x3c(%ebx)
106970: c7 43 40 00 00 00 00 movl $0x0,0x40(%ebx)
106977: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
10697e: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
106985: c7 43 4c 00 00 00 00 movl $0x0,0x4c(%ebx)
10698c: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
106993: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx)
10699a: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx)
1069a1: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
1069a8: c6 43 60 00 movb $0x0,0x60(%ebx)
1069ac: 8d 7b 7c lea 0x7c(%ebx),%edi
1069af: b1 09 mov $0x9,%cl
1069b1: 89 f0 mov %esi,%eax
1069b3: f3 ab rep stos %eax,%es:(%edi)
1069b5: c7 83 a0 00 00 00 00 movl $0x0,0xa0(%ebx)
1069bc: 00 00 00
1069bf: c7 83 a4 00 00 00 01 movl $0x1,0xa4(%ebx)
1069c6: 00 00 00
1069c9: c7 83 a8 00 00 00 00 movl $0x0,0xa8(%ebx)
1069d0: 00 00 00
1069d3: 66 c7 83 ac 00 00 00 movw $0x330e,0xac(%ebx)
1069da: 0e 33
1069dc: 66 c7 83 ae 00 00 00 movw $0xabcd,0xae(%ebx)
1069e3: cd ab
1069e5: 66 c7 83 b0 00 00 00 movw $0x1234,0xb0(%ebx)
1069ec: 34 12
1069ee: 66 c7 83 b2 00 00 00 movw $0xe66d,0xb2(%ebx)
1069f5: 6d e6
1069f7: 66 c7 83 b4 00 00 00 movw $0xdeec,0xb4(%ebx)
1069fe: ec de
106a00: 66 c7 83 b6 00 00 00 movw $0x5,0xb6(%ebx)
106a07: 05 00
106a09: 66 c7 83 b8 00 00 00 movw $0xb,0xb8(%ebx)
106a10: 0b 00
106a12: c7 83 bc 00 00 00 00 movl $0x0,0xbc(%ebx)
106a19: 00 00 00
106a1c: c7 83 c0 00 00 00 00 movl $0x0,0xc0(%ebx)
106a23: 00 00 00
106a26: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx)
106a2d: 00 00 00
106a30: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx)
106a37: 00 00 00
106a3a: c7 83 cc 00 00 00 00 movl $0x0,0xcc(%ebx)
106a41: 00 00 00
106a44: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx)
106a4b: 00 00 00
106a4e: c7 83 f8 00 00 00 00 movl $0x0,0xf8(%ebx)
106a55: 00 00 00
106a58: c7 83 fc 00 00 00 00 movl $0x0,0xfc(%ebx)
106a5f: 00 00 00
106a62: c7 83 00 01 00 00 00 movl $0x0,0x100(%ebx)
106a69: 00 00 00
106a6c: c7 83 04 01 00 00 00 movl $0x0,0x104(%ebx)
106a73: 00 00 00
106a76: c7 83 08 01 00 00 00 movl $0x0,0x108(%ebx)
106a7d: 00 00 00
106a80: c7 83 0c 01 00 00 00 movl $0x0,0x10c(%ebx)
106a87: 00 00 00
106a8a: c7 83 10 01 00 00 00 movl $0x0,0x110(%ebx)
106a91: 00 00 00
106a94: c7 83 14 01 00 00 00 movl $0x0,0x114(%ebx)
106a9b: 00 00 00
106a9e: c7 83 18 01 00 00 00 movl $0x0,0x118(%ebx)
106aa5: 00 00 00
106aa8: c7 83 1c 01 00 00 00 movl $0x0,0x11c(%ebx)
106aaf: 00 00 00
106ab2: c6 83 d4 00 00 00 00 movb $0x0,0xd4(%ebx)
106ab9: c6 83 dc 00 00 00 00 movb $0x0,0xdc(%ebx)
106ac0: c7 83 f4 00 00 00 00 movl $0x0,0xf4(%ebx)
106ac7: 00 00 00
106aca: c7 83 48 01 00 00 00 movl $0x0,0x148(%ebx)
106ad1: 00 00 00
106ad4: c7 83 4c 01 00 00 00 movl $0x0,0x14c(%ebx)
106adb: 00 00 00
106ade: c7 83 50 01 00 00 00 movl $0x0,0x150(%ebx)
106ae5: 00 00 00
106ae8: c7 83 54 01 00 00 00 movl $0x0,0x154(%ebx)
106aef: 00 00 00
106af2: c7 83 d4 02 00 00 00 movl $0x0,0x2d4(%ebx)
106af9: 00 00 00
106afc: c7 83 d4 01 00 00 00 movl $0x0,0x1d4(%ebx)
106b03: 00 00 00
106b06: c7 83 dc 02 00 00 00 movl $0x0,0x2dc(%ebx)
106b0d: 00 00 00
106b10: c7 83 e0 02 00 00 00 movl $0x0,0x2e0(%ebx)
106b17: 00 00 00
106b1a: c7 83 e4 02 00 00 00 movl $0x0,0x2e4(%ebx)
106b21: 00 00 00
106b24: c7 83 e8 02 00 00 00 movl $0x0,0x2e8(%ebx)
106b2b: 00 00 00
106b2e: c7 45 e8 45 00 00 00 movl $0x45,-0x18(%ebp)
106b35: 89 d7 mov %edx,%edi
106b37: b1 45 mov $0x45,%cl
106b39: f3 ab rep stos %eax,%es:(%edi)
creating_task->libc_reent = ptr;
106b3b: 8b 45 0c mov 0xc(%ebp),%eax
106b3e: 89 98 f0 00 00 00 mov %ebx,0xf0(%eax)
106b44: b0 01 mov $0x1,%al
return true;
}
else
return false;
}
106b46: 8d 65 f4 lea -0xc(%ebp),%esp
106b49: 5b pop %ebx
106b4a: 5e pop %esi
106b4b: 5f pop %edi
106b4c: c9 leave
106b4d: c3 ret
00106844 <libc_delete_hook>:
rtems_extension libc_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
106844: 55 push %ebp
106845: 89 e5 mov %esp,%ebp
106847: 57 push %edi
106848: 56 push %esi
106849: 53 push %ebx
10684a: 83 ec 0c sub $0xc,%esp
10684d: 8b 7d 08 mov 0x8(%ebp),%edi
106850: 8b 75 0c mov 0xc(%ebp),%esi
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
106853: 39 f7 cmp %esi,%edi
106855: 75 08 jne 10685f <libc_delete_hook+0x1b>
ptr = _REENT;
106857: 8b 1d a0 aa 11 00 mov 0x11aaa0,%ebx
10685d: eb 06 jmp 106865 <libc_delete_hook+0x21>
} else {
ptr = deleted_task->libc_reent;
10685f: 8b 9e f0 00 00 00 mov 0xf0(%esi),%ebx
}
if (ptr && ptr != &libc_global_reent) {
106865: 85 db test %ebx,%ebx
106867: 74 20 je 106889 <libc_delete_hook+0x45> <== NEVER TAKEN
106869: 81 fb 18 a6 11 00 cmp $0x11a618,%ebx
10686f: 74 18 je 106889 <libc_delete_hook+0x45>
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
106871: 50 push %eax
106872: 50 push %eax
106873: 68 a9 68 10 00 push $0x1068a9
106878: 53 push %ebx
106879: e8 0a 85 00 00 call 10ed88 <_fwalk>
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
10687e: 89 1c 24 mov %ebx,(%esp)
106881: e8 ee 54 00 00 call 10bd74 <_Workspace_Free>
106886: 83 c4 10 add $0x10,%esp
#endif
}
deleted_task->libc_reent = NULL;
106889: c7 86 f0 00 00 00 00 movl $0x0,0xf0(%esi)
106890: 00 00 00
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
106893: 39 f7 cmp %esi,%edi
106895: 75 0a jne 1068a1 <libc_delete_hook+0x5d>
_REENT = 0;
106897: c7 05 a0 aa 11 00 00 movl $0x0,0x11aaa0
10689e: 00 00 00
}
}
1068a1: 8d 65 f4 lea -0xc(%ebp),%esp
1068a4: 5b pop %ebx
1068a5: 5e pop %esi
1068a6: 5f pop %edi
1068a7: c9 leave
1068a8: c3 ret
00114c84 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
114c84: 55 push %ebp
114c85: 89 e5 mov %esp,%ebp
114c87: 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()))
114c8a: 83 3d 80 cc 11 00 03 cmpl $0x3,0x11cc80
114c91: 75 55 jne 114ce8 <libc_wrapup+0x64> <== NEVER TAKEN
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != &libc_global_reent) {
114c93: 81 3d a0 aa 11 00 18 cmpl $0x11a618,0x11aaa0
114c9a: a6 11 00
114c9d: 74 1a je 114cb9 <libc_wrapup+0x35>
_wrapup_reent(&libc_global_reent);
114c9f: 83 ec 0c sub $0xc,%esp
114ca2: 68 18 a6 11 00 push $0x11a618
114ca7: e8 b8 05 00 00 call 115264 <_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;
114cac: c7 05 a0 aa 11 00 18 movl $0x11a618,0x11aaa0
114cb3: a6 11 00
114cb6: 83 c4 10 add $0x10,%esp
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
114cb9: 83 ec 0c sub $0xc,%esp
114cbc: a1 a0 aa 11 00 mov 0x11aaa0,%eax
114cc1: ff 70 04 pushl 0x4(%eax)
114cc4: e8 53 9b ff ff call 10e81c <fclose>
fclose (stdout);
114cc9: 5a pop %edx
114cca: a1 a0 aa 11 00 mov 0x11aaa0,%eax
114ccf: ff 70 08 pushl 0x8(%eax)
114cd2: e8 45 9b ff ff call 10e81c <fclose>
fclose (stderr);
114cd7: 58 pop %eax
114cd8: a1 a0 aa 11 00 mov 0x11aaa0,%eax
114cdd: ff 70 0c pushl 0xc(%eax)
114ce0: e8 37 9b ff ff call 10e81c <fclose>
114ce5: 83 c4 10 add $0x10,%esp
}
114ce8: c9 leave
114ce9: c3 ret
00114bc0 <lseek>:
off_t lseek(
int fd,
off_t offset,
int whence
)
{
114bc0: 55 push %ebp <== NOT EXECUTED
114bc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
114bc3: 56 push %esi <== NOT EXECUTED
114bc4: 53 push %ebx <== NOT EXECUTED
114bc5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
114bc8: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
114bcb: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
114bce: 3b 05 b8 86 11 00 cmp 0x1186b8,%eax <== NOT EXECUTED
114bd4: 73 0f jae 114be5 <lseek+0x25> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
114bd6: 6b d8 34 imul $0x34,%eax,%ebx <== NOT EXECUTED
114bd9: 03 1d 80 c9 11 00 add 0x11c980,%ebx <== NOT EXECUTED
rtems_libio_check_is_open(iop);
114bdf: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED
114be3: 75 0d jne 114bf2 <lseek+0x32> <== NOT EXECUTED
114be5: e8 e6 9a ff ff call 10e6d0 <__errno> <== NOT EXECUTED
114bea: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
114bf0: eb 46 jmp 114c38 <lseek+0x78> <== NOT EXECUTED
/*
* Check as many errors as possible before touching iop->offset.
*/
if ( !iop->handlers->lseek_h )
114bf2: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED
114bf5: 83 78 14 00 cmpl $0x0,0x14(%eax) <== NOT EXECUTED
114bf9: 75 0d jne 114c08 <lseek+0x48> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
114bfb: e8 d0 9a ff ff call 10e6d0 <__errno> <== NOT EXECUTED
114c00: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
114c06: eb 30 jmp 114c38 <lseek+0x78> <== NOT EXECUTED
/*
* Now process the lseek().
*/
old_offset = iop->offset;
114c08: 8b 73 08 mov 0x8(%ebx),%esi <== NOT EXECUTED
switch ( whence ) {
114c0b: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED
114c0e: 74 0e je 114c1e <lseek+0x5e> <== NOT EXECUTED
114c10: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED
114c13: 74 0e je 114c23 <lseek+0x63> <== NOT EXECUTED
114c15: 85 d2 test %edx,%edx <== NOT EXECUTED
114c17: 75 14 jne 114c2d <lseek+0x6d> <== NOT EXECUTED
case SEEK_SET:
iop->offset = offset;
114c19: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED
114c1c: eb 1f jmp 114c3d <lseek+0x7d> <== NOT EXECUTED
break;
case SEEK_CUR:
iop->offset += offset;
114c1e: 8d 04 31 lea (%ecx,%esi,1),%eax <== NOT EXECUTED
114c21: eb 05 jmp 114c28 <lseek+0x68> <== NOT EXECUTED
break;
case SEEK_END:
iop->offset = iop->size + offset;
114c23: 89 c8 mov %ecx,%eax <== NOT EXECUTED
114c25: 03 43 04 add 0x4(%ebx),%eax <== NOT EXECUTED
114c28: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED
114c2b: eb 10 jmp 114c3d <lseek+0x7d> <== NOT EXECUTED
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
114c2d: e8 9e 9a ff ff call 10e6d0 <__errno> <== NOT EXECUTED
114c32: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
114c38: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
114c3b: eb 15 jmp 114c52 <lseek+0x92> <== NOT EXECUTED
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->handlers->lseek_h)( iop, offset, whence );
114c3d: 50 push %eax <== NOT EXECUTED
114c3e: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED
114c41: 52 push %edx <== NOT EXECUTED
114c42: 51 push %ecx <== NOT EXECUTED
114c43: 53 push %ebx <== NOT EXECUTED
114c44: ff 50 14 call *0x14(%eax) <== NOT EXECUTED
if ( status == (off_t) -1 )
114c47: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
114c4a: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED
114c4d: 75 03 jne 114c52 <lseek+0x92> <== NOT EXECUTED
iop->offset = old_offset;
114c4f: 89 73 08 mov %esi,0x8(%ebx) <== NOT EXECUTED
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
114c52: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
114c55: 5b pop %ebx <== NOT EXECUTED
114c56: 5e pop %esi <== NOT EXECUTED
114c57: c9 leave <== NOT EXECUTED
114c58: c3 ret <== NOT EXECUTED
00106674 <malloc>:
size_t size
)
{
void *return_this;
MSBUMP(malloc_calls, 1);
106674: 55 push %ebp
106675: 89 e5 mov %esp,%ebp
106677: 56 push %esi
106678: 53 push %ebx
106679: 8b 75 08 mov 0x8(%ebp),%esi
10667c: ff 05 f4 c9 11 00 incl 0x11c9f4
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
106682: e8 48 ff ff ff call 1065cf <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
106687: 85 f6 test %esi,%esi
106689: 74 75 je 106700 <malloc+0x8c> <== NEVER TAKEN
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
10668b: 83 3d 80 cc 11 00 03 cmpl $0x3,0x11cc80
106692: 75 09 jne 10669d <malloc+0x29>
106694: e8 df fe ff ff call 106578 <malloc_is_system_state_OK>
106699: 84 c0 test %al,%al
10669b: 74 63 je 106700 <malloc+0x8c> <== NEVER TAKEN
* Try to give a segment in the current heap if there is not
* enough space then try to grow the heap.
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( &RTEMS_Malloc_Heap, size );
10669d: 51 push %ecx
10669e: 51 push %ecx
10669f: 56 push %esi
1066a0: 68 98 c9 11 00 push $0x11c998
1066a5: e8 ee 41 00 00 call 10a898 <_Protected_heap_Allocate>
1066aa: 89 c3 mov %eax,%ebx
if ( !return_this ) {
1066ac: 83 c4 10 add $0x10,%esp
1066af: 85 c0 test %eax,%eax
1066b1: 75 26 jne 1066d9 <malloc+0x65> <== ALWAYS TAKEN
if (rtems_malloc_sbrk_helpers)
1066b3: a1 58 af 11 00 mov 0x11af58,%eax <== NOT EXECUTED
1066b8: 85 c0 test %eax,%eax <== NOT EXECUTED
1066ba: 74 0e je 1066ca <malloc+0x56> <== NOT EXECUTED
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
1066bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1066bf: 56 push %esi <== NOT EXECUTED
1066c0: ff 50 04 call *0x4(%eax) <== NOT EXECUTED
if ( !return_this ) {
1066c3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1066c6: 85 c0 test %eax,%eax <== NOT EXECUTED
1066c8: 75 0d jne 1066d7 <malloc+0x63> <== NOT EXECUTED
errno = ENOMEM;
1066ca: e8 01 80 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
1066cf: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
1066d5: eb 2b jmp 106702 <malloc+0x8e> <== NOT EXECUTED
return (void *) 0;
1066d7: 89 c3 mov %eax,%ebx <== NOT EXECUTED
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
1066d9: a1 5c af 11 00 mov 0x11af5c,%eax
1066de: 85 c0 test %eax,%eax
1066e0: 74 09 je 1066eb <malloc+0x77> <== ALWAYS TAKEN
(*rtems_malloc_dirty_helper)( return_this, size );
1066e2: 52 push %edx <== NOT EXECUTED
1066e3: 52 push %edx <== NOT EXECUTED
1066e4: 56 push %esi <== NOT EXECUTED
1066e5: 53 push %ebx <== NOT EXECUTED
1066e6: ff d0 call *%eax <== NOT EXECUTED
1066e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
1066eb: a1 54 af 11 00 mov 0x11af54,%eax
1066f0: 85 c0 test %eax,%eax
1066f2: 74 0e je 106702 <malloc+0x8e> <== ALWAYS TAKEN
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
1066f4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1066f7: 53 push %ebx <== NOT EXECUTED
1066f8: ff 50 04 call *0x4(%eax) <== NOT EXECUTED
1066fb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1066fe: eb 02 jmp 106702 <malloc+0x8e> <== NOT EXECUTED
106700: 31 db xor %ebx,%ebx <== NOT EXECUTED
if (rtems_malloc_boundary_helpers)
(*rtems_malloc_boundary_helpers->at_malloc)(return_this, size);
#endif
return return_this;
}
106702: 89 d8 mov %ebx,%eax
106704: 8d 65 f8 lea -0x8(%ebp),%esp
106707: 5b pop %ebx
106708: 5e pop %esi
106709: c9 leave
10670a: c3 ret
001065b7 <malloc_deferred_free>:
}
void malloc_deferred_free(
void *pointer
)
{
1065b7: 55 push %ebp <== NOT EXECUTED
1065b8: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1065ba: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
1065bd: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
1065c0: 68 8c c9 11 00 push $0x11c98c <== NOT EXECUTED
1065c5: e8 82 34 00 00 call 109a4c <_Chain_Append> <== NOT EXECUTED
1065ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_chain_append(&RTEMS_Malloc_GC_list, (rtems_chain_node *)pointer);
}
1065cd: c9 leave <== NOT EXECUTED
1065ce: c3 ret <== NOT EXECUTED
001065cf <malloc_deferred_frees_process>:
{
rtems_chain_initialize_empty(&RTEMS_Malloc_GC_list);
}
void malloc_deferred_frees_process(void)
{
1065cf: 55 push %ebp
1065d0: 89 e5 mov %esp,%ebp
1065d2: 83 ec 08 sub $0x8,%esp
1065d5: eb 0c jmp 1065e3 <malloc_deferred_frees_process+0x14>
/*
* If some free's have been deferred, then do them now.
*/
while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL)
free(to_be_freed);
1065d7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1065da: 50 push %eax <== NOT EXECUTED
1065db: e8 98 fe ff ff call 106478 <free> <== NOT EXECUTED
1065e0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1065e3: 83 ec 0c sub $0xc,%esp
1065e6: 68 8c c9 11 00 push $0x11c98c
1065eb: e8 80 34 00 00 call 109a70 <_Chain_Get>
rtems_chain_node *to_be_freed;
/*
* If some free's have been deferred, then do them now.
*/
while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL)
1065f0: 83 c4 10 add $0x10,%esp
1065f3: 85 c0 test %eax,%eax
1065f5: 75 e0 jne 1065d7 <malloc_deferred_frees_process+0x8><== NEVER TAKEN
free(to_be_freed);
}
1065f7: c9 leave
1065f8: c3 ret
00106578 <malloc_is_system_state_OK>:
#include "malloc_p.h"
rtems_chain_control RTEMS_Malloc_GC_list;
bool malloc_is_system_state_OK(void)
{
106578: 55 push %ebp
106579: 89 e5 mov %esp,%ebp
if ( _Thread_Dispatch_disable_level > 0 )
10657b: a1 e0 ca 11 00 mov 0x11cae0,%eax
106580: 31 d2 xor %edx,%edx
106582: 85 c0 test %eax,%eax
106584: 75 0a jne 106590 <malloc_is_system_state_OK+0x18><== NEVER TAKEN
return false;
if ( _ISR_Nest_level > 0 )
106586: a1 7c cb 11 00 mov 0x11cb7c,%eax
10658b: 85 c0 test %eax,%eax
10658d: 0f 94 c2 sete %dl
return false;
return true;
}
106590: 88 d0 mov %dl,%al
106592: c9 leave
106593: c3 ret
0010670c <mknod>:
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
10670c: 55 push %ebp
10670d: 89 e5 mov %esp,%ebp
10670f: 57 push %edi
106710: 56 push %esi
106711: 53 push %ebx
106712: 83 ec 2c sub $0x2c,%esp
106715: 8b 5d 08 mov 0x8(%ebp),%ebx
106718: 8b 45 10 mov 0x10(%ebp),%eax
10671b: 8b 55 14 mov 0x14(%ebp),%edx
10671e: 89 45 c8 mov %eax,-0x38(%ebp)
106721: 89 55 cc mov %edx,-0x34(%ebp)
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT) {
106724: 8b 45 0c mov 0xc(%ebp),%eax
106727: 25 00 f0 00 00 and $0xf000,%eax
10672c: 3d 00 40 00 00 cmp $0x4000,%eax
106731: 74 2b je 10675e <mknod+0x52>
106733: 77 0e ja 106743 <mknod+0x37> <== NEVER TAKEN
106735: 3d 00 10 00 00 cmp $0x1000,%eax
10673a: 74 29 je 106765 <mknod+0x59> <== NEVER TAKEN
10673c: 3d 00 20 00 00 cmp $0x2000,%eax
106741: eb 0c jmp 10674f <mknod+0x43>
106743: 3d 00 60 00 00 cmp $0x6000,%eax <== NOT EXECUTED
106748: 74 14 je 10675e <mknod+0x52> <== NOT EXECUTED
10674a: 3d 00 80 00 00 cmp $0x8000,%eax <== NOT EXECUTED
10674f: 74 0d je 10675e <mknod+0x52> <== ALWAYS TAKEN
case S_IFBLK:
case S_IFREG:
case S_IFIFO:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
106751: e8 7a 7f 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
106756: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
10675c: eb 12 jmp 106770 <mknod+0x64> <== NOT EXECUTED
}
if ( S_ISFIFO(mode) )
10675e: 3d 00 10 00 00 cmp $0x1000,%eax
106763: 75 13 jne 106778 <mknod+0x6c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
106765: e8 66 7f 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10676a: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
106770: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED
106773: e9 a6 00 00 00 jmp 10681e <mknod+0x112> <== NOT EXECUTED
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
106778: 8a 03 mov (%ebx),%al
10677a: 3c 2f cmp $0x2f,%al
10677c: 74 08 je 106786 <mknod+0x7a> <== ALWAYS TAKEN
10677e: 3c 5c cmp $0x5c,%al <== NOT EXECUTED
106780: 74 04 je 106786 <mknod+0x7a> <== NOT EXECUTED
106782: 84 c0 test %al,%al <== NOT EXECUTED
106784: 75 16 jne 10679c <mknod+0x90> <== NOT EXECUTED
106786: 8d 7d dc lea -0x24(%ebp),%edi
106789: a1 4c aa 11 00 mov 0x11aa4c,%eax
10678e: 8d 70 14 lea 0x14(%eax),%esi
106791: b9 04 00 00 00 mov $0x4,%ecx
106796: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
106798: b1 01 mov $0x1,%cl
10679a: eb 12 jmp 1067ae <mknod+0xa2>
10679c: 8d 7d dc lea -0x24(%ebp),%edi <== NOT EXECUTED
10679f: a1 4c aa 11 00 mov 0x11aa4c,%eax <== NOT EXECUTED
1067a4: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED
1067a7: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
1067ac: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
if ( !temp_loc.ops->evalformake_h ) {
1067ae: 8b 45 e4 mov -0x1c(%ebp),%eax
1067b1: 8b 50 04 mov 0x4(%eax),%edx
1067b4: 85 d2 test %edx,%edx
1067b6: 74 ad je 106765 <mknod+0x59> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*temp_loc.ops->evalformake_h)(
1067b8: 50 push %eax
1067b9: 8d 45 ec lea -0x14(%ebp),%eax
1067bc: 50 push %eax
1067bd: 8d 7d dc lea -0x24(%ebp),%edi
1067c0: 57 push %edi
1067c1: 8d 04 0b lea (%ebx,%ecx,1),%eax
1067c4: 50 push %eax
1067c5: ff d2 call *%edx
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
1067c7: 83 c4 10 add $0x10,%esp
1067ca: 83 ce ff or $0xffffffff,%esi
1067cd: 85 c0 test %eax,%eax
1067cf: 75 4d jne 10681e <mknod+0x112> <== NEVER TAKEN
return -1;
if ( !temp_loc.ops->mknod_h ) {
1067d1: 8b 45 e4 mov -0x1c(%ebp),%eax
1067d4: 8b 50 14 mov 0x14(%eax),%edx
1067d7: 85 d2 test %edx,%edx
1067d9: 75 15 jne 1067f0 <mknod+0xe4> <== ALWAYS TAKEN
rtems_filesystem_freenode( &temp_loc );
1067db: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
1067de: 85 c0 test %eax,%eax <== NOT EXECUTED
1067e0: 74 83 je 106765 <mknod+0x59> <== NOT EXECUTED
1067e2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1067e5: 57 push %edi <== NOT EXECUTED
1067e6: ff d0 call *%eax <== NOT EXECUTED
1067e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1067eb: e9 75 ff ff ff jmp 106765 <mknod+0x59> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
1067f0: 83 ec 0c sub $0xc,%esp
1067f3: 57 push %edi
1067f4: ff 75 cc pushl -0x34(%ebp)
1067f7: ff 75 c8 pushl -0x38(%ebp)
1067fa: ff 75 0c pushl 0xc(%ebp)
1067fd: ff 75 ec pushl -0x14(%ebp)
106800: ff d2 call *%edx
106802: 89 c6 mov %eax,%esi
rtems_filesystem_freenode( &temp_loc );
106804: 8b 45 e4 mov -0x1c(%ebp),%eax
106807: 83 c4 20 add $0x20,%esp
10680a: 85 c0 test %eax,%eax
10680c: 74 10 je 10681e <mknod+0x112> <== NEVER TAKEN
10680e: 8b 40 1c mov 0x1c(%eax),%eax
106811: 85 c0 test %eax,%eax
106813: 74 09 je 10681e <mknod+0x112> <== ALWAYS TAKEN
106815: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106818: 57 push %edi <== NOT EXECUTED
106819: ff d0 call *%eax <== NOT EXECUTED
10681b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return result;
}
10681e: 89 f0 mov %esi,%eax
106820: 8d 65 f4 lea -0xc(%ebp),%esp
106823: 5b pop %ebx
106824: 5e pop %esi
106825: 5f pop %edi
106826: c9 leave
106827: c3 ret
0010d02d <mount>:
const rtems_filesystem_operations_table *fs_ops,
rtems_filesystem_options_t options,
const char *device,
const char *mount_point
)
{
10d02d: 55 push %ebp
10d02e: 89 e5 mov %esp,%ebp
10d030: 57 push %edi
10d031: 56 push %esi
10d032: 53 push %ebx
10d033: 83 ec 1c sub $0x1c,%esp
10d036: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Is there a file system operations table?
*/
if ( fs_ops == NULL ) {
10d039: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10d03d: 74 05 je 10d044 <mount+0x17> <== NEVER TAKEN
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
10d03f: 83 fe 01 cmp $0x1,%esi
10d042: 76 10 jbe 10d054 <mount+0x27> <== ALWAYS TAKEN
options != RTEMS_FILESYSTEM_READ_WRITE ) {
errno = EINVAL;
10d044: e8 87 16 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10d049: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
10d04f: e9 e4 01 00 00 jmp 10d238 <mount+0x20b> <== NOT EXECUTED
return -1;
}
/* Do they support being mounted at all ? */
if ( !fs_ops->fsmount_me_h ) {
10d054: 8b 45 0c mov 0xc(%ebp),%eax
10d057: 83 78 24 00 cmpl $0x0,0x24(%eax)
10d05b: 75 17 jne 10d074 <mount+0x47> <== ALWAYS TAKEN
errno = ENOTSUP;
10d05d: e8 6e 16 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10d062: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10d068: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
10d06f: e9 94 01 00 00 jmp 10d208 <mount+0x1db> <== NOT EXECUTED
/*
* Allocate a mount table entry
*/
size = sizeof(rtems_filesystem_mount_table_entry_t);
if ( device )
10d074: b8 64 00 00 00 mov $0x64,%eax
10d079: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10d07d: 74 0f je 10d08e <mount+0x61> <== ALWAYS TAKEN
size += strlen( device ) + 1;
10d07f: 31 c0 xor %eax,%eax
10d081: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED
10d084: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED
10d087: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED
10d089: f7 d1 not %ecx <== NOT EXECUTED
10d08b: 8d 41 64 lea 0x64(%ecx),%eax <== NOT EXECUTED
temp_mt_entry = malloc( size );
10d08e: 83 ec 0c sub $0xc,%esp
10d091: 50 push %eax
10d092: e8 dd 95 ff ff call 106674 <malloc>
10d097: 89 c3 mov %eax,%ebx
10d099: 89 45 e0 mov %eax,-0x20(%ebp)
if ( !temp_mt_entry ) {
10d09c: 83 c4 10 add $0x10,%esp
10d09f: 85 c0 test %eax,%eax
10d0a1: 75 10 jne 10d0b3 <mount+0x86> <== ALWAYS TAKEN
errno = ENOMEM;
10d0a3: e8 28 16 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10d0a8: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
10d0ae: e9 85 01 00 00 jmp 10d238 <mount+0x20b> <== NOT EXECUTED
return -1;
}
temp_mt_entry->mt_fs_root.mt_entry = temp_mt_entry;
10d0b3: 89 43 24 mov %eax,0x24(%ebx)
temp_mt_entry->options = options;
10d0b6: 89 70 28 mov %esi,0x28(%eax)
if ( device ) {
10d0b9: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10d0bd: 74 16 je 10d0d5 <mount+0xa8> <== ALWAYS TAKEN
temp_mt_entry->dev =
10d0bf: 8d 40 64 lea 0x64(%eax),%eax <== NOT EXECUTED
10d0c2: 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 );
10d0c5: 52 push %edx <== NOT EXECUTED
10d0c6: 52 push %edx <== NOT EXECUTED
10d0c7: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED
10d0ca: 50 push %eax <== NOT EXECUTED
10d0cb: e8 60 27 00 00 call 10f830 <strcpy> <== NOT EXECUTED
10d0d0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10d0d3: eb 07 jmp 10d0dc <mount+0xaf> <== NOT EXECUTED
} else
temp_mt_entry->dev = 0;
10d0d5: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( mount_point ) {
10d0dc: 83 7d 18 00 cmpl $0x0,0x18(%ebp)
10d0e0: 0f 84 a8 00 00 00 je 10d18e <mount+0x161> <== ALWAYS TAKEN
if ( rtems_filesystem_evaluate_path(
10d0e6: 6a 01 push $0x1 <== NOT EXECUTED
10d0e8: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED
10d0eb: 56 push %esi <== NOT EXECUTED
10d0ec: 6a 07 push $0x7 <== NOT EXECUTED
10d0ee: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED
10d0f1: e8 60 92 ff ff call 106356 <rtems_filesystem_evaluate_path><== NOT EXECUTED
10d0f6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10d0f9: 40 inc %eax <== NOT EXECUTED
10d0fa: 0f 84 08 01 00 00 je 10d208 <mount+0x1db> <== NOT EXECUTED
/*
* Test for node_type_h
*/
if (!loc.ops->node_type_h) {
10d100: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
10d103: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED
10d106: 85 c0 test %eax,%eax <== NOT EXECUTED
10d108: 75 10 jne 10d11a <mount+0xed> <== NOT EXECUTED
errno = ENOTSUP;
10d10a: e8 c1 15 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10d10f: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10d115: e9 f0 00 00 00 jmp 10d20a <mount+0x1dd> <== NOT EXECUTED
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
10d11a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10d11d: 56 push %esi <== NOT EXECUTED
10d11e: ff d0 call *%eax <== NOT EXECUTED
10d120: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10d123: 48 dec %eax <== NOT EXECUTED
10d124: 74 10 je 10d136 <mount+0x109> <== NOT EXECUTED
errno = ENOTDIR;
10d126: e8 a5 15 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10d12b: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
10d131: e9 d4 00 00 00 jmp 10d20a <mount+0x1dd> <== NOT EXECUTED
/*
* For each mount table entry
*/
for ( the_node = rtems_filesystem_mount_table_control.first;
10d136: a1 7c cd 11 00 mov 0x11cd7c,%eax <== NOT EXECUTED
!rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
the_node = the_node->next ) {
the_mount_entry = (rtems_filesystem_mount_table_entry_t *) the_node;
if ( the_mount_entry->mt_fs_root.node_access == loc->node_access )
10d13b: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
10d13e: eb 07 jmp 10d147 <mount+0x11a> <== NOT EXECUTED
10d140: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED
10d143: 74 0e je 10d153 <mount+0x126> <== 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 ) {
10d145: 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 );
10d147: 3d 80 cd 11 00 cmp $0x11cd80,%eax <== NOT EXECUTED
10d14c: 75 f2 jne 10d140 <mount+0x113> <== NOT EXECUTED
10d14e: e9 f0 00 00 00 jmp 10d243 <mount+0x216> <== NOT EXECUTED
/*
* You can only mount one file system onto a single mount point.
*/
if ( Is_node_fs_root( &loc ) ){
errno = EBUSY;
10d153: e8 78 15 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10d158: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED
10d15e: eb 0b jmp 10d16b <mount+0x13e> <== 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;
10d160: e8 6b 15 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10d165: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10d16b: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED
10d16e: e9 97 00 00 00 jmp 10d20a <mount+0x1dd> <== NOT EXECUTED
goto cleanup_and_bail;
}
if ( loc.ops->mount_h( temp_mt_entry ) ) {
10d173: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10d176: 53 push %ebx <== NOT EXECUTED
10d177: ff d0 call *%eax <== NOT EXECUTED
10d179: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10d17c: 85 c0 test %eax,%eax <== NOT EXECUTED
10d17e: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED
10d181: 74 07 je 10d18a <mount+0x15d> <== NOT EXECUTED
10d183: 89 c6 mov %eax,%esi <== NOT EXECUTED
10d185: e9 80 00 00 00 jmp 10d20a <mount+0x1dd> <== NOT EXECUTED
10d18a: 89 c6 mov %eax,%esi <== NOT EXECUTED
10d18c: eb 33 jmp 10d1c1 <mount+0x194> <== NOT EXECUTED
* 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;
10d18e: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
temp_mt_entry->mt_fs_root.handlers = NULL;
10d195: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
temp_mt_entry->mt_fs_root.ops = NULL;
10d19c: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
temp_mt_entry->mt_point_node.node_access = NULL;
10d1a3: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
temp_mt_entry->mt_point_node.handlers = NULL;
10d1aa: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
temp_mt_entry->mt_point_node.ops = NULL;
10d1b1: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
temp_mt_entry->mt_point_node.mt_entry = NULL;
10d1b8: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
10d1bf: 31 f6 xor %esi,%esi
}
if ( fs_ops->fsmount_me_h( temp_mt_entry ) ) {
10d1c1: 83 ec 0c sub $0xc,%esp
10d1c4: 53 push %ebx
10d1c5: 8b 55 0c mov 0xc(%ebp),%edx
10d1c8: ff 52 24 call *0x24(%edx)
10d1cb: 83 c4 10 add $0x10,%esp
10d1ce: 85 c0 test %eax,%eax
10d1d0: 74 15 je 10d1e7 <mount+0x1ba> <== ALWAYS TAKEN
/* try to undo the mount operation */
if ( loc.ops->unmount_h ) {
10d1d2: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
10d1d5: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED
10d1d8: 85 c0 test %eax,%eax <== NOT EXECUTED
10d1da: 74 2e je 10d20a <mount+0x1dd> <== NOT EXECUTED
loc.ops->unmount_h( temp_mt_entry );
10d1dc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10d1df: 53 push %ebx <== NOT EXECUTED
10d1e0: ff d0 call *%eax <== NOT EXECUTED
10d1e2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10d1e5: eb 23 jmp 10d20a <mount+0x1dd> <== NOT EXECUTED
10d1e7: 50 push %eax
10d1e8: 50 push %eax
10d1e9: 53 push %ebx
10d1ea: 68 7c cd 11 00 push $0x11cd7c
10d1ef: e8 58 c8 ff ff call 109a4c <_Chain_Append>
*/
rtems_chain_append( &rtems_filesystem_mount_table_control,
&temp_mt_entry->Node );
if ( mt_entry )
10d1f4: 83 c4 10 add $0x10,%esp
10d1f7: 31 c0 xor %eax,%eax
10d1f9: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
10d1fd: 74 3c je 10d23b <mount+0x20e> <== NEVER TAKEN
*mt_entry = temp_mt_entry;
10d1ff: 8b 7d 08 mov 0x8(%ebp),%edi
10d202: 89 1f mov %ebx,(%edi)
10d204: 31 c0 xor %eax,%eax
10d206: eb 33 jmp 10d23b <mount+0x20e>
10d208: 31 f6 xor %esi,%esi
return 0;
cleanup_and_bail:
free( temp_mt_entry );
10d20a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10d20d: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED
10d210: e8 63 92 ff ff call 106478 <free> <== NOT EXECUTED
if ( loc_to_free )
10d215: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10d218: 85 f6 test %esi,%esi <== NOT EXECUTED
10d21a: 74 1c je 10d238 <mount+0x20b> <== NOT EXECUTED
rtems_filesystem_freenode( loc_to_free );
10d21c: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED
10d21f: 85 c0 test %eax,%eax <== NOT EXECUTED
10d221: 74 15 je 10d238 <mount+0x20b> <== NOT EXECUTED
10d223: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
10d226: 85 c0 test %eax,%eax <== NOT EXECUTED
10d228: 74 0e je 10d238 <mount+0x20b> <== NOT EXECUTED
10d22a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10d22d: 56 push %esi <== NOT EXECUTED
10d22e: ff d0 call *%eax <== NOT EXECUTED
10d230: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10d233: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10d236: eb 03 jmp 10d23b <mount+0x20e> <== NOT EXECUTED
10d238: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
return -1;
}
10d23b: 8d 65 f4 lea -0xc(%ebp),%esp
10d23e: 5b pop %ebx
10d23f: 5e pop %esi
10d240: 5f pop %edi
10d241: c9 leave
10d242: c3 ret
* may have been allocated in loc should not be sent to freenode
* until the system is unmounted. It may be needed to correctly
* traverse the tree.
*/
temp_mt_entry->mt_point_node.node_access = loc.node_access;
10d243: 89 53 08 mov %edx,0x8(%ebx) <== NOT EXECUTED
temp_mt_entry->mt_point_node.handlers = loc.handlers;
10d246: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED
10d249: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED
temp_mt_entry->mt_point_node.ops = loc.ops;
10d24c: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED
10d24f: 89 53 10 mov %edx,0x10(%ebx) <== NOT EXECUTED
temp_mt_entry->mt_point_node.mt_entry = loc.mt_entry;
10d252: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED
10d255: 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 ){
10d258: 8b 42 20 mov 0x20(%edx),%eax <== NOT EXECUTED
10d25b: 85 c0 test %eax,%eax <== NOT EXECUTED
10d25d: 0f 85 10 ff ff ff jne 10d173 <mount+0x146> <== NOT EXECUTED
10d263: e9 f8 fe ff ff jmp 10d160 <mount+0x133> <== NOT EXECUTED
001068a9 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
1068a9: 55 push %ebp
1068aa: 89 e5 mov %esp,%ebp
1068ac: 53 push %ebx
1068ad: 83 ec 10 sub $0x10,%esp
1068b0: 8b 5d 08 mov 0x8(%ebp),%ebx
switch ( fileno(fp) ) {
1068b3: 53 push %ebx
1068b4: e8 03 81 00 00 call 10e9bc <fileno>
1068b9: 83 c4 10 add $0x10,%esp
1068bc: 83 f8 02 cmp $0x2,%eax
1068bf: 77 26 ja 1068e7 <newlib_free_buffers+0x3e><== NEVER TAKEN
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
1068c1: 80 7b 0c 00 cmpb $0x0,0xc(%ebx)
1068c5: 79 2c jns 1068f3 <newlib_free_buffers+0x4a>
free( fp->_bf._base );
1068c7: 83 ec 0c sub $0xc,%esp
1068ca: ff 73 10 pushl 0x10(%ebx)
1068cd: e8 a6 fb ff ff call 106478 <free>
fp->_flags &= ~__SMBF;
1068d2: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx)
fp->_bf._base = fp->_p = (unsigned char *) NULL;
1068d8: c7 03 00 00 00 00 movl $0x0,(%ebx)
1068de: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
1068e5: eb 09 jmp 1068f0 <newlib_free_buffers+0x47>
}
break;
default:
fclose(fp);
1068e7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1068ea: 53 push %ebx <== NOT EXECUTED
1068eb: e8 2c 7f 00 00 call 10e81c <fclose> <== NOT EXECUTED
1068f0: 83 c4 10 add $0x10,%esp
}
return 0;
}
1068f3: 31 c0 xor %eax,%eax
1068f5: 8b 5d fc mov -0x4(%ebp),%ebx
1068f8: c9 leave
1068f9: c3 ret
00106aa8 <null_initialize>:
rtems_device_driver null_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *pargp
)
{
106aa8: 55 push %ebp
106aa9: 89 e5 mov %esp,%ebp
106aab: 53 push %ebx
106aac: 83 ec 04 sub $0x4,%esp
106aaf: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_device_driver status;
if ( !initialized ) {
106ab2: 80 3d ac f1 11 00 00 cmpb $0x0,0x11f1ac
106ab9: 75 2b jne 106ae6 <null_initialize+0x3e>
initialized = 1;
106abb: c6 05 ac f1 11 00 01 movb $0x1,0x11f1ac
status = rtems_io_register_name(
106ac2: 50 push %eax
106ac3: 6a 00 push $0x0
106ac5: 53 push %ebx
106ac6: 68 c1 8e 11 00 push $0x118ec1
106acb: e8 f5 00 00 00 call 106bc5 <rtems_io_register_name>
"/dev/null",
major,
(rtems_device_minor_number) 0
);
if (status != RTEMS_SUCCESSFUL)
106ad0: 83 c4 10 add $0x10,%esp
106ad3: 85 c0 test %eax,%eax
106ad5: 74 09 je 106ae0 <null_initialize+0x38> <== ALWAYS TAKEN
rtems_fatal_error_occurred(status);
106ad7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106ada: 50 push %eax <== NOT EXECUTED
106adb: e8 34 38 00 00 call 10a314 <rtems_fatal_error_occurred><== NOT EXECUTED
NULL_major = major;
106ae0: 89 1d c0 f3 11 00 mov %ebx,0x11f3c0
}
return RTEMS_SUCCESSFUL;
}
106ae6: 31 c0 xor %eax,%eax
106ae8: 8b 5d fc mov -0x4(%ebp),%ebx
106aeb: c9 leave
106aec: c3 ret
00106a8d <null_write>:
rtems_device_driver null_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *pargp
)
{
106a8d: 55 push %ebp
106a8e: 89 e5 mov %esp,%ebp
106a90: 8b 55 10 mov 0x10(%ebp),%edx
rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) pargp;
if ( rw_args )
106a93: 85 d2 test %edx,%edx
106a95: 74 06 je 106a9d <null_write+0x10> <== ALWAYS TAKEN
rw_args->bytes_moved = rw_args->count;
106a97: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED
106a9a: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED
return NULL_SUCCESSFUL;
}
106a9d: 31 c0 xor %eax,%eax
106a9f: c9 leave
106aa0: c3 ret
00106bb0 <open>:
int open(
const char *pathname,
int flags,
...
)
{
106bb0: 55 push %ebp
106bb1: 89 e5 mov %esp,%ebp
106bb3: 57 push %edi
106bb4: 56 push %esi
106bb5: 53 push %ebx
106bb6: 83 ec 1c sub $0x1c,%esp
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
106bb9: 8b 45 0c mov 0xc(%ebp),%eax
106bbc: 40 inc %eax
if ( ( status & _FREAD ) == _FREAD )
106bbd: 89 c3 mov %eax,%ebx
106bbf: 83 e3 01 and $0x1,%ebx
106bc2: f7 db neg %ebx
106bc4: 83 e3 04 and $0x4,%ebx
eval_flags |= RTEMS_LIBIO_PERMS_READ;
if ( ( status & _FWRITE ) == _FWRITE )
106bc7: a8 02 test $0x2,%al
106bc9: 74 03 je 106bce <open+0x1e>
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
106bcb: 83 cb 02 or $0x2,%ebx
va_start(ap, flags);
mode = va_arg( ap, int );
106bce: 8b 45 10 mov 0x10(%ebp),%eax
106bd1: 89 45 dc mov %eax,-0x24(%ebp)
* code does not require changes here since network file
* descriptors are obtained using socket(), not open().
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
106bd4: e8 4c 63 00 00 call 10cf25 <rtems_libio_allocate>
106bd9: 89 45 e0 mov %eax,-0x20(%ebp)
if ( iop == 0 ) {
106bdc: be 17 00 00 00 mov $0x17,%esi
106be1: 85 c0 test %eax,%eax
106be3: 0f 84 8e 01 00 00 je 106d77 <open+0x1c7>
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
106be9: 6a 01 push $0x1
106beb: 8d 7d e4 lea -0x1c(%ebp),%edi
106bee: 57 push %edi
106bef: 53 push %ebx
106bf0: ff 75 08 pushl 0x8(%ebp)
106bf3: e8 5e f7 ff ff call 106356 <rtems_filesystem_evaluate_path>
pathname, eval_flags, &loc, true );
if ( status == -1 ) {
106bf8: 83 c4 10 add $0x10,%esp
106bfb: 40 inc %eax
106bfc: 75 61 jne 106c5f <open+0xaf> <== ALWAYS TAKEN
if ( errno != ENOENT ) {
106bfe: e8 cd 7a 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
106c03: 83 38 02 cmpl $0x2,(%eax) <== NOT EXECUTED
106c06: 75 2c jne 106c34 <open+0x84> <== 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) ) {
106c08: be 02 00 00 00 mov $0x2,%esi <== NOT EXECUTED
106c0d: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) <== NOT EXECUTED
106c14: 0f 84 2c 01 00 00 je 106d46 <open+0x196> <== NOT EXECUTED
rc = ENOENT;
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
106c1a: 6a 00 push $0x0 <== NOT EXECUTED
106c1c: 6a 00 push $0x0 <== NOT EXECUTED
106c1e: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED
106c21: 80 cc 80 or $0x80,%ah <== NOT EXECUTED
106c24: 50 push %eax <== NOT EXECUTED
106c25: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
106c28: e8 df fa ff ff call 10670c <mknod> <== NOT EXECUTED
if ( rc ) {
106c2d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106c30: 85 c0 test %eax,%eax <== NOT EXECUTED
106c32: 74 0c je 106c40 <open+0x90> <== NOT EXECUTED
rc = errno;
106c34: e8 97 7a 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
106c39: 8b 30 mov (%eax),%esi <== NOT EXECUTED
106c3b: e9 02 01 00 00 jmp 106d42 <open+0x192> <== NOT EXECUTED
goto done;
}
/* Sanity check to see if the file name exists after the mknod() */
status = rtems_filesystem_evaluate_path( pathname, 0x0, &loc, true );
106c40: 6a 01 push $0x1 <== NOT EXECUTED
106c42: 57 push %edi <== NOT EXECUTED
106c43: 6a 00 push $0x0 <== NOT EXECUTED
106c45: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
106c48: e8 09 f7 ff ff call 106356 <rtems_filesystem_evaluate_path><== NOT EXECUTED
if ( status != 0 ) { /* The file did not exist */
106c4d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106c50: be 0d 00 00 00 mov $0xd,%esi <== NOT EXECUTED
106c55: 85 c0 test %eax,%eax <== NOT EXECUTED
106c57: 0f 85 e9 00 00 00 jne 106d46 <open+0x196> <== NOT EXECUTED
106c5d: eb 1b jmp 106c7a <open+0xca> <== NOT EXECUTED
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
106c5f: 8b 45 0c mov 0xc(%ebp),%eax
106c62: 25 00 0a 00 00 and $0xa00,%eax
106c67: 3d 00 0a 00 00 cmp $0xa00,%eax
106c6c: 75 0c jne 106c7a <open+0xca> <== ALWAYS TAKEN
106c6e: be 11 00 00 00 mov $0x11,%esi <== NOT EXECUTED
106c73: 89 fb mov %edi,%ebx <== NOT EXECUTED
106c75: e9 ce 00 00 00 jmp 106d48 <open+0x198> <== NOT EXECUTED
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->handlers = loc.handlers;
106c7a: 8b 45 e8 mov -0x18(%ebp),%eax
106c7d: 8b 55 e0 mov -0x20(%ebp),%edx
106c80: 89 42 30 mov %eax,0x30(%edx)
iop->file_info = loc.node_access;
106c83: 8b 45 e4 mov -0x1c(%ebp),%eax
106c86: 89 42 2c mov %eax,0x2c(%edx)
iop->flags |= rtems_libio_fcntl_flags( flags );
106c89: 8b 5a 0c mov 0xc(%edx),%ebx
106c8c: 83 ec 0c sub $0xc,%esp
106c8f: ff 75 0c pushl 0xc(%ebp)
106c92: e8 20 63 00 00 call 10cfb7 <rtems_libio_fcntl_flags>
106c97: 09 c3 or %eax,%ebx
106c99: 8b 45 e0 mov -0x20(%ebp),%eax
106c9c: 89 58 0c mov %ebx,0xc(%eax)
iop->pathinfo = loc;
106c9f: 89 c7 mov %eax,%edi
106ca1: 83 c7 10 add $0x10,%edi
106ca4: 8d 75 e4 lea -0x1c(%ebp),%esi
106ca7: b9 04 00 00 00 mov $0x4,%ecx
106cac: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !iop->handlers->open_h ) {
106cae: 89 c2 mov %eax,%edx
106cb0: 8b 40 30 mov 0x30(%eax),%eax
106cb3: 8b 00 mov (%eax),%eax
106cb5: 83 c4 10 add $0x10,%esp
106cb8: 85 c0 test %eax,%eax
106cba: 0f 84 df 00 00 00 je 106d9f <open+0x1ef> <== NEVER TAKEN
rc = ENOTSUP;
goto done;
}
rc = (*iop->handlers->open_h)( iop, pathname, flags, mode );
106cc0: ff 75 dc pushl -0x24(%ebp)
106cc3: ff 75 0c pushl 0xc(%ebp)
106cc6: ff 75 08 pushl 0x8(%ebp)
106cc9: 52 push %edx
106cca: ff d0 call *%eax
106ccc: 89 c6 mov %eax,%esi
if ( rc )
106cce: 83 c4 10 add $0x10,%esp
106cd1: 85 c0 test %eax,%eax
106cd3: 0f 85 cb 00 00 00 jne 106da4 <open+0x1f4> <== NEVER TAKEN
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
106cd9: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
106ce0: 0f 84 9d 00 00 00 je 106d83 <open+0x1d3> <== ALWAYS TAKEN
rc = ftruncate( iop - rtems_libio_iops, 0 );
106ce6: 50 push %eax <== NOT EXECUTED
106ce7: 50 push %eax <== NOT EXECUTED
106ce8: 6a 00 push $0x0 <== NOT EXECUTED
106cea: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
106ced: 2b 05 80 c9 11 00 sub 0x11c980,%eax <== NOT EXECUTED
106cf3: c1 f8 02 sar $0x2,%eax <== NOT EXECUTED
106cf6: 69 c0 c5 4e ec c4 imul $0xc4ec4ec5,%eax,%eax <== NOT EXECUTED
106cfc: 50 push %eax <== NOT EXECUTED
106cfd: e8 c2 5f 00 00 call 10ccc4 <ftruncate> <== NOT EXECUTED
106d02: 89 c6 mov %eax,%esi <== NOT EXECUTED
if ( rc ) {
106d04: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106d07: 85 c0 test %eax,%eax <== NOT EXECUTED
106d09: 74 78 je 106d83 <open+0x1d3> <== NOT EXECUTED
if(errno) rc = errno;
106d0b: e8 c0 79 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
106d10: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED
106d13: 74 07 je 106d1c <open+0x16c> <== NOT EXECUTED
106d15: e8 b6 79 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
106d1a: 8b 30 mov (%eax),%esi <== NOT EXECUTED
close( iop - rtems_libio_iops );
106d1c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106d1f: a1 80 c9 11 00 mov 0x11c980,%eax <== NOT EXECUTED
106d24: 29 45 e0 sub %eax,-0x20(%ebp) <== NOT EXECUTED
106d27: c1 7d e0 02 sarl $0x2,-0x20(%ebp) <== NOT EXECUTED
106d2b: 69 45 e0 c5 4e ec c4 imul $0xc4ec4ec5,-0x20(%ebp),%eax <== NOT EXECUTED
106d32: 50 push %eax <== NOT EXECUTED
106d33: e8 08 5f 00 00 call 10cc40 <close> <== NOT EXECUTED
106d38: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED
106d3f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
*/
done:
va_end(ap);
if ( rc ) {
106d42: 85 f6 test %esi,%esi <== NOT EXECUTED
106d44: 74 3d je 106d83 <open+0x1d3> <== NOT EXECUTED
106d46: 31 db xor %ebx,%ebx <== NOT EXECUTED
if ( iop )
106d48: 83 7d e0 00 cmpl $0x0,-0x20(%ebp) <== NOT EXECUTED
106d4c: 74 0e je 106d5c <open+0x1ac> <== NOT EXECUTED
rtems_libio_free( iop );
106d4e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106d51: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED
106d54: e8 77 61 00 00 call 10ced0 <rtems_libio_free> <== NOT EXECUTED
106d59: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if ( loc_to_free )
106d5c: 85 db test %ebx,%ebx <== NOT EXECUTED
106d5e: 74 17 je 106d77 <open+0x1c7> <== NOT EXECUTED
rtems_filesystem_freenode( loc_to_free );
106d60: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED
106d63: 85 c0 test %eax,%eax <== NOT EXECUTED
106d65: 74 10 je 106d77 <open+0x1c7> <== NOT EXECUTED
106d67: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
106d6a: 85 c0 test %eax,%eax <== NOT EXECUTED
106d6c: 74 09 je 106d77 <open+0x1c7> <== NOT EXECUTED
106d6e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106d71: 53 push %ebx <== NOT EXECUTED
106d72: ff d0 call *%eax <== NOT EXECUTED
106d74: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( rc );
106d77: e8 54 79 00 00 call 10e6d0 <__errno>
106d7c: 89 30 mov %esi,(%eax)
106d7e: 83 c8 ff or $0xffffffff,%eax
106d81: eb 14 jmp 106d97 <open+0x1e7>
}
return iop - rtems_libio_iops;
106d83: 8b 15 80 c9 11 00 mov 0x11c980,%edx
106d89: 29 55 e0 sub %edx,-0x20(%ebp)
106d8c: c1 7d e0 02 sarl $0x2,-0x20(%ebp)
106d90: 69 45 e0 c5 4e ec c4 imul $0xc4ec4ec5,-0x20(%ebp),%eax
}
106d97: 8d 65 f4 lea -0xc(%ebp),%esp
106d9a: 5b pop %ebx
106d9b: 5e pop %esi
106d9c: 5f pop %edi
106d9d: c9 leave
106d9e: c3 ret
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
rtems_set_errno_and_return_minus_one( rc );
}
return iop - rtems_libio_iops;
106d9f: be 86 00 00 00 mov $0x86,%esi <== NOT EXECUTED
106da4: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED
106da7: eb 9f jmp 106d48 <open+0x198> <== NOT EXECUTED
00106b50 <open_dev_console>:
/*
* This is a replaceable stub
*/
void open_dev_console(void)
{
106b50: 55 push %ebp
106b51: 89 e5 mov %esp,%ebp
106b53: 83 ec 0c sub $0xc,%esp
int error_code = 'S' << 24 | 'T' << 16 | 'D' << 8;
/*
* Attempt to open /dev/console.
*/
if ((stdin_fd = open("/dev/console", O_RDONLY, 0)) == -1) {
106b56: 6a 00 push $0x0
106b58: 6a 00 push $0x0
106b5a: 68 33 56 11 00 push $0x115633
106b5f: e8 4c 00 00 00 call 106bb0 <open>
106b64: 83 c4 10 add $0x10,%esp
106b67: 40 inc %eax
106b68: 74 41 je 106bab <open_dev_console+0x5b>
/*
* But if we find /dev/console once, we better find it twice more
* or something is REALLY wrong.
*/
if ((stdout_fd = open("/dev/console", O_WRONLY, 0)) == -1)
106b6a: 52 push %edx
106b6b: 6a 00 push $0x0
106b6d: 6a 01 push $0x1
106b6f: 68 33 56 11 00 push $0x115633
106b74: e8 37 00 00 00 call 106bb0 <open>
106b79: 83 c4 10 add $0x10,%esp
106b7c: 40 inc %eax
106b7d: 75 0a jne 106b89 <open_dev_console+0x39> <== ALWAYS TAKEN
rtems_fatal_error_occurred( error_code | '1' );
106b7f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106b82: 68 31 44 54 53 push $0x53544431 <== NOT EXECUTED
106b87: eb 1d jmp 106ba6 <open_dev_console+0x56> <== NOT EXECUTED
if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1)
106b89: 50 push %eax
106b8a: 6a 00 push $0x0
106b8c: 6a 01 push $0x1
106b8e: 68 33 56 11 00 push $0x115633
106b93: e8 18 00 00 00 call 106bb0 <open>
106b98: 83 c4 10 add $0x10,%esp
106b9b: 40 inc %eax
106b9c: 75 0d jne 106bab <open_dev_console+0x5b> <== ALWAYS TAKEN
rtems_fatal_error_occurred( error_code | '2' );
106b9e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106ba1: 68 32 44 54 53 push $0x53544432 <== NOT EXECUTED
106ba6: e8 e1 2b 00 00 call 10978c <rtems_fatal_error_occurred><== NOT EXECUTED
}
106bab: c9 leave
106bac: c3 ret
001077a8 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
1077a8: 55 push %ebp
1077a9: 89 e5 mov %esp,%ebp
1077ab: 56 push %esi
1077ac: 53 push %ebx
1077ad: 83 ec 10 sub $0x10,%esp
1077b0: 89 d3 mov %edx,%ebx
1077b2: 88 45 f4 mov %al,-0xc(%ebp)
int i;
if (tty->termios.c_oflag & OPOST) {
1077b5: 8b 4a 34 mov 0x34(%edx),%ecx
1077b8: f6 c1 01 test $0x1,%cl
1077bb: 0f 84 df 00 00 00 je 1078a0 <oproc+0xf8> <== NEVER TAKEN
switch (c) {
1077c1: 3c 09 cmp $0x9,%al
1077c3: 74 76 je 10783b <oproc+0x93>
1077c5: 77 0d ja 1077d4 <oproc+0x2c> <== ALWAYS TAKEN
1077c7: 3c 08 cmp $0x8,%al <== NOT EXECUTED
1077c9: 0f 85 a6 00 00 00 jne 107875 <oproc+0xcd> <== NOT EXECUTED
1077cf: e9 94 00 00 00 jmp 107868 <oproc+0xc0> <== NOT EXECUTED
1077d4: 3c 0a cmp $0xa,%al
1077d6: 74 0a je 1077e2 <oproc+0x3a>
1077d8: 3c 0d cmp $0xd,%al
1077da: 0f 85 95 00 00 00 jne 107875 <oproc+0xcd> <== ALWAYS TAKEN
1077e0: eb 33 jmp 107815 <oproc+0x6d> <== NOT EXECUTED
case '\n':
if (tty->termios.c_oflag & ONLRET)
1077e2: 80 e1 20 and $0x20,%cl
1077e5: 74 07 je 1077ee <oproc+0x46> <== ALWAYS TAKEN
tty->column = 0;
1077e7: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLCR) {
1077ee: f6 43 34 04 testb $0x4,0x34(%ebx)
1077f2: 0f 84 a8 00 00 00 je 1078a0 <oproc+0xf8> <== NEVER TAKEN
rtems_termios_puts ("\r", 1, tty);
1077f8: 50 push %eax
1077f9: 53 push %ebx
1077fa: 6a 01 push $0x1
1077fc: 68 07 68 11 00 push $0x116807
107801: e8 8d fe ff ff call 107693 <rtems_termios_puts>
tty->column = 0;
107806: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx)
10780d: 83 c4 10 add $0x10,%esp
107810: e9 8b 00 00 00 jmp 1078a0 <oproc+0xf8>
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
107815: f6 c1 10 test $0x10,%cl <== NOT EXECUTED
107818: 74 0a je 107824 <oproc+0x7c> <== NOT EXECUTED
10781a: 83 7a 28 00 cmpl $0x0,0x28(%edx) <== NOT EXECUTED
10781e: 0f 84 8c 00 00 00 je 1078b0 <oproc+0x108> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
107824: f6 c1 08 test $0x8,%cl <== NOT EXECUTED
107827: 74 09 je 107832 <oproc+0x8a> <== NOT EXECUTED
c = '\n';
107829: c6 45 f4 0a movb $0xa,-0xc(%ebp) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
10782d: 80 e1 20 and $0x20,%cl <== NOT EXECUTED
107830: 74 6e je 1078a0 <oproc+0xf8> <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
107832: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED
107839: eb 65 jmp 1078a0 <oproc+0xf8> <== NOT EXECUTED
break;
case '\t':
i = 8 - (tty->column & 7);
10783b: 8b 52 28 mov 0x28(%edx),%edx
10783e: 89 d0 mov %edx,%eax
107840: 83 e0 07 and $0x7,%eax
107843: be 08 00 00 00 mov $0x8,%esi
107848: 29 c6 sub %eax,%esi
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
10784a: 81 e1 00 18 00 00 and $0x1800,%ecx
107850: 81 f9 00 18 00 00 cmp $0x1800,%ecx
107856: 8d 04 16 lea (%esi,%edx,1),%eax
107859: 75 15 jne 107870 <oproc+0xc8> <== NEVER TAKEN
tty->column += i;
10785b: 89 43 28 mov %eax,0x28(%ebx)
rtems_termios_puts ( " ", i, tty);
10785e: 50 push %eax
10785f: 53 push %ebx
107860: 56 push %esi
107861: 68 09 68 11 00 push $0x116809
107866: eb 40 jmp 1078a8 <oproc+0x100>
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
107868: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED
10786b: 85 c0 test %eax,%eax <== NOT EXECUTED
10786d: 7e 31 jle 1078a0 <oproc+0xf8> <== NOT EXECUTED
tty->column--;
10786f: 48 dec %eax <== NOT EXECUTED
107870: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
107873: eb 2b jmp 1078a0 <oproc+0xf8> <== NOT EXECUTED
break;
default:
if (tty->termios.c_oflag & OLCUC)
107875: 80 e1 02 and $0x2,%cl
107878: 74 14 je 10788e <oproc+0xe6> <== ALWAYS TAKEN
c = toupper(c);
10787a: 0f b6 d0 movzbl %al,%edx <== NOT EXECUTED
10787d: a1 98 aa 11 00 mov 0x11aa98,%eax <== NOT EXECUTED
107882: f6 04 10 02 testb $0x2,(%eax,%edx,1) <== NOT EXECUTED
107886: 74 03 je 10788b <oproc+0xe3> <== NOT EXECUTED
107888: 83 ea 20 sub $0x20,%edx <== NOT EXECUTED
10788b: 88 55 f4 mov %dl,-0xc(%ebp) <== NOT EXECUTED
if (!iscntrl(c))
10788e: 0f b6 55 f4 movzbl -0xc(%ebp),%edx
107892: a1 98 aa 11 00 mov 0x11aa98,%eax
107897: f6 04 10 20 testb $0x20,(%eax,%edx,1)
10789b: 75 03 jne 1078a0 <oproc+0xf8> <== NEVER TAKEN
tty->column++;
10789d: ff 43 28 incl 0x28(%ebx)
break;
}
}
rtems_termios_puts (&c, 1, tty);
1078a0: 56 push %esi
1078a1: 53 push %ebx
1078a2: 6a 01 push $0x1
1078a4: 8d 45 f4 lea -0xc(%ebp),%eax
1078a7: 50 push %eax
1078a8: e8 e6 fd ff ff call 107693 <rtems_termios_puts>
1078ad: 83 c4 10 add $0x10,%esp
}
1078b0: 8d 65 f8 lea -0x8(%ebp),%esp
1078b3: 5b pop %ebx
1078b4: 5e pop %esi
1078b5: c9 leave
1078b6: c3 ret
00108204 <posix_memalign>:
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
108204: 55 push %ebp
108205: 89 e5 mov %esp,%ebp
108207: 53 push %ebx
108208: 8b 5d 08 mov 0x8(%ebp),%ebx
10820b: 8b 55 0c mov 0xc(%ebp),%edx
10820e: 8b 4d 10 mov 0x10(%ebp),%ecx
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
108211: ff 05 04 19 12 00 incl 0x121904
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
108217: 8d 42 ff lea -0x1(%edx),%eax
10821a: 85 d0 test %edx,%eax
10821c: 75 05 jne 108223 <posix_memalign+0x1f> <== NEVER TAKEN
10821e: 83 fa 03 cmp $0x3,%edx
108221: 77 08 ja 10822b <posix_memalign+0x27>
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
}
108223: b8 16 00 00 00 mov $0x16,%eax
108228: 5b pop %ebx
108229: c9 leave
10822a: c3 ret
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
10822b: 89 4d 10 mov %ecx,0x10(%ebp)
10822e: 89 55 0c mov %edx,0xc(%ebp)
108231: 89 5d 08 mov %ebx,0x8(%ebp)
}
108234: 5b pop %ebx
108235: c9 leave
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
108236: e9 c1 03 00 00 jmp 1085fc <rtems_memalign>
00114d0c <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
114d0c: 55 push %ebp <== NOT EXECUTED
114d0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED
114d0f: 56 push %esi <== NOT EXECUTED
114d10: 53 push %ebx <== NOT EXECUTED
114d11: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
114d14: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED
114d17: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
114d1a: 3b 05 b8 86 11 00 cmp 0x1186b8,%eax <== NOT EXECUTED
114d20: 73 2d jae 114d4f <read+0x43> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
114d22: 6b d8 34 imul $0x34,%eax,%ebx <== NOT EXECUTED
114d25: 03 1d 80 c9 11 00 add 0x11c980,%ebx <== NOT EXECUTED
rtems_libio_check_is_open( iop );
114d2b: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED
114d2e: f6 c6 01 test $0x1,%dh <== NOT EXECUTED
114d31: 74 1c je 114d4f <read+0x43> <== NOT EXECUTED
rtems_libio_check_buffer( buffer );
114d33: 85 f6 test %esi,%esi <== NOT EXECUTED
114d35: 75 0d jne 114d44 <read+0x38> <== NOT EXECUTED
114d37: e8 94 99 ff ff call 10e6d0 <__errno> <== NOT EXECUTED
114d3c: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
114d42: eb 2d jmp 114d71 <read+0x65> <== NOT EXECUTED
rtems_libio_check_count( count );
114d44: 31 c0 xor %eax,%eax <== NOT EXECUTED
114d46: 85 c9 test %ecx,%ecx <== NOT EXECUTED
114d48: 74 3c je 114d86 <read+0x7a> <== NOT EXECUTED
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
114d4a: 80 e2 02 and $0x2,%dl <== NOT EXECUTED
114d4d: 75 0d jne 114d5c <read+0x50> <== NOT EXECUTED
114d4f: e8 7c 99 ff ff call 10e6d0 <__errno> <== NOT EXECUTED
114d54: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
114d5a: eb 15 jmp 114d71 <read+0x65> <== NOT EXECUTED
/*
* Now process the read().
*/
if ( !iop->handlers->read_h )
114d5c: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED
114d5f: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED
114d62: 85 c0 test %eax,%eax <== NOT EXECUTED
114d64: 75 10 jne 114d76 <read+0x6a> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
114d66: e8 65 99 ff ff call 10e6d0 <__errno> <== NOT EXECUTED
114d6b: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
114d71: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
114d74: eb 10 jmp 114d86 <read+0x7a> <== NOT EXECUTED
rc = (*iop->handlers->read_h)( iop, buffer, count );
114d76: 52 push %edx <== NOT EXECUTED
114d77: 51 push %ecx <== NOT EXECUTED
114d78: 56 push %esi <== NOT EXECUTED
114d79: 53 push %ebx <== NOT EXECUTED
114d7a: ff d0 call *%eax <== NOT EXECUTED
if ( rc > 0 )
114d7c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
114d7f: 85 c0 test %eax,%eax <== NOT EXECUTED
114d81: 7e 03 jle 114d86 <read+0x7a> <== NOT EXECUTED
iop->offset += rc;
114d83: 01 43 08 add %eax,0x8(%ebx) <== NOT EXECUTED
return rc;
}
114d86: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
114d89: 5b pop %ebx <== NOT EXECUTED
114d8a: 5e pop %esi <== NOT EXECUTED
114d8b: c9 leave <== NOT EXECUTED
114d8c: c3 ret <== NOT EXECUTED
00114e0c <realloc>:
{
size_t old_size;
char *new_area;
size_t resize;
MSBUMP(realloc_calls, 1);
114e0c: 55 push %ebp
114e0d: 89 e5 mov %esp,%ebp
114e0f: 57 push %edi
114e10: 56 push %esi
114e11: 53 push %ebx
114e12: 83 ec 1c sub $0x1c,%esp
114e15: 8b 5d 0c mov 0xc(%ebp),%ebx
114e18: ff 05 00 ca 11 00 incl 0x11ca00
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
114e1e: 83 3d 80 cc 11 00 03 cmpl $0x3,0x11cc80
114e25: 75 1a jne 114e41 <realloc+0x35> <== NEVER TAKEN
if (_Thread_Dispatch_disable_level > 0)
114e27: a1 e0 ca 11 00 mov 0x11cae0,%eax
114e2c: 85 c0 test %eax,%eax
114e2e: 0f 85 b7 00 00 00 jne 114eeb <realloc+0xdf> <== NEVER TAKEN
return (void *) 0;
if (_ISR_Nest_level > 0)
114e34: a1 7c cb 11 00 mov 0x11cb7c,%eax
114e39: 85 c0 test %eax,%eax
114e3b: 0f 85 aa 00 00 00 jne 114eeb <realloc+0xdf> <== NEVER TAKEN
}
/*
* Continue with realloc().
*/
if ( !ptr )
114e41: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
114e45: 75 0e jne 114e55 <realloc+0x49> <== ALWAYS TAKEN
return malloc( size );
114e47: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
114e4a: 53 push %ebx <== NOT EXECUTED
114e4b: e8 24 18 ff ff call 106674 <malloc> <== NOT EXECUTED
114e50: e9 8e 00 00 00 jmp 114ee3 <realloc+0xd7> <== NOT EXECUTED
if ( !size ) {
114e55: 85 db test %ebx,%ebx
114e57: 75 14 jne 114e6d <realloc+0x61> <== ALWAYS TAKEN
free( ptr );
114e59: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
114e5c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
114e5f: e8 14 16 ff ff call 106478 <free> <== NOT EXECUTED
114e64: c7 45 08 00 00 00 00 movl $0x0,0x8(%ebp) <== NOT EXECUTED
114e6b: eb 79 jmp 114ee6 <realloc+0xda> <== NOT EXECUTED
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) {
114e6d: 52 push %edx
114e6e: 8d 45 f0 lea -0x10(%ebp),%eax
114e71: 50 push %eax
114e72: ff 75 08 pushl 0x8(%ebp)
114e75: 68 98 c9 11 00 push $0x11c998
114e7a: e8 05 01 00 00 call 114f84 <_Protected_heap_Get_block_size>
114e7f: 83 c4 10 add $0x10,%esp
114e82: 84 c0 test %al,%al
114e84: 75 0d jne 114e93 <realloc+0x87>
errno = EINVAL;
114e86: e8 45 98 ff ff call 10e6d0 <__errno>
114e8b: c7 00 16 00 00 00 movl $0x16,(%eax)
114e91: eb 58 jmp 114eeb <realloc+0xdf>
#if defined(RTEMS_MALLOC_BOUNDARY_HELPERS)
if (rtems_malloc_boundary_helpers)
resize += (*rtems_malloc_boundary_helpers->overhead)();
#endif
if ( _Protected_heap_Resize_block( &RTEMS_Malloc_Heap, ptr, resize ) ) {
114e93: 50 push %eax
114e94: 53 push %ebx
114e95: ff 75 08 pushl 0x8(%ebp)
114e98: 68 98 c9 11 00 push $0x11c998
114e9d: e8 1a 01 00 00 call 114fbc <_Protected_heap_Resize_block>
114ea2: 83 c4 10 add $0x10,%esp
114ea5: 84 c0 test %al,%al
114ea7: 75 49 jne 114ef2 <realloc+0xe6>
* There used to be a free on this error case but it is wrong to
* free the memory per OpenGroup Single UNIX Specification V2
* and the C Standard.
*/
new_area = malloc( size );
114ea9: 83 ec 0c sub $0xc,%esp
114eac: 53 push %ebx
114ead: e8 c2 17 ff ff call 106674 <malloc>
114eb2: 89 45 d8 mov %eax,-0x28(%ebp)
MSBUMP(malloc_calls, -1); /* subtract off the malloc */
114eb5: ff 0d f4 c9 11 00 decl 0x11c9f4
if ( !new_area ) {
114ebb: 83 c4 10 add $0x10,%esp
114ebe: 85 c0 test %eax,%eax
114ec0: 74 29 je 114eeb <realloc+0xdf> <== NEVER TAKEN
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
114ec2: 8b 45 f0 mov -0x10(%ebp),%eax
114ec5: 89 d9 mov %ebx,%ecx
114ec7: 39 c3 cmp %eax,%ebx
114ec9: 76 02 jbe 114ecd <realloc+0xc1> <== NEVER TAKEN
114ecb: 89 c1 mov %eax,%ecx
114ecd: 8b 7d d8 mov -0x28(%ebp),%edi
114ed0: 8b 75 08 mov 0x8(%ebp),%esi
114ed3: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
free( ptr );
114ed5: 83 ec 0c sub $0xc,%esp
114ed8: ff 75 08 pushl 0x8(%ebp)
114edb: e8 98 15 ff ff call 106478 <free>
114ee0: 8b 45 d8 mov -0x28(%ebp),%eax
114ee3: 89 45 08 mov %eax,0x8(%ebp)
114ee6: 83 c4 10 add $0x10,%esp
114ee9: eb 07 jmp 114ef2 <realloc+0xe6>
return new_area;
114eeb: c7 45 08 00 00 00 00 movl $0x0,0x8(%ebp)
}
114ef2: 8b 45 08 mov 0x8(%ebp),%eax
114ef5: 8d 65 f4 lea -0xc(%ebp),%esp
114ef8: 5b pop %ebx
114ef9: 5e pop %esi
114efa: 5f pop %edi
114efb: c9 leave
114efc: c3 ret
0010e210 <rtems_assoc_local_by_remote>:
uint32_t rtems_assoc_local_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
10e210: 55 push %ebp
10e211: 89 e5 mov %esp,%ebp
10e213: 83 ec 10 sub $0x10,%esp
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
10e216: ff 75 0c pushl 0xc(%ebp)
10e219: ff 75 08 pushl 0x8(%ebp)
10e21c: e8 13 00 00 00 call 10e234 <rtems_assoc_ptr_by_remote>
10e221: 89 c2 mov %eax,%edx
if (nap)
10e223: 83 c4 10 add $0x10,%esp
10e226: 31 c0 xor %eax,%eax
10e228: 85 d2 test %edx,%edx
10e22a: 74 03 je 10e22f <rtems_assoc_local_by_remote+0x1f><== NEVER TAKEN
return nap->local_value;
10e22c: 8b 42 04 mov 0x4(%edx),%eax
return 0;
}
10e22f: c9 leave
10e230: c3 ret
0010e1d4 <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
10e1d4: 55 push %ebp
10e1d5: 89 e5 mov %esp,%ebp
10e1d7: 57 push %edi
10e1d8: 56 push %esi
10e1d9: 53 push %ebx
10e1da: 83 ec 0c sub $0xc,%esp
10e1dd: bb 01 00 00 00 mov $0x1,%ebx
10e1e2: 31 ff xor %edi,%edi
10e1e4: 31 f6 xor %esi,%esi
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
if (b & remote_value)
10e1e6: 85 5d 0c test %ebx,0xc(%ebp)
10e1e9: 74 10 je 10e1fb <rtems_assoc_local_by_remote_bitfield+0x27><== ALWAYS TAKEN
local_value |= rtems_assoc_local_by_remote(ap, b);
10e1eb: 50 push %eax <== NOT EXECUTED
10e1ec: 50 push %eax <== NOT EXECUTED
10e1ed: 53 push %ebx <== NOT EXECUTED
10e1ee: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
10e1f1: e8 1a 00 00 00 call 10e210 <rtems_assoc_local_by_remote><== NOT EXECUTED
10e1f6: 09 c7 or %eax,%edi <== NOT EXECUTED
10e1f8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
)
{
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
10e1fb: d1 e3 shl %ebx
10e1fd: 46 inc %esi
10e1fe: 83 fe 20 cmp $0x20,%esi
10e201: 75 e3 jne 10e1e6 <rtems_assoc_local_by_remote_bitfield+0x12>
if (b & remote_value)
local_value |= rtems_assoc_local_by_remote(ap, b);
}
return local_value;
}
10e203: 89 f8 mov %edi,%eax
10e205: 8d 65 f4 lea -0xc(%ebp),%esp
10e208: 5b pop %ebx
10e209: 5e pop %esi
10e20a: 5f pop %edi
10e20b: c9 leave
10e20c: c3 ret
0010f89c <rtems_assoc_name_bad>:
const char *
rtems_assoc_name_bad(
uint32_t bad_value
)
{
10f89c: 55 push %ebp <== NOT EXECUTED
10f89d: 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;
}
10f89f: b8 b8 e6 11 00 mov $0x11e6b8,%eax <== NOT EXECUTED
10f8a4: c9 leave <== NOT EXECUTED
10f8a5: c3 ret <== NOT EXECUTED
0010e1bc <rtems_assoc_name_by_local>:
const char *rtems_assoc_name_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
10e1bc: 55 push %ebp <== NOT EXECUTED
10e1bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10e1bf: 53 push %ebx <== NOT EXECUTED
10e1c0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10e1c3: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
10e1c6: 53 push %ebx <== NOT EXECUTED
10e1c7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
10e1ca: e8 1d 00 00 00 call 10e1ec <rtems_assoc_ptr_by_local><== NOT EXECUTED
if (nap)
10e1cf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10e1d2: 85 c0 test %eax,%eax <== NOT EXECUTED
10e1d4: 74 07 je 10e1dd <rtems_assoc_name_by_local+0x21><== NOT EXECUTED
return nap->name;
10e1d6: 8b 00 mov (%eax),%eax <== NOT EXECUTED
return rtems_assoc_name_bad(local_value);
}
10e1d8: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10e1db: c9 leave <== NOT EXECUTED
10e1dc: c3 ret <== NOT EXECUTED
nap = rtems_assoc_ptr_by_local(ap, local_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(local_value);
10e1dd: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED
}
10e1e0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10e1e3: 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);
10e1e4: e9 b3 16 00 00 jmp 10f89c <rtems_assoc_name_bad> <== NOT EXECUTED
0010e670 <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
10e670: 55 push %ebp
10e671: 89 e5 mov %esp,%ebp
10e673: 56 push %esi
10e674: 53 push %ebx
10e675: 8b 5d 08 mov 0x8(%ebp),%ebx
10e678: 8b 75 0c mov 0xc(%ebp),%esi
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
10e67b: 8b 03 mov (%ebx),%eax
10e67d: 85 c0 test %eax,%eax
10e67f: 74 1b je 10e69c <rtems_assoc_ptr_by_local+0x2c><== NEVER TAKEN
10e681: 52 push %edx
10e682: 52 push %edx
10e683: 68 dd 6e 11 00 push $0x116edd
10e688: 50 push %eax
10e689: e8 3e 11 00 00 call 10f7cc <strcmp>
10e68e: 83 c4 10 add $0x10,%esp
10e691: 85 c0 test %eax,%eax
10e693: 75 07 jne 10e69c <rtems_assoc_ptr_by_local+0x2c><== ALWAYS TAKEN
default_ap = ap++;
10e695: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10e697: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED
10e69a: eb 0c jmp 10e6a8 <rtems_assoc_ptr_by_local+0x38><== NOT EXECUTED
10e69c: 31 c0 xor %eax,%eax
10e69e: eb 08 jmp 10e6a8 <rtems_assoc_ptr_by_local+0x38>
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
10e6a0: 39 73 04 cmp %esi,0x4(%ebx)
10e6a3: 74 0a je 10e6af <rtems_assoc_ptr_by_local+0x3f>
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
10e6a5: 83 c3 0c add $0xc,%ebx
10e6a8: 83 3b 00 cmpl $0x0,(%ebx)
10e6ab: 75 f3 jne 10e6a0 <rtems_assoc_ptr_by_local+0x30>
10e6ad: 89 c3 mov %eax,%ebx
if (ap->local_value == local_value)
return ap;
return default_ap;
}
10e6af: 89 d8 mov %ebx,%eax
10e6b1: 8d 65 f8 lea -0x8(%ebp),%esp
10e6b4: 5b pop %ebx
10e6b5: 5e pop %esi
10e6b6: c9 leave
10e6b7: c3 ret
0010e234 <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
10e234: 55 push %ebp
10e235: 89 e5 mov %esp,%ebp
10e237: 56 push %esi
10e238: 53 push %ebx
10e239: 8b 5d 08 mov 0x8(%ebp),%ebx
10e23c: 8b 75 0c mov 0xc(%ebp),%esi
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
10e23f: 8b 03 mov (%ebx),%eax
10e241: 85 c0 test %eax,%eax
10e243: 74 1b je 10e260 <rtems_assoc_ptr_by_remote+0x2c><== NEVER TAKEN
10e245: 52 push %edx
10e246: 52 push %edx
10e247: 68 dd 6e 11 00 push $0x116edd
10e24c: 50 push %eax
10e24d: e8 7a 15 00 00 call 10f7cc <strcmp>
10e252: 83 c4 10 add $0x10,%esp
10e255: 85 c0 test %eax,%eax
10e257: 75 07 jne 10e260 <rtems_assoc_ptr_by_remote+0x2c><== ALWAYS TAKEN
default_ap = ap++;
10e259: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10e25b: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED
10e25e: eb 0c jmp 10e26c <rtems_assoc_ptr_by_remote+0x38><== NOT EXECUTED
10e260: 31 c0 xor %eax,%eax
10e262: eb 08 jmp 10e26c <rtems_assoc_ptr_by_remote+0x38>
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
10e264: 39 73 08 cmp %esi,0x8(%ebx)
10e267: 74 0a je 10e273 <rtems_assoc_ptr_by_remote+0x3f>
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
10e269: 83 c3 0c add $0xc,%ebx
10e26c: 83 3b 00 cmpl $0x0,(%ebx)
10e26f: 75 f3 jne 10e264 <rtems_assoc_ptr_by_remote+0x30><== ALWAYS TAKEN
10e271: 89 c3 mov %eax,%ebx <== NOT EXECUTED
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
10e273: 89 d8 mov %ebx,%eax
10e275: 8d 65 f8 lea -0x8(%ebp),%esp
10e278: 5b pop %ebx
10e279: 5e pop %esi
10e27a: c9 leave
10e27b: c3 ret
0010e27c <rtems_assoc_remote_by_local>:
uint32_t rtems_assoc_remote_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
10e27c: 55 push %ebp <== NOT EXECUTED
10e27d: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10e27f: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
10e282: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED
10e285: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
10e288: e8 e3 03 00 00 call 10e670 <rtems_assoc_ptr_by_local><== NOT EXECUTED
10e28d: 89 c2 mov %eax,%edx <== NOT EXECUTED
if (nap)
10e28f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10e292: 31 c0 xor %eax,%eax <== NOT EXECUTED
10e294: 85 d2 test %edx,%edx <== NOT EXECUTED
10e296: 74 03 je 10e29b <rtems_assoc_remote_by_local+0x1f><== NOT EXECUTED
return nap->remote_value;
10e298: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED
return 0;
}
10e29b: c9 leave <== NOT EXECUTED
10e29c: c3 ret <== NOT EXECUTED
00109568 <rtems_barrier_create>:
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
109568: 55 push %ebp
109569: 89 e5 mov %esp,%ebp
10956b: 57 push %edi
10956c: 56 push %esi
10956d: 53 push %ebx
10956e: 83 ec 1c sub $0x1c,%esp
109571: 8b 75 0c mov 0xc(%ebp),%esi
109574: 8b 55 10 mov 0x10(%ebp),%edx
109577: 8b 7d 14 mov 0x14(%ebp),%edi
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
10957a: b8 03 00 00 00 mov $0x3,%eax
10957f: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
109583: 0f 84 90 00 00 00 je 109619 <rtems_barrier_create+0xb1><== NEVER TAKEN
return RTEMS_INVALID_NAME;
if ( !id )
109589: b8 09 00 00 00 mov $0x9,%eax
10958e: 85 ff test %edi,%edi
109590: 0f 84 83 00 00 00 je 109619 <rtems_barrier_create+0xb1><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
109596: f7 c6 10 00 00 00 test $0x10,%esi
10959c: 74 12 je 1095b0 <rtems_barrier_create+0x48>
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
if ( maximum_waiters == 0 )
10959e: b8 0a 00 00 00 mov $0xa,%eax
1095a3: 85 d2 test %edx,%edx
1095a5: 74 72 je 109619 <rtems_barrier_create+0xb1>
if ( !id )
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
1095a7: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
1095ae: eb 07 jmp 1095b7 <rtems_barrier_create+0x4f>
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
1095b0: c7 45 ec 01 00 00 00 movl $0x1,-0x14(%ebp)
the_attributes.maximum_count = maximum_waiters;
1095b7: 89 55 f0 mov %edx,-0x10(%ebp)
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
1095ba: a1 f4 f4 11 00 mov 0x11f4f4,%eax
1095bf: 40 inc %eax
1095c0: a3 f4 f4 11 00 mov %eax,0x11f4f4
#ifdef __cplusplus
extern "C" {
#endif
/**
1095c5: 83 ec 0c sub $0xc,%esp
1095c8: 68 fc f3 11 00 push $0x11f3fc
1095cd: e8 c2 1a 00 00 call 10b094 <_Objects_Allocate>
1095d2: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
1095d4: 83 c4 10 add $0x10,%esp
1095d7: 85 c0 test %eax,%eax
1095d9: 75 0c jne 1095e7 <rtems_barrier_create+0x7f>
_Thread_Enable_dispatch();
1095db: e8 b8 26 00 00 call 10bc98 <_Thread_Enable_dispatch>
1095e0: b8 05 00 00 00 mov $0x5,%eax
1095e5: eb 32 jmp 109619 <rtems_barrier_create+0xb1>
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
1095e7: 89 70 10 mov %esi,0x10(%eax)
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
1095ea: 50 push %eax
1095eb: 50 push %eax
1095ec: 8d 45 ec lea -0x14(%ebp),%eax
1095ef: 50 push %eax
1095f0: 8d 43 14 lea 0x14(%ebx),%eax
1095f3: 50 push %eax
1095f4: e8 67 12 00 00 call 10a860 <_CORE_barrier_Initialize>
1095f9: 8b 4b 08 mov 0x8(%ebx),%ecx
1095fc: 0f b7 d1 movzwl %cx,%edx
1095ff: a1 18 f4 11 00 mov 0x11f418,%eax
109604: 89 1c 90 mov %ebx,(%eax,%edx,4)
109607: 8b 45 08 mov 0x8(%ebp),%eax
10960a: 89 43 0c mov %eax,0xc(%ebx)
&_Barrier_Information,
&the_barrier->Object,
(Objects_Name) name
);
*id = the_barrier->Object.id;
10960d: 89 0f mov %ecx,(%edi)
_Thread_Enable_dispatch();
10960f: e8 84 26 00 00 call 10bc98 <_Thread_Enable_dispatch>
109614: 31 c0 xor %eax,%eax
109616: 83 c4 10 add $0x10,%esp
return RTEMS_SUCCESSFUL;
}
109619: 8d 65 f4 lea -0xc(%ebp),%esp
10961c: 5b pop %ebx
10961d: 5e pop %esi
10961e: 5f pop %edi
10961f: c9 leave
109620: c3 ret
001096a8 <rtems_barrier_release>:
rtems_status_code rtems_barrier_release(
rtems_id id,
uint32_t *released
)
{
1096a8: 55 push %ebp
1096a9: 89 e5 mov %esp,%ebp
1096ab: 56 push %esi
1096ac: 53 push %ebx
1096ad: 83 ec 10 sub $0x10,%esp
1096b0: 8b 5d 08 mov 0x8(%ebp),%ebx
1096b3: 8b 75 0c mov 0xc(%ebp),%esi
Barrier_Control *the_barrier;
Objects_Locations location;
if ( !released )
1096b6: b8 09 00 00 00 mov $0x9,%eax
1096bb: 85 f6 test %esi,%esi
1096bd: 74 39 je 1096f8 <rtems_barrier_release+0x50><== NEVER TAKEN
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory
* to add to the heap
1096bf: 52 push %edx
1096c0: 8d 45 f4 lea -0xc(%ebp),%eax
1096c3: 50 push %eax
1096c4: 53 push %ebx
1096c5: 68 fc f3 11 00 push $0x11f3fc
1096ca: e8 09 1e 00 00 call 10b4d8 <_Objects_Get>
1096cf: 89 c2 mov %eax,%edx
return RTEMS_INVALID_ADDRESS;
the_barrier = _Barrier_Get( id, &location );
switch ( location ) {
1096d1: 83 c4 10 add $0x10,%esp
1096d4: b8 04 00 00 00 mov $0x4,%eax
1096d9: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
1096dd: 75 19 jne 1096f8 <rtems_barrier_release+0x50>
case OBJECTS_LOCAL:
*released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL );
1096df: 50 push %eax
1096e0: 6a 00 push $0x0
1096e2: 53 push %ebx
1096e3: 8d 42 14 lea 0x14(%edx),%eax
1096e6: 50 push %eax
1096e7: e8 a8 11 00 00 call 10a894 <_CORE_barrier_Release>
1096ec: 89 06 mov %eax,(%esi)
_Thread_Enable_dispatch();
1096ee: e8 a5 25 00 00 call 10bc98 <_Thread_Enable_dispatch>
1096f3: 31 c0 xor %eax,%eax
1096f5: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1096f8: 8d 65 f8 lea -0x8(%ebp),%esp
1096fb: 5b pop %ebx
1096fc: 5e pop %esi
1096fd: c9 leave
1096fe: c3 ret
00108984 <rtems_clock_get>:
rtems_status_code rtems_clock_get(
rtems_clock_get_options option,
void *time_buffer
)
{
108984: 55 push %ebp
108985: 89 e5 mov %esp,%ebp
108987: 53 push %ebx
108988: 83 ec 04 sub $0x4,%esp
10898b: 8b 55 08 mov 0x8(%ebp),%edx
10898e: 8b 5d 0c mov 0xc(%ebp),%ebx
if ( !time_buffer )
108991: b8 09 00 00 00 mov $0x9,%eax
108996: 85 db test %ebx,%ebx
108998: 74 44 je 1089de <rtems_clock_get+0x5a> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
switch ( option ) {
10899a: b8 0a 00 00 00 mov $0xa,%eax
10899f: 83 fa 04 cmp $0x4,%edx
1089a2: 77 3a ja 1089de <rtems_clock_get+0x5a>
1089a4: ff 24 95 18 68 11 00 jmp *0x116818(,%edx,4)
case RTEMS_CLOCK_GET_TOD:
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
1089ab: 89 5d 08 mov %ebx,0x8(%ebp)
break;
}
return RTEMS_INVALID_NUMBER;
}
1089ae: 58 pop %eax
1089af: 5b pop %ebx
1089b0: c9 leave
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
switch ( option ) {
case RTEMS_CLOCK_GET_TOD:
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
1089b1: e9 76 00 00 00 jmp 108a2c <rtems_clock_get_tod>
case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH:
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
1089b6: 89 5d 08 mov %ebx,0x8(%ebp)
break;
}
return RTEMS_INVALID_NUMBER;
}
1089b9: 5b pop %ebx
1089ba: 5b pop %ebx
1089bb: c9 leave
switch ( option ) {
case RTEMS_CLOCK_GET_TOD:
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH:
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
1089bc: e9 23 00 00 00 jmp 1089e4 <rtems_clock_get_seconds_since_epoch>
case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_since_boot();
1089c1: e8 5a 00 00 00 call 108a20 <rtems_clock_get_ticks_since_boot>
1089c6: eb 05 jmp 1089cd <rtems_clock_get+0x49>
return RTEMS_SUCCESSFUL;
}
case RTEMS_CLOCK_GET_TICKS_PER_SECOND: {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_per_second();
1089c8: e8 3f 00 00 00 call 108a0c <rtems_clock_get_ticks_per_second>
1089cd: 89 03 mov %eax,(%ebx)
1089cf: 31 c0 xor %eax,%eax
1089d1: eb 0b jmp 1089de <rtems_clock_get+0x5a>
return RTEMS_SUCCESSFUL;
}
case RTEMS_CLOCK_GET_TIME_VALUE:
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
1089d3: 89 5d 08 mov %ebx,0x8(%ebp)
break;
}
return RTEMS_INVALID_NUMBER;
}
1089d6: 59 pop %ecx
1089d7: 5b pop %ebx
1089d8: c9 leave
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
case RTEMS_CLOCK_GET_TIME_VALUE:
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
1089d9: e9 ea 00 00 00 jmp 108ac8 <rtems_clock_get_tod_timeval>
break;
}
return RTEMS_INVALID_NUMBER;
}
1089de: 5a pop %edx
1089df: 5b pop %ebx
1089e0: c9 leave
1089e1: c3 ret
001089e4 <rtems_clock_get_seconds_since_epoch>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
1089e4: 55 push %ebp
1089e5: 89 e5 mov %esp,%ebp
1089e7: 8b 55 08 mov 0x8(%ebp),%edx
if ( !the_interval )
1089ea: b8 09 00 00 00 mov $0x9,%eax
1089ef: 85 d2 test %edx,%edx
1089f1: 74 17 je 108a0a <rtems_clock_get_seconds_since_epoch+0x26><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
1089f3: b8 0b 00 00 00 mov $0xb,%eax
1089f8: 80 3d f4 ca 11 00 00 cmpb $0x0,0x11caf4
1089ff: 74 09 je 108a0a <rtems_clock_get_seconds_since_epoch+0x26>
return RTEMS_NOT_DEFINED;
*the_interval = _TOD_Seconds_since_epoch;
108a01: a1 70 cb 11 00 mov 0x11cb70,%eax
108a06: 89 02 mov %eax,(%edx)
108a08: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
108a0a: c9 leave
108a0b: c3 ret
00108a2c <rtems_clock_get_tod>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod(
rtems_time_of_day *time_buffer
)
{
108a2c: 55 push %ebp
108a2d: 89 e5 mov %esp,%ebp
108a2f: 56 push %esi
108a30: 53 push %ebx
108a31: 83 ec 50 sub $0x50,%esp
108a34: 8b 75 08 mov 0x8(%ebp),%esi
rtems_time_of_day *tmbuf = time_buffer;
struct tm time;
struct timeval now;
if ( !time_buffer )
108a37: b8 09 00 00 00 mov $0x9,%eax
108a3c: 85 f6 test %esi,%esi
108a3e: 74 7f je 108abf <rtems_clock_get_tod+0x93><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
108a40: b8 0b 00 00 00 mov $0xb,%eax
108a45: 80 3d f4 ca 11 00 00 cmpb $0x0,0x11caf4
108a4c: 74 71 je 108abf <rtems_clock_get_tod+0x93>
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
108a4e: 9c pushf
108a4f: fa cli
108a50: 5b pop %ebx
* This routine grows @a the_heap memory area using the size bytes which
108a51: 83 ec 0c sub $0xc,%esp
108a54: 8d 45 e8 lea -0x18(%ebp),%eax
108a57: 50 push %eax
108a58: e8 3f 14 00 00 call 109e9c <_TOD_Get>
* begin at @a starting_address.
108a5d: 53 push %ebx
108a5e: 9d popf
*
* @param[in] the_heap is the heap to operate upon
108a5f: 8b 45 e8 mov -0x18(%ebp),%eax
108a62: 89 45 f0 mov %eax,-0x10(%ebp)
* @param[in] starting_address is the starting address of the memory
108a65: 8b 45 ec mov -0x14(%ebp),%eax
108a68: b9 e8 03 00 00 mov $0x3e8,%ecx
108a6d: 31 d2 xor %edx,%edx
108a6f: f7 f1 div %ecx
108a71: 89 45 f4 mov %eax,-0xc(%ebp)
/* Obtain the current time */
_TOD_Get_timeval( &now );
/* Split it into a closer format */
gmtime_r( &now.tv_sec, &time );
108a74: 58 pop %eax
108a75: 5a pop %edx
108a76: 8d 45 c4 lea -0x3c(%ebp),%eax
108a79: 50 push %eax
108a7a: 8d 45 f0 lea -0x10(%ebp),%eax
108a7d: 50 push %eax
108a7e: e8 95 63 00 00 call 10ee18 <gmtime_r>
/* Now adjust it to the RTEMS format */
tmbuf->year = time.tm_year + 1900;
108a83: 8b 45 d8 mov -0x28(%ebp),%eax
108a86: 05 6c 07 00 00 add $0x76c,%eax
108a8b: 89 06 mov %eax,(%esi)
tmbuf->month = time.tm_mon + 1;
108a8d: 8b 45 d4 mov -0x2c(%ebp),%eax
108a90: 40 inc %eax
108a91: 89 46 04 mov %eax,0x4(%esi)
tmbuf->day = time.tm_mday;
108a94: 8b 45 d0 mov -0x30(%ebp),%eax
108a97: 89 46 08 mov %eax,0x8(%esi)
tmbuf->hour = time.tm_hour;
108a9a: 8b 45 cc mov -0x34(%ebp),%eax
108a9d: 89 46 0c mov %eax,0xc(%esi)
tmbuf->minute = time.tm_min;
108aa0: 8b 45 c8 mov -0x38(%ebp),%eax
108aa3: 89 46 10 mov %eax,0x10(%esi)
tmbuf->second = time.tm_sec;
108aa6: 8b 45 c4 mov -0x3c(%ebp),%eax
108aa9: 89 46 14 mov %eax,0x14(%esi)
tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick;
108aac: 8b 45 f4 mov -0xc(%ebp),%eax
108aaf: 31 d2 xor %edx,%edx
108ab1: f7 35 7c cc 11 00 divl 0x11cc7c
108ab7: 89 46 18 mov %eax,0x18(%esi)
108aba: 31 c0 xor %eax,%eax
108abc: 83 c4 10 add $0x10,%esp
return RTEMS_SUCCESSFUL;
}
108abf: 8d 65 f8 lea -0x8(%ebp),%esp
108ac2: 5b pop %ebx
108ac3: 5e pop %esi
108ac4: c9 leave
108ac5: c3 ret
00108ac8 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
108ac8: 55 push %ebp
108ac9: 89 e5 mov %esp,%ebp
108acb: 56 push %esi
108acc: 53 push %ebx
108acd: 83 ec 20 sub $0x20,%esp
108ad0: 8b 75 08 mov 0x8(%ebp),%esi
if ( !time )
108ad3: b8 09 00 00 00 mov $0x9,%eax
108ad8: 85 f6 test %esi,%esi
108ada: 74 38 je 108b14 <rtems_clock_get_tod_timeval+0x4c><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
108adc: b8 0b 00 00 00 mov $0xb,%eax
108ae1: 80 3d f4 ca 11 00 00 cmpb $0x0,0x11caf4
108ae8: 74 2a je 108b14 <rtems_clock_get_tod_timeval+0x4c>
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
108aea: 9c pushf
108aeb: fa cli
108aec: 5b pop %ebx
* This routine grows @a the_heap memory area using the size bytes which
108aed: 83 ec 0c sub $0xc,%esp
108af0: 8d 45 f0 lea -0x10(%ebp),%eax
108af3: 50 push %eax
108af4: e8 a3 13 00 00 call 109e9c <_TOD_Get>
* begin at @a starting_address.
108af9: 53 push %ebx
108afa: 9d popf
*
* @param[in] the_heap is the heap to operate upon
108afb: 8b 45 f0 mov -0x10(%ebp),%eax
108afe: 89 06 mov %eax,(%esi)
* @param[in] starting_address is the starting address of the memory
108b00: 8b 45 f4 mov -0xc(%ebp),%eax
108b03: b9 e8 03 00 00 mov $0x3e8,%ecx
108b08: 31 d2 xor %edx,%edx
108b0a: f7 f1 div %ecx
108b0c: 89 46 04 mov %eax,0x4(%esi)
108b0f: 31 c0 xor %eax,%eax
108b11: 83 c4 10 add $0x10,%esp
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
}
108b14: 8d 65 f8 lea -0x8(%ebp),%esp
108b17: 5b pop %ebx
108b18: 5e pop %esi
108b19: c9 leave
108b1a: c3 ret
00108d1c <rtems_clock_get_uptime>:
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
108d1c: 55 push %ebp
108d1d: 89 e5 mov %esp,%ebp
108d1f: 83 ec 08 sub $0x8,%esp
108d22: 8b 55 08 mov 0x8(%ebp),%edx
if ( !uptime )
108d25: b8 09 00 00 00 mov $0x9,%eax
108d2a: 85 d2 test %edx,%edx
108d2c: 74 0e je 108d3c <rtems_clock_get_uptime+0x20><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
_TOD_Get_uptime( uptime );
108d2e: 83 ec 0c sub $0xc,%esp
108d31: 52 push %edx
108d32: e8 e5 14 00 00 call 10a21c <_TOD_Get_uptime>
108d37: 31 c0 xor %eax,%eax
108d39: 83 c4 10 add $0x10,%esp
return RTEMS_SUCCESSFUL;
}
108d3c: c9 leave
108d3d: c3 ret
00109950 <rtems_clock_set>:
*/
rtems_status_code rtems_clock_set(
rtems_time_of_day *time_buffer
)
{
109950: 55 push %ebp
109951: 89 e5 mov %esp,%ebp
109953: 53 push %ebx
109954: 83 ec 14 sub $0x14,%esp
109957: 8b 5d 08 mov 0x8(%ebp),%ebx
struct timespec newtime;
if ( !time_buffer )
10995a: ba 09 00 00 00 mov $0x9,%edx
10995f: 85 db test %ebx,%ebx
109961: 74 54 je 1099b7 <rtems_clock_set+0x67> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( time_buffer ) ) {
109963: 83 ec 0c sub $0xc,%esp
109966: 53 push %ebx
109967: e8 f8 00 00 00 call 109a64 <_TOD_Validate>
10996c: 83 c4 10 add $0x10,%esp
10996f: ba 14 00 00 00 mov $0x14,%edx
109974: 84 c0 test %al,%al
109976: 74 3f je 1099b7 <rtems_clock_set+0x67>
newtime.tv_sec = _TOD_To_seconds( time_buffer );
109978: 83 ec 0c sub $0xc,%esp
10997b: 53 push %ebx
10997c: e8 7b 00 00 00 call 1099fc <_TOD_To_seconds>
109981: 89 45 f4 mov %eax,-0xc(%ebp)
newtime.tv_nsec = time_buffer->ticks *
109984: 8b 43 18 mov 0x18(%ebx),%eax
109987: 0f af 05 38 86 12 00 imul 0x128638,%eax
10998e: 69 c0 e8 03 00 00 imul $0x3e8,%eax,%eax
109994: 89 45 f8 mov %eax,-0x8(%ebp)
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
109997: a1 9c 84 12 00 mov 0x12849c,%eax
10999c: 40 inc %eax
10999d: a3 9c 84 12 00 mov %eax,0x12849c
(_TOD_Microseconds_per_tick * TOD_NANOSECONDS_PER_MICROSECOND);
_Thread_Disable_dispatch();
_TOD_Set( &newtime );
1099a2: 8d 45 f4 lea -0xc(%ebp),%eax
1099a5: 89 04 24 mov %eax,(%esp)
1099a8: e8 73 17 00 00 call 10b120 <_TOD_Set>
_Thread_Enable_dispatch();
1099ad: e8 ba 27 00 00 call 10c16c <_Thread_Enable_dispatch>
1099b2: 31 d2 xor %edx,%edx
1099b4: 83 c4 10 add $0x10,%esp
return RTEMS_SUCCESSFUL;
}
return RTEMS_INVALID_CLOCK;
}
1099b7: 89 d0 mov %edx,%eax
1099b9: 8b 5d fc mov -0x4(%ebp),%ebx
1099bc: c9 leave
1099bd: c3 ret
00108b1c <rtems_clock_set_nanoseconds_extension>:
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_set_nanoseconds_extension(
rtems_nanoseconds_extension_routine routine
)
{
108b1c: 55 push %ebp
108b1d: 89 e5 mov %esp,%ebp
108b1f: 8b 55 08 mov 0x8(%ebp),%edx
if ( !routine )
108b22: b8 09 00 00 00 mov $0x9,%eax
108b27: 85 d2 test %edx,%edx
108b29: 74 08 je 108b33 <rtems_clock_set_nanoseconds_extension+0x17><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
_Watchdog_Nanoseconds_since_tick_handler = routine;
108b2b: 89 15 84 cc 11 00 mov %edx,0x11cc84
108b31: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
108b33: c9 leave
108b34: c3 ret
00106b88 <rtems_cpu_usage_report_with_plugin>:
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
106b88: 55 push %ebp
106b89: 89 e5 mov %esp,%ebp
106b8b: 57 push %edi
106b8c: 56 push %esi
106b8d: 53 push %ebx
106b8e: 83 ec 4c sub $0x4c,%esp
struct timespec uptime, total, ran;
#else
uint32_t total_units = 0;
#endif
if ( !print )
106b91: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
106b95: 0f 84 43 01 00 00 je 106cde <rtems_cpu_usage_report_with_plugin+0x156><== NEVER TAKEN
* When not using nanosecond CPU usage resolution, we have to count
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
_TOD_Get_uptime( &uptime );
106b9b: 83 ec 0c sub $0xc,%esp
106b9e: 8d 5d e4 lea -0x1c(%ebp),%ebx
106ba1: 53 push %ebx
106ba2: e8 e9 44 00 00 call 10b090 <_TOD_Get_uptime>
_Timespec_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total );
106ba7: 83 c4 0c add $0xc,%esp
106baa: 8d 45 dc lea -0x24(%ebp),%eax
106bad: 50 push %eax
106bae: 53 push %ebx
106baf: 68 38 87 12 00 push $0x128738
106bb4: e8 67 63 00 00 call 10cf20 <_Timespec_Subtract>
}
}
}
#endif
(*print)( context, "CPU Usage by thread\n"
106bb9: 58 pop %eax
106bba: 5a pop %edx
106bbb: 68 ea 92 11 00 push $0x1192ea
106bc0: ff 75 08 pushl 0x8(%ebp)
106bc3: ff 55 0c call *0xc(%ebp)
106bc6: bf 01 00 00 00 mov $0x1,%edi
106bcb: 83 c4 10 add $0x10,%esp
);
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
106bce: 8b 04 bd 70 84 12 00 mov 0x128470(,%edi,4),%eax
106bd5: 85 c0 test %eax,%eax
106bd7: 0f 84 d9 00 00 00 je 106cb6 <rtems_cpu_usage_report_with_plugin+0x12e>
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
106bdd: 8b 40 04 mov 0x4(%eax),%eax
106be0: 89 45 b0 mov %eax,-0x50(%ebp)
if ( information ) {
106be3: be 01 00 00 00 mov $0x1,%esi
106be8: 85 c0 test %eax,%eax
106bea: 0f 85 b7 00 00 00 jne 106ca7 <rtems_cpu_usage_report_with_plugin+0x11f><== ALWAYS TAKEN
106bf0: e9 c1 00 00 00 jmp 106cb6 <rtems_cpu_usage_report_with_plugin+0x12e><== NOT EXECUTED
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
106bf5: 8b 55 b0 mov -0x50(%ebp),%edx
106bf8: 8b 42 1c mov 0x1c(%edx),%eax
106bfb: 8b 1c b0 mov (%eax,%esi,4),%ebx
if ( !the_thread )
106bfe: 85 db test %ebx,%ebx
106c00: 0f 84 a0 00 00 00 je 106ca6 <rtems_cpu_usage_report_with_plugin+0x11e><== NEVER TAKEN
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
106c06: 50 push %eax
106c07: 8d 45 bf lea -0x41(%ebp),%eax
106c0a: 50 push %eax
106c0b: 6a 0d push $0xd
106c0d: ff 73 08 pushl 0x8(%ebx)
106c10: e8 8f 32 00 00 call 109ea4 <rtems_object_get_name>
(*print)(
106c15: 8d 55 bf lea -0x41(%ebp),%edx
106c18: 52 push %edx
106c19: ff 73 08 pushl 0x8(%ebx)
106c1c: 68 2f 93 11 00 push $0x11932f
106c21: ff 75 08 pushl 0x8(%ebp)
106c24: ff 55 0c call *0xc(%ebp)
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
106c27: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx
106c2d: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax
106c33: 89 45 d8 mov %eax,-0x28(%ebp)
106c36: 89 55 d4 mov %edx,-0x2c(%ebp)
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
106c39: 83 c4 20 add $0x20,%esp
106c3c: a1 5c 85 12 00 mov 0x12855c,%eax
106c41: 8b 40 08 mov 0x8(%eax),%eax
106c44: 3b 43 08 cmp 0x8(%ebx),%eax
106c47: 75 22 jne 106c6b <rtems_cpu_usage_report_with_plugin+0xe3>
struct timespec used;
_Timespec_Subtract(
106c49: 50 push %eax
106c4a: 8d 5d cc lea -0x34(%ebp),%ebx
106c4d: 53 push %ebx
106c4e: 8d 45 e4 lea -0x1c(%ebp),%eax
106c51: 50 push %eax
106c52: 68 64 85 12 00 push $0x128564
106c57: e8 c4 62 00 00 call 10cf20 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch, &uptime, &used
);
_Timespec_Add_to( &ran, &used );
106c5c: 59 pop %ecx
106c5d: 58 pop %eax
106c5e: 53 push %ebx
106c5f: 8d 45 d4 lea -0x2c(%ebp),%eax
106c62: 50 push %eax
106c63: e8 cc 61 00 00 call 10ce34 <_Timespec_Add_to>
106c68: 83 c4 10 add $0x10,%esp
};
_Timespec_Divide( &ran, &total, &ival, &fval );
106c6b: 8d 45 ec lea -0x14(%ebp),%eax
106c6e: 50 push %eax
106c6f: 8d 45 f0 lea -0x10(%ebp),%eax
106c72: 50 push %eax
106c73: 8d 45 dc lea -0x24(%ebp),%eax
106c76: 50 push %eax
106c77: 8d 45 d4 lea -0x2c(%ebp),%eax
106c7a: 50 push %eax
106c7b: e8 e4 61 00 00 call 10ce64 <_Timespec_Divide>
/*
* Print the information
*/
(*print)( context,
106c80: 58 pop %eax
106c81: 5a pop %edx
106c82: ff 75 ec pushl -0x14(%ebp)
106c85: ff 75 f0 pushl -0x10(%ebp)
106c88: 8b 45 d8 mov -0x28(%ebp),%eax
106c8b: b9 e8 03 00 00 mov $0x3e8,%ecx
106c90: 31 d2 xor %edx,%edx
106c92: f7 f1 div %ecx
106c94: 50 push %eax
106c95: ff 75 d4 pushl -0x2c(%ebp)
106c98: 68 42 93 11 00 push $0x119342
106c9d: ff 75 08 pushl 0x8(%ebp)
106ca0: ff 55 0c call *0xc(%ebp)
106ca3: 83 c4 20 add $0x20,%esp
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
106ca6: 46 inc %esi
106ca7: 8b 55 b0 mov -0x50(%ebp),%edx
106caa: 0f b7 42 10 movzwl 0x10(%edx),%eax
106cae: 39 c6 cmp %eax,%esi
106cb0: 0f 86 3f ff ff ff jbe 106bf5 <rtems_cpu_usage_report_with_plugin+0x6d>
#endif
);
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
api_index++ ) {
106cb6: 47 inc %edi
" ID NAME TICKS PERCENT\n"
#endif
);
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
106cb7: 83 ff 05 cmp $0x5,%edi
106cba: 0f 85 0e ff ff ff jne 106bce <rtems_cpu_usage_report_with_plugin+0x46>
}
}
}
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
(*print)( context, "Time since last CPU Usage reset %" PRId32
106cc0: 8b 45 e0 mov -0x20(%ebp),%eax
106cc3: b9 e8 03 00 00 mov $0x3e8,%ecx
106cc8: 31 d2 xor %edx,%edx
106cca: f7 f1 div %ecx
106ccc: 50 push %eax
106ccd: ff 75 dc pushl -0x24(%ebp)
106cd0: 68 5a 93 11 00 push $0x11935a
106cd5: ff 75 08 pushl 0x8(%ebp)
106cd8: ff 55 0c call *0xc(%ebp)
106cdb: 83 c4 10 add $0x10,%esp
"Ticks since last reset = %" PRId32 "\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset
);
(*print)( context, "Total Units = %" PRId32 "\n", total_units );
#endif
}
106cde: 8d 65 f4 lea -0xc(%ebp),%esp
106ce1: 5b pop %ebx
106ce2: 5e pop %esi
106ce3: 5f pop %edi
106ce4: c9 leave
106ce5: c3 ret
0010dec3 <rtems_deviceio_errno>:
{ 0, 0, 0 },
};
static int
rtems_deviceio_errno(rtems_status_code code)
{
10dec3: 55 push %ebp <== NOT EXECUTED
10dec4: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10dec6: 53 push %ebx <== NOT EXECUTED
10dec7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
int rc;
if ((rc = rtems_assoc_remote_by_local(errno_assoc, (uint32_t) code)))
10deca: 50 push %eax <== NOT EXECUTED
10decb: 68 b0 6d 11 00 push $0x116db0 <== NOT EXECUTED
10ded0: e8 a7 03 00 00 call 10e27c <rtems_assoc_remote_by_local><== NOT EXECUTED
10ded5: 89 c3 mov %eax,%ebx <== NOT EXECUTED
10ded7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10deda: 85 c0 test %eax,%eax <== NOT EXECUTED
10dedc: 74 07 je 10dee5 <rtems_deviceio_errno+0x22><== NOT EXECUTED
{
errno = rc;
10dede: e8 ed 07 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10dee3: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
return -1;
}
return -1;
}
10dee5: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10dee8: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10deeb: c9 leave <== NOT EXECUTED
10deec: c3 ret <== NOT EXECUTED
00107040 <rtems_error>:
int rtems_error(
int error_flag,
const char *printf_format,
...
)
{
107040: 55 push %ebp <== NOT EXECUTED
107041: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107043: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
107046: 8d 4d 10 lea 0x10(%ebp),%ecx <== NOT EXECUTED
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
chars_written = rtems_verror(error_flag, printf_format, arglist);
107049: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
10704c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10704f: e8 6d fe ff ff call 106ec1 <rtems_verror> <== NOT EXECUTED
va_end(arglist);
return chars_written;
}
107054: c9 leave <== NOT EXECUTED
107055: c3 ret <== NOT EXECUTED
00108b74 <rtems_event_receive>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
108b74: 55 push %ebp
108b75: 89 e5 mov %esp,%ebp
108b77: 83 ec 08 sub $0x8,%esp
108b7a: 8b 4d 08 mov 0x8(%ebp),%ecx
108b7d: 8b 55 14 mov 0x14(%ebp),%edx
RTEMS_API_Control *api;
if ( !event_out )
108b80: b8 09 00 00 00 mov $0x9,%eax
108b85: 85 d2 test %edx,%edx
108b87: 74 3f je 108bc8 <rtems_event_receive+0x54><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
108b89: a1 a0 cb 11 00 mov 0x11cba0,%eax
108b8e: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
if ( _Event_sets_Is_empty( event_in ) ) {
108b94: 85 c9 test %ecx,%ecx
108b96: 75 08 jne 108ba0 <rtems_event_receive+0x2c>
*event_out = api->pending_events;
108b98: 8b 00 mov (%eax),%eax
108b9a: 89 02 mov %eax,(%edx)
108b9c: 31 c0 xor %eax,%eax
108b9e: eb 28 jmp 108bc8 <rtems_event_receive+0x54>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
108ba0: a1 e0 ca 11 00 mov 0x11cae0,%eax
108ba5: 40 inc %eax
108ba6: a3 e0 ca 11 00 mov %eax,0x11cae0
return RTEMS_SUCCESSFUL;
}
_Thread_Disable_dispatch();
_Event_Seize( event_in, option_set, ticks, event_out );
108bab: 52 push %edx
108bac: ff 75 10 pushl 0x10(%ebp)
108baf: ff 75 0c pushl 0xc(%ebp)
108bb2: 51 push %ecx
108bb3: e8 14 00 00 00 call 108bcc <_Event_Seize>
_Thread_Enable_dispatch();
108bb8: e8 2f 22 00 00 call 10adec <_Thread_Enable_dispatch>
return( _Thread_Executing->Wait.return_code );
108bbd: a1 a0 cb 11 00 mov 0x11cba0,%eax
108bc2: 8b 40 34 mov 0x34(%eax),%eax
108bc5: 83 c4 10 add $0x10,%esp
}
108bc8: c9 leave
108bc9: c3 ret
0010afa8 <rtems_extension_delete>:
*/
rtems_status_code rtems_extension_delete(
Objects_Id id
)
{
10afa8: 55 push %ebp
10afa9: 89 e5 mov %esp,%ebp
10afab: 53 push %ebx
10afac: 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
10afaf: 8d 45 f8 lea -0x8(%ebp),%eax
10afb2: 50 push %eax
10afb3: ff 75 08 pushl 0x8(%ebp)
10afb6: 68 84 19 12 00 push $0x121984
10afbb: e8 30 0f 00 00 call 10bef0 <_Objects_Get>
10afc0: 89 c3 mov %eax,%ebx
Extension_Control *the_extension;
Objects_Locations location;
the_extension = _Extension_Get( id, &location );
switch ( location ) {
10afc2: 83 c4 10 add $0x10,%esp
10afc5: b8 04 00 00 00 mov $0x4,%eax
10afca: 83 7d f8 00 cmpl $0x0,-0x8(%ebp)
10afce: 75 30 jne 10b000 <rtems_extension_delete+0x58><== NEVER TAKEN
case OBJECTS_LOCAL:
_User_extensions_Remove_set( &the_extension->Extension );
10afd0: 83 ec 0c sub $0xc,%esp
10afd3: 8d 43 10 lea 0x10(%ebx),%eax
10afd6: 50 push %eax
10afd7: e8 a4 24 00 00 call 10d480 <_User_extensions_Remove_set>
_Objects_Close( &_Extension_Information, &the_extension->Object );
10afdc: 59 pop %ecx
10afdd: 58 pop %eax
10afde: 53 push %ebx
10afdf: 68 84 19 12 00 push $0x121984
10afe4: e8 37 0b 00 00 call 10bb20 <_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
10afe9: 58 pop %eax
10afea: 5a pop %edx
10afeb: 53 push %ebx
10afec: 68 84 19 12 00 push $0x121984
10aff1: e8 c6 0d 00 00 call 10bdbc <_Objects_Free>
_Extension_Free( the_extension );
_Thread_Enable_dispatch();
10aff6: e8 b5 16 00 00 call 10c6b0 <_Thread_Enable_dispatch>
10affb: 31 c0 xor %eax,%eax
10affd: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10b000: 8b 5d fc mov -0x4(%ebp),%ebx
10b003: c9 leave
10b004: c3 ret
001062e0 <rtems_filesystem_evaluate_parent>:
int rtems_filesystem_evaluate_parent(
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
1062e0: 55 push %ebp <== NOT EXECUTED
1062e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1062e3: 57 push %edi <== NOT EXECUTED
1062e4: 56 push %esi <== NOT EXECUTED
1062e5: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
1062e8: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED
rtems_filesystem_location_info_t parent;
int result;
if ( !pathloc )
1062eb: 85 f6 test %esi,%esi <== NOT EXECUTED
1062ed: 75 0d jne 1062fc <rtems_filesystem_evaluate_parent+0x1c><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
1062ef: e8 dc 83 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
1062f4: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
1062fa: eb 13 jmp 10630f <rtems_filesystem_evaluate_parent+0x2f><== NOT EXECUTED
if ( !pathloc->ops->evalpath_h )
1062fc: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED
1062ff: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED
106302: 75 10 jne 106314 <rtems_filesystem_evaluate_parent+0x34><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
106304: e8 c7 83 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
106309: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
10630f: 83 cf ff or $0xffffffff,%edi <== NOT EXECUTED
106312: eb 39 jmp 10634d <rtems_filesystem_evaluate_parent+0x6d><== NOT EXECUTED
parent = *pathloc;
106314: 8d 7d e8 lea -0x18(%ebp),%edi <== NOT EXECUTED
106317: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
10631c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
result = (*pathloc->ops->evalpath_h)( "..", flags, &parent );
10631e: 52 push %edx <== NOT EXECUTED
10631f: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED
106322: 56 push %esi <== NOT EXECUTED
106323: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
106326: 68 b9 67 11 00 push $0x1167b9 <== NOT EXECUTED
10632b: ff 10 call *(%eax) <== NOT EXECUTED
10632d: 89 c7 mov %eax,%edi <== NOT EXECUTED
if (result != 0){
10632f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106332: 85 c0 test %eax,%eax <== NOT EXECUTED
106334: 75 d9 jne 10630f <rtems_filesystem_evaluate_parent+0x2f><== NOT EXECUTED
return -1;
}
rtems_filesystem_freenode( &parent );
106336: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED
106339: 85 c0 test %eax,%eax <== NOT EXECUTED
10633b: 74 10 je 10634d <rtems_filesystem_evaluate_parent+0x6d><== NOT EXECUTED
10633d: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
106340: 85 c0 test %eax,%eax <== NOT EXECUTED
106342: 74 09 je 10634d <rtems_filesystem_evaluate_parent+0x6d><== NOT EXECUTED
106344: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106347: 56 push %esi <== NOT EXECUTED
106348: ff d0 call *%eax <== NOT EXECUTED
10634a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return result;
}
10634d: 89 f8 mov %edi,%eax <== NOT EXECUTED
10634f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
106352: 5e pop %esi <== NOT EXECUTED
106353: 5f pop %edi <== NOT EXECUTED
106354: c9 leave <== NOT EXECUTED
106355: c3 ret <== NOT EXECUTED
00106356 <rtems_filesystem_evaluate_path>:
const char *pathname,
int flags,
rtems_filesystem_location_info_t *pathloc,
int follow_link
)
{
106356: 55 push %ebp
106357: 89 e5 mov %esp,%ebp
106359: 57 push %edi
10635a: 56 push %esi
10635b: 53 push %ebx
10635c: 83 ec 1c sub $0x1c,%esp
10635f: 8b 5d 08 mov 0x8(%ebp),%ebx
106362: 8b 45 0c mov 0xc(%ebp),%eax
106365: 89 45 f0 mov %eax,-0x10(%ebp)
106368: 8b 55 10 mov 0x10(%ebp),%edx
10636b: 89 55 e0 mov %edx,-0x20(%ebp)
10636e: 8b 7d 14 mov 0x14(%ebp),%edi
106371: 89 7d ec mov %edi,-0x14(%ebp)
/*
* Verify Input parameters.
*/
if ( !pathname )
106374: 85 db test %ebx,%ebx
106376: 75 0d jne 106385 <rtems_filesystem_evaluate_path+0x2f><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EFAULT );
106378: e8 53 83 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10637d: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED
106383: eb 11 jmp 106396 <rtems_filesystem_evaluate_path+0x40><== NOT EXECUTED
if ( !pathloc )
106385: 83 7d e0 00 cmpl $0x0,-0x20(%ebp)
106389: 75 13 jne 10639e <rtems_filesystem_evaluate_path+0x48><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
10638b: e8 40 83 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
106390: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
106396: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED
106399: e9 cd 00 00 00 jmp 10646b <rtems_filesystem_evaluate_path+0x115><== NOT EXECUTED
/*
* Evaluate the path using the optable evalpath.
*/
rtems_filesystem_get_start_loc( pathname, &i, pathloc );
10639e: 8a 03 mov (%ebx),%al
1063a0: 3c 2f cmp $0x2f,%al
1063a2: 74 08 je 1063ac <rtems_filesystem_evaluate_path+0x56><== ALWAYS TAKEN
1063a4: 3c 5c cmp $0x5c,%al <== NOT EXECUTED
1063a6: 74 04 je 1063ac <rtems_filesystem_evaluate_path+0x56><== NOT EXECUTED
1063a8: 84 c0 test %al,%al <== NOT EXECUTED
1063aa: 75 16 jne 1063c2 <rtems_filesystem_evaluate_path+0x6c><== NOT EXECUTED
1063ac: a1 4c aa 11 00 mov 0x11aa4c,%eax
1063b1: 8d 70 14 lea 0x14(%eax),%esi
1063b4: b9 04 00 00 00 mov $0x4,%ecx
1063b9: 8b 7d e0 mov -0x20(%ebp),%edi
1063bc: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
1063be: b1 01 mov $0x1,%cl
1063c0: eb 12 jmp 1063d4 <rtems_filesystem_evaluate_path+0x7e>
1063c2: a1 4c aa 11 00 mov 0x11aa4c,%eax <== NOT EXECUTED
1063c7: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED
1063ca: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
1063cf: 8b 7d e0 mov -0x20(%ebp),%edi <== NOT EXECUTED
1063d2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
if ( !pathloc->ops->evalpath_h )
1063d4: 8b 55 e0 mov -0x20(%ebp),%edx
1063d7: 8b 42 08 mov 0x8(%edx),%eax
1063da: 8b 10 mov (%eax),%edx
1063dc: 85 d2 test %edx,%edx
1063de: 74 66 je 106446 <rtems_filesystem_evaluate_path+0xf0><== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
result = (*pathloc->ops->evalpath_h)( &pathname[i], flags, pathloc );
1063e0: 56 push %esi
1063e1: ff 75 e0 pushl -0x20(%ebp)
1063e4: ff 75 f0 pushl -0x10(%ebp)
1063e7: 8d 04 0b lea (%ebx,%ecx,1),%eax
1063ea: 50 push %eax
1063eb: ff d2 call *%edx
1063ed: 89 c6 mov %eax,%esi
/*
* Get the Node type and determine if you need to follow the link or
* not.
*/
if ( (result == 0) && follow_link ) {
1063ef: 83 c4 10 add $0x10,%esp
1063f2: 85 c0 test %eax,%eax
1063f4: 75 75 jne 10646b <rtems_filesystem_evaluate_path+0x115><== NEVER TAKEN
1063f6: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
1063fa: 74 6f je 10646b <rtems_filesystem_evaluate_path+0x115>
if ( !pathloc->ops->node_type_h ){
1063fc: 8b 7d e0 mov -0x20(%ebp),%edi
1063ff: 8b 47 08 mov 0x8(%edi),%eax
106402: 8b 50 10 mov 0x10(%eax),%edx
106405: 85 d2 test %edx,%edx
106407: 75 0d jne 106416 <rtems_filesystem_evaluate_path+0xc0><== ALWAYS TAKEN
rtems_filesystem_freenode( pathloc );
106409: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
10640c: 85 c0 test %eax,%eax <== NOT EXECUTED
10640e: 74 36 je 106446 <rtems_filesystem_evaluate_path+0xf0><== NOT EXECUTED
106410: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106413: 57 push %edi <== NOT EXECUTED
106414: eb 2b jmp 106441 <rtems_filesystem_evaluate_path+0xeb><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
type = (*pathloc->ops->node_type_h)( pathloc );
106416: 83 ec 0c sub $0xc,%esp
106419: ff 75 e0 pushl -0x20(%ebp)
10641c: ff d2 call *%edx
if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) ||
10641e: 83 e8 03 sub $0x3,%eax
106421: 83 c4 10 add $0x10,%esp
106424: 83 f8 01 cmp $0x1,%eax
106427: 77 42 ja 10646b <rtems_filesystem_evaluate_path+0x115><== ALWAYS TAKEN
( type == RTEMS_FILESYSTEM_SYM_LINK ) ) {
if ( !pathloc->ops->eval_link_h ){
106429: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED
10642c: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED
10642f: 8b 48 34 mov 0x34(%eax),%ecx <== NOT EXECUTED
106432: 85 c9 test %ecx,%ecx <== NOT EXECUTED
106434: 75 20 jne 106456 <rtems_filesystem_evaluate_path+0x100><== NOT EXECUTED
rtems_filesystem_freenode( pathloc );
106436: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
106439: 85 c0 test %eax,%eax <== NOT EXECUTED
10643b: 74 09 je 106446 <rtems_filesystem_evaluate_path+0xf0><== NOT EXECUTED
10643d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106440: 52 push %edx <== NOT EXECUTED
106441: ff d0 call *%eax <== NOT EXECUTED
106443: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
106446: e8 85 82 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
10644b: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
106451: e9 40 ff ff ff jmp 106396 <rtems_filesystem_evaluate_path+0x40><== NOT EXECUTED
* pathloc will be passed up (and eventually released).
* Hence, the (valid) originial node that we submit to
* eval_link_h() should be released by the handler.
*/
result = (*pathloc->ops->eval_link_h)( pathloc, flags );
106456: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED
106459: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED
10645c: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
10645f: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
}
return result;
}
106462: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
106465: 5b pop %ebx <== NOT EXECUTED
106466: 5e pop %esi <== NOT EXECUTED
106467: 5f pop %edi <== NOT EXECUTED
106468: 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 );
106469: ff e1 jmp *%ecx <== NOT EXECUTED
}
}
return result;
}
10646b: 89 f0 mov %esi,%eax
10646d: 8d 65 f4 lea -0xc(%ebp),%esp
106470: 5b pop %ebx
106471: 5e pop %esi
106472: 5f pop %edi
106473: c9 leave
106474: c3 ret
0010cb1c <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 )
{
10cb1c: 55 push %ebp
10cb1d: 89 e5 mov %esp,%ebp
10cb1f: 57 push %edi
10cb20: 56 push %esi
10cb21: 53 push %ebx
10cb22: 83 ec 2c sub $0x2c,%esp
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
10cb25: a1 4c aa 11 00 mov 0x11aa4c,%eax
10cb2a: c7 40 24 12 00 00 00 movl $0x12,0x24(%eax)
init_fs_mount_table();
10cb31: e8 d2 04 00 00 call 10d008 <init_fs_mount_table>
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
10cb36: 83 3d a8 54 11 00 00 cmpl $0x0,0x1154a8
10cb3d: 75 0a jne 10cb49 <rtems_filesystem_initialize+0x2d><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0001 );
10cb3f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10cb42: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED
10cb47: eb 2a jmp 10cb73 <rtems_filesystem_initialize+0x57><== NOT EXECUTED
mt = &rtems_filesystem_mount_table[0];
10cb49: a1 c0 86 11 00 mov 0x1186c0,%eax
status = mount(
10cb4e: 83 ec 0c sub $0xc,%esp
10cb51: ff 70 0c pushl 0xc(%eax)
10cb54: ff 70 08 pushl 0x8(%eax)
10cb57: ff 70 04 pushl 0x4(%eax)
10cb5a: ff 30 pushl (%eax)
10cb5c: 8d 45 f0 lea -0x10(%ebp),%eax
10cb5f: 50 push %eax
10cb60: e8 c8 04 00 00 call 10d02d <mount>
&entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point );
if ( status == -1 )
10cb65: 83 c4 20 add $0x20,%esp
10cb68: 40 inc %eax
10cb69: 75 0d jne 10cb78 <rtems_filesystem_initialize+0x5c><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0002 );
10cb6b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10cb6e: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED
10cb73: e8 14 cc ff ff call 10978c <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_filesystem_link_counts = 0;
10cb78: a1 4c aa 11 00 mov 0x11aa4c,%eax
10cb7d: 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;
10cb83: 8d 78 14 lea 0x14(%eax),%edi
10cb86: 8b 45 f0 mov -0x10(%ebp),%eax
10cb89: 8d 70 18 lea 0x18(%eax),%esi
10cb8c: b9 04 00 00 00 mov $0x4,%ecx
10cb91: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
10cb93: 6a 00 push $0x0
10cb95: 8d 5d e0 lea -0x20(%ebp),%ebx
10cb98: 53 push %ebx
10cb99: 6a 00 push $0x0
10cb9b: 68 b4 6c 11 00 push $0x116cb4
10cba0: e8 b1 97 ff ff call 106356 <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
10cba5: a1 4c aa 11 00 mov 0x11aa4c,%eax
10cbaa: 8d 78 14 lea 0x14(%eax),%edi
10cbad: b9 04 00 00 00 mov $0x4,%ecx
10cbb2: 89 de mov %ebx,%esi
10cbb4: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
10cbb6: 6a 00 push $0x0
10cbb8: 53 push %ebx
10cbb9: 6a 00 push $0x0
10cbbb: 68 b4 6c 11 00 push $0x116cb4
10cbc0: e8 91 97 ff ff call 106356 <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
10cbc5: a1 4c aa 11 00 mov 0x11aa4c,%eax
10cbca: 8d 78 04 lea 0x4(%eax),%edi
10cbcd: b9 04 00 00 00 mov $0x4,%ecx
10cbd2: 89 de mov %ebx,%esi
10cbd4: 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);
10cbd6: 83 c4 18 add $0x18,%esp
10cbd9: 68 ff 01 00 00 push $0x1ff
10cbde: 68 b6 6c 11 00 push $0x116cb6
10cbe3: e8 04 04 00 00 call 10cfec <mkdir>
if ( status != 0 )
10cbe8: 83 c4 10 add $0x10,%esp
10cbeb: 85 c0 test %eax,%eax
10cbed: 74 0d je 10cbfc <rtems_filesystem_initialize+0xe0><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0003 );
10cbef: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10cbf2: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED
10cbf7: e9 77 ff ff ff jmp 10cb73 <rtems_filesystem_initialize+0x57><== NOT EXECUTED
* before device drivers are initialized. So we return via a base
* filesystem image and nothing auto-mounted at this point.
*/
#endif
}
10cbfc: 8d 65 f4 lea -0xc(%ebp),%esp
10cbff: 5b pop %ebx
10cc00: 5e pop %esi
10cc01: 5f pop %edi
10cc02: c9 leave
10cc03: c3 ret
001094d0 <rtems_interrupt_catch>:
rtems_status_code rtems_interrupt_catch(
rtems_isr_entry new_isr_handler,
rtems_vector_number vector,
rtems_isr_entry *old_isr_handler
)
{
1094d0: 55 push %ebp <== NOT EXECUTED
1094d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1094d3: 53 push %ebx <== NOT EXECUTED
1094d4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED
1094d7: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
1094da: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED
1094dd: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
if ( !_ISR_Is_vector_number_valid( vector ) )
1094e0: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
1094e5: 81 fb ff 00 00 00 cmp $0xff,%ebx <== NOT EXECUTED
1094eb: 77 1d ja 10950a <rtems_interrupt_catch+0x3a><== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
if ( !_ISR_Is_valid_user_handler( (void *) new_isr_handler ) )
1094ed: 85 c9 test %ecx,%ecx <== NOT EXECUTED
1094ef: 74 14 je 109505 <rtems_interrupt_catch+0x35><== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_ISR_Is_valid_user_handler( (void *) old_isr_handler ) )
1094f1: 85 d2 test %edx,%edx <== NOT EXECUTED
1094f3: 74 10 je 109505 <rtems_interrupt_catch+0x35><== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_ISR_Install_vector(
1094f5: 50 push %eax <== NOT EXECUTED
1094f6: 52 push %edx <== NOT EXECUTED
1094f7: 51 push %ecx <== NOT EXECUTED
1094f8: 53 push %ebx <== NOT EXECUTED
1094f9: e8 44 cc ff ff call 106142 <_CPU_ISR_install_vector><== NOT EXECUTED
1094fe: 31 c0 xor %eax,%eax <== NOT EXECUTED
109500: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109503: eb 05 jmp 10950a <rtems_interrupt_catch+0x3a><== NOT EXECUTED
vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler );
return RTEMS_SUCCESSFUL;
109505: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED
}
10950a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10950d: c9 leave <== NOT EXECUTED
10950e: c3 ret <== NOT EXECUTED
00106188 <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
106188: 55 push %ebp <== NOT EXECUTED
106189: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10618b: 57 push %edi <== NOT EXECUTED
10618c: 56 push %esi <== NOT EXECUTED
10618d: 53 push %ebx <== NOT EXECUTED
10618e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED
106191: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED
106194: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
rtems_filesystem_location_info_t loc;
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path( name, 0x00, &loc, true );
106197: 6a 01 push $0x1 <== NOT EXECUTED
106199: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED
10619c: 50 push %eax <== NOT EXECUTED
10619d: 6a 00 push $0x0 <== NOT EXECUTED
10619f: 57 push %edi <== NOT EXECUTED
1061a0: e8 b1 01 00 00 call 106356 <rtems_filesystem_evaluate_path><== NOT EXECUTED
1061a5: 89 c3 mov %eax,%ebx <== NOT EXECUTED
the_jnode = loc.node_access;
1061a7: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
1061aa: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED
if ( !loc.ops->node_type_h ) {
1061ad: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
1061b0: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED
1061b3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1061b6: 85 d2 test %edx,%edx <== NOT EXECUTED
1061b8: 75 23 jne 1061dd <rtems_io_lookup_name+0x55><== NOT EXECUTED
rtems_filesystem_freenode( &loc );
1061ba: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
1061bd: 85 c0 test %eax,%eax <== NOT EXECUTED
1061bf: 74 0c je 1061cd <rtems_io_lookup_name+0x45><== NOT EXECUTED
1061c1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1061c4: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED
1061c7: 52 push %edx <== NOT EXECUTED
1061c8: ff d0 call *%eax <== NOT EXECUTED
1061ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
1061cd: e8 fe 84 00 00 call 10e6d0 <__errno> <== NOT EXECUTED
1061d2: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
1061d8: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
1061db: eb 78 jmp 106255 <rtems_io_lookup_name+0xcd><== NOT EXECUTED
}
node_type = (*loc.ops->node_type_h)( &loc );
1061dd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1061e0: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED
1061e3: 50 push %eax <== NOT EXECUTED
1061e4: ff d2 call *%edx <== NOT EXECUTED
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
1061e6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1061e9: 85 db test %ebx,%ebx <== NOT EXECUTED
1061eb: 75 05 jne 1061f2 <rtems_io_lookup_name+0x6a><== NOT EXECUTED
1061ed: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED
1061f0: 74 1e je 106210 <rtems_io_lookup_name+0x88><== NOT EXECUTED
rtems_filesystem_freenode( &loc );
1061f2: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
1061f5: 85 c0 test %eax,%eax <== NOT EXECUTED
1061f7: 74 53 je 10624c <rtems_io_lookup_name+0xc4><== NOT EXECUTED
1061f9: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED
1061fc: 85 d2 test %edx,%edx <== NOT EXECUTED
1061fe: 74 4c je 10624c <rtems_io_lookup_name+0xc4><== NOT EXECUTED
106200: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106203: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED
106206: 50 push %eax <== NOT EXECUTED
106207: ff d2 call *%edx <== NOT EXECUTED
106209: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED
10620e: eb 37 jmp 106247 <rtems_io_lookup_name+0xbf><== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
device_info->device_name = (char *) name;
106210: 89 3e mov %edi,(%esi) <== NOT EXECUTED
device_info->device_name_length = strlen( name );
106212: 31 c0 xor %eax,%eax <== NOT EXECUTED
106214: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED
106217: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED
106219: f7 d1 not %ecx <== NOT EXECUTED
10621b: 49 dec %ecx <== NOT EXECUTED
10621c: 89 4e 04 mov %ecx,0x4(%esi) <== NOT EXECUTED
device_info->major = the_jnode->info.device.major;
10621f: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED
106222: 8b 42 50 mov 0x50(%edx),%eax <== NOT EXECUTED
106225: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED
device_info->minor = the_jnode->info.device.minor;
106228: 8b 42 54 mov 0x54(%edx),%eax <== NOT EXECUTED
10622b: 89 46 0c mov %eax,0xc(%esi) <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
10622e: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
106231: 85 c0 test %eax,%eax <== NOT EXECUTED
106233: 74 1e je 106253 <rtems_io_lookup_name+0xcb><== NOT EXECUTED
106235: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED
106238: 85 c0 test %eax,%eax <== NOT EXECUTED
10623a: 74 17 je 106253 <rtems_io_lookup_name+0xcb><== NOT EXECUTED
10623c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10623f: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED
106242: 52 push %edx <== NOT EXECUTED
106243: ff d0 call *%eax <== NOT EXECUTED
106245: 31 c0 xor %eax,%eax <== NOT EXECUTED
106247: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10624a: eb 09 jmp 106255 <rtems_io_lookup_name+0xcd><== NOT EXECUTED
10624c: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED
106251: eb 02 jmp 106255 <rtems_io_lookup_name+0xcd><== NOT EXECUTED
106253: 31 c0 xor %eax,%eax <== NOT EXECUTED
#endif
return RTEMS_SUCCESSFUL;
}
106255: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
106258: 5b pop %ebx <== NOT EXECUTED
106259: 5e pop %esi <== NOT EXECUTED
10625a: 5f pop %edi <== NOT EXECUTED
10625b: c9 leave <== NOT EXECUTED
10625c: c3 ret <== NOT EXECUTED
0010a504 <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
)
{
10a504: 55 push %ebp
10a505: 89 e5 mov %esp,%ebp
10a507: 57 push %edi
10a508: 56 push %esi
10a509: 53 push %ebx
10a50a: 83 ec 08 sub $0x8,%esp
10a50d: 8b 5d 08 mov 0x8(%ebp),%ebx
10a510: 8b 75 0c mov 0xc(%ebp),%esi
10a513: 8b 45 10 mov 0x10(%ebp),%eax
10a516: 89 45 f0 mov %eax,-0x10(%ebp)
/*
* Validate the pointer data and contents passed in
*/
if ( !driver_table )
10a519: 85 f6 test %esi,%esi
10a51b: 0f 84 9a 00 00 00 je 10a5bb <rtems_io_register_driver+0xb7>
return RTEMS_INVALID_ADDRESS;
if ( !registered_major )
10a521: 85 c0 test %eax,%eax
10a523: 0f 84 92 00 00 00 je 10a5bb <rtems_io_register_driver+0xb7>
return RTEMS_INVALID_ADDRESS;
if ( !driver_table->initialization_entry && !driver_table->open_entry )
10a529: 83 3e 00 cmpl $0x0,(%esi)
10a52c: 75 0a jne 10a538 <rtems_io_register_driver+0x34>
10a52e: 83 7e 04 00 cmpl $0x0,0x4(%esi)
10a532: 0f 84 83 00 00 00 je 10a5bb <rtems_io_register_driver+0xb7><== ALWAYS TAKEN
return RTEMS_INVALID_ADDRESS;
*registered_major = 0;
10a538: 8b 45 f0 mov -0x10(%ebp),%eax
10a53b: c7 00 00 00 00 00 movl $0x0,(%eax)
/*
* The requested major number is higher than what is configured.
*/
if ( major >= _IO_Number_of_drivers )
10a541: 8b 15 58 f7 11 00 mov 0x11f758,%edx
10a547: b8 0a 00 00 00 mov $0xa,%eax
10a54c: 39 d3 cmp %edx,%ebx
10a54e: 73 77 jae 10a5c7 <rtems_io_register_driver+0xc3>
/*
* Test for initialise/open being present to indicate the driver slot is
* in use.
*/
if ( major == 0 ) {
10a550: 85 db test %ebx,%ebx
10a552: 75 2b jne 10a57f <rtems_io_register_driver+0x7b>
bool found = false;
for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) {
10a554: 8d 5a ff lea -0x1(%edx),%ebx
10a557: 6b c2 18 imul $0x18,%edx,%eax
10a55a: 83 e8 18 sub $0x18,%eax
10a55d: 03 05 5c f7 11 00 add 0x11f75c,%eax
10a563: eb 0f jmp 10a574 <rtems_io_register_driver+0x70>
if ( !_IO_Driver_address_table[major].initialization_entry &&
10a565: 83 38 00 cmpl $0x0,(%eax)
10a568: 75 06 jne 10a570 <rtems_io_register_driver+0x6c>
10a56a: 83 78 04 00 cmpl $0x0,0x4(%eax)
10a56e: 74 0f je 10a57f <rtems_io_register_driver+0x7b><== ALWAYS TAKEN
* in use.
*/
if ( major == 0 ) {
bool found = false;
for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) {
10a570: 4b dec %ebx
10a571: 83 e8 18 sub $0x18,%eax
10a574: 85 db test %ebx,%ebx
10a576: 75 ed jne 10a565 <rtems_io_register_driver+0x61>
10a578: b8 05 00 00 00 mov $0x5,%eax
10a57d: eb 48 jmp 10a5c7 <rtems_io_register_driver+0xc3>
if ( !found )
return RTEMS_TOO_MANY;
}
if ( _IO_Driver_address_table[major].initialization_entry ||
10a57f: 6b fb 18 imul $0x18,%ebx,%edi
10a582: 03 3d 5c f7 11 00 add 0x11f75c,%edi
10a588: 83 3f 00 cmpl $0x0,(%edi)
10a58b: 75 35 jne 10a5c2 <rtems_io_register_driver+0xbe>
10a58d: 83 7f 04 00 cmpl $0x0,0x4(%edi)
10a591: 75 2f jne 10a5c2 <rtems_io_register_driver+0xbe><== NEVER TAKEN
_IO_Driver_address_table[major].open_entry )
return RTEMS_RESOURCE_IN_USE;
_IO_Driver_address_table[major] = *driver_table;
10a593: b9 06 00 00 00 mov $0x6,%ecx
10a598: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*registered_major = major;
10a59a: 8b 45 f0 mov -0x10(%ebp),%eax
10a59d: 89 18 mov %ebx,(%eax)
return rtems_io_initialize( major, 0, NULL );
10a59f: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp)
10a5a6: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp)
10a5ad: 89 5d 08 mov %ebx,0x8(%ebp)
}
10a5b0: 5b pop %ebx
10a5b1: 5e pop %esi
10a5b2: 5b pop %ebx
10a5b3: 5e pop %esi
10a5b4: 5f pop %edi
10a5b5: c9 leave
_IO_Driver_address_table[major] = *driver_table;
*registered_major = major;
return rtems_io_initialize( major, 0, NULL );
10a5b6: e9 ed fd ff ff jmp 10a3a8 <rtems_io_initialize>
10a5bb: b8 09 00 00 00 mov $0x9,%eax
10a5c0: eb 05 jmp 10a5c7 <rtems_io_register_driver+0xc3>
10a5c2: b8 0c 00 00 00 mov $0xc,%eax
}
10a5c7: 5a pop %edx
10a5c8: 59 pop %ecx
10a5c9: 5b pop %ebx
10a5ca: 5e pop %esi
10a5cb: 5f pop %edi
10a5cc: c9 leave
10a5cd: c3 ret
0010a5d0 <rtems_io_unregister_driver>:
*/
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
10a5d0: 55 push %ebp
10a5d1: 89 e5 mov %esp,%ebp
10a5d3: 57 push %edi
10a5d4: 83 ec 04 sub $0x4,%esp
10a5d7: 8b 55 08 mov 0x8(%ebp),%edx
if ( major < _IO_Number_of_drivers ) {
10a5da: b8 0d 00 00 00 mov $0xd,%eax
10a5df: 3b 15 58 f7 11 00 cmp 0x11f758,%edx
10a5e5: 73 12 jae 10a5f9 <rtems_io_unregister_driver+0x29><== NEVER TAKEN
memset(
10a5e7: 6b fa 18 imul $0x18,%edx,%edi
10a5ea: 03 3d 5c f7 11 00 add 0x11f75c,%edi
10a5f0: b9 06 00 00 00 mov $0x6,%ecx
10a5f5: 31 c0 xor %eax,%eax
10a5f7: f3 ab rep stos %eax,%es:(%edi)
sizeof( rtems_driver_address_table )
);
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
}
10a5f9: 5a pop %edx
10a5fa: 5f pop %edi
10a5fb: c9 leave
10a5fc: c3 ret
0010b438 <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)
{
10b438: 55 push %ebp
10b439: 89 e5 mov %esp,%ebp
10b43b: 57 push %edi
10b43c: 56 push %esi
10b43d: 53 push %ebx
10b43e: 83 ec 0c sub $0xc,%esp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
10b441: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
10b445: 74 41 je 10b488 <rtems_iterate_over_all_threads+0x50><== NEVER TAKEN
return;
10b447: 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 ] )
10b44c: 8b 04 bd 70 84 12 00 mov 0x128470(,%edi,4),%eax
10b453: 85 c0 test %eax,%eax
10b455: 74 2b je 10b482 <rtems_iterate_over_all_threads+0x4a>
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
10b457: 8b 70 04 mov 0x4(%eax),%esi
if ( information ) {
10b45a: bb 01 00 00 00 mov $0x1,%ebx
10b45f: 85 f6 test %esi,%esi
10b461: 75 17 jne 10b47a <rtems_iterate_over_all_threads+0x42><== ALWAYS TAKEN
10b463: eb 1d jmp 10b482 <rtems_iterate_over_all_threads+0x4a><== NOT EXECUTED
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
10b465: 8b 46 1c mov 0x1c(%esi),%eax
10b468: 8b 04 98 mov (%eax,%ebx,4),%eax
if ( !the_thread )
10b46b: 85 c0 test %eax,%eax
10b46d: 74 0a je 10b479 <rtems_iterate_over_all_threads+0x41><== NEVER TAKEN
continue;
(*routine)(the_thread);
10b46f: 83 ec 0c sub $0xc,%esp
10b472: 50 push %eax
10b473: ff 55 08 call *0x8(%ebp)
10b476: 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++ ) {
10b479: 43 inc %ebx
10b47a: 0f b7 46 10 movzwl 0x10(%esi),%eax
10b47e: 39 c3 cmp %eax,%ebx
10b480: 76 e3 jbe 10b465 <rtems_iterate_over_all_threads+0x2d>
if ( !routine )
return;
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
api_index++ ) {
10b482: 47 inc %edi
if ( !routine )
return;
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
10b483: 83 ff 05 cmp $0x5,%edi
10b486: 75 c4 jne 10b44c <rtems_iterate_over_all_threads+0x14>
(*routine)(the_thread);
}
}
}
}
10b488: 8d 65 f4 lea -0xc(%ebp),%esp
10b48b: 5b pop %ebx
10b48c: 5e pop %esi
10b48d: 5f pop %edi
10b48e: c9 leave
10b48f: c3 ret
0010cf25 <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 )
{
10cf25: 55 push %ebp
10cf26: 89 e5 mov %esp,%ebp
10cf28: 57 push %edi
10cf29: 53 push %ebx
10cf2a: 83 ec 24 sub $0x24,%esp
rtems_libio_t *iop, *next;
rtems_status_code rc;
rtems_id sema;
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
10cf2d: 6a 00 push $0x0
10cf2f: 6a 00 push $0x0
10cf31: ff 35 88 c9 11 00 pushl 0x11c988
10cf37: e8 38 c2 ff ff call 109174 <rtems_semaphore_obtain>
if (rtems_libio_iop_freelist) {
10cf3c: 8b 15 84 c9 11 00 mov 0x11c984,%edx
10cf42: 83 c4 10 add $0x10,%esp
10cf45: 85 d2 test %edx,%edx
10cf47: 74 55 je 10cf9e <rtems_libio_allocate+0x79>
rc = rtems_semaphore_create(
10cf49: 83 ec 0c sub $0xc,%esp
10cf4c: 8d 45 f4 lea -0xc(%ebp),%eax
10cf4f: 50 push %eax
10cf50: 6a 00 push $0x0
10cf52: 6a 54 push $0x54
10cf54: 6a 01 push $0x1
10cf56: 2b 15 80 c9 11 00 sub 0x11c980,%edx
10cf5c: c1 fa 02 sar $0x2,%edx
10cf5f: 69 c2 c5 4e ec c4 imul $0xc4ec4ec5,%edx,%eax
10cf65: 0d 00 49 42 4c or $0x4c424900,%eax
10cf6a: 50 push %eax
10cf6b: e8 d0 bf ff ff call 108f40 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&sema
);
if (rc != RTEMS_SUCCESSFUL)
10cf70: 83 c4 20 add $0x20,%esp
10cf73: 85 c0 test %eax,%eax
10cf75: 75 27 jne 10cf9e <rtems_libio_allocate+0x79><== NEVER TAKEN
goto failed;
iop = rtems_libio_iop_freelist;
10cf77: 8b 1d 84 c9 11 00 mov 0x11c984,%ebx
next = iop->data1;
10cf7d: 8b 53 28 mov 0x28(%ebx),%edx
(void) memset( iop, 0, sizeof(rtems_libio_t) );
10cf80: b9 0d 00 00 00 mov $0xd,%ecx
10cf85: 89 df mov %ebx,%edi
10cf87: f3 ab rep stos %eax,%es:(%edi)
iop->flags = LIBIO_FLAGS_OPEN;
10cf89: c7 43 0c 00 01 00 00 movl $0x100,0xc(%ebx)
iop->sem = sema;
10cf90: 8b 45 f4 mov -0xc(%ebp),%eax
10cf93: 89 43 20 mov %eax,0x20(%ebx)
rtems_libio_iop_freelist = next;
10cf96: 89 15 84 c9 11 00 mov %edx,0x11c984
10cf9c: eb 02 jmp 10cfa0 <rtems_libio_allocate+0x7b>
}
failed:
iop = 0;
done:
10cf9e: 31 db xor %ebx,%ebx
rtems_semaphore_release( rtems_libio_semaphore );
10cfa0: 83 ec 0c sub $0xc,%esp
10cfa3: ff 35 88 c9 11 00 pushl 0x11c988
10cfa9: e8 ae c2 ff ff call 10925c <rtems_semaphore_release>
return iop;
}
10cfae: 89 d8 mov %ebx,%eax
10cfb0: 8d 65 f8 lea -0x8(%ebp),%esp
10cfb3: 5b pop %ebx
10cfb4: 5f pop %edi
10cfb5: c9 leave
10cfb6: c3 ret
0010ced0 <rtems_libio_free>:
*/
void rtems_libio_free(
rtems_libio_t *iop
)
{
10ced0: 55 push %ebp
10ced1: 89 e5 mov %esp,%ebp
10ced3: 53 push %ebx
10ced4: 83 ec 08 sub $0x8,%esp
10ced7: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
10ceda: 6a 00 push $0x0
10cedc: 6a 00 push $0x0
10cede: ff 35 88 c9 11 00 pushl 0x11c988
10cee4: e8 8b c2 ff ff call 109174 <rtems_semaphore_obtain>
if (iop->sem)
10cee9: 8b 43 20 mov 0x20(%ebx),%eax
10ceec: 83 c4 10 add $0x10,%esp
10ceef: 85 c0 test %eax,%eax
10cef1: 74 0c je 10ceff <rtems_libio_free+0x2f> <== NEVER TAKEN
rtems_semaphore_delete(iop->sem);
10cef3: 83 ec 0c sub $0xc,%esp
10cef6: 50 push %eax
10cef7: e8 e8 c1 ff ff call 1090e4 <rtems_semaphore_delete>
10cefc: 83 c4 10 add $0x10,%esp
iop->flags &= ~LIBIO_FLAGS_OPEN;
10ceff: 81 63 0c ff fe ff ff andl $0xfffffeff,0xc(%ebx)
iop->data1 = rtems_libio_iop_freelist;
10cf06: a1 84 c9 11 00 mov 0x11c984,%eax
10cf0b: 89 43 28 mov %eax,0x28(%ebx)
rtems_libio_iop_freelist = iop;
10cf0e: 89 1d 84 c9 11 00 mov %ebx,0x11c984
rtems_semaphore_release(rtems_libio_semaphore);
10cf14: a1 88 c9 11 00 mov 0x11c988,%eax
10cf19: 89 45 08 mov %eax,0x8(%ebp)
}
10cf1c: 8b 5d fc mov -0x4(%ebp),%ebx
10cf1f: c9 leave
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
rtems_semaphore_release(rtems_libio_semaphore);
10cf20: e9 37 c3 ff ff jmp 10925c <rtems_semaphore_release>
001064f0 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
1064f0: 55 push %ebp
1064f1: 89 e5 mov %esp,%ebp
1064f3: 53 push %ebx
1064f4: 83 ec 04 sub $0x4,%esp
rtems_status_code rc;
int i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
1064f7: a1 b8 86 11 00 mov 0x1186b8,%eax
1064fc: 85 c0 test %eax,%eax
1064fe: 74 46 je 106546 <rtems_libio_init+0x56>
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
106500: 52 push %edx
106501: 52 push %edx
106502: 6a 34 push $0x34
106504: 50 push %eax
106505: e8 fa 66 00 00 call 10cc04 <calloc>
10650a: 89 c1 mov %eax,%ecx
10650c: a3 80 c9 11 00 mov %eax,0x11c980
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
106511: 83 c4 10 add $0x10,%esp
106514: 85 c0 test %eax,%eax
106516: 75 07 jne 10651f <rtems_libio_init+0x2f> <== ALWAYS TAKEN
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
106518: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10651b: 6a 1a push $0x1a <== NOT EXECUTED
10651d: eb 4a jmp 106569 <rtems_libio_init+0x79> <== NOT EXECUTED
iop = rtems_libio_iop_freelist = rtems_libio_iops;
10651f: a3 84 c9 11 00 mov %eax,0x11c984
for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++)
106524: 8b 1d b8 86 11 00 mov 0x1186b8,%ebx
10652a: 89 c2 mov %eax,%edx
10652c: 31 c0 xor %eax,%eax
10652e: eb 03 jmp 106533 <rtems_libio_init+0x43>
iop->data1 = iop + 1;
106530: 89 52 f4 mov %edx,-0xc(%edx)
106533: 40 inc %eax
106534: 83 c2 34 add $0x34,%edx
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++)
106537: 39 d8 cmp %ebx,%eax
106539: 75 f5 jne 106530 <rtems_libio_init+0x40>
iop->data1 = iop + 1;
iop->data1 = NULL;
10653b: 6b c0 34 imul $0x34,%eax,%eax
10653e: c7 44 01 f4 00 00 00 movl $0x0,-0xc(%ecx,%eax,1)
106545: 00
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
106546: 83 ec 0c sub $0xc,%esp
106549: 68 88 c9 11 00 push $0x11c988
10654e: 6a 00 push $0x0
106550: 6a 54 push $0x54
106552: 6a 01 push $0x1
106554: 68 4f 49 42 4c push $0x4c42494f
106559: e8 e2 29 00 00 call 108f40 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
10655e: 83 c4 20 add $0x20,%esp
106561: 85 c0 test %eax,%eax
106563: 74 09 je 10656e <rtems_libio_init+0x7e> <== ALWAYS TAKEN
rtems_fatal_error_occurred( rc );
106565: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106568: 50 push %eax <== NOT EXECUTED
106569: e8 1e 32 00 00 call 10978c <rtems_fatal_error_occurred><== NOT EXECUTED
/*
* Initialize the base file system infrastructure.
*/
rtems_filesystem_initialize();
}
10656e: 8b 5d fc mov -0x4(%ebp),%ebx
106571: c9 leave
/*
* Initialize the base file system infrastructure.
*/
rtems_filesystem_initialize();
106572: e9 a5 65 00 00 jmp 10cb1c <rtems_filesystem_initialize>
0010ce18 <rtems_libio_is_file_open>:
*/
int rtems_libio_is_file_open(
void *node_access
)
{
10ce18: 55 push %ebp <== NOT EXECUTED
10ce19: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10ce1b: 53 push %ebx <== NOT EXECUTED
10ce1c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10ce1f: 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 );
10ce22: 6a 00 push $0x0 <== NOT EXECUTED
10ce24: 6a 00 push $0x0 <== NOT EXECUTED
10ce26: ff 35 88 c9 11 00 pushl 0x11c988 <== NOT EXECUTED
10ce2c: e8 43 c3 ff ff call 109174 <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++){
10ce31: a1 80 c9 11 00 mov 0x11c980,%eax <== NOT EXECUTED
10ce36: 8b 0d b8 86 11 00 mov 0x1186b8,%ecx <== NOT EXECUTED
10ce3c: 31 d2 xor %edx,%edx <== NOT EXECUTED
10ce3e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ce41: eb 16 jmp 10ce59 <rtems_libio_is_file_open+0x41><== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {
10ce43: f6 40 0d 01 testb $0x1,0xd(%eax) <== NOT EXECUTED
10ce47: 74 0c je 10ce55 <rtems_libio_is_file_open+0x3d><== NOT EXECUTED
/*
* Check if this node is under the file system that we
* are trying to dismount.
*/
if ( iop->pathinfo.node_access == node_access ) {
10ce49: 39 58 10 cmp %ebx,0x10(%eax) <== NOT EXECUTED
10ce4c: 75 07 jne 10ce55 <rtems_libio_is_file_open+0x3d><== NOT EXECUTED
10ce4e: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED
10ce53: eb 0a jmp 10ce5f <rtems_libio_is_file_open+0x47><== NOT EXECUTED
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
10ce55: 83 c0 34 add $0x34,%eax <== NOT EXECUTED
10ce58: 42 inc %edx <== NOT EXECUTED
10ce59: 39 ca cmp %ecx,%edx <== NOT EXECUTED
10ce5b: 72 e6 jb 10ce43 <rtems_libio_is_file_open+0x2b><== NOT EXECUTED
10ce5d: 31 db xor %ebx,%ebx <== NOT EXECUTED
break;
}
}
}
rtems_semaphore_release( rtems_libio_semaphore );
10ce5f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10ce62: ff 35 88 c9 11 00 pushl 0x11c988 <== NOT EXECUTED
10ce68: e8 ef c3 ff ff call 10925c <rtems_semaphore_release><== NOT EXECUTED
return result;
}
10ce6d: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10ce6f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10ce72: c9 leave <== NOT EXECUTED
10ce73: c3 ret <== NOT EXECUTED
0010ce74 <rtems_libio_is_open_files_in_fs>:
*/
int rtems_libio_is_open_files_in_fs(
rtems_filesystem_mount_table_entry_t * fs_mt_entry
)
{
10ce74: 55 push %ebp <== NOT EXECUTED
10ce75: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10ce77: 53 push %ebx <== NOT EXECUTED
10ce78: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10ce7b: 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 );
10ce7e: 6a 00 push $0x0 <== NOT EXECUTED
10ce80: 6a 00 push $0x0 <== NOT EXECUTED
10ce82: ff 35 88 c9 11 00 pushl 0x11c988 <== NOT EXECUTED
10ce88: e8 e7 c2 ff ff call 109174 <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++){
10ce8d: a1 80 c9 11 00 mov 0x11c980,%eax <== NOT EXECUTED
10ce92: 8b 0d b8 86 11 00 mov 0x1186b8,%ecx <== NOT EXECUTED
10ce98: 31 d2 xor %edx,%edx <== NOT EXECUTED
10ce9a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10ce9d: eb 16 jmp 10ceb5 <rtems_libio_is_open_files_in_fs+0x41><== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {
10ce9f: f6 40 0d 01 testb $0x1,0xd(%eax) <== NOT EXECUTED
10cea3: 74 0c je 10ceb1 <rtems_libio_is_open_files_in_fs+0x3d><== 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 ) {
10cea5: 39 58 1c cmp %ebx,0x1c(%eax) <== NOT EXECUTED
10cea8: 75 07 jne 10ceb1 <rtems_libio_is_open_files_in_fs+0x3d><== NOT EXECUTED
10ceaa: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED
10ceaf: eb 0a jmp 10cebb <rtems_libio_is_open_files_in_fs+0x47><== NOT EXECUTED
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
10ceb1: 83 c0 34 add $0x34,%eax <== NOT EXECUTED
10ceb4: 42 inc %edx <== NOT EXECUTED
10ceb5: 39 ca cmp %ecx,%edx <== NOT EXECUTED
10ceb7: 72 e6 jb 10ce9f <rtems_libio_is_open_files_in_fs+0x2b><== NOT EXECUTED
10ceb9: 31 db xor %ebx,%ebx <== NOT EXECUTED
break;
}
}
}
rtems_semaphore_release( rtems_libio_semaphore );
10cebb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10cebe: ff 35 88 c9 11 00 pushl 0x11c988 <== NOT EXECUTED
10cec4: e8 93 c3 ff ff call 10925c <rtems_semaphore_release><== NOT EXECUTED
return result;
}
10cec9: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10cecb: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
10cece: c9 leave <== NOT EXECUTED
10cecf: c3 ret <== NOT EXECUTED
0010cdd8 <rtems_libio_to_fcntl_flags>:
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
10cdd8: 55 push %ebp <== NOT EXECUTED
10cdd9: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10cddb: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
10cdde: 89 c8 mov %ecx,%eax <== NOT EXECUTED
10cde0: 83 e0 06 and $0x6,%eax <== NOT EXECUTED
10cde3: ba 02 00 00 00 mov $0x2,%edx <== NOT EXECUTED
10cde8: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED
10cdeb: 74 0f je 10cdfc <rtems_libio_to_fcntl_flags+0x24><== NOT EXECUTED
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
10cded: 31 d2 xor %edx,%edx <== NOT EXECUTED
10cdef: f6 c1 02 test $0x2,%cl <== NOT EXECUTED
10cdf2: 75 08 jne 10cdfc <rtems_libio_to_fcntl_flags+0x24><== NOT EXECUTED
10cdf4: 89 ca mov %ecx,%edx <== NOT EXECUTED
10cdf6: c1 ea 02 shr $0x2,%edx <== NOT EXECUTED
10cdf9: 83 e2 01 and $0x1,%edx <== NOT EXECUTED
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
10cdfc: f6 c1 01 test $0x1,%cl <== NOT EXECUTED
10cdff: 74 03 je 10ce04 <rtems_libio_to_fcntl_flags+0x2c><== NOT EXECUTED
fcntl_flags |= O_NONBLOCK;
10ce01: 80 ce 40 or $0x40,%dh <== NOT EXECUTED
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
10ce04: f6 c5 02 test $0x2,%ch <== NOT EXECUTED
10ce07: 74 03 je 10ce0c <rtems_libio_to_fcntl_flags+0x34><== NOT EXECUTED
fcntl_flags |= O_APPEND;
10ce09: 83 ca 08 or $0x8,%edx <== NOT EXECUTED
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
10ce0c: 80 e5 04 and $0x4,%ch <== NOT EXECUTED
10ce0f: 74 03 je 10ce14 <rtems_libio_to_fcntl_flags+0x3c><== NOT EXECUTED
fcntl_flags |= O_CREAT;
10ce11: 80 ce 02 or $0x2,%dh <== NOT EXECUTED
}
return fcntl_flags;
}
10ce14: 89 d0 mov %edx,%eax <== NOT EXECUTED
10ce16: c9 leave <== NOT EXECUTED
10ce17: c3 ret <== NOT EXECUTED
001085fc <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
1085fc: 55 push %ebp
1085fd: 89 e5 mov %esp,%ebp
1085ff: 56 push %esi
108600: 53 push %ebx
108601: 8b 75 08 mov 0x8(%ebp),%esi
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
108604: 85 f6 test %esi,%esi
108606: 74 55 je 10865d <rtems_memalign+0x61>
return EINVAL;
*pointer = NULL;
108608: c7 06 00 00 00 00 movl $0x0,(%esi)
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
10860e: 83 3d 8c 1b 12 00 03 cmpl $0x3,0x121b8c
108615: 75 09 jne 108620 <rtems_memalign+0x24> <== NEVER TAKEN
108617: e8 f8 f1 ff ff call 107814 <malloc_is_system_state_OK>
10861c: 84 c0 test %al,%al
10861e: 74 3d je 10865d <rtems_memalign+0x61> <== NEVER TAKEN
/*
*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
108620: e8 46 f2 ff ff call 10786b <malloc_deferred_frees_process>
/*
* Perform the aligned allocation requested
*/
return_this = _Protected_heap_Allocate_aligned(
108625: 50 push %eax
108626: ff 75 0c pushl 0xc(%ebp)
108629: ff 75 10 pushl 0x10(%ebp)
10862c: 68 a4 18 12 00 push $0x1218a4
108631: e8 66 3f 00 00 call 10c59c <_Protected_heap_Allocate_aligned>
108636: 89 c3 mov %eax,%ebx
&RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
108638: 83 c4 10 add $0x10,%esp
10863b: b8 0c 00 00 00 mov $0xc,%eax
108640: 85 db test %ebx,%ebx
108642: 74 1e je 108662 <rtems_memalign+0x66>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
108644: a1 d4 f9 11 00 mov 0x11f9d4,%eax
108649: 85 c0 test %eax,%eax
10864b: 74 0a je 108657 <rtems_memalign+0x5b> <== ALWAYS TAKEN
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
10864d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108650: 56 push %esi <== NOT EXECUTED
108651: ff 50 04 call *0x4(%eax) <== NOT EXECUTED
108654: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
*/
if (rtems_malloc_boundary_helpers)
(*rtems_malloc_boundary_helpers->at_malloc)(return_this, size);
#endif
*pointer = return_this;
108657: 89 1e mov %ebx,(%esi)
108659: 31 c0 xor %eax,%eax
10865b: eb 05 jmp 108662 <rtems_memalign+0x66>
return 0;
10865d: b8 16 00 00 00 mov $0x16,%eax
}
108662: 8d 65 f8 lea -0x8(%ebp),%esp
108665: 5b pop %ebx
108666: 5e pop %esi
108667: c9 leave
108668: c3 ret
00110d44 <rtems_message_queue_create>:
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
Objects_Id *id
)
{
110d44: 55 push %ebp
110d45: 89 e5 mov %esp,%ebp
110d47: 57 push %edi
110d48: 56 push %esi
110d49: 53 push %ebx
110d4a: 83 ec 1c sub $0x1c,%esp
110d4d: 8b 7d 10 mov 0x10(%ebp),%edi
110d50: 8b 75 14 mov 0x14(%ebp),%esi
CORE_message_queue_Attributes the_msgq_attributes;
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !rtems_is_name_valid( name ) )
110d53: b8 03 00 00 00 mov $0x3,%eax
110d58: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
110d5c: 0f 84 b2 00 00 00 je 110e14 <rtems_message_queue_create+0xd0>
return RTEMS_INVALID_NAME;
if ( !id )
110d62: b8 09 00 00 00 mov $0x9,%eax
110d67: 83 7d 18 00 cmpl $0x0,0x18(%ebp)
110d6b: 0f 84 a3 00 00 00 je 110e14 <rtems_message_queue_create+0xd0><== NEVER TAKEN
if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
110d71: b8 0a 00 00 00 mov $0xa,%eax
110d76: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
110d7a: 0f 84 94 00 00 00 je 110e14 <rtems_message_queue_create+0xd0><== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
110d80: b8 08 00 00 00 mov $0x8,%eax
110d85: 85 ff test %edi,%edi
110d87: 0f 84 87 00 00 00 je 110e14 <rtems_message_queue_create+0xd0><== NEVER TAKEN
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
110d8d: a1 e0 27 13 00 mov 0x1327e0,%eax
110d92: 40 inc %eax
110d93: a3 e0 27 13 00 mov %eax,0x1327e0
#endif
#endif
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
110d98: e8 7b 72 00 00 call 118018 <_Message_queue_Allocate>
110d9d: 89 c3 mov %eax,%ebx
if ( !the_message_queue ) {
110d9f: 85 c0 test %eax,%eax
110da1: 75 0c jne 110daf <rtems_message_queue_create+0x6b>
_Thread_Enable_dispatch();
110da3: e8 70 49 00 00 call 115718 <_Thread_Enable_dispatch>
110da8: b8 05 00 00 00 mov $0x5,%eax
110dad: eb 65 jmp 110e14 <rtems_message_queue_create+0xd0>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_message_queue->attribute_set = attribute_set;
110daf: 89 70 10 mov %esi,0x10(%eax)
if (_Attributes_Is_priority( attribute_set ) )
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
110db2: 31 c0 xor %eax,%eax
110db4: f7 c6 04 00 00 00 test $0x4,%esi
110dba: 0f 95 c0 setne %al
110dbd: 89 45 f0 mov %eax,-0x10(%ebp)
else
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
if ( ! _CORE_message_queue_Initialize(
110dc0: 57 push %edi
110dc1: ff 75 0c pushl 0xc(%ebp)
110dc4: 8d 45 f0 lea -0x10(%ebp),%eax
110dc7: 50 push %eax
110dc8: 8d 43 14 lea 0x14(%ebx),%eax
110dcb: 50 push %eax
110dcc: e8 9b 2d 00 00 call 113b6c <_CORE_message_queue_Initialize>
110dd1: 83 c4 10 add $0x10,%esp
110dd4: 84 c0 test %al,%al
110dd6: 75 1c jne 110df4 <rtems_message_queue_create+0xb0>
* @return This method returns the maximum memory available. If
* unsuccessful, 0 will be returned.
*/
static inline uint32_t _Protected_heap_Initialize(
Heap_Control *the_heap,
void *starting_address,
110dd8: 50 push %eax
110dd9: 50 push %eax
110dda: 53 push %ebx
110ddb: 68 94 2a 13 00 push $0x132a94
110de0: e8 03 40 00 00 call 114de8 <_Objects_Free>
_Objects_MP_Close(
&_Message_queue_Information, the_message_queue->Object.id);
#endif
_Message_queue_Free( the_message_queue );
_Thread_Enable_dispatch();
110de5: e8 2e 49 00 00 call 115718 <_Thread_Enable_dispatch>
110dea: b8 0d 00 00 00 mov $0xd,%eax
110def: 83 c4 10 add $0x10,%esp
110df2: eb 20 jmp 110e14 <rtems_message_queue_create+0xd0>
110df4: 8b 4b 08 mov 0x8(%ebx),%ecx
110df7: 0f b7 d1 movzwl %cx,%edx
110dfa: a1 b0 2a 13 00 mov 0x132ab0,%eax
110dff: 89 1c 90 mov %ebx,(%eax,%edx,4)
110e02: 8b 45 08 mov 0x8(%ebp),%eax
110e05: 89 43 0c mov %eax,0xc(%ebx)
&_Message_queue_Information,
&the_message_queue->Object,
(Objects_Name) name
);
*id = the_message_queue->Object.id;
110e08: 8b 45 18 mov 0x18(%ebp),%eax
110e0b: 89 08 mov %ecx,(%eax)
name,
0
);
#endif
_Thread_Enable_dispatch();
110e0d: e8 06 49 00 00 call 115718 <_Thread_Enable_dispatch>
110e12: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
110e14: 8d 65 f4 lea -0xc(%ebp),%esp
110e17: 5b pop %ebx
110e18: 5e pop %esi
110e19: 5f pop %edi
110e1a: c9 leave
110e1b: c3 ret
00110e80 <rtems_message_queue_flush>:
rtems_status_code rtems_message_queue_flush(
Objects_Id id,
uint32_t *count
)
{
110e80: 55 push %ebp
110e81: 89 e5 mov %esp,%ebp
110e83: 53 push %ebx
110e84: 83 ec 14 sub $0x14,%esp
110e87: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
110e8a: b8 09 00 00 00 mov $0x9,%eax
110e8f: 85 db test %ebx,%ebx
110e91: 74 3a je 110ecd <rtems_message_queue_flush+0x4d><== NEVER TAKEN
* @param[in] size is the size in bytes of the memory area to add
* @return a status indicating success or the reason for failure
*/
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
110e93: 50 push %eax
110e94: 8d 45 f8 lea -0x8(%ebp),%eax
110e97: 50 push %eax
110e98: ff 75 08 pushl 0x8(%ebp)
110e9b: 68 94 2a 13 00 push $0x132a94
110ea0: e8 b3 40 00 00 call 114f58 <_Objects_Get>
110ea5: 89 c2 mov %eax,%edx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
110ea7: 83 c4 10 add $0x10,%esp
110eaa: b8 04 00 00 00 mov $0x4,%eax
110eaf: 83 7d f8 00 cmpl $0x0,-0x8(%ebp)
110eb3: 75 18 jne 110ecd <rtems_message_queue_flush+0x4d>
case OBJECTS_LOCAL:
*count = _CORE_message_queue_Flush( &the_message_queue->message_queue );
110eb5: 83 ec 0c sub $0xc,%esp
110eb8: 8d 42 14 lea 0x14(%edx),%eax
110ebb: 50 push %eax
110ebc: e8 47 2c 00 00 call 113b08 <_CORE_message_queue_Flush>
110ec1: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
110ec3: e8 50 48 00 00 call 115718 <_Thread_Enable_dispatch>
110ec8: 31 c0 xor %eax,%eax
110eca: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
110ecd: 8b 5d fc mov -0x4(%ebp),%ebx
110ed0: c9 leave
110ed1: c3 ret
00110ed4 <rtems_message_queue_get_number_pending>:
rtems_status_code rtems_message_queue_get_number_pending(
Objects_Id id,
uint32_t *count
)
{
110ed4: 55 push %ebp
110ed5: 89 e5 mov %esp,%ebp
110ed7: 53 push %ebx
110ed8: 83 ec 14 sub $0x14,%esp
110edb: 8b 5d 0c mov 0xc(%ebp),%ebx
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
110ede: b8 09 00 00 00 mov $0x9,%eax
110ee3: 85 db test %ebx,%ebx
110ee5: 74 2e je 110f15 <rtems_message_queue_get_number_pending+0x41><== NEVER TAKEN
110ee7: 50 push %eax
110ee8: 8d 45 f8 lea -0x8(%ebp),%eax
110eeb: 50 push %eax
110eec: ff 75 08 pushl 0x8(%ebp)
110eef: 68 94 2a 13 00 push $0x132a94
110ef4: e8 5f 40 00 00 call 114f58 <_Objects_Get>
110ef9: 89 c2 mov %eax,%edx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
110efb: 83 c4 10 add $0x10,%esp
110efe: b8 04 00 00 00 mov $0x4,%eax
110f03: 83 7d f8 00 cmpl $0x0,-0x8(%ebp)
110f07: 75 0c jne 110f15 <rtems_message_queue_get_number_pending+0x41>
case OBJECTS_LOCAL:
*count = the_message_queue->message_queue.number_of_pending_messages;
110f09: 8b 42 5c mov 0x5c(%edx),%eax
110f0c: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
110f0e: e8 05 48 00 00 call 115718 <_Thread_Enable_dispatch>
110f13: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
110f15: 8b 5d fc mov -0x4(%ebp),%ebx
110f18: c9 leave
110f19: c3 ret
00108ec0 <rtems_message_queue_send>:
rtems_status_code rtems_message_queue_send(
Objects_Id id,
const void *buffer,
size_t size
)
{
108ec0: 55 push %ebp
108ec1: 89 e5 mov %esp,%ebp
108ec3: 56 push %esi
108ec4: 53 push %ebx
108ec5: 83 ec 10 sub $0x10,%esp
108ec8: 8b 5d 08 mov 0x8(%ebp),%ebx
108ecb: 8b 75 0c mov 0xc(%ebp),%esi
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
108ece: b8 09 00 00 00 mov $0x9,%eax
108ed3: 85 f6 test %esi,%esi
108ed5: 74 4f je 108f26 <rtems_message_queue_send+0x66><== NEVER TAKEN
* @param[in] size is the size in bytes of the memory area to add
* @return a status indicating success or the reason for failure
*/
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
108ed7: 50 push %eax
108ed8: 8d 45 f4 lea -0xc(%ebp),%eax
108edb: 50 push %eax
108edc: 53 push %ebx
108edd: 68 8c cd 11 00 push $0x11cd8c
108ee2: e8 45 17 00 00 call 10a62c <_Objects_Get>
108ee7: 89 c2 mov %eax,%edx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
108ee9: 83 c4 10 add $0x10,%esp
108eec: b8 04 00 00 00 mov $0x4,%eax
108ef1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
108ef5: 75 2f jne 108f26 <rtems_message_queue_send+0x66><== NEVER TAKEN
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory for
* the heap
108ef7: 6a 00 push $0x0
108ef9: 6a 00 push $0x0
108efb: 68 ff ff ff 7f push $0x7fffffff
108f00: 6a 00 push $0x0
108f02: 53 push %ebx
108f03: ff 75 10 pushl 0x10(%ebp)
108f06: 56 push %esi
108f07: 8d 42 14 lea 0x14(%edx),%eax
108f0a: 50 push %eax
108f0b: e8 88 0b 00 00 call 109a98 <_CORE_message_queue_Submit>
108f10: 89 c3 mov %eax,%ebx
MESSAGE_QUEUE_MP_HANDLER,
FALSE, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
108f12: 83 c4 20 add $0x20,%esp
108f15: e8 d2 1e 00 00 call 10adec <_Thread_Enable_dispatch>
/*
* Since this API does not allow for blocking sends, we can directly
* return the returned status.
*/
return _Message_queue_Translate_core_message_queue_return_code(status);
108f1a: 83 ec 0c sub $0xc,%esp
108f1d: 53 push %ebx
108f1e: e8 0d 00 00 00 call 108f30 <_Message_queue_Translate_core_message_queue_return_code>
108f23: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
108f26: 8d 65 f8 lea -0x8(%ebp),%esp
108f29: 5b pop %ebx
108f2a: 5e pop %esi
108f2b: c9 leave
108f2c: c3 ret
00111040 <rtems_message_queue_urgent>:
rtems_status_code rtems_message_queue_urgent(
Objects_Id id,
const void *buffer,
size_t size
)
{
111040: 55 push %ebp
111041: 89 e5 mov %esp,%ebp
111043: 56 push %esi
111044: 53 push %ebx
111045: 83 ec 10 sub $0x10,%esp
111048: 8b 5d 08 mov 0x8(%ebp),%ebx
11104b: 8b 75 0c mov 0xc(%ebp),%esi
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
11104e: b8 09 00 00 00 mov $0x9,%eax
111053: 85 f6 test %esi,%esi
111055: 74 4f je 1110a6 <rtems_message_queue_urgent+0x66><== NEVER TAKEN
* @param[in] size is the size in bytes of the memory area to add
* @return a status indicating success or the reason for failure
*/
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
111057: 50 push %eax
111058: 8d 45 f4 lea -0xc(%ebp),%eax
11105b: 50 push %eax
11105c: 53 push %ebx
11105d: 68 94 2a 13 00 push $0x132a94
111062: e8 f1 3e 00 00 call 114f58 <_Objects_Get>
111067: 89 c2 mov %eax,%edx
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
111069: 83 c4 10 add $0x10,%esp
11106c: b8 04 00 00 00 mov $0x4,%eax
111071: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
111075: 75 2f jne 1110a6 <rtems_message_queue_urgent+0x66>
size_t size
111077: 6a 00 push $0x0
111079: 6a 00 push $0x0
11107b: 68 00 00 00 80 push $0x80000000
111080: 6a 00 push $0x0
111082: 53 push %ebx
111083: ff 75 10 pushl 0x10(%ebp)
111086: 56 push %esi
111087: 8d 42 14 lea 0x14(%edx),%eax
11108a: 50 push %eax
11108b: e8 cc 2c 00 00 call 113d5c <_CORE_message_queue_Submit>
111090: 89 c3 mov %eax,%ebx
id,
MESSAGE_QUEUE_MP_HANDLER,
FALSE, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
111092: 83 c4 20 add $0x20,%esp
111095: e8 7e 46 00 00 call 115718 <_Thread_Enable_dispatch>
/*
* Since this API does not allow for blocking sends, we can directly
* return the returned status.
*/
return _Message_queue_Translate_core_message_queue_return_code(status);
11109a: 83 ec 0c sub $0xc,%esp
11109d: 53 push %ebx
11109e: e8 8d ff ff ff call 111030 <_Message_queue_Translate_core_message_queue_return_code>
1110a3: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
1110a6: 8d 65 f8 lea -0x8(%ebp),%esp
1110a9: 5b pop %ebx
1110aa: 5e pop %esi
1110ab: c9 leave
1110ac: c3 ret
0010a510 <rtems_object_set_name>:
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
10a510: 55 push %ebp
10a511: 89 e5 mov %esp,%ebp
10a513: 57 push %edi
10a514: 56 push %esi
10a515: 53 push %ebx
10a516: 83 ec 1c sub $0x1c,%esp
10a519: 8b 7d 0c mov 0xc(%ebp),%edi
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
10a51c: b8 09 00 00 00 mov $0x9,%eax
10a521: 85 ff test %edi,%edi
10a523: 74 50 je 10a575 <rtems_object_set_name+0x65><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10a525: 8b 5d 08 mov 0x8(%ebp),%ebx
10a528: 85 db test %ebx,%ebx
10a52a: 75 08 jne 10a534 <rtems_object_set_name+0x24>
10a52c: a1 2c 06 12 00 mov 0x12062c,%eax
10a531: 8b 58 08 mov 0x8(%eax),%ebx
information = _Objects_Get_information_id( tmpId );
10a534: 83 ec 0c sub $0xc,%esp
10a537: 53 push %ebx
10a538: e8 a7 16 00 00 call 10bbe4 <_Objects_Get_information_id>
10a53d: 89 c6 mov %eax,%esi
if ( !information )
10a53f: 83 c4 10 add $0x10,%esp
10a542: 85 c0 test %eax,%eax
10a544: 74 2a je 10a570 <rtems_object_set_name+0x60>
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
10a546: 51 push %ecx
10a547: 8d 45 f0 lea -0x10(%ebp),%eax
10a54a: 50 push %eax
10a54b: 53 push %ebx
10a54c: 56 push %esi
10a54d: e8 2a 18 00 00 call 10bd7c <_Objects_Get>
switch ( location ) {
10a552: 83 c4 10 add $0x10,%esp
10a555: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
10a559: 75 15 jne 10a570 <rtems_object_set_name+0x60>
case OBJECTS_LOCAL:
_Objects_Set_name( information, the_object, name );
10a55b: 52 push %edx
10a55c: 57 push %edi
10a55d: 50 push %eax
10a55e: 56 push %esi
10a55f: e8 54 1a 00 00 call 10bfb8 <_Objects_Set_name>
_Thread_Enable_dispatch();
10a564: e8 33 21 00 00 call 10c69c <_Thread_Enable_dispatch>
10a569: 31 c0 xor %eax,%eax
10a56b: 83 c4 10 add $0x10,%esp
10a56e: eb 05 jmp 10a575 <rtems_object_set_name+0x65>
return RTEMS_SUCCESSFUL;
10a570: b8 04 00 00 00 mov $0x4,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a575: 8d 65 f4 lea -0xc(%ebp),%esp
10a578: 5b pop %ebx
10a579: 5e pop %esi
10a57a: 5f pop %edi
10a57b: c9 leave
10a57c: c3 ret
00107028 <rtems_panic>:
void rtems_panic(
const char *printf_format,
...
)
{
107028: 55 push %ebp <== NOT EXECUTED
107029: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10702b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED
10702e: 8d 4d 0c lea 0xc(%ebp),%ecx <== NOT EXECUTED
va_list arglist;
va_start(arglist, printf_format);
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
107031: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
107034: b8 00 00 00 20 mov $0x20000000,%eax <== NOT EXECUTED
107039: e8 83 fe ff ff call 106ec1 <rtems_verror> <== NOT EXECUTED
va_end(arglist);
}
10703e: c9 leave <== NOT EXECUTED
10703f: c3 ret <== NOT EXECUTED
001110b0 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
Objects_Id *id
)
{
1110b0: 55 push %ebp
1110b1: 89 e5 mov %esp,%ebp
1110b3: 57 push %edi
1110b4: 56 push %esi
1110b5: 53 push %ebx
1110b6: 83 ec 0c sub $0xc,%esp
1110b9: 8b 7d 10 mov 0x10(%ebp),%edi
1110bc: 8b 75 14 mov 0x14(%ebp),%esi
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
1110bf: b8 03 00 00 00 mov $0x3,%eax
1110c4: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
1110c8: 0f 84 c9 00 00 00 je 111197 <rtems_partition_create+0xe7>
return RTEMS_INVALID_NAME;
if ( !starting_address )
1110ce: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
1110d2: 0f 84 b3 00 00 00 je 11118b <rtems_partition_create+0xdb><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !id )
1110d8: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp)
1110dc: 0f 84 a9 00 00 00 je 11118b <rtems_partition_create+0xdb><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
1110e2: 85 ff test %edi,%edi
1110e4: 0f 84 a8 00 00 00 je 111192 <rtems_partition_create+0xe2>
1110ea: 85 f6 test %esi,%esi
1110ec: 0f 84 a0 00 00 00 je 111192 <rtems_partition_create+0xe2>
1110f2: 39 f7 cmp %esi,%edi
1110f4: 0f 82 98 00 00 00 jb 111192 <rtems_partition_create+0xe2>
1110fa: f7 c6 03 00 00 00 test $0x3,%esi
111100: 0f 85 8c 00 00 00 jne 111192 <rtems_partition_create+0xe2>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
111106: f6 45 0c 03 testb $0x3,0xc(%ebp)
11110a: 75 7f jne 11118b <rtems_partition_create+0xdb>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
11110c: a1 e0 27 13 00 mov 0x1327e0,%eax
111111: 40 inc %eax
111112: a3 e0 27 13 00 mov %eax,0x1327e0
* Returns TRUE if the @a starting_address is in the heap, and FALSE
* otherwise.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the user block
* to obtain the size of
111117: 83 ec 0c sub $0xc,%esp
11111a: 68 14 26 13 00 push $0x132614
11111f: e8 b4 39 00 00 call 114ad8 <_Objects_Allocate>
111124: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
111126: 83 c4 10 add $0x10,%esp
111129: 85 c0 test %eax,%eax
11112b: 75 0c jne 111139 <rtems_partition_create+0x89>
_Thread_Enable_dispatch();
11112d: e8 e6 45 00 00 call 115718 <_Thread_Enable_dispatch>
111132: b8 05 00 00 00 mov $0x5,%eax
111137: eb 5e jmp 111197 <rtems_partition_create+0xe7>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
111139: 8b 45 0c mov 0xc(%ebp),%eax
11113c: 89 43 10 mov %eax,0x10(%ebx)
the_partition->length = length;
11113f: 89 7b 14 mov %edi,0x14(%ebx)
the_partition->buffer_size = buffer_size;
111142: 89 73 18 mov %esi,0x18(%ebx)
the_partition->attribute_set = attribute_set;
111145: 8b 45 18 mov 0x18(%ebp),%eax
111148: 89 43 1c mov %eax,0x1c(%ebx)
the_partition->number_of_used_blocks = 0;
11114b: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
_Chain_Initialize( &the_partition->Memory, starting_address,
111152: 56 push %esi
111153: 89 f8 mov %edi,%eax
111155: 31 d2 xor %edx,%edx
111157: f7 f6 div %esi
111159: 50 push %eax
11115a: ff 75 0c pushl 0xc(%ebp)
11115d: 8d 43 24 lea 0x24(%ebx),%eax
111160: 50 push %eax
111161: e8 ca 28 00 00 call 113a30 <_Chain_Initialize>
111166: 8b 4b 08 mov 0x8(%ebx),%ecx
111169: 0f b7 d1 movzwl %cx,%edx
11116c: a1 30 26 13 00 mov 0x132630,%eax
111171: 89 1c 90 mov %ebx,(%eax,%edx,4)
111174: 8b 45 08 mov 0x8(%ebp),%eax
111177: 89 43 0c mov %eax,0xc(%ebx)
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
11117a: 8b 45 1c mov 0x1c(%ebp),%eax
11117d: 89 08 mov %ecx,(%eax)
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
11117f: e8 94 45 00 00 call 115718 <_Thread_Enable_dispatch>
111184: 31 c0 xor %eax,%eax
111186: 83 c4 10 add $0x10,%esp
111189: eb 0c jmp 111197 <rtems_partition_create+0xe7>
return RTEMS_SUCCESSFUL;
11118b: b8 09 00 00 00 mov $0x9,%eax
111190: eb 05 jmp 111197 <rtems_partition_create+0xe7>
111192: b8 08 00 00 00 mov $0x8,%eax
}
111197: 8d 65 f4 lea -0xc(%ebp),%esp
11119a: 5b pop %ebx
11119b: 5e pop %esi
11119c: 5f pop %edi
11119d: c9 leave
11119e: c3 ret
00111204 <rtems_partition_get_buffer>:
rtems_status_code rtems_partition_get_buffer(
Objects_Id id,
void **buffer
)
{
111204: 55 push %ebp
111205: 89 e5 mov %esp,%ebp
111207: 57 push %edi
111208: 56 push %esi
111209: 53 push %ebx
11120a: 83 ec 1c sub $0x1c,%esp
11120d: 8b 7d 0c mov 0xc(%ebp),%edi
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
111210: b8 09 00 00 00 mov $0x9,%eax
111215: 85 ff test %edi,%edi
111217: 74 4f je 111268 <rtems_partition_get_buffer+0x64><== NEVER TAKEN
);
/**
* This routine returns the block of memory which begins
* at @a starting_address to @a the_heap. Any coalescing which is
* possible with the freeing of this routine is performed.
111219: 50 push %eax
11121a: 8d 45 f0 lea -0x10(%ebp),%eax
11121d: 50 push %eax
11121e: ff 75 08 pushl 0x8(%ebp)
111221: 68 14 26 13 00 push $0x132614
111226: e8 2d 3d 00 00 call 114f58 <_Objects_Get>
11122b: 89 c3 mov %eax,%ebx
return RTEMS_INVALID_ADDRESS;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
11122d: 83 c4 10 add $0x10,%esp
111230: b8 04 00 00 00 mov $0x4,%eax
111235: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
111239: 75 2d jne 111268 <rtems_partition_get_buffer+0x64>
#endif
/**
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
11123b: 83 ec 0c sub $0xc,%esp
11123e: 8d 43 24 lea 0x24(%ebx),%eax
111241: 50 push %eax
111242: e8 c1 27 00 00 call 113a08 <_Chain_Get>
111247: 89 c6 mov %eax,%esi
case OBJECTS_LOCAL:
the_buffer = _Partition_Allocate_buffer( the_partition );
if ( the_buffer ) {
111249: 83 c4 10 add $0x10,%esp
11124c: 85 c0 test %eax,%eax
11124e: 74 0e je 11125e <rtems_partition_get_buffer+0x5a>
the_partition->number_of_used_blocks += 1;
111250: ff 43 20 incl 0x20(%ebx)
_Thread_Enable_dispatch();
111253: e8 c0 44 00 00 call 115718 <_Thread_Enable_dispatch>
*buffer = the_buffer;
111258: 89 37 mov %esi,(%edi)
11125a: 31 c0 xor %eax,%eax
11125c: eb 0a jmp 111268 <rtems_partition_get_buffer+0x64>
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
11125e: e8 b5 44 00 00 call 115718 <_Thread_Enable_dispatch>
111263: b8 0d 00 00 00 mov $0xd,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
111268: 8d 65 f4 lea -0xc(%ebp),%esp
11126b: 5b pop %ebx
11126c: 5e pop %esi
11126d: 5f pop %edi
11126e: c9 leave
11126f: c3 ret
001107e4 <rtems_port_create>:
void *internal_start,
void *external_start,
uint32_t length,
Objects_Id *id
)
{
1107e4: 55 push %ebp
1107e5: 89 e5 mov %esp,%ebp
1107e7: 57 push %edi
1107e8: 56 push %esi
1107e9: 53 push %ebx
1107ea: 83 ec 0c sub $0xc,%esp
1107ed: 8b 75 0c mov 0xc(%ebp),%esi
1107f0: 8b 7d 10 mov 0x10(%ebp),%edi
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name) )
1107f3: b8 03 00 00 00 mov $0x3,%eax
1107f8: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
1107fc: 74 6f je 11086d <rtems_port_create+0x89>
return RTEMS_INVALID_NAME;
if ( !id )
1107fe: 83 7d 18 00 cmpl $0x0,0x18(%ebp)
110802: 74 64 je 110868 <rtems_port_create+0x84><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( internal_start ) ||
110804: 89 f8 mov %edi,%eax
110806: 09 f0 or %esi,%eax
110808: a8 03 test $0x3,%al
11080a: 75 5c jne 110868 <rtems_port_create+0x84>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
11080c: a1 e0 27 13 00 mov 0x1327e0,%eax
110811: 40 inc %eax
110812: a3 e0 27 13 00 mov %eax,0x1327e0
#ifdef __cplusplus
extern "C" {
#endif
/**
* This routine initializes @a the_heap record to manage the
110817: 83 ec 0c sub $0xc,%esp
11081a: 68 d4 25 13 00 push $0x1325d4
11081f: e8 b4 42 00 00 call 114ad8 <_Objects_Allocate>
110824: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
110826: 83 c4 10 add $0x10,%esp
110829: 85 c0 test %eax,%eax
11082b: 75 0c jne 110839 <rtems_port_create+0x55>
_Thread_Enable_dispatch();
11082d: e8 e6 4e 00 00 call 115718 <_Thread_Enable_dispatch>
110832: b8 05 00 00 00 mov $0x5,%eax
110837: eb 34 jmp 11086d <rtems_port_create+0x89>
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
110839: 89 70 10 mov %esi,0x10(%eax)
the_port->external_base = external_start;
11083c: 89 78 14 mov %edi,0x14(%eax)
the_port->length = length - 1;
11083f: 8b 45 14 mov 0x14(%ebp),%eax
110842: 48 dec %eax
110843: 89 43 18 mov %eax,0x18(%ebx)
110846: 8b 4b 08 mov 0x8(%ebx),%ecx
110849: 0f b7 d1 movzwl %cx,%edx
11084c: a1 f0 25 13 00 mov 0x1325f0,%eax
110851: 89 1c 90 mov %ebx,(%eax,%edx,4)
110854: 8b 45 08 mov 0x8(%ebp),%eax
110857: 89 43 0c mov %eax,0xc(%ebx)
&_Dual_ported_memory_Information,
&the_port->Object,
(Objects_Name) name
);
*id = the_port->Object.id;
11085a: 8b 45 18 mov 0x18(%ebp),%eax
11085d: 89 08 mov %ecx,(%eax)
_Thread_Enable_dispatch();
11085f: e8 b4 4e 00 00 call 115718 <_Thread_Enable_dispatch>
110864: 31 c0 xor %eax,%eax
110866: eb 05 jmp 11086d <rtems_port_create+0x89>
return RTEMS_SUCCESSFUL;
110868: b8 09 00 00 00 mov $0x9,%eax
}
11086d: 8d 65 f4 lea -0xc(%ebp),%esp
110870: 5b pop %ebx
110871: 5e pop %esi
110872: 5f pop %edi
110873: c9 leave
110874: c3 ret
001108cc <rtems_port_external_to_internal>:
rtems_status_code rtems_port_external_to_internal(
Objects_Id id,
void *external,
void **internal
)
{
1108cc: 55 push %ebp
1108cd: 89 e5 mov %esp,%ebp
1108cf: 56 push %esi
1108d0: 53 push %ebx
1108d1: 83 ec 10 sub $0x10,%esp
1108d4: 8b 75 0c mov 0xc(%ebp),%esi
1108d7: 8b 5d 10 mov 0x10(%ebp),%ebx
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !internal )
1108da: b8 09 00 00 00 mov $0x9,%eax
1108df: 85 db test %ebx,%ebx
1108e1: 74 3c je 11091f <rtems_port_external_to_internal+0x53><== NEVER TAKEN
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory
* to add to the heap
* @param[in] size is the size in bytes of the memory area to add
1108e3: 50 push %eax
1108e4: 8d 45 f4 lea -0xc(%ebp),%eax
1108e7: 50 push %eax
1108e8: ff 75 08 pushl 0x8(%ebp)
1108eb: 68 d4 25 13 00 push $0x1325d4
1108f0: e8 63 46 00 00 call 114f58 <_Objects_Get>
1108f5: 89 c1 mov %eax,%ecx
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
1108f7: 83 c4 10 add $0x10,%esp
1108fa: b8 04 00 00 00 mov $0x4,%eax
1108ff: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
110903: 75 1a jne 11091f <rtems_port_external_to_internal+0x53>
* a block of the requested size, then NULL is returned.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
* @return NULL if unsuccessful and a pointer to the block if successful
*/
110905: 89 f2 mov %esi,%edx
110907: 2b 51 14 sub 0x14(%ecx),%edx
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( external, the_port->external_base );
if ( ending > the_port->length )
11090a: 3b 51 18 cmp 0x18(%ecx),%edx
11090d: 76 04 jbe 110913 <rtems_port_external_to_internal+0x47>
*internal = external;
11090f: 89 33 mov %esi,(%ebx)
110911: eb 05 jmp 110918 <rtems_port_external_to_internal+0x4c>
else
*internal = _Addresses_Add_offset( the_port->internal_base,
110913: 03 51 10 add 0x10(%ecx),%edx
110916: 89 13 mov %edx,(%ebx)
ending );
_Thread_Enable_dispatch();
110918: e8 fb 4d 00 00 call 115718 <_Thread_Enable_dispatch>
11091d: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11091f: 8d 65 f8 lea -0x8(%ebp),%esp
110922: 5b pop %ebx
110923: 5e pop %esi
110924: c9 leave
110925: c3 ret
0011094c <rtems_port_internal_to_external>:
rtems_status_code rtems_port_internal_to_external(
Objects_Id id,
void *internal,
void **external
)
{
11094c: 55 push %ebp
11094d: 89 e5 mov %esp,%ebp
11094f: 56 push %esi
110950: 53 push %ebx
110951: 83 ec 10 sub $0x10,%esp
110954: 8b 75 0c mov 0xc(%ebp),%esi
110957: 8b 5d 10 mov 0x10(%ebp),%ebx
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
11095a: b8 09 00 00 00 mov $0x9,%eax
11095f: 85 db test %ebx,%ebx
110961: 74 3c je 11099f <rtems_port_internal_to_external+0x53><== NEVER TAKEN
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory
* to add to the heap
* @param[in] size is the size in bytes of the memory area to add
110963: 50 push %eax
110964: 8d 45 f4 lea -0xc(%ebp),%eax
110967: 50 push %eax
110968: ff 75 08 pushl 0x8(%ebp)
11096b: 68 d4 25 13 00 push $0x1325d4
110970: e8 e3 45 00 00 call 114f58 <_Objects_Get>
110975: 89 c1 mov %eax,%ecx
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
110977: 83 c4 10 add $0x10,%esp
11097a: b8 04 00 00 00 mov $0x4,%eax
11097f: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
110983: 75 1a jne 11099f <rtems_port_internal_to_external+0x53>
* a block of the requested size, then NULL is returned.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
* @return NULL if unsuccessful and a pointer to the block if successful
*/
110985: 89 f2 mov %esi,%edx
110987: 2b 51 10 sub 0x10(%ecx),%edx
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( internal, the_port->internal_base );
if ( ending > the_port->length )
11098a: 3b 51 18 cmp 0x18(%ecx),%edx
11098d: 76 04 jbe 110993 <rtems_port_internal_to_external+0x47>
*external = internal;
11098f: 89 33 mov %esi,(%ebx)
110991: eb 05 jmp 110998 <rtems_port_internal_to_external+0x4c>
else
*external = _Addresses_Add_offset( the_port->external_base,
110993: 03 51 14 add 0x14(%ecx),%edx
110996: 89 13 mov %edx,(%ebx)
ending );
_Thread_Enable_dispatch();
110998: e8 7b 4d 00 00 call 115718 <_Thread_Enable_dispatch>
11099d: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11099f: 8d 65 f8 lea -0x8(%ebp),%esp
1109a2: 5b pop %ebx
1109a3: 5e pop %esi
1109a4: c9 leave
1109a5: c3 ret
00109ce4 <rtems_rate_monotonic_create>:
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
Objects_Id *id
)
{
109ce4: 55 push %ebp
109ce5: 89 e5 mov %esp,%ebp
109ce7: 57 push %edi
109ce8: 56 push %esi
109ce9: 53 push %ebx
109cea: 83 ec 0c sub $0xc,%esp
109ced: 8b 75 08 mov 0x8(%ebp),%esi
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
109cf0: b8 03 00 00 00 mov $0x3,%eax
109cf5: 85 f6 test %esi,%esi
109cf7: 0f 84 ac 00 00 00 je 109da9 <rtems_rate_monotonic_create+0xc5>
return RTEMS_INVALID_NAME;
if ( !id )
109cfd: b8 09 00 00 00 mov $0x9,%eax
109d02: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
109d06: 0f 84 9d 00 00 00 je 109da9 <rtems_rate_monotonic_create+0xc5><== NEVER TAKEN
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
109d0c: a1 84 05 12 00 mov 0x120584,%eax
109d11: 40 inc %eax
109d12: a3 84 05 12 00 mov %eax,0x120584
#ifdef __cplusplus
extern "C" {
#endif
/**
109d17: 83 ec 0c sub $0xc,%esp
109d1a: 68 8c 04 12 00 push $0x12048c
109d1f: e8 e4 1a 00 00 call 10b808 <_Objects_Allocate>
109d24: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
109d26: 83 c4 10 add $0x10,%esp
109d29: 85 c0 test %eax,%eax
109d2b: 75 0c jne 109d39 <rtems_rate_monotonic_create+0x55>
_Thread_Enable_dispatch();
109d2d: e8 b2 27 00 00 call 10c4e4 <_Thread_Enable_dispatch>
109d32: b8 05 00 00 00 mov $0x5,%eax
109d37: eb 70 jmp 109da9 <rtems_rate_monotonic_create+0xc5>
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
109d39: a1 44 06 12 00 mov 0x120644,%eax
109d3e: 89 43 50 mov %eax,0x50(%ebx)
the_period->state = RATE_MONOTONIC_INACTIVE;
109d41: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx)
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
109d48: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
* @param[in] the_heap is the heap to operate upon
109d4f: c7 43 2c 00 00 00 00 movl $0x0,0x2c(%ebx)
* @param[in] starting_address is the starting address of the memory for
109d56: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx)
* the heap
109d5d: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx)
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
109d64: 8d 7b 54 lea 0x54(%ebx),%edi
109d67: b9 0e 00 00 00 mov $0xe,%ecx
109d6c: 31 c0 xor %eax,%eax
109d6e: f3 ab rep stos %eax,%es:(%edi)
109d70: c7 43 5c ff ff ff 7f movl $0x7fffffff,0x5c(%ebx)
109d77: c7 43 60 ff ff ff 7f movl $0x7fffffff,0x60(%ebx)
109d7e: c7 43 74 ff ff ff 7f movl $0x7fffffff,0x74(%ebx)
109d85: c7 43 78 ff ff ff 7f movl $0x7fffffff,0x78(%ebx)
109d8c: 8b 4b 08 mov 0x8(%ebx),%ecx
109d8f: 0f b7 d1 movzwl %cx,%edx
109d92: a1 a8 04 12 00 mov 0x1204a8,%eax
109d97: 89 1c 90 mov %ebx,(%eax,%edx,4)
109d9a: 89 73 0c mov %esi,0xc(%ebx)
&_Rate_monotonic_Information,
&the_period->Object,
(Objects_Name) name
);
*id = the_period->Object.id;
109d9d: 8b 45 0c mov 0xc(%ebp),%eax
109da0: 89 08 mov %ecx,(%eax)
_Thread_Enable_dispatch();
109da2: e8 3d 27 00 00 call 10c4e4 <_Thread_Enable_dispatch>
109da7: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
109da9: 8d 65 f4 lea -0xc(%ebp),%esp
109dac: 5b pop %ebx
109dad: 5e pop %esi
109dae: 5f pop %edi
109daf: c9 leave
109db0: c3 ret
0010ec64 <rtems_rate_monotonic_get_statistics>:
rtems_status_code rtems_rate_monotonic_get_statistics(
Objects_Id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
10ec64: 55 push %ebp
10ec65: 89 e5 mov %esp,%ebp
10ec67: 57 push %edi
10ec68: 56 push %esi
10ec69: 83 ec 20 sub $0x20,%esp
10ec6c: 8b 7d 0c mov 0xc(%ebp),%edi
Objects_Locations location;
Rate_monotonic_Control *the_period;
if ( !statistics )
10ec6f: b8 09 00 00 00 mov $0x9,%eax
10ec74: 85 ff test %edi,%edi
10ec76: 74 33 je 10ecab <rtems_rate_monotonic_get_statistics+0x47><== NEVER TAKEN
/**
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory
10ec78: 50 push %eax
10ec79: 8d 45 f4 lea -0xc(%ebp),%eax
10ec7c: 50 push %eax
10ec7d: ff 75 08 pushl 0x8(%ebp)
10ec80: 68 8c 04 12 00 push $0x12048c
10ec85: e8 9a d0 ff ff call 10bd24 <_Objects_Get>
10ec8a: 89 c2 mov %eax,%edx
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
10ec8c: 83 c4 10 add $0x10,%esp
10ec8f: b8 04 00 00 00 mov $0x4,%eax
10ec94: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10ec98: 75 11 jne 10ecab <rtems_rate_monotonic_get_statistics+0x47>
case OBJECTS_LOCAL:
*statistics = the_period->Statistics;
10ec9a: 8d 72 54 lea 0x54(%edx),%esi
10ec9d: b9 0e 00 00 00 mov $0xe,%ecx
10eca2: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Thread_Enable_dispatch();
10eca4: e8 3b d8 ff ff call 10c4e4 <_Thread_Enable_dispatch>
10eca9: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ecab: 8d 65 f8 lea -0x8(%ebp),%esp
10ecae: 5e pop %esi
10ecaf: 5f pop %edi
10ecb0: c9 leave
10ecb1: c3 ret
0010ecb4 <rtems_rate_monotonic_get_status>:
rtems_status_code rtems_rate_monotonic_get_status(
Objects_Id id,
rtems_rate_monotonic_period_status *status
)
{
10ecb4: 55 push %ebp
10ecb5: 89 e5 mov %esp,%ebp
10ecb7: 57 push %edi
10ecb8: 56 push %esi
10ecb9: 53 push %ebx
10ecba: 83 ec 1c sub $0x1c,%esp
10ecbd: 8b 75 0c mov 0xc(%ebp),%esi
Objects_Locations location;
Rate_monotonic_Control *the_period;
if ( !status )
10ecc0: b8 09 00 00 00 mov $0x9,%eax
10ecc5: 85 f6 test %esi,%esi
10ecc7: 0f 84 91 00 00 00 je 10ed5e <rtems_rate_monotonic_get_status+0xaa><== NEVER TAKEN
10eccd: 50 push %eax
10ecce: 8d 45 f0 lea -0x10(%ebp),%eax
10ecd1: 50 push %eax
10ecd2: ff 75 08 pushl 0x8(%ebp)
10ecd5: 68 8c 04 12 00 push $0x12048c
10ecda: e8 45 d0 ff ff call 10bd24 <_Objects_Get>
10ecdf: 89 c7 mov %eax,%edi
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
10ece1: 83 c4 10 add $0x10,%esp
10ece4: b8 04 00 00 00 mov $0x4,%eax
10ece9: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
10eced: 75 6f jne 10ed5e <rtems_rate_monotonic_get_status+0xaa>
case OBJECTS_LOCAL:
status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0);
10ecef: 8b 47 50 mov 0x50(%edi),%eax
10ecf2: 31 d2 xor %edx,%edx
10ecf4: 85 c0 test %eax,%eax
10ecf6: 74 03 je 10ecfb <rtems_rate_monotonic_get_status+0x47><== NEVER TAKEN
10ecf8: 8b 50 08 mov 0x8(%eax),%edx
10ecfb: 89 16 mov %edx,(%esi)
status->state = the_period->state;
10ecfd: 8b 47 38 mov 0x38(%edi),%eax
10ed00: 89 46 04 mov %eax,0x4(%esi)
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
10ed03: 85 c0 test %eax,%eax
10ed05: 75 1e jne 10ed25 <rtems_rate_monotonic_get_status+0x71>
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
status->since_last_period.tv_sec = 0;
10ed07: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi)
status->since_last_period.tv_nsec = 0;
10ed0e: 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;
10ed15: c7 46 10 00 00 00 00 movl $0x0,0x10(%esi)
status->executed_since_last_period.tv_nsec = 0;
10ed1c: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi)
10ed23: eb 32 jmp 10ed57 <rtems_rate_monotonic_get_status+0xa3>
* This lets them share one single invocation of _TOD_Get_uptime().
*/
#if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \
defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS)
struct timespec uptime;
_TOD_Get_uptime( &uptime );
10ed25: 83 ec 0c sub $0xc,%esp
10ed28: 8d 5d e8 lea -0x18(%ebp),%ebx
10ed2b: 53 push %ebx
10ed2c: e8 8b c7 ff ff call 10b4bc <_TOD_Get_uptime>
#endif
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
_Timespec_Subtract(
10ed31: 83 c4 0c add $0xc,%esp
10ed34: 8d 46 08 lea 0x8(%esi),%eax
10ed37: 50 push %eax
10ed38: 53 push %ebx
10ed39: 8d 47 44 lea 0x44(%edi),%eax
10ed3c: 50 push %eax
10ed3d: e8 ba e4 ff ff call 10d1fc <_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(
10ed42: 83 c4 0c add $0xc,%esp
10ed45: 8d 46 10 lea 0x10(%esi),%eax
10ed48: 50 push %eax
10ed49: 53 push %ebx
10ed4a: 68 4c 06 12 00 push $0x12064c
10ed4f: e8 a8 e4 ff ff call 10d1fc <_Timespec_Subtract>
10ed54: 83 c4 10 add $0x10,%esp
the_period->owner->cpu_time_used -
the_period->owner_executed_at_period;
#endif
}
_Thread_Enable_dispatch();
10ed57: e8 88 d7 ff ff call 10c4e4 <_Thread_Enable_dispatch>
10ed5c: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ed5e: 8d 65 f4 lea -0xc(%ebp),%esp
10ed61: 5b pop %ebx
10ed62: 5e pop %esi
10ed63: 5f pop %edi
10ed64: c9 leave
10ed65: c3 ret
00109f7e <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
Objects_Id id,
rtems_interval length
)
{
109f7e: 55 push %ebp
109f7f: 89 e5 mov %esp,%ebp
109f81: 57 push %edi
109f82: 56 push %esi
109f83: 53 push %ebx
109f84: 83 ec 20 sub $0x20,%esp
109f87: 8b 7d 0c mov 0xc(%ebp),%edi
/**
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory
109f8a: 8d 45 f0 lea -0x10(%ebp),%eax
109f8d: 50 push %eax
109f8e: ff 75 08 pushl 0x8(%ebp)
109f91: 68 8c 04 12 00 push $0x12048c
109f96: e8 89 1d 00 00 call 10bd24 <_Objects_Get>
109f9b: 89 c3 mov %eax,%ebx
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
109f9d: 83 c4 10 add $0x10,%esp
109fa0: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
109fa4: 0f 85 44 01 00 00 jne 10a0ee <rtems_rate_monotonic_period+0x170>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
109faa: 8b 40 50 mov 0x50(%eax),%eax
109fad: 3b 05 44 06 12 00 cmp 0x120644,%eax
109fb3: 74 0f je 109fc4 <rtems_rate_monotonic_period+0x46>
_Thread_Enable_dispatch();
109fb5: e8 2a 25 00 00 call 10c4e4 <_Thread_Enable_dispatch>
109fba: bb 17 00 00 00 mov $0x17,%ebx
109fbf: e9 2f 01 00 00 jmp 10a0f3 <rtems_rate_monotonic_period+0x175>
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
109fc4: 85 ff test %edi,%edi
109fc6: 75 21 jne 109fe9 <rtems_rate_monotonic_period+0x6b>
switch ( the_period->state ) {
109fc8: 8b 43 38 mov 0x38(%ebx),%eax
109fcb: bb 0b 00 00 00 mov $0xb,%ebx
109fd0: 85 c0 test %eax,%eax
109fd2: 74 0b je 109fdf <rtems_rate_monotonic_period+0x61>
109fd4: 83 e8 03 sub $0x3,%eax
109fd7: 83 f8 02 cmp $0x2,%eax
109fda: 19 db sbb %ebx,%ebx
109fdc: 83 e3 06 and $0x6,%ebx
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
109fdf: e8 00 25 00 00 call 10c4e4 <_Thread_Enable_dispatch>
109fe4: e9 0a 01 00 00 jmp 10a0f3 <rtems_rate_monotonic_period+0x175>
return( return_value );
}
_ISR_Disable( level );
109fe9: 9c pushf
109fea: fa cli
109feb: 5e pop %esi
switch ( the_period->state ) {
109fec: 8b 43 38 mov 0x38(%ebx),%eax
109fef: 83 f8 02 cmp $0x2,%eax
109ff2: 74 60 je 10a054 <rtems_rate_monotonic_period+0xd6>
109ff4: 83 f8 04 cmp $0x4,%eax
109ff7: 0f 84 ba 00 00 00 je 10a0b7 <rtems_rate_monotonic_period+0x139>
109ffd: 85 c0 test %eax,%eax
109fff: 0f 85 e9 00 00 00 jne 10a0ee <rtems_rate_monotonic_period+0x170><== NEVER TAKEN
case RATE_MONOTONIC_INACTIVE: {
_ISR_Enable( level );
10a005: 56 push %esi
10a006: 9d popf
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
10a007: 83 ec 0c sub $0xc,%esp
10a00a: 53 push %ebx
10a00b: e8 c8 fd ff ff call 109dd8 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
10a010: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx)
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
10a017: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
* @param[in] the_heap is the heap to operate upon
10a01e: c7 43 2c 14 a3 10 00 movl $0x10a314,0x2c(%ebx)
* @param[in] starting_address is the starting address of the memory for
10a025: 8b 45 08 mov 0x8(%ebp),%eax
10a028: 89 43 30 mov %eax,0x30(%ebx)
* the heap
10a02b: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx)
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
10a032: 89 7b 4c mov %edi,0x4c(%ebx)
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
Heap_Control *the_heap,
10a035: 89 7b 1c mov %edi,0x1c(%ebx)
void *starting_address,
size_t *size
10a038: 58 pop %eax
10a039: 5a pop %edx
10a03a: 8d 43 10 lea 0x10(%ebx),%eax
10a03d: 50 push %eax
10a03e: 68 64 06 12 00 push $0x120664
10a043: e8 f8 33 00 00 call 10d440 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
10a048: e8 97 24 00 00 call 10c4e4 <_Thread_Enable_dispatch>
10a04d: 31 db xor %ebx,%ebx
10a04f: e9 95 00 00 00 jmp 10a0e9 <rtems_rate_monotonic_period+0x16b>
case RATE_MONOTONIC_ACTIVE:
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
10a054: 83 ec 0c sub $0xc,%esp
10a057: 53 push %ebx
10a058: e8 e3 fd ff ff call 109e40 <_Rate_monotonic_Update_statistics>
/*
* This tells the _Rate_monotonic_Timeout that this task is
* in the process of blocking on the period and that we
* may be changing the length of the next period.
*/
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
10a05d: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx)
the_period->next_length = length;
10a064: 89 7b 4c mov %edi,0x4c(%ebx)
_ISR_Enable( level );
10a067: 56 push %esi
10a068: 9d popf
_Thread_Executing->Wait.id = the_period->Object.id;
10a069: 8b 15 44 06 12 00 mov 0x120644,%edx
10a06f: 8b 43 08 mov 0x8(%ebx),%eax
10a072: 89 42 20 mov %eax,0x20(%edx)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10a075: 5e pop %esi
10a076: 5f pop %edi
10a077: 68 00 40 00 00 push $0x4000
10a07c: 52 push %edx
10a07d: e8 7e 2c 00 00 call 10cd00 <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
10a082: 9c pushf
10a083: fa cli
10a084: 58 pop %eax
local_state = the_period->state;
10a085: 8b 53 38 mov 0x38(%ebx),%edx
the_period->state = RATE_MONOTONIC_ACTIVE;
10a088: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx)
_ISR_Enable( level );
10a08f: 50 push %eax
10a090: 9d popf
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
10a091: 83 c4 10 add $0x10,%esp
10a094: 83 fa 03 cmp $0x3,%edx
10a097: 75 15 jne 10a0ae <rtems_rate_monotonic_period+0x130><== ALWAYS TAKEN
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10a099: 51 push %ecx <== NOT EXECUTED
10a09a: 51 push %ecx <== NOT EXECUTED
10a09b: 68 00 40 00 00 push $0x4000 <== NOT EXECUTED
10a0a0: ff 35 44 06 12 00 pushl 0x120644 <== NOT EXECUTED
10a0a6: e8 b9 20 00 00 call 10c164 <_Thread_Clear_state> <== NOT EXECUTED
10a0ab: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
_Thread_Enable_dispatch();
10a0ae: e8 31 24 00 00 call 10c4e4 <_Thread_Enable_dispatch>
10a0b3: 31 db xor %ebx,%ebx
10a0b5: eb 3c jmp 10a0f3 <rtems_rate_monotonic_period+0x175>
case RATE_MONOTONIC_EXPIRED:
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
10a0b7: 83 ec 0c sub $0xc,%esp
10a0ba: 53 push %ebx
10a0bb: e8 80 fd ff ff call 109e40 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
10a0c0: 56 push %esi
10a0c1: 9d popf
the_period->state = RATE_MONOTONIC_ACTIVE;
10a0c2: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx)
the_period->next_length = length;
10a0c9: 89 7b 4c mov %edi,0x4c(%ebx)
* @param[in] size points to a user area to return the size in
* @return TRUE if successfully able to determine the size, FALSE otherwise
* @return *size filled in with the size of the user area for this block
*/
bool _Protected_heap_Get_block_size(
Heap_Control *the_heap,
10a0cc: 89 7b 1c mov %edi,0x1c(%ebx)
void *starting_address,
size_t *size
10a0cf: 58 pop %eax
10a0d0: 5a pop %edx
10a0d1: 8d 43 10 lea 0x10(%ebx),%eax
10a0d4: 50 push %eax
10a0d5: 68 64 06 12 00 push $0x120664
10a0da: e8 61 33 00 00 call 10d440 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
10a0df: e8 00 24 00 00 call 10c4e4 <_Thread_Enable_dispatch>
10a0e4: bb 06 00 00 00 mov $0x6,%ebx
10a0e9: 83 c4 10 add $0x10,%esp
10a0ec: eb 05 jmp 10a0f3 <rtems_rate_monotonic_period+0x175>
return RTEMS_TIMEOUT;
10a0ee: bb 04 00 00 00 mov $0x4,%ebx
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a0f3: 89 d8 mov %ebx,%eax
10a0f5: 8d 65 f4 lea -0xc(%ebp),%esp
10a0f8: 5b pop %ebx
10a0f9: 5e pop %esi
10a0fa: 5f pop %edi
10a0fb: c9 leave
10a0fc: c3 ret
0010a100 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
10a100: 55 push %ebp
10a101: 89 e5 mov %esp,%ebp
10a103: 57 push %edi
10a104: 56 push %esi
10a105: 53 push %ebx
10a106: 83 ec 6c sub $0x6c,%esp
10a109: 8b 75 0c mov 0xc(%ebp),%esi
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
10a10c: 85 f6 test %esi,%esi
10a10e: 0f 84 44 01 00 00 je 10a258 <rtems_rate_monotonic_report_statistics_with_plugin+0x158><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
10a114: 51 push %ecx
10a115: 51 push %ecx
10a116: 68 a4 9b 11 00 push $0x119ba4
10a11b: ff 75 08 pushl 0x8(%ebp)
10a11e: ff d6 call *%esi
#if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS)
(*print)( context, "--- CPU times are in seconds ---\n" );
10a120: 58 pop %eax
10a121: 5a pop %edx
10a122: 68 c2 9b 11 00 push $0x119bc2
10a127: ff 75 08 pushl 0x8(%ebp)
10a12a: ff d6 call *%esi
#endif
#if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS)
(*print)( context, "--- Wall times are in seconds ---\n" );
10a12c: 5f pop %edi
10a12d: 58 pop %eax
10a12e: 68 e4 9b 11 00 push $0x119be4
10a133: ff 75 08 pushl 0x8(%ebp)
10a136: ff d6 call *%esi
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
10a138: 59 pop %ecx
10a139: 5b pop %ebx
10a13a: 68 07 9c 11 00 push $0x119c07
10a13f: ff 75 08 pushl 0x8(%ebp)
10a142: ff d6 call *%esi
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
10a144: 58 pop %eax
10a145: 5a pop %edx
10a146: 68 52 9c 11 00 push $0x119c52
10a14b: ff 75 08 pushl 0x8(%ebp)
10a14e: ff d6 call *%esi
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10a150: 8b 3d 94 04 12 00 mov 0x120494,%edi
10a156: 83 c4 10 add $0x10,%esp
10a159: e9 ee 00 00 00 jmp 10a24c <rtems_rate_monotonic_report_statistics_with_plugin+0x14c>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
10a15e: 50 push %eax
10a15f: 50 push %eax
10a160: 8d 45 94 lea -0x6c(%ebp),%eax
10a163: 50 push %eax
10a164: 57 push %edi
10a165: e8 fa 4a 00 00 call 10ec64 <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
10a16a: 83 c4 10 add $0x10,%esp
10a16d: 85 c0 test %eax,%eax
10a16f: 0f 85 d6 00 00 00 jne 10a24b <rtems_rate_monotonic_report_statistics_with_plugin+0x14b>
continue;
/* If the above passed, so should this but check it anyway */
status = rtems_rate_monotonic_get_status( id, &the_status );
10a175: 50 push %eax
10a176: 50 push %eax
10a177: 8d 55 cc lea -0x34(%ebp),%edx
10a17a: 52 push %edx
10a17b: 57 push %edi
10a17c: e8 33 4b 00 00 call 10ecb4 <rtems_rate_monotonic_get_status>
#if defined(RTEMS_DEBUG)
if ( status != RTEMS_SUCCESSFUL )
continue;
#endif
name[ 0 ] = '\0';
10a181: c6 45 ef 00 movb $0x0,-0x11(%ebp)
if ( the_status.owner ) {
10a185: 8b 55 cc mov -0x34(%ebp),%edx
10a188: 83 c4 10 add $0x10,%esp
10a18b: 85 d2 test %edx,%edx
10a18d: 74 10 je 10a19f <rtems_rate_monotonic_report_statistics_with_plugin+0x9f><== NEVER TAKEN
rtems_object_get_name( the_status.owner, sizeof(name), name );
10a18f: 50 push %eax
10a190: 8d 45 ef lea -0x11(%ebp),%eax
10a193: 50 push %eax
10a194: 6a 05 push $0x5
10a196: 52 push %edx
10a197: e8 04 02 00 00 call 10a3a0 <rtems_object_get_name>
10a19c: 83 c4 10 add $0x10,%esp
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
10a19f: 53 push %ebx
10a1a0: 53 push %ebx
10a1a1: ff 75 98 pushl -0x68(%ebp)
10a1a4: ff 75 94 pushl -0x6c(%ebp)
10a1a7: 8d 45 ef lea -0x11(%ebp),%eax
10a1aa: 50 push %eax
10a1ab: 57 push %edi
10a1ac: 68 9e 9c 11 00 push $0x119c9e
10a1b1: ff 75 08 pushl 0x8(%ebp)
10a1b4: ff d6 call *%esi
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
10a1b6: 8b 45 94 mov -0x6c(%ebp),%eax
10a1b9: 83 c4 20 add $0x20,%esp
10a1bc: 85 c0 test %eax,%eax
10a1be: 75 11 jne 10a1d1 <rtems_rate_monotonic_report_statistics_with_plugin+0xd1>
(*print)( context, "\n" );
10a1c0: 51 push %ecx
10a1c1: 51 push %ecx
10a1c2: 68 1d 9f 11 00 push $0x119f1d
10a1c7: ff 75 08 pushl 0x8(%ebp)
10a1ca: ff d6 call *%esi
10a1cc: 83 c4 10 add $0x10,%esp
10a1cf: eb 7a jmp 10a24b <rtems_rate_monotonic_report_statistics_with_plugin+0x14b>
*/
{
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
struct timespec cpu_average;
_Timespec_Divide_by_integer(
10a1d1: 52 push %edx
10a1d2: 8d 55 e4 lea -0x1c(%ebp),%edx
10a1d5: 52 push %edx
10a1d6: 50 push %eax
10a1d7: 8d 45 ac lea -0x54(%ebp),%eax
10a1da: 50 push %eax
10a1db: e8 58 2f 00 00 call 10d138 <_Timespec_Divide_by_integer>
&the_stats.total_cpu_time,
the_stats.count,
&cpu_average
);
(*print)( context,
10a1e0: 8b 45 e8 mov -0x18(%ebp),%eax
10a1e3: bb e8 03 00 00 mov $0x3e8,%ebx
10a1e8: 99 cltd
10a1e9: f7 fb idiv %ebx
10a1eb: 50 push %eax
10a1ec: ff 75 e4 pushl -0x1c(%ebp)
10a1ef: 8b 45 a8 mov -0x58(%ebp),%eax
10a1f2: 99 cltd
10a1f3: f7 fb idiv %ebx
10a1f5: 50 push %eax
10a1f6: ff 75 a4 pushl -0x5c(%ebp)
10a1f9: 8b 45 a0 mov -0x60(%ebp),%eax
10a1fc: 99 cltd
10a1fd: f7 fb idiv %ebx
10a1ff: 50 push %eax
10a200: ff 75 9c pushl -0x64(%ebp)
10a203: 68 b5 9c 11 00 push $0x119cb5
10a208: ff 75 08 pushl 0x8(%ebp)
10a20b: ff d6 call *%esi
* print Wall time part of statistics
*/
{
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
struct timespec wall_average;
_Timespec_Divide_by_integer(
10a20d: 83 c4 2c add $0x2c,%esp
10a210: 8d 45 e4 lea -0x1c(%ebp),%eax
10a213: 50 push %eax
10a214: ff 75 94 pushl -0x6c(%ebp)
10a217: 8d 45 c4 lea -0x3c(%ebp),%eax
10a21a: 50 push %eax
10a21b: e8 18 2f 00 00 call 10d138 <_Timespec_Divide_by_integer>
&the_stats.total_wall_time,
the_stats.count,
&wall_average
);
(*print)( context,
10a220: 8b 45 e8 mov -0x18(%ebp),%eax
10a223: 99 cltd
10a224: f7 fb idiv %ebx
10a226: 50 push %eax
10a227: ff 75 e4 pushl -0x1c(%ebp)
10a22a: 8b 45 c0 mov -0x40(%ebp),%eax
10a22d: 99 cltd
10a22e: f7 fb idiv %ebx
10a230: 50 push %eax
10a231: ff 75 bc pushl -0x44(%ebp)
10a234: 8b 45 b8 mov -0x48(%ebp),%eax
10a237: 99 cltd
10a238: f7 fb idiv %ebx
10a23a: 50 push %eax
10a23b: ff 75 b4 pushl -0x4c(%ebp)
10a23e: 68 d4 9c 11 00 push $0x119cd4
10a243: ff 75 08 pushl 0x8(%ebp)
10a246: ff d6 call *%esi
10a248: 83 c4 30 add $0x30,%esp
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
10a24b: 47 inc %edi
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
10a24c: 3b 3d 98 04 12 00 cmp 0x120498,%edi
10a252: 0f 86 06 ff ff ff jbe 10a15e <rtems_rate_monotonic_report_statistics_with_plugin+0x5e>
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
10a258: 8d 65 f4 lea -0xc(%ebp),%esp
10a25b: 5b pop %ebx
10a25c: 5e pop %esi
10a25d: 5f pop %edi
10a25e: c9 leave
10a25f: c3 ret
00111ac0 <rtems_region_extend>:
rtems_status_code rtems_region_extend(
Objects_Id id,
void *starting_address,
uint32_t length
)
{
111ac0: 55 push %ebp
111ac1: 89 e5 mov %esp,%ebp
111ac3: 57 push %edi
111ac4: 56 push %esi
111ac5: 53 push %ebx
111ac6: 83 ec 1c sub $0x1c,%esp
111ac9: 8b 7d 0c mov 0xc(%ebp),%edi
Heap_Extend_status heap_status;
Objects_Locations location;
rtems_status_code return_status = RTEMS_INTERNAL_ERROR;
Region_Control *the_region;
if ( !starting_address )
111acc: bb 09 00 00 00 mov $0x9,%ebx
111ad1: 85 ff test %edi,%edi
111ad3: 0f 84 82 00 00 00 je 111b5b <rtems_region_extend+0x9b><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
111ad9: 83 ec 0c sub $0xc,%esp
111adc: ff 35 98 28 13 00 pushl 0x132898
111ae2: e8 89 1e 00 00 call 113970 <_API_Mutex_Lock>
/**
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
111ae7: 83 c4 0c add $0xc,%esp
111aea: 8d 45 ec lea -0x14(%ebp),%eax
111aed: 50 push %eax
111aee: ff 75 08 pushl 0x8(%ebp)
111af1: 68 94 26 13 00 push $0x132694
111af6: e8 21 34 00 00 call 114f1c <_Objects_Get_no_protection>
111afb: 89 c6 mov %eax,%esi
the_region = _Region_Get( id, &location );
switch ( location ) {
111afd: 83 c4 10 add $0x10,%esp
111b00: 8b 45 ec mov -0x14(%ebp),%eax
111b03: 85 c0 test %eax,%eax
111b05: 74 08 je 111b0f <rtems_region_extend+0x4f>
111b07: bb 04 00 00 00 mov $0x4,%ebx
111b0c: 48 dec %eax
111b0d: eb 25 jmp 111b34 <rtems_region_extend+0x74>
case OBJECTS_LOCAL:
heap_status = _Heap_Extend(
111b0f: 8d 45 f0 lea -0x10(%ebp),%eax
111b12: 50 push %eax
111b13: ff 75 10 pushl 0x10(%ebp)
111b16: 57 push %edi
111b17: 8d 46 68 lea 0x68(%esi),%eax
111b1a: 50 push %eax
111b1b: e8 4c 28 00 00 call 11436c <_Heap_Extend>
starting_address,
length,
&amount_extended
);
switch ( heap_status ) {
111b20: 83 c4 10 add $0x10,%esp
111b23: bb 09 00 00 00 mov $0x9,%ebx
111b28: 83 f8 01 cmp $0x1,%eax
111b2b: 74 1d je 111b4a <rtems_region_extend+0x8a>
111b2d: 72 09 jb 111b38 <rtems_region_extend+0x78>
case HEAP_EXTEND_SUCCESSFUL:
the_region->length += amount_extended;
the_region->maximum_segment_size += amount_extended;
return_status = RTEMS_SUCCESSFUL;
break;
111b2f: b3 18 mov $0x18,%bl
starting_address,
length,
&amount_extended
);
switch ( heap_status ) {
111b31: 83 f8 02 cmp $0x2,%eax
111b34: 75 0f jne 111b45 <rtems_region_extend+0x85><== NEVER TAKEN
111b36: eb 12 jmp 111b4a <rtems_region_extend+0x8a>
case HEAP_EXTEND_SUCCESSFUL:
the_region->length += amount_extended;
111b38: 8b 45 f0 mov -0x10(%ebp),%eax
111b3b: 01 46 54 add %eax,0x54(%esi)
the_region->maximum_segment_size += amount_extended;
111b3e: 01 46 5c add %eax,0x5c(%esi)
111b41: 31 db xor %ebx,%ebx
111b43: eb 05 jmp 111b4a <rtems_region_extend+0x8a>
return_status = RTEMS_SUCCESSFUL;
break;
111b45: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
111b4a: 83 ec 0c sub $0xc,%esp
111b4d: ff 35 98 28 13 00 pushl 0x132898
111b53: e8 60 1e 00 00 call 1139b8 <_API_Mutex_Unlock>
111b58: 83 c4 10 add $0x10,%esp
return return_status;
}
111b5b: 89 d8 mov %ebx,%eax
111b5d: 8d 65 f4 lea -0xc(%ebp),%esp
111b60: 5b pop %ebx
111b61: 5e pop %esi
111b62: 5f pop %edi
111b63: c9 leave
111b64: c3 ret
00111c80 <rtems_region_get_segment>:
uint32_t size,
rtems_option option_set,
rtems_interval timeout,
void **segment
)
{
111c80: 55 push %ebp
111c81: 89 e5 mov %esp,%ebp
111c83: 57 push %edi
111c84: 56 push %esi
111c85: 53 push %ebx
111c86: 83 ec 1c sub $0x1c,%esp
Objects_Locations location;
rtems_status_code return_status = RTEMS_INTERNAL_ERROR;
register Region_Control *the_region;
void *the_segment;
if ( !segment )
111c89: bb 09 00 00 00 mov $0x9,%ebx
111c8e: 83 7d 18 00 cmpl $0x0,0x18(%ebp)
111c92: 0f 84 fd 00 00 00 je 111d95 <rtems_region_get_segment+0x115><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
*segment = NULL;
111c98: 8b 45 18 mov 0x18(%ebp),%eax
111c9b: c7 00 00 00 00 00 movl $0x0,(%eax)
if ( size == 0 )
111ca1: bb 08 00 00 00 mov $0x8,%ebx
111ca6: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
111caa: 0f 84 e5 00 00 00 je 111d95 <rtems_region_get_segment+0x115><== NEVER TAKEN
return RTEMS_INVALID_SIZE;
_RTEMS_Lock_allocator();
111cb0: 83 ec 0c sub $0xc,%esp
111cb3: ff 35 98 28 13 00 pushl 0x132898
111cb9: e8 b2 1c 00 00 call 113970 <_API_Mutex_Lock>
executing = _Thread_Executing;
111cbe: 8b 3d a0 28 13 00 mov 0x1328a0,%edi
111cc4: 83 c4 0c add $0xc,%esp
111cc7: 8d 45 f0 lea -0x10(%ebp),%eax
111cca: 50 push %eax
111ccb: ff 75 08 pushl 0x8(%ebp)
111cce: 68 94 26 13 00 push $0x132694
111cd3: e8 44 32 00 00 call 114f1c <_Objects_Get_no_protection>
111cd8: 89 c6 mov %eax,%esi
the_region = _Region_Get( id, &location );
switch ( location ) {
111cda: 83 c4 10 add $0x10,%esp
111cdd: 8b 45 f0 mov -0x10(%ebp),%eax
111ce0: 85 c0 test %eax,%eax
111ce2: 74 14 je 111cf8 <rtems_region_get_segment+0x78>
111ce4: 31 db xor %ebx,%ebx
111ce6: 83 f8 01 cmp $0x1,%eax
111ce9: 0f 95 c3 setne %bl
111cec: 4b dec %ebx
111ced: 83 e3 eb and $0xffffffeb,%ebx
111cf0: 83 c3 19 add $0x19,%ebx
111cf3: e9 8c 00 00 00 jmp 111d84 <rtems_region_get_segment+0x104>
case OBJECTS_LOCAL:
if ( size > the_region->maximum_segment_size )
111cf8: bb 08 00 00 00 mov $0x8,%ebx
111cfd: 8b 55 0c mov 0xc(%ebp),%edx
111d00: 3b 56 5c cmp 0x5c(%esi),%edx
111d03: 77 7f ja 111d84 <rtems_region_get_segment+0x104>
/**
* This function attempts to allocate a block of @a size bytes from
* @a the_heap. If insufficient memory is free in @a the_heap to allocate
* a block of the requested size, then NULL is returned.
*
111d05: 50 push %eax
111d06: 50 push %eax
111d07: ff 75 0c pushl 0xc(%ebp)
111d0a: 8d 46 68 lea 0x68(%esi),%eax
111d0d: 50 push %eax
111d0e: e8 ed 25 00 00 call 114300 <_Heap_Allocate>
the_segment = _Region_Allocate_segment( the_region, size );
_Region_Debug_Walk( the_region, 2 );
if ( the_segment ) {
111d13: 83 c4 10 add $0x10,%esp
111d16: 85 c0 test %eax,%eax
111d18: 74 0c je 111d26 <rtems_region_get_segment+0xa6>
the_region->number_of_used_blocks += 1;
111d1a: ff 46 64 incl 0x64(%esi)
*segment = the_segment;
111d1d: 8b 55 18 mov 0x18(%ebp),%edx
111d20: 89 02 mov %eax,(%edx)
111d22: 31 db xor %ebx,%ebx
111d24: eb 5e jmp 111d84 <rtems_region_get_segment+0x104>
return_status = RTEMS_SUCCESSFUL;
}
else if ( _Options_Is_no_wait( option_set ) ) {
111d26: bb 0d 00 00 00 mov $0xd,%ebx
111d2b: f6 45 10 01 testb $0x1,0x10(%ebp)
111d2f: 75 53 jne 111d84 <rtems_region_get_segment+0x104>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
111d31: a1 e0 27 13 00 mov 0x1327e0,%eax
111d36: 40 inc %eax
111d37: a3 e0 27 13 00 mov %eax,0x1327e0
* Switch from using the memory allocation mutex to using a
* dispatching disabled critical section. We have to do this
* because this thread is going to block.
*/
_Thread_Disable_dispatch();
_RTEMS_Unlock_allocator();
111d3c: 83 ec 0c sub $0xc,%esp
111d3f: ff 35 98 28 13 00 pushl 0x132898
111d45: e8 6e 1c 00 00 call 1139b8 <_API_Mutex_Unlock>
executing->Wait.queue = &the_region->Wait_queue;
111d4a: 8d 46 10 lea 0x10(%esi),%eax
111d4d: 89 47 44 mov %eax,0x44(%edi)
executing->Wait.id = id;
111d50: 8b 55 08 mov 0x8(%ebp),%edx
111d53: 89 57 20 mov %edx,0x20(%edi)
executing->Wait.count = size;
111d56: 8b 55 0c mov 0xc(%ebp),%edx
111d59: 89 57 24 mov %edx,0x24(%edi)
executing->Wait.return_argument = segment;
111d5c: 8b 55 18 mov 0x18(%ebp),%edx
111d5f: 89 57 28 mov %edx,0x28(%edi)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
/**
* This routine grows @a the_heap memory area using the size bytes which
111d62: c7 46 40 01 00 00 00 movl $0x1,0x40(%esi)
_Thread_queue_Enter_critical_section( &the_region->Wait_queue );
_Thread_queue_Enqueue( &the_region->Wait_queue, timeout );
111d69: 83 c4 0c add $0xc,%esp
111d6c: 68 6c 5e 11 00 push $0x115e6c
111d71: ff 75 14 pushl 0x14(%ebp)
111d74: 50 push %eax
111d75: e8 ee 3d 00 00 call 115b68 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
111d7a: e8 99 39 00 00 call 115718 <_Thread_Enable_dispatch>
return (rtems_status_code) executing->Wait.return_code;
111d7f: 8b 5f 34 mov 0x34(%edi),%ebx
111d82: eb 0e jmp 111d92 <rtems_region_get_segment+0x112>
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
111d84: 83 ec 0c sub $0xc,%esp
111d87: ff 35 98 28 13 00 pushl 0x132898
111d8d: e8 26 1c 00 00 call 1139b8 <_API_Mutex_Unlock>
111d92: 83 c4 10 add $0x10,%esp
return return_status;
}
111d95: 89 d8 mov %ebx,%eax
111d97: 8d 65 f4 lea -0xc(%ebp),%esp
111d9a: 5b pop %ebx
111d9b: 5e pop %esi
111d9c: 5f pop %edi
111d9d: c9 leave
111d9e: c3 ret
00111e50 <rtems_region_resize_segment>:
Objects_Id id,
void *segment,
size_t size,
size_t *old_size
)
{
111e50: 55 push %ebp
111e51: 89 e5 mov %esp,%ebp
111e53: 57 push %edi
111e54: 56 push %esi
111e55: 53 push %ebx
111e56: 83 ec 1c sub $0x1c,%esp
111e59: 8b 7d 14 mov 0x14(%ebp),%edi
uint32_t osize;
rtems_status_code return_status = RTEMS_INTERNAL_ERROR;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
111e5c: 85 ff test %edi,%edi
111e5e: 0f 84 aa 00 00 00 je 111f0e <rtems_region_resize_segment+0xbe>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
111e64: 83 ec 0c sub $0xc,%esp
111e67: ff 35 98 28 13 00 pushl 0x132898
111e6d: e8 fe 1a 00 00 call 113970 <_API_Mutex_Lock>
111e72: 83 c4 0c add $0xc,%esp
111e75: 8d 45 ec lea -0x14(%ebp),%eax
111e78: 50 push %eax
111e79: ff 75 08 pushl 0x8(%ebp)
111e7c: 68 94 26 13 00 push $0x132694
111e81: e8 96 30 00 00 call 114f1c <_Objects_Get_no_protection>
111e86: 89 c3 mov %eax,%ebx
the_region = _Region_Get( id, &location );
switch ( location ) {
111e88: 83 c4 10 add $0x10,%esp
111e8b: 8b 45 ec mov -0x14(%ebp),%eax
111e8e: 85 c0 test %eax,%eax
111e90: 74 1f je 111eb1 <rtems_region_resize_segment+0x61>
111e92: 31 db xor %ebx,%ebx
111e94: 83 f8 01 cmp $0x1,%eax
111e97: 0f 95 c3 setne %bl
111e9a: 4b dec %ebx
111e9b: 83 e3 eb and $0xffffffeb,%ebx
111e9e: 83 c3 19 add $0x19,%ebx
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
111ea1: 83 ec 0c sub $0xc,%esp
111ea4: ff 35 98 28 13 00 pushl 0x132898
111eaa: e8 09 1b 00 00 call 1139b8 <_API_Mutex_Unlock>
111eaf: eb 39 jmp 111eea <rtems_region_resize_segment+0x9a>
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 7 );
status = _Heap_Resize_block(
111eb1: 83 ec 0c sub $0xc,%esp
111eb4: 8d 45 f0 lea -0x10(%ebp),%eax
111eb7: 50 push %eax
111eb8: 8d 45 e8 lea -0x18(%ebp),%eax
111ebb: 50 push %eax
111ebc: ff 75 10 pushl 0x10(%ebp)
111ebf: ff 75 0c pushl 0xc(%ebp)
111ec2: 8d 43 68 lea 0x68(%ebx),%eax
111ec5: 50 push %eax
111ec6: e8 19 29 00 00 call 1147e4 <_Heap_Resize_block>
111ecb: 89 c6 mov %eax,%esi
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
111ecd: 8b 45 e8 mov -0x18(%ebp),%eax
111ed0: 89 07 mov %eax,(%edi)
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 )
111ed2: 83 c4 20 add $0x20,%esp
111ed5: 85 f6 test %esi,%esi
111ed7: 75 16 jne 111eef <rtems_region_resize_segment+0x9f><== ALWAYS TAKEN
111ed9: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED
111edd: 74 10 je 111eef <rtems_region_resize_segment+0x9f><== NOT EXECUTED
_Region_Process_queue( the_region ); /* unlocks allocator */
111edf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
111ee2: 53 push %ebx <== NOT EXECUTED
111ee3: e8 b8 61 00 00 call 1180a0 <_Region_Process_queue> <== NOT EXECUTED
111ee8: 31 db xor %ebx,%ebx <== NOT EXECUTED
111eea: 83 c4 10 add $0x10,%esp
111eed: eb 24 jmp 111f13 <rtems_region_resize_segment+0xc3>
else
_RTEMS_Unlock_allocator();
111eef: 83 ec 0c sub $0xc,%esp
111ef2: ff 35 98 28 13 00 pushl 0x132898
111ef8: e8 bb 1a 00 00 call 1139b8 <_API_Mutex_Unlock>
return
111efd: 83 c4 10 add $0x10,%esp
111f00: 31 db xor %ebx,%ebx
111f02: 85 f6 test %esi,%esi
111f04: 74 0d je 111f13 <rtems_region_resize_segment+0xc3><== NEVER TAKEN
111f06: bb 0d 00 00 00 mov $0xd,%ebx
111f0b: 4e dec %esi
111f0c: 74 05 je 111f13 <rtems_region_resize_segment+0xc3><== NEVER TAKEN
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
return return_status;
111f0e: bb 09 00 00 00 mov $0x9,%ebx
}
111f13: 89 d8 mov %ebx,%eax
111f15: 8d 65 f4 lea -0xc(%ebp),%esp
111f18: 5b pop %ebx
111f19: 5e pop %esi
111f1a: 5f pop %edi
111f1b: c9 leave
111f1c: c3 ret
00108f40 <rtems_semaphore_create>:
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
108f40: 55 push %ebp
108f41: 89 e5 mov %esp,%ebp
108f43: 57 push %edi
108f44: 56 push %esi
108f45: 53 push %ebx
108f46: 83 ec 2c sub $0x2c,%esp
108f49: 8b 5d 10 mov 0x10(%ebp),%ebx
register Semaphore_Control *the_semaphore;
CORE_mutex_Attributes the_mutex_attributes;
CORE_semaphore_Attributes the_semaphore_attributes;
if ( !rtems_is_name_valid( name ) )
108f4c: b8 03 00 00 00 mov $0x3,%eax
108f51: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
108f55: 0f 84 7f 01 00 00 je 1090da <rtems_semaphore_create+0x19a><== NEVER TAKEN
return RTEMS_INVALID_NAME;
if ( !id )
108f5b: b8 09 00 00 00 mov $0x9,%eax
108f60: 83 7d 18 00 cmpl $0x0,0x18(%ebp)
108f64: 0f 84 70 01 00 00 je 1090da <rtems_semaphore_create+0x19a><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
} else
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
108f6a: 89 da mov %ebx,%edx
108f6c: 81 e2 c0 00 00 00 and $0xc0,%edx
108f72: 74 28 je 108f9c <rtems_semaphore_create+0x5c>
* @param[in] alignment the required alignment
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
108f74: 89 d8 mov %ebx,%eax
108f76: 83 e0 30 and $0x30,%eax
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) ||
108f79: 83 f8 10 cmp $0x10,%eax
108f7c: 74 09 je 108f87 <rtems_semaphore_create+0x47>
108f7e: 83 f8 20 cmp $0x20,%eax
108f81: 0f 85 4e 01 00 00 jne 1090d5 <rtems_semaphore_create+0x195><== NEVER TAKEN
108f87: f6 c3 04 test $0x4,%bl
108f8a: 0f 84 45 01 00 00 je 1090d5 <rtems_semaphore_create+0x195><== NEVER TAKEN
_Attributes_Is_priority( attribute_set ) ) )
return RTEMS_NOT_DEFINED;
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
108f90: 81 fa c0 00 00 00 cmp $0xc0,%edx
108f96: 0f 84 39 01 00 00 je 1090d5 <rtems_semaphore_create+0x195>
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
108f9c: 89 df mov %ebx,%edi
108f9e: 83 e7 30 and $0x30,%edi
108fa1: 74 0f je 108fb2 <rtems_semaphore_create+0x72>
108fa3: b8 0a 00 00 00 mov $0xa,%eax
108fa8: 83 7d 0c 01 cmpl $0x1,0xc(%ebp)
108fac: 0f 87 28 01 00 00 ja 1090da <rtems_semaphore_create+0x19a>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
108fb2: a1 e0 ca 11 00 mov 0x11cae0,%eax
108fb7: 40 inc %eax
108fb8: a3 e0 ca 11 00 mov %eax,0x11cae0
#ifdef __cplusplus
extern "C" {
#endif
/**
108fbd: 83 ec 0c sub $0xc,%esp
108fc0: 68 28 ca 11 00 push $0x11ca28
108fc5: e8 1e 12 00 00 call 10a1e8 <_Objects_Allocate>
108fca: 89 c6 mov %eax,%esi
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
108fcc: 83 c4 10 add $0x10,%esp
108fcf: 85 c0 test %eax,%eax
108fd1: 75 0f jne 108fe2 <rtems_semaphore_create+0xa2>
_Thread_Enable_dispatch();
108fd3: e8 14 1e 00 00 call 10adec <_Thread_Enable_dispatch>
108fd8: b8 05 00 00 00 mov $0x5,%eax
108fdd: e9 f8 00 00 00 jmp 1090da <rtems_semaphore_create+0x19a>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_semaphore->attribute_set = attribute_set;
108fe2: 89 58 10 mov %ebx,0x10(%eax)
* If it is not a counting semaphore, then it is either a
* simple binary semaphore or a more powerful mutex style binary
* semaphore.
*/
if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
108fe5: 85 ff test %edi,%edi
108fe7: 0f 84 92 00 00 00 je 10907f <rtems_semaphore_create+0x13f>
CORE_mutex_Status mutex_status;
if ( _Attributes_Is_inherit_priority( attribute_set ) )
108fed: f6 c3 40 test $0x40,%bl
108ff0: 74 09 je 108ffb <rtems_semaphore_create+0xbb>
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
108ff2: c7 45 e4 02 00 00 00 movl $0x2,-0x1c(%ebp)
108ff9: eb 18 jmp 109013 <rtems_semaphore_create+0xd3>
else if ( _Attributes_Is_priority_ceiling( attribute_set ) )
108ffb: 84 db test %bl,%bl
108ffd: 79 09 jns 109008 <rtems_semaphore_create+0xc8>
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
108fff: c7 45 e4 03 00 00 00 movl $0x3,-0x1c(%ebp)
109006: eb 0b jmp 109013 <rtems_semaphore_create+0xd3>
else if ( _Attributes_Is_priority( attribute_set ) )
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
109008: 31 c0 xor %eax,%eax
10900a: f6 c3 04 test $0x4,%bl
10900d: 0f 95 c0 setne %al
109010: 89 45 e4 mov %eax,-0x1c(%ebp)
else
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
109013: 83 ff 10 cmp $0x10,%edi
109016: 75 1a jne 109032 <rtems_semaphore_create+0xf2>
the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
109018: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
switch ( the_mutex_attributes.discipline ) {
10901f: 8b 45 e4 mov -0x1c(%ebp),%eax
109022: 83 f8 01 cmp $0x1,%eax
109025: 76 12 jbe 109039 <rtems_semaphore_create+0xf9>
109027: 83 f8 03 cmp $0x3,%eax
10902a: 77 11 ja 10903d <rtems_semaphore_create+0xfd><== NEVER TAKEN
case CORE_MUTEX_DISCIPLINES_PRIORITY:
the_mutex_attributes.only_owner_release = FALSE;
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
the_mutex_attributes.only_owner_release = TRUE;
10902c: c6 45 e0 01 movb $0x1,-0x20(%ebp)
109030: eb 0b jmp 10903d <rtems_semaphore_create+0xfd>
break;
}
} else {
the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
109032: c7 45 dc 02 00 00 00 movl $0x2,-0x24(%ebp)
the_mutex_attributes.only_owner_release = FALSE;
109039: c6 45 e0 00 movb $0x0,-0x20(%ebp)
}
the_mutex_attributes.priority_ceiling = priority_ceiling;
10903d: 8b 45 14 mov 0x14(%ebp),%eax
109040: 89 45 e8 mov %eax,-0x18(%ebp)
mutex_status = _CORE_mutex_Initialize(
109043: 51 push %ecx
109044: 31 c0 xor %eax,%eax
109046: 83 7d 0c 01 cmpl $0x1,0xc(%ebp)
10904a: 0f 94 c0 sete %al
10904d: 50 push %eax
10904e: 8d 45 dc lea -0x24(%ebp),%eax
109051: 50 push %eax
109052: 8d 46 14 lea 0x14(%esi),%eax
109055: 50 push %eax
109056: e8 4d 0b 00 00 call 109ba8 <_CORE_mutex_Initialize>
&the_semaphore->Core_control.mutex,
&the_mutex_attributes,
(count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED
);
if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {
10905b: 83 c4 10 add $0x10,%esp
10905e: 83 f8 06 cmp $0x6,%eax
109061: 75 50 jne 1090b3 <rtems_semaphore_create+0x173><== ALWAYS TAKEN
* @param[in] starting_address is the starting address of the memory for
* the heap
* @param[in] size is the size in bytes of the memory area for the heap
* @param[in] page_size is the size in bytes of the allocation unit
*
* @return This method returns the maximum memory available. If
109063: 52 push %edx <== NOT EXECUTED
109064: 52 push %edx <== NOT EXECUTED
109065: 56 push %esi <== NOT EXECUTED
109066: 68 28 ca 11 00 push $0x11ca28 <== NOT EXECUTED
10906b: e8 88 14 00 00 call 10a4f8 <_Objects_Free> <== NOT EXECUTED
_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
109070: e8 77 1d 00 00 call 10adec <_Thread_Enable_dispatch><== NOT EXECUTED
109075: b8 13 00 00 00 mov $0x13,%eax <== NOT EXECUTED
10907a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10907d: eb 5b jmp 1090da <rtems_semaphore_create+0x19a><== NOT EXECUTED
return RTEMS_INVALID_PRIORITY;
}
} else {
if ( _Attributes_Is_priority( attribute_set ) )
the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
10907f: 31 c0 xor %eax,%eax
109081: f6 c3 04 test $0x4,%bl
109084: 0f 95 c0 setne %al
109087: 89 45 f0 mov %eax,-0x10(%ebp)
/*
* This effectively disables limit checking.
*/
the_semaphore_attributes.maximum_count = 0xFFFFFFFF;
10908a: c7 45 ec ff ff ff ff movl $0xffffffff,-0x14(%ebp)
/*
* The following are just to make Purify happy.
*/
the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
109091: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM;
109098: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp)
_CORE_semaphore_Initialize(
10909f: 50 push %eax
1090a0: ff 75 0c pushl 0xc(%ebp)
1090a3: 8d 45 ec lea -0x14(%ebp),%eax
1090a6: 50 push %eax
1090a7: 8d 46 14 lea 0x14(%esi),%eax
1090aa: 50 push %eax
1090ab: e8 74 0d 00 00 call 109e24 <_CORE_semaphore_Initialize>
1090b0: 83 c4 10 add $0x10,%esp
1090b3: 8b 4e 08 mov 0x8(%esi),%ecx
1090b6: 0f b7 d1 movzwl %cx,%edx
1090b9: a1 44 ca 11 00 mov 0x11ca44,%eax
1090be: 89 34 90 mov %esi,(%eax,%edx,4)
1090c1: 8b 45 08 mov 0x8(%ebp),%eax
1090c4: 89 46 0c mov %eax,0xc(%esi)
&_Semaphore_Information,
&the_semaphore->Object,
(Objects_Name) name
);
*id = the_semaphore->Object.id;
1090c7: 8b 45 18 mov 0x18(%ebp),%eax
1090ca: 89 08 mov %ecx,(%eax)
the_semaphore->Object.id,
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
1090cc: e8 1b 1d 00 00 call 10adec <_Thread_Enable_dispatch>
1090d1: 31 c0 xor %eax,%eax
1090d3: eb 05 jmp 1090da <rtems_semaphore_create+0x19a>
return RTEMS_SUCCESSFUL;
1090d5: b8 0b 00 00 00 mov $0xb,%eax
}
1090da: 8d 65 f4 lea -0xc(%ebp),%esp
1090dd: 5b pop %ebx
1090de: 5e pop %esi
1090df: 5f pop %edi
1090e0: c9 leave
1090e1: c3 ret
001121dc <rtems_semaphore_flush>:
#endif
rtems_status_code rtems_semaphore_flush(
rtems_id id
)
{
1121dc: 55 push %ebp
1121dd: 89 e5 mov %esp,%ebp
1121df: 83 ec 1c sub $0x1c,%esp
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] starting_address is the starting address of the memory
* to add to the heap
1121e2: 8d 45 fc lea -0x4(%ebp),%eax
1121e5: 50 push %eax
1121e6: ff 75 08 pushl 0x8(%ebp)
1121e9: 68 d4 26 13 00 push $0x1326d4
1121ee: e8 65 2d 00 00 call 114f58 <_Objects_Get>
1121f3: 89 c2 mov %eax,%edx
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
1121f5: 83 c4 10 add $0x10,%esp
1121f8: b8 04 00 00 00 mov $0x4,%eax
1121fd: 83 7d fc 00 cmpl $0x0,-0x4(%ebp)
112201: 75 2b jne 11222e <rtems_semaphore_flush+0x52>
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
112203: f6 42 10 30 testb $0x30,0x10(%edx)
112207: 8d 42 14 lea 0x14(%edx),%eax
11220a: 74 0d je 112219 <rtems_semaphore_flush+0x3d><== NEVER TAKEN
_CORE_mutex_Flush(
11220c: 51 push %ecx
11220d: 6a 01 push $0x1
11220f: 6a 00 push $0x0
112211: 50 push %eax
112212: e8 49 1c 00 00 call 113e60 <_CORE_mutex_Flush>
112217: eb 0b jmp 112224 <rtems_semaphore_flush+0x48>
&the_semaphore->Core_control.mutex,
SEND_OBJECT_WAS_DELETED,
CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT
);
} else {
_CORE_semaphore_Flush(
112219: 52 push %edx <== NOT EXECUTED
11221a: 6a 01 push $0x1 <== NOT EXECUTED
11221c: 6a 00 push $0x0 <== NOT EXECUTED
11221e: 50 push %eax <== NOT EXECUTED
11221f: e8 b8 1e 00 00 call 1140dc <_CORE_semaphore_Flush> <== NOT EXECUTED
112224: 83 c4 10 add $0x10,%esp
&the_semaphore->Core_control.semaphore,
SEND_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT
);
}
_Thread_Enable_dispatch();
112227: e8 ec 34 00 00 call 115718 <_Thread_Enable_dispatch>
11222c: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
11222e: c9 leave
11222f: c3 ret
00114ddc <rtems_shutdown_executive>:
*/
void rtems_shutdown_executive(
uint32_t result
)
{
114ddc: 55 push %ebp
114ddd: 89 e5 mov %esp,%ebp
114ddf: 83 ec 28 sub $0x28,%esp
if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) {
114de2: 83 3d 80 cc 11 00 04 cmpl $0x4,0x11cc80
114de9: 74 1d je 114e08 <rtems_shutdown_executive+0x2c><== NEVER TAKEN
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
114deb: c7 05 80 cc 11 00 04 movl $0x4,0x11cc80
114df2: 00 00 00
#endif
}
/**
* This routine sets the current system state to that specified by
* the called.
114df5: 50 push %eax
114df6: 50 push %eax
114df7: 68 c8 ca 11 00 push $0x11cac8
114dfc: 8d 45 e8 lea -0x18(%ebp),%eax
114dff: 50 push %eax
114e00: e8 1b 70 ff ff call 10be20 <_CPU_Context_switch>
114e05: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_SHUTDOWN );
_Thread_Stop_multitasking();
}
}
114e08: c9 leave <== NOT EXECUTED
114e09: c3 ret <== NOT EXECUTED
00109ef0 <rtems_signal_catch>:
rtems_status_code rtems_signal_catch(
rtems_asr_entry asr_handler,
rtems_mode mode_set
)
{
109ef0: 55 push %ebp
109ef1: 89 e5 mov %esp,%ebp
109ef3: 83 ec 08 sub $0x8,%esp
109ef6: 8b 4d 08 mov 0x8(%ebp),%ecx
RTEMS_API_Control *api;
ASR_Information *asr;
/* XXX normalize mode */
executing = _Thread_Executing;
api = (RTEMS_API_Control*)executing->API_Extensions[ THREAD_API_RTEMS ];
109ef9: a1 ac f5 11 00 mov 0x11f5ac,%eax
109efe: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
109f04: a1 ec f4 11 00 mov 0x11f4ec,%eax
109f09: 40 inc %eax
109f0a: a3 ec f4 11 00 mov %eax,0x11f4ec
asr = &api->Signal;
_Thread_Disable_dispatch(); /* cannot reschedule while */
/* the thread is inconsistent */
if ( !_ASR_Is_null_handler( asr_handler ) ) {
109f0f: 85 c9 test %ecx,%ecx
109f11: 74 0b je 109f1e <rtems_signal_catch+0x2e><== NEVER TAKEN
asr->mode_set = mode_set;
109f13: 8b 45 0c mov 0xc(%ebp),%eax
109f16: 89 42 10 mov %eax,0x10(%edx)
asr->handler = asr_handler;
109f19: 89 4a 0c mov %ecx,0xc(%edx)
109f1c: eb 27 jmp 109f45 <rtems_signal_catch+0x55>
#endif
/**
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
109f1e: c6 42 08 01 movb $0x1,0x8(%edx) <== NOT EXECUTED
* @a page_size byte units. If @a page_size is 0 or is not multiple of
109f22: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) <== NOT EXECUTED
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
109f29: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) <== NOT EXECUTED
*
109f30: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx) <== NOT EXECUTED
* @param[in] the_heap is the heap to operate upon
109f37: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) <== NOT EXECUTED
* @param[in] starting_address is the starting address of the memory for
109f3e: c7 42 1c 00 00 00 00 movl $0x0,0x1c(%edx) <== NOT EXECUTED
}
else
_ASR_Initialize( asr );
_Thread_Enable_dispatch();
109f45: e8 ee 1d 00 00 call 10bd38 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
}
109f4a: 31 c0 xor %eax,%eax
109f4c: c9 leave
109f4d: c3 ret
001123cc <rtems_signal_send>:
rtems_status_code rtems_signal_send(
Objects_Id id,
rtems_signal_set signal_set
)
{
1123cc: 55 push %ebp
1123cd: 89 e5 mov %esp,%ebp
1123cf: 53 push %ebx
1123d0: 83 ec 14 sub $0x14,%esp
1123d3: 8b 5d 0c mov 0xc(%ebp),%ebx
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
1123d6: b8 0a 00 00 00 mov $0xa,%eax
1123db: 85 db test %ebx,%ebx
1123dd: 74 71 je 112450 <rtems_signal_send+0x84><== NEVER TAKEN
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
1123df: 50 push %eax
1123e0: 50 push %eax
1123e1: 8d 45 f8 lea -0x8(%ebp),%eax
1123e4: 50 push %eax
1123e5: ff 75 08 pushl 0x8(%ebp)
1123e8: e8 4b 33 00 00 call 115738 <_Thread_Get>
1123ed: 89 c1 mov %eax,%ecx
switch ( location ) {
1123ef: 83 c4 10 add $0x10,%esp
1123f2: b8 04 00 00 00 mov $0x4,%eax
1123f7: 83 7d f8 00 cmpl $0x0,-0x8(%ebp)
1123fb: 75 53 jne 112450 <rtems_signal_send+0x84>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
1123fd: 8b 91 f4 00 00 00 mov 0xf4(%ecx),%edx
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
112403: 83 7a 0c 00 cmpl $0x0,0xc(%edx)
112407: 74 3d je 112446 <rtems_signal_send+0x7a>
if ( asr->is_enabled ) {
112409: 80 7a 08 00 cmpb $0x0,0x8(%edx)
11240d: 74 26 je 112435 <rtems_signal_send+0x69><== NEVER TAKEN
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
11240f: 9c pushf
112410: fa cli
112411: 58 pop %eax
);
112412: 09 5a 14 or %ebx,0x14(%edx)
112415: 50 push %eax
112416: 9d popf
_ASR_Post_signals( signal_set, &asr->signals_posted );
the_thread->do_post_task_switch_extension = true;
112417: c6 41 75 01 movb $0x1,0x75(%ecx)
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
11241b: a1 7c 28 13 00 mov 0x13287c,%eax
112420: 85 c0 test %eax,%eax
112422: 74 19 je 11243d <rtems_signal_send+0x71>
112424: 3b 0d a0 28 13 00 cmp 0x1328a0,%ecx
11242a: 75 11 jne 11243d <rtems_signal_send+0x71><== NEVER TAKEN
_ISR_Signals_to_thread_executing = TRUE;
11242c: c6 05 34 29 13 00 01 movb $0x1,0x132934
112433: eb 08 jmp 11243d <rtems_signal_send+0x71>
* @return NULL if unsuccessful and a pointer to the block if successful
*/
void *_Protected_heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
112435: 9c pushf <== NOT EXECUTED
112436: fa cli <== NOT EXECUTED
112437: 58 pop %eax <== NOT EXECUTED
);
112438: 09 5a 18 or %ebx,0x18(%edx) <== NOT EXECUTED
11243b: 50 push %eax <== NOT EXECUTED
11243c: 9d popf <== NOT EXECUTED
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
11243d: e8 d6 32 00 00 call 115718 <_Thread_Enable_dispatch>
112442: 31 c0 xor %eax,%eax
112444: eb 0a jmp 112450 <rtems_signal_send+0x84>
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
112446: e8 cd 32 00 00 call 115718 <_Thread_Enable_dispatch>
11244b: b8 0b 00 00 00 mov $0xb,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112450: 8b 5d fc mov -0x4(%ebp),%ebx
112453: c9 leave
112454: c3 ret
001066f8 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
1066f8: 55 push %ebp
1066f9: 89 e5 mov %esp,%ebp
1066fb: 57 push %edi
1066fc: 56 push %esi
1066fd: 8b 45 08 mov 0x8(%ebp),%eax
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
106700: 83 78 08 00 cmpl $0x0,0x8(%eax)
106704: 74 15 je 10671b <rtems_stack_checker_begin_extension+0x23><== NEVER TAKEN
return;
the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
*the_pattern = Stack_check_Pattern;
106706: 8b 80 c8 00 00 00 mov 0xc8(%eax),%eax
10670c: 8d 78 08 lea 0x8(%eax),%edi
10670f: be 90 f3 11 00 mov $0x11f390,%esi
106714: b9 04 00 00 00 mov $0x4,%ecx
106719: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
10671b: 5e pop %esi
10671c: 5f pop %edi
10671d: c9 leave
10671e: c3 ret
00106a80 <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running,
Thread_Control *the_thread
)
{
106a80: 55 push %ebp
106a81: 89 e5 mov %esp,%ebp
106a83: 57 push %edi
106a84: 83 ec 04 sub $0x4,%esp
106a87: 8b 7d 0c mov 0xc(%ebp),%edi
Stack_check_Initialize();
106a8a: e8 84 ff ff ff call 106a13 <Stack_check_Initialize>
if (the_thread)
106a8f: 85 ff test %edi,%edi
106a91: 74 10 je 106aa3 <rtems_stack_checker_create_extension+0x23><== NEVER TAKEN
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
106a93: 8b 8f c4 00 00 00 mov 0xc4(%edi),%ecx
106a99: 8b bf c8 00 00 00 mov 0xc8(%edi),%edi
106a9f: b0 a5 mov $0xa5,%al
106aa1: f3 aa rep stos %al,%es:(%edi)
return true;
}
106aa3: b0 01 mov $0x1,%al
106aa5: 5a pop %edx
106aa6: 5f pop %edi
106aa7: c9 leave
106aa8: c3 ret
00106941 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
106941: 55 push %ebp <== NOT EXECUTED
106942: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106944: 53 push %ebx <== NOT EXECUTED
106945: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
106948: a1 cc f5 11 00 mov 0x11f5cc,%eax <== NOT EXECUTED
)
{
void *sp = __builtin_frame_address(0);
#if defined(__GNUC__)
if ( sp < the_stack->area ) {
10694d: 8b 90 c8 00 00 00 mov 0xc8(%eax),%edx <== NOT EXECUTED
106953: 31 db xor %ebx,%ebx <== NOT EXECUTED
106955: 39 d5 cmp %edx,%ebp <== NOT EXECUTED
106957: 72 0e jb 106967 <rtems_stack_checker_is_blown+0x26><== NOT EXECUTED
106959: 8b 88 c4 00 00 00 mov 0xc4(%eax),%ecx <== NOT EXECUTED
10695f: 8d 04 0a lea (%edx,%ecx,1),%eax <== NOT EXECUTED
106962: 39 c5 cmp %eax,%ebp <== NOT EXECUTED
106964: 0f 96 c3 setbe %bl <== NOT EXECUTED
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
106967: b0 01 mov $0x1,%al <== NOT EXECUTED
106969: 83 3d 74 f1 11 00 00 cmpl $0x0,0x11f174 <== NOT EXECUTED
106970: 74 19 je 10698b <rtems_stack_checker_is_blown+0x4a><== NOT EXECUTED
pattern_ok = (!memcmp(
106972: 51 push %ecx <== NOT EXECUTED
106973: 6a 10 push $0x10 <== NOT EXECUTED
106975: 68 90 f3 11 00 push $0x11f390 <== NOT EXECUTED
10697a: 8d 42 08 lea 0x8(%edx),%eax <== NOT EXECUTED
10697d: 50 push %eax <== NOT EXECUTED
10697e: e8 6d 94 00 00 call 10fdf0 <memcmp> <== NOT EXECUTED
106983: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106986: 85 c0 test %eax,%eax <== NOT EXECUTED
106988: 0f 94 c0 sete %al <== NOT EXECUTED
}
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
if ( sp_ok && pattern_ok )
10698b: 84 db test %bl,%bl <== NOT EXECUTED
10698d: 74 06 je 106995 <rtems_stack_checker_is_blown+0x54><== NOT EXECUTED
10698f: 31 d2 xor %edx,%edx <== NOT EXECUTED
106991: 84 c0 test %al,%al <== NOT EXECUTED
106993: 75 16 jne 1069ab <rtems_stack_checker_is_blown+0x6a><== NOT EXECUTED
return false;
/*
* Let's report as much as we can.
*/
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
106995: 52 push %edx <== NOT EXECUTED
106996: 52 push %edx <== NOT EXECUTED
106997: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
10699a: 50 push %eax <== NOT EXECUTED
10699b: ff 35 cc f5 11 00 pushl 0x11f5cc <== NOT EXECUTED
1069a1: e8 34 ff ff ff call 1068da <Stack_check_report_blown_task><== NOT EXECUTED
1069a6: b2 01 mov $0x1,%dl <== NOT EXECUTED
1069a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return true;
}
1069ab: 88 d0 mov %dl,%al <== NOT EXECUTED
1069ad: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
1069b0: c9 leave <== NOT EXECUTED
1069b1: c3 ret <== NOT EXECUTED
001068c3 <rtems_stack_checker_report_usage>:
void rtems_stack_checker_report_usage( void )
{
1068c3: 55 push %ebp <== NOT EXECUTED
1068c4: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1068c6: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
1068c9: 68 d0 7b 10 00 push $0x107bd0 <== NOT EXECUTED
1068ce: 6a 00 push $0x0 <== NOT EXECUTED
1068d0: e8 8d ff ff ff call 106862 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
1068d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
1068d8: c9 leave <== NOT EXECUTED
1068d9: c3 ret <== NOT EXECUTED
00106862 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
106862: 55 push %ebp <== NOT EXECUTED
106863: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106865: 56 push %esi <== NOT EXECUTED
106866: 53 push %ebx <== NOT EXECUTED
106867: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
10686a: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED
print_context = context;
10686d: 89 1d 78 f1 11 00 mov %ebx,0x11f178 <== NOT EXECUTED
print_handler = print;
106873: 89 35 7c f1 11 00 mov %esi,0x11f17c <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
106879: 51 push %ecx <== NOT EXECUTED
10687a: 51 push %ecx <== NOT EXECUTED
10687b: 68 c5 8b 11 00 push $0x118bc5 <== NOT EXECUTED
106880: 53 push %ebx <== NOT EXECUTED
106881: ff d6 call *%esi <== NOT EXECUTED
(*print)( context,
106883: 58 pop %eax <== NOT EXECUTED
106884: 5a pop %edx <== NOT EXECUTED
106885: 68 dc 8b 11 00 push $0x118bdc <== NOT EXECUTED
10688a: 53 push %ebx <== NOT EXECUTED
10688b: ff d6 call *%esi <== NOT EXECUTED
" ID NAME LOW HIGH CURRENT AVAILABLE USED\n"
);
/* iterate over all threads and dump the usage */
rtems_iterate_over_all_threads( Stack_check_Dump_threads_usage );
10688d: c7 04 24 4a 67 10 00 movl $0x10674a,(%esp) <== NOT EXECUTED
106894: e8 a3 46 00 00 call 10af3c <rtems_iterate_over_all_threads><== NOT EXECUTED
/* dump interrupt stack info if any */
Stack_check_Dump_threads_usage((Thread_Control *) -1);
106899: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED
1068a0: e8 a5 fe ff ff call 10674a <Stack_check_Dump_threads_usage><== NOT EXECUTED
print_context = NULL;
1068a5: c7 05 78 f1 11 00 00 movl $0x0,0x11f178 <== NOT EXECUTED
1068ac: 00 00 00
print_handler = NULL;
1068af: c7 05 7c f1 11 00 00 movl $0x0,0x11f17c <== NOT EXECUTED
1068b6: 00 00 00
1068b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
1068bc: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
1068bf: 5b pop %ebx <== NOT EXECUTED
1068c0: 5e pop %esi <== NOT EXECUTED
1068c1: c9 leave <== NOT EXECUTED
1068c2: c3 ret <== NOT EXECUTED
001069b2 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running,
Thread_Control *heir
)
{
1069b2: 55 push %ebp
1069b3: 89 e5 mov %esp,%ebp
1069b5: 56 push %esi
1069b6: 53 push %ebx
1069b7: 8b 5d 08 mov 0x8(%ebp),%ebx
Stack_Control *the_stack = &running->Start.Initial_stack;
void *pattern;
bool sp_ok;
bool pattern_ok = true;
pattern = (void *) Stack_check_Get_pattern_area(the_stack)->pattern;
1069ba: 8b 93 c8 00 00 00 mov 0xc8(%ebx),%edx
)
{
void *sp = __builtin_frame_address(0);
#if defined(__GNUC__)
if ( sp < the_stack->area ) {
1069c0: 31 f6 xor %esi,%esi
1069c2: 39 d5 cmp %edx,%ebp
1069c4: 72 0f jb 1069d5 <rtems_stack_checker_switch_extension+0x23><== NEVER TAKEN
1069c6: 89 d0 mov %edx,%eax
1069c8: 03 83 c4 00 00 00 add 0xc4(%ebx),%eax
1069ce: 39 c5 cmp %eax,%ebp
1069d0: 0f 96 c0 setbe %al
1069d3: 89 c6 mov %eax,%esi
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
1069d5: 50 push %eax
1069d6: 6a 10 push $0x10
1069d8: 68 90 f3 11 00 push $0x11f390
1069dd: 8d 42 08 lea 0x8(%edx),%eax
1069e0: 50 push %eax
1069e1: e8 0a 94 00 00 call 10fdf0 <memcmp>
1069e6: 83 c4 10 add $0x10,%esp
1069e9: 85 c0 test %eax,%eax
1069eb: 0f 94 c0 sete %al
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
1069ee: 89 f2 mov %esi,%edx
1069f0: 84 d2 test %dl,%dl
1069f2: 74 04 je 1069f8 <rtems_stack_checker_switch_extension+0x46><== NEVER TAKEN
1069f4: 84 c0 test %al,%al
1069f6: 75 14 jne 106a0c <rtems_stack_checker_switch_extension+0x5a><== ALWAYS TAKEN
Stack_check_report_blown_task( running, pattern_ok );
1069f8: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
1069fb: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED
1069fe: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED
}
}
106a01: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
106a04: 5b pop %ebx <== NOT EXECUTED
106a05: 5e pop %esi <== NOT EXECUTED
106a06: 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 );
106a07: e9 ce fe ff ff jmp 1068da <Stack_check_report_blown_task><== NOT EXECUTED
}
}
106a0c: 8d 65 f8 lea -0x8(%ebp),%esp
106a0f: 5b pop %ebx
106a10: 5e pop %esi
106a11: c9 leave
106a12: c3 ret
00106eac <rtems_status_text>:
const char *
rtems_status_text(
rtems_status_code status
)
{
106eac: 55 push %ebp <== NOT EXECUTED
106ead: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106eaf: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
return rtems_assoc_name_by_local(rtems_status_assoc, status);
106eb2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
106eb5: 68 d8 96 11 00 push $0x1196d8 <== NOT EXECUTED
106eba: e8 fd 72 00 00 call 10e1bc <rtems_assoc_name_by_local><== NOT EXECUTED
}
106ebf: c9 leave <== NOT EXECUTED
106ec0: c3 ret <== NOT EXECUTED
001092ec <rtems_task_create>:
size_t stack_size,
rtems_mode initial_modes,
rtems_attribute attribute_set,
Objects_Id *id
)
{
1092ec: 55 push %ebp
1092ed: 89 e5 mov %esp,%ebp
1092ef: 57 push %edi
1092f0: 56 push %esi
1092f1: 53 push %ebx
1092f2: 83 ec 0c sub $0xc,%esp
1092f5: 8b 5d 14 mov 0x14(%ebp),%ebx
1092f8: 8b 7d 18 mov 0x18(%ebp),%edi
Priority_Control core_priority;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
1092fb: b8 09 00 00 00 mov $0x9,%eax
109300: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp)
109304: 0f 84 08 01 00 00 je 109412 <rtems_task_create+0x126><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
10930a: b8 03 00 00 00 mov $0x3,%eax
10930f: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
109313: 0f 84 f9 00 00 00 je 109412 <rtems_task_create+0x126>
/*
* Validate the RTEMS API priority and convert it to the core priority range.
*/
if ( !_Attributes_Is_system_task( the_attribute_set ) ) {
109319: 66 85 ff test %di,%di
10931c: 78 24 js 109342 <rtems_task_create+0x56>
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
size_t size
);
10931e: 31 d2 xor %edx,%edx
109320: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
109324: 74 0f je 109335 <rtems_task_create+0x49>
109326: 0f b6 05 64 87 11 00 movzbl 0x118764,%eax
10932d: 31 d2 xor %edx,%edx
10932f: 39 45 0c cmp %eax,0xc(%ebp)
109332: 0f 96 c2 setbe %dl
if ( !_RTEMS_tasks_Priority_is_valid( initial_priority ) )
109335: b8 13 00 00 00 mov $0x13,%eax
10933a: 85 d2 test %edx,%edx
10933c: 0f 84 d0 00 00 00 je 109412 <rtems_task_create+0x126>
*/
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
109342: 83 ec 0c sub $0xc,%esp
109345: ff 35 98 cb 11 00 pushl 0x11cb98
10934b: e8 88 06 00 00 call 1099d8 <_API_Mutex_Lock>
#ifdef __cplusplus
extern "C" {
#endif
/**
109350: c7 04 24 68 ca 11 00 movl $0x11ca68,(%esp)
109357: e8 8c 0e 00 00 call 10a1e8 <_Objects_Allocate>
10935c: 89 c6 mov %eax,%esi
* the event of an error.
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
10935e: 83 c4 10 add $0x10,%esp
109361: 85 c0 test %eax,%eax
109363: 75 18 jne 10937d <rtems_task_create+0x91>
_RTEMS_Unlock_allocator();
109365: 83 ec 0c sub $0xc,%esp
109368: ff 35 98 cb 11 00 pushl 0x11cb98
10936e: e8 ad 06 00 00 call 109a20 <_API_Mutex_Unlock>
109373: b8 05 00 00 00 mov $0x5,%eax
109378: e9 92 00 00 00 jmp 10940f <rtems_task_create+0x123>
/*
* Initialize the core thread for this task.
*/
status = _Thread_Initialize(
10937d: 50 push %eax
10937e: ff 75 08 pushl 0x8(%ebp)
109381: 89 d8 mov %ebx,%eax
109383: 83 e0 01 and $0x1,%eax
109386: 50 push %eax
109387: 6a 00 push $0x0
109389: 89 d8 mov %ebx,%eax
10938b: c1 e8 09 shr $0x9,%eax
10938e: 83 e0 01 and $0x1,%eax
109391: 50 push %eax
109392: 89 d8 mov %ebx,%eax
109394: c1 e8 08 shr $0x8,%eax
109397: 83 f0 01 xor $0x1,%eax
10939a: 83 e0 01 and $0x1,%eax
10939d: 50 push %eax
10939e: ff 75 0c pushl 0xc(%ebp)
1093a1: 83 e7 01 and $0x1,%edi
1093a4: 57 push %edi
1093a5: ff 75 10 pushl 0x10(%ebp)
1093a8: 6a 00 push $0x0
1093aa: 56 push %esi
1093ab: 68 68 ca 11 00 push $0x11ca68
1093b0: e8 cf 1a 00 00 call 10ae84 <_Thread_Initialize>
NULL, /* no budget algorithm callout */
_Modes_Get_interrupt_level(initial_modes),
(Objects_Name) name
);
if ( !status ) {
1093b5: 83 c4 30 add $0x30,%esp
1093b8: 84 c0 test %al,%al
1093ba: 75 27 jne 1093e3 <rtems_task_create+0xf7>
* @param[in] starting_address is the starting address of the memory for
* the heap
* @param[in] size is the size in bytes of the memory area for the heap
* @param[in] page_size is the size in bytes of the allocation unit
*
* @return This method returns the maximum memory available. If
1093bc: 83 ec 0c sub $0xc,%esp
1093bf: ff 76 08 pushl 0x8(%esi)
1093c2: e8 a5 11 00 00 call 10a56c <_Objects_Get_information_id>
1093c7: 5a pop %edx
1093c8: 59 pop %ecx
1093c9: 56 push %esi
1093ca: 50 push %eax
1093cb: e8 28 11 00 00 call 10a4f8 <_Objects_Free>
#if defined(RTEMS_MULTIPROCESSING)
if ( is_global )
_Objects_MP_Free_global_object( the_global_object );
#endif
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
1093d0: 58 pop %eax
1093d1: ff 35 98 cb 11 00 pushl 0x11cb98
1093d7: e8 44 06 00 00 call 109a20 <_API_Mutex_Unlock>
1093dc: b8 0d 00 00 00 mov $0xd,%eax
1093e1: eb 2c jmp 10940f <rtems_task_create+0x123>
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
1093e3: 8b 86 f4 00 00 00 mov 0xf4(%esi),%eax
1093e9: c1 eb 0a shr $0xa,%ebx
1093ec: 83 f3 01 xor $0x1,%ebx
1093ef: 88 da mov %bl,%dl
1093f1: 83 e2 01 and $0x1,%edx
1093f4: 88 50 08 mov %dl,0x8(%eax)
*id = the_thread->Object.id;
1093f7: 8b 46 08 mov 0x8(%esi),%eax
1093fa: 8b 55 1c mov 0x1c(%ebp),%edx
1093fd: 89 02 mov %eax,(%edx)
);
}
#endif
_RTEMS_Unlock_allocator();
1093ff: 83 ec 0c sub $0xc,%esp
109402: ff 35 98 cb 11 00 pushl 0x11cb98
109408: e8 13 06 00 00 call 109a20 <_API_Mutex_Unlock>
10940d: 31 c0 xor %eax,%eax
10940f: 83 c4 10 add $0x10,%esp
return RTEMS_SUCCESSFUL;
}
109412: 8d 65 f4 lea -0xc(%ebp),%esp
109415: 5b pop %ebx
109416: 5e pop %esi
109417: 5f pop %edi
109418: c9 leave
109419: c3 ret
0010aa34 <rtems_task_get_note>:
rtems_status_code rtems_task_get_note(
Objects_Id id,
uint32_t notepad,
uint32_t *note
)
{
10aa34: 55 push %ebp
10aa35: 89 e5 mov %esp,%ebp
10aa37: 56 push %esi
10aa38: 53 push %ebx
10aa39: 83 ec 10 sub $0x10,%esp
10aa3c: 8b 4d 08 mov 0x8(%ebp),%ecx
10aa3f: 8b 5d 0c mov 0xc(%ebp),%ebx
10aa42: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
10aa45: a1 ec 17 12 00 mov 0x1217ec,%eax
10aa4a: 8b 40 40 mov 0x40(%eax),%eax
10aa4d: ba 16 00 00 00 mov $0x16,%edx
10aa52: 80 78 04 00 cmpb $0x0,0x4(%eax)
10aa56: 74 61 je 10aab9 <rtems_task_get_note+0x85><== NEVER TAKEN
return RTEMS_NOT_CONFIGURED;
if ( !note )
10aa58: ba 09 00 00 00 mov $0x9,%edx
10aa5d: 85 f6 test %esi,%esi
10aa5f: 74 58 je 10aab9 <rtems_task_get_note+0x85><== NEVER TAKEN
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
10aa61: ba 0a 00 00 00 mov $0xa,%edx
10aa66: 83 fb 0f cmp $0xf,%ebx
10aa69: 77 4e ja 10aab9 <rtems_task_get_note+0x85>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10aa6b: 85 c9 test %ecx,%ecx
10aa6d: 74 0a je 10aa79 <rtems_task_get_note+0x45>
10aa6f: a1 14 18 12 00 mov 0x121814,%eax
10aa74: 3b 48 08 cmp 0x8(%eax),%ecx
10aa77: 75 13 jne 10aa8c <rtems_task_get_note+0x58>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
10aa79: a1 14 18 12 00 mov 0x121814,%eax
10aa7e: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
10aa84: 8b 44 98 20 mov 0x20(%eax,%ebx,4),%eax
10aa88: 89 06 mov %eax,(%esi)
10aa8a: eb 2b jmp 10aab7 <rtems_task_get_note+0x83>
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
10aa8c: 50 push %eax
10aa8d: 50 push %eax
10aa8e: 8d 45 f4 lea -0xc(%ebp),%eax
10aa91: 50 push %eax
10aa92: 51 push %ecx
10aa93: e8 38 1c 00 00 call 10c6d0 <_Thread_Get>
switch ( location ) {
10aa98: 83 c4 10 add $0x10,%esp
10aa9b: ba 04 00 00 00 mov $0x4,%edx
10aaa0: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10aaa4: 75 13 jne 10aab9 <rtems_task_get_note+0x85><== ALWAYS TAKEN
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
10aaa6: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED
10aaac: 8b 44 98 20 mov 0x20(%eax,%ebx,4),%eax <== NOT EXECUTED
10aab0: 89 06 mov %eax,(%esi) <== NOT EXECUTED
_Thread_Enable_dispatch();
10aab2: e8 f9 1b 00 00 call 10c6b0 <_Thread_Enable_dispatch><== NOT EXECUTED
10aab7: 31 d2 xor %edx,%edx
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10aab9: 89 d0 mov %edx,%eax
10aabb: 8d 65 f8 lea -0x8(%ebp),%esp
10aabe: 5b pop %ebx
10aabf: 5e pop %esi
10aac0: c9 leave
10aac1: c3 ret
001094a0 <rtems_task_ident>:
rtems_status_code rtems_task_ident(
rtems_name name,
uint32_t node,
Objects_Id *id
)
{
1094a0: 55 push %ebp
1094a1: 89 e5 mov %esp,%ebp
1094a3: 83 ec 08 sub $0x8,%esp
1094a6: 8b 4d 08 mov 0x8(%ebp),%ecx
1094a9: 8b 55 10 mov 0x10(%ebp),%edx
Objects_Name_or_id_lookup_errors status;
if ( !id )
1094ac: b8 09 00 00 00 mov $0x9,%eax
1094b1: 85 d2 test %edx,%edx
1094b3: 74 2b je 1094e0 <rtems_task_ident+0x40> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( name == OBJECTS_ID_OF_SELF ) {
1094b5: 85 c9 test %ecx,%ecx
1094b7: 75 0e jne 1094c7 <rtems_task_ident+0x27>
*id = _Thread_Executing->Object.id;
1094b9: a1 a0 cb 11 00 mov 0x11cba0,%eax
1094be: 8b 40 08 mov 0x8(%eax),%eax
1094c1: 89 02 mov %eax,(%edx)
1094c3: 31 c0 xor %eax,%eax
1094c5: eb 19 jmp 1094e0 <rtems_task_ident+0x40>
return RTEMS_SUCCESSFUL;
}
status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
1094c7: 52 push %edx
1094c8: ff 75 0c pushl 0xc(%ebp)
1094cb: 51 push %ecx
1094cc: 68 68 ca 11 00 push $0x11ca68
1094d1: e8 9e 12 00 00 call 10a774 <_Objects_Name_to_id_u32>
return _Status_Object_name_errors_to_status[ status ];
1094d6: 8b 04 85 a8 68 11 00 mov 0x1168a8(,%eax,4),%eax
1094dd: 83 c4 10 add $0x10,%esp
}
1094e0: c9 leave
1094e1: c3 ret
001099ec <rtems_task_is_suspended>:
*/
rtems_status_code rtems_task_is_suspended(
Objects_Id id
)
{
1099ec: 55 push %ebp
1099ed: 89 e5 mov %esp,%ebp
1099ef: 83 ec 20 sub $0x20,%esp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
1099f2: 8d 45 fc lea -0x4(%ebp),%eax
1099f5: 50 push %eax
1099f6: ff 75 08 pushl 0x8(%ebp)
1099f9: e8 a6 19 00 00 call 10b3a4 <_Thread_Get>
1099fe: 89 c2 mov %eax,%edx
switch ( location ) {
109a00: 83 c4 10 add $0x10,%esp
109a03: b8 04 00 00 00 mov $0x4,%eax
109a08: 83 7d fc 00 cmpl $0x0,-0x4(%ebp)
109a0c: 75 19 jne 109a27 <rtems_task_is_suspended+0x3b><== NEVER TAKEN
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
109a0e: f6 42 10 02 testb $0x2,0x10(%edx)
109a12: 75 09 jne 109a1d <rtems_task_is_suspended+0x31>
_Thread_Enable_dispatch();
109a14: e8 6b 19 00 00 call 10b384 <_Thread_Enable_dispatch>
109a19: 31 c0 xor %eax,%eax
109a1b: eb 0a jmp 109a27 <rtems_task_is_suspended+0x3b>
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
109a1d: e8 62 19 00 00 call 10b384 <_Thread_Enable_dispatch>
109a22: b8 0f 00 00 00 mov $0xf,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
109a27: c9 leave
109a28: c3 ret
0010e2a0 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
10e2a0: 55 push %ebp
10e2a1: 89 e5 mov %esp,%ebp
10e2a3: 57 push %edi
10e2a4: 56 push %esi
10e2a5: 53 push %ebx
10e2a6: 83 ec 0c sub $0xc,%esp
10e2a9: 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 )
10e2ac: b8 09 00 00 00 mov $0x9,%eax
10e2b1: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10e2b5: 0f 84 04 01 00 00 je 10e3bf <rtems_task_mode+0x11f> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
10e2bb: a1 a0 cb 11 00 mov 0x11cba0,%eax
10e2c0: 89 45 ec mov %eax,-0x14(%ebp)
api = executing->API_Extensions[ THREAD_API_RTEMS ];
10e2c3: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx
10e2c9: 89 55 f0 mov %edx,-0x10(%ebp)
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
10e2cc: 80 78 76 01 cmpb $0x1,0x76(%eax)
10e2d0: 19 f6 sbb %esi,%esi
10e2d2: 81 e6 00 01 00 00 and $0x100,%esi
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
10e2d8: 83 78 7c 00 cmpl $0x0,0x7c(%eax)
10e2dc: 74 06 je 10e2e4 <rtems_task_mode+0x44>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
10e2de: 81 ce 00 02 00 00 or $0x200,%esi
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
10e2e4: 8b 5d f0 mov -0x10(%ebp),%ebx
10e2e7: 80 7b 08 01 cmpb $0x1,0x8(%ebx)
10e2eb: 19 db sbb %ebx,%ebx
10e2ed: 81 e3 00 04 00 00 and $0x400,%ebx
old_mode |= _ISR_Get_level();
10e2f3: e8 03 dd ff ff call 10bffb <_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;
10e2f8: 09 c3 or %eax,%ebx
old_mode |= _ISR_Get_level();
*previous_mode_set = old_mode;
10e2fa: 09 f3 or %esi,%ebx
10e2fc: 8b 45 10 mov 0x10(%ebp),%eax
10e2ff: 89 18 mov %ebx,(%eax)
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
10e301: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp)
10e308: 74 11 je 10e31b <rtems_task_mode+0x7b>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE;
10e30a: 89 f8 mov %edi,%eax
10e30c: c1 e8 08 shr $0x8,%eax
10e30f: 83 f0 01 xor $0x1,%eax
10e312: 83 e0 01 and $0x1,%eax
10e315: 8b 55 ec mov -0x14(%ebp),%edx
10e318: 88 42 76 mov %al,0x76(%edx)
if ( mask & RTEMS_TIMESLICE_MASK ) {
10e31b: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
10e322: 74 26 je 10e34a <rtems_task_mode+0xaa>
if ( _Modes_Is_timeslice(mode_set) ) {
10e324: f7 c7 00 02 00 00 test $0x200,%edi
10e32a: 74 14 je 10e340 <rtems_task_mode+0xa0>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
10e32c: 8b 5d ec mov -0x14(%ebp),%ebx
10e32f: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
10e336: a1 ac ca 11 00 mov 0x11caac,%eax
10e33b: 89 43 78 mov %eax,0x78(%ebx)
10e33e: eb 0a jmp 10e34a <rtems_task_mode+0xaa>
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
10e340: 8b 45 ec mov -0x14(%ebp),%eax
10e343: c7 40 7c 00 00 00 00 movl $0x0,0x7c(%eax)
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
10e34a: f6 45 0c 01 testb $0x1,0xc(%ebp)
10e34e: 74 0c je 10e35c <rtems_task_mode+0xbc>
* Returns pointer to the start of the memory block if success, NULL if
* failure.
*
* @param[in] the_heap is the heap to operate upon
* @param[in] size is the amount of memory to allocate in bytes
* @param[in] alignment the required alignment
10e350: f7 c7 01 00 00 00 test $0x1,%edi
10e356: 74 03 je 10e35b <rtems_task_mode+0xbb>
10e358: fa cli
10e359: eb 01 jmp 10e35c <rtems_task_mode+0xbc>
10e35b: fb sti
*/
is_asr_enabled = FALSE;
needs_asr_dispatching = FALSE;
if ( mask & RTEMS_ASR_MASK ) {
10e35c: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
10e363: 74 3b je 10e3a0 <rtems_task_mode+0x100>
10e365: c1 ef 0a shr $0xa,%edi
10e368: 83 f7 01 xor $0x1,%edi
10e36b: 89 f8 mov %edi,%eax
10e36d: 83 e0 01 and $0x1,%eax
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
10e370: 8b 55 f0 mov -0x10(%ebp),%edx
10e373: 3a 42 08 cmp 0x8(%edx),%al
10e376: 74 28 je 10e3a0 <rtems_task_mode+0x100>
asr->is_enabled = is_asr_enabled;
10e378: 88 42 08 mov %al,0x8(%edx)
uint32_t page_size
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
}
10e37b: 9c pushf
10e37c: fa cli
10e37d: 59 pop %ecx
/**
10e37e: 8b 5d f0 mov -0x10(%ebp),%ebx
10e381: 8b 53 18 mov 0x18(%ebx),%edx
* This routine grows @a the_heap memory area using the size bytes which
10e384: 8b 43 14 mov 0x14(%ebx),%eax
10e387: 89 43 18 mov %eax,0x18(%ebx)
* begin at @a starting_address.
10e38a: 89 53 14 mov %edx,0x14(%ebx)
*
10e38d: 51 push %ecx
10e38e: 9d popf
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
10e38f: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10e393: 74 0b je 10e3a0 <rtems_task_mode+0x100> <== ALWAYS TAKEN
needs_asr_dispatching = true;
executing->do_post_task_switch_extension = true;
10e395: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
10e398: c6 40 75 01 movb $0x1,0x75(%eax) <== NOT EXECUTED
10e39c: b3 01 mov $0x1,%bl <== NOT EXECUTED
10e39e: eb 02 jmp 10e3a2 <rtems_task_mode+0x102> <== NOT EXECUTED
10e3a0: 31 db xor %ebx,%ebx
}
}
}
if ( _System_state_Is_up(_System_state_Current) )
10e3a2: 83 3d 80 cc 11 00 03 cmpl $0x3,0x11cc80
10e3a9: 75 12 jne 10e3bd <rtems_task_mode+0x11d> <== NEVER TAKEN
if ( _Thread_Evaluate_mode() || needs_asr_dispatching )
10e3ab: e8 58 01 00 00 call 10e508 <_Thread_Evaluate_mode>
10e3b0: 84 c0 test %al,%al
10e3b2: 75 04 jne 10e3b8 <rtems_task_mode+0x118>
10e3b4: 84 db test %bl,%bl
10e3b6: 74 05 je 10e3bd <rtems_task_mode+0x11d> <== ALWAYS TAKEN
_Thread_Dispatch();
10e3b8: e8 eb c8 ff ff call 10aca8 <_Thread_Dispatch>
10e3bd: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
10e3bf: 83 c4 0c add $0xc,%esp
10e3c2: 5b pop %ebx
10e3c3: 5e pop %esi
10e3c4: 5f pop %edi
10e3c5: c9 leave
10e3c6: c3 ret
0010ab98 <rtems_task_set_note>:
rtems_status_code rtems_task_set_note(
Objects_Id id,
uint32_t notepad,
uint32_t note
)
{
10ab98: 55 push %ebp
10ab99: 89 e5 mov %esp,%ebp
10ab9b: 56 push %esi
10ab9c: 53 push %ebx
10ab9d: 83 ec 10 sub $0x10,%esp
10aba0: 8b 4d 08 mov 0x8(%ebp),%ecx
10aba3: 8b 5d 0c mov 0xc(%ebp),%ebx
10aba6: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
10aba9: a1 ec 17 12 00 mov 0x1217ec,%eax
10abae: 8b 40 40 mov 0x40(%eax),%eax
10abb1: ba 16 00 00 00 mov $0x16,%edx
10abb6: 80 78 04 00 cmpb $0x0,0x4(%eax)
10abba: 74 54 je 10ac10 <rtems_task_set_note+0x78><== NEVER TAKEN
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
10abbc: ba 0a 00 00 00 mov $0xa,%edx
10abc1: 83 fb 0f cmp $0xf,%ebx
10abc4: 77 4a ja 10ac10 <rtems_task_set_note+0x78>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
10abc6: 85 c9 test %ecx,%ecx
10abc8: 74 0a je 10abd4 <rtems_task_set_note+0x3c>
10abca: a1 14 18 12 00 mov 0x121814,%eax
10abcf: 3b 48 08 cmp 0x8(%eax),%ecx
10abd2: 75 11 jne 10abe5 <rtems_task_set_note+0x4d><== ALWAYS TAKEN
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
10abd4: a1 14 18 12 00 mov 0x121814,%eax
10abd9: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
10abdf: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4)
10abe3: eb 29 jmp 10ac0e <rtems_task_set_note+0x76>
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
10abe5: 50 push %eax
10abe6: 50 push %eax
10abe7: 8d 45 f4 lea -0xc(%ebp),%eax
10abea: 50 push %eax
10abeb: 51 push %ecx
10abec: e8 df 1a 00 00 call 10c6d0 <_Thread_Get>
switch ( location ) {
10abf1: 83 c4 10 add $0x10,%esp
10abf4: ba 04 00 00 00 mov $0x4,%edx
10abf9: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10abfd: 75 11 jne 10ac10 <rtems_task_set_note+0x78>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
10abff: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax
10ac05: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4)
_Thread_Enable_dispatch();
10ac09: e8 a2 1a 00 00 call 10c6b0 <_Thread_Enable_dispatch>
10ac0e: 31 d2 xor %edx,%edx
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10ac10: 89 d0 mov %edx,%eax
10ac12: 8d 65 f8 lea -0x8(%ebp),%esp
10ac15: 5b pop %ebx
10ac16: 5e pop %esi
10ac17: c9 leave
10ac18: c3 ret
0010a3a8 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
Objects_Id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
10a3a8: 55 push %ebp
10a3a9: 89 e5 mov %esp,%ebp
10a3ab: 56 push %esi
10a3ac: 53 push %ebx
10a3ad: 83 ec 10 sub $0x10,%esp
10a3b0: 8b 5d 0c mov 0xc(%ebp),%ebx
10a3b3: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10a3b6: 85 db test %ebx,%ebx
10a3b8: 74 10 je 10a3ca <rtems_task_set_priority+0x22>
10a3ba: 0f b6 05 e4 b0 11 00 movzbl 0x11b0e4,%eax
10a3c1: ba 13 00 00 00 mov $0x13,%edx
10a3c6: 39 c3 cmp %eax,%ebx
10a3c8: 77 52 ja 10a41c <rtems_task_set_priority+0x74>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
10a3ca: ba 09 00 00 00 mov $0x9,%edx
10a3cf: 85 f6 test %esi,%esi
10a3d1: 74 49 je 10a41c <rtems_task_set_priority+0x74><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10a3d3: 52 push %edx
10a3d4: 52 push %edx
10a3d5: 8d 45 f4 lea -0xc(%ebp),%eax
10a3d8: 50 push %eax
10a3d9: ff 75 08 pushl 0x8(%ebp)
10a3dc: e8 f3 19 00 00 call 10bdd4 <_Thread_Get>
10a3e1: 89 c1 mov %eax,%ecx
switch ( location ) {
10a3e3: 83 c4 10 add $0x10,%esp
10a3e6: ba 04 00 00 00 mov $0x4,%edx
10a3eb: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10a3ef: 75 2b jne 10a41c <rtems_task_set_priority+0x74>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
10a3f1: 8b 40 14 mov 0x14(%eax),%eax
10a3f4: 89 06 mov %eax,(%esi)
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
10a3f6: 85 db test %ebx,%ebx
10a3f8: 74 1b je 10a415 <rtems_task_set_priority+0x6d>
the_thread->real_priority = new_priority;
10a3fa: 89 59 18 mov %ebx,0x18(%ecx)
if ( the_thread->resource_count == 0 ||
10a3fd: 83 79 1c 00 cmpl $0x0,0x1c(%ecx)
10a401: 74 05 je 10a408 <rtems_task_set_priority+0x60>
10a403: 39 59 14 cmp %ebx,0x14(%ecx)
10a406: 76 0d jbe 10a415 <rtems_task_set_priority+0x6d><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, FALSE );
10a408: 50 push %eax
10a409: 6a 00 push $0x0
10a40b: 53 push %ebx
10a40c: 51 push %ecx
10a40d: e8 02 15 00 00 call 10b914 <_Thread_Change_priority>
10a412: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10a415: e8 9a 19 00 00 call 10bdb4 <_Thread_Enable_dispatch>
10a41a: 31 d2 xor %edx,%edx
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a41c: 89 d0 mov %edx,%eax
10a41e: 8d 65 f8 lea -0x8(%ebp),%esp
10a421: 5b pop %ebx
10a422: 5e pop %esi
10a423: c9 leave
10a424: c3 ret
0010a8f0 <rtems_task_variable_add>:
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
10a8f0: 55 push %ebp
10a8f1: 89 e5 mov %esp,%ebp
10a8f3: 57 push %edi
10a8f4: 56 push %esi
10a8f5: 53 push %ebx
10a8f6: 83 ec 1c sub $0x1c,%esp
10a8f9: 8b 75 0c mov 0xc(%ebp),%esi
10a8fc: 8b 7d 10 mov 0x10(%ebp),%edi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
10a8ff: b8 09 00 00 00 mov $0x9,%eax
10a904: 85 f6 test %esi,%esi
10a906: 74 75 je 10a97d <rtems_task_variable_add+0x8d><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
10a908: 50 push %eax
10a909: 50 push %eax
10a90a: 8d 45 f0 lea -0x10(%ebp),%eax
10a90d: 50 push %eax
10a90e: ff 75 08 pushl 0x8(%ebp)
10a911: e8 16 1a 00 00 call 10c32c <_Thread_Get>
10a916: 89 c3 mov %eax,%ebx
switch (location) {
10a918: 83 c4 10 add $0x10,%esp
10a91b: b8 04 00 00 00 mov $0x4,%eax
10a920: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
10a924: 75 57 jne 10a97d <rtems_task_variable_add+0x8d><== NEVER TAKEN
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
10a926: 8b 83 04 01 00 00 mov 0x104(%ebx),%eax
10a92c: eb 0c jmp 10a93a <rtems_task_variable_add+0x4a>
while (tvp) {
if (tvp->ptr == ptr) {
10a92e: 39 70 04 cmp %esi,0x4(%eax)
10a931: 75 05 jne 10a938 <rtems_task_variable_add+0x48>
tvp->dtor = dtor;
10a933: 89 78 10 mov %edi,0x10(%eax)
10a936: eb 3e jmp 10a976 <rtems_task_variable_add+0x86>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
10a938: 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) {
10a93a: 85 c0 test %eax,%eax
10a93c: 75 f0 jne 10a92e <rtems_task_variable_add+0x3e>
}
/*
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
10a93e: 83 ec 0c sub $0xc,%esp
10a941: 6a 14 push $0x14
10a943: e8 31 2a 00 00 call 10d379 <_Workspace_Allocate>
10a948: 89 c2 mov %eax,%edx
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
10a94a: 83 c4 10 add $0x10,%esp
10a94d: 85 c0 test %eax,%eax
10a94f: 75 0c jne 10a95d <rtems_task_variable_add+0x6d>
_Thread_Enable_dispatch();
10a951: e8 b6 19 00 00 call 10c30c <_Thread_Enable_dispatch>
10a956: b8 1a 00 00 00 mov $0x1a,%eax
10a95b: eb 20 jmp 10a97d <rtems_task_variable_add+0x8d>
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
10a95d: 8b 06 mov (%esi),%eax
10a95f: 89 42 08 mov %eax,0x8(%edx)
new->ptr = ptr;
10a962: 89 72 04 mov %esi,0x4(%edx)
new->dtor = dtor;
10a965: 89 7a 10 mov %edi,0x10(%edx)
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
10a968: 8b 83 04 01 00 00 mov 0x104(%ebx),%eax
10a96e: 89 02 mov %eax,(%edx)
the_thread->task_variables = new;
10a970: 89 93 04 01 00 00 mov %edx,0x104(%ebx)
_Thread_Enable_dispatch();
10a976: e8 91 19 00 00 call 10c30c <_Thread_Enable_dispatch>
10a97b: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10a97d: 8d 65 f4 lea -0xc(%ebp),%esp
10a980: 5b pop %ebx
10a981: 5e pop %esi
10a982: 5f pop %edi
10a983: c9 leave
10a984: c3 ret
0010a988 <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
10a988: 55 push %ebp
10a989: 89 e5 mov %esp,%ebp
10a98b: 56 push %esi
10a98c: 53 push %ebx
10a98d: 83 ec 10 sub $0x10,%esp
10a990: 8b 75 0c mov 0xc(%ebp),%esi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
10a993: b8 09 00 00 00 mov $0x9,%eax
10a998: 85 f6 test %esi,%esi
10a99a: 74 64 je 10aa00 <rtems_task_variable_delete+0x78>
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
10a99c: 52 push %edx
10a99d: 52 push %edx
10a99e: 8d 45 f4 lea -0xc(%ebp),%eax
10a9a1: 50 push %eax
10a9a2: ff 75 08 pushl 0x8(%ebp)
10a9a5: e8 82 19 00 00 call 10c32c <_Thread_Get>
10a9aa: 89 c3 mov %eax,%ebx
switch (location) {
10a9ac: 83 c4 10 add $0x10,%esp
10a9af: b8 04 00 00 00 mov $0x4,%eax
10a9b4: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10a9b8: 75 46 jne 10aa00 <rtems_task_variable_delete+0x78><== NEVER TAKEN
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
10a9ba: 8b 93 04 01 00 00 mov 0x104(%ebx),%edx
10a9c0: 31 c0 xor %eax,%eax
10a9c2: eb 2e jmp 10a9f2 <rtems_task_variable_delete+0x6a>
while (tvp) {
if (tvp->ptr == ptr) {
10a9c4: 39 72 04 cmp %esi,0x4(%edx)
10a9c7: 75 25 jne 10a9ee <rtems_task_variable_delete+0x66>
if (prev)
10a9c9: 85 c0 test %eax,%eax
10a9cb: 8b 0a mov (%edx),%ecx
10a9cd: 74 04 je 10a9d3 <rtems_task_variable_delete+0x4b>
prev->next = tvp->next;
10a9cf: 89 08 mov %ecx,(%eax)
10a9d1: eb 06 jmp 10a9d9 <rtems_task_variable_delete+0x51>
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
10a9d3: 89 8b 04 01 00 00 mov %ecx,0x104(%ebx)
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
10a9d9: 50 push %eax
10a9da: 50 push %eax
10a9db: 52 push %edx
10a9dc: 53 push %ebx
10a9dd: e8 8e 00 00 00 call 10aa70 <_RTEMS_Tasks_Invoke_task_variable_dtor>
_Thread_Enable_dispatch();
10a9e2: e8 25 19 00 00 call 10c30c <_Thread_Enable_dispatch>
10a9e7: 31 c0 xor %eax,%eax
10a9e9: 83 c4 10 add $0x10,%esp
10a9ec: eb 12 jmp 10aa00 <rtems_task_variable_delete+0x78>
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
10a9ee: 89 d0 mov %edx,%eax
10a9f0: 8b 12 mov (%edx),%edx
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
10a9f2: 85 d2 test %edx,%edx
10a9f4: 75 ce jne 10a9c4 <rtems_task_variable_delete+0x3c>
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
10a9f6: e8 11 19 00 00 call 10c30c <_Thread_Enable_dispatch>
10a9fb: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10aa00: 8d 65 f8 lea -0x8(%ebp),%esp
10aa03: 5b pop %ebx
10aa04: 5e pop %esi
10aa05: c9 leave
10aa06: c3 ret
0010aa08 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
10aa08: 55 push %ebp
10aa09: 89 e5 mov %esp,%ebp
10aa0b: 56 push %esi
10aa0c: 53 push %ebx
10aa0d: 83 ec 10 sub $0x10,%esp
10aa10: 8b 5d 0c mov 0xc(%ebp),%ebx
10aa13: 8b 75 10 mov 0x10(%ebp),%esi
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
10aa16: 85 db test %ebx,%ebx
10aa18: 74 48 je 10aa62 <rtems_task_variable_get+0x5a>
return RTEMS_INVALID_ADDRESS;
if ( !result )
10aa1a: 85 f6 test %esi,%esi
10aa1c: 74 44 je 10aa62 <rtems_task_variable_get+0x5a>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
10aa1e: 50 push %eax
10aa1f: 50 push %eax
10aa20: 8d 45 f4 lea -0xc(%ebp),%eax
10aa23: 50 push %eax
10aa24: ff 75 08 pushl 0x8(%ebp)
10aa27: e8 00 19 00 00 call 10c32c <_Thread_Get>
10aa2c: 89 c2 mov %eax,%edx
switch (location) {
10aa2e: 83 c4 10 add $0x10,%esp
10aa31: b8 04 00 00 00 mov $0x4,%eax
10aa36: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10aa3a: 75 2b jne 10aa67 <rtems_task_variable_get+0x5f><== NEVER TAKEN
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
10aa3c: 8b 82 04 01 00 00 mov 0x104(%edx),%eax
10aa42: eb 15 jmp 10aa59 <rtems_task_variable_get+0x51>
while (tvp) {
if (tvp->ptr == ptr) {
10aa44: 39 58 04 cmp %ebx,0x4(%eax)
10aa47: 75 0e jne 10aa57 <rtems_task_variable_get+0x4f>
/*
* Should this return the current (i.e not the
* saved) value if `tid' is the current task?
*/
*result = tvp->tval;
10aa49: 8b 40 0c mov 0xc(%eax),%eax
10aa4c: 89 06 mov %eax,(%esi)
_Thread_Enable_dispatch();
10aa4e: e8 b9 18 00 00 call 10c30c <_Thread_Enable_dispatch>
10aa53: 31 c0 xor %eax,%eax
10aa55: eb 10 jmp 10aa67 <rtems_task_variable_get+0x5f>
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
10aa57: 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) {
10aa59: 85 c0 test %eax,%eax
10aa5b: 75 e7 jne 10aa44 <rtems_task_variable_get+0x3c>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
10aa5d: e8 aa 18 00 00 call 10c30c <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
10aa62: b8 09 00 00 00 mov $0x9,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
10aa67: 8d 65 f8 lea -0x8(%ebp),%esp
10aa6a: 5b pop %ebx
10aa6b: 5e pop %esi
10aa6c: c9 leave
10aa6d: c3 ret
0010a150 <rtems_task_wake_when>:
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
10a150: 55 push %ebp
10a151: 89 e5 mov %esp,%ebp
10a153: 53 push %ebx
10a154: 83 ec 04 sub $0x4,%esp
10a157: 8b 5d 08 mov 0x8(%ebp),%ebx
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
10a15a: b8 0b 00 00 00 mov $0xb,%eax
10a15f: 80 3d d8 f4 11 00 00 cmpb $0x0,0x11f4d8
10a166: 0f 84 9e 00 00 00 je 10a20a <rtems_task_wake_when+0xba>
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
10a16c: b8 09 00 00 00 mov $0x9,%eax
10a171: 85 db test %ebx,%ebx
10a173: 0f 84 91 00 00 00 je 10a20a <rtems_task_wake_when+0xba><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
10a179: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
if ( !_TOD_Validate( time_buffer ) )
10a180: 83 ec 0c sub $0xc,%esp
10a183: 53 push %ebx
10a184: e8 d7 f4 ff ff call 109660 <_TOD_Validate>
10a189: 83 c4 10 add $0x10,%esp
10a18c: 84 c0 test %al,%al
10a18e: 74 75 je 10a205 <rtems_task_wake_when+0xb5>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
10a190: 83 ec 0c sub $0xc,%esp
10a193: 53 push %ebx
10a194: e8 5f f4 ff ff call 1095f8 <_TOD_To_seconds>
10a199: 89 c3 mov %eax,%ebx
if ( seconds <= _TOD_Seconds_since_epoch )
10a19b: 83 c4 10 add $0x10,%esp
10a19e: 3b 05 54 f5 11 00 cmp 0x11f554,%eax
10a1a4: 76 5f jbe 10a205 <rtems_task_wake_when+0xb5>
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
10a1a6: a1 c4 f4 11 00 mov 0x11f4c4,%eax
10a1ab: 40 inc %eax
10a1ac: a3 c4 f4 11 00 mov %eax,0x11f4c4
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
10a1b1: 50 push %eax
10a1b2: 50 push %eax
10a1b3: 6a 10 push $0x10
10a1b5: ff 35 84 f5 11 00 pushl 0x11f584
10a1bb: e8 84 20 00 00 call 10c244 <_Thread_Set_state>
_Watchdog_Initialize(
10a1c0: a1 84 f5 11 00 mov 0x11f584,%eax
10a1c5: 8b 50 08 mov 0x8(%eax),%edx
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
10a1c8: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
* @param[in] the_heap is the heap to operate upon
10a1cf: c7 40 64 d8 b8 10 00 movl $0x10b8d8,0x64(%eax)
* @param[in] starting_address is the starting address of the memory for
10a1d6: 89 50 68 mov %edx,0x68(%eax)
* the heap
10a1d9: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax)
* @return TRUE if successfully able to resize the block.
* FALSE if the block can't be resized in place.
*/
bool _Protected_heap_Resize_block(
Heap_Control *the_heap,
void *starting_address,
10a1e0: 2b 1d 54 f5 11 00 sub 0x11f554,%ebx
10a1e6: 89 58 54 mov %ebx,0x54(%eax)
size_t size
);
10a1e9: 5a pop %edx
10a1ea: 59 pop %ecx
10a1eb: 83 c0 48 add $0x48,%eax
10a1ee: 50 push %eax
10a1ef: 68 98 f5 11 00 push $0x11f598
10a1f4: e8 63 26 00 00 call 10c85c <_Watchdog_Insert>
);
_Watchdog_Insert_seconds(
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch
);
_Thread_Enable_dispatch();
10a1f9: e8 56 18 00 00 call 10ba54 <_Thread_Enable_dispatch>
10a1fe: 31 c0 xor %eax,%eax
10a200: 83 c4 10 add $0x10,%esp
10a203: eb 05 jmp 10a20a <rtems_task_wake_when+0xba>
return RTEMS_SUCCESSFUL;
10a205: b8 14 00 00 00 mov $0x14,%eax
}
10a20a: 8b 5d fc mov -0x4(%ebp),%ebx
10a20d: c9 leave
10a20e: c3 ret
001071a0 <rtems_termios_bufsize>:
rtems_status_code rtems_termios_bufsize (
int cbufsize,
int raw_input,
int raw_output
)
{
1071a0: 55 push %ebp <== NOT EXECUTED
1071a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
rtems_termios_cbufsize = cbufsize;
1071a3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
1071a6: a3 1c aa 11 00 mov %eax,0x11aa1c <== NOT EXECUTED
rtems_termios_raw_input_size = raw_input;
1071ab: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
1071ae: a3 20 aa 11 00 mov %eax,0x11aa20 <== NOT EXECUTED
rtems_termios_raw_output_size = raw_output;
1071b3: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
1071b6: a3 24 aa 11 00 mov %eax,0x11aa24 <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
1071bb: 31 c0 xor %eax,%eax <== NOT EXECUTED
1071bd: c9 leave <== NOT EXECUTED
1071be: c3 ret <== NOT EXECUTED
0010833e <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
10833e: 55 push %ebp
10833f: 89 e5 mov %esp,%ebp
108341: 56 push %esi
108342: 53 push %ebx
108343: 8b 75 08 mov 0x8(%ebp),%esi
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
108346: 8b 06 mov (%esi),%eax
108348: 8b 58 28 mov 0x28(%eax),%ebx
rtems_status_code sc;
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
10834b: 50 push %eax
10834c: 6a 00 push $0x0
10834e: 6a 00 push $0x0
108350: ff 35 1c ca 11 00 pushl 0x11ca1c
108356: e8 19 0e 00 00 call 109174 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
10835b: 83 c4 10 add $0x10,%esp
10835e: 85 c0 test %eax,%eax
108360: 75 69 jne 1083cb <rtems_termios_close+0x8d><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
108362: 8b 43 08 mov 0x8(%ebx),%eax
108365: 48 dec %eax
108366: 89 43 08 mov %eax,0x8(%ebx)
108369: 85 c0 test %eax,%eax
10836b: 0f 85 1f 01 00 00 jne 108490 <rtems_termios_close+0x152>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
108371: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
108377: c1 e0 05 shl $0x5,%eax
10837a: 8b 80 98 c7 11 00 mov 0x11c798(%eax),%eax
108380: 85 c0 test %eax,%eax
108382: 74 0b je 10838f <rtems_termios_close+0x51><== ALWAYS TAKEN
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
108384: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108387: 53 push %ebx <== NOT EXECUTED
108388: ff d0 call *%eax <== NOT EXECUTED
10838a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10838d: eb 07 jmp 108396 <rtems_termios_close+0x58><== NOT EXECUTED
}
else {
/*
* default: just flush output buffer
*/
drainOutput (tty);
10838f: 89 d8 mov %ebx,%eax
108391: e8 ec f8 ff ff call 107c82 <drainOutput>
}
if (tty->device.outputUsesInterrupts
108396: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
10839d: 75 35 jne 1083d4 <rtems_termios_close+0x96><== ALWAYS TAKEN
== TERMIOS_TASK_DRIVEN) {
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send(
10839f: 50 push %eax <== NOT EXECUTED
1083a0: 50 push %eax <== NOT EXECUTED
1083a1: 6a 01 push $0x1 <== NOT EXECUTED
1083a3: ff b3 c4 00 00 00 pushl 0xc4(%ebx) <== NOT EXECUTED
1083a9: e8 36 09 00 00 call 108ce4 <rtems_event_send> <== NOT EXECUTED
tty->rxTaskId,
TERMIOS_RX_TERMINATE_EVENT);
if (sc != RTEMS_SUCCESSFUL)
1083ae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1083b1: 85 c0 test %eax,%eax <== NOT EXECUTED
1083b3: 75 16 jne 1083cb <rtems_termios_close+0x8d><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_event_send(
1083b5: 51 push %ecx <== NOT EXECUTED
1083b6: 51 push %ecx <== NOT EXECUTED
1083b7: 6a 01 push $0x1 <== NOT EXECUTED
1083b9: ff b3 c8 00 00 00 pushl 0xc8(%ebx) <== NOT EXECUTED
1083bf: e8 20 09 00 00 call 108ce4 <rtems_event_send> <== NOT EXECUTED
tty->txTaskId,
TERMIOS_TX_TERMINATE_EVENT);
if (sc != RTEMS_SUCCESSFUL)
1083c4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1083c7: 85 c0 test %eax,%eax <== NOT EXECUTED
1083c9: 74 09 je 1083d4 <rtems_termios_close+0x96><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
1083cb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1083ce: 50 push %eax <== NOT EXECUTED
1083cf: e8 b8 13 00 00 call 10978c <rtems_fatal_error_occurred><== NOT EXECUTED
}
if (tty->device.lastClose)
1083d4: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax
1083da: 85 c0 test %eax,%eax
1083dc: 74 0d je 1083eb <rtems_termios_close+0xad><== NEVER TAKEN
(*tty->device.lastClose)(tty->major, tty->minor, arg);
1083de: 52 push %edx
1083df: 56 push %esi
1083e0: ff 73 10 pushl 0x10(%ebx)
1083e3: ff 73 0c pushl 0xc(%ebx)
1083e6: ff d0 call *%eax
1083e8: 83 c4 10 add $0x10,%esp
if (tty->forw == NULL) {
1083eb: 8b 13 mov (%ebx),%edx
1083ed: 85 d2 test %edx,%edx
1083ef: 8b 43 04 mov 0x4(%ebx),%eax
1083f2: 75 11 jne 108405 <rtems_termios_close+0xc7><== NEVER TAKEN
rtems_termios_ttyTail = tty->back;
1083f4: a3 20 ca 11 00 mov %eax,0x11ca20
if ( rtems_termios_ttyTail != NULL ) {
1083f9: 85 c0 test %eax,%eax
1083fb: 74 0b je 108408 <rtems_termios_close+0xca><== ALWAYS TAKEN
rtems_termios_ttyTail->forw = NULL;
1083fd: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED
108403: eb 03 jmp 108408 <rtems_termios_close+0xca><== NOT EXECUTED
}
}
else {
tty->forw->back = tty->back;
108405: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED
}
if (tty->back == NULL) {
108408: 8b 53 04 mov 0x4(%ebx),%edx
10840b: 85 d2 test %edx,%edx
10840d: 8b 03 mov (%ebx),%eax
10840f: 75 12 jne 108423 <rtems_termios_close+0xe5><== NEVER TAKEN
rtems_termios_ttyHead = tty->forw;
108411: a3 24 ca 11 00 mov %eax,0x11ca24
if ( rtems_termios_ttyHead != NULL ) {
108416: 85 c0 test %eax,%eax
108418: 74 0b je 108425 <rtems_termios_close+0xe7><== ALWAYS TAKEN
rtems_termios_ttyHead->back = NULL;
10841a: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) <== NOT EXECUTED
108421: eb 02 jmp 108425 <rtems_termios_close+0xe7><== NOT EXECUTED
}
}
else {
tty->back->forw = tty->forw;
108423: 89 02 mov %eax,(%edx) <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
108425: 83 ec 0c sub $0xc,%esp
108428: ff 73 14 pushl 0x14(%ebx)
10842b: e8 b4 0c 00 00 call 1090e4 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
108430: 58 pop %eax
108431: ff 73 18 pushl 0x18(%ebx)
108434: e8 ab 0c 00 00 call 1090e4 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
108439: 58 pop %eax
10843a: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
108440: e8 9f 0c 00 00 call 1090e4 <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
108445: 83 c4 10 add $0x10,%esp
108448: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx)
10844f: 74 09 je 10845a <rtems_termios_close+0x11c><== ALWAYS TAKEN
108451: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) <== NOT EXECUTED
108458: 75 0e jne 108468 <rtems_termios_close+0x12a><== NOT EXECUTED
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
10845a: 83 ec 0c sub $0xc,%esp
10845d: ff 73 68 pushl 0x68(%ebx)
108460: e8 7f 0c 00 00 call 1090e4 <rtems_semaphore_delete>
108465: 83 c4 10 add $0x10,%esp
free (tty->rawInBuf.theBuf);
108468: 83 ec 0c sub $0xc,%esp
10846b: ff 73 58 pushl 0x58(%ebx)
10846e: e8 05 e0 ff ff call 106478 <free>
free (tty->rawOutBuf.theBuf);
108473: 5e pop %esi
108474: ff 73 7c pushl 0x7c(%ebx)
108477: e8 fc df ff ff call 106478 <free>
free (tty->cbuf);
10847c: 59 pop %ecx
10847d: ff 73 1c pushl 0x1c(%ebx)
108480: e8 f3 df ff ff call 106478 <free>
free (tty);
108485: 89 1c 24 mov %ebx,(%esp)
108488: e8 eb df ff ff call 106478 <free>
10848d: 83 c4 10 add $0x10,%esp
}
rtems_semaphore_release (rtems_termios_ttyMutex);
108490: 83 ec 0c sub $0xc,%esp
108493: ff 35 1c ca 11 00 pushl 0x11ca1c
108499: e8 be 0d 00 00 call 10925c <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
10849e: 31 c0 xor %eax,%eax
1084a0: 8d 65 f8 lea -0x8(%ebp),%esp
1084a3: 5b pop %ebx
1084a4: 5e pop %esi
1084a5: c9 leave
1084a6: c3 ret
001073a7 <rtems_termios_dequeue_characters>:
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
1073a7: 55 push %ebp
1073a8: 89 e5 mov %esp,%ebp
1073aa: 83 ec 08 sub $0x8,%esp
1073ad: 8b 55 08 mov 0x8(%ebp),%edx
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
1073b0: 8b 45 0c mov 0xc(%ebp),%eax
1073b3: 01 82 90 00 00 00 add %eax,0x90(%edx)
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
1073b9: 83 ba b4 00 00 00 02 cmpl $0x2,0xb4(%edx)
1073c0: 75 1f jne 1073e1 <rtems_termios_dequeue_characters+0x3a><== ALWAYS TAKEN
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId,
1073c2: 50 push %eax <== NOT EXECUTED
1073c3: 50 push %eax <== NOT EXECUTED
1073c4: 6a 02 push $0x2 <== NOT EXECUTED
1073c6: ff b2 c8 00 00 00 pushl 0xc8(%edx) <== NOT EXECUTED
1073cc: e8 13 19 00 00 call 108ce4 <rtems_event_send> <== NOT EXECUTED
TERMIOS_TX_START_EVENT);
if (sc != RTEMS_SUCCESSFUL)
1073d1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1073d4: 85 c0 test %eax,%eax <== NOT EXECUTED
1073d6: 74 2f je 107407 <rtems_termios_dequeue_characters+0x60><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
1073d8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1073db: 50 push %eax <== NOT EXECUTED
1073dc: e8 ab 23 00 00 call 10978c <rtems_fatal_error_occurred><== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
else if (tty->t_line == PPPDISC ) {
1073e1: 83 ba cc 00 00 00 05 cmpl $0x5,0xcc(%edx)
1073e8: 75 14 jne 1073fe <rtems_termios_dequeue_characters+0x57><== ALWAYS TAKEN
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
1073ea: a1 48 c8 11 00 mov 0x11c848,%eax <== NOT EXECUTED
1073ef: 85 c0 test %eax,%eax <== NOT EXECUTED
1073f1: 74 14 je 107407 <rtems_termios_dequeue_characters+0x60><== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
1073f3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1073f6: 52 push %edx <== NOT EXECUTED
1073f7: ff d0 call *%eax <== NOT EXECUTED
1073f9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1073fc: eb 09 jmp 107407 <rtems_termios_dequeue_characters+0x60><== NOT EXECUTED
}
return 0; /* nothing to output in IRQ... */
}
else {
return rtems_termios_refill_transmitter(tty);
1073fe: 89 55 08 mov %edx,0x8(%ebp)
}
}
107401: c9 leave
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
else {
return rtems_termios_refill_transmitter(tty);
107402: e9 d3 fd ff ff jmp 1071da <rtems_termios_refill_transmitter>
}
}
107407: 31 c0 xor %eax,%eax
107409: c9 leave <== NOT EXECUTED
10740a: c3 ret <== NOT EXECUTED
0010740b <rtems_termios_enqueue_raw_characters>:
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, char *buf, int len)
{
10740b: 55 push %ebp <== NOT EXECUTED
10740c: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10740e: 57 push %edi <== NOT EXECUTED
10740f: 56 push %esi <== NOT EXECUTED
107410: 53 push %ebx <== NOT EXECUTED
107411: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED
107414: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
107417: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED
10741d: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
107420: 83 b8 a4 c7 11 00 00 cmpl $0x0,0x11c7a4(%eax) <== NOT EXECUTED
107427: 75 37 jne 107460 <rtems_termios_enqueue_raw_characters+0x55><== NOT EXECUTED
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
107429: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED
10742c: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
10742f: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED
107432: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED
107435: 31 ff xor %edi,%edi <== NOT EXECUTED
107437: c6 45 ea 00 movb $0x0,-0x16(%ebp) <== NOT EXECUTED
10743b: e9 27 02 00 00 jmp 107667 <rtems_termios_enqueue_raw_characters+0x25c><== NOT EXECUTED
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
107440: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
107443: 0f be 11 movsbl (%ecx),%edx <== NOT EXECUTED
107446: 41 inc %ecx <== NOT EXECUTED
107447: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
10744a: 56 push %esi <== NOT EXECUTED
10744b: 56 push %esi <== NOT EXECUTED
10744c: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED
107452: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
107455: 53 push %ebx <== NOT EXECUTED
107456: 52 push %edx <== NOT EXECUTED
107457: ff 90 a4 c7 11 00 call *0x11c7a4(%eax) <== NOT EXECUTED
10745d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
107460: ff 4d 10 decl 0x10(%ebp) <== NOT EXECUTED
107463: 83 7d 10 ff cmpl $0xffffffff,0x10(%ebp) <== NOT EXECUTED
107467: 75 d7 jne 107440 <rtems_termios_enqueue_raw_characters+0x35><== NOT EXECUTED
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
107469: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx) <== NOT EXECUTED
107470: 0f 85 11 02 00 00 jne 107687 <rtems_termios_enqueue_raw_characters+0x27c><== NOT EXECUTED
107476: 8b 93 dc 00 00 00 mov 0xdc(%ebx),%edx <== NOT EXECUTED
10747c: 85 d2 test %edx,%edx <== NOT EXECUTED
10747e: 0f 84 03 02 00 00 je 107687 <rtems_termios_enqueue_raw_characters+0x27c><== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
107484: 51 push %ecx <== NOT EXECUTED
107485: 51 push %ecx <== NOT EXECUTED
107486: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED
10748c: 8d 43 30 lea 0x30(%ebx),%eax <== NOT EXECUTED
10748f: 50 push %eax <== NOT EXECUTED
107490: ff d2 call *%edx <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
107492: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED
107499: 00 00 00
10749c: 31 ff xor %edi,%edi <== NOT EXECUTED
10749e: e9 df 01 00 00 jmp 107682 <rtems_termios_enqueue_raw_characters+0x277><== NOT EXECUTED
}
return 0;
}
while (len--) {
c = *buf++;
1074a3: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
1074a6: 8a 00 mov (%eax),%al <== NOT EXECUTED
1074a8: 88 45 eb mov %al,-0x15(%ebp) <== NOT EXECUTED
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
1074ab: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1074b1: f6 c4 02 test $0x2,%ah <== NOT EXECUTED
1074b4: 74 43 je 1074f9 <rtems_termios_enqueue_raw_characters+0xee><== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
1074b6: 0f be 55 eb movsbl -0x15(%ebp),%edx <== NOT EXECUTED
1074ba: 0f b6 43 4a movzbl 0x4a(%ebx),%eax <== NOT EXECUTED
1074be: 39 c2 cmp %eax,%edx <== NOT EXECUTED
1074c0: 75 1e jne 1074e0 <rtems_termios_enqueue_raw_characters+0xd5><== NOT EXECUTED
if (c == tty->termios.c_cc[VSTART]) {
1074c2: 0f b6 43 49 movzbl 0x49(%ebx),%eax <== NOT EXECUTED
1074c6: 39 c2 cmp %eax,%edx <== NOT EXECUTED
1074c8: 75 0b jne 1074d5 <rtems_termios_enqueue_raw_characters+0xca><== NOT EXECUTED
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
1074ca: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1074d0: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED
1074d3: eb 1c jmp 1074f1 <rtems_termios_enqueue_raw_characters+0xe6><== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
1074d5: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1074db: 83 c8 10 or $0x10,%eax <== NOT EXECUTED
1074de: eb 11 jmp 1074f1 <rtems_termios_enqueue_raw_characters+0xe6><== NOT EXECUTED
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
1074e0: 0f b6 43 49 movzbl 0x49(%ebx),%eax <== NOT EXECUTED
1074e4: 39 c2 cmp %eax,%edx <== NOT EXECUTED
1074e6: 75 11 jne 1074f9 <rtems_termios_enqueue_raw_characters+0xee><== NOT EXECUTED
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
1074e8: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1074ee: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED
1074f1: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
1074f7: eb 06 jmp 1074ff <rtems_termios_enqueue_raw_characters+0xf4><== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
1074f9: 80 7d ea 00 cmpb $0x0,-0x16(%ebp) <== NOT EXECUTED
1074fd: 74 55 je 107554 <rtems_termios_enqueue_raw_characters+0x149><== NOT EXECUTED
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
1074ff: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
107505: 83 e0 30 and $0x30,%eax <== NOT EXECUTED
107508: c6 45 ea 01 movb $0x1,-0x16(%ebp) <== NOT EXECUTED
10750c: 83 f8 20 cmp $0x20,%eax <== NOT EXECUTED
10750f: 0f 85 4f 01 00 00 jne 107664 <rtems_termios_enqueue_raw_characters+0x259><== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
107515: 9c pushf <== NOT EXECUTED
107516: fa cli <== NOT EXECUTED
107517: 5e pop %esi <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
107518: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10751e: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
107521: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
107527: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
10752e: 74 19 je 107549 <rtems_termios_enqueue_raw_characters+0x13e><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
107530: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED
107536: 52 push %edx <== NOT EXECUTED
107537: 6a 01 push $0x1 <== NOT EXECUTED
107539: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED
10753c: 50 push %eax <== NOT EXECUTED
10753d: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
107540: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
107546: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
107549: 56 push %esi <== NOT EXECUTED
10754a: 9d popf <== NOT EXECUTED
10754b: c6 45 ea 01 movb $0x1,-0x16(%ebp) <== NOT EXECUTED
10754f: e9 10 01 00 00 jmp 107664 <rtems_termios_enqueue_raw_characters+0x259><== NOT EXECUTED
}
}
else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
107554: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED
107557: 8b 4b 64 mov 0x64(%ebx),%ecx <== NOT EXECUTED
10755a: 40 inc %eax <== NOT EXECUTED
10755b: 31 d2 xor %edx,%edx <== NOT EXECUTED
10755d: f7 f1 div %ecx <== NOT EXECUTED
10755f: 89 d6 mov %edx,%esi <== NOT EXECUTED
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
107561: 9c pushf <== NOT EXECUTED
107562: fa cli <== NOT EXECUTED
107563: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
107566: 8b 4b 5c mov 0x5c(%ebx),%ecx <== NOT EXECUTED
107569: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED
10756c: 8b 53 64 mov 0x64(%ebx),%edx <== NOT EXECUTED
10756f: 29 c8 sub %ecx,%eax <== NOT EXECUTED
107571: 01 f0 add %esi,%eax <== NOT EXECUTED
107573: 89 d1 mov %edx,%ecx <== NOT EXECUTED
107575: 31 d2 xor %edx,%edx <== NOT EXECUTED
107577: f7 f1 div %ecx <== NOT EXECUTED
107579: 3b 93 c0 00 00 00 cmp 0xc0(%ebx),%edx <== NOT EXECUTED
10757f: 0f 86 98 00 00 00 jbe 10761d <rtems_termios_enqueue_raw_characters+0x212><== NOT EXECUTED
107585: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10758b: a8 01 test $0x1,%al <== NOT EXECUTED
10758d: 0f 85 8a 00 00 00 jne 10761d <rtems_termios_enqueue_raw_characters+0x212><== NOT EXECUTED
% tty->rawInBuf.Size)
> tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
107593: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
107599: 83 c8 01 or $0x1,%eax <== NOT EXECUTED
10759c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
1075a2: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1075a8: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED
1075ad: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED
1075b2: 75 33 jne 1075e7 <rtems_termios_enqueue_raw_characters+0x1dc><== NOT EXECUTED
== (FL_MDXOF ) ){
if ((tty->flow_ctrl & FL_OSTOP) ||
1075b4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1075ba: a8 20 test $0x20,%al <== NOT EXECUTED
1075bc: 75 09 jne 1075c7 <rtems_termios_enqueue_raw_characters+0x1bc><== NOT EXECUTED
1075be: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
1075c5: 75 56 jne 10761d <rtems_termios_enqueue_raw_characters+0x212><== NOT EXECUTED
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
1075c7: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1075cd: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
1075d0: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
(*tty->device.write)(tty->minor,
1075d6: 51 push %ecx <== NOT EXECUTED
1075d7: 6a 01 push $0x1 <== NOT EXECUTED
1075d9: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED
1075dc: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
1075df: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
1075e5: eb 33 jmp 10761a <rtems_termios_enqueue_raw_characters+0x20f><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]),
1);
}
}
else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF))
1075e7: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1075ed: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED
1075f2: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED
1075f7: 75 24 jne 10761d <rtems_termios_enqueue_raw_characters+0x212><== NOT EXECUTED
== (FL_MDRTS ) ) {
tty->flow_ctrl |= FL_IRTSOFF;
1075f9: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1075ff: 83 c8 04 or $0x4,%eax <== NOT EXECUTED
107602: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
107608: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax <== NOT EXECUTED
10760e: 85 c0 test %eax,%eax <== NOT EXECUTED
107610: 74 0b je 10761d <rtems_termios_enqueue_raw_characters+0x212><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
107612: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107615: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
107618: ff d0 call *%eax <== NOT EXECUTED
10761a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
10761d: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED
107620: 9d popf <== NOT EXECUTED
if (newTail == tty->rawInBuf.Head) {
107621: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED
107624: 39 c6 cmp %eax,%esi <== NOT EXECUTED
107626: 75 03 jne 10762b <rtems_termios_enqueue_raw_characters+0x220><== NOT EXECUTED
dropped++;
107628: 47 inc %edi <== NOT EXECUTED
107629: eb 39 jmp 107664 <rtems_termios_enqueue_raw_characters+0x259><== NOT EXECUTED
}
else {
tty->rawInBuf.theBuf[newTail] = c;
10762b: 8b 43 58 mov 0x58(%ebx),%eax <== NOT EXECUTED
10762e: 8a 55 eb mov -0x15(%ebp),%dl <== NOT EXECUTED
107631: 88 14 30 mov %dl,(%eax,%esi,1) <== NOT EXECUTED
tty->rawInBuf.Tail = newTail;
107634: 89 73 60 mov %esi,0x60(%ebx) <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
107637: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx) <== NOT EXECUTED
10763e: 75 24 jne 107664 <rtems_termios_enqueue_raw_characters+0x259><== NOT EXECUTED
107640: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax <== NOT EXECUTED
107646: 85 c0 test %eax,%eax <== NOT EXECUTED
107648: 74 1a je 107664 <rtems_termios_enqueue_raw_characters+0x259><== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
10764a: 52 push %edx <== NOT EXECUTED
10764b: 52 push %edx <== NOT EXECUTED
10764c: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED
107652: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED
107655: ff d0 call *%eax <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
107657: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED
10765e: 00 00 00
107661: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
return 0;
}
while (len--) {
c = *buf++;
107664: ff 45 0c incl 0xc(%ebp) <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
107667: ff 4d 10 decl 0x10(%ebp) <== NOT EXECUTED
10766a: 83 7d 10 ff cmpl $0xffffffff,0x10(%ebp) <== NOT EXECUTED
10766e: 0f 85 2f fe ff ff jne 1074a3 <rtems_termios_enqueue_raw_characters+0x98><== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
}
}
}
tty->rawInBufDropped += dropped;
107674: 01 7b 78 add %edi,0x78(%ebx) <== NOT EXECUTED
rtems_semaphore_release (tty->rawInBuf.Semaphore);
107677: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10767a: ff 73 68 pushl 0x68(%ebx) <== NOT EXECUTED
10767d: e8 da 1b 00 00 call 10925c <rtems_semaphore_release><== NOT EXECUTED
107682: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107685: eb 02 jmp 107689 <rtems_termios_enqueue_raw_characters+0x27e><== NOT EXECUTED
return dropped;
107687: 31 ff xor %edi,%edi <== NOT EXECUTED
}
107689: 89 f8 mov %edi,%eax <== NOT EXECUTED
10768b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10768e: 5b pop %ebx <== NOT EXECUTED
10768f: 5e pop %esi <== NOT EXECUTED
107690: 5f pop %edi <== NOT EXECUTED
107691: c9 leave <== NOT EXECUTED
107692: c3 ret <== NOT EXECUTED
00107164 <rtems_termios_initialize>:
struct rtems_termios_tty *rtems_termios_ttyTail;
rtems_id rtems_termios_ttyMutex;
void
rtems_termios_initialize (void)
{
107164: 55 push %ebp
107165: 89 e5 mov %esp,%ebp
107167: 83 ec 08 sub $0x8,%esp
rtems_status_code sc;
/*
* Create the mutex semaphore for the tty list
*/
if (!rtems_termios_ttyMutex) {
10716a: 83 3d 1c ca 11 00 00 cmpl $0x0,0x11ca1c
107171: 75 28 jne 10719b <rtems_termios_initialize+0x37><== NEVER TAKEN
sc = rtems_semaphore_create (
107173: 83 ec 0c sub $0xc,%esp
107176: 68 1c ca 11 00 push $0x11ca1c
10717b: 6a 00 push $0x0
10717d: 6a 54 push $0x54
10717f: 6a 01 push $0x1
107181: 68 69 6d 52 54 push $0x54526d69
107186: e8 b5 1d 00 00 call 108f40 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'm', 'i'),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_termios_ttyMutex);
if (sc != RTEMS_SUCCESSFUL)
10718b: 83 c4 20 add $0x20,%esp
10718e: 85 c0 test %eax,%eax
107190: 74 09 je 10719b <rtems_termios_initialize+0x37><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
107192: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107195: 50 push %eax <== NOT EXECUTED
107196: e8 f1 25 00 00 call 10978c <rtems_fatal_error_occurred><== NOT EXECUTED
}
}
10719b: c9 leave
10719c: c3 ret
00107fe9 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
107fe9: 55 push %ebp <== NOT EXECUTED
107fea: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107fec: 57 push %edi <== NOT EXECUTED
107fed: 56 push %esi <== NOT EXECUTED
107fee: 53 push %ebx <== NOT EXECUTED
107fef: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
107ff2: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
107ff5: 8b 02 mov (%edx),%eax <== NOT EXECUTED
107ff7: 8b 58 28 mov 0x28(%eax),%ebx <== NOT EXECUTED
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
107ffa: 8b 72 08 mov 0x8(%edx),%esi <== NOT EXECUTED
rtems_status_code sc;
args->ioctl_return = 0;
107ffd: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
108004: 6a 00 push $0x0 <== NOT EXECUTED
108006: 6a 00 push $0x0 <== NOT EXECUTED
108008: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED
10800b: e8 64 11 00 00 call 109174 <rtems_semaphore_obtain><== NOT EXECUTED
108010: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
108013: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108016: 85 c0 test %eax,%eax <== NOT EXECUTED
108018: 74 0b je 108025 <rtems_termios_ioctl+0x3c><== NOT EXECUTED
args->ioctl_return = sc;
10801a: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
10801d: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED
108020: e9 0e 03 00 00 jmp 108333 <rtems_termios_ioctl+0x34a><== NOT EXECUTED
return sc;
}
switch (args->command) {
108025: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
108028: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED
10802b: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED
10802e: 0f 84 56 02 00 00 je 10828a <rtems_termios_ioctl+0x2a1><== NOT EXECUTED
108034: 77 10 ja 108046 <rtems_termios_ioctl+0x5d><== NOT EXECUTED
108036: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED
108039: 74 75 je 1080b0 <rtems_termios_ioctl+0xc7><== NOT EXECUTED
10803b: 0f 87 27 02 00 00 ja 108268 <rtems_termios_ioctl+0x27f><== NOT EXECUTED
108041: 48 dec %eax <== NOT EXECUTED
108042: 75 2f jne 108073 <rtems_termios_ioctl+0x8a><== NOT EXECUTED
108044: eb 55 jmp 10809b <rtems_termios_ioctl+0xb2><== NOT EXECUTED
108046: 3d 7f 66 04 40 cmp $0x4004667f,%eax <== NOT EXECUTED
10804b: 0f 84 ae 02 00 00 je 1082ff <rtems_termios_ioctl+0x316><== NOT EXECUTED
108051: 77 0a ja 10805d <rtems_termios_ioctl+0x74><== NOT EXECUTED
108053: 83 f8 05 cmp $0x5,%eax <== NOT EXECUTED
108056: 75 1b jne 108073 <rtems_termios_ioctl+0x8a><== NOT EXECUTED
108058: e9 17 02 00 00 jmp 108274 <rtems_termios_ioctl+0x28b><== NOT EXECUTED
10805d: 3d 1a 74 04 40 cmp $0x4004741a,%eax <== NOT EXECUTED
108062: 0f 84 87 02 00 00 je 1082ef <rtems_termios_ioctl+0x306><== NOT EXECUTED
108068: 3d 1b 74 04 80 cmp $0x8004741b,%eax <== NOT EXECUTED
10806d: 0f 84 2a 02 00 00 je 10829d <rtems_termios_ioctl+0x2b4><== NOT EXECUTED
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
108073: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED
108079: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
10807c: 8b 80 ac c7 11 00 mov 0x11c7ac(%eax),%eax <== NOT EXECUTED
108082: c7 45 e0 0a 00 00 00 movl $0xa,-0x20(%ebp) <== NOT EXECUTED
108089: 85 c0 test %eax,%eax <== NOT EXECUTED
10808b: 0f 84 8b 02 00 00 je 10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
108091: 52 push %edx <== NOT EXECUTED
108092: 52 push %edx <== NOT EXECUTED
108093: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
108096: e9 49 02 00 00 jmp 1082e4 <rtems_termios_ioctl+0x2fb><== NOT EXECUTED
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
10809b: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
10809e: 8b 79 08 mov 0x8(%ecx),%edi <== NOT EXECUTED
1080a1: 8d 73 30 lea 0x30(%ebx),%esi <== NOT EXECUTED
1080a4: b9 09 00 00 00 mov $0x9,%ecx <== NOT EXECUTED
1080a9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
1080ab: e9 6c 02 00 00 jmp 10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
1080b0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
1080b3: 8b 70 08 mov 0x8(%eax),%esi <== NOT EXECUTED
1080b6: 8d 7b 30 lea 0x30(%ebx),%edi <== NOT EXECUTED
1080b9: b9 09 00 00 00 mov $0x9,%ecx <== NOT EXECUTED
1080be: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
1080c0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1080c6: f6 c4 02 test $0x2,%ah <== NOT EXECUTED
1080c9: 74 57 je 108122 <rtems_termios_ioctl+0x139><== NOT EXECUTED
1080cb: f6 43 31 04 testb $0x4,0x31(%ebx) <== NOT EXECUTED
1080cf: 75 51 jne 108122 <rtems_termios_ioctl+0x139><== NOT EXECUTED
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
1080d1: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1080d7: 25 ef fd ff ff and $0xfffffdef,%eax <== NOT EXECUTED
1080dc: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
1080e2: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1080e8: a8 20 test $0x20,%al <== NOT EXECUTED
1080ea: 74 36 je 108122 <rtems_termios_ioctl+0x139><== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
1080ec: 9c pushf <== NOT EXECUTED
1080ed: fa cli <== NOT EXECUTED
1080ee: 5e pop %esi <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
1080ef: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1080f5: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
1080f8: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
1080fe: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
108105: 74 19 je 108120 <rtems_termios_ioctl+0x137><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
108107: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED
10810d: 57 push %edi <== NOT EXECUTED
10810e: 6a 01 push $0x1 <== NOT EXECUTED
108110: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED
108113: 50 push %eax <== NOT EXECUTED
108114: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
108117: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
10811d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
108120: 56 push %esi <== NOT EXECUTED
108121: 9d popf <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) &&
108122: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108128: f6 c4 04 test $0x4,%ah <== NOT EXECUTED
10812b: 74 24 je 108151 <rtems_termios_ioctl+0x168><== NOT EXECUTED
10812d: f6 43 31 10 testb $0x10,0x31(%ebx) <== NOT EXECUTED
108131: 75 1e jne 108151 <rtems_termios_ioctl+0x168><== NOT EXECUTED
!(tty->termios.c_iflag & IXOFF)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
108133: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108139: 80 e4 fb and $0xfb,%ah <== NOT EXECUTED
10813c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
108142: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108148: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED
10814b: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) &&
108151: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108157: f6 c4 01 test $0x1,%ah <== NOT EXECUTED
10815a: 74 43 je 10819f <rtems_termios_ioctl+0x1b6><== NOT EXECUTED
10815c: 83 7b 38 00 cmpl $0x0,0x38(%ebx) <== NOT EXECUTED
108160: 78 3d js 10819f <rtems_termios_ioctl+0x1b6><== NOT EXECUTED
!(tty->termios.c_cflag & CRTSCTS)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
108162: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108168: 80 e4 fe and $0xfe,%ah <== NOT EXECUTED
10816b: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) &&
108171: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108177: a8 04 test $0x4,%al <== NOT EXECUTED
108179: 74 15 je 108190 <rtems_termios_ioctl+0x1a7><== NOT EXECUTED
10817b: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED
108181: 85 c0 test %eax,%eax <== NOT EXECUTED
108183: 74 0b je 108190 <rtems_termios_ioctl+0x1a7><== NOT EXECUTED
(tty->device.startRemoteTx != NULL)) {
tty->device.startRemoteTx(tty->minor);
108185: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108188: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10818b: ff d0 call *%eax <== NOT EXECUTED
10818d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
108190: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108196: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED
108199: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
10819f: 83 7b 38 00 cmpl $0x0,0x38(%ebx) <== NOT EXECUTED
1081a3: 79 0f jns 1081b4 <rtems_termios_ioctl+0x1cb><== NOT EXECUTED
tty->flow_ctrl |= FL_MDRTS;
1081a5: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1081ab: 80 cc 01 or $0x1,%ah <== NOT EXECUTED
1081ae: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
1081b4: f6 43 31 10 testb $0x10,0x31(%ebx) <== NOT EXECUTED
1081b8: 74 0f je 1081c9 <rtems_termios_ioctl+0x1e0><== NOT EXECUTED
tty->flow_ctrl |= FL_MDXOF;
1081ba: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1081c0: 80 cc 04 or $0x4,%ah <== NOT EXECUTED
1081c3: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
1081c9: f6 43 31 04 testb $0x4,0x31(%ebx) <== NOT EXECUTED
1081cd: 74 0f je 1081de <rtems_termios_ioctl+0x1f5><== NOT EXECUTED
tty->flow_ctrl |= FL_MDXON;
1081cf: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1081d5: 80 cc 02 or $0x2,%ah <== NOT EXECUTED
1081d8: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
tty->termios = *(struct termios *)args->buffer;
/* check for and process change in flow control options */
termios_set_flowctrl(tty);
if (tty->termios.c_lflag & ICANON) {
1081de: f6 43 3c 02 testb $0x2,0x3c(%ebx) <== NOT EXECUTED
1081e2: 75 45 jne 108229 <rtems_termios_ioctl+0x240><== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
}
else {
rtems_interval ticksPerSecond;
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_PER_SECOND, &ticksPerSecond);
1081e4: 56 push %esi <== NOT EXECUTED
1081e5: 56 push %esi <== NOT EXECUTED
1081e6: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED
1081e9: 50 push %eax <== NOT EXECUTED
1081ea: 6a 03 push $0x3 <== NOT EXECUTED
1081ec: e8 93 07 00 00 call 108984 <rtems_clock_get> <== NOT EXECUTED
tty->vtimeTicks = tty->termios.c_cc[VTIME] * ticksPerSecond / 10;
1081f1: 0f b6 43 46 movzbl 0x46(%ebx),%eax <== NOT EXECUTED
1081f5: 0f af 45 f0 imul -0x10(%ebp),%eax <== NOT EXECUTED
1081f9: b9 0a 00 00 00 mov $0xa,%ecx <== NOT EXECUTED
1081fe: 31 d2 xor %edx,%edx <== NOT EXECUTED
108200: f7 f1 div %ecx <== NOT EXECUTED
108202: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED
if (tty->termios.c_cc[VTIME]) {
108205: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108208: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED
10820c: 74 15 je 108223 <rtems_termios_ioctl+0x23a><== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
10820e: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
108215: 89 43 70 mov %eax,0x70(%ebx) <== NOT EXECUTED
if (tty->termios.c_cc[VMIN])
108218: 80 7b 47 00 cmpb $0x0,0x47(%ebx) <== NOT EXECUTED
10821c: 75 19 jne 108237 <rtems_termios_ioctl+0x24e><== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
10821e: 89 43 74 mov %eax,0x74(%ebx) <== NOT EXECUTED
108221: eb 24 jmp 108247 <rtems_termios_ioctl+0x25e><== NOT EXECUTED
}
else {
if (tty->termios.c_cc[VMIN]) {
108223: 80 7b 47 00 cmpb $0x0,0x47(%ebx) <== NOT EXECUTED
108227: 74 17 je 108240 <rtems_termios_ioctl+0x257><== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
108229: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
108230: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
108237: c7 43 74 00 00 00 00 movl $0x0,0x74(%ebx) <== NOT EXECUTED
10823e: eb 07 jmp 108247 <rtems_termios_ioctl+0x25e><== NOT EXECUTED
}
else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
108240: c7 43 6c 01 00 00 00 movl $0x1,0x6c(%ebx) <== NOT EXECUTED
}
}
}
if (tty->device.setAttributes)
108247: 8b 93 a8 00 00 00 mov 0xa8(%ebx),%edx <== NOT EXECUTED
10824d: 85 d2 test %edx,%edx <== NOT EXECUTED
10824f: 0f 84 c7 00 00 00 je 10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
(*tty->device.setAttributes)(tty->minor, &tty->termios);
108255: 51 push %ecx <== NOT EXECUTED
108256: 51 push %ecx <== NOT EXECUTED
108257: 8d 43 30 lea 0x30(%ebx),%eax <== NOT EXECUTED
10825a: 50 push %eax <== NOT EXECUTED
10825b: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10825e: ff d2 call *%edx <== NOT EXECUTED
108260: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108263: e9 b4 00 00 00 jmp 10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
108268: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10826a: e8 13 fa ff ff call 107c82 <drainOutput> <== NOT EXECUTED
10826f: e9 a8 00 00 00 jmp 10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
108274: 8b 16 mov (%esi),%edx <== NOT EXECUTED
108276: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED
108279: 89 83 d8 00 00 00 mov %eax,0xd8(%ebx) <== NOT EXECUTED
10827f: 89 93 d4 00 00 00 mov %edx,0xd4(%ebx) <== NOT EXECUTED
108285: e9 92 00 00 00 jmp 10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
break;
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
10828a: 8b 16 mov (%esi),%edx <== NOT EXECUTED
10828c: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED
10828f: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx) <== NOT EXECUTED
108295: 89 93 dc 00 00 00 mov %edx,0xdc(%ebx) <== NOT EXECUTED
10829b: eb 7f jmp 10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
10829d: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED
1082a3: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
1082a6: 8b 80 98 c7 11 00 mov 0x11c798(%eax),%eax <== NOT EXECUTED
1082ac: 85 c0 test %eax,%eax <== NOT EXECUTED
1082ae: 74 0c je 1082bc <rtems_termios_ioctl+0x2d3><== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
1082b0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1082b3: 53 push %ebx <== NOT EXECUTED
1082b4: ff d0 call *%eax <== NOT EXECUTED
1082b6: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED
1082b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
tty->t_line=*(int*)(args->buffer);
1082bc: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
1082bf: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED
1082c2: 8b 00 mov (%eax),%eax <== NOT EXECUTED
1082c4: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx) <== NOT EXECUTED
tty->t_sc = NULL; /* ensure that no more valid data */
1082ca: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx) <== NOT EXECUTED
1082d1: 00 00 00
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
1082d4: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
1082d7: 8b 80 94 c7 11 00 mov 0x11c794(%eax),%eax <== NOT EXECUTED
1082dd: 85 c0 test %eax,%eax <== NOT EXECUTED
1082df: 74 3b je 10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
1082e1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1082e4: 53 push %ebx <== NOT EXECUTED
1082e5: ff d0 call *%eax <== NOT EXECUTED
1082e7: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED
1082ea: e9 71 ff ff ff jmp 108260 <rtems_termios_ioctl+0x277><== NOT EXECUTED
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
1082ef: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
1082f2: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED
1082f5: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED
1082fb: 89 02 mov %eax,(%edx) <== NOT EXECUTED
1082fd: eb 1d jmp 10831c <rtems_termios_ioctl+0x333><== NOT EXECUTED
break;
#endif
case FIONREAD:
{
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
1082ff: 8b 53 60 mov 0x60(%ebx),%edx <== NOT EXECUTED
108302: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED
if ( rawnc < 0 )
108305: 29 c2 sub %eax,%edx <== NOT EXECUTED
108307: 79 05 jns 10830e <rtems_termios_ioctl+0x325><== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
108309: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED
10830c: 01 c2 add %eax,%edx <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
10830e: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
108311: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED
108314: 03 53 20 add 0x20(%ebx),%edx <== NOT EXECUTED
108317: 2b 53 24 sub 0x24(%ebx),%edx <== NOT EXECUTED
10831a: 89 10 mov %edx,(%eax) <== NOT EXECUTED
}
break;
}
rtems_semaphore_release (tty->osem);
10831c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10831f: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED
108322: e8 35 0f 00 00 call 10925c <rtems_semaphore_release><== NOT EXECUTED
args->ioctl_return = sc;
108327: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED
10832a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10832d: 89 50 0c mov %edx,0xc(%eax) <== NOT EXECUTED
108330: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return sc;
}
108333: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
108336: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
108339: 5b pop %ebx <== NOT EXECUTED
10833a: 5e pop %esi <== NOT EXECUTED
10833b: 5f pop %edi <== NOT EXECUTED
10833c: c9 leave <== NOT EXECUTED
10833d: c3 ret <== NOT EXECUTED
001084a7 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
1084a7: 55 push %ebp
1084a8: 89 e5 mov %esp,%ebp
1084aa: 57 push %edi
1084ab: 56 push %esi
1084ac: 53 push %ebx
1084ad: 83 ec 10 sub $0x10,%esp
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,
1084b0: 6a 00 push $0x0
1084b2: 6a 00 push $0x0
1084b4: ff 35 1c ca 11 00 pushl 0x11ca1c
1084ba: e8 b5 0c 00 00 call 109174 <rtems_semaphore_obtain>
1084bf: 89 45 f0 mov %eax,-0x10(%ebp)
RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
1084c2: 83 c4 10 add $0x10,%esp
1084c5: 85 c0 test %eax,%eax
1084c7: 0f 85 c0 03 00 00 jne 10888d <rtems_termios_open+0x3e6><== NEVER TAKEN
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
1084cd: a1 24 ca 11 00 mov 0x11ca24,%eax
1084d2: eb 1c jmp 1084f0 <rtems_termios_open+0x49>
if ((tty->major == major) && (tty->minor == minor))
1084d4: 8b 4d 08 mov 0x8(%ebp),%ecx
1084d7: 8b 55 e8 mov -0x18(%ebp),%edx
1084da: 39 4a 0c cmp %ecx,0xc(%edx)
1084dd: 75 0c jne 1084eb <rtems_termios_open+0x44><== NEVER TAKEN
1084df: 8b 75 0c mov 0xc(%ebp),%esi
1084e2: 39 72 10 cmp %esi,0x10(%edx)
1084e5: 0f 84 14 03 00 00 je 1087ff <rtems_termios_open+0x358><== ALWAYS TAKEN
*/
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,
RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
1084eb: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED
1084ee: 8b 00 mov (%eax),%eax <== NOT EXECUTED
1084f0: 89 45 e8 mov %eax,-0x18(%ebp)
1084f3: 83 7d e8 00 cmpl $0x0,-0x18(%ebp)
1084f7: 75 db jne 1084d4 <rtems_termios_open+0x2d>
1084f9: e9 9a 03 00 00 jmp 108898 <rtems_termios_open+0x3f1>
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
if (tty == NULL) {
rtems_semaphore_release (rtems_termios_ttyMutex);
1084fe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108501: e9 9d 00 00 00 jmp 1085a3 <rtems_termios_open+0xfc><== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
108506: a1 20 aa 11 00 mov 0x11aa20,%eax
10850b: 8b 55 e8 mov -0x18(%ebp),%edx
10850e: 89 42 64 mov %eax,0x64(%edx)
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
108511: 8b 42 64 mov 0x64(%edx),%eax
108514: 83 ec 0c sub $0xc,%esp
108517: 50 push %eax
108518: e8 57 e1 ff ff call 106674 <malloc>
10851d: 8b 4d e8 mov -0x18(%ebp),%ecx
108520: 89 41 58 mov %eax,0x58(%ecx)
if (tty->rawInBuf.theBuf == NULL) {
108523: 83 c4 10 add $0x10,%esp
108526: 85 c0 test %eax,%eax
108528: 75 06 jne 108530 <rtems_termios_open+0x89><== ALWAYS TAKEN
free(tty);
10852a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10852d: 51 push %ecx <== NOT EXECUTED
10852e: eb 6d jmp 10859d <rtems_termios_open+0xf6><== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
108530: a1 24 aa 11 00 mov 0x11aa24,%eax
108535: 8b 75 e8 mov -0x18(%ebp),%esi
108538: 89 86 88 00 00 00 mov %eax,0x88(%esi)
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
10853e: 8b 86 88 00 00 00 mov 0x88(%esi),%eax
108544: 83 ec 0c sub $0xc,%esp
108547: 50 push %eax
108548: e8 27 e1 ff ff call 106674 <malloc>
10854d: 89 46 7c mov %eax,0x7c(%esi)
if (tty->rawOutBuf.theBuf == NULL) {
108550: 83 c4 10 add $0x10,%esp
108553: 85 c0 test %eax,%eax
108555: 75 10 jne 108567 <rtems_termios_open+0xc0><== ALWAYS TAKEN
free((void *)(tty->rawInBuf.theBuf));
108557: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10855a: ff 76 58 pushl 0x58(%esi) <== NOT EXECUTED
10855d: e8 16 df ff ff call 106478 <free> <== NOT EXECUTED
free(tty);
108562: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
108565: eb 36 jmp 10859d <rtems_termios_open+0xf6><== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
108567: 83 ec 0c sub $0xc,%esp
10856a: ff 35 1c aa 11 00 pushl 0x11aa1c
108570: e8 ff e0 ff ff call 106674 <malloc>
108575: 8b 55 e8 mov -0x18(%ebp),%edx
108578: 89 42 1c mov %eax,0x1c(%edx)
if (tty->cbuf == NULL) {
10857b: 83 c4 10 add $0x10,%esp
10857e: 85 c0 test %eax,%eax
108580: 75 38 jne 1085ba <rtems_termios_open+0x113><== ALWAYS TAKEN
free((void *)(tty->rawOutBuf.theBuf));
108582: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108585: ff 72 7c pushl 0x7c(%edx) <== NOT EXECUTED
108588: e8 eb de ff ff call 106478 <free> <== NOT EXECUTED
free((void *)(tty->rawInBuf.theBuf));
10858d: 58 pop %eax <== NOT EXECUTED
10858e: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED
108591: ff 71 58 pushl 0x58(%ecx) <== NOT EXECUTED
108594: e8 df de ff ff call 106478 <free> <== NOT EXECUTED
free(tty);
108599: 58 pop %eax <== NOT EXECUTED
10859a: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED
10859d: e8 d6 de ff ff call 106478 <free> <== NOT EXECUTED
rtems_semaphore_release (rtems_termios_ttyMutex);
1085a2: 5f pop %edi <== NOT EXECUTED
1085a3: ff 35 1c ca 11 00 pushl 0x11ca1c <== NOT EXECUTED
1085a9: e8 ae 0c 00 00 call 10925c <rtems_semaphore_release><== NOT EXECUTED
1085ae: c7 45 f0 1a 00 00 00 movl $0x1a,-0x10(%ebp) <== NOT EXECUTED
1085b5: e9 d0 02 00 00 jmp 10888a <rtems_termios_open+0x3e3><== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
1085ba: 8b 75 e8 mov -0x18(%ebp),%esi
1085bd: c7 86 d4 00 00 00 00 movl $0x0,0xd4(%esi)
1085c4: 00 00 00
tty->tty_snd.sw_arg = NULL;
1085c7: c7 86 d8 00 00 00 00 movl $0x0,0xd8(%esi)
1085ce: 00 00 00
tty->tty_rcv.sw_pfn = NULL;
1085d1: c7 86 dc 00 00 00 00 movl $0x0,0xdc(%esi)
1085d8: 00 00 00
tty->tty_rcv.sw_arg = NULL;
1085db: c7 86 e0 00 00 00 00 movl $0x0,0xe0(%esi)
1085e2: 00 00 00
tty->tty_rcvwakeup = 0;
1085e5: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi)
1085ec: 00 00 00
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
1085ef: a1 24 ca 11 00 mov 0x11ca24,%eax
1085f4: 89 06 mov %eax,(%esi)
tty->back = NULL;
1085f6: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi)
if (rtems_termios_ttyHead != NULL)
1085fd: 85 c0 test %eax,%eax
1085ff: 74 03 je 108604 <rtems_termios_open+0x15d><== ALWAYS TAKEN
rtems_termios_ttyHead->back = tty;
108601: 89 70 04 mov %esi,0x4(%eax) <== NOT EXECUTED
rtems_termios_ttyHead = tty;
108604: 89 1d 24 ca 11 00 mov %ebx,0x11ca24
if (rtems_termios_ttyTail == NULL)
10860a: 83 3d 20 ca 11 00 00 cmpl $0x0,0x11ca20
108611: 75 06 jne 108619 <rtems_termios_open+0x172><== NEVER TAKEN
rtems_termios_ttyTail = tty;
108613: 89 1d 20 ca 11 00 mov %ebx,0x11ca20
tty->minor = minor;
108619: 8b 45 0c mov 0xc(%ebp),%eax
10861c: 89 43 10 mov %eax,0x10(%ebx)
tty->major = major;
10861f: 8b 55 08 mov 0x8(%ebp),%edx
108622: 89 53 0c mov %edx,0xc(%ebx)
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
108625: 83 ec 0c sub $0xc,%esp
108628: 8d 43 14 lea 0x14(%ebx),%eax
10862b: 50 push %eax
10862c: 6a 00 push $0x0
10862e: 6a 54 push $0x54
108630: 6a 01 push $0x1
108632: 0f be 05 28 aa 11 00 movsbl 0x11aa28,%eax
108639: 0d 00 69 52 54 or $0x54526900,%eax
10863e: 50 push %eax
10863f: e8 fc 08 00 00 call 108f40 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'i', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
108644: 83 c4 20 add $0x20,%esp
108647: 85 c0 test %eax,%eax
108649: 0f 85 24 02 00 00 jne 108873 <rtems_termios_open+0x3cc><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
10864f: 83 ec 0c sub $0xc,%esp
108652: 8d 43 18 lea 0x18(%ebx),%eax
108655: 50 push %eax
108656: 6a 00 push $0x0
108658: 6a 54 push $0x54
10865a: 6a 01 push $0x1
10865c: 0f be 05 28 aa 11 00 movsbl 0x11aa28,%eax
108663: 0d 00 6f 52 54 or $0x54526f00,%eax
108668: 50 push %eax
108669: e8 d2 08 00 00 call 108f40 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'o', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
10866e: 83 c4 20 add $0x20,%esp
108671: 85 c0 test %eax,%eax
108673: 0f 85 fa 01 00 00 jne 108873 <rtems_termios_open+0x3cc><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
108679: 83 ec 0c sub $0xc,%esp
10867c: 8d 83 8c 00 00 00 lea 0x8c(%ebx),%eax
108682: 50 push %eax
108683: 6a 00 push $0x0
108685: 6a 20 push $0x20
108687: 6a 00 push $0x0
108689: 0f be 05 28 aa 11 00 movsbl 0x11aa28,%eax
108690: 0d 00 78 52 54 or $0x54527800,%eax
108695: 50 push %eax
108696: e8 a5 08 00 00 call 108f40 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'x', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,
RTEMS_NO_PRIORITY,
&tty->rawOutBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
10869b: 83 c4 20 add $0x20,%esp
10869e: 85 c0 test %eax,%eax
1086a0: 0f 85 cd 01 00 00 jne 108873 <rtems_termios_open+0x3cc><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
1086a6: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx)
1086ad: 00 00 00
/*
* Set callbacks
*/
tty->device = *callbacks;
1086b0: 8d bb 98 00 00 00 lea 0x98(%ebx),%edi
1086b6: b9 08 00 00 00 mov $0x8,%ecx
1086bb: 8b 75 14 mov 0x14(%ebp),%esi
1086be: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
1086c0: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
1086c7: 75 68 jne 108731 <rtems_termios_open+0x28a><== ALWAYS TAKEN
sc = rtems_task_create (
1086c9: 56 push %esi <== NOT EXECUTED
1086ca: 56 push %esi <== NOT EXECUTED
1086cb: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax <== NOT EXECUTED
1086d1: 50 push %eax <== NOT EXECUTED
1086d2: 6a 00 push $0x0 <== NOT EXECUTED
1086d4: 68 00 05 00 00 push $0x500 <== NOT EXECUTED
1086d9: 68 00 04 00 00 push $0x400 <== NOT EXECUTED
1086de: 6a 0a push $0xa <== NOT EXECUTED
1086e0: 0f be 05 28 aa 11 00 movsbl 0x11aa28,%eax <== NOT EXECUTED
1086e7: 0d 00 54 78 54 or $0x54785400,%eax <== NOT EXECUTED
1086ec: 50 push %eax <== NOT EXECUTED
1086ed: e8 fa 0b 00 00 call 1092ec <rtems_task_create> <== NOT EXECUTED
TERMIOS_TXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
1086f2: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
1086f5: 85 c0 test %eax,%eax <== NOT EXECUTED
1086f7: 0f 85 76 01 00 00 jne 108873 <rtems_termios_open+0x3cc><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
1086fd: 51 push %ecx <== NOT EXECUTED
1086fe: 51 push %ecx <== NOT EXECUTED
1086ff: 8d 83 c4 00 00 00 lea 0xc4(%ebx),%eax <== NOT EXECUTED
108705: 50 push %eax <== NOT EXECUTED
108706: 6a 00 push $0x0 <== NOT EXECUTED
108708: 68 00 05 00 00 push $0x500 <== NOT EXECUTED
10870d: 68 00 04 00 00 push $0x400 <== NOT EXECUTED
108712: 6a 09 push $0x9 <== NOT EXECUTED
108714: 0f be 05 28 aa 11 00 movsbl 0x11aa28,%eax <== NOT EXECUTED
10871b: 0d 00 54 78 52 or $0x52785400,%eax <== NOT EXECUTED
108720: 50 push %eax <== NOT EXECUTED
108721: e8 c6 0b 00 00 call 1092ec <rtems_task_create> <== NOT EXECUTED
TERMIOS_RXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
108726: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
108729: 85 c0 test %eax,%eax <== NOT EXECUTED
10872b: 0f 85 42 01 00 00 jne 108873 <rtems_termios_open+0x3cc><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
108731: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx)
108738: 74 09 je 108743 <rtems_termios_open+0x29c><== ALWAYS TAKEN
10873a: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) <== NOT EXECUTED
108741: 75 2a jne 10876d <rtems_termios_open+0x2c6><== NOT EXECUTED
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
108743: 83 ec 0c sub $0xc,%esp
108746: 8d 43 68 lea 0x68(%ebx),%eax
108749: 50 push %eax
10874a: 6a 00 push $0x0
10874c: 6a 24 push $0x24
10874e: 6a 00 push $0x0
108750: 0f be 05 28 aa 11 00 movsbl 0x11aa28,%eax
108757: 0d 00 72 52 54 or $0x54527200,%eax
10875c: 50 push %eax
10875d: e8 de 07 00 00 call 108f40 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'r', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->rawInBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
108762: 83 c4 20 add $0x20,%esp
108765: 85 c0 test %eax,%eax
108767: 0f 85 06 01 00 00 jne 108873 <rtems_termios_open+0x3cc><== NEVER TAKEN
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
10876d: c7 43 30 02 25 00 00 movl $0x2502,0x30(%ebx)
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
108774: c7 43 34 05 18 00 00 movl $0x1805,0x34(%ebx)
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
10877b: c7 43 38 bd 08 00 00 movl $0x8bd,0x38(%ebx)
tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
108782: c7 43 3c 3b 82 00 00 movl $0x823b,0x3c(%ebx)
tty->termios.c_cc[VINTR] = '\003';
108789: c6 43 41 03 movb $0x3,0x41(%ebx)
tty->termios.c_cc[VQUIT] = '\034';
10878d: c6 43 42 1c movb $0x1c,0x42(%ebx)
tty->termios.c_cc[VERASE] = '\177';
108791: c6 43 43 7f movb $0x7f,0x43(%ebx)
tty->termios.c_cc[VKILL] = '\025';
108795: c6 43 44 15 movb $0x15,0x44(%ebx)
tty->termios.c_cc[VEOF] = '\004';
108799: c6 43 45 04 movb $0x4,0x45(%ebx)
tty->termios.c_cc[VEOL] = '\000';
10879d: c6 43 4c 00 movb $0x0,0x4c(%ebx)
tty->termios.c_cc[VEOL2] = '\000';
1087a1: c6 43 51 00 movb $0x0,0x51(%ebx)
tty->termios.c_cc[VSTART] = '\021';
1087a5: c6 43 49 11 movb $0x11,0x49(%ebx)
tty->termios.c_cc[VSTOP] = '\023';
1087a9: c6 43 4a 13 movb $0x13,0x4a(%ebx)
tty->termios.c_cc[VSUSP] = '\032';
1087ad: c6 43 4b 1a movb $0x1a,0x4b(%ebx)
tty->termios.c_cc[VREPRINT] = '\022';
1087b1: c6 43 4d 12 movb $0x12,0x4d(%ebx)
tty->termios.c_cc[VDISCARD] = '\017';
1087b5: c6 43 4e 0f movb $0xf,0x4e(%ebx)
tty->termios.c_cc[VWERASE] = '\027';
1087b9: c6 43 4f 17 movb $0x17,0x4f(%ebx)
tty->termios.c_cc[VLNEXT] = '\026';
1087bd: c6 43 50 16 movb $0x16,0x50(%ebx)
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
1087c1: c7 83 b8 00 00 00 00 movl $0x0,0xb8(%ebx)
1087c8: 00 00 00
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
1087cb: 8b 43 64 mov 0x64(%ebx),%eax
1087ce: d1 e8 shr %eax
1087d0: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx)
tty->highwater = tty->rawInBuf.Size * 3/4;
1087d6: 8b 43 64 mov 0x64(%ebx),%eax
1087d9: 8d 04 40 lea (%eax,%eax,2),%eax
1087dc: c1 e8 02 shr $0x2,%eax
1087df: 89 83 c0 00 00 00 mov %eax,0xc0(%ebx)
/*
* Bump name characer
*/
if (c++ == 'z')
1087e5: 8a 15 28 aa 11 00 mov 0x11aa28,%dl
1087eb: 8d 42 01 lea 0x1(%edx),%eax
1087ee: a2 28 aa 11 00 mov %al,0x11aa28
1087f3: 80 fa 7a cmp $0x7a,%dl
1087f6: 75 07 jne 1087ff <rtems_termios_open+0x358><== ALWAYS TAKEN
c = 'a';
1087f8: c6 05 28 aa 11 00 61 movb $0x61,0x11aa28 <== NOT EXECUTED
}
args->iop->data1 = tty;
1087ff: 8b 55 10 mov 0x10(%ebp),%edx
108802: 8b 02 mov (%edx),%eax
108804: 8b 4d e8 mov -0x18(%ebp),%ecx
108807: 89 48 28 mov %ecx,0x28(%eax)
if (!tty->refcount++) {
10880a: 8b 51 08 mov 0x8(%ecx),%edx
10880d: 8d 42 01 lea 0x1(%edx),%eax
108810: 89 41 08 mov %eax,0x8(%ecx)
108813: 85 d2 test %edx,%edx
108815: 75 65 jne 10887c <rtems_termios_open+0x3d5>
if (tty->device.firstOpen)
108817: 8b 81 98 00 00 00 mov 0x98(%ecx),%eax
10881d: 85 c0 test %eax,%eax
10881f: 74 0f je 108830 <rtems_termios_open+0x389><== NEVER TAKEN
(*tty->device.firstOpen)(major, minor, arg);
108821: 52 push %edx
108822: ff 75 10 pushl 0x10(%ebp)
108825: ff 75 0c pushl 0xc(%ebp)
108828: ff 75 08 pushl 0x8(%ebp)
10882b: ff d0 call *%eax
10882d: 83 c4 10 add $0x10,%esp
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
108830: 8b 75 e8 mov -0x18(%ebp),%esi
108833: 83 be b4 00 00 00 02 cmpl $0x2,0xb4(%esi)
10883a: 75 40 jne 10887c <rtems_termios_open+0x3d5><== ALWAYS TAKEN
sc = rtems_task_start(tty->rxTaskId,
10883c: 50 push %eax <== NOT EXECUTED
10883d: 56 push %esi <== NOT EXECUTED
10883e: 68 1e 89 10 00 push $0x10891e <== NOT EXECUTED
108843: ff b6 c4 00 00 00 pushl 0xc4(%esi) <== NOT EXECUTED
108849: e8 0e 0d 00 00 call 10955c <rtems_task_start> <== NOT EXECUTED
rtems_termios_rxdaemon,
(rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
10884e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108851: 85 c0 test %eax,%eax <== NOT EXECUTED
108853: 75 1e jne 108873 <rtems_termios_open+0x3cc><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(tty->txTaskId,
108855: 50 push %eax <== NOT EXECUTED
108856: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED
108859: 68 bb 88 10 00 push $0x1088bb <== NOT EXECUTED
10885e: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED
108861: ff b0 c8 00 00 00 pushl 0xc8(%eax) <== NOT EXECUTED
108867: e8 f0 0c 00 00 call 10955c <rtems_task_start> <== NOT EXECUTED
rtems_termios_txdaemon,
(rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
10886c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10886f: 85 c0 test %eax,%eax <== NOT EXECUTED
108871: 74 09 je 10887c <rtems_termios_open+0x3d5><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
108873: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108876: 50 push %eax <== NOT EXECUTED
108877: e8 10 0f 00 00 call 10978c <rtems_fatal_error_occurred><== NOT EXECUTED
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
10887c: 83 ec 0c sub $0xc,%esp
10887f: ff 35 1c ca 11 00 pushl 0x11ca1c
108885: e8 d2 09 00 00 call 10925c <rtems_semaphore_release>
10888a: 83 c4 10 add $0x10,%esp
return RTEMS_SUCCESSFUL;
}
10888d: 8b 45 f0 mov -0x10(%ebp),%eax
108890: 8d 65 f4 lea -0xc(%ebp),%esp
108893: 5b pop %ebx
108894: 5e pop %esi
108895: 5f pop %edi
108896: c9 leave
108897: c3 ret
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
108898: 50 push %eax
108899: 50 push %eax
10889a: 68 e8 00 00 00 push $0xe8
10889f: 6a 01 push $0x1
1088a1: e8 5e 43 00 00 call 10cc04 <calloc>
1088a6: 89 45 e8 mov %eax,-0x18(%ebp)
1088a9: 89 c3 mov %eax,%ebx
if (tty == NULL) {
1088ab: 83 c4 10 add $0x10,%esp
1088ae: 85 c0 test %eax,%eax
1088b0: 0f 85 50 fc ff ff jne 108506 <rtems_termios_open+0x5f><== ALWAYS TAKEN
1088b6: e9 43 fc ff ff jmp 1084fe <rtems_termios_open+0x57><== NOT EXECUTED
00107693 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
107693: 55 push %ebp
107694: 89 e5 mov %esp,%ebp
107696: 57 push %edi
107697: 56 push %esi
107698: 53 push %ebx
107699: 83 ec 1c sub $0x1c,%esp
10769c: 8b 45 08 mov 0x8(%ebp),%eax
10769f: 8b 55 0c mov 0xc(%ebp),%edx
1076a2: 89 55 e8 mov %edx,-0x18(%ebp)
1076a5: 8b 5d 10 mov 0x10(%ebp),%ebx
const unsigned char *buf = _buf;
1076a8: 89 45 ec mov %eax,-0x14(%ebp)
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
1076ab: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx)
1076b2: 75 1b jne 1076cf <rtems_termios_puts+0x3c><== ALWAYS TAKEN
(*tty->device.write)(tty->minor, (void *)buf, len);
1076b4: 89 55 10 mov %edx,0x10(%ebp) <== NOT EXECUTED
1076b7: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED
1076ba: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED
1076bd: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
1076c0: 8b 8b a4 00 00 00 mov 0xa4(%ebx),%ecx <== NOT EXECUTED
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
1076c6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
1076c9: 5b pop %ebx <== NOT EXECUTED
1076ca: 5e pop %esi <== NOT EXECUTED
1076cb: 5f pop %edi <== NOT EXECUTED
1076cc: c9 leave <== NOT EXECUTED
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
1076cd: ff e1 jmp *%ecx <== NOT EXECUTED
return;
}
newHead = tty->rawOutBuf.Head;
1076cf: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
1076d5: 89 45 f0 mov %eax,-0x10(%ebp)
1076d8: e9 b9 00 00 00 jmp 107796 <rtems_termios_puts+0x103>
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
1076dd: 8b 75 f0 mov -0x10(%ebp),%esi
1076e0: 46 inc %esi
1076e1: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx
1076e7: 89 f0 mov %esi,%eax
1076e9: 31 d2 xor %edx,%edx
1076eb: f7 f1 div %ecx
1076ed: 89 d6 mov %edx,%esi
1076ef: 89 55 f0 mov %edx,-0x10(%ebp)
rtems_interrupt_disable (level);
1076f2: 9c pushf
1076f3: fa cli
1076f4: 5f pop %edi
1076f5: eb 2f jmp 107726 <rtems_termios_puts+0x93>
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
1076f7: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx)
1076fe: 00 00 00
rtems_interrupt_enable (level);
107701: 57 push %edi
107702: 9d popf
sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
107703: 51 push %ecx
107704: 6a 00 push $0x0
107706: 6a 00 push $0x0
107708: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
10770e: e8 61 1a 00 00 call 109174 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
107713: 83 c4 10 add $0x10,%esp
107716: 85 c0 test %eax,%eax
107718: 74 09 je 107723 <rtems_termios_puts+0x90><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
10771a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10771d: 50 push %eax <== NOT EXECUTED
10771e: e8 69 20 00 00 call 10978c <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_interrupt_disable (level);
107723: 9c pushf
107724: fa cli
107725: 5f pop %edi
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
107726: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
10772c: 39 c6 cmp %eax,%esi
10772e: 74 c7 je 1076f7 <rtems_termios_puts+0x64>
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
107730: 8b 8b 80 00 00 00 mov 0x80(%ebx),%ecx
107736: 8b 53 7c mov 0x7c(%ebx),%edx
107739: 8b 45 ec mov -0x14(%ebp),%eax
10773c: 8a 00 mov (%eax),%al
10773e: 88 04 0a mov %al,(%edx,%ecx,1)
tty->rawOutBuf.Head = newHead;
107741: 89 b3 80 00 00 00 mov %esi,0x80(%ebx)
if (tty->rawOutBufState == rob_idle) {
107747: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx)
10774e: 75 3e jne 10778e <rtems_termios_puts+0xfb>
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
107750: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
107756: a8 10 test $0x10,%al
107758: 75 1b jne 107775 <rtems_termios_puts+0xe2><== NEVER TAKEN
(*tty->device.write)(tty->minor,
10775a: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
107760: 52 push %edx
107761: 6a 01 push $0x1
107763: 03 43 7c add 0x7c(%ebx),%eax
107766: 50 push %eax
107767: ff 73 10 pushl 0x10(%ebx)
10776a: ff 93 a4 00 00 00 call *0xa4(%ebx)
107770: 83 c4 10 add $0x10,%esp
107773: eb 0f jmp 107784 <rtems_termios_puts+0xf1>
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
107775: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10777b: 83 c8 20 or $0x20,%eax <== NOT EXECUTED
10777e: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
107784: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx)
10778b: 00 00 00
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
10778e: ff 45 ec incl -0x14(%ebp)
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
}
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
107791: 57 push %edi
107792: 9d popf
len--;
107793: ff 4d e8 decl -0x18(%ebp)
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
107796: 83 7d e8 00 cmpl $0x0,-0x18(%ebp)
10779a: 0f 85 3d ff ff ff jne 1076dd <rtems_termios_puts+0x4a>
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
1077a0: 8d 65 f4 lea -0xc(%ebp),%esp
1077a3: 5b pop %ebx
1077a4: 5e pop %esi
1077a5: 5f pop %edi
1077a6: c9 leave
1077a7: c3 ret
00107cdf <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
107cdf: 55 push %ebp <== NOT EXECUTED
107ce0: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107ce2: 57 push %edi <== NOT EXECUTED
107ce3: 56 push %esi <== NOT EXECUTED
107ce4: 53 push %ebx <== NOT EXECUTED
107ce5: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
107ce8: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
107ceb: 8b 02 mov (%edx),%eax <== NOT EXECUTED
107ced: 8b 70 28 mov 0x28(%eax),%esi <== NOT EXECUTED
uint32_t count = args->count;
107cf0: 8b 4a 0c mov 0xc(%edx),%ecx <== NOT EXECUTED
107cf3: 89 4d d0 mov %ecx,-0x30(%ebp) <== NOT EXECUTED
char *buffer = args->buffer;
107cf6: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED
107cf9: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
107cfc: 6a 00 push $0x0 <== NOT EXECUTED
107cfe: 6a 00 push $0x0 <== NOT EXECUTED
107d00: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED
107d03: e8 6c 14 00 00 call 109174 <rtems_semaphore_obtain><== NOT EXECUTED
107d08: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
107d0b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107d0e: 85 c0 test %eax,%eax <== NOT EXECUTED
107d10: 0f 85 c8 02 00 00 jne 107fde <rtems_termios_read+0x2ff><== NOT EXECUTED
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
107d16: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED
107d1c: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
107d1f: 8b 80 9c c7 11 00 mov 0x11c79c(%eax),%eax <== NOT EXECUTED
107d25: 85 c0 test %eax,%eax <== NOT EXECUTED
107d27: 74 1b je 107d44 <rtems_termios_read+0x65><== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
107d29: 52 push %edx <== NOT EXECUTED
107d2a: 52 push %edx <== NOT EXECUTED
107d2b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
107d2e: 56 push %esi <== NOT EXECUTED
107d2f: ff d0 call *%eax <== NOT EXECUTED
107d31: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
107d34: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi) <== NOT EXECUTED
107d3b: 00 00 00
rtems_semaphore_release (tty->isem);
107d3e: 58 pop %eax <== NOT EXECUTED
107d3f: e9 8f 02 00 00 jmp 107fd3 <rtems_termios_read+0x2f4><== NOT EXECUTED
return sc;
}
if (tty->cindex == tty->ccount) {
107d44: 8b 46 24 mov 0x24(%esi),%eax <== NOT EXECUTED
107d47: 3b 46 20 cmp 0x20(%esi),%eax <== NOT EXECUTED
107d4a: 0f 85 5c 02 00 00 jne 107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
tty->cindex = tty->ccount = 0;
107d50: c7 46 20 00 00 00 00 movl $0x0,0x20(%esi) <== NOT EXECUTED
107d57: c7 46 24 00 00 00 00 movl $0x0,0x24(%esi) <== NOT EXECUTED
tty->read_start_column = tty->column;
107d5e: 8b 46 28 mov 0x28(%esi),%eax <== NOT EXECUTED
107d61: 89 46 2c mov %eax,0x2c(%esi) <== NOT EXECUTED
if (tty->device.pollRead != NULL
107d64: 83 be a0 00 00 00 00 cmpl $0x0,0xa0(%esi) <== NOT EXECUTED
107d6b: 0f 84 f8 00 00 00 je 107e69 <rtems_termios_read+0x18a><== NOT EXECUTED
107d71: 83 be b4 00 00 00 00 cmpl $0x0,0xb4(%esi) <== NOT EXECUTED
107d78: 0f 85 eb 00 00 00 jne 107e69 <rtems_termios_read+0x18a><== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
107d7e: f6 46 3c 02 testb $0x2,0x3c(%esi) <== NOT EXECUTED
107d82: 74 35 je 107db9 <rtems_termios_read+0xda><== NOT EXECUTED
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
107d84: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107d87: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
107d8a: ff 96 a0 00 00 00 call *0xa0(%esi) <== NOT EXECUTED
if (n < 0) {
107d90: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107d93: 85 c0 test %eax,%eax <== NOT EXECUTED
107d95: 79 0f jns 107da6 <rtems_termios_read+0xc7><== NOT EXECUTED
rtems_task_wake_after (1);
107d97: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107d9a: 6a 01 push $0x1 <== NOT EXECUTED
107d9c: e8 1f 18 00 00 call 1095c0 <rtems_task_wake_after> <== NOT EXECUTED
107da1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107da4: eb de jmp 107d84 <rtems_termios_read+0xa5><== NOT EXECUTED
}
else {
if (siproc (n, tty))
107da6: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
107da9: 89 f2 mov %esi,%edx <== NOT EXECUTED
107dab: e8 db fd ff ff call 107b8b <siproc> <== NOT EXECUTED
107db0: 85 c0 test %eax,%eax <== NOT EXECUTED
107db2: 74 d0 je 107d84 <rtems_termios_read+0xa5><== NOT EXECUTED
107db4: e9 f3 01 00 00 jmp 107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
}
}
}
else {
rtems_interval then, now;
if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
107db9: 80 7e 47 00 cmpb $0x0,0x47(%esi) <== NOT EXECUTED
107dbd: 75 16 jne 107dd5 <rtems_termios_read+0xf6><== NOT EXECUTED
107dbf: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED
107dc3: 74 10 je 107dd5 <rtems_termios_read+0xf6><== NOT EXECUTED
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);
107dc5: 50 push %eax <== NOT EXECUTED
107dc6: 50 push %eax <== NOT EXECUTED
107dc7: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED
107dca: 50 push %eax <== NOT EXECUTED
107dcb: 6a 02 push $0x2 <== NOT EXECUTED
107dcd: e8 b2 0b 00 00 call 108984 <rtems_clock_get> <== NOT EXECUTED
107dd2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
else {
siproc (n, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);
107dd5: 8d 7d f0 lea -0x10(%ebp),%edi <== NOT EXECUTED
}
}
else {
if (!tty->termios.c_cc[VTIME])
break;
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now);
107dd8: 8d 5d ec lea -0x14(%ebp),%ebx <== NOT EXECUTED
else {
rtems_interval then, now;
if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
107ddb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107dde: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
107de1: ff 96 a0 00 00 00 call *0xa0(%esi) <== NOT EXECUTED
if (n < 0) {
107de7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107dea: 85 c0 test %eax,%eax <== NOT EXECUTED
107dec: 79 46 jns 107e34 <rtems_termios_read+0x155><== NOT EXECUTED
if (tty->termios.c_cc[VMIN]) {
107dee: 80 7e 47 00 cmpb $0x0,0x47(%esi) <== NOT EXECUTED
107df2: 74 0e je 107e02 <rtems_termios_read+0x123><== NOT EXECUTED
if (tty->termios.c_cc[VTIME] && tty->ccount) {
107df4: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED
107df8: 74 2e je 107e28 <rtems_termios_read+0x149><== NOT EXECUTED
107dfa: 83 7e 20 00 cmpl $0x0,0x20(%esi) <== NOT EXECUTED
107dfe: 74 28 je 107e28 <rtems_termios_read+0x149><== NOT EXECUTED
107e00: eb 0a jmp 107e0c <rtems_termios_read+0x12d><== NOT EXECUTED
break;
}
}
}
else {
if (!tty->termios.c_cc[VTIME])
107e02: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED
107e06: 0f 84 a0 01 00 00 je 107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
break;
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now);
107e0c: 50 push %eax <== NOT EXECUTED
107e0d: 50 push %eax <== NOT EXECUTED
107e0e: 53 push %ebx <== NOT EXECUTED
107e0f: 6a 02 push $0x2 <== NOT EXECUTED
107e11: e8 6e 0b 00 00 call 108984 <rtems_clock_get> <== NOT EXECUTED
if ((now - then) > tty->vtimeTicks) {
107e16: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED
107e19: 2b 45 f0 sub -0x10(%ebp),%eax <== NOT EXECUTED
107e1c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107e1f: 3b 46 54 cmp 0x54(%esi),%eax <== NOT EXECUTED
107e22: 0f 87 84 01 00 00 ja 107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
break;
}
}
rtems_task_wake_after (1);
107e28: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107e2b: 6a 01 push $0x1 <== NOT EXECUTED
107e2d: e8 8e 17 00 00 call 1095c0 <rtems_task_wake_after> <== NOT EXECUTED
107e32: eb 2d jmp 107e61 <rtems_termios_read+0x182><== NOT EXECUTED
}
else {
siproc (n, tty);
107e34: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
107e37: 89 f2 mov %esi,%edx <== NOT EXECUTED
107e39: e8 4d fd ff ff call 107b8b <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
107e3e: 8a 56 47 mov 0x47(%esi),%dl <== NOT EXECUTED
107e41: 0f b6 c2 movzbl %dl,%eax <== NOT EXECUTED
107e44: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED
107e47: 0f 8d 5f 01 00 00 jge 107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
107e4d: 84 d2 test %dl,%dl <== NOT EXECUTED
107e4f: 74 8a je 107ddb <rtems_termios_read+0xfc><== NOT EXECUTED
107e51: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED
107e55: 74 84 je 107ddb <rtems_termios_read+0xfc><== NOT EXECUTED
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);
107e57: 50 push %eax <== NOT EXECUTED
107e58: 50 push %eax <== NOT EXECUTED
107e59: 57 push %edi <== NOT EXECUTED
107e5a: 6a 02 push $0x2 <== NOT EXECUTED
107e5c: e8 23 0b 00 00 call 108984 <rtems_clock_get> <== NOT EXECUTED
107e61: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107e64: e9 72 ff ff ff jmp 107ddb <rtems_termios_read+0xfc><== NOT EXECUTED
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
107e69: 8b 7e 74 mov 0x74(%esi),%edi <== NOT EXECUTED
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(tty->minor,
107e6c: 8d 56 49 lea 0x49(%esi),%edx <== NOT EXECUTED
107e6f: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED
107e72: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED
107e77: e9 11 01 00 00 jmp 107f8d <rtems_termios_read+0x2ae><== NOT EXECUTED
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
107e7c: 8b 46 5c mov 0x5c(%esi),%eax <== NOT EXECUTED
107e7f: 8b 56 64 mov 0x64(%esi),%edx <== NOT EXECUTED
107e82: 40 inc %eax <== NOT EXECUTED
107e83: 89 d1 mov %edx,%ecx <== NOT EXECUTED
107e85: 31 d2 xor %edx,%edx <== NOT EXECUTED
107e87: f7 f1 div %ecx <== NOT EXECUTED
c = tty->rawInBuf.theBuf[newHead];
107e89: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED
107e8c: 0f b6 3c 10 movzbl (%eax,%edx,1),%edi <== NOT EXECUTED
tty->rawInBuf.Head = newHead;
107e90: 89 56 5c mov %edx,0x5c(%esi) <== NOT EXECUTED
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
107e93: 8b 5e 60 mov 0x60(%esi),%ebx <== NOT EXECUTED
107e96: 8b 46 64 mov 0x64(%esi),%eax <== NOT EXECUTED
107e99: 8b 4e 64 mov 0x64(%esi),%ecx <== NOT EXECUTED
107e9c: 01 d8 add %ebx,%eax <== NOT EXECUTED
107e9e: 29 d0 sub %edx,%eax <== NOT EXECUTED
107ea0: 31 d2 xor %edx,%edx <== NOT EXECUTED
107ea2: f7 f1 div %ecx <== NOT EXECUTED
107ea4: 3b 96 bc 00 00 00 cmp 0xbc(%esi),%edx <== NOT EXECUTED
107eaa: 73 74 jae 107f20 <rtems_termios_read+0x241><== NOT EXECUTED
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
107eac: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
107eb2: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED
107eb5: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
107ebb: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
107ec1: 25 02 02 00 00 and $0x202,%eax <== NOT EXECUTED
107ec6: 3d 02 02 00 00 cmp $0x202,%eax <== NOT EXECUTED
107ecb: 75 24 jne 107ef1 <rtems_termios_read+0x212><== NOT EXECUTED
107ecd: 83 be 94 00 00 00 00 cmpl $0x0,0x94(%esi) <== NOT EXECUTED
107ed4: 74 0a je 107ee0 <rtems_termios_read+0x201><== NOT EXECUTED
107ed6: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
107edc: a8 20 test $0x20,%al <== NOT EXECUTED
107ede: 74 11 je 107ef1 <rtems_termios_read+0x212><== NOT EXECUTED
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(tty->minor,
107ee0: 50 push %eax <== NOT EXECUTED
107ee1: 6a 01 push $0x1 <== NOT EXECUTED
107ee3: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED
107ee6: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
107ee9: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED
107eef: eb 2c jmp 107f1d <rtems_termios_read+0x23e><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTART]),
1);
}
else if (tty->flow_ctrl & FL_MDRTS) {
107ef1: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
107ef7: f6 c4 01 test $0x1,%ah <== NOT EXECUTED
107efa: 74 24 je 107f20 <rtems_termios_read+0x241><== NOT EXECUTED
tty->flow_ctrl &= ~FL_IRTSOFF;
107efc: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
107f02: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED
107f05: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
107f0b: 8b 86 b0 00 00 00 mov 0xb0(%esi),%eax <== NOT EXECUTED
107f11: 85 c0 test %eax,%eax <== NOT EXECUTED
107f13: 74 0b je 107f20 <rtems_termios_read+0x241><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
107f15: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107f18: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
107f1b: ff d0 call *%eax <== NOT EXECUTED
107f1d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
107f20: f6 46 3c 02 testb $0x2,0x3c(%esi) <== NOT EXECUTED
107f24: 74 12 je 107f38 <rtems_termios_read+0x259><== NOT EXECUTED
if (siproc (c, tty))
107f26: 89 fa mov %edi,%edx <== NOT EXECUTED
107f28: 0f b6 c2 movzbl %dl,%eax <== NOT EXECUTED
107f2b: 89 f2 mov %esi,%edx <== NOT EXECUTED
107f2d: e8 59 fc ff ff call 107b8b <siproc> <== NOT EXECUTED
107f32: 85 c0 test %eax,%eax <== NOT EXECUTED
107f34: 75 17 jne 107f4d <rtems_termios_read+0x26e><== NOT EXECUTED
107f36: eb 1c jmp 107f54 <rtems_termios_read+0x275><== NOT EXECUTED
wait = 0;
}
else {
siproc (c, tty);
107f38: 89 f9 mov %edi,%ecx <== NOT EXECUTED
107f3a: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED
107f3d: 89 f2 mov %esi,%edx <== NOT EXECUTED
107f3f: e8 47 fc ff ff call 107b8b <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
107f44: 0f b6 46 47 movzbl 0x47(%esi),%eax <== NOT EXECUTED
107f48: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED
107f4b: 7c 07 jl 107f54 <rtems_termios_read+0x275><== NOT EXECUTED
107f4d: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
107f54: 8b 4e 70 mov 0x70(%esi),%ecx <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
107f57: 8b 56 5c mov 0x5c(%esi),%edx <== NOT EXECUTED
107f5a: 8b 46 60 mov 0x60(%esi),%eax <== NOT EXECUTED
107f5d: 39 c2 cmp %eax,%edx <== NOT EXECUTED
107f5f: 74 0f je 107f70 <rtems_termios_read+0x291><== NOT EXECUTED
107f61: a1 1c aa 11 00 mov 0x11aa1c,%eax <== NOT EXECUTED
107f66: 48 dec %eax <== NOT EXECUTED
107f67: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED
107f6a: 0f 8c 0c ff ff ff jl 107e7c <rtems_termios_read+0x19d><== NOT EXECUTED
107f70: 8b 5d dc mov -0x24(%ebp),%ebx <== NOT EXECUTED
107f73: 89 cf mov %ecx,%edi <== NOT EXECUTED
}
/*
* Wait for characters
*/
if ( wait ) {
107f75: 85 db test %ebx,%ebx <== NOT EXECUTED
107f77: 74 33 je 107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->rawInBuf.Semaphore,
107f79: 50 push %eax <== NOT EXECUTED
107f7a: 51 push %ecx <== NOT EXECUTED
107f7b: ff 76 6c pushl 0x6c(%esi) <== NOT EXECUTED
107f7e: ff 76 68 pushl 0x68(%esi) <== NOT EXECUTED
107f81: e8 ee 11 00 00 call 109174 <rtems_semaphore_obtain><== NOT EXECUTED
tty->rawInBufSemaphoreOptions,
timeout);
if (sc != RTEMS_SUCCESSFUL)
107f86: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107f89: 85 c0 test %eax,%eax <== NOT EXECUTED
107f8b: 75 1f jne 107fac <rtems_termios_read+0x2cd><== NOT EXECUTED
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
rtems_status_code sc;
int wait = (int)1;
while ( wait ) {
107f8d: 89 5d dc mov %ebx,-0x24(%ebp) <== NOT EXECUTED
107f90: 89 f9 mov %edi,%ecx <== NOT EXECUTED
107f92: eb c3 jmp 107f57 <rtems_termios_read+0x278><== NOT EXECUTED
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
107f94: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED
107f97: 8a 04 10 mov (%eax,%edx,1),%al <== NOT EXECUTED
107f9a: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED
107f9d: 88 01 mov %al,(%ecx) <== NOT EXECUTED
107f9f: 41 inc %ecx <== NOT EXECUTED
107fa0: 89 4d d4 mov %ecx,-0x2c(%ebp) <== NOT EXECUTED
107fa3: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED
107fa6: 89 46 24 mov %eax,0x24(%esi) <== NOT EXECUTED
count--;
107fa9: ff 4d d0 decl -0x30(%ebp) <== NOT EXECUTED
else
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
107fac: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) <== NOT EXECUTED
107fb0: 74 08 je 107fba <rtems_termios_read+0x2db><== NOT EXECUTED
107fb2: 8b 56 24 mov 0x24(%esi),%edx <== NOT EXECUTED
107fb5: 3b 56 20 cmp 0x20(%esi),%edx <== NOT EXECUTED
107fb8: 7c da jl 107f94 <rtems_termios_read+0x2b5><== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
107fba: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
107fbd: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED
107fc0: 2b 45 d0 sub -0x30(%ebp),%eax <== NOT EXECUTED
107fc3: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
107fc6: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi) <== NOT EXECUTED
107fcd: 00 00 00
rtems_semaphore_release (tty->isem);
107fd0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107fd3: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED
107fd6: e8 81 12 00 00 call 10925c <rtems_semaphore_release><== NOT EXECUTED
107fdb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
return sc;
}
107fde: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED
107fe1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
107fe4: 5b pop %ebx <== NOT EXECUTED
107fe5: 5e pop %esi <== NOT EXECUTED
107fe6: 5f pop %edi <== NOT EXECUTED
107fe7: c9 leave <== NOT EXECUTED
107fe8: c3 ret <== NOT EXECUTED
001071da <rtems_termios_refill_transmitter>:
* in task-driven mode, this function is called in Tx task context
* in interrupt-driven mode, this function is called in TxIRQ context
*/
int
rtems_termios_refill_transmitter (struct rtems_termios_tty *tty)
{
1071da: 55 push %ebp
1071db: 89 e5 mov %esp,%ebp
1071dd: 57 push %edi
1071de: 56 push %esi
1071df: 53 push %ebx
1071e0: 83 ec 0c sub $0xc,%esp
1071e3: 8b 75 08 mov 0x8(%ebp),%esi
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
1071e6: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax
1071ec: 25 03 04 00 00 and $0x403,%eax
1071f1: 3d 01 04 00 00 cmp $0x401,%eax
1071f6: 75 2c jne 107224 <rtems_termios_refill_transmitter+0x4a><== ALWAYS TAKEN
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor,
1071f8: 57 push %edi <== NOT EXECUTED
1071f9: 6a 01 push $0x1 <== NOT EXECUTED
1071fb: 8d 46 4a lea 0x4a(%esi),%eax <== NOT EXECUTED
1071fe: 50 push %eax <== NOT EXECUTED
1071ff: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
107202: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
107208: 9c pushf <== NOT EXECUTED
107209: fa cli <== NOT EXECUTED
10720a: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
10720b: ff 8e 90 00 00 00 decl 0x90(%esi) <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
107211: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
107217: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
10721a: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED
rtems_interrupt_enable(level);
107220: 52 push %edx <== NOT EXECUTED
107221: 9d popf <== NOT EXECUTED
107222: eb 38 jmp 10725c <rtems_termios_refill_transmitter+0x82><== NOT EXECUTED
nToSend = 1;
}
else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF))
107224: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax
10722a: 83 e0 03 and $0x3,%eax
10722d: 83 f8 02 cmp $0x2,%eax
107230: 75 37 jne 107269 <rtems_termios_refill_transmitter+0x8f><== ALWAYS TAKEN
* FIXME: this .write call will generate another
* dequeue callback. This will advance the "Tail" in the data
* buffer, although the corresponding data is not yet out!
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor,
107232: 53 push %ebx <== NOT EXECUTED
107233: 6a 01 push $0x1 <== NOT EXECUTED
107235: 8d 46 49 lea 0x49(%esi),%eax <== NOT EXECUTED
107238: 50 push %eax <== NOT EXECUTED
107239: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED
10723c: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
107242: 9c pushf <== NOT EXECUTED
107243: fa cli <== NOT EXECUTED
107244: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
107245: ff 8e 90 00 00 00 decl 0x90(%esi) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
10724b: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
107251: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED
107254: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED
rtems_interrupt_enable(level);
10725a: 52 push %edx <== NOT EXECUTED
10725b: 9d popf <== NOT EXECUTED
10725c: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED
107261: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107264: e9 34 01 00 00 jmp 10739d <rtems_termios_refill_transmitter+0x1c3><== NOT EXECUTED
nToSend = 1;
}
else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
107269: 8b 96 80 00 00 00 mov 0x80(%esi),%edx
10726f: 8b 86 84 00 00 00 mov 0x84(%esi),%eax
107275: 39 c2 cmp %eax,%edx
107277: 75 21 jne 10729a <rtems_termios_refill_transmitter+0xc0><== ALWAYS TAKEN
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
107279: 31 db xor %ebx,%ebx
10727b: 83 be 94 00 00 00 02 cmpl $0x2,0x94(%esi) <== NOT EXECUTED
107282: 0f 85 15 01 00 00 jne 10739d <rtems_termios_refill_transmitter+0x1c3><== NOT EXECUTED
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
107288: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10728b: ff b6 8c 00 00 00 pushl 0x8c(%esi) <== NOT EXECUTED
107291: e8 c6 1f 00 00 call 10925c <rtems_semaphore_release><== NOT EXECUTED
107296: 31 db xor %ebx,%ebx <== NOT EXECUTED
107298: eb c7 jmp 107261 <rtems_termios_refill_transmitter+0x87><== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
10729a: 9c pushf
10729b: fa cli
10729c: 58 pop %eax
len = tty->t_dqlen;
10729d: 8b 8e 90 00 00 00 mov 0x90(%esi),%ecx
tty->t_dqlen = 0;
1072a3: c7 86 90 00 00 00 00 movl $0x0,0x90(%esi)
1072aa: 00 00 00
rtems_interrupt_enable(level);
1072ad: 50 push %eax
1072ae: 9d popf
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
1072af: 8b 96 84 00 00 00 mov 0x84(%esi),%edx
1072b5: 8b 9e 88 00 00 00 mov 0x88(%esi),%ebx
1072bb: 01 d1 add %edx,%ecx
1072bd: 89 c8 mov %ecx,%eax
1072bf: 31 d2 xor %edx,%edx
1072c1: f7 f3 div %ebx
1072c3: 89 d7 mov %edx,%edi
tty->rawOutBuf.Tail = newTail;
1072c5: 89 96 84 00 00 00 mov %edx,0x84(%esi)
if (tty->rawOutBufState == rob_wait) {
1072cb: 83 be 94 00 00 00 02 cmpl $0x2,0x94(%esi)
1072d2: 75 11 jne 1072e5 <rtems_termios_refill_transmitter+0x10b>
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
1072d4: 83 ec 0c sub $0xc,%esp
1072d7: ff b6 8c 00 00 00 pushl 0x8c(%esi)
1072dd: e8 7a 1f 00 00 call 10925c <rtems_semaphore_release>
1072e2: 83 c4 10 add $0x10,%esp
}
if (newTail == tty->rawOutBuf.Head) {
1072e5: 8b 86 80 00 00 00 mov 0x80(%esi),%eax
1072eb: 39 c7 cmp %eax,%edi
1072ed: 75 2c jne 10731b <rtems_termios_refill_transmitter+0x141>
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
1072ef: c7 86 94 00 00 00 00 movl $0x0,0x94(%esi)
1072f6: 00 00 00
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
1072f9: 8b 96 d4 00 00 00 mov 0xd4(%esi),%edx
1072ff: 31 db xor %ebx,%ebx
107301: 85 d2 test %edx,%edx
107303: 0f 84 8e 00 00 00 je 107397 <rtems_termios_refill_transmitter+0x1bd><== ALWAYS TAKEN
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
107309: 51 push %ecx <== NOT EXECUTED
10730a: 51 push %ecx <== NOT EXECUTED
10730b: ff b6 d8 00 00 00 pushl 0xd8(%esi) <== NOT EXECUTED
107311: 8d 46 30 lea 0x30(%esi),%eax <== NOT EXECUTED
107314: 50 push %eax <== NOT EXECUTED
107315: ff d2 call *%edx <== NOT EXECUTED
107317: 31 db xor %ebx,%ebx <== NOT EXECUTED
107319: eb 79 jmp 107394 <rtems_termios_refill_transmitter+0x1ba><== NOT EXECUTED
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
10731b: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax
107321: 25 10 02 00 00 and $0x210,%eax
107326: 3d 10 02 00 00 cmp $0x210,%eax
10732b: 75 22 jne 10734f <rtems_termios_refill_transmitter+0x175><== ALWAYS TAKEN
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
10732d: 9c pushf <== NOT EXECUTED
10732e: fa cli <== NOT EXECUTED
10732f: 5a pop %edx <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
107330: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED
107336: 83 c8 20 or $0x20,%eax <== NOT EXECUTED
107339: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
10733f: c7 86 94 00 00 00 01 movl $0x1,0x94(%esi) <== NOT EXECUTED
107346: 00 00 00
rtems_interrupt_enable(level);
107349: 52 push %edx <== NOT EXECUTED
10734a: 9d popf <== NOT EXECUTED
10734b: 31 db xor %ebx,%ebx <== NOT EXECUTED
10734d: eb 48 jmp 107397 <rtems_termios_refill_transmitter+0x1bd><== NOT EXECUTED
}
else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
10734f: 8b 86 80 00 00 00 mov 0x80(%esi),%eax
107355: 39 c7 cmp %eax,%edi
107357: 76 08 jbe 107361 <rtems_termios_refill_transmitter+0x187>
nToSend = tty->rawOutBuf.Size - newTail;
107359: 8b 9e 88 00 00 00 mov 0x88(%esi),%ebx
10735f: eb 06 jmp 107367 <rtems_termios_refill_transmitter+0x18d>
else
nToSend = tty->rawOutBuf.Head - newTail;
107361: 8b 9e 80 00 00 00 mov 0x80(%esi),%ebx
107367: 29 fb sub %edi,%ebx
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
107369: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax
10736f: f6 c4 06 test $0x6,%ah
107372: 74 05 je 107379 <rtems_termios_refill_transmitter+0x19f><== ALWAYS TAKEN
107374: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
107379: c7 86 94 00 00 00 01 movl $0x1,0x94(%esi)
107380: 00 00 00
(*tty->device.write)(tty->minor,
107383: 50 push %eax
107384: 53 push %ebx
107385: 8b 46 7c mov 0x7c(%esi),%eax
107388: 01 f8 add %edi,%eax
10738a: 50 push %eax
10738b: ff 76 10 pushl 0x10(%esi)
10738e: ff 96 a4 00 00 00 call *0xa4(%esi)
107394: 83 c4 10 add $0x10,%esp
&tty->rawOutBuf.theBuf[newTail],
nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
107397: 89 be 84 00 00 00 mov %edi,0x84(%esi)
}
return nToSend;
}
10739d: 89 d8 mov %ebx,%eax
10739f: 8d 65 f4 lea -0xc(%ebp),%esp
1073a2: 5b pop %ebx
1073a3: 5e pop %esi
1073a4: 5f pop %edi
1073a5: c9 leave
1073a6: c3 ret
0010891e <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
10891e: 55 push %ebp <== NOT EXECUTED
10891f: 89 e5 mov %esp,%ebp <== NOT EXECUTED
108921: 57 push %edi <== NOT EXECUTED
108922: 56 push %esi <== NOT EXECUTED
108923: 53 push %ebx <== NOT EXECUTED
108924: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED
108927: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
char c_buf;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_RX_PROC_EVENT |
10892a: 8d 7d ec lea -0x14(%ebp),%edi <== NOT EXECUTED
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters (
10892d: 8d 75 f3 lea -0xd(%ebp),%esi <== NOT EXECUTED
char c_buf;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_RX_PROC_EVENT |
108930: 57 push %edi <== NOT EXECUTED
108931: 6a 00 push $0x0 <== NOT EXECUTED
108933: 6a 02 push $0x2 <== NOT EXECUTED
108935: 6a 03 push $0x3 <== NOT EXECUTED
108937: e8 38 02 00 00 call 108b74 <rtems_event_receive> <== NOT EXECUTED
TERMIOS_RX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
10893c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10893f: f6 45 ec 01 testb $0x1,-0x14(%ebp) <== NOT EXECUTED
108943: 74 16 je 10895b <rtems_termios_rxdaemon+0x3d><== NOT EXECUTED
tty->rxTaskId = 0;
108945: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) <== NOT EXECUTED
10894c: 00 00 00
rtems_task_delete(RTEMS_SELF);
10894f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108952: 6a 00 push $0x0 <== NOT EXECUTED
108954: e8 c3 0a 00 00 call 10941c <rtems_task_delete> <== NOT EXECUTED
108959: eb 21 jmp 10897c <rtems_termios_rxdaemon+0x5e><== NOT EXECUTED
}
else {
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
10895b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10895e: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
108961: ff 93 a0 00 00 00 call *0xa0(%ebx) <== NOT EXECUTED
if (c != EOF) {
108967: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10896a: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED
10896d: 74 c1 je 108930 <rtems_termios_rxdaemon+0x12><== NOT EXECUTED
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
10896f: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED
rtems_termios_enqueue_raw_characters (
108972: 50 push %eax <== NOT EXECUTED
108973: 6a 01 push $0x1 <== NOT EXECUTED
108975: 56 push %esi <== NOT EXECUTED
108976: 53 push %ebx <== NOT EXECUTED
108977: e8 8f ea ff ff call 10740b <rtems_termios_enqueue_raw_characters><== NOT EXECUTED
10897c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10897f: eb af jmp 108930 <rtems_termios_rxdaemon+0x12><== NOT EXECUTED
001071bf <rtems_termios_rxirq_occured>:
* signal receive interrupt to rx daemon
* NOTE: This routine runs in the context of the
* device receive interrupt handler.
*/
void rtems_termios_rxirq_occured(struct rtems_termios_tty *tty)
{
1071bf: 55 push %ebp <== NOT EXECUTED
1071c0: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1071c2: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
/*
* send event to rx daemon task
*/
rtems_event_send(tty->rxTaskId,TERMIOS_RX_PROC_EVENT);
1071c5: 6a 02 push $0x2 <== NOT EXECUTED
1071c7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
1071ca: ff b0 c4 00 00 00 pushl 0xc4(%eax) <== NOT EXECUTED
1071d0: e8 0f 1b 00 00 call 108ce4 <rtems_event_send> <== NOT EXECUTED
1071d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
1071d8: c9 leave <== NOT EXECUTED
1071d9: c3 ret <== NOT EXECUTED
001088bb <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
1088bb: 55 push %ebp <== NOT EXECUTED
1088bc: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1088be: 56 push %esi <== NOT EXECUTED
1088bf: 53 push %ebx <== NOT EXECUTED
1088c0: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
1088c3: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_TX_START_EVENT |
1088c6: 8d 75 f4 lea -0xc(%ebp),%esi <== NOT EXECUTED
1088c9: 56 push %esi <== NOT EXECUTED
1088ca: 6a 00 push $0x0 <== NOT EXECUTED
1088cc: 6a 02 push $0x2 <== NOT EXECUTED
1088ce: 6a 03 push $0x3 <== NOT EXECUTED
1088d0: e8 9f 02 00 00 call 108b74 <rtems_event_receive> <== NOT EXECUTED
TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
1088d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1088d8: f6 45 f4 01 testb $0x1,-0xc(%ebp) <== NOT EXECUTED
1088dc: 74 16 je 1088f4 <rtems_termios_txdaemon+0x39><== NOT EXECUTED
tty->txTaskId = 0;
1088de: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED
1088e5: 00 00 00
rtems_task_delete(RTEMS_SELF);
1088e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1088eb: 6a 00 push $0x0 <== NOT EXECUTED
1088ed: e8 2a 0b 00 00 call 10941c <rtems_task_delete> <== NOT EXECUTED
1088f2: eb 25 jmp 108919 <rtems_termios_txdaemon+0x5e><== NOT EXECUTED
}
else {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
1088f4: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED
1088fa: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED
1088fd: 8b 80 a8 c7 11 00 mov 0x11c7a8(%eax),%eax <== NOT EXECUTED
108903: 85 c0 test %eax,%eax <== NOT EXECUTED
108905: 74 09 je 108910 <rtems_termios_txdaemon+0x55><== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
108907: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10890a: 53 push %ebx <== NOT EXECUTED
10890b: ff d0 call *%eax <== NOT EXECUTED
10890d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
108910: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108913: 53 push %ebx <== NOT EXECUTED
108914: e8 c1 e8 ff ff call 1071da <rtems_termios_refill_transmitter><== NOT EXECUTED
108919: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10891c: eb ab jmp 1088c9 <rtems_termios_txdaemon+0xe><== NOT EXECUTED
00107bd9 <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
107bd9: 55 push %ebp
107bda: 89 e5 mov %esp,%ebp
107bdc: 57 push %edi
107bdd: 56 push %esi
107bde: 53 push %ebx
107bdf: 83 ec 10 sub $0x10,%esp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
107be2: 8b 55 08 mov 0x8(%ebp),%edx
107be5: 8b 02 mov (%edx),%eax
107be7: 8b 78 28 mov 0x28(%eax),%edi
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
107bea: 6a 00 push $0x0
107bec: 6a 00 push $0x0
107bee: ff 77 18 pushl 0x18(%edi)
107bf1: e8 7e 15 00 00 call 109174 <rtems_semaphore_obtain>
107bf6: 89 45 f0 mov %eax,-0x10(%ebp)
if (sc != RTEMS_SUCCESSFUL)
107bf9: 83 c4 10 add $0x10,%esp
107bfc: 85 c0 test %eax,%eax
107bfe: 75 77 jne 107c77 <rtems_termios_write+0x9e><== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
107c00: 8b 87 cc 00 00 00 mov 0xcc(%edi),%eax
107c06: c1 e0 05 shl $0x5,%eax
107c09: 8b 80 a0 c7 11 00 mov 0x11c7a0(%eax),%eax
107c0f: 85 c0 test %eax,%eax
107c11: 74 0e je 107c21 <rtems_termios_write+0x48><== ALWAYS TAKEN
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
107c13: 52 push %edx <== NOT EXECUTED
107c14: 52 push %edx <== NOT EXECUTED
107c15: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED
107c18: 57 push %edi <== NOT EXECUTED
107c19: ff d0 call *%eax <== NOT EXECUTED
107c1b: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
107c1e: 5e pop %esi <== NOT EXECUTED
107c1f: eb 4b jmp 107c6c <rtems_termios_write+0x93><== NOT EXECUTED
return sc;
}
if (tty->termios.c_oflag & OPOST) {
107c21: f6 47 34 01 testb $0x1,0x34(%edi)
107c25: 74 26 je 107c4d <rtems_termios_write+0x74><== NEVER TAKEN
uint32_t count = args->count;
107c27: 8b 45 08 mov 0x8(%ebp),%eax
107c2a: 8b 70 0c mov 0xc(%eax),%esi
char *buffer = args->buffer;
107c2d: 8b 58 08 mov 0x8(%eax),%ebx
107c30: eb 0c jmp 107c3e <rtems_termios_write+0x65>
while (count--)
oproc (*buffer++, tty);
107c32: 0f b6 03 movzbl (%ebx),%eax
107c35: 43 inc %ebx
107c36: 89 fa mov %edi,%edx
107c38: e8 6b fb ff ff call 1077a8 <oproc>
107c3d: 4e dec %esi
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
107c3e: 85 f6 test %esi,%esi
107c40: 75 f0 jne 107c32 <rtems_termios_write+0x59>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
107c42: 8b 55 08 mov 0x8(%ebp),%edx
107c45: 8b 42 0c mov 0xc(%edx),%eax
107c48: 89 42 14 mov %eax,0x14(%edx)
107c4b: eb 1c jmp 107c69 <rtems_termios_write+0x90>
}
else {
rtems_termios_puts (args->buffer, args->count, tty);
107c4d: 53 push %ebx <== NOT EXECUTED
107c4e: 57 push %edi <== NOT EXECUTED
107c4f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
107c52: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
107c55: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
107c58: e8 36 fa ff ff call 107693 <rtems_termios_puts> <== NOT EXECUTED
args->bytes_moved = args->count;
107c5d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
107c60: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED
107c63: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED
107c66: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
rtems_semaphore_release (tty->osem);
107c69: 83 ec 0c sub $0xc,%esp
107c6c: ff 77 18 pushl 0x18(%edi)
107c6f: e8 e8 15 00 00 call 10925c <rtems_semaphore_release>
107c74: 83 c4 10 add $0x10,%esp
return sc;
}
107c77: 8b 45 f0 mov -0x10(%ebp),%eax
107c7a: 8d 65 f4 lea -0xc(%ebp),%esp
107c7d: 5b pop %ebx
107c7e: 5e pop %esi
107c7f: 5f pop %edi
107c80: c9 leave
107c81: c3 ret
00112ad8 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
Objects_Id id
)
{
112ad8: 55 push %ebp
112ad9: 89 e5 mov %esp,%ebp
112adb: 83 ec 1c sub $0x1c,%esp
/**
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
112ade: 8d 45 fc lea -0x4(%ebp),%eax
112ae1: 50 push %eax
112ae2: ff 75 08 pushl 0x8(%ebp)
112ae5: 68 d4 2a 13 00 push $0x132ad4
112aea: e8 69 24 00 00 call 114f58 <_Objects_Get>
112aef: 89 c2 mov %eax,%edx
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
112af1: 83 c4 10 add $0x10,%esp
112af4: b8 04 00 00 00 mov $0x4,%eax
112af9: 83 7d fc 00 cmpl $0x0,-0x4(%ebp)
112afd: 75 1c jne 112b1b <rtems_timer_cancel+0x43>
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
112aff: 83 7a 38 04 cmpl $0x4,0x38(%edx)
112b03: 74 0f je 112b14 <rtems_timer_cancel+0x3c><== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
112b05: 83 ec 0c sub $0xc,%esp
112b08: 8d 42 10 lea 0x10(%edx),%eax
112b0b: 50 push %eax
112b0c: e8 3b 3e 00 00 call 11694c <_Watchdog_Remove>
112b11: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
112b14: e8 ff 2b 00 00 call 115718 <_Thread_Enable_dispatch>
112b19: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112b1b: c9 leave
112b1c: c3 ret
00112b20 <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
Objects_Id *id
)
{
112b20: 55 push %ebp
112b21: 89 e5 mov %esp,%ebp
112b23: 57 push %edi
112b24: 56 push %esi
112b25: 53 push %ebx
112b26: 83 ec 0c sub $0xc,%esp
112b29: 8b 75 08 mov 0x8(%ebp),%esi
112b2c: 8b 7d 0c mov 0xc(%ebp),%edi
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
112b2f: b8 03 00 00 00 mov $0x3,%eax
112b34: 85 f6 test %esi,%esi
112b36: 74 73 je 112bab <rtems_timer_create+0x8b>
return RTEMS_INVALID_NAME;
if ( !id )
112b38: b8 09 00 00 00 mov $0x9,%eax
112b3d: 85 ff test %edi,%edi
112b3f: 74 6a je 112bab <rtems_timer_create+0x8b><== NEVER TAKEN
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
112b41: a1 e0 27 13 00 mov 0x1327e0,%eax
112b46: 40 inc %eax
112b47: a3 e0 27 13 00 mov %eax,0x1327e0
#ifdef __cplusplus
extern "C" {
#endif
/**
112b4c: 83 ec 0c sub $0xc,%esp
112b4f: 68 d4 2a 13 00 push $0x132ad4
112b54: e8 7f 1f 00 00 call 114ad8 <_Objects_Allocate>
112b59: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
112b5b: 83 c4 10 add $0x10,%esp
112b5e: 85 c0 test %eax,%eax
112b60: 75 0c jne 112b6e <rtems_timer_create+0x4e>
_Thread_Enable_dispatch();
112b62: e8 b1 2b 00 00 call 115718 <_Thread_Enable_dispatch>
112b67: b8 05 00 00 00 mov $0x5,%eax
112b6c: eb 3d jmp 112bab <rtems_timer_create+0x8b>
return RTEMS_TOO_MANY;
}
the_timer->the_class = TIMER_DORMANT;
112b6e: 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.
*
112b75: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
* @param[in] the_heap is the heap to operate upon
112b7c: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
* @param[in] starting_address is the starting address of the memory for
112b83: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
* the heap
112b8a: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
112b91: 8b 48 08 mov 0x8(%eax),%ecx
112b94: 0f b7 d1 movzwl %cx,%edx
112b97: a1 f0 2a 13 00 mov 0x132af0,%eax
112b9c: 89 1c 90 mov %ebx,(%eax,%edx,4)
112b9f: 89 73 0c mov %esi,0xc(%ebx)
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
112ba2: 89 0f mov %ecx,(%edi)
_Thread_Enable_dispatch();
112ba4: e8 6f 2b 00 00 call 115718 <_Thread_Enable_dispatch>
112ba9: 31 c0 xor %eax,%eax
return RTEMS_SUCCESSFUL;
}
112bab: 8d 65 f4 lea -0xc(%ebp),%esp
112bae: 5b pop %ebx
112baf: 5e pop %esi
112bb0: 5f pop %edi
112bb1: c9 leave
112bb2: c3 ret
00112c10 <rtems_timer_fire_after>:
Objects_Id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
112c10: 55 push %ebp
112c11: 89 e5 mov %esp,%ebp
112c13: 57 push %edi
112c14: 56 push %esi
112c15: 53 push %ebx
112c16: 83 ec 1c sub $0x1c,%esp
112c19: 8b 7d 10 mov 0x10(%ebp),%edi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
112c1c: b8 0a 00 00 00 mov $0xa,%eax
112c21: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
112c25: 0f 84 8e 00 00 00 je 112cb9 <rtems_timer_fire_after+0xa9>
return RTEMS_INVALID_NUMBER;
if ( !routine )
112c2b: b8 09 00 00 00 mov $0x9,%eax
112c30: 85 ff test %edi,%edi
112c32: 0f 84 81 00 00 00 je 112cb9 <rtems_timer_fire_after+0xa9><== NEVER TAKEN
/**
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
112c38: 52 push %edx
112c39: 8d 45 f0 lea -0x10(%ebp),%eax
112c3c: 50 push %eax
112c3d: ff 75 08 pushl 0x8(%ebp)
112c40: 68 d4 2a 13 00 push $0x132ad4
112c45: e8 0e 23 00 00 call 114f58 <_Objects_Get>
112c4a: 89 c3 mov %eax,%ebx
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
112c4c: 83 c4 10 add $0x10,%esp
112c4f: b8 04 00 00 00 mov $0x4,%eax
112c54: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
112c58: 75 5f jne 112cb9 <rtems_timer_fire_after+0xa9>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
112c5a: 8d 73 10 lea 0x10(%ebx),%esi
112c5d: 83 ec 0c sub $0xc,%esp
112c60: 56 push %esi
112c61: e8 e6 3c 00 00 call 11694c <_Watchdog_Remove>
_ISR_Disable( level );
112c66: 9c pushf
112c67: fa cli
112c68: 5a pop %edx
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
112c69: 83 c4 10 add $0x10,%esp
112c6c: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
112c70: 74 0b je 112c7d <rtems_timer_fire_after+0x6d><== ALWAYS TAKEN
_ISR_Enable( level );
112c72: 52 push %edx <== NOT EXECUTED
112c73: 9d popf <== NOT EXECUTED
_Thread_Enable_dispatch();
112c74: e8 9f 2a 00 00 call 115718 <_Thread_Enable_dispatch><== NOT EXECUTED
112c79: 31 c0 xor %eax,%eax <== NOT EXECUTED
112c7b: eb 3c jmp 112cb9 <rtems_timer_fire_after+0xa9><== NOT EXECUTED
/*
* OK. Now we now the timer was not rescheduled by an interrupt
* so we can atomically initialize it as in use.
*/
the_timer->the_class = TIMER_INTERVAL;
112c7d: 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.
*
112c84: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
* @param[in] the_heap is the heap to operate upon
112c8b: 89 7b 2c mov %edi,0x2c(%ebx)
* @param[in] starting_address is the starting address of the memory for
112c8e: 8b 45 08 mov 0x8(%ebp),%eax
112c91: 89 43 30 mov %eax,0x30(%ebx)
* the heap
112c94: 8b 45 14 mov 0x14(%ebp),%eax
112c97: 89 43 34 mov %eax,0x34(%ebx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_ISR_Enable( level );
112c9a: 52 push %edx
112c9b: 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,
112c9c: 8b 45 0c mov 0xc(%ebp),%eax
112c9f: 89 43 1c mov %eax,0x1c(%ebx)
void *starting_address,
size_t *size
112ca2: 50 push %eax
112ca3: 50 push %eax
112ca4: 56 push %esi
112ca5: 68 c0 28 13 00 push $0x1328c0
112caa: e8 85 3b 00 00 call 116834 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
_Thread_Enable_dispatch();
112caf: e8 64 2a 00 00 call 115718 <_Thread_Enable_dispatch>
112cb4: 31 c0 xor %eax,%eax
112cb6: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112cb9: 8d 65 f4 lea -0xc(%ebp),%esp
112cbc: 5b pop %ebx
112cbd: 5e pop %esi
112cbe: 5f pop %edi
112cbf: c9 leave
112cc0: c3 ret
00112cc4 <rtems_timer_fire_when>:
Objects_Id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
112cc4: 55 push %ebp
112cc5: 89 e5 mov %esp,%ebp
112cc7: 57 push %edi
112cc8: 56 push %esi
112cc9: 53 push %ebx
112cca: 83 ec 1c sub $0x1c,%esp
112ccd: 8b 5d 0c mov 0xc(%ebp),%ebx
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
112cd0: b8 0b 00 00 00 mov $0xb,%eax
112cd5: 80 3d f4 27 13 00 00 cmpb $0x0,0x1327f4
112cdc: 0f 84 ae 00 00 00 je 112d90 <rtems_timer_fire_when+0xcc>
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
112ce2: 83 ec 0c sub $0xc,%esp
112ce5: 53 push %ebx
112ce6: e8 85 da ff ff call 110770 <_TOD_Validate>
112ceb: 83 c4 10 add $0x10,%esp
112cee: 84 c0 test %al,%al
112cf0: 0f 84 95 00 00 00 je 112d8b <rtems_timer_fire_when+0xc7>
return RTEMS_INVALID_CLOCK;
if ( !routine )
112cf6: b8 09 00 00 00 mov $0x9,%eax
112cfb: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
112cff: 0f 84 8b 00 00 00 je 112d90 <rtems_timer_fire_when+0xcc><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
112d05: 83 ec 0c sub $0xc,%esp
112d08: 53 push %ebx
112d09: e8 fa d9 ff ff call 110708 <_TOD_To_seconds>
112d0e: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch )
112d10: 83 c4 10 add $0x10,%esp
112d13: 3b 05 70 28 13 00 cmp 0x132870,%eax
112d19: 76 70 jbe 112d8b <rtems_timer_fire_when+0xc7>
/**
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
112d1b: 51 push %ecx
112d1c: 8d 45 f0 lea -0x10(%ebp),%eax
112d1f: 50 push %eax
112d20: ff 75 08 pushl 0x8(%ebp)
112d23: 68 d4 2a 13 00 push $0x132ad4
112d28: e8 2b 22 00 00 call 114f58 <_Objects_Get>
112d2d: 89 c6 mov %eax,%esi
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
112d2f: 83 c4 10 add $0x10,%esp
112d32: b8 04 00 00 00 mov $0x4,%eax
112d37: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
112d3b: 75 53 jne 112d90 <rtems_timer_fire_when+0xcc>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
112d3d: 8d 5e 10 lea 0x10(%esi),%ebx
112d40: 83 ec 0c sub $0xc,%esp
112d43: 53 push %ebx
112d44: e8 03 3c 00 00 call 11694c <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY;
112d49: c7 46 38 02 00 00 00 movl $0x2,0x38(%esi)
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
112d50: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi)
* @param[in] the_heap is the heap to operate upon
112d57: 8b 45 10 mov 0x10(%ebp),%eax
112d5a: 89 46 2c mov %eax,0x2c(%esi)
* @param[in] starting_address is the starting address of the memory for
112d5d: 8b 45 08 mov 0x8(%ebp),%eax
112d60: 89 46 30 mov %eax,0x30(%esi)
* the heap
112d63: 8b 45 14 mov 0x14(%ebp),%eax
112d66: 89 46 34 mov %eax,0x34(%esi)
* @return TRUE if successfully able to resize the block.
* FALSE if the block can't be resized in place.
*/
bool _Protected_heap_Resize_block(
Heap_Control *the_heap,
void *starting_address,
112d69: 2b 3d 70 28 13 00 sub 0x132870,%edi
112d6f: 89 7e 1c mov %edi,0x1c(%esi)
size_t size
);
112d72: 58 pop %eax
112d73: 5a pop %edx
112d74: 53 push %ebx
112d75: 68 b4 28 13 00 push $0x1328b4
112d7a: e8 b5 3a 00 00 call 116834 <_Watchdog_Insert>
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_Watchdog_Insert_seconds(
&the_timer->Ticker,
seconds - _TOD_Seconds_since_epoch
);
_Thread_Enable_dispatch();
112d7f: e8 94 29 00 00 call 115718 <_Thread_Enable_dispatch>
112d84: 31 c0 xor %eax,%eax
112d86: 83 c4 10 add $0x10,%esp
112d89: eb 05 jmp 112d90 <rtems_timer_fire_when+0xcc>
return RTEMS_SUCCESSFUL;
112d8b: b8 14 00 00 00 mov $0x14,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112d90: 8d 65 f4 lea -0xc(%ebp),%esp
112d93: 5b pop %ebx
112d94: 5e pop %esi
112d95: 5f pop %edi
112d96: c9 leave
112d97: c3 ret
00112d98 <rtems_timer_get_information>:
rtems_status_code rtems_timer_get_information(
Objects_Id id,
rtems_timer_information *the_info
)
{
112d98: 55 push %ebp
112d99: 89 e5 mov %esp,%ebp
112d9b: 53 push %ebx
112d9c: 83 ec 14 sub $0x14,%esp
112d9f: 8b 5d 0c mov 0xc(%ebp),%ebx
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
112da2: b8 09 00 00 00 mov $0x9,%eax
112da7: 85 db test %ebx,%ebx
112da9: 74 40 je 112deb <rtems_timer_get_information+0x53><== NEVER TAKEN
/**
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
112dab: 50 push %eax
112dac: 8d 45 f8 lea -0x8(%ebp),%eax
112daf: 50 push %eax
112db0: ff 75 08 pushl 0x8(%ebp)
112db3: 68 d4 2a 13 00 push $0x132ad4
112db8: e8 9b 21 00 00 call 114f58 <_Objects_Get>
112dbd: 89 c2 mov %eax,%edx
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
112dbf: 83 c4 10 add $0x10,%esp
112dc2: b8 04 00 00 00 mov $0x4,%eax
112dc7: 83 7d f8 00 cmpl $0x0,-0x8(%ebp)
112dcb: 75 1e jne 112deb <rtems_timer_get_information+0x53>
case OBJECTS_LOCAL:
the_info->the_class = the_timer->the_class;
112dcd: 8b 42 38 mov 0x38(%edx),%eax
112dd0: 89 03 mov %eax,(%ebx)
the_info->initial = the_timer->Ticker.initial;
112dd2: 8b 42 1c mov 0x1c(%edx),%eax
112dd5: 89 43 04 mov %eax,0x4(%ebx)
the_info->start_time = the_timer->Ticker.start_time;
112dd8: 8b 42 24 mov 0x24(%edx),%eax
112ddb: 89 43 08 mov %eax,0x8(%ebx)
the_info->stop_time = the_timer->Ticker.stop_time;
112dde: 8b 42 28 mov 0x28(%edx),%eax
112de1: 89 43 0c mov %eax,0xc(%ebx)
_Thread_Enable_dispatch();
112de4: e8 2f 29 00 00 call 115718 <_Thread_Enable_dispatch>
112de9: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112deb: 8b 5d fc mov -0x4(%ebp),%ebx
112dee: c9 leave
112def: c3 ret
00113048 <rtems_timer_initiate_server>:
rtems_status_code rtems_timer_initiate_server(
uint32_t priority,
uint32_t stack_size,
rtems_attribute attribute_set
)
{
113048: 55 push %ebp
113049: 89 e5 mov %esp,%ebp
11304b: 57 push %edi
11304c: 56 push %esi
11304d: 53 push %ebx
11304e: 83 ec 1c sub $0x1c,%esp
113051: 8b 55 08 mov 0x8(%ebp),%edx
113054: 8b 75 10 mov 0x10(%ebp),%esi
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
size_t size
);
113057: 31 c0 xor %eax,%eax
113059: 85 d2 test %edx,%edx
11305b: 74 0f je 11306c <rtems_timer_initiate_server+0x24>
11305d: 0f b6 05 e4 a0 12 00 movzbl 0x12a0e4,%eax
113064: 39 c2 cmp %eax,%edx
113066: 0f 96 c0 setbe %al
113069: 0f b6 c0 movzbl %al,%eax
* Make sure the requested priority is valid. The if is
* structured so we check it is invalid before looking for
* a specific invalid value as the default.
*/
_priority = priority;
if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
11306c: 89 d7 mov %edx,%edi
11306e: 85 c0 test %eax,%eax
113070: 75 0e jne 113080 <rtems_timer_initiate_server+0x38><== NEVER TAKEN
if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
113072: b8 13 00 00 00 mov $0x13,%eax
113077: 42 inc %edx
113078: 0f 85 31 01 00 00 jne 1131af <rtems_timer_initiate_server+0x167>
11307e: 31 ff xor %edi,%edi
/**
* This routine walks the heap and tots up the free and allocated
* sizes.
*
* @param[in] the_heap pointer to heap header
113080: a1 e0 27 13 00 mov 0x1327e0,%eax
113085: 40 inc %eax
113086: a3 e0 27 13 00 mov %eax,0x1327e0
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
11308b: 8a 1d 54 e2 12 00 mov 0x12e254,%bl
initialized = true;
113091: c6 05 54 e2 12 00 01 movb $0x1,0x12e254
_Thread_Enable_dispatch();
113098: e8 7b 26 00 00 call 115718 <_Thread_Enable_dispatch>
if ( tmpInitialized )
11309d: b8 0e 00 00 00 mov $0xe,%eax
1130a2: 84 db test %bl,%bl
1130a4: 0f 85 05 01 00 00 jne 1131af <rtems_timer_initiate_server+0x167>
1130aa: c7 05 74 27 13 00 78 movl $0x132778,0x132774
1130b1: 27 13 00
1130b4: c7 05 78 27 13 00 00 movl $0x0,0x132778
1130bb: 00 00 00
1130be: c7 05 7c 27 13 00 74 movl $0x132774,0x13277c
1130c5: 27 13 00
* other library rules. For example, if using a TSR written in Ada the
* Server should run at the same priority as the priority Ada task.
* Otherwise, the priority ceiling for the mutex used to protect the
* GNAT run-time is violated.
*/
status = rtems_task_create(
1130c8: 52 push %edx
1130c9: 52 push %edx
1130ca: 8d 45 f0 lea -0x10(%ebp),%eax
1130cd: 50 push %eax
1130ce: 81 ce 00 80 00 00 or $0x8000,%esi
1130d4: 56 push %esi
1130d5: 68 00 01 00 00 push $0x100
1130da: ff 75 0c pushl 0xc(%ebp)
1130dd: 57 push %edi
1130de: 68 45 4d 49 54 push $0x54494d45
1130e3: e8 70 f3 ff ff call 112458 <rtems_task_create>
/* user may want floating point but we need */
/* system task specified for 0 priority */
attribute_set | RTEMS_SYSTEM_TASK,
&id /* get the id back */
);
if (status) {
1130e8: 83 c4 20 add $0x20,%esp
1130eb: 85 c0 test %eax,%eax
1130ed: 0f 85 b5 00 00 00 jne 1131a8 <rtems_timer_initiate_server+0x160>
* to a TCB pointer from here out.
*
* NOTE: Setting the pointer to the Timer Server TCB to a value other than
* NULL indicates that task-based timer support is initialized.
*/
_Timer_Server = (Thread_Control *)_Objects_Get_local_object(
1130f3: 8b 4d f0 mov -0x10(%ebp),%ecx
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
);
/**
1130f6: 31 c0 xor %eax,%eax
1130f8: 66 3b 0d 24 27 13 00 cmp 0x132724,%cx
1130ff: 77 0b ja 11310c <rtems_timer_initiate_server+0xc4><== NEVER TAKEN
* This heap routine returns information about the free blocks
* in the specified heap.
113101: 0f b7 d1 movzwl %cx,%edx
113104: a1 30 27 13 00 mov 0x132730,%eax
113109: 8b 04 90 mov (%eax,%edx,4),%eax
11310c: a3 18 2b 13 00 mov %eax,0x132b18
113111: c7 05 54 27 13 00 58 movl $0x132758,0x132754
113118: 27 13 00
11311b: c7 05 58 27 13 00 00 movl $0x0,0x132758
113122: 00 00 00
113125: c7 05 5c 27 13 00 54 movl $0x132754,0x13275c
11312c: 27 13 00
11312f: c7 05 68 27 13 00 6c movl $0x13276c,0x132768
113136: 27 13 00
113139: c7 05 6c 27 13 00 00 movl $0x0,0x13276c
113140: 00 00 00
113143: c7 05 70 27 13 00 68 movl $0x132768,0x132770
11314a: 27 13 00
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
11314d: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
* @param[in] the_heap is the heap to operate upon
113154: c7 40 64 9c 55 11 00 movl $0x11559c,0x64(%eax)
* @param[in] starting_address is the starting address of the memory for
11315b: 89 48 68 mov %ecx,0x68(%eax)
* the heap
11315e: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax)
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
113165: c7 05 88 27 13 00 00 movl $0x0,0x132788
11316c: 00 00 00
* @param[in] the_heap is the heap to operate upon
11316f: c7 05 9c 27 13 00 9c movl $0x11559c,0x13279c
113176: 55 11 00
* @param[in] starting_address is the starting address of the memory for
113179: 89 0d a0 27 13 00 mov %ecx,0x1327a0
* the heap
11317f: c7 05 a4 27 13 00 00 movl $0x0,0x1327a4
113186: 00 00 00
/*
* Initialize the pointer to the timer reset method so applications
* that do not use the Timer Server do not have to pull it in.
*/
_Timer_Server_schedule_operation = _Timer_Server_schedule_operation_method;
113189: c7 05 14 2b 13 00 b7 movl $0x1131b7,0x132b14
113190: 31 11 00
/*
* Start the timer server
*/
status = rtems_task_start(
113193: 50 push %eax
113194: 6a 00 push $0x0
113196: 68 40 32 11 00 push $0x113240
11319b: 51 push %ecx
11319c: e8 53 f7 ff ff call 1128f4 <rtems_task_start>
id, /* the id from create */
(rtems_task_entry) _Timer_Server_body, /* the timer server entry point */
0 /* there is no argument */
);
if (status) {
1131a1: 83 c4 10 add $0x10,%esp
1131a4: 85 c0 test %eax,%eax
1131a6: 74 07 je 1131af <rtems_timer_initiate_server+0x167><== ALWAYS TAKEN
* but there is actually no way (in normal circumstances) that the
* start can fail. The id and starting address are known to be
* be good. If this service fails, something is weirdly wrong on the
* target such as a stray write in an ISR or incorrect memory layout.
*/
initialized = false;
1131a8: c6 05 54 e2 12 00 00 movb $0x0,0x12e254
}
return status;
}
1131af: 8d 65 f4 lea -0xc(%ebp),%esp
1131b2: 5b pop %ebx
1131b3: 5e pop %esi
1131b4: 5f pop %edi
1131b5: c9 leave
1131b6: c3 ret
00112e14 <rtems_timer_reset>:
*/
rtems_status_code rtems_timer_reset(
Objects_Id id
)
{
112e14: 55 push %ebp
112e15: 89 e5 mov %esp,%ebp
112e17: 53 push %ebx
112e18: 83 ec 18 sub $0x18,%esp
112e1b: 8d 45 f8 lea -0x8(%ebp),%eax
112e1e: 50 push %eax
112e1f: ff 75 08 pushl 0x8(%ebp)
112e22: 68 d4 2a 13 00 push $0x132ad4
112e27: e8 2c 21 00 00 call 114f58 <_Objects_Get>
112e2c: 89 c3 mov %eax,%ebx
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
112e2e: 83 c4 10 add $0x10,%esp
112e31: b8 04 00 00 00 mov $0x4,%eax
112e36: 83 7d f8 00 cmpl $0x0,-0x8(%ebp)
112e3a: 75 6e jne 112eaa <rtems_timer_reset+0x96>
case OBJECTS_LOCAL:
switch ( the_timer->the_class ) {
112e3c: 8b 43 38 mov 0x38(%ebx),%eax
112e3f: 83 f8 01 cmp $0x1,%eax
112e42: 74 24 je 112e68 <rtems_timer_reset+0x54>
112e44: 72 07 jb 112e4d <rtems_timer_reset+0x39>
112e46: 83 f8 04 cmp $0x4,%eax
112e49: 77 58 ja 112ea3 <rtems_timer_reset+0x8f><== NEVER TAKEN
112e4b: eb 4a jmp 112e97 <rtems_timer_reset+0x83>
case TIMER_INTERVAL:
_Watchdog_Remove( &the_timer->Ticker );
112e4d: 83 c3 10 add $0x10,%ebx
112e50: 83 ec 0c sub $0xc,%esp
112e53: 53 push %ebx
112e54: e8 f3 3a 00 00 call 11694c <_Watchdog_Remove>
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
112e59: 58 pop %eax
112e5a: 5a pop %edx
112e5b: 53 push %ebx
112e5c: 68 c0 28 13 00 push $0x1328c0
112e61: e8 ce 39 00 00 call 116834 <_Watchdog_Insert>
112e66: eb 2a jmp 112e92 <rtems_timer_reset+0x7e>
break;
case TIMER_INTERVAL_ON_TASK:
if ( !_Timer_Server_schedule_operation ) {
112e68: 83 3d 14 2b 13 00 00 cmpl $0x0,0x132b14
112e6f: 75 0c jne 112e7d <rtems_timer_reset+0x69><== ALWAYS TAKEN
_Thread_Enable_dispatch();
112e71: e8 a2 28 00 00 call 115718 <_Thread_Enable_dispatch><== NOT EXECUTED
112e76: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED
112e7b: eb 2d jmp 112eaa <rtems_timer_reset+0x96><== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
}
_Watchdog_Remove( &the_timer->Ticker );
112e7d: 83 ec 0c sub $0xc,%esp
112e80: 8d 43 10 lea 0x10(%ebx),%eax
112e83: 50 push %eax
112e84: e8 c3 3a 00 00 call 11694c <_Watchdog_Remove>
(*_Timer_Server_schedule_operation)( the_timer );
112e89: 89 1c 24 mov %ebx,(%esp)
112e8c: ff 15 14 2b 13 00 call *0x132b14
112e92: 83 c4 10 add $0x10,%esp
112e95: eb 0c jmp 112ea3 <rtems_timer_reset+0x8f>
break;
case TIMER_TIME_OF_DAY:
case TIMER_TIME_OF_DAY_ON_TASK:
case TIMER_DORMANT:
_Thread_Enable_dispatch();
112e97: e8 7c 28 00 00 call 115718 <_Thread_Enable_dispatch>
112e9c: b8 0b 00 00 00 mov $0xb,%eax
112ea1: eb 07 jmp 112eaa <rtems_timer_reset+0x96>
return RTEMS_NOT_DEFINED;
}
_Thread_Enable_dispatch();
112ea3: e8 70 28 00 00 call 115718 <_Thread_Enable_dispatch>
112ea8: 31 c0 xor %eax,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112eaa: 8b 5d fc mov -0x4(%ebp),%ebx
112ead: c9 leave
112eae: c3 ret
00112eb0 <rtems_timer_server_fire_after>:
Objects_Id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
112eb0: 55 push %ebp
112eb1: 89 e5 mov %esp,%ebp
112eb3: 57 push %edi
112eb4: 56 push %esi
112eb5: 53 push %ebx
112eb6: 83 ec 1c sub $0x1c,%esp
112eb9: 8b 7d 08 mov 0x8(%ebp),%edi
112ebc: 8b 75 10 mov 0x10(%ebp),%esi
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( !_Timer_Server )
112ebf: b8 0e 00 00 00 mov $0xe,%eax
112ec4: 83 3d 18 2b 13 00 00 cmpl $0x0,0x132b18
112ecb: 0f 84 91 00 00 00 je 112f62 <rtems_timer_server_fire_after+0xb2>
return RTEMS_INCORRECT_STATE;
if ( !routine )
112ed1: b8 09 00 00 00 mov $0x9,%eax
112ed6: 85 f6 test %esi,%esi
112ed8: 0f 84 84 00 00 00 je 112f62 <rtems_timer_server_fire_after+0xb2><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
112ede: b8 0a 00 00 00 mov $0xa,%eax
112ee3: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
112ee7: 74 79 je 112f62 <rtems_timer_server_fire_after+0xb2>
112ee9: 50 push %eax
112eea: 8d 45 f0 lea -0x10(%ebp),%eax
112eed: 50 push %eax
112eee: 57 push %edi
112eef: 68 d4 2a 13 00 push $0x132ad4
112ef4: e8 5f 20 00 00 call 114f58 <_Objects_Get>
112ef9: 89 c3 mov %eax,%ebx
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
112efb: 83 c4 10 add $0x10,%esp
112efe: b8 04 00 00 00 mov $0x4,%eax
112f03: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
112f07: 75 59 jne 112f62 <rtems_timer_server_fire_after+0xb2>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
112f09: 83 ec 0c sub $0xc,%esp
112f0c: 8d 43 10 lea 0x10(%ebx),%eax
112f0f: 50 push %eax
112f10: e8 37 3a 00 00 call 11694c <_Watchdog_Remove>
_ISR_Disable( level );
112f15: 9c pushf
112f16: fa cli
112f17: 5a pop %edx
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
112f18: 83 c4 10 add $0x10,%esp
112f1b: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
112f1f: 74 0b je 112f2c <rtems_timer_server_fire_after+0x7c><== ALWAYS TAKEN
_ISR_Enable( level );
112f21: 52 push %edx <== NOT EXECUTED
112f22: 9d popf <== NOT EXECUTED
_Thread_Enable_dispatch();
112f23: e8 f0 27 00 00 call 115718 <_Thread_Enable_dispatch><== NOT EXECUTED
112f28: 31 c0 xor %eax,%eax <== NOT EXECUTED
112f2a: eb 36 jmp 112f62 <rtems_timer_server_fire_after+0xb2><== NOT EXECUTED
/*
* OK. Now we now the timer was not rescheduled by an interrupt
* so we can atomically initialize it as in use.
*/
the_timer->the_class = TIMER_INTERVAL_ON_TASK;
112f2c: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx)
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
112f33: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
* @param[in] the_heap is the heap to operate upon
112f3a: 89 73 2c mov %esi,0x2c(%ebx)
* @param[in] starting_address is the starting address of the memory for
112f3d: 89 7b 30 mov %edi,0x30(%ebx)
* the heap
112f40: 8b 45 14 mov 0x14(%ebp),%eax
112f43: 89 43 34 mov %eax,0x34(%ebx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = ticks;
112f46: 8b 45 0c mov 0xc(%ebp),%eax
112f49: 89 43 1c mov %eax,0x1c(%ebx)
_ISR_Enable( level );
112f4c: 52 push %edx
112f4d: 9d popf
/*
* _Timer_Server_schedule_operation != NULL because we checked that
* _Timer_Server was != NULL above. Both are set at the same time.
*/
(*_Timer_Server_schedule_operation)( the_timer );
112f4e: 83 ec 0c sub $0xc,%esp
112f51: 53 push %ebx
112f52: ff 15 14 2b 13 00 call *0x132b14
_Thread_Enable_dispatch();
112f58: e8 bb 27 00 00 call 115718 <_Thread_Enable_dispatch>
112f5d: 31 c0 xor %eax,%eax
112f5f: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
112f62: 8d 65 f4 lea -0xc(%ebp),%esp
112f65: 5b pop %ebx
112f66: 5e pop %esi
112f67: 5f pop %edi
112f68: c9 leave
112f69: c3 ret
00112f6c <rtems_timer_server_fire_when>:
Objects_Id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
112f6c: 55 push %ebp
112f6d: 89 e5 mov %esp,%ebp
112f6f: 57 push %edi
112f70: 56 push %esi
112f71: 53 push %ebx
112f72: 83 ec 1c sub $0x1c,%esp
112f75: 8b 5d 0c mov 0xc(%ebp),%ebx
112f78: 8b 7d 10 mov 0x10(%ebp),%edi
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_Timer_Server )
112f7b: b8 0e 00 00 00 mov $0xe,%eax
112f80: 83 3d 18 2b 13 00 00 cmpl $0x0,0x132b18
112f87: 0f 84 b3 00 00 00 je 113040 <rtems_timer_server_fire_when+0xd4><== NEVER TAKEN
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
112f8d: b8 0b 00 00 00 mov $0xb,%eax
112f92: 80 3d f4 27 13 00 00 cmpb $0x0,0x1327f4
112f99: 0f 84 a1 00 00 00 je 113040 <rtems_timer_server_fire_when+0xd4><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
112f9f: b8 09 00 00 00 mov $0x9,%eax
112fa4: 85 ff test %edi,%edi
112fa6: 0f 84 94 00 00 00 je 113040 <rtems_timer_server_fire_when+0xd4><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
112fac: 83 ec 0c sub $0xc,%esp
112faf: 53 push %ebx
112fb0: e8 bb d7 ff ff call 110770 <_TOD_Validate>
112fb5: 83 c4 10 add $0x10,%esp
112fb8: 84 c0 test %al,%al
112fba: 74 7f je 11303b <rtems_timer_server_fire_when+0xcf><== NEVER TAKEN
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
112fbc: 83 ec 0c sub $0xc,%esp
112fbf: 53 push %ebx
112fc0: e8 43 d7 ff ff call 110708 <_TOD_To_seconds>
112fc5: 89 c6 mov %eax,%esi
if ( seconds <= _TOD_Seconds_since_epoch )
112fc7: 83 c4 10 add $0x10,%esp
112fca: 3b 05 70 28 13 00 cmp 0x132870,%eax
112fd0: 76 69 jbe 11303b <rtems_timer_server_fire_when+0xcf><== NEVER TAKEN
/**
* This routine grows @a the_heap memory area using the size bytes which
* begin at @a starting_address.
*
* @param[in] the_heap is the heap to operate upon
112fd2: 50 push %eax
112fd3: 8d 45 f0 lea -0x10(%ebp),%eax
112fd6: 50 push %eax
112fd7: ff 75 08 pushl 0x8(%ebp)
112fda: 68 d4 2a 13 00 push $0x132ad4
112fdf: e8 74 1f 00 00 call 114f58 <_Objects_Get>
112fe4: 89 c3 mov %eax,%ebx
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
112fe6: 83 c4 10 add $0x10,%esp
112fe9: b8 04 00 00 00 mov $0x4,%eax
112fee: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
112ff2: 75 4c jne 113040 <rtems_timer_server_fire_when+0xd4><== NEVER TAKEN
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
112ff4: 83 ec 0c sub $0xc,%esp
112ff7: 8d 43 10 lea 0x10(%ebx),%eax
112ffa: 50 push %eax
112ffb: e8 4c 39 00 00 call 11694c <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
113000: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx)
* This routine initializes @a the_heap record to manage the
* contiguous heap of @a size bytes which starts at @a starting_address.
* Blocks of memory are allocated from the heap in multiples of
* @a page_size byte units. If @a page_size is 0 or is not multiple of
* CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary.
*
113007: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
* @param[in] the_heap is the heap to operate upon
11300e: 89 7b 2c mov %edi,0x2c(%ebx)
* @param[in] starting_address is the starting address of the memory for
113011: 8b 45 08 mov 0x8(%ebp),%eax
113014: 89 43 30 mov %eax,0x30(%ebx)
* the heap
113017: 8b 45 14 mov 0x14(%ebp),%eax
11301a: 89 43 34 mov %eax,0x34(%ebx)
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch;
11301d: 2b 35 70 28 13 00 sub 0x132870,%esi
113023: 89 73 1c mov %esi,0x1c(%ebx)
/*
* _Timer_Server_schedule_operation != NULL because we checked that
* _Timer_Server was != NULL above. Both are set at the same time.
*/
(*_Timer_Server_schedule_operation)( the_timer );
113026: 89 1c 24 mov %ebx,(%esp)
113029: ff 15 14 2b 13 00 call *0x132b14
_Thread_Enable_dispatch();
11302f: e8 e4 26 00 00 call 115718 <_Thread_Enable_dispatch>
113034: 31 c0 xor %eax,%eax
113036: 83 c4 10 add $0x10,%esp
113039: eb 05 jmp 113040 <rtems_timer_server_fire_when+0xd4>
return RTEMS_SUCCESSFUL;
11303b: b8 14 00 00 00 mov $0x14,%eax
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
113040: 8d 65 f4 lea -0xc(%ebp),%esp
113043: 5b pop %ebx
113044: 5e pop %esi
113045: 5f pop %edi
113046: c9 leave
113047: c3 ret
00106ec1 <rtems_verror>:
static int rtems_verror(
uint32_t error_flag,
const char *printf_format,
va_list arglist
)
{
106ec1: 55 push %ebp <== NOT EXECUTED
106ec2: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106ec4: 57 push %edi <== NOT EXECUTED
106ec5: 56 push %esi <== NOT EXECUTED
106ec6: 53 push %ebx <== NOT EXECUTED
106ec7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106eca: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED
106ecd: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED
106ed0: 89 cb mov %ecx,%ebx <== NOT EXECUTED
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC)
106ed2: 25 00 00 00 20 and $0x20000000,%eax <== NOT EXECUTED
106ed7: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED
106eda: 74 2a je 106f06 <rtems_verror+0x45> <== NOT EXECUTED
{
if (rtems_panic_in_progress++)
106edc: 8b 15 38 83 12 00 mov 0x128338,%edx <== NOT EXECUTED
106ee2: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED
106ee5: a3 38 83 12 00 mov %eax,0x128338 <== NOT EXECUTED
106eea: 85 d2 test %edx,%edx <== NOT EXECUTED
106eec: 74 0b je 106ef9 <rtems_verror+0x38> <== NOT EXECUTED
106eee: a1 9c 84 12 00 mov 0x12849c,%eax <== NOT EXECUTED
106ef3: 40 inc %eax <== NOT EXECUTED
106ef4: a3 9c 84 12 00 mov %eax,0x12849c <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
106ef9: 83 3d 38 83 12 00 02 cmpl $0x2,0x128338 <== NOT EXECUTED
106f00: 0f 8f 18 01 00 00 jg 10701e <rtems_verror+0x15d> <== NOT EXECUTED
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
106f06: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106f09: a1 00 e7 11 00 mov 0x11e700,%eax <== NOT EXECUTED
106f0e: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
106f11: e8 5e 8f 00 00 call 10fe74 <fflush> <== NOT EXECUTED
status = error_flag & ~RTEMS_ERROR_MASK;
106f16: 8b 75 ec mov -0x14(%ebp),%esi <== NOT EXECUTED
106f19: 81 e6 ff ff ff 8f and $0x8fffffff,%esi <== NOT EXECUTED
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
106f1f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106f22: 31 ff xor %edi,%edi <== NOT EXECUTED
106f24: f7 45 ec 00 00 00 40 testl $0x40000000,-0x14(%ebp) <== NOT EXECUTED
106f2b: 74 07 je 106f34 <rtems_verror+0x73> <== NOT EXECUTED
local_errno = errno;
106f2d: e8 92 8c 00 00 call 10fbc4 <__errno> <== NOT EXECUTED
106f32: 8b 38 mov (%eax),%edi <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
106f34: 50 push %eax <== NOT EXECUTED
106f35: 53 push %ebx <== NOT EXECUTED
106f36: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED
106f39: a1 00 e7 11 00 mov 0x11e700,%eax <== NOT EXECUTED
106f3e: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
106f41: e8 16 d9 00 00 call 11485c <vfprintf> <== NOT EXECUTED
106f46: 89 c3 mov %eax,%ebx <== NOT EXECUTED
if (status)
106f48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106f4b: 85 f6 test %esi,%esi <== NOT EXECUTED
106f4d: 74 28 je 106f77 <rtems_verror+0xb6> <== NOT EXECUTED
const char *
rtems_status_text(
rtems_status_code status
)
{
return rtems_assoc_name_by_local(rtems_status_assoc, status);
106f4f: 50 push %eax <== NOT EXECUTED
106f50: 50 push %eax <== NOT EXECUTED
106f51: 56 push %esi <== NOT EXECUTED
106f52: 68 d8 96 11 00 push $0x1196d8 <== NOT EXECUTED
106f57: e8 60 72 00 00 call 10e1bc <rtems_assoc_name_by_local><== NOT EXECUTED
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status));
106f5c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
106f5f: 50 push %eax <== NOT EXECUTED
106f60: 68 c9 93 11 00 push $0x1193c9 <== NOT EXECUTED
106f65: a1 00 e7 11 00 mov 0x11e700,%eax <== NOT EXECUTED
106f6a: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
106f6d: e8 b2 92 00 00 call 110224 <fprintf> <== NOT EXECUTED
106f72: 01 c3 add %eax,%ebx <== NOT EXECUTED
106f74: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
if (local_errno)
106f77: 83 ff 00 cmp $0x0,%edi <== NOT EXECUTED
106f7a: 74 40 je 106fbc <rtems_verror+0xfb> <== NOT EXECUTED
{
if ((local_errno > 0) && *strerror(local_errno))
106f7c: 7e 25 jle 106fa3 <rtems_verror+0xe2> <== NOT EXECUTED
106f7e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106f81: 57 push %edi <== NOT EXECUTED
106f82: e8 79 9f 00 00 call 110f00 <strerror> <== NOT EXECUTED
106f87: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106f8a: 80 38 00 cmpb $0x0,(%eax) <== NOT EXECUTED
106f8d: 74 14 je 106fa3 <rtems_verror+0xe2> <== NOT EXECUTED
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
106f8f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106f92: 57 push %edi <== NOT EXECUTED
106f93: e8 68 9f 00 00 call 110f00 <strerror> <== NOT EXECUTED
106f98: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
106f9b: 50 push %eax <== NOT EXECUTED
106f9c: 68 d7 93 11 00 push $0x1193d7 <== NOT EXECUTED
106fa1: eb 07 jmp 106faa <rtems_verror+0xe9> <== NOT EXECUTED
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
106fa3: 50 push %eax <== NOT EXECUTED
106fa4: 57 push %edi <== NOT EXECUTED
106fa5: 68 e4 93 11 00 push $0x1193e4 <== NOT EXECUTED
106faa: a1 00 e7 11 00 mov 0x11e700,%eax <== NOT EXECUTED
106faf: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
106fb2: e8 6d 92 00 00 call 110224 <fprintf> <== NOT EXECUTED
106fb7: 01 c3 add %eax,%ebx <== NOT EXECUTED
106fb9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
chars_written += fprintf(stderr, "\n");
106fbc: 56 push %esi <== NOT EXECUTED
106fbd: 56 push %esi <== NOT EXECUTED
106fbe: 68 81 9b 11 00 push $0x119b81 <== NOT EXECUTED
106fc3: a1 00 e7 11 00 mov 0x11e700,%eax <== NOT EXECUTED
106fc8: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
106fcb: e8 54 92 00 00 call 110224 <fprintf> <== NOT EXECUTED
106fd0: 89 c6 mov %eax,%esi <== NOT EXECUTED
(void) fflush(stderr);
106fd2: 59 pop %ecx <== NOT EXECUTED
106fd3: a1 00 e7 11 00 mov 0x11e700,%eax <== NOT EXECUTED
106fd8: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED
106fdb: e8 94 8e 00 00 call 10fe74 <fflush> <== NOT EXECUTED
if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT))
106fe0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
}
chars_written += fprintf(stderr, "\n");
106fe3: 8d 04 1e lea (%esi,%ebx,1),%eax <== NOT EXECUTED
(void) fflush(stderr);
if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT))
106fe6: f7 45 ec 00 00 00 30 testl $0x30000000,-0x14(%ebp) <== NOT EXECUTED
106fed: 74 31 je 107020 <rtems_verror+0x15f> <== NOT EXECUTED
{
if (error_flag & RTEMS_ERROR_PANIC)
106fef: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED
106ff3: 74 16 je 10700b <rtems_verror+0x14a> <== NOT EXECUTED
{
rtems_error(0, "fatal error, exiting");
106ff5: 52 push %edx <== NOT EXECUTED
106ff6: 52 push %edx <== NOT EXECUTED
106ff7: 68 f8 93 11 00 push $0x1193f8 <== NOT EXECUTED
106ffc: 6a 00 push $0x0 <== NOT EXECUTED
106ffe: e8 3d 00 00 00 call 107040 <rtems_error> <== NOT EXECUTED
_exit(local_errno);
107003: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
107006: e8 fb 05 00 00 call 107606 <_exit> <== NOT EXECUTED
}
else
{
rtems_error(0, "fatal error, aborting");
10700b: 50 push %eax <== NOT EXECUTED
10700c: 50 push %eax <== NOT EXECUTED
10700d: 68 0d 94 11 00 push $0x11940d <== NOT EXECUTED
107012: 6a 00 push $0x0 <== NOT EXECUTED
107014: e8 27 00 00 00 call 107040 <rtems_error> <== NOT EXECUTED
abort();
107019: e8 72 8b 00 00 call 10fb90 <abort> <== NOT EXECUTED
10701e: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
}
return chars_written;
}
107020: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
107023: 5b pop %ebx <== NOT EXECUTED
107024: 5e pop %esi <== NOT EXECUTED
107025: 5f pop %edi <== NOT EXECUTED
107026: c9 leave <== NOT EXECUTED
107027: c3 ret <== NOT EXECUTED
00107b8b <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
107b8b: 55 push %ebp <== NOT EXECUTED
107b8c: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107b8e: 56 push %esi <== NOT EXECUTED
107b8f: 53 push %ebx <== NOT EXECUTED
107b90: 89 d6 mov %edx,%esi <== NOT EXECUTED
107b92: 88 c3 mov %al,%bl <== NOT EXECUTED
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
107b94: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx) <== NOT EXECUTED
107b9b: 74 2e je 107bcb <siproc+0x40> <== NOT EXECUTED
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
107b9d: 51 push %ecx <== NOT EXECUTED
107b9e: 6a 00 push $0x0 <== NOT EXECUTED
107ba0: 6a 00 push $0x0 <== NOT EXECUTED
107ba2: ff 72 18 pushl 0x18(%edx) <== NOT EXECUTED
107ba5: e8 ca 15 00 00 call 109174 <rtems_semaphore_obtain><== NOT EXECUTED
i = iproc (c, tty);
107baa: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED
107bad: 89 f2 mov %esi,%edx <== NOT EXECUTED
107baf: e8 c8 fe ff ff call 107a7c <iproc> <== NOT EXECUTED
107bb4: 89 c3 mov %eax,%ebx <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
107bb6: 5a pop %edx <== NOT EXECUTED
107bb7: ff 76 18 pushl 0x18(%esi) <== NOT EXECUTED
107bba: e8 9d 16 00 00 call 10925c <rtems_semaphore_release><== NOT EXECUTED
107bbf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
else {
i = iproc (c, tty);
}
return i;
}
107bc2: 89 d8 mov %ebx,%eax <== NOT EXECUTED
107bc4: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
107bc7: 5b pop %ebx <== NOT EXECUTED
107bc8: 5e pop %esi <== NOT EXECUTED
107bc9: c9 leave <== NOT EXECUTED
107bca: c3 ret <== NOT EXECUTED
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
107bcb: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
}
return i;
}
107bce: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
107bd1: 5b pop %ebx <== NOT EXECUTED
107bd2: 5e pop %esi <== NOT EXECUTED
107bd3: c9 leave <== NOT EXECUTED
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
107bd4: e9 a3 fe ff ff jmp 107a7c <iproc> <== NOT EXECUTED
00107078 <termios_baud_to_number>:
#include <sys/termios.h>
int termios_baud_to_number(
int termios_baud
)
{
107078: 55 push %ebp <== NOT EXECUTED
107079: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10707b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
case B110: baud = 110; break;
case B134: baud = 135; break;
case B150: baud = 150; break;
case B200: baud = 200; break;
case B300: baud = 300; break;
case B600: baud = 600; break;
10707e: b8 b0 04 00 00 mov $0x4b0,%eax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107083: 83 fa 09 cmp $0x9,%edx <== NOT EXECUTED
107086: 0f 84 d6 00 00 00 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
10708c: 7f 65 jg 1070f3 <termios_baud_to_number+0x7b><== NOT EXECUTED
case B0: baud = 0; break;
case B50: baud = 50; break;
case B75: baud = 75; break;
case B110: baud = 110; break;
10708e: 66 b8 87 00 mov $0x87,%ax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107092: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED
107095: 0f 84 c7 00 00 00 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
10709b: 7f 2e jg 1070cb <termios_baud_to_number+0x53><== NOT EXECUTED
10709d: b0 32 mov $0x32,%al <== NOT EXECUTED
10709f: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED
1070a2: 0f 84 ba 00 00 00 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
1070a8: 7f 09 jg 1070b3 <termios_baud_to_number+0x3b><== NOT EXECUTED
1070aa: 30 c0 xor %al,%al <== NOT EXECUTED
1070ac: 85 d2 test %edx,%edx <== NOT EXECUTED
1070ae: e9 aa 00 00 00 jmp 10715d <termios_baud_to_number+0xe5><== NOT EXECUTED
1070b3: b8 4b 00 00 00 mov $0x4b,%eax <== NOT EXECUTED
1070b8: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED
1070bb: 0f 84 a1 00 00 00 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B0: baud = 0; break;
case B50: baud = 50; break;
case B75: baud = 75; break;
1070c1: b0 6e mov $0x6e,%al <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
1070c3: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED
1070c6: e9 92 00 00 00 jmp 10715d <termios_baud_to_number+0xe5><== NOT EXECUTED
case B0: baud = 0; break;
case B50: baud = 50; break;
case B75: baud = 75; break;
case B110: baud = 110; break;
case B134: baud = 135; break;
case B150: baud = 150; break;
1070cb: b8 c8 00 00 00 mov $0xc8,%eax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
1070d0: 83 fa 06 cmp $0x6,%edx <== NOT EXECUTED
1070d3: 0f 84 89 00 00 00 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B0: baud = 0; break;
case B50: baud = 50; break;
case B75: baud = 75; break;
case B110: baud = 110; break;
case B134: baud = 135; break;
1070d9: b0 96 mov $0x96,%al <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
1070db: 0f 8c 81 00 00 00 jl 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B50: baud = 50; break;
case B75: baud = 75; break;
case B110: baud = 110; break;
case B134: baud = 135; break;
case B150: baud = 150; break;
case B200: baud = 200; break;
1070e1: 66 b8 2c 01 mov $0x12c,%ax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
1070e5: 83 fa 07 cmp $0x7,%edx <== NOT EXECUTED
1070e8: 74 78 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B75: baud = 75; break;
case B110: baud = 110; break;
case B134: baud = 135; break;
case B150: baud = 150; break;
case B200: baud = 200; break;
case B300: baud = 300; break;
1070ea: 66 b8 58 02 mov $0x258,%ax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
1070ee: 83 fa 08 cmp $0x8,%edx <== NOT EXECUTED
1070f1: eb 6a jmp 10715d <termios_baud_to_number+0xe5><== NOT EXECUTED
case B600: baud = 600; break;
case B1200: baud = 1200; break;
case B1800: baud = 1800; break;
case B2400: baud = 2400; break;
case B4800: baud = 4800; break;
case B9600: baud = 9600; break;
1070f3: b8 00 4b 00 00 mov $0x4b00,%eax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
1070f8: 83 fa 0e cmp $0xe,%edx <== NOT EXECUTED
1070fb: 74 65 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
1070fd: 7f 21 jg 107120 <termios_baud_to_number+0xa8><== NOT EXECUTED
case B150: baud = 150; break;
case B200: baud = 200; break;
case B300: baud = 300; break;
case B600: baud = 600; break;
case B1200: baud = 1200; break;
case B1800: baud = 1800; break;
1070ff: 66 b8 60 09 mov $0x960,%ax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107103: 83 fa 0b cmp $0xb,%edx <== NOT EXECUTED
107106: 74 5a je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B134: baud = 135; break;
case B150: baud = 150; break;
case B200: baud = 200; break;
case B300: baud = 300; break;
case B600: baud = 600; break;
case B1200: baud = 1200; break;
107108: 66 b8 08 07 mov $0x708,%ax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
10710c: 7c 54 jl 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B200: baud = 200; break;
case B300: baud = 300; break;
case B600: baud = 600; break;
case B1200: baud = 1200; break;
case B1800: baud = 1800; break;
case B2400: baud = 2400; break;
10710e: 66 b8 c0 12 mov $0x12c0,%ax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107112: 83 fa 0c cmp $0xc,%edx <== NOT EXECUTED
107115: 74 4b je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B300: baud = 300; break;
case B600: baud = 600; break;
case B1200: baud = 1200; break;
case B1800: baud = 1800; break;
case B2400: baud = 2400; break;
case B4800: baud = 4800; break;
107117: 66 b8 80 25 mov $0x2580,%ax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
10711b: 83 fa 0d cmp $0xd,%edx <== NOT EXECUTED
10711e: eb 3d jmp 10715d <termios_baud_to_number+0xe5><== NOT EXECUTED
case B2400: baud = 2400; break;
case B4800: baud = 4800; break;
case B9600: baud = 9600; break;
case B19200: baud = 19200; break;
case B38400: baud = 38400; break;
case B57600: baud = 57600; break;
107120: b8 00 c2 01 00 mov $0x1c200,%eax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107125: 81 fa 02 10 00 00 cmp $0x1002,%edx <== NOT EXECUTED
10712b: 74 35 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
10712d: 7f 16 jg 107145 <termios_baud_to_number+0xcd><== NOT EXECUTED
case B1200: baud = 1200; break;
case B1800: baud = 1800; break;
case B2400: baud = 2400; break;
case B4800: baud = 4800; break;
case B9600: baud = 9600; break;
case B19200: baud = 19200; break;
10712f: b8 00 96 00 00 mov $0x9600,%eax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107134: 83 fa 0f cmp $0xf,%edx <== NOT EXECUTED
107137: 74 29 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B1800: baud = 1800; break;
case B2400: baud = 2400; break;
case B4800: baud = 4800; break;
case B9600: baud = 9600; break;
case B19200: baud = 19200; break;
case B38400: baud = 38400; break;
107139: 66 b8 00 e1 mov $0xe100,%ax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
10713d: 81 fa 01 10 00 00 cmp $0x1001,%edx <== NOT EXECUTED
107143: eb 18 jmp 10715d <termios_baud_to_number+0xe5><== NOT EXECUTED
case B4800: baud = 4800; break;
case B9600: baud = 9600; break;
case B19200: baud = 19200; break;
case B38400: baud = 38400; break;
case B57600: baud = 57600; break;
case B115200: baud = 115200; break;
107145: b8 00 84 03 00 mov $0x38400,%eax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
10714a: 81 fa 03 10 00 00 cmp $0x1003,%edx <== NOT EXECUTED
107150: 74 10 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B9600: baud = 9600; break;
case B19200: baud = 19200; break;
case B38400: baud = 38400; break;
case B57600: baud = 57600; break;
case B115200: baud = 115200; break;
case B230400: baud = 230400; break;
107152: b8 00 08 07 00 mov $0x70800,%eax <== NOT EXECUTED
int termios_baud
)
{
int baud;
switch (termios_baud) {
107157: 81 fa 04 10 00 00 cmp $0x1004,%edx <== NOT EXECUTED
10715d: 74 03 je 107162 <termios_baud_to_number+0xea><== NOT EXECUTED
case B19200: baud = 19200; break;
case B38400: baud = 38400; break;
case B57600: baud = 57600; break;
case B115200: baud = 115200; break;
case B230400: baud = 230400; break;
case B460800: baud = 460800; break;
10715f: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
default: baud = -1; break;
}
return baud;
}
107162: c9 leave <== NOT EXECUTED
107163: c3 ret <== NOT EXECUTED
00106dc4 <vprintk>:
*/
void vprintk(
const char *fmt,
va_list ap
)
{
106dc4: 55 push %ebp
106dc5: 89 e5 mov %esp,%ebp
106dc7: 57 push %edi
106dc8: 56 push %esi
106dc9: 53 push %ebx
106dca: 83 ec 4c sub $0x4c,%esp
106dcd: 8b 7d 08 mov 0x8(%ebp),%edi
106dd0: e9 6d 02 00 00 jmp 107042 <vprintk+0x27e>
base = 0;
sign = 0;
width = 0;
minus = 0;
lead = ' ';
if (*fmt == '%') {
106dd5: 3c 25 cmp $0x25,%al
106dd7: 0f 85 54 02 00 00 jne 107031 <vprintk+0x26d>
fmt++;
106ddd: 47 inc %edi
if (*fmt == '0' ) {
106dde: c7 45 c8 20 00 00 00 movl $0x20,-0x38(%ebp)
106de5: 80 3f 30 cmpb $0x30,(%edi)
106de8: 75 08 jne 106df2 <vprintk+0x2e>
lead = '0';
fmt++;
106dea: 47 inc %edi
106deb: c7 45 c8 30 00 00 00 movl $0x30,-0x38(%ebp)
}
if (*fmt == '-' ) {
106df2: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp)
106df9: 80 3f 2d cmpb $0x2d,(%edi)
106dfc: 75 08 jne 106e06 <vprintk+0x42>
minus = 1;
fmt++;
106dfe: 47 inc %edi
106dff: c7 45 cc 01 00 00 00 movl $0x1,-0x34(%ebp)
106e06: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
106e0d: eb 0f jmp 106e1e <vprintk+0x5a>
}
while (*fmt >= '0' && *fmt <= '9' ) {
width *= 10;
106e0f: 6b 55 c4 0a imul $0xa,-0x3c(%ebp),%edx
width += (*fmt - '0');
106e13: 0f be c1 movsbl %cl,%eax
106e16: 8d 44 02 d0 lea -0x30(%edx,%eax,1),%eax
106e1a: 89 45 c4 mov %eax,-0x3c(%ebp)
fmt++;
106e1d: 47 inc %edi
}
if (*fmt == '-' ) {
minus = 1;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
106e1e: 8a 0f mov (%edi),%cl
106e20: 8d 41 d0 lea -0x30(%ecx),%eax
106e23: 3c 09 cmp $0x9,%al
106e25: 76 e8 jbe 106e0f <vprintk+0x4b>
width *= 10;
width += (*fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
106e27: 31 d2 xor %edx,%edx
106e29: 80 f9 6c cmp $0x6c,%cl
106e2c: 75 08 jne 106e36 <vprintk+0x72>
lflag = 1;
c = *++fmt;
106e2e: 47 inc %edi
106e2f: 8a 0f mov (%edi),%cl
106e31: ba 01 00 00 00 mov $0x1,%edx
}
switch (c) {
106e36: 80 f9 64 cmp $0x64,%cl
106e39: 74 71 je 106eac <vprintk+0xe8>
106e3b: 7f 38 jg 106e75 <vprintk+0xb1>
106e3d: 80 f9 4f cmp $0x4f,%cl
106e40: 0f 84 32 01 00 00 je 106f78 <vprintk+0x1b4> <== NEVER TAKEN
106e46: 7f 10 jg 106e58 <vprintk+0x94> <== NEVER TAKEN
106e48: 80 f9 44 cmp $0x44,%cl
106e4b: 74 5f je 106eac <vprintk+0xe8> <== NEVER TAKEN
106e4d: 80 f9 49 cmp $0x49,%cl
106e50: 0f 85 17 01 00 00 jne 106f6d <vprintk+0x1a9> <== ALWAYS TAKEN
106e56: eb 54 jmp 106eac <vprintk+0xe8> <== NOT EXECUTED
106e58: 80 f9 58 cmp $0x58,%cl <== NOT EXECUTED
106e5b: 0f 84 20 01 00 00 je 106f81 <vprintk+0x1bd> <== NOT EXECUTED
106e61: 80 f9 63 cmp $0x63,%cl <== NOT EXECUTED
106e64: 0f 84 e5 00 00 00 je 106f4f <vprintk+0x18b> <== NOT EXECUTED
106e6a: 80 f9 55 cmp $0x55,%cl <== NOT EXECUTED
106e6d: 0f 85 fa 00 00 00 jne 106f6d <vprintk+0x1a9> <== NOT EXECUTED
106e73: eb 3e jmp 106eb3 <vprintk+0xef> <== NOT EXECUTED
106e75: 80 f9 70 cmp $0x70,%cl
106e78: 0f 84 03 01 00 00 je 106f81 <vprintk+0x1bd> <== NEVER TAKEN
106e7e: 7f 13 jg 106e93 <vprintk+0xcf> <== ALWAYS TAKEN
106e80: 80 f9 69 cmp $0x69,%cl <== NOT EXECUTED
106e83: 74 27 je 106eac <vprintk+0xe8> <== NOT EXECUTED
106e85: 80 f9 6f cmp $0x6f,%cl <== NOT EXECUTED
106e88: 0f 85 df 00 00 00 jne 106f6d <vprintk+0x1a9> <== NOT EXECUTED
106e8e: e9 e5 00 00 00 jmp 106f78 <vprintk+0x1b4> <== NOT EXECUTED
106e93: 80 f9 75 cmp $0x75,%cl
106e96: 74 1b je 106eb3 <vprintk+0xef>
106e98: 80 f9 78 cmp $0x78,%cl
106e9b: 0f 84 e0 00 00 00 je 106f81 <vprintk+0x1bd>
106ea1: 80 f9 73 cmp $0x73,%cl
106ea4: 0f 85 c3 00 00 00 jne 106f6d <vprintk+0x1a9> <== NEVER TAKEN
106eaa: eb 13 jmp 106ebf <vprintk+0xfb>
106eac: b8 01 00 00 00 mov $0x1,%eax
106eb1: eb 02 jmp 106eb5 <vprintk+0xf1>
106eb3: 31 c0 xor %eax,%eax
106eb5: be 0a 00 00 00 mov $0xa,%esi
106eba: e9 c9 00 00 00 jmp 106f88 <vprintk+0x1c4>
case 'p': base = 16; sign = 0; break;
case 's':
{ int i, len;
char *s;
str = va_arg(ap, char *);
106ebf: 8b 45 0c mov 0xc(%ebp),%eax
106ec2: 83 c0 04 add $0x4,%eax
106ec5: 89 45 d0 mov %eax,-0x30(%ebp)
106ec8: 8b 55 0c mov 0xc(%ebp),%edx
106ecb: 8b 12 mov (%edx),%edx
106ecd: 89 55 c0 mov %edx,-0x40(%ebp)
106ed0: 31 f6 xor %esi,%esi
106ed2: eb 01 jmp 106ed5 <vprintk+0x111>
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
106ed4: 46 inc %esi
106ed5: 8b 4d c0 mov -0x40(%ebp),%ecx
106ed8: 80 3c 31 00 cmpb $0x0,(%ecx,%esi,1)
106edc: 75 f6 jne 106ed4 <vprintk+0x110>
;
/* leading spaces */
if ( !minus )
106ede: 89 f3 mov %esi,%ebx
106ee0: 83 7d cc 00 cmpl $0x0,-0x34(%ebp)
106ee4: 74 11 je 106ef7 <vprintk+0x133>
106ee6: eb 14 jmp 106efc <vprintk+0x138>
for ( i=len ; i<width ; i++ )
BSP_output_char(' ');
106ee8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106eeb: 6a 20 push $0x20 <== NOT EXECUTED
106eed: ff 15 dc 87 11 00 call *0x1187dc <== NOT EXECUTED
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
106ef3: 43 inc %ebx <== NOT EXECUTED
106ef4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106ef7: 3b 5d c4 cmp -0x3c(%ebp),%ebx
106efa: 7c ec jl 106ee8 <vprintk+0x124> <== NEVER TAKEN
BSP_output_char(' ');
/* no width option */
if (width == 0) {
106efc: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
106f00: 75 03 jne 106f05 <vprintk+0x141>
106f02: 89 75 c4 mov %esi,-0x3c(%ebp)
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
106f05: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
106f09: 7e 1e jle 106f29 <vprintk+0x165> <== NEVER TAKEN
106f0b: eb 13 jmp 106f20 <vprintk+0x15c>
BSP_output_char(*str);
106f0d: 83 ec 0c sub $0xc,%esp
106f10: 0f be c0 movsbl %al,%eax
106f13: 50 push %eax
106f14: ff 15 dc 87 11 00 call *0x1187dc
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
106f1a: ff 45 c0 incl -0x40(%ebp)
106f1d: 83 c4 10 add $0x10,%esp
106f20: 8b 55 c0 mov -0x40(%ebp),%edx
106f23: 8a 02 mov (%edx),%al
106f25: 84 c0 test %al,%al
106f27: 75 e4 jne 106f0d <vprintk+0x149>
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
106f29: 89 f3 mov %esi,%ebx
106f2b: 83 7d cc 00 cmpl $0x0,-0x34(%ebp)
106f2f: 75 14 jne 106f45 <vprintk+0x181>
106f31: e9 18 01 00 00 jmp 10704e <vprintk+0x28a>
for ( i=len ; i<width ; i++ )
BSP_output_char(' ');
106f36: 83 ec 0c sub $0xc,%esp
106f39: 6a 20 push $0x20
106f3b: ff 15 dc 87 11 00 call *0x1187dc
for ( i=0 ; i<width && *str ; str++ )
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
106f41: 43 inc %ebx
106f42: 83 c4 10 add $0x10,%esp
106f45: 3b 5d c4 cmp -0x3c(%ebp),%ebx
106f48: 7c ec jl 106f36 <vprintk+0x172>
106f4a: e9 ff 00 00 00 jmp 10704e <vprintk+0x28a>
BSP_output_char(' ');
}
break;
case 'c':
BSP_output_char(va_arg(ap, int));
106f4f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED
106f52: 83 c3 04 add $0x4,%ebx <== NOT EXECUTED
106f55: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106f58: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
106f5b: 0f be 01 movsbl (%ecx),%eax <== NOT EXECUTED
106f5e: 50 push %eax <== NOT EXECUTED
106f5f: ff 15 dc 87 11 00 call *0x1187dc <== NOT EXECUTED
106f65: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED
106f68: e9 d1 00 00 00 jmp 10703e <vprintk+0x27a> <== NOT EXECUTED
break;
default:
BSP_output_char(c);
106f6d: 83 ec 0c sub $0xc,%esp
106f70: 0f be c1 movsbl %cl,%eax
106f73: e9 bf 00 00 00 jmp 107037 <vprintk+0x273>
106f78: 31 c0 xor %eax,%eax
106f7a: be 08 00 00 00 mov $0x8,%esi <== NOT EXECUTED
106f7f: eb 07 jmp 106f88 <vprintk+0x1c4> <== NOT EXECUTED
106f81: 31 c0 xor %eax,%eax
106f83: be 10 00 00 00 mov $0x10,%esi
break;
} /* switch*/
if (base)
printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int),
106f88: 85 d2 test %edx,%edx
106f8a: 8b 4d 0c mov 0xc(%ebp),%ecx
106f8d: 8d 51 04 lea 0x4(%ecx),%edx
106f90: 75 03 jne 106f95 <vprintk+0x1d1> <== ALWAYS TAKEN
106f92: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
106f95: 8b 19 mov (%ecx),%ebx
106f97: 89 55 0c mov %edx,0xc(%ebp)
{
long unsigned int n;
int count;
char toPrint[20];
if ( (sign == 1) && ((long)num < 0) ) {
106f9a: 48 dec %eax
106f9b: 75 1c jne 106fb9 <vprintk+0x1f5>
106f9d: 85 db test %ebx,%ebx
106f9f: 79 18 jns 106fb9 <vprintk+0x1f5> <== ALWAYS TAKEN
BSP_output_char('-');
106fa1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
106fa4: 6a 2d push $0x2d <== NOT EXECUTED
106fa6: ff 15 dc 87 11 00 call *0x1187dc <== NOT EXECUTED
num = -num;
106fac: f7 db neg %ebx <== NOT EXECUTED
if (maxwidth) maxwidth--;
106fae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
106fb1: 83 7d c4 01 cmpl $0x1,-0x3c(%ebp) <== NOT EXECUTED
106fb5: 83 55 c4 ff adcl $0xffffffff,-0x3c(%ebp) <== NOT EXECUTED
106fb9: 31 c9 xor %ecx,%ecx
106fbb: eb 12 jmp 106fcf <vprintk+0x20b>
}
count = 0;
while ((n = num / base) > 0) {
toPrint[count++] = (num - (n*base));
106fbd: 8b 45 b4 mov -0x4c(%ebp),%eax
106fc0: 0f af c6 imul %esi,%eax
106fc3: 28 c3 sub %al,%bl
106fc5: 88 5c 0d e0 mov %bl,-0x20(%ebp,%ecx,1)
106fc9: 8b 4d b8 mov -0x48(%ebp),%ecx
106fcc: 8b 5d b4 mov -0x4c(%ebp),%ebx
num = -num;
if (maxwidth) maxwidth--;
}
count = 0;
while ((n = num / base) > 0) {
106fcf: 89 d8 mov %ebx,%eax
106fd1: 31 d2 xor %edx,%edx
106fd3: f7 f6 div %esi
106fd5: 89 45 b4 mov %eax,-0x4c(%ebp)
106fd8: 85 c0 test %eax,%eax
106fda: 8d 41 01 lea 0x1(%ecx),%eax
106fdd: 89 45 b8 mov %eax,-0x48(%ebp)
106fe0: 75 db jne 106fbd <vprintk+0x1f9>
toPrint[count++] = (num - (n*base));
num = n;
}
toPrint[count++] = num;
106fe2: 88 5c 0d e0 mov %bl,-0x20(%ebp,%ecx,1)
for (n=maxwidth ; n > count; n-- )
106fe6: 8b 5d c4 mov -0x3c(%ebp),%ebx
BSP_output_char(lead);
106fe9: 0f be 75 c8 movsbl -0x38(%ebp),%esi
106fed: eb 0e jmp 106ffd <vprintk+0x239>
106fef: 83 ec 0c sub $0xc,%esp
106ff2: 56 push %esi
106ff3: ff 15 dc 87 11 00 call *0x1187dc
toPrint[count++] = (num - (n*base));
num = n;
}
toPrint[count++] = num;
for (n=maxwidth ; n > count; n-- )
106ff9: 4b dec %ebx
106ffa: 83 c4 10 add $0x10,%esp
106ffd: 3b 5d b8 cmp -0x48(%ebp),%ebx
107000: 77 ed ja 106fef <vprintk+0x22b>
107002: 31 db xor %ebx,%ebx
BSP_output_char(lead);
for (n = 0; n < count; n++) {
BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
107004: 8d 75 f4 lea -0xc(%ebp),%esi
107007: 03 75 b8 add -0x48(%ebp),%esi
10700a: eb 1e jmp 10702a <vprintk+0x266>
10700c: 83 ec 0c sub $0xc,%esp
10700f: 89 d8 mov %ebx,%eax
107011: f7 d0 not %eax
107013: 0f be 44 30 ec movsbl -0x14(%eax,%esi,1),%eax
107018: 0f be 80 f6 67 11 00 movsbl 0x1167f6(%eax),%eax
10701f: 50 push %eax
107020: ff 15 dc 87 11 00 call *0x1187dc
toPrint[count++] = num;
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
107026: 43 inc %ebx
107027: 83 c4 10 add $0x10,%esp
10702a: 3b 5d b8 cmp -0x48(%ebp),%ebx
10702d: 72 dd jb 10700c <vprintk+0x248>
10702f: eb 10 jmp 107041 <vprintk+0x27d>
if (base)
printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int),
base, sign, width, lead);
} else {
BSP_output_char(*fmt);
107031: 83 ec 0c sub $0xc,%esp
107034: 0f be c0 movsbl %al,%eax
107037: 50 push %eax
107038: ff 15 dc 87 11 00 call *0x1187dc
10703e: 83 c4 10 add $0x10,%esp
)
{
char c, *str;
int lflag, base, sign, width, lead, minus;
for (; *fmt != '\0'; fmt++) {
107041: 47 inc %edi
107042: 8a 07 mov (%edi),%al
107044: 84 c0 test %al,%al
107046: 0f 85 89 fd ff ff jne 106dd5 <vprintk+0x11>
10704c: eb 08 jmp 107056 <vprintk+0x292>
base, sign, width, lead);
} else {
BSP_output_char(*fmt);
}
}
}
10704e: 8b 55 d0 mov -0x30(%ebp),%edx
107051: 89 55 0c mov %edx,0xc(%ebp)
107054: eb eb jmp 107041 <vprintk+0x27d>
107056: 8d 65 f4 lea -0xc(%ebp),%esp
107059: 5b pop %ebx
10705a: 5e pop %esi
10705b: 5f pop %edi
10705c: c9 leave
10705d: c3 ret
00114f00 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
114f00: 55 push %ebp
114f01: 89 e5 mov %esp,%ebp
114f03: 56 push %esi
114f04: 53 push %ebx
114f05: 8b 45 08 mov 0x8(%ebp),%eax
114f08: 8b 75 0c mov 0xc(%ebp),%esi
114f0b: 8b 4d 10 mov 0x10(%ebp),%ecx
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
114f0e: 3b 05 b8 86 11 00 cmp 0x1186b8,%eax
114f14: 73 2d jae 114f43 <write+0x43> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
114f16: 6b d8 34 imul $0x34,%eax,%ebx
114f19: 03 1d 80 c9 11 00 add 0x11c980,%ebx
rtems_libio_check_is_open( iop );
114f1f: 8b 53 0c mov 0xc(%ebx),%edx
114f22: f6 c6 01 test $0x1,%dh
114f25: 74 1c je 114f43 <write+0x43> <== NEVER TAKEN
rtems_libio_check_buffer( buffer );
114f27: 85 f6 test %esi,%esi
114f29: 75 0d jne 114f38 <write+0x38> <== ALWAYS TAKEN
114f2b: e8 a0 97 ff ff call 10e6d0 <__errno> <== NOT EXECUTED
114f30: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
114f36: eb 2d jmp 114f65 <write+0x65> <== NOT EXECUTED
rtems_libio_check_count( count );
114f38: 31 c0 xor %eax,%eax
114f3a: 85 c9 test %ecx,%ecx
114f3c: 74 3c je 114f7a <write+0x7a> <== NEVER TAKEN
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
114f3e: 80 e2 04 and $0x4,%dl
114f41: 75 0d jne 114f50 <write+0x50> <== ALWAYS TAKEN
114f43: e8 88 97 ff ff call 10e6d0 <__errno> <== NOT EXECUTED
114f48: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED
114f4e: eb 15 jmp 114f65 <write+0x65> <== NOT EXECUTED
/*
* Now process the write() request.
*/
if ( !iop->handlers->write_h )
114f50: 8b 43 30 mov 0x30(%ebx),%eax
114f53: 8b 40 0c mov 0xc(%eax),%eax
114f56: 85 c0 test %eax,%eax
114f58: 75 10 jne 114f6a <write+0x6a> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTSUP );
114f5a: e8 71 97 ff ff call 10e6d0 <__errno> <== NOT EXECUTED
114f5f: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED
114f65: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
114f68: eb 10 jmp 114f7a <write+0x7a> <== NOT EXECUTED
rc = (*iop->handlers->write_h)( iop, buffer, count );
114f6a: 52 push %edx
114f6b: 51 push %ecx
114f6c: 56 push %esi
114f6d: 53 push %ebx
114f6e: ff d0 call *%eax
if ( rc > 0 )
114f70: 83 c4 10 add $0x10,%esp
114f73: 85 c0 test %eax,%eax
114f75: 7e 03 jle 114f7a <write+0x7a> <== NEVER TAKEN
iop->offset += rc;
114f77: 01 43 08 add %eax,0x8(%ebx)
return rc;
}
114f7a: 8d 65 f8 lea -0x8(%ebp),%esp
114f7d: 5b pop %ebx
114f7e: 5e pop %esi
114f7f: c9 leave
114f80: c3 ret