RTEMS 4.11Annotated Report
Fri Feb 18 17:39:28 2011
0010d6d8 <IMFS_Set_handlers>:
#define MAXSYMLINK 5
int IMFS_Set_handlers(
rtems_filesystem_location_info_t *loc
)
{
10d6d8: 55 push %ebp
10d6d9: 89 e5 mov %esp,%ebp
10d6db: 8b 45 08 mov 0x8(%ebp),%eax
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
10d6de: 8b 50 10 mov 0x10(%eax),%edx
10d6e1: 8b 52 34 mov 0x34(%edx),%edx
switch( node->type ) {
10d6e4: 8b 08 mov (%eax),%ecx
10d6e6: 8b 49 4c mov 0x4c(%ecx),%ecx
10d6e9: 49 dec %ecx
10d6ea: 83 f9 06 cmp $0x6,%ecx
10d6ed: 77 29 ja 10d718 <IMFS_Set_handlers+0x40><== NEVER TAKEN
10d6ef: ff 24 8d 2c f3 11 00 jmp *0x11f32c(,%ecx,4)
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
10d6f6: 8b 52 0c mov 0xc(%edx),%edx
10d6f9: eb 1a jmp 10d715 <IMFS_Set_handlers+0x3d>
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
10d6fb: c7 40 08 50 f3 11 00 movl $0x11f350,0x8(%eax)
break;
10d702: eb 14 jmp 10d718 <IMFS_Set_handlers+0x40>
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
10d704: c7 40 08 c0 f3 11 00 movl $0x11f3c0,0x8(%eax)
break;
10d70b: eb 0b jmp 10d718 <IMFS_Set_handlers+0x40>
case IMFS_LINEAR_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
10d70d: 8b 52 08 mov 0x8(%edx),%edx
10d710: eb 03 jmp 10d715 <IMFS_Set_handlers+0x3d>
break;
case IMFS_FIFO:
loc->handlers = fs_info->fifo_handlers;
10d712: 8b 52 10 mov 0x10(%edx),%edx
10d715: 89 50 08 mov %edx,0x8(%eax)
break;
}
return 0;
}
10d718: 31 c0 xor %eax,%eax
10d71a: c9 leave
10d71b: c3 ret
0010d58b <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
10d58b: 55 push %ebp
10d58c: 89 e5 mov %esp,%ebp
10d58e: 57 push %edi
10d58f: 56 push %esi
10d590: 53 push %ebx
10d591: 83 ec 1c sub $0x1c,%esp
10d594: 8b 4d 08 mov 0x8(%ebp),%ecx
10d597: 8b 5d 0c mov 0xc(%ebp),%ebx
10d59a: 8b 75 18 mov 0x18(%ebp),%esi
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
return NULL;
10d59d: 31 c0 xor %eax,%eax
IMFS_fs_info_t *fs_info;
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
10d59f: 85 c9 test %ecx,%ecx
10d5a1: 0f 84 f4 00 00 00 je 10d69b <IMFS_create_node+0x110><== NEVER TAKEN
return NULL;
parent = parent_loc->node_access;
10d5a7: 8b 11 mov (%ecx),%edx
fs_info = parent_loc->mt_entry->fs_info;
10d5a9: 8b 49 10 mov 0x10(%ecx),%ecx
10d5ac: 8b 79 34 mov 0x34(%ecx),%edi
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
10d5af: 83 fb 07 cmp $0x7,%ebx
10d5b2: 75 0d jne 10d5c1 <IMFS_create_node+0x36>
10d5b4: 81 7f 10 c4 f2 11 00 cmpl $0x11f2c4,0x10(%edi)
10d5bb: 0f 84 da 00 00 00 je 10d69b <IMFS_create_node+0x110>
return NULL;
/*
* Allocate filesystem node and fill in basic information
*/
node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
10d5c1: 50 push %eax
10d5c2: a1 80 30 12 00 mov 0x123080,%eax
10d5c7: 8b 40 2c mov 0x2c(%eax),%eax
10d5ca: f7 d0 not %eax
10d5cc: 23 45 14 and 0x14(%ebp),%eax
10d5cf: 50 push %eax
10d5d0: ff 75 10 pushl 0x10(%ebp)
10d5d3: 53 push %ebx
10d5d4: 89 55 e4 mov %edx,-0x1c(%ebp)
10d5d7: e8 40 ff ff ff call 10d51c <IMFS_allocate_node>
if ( !node )
10d5dc: 83 c4 10 add $0x10,%esp
10d5df: 85 c0 test %eax,%eax
10d5e1: 8b 55 e4 mov -0x1c(%ebp),%edx
10d5e4: 0f 84 b1 00 00 00 je 10d69b <IMFS_create_node+0x110>
return NULL;
/*
* Set the type specific information
*/
if ( type == IMFS_DIRECTORY ) {
10d5ea: 83 fb 01 cmp $0x1,%ebx
10d5ed: 75 15 jne 10d604 <IMFS_create_node+0x79>
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
10d5ef: 8d 48 54 lea 0x54(%eax),%ecx
10d5f2: 89 48 50 mov %ecx,0x50(%eax)
head->next = tail;
head->previous = NULL;
10d5f5: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
10d5fc: 8d 48 50 lea 0x50(%eax),%ecx
10d5ff: 89 48 58 mov %ecx,0x58(%eax)
10d602: eb 75 jmp 10d679 <IMFS_create_node+0xee>
rtems_chain_initialize_empty(&node->info.directory.Entries);
} else if ( type == IMFS_HARD_LINK ) {
10d604: 83 fb 03 cmp $0x3,%ebx
10d607: 74 05 je 10d60e <IMFS_create_node+0x83>
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
10d609: 83 fb 04 cmp $0x4,%ebx
10d60c: 75 07 jne 10d615 <IMFS_create_node+0x8a>
node->info.sym_link.name = info->sym_link.name;
10d60e: 8b 0e mov (%esi),%ecx
10d610: 89 48 50 mov %ecx,0x50(%eax)
10d613: eb 64 jmp 10d679 <IMFS_create_node+0xee>
} else if ( type == IMFS_DEVICE ) {
10d615: 83 fb 02 cmp $0x2,%ebx
10d618: 75 0d jne 10d627 <IMFS_create_node+0x9c>
node->info.device.major = info->device.major;
10d61a: 8b 0e mov (%esi),%ecx
10d61c: 89 48 50 mov %ecx,0x50(%eax)
node->info.device.minor = info->device.minor;
10d61f: 8b 4e 04 mov 0x4(%esi),%ecx
10d622: 89 48 54 mov %ecx,0x54(%eax)
10d625: eb 52 jmp 10d679 <IMFS_create_node+0xee>
} else if ( type == IMFS_LINEAR_FILE ) {
10d627: 83 fb 06 cmp $0x6,%ebx
10d62a: 75 17 jne 10d643 <IMFS_create_node+0xb8>
node->info.linearfile.size = 0;
10d62c: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
10d633: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.linearfile.direct = 0;
10d63a: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
10d641: eb 36 jmp 10d679 <IMFS_create_node+0xee>
} else if ( type == IMFS_MEMORY_FILE ) {
10d643: 83 fb 05 cmp $0x5,%ebx
10d646: 75 25 jne 10d66d <IMFS_create_node+0xe2>
node->info.file.size = 0;
10d648: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
10d64f: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.file.indirect = 0;
10d656: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
node->info.file.doubly_indirect = 0;
10d65d: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
node->info.file.triply_indirect = 0;
10d664: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
10d66b: eb 0c jmp 10d679 <IMFS_create_node+0xee>
} else if ( type == IMFS_FIFO ) {
10d66d: 83 fb 07 cmp $0x7,%ebx
10d670: 75 07 jne 10d679 <IMFS_create_node+0xee> <== NEVER TAKEN
node->info.fifo.pipe = NULL;
10d672: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax)
}
/*
* This node MUST have a parent, so put it in that directory list.
*/
node->Parent = parent;
10d679: 89 50 08 mov %edx,0x8(%eax)
node->st_ino = ++fs_info->ino_count;
10d67c: 8b 4f 04 mov 0x4(%edi),%ecx
10d67f: 41 inc %ecx
10d680: 89 4f 04 mov %ecx,0x4(%edi)
10d683: 89 48 38 mov %ecx,0x38(%eax)
10d686: 53 push %ebx
10d687: 53 push %ebx
10d688: 50 push %eax
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
10d689: 83 c2 50 add $0x50,%edx
10d68c: 52 push %edx
10d68d: 89 45 e4 mov %eax,-0x1c(%ebp)
10d690: e8 4b d3 ff ff call 10a9e0 <_Chain_Append>
return node;
10d695: 83 c4 10 add $0x10,%esp
10d698: 8b 45 e4 mov -0x1c(%ebp),%eax
}
10d69b: 8d 65 f4 lea -0xc(%ebp),%esp
10d69e: 5b pop %ebx
10d69f: 5e pop %esi
10d6a0: 5f pop %edi
10d6a1: c9 leave
10d6a2: c3 ret
0010d7b9 <IMFS_eval_path>:
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
10d7b9: 55 push %ebp
10d7ba: 89 e5 mov %esp,%ebp
10d7bc: 57 push %edi
10d7bd: 56 push %esi
10d7be: 53 push %ebx
10d7bf: 83 ec 5c sub $0x5c,%esp
10d7c2: 8b 5d 14 mov 0x14(%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 ) ) {
10d7c5: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp)
10d7cc: 74 0d je 10d7db <IMFS_eval_path+0x22> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO );
10d7ce: e8 f9 38 00 00 call 1110cc <__errno> <== NOT EXECUTED
10d7d3: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED
10d7d9: eb 42 jmp 10d81d <IMFS_eval_path+0x64> <== NOT EXECUTED
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
10d7db: 8b 3b mov (%ebx),%edi
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
int i = 0;
int len;
IMFS_token_types type = IMFS_CURRENT_DIR;
10d7dd: be 01 00 00 00 mov $0x1,%esi
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
int i = 0;
10d7e2: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp)
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
10d7e9: e9 29 01 00 00 jmp 10d917 <IMFS_eval_path+0x15e>
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
10d7ee: 8d 45 e4 lea -0x1c(%ebp),%eax
10d7f1: 50 push %eax
10d7f2: 8d 4d af lea -0x51(%ebp),%ecx
10d7f5: 51 push %ecx
10d7f6: ff 75 0c pushl 0xc(%ebp)
10d7f9: 8b 45 08 mov 0x8(%ebp),%eax
10d7fc: 03 45 a4 add -0x5c(%ebp),%eax
10d7ff: 50 push %eax
10d800: e8 b3 05 00 00 call 10ddb8 <IMFS_get_token>
10d805: 89 c6 mov %eax,%esi
pathnamelen -= len;
10d807: 8b 55 e4 mov -0x1c(%ebp),%edx
i += len;
if ( !pathloc->node_access )
10d80a: 83 c4 10 add $0x10,%esp
10d80d: 83 3b 00 cmpl $0x0,(%ebx)
10d810: 75 13 jne 10d825 <IMFS_eval_path+0x6c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOENT );
10d812: e8 b5 38 00 00 call 1110cc <__errno>
10d817: c7 00 02 00 00 00 movl $0x2,(%eax)
10d81d: 83 cf ff or $0xffffffff,%edi
10d820: e9 75 01 00 00 jmp 10d99a <IMFS_eval_path+0x1e1>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
10d825: 85 c0 test %eax,%eax
10d827: 74 21 je 10d84a <IMFS_eval_path+0x91>
if ( node->type == IMFS_DIRECTORY )
10d829: 83 7f 4c 01 cmpl $0x1,0x4c(%edi)
10d82d: 75 1b jne 10d84a <IMFS_eval_path+0x91>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
10d82f: 57 push %edi
10d830: 57 push %edi
10d831: 6a 01 push $0x1
10d833: 53 push %ebx
10d834: 89 55 a0 mov %edx,-0x60(%ebp)
10d837: e8 e0 fe ff ff call 10d71c <IMFS_evaluate_permission>
10d83c: 83 c4 10 add $0x10,%esp
10d83f: 85 c0 test %eax,%eax
10d841: 8b 55 a0 mov -0x60(%ebp),%edx
10d844: 0f 84 3e 01 00 00 je 10d988 <IMFS_eval_path+0x1cf>
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
10d84a: 29 55 0c sub %edx,0xc(%ebp)
i += len;
10d84d: 01 55 a4 add %edx,-0x5c(%ebp)
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
10d850: 8b 3b mov (%ebx),%edi
switch( type ) {
10d852: 83 fe 03 cmp $0x3,%esi
10d855: 74 38 je 10d88f <IMFS_eval_path+0xd6>
10d857: 83 fe 04 cmp $0x4,%esi
10d85a: 0f 84 a7 00 00 00 je 10d907 <IMFS_eval_path+0x14e>
10d860: 83 fe 02 cmp $0x2,%esi
10d863: 0f 85 ae 00 00 00 jne 10d917 <IMFS_eval_path+0x15e>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
10d869: a1 80 30 12 00 mov 0x123080,%eax
10d86e: 3b 78 18 cmp 0x18(%eax),%edi
10d871: 0f 84 a0 00 00 00 je 10d917 <IMFS_eval_path+0x15e> <== NEVER TAKEN
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
pathloc->mt_entry->mt_fs_root.node_access) {
10d877: 8b 43 10 mov 0x10(%ebx),%eax
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
10d87a: 3b 78 1c cmp 0x1c(%eax),%edi
10d87d: 75 0b jne 10d88a <IMFS_eval_path+0xd1>
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
newloc = pathloc->mt_entry->mt_point_node;
10d87f: 8d 7d d0 lea -0x30(%ebp),%edi
10d882: 8d 70 08 lea 0x8(%eax),%esi
10d885: e9 ad 00 00 00 jmp 10d937 <IMFS_eval_path+0x17e>
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
10d88a: 8b 7f 08 mov 0x8(%edi),%edi
10d88d: eb 6c jmp 10d8fb <IMFS_eval_path+0x142>
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
10d88f: 8b 47 4c mov 0x4c(%edi),%eax
10d892: 83 f8 03 cmp $0x3,%eax
10d895: 75 11 jne 10d8a8 <IMFS_eval_path+0xef>
IMFS_evaluate_hard_link( pathloc, 0 );
10d897: 51 push %ecx
10d898: 51 push %ecx
10d899: 6a 00 push $0x0
10d89b: 53 push %ebx
10d89c: e8 d9 fe ff ff call 10d77a <IMFS_evaluate_hard_link>
node = pathloc->node_access;
10d8a1: 8b 3b mov (%ebx),%edi
10d8a3: 83 c4 10 add $0x10,%esp
10d8a6: eb 1d jmp 10d8c5 <IMFS_eval_path+0x10c>
* It would be a design error if we evaluated the link and
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
10d8a8: 83 f8 04 cmp $0x4,%eax
10d8ab: 75 18 jne 10d8c5 <IMFS_eval_path+0x10c>
result = IMFS_evaluate_sym_link( pathloc, 0 );
10d8ad: 52 push %edx
10d8ae: 52 push %edx
10d8af: 6a 00 push $0x0
10d8b1: 53 push %ebx
10d8b2: e8 ed 00 00 00 call 10d9a4 <IMFS_evaluate_sym_link>
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
10d8b7: 8b 3b mov (%ebx),%edi
if ( result == -1 )
10d8b9: 83 c4 10 add $0x10,%esp
10d8bc: 83 f8 ff cmp $0xffffffff,%eax
10d8bf: 0f 84 d3 00 00 00 je 10d998 <IMFS_eval_path+0x1df> <== NEVER TAKEN
}
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10d8c5: 83 7f 4c 01 cmpl $0x1,0x4c(%edi)
10d8c9: 74 10 je 10d8db <IMFS_eval_path+0x122>
rtems_set_errno_and_return_minus_one( ENOTDIR );
10d8cb: e8 fc 37 00 00 call 1110cc <__errno>
10d8d0: c7 00 14 00 00 00 movl $0x14,(%eax)
10d8d6: e9 42 ff ff ff jmp 10d81d <IMFS_eval_path+0x64>
/*
* 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 ) {
10d8db: 8b 47 5c mov 0x5c(%edi),%eax
10d8de: 85 c0 test %eax,%eax
10d8e0: 74 08 je 10d8ea <IMFS_eval_path+0x131>
newloc = node->info.directory.mt_fs->mt_fs_root;
10d8e2: 8d 7d d0 lea -0x30(%ebp),%edi
10d8e5: 8d 70 1c lea 0x1c(%eax),%esi
10d8e8: eb 4d jmp 10d937 <IMFS_eval_path+0x17e>
}
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10d8ea: 50 push %eax
10d8eb: 50 push %eax
10d8ec: 8d 45 af lea -0x51(%ebp),%eax
10d8ef: 50 push %eax
10d8f0: 57 push %edi
10d8f1: e8 56 04 00 00 call 10dd4c <IMFS_find_match_in_dir>
10d8f6: 89 c7 mov %eax,%edi
if ( !node )
10d8f8: 83 c4 10 add $0x10,%esp
10d8fb: 85 ff test %edi,%edi
10d8fd: 0f 84 0f ff ff ff je 10d812 <IMFS_eval_path+0x59>
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
10d903: 89 3b mov %edi,(%ebx)
10d905: eb 10 jmp 10d917 <IMFS_eval_path+0x15e>
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
10d907: e8 c0 37 00 00 call 1110cc <__errno>
10d90c: c7 00 5b 00 00 00 movl $0x5b,(%eax)
10d912: e9 06 ff ff ff jmp 10d81d <IMFS_eval_path+0x64>
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
10d917: 83 fe 04 cmp $0x4,%esi
10d91a: 74 08 je 10d924 <IMFS_eval_path+0x16b> <== NEVER TAKEN
10d91c: 85 f6 test %esi,%esi
10d91e: 0f 85 ca fe ff ff jne 10d7ee <IMFS_eval_path+0x35>
* 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 ) {
10d924: 83 7f 4c 01 cmpl $0x1,0x4c(%edi)
10d928: 75 41 jne 10d96b <IMFS_eval_path+0x1b2>
if ( node->info.directory.mt_fs != NULL ) {
10d92a: 8b 77 5c mov 0x5c(%edi),%esi
10d92d: 85 f6 test %esi,%esi
10d92f: 74 3a je 10d96b <IMFS_eval_path+0x1b2>
newloc = node->info.directory.mt_fs->mt_fs_root;
10d931: 8d 7d d0 lea -0x30(%ebp),%edi
10d934: 83 c6 1c add $0x1c,%esi
10d937: b9 05 00 00 00 mov $0x5,%ecx
10d93c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*pathloc = newloc;
10d93e: 8d 75 d0 lea -0x30(%ebp),%esi
10d941: b1 05 mov $0x5,%cl
10d943: 89 df mov %ebx,%edi
10d945: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
10d947: 8b 45 e4 mov -0x1c(%ebp),%eax
10d94a: 8b 53 0c mov 0xc(%ebx),%edx
10d94d: 53 push %ebx
10d94e: ff 75 10 pushl 0x10(%ebp)
10d951: 8b 4d 0c mov 0xc(%ebp),%ecx
10d954: 01 c1 add %eax,%ecx
10d956: 51 push %ecx
10d957: 8b 4d a4 mov -0x5c(%ebp),%ecx
10d95a: 29 c1 sub %eax,%ecx
10d95c: 8b 45 08 mov 0x8(%ebp),%eax
10d95f: 01 c8 add %ecx,%eax
10d961: 50 push %eax
10d962: ff 12 call *(%edx)
10d964: 89 c7 mov %eax,%edi
10d966: 83 c4 10 add $0x10,%esp
10d969: eb 2f jmp 10d99a <IMFS_eval_path+0x1e1>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
10d96b: 83 ec 0c sub $0xc,%esp
10d96e: 53 push %ebx
10d96f: e8 64 fd ff ff call 10d6d8 <IMFS_Set_handlers>
10d974: 89 c7 mov %eax,%edi
10d976: 5a pop %edx
10d977: 59 pop %ecx
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
10d978: ff 75 10 pushl 0x10(%ebp)
10d97b: 53 push %ebx
10d97c: e8 9b fd ff ff call 10d71c <IMFS_evaluate_permission>
10d981: 83 c4 10 add $0x10,%esp
10d984: 85 c0 test %eax,%eax
10d986: 75 12 jne 10d99a <IMFS_eval_path+0x1e1>
rtems_set_errno_and_return_minus_one( EACCES );
10d988: e8 3f 37 00 00 call 1110cc <__errno>
10d98d: c7 00 0d 00 00 00 movl $0xd,(%eax)
10d993: e9 85 fe ff ff jmp 10d81d <IMFS_eval_path+0x64>
10d998: 89 c7 mov %eax,%edi <== NOT EXECUTED
return result;
}
10d99a: 89 f8 mov %edi,%eax
10d99c: 8d 65 f4 lea -0xc(%ebp),%esp
10d99f: 5b pop %ebx
10d9a0: 5e pop %esi
10d9a1: 5f pop %edi
10d9a2: c9 leave
10d9a3: c3 ret
0010da98 <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 */
)
{
10da98: 55 push %ebp
10da99: 89 e5 mov %esp,%ebp
10da9b: 57 push %edi
10da9c: 56 push %esi
10da9d: 53 push %ebx
10da9e: 83 ec 5c sub $0x5c,%esp
10daa1: 8b 55 0c mov 0xc(%ebp),%edx
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
10daa4: 8b 1a mov (%edx),%ebx
/*
* Get the path length.
*/
pathlen = strlen( path );
10daa6: 31 c0 xor %eax,%eax
10daa8: 83 c9 ff or $0xffffffff,%ecx
10daab: 8b 7d 08 mov 0x8(%ebp),%edi
10daae: f2 ae repnz scas %es:(%edi),%al
10dab0: f7 d1 not %ecx
10dab2: 49 dec %ecx
10dab3: 89 4d a0 mov %ecx,-0x60(%ebp)
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
int i = 0;
10dab6: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp)
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
10dabd: 8d 7d af lea -0x51(%ebp),%edi
10dac0: 89 d6 mov %edx,%esi
10dac2: 8d 45 e4 lea -0x1c(%ebp),%eax
10dac5: 50 push %eax
10dac6: 57 push %edi
10dac7: ff 75 a0 pushl -0x60(%ebp)
10daca: 8b 45 08 mov 0x8(%ebp),%eax
10dacd: 03 45 a4 add -0x5c(%ebp),%eax
10dad0: 50 push %eax
10dad1: e8 e2 02 00 00 call 10ddb8 <IMFS_get_token>
10dad6: 89 c2 mov %eax,%edx
pathlen -= len;
10dad8: 8b 4d e4 mov -0x1c(%ebp),%ecx
10dadb: 29 4d a0 sub %ecx,-0x60(%ebp)
i += len;
if ( !pathloc->node_access )
10dade: 83 c4 10 add $0x10,%esp
10dae1: 83 3e 00 cmpl $0x0,(%esi)
10dae4: 0f 84 79 01 00 00 je 10dc63 <IMFS_evaluate_for_make+0x1cb><== NEVER TAKEN
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
10daea: 85 c0 test %eax,%eax
10daec: 74 36 je 10db24 <IMFS_evaluate_for_make+0x8c>
if ( node->type == IMFS_DIRECTORY )
10daee: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10daf2: 75 30 jne 10db24 <IMFS_evaluate_for_make+0x8c>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
10daf4: 53 push %ebx
10daf5: 53 push %ebx
10daf6: 6a 01 push $0x1
10daf8: 56 push %esi
10daf9: 89 45 9c mov %eax,-0x64(%ebp)
10dafc: 89 4d 98 mov %ecx,-0x68(%ebp)
10daff: e8 18 fc ff ff call 10d71c <IMFS_evaluate_permission>
10db04: 83 c4 10 add $0x10,%esp
10db07: 85 c0 test %eax,%eax
10db09: 8b 55 9c mov -0x64(%ebp),%edx
10db0c: 8b 4d 98 mov -0x68(%ebp),%ecx
10db0f: 75 13 jne 10db24 <IMFS_evaluate_for_make+0x8c>
rtems_set_errno_and_return_minus_one( EACCES );
10db11: e8 b6 35 00 00 call 1110cc <__errno>
10db16: c7 00 0d 00 00 00 movl $0xd,(%eax)
10db1c: 83 cb ff or $0xffffffff,%ebx
10db1f: e9 99 01 00 00 jmp 10dcbd <IMFS_evaluate_for_make+0x225>
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
i += len;
10db24: 01 4d a4 add %ecx,-0x5c(%ebp)
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
10db27: 8b 1e mov (%esi),%ebx
switch( type ) {
10db29: 83 fa 02 cmp $0x2,%edx
10db2c: 74 1f je 10db4d <IMFS_evaluate_for_make+0xb5>
10db2e: 77 0a ja 10db3a <IMFS_evaluate_for_make+0xa2>
10db30: 85 d2 test %edx,%edx
10db32: 0f 84 d9 00 00 00 je 10dc11 <IMFS_evaluate_for_make+0x179>
10db38: eb 88 jmp 10dac2 <IMFS_evaluate_for_make+0x2a>
10db3a: 83 fa 03 cmp $0x3,%edx
10db3d: 74 40 je 10db7f <IMFS_evaluate_for_make+0xe7>
10db3f: 83 fa 04 cmp $0x4,%edx
10db42: 0f 85 7a ff ff ff jne 10dac2 <IMFS_evaluate_for_make+0x2a><== NEVER TAKEN
10db48: e9 d4 00 00 00 jmp 10dc21 <IMFS_evaluate_for_make+0x189>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
10db4d: a1 80 30 12 00 mov 0x123080,%eax
10db52: 3b 58 18 cmp 0x18(%eax),%ebx
10db55: 0f 84 67 ff ff ff je 10dac2 <IMFS_evaluate_for_make+0x2a>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){
10db5b: 8b 46 10 mov 0x10(%esi),%eax
10db5e: 3b 58 1c cmp 0x1c(%eax),%ebx
10db61: 75 0c jne 10db6f <IMFS_evaluate_for_make+0xd7>
10db63: 89 f2 mov %esi,%edx
10db65: 89 c6 mov %eax,%esi
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
10db67: 8d 7d d0 lea -0x30(%ebp),%edi
10db6a: 83 c6 08 add $0x8,%esi
10db6d: eb 5a jmp 10dbc9 <IMFS_evaluate_for_make+0x131>
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
10db6f: 8b 5b 08 mov 0x8(%ebx),%ebx
10db72: 85 db test %ebx,%ebx
10db74: 0f 85 90 00 00 00 jne 10dc0a <IMFS_evaluate_for_make+0x172>
10db7a: e9 e4 00 00 00 jmp 10dc63 <IMFS_evaluate_for_make+0x1cb>
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
10db7f: 8b 43 4c mov 0x4c(%ebx),%eax
10db82: 83 f8 03 cmp $0x3,%eax
10db85: 74 05 je 10db8c <IMFS_evaluate_for_make+0xf4>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
10db87: 83 f8 04 cmp $0x4,%eax
10db8a: 75 16 jne 10dba2 <IMFS_evaluate_for_make+0x10a>
result = IMFS_evaluate_link( pathloc, 0 );
10db8c: 50 push %eax
10db8d: 50 push %eax
10db8e: 6a 00 push $0x0
10db90: 56 push %esi
10db91: e8 7f fe ff ff call 10da15 <IMFS_evaluate_link>
if ( result == -1 )
10db96: 83 c4 10 add $0x10,%esp
10db99: 83 f8 ff cmp $0xffffffff,%eax
10db9c: 0f 84 19 01 00 00 je 10dcbb <IMFS_evaluate_for_make+0x223><== NEVER TAKEN
return -1;
}
node = pathloc->node_access;
10dba2: 8b 06 mov (%esi),%eax
if ( !node )
10dba4: 85 c0 test %eax,%eax
10dba6: 0f 84 e9 00 00 00 je 10dc95 <IMFS_evaluate_for_make+0x1fd><== NEVER TAKEN
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
10dbac: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
10dbb0: 0f 85 df 00 00 00 jne 10dc95 <IMFS_evaluate_for_make+0x1fd>
/*
* 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 ) {
10dbb6: 8b 50 5c mov 0x5c(%eax),%edx
10dbb9: 85 d2 test %edx,%edx
10dbbb: 74 3b je 10dbf8 <IMFS_evaluate_for_make+0x160>
10dbbd: 89 f0 mov %esi,%eax
10dbbf: 89 d6 mov %edx,%esi
10dbc1: 89 c2 mov %eax,%edx
newloc = node->info.directory.mt_fs->mt_fs_root;
10dbc3: 8d 7d d0 lea -0x30(%ebp),%edi
10dbc6: 83 c6 1c add $0x1c,%esi
10dbc9: b9 05 00 00 00 mov $0x5,%ecx
10dbce: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
*pathloc = newloc;
10dbd0: 8d 75 d0 lea -0x30(%ebp),%esi
10dbd3: b1 05 mov $0x5,%cl
10dbd5: 89 d7 mov %edx,%edi
10dbd7: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
10dbd9: 56 push %esi
10dbda: 8b 42 0c mov 0xc(%edx),%eax
10dbdd: ff 75 10 pushl 0x10(%ebp)
10dbe0: 52 push %edx
10dbe1: 8b 55 a4 mov -0x5c(%ebp),%edx
10dbe4: 2b 55 e4 sub -0x1c(%ebp),%edx
10dbe7: 03 55 08 add 0x8(%ebp),%edx
10dbea: 52 push %edx
10dbeb: ff 50 04 call *0x4(%eax)
10dbee: 89 c3 mov %eax,%ebx
10dbf0: 83 c4 10 add $0x10,%esp
10dbf3: e9 c5 00 00 00 jmp 10dcbd <IMFS_evaluate_for_make+0x225>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
10dbf8: 53 push %ebx
10dbf9: 53 push %ebx
10dbfa: 57 push %edi
10dbfb: 50 push %eax
10dbfc: e8 4b 01 00 00 call 10dd4c <IMFS_find_match_in_dir>
10dc01: 89 c3 mov %eax,%ebx
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
10dc03: 83 c4 10 add $0x10,%esp
10dc06: 85 c0 test %eax,%eax
10dc08: 74 27 je 10dc31 <IMFS_evaluate_for_make+0x199>
done = true;
else
pathloc->node_access = node;
10dc0a: 89 1e mov %ebx,(%esi)
10dc0c: e9 b1 fe ff ff jmp 10dac2 <IMFS_evaluate_for_make+0x2a>
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
10dc11: e8 b6 34 00 00 call 1110cc <__errno>
10dc16: c7 00 11 00 00 00 movl $0x11,(%eax)
10dc1c: e9 fb fe ff ff jmp 10db1c <IMFS_evaluate_for_make+0x84>
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
10dc21: e8 a6 34 00 00 call 1110cc <__errno>
10dc26: c7 00 5b 00 00 00 movl $0x5b,(%eax)
10dc2c: e9 eb fe ff ff jmp 10db1c <IMFS_evaluate_for_make+0x84>
10dc31: 89 f2 mov %esi,%edx
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
10dc33: 8b 45 a4 mov -0x5c(%ebp),%eax
10dc36: 2b 45 e4 sub -0x1c(%ebp),%eax
10dc39: 03 45 08 add 0x8(%ebp),%eax
10dc3c: 8b 4d 10 mov 0x10(%ebp),%ecx
10dc3f: 89 01 mov %eax,(%ecx)
* pathloc is returned with a pointer to the parent of the new node.
* name is returned with a pointer to the first character in the
* new node name. The parent node is verified to be a directory.
*/
int IMFS_evaluate_for_make(
10dc41: 8b 5d 08 mov 0x8(%ebp),%ebx
10dc44: 03 5d a4 add -0x5c(%ebp),%ebx
/*
* 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++) {
10dc47: eb 2a jmp 10dc73 <IMFS_evaluate_for_make+0x1db>
if ( !IMFS_is_separator( path[ i ] ) )
10dc49: 83 ec 0c sub $0xc,%esp
10dc4c: 0f be c0 movsbl %al,%eax
10dc4f: 50 push %eax
10dc50: 89 55 9c mov %edx,-0x64(%ebp)
10dc53: e8 a8 a3 ff ff call 108000 <rtems_filesystem_is_separator>
10dc58: 43 inc %ebx
10dc59: 83 c4 10 add $0x10,%esp
10dc5c: 85 c0 test %eax,%eax
10dc5e: 8b 55 9c mov -0x64(%ebp),%edx
10dc61: 75 10 jne 10dc73 <IMFS_evaluate_for_make+0x1db>
rtems_set_errno_and_return_minus_one( ENOENT );
10dc63: e8 64 34 00 00 call 1110cc <__errno>
10dc68: c7 00 02 00 00 00 movl $0x2,(%eax)
10dc6e: e9 a9 fe ff ff jmp 10db1c <IMFS_evaluate_for_make+0x84>
/*
* 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++) {
10dc73: 8a 03 mov (%ebx),%al
10dc75: 84 c0 test %al,%al
10dc77: 75 d0 jne 10dc49 <IMFS_evaluate_for_make+0x1b1>
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
10dc79: 83 ec 0c sub $0xc,%esp
10dc7c: 52 push %edx
10dc7d: 89 55 9c mov %edx,-0x64(%ebp)
10dc80: e8 53 fa ff ff call 10d6d8 <IMFS_Set_handlers>
10dc85: 89 c3 mov %eax,%ebx
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
10dc87: 8b 55 9c mov -0x64(%ebp),%edx
10dc8a: 8b 02 mov (%edx),%eax
10dc8c: 83 c4 10 add $0x10,%esp
10dc8f: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
10dc93: 74 10 je 10dca5 <IMFS_evaluate_for_make+0x20d><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
10dc95: e8 32 34 00 00 call 1110cc <__errno>
10dc9a: c7 00 14 00 00 00 movl $0x14,(%eax)
10dca0: e9 77 fe ff ff jmp 10db1c <IMFS_evaluate_for_make+0x84>
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
10dca5: 51 push %ecx
10dca6: 51 push %ecx
10dca7: 6a 03 push $0x3
10dca9: 52 push %edx
10dcaa: e8 6d fa ff ff call 10d71c <IMFS_evaluate_permission>
10dcaf: 83 c4 10 add $0x10,%esp
10dcb2: 85 c0 test %eax,%eax
10dcb4: 75 07 jne 10dcbd <IMFS_evaluate_for_make+0x225>
10dcb6: e9 56 fe ff ff jmp 10db11 <IMFS_evaluate_for_make+0x79>
10dcbb: 89 c3 mov %eax,%ebx <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
10dcbd: 89 d8 mov %ebx,%eax
10dcbf: 8d 65 f4 lea -0xc(%ebp),%esp
10dcc2: 5b pop %ebx
10dcc3: 5e pop %esi
10dcc4: 5f pop %edi
10dcc5: c9 leave
10dcc6: c3 ret
0010d71c <IMFS_evaluate_permission>:
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
10d71c: 55 push %ebp
10d71d: 89 e5 mov %esp,%ebp
10d71f: 57 push %edi
10d720: 56 push %esi
10d721: 53 push %ebx
10d722: 83 ec 0c sub $0xc,%esp
10d725: 8b 75 0c mov 0xc(%ebp),%esi
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
10d728: f7 c6 f8 ff ff ff test $0xfffffff8,%esi
10d72e: 74 10 je 10d740 <IMFS_evaluate_permission+0x24><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
10d730: e8 97 39 00 00 call 1110cc <__errno> <== NOT EXECUTED
10d735: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
10d73b: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10d73e: eb 32 jmp 10d772 <IMFS_evaluate_permission+0x56><== NOT EXECUTED
jnode = node->node_access;
10d740: 8b 45 08 mov 0x8(%ebp),%eax
10d743: 8b 18 mov (%eax),%ebx
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
10d745: e8 2e 0a 00 00 call 10e178 <geteuid>
10d74a: 89 c7 mov %eax,%edi
st_gid = getegid();
10d74c: e8 17 0a 00 00 call 10e168 <getegid>
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
10d751: 66 3b 7b 3c cmp 0x3c(%ebx),%di
10d755: 75 05 jne 10d75c <IMFS_evaluate_permission+0x40>
flags_to_test <<= 6;
10d757: c1 e6 06 shl $0x6,%esi
10d75a: eb 09 jmp 10d765 <IMFS_evaluate_permission+0x49>
else if ( st_gid == jnode->st_gid )
10d75c: 66 3b 43 3e cmp 0x3e(%ebx),%ax
10d760: 75 03 jne 10d765 <IMFS_evaluate_permission+0x49><== NEVER TAKEN
flags_to_test <<= 3;
10d762: c1 e6 03 shl $0x3,%esi
/*
* If all of the flags are set we have permission
* to do this.
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
10d765: 8b 43 30 mov 0x30(%ebx),%eax
10d768: 21 f0 and %esi,%eax
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
10d76a: 39 f0 cmp %esi,%eax
10d76c: 0f 94 c0 sete %al
10d76f: 0f b6 c0 movzbl %al,%eax
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
return 1;
return 0;
}
10d772: 83 c4 0c add $0xc,%esp
10d775: 5b pop %ebx
10d776: 5e pop %esi
10d777: 5f pop %edi
10d778: c9 leave
10d779: c3 ret
00107b68 <IMFS_fifo_lseek>:
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
107b68: 55 push %ebp
107b69: 89 e5 mov %esp,%ebp
107b6b: 53 push %ebx
107b6c: 83 ec 10 sub $0x10,%esp
107b6f: 8b 45 08 mov 0x8(%ebp),%eax
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
107b72: 50 push %eax
107b73: ff 75 14 pushl 0x14(%ebp)
107b76: ff 75 10 pushl 0x10(%ebp)
107b79: ff 75 0c pushl 0xc(%ebp)
107b7c: 8b 40 18 mov 0x18(%eax),%eax
107b7f: ff 70 50 pushl 0x50(%eax)
107b82: e8 ca 86 00 00 call 110251 <pipe_lseek>
107b87: 89 c3 mov %eax,%ebx
IMFS_FIFO_RETURN(err);
107b89: 83 c4 20 add $0x20,%esp
107b8c: 99 cltd
107b8d: 85 d2 test %edx,%edx
107b8f: 79 0e jns 107b9f <IMFS_fifo_lseek+0x37> <== NEVER TAKEN
107b91: e8 56 b3 00 00 call 112eec <__errno>
107b96: f7 db neg %ebx
107b98: 89 18 mov %ebx,(%eax)
107b9a: 83 c8 ff or $0xffffffff,%eax
107b9d: 89 c2 mov %eax,%edx
}
107b9f: 8b 5d fc mov -0x4(%ebp),%ebx
107ba2: c9 leave
107ba3: c3 ret
00107c04 <IMFS_fifo_write>:
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
107c04: 55 push %ebp
107c05: 89 e5 mov %esp,%ebp
107c07: 56 push %esi
107c08: 53 push %ebx
107c09: 83 ec 10 sub $0x10,%esp
107c0c: 8b 45 08 mov 0x8(%ebp),%eax
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
107c0f: 8b 70 18 mov 0x18(%eax),%esi
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
107c12: 50 push %eax
107c13: ff 75 10 pushl 0x10(%ebp)
107c16: ff 75 0c pushl 0xc(%ebp)
107c19: ff 76 50 pushl 0x50(%esi)
107c1c: e8 2c 84 00 00 call 11004d <pipe_write>
107c21: 89 c3 mov %eax,%ebx
if (err > 0) {
107c23: 83 c4 10 add $0x10,%esp
107c26: 83 f8 00 cmp $0x0,%eax
107c29: 7e 1d jle 107c48 <IMFS_fifo_write+0x44>
IMFS_mtime_ctime_update(jnode);
107c2b: 50 push %eax
107c2c: 50 push %eax
107c2d: 6a 00 push $0x0
107c2f: 8d 45 f0 lea -0x10(%ebp),%eax
107c32: 50 push %eax
107c33: e8 ec 0d 00 00 call 108a24 <gettimeofday>
107c38: 8b 45 f0 mov -0x10(%ebp),%eax
107c3b: 89 46 44 mov %eax,0x44(%esi)
107c3e: 89 46 48 mov %eax,0x48(%esi)
107c41: 83 c4 10 add $0x10,%esp
107c44: 89 d8 mov %ebx,%eax
107c46: eb 13 jmp 107c5b <IMFS_fifo_write+0x57>
}
IMFS_FIFO_RETURN(err);
107c48: b8 00 00 00 00 mov $0x0,%eax
107c4d: 74 0c je 107c5b <IMFS_fifo_write+0x57> <== NEVER TAKEN
107c4f: e8 98 b2 00 00 call 112eec <__errno>
107c54: f7 db neg %ebx
107c56: 89 18 mov %ebx,(%eax)
107c58: 83 c8 ff or $0xffffffff,%eax
}
107c5b: 8d 65 f8 lea -0x8(%ebp),%esp
107c5e: 5b pop %ebx
107c5f: 5e pop %esi
107c60: c9 leave
107c61: c3 ret
0010dd4c <IMFS_find_match_in_dir>:
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
10dd4c: 55 push %ebp
10dd4d: 89 e5 mov %esp,%ebp
10dd4f: 57 push %edi
10dd50: 56 push %esi
10dd51: 53 push %ebx
10dd52: 83 ec 14 sub $0x14,%esp
10dd55: 8b 5d 08 mov 0x8(%ebp),%ebx
10dd58: 8b 7d 0c mov 0xc(%ebp),%edi
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
10dd5b: 68 48 f3 11 00 push $0x11f348
10dd60: 57 push %edi
10dd61: e8 26 40 00 00 call 111d8c <strcmp>
10dd66: 83 c4 10 add $0x10,%esp
10dd69: 85 c0 test %eax,%eax
10dd6b: 74 40 je 10ddad <IMFS_find_match_in_dir+0x61><== NEVER TAKEN
return directory;
if ( !strcmp( name, dotdotname ) )
10dd6d: 51 push %ecx
10dd6e: 51 push %ecx
10dd6f: 68 4a f3 11 00 push $0x11f34a
10dd74: 57 push %edi
10dd75: e8 12 40 00 00 call 111d8c <strcmp>
10dd7a: 83 c4 10 add $0x10,%esp
10dd7d: 85 c0 test %eax,%eax
10dd7f: 75 05 jne 10dd86 <IMFS_find_match_in_dir+0x3a><== ALWAYS TAKEN
return directory->Parent;
10dd81: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED
10dd84: eb 27 jmp 10ddad <IMFS_find_match_in_dir+0x61><== NOT EXECUTED
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
10dd86: 8b 73 50 mov 0x50(%ebx),%esi
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
10dd89: 83 c3 54 add $0x54,%ebx
if ( !strcmp( name, dotdotname ) )
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
10dd8c: eb 15 jmp 10dda3 <IMFS_find_match_in_dir+0x57>
!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 ) )
10dd8e: 8d 46 0c lea 0xc(%esi),%eax
10dd91: 52 push %edx
10dd92: 52 push %edx
10dd93: 50 push %eax
10dd94: 57 push %edi
10dd95: e8 f2 3f 00 00 call 111d8c <strcmp>
10dd9a: 83 c4 10 add $0x10,%esp
10dd9d: 85 c0 test %eax,%eax
10dd9f: 74 0a je 10ddab <IMFS_find_match_in_dir+0x5f>
the_chain = &directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
10dda1: 8b 36 mov (%esi),%esi
if ( !strcmp( name, dotdotname ) )
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
10dda3: 39 de cmp %ebx,%esi
10dda5: 75 e7 jne 10dd8e <IMFS_find_match_in_dir+0x42>
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
10dda7: 31 db xor %ebx,%ebx
10dda9: eb 02 jmp 10ddad <IMFS_find_match_in_dir+0x61>
for ( the_node = rtems_chain_first( the_chain );
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
10ddab: 89 f3 mov %esi,%ebx
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
10ddad: 89 d8 mov %ebx,%eax
10ddaf: 8d 65 f4 lea -0xc(%ebp),%esp
10ddb2: 5b pop %ebx
10ddb3: 5e pop %esi
10ddb4: 5f pop %edi
10ddb5: c9 leave
10ddb6: c3 ret
0010dcc8 <IMFS_fsunmount>:
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
int IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
10dcc8: 55 push %ebp
10dcc9: 89 e5 mov %esp,%ebp
10dccb: 57 push %edi
10dccc: 56 push %esi
10dccd: 53 push %ebx
10dcce: 83 ec 2c sub $0x2c,%esp
10dcd1: 8b 45 08 mov 0x8(%ebp),%eax
/*
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;
10dcd4: 8b 58 1c mov 0x1c(%eax),%ebx
loc = temp_mt_entry->mt_fs_root;
10dcd7: 8d 7d d4 lea -0x2c(%ebp),%edi
10dcda: 8d 70 1c lea 0x1c(%eax),%esi
10dcdd: b9 05 00 00 00 mov $0x5,%ecx
10dce2: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
10dce4: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
10dceb: 8d 75 d4 lea -0x2c(%ebp),%esi
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
10dcee: 8b 7b 08 mov 0x8(%ebx),%edi
loc.node_access = (void *)jnode;
10dcf1: 89 5d d4 mov %ebx,-0x2c(%ebp)
IMFS_Set_handlers( &loc );
10dcf4: 83 ec 0c sub $0xc,%esp
10dcf7: 56 push %esi
10dcf8: e8 db f9 ff ff call 10d6d8 <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
10dcfd: 83 c4 10 add $0x10,%esp
10dd00: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10dd04: 75 08 jne 10dd0e <IMFS_fsunmount+0x46>
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10dd06: 8d 43 54 lea 0x54(%ebx),%eax
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
10dd09: 39 43 50 cmp %eax,0x50(%ebx)
10dd0c: 75 13 jne 10dd21 <IMFS_fsunmount+0x59>
result = IMFS_unlink( NULL, &loc );
10dd0e: 50 push %eax
10dd0f: 50 push %eax
10dd10: 56 push %esi
10dd11: 6a 00 push $0x0
10dd13: e8 cc 91 ff ff call 106ee4 <IMFS_unlink>
if (result != 0)
10dd18: 83 c4 10 add $0x10,%esp
10dd1b: 85 c0 test %eax,%eax
10dd1d: 75 1e jne 10dd3d <IMFS_fsunmount+0x75> <== NEVER TAKEN
return -1;
jnode = next;
10dd1f: 89 fb mov %edi,%ebx
}
if ( jnode != NULL ) {
10dd21: 85 db test %ebx,%ebx
10dd23: 74 1d je 10dd42 <IMFS_fsunmount+0x7a>
if ( jnode->type == IMFS_DIRECTORY ) {
10dd25: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx)
10dd29: 75 c3 jne 10dcee <IMFS_fsunmount+0x26> <== NEVER TAKEN
}
}
} while (jnode != NULL);
return 0;
}
10dd2b: 8b 43 50 mov 0x50(%ebx),%eax
10dd2e: 8d 53 54 lea 0x54(%ebx),%edx
return -1;
jnode = next;
}
if ( jnode != NULL ) {
if ( jnode->type == IMFS_DIRECTORY ) {
if ( jnode_has_children( jnode ) )
10dd31: 39 d0 cmp %edx,%eax
10dd33: 74 b9 je 10dcee <IMFS_fsunmount+0x26>
jnode = jnode_get_first_child( jnode );
10dd35: 89 c3 mov %eax,%ebx
}
}
} while (jnode != NULL);
10dd37: 85 c0 test %eax,%eax
10dd39: 75 b3 jne 10dcee <IMFS_fsunmount+0x26> <== ALWAYS TAKEN
10dd3b: eb 05 jmp 10dd42 <IMFS_fsunmount+0x7a>
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
10dd3d: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
10dd40: eb 02 jmp 10dd44 <IMFS_fsunmount+0x7c> <== NOT EXECUTED
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
return 0;
10dd42: 31 c0 xor %eax,%eax
}
10dd44: 8d 65 f4 lea -0xc(%ebp),%esp
10dd47: 5b pop %ebx
10dd48: 5e pop %esi
10dd49: 5f pop %edi
10dd4a: c9 leave
10dd4b: c3 ret
0010ddb8 <IMFS_get_token>:
const char *path,
int pathlen,
char *token,
int *token_len
)
{
10ddb8: 55 push %ebp
10ddb9: 89 e5 mov %esp,%ebp
10ddbb: 57 push %edi
10ddbc: 56 push %esi
10ddbd: 53 push %ebx
10ddbe: 83 ec 1c sub $0x1c,%esp
10ddc1: 8b 7d 08 mov 0x8(%ebp),%edi
10ddc4: 8b 75 10 mov 0x10(%ebp),%esi
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
10ddc7: 8a 17 mov (%edi),%dl
int pathlen,
char *token,
int *token_len
)
{
register int i = 0;
10ddc9: 31 db xor %ebx,%ebx
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
10ddcb: eb 10 jmp 10dddd <IMFS_get_token+0x25>
token[i] = c;
10ddcd: 88 14 1e mov %dl,(%esi,%ebx,1)
if ( i == IMFS_NAME_MAX )
10ddd0: 83 fb 20 cmp $0x20,%ebx
10ddd3: 0f 84 86 00 00 00 je 10de5f <IMFS_get_token+0xa7>
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
10ddd9: 43 inc %ebx
10ddda: 8a 14 1f mov (%edi,%ebx,1),%dl
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
10dddd: 83 ec 0c sub $0xc,%esp
10dde0: 0f be c2 movsbl %dl,%eax
10dde3: 50 push %eax
10dde4: 88 55 e4 mov %dl,-0x1c(%ebp)
10dde7: e8 14 a2 ff ff call 108000 <rtems_filesystem_is_separator>
10ddec: 83 c4 10 add $0x10,%esp
10ddef: 85 c0 test %eax,%eax
10ddf1: 8a 55 e4 mov -0x1c(%ebp),%dl
10ddf4: 75 05 jne 10ddfb <IMFS_get_token+0x43>
10ddf6: 3b 5d 0c cmp 0xc(%ebp),%ebx
10ddf9: 7c d2 jl 10ddcd <IMFS_get_token+0x15>
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
10ddfb: 85 db test %ebx,%ebx
10ddfd: 75 10 jne 10de0f <IMFS_get_token+0x57>
token[i] = c;
10ddff: 88 16 mov %dl,(%esi)
if ( (token[i] != '\0') && pathlen ) {
10de01: 84 d2 test %dl,%dl
10de03: 74 06 je 10de0b <IMFS_get_token+0x53>
10de05: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10de09: 75 16 jne 10de21 <IMFS_get_token+0x69>
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
10de0b: 31 ff xor %edi,%edi
10de0d: eb 1c jmp 10de2b <IMFS_get_token+0x73>
char *token,
int *token_len
)
{
register int i = 0;
IMFS_token_types type = IMFS_NAME;
10de0f: bf 03 00 00 00 mov $0x3,%edi
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
10de14: 80 7c 1e ff 00 cmpb $0x0,-0x1(%esi,%ebx,1)
10de19: 74 10 je 10de2b <IMFS_get_token+0x73> <== NEVER TAKEN
token[i] = '\0';
10de1b: c6 04 1e 00 movb $0x0,(%esi,%ebx,1)
10de1f: eb 0a jmp 10de2b <IMFS_get_token+0x73>
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
type = IMFS_CURRENT_DIR;
10de21: bf 01 00 00 00 mov $0x1,%edi
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
10de26: bb 01 00 00 00 mov $0x1,%ebx
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
10de2b: 8b 45 14 mov 0x14(%ebp),%eax
10de2e: 89 18 mov %ebx,(%eax)
/*
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
10de30: 83 ff 03 cmp $0x3,%edi
10de33: 75 3d jne 10de72 <IMFS_get_token+0xba>
if ( strcmp( token, "..") == 0 )
10de35: 52 push %edx
10de36: 52 push %edx
10de37: 68 4d f3 11 00 push $0x11f34d
10de3c: 56 push %esi
10de3d: e8 4a 3f 00 00 call 111d8c <strcmp>
10de42: 83 c4 10 add $0x10,%esp
10de45: 85 c0 test %eax,%eax
10de47: 74 1d je 10de66 <IMFS_get_token+0xae>
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
10de49: 50 push %eax
10de4a: 50 push %eax
10de4b: 68 4e f3 11 00 push $0x11f34e
10de50: 56 push %esi
10de51: e8 36 3f 00 00 call 111d8c <strcmp>
10de56: 83 c4 10 add $0x10,%esp
10de59: 85 c0 test %eax,%eax
10de5b: 74 10 je 10de6d <IMFS_get_token+0xb5>
10de5d: eb 13 jmp 10de72 <IMFS_get_token+0xba>
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
token[i] = c;
if ( i == IMFS_NAME_MAX )
return IMFS_INVALID_TOKEN;
10de5f: bf 04 00 00 00 mov $0x4,%edi
10de64: eb 0c jmp 10de72 <IMFS_get_token+0xba>
* it was a special name.
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
10de66: bf 02 00 00 00 mov $0x2,%edi
10de6b: eb 05 jmp 10de72 <IMFS_get_token+0xba>
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
10de6d: bf 01 00 00 00 mov $0x1,%edi
}
return type;
}
10de72: 89 f8 mov %edi,%eax
10de74: 8d 65 f4 lea -0xc(%ebp),%esp
10de77: 5b pop %ebx
10de78: 5e pop %esi
10de79: 5f pop %edi
10de7a: c9 leave
10de7b: c3 ret
00106b7c <IMFS_initialize_support>:
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *memfile_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers,
const rtems_filesystem_file_handlers_r *fifo_handlers
)
{
106b7c: 55 push %ebp
106b7d: 89 e5 mov %esp,%ebp
106b7f: 57 push %edi
106b80: 56 push %esi
106b81: 53 push %ebx
106b82: 83 ec 1c sub $0x1c,%esp
106b85: 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,
106b88: a1 48 11 12 00 mov 0x121148,%eax
106b8d: b9 06 00 00 00 mov $0x6,%ecx
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
106b92: ba 10 00 00 00 mov $0x10,%edx
if (bit_mask == requested_bytes_per_block) {
106b97: 39 c2 cmp %eax,%edx
106b99: 74 0c je 106ba7 <IMFS_initialize_support+0x2b>
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
106b9b: 7f 05 jg 106ba2 <IMFS_initialize_support+0x26>
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
106b9d: d1 e2 shl %edx
106b9f: 49 dec %ecx
106ba0: 75 f5 jne 106b97 <IMFS_initialize_support+0x1b><== ALWAYS TAKEN
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
? requested_bytes_per_block
: default_bytes_per_block);
106ba2: b8 80 00 00 00 mov $0x80,%eax
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
106ba7: a3 ec 4e 12 00 mov %eax,0x124eec
/*
* Create the root node
*
* NOTE: UNIX root is 755 and owned by root/root (0/0).
*/
temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node();
106bac: e8 f2 6a 00 00 call 10d6a3 <IMFS_create_root_node>
106bb1: 89 c2 mov %eax,%edx
106bb3: 89 43 1c mov %eax,0x1c(%ebx)
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
106bb6: 8b 45 14 mov 0x14(%ebp),%eax
106bb9: 89 43 24 mov %eax,0x24(%ebx)
temp_mt_entry->mt_fs_root.ops = op_table;
106bbc: 8b 45 0c mov 0xc(%ebp),%eax
106bbf: 89 43 28 mov %eax,0x28(%ebx)
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
106bc2: 8d 7b 38 lea 0x38(%ebx),%edi
106bc5: be fc f2 11 00 mov $0x11f2fc,%esi
106bca: b9 0c 00 00 00 mov $0xc,%ecx
106bcf: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
106bd1: 50 push %eax
106bd2: 50 push %eax
106bd3: 6a 14 push $0x14
106bd5: 6a 01 push $0x1
106bd7: 89 55 e4 mov %edx,-0x1c(%ebp)
106bda: e8 fd 05 00 00 call 1071dc <calloc>
if ( !fs_info ) {
106bdf: 83 c4 10 add $0x10,%esp
106be2: 85 c0 test %eax,%eax
106be4: 8b 55 e4 mov -0x1c(%ebp),%edx
106be7: 75 1c jne 106c05 <IMFS_initialize_support+0x89>
free(temp_mt_entry->mt_fs_root.node_access);
106be9: 83 ec 0c sub $0xc,%esp
106bec: 52 push %edx
106bed: e8 56 07 00 00 call 107348 <free>
rtems_set_errno_and_return_minus_one(ENOMEM);
106bf2: e8 d5 a4 00 00 call 1110cc <__errno>
106bf7: c7 00 0c 00 00 00 movl $0xc,(%eax)
106bfd: 83 c4 10 add $0x10,%esp
106c00: 83 c8 ff or $0xffffffff,%eax
106c03: eb 34 jmp 106c39 <IMFS_initialize_support+0xbd>
}
temp_mt_entry->fs_info = fs_info;
106c05: 89 43 34 mov %eax,0x34(%ebx)
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
106c08: 8b 0d f0 4e 12 00 mov 0x124ef0,%ecx
106c0e: 89 08 mov %ecx,(%eax)
106c10: 41 inc %ecx
106c11: 89 0d f0 4e 12 00 mov %ecx,0x124ef0
fs_info->ino_count = 1;
106c17: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
fs_info->memfile_handlers = memfile_handlers;
106c1e: 8b 4d 10 mov 0x10(%ebp),%ecx
106c21: 89 48 08 mov %ecx,0x8(%eax)
fs_info->directory_handlers = directory_handlers;
106c24: 8b 4d 14 mov 0x14(%ebp),%ecx
106c27: 89 48 0c mov %ecx,0xc(%eax)
fs_info->fifo_handlers = fifo_handlers;
106c2a: 8b 4d 18 mov 0x18(%ebp),%ecx
106c2d: 89 48 10 mov %ecx,0x10(%eax)
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
106c30: c7 42 38 01 00 00 00 movl $0x1,0x38(%edx)
return 0;
106c37: 31 c0 xor %eax,%eax
}
106c39: 8d 65 f4 lea -0xc(%ebp),%esp
106c3c: 5b pop %ebx
106c3d: 5e pop %esi
106c3e: 5f pop %edi
106c3f: c9 leave
106c40: c3 ret
00110096 <IMFS_memfile_extend>:
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
110096: 55 push %ebp
110097: 89 e5 mov %esp,%ebp
110099: 57 push %edi
11009a: 56 push %esi
11009b: 53 push %ebx
11009c: 83 ec 2c sub $0x2c,%esp
11009f: 8b 7d 08 mov 0x8(%ebp),%edi
1100a2: 8b 5d 0c mov 0xc(%ebp),%ebx
1100a5: 8b 75 10 mov 0x10(%ebp),%esi
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
1100a8: a1 ec 4e 12 00 mov 0x124eec,%eax
1100ad: 89 c1 mov %eax,%ecx
1100af: c1 e9 02 shr $0x2,%ecx
1100b2: 8d 51 01 lea 0x1(%ecx),%edx
1100b5: 0f af d1 imul %ecx,%edx
1100b8: 42 inc %edx
1100b9: 0f af d1 imul %ecx,%edx
1100bc: 4a dec %edx
1100bd: 0f af d0 imul %eax,%edx
1100c0: 83 fe 00 cmp $0x0,%esi
1100c3: 7c 16 jl 1100db <IMFS_memfile_extend+0x45><== NEVER TAKEN
1100c5: 7f 04 jg 1100cb <IMFS_memfile_extend+0x35><== NEVER TAKEN
1100c7: 39 d3 cmp %edx,%ebx
1100c9: 72 10 jb 1100db <IMFS_memfile_extend+0x45>
rtems_set_errno_and_return_minus_one( EINVAL );
1100cb: e8 fc 0f 00 00 call 1110cc <__errno>
1100d0: c7 00 16 00 00 00 movl $0x16,(%eax)
1100d6: e9 92 00 00 00 jmp 11016d <IMFS_memfile_extend+0xd7>
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
1100db: 8b 57 50 mov 0x50(%edi),%edx
1100de: 8b 4f 54 mov 0x54(%edi),%ecx
1100e1: 89 55 e0 mov %edx,-0x20(%ebp)
1100e4: 89 4d e4 mov %ecx,-0x1c(%ebp)
1100e7: 39 ce cmp %ecx,%esi
1100e9: 0f 8c 8f 00 00 00 jl 11017e <IMFS_memfile_extend+0xe8><== NEVER TAKEN
1100ef: 7f 08 jg 1100f9 <IMFS_memfile_extend+0x63><== NEVER TAKEN
1100f1: 39 d3 cmp %edx,%ebx
1100f3: 0f 86 85 00 00 00 jbe 11017e <IMFS_memfile_extend+0xe8>
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
1100f9: 89 45 d8 mov %eax,-0x28(%ebp)
1100fc: 89 c1 mov %eax,%ecx
1100fe: c1 f9 1f sar $0x1f,%ecx
110101: 89 4d dc mov %ecx,-0x24(%ebp)
110104: ff 75 dc pushl -0x24(%ebp)
110107: ff 75 d8 pushl -0x28(%ebp)
11010a: 56 push %esi
11010b: 53 push %ebx
11010c: e8 3f c8 00 00 call 11c950 <__divdi3>
110111: 83 c4 10 add $0x10,%esp
110114: 89 45 d4 mov %eax,-0x2c(%ebp)
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
110117: ff 75 dc pushl -0x24(%ebp)
11011a: ff 75 d8 pushl -0x28(%ebp)
11011d: ff 75 e4 pushl -0x1c(%ebp)
110120: ff 75 e0 pushl -0x20(%ebp)
110123: e8 28 c8 00 00 call 11c950 <__divdi3>
110128: 83 c4 10 add $0x10,%esp
11012b: 89 45 e0 mov %eax,-0x20(%ebp)
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
11012e: 89 c2 mov %eax,%edx
110130: eb 41 jmp 110173 <IMFS_memfile_extend+0xdd>
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
110132: 51 push %ecx
110133: 51 push %ecx
110134: 52 push %edx
110135: 57 push %edi
110136: 89 55 d0 mov %edx,-0x30(%ebp)
110139: e8 99 fd ff ff call 10fed7 <IMFS_memfile_addblock>
11013e: 83 c4 10 add $0x10,%esp
110141: 85 c0 test %eax,%eax
110143: 8b 55 d0 mov -0x30(%ebp),%edx
110146: 74 2a je 110172 <IMFS_memfile_extend+0xdc>
110148: eb 13 jmp 11015d <IMFS_memfile_extend+0xc7>
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
11014a: 50 push %eax
11014b: 50 push %eax
11014c: 52 push %edx
11014d: 57 push %edi
11014e: 89 55 d0 mov %edx,-0x30(%ebp)
110151: e8 16 ff ff ff call 11006c <IMFS_memfile_remove_block>
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
for ( ; block>=old_blocks ; block-- ) {
110156: 8b 55 d0 mov -0x30(%ebp),%edx
110159: 4a dec %edx
11015a: 83 c4 10 add $0x10,%esp
11015d: 3b 55 e0 cmp -0x20(%ebp),%edx
110160: 73 e8 jae 11014a <IMFS_memfile_extend+0xb4>
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
110162: e8 65 0f 00 00 call 1110cc <__errno>
110167: c7 00 1c 00 00 00 movl $0x1c,(%eax)
11016d: 83 c8 ff or $0xffffffff,%eax
110170: eb 0e jmp 110180 <IMFS_memfile_extend+0xea>
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
110172: 42 inc %edx
110173: 3b 55 d4 cmp -0x2c(%ebp),%edx
110176: 76 ba jbe 110132 <IMFS_memfile_extend+0x9c>
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
110178: 89 5f 50 mov %ebx,0x50(%edi)
11017b: 89 77 54 mov %esi,0x54(%edi)
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
return 0;
11017e: 31 c0 xor %eax,%eax
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
return 0;
}
110180: 8d 65 f4 lea -0xc(%ebp),%esp
110183: 5b pop %ebx
110184: 5e pop %esi
110185: 5f pop %edi
110186: c9 leave
110187: c3 ret
0010fbdc <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
10fbdc: 55 push %ebp
10fbdd: 89 e5 mov %esp,%ebp
10fbdf: 57 push %edi
10fbe0: 56 push %esi
10fbe1: 53 push %ebx
10fbe2: 83 ec 1c sub $0x1c,%esp
10fbe5: 8b 75 08 mov 0x8(%ebp),%esi
10fbe8: 8b 7d 0c mov 0xc(%ebp),%edi
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
10fbeb: 8b 0d ec 4e 12 00 mov 0x124eec,%ecx
10fbf1: c1 e9 02 shr $0x2,%ecx
10fbf4: 8d 41 ff lea -0x1(%ecx),%eax
10fbf7: 39 c7 cmp %eax,%edi
10fbf9: 77 40 ja 10fc3b <IMFS_memfile_get_block_pointer+0x5f>
p = info->indirect;
10fbfb: 8b 46 58 mov 0x58(%esi),%eax
if ( malloc_it ) {
10fbfe: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10fc02: 74 25 je 10fc29 <IMFS_memfile_get_block_pointer+0x4d>
if ( !p ) {
10fc04: 85 c0 test %eax,%eax
10fc06: 75 12 jne 10fc1a <IMFS_memfile_get_block_pointer+0x3e>
p = memfile_alloc_block();
10fc08: e8 ad ff ff ff call 10fbba <memfile_alloc_block>
if ( !p )
return 0;
10fc0d: 31 db xor %ebx,%ebx
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
10fc0f: 85 c0 test %eax,%eax
10fc11: 0f 84 f7 00 00 00 je 10fd0e <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
info->indirect = p;
10fc17: 89 46 58 mov %eax,0x58(%esi)
}
return &info->indirect[ my_block ];
10fc1a: 8d 1c bd 00 00 00 00 lea 0x0(,%edi,4),%ebx
10fc21: 03 5e 58 add 0x58(%esi),%ebx
10fc24: e9 e5 00 00 00 jmp 10fd0e <IMFS_memfile_get_block_pointer+0x132>
}
if ( !p )
return 0;
10fc29: 31 db xor %ebx,%ebx
info->indirect = p;
}
return &info->indirect[ my_block ];
}
if ( !p )
10fc2b: 85 c0 test %eax,%eax
10fc2d: 0f 84 db 00 00 00 je 10fd0e <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
return &info->indirect[ my_block ];
10fc33: 8d 1c b8 lea (%eax,%edi,4),%ebx
10fc36: e9 d3 00 00 00 jmp 10fd0e <IMFS_memfile_get_block_pointer+0x132>
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
10fc3b: 8d 41 01 lea 0x1(%ecx),%eax
10fc3e: 0f af c1 imul %ecx,%eax
10fc41: 8d 50 ff lea -0x1(%eax),%edx
10fc44: 39 d7 cmp %edx,%edi
10fc46: 77 40 ja 10fc88 <IMFS_memfile_get_block_pointer+0xac>
my_block -= FIRST_DOUBLY_INDIRECT;
10fc48: 29 cf sub %ecx,%edi
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
10fc4a: 89 f8 mov %edi,%eax
10fc4c: 31 d2 xor %edx,%edx
10fc4e: f7 f1 div %ecx
10fc50: 89 55 e4 mov %edx,-0x1c(%ebp)
10fc53: 89 c7 mov %eax,%edi
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
p = info->doubly_indirect;
10fc55: 8b 46 5c mov 0x5c(%esi),%eax
if ( malloc_it ) {
10fc58: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10fc5c: 74 1b je 10fc79 <IMFS_memfile_get_block_pointer+0x9d>
if ( !p ) {
10fc5e: 85 c0 test %eax,%eax
10fc60: 75 12 jne 10fc74 <IMFS_memfile_get_block_pointer+0x98>
p = memfile_alloc_block();
10fc62: e8 53 ff ff ff call 10fbba <memfile_alloc_block>
if ( !p )
return 0;
10fc67: 31 db xor %ebx,%ebx
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
10fc69: 85 c0 test %eax,%eax
10fc6b: 0f 84 9d 00 00 00 je 10fd0e <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
info->doubly_indirect = p;
10fc71: 89 46 5c mov %eax,0x5c(%esi)
}
p1 = (block_p *)p[ doubly ];
10fc74: 8d 34 b8 lea (%eax,%edi,4),%esi
10fc77: eb 65 jmp 10fcde <IMFS_memfile_get_block_pointer+0x102>
return (block_p *)&p1[ singly ];
}
if ( !p )
return 0;
10fc79: 31 db xor %ebx,%ebx
}
return (block_p *)&p1[ singly ];
}
if ( !p )
10fc7b: 85 c0 test %eax,%eax
10fc7d: 0f 84 8b 00 00 00 je 10fd0e <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p = (block_p *)p[ doubly ];
10fc83: 8b 04 b8 mov (%eax,%edi,4),%eax
10fc86: eb 7c jmp 10fd04 <IMFS_memfile_get_block_pointer+0x128>
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
10fc88: 8d 50 01 lea 0x1(%eax),%edx
10fc8b: 0f af d1 imul %ecx,%edx
10fc8e: 4a dec %edx
}
/*
* This means the requested block number is out of range.
*/
return 0;
10fc8f: 31 db xor %ebx,%ebx
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
10fc91: 39 d7 cmp %edx,%edi
10fc93: 77 79 ja 10fd0e <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
my_block -= FIRST_TRIPLY_INDIRECT;
10fc95: 29 c7 sub %eax,%edi
10fc97: 89 f8 mov %edi,%eax
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
10fc99: 31 d2 xor %edx,%edx
10fc9b: f7 f1 div %ecx
10fc9d: 89 55 e4 mov %edx,-0x1c(%ebp)
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
10fca0: 31 d2 xor %edx,%edx
10fca2: f7 f1 div %ecx
10fca4: 89 55 e0 mov %edx,-0x20(%ebp)
10fca7: 89 c7 mov %eax,%edi
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
p = info->triply_indirect;
10fca9: 8b 46 60 mov 0x60(%esi),%eax
if ( malloc_it ) {
10fcac: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10fcb0: 74 41 je 10fcf3 <IMFS_memfile_get_block_pointer+0x117>
if ( !p ) {
10fcb2: 85 c0 test %eax,%eax
10fcb4: 75 0c jne 10fcc2 <IMFS_memfile_get_block_pointer+0xe6>
p = memfile_alloc_block();
10fcb6: e8 ff fe ff ff call 10fbba <memfile_alloc_block>
if ( !p )
10fcbb: 85 c0 test %eax,%eax
10fcbd: 74 4f je 10fd0e <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
info->triply_indirect = p;
10fcbf: 89 46 60 mov %eax,0x60(%esi)
}
p1 = (block_p *) p[ triply ];
10fcc2: 8d 34 b8 lea (%eax,%edi,4),%esi
10fcc5: 8b 06 mov (%esi),%eax
if ( !p1 ) {
10fcc7: 85 c0 test %eax,%eax
10fcc9: 75 0d jne 10fcd8 <IMFS_memfile_get_block_pointer+0xfc>
p1 = memfile_alloc_block();
10fccb: e8 ea fe ff ff call 10fbba <memfile_alloc_block>
if ( !p1 )
return 0;
10fcd0: 31 db xor %ebx,%ebx
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
10fcd2: 85 c0 test %eax,%eax
10fcd4: 74 38 je 10fd0e <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p[ triply ] = (block_p) p1;
10fcd6: 89 06 mov %eax,(%esi)
}
p2 = (block_p *)p1[ doubly ];
10fcd8: 8b 55 e0 mov -0x20(%ebp),%edx
10fcdb: 8d 34 90 lea (%eax,%edx,4),%esi
10fcde: 8b 06 mov (%esi),%eax
if ( !p2 ) {
10fce0: 85 c0 test %eax,%eax
10fce2: 75 24 jne 10fd08 <IMFS_memfile_get_block_pointer+0x12c>
p2 = memfile_alloc_block();
10fce4: e8 d1 fe ff ff call 10fbba <memfile_alloc_block>
if ( !p2 )
return 0;
10fce9: 31 db xor %ebx,%ebx
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
if ( !p2 )
10fceb: 85 c0 test %eax,%eax
10fced: 74 1f je 10fd0e <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p1[ doubly ] = (block_p) p2;
10fcef: 89 06 mov %eax,(%esi)
10fcf1: eb 15 jmp 10fd08 <IMFS_memfile_get_block_pointer+0x12c>
}
return (block_p *)&p2[ singly ];
}
if ( !p )
10fcf3: 85 c0 test %eax,%eax
10fcf5: 74 17 je 10fd0e <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p1 = (block_p *) p[ triply ];
10fcf7: 8b 04 b8 mov (%eax,%edi,4),%eax
if ( !p1 )
10fcfa: 85 c0 test %eax,%eax
10fcfc: 74 10 je 10fd0e <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
p2 = (block_p *)p1[ doubly ];
10fcfe: 8b 55 e0 mov -0x20(%ebp),%edx
10fd01: 8b 04 90 mov (%eax,%edx,4),%eax
if ( !p2 )
10fd04: 85 c0 test %eax,%eax
10fd06: 74 06 je 10fd0e <IMFS_memfile_get_block_pointer+0x132><== NEVER TAKEN
return 0;
return (block_p *)&p2[ singly ];
10fd08: 8b 55 e4 mov -0x1c(%ebp),%edx
10fd0b: 8d 1c 90 lea (%eax,%edx,4),%ebx
/*
* This means the requested block number is out of range.
*/
return 0;
}
10fd0e: 89 d8 mov %ebx,%eax
10fd10: 83 c4 1c add $0x1c,%esp
10fd13: 5b pop %ebx
10fd14: 5e pop %esi
10fd15: 5f pop %edi
10fd16: c9 leave
10fd17: c3 ret
0010fd18 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
10fd18: 55 push %ebp
10fd19: 89 e5 mov %esp,%ebp
10fd1b: 57 push %edi
10fd1c: 56 push %esi
10fd1d: 53 push %ebx
10fd1e: 83 ec 4c sub $0x4c,%esp
10fd21: 8b 75 0c mov 0xc(%ebp),%esi
10fd24: 8b 7d 10 mov 0x10(%ebp),%edi
10fd27: 8b 5d 18 mov 0x18(%ebp),%ebx
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
10fd2a: 8b 45 08 mov 0x8(%ebp),%eax
10fd2d: 83 78 4c 06 cmpl $0x6,0x4c(%eax)
10fd31: 75 3f jne 10fd72 <IMFS_memfile_read+0x5a>
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
10fd33: 8b 48 58 mov 0x58(%eax),%ecx
if (my_length > (the_jnode->info.linearfile.size - start))
10fd36: 89 c2 mov %eax,%edx
10fd38: 8b 40 50 mov 0x50(%eax),%eax
10fd3b: 8b 52 54 mov 0x54(%edx),%edx
10fd3e: 89 45 b0 mov %eax,-0x50(%ebp)
10fd41: 89 55 b4 mov %edx,-0x4c(%ebp)
10fd44: 29 f0 sub %esi,%eax
10fd46: 19 fa sbb %edi,%edx
10fd48: 89 45 d0 mov %eax,-0x30(%ebp)
10fd4b: 89 55 d4 mov %edx,-0x2c(%ebp)
10fd4e: 31 c0 xor %eax,%eax
10fd50: 39 d0 cmp %edx,%eax
10fd52: 7c 0e jl 10fd62 <IMFS_memfile_read+0x4a><== NEVER TAKEN
10fd54: 7f 05 jg 10fd5b <IMFS_memfile_read+0x43><== NEVER TAKEN
10fd56: 3b 5d d0 cmp -0x30(%ebp),%ebx
10fd59: 76 07 jbe 10fd62 <IMFS_memfile_read+0x4a><== NEVER TAKEN
my_length = the_jnode->info.linearfile.size - start;
10fd5b: 8b 55 b0 mov -0x50(%ebp),%edx
10fd5e: 29 f2 sub %esi,%edx
10fd60: eb 02 jmp 10fd64 <IMFS_memfile_read+0x4c>
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
10fd62: 89 da mov %ebx,%edx <== NOT EXECUTED
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
my_length = the_jnode->info.linearfile.size - start;
memcpy(dest, &file_ptr[start], my_length);
10fd64: 01 ce add %ecx,%esi
10fd66: 8b 7d 14 mov 0x14(%ebp),%edi
10fd69: 89 d1 mov %edx,%ecx
10fd6b: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
10fd6d: e9 1d 01 00 00 jmp 10fe8f <IMFS_memfile_read+0x177>
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
10fd72: 89 f0 mov %esi,%eax
if ( last_byte > the_jnode->info.file.size )
10fd74: 8b 55 08 mov 0x8(%ebp),%edx
10fd77: 8b 52 50 mov 0x50(%edx),%edx
10fd7a: 89 55 cc mov %edx,-0x34(%ebp)
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
10fd7d: 8d 0c 33 lea (%ebx,%esi,1),%ecx
10fd80: 89 4d d0 mov %ecx,-0x30(%ebp)
if ( last_byte > the_jnode->info.file.size )
10fd83: 31 c9 xor %ecx,%ecx
10fd85: 8b 55 08 mov 0x8(%ebp),%edx
10fd88: 3b 4a 54 cmp 0x54(%edx),%ecx
10fd8b: 7c 14 jl 10fda1 <IMFS_memfile_read+0x89><== NEVER TAKEN
10fd8d: 7f 08 jg 10fd97 <IMFS_memfile_read+0x7f><== NEVER TAKEN
10fd8f: 8b 4d cc mov -0x34(%ebp),%ecx
10fd92: 39 4d d0 cmp %ecx,-0x30(%ebp)
10fd95: 76 0a jbe 10fda1 <IMFS_memfile_read+0x89>
my_length = the_jnode->info.file.size - start;
10fd97: 8b 55 cc mov -0x34(%ebp),%edx
10fd9a: 29 c2 sub %eax,%edx
10fd9c: 89 55 d0 mov %edx,-0x30(%ebp)
10fd9f: eb 03 jmp 10fda4 <IMFS_memfile_read+0x8c>
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
10fda1: 89 5d d0 mov %ebx,-0x30(%ebp)
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
10fda4: 8b 0d ec 4e 12 00 mov 0x124eec,%ecx
10fdaa: 89 4d c4 mov %ecx,-0x3c(%ebp)
10fdad: 89 c8 mov %ecx,%eax
10fdaf: 99 cltd
10fdb0: 89 d3 mov %edx,%ebx
10fdb2: 52 push %edx
10fdb3: 51 push %ecx
10fdb4: 57 push %edi
10fdb5: 56 push %esi
10fdb6: 89 4d c0 mov %ecx,-0x40(%ebp)
10fdb9: e8 de cc 00 00 call 11ca9c <__moddi3>
10fdbe: 83 c4 10 add $0x10,%esp
10fdc1: 89 45 cc mov %eax,-0x34(%ebp)
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
10fdc4: 8b 4d c0 mov -0x40(%ebp),%ecx
10fdc7: 53 push %ebx
10fdc8: 51 push %ecx
10fdc9: 57 push %edi
10fdca: 56 push %esi
10fdcb: e8 80 cb 00 00 call 11c950 <__divdi3>
10fdd0: 83 c4 10 add $0x10,%esp
10fdd3: 89 c3 mov %eax,%ebx
if ( start_offset ) {
10fdd5: 83 7d cc 00 cmpl $0x0,-0x34(%ebp)
10fdd9: 74 3d je 10fe18 <IMFS_memfile_read+0x100>
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
10fddb: 57 push %edi
10fddc: 6a 00 push $0x0
10fdde: 50 push %eax
10fddf: ff 75 08 pushl 0x8(%ebp)
10fde2: e8 f5 fd ff ff call 10fbdc <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
10fde7: 83 c4 10 add $0x10,%esp
return copied;
10fdea: 31 d2 xor %edx,%edx
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
10fdec: 85 c0 test %eax,%eax
10fdee: 0f 84 ba 00 00 00 je 10feae <IMFS_memfile_read+0x196><== NEVER TAKEN
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
10fdf4: 8b 4d c4 mov -0x3c(%ebp),%ecx
10fdf7: 2b 4d cc sub -0x34(%ebp),%ecx
10fdfa: 8b 55 d0 mov -0x30(%ebp),%edx
10fdfd: 39 ca cmp %ecx,%edx
10fdff: 76 02 jbe 10fe03 <IMFS_memfile_read+0xeb>
10fe01: 89 ca mov %ecx,%edx
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
10fe03: 8b 75 cc mov -0x34(%ebp),%esi
10fe06: 03 30 add (%eax),%esi
dest += to_copy;
10fe08: 8b 7d 14 mov 0x14(%ebp),%edi
10fe0b: 89 d1 mov %edx,%ecx
10fe0d: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
10fe0f: 89 7d cc mov %edi,-0x34(%ebp)
block++;
10fe12: 43 inc %ebx
my_length -= to_copy;
10fe13: 29 55 d0 sub %edx,-0x30(%ebp)
10fe16: eb 08 jmp 10fe20 <IMFS_memfile_read+0x108>
unsigned int last_byte;
unsigned int copied;
unsigned int start_offset;
unsigned char *dest;
dest = destination;
10fe18: 8b 45 14 mov 0x14(%ebp),%eax
10fe1b: 89 45 cc mov %eax,-0x34(%ebp)
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
my_length = the_jnode->info.file.size - start;
copied = 0;
10fe1e: 31 d2 xor %edx,%edx
}
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
10fe20: 8b 0d ec 4e 12 00 mov 0x124eec,%ecx
10fe26: 89 4d c8 mov %ecx,-0x38(%ebp)
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
10fe29: eb 2f jmp 10fe5a <IMFS_memfile_read+0x142>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
10fe2b: 56 push %esi
10fe2c: 6a 00 push $0x0
10fe2e: 53 push %ebx
10fe2f: ff 75 08 pushl 0x8(%ebp)
10fe32: 89 55 c0 mov %edx,-0x40(%ebp)
10fe35: e8 a2 fd ff ff call 10fbdc <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
10fe3a: 83 c4 10 add $0x10,%esp
10fe3d: 85 c0 test %eax,%eax
10fe3f: 8b 55 c0 mov -0x40(%ebp),%edx
10fe42: 74 6a je 10feae <IMFS_memfile_read+0x196><== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
10fe44: 8b 30 mov (%eax),%esi
10fe46: 8b 7d cc mov -0x34(%ebp),%edi
10fe49: 8b 4d c8 mov -0x38(%ebp),%ecx
10fe4c: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
dest += to_copy;
10fe4e: 89 7d cc mov %edi,-0x34(%ebp)
block++;
10fe51: 43 inc %ebx
my_length -= to_copy;
10fe52: 8b 7d c8 mov -0x38(%ebp),%edi
10fe55: 29 7d d0 sub %edi,-0x30(%ebp)
copied += to_copy;
10fe58: 01 fa add %edi,%edx
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
10fe5a: 8b 45 d0 mov -0x30(%ebp),%eax
10fe5d: 3b 05 ec 4e 12 00 cmp 0x124eec,%eax
10fe63: 73 c6 jae 10fe2b <IMFS_memfile_read+0x113>
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
10fe65: 85 c0 test %eax,%eax
10fe67: 74 26 je 10fe8f <IMFS_memfile_read+0x177>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
10fe69: 51 push %ecx
10fe6a: 6a 00 push $0x0
10fe6c: 53 push %ebx
10fe6d: ff 75 08 pushl 0x8(%ebp)
10fe70: 89 55 c0 mov %edx,-0x40(%ebp)
10fe73: e8 64 fd ff ff call 10fbdc <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
10fe78: 83 c4 10 add $0x10,%esp
10fe7b: 85 c0 test %eax,%eax
10fe7d: 8b 55 c0 mov -0x40(%ebp),%edx
10fe80: 74 2c je 10feae <IMFS_memfile_read+0x196><== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
10fe82: 8b 30 mov (%eax),%esi
10fe84: 8b 7d cc mov -0x34(%ebp),%edi
10fe87: 8b 4d d0 mov -0x30(%ebp),%ecx
10fe8a: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
copied += my_length;
10fe8c: 03 55 d0 add -0x30(%ebp),%edx
}
IMFS_update_atime( the_jnode );
10fe8f: 50 push %eax
10fe90: 50 push %eax
10fe91: 6a 00 push $0x0
10fe93: 8d 45 e0 lea -0x20(%ebp),%eax
10fe96: 50 push %eax
10fe97: 89 55 c0 mov %edx,-0x40(%ebp)
10fe9a: e8 21 75 ff ff call 1073c0 <gettimeofday>
10fe9f: 8b 45 e0 mov -0x20(%ebp),%eax
10fea2: 8b 4d 08 mov 0x8(%ebp),%ecx
10fea5: 89 41 40 mov %eax,0x40(%ecx)
return copied;
10fea8: 8b 55 c0 mov -0x40(%ebp),%edx
10feab: 83 c4 10 add $0x10,%esp
}
10feae: 89 d0 mov %edx,%eax
10feb0: 8d 65 f4 lea -0xc(%ebp),%esp
10feb3: 5b pop %ebx
10feb4: 5e pop %esi
10feb5: 5f pop %edi
10feb6: c9 leave
10feb7: c3 ret
0010ff76 <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
10ff76: 55 push %ebp
10ff77: 89 e5 mov %esp,%ebp
10ff79: 57 push %edi
10ff7a: 56 push %esi
10ff7b: 53 push %ebx
10ff7c: 83 ec 1c sub $0x1c,%esp
10ff7f: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Eventually this could be set smarter at each call to
* memfile_free_blocks_in_table to greatly speed this up.
*/
to_free = IMFS_MEMFILE_BLOCK_SLOTS;
10ff82: 8b 35 ec 4e 12 00 mov 0x124eec,%esi
10ff88: c1 ee 02 shr $0x2,%esi
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
10ff8b: 83 7b 58 00 cmpl $0x0,0x58(%ebx)
10ff8f: 74 0f je 10ffa0 <IMFS_memfile_remove+0x2a>
memfile_free_blocks_in_table( &info->indirect, to_free );
10ff91: 57 push %edi
10ff92: 57 push %edi
10ff93: 56 push %esi
10ff94: 8d 43 58 lea 0x58(%ebx),%eax
10ff97: 50 push %eax
10ff98: e8 8c ff ff ff call 10ff29 <memfile_free_blocks_in_table>
10ff9d: 83 c4 10 add $0x10,%esp
}
if ( info->doubly_indirect ) {
10ffa0: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx)
10ffa4: 74 3e je 10ffe4 <IMFS_memfile_remove+0x6e>
10ffa6: 31 ff xor %edi,%edi
10ffa8: eb 1f jmp 10ffc9 <IMFS_memfile_remove+0x53>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
if ( info->doubly_indirect[i] ) {
10ffaa: 8b 43 5c mov 0x5c(%ebx),%eax
10ffad: 8d 14 bd 00 00 00 00 lea 0x0(,%edi,4),%edx
10ffb4: 83 3c b8 00 cmpl $0x0,(%eax,%edi,4)
10ffb8: 74 0e je 10ffc8 <IMFS_memfile_remove+0x52><== NEVER TAKEN
memfile_free_blocks_in_table(
10ffba: 51 push %ecx
10ffbb: 51 push %ecx
10ffbc: 56 push %esi
10ffbd: 01 d0 add %edx,%eax
10ffbf: 50 push %eax
10ffc0: e8 64 ff ff ff call 10ff29 <memfile_free_blocks_in_table>
10ffc5: 83 c4 10 add $0x10,%esp
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
10ffc8: 47 inc %edi
10ffc9: a1 ec 4e 12 00 mov 0x124eec,%eax
10ffce: c1 e8 02 shr $0x2,%eax
10ffd1: 39 c7 cmp %eax,%edi
10ffd3: 72 d5 jb 10ffaa <IMFS_memfile_remove+0x34>
if ( info->doubly_indirect[i] ) {
memfile_free_blocks_in_table(
(block_p **)&info->doubly_indirect[i], to_free );
}
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
10ffd5: 57 push %edi
10ffd6: 57 push %edi
10ffd7: 56 push %esi
10ffd8: 8d 43 5c lea 0x5c(%ebx),%eax
10ffdb: 50 push %eax
10ffdc: e8 48 ff ff ff call 10ff29 <memfile_free_blocks_in_table>
10ffe1: 83 c4 10 add $0x10,%esp
}
if ( info->triply_indirect ) {
10ffe4: 83 7b 60 00 cmpl $0x0,0x60(%ebx)
10ffe8: 74 78 je 110062 <IMFS_memfile_remove+0xec>
10ffea: 31 ff xor %edi,%edi
10ffec: eb 59 jmp 110047 <IMFS_memfile_remove+0xd1>
10ffee: 8d 04 bd 00 00 00 00 lea 0x0(,%edi,4),%eax
10fff5: 89 45 e4 mov %eax,-0x1c(%ebp)
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
10fff8: 8b 43 60 mov 0x60(%ebx),%eax
10fffb: 8b 04 b8 mov (%eax,%edi,4),%eax
if ( !p ) /* ensure we have a valid pointer */
10fffe: 85 c0 test %eax,%eax
110000: 74 51 je 110053 <IMFS_memfile_remove+0xdd><== NEVER TAKEN
110002: 31 d2 xor %edx,%edx
110004: eb 21 jmp 110027 <IMFS_memfile_remove+0xb1>
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
110006: 83 38 00 cmpl $0x0,(%eax)
110009: 74 18 je 110023 <IMFS_memfile_remove+0xad><== NEVER TAKEN
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
11000b: 51 push %ecx
11000c: 51 push %ecx
11000d: 56 push %esi
11000e: 50 push %eax
11000f: 89 45 dc mov %eax,-0x24(%ebp)
110012: 89 55 e0 mov %edx,-0x20(%ebp)
110015: e8 0f ff ff ff call 10ff29 <memfile_free_blocks_in_table>
11001a: 83 c4 10 add $0x10,%esp
11001d: 8b 55 e0 mov -0x20(%ebp),%edx
110020: 8b 45 dc mov -0x24(%ebp),%eax
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
if ( !p ) /* ensure we have a valid pointer */
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
110023: 42 inc %edx
110024: 83 c0 04 add $0x4,%eax
110027: 8b 0d ec 4e 12 00 mov 0x124eec,%ecx
11002d: c1 e9 02 shr $0x2,%ecx
110030: 39 ca cmp %ecx,%edx
110032: 72 d2 jb 110006 <IMFS_memfile_remove+0x90>
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
110034: 52 push %edx
110035: 52 push %edx
110036: 56 push %esi
110037: 8b 45 e4 mov -0x1c(%ebp),%eax
11003a: 03 43 60 add 0x60(%ebx),%eax
11003d: 50 push %eax
11003e: e8 e6 fe ff ff call 10ff29 <memfile_free_blocks_in_table>
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
110043: 47 inc %edi
110044: 83 c4 10 add $0x10,%esp
110047: a1 ec 4e 12 00 mov 0x124eec,%eax
11004c: c1 e8 02 shr $0x2,%eax
11004f: 39 c7 cmp %eax,%edi
110051: 72 9b jb 10ffee <IMFS_memfile_remove+0x78>
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
110053: 50 push %eax
110054: 50 push %eax
110055: 56 push %esi
(block_p **)&info->triply_indirect, to_free );
110056: 83 c3 60 add $0x60,%ebx
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
110059: 53 push %ebx
11005a: e8 ca fe ff ff call 10ff29 <memfile_free_blocks_in_table>
11005f: 83 c4 10 add $0x10,%esp
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
110062: 31 c0 xor %eax,%eax
110064: 8d 65 f4 lea -0xc(%ebp),%esp
110067: 5b pop %ebx
110068: 5e pop %esi
110069: 5f pop %edi
11006a: c9 leave
11006b: c3 ret
00110188 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
110188: 55 push %ebp
110189: 89 e5 mov %esp,%ebp
11018b: 57 push %edi
11018c: 56 push %esi
11018d: 53 push %ebx
11018e: 83 ec 2c sub $0x2c,%esp
110191: 8b 75 0c mov 0xc(%ebp),%esi
110194: 8b 7d 10 mov 0x10(%ebp),%edi
/*
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
110197: 8b 4d 18 mov 0x18(%ebp),%ecx
11019a: 01 f1 add %esi,%ecx
if ( last_byte > the_jnode->info.file.size ) {
11019c: 89 c8 mov %ecx,%eax
11019e: 31 d2 xor %edx,%edx
1101a0: 8b 5d 08 mov 0x8(%ebp),%ebx
1101a3: 3b 53 54 cmp 0x54(%ebx),%edx
1101a6: 7c 2c jl 1101d4 <IMFS_memfile_write+0x4c><== NEVER TAKEN
1101a8: 7f 05 jg 1101af <IMFS_memfile_write+0x27><== NEVER TAKEN
1101aa: 3b 4b 50 cmp 0x50(%ebx),%ecx
1101ad: 76 25 jbe 1101d4 <IMFS_memfile_write+0x4c><== NEVER TAKEN
status = IMFS_memfile_extend( the_jnode, last_byte );
1101af: 51 push %ecx
1101b0: 52 push %edx
1101b1: 50 push %eax
1101b2: ff 75 08 pushl 0x8(%ebp)
1101b5: e8 dc fe ff ff call 110096 <IMFS_memfile_extend>
if ( status )
1101ba: 83 c4 10 add $0x10,%esp
1101bd: 85 c0 test %eax,%eax
1101bf: 74 13 je 1101d4 <IMFS_memfile_write+0x4c>
rtems_set_errno_and_return_minus_one( ENOSPC );
1101c1: e8 06 0f 00 00 call 1110cc <__errno>
1101c6: c7 00 1c 00 00 00 movl $0x1c,(%eax)
1101cc: 83 c9 ff or $0xffffffff,%ecx
1101cf: e9 0f 01 00 00 jmp 1102e3 <IMFS_memfile_write+0x15b>
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
1101d4: a1 ec 4e 12 00 mov 0x124eec,%eax
1101d9: 89 45 cc mov %eax,-0x34(%ebp)
1101dc: 99 cltd
1101dd: 89 d3 mov %edx,%ebx
1101df: 52 push %edx
1101e0: 50 push %eax
1101e1: 57 push %edi
1101e2: 56 push %esi
1101e3: 89 45 c8 mov %eax,-0x38(%ebp)
1101e6: e8 b1 c8 00 00 call 11ca9c <__moddi3>
1101eb: 83 c4 10 add $0x10,%esp
1101ee: 89 45 d0 mov %eax,-0x30(%ebp)
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
1101f1: 8b 4d c8 mov -0x38(%ebp),%ecx
1101f4: 53 push %ebx
1101f5: 51 push %ecx
1101f6: 57 push %edi
1101f7: 56 push %esi
1101f8: e8 53 c7 00 00 call 11c950 <__divdi3>
1101fd: 83 c4 10 add $0x10,%esp
110200: 89 c3 mov %eax,%ebx
if ( start_offset ) {
110202: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
110206: 74 40 je 110248 <IMFS_memfile_write+0xc0>
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
110208: 52 push %edx
110209: 6a 00 push $0x0
11020b: 53 push %ebx
11020c: ff 75 08 pushl 0x8(%ebp)
11020f: e8 c8 f9 ff ff call 10fbdc <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
110214: 83 c4 10 add $0x10,%esp
return copied;
110217: 31 c9 xor %ecx,%ecx
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
110219: 85 c0 test %eax,%eax
11021b: 0f 84 c2 00 00 00 je 1102e3 <IMFS_memfile_write+0x15b><== NEVER TAKEN
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
110221: 8b 55 cc mov -0x34(%ebp),%edx
110224: 2b 55 d0 sub -0x30(%ebp),%edx
110227: 3b 55 18 cmp 0x18(%ebp),%edx
11022a: 76 03 jbe 11022f <IMFS_memfile_write+0xa7>
11022c: 8b 55 18 mov 0x18(%ebp),%edx
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
11022f: 8b 00 mov (%eax),%eax
110231: 03 45 d0 add -0x30(%ebp),%eax
src += to_copy;
110234: 89 c7 mov %eax,%edi
110236: 8b 75 14 mov 0x14(%ebp),%esi
110239: 89 d1 mov %edx,%ecx
11023b: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
block++;
11023d: 43 inc %ebx
my_length -= to_copy;
11023e: 8b 4d 18 mov 0x18(%ebp),%ecx
110241: 29 d1 sub %edx,%ecx
110243: 89 4d d4 mov %ecx,-0x2c(%ebp)
110246: eb 0b jmp 110253 <IMFS_memfile_write+0xcb>
unsigned int last_byte;
unsigned int start_offset;
int copied;
const unsigned char *src;
src = source;
110248: 8b 75 14 mov 0x14(%ebp),%esi
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
11024b: 8b 45 18 mov 0x18(%ebp),%eax
11024e: 89 45 d4 mov %eax,-0x2c(%ebp)
status = IMFS_memfile_extend( the_jnode, last_byte );
if ( status )
rtems_set_errno_and_return_minus_one( ENOSPC );
}
copied = 0;
110251: 31 d2 xor %edx,%edx
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
110253: 8b 0d ec 4e 12 00 mov 0x124eec,%ecx
110259: 89 4d d0 mov %ecx,-0x30(%ebp)
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
11025c: eb 2b jmp 110289 <IMFS_memfile_write+0x101>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
11025e: 50 push %eax
11025f: 6a 00 push $0x0
110261: 53 push %ebx
110262: ff 75 08 pushl 0x8(%ebp)
110265: 89 55 c8 mov %edx,-0x38(%ebp)
110268: e8 6f f9 ff ff call 10fbdc <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
11026d: 83 c4 10 add $0x10,%esp
110270: 85 c0 test %eax,%eax
110272: 8b 55 c8 mov -0x38(%ebp),%edx
110275: 74 6a je 1102e1 <IMFS_memfile_write+0x159><== NEVER TAKEN
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
110277: 8b 00 mov (%eax),%eax
src += to_copy;
110279: 89 c7 mov %eax,%edi
11027b: 8b 4d d0 mov -0x30(%ebp),%ecx
11027e: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
block++;
110280: 43 inc %ebx
my_length -= to_copy;
110281: 8b 45 d0 mov -0x30(%ebp),%eax
110284: 29 45 d4 sub %eax,-0x2c(%ebp)
* IMFS_memfile_write
*
* This routine writes the specified data buffer into the in memory
* file pointed to by the_jnode. The file is extended as needed.
*/
MEMFILE_STATIC ssize_t IMFS_memfile_write(
110287: 01 c2 add %eax,%edx
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
110289: 8b 4d d4 mov -0x2c(%ebp),%ecx
11028c: 3b 0d ec 4e 12 00 cmp 0x124eec,%ecx
110292: 73 ca jae 11025e <IMFS_memfile_write+0xd6>
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
110294: 85 c9 test %ecx,%ecx
110296: 74 27 je 1102bf <IMFS_memfile_write+0x137>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
110298: 57 push %edi
110299: 6a 00 push $0x0
11029b: 53 push %ebx
11029c: ff 75 08 pushl 0x8(%ebp)
11029f: 89 55 c8 mov %edx,-0x38(%ebp)
1102a2: e8 35 f9 ff ff call 10fbdc <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
1102a7: 83 c4 10 add $0x10,%esp
1102aa: 8b 55 c8 mov -0x38(%ebp),%edx
1102ad: 89 d1 mov %edx,%ecx
1102af: 85 c0 test %eax,%eax
1102b1: 74 30 je 1102e3 <IMFS_memfile_write+0x15b><== NEVER TAKEN
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, my_length );
1102b3: 8b 00 mov (%eax),%eax
1102b5: 89 c7 mov %eax,%edi
1102b7: 8b 4d d4 mov -0x2c(%ebp),%ecx
1102ba: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
my_length = 0;
copied += to_copy;
1102bc: 03 55 d4 add -0x2c(%ebp),%edx
}
IMFS_mtime_ctime_update( the_jnode );
1102bf: 53 push %ebx
1102c0: 53 push %ebx
1102c1: 6a 00 push $0x0
1102c3: 8d 45 e0 lea -0x20(%ebp),%eax
1102c6: 50 push %eax
1102c7: 89 55 c8 mov %edx,-0x38(%ebp)
1102ca: e8 f1 70 ff ff call 1073c0 <gettimeofday>
1102cf: 8b 45 e0 mov -0x20(%ebp),%eax
1102d2: 8b 5d 08 mov 0x8(%ebp),%ebx
1102d5: 89 43 44 mov %eax,0x44(%ebx)
1102d8: 89 43 48 mov %eax,0x48(%ebx)
return copied;
1102db: 83 c4 10 add $0x10,%esp
1102de: 8b 55 c8 mov -0x38(%ebp),%edx
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
1102e1: 89 d1 mov %edx,%ecx
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
1102e3: 89 c8 mov %ecx,%eax
1102e5: 8d 65 f4 lea -0xc(%ebp),%esp
1102e8: 5b pop %ebx
1102e9: 5e pop %esi
1102ea: 5f pop %edi
1102eb: c9 leave
1102ec: c3 ret
00106d90 <IMFS_mount>:
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
106d90: 55 push %ebp
106d91: 89 e5 mov %esp,%ebp
106d93: 83 ec 08 sub $0x8,%esp
106d96: 8b 55 08 mov 0x8(%ebp),%edx
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
106d99: 8b 42 08 mov 0x8(%edx),%eax
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
106d9c: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
106da0: 74 10 je 106db2 <IMFS_mount+0x22> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
106da2: e8 25 a3 00 00 call 1110cc <__errno> <== NOT EXECUTED
106da7: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
106dad: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106db0: eb 05 jmp 106db7 <IMFS_mount+0x27> <== NOT EXECUTED
/*
* Set mt_fs pointer to point to the mount table entry for
* the mounted file system.
*/
node->info.directory.mt_fs = mt_entry;
106db2: 89 50 5c mov %edx,0x5c(%eax)
return 0;
106db5: 31 c0 xor %eax,%eax
}
106db7: c9 leave
106db8: c3 ret
00109528 <IMFS_print_jnode>:
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
109528: 55 push %ebp
109529: 89 e5 mov %esp,%ebp
10952b: 53 push %ebx
10952c: 83 ec 0c sub $0xc,%esp
10952f: 8b 5d 08 mov 0x8(%ebp),%ebx
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
109532: a1 40 98 12 00 mov 0x129840,%eax
109537: ff 70 08 pushl 0x8(%eax)
10953a: 8d 43 0c lea 0xc(%ebx),%eax
10953d: 50 push %eax
10953e: e8 ed bd 00 00 call 115330 <fputs>
switch( the_jnode->type ) {
109543: 8b 43 4c mov 0x4c(%ebx),%eax
109546: 83 c4 10 add $0x10,%esp
109549: 8d 50 ff lea -0x1(%eax),%edx
10954c: 83 fa 06 cmp $0x6,%edx
10954f: 77 75 ja 1095c6 <IMFS_print_jnode+0x9e> <== NEVER TAKEN
109551: a1 40 98 12 00 mov 0x129840,%eax
109556: ff 24 95 70 48 12 00 jmp *0x124870(,%edx,4)
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
10955d: 51 push %ecx
10955e: 51 push %ecx
10955f: ff 70 08 pushl 0x8(%eax)
109562: 6a 2f push $0x2f
109564: e8 1b bd 00 00 call 115284 <fputc>
109569: eb 2b jmp 109596 <IMFS_print_jnode+0x6e>
break;
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
10956b: ff 73 54 pushl 0x54(%ebx)
10956e: ff 73 50 pushl 0x50(%ebx)
109571: 68 95 47 12 00 push $0x124795
109576: eb 16 jmp 10958e <IMFS_print_jnode+0x66>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
109578: ff 73 58 pushl 0x58(%ebx)
10957b: ff 73 50 pushl 0x50(%ebx)
10957e: 68 a8 47 12 00 push $0x1247a8
109583: eb 09 jmp 10958e <IMFS_print_jnode+0x66>
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
109585: 52 push %edx
109586: ff 73 50 pushl 0x50(%ebx)
109589: 68 b7 47 12 00 push $0x1247b7
10958e: ff 70 08 pushl 0x8(%eax)
109591: e8 8e bc 00 00 call 115224 <fprintf>
(uint32_t)the_jnode->info.file.size );
#endif
break;
109596: 83 c4 10 add $0x10,%esp
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
109599: c7 45 08 a1 4a 12 00 movl $0x124aa1,0x8(%ebp)
}
1095a0: 8b 5d fc mov -0x4(%ebp),%ebx
1095a3: c9 leave
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
1095a4: e9 4f d5 00 00 jmp 116af8 <puts>
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
1095a9: 53 push %ebx
1095aa: 53 push %ebx
1095ab: ff 70 08 pushl 0x8(%eax)
1095ae: 68 c3 47 12 00 push $0x1247c3
1095b3: eb 0a jmp 1095bf <IMFS_print_jnode+0x97>
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
1095b5: 51 push %ecx
1095b6: 51 push %ecx
1095b7: ff 70 08 pushl 0x8(%eax)
1095ba: 68 d7 47 12 00 push $0x1247d7
1095bf: e8 6c bd 00 00 call 115330 <fputs>
1095c4: eb 14 jmp 1095da <IMFS_print_jnode+0xb2>
return;
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
1095c6: 52 push %edx <== NOT EXECUTED
1095c7: 50 push %eax <== NOT EXECUTED
1095c8: 68 ea 47 12 00 push $0x1247ea <== NOT EXECUTED
1095cd: a1 40 98 12 00 mov 0x129840,%eax <== NOT EXECUTED
1095d2: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED
1095d5: e8 4a bc 00 00 call 115224 <fprintf> <== NOT EXECUTED
return;
1095da: 83 c4 10 add $0x10,%esp
}
puts("");
}
1095dd: 8b 5d fc mov -0x4(%ebp),%ebx
1095e0: c9 leave
1095e1: c3 ret
00106df8 <IMFS_rename>:
rtems_filesystem_location_info_t *old_parent_loc, /* IN */
rtems_filesystem_location_info_t *old_loc, /* IN */
rtems_filesystem_location_info_t *new_parent_loc, /* IN */
const char *new_name /* IN */
)
{
106df8: 55 push %ebp
106df9: 89 e5 mov %esp,%ebp
106dfb: 53 push %ebx
106dfc: 83 ec 18 sub $0x18,%esp
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
106dff: 8b 45 0c mov 0xc(%ebp),%eax
106e02: 8b 18 mov (%eax),%ebx
strncpy( the_jnode->name, new_name, IMFS_NAME_MAX );
106e04: 6a 20 push $0x20
106e06: ff 75 14 pushl 0x14(%ebp)
106e09: 8d 43 0c lea 0xc(%ebx),%eax
106e0c: 50 push %eax
106e0d: e8 8a b1 00 00 call 111f9c <strncpy>
if ( the_jnode->Parent != NULL )
106e12: 83 c4 10 add $0x10,%esp
106e15: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
106e19: 74 0c je 106e27 <IMFS_rename+0x2f> <== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
106e1b: 83 ec 0c sub $0xc,%esp
106e1e: 53 push %ebx
106e1f: e8 e0 3b 00 00 call 10aa04 <_Chain_Extract>
106e24: 83 c4 10 add $0x10,%esp
rtems_chain_extract( (rtems_chain_node *) the_jnode );
new_parent = new_parent_loc->node_access;
106e27: 8b 45 10 mov 0x10(%ebp),%eax
106e2a: 8b 00 mov (%eax),%eax
the_jnode->Parent = new_parent;
106e2c: 89 43 08 mov %eax,0x8(%ebx)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
106e2f: 51 push %ecx
106e30: 51 push %ecx
106e31: 53 push %ebx
rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
106e32: 83 c0 50 add $0x50,%eax
106e35: 50 push %eax
106e36: e8 a5 3b 00 00 call 10a9e0 <_Chain_Append>
/*
* Update the time.
*/
IMFS_update_ctime( the_jnode );
106e3b: 58 pop %eax
106e3c: 5a pop %edx
106e3d: 6a 00 push $0x0
106e3f: 8d 45 f0 lea -0x10(%ebp),%eax
106e42: 50 push %eax
106e43: e8 78 05 00 00 call 1073c0 <gettimeofday>
106e48: 8b 45 f0 mov -0x10(%ebp),%eax
106e4b: 89 43 48 mov %eax,0x48(%ebx)
return 0;
}
106e4e: 31 c0 xor %eax,%eax
106e50: 8b 5d fc mov -0x4(%ebp),%ebx
106e53: c9 leave
106e54: c3 ret
0010df48 <IMFS_stat>:
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
10df48: 55 push %ebp
10df49: 89 e5 mov %esp,%ebp
10df4b: 56 push %esi
10df4c: 53 push %ebx
10df4d: 8b 4d 08 mov 0x8(%ebp),%ecx
10df50: 8b 45 0c mov 0xc(%ebp),%eax
IMFS_fs_info_t *fs_info;
IMFS_jnode_t *the_jnode;
IMFS_device_t *io;
the_jnode = loc->node_access;
10df53: 8b 11 mov (%ecx),%edx
switch ( the_jnode->type ) {
10df55: 8b 5a 4c mov 0x4c(%edx),%ebx
10df58: 83 eb 02 sub $0x2,%ebx
10df5b: 83 fb 05 cmp $0x5,%ebx
10df5e: 77 33 ja 10df93 <IMFS_stat+0x4b> <== NEVER TAKEN
10df60: ff 24 9d 30 f4 11 00 jmp *0x11f430(,%ebx,4)
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
10df67: 8b 5a 54 mov 0x54(%edx),%ebx
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
10df6a: 8b 72 50 mov 0x50(%edx),%esi
10df6d: 89 70 18 mov %esi,0x18(%eax)
10df70: 89 58 1c mov %ebx,0x1c(%eax)
break;
10df73: eb 2e jmp 10dfa3 <IMFS_stat+0x5b>
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
10df75: 8b 5a 50 mov 0x50(%edx),%ebx
10df78: 8b 72 54 mov 0x54(%edx),%esi
10df7b: 89 58 20 mov %ebx,0x20(%eax)
10df7e: 89 70 24 mov %esi,0x24(%eax)
break;
10df81: eb 20 jmp 10dfa3 <IMFS_stat+0x5b>
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
10df83: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax)
10df8a: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
break;
10df91: eb 10 jmp 10dfa3 <IMFS_stat+0x5b>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
10df93: e8 34 31 00 00 call 1110cc <__errno>
10df98: c7 00 86 00 00 00 movl $0x86,(%eax)
10df9e: 83 c8 ff or $0xffffffff,%eax
10dfa1: eb 47 jmp 10dfea <IMFS_stat+0xa2>
/*
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
10dfa3: 8b 49 10 mov 0x10(%ecx),%ecx
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
10dfa6: 8b 49 34 mov 0x34(%ecx),%ecx
10dfa9: 8b 09 mov (%ecx),%ecx
/*
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
10dfab: c7 00 fe ff 00 00 movl $0xfffe,(%eax)
10dfb1: 89 48 04 mov %ecx,0x4(%eax)
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
10dfb4: 8b 4a 30 mov 0x30(%edx),%ecx
10dfb7: 89 48 0c mov %ecx,0xc(%eax)
buf->st_nlink = the_jnode->st_nlink;
10dfba: 8b 4a 34 mov 0x34(%edx),%ecx
10dfbd: 66 89 48 10 mov %cx,0x10(%eax)
buf->st_ino = the_jnode->st_ino;
10dfc1: 8b 4a 38 mov 0x38(%edx),%ecx
10dfc4: 89 48 08 mov %ecx,0x8(%eax)
buf->st_uid = the_jnode->st_uid;
10dfc7: 8b 4a 3c mov 0x3c(%edx),%ecx
10dfca: 66 89 48 12 mov %cx,0x12(%eax)
buf->st_gid = the_jnode->st_gid;
10dfce: 66 8b 4a 3e mov 0x3e(%edx),%cx
10dfd2: 66 89 48 14 mov %cx,0x14(%eax)
buf->st_atime = the_jnode->stat_atime;
10dfd6: 8b 4a 40 mov 0x40(%edx),%ecx
10dfd9: 89 48 28 mov %ecx,0x28(%eax)
buf->st_mtime = the_jnode->stat_mtime;
10dfdc: 8b 4a 44 mov 0x44(%edx),%ecx
10dfdf: 89 48 30 mov %ecx,0x30(%eax)
buf->st_ctime = the_jnode->stat_ctime;
10dfe2: 8b 52 48 mov 0x48(%edx),%edx
10dfe5: 89 50 38 mov %edx,0x38(%eax)
return 0;
10dfe8: 31 c0 xor %eax,%eax
}
10dfea: 5b pop %ebx
10dfeb: 5e pop %esi
10dfec: c9 leave
10dfed: c3 ret
00106ee4 <IMFS_unlink>:
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
106ee4: 55 push %ebp
106ee5: 89 e5 mov %esp,%ebp
106ee7: 57 push %edi
106ee8: 56 push %esi
106ee9: 53 push %ebx
106eea: 83 ec 2c sub $0x2c,%esp
IMFS_jnode_t *node;
rtems_filesystem_location_info_t the_link;
int result = 0;
node = loc->node_access;
106eed: 8b 45 0c mov 0xc(%ebp),%eax
106ef0: 8b 18 mov (%eax),%ebx
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
106ef2: 83 7b 4c 03 cmpl $0x3,0x4c(%ebx)
106ef6: 75 7a jne 106f72 <IMFS_unlink+0x8e>
if ( !node->info.hard_link.link_node )
106ef8: 8b 43 50 mov 0x50(%ebx),%eax
106efb: 85 c0 test %eax,%eax
106efd: 75 10 jne 106f0f <IMFS_unlink+0x2b> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
106eff: e8 c8 a1 00 00 call 1110cc <__errno> <== NOT EXECUTED
106f04: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
106f0a: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106f0d: eb 75 jmp 106f84 <IMFS_unlink+0xa0> <== NOT EXECUTED
the_link = *loc;
106f0f: 8d 7d cc lea -0x34(%ebp),%edi
106f12: b9 05 00 00 00 mov $0x5,%ecx
106f17: 8b 75 0c mov 0xc(%ebp),%esi
106f1a: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_link.node_access = node->info.hard_link.link_node;
106f1c: 89 45 cc mov %eax,-0x34(%ebp)
IMFS_Set_handlers( &the_link );
106f1f: 83 ec 0c sub $0xc,%esp
106f22: 8d 75 cc lea -0x34(%ebp),%esi
106f25: 56 push %esi
106f26: e8 ad 67 00 00 call 10d6d8 <IMFS_Set_handlers>
/*
* If removing the last hard link to a node, then we need
* to remove the node that is a link and the node itself.
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
106f2b: 8b 43 50 mov 0x50(%ebx),%eax
106f2e: 8b 50 34 mov 0x34(%eax),%edx
106f31: 83 c4 10 add $0x10,%esp
106f34: 66 83 fa 01 cmp $0x1,%dx
106f38: 75 1a jne 106f54 <IMFS_unlink+0x70>
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
106f3a: 51 push %ecx
106f3b: 51 push %ecx
106f3c: 56 push %esi
106f3d: ff 75 08 pushl 0x8(%ebp)
106f40: 8b 45 d4 mov -0x2c(%ebp),%eax
106f43: ff 50 34 call *0x34(%eax)
106f46: 89 c2 mov %eax,%edx
if ( result != 0 )
106f48: 83 c4 10 add $0x10,%esp
return -1;
106f4b: 83 c8 ff or $0xffffffff,%eax
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
if ( result != 0 )
106f4e: 85 d2 test %edx,%edx
106f50: 74 20 je 106f72 <IMFS_unlink+0x8e>
106f52: eb 30 jmp 106f84 <IMFS_unlink+0xa0>
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
106f54: 4a dec %edx
106f55: 66 89 50 34 mov %dx,0x34(%eax)
IMFS_update_ctime( node->info.hard_link.link_node );
106f59: 52 push %edx
106f5a: 52 push %edx
106f5b: 6a 00 push $0x0
106f5d: 8d 45 e0 lea -0x20(%ebp),%eax
106f60: 50 push %eax
106f61: e8 5a 04 00 00 call 1073c0 <gettimeofday>
106f66: 8b 43 50 mov 0x50(%ebx),%eax
106f69: 8b 55 e0 mov -0x20(%ebp),%edx
106f6c: 89 50 48 mov %edx,0x48(%eax)
106f6f: 83 c4 10 add $0x10,%esp
/*
* Now actually free the node we were asked to free.
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
106f72: 50 push %eax
106f73: 50 push %eax
106f74: 8b 55 0c mov 0xc(%ebp),%edx
106f77: 8b 42 08 mov 0x8(%edx),%eax
106f7a: 52 push %edx
106f7b: ff 75 08 pushl 0x8(%ebp)
106f7e: ff 50 34 call *0x34(%eax)
return result;
106f81: 83 c4 10 add $0x10,%esp
}
106f84: 8d 65 f4 lea -0xc(%ebp),%esp
106f87: 5b pop %ebx
106f88: 5e pop %esi
106f89: 5f pop %edi
106f8a: c9 leave
106f8b: c3 ret
00106f8c <IMFS_unmount>:
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
106f8c: 55 push %ebp
106f8d: 89 e5 mov %esp,%ebp
106f8f: 83 ec 08 sub $0x8,%esp
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
106f92: 8b 45 08 mov 0x8(%ebp),%eax
106f95: 8b 40 08 mov 0x8(%eax),%eax
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
106f98: 83 78 4c 01 cmpl $0x1,0x4c(%eax)
106f9c: 74 0d je 106fab <IMFS_unmount+0x1f> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
106f9e: e8 29 a1 00 00 call 1110cc <__errno> <== NOT EXECUTED
106fa3: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
106fa9: eb 11 jmp 106fbc <IMFS_unmount+0x30> <== NOT EXECUTED
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
106fab: 83 78 5c 00 cmpl $0x0,0x5c(%eax)
106faf: 75 10 jne 106fc1 <IMFS_unmount+0x35> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */
106fb1: e8 16 a1 00 00 call 1110cc <__errno> <== NOT EXECUTED
106fb6: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
106fbc: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
106fbf: eb 09 jmp 106fca <IMFS_unmount+0x3e> <== NOT EXECUTED
/*
* Set the mt_fs pointer to indicate that there is no longer
* a file system mounted to this point.
*/
node->info.directory.mt_fs = NULL;
106fc1: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
return 0;
106fc8: 31 c0 xor %eax,%eax
}
106fca: c9 leave
106fcb: c3 ret
00107108 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
107108: 55 push %ebp <== NOT EXECUTED
107109: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10710b: 57 push %edi <== NOT EXECUTED
10710c: 56 push %esi <== NOT EXECUTED
10710d: 53 push %ebx <== NOT EXECUTED
10710e: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED
107111: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
107114: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED
107117: 75 1d jne 107136 <Stack_check_Dump_threads_usage+0x2e><== NOT EXECUTED
if (!Stack_check_Interrupt_stack.area)
107119: 83 3d 3c 72 12 00 00 cmpl $0x0,0x12723c <== NOT EXECUTED
107120: 0f 84 f5 00 00 00 je 10721b <Stack_check_Dump_threads_usage+0x113><== NOT EXECUTED
return;
stack = &Stack_check_Interrupt_stack;
107126: ba 38 72 12 00 mov $0x127238,%edx <== NOT EXECUTED
the_thread = 0;
current = 0;
10712b: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
if (!Stack_check_Interrupt_stack.area)
return;
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
107132: 31 db xor %ebx,%ebx <== NOT EXECUTED
107134: eb 0f jmp 107145 <Stack_check_Dump_threads_usage+0x3d><== NOT EXECUTED
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
107136: 8d 93 b8 00 00 00 lea 0xb8(%ebx),%edx <== NOT EXECUTED
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
10713c: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED
107142: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED
}
low = Stack_check_usable_stack_start(stack);
107145: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED
107148: 8d 48 10 lea 0x10(%eax),%ecx <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
10714b: 8b 32 mov (%edx),%esi <== NOT EXECUTED
10714d: 83 ee 10 sub $0x10,%esi <== NOT EXECUTED
107150: 89 75 d4 mov %esi,-0x2c(%ebp) <== NOT EXECUTED
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
107153: 83 c0 20 add $0x20,%eax <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
107156: 83 e6 fc and $0xfffffffc,%esi <== NOT EXECUTED
107159: 8d 34 30 lea (%eax,%esi,1),%esi <== NOT EXECUTED
10715c: eb 0b jmp 107169 <Stack_check_Dump_threads_usage+0x61><== NOT EXECUTED
if (*base != U32_PATTERN)
10715e: 81 38 a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%eax) <== NOT EXECUTED
107164: 75 0b jne 107171 <Stack_check_Dump_threads_usage+0x69><== 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++)
107166: 83 c0 04 add $0x4,%eax <== NOT EXECUTED
107169: 39 f0 cmp %esi,%eax <== NOT EXECUTED
10716b: 72 f1 jb 10715e <Stack_check_Dump_threads_usage+0x56><== NOT EXECUTED
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
used = Stack_check_Calculate_used( low, size, high_water_mark );
else
used = 0;
10716d: 31 ff xor %edi,%edi <== NOT EXECUTED
10716f: eb 0e jmp 10717f <Stack_check_Dump_threads_usage+0x77><== NOT EXECUTED
107171: 31 ff xor %edi,%edi <== NOT EXECUTED
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
107173: 85 c0 test %eax,%eax <== NOT EXECUTED
107175: 74 08 je 10717f <Stack_check_Dump_threads_usage+0x77><== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
107177: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED
10717a: 8d 3c 39 lea (%ecx,%edi,1),%edi <== NOT EXECUTED
10717d: 29 c7 sub %eax,%edi <== NOT EXECUTED
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
10717f: 85 db test %ebx,%ebx <== NOT EXECUTED
107181: 8b 35 14 6f 12 00 mov 0x126f14,%esi <== NOT EXECUTED
107187: 74 28 je 1071b1 <Stack_check_Dump_threads_usage+0xa9><== NOT EXECUTED
#endif
{
(*print_handler)(
107189: 50 push %eax <== NOT EXECUTED
10718a: 8d 45 e3 lea -0x1d(%ebp),%eax <== NOT EXECUTED
10718d: 50 push %eax <== NOT EXECUTED
10718e: 6a 05 push $0x5 <== NOT EXECUTED
107190: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
107193: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED
107196: e8 b1 53 00 00 call 10c54c <rtems_object_get_name> <== NOT EXECUTED
10719b: 50 push %eax <== NOT EXECUTED
10719c: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
10719f: 68 ab 15 12 00 push $0x1215ab <== NOT EXECUTED
1071a4: ff 35 10 6f 12 00 pushl 0x126f10 <== NOT EXECUTED
1071aa: ff d6 call *%esi <== NOT EXECUTED
1071ac: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
1071af: eb 16 jmp 1071c7 <Stack_check_Dump_threads_usage+0xbf><== NOT EXECUTED
rtems_object_get_name( the_thread->Object.id, sizeof(name), name )
);
}
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
1071b1: 53 push %ebx <== NOT EXECUTED
1071b2: 6a ff push $0xffffffff <== NOT EXECUTED
1071b4: 68 b8 15 12 00 push $0x1215b8 <== NOT EXECUTED
1071b9: ff 35 10 6f 12 00 pushl 0x126f10 <== NOT EXECUTED
1071bf: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED
1071c2: ff d6 call *%esi <== NOT EXECUTED
1071c4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1071c7: 8b 55 cc mov -0x34(%ebp),%edx <== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
1071ca: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
1071cd: 51 push %ecx <== NOT EXECUTED
1071ce: 51 push %ecx <== NOT EXECUTED
1071cf: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED
1071d2: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
1071d5: 8b 12 mov (%edx),%edx <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
1071d7: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED
1071db: 52 push %edx <== NOT EXECUTED
1071dc: 50 push %eax <== NOT EXECUTED
1071dd: 68 c6 15 12 00 push $0x1215c6 <== NOT EXECUTED
1071e2: ff 35 10 6f 12 00 pushl 0x126f10 <== NOT EXECUTED
1071e8: ff 15 14 6f 12 00 call *0x126f14 <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
1071ee: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
1071f1: 83 3d 18 6f 12 00 00 cmpl $0x0,0x126f18 <== NOT EXECUTED
1071f8: 8b 35 14 6f 12 00 mov 0x126f14,%esi <== NOT EXECUTED
1071fe: 75 09 jne 107209 <Stack_check_Dump_threads_usage+0x101><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
107200: 52 push %edx <== NOT EXECUTED
107201: 52 push %edx <== NOT EXECUTED
107202: 68 e4 15 12 00 push $0x1215e4 <== NOT EXECUTED
107207: eb 07 jmp 107210 <Stack_check_Dump_threads_usage+0x108><== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
107209: 50 push %eax <== NOT EXECUTED
10720a: 57 push %edi <== NOT EXECUTED
10720b: 68 f1 15 12 00 push $0x1215f1 <== NOT EXECUTED
107210: ff 35 10 6f 12 00 pushl 0x126f10 <== NOT EXECUTED
107216: ff d6 call *%esi <== NOT EXECUTED
107218: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
10721b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10721e: 5b pop %ebx <== NOT EXECUTED
10721f: 5e pop %esi <== NOT EXECUTED
107220: 5f pop %edi <== NOT EXECUTED
107221: c9 leave <== NOT EXECUTED
107222: c3 ret <== NOT EXECUTED
00107223 <Stack_check_Initialize>:
/*
* Stack_check_Initialize
*/
void Stack_check_Initialize( void )
{
107223: 55 push %ebp
107224: 89 e5 mov %esp,%ebp
107226: 57 push %edi
static uint32_t pattern[ 4 ] = {
0xFEEDF00D, 0x0BAD0D06, /* FEED FOOD to BAD DOG */
0xDEADF00D, 0x600D0D06 /* DEAD FOOD but GOOD DOG */
};
if ( Stack_check_Initialized )
107227: 83 3d 18 6f 12 00 00 cmpl $0x0,0x126f18
10722e: 75 5a jne 10728a <Stack_check_Initialize+0x67>
/*
* Dope the pattern and fill areas
*/
p = Stack_check_Pattern.pattern;
for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {
p[i] = pattern[ i%4 ];
107230: c7 05 28 72 12 00 0d movl $0xfeedf00d,0x127228
107237: f0 ed fe
10723a: c7 05 2c 72 12 00 06 movl $0xbad0d06,0x12722c
107241: 0d ad 0b
107244: c7 05 30 72 12 00 0d movl $0xdeadf00d,0x127230
10724b: f0 ad de
10724e: c7 05 34 72 12 00 06 movl $0x600d0d06,0x127234
107255: 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) {
107258: 8b 15 10 79 12 00 mov 0x127910,%edx
10725e: 85 d2 test %edx,%edx
107260: 74 1e je 107280 <Stack_check_Initialize+0x5d><== NEVER TAKEN
107262: 8b 0d 14 79 12 00 mov 0x127914,%ecx
107268: 85 c9 test %ecx,%ecx
10726a: 74 14 je 107280 <Stack_check_Initialize+0x5d><== NEVER TAKEN
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
10726c: 89 15 3c 72 12 00 mov %edx,0x12723c
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
107272: 29 d1 sub %edx,%ecx
107274: 89 0d 38 72 12 00 mov %ecx,0x127238
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
10727a: b0 a5 mov $0xa5,%al
10727c: 89 d7 mov %edx,%edi
10727e: f3 aa rep stos %al,%es:(%edi)
}
#endif
Stack_check_Initialized = 1;
107280: c7 05 18 6f 12 00 01 movl $0x1,0x126f18
107287: 00 00 00
}
10728a: 5f pop %edi
10728b: c9 leave
10728c: c3 ret
001072db <Stack_check_report_blown_task>:
Thread_Control *running,
bool pattern_ok
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
1072db: 55 push %ebp <== NOT EXECUTED
1072dc: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1072de: 56 push %esi <== NOT EXECUTED
1072df: 53 push %ebx <== NOT EXECUTED
1072e0: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED
1072e3: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
1072e6: 8a 55 0c mov 0xc(%ebp),%dl <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
1072e9: 8b b3 bc 00 00 00 mov 0xbc(%ebx),%esi <== NOT EXECUTED
char name[32];
printk("BLOWN STACK!!!\n");
1072ef: 68 f7 15 12 00 push $0x1215f7 <== NOT EXECUTED
1072f4: 88 55 d4 mov %dl,-0x2c(%ebp) <== NOT EXECUTED
1072f7: e8 08 19 00 00 call 108c04 <printk> <== NOT EXECUTED
printk("task control block: 0x%08" PRIxPTR "\n", running);
1072fc: 5a pop %edx <== NOT EXECUTED
1072fd: 59 pop %ecx <== NOT EXECUTED
1072fe: 53 push %ebx <== NOT EXECUTED
1072ff: 68 07 16 12 00 push $0x121607 <== NOT EXECUTED
107304: e8 fb 18 00 00 call 108c04 <printk> <== NOT EXECUTED
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
107309: 59 pop %ecx <== NOT EXECUTED
10730a: 58 pop %eax <== NOT EXECUTED
10730b: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
10730e: 68 24 16 12 00 push $0x121624 <== NOT EXECUTED
107313: e8 ec 18 00 00 call 108c04 <printk> <== NOT EXECUTED
printk(
107318: 58 pop %eax <== NOT EXECUTED
107319: 5a pop %edx <== NOT EXECUTED
10731a: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED
10731d: 68 36 16 12 00 push $0x121636 <== NOT EXECUTED
107322: e8 dd 18 00 00 call 108c04 <printk> <== NOT EXECUTED
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
107327: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
10732a: 8d 45 d8 lea -0x28(%ebp),%eax <== NOT EXECUTED
10732d: 50 push %eax <== NOT EXECUTED
10732e: 6a 20 push $0x20 <== NOT EXECUTED
107330: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED
107333: e8 14 52 00 00 call 10c54c <rtems_object_get_name> <== NOT EXECUTED
107338: 5a pop %edx <== NOT EXECUTED
107339: 59 pop %ecx <== NOT EXECUTED
10733a: 50 push %eax <== NOT EXECUTED
10733b: 68 4a 16 12 00 push $0x12164a <== NOT EXECUTED
107340: e8 bf 18 00 00 call 108c04 <printk> <== NOT EXECUTED
);
printk(
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
107345: 8b 8b bc 00 00 00 mov 0xbc(%ebx),%ecx <== NOT EXECUTED
10734b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
);
printk(
"task name string: %s\n",
rtems_object_get_name(running->Object.id, sizeof(name), name)
);
printk(
107351: 8d 1c 01 lea (%ecx,%eax,1),%ebx <== NOT EXECUTED
107354: 53 push %ebx <== NOT EXECUTED
107355: 51 push %ecx <== NOT EXECUTED
107356: 50 push %eax <== NOT EXECUTED
107357: 68 60 16 12 00 push $0x121660 <== NOT EXECUTED
10735c: e8 a3 18 00 00 call 108c04 <printk> <== NOT EXECUTED
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
107361: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
107364: 8a 55 d4 mov -0x2c(%ebp),%dl <== NOT EXECUTED
107367: 84 d2 test %dl,%dl <== NOT EXECUTED
107369: 75 17 jne 107382 <Stack_check_report_blown_task+0xa7><== NOT EXECUTED
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
10736b: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
printk(
10736e: 83 c6 18 add $0x18,%esi <== NOT EXECUTED
107371: 56 push %esi <== NOT EXECUTED
107372: 50 push %eax <== NOT EXECUTED
107373: 6a 10 push $0x10 <== NOT EXECUTED
107375: 68 91 16 12 00 push $0x121691 <== NOT EXECUTED
10737a: e8 85 18 00 00 call 108c04 <printk> <== NOT EXECUTED
10737f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
107382: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107385: 68 81 00 00 00 push $0x81 <== NOT EXECUTED
10738a: e8 05 59 00 00 call 10cc94 <rtems_fatal_error_occurred><== NOT EXECUTED
0010ce0c <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
10ce0c: 55 push %ebp
10ce0d: 89 e5 mov %esp,%ebp
10ce0f: 53 push %ebx
10ce10: 83 ec 04 sub $0x4,%esp
10ce13: 8b 5d 08 mov 0x8(%ebp),%ebx
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
10ce16: 8b 15 78 88 12 00 mov 0x128878,%edx
* Otherwise, we have to block.
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
10ce1c: 9c pushf
10ce1d: fa cli
10ce1e: 58 pop %eax
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
10ce1f: 8b 4b 44 mov 0x44(%ebx),%ecx
10ce22: 85 c9 test %ecx,%ecx
10ce24: 75 0b jne 10ce31 <_CORE_RWLock_Release+0x25>
_ISR_Enable( level );
10ce26: 50 push %eax
10ce27: 9d popf
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
10ce28: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx)
return CORE_RWLOCK_SUCCESSFUL;
10ce2f: eb 72 jmp 10cea3 <_CORE_RWLock_Release+0x97>
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
10ce31: 49 dec %ecx
10ce32: 75 0f jne 10ce43 <_CORE_RWLock_Release+0x37>
the_rwlock->number_of_readers -= 1;
10ce34: 8b 4b 48 mov 0x48(%ebx),%ecx
10ce37: 49 dec %ecx
10ce38: 89 4b 48 mov %ecx,0x48(%ebx)
if ( the_rwlock->number_of_readers != 0 ) {
10ce3b: 85 c9 test %ecx,%ecx
10ce3d: 74 04 je 10ce43 <_CORE_RWLock_Release+0x37>
/* must be unlocked again */
_ISR_Enable( level );
10ce3f: 50 push %eax
10ce40: 9d popf
return CORE_RWLOCK_SUCCESSFUL;
10ce41: eb 60 jmp 10cea3 <_CORE_RWLock_Release+0x97>
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
10ce43: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx)
/*
* Implicitly transition to "unlocked" and find another thread interested
* in obtaining this rwlock.
*/
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
10ce4a: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
_ISR_Enable( level );
10ce51: 50 push %eax
10ce52: 9d popf
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
10ce53: 83 ec 0c sub $0xc,%esp
10ce56: 53 push %ebx
10ce57: e8 e0 17 00 00 call 10e63c <_Thread_queue_Dequeue>
if ( next ) {
10ce5c: 83 c4 10 add $0x10,%esp
10ce5f: 85 c0 test %eax,%eax
10ce61: 74 40 je 10cea3 <_CORE_RWLock_Release+0x97>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
10ce63: 83 78 30 01 cmpl $0x1,0x30(%eax)
10ce67: 75 09 jne 10ce72 <_CORE_RWLock_Release+0x66>
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
10ce69: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx)
return CORE_RWLOCK_SUCCESSFUL;
10ce70: eb 31 jmp 10cea3 <_CORE_RWLock_Release+0x97>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
10ce72: ff 43 48 incl 0x48(%ebx)
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
10ce75: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx)
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
10ce7c: 83 ec 0c sub $0xc,%esp
10ce7f: 53 push %ebx
10ce80: e8 af 1b 00 00 call 10ea34 <_Thread_queue_First>
if ( !next ||
10ce85: 83 c4 10 add $0x10,%esp
10ce88: 85 c0 test %eax,%eax
10ce8a: 74 17 je 10cea3 <_CORE_RWLock_Release+0x97>
10ce8c: 83 78 30 01 cmpl $0x1,0x30(%eax)
10ce90: 74 11 je 10cea3 <_CORE_RWLock_Release+0x97><== NEVER TAKEN
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
10ce92: ff 43 48 incl 0x48(%ebx)
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
10ce95: 52 push %edx
10ce96: 52 push %edx
10ce97: 50 push %eax
10ce98: 53 push %ebx
10ce99: e8 86 1a 00 00 call 10e924 <_Thread_queue_Extract>
}
10ce9e: 83 c4 10 add $0x10,%esp
10cea1: eb d9 jmp 10ce7c <_CORE_RWLock_Release+0x70>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
10cea3: 31 c0 xor %eax,%eax
10cea5: 8b 5d fc mov -0x4(%ebp),%ebx
10cea8: c9 leave
10cea9: c3 ret
0010ceac <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
10ceac: 55 push %ebp
10cead: 89 e5 mov %esp,%ebp
10ceaf: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10ceb2: 8d 45 f4 lea -0xc(%ebp),%eax
10ceb5: 50 push %eax
10ceb6: ff 75 08 pushl 0x8(%ebp)
10ceb9: e8 66 14 00 00 call 10e324 <_Thread_Get>
switch ( location ) {
10cebe: 83 c4 10 add $0x10,%esp
10cec1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10cec5: 75 17 jne 10cede <_CORE_RWLock_Timeout+0x32><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
10cec7: 83 ec 0c sub $0xc,%esp
10ceca: 50 push %eax
10cecb: e8 30 1c 00 00 call 10eb00 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10ced0: a1 50 83 12 00 mov 0x128350,%eax
10ced5: 48 dec %eax
10ced6: a3 50 83 12 00 mov %eax,0x128350
10cedb: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10cede: c9 leave
10cedf: c3 ret
0011736c <_CORE_message_queue_Broadcast>:
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
11736c: 55 push %ebp
11736d: 89 e5 mov %esp,%ebp
11736f: 57 push %edi
117370: 56 push %esi
117371: 53 push %ebx
117372: 83 ec 1c sub $0x1c,%esp
117375: 8b 5d 08 mov 0x8(%ebp),%ebx
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
117378: b8 01 00 00 00 mov $0x1,%eax
{
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
11737d: 8b 55 10 mov 0x10(%ebp),%edx
117380: 3b 53 4c cmp 0x4c(%ebx),%edx
117383: 77 4e ja 1173d3 <_CORE_message_queue_Broadcast+0x67><== NEVER TAKEN
* NOTE: This check is critical because threads can block on
* send and receive and this ensures that we are broadcasting
* the message to threads waiting to receive -- not to send.
*/
if ( the_message_queue->number_of_pending_messages != 0 ) {
117385: 83 7b 48 00 cmpl $0x0,0x48(%ebx)
117389: 75 09 jne 117394 <_CORE_message_queue_Broadcast+0x28>
11738b: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
117392: eb 23 jmp 1173b7 <_CORE_message_queue_Broadcast+0x4b>
*count = 0;
117394: 8b 45 1c mov 0x1c(%ebp),%eax
117397: c7 00 00 00 00 00 movl $0x0,(%eax)
11739d: eb 32 jmp 1173d1 <_CORE_message_queue_Broadcast+0x65>
*/
number_broadcasted = 0;
while ((the_thread =
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
11739f: ff 45 e4 incl -0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
1173a2: 8b 42 2c mov 0x2c(%edx),%eax
1173a5: 89 c7 mov %eax,%edi
1173a7: 8b 75 0c mov 0xc(%ebp),%esi
1173aa: 8b 4d 10 mov 0x10(%ebp),%ecx
1173ad: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
1173af: 8b 42 28 mov 0x28(%edx),%eax
1173b2: 8b 55 10 mov 0x10(%ebp),%edx
1173b5: 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 =
1173b7: 83 ec 0c sub $0xc,%esp
1173ba: 53 push %ebx
1173bb: e8 0c 25 00 00 call 1198cc <_Thread_queue_Dequeue>
1173c0: 89 c2 mov %eax,%edx
1173c2: 83 c4 10 add $0x10,%esp
1173c5: 85 c0 test %eax,%eax
1173c7: 75 d6 jne 11739f <_CORE_message_queue_Broadcast+0x33>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
1173c9: 8b 55 e4 mov -0x1c(%ebp),%edx
1173cc: 8b 45 1c mov 0x1c(%ebp),%eax
1173cf: 89 10 mov %edx,(%eax)
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
1173d1: 31 c0 xor %eax,%eax
}
1173d3: 8d 65 f4 lea -0xc(%ebp),%esp
1173d6: 5b pop %ebx
1173d7: 5e pop %esi
1173d8: 5f pop %edi
1173d9: c9 leave
1173da: c3 ret
00112220 <_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
)
{
112220: 55 push %ebp
112221: 89 e5 mov %esp,%ebp
112223: 57 push %edi
112224: 56 push %esi
112225: 53 push %ebx
112226: 83 ec 1c sub $0x1c,%esp
112229: 8b 5d 08 mov 0x8(%ebp),%ebx
11222c: 8b 7d 10 mov 0x10(%ebp),%edi
11222f: 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;
112232: 89 7b 44 mov %edi,0x44(%ebx)
the_message_queue->number_of_pending_messages = 0;
112235: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx)
the_message_queue->maximum_message_size = maximum_message_size;
11223c: 89 53 4c mov %edx,0x4c(%ebx)
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Notify_Handler the_handler,
void *the_argument
)
{
the_message_queue->notify_handler = the_handler;
11223f: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx)
the_message_queue->notify_argument = the_argument;
112246: 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)) {
11224d: 89 d0 mov %edx,%eax
11224f: f6 c2 03 test $0x3,%dl
112252: 74 0c je 112260 <_CORE_message_queue_Initialize+0x40>
allocated_message_size += sizeof(uint32_t);
112254: 83 c0 04 add $0x4,%eax
allocated_message_size &= ~(sizeof(uint32_t) - 1);
112257: 83 e0 fc and $0xfffffffc,%eax
}
if (allocated_message_size < maximum_message_size)
return false;
11225a: 31 f6 xor %esi,%esi
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
allocated_message_size += sizeof(uint32_t);
allocated_message_size &= ~(sizeof(uint32_t) - 1);
}
if (allocated_message_size < maximum_message_size)
11225c: 39 d0 cmp %edx,%eax
11225e: 72 68 jb 1122c8 <_CORE_message_queue_Initialize+0xa8><== 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 *
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
112260: 8d 50 14 lea 0x14(%eax),%edx
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
112263: 89 d1 mov %edx,%ecx
112265: 0f af cf imul %edi,%ecx
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
return false;
112268: 31 f6 xor %esi,%esi
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
11226a: 39 c1 cmp %eax,%ecx
11226c: 72 5a jb 1122c8 <_CORE_message_queue_Initialize+0xa8><== NEVER TAKEN
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
11226e: 83 ec 0c sub $0xc,%esp
112271: 51 push %ecx
112272: 89 55 e4 mov %edx,-0x1c(%ebp)
112275: e8 a4 27 00 00 call 114a1e <_Workspace_Allocate>
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
11227a: 89 43 5c mov %eax,0x5c(%ebx)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
11227d: 83 c4 10 add $0x10,%esp
112280: 85 c0 test %eax,%eax
112282: 8b 55 e4 mov -0x1c(%ebp),%edx
112285: 74 41 je 1122c8 <_CORE_message_queue_Initialize+0xa8>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
112287: 52 push %edx
112288: 57 push %edi
112289: 50 push %eax
11228a: 8d 43 68 lea 0x68(%ebx),%eax
11228d: 50 push %eax
11228e: e8 e9 4a 00 00 call 116d7c <_Chain_Initialize>
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
112293: 8d 43 54 lea 0x54(%ebx),%eax
112296: 89 43 50 mov %eax,0x50(%ebx)
head->next = tail;
head->previous = NULL;
112299: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx)
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
1122a0: 8d 43 50 lea 0x50(%ebx),%eax
1122a3: 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(
1122a6: 6a 06 push $0x6
1122a8: 68 80 00 00 00 push $0x80
1122ad: 8b 45 0c mov 0xc(%ebp),%eax
1122b0: 83 38 01 cmpl $0x1,(%eax)
1122b3: 0f 94 c0 sete %al
1122b6: 0f b6 c0 movzbl %al,%eax
1122b9: 50 push %eax
1122ba: 53 push %ebx
1122bb: e8 84 1f 00 00 call 114244 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
1122c0: 83 c4 20 add $0x20,%esp
1122c3: be 01 00 00 00 mov $0x1,%esi
}
1122c8: 89 f0 mov %esi,%eax
1122ca: 8d 65 f4 lea -0xc(%ebp),%esp
1122cd: 5b pop %ebx
1122ce: 5e pop %esi
1122cf: 5f pop %edi
1122d0: c9 leave
1122d1: c3 ret
001122d4 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
1122d4: 55 push %ebp
1122d5: 89 e5 mov %esp,%ebp
1122d7: 57 push %edi
1122d8: 56 push %esi
1122d9: 53 push %ebx
1122da: 83 ec 2c sub $0x2c,%esp
1122dd: 8b 55 08 mov 0x8(%ebp),%edx
1122e0: 8b 45 0c mov 0xc(%ebp),%eax
1122e3: 89 45 dc mov %eax,-0x24(%ebp)
1122e6: 8b 5d 10 mov 0x10(%ebp),%ebx
1122e9: 89 5d e0 mov %ebx,-0x20(%ebp)
1122ec: 8b 4d 14 mov 0x14(%ebp),%ecx
1122ef: 8b 75 1c mov 0x1c(%ebp),%esi
1122f2: 89 75 d4 mov %esi,-0x2c(%ebp)
1122f5: 8a 45 18 mov 0x18(%ebp),%al
1122f8: 88 45 db mov %al,-0x25(%ebp)
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
executing = _Thread_Executing;
1122fb: a1 f0 d9 12 00 mov 0x12d9f0,%eax
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
112300: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
_ISR_Disable( level );
112307: 9c pushf
112308: fa cli
112309: 8f 45 e4 popl -0x1c(%ebp)
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
11230c: 8b 5a 50 mov 0x50(%edx),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
11230f: 8d 72 54 lea 0x54(%edx),%esi
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
112312: 39 f3 cmp %esi,%ebx
112314: 0f 84 8a 00 00 00 je 1123a4 <_CORE_message_queue_Seize+0xd0>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
11231a: 8b 33 mov (%ebx),%esi
head->next = new_first;
11231c: 89 72 50 mov %esi,0x50(%edx)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
11231f: 8d 7a 50 lea 0x50(%edx),%edi
112322: 89 7e 04 mov %edi,0x4(%esi)
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
_ISR_Disable( level );
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
112325: 85 db test %ebx,%ebx
112327: 74 7b je 1123a4 <_CORE_message_queue_Seize+0xd0><== NEVER TAKEN
the_message_queue->number_of_pending_messages -= 1;
112329: ff 4a 48 decl 0x48(%edx)
_ISR_Enable( level );
11232c: ff 75 e4 pushl -0x1c(%ebp)
11232f: 9d popf
*size_p = the_message->Contents.size;
112330: 8b 43 0c mov 0xc(%ebx),%eax
112333: 89 01 mov %eax,(%ecx)
_Thread_Executing->Wait.count =
112335: 8b 73 08 mov 0x8(%ebx),%esi
112338: a1 f0 d9 12 00 mov 0x12d9f0,%eax
11233d: 89 70 24 mov %esi,0x24(%eax)
_CORE_message_queue_Get_message_priority( the_message );
_CORE_message_queue_Copy_buffer(
the_message->Contents.buffer,
112340: 8d 73 10 lea 0x10(%ebx),%esi
112343: 89 75 e4 mov %esi,-0x1c(%ebp)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
112346: 8b 09 mov (%ecx),%ecx
112348: 8b 7d e0 mov -0x20(%ebp),%edi
11234b: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
* is not, then we can go ahead and free the buffer.
*
* NOTE: If we note that the queue was not full before this receive,
* then we can avoid this dequeue.
*/
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
11234d: 83 ec 0c sub $0xc,%esp
112350: 52 push %edx
112351: 89 55 d0 mov %edx,-0x30(%ebp)
112354: e8 b3 1b 00 00 call 113f0c <_Thread_queue_Dequeue>
if ( !the_thread ) {
112359: 83 c4 10 add $0x10,%esp
11235c: 85 c0 test %eax,%eax
11235e: 8b 55 d0 mov -0x30(%ebp),%edx
112361: 75 15 jne 112378 <_CORE_message_queue_Seize+0xa4>
RTEMS_INLINE_ROUTINE void _CORE_message_queue_Free_message_buffer (
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Buffer_control *the_message
)
{
_Chain_Append( &the_message_queue->Inactive_messages, &the_message->Node );
112363: 89 5d 0c mov %ebx,0xc(%ebp)
112366: 83 c2 68 add $0x68,%edx
112369: 89 55 08 mov %edx,0x8(%ebp)
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
11236c: 8d 65 f4 lea -0xc(%ebp),%esp
11236f: 5b pop %ebx
112370: 5e pop %esi
112371: 5f pop %edi
112372: c9 leave
112373: e9 28 fe ff ff jmp 1121a0 <_Chain_Append>
CORE_message_queue_Buffer_control *the_message,
int priority
)
{
#if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
the_message->priority = priority;
112378: 8b 48 24 mov 0x24(%eax),%ecx
11237b: 89 4b 08 mov %ecx,0x8(%ebx)
*/
_CORE_message_queue_Set_message_priority(
the_message,
the_thread->Wait.count
);
the_message->Contents.size = (size_t) the_thread->Wait.option;
11237e: 8b 48 30 mov 0x30(%eax),%ecx
112381: 89 4b 0c mov %ecx,0xc(%ebx)
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
112384: 8b 70 2c mov 0x2c(%eax),%esi
112387: 8b 7d e4 mov -0x1c(%ebp),%edi
11238a: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
11238c: 8b 43 08 mov 0x8(%ebx),%eax
11238f: 89 45 10 mov %eax,0x10(%ebp)
112392: 89 5d 0c mov %ebx,0xc(%ebp)
112395: 89 55 08 mov %edx,0x8(%ebp)
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
112398: 8d 65 f4 lea -0xc(%ebp),%esp
11239b: 5b pop %ebx
11239c: 5e pop %esi
11239d: 5f pop %edi
11239e: c9 leave
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
11239f: e9 10 4a 00 00 jmp 116db4 <_CORE_message_queue_Insert_message>
return;
}
#endif
}
if ( !wait ) {
1123a4: 80 7d db 00 cmpb $0x0,-0x25(%ebp)
1123a8: 75 13 jne 1123bd <_CORE_message_queue_Seize+0xe9>
_ISR_Enable( level );
1123aa: ff 75 e4 pushl -0x1c(%ebp)
1123ad: 9d popf
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
1123ae: c7 40 34 04 00 00 00 movl $0x4,0x34(%eax)
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 );
}
1123b5: 8d 65 f4 lea -0xc(%ebp),%esp
1123b8: 5b pop %ebx
1123b9: 5e pop %esi
1123ba: 5f pop %edi
1123bb: c9 leave
1123bc: c3 ret
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
1123bd: 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;
1123c4: 89 50 44 mov %edx,0x44(%eax)
executing->Wait.id = id;
1123c7: 8b 5d dc mov -0x24(%ebp),%ebx
1123ca: 89 58 20 mov %ebx,0x20(%eax)
executing->Wait.return_argument_second.mutable_object = buffer;
1123cd: 8b 75 e0 mov -0x20(%ebp),%esi
1123d0: 89 70 2c mov %esi,0x2c(%eax)
executing->Wait.return_argument = size_p;
1123d3: 89 48 28 mov %ecx,0x28(%eax)
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
1123d6: ff 75 e4 pushl -0x1c(%ebp)
1123d9: 9d popf
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
1123da: c7 45 10 f4 42 11 00 movl $0x1142f4,0x10(%ebp)
1123e1: 8b 45 d4 mov -0x2c(%ebp),%eax
1123e4: 89 45 0c mov %eax,0xc(%ebp)
1123e7: 89 55 08 mov %edx,0x8(%ebp)
}
1123ea: 8d 65 f4 lea -0xc(%ebp),%esp
1123ed: 5b pop %ebx
1123ee: 5e pop %esi
1123ef: 5f pop %edi
1123f0: 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 );
1123f1: e9 22 1c 00 00 jmp 114018 <_Thread_queue_Enqueue_with_handler>
0010ac2d <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
10ac2d: 55 push %ebp
10ac2e: 89 e5 mov %esp,%ebp
10ac30: 53 push %ebx
10ac31: 83 ec 14 sub $0x14,%esp
10ac34: 8b 5d 08 mov 0x8(%ebp),%ebx
10ac37: 8a 55 10 mov 0x10(%ebp),%dl
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
10ac3a: a1 40 53 12 00 mov 0x125340,%eax
10ac3f: 85 c0 test %eax,%eax
10ac41: 74 19 je 10ac5c <_CORE_mutex_Seize+0x2f>
10ac43: 84 d2 test %dl,%dl
10ac45: 74 15 je 10ac5c <_CORE_mutex_Seize+0x2f><== NEVER TAKEN
10ac47: 83 3d 9c 54 12 00 01 cmpl $0x1,0x12549c
10ac4e: 76 0c jbe 10ac5c <_CORE_mutex_Seize+0x2f>
10ac50: 53 push %ebx
10ac51: 6a 12 push $0x12
10ac53: 6a 00 push $0x0
10ac55: 6a 00 push $0x0
10ac57: e8 dc 05 00 00 call 10b238 <_Internal_error_Occurred>
10ac5c: 51 push %ecx
10ac5d: 51 push %ecx
10ac5e: 8d 45 18 lea 0x18(%ebp),%eax
10ac61: 50 push %eax
10ac62: 53 push %ebx
10ac63: 88 55 f4 mov %dl,-0xc(%ebp)
10ac66: e8 c9 47 00 00 call 10f434 <_CORE_mutex_Seize_interrupt_trylock>
10ac6b: 83 c4 10 add $0x10,%esp
10ac6e: 85 c0 test %eax,%eax
10ac70: 8a 55 f4 mov -0xc(%ebp),%dl
10ac73: 74 48 je 10acbd <_CORE_mutex_Seize+0x90>
10ac75: 84 d2 test %dl,%dl
10ac77: 75 12 jne 10ac8b <_CORE_mutex_Seize+0x5e>
10ac79: ff 75 18 pushl 0x18(%ebp)
10ac7c: 9d popf
10ac7d: a1 68 58 12 00 mov 0x125868,%eax
10ac82: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax)
10ac89: eb 32 jmp 10acbd <_CORE_mutex_Seize+0x90>
10ac8b: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx)
10ac92: a1 68 58 12 00 mov 0x125868,%eax
10ac97: 89 58 44 mov %ebx,0x44(%eax)
10ac9a: 8b 55 0c mov 0xc(%ebp),%edx
10ac9d: 89 50 20 mov %edx,0x20(%eax)
10aca0: a1 40 53 12 00 mov 0x125340,%eax
10aca5: 40 inc %eax
10aca6: a3 40 53 12 00 mov %eax,0x125340
10acab: ff 75 18 pushl 0x18(%ebp)
10acae: 9d popf
10acaf: 50 push %eax
10acb0: 50 push %eax
10acb1: ff 75 14 pushl 0x14(%ebp)
10acb4: 53 push %ebx
10acb5: e8 26 ff ff ff call 10abe0 <_CORE_mutex_Seize_interrupt_blocking>
10acba: 83 c4 10 add $0x10,%esp
}
10acbd: 8b 5d fc mov -0x4(%ebp),%ebx
10acc0: c9 leave
10acc1: c3 ret
0010ade8 <_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
)
{
10ade8: 55 push %ebp
10ade9: 89 e5 mov %esp,%ebp
10adeb: 53 push %ebx
10adec: 83 ec 10 sub $0x10,%esp
10adef: 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)) ) {
10adf2: 53 push %ebx
10adf3: e8 dc 16 00 00 call 10c4d4 <_Thread_queue_Dequeue>
10adf8: 89 c2 mov %eax,%edx
10adfa: 83 c4 10 add $0x10,%esp
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10adfd: 31 c0 xor %eax,%eax
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
10adff: 85 d2 test %edx,%edx
10ae01: 75 15 jne 10ae18 <_CORE_semaphore_Surrender+0x30>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
10ae03: 9c pushf
10ae04: fa cli
10ae05: 59 pop %ecx
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
10ae06: 8b 53 48 mov 0x48(%ebx),%edx
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
10ae09: b0 04 mov $0x4,%al
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
10ae0b: 3b 53 40 cmp 0x40(%ebx),%edx
10ae0e: 73 06 jae 10ae16 <_CORE_semaphore_Surrender+0x2e><== NEVER TAKEN
the_semaphore->count += 1;
10ae10: 42 inc %edx
10ae11: 89 53 48 mov %edx,0x48(%ebx)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
10ae14: 30 c0 xor %al,%al
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
10ae16: 51 push %ecx
10ae17: 9d popf
}
return status;
}
10ae18: 8b 5d fc mov -0x4(%ebp),%ebx
10ae1b: c9 leave
10ae1c: c3 ret
00109d4c <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
109d4c: 55 push %ebp
109d4d: 89 e5 mov %esp,%ebp
109d4f: 57 push %edi
109d50: 56 push %esi
109d51: 53 push %ebx
109d52: 83 ec 2c sub $0x2c,%esp
109d55: 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 ];
109d58: 8b bb e8 00 00 00 mov 0xe8(%ebx),%edi
option_set = (rtems_option) the_thread->Wait.option;
109d5e: 8b 43 30 mov 0x30(%ebx),%eax
109d61: 89 45 e0 mov %eax,-0x20(%ebp)
_ISR_Disable( level );
109d64: 9c pushf
109d65: fa cli
109d66: 58 pop %eax
pending_events = api->pending_events;
109d67: 8b 17 mov (%edi),%edx
109d69: 89 55 d4 mov %edx,-0x2c(%ebp)
event_condition = (rtems_event_set) the_thread->Wait.count;
109d6c: 8b 73 24 mov 0x24(%ebx),%esi
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
109d6f: 21 f2 and %esi,%edx
109d71: 75 07 jne 109d7a <_Event_Surrender+0x2e>
_ISR_Enable( level );
109d73: 50 push %eax
109d74: 9d popf
return;
109d75: e9 af 00 00 00 jmp 109e29 <_Event_Surrender+0xdd>
/*
* 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() &&
109d7a: 83 3d 64 58 12 00 00 cmpl $0x0,0x125864
109d81: 74 49 je 109dcc <_Event_Surrender+0x80>
109d83: 3b 1d 68 58 12 00 cmp 0x125868,%ebx
109d89: 75 41 jne 109dcc <_Event_Surrender+0x80>
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
109d8b: 8b 0d 3c 5c 12 00 mov 0x125c3c,%ecx
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
109d91: 83 f9 02 cmp $0x2,%ecx
109d94: 74 09 je 109d9f <_Event_Surrender+0x53> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
109d96: 8b 0d 3c 5c 12 00 mov 0x125c3c,%ecx
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
109d9c: 49 dec %ecx
109d9d: 75 2d jne 109dcc <_Event_Surrender+0x80>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
109d9f: 39 f2 cmp %esi,%edx
109da1: 74 06 je 109da9 <_Event_Surrender+0x5d>
109da3: f6 45 e0 02 testb $0x2,-0x20(%ebp)
109da7: 74 1f je 109dc8 <_Event_Surrender+0x7c> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
109da9: 89 d6 mov %edx,%esi
109dab: f7 d6 not %esi
109dad: 23 75 d4 and -0x2c(%ebp),%esi
109db0: 89 37 mov %esi,(%edi)
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
109db2: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
109db9: 8b 4b 28 mov 0x28(%ebx),%ecx
109dbc: 89 11 mov %edx,(%ecx)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
109dbe: c7 05 3c 5c 12 00 03 movl $0x3,0x125c3c
109dc5: 00 00 00
}
_ISR_Enable( level );
109dc8: 50 push %eax
109dc9: 9d popf
return;
109dca: eb 5d jmp 109e29 <_Event_Surrender+0xdd>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
109dcc: f6 43 11 01 testb $0x1,0x11(%ebx)
109dd0: 74 55 je 109e27 <_Event_Surrender+0xdb>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
109dd2: 39 f2 cmp %esi,%edx
109dd4: 74 06 je 109ddc <_Event_Surrender+0x90>
109dd6: f6 45 e0 02 testb $0x2,-0x20(%ebp)
109dda: 74 4b je 109e27 <_Event_Surrender+0xdb> <== NEVER TAKEN
109ddc: 89 d6 mov %edx,%esi
109dde: f7 d6 not %esi
109de0: 23 75 d4 and -0x2c(%ebp),%esi
109de3: 89 37 mov %esi,(%edi)
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
109de5: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
109dec: 8b 4b 28 mov 0x28(%ebx),%ecx
109def: 89 11 mov %edx,(%ecx)
_ISR_Flash( level );
109df1: 50 push %eax
109df2: 9d popf
109df3: fa cli
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
109df4: 83 7b 50 02 cmpl $0x2,0x50(%ebx)
109df8: 74 06 je 109e00 <_Event_Surrender+0xb4>
_ISR_Enable( level );
109dfa: 50 push %eax
109dfb: 9d popf
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
109dfc: 51 push %ecx
109dfd: 51 push %ecx
109dfe: eb 17 jmp 109e17 <_Event_Surrender+0xcb>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
109e00: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx)
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
109e07: 50 push %eax
109e08: 9d popf
(void) _Watchdog_Remove( &the_thread->Timer );
109e09: 83 ec 0c sub $0xc,%esp
109e0c: 8d 43 48 lea 0x48(%ebx),%eax
109e0f: 50 push %eax
109e10: e8 b7 30 00 00 call 10cecc <_Watchdog_Remove>
109e15: 58 pop %eax
109e16: 5a pop %edx
109e17: 68 f8 ff 03 10 push $0x1003fff8
109e1c: 53 push %ebx
109e1d: e8 62 20 00 00 call 10be84 <_Thread_Clear_state>
109e22: 83 c4 10 add $0x10,%esp
109e25: eb 02 jmp 109e29 <_Event_Surrender+0xdd>
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
109e27: 50 push %eax
109e28: 9d popf
}
109e29: 8d 65 f4 lea -0xc(%ebp),%esp
109e2c: 5b pop %ebx
109e2d: 5e pop %esi
109e2e: 5f pop %edi
109e2f: c9 leave
109e30: c3 ret
00109e34 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
109e34: 55 push %ebp
109e35: 89 e5 mov %esp,%ebp
109e37: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
109e3a: 8d 45 f4 lea -0xc(%ebp),%eax
109e3d: 50 push %eax
109e3e: ff 75 08 pushl 0x8(%ebp)
109e41: e8 76 23 00 00 call 10c1bc <_Thread_Get>
switch ( location ) {
109e46: 83 c4 10 add $0x10,%esp
109e49: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
109e4d: 75 49 jne 109e98 <_Event_Timeout+0x64> <== NEVER TAKEN
*
* If it is not satisfied, then it is "nothing happened" and
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
_ISR_Disable( level );
109e4f: 9c pushf
109e50: fa cli
109e51: 5a pop %edx
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
109e52: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax)
if ( _Thread_Is_executing( the_thread ) ) {
109e59: 3b 05 68 58 12 00 cmp 0x125868,%eax
109e5f: 75 13 jne 109e74 <_Event_Timeout+0x40>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
109e61: 8b 0d 3c 5c 12 00 mov 0x125c3c,%ecx
109e67: 49 dec %ecx
109e68: 75 0a jne 109e74 <_Event_Timeout+0x40>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
109e6a: c7 05 3c 5c 12 00 02 movl $0x2,0x125c3c
109e71: 00 00 00
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
109e74: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax)
_ISR_Enable( level );
109e7b: 52 push %edx
109e7c: 9d popf
109e7d: 52 push %edx
109e7e: 52 push %edx
109e7f: 68 f8 ff 03 10 push $0x1003fff8
109e84: 50 push %eax
109e85: e8 fa 1f 00 00 call 10be84 <_Thread_Clear_state>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
109e8a: a1 40 53 12 00 mov 0x125340,%eax
109e8f: 48 dec %eax
109e90: a3 40 53 12 00 mov %eax,0x125340
_Thread_Unblock( the_thread );
_Thread_Unnest_dispatch();
break;
109e95: 83 c4 10 add $0x10,%esp
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
109e98: c9 leave
109e99: c3 ret
0010fa7b <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
10fa7b: 55 push %ebp
10fa7c: 89 e5 mov %esp,%ebp
10fa7e: 57 push %edi
10fa7f: 56 push %esi
10fa80: 53 push %ebx
10fa81: 83 ec 4c sub $0x4c,%esp
10fa84: 8b 5d 08 mov 0x8(%ebp),%ebx
10fa87: 8b 4d 10 mov 0x10(%ebp),%ecx
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
10fa8a: 8b 43 20 mov 0x20(%ebx),%eax
10fa8d: 89 45 c0 mov %eax,-0x40(%ebp)
Heap_Block *start_block = first_block;
Heap_Block *merge_below_block = NULL;
Heap_Block *merge_above_block = NULL;
Heap_Block *link_below_block = NULL;
Heap_Block *link_above_block = NULL;
Heap_Block *extend_first_block = NULL;
10fa90: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
Heap_Block *extend_last_block = NULL;
10fa97: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
uintptr_t const page_size = heap->page_size;
10fa9e: 8b 53 10 mov 0x10(%ebx),%edx
10faa1: 89 55 c4 mov %edx,-0x3c(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10faa4: 8b 43 14 mov 0x14(%ebx),%eax
uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr;
uintptr_t const extend_area_end = extend_area_begin + extend_area_size;
uintptr_t const free_size = stats->free_size;
10faa7: 8b 7b 30 mov 0x30(%ebx),%edi
10faaa: 89 7d bc mov %edi,-0x44(%ebp)
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
return false;
10faad: 31 f6 xor %esi,%esi
uintptr_t const free_size = stats->free_size;
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
10faaf: 8b 7d 0c mov 0xc(%ebp),%edi
10fab2: 01 cf add %ecx,%edi
10fab4: 0f 82 d4 01 00 00 jb 10fc8e <_Heap_Extend+0x213>
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
10faba: 52 push %edx
10fabb: 52 push %edx
10fabc: 8d 55 e0 lea -0x20(%ebp),%edx
10fabf: 52 push %edx
10fac0: 8d 55 e4 lea -0x1c(%ebp),%edx
10fac3: 52 push %edx
10fac4: 50 push %eax
10fac5: ff 75 c4 pushl -0x3c(%ebp)
10fac8: 51 push %ecx
10fac9: ff 75 0c pushl 0xc(%ebp)
10facc: e8 8a b8 ff ff call 10b35b <_Heap_Get_first_and_last_block>
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
10fad1: 83 c4 20 add $0x20,%esp
10fad4: 84 c0 test %al,%al
10fad6: 0f 84 b2 01 00 00 je 10fc8e <_Heap_Extend+0x213>
10fadc: 8b 4d c0 mov -0x40(%ebp),%ecx
10fadf: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp)
10fae6: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp)
10faed: 31 f6 xor %esi,%esi
10faef: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
10faf6: 8b 43 18 mov 0x18(%ebx),%eax
10faf9: 89 5d b8 mov %ebx,-0x48(%ebp)
10fafc: eb 02 jmp 10fb00 <_Heap_Extend+0x85>
10fafe: 89 c8 mov %ecx,%eax
uintptr_t const sub_area_end = start_block->prev_size;
10fb00: 8b 19 mov (%ecx),%ebx
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
10fb02: 39 c7 cmp %eax,%edi
10fb04: 76 09 jbe 10fb0f <_Heap_Extend+0x94>
10fb06: 39 5d 0c cmp %ebx,0xc(%ebp)
10fb09: 0f 82 7d 01 00 00 jb 10fc8c <_Heap_Extend+0x211>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
10fb0f: 39 c7 cmp %eax,%edi
10fb11: 74 06 je 10fb19 <_Heap_Extend+0x9e>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
10fb13: 39 df cmp %ebx,%edi
10fb15: 72 07 jb 10fb1e <_Heap_Extend+0xa3>
10fb17: eb 08 jmp 10fb21 <_Heap_Extend+0xa6>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
10fb19: 89 4d d0 mov %ecx,-0x30(%ebp)
10fb1c: eb 03 jmp 10fb21 <_Heap_Extend+0xa6>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
10fb1e: 89 4d c8 mov %ecx,-0x38(%ebp)
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
10fb21: 8d 43 f8 lea -0x8(%ebx),%eax
10fb24: 89 45 d4 mov %eax,-0x2c(%ebp)
10fb27: 89 d8 mov %ebx,%eax
10fb29: 31 d2 xor %edx,%edx
10fb2b: f7 75 c4 divl -0x3c(%ebp)
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
10fb2e: 29 55 d4 sub %edx,-0x2c(%ebp)
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
10fb31: 3b 5d 0c cmp 0xc(%ebp),%ebx
10fb34: 75 07 jne 10fb3d <_Heap_Extend+0xc2>
start_block->prev_size = extend_area_end;
10fb36: 89 39 mov %edi,(%ecx)
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area(
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
10fb38: 8b 75 d4 mov -0x2c(%ebp),%esi
10fb3b: eb 08 jmp 10fb45 <_Heap_Extend+0xca>
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
10fb3d: 73 06 jae 10fb45 <_Heap_Extend+0xca>
10fb3f: 8b 55 d4 mov -0x2c(%ebp),%edx
10fb42: 89 55 cc mov %edx,-0x34(%ebp)
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10fb45: 8b 45 d4 mov -0x2c(%ebp),%eax
10fb48: 8b 48 04 mov 0x4(%eax),%ecx
10fb4b: 83 e1 fe and $0xfffffffe,%ecx
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
10fb4e: 01 c1 add %eax,%ecx
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
10fb50: 3b 4d c0 cmp -0x40(%ebp),%ecx
10fb53: 75 a9 jne 10fafe <_Heap_Extend+0x83>
10fb55: 8b 5d b8 mov -0x48(%ebp),%ebx
if ( extend_area_begin < heap->area_begin ) {
10fb58: 8b 55 0c mov 0xc(%ebp),%edx
10fb5b: 3b 53 18 cmp 0x18(%ebx),%edx
10fb5e: 73 05 jae 10fb65 <_Heap_Extend+0xea>
heap->area_begin = extend_area_begin;
10fb60: 89 53 18 mov %edx,0x18(%ebx)
10fb63: eb 08 jmp 10fb6d <_Heap_Extend+0xf2>
} else if ( heap->area_end < extend_area_end ) {
10fb65: 39 7b 1c cmp %edi,0x1c(%ebx)
10fb68: 73 03 jae 10fb6d <_Heap_Extend+0xf2>
heap->area_end = extend_area_end;
10fb6a: 89 7b 1c mov %edi,0x1c(%ebx)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
10fb6d: 8b 45 e0 mov -0x20(%ebp),%eax
10fb70: 8b 55 e4 mov -0x1c(%ebp),%edx
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
10fb73: 89 c1 mov %eax,%ecx
10fb75: 29 d1 sub %edx,%ecx
10fb77: 89 4d d4 mov %ecx,-0x2c(%ebp)
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
10fb7a: 89 3a mov %edi,(%edx)
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
10fb7c: 83 c9 01 or $0x1,%ecx
10fb7f: 89 4a 04 mov %ecx,0x4(%edx)
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
10fb82: 8b 4d d4 mov -0x2c(%ebp),%ecx
10fb85: 89 08 mov %ecx,(%eax)
extend_last_block->size_and_flag = 0;
10fb87: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
10fb8e: 39 53 20 cmp %edx,0x20(%ebx)
10fb91: 76 05 jbe 10fb98 <_Heap_Extend+0x11d>
heap->first_block = extend_first_block;
10fb93: 89 53 20 mov %edx,0x20(%ebx)
10fb96: eb 08 jmp 10fba0 <_Heap_Extend+0x125>
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
10fb98: 39 43 24 cmp %eax,0x24(%ebx)
10fb9b: 73 03 jae 10fba0 <_Heap_Extend+0x125>
heap->last_block = extend_last_block;
10fb9d: 89 43 24 mov %eax,0x24(%ebx)
}
if ( merge_below_block != NULL ) {
10fba0: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
10fba4: 74 3b je 10fbe1 <_Heap_Extend+0x166>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
10fba6: 8b 43 10 mov 0x10(%ebx),%eax
10fba9: 89 45 d4 mov %eax,-0x2c(%ebp)
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
10fbac: 8b 4d 0c mov 0xc(%ebp),%ecx
10fbaf: 83 c1 08 add $0x8,%ecx
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
10fbb2: 89 c8 mov %ecx,%eax
10fbb4: 31 d2 xor %edx,%edx
10fbb6: f7 75 d4 divl -0x2c(%ebp)
if ( remainder != 0 ) {
10fbb9: 85 d2 test %edx,%edx
10fbbb: 74 05 je 10fbc2 <_Heap_Extend+0x147> <== ALWAYS TAKEN
return value - remainder + alignment;
10fbbd: 03 4d d4 add -0x2c(%ebp),%ecx <== NOT EXECUTED
10fbc0: 29 d1 sub %edx,%ecx <== NOT EXECUTED
uintptr_t const new_first_block_begin =
10fbc2: 8d 51 f8 lea -0x8(%ecx),%edx
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
10fbc5: 8b 45 d0 mov -0x30(%ebp),%eax
10fbc8: 8b 00 mov (%eax),%eax
10fbca: 89 41 f8 mov %eax,-0x8(%ecx)
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const new_first_block_begin =
new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
10fbcd: 8b 45 d0 mov -0x30(%ebp),%eax
10fbd0: 29 d0 sub %edx,%eax
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
10fbd2: 83 c8 01 or $0x1,%eax
10fbd5: 89 42 04 mov %eax,0x4(%edx)
_Heap_Free_block( heap, new_first_block );
10fbd8: 89 d8 mov %ebx,%eax
10fbda: e8 81 fe ff ff call 10fa60 <_Heap_Free_block>
10fbdf: eb 14 jmp 10fbf5 <_Heap_Extend+0x17a>
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
_Heap_Merge_below( heap, extend_area_begin, merge_below_block );
} else if ( link_below_block != NULL ) {
10fbe1: 83 7d c8 00 cmpl $0x0,-0x38(%ebp)
10fbe5: 74 0e je 10fbf5 <_Heap_Extend+0x17a>
_Heap_Link_below(
10fbe7: 8b 55 e0 mov -0x20(%ebp),%edx
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
(link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;
10fbea: 8b 45 c8 mov -0x38(%ebp),%eax
10fbed: 29 d0 sub %edx,%eax
10fbef: 83 c8 01 or $0x1,%eax
10fbf2: 89 42 04 mov %eax,0x4(%edx)
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
10fbf5: 85 f6 test %esi,%esi
10fbf7: 74 30 je 10fc29 <_Heap_Extend+0x1ae>
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
extend_area_end - last_block_begin - HEAP_BLOCK_HEADER_SIZE,
10fbf9: 83 ef 08 sub $0x8,%edi
uintptr_t extend_area_end
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
10fbfc: 29 f7 sub %esi,%edi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
10fbfe: 89 f8 mov %edi,%eax
10fc00: 31 d2 xor %edx,%edx
10fc02: f7 73 10 divl 0x10(%ebx)
10fc05: 29 d7 sub %edx,%edi
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
(last_block->size_and_flag - last_block_new_size)
10fc07: 8b 46 04 mov 0x4(%esi),%eax
10fc0a: 29 f8 sub %edi,%eax
| HEAP_PREV_BLOCK_USED;
10fc0c: 83 c8 01 or $0x1,%eax
10fc0f: 89 44 37 04 mov %eax,0x4(%edi,%esi,1)
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
10fc13: 8b 46 04 mov 0x4(%esi),%eax
10fc16: 83 e0 01 and $0x1,%eax
block->size_and_flag = size | flag;
10fc19: 09 f8 or %edi,%eax
10fc1b: 89 46 04 mov %eax,0x4(%esi)
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
10fc1e: 89 f2 mov %esi,%edx
10fc20: 89 d8 mov %ebx,%eax
10fc22: e8 39 fe ff ff call 10fa60 <_Heap_Free_block>
10fc27: eb 21 jmp 10fc4a <_Heap_Extend+0x1cf>
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
10fc29: 83 7d cc 00 cmpl $0x0,-0x34(%ebp)
10fc2d: 74 1b je 10fc4a <_Heap_Extend+0x1cf>
_Heap_Link_above(
10fc2f: 8b 4d e0 mov -0x20(%ebp),%ecx
)
{
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
10fc32: 8b 45 e4 mov -0x1c(%ebp),%eax
10fc35: 2b 45 cc sub -0x34(%ebp),%eax
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
10fc38: 8b 7d cc mov -0x34(%ebp),%edi
10fc3b: 8b 57 04 mov 0x4(%edi),%edx
10fc3e: 83 e2 01 and $0x1,%edx
block->size_and_flag = size | flag;
10fc41: 09 d0 or %edx,%eax
10fc43: 89 47 04 mov %eax,0x4(%edi)
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
10fc46: 83 49 04 01 orl $0x1,0x4(%ecx)
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
10fc4a: 85 f6 test %esi,%esi
10fc4c: 75 10 jne 10fc5e <_Heap_Extend+0x1e3>
10fc4e: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
10fc52: 75 0a jne 10fc5e <_Heap_Extend+0x1e3>
_Heap_Free_block( heap, extend_first_block );
10fc54: 8b 55 e4 mov -0x1c(%ebp),%edx
10fc57: 89 d8 mov %ebx,%eax
10fc59: e8 02 fe ff ff call 10fa60 <_Heap_Free_block>
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
heap->last_block,
(uintptr_t) heap->first_block - (uintptr_t) heap->last_block
10fc5e: 8b 53 24 mov 0x24(%ebx),%edx
* This feature will be used to terminate the scattered heap area list. See
* also _Heap_Extend().
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
10fc61: 8b 43 20 mov 0x20(%ebx),%eax
10fc64: 29 d0 sub %edx,%eax
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
10fc66: 8b 4a 04 mov 0x4(%edx),%ecx
10fc69: 83 e1 01 and $0x1,%ecx
block->size_and_flag = size | flag;
10fc6c: 09 c8 or %ecx,%eax
10fc6e: 89 42 04 mov %eax,0x4(%edx)
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
10fc71: 8b 43 30 mov 0x30(%ebx),%eax
10fc74: 2b 45 bc sub -0x44(%ebp),%eax
/* Statistics */
stats->size += extended_size;
10fc77: 01 43 2c add %eax,0x2c(%ebx)
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
10fc7a: be 01 00 00 00 mov $0x1,%esi
extended_size = stats->free_size - free_size;
/* Statistics */
stats->size += extended_size;
if ( extended_size_ptr != NULL )
10fc7f: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10fc83: 74 09 je 10fc8e <_Heap_Extend+0x213> <== NEVER TAKEN
*extended_size_ptr = extended_size;
10fc85: 8b 55 14 mov 0x14(%ebp),%edx
10fc88: 89 02 mov %eax,(%edx)
10fc8a: eb 02 jmp 10fc8e <_Heap_Extend+0x213>
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
10fc8c: 31 f6 xor %esi,%esi
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
10fc8e: 89 f0 mov %esi,%eax
10fc90: 8d 65 f4 lea -0xc(%ebp),%esp
10fc93: 5b pop %ebx
10fc94: 5e pop %esi
10fc95: 5f pop %edi
10fc96: c9 leave
10fc97: c3 ret
0010f6d0 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
10f6d0: 55 push %ebp
10f6d1: 89 e5 mov %esp,%ebp
10f6d3: 57 push %edi
10f6d4: 56 push %esi
10f6d5: 53 push %ebx
10f6d6: 83 ec 14 sub $0x14,%esp
10f6d9: 8b 4d 08 mov 0x8(%ebp),%ecx
10f6dc: 8b 45 0c mov 0xc(%ebp),%eax
10f6df: 8d 58 f8 lea -0x8(%eax),%ebx
10f6e2: 31 d2 xor %edx,%edx
10f6e4: f7 71 10 divl 0x10(%ecx)
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
10f6e7: 29 d3 sub %edx,%ebx
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
10f6e9: 8b 41 20 mov 0x20(%ecx),%eax
10f6ec: 89 45 ec mov %eax,-0x14(%ebp)
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10f6ef: 31 d2 xor %edx,%edx
10f6f1: 39 c3 cmp %eax,%ebx
10f6f3: 72 08 jb 10f6fd <_Heap_Free+0x2d>
10f6f5: 31 d2 xor %edx,%edx
10f6f7: 39 59 24 cmp %ebx,0x24(%ecx)
10f6fa: 0f 93 c2 setae %dl
bool next_is_free = false;
_Heap_Protection_block_check( heap, block );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
return false;
10f6fd: 31 c0 xor %eax,%eax
uintptr_t next_block_size = 0;
bool next_is_free = false;
_Heap_Protection_block_check( heap, block );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
10f6ff: 85 d2 test %edx,%edx
10f701: 0f 84 21 01 00 00 je 10f828 <_Heap_Free+0x158>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
10f707: 8b 43 04 mov 0x4(%ebx),%eax
10f70a: 89 45 f0 mov %eax,-0x10(%ebp)
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10f70d: 89 c6 mov %eax,%esi
10f70f: 83 e6 fe and $0xfffffffe,%esi
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
10f712: 8d 14 33 lea (%ebx,%esi,1),%edx
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10f715: 31 ff xor %edi,%edi
10f717: 3b 55 ec cmp -0x14(%ebp),%edx
10f71a: 72 0a jb 10f726 <_Heap_Free+0x56> <== NEVER TAKEN
10f71c: 31 c0 xor %eax,%eax
10f71e: 39 51 24 cmp %edx,0x24(%ecx)
10f721: 0f 93 c0 setae %al
10f724: 89 c7 mov %eax,%edi
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
_HAssert( false );
return false;
10f726: 31 c0 xor %eax,%eax
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
10f728: 85 ff test %edi,%edi
10f72a: 0f 84 f8 00 00 00 je 10f828 <_Heap_Free+0x158> <== NEVER TAKEN
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
10f730: 8b 7a 04 mov 0x4(%edx),%edi
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
_HAssert( false );
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10f733: f7 c7 01 00 00 00 test $0x1,%edi
10f739: 0f 84 e9 00 00 00 je 10f828 <_Heap_Free+0x158> <== NEVER TAKEN
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10f73f: 83 e7 fe and $0xfffffffe,%edi
10f742: 89 7d e8 mov %edi,-0x18(%ebp)
if ( !_Heap_Protection_determine_block_free( heap, block ) ) {
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
10f745: 8b 41 24 mov 0x24(%ecx),%eax
10f748: 89 45 e4 mov %eax,-0x1c(%ebp)
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
10f74b: 31 c0 xor %eax,%eax
10f74d: 3b 55 e4 cmp -0x1c(%ebp),%edx
10f750: 74 0a je 10f75c <_Heap_Free+0x8c>
10f752: 31 c0 xor %eax,%eax
10f754: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1)
10f759: 0f 94 c0 sete %al
if ( !_Heap_Protection_determine_block_free( heap, block ) ) {
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
10f75c: 88 45 e3 mov %al,-0x1d(%ebp)
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
10f75f: f6 45 f0 01 testb $0x1,-0x10(%ebp)
10f763: 75 62 jne 10f7c7 <_Heap_Free+0xf7>
uintptr_t const prev_size = block->prev_size;
10f765: 8b 03 mov (%ebx),%eax
10f767: 89 45 f0 mov %eax,-0x10(%ebp)
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
10f76a: 29 c3 sub %eax,%ebx
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10f76c: 31 ff xor %edi,%edi
10f76e: 3b 5d ec cmp -0x14(%ebp),%ebx
10f771: 72 0a jb 10f77d <_Heap_Free+0xad> <== NEVER TAKEN
10f773: 31 c0 xor %eax,%eax
10f775: 39 5d e4 cmp %ebx,-0x1c(%ebp)
10f778: 0f 93 c0 setae %al
10f77b: 89 c7 mov %eax,%edi
Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size );
if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) {
_HAssert( false );
return( false );
10f77d: 31 c0 xor %eax,%eax
if ( !_Heap_Is_prev_used( block ) ) {
uintptr_t const prev_size = block->prev_size;
Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size );
if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) {
10f77f: 85 ff test %edi,%edi
10f781: 0f 84 a1 00 00 00 je 10f828 <_Heap_Free+0x158> <== 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) ) {
10f787: f6 43 04 01 testb $0x1,0x4(%ebx)
10f78b: 0f 84 97 00 00 00 je 10f828 <_Heap_Free+0x158> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
10f791: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
10f795: 74 1a je 10f7b1 <_Heap_Free+0xe1>
uintptr_t const size = block_size + prev_size + next_block_size;
10f797: 8b 45 e8 mov -0x18(%ebp),%eax
10f79a: 8d 04 06 lea (%esi,%eax,1),%eax
10f79d: 03 45 f0 add -0x10(%ebp),%eax
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
10f7a0: 8b 7a 08 mov 0x8(%edx),%edi
Heap_Block *prev = block->prev;
10f7a3: 8b 52 0c mov 0xc(%edx),%edx
prev->next = next;
10f7a6: 89 7a 08 mov %edi,0x8(%edx)
next->prev = prev;
10f7a9: 89 57 0c mov %edx,0xc(%edi)
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
10f7ac: ff 49 38 decl 0x38(%ecx)
10f7af: eb 33 jmp 10f7e4 <_Heap_Free+0x114>
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
10f7b1: 8b 45 f0 mov -0x10(%ebp),%eax
10f7b4: 8d 04 06 lea (%esi,%eax,1),%eax
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10f7b7: 89 c7 mov %eax,%edi
10f7b9: 83 cf 01 or $0x1,%edi
10f7bc: 89 7b 04 mov %edi,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10f7bf: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = size;
10f7c3: 89 02 mov %eax,(%edx)
10f7c5: eb 56 jmp 10f81d <_Heap_Free+0x14d>
}
} else if ( next_is_free ) { /* coalesce next */
10f7c7: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp)
10f7cb: 74 24 je 10f7f1 <_Heap_Free+0x121>
uintptr_t const size = block_size + next_block_size;
10f7cd: 8b 45 e8 mov -0x18(%ebp),%eax
10f7d0: 01 f0 add %esi,%eax
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *next = old_block->next;
10f7d2: 8b 7a 08 mov 0x8(%edx),%edi
Heap_Block *prev = old_block->prev;
10f7d5: 8b 52 0c mov 0xc(%edx),%edx
new_block->next = next;
10f7d8: 89 7b 08 mov %edi,0x8(%ebx)
new_block->prev = prev;
10f7db: 89 53 0c mov %edx,0xc(%ebx)
next->prev = new_block;
10f7de: 89 5f 0c mov %ebx,0xc(%edi)
prev->next = new_block;
10f7e1: 89 5a 08 mov %ebx,0x8(%edx)
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
10f7e4: 89 c2 mov %eax,%edx
10f7e6: 83 ca 01 or $0x1,%edx
10f7e9: 89 53 04 mov %edx,0x4(%ebx)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
10f7ec: 89 04 03 mov %eax,(%ebx,%eax,1)
10f7ef: eb 2c jmp 10f81d <_Heap_Free+0x14d>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
10f7f1: 8b 41 08 mov 0x8(%ecx),%eax
new_block->next = next;
10f7f4: 89 43 08 mov %eax,0x8(%ebx)
new_block->prev = block_before;
10f7f7: 89 4b 0c mov %ecx,0xc(%ebx)
block_before->next = new_block;
10f7fa: 89 59 08 mov %ebx,0x8(%ecx)
next->prev = new_block;
10f7fd: 89 58 0c mov %ebx,0xc(%eax)
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
10f800: 89 f0 mov %esi,%eax
10f802: 83 c8 01 or $0x1,%eax
10f805: 89 43 04 mov %eax,0x4(%ebx)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
10f808: 83 62 04 fe andl $0xfffffffe,0x4(%edx)
next_block->prev_size = block_size;
10f80c: 89 32 mov %esi,(%edx)
/* Statistics */
++stats->free_blocks;
10f80e: 8b 41 38 mov 0x38(%ecx),%eax
10f811: 40 inc %eax
10f812: 89 41 38 mov %eax,0x38(%ecx)
if ( stats->max_free_blocks < stats->free_blocks ) {
10f815: 39 41 3c cmp %eax,0x3c(%ecx)
10f818: 73 03 jae 10f81d <_Heap_Free+0x14d>
stats->max_free_blocks = stats->free_blocks;
10f81a: 89 41 3c mov %eax,0x3c(%ecx)
}
}
/* Statistics */
--stats->used_blocks;
10f81d: ff 49 40 decl 0x40(%ecx)
++stats->frees;
10f820: ff 41 50 incl 0x50(%ecx)
stats->free_size += block_size;
10f823: 01 71 30 add %esi,0x30(%ecx)
return( true );
10f826: b0 01 mov $0x1,%al
}
10f828: 83 c4 14 add $0x14,%esp
10f82b: 5b pop %ebx
10f82c: 5e pop %esi
10f82d: 5f pop %edi
10f82e: c9 leave
10f82f: c3 ret
0011d470 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
11d470: 55 push %ebp
11d471: 89 e5 mov %esp,%ebp
11d473: 57 push %edi
11d474: 56 push %esi
11d475: 53 push %ebx
11d476: 8b 5d 08 mov 0x8(%ebp),%ebx
11d479: 8b 75 0c mov 0xc(%ebp),%esi
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
11d47c: 8d 4e f8 lea -0x8(%esi),%ecx
11d47f: 89 f0 mov %esi,%eax
11d481: 31 d2 xor %edx,%edx
11d483: f7 73 10 divl 0x10(%ebx)
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
11d486: 29 d1 sub %edx,%ecx
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
11d488: 8b 53 20 mov 0x20(%ebx),%edx
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11d48b: 31 ff xor %edi,%edi
11d48d: 39 d1 cmp %edx,%ecx
11d48f: 72 0a jb 11d49b <_Heap_Size_of_alloc_area+0x2b>
11d491: 31 c0 xor %eax,%eax
11d493: 39 4b 24 cmp %ecx,0x24(%ebx)
11d496: 0f 93 c0 setae %al
11d499: 89 c7 mov %eax,%edi
Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
Heap_Block *next_block = NULL;
uintptr_t block_size = 0;
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
return false;
11d49b: 31 c0 xor %eax,%eax
uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;
Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
Heap_Block *next_block = NULL;
uintptr_t block_size = 0;
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
11d49d: 85 ff test %edi,%edi
11d49f: 74 30 je 11d4d1 <_Heap_Size_of_alloc_area+0x61>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
11d4a1: 8b 41 04 mov 0x4(%ecx),%eax
11d4a4: 83 e0 fe and $0xfffffffe,%eax
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
11d4a7: 01 c1 add %eax,%ecx
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
11d4a9: 31 ff xor %edi,%edi
11d4ab: 39 d1 cmp %edx,%ecx
11d4ad: 72 0a jb 11d4b9 <_Heap_Size_of_alloc_area+0x49><== NEVER TAKEN
11d4af: 31 c0 xor %eax,%eax
11d4b1: 39 4b 24 cmp %ecx,0x24(%ebx)
11d4b4: 0f 93 c0 setae %al
11d4b7: 89 c7 mov %eax,%edi
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
11d4b9: 31 c0 xor %eax,%eax
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
11d4bb: 85 ff test %edi,%edi
11d4bd: 74 12 je 11d4d1 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
11d4bf: f6 41 04 01 testb $0x1,0x4(%ecx)
11d4c3: 74 0c je 11d4d1 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
11d4c5: 29 f1 sub %esi,%ecx
11d4c7: 8d 51 04 lea 0x4(%ecx),%edx
11d4ca: 8b 45 10 mov 0x10(%ebp),%eax
11d4cd: 89 10 mov %edx,(%eax)
return true;
11d4cf: b0 01 mov $0x1,%al
}
11d4d1: 5b pop %ebx
11d4d2: 5e pop %esi
11d4d3: 5f pop %edi
11d4d4: c9 leave
11d4d5: c3 ret
0010bc16 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
10bc16: 55 push %ebp
10bc17: 89 e5 mov %esp,%ebp
10bc19: 57 push %edi
10bc1a: 56 push %esi
10bc1b: 53 push %ebx
10bc1c: 83 ec 4c sub $0x4c,%esp
10bc1f: 8b 75 08 mov 0x8(%ebp),%esi
10bc22: 8b 5d 0c mov 0xc(%ebp),%ebx
uintptr_t const page_size = heap->page_size;
10bc25: 8b 46 10 mov 0x10(%esi),%eax
10bc28: 89 45 d8 mov %eax,-0x28(%ebp)
uintptr_t const min_block_size = heap->min_block_size;
10bc2b: 8b 4e 14 mov 0x14(%esi),%ecx
10bc2e: 89 4d d4 mov %ecx,-0x2c(%ebp)
Heap_Block *const first_block = heap->first_block;
10bc31: 8b 46 20 mov 0x20(%esi),%eax
10bc34: 89 45 d0 mov %eax,-0x30(%ebp)
Heap_Block *const last_block = heap->last_block;
10bc37: 8b 4e 24 mov 0x24(%esi),%ecx
10bc3a: 89 4d c8 mov %ecx,-0x38(%ebp)
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
10bc3d: c7 45 e4 d8 bb 10 00 movl $0x10bbd8,-0x1c(%ebp)
10bc44: 80 7d 10 00 cmpb $0x0,0x10(%ebp)
10bc48: 74 07 je 10bc51 <_Heap_Walk+0x3b>
10bc4a: c7 45 e4 dd bb 10 00 movl $0x10bbdd,-0x1c(%ebp)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
10bc51: b0 01 mov $0x1,%al
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
10bc53: 83 3d 24 75 12 00 03 cmpl $0x3,0x127524
10bc5a: 0f 85 e8 02 00 00 jne 10bf48 <_Heap_Walk+0x332>
Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
(*printer)(
10bc60: 52 push %edx
10bc61: ff 76 0c pushl 0xc(%esi)
10bc64: ff 76 08 pushl 0x8(%esi)
10bc67: ff 75 c8 pushl -0x38(%ebp)
10bc6a: ff 75 d0 pushl -0x30(%ebp)
10bc6d: ff 76 1c pushl 0x1c(%esi)
10bc70: ff 76 18 pushl 0x18(%esi)
10bc73: ff 75 d4 pushl -0x2c(%ebp)
10bc76: ff 75 d8 pushl -0x28(%ebp)
10bc79: 68 d9 ff 11 00 push $0x11ffd9
10bc7e: 6a 00 push $0x0
10bc80: 53 push %ebx
10bc81: ff 55 e4 call *-0x1c(%ebp)
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
10bc84: 83 c4 30 add $0x30,%esp
10bc87: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
10bc8b: 75 0b jne 10bc98 <_Heap_Walk+0x82>
(*printer)( source, true, "page size is zero\n" );
10bc8d: 50 push %eax
10bc8e: 68 6a 00 12 00 push $0x12006a
10bc93: e9 6b 02 00 00 jmp 10bf03 <_Heap_Walk+0x2ed>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
10bc98: f6 45 d8 03 testb $0x3,-0x28(%ebp)
10bc9c: 74 0d je 10bcab <_Heap_Walk+0x95>
(*printer)(
10bc9e: ff 75 d8 pushl -0x28(%ebp)
10bca1: 68 7d 00 12 00 push $0x12007d
10bca6: e9 58 02 00 00 jmp 10bf03 <_Heap_Walk+0x2ed>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bcab: 8b 45 d4 mov -0x2c(%ebp),%eax
10bcae: 31 d2 xor %edx,%edx
10bcb0: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
10bcb3: 85 d2 test %edx,%edx
10bcb5: 74 0d je 10bcc4 <_Heap_Walk+0xae>
(*printer)(
10bcb7: ff 75 d4 pushl -0x2c(%ebp)
10bcba: 68 9b 00 12 00 push $0x12009b
10bcbf: e9 3f 02 00 00 jmp 10bf03 <_Heap_Walk+0x2ed>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
10bcc4: 8b 45 d0 mov -0x30(%ebp),%eax
10bcc7: 83 c0 08 add $0x8,%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bcca: 31 d2 xor %edx,%edx
10bccc: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if (
10bccf: 85 d2 test %edx,%edx
10bcd1: 74 0d je 10bce0 <_Heap_Walk+0xca>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
10bcd3: ff 75 d0 pushl -0x30(%ebp)
10bcd6: 68 bf 00 12 00 push $0x1200bf
10bcdb: e9 23 02 00 00 jmp 10bf03 <_Heap_Walk+0x2ed>
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
10bce0: 8b 45 d0 mov -0x30(%ebp),%eax
10bce3: f6 40 04 01 testb $0x1,0x4(%eax)
10bce7: 75 0b jne 10bcf4 <_Heap_Walk+0xde>
(*printer)(
10bce9: 57 push %edi
10bcea: 68 f0 00 12 00 push $0x1200f0
10bcef: e9 0f 02 00 00 jmp 10bf03 <_Heap_Walk+0x2ed>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10bcf4: 8b 4d c8 mov -0x38(%ebp),%ecx
10bcf7: 8b 79 04 mov 0x4(%ecx),%edi
10bcfa: 83 e7 fe and $0xfffffffe,%edi
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
10bcfd: 01 cf add %ecx,%edi
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
10bcff: f6 47 04 01 testb $0x1,0x4(%edi)
10bd03: 75 0b jne 10bd10 <_Heap_Walk+0xfa>
(*printer)(
10bd05: 56 push %esi
10bd06: 68 1e 01 12 00 push $0x12011e
10bd0b: e9 f3 01 00 00 jmp 10bf03 <_Heap_Walk+0x2ed>
);
return false;
}
if (
10bd10: 3b 7d d0 cmp -0x30(%ebp),%edi
10bd13: 74 0b je 10bd20 <_Heap_Walk+0x10a> <== ALWAYS TAKEN
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
10bd15: 51 push %ecx <== NOT EXECUTED
10bd16: 68 33 01 12 00 push $0x120133 <== NOT EXECUTED
10bd1b: e9 e3 01 00 00 jmp 10bf03 <_Heap_Walk+0x2ed> <== NOT EXECUTED
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
10bd20: 8b 46 10 mov 0x10(%esi),%eax
10bd23: 89 45 e0 mov %eax,-0x20(%ebp)
block = next_block;
} while ( block != first_block );
return true;
}
10bd26: 8b 4e 08 mov 0x8(%esi),%ecx
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
10bd29: 89 75 dc mov %esi,-0x24(%ebp)
10bd2c: eb 75 jmp 10bda3 <_Heap_Walk+0x18d>
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10bd2e: 31 c0 xor %eax,%eax
10bd30: 39 4e 20 cmp %ecx,0x20(%esi)
10bd33: 77 08 ja 10bd3d <_Heap_Walk+0x127>
10bd35: 31 c0 xor %eax,%eax
10bd37: 39 4e 24 cmp %ecx,0x24(%esi)
10bd3a: 0f 93 c0 setae %al
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
10bd3d: 85 c0 test %eax,%eax
10bd3f: 75 0b jne 10bd4c <_Heap_Walk+0x136>
(*printer)(
10bd41: 51 push %ecx
10bd42: 68 62 01 12 00 push $0x120162
10bd47: e9 b7 01 00 00 jmp 10bf03 <_Heap_Walk+0x2ed>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
10bd4c: 8d 41 08 lea 0x8(%ecx),%eax
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bd4f: 31 d2 xor %edx,%edx
10bd51: f7 75 e0 divl -0x20(%ebp)
);
return false;
}
if (
10bd54: 85 d2 test %edx,%edx
10bd56: 74 0b je 10bd63 <_Heap_Walk+0x14d>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
10bd58: 51 push %ecx
10bd59: 68 82 01 12 00 push $0x120182
10bd5e: e9 a0 01 00 00 jmp 10bf03 <_Heap_Walk+0x2ed>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
10bd63: 8b 41 04 mov 0x4(%ecx),%eax
10bd66: 83 e0 fe and $0xfffffffe,%eax
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
10bd69: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1)
10bd6e: 74 0b je 10bd7b <_Heap_Walk+0x165>
(*printer)(
10bd70: 51 push %ecx
10bd71: 68 b2 01 12 00 push $0x1201b2
10bd76: e9 88 01 00 00 jmp 10bf03 <_Heap_Walk+0x2ed>
);
return false;
}
if ( free_block->prev != prev_block ) {
10bd7b: 8b 41 0c mov 0xc(%ecx),%eax
10bd7e: 3b 45 dc cmp -0x24(%ebp),%eax
10bd81: 74 1a je 10bd9d <_Heap_Walk+0x187>
(*printer)(
10bd83: 83 ec 0c sub $0xc,%esp
10bd86: 50 push %eax
10bd87: 51 push %ecx
10bd88: 68 ce 01 12 00 push $0x1201ce
10bd8d: 6a 01 push $0x1
10bd8f: 53 push %ebx
10bd90: ff 55 e4 call *-0x1c(%ebp)
10bd93: 83 c4 20 add $0x20,%esp
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
10bd96: 31 c0 xor %eax,%eax
10bd98: e9 ab 01 00 00 jmp 10bf48 <_Heap_Walk+0x332>
return false;
}
prev_block = free_block;
free_block = free_block->next;
10bd9d: 89 4d dc mov %ecx,-0x24(%ebp)
10bda0: 8b 49 08 mov 0x8(%ecx),%ecx
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
10bda3: 39 f1 cmp %esi,%ecx
10bda5: 75 87 jne 10bd2e <_Heap_Walk+0x118>
10bda7: 89 5d dc mov %ebx,-0x24(%ebp)
10bdaa: eb 02 jmp 10bdae <_Heap_Walk+0x198>
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10bdac: 89 df mov %ebx,%edi
return true;
}
10bdae: 8b 4f 04 mov 0x4(%edi),%ecx
10bdb1: 89 4d cc mov %ecx,-0x34(%ebp)
10bdb4: 83 e1 fe and $0xfffffffe,%ecx
10bdb7: 89 4d e0 mov %ecx,-0x20(%ebp)
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
10bdba: 8d 1c 0f lea (%edi,%ecx,1),%ebx
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
10bdbd: 31 c0 xor %eax,%eax
10bdbf: 39 5e 20 cmp %ebx,0x20(%esi)
10bdc2: 77 08 ja 10bdcc <_Heap_Walk+0x1b6> <== NEVER TAKEN
10bdc4: 31 c0 xor %eax,%eax
10bdc6: 39 5e 24 cmp %ebx,0x24(%esi)
10bdc9: 0f 93 c0 setae %al
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
10bdcc: 85 c0 test %eax,%eax
10bdce: 75 11 jne 10bde1 <_Heap_Walk+0x1cb>
10bdd0: 89 d9 mov %ebx,%ecx
10bdd2: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bdd5: 83 ec 0c sub $0xc,%esp
10bdd8: 51 push %ecx
10bdd9: 57 push %edi
10bdda: 68 00 02 12 00 push $0x120200
10bddf: eb ac jmp 10bd8d <_Heap_Walk+0x177>
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
10bde1: 3b 7d c8 cmp -0x38(%ebp),%edi
10bde4: 0f 95 c1 setne %cl
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
10bde7: 8b 45 e0 mov -0x20(%ebp),%eax
10bdea: 31 d2 xor %edx,%edx
10bdec: f7 75 d8 divl -0x28(%ebp)
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
10bdef: 85 d2 test %edx,%edx
10bdf1: 74 15 je 10be08 <_Heap_Walk+0x1f2>
10bdf3: 84 c9 test %cl,%cl
10bdf5: 74 11 je 10be08 <_Heap_Walk+0x1f2>
10bdf7: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bdfa: 83 ec 0c sub $0xc,%esp
10bdfd: ff 75 e0 pushl -0x20(%ebp)
10be00: 57 push %edi
10be01: 68 2d 02 12 00 push $0x12022d
10be06: eb 85 jmp 10bd8d <_Heap_Walk+0x177>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
10be08: 8b 45 d4 mov -0x2c(%ebp),%eax
10be0b: 39 45 e0 cmp %eax,-0x20(%ebp)
10be0e: 73 18 jae 10be28 <_Heap_Walk+0x212>
10be10: 84 c9 test %cl,%cl
10be12: 74 14 je 10be28 <_Heap_Walk+0x212> <== NEVER TAKEN
10be14: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be17: 52 push %edx
10be18: 52 push %edx
10be19: 50 push %eax
10be1a: ff 75 e0 pushl -0x20(%ebp)
10be1d: 57 push %edi
10be1e: 68 5b 02 12 00 push $0x12025b
10be23: e9 65 ff ff ff jmp 10bd8d <_Heap_Walk+0x177>
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
10be28: 39 fb cmp %edi,%ebx
10be2a: 77 18 ja 10be44 <_Heap_Walk+0x22e>
10be2c: 84 c9 test %cl,%cl
10be2e: 74 14 je 10be44 <_Heap_Walk+0x22e>
10be30: 89 d9 mov %ebx,%ecx
10be32: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10be35: 83 ec 0c sub $0xc,%esp
10be38: 51 push %ecx
10be39: 57 push %edi
10be3a: 68 86 02 12 00 push $0x120286
10be3f: e9 49 ff ff ff jmp 10bd8d <_Heap_Walk+0x177>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
10be44: 8b 4d cc mov -0x34(%ebp),%ecx
10be47: 83 e1 01 and $0x1,%ecx
10be4a: 89 4d c4 mov %ecx,-0x3c(%ebp)
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
10be4d: f6 43 04 01 testb $0x1,0x4(%ebx)
10be51: 0f 85 ba 00 00 00 jne 10bf11 <_Heap_Walk+0x2fb>
block = next_block;
} while ( block != first_block );
return true;
}
10be57: 8b 46 08 mov 0x8(%esi),%eax
10be5a: 89 45 c0 mov %eax,-0x40(%ebp)
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
10be5d: 8b 4f 08 mov 0x8(%edi),%ecx
10be60: 89 4d b4 mov %ecx,-0x4c(%ebp)
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
10be63: ba a6 ff 11 00 mov $0x11ffa6,%edx
10be68: 3b 4e 0c cmp 0xc(%esi),%ecx
10be6b: 74 0e je 10be7b <_Heap_Walk+0x265>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
10be6d: ba ed fe 11 00 mov $0x11feed,%edx
10be72: 39 f1 cmp %esi,%ecx
10be74: 75 05 jne 10be7b <_Heap_Walk+0x265>
10be76: ba b5 ff 11 00 mov $0x11ffb5,%edx
false,
"block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n",
block,
block_size,
block->prev,
block->prev == first_free_block ?
10be7b: 8b 47 0c mov 0xc(%edi),%eax
10be7e: 89 45 cc mov %eax,-0x34(%ebp)
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
10be81: b8 bf ff 11 00 mov $0x11ffbf,%eax
10be86: 8b 4d c0 mov -0x40(%ebp),%ecx
10be89: 39 4d cc cmp %ecx,-0x34(%ebp)
10be8c: 74 0f je 10be9d <_Heap_Walk+0x287>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
10be8e: b8 ed fe 11 00 mov $0x11feed,%eax
10be93: 39 75 cc cmp %esi,-0x34(%ebp)
10be96: 75 05 jne 10be9d <_Heap_Walk+0x287>
10be98: b8 cf ff 11 00 mov $0x11ffcf,%eax
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
10be9d: 83 ec 0c sub $0xc,%esp
10bea0: 52 push %edx
10bea1: ff 75 b4 pushl -0x4c(%ebp)
10bea4: 50 push %eax
10bea5: ff 75 cc pushl -0x34(%ebp)
10bea8: ff 75 e0 pushl -0x20(%ebp)
10beab: 57 push %edi
10beac: 68 ba 02 12 00 push $0x1202ba
10beb1: 6a 00 push $0x0
10beb3: ff 75 dc pushl -0x24(%ebp)
10beb6: ff 55 e4 call *-0x1c(%ebp)
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
10beb9: 8b 03 mov (%ebx),%eax
10bebb: 83 c4 30 add $0x30,%esp
10bebe: 39 45 e0 cmp %eax,-0x20(%ebp)
10bec1: 74 16 je 10bed9 <_Heap_Walk+0x2c3>
10bec3: 89 d9 mov %ebx,%ecx
10bec5: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bec8: 56 push %esi
10bec9: 51 push %ecx
10beca: 50 push %eax
10becb: ff 75 e0 pushl -0x20(%ebp)
10bece: 57 push %edi
10becf: 68 ef 02 12 00 push $0x1202ef
10bed4: e9 b4 fe ff ff jmp 10bd8d <_Heap_Walk+0x177>
);
return false;
}
if ( !prev_used ) {
10bed9: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
10bedd: 75 0b jne 10beea <_Heap_Walk+0x2d4>
10bedf: 8b 5d dc mov -0x24(%ebp),%ebx
(*printer)(
10bee2: 57 push %edi
10bee3: 68 28 03 12 00 push $0x120328
10bee8: eb 19 jmp 10bf03 <_Heap_Walk+0x2ed>
block = next_block;
} while ( block != first_block );
return true;
}
10beea: 8b 46 08 mov 0x8(%esi),%eax
10beed: eb 07 jmp 10bef6 <_Heap_Walk+0x2e0>
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
if ( free_block == block ) {
10beef: 39 f8 cmp %edi,%eax
10bef1: 74 4a je 10bf3d <_Heap_Walk+0x327>
return true;
}
free_block = free_block->next;
10bef3: 8b 40 08 mov 0x8(%eax),%eax
)
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
10bef6: 39 f0 cmp %esi,%eax
10bef8: 75 f5 jne 10beef <_Heap_Walk+0x2d9>
10befa: 8b 5d dc mov -0x24(%ebp),%ebx
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
10befd: 57 push %edi
10befe: 68 93 03 12 00 push $0x120393
10bf03: 6a 01 push $0x1
10bf05: 53 push %ebx
10bf06: ff 55 e4 call *-0x1c(%ebp)
10bf09: 83 c4 10 add $0x10,%esp
10bf0c: e9 85 fe ff ff jmp 10bd96 <_Heap_Walk+0x180>
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
10bf11: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp)
10bf15: 74 0e je 10bf25 <_Heap_Walk+0x30f>
(*printer)(
10bf17: 83 ec 0c sub $0xc,%esp
10bf1a: ff 75 e0 pushl -0x20(%ebp)
10bf1d: 57 push %edi
10bf1e: 68 57 03 12 00 push $0x120357
10bf23: eb 0d jmp 10bf32 <_Heap_Walk+0x31c>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
10bf25: 51 push %ecx
10bf26: 51 push %ecx
10bf27: ff 37 pushl (%edi)
10bf29: ff 75 e0 pushl -0x20(%ebp)
10bf2c: 57 push %edi
10bf2d: 68 6e 03 12 00 push $0x12036e
10bf32: 6a 00 push $0x0
10bf34: ff 75 dc pushl -0x24(%ebp)
10bf37: ff 55 e4 call *-0x1c(%ebp)
10bf3a: 83 c4 20 add $0x20,%esp
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
10bf3d: 3b 5d d0 cmp -0x30(%ebp),%ebx
10bf40: 0f 85 66 fe ff ff jne 10bdac <_Heap_Walk+0x196>
return true;
10bf46: b0 01 mov $0x1,%al
}
10bf48: 8d 65 f4 lea -0xc(%ebp),%esp
10bf4b: 5b pop %ebx
10bf4c: 5e pop %esi
10bf4d: 5f pop %edi
10bf4e: c9 leave
10bf4f: c3 ret
0010b238 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10b238: 55 push %ebp
10b239: 89 e5 mov %esp,%ebp
10b23b: 53 push %ebx
10b23c: 83 ec 08 sub $0x8,%esp
10b23f: 8b 45 08 mov 0x8(%ebp),%eax
10b242: 8b 55 0c mov 0xc(%ebp),%edx
10b245: 8b 5d 10 mov 0x10(%ebp),%ebx
_Internal_errors_What_happened.the_source = the_source;
10b248: a3 d8 53 12 00 mov %eax,0x1253d8
_Internal_errors_What_happened.is_internal = is_internal;
10b24d: 88 15 dc 53 12 00 mov %dl,0x1253dc
_Internal_errors_What_happened.the_error = the_error;
10b253: 89 1d e0 53 12 00 mov %ebx,0x1253e0
_User_extensions_Fatal( the_source, is_internal, the_error );
10b259: 53 push %ebx
10b25a: 0f b6 d2 movzbl %dl,%edx
10b25d: 52 push %edx
10b25e: 50 push %eax
10b25f: e8 27 1a 00 00 call 10cc8b <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
10b264: c7 05 9c 54 12 00 05 movl $0x5,0x12549c <== NOT EXECUTED
10b26b: 00 00 00
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
10b26e: fa cli <== NOT EXECUTED
10b26f: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10b271: f4 hlt <== NOT EXECUTED
10b272: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10b275: eb fe jmp 10b275 <_Internal_error_Occurred+0x3d><== NOT EXECUTED
0010b2c8 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
10b2c8: 55 push %ebp
10b2c9: 89 e5 mov %esp,%ebp
10b2cb: 56 push %esi
10b2cc: 53 push %ebx
10b2cd: 8b 5d 08 mov 0x8(%ebp),%ebx
* 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 )
return NULL;
10b2d0: 31 c9 xor %ecx,%ecx
* 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 )
10b2d2: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
10b2d6: 74 53 je 10b32b <_Objects_Allocate+0x63><== 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 );
10b2d8: 8d 73 20 lea 0x20(%ebx),%esi
10b2db: 83 ec 0c sub $0xc,%esp
10b2de: 56 push %esi
10b2df: e8 38 f7 ff ff call 10aa1c <_Chain_Get>
10b2e4: 89 c1 mov %eax,%ecx
if ( information->auto_extend ) {
10b2e6: 83 c4 10 add $0x10,%esp
10b2e9: 80 7b 12 00 cmpb $0x0,0x12(%ebx)
10b2ed: 74 3c je 10b32b <_Objects_Allocate+0x63>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
10b2ef: 85 c0 test %eax,%eax
10b2f1: 75 1a jne 10b30d <_Objects_Allocate+0x45>
_Objects_Extend_information( information );
10b2f3: 83 ec 0c sub $0xc,%esp
10b2f6: 53 push %ebx
10b2f7: e8 60 00 00 00 call 10b35c <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
10b2fc: 89 34 24 mov %esi,(%esp)
10b2ff: e8 18 f7 ff ff call 10aa1c <_Chain_Get>
10b304: 89 c1 mov %eax,%ecx
}
if ( the_object ) {
10b306: 83 c4 10 add $0x10,%esp
10b309: 85 c0 test %eax,%eax
10b30b: 74 1e je 10b32b <_Objects_Allocate+0x63>
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
10b30d: 0f b7 41 08 movzwl 0x8(%ecx),%eax
10b311: 0f b7 53 08 movzwl 0x8(%ebx),%edx
10b315: 29 d0 sub %edx,%eax
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
10b317: 0f b7 73 14 movzwl 0x14(%ebx),%esi
10b31b: 31 d2 xor %edx,%edx
10b31d: f7 f6 div %esi
information->inactive_per_block[ block ]--;
10b31f: c1 e0 02 shl $0x2,%eax
10b322: 03 43 30 add 0x30(%ebx),%eax
10b325: ff 08 decl (%eax)
information->inactive--;
10b327: 66 ff 4b 2c decw 0x2c(%ebx)
);
}
#endif
return the_object;
}
10b32b: 89 c8 mov %ecx,%eax
10b32d: 8d 65 f8 lea -0x8(%ebp),%esp
10b330: 5b pop %ebx
10b331: 5e pop %esi
10b332: c9 leave
10b333: c3 ret
0010b64c <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
10b64c: 55 push %ebp
10b64d: 89 e5 mov %esp,%ebp
10b64f: 57 push %edi
10b650: 56 push %esi
10b651: 53 push %ebx
10b652: 83 ec 0c sub $0xc,%esp
10b655: 8b 75 08 mov 0x8(%ebp),%esi
10b658: 8b 7d 0c mov 0xc(%ebp),%edi
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
10b65b: 31 db xor %ebx,%ebx
)
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
10b65d: 66 85 ff test %di,%di
10b660: 74 37 je 10b699 <_Objects_Get_information+0x4d>
/*
* This call implicitly validates the_api so we do not call
* _Objects_Is_api_valid above here.
*/
the_class_api_maximum = _Objects_API_maximum_class( the_api );
10b662: 83 ec 0c sub $0xc,%esp
10b665: 56 push %esi
10b666: e8 c5 41 00 00 call 10f830 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
10b66b: 83 c4 10 add $0x10,%esp
10b66e: 85 c0 test %eax,%eax
10b670: 74 27 je 10b699 <_Objects_Get_information+0x4d>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
10b672: 0f b7 ff movzwl %di,%edi
10b675: 39 c7 cmp %eax,%edi
10b677: 77 20 ja 10b699 <_Objects_Get_information+0x4d>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
10b679: 8b 04 b5 18 53 12 00 mov 0x125318(,%esi,4),%eax
10b680: 85 c0 test %eax,%eax
10b682: 74 15 je 10b699 <_Objects_Get_information+0x4d><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
10b684: 8b 1c b8 mov (%eax,%edi,4),%ebx
if ( !info )
10b687: 85 db test %ebx,%ebx
10b689: 74 0e je 10b699 <_Objects_Get_information+0x4d><== NEVER TAKEN
* Thus we may have 0 local instances and still have a valid object
* pointer.
*/
#if !defined(RTEMS_MULTIPROCESSING)
if ( info->maximum == 0 )
return NULL;
10b68b: 31 c0 xor %eax,%eax
10b68d: 66 83 7b 10 00 cmpw $0x0,0x10(%ebx)
10b692: 0f 95 c0 setne %al
10b695: f7 d8 neg %eax
10b697: 21 c3 and %eax,%ebx
#endif
return info;
}
10b699: 89 d8 mov %ebx,%eax
10b69b: 8d 65 f4 lea -0xc(%ebp),%esp
10b69e: 5b pop %ebx
10b69f: 5e pop %esi
10b6a0: 5f pop %edi
10b6a1: c9 leave
10b6a2: c3 ret
00118ab0 <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
118ab0: 55 push %ebp
118ab1: 89 e5 mov %esp,%ebp
118ab3: 53 push %ebx
118ab4: 8b 55 08 mov 0x8(%ebp),%edx
118ab7: 8b 4d 10 mov 0x10(%ebp),%ecx
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
118aba: b8 01 00 00 00 mov $0x1,%eax
118abf: 2b 42 08 sub 0x8(%edx),%eax
118ac2: 03 45 0c add 0xc(%ebp),%eax
if ( information->maximum >= index ) {
118ac5: 0f b7 5a 10 movzwl 0x10(%edx),%ebx
118ac9: 39 c3 cmp %eax,%ebx
118acb: 72 12 jb 118adf <_Objects_Get_no_protection+0x2f>
if ( (the_object = information->local_table[ index ]) != NULL ) {
118acd: 8b 52 1c mov 0x1c(%edx),%edx
118ad0: 8b 04 82 mov (%edx,%eax,4),%eax
118ad3: 85 c0 test %eax,%eax
118ad5: 74 08 je 118adf <_Objects_Get_no_protection+0x2f><== NEVER TAKEN
*location = OBJECTS_LOCAL;
118ad7: c7 01 00 00 00 00 movl $0x0,(%ecx)
return the_object;
118add: eb 08 jmp 118ae7 <_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;
118adf: c7 01 01 00 00 00 movl $0x1,(%ecx)
return NULL;
118ae5: 31 c0 xor %eax,%eax
}
118ae7: 5b pop %ebx
118ae8: c9 leave
118ae9: c3 ret
0010c868 <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
10c868: 55 push %ebp
10c869: 89 e5 mov %esp,%ebp
10c86b: 53 push %ebx
10c86c: 83 ec 14 sub $0x14,%esp
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
10c86f: 8b 45 08 mov 0x8(%ebp),%eax
10c872: 85 c0 test %eax,%eax
10c874: 75 08 jne 10c87e <_Objects_Id_to_name+0x16>
10c876: a1 d4 78 12 00 mov 0x1278d4,%eax
10c87b: 8b 40 08 mov 0x8(%eax),%eax
10c87e: 89 c2 mov %eax,%edx
10c880: c1 ea 18 shr $0x18,%edx
10c883: 83 e2 07 and $0x7,%edx
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
10c886: 8d 4a ff lea -0x1(%edx),%ecx
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
10c889: bb 03 00 00 00 mov $0x3,%ebx
10c88e: 83 f9 02 cmp $0x2,%ecx
10c891: 77 36 ja 10c8c9 <_Objects_Id_to_name+0x61>
10c893: eb 3b jmp 10c8d0 <_Objects_Id_to_name+0x68>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
10c895: 89 c1 mov %eax,%ecx
10c897: c1 e9 1b shr $0x1b,%ecx
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
10c89a: 8b 14 8a mov (%edx,%ecx,4),%edx
if ( !information )
10c89d: 85 d2 test %edx,%edx
10c89f: 74 28 je 10c8c9 <_Objects_Id_to_name+0x61><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
10c8a1: 80 7a 38 00 cmpb $0x0,0x38(%edx)
10c8a5: 75 22 jne 10c8c9 <_Objects_Id_to_name+0x61><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
10c8a7: 51 push %ecx
10c8a8: 8d 4d f4 lea -0xc(%ebp),%ecx
10c8ab: 51 push %ecx
10c8ac: 50 push %eax
10c8ad: 52 push %edx
10c8ae: e8 5d ff ff ff call 10c810 <_Objects_Get>
if ( !the_object )
10c8b3: 83 c4 10 add $0x10,%esp
10c8b6: 85 c0 test %eax,%eax
10c8b8: 74 0f je 10c8c9 <_Objects_Id_to_name+0x61>
return OBJECTS_INVALID_ID;
*name = the_object->name;
10c8ba: 8b 50 0c mov 0xc(%eax),%edx
10c8bd: 8b 45 0c mov 0xc(%ebp),%eax
10c8c0: 89 10 mov %edx,(%eax)
_Thread_Enable_dispatch();
10c8c2: e8 67 0a 00 00 call 10d32e <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
10c8c7: 31 db xor %ebx,%ebx
}
10c8c9: 89 d8 mov %ebx,%eax
10c8cb: 8b 5d fc mov -0x4(%ebp),%ebx
10c8ce: c9 leave
10c8cf: 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 ] )
10c8d0: 8b 14 95 84 73 12 00 mov 0x127384(,%edx,4),%edx
10c8d7: 85 d2 test %edx,%edx
10c8d9: 75 ba jne 10c895 <_Objects_Id_to_name+0x2d>
10c8db: eb ec jmp 10c8c9 <_Objects_Id_to_name+0x61>
0010e2bc <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
10e2bc: 55 push %ebp
10e2bd: 89 e5 mov %esp,%ebp
10e2bf: 57 push %edi
10e2c0: 56 push %esi
10e2c1: 53 push %ebx
10e2c2: 83 ec 30 sub $0x30,%esp
10e2c5: 8b 75 08 mov 0x8(%ebp),%esi
10e2c8: 8b 5d 14 mov 0x14(%ebp),%ebx
10e2cb: 8a 55 18 mov 0x18(%ebp),%dl
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
size_t length_out;
bool do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
10e2ce: 8d 45 e4 lea -0x1c(%ebp),%eax
RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd (
mqd_t id,
Objects_Locations *location
)
{
return (POSIX_Message_queue_Control_fd *) _Objects_Get(
10e2d1: 50 push %eax
10e2d2: 56 push %esi
10e2d3: 68 70 e2 12 00 push $0x12e270
10e2d8: 88 55 d4 mov %dl,-0x2c(%ebp)
10e2db: e8 f0 2a 00 00 call 110dd0 <_Objects_Get>
switch ( location ) {
10e2e0: 83 c4 10 add $0x10,%esp
10e2e3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10e2e7: 8a 55 d4 mov -0x2c(%ebp),%dl
10e2ea: 0f 85 aa 00 00 00 jne 10e39a <_POSIX_Message_queue_Receive_support+0xde>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
10e2f0: 8b 78 14 mov 0x14(%eax),%edi
10e2f3: 89 f9 mov %edi,%ecx
10e2f5: 83 e1 03 and $0x3,%ecx
10e2f8: 49 dec %ecx
10e2f9: 75 0a jne 10e305 <_POSIX_Message_queue_Receive_support+0x49>
_Thread_Enable_dispatch();
10e2fb: e8 ea 35 00 00 call 1118ea <_Thread_Enable_dispatch>
10e300: e9 95 00 00 00 jmp 10e39a <_POSIX_Message_queue_Receive_support+0xde>
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
10e305: 8b 40 10 mov 0x10(%eax),%eax
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
10e308: 8b 48 68 mov 0x68(%eax),%ecx
10e30b: 39 4d 10 cmp %ecx,0x10(%ebp)
10e30e: 73 15 jae 10e325 <_POSIX_Message_queue_Receive_support+0x69>
_Thread_Enable_dispatch();
10e310: e8 d5 35 00 00 call 1118ea <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
10e315: e8 da 8a 00 00 call 116df4 <__errno>
10e31a: c7 00 7a 00 00 00 movl $0x7a,(%eax)
10e320: e9 80 00 00 00 jmp 10e3a5 <_POSIX_Message_queue_Receive_support+0xe9>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
10e325: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp)
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
10e32c: 31 c9 xor %ecx,%ecx
10e32e: 84 d2 test %dl,%dl
10e330: 74 09 je 10e33b <_POSIX_Message_queue_Receive_support+0x7f><== NEVER TAKEN
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
10e332: 81 e7 00 40 00 00 and $0x4000,%edi
10e338: 0f 94 c1 sete %cl
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
10e33b: 52 push %edx
10e33c: 52 push %edx
10e33d: ff 75 1c pushl 0x1c(%ebp)
10e340: 0f b6 c9 movzbl %cl,%ecx
10e343: 51 push %ecx
10e344: 8d 55 e0 lea -0x20(%ebp),%edx
10e347: 52 push %edx
10e348: ff 75 0c pushl 0xc(%ebp)
10e34b: 56 push %esi
10e34c: 83 c0 1c add $0x1c,%eax
10e34f: 50 push %eax
10e350: e8 7f 1c 00 00 call 10ffd4 <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
10e355: 83 c4 20 add $0x20,%esp
10e358: e8 8d 35 00 00 call 1118ea <_Thread_Enable_dispatch>
*msg_prio =
_POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count);
10e35d: a1 e8 e2 12 00 mov 0x12e2e8,%eax
RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core(
CORE_message_queue_Submit_types priority
)
{
/* absolute value without a library dependency */
return ((priority >= 0) ? priority : -priority);
10e362: 8b 50 24 mov 0x24(%eax),%edx
10e365: c1 fa 1f sar $0x1f,%edx
10e368: 8b 48 24 mov 0x24(%eax),%ecx
10e36b: 31 d1 xor %edx,%ecx
10e36d: 89 0b mov %ecx,(%ebx)
10e36f: 29 13 sub %edx,(%ebx)
if ( !_Thread_Executing->Wait.return_code )
10e371: 83 78 34 00 cmpl $0x0,0x34(%eax)
10e375: 75 05 jne 10e37c <_POSIX_Message_queue_Receive_support+0xc0>
return length_out;
10e377: 8b 45 e0 mov -0x20(%ebp),%eax
10e37a: eb 2c jmp 10e3a8 <_POSIX_Message_queue_Receive_support+0xec>
rtems_set_errno_and_return_minus_one(
10e37c: e8 73 8a 00 00 call 116df4 <__errno>
10e381: 89 c3 mov %eax,%ebx
10e383: 83 ec 0c sub $0xc,%esp
10e386: a1 e8 e2 12 00 mov 0x12e2e8,%eax
10e38b: ff 70 34 pushl 0x34(%eax)
10e38e: e8 ed 01 00 00 call 10e580 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
10e393: 89 03 mov %eax,(%ebx)
10e395: 83 c4 10 add $0x10,%esp
10e398: eb 0b jmp 10e3a5 <_POSIX_Message_queue_Receive_support+0xe9>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
10e39a: e8 55 8a 00 00 call 116df4 <__errno>
10e39f: c7 00 09 00 00 00 movl $0x9,(%eax)
10e3a5: 83 c8 ff or $0xffffffff,%eax
}
10e3a8: 8d 65 f4 lea -0xc(%ebp),%esp
10e3ab: 5b pop %ebx
10e3ac: 5e pop %esi
10e3ad: 5f pop %edi
10e3ae: c9 leave
10e3af: c3 ret
0010e97c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
#include <rtems/posix/pthread.h>
void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(
Thread_Control *the_thread
)
{
10e97c: 55 push %ebp
10e97d: 89 e5 mov %esp,%ebp
10e97f: 83 ec 08 sub $0x8,%esp
10e982: 8b 55 08 mov 0x8(%ebp),%edx
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
10e985: 8b 82 ec 00 00 00 mov 0xec(%edx),%eax
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
10e98b: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax)
10e992: 75 2c jne 10e9c0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44><== NEVER TAKEN
10e994: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax)
10e99b: 75 23 jne 10e9c0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44>
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
10e99d: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax)
10e9a4: 74 1a je 10e9c0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10e9a6: a1 50 63 12 00 mov 0x126350,%eax
10e9ab: 48 dec %eax
10e9ac: a3 50 63 12 00 mov %eax,0x126350
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
10e9b1: 50 push %eax
10e9b2: 50 push %eax
10e9b3: 6a ff push $0xffffffff
10e9b5: 52 push %edx
10e9b6: e8 51 08 00 00 call 10f20c <_POSIX_Thread_Exit>
10e9bb: 83 c4 10 add $0x10,%esp
} else
_Thread_Enable_dispatch();
}
10e9be: c9 leave
10e9bf: c3 ret
10e9c0: c9 leave
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
} else
_Thread_Enable_dispatch();
10e9c1: e9 7c db ff ff jmp 10c542 <_Thread_Enable_dispatch>
0010fc04 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
10fc04: 55 push %ebp
10fc05: 89 e5 mov %esp,%ebp
10fc07: 57 push %edi
10fc08: 56 push %esi
10fc09: 53 push %ebx
10fc0a: 83 ec 28 sub $0x28,%esp
10fc0d: 8b 55 08 mov 0x8(%ebp),%edx
10fc10: 8b 5d 0c mov 0xc(%ebp),%ebx
10fc13: 8b 7d 10 mov 0x10(%ebp),%edi
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
10fc16: ff 33 pushl (%ebx)
10fc18: 89 55 e0 mov %edx,-0x20(%ebp)
10fc1b: e8 c4 ff ff ff call 10fbe4 <_POSIX_Priority_Is_valid>
10fc20: 83 c4 10 add $0x10,%esp
return EINVAL;
10fc23: be 16 00 00 00 mov $0x16,%esi
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
10fc28: 84 c0 test %al,%al
10fc2a: 8b 55 e0 mov -0x20(%ebp),%edx
10fc2d: 0f 84 a4 00 00 00 je 10fcd7 <_POSIX_Thread_Translate_sched_param+0xd3><== NEVER TAKEN
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
10fc33: c7 07 00 00 00 00 movl $0x0,(%edi)
*budget_callout = NULL;
10fc39: 8b 45 14 mov 0x14(%ebp),%eax
10fc3c: c7 00 00 00 00 00 movl $0x0,(%eax)
if ( policy == SCHED_OTHER ) {
10fc42: 85 d2 test %edx,%edx
10fc44: 75 0b jne 10fc51 <_POSIX_Thread_Translate_sched_param+0x4d>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
10fc46: c7 07 01 00 00 00 movl $0x1,(%edi)
10fc4c: e9 83 00 00 00 jmp 10fcd4 <_POSIX_Thread_Translate_sched_param+0xd0>
return 0;
}
if ( policy == SCHED_FIFO ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
10fc51: 31 f6 xor %esi,%esi
if ( policy == SCHED_OTHER ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
return 0;
}
if ( policy == SCHED_FIFO ) {
10fc53: 83 fa 01 cmp $0x1,%edx
10fc56: 74 7f je 10fcd7 <_POSIX_Thread_Translate_sched_param+0xd3>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
10fc58: 83 fa 02 cmp $0x2,%edx
10fc5b: 75 08 jne 10fc65 <_POSIX_Thread_Translate_sched_param+0x61>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
10fc5d: c7 07 02 00 00 00 movl $0x2,(%edi)
return 0;
10fc63: eb 72 jmp 10fcd7 <_POSIX_Thread_Translate_sched_param+0xd3>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
10fc65: be 16 00 00 00 mov $0x16,%esi
if ( policy == SCHED_RR ) {
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
return 0;
}
if ( policy == SCHED_SPORADIC ) {
10fc6a: 83 fa 04 cmp $0x4,%edx
10fc6d: 75 68 jne 10fcd7 <_POSIX_Thread_Translate_sched_param+0xd3>
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
10fc6f: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10fc73: 75 06 jne 10fc7b <_POSIX_Thread_Translate_sched_param+0x77>
10fc75: 83 7b 0c 00 cmpl $0x0,0xc(%ebx)
10fc79: 74 5c je 10fcd7 <_POSIX_Thread_Translate_sched_param+0xd3>
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
10fc7b: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10fc7f: 75 0b jne 10fc8c <_POSIX_Thread_Translate_sched_param+0x88>
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
10fc81: be 16 00 00 00 mov $0x16,%esi
if ( policy == SCHED_SPORADIC ) {
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
10fc86: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10fc8a: 74 4b je 10fcd7 <_POSIX_Thread_Translate_sched_param+0xd3>
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
10fc8c: 83 ec 0c sub $0xc,%esp
10fc8f: 8d 43 08 lea 0x8(%ebx),%eax
10fc92: 50 push %eax
10fc93: e8 0c de ff ff call 10daa4 <_Timespec_To_ticks>
10fc98: 89 45 e4 mov %eax,-0x1c(%ebp)
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
10fc9b: 8d 43 10 lea 0x10(%ebx),%eax
10fc9e: 89 04 24 mov %eax,(%esp)
10fca1: e8 fe dd ff ff call 10daa4 <_Timespec_To_ticks>
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
10fca6: 83 c4 10 add $0x10,%esp
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
10fca9: be 16 00 00 00 mov $0x16,%esi
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
10fcae: 39 45 e4 cmp %eax,-0x1c(%ebp)
10fcb1: 72 24 jb 10fcd7 <_POSIX_Thread_Translate_sched_param+0xd3>
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
10fcb3: 83 ec 0c sub $0xc,%esp
10fcb6: ff 73 04 pushl 0x4(%ebx)
10fcb9: e8 26 ff ff ff call 10fbe4 <_POSIX_Priority_Is_valid>
10fcbe: 83 c4 10 add $0x10,%esp
10fcc1: 84 c0 test %al,%al
10fcc3: 74 12 je 10fcd7 <_POSIX_Thread_Translate_sched_param+0xd3>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
10fcc5: c7 07 03 00 00 00 movl $0x3,(%edi)
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
10fccb: 8b 45 14 mov 0x14(%ebp),%eax
10fcce: c7 00 ed a7 10 00 movl $0x10a7ed,(%eax)
return 0;
10fcd4: 66 31 f6 xor %si,%si
}
return EINVAL;
}
10fcd7: 89 f0 mov %esi,%eax
10fcd9: 8d 65 f4 lea -0xc(%ebp),%esp
10fcdc: 5b pop %ebx
10fcdd: 5e pop %esi
10fcde: 5f pop %edi
10fcdf: c9 leave
10fce0: c3 ret
0010a4f0 <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
10a4f0: 55 push %ebp
10a4f1: 89 e5 mov %esp,%ebp
10a4f3: 57 push %edi
10a4f4: 56 push %esi
10a4f5: 53 push %ebx
10a4f6: 83 ec 6c sub $0x6c,%esp
uint32_t maximum;
posix_initialization_threads_table *user_threads;
pthread_t thread_id;
pthread_attr_t attr;
user_threads = Configuration_POSIX_API.User_initialization_threads_table;
10a4f9: 8b 3d 40 22 12 00 mov 0x122240,%edi
maximum = Configuration_POSIX_API.number_of_initialization_threads;
10a4ff: 8b 15 3c 22 12 00 mov 0x12223c,%edx
if ( !user_threads || maximum == 0 )
10a505: 85 d2 test %edx,%edx
10a507: 74 54 je 10a55d <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN
10a509: 85 ff test %edi,%edi
10a50b: 74 50 je 10a55d <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN
10a50d: 31 db xor %ebx,%ebx
for ( index=0 ; index < maximum ; index++ ) {
/*
* There is no way for these calls to fail in this situation.
*/
(void) pthread_attr_init( &attr );
10a50f: 8d 75 a4 lea -0x5c(%ebp),%esi
10a512: 83 ec 0c sub $0xc,%esp
10a515: 56 push %esi
10a516: 89 55 94 mov %edx,-0x6c(%ebp)
10a519: e8 c6 57 00 00 call 10fce4 <pthread_attr_init>
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
10a51e: 5a pop %edx
10a51f: 59 pop %ecx
10a520: 6a 02 push $0x2
10a522: 56 push %esi
10a523: e8 e4 57 00 00 call 10fd0c <pthread_attr_setinheritsched>
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
10a528: 59 pop %ecx
10a529: 58 pop %eax
10a52a: ff 74 df 04 pushl 0x4(%edi,%ebx,8)
10a52e: 56 push %esi
10a52f: e8 04 58 00 00 call 10fd38 <pthread_attr_setstacksize>
status = pthread_create(
10a534: 6a 00 push $0x0
10a536: ff 34 df pushl (%edi,%ebx,8)
10a539: 56 push %esi
10a53a: 8d 45 e4 lea -0x1c(%ebp),%eax
10a53d: 50 push %eax
10a53e: e8 e5 fc ff ff call 10a228 <pthread_create>
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
10a543: 83 c4 20 add $0x20,%esp
10a546: 85 c0 test %eax,%eax
10a548: 8b 55 94 mov -0x6c(%ebp),%edx
10a54b: 74 0b je 10a558 <_POSIX_Threads_Initialize_user_threads_body+0x68>
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
10a54d: 52 push %edx
10a54e: 50 push %eax
10a54f: 6a 01 push $0x1
10a551: 6a 02 push $0x2
10a553: e8 e8 1b 00 00 call 10c140 <_Internal_error_Occurred>
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
10a558: 43 inc %ebx
10a559: 39 d3 cmp %edx,%ebx
10a55b: 72 b5 jb 10a512 <_POSIX_Threads_Initialize_user_threads_body+0x22><== NEVER TAKEN
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
}
}
10a55d: 8d 65 f4 lea -0xc(%ebp),%esp
10a560: 5b pop %ebx
10a561: 5e pop %esi
10a562: 5f pop %edi
10a563: c9 leave
10a564: c3 ret
0010ed6f <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
10ed6f: 55 push %ebp
10ed70: 89 e5 mov %esp,%ebp
10ed72: 56 push %esi
10ed73: 53 push %ebx
10ed74: 8b 5d 0c mov 0xc(%ebp),%ebx
Thread_Control *the_thread;
POSIX_API_Control *api;
the_thread = argument;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10ed77: 8b b3 ec 00 00 00 mov 0xec(%ebx),%esi
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
10ed7d: 83 ec 0c sub $0xc,%esp
10ed80: 8d 86 98 00 00 00 lea 0x98(%esi),%eax
10ed86: 50 push %eax
10ed87: e8 7c 0d 00 00 call 10fb08 <_Timespec_To_ticks>
the_thread->cpu_time_budget = ticks;
10ed8c: 89 43 78 mov %eax,0x78(%ebx)
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
10ed8f: 0f b6 05 24 12 12 00 movzbl 0x121224,%eax
10ed96: 2b 86 88 00 00 00 sub 0x88(%esi),%eax
new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority );
the_thread->real_priority = new_priority;
10ed9c: 89 43 18 mov %eax,0x18(%ebx)
*/
#if 0
printk( "TSR %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
10ed9f: 83 c4 10 add $0x10,%esp
10eda2: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx)
10eda6: 75 12 jne 10edba <_POSIX_Threads_Sporadic_budget_TSR+0x4b><== NEVER TAKEN
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
10eda8: 39 43 14 cmp %eax,0x14(%ebx)
10edab: 76 0d jbe 10edba <_POSIX_Threads_Sporadic_budget_TSR+0x4b>
_Thread_Change_priority( the_thread, new_priority, true );
10edad: 52 push %edx
10edae: 6a 01 push $0x1
10edb0: 50 push %eax
10edb1: 53 push %ebx
10edb2: e8 0d d0 ff ff call 10bdc4 <_Thread_Change_priority>
10edb7: 83 c4 10 add $0x10,%esp
#endif
}
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
10edba: 83 ec 0c sub $0xc,%esp
10edbd: 8d 86 90 00 00 00 lea 0x90(%esi),%eax
10edc3: 50 push %eax
10edc4: e8 3f 0d 00 00 call 10fb08 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10edc9: 89 86 b4 00 00 00 mov %eax,0xb4(%esi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10edcf: 83 c4 10 add $0x10,%esp
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
10edd2: 81 c6 a8 00 00 00 add $0xa8,%esi
10edd8: 89 75 0c mov %esi,0xc(%ebp)
10eddb: c7 45 08 04 54 12 00 movl $0x125404,0x8(%ebp)
}
10ede2: 8d 65 f8 lea -0x8(%ebp),%esp
10ede5: 5b pop %ebx
10ede6: 5e pop %esi
10ede7: c9 leave
10ede8: e9 bf df ff ff jmp 10cdac <_Watchdog_Insert>
0010eded <_POSIX_Threads_Sporadic_budget_callout>:
* _POSIX_Threads_Sporadic_budget_callout
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
10eded: 55 push %ebp
10edee: 89 e5 mov %esp,%ebp
10edf0: 83 ec 08 sub $0x8,%esp
10edf3: 8b 45 08 mov 0x8(%ebp),%eax
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10edf6: 8b 88 ec 00 00 00 mov 0xec(%eax),%ecx
/*
* This will prevent the thread from consuming its entire "budget"
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
10edfc: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax)
10ee03: 0f b6 15 24 12 12 00 movzbl 0x121224,%edx
10ee0a: 2b 91 8c 00 00 00 sub 0x8c(%ecx),%edx
new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority);
the_thread->real_priority = new_priority;
10ee10: 89 50 18 mov %edx,0x18(%eax)
*/
#if 0
printk( "callout %d %d %d\n", the_thread->resource_count,
the_thread->current_priority, new_priority );
#endif
if ( the_thread->resource_count == 0 ) {
10ee13: 83 78 1c 00 cmpl $0x0,0x1c(%eax)
10ee17: 75 12 jne 10ee2b <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN
/*
* Make sure we are actually lowering it. If they have lowered it
* to logically lower than sched_ss_low_priority, then we do not want to
* change it.
*/
if ( the_thread->current_priority < new_priority ) {
10ee19: 39 50 14 cmp %edx,0x14(%eax)
10ee1c: 73 0d jae 10ee2b <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN
_Thread_Change_priority( the_thread, new_priority, true );
10ee1e: 51 push %ecx
10ee1f: 6a 01 push $0x1
10ee21: 52 push %edx
10ee22: 50 push %eax
10ee23: e8 9c cf ff ff call 10bdc4 <_Thread_Change_priority>
10ee28: 83 c4 10 add $0x10,%esp
#if 0
printk( "lower priority\n" );
#endif
}
}
}
10ee2b: c9 leave
10ee2c: c3 ret
0010a2b0 <_POSIX_Timer_TSR>:
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR(
Objects_Id timer __attribute__((unused)),
void *data)
{
10a2b0: 55 push %ebp
10a2b1: 89 e5 mov %esp,%ebp
10a2b3: 53 push %ebx
10a2b4: 83 ec 04 sub $0x4,%esp
10a2b7: 8b 5d 0c mov 0xc(%ebp),%ebx
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
10a2ba: ff 43 68 incl 0x68(%ebx)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
10a2bd: 83 7b 54 00 cmpl $0x0,0x54(%ebx)
10a2c1: 75 06 jne 10a2c9 <_POSIX_Timer_TSR+0x19>
10a2c3: 83 7b 58 00 cmpl $0x0,0x58(%ebx)
10a2c7: 74 34 je 10a2fd <_POSIX_Timer_TSR+0x4d> <== NEVER TAKEN
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
10a2c9: 83 ec 0c sub $0xc,%esp
10a2cc: 53 push %ebx
10a2cd: 68 b0 a2 10 00 push $0x10a2b0
10a2d2: ff 73 08 pushl 0x8(%ebx)
10a2d5: ff 73 64 pushl 0x64(%ebx)
10a2d8: 8d 43 10 lea 0x10(%ebx),%eax
10a2db: 50 push %eax
10a2dc: e8 df 56 00 00 call 10f9c0 <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
10a2e1: 83 c4 20 add $0x20,%esp
10a2e4: 84 c0 test %al,%al
10a2e6: 74 30 je 10a318 <_POSIX_Timer_TSR+0x68> <== NEVER TAKEN
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
10a2e8: 83 ec 0c sub $0xc,%esp
10a2eb: 8d 43 6c lea 0x6c(%ebx),%eax
10a2ee: 50 push %eax
10a2ef: e8 5c 14 00 00 call 10b750 <_TOD_Get>
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10a2f4: c6 43 3c 03 movb $0x3,0x3c(%ebx)
10a2f8: 83 c4 10 add $0x10,%esp
10a2fb: eb 04 jmp 10a301 <_POSIX_Timer_TSR+0x51>
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10a2fd: c6 43 3c 04 movb $0x4,0x3c(%ebx) <== NOT EXECUTED
/*
* The sending of the signal to the process running the handling function
* specified for that signal is simulated
*/
if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
10a301: 50 push %eax
10a302: 50 push %eax
10a303: ff 73 44 pushl 0x44(%ebx)
10a306: ff 73 38 pushl 0x38(%ebx)
10a309: e8 86 52 00 00 call 10f594 <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
10a30e: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
10a315: 83 c4 10 add $0x10,%esp
}
10a318: 8b 5d fc mov -0x4(%ebp),%ebx
10a31b: c9 leave
10a31c: c3 ret
00110ae8 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
110ae8: 55 push %ebp
110ae9: 89 e5 mov %esp,%ebp
110aeb: 57 push %edi
110aec: 56 push %esi
110aed: 53 push %ebx
110aee: 83 ec 68 sub $0x68,%esp
110af1: 8b 5d 0c mov 0xc(%ebp),%ebx
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
110af4: 6a 01 push $0x1
110af6: 0f b6 45 10 movzbl 0x10(%ebp),%eax
110afa: 50 push %eax
110afb: 8d 45 dc lea -0x24(%ebp),%eax
110afe: 50 push %eax
110aff: 53 push %ebx
110b00: ff 75 08 pushl 0x8(%ebp)
110b03: e8 8c 00 00 00 call 110b94 <_POSIX_signals_Clear_signals>
110b08: 83 c4 20 add $0x20,%esp
is_global, true ) )
return false;
110b0b: 31 c9 xor %ecx,%ecx
{
siginfo_t siginfo_struct;
sigset_t saved_signals_blocked;
Thread_Wait_information stored_thread_wait_information;
if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct,
110b0d: 84 c0 test %al,%al
110b0f: 74 78 je 110b89 <_POSIX_signals_Check_signal+0xa1>
#endif
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
110b11: 6b d3 0c imul $0xc,%ebx,%edx
110b14: 8b 82 a4 58 12 00 mov 0x1258a4(%edx),%eax
110b1a: 83 f8 01 cmp $0x1,%eax
110b1d: 74 6a je 110b89 <_POSIX_signals_Check_signal+0xa1><== NEVER TAKEN
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
110b1f: 8b 4d 08 mov 0x8(%ebp),%ecx
110b22: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx
110b28: 89 4d a4 mov %ecx,-0x5c(%ebp)
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
110b2b: 0b 8a a0 58 12 00 or 0x1258a0(%edx),%ecx
110b31: 8b 75 08 mov 0x8(%ebp),%esi
110b34: 89 8e d0 00 00 00 mov %ecx,0xd0(%esi)
/*
* We have to save the blocking information of the current wait queue
* because the signal handler may subsequently go on and put the thread
* on a wait queue, for its own purposes.
*/
memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait,
110b3a: 8d 7d b4 lea -0x4c(%ebp),%edi
110b3d: 8b 35 68 58 12 00 mov 0x125868,%esi
110b43: 83 c6 20 add $0x20,%esi
110b46: b9 0a 00 00 00 mov $0xa,%ecx
110b4b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
110b4d: 83 ba 9c 58 12 00 02 cmpl $0x2,0x12589c(%edx)
110b54: 75 09 jne 110b5f <_POSIX_signals_Check_signal+0x77>
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
110b56: 52 push %edx
110b57: 6a 00 push $0x0
110b59: 8d 55 dc lea -0x24(%ebp),%edx
110b5c: 52 push %edx
110b5d: eb 03 jmp 110b62 <_POSIX_signals_Check_signal+0x7a>
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
110b5f: 83 ec 0c sub $0xc,%esp
110b62: 53 push %ebx
110b63: ff d0 call *%eax
break;
110b65: 83 c4 10 add $0x10,%esp
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
110b68: 8b 3d 68 58 12 00 mov 0x125868,%edi
110b6e: 83 c7 20 add $0x20,%edi
110b71: 8d 75 b4 lea -0x4c(%ebp),%esi
110b74: b9 0a 00 00 00 mov $0xa,%ecx
110b79: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
110b7b: 8b 75 a4 mov -0x5c(%ebp),%esi
110b7e: 8b 4d 08 mov 0x8(%ebp),%ecx
110b81: 89 b1 d0 00 00 00 mov %esi,0xd0(%ecx)
return true;
110b87: b1 01 mov $0x1,%cl
}
110b89: 88 c8 mov %cl,%al
110b8b: 8d 65 f4 lea -0xc(%ebp),%esp
110b8e: 5b pop %ebx
110b8f: 5e pop %esi
110b90: 5f pop %edi
110b91: c9 leave
110b92: c3 ret
0011107c <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
11107c: 55 push %ebp
11107d: 89 e5 mov %esp,%ebp
11107f: 53 push %ebx
111080: 8b 4d 08 mov 0x8(%ebp),%ecx
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
111083: 9c pushf
111084: fa cli
111085: 5a pop %edx
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
111086: 6b c1 0c imul $0xc,%ecx,%eax
111089: 83 b8 9c 58 12 00 02 cmpl $0x2,0x12589c(%eax)
111090: 75 0e jne 1110a0 <_POSIX_signals_Clear_process_signals+0x24>
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
111092: 8d 98 98 5a 12 00 lea 0x125a98(%eax),%ebx
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
111098: 39 98 94 5a 12 00 cmp %ebx,0x125a94(%eax)
11109e: 75 0e jne 1110ae <_POSIX_signals_Clear_process_signals+0x32><== NEVER TAKEN
1110a0: 49 dec %ecx
1110a1: b8 fe ff ff ff mov $0xfffffffe,%eax
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
1110a6: d3 c0 rol %cl,%eax
1110a8: 21 05 90 5a 12 00 and %eax,0x125a90
}
_ISR_Enable( level );
1110ae: 52 push %edx
1110af: 9d popf
}
1110b0: 5b pop %ebx
1110b1: c9 leave
1110b2: c3 ret
0010ab58 <_POSIX_signals_Get_lowest>:
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
sigset_t set
)
{
10ab58: 55 push %ebp
10ab59: 89 e5 mov %esp,%ebp
10ab5b: 56 push %esi
10ab5c: 53 push %ebx
10ab5d: 8b 55 08 mov 0x8(%ebp),%edx
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10ab60: b8 1b 00 00 00 mov $0x1b,%eax
10ab65: bb 01 00 00 00 mov $0x1,%ebx
#include <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
10ab6a: 8d 48 ff lea -0x1(%eax),%ecx
10ab6d: 89 de mov %ebx,%esi
10ab6f: d3 e6 shl %cl,%esi
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
10ab71: 85 d6 test %edx,%esi
10ab73: 75 1e jne 10ab93 <_POSIX_signals_Get_lowest+0x3b><== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
10ab75: 40 inc %eax
10ab76: 83 f8 20 cmp $0x20,%eax
10ab79: 75 ef jne 10ab6a <_POSIX_signals_Get_lowest+0x12>
10ab7b: b0 01 mov $0x1,%al
10ab7d: bb 01 00 00 00 mov $0x1,%ebx
#include <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
int _POSIX_signals_Get_lowest(
10ab82: 8d 48 ff lea -0x1(%eax),%ecx
10ab85: 89 de mov %ebx,%esi
10ab87: d3 e6 shl %cl,%esi
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
10ab89: 85 d6 test %edx,%esi
10ab8b: 75 06 jne 10ab93 <_POSIX_signals_Get_lowest+0x3b>
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
10ab8d: 40 inc %eax
10ab8e: 83 f8 1b cmp $0x1b,%eax
10ab91: 75 ef jne 10ab82 <_POSIX_signals_Get_lowest+0x2a><== ALWAYS TAKEN
* a return 0. This routine will NOT be called unless a signal
* is pending in the set passed in.
*/
found_it:
return signo;
}
10ab93: 5b pop %ebx
10ab94: 5e pop %esi
10ab95: c9 leave
10ab96: c3 ret
00122140 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
122140: 55 push %ebp
122141: 89 e5 mov %esp,%ebp
122143: 57 push %edi
122144: 56 push %esi
122145: 53 push %ebx
122146: 83 ec 0c sub $0xc,%esp
122149: 8b 5d 08 mov 0x8(%ebp),%ebx
12214c: 8b 75 0c mov 0xc(%ebp),%esi
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
12214f: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax
122155: 8d 4e ff lea -0x1(%esi),%ecx
122158: ba 01 00 00 00 mov $0x1,%edx
12215d: d3 e2 shl %cl,%edx
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
12215f: 8b 4b 10 mov 0x10(%ebx),%ecx
122162: 89 cf mov %ecx,%edi
122164: 81 e7 00 80 00 10 and $0x10008000,%edi
12216a: 81 ff 00 80 00 10 cmp $0x10008000,%edi
122170: 75 58 jne 1221ca <_POSIX_signals_Unblock_thread+0x8a>
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
122172: 85 53 30 test %edx,0x30(%ebx)
122175: 75 12 jne 122189 <_POSIX_signals_Unblock_thread+0x49>
122177: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
12217d: f7 d0 not %eax
/*
* This should only be reached via pthread_kill().
*/
return false;
12217f: 31 ff xor %edi,%edi
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
122181: 85 c2 test %eax,%edx
122183: 0f 84 b0 00 00 00 je 122239 <_POSIX_signals_Unblock_thread+0xf9>
the_thread->Wait.return_code = EINTR;
122189: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx)
the_info = (siginfo_t *) the_thread->Wait.return_argument;
122190: 8b 43 28 mov 0x28(%ebx),%eax
if ( !info ) {
122193: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
122197: 75 12 jne 1221ab <_POSIX_signals_Unblock_thread+0x6b>
the_info->si_signo = signo;
122199: 89 30 mov %esi,(%eax)
the_info->si_code = SI_USER;
12219b: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax)
the_info->si_value.sival_int = 0;
1221a2: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
1221a9: eb 0c jmp 1221b7 <_POSIX_signals_Unblock_thread+0x77>
} else {
*the_info = *info;
1221ab: b9 03 00 00 00 mov $0x3,%ecx
1221b0: 89 c7 mov %eax,%edi
1221b2: 8b 75 10 mov 0x10(%ebp),%esi
1221b5: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
_Thread_queue_Extract_with_proxy( the_thread );
1221b7: 83 ec 0c sub $0xc,%esp
1221ba: 53 push %ebx
1221bb: e8 bc ed fe ff call 110f7c <_Thread_queue_Extract_with_proxy>
return true;
1221c0: 83 c4 10 add $0x10,%esp
1221c3: bf 01 00 00 00 mov $0x1,%edi
1221c8: eb 6f jmp 122239 <_POSIX_signals_Unblock_thread+0xf9>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
1221ca: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax
1221d0: f7 d0 not %eax
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
1221d2: 31 ff xor %edi,%edi
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
1221d4: 85 c2 test %eax,%edx
1221d6: 74 61 je 122239 <_POSIX_signals_Unblock_thread+0xf9>
* it is not blocked, THEN
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {
1221d8: f7 c1 00 00 00 10 test $0x10000000,%ecx
1221de: 74 3d je 12221d <_POSIX_signals_Unblock_thread+0xdd>
the_thread->Wait.return_code = EINTR;
1221e0: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx)
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
1221e7: f7 c1 e0 be 03 00 test $0x3bee0,%ecx
1221ed: 74 0b je 1221fa <_POSIX_signals_Unblock_thread+0xba>
_Thread_queue_Extract_with_proxy( the_thread );
1221ef: 83 ec 0c sub $0xc,%esp
1221f2: 53 push %ebx
1221f3: e8 84 ed fe ff call 110f7c <_Thread_queue_Extract_with_proxy>
1221f8: eb 1e jmp 122218 <_POSIX_signals_Unblock_thread+0xd8>
else if ( _States_Is_delaying(the_thread->current_state) ) {
1221fa: 80 e1 08 and $0x8,%cl
1221fd: 74 3a je 122239 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
1221ff: 83 ec 0c sub $0xc,%esp
122202: 8d 43 48 lea 0x48(%ebx),%eax
122205: 50 push %eax
122206: e8 81 f4 fe ff call 11168c <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
12220b: 58 pop %eax
12220c: 5a pop %edx
12220d: 68 f8 ff 03 10 push $0x1003fff8
122212: 53 push %ebx
122213: e8 2c e4 fe ff call 110644 <_Thread_Clear_state>
122218: 83 c4 10 add $0x10,%esp
12221b: eb 1c jmp 122239 <_POSIX_signals_Unblock_thread+0xf9>
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
12221d: 85 c9 test %ecx,%ecx
12221f: 75 18 jne 122239 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
122221: 83 3d d8 b9 12 00 00 cmpl $0x0,0x12b9d8
122228: 74 0f je 122239 <_POSIX_signals_Unblock_thread+0xf9>
12222a: 3b 1d dc b9 12 00 cmp 0x12b9dc,%ebx
122230: 75 07 jne 122239 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
122232: c6 05 e8 b9 12 00 01 movb $0x1,0x12b9e8
}
}
return false;
}
122239: 89 f8 mov %edi,%eax
12223b: 8d 65 f4 lea -0xc(%ebp),%esp
12223e: 5b pop %ebx
12223f: 5e pop %esi
122240: 5f pop %edi
122241: c9 leave
122242: c3 ret
0010b3a8 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
10b3a8: 55 push %ebp
10b3a9: 89 e5 mov %esp,%ebp
10b3ab: 53 push %ebx
10b3ac: 83 ec 18 sub $0x18,%esp
/*
* When we get here, the Timer is already off the chain so we do not
* have to worry about that -- hence no _Watchdog_Remove().
*/
the_period = _Rate_monotonic_Get( id, &location );
10b3af: 8d 45 f4 lea -0xc(%ebp),%eax
10b3b2: 50 push %eax
10b3b3: ff 75 08 pushl 0x8(%ebp)
10b3b6: 68 74 83 12 00 push $0x128374
10b3bb: e8 c8 1a 00 00 call 10ce88 <_Objects_Get>
10b3c0: 89 c3 mov %eax,%ebx
switch ( location ) {
10b3c2: 83 c4 10 add $0x10,%esp
10b3c5: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10b3c9: 75 64 jne 10b42f <_Rate_monotonic_Timeout+0x87><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
10b3cb: 8b 40 40 mov 0x40(%eax),%eax
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
10b3ce: f6 40 11 40 testb $0x40,0x11(%eax)
10b3d2: 74 18 je 10b3ec <_Rate_monotonic_Timeout+0x44>
10b3d4: 8b 53 08 mov 0x8(%ebx),%edx
10b3d7: 39 50 20 cmp %edx,0x20(%eax)
10b3da: 75 10 jne 10b3ec <_Rate_monotonic_Timeout+0x44>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
10b3dc: 52 push %edx
10b3dd: 52 push %edx
10b3de: 68 f8 ff 03 10 push $0x1003fff8
10b3e3: 50 push %eax
10b3e4: e8 2f 22 00 00 call 10d618 <_Thread_Clear_state>
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
10b3e9: 59 pop %ecx
10b3ea: eb 10 jmp 10b3fc <_Rate_monotonic_Timeout+0x54>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
10b3ec: 83 7b 38 01 cmpl $0x1,0x38(%ebx)
10b3f0: 75 2b jne 10b41d <_Rate_monotonic_Timeout+0x75>
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
10b3f2: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx)
_Rate_monotonic_Initiate_statistics( the_period );
10b3f9: 83 ec 0c sub $0xc,%esp
10b3fc: 53 push %ebx
10b3fd: e8 ec fa ff ff call 10aeee <_Rate_monotonic_Initiate_statistics>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b402: 8b 43 3c mov 0x3c(%ebx),%eax
10b405: 89 43 1c mov %eax,0x1c(%ebx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b408: 58 pop %eax
10b409: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
10b40a: 83 c3 10 add $0x10,%ebx
10b40d: 53 push %ebx
10b40e: 68 28 85 12 00 push $0x128528
10b413: e8 24 32 00 00 call 10e63c <_Watchdog_Insert>
10b418: 83 c4 10 add $0x10,%esp
10b41b: eb 07 jmp 10b424 <_Rate_monotonic_Timeout+0x7c>
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
10b41d: c7 43 38 04 00 00 00 movl $0x4,0x38(%ebx)
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10b424: a1 64 84 12 00 mov 0x128464,%eax
10b429: 48 dec %eax
10b42a: a3 64 84 12 00 mov %eax,0x128464
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
10b42f: 8b 5d fc mov -0x4(%ebp),%ebx
10b432: c9 leave
10b433: c3 ret
0010ba0c <_Scheduler_priority_Block>:
#include <rtems/score/thread.h>
void _Scheduler_priority_Block(
Thread_Control *the_thread
)
{
10ba0c: 55 push %ebp
10ba0d: 89 e5 mov %esp,%ebp
10ba0f: 56 push %esi
10ba10: 53 push %ebx
10ba11: 8b 55 08 mov 0x8(%ebp),%edx
)
{
Scheduler_priority_Per_thread *sched_info;
Chain_Control *ready;
sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info;
10ba14: 8b 8a 8c 00 00 00 mov 0x8c(%edx),%ecx
ready = sched_info->ready_chain;
10ba1a: 8b 01 mov (%ecx),%eax
if ( _Chain_Has_only_one_node( ready ) ) {
10ba1c: 8b 58 08 mov 0x8(%eax),%ebx
10ba1f: 39 18 cmp %ebx,(%eax)
10ba21: 75 32 jne 10ba55 <_Scheduler_priority_Block+0x49>
Chain_Node *tail = _Chain_Tail( the_chain );
10ba23: 8d 58 04 lea 0x4(%eax),%ebx
10ba26: 89 18 mov %ebx,(%eax)
head->next = tail;
head->previous = NULL;
10ba28: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
tail->previous = head;
10ba2f: 89 40 08 mov %eax,0x8(%eax)
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor &= the_priority_map->block_minor;
10ba32: 8b 59 04 mov 0x4(%ecx),%ebx
10ba35: 66 8b 03 mov (%ebx),%ax
10ba38: 66 23 41 0e and 0xe(%ecx),%ax
10ba3c: 66 89 03 mov %ax,(%ebx)
if ( *the_priority_map->minor == 0 )
10ba3f: 66 85 c0 test %ax,%ax
10ba42: 75 1b jne 10ba5f <_Scheduler_priority_Block+0x53>
_Priority_Major_bit_map &= the_priority_map->block_major;
10ba44: 66 a1 78 58 12 00 mov 0x125878,%ax
10ba4a: 23 41 0c and 0xc(%ecx),%eax
10ba4d: 66 a3 78 58 12 00 mov %ax,0x125878
10ba53: eb 0a jmp 10ba5f <_Scheduler_priority_Block+0x53>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
10ba55: 8b 0a mov (%edx),%ecx
previous = the_node->previous;
10ba57: 8b 42 04 mov 0x4(%edx),%eax
next->previous = previous;
10ba5a: 89 41 04 mov %eax,0x4(%ecx)
previous->next = next;
10ba5d: 89 08 mov %ecx,(%eax)
_Scheduler_priority_Ready_queue_extract( the_thread );
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
10ba5f: 3b 15 6c 58 12 00 cmp 0x12586c,%edx
10ba65: 75 43 jne 10baaa <_Scheduler_priority_Block+0x9e>
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{
Priority_bit_map_Control minor;
Priority_bit_map_Control major;
_Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
10ba67: 66 8b 35 78 58 12 00 mov 0x125878,%si
10ba6e: 31 c9 xor %ecx,%ecx
10ba70: 89 cb mov %ecx,%ebx
10ba72: 66 0f bc de bsf %si,%bx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10ba76: 0f b7 db movzwl %bx,%ebx
10ba79: 66 8b b4 1b 7c 58 12 mov 0x12587c(%ebx,%ebx,1),%si
10ba80: 00
10ba81: 66 0f bc ce bsf %si,%cx
return (_Priority_Bits_index( major ) << 4) +
10ba85: c1 e3 04 shl $0x4,%ebx
10ba88: 0f b7 c9 movzwl %cx,%ecx
10ba8b: 8d 04 0b lea (%ebx,%ecx,1),%eax
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
10ba8e: 6b c0 0c imul $0xc,%eax,%eax
10ba91: 03 05 50 11 12 00 add 0x121150,%eax
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
10ba97: 8b 18 mov (%eax),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10ba99: 83 c0 04 add $0x4,%eax
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
10ba9c: 31 c9 xor %ecx,%ecx
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
10ba9e: 39 c3 cmp %eax,%ebx
10baa0: 74 02 je 10baa4 <_Scheduler_priority_Block+0x98><== NEVER TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
10baa2: 89 d9 mov %ebx,%ecx
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10baa4: 89 0d 6c 58 12 00 mov %ecx,0x12586c
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
10baaa: 3b 15 68 58 12 00 cmp 0x125868,%edx
10bab0: 75 07 jne 10bab9 <_Scheduler_priority_Block+0xad>
_Thread_Dispatch_necessary = true;
10bab2: c6 05 74 58 12 00 01 movb $0x1,0x125874
}
10bab9: 5b pop %ebx
10baba: 5e pop %esi
10babb: c9 leave
10babc: c3 ret
0010bc0c <_Scheduler_priority_Schedule>:
#include <rtems/system.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Schedule(void)
{
10bc0c: 55 push %ebp
10bc0d: 89 e5 mov %esp,%ebp
10bc0f: 53 push %ebx
RTEMS_INLINE_ROUTINE Priority_Control _Priority_bit_map_Get_highest( void )
{
Priority_bit_map_Control minor;
Priority_bit_map_Control major;
_Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
10bc10: 66 8b 1d 78 58 12 00 mov 0x125878,%bx
10bc17: 31 d2 xor %edx,%edx
10bc19: 89 d1 mov %edx,%ecx
10bc1b: 66 0f bc cb bsf %bx,%cx
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
10bc1f: 0f b7 c9 movzwl %cx,%ecx
10bc22: 66 8b 9c 09 7c 58 12 mov 0x12587c(%ecx,%ecx,1),%bx
10bc29: 00
10bc2a: 66 0f bc d3 bsf %bx,%dx
return (_Priority_Bits_index( major ) << 4) +
10bc2e: c1 e1 04 shl $0x4,%ecx
10bc31: 0f b7 d2 movzwl %dx,%edx
10bc34: 8d 04 11 lea (%ecx,%edx,1),%eax
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
10bc37: 6b c0 0c imul $0xc,%eax,%eax
10bc3a: 03 05 50 11 12 00 add 0x121150,%eax
_Scheduler_priority_Schedule_body();
}
10bc40: 8b 08 mov (%eax),%ecx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10bc42: 83 c0 04 add $0x4,%eax
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
10bc45: 31 d2 xor %edx,%edx
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
10bc47: 39 c1 cmp %eax,%ecx
10bc49: 74 02 je 10bc4d <_Scheduler_priority_Schedule+0x41><== NEVER TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
10bc4b: 89 ca mov %ecx,%edx
*
* @param[in] the_thread - pointer to thread
*/
RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void)
{
_Thread_Heir = _Scheduler_priority_Ready_queue_first(
10bc4d: 89 15 6c 58 12 00 mov %edx,0x12586c
10bc53: 5b pop %ebx
10bc54: c9 leave
10bc55: c3 ret
0010acb8 <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
10acb8: 55 push %ebp
10acb9: 89 e5 mov %esp,%ebp
10acbb: 56 push %esi
10acbc: 53 push %ebx
10acbd: 8b 4d 08 mov 0x8(%ebp),%ecx
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
10acc0: 8b 35 b4 4a 12 00 mov 0x124ab4,%esi
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
10acc6: 31 db xor %ebx,%ebx
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
10acc8: 85 c9 test %ecx,%ecx
10acca: 74 57 je 10ad23 <_TOD_Validate+0x6b> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
10accc: b8 40 42 0f 00 mov $0xf4240,%eax
10acd1: 31 d2 xor %edx,%edx
10acd3: f7 f6 div %esi
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
10acd5: 39 41 18 cmp %eax,0x18(%ecx)
10acd8: 73 49 jae 10ad23 <_TOD_Validate+0x6b>
(the_tod->ticks >= ticks_per_second) ||
10acda: 83 79 14 3b cmpl $0x3b,0x14(%ecx)
10acde: 77 43 ja 10ad23 <_TOD_Validate+0x6b>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
10ace0: 83 79 10 3b cmpl $0x3b,0x10(%ecx)
10ace4: 77 3d ja 10ad23 <_TOD_Validate+0x6b>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
10ace6: 83 79 0c 17 cmpl $0x17,0xc(%ecx)
10acea: 77 37 ja 10ad23 <_TOD_Validate+0x6b>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
10acec: 8b 41 04 mov 0x4(%ecx),%eax
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
10acef: 85 c0 test %eax,%eax
10acf1: 74 30 je 10ad23 <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->month == 0) ||
10acf3: 83 f8 0c cmp $0xc,%eax
10acf6: 77 2b ja 10ad23 <_TOD_Validate+0x6b>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10acf8: 8b 31 mov (%ecx),%esi
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
10acfa: 81 fe c3 07 00 00 cmp $0x7c3,%esi
10ad00: 76 21 jbe 10ad23 <_TOD_Validate+0x6b>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
10ad02: 8b 51 08 mov 0x8(%ecx),%edx
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
10ad05: 85 d2 test %edx,%edx
10ad07: 74 1a je 10ad23 <_TOD_Validate+0x6b> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
10ad09: 83 e6 03 and $0x3,%esi
10ad0c: 75 09 jne 10ad17 <_TOD_Validate+0x5f>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
10ad0e: 8b 04 85 a4 1c 12 00 mov 0x121ca4(,%eax,4),%eax
10ad15: eb 07 jmp 10ad1e <_TOD_Validate+0x66>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
10ad17: 8b 04 85 70 1c 12 00 mov 0x121c70(,%eax,4),%eax
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
10ad1e: 39 c2 cmp %eax,%edx
10ad20: 0f 96 c3 setbe %bl
if ( the_tod->day > days_in_month )
return false;
return true;
}
10ad23: 88 d8 mov %bl,%al
10ad25: 5b pop %ebx
10ad26: 5e pop %esi
10ad27: c9 leave
10ad28: c3 ret
0010bdc4 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
10bdc4: 55 push %ebp
10bdc5: 89 e5 mov %esp,%ebp
10bdc7: 57 push %edi
10bdc8: 56 push %esi
10bdc9: 53 push %ebx
10bdca: 83 ec 28 sub $0x28,%esp
10bdcd: 8b 5d 08 mov 0x8(%ebp),%ebx
10bdd0: 8b 75 0c mov 0xc(%ebp),%esi
10bdd3: 8a 45 10 mov 0x10(%ebp),%al
10bdd6: 88 45 e7 mov %al,-0x19(%ebp)
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
10bdd9: 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 );
10bddc: 53 push %ebx
10bddd: e8 5e 0b 00 00 call 10c940 <_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 )
10bde2: 83 c4 10 add $0x10,%esp
10bde5: 39 73 14 cmp %esi,0x14(%ebx)
10bde8: 74 0c je 10bdf6 <_Thread_Change_priority+0x32>
_Thread_Set_priority( the_thread, new_priority );
10bdea: 50 push %eax
10bdeb: 50 push %eax
10bdec: 56 push %esi
10bded: 53 push %ebx
10bdee: e8 fd 0a 00 00 call 10c8f0 <_Thread_Set_priority>
10bdf3: 83 c4 10 add $0x10,%esp
_ISR_Disable( level );
10bdf6: 9c pushf
10bdf7: fa cli
10bdf8: 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;
10bdf9: 8b 43 10 mov 0x10(%ebx),%eax
if ( state != STATES_TRANSIENT ) {
10bdfc: 83 f8 04 cmp $0x4,%eax
10bdff: 74 2b je 10be2c <_Thread_Change_priority+0x68>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
10be01: 83 e7 04 and $0x4,%edi
10be04: 75 08 jne 10be0e <_Thread_Change_priority+0x4a><== NEVER TAKEN
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
10be06: 89 c2 mov %eax,%edx
10be08: 83 e2 fb and $0xfffffffb,%edx
10be0b: 89 53 10 mov %edx,0x10(%ebx)
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
10be0e: 56 push %esi
10be0f: 9d popf
if ( _States_Is_waiting_on_thread_queue( state ) ) {
10be10: a9 e0 be 03 00 test $0x3bee0,%eax
10be15: 74 65 je 10be7c <_Thread_Change_priority+0xb8>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
10be17: 89 5d 0c mov %ebx,0xc(%ebp)
10be1a: 8b 43 44 mov 0x44(%ebx),%eax
10be1d: 89 45 08 mov %eax,0x8(%ebp)
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
10be20: 8d 65 f4 lea -0xc(%ebp),%esp
10be23: 5b pop %ebx
10be24: 5e pop %esi
10be25: 5f pop %edi
10be26: 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 );
10be27: e9 3c 0a 00 00 jmp 10c868 <_Thread_queue_Requeue>
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
10be2c: 83 e7 04 and $0x4,%edi
10be2f: 75 26 jne 10be57 <_Thread_Change_priority+0x93><== 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 );
10be31: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
if ( prepend_it )
10be38: 80 7d e7 00 cmpb $0x0,-0x19(%ebp)
10be3c: 74 0c je 10be4a <_Thread_Change_priority+0x86>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
10be3e: 83 ec 0c sub $0xc,%esp
10be41: 53 push %ebx
10be42: ff 15 78 11 12 00 call *0x121178
10be48: eb 0a jmp 10be54 <_Thread_Change_priority+0x90>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
10be4a: 83 ec 0c sub $0xc,%esp
10be4d: 53 push %ebx
10be4e: ff 15 74 11 12 00 call *0x121174
10be54: 83 c4 10 add $0x10,%esp
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
10be57: 56 push %esi
10be58: 9d popf
10be59: fa cli
* This kernel routine implements the scheduling decision logic for
* the scheduler. It does NOT dispatch.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void )
{
_Scheduler.Operations.schedule();
10be5a: ff 15 58 11 12 00 call *0x121158
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
10be60: a1 68 58 12 00 mov 0x125868,%eax
* We altered the set of thread priorities. So let's figure out
* who is the heir and if we need to switch to them.
*/
_Scheduler_Schedule();
if ( !_Thread_Is_executing_also_the_heir() &&
10be65: 3b 05 6c 58 12 00 cmp 0x12586c,%eax
10be6b: 74 0d je 10be7a <_Thread_Change_priority+0xb6>
10be6d: 80 78 74 00 cmpb $0x0,0x74(%eax)
10be71: 74 07 je 10be7a <_Thread_Change_priority+0xb6>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
10be73: c6 05 74 58 12 00 01 movb $0x1,0x125874
_ISR_Enable( level );
10be7a: 56 push %esi
10be7b: 9d popf
}
10be7c: 8d 65 f4 lea -0xc(%ebp),%esp
10be7f: 5b pop %ebx
10be80: 5e pop %esi
10be81: 5f pop %edi
10be82: c9 leave
10be83: c3 ret
0010c028 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10c028: 55 push %ebp
10c029: 89 e5 mov %esp,%ebp
10c02b: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10c02e: 8d 45 f4 lea -0xc(%ebp),%eax
10c031: 50 push %eax
10c032: ff 75 08 pushl 0x8(%ebp)
10c035: e8 82 01 00 00 call 10c1bc <_Thread_Get>
switch ( location ) {
10c03a: 83 c4 10 add $0x10,%esp
10c03d: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10c041: 75 1b jne 10c05e <_Thread_Delay_ended+0x36><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
10c043: 52 push %edx
10c044: 52 push %edx
10c045: 68 18 00 00 10 push $0x10000018
10c04a: 50 push %eax
10c04b: e8 34 fe ff ff call 10be84 <_Thread_Clear_state>
10c050: a1 40 53 12 00 mov 0x125340,%eax
10c055: 48 dec %eax
10c056: a3 40 53 12 00 mov %eax,0x125340
10c05b: 83 c4 10 add $0x10,%esp
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
10c05e: c9 leave
10c05f: c3 ret
0010c060 <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
10c060: 55 push %ebp
10c061: 89 e5 mov %esp,%ebp
10c063: 57 push %edi
10c064: 56 push %esi
10c065: 53 push %ebx
10c066: 83 ec 1c sub $0x1c,%esp
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
10c069: 8b 1d 68 58 12 00 mov 0x125868,%ebx
_ISR_Disable( level );
10c06f: 9c pushf
10c070: fa cli
10c071: 58 pop %eax
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
10c072: 8d 7d d8 lea -0x28(%ebp),%edi
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10c075: e9 f9 00 00 00 jmp 10c173 <_Thread_Dispatch+0x113>
heir = _Thread_Heir;
10c07a: 8b 35 6c 58 12 00 mov 0x12586c,%esi
_Thread_Dispatch_disable_level = 1;
10c080: c7 05 40 53 12 00 01 movl $0x1,0x125340
10c087: 00 00 00
_Thread_Dispatch_necessary = false;
10c08a: c6 05 74 58 12 00 00 movb $0x0,0x125874
_Thread_Executing = heir;
10c091: 89 35 68 58 12 00 mov %esi,0x125868
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
10c097: 39 de cmp %ebx,%esi
10c099: 0f 84 e2 00 00 00 je 10c181 <_Thread_Dispatch+0x121>
*/
#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 )
10c09f: 83 7e 7c 01 cmpl $0x1,0x7c(%esi)
10c0a3: 75 09 jne 10c0ae <_Thread_Dispatch+0x4e>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
10c0a5: 8b 15 10 53 12 00 mov 0x125310,%edx
10c0ab: 89 56 78 mov %edx,0x78(%esi)
_ISR_Enable( level );
10c0ae: 50 push %eax
10c0af: 9d popf
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
10c0b0: 83 ec 0c sub $0xc,%esp
10c0b3: 8d 45 e0 lea -0x20(%ebp),%eax
10c0b6: 50 push %eax
10c0b7: e8 5c 34 00 00 call 10f518 <_TOD_Get_uptime>
_Timestamp_Subtract(
10c0bc: 83 c4 0c add $0xc,%esp
10c0bf: 57 push %edi
10c0c0: 8d 45 e0 lea -0x20(%ebp),%eax
10c0c3: 50 push %eax
10c0c4: 68 f0 53 12 00 push $0x1253f0
10c0c9: e8 72 0a 00 00 call 10cb40 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
10c0ce: 58 pop %eax
10c0cf: 5a pop %edx
10c0d0: 57 push %edi
10c0d1: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax
10c0d7: 50 push %eax
10c0d8: e8 33 0a 00 00 call 10cb10 <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
10c0dd: 8b 45 e0 mov -0x20(%ebp),%eax
10c0e0: 8b 55 e4 mov -0x1c(%ebp),%edx
10c0e3: a3 f0 53 12 00 mov %eax,0x1253f0
10c0e8: 89 15 f4 53 12 00 mov %edx,0x1253f4
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
10c0ee: a1 c8 53 12 00 mov 0x1253c8,%eax
10c0f3: 83 c4 10 add $0x10,%esp
10c0f6: 85 c0 test %eax,%eax
10c0f8: 74 10 je 10c10a <_Thread_Dispatch+0xaa> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
10c0fa: 8b 10 mov (%eax),%edx
10c0fc: 89 93 e4 00 00 00 mov %edx,0xe4(%ebx)
*_Thread_libc_reent = heir->libc_reent;
10c102: 8b 96 e4 00 00 00 mov 0xe4(%esi),%edx
10c108: 89 10 mov %edx,(%eax)
}
_User_extensions_Thread_switch( executing, heir );
10c10a: 51 push %ecx
10c10b: 51 push %ecx
10c10c: 56 push %esi
10c10d: 53 push %ebx
10c10e: e8 65 0c 00 00 call 10cd78 <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
10c113: 58 pop %eax
10c114: 5a pop %edx
10c115: 81 c6 c8 00 00 00 add $0xc8,%esi
10c11b: 56 push %esi
10c11c: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax
10c122: 50 push %eax
10c123: e8 28 0f 00 00 call 10d050 <_CPU_Context_switch>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
10c128: 83 c4 10 add $0x10,%esp
10c12b: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx)
10c132: 74 36 je 10c16a <_Thread_Dispatch+0x10a>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
10c134: a1 c4 53 12 00 mov 0x1253c4,%eax
10c139: 39 c3 cmp %eax,%ebx
10c13b: 74 2d je 10c16a <_Thread_Dispatch+0x10a>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
10c13d: 85 c0 test %eax,%eax
10c13f: 74 11 je 10c152 <_Thread_Dispatch+0xf2>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
10c141: 83 ec 0c sub $0xc,%esp
10c144: 05 e0 00 00 00 add $0xe0,%eax
10c149: 50 push %eax
10c14a: e8 35 0f 00 00 call 10d084 <_CPU_Context_save_fp>
10c14f: 83 c4 10 add $0x10,%esp
_Context_Restore_fp( &executing->fp_context );
10c152: 83 ec 0c sub $0xc,%esp
10c155: 8d 83 e0 00 00 00 lea 0xe0(%ebx),%eax
10c15b: 50 push %eax
10c15c: e8 2d 0f 00 00 call 10d08e <_CPU_Context_restore_fp>
_Thread_Allocated_fp = executing;
10c161: 89 1d c4 53 12 00 mov %ebx,0x1253c4
10c167: 83 c4 10 add $0x10,%esp
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
10c16a: 8b 1d 68 58 12 00 mov 0x125868,%ebx
_ISR_Disable( level );
10c170: 9c pushf
10c171: fa cli
10c172: 58 pop %eax
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
10c173: 8a 15 74 58 12 00 mov 0x125874,%dl
10c179: 84 d2 test %dl,%dl
10c17b: 0f 85 f9 fe ff ff jne 10c07a <_Thread_Dispatch+0x1a>
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
10c181: c7 05 40 53 12 00 00 movl $0x0,0x125340
10c188: 00 00 00
_ISR_Enable( level );
10c18b: 50 push %eax
10c18c: 9d popf
_API_extensions_Run_postswitch();
10c18d: e8 49 e7 ff ff call 10a8db <_API_extensions_Run_postswitch>
}
10c192: 8d 65 f4 lea -0xc(%ebp),%esp
10c195: 5b pop %ebx
10c196: 5e pop %esi
10c197: 5f pop %edi
10c198: c9 leave
10c199: c3 ret
00110f30 <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
110f30: 55 push %ebp
110f31: 89 e5 mov %esp,%ebp
110f33: 53 push %ebx
110f34: 83 ec 14 sub $0x14,%esp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
110f37: 8b 1d 68 58 12 00 mov 0x125868,%ebx
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
110f3d: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax
_ISR_Set_level(level);
110f43: 85 c0 test %eax,%eax
110f45: 74 03 je 110f4a <_Thread_Handler+0x1a>
110f47: fa cli
110f48: eb 01 jmp 110f4b <_Thread_Handler+0x1b>
110f4a: fb sti
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
doneCons = doneConstructors;
110f4b: a0 00 50 12 00 mov 0x125000,%al
110f50: 88 45 f7 mov %al,-0x9(%ebp)
doneConstructors = 1;
110f53: c6 05 00 50 12 00 01 movb $0x1,0x125000
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
110f5a: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx)
110f61: 74 24 je 110f87 <_Thread_Handler+0x57>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
110f63: a1 c4 53 12 00 mov 0x1253c4,%eax
110f68: 39 c3 cmp %eax,%ebx
110f6a: 74 1b je 110f87 <_Thread_Handler+0x57>
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
110f6c: 85 c0 test %eax,%eax
110f6e: 74 11 je 110f81 <_Thread_Handler+0x51>
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
110f70: 83 ec 0c sub $0xc,%esp
110f73: 05 e0 00 00 00 add $0xe0,%eax
110f78: 50 push %eax
110f79: e8 06 c1 ff ff call 10d084 <_CPU_Context_save_fp>
110f7e: 83 c4 10 add $0x10,%esp
_Thread_Allocated_fp = executing;
110f81: 89 1d c4 53 12 00 mov %ebx,0x1253c4
/*
* 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 );
110f87: 83 ec 0c sub $0xc,%esp
110f8a: 53 push %ebx
110f8b: e8 98 bc ff ff call 10cc28 <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
110f90: e8 05 b2 ff ff call 10c19a <_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) */ {
110f95: 83 c4 10 add $0x10,%esp
110f98: 80 7d f7 00 cmpb $0x0,-0x9(%ebp)
110f9c: 75 05 jne 110fa3 <_Thread_Handler+0x73>
INIT_NAME ();
110f9e: e8 2d c7 00 00 call 11d6d0 <__start_set_sysctl_set>
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
110fa3: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax
110fa9: 85 c0 test %eax,%eax
110fab: 75 0b jne 110fb8 <_Thread_Handler+0x88>
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
110fad: 83 ec 0c sub $0xc,%esp
110fb0: ff b3 9c 00 00 00 pushl 0x9c(%ebx)
110fb6: eb 0c jmp 110fc4 <_Thread_Handler+0x94>
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
110fb8: 48 dec %eax
110fb9: 75 15 jne 110fd0 <_Thread_Handler+0xa0> <== NEVER TAKEN
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
110fbb: 83 ec 0c sub $0xc,%esp
110fbe: ff b3 98 00 00 00 pushl 0x98(%ebx)
110fc4: ff 93 90 00 00 00 call *0x90(%ebx)
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
110fca: 89 43 28 mov %eax,0x28(%ebx)
110fcd: 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 );
110fd0: 83 ec 0c sub $0xc,%esp
110fd3: 53 push %ebx
110fd4: e8 80 bc ff ff call 10cc59 <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
110fd9: 83 c4 0c add $0xc,%esp
110fdc: 6a 05 push $0x5
110fde: 6a 01 push $0x1
110fe0: 6a 00 push $0x0
110fe2: e8 51 a2 ff ff call 10b238 <_Internal_error_Occurred>
0010c22c <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
10c22c: 55 push %ebp
10c22d: 89 e5 mov %esp,%ebp
10c22f: 57 push %edi
10c230: 56 push %esi
10c231: 53 push %ebx
10c232: 83 ec 1c sub $0x1c,%esp
10c235: 8b 5d 0c mov 0xc(%ebp),%ebx
10c238: 8b 4d 10 mov 0x10(%ebp),%ecx
10c23b: 8b 75 14 mov 0x14(%ebp),%esi
10c23e: 8a 55 18 mov 0x18(%ebp),%dl
10c241: 8a 45 20 mov 0x20(%ebp),%al
10c244: 88 45 e7 mov %al,-0x19(%ebp)
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
10c247: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx)
10c24e: 00 00 00
10c251: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx)
10c258: 00 00 00
extensions_area = NULL;
the_thread->libc_reent = NULL;
10c25b: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10c262: 00 00 00
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
10c265: 85 c9 test %ecx,%ecx
10c267: 75 31 jne 10c29a <_Thread_Initialize+0x6e>
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
10c269: 57 push %edi
10c26a: 57 push %edi
10c26b: 56 push %esi
10c26c: 53 push %ebx
10c26d: 88 55 e0 mov %dl,-0x20(%ebp)
10c270: e8 fb 06 00 00 call 10c970 <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
10c275: 83 c4 10 add $0x10,%esp
10c278: 39 f0 cmp %esi,%eax
10c27a: 8a 55 e0 mov -0x20(%ebp),%dl
10c27d: 0f 82 bf 01 00 00 jb 10c442 <_Thread_Initialize+0x216>
10c283: 85 c0 test %eax,%eax
10c285: 0f 84 b7 01 00 00 je 10c442 <_Thread_Initialize+0x216><== NEVER TAKEN
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
10c28b: 8b 8b c4 00 00 00 mov 0xc4(%ebx),%ecx
the_thread->Start.core_allocated_stack = true;
10c291: c6 83 b4 00 00 00 01 movb $0x1,0xb4(%ebx)
10c298: eb 09 jmp 10c2a3 <_Thread_Initialize+0x77>
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
10c29a: c6 83 b4 00 00 00 00 movb $0x0,0xb4(%ebx)
10c2a1: 89 f0 mov %esi,%eax
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
10c2a3: 89 8b bc 00 00 00 mov %ecx,0xbc(%ebx)
the_stack->size = size;
10c2a9: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
extensions_area = NULL;
the_thread->libc_reent = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
fp_area = NULL;
10c2af: 31 ff xor %edi,%edi
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
10c2b1: 84 d2 test %dl,%dl
10c2b3: 74 17 je 10c2cc <_Thread_Initialize+0xa0>
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
10c2b5: 83 ec 0c sub $0xc,%esp
10c2b8: 6a 6c push $0x6c
10c2ba: e8 27 0d 00 00 call 10cfe6 <_Workspace_Allocate>
10c2bf: 89 c7 mov %eax,%edi
if ( !fp_area )
10c2c1: 83 c4 10 add $0x10,%esp
10c2c4: 85 c0 test %eax,%eax
10c2c6: 0f 84 23 01 00 00 je 10c3ef <_Thread_Initialize+0x1c3>
goto failed;
fp_area = _Context_Fp_start( fp_area, 0 );
}
the_thread->fp_context = fp_area;
10c2cc: 89 bb e0 00 00 00 mov %edi,0xe0(%ebx)
the_thread->Start.fp_context = fp_area;
10c2d2: 89 bb c0 00 00 00 mov %edi,0xc0(%ebx)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10c2d8: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx)
the_watchdog->routine = routine;
10c2df: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx)
the_watchdog->id = id;
10c2e6: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
the_watchdog->user_data = user_data;
10c2ed: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10c2f4: a1 d4 53 12 00 mov 0x1253d4,%eax
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
10c2f9: 31 f6 xor %esi,%esi
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
10c2fb: 85 c0 test %eax,%eax
10c2fd: 74 1d je 10c31c <_Thread_Initialize+0xf0>
extensions_area = _Workspace_Allocate(
10c2ff: 83 ec 0c sub $0xc,%esp
10c302: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax
10c309: 50 push %eax
10c30a: e8 d7 0c 00 00 call 10cfe6 <_Workspace_Allocate>
10c30f: 89 c6 mov %eax,%esi
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
10c311: 83 c4 10 add $0x10,%esp
10c314: 85 c0 test %eax,%eax
10c316: 0f 84 d5 00 00 00 je 10c3f1 <_Thread_Initialize+0x1c5>
goto failed;
}
the_thread->extensions = (void **) extensions_area;
10c31c: 89 b3 f0 00 00 00 mov %esi,0xf0(%ebx)
* if they are linked to the thread. An extension user may
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
10c322: 85 f6 test %esi,%esi
10c324: 74 16 je 10c33c <_Thread_Initialize+0x110>
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
10c326: 8b 15 d4 53 12 00 mov 0x1253d4,%edx
10c32c: 31 c0 xor %eax,%eax
10c32e: eb 08 jmp 10c338 <_Thread_Initialize+0x10c>
the_thread->extensions[i] = NULL;
10c330: c7 04 86 00 00 00 00 movl $0x0,(%esi,%eax,4)
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
10c337: 40 inc %eax
10c338: 39 d0 cmp %edx,%eax
10c33a: 76 f4 jbe 10c330 <_Thread_Initialize+0x104>
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
10c33c: 8a 45 e7 mov -0x19(%ebp),%al
10c33f: 88 83 a0 00 00 00 mov %al,0xa0(%ebx)
the_thread->Start.budget_algorithm = budget_algorithm;
10c345: 8b 45 24 mov 0x24(%ebp),%eax
10c348: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
the_thread->Start.budget_callout = budget_callout;
10c34e: 8b 45 28 mov 0x28(%ebp),%eax
10c351: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx)
switch ( budget_algorithm ) {
10c357: 83 7d 24 02 cmpl $0x2,0x24(%ebp)
10c35b: 75 08 jne 10c365 <_Thread_Initialize+0x139>
case THREAD_CPU_BUDGET_ALGORITHM_NONE:
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
10c35d: a1 10 53 12 00 mov 0x125310,%eax
10c362: 89 43 78 mov %eax,0x78(%ebx)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
10c365: 8b 45 2c mov 0x2c(%ebp),%eax
10c368: 89 83 ac 00 00 00 mov %eax,0xac(%ebx)
the_thread->current_state = STATES_DORMANT;
10c36e: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
the_thread->Wait.queue = NULL;
10c375: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx)
the_thread->resource_count = 0;
10c37c: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx)
the_thread->real_priority = priority;
10c383: 8b 45 1c mov 0x1c(%ebp),%eax
10c386: 89 43 18 mov %eax,0x18(%ebx)
the_thread->Start.initial_priority = priority;
10c389: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx)
*/
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.allocate( the_thread );
10c38f: 83 ec 0c sub $0xc,%esp
10c392: 53 push %ebx
10c393: ff 15 68 11 12 00 call *0x121168
10c399: 89 c2 mov %eax,%edx
sched =_Scheduler_Allocate( the_thread );
if ( !sched )
10c39b: 83 c4 10 add $0x10,%esp
10c39e: 85 c0 test %eax,%eax
10c3a0: 74 51 je 10c3f3 <_Thread_Initialize+0x1c7>
goto failed;
_Thread_Set_priority( the_thread, priority );
10c3a2: 51 push %ecx
10c3a3: 51 push %ecx
10c3a4: ff 75 1c pushl 0x1c(%ebp)
10c3a7: 53 push %ebx
10c3a8: 89 45 e0 mov %eax,-0x20(%ebp)
10c3ab: e8 40 05 00 00 call 10c8f0 <_Thread_Set_priority>
/*
* Initialize the CPU usage statistics
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
10c3b0: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx)
10c3b7: 00 00 00
10c3ba: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx)
10c3c1: 00 00 00
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
10c3c4: 8b 45 08 mov 0x8(%ebp),%eax
10c3c7: 8b 40 1c mov 0x1c(%eax),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
10c3ca: 0f b7 4b 08 movzwl 0x8(%ebx),%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10c3ce: 89 1c 88 mov %ebx,(%eax,%ecx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
10c3d1: 8b 45 30 mov 0x30(%ebp),%eax
10c3d4: 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 );
10c3d7: 89 1c 24 mov %ebx,(%esp)
10c3da: e8 e9 08 00 00 call 10ccc8 <_User_extensions_Thread_create>
10c3df: 88 c1 mov %al,%cl
if ( extension_status )
10c3e1: 83 c4 10 add $0x10,%esp
return true;
10c3e4: b0 01 mov $0x1,%al
* 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 );
if ( extension_status )
10c3e6: 84 c9 test %cl,%cl
10c3e8: 8b 55 e0 mov -0x20(%ebp),%edx
10c3eb: 74 06 je 10c3f3 <_Thread_Initialize+0x1c7>
10c3ed: eb 55 jmp 10c444 <_Thread_Initialize+0x218>
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
10c3ef: 31 f6 xor %esi,%esi
size_t actual_stack_size = 0;
void *stack = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
void *fp_area;
#endif
void *sched = NULL;
10c3f1: 31 d2 xor %edx,%edx
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
return true;
failed:
_Workspace_Free( the_thread->libc_reent );
10c3f3: 83 ec 0c sub $0xc,%esp
10c3f6: ff b3 e4 00 00 00 pushl 0xe4(%ebx)
10c3fc: 89 55 e0 mov %edx,-0x20(%ebp)
10c3ff: e8 fb 0b 00 00 call 10cfff <_Workspace_Free>
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
10c404: 5a pop %edx
10c405: ff b3 e8 00 00 00 pushl 0xe8(%ebx)
10c40b: e8 ef 0b 00 00 call 10cfff <_Workspace_Free>
10c410: 58 pop %eax
10c411: ff b3 ec 00 00 00 pushl 0xec(%ebx)
10c417: e8 e3 0b 00 00 call 10cfff <_Workspace_Free>
_Workspace_Free( extensions_area );
10c41c: 89 34 24 mov %esi,(%esp)
10c41f: e8 db 0b 00 00 call 10cfff <_Workspace_Free>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
10c424: 89 3c 24 mov %edi,(%esp)
10c427: e8 d3 0b 00 00 call 10cfff <_Workspace_Free>
#endif
_Workspace_Free( sched );
10c42c: 8b 55 e0 mov -0x20(%ebp),%edx
10c42f: 89 14 24 mov %edx,(%esp)
10c432: e8 c8 0b 00 00 call 10cfff <_Workspace_Free>
_Thread_Stack_Free( the_thread );
10c437: 89 1c 24 mov %ebx,(%esp)
10c43a: e8 81 05 00 00 call 10c9c0 <_Thread_Stack_Free>
return false;
10c43f: 83 c4 10 add $0x10,%esp
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
10c442: 31 c0 xor %eax,%eax
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
10c444: 8d 65 f4 lea -0xc(%ebp),%esp
10c447: 5b pop %ebx
10c448: 5e pop %esi
10c449: 5f pop %edi
10c44a: c9 leave
10c44b: c3 ret
0010f678 <_Thread_Resume>:
*/
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
10f678: 55 push %ebp
10f679: 89 e5 mov %esp,%ebp
10f67b: 53 push %ebx
10f67c: 83 ec 04 sub $0x4,%esp
10f67f: 8b 45 08 mov 0x8(%ebp),%eax
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
10f682: 9c pushf
10f683: fa cli
10f684: 5b pop %ebx
current_state = the_thread->current_state;
10f685: 8b 50 10 mov 0x10(%eax),%edx
if ( current_state & STATES_SUSPENDED ) {
10f688: f6 c2 02 test $0x2,%dl
10f68b: 74 17 je 10f6a4 <_Thread_Resume+0x2c> <== NEVER TAKEN
10f68d: 83 e2 fd and $0xfffffffd,%edx
current_state =
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
10f690: 89 50 10 mov %edx,0x10(%eax)
if ( _States_Is_ready( current_state ) ) {
10f693: 85 d2 test %edx,%edx
10f695: 75 0d jne 10f6a4 <_Thread_Resume+0x2c>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(
Thread_Control *the_thread
)
{
_Scheduler.Operations.unblock( the_thread );
10f697: 83 ec 0c sub $0xc,%esp
10f69a: 50 push %eax
10f69b: ff 15 64 41 12 00 call *0x124164
10f6a1: 83 c4 10 add $0x10,%esp
_Scheduler_Unblock( the_thread );
}
}
_ISR_Enable( level );
10f6a4: 53 push %ebx
10f6a5: 9d popf
}
10f6a6: 8b 5d fc mov -0x4(%ebp),%ebx
10f6a9: c9 leave
10f6aa: c3 ret
0010caa8 <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
10caa8: 55 push %ebp
10caa9: 89 e5 mov %esp,%ebp
10caab: 53 push %ebx
10caac: 83 ec 04 sub $0x4,%esp
Thread_Control *executing;
executing = _Thread_Executing;
10caaf: 8b 1d 68 58 12 00 mov 0x125868,%ebx
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
10cab5: 80 7b 74 00 cmpb $0x0,0x74(%ebx)
10cab9: 74 4d je 10cb08 <_Thread_Tickle_timeslice+0x60>
return;
if ( !_States_Is_ready( executing->current_state ) )
10cabb: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10cabf: 75 47 jne 10cb08 <_Thread_Tickle_timeslice+0x60>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
10cac1: 8b 43 7c mov 0x7c(%ebx),%eax
10cac4: 83 f8 01 cmp $0x1,%eax
10cac7: 72 3f jb 10cb08 <_Thread_Tickle_timeslice+0x60>
10cac9: 83 f8 02 cmp $0x2,%eax
10cacc: 76 07 jbe 10cad5 <_Thread_Tickle_timeslice+0x2d>
10cace: 83 f8 03 cmp $0x3,%eax
10cad1: 75 35 jne 10cb08 <_Thread_Tickle_timeslice+0x60><== NEVER TAKEN
10cad3: eb 1b jmp 10caf0 <_Thread_Tickle_timeslice+0x48>
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
#endif
if ( (int)(--executing->cpu_time_budget) <= 0 ) {
10cad5: 8b 43 78 mov 0x78(%ebx),%eax
10cad8: 48 dec %eax
10cad9: 89 43 78 mov %eax,0x78(%ebx)
10cadc: 85 c0 test %eax,%eax
10cade: 7f 28 jg 10cb08 <_Thread_Tickle_timeslice+0x60>
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
10cae0: ff 15 5c 11 12 00 call *0x12115c
* executing thread's timeslice is reset. Otherwise, the
* currently executing thread is placed at the rear of the
* FIFO for this priority and a new heir is selected.
*/
_Scheduler_Yield( );
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
10cae6: a1 10 53 12 00 mov 0x125310,%eax
10caeb: 89 43 78 mov %eax,0x78(%ebx)
10caee: eb 18 jmp 10cb08 <_Thread_Tickle_timeslice+0x60>
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
10caf0: 8b 43 78 mov 0x78(%ebx),%eax
10caf3: 48 dec %eax
10caf4: 89 43 78 mov %eax,0x78(%ebx)
10caf7: 85 c0 test %eax,%eax
10caf9: 75 0d jne 10cb08 <_Thread_Tickle_timeslice+0x60>
(*executing->budget_callout)( executing );
10cafb: 83 ec 0c sub $0xc,%esp
10cafe: 53 push %ebx
10caff: ff 93 80 00 00 00 call *0x80(%ebx)
10cb05: 83 c4 10 add $0x10,%esp
break;
#endif
}
}
10cb08: 8b 5d fc mov -0x4(%ebp),%ebx
10cb0b: c9 leave
10cb0c: c3 ret
0010fa60 <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
10fa60: 55 push %ebp
10fa61: 89 e5 mov %esp,%ebp
10fa63: 83 ec 08 sub $0x8,%esp
10fa66: 8b 55 08 mov 0x8(%ebp),%edx
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
10fa69: 8b 42 44 mov 0x44(%edx),%eax
* 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 &&
10fa6c: 8b 48 30 mov 0x30(%eax),%ecx
10fa6f: 85 c9 test %ecx,%ecx
10fa71: 74 1c je 10fa8f <_Thread_queue_Process_timeout+0x2f>
10fa73: 3b 15 68 58 12 00 cmp 0x125868,%edx
10fa79: 75 14 jne 10fa8f <_Thread_queue_Process_timeout+0x2f>
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
10fa7b: 83 f9 03 cmp $0x3,%ecx
10fa7e: 74 21 je 10faa1 <_Thread_queue_Process_timeout+0x41><== NEVER TAKEN
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
10fa80: 8b 48 3c mov 0x3c(%eax),%ecx
10fa83: 89 4a 34 mov %ecx,0x34(%edx)
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
10fa86: c7 40 30 02 00 00 00 movl $0x2,0x30(%eax)
10fa8d: eb 12 jmp 10faa1 <_Thread_queue_Process_timeout+0x41>
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
10fa8f: 8b 48 3c mov 0x3c(%eax),%ecx
10fa92: 89 4a 34 mov %ecx,0x34(%edx)
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
10fa95: 51 push %ecx
10fa96: 51 push %ecx
10fa97: 52 push %edx
10fa98: 50 push %eax
10fa99: e8 da fe ff ff call 10f978 <_Thread_queue_Extract>
10fa9e: 83 c4 10 add $0x10,%esp
}
}
10faa1: c9 leave
10faa2: c3 ret
0010c868 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
10c868: 55 push %ebp
10c869: 89 e5 mov %esp,%ebp
10c86b: 57 push %edi
10c86c: 56 push %esi
10c86d: 53 push %ebx
10c86e: 83 ec 1c sub $0x1c,%esp
10c871: 8b 75 08 mov 0x8(%ebp),%esi
10c874: 8b 7d 0c mov 0xc(%ebp),%edi
/*
* Just in case the thread really wasn't blocked on a thread queue
* when we get here.
*/
if ( !the_thread_queue )
10c877: 85 f6 test %esi,%esi
10c879: 74 36 je 10c8b1 <_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 ) {
10c87b: 83 7e 34 01 cmpl $0x1,0x34(%esi)
10c87f: 75 30 jne 10c8b1 <_Thread_queue_Requeue+0x49><== NEVER TAKEN
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
10c881: 9c pushf
10c882: fa cli
10c883: 5b pop %ebx
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
10c884: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi)
10c88b: 74 22 je 10c8af <_Thread_queue_Requeue+0x47><== NEVER TAKEN
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10c88d: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi)
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
10c894: 50 push %eax
10c895: 6a 01 push $0x1
10c897: 57 push %edi
10c898: 56 push %esi
10c899: e8 0a 31 00 00 call 10f9a8 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
10c89e: 83 c4 0c add $0xc,%esp
10c8a1: 8d 45 e4 lea -0x1c(%ebp),%eax
10c8a4: 50 push %eax
10c8a5: 57 push %edi
10c8a6: 56 push %esi
10c8a7: e8 c0 fd ff ff call 10c66c <_Thread_queue_Enqueue_priority>
10c8ac: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10c8af: 53 push %ebx
10c8b0: 9d popf
}
}
10c8b1: 8d 65 f4 lea -0xc(%ebp),%esp
10c8b4: 5b pop %ebx
10c8b5: 5e pop %esi
10c8b6: 5f pop %edi
10c8b7: c9 leave
10c8b8: c3 ret
0010c8bc <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
10c8bc: 55 push %ebp
10c8bd: 89 e5 mov %esp,%ebp
10c8bf: 83 ec 20 sub $0x20,%esp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
10c8c2: 8d 45 f4 lea -0xc(%ebp),%eax
10c8c5: 50 push %eax
10c8c6: ff 75 08 pushl 0x8(%ebp)
10c8c9: e8 ee f8 ff ff call 10c1bc <_Thread_Get>
switch ( location ) {
10c8ce: 83 c4 10 add $0x10,%esp
10c8d1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10c8d5: 75 17 jne 10c8ee <_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 );
10c8d7: 83 ec 0c sub $0xc,%esp
10c8da: 50 push %eax
10c8db: e8 80 31 00 00 call 10fa60 <_Thread_queue_Process_timeout>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
10c8e0: a1 40 53 12 00 mov 0x125340,%eax
10c8e5: 48 dec %eax
10c8e6: a3 40 53 12 00 mov %eax,0x125340
10c8eb: 83 c4 10 add $0x10,%esp
_Thread_Unnest_dispatch();
break;
}
}
10c8ee: c9 leave
10c8ef: c3 ret
00116970 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
116970: 55 push %ebp
116971: 89 e5 mov %esp,%ebp
116973: 57 push %edi
116974: 56 push %esi
116975: 53 push %ebx
116976: 83 ec 4c sub $0x4c,%esp
116979: 8b 5d 08 mov 0x8(%ebp),%ebx
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
11697c: 8d 55 dc lea -0x24(%ebp),%edx
11697f: 8d 45 e0 lea -0x20(%ebp),%eax
116982: 89 45 dc mov %eax,-0x24(%ebp)
head->previous = NULL;
116985: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
tail->previous = head;
11698c: 89 55 e4 mov %edx,-0x1c(%ebp)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
11698f: 8d 7d d0 lea -0x30(%ebp),%edi
116992: 8d 4d d4 lea -0x2c(%ebp),%ecx
116995: 89 4d d0 mov %ecx,-0x30(%ebp)
head->previous = NULL;
116998: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
tail->previous = head;
11699f: 89 7d d8 mov %edi,-0x28(%ebp)
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1169a2: 8d 53 30 lea 0x30(%ebx),%edx
1169a5: 89 55 c0 mov %edx,-0x40(%ebp)
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
1169a8: 8d 73 68 lea 0x68(%ebx),%esi
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
1169ab: 89 45 b4 mov %eax,-0x4c(%ebp)
Chain_Control *tmp;
/*
* Afterwards all timer inserts are directed to this chain and the interval
* and TOD chains will be no more modified by other parties.
*/
ts->insert_chain = insert_chain;
1169ae: 8d 4d dc lea -0x24(%ebp),%ecx
1169b1: 89 4b 78 mov %ecx,0x78(%ebx)
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
1169b4: a1 28 f0 13 00 mov 0x13f028,%eax
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
1169b9: 8b 53 3c mov 0x3c(%ebx),%edx
watchdogs->last_snapshot = snapshot;
1169bc: 89 43 3c mov %eax,0x3c(%ebx)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1169bf: 51 push %ecx
1169c0: 57 push %edi
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
1169c1: 29 d0 sub %edx,%eax
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1169c3: 50 push %eax
1169c4: ff 75 c0 pushl -0x40(%ebp)
1169c7: e8 b8 39 00 00 call 11a384 <_Watchdog_Adjust_to_chain>
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
1169cc: a1 a0 ef 13 00 mov 0x13efa0,%eax
1169d1: 89 45 c4 mov %eax,-0x3c(%ebp)
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
1169d4: 8b 43 74 mov 0x74(%ebx),%eax
/*
* Process the seconds chain. Start by checking that the Time
* of Day (TOD) has not been set backwards. If it has then
* we want to adjust the watchdogs->Chain to indicate this.
*/
if ( snapshot > last_snapshot ) {
1169d7: 83 c4 10 add $0x10,%esp
1169da: 39 45 c4 cmp %eax,-0x3c(%ebp)
1169dd: 76 10 jbe 1169ef <_Timer_server_Body+0x7f>
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1169df: 52 push %edx
1169e0: 57 push %edi
if ( snapshot > last_snapshot ) {
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
1169e1: 8b 55 c4 mov -0x3c(%ebp),%edx
1169e4: 29 c2 sub %eax,%edx
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
1169e6: 52 push %edx
1169e7: 56 push %esi
1169e8: e8 97 39 00 00 call 11a384 <_Watchdog_Adjust_to_chain>
1169ed: eb 0f jmp 1169fe <_Timer_server_Body+0x8e>
} else if ( snapshot < last_snapshot ) {
1169ef: 73 10 jae 116a01 <_Timer_server_Body+0x91>
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
1169f1: 51 push %ecx
} else if ( snapshot < last_snapshot ) {
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
1169f2: 2b 45 c4 sub -0x3c(%ebp),%eax
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
1169f5: 50 push %eax
1169f6: 6a 01 push $0x1
1169f8: 56 push %esi
1169f9: e8 1a 39 00 00 call 11a318 <_Watchdog_Adjust>
1169fe: 83 c4 10 add $0x10,%esp
}
watchdogs->last_snapshot = snapshot;
116a01: 8b 4d c4 mov -0x3c(%ebp),%ecx
116a04: 89 4b 74 mov %ecx,0x74(%ebx)
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
116a07: 8b 43 78 mov 0x78(%ebx),%eax
116a0a: 83 ec 0c sub $0xc,%esp
116a0d: 50 push %eax
116a0e: e8 fd 08 00 00 call 117310 <_Chain_Get>
if ( timer == NULL ) {
116a13: 83 c4 10 add $0x10,%esp
116a16: 85 c0 test %eax,%eax
116a18: 74 29 je 116a43 <_Timer_server_Body+0xd3><== ALWAYS TAKEN
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
116a1a: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED
116a1d: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED
116a20: 75 0b jne 116a2d <_Timer_server_Body+0xbd><== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
116a22: 52 push %edx <== NOT EXECUTED
116a23: 52 push %edx <== NOT EXECUTED
116a24: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
116a27: 50 push %eax <== NOT EXECUTED
116a28: ff 75 c0 pushl -0x40(%ebp) <== NOT EXECUTED
116a2b: eb 0c jmp 116a39 <_Timer_server_Body+0xc9><== NOT EXECUTED
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
116a2d: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED
116a30: 75 d5 jne 116a07 <_Timer_server_Body+0x97><== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
116a32: 51 push %ecx <== NOT EXECUTED
116a33: 51 push %ecx <== NOT EXECUTED
116a34: 83 c0 10 add $0x10,%eax <== NOT EXECUTED
116a37: 50 push %eax <== NOT EXECUTED
116a38: 56 push %esi <== NOT EXECUTED
116a39: e8 ce 39 00 00 call 11a40c <_Watchdog_Insert> <== NOT EXECUTED
116a3e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
116a41: eb c4 jmp 116a07 <_Timer_server_Body+0x97><== NOT EXECUTED
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
116a43: 9c pushf
116a44: fa cli
116a45: 5a pop %edx
tmp = ts->insert_chain;
116a46: 8b 43 78 mov 0x78(%ebx),%eax
if ( _Chain_Is_empty( insert_chain ) ) {
116a49: b0 01 mov $0x1,%al
116a4b: 8b 4d b4 mov -0x4c(%ebp),%ecx
116a4e: 39 4d dc cmp %ecx,-0x24(%ebp)
116a51: 75 09 jne 116a5c <_Timer_server_Body+0xec><== NEVER TAKEN
ts->insert_chain = NULL;
116a53: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx)
do_loop = false;
116a5a: 31 c0 xor %eax,%eax
}
_ISR_Enable( level );
116a5c: 52 push %edx
116a5d: 9d popf
* Afterwards all timer inserts are directed to this chain and the interval
* and TOD chains will be no more modified by other parties.
*/
ts->insert_chain = insert_chain;
while ( do_loop ) {
116a5e: 84 c0 test %al,%al
116a60: 0f 85 4e ff ff ff jne 1169b4 <_Timer_server_Body+0x44><== NEVER TAKEN
116a66: 8d 45 d4 lea -0x2c(%ebp),%eax
_Chain_Initialize_empty( &fire_chain );
while ( true ) {
_Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
if ( !_Chain_Is_empty( &fire_chain ) ) {
116a69: 39 45 d0 cmp %eax,-0x30(%ebp)
116a6c: 74 3a je 116aa8 <_Timer_server_Body+0x138>
116a6e: 89 45 b0 mov %eax,-0x50(%ebp)
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
116a71: 9c pushf
116a72: fa cli
116a73: 59 pop %ecx
initialized = false;
}
#endif
return status;
}
116a74: 8b 45 d0 mov -0x30(%ebp),%eax
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
116a77: 3b 45 b0 cmp -0x50(%ebp),%eax
116a7a: 74 25 je 116aa1 <_Timer_server_Body+0x131>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
116a7c: 8b 10 mov (%eax),%edx
head->next = new_first;
116a7e: 89 55 d0 mov %edx,-0x30(%ebp)
new_first->previous = head;
116a81: 89 7a 04 mov %edi,0x4(%edx)
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
116a84: 85 c0 test %eax,%eax
116a86: 74 19 je 116aa1 <_Timer_server_Body+0x131><== NEVER TAKEN
watchdog->state = WATCHDOG_INACTIVE;
116a88: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
_ISR_Enable( level );
116a8f: 51 push %ecx
116a90: 9d popf
/*
* The timer server may block here and wait for resources or time.
* The system watchdogs are inactive and will remain inactive since
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
116a91: 52 push %edx
116a92: 52 push %edx
116a93: ff 70 24 pushl 0x24(%eax)
116a96: ff 70 20 pushl 0x20(%eax)
116a99: ff 50 1c call *0x1c(%eax)
}
116a9c: 83 c4 10 add $0x10,%esp
116a9f: eb d0 jmp 116a71 <_Timer_server_Body+0x101>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
116aa1: 51 push %ecx
116aa2: 9d popf
116aa3: e9 06 ff ff ff jmp 1169ae <_Timer_server_Body+0x3e>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
116aa8: c6 43 7c 00 movb $0x0,0x7c(%ebx)
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
116aac: e8 23 fe ff ff call 1168d4 <_Thread_Disable_dispatch>
_Thread_Set_state( ts->thread, STATES_DELAYING );
116ab1: 51 push %ecx
116ab2: 51 push %ecx
116ab3: 6a 08 push $0x8
116ab5: ff 33 pushl (%ebx)
116ab7: e8 fc 32 00 00 call 119db8 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
116abc: 89 d8 mov %ebx,%eax
116abe: e8 21 fe ff ff call 1168e4 <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
116ac3: 89 d8 mov %ebx,%eax
116ac5: e8 60 fe ff ff call 11692a <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
116aca: e8 c3 2a 00 00 call 119592 <_Thread_Enable_dispatch>
ts->active = true;
116acf: c6 43 7c 01 movb $0x1,0x7c(%ebx)
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
116ad3: 8d 43 08 lea 0x8(%ebx),%eax
116ad6: 89 04 24 mov %eax,(%esp)
116ad9: e8 4e 3a 00 00 call 11a52c <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
116ade: 8d 43 40 lea 0x40(%ebx),%eax
116ae1: 89 04 24 mov %eax,(%esp)
116ae4: e8 43 3a 00 00 call 11a52c <_Watchdog_Remove>
116ae9: 83 c4 10 add $0x10,%esp
116aec: e9 bd fe ff ff jmp 1169ae <_Timer_server_Body+0x3e>
00116af1 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
116af1: 55 push %ebp
116af2: 89 e5 mov %esp,%ebp
116af4: 57 push %edi
116af5: 56 push %esi
116af6: 53 push %ebx
116af7: 83 ec 2c sub $0x2c,%esp
116afa: 8b 5d 08 mov 0x8(%ebp),%ebx
116afd: 8b 75 0c mov 0xc(%ebp),%esi
if ( ts->insert_chain == NULL ) {
116b00: 8b 43 78 mov 0x78(%ebx),%eax
116b03: 85 c0 test %eax,%eax
116b05: 0f 85 de 00 00 00 jne 116be9 <_Timer_server_Schedule_operation_method+0xf8><== NEVER TAKEN
* is the reference point for the delta chain. Thus if we do not update the
* reference point we have to add DT to the initial delta of the watchdog
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
116b0b: e8 c4 fd ff ff call 1168d4 <_Thread_Disable_dispatch>
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
116b10: 8b 46 38 mov 0x38(%esi),%eax
116b13: 83 f8 01 cmp $0x1,%eax
116b16: 75 5a jne 116b72 <_Timer_server_Schedule_operation_method+0x81>
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
116b18: 9c pushf
116b19: fa cli
116b1a: 8f 45 e0 popl -0x20(%ebp)
snapshot = _Watchdog_Ticks_since_boot;
116b1d: 8b 15 28 f0 13 00 mov 0x13f028,%edx
last_snapshot = ts->Interval_watchdogs.last_snapshot;
116b23: 8b 4b 3c mov 0x3c(%ebx),%ecx
initialized = false;
}
#endif
return status;
}
116b26: 8b 43 30 mov 0x30(%ebx),%eax
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
116b29: 8d 7b 34 lea 0x34(%ebx),%edi
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = _Watchdog_Ticks_since_boot;
last_snapshot = ts->Interval_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
116b2c: 39 f8 cmp %edi,%eax
116b2e: 74 19 je 116b49 <_Timer_server_Schedule_operation_method+0x58>
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
116b30: 89 d7 mov %edx,%edi
116b32: 29 cf sub %ecx,%edi
116b34: 89 7d e4 mov %edi,-0x1c(%ebp)
delta_interval = first_watchdog->delta_interval;
116b37: 8b 78 10 mov 0x10(%eax),%edi
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
116b3a: 31 c9 xor %ecx,%ecx
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
116b3c: 3b 7d e4 cmp -0x1c(%ebp),%edi
116b3f: 76 05 jbe 116b46 <_Timer_server_Schedule_operation_method+0x55>
delta_interval -= delta;
116b41: 89 f9 mov %edi,%ecx
116b43: 2b 4d e4 sub -0x1c(%ebp),%ecx
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
116b46: 89 48 10 mov %ecx,0x10(%eax)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
116b49: 89 53 3c mov %edx,0x3c(%ebx)
_ISR_Enable( level );
116b4c: ff 75 e0 pushl -0x20(%ebp)
116b4f: 9d popf
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
116b50: 50 push %eax
116b51: 50 push %eax
116b52: 83 c6 10 add $0x10,%esi
116b55: 56 push %esi
116b56: 8d 43 30 lea 0x30(%ebx),%eax
116b59: 50 push %eax
116b5a: e8 ad 38 00 00 call 11a40c <_Watchdog_Insert>
if ( !ts->active ) {
116b5f: 8a 43 7c mov 0x7c(%ebx),%al
116b62: 83 c4 10 add $0x10,%esp
116b65: 84 c0 test %al,%al
116b67: 75 74 jne 116bdd <_Timer_server_Schedule_operation_method+0xec>
_Timer_server_Reset_interval_system_watchdog( ts );
116b69: 89 d8 mov %ebx,%eax
116b6b: e8 74 fd ff ff call 1168e4 <_Timer_server_Reset_interval_system_watchdog>
116b70: eb 6b jmp 116bdd <_Timer_server_Schedule_operation_method+0xec>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
116b72: 83 f8 03 cmp $0x3,%eax
116b75: 75 66 jne 116bdd <_Timer_server_Schedule_operation_method+0xec>
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
116b77: 9c pushf
116b78: fa cli
116b79: 8f 45 e0 popl -0x20(%ebp)
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
116b7c: 8b 15 a0 ef 13 00 mov 0x13efa0,%edx
last_snapshot = ts->TOD_watchdogs.last_snapshot;
116b82: 8b 43 74 mov 0x74(%ebx),%eax
initialized = false;
}
#endif
return status;
}
116b85: 8b 4b 68 mov 0x68(%ebx),%ecx
116b88: 8d 7b 6c lea 0x6c(%ebx),%edi
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
116b8b: 39 f9 cmp %edi,%ecx
116b8d: 74 27 je 116bb6 <_Timer_server_Schedule_operation_method+0xc5>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
116b8f: 8b 79 10 mov 0x10(%ecx),%edi
116b92: 89 7d d4 mov %edi,-0x2c(%ebp)
if ( snapshot > last_snapshot ) {
116b95: 39 c2 cmp %eax,%edx
116b97: 76 15 jbe 116bae <_Timer_server_Schedule_operation_method+0xbd>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
116b99: 89 d7 mov %edx,%edi
116b9b: 29 c7 sub %eax,%edi
116b9d: 89 7d e4 mov %edi,-0x1c(%ebp)
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
116ba0: 31 c0 xor %eax,%eax
if ( snapshot > last_snapshot ) {
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
116ba2: 39 7d d4 cmp %edi,-0x2c(%ebp)
116ba5: 76 0c jbe 116bb3 <_Timer_server_Schedule_operation_method+0xc2><== NEVER TAKEN
delta_interval -= delta;
116ba7: 8b 45 d4 mov -0x2c(%ebp),%eax
116baa: 29 f8 sub %edi,%eax
116bac: eb 05 jmp 116bb3 <_Timer_server_Schedule_operation_method+0xc2>
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
116bae: 03 45 d4 add -0x2c(%ebp),%eax
delta_interval += delta;
116bb1: 29 d0 sub %edx,%eax
}
first_watchdog->delta_interval = delta_interval;
116bb3: 89 41 10 mov %eax,0x10(%ecx)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
116bb6: 89 53 74 mov %edx,0x74(%ebx)
_ISR_Enable( level );
116bb9: ff 75 e0 pushl -0x20(%ebp)
116bbc: 9d popf
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
116bbd: 57 push %edi
116bbe: 57 push %edi
116bbf: 83 c6 10 add $0x10,%esi
116bc2: 56 push %esi
116bc3: 8d 43 68 lea 0x68(%ebx),%eax
116bc6: 50 push %eax
116bc7: e8 40 38 00 00 call 11a40c <_Watchdog_Insert>
if ( !ts->active ) {
116bcc: 8a 43 7c mov 0x7c(%ebx),%al
116bcf: 83 c4 10 add $0x10,%esp
116bd2: 84 c0 test %al,%al
116bd4: 75 07 jne 116bdd <_Timer_server_Schedule_operation_method+0xec>
_Timer_server_Reset_tod_system_watchdog( ts );
116bd6: 89 d8 mov %ebx,%eax
116bd8: e8 4d fd ff ff call 11692a <_Timer_server_Reset_tod_system_watchdog>
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
}
}
116bdd: 8d 65 f4 lea -0xc(%ebp),%esp
116be0: 5b pop %ebx
116be1: 5e pop %esi
116be2: 5f pop %edi
116be3: c9 leave
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
116be4: e9 a9 29 00 00 jmp 119592 <_Thread_Enable_dispatch>
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
116be9: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED
116bec: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED
116bef: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED
}
}
116bf2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
116bf5: 5b pop %ebx <== NOT EXECUTED
116bf6: 5e pop %esi <== NOT EXECUTED
116bf7: 5f pop %edi <== NOT EXECUTED
116bf8: c9 leave <== NOT EXECUTED
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
116bf9: e9 d6 06 00 00 jmp 1172d4 <_Chain_Append> <== NOT EXECUTED
0010cc8b <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
10cc8b: 55 push %ebp
10cc8c: 89 e5 mov %esp,%ebp
10cc8e: 57 push %edi
10cc8f: 56 push %esi
10cc90: 53 push %ebx
10cc91: 83 ec 0c sub $0xc,%esp
10cc94: 8b 7d 10 mov 0x10(%ebp),%edi
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
10cc97: 8b 1d 14 55 12 00 mov 0x125514,%ebx
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10cc9d: 0f b6 75 0c movzbl 0xc(%ebp),%esi
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10cca1: eb 15 jmp 10ccb8 <_User_extensions_Fatal+0x2d>
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
10cca3: 8b 43 30 mov 0x30(%ebx),%eax
10cca6: 85 c0 test %eax,%eax
10cca8: 74 0b je 10ccb5 <_User_extensions_Fatal+0x2a>
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
10ccaa: 52 push %edx
10ccab: 57 push %edi
10ccac: 56 push %esi
10ccad: ff 75 08 pushl 0x8(%ebp)
10ccb0: ff d0 call *%eax
10ccb2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
10ccb5: 8b 5b 04 mov 0x4(%ebx),%ebx
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
10ccb8: 81 fb 0c 55 12 00 cmp $0x12550c,%ebx
10ccbe: 75 e3 jne 10cca3 <_User_extensions_Fatal+0x18><== ALWAYS TAKEN
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
10ccc0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
10ccc3: 5b pop %ebx <== NOT EXECUTED
10ccc4: 5e pop %esi <== NOT EXECUTED
10ccc5: 5f pop %edi <== NOT EXECUTED
10ccc6: c9 leave <== NOT EXECUTED
10ccc7: c3 ret <== NOT EXECUTED
0010cb74 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
10cb74: 55 push %ebp
10cb75: 89 e5 mov %esp,%ebp
10cb77: 57 push %edi
10cb78: 56 push %esi
10cb79: 53 push %ebx
10cb7a: 83 ec 1c sub $0x1c,%esp
User_extensions_Control *extension;
uint32_t i;
uint32_t number_of_extensions;
User_extensions_Table *initial_extensions;
number_of_extensions = Configuration.number_of_initial_extensions;
10cb7d: a1 60 12 12 00 mov 0x121260,%eax
10cb82: 89 45 e4 mov %eax,-0x1c(%ebp)
initial_extensions = Configuration.User_extension_table;
10cb85: 8b 35 64 12 12 00 mov 0x121264,%esi
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10cb8b: c7 05 0c 55 12 00 10 movl $0x125510,0x12550c
10cb92: 55 12 00
head->previous = NULL;
10cb95: c7 05 10 55 12 00 00 movl $0x0,0x125510
10cb9c: 00 00 00
tail->previous = head;
10cb9f: c7 05 14 55 12 00 0c movl $0x12550c,0x125514
10cba6: 55 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10cba9: c7 05 44 53 12 00 48 movl $0x125348,0x125344
10cbb0: 53 12 00
head->previous = NULL;
10cbb3: c7 05 48 53 12 00 00 movl $0x0,0x125348
10cbba: 00 00 00
tail->previous = head;
10cbbd: c7 05 4c 53 12 00 44 movl $0x125344,0x12534c
10cbc4: 53 12 00
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
10cbc7: 85 f6 test %esi,%esi
10cbc9: 74 53 je 10cc1e <_User_extensions_Handler_initialization+0xaa><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
10cbcb: 6b c8 34 imul $0x34,%eax,%ecx
10cbce: 83 ec 0c sub $0xc,%esp
10cbd1: 51 push %ecx
10cbd2: 89 4d e0 mov %ecx,-0x20(%ebp)
10cbd5: e8 3d 04 00 00 call 10d017 <_Workspace_Allocate_or_fatal_error>
10cbda: 89 c3 mov %eax,%ebx
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
10cbdc: 31 c0 xor %eax,%eax
10cbde: 8b 4d e0 mov -0x20(%ebp),%ecx
10cbe1: 89 df mov %ebx,%edi
10cbe3: f3 aa rep stos %al,%es:(%edi)
10cbe5: 89 f0 mov %esi,%eax
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10cbe7: 83 c4 10 add $0x10,%esp
10cbea: 31 d2 xor %edx,%edx
10cbec: eb 2b jmp 10cc19 <_User_extensions_Handler_initialization+0xa5>
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
10cbee: 8d 7b 14 lea 0x14(%ebx),%edi
10cbf1: 89 c6 mov %eax,%esi
10cbf3: b9 08 00 00 00 mov $0x8,%ecx
10cbf8: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_User_extensions_Add_set( extension );
10cbfa: 83 ec 0c sub $0xc,%esp
10cbfd: 53 push %ebx
10cbfe: 89 45 dc mov %eax,-0x24(%ebp)
10cc01: 89 55 e0 mov %edx,-0x20(%ebp)
10cc04: e8 3f 2f 00 00 call 10fb48 <_User_extensions_Add_set>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
10cc09: 83 c3 34 add $0x34,%ebx
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
10cc0c: 8b 55 e0 mov -0x20(%ebp),%edx
10cc0f: 42 inc %edx
10cc10: 8b 45 dc mov -0x24(%ebp),%eax
10cc13: 83 c0 20 add $0x20,%eax
10cc16: 83 c4 10 add $0x10,%esp
10cc19: 3b 55 e4 cmp -0x1c(%ebp),%edx
10cc1c: 72 d0 jb 10cbee <_User_extensions_Handler_initialization+0x7a>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
10cc1e: 8d 65 f4 lea -0xc(%ebp),%esp
10cc21: 5b pop %ebx
10cc22: 5e pop %esi
10cc23: 5f pop %edi
10cc24: c9 leave
10cc25: c3 ret
0010e4cc <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
10e4cc: 55 push %ebp
10e4cd: 89 e5 mov %esp,%ebp
10e4cf: 57 push %edi
10e4d0: 56 push %esi
10e4d1: 53 push %ebx
10e4d2: 83 ec 1c sub $0x1c,%esp
10e4d5: 8b 75 08 mov 0x8(%ebp),%esi
10e4d8: 8b 7d 0c mov 0xc(%ebp),%edi
10e4db: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
_ISR_Disable( level );
10e4de: 9c pushf
10e4df: fa cli
10e4e0: 58 pop %eax
}
}
_ISR_Enable( level );
}
10e4e1: 8b 16 mov (%esi),%edx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10e4e3: 8d 4e 04 lea 0x4(%esi),%ecx
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
10e4e6: 39 ca cmp %ecx,%edx
10e4e8: 74 44 je 10e52e <_Watchdog_Adjust+0x62>
switch ( direction ) {
10e4ea: 85 ff test %edi,%edi
10e4ec: 74 3c je 10e52a <_Watchdog_Adjust+0x5e>
10e4ee: 4f dec %edi
10e4ef: 75 3d jne 10e52e <_Watchdog_Adjust+0x62> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
10e4f1: 01 5a 10 add %ebx,0x10(%edx)
break;
10e4f4: eb 38 jmp 10e52e <_Watchdog_Adjust+0x62>
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
10e4f6: 8b 16 mov (%esi),%edx
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
10e4f8: 8b 7a 10 mov 0x10(%edx),%edi
10e4fb: 39 fb cmp %edi,%ebx
10e4fd: 73 07 jae 10e506 <_Watchdog_Adjust+0x3a>
_Watchdog_First( header )->delta_interval -= units;
10e4ff: 29 df sub %ebx,%edi
10e501: 89 7a 10 mov %edi,0x10(%edx)
break;
10e504: eb 28 jmp 10e52e <_Watchdog_Adjust+0x62>
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
10e506: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx)
_ISR_Enable( level );
10e50d: 50 push %eax
10e50e: 9d popf
_Watchdog_Tickle( header );
10e50f: 83 ec 0c sub $0xc,%esp
10e512: 56 push %esi
10e513: 89 4d e4 mov %ecx,-0x1c(%ebp)
10e516: e8 a5 01 00 00 call 10e6c0 <_Watchdog_Tickle>
_ISR_Disable( level );
10e51b: 9c pushf
10e51c: fa cli
10e51d: 58 pop %eax
if ( _Chain_Is_empty( header ) )
10e51e: 83 c4 10 add $0x10,%esp
10e521: 8b 4d e4 mov -0x1c(%ebp),%ecx
10e524: 39 0e cmp %ecx,(%esi)
10e526: 74 06 je 10e52e <_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;
10e528: 29 fb sub %edi,%ebx
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
10e52a: 85 db test %ebx,%ebx
10e52c: 75 c8 jne 10e4f6 <_Watchdog_Adjust+0x2a> <== ALWAYS TAKEN
}
break;
}
}
_ISR_Enable( level );
10e52e: 50 push %eax
10e52f: 9d popf
}
10e530: 8d 65 f4 lea -0xc(%ebp),%esp
10e533: 5b pop %ebx
10e534: 5e pop %esi
10e535: 5f pop %edi
10e536: c9 leave
10e537: c3 ret
0010cecc <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
10cecc: 55 push %ebp
10cecd: 89 e5 mov %esp,%ebp
10cecf: 56 push %esi
10ced0: 53 push %ebx
10ced1: 8b 55 08 mov 0x8(%ebp),%edx
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
10ced4: 9c pushf
10ced5: fa cli
10ced6: 5e pop %esi
previous_state = the_watchdog->state;
10ced7: 8b 42 08 mov 0x8(%edx),%eax
switch ( previous_state ) {
10ceda: 83 f8 01 cmp $0x1,%eax
10cedd: 74 09 je 10cee8 <_Watchdog_Remove+0x1c>
10cedf: 72 42 jb 10cf23 <_Watchdog_Remove+0x57>
10cee1: 83 f8 03 cmp $0x3,%eax
10cee4: 77 3d ja 10cf23 <_Watchdog_Remove+0x57> <== NEVER TAKEN
10cee6: eb 09 jmp 10cef1 <_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;
10cee8: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
break;
10ceef: eb 32 jmp 10cf23 <_Watchdog_Remove+0x57>
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
10cef1: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx)
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
_ISR_Enable( level );
return( previous_state );
}
10cef8: 8b 0a mov (%edx),%ecx
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
10cefa: 83 39 00 cmpl $0x0,(%ecx)
10cefd: 74 06 je 10cf05 <_Watchdog_Remove+0x39>
next_watchdog->delta_interval += the_watchdog->delta_interval;
10ceff: 8b 5a 10 mov 0x10(%edx),%ebx
10cf02: 01 59 10 add %ebx,0x10(%ecx)
if ( _Watchdog_Sync_count )
10cf05: 8b 1d 50 54 12 00 mov 0x125450,%ebx
10cf0b: 85 db test %ebx,%ebx
10cf0d: 74 0c je 10cf1b <_Watchdog_Remove+0x4f>
_Watchdog_Sync_level = _ISR_Nest_level;
10cf0f: 8b 1d 64 58 12 00 mov 0x125864,%ebx
10cf15: 89 1d e8 53 12 00 mov %ebx,0x1253e8
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
10cf1b: 8b 5a 04 mov 0x4(%edx),%ebx
next->previous = previous;
10cf1e: 89 59 04 mov %ebx,0x4(%ecx)
previous->next = next;
10cf21: 89 0b mov %ecx,(%ebx)
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
10cf23: 8b 0d 54 54 12 00 mov 0x125454,%ecx
10cf29: 89 4a 18 mov %ecx,0x18(%edx)
_ISR_Enable( level );
10cf2c: 56 push %esi
10cf2d: 9d popf
return( previous_state );
}
10cf2e: 5b pop %ebx
10cf2f: 5e pop %esi
10cf30: c9 leave
10cf31: c3 ret
0010e058 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
10e058: 55 push %ebp
10e059: 89 e5 mov %esp,%ebp
10e05b: 57 push %edi
10e05c: 56 push %esi
10e05d: 53 push %ebx
10e05e: 83 ec 20 sub $0x20,%esp
10e061: 8b 7d 08 mov 0x8(%ebp),%edi
10e064: 8b 75 0c mov 0xc(%ebp),%esi
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
10e067: 9c pushf
10e068: fa cli
10e069: 8f 45 e4 popl -0x1c(%ebp)
printk( "Watchdog Chain: %s %p\n", name, header );
10e06c: 56 push %esi
10e06d: 57 push %edi
10e06e: 68 f0 17 12 00 push $0x1217f0
10e073: e8 60 aa ff ff call 108ad8 <printk>
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
10e078: 8b 1e mov (%esi),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10e07a: 83 c6 04 add $0x4,%esi
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
10e07d: 83 c4 10 add $0x10,%esp
10e080: 39 f3 cmp %esi,%ebx
10e082: 74 1d je 10e0a1 <_Watchdog_Report_chain+0x49>
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
10e084: 52 push %edx
10e085: 52 push %edx
10e086: 53 push %ebx
10e087: 6a 00 push $0x0
10e089: e8 32 00 00 00 call 10e0c0 <_Watchdog_Report>
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
node != _Chain_Tail(header) ;
node = node->next )
10e08e: 8b 1b mov (%ebx),%ebx
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
10e090: 83 c4 10 add $0x10,%esp
10e093: 39 f3 cmp %esi,%ebx
10e095: 75 ed jne 10e084 <_Watchdog_Report_chain+0x2c><== NEVER TAKEN
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
10e097: 50 push %eax
10e098: 50 push %eax
10e099: 57 push %edi
10e09a: 68 07 18 12 00 push $0x121807
10e09f: eb 08 jmp 10e0a9 <_Watchdog_Report_chain+0x51>
} else {
printk( "Chain is empty\n" );
10e0a1: 83 ec 0c sub $0xc,%esp
10e0a4: 68 16 18 12 00 push $0x121816
10e0a9: e8 2a aa ff ff call 108ad8 <printk>
10e0ae: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10e0b1: ff 75 e4 pushl -0x1c(%ebp)
10e0b4: 9d popf
}
10e0b5: 8d 65 f4 lea -0xc(%ebp),%esp
10e0b8: 5b pop %ebx
10e0b9: 5e pop %esi
10e0ba: 5f pop %edi
10e0bb: c9 leave
10e0bc: c3 ret
0010b1c8 <_rename_r>:
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
10b1c8: 55 push %ebp
10b1c9: 89 e5 mov %esp,%ebp
10b1cb: 57 push %edi
10b1cc: 56 push %esi
10b1cd: 53 push %ebx
10b1ce: 83 ec 78 sub $0x78,%esp
/*
* Get the parent node of the old path to be renamed. Find the parent path.
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
10b1d1: ff 75 0c pushl 0xc(%ebp)
10b1d4: e8 5e ed ff ff call 109f37 <rtems_filesystem_dirname>
10b1d9: 89 45 94 mov %eax,-0x6c(%ebp)
if ( old_parent_pathlen == 0 )
10b1dc: 83 c4 10 add $0x10,%esp
10b1df: 85 c0 test %eax,%eax
10b1e1: 8d 45 b8 lea -0x48(%ebp),%eax
10b1e4: 75 15 jne 10b1fb <_rename_r+0x33>
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
10b1e6: 51 push %ecx
10b1e7: 50 push %eax
10b1e8: 8d 45 e4 lea -0x1c(%ebp),%eax
10b1eb: 50 push %eax
10b1ec: ff 75 0c pushl 0xc(%ebp)
10b1ef: e8 48 03 00 00 call 10b53c <rtems_filesystem_get_start_loc>
10b1f4: 83 c4 10 add $0x10,%esp
rtems_filesystem_location_info_t old_parent_loc;
rtems_filesystem_location_info_t new_parent_loc;
int i;
int result;
const char *name;
bool free_old_parentloc = false;
10b1f7: 31 db xor %ebx,%ebx
10b1f9: eb 23 jmp 10b21e <_rename_r+0x56>
old_parent_pathlen = rtems_filesystem_dirname ( old );
if ( old_parent_pathlen == 0 )
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
else {
result = rtems_filesystem_evaluate_path( old, old_parent_pathlen,
10b1fb: 83 ec 0c sub $0xc,%esp
10b1fe: 6a 00 push $0x0
10b200: 50 push %eax
10b201: 6a 02 push $0x2
10b203: ff 75 94 pushl -0x6c(%ebp)
10b206: ff 75 0c pushl 0xc(%ebp)
10b209: e8 e8 ec ff ff call 109ef6 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
10b20e: 83 c4 20 add $0x20,%esp
return -1;
10b211: 83 cf ff or $0xffffffff,%edi
else {
result = rtems_filesystem_evaluate_path( old, old_parent_pathlen,
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
10b214: 85 c0 test %eax,%eax
10b216: 0f 85 50 01 00 00 jne 10b36c <_rename_r+0x1a4> <== NEVER TAKEN
return -1;
free_old_parentloc = true;
10b21c: b3 01 mov $0x1,%bl
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
10b21e: 8d 7d cc lea -0x34(%ebp),%edi
10b221: 8d 75 b8 lea -0x48(%ebp),%esi
10b224: b9 05 00 00 00 mov $0x5,%ecx
10b229: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
name = old + old_parent_pathlen;
10b22b: 8b 75 0c mov 0xc(%ebp),%esi
10b22e: 03 75 94 add -0x6c(%ebp),%esi
10b231: 89 75 e0 mov %esi,-0x20(%ebp)
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
10b234: 83 c9 ff or $0xffffffff,%ecx
10b237: 89 f7 mov %esi,%edi
10b239: 31 c0 xor %eax,%eax
10b23b: f2 ae repnz scas %es:(%edi),%al
10b23d: f7 d1 not %ecx
10b23f: 49 dec %ecx
10b240: 52 push %edx
10b241: 52 push %edx
10b242: 51 push %ecx
10b243: 56 push %esi
10b244: e8 2d ed ff ff call 109f76 <rtems_filesystem_prefix_separators>
10b249: 01 c6 add %eax,%esi
10b24b: 89 75 e0 mov %esi,-0x20(%ebp)
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
10b24e: 83 c9 ff or $0xffffffff,%ecx
10b251: 89 f7 mov %esi,%edi
10b253: 31 c0 xor %eax,%eax
10b255: f2 ae repnz scas %es:(%edi),%al
10b257: f7 d1 not %ecx
10b259: 49 dec %ecx
10b25a: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10b261: 8d 7d cc lea -0x34(%ebp),%edi
10b264: 57 push %edi
10b265: 6a 00 push $0x0
10b267: 51 push %ecx
10b268: 56 push %esi
10b269: e8 2a ec ff ff call 109e98 <rtems_filesystem_evaluate_relative_path>
0, &old_loc, false );
if ( result != 0 ) {
10b26e: 83 c4 20 add $0x20,%esp
10b271: 85 c0 test %eax,%eax
10b273: 74 16 je 10b28b <_rename_r+0xc3>
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
return -1;
10b275: 83 cf ff or $0xffffffff,%edi
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &old_loc, false );
if ( result != 0 ) {
if ( free_old_parentloc )
10b278: 84 db test %bl,%bl
10b27a: 0f 84 ec 00 00 00 je 10b36c <_rename_r+0x1a4> <== NEVER TAKEN
rtems_filesystem_freenode( &old_parent_loc );
10b280: 83 ec 0c sub $0xc,%esp
10b283: 8d 45 b8 lea -0x48(%ebp),%eax
10b286: e9 d8 00 00 00 jmp 10b363 <_rename_r+0x19b>
/*
* Get the parent of the new node we are renaming to.
*/
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
10b28b: 50 push %eax
10b28c: 8d 75 a4 lea -0x5c(%ebp),%esi
10b28f: 56 push %esi
10b290: 8d 45 e4 lea -0x1c(%ebp),%eax
10b293: 50 push %eax
10b294: ff 75 10 pushl 0x10(%ebp)
10b297: e8 a0 02 00 00 call 10b53c <rtems_filesystem_get_start_loc>
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
10b29c: 83 c4 0c add $0xc,%esp
10b29f: 8d 45 e0 lea -0x20(%ebp),%eax
10b2a2: 50 push %eax
10b2a3: 56 push %esi
10b2a4: 8b 45 10 mov 0x10(%ebp),%eax
10b2a7: 03 45 e4 add -0x1c(%ebp),%eax
10b2aa: 50 push %eax
10b2ab: 8b 45 b0 mov -0x50(%ebp),%eax
10b2ae: ff 50 04 call *0x4(%eax)
if ( result != 0 ) {
10b2b1: 83 c4 10 add $0x10,%esp
10b2b4: 85 c0 test %eax,%eax
10b2b6: 74 2d je 10b2e5 <_rename_r+0x11d>
rtems_filesystem_freenode( &new_parent_loc );
10b2b8: 83 ec 0c sub $0xc,%esp
10b2bb: 56 push %esi
10b2bc: e8 43 ee ff ff call 10a104 <rtems_filesystem_freenode>
if ( free_old_parentloc )
10b2c1: 83 c4 10 add $0x10,%esp
10b2c4: 84 db test %bl,%bl
10b2c6: 74 0f je 10b2d7 <_rename_r+0x10f> <== NEVER TAKEN
rtems_filesystem_freenode( &old_parent_loc );
10b2c8: 83 ec 0c sub $0xc,%esp
10b2cb: 8d 45 b8 lea -0x48(%ebp),%eax
10b2ce: 50 push %eax
10b2cf: e8 30 ee ff ff call 10a104 <rtems_filesystem_freenode>
10b2d4: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( &old_loc );
10b2d7: 83 ec 0c sub $0xc,%esp
10b2da: 8d 45 cc lea -0x34(%ebp),%eax
10b2dd: 50 push %eax
10b2de: e8 21 ee ff ff call 10a104 <rtems_filesystem_freenode>
10b2e3: eb 3e jmp 10b323 <_rename_r+0x15b>
/*
* Check to see if the caller is trying to rename across file system
* boundaries.
*/
if ( old_parent_loc.mt_entry != new_parent_loc.mt_entry ) {
10b2e5: 8b 45 b4 mov -0x4c(%ebp),%eax
10b2e8: 39 45 c8 cmp %eax,-0x38(%ebp)
10b2eb: 74 3e je 10b32b <_rename_r+0x163>
rtems_filesystem_freenode( &new_parent_loc );
10b2ed: 83 ec 0c sub $0xc,%esp
10b2f0: 56 push %esi
10b2f1: e8 0e ee ff ff call 10a104 <rtems_filesystem_freenode>
if ( free_old_parentloc )
10b2f6: 83 c4 10 add $0x10,%esp
10b2f9: 84 db test %bl,%bl
10b2fb: 74 0f je 10b30c <_rename_r+0x144>
rtems_filesystem_freenode( &old_parent_loc );
10b2fd: 83 ec 0c sub $0xc,%esp
10b300: 8d 45 b8 lea -0x48(%ebp),%eax
10b303: 50 push %eax
10b304: e8 fb ed ff ff call 10a104 <rtems_filesystem_freenode>
10b309: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( &old_loc );
10b30c: 83 ec 0c sub $0xc,%esp
10b30f: 8d 45 cc lea -0x34(%ebp),%eax
10b312: 50 push %eax
10b313: e8 ec ed ff ff call 10a104 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EXDEV );
10b318: e8 37 95 00 00 call 114854 <__errno>
10b31d: c7 00 12 00 00 00 movl $0x12,(%eax)
10b323: 83 c4 10 add $0x10,%esp
10b326: 83 cf ff or $0xffffffff,%edi
10b329: eb 41 jmp 10b36c <_rename_r+0x1a4>
}
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
10b32b: ff 75 e0 pushl -0x20(%ebp)
10b32e: 56 push %esi
10b32f: 57 push %edi
10b330: 8d 55 b8 lea -0x48(%ebp),%edx
10b333: 52 push %edx
10b334: 8b 45 b0 mov -0x50(%ebp),%eax
10b337: 89 55 90 mov %edx,-0x70(%ebp)
10b33a: ff 50 40 call *0x40(%eax)
10b33d: 89 c7 mov %eax,%edi
rtems_filesystem_freenode( &new_parent_loc );
10b33f: 89 34 24 mov %esi,(%esp)
10b342: e8 bd ed ff ff call 10a104 <rtems_filesystem_freenode>
if ( free_old_parentloc )
10b347: 83 c4 10 add $0x10,%esp
10b34a: 84 db test %bl,%bl
10b34c: 8b 55 90 mov -0x70(%ebp),%edx
10b34f: 74 0c je 10b35d <_rename_r+0x195>
rtems_filesystem_freenode( &old_parent_loc );
10b351: 83 ec 0c sub $0xc,%esp
10b354: 52 push %edx
10b355: e8 aa ed ff ff call 10a104 <rtems_filesystem_freenode>
10b35a: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( &old_loc );
10b35d: 83 ec 0c sub $0xc,%esp
10b360: 8d 45 cc lea -0x34(%ebp),%eax
10b363: 50 push %eax
10b364: e8 9b ed ff ff call 10a104 <rtems_filesystem_freenode>
return result;
10b369: 83 c4 10 add $0x10,%esp
}
10b36c: 89 f8 mov %edi,%eax
10b36e: 8d 65 f4 lea -0xc(%ebp),%esp
10b371: 5b pop %ebx
10b372: 5e pop %esi
10b373: 5f pop %edi
10b374: c9 leave
10b375: c3 ret
0010a7b4 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
10a7b4: 55 push %ebp
10a7b5: 89 e5 mov %esp,%ebp
10a7b7: 57 push %edi
10a7b8: 56 push %esi
10a7b9: 53 push %ebx
10a7ba: 83 ec 18 sub $0x18,%esp
10a7bd: 8b 75 08 mov 0x8(%ebp),%esi
10a7c0: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
10a7c3: 68 d8 72 12 00 push $0x1272d8
10a7c8: e8 2f 10 00 00 call 10b7fc <pthread_mutex_lock>
if (fcntl (fildes, F_GETFD) < 0) {
10a7cd: 5f pop %edi
10a7ce: 58 pop %eax
10a7cf: 6a 01 push $0x1
10a7d1: 56 push %esi
10a7d2: e8 e5 60 00 00 call 1108bc <fcntl>
10a7d7: 83 c4 10 add $0x10,%esp
10a7da: 85 c0 test %eax,%eax
10a7dc: 79 1d jns 10a7fb <aio_cancel+0x47>
pthread_mutex_unlock(&aio_request_queue.mutex);
10a7de: 83 ec 0c sub $0xc,%esp
10a7e1: 68 d8 72 12 00 push $0x1272d8
10a7e6: e8 91 10 00 00 call 10b87c <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
10a7eb: e8 7c 8e 00 00 call 11366c <__errno>
10a7f0: c7 00 09 00 00 00 movl $0x9,(%eax)
10a7f6: e9 e3 00 00 00 jmp 10a8de <aio_cancel+0x12a>
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
10a7fb: 85 db test %ebx,%ebx
10a7fd: 0f 85 bd 00 00 00 jne 10a8c0 <aio_cancel+0x10c>
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
10a803: 51 push %ecx
10a804: 6a 00 push $0x0
10a806: 56 push %esi
10a807: 68 20 73 12 00 push $0x127320
10a80c: e8 27 03 00 00 call 10ab38 <rtems_aio_search_fd>
10a811: 89 c3 mov %eax,%ebx
if (r_chain == NULL) {
10a813: 83 c4 10 add $0x10,%esp
10a816: 85 c0 test %eax,%eax
10a818: 75 6c jne 10a886 <aio_cancel+0xd2>
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
10a81a: 81 3d 2c 73 12 00 30 cmpl $0x127330,0x12732c
10a821: 73 12 00
10a824: 0f 84 07 01 00 00 je 10a931 <aio_cancel+0x17d> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
10a82a: 52 push %edx
10a82b: 6a 00 push $0x0
10a82d: 56 push %esi
10a82e: 68 2c 73 12 00 push $0x12732c
10a833: e8 00 03 00 00 call 10ab38 <rtems_aio_search_fd>
10a838: 89 c3 mov %eax,%ebx
if (r_chain == NULL) {
10a83a: 83 c4 10 add $0x10,%esp
10a83d: 85 c0 test %eax,%eax
10a83f: 75 17 jne 10a858 <aio_cancel+0xa4>
pthread_mutex_unlock(&aio_request_queue.mutex);
10a841: 83 ec 0c sub $0xc,%esp
10a844: 68 d8 72 12 00 push $0x1272d8
10a849: e8 2e 10 00 00 call 10b87c <pthread_mutex_unlock>
return AIO_ALLDONE;
10a84e: 83 c4 10 add $0x10,%esp
10a851: b3 02 mov $0x2,%bl
10a853: e9 21 01 00 00 jmp 10a979 <aio_cancel+0x1c5>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10a858: 83 ec 0c sub $0xc,%esp
10a85b: 50 push %eax
10a85c: e8 03 27 00 00 call 10cf64 <_Chain_Extract>
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10a861: 89 1c 24 mov %ebx,(%esp)
10a864: e8 12 06 00 00 call 10ae7b <rtems_aio_remove_fd>
pthread_mutex_destroy (&r_chain->mutex);
10a869: 8d 73 1c lea 0x1c(%ebx),%esi
10a86c: 89 34 24 mov %esi,(%esp)
10a86f: e8 68 0d 00 00 call 10b5dc <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->mutex);
10a874: 89 34 24 mov %esi,(%esp)
10a877: e8 6c 0a 00 00 call 10b2e8 <pthread_cond_destroy>
free (r_chain);
10a87c: 89 1c 24 mov %ebx,(%esp)
10a87f: e8 ac d4 ff ff call 107d30 <free>
10a884: eb 24 jmp 10a8aa <aio_cancel+0xf6>
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
10a886: 8d 70 1c lea 0x1c(%eax),%esi
10a889: 83 ec 0c sub $0xc,%esp
10a88c: 56 push %esi
10a88d: e8 6a 0f 00 00 call 10b7fc <pthread_mutex_lock>
10a892: 89 1c 24 mov %ebx,(%esp)
10a895: e8 ca 26 00 00 call 10cf64 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
10a89a: 89 1c 24 mov %ebx,(%esp)
10a89d: e8 d9 05 00 00 call 10ae7b <rtems_aio_remove_fd>
pthread_mutex_unlock (&r_chain->mutex);
10a8a2: 89 34 24 mov %esi,(%esp)
10a8a5: e8 d2 0f 00 00 call 10b87c <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
10a8aa: c7 04 24 d8 72 12 00 movl $0x1272d8,(%esp)
10a8b1: e8 c6 0f 00 00 call 10b87c <pthread_mutex_unlock>
return AIO_CANCELED;
10a8b6: 83 c4 10 add $0x10,%esp
10a8b9: 31 db xor %ebx,%ebx
10a8bb: e9 b9 00 00 00 jmp 10a979 <aio_cancel+0x1c5>
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
10a8c0: 8b 3b mov (%ebx),%edi
10a8c2: 39 f7 cmp %esi,%edi
10a8c4: 74 23 je 10a8e9 <aio_cancel+0x135>
pthread_mutex_unlock (&aio_request_queue.mutex);
10a8c6: 83 ec 0c sub $0xc,%esp
10a8c9: 68 d8 72 12 00 push $0x1272d8
10a8ce: e8 a9 0f 00 00 call 10b87c <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
10a8d3: e8 94 8d 00 00 call 11366c <__errno>
10a8d8: c7 00 16 00 00 00 movl $0x16,(%eax)
10a8de: 83 c4 10 add $0x10,%esp
10a8e1: 83 cb ff or $0xffffffff,%ebx
10a8e4: e9 90 00 00 00 jmp 10a979 <aio_cancel+0x1c5>
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
10a8e9: 50 push %eax
10a8ea: 6a 00 push $0x0
10a8ec: 57 push %edi
10a8ed: 68 20 73 12 00 push $0x127320
10a8f2: e8 41 02 00 00 call 10ab38 <rtems_aio_search_fd>
10a8f7: 89 c6 mov %eax,%esi
if (r_chain == NULL) {
10a8f9: 83 c4 10 add $0x10,%esp
10a8fc: 85 c0 test %eax,%eax
10a8fe: 75 48 jne 10a948 <aio_cancel+0x194>
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
10a900: 81 3d 2c 73 12 00 30 cmpl $0x127330,0x12732c
10a907: 73 12 00
10a90a: 74 25 je 10a931 <aio_cancel+0x17d> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
10a90c: 56 push %esi
10a90d: 6a 00 push $0x0
10a90f: 57 push %edi
10a910: 68 2c 73 12 00 push $0x12732c
10a915: e8 1e 02 00 00 call 10ab38 <rtems_aio_search_fd>
if (r_chain == NULL) {
10a91a: 83 c4 10 add $0x10,%esp
10a91d: 85 c0 test %eax,%eax
10a91f: 74 a5 je 10a8c6 <aio_cancel+0x112>
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
10a921: 51 push %ecx
10a922: 51 push %ecx
10a923: 53 push %ebx
10a924: 83 c0 08 add $0x8,%eax
10a927: 50 push %eax
10a928: e8 97 05 00 00 call 10aec4 <rtems_aio_remove_req>
10a92d: 89 c3 mov %eax,%ebx
10a92f: eb 39 jmp 10a96a <aio_cancel+0x1b6>
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
} else {
pthread_mutex_unlock (&aio_request_queue.mutex);
10a931: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10a934: 68 d8 72 12 00 push $0x1272d8 <== NOT EXECUTED
10a939: e8 3e 0f 00 00 call 10b87c <pthread_mutex_unlock> <== NOT EXECUTED
return AIO_ALLDONE;
10a93e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10a941: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED
10a946: eb 31 jmp 10a979 <aio_cancel+0x1c5> <== NOT EXECUTED
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
10a948: 8d 78 1c lea 0x1c(%eax),%edi
10a94b: 83 ec 0c sub $0xc,%esp
10a94e: 57 push %edi
10a94f: e8 a8 0e 00 00 call 10b7fc <pthread_mutex_lock>
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
10a954: 58 pop %eax
10a955: 5a pop %edx
10a956: 53 push %ebx
10a957: 83 c6 08 add $0x8,%esi
10a95a: 56 push %esi
10a95b: e8 64 05 00 00 call 10aec4 <rtems_aio_remove_req>
10a960: 89 c3 mov %eax,%ebx
pthread_mutex_unlock (&r_chain->mutex);
10a962: 89 3c 24 mov %edi,(%esp)
10a965: e8 12 0f 00 00 call 10b87c <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
10a96a: c7 04 24 d8 72 12 00 movl $0x1272d8,(%esp)
10a971: e8 06 0f 00 00 call 10b87c <pthread_mutex_unlock>
return result;
10a976: 83 c4 10 add $0x10,%esp
}
return AIO_ALLDONE;
}
10a979: 89 d8 mov %ebx,%eax
10a97b: 8d 65 f4 lea -0xc(%ebp),%esp
10a97e: 5b pop %ebx
10a97f: 5e pop %esi
10a980: 5f pop %edi
10a981: c9 leave
10a982: c3 ret
0010a990 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
10a990: 55 push %ebp
10a991: 89 e5 mov %esp,%ebp
10a993: 53 push %ebx
10a994: 83 ec 04 sub $0x4,%esp
10a997: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
10a99a: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp)
10a9a1: 74 1b je 10a9be <aio_fsync+0x2e>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10a9a3: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10a9aa: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10a9b1: e8 b6 8c 00 00 call 11366c <__errno>
10a9b6: c7 00 16 00 00 00 movl $0x16,(%eax)
10a9bc: eb 74 jmp 10aa32 <aio_fsync+0xa2>
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10a9be: 50 push %eax
10a9bf: 50 push %eax
10a9c0: 6a 03 push $0x3
10a9c2: ff 33 pushl (%ebx)
10a9c4: e8 f3 5e 00 00 call 1108bc <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10a9c9: 83 e0 03 and $0x3,%eax
10a9cc: 48 dec %eax
10a9cd: 83 c4 10 add $0x10,%esp
10a9d0: 83 f8 01 cmp $0x1,%eax
10a9d3: 76 1b jbe 10a9f0 <aio_fsync+0x60>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10a9d5: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10a9dc: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10a9e3: e8 84 8c 00 00 call 11366c <__errno>
10a9e8: c7 00 09 00 00 00 movl $0x9,(%eax)
10a9ee: eb 42 jmp 10aa32 <aio_fsync+0xa2>
req = malloc (sizeof (rtems_aio_request));
10a9f0: 83 ec 0c sub $0xc,%esp
10a9f3: 6a 18 push $0x18
10a9f5: e8 ba d7 ff ff call 1081b4 <malloc>
if (req == NULL)
10a9fa: 83 c4 10 add $0x10,%esp
10a9fd: 85 c0 test %eax,%eax
10a9ff: 75 1b jne 10aa1c <aio_fsync+0x8c> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10aa01: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10aa08: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10aa0f: e8 58 8c 00 00 call 11366c <__errno> <== NOT EXECUTED
10aa14: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10aa1a: eb 16 jmp 10aa32 <aio_fsync+0xa2> <== NOT EXECUTED
req->aiocbp = aiocbp;
10aa1c: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_SYNC;
10aa1f: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx)
return rtems_aio_enqueue (req);
10aa26: 89 45 08 mov %eax,0x8(%ebp)
}
10aa29: 8b 5d fc mov -0x4(%ebp),%ebx
10aa2c: c9 leave
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
return rtems_aio_enqueue (req);
10aa2d: e9 ef 04 00 00 jmp 10af21 <rtems_aio_enqueue>
}
10aa32: 83 c8 ff or $0xffffffff,%eax
10aa35: 8b 5d fc mov -0x4(%ebp),%ebx
10aa38: c9 leave
10aa39: c3 ret
0010b124 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
10b124: 55 push %ebp
10b125: 89 e5 mov %esp,%ebp
10b127: 53 push %ebx
10b128: 83 ec 0c sub $0xc,%esp
10b12b: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10b12e: 6a 03 push $0x3
10b130: ff 33 pushl (%ebx)
10b132: e8 85 57 00 00 call 1108bc <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10b137: 83 e0 03 and $0x3,%eax
10b13a: 83 c4 10 add $0x10,%esp
10b13d: 83 f8 02 cmp $0x2,%eax
10b140: 74 1f je 10b161 <aio_read+0x3d>
10b142: 85 c0 test %eax,%eax
10b144: 74 1b je 10b161 <aio_read+0x3d> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10b146: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10b14d: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b154: e8 13 85 00 00 call 11366c <__errno>
10b159: c7 00 09 00 00 00 movl $0x9,(%eax)
10b15f: eb 69 jmp 10b1ca <aio_read+0xa6>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10b161: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10b165: 75 06 jne 10b16d <aio_read+0x49>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10b167: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10b16b: 79 1b jns 10b188 <aio_read+0x64>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10b16d: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10b174: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b17b: e8 ec 84 00 00 call 11366c <__errno>
10b180: c7 00 16 00 00 00 movl $0x16,(%eax)
10b186: eb 42 jmp 10b1ca <aio_read+0xa6>
req = malloc (sizeof (rtems_aio_request));
10b188: 83 ec 0c sub $0xc,%esp
10b18b: 6a 18 push $0x18
10b18d: e8 22 d0 ff ff call 1081b4 <malloc>
if (req == NULL)
10b192: 83 c4 10 add $0x10,%esp
10b195: 85 c0 test %eax,%eax
10b197: 75 1b jne 10b1b4 <aio_read+0x90> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10b199: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10b1a0: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10b1a7: e8 c0 84 00 00 call 11366c <__errno> <== NOT EXECUTED
10b1ac: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10b1b2: eb 16 jmp 10b1ca <aio_read+0xa6> <== NOT EXECUTED
req->aiocbp = aiocbp;
10b1b4: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_READ;
10b1b7: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx)
return rtems_aio_enqueue (req);
10b1be: 89 45 08 mov %eax,0x8(%ebp)
}
10b1c1: 8b 5d fc mov -0x4(%ebp),%ebx
10b1c4: c9 leave
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
return rtems_aio_enqueue (req);
10b1c5: e9 57 fd ff ff jmp 10af21 <rtems_aio_enqueue>
}
10b1ca: 83 c8 ff or $0xffffffff,%eax
10b1cd: 8b 5d fc mov -0x4(%ebp),%ebx
10b1d0: c9 leave
10b1d1: c3 ret
0010b1e0 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
10b1e0: 55 push %ebp
10b1e1: 89 e5 mov %esp,%ebp
10b1e3: 53 push %ebx
10b1e4: 83 ec 0c sub $0xc,%esp
10b1e7: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
10b1ea: 6a 03 push $0x3
10b1ec: ff 33 pushl (%ebx)
10b1ee: e8 c9 56 00 00 call 1108bc <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
10b1f3: 83 e0 03 and $0x3,%eax
10b1f6: 48 dec %eax
10b1f7: 83 c4 10 add $0x10,%esp
10b1fa: 83 f8 01 cmp $0x1,%eax
10b1fd: 76 1b jbe 10b21a <aio_write+0x3a>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
10b1ff: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx)
10b206: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b20d: e8 5a 84 00 00 call 11366c <__errno>
10b212: c7 00 09 00 00 00 movl $0x9,(%eax)
10b218: eb 69 jmp 10b283 <aio_write+0xa3>
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
10b21a: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10b21e: 75 06 jne 10b226 <aio_write+0x46>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
10b220: 83 7b 08 00 cmpl $0x0,0x8(%ebx)
10b224: 79 1b jns 10b241 <aio_write+0x61>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
10b226: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx)
10b22d: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx)
10b234: e8 33 84 00 00 call 11366c <__errno>
10b239: c7 00 16 00 00 00 movl $0x16,(%eax)
10b23f: eb 42 jmp 10b283 <aio_write+0xa3>
req = malloc (sizeof (rtems_aio_request));
10b241: 83 ec 0c sub $0xc,%esp
10b244: 6a 18 push $0x18
10b246: e8 69 cf ff ff call 1081b4 <malloc>
if (req == NULL)
10b24b: 83 c4 10 add $0x10,%esp
10b24e: 85 c0 test %eax,%eax
10b250: 75 1b jne 10b26d <aio_write+0x8d> <== ALWAYS TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
10b252: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED
10b259: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED
10b260: e8 07 84 00 00 call 11366c <__errno> <== NOT EXECUTED
10b265: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED
10b26b: eb 16 jmp 10b283 <aio_write+0xa3> <== NOT EXECUTED
req->aiocbp = aiocbp;
10b26d: 89 58 14 mov %ebx,0x14(%eax)
req->aiocbp->aio_lio_opcode = LIO_WRITE;
10b270: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx)
return rtems_aio_enqueue (req);
10b277: 89 45 08 mov %eax,0x8(%ebp)
}
10b27a: 8b 5d fc mov -0x4(%ebp),%ebx
10b27d: c9 leave
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
return rtems_aio_enqueue (req);
10b27e: e9 9e fc ff ff jmp 10af21 <rtems_aio_enqueue>
}
10b283: 83 c8 ff or $0xffffffff,%eax
10b286: 8b 5d fc mov -0x4(%ebp),%ebx
10b289: c9 leave
10b28a: c3 ret
00107518 <chroot>:
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
107518: 55 push %ebp
107519: 89 e5 mov %esp,%ebp
10751b: 57 push %edi
10751c: 56 push %esi
10751d: 83 ec 20 sub $0x20,%esp
int result;
rtems_filesystem_location_info_t loc;
/* an automatic call to new private env the first time */
if (rtems_current_user_env == &rtems_global_user_env) {
107520: 81 3d 6c 30 12 00 48 cmpl $0x125248,0x12306c
107527: 52 12 00
10752a: 75 1e jne 10754a <chroot+0x32>
rtems_libio_set_private_env(); /* try to set a new private env*/
10752c: e8 cc 10 00 00 call 1085fd <rtems_libio_set_private_env>
if (rtems_current_user_env == &rtems_global_user_env) /* not ok */
107531: 81 3d 6c 30 12 00 48 cmpl $0x125248,0x12306c
107538: 52 12 00
10753b: 75 0d jne 10754a <chroot+0x32>
rtems_set_errno_and_return_minus_one( ENOTSUP );
10753d: e8 52 a3 00 00 call 111894 <__errno>
107542: c7 00 86 00 00 00 movl $0x86,(%eax)
107548: eb 22 jmp 10756c <chroot+0x54>
}
result = chdir(pathname);
10754a: 83 ec 0c sub $0xc,%esp
10754d: ff 75 08 pushl 0x8(%ebp)
107550: e8 87 74 00 00 call 10e9dc <chdir>
if (result) {
107555: 83 c4 10 add $0x10,%esp
107558: 85 c0 test %eax,%eax
10755a: 74 15 je 107571 <chroot+0x59>
rtems_set_errno_and_return_minus_one( errno );
10755c: e8 33 a3 00 00 call 111894 <__errno>
107561: 89 c6 mov %eax,%esi
107563: e8 2c a3 00 00 call 111894 <__errno>
107568: 8b 00 mov (%eax),%eax
10756a: 89 06 mov %eax,(%esi)
10756c: 83 c8 ff or $0xffffffff,%eax
10756f: eb 44 jmp 1075b5 <chroot+0x9d>
}
/* clone the new root location */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
107571: 83 ec 0c sub $0xc,%esp
107574: 6a 00 push $0x0
107576: 8d 75 e4 lea -0x1c(%ebp),%esi
107579: 56 push %esi
10757a: 6a 00 push $0x0
10757c: 6a 01 push $0x1
10757e: 68 3e fc 11 00 push $0x11fc3e
107583: e8 02 01 00 00 call 10768a <rtems_filesystem_evaluate_path>
107588: 83 c4 20 add $0x20,%esp
10758b: 85 c0 test %eax,%eax
10758d: 75 cd jne 10755c <chroot+0x44> <== NEVER TAKEN
/* our cwd has changed, though - but there is no easy way of return :-( */
rtems_set_errno_and_return_minus_one( errno );
}
rtems_filesystem_freenode(&rtems_filesystem_root);
10758f: 83 ec 0c sub $0xc,%esp
107592: a1 6c 30 12 00 mov 0x12306c,%eax
107597: 83 c0 18 add $0x18,%eax
10759a: 50 push %eax
10759b: e8 a8 01 00 00 call 107748 <rtems_filesystem_freenode>
rtems_filesystem_root = loc;
1075a0: 8b 3d 6c 30 12 00 mov 0x12306c,%edi
1075a6: 83 c7 18 add $0x18,%edi
1075a9: b9 05 00 00 00 mov $0x5,%ecx
1075ae: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return 0;
1075b0: 83 c4 10 add $0x10,%esp
1075b3: 31 c0 xor %eax,%eax
}
1075b5: 8d 65 f8 lea -0x8(%ebp),%esp
1075b8: 5e pop %esi
1075b9: 5f pop %edi
1075ba: c9 leave
1075bb: c3 ret
00109f98 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
109f98: 55 push %ebp
109f99: 89 e5 mov %esp,%ebp
109f9b: 83 ec 08 sub $0x8,%esp
109f9e: 8b 45 08 mov 0x8(%ebp),%eax
109fa1: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
109fa4: 85 d2 test %edx,%edx
109fa6: 74 3c je 109fe4 <clock_gettime+0x4c>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
109fa8: 83 f8 01 cmp $0x1,%eax
109fab: 75 0b jne 109fb8 <clock_gettime+0x20>
_TOD_Get(tp);
109fad: 83 ec 0c sub $0xc,%esp
109fb0: 52 push %edx
109fb1: e8 aa 1b 00 00 call 10bb60 <_TOD_Get>
109fb6: eb 13 jmp 109fcb <clock_gettime+0x33>
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
109fb8: 83 f8 04 cmp $0x4,%eax
109fbb: 74 05 je 109fc2 <clock_gettime+0x2a> <== NEVER TAKEN
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME ) {
109fbd: 83 f8 02 cmp $0x2,%eax
109fc0: 75 10 jne 109fd2 <clock_gettime+0x3a>
_TOD_Get_uptime_as_timespec( tp );
109fc2: 83 ec 0c sub $0xc,%esp
109fc5: 52 push %edx
109fc6: e8 e9 1b 00 00 call 10bbb4 <_TOD_Get_uptime_as_timespec>
return 0;
109fcb: 83 c4 10 add $0x10,%esp
109fce: 31 c0 xor %eax,%eax
109fd0: eb 20 jmp 109ff2 <clock_gettime+0x5a>
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME )
109fd2: 83 f8 03 cmp $0x3,%eax
109fd5: 75 0d jne 109fe4 <clock_gettime+0x4c>
rtems_set_errno_and_return_minus_one( ENOSYS );
109fd7: e8 84 7f 00 00 call 111f60 <__errno>
109fdc: c7 00 58 00 00 00 movl $0x58,(%eax)
109fe2: eb 0b jmp 109fef <clock_gettime+0x57>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
109fe4: e8 77 7f 00 00 call 111f60 <__errno>
109fe9: c7 00 16 00 00 00 movl $0x16,(%eax)
109fef: 83 c8 ff or $0xffffffff,%eax
return 0;
}
109ff2: c9 leave
109ff3: c3 ret
00109ff4 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
109ff4: 55 push %ebp
109ff5: 89 e5 mov %esp,%ebp
109ff7: 83 ec 08 sub $0x8,%esp
109ffa: 8b 45 08 mov 0x8(%ebp),%eax
109ffd: 8b 55 0c mov 0xc(%ebp),%edx
if ( !tp )
10a000: 85 d2 test %edx,%edx
10a002: 74 44 je 10a048 <clock_settime+0x54> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
10a004: 83 f8 01 cmp $0x1,%eax
10a007: 75 28 jne 10a031 <clock_settime+0x3d>
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
10a009: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx)
10a00f: 76 37 jbe 10a048 <clock_settime+0x54>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a011: a1 e0 74 12 00 mov 0x1274e0,%eax
10a016: 40 inc %eax
10a017: a3 e0 74 12 00 mov %eax,0x1274e0
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
10a01c: 83 ec 0c sub $0xc,%esp
10a01f: 52 push %edx
10a020: e8 e7 1b 00 00 call 10bc0c <_TOD_Set>
_Thread_Enable_dispatch();
10a025: e8 30 2f 00 00 call 10cf5a <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
10a02a: 83 c4 10 add $0x10,%esp
10a02d: 31 c0 xor %eax,%eax
10a02f: eb 25 jmp 10a056 <clock_settime+0x62>
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME )
10a031: 83 f8 02 cmp $0x2,%eax
10a034: 74 05 je 10a03b <clock_settime+0x47>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME )
10a036: 83 f8 03 cmp $0x3,%eax
10a039: 75 0d jne 10a048 <clock_settime+0x54>
rtems_set_errno_and_return_minus_one( ENOSYS );
10a03b: e8 20 7f 00 00 call 111f60 <__errno>
10a040: c7 00 58 00 00 00 movl $0x58,(%eax)
10a046: eb 0b jmp 10a053 <clock_settime+0x5f>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
10a048: e8 13 7f 00 00 call 111f60 <__errno>
10a04d: c7 00 16 00 00 00 movl $0x16,(%eax)
10a053: 83 c8 ff or $0xffffffff,%eax
return 0;
}
10a056: c9 leave
10a057: c3 ret
0010d460 <devFS_evaluate_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
10d460: 55 push %ebp
10d461: 89 e5 mov %esp,%ebp
10d463: 57 push %edi
10d464: 56 push %esi
10d465: 53 push %ebx
10d466: 83 ec 1c sub $0x1c,%esp
10d469: 8b 4d 0c mov 0xc(%ebp),%ecx
10d46c: 8b 5d 14 mov 0x14(%ebp),%ebx
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
10d46f: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp)
10d476: 74 0d je 10d485 <devFS_evaluate_path+0x25><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
10d478: e8 47 22 00 00 call 10f6c4 <__errno> <== NOT EXECUTED
10d47d: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED
10d483: eb 77 jmp 10d4fc <devFS_evaluate_path+0x9c><== NOT EXECUTED
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
10d485: 8b 33 mov (%ebx),%esi
if (!device_name_table)
10d487: 85 f6 test %esi,%esi
10d489: 74 04 je 10d48f <devFS_evaluate_path+0x2f>
10d48b: 31 ff xor %edi,%edi
10d48d: eb 5a jmp 10d4e9 <devFS_evaluate_path+0x89>
rtems_set_errno_and_return_minus_one( EFAULT );
10d48f: e8 30 22 00 00 call 10f6c4 <__errno>
10d494: c7 00 0e 00 00 00 movl $0xe,(%eax)
10d49a: eb 60 jmp 10d4fc <devFS_evaluate_path+0x9c>
for (i = 0; i < rtems_device_table_size; i++) {
if (!device_name_table[i].device_name)
10d49c: 8b 16 mov (%esi),%edx
10d49e: 85 d2 test %edx,%edx
10d4a0: 74 43 je 10d4e5 <devFS_evaluate_path+0x85>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
10d4a2: 50 push %eax
10d4a3: 51 push %ecx
10d4a4: 52 push %edx
10d4a5: ff 75 08 pushl 0x8(%ebp)
10d4a8: 89 55 e4 mov %edx,-0x1c(%ebp)
10d4ab: 89 4d e0 mov %ecx,-0x20(%ebp)
10d4ae: e8 f1 2e 00 00 call 1103a4 <strncmp>
10d4b3: 83 c4 10 add $0x10,%esp
10d4b6: 85 c0 test %eax,%eax
10d4b8: 8b 55 e4 mov -0x1c(%ebp),%edx
10d4bb: 8b 4d e0 mov -0x20(%ebp),%ecx
10d4be: 75 25 jne 10d4e5 <devFS_evaluate_path+0x85>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
10d4c0: 80 3c 0a 00 cmpb $0x0,(%edx,%ecx,1)
10d4c4: 75 1f jne 10d4e5 <devFS_evaluate_path+0x85><== NEVER TAKEN
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
10d4c6: 89 33 mov %esi,(%ebx)
pathloc->handlers = &devFS_file_handlers;
10d4c8: c7 43 08 ac 0f 12 00 movl $0x120fac,0x8(%ebx)
pathloc->ops = &devFS_ops;
10d4cf: c7 43 0c 64 0f 12 00 movl $0x120f64,0xc(%ebx)
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
10d4d6: a1 00 11 12 00 mov 0x121100,%eax
10d4db: 8b 40 28 mov 0x28(%eax),%eax
10d4de: 89 43 10 mov %eax,0x10(%ebx)
return 0;
10d4e1: 31 c0 xor %eax,%eax
10d4e3: eb 1a jmp 10d4ff <devFS_evaluate_path+0x9f>
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
10d4e5: 47 inc %edi
10d4e6: 83 c6 14 add $0x14,%esi
10d4e9: 3b 3d 48 f1 11 00 cmp 0x11f148,%edi
10d4ef: 72 ab jb 10d49c <devFS_evaluate_path+0x3c>
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
}
/* no such file or directory */
rtems_set_errno_and_return_minus_one( ENOENT );
10d4f1: e8 ce 21 00 00 call 10f6c4 <__errno>
10d4f6: c7 00 02 00 00 00 movl $0x2,(%eax)
10d4fc: 83 c8 ff or $0xffffffff,%eax
}
10d4ff: 8d 65 f4 lea -0xc(%ebp),%esp
10d502: 5b pop %ebx
10d503: 5e pop %esi
10d504: 5f pop %edi
10d505: c9 leave
10d506: c3 ret
00106c40 <devFS_mknod>:
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
106c40: 55 push %ebp
106c41: 89 e5 mov %esp,%ebp
106c43: 57 push %edi
106c44: 56 push %esi
106c45: 53 push %ebx
106c46: 83 ec 1c sub $0x1c,%esp
106c49: 8b 7d 08 mov 0x8(%ebp),%edi
106c4c: 8b 4d 10 mov 0x10(%ebp),%ecx
106c4f: 8b 55 14 mov 0x14(%ebp),%edx
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
106c52: 80 3f 64 cmpb $0x64,(%edi)
106c55: 75 18 jne 106c6f <devFS_mknod+0x2f>
106c57: 80 7f 01 65 cmpb $0x65,0x1(%edi)
106c5b: 75 12 jne 106c6f <devFS_mknod+0x2f> <== NEVER TAKEN
106c5d: 80 7f 02 76 cmpb $0x76,0x2(%edi)
106c61: 75 0c jne 106c6f <devFS_mknod+0x2f> <== NEVER TAKEN
(path[2] == 'v') && (path[3] == '\0'))
return 0;
106c63: 31 c0 xor %eax,%eax
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
(path[2] == 'v') && (path[3] == '\0'))
106c65: 80 7f 03 00 cmpb $0x0,0x3(%edi)
106c69: 0f 84 c9 00 00 00 je 106d38 <devFS_mknod+0xf8>
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
106c6f: 8b 45 0c mov 0xc(%ebp),%eax
106c72: 25 00 f0 00 00 and $0xf000,%eax
106c77: 3d 00 20 00 00 cmp $0x2000,%eax
106c7c: 74 14 je 106c92 <devFS_mknod+0x52>
106c7e: 3d 00 60 00 00 cmp $0x6000,%eax
106c83: 74 0d je 106c92 <devFS_mknod+0x52>
rtems_set_errno_and_return_minus_one( EINVAL );
106c85: e8 3a 8a 00 00 call 10f6c4 <__errno>
106c8a: c7 00 16 00 00 00 movl $0x16,(%eax)
106c90: eb 23 jmp 106cb5 <devFS_mknod+0x75>
)
{
union __rtems_dev_t temp;
temp.device = device;
return temp.__overlay.major;
106c92: 89 4d e4 mov %ecx,-0x1c(%ebp)
dev_t device
)
{
union __rtems_dev_t temp;
temp.device = device;
106c95: 89 55 e0 mov %edx,-0x20(%ebp)
else
rtems_filesystem_split_dev_t(dev, major, minor);
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
106c98: 8b 45 18 mov 0x18(%ebp),%eax
106c9b: 8b 08 mov (%eax),%ecx
if (!device_name_table)
106c9d: 85 c9 test %ecx,%ecx
106c9f: 74 09 je 106caa <devFS_mknod+0x6a>
106ca1: 89 ca mov %ecx,%edx
106ca3: 83 ce ff or $0xffffffff,%esi
106ca6: 31 db xor %ebx,%ebx
106ca8: eb 46 jmp 106cf0 <devFS_mknod+0xb0>
rtems_set_errno_and_return_minus_one( EFAULT );
106caa: e8 15 8a 00 00 call 10f6c4 <__errno>
106caf: c7 00 0e 00 00 00 movl $0xe,(%eax)
106cb5: 83 c8 ff or $0xffffffff,%eax
106cb8: eb 7e jmp 106d38 <devFS_mknod+0xf8>
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
106cba: 8b 02 mov (%edx),%eax
106cbc: 85 c0 test %eax,%eax
106cbe: 74 2a je 106cea <devFS_mknod+0xaa>
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
106cc0: 83 ec 08 sub $0x8,%esp
106cc3: 50 push %eax
106cc4: 57 push %edi
106cc5: 89 55 d8 mov %edx,-0x28(%ebp)
106cc8: 89 4d dc mov %ecx,-0x24(%ebp)
106ccb: e8 2c 96 00 00 call 1102fc <strcmp>
106cd0: 83 c4 10 add $0x10,%esp
106cd3: 85 c0 test %eax,%eax
106cd5: 8b 55 d8 mov -0x28(%ebp),%edx
106cd8: 8b 4d dc mov -0x24(%ebp),%ecx
106cdb: 75 0f jne 106cec <devFS_mknod+0xac>
rtems_set_errno_and_return_minus_one( EEXIST );
106cdd: e8 e2 89 00 00 call 10f6c4 <__errno>
106ce2: c7 00 11 00 00 00 movl $0x11,(%eax)
106ce8: eb cb jmp 106cb5 <devFS_mknod+0x75>
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
slot = i;
106cea: 89 de mov %ebx,%esi
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
106cec: 43 inc %ebx
106ced: 83 c2 14 add $0x14,%edx
106cf0: 3b 1d 48 f1 11 00 cmp 0x11f148,%ebx
106cf6: 72 c2 jb 106cba <devFS_mknod+0x7a>
else
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
}
if (slot == -1)
106cf8: 83 fe ff cmp $0xffffffff,%esi
106cfb: 75 0d jne 106d0a <devFS_mknod+0xca>
rtems_set_errno_and_return_minus_one( ENOMEM );
106cfd: e8 c2 89 00 00 call 10f6c4 <__errno>
106d02: c7 00 0c 00 00 00 movl $0xc,(%eax)
106d08: eb ab jmp 106cb5 <devFS_mknod+0x75>
_ISR_Disable(level);
106d0a: 9c pushf
106d0b: fa cli
106d0c: 5b pop %ebx
device_name_table[slot].device_name = (char *)path;
106d0d: 6b d6 14 imul $0x14,%esi,%edx
106d10: 8d 14 11 lea (%ecx,%edx,1),%edx
106d13: 89 3a mov %edi,(%edx)
device_name_table[slot].device_name_length = strlen(path);
106d15: 31 c0 xor %eax,%eax
106d17: 83 c9 ff or $0xffffffff,%ecx
106d1a: f2 ae repnz scas %es:(%edi),%al
106d1c: f7 d1 not %ecx
106d1e: 49 dec %ecx
106d1f: 89 4a 04 mov %ecx,0x4(%edx)
device_name_table[slot].major = major;
106d22: 8b 45 e4 mov -0x1c(%ebp),%eax
106d25: 89 42 08 mov %eax,0x8(%edx)
device_name_table[slot].minor = minor;
106d28: 8b 45 e0 mov -0x20(%ebp),%eax
106d2b: 89 42 0c mov %eax,0xc(%edx)
device_name_table[slot].mode = mode;
106d2e: 8b 45 0c mov 0xc(%ebp),%eax
106d31: 89 42 10 mov %eax,0x10(%edx)
_ISR_Enable(level);
106d34: 53 push %ebx
106d35: 9d popf
return 0;
106d36: 31 c0 xor %eax,%eax
}
106d38: 8d 65 f4 lea -0xc(%ebp),%esp
106d3b: 5b pop %ebx
106d3c: 5e pop %esi
106d3d: 5f pop %edi
106d3e: c9 leave
106d3f: c3 ret
00108084 <drainOutput>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
108084: 55 push %ebp
108085: 89 e5 mov %esp,%ebp
108087: 53 push %ebx
108088: 83 ec 04 sub $0x4,%esp
10808b: 89 c3 mov %eax,%ebx
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
10808d: 83 b8 b4 00 00 00 00 cmpl $0x0,0xb4(%eax)
108094: 74 46 je 1080dc <drainOutput+0x58>
rtems_interrupt_disable (level);
108096: 9c pushf
108097: fa cli
108098: 58 pop %eax
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
108099: eb 2f jmp 1080ca <drainOutput+0x46>
tty->rawOutBufState = rob_wait;
10809b: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx)
1080a2: 00 00 00
rtems_interrupt_enable (level);
1080a5: 50 push %eax
1080a6: 9d popf
sc = rtems_semaphore_obtain(
1080a7: 50 push %eax
1080a8: 6a 00 push $0x0
1080aa: 6a 00 push $0x0
1080ac: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
1080b2: e8 b1 20 00 00 call 10a168 <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
1080b7: 83 c4 10 add $0x10,%esp
1080ba: 85 c0 test %eax,%eax
1080bc: 74 09 je 1080c7 <drainOutput+0x43> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
1080be: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1080c1: 50 push %eax <== NOT EXECUTED
1080c2: e8 6d 26 00 00 call 10a734 <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_interrupt_disable (level);
1080c7: 9c pushf
1080c8: fa cli
1080c9: 58 pop %eax
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
1080ca: 8b 8b 84 00 00 00 mov 0x84(%ebx),%ecx
1080d0: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx
1080d6: 39 d1 cmp %edx,%ecx
1080d8: 75 c1 jne 10809b <drainOutput+0x17>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
rtems_interrupt_enable (level);
1080da: 50 push %eax
1080db: 9d popf
}
}
1080dc: 8b 5d fc mov -0x4(%ebp),%ebx
1080df: c9 leave
1080e0: c3 ret
00108c3b <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
108c3b: 55 push %ebp
108c3c: 89 e5 mov %esp,%ebp
108c3e: 53 push %ebx
108c3f: 83 ec 24 sub $0x24,%esp
if ((tty->termios.c_lflag & ECHOCTL) &&
108c42: f6 42 3d 02 testb $0x2,0x3d(%edx)
108c46: 74 3e je 108c86 <echo+0x4b> <== NEVER TAKEN
iscntrl(c) && (c != '\t') && (c != '\n')) {
108c48: 0f b6 c8 movzbl %al,%ecx
108c4b: 8b 1d 3c 31 12 00 mov 0x12313c,%ebx
108c51: f6 44 0b 01 20 testb $0x20,0x1(%ebx,%ecx,1)
108c56: 74 2e je 108c86 <echo+0x4b>
108c58: 3c 09 cmp $0x9,%al
108c5a: 74 2a je 108c86 <echo+0x4b>
108c5c: 3c 0a cmp $0xa,%al
108c5e: 74 26 je 108c86 <echo+0x4b>
char echobuf[2];
echobuf[0] = '^';
108c60: c6 45 f6 5e movb $0x5e,-0xa(%ebp)
echobuf[1] = c ^ 0x40;
108c64: 83 f0 40 xor $0x40,%eax
108c67: 88 45 f7 mov %al,-0x9(%ebp)
rtems_termios_puts (echobuf, 2, tty);
108c6a: 50 push %eax
108c6b: 52 push %edx
108c6c: 6a 02 push $0x2
108c6e: 8d 45 f6 lea -0xa(%ebp),%eax
108c71: 50 push %eax
108c72: 89 55 e4 mov %edx,-0x1c(%ebp)
108c75: e8 84 fd ff ff call 1089fe <rtems_termios_puts>
tty->column += 2;
108c7a: 8b 55 e4 mov -0x1c(%ebp),%edx
108c7d: 83 42 28 02 addl $0x2,0x28(%edx)
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
108c81: 83 c4 10 add $0x10,%esp
108c84: eb 08 jmp 108c8e <echo+0x53>
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
} else {
oproc (c, tty);
108c86: 0f b6 c0 movzbl %al,%eax
108c89: e8 90 fe ff ff call 108b1e <oproc>
}
}
108c8e: 8b 5d fc mov -0x4(%ebp),%ebx
108c91: c9 leave
108c92: c3 ret
0010811e <endgrent>:
void endgrent(void)
{
10811e: 55 push %ebp
10811f: 89 e5 mov %esp,%ebp
108121: 83 ec 08 sub $0x8,%esp
if (group_fp != NULL)
108124: a1 f8 6a 12 00 mov 0x126af8,%eax
108129: 85 c0 test %eax,%eax
10812b: 74 0c je 108139 <endgrent+0x1b> <== NEVER TAKEN
fclose(group_fp);
10812d: 83 ec 0c sub $0xc,%esp
108130: 50 push %eax
108131: e8 6e 9e 00 00 call 111fa4 <fclose>
108136: 83 c4 10 add $0x10,%esp
}
108139: c9 leave
10813a: c3 ret
00107fd1 <endpwent>:
void endpwent(void)
{
107fd1: 55 push %ebp
107fd2: 89 e5 mov %esp,%ebp
107fd4: 83 ec 08 sub $0x8,%esp
if (passwd_fp != NULL)
107fd7: a1 d4 6b 12 00 mov 0x126bd4,%eax
107fdc: 85 c0 test %eax,%eax
107fde: 74 0c je 107fec <endpwent+0x1b> <== NEVER TAKEN
fclose(passwd_fp);
107fe0: 83 ec 0c sub $0xc,%esp
107fe3: 50 push %eax
107fe4: e8 bb 9f 00 00 call 111fa4 <fclose>
107fe9: 83 c4 10 add $0x10,%esp
}
107fec: c9 leave
107fed: c3 ret
00108c93 <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)
{
108c93: 55 push %ebp
108c94: 89 e5 mov %esp,%ebp
108c96: 57 push %edi
108c97: 56 push %esi
108c98: 53 push %ebx
108c99: 83 ec 2c sub $0x2c,%esp
108c9c: 89 c3 mov %eax,%ebx
108c9e: 89 55 e4 mov %edx,-0x1c(%ebp)
if (tty->ccount == 0)
108ca1: 83 78 20 00 cmpl $0x0,0x20(%eax)
108ca5: 0f 84 59 01 00 00 je 108e04 <erase+0x171>
return;
if (lineFlag) {
108cab: 85 d2 test %edx,%edx
108cad: 0f 84 46 01 00 00 je 108df9 <erase+0x166>
if (!(tty->termios.c_lflag & ECHO)) {
108cb3: 8b 40 3c mov 0x3c(%eax),%eax
108cb6: a8 08 test $0x8,%al
108cb8: 75 0c jne 108cc6 <erase+0x33> <== ALWAYS TAKEN
tty->ccount = 0;
108cba: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED
return;
108cc1: e9 3e 01 00 00 jmp 108e04 <erase+0x171> <== NOT EXECUTED
}
if (!(tty->termios.c_lflag & ECHOE)) {
108cc6: a8 10 test $0x10,%al
108cc8: 0f 85 2b 01 00 00 jne 108df9 <erase+0x166> <== ALWAYS TAKEN
tty->ccount = 0;
108cce: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
108cd5: 0f b6 43 44 movzbl 0x44(%ebx),%eax <== NOT EXECUTED
108cd9: 89 da mov %ebx,%edx <== NOT EXECUTED
108cdb: e8 5b ff ff ff call 108c3b <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
108ce0: f6 43 3c 20 testb $0x20,0x3c(%ebx) <== NOT EXECUTED
108ce4: 0f 84 1a 01 00 00 je 108e04 <erase+0x171> <== NOT EXECUTED
echo ('\n', tty);
108cea: 89 da mov %ebx,%edx <== NOT EXECUTED
108cec: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
108cf1: eb 2a jmp 108d1d <erase+0x8a> <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
108cf3: 8b 7b 1c mov 0x1c(%ebx),%edi
108cf6: 8d 50 ff lea -0x1(%eax),%edx
108cf9: 89 53 20 mov %edx,0x20(%ebx)
108cfc: 8a 4c 07 ff mov -0x1(%edi,%eax,1),%cl
if (tty->termios.c_lflag & ECHO) {
108d00: 8b 53 3c mov 0x3c(%ebx),%edx
108d03: f6 c2 08 test $0x8,%dl
108d06: 0f 84 e7 00 00 00 je 108df3 <erase+0x160> <== NEVER TAKEN
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
108d0c: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
108d10: 75 17 jne 108d29 <erase+0x96>
108d12: f6 c2 10 test $0x10,%dl
108d15: 75 12 jne 108d29 <erase+0x96> <== ALWAYS TAKEN
echo (tty->termios.c_cc[VERASE], tty);
108d17: 0f b6 43 43 movzbl 0x43(%ebx),%eax <== NOT EXECUTED
108d1b: 89 da mov %ebx,%edx <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
108d1d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED
108d20: 5b pop %ebx <== NOT EXECUTED
108d21: 5e pop %esi <== NOT EXECUTED
108d22: 5f pop %edi <== NOT EXECUTED
108d23: 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);
108d24: e9 12 ff ff ff jmp 108c3b <echo> <== NOT EXECUTED
} else if (c == '\t') {
108d29: 80 f9 09 cmp $0x9,%cl
108d2c: 8b 35 3c 31 12 00 mov 0x12313c,%esi
108d32: 89 75 e0 mov %esi,-0x20(%ebp)
108d35: 75 60 jne 108d97 <erase+0x104>
int col = tty->read_start_column;
108d37: 8b 73 2c mov 0x2c(%ebx),%esi
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
108d3a: b9 01 00 00 00 mov $0x1,%ecx
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
108d3f: 81 e2 00 02 00 00 and $0x200,%edx
108d45: 89 55 dc mov %edx,-0x24(%ebp)
108d48: 89 45 d4 mov %eax,-0x2c(%ebp)
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
108d4b: eb 28 jmp 108d75 <erase+0xe2>
c = tty->cbuf[i++];
108d4d: 8a 54 0f ff mov -0x1(%edi,%ecx,1),%dl
if (c == '\t') {
108d51: 80 fa 09 cmp $0x9,%dl
108d54: 75 05 jne 108d5b <erase+0xc8>
col = (col | 7) + 1;
108d56: 83 ce 07 or $0x7,%esi
108d59: eb 18 jmp 108d73 <erase+0xe0>
} else if (iscntrl (c)) {
108d5b: 0f b6 d2 movzbl %dl,%edx
108d5e: 8b 45 e0 mov -0x20(%ebp),%eax
108d61: f6 44 10 01 20 testb $0x20,0x1(%eax,%edx,1)
108d66: 74 0b je 108d73 <erase+0xe0> <== ALWAYS TAKEN
if (tty->termios.c_lflag & ECHOCTL)
108d68: 83 7d dc 00 cmpl $0x0,-0x24(%ebp) <== NOT EXECUTED
108d6c: 74 06 je 108d74 <erase+0xe1> <== NOT EXECUTED
col += 2;
108d6e: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
108d71: eb 01 jmp 108d74 <erase+0xe1> <== NOT EXECUTED
} else {
col++;
108d73: 46 inc %esi
108d74: 41 inc %ecx
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
108d75: 3b 4d d4 cmp -0x2c(%ebp),%ecx
108d78: 75 d3 jne 108d4d <erase+0xba>
108d7a: eb 14 jmp 108d90 <erase+0xfd>
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
108d7c: 57 push %edi
108d7d: 53 push %ebx
108d7e: 6a 01 push $0x1
108d80: 68 bc ef 11 00 push $0x11efbc
108d85: e8 74 fc ff ff call 1089fe <rtems_termios_puts>
tty->column--;
108d8a: ff 4b 28 decl 0x28(%ebx)
108d8d: 83 c4 10 add $0x10,%esp
}
/*
* Back up over the tab
*/
while (tty->column > col) {
108d90: 39 73 28 cmp %esi,0x28(%ebx)
108d93: 7f e7 jg 108d7c <erase+0xe9>
108d95: eb 5c jmp 108df3 <erase+0x160>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
108d97: 0f b6 f1 movzbl %cl,%esi
108d9a: 8b 45 e0 mov -0x20(%ebp),%eax
108d9d: f6 44 30 01 20 testb $0x20,0x1(%eax,%esi,1)
108da2: 74 21 je 108dc5 <erase+0x132> <== ALWAYS TAKEN
108da4: 80 e6 02 and $0x2,%dh <== NOT EXECUTED
108da7: 74 1c je 108dc5 <erase+0x132> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
108da9: 51 push %ecx <== NOT EXECUTED
108daa: 53 push %ebx <== NOT EXECUTED
108dab: 6a 03 push $0x3 <== NOT EXECUTED
108dad: 68 ba ef 11 00 push $0x11efba <== NOT EXECUTED
108db2: e8 47 fc ff ff call 1089fe <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
108db7: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
108dba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
108dbd: 85 c0 test %eax,%eax <== NOT EXECUTED
108dbf: 74 04 je 108dc5 <erase+0x132> <== NOT EXECUTED
tty->column--;
108dc1: 48 dec %eax <== NOT EXECUTED
108dc2: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
108dc5: a1 3c 31 12 00 mov 0x12313c,%eax
108dca: f6 44 30 01 20 testb $0x20,0x1(%eax,%esi,1)
108dcf: 74 06 je 108dd7 <erase+0x144> <== ALWAYS TAKEN
108dd1: f6 43 3d 02 testb $0x2,0x3d(%ebx) <== NOT EXECUTED
108dd5: 74 1c je 108df3 <erase+0x160> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
108dd7: 52 push %edx
108dd8: 53 push %ebx
108dd9: 6a 03 push $0x3
108ddb: 68 ba ef 11 00 push $0x11efba
108de0: e8 19 fc ff ff call 1089fe <rtems_termios_puts>
if (tty->column)
108de5: 8b 43 28 mov 0x28(%ebx),%eax
108de8: 83 c4 10 add $0x10,%esp
108deb: 85 c0 test %eax,%eax
108ded: 74 04 je 108df3 <erase+0x160> <== NEVER TAKEN
tty->column--;
108def: 48 dec %eax
108df0: 89 43 28 mov %eax,0x28(%ebx)
}
}
}
if (!lineFlag)
108df3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
108df7: 74 0b je 108e04 <erase+0x171>
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
108df9: 8b 43 20 mov 0x20(%ebx),%eax
108dfc: 85 c0 test %eax,%eax
108dfe: 0f 85 ef fe ff ff jne 108cf3 <erase+0x60>
}
}
if (!lineFlag)
break;
}
}
108e04: 8d 65 f4 lea -0xc(%ebp),%esp
108e07: 5b pop %ebx
108e08: 5e pop %esi
108e09: 5f pop %edi
108e0a: c9 leave
108e0b: c3 ret
00107bd8 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
107bd8: 55 push %ebp
107bd9: 89 e5 mov %esp,%ebp
107bdb: 57 push %edi
107bdc: 56 push %esi
107bdd: 53 push %ebx
107bde: 83 ec 0c sub $0xc,%esp
107be1: 8b 5d 08 mov 0x8(%ebp),%ebx
int ret;
va_list ap;
va_start( ap, cmd );
107be4: 8d 75 10 lea 0x10(%ebp),%esi
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
107be7: 8b 0d 44 21 12 00 mov 0x122144,%ecx
107bed: 39 cb cmp %ecx,%ebx
107bef: 73 14 jae 107c05 <fcntl+0x2d>
iop = rtems_libio_iop( fd );
107bf1: 8b 15 f8 61 12 00 mov 0x1261f8,%edx
107bf7: 6b db 38 imul $0x38,%ebx,%ebx
107bfa: 8d 1c 1a lea (%edx,%ebx,1),%ebx
rtems_libio_check_is_open(iop);
107bfd: 8b 43 14 mov 0x14(%ebx),%eax
107c00: f6 c4 01 test $0x1,%ah
107c03: 75 10 jne 107c15 <fcntl+0x3d>
107c05: e8 1a a3 00 00 call 111f24 <__errno>
107c0a: c7 00 09 00 00 00 movl $0x9,(%eax)
107c10: e9 e6 00 00 00 jmp 107cfb <fcntl+0x123>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
107c15: 83 7d 0c 09 cmpl $0x9,0xc(%ebp)
107c19: 0f 87 af 00 00 00 ja 107cce <fcntl+0xf6>
107c1f: 8b 7d 0c mov 0xc(%ebp),%edi
107c22: ff 24 bd e8 07 12 00 jmp *0x1207e8(,%edi,4)
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
107c29: 8b 36 mov (%esi),%esi
if ( fd2 )
107c2b: 85 f6 test %esi,%esi
107c2d: 74 0e je 107c3d <fcntl+0x65>
diop = rtems_libio_iop( fd2 );
107c2f: 31 c0 xor %eax,%eax
107c31: 39 ce cmp %ecx,%esi
107c33: 73 15 jae 107c4a <fcntl+0x72> <== NEVER TAKEN
107c35: 6b c6 38 imul $0x38,%esi,%eax
107c38: 8d 04 02 lea (%edx,%eax,1),%eax
107c3b: eb 0d jmp 107c4a <fcntl+0x72>
else {
/* allocate a file control block */
diop = rtems_libio_allocate();
107c3d: e8 d1 04 00 00 call 108113 <rtems_libio_allocate>
if ( diop == 0 ) {
107c42: 85 c0 test %eax,%eax
107c44: 0f 84 b1 00 00 00 je 107cfb <fcntl+0x123> <== NEVER TAKEN
ret = -1;
break;
}
}
diop->flags = iop->flags;
107c4a: 8b 53 14 mov 0x14(%ebx),%edx
107c4d: 89 50 14 mov %edx,0x14(%eax)
diop->pathinfo = iop->pathinfo;
107c50: 8d 78 18 lea 0x18(%eax),%edi
107c53: 8d 73 18 lea 0x18(%ebx),%esi
107c56: b9 05 00 00 00 mov $0x5,%ecx
107c5b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
ret = (int) (diop - rtems_libio_iops);
107c5d: 2b 05 f8 61 12 00 sub 0x1261f8,%eax
107c63: c1 f8 03 sar $0x3,%eax
107c66: 69 f0 b7 6d db b6 imul $0xb6db6db7,%eax,%esi
107c6c: eb 6d jmp 107cdb <fcntl+0x103>
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
107c6e: f6 c4 08 test $0x8,%ah
107c71: 0f 95 c0 setne %al
107c74: 0f b6 c0 movzbl %al,%eax
107c77: 89 c6 mov %eax,%esi
107c79: eb 64 jmp 107cdf <fcntl+0x107>
* if a new process is exec()'ed. Since RTEMS does not support
* processes, then we can ignore this one except to make
* F_GETFD work.
*/
if ( va_arg( ap, int ) )
107c7b: 83 3e 00 cmpl $0x0,(%esi)
107c7e: 74 05 je 107c85 <fcntl+0xad>
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
107c80: 80 cc 08 or $0x8,%ah
107c83: eb 03 jmp 107c88 <fcntl+0xb0>
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
107c85: 80 e4 f7 and $0xf7,%ah
107c88: 89 43 14 mov %eax,0x14(%ebx)
107c8b: eb 30 jmp 107cbd <fcntl+0xe5>
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
107c8d: 83 ec 0c sub $0xc,%esp
107c90: 50 push %eax
107c91: e8 3f 04 00 00 call 1080d5 <rtems_libio_to_fcntl_flags>
107c96: 89 c6 mov %eax,%esi
107c98: 83 c4 10 add $0x10,%esp
107c9b: eb 3e jmp 107cdb <fcntl+0x103>
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
107c9d: 83 ec 0c sub $0xc,%esp
107ca0: ff 36 pushl (%esi)
107ca2: e8 f9 03 00 00 call 1080a0 <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
107ca7: 25 01 02 00 00 and $0x201,%eax
107cac: 8b 53 14 mov 0x14(%ebx),%edx
107caf: 81 e2 fe fd ff ff and $0xfffffdfe,%edx
107cb5: 09 d0 or %edx,%eax
107cb7: 89 43 14 mov %eax,0x14(%ebx)
107cba: 83 c4 10 add $0x10,%esp
rtems_libio_t *iop;
rtems_libio_t *diop;
int fd2;
int flags;
int mask;
int ret = 0;
107cbd: 31 f6 xor %esi,%esi
107cbf: eb 1e jmp 107cdf <fcntl+0x107>
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
107cc1: e8 5e a2 00 00 call 111f24 <__errno>
107cc6: c7 00 86 00 00 00 movl $0x86,(%eax)
107ccc: eb 2d jmp 107cfb <fcntl+0x123>
ret = -1;
break;
default:
errno = EINVAL;
107cce: e8 51 a2 00 00 call 111f24 <__errno>
107cd3: c7 00 16 00 00 00 movl $0x16,(%eax)
107cd9: eb 20 jmp 107cfb <fcntl+0x123>
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
107cdb: 85 f6 test %esi,%esi
107cdd: 78 1f js 107cfe <fcntl+0x126> <== NEVER TAKEN
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
107cdf: 50 push %eax
107ce0: 50 push %eax
107ce1: 8b 43 20 mov 0x20(%ebx),%eax
107ce4: 53 push %ebx
107ce5: ff 75 0c pushl 0xc(%ebp)
107ce8: ff 50 30 call *0x30(%eax)
107ceb: 89 c3 mov %eax,%ebx
if (err) {
107ced: 83 c4 10 add $0x10,%esp
107cf0: 85 c0 test %eax,%eax
107cf2: 74 0a je 107cfe <fcntl+0x126> <== ALWAYS TAKEN
errno = err;
107cf4: e8 2b a2 00 00 call 111f24 <__errno> <== NOT EXECUTED
107cf9: 89 18 mov %ebx,(%eax) <== NOT EXECUTED
ret = -1;
107cfb: 83 ce ff or $0xffffffff,%esi
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
107cfe: 89 f0 mov %esi,%eax
107d00: 8d 65 f4 lea -0xc(%ebp),%esp
107d03: 5b pop %ebx
107d04: 5e pop %esi
107d05: 5f pop %edi
107d06: c9 leave
107d07: c3 ret
0010fb23 <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
10fb23: 55 push %ebp
10fb24: 89 e5 mov %esp,%ebp
10fb26: 57 push %edi
10fb27: 56 push %esi
10fb28: 53 push %ebx
10fb29: 83 ec 2c sub $0x2c,%esp
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
10fb2c: 83 3d 20 70 12 00 00 cmpl $0x0,0x127020
10fb33: 75 50 jne 10fb85 <fifo_open+0x62>
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
10fb35: 53 push %ebx
10fb36: 6a 00 push $0x0
10fb38: 6a 00 push $0x0
10fb3a: ff 35 20 72 12 00 pushl 0x127220
10fb40: e8 c7 c0 ff ff call 10bc0c <rtems_semaphore_obtain>
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
10fb45: 83 c4 10 add $0x10,%esp
free(pipe);
}
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
10fb48: 31 db xor %ebx,%ebx
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
10fb4a: 83 3d 20 70 12 00 00 cmpl $0x0,0x127020
10fb51: 75 1d jne 10fb70 <fifo_open+0x4d> <== NEVER TAKEN
sc = rtems_semaphore_create(
10fb53: 83 ec 0c sub $0xc,%esp
10fb56: 68 20 70 12 00 push $0x127020
10fb5b: 6a 00 push $0x0
10fb5d: 6a 54 push $0x54
10fb5f: 6a 01 push $0x1
10fb61: 68 45 50 49 50 push $0x50495045
10fb66: e8 79 be ff ff call 10b9e4 <rtems_semaphore_create>
10fb6b: 89 c3 mov %eax,%ebx
10fb6d: 83 c4 20 add $0x20,%esp
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10fb70: 83 ec 0c sub $0xc,%esp
10fb73: ff 35 20 72 12 00 pushl 0x127220
10fb79: e8 7a c1 ff ff call 10bcf8 <rtems_semaphore_release>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
10fb7e: 83 c4 10 add $0x10,%esp
10fb81: 85 db test %ebx,%ebx
10fb83: 75 19 jne 10fb9e <fifo_open+0x7b>
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
10fb85: 51 push %ecx
10fb86: 6a 00 push $0x0
10fb88: 6a 00 push $0x0
10fb8a: ff 35 20 70 12 00 pushl 0x127020
10fb90: e8 77 c0 ff ff call 10bc0c <rtems_semaphore_obtain>
}
if (sc == RTEMS_SUCCESSFUL) {
10fb95: 83 c4 10 add $0x10,%esp
return 0;
10fb98: 31 f6 xor %esi,%esi
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
}
if (sc == RTEMS_SUCCESSFUL) {
10fb9a: 85 c0 test %eax,%eax
10fb9c: 74 05 je 10fba3 <fifo_open+0x80> <== ALWAYS TAKEN
return 0;
} else {
return -ENOMEM;
10fb9e: be f4 ff ff ff mov $0xfffffff4,%esi
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
if (err)
10fba3: 85 f6 test %esi,%esi
10fba5: 0f 85 37 03 00 00 jne 10fee2 <fifo_open+0x3bf>
return err;
pipe = *pipep;
10fbab: 8b 45 08 mov 0x8(%ebp),%eax
10fbae: 8b 18 mov (%eax),%ebx
if (pipe == NULL) {
10fbb0: 85 db test %ebx,%ebx
10fbb2: 0f 85 56 01 00 00 jne 10fd0e <fifo_open+0x1eb>
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
10fbb8: 83 ec 0c sub $0xc,%esp
10fbbb: 6a 34 push $0x34
10fbbd: e8 ee 93 ff ff call 108fb0 <malloc>
10fbc2: 89 c3 mov %eax,%ebx
10fbc4: 89 45 d4 mov %eax,-0x2c(%ebp)
if (pipe == NULL)
10fbc7: 83 c4 10 add $0x10,%esp
10fbca: 85 c0 test %eax,%eax
10fbcc: 0f 84 35 01 00 00 je 10fd07 <fifo_open+0x1e4>
return err;
memset(pipe, 0, sizeof(pipe_control_t));
10fbd2: b9 0d 00 00 00 mov $0xd,%ecx
10fbd7: 89 c7 mov %eax,%edi
10fbd9: 89 f0 mov %esi,%eax
10fbdb: f3 ab rep stos %eax,%es:(%edi)
pipe->Size = PIPE_BUF;
10fbdd: c7 43 04 00 02 00 00 movl $0x200,0x4(%ebx)
pipe->Buffer = malloc(pipe->Size);
10fbe4: 83 ec 0c sub $0xc,%esp
10fbe7: 68 00 02 00 00 push $0x200
10fbec: e8 bf 93 ff ff call 108fb0 <malloc>
10fbf1: 89 03 mov %eax,(%ebx)
if (! pipe->Buffer)
10fbf3: 83 c4 10 add $0x10,%esp
10fbf6: 85 c0 test %eax,%eax
10fbf8: 0f 84 fb 00 00 00 je 10fcf9 <fifo_open+0x1d6> <== NEVER TAKEN
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
10fbfe: 8d 43 2c lea 0x2c(%ebx),%eax
10fc01: 50 push %eax
10fc02: 6a 00 push $0x0
10fc04: 6a 00 push $0x0
rtems_build_name ('P', 'I', 'r', c),
10fc06: 0f be 05 a8 50 12 00 movsbl 0x1250a8,%eax
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
10fc0d: 0d 00 72 49 50 or $0x50497200,%eax
10fc12: 50 push %eax
10fc13: e8 40 18 00 00 call 111458 <rtems_barrier_create>
10fc18: 83 c4 10 add $0x10,%esp
10fc1b: 85 c0 test %eax,%eax
10fc1d: 0f 85 c6 00 00 00 jne 10fce9 <fifo_open+0x1c6>
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
10fc23: 8d 43 30 lea 0x30(%ebx),%eax
10fc26: 50 push %eax
10fc27: 6a 00 push $0x0
10fc29: 6a 00 push $0x0
rtems_build_name ('P', 'I', 'w', c),
10fc2b: 0f be 05 a8 50 12 00 movsbl 0x1250a8,%eax
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
10fc32: 0d 00 77 49 50 or $0x50497700,%eax
10fc37: 50 push %eax
10fc38: e8 1b 18 00 00 call 111458 <rtems_barrier_create>
10fc3d: 83 c4 10 add $0x10,%esp
10fc40: 85 c0 test %eax,%eax
10fc42: 0f 85 90 00 00 00 jne 10fcd8 <fifo_open+0x1b5>
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
10fc48: 83 ec 0c sub $0xc,%esp
10fc4b: 8d 43 28 lea 0x28(%ebx),%eax
10fc4e: 50 push %eax
10fc4f: 6a 00 push $0x0
10fc51: 6a 10 push $0x10
10fc53: 6a 01 push $0x1
rtems_build_name ('P', 'I', 's', c), 1,
10fc55: 0f be 05 a8 50 12 00 movsbl 0x1250a8,%eax
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
10fc5c: 0d 00 73 49 50 or $0x50497300,%eax
10fc61: 50 push %eax
10fc62: e8 7d bd ff ff call 10b9e4 <rtems_semaphore_create>
10fc67: 83 c4 20 add $0x20,%esp
10fc6a: 85 c0 test %eax,%eax
10fc6c: 75 59 jne 10fcc7 <fifo_open+0x1a4>
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
_Objects_Get( &_Barrier_Information, id, location );
10fc6e: 52 push %edx
/* Set barriers to be interruptible by signals. */
static void pipe_interruptible(pipe_control_t *pipe)
{
Objects_Locations location;
_Barrier_Get(pipe->readBarrier, &location)->Barrier.Wait_queue.state
10fc6f: 8d 7d e0 lea -0x20(%ebp),%edi
10fc72: 57 push %edi
10fc73: ff 73 2c pushl 0x2c(%ebx)
10fc76: 68 5c 7c 12 00 push $0x127c5c
10fc7b: e8 d4 d4 ff ff call 10d154 <_Objects_Get>
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
10fc80: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax)
_Thread_Enable_dispatch();
10fc87: e8 9e df ff ff call 10dc2a <_Thread_Enable_dispatch>
10fc8c: 83 c4 0c add $0xc,%esp
10fc8f: 57 push %edi
10fc90: ff 73 30 pushl 0x30(%ebx)
10fc93: 68 5c 7c 12 00 push $0x127c5c
10fc98: e8 b7 d4 ff ff call 10d154 <_Objects_Get>
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
10fc9d: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax)
_Thread_Enable_dispatch();
10fca4: e8 81 df ff ff call 10dc2a <_Thread_Enable_dispatch>
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
10fca9: a0 a8 50 12 00 mov 0x1250a8,%al
10fcae: 8d 50 01 lea 0x1(%eax),%edx
10fcb1: 88 15 a8 50 12 00 mov %dl,0x1250a8
10fcb7: 83 c4 10 add $0x10,%esp
10fcba: 3c 7a cmp $0x7a,%al
10fcbc: 75 50 jne 10fd0e <fifo_open+0x1eb>
c = 'a';
10fcbe: c6 05 a8 50 12 00 61 movb $0x61,0x1250a8
10fcc5: eb 47 jmp 10fd0e <fifo_open+0x1eb>
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
10fcc7: 83 ec 0c sub $0xc,%esp
10fcca: 8b 55 d4 mov -0x2c(%ebp),%edx
10fccd: ff 72 30 pushl 0x30(%edx)
10fcd0: e8 3b 18 00 00 call 111510 <rtems_barrier_delete>
10fcd5: 83 c4 10 add $0x10,%esp
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
10fcd8: 83 ec 0c sub $0xc,%esp
10fcdb: 8b 45 d4 mov -0x2c(%ebp),%eax
10fcde: ff 70 2c pushl 0x2c(%eax)
10fce1: e8 2a 18 00 00 call 111510 <rtems_barrier_delete>
10fce6: 83 c4 10 add $0x10,%esp
err_rbar:
free(pipe->Buffer);
10fce9: 83 ec 0c sub $0xc,%esp
10fcec: 8b 55 d4 mov -0x2c(%ebp),%edx
10fcef: ff 32 pushl (%edx)
10fcf1: e8 96 8c ff ff call 10898c <free>
10fcf6: 83 c4 10 add $0x10,%esp
err_buf:
free(pipe);
10fcf9: 83 ec 0c sub $0xc,%esp
10fcfc: ff 75 d4 pushl -0x2c(%ebp)
10fcff: e8 88 8c ff ff call 10898c <free>
10fd04: 83 c4 10 add $0x10,%esp
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
10fd07: be f4 ff ff ff mov $0xfffffff4,%esi
10fd0c: eb 33 jmp 10fd41 <fifo_open+0x21e>
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
10fd0e: 50 push %eax
10fd0f: 6a 00 push $0x0
10fd11: 6a 00 push $0x0
10fd13: ff 73 28 pushl 0x28(%ebx)
10fd16: e8 f1 be ff ff call 10bc0c <rtems_semaphore_obtain>
10fd1b: 83 c4 10 add $0x10,%esp
10fd1e: 85 c0 test %eax,%eax
10fd20: 74 05 je 10fd27 <fifo_open+0x204> <== ALWAYS TAKEN
err = -EINTR;
10fd22: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED
if (*pipep == NULL) {
10fd27: 8b 45 08 mov 0x8(%ebp),%eax
10fd2a: 83 38 00 cmpl $0x0,(%eax)
10fd2d: 75 12 jne 10fd41 <fifo_open+0x21e>
if (err)
10fd2f: 85 f6 test %esi,%esi
10fd31: 74 09 je 10fd3c <fifo_open+0x219> <== ALWAYS TAKEN
pipe_free(pipe);
10fd33: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10fd35: e8 1c fd ff ff call 10fa56 <pipe_free> <== NOT EXECUTED
10fd3a: eb 05 jmp 10fd41 <fifo_open+0x21e> <== NOT EXECUTED
else
*pipep = pipe;
10fd3c: 8b 55 08 mov 0x8(%ebp),%edx
10fd3f: 89 1a mov %ebx,(%edx)
}
out:
pipe_unlock();
10fd41: e8 fa fc ff ff call 10fa40 <pipe_unlock>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
10fd46: 85 f6 test %esi,%esi
10fd48: 0f 85 94 01 00 00 jne 10fee2 <fifo_open+0x3bf>
return err;
pipe = *pipep;
10fd4e: 8b 45 08 mov 0x8(%ebp),%eax
10fd51: 8b 18 mov (%eax),%ebx
switch (LIBIO_ACCMODE(iop)) {
10fd53: 8b 55 0c mov 0xc(%ebp),%edx
10fd56: 8b 42 14 mov 0x14(%edx),%eax
10fd59: 83 e0 06 and $0x6,%eax
10fd5c: 83 f8 04 cmp $0x4,%eax
10fd5f: 0f 84 91 00 00 00 je 10fdf6 <fifo_open+0x2d3>
10fd65: 83 f8 06 cmp $0x6,%eax
10fd68: 0f 84 10 01 00 00 je 10fe7e <fifo_open+0x35b>
10fd6e: 83 f8 02 cmp $0x2,%eax
10fd71: 0f 85 49 01 00 00 jne 10fec0 <fifo_open+0x39d> <== NEVER TAKEN
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
10fd77: ff 43 20 incl 0x20(%ebx)
if (pipe->Readers ++ == 0)
10fd7a: 8b 43 10 mov 0x10(%ebx),%eax
10fd7d: 8d 50 01 lea 0x1(%eax),%edx
10fd80: 89 53 10 mov %edx,0x10(%ebx)
10fd83: 85 c0 test %eax,%eax
10fd85: 75 11 jne 10fd98 <fifo_open+0x275> <== NEVER TAKEN
PIPE_WAKEUPWRITERS(pipe);
10fd87: 57 push %edi
10fd88: 57 push %edi
10fd89: 8d 45 e4 lea -0x1c(%ebp),%eax
10fd8c: 50 push %eax
10fd8d: ff 73 30 pushl 0x30(%ebx)
10fd90: e8 03 18 00 00 call 111598 <rtems_barrier_release>
10fd95: 83 c4 10 add $0x10,%esp
if (pipe->Writers == 0) {
10fd98: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10fd9c: 0f 85 1e 01 00 00 jne 10fec0 <fifo_open+0x39d>
/* Not an error */
if (LIBIO_NODELAY(iop))
10fda2: 8b 45 0c mov 0xc(%ebp),%eax
10fda5: f6 40 14 01 testb $0x1,0x14(%eax)
10fda9: 0f 85 11 01 00 00 jne 10fec0 <fifo_open+0x39d>
break;
prevCounter = pipe->writerCounter;
10fdaf: 8b 7b 24 mov 0x24(%ebx),%edi
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
10fdb2: 83 ec 0c sub $0xc,%esp
10fdb5: ff 73 28 pushl 0x28(%ebx)
10fdb8: e8 3b bf ff ff call 10bcf8 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
10fdbd: 5a pop %edx
10fdbe: 59 pop %ecx
10fdbf: 6a 00 push $0x0
10fdc1: ff 73 2c pushl 0x2c(%ebx)
10fdc4: e8 27 18 00 00 call 1115f0 <rtems_barrier_wait>
10fdc9: 83 c4 10 add $0x10,%esp
10fdcc: 85 c0 test %eax,%eax
10fdce: 0f 85 f9 00 00 00 jne 10fecd <fifo_open+0x3aa> <== NEVER TAKEN
goto out_error;
if (! PIPE_LOCK(pipe))
10fdd4: 50 push %eax
10fdd5: 6a 00 push $0x0
10fdd7: 6a 00 push $0x0
10fdd9: ff 73 28 pushl 0x28(%ebx)
10fddc: e8 2b be ff ff call 10bc0c <rtems_semaphore_obtain>
10fde1: 83 c4 10 add $0x10,%esp
10fde4: 85 c0 test %eax,%eax
10fde6: 0f 85 e1 00 00 00 jne 10fecd <fifo_open+0x3aa> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->writerCounter);
10fdec: 3b 7b 24 cmp 0x24(%ebx),%edi
10fdef: 74 c1 je 10fdb2 <fifo_open+0x28f> <== NEVER TAKEN
10fdf1: e9 ca 00 00 00 jmp 10fec0 <fifo_open+0x39d>
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
10fdf6: ff 43 24 incl 0x24(%ebx)
if (pipe->Writers ++ == 0)
10fdf9: 8b 43 14 mov 0x14(%ebx),%eax
10fdfc: 8d 50 01 lea 0x1(%eax),%edx
10fdff: 89 53 14 mov %edx,0x14(%ebx)
10fe02: 85 c0 test %eax,%eax
10fe04: 75 11 jne 10fe17 <fifo_open+0x2f4> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
10fe06: 57 push %edi
10fe07: 57 push %edi
10fe08: 8d 45 e4 lea -0x1c(%ebp),%eax
10fe0b: 50 push %eax
10fe0c: ff 73 2c pushl 0x2c(%ebx)
10fe0f: e8 84 17 00 00 call 111598 <rtems_barrier_release>
10fe14: 83 c4 10 add $0x10,%esp
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
10fe17: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
10fe1b: 0f 85 9f 00 00 00 jne 10fec0 <fifo_open+0x39d>
10fe21: 8b 55 0c mov 0xc(%ebp),%edx
10fe24: f6 42 14 01 testb $0x1,0x14(%edx)
10fe28: 74 18 je 10fe42 <fifo_open+0x31f>
PIPE_UNLOCK(pipe);
10fe2a: 83 ec 0c sub $0xc,%esp
10fe2d: ff 73 28 pushl 0x28(%ebx)
10fe30: e8 c3 be ff ff call 10bcf8 <rtems_semaphore_release>
err = -ENXIO;
goto out_error;
10fe35: 83 c4 10 add $0x10,%esp
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
err = -ENXIO;
10fe38: be fa ff ff ff mov $0xfffffffa,%esi
goto out_error;
10fe3d: e9 90 00 00 00 jmp 10fed2 <fifo_open+0x3af>
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
10fe42: 8b 7b 20 mov 0x20(%ebx),%edi
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
10fe45: 83 ec 0c sub $0xc,%esp
10fe48: ff 73 28 pushl 0x28(%ebx)
10fe4b: e8 a8 be ff ff call 10bcf8 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
10fe50: 5a pop %edx
10fe51: 59 pop %ecx
10fe52: 6a 00 push $0x0
10fe54: ff 73 30 pushl 0x30(%ebx)
10fe57: e8 94 17 00 00 call 1115f0 <rtems_barrier_wait>
10fe5c: 83 c4 10 add $0x10,%esp
10fe5f: 85 c0 test %eax,%eax
10fe61: 75 6a jne 10fecd <fifo_open+0x3aa> <== NEVER TAKEN
goto out_error;
if (! PIPE_LOCK(pipe))
10fe63: 50 push %eax
10fe64: 6a 00 push $0x0
10fe66: 6a 00 push $0x0
10fe68: ff 73 28 pushl 0x28(%ebx)
10fe6b: e8 9c bd ff ff call 10bc0c <rtems_semaphore_obtain>
10fe70: 83 c4 10 add $0x10,%esp
10fe73: 85 c0 test %eax,%eax
10fe75: 75 56 jne 10fecd <fifo_open+0x3aa> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->readerCounter);
10fe77: 3b 7b 20 cmp 0x20(%ebx),%edi
10fe7a: 74 c9 je 10fe45 <fifo_open+0x322> <== NEVER TAKEN
10fe7c: eb 42 jmp 10fec0 <fifo_open+0x39d>
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
10fe7e: ff 43 20 incl 0x20(%ebx)
if (pipe->Readers ++ == 0)
10fe81: 8b 43 10 mov 0x10(%ebx),%eax
10fe84: 8d 50 01 lea 0x1(%eax),%edx
10fe87: 89 53 10 mov %edx,0x10(%ebx)
10fe8a: 85 c0 test %eax,%eax
10fe8c: 75 11 jne 10fe9f <fifo_open+0x37c> <== NEVER TAKEN
PIPE_WAKEUPWRITERS(pipe);
10fe8e: 51 push %ecx
10fe8f: 51 push %ecx
10fe90: 8d 45 e4 lea -0x1c(%ebp),%eax
10fe93: 50 push %eax
10fe94: ff 73 30 pushl 0x30(%ebx)
10fe97: e8 fc 16 00 00 call 111598 <rtems_barrier_release>
10fe9c: 83 c4 10 add $0x10,%esp
pipe->writerCounter ++;
10fe9f: ff 43 24 incl 0x24(%ebx)
if (pipe->Writers ++ == 0)
10fea2: 8b 43 14 mov 0x14(%ebx),%eax
10fea5: 8d 50 01 lea 0x1(%eax),%edx
10fea8: 89 53 14 mov %edx,0x14(%ebx)
10feab: 85 c0 test %eax,%eax
10fead: 75 11 jne 10fec0 <fifo_open+0x39d> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
10feaf: 52 push %edx
10feb0: 52 push %edx
10feb1: 8d 45 e4 lea -0x1c(%ebp),%eax
10feb4: 50 push %eax
10feb5: ff 73 2c pushl 0x2c(%ebx)
10feb8: e8 db 16 00 00 call 111598 <rtems_barrier_release>
10febd: 83 c4 10 add $0x10,%esp
break;
}
PIPE_UNLOCK(pipe);
10fec0: 83 ec 0c sub $0xc,%esp
10fec3: ff 73 28 pushl 0x28(%ebx)
10fec6: e8 2d be ff ff call 10bcf8 <rtems_semaphore_release>
10fecb: eb 12 jmp 10fedf <fifo_open+0x3bc>
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
10fecd: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
10fed2: 50 push %eax
10fed3: 50 push %eax
10fed4: ff 75 0c pushl 0xc(%ebp)
10fed7: ff 75 08 pushl 0x8(%ebp)
10feda: e8 b2 fb ff ff call 10fa91 <pipe_release>
return err;
10fedf: 83 c4 10 add $0x10,%esp
}
10fee2: 89 f0 mov %esi,%eax
10fee4: 8d 65 f4 lea -0xc(%ebp),%esp
10fee7: 5b pop %ebx
10fee8: 5e pop %esi
10fee9: 5f pop %edi
10feea: c9 leave
10feeb: c3 ret
00107d7c <fpathconf>:
long fpathconf(
int fd,
int name
)
{
107d7c: 55 push %ebp
107d7d: 89 e5 mov %esp,%ebp
107d7f: 83 ec 08 sub $0x8,%esp
107d82: 8b 45 08 mov 0x8(%ebp),%eax
107d85: 8b 55 0c mov 0xc(%ebp),%edx
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
107d88: 3b 05 44 21 12 00 cmp 0x122144,%eax
107d8e: 73 11 jae 107da1 <fpathconf+0x25>
iop = rtems_libio_iop(fd);
107d90: 6b c0 38 imul $0x38,%eax,%eax
107d93: 03 05 f8 61 12 00 add 0x1261f8,%eax
rtems_libio_check_is_open(iop);
107d99: 8b 48 14 mov 0x14(%eax),%ecx
107d9c: f6 c5 01 test $0x1,%ch
107d9f: 75 0d jne 107dae <fpathconf+0x32> <== ALWAYS TAKEN
107da1: e8 7e a1 00 00 call 111f24 <__errno>
107da6: c7 00 09 00 00 00 movl $0x9,(%eax)
107dac: eb 5b jmp 107e09 <fpathconf+0x8d>
rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ);
107dae: 80 e1 02 and $0x2,%cl
107db1: 74 4b je 107dfe <fpathconf+0x82>
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
107db3: 8b 40 28 mov 0x28(%eax),%eax
switch ( name ) {
107db6: 83 fa 0b cmp $0xb,%edx
107db9: 77 43 ja 107dfe <fpathconf+0x82>
107dbb: ff 24 95 10 08 12 00 jmp *0x120810(,%edx,4)
case _PC_LINK_MAX:
return_value = the_limits->link_max;
107dc2: 8b 40 38 mov 0x38(%eax),%eax
break;
107dc5: eb 45 jmp 107e0c <fpathconf+0x90>
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
107dc7: 8b 40 3c mov 0x3c(%eax),%eax
break;
107dca: eb 40 jmp 107e0c <fpathconf+0x90>
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
107dcc: 8b 40 40 mov 0x40(%eax),%eax
break;
107dcf: eb 3b jmp 107e0c <fpathconf+0x90>
case _PC_NAME_MAX:
return_value = the_limits->name_max;
107dd1: 8b 40 44 mov 0x44(%eax),%eax
break;
107dd4: eb 36 jmp 107e0c <fpathconf+0x90>
case _PC_PATH_MAX:
return_value = the_limits->path_max;
107dd6: 8b 40 48 mov 0x48(%eax),%eax
break;
107dd9: eb 31 jmp 107e0c <fpathconf+0x90>
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
107ddb: 8b 40 4c mov 0x4c(%eax),%eax
break;
107dde: eb 2c jmp 107e0c <fpathconf+0x90>
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
107de0: 8b 40 54 mov 0x54(%eax),%eax
break;
107de3: eb 27 jmp 107e0c <fpathconf+0x90>
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
107de5: 8b 40 58 mov 0x58(%eax),%eax
break;
107de8: eb 22 jmp 107e0c <fpathconf+0x90>
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
107dea: 8b 40 64 mov 0x64(%eax),%eax
break;
107ded: eb 1d jmp 107e0c <fpathconf+0x90>
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
107def: 8b 40 50 mov 0x50(%eax),%eax
break;
107df2: eb 18 jmp 107e0c <fpathconf+0x90>
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
107df4: 8b 40 5c mov 0x5c(%eax),%eax
break;
107df7: eb 13 jmp 107e0c <fpathconf+0x90>
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
107df9: 8b 40 60 mov 0x60(%eax),%eax
break;
107dfc: eb 0e jmp 107e0c <fpathconf+0x90>
default:
rtems_set_errno_and_return_minus_one( EINVAL );
107dfe: e8 21 a1 00 00 call 111f24 <__errno>
107e03: c7 00 16 00 00 00 movl $0x16,(%eax)
107e09: 83 c8 ff or $0xffffffff,%eax
break;
}
return return_value;
}
107e0c: c9 leave
107e0d: c3 ret
00107348 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
107348: 55 push %ebp
107349: 89 e5 mov %esp,%ebp
10734b: 53 push %ebx
10734c: 83 ec 04 sub $0x4,%esp
10734f: 8b 5d 08 mov 0x8(%ebp),%ebx
MSBUMP(free_calls, 1);
107352: ff 05 1c 52 12 00 incl 0x12521c
if ( !ptr )
107358: 85 db test %ebx,%ebx
10735a: 74 5f je 1073bb <free+0x73>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
10735c: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c
107363: 75 15 jne 10737a <free+0x32> <== NEVER TAKEN
!malloc_is_system_state_OK() ) {
107365: e8 56 01 00 00 call 1074c0 <malloc_is_system_state_OK>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
10736a: 84 c0 test %al,%al
10736c: 75 0c jne 10737a <free+0x32>
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
10736e: 89 5d 08 mov %ebx,0x8(%ebp)
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
107371: 8b 5d fc mov -0x4(%ebp),%ebx
107374: c9 leave
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
107375: e9 ae 01 00 00 jmp 107528 <malloc_deferred_free>
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
10737a: a1 70 36 12 00 mov 0x123670,%eax
10737f: 85 c0 test %eax,%eax
107381: 74 0a je 10738d <free+0x45>
(*rtems_malloc_statistics_helpers->at_free)(ptr);
107383: 83 ec 0c sub $0xc,%esp
107386: 53 push %ebx
107387: ff 50 08 call *0x8(%eax)
10738a: 83 c4 10 add $0x10,%esp
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
10738d: 50 push %eax
10738e: 50 push %eax
10738f: 53 push %ebx
107390: ff 35 80 11 12 00 pushl 0x121180
107396: e8 09 46 00 00 call 10b9a4 <_Protected_heap_Free>
10739b: 83 c4 10 add $0x10,%esp
10739e: 84 c0 test %al,%al
1073a0: 75 19 jne 1073bb <free+0x73>
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
ptr,
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
1073a2: a1 80 11 12 00 mov 0x121180,%eax
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_free)(ptr);
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
1073a7: ff 70 1c pushl 0x1c(%eax)
1073aa: ff 70 18 pushl 0x18(%eax)
1073ad: 53 push %ebx
1073ae: 68 db ee 11 00 push $0x11eedb
1073b3: e8 d8 0b 00 00 call 107f90 <printk>
1073b8: 83 c4 10 add $0x10,%esp
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
1073bb: 8b 5d fc mov -0x4(%ebp),%ebx
1073be: c9 leave
1073bf: c3 ret
001085c0 <free_user_env>:
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
1085c0: 55 push %ebp
1085c1: 89 e5 mov %esp,%ebp
1085c3: 53 push %ebx
1085c4: 83 ec 04 sub $0x4,%esp
1085c7: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
1085ca: 81 fb 48 52 12 00 cmp $0x125248,%ebx
1085d0: 74 26 je 1085f8 <free_user_env+0x38> <== NEVER TAKEN
#ifdef HAVE_USERENV_REFCNT
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
1085d2: 83 ec 0c sub $0xc,%esp
1085d5: 8d 43 04 lea 0x4(%ebx),%eax
1085d8: 50 push %eax
1085d9: e8 6a f1 ff ff call 107748 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &env->root_directory);
1085de: 8d 43 18 lea 0x18(%ebx),%eax
1085e1: 89 04 24 mov %eax,(%esp)
1085e4: e8 5f f1 ff ff call 107748 <rtems_filesystem_freenode>
free(env);
1085e9: 83 c4 10 add $0x10,%esp
1085ec: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
1085ef: 8b 5d fc mov -0x4(%ebp),%ebx
1085f2: c9 leave
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
rtems_filesystem_freenode( &env->root_directory);
free(env);
1085f3: e9 64 f1 ff ff jmp 10775c <free>
}
}
1085f8: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
1085fb: c9 leave <== NOT EXECUTED
1085fc: c3 ret <== NOT EXECUTED
0011e728 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
11e728: 55 push %ebp
11e729: 89 e5 mov %esp,%ebp
11e72b: 57 push %edi
11e72c: 56 push %esi
11e72d: 53 push %ebx
11e72e: 83 ec 2c sub $0x2c,%esp
11e731: 8b 45 08 mov 0x8(%ebp),%eax
rtems_filesystem_location_info_t loc;
/*
* Get the file control block structure associated with the file descriptor
*/
iop = rtems_libio_iop( dd_fd );
11e734: 31 db xor %ebx,%ebx
11e736: 3b 05 44 31 12 00 cmp 0x123144,%eax
11e73c: 73 09 jae 11e747 <getdents+0x1f> <== NEVER TAKEN
11e73e: 6b d8 38 imul $0x38,%eax,%ebx
11e741: 03 1d 40 73 12 00 add 0x127340,%ebx
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
11e747: 8d 7d d4 lea -0x2c(%ebp),%edi
11e74a: 8d 73 18 lea 0x18(%ebx),%esi
11e74d: b9 05 00 00 00 mov $0x5,%ecx
11e752: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
11e754: 83 ec 0c sub $0xc,%esp
11e757: 8d 45 d4 lea -0x2c(%ebp),%eax
11e75a: 50 push %eax
11e75b: 8b 45 e0 mov -0x20(%ebp),%eax
11e75e: ff 50 10 call *0x10(%eax)
11e761: 83 c4 10 add $0x10,%esp
11e764: 48 dec %eax
11e765: 74 10 je 11e777 <getdents+0x4f>
rtems_set_errno_and_return_minus_one( ENOTDIR );
11e767: e8 d8 38 ff ff call 112044 <__errno>
11e76c: c7 00 14 00 00 00 movl $0x14,(%eax)
11e772: 83 c8 ff or $0xffffffff,%eax
11e775: eb 11 jmp 11e788 <getdents+0x60>
/*
* Return the number of bytes that were actually transfered as a result
* of the read attempt.
*/
return (*iop->pathinfo.handlers->read_h)( iop, dd_buf, dd_len );
11e777: 50 push %eax
11e778: 8b 43 20 mov 0x20(%ebx),%eax
11e77b: ff 75 10 pushl 0x10(%ebp)
11e77e: ff 75 0c pushl 0xc(%ebp)
11e781: 53 push %ebx
11e782: ff 50 08 call *0x8(%eax)
11e785: 83 c4 10 add $0x10,%esp
}
11e788: 8d 65 f4 lea -0xc(%ebp),%esp
11e78b: 5b pop %ebx
11e78c: 5e pop %esi
11e78d: 5f pop %edi
11e78e: c9 leave
11e78f: c3 ret
001106a4 <imfs_dir_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
1106a4: 55 push %ebp
1106a5: 89 e5 mov %esp,%ebp
1106a7: 8b 55 08 mov 0x8(%ebp),%edx
IMFS_jnode_t *the_jnode;
/* Is the node a directory ? */
the_jnode = (IMFS_jnode_t *) iop->pathinfo.node_access;
if ( the_jnode->type != IMFS_DIRECTORY )
1106aa: 8b 4a 18 mov 0x18(%edx),%ecx
return -1; /* It wasn't a directory --> return error */
1106ad: 83 c8 ff or $0xffffffff,%eax
IMFS_jnode_t *the_jnode;
/* Is the node a directory ? */
the_jnode = (IMFS_jnode_t *) iop->pathinfo.node_access;
if ( the_jnode->type != IMFS_DIRECTORY )
1106b0: 83 79 4c 01 cmpl $0x1,0x4c(%ecx)
1106b4: 75 10 jne 1106c6 <imfs_dir_open+0x22> <== NEVER TAKEN
return -1; /* It wasn't a directory --> return error */
iop->offset = 0;
1106b6: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
1106bd: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx)
return 0;
1106c4: 31 c0 xor %eax,%eax
}
1106c6: c9 leave
1106c7: c3 ret
0011090d <imfs_dir_rmnod>:
int imfs_dir_rmnod(
rtems_filesystem_location_info_t *parent_pathloc, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
11090d: 55 push %ebp
11090e: 89 e5 mov %esp,%ebp
110910: 53 push %ebx
110911: 83 ec 04 sub $0x4,%esp
110914: 8b 45 0c mov 0xc(%ebp),%eax
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
110917: 8b 18 mov (%eax),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
110919: 8d 53 54 lea 0x54(%ebx),%edx
/*
* You cannot remove a node that still has children
*/
if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) )
11091c: 39 53 50 cmp %edx,0x50(%ebx)
11091f: 74 0d je 11092e <imfs_dir_rmnod+0x21>
rtems_set_errno_and_return_minus_one( ENOTEMPTY );
110921: e8 a6 07 00 00 call 1110cc <__errno>
110926: c7 00 5a 00 00 00 movl $0x5a,(%eax)
11092c: eb 13 jmp 110941 <imfs_dir_rmnod+0x34>
/*
* You cannot remove the file system root node.
*/
if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access )
11092e: 8b 40 10 mov 0x10(%eax),%eax
110931: 39 58 1c cmp %ebx,0x1c(%eax)
110934: 75 10 jne 110946 <imfs_dir_rmnod+0x39>
rtems_set_errno_and_return_minus_one( EBUSY );
110936: e8 91 07 00 00 call 1110cc <__errno>
11093b: c7 00 10 00 00 00 movl $0x10,(%eax)
110941: 83 c8 ff or $0xffffffff,%eax
110944: eb 1c jmp 110962 <imfs_dir_rmnod+0x55>
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
110946: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx)
11094a: 75 ea jne 110936 <imfs_dir_rmnod+0x29> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EBUSY );
IMFS_create_orphan( the_jnode );
11094c: 83 ec 0c sub $0xc,%esp
11094f: 53 push %ebx
110950: e8 27 d5 ff ff call 10de7c <IMFS_create_orphan>
IMFS_check_node_remove( the_jnode );
110955: 89 1c 24 mov %ebx,(%esp)
110958: e8 61 d5 ff ff call 10debe <IMFS_check_node_remove>
return 0;
11095d: 83 c4 10 add $0x10,%esp
110960: 31 c0 xor %eax,%eax
}
110962: 8b 5d fc mov -0x4(%ebp),%ebx
110965: c9 leave
110966: c3 ret
00107c6c <init_etc_passwd_group>:
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
107c6c: 55 push %ebp
107c6d: 89 e5 mov %esp,%ebp
107c6f: 53 push %ebx
107c70: 83 ec 04 sub $0x4,%esp
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
107c73: 80 3d bc 6c 12 00 00 cmpb $0x0,0x126cbc
107c7a: 0f 85 b8 00 00 00 jne 107d38 <init_etc_passwd_group+0xcc>
return;
etc_passwd_initted = 1;
107c80: c6 05 bc 6c 12 00 01 movb $0x1,0x126cbc
mkdir("/etc", 0777);
107c87: 50 push %eax
107c88: 50 push %eax
107c89: 68 ff 01 00 00 push $0x1ff
107c8e: 68 67 07 12 00 push $0x120767
107c93: e8 7c 07 00 00 call 108414 <mkdir>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
107c98: 59 pop %ecx
107c99: 5b pop %ebx
107c9a: 68 b2 f4 11 00 push $0x11f4b2
107c9f: 68 6c 07 12 00 push $0x12076c
107ca4: e8 ff a9 00 00 call 1126a8 <fopen>
107ca9: 83 c4 10 add $0x10,%esp
107cac: 85 c0 test %eax,%eax
107cae: 74 06 je 107cb6 <init_etc_passwd_group+0x4a>
fclose(fp);
107cb0: 83 ec 0c sub $0xc,%esp
107cb3: 50 push %eax
107cb4: eb 2a jmp 107ce0 <init_etc_passwd_group+0x74>
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
107cb6: 52 push %edx
107cb7: 52 push %edx
107cb8: 68 cc f3 11 00 push $0x11f3cc
107cbd: 68 6c 07 12 00 push $0x12076c
107cc2: e8 e1 a9 00 00 call 1126a8 <fopen>
107cc7: 89 c3 mov %eax,%ebx
107cc9: 83 c4 10 add $0x10,%esp
107ccc: 85 c0 test %eax,%eax
107cce: 74 18 je 107ce8 <init_etc_passwd_group+0x7c><== NEVER TAKEN
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
107cd0: 50 push %eax
107cd1: 50 push %eax
107cd2: 53 push %ebx
107cd3: 68 78 07 12 00 push $0x120778
107cd8: e8 97 aa 00 00 call 112774 <fputs>
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
107cdd: 89 1c 24 mov %ebx,(%esp)
107ce0: e8 bf a2 00 00 call 111fa4 <fclose>
107ce5: 83 c4 10 add $0x10,%esp
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
107ce8: 51 push %ecx
107ce9: 51 push %ecx
107cea: 68 b2 f4 11 00 push $0x11f4b2
107cef: 68 df 07 12 00 push $0x1207df
107cf4: e8 af a9 00 00 call 1126a8 <fopen>
107cf9: 83 c4 10 add $0x10,%esp
107cfc: 85 c0 test %eax,%eax
107cfe: 74 06 je 107d06 <init_etc_passwd_group+0x9a>
fclose(fp);
107d00: 83 ec 0c sub $0xc,%esp
107d03: 50 push %eax
107d04: eb 2a jmp 107d30 <init_etc_passwd_group+0xc4>
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
107d06: 52 push %edx
107d07: 52 push %edx
107d08: 68 cc f3 11 00 push $0x11f3cc
107d0d: 68 df 07 12 00 push $0x1207df
107d12: e8 91 a9 00 00 call 1126a8 <fopen>
107d17: 89 c3 mov %eax,%ebx
107d19: 83 c4 10 add $0x10,%esp
107d1c: 85 c0 test %eax,%eax
107d1e: 74 18 je 107d38 <init_etc_passwd_group+0xcc><== NEVER TAKEN
fprintf( fp, "root:x:0:root\n"
107d20: 50 push %eax
107d21: 50 push %eax
107d22: 53 push %ebx
107d23: 68 ea 07 12 00 push $0x1207ea
107d28: e8 47 aa 00 00 call 112774 <fputs>
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
107d2d: 89 1c 24 mov %ebx,(%esp)
107d30: e8 6f a2 00 00 call 111fa4 <fclose>
107d35: 83 c4 10 add $0x10,%esp
}
}
107d38: 8b 5d fc mov -0x4(%ebp),%ebx
107d3b: c9 leave
107d3c: c3 ret
00108e0c <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
108e0c: 55 push %ebp
108e0d: 89 e5 mov %esp,%ebp
108e0f: 53 push %ebx
108e10: 83 ec 14 sub $0x14,%esp
108e13: 89 d3 mov %edx,%ebx
108e15: 88 c1 mov %al,%cl
if (tty->termios.c_iflag & ISTRIP)
108e17: 8b 52 30 mov 0x30(%edx),%edx
108e1a: f6 c2 20 test $0x20,%dl
108e1d: 74 03 je 108e22 <iproc+0x16> <== ALWAYS TAKEN
c &= 0x7f;
108e1f: 83 e1 7f and $0x7f,%ecx <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
108e22: f6 c6 02 test $0x2,%dh
108e25: 74 16 je 108e3d <iproc+0x31>
c = tolower (c);
108e27: 0f b6 c9 movzbl %cl,%ecx
108e2a: a1 3c 31 12 00 mov 0x12313c,%eax
108e2f: 0f be 44 08 01 movsbl 0x1(%eax,%ecx,1),%eax
108e34: 83 e0 03 and $0x3,%eax
108e37: 48 dec %eax
108e38: 75 03 jne 108e3d <iproc+0x31>
108e3a: 83 c1 20 add $0x20,%ecx
if (c == '\r') {
108e3d: 80 f9 0d cmp $0xd,%cl
108e40: 75 14 jne 108e56 <iproc+0x4a>
if (tty->termios.c_iflag & IGNCR)
return 0;
108e42: 31 c0 xor %eax,%eax
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
108e44: f6 c2 80 test $0x80,%dl
108e47: 0f 85 d9 00 00 00 jne 108f26 <iproc+0x11a> <== NEVER TAKEN
return 0;
if (tty->termios.c_iflag & ICRNL)
108e4d: 80 e6 01 and $0x1,%dh
108e50: 74 1a je 108e6c <iproc+0x60> <== NEVER TAKEN
c = '\n';
108e52: b1 0a mov $0xa,%cl
108e54: eb 16 jmp 108e6c <iproc+0x60>
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
108e56: 80 f9 0a cmp $0xa,%cl
108e59: 75 09 jne 108e64 <iproc+0x58>
108e5b: 80 e2 40 and $0x40,%dl
108e5e: 74 0c je 108e6c <iproc+0x60> <== ALWAYS TAKEN
c = '\r';
108e60: b1 0d mov $0xd,%cl <== NOT EXECUTED
108e62: eb 08 jmp 108e6c <iproc+0x60> <== NOT EXECUTED
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
108e64: 84 c9 test %cl,%cl
108e66: 0f 84 87 00 00 00 je 108ef3 <iproc+0xe7> <== NEVER TAKEN
108e6c: 8b 53 3c mov 0x3c(%ebx),%edx
108e6f: f6 c2 02 test $0x2,%dl
108e72: 74 7f je 108ef3 <iproc+0xe7>
if (c == tty->termios.c_cc[VERASE]) {
108e74: 3a 4b 43 cmp 0x43(%ebx),%cl
108e77: 75 04 jne 108e7d <iproc+0x71>
erase (tty, 0);
108e79: 31 d2 xor %edx,%edx
108e7b: eb 0a jmp 108e87 <iproc+0x7b>
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
108e7d: 3a 4b 44 cmp 0x44(%ebx),%cl
108e80: 75 11 jne 108e93 <iproc+0x87>
erase (tty, 1);
108e82: ba 01 00 00 00 mov $0x1,%edx
108e87: 89 d8 mov %ebx,%eax
108e89: e8 05 fe ff ff call 108c93 <erase>
108e8e: e9 91 00 00 00 jmp 108f24 <iproc+0x118>
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
108e93: b8 01 00 00 00 mov $0x1,%eax
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
108e98: 3a 4b 45 cmp 0x45(%ebx),%cl
108e9b: 0f 84 85 00 00 00 je 108f26 <iproc+0x11a> <== NEVER TAKEN
return 1;
} else if (c == '\n') {
108ea1: 80 f9 0a cmp $0xa,%cl
108ea4: 75 1a jne 108ec0 <iproc+0xb4>
if (tty->termios.c_lflag & (ECHO | ECHONL))
108ea6: 80 e2 48 and $0x48,%dl
108ea9: 74 09 je 108eb4 <iproc+0xa8> <== NEVER TAKEN
echo (c, tty);
108eab: 89 da mov %ebx,%edx
108ead: b0 0a mov $0xa,%al
108eaf: e8 87 fd ff ff call 108c3b <echo>
tty->cbuf[tty->ccount++] = c;
108eb4: 8b 43 20 mov 0x20(%ebx),%eax
108eb7: 8b 53 1c mov 0x1c(%ebx),%edx
108eba: c6 04 02 0a movb $0xa,(%edx,%eax,1)
108ebe: eb 28 jmp 108ee8 <iproc+0xdc>
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
108ec0: 3a 4b 4c cmp 0x4c(%ebx),%cl
108ec3: 74 05 je 108eca <iproc+0xbe> <== NEVER TAKEN
108ec5: 3a 4b 51 cmp 0x51(%ebx),%cl
108ec8: 75 29 jne 108ef3 <iproc+0xe7> <== ALWAYS TAKEN
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
108eca: 80 e2 08 and $0x8,%dl <== NOT EXECUTED
108ecd: 74 10 je 108edf <iproc+0xd3> <== NOT EXECUTED
echo (c, tty);
108ecf: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED
108ed2: 89 da mov %ebx,%edx <== NOT EXECUTED
108ed4: 88 4d f4 mov %cl,-0xc(%ebp) <== NOT EXECUTED
108ed7: e8 5f fd ff ff call 108c3b <echo> <== NOT EXECUTED
108edc: 8a 4d f4 mov -0xc(%ebp),%cl <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
108edf: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED
108ee2: 8b 53 1c mov 0x1c(%ebx),%edx <== NOT EXECUTED
108ee5: 88 0c 02 mov %cl,(%edx,%eax,1) <== NOT EXECUTED
108ee8: 40 inc %eax
108ee9: 89 43 20 mov %eax,0x20(%ebx)
return 1;
108eec: b8 01 00 00 00 mov $0x1,%eax
108ef1: eb 33 jmp 108f26 <iproc+0x11a>
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
108ef3: 8b 15 70 30 12 00 mov 0x123070,%edx
108ef9: 4a dec %edx
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
108efa: 31 c0 xor %eax,%eax
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
108efc: 39 53 20 cmp %edx,0x20(%ebx)
108eff: 7d 25 jge 108f26 <iproc+0x11a> <== NEVER TAKEN
if (tty->termios.c_lflag & ECHO)
108f01: f6 43 3c 08 testb $0x8,0x3c(%ebx)
108f05: 74 10 je 108f17 <iproc+0x10b> <== NEVER TAKEN
echo (c, tty);
108f07: 0f b6 c1 movzbl %cl,%eax
108f0a: 89 da mov %ebx,%edx
108f0c: 88 4d f4 mov %cl,-0xc(%ebp)
108f0f: e8 27 fd ff ff call 108c3b <echo>
108f14: 8a 4d f4 mov -0xc(%ebp),%cl
tty->cbuf[tty->ccount++] = c;
108f17: 8b 43 20 mov 0x20(%ebx),%eax
108f1a: 8b 53 1c mov 0x1c(%ebx),%edx
108f1d: 88 0c 02 mov %cl,(%edx,%eax,1)
108f20: 40 inc %eax
108f21: 89 43 20 mov %eax,0x20(%ebx)
}
return 0;
108f24: 31 c0 xor %eax,%eax
}
108f26: 83 c4 14 add $0x14,%esp
108f29: 5b pop %ebx
108f2a: c9 leave
108f2b: c3 ret
00121ef8 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
121ef8: 55 push %ebp
121ef9: 89 e5 mov %esp,%ebp
121efb: 57 push %edi
121efc: 56 push %esi
121efd: 53 push %ebx
121efe: 83 ec 4c sub $0x4c,%esp
121f01: 8b 5d 0c mov 0xc(%ebp),%ebx
121f04: 8b 7d 10 mov 0x10(%ebp),%edi
POSIX_signals_Siginfo_node *psiginfo;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
121f07: e8 64 fd ff ff call 121c70 <getpid>
121f0c: 39 45 08 cmp %eax,0x8(%ebp)
121f0f: 74 0d je 121f1e <killinfo+0x26>
rtems_set_errno_and_return_minus_one( ESRCH );
121f11: e8 4e 3a ff ff call 115964 <__errno>
121f16: c7 00 03 00 00 00 movl $0x3,(%eax)
121f1c: eb 0f jmp 121f2d <killinfo+0x35>
/*
* Validate the signal passed.
*/
if ( !sig )
121f1e: 85 db test %ebx,%ebx
121f20: 75 13 jne 121f35 <killinfo+0x3d>
rtems_set_errno_and_return_minus_one( EINVAL );
121f22: e8 3d 3a ff ff call 115964 <__errno>
121f27: c7 00 16 00 00 00 movl $0x16,(%eax)
121f2d: 83 c8 ff or $0xffffffff,%eax
121f30: e9 ef 01 00 00 jmp 122124 <killinfo+0x22c>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
121f35: 8d 4b ff lea -0x1(%ebx),%ecx
if ( !is_valid_signo(sig) )
121f38: 83 f9 1f cmp $0x1f,%ecx
121f3b: 77 e5 ja 121f22 <killinfo+0x2a>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
121f3d: 6b d3 0c imul $0xc,%ebx,%edx
return 0;
121f40: 31 c0 xor %eax,%eax
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
121f42: 83 ba 18 ba 12 00 01 cmpl $0x1,0x12ba18(%edx)
121f49: 0f 84 d5 01 00 00 je 122124 <killinfo+0x22c>
/*
* P1003.1c/Draft 10, p. 33 says that certain signals should always
* be directed to the executing thread such as those caused by hardware
* faults.
*/
if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) )
121f4f: 83 fb 04 cmp $0x4,%ebx
121f52: 74 0a je 121f5e <killinfo+0x66>
121f54: 83 fb 08 cmp $0x8,%ebx
121f57: 74 05 je 121f5e <killinfo+0x66>
121f59: 83 fb 0b cmp $0xb,%ebx
121f5c: 75 16 jne 121f74 <killinfo+0x7c>
return pthread_kill( pthread_self(), sig );
121f5e: e8 89 03 00 00 call 1222ec <pthread_self>
121f63: 56 push %esi
121f64: 56 push %esi
121f65: 53 push %ebx
121f66: 50 push %eax
121f67: e8 d8 02 00 00 call 122244 <pthread_kill>
121f6c: 83 c4 10 add $0x10,%esp
121f6f: e9 b0 01 00 00 jmp 122124 <killinfo+0x22c>
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
121f74: be 01 00 00 00 mov $0x1,%esi
121f79: d3 e6 shl %cl,%esi
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
121f7b: 89 5d dc mov %ebx,-0x24(%ebp)
siginfo->si_code = SI_USER;
121f7e: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp)
if ( !value ) {
121f85: 85 ff test %edi,%edi
121f87: 75 09 jne 121f92 <killinfo+0x9a>
siginfo->si_value.sival_int = 0;
121f89: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
121f90: eb 05 jmp 121f97 <killinfo+0x9f>
} else {
siginfo->si_value = *value;
121f92: 8b 07 mov (%edi),%eax
121f94: 89 45 e4 mov %eax,-0x1c(%ebp)
121f97: a1 b4 b4 12 00 mov 0x12b4b4,%eax
121f9c: 40 inc %eax
121f9d: a3 b4 b4 12 00 mov %eax,0x12b4b4
/*
* Is the currently executing thread interested? If so then it will
* get it an execute it as soon as the dispatcher executes.
*/
the_thread = _Thread_Executing;
121fa2: a1 dc b9 12 00 mov 0x12b9dc,%eax
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
121fa7: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
121fad: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx
121fb3: f7 d2 not %edx
121fb5: 85 d6 test %edx,%esi
121fb7: 0f 85 ed 00 00 00 jne 1220aa <killinfo+0x1b2>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
121fbd: 8b 15 9c bb 12 00 mov 0x12bb9c,%edx
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
121fc3: eb 23 jmp 121fe8 <killinfo+0xf0>
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
the_thread = (Thread_Control *)the_node;
121fc5: 89 d0 mov %edx,%eax
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
121fc7: 8b 8a ec 00 00 00 mov 0xec(%edx),%ecx
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
121fcd: 85 72 30 test %esi,0x30(%edx)
121fd0: 0f 85 d4 00 00 00 jne 1220aa <killinfo+0x1b2>
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
121fd6: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx
121fdc: f7 d1 not %ecx
121fde: 85 ce test %ecx,%esi
121fe0: 0f 85 c4 00 00 00 jne 1220aa <killinfo+0x1b2>
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
!_Chain_Is_tail( the_chain, the_node ) ;
the_node = the_node->next ) {
121fe6: 8b 12 mov (%edx),%edx
/* XXX violation of visibility -- need to define thread queue support */
the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo;
for ( the_node = _Chain_First( the_chain );
121fe8: 81 fa a0 bb 12 00 cmp $0x12bba0,%edx
121fee: 75 d5 jne 121fc5 <killinfo+0xcd>
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
121ff0: 0f b6 0d 24 72 12 00 movzbl 0x127224,%ecx
121ff7: 41 inc %ecx
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
121ff8: 31 c0 xor %eax,%eax
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
121ffa: c7 45 cc 02 00 00 00 movl $0x2,-0x34(%ebp)
/*
* This can occur when no one is interested and an API is not configured.
*/
if ( !_Objects_Information_table[ the_api ] )
122001: 8b 7d cc mov -0x34(%ebp),%edi
122004: 8b 14 bd 8c b4 12 00 mov 0x12b48c(,%edi,4),%edx
12200b: 85 d2 test %edx,%edx
12200d: 0f 84 86 00 00 00 je 122099 <killinfo+0x1a1> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
122013: 8b 52 04 mov 0x4(%edx),%edx
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
122016: 0f b7 7a 10 movzwl 0x10(%edx),%edi
12201a: 89 7d c4 mov %edi,-0x3c(%ebp)
object_table = the_info->local_table;
12201d: 8b 52 1c mov 0x1c(%edx),%edx
122020: 89 55 c0 mov %edx,-0x40(%ebp)
for ( index = 1 ; index <= maximum ; index++ ) {
122023: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp)
12202a: 89 5d b4 mov %ebx,-0x4c(%ebp)
12202d: eb 5f jmp 12208e <killinfo+0x196>
the_thread = (Thread_Control *) object_table[ index ];
12202f: 8b 5d d0 mov -0x30(%ebp),%ebx
122032: 8b 7d c0 mov -0x40(%ebp),%edi
122035: 8b 14 9f mov (%edi,%ebx,4),%edx
if ( !the_thread )
122038: 85 d2 test %edx,%edx
12203a: 74 4f je 12208b <killinfo+0x193>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
12203c: 8b 5a 14 mov 0x14(%edx),%ebx
12203f: 89 5d d4 mov %ebx,-0x2c(%ebp)
122042: 39 cb cmp %ecx,%ebx
122044: 77 45 ja 12208b <killinfo+0x193>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
122046: 8b ba ec 00 00 00 mov 0xec(%edx),%edi
12204c: 8b bf d0 00 00 00 mov 0xd0(%edi),%edi
122052: f7 d7 not %edi
122054: 85 fe test %edi,%esi
122056: 74 33 je 12208b <killinfo+0x193>
*
* NOTE: We initialized interested_priority to PRIORITY_MAXIMUM + 1
* so we never have to worry about deferencing a NULL
* interested thread.
*/
if ( the_thread->current_priority < interested_priority ) {
122058: 39 cb cmp %ecx,%ebx
12205a: 72 2a jb 122086 <killinfo+0x18e>
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
12205c: 85 c0 test %eax,%eax
12205e: 74 2b je 12208b <killinfo+0x193> <== NEVER TAKEN
122060: 8b 78 10 mov 0x10(%eax),%edi
122063: 89 7d c8 mov %edi,-0x38(%ebp)
122066: 85 ff test %edi,%edi
122068: 74 21 je 12208b <killinfo+0x193> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
12206a: 8b 7a 10 mov 0x10(%edx),%edi
12206d: 85 ff test %edi,%edi
12206f: 74 15 je 122086 <killinfo+0x18e>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
122071: f7 45 c8 00 00 00 10 testl $0x10000000,-0x38(%ebp)
122078: 75 11 jne 12208b <killinfo+0x193>
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
12207a: 81 e7 00 00 00 10 and $0x10000000,%edi
122080: 74 09 je 12208b <killinfo+0x193>
122082: 89 d9 mov %ebx,%ecx
122084: eb 03 jmp 122089 <killinfo+0x191>
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
122086: 8b 4d d4 mov -0x2c(%ebp),%ecx
122089: 89 d0 mov %edx,%eax
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
12208b: ff 45 d0 incl -0x30(%ebp)
12208e: 8b 55 c4 mov -0x3c(%ebp),%edx
122091: 39 55 d0 cmp %edx,-0x30(%ebp)
122094: 76 99 jbe 12202f <killinfo+0x137>
122096: 8b 5d b4 mov -0x4c(%ebp),%ebx
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
122099: ff 45 cc incl -0x34(%ebp)
12209c: 83 7d cc 04 cmpl $0x4,-0x34(%ebp)
1220a0: 0f 85 5b ff ff ff jne 122001 <killinfo+0x109>
}
}
}
}
if ( interested ) {
1220a6: 85 c0 test %eax,%eax
1220a8: 74 13 je 1220bd <killinfo+0x1c5>
/*
* Returns true if the signal was synchronously given to a thread
* blocked waiting for the signal.
*/
if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {
1220aa: 51 push %ecx
mask = signo_to_mask( sig );
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
1220ab: 8d 55 dc lea -0x24(%ebp),%edx
/*
* Returns true if the signal was synchronously given to a thread
* blocked waiting for the signal.
*/
if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {
1220ae: 52 push %edx
1220af: 53 push %ebx
1220b0: 50 push %eax
1220b1: e8 8a 00 00 00 call 122140 <_POSIX_signals_Unblock_thread>
1220b6: 83 c4 10 add $0x10,%esp
1220b9: 84 c0 test %al,%al
1220bb: 75 60 jne 12211d <killinfo+0x225>
/*
* We may have woken up a thread but we definitely need to post the
* signal to the process wide information set.
*/
_POSIX_signals_Set_process_signals( mask );
1220bd: 83 ec 0c sub $0xc,%esp
1220c0: 56 push %esi
1220c1: e8 66 00 00 00 call 12212c <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
1220c6: 6b db 0c imul $0xc,%ebx,%ebx
1220c9: 83 c4 10 add $0x10,%esp
1220cc: 83 bb 10 ba 12 00 02 cmpl $0x2,0x12ba10(%ebx)
1220d3: 75 48 jne 12211d <killinfo+0x225>
psiginfo = (POSIX_signals_Siginfo_node *)
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
1220d5: 83 ec 0c sub $0xc,%esp
1220d8: 68 90 bb 12 00 push $0x12bb90
1220dd: e8 5a d0 fe ff call 10f13c <_Chain_Get>
if ( !psiginfo ) {
1220e2: 83 c4 10 add $0x10,%esp
1220e5: 85 c0 test %eax,%eax
1220e7: 75 15 jne 1220fe <killinfo+0x206>
_Thread_Enable_dispatch();
1220e9: e8 6c e8 fe ff call 11095a <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
1220ee: e8 71 38 ff ff call 115964 <__errno>
1220f3: c7 00 0b 00 00 00 movl $0xb,(%eax)
1220f9: e9 2f fe ff ff jmp 121f2d <killinfo+0x35>
}
psiginfo->Info = *siginfo;
1220fe: 8d 78 08 lea 0x8(%eax),%edi
122101: 8d 75 dc lea -0x24(%ebp),%esi
122104: b9 03 00 00 00 mov $0x3,%ecx
122109: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
12210b: 52 push %edx
12210c: 52 push %edx
12210d: 50 push %eax
12210e: 81 c3 08 bc 12 00 add $0x12bc08,%ebx
122114: 53 push %ebx
122115: e8 e6 cf fe ff call 10f100 <_Chain_Append>
12211a: 83 c4 10 add $0x10,%esp
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
12211d: e8 38 e8 fe ff call 11095a <_Thread_Enable_dispatch>
return 0;
122122: 31 c0 xor %eax,%eax
}
122124: 8d 65 f4 lea -0xc(%ebp),%esp
122127: 5b pop %ebx
122128: 5e pop %esi
122129: 5f pop %edi
12212a: c9 leave
12212b: c3 ret
0011d024 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
11d024: 55 push %ebp
11d025: 89 e5 mov %esp,%ebp
11d027: 53 push %ebx
11d028: 83 ec 04 sub $0x4,%esp
/*
* In case RTEMS is already down, don't do this. It could be
* dangerous.
*/
if (!_System_state_Is_up(_System_state_Get()))
11d02b: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c
11d032: 75 4f jne 11d083 <libc_wrapup+0x5f> <== NEVER TAKEN
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != _global_impure_ptr) {
11d034: 8b 1d c0 f9 11 00 mov 0x11f9c0,%ebx
11d03a: 39 1d 40 31 12 00 cmp %ebx,0x123140
11d040: 74 12 je 11d054 <libc_wrapup+0x30>
_wrapup_reent(_global_impure_ptr);
11d042: 83 ec 0c sub $0xc,%esp
11d045: 53 push %ebx
11d046: e8 b5 05 00 00 call 11d600 <_wrapup_reent>
/* Don't reclaim this one, just in case we do printfs
* on the way out to ROM.
*/
_reclaim_reent(&libc_global_reent);
#endif
_REENT = _global_impure_ptr;
11d04b: 89 1d 40 31 12 00 mov %ebx,0x123140
11d051: 83 c4 10 add $0x10,%esp
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
11d054: 83 ec 0c sub $0xc,%esp
11d057: a1 40 31 12 00 mov 0x123140,%eax
11d05c: ff 70 04 pushl 0x4(%eax)
11d05f: e8 c0 41 ff ff call 111224 <fclose>
fclose (stdout);
11d064: 5a pop %edx
11d065: a1 40 31 12 00 mov 0x123140,%eax
11d06a: ff 70 08 pushl 0x8(%eax)
11d06d: e8 b2 41 ff ff call 111224 <fclose>
fclose (stderr);
11d072: 58 pop %eax
11d073: a1 40 31 12 00 mov 0x123140,%eax
11d078: ff 70 0c pushl 0xc(%eax)
11d07b: e8 a4 41 ff ff call 111224 <fclose>
11d080: 83 c4 10 add $0x10,%esp
}
11d083: 8b 5d fc mov -0x4(%ebp),%ebx
11d086: c9 leave
11d087: c3 ret
0011cf30 <lseek>:
off_t lseek(
int fd,
off_t offset,
int whence
)
{
11cf30: 55 push %ebp
11cf31: 89 e5 mov %esp,%ebp
11cf33: 57 push %edi
11cf34: 56 push %esi
11cf35: 53 push %ebx
11cf36: 83 ec 1c sub $0x1c,%esp
11cf39: 8b 5d 08 mov 0x8(%ebp),%ebx
11cf3c: 8b 45 0c mov 0xc(%ebp),%eax
11cf3f: 8b 55 10 mov 0x10(%ebp),%edx
11cf42: 8b 4d 14 mov 0x14(%ebp),%ecx
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
11cf45: 3b 1d 44 11 12 00 cmp 0x121144,%ebx
11cf4b: 73 0f jae 11cf5c <lseek+0x2c>
iop = rtems_libio_iop( fd );
11cf4d: 6b db 38 imul $0x38,%ebx,%ebx
11cf50: 03 1d f8 51 12 00 add 0x1251f8,%ebx
rtems_libio_check_is_open(iop);
11cf56: f6 43 15 01 testb $0x1,0x15(%ebx)
11cf5a: 75 0d jne 11cf69 <lseek+0x39>
11cf5c: e8 6b 41 ff ff call 1110cc <__errno>
11cf61: c7 00 09 00 00 00 movl $0x9,(%eax)
11cf67: eb 4b jmp 11cfb4 <lseek+0x84>
/*
* Now process the lseek().
*/
old_offset = iop->offset;
11cf69: 8b 73 0c mov 0xc(%ebx),%esi
11cf6c: 8b 7b 10 mov 0x10(%ebx),%edi
11cf6f: 89 75 e0 mov %esi,-0x20(%ebp)
11cf72: 89 7d e4 mov %edi,-0x1c(%ebp)
switch ( whence ) {
11cf75: 83 f9 01 cmp $0x1,%ecx
11cf78: 74 11 je 11cf8b <lseek+0x5b>
11cf7a: 83 f9 02 cmp $0x2,%ecx
11cf7d: 74 18 je 11cf97 <lseek+0x67>
11cf7f: 85 c9 test %ecx,%ecx
11cf81: 75 26 jne 11cfa9 <lseek+0x79>
case SEEK_SET:
iop->offset = offset;
11cf83: 89 43 0c mov %eax,0xc(%ebx)
11cf86: 89 53 10 mov %edx,0x10(%ebx)
break;
11cf89: eb 30 jmp 11cfbb <lseek+0x8b>
case SEEK_CUR:
iop->offset += offset;
11cf8b: 8b 75 e0 mov -0x20(%ebp),%esi
11cf8e: 8b 7d e4 mov -0x1c(%ebp),%edi
11cf91: 01 c6 add %eax,%esi
11cf93: 11 d7 adc %edx,%edi
11cf95: eb 0a jmp 11cfa1 <lseek+0x71>
break;
case SEEK_END:
iop->offset = iop->size + offset;
11cf97: 89 c6 mov %eax,%esi
11cf99: 89 d7 mov %edx,%edi
11cf9b: 03 73 04 add 0x4(%ebx),%esi
11cf9e: 13 7b 08 adc 0x8(%ebx),%edi
11cfa1: 89 73 0c mov %esi,0xc(%ebx)
11cfa4: 89 7b 10 mov %edi,0x10(%ebx)
break;
11cfa7: eb 12 jmp 11cfbb <lseek+0x8b>
default:
rtems_set_errno_and_return_minus_one( EINVAL );
11cfa9: e8 1e 41 ff ff call 1110cc <__errno>
11cfae: c7 00 16 00 00 00 movl $0x16,(%eax)
11cfb4: 83 c8 ff or $0xffffffff,%eax
11cfb7: 89 c2 mov %eax,%edx
11cfb9: eb 23 jmp 11cfde <lseek+0xae>
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
11cfbb: 8b 73 20 mov 0x20(%ebx),%esi
11cfbe: 51 push %ecx
11cfbf: 52 push %edx
11cfc0: 50 push %eax
11cfc1: 53 push %ebx
11cfc2: ff 56 14 call *0x14(%esi)
if ( status == (off_t) -1 )
11cfc5: 83 c4 10 add $0x10,%esp
11cfc8: 83 fa ff cmp $0xffffffff,%edx
11cfcb: 75 11 jne 11cfde <lseek+0xae>
11cfcd: 83 f8 ff cmp $0xffffffff,%eax
11cfd0: 75 0c jne 11cfde <lseek+0xae> <== NEVER TAKEN
iop->offset = old_offset;
11cfd2: 8b 75 e0 mov -0x20(%ebp),%esi
11cfd5: 8b 7d e4 mov -0x1c(%ebp),%edi
11cfd8: 89 73 0c mov %esi,0xc(%ebx)
11cfdb: 89 7b 10 mov %edi,0x10(%ebx)
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
11cfde: 8d 65 f4 lea -0xc(%ebp),%esp
11cfe1: 5b pop %ebx
11cfe2: 5e pop %esi
11cfe3: 5f pop %edi
11cfe4: c9 leave
11cfe5: c3 ret
001075e4 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
1075e4: 55 push %ebp
1075e5: 89 e5 mov %esp,%ebp
1075e7: 56 push %esi
1075e8: 53 push %ebx
1075e9: 8b 75 08 mov 0x8(%ebp),%esi
void *return_this;
MSBUMP(malloc_calls, 1);
1075ec: ff 05 14 52 12 00 incl 0x125214
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
1075f2: e8 07 ff ff ff call 1074fe <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
return (void *) 0;
1075f7: 31 db xor %ebx,%ebx
malloc_deferred_frees_process();
/*
* Validate the parameters
*/
if ( !size )
1075f9: 85 f6 test %esi,%esi
1075fb: 74 78 je 107675 <malloc+0x91>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
1075fd: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c
107604: 75 09 jne 10760f <malloc+0x2b>
!malloc_is_system_state_OK() )
107606: e8 b5 fe ff ff call 1074c0 <malloc_is_system_state_OK>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
10760b: 84 c0 test %al,%al
10760d: 74 66 je 107675 <malloc+0x91> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
10760f: 6a 00 push $0x0
107611: 6a 00 push $0x0
107613: 56 push %esi
107614: ff 35 80 11 12 00 pushl 0x121180
10761a: e8 4d 43 00 00 call 10b96c <_Protected_heap_Allocate_aligned_with_boundary>
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
10761f: 83 c4 10 add $0x10,%esp
107622: 89 c3 mov %eax,%ebx
107624: 85 c0 test %eax,%eax
107626: 75 28 jne 107650 <malloc+0x6c>
if (rtems_malloc_sbrk_helpers)
107628: a1 74 36 12 00 mov 0x123674,%eax
10762d: 85 c0 test %eax,%eax
10762f: 74 10 je 107641 <malloc+0x5d>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
107631: 83 ec 0c sub $0xc,%esp
107634: 56 push %esi
107635: ff 50 04 call *0x4(%eax)
107638: 89 c3 mov %eax,%ebx
if ( !return_this ) {
10763a: 83 c4 10 add $0x10,%esp
10763d: 85 c0 test %eax,%eax
10763f: 75 0f jne 107650 <malloc+0x6c>
errno = ENOMEM;
107641: e8 86 9a 00 00 call 1110cc <__errno>
107646: c7 00 0c 00 00 00 movl $0xc,(%eax)
return (void *) 0;
10764c: 31 db xor %ebx,%ebx
10764e: eb 25 jmp 107675 <malloc+0x91>
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
107650: a1 78 36 12 00 mov 0x123678,%eax
107655: 85 c0 test %eax,%eax
107657: 74 09 je 107662 <malloc+0x7e>
(*rtems_malloc_dirty_helper)( return_this, size );
107659: 52 push %edx
10765a: 52 push %edx
10765b: 56 push %esi
10765c: 53 push %ebx
10765d: ff d0 call *%eax
10765f: 83 c4 10 add $0x10,%esp
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
107662: a1 70 36 12 00 mov 0x123670,%eax
107667: 85 c0 test %eax,%eax
107669: 74 0a je 107675 <malloc+0x91>
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
10766b: 83 ec 0c sub $0xc,%esp
10766e: 53 push %ebx
10766f: ff 50 04 call *0x4(%eax)
107672: 83 c4 10 add $0x10,%esp
return return_this;
}
107675: 89 d8 mov %ebx,%eax
107677: 8d 65 f8 lea -0x8(%ebp),%esp
10767a: 5b pop %ebx
10767b: 5e pop %esi
10767c: c9 leave
10767d: c3 ret
0010794c <malloc_sbrk_extend_and_allocate>:
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
10794c: 55 push %ebp
10794d: 89 e5 mov %esp,%ebp
10794f: 57 push %edi
107950: 56 push %esi
107951: 53 push %ebx
107952: 83 ec 0c sub $0xc,%esp
107955: 8b 7d 08 mov 0x8(%ebp),%edi
* Round to the "requested sbrk amount" so hopefully we won't have
* to grow again for a while. This effectively does sbrk() calls
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
107958: 8b 0d 94 53 12 00 mov 0x125394,%ecx
if ( sbrk_amount == 0 )
return (void *) 0;
10795e: 31 f6 xor %esi,%esi
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
107960: 85 c9 test %ecx,%ecx
107962: 74 67 je 1079cb <malloc_sbrk_extend_and_allocate+0x7f><== NEVER TAKEN
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
107964: 8d 1c 0f lea (%edi,%ecx,1),%ebx
107967: 89 d8 mov %ebx,%eax
107969: 31 d2 xor %edx,%edx
10796b: f7 f1 div %ecx
10796d: 89 c3 mov %eax,%ebx
10796f: 0f af d9 imul %ecx,%ebx
starting_address = (void *) sbrk(the_size);
107972: 83 ec 0c sub $0xc,%esp
107975: 53 push %ebx
107976: e8 d8 8a ff ff call 100453 <sbrk>
if ( starting_address == (void*) -1 )
10797b: 83 c4 10 add $0x10,%esp
10797e: 83 f8 ff cmp $0xffffffff,%eax
107981: 74 48 je 1079cb <malloc_sbrk_extend_and_allocate+0x7f>
return (void *) 0;
if ( !_Protected_heap_Extend(
107983: 52 push %edx
107984: 53 push %ebx
107985: 50 push %eax
107986: ff 35 80 11 12 00 pushl 0x121180
10798c: e8 73 43 00 00 call 10bd04 <_Protected_heap_Extend>
107991: 83 c4 10 add $0x10,%esp
107994: 84 c0 test %al,%al
107996: 75 18 jne 1079b0 <malloc_sbrk_extend_and_allocate+0x64>
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
107998: 83 ec 0c sub $0xc,%esp
10799b: f7 db neg %ebx
10799d: 53 push %ebx
10799e: e8 b0 8a ff ff call 100453 <sbrk>
errno = ENOMEM;
1079a3: e8 ec 9c 00 00 call 111694 <__errno>
1079a8: c7 00 0c 00 00 00 movl $0xc,(%eax)
1079ae: eb 18 jmp 1079c8 <malloc_sbrk_extend_and_allocate+0x7c>
return (void *) 0;
}
MSBUMP(space_available, the_size);
1079b0: 01 1d 68 53 12 00 add %ebx,0x125368
1079b6: 6a 00 push $0x0
1079b8: 6a 00 push $0x0
1079ba: 57 push %edi
1079bb: ff 35 80 11 12 00 pushl 0x121180
1079c1: e8 06 43 00 00 call 10bccc <_Protected_heap_Allocate_aligned_with_boundary>
1079c6: 89 c6 mov %eax,%esi
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
1079c8: 83 c4 10 add $0x10,%esp
}
1079cb: 89 f0 mov %esi,%eax
1079cd: 8d 65 f4 lea -0xc(%ebp),%esp
1079d0: 5b pop %ebx
1079d1: 5e pop %esi
1079d2: 5f pop %edi
1079d3: c9 leave
1079d4: c3 ret
001103af <memfile_ftruncate>:
*/
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
1103af: 55 push %ebp
1103b0: 89 e5 mov %esp,%ebp
1103b2: 53 push %ebx
1103b3: 83 ec 14 sub $0x14,%esp
1103b6: 8b 4d 08 mov 0x8(%ebp),%ecx
1103b9: 8b 45 0c mov 0xc(%ebp),%eax
1103bc: 8b 55 10 mov 0x10(%ebp),%edx
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
1103bf: 8b 59 18 mov 0x18(%ecx),%ebx
* POSIX 1003.1b does not specify what happens if you truncate a file
* and the new length is greater than the current size. We treat this
* as an extend operation.
*/
if ( length > the_jnode->info.file.size )
1103c2: 3b 53 54 cmp 0x54(%ebx),%edx
1103c5: 7c 15 jl 1103dc <memfile_ftruncate+0x2d><== NEVER TAKEN
1103c7: 7f 05 jg 1103ce <memfile_ftruncate+0x1f><== NEVER TAKEN
1103c9: 3b 43 50 cmp 0x50(%ebx),%eax
1103cc: 76 0e jbe 1103dc <memfile_ftruncate+0x2d>
return IMFS_memfile_extend( the_jnode, length );
1103ce: 51 push %ecx
1103cf: 52 push %edx
1103d0: 50 push %eax
1103d1: 53 push %ebx
1103d2: e8 bf fc ff ff call 110096 <IMFS_memfile_extend>
1103d7: 83 c4 10 add $0x10,%esp
1103da: eb 24 jmp 110400 <memfile_ftruncate+0x51>
/*
* The in-memory files do not currently reclaim memory until the file is
* deleted. So we leave the previously allocated blocks in place for
* future use and just set the length.
*/
the_jnode->info.file.size = length;
1103dc: 89 43 50 mov %eax,0x50(%ebx)
1103df: 89 53 54 mov %edx,0x54(%ebx)
iop->size = the_jnode->info.file.size;
1103e2: 89 41 04 mov %eax,0x4(%ecx)
1103e5: 89 51 08 mov %edx,0x8(%ecx)
IMFS_update_atime( the_jnode );
1103e8: 50 push %eax
1103e9: 50 push %eax
1103ea: 6a 00 push $0x0
1103ec: 8d 45 f0 lea -0x10(%ebp),%eax
1103ef: 50 push %eax
1103f0: e8 cb 6f ff ff call 1073c0 <gettimeofday>
1103f5: 8b 45 f0 mov -0x10(%ebp),%eax
1103f8: 89 43 40 mov %eax,0x40(%ebx)
return 0;
1103fb: 83 c4 10 add $0x10,%esp
1103fe: 31 c0 xor %eax,%eax
}
110400: 8b 5d fc mov -0x4(%ebp),%ebx
110403: c9 leave
110404: c3 ret
00110405 <memfile_lseek>:
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
110405: 55 push %ebp
110406: 89 e5 mov %esp,%ebp
110408: 56 push %esi
110409: 53 push %ebx
11040a: 8b 5d 08 mov 0x8(%ebp),%ebx
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
11040d: 8b 73 18 mov 0x18(%ebx),%esi
if (the_jnode->type == IMFS_LINEAR_FILE) {
110410: 83 7e 4c 06 cmpl $0x6,0x4c(%esi)
110414: 75 1a jne 110430 <memfile_lseek+0x2b>
if (iop->offset > the_jnode->info.linearfile.size)
110416: 8b 56 50 mov 0x50(%esi),%edx
110419: 8b 46 54 mov 0x54(%esi),%eax
11041c: 39 43 10 cmp %eax,0x10(%ebx)
11041f: 7c 41 jl 110462 <memfile_lseek+0x5d> <== NEVER TAKEN
110421: 7f 05 jg 110428 <memfile_lseek+0x23> <== NEVER TAKEN
110423: 39 53 0c cmp %edx,0xc(%ebx)
110426: 76 3a jbe 110462 <memfile_lseek+0x5d> <== ALWAYS TAKEN
iop->offset = the_jnode->info.linearfile.size;
110428: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED
11042b: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED
11042e: eb 32 jmp 110462 <memfile_lseek+0x5d> <== NOT EXECUTED
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
110430: 50 push %eax
110431: ff 73 10 pushl 0x10(%ebx)
110434: ff 73 0c pushl 0xc(%ebx)
110437: 56 push %esi
110438: e8 59 fc ff ff call 110096 <IMFS_memfile_extend>
11043d: 83 c4 10 add $0x10,%esp
110440: 85 c0 test %eax,%eax
110442: 74 12 je 110456 <memfile_lseek+0x51>
rtems_set_errno_and_return_minus_one( ENOSPC );
110444: e8 83 0c 00 00 call 1110cc <__errno>
110449: c7 00 1c 00 00 00 movl $0x1c,(%eax)
11044f: 83 c8 ff or $0xffffffff,%eax
110452: 89 c2 mov %eax,%edx
110454: eb 12 jmp 110468 <memfile_lseek+0x63>
iop->size = the_jnode->info.file.size;
110456: 8b 46 50 mov 0x50(%esi),%eax
110459: 8b 56 54 mov 0x54(%esi),%edx
11045c: 89 43 04 mov %eax,0x4(%ebx)
11045f: 89 53 08 mov %edx,0x8(%ebx)
}
return iop->offset;
110462: 8b 43 0c mov 0xc(%ebx),%eax
110465: 8b 53 10 mov 0x10(%ebx),%edx
}
110468: 8d 65 f8 lea -0x8(%ebp),%esp
11046b: 5b pop %ebx
11046c: 5e pop %esi
11046d: c9 leave
11046e: c3 ret
00110320 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
110320: 55 push %ebp
110321: 89 e5 mov %esp,%ebp
110323: 56 push %esi
110324: 53 push %ebx
110325: 8b 75 08 mov 0x8(%ebp),%esi
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
110328: 8b 5e 18 mov 0x18(%esi),%ebx
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
11032b: f7 46 14 04 02 00 00 testl $0x204,0x14(%esi)
110332: 74 54 je 110388 <memfile_open+0x68>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
110334: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx)
110338: 75 4e jne 110388 <memfile_open+0x68> <== ALWAYS TAKEN
uint32_t count = the_jnode->info.linearfile.size;
11033a: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
11033d: 8b 53 58 mov 0x58(%ebx),%edx <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
110340: c7 43 4c 05 00 00 00 movl $0x5,0x4c(%ebx) <== NOT EXECUTED
the_jnode->info.file.size = 0;
110347: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED
11034e: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
110355: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
11035c: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
110363: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED
if ((count != 0)
11036a: 85 c0 test %eax,%eax <== NOT EXECUTED
11036c: 74 1a je 110388 <memfile_open+0x68> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
11036e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
110371: 50 push %eax <== NOT EXECUTED
110372: 52 push %edx <== NOT EXECUTED
110373: 6a 00 push $0x0 <== NOT EXECUTED
110375: 6a 00 push $0x0 <== NOT EXECUTED
110377: 53 push %ebx <== NOT EXECUTED
110378: e8 0b fe ff ff call 110188 <IMFS_memfile_write> <== NOT EXECUTED
11037d: 89 c2 mov %eax,%edx <== NOT EXECUTED
11037f: 83 c4 20 add $0x20,%esp <== NOT EXECUTED
return -1;
110382: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
110385: 42 inc %edx <== NOT EXECUTED
110386: 74 20 je 1103a8 <memfile_open+0x88> <== NOT EXECUTED
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
110388: f6 46 15 02 testb $0x2,0x15(%esi)
11038c: 74 0c je 11039a <memfile_open+0x7a>
iop->offset = the_jnode->info.file.size;
11038e: 8b 43 50 mov 0x50(%ebx),%eax
110391: 8b 53 54 mov 0x54(%ebx),%edx
110394: 89 46 0c mov %eax,0xc(%esi)
110397: 89 56 10 mov %edx,0x10(%esi)
iop->size = the_jnode->info.file.size;
11039a: 8b 43 50 mov 0x50(%ebx),%eax
11039d: 8b 53 54 mov 0x54(%ebx),%edx
1103a0: 89 46 04 mov %eax,0x4(%esi)
1103a3: 89 56 08 mov %edx,0x8(%esi)
return 0;
1103a6: 31 c0 xor %eax,%eax
}
1103a8: 8d 65 f8 lea -0x8(%ebp),%esp
1103ab: 5b pop %ebx
1103ac: 5e pop %esi
1103ad: c9 leave
1103ae: c3 ret
001077b5 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
1077b5: 55 push %ebp
1077b6: 89 e5 mov %esp,%ebp
1077b8: 57 push %edi
1077b9: 56 push %esi
1077ba: 53 push %ebx
1077bb: 83 ec 4c sub $0x4c,%esp
1077be: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
1077c1: 83 7d 14 01 cmpl $0x1,0x14(%ebp)
1077c5: 77 13 ja 1077da <mount+0x25>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
1077c7: 83 ec 0c sub $0xc,%esp
1077ca: 56 push %esi
1077cb: e8 77 6c 00 00 call 10e447 <rtems_filesystem_get_mount_handler>
1077d0: 89 45 b0 mov %eax,-0x50(%ebp)
if ( !mount_h )
1077d3: 83 c4 10 add $0x10,%esp
1077d6: 85 c0 test %eax,%eax
1077d8: 75 10 jne 1077ea <mount+0x35>
rtems_set_errno_and_return_minus_one( EINVAL );
1077da: e8 ed 98 00 00 call 1110cc <__errno>
1077df: c7 00 16 00 00 00 movl $0x16,(%eax)
1077e5: e9 ca 00 00 00 jmp 1078b4 <mount+0xff>
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
bool has_target = target != NULL;
1077ea: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
1077ee: 0f 95 45 b7 setne -0x49(%ebp)
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
1077f2: 8b 45 0c mov 0xc(%ebp),%eax
1077f5: 89 45 b8 mov %eax,-0x48(%ebp)
1077f8: 80 7d b7 00 cmpb $0x0,-0x49(%ebp)
1077fc: 75 07 jne 107805 <mount+0x50>
1077fe: c7 45 b8 d4 ee 11 00 movl $0x11eed4,-0x48(%ebp)
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
107805: 83 ca ff or $0xffffffff,%edx
107808: 31 c0 xor %eax,%eax
10780a: 89 d1 mov %edx,%ecx
10780c: 89 f7 mov %esi,%edi
10780e: f2 ae repnz scas %es:(%edi),%al
107810: f7 d1 not %ecx
107812: 89 4d bc mov %ecx,-0x44(%ebp)
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
107815: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
10781c: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
107820: 74 0c je 10782e <mount+0x79>
107822: 89 d1 mov %edx,%ecx
107824: 8b 7d 08 mov 0x8(%ebp),%edi
107827: f2 ae repnz scas %es:(%edi),%al
107829: f7 d1 not %ecx
10782b: 89 4d c4 mov %ecx,-0x3c(%ebp)
size_t target_size = strlen( target ) + 1;
10782e: 31 c0 xor %eax,%eax
107830: 83 c9 ff or $0xffffffff,%ecx
107833: 8b 7d b8 mov -0x48(%ebp),%edi
107836: f2 ae repnz scas %es:(%edi),%al
107838: f7 d1 not %ecx
10783a: 89 4d c0 mov %ecx,-0x40(%ebp)
10783d: 49 dec %ecx
10783e: 89 4d ac mov %ecx,-0x54(%ebp)
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
107841: 50 push %eax
107842: 50 push %eax
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
107843: 8b 55 c4 mov -0x3c(%ebp),%edx
107846: 8b 7d bc mov -0x44(%ebp),%edi
107849: 8d 44 3a 74 lea 0x74(%edx,%edi,1),%eax
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
10784d: 03 45 c0 add -0x40(%ebp),%eax
+ filesystemtype_size + source_size + target_size;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
107850: 50 push %eax
107851: 6a 01 push $0x1
107853: e8 84 f9 ff ff call 1071dc <calloc>
107858: 89 c3 mov %eax,%ebx
if ( mt_entry != NULL ) {
10785a: 83 c4 10 add $0x10,%esp
10785d: 85 c0 test %eax,%eax
10785f: 74 48 je 1078a9 <mount+0xf4> <== NEVER TAKEN
char *str = (char *) mt_entry + sizeof( *mt_entry );
107861: 8d 40 74 lea 0x74(%eax),%eax
memcpy( str, filesystemtype, filesystemtype_size );
107864: 89 c7 mov %eax,%edi
107866: 8b 4d bc mov -0x44(%ebp),%ecx
107869: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
10786b: 89 fa mov %edi,%edx
mt_entry->type = str;
10786d: 89 43 6c mov %eax,0x6c(%ebx)
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
107870: 8b 75 08 mov 0x8(%ebp),%esi
107873: 8b 4d c4 mov -0x3c(%ebp),%ecx
107876: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
107878: 89 f8 mov %edi,%eax
mt_entry->dev = str;
10787a: 89 53 70 mov %edx,0x70(%ebx)
str += source_size;
memcpy( str, target, target_size );
10787d: 8b 75 b8 mov -0x48(%ebp),%esi
107880: 8b 4d c0 mov -0x40(%ebp),%ecx
107883: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
mt_entry->target = str;
107885: 89 43 68 mov %eax,0x68(%ebx)
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
107888: 89 5b 2c mov %ebx,0x2c(%ebx)
mt_entry->options = options;
10788b: 8b 45 14 mov 0x14(%ebp),%eax
10788e: 89 43 30 mov %eax,0x30(%ebx)
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
107891: 8d 7b 38 lea 0x38(%ebx),%edi
107894: be 14 ef 11 00 mov $0x11ef14,%esi
107899: b1 0c mov $0xc,%cl
10789b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
10789d: 80 7d b7 00 cmpb $0x0,-0x49(%ebp)
1078a1: 0f 84 a3 00 00 00 je 10794a <mount+0x195>
1078a7: eb 13 jmp 1078bc <mount+0x107>
target,
filesystemtype,
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
1078a9: e8 1e 98 00 00 call 1110cc <__errno> <== NOT EXECUTED
1078ae: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
1078b4: 83 c8 ff or $0xffffffff,%eax
1078b7: e9 26 01 00 00 jmp 1079e2 <mount+0x22d>
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
1078bc: 83 ec 0c sub $0xc,%esp
1078bf: 6a 01 push $0x1
1078c1: 8d 75 d4 lea -0x2c(%ebp),%esi
1078c4: 56 push %esi
1078c5: 6a 07 push $0x7
1078c7: ff 75 ac pushl -0x54(%ebp)
1078ca: ff 75 0c pushl 0xc(%ebp)
1078cd: e8 a4 f9 ff ff call 107276 <rtems_filesystem_evaluate_path>
1078d2: 83 c4 20 add $0x20,%esp
1078d5: 40 inc %eax
1078d6: 0f 84 df 00 00 00 je 1079bb <mount+0x206> <== NEVER TAKEN
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
1078dc: 83 ec 0c sub $0xc,%esp
1078df: 56 push %esi
1078e0: 8b 45 e0 mov -0x20(%ebp),%eax
1078e3: ff 50 10 call *0x10(%eax)
1078e6: 83 c4 10 add $0x10,%esp
1078e9: 48 dec %eax
1078ea: 74 10 je 1078fc <mount+0x147>
errno = ENOTDIR;
1078ec: e8 db 97 00 00 call 1110cc <__errno>
1078f1: c7 00 14 00 00 00 movl $0x14,(%eax)
goto cleanup_and_bail;
1078f7: e9 c1 00 00 00 jmp 1079bd <mount+0x208>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
1078fc: 57 push %edi
1078fd: 57 push %edi
1078fe: ff 75 d4 pushl -0x2c(%ebp)
107901: 68 2c 77 10 00 push $0x10772c
107906: e8 62 fe ff ff call 10776d <rtems_filesystem_mount_iterate>
10790b: 83 c4 10 add $0x10,%esp
10790e: 84 c0 test %al,%al
107910: 74 10 je 107922 <mount+0x16d>
errno = EBUSY;
107912: e8 b5 97 00 00 call 1110cc <__errno>
107917: c7 00 10 00 00 00 movl $0x10,(%eax)
goto cleanup_and_bail;
10791d: e9 9b 00 00 00 jmp 1079bd <mount+0x208>
* may have been allocated in loc should not be sent to freenode
* until the system is unmounted. It may be needed to correctly
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
107922: 8b 45 d4 mov -0x2c(%ebp),%eax
107925: 89 43 08 mov %eax,0x8(%ebx)
mt_entry->mt_point_node.handlers = loc.handlers;
107928: 8b 45 dc mov -0x24(%ebp),%eax
10792b: 89 43 10 mov %eax,0x10(%ebx)
mt_entry->mt_point_node.ops = loc.ops;
10792e: 8b 45 e0 mov -0x20(%ebp),%eax
107931: 89 43 14 mov %eax,0x14(%ebx)
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
107934: 8b 55 e4 mov -0x1c(%ebp),%edx
107937: 89 53 18 mov %edx,0x18(%ebx)
/*
* This link to the parent is only done when we are dealing with system
* below the base file system
*/
if ( loc.ops->mount_h( mt_entry ) ) {
10793a: 83 ec 0c sub $0xc,%esp
10793d: 53 push %ebx
10793e: ff 50 20 call *0x20(%eax)
107941: 83 c4 10 add $0x10,%esp
107944: 85 c0 test %eax,%eax
107946: 74 1d je 107965 <mount+0x1b0> <== ALWAYS TAKEN
107948: eb 73 jmp 1079bd <mount+0x208> <== NOT EXECUTED
)
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
10794a: 31 f6 xor %esi,%esi
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
10794c: 81 3d 64 2f 12 00 68 cmpl $0x122f68,0x122f64
107953: 2f 12 00
107956: 74 0d je 107965 <mount+0x1b0> <== ALWAYS TAKEN
errno = EINVAL;
107958: e8 6f 97 00 00 call 1110cc <__errno> <== NOT EXECUTED
10795d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
goto cleanup_and_bail;
107963: eb 58 jmp 1079bd <mount+0x208> <== NOT EXECUTED
* mt_point_node.node_access will be left to null to indicate that this
* is the root of the entire file system.
*/
}
if ( (*mount_h)( mt_entry, data ) ) {
107965: 51 push %ecx
107966: 51 push %ecx
107967: ff 75 18 pushl 0x18(%ebp)
10796a: 53 push %ebx
10796b: ff 55 b0 call *-0x50(%ebp)
10796e: 83 c4 10 add $0x10,%esp
107971: 85 c0 test %eax,%eax
107973: 74 0f je 107984 <mount+0x1cf>
/*
* Try to undo the mount operation
*/
loc.ops->unmount_h( mt_entry );
107975: 83 ec 0c sub $0xc,%esp
107978: 53 push %ebx
107979: 8b 45 e0 mov -0x20(%ebp),%eax
10797c: ff 50 28 call *0x28(%eax)
goto cleanup_and_bail;
10797f: 83 c4 10 add $0x10,%esp
107982: eb 39 jmp 1079bd <mount+0x208>
}
/*
* Add the mount table entry to the mount table chain
*/
rtems_libio_lock();
107984: e8 b4 fd ff ff call 10773d <rtems_libio_lock>
107989: 52 push %edx
10798a: 52 push %edx
10798b: 53 push %ebx
10798c: 68 64 2f 12 00 push $0x122f64
107991: e8 4a 30 00 00 call 10a9e0 <_Chain_Append>
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
107996: e8 bc fd ff ff call 107757 <rtems_libio_unlock>
if ( !has_target )
10799b: 83 c4 10 add $0x10,%esp
rtems_filesystem_root = mt_entry->mt_fs_root;
return 0;
10799e: 31 c0 xor %eax,%eax
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
1079a0: 80 7d b7 00 cmpb $0x0,-0x49(%ebp)
1079a4: 75 3c jne 1079e2 <mount+0x22d>
rtems_filesystem_root = mt_entry->mt_fs_root;
1079a6: 8b 3d 80 30 12 00 mov 0x123080,%edi
1079ac: 83 c7 18 add $0x18,%edi
1079af: 8d 73 1c lea 0x1c(%ebx),%esi
1079b2: b9 05 00 00 00 mov $0x5,%ecx
1079b7: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
1079b9: eb 27 jmp 1079e2 <mount+0x22d>
)
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
1079bb: 31 f6 xor %esi,%esi
return 0;
cleanup_and_bail:
free( mt_entry );
1079bd: 83 ec 0c sub $0xc,%esp
1079c0: 53 push %ebx
1079c1: e8 82 f9 ff ff call 107348 <free>
if ( loc_to_free )
1079c6: 83 c4 10 add $0x10,%esp
rtems_filesystem_freenode( loc_to_free );
return -1;
1079c9: 83 c8 ff or $0xffffffff,%eax
cleanup_and_bail:
free( mt_entry );
if ( loc_to_free )
1079cc: 85 f6 test %esi,%esi
1079ce: 74 12 je 1079e2 <mount+0x22d> <== NEVER TAKEN
rtems_filesystem_freenode( loc_to_free );
1079d0: 83 ec 0c sub $0xc,%esp
1079d3: 56 push %esi
1079d4: 89 45 a8 mov %eax,-0x58(%ebp)
1079d7: e8 58 f9 ff ff call 107334 <rtems_filesystem_freenode>
1079dc: 83 c4 10 add $0x10,%esp
1079df: 8b 45 a8 mov -0x58(%ebp),%eax
return -1;
}
1079e2: 8d 65 f4 lea -0xc(%ebp),%esp
1079e5: 5b pop %ebx
1079e6: 5e pop %esi
1079e7: 5f pop %edi
1079e8: c9 leave
1079e9: c3 ret
00107d3c <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
107d3c: 55 push %ebp
107d3d: 89 e5 mov %esp,%ebp
107d3f: 57 push %edi
107d40: 56 push %esi
107d41: 53 push %ebx
107d42: 83 ec 1c sub $0x1c,%esp
107d45: 8b 4d 08 mov 0x8(%ebp),%ecx
107d48: 8b 5d 0c mov 0xc(%ebp),%ebx
107d4b: 8b 75 10 mov 0x10(%ebp),%esi
107d4e: 8b 7d 14 mov 0x14(%ebp),%edi
107d51: 8b 55 18 mov 0x18(%ebp),%edx
int rv = -1;
if (target != NULL) {
107d54: 85 db test %ebx,%ebx
107d56: 74 3b je 107d93 <mount_and_make_target_path+0x57>
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
107d58: 50 push %eax
107d59: 50 push %eax
107d5a: 68 ff 01 00 00 push $0x1ff
107d5f: 53 push %ebx
107d60: 89 55 e0 mov %edx,-0x20(%ebp)
107d63: 89 4d e4 mov %ecx,-0x1c(%ebp)
107d66: e8 bd 08 00 00 call 108628 <rtems_mkdir>
if (rv == 0) {
107d6b: 83 c4 10 add $0x10,%esp
107d6e: 85 c0 test %eax,%eax
107d70: 8b 55 e0 mov -0x20(%ebp),%edx
107d73: 8b 4d e4 mov -0x1c(%ebp),%ecx
107d76: 75 29 jne 107da1 <mount_and_make_target_path+0x65><== NEVER TAKEN
rv = mount(
107d78: 89 55 18 mov %edx,0x18(%ebp)
107d7b: 89 7d 14 mov %edi,0x14(%ebp)
107d7e: 89 75 10 mov %esi,0x10(%ebp)
107d81: 89 5d 0c mov %ebx,0xc(%ebp)
107d84: 89 4d 08 mov %ecx,0x8(%ebp)
} else {
errno = EINVAL;
}
return rv;
}
107d87: 8d 65 f4 lea -0xc(%ebp),%esp
107d8a: 5b pop %ebx
107d8b: 5e pop %esi
107d8c: 5f pop %edi
107d8d: c9 leave
int rv = -1;
if (target != NULL) {
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv == 0) {
rv = mount(
107d8e: e9 a2 00 00 00 jmp 107e35 <mount>
options,
data
);
}
} else {
errno = EINVAL;
107d93: e8 b0 99 00 00 call 111748 <__errno>
107d98: c7 00 16 00 00 00 movl $0x16,(%eax)
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
107d9e: 83 c8 ff or $0xffffffff,%eax
} else {
errno = EINVAL;
}
return rv;
}
107da1: 8d 65 f4 lea -0xc(%ebp),%esp
107da4: 5b pop %ebx
107da5: 5e pop %esi
107da6: 5f pop %edi
107da7: c9 leave
107da8: c3 ret
00107a45 <newlib_create_hook>:
*/
bool newlib_create_hook(
rtems_tcb *current_task __attribute__((unused)),
rtems_tcb *creating_task
)
{
107a45: 55 push %ebp
107a46: 89 e5 mov %esp,%ebp
107a48: 57 push %edi
107a49: 56 push %esi
107a4a: 53 push %ebx
107a4b: 83 ec 1c sub $0x1c,%esp
struct _reent *ptr;
if (_Thread_libc_reent == 0)
107a4e: 83 3d c8 53 12 00 00 cmpl $0x0,0x1253c8
107a55: 75 14 jne 107a6b <newlib_create_hook+0x26>
{
_REENT = _global_impure_ptr;
107a57: a1 c0 f9 11 00 mov 0x11f9c0,%eax
107a5c: a3 40 31 12 00 mov %eax,0x123140
RTEMS_INLINE_ROUTINE void _Thread_Set_libc_reent (
struct _reent **libc_reent
)
{
_Thread_libc_reent = libc_reent;
107a61: c7 05 c8 53 12 00 40 movl $0x123140,0x1253c8
107a68: 31 12 00
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));
107a6b: 83 ec 0c sub $0xc,%esp
107a6e: 68 24 04 00 00 push $0x424
107a73: e8 6e 55 00 00 call 10cfe6 <_Workspace_Allocate>
107a78: 89 c2 mov %eax,%edx
#endif
if (ptr) {
107a7a: 83 c4 10 add $0x10,%esp
_REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */
creating_task->libc_reent = ptr;
return TRUE;
}
return FALSE;
107a7d: 31 c0 xor %eax,%eax
* hooks run with thread dispatching disabled.
*/
ptr = (struct _reent *) _Workspace_Allocate(sizeof(struct _reent));
#endif
if (ptr) {
107a7f: 85 d2 test %edx,%edx
107a81: 0f 84 28 02 00 00 je 107caf <newlib_create_hook+0x26a><== NEVER TAKEN
_REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */
107a87: c7 02 00 00 00 00 movl $0x0,(%edx)
107a8d: 8d b2 ec 02 00 00 lea 0x2ec(%edx),%esi
107a93: 89 72 04 mov %esi,0x4(%edx)
107a96: 8d 8a 54 03 00 00 lea 0x354(%edx),%ecx
107a9c: 89 4a 08 mov %ecx,0x8(%edx)
107a9f: 8d 8a bc 03 00 00 lea 0x3bc(%edx),%ecx
107aa5: 89 4a 0c mov %ecx,0xc(%edx)
107aa8: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx)
107aaf: 8d 4a 14 lea 0x14(%edx),%ecx
107ab2: bb 19 00 00 00 mov $0x19,%ebx
107ab7: 89 cf mov %ecx,%edi
107ab9: 89 d9 mov %ebx,%ecx
107abb: f3 aa rep stos %al,%es:(%edi)
107abd: 89 cb mov %ecx,%ebx
107abf: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx)
107ac6: c7 42 34 66 ec 11 00 movl $0x11ec66,0x34(%edx)
107acd: c7 42 38 00 00 00 00 movl $0x0,0x38(%edx)
107ad4: c7 42 3c 00 00 00 00 movl $0x0,0x3c(%edx)
107adb: c7 42 40 00 00 00 00 movl $0x0,0x40(%edx)
107ae2: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx)
107ae9: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx)
107af0: c7 42 4c 00 00 00 00 movl $0x0,0x4c(%edx)
107af7: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx)
107afe: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx)
107b05: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx)
107b0c: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx)
107b13: c6 42 60 00 movb $0x0,0x60(%edx)
107b17: 8d 42 7c lea 0x7c(%edx),%eax
107b1a: 89 45 e4 mov %eax,-0x1c(%ebp)
107b1d: b1 09 mov $0x9,%cl
107b1f: 89 c7 mov %eax,%edi
107b21: 89 d8 mov %ebx,%eax
107b23: f3 ab rep stos %eax,%es:(%edi)
107b25: c7 82 a0 00 00 00 00 movl $0x0,0xa0(%edx)
107b2c: 00 00 00
107b2f: c7 82 a4 00 00 00 01 movl $0x1,0xa4(%edx)
107b36: 00 00 00
107b39: c7 82 a8 00 00 00 00 movl $0x0,0xa8(%edx)
107b40: 00 00 00
107b43: 66 c7 82 ac 00 00 00 movw $0x330e,0xac(%edx)
107b4a: 0e 33
107b4c: 66 c7 82 ae 00 00 00 movw $0xabcd,0xae(%edx)
107b53: cd ab
107b55: 66 c7 82 b0 00 00 00 movw $0x1234,0xb0(%edx)
107b5c: 34 12
107b5e: 66 c7 82 b2 00 00 00 movw $0xe66d,0xb2(%edx)
107b65: 6d e6
107b67: 66 c7 82 b4 00 00 00 movw $0xdeec,0xb4(%edx)
107b6e: ec de
107b70: 66 c7 82 b6 00 00 00 movw $0x5,0xb6(%edx)
107b77: 05 00
107b79: 66 c7 82 b8 00 00 00 movw $0xb,0xb8(%edx)
107b80: 0b 00
107b82: c7 82 bc 00 00 00 00 movl $0x0,0xbc(%edx)
107b89: 00 00 00
107b8c: c7 82 c0 00 00 00 00 movl $0x0,0xc0(%edx)
107b93: 00 00 00
107b96: c7 82 c4 00 00 00 00 movl $0x0,0xc4(%edx)
107b9d: 00 00 00
107ba0: c7 82 c8 00 00 00 00 movl $0x0,0xc8(%edx)
107ba7: 00 00 00
107baa: c7 82 cc 00 00 00 00 movl $0x0,0xcc(%edx)
107bb1: 00 00 00
107bb4: c7 82 d0 00 00 00 00 movl $0x0,0xd0(%edx)
107bbb: 00 00 00
107bbe: c7 82 f8 00 00 00 00 movl $0x0,0xf8(%edx)
107bc5: 00 00 00
107bc8: c7 82 fc 00 00 00 00 movl $0x0,0xfc(%edx)
107bcf: 00 00 00
107bd2: c7 82 00 01 00 00 00 movl $0x0,0x100(%edx)
107bd9: 00 00 00
107bdc: c7 82 04 01 00 00 00 movl $0x0,0x104(%edx)
107be3: 00 00 00
107be6: c7 82 08 01 00 00 00 movl $0x0,0x108(%edx)
107bed: 00 00 00
107bf0: c7 82 0c 01 00 00 00 movl $0x0,0x10c(%edx)
107bf7: 00 00 00
107bfa: c7 82 10 01 00 00 00 movl $0x0,0x110(%edx)
107c01: 00 00 00
107c04: c7 82 14 01 00 00 00 movl $0x0,0x114(%edx)
107c0b: 00 00 00
107c0e: c7 82 18 01 00 00 00 movl $0x0,0x118(%edx)
107c15: 00 00 00
107c18: c7 82 1c 01 00 00 00 movl $0x0,0x11c(%edx)
107c1f: 00 00 00
107c22: c6 82 d4 00 00 00 00 movb $0x0,0xd4(%edx)
107c29: c6 82 dc 00 00 00 00 movb $0x0,0xdc(%edx)
107c30: c7 82 f4 00 00 00 00 movl $0x0,0xf4(%edx)
107c37: 00 00 00
107c3a: c7 82 48 01 00 00 00 movl $0x0,0x148(%edx)
107c41: 00 00 00
107c44: c7 82 4c 01 00 00 00 movl $0x0,0x14c(%edx)
107c4b: 00 00 00
107c4e: c7 82 50 01 00 00 00 movl $0x0,0x150(%edx)
107c55: 00 00 00
107c58: c7 82 54 01 00 00 00 movl $0x0,0x154(%edx)
107c5f: 00 00 00
107c62: c7 82 d4 02 00 00 00 movl $0x0,0x2d4(%edx)
107c69: 00 00 00
107c6c: c7 82 d4 01 00 00 00 movl $0x0,0x1d4(%edx)
107c73: 00 00 00
107c76: c7 82 dc 02 00 00 00 movl $0x0,0x2dc(%edx)
107c7d: 00 00 00
107c80: c7 82 e0 02 00 00 00 movl $0x0,0x2e0(%edx)
107c87: 00 00 00
107c8a: c7 82 e4 02 00 00 00 movl $0x0,0x2e4(%edx)
107c91: 00 00 00
107c94: c7 82 e8 02 00 00 00 movl $0x0,0x2e8(%edx)
107c9b: 00 00 00
107c9e: b1 4e mov $0x4e,%cl
107ca0: 89 f7 mov %esi,%edi
107ca2: f3 ab rep stos %eax,%es:(%edi)
creating_task->libc_reent = ptr;
107ca4: 8b 45 0c mov 0xc(%ebp),%eax
107ca7: 89 90 e4 00 00 00 mov %edx,0xe4(%eax)
return TRUE;
107cad: b0 01 mov $0x1,%al
}
return FALSE;
}
107caf: 8d 65 f4 lea -0xc(%ebp),%esp
107cb2: 5b pop %ebx
107cb3: 5e pop %esi
107cb4: 5f pop %edi
107cb5: c9 leave
107cb6: c3 ret
00107cb7 <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
107cb7: 55 push %ebp
107cb8: 89 e5 mov %esp,%ebp
107cba: 57 push %edi
107cbb: 56 push %esi
107cbc: 53 push %ebx
107cbd: 83 ec 0c sub $0xc,%esp
107cc0: 8b 7d 08 mov 0x8(%ebp),%edi
107cc3: 8b 75 0c mov 0xc(%ebp),%esi
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
107cc6: 39 f7 cmp %esi,%edi
107cc8: 75 08 jne 107cd2 <newlib_delete_hook+0x1b>
ptr = _REENT;
107cca: 8b 1d 40 31 12 00 mov 0x123140,%ebx
107cd0: eb 06 jmp 107cd8 <newlib_delete_hook+0x21>
} else {
ptr = deleted_task->libc_reent;
107cd2: 8b 9e e4 00 00 00 mov 0xe4(%esi),%ebx
}
if (ptr && ptr != _global_impure_ptr) {
107cd8: 85 db test %ebx,%ebx
107cda: 74 20 je 107cfc <newlib_delete_hook+0x45><== NEVER TAKEN
107cdc: 3b 1d c0 f9 11 00 cmp 0x11f9c0,%ebx
107ce2: 74 18 je 107cfc <newlib_delete_hook+0x45>
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
107ce4: 50 push %eax
107ce5: 50 push %eax
107ce6: 68 f4 79 10 00 push $0x1079f4
107ceb: 53 push %ebx
107cec: e8 c3 9b 00 00 call 1118b4 <_fwalk>
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
107cf1: 89 1c 24 mov %ebx,(%esp)
107cf4: e8 06 53 00 00 call 10cfff <_Workspace_Free>
107cf9: 83 c4 10 add $0x10,%esp
#endif
}
deleted_task->libc_reent = NULL;
107cfc: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi)
107d03: 00 00 00
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
107d06: 39 f7 cmp %esi,%edi
107d08: 75 0a jne 107d14 <newlib_delete_hook+0x5d>
_REENT = 0;
107d0a: c7 05 40 31 12 00 00 movl $0x0,0x123140
107d11: 00 00 00
}
}
107d14: 8d 65 f4 lea -0xc(%ebp),%esp
107d17: 5b pop %ebx
107d18: 5e pop %esi
107d19: 5f pop %edi
107d1a: c9 leave
107d1b: c3 ret
001079f4 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
1079f4: 55 push %ebp
1079f5: 89 e5 mov %esp,%ebp
1079f7: 53 push %ebx
1079f8: 83 ec 10 sub $0x10,%esp
1079fb: 8b 5d 08 mov 0x8(%ebp),%ebx
switch ( fileno(fp) ) {
1079fe: 53 push %ebx
1079ff: e8 9c 9a 00 00 call 1114a0 <fileno>
107a04: 83 c4 10 add $0x10,%esp
107a07: 83 f8 02 cmp $0x2,%eax
107a0a: 77 26 ja 107a32 <newlib_free_buffers+0x3e><== NEVER TAKEN
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
107a0c: f6 43 0c 80 testb $0x80,0xc(%ebx)
107a10: 74 2c je 107a3e <newlib_free_buffers+0x4a><== ALWAYS TAKEN
free( fp->_bf._base );
107a12: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107a15: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
107a18: e8 2b f9 ff ff call 107348 <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
107a1d: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx) <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
107a23: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED
107a29: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED
107a30: eb 09 jmp 107a3b <newlib_free_buffers+0x47><== NOT EXECUTED
}
break;
default:
fclose(fp);
107a32: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107a35: 53 push %ebx <== NOT EXECUTED
107a36: e8 e9 97 00 00 call 111224 <fclose> <== NOT EXECUTED
107a3b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
return 0;
}
107a3e: 31 c0 xor %eax,%eax
107a40: 8b 5d fc mov -0x4(%ebp),%ebx
107a43: c9 leave
107a44: c3 ret
00107d7c <open>:
int open(
const char *pathname,
int flags,
...
)
{
107d7c: 55 push %ebp
107d7d: 89 e5 mov %esp,%ebp
107d7f: 57 push %edi
107d80: 56 push %esi
107d81: 53 push %ebx
107d82: 83 ec 3c sub $0x3c,%esp
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
107d85: 8b 45 0c mov 0xc(%ebp),%eax
107d88: 40 inc %eax
if ( ( status & _FREAD ) == _FREAD )
107d89: 89 c6 mov %eax,%esi
107d8b: 83 e6 01 and $0x1,%esi
eval_flags |= RTEMS_LIBIO_PERMS_READ;
107d8e: f7 de neg %esi
107d90: 83 e6 04 and $0x4,%esi
if ( ( status & _FWRITE ) == _FWRITE )
107d93: a8 02 test $0x2,%al
107d95: 74 03 je 107d9a <open+0x1e>
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
107d97: 83 ce 02 or $0x2,%esi
va_start(ap, flags);
mode = va_arg( ap, int );
107d9a: 8b 45 10 mov 0x10(%ebp),%eax
107d9d: 89 45 c4 mov %eax,-0x3c(%ebp)
* code does not require changes here since network file
* descriptors are obtained using socket(), not open().
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
107da0: e8 86 64 00 00 call 10e22b <rtems_libio_allocate>
107da5: 89 c3 mov %eax,%ebx
if ( iop == 0 ) {
107da7: 85 c0 test %eax,%eax
107da9: 0f 84 56 01 00 00 je 107f05 <open+0x189>
}
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
107daf: 83 c9 ff or $0xffffffff,%ecx
107db2: 8b 7d 08 mov 0x8(%ebp),%edi
107db5: 31 c0 xor %eax,%eax
107db7: f2 ae repnz scas %es:(%edi),%al
107db9: f7 d1 not %ecx
107dbb: 49 dec %ecx
107dbc: 83 ec 0c sub $0xc,%esp
107dbf: 6a 01 push $0x1
107dc1: 8d 45 d4 lea -0x2c(%ebp),%eax
107dc4: 50 push %eax
107dc5: 56 push %esi
107dc6: 51 push %ecx
107dc7: ff 75 08 pushl 0x8(%ebp)
107dca: e8 a7 f4 ff ff call 107276 <rtems_filesystem_evaluate_path>
107dcf: 89 c6 mov %eax,%esi
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
107dd1: 83 c4 20 add $0x20,%esp
107dd4: 83 f8 ff cmp $0xffffffff,%eax
107dd7: 75 6c jne 107e45 <open+0xc9>
if ( errno != ENOENT ) {
107dd9: e8 ee 92 00 00 call 1110cc <__errno>
107dde: 83 38 02 cmpl $0x2,(%eax)
107de1: 75 27 jne 107e0a <open+0x8e>
rc = errno;
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
107de3: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
107dea: 0f 84 1c 01 00 00 je 107f0c <open+0x190>
rc = ENOENT;
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
107df0: 6a 00 push $0x0
107df2: 6a 00 push $0x0
107df4: 8b 45 c4 mov -0x3c(%ebp),%eax
107df7: 80 cc 80 or $0x80,%ah
107dfa: 50 push %eax
107dfb: ff 75 08 pushl 0x8(%ebp)
107dfe: e8 99 f8 ff ff call 10769c <mknod>
if ( rc ) {
107e03: 83 c4 10 add $0x10,%esp
107e06: 85 c0 test %eax,%eax
107e08: 74 0e je 107e18 <open+0x9c> <== ALWAYS TAKEN
rc = errno;
107e0a: e8 bd 92 00 00 call 1110cc <__errno>
107e0f: 8b 30 mov (%eax),%esi
int mode;
int rc;
rtems_libio_t *iop = 0;
int status;
rtems_filesystem_location_info_t loc;
rtems_filesystem_location_info_t *loc_to_free = NULL;
107e11: 31 ff xor %edi,%edi
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
if ( rc ) {
rc = errno;
goto done;
107e13: e9 10 01 00 00 jmp 107f28 <open+0x1ac>
/*
* After we do the mknod(), we have to evaluate the path to get the
* "loc" structure needed to actually have the file itself open.
* So we created it, and then we need to have "look it up."
*/
status = rtems_filesystem_evaluate_path(
107e18: 89 f1 mov %esi,%ecx
107e1a: 8b 7d 08 mov 0x8(%ebp),%edi
107e1d: 31 c0 xor %eax,%eax
107e1f: f2 ae repnz scas %es:(%edi),%al
107e21: f7 d1 not %ecx
107e23: 49 dec %ecx
107e24: 83 ec 0c sub $0xc,%esp
107e27: 6a 01 push $0x1
107e29: 8d 45 d4 lea -0x2c(%ebp),%eax
107e2c: 50 push %eax
107e2d: 6a 00 push $0x0
107e2f: 51 push %ecx
107e30: ff 75 08 pushl 0x8(%ebp)
107e33: e8 3e f4 ff ff call 107276 <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
107e38: 83 c4 20 add $0x20,%esp
107e3b: 85 c0 test %eax,%eax
107e3d: 0f 85 d2 00 00 00 jne 107f15 <open+0x199> <== NEVER TAKEN
107e43: eb 13 jmp 107e58 <open+0xdc>
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
107e45: 8b 45 0c mov 0xc(%ebp),%eax
107e48: 25 00 0a 00 00 and $0xa00,%eax
107e4d: 3d 00 0a 00 00 cmp $0xa00,%eax
107e52: 0f 84 c6 00 00 00 je 107f1e <open+0x1a2> <== NEVER TAKEN
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
107e58: 8b 73 14 mov 0x14(%ebx),%esi
107e5b: 83 ec 0c sub $0xc,%esp
107e5e: ff 75 0c pushl 0xc(%ebp)
107e61: e8 52 63 00 00 call 10e1b8 <rtems_libio_fcntl_flags>
107e66: 09 f0 or %esi,%eax
107e68: 89 43 14 mov %eax,0x14(%ebx)
iop->pathinfo = loc;
107e6b: 8d 7b 18 lea 0x18(%ebx),%edi
107e6e: 8d 75 d4 lea -0x2c(%ebp),%esi
107e71: b9 05 00 00 00 mov $0x5,%ecx
107e76: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
107e78: 8b 43 20 mov 0x20(%ebx),%eax
107e7b: ff 75 c4 pushl -0x3c(%ebp)
107e7e: ff 75 0c pushl 0xc(%ebp)
107e81: ff 75 08 pushl 0x8(%ebp)
107e84: 53 push %ebx
107e85: ff 10 call *(%eax)
if ( rc ) {
107e87: 83 c4 20 add $0x20,%esp
107e8a: 85 c0 test %eax,%eax
107e8c: 74 0f je 107e9d <open+0x121>
rc = errno;
107e8e: e8 39 92 00 00 call 1110cc <__errno>
107e93: 8b 30 mov (%eax),%esi
rc = EEXIST;
loc_to_free = &loc;
goto done;
}
loc_to_free = &loc;
107e95: 8d 7d d4 lea -0x2c(%ebp),%edi
iop->pathinfo = loc;
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
if ( rc ) {
rc = errno;
goto done;
107e98: e9 8b 00 00 00 jmp 107f28 <open+0x1ac>
}
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
107e9d: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
107ea4: 0f 84 ae 00 00 00 je 107f58 <open+0x1dc>
rc = ftruncate( iop - rtems_libio_iops, 0 );
107eaa: 50 push %eax
107eab: 6a 00 push $0x0
107ead: 6a 00 push $0x0
107eaf: 89 d8 mov %ebx,%eax
107eb1: 2b 05 f8 51 12 00 sub 0x1251f8,%eax
107eb7: c1 f8 03 sar $0x3,%eax
107eba: 69 c0 b7 6d db b6 imul $0xb6db6db7,%eax,%eax
107ec0: 50 push %eax
107ec1: e8 0a 62 00 00 call 10e0d0 <ftruncate>
107ec6: 89 c6 mov %eax,%esi
if ( rc ) {
107ec8: 83 c4 10 add $0x10,%esp
107ecb: 85 c0 test %eax,%eax
107ecd: 0f 84 85 00 00 00 je 107f58 <open+0x1dc>
if(errno) rc = errno;
107ed3: e8 f4 91 00 00 call 1110cc <__errno>
107ed8: 83 38 00 cmpl $0x0,(%eax)
107edb: 74 07 je 107ee4 <open+0x168> <== NEVER TAKEN
107edd: e8 ea 91 00 00 call 1110cc <__errno>
107ee2: 8b 30 mov (%eax),%esi
close( iop - rtems_libio_iops );
107ee4: 83 ec 0c sub $0xc,%esp
107ee7: 2b 1d f8 51 12 00 sub 0x1251f8,%ebx
107eed: c1 fb 03 sar $0x3,%ebx
107ef0: 69 db b7 6d db b6 imul $0xb6db6db7,%ebx,%ebx
107ef6: 53 push %ebx
107ef7: e8 64 61 00 00 call 10e060 <close>
107efc: 83 c4 10 add $0x10,%esp
/* those are released by close(): */
iop = 0;
loc_to_free = NULL;
107eff: 31 ff xor %edi,%edi
rc = ftruncate( iop - rtems_libio_iops, 0 );
if ( rc ) {
if(errno) rc = errno;
close( iop - rtems_libio_iops );
/* those are released by close(): */
iop = 0;
107f01: 31 db xor %ebx,%ebx
107f03: eb 23 jmp 107f28 <open+0x1ac>
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
if ( iop == 0 ) {
rc = ENFILE;
107f05: be 17 00 00 00 mov $0x17,%esi
107f0a: eb 40 jmp 107f4c <open+0x1d0>
int mode;
int rc;
rtems_libio_t *iop = 0;
int status;
rtems_filesystem_location_info_t loc;
rtems_filesystem_location_info_t *loc_to_free = NULL;
107f0c: 31 ff xor %edi,%edi
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
rc = ENOENT;
107f0e: be 02 00 00 00 mov $0x2,%esi
107f13: eb 17 jmp 107f2c <open+0x1b0>
int mode;
int rc;
rtems_libio_t *iop = 0;
int status;
rtems_filesystem_location_info_t loc;
rtems_filesystem_location_info_t *loc_to_free = NULL;
107f15: 31 ff xor %edi,%edi <== NOT EXECUTED
* So we created it, and then we need to have "look it up."
*/
status = rtems_filesystem_evaluate_path(
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
107f17: be 0d 00 00 00 mov $0xd,%esi <== NOT EXECUTED
107f1c: eb 0e jmp 107f2c <open+0x1b0> <== NOT EXECUTED
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
/* We were trying to create a file that already exists */
rc = EEXIST;
loc_to_free = &loc;
107f1e: 8d 7d d4 lea -0x2c(%ebp),%edi
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
/* We were trying to create a file that already exists */
rc = EEXIST;
107f21: be 11 00 00 00 mov $0x11,%esi
107f26: eb 04 jmp 107f2c <open+0x1b0>
* Single exit and clean up path.
*/
done:
va_end(ap);
if ( rc ) {
107f28: 85 f6 test %esi,%esi
107f2a: 74 2c je 107f58 <open+0x1dc> <== NEVER TAKEN
if ( iop )
107f2c: 85 db test %ebx,%ebx
107f2e: 74 0c je 107f3c <open+0x1c0>
rtems_libio_free( iop );
107f30: 83 ec 0c sub $0xc,%esp
107f33: 53 push %ebx
107f34: e8 6b 63 00 00 call 10e2a4 <rtems_libio_free>
107f39: 83 c4 10 add $0x10,%esp
if ( loc_to_free )
107f3c: 85 ff test %edi,%edi
107f3e: 74 0c je 107f4c <open+0x1d0>
rtems_filesystem_freenode( loc_to_free );
107f40: 83 ec 0c sub $0xc,%esp
107f43: 57 push %edi
107f44: e8 eb f3 ff ff call 107334 <rtems_filesystem_freenode>
107f49: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( rc );
107f4c: e8 7b 91 00 00 call 1110cc <__errno>
107f51: 89 30 mov %esi,(%eax)
107f53: 83 c8 ff or $0xffffffff,%eax
107f56: eb 0f jmp 107f67 <open+0x1eb>
}
return iop - rtems_libio_iops;
107f58: 2b 1d f8 51 12 00 sub 0x1251f8,%ebx
107f5e: c1 fb 03 sar $0x3,%ebx
107f61: 69 c3 b7 6d db b6 imul $0xb6db6db7,%ebx,%eax
}
107f67: 8d 65 f4 lea -0xc(%ebp),%esp
107f6a: 5b pop %ebx
107f6b: 5e pop %esi
107f6c: 5f pop %edi
107f6d: c9 leave
107f6e: c3 ret
00108b1e <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
108b1e: 55 push %ebp
108b1f: 89 e5 mov %esp,%ebp
108b21: 56 push %esi
108b22: 53 push %ebx
108b23: 83 ec 10 sub $0x10,%esp
108b26: 89 d3 mov %edx,%ebx
108b28: 88 45 f4 mov %al,-0xc(%ebp)
int i;
if (tty->termios.c_oflag & OPOST) {
108b2b: 8b 52 34 mov 0x34(%edx),%edx
108b2e: f6 c2 01 test $0x1,%dl
108b31: 0f 84 ed 00 00 00 je 108c24 <oproc+0x106> <== NEVER TAKEN
switch (c) {
108b37: 3c 09 cmp $0x9,%al
108b39: 74 75 je 108bb0 <oproc+0x92>
108b3b: 77 0d ja 108b4a <oproc+0x2c> <== ALWAYS TAKEN
108b3d: 3c 08 cmp $0x8,%al <== NOT EXECUTED
108b3f: 0f 85 aa 00 00 00 jne 108bef <oproc+0xd1> <== NOT EXECUTED
108b45: e9 98 00 00 00 jmp 108be2 <oproc+0xc4> <== NOT EXECUTED
108b4a: 3c 0a cmp $0xa,%al
108b4c: 74 0a je 108b58 <oproc+0x3a>
108b4e: 3c 0d cmp $0xd,%al
108b50: 0f 85 99 00 00 00 jne 108bef <oproc+0xd1> <== ALWAYS TAKEN
108b56: eb 32 jmp 108b8a <oproc+0x6c> <== NOT EXECUTED
case '\n':
if (tty->termios.c_oflag & ONLRET)
108b58: f6 c2 20 test $0x20,%dl
108b5b: 74 07 je 108b64 <oproc+0x46> <== ALWAYS TAKEN
tty->column = 0;
108b5d: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLCR) {
108b64: 80 e2 04 and $0x4,%dl
108b67: 0f 84 b7 00 00 00 je 108c24 <oproc+0x106> <== NEVER TAKEN
rtems_termios_puts ("\r", 1, tty);
108b6d: 56 push %esi
108b6e: 53 push %ebx
108b6f: 6a 01 push $0x1
108b71: 68 b8 ef 11 00 push $0x11efb8
108b76: e8 83 fe ff ff call 1089fe <rtems_termios_puts>
tty->column = 0;
108b7b: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx)
108b82: 83 c4 10 add $0x10,%esp
108b85: e9 9a 00 00 00 jmp 108c24 <oproc+0x106>
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
108b8a: f6 c2 10 test $0x10,%dl <== NOT EXECUTED
108b8d: 74 0a je 108b99 <oproc+0x7b> <== NOT EXECUTED
108b8f: 83 7b 28 00 cmpl $0x0,0x28(%ebx) <== NOT EXECUTED
108b93: 0f 84 9b 00 00 00 je 108c34 <oproc+0x116> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
108b99: f6 c2 08 test $0x8,%dl <== NOT EXECUTED
108b9c: 74 09 je 108ba7 <oproc+0x89> <== NOT EXECUTED
c = '\n';
108b9e: c6 45 f4 0a movb $0xa,-0xc(%ebp) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
108ba2: 80 e2 20 and $0x20,%dl <== NOT EXECUTED
108ba5: 74 7d je 108c24 <oproc+0x106> <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
108ba7: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED
break;
108bae: eb 74 jmp 108c24 <oproc+0x106> <== NOT EXECUTED
case '\t':
i = 8 - (tty->column & 7);
108bb0: 8b 4b 28 mov 0x28(%ebx),%ecx
108bb3: 89 ce mov %ecx,%esi
108bb5: 83 e6 07 and $0x7,%esi
108bb8: b8 08 00 00 00 mov $0x8,%eax
108bbd: 29 f0 sub %esi,%eax
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
108bbf: 81 e2 00 18 00 00 and $0x1800,%edx
108bc5: 81 fa 00 18 00 00 cmp $0x1800,%edx
108bcb: 8d 14 08 lea (%eax,%ecx,1),%edx
108bce: 75 0d jne 108bdd <oproc+0xbf> <== NEVER TAKEN
tty->column += i;
108bd0: 89 53 28 mov %edx,0x28(%ebx)
rtems_termios_puts ( " ", i, tty);
108bd3: 51 push %ecx
108bd4: 53 push %ebx
108bd5: 50 push %eax
108bd6: 68 78 eb 11 00 push $0x11eb78
108bdb: eb 4f jmp 108c2c <oproc+0x10e>
return;
}
tty->column += i;
108bdd: 89 53 28 mov %edx,0x28(%ebx) <== NOT EXECUTED
break;
108be0: eb 42 jmp 108c24 <oproc+0x106> <== NOT EXECUTED
case '\b':
if (tty->column > 0)
108be2: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED
108be5: 85 c0 test %eax,%eax <== NOT EXECUTED
108be7: 7e 3b jle 108c24 <oproc+0x106> <== NOT EXECUTED
tty->column--;
108be9: 48 dec %eax <== NOT EXECUTED
108bea: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED
108bed: eb 35 jmp 108c24 <oproc+0x106> <== NOT EXECUTED
break;
default:
if (tty->termios.c_oflag & OLCUC)
108bef: 80 e2 02 and $0x2,%dl
108bf2: 74 1c je 108c10 <oproc+0xf2> <== ALWAYS TAKEN
c = toupper(c);
108bf4: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
108bf7: 8b 15 3c 31 12 00 mov 0x12313c,%edx <== NOT EXECUTED
108bfd: 0f be 54 02 01 movsbl 0x1(%edx,%eax,1),%edx <== NOT EXECUTED
108c02: 83 e2 03 and $0x3,%edx <== NOT EXECUTED
108c05: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED
108c08: 75 03 jne 108c0d <oproc+0xef> <== NOT EXECUTED
108c0a: 83 e8 20 sub $0x20,%eax <== NOT EXECUTED
108c0d: 88 45 f4 mov %al,-0xc(%ebp) <== NOT EXECUTED
if (!iscntrl(c))
108c10: 0f b6 45 f4 movzbl -0xc(%ebp),%eax
108c14: 8b 15 3c 31 12 00 mov 0x12313c,%edx
108c1a: f6 44 02 01 20 testb $0x20,0x1(%edx,%eax,1)
108c1f: 75 03 jne 108c24 <oproc+0x106> <== NEVER TAKEN
tty->column++;
108c21: ff 43 28 incl 0x28(%ebx)
break;
}
}
rtems_termios_puts (&c, 1, tty);
108c24: 52 push %edx
108c25: 53 push %ebx
108c26: 6a 01 push $0x1
108c28: 8d 45 f4 lea -0xc(%ebp),%eax
108c2b: 50 push %eax
108c2c: e8 cd fd ff ff call 1089fe <rtems_termios_puts>
108c31: 83 c4 10 add $0x10,%esp
}
108c34: 8d 65 f8 lea -0x8(%ebp),%esp
108c37: 5b pop %ebx
108c38: 5e pop %esi
108c39: c9 leave
108c3a: c3 ret
00108ff0 <pipe>:
extern int pipe_create(int filsdes[2]);
int pipe(
int filsdes[2]
)
{
108ff0: 55 push %ebp
108ff1: 89 e5 mov %esp,%ebp
108ff3: 83 ec 08 sub $0x8,%esp
108ff6: 8b 45 08 mov 0x8(%ebp),%eax
if (filsdes == NULL)
108ff9: 85 c0 test %eax,%eax
108ffb: 75 10 jne 10900d <pipe+0x1d> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EFAULT );
108ffd: e8 22 99 00 00 call 112924 <__errno>
109002: c7 00 0e 00 00 00 movl $0xe,(%eax)
return pipe_create(filsdes);
}
109008: 83 c8 ff or $0xffffffff,%eax
10900b: c9 leave
10900c: c3 ret
)
{
if (filsdes == NULL)
rtems_set_errno_and_return_minus_one( EFAULT );
return pipe_create(filsdes);
10900d: 89 45 08 mov %eax,0x8(%ebp)
}
109010: c9 leave
)
{
if (filsdes == NULL)
rtems_set_errno_and_return_minus_one( EFAULT );
return pipe_create(filsdes);
109011: e9 e6 5e 00 00 jmp 10eefc <pipe_create>
0010eefc <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
10eefc: 55 push %ebp
10eefd: 89 e5 mov %esp,%ebp
10eeff: 57 push %edi
10ef00: 56 push %esi
10ef01: 53 push %ebx
10ef02: 83 ec 34 sub $0x34,%esp
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
10ef05: 68 ff 01 00 00 push $0x1ff
10ef0a: 68 50 0d 12 00 push $0x120d50
10ef0f: e8 58 14 00 00 call 11036c <rtems_mkdir>
10ef14: 83 c4 10 add $0x10,%esp
return -1;
10ef17: c7 45 d4 ff ff ff ff movl $0xffffffff,-0x2c(%ebp)
)
{
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
10ef1e: 85 c0 test %eax,%eax
10ef20: 0f 85 e8 00 00 00 jne 10f00e <pipe_create+0x112> <== NEVER TAKEN
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
10ef26: 8d 5d d9 lea -0x27(%ebp),%ebx
10ef29: be 55 0d 12 00 mov $0x120d55,%esi
10ef2e: b9 0a 00 00 00 mov $0xa,%ecx
10ef33: 89 df mov %ebx,%edi
10ef35: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
10ef37: 0f b7 05 20 60 12 00 movzwl 0x126020,%eax
10ef3e: 8d 50 01 lea 0x1(%eax),%edx
10ef41: 66 89 15 20 60 12 00 mov %dx,0x126020
10ef48: 57 push %edi
10ef49: 50 push %eax
10ef4a: 68 60 0d 12 00 push $0x120d60
10ef4f: 8d 45 e3 lea -0x1d(%ebp),%eax
10ef52: 50 push %eax
10ef53: e8 b8 43 00 00 call 113310 <sprintf>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
10ef58: 59 pop %ecx
10ef59: 5e pop %esi
10ef5a: 68 80 01 00 00 push $0x180
10ef5f: 53 push %ebx
10ef60: e8 c7 11 00 00 call 11012c <mkfifo>
10ef65: 83 c4 10 add $0x10,%esp
10ef68: 85 c0 test %eax,%eax
10ef6a: 74 0a je 10ef76 <pipe_create+0x7a>
if (errno != EEXIST){
10ef6c: e8 b3 39 00 00 call 112924 <__errno>
10ef71: e9 98 00 00 00 jmp 10f00e <pipe_create+0x112>
return -1;
/* sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); */
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
10ef76: 52 push %edx
10ef77: 52 push %edx
10ef78: 68 00 40 00 00 push $0x4000
10ef7d: 53 push %ebx
10ef7e: e8 59 9e ff ff call 108ddc <open>
10ef83: 8b 55 08 mov 0x8(%ebp),%edx
10ef86: 89 02 mov %eax,(%edx)
if (filsdes[0] < 0) {
10ef88: 83 c4 10 add $0x10,%esp
10ef8b: 85 c0 test %eax,%eax
10ef8d: 79 0d jns 10ef9c <pipe_create+0xa0>
err = errno;
10ef8f: e8 90 39 00 00 call 112924 <__errno>
10ef94: 8b 30 mov (%eax),%esi
/* Delete file at errors, or else if pipe is successfully created
the file node will be deleted after it is closed by all. */
unlink(fifopath);
10ef96: 83 ec 0c sub $0xc,%esp
10ef99: 53 push %ebx
10ef9a: eb 51 jmp 10efed <pipe_create+0xf1>
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
10ef9c: 31 d2 xor %edx,%edx
10ef9e: 3b 05 44 21 12 00 cmp 0x122144,%eax
10efa4: 73 09 jae 10efaf <pipe_create+0xb3> <== NEVER TAKEN
10efa6: 6b d0 38 imul $0x38,%eax,%edx
10efa9: 03 15 20 62 12 00 add 0x126220,%edx
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
10efaf: 83 62 14 fe andl $0xfffffffe,0x14(%edx)
filsdes[1] = open(fifopath, O_WRONLY);
10efb3: 50 push %eax
10efb4: 50 push %eax
10efb5: 6a 01 push $0x1
10efb7: 8d 45 d9 lea -0x27(%ebp),%eax
10efba: 50 push %eax
10efbb: e8 1c 9e ff ff call 108ddc <open>
10efc0: 8b 55 08 mov 0x8(%ebp),%edx
10efc3: 89 42 04 mov %eax,0x4(%edx)
if (filsdes[1] < 0) {
10efc6: 83 c4 10 add $0x10,%esp
int pipe_create(
int filsdes[2]
)
{
rtems_libio_t *iop;
int err = 0;
10efc9: 31 f6 xor %esi,%esi
iop = rtems_libio_iop(filsdes[0]);
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
if (filsdes[1] < 0) {
10efcb: 85 c0 test %eax,%eax
10efcd: 79 17 jns 10efe6 <pipe_create+0xea>
err = errno;
10efcf: e8 50 39 00 00 call 112924 <__errno>
10efd4: 8b 30 mov (%eax),%esi
close(filsdes[0]);
10efd6: 83 ec 0c sub $0xc,%esp
10efd9: 8b 45 08 mov 0x8(%ebp),%eax
10efdc: ff 30 pushl (%eax)
10efde: e8 01 90 ff ff call 107fe4 <close>
10efe3: 83 c4 10 add $0x10,%esp
}
unlink(fifopath);
10efe6: 83 ec 0c sub $0xc,%esp
10efe9: 8d 45 d9 lea -0x27(%ebp),%eax
10efec: 50 push %eax
10efed: e8 86 b9 ff ff call 10a978 <unlink>
10eff2: 83 c4 10 add $0x10,%esp
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
10eff5: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
10effc: 85 f6 test %esi,%esi
10effe: 74 0e je 10f00e <pipe_create+0x112>
rtems_set_errno_and_return_minus_one(err);
10f000: e8 1f 39 00 00 call 112924 <__errno>
10f005: 89 30 mov %esi,(%eax)
10f007: c7 45 d4 ff ff ff ff movl $0xffffffff,-0x2c(%ebp)
return 0;
}
10f00e: 8b 45 d4 mov -0x2c(%ebp),%eax
10f011: 8d 65 f4 lea -0xc(%ebp),%esp
10f014: 5b pop %ebx
10f015: 5e pop %esi
10f016: 5f pop %edi
10f017: c9 leave
10f018: c3 ret
001101fb <pipe_ioctl>:
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
1101fb: 55 push %ebp
1101fc: 89 e5 mov %esp,%ebp
1101fe: 56 push %esi
1101ff: 53 push %ebx
110200: 8b 5d 08 mov 0x8(%ebp),%ebx
110203: 8b 75 10 mov 0x10(%ebp),%esi
*(unsigned int *)buffer = pipe->Length;
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
110206: b8 ea ff ff ff mov $0xffffffea,%eax
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
11020b: 81 7d 0c 7f 66 04 40 cmpl $0x4004667f,0xc(%ebp)
110212: 75 36 jne 11024a <pipe_ioctl+0x4f>
if (buffer == NULL)
return -EFAULT;
110214: b0 f2 mov $0xf2,%al
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
110216: 85 f6 test %esi,%esi
110218: 74 30 je 11024a <pipe_ioctl+0x4f>
return -EFAULT;
if (! PIPE_LOCK(pipe))
11021a: 51 push %ecx
11021b: 6a 00 push $0x0
11021d: 6a 00 push $0x0
11021f: ff 73 28 pushl 0x28(%ebx)
110222: e8 e5 b9 ff ff call 10bc0c <rtems_semaphore_obtain>
110227: 89 c2 mov %eax,%edx
110229: 83 c4 10 add $0x10,%esp
return -EINTR;
11022c: b8 fc ff ff ff mov $0xfffffffc,%eax
{
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
if (! PIPE_LOCK(pipe))
110231: 85 d2 test %edx,%edx
110233: 75 15 jne 11024a <pipe_ioctl+0x4f> <== NEVER TAKEN
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
110235: 8b 43 0c mov 0xc(%ebx),%eax
110238: 89 06 mov %eax,(%esi)
PIPE_UNLOCK(pipe);
11023a: 83 ec 0c sub $0xc,%esp
11023d: ff 73 28 pushl 0x28(%ebx)
110240: e8 b3 ba ff ff call 10bcf8 <rtems_semaphore_release>
return 0;
110245: 83 c4 10 add $0x10,%esp
110248: 31 c0 xor %eax,%eax
}
return -EINVAL;
}
11024a: 8d 65 f8 lea -0x8(%ebp),%esp
11024d: 5b pop %ebx
11024e: 5e pop %esi
11024f: c9 leave
110250: c3 ret
0010feec <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
10feec: 55 push %ebp
10feed: 89 e5 mov %esp,%ebp
10feef: 57 push %edi
10fef0: 56 push %esi
10fef1: 53 push %ebx
10fef2: 83 ec 30 sub $0x30,%esp
10fef5: 8b 5d 08 mov 0x8(%ebp),%ebx
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
10fef8: 6a 00 push $0x0
10fefa: 6a 00 push $0x0
10fefc: ff 73 28 pushl 0x28(%ebx)
10feff: e8 08 bd ff ff call 10bc0c <rtems_semaphore_obtain>
10ff04: 83 c4 10 add $0x10,%esp
return -EINTR;
10ff07: be fc ff ff ff mov $0xfffffffc,%esi
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
10ff0c: 85 c0 test %eax,%eax
10ff0e: 0f 85 2f 01 00 00 jne 110043 <pipe_read+0x157> <== NEVER TAKEN
10ff14: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
10ff1b: e9 f0 00 00 00 jmp 110010 <pipe_read+0x124>
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
10ff20: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10ff24: 0f 84 f2 00 00 00 je 11001c <pipe_read+0x130>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
10ff2a: 8b 45 14 mov 0x14(%ebp),%eax
10ff2d: f6 40 14 01 testb $0x1,0x14(%eax)
10ff31: 0f 85 e9 00 00 00 jne 110020 <pipe_read+0x134>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
10ff37: ff 43 18 incl 0x18(%ebx)
PIPE_UNLOCK(pipe);
10ff3a: 83 ec 0c sub $0xc,%esp
10ff3d: ff 73 28 pushl 0x28(%ebx)
10ff40: e8 b3 bd ff ff call 10bcf8 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
10ff45: 5f pop %edi
10ff46: 58 pop %eax
10ff47: 6a 00 push $0x0
10ff49: ff 73 2c pushl 0x2c(%ebx)
10ff4c: e8 9f 16 00 00 call 1115f0 <rtems_barrier_wait>
10ff51: 83 c4 0c add $0xc,%esp
10ff54: 83 f8 01 cmp $0x1,%eax
10ff57: 19 f6 sbb %esi,%esi
10ff59: f7 d6 not %esi
10ff5b: 83 e6 fc and $0xfffffffc,%esi
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
10ff5e: 6a 00 push $0x0
10ff60: 6a 00 push $0x0
10ff62: ff 73 28 pushl 0x28(%ebx)
10ff65: e8 a2 bc ff ff call 10bc0c <rtems_semaphore_obtain>
10ff6a: 83 c4 10 add $0x10,%esp
10ff6d: 85 c0 test %eax,%eax
10ff6f: 0f 85 c0 00 00 00 jne 110035 <pipe_read+0x149> <== NEVER TAKEN
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
10ff75: ff 4b 18 decl 0x18(%ebx)
if (ret != 0)
10ff78: 85 f6 test %esi,%esi
10ff7a: 0f 85 a5 00 00 00 jne 110025 <pipe_read+0x139> <== NEVER TAKEN
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
10ff80: 8b 53 0c mov 0xc(%ebx),%edx
10ff83: 85 d2 test %edx,%edx
10ff85: 74 99 je 10ff20 <pipe_read+0x34>
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
10ff87: 8b 45 10 mov 0x10(%ebp),%eax
10ff8a: 2b 45 d0 sub -0x30(%ebp),%eax
10ff8d: 89 55 d4 mov %edx,-0x2c(%ebp)
10ff90: 39 c2 cmp %eax,%edx
10ff92: 76 03 jbe 10ff97 <pipe_read+0xab>
10ff94: 89 45 d4 mov %eax,-0x2c(%ebp)
chunk1 = pipe->Size - pipe->Start;
10ff97: 8b 73 08 mov 0x8(%ebx),%esi
10ff9a: 8b 43 04 mov 0x4(%ebx),%eax
10ff9d: 29 f0 sub %esi,%eax
if (chunk > chunk1) {
10ff9f: 39 45 d4 cmp %eax,-0x2c(%ebp)
10ffa2: 8b 7d 0c mov 0xc(%ebp),%edi
10ffa5: 8b 4d d0 mov -0x30(%ebp),%ecx
10ffa8: 8d 14 0f lea (%edi,%ecx,1),%edx
10ffab: 7e 1b jle 10ffc8 <pipe_read+0xdc>
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
10ffad: 03 33 add (%ebx),%esi
10ffaf: 89 d7 mov %edx,%edi
10ffb1: 89 c1 mov %eax,%ecx
10ffb3: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
10ffb5: 8b 55 d0 mov -0x30(%ebp),%edx
10ffb8: 01 c2 add %eax,%edx
10ffba: 03 55 0c add 0xc(%ebp),%edx
10ffbd: 8b 4d d4 mov -0x2c(%ebp),%ecx
10ffc0: 29 c1 sub %eax,%ecx
10ffc2: 8b 33 mov (%ebx),%esi
10ffc4: 89 d7 mov %edx,%edi
10ffc6: eb 07 jmp 10ffcf <pipe_read+0xe3>
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
10ffc8: 03 33 add (%ebx),%esi
10ffca: 89 d7 mov %edx,%edi
10ffcc: 8b 4d d4 mov -0x2c(%ebp),%ecx
10ffcf: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
pipe->Start += chunk;
10ffd1: 8b 45 d4 mov -0x2c(%ebp),%eax
10ffd4: 03 43 08 add 0x8(%ebx),%eax
pipe->Start %= pipe->Size;
10ffd7: 31 d2 xor %edx,%edx
10ffd9: f7 73 04 divl 0x4(%ebx)
10ffdc: 89 53 08 mov %edx,0x8(%ebx)
pipe->Length -= chunk;
10ffdf: 8b 43 0c mov 0xc(%ebx),%eax
10ffe2: 2b 45 d4 sub -0x2c(%ebp),%eax
10ffe5: 89 43 0c mov %eax,0xc(%ebx)
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
10ffe8: 85 c0 test %eax,%eax
10ffea: 75 07 jne 10fff3 <pipe_read+0x107>
pipe->Start = 0;
10ffec: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
if (pipe->waitingWriters > 0)
10fff3: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx)
10fff7: 74 11 je 11000a <pipe_read+0x11e>
PIPE_WAKEUPWRITERS(pipe);
10fff9: 56 push %esi
10fffa: 56 push %esi
10fffb: 8d 45 e4 lea -0x1c(%ebp),%eax
10fffe: 50 push %eax
10ffff: ff 73 30 pushl 0x30(%ebx)
110002: e8 91 15 00 00 call 111598 <rtems_barrier_release>
110007: 83 c4 10 add $0x10,%esp
read += chunk;
11000a: 8b 4d d4 mov -0x2c(%ebp),%ecx
11000d: 01 4d d0 add %ecx,-0x30(%ebp)
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
110010: 8b 7d 10 mov 0x10(%ebp),%edi
110013: 39 7d d0 cmp %edi,-0x30(%ebp)
110016: 0f 82 64 ff ff ff jb 10ff80 <pipe_read+0x94>
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
11001c: 31 f6 xor %esi,%esi
11001e: eb 05 jmp 110025 <pipe_read+0x139>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
110020: be f5 ff ff ff mov $0xfffffff5,%esi
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
110025: 83 ec 0c sub $0xc,%esp
110028: ff 73 28 pushl 0x28(%ebx)
11002b: e8 c8 bc ff ff call 10bcf8 <rtems_semaphore_release>
110030: 83 c4 10 add $0x10,%esp
110033: eb 05 jmp 11003a <pipe_read+0x14e>
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
110035: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED
out_locked:
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
11003a: 83 7d d0 00 cmpl $0x0,-0x30(%ebp)
11003e: 7e 03 jle 110043 <pipe_read+0x157>
110040: 8b 75 d0 mov -0x30(%ebp),%esi
return read;
return ret;
}
110043: 89 f0 mov %esi,%eax
110045: 8d 65 f4 lea -0xc(%ebp),%esp
110048: 5b pop %ebx
110049: 5e pop %esi
11004a: 5f pop %edi
11004b: c9 leave
11004c: c3 ret
0010fa91 <pipe_release>:
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
10fa91: 55 push %ebp
10fa92: 89 e5 mov %esp,%ebp
10fa94: 57 push %edi
10fa95: 56 push %esi
10fa96: 53 push %ebx
10fa97: 83 ec 1c sub $0x1c,%esp
10fa9a: 8b 7d 08 mov 0x8(%ebp),%edi
pipe_control_t *pipe = *pipep;
10fa9d: 8b 1f mov (%edi),%ebx
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
10fa9f: 8b 45 0c mov 0xc(%ebp),%eax
10faa2: 8b 40 14 mov 0x14(%eax),%eax
10faa5: 89 c6 mov %eax,%esi
10faa7: 83 e6 06 and $0x6,%esi
if (mode & LIBIO_FLAGS_READ)
10faaa: a8 02 test $0x2,%al
10faac: 74 03 je 10fab1 <pipe_release+0x20>
pipe->Readers --;
10faae: ff 4b 10 decl 0x10(%ebx)
if (mode & LIBIO_FLAGS_WRITE)
10fab1: f7 c6 04 00 00 00 test $0x4,%esi
10fab7: 74 03 je 10fabc <pipe_release+0x2b>
pipe->Writers --;
10fab9: ff 4b 14 decl 0x14(%ebx)
PIPE_UNLOCK(pipe);
10fabc: 83 ec 0c sub $0xc,%esp
10fabf: ff 73 28 pushl 0x28(%ebx)
10fac2: e8 31 c2 ff ff call 10bcf8 <rtems_semaphore_release>
if (pipe->Readers == 0 && pipe->Writers == 0) {
10fac7: 8b 43 10 mov 0x10(%ebx),%eax
10faca: 83 c4 10 add $0x10,%esp
10facd: 85 c0 test %eax,%eax
10facf: 75 15 jne 10fae6 <pipe_release+0x55>
10fad1: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10fad5: 75 0f jne 10fae6 <pipe_release+0x55>
#if 0
/* To delete an anonymous pipe file when all users closed it */
if (pipe->Anonymous)
delfile = TRUE;
#endif
pipe_free(pipe);
10fad7: 89 d8 mov %ebx,%eax
10fad9: e8 78 ff ff ff call 10fa56 <pipe_free>
*pipep = NULL;
10fade: c7 07 00 00 00 00 movl $0x0,(%edi)
10fae4: eb 30 jmp 10fb16 <pipe_release+0x85>
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
10fae6: 83 fe 04 cmp $0x4,%esi
10fae9: 74 0f je 10fafa <pipe_release+0x69>
10faeb: 85 c0 test %eax,%eax
10faed: 75 0b jne 10fafa <pipe_release+0x69> <== NEVER TAKEN
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
10faef: 57 push %edi
10faf0: 57 push %edi
10faf1: 8d 45 e4 lea -0x1c(%ebp),%eax
10faf4: 50 push %eax
10faf5: ff 73 30 pushl 0x30(%ebx)
10faf8: eb 14 jmp 10fb0e <pipe_release+0x7d>
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
10fafa: 83 fe 02 cmp $0x2,%esi
10fafd: 74 17 je 10fb16 <pipe_release+0x85> <== NEVER TAKEN
10faff: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
10fb03: 75 11 jne 10fb16 <pipe_release+0x85> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
10fb05: 56 push %esi
10fb06: 56 push %esi
10fb07: 8d 45 e4 lea -0x1c(%ebp),%eax
10fb0a: 50 push %eax
10fb0b: ff 73 2c pushl 0x2c(%ebx)
10fb0e: e8 85 1a 00 00 call 111598 <rtems_barrier_release>
10fb13: 83 c4 10 add $0x10,%esp
pipe_unlock();
10fb16: e8 25 ff ff ff call 10fa40 <pipe_unlock>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
10fb1b: 8d 65 f4 lea -0xc(%ebp),%esp
10fb1e: 5b pop %ebx
10fb1f: 5e pop %esi
10fb20: 5f pop %edi
10fb21: c9 leave
10fb22: c3 ret
0011004d <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
11004d: 55 push %ebp
11004e: 89 e5 mov %esp,%ebp
110050: 57 push %edi
110051: 56 push %esi
110052: 53 push %ebx
110053: 83 ec 2c sub $0x2c,%esp
110056: 8b 5d 08 mov 0x8(%ebp),%ebx
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
return 0;
110059: 31 f6 xor %esi,%esi
)
{
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
11005b: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
11005f: 0f 84 8c 01 00 00 je 1101f1 <pipe_write+0x1a4> <== NEVER TAKEN
return 0;
if (! PIPE_LOCK(pipe))
110065: 52 push %edx
110066: 6a 00 push $0x0
110068: 6a 00 push $0x0
11006a: ff 73 28 pushl 0x28(%ebx)
11006d: e8 9a bb ff ff call 10bc0c <rtems_semaphore_obtain>
110072: 83 c4 10 add $0x10,%esp
return -EINTR;
110075: be fc ff ff ff mov $0xfffffffc,%esi
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
11007a: 85 c0 test %eax,%eax
11007c: 0f 85 6f 01 00 00 jne 1101f1 <pipe_write+0x1a4> <== NEVER TAKEN
return -EINTR;
if (pipe->Readers == 0) {
110082: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
110086: 0f 84 16 01 00 00 je 1101a2 <pipe_write+0x155>
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
11008c: bf 01 00 00 00 mov $0x1,%edi
110091: 8b 45 10 mov 0x10(%ebp),%eax
110094: 3b 43 04 cmp 0x4(%ebx),%eax
110097: 77 02 ja 11009b <pipe_write+0x4e> <== NEVER TAKEN
110099: 89 c7 mov %eax,%edi
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
11009b: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
1100a2: e9 eb 00 00 00 jmp 110192 <pipe_write+0x145>
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
1100a7: 8b 4d 14 mov 0x14(%ebp),%ecx
1100aa: f6 41 14 01 testb $0x1,0x14(%ecx)
1100ae: 0f 85 fc 00 00 00 jne 1101b0 <pipe_write+0x163>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
1100b4: ff 43 1c incl 0x1c(%ebx)
PIPE_UNLOCK(pipe);
1100b7: 83 ec 0c sub $0xc,%esp
1100ba: ff 73 28 pushl 0x28(%ebx)
1100bd: e8 36 bc ff ff call 10bcf8 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
1100c2: 5e pop %esi
1100c3: 58 pop %eax
1100c4: 6a 00 push $0x0
1100c6: ff 73 30 pushl 0x30(%ebx)
1100c9: e8 22 15 00 00 call 1115f0 <rtems_barrier_wait>
1100ce: 83 c4 0c add $0xc,%esp
1100d1: 83 f8 01 cmp $0x1,%eax
1100d4: 19 f6 sbb %esi,%esi
1100d6: f7 d6 not %esi
1100d8: 83 e6 fc and $0xfffffffc,%esi
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
1100db: 6a 00 push $0x0
1100dd: 6a 00 push $0x0
1100df: ff 73 28 pushl 0x28(%ebx)
1100e2: e8 25 bb ff ff call 10bc0c <rtems_semaphore_obtain>
1100e7: 83 c4 10 add $0x10,%esp
1100ea: 85 c0 test %eax,%eax
1100ec: 0f 85 f1 00 00 00 jne 1101e3 <pipe_write+0x196> <== NEVER TAKEN
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
1100f2: ff 4b 1c decl 0x1c(%ebx)
if (ret != 0)
1100f5: 85 f6 test %esi,%esi
1100f7: 0f 85 bf 00 00 00 jne 1101bc <pipe_write+0x16f> <== NEVER TAKEN
goto out_locked;
if (pipe->Readers == 0) {
1100fd: 83 7b 10 00 cmpl $0x0,0x10(%ebx)
110101: 0f 84 b0 00 00 00 je 1101b7 <pipe_write+0x16a> <== NEVER TAKEN
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
110107: 8b 73 04 mov 0x4(%ebx),%esi
11010a: 8b 43 0c mov 0xc(%ebx),%eax
11010d: 89 f1 mov %esi,%ecx
11010f: 29 c1 sub %eax,%ecx
110111: 39 f9 cmp %edi,%ecx
110113: 72 92 jb 1100a7 <pipe_write+0x5a>
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
110115: 8b 55 10 mov 0x10(%ebp),%edx
110118: 2b 55 d4 sub -0x2c(%ebp),%edx
11011b: 89 4d d0 mov %ecx,-0x30(%ebp)
11011e: 39 d1 cmp %edx,%ecx
110120: 76 03 jbe 110125 <pipe_write+0xd8>
110122: 89 55 d0 mov %edx,-0x30(%ebp)
chunk1 = pipe->Size - PIPE_WSTART(pipe);
110125: 03 43 08 add 0x8(%ebx),%eax
110128: 31 d2 xor %edx,%edx
11012a: f7 f6 div %esi
11012c: 29 d6 sub %edx,%esi
11012e: 89 75 cc mov %esi,-0x34(%ebp)
if (chunk > chunk1) {
110131: 39 75 d0 cmp %esi,-0x30(%ebp)
110134: 8b 4d 0c mov 0xc(%ebp),%ecx
110137: 8b 45 d4 mov -0x2c(%ebp),%eax
11013a: 8d 34 01 lea (%ecx,%eax,1),%esi
11013d: 7e 20 jle 11015f <pipe_write+0x112>
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
11013f: 8b 03 mov (%ebx),%eax
110141: 01 d0 add %edx,%eax
110143: 89 c7 mov %eax,%edi
110145: 8b 4d cc mov -0x34(%ebp),%ecx
110148: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
11014a: 8b 03 mov (%ebx),%eax
11014c: 8b 4d d0 mov -0x30(%ebp),%ecx
11014f: 2b 4d cc sub -0x34(%ebp),%ecx
110152: 8b 75 cc mov -0x34(%ebp),%esi
110155: 03 75 d4 add -0x2c(%ebp),%esi
110158: 03 75 0c add 0xc(%ebp),%esi
11015b: 89 c7 mov %eax,%edi
11015d: eb 09 jmp 110168 <pipe_write+0x11b>
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
11015f: 8b 03 mov (%ebx),%eax
110161: 01 d0 add %edx,%eax
110163: 89 c7 mov %eax,%edi
110165: 8b 4d d0 mov -0x30(%ebp),%ecx
110168: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
pipe->Length += chunk;
11016a: 8b 45 d0 mov -0x30(%ebp),%eax
11016d: 01 43 0c add %eax,0xc(%ebx)
if (pipe->waitingReaders > 0)
110170: 83 7b 18 00 cmpl $0x0,0x18(%ebx)
110174: 74 11 je 110187 <pipe_write+0x13a>
PIPE_WAKEUPREADERS(pipe);
110176: 51 push %ecx
110177: 51 push %ecx
110178: 8d 4d e4 lea -0x1c(%ebp),%ecx
11017b: 51 push %ecx
11017c: ff 73 2c pushl 0x2c(%ebx)
11017f: e8 14 14 00 00 call 111598 <rtems_barrier_release>
110184: 83 c4 10 add $0x10,%esp
written += chunk;
110187: 8b 45 d0 mov -0x30(%ebp),%eax
11018a: 01 45 d4 add %eax,-0x2c(%ebp)
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
11018d: bf 01 00 00 00 mov $0x1,%edi
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
110192: 8b 4d 10 mov 0x10(%ebp),%ecx
110195: 39 4d d4 cmp %ecx,-0x2c(%ebp)
110198: 0f 82 69 ff ff ff jb 110107 <pipe_write+0xba>
11019e: 31 f6 xor %esi,%esi
1101a0: eb 1a jmp 1101bc <pipe_write+0x16f>
if (! PIPE_LOCK(pipe))
return -EINTR;
if (pipe->Readers == 0) {
ret = -EPIPE;
1101a2: be e0 ff ff ff mov $0xffffffe0,%esi
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
int chunk, chunk1, written = 0, ret = 0;
1101a7: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
1101ae: eb 0c jmp 1101bc <pipe_write+0x16f>
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
1101b0: be f5 ff ff ff mov $0xfffffff5,%esi
1101b5: eb 05 jmp 1101bc <pipe_write+0x16f>
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
1101b7: be e0 ff ff ff mov $0xffffffe0,%esi <== NOT EXECUTED
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
1101bc: 83 ec 0c sub $0xc,%esp
1101bf: ff 73 28 pushl 0x28(%ebx)
1101c2: e8 31 bb ff ff call 10bcf8 <rtems_semaphore_release>
1101c7: 83 c4 10 add $0x10,%esp
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
1101ca: 83 fe e0 cmp $0xffffffe0,%esi
1101cd: 75 19 jne 1101e8 <pipe_write+0x19b>
kill(getpid(), SIGPIPE);
1101cf: e8 24 07 00 00 call 1108f8 <getpid>
1101d4: 52 push %edx
1101d5: 52 push %edx
1101d6: 6a 0d push $0xd
1101d8: 50 push %eax
1101d9: e8 a2 09 00 00 call 110b80 <kill>
1101de: 83 c4 10 add $0x10,%esp
1101e1: eb 05 jmp 1101e8 <pipe_write+0x19b>
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
1101e3: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
1101e8: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
1101ec: 7e 03 jle 1101f1 <pipe_write+0x1a4>
1101ee: 8b 75 d4 mov -0x2c(%ebp),%esi
return written;
return ret;
}
1101f1: 89 f0 mov %esi,%eax
1101f3: 8d 65 f4 lea -0xc(%ebp),%esp
1101f6: 5b pop %ebx
1101f7: 5e pop %esi
1101f8: 5f pop %edi
1101f9: c9 leave
1101fa: c3 ret
0010a7d4 <posix_memalign>:
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
10a7d4: 55 push %ebp
10a7d5: 89 e5 mov %esp,%ebp
10a7d7: 53 push %ebx
10a7d8: 83 ec 04 sub $0x4,%esp
10a7db: 8b 45 0c mov 0xc(%ebp),%eax
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
10a7de: ff 05 04 c3 12 00 incl 0x12c304
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
10a7e4: 8d 58 ff lea -0x1(%eax),%ebx
10a7e7: 85 c3 test %eax,%ebx
10a7e9: 75 0d jne 10a7f8 <posix_memalign+0x24> <== NEVER TAKEN
10a7eb: 83 f8 03 cmp $0x3,%eax
10a7ee: 76 08 jbe 10a7f8 <posix_memalign+0x24>
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
}
10a7f0: 59 pop %ecx
10a7f1: 5b pop %ebx
10a7f2: c9 leave
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
10a7f3: e9 74 01 00 00 jmp 10a96c <rtems_memalign>
}
10a7f8: b8 16 00 00 00 mov $0x16,%eax
10a7fd: 5a pop %edx
10a7fe: 5b pop %ebx
10a7ff: c9 leave
10a800: c3 ret
0010efdc <pthread_attr_getinheritsched>:
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
10efdc: 55 push %ebp
10efdd: 89 e5 mov %esp,%ebp
10efdf: 8b 55 08 mov 0x8(%ebp),%edx
10efe2: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized || !inheritsched )
return EINVAL;
10efe5: b8 16 00 00 00 mov $0x16,%eax
int pthread_attr_getinheritsched(
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
10efea: 85 d2 test %edx,%edx
10efec: 74 17 je 10f005 <pthread_attr_getinheritsched+0x29><== NEVER TAKEN
10efee: 85 c9 test %ecx,%ecx
10eff0: 74 0e je 10f000 <pthread_attr_getinheritsched+0x24><== NEVER TAKEN
10eff2: 83 3a 00 cmpl $0x0,(%edx)
10eff5: 74 09 je 10f000 <pthread_attr_getinheritsched+0x24><== NEVER TAKEN
return EINVAL;
*inheritsched = attr->inheritsched;
10eff7: 8b 42 10 mov 0x10(%edx),%eax
10effa: 89 01 mov %eax,(%ecx)
return 0;
10effc: 31 c0 xor %eax,%eax
10effe: eb 05 jmp 10f005 <pthread_attr_getinheritsched+0x29>
const pthread_attr_t *attr,
int *inheritsched
)
{
if ( !attr || !attr->is_initialized || !inheritsched )
return EINVAL;
10f000: b8 16 00 00 00 mov $0x16,%eax
*inheritsched = attr->inheritsched;
return 0;
}
10f005: c9 leave
10f006: c3 ret
0010f1f8 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
10f1f8: 55 push %ebp
10f1f9: 89 e5 mov %esp,%ebp
10f1fb: 8b 55 08 mov 0x8(%ebp),%edx
10f1fe: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
10f201: b8 16 00 00 00 mov $0x16,%eax
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
10f206: 85 d2 test %edx,%edx
10f208: 74 1e je 10f228 <pthread_attr_setschedpolicy+0x30>
10f20a: 83 3a 00 cmpl $0x0,(%edx)
10f20d: 74 19 je 10f228 <pthread_attr_setschedpolicy+0x30>
return EINVAL;
switch ( policy ) {
10f20f: 83 f9 04 cmp $0x4,%ecx
10f212: 77 0f ja 10f223 <pthread_attr_setschedpolicy+0x2b>
10f214: b0 01 mov $0x1,%al
10f216: d3 e0 shl %cl,%eax
10f218: a8 17 test $0x17,%al
10f21a: 74 07 je 10f223 <pthread_attr_setschedpolicy+0x2b><== NEVER TAKEN
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
10f21c: 89 4a 14 mov %ecx,0x14(%edx)
return 0;
10f21f: 31 c0 xor %eax,%eax
10f221: eb 05 jmp 10f228 <pthread_attr_setschedpolicy+0x30>
default:
return ENOTSUP;
10f223: b8 86 00 00 00 mov $0x86,%eax
}
}
10f228: c9 leave
10f229: c3 ret
0010a518 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
10a518: 55 push %ebp
10a519: 89 e5 mov %esp,%ebp
10a51b: 57 push %edi
10a51c: 56 push %esi
10a51d: 53 push %ebx
10a51e: 83 ec 1c sub $0x1c,%esp
10a521: 8b 5d 08 mov 0x8(%ebp),%ebx
10a524: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Error check parameters
*/
if ( !barrier )
return EINVAL;
10a527: b8 16 00 00 00 mov $0x16,%eax
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
10a52c: 85 db test %ebx,%ebx
10a52e: 0f 84 96 00 00 00 je 10a5ca <pthread_barrier_init+0xb2>
return EINVAL;
if ( count == 0 )
10a534: 85 f6 test %esi,%esi
10a536: 0f 84 8e 00 00 00 je 10a5ca <pthread_barrier_init+0xb2>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10a53c: 8b 7d 0c mov 0xc(%ebp),%edi
10a53f: 85 ff test %edi,%edi
10a541: 75 0f jne 10a552 <pthread_barrier_init+0x3a>
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
10a543: 83 ec 0c sub $0xc,%esp
10a546: 8d 7d d8 lea -0x28(%ebp),%edi
10a549: 57 push %edi
10a54a: e8 19 ff ff ff call 10a468 <pthread_barrierattr_init>
10a54f: 83 c4 10 add $0x10,%esp
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
return EINVAL;
10a552: b8 16 00 00 00 mov $0x16,%eax
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
10a557: 83 3f 00 cmpl $0x0,(%edi)
10a55a: 74 6e je 10a5ca <pthread_barrier_init+0xb2>
return EINVAL;
switch ( the_attr->process_shared ) {
10a55c: 83 7f 04 00 cmpl $0x0,0x4(%edi)
10a560: 75 68 jne 10a5ca <pthread_barrier_init+0xb2><== NEVER TAKEN
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
10a562: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
the_attributes.maximum_count = count;
10a569: 89 75 e4 mov %esi,-0x1c(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a56c: a1 50 63 12 00 mov 0x126350,%eax
10a571: 40 inc %eax
10a572: a3 50 63 12 00 mov %eax,0x126350
* the inactive chain of free barrier control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void )
{
return (POSIX_Barrier_Control *)
_Objects_Allocate( &_POSIX_Barrier_Information );
10a577: 83 ec 0c sub $0xc,%esp
10a57a: 68 f4 66 12 00 push $0x1266f4
10a57f: e8 0c 1e 00 00 call 10c390 <_Objects_Allocate>
10a584: 89 c6 mov %eax,%esi
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
10a586: 83 c4 10 add $0x10,%esp
10a589: 85 c0 test %eax,%eax
10a58b: 75 0c jne 10a599 <pthread_barrier_init+0x81>
_Thread_Enable_dispatch();
10a58d: e8 d0 2c 00 00 call 10d262 <_Thread_Enable_dispatch>
return EAGAIN;
10a592: b8 0b 00 00 00 mov $0xb,%eax
10a597: eb 31 jmp 10a5ca <pthread_barrier_init+0xb2>
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
10a599: 50 push %eax
10a59a: 50 push %eax
10a59b: 8d 45 e0 lea -0x20(%ebp),%eax
10a59e: 50 push %eax
10a59f: 8d 46 10 lea 0x10(%esi),%eax
10a5a2: 50 push %eax
10a5a3: e8 a8 14 00 00 call 10ba50 <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10a5a8: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10a5ab: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10a5ae: 8b 15 10 67 12 00 mov 0x126710,%edx
10a5b4: 89 34 8a mov %esi,(%edx,%ecx,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10a5b7: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
10a5be: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10a5c0: e8 9d 2c 00 00 call 10d262 <_Thread_Enable_dispatch>
return 0;
10a5c5: 83 c4 10 add $0x10,%esp
10a5c8: 31 c0 xor %eax,%eax
}
10a5ca: 8d 65 f4 lea -0xc(%ebp),%esp
10a5cd: 5b pop %ebx
10a5ce: 5e pop %esi
10a5cf: 5f pop %edi
10a5d0: c9 leave
10a5d1: c3 ret
00109ed0 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
109ed0: 55 push %ebp
109ed1: 89 e5 mov %esp,%ebp
109ed3: 56 push %esi
109ed4: 53 push %ebx
109ed5: 8b 5d 08 mov 0x8(%ebp),%ebx
109ed8: 8b 75 0c mov 0xc(%ebp),%esi
/*
* The POSIX standard does not address what to do when the routine
* is NULL. It also does not address what happens when we cannot
* allocate memory or anything else bad happens.
*/
if ( !routine )
109edb: 85 db test %ebx,%ebx
109edd: 74 4b je 109f2a <pthread_cleanup_push+0x5a>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
109edf: a1 48 63 12 00 mov 0x126348,%eax
109ee4: 40 inc %eax
109ee5: a3 48 63 12 00 mov %eax,0x126348
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
109eea: 83 ec 0c sub $0xc,%esp
109eed: 6a 10 push $0x10
109eef: e8 32 3c 00 00 call 10db26 <_Workspace_Allocate>
if ( handler ) {
109ef4: 83 c4 10 add $0x10,%esp
109ef7: 85 c0 test %eax,%eax
109ef9: 74 24 je 109f1f <pthread_cleanup_push+0x4f><== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
109efb: 8b 15 70 68 12 00 mov 0x126870,%edx
handler_stack = &thread_support->Cancellation_Handlers;
109f01: 8b 92 ec 00 00 00 mov 0xec(%edx),%edx
109f07: 81 c2 e4 00 00 00 add $0xe4,%edx
handler->routine = routine;
109f0d: 89 58 08 mov %ebx,0x8(%eax)
handler->arg = arg;
109f10: 89 70 0c mov %esi,0xc(%eax)
_Chain_Append( handler_stack, &handler->Node );
109f13: 51 push %ecx
109f14: 51 push %ecx
109f15: 50 push %eax
109f16: 52 push %edx
109f17: e8 88 15 00 00 call 10b4a4 <_Chain_Append>
109f1c: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
}
109f1f: 8d 65 f8 lea -0x8(%ebp),%esp
109f22: 5b pop %ebx
109f23: 5e pop %esi
109f24: c9 leave
handler->routine = routine;
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
}
_Thread_Enable_dispatch();
109f25: e9 34 2d 00 00 jmp 10cc5e <_Thread_Enable_dispatch>
}
109f2a: 8d 65 f8 lea -0x8(%ebp),%esp
109f2d: 5b pop %ebx
109f2e: 5e pop %esi
109f2f: c9 leave
109f30: c3 ret
0010ac40 <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
10ac40: 55 push %ebp
10ac41: 89 e5 mov %esp,%ebp
10ac43: 56 push %esi
10ac44: 53 push %ebx
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
10ac45: 8b 5d 0c mov 0xc(%ebp),%ebx
10ac48: 85 db test %ebx,%ebx
10ac4a: 75 05 jne 10ac51 <pthread_cond_init+0x11>
else the_attr = &_POSIX_Condition_variables_Default_attributes;
10ac4c: bb 08 15 12 00 mov $0x121508,%ebx
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
return EINVAL;
10ac51: b8 16 00 00 00 mov $0x16,%eax
else the_attr = &_POSIX_Condition_variables_Default_attributes;
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
10ac56: 83 7b 04 01 cmpl $0x1,0x4(%ebx)
10ac5a: 74 76 je 10acd2 <pthread_cond_init+0x92><== NEVER TAKEN
return EINVAL;
if ( !the_attr->is_initialized )
10ac5c: 83 3b 00 cmpl $0x0,(%ebx)
10ac5f: 74 71 je 10acd2 <pthread_cond_init+0x92>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10ac61: a1 60 73 12 00 mov 0x127360,%eax
10ac66: 40 inc %eax
10ac67: a3 60 73 12 00 mov %eax,0x127360
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
_Objects_Allocate( &_POSIX_Condition_variables_Information );
10ac6c: 83 ec 0c sub $0xc,%esp
10ac6f: 68 9c 77 12 00 push $0x12779c
10ac74: e8 f7 22 00 00 call 10cf70 <_Objects_Allocate>
10ac79: 89 c6 mov %eax,%esi
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
10ac7b: 83 c4 10 add $0x10,%esp
10ac7e: 85 c0 test %eax,%eax
10ac80: 75 0c jne 10ac8e <pthread_cond_init+0x4e>
_Thread_Enable_dispatch();
10ac82: e8 bb 31 00 00 call 10de42 <_Thread_Enable_dispatch>
return ENOMEM;
10ac87: b8 0c 00 00 00 mov $0xc,%eax
10ac8c: eb 44 jmp 10acd2 <pthread_cond_init+0x92>
}
the_cond->process_shared = the_attr->process_shared;
10ac8e: 8b 43 04 mov 0x4(%ebx),%eax
10ac91: 89 46 10 mov %eax,0x10(%esi)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
10ac94: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi)
_Thread_queue_Initialize(
10ac9b: 6a 74 push $0x74
10ac9d: 68 00 08 00 10 push $0x10000800
10aca2: 6a 00 push $0x0
10aca4: 8d 46 18 lea 0x18(%esi),%eax
10aca7: 50 push %eax
10aca8: e8 4f 38 00 00 call 10e4fc <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10acad: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10acb0: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10acb3: 8b 15 b8 77 12 00 mov 0x1277b8,%edx
10acb9: 89 34 8a mov %esi,(%edx,%ecx,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10acbc: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
10acc3: 8b 55 08 mov 0x8(%ebp),%edx
10acc6: 89 02 mov %eax,(%edx)
_Thread_Enable_dispatch();
10acc8: e8 75 31 00 00 call 10de42 <_Thread_Enable_dispatch>
return 0;
10accd: 83 c4 10 add $0x10,%esp
10acd0: 31 c0 xor %eax,%eax
}
10acd2: 8d 65 f8 lea -0x8(%ebp),%esp
10acd5: 5b pop %ebx
10acd6: 5e pop %esi
10acd7: c9 leave
10acd8: c3 ret
0010aaf4 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
10aaf4: 55 push %ebp
10aaf5: 89 e5 mov %esp,%ebp
10aaf7: 8b 55 08 mov 0x8(%ebp),%edx
if ( !attr || attr->is_initialized == false )
return EINVAL;
10aafa: b8 16 00 00 00 mov $0x16,%eax
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
10aaff: 85 d2 test %edx,%edx
10ab01: 74 0d je 10ab10 <pthread_condattr_destroy+0x1c>
10ab03: 83 3a 00 cmpl $0x0,(%edx)
10ab06: 74 08 je 10ab10 <pthread_condattr_destroy+0x1c><== NEVER TAKEN
return EINVAL;
attr->is_initialized = false;
10ab08: c7 02 00 00 00 00 movl $0x0,(%edx)
return 0;
10ab0e: 30 c0 xor %al,%al
}
10ab10: c9 leave
10ab11: c3 ret
0010a228 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
10a228: 55 push %ebp
10a229: 89 e5 mov %esp,%ebp
10a22b: 57 push %edi
10a22c: 56 push %esi
10a22d: 53 push %ebx
10a22e: 83 ec 5c sub $0x5c,%esp
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
return EFAULT;
10a231: c7 45 b4 0e 00 00 00 movl $0xe,-0x4c(%ebp)
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
10a238: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a23c: 0f 84 0f 02 00 00 je 10a451 <pthread_create+0x229>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
10a242: 8b 5d 0c mov 0xc(%ebp),%ebx
10a245: 85 db test %ebx,%ebx
10a247: 75 05 jne 10a24e <pthread_create+0x26>
10a249: bb 74 01 12 00 mov $0x120174,%ebx
if ( !the_attr->is_initialized )
return EINVAL;
10a24e: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp)
if ( !start_routine )
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
if ( !the_attr->is_initialized )
10a255: 83 3b 00 cmpl $0x0,(%ebx)
10a258: 0f 84 f3 01 00 00 je 10a451 <pthread_create+0x229>
* stack space if it is allowed to allocate it itself.
*
* NOTE: If the user provides the stack we will let it drop below
* twice the minimum.
*/
if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) )
10a25e: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a262: 74 0e je 10a272 <pthread_create+0x4a>
10a264: a1 44 22 12 00 mov 0x122244,%eax
10a269: 39 43 08 cmp %eax,0x8(%ebx)
10a26c: 0f 82 df 01 00 00 jb 10a451 <pthread_create+0x229>
* If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread
* inherits scheduling attributes from the creating thread. If it is
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
10a272: 8b 43 10 mov 0x10(%ebx),%eax
10a275: 83 f8 01 cmp $0x1,%eax
10a278: 74 0b je 10a285 <pthread_create+0x5d>
10a27a: 83 f8 02 cmp $0x2,%eax
10a27d: 0f 85 c7 01 00 00 jne 10a44a <pthread_create+0x222>
10a283: eb 1f jmp 10a2a4 <pthread_create+0x7c>
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10a285: a1 78 68 12 00 mov 0x126878,%eax
10a28a: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi
schedpolicy = api->schedpolicy;
10a290: 8b 86 84 00 00 00 mov 0x84(%esi),%eax
10a296: 89 45 ac mov %eax,-0x54(%ebp)
schedparam = api->schedparam;
10a299: 8d 7d c4 lea -0x3c(%ebp),%edi
10a29c: 81 c6 88 00 00 00 add $0x88,%esi
10a2a2: eb 0c jmp 10a2b0 <pthread_create+0x88>
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
10a2a4: 8b 43 14 mov 0x14(%ebx),%eax
10a2a7: 89 45 ac mov %eax,-0x54(%ebp)
schedparam = the_attr->schedparam;
10a2aa: 8d 7d c4 lea -0x3c(%ebp),%edi
10a2ad: 8d 73 18 lea 0x18(%ebx),%esi
10a2b0: b9 07 00 00 00 mov $0x7,%ecx
10a2b5: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
return ENOTSUP;
10a2b7: c7 45 b4 86 00 00 00 movl $0x86,-0x4c(%ebp)
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
10a2be: 83 7b 0c 00 cmpl $0x0,0xc(%ebx)
10a2c2: 0f 85 89 01 00 00 jne 10a451 <pthread_create+0x229>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
10a2c8: 83 ec 0c sub $0xc,%esp
10a2cb: ff 75 c4 pushl -0x3c(%ebp)
10a2ce: e8 11 59 00 00 call 10fbe4 <_POSIX_Priority_Is_valid>
10a2d3: 83 c4 10 add $0x10,%esp
return EINVAL;
10a2d6: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp)
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
10a2dd: 84 c0 test %al,%al
10a2df: 0f 84 6c 01 00 00 je 10a451 <pthread_create+0x229> <== NEVER TAKEN
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
10a2e5: 8b 45 c4 mov -0x3c(%ebp),%eax
10a2e8: 89 45 a8 mov %eax,-0x58(%ebp)
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
10a2eb: 0f b6 3d 48 22 12 00 movzbl 0x122248,%edi
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
10a2f2: 8d 45 e0 lea -0x20(%ebp),%eax
10a2f5: 50 push %eax
10a2f6: 8d 45 e4 lea -0x1c(%ebp),%eax
10a2f9: 50 push %eax
10a2fa: 8d 45 c4 lea -0x3c(%ebp),%eax
10a2fd: 50 push %eax
10a2fe: ff 75 ac pushl -0x54(%ebp)
10a301: e8 fe 58 00 00 call 10fc04 <_POSIX_Thread_Translate_sched_param>
10a306: 89 45 b4 mov %eax,-0x4c(%ebp)
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
10a309: 83 c4 10 add $0x10,%esp
10a30c: 85 c0 test %eax,%eax
10a30e: 0f 85 3d 01 00 00 jne 10a451 <pthread_create+0x229>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
10a314: 83 ec 0c sub $0xc,%esp
10a317: ff 35 f4 63 12 00 pushl 0x1263f4
10a31d: e8 4e 15 00 00 call 10b870 <_API_Mutex_Lock>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
10a322: c7 04 24 74 65 12 00 movl $0x126574,(%esp)
10a329: e8 a2 1e 00 00 call 10c1d0 <_Objects_Allocate>
10a32e: 89 45 b0 mov %eax,-0x50(%ebp)
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
10a331: 83 c4 10 add $0x10,%esp
10a334: 85 c0 test %eax,%eax
10a336: 75 05 jne 10a33d <pthread_create+0x115>
_RTEMS_Unlock_allocator();
10a338: 83 ec 0c sub $0xc,%esp
10a33b: eb 53 jmp 10a390 <pthread_create+0x168>
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
10a33d: 8b 4d e0 mov -0x20(%ebp),%ecx
10a340: 8b 75 e4 mov -0x1c(%ebp),%esi
10a343: 8b 53 08 mov 0x8(%ebx),%edx
10a346: a1 44 22 12 00 mov 0x122244,%eax
10a34b: d1 e0 shl %eax
10a34d: 39 d0 cmp %edx,%eax
10a34f: 73 02 jae 10a353 <pthread_create+0x12b>
10a351: 89 d0 mov %edx,%eax
10a353: 52 push %edx
10a354: 6a 00 push $0x0
10a356: 6a 00 push $0x0
10a358: 51 push %ecx
10a359: 56 push %esi
10a35a: 6a 01 push $0x1
10a35c: 81 e7 ff 00 00 00 and $0xff,%edi
10a362: 2b 7d a8 sub -0x58(%ebp),%edi
10a365: 57 push %edi
10a366: 6a 01 push $0x1
10a368: 50 push %eax
10a369: ff 73 04 pushl 0x4(%ebx)
10a36c: ff 75 b0 pushl -0x50(%ebp)
10a36f: 68 74 65 12 00 push $0x126574
10a374: e8 bb 2d 00 00 call 10d134 <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
10a379: 83 c4 30 add $0x30,%esp
10a37c: 84 c0 test %al,%al
10a37e: 75 2a jne 10a3aa <pthread_create+0x182>
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
10a380: 56 push %esi
10a381: 56 push %esi
10a382: ff 75 b0 pushl -0x50(%ebp)
10a385: 68 74 65 12 00 push $0x126574
10a38a: e8 35 21 00 00 call 10c4c4 <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
10a38f: 5b pop %ebx
10a390: ff 35 f4 63 12 00 pushl 0x1263f4
10a396: e8 1d 15 00 00 call 10b8b8 <_API_Mutex_Unlock>
return EAGAIN;
10a39b: 83 c4 10 add $0x10,%esp
10a39e: c7 45 b4 0b 00 00 00 movl $0xb,-0x4c(%ebp)
10a3a5: e9 a7 00 00 00 jmp 10a451 <pthread_create+0x229>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10a3aa: 8b 45 b0 mov -0x50(%ebp),%eax
10a3ad: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx
api->Attributes = *the_attr;
10a3b3: b9 10 00 00 00 mov $0x10,%ecx
10a3b8: 89 d7 mov %edx,%edi
10a3ba: 89 de mov %ebx,%esi
10a3bc: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
api->detachstate = the_attr->detachstate;
10a3be: 8b 43 3c mov 0x3c(%ebx),%eax
10a3c1: 89 42 40 mov %eax,0x40(%edx)
api->schedpolicy = schedpolicy;
10a3c4: 8b 45 ac mov -0x54(%ebp),%eax
10a3c7: 89 82 84 00 00 00 mov %eax,0x84(%edx)
api->schedparam = schedparam;
10a3cd: 8d ba 88 00 00 00 lea 0x88(%edx),%edi
10a3d3: 8d 75 c4 lea -0x3c(%ebp),%esi
10a3d6: b1 07 mov $0x7,%cl
10a3d8: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
10a3da: 83 ec 0c sub $0xc,%esp
10a3dd: 6a 00 push $0x0
10a3df: ff 75 14 pushl 0x14(%ebp)
10a3e2: ff 75 10 pushl 0x10(%ebp)
10a3e5: 6a 01 push $0x1
10a3e7: ff 75 b0 pushl -0x50(%ebp)
10a3ea: 89 55 a4 mov %edx,-0x5c(%ebp)
10a3ed: e8 62 35 00 00 call 10d954 <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
10a3f2: 83 c4 20 add $0x20,%esp
10a3f5: 83 7d ac 04 cmpl $0x4,-0x54(%ebp)
10a3f9: 8b 55 a4 mov -0x5c(%ebp),%edx
10a3fc: 75 2e jne 10a42c <pthread_create+0x204>
_Watchdog_Insert_ticks(
10a3fe: 83 ec 0c sub $0xc,%esp
&api->Sporadic_timer,
_Timespec_To_ticks( &api->schedparam.sched_ss_repl_period )
10a401: 8d 82 90 00 00 00 lea 0x90(%edx),%eax
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
_Watchdog_Insert_ticks(
10a407: 50 push %eax
10a408: e8 97 36 00 00 call 10daa4 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10a40d: 8b 55 a4 mov -0x5c(%ebp),%edx
10a410: 89 82 b4 00 00 00 mov %eax,0xb4(%edx)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10a416: 58 pop %eax
10a417: 59 pop %ecx
10a418: 81 c2 a8 00 00 00 add $0xa8,%edx
10a41e: 52 push %edx
10a41f: 68 14 64 12 00 push $0x126414
10a424: e8 2f 39 00 00 call 10dd58 <_Watchdog_Insert>
10a429: 83 c4 10 add $0x10,%esp
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
10a42c: 8b 45 b0 mov -0x50(%ebp),%eax
10a42f: 8b 50 08 mov 0x8(%eax),%edx
10a432: 8b 45 08 mov 0x8(%ebp),%eax
10a435: 89 10 mov %edx,(%eax)
_RTEMS_Unlock_allocator();
10a437: 83 ec 0c sub $0xc,%esp
10a43a: ff 35 f4 63 12 00 pushl 0x1263f4
10a440: e8 73 14 00 00 call 10b8b8 <_API_Mutex_Unlock>
return 0;
10a445: 83 c4 10 add $0x10,%esp
10a448: eb 07 jmp 10a451 <pthread_create+0x229>
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
break;
default:
return EINVAL;
10a44a: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp)
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
10a451: 8b 45 b4 mov -0x4c(%ebp),%eax
10a454: 8d 65 f4 lea -0xc(%ebp),%esp
10a457: 5b pop %ebx
10a458: 5e pop %esi
10a459: 5f pop %edi
10a45a: c9 leave
10a45b: c3 ret
00110ce0 <pthread_exit>:
}
void pthread_exit(
void *value_ptr
)
{
110ce0: 55 push %ebp
110ce1: 89 e5 mov %esp,%ebp
110ce3: 83 ec 10 sub $0x10,%esp
_POSIX_Thread_Exit( _Thread_Executing, value_ptr );
110ce6: ff 75 08 pushl 0x8(%ebp)
110ce9: ff 35 68 58 12 00 pushl 0x125868
110cef: e8 88 ff ff ff call 110c7c <_POSIX_Thread_Exit>
110cf4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
110cf7: c9 leave <== NOT EXECUTED
110cf8: c3 ret <== NOT EXECUTED
0010bf24 <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
10bf24: 55 push %ebp
10bf25: 89 e5 mov %esp,%ebp
10bf27: 53 push %ebx
10bf28: 83 ec 2c sub $0x2c,%esp
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
10bf2b: 8d 45 f4 lea -0xc(%ebp),%eax
10bf2e: 50 push %eax
10bf2f: ff 75 0c pushl 0xc(%ebp)
10bf32: e8 b9 00 00 00 call 10bff0 <_POSIX_Absolute_timeout_to_ticks>
10bf37: 89 c3 mov %eax,%ebx
int _EXFUN(pthread_mutex_trylock, (pthread_mutex_t *__mutex));
int _EXFUN(pthread_mutex_unlock, (pthread_mutex_t *__mutex));
#if defined(_POSIX_TIMEOUTS)
int _EXFUN(pthread_mutex_timedlock,
10bf39: 83 c4 0c add $0xc,%esp
10bf3c: 83 f8 03 cmp $0x3,%eax
10bf3f: 0f 94 c2 sete %dl
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
10bf42: ff 75 f4 pushl -0xc(%ebp)
10bf45: 0f b6 c2 movzbl %dl,%eax
10bf48: 50 push %eax
10bf49: ff 75 08 pushl 0x8(%ebp)
10bf4c: 88 55 e4 mov %dl,-0x1c(%ebp)
10bf4f: e8 e8 fe ff ff call 10be3c <_POSIX_Mutex_Lock_support>
* This service only gives us the option to block. We used a polling
* attempt to lock if the abstime was not in the future. If we did
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
10bf54: 83 c4 10 add $0x10,%esp
10bf57: 8a 55 e4 mov -0x1c(%ebp),%dl
10bf5a: 84 d2 test %dl,%dl
10bf5c: 75 1d jne 10bf7b <pthread_mutex_timedlock+0x57>
10bf5e: 83 f8 10 cmp $0x10,%eax
10bf61: 75 18 jne 10bf7b <pthread_mutex_timedlock+0x57><== NEVER TAKEN
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10bf63: 85 db test %ebx,%ebx
10bf65: 74 08 je 10bf6f <pthread_mutex_timedlock+0x4b><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10bf67: 4b dec %ebx
10bf68: 83 fb 01 cmp $0x1,%ebx
10bf6b: 77 0e ja 10bf7b <pthread_mutex_timedlock+0x57><== NEVER TAKEN
10bf6d: eb 07 jmp 10bf76 <pthread_mutex_timedlock+0x52>
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
10bf6f: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED
10bf74: eb 05 jmp 10bf7b <pthread_mutex_timedlock+0x57><== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10bf76: b8 74 00 00 00 mov $0x74,%eax
}
return lock_status;
}
10bf7b: 8b 5d fc mov -0x4(%ebp),%ebx
10bf7e: c9 leave
10bf7f: c3 ret
0010bb9c <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
10bb9c: 55 push %ebp
10bb9d: 89 e5 mov %esp,%ebp
10bb9f: 8b 55 08 mov 0x8(%ebp),%edx
10bba2: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
10bba5: b8 16 00 00 00 mov $0x16,%eax
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
10bbaa: 85 d2 test %edx,%edx
10bbac: 74 0f je 10bbbd <pthread_mutexattr_setpshared+0x21>
10bbae: 83 3a 00 cmpl $0x0,(%edx)
10bbb1: 74 0a je 10bbbd <pthread_mutexattr_setpshared+0x21>
return EINVAL;
switch ( pshared ) {
10bbb3: 83 f9 01 cmp $0x1,%ecx
10bbb6: 77 05 ja 10bbbd <pthread_mutexattr_setpshared+0x21><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10bbb8: 89 4a 04 mov %ecx,0x4(%edx)
return 0;
10bbbb: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
10bbbd: c9 leave
10bbbe: c3 ret
00109dc4 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
109dc4: 55 push %ebp
109dc5: 89 e5 mov %esp,%ebp
109dc7: 8b 55 08 mov 0x8(%ebp),%edx
109dca: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr || !attr->is_initialized )
return EINVAL;
109dcd: b8 16 00 00 00 mov $0x16,%eax
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
if ( !attr || !attr->is_initialized )
109dd2: 85 d2 test %edx,%edx
109dd4: 74 0f je 109de5 <pthread_mutexattr_settype+0x21>
109dd6: 83 3a 00 cmpl $0x0,(%edx)
109dd9: 74 0a je 109de5 <pthread_mutexattr_settype+0x21><== NEVER TAKEN
return EINVAL;
switch ( type ) {
109ddb: 83 f9 03 cmp $0x3,%ecx
109dde: 77 05 ja 109de5 <pthread_mutexattr_settype+0x21>
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
109de0: 89 4a 10 mov %ecx,0x10(%edx)
return 0;
109de3: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
109de5: c9 leave
109de6: c3 ret
0010a874 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
10a874: 55 push %ebp
10a875: 89 e5 mov %esp,%ebp
10a877: 56 push %esi
10a878: 53 push %ebx
10a879: 83 ec 10 sub $0x10,%esp
10a87c: 8b 5d 08 mov 0x8(%ebp),%ebx
10a87f: 8b 75 0c mov 0xc(%ebp),%esi
if ( !once_control || !init_routine )
10a882: 85 f6 test %esi,%esi
10a884: 74 51 je 10a8d7 <pthread_once+0x63>
10a886: 85 db test %ebx,%ebx
10a888: 74 4d je 10a8d7 <pthread_once+0x63>
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
10a88a: 31 c0 xor %eax,%eax
)
{
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
10a88c: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a890: 75 4a jne 10a8dc <pthread_once+0x68>
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
10a892: 52 push %edx
10a893: 8d 45 f4 lea -0xc(%ebp),%eax
10a896: 50 push %eax
10a897: 68 00 01 00 00 push $0x100
10a89c: 68 00 01 00 00 push $0x100
10a8a1: e8 9e 0a 00 00 call 10b344 <rtems_task_mode>
if ( !once_control->init_executed ) {
10a8a6: 83 c4 10 add $0x10,%esp
10a8a9: 83 7b 04 00 cmpl $0x0,0x4(%ebx)
10a8ad: 75 0f jne 10a8be <pthread_once+0x4a> <== NEVER TAKEN
once_control->is_initialized = true;
10a8af: c7 03 01 00 00 00 movl $0x1,(%ebx)
once_control->init_executed = true;
10a8b5: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx)
(*init_routine)();
10a8bc: ff d6 call *%esi
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
10a8be: 50 push %eax
10a8bf: 8d 45 f4 lea -0xc(%ebp),%eax
10a8c2: 50 push %eax
10a8c3: 68 00 01 00 00 push $0x100
10a8c8: ff 75 f4 pushl -0xc(%ebp)
10a8cb: e8 74 0a 00 00 call 10b344 <rtems_task_mode>
10a8d0: 83 c4 10 add $0x10,%esp
}
return 0;
10a8d3: 31 c0 xor %eax,%eax
10a8d5: eb 05 jmp 10a8dc <pthread_once+0x68>
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
10a8d7: b8 16 00 00 00 mov $0x16,%eax
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
10a8dc: 8d 65 f8 lea -0x8(%ebp),%esp
10a8df: 5b pop %ebx
10a8e0: 5e pop %esi
10a8e1: c9 leave
10a8e2: c3 ret
0010b0a0 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
10b0a0: 55 push %ebp
10b0a1: 89 e5 mov %esp,%ebp
10b0a3: 56 push %esi
10b0a4: 53 push %ebx
10b0a5: 83 ec 10 sub $0x10,%esp
10b0a8: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Error check parameters
*/
if ( !rwlock )
return EINVAL;
10b0ab: b8 16 00 00 00 mov $0x16,%eax
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
10b0b0: 85 db test %ebx,%ebx
10b0b2: 0f 84 8b 00 00 00 je 10b143 <pthread_rwlock_init+0xa3>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
10b0b8: 8b 75 0c mov 0xc(%ebp),%esi
10b0bb: 85 f6 test %esi,%esi
10b0bd: 75 0f jne 10b0ce <pthread_rwlock_init+0x2e>
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
10b0bf: 83 ec 0c sub $0xc,%esp
10b0c2: 8d 75 ec lea -0x14(%ebp),%esi
10b0c5: 56 push %esi
10b0c6: e8 5d 09 00 00 call 10ba28 <pthread_rwlockattr_init>
10b0cb: 83 c4 10 add $0x10,%esp
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
return EINVAL;
10b0ce: b8 16 00 00 00 mov $0x16,%eax
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
10b0d3: 83 3e 00 cmpl $0x0,(%esi)
10b0d6: 74 6b je 10b143 <pthread_rwlock_init+0xa3><== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
10b0d8: 83 7e 04 00 cmpl $0x0,0x4(%esi)
10b0dc: 75 65 jne 10b143 <pthread_rwlock_init+0xa3><== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
10b0de: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b0e5: a1 50 83 12 00 mov 0x128350,%eax
10b0ea: 40 inc %eax
10b0eb: a3 50 83 12 00 mov %eax,0x128350
* the inactive chain of free RWLock control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void )
{
return (POSIX_RWLock_Control *)
_Objects_Allocate( &_POSIX_RWLock_Information );
10b0f0: 83 ec 0c sub $0xc,%esp
10b0f3: 68 34 85 12 00 push $0x128534
10b0f8: e8 33 23 00 00 call 10d430 <_Objects_Allocate>
10b0fd: 89 c6 mov %eax,%esi
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
10b0ff: 83 c4 10 add $0x10,%esp
10b102: 85 c0 test %eax,%eax
10b104: 75 0c jne 10b112 <pthread_rwlock_init+0x72>
_Thread_Enable_dispatch();
10b106: e8 f7 31 00 00 call 10e302 <_Thread_Enable_dispatch>
return EAGAIN;
10b10b: b8 0b 00 00 00 mov $0xb,%eax
10b110: eb 31 jmp 10b143 <pthread_rwlock_init+0xa3>
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
10b112: 50 push %eax
10b113: 50 push %eax
10b114: 8d 45 f4 lea -0xc(%ebp),%eax
10b117: 50 push %eax
10b118: 8d 46 10 lea 0x10(%esi),%eax
10b11b: 50 push %eax
10b11c: e8 7b 1b 00 00 call 10cc9c <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10b121: 8b 46 08 mov 0x8(%esi),%eax
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10b124: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10b127: 8b 15 50 85 12 00 mov 0x128550,%edx
10b12d: 89 34 8a mov %esi,(%edx,%ecx,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10b130: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi)
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
10b137: 89 03 mov %eax,(%ebx)
_Thread_Enable_dispatch();
10b139: e8 c4 31 00 00 call 10e302 <_Thread_Enable_dispatch>
return 0;
10b13e: 83 c4 10 add $0x10,%esp
10b141: 31 c0 xor %eax,%eax
}
10b143: 8d 65 f8 lea -0x8(%ebp),%esp
10b146: 5b pop %ebx
10b147: 5e pop %esi
10b148: c9 leave
10b149: c3 ret
0010b1b4 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10b1b4: 55 push %ebp
10b1b5: 89 e5 mov %esp,%ebp
10b1b7: 57 push %edi
10b1b8: 56 push %esi
10b1b9: 53 push %ebx
10b1ba: 83 ec 2c sub $0x2c,%esp
10b1bd: 8b 7d 08 mov 0x8(%ebp),%edi
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
return EINVAL;
10b1c0: bb 16 00 00 00 mov $0x16,%ebx
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
10b1c5: 85 ff test %edi,%edi
10b1c7: 0f 84 87 00 00 00 je 10b254 <pthread_rwlock_timedrdlock+0xa0>
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
10b1cd: 50 push %eax
10b1ce: 50 push %eax
10b1cf: 8d 45 e0 lea -0x20(%ebp),%eax
10b1d2: 50 push %eax
10b1d3: ff 75 0c pushl 0xc(%ebp)
10b1d6: e8 59 59 00 00 call 110b34 <_POSIX_Absolute_timeout_to_ticks>
10b1db: 89 c6 mov %eax,%esi
10b1dd: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10b1e0: 8d 45 e4 lea -0x1c(%ebp),%eax
10b1e3: 50 push %eax
10b1e4: ff 37 pushl (%edi)
10b1e6: 68 34 85 12 00 push $0x128534
10b1eb: e8 6c 26 00 00 call 10d85c <_Objects_Get>
switch ( location ) {
10b1f0: 83 c4 10 add $0x10,%esp
10b1f3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b1f7: 75 5b jne 10b254 <pthread_rwlock_timedrdlock+0xa0>
int _EXFUN(pthread_rwlock_init,
(pthread_rwlock_t *__rwlock, _CONST pthread_rwlockattr_t *__attr));
int _EXFUN(pthread_rwlock_destroy, (pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_rdlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_tryrdlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedrdlock,
10b1f9: 83 fe 03 cmp $0x3,%esi
10b1fc: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
10b1ff: 83 ec 0c sub $0xc,%esp
10b202: 6a 00 push $0x0
10b204: ff 75 e0 pushl -0x20(%ebp)
10b207: 0f b6 ca movzbl %dl,%ecx
10b20a: 51 push %ecx
10b20b: ff 37 pushl (%edi)
10b20d: 83 c0 10 add $0x10,%eax
10b210: 50 push %eax
10b211: 88 55 d4 mov %dl,-0x2c(%ebp)
10b214: e8 b7 1a 00 00 call 10ccd0 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10b219: 83 c4 20 add $0x20,%esp
10b21c: e8 e1 30 00 00 call 10e302 <_Thread_Enable_dispatch>
if ( !do_wait ) {
10b221: 8a 55 d4 mov -0x2c(%ebp),%dl
10b224: 84 d2 test %dl,%dl
10b226: 75 17 jne 10b23f <pthread_rwlock_timedrdlock+0x8b>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
10b228: a1 78 88 12 00 mov 0x128878,%eax
10b22d: 83 78 34 02 cmpl $0x2,0x34(%eax)
10b231: 75 0c jne 10b23f <pthread_rwlock_timedrdlock+0x8b>
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10b233: 85 f6 test %esi,%esi
10b235: 74 1d je 10b254 <pthread_rwlock_timedrdlock+0xa0><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b237: 4e dec %esi
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10b238: b3 74 mov $0x74,%bl
_Thread_Enable_dispatch();
if ( !do_wait ) {
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b23a: 83 fe 01 cmp $0x1,%esi
10b23d: 76 15 jbe 10b254 <pthread_rwlock_timedrdlock+0xa0><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b23f: 83 ec 0c sub $0xc,%esp
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
10b242: a1 78 88 12 00 mov 0x128878,%eax
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b247: ff 70 34 pushl 0x34(%eax)
10b24a: e8 bd 00 00 00 call 10b30c <_POSIX_RWLock_Translate_core_RWLock_return_code>
10b24f: 89 c3 mov %eax,%ebx
10b251: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b254: 89 d8 mov %ebx,%eax
10b256: 8d 65 f4 lea -0xc(%ebp),%esp
10b259: 5b pop %ebx
10b25a: 5e pop %esi
10b25b: 5f pop %edi
10b25c: c9 leave
10b25d: c3 ret
0010b260 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
10b260: 55 push %ebp
10b261: 89 e5 mov %esp,%ebp
10b263: 57 push %edi
10b264: 56 push %esi
10b265: 53 push %ebx
10b266: 83 ec 2c sub $0x2c,%esp
10b269: 8b 7d 08 mov 0x8(%ebp),%edi
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
return EINVAL;
10b26c: bb 16 00 00 00 mov $0x16,%ebx
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
10b271: 85 ff test %edi,%edi
10b273: 0f 84 87 00 00 00 je 10b300 <pthread_rwlock_timedwrlock+0xa0>
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
10b279: 50 push %eax
10b27a: 50 push %eax
10b27b: 8d 45 e0 lea -0x20(%ebp),%eax
10b27e: 50 push %eax
10b27f: ff 75 0c pushl 0xc(%ebp)
10b282: e8 ad 58 00 00 call 110b34 <_POSIX_Absolute_timeout_to_ticks>
10b287: 89 c6 mov %eax,%esi
10b289: 83 c4 0c add $0xc,%esp
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
10b28c: 8d 45 e4 lea -0x1c(%ebp),%eax
10b28f: 50 push %eax
10b290: ff 37 pushl (%edi)
10b292: 68 34 85 12 00 push $0x128534
10b297: e8 c0 25 00 00 call 10d85c <_Objects_Get>
switch ( location ) {
10b29c: 83 c4 10 add $0x10,%esp
10b29f: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b2a3: 75 5b jne 10b300 <pthread_rwlock_timedwrlock+0xa0>
(pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime));
int _EXFUN(pthread_rwlock_unlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_wrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_trywrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedwrlock,
10b2a5: 83 fe 03 cmp $0x3,%esi
10b2a8: 0f 94 c2 sete %dl
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
10b2ab: 83 ec 0c sub $0xc,%esp
10b2ae: 6a 00 push $0x0
10b2b0: ff 75 e0 pushl -0x20(%ebp)
10b2b3: 0f b6 ca movzbl %dl,%ecx
10b2b6: 51 push %ecx
10b2b7: ff 37 pushl (%edi)
10b2b9: 83 c0 10 add $0x10,%eax
10b2bc: 50 push %eax
10b2bd: 88 55 d4 mov %dl,-0x2c(%ebp)
10b2c0: e8 c3 1a 00 00 call 10cd88 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
10b2c5: 83 c4 20 add $0x20,%esp
10b2c8: e8 35 30 00 00 call 10e302 <_Thread_Enable_dispatch>
if ( !do_wait &&
10b2cd: 8a 55 d4 mov -0x2c(%ebp),%dl
10b2d0: 84 d2 test %dl,%dl
10b2d2: 75 17 jne 10b2eb <pthread_rwlock_timedwrlock+0x8b>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
10b2d4: a1 78 88 12 00 mov 0x128878,%eax
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
10b2d9: 83 78 34 02 cmpl $0x2,0x34(%eax)
10b2dd: 75 0c jne 10b2eb <pthread_rwlock_timedwrlock+0x8b>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
10b2df: 85 f6 test %esi,%esi
10b2e1: 74 1d je 10b300 <pthread_rwlock_timedwrlock+0xa0><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b2e3: 4e dec %esi
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
10b2e4: b3 74 mov $0x74,%bl
_Thread_Enable_dispatch();
if ( !do_wait &&
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
10b2e6: 83 fe 01 cmp $0x1,%esi
10b2e9: 76 15 jbe 10b300 <pthread_rwlock_timedwrlock+0xa0><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b2eb: 83 ec 0c sub $0xc,%esp
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
10b2ee: a1 78 88 12 00 mov 0x128878,%eax
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
10b2f3: ff 70 34 pushl 0x34(%eax)
10b2f6: e8 11 00 00 00 call 10b30c <_POSIX_RWLock_Translate_core_RWLock_return_code>
10b2fb: 89 c3 mov %eax,%ebx
10b2fd: 83 c4 10 add $0x10,%esp
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
10b300: 89 d8 mov %ebx,%eax
10b302: 8d 65 f4 lea -0xc(%ebp),%esp
10b305: 5b pop %ebx
10b306: 5e pop %esi
10b307: 5f pop %edi
10b308: c9 leave
10b309: c3 ret
0010ba48 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
10ba48: 55 push %ebp
10ba49: 89 e5 mov %esp,%ebp
10ba4b: 8b 55 08 mov 0x8(%ebp),%edx
10ba4e: 8b 4d 0c mov 0xc(%ebp),%ecx
if ( !attr )
return EINVAL;
10ba51: b8 16 00 00 00 mov $0x16,%eax
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
10ba56: 85 d2 test %edx,%edx
10ba58: 74 0f je 10ba69 <pthread_rwlockattr_setpshared+0x21>
return EINVAL;
if ( !attr->is_initialized )
10ba5a: 83 3a 00 cmpl $0x0,(%edx)
10ba5d: 74 0a je 10ba69 <pthread_rwlockattr_setpshared+0x21>
return EINVAL;
switch ( pshared ) {
10ba5f: 83 f9 01 cmp $0x1,%ecx
10ba62: 77 05 ja 10ba69 <pthread_rwlockattr_setpshared+0x21><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
10ba64: 89 4a 04 mov %ecx,0x4(%edx)
return 0;
10ba67: 30 c0 xor %al,%al
default:
return EINVAL;
}
}
10ba69: c9 leave
10ba6a: c3 ret
0010c748 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
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 2c sub $0x2c,%esp
10c751: 8b 75 10 mov 0x10(%ebp),%esi
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
10c754: c7 45 d4 16 00 00 00 movl $0x16,-0x2c(%ebp)
int rc;
/*
* Check all the parameters
*/
if ( !param )
10c75b: 85 f6 test %esi,%esi
10c75d: 0f 84 00 01 00 00 je 10c863 <pthread_setschedparam+0x11b>
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
10c763: 8d 45 e0 lea -0x20(%ebp),%eax
10c766: 50 push %eax
10c767: 8d 45 e4 lea -0x1c(%ebp),%eax
10c76a: 50 push %eax
10c76b: 56 push %esi
10c76c: ff 75 0c pushl 0xc(%ebp)
10c76f: e8 20 53 00 00 call 111a94 <_POSIX_Thread_Translate_sched_param>
10c774: 89 45 d4 mov %eax,-0x2c(%ebp)
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
10c777: 83 c4 10 add $0x10,%esp
10c77a: 85 c0 test %eax,%eax
10c77c: 0f 85 e1 00 00 00 jne 10c863 <pthread_setschedparam+0x11b>
10c782: 53 push %ebx
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _POSIX_Threads_Get( thread, &location );
10c783: 8d 45 dc lea -0x24(%ebp),%eax
10c786: 50 push %eax
10c787: ff 75 08 pushl 0x8(%ebp)
10c78a: 68 d4 95 12 00 push $0x1295d4
10c78f: e8 80 1c 00 00 call 10e414 <_Objects_Get>
10c794: 89 c2 mov %eax,%edx
switch ( location ) {
10c796: 83 c4 10 add $0x10,%esp
10c799: 83 7d dc 00 cmpl $0x0,-0x24(%ebp)
10c79d: 0f 85 b9 00 00 00 jne 10c85c <pthread_setschedparam+0x114>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10c7a3: 8b 98 ec 00 00 00 mov 0xec(%eax),%ebx
if ( api->schedpolicy == SCHED_SPORADIC )
10c7a9: 83 bb 84 00 00 00 04 cmpl $0x4,0x84(%ebx)
10c7b0: 75 18 jne 10c7ca <pthread_setschedparam+0x82>
(void) _Watchdog_Remove( &api->Sporadic_timer );
10c7b2: 83 ec 0c sub $0xc,%esp
10c7b5: 8d 83 a8 00 00 00 lea 0xa8(%ebx),%eax
10c7bb: 50 push %eax
10c7bc: 89 55 d0 mov %edx,-0x30(%ebp)
10c7bf: e8 58 35 00 00 call 10fd1c <_Watchdog_Remove>
10c7c4: 83 c4 10 add $0x10,%esp
10c7c7: 8b 55 d0 mov -0x30(%ebp),%edx
api->schedpolicy = policy;
10c7ca: 8b 45 0c mov 0xc(%ebp),%eax
10c7cd: 89 83 84 00 00 00 mov %eax,0x84(%ebx)
api->schedparam = *param;
10c7d3: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi
10c7d9: b9 07 00 00 00 mov $0x7,%ecx
10c7de: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
the_thread->budget_algorithm = budget_algorithm;
10c7e0: 8b 45 e4 mov -0x1c(%ebp),%eax
10c7e3: 89 42 7c mov %eax,0x7c(%edx)
the_thread->budget_callout = budget_callout;
10c7e6: 8b 45 e0 mov -0x20(%ebp),%eax
10c7e9: 89 82 80 00 00 00 mov %eax,0x80(%edx)
switch ( api->schedpolicy ) {
10c7ef: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
10c7f3: 78 60 js 10c855 <pthread_setschedparam+0x10d><== NEVER TAKEN
10c7f5: 83 7d 0c 02 cmpl $0x2,0xc(%ebp)
10c7f9: 7e 08 jle 10c803 <pthread_setschedparam+0xbb>
10c7fb: 83 7d 0c 04 cmpl $0x4,0xc(%ebp)
10c7ff: 75 54 jne 10c855 <pthread_setschedparam+0x10d><== NEVER TAKEN
10c801: eb 24 jmp 10c827 <pthread_setschedparam+0xdf>
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
10c803: a1 80 93 12 00 mov 0x129380,%eax
10c808: 89 42 78 mov %eax,0x78(%edx)
10c80b: 0f b6 05 48 52 12 00 movzbl 0x125248,%eax
10c812: 2b 83 88 00 00 00 sub 0x88(%ebx),%eax
the_thread->real_priority =
10c818: 89 42 18 mov %eax,0x18(%edx)
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
10c81b: 51 push %ecx
10c81c: 6a 01 push $0x1
10c81e: 50 push %eax
10c81f: 52 push %edx
10c820: e8 bf 22 00 00 call 10eae4 <_Thread_Change_priority>
10c825: eb 2b jmp 10c852 <pthread_setschedparam+0x10a>
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
10c827: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax
10c82d: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx)
_Watchdog_Remove( &api->Sporadic_timer );
10c833: 83 ec 0c sub $0xc,%esp
10c836: 81 c3 a8 00 00 00 add $0xa8,%ebx
10c83c: 53 push %ebx
10c83d: 89 55 d0 mov %edx,-0x30(%ebp)
10c840: e8 d7 34 00 00 call 10fd1c <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
10c845: 58 pop %eax
10c846: 5a pop %edx
10c847: 8b 55 d0 mov -0x30(%ebp),%edx
10c84a: 52 push %edx
10c84b: 6a 00 push $0x0
10c84d: e8 e1 fd ff ff call 10c633 <_POSIX_Threads_Sporadic_budget_TSR>
break;
10c852: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10c855: e8 60 26 00 00 call 10eeba <_Thread_Enable_dispatch>
return 0;
10c85a: eb 07 jmp 10c863 <pthread_setschedparam+0x11b>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
10c85c: c7 45 d4 03 00 00 00 movl $0x3,-0x2c(%ebp)
}
10c863: 8b 45 d4 mov -0x2c(%ebp),%eax
10c866: 8d 65 f4 lea -0xc(%ebp),%esp
10c869: 5b pop %ebx
10c86a: 5e pop %esi
10c86b: 5f pop %edi
10c86c: c9 leave
10c86d: c3 ret
0010a644 <pthread_testcancel>:
*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
10a644: 55 push %ebp
10a645: 89 e5 mov %esp,%ebp
10a647: 53 push %ebx
10a648: 83 ec 04 sub $0x4,%esp
* Don't even think about deleting a resource from an ISR.
* Besides this request is supposed to be for _Thread_Executing
* and the ISR context is not a thread.
*/
if ( _ISR_Is_in_progress() )
10a64b: 83 3d 6c 68 12 00 00 cmpl $0x0,0x12686c
10a652: 75 48 jne 10a69c <pthread_testcancel+0x58><== NEVER TAKEN
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
10a654: a1 70 68 12 00 mov 0x126870,%eax
10a659: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax
10a65f: 8b 15 48 63 12 00 mov 0x126348,%edx
10a665: 42 inc %edx
10a666: 89 15 48 63 12 00 mov %edx,0x126348
*/
void pthread_testcancel( void )
{
POSIX_API_Control *thread_support;
bool cancel = false;
10a66c: 31 db xor %ebx,%ebx
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
10a66e: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax)
10a675: 75 0a jne 10a681 <pthread_testcancel+0x3d><== NEVER TAKEN
/* Setting Cancelability State, P1003.1c/Draft 10, p. 183 */
int _EXFUN(pthread_setcancelstate, (int __state, int *__oldstate));
int _EXFUN(pthread_setcanceltype, (int __type, int *__oldtype));
void _EXFUN(pthread_testcancel, (void));
10a677: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax)
10a67e: 0f 95 c3 setne %bl
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
10a681: e8 d8 25 00 00 call 10cc5e <_Thread_Enable_dispatch>
if ( cancel )
10a686: 84 db test %bl,%bl
10a688: 74 12 je 10a69c <pthread_testcancel+0x58>
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
10a68a: 50 push %eax
10a68b: 50 push %eax
10a68c: 6a ff push $0xffffffff
10a68e: ff 35 70 68 12 00 pushl 0x126870
10a694: e8 bb 52 00 00 call 10f954 <_POSIX_Thread_Exit>
10a699: 83 c4 10 add $0x10,%esp
}
10a69c: 8b 5d fc mov -0x4(%ebp),%ebx
10a69f: c9 leave
10a6a0: c3 ret
0011d0a4 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
11d0a4: 55 push %ebp
11d0a5: 89 e5 mov %esp,%ebp
11d0a7: 56 push %esi
11d0a8: 53 push %ebx
11d0a9: 8b 5d 08 mov 0x8(%ebp),%ebx
11d0ac: 8b 55 0c mov 0xc(%ebp),%edx
11d0af: 8b 4d 10 mov 0x10(%ebp),%ecx
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
11d0b2: 3b 1d 44 11 12 00 cmp 0x121144,%ebx
11d0b8: 73 14 jae 11d0ce <read+0x2a> <== NEVER TAKEN
iop = rtems_libio_iop( fd );
11d0ba: 6b db 38 imul $0x38,%ebx,%ebx
11d0bd: 03 1d f8 51 12 00 add 0x1251f8,%ebx
rtems_libio_check_is_open( iop );
11d0c3: 8b 73 14 mov 0x14(%ebx),%esi
11d0c6: f7 c6 00 01 00 00 test $0x100,%esi
11d0cc: 75 0d jne 11d0db <read+0x37>
11d0ce: e8 f9 3f ff ff call 1110cc <__errno>
11d0d3: c7 00 09 00 00 00 movl $0x9,(%eax)
11d0d9: eb 1a jmp 11d0f5 <read+0x51>
rtems_libio_check_buffer( buffer );
11d0db: 85 d2 test %edx,%edx
11d0dd: 74 0b je 11d0ea <read+0x46> <== NEVER TAKEN
rtems_libio_check_count( count );
11d0df: 31 c0 xor %eax,%eax
11d0e1: 85 c9 test %ecx,%ecx
11d0e3: 74 31 je 11d116 <read+0x72>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
11d0e5: 83 e6 02 and $0x2,%esi
11d0e8: 75 10 jne 11d0fa <read+0x56>
11d0ea: e8 dd 3f ff ff call 1110cc <__errno>
11d0ef: c7 00 16 00 00 00 movl $0x16,(%eax)
11d0f5: 83 c8 ff or $0xffffffff,%eax
11d0f8: eb 1c jmp 11d116 <read+0x72>
/*
* Now process the read().
*/
rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
11d0fa: 50 push %eax
11d0fb: 8b 43 20 mov 0x20(%ebx),%eax
11d0fe: 51 push %ecx
11d0ff: 52 push %edx
11d100: 53 push %ebx
11d101: ff 50 08 call *0x8(%eax)
if ( rc > 0 )
11d104: 83 c4 10 add $0x10,%esp
11d107: 85 c0 test %eax,%eax
11d109: 7e 0b jle 11d116 <read+0x72>
iop->offset += rc;
11d10b: 89 c1 mov %eax,%ecx
11d10d: c1 f9 1f sar $0x1f,%ecx
11d110: 01 43 0c add %eax,0xc(%ebx)
11d113: 11 4b 10 adc %ecx,0x10(%ebx)
return rc;
}
11d116: 8d 65 f8 lea -0x8(%ebp),%esp
11d119: 5b pop %ebx
11d11a: 5e pop %esi
11d11b: c9 leave
11d11c: c3 ret
00109ea4 <readlink>:
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
109ea4: 55 push %ebp
109ea5: 89 e5 mov %esp,%ebp
109ea7: 57 push %edi
109ea8: 56 push %esi
109ea9: 53 push %ebx
109eaa: 83 ec 2c sub $0x2c,%esp
109ead: 8b 55 08 mov 0x8(%ebp),%edx
109eb0: 8b 5d 0c mov 0xc(%ebp),%ebx
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
109eb3: 85 db test %ebx,%ebx
109eb5: 75 10 jne 109ec7 <readlink+0x23>
rtems_set_errno_and_return_minus_one( EFAULT );
109eb7: e8 1c 99 00 00 call 1137d8 <__errno>
109ebc: c7 00 0e 00 00 00 movl $0xe,(%eax)
109ec2: 83 cf ff or $0xffffffff,%edi
109ec5: eb 69 jmp 109f30 <readlink+0x8c>
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
109ec7: 31 c0 xor %eax,%eax
109ec9: 83 c9 ff or $0xffffffff,%ecx
109ecc: 89 d7 mov %edx,%edi
109ece: f2 ae repnz scas %es:(%edi),%al
109ed0: f7 d1 not %ecx
109ed2: 49 dec %ecx
109ed3: 83 ec 0c sub $0xc,%esp
109ed6: 6a 00 push $0x0
109ed8: 8d 75 d4 lea -0x2c(%ebp),%esi
109edb: 56 push %esi
109edc: 6a 00 push $0x0
109ede: 51 push %ecx
109edf: 52 push %edx
109ee0: e8 6d f0 ff ff call 108f52 <rtems_filesystem_evaluate_path>
0, &loc, false );
if ( result != 0 )
109ee5: 83 c4 20 add $0x20,%esp
return -1;
109ee8: 83 cf ff or $0xffffffff,%edi
if (!buf)
rtems_set_errno_and_return_minus_one( EFAULT );
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
0, &loc, false );
if ( result != 0 )
109eeb: 85 c0 test %eax,%eax
109eed: 75 41 jne 109f30 <readlink+0x8c> <== NEVER TAKEN
return -1;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
109eef: 83 ec 0c sub $0xc,%esp
109ef2: 56 push %esi
109ef3: 8b 45 e0 mov -0x20(%ebp),%eax
109ef6: ff 50 10 call *0x10(%eax)
109ef9: 83 c4 10 add $0x10,%esp
109efc: 83 f8 04 cmp $0x4,%eax
109eff: 74 16 je 109f17 <readlink+0x73>
rtems_filesystem_freenode( &loc );
109f01: 83 ec 0c sub $0xc,%esp
109f04: 56 push %esi
109f05: e8 06 f1 ff ff call 109010 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EINVAL );
109f0a: e8 c9 98 00 00 call 1137d8 <__errno>
109f0f: c7 00 16 00 00 00 movl $0x16,(%eax)
109f15: eb 16 jmp 109f2d <readlink+0x89>
}
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
109f17: 50 push %eax
109f18: ff 75 10 pushl 0x10(%ebp)
109f1b: 53 push %ebx
109f1c: 56 push %esi
109f1d: 8b 45 e0 mov -0x20(%ebp),%eax
109f20: ff 50 3c call *0x3c(%eax)
109f23: 89 c7 mov %eax,%edi
rtems_filesystem_freenode( &loc );
109f25: 89 34 24 mov %esi,(%esp)
109f28: e8 e3 f0 ff ff call 109010 <rtems_filesystem_freenode>
return result;
109f2d: 83 c4 10 add $0x10,%esp
}
109f30: 89 f8 mov %edi,%eax
109f32: 8d 65 f4 lea -0xc(%ebp),%esp
109f35: 5b pop %ebx
109f36: 5e pop %esi
109f37: 5f pop %edi
109f38: c9 leave
109f39: c3 ret
00108c54 <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
108c54: 55 push %ebp
108c55: 89 e5 mov %esp,%ebp
108c57: 57 push %edi
108c58: 56 push %esi
108c59: 53 push %ebx
108c5a: 83 ec 2c sub $0x2c,%esp
108c5d: 8b 75 08 mov 0x8(%ebp),%esi
108c60: 8b 7d 0c mov 0xc(%ebp),%edi
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
108c63: 3b 35 44 21 12 00 cmp 0x122144,%esi
108c69: 73 11 jae 108c7c <readv+0x28>
iop = rtems_libio_iop( fd );
108c6b: 6b f6 38 imul $0x38,%esi,%esi
108c6e: 03 35 f8 61 12 00 add 0x1261f8,%esi
rtems_libio_check_is_open( iop );
108c74: 8b 46 14 mov 0x14(%esi),%eax
108c77: f6 c4 01 test $0x1,%ah
108c7a: 75 10 jne 108c8c <readv+0x38>
108c7c: e8 1b 90 00 00 call 111c9c <__errno>
108c81: c7 00 09 00 00 00 movl $0x9,(%eax)
108c87: e9 a4 00 00 00 jmp 108d30 <readv+0xdc>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
108c8c: a8 02 test $0x2,%al
108c8e: 74 35 je 108cc5 <readv+0x71> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
108c90: 85 ff test %edi,%edi
108c92: 74 31 je 108cc5 <readv+0x71>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
108c94: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
108c98: 7e 2b jle 108cc5 <readv+0x71>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
108c9a: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp)
108ca1: 7f 22 jg 108cc5 <readv+0x71> <== NEVER TAKEN
108ca3: b2 01 mov $0x1,%dl
108ca5: 31 c0 xor %eax,%eax
108ca7: 31 c9 xor %ecx,%ecx
108ca9: 89 75 d4 mov %esi,-0x2c(%ebp)
108cac: eb 03 jmp 108cb1 <readv+0x5d>
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
108cae: 8b 4d e4 mov -0x1c(%ebp),%ecx
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
108cb1: 83 3c c7 00 cmpl $0x0,(%edi,%eax,8)
108cb5: 74 0e je 108cc5 <readv+0x71>
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
108cb7: 8b 5c c7 04 mov 0x4(%edi,%eax,8),%ebx
108cbb: 8d 34 19 lea (%ecx,%ebx,1),%esi
108cbe: 89 75 e4 mov %esi,-0x1c(%ebp)
if ( total < old )
108cc1: 39 ce cmp %ecx,%esi
108cc3: 7d 0d jge 108cd2 <readv+0x7e>
rtems_set_errno_and_return_minus_one( EINVAL );
108cc5: e8 d2 8f 00 00 call 111c9c <__errno>
108cca: c7 00 16 00 00 00 movl $0x16,(%eax)
108cd0: eb 5e jmp 108d30 <readv+0xdc>
if ( iov[v].iov_len )
all_zeros = false;
108cd2: 85 db test %ebx,%ebx
108cd4: 0f 94 c1 sete %cl
108cd7: f7 d9 neg %ecx
108cd9: 21 ca and %ecx,%edx
* are obvious errors in the iovec. So this extra loop ensures
* that we do not do anything if there is an argument error.
*/
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
108cdb: 40 inc %eax
108cdc: 3b 45 10 cmp 0x10(%ebp),%eax
108cdf: 7c cd jl 108cae <readv+0x5a>
108ce1: 8b 75 d4 mov -0x2c(%ebp),%esi
* A readv with all zeros logically has no effect. Even though
* OpenGroup didn't address this case as they did with writev(),
* we will handle it the same way for symmetry.
*/
if ( all_zeros == true ) {
return 0;
108ce4: 31 db xor %ebx,%ebx
/*
* A readv with all zeros logically has no effect. Even though
* OpenGroup didn't address this case as they did with writev(),
* we will handle it the same way for symmetry.
*/
if ( all_zeros == true ) {
108ce6: 84 d2 test %dl,%dl
108ce8: 75 49 jne 108d33 <readv+0xdf>
108cea: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
108cf1: 50 push %eax
108cf2: 8b 46 20 mov 0x20(%esi),%eax
108cf5: 8b 55 e4 mov -0x1c(%ebp),%edx
108cf8: ff 74 d7 04 pushl 0x4(%edi,%edx,8)
108cfc: ff 34 d7 pushl (%edi,%edx,8)
108cff: 56 push %esi
108d00: ff 50 08 call *0x8(%eax)
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
108d03: 83 c4 10 add $0x10,%esp
108d06: 83 f8 00 cmp $0x0,%eax
108d09: 7c 25 jl 108d30 <readv+0xdc> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
108d0b: 74 0d je 108d1a <readv+0xc6> <== NEVER TAKEN
iop->offset += bytes;
108d0d: 89 c1 mov %eax,%ecx
108d0f: c1 f9 1f sar $0x1f,%ecx
108d12: 01 46 0c add %eax,0xc(%esi)
108d15: 11 4e 10 adc %ecx,0x10(%esi)
total += bytes;
108d18: 01 c3 add %eax,%ebx
}
if (bytes != iov[ v ].iov_len)
108d1a: 8b 55 e4 mov -0x1c(%ebp),%edx
108d1d: 3b 44 d7 04 cmp 0x4(%edi,%edx,8),%eax
108d21: 75 10 jne 108d33 <readv+0xdf> <== NEVER TAKEN
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
108d23: 42 inc %edx
108d24: 89 55 e4 mov %edx,-0x1c(%ebp)
108d27: 8b 45 10 mov 0x10(%ebp),%eax
108d2a: 39 c2 cmp %eax,%edx
108d2c: 7c c3 jl 108cf1 <readv+0x9d>
108d2e: eb 03 jmp 108d33 <readv+0xdf>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
108d30: 83 cb ff or $0xffffffff,%ebx
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
108d33: 89 d8 mov %ebx,%eax
108d35: 8d 65 f4 lea -0xc(%ebp),%esp
108d38: 5b pop %ebx
108d39: 5e pop %esi
108d3a: 5f pop %edi
108d3b: c9 leave
108d3c: c3 ret
0011d1a8 <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
11d1a8: 55 push %ebp
11d1a9: 89 e5 mov %esp,%ebp
11d1ab: 57 push %edi
11d1ac: 56 push %esi
11d1ad: 53 push %ebx
11d1ae: 83 ec 2c sub $0x2c,%esp
11d1b1: 8b 5d 08 mov 0x8(%ebp),%ebx
11d1b4: 8b 75 0c mov 0xc(%ebp),%esi
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
11d1b7: ff 05 20 52 12 00 incl 0x125220
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
11d1bd: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c
11d1c4: 75 1a jne 11d1e0 <realloc+0x38> <== NEVER TAKEN
if (_Thread_Dispatch_disable_level > 0)
11d1c6: a1 40 53 12 00 mov 0x125340,%eax
11d1cb: 85 c0 test %eax,%eax
11d1cd: 0f 85 ad 00 00 00 jne 11d280 <realloc+0xd8> <== NEVER TAKEN
return (void *) 0;
if (_ISR_Nest_level > 0)
11d1d3: 83 3d 64 58 12 00 00 cmpl $0x0,0x125864
11d1da: 0f 85 a0 00 00 00 jne 11d280 <realloc+0xd8> <== NEVER TAKEN
}
/*
* Continue with realloc().
*/
if ( !ptr )
11d1e0: 85 db test %ebx,%ebx
11d1e2: 75 13 jne 11d1f7 <realloc+0x4f>
return malloc( size );
11d1e4: 83 ec 0c sub $0xc,%esp
11d1e7: 56 push %esi
11d1e8: e8 f7 a3 fe ff call 1075e4 <malloc>
11d1ed: 89 c3 mov %eax,%ebx
11d1ef: 83 c4 10 add $0x10,%esp
11d1f2: e9 8b 00 00 00 jmp 11d282 <realloc+0xda>
if ( !size ) {
11d1f7: 85 f6 test %esi,%esi
11d1f9: 75 0e jne 11d209 <realloc+0x61> <== ALWAYS TAKEN
free( ptr );
11d1fb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
11d1fe: 53 push %ebx <== NOT EXECUTED
11d1ff: e8 44 a1 fe ff call 107348 <free> <== NOT EXECUTED
return (void *) 0;
11d204: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
11d207: eb 77 jmp 11d280 <realloc+0xd8> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
11d209: 52 push %edx
11d20a: 8d 45 e4 lea -0x1c(%ebp),%eax
11d20d: 50 push %eax
11d20e: 53 push %ebx
11d20f: ff 35 80 11 12 00 pushl 0x121180
11d215: e8 ee 00 00 00 call 11d308 <_Protected_heap_Get_block_size>
11d21a: 83 c4 10 add $0x10,%esp
11d21d: 84 c0 test %al,%al
11d21f: 75 0d jne 11d22e <realloc+0x86>
errno = EINVAL;
11d221: e8 a6 3e ff ff call 1110cc <__errno>
11d226: c7 00 16 00 00 00 movl $0x16,(%eax)
11d22c: eb 52 jmp 11d280 <realloc+0xd8>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
11d22e: 50 push %eax
11d22f: 56 push %esi
11d230: 53 push %ebx
11d231: ff 35 80 11 12 00 pushl 0x121180
11d237: e8 04 01 00 00 call 11d340 <_Protected_heap_Resize_block>
11d23c: 83 c4 10 add $0x10,%esp
11d23f: 84 c0 test %al,%al
11d241: 75 3f jne 11d282 <realloc+0xda>
* 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 );
11d243: 83 ec 0c sub $0xc,%esp
11d246: 56 push %esi
11d247: e8 98 a3 fe ff call 1075e4 <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
11d24c: ff 0d 14 52 12 00 decl 0x125214
if ( !new_area ) {
11d252: 83 c4 10 add $0x10,%esp
11d255: 85 c0 test %eax,%eax
11d257: 74 27 je 11d280 <realloc+0xd8>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
11d259: 8b 55 e4 mov -0x1c(%ebp),%edx
11d25c: 89 f1 mov %esi,%ecx
11d25e: 39 d6 cmp %edx,%esi
11d260: 76 02 jbe 11d264 <realloc+0xbc> <== NEVER TAKEN
11d262: 89 d1 mov %edx,%ecx
11d264: 89 c7 mov %eax,%edi
11d266: 89 de mov %ebx,%esi
11d268: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
free( ptr );
11d26a: 83 ec 0c sub $0xc,%esp
11d26d: 53 push %ebx
11d26e: 89 45 d4 mov %eax,-0x2c(%ebp)
11d271: e8 d2 a0 fe ff call 107348 <free>
return new_area;
11d276: 83 c4 10 add $0x10,%esp
11d279: 8b 45 d4 mov -0x2c(%ebp),%eax
11d27c: 89 c3 mov %eax,%ebx
11d27e: eb 02 jmp 11d282 <realloc+0xda>
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
return (void *) 0;
11d280: 31 db xor %ebx,%ebx
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
11d282: 89 d8 mov %ebx,%eax
11d284: 8d 65 f4 lea -0xc(%ebp),%esp
11d287: 5b pop %ebx
11d288: 5e pop %esi
11d289: 5f pop %edi
11d28a: c9 leave
11d28b: c3 ret
00108390 <rmdir>:
#include <rtems/seterr.h>
int rmdir(
const char *pathname
)
{
108390: 55 push %ebp
108391: 89 e5 mov %esp,%ebp
108393: 57 push %edi
108394: 56 push %esi
108395: 53 push %ebx
108396: 83 ec 58 sub $0x58,%esp
/*
* Get the parent node of the node we wish to remove. Find the parent path.
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
108399: ff 75 08 pushl 0x8(%ebp)
10839c: e8 fe f2 ff ff call 10769f <rtems_filesystem_dirname>
1083a1: 89 45 b4 mov %eax,-0x4c(%ebp)
if ( parentpathlen == 0 )
1083a4: 83 c4 10 add $0x10,%esp
1083a7: 85 c0 test %eax,%eax
1083a9: 8d 45 d0 lea -0x30(%ebp),%eax
1083ac: 75 15 jne 1083c3 <rmdir+0x33>
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
1083ae: 51 push %ecx
1083af: 50 push %eax
1083b0: 8d 45 e4 lea -0x1c(%ebp),%eax
1083b3: 50 push %eax
1083b4: ff 75 08 pushl 0x8(%ebp)
1083b7: e8 08 01 00 00 call 1084c4 <rtems_filesystem_get_start_loc>
1083bc: 83 c4 10 add $0x10,%esp
const char *name;
rtems_filesystem_location_info_t parentloc;
rtems_filesystem_location_info_t loc;
int i;
int result;
bool free_parentloc = false;
1083bf: 31 db xor %ebx,%ebx
1083c1: eb 25 jmp 1083e8 <rmdir+0x58>
parentpathlen = rtems_filesystem_dirname ( pathname );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
1083c3: 83 ec 0c sub $0xc,%esp
1083c6: 6a 00 push $0x0
1083c8: 50 push %eax
1083c9: 6a 02 push $0x2
1083cb: ff 75 b4 pushl -0x4c(%ebp)
1083ce: ff 75 08 pushl 0x8(%ebp)
1083d1: e8 88 f2 ff ff call 10765e <rtems_filesystem_evaluate_path>
1083d6: 89 c2 mov %eax,%edx
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
1083d8: 83 c4 20 add $0x20,%esp
return -1;
1083db: 83 c8 ff or $0xffffffff,%eax
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
1083de: 85 d2 test %edx,%edx
1083e0: 0f 85 d6 00 00 00 jne 1084bc <rmdir+0x12c> <== NEVER TAKEN
return -1;
free_parentloc = true;
1083e6: b3 01 mov $0x1,%bl
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
1083e8: 8d 7d bc lea -0x44(%ebp),%edi
1083eb: 8d 75 d0 lea -0x30(%ebp),%esi
1083ee: b9 05 00 00 00 mov $0x5,%ecx
1083f3: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
name = pathname + parentpathlen;
1083f5: 8b 75 08 mov 0x8(%ebp),%esi
1083f8: 03 75 b4 add -0x4c(%ebp),%esi
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
1083fb: 83 c9 ff or $0xffffffff,%ecx
1083fe: 89 f7 mov %esi,%edi
108400: 31 c0 xor %eax,%eax
108402: f2 ae repnz scas %es:(%edi),%al
108404: f7 d1 not %ecx
108406: 49 dec %ecx
108407: 52 push %edx
108408: 52 push %edx
108409: 51 push %ecx
10840a: 56 push %esi
10840b: e8 ce f2 ff ff call 1076de <rtems_filesystem_prefix_separators>
108410: 01 c6 add %eax,%esi
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
108412: 83 c9 ff or $0xffffffff,%ecx
108415: 89 f7 mov %esi,%edi
108417: 31 c0 xor %eax,%eax
108419: f2 ae repnz scas %es:(%edi),%al
10841b: f7 d1 not %ecx
10841d: 49 dec %ecx
10841e: c7 04 24 00 00 00 00 movl $0x0,(%esp)
108425: 8d 7d bc lea -0x44(%ebp),%edi
108428: 57 push %edi
108429: 6a 00 push $0x0
10842b: 51 push %ecx
10842c: 56 push %esi
10842d: e8 ce f1 ff ff call 107600 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
108432: 83 c4 20 add $0x20,%esp
108435: 85 c0 test %eax,%eax
108437: 74 13 je 10844c <rmdir+0xbc>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
108439: 83 c8 ff or $0xffffffff,%eax
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
10843c: 84 db test %bl,%bl
10843e: 74 7c je 1084bc <rmdir+0x12c>
rtems_filesystem_freenode( &parentloc );
108440: 83 ec 0c sub $0xc,%esp
108443: 8d 55 d0 lea -0x30(%ebp),%edx
108446: 52 push %edx
108447: 89 45 b0 mov %eax,-0x50(%ebp)
10844a: eb 65 jmp 1084b1 <rmdir+0x121>
}
/*
* Verify you can remove this node as a directory.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
10844c: 83 ec 0c sub $0xc,%esp
10844f: 57 push %edi
108450: 8b 45 c8 mov -0x38(%ebp),%eax
108453: ff 50 10 call *0x10(%eax)
108456: 83 c4 10 add $0x10,%esp
108459: 48 dec %eax
10845a: 74 2f je 10848b <rmdir+0xfb>
rtems_filesystem_freenode( &loc );
10845c: 83 ec 0c sub $0xc,%esp
10845f: 57 push %edi
108460: e8 b7 f2 ff ff call 10771c <rtems_filesystem_freenode>
if ( free_parentloc )
108465: 83 c4 10 add $0x10,%esp
108468: 84 db test %bl,%bl
10846a: 74 0f je 10847b <rmdir+0xeb> <== NEVER TAKEN
rtems_filesystem_freenode( &parentloc );
10846c: 83 ec 0c sub $0xc,%esp
10846f: 8d 45 d0 lea -0x30(%ebp),%eax
108472: 50 push %eax
108473: e8 a4 f2 ff ff call 10771c <rtems_filesystem_freenode>
108478: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( ENOTDIR );
10847b: e8 dc 93 00 00 call 11185c <__errno>
108480: c7 00 14 00 00 00 movl $0x14,(%eax)
108486: 83 c8 ff or $0xffffffff,%eax
108489: eb 31 jmp 1084bc <rmdir+0x12c>
/*
* Use the filesystems rmnod to remove the node.
*/
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
10848b: 50 push %eax
10848c: 50 push %eax
10848d: 57 push %edi
10848e: 8d 75 d0 lea -0x30(%ebp),%esi
108491: 56 push %esi
108492: 8b 45 c4 mov -0x3c(%ebp),%eax
108495: ff 50 34 call *0x34(%eax)
rtems_filesystem_freenode( &loc );
108498: 89 3c 24 mov %edi,(%esp)
10849b: 89 45 b0 mov %eax,-0x50(%ebp)
10849e: e8 79 f2 ff ff call 10771c <rtems_filesystem_freenode>
if ( free_parentloc )
1084a3: 83 c4 10 add $0x10,%esp
1084a6: 84 db test %bl,%bl
1084a8: 8b 45 b0 mov -0x50(%ebp),%eax
1084ab: 74 0f je 1084bc <rmdir+0x12c>
rtems_filesystem_freenode( &parentloc );
1084ad: 83 ec 0c sub $0xc,%esp
1084b0: 56 push %esi
1084b1: e8 66 f2 ff ff call 10771c <rtems_filesystem_freenode>
1084b6: 83 c4 10 add $0x10,%esp
1084b9: 8b 45 b0 mov -0x50(%ebp),%eax
return result;
}
1084bc: 8d 65 f4 lea -0xc(%ebp),%esp
1084bf: 5b pop %ebx
1084c0: 5e pop %esi
1084c1: 5f pop %edi
1084c2: c9 leave
1084c3: c3 ret
0010af21 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
10af21: 55 push %ebp
10af22: 89 e5 mov %esp,%ebp
10af24: 57 push %edi
10af25: 56 push %esi
10af26: 53 push %ebx
10af27: 83 ec 58 sub $0x58,%esp
10af2a: 8b 5d 08 mov 0x8(%ebp),%ebx
struct sched_param param;
/* The queue should be initialized */
AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED);
result = pthread_mutex_lock (&aio_request_queue.mutex);
10af2d: 68 d8 72 12 00 push $0x1272d8
10af32: e8 c5 08 00 00 call 10b7fc <pthread_mutex_lock>
10af37: 89 45 b4 mov %eax,-0x4c(%ebp)
if (result != 0) {
10af3a: 83 c4 10 add $0x10,%esp
10af3d: 85 c0 test %eax,%eax
10af3f: 74 0e je 10af4f <rtems_aio_enqueue+0x2e><== ALWAYS TAKEN
free (req);
10af41: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10af44: 53 push %ebx <== NOT EXECUTED
10af45: e8 e6 cd ff ff call 107d30 <free> <== NOT EXECUTED
10af4a: e9 c6 01 00 00 jmp 10b115 <rtems_aio_enqueue+0x1f4><== NOT EXECUTED
return result;
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
10af4f: e8 a8 10 00 00 call 10bffc <pthread_self>
10af54: 57 push %edi
10af55: 8d 55 c4 lea -0x3c(%ebp),%edx
10af58: 52 push %edx
10af59: 8d 55 e0 lea -0x20(%ebp),%edx
10af5c: 52 push %edx
10af5d: 50 push %eax
10af5e: e8 9d 0c 00 00 call 10bc00 <pthread_getschedparam>
req->caller_thread = pthread_self ();
10af63: e8 94 10 00 00 call 10bffc <pthread_self>
10af68: 89 43 10 mov %eax,0x10(%ebx)
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
10af6b: 8b 43 14 mov 0x14(%ebx),%eax
10af6e: 8b 55 c4 mov -0x3c(%ebp),%edx
10af71: 2b 50 14 sub 0x14(%eax),%edx
10af74: 89 53 0c mov %edx,0xc(%ebx)
req->policy = policy;
10af77: 8b 55 e0 mov -0x20(%ebp),%edx
10af7a: 89 53 08 mov %edx,0x8(%ebx)
req->aiocbp->error_code = EINPROGRESS;
10af7d: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax)
req->aiocbp->return_value = 0;
10af84: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
if ((aio_request_queue.idle_threads == 0) &&
10af8b: 83 c4 10 add $0x10,%esp
10af8e: 83 3d 40 73 12 00 00 cmpl $0x0,0x127340
10af95: 0f 85 b7 00 00 00 jne 10b052 <rtems_aio_enqueue+0x131><== NEVER TAKEN
10af9b: 83 3d 3c 73 12 00 04 cmpl $0x4,0x12733c
10afa2: 0f 8f aa 00 00 00 jg 10b052 <rtems_aio_enqueue+0x131>
aio_request_queue.active_threads < AIO_MAX_THREADS)
/* we still have empty places on the active_threads chain */
{
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
10afa8: 56 push %esi
10afa9: 6a 01 push $0x1
10afab: ff 30 pushl (%eax)
10afad: 68 20 73 12 00 push $0x127320
10afb2: e8 81 fb ff ff call 10ab38 <rtems_aio_search_fd>
10afb7: 89 c6 mov %eax,%esi
if (r_chain->new_fd == 1) {
10afb9: 83 c4 10 add $0x10,%esp
10afbc: 83 78 18 01 cmpl $0x1,0x18(%eax)
10afc0: 8d 50 08 lea 0x8(%eax),%edx
10afc3: 8d 78 1c lea 0x1c(%eax),%edi
10afc6: 8d 40 20 lea 0x20(%eax),%eax
10afc9: 89 45 b0 mov %eax,-0x50(%ebp)
10afcc: 75 66 jne 10b034 <rtems_aio_enqueue+0x113>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
10afce: 51 push %ecx
10afcf: 51 push %ecx
10afd0: 53 push %ebx
10afd1: 52 push %edx
10afd2: e8 c9 1f 00 00 call 10cfa0 <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
10afd7: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi)
pthread_mutex_init (&r_chain->mutex, NULL);
10afde: 5b pop %ebx
10afdf: 58 pop %eax
10afe0: 6a 00 push $0x0
10afe2: 57 push %edi
10afe3: e8 f4 06 00 00 call 10b6dc <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10afe8: 5a pop %edx
10afe9: 59 pop %ecx
10afea: 6a 00 push $0x0
10afec: ff 75 b0 pushl -0x50(%ebp)
10afef: e8 a8 03 00 00 call 10b39c <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
10aff4: 56 push %esi
10aff5: 68 14 ac 10 00 push $0x10ac14
10affa: 68 e0 72 12 00 push $0x1272e0
10afff: 8d 45 e4 lea -0x1c(%ebp),%eax
10b002: 50 push %eax
10b003: e8 c4 09 00 00 call 10b9cc <pthread_create>
10b008: 89 c3 mov %eax,%ebx
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
10b00a: 83 c4 20 add $0x20,%esp
10b00d: 85 c0 test %eax,%eax
10b00f: 74 18 je 10b029 <rtems_aio_enqueue+0x108><== ALWAYS TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
10b011: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b014: 68 d8 72 12 00 push $0x1272d8 <== NOT EXECUTED
10b019: e8 5e 08 00 00 call 10b87c <pthread_mutex_unlock> <== NOT EXECUTED
return result;
10b01e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10b021: 89 5d b4 mov %ebx,-0x4c(%ebp) <== NOT EXECUTED
10b024: e9 ef 00 00 00 jmp 10b118 <rtems_aio_enqueue+0x1f7><== NOT EXECUTED
}
++aio_request_queue.active_threads;
10b029: ff 05 3c 73 12 00 incl 0x12733c
10b02f: e9 d4 00 00 00 jmp 10b108 <rtems_aio_enqueue+0x1e7>
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
10b034: 83 ec 0c sub $0xc,%esp
10b037: 57 push %edi
10b038: 89 55 ac mov %edx,-0x54(%ebp)
10b03b: e8 bc 07 00 00 call 10b7fc <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
10b040: 5e pop %esi
10b041: 58 pop %eax
10b042: 53 push %ebx
10b043: 8b 55 ac mov -0x54(%ebp),%edx
10b046: 52 push %edx
10b047: e8 ec fd ff ff call 10ae38 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
10b04c: 5b pop %ebx
10b04d: ff 75 b0 pushl -0x50(%ebp)
10b050: eb 36 jmp 10b088 <rtems_aio_enqueue+0x167>
else
{
/* the maximum number of threads has been already created
even though some of them might be idle.
The request belongs to one of the active fd chain */
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req,
10b052: 51 push %ecx
10b053: 6a 00 push $0x0
10b055: ff 30 pushl (%eax)
10b057: 68 20 73 12 00 push $0x127320
10b05c: e8 d7 fa ff ff call 10ab38 <rtems_aio_search_fd>
10b061: 89 c6 mov %eax,%esi
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
10b063: 83 c4 10 add $0x10,%esp
10b066: 85 c0 test %eax,%eax
10b068: 74 2d je 10b097 <rtems_aio_enqueue+0x176>
{
pthread_mutex_lock (&r_chain->mutex);
10b06a: 8d 78 1c lea 0x1c(%eax),%edi
10b06d: 83 ec 0c sub $0xc,%esp
10b070: 57 push %edi
10b071: e8 86 07 00 00 call 10b7fc <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
10b076: 58 pop %eax
10b077: 5a pop %edx
10b078: 53 push %ebx
10b079: 8d 46 08 lea 0x8(%esi),%eax
10b07c: 50 push %eax
10b07d: e8 b6 fd ff ff call 10ae38 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
10b082: 83 c6 20 add $0x20,%esi
10b085: 89 34 24 mov %esi,(%esp)
10b088: e8 ab 03 00 00 call 10b438 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
10b08d: 89 3c 24 mov %edi,(%esp)
10b090: e8 e7 07 00 00 call 10b87c <pthread_mutex_unlock>
10b095: eb 6e jmp 10b105 <rtems_aio_enqueue+0x1e4>
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
10b097: 56 push %esi
10b098: 6a 01 push $0x1
10b09a: 8b 43 14 mov 0x14(%ebx),%eax
10b09d: ff 30 pushl (%eax)
10b09f: 68 2c 73 12 00 push $0x12732c
10b0a4: e8 8f fa ff ff call 10ab38 <rtems_aio_search_fd>
10b0a9: 89 c6 mov %eax,%esi
if (r_chain->new_fd == 1) {
10b0ab: 83 c4 10 add $0x10,%esp
10b0ae: 83 78 18 01 cmpl $0x1,0x18(%eax)
10b0b2: 8d 40 08 lea 0x8(%eax),%eax
10b0b5: 75 2c jne 10b0e3 <rtems_aio_enqueue+0x1c2>
10b0b7: 51 push %ecx
10b0b8: 51 push %ecx
10b0b9: 53 push %ebx
10b0ba: 50 push %eax
10b0bb: e8 e0 1e 00 00 call 10cfa0 <_Chain_Insert>
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
10b0c0: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi)
pthread_mutex_init (&r_chain->mutex, NULL);
10b0c7: 58 pop %eax
10b0c8: 5a pop %edx
10b0c9: 6a 00 push $0x0
10b0cb: 8d 46 1c lea 0x1c(%esi),%eax
10b0ce: 50 push %eax
10b0cf: e8 08 06 00 00 call 10b6dc <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
10b0d4: 5b pop %ebx
10b0d5: 5f pop %edi
10b0d6: 6a 00 push $0x0
10b0d8: 83 c6 20 add $0x20,%esi
10b0db: 56 push %esi
10b0dc: e8 bb 02 00 00 call 10b39c <pthread_cond_init>
10b0e1: eb 09 jmp 10b0ec <rtems_aio_enqueue+0x1cb>
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
10b0e3: 51 push %ecx
10b0e4: 51 push %ecx
10b0e5: 53 push %ebx
10b0e6: 50 push %eax
10b0e7: e8 4c fd ff ff call 10ae38 <rtems_aio_insert_prio>
10b0ec: 83 c4 10 add $0x10,%esp
if (aio_request_queue.idle_threads > 0)
10b0ef: 83 3d 40 73 12 00 00 cmpl $0x0,0x127340
10b0f6: 7e 10 jle 10b108 <rtems_aio_enqueue+0x1e7><== ALWAYS TAKEN
pthread_cond_signal (&aio_request_queue.new_req);
10b0f8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10b0fb: 68 dc 72 12 00 push $0x1272dc <== NOT EXECUTED
10b100: e8 33 03 00 00 call 10b438 <pthread_cond_signal> <== NOT EXECUTED
10b105: 83 c4 10 add $0x10,%esp
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
10b108: 83 ec 0c sub $0xc,%esp
10b10b: 68 d8 72 12 00 push $0x1272d8
10b110: e8 67 07 00 00 call 10b87c <pthread_mutex_unlock>
return 0;
10b115: 83 c4 10 add $0x10,%esp
}
10b118: 8b 45 b4 mov -0x4c(%ebp),%eax
10b11b: 8d 65 f4 lea -0xc(%ebp),%esp
10b11e: 5b pop %ebx
10b11f: 5e pop %esi
10b120: 5f pop %edi
10b121: c9 leave
10b122: c3 ret
0010ac14 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
10ac14: 55 push %ebp
10ac15: 89 e5 mov %esp,%ebp
10ac17: 57 push %edi
10ac18: 56 push %esi
10ac19: 53 push %ebx
10ac1a: 83 ec 4c sub $0x4c,%esp
rtems_aio_request_chain *r_chain = arg;
10ac1d: 8b 5d 08 mov 0x8(%ebp),%ebx
pthread_mutex_unlock (&r_chain->mutex);
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
10ac20: 8d 7d dc lea -0x24(%ebp),%edi
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
10ac23: 8d 43 1c lea 0x1c(%ebx),%eax
10ac26: 89 45 b4 mov %eax,-0x4c(%ebp)
10ac29: 83 ec 0c sub $0xc,%esp
10ac2c: 50 push %eax
10ac2d: e8 ca 0b 00 00 call 10b7fc <pthread_mutex_lock>
if (result != 0)
10ac32: 83 c4 10 add $0x10,%esp
10ac35: 85 c0 test %eax,%eax
10ac37: 0f 85 f1 01 00 00 jne 10ae2e <rtems_aio_handle+0x21a><== NEVER TAKEN
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ac3d: 8b 73 08 mov 0x8(%ebx),%esi
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10ac40: 8d 43 0c lea 0xc(%ebx),%eax
/* If the locked chain is not empty, take the first
request extract it, unlock the chain and process
the request, in this way the user can supply more
requests to this fd chain */
if (!rtems_chain_is_empty (chain)) {
10ac43: 39 c6 cmp %eax,%esi
10ac45: 0f 84 cd 00 00 00 je 10ad18 <rtems_aio_handle+0x104>
node = rtems_chain_first (chain);
req = (rtems_aio_request *) node;
/* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING
discussion in rtems_aio_enqueue () */
pthread_getschedparam (pthread_self(), &policy, ¶m);
10ac4b: e8 ac 13 00 00 call 10bffc <pthread_self>
10ac50: 52 push %edx
10ac51: 8d 55 c0 lea -0x40(%ebp),%edx
10ac54: 52 push %edx
10ac55: 8d 4d e4 lea -0x1c(%ebp),%ecx
10ac58: 51 push %ecx
10ac59: 50 push %eax
10ac5a: e8 a1 0f 00 00 call 10bc00 <pthread_getschedparam>
param.sched_priority = req->priority;
10ac5f: 8b 46 0c mov 0xc(%esi),%eax
10ac62: 89 45 c0 mov %eax,-0x40(%ebp)
pthread_setschedparam (pthread_self(), req->policy, ¶m);
10ac65: 8b 56 08 mov 0x8(%esi),%edx
10ac68: 89 55 b0 mov %edx,-0x50(%ebp)
10ac6b: e8 8c 13 00 00 call 10bffc <pthread_self>
10ac70: 83 c4 0c add $0xc,%esp
10ac73: 8d 4d c0 lea -0x40(%ebp),%ecx
10ac76: 51 push %ecx
10ac77: 8b 55 b0 mov -0x50(%ebp),%edx
10ac7a: 52 push %edx
10ac7b: 50 push %eax
10ac7c: e8 8b 13 00 00 call 10c00c <pthread_setschedparam>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10ac81: 89 34 24 mov %esi,(%esp)
10ac84: e8 db 22 00 00 call 10cf64 <_Chain_Extract>
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
10ac89: 59 pop %ecx
10ac8a: ff 75 b4 pushl -0x4c(%ebp)
10ac8d: e8 ea 0b 00 00 call 10b87c <pthread_mutex_unlock>
switch (req->aiocbp->aio_lio_opcode) {
10ac92: 8b 46 14 mov 0x14(%esi),%eax
10ac95: 83 c4 10 add $0x10,%esp
10ac98: 8b 50 2c mov 0x2c(%eax),%edx
10ac9b: 83 fa 02 cmp $0x2,%edx
10ac9e: 74 20 je 10acc0 <rtems_aio_handle+0xac>
10aca0: 83 fa 03 cmp $0x3,%edx
10aca3: 74 36 je 10acdb <rtems_aio_handle+0xc7> <== NEVER TAKEN
10aca5: 4a dec %edx
10aca6: 75 45 jne 10aced <rtems_aio_handle+0xd9> <== NEVER TAKEN
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
10aca8: 83 ec 0c sub $0xc,%esp
10acab: ff 70 08 pushl 0x8(%eax)
10acae: ff 70 04 pushl 0x4(%eax)
10acb1: ff 70 10 pushl 0x10(%eax)
10acb4: ff 70 0c pushl 0xc(%eax)
10acb7: ff 30 pushl (%eax)
10acb9: e8 e6 93 00 00 call 1140a4 <pread>
10acbe: eb 16 jmp 10acd6 <rtems_aio_handle+0xc2>
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
10acc0: 83 ec 0c sub $0xc,%esp
10acc3: ff 70 08 pushl 0x8(%eax)
10acc6: ff 70 04 pushl 0x4(%eax)
10acc9: ff 70 10 pushl 0x10(%eax)
10accc: ff 70 0c pushl 0xc(%eax)
10accf: ff 30 pushl (%eax)
10acd1: e8 82 94 00 00 call 114158 <pwrite>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
10acd6: 83 c4 20 add $0x20,%esp
10acd9: eb 0d jmp 10ace8 <rtems_aio_handle+0xd4>
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
10acdb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10acde: ff 30 pushl (%eax) <== NOT EXECUTED
10ace0: e8 27 5d 00 00 call 110a0c <fsync> <== NOT EXECUTED
break;
10ace5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
default:
result = -1;
}
if (result == -1) {
10ace8: 83 f8 ff cmp $0xffffffff,%eax
10aceb: 75 19 jne 10ad06 <rtems_aio_handle+0xf2> <== ALWAYS TAKEN
req->aiocbp->return_value = -1;
10aced: 8b 76 14 mov 0x14(%esi),%esi <== NOT EXECUTED
10acf0: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED
req->aiocbp->error_code = errno;
10acf7: e8 70 89 00 00 call 11366c <__errno> <== NOT EXECUTED
10acfc: 8b 00 mov (%eax),%eax <== NOT EXECUTED
10acfe: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED
10ad01: e9 1d ff ff ff jmp 10ac23 <rtems_aio_handle+0xf> <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
10ad06: 8b 56 14 mov 0x14(%esi),%edx
10ad09: 89 42 34 mov %eax,0x34(%edx)
req->aiocbp->error_code = 0;
10ad0c: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx)
10ad13: e9 0b ff ff ff jmp 10ac23 <rtems_aio_handle+0xf>
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
10ad18: 83 ec 0c sub $0xc,%esp
10ad1b: ff 75 b4 pushl -0x4c(%ebp)
10ad1e: e8 59 0b 00 00 call 10b87c <pthread_mutex_unlock>
pthread_mutex_lock (&aio_request_queue.mutex);
10ad23: c7 04 24 d8 72 12 00 movl $0x1272d8,(%esp)
10ad2a: e8 cd 0a 00 00 call 10b7fc <pthread_mutex_lock>
if (rtems_chain_is_empty (chain))
10ad2f: 83 c4 10 add $0x10,%esp
10ad32: 39 73 08 cmp %esi,0x8(%ebx)
10ad35: 0f 85 de 00 00 00 jne 10ae19 <rtems_aio_handle+0x205><== NEVER TAKEN
{
clock_gettime (CLOCK_REALTIME, &timeout);
10ad3b: 52 push %edx
10ad3c: 52 push %edx
10ad3d: 57 push %edi
10ad3e: 6a 01 push $0x1
10ad40: e8 47 05 00 00 call 10b28c <clock_gettime>
timeout.tv_sec += 3;
10ad45: 83 45 dc 03 addl $0x3,-0x24(%ebp)
timeout.tv_nsec = 0;
10ad49: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
result = pthread_cond_timedwait (&r_chain->cond,
10ad50: 8d 73 20 lea 0x20(%ebx),%esi
10ad53: 83 c4 0c add $0xc,%esp
10ad56: 57 push %edi
10ad57: 68 d8 72 12 00 push $0x1272d8
10ad5c: 56 push %esi
10ad5d: e8 46 07 00 00 call 10b4a8 <pthread_cond_timedwait>
&aio_request_queue.mutex,
&timeout);
/* If no requests were added to the chain we delete the fd chain from
the queue and start working with idle fd chains */
if (result == ETIMEDOUT) {
10ad62: 83 c4 10 add $0x10,%esp
10ad65: 83 f8 74 cmp $0x74,%eax
10ad68: 0f 85 ab 00 00 00 jne 10ae19 <rtems_aio_handle+0x205><== NEVER TAKEN
10ad6e: 83 ec 0c sub $0xc,%esp
10ad71: 53 push %ebx
10ad72: e8 ed 21 00 00 call 10cf64 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
10ad77: 58 pop %eax
10ad78: ff 75 b4 pushl -0x4c(%ebp)
10ad7b: e8 5c 08 00 00 call 10b5dc <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->cond);
10ad80: 89 34 24 mov %esi,(%esp)
10ad83: e8 60 05 00 00 call 10b2e8 <pthread_cond_destroy>
free (r_chain);
10ad88: 89 1c 24 mov %ebx,(%esp)
10ad8b: e8 a0 cf ff ff call 107d30 <free>
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
10ad90: 83 c4 10 add $0x10,%esp
10ad93: 81 3d 2c 73 12 00 30 cmpl $0x127330,0x12732c
10ad9a: 73 12 00
10ad9d: 75 54 jne 10adf3 <rtems_aio_handle+0x1df>
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
10ad9f: ff 05 40 73 12 00 incl 0x127340
--aio_request_queue.active_threads;
10ada5: ff 0d 3c 73 12 00 decl 0x12733c
clock_gettime (CLOCK_REALTIME, &timeout);
10adab: 53 push %ebx
10adac: 53 push %ebx
10adad: 57 push %edi
10adae: 6a 01 push $0x1
10adb0: e8 d7 04 00 00 call 10b28c <clock_gettime>
timeout.tv_sec += 3;
10adb5: 83 45 dc 03 addl $0x3,-0x24(%ebp)
timeout.tv_nsec = 0;
10adb9: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp)
result = pthread_cond_timedwait (&aio_request_queue.new_req,
10adc0: 83 c4 0c add $0xc,%esp
10adc3: 57 push %edi
10adc4: 68 d8 72 12 00 push $0x1272d8
10adc9: 68 dc 72 12 00 push $0x1272dc
10adce: e8 d5 06 00 00 call 10b4a8 <pthread_cond_timedwait>
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
10add3: 83 c4 10 add $0x10,%esp
10add6: 83 f8 74 cmp $0x74,%eax
10add9: 75 18 jne 10adf3 <rtems_aio_handle+0x1df><== NEVER TAKEN
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
10addb: ff 0d 40 73 12 00 decl 0x127340
pthread_mutex_unlock (&aio_request_queue.mutex);
10ade1: 83 ec 0c sub $0xc,%esp
10ade4: 68 d8 72 12 00 push $0x1272d8
10ade9: e8 8e 0a 00 00 call 10b87c <pthread_mutex_unlock>
return NULL;
10adee: 83 c4 10 add $0x10,%esp
10adf1: eb 3b jmp 10ae2e <rtems_aio_handle+0x21a>
}
}
/* Otherwise move this chain to the working chain and
start the loop all over again */
AIO_printf ("Work on idle\n");
--aio_request_queue.idle_threads;
10adf3: ff 0d 40 73 12 00 decl 0x127340
++aio_request_queue.active_threads;
10adf9: ff 05 3c 73 12 00 incl 0x12733c
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10adff: 8b 1d 2c 73 12 00 mov 0x12732c,%ebx
10ae05: 83 ec 0c sub $0xc,%esp
10ae08: 53 push %ebx
10ae09: e8 56 21 00 00 call 10cf64 <_Chain_Extract>
node = rtems_chain_first (&aio_request_queue.idle_req);
rtems_chain_extract (node);
r_chain = (rtems_aio_request_chain *) node;
rtems_aio_move_to_work (r_chain);
10ae0e: 89 1c 24 mov %ebx,(%esp)
10ae11: e8 cd fd ff ff call 10abe3 <rtems_aio_move_to_work>
10ae16: 83 c4 10 add $0x10,%esp
}
}
/* If there was a request added in the initial fd chain then release
the mutex and process it */
pthread_mutex_unlock (&aio_request_queue.mutex);
10ae19: 83 ec 0c sub $0xc,%esp
10ae1c: 68 d8 72 12 00 push $0x1272d8
10ae21: e8 56 0a 00 00 call 10b87c <pthread_mutex_unlock>
10ae26: 83 c4 10 add $0x10,%esp
10ae29: e9 f5 fd ff ff jmp 10ac23 <rtems_aio_handle+0xf>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae2e: 31 c0 xor %eax,%eax
10ae30: 8d 65 f4 lea -0xc(%ebp),%esp
10ae33: 5b pop %ebx
10ae34: 5e pop %esi
10ae35: 5f pop %edi
10ae36: c9 leave
10ae37: c3 ret
0010aa3c <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
10aa3c: 55 push %ebp
10aa3d: 89 e5 mov %esp,%ebp
10aa3f: 53 push %ebx
10aa40: 83 ec 10 sub $0x10,%esp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
10aa43: 68 e0 72 12 00 push $0x1272e0
10aa48: e8 33 0f 00 00 call 10b980 <pthread_attr_init>
10aa4d: 89 c3 mov %eax,%ebx
if (result != 0)
10aa4f: 83 c4 10 add $0x10,%esp
10aa52: 85 c0 test %eax,%eax
10aa54: 0f 85 d7 00 00 00 jne 10ab31 <rtems_aio_init+0xf5> <== NEVER TAKEN
return result;
result =
10aa5a: 51 push %ecx
10aa5b: 51 push %ecx
10aa5c: 6a 00 push $0x0
10aa5e: 68 e0 72 12 00 push $0x1272e0
10aa63: e8 40 0f 00 00 call 10b9a8 <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
10aa68: 83 c4 10 add $0x10,%esp
10aa6b: 85 c0 test %eax,%eax
10aa6d: 74 10 je 10aa7f <rtems_aio_init+0x43> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
10aa6f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aa72: 68 e0 72 12 00 push $0x1272e0 <== NOT EXECUTED
10aa77: e8 e4 0e 00 00 call 10b960 <pthread_attr_destroy> <== NOT EXECUTED
10aa7c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
10aa7f: 52 push %edx
10aa80: 52 push %edx
10aa81: 6a 00 push $0x0
10aa83: 68 d8 72 12 00 push $0x1272d8
10aa88: e8 4f 0c 00 00 call 10b6dc <pthread_mutex_init>
if (result != 0)
10aa8d: 83 c4 10 add $0x10,%esp
10aa90: 85 c0 test %eax,%eax
10aa92: 74 10 je 10aaa4 <rtems_aio_init+0x68> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
10aa94: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aa97: 68 e0 72 12 00 push $0x1272e0 <== NOT EXECUTED
10aa9c: e8 bf 0e 00 00 call 10b960 <pthread_attr_destroy> <== NOT EXECUTED
10aaa1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
10aaa4: 50 push %eax
10aaa5: 50 push %eax
10aaa6: 6a 00 push $0x0
10aaa8: 68 dc 72 12 00 push $0x1272dc
10aaad: e8 ea 08 00 00 call 10b39c <pthread_cond_init>
10aab2: 89 c3 mov %eax,%ebx
if (result != 0) {
10aab4: 83 c4 10 add $0x10,%esp
10aab7: 85 c0 test %eax,%eax
10aab9: 74 1c je 10aad7 <rtems_aio_init+0x9b> <== ALWAYS TAKEN
pthread_mutex_destroy (&aio_request_queue.mutex);
10aabb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aabe: 68 d8 72 12 00 push $0x1272d8 <== NOT EXECUTED
10aac3: e8 14 0b 00 00 call 10b5dc <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
10aac8: c7 04 24 e0 72 12 00 movl $0x1272e0,(%esp) <== NOT EXECUTED
10aacf: e8 8c 0e 00 00 call 10b960 <pthread_attr_destroy> <== NOT EXECUTED
10aad4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10aad7: c7 05 20 73 12 00 24 movl $0x127324,0x127320
10aade: 73 12 00
head->previous = NULL;
10aae1: c7 05 24 73 12 00 00 movl $0x0,0x127324
10aae8: 00 00 00
tail->previous = head;
10aaeb: c7 05 28 73 12 00 20 movl $0x127320,0x127328
10aaf2: 73 12 00
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
10aaf5: c7 05 2c 73 12 00 30 movl $0x127330,0x12732c
10aafc: 73 12 00
head->previous = NULL;
10aaff: c7 05 30 73 12 00 00 movl $0x0,0x127330
10ab06: 00 00 00
tail->previous = head;
10ab09: c7 05 34 73 12 00 2c movl $0x12732c,0x127334
10ab10: 73 12 00
}
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
10ab13: c7 05 3c 73 12 00 00 movl $0x0,0x12733c
10ab1a: 00 00 00
aio_request_queue.idle_threads = 0;
10ab1d: c7 05 40 73 12 00 00 movl $0x0,0x127340
10ab24: 00 00 00
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
10ab27: c7 05 38 73 12 00 0b movl $0xb00b,0x127338
10ab2e: b0 00 00
return result;
}
10ab31: 89 d8 mov %ebx,%eax
10ab33: 8b 5d fc mov -0x4(%ebp),%ebx
10ab36: c9 leave
10ab37: c3 ret
0010ae38 <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
10ae38: 55 push %ebp
10ae39: 89 e5 mov %esp,%ebp
10ae3b: 56 push %esi
10ae3c: 53 push %ebx
10ae3d: 8b 4d 08 mov 0x8(%ebp),%ecx
10ae40: 8b 55 0c mov 0xc(%ebp),%edx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae43: 8b 01 mov (%ecx),%eax
10ae45: 8d 59 04 lea 0x4(%ecx),%ebx
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
10ae48: 39 d8 cmp %ebx,%eax
10ae4a: 74 27 je 10ae73 <rtems_aio_insert_prio+0x3b><== NEVER TAKEN
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
10ae4c: 8b 48 14 mov 0x14(%eax),%ecx
10ae4f: 8b 49 14 mov 0x14(%ecx),%ecx
while (req->aiocbp->aio_reqprio > prio &&
10ae52: 8b 72 14 mov 0x14(%edx),%esi
10ae55: 8b 76 14 mov 0x14(%esi),%esi
10ae58: eb 08 jmp 10ae62 <rtems_aio_insert_prio+0x2a>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10ae5a: 8b 00 mov (%eax),%eax <== NOT EXECUTED
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
10ae5c: 8b 48 14 mov 0x14(%eax),%ecx <== NOT EXECUTED
10ae5f: 8b 49 14 mov 0x14(%ecx),%ecx <== NOT EXECUTED
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
while (req->aiocbp->aio_reqprio > prio &&
10ae62: 39 ce cmp %ecx,%esi
10ae64: 7e 04 jle 10ae6a <rtems_aio_insert_prio+0x32><== ALWAYS TAKEN
10ae66: 39 d8 cmp %ebx,%eax <== NOT EXECUTED
10ae68: 75 f0 jne 10ae5a <rtems_aio_insert_prio+0x22><== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
10ae6a: 89 55 0c mov %edx,0xc(%ebp)
10ae6d: 8b 40 04 mov 0x4(%eax),%eax
10ae70: 89 45 08 mov %eax,0x8(%ebp)
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
10ae73: 5b pop %ebx
10ae74: 5e pop %esi
10ae75: c9 leave
10ae76: e9 25 21 00 00 jmp 10cfa0 <_Chain_Insert>
0010abe3 <rtems_aio_move_to_work>:
* NONE
*/
void
rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
{
10abe3: 55 push %ebp
10abe4: 89 e5 mov %esp,%ebp
10abe6: 83 ec 08 sub $0x8,%esp
10abe9: 8b 55 08 mov 0x8(%ebp),%edx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10abec: a1 20 73 12 00 mov 0x127320,%eax
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
10abf1: 8b 4a 14 mov 0x14(%edx),%ecx
10abf4: eb 02 jmp 10abf8 <rtems_aio_move_to_work+0x15>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10abf6: 8b 00 mov (%eax),%eax
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
while (temp->fildes < r_chain->fildes &&
10abf8: 39 48 14 cmp %ecx,0x14(%eax)
10abfb: 7d 07 jge 10ac04 <rtems_aio_move_to_work+0x21>
10abfd: 3d 24 73 12 00 cmp $0x127324,%eax
10ac02: 75 f2 jne 10abf6 <rtems_aio_move_to_work+0x13><== ALWAYS TAKEN
10ac04: 51 push %ecx
10ac05: 51 push %ecx
10ac06: 52 push %edx
10ac07: ff 70 04 pushl 0x4(%eax)
10ac0a: e8 91 23 00 00 call 10cfa0 <_Chain_Insert>
10ac0f: 83 c4 10 add $0x10,%esp
node = rtems_chain_next (node);
temp = (rtems_aio_request_chain *) node;
}
rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd);
}
10ac12: c9 leave
10ac13: c3 ret
0010aec4 <rtems_aio_remove_req>:
* AIO_NOTCANCELED - if request was not canceled
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
10aec4: 55 push %ebp
10aec5: 89 e5 mov %esp,%ebp
10aec7: 53 push %ebx
10aec8: 83 ec 04 sub $0x4,%esp
10aecb: 8b 55 08 mov 0x8(%ebp),%edx
10aece: 8b 4d 0c mov 0xc(%ebp),%ecx
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10aed1: 8b 1a mov (%edx),%ebx
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
10aed3: 83 c2 04 add $0x4,%edx
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
return AIO_ALLDONE;
10aed6: b8 02 00 00 00 mov $0x2,%eax
* AIO_CANCELED - if request was canceled
*/
int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp)
{
if (rtems_chain_is_empty (chain))
10aedb: 39 d3 cmp %edx,%ebx
10aedd: 75 08 jne 10aee7 <rtems_aio_remove_req+0x23>
10aedf: eb 3b jmp 10af1c <rtems_aio_remove_req+0x58>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
10aee1: 8b 18 mov (%eax),%ebx <== NOT EXECUTED
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
10aee3: 39 d3 cmp %edx,%ebx <== NOT EXECUTED
10aee5: 74 30 je 10af17 <rtems_aio_remove_req+0x53><== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
10aee7: 89 d8 mov %ebx,%eax
rtems_chain_node *node = rtems_chain_first (chain);
rtems_aio_request *current;
current = (rtems_aio_request *) node;
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
10aee9: 39 4b 14 cmp %ecx,0x14(%ebx)
10aeec: 75 f3 jne 10aee1 <rtems_aio_remove_req+0x1d><== NEVER TAKEN
10aeee: 83 ec 0c sub $0xc,%esp
10aef1: 53 push %ebx
10aef2: e8 6d 20 00 00 call 10cf64 <_Chain_Extract>
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
10aef7: 8b 43 14 mov 0x14(%ebx),%eax
10aefa: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax)
current->aiocbp->return_value = -1;
10af01: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax)
free (current);
10af08: 89 1c 24 mov %ebx,(%esp)
10af0b: e8 20 ce ff ff call 107d30 <free>
}
return AIO_CANCELED;
10af10: 83 c4 10 add $0x10,%esp
10af13: 31 c0 xor %eax,%eax
10af15: eb 05 jmp 10af1c <rtems_aio_remove_req+0x58>
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
10af17: b8 01 00 00 00 mov $0x1,%eax
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
10af1c: 8b 5d fc mov -0x4(%ebp),%ebx
10af1f: c9 leave
10af20: c3 ret
0010ab2c <rtems_chain_append_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10ab2c: 55 push %ebp
10ab2d: 89 e5 mov %esp,%ebp
10ab2f: 56 push %esi
10ab30: 53 push %ebx
10ab31: 8b 5d 10 mov 0x10(%ebp),%ebx
10ab34: 8b 75 14 mov 0x14(%ebp),%esi
RTEMS_INLINE_ROUTINE bool rtems_chain_append_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Append_with_empty_check( chain, node );
10ab37: 50 push %eax
10ab38: 50 push %eax
10ab39: ff 75 0c pushl 0xc(%ebp)
10ab3c: ff 75 08 pushl 0x8(%ebp)
10ab3f: e8 94 04 00 00 call 10afd8 <_Chain_Append_with_empty_check>
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
10ab44: 83 c4 10 add $0x10,%esp
10ab47: 84 c0 test %al,%al
10ab49: 74 11 je 10ab5c <rtems_chain_append_with_notification+0x30><== NEVER TAKEN
sc = rtems_event_send( task, events );
10ab4b: 89 75 0c mov %esi,0xc(%ebp)
10ab4e: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10ab51: 8d 65 f8 lea -0x8(%ebp),%esp
10ab54: 5b pop %ebx
10ab55: 5e pop %esi
10ab56: c9 leave
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
sc = rtems_event_send( task, events );
10ab57: e9 d4 f6 ff ff jmp 10a230 <rtems_event_send>
}
return sc;
}
10ab5c: 31 c0 xor %eax,%eax
10ab5e: 8d 65 f8 lea -0x8(%ebp),%esp
10ab61: 5b pop %ebx
10ab62: 5e pop %esi <== NOT EXECUTED
10ab63: c9 leave <== NOT EXECUTED
10ab64: c3 ret <== NOT EXECUTED
0010aba4 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
10aba4: 55 push %ebp
10aba5: 89 e5 mov %esp,%ebp
10aba7: 57 push %edi
10aba8: 56 push %esi
10aba9: 53 push %ebx
10abaa: 83 ec 1c sub $0x1c,%esp
10abad: 8b 7d 0c mov 0xc(%ebp),%edi
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
10abb0: 8d 75 e4 lea -0x1c(%ebp),%esi
10abb3: eb 13 jmp 10abc8 <rtems_chain_get_with_wait+0x24>
10abb5: 56 push %esi
10abb6: ff 75 10 pushl 0x10(%ebp)
10abb9: 6a 00 push $0x0
10abbb: 57 push %edi
10abbc: e8 0f f5 ff ff call 10a0d0 <rtems_event_receive>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
10abc1: 83 c4 10 add $0x10,%esp
10abc4: 85 c0 test %eax,%eax
10abc6: 75 16 jne 10abde <rtems_chain_get_with_wait+0x3a><== ALWAYS TAKEN
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
10abc8: 83 ec 0c sub $0xc,%esp
10abcb: ff 75 08 pushl 0x8(%ebp)
10abce: e8 a5 04 00 00 call 10b078 <_Chain_Get>
10abd3: 89 c3 mov %eax,%ebx
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
10abd5: 83 c4 10 add $0x10,%esp
10abd8: 85 c0 test %eax,%eax
10abda: 74 d9 je 10abb5 <rtems_chain_get_with_wait+0x11>
10abdc: 31 c0 xor %eax,%eax
timeout,
&out
);
}
*node_ptr = node;
10abde: 8b 55 14 mov 0x14(%ebp),%edx
10abe1: 89 1a mov %ebx,(%edx)
return sc;
}
10abe3: 8d 65 f4 lea -0xc(%ebp),%esp
10abe6: 5b pop %ebx
10abe7: 5e pop %esi
10abe8: 5f pop %edi
10abe9: c9 leave
10abea: c3 ret
0010abec <rtems_chain_prepend_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
10abec: 55 push %ebp
10abed: 89 e5 mov %esp,%ebp
10abef: 56 push %esi
10abf0: 53 push %ebx
10abf1: 8b 5d 10 mov 0x10(%ebp),%ebx
10abf4: 8b 75 14 mov 0x14(%ebp),%esi
RTEMS_INLINE_ROUTINE bool rtems_chain_prepend_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Prepend_with_empty_check( chain, node );
10abf7: 50 push %eax
10abf8: 50 push %eax
10abf9: ff 75 0c pushl 0xc(%ebp)
10abfc: ff 75 08 pushl 0x8(%ebp)
10abff: e8 b8 04 00 00 call 10b0bc <_Chain_Prepend_with_empty_check>
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
10ac04: 83 c4 10 add $0x10,%esp
10ac07: 84 c0 test %al,%al
10ac09: 74 11 je 10ac1c <rtems_chain_prepend_with_notification+0x30><== NEVER TAKEN
sc = rtems_event_send( task, events );
10ac0b: 89 75 0c mov %esi,0xc(%ebp)
10ac0e: 89 5d 08 mov %ebx,0x8(%ebp)
}
return sc;
}
10ac11: 8d 65 f8 lea -0x8(%ebp),%esp
10ac14: 5b pop %ebx
10ac15: 5e pop %esi
10ac16: c9 leave
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
sc = rtems_event_send( task, events );
10ac17: e9 14 f6 ff ff jmp 10a230 <rtems_event_send>
}
return sc;
}
10ac1c: 31 c0 xor %eax,%eax
10ac1e: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
10ac21: 5b pop %ebx <== NOT EXECUTED
10ac22: 5e pop %esi <== NOT EXECUTED
10ac23: c9 leave <== NOT EXECUTED
10ac24: c3 ret <== NOT EXECUTED
00107698 <rtems_cpu_usage_report_with_plugin>:
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
107698: 55 push %ebp
107699: 89 e5 mov %esp,%ebp
10769b: 57 push %edi
10769c: 56 push %esi
10769d: 53 push %ebx
10769e: 83 ec 6c sub $0x6c,%esp
1076a1: 8b 7d 08 mov 0x8(%ebp),%edi
Timestamp_Control uptime, total, ran, last_context_switch;
#else
uint32_t total_units = 0;
#endif
if ( !print )
1076a4: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
1076a8: 0f 84 54 01 00 00 je 107802 <rtems_cpu_usage_report_with_plugin+0x16a><== NEVER TAKEN
* When not using nanosecond CPU usage resolution, we have to count
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
last_context_switch = _Thread_Time_of_last_context_switch;
1076ae: a1 94 90 12 00 mov 0x129094,%eax
1076b3: 8b 15 98 90 12 00 mov 0x129098,%edx
1076b9: 89 45 c0 mov %eax,-0x40(%ebp)
1076bc: 89 55 c4 mov %edx,-0x3c(%ebp)
_TOD_Get_uptime( &uptime );
1076bf: 83 ec 0c sub $0xc,%esp
1076c2: 8d 5d d8 lea -0x28(%ebp),%ebx
1076c5: 53 push %ebx
1076c6: e8 75 4b 00 00 call 10c240 <_TOD_Get_uptime>
_Timestamp_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total );
1076cb: 83 c4 0c add $0xc,%esp
1076ce: 8d 75 d0 lea -0x30(%ebp),%esi
1076d1: 56 push %esi
1076d2: 53 push %ebx
1076d3: 68 80 95 12 00 push $0x129580
1076d8: e8 47 6b 00 00 call 10e224 <_Timespec_Subtract>
}
}
}
#endif
(*print)(
1076dd: 5b pop %ebx
1076de: 5e pop %esi
1076df: 68 b5 13 12 00 push $0x1213b5
1076e4: 57 push %edi
1076e5: ff 55 0c call *0xc(%ebp)
1076e8: 83 c4 10 add $0x10,%esp
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
1076eb: bb 01 00 00 00 mov $0x1,%ebx
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
1076f0: 8b 04 9d bc 8f 12 00 mov 0x128fbc(,%ebx,4),%eax
1076f7: 8b 70 04 mov 0x4(%eax),%esi
if ( information ) {
1076fa: 85 f6 test %esi,%esi
1076fc: 0f 84 da 00 00 00 je 1077dc <rtems_cpu_usage_report_with_plugin+0x144><== NEVER TAKEN
107702: c7 45 a4 01 00 00 00 movl $0x1,-0x5c(%ebp)
107709: 89 5d 94 mov %ebx,-0x6c(%ebp)
10770c: e9 bb 00 00 00 jmp 1077cc <rtems_cpu_usage_report_with_plugin+0x134>
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
107711: 8b 46 1c mov 0x1c(%esi),%eax
107714: 8b 4d a4 mov -0x5c(%ebp),%ecx
107717: 8b 14 88 mov (%eax,%ecx,4),%edx
if ( !the_thread )
10771a: 85 d2 test %edx,%edx
10771c: 0f 84 a7 00 00 00 je 1077c9 <rtems_cpu_usage_report_with_plugin+0x131><== NEVER TAKEN
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
107722: 51 push %ecx
107723: 8d 5d ab lea -0x55(%ebp),%ebx
107726: 53 push %ebx
107727: 6a 0d push $0xd
107729: ff 72 08 pushl 0x8(%edx)
10772c: 89 55 a0 mov %edx,-0x60(%ebp)
10772f: e8 98 39 00 00 call 10b0cc <rtems_object_get_name>
(*print)(
107734: 53 push %ebx
107735: 8b 55 a0 mov -0x60(%ebp),%edx
107738: ff 72 08 pushl 0x8(%edx)
10773b: 68 27 15 12 00 push $0x121527
107740: 57 push %edi
107741: ff 55 0c call *0xc(%ebp)
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
107744: 8b 55 a0 mov -0x60(%ebp),%edx
107747: 8b 8a 84 00 00 00 mov 0x84(%edx),%ecx
10774d: 8b 9a 88 00 00 00 mov 0x88(%edx),%ebx
107753: 89 4d c8 mov %ecx,-0x38(%ebp)
107756: 89 5d cc mov %ebx,-0x34(%ebp)
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
107759: 83 c4 20 add $0x20,%esp
10775c: a1 4c 95 12 00 mov 0x12954c,%eax
107761: 8b 5a 08 mov 0x8(%edx),%ebx
107764: 39 58 08 cmp %ebx,0x8(%eax)
107767: 75 27 jne 107790 <rtems_cpu_usage_report_with_plugin+0xf8>
Timestamp_Control used;
_Timestamp_Subtract( &last_context_switch, &uptime, &used );
107769: 50 push %eax
10776a: 8d 45 b8 lea -0x48(%ebp),%eax
10776d: 50 push %eax
10776e: 8d 55 d8 lea -0x28(%ebp),%edx
107771: 52 push %edx
107772: 8d 55 c0 lea -0x40(%ebp),%edx
107775: 52 push %edx
107776: 89 45 a0 mov %eax,-0x60(%ebp)
107779: e8 a6 6a 00 00 call 10e224 <_Timespec_Subtract>
_Timestamp_Add_to( &ran, &used );
10777e: 59 pop %ecx
10777f: 5b pop %ebx
107780: 8b 45 a0 mov -0x60(%ebp),%eax
107783: 50 push %eax
107784: 8d 45 c8 lea -0x38(%ebp),%eax
107787: 50 push %eax
107788: e8 ab 69 00 00 call 10e138 <_Timespec_Add_to>
10778d: 83 c4 10 add $0x10,%esp
};
_Timestamp_Divide( &ran, &total, &ival, &fval );
107790: 8d 4d e0 lea -0x20(%ebp),%ecx
107793: 51 push %ecx
107794: 8d 5d e4 lea -0x1c(%ebp),%ebx
107797: 53 push %ebx
107798: 8d 45 d0 lea -0x30(%ebp),%eax
10779b: 50 push %eax
10779c: 8d 4d c8 lea -0x38(%ebp),%ecx
10779f: 51 push %ecx
1077a0: e8 c3 69 00 00 call 10e168 <_Timespec_Divide>
/*
* Print the information
*/
(*print)( context,
1077a5: 58 pop %eax
1077a6: 5a pop %edx
1077a7: ff 75 e0 pushl -0x20(%ebp)
1077aa: ff 75 e4 pushl -0x1c(%ebp)
1077ad: 8b 45 cc mov -0x34(%ebp),%eax
1077b0: b9 e8 03 00 00 mov $0x3e8,%ecx
1077b5: 31 d2 xor %edx,%edx
1077b7: f7 f1 div %ecx
1077b9: 50 push %eax
1077ba: ff 75 c8 pushl -0x38(%ebp)
1077bd: 68 3a 15 12 00 push $0x12153a
1077c2: 57 push %edi
1077c3: ff 55 0c call *0xc(%ebp)
1077c6: 83 c4 20 add $0x20,%esp
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
1077c9: ff 45 a4 incl -0x5c(%ebp)
1077cc: 0f b7 46 10 movzwl 0x10(%esi),%eax
1077d0: 39 45 a4 cmp %eax,-0x5c(%ebp)
1077d3: 0f 86 38 ff ff ff jbe 107711 <rtems_cpu_usage_report_with_plugin+0x79>
1077d9: 8b 5d 94 mov -0x6c(%ebp),%ebx
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
1077dc: 43 inc %ebx
1077dd: 83 fb 04 cmp $0x4,%ebx
1077e0: 0f 85 0a ff ff ff jne 1076f0 <rtems_cpu_usage_report_with_plugin+0x58>
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)(
1077e6: 8b 45 d4 mov -0x2c(%ebp),%eax
1077e9: b9 e8 03 00 00 mov $0x3e8,%ecx
1077ee: 31 d2 xor %edx,%edx
1077f0: f7 f1 div %ecx
1077f2: 50 push %eax
1077f3: ff 75 d0 pushl -0x30(%ebp)
1077f6: 68 52 15 12 00 push $0x121552
1077fb: 57 push %edi
1077fc: ff 55 0c call *0xc(%ebp)
1077ff: 83 c4 10 add $0x10,%esp
"-------------------------------------------------------------------------------\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,
total_units
);
#endif
}
107802: 8d 65 f4 lea -0xc(%ebp),%esp
107805: 5b pop %ebx
107806: 5e pop %esi
107807: 5f pop %edi
107808: c9 leave
107809: c3 ret
0011104c <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
11104c: 55 push %ebp
11104d: 89 e5 mov %esp,%ebp
11104f: 53 push %ebx
111050: 83 ec 04 sub $0x4,%esp
111053: 8b 55 08 mov 0x8(%ebp),%edx
if (sc == RTEMS_SUCCESSFUL) {
return 0;
111056: 31 c0 xor %eax,%eax
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
111058: 85 d2 test %edx,%edx
11105a: 74 1b je 111077 <rtems_deviceio_errno+0x2b>
return 0;
} else {
int eno = EINVAL;
11105c: bb 16 00 00 00 mov $0x16,%ebx
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
111061: 83 fa 1c cmp $0x1c,%edx
111064: 77 07 ja 11106d <rtems_deviceio_errno+0x21><== NEVER TAKEN
eno = status_code_to_errno [sc];
111066: 8b 1c 95 a8 f6 11 00 mov 0x11f6a8(,%edx,4),%ebx
}
errno = eno;
11106d: e8 5a 00 00 00 call 1110cc <__errno>
111072: 89 18 mov %ebx,(%eax)
return -1;
111074: 83 c8 ff or $0xffffffff,%eax
}
}
111077: 5a pop %edx
111078: 5b pop %ebx
111079: c9 leave
11107a: c3 ret
0010e447 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
10e447: 55 push %ebp
10e448: 89 e5 mov %esp,%ebp
10e44a: 83 ec 18 sub $0x18,%esp
10e44d: 8b 45 08 mov 0x8(%ebp),%eax
find_arg fa = {
10e450: 89 45 f0 mov %eax,-0x10(%ebp)
10e453: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
10e45a: 85 c0 test %eax,%eax
10e45c: 74 13 je 10e471 <rtems_filesystem_get_mount_handler+0x2a><== NEVER TAKEN
rtems_filesystem_iterate( find_handler, &fa );
10e45e: 50 push %eax
10e45f: 50 push %eax
10e460: 8d 45 f0 lea -0x10(%ebp),%eax
10e463: 50 push %eax
10e464: 68 70 e3 10 00 push $0x10e370
10e469: e8 62 ff ff ff call 10e3d0 <rtems_filesystem_iterate>
10e46e: 83 c4 10 add $0x10,%esp
}
return fa.mount_h;
}
10e471: 8b 45 f4 mov -0xc(%ebp),%eax
10e474: c9 leave
10e475: c3 ret
001070fc <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 )
{
1070fc: 55 push %ebp
1070fd: 89 e5 mov %esp,%ebp
1070ff: 57 push %edi
107100: 56 push %esi
107101: 53 push %ebx
107102: 83 ec 2c sub $0x2c,%esp
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
107105: a1 80 30 12 00 mov 0x123080,%eax
10710a: c7 40 2c 12 00 00 00 movl $0x12,0x2c(%eax)
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
107111: 83 3d 80 d7 11 00 00 cmpl $0x0,0x11d780
107118: 75 0a jne 107124 <rtems_filesystem_initialize+0x28><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0001 );
10711a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10711d: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED
107122: eb 28 jmp 10714c <rtems_filesystem_initialize+0x50><== NOT EXECUTED
mt = &rtems_filesystem_mount_table[0];
107124: a1 4c 11 12 00 mov 0x12114c,%eax
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
107129: 83 ec 0c sub $0xc,%esp
10712c: 6a 00 push $0x0
10712e: ff 70 04 pushl 0x4(%eax)
107131: ff 30 pushl (%eax)
107133: ff 70 0c pushl 0xc(%eax)
107136: ff 70 08 pushl 0x8(%eax)
107139: e8 77 06 00 00 call 1077b5 <mount>
if ( status == -1 )
10713e: 83 c4 20 add $0x20,%esp
107141: 40 inc %eax
107142: 75 0d jne 107151 <rtems_filesystem_initialize+0x55><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0002 );
107144: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107147: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED
10714c: e8 e3 35 00 00 call 10a734 <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_filesystem_link_counts = 0;
107151: a1 80 30 12 00 mov 0x123080,%eax
107156: 66 c7 40 30 00 00 movw $0x0,0x30(%eax)
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
10715c: 83 ec 0c sub $0xc,%esp
10715f: 6a 00 push $0x0
107161: 8d 5d d4 lea -0x2c(%ebp),%ebx
107164: 53 push %ebx
107165: 6a 00 push $0x0
107167: 6a 01 push $0x1
107169: 68 d4 ee 11 00 push $0x11eed4
10716e: e8 03 01 00 00 call 107276 <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
107173: 8b 3d 80 30 12 00 mov 0x123080,%edi
107179: 83 c7 18 add $0x18,%edi
10717c: b9 05 00 00 00 mov $0x5,%ecx
107181: 89 de mov %ebx,%esi
107183: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
107185: 83 c4 14 add $0x14,%esp
107188: 6a 00 push $0x0
10718a: 53 push %ebx
10718b: 6a 00 push $0x0
10718d: 6a 01 push $0x1
10718f: 68 d4 ee 11 00 push $0x11eed4
107194: e8 dd 00 00 00 call 107276 <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
107199: 8b 3d 80 30 12 00 mov 0x123080,%edi
10719f: 83 c7 04 add $0x4,%edi
1071a2: b9 05 00 00 00 mov $0x5,%ecx
1071a7: 89 de mov %ebx,%esi
1071a9: 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);
1071ab: 83 c4 18 add $0x18,%esp
1071ae: 68 ff 01 00 00 push $0x1ff
1071b3: 68 d6 ee 11 00 push $0x11eed6
1071b8: e8 c3 04 00 00 call 107680 <mkdir>
if ( status != 0 )
1071bd: 83 c4 10 add $0x10,%esp
1071c0: 85 c0 test %eax,%eax
1071c2: 74 0d je 1071d1 <rtems_filesystem_initialize+0xd5><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0003 );
1071c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1071c7: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED
1071cc: e9 7b ff ff ff jmp 10714c <rtems_filesystem_initialize+0x50><== NOT EXECUTED
* it will be mounted onto is created. Moreover, if it is going to
* use a device, then it is REALLY unfair to attempt this
* before device drivers are initialized. So we return via a base
* filesystem image and nothing auto-mounted at this point.
*/
}
1071d1: 8d 65 f4 lea -0xc(%ebp),%esp
1071d4: 5b pop %ebx
1071d5: 5e pop %esi
1071d6: 5f pop %edi
1071d7: c9 leave
1071d8: c3 ret
0010e3d0 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
10e3d0: 55 push %ebp
10e3d1: 89 e5 mov %esp,%ebp
10e3d3: 57 push %edi
10e3d4: 56 push %esi
10e3d5: 53 push %ebx
10e3d6: 83 ec 1c sub $0x1c,%esp
10e3d9: 8b 75 08 mov 0x8(%ebp),%esi
10e3dc: 8b 7d 0c mov 0xc(%ebp),%edi
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
10e3df: 31 c0 xor %eax,%eax
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
10e3e1: bb 60 d7 11 00 mov $0x11d760,%ebx
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
10e3e6: eb 0c jmp 10e3f4 <rtems_filesystem_iterate+0x24>
stop = (*routine)( table_entry, routine_arg );
10e3e8: 51 push %ecx
10e3e9: 51 push %ecx
10e3ea: 57 push %edi
10e3eb: 53 push %ebx
10e3ec: ff d6 call *%esi
++table_entry;
10e3ee: 83 c3 08 add $0x8,%ebx
10e3f1: 83 c4 10 add $0x10,%esp
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
10e3f4: 83 3b 00 cmpl $0x0,(%ebx)
10e3f7: 74 06 je 10e3ff <rtems_filesystem_iterate+0x2f>
10e3f9: 84 c0 test %al,%al
10e3fb: 74 eb je 10e3e8 <rtems_filesystem_iterate+0x18>
10e3fd: eb 40 jmp 10e43f <rtems_filesystem_iterate+0x6f>
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
10e3ff: 84 c0 test %al,%al
10e401: 75 3c jne 10e43f <rtems_filesystem_iterate+0x6f>
rtems_libio_lock();
10e403: 88 45 e4 mov %al,-0x1c(%ebp)
10e406: e8 95 ff ff ff call 10e3a0 <rtems_libio_lock>
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
10e40b: 8b 1d a8 30 12 00 mov 0x1230a8,%ebx
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
10e411: 8a 55 e4 mov -0x1c(%ebp),%dl
10e414: eb 10 jmp 10e426 <rtems_filesystem_iterate+0x56>
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
10e416: 52 push %edx
10e417: 52 push %edx
10e418: 57 push %edi
10e419: 8d 43 08 lea 0x8(%ebx),%eax
10e41c: 50 push %eax
10e41d: ff d6 call *%esi
10e41f: 88 c2 mov %al,%dl
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
10e421: 8b 1b mov (%ebx),%ebx
if ( !stop ) {
rtems_libio_lock();
for (
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
node = rtems_chain_next( node )
10e423: 83 c4 10 add $0x10,%esp
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
10e426: 81 fb ac 30 12 00 cmp $0x1230ac,%ebx
10e42c: 74 04 je 10e432 <rtems_filesystem_iterate+0x62>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
10e42e: 84 d2 test %dl,%dl
10e430: 74 e4 je 10e416 <rtems_filesystem_iterate+0x46><== ALWAYS TAKEN
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
}
rtems_libio_unlock();
10e432: 88 55 e4 mov %dl,-0x1c(%ebp)
10e435: e8 80 ff ff ff call 10e3ba <rtems_libio_unlock>
10e43a: 8a 55 e4 mov -0x1c(%ebp),%dl
10e43d: 88 d0 mov %dl,%al
}
return stop;
}
10e43f: 8d 65 f4 lea -0xc(%ebp),%esp
10e442: 5b pop %ebx
10e443: 5e pop %esi
10e444: 5f pop %edi
10e445: c9 leave
10e446: c3 ret
0010776d <rtems_filesystem_mount_iterate>:
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
10776d: 55 push %ebp
10776e: 89 e5 mov %esp,%ebp
107770: 57 push %edi
107771: 56 push %esi
107772: 53 push %ebx
107773: 83 ec 1c sub $0x1c,%esp
107776: 8b 7d 08 mov 0x8(%ebp),%edi
107779: 8b 75 0c mov 0xc(%ebp),%esi
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
10777c: e8 bc ff ff ff call 10773d <rtems_libio_lock>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
107781: 8b 1d 64 2f 12 00 mov 0x122f64,%ebx
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
rtems_chain_node *node = NULL;
bool stop = false;
107787: 31 c0 xor %eax,%eax
rtems_libio_lock();
for (
107789: eb 0b jmp 107796 <rtems_filesystem_mount_iterate+0x29>
node = rtems_chain_next( node )
) {
const rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) node;
stop = (*routine)( mt_entry, routine_arg );
10778b: 50 push %eax
10778c: 50 push %eax
10778d: 56 push %esi
10778e: 53 push %ebx
10778f: ff d7 call *%edi
}
rtems_libio_unlock();
return stop;
}
107791: 8b 1b mov (%ebx),%ebx
rtems_libio_lock();
for (
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
node = rtems_chain_next( node )
107793: 83 c4 10 add $0x10,%esp
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
107796: 81 fb 68 2f 12 00 cmp $0x122f68,%ebx
10779c: 74 04 je 1077a2 <rtems_filesystem_mount_iterate+0x35>
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
10779e: 84 c0 test %al,%al
1077a0: 74 e9 je 10778b <rtems_filesystem_mount_iterate+0x1e><== ALWAYS TAKEN
const rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) node;
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
1077a2: 88 45 e4 mov %al,-0x1c(%ebp)
1077a5: e8 ad ff ff ff call 107757 <rtems_libio_unlock>
return stop;
}
1077aa: 8a 45 e4 mov -0x1c(%ebp),%al
1077ad: 8d 65 f4 lea -0xc(%ebp),%esp
1077b0: 5b pop %ebx
1077b1: 5e pop %esi
1077b2: 5f pop %edi
1077b3: c9 leave
1077b4: c3 ret
001072f6 <rtems_filesystem_prefix_separators>:
int rtems_filesystem_prefix_separators(
const char *pathname,
int pathnamelen
)
{
1072f6: 55 push %ebp
1072f7: 89 e5 mov %esp,%ebp
1072f9: 57 push %edi
1072fa: 56 push %esi
1072fb: 53 push %ebx
1072fc: 83 ec 0c sub $0xc,%esp
1072ff: 8b 7d 08 mov 0x8(%ebp),%edi
107302: 8b 75 0c mov 0xc(%ebp),%esi
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
107305: 31 db xor %ebx,%ebx
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
107307: eb 01 jmp 10730a <rtems_filesystem_prefix_separators+0x14>
{
pathname++;
pathnamelen--;
stripped++;
107309: 43 inc %ebx
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
10730a: 8a 04 1f mov (%edi,%ebx,1),%al
10730d: 39 de cmp %ebx,%esi
10730f: 74 17 je 107328 <rtems_filesystem_prefix_separators+0x32><== NEVER TAKEN
107311: 84 c0 test %al,%al
107313: 74 13 je 107328 <rtems_filesystem_prefix_separators+0x32><== NEVER TAKEN
107315: 83 ec 0c sub $0xc,%esp
107318: 0f be c0 movsbl %al,%eax
10731b: 50 push %eax
10731c: e8 df 0c 00 00 call 108000 <rtems_filesystem_is_separator>
107321: 83 c4 10 add $0x10,%esp
107324: 85 c0 test %eax,%eax
107326: 75 e1 jne 107309 <rtems_filesystem_prefix_separators+0x13>
pathname++;
pathnamelen--;
stripped++;
}
return stripped;
}
107328: 89 d8 mov %ebx,%eax
10732a: 8d 65 f4 lea -0xc(%ebp),%esp
10732d: 5b pop %ebx
10732e: 5e pop %esi
10732f: 5f pop %edi
107330: c9 leave
107331: c3 ret
00107bbd <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
107bbd: 55 push %ebp
107bbe: 89 e5 mov %esp,%ebp
107bc0: 56 push %esi
107bc1: 53 push %ebx
107bc2: 8b 75 0c mov 0xc(%ebp),%esi
* pointer to the buffer that will hold the value of the key itself.
* We have to to this, because the others functions on this interface
* deal with the value of the key, as used with the POSIX API.
*/
/* Do not pull your hair, trust me this works. :-) */
__gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
107bc5: 83 ec 0c sub $0xc,%esp
107bc8: 6a 08 push $0x8
107bca: e8 89 03 00 00 call 107f58 <malloc>
107bcf: 89 c3 mov %eax,%ebx
*key = new_key;
107bd1: 8b 45 08 mov 0x8(%ebp),%eax
107bd4: 89 18 mov %ebx,(%eax)
new_key->val = NULL;
107bd6: c7 03 00 00 00 00 movl $0x0,(%ebx)
new_key->dtor = dtor;
107bdc: 89 73 04 mov %esi,0x4(%ebx)
"gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
107bdf: 83 c4 0c add $0xc,%esp
107be2: 56 push %esi
107be3: 53 push %ebx
107be4: 6a 00 push $0x0
107be6: e8 1d 34 00 00 call 10b008 <rtems_task_variable_add>
107beb: 89 c2 mov %eax,%edx
if ( status == RTEMS_SUCCESSFUL )
107bed: 83 c4 10 add $0x10,%esp
return 0;
107bf0: 31 c0 xor %eax,%eax
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
if ( status == RTEMS_SUCCESSFUL )
107bf2: 85 d2 test %edx,%edx
107bf4: 74 0f je 107c05 <rtems_gxx_key_create+0x48><== ALWAYS TAKEN
return 0;
free( new_key );
107bf6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
107bf9: 53 push %ebx <== NOT EXECUTED
107bfa: e8 79 fe ff ff call 107a78 <free> <== NOT EXECUTED
return -1;
107bff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
107c02: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
}
107c05: 8d 65 f8 lea -0x8(%ebp),%esp
107c08: 5b pop %ebx
107c09: 5e pop %esi
107c0a: c9 leave
107c0b: c3 ret
00107c1c <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
107c1c: 55 push %ebp
107c1d: 89 e5 mov %esp,%ebp
107c1f: 53 push %ebx
107c20: 83 ec 0c sub $0xc,%esp
107c23: 8b 5d 08 mov 0x8(%ebp),%ebx
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: delete key=%x\n", key );
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_delete( RTEMS_SELF, (void **)key );
107c26: 53 push %ebx
107c27: 6a 00 push $0x0
107c29: e8 6e 34 00 00 call 10b09c <rtems_task_variable_delete>
if ( status == RTEMS_SUCCESSFUL ) {
107c2e: 83 c4 10 add $0x10,%esp
107c31: 85 c0 test %eax,%eax
107c33: 75 11 jne 107c46 <rtems_gxx_key_delete+0x2a><== NEVER TAKEN
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
107c35: 85 db test %ebx,%ebx
107c37: 74 0d je 107c46 <rtems_gxx_key_delete+0x2a><== NEVER TAKEN
107c39: 83 ec 0c sub $0xc,%esp
107c3c: ff 33 pushl (%ebx)
107c3e: e8 35 fe ff ff call 107a78 <free>
107c43: 83 c4 10 add $0x10,%esp
return 0;
}
key = NULL;
return 0;
}
107c46: 31 c0 xor %eax,%eax
107c48: 8b 5d fc mov -0x4(%ebp),%ebx
107c4b: c9 leave
107c4c: c3 ret
00107b64 <rtems_gxx_once>:
/* uncomment this if you need to debug this interface */
/*#define DEBUG_GXX_WRAPPERS 1*/
int rtems_gxx_once(__gthread_once_t *once, void (*func) (void))
{
107b64: 55 push %ebp
107b65: 89 e5 mov %esp,%ebp
107b67: 56 push %esi
107b68: 53 push %ebx
107b69: 83 ec 10 sub $0x10,%esp
107b6c: 8b 5d 08 mov 0x8(%ebp),%ebx
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
107b6f: 8b 03 mov (%ebx),%eax
107b71: 85 c0 test %eax,%eax
107b73: 75 3f jne 107bb4 <rtems_gxx_once+0x50>
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
107b75: 52 push %edx
107b76: 8d 45 f4 lea -0xc(%ebp),%eax
107b79: 50 push %eax
107b7a: 68 00 01 00 00 push $0x100
107b7f: 68 00 01 00 00 push $0x100
107b84: e8 ff 32 00 00 call 10ae88 <rtems_task_mode>
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
107b89: 8b 33 mov (%ebx),%esi
107b8b: 83 c4 10 add $0x10,%esp
107b8e: 85 f6 test %esi,%esi
107b90: 75 06 jne 107b98 <rtems_gxx_once+0x34> <== NEVER TAKEN
*(volatile __gthread_once_t *)once = 1;
107b92: c7 03 01 00 00 00 movl $0x1,(%ebx)
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
107b98: 50 push %eax
107b99: 8d 45 f4 lea -0xc(%ebp),%eax
107b9c: 50 push %eax
107b9d: 68 00 01 00 00 push $0x100
107ba2: ff 75 f4 pushl -0xc(%ebp)
107ba5: e8 de 32 00 00 call 10ae88 <rtems_task_mode>
if ( o == 0 )
107baa: 83 c4 10 add $0x10,%esp
107bad: 85 f6 test %esi,%esi
107baf: 75 03 jne 107bb4 <rtems_gxx_once+0x50> <== NEVER TAKEN
(*func)();
107bb1: ff 55 0c call *0xc(%ebp)
}
return 0;
}
107bb4: 31 c0 xor %eax,%eax
107bb6: 8d 65 f8 lea -0x8(%ebp),%esp
107bb9: 5b pop %ebx
107bba: 5e pop %esi
107bbb: c9 leave
107bbc: c3 ret
00107ca5 <rtems_gxx_setspecific>:
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
107ca5: 55 push %ebp
107ca6: 89 e5 mov %esp,%ebp
107ca8: 53 push %ebx
107ca9: 83 ec 08 sub $0x8,%esp
107cac: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_task_self()
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
107caf: ff 73 04 pushl 0x4(%ebx)
107cb2: 53 push %ebx
107cb3: 6a 00 push $0x0
107cb5: e8 4e 33 00 00 call 10b008 <rtems_task_variable_add>
107cba: 89 c2 mov %eax,%edx
if ( status == RTEMS_SUCCESSFUL ) {
107cbc: 83 c4 10 add $0x10,%esp
/* now let's set the proper value */
key->val = (void *)ptr;
return 0;
}
return -1;
107cbf: 83 c8 ff or $0xffffffff,%eax
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
if ( status == RTEMS_SUCCESSFUL ) {
107cc2: 85 d2 test %edx,%edx
107cc4: 75 07 jne 107ccd <rtems_gxx_setspecific+0x28><== NEVER TAKEN
/* now let's set the proper value */
key->val = (void *)ptr;
107cc6: 8b 45 0c mov 0xc(%ebp),%eax
107cc9: 89 03 mov %eax,(%ebx)
return 0;
107ccb: 31 c0 xor %eax,%eax
}
return -1;
}
107ccd: 8b 5d fc mov -0x4(%ebp),%ebx
107cd0: c9 leave
107cd1: c3 ret
0010a930 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
10a930: 55 push %ebp
10a931: 89 e5 mov %esp,%ebp
10a933: 83 ec 08 sub $0x8,%esp
if (
10a936: 83 3d 88 c5 12 00 03 cmpl $0x3,0x12c588
10a93d: 75 0d jne 10a94c <rtems_heap_allocate_aligned_with_boundary+0x1c><== NEVER TAKEN
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
10a93f: e8 34 f1 ff ff call 109a78 <malloc_is_system_state_OK>
10a944: 88 c2 mov %al,%dl
) {
return NULL;
10a946: 31 c0 xor %eax,%eax
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
10a948: 84 d2 test %dl,%dl
10a94a: 74 1c je 10a968 <rtems_heap_allocate_aligned_with_boundary+0x38>
) {
return NULL;
}
malloc_deferred_frees_process();
10a94c: e8 65 f1 ff ff call 109ab6 <malloc_deferred_frees_process>
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
10a951: ff 75 10 pushl 0x10(%ebp)
10a954: ff 75 0c pushl 0xc(%ebp)
10a957: ff 75 08 pushl 0x8(%ebp)
10a95a: ff 35 40 79 12 00 pushl 0x127940
10a960: e8 d7 43 00 00 call 10ed3c <_Protected_heap_Allocate_aligned_with_boundary>
10a965: 83 c4 10 add $0x10,%esp
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
10a968: c9 leave
10a969: c3 ret
00107022 <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
107022: 55 push %ebp
107023: 89 e5 mov %esp,%ebp
107025: 57 push %edi
107026: 56 push %esi
107027: 53 push %ebx
107028: 83 ec 48 sub $0x48,%esp
10702b: 8b 75 08 mov 0x8(%ebp),%esi
IMFS_jnode_t *the_jnode;
rtems_filesystem_location_info_t loc;
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path(
10702e: 31 c0 xor %eax,%eax
107030: 83 c9 ff or $0xffffffff,%ecx
107033: 89 f7 mov %esi,%edi
107035: f2 ae repnz scas %es:(%edi),%al
107037: f7 d1 not %ecx
107039: 49 dec %ecx
10703a: 6a 01 push $0x1
10703c: 8d 55 d4 lea -0x2c(%ebp),%edx
10703f: 52 push %edx
107040: 6a 00 push $0x0
107042: 51 push %ecx
107043: 56 push %esi
107044: 89 55 c4 mov %edx,-0x3c(%ebp)
107047: e8 2a 02 00 00 call 107276 <rtems_filesystem_evaluate_path>
10704c: 89 c7 mov %eax,%edi
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
10704e: 8b 5d d4 mov -0x2c(%ebp),%ebx
node_type = (*loc.ops->node_type_h)( &loc );
107051: 83 c4 14 add $0x14,%esp
107054: 8b 55 c4 mov -0x3c(%ebp),%edx
107057: 52 push %edx
107058: 8b 45 e0 mov -0x20(%ebp),%eax
10705b: ff 50 10 call *0x10(%eax)
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
10705e: 83 c4 10 add $0x10,%esp
107061: 83 f8 02 cmp $0x2,%eax
107064: 8b 55 c4 mov -0x3c(%ebp),%edx
107067: 75 07 jne 107070 <rtems_io_lookup_name+0x4e>
107069: 85 ff test %edi,%edi
10706b: 0f 95 c0 setne %al
10706e: 74 16 je 107086 <rtems_io_lookup_name+0x64><== ALWAYS TAKEN
rtems_filesystem_freenode( &loc );
107070: 83 ec 0c sub $0xc,%esp
107073: 8d 45 d4 lea -0x2c(%ebp),%eax
107076: 50 push %eax
107077: e8 b8 02 00 00 call 107334 <rtems_filesystem_freenode>
return RTEMS_UNSATISFIED;
10707c: 83 c4 10 add $0x10,%esp
10707f: b8 0d 00 00 00 mov $0xd,%eax
107084: eb 32 jmp 1070b8 <rtems_io_lookup_name+0x96>
}
device_info->device_name = (char *) name;
107086: 8b 4d 0c mov 0xc(%ebp),%ecx
107089: 89 31 mov %esi,(%ecx)
device_info->device_name_length = strlen( name );
10708b: 83 c9 ff or $0xffffffff,%ecx
10708e: 89 f7 mov %esi,%edi
107090: f2 ae repnz scas %es:(%edi),%al
107092: f7 d1 not %ecx
107094: 49 dec %ecx
107095: 8b 45 0c mov 0xc(%ebp),%eax
107098: 89 48 04 mov %ecx,0x4(%eax)
device_info->major = the_jnode->info.device.major;
10709b: 8b 43 50 mov 0x50(%ebx),%eax
10709e: 8b 4d 0c mov 0xc(%ebp),%ecx
1070a1: 89 41 08 mov %eax,0x8(%ecx)
device_info->minor = the_jnode->info.device.minor;
1070a4: 8b 43 54 mov 0x54(%ebx),%eax
1070a7: 89 41 0c mov %eax,0xc(%ecx)
rtems_filesystem_freenode( &loc );
1070aa: 83 ec 0c sub $0xc,%esp
1070ad: 52 push %edx
1070ae: e8 81 02 00 00 call 107334 <rtems_filesystem_freenode>
return RTEMS_SUCCESSFUL;
1070b3: 83 c4 10 add $0x10,%esp
1070b6: 31 c0 xor %eax,%eax
}
1070b8: 8d 65 f4 lea -0xc(%ebp),%esp
1070bb: 5b pop %ebx
1070bc: 5e pop %esi
1070bd: 5f pop %edi
1070be: c9 leave
1070bf: c3 ret
0010b714 <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
)
{
10b714: 55 push %ebp
10b715: 89 e5 mov %esp,%ebp
10b717: 57 push %edi
10b718: 56 push %esi
10b719: 53 push %ebx
10b71a: 83 ec 0c sub $0xc,%esp
10b71d: 8b 5d 08 mov 0x8(%ebp),%ebx
10b720: 8b 75 0c mov 0xc(%ebp),%esi
10b723: 8b 45 10 mov 0x10(%ebp),%eax
rtems_device_major_number major_limit = _IO_Number_of_drivers;
10b726: 8b 15 78 8d 12 00 mov 0x128d78,%edx
if ( rtems_interrupt_is_in_progress() )
10b72c: 83 3d 1c 89 12 00 00 cmpl $0x0,0x12891c
10b733: 0f 85 cc 00 00 00 jne 10b805 <rtems_io_register_driver+0xf1><== NEVER TAKEN
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
10b739: 85 c0 test %eax,%eax
10b73b: 0f 84 cb 00 00 00 je 10b80c <rtems_io_register_driver+0xf8>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
10b741: 89 10 mov %edx,(%eax)
if ( driver_table == NULL )
10b743: 85 f6 test %esi,%esi
10b745: 0f 84 c1 00 00 00 je 10b80c <rtems_io_register_driver+0xf8>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10b74b: 83 3e 00 cmpl $0x0,(%esi)
10b74e: 0f 85 cc 00 00 00 jne 10b820 <rtems_io_register_driver+0x10c>
10b754: 83 7e 04 00 cmpl $0x0,0x4(%esi)
10b758: 0f 85 c2 00 00 00 jne 10b820 <rtems_io_register_driver+0x10c>
10b75e: e9 a9 00 00 00 jmp 10b80c <rtems_io_register_driver+0xf8>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b763: 8b 15 f8 83 12 00 mov 0x1283f8,%edx
10b769: 42 inc %edx
10b76a: 89 15 f8 83 12 00 mov %edx,0x1283f8
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
10b770: 85 db test %ebx,%ebx
10b772: 75 32 jne 10b7a6 <rtems_io_register_driver+0x92>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
10b774: 8b 0d 78 8d 12 00 mov 0x128d78,%ecx
10b77a: 8b 15 7c 8d 12 00 mov 0x128d7c,%edx
10b780: eb 15 jmp 10b797 <rtems_io_register_driver+0x83>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10b782: 83 3a 00 cmpl $0x0,(%edx)
10b785: 0f 85 9f 00 00 00 jne 10b82a <rtems_io_register_driver+0x116>
10b78b: 83 7a 04 00 cmpl $0x0,0x4(%edx)
10b78f: 0f 85 95 00 00 00 jne 10b82a <rtems_io_register_driver+0x116>
10b795: eb 04 jmp 10b79b <rtems_io_register_driver+0x87>
rtems_device_major_number n = _IO_Number_of_drivers;
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
10b797: 39 cb cmp %ecx,%ebx
10b799: 72 e7 jb 10b782 <rtems_io_register_driver+0x6e>
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
10b79b: 89 18 mov %ebx,(%eax)
if ( m != n )
10b79d: 39 cb cmp %ecx,%ebx
10b79f: 75 30 jne 10b7d1 <rtems_io_register_driver+0xbd>
10b7a1: e9 8d 00 00 00 jmp 10b833 <rtems_io_register_driver+0x11f>
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
10b7a6: 6b d3 18 imul $0x18,%ebx,%edx
10b7a9: 03 15 7c 8d 12 00 add 0x128d7c,%edx
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
10b7af: 31 c9 xor %ecx,%ecx
10b7b1: 83 3a 00 cmpl $0x0,(%edx)
10b7b4: 75 09 jne 10b7bf <rtems_io_register_driver+0xab>
10b7b6: 31 c9 xor %ecx,%ecx
10b7b8: 83 7a 04 00 cmpl $0x0,0x4(%edx)
10b7bc: 0f 94 c1 sete %cl
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
10b7bf: 85 c9 test %ecx,%ecx
10b7c1: 75 0c jne 10b7cf <rtems_io_register_driver+0xbb>
_Thread_Enable_dispatch();
10b7c3: e8 ee 1a 00 00 call 10d2b6 <_Thread_Enable_dispatch>
return RTEMS_RESOURCE_IN_USE;
10b7c8: b8 0c 00 00 00 mov $0xc,%eax
10b7cd: eb 49 jmp 10b818 <rtems_io_register_driver+0x104>
}
*registered_major = major;
10b7cf: 89 18 mov %ebx,(%eax)
}
_IO_Driver_address_table [major] = *driver_table;
10b7d1: 6b c3 18 imul $0x18,%ebx,%eax
10b7d4: 03 05 7c 8d 12 00 add 0x128d7c,%eax
10b7da: b9 06 00 00 00 mov $0x6,%ecx
10b7df: 89 c7 mov %eax,%edi
10b7e1: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
_Thread_Enable_dispatch();
10b7e3: e8 ce 1a 00 00 call 10d2b6 <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
10b7e8: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp)
10b7ef: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp)
10b7f6: 89 5d 08 mov %ebx,0x8(%ebp)
}
10b7f9: 83 c4 0c add $0xc,%esp
10b7fc: 5b pop %ebx
10b7fd: 5e pop %esi
10b7fe: 5f pop %edi
10b7ff: c9 leave
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
10b800: e9 9b 71 00 00 jmp 1129a0 <rtems_io_initialize>
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
10b805: b8 12 00 00 00 mov $0x12,%eax
10b80a: eb 0c jmp 10b818 <rtems_io_register_driver+0x104>
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
10b80c: b8 09 00 00 00 mov $0x9,%eax
10b811: eb 05 jmp 10b818 <rtems_io_register_driver+0x104>
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
10b813: b8 0a 00 00 00 mov $0xa,%eax
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
10b818: 83 c4 0c add $0xc,%esp
10b81b: 5b pop %ebx
10b81c: 5e pop %esi
10b81d: 5f pop %edi
10b81e: c9 leave
10b81f: c3 ret
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
10b820: 39 d3 cmp %edx,%ebx
10b822: 0f 82 3b ff ff ff jb 10b763 <rtems_io_register_driver+0x4f>
10b828: eb e9 jmp 10b813 <rtems_io_register_driver+0xff>
rtems_device_major_number n = _IO_Number_of_drivers;
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
10b82a: 43 inc %ebx
10b82b: 83 c2 18 add $0x18,%edx
10b82e: e9 64 ff ff ff jmp 10b797 <rtems_io_register_driver+0x83>
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
10b833: e8 7e 1a 00 00 call 10d2b6 <_Thread_Enable_dispatch>
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
10b838: b8 05 00 00 00 mov $0x5,%eax
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
return sc;
10b83d: eb d9 jmp 10b818 <rtems_io_register_driver+0x104>
0010c744 <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)
{
10c744: 55 push %ebp
10c745: 89 e5 mov %esp,%ebp
10c747: 57 push %edi
10c748: 56 push %esi
10c749: 53 push %ebx
10c74a: 83 ec 0c sub $0xc,%esp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
10c74d: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
10c751: 74 3d je 10c790 <rtems_iterate_over_all_threads+0x4c><== NEVER TAKEN
10c753: bb 01 00 00 00 mov $0x1,%ebx
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
10c758: 8b 04 9d bc 8f 12 00 mov 0x128fbc(,%ebx,4),%eax
10c75f: 8b 78 04 mov 0x4(%eax),%edi
if ( !information )
10c762: be 01 00 00 00 mov $0x1,%esi
10c767: 85 ff test %edi,%edi
10c769: 75 17 jne 10c782 <rtems_iterate_over_all_threads+0x3e>
10c76b: eb 1d jmp 10c78a <rtems_iterate_over_all_threads+0x46>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
10c76d: 8b 47 1c mov 0x1c(%edi),%eax
10c770: 8b 04 b0 mov (%eax,%esi,4),%eax
if ( !the_thread )
10c773: 85 c0 test %eax,%eax
10c775: 74 0a je 10c781 <rtems_iterate_over_all_threads+0x3d><== NEVER TAKEN
continue;
(*routine)(the_thread);
10c777: 83 ec 0c sub $0xc,%esp
10c77a: 50 push %eax
10c77b: ff 55 08 call *0x8(%ebp)
10c77e: 83 c4 10 add $0x10,%esp
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
10c781: 46 inc %esi
10c782: 0f b7 47 10 movzwl 0x10(%edi),%eax
10c786: 39 c6 cmp %eax,%esi
10c788: 76 e3 jbe 10c76d <rtems_iterate_over_all_threads+0x29>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
10c78a: 43 inc %ebx
10c78b: 83 fb 04 cmp $0x4,%ebx
10c78e: 75 c8 jne 10c758 <rtems_iterate_over_all_threads+0x14>
(*routine)(the_thread);
}
}
}
10c790: 8d 65 f4 lea -0xc(%ebp),%esp
10c793: 5b pop %ebx
10c794: 5e pop %esi
10c795: 5f pop %edi
10c796: c9 leave
10c797: c3 ret
0010e2a4 <rtems_libio_free>:
*/
void rtems_libio_free(
rtems_libio_t *iop
)
{
10e2a4: 55 push %ebp
10e2a5: 89 e5 mov %esp,%ebp
10e2a7: 53 push %ebx
10e2a8: 83 ec 04 sub $0x4,%esp
10e2ab: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_libio_lock();
10e2ae: e8 d5 fe ff ff call 10e188 <rtems_libio_lock>
if (iop->sem)
10e2b3: 8b 43 2c mov 0x2c(%ebx),%eax
10e2b6: 85 c0 test %eax,%eax
10e2b8: 74 0c je 10e2c6 <rtems_libio_free+0x22> <== NEVER TAKEN
rtems_semaphore_delete(iop->sem);
10e2ba: 83 ec 0c sub $0xc,%esp
10e2bd: 50 push %eax
10e2be: e8 15 be ff ff call 10a0d8 <rtems_semaphore_delete>
10e2c3: 83 c4 10 add $0x10,%esp
iop->flags &= ~LIBIO_FLAGS_OPEN;
10e2c6: 81 63 14 ff fe ff ff andl $0xfffffeff,0x14(%ebx)
iop->data1 = rtems_libio_iop_freelist;
10e2cd: a1 fc 51 12 00 mov 0x1251fc,%eax
10e2d2: 89 43 34 mov %eax,0x34(%ebx)
rtems_libio_iop_freelist = iop;
10e2d5: 89 1d fc 51 12 00 mov %ebx,0x1251fc
rtems_libio_unlock();
}
10e2db: 8b 5d fc mov -0x4(%ebp),%ebx
10e2de: c9 leave
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
rtems_libio_unlock();
10e2df: e9 be fe ff ff jmp 10e1a2 <rtems_libio_unlock>
00107434 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
107434: 55 push %ebp
107435: 89 e5 mov %esp,%ebp
107437: 53 push %ebx
107438: 83 ec 04 sub $0x4,%esp
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
10743b: 8b 1d 44 11 12 00 mov 0x121144,%ebx
107441: 85 db test %ebx,%ebx
107443: 74 3e je 107483 <rtems_libio_init+0x4f> <== NEVER TAKEN
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
107445: 50 push %eax
107446: 50 push %eax
107447: 6a 38 push $0x38
107449: 53 push %ebx
10744a: e8 8d fd ff ff call 1071dc <calloc>
10744f: a3 f8 51 12 00 mov %eax,0x1251f8
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
107454: 83 c4 10 add $0x10,%esp
107457: 85 c0 test %eax,%eax
107459: 75 07 jne 107462 <rtems_libio_init+0x2e>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
10745b: 83 ec 0c sub $0xc,%esp
10745e: 6a 1a push $0x1a
107460: eb 44 jmp 1074a6 <rtems_libio_init+0x72>
iop = rtems_libio_iop_freelist = rtems_libio_iops;
107462: a3 fc 51 12 00 mov %eax,0x1251fc
107467: 89 c2 mov %eax,%edx
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
107469: 31 c9 xor %ecx,%ecx
10746b: eb 03 jmp 107470 <rtems_libio_init+0x3c>
iop->data1 = iop + 1;
10746d: 89 52 fc mov %edx,-0x4(%edx)
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
107470: 41 inc %ecx
107471: 83 c2 38 add $0x38,%edx
107474: 39 d9 cmp %ebx,%ecx
107476: 72 f5 jb 10746d <rtems_libio_init+0x39>
iop->data1 = iop + 1;
iop->data1 = NULL;
107478: 6b db 38 imul $0x38,%ebx,%ebx
10747b: c7 44 18 fc 00 00 00 movl $0x0,-0x4(%eax,%ebx,1)
107482: 00
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
107483: 83 ec 0c sub $0xc,%esp
107486: 68 00 52 12 00 push $0x125200
10748b: 6a 00 push $0x0
10748d: 6a 54 push $0x54
10748f: 6a 01 push $0x1
107491: 68 4f 49 42 4c push $0x4c42494f
107496: e8 a5 2a 00 00 call 109f40 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
10749b: 83 c4 20 add $0x20,%esp
10749e: 85 c0 test %eax,%eax
1074a0: 74 09 je 1074ab <rtems_libio_init+0x77> <== ALWAYS TAKEN
rtems_fatal_error_occurred( rc );
1074a2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1074a5: 50 push %eax <== NOT EXECUTED
1074a6: e8 89 32 00 00 call 10a734 <rtems_fatal_error_occurred>
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
1074ab: a1 40 11 12 00 mov 0x121140,%eax
1074b0: 85 c0 test %eax,%eax
1074b2: 74 06 je 1074ba <rtems_libio_init+0x86> <== NEVER TAKEN
(* rtems_fs_init_helper)();
}
1074b4: 8b 5d fc mov -0x4(%ebp),%ebx
1074b7: c9 leave
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
(* rtems_fs_init_helper)();
1074b8: ff e0 jmp *%eax
}
1074ba: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED
1074bd: c9 leave <== NOT EXECUTED
1074be: c3 ret <== NOT EXECUTED
001085fd <rtems_libio_set_private_env>:
rtems_status_code rtems_libio_set_private_env(void)
{
1085fd: 55 push %ebp
1085fe: 89 e5 mov %esp,%ebp
108600: 57 push %edi
108601: 56 push %esi
108602: 53 push %ebx
108603: 83 ec 3c sub $0x3c,%esp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id task_id = rtems_task_self();
108606: e8 4d 27 00 00 call 10ad58 <rtems_task_self>
10860b: 89 c3 mov %eax,%ebx
rtems_filesystem_location_info_t root_loc;
rtems_filesystem_location_info_t current_loc;
rtems_user_env_t *new_env = NULL;
int rv = 0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);
10860d: 83 ec 0c sub $0xc,%esp
108610: 6a 00 push $0x0
108612: 8d 45 d4 lea -0x2c(%ebp),%eax
108615: 50 push %eax
108616: 6a 00 push $0x0
108618: 6a 01 push $0x1
10861a: 68 3c f7 11 00 push $0x11f73c
10861f: e8 66 f0 ff ff call 10768a <rtems_filesystem_evaluate_path>
108624: 89 c2 mov %eax,%edx
if (rv != 0)
108626: 83 c4 20 add $0x20,%esp
error_1:
rtems_filesystem_freenode(&root_loc);
error_0:
return RTEMS_NO_MEMORY;
108629: b8 1a 00 00 00 mov $0x1a,%eax
rtems_filesystem_location_info_t current_loc;
rtems_user_env_t *new_env = NULL;
int rv = 0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);
if (rv != 0)
10862e: 85 d2 test %edx,%edx
108630: 0f 85 c0 00 00 00 jne 1086f6 <rtems_libio_set_private_env+0xf9><== NEVER TAKEN
goto error_0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, ¤t_loc, 0);
108636: 83 ec 0c sub $0xc,%esp
108639: 6a 00 push $0x0
10863b: 8d 45 c0 lea -0x40(%ebp),%eax
10863e: 50 push %eax
10863f: 6a 00 push $0x0
108641: 6a 01 push $0x1
108643: 68 3c f7 11 00 push $0x11f73c
108648: e8 3d f0 ff ff call 10768a <rtems_filesystem_evaluate_path>
if (rv != 0)
10864d: 83 c4 20 add $0x20,%esp
108650: 85 c0 test %eax,%eax
108652: 0f 85 8a 00 00 00 jne 1086e2 <rtems_libio_set_private_env+0xe5><== NEVER TAKEN
* Bharath: I'm not sure if the check can be reduced to
* if( rtems_current_user_env->task_id != task_id ) {
*/
if (
rtems_current_user_env == &rtems_global_user_env
108658: a1 6c 30 12 00 mov 0x12306c,%eax
/*
* Bharath: I'm not sure if the check can be reduced to
* if( rtems_current_user_env->task_id != task_id ) {
*/
if (
10865d: 3d 48 52 12 00 cmp $0x125248,%eax
108662: 74 04 je 108668 <rtems_libio_set_private_env+0x6b>
rtems_current_user_env == &rtems_global_user_env
|| rtems_current_user_env->task_id != task_id
108664: 39 18 cmp %ebx,(%eax)
108666: 74 32 je 10869a <rtems_libio_set_private_env+0x9d>
) {
new_env = malloc(sizeof(rtems_user_env_t));
108668: 83 ec 0c sub $0xc,%esp
10866b: 6a 48 push $0x48
10866d: e8 8a f5 ff ff call 107bfc <malloc>
108672: 89 c6 mov %eax,%esi
if (new_env == NULL)
108674: 83 c4 10 add $0x10,%esp
108677: 85 c0 test %eax,%eax
108679: 74 58 je 1086d3 <rtems_libio_set_private_env+0xd6>
#ifdef HAVE_USERENV_REFCNT
new_env->refcnt = 1;
#endif
sc = rtems_task_variable_add(
10867b: 50 push %eax
10867c: 68 c0 85 10 00 push $0x1085c0
108681: 68 6c 30 12 00 push $0x12306c
108686: 6a 00 push $0x0
108688: e8 3f 27 00 00 call 10adcc <rtems_task_variable_add>
RTEMS_SELF,
(void*)&rtems_current_user_env,
(void(*)(void *))free_user_env
);
if (sc != RTEMS_SUCCESSFUL)
10868d: 83 c4 10 add $0x10,%esp
108690: 85 c0 test %eax,%eax
108692: 75 33 jne 1086c7 <rtems_libio_set_private_env+0xca>
goto error_3;
rtems_current_user_env = new_env;
108694: 89 35 6c 30 12 00 mov %esi,0x12306c
}
/* Inherit the global values */
*rtems_current_user_env = rtems_global_user_env;
10869a: a1 6c 30 12 00 mov 0x12306c,%eax
10869f: be 48 52 12 00 mov $0x125248,%esi
1086a4: b9 12 00 00 00 mov $0x12,%ecx
1086a9: 89 c7 mov %eax,%edi
1086ab: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rtems_current_user_env->task_id = task_id;
1086ad: 89 18 mov %ebx,(%eax)
* Clone the pathlocs. In contrast to most other code we must _not_ free the
* original locs because what we are trying to do here is forking off clones.
* The reason is a pathloc can be allocated by the file system and needs to
* be freed when deleting the environment.
*/
rtems_filesystem_root = root_loc;
1086af: 8d 78 18 lea 0x18(%eax),%edi
1086b2: 8d 75 d4 lea -0x2c(%ebp),%esi
1086b5: b1 05 mov $0x5,%cl
1086b7: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
rtems_filesystem_current = current_loc;
1086b9: 8d 78 04 lea 0x4(%eax),%edi
1086bc: 8d 75 c0 lea -0x40(%ebp),%esi
1086bf: b1 05 mov $0x5,%cl
1086c1: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
return RTEMS_SUCCESSFUL;
1086c3: 31 c0 xor %eax,%eax
1086c5: eb 2f jmp 1086f6 <rtems_libio_set_private_env+0xf9>
error_3:
free(new_env);
1086c7: 83 ec 0c sub $0xc,%esp
1086ca: 56 push %esi
1086cb: e8 8c f0 ff ff call 10775c <free>
1086d0: 83 c4 10 add $0x10,%esp
error_2:
rtems_filesystem_freenode(¤t_loc);
1086d3: 83 ec 0c sub $0xc,%esp
1086d6: 8d 45 c0 lea -0x40(%ebp),%eax
1086d9: 50 push %eax
1086da: e8 69 f0 ff ff call 107748 <rtems_filesystem_freenode>
1086df: 83 c4 10 add $0x10,%esp
error_1:
rtems_filesystem_freenode(&root_loc);
1086e2: 83 ec 0c sub $0xc,%esp
1086e5: 8d 45 d4 lea -0x2c(%ebp),%eax
1086e8: 50 push %eax
1086e9: e8 5a f0 ff ff call 107748 <rtems_filesystem_freenode>
1086ee: 83 c4 10 add $0x10,%esp
error_0:
return RTEMS_NO_MEMORY;
1086f1: b8 1a 00 00 00 mov $0x1a,%eax
}
1086f6: 8d 65 f4 lea -0xc(%ebp),%esp
1086f9: 5b pop %ebx
1086fa: 5e pop %esi
1086fb: 5f pop %edi
1086fc: c9 leave
1086fd: c3 ret
001086fe <rtems_libio_share_private_env>:
* b) mutex access to rtems_filesystem_current, rtems_filesytem_root
* while changing any of those (chdir(), chroot()).
*/
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
1086fe: 55 push %ebp
1086ff: 89 e5 mov %esp,%ebp
108701: 56 push %esi
108702: 53 push %ebx
108703: 83 ec 20 sub $0x20,%esp
108706: 8b 75 08 mov 0x8(%ebp),%esi
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
108709: e8 4a 26 00 00 call 10ad58 <rtems_task_self>
10870e: 89 c3 mov %eax,%ebx
* If this was an attempt to share the task with self,
* if somebody wanted to do it... Lets tell them, its shared
*/
if( task_id == current_task_id )
return RTEMS_SUCCESSFUL;
108710: 31 c0 xor %eax,%eax
/*
* If this was an attempt to share the task with self,
* if somebody wanted to do it... Lets tell them, its shared
*/
if( task_id == current_task_id )
108712: 39 de cmp %ebx,%esi
108714: 74 3c je 108752 <rtems_libio_share_private_env+0x54><== NEVER TAKEN
return RTEMS_SUCCESSFUL;
/*
* Try to get the requested user environment
*/
sc = rtems_task_variable_get(
108716: 52 push %edx
task_id,
(void*)&rtems_current_user_env,
(void*)&shared_user_env );
108717: 8d 45 f4 lea -0xc(%ebp),%eax
if( task_id == current_task_id )
return RTEMS_SUCCESSFUL;
/*
* Try to get the requested user environment
*/
sc = rtems_task_variable_get(
10871a: 50 push %eax
10871b: 68 6c 30 12 00 push $0x12306c
108720: 56 push %esi
108721: e8 3a 27 00 00 call 10ae60 <rtems_task_variable_get>
(void*)&shared_user_env );
/*
* If it was not successful, return the error code
*/
if (sc != RTEMS_SUCCESSFUL)
108726: 83 c4 10 add $0x10,%esp
108729: 85 c0 test %eax,%eax
10872b: 75 25 jne 108752 <rtems_libio_share_private_env+0x54>
* If we have a current environment in place, we need to
* free it, since we will be sharing the variable with the
* shared_user_env
*/
if (rtems_current_user_env->task_id==current_task_id) {
10872d: 8b 15 6c 30 12 00 mov 0x12306c,%edx
108733: 39 1a cmp %ebx,(%edx)
108735: 75 12 jne 108749 <rtems_libio_share_private_env+0x4b>
rtems_user_env_t *tmp = rtems_current_user_env;
free_user_env( tmp );
108737: 83 ec 0c sub $0xc,%esp
10873a: 52 push %edx
10873b: 89 45 e4 mov %eax,-0x1c(%ebp)
10873e: e8 7d fe ff ff call 1085c0 <free_user_env>
108743: 83 c4 10 add $0x10,%esp
108746: 8b 45 e4 mov -0x1c(%ebp),%eax
}
/* the current_user_env is the same pointer that remote env */
rtems_current_user_env = shared_user_env;
108749: 8b 55 f4 mov -0xc(%ebp),%edx
10874c: 89 15 6c 30 12 00 mov %edx,0x12306c
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
}
108752: 8d 65 f8 lea -0x8(%ebp),%esp
108755: 5b pop %ebx
108756: 5e pop %esi
108757: c9 leave
108758: c3 ret
0010e1ed <rtems_libio_to_fcntl_flags>:
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
10e1ed: 55 push %ebp
10e1ee: 89 e5 mov %esp,%ebp
10e1f0: 8b 55 08 mov 0x8(%ebp),%edx
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
10e1f3: 89 d1 mov %edx,%ecx
10e1f5: 83 e1 06 and $0x6,%ecx
fcntl_flags |= O_RDWR;
10e1f8: b8 02 00 00 00 mov $0x2,%eax
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
10e1fd: 83 f9 06 cmp $0x6,%ecx
10e200: 74 0f je 10e211 <rtems_libio_to_fcntl_flags+0x24>
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
fcntl_flags |= O_RDONLY;
10e202: 30 c0 xor %al,%al
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
10e204: f6 c2 02 test $0x2,%dl
10e207: 75 08 jne 10e211 <rtems_libio_to_fcntl_flags+0x24><== ALWAYS TAKEN
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
10e209: 31 c0 xor %eax,%eax
10e20b: f6 c2 04 test $0x4,%dl <== NOT EXECUTED
10e20e: 0f 95 c0 setne %al <== NOT EXECUTED
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
10e211: f6 c2 01 test $0x1,%dl
10e214: 74 03 je 10e219 <rtems_libio_to_fcntl_flags+0x2c>
fcntl_flags |= O_NONBLOCK;
10e216: 80 cc 40 or $0x40,%ah
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
10e219: f6 c6 02 test $0x2,%dh
10e21c: 74 03 je 10e221 <rtems_libio_to_fcntl_flags+0x34>
fcntl_flags |= O_APPEND;
10e21e: 83 c8 08 or $0x8,%eax
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
10e221: 80 e6 04 and $0x4,%dh
10e224: 74 03 je 10e229 <rtems_libio_to_fcntl_flags+0x3c>
fcntl_flags |= O_CREAT;
10e226: 80 cc 02 or $0x2,%ah
}
return fcntl_flags;
}
10e229: c9 leave
10e22a: c3 ret
00109d7c <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
109d7c: 55 push %ebp
109d7d: 89 e5 mov %esp,%ebp
109d7f: 83 ec 1c sub $0x1c,%esp
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
109d82: 8d 45 f4 lea -0xc(%ebp),%eax
109d85: 50 push %eax
109d86: ff 75 08 pushl 0x8(%ebp)
109d89: ff 35 40 79 12 00 pushl 0x127940
109d8f: e8 50 50 00 00 call 10ede4 <_Protected_heap_Get_block_size>
109d94: 83 c4 10 add $0x10,%esp
109d97: 84 c0 test %al,%al
109d99: 74 11 je 109dac <rtems_malloc_statistics_at_free+0x30><== NEVER TAKEN
MSBUMP(lifetime_freed, size);
109d9b: 8b 45 f4 mov -0xc(%ebp),%eax
109d9e: 31 d2 xor %edx,%edx
109da0: 01 05 20 c3 12 00 add %eax,0x12c320
109da6: 11 15 24 c3 12 00 adc %edx,0x12c324
}
}
109dac: c9 leave
109dad: c3 ret
00109dae <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
109dae: 55 push %ebp
109daf: 89 e5 mov %esp,%ebp
109db1: 83 ec 18 sub $0x18,%esp
109db4: 8b 45 08 mov 0x8(%ebp),%eax
uintptr_t actual_size = 0;
109db7: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
uint32_t current_depth;
rtems_malloc_statistics_t *s = &rtems_malloc_statistics;
if ( !pointer )
109dbe: 85 c0 test %eax,%eax
109dc0: 74 43 je 109e05 <rtems_malloc_statistics_at_malloc+0x57><== NEVER TAKEN
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
109dc2: 52 push %edx
109dc3: 8d 55 f4 lea -0xc(%ebp),%edx
109dc6: 52 push %edx
109dc7: 50 push %eax
109dc8: ff 35 40 79 12 00 pushl 0x127940
109dce: e8 11 50 00 00 call 10ede4 <_Protected_heap_Get_block_size>
MSBUMP(lifetime_allocated, actual_size);
109dd3: 8b 45 f4 mov -0xc(%ebp),%eax
109dd6: 31 d2 xor %edx,%edx
109dd8: 03 05 18 c3 12 00 add 0x12c318,%eax
109dde: 13 15 1c c3 12 00 adc 0x12c31c,%edx
109de4: a3 18 c3 12 00 mov %eax,0x12c318
109de9: 89 15 1c c3 12 00 mov %edx,0x12c31c
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
109def: 2b 05 20 c3 12 00 sub 0x12c320,%eax
if (current_depth > s->max_depth)
109df5: 83 c4 10 add $0x10,%esp
109df8: 3b 05 14 c3 12 00 cmp 0x12c314,%eax
109dfe: 76 05 jbe 109e05 <rtems_malloc_statistics_at_malloc+0x57>
s->max_depth = current_depth;
109e00: a3 14 c3 12 00 mov %eax,0x12c314
}
109e05: c9 leave
109e06: c3 ret
00111a3c <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
111a3c: 55 push %ebp
111a3d: 89 e5 mov %esp,%ebp
111a3f: 57 push %edi
111a40: 56 push %esi
111a41: 53 push %ebx
111a42: 83 ec 0c sub $0xc,%esp
111a45: 8b 5d 08 mov 0x8(%ebp),%ebx
/*
* Parameter error checks
*/
if ( !pointer )
return EINVAL;
111a48: be 16 00 00 00 mov $0x16,%esi
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
111a4d: 85 db test %ebx,%ebx
111a4f: 74 55 je 111aa6 <rtems_memalign+0x6a>
return EINVAL;
*pointer = NULL;
111a51: c7 03 00 00 00 00 movl $0x0,(%ebx)
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
111a57: 83 3d 54 85 12 00 03 cmpl $0x3,0x128554
111a5e: 75 09 jne 111a69 <rtems_memalign+0x2d> <== NEVER TAKEN
!malloc_is_system_state_OK() )
111a60: e8 97 67 ff ff call 1081fc <malloc_is_system_state_OK>
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
111a65: 84 c0 test %al,%al
111a67: 74 3d je 111aa6 <rtems_memalign+0x6a> <== NEVER TAKEN
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
111a69: e8 cc 67 ff ff call 10823a <malloc_deferred_frees_process>
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
111a6e: 6a 00 push $0x0
111a70: ff 75 0c pushl 0xc(%ebp)
111a73: ff 75 10 pushl 0x10(%ebp)
111a76: ff 35 80 41 12 00 pushl 0x124180
111a7c: e8 87 af ff ff call 10ca08 <_Protected_heap_Allocate_aligned_with_boundary>
111a81: 89 c7 mov %eax,%edi
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
111a83: 83 c4 10 add $0x10,%esp
return ENOMEM;
111a86: be 0c 00 00 00 mov $0xc,%esi
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
111a8b: 85 c0 test %eax,%eax
111a8d: 74 17 je 111aa6 <rtems_memalign+0x6a>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
111a8f: a1 90 66 12 00 mov 0x126690,%eax
111a94: 85 c0 test %eax,%eax
111a96: 74 0a je 111aa2 <rtems_memalign+0x66>
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
111a98: 83 ec 0c sub $0xc,%esp
111a9b: 53 push %ebx
111a9c: ff 50 04 call *0x4(%eax)
111a9f: 83 c4 10 add $0x10,%esp
*pointer = return_this;
111aa2: 89 3b mov %edi,(%ebx)
return 0;
111aa4: 31 f6 xor %esi,%esi
}
111aa6: 89 f0 mov %esi,%eax
111aa8: 8d 65 f4 lea -0xc(%ebp),%esp
111aab: 5b pop %ebx
111aac: 5e pop %esi
111aad: 5f pop %edi
111aae: c9 leave
111aaf: c3 ret
0011036c <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
11036c: 55 push %ebp
11036d: 89 e5 mov %esp,%ebp
11036f: 57 push %edi
110370: 56 push %esi
110371: 53 push %ebx
110372: 83 ec 78 sub $0x78,%esp
int success = 0;
char *dup_path = strdup(path);
110375: ff 75 08 pushl 0x8(%ebp)
110378: e8 87 32 00 00 call 113604 <strdup>
11037d: 89 c3 mov %eax,%ebx
if (dup_path != NULL) {
11037f: 83 c4 10 add $0x10,%esp
success = build(dup_path, mode);
free(dup_path);
}
return success != 0 ? 0 : -1;
110382: 83 c8 ff or $0xffffffff,%eax
rtems_mkdir(const char *path, mode_t mode)
{
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
110385: 85 db test %ebx,%ebx
110387: 0f 84 1e 01 00 00 je 1104ab <rtems_mkdir+0x13f> <== NEVER TAKEN
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
11038d: 31 c0 xor %eax,%eax
11038f: 80 3b 2f cmpb $0x2f,(%ebx)
110392: 0f 94 c0 sete %al
110395: 8d 3c 03 lea (%ebx,%eax,1),%edi
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
110398: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp)
11039f: b8 01 00 00 00 mov $0x1,%eax
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
1103a4: 8a 0f mov (%edi),%cl
last = 1;
1103a6: ba 01 00 00 00 mov $0x1,%edx
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
1103ab: 84 c9 test %cl,%cl
1103ad: 74 0b je 1103ba <rtems_mkdir+0x4e>
last = 1;
else if (p[0] != '/')
1103af: 80 f9 2f cmp $0x2f,%cl
1103b2: 0f 85 c8 00 00 00 jne 110480 <rtems_mkdir+0x114>
1103b8: 30 d2 xor %dl,%dl
continue;
*p = '\0';
1103ba: c6 07 00 movb $0x0,(%edi)
if (!last && p[1] == '\0')
1103bd: be 01 00 00 00 mov $0x1,%esi
1103c2: 85 d2 test %edx,%edx
1103c4: 75 0b jne 1103d1 <rtems_mkdir+0x65>
1103c6: 31 d2 xor %edx,%edx
1103c8: 80 7f 01 00 cmpb $0x0,0x1(%edi)
1103cc: 0f 94 c2 sete %dl
1103cf: 89 d6 mov %edx,%esi
last = 1;
if (first) {
1103d1: 85 c0 test %eax,%eax
1103d3: 74 1a je 1103ef <rtems_mkdir+0x83>
* mkdir [-m mode] dir
*
* We change the user's umask and then restore it,
* instead of doing chmod's.
*/
oumask = umask(0);
1103d5: 83 ec 0c sub $0xc,%esp
1103d8: 6a 00 push $0x0
1103da: e8 75 01 00 00 call 110554 <umask>
1103df: 89 45 94 mov %eax,-0x6c(%ebp)
numask = oumask & ~(S_IWUSR | S_IXUSR);
1103e2: 24 3f and $0x3f,%al
(void)umask(numask);
1103e4: 89 04 24 mov %eax,(%esp)
1103e7: e8 68 01 00 00 call 110554 <umask>
1103ec: 83 c4 10 add $0x10,%esp
first = 0;
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
1103ef: b8 ff 01 00 00 mov $0x1ff,%eax
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
1103f4: 85 f6 test %esi,%esi
1103f6: 74 11 je 110409 <rtems_mkdir+0x9d>
(void)umask(oumask);
1103f8: 83 ec 0c sub $0xc,%esp
1103fb: ff 75 94 pushl -0x6c(%ebp)
1103fe: e8 51 01 00 00 call 110554 <umask>
110403: 83 c4 10 add $0x10,%esp
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
110406: 8b 45 0c mov 0xc(%ebp),%eax
110409: 52 push %edx
11040a: 52 push %edx
11040b: 50 push %eax
11040c: 53 push %ebx
11040d: e8 ce 82 ff ff call 1086e0 <mkdir>
110412: 83 c4 10 add $0x10,%esp
110415: 85 c0 test %eax,%eax
110417: 79 5e jns 110477 <rtems_mkdir+0x10b>
if (errno == EEXIST || errno == EISDIR) {
110419: e8 06 25 00 00 call 112924 <__errno>
11041e: 83 38 11 cmpl $0x11,(%eax)
110421: 74 0a je 11042d <rtems_mkdir+0xc1>
110423: e8 fc 24 00 00 call 112924 <__errno>
110428: 83 38 15 cmpl $0x15,(%eax)
11042b: 75 59 jne 110486 <rtems_mkdir+0x11a> <== ALWAYS TAKEN
if (stat(path, &sb) < 0) {
11042d: 50 push %eax
11042e: 50 push %eax
11042f: 8d 45 a0 lea -0x60(%ebp),%eax
110432: 50 push %eax
110433: 53 push %ebx
110434: e8 8b 00 00 00 call 1104c4 <stat>
110439: 83 c4 10 add $0x10,%esp
11043c: 85 c0 test %eax,%eax
11043e: 78 46 js 110486 <rtems_mkdir+0x11a> <== NEVER TAKEN
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
110440: 8b 45 ac mov -0x54(%ebp),%eax
110443: 25 00 f0 00 00 and $0xf000,%eax
110448: 3d 00 40 00 00 cmp $0x4000,%eax
11044d: 74 22 je 110471 <rtems_mkdir+0x105>
if (last)
11044f: 85 f6 test %esi,%esi
110451: 74 0f je 110462 <rtems_mkdir+0xf6>
errno = EEXIST;
110453: e8 cc 24 00 00 call 112924 <__errno>
110458: c7 00 11 00 00 00 movl $0x11,(%eax)
else
errno = ENOTDIR;
retval = 0;
11045e: 31 ff xor %edi,%edi
110460: eb 38 jmp 11049a <rtems_mkdir+0x12e>
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
errno = EEXIST;
else
errno = ENOTDIR;
110462: e8 bd 24 00 00 call 112924 <__errno>
110467: c7 00 14 00 00 00 movl $0x14,(%eax)
retval = 0;
11046d: 31 ff xor %edi,%edi
11046f: eb 1b jmp 11048c <rtems_mkdir+0x120>
break;
}
if (last)
110471: 85 f6 test %esi,%esi
110473: 75 3e jne 1104b3 <rtems_mkdir+0x147>
110475: eb 04 jmp 11047b <rtems_mkdir+0x10f>
} else {
retval = 0;
break;
}
}
if (!last)
110477: 85 f6 test %esi,%esi
110479: 75 3f jne 1104ba <rtems_mkdir+0x14e>
*p = '/';
11047b: c6 07 2f movb $0x2f,(%edi)
11047e: 31 c0 xor %eax,%eax
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
110480: 47 inc %edi
110481: e9 1e ff ff ff jmp 1103a4 <rtems_mkdir+0x38>
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
if (stat(path, &sb) < 0) {
retval = 0;
110486: 31 ff xor %edi,%edi
}
}
if (!last)
*p = '/';
}
if (!first && !last)
110488: 85 f6 test %esi,%esi
11048a: 75 0e jne 11049a <rtems_mkdir+0x12e> <== ALWAYS TAKEN
(void)umask(oumask);
11048c: 83 ec 0c sub $0xc,%esp
11048f: ff 75 94 pushl -0x6c(%ebp)
110492: e8 bd 00 00 00 call 110554 <umask>
110497: 83 c4 10 add $0x10,%esp
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
11049a: 83 ec 0c sub $0xc,%esp
11049d: 53 push %ebx
11049e: e8 e1 7c ff ff call 108184 <free>
}
return success != 0 ? 0 : -1;
1104a3: 83 c4 10 add $0x10,%esp
1104a6: 83 ff 01 cmp $0x1,%edi
1104a9: 19 c0 sbb %eax,%eax
}
1104ab: 8d 65 f4 lea -0xc(%ebp),%esp
1104ae: 5b pop %ebx
1104af: 5e pop %esi
1104b0: 5f pop %edi
1104b1: c9 leave
1104b2: c3 ret
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
retval = 2;
1104b3: bf 02 00 00 00 mov $0x2,%edi
1104b8: eb e0 jmp 11049a <rtems_mkdir+0x12e>
} else {
retval = 0;
break;
}
}
if (!last)
1104ba: bf 01 00 00 00 mov $0x1,%edi
1104bf: eb d9 jmp 11049a <rtems_mkdir+0x12e>
001147ec <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
1147ec: 55 push %ebp
1147ed: 89 e5 mov %esp,%ebp
1147ef: 57 push %edi
1147f0: 56 push %esi
1147f1: 53 push %ebx
1147f2: 83 ec 1c sub $0x1c,%esp
1147f5: 8b 75 0c mov 0xc(%ebp),%esi
1147f8: 8b 55 10 mov 0x10(%ebp),%edx
1147fb: 8b 7d 14 mov 0x14(%ebp),%edi
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
1147fe: b8 03 00 00 00 mov $0x3,%eax
rtems_id *id
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
114803: 83 7d 08 00 cmpl $0x0,0x8(%ebp)
114807: 0f 84 ce 00 00 00 je 1148db <rtems_partition_create+0xef>
return RTEMS_INVALID_NAME;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
11480d: b0 09 mov $0x9,%al
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
11480f: 85 f6 test %esi,%esi
114811: 0f 84 c4 00 00 00 je 1148db <rtems_partition_create+0xef>
return RTEMS_INVALID_ADDRESS;
if ( !id )
114817: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp)
11481b: 0f 84 ba 00 00 00 je 1148db <rtems_partition_create+0xef><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
114821: 85 ff test %edi,%edi
114823: 0f 84 ad 00 00 00 je 1148d6 <rtems_partition_create+0xea>
114829: 85 d2 test %edx,%edx
11482b: 0f 84 a5 00 00 00 je 1148d6 <rtems_partition_create+0xea>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
114831: b0 08 mov $0x8,%al
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
114833: 39 fa cmp %edi,%edx
114835: 0f 82 a0 00 00 00 jb 1148db <rtems_partition_create+0xef>
11483b: f7 c7 03 00 00 00 test $0x3,%edi
114841: 0f 85 94 00 00 00 jne 1148db <rtems_partition_create+0xef>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
return RTEMS_INVALID_ADDRESS;
114847: b0 09 mov $0x9,%al
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
114849: f7 c6 03 00 00 00 test $0x3,%esi
11484f: 0f 85 86 00 00 00 jne 1148db <rtems_partition_create+0xef>
114855: a1 14 ef 13 00 mov 0x13ef14,%eax
11485a: 40 inc %eax
11485b: a3 14 ef 13 00 mov %eax,0x13ef14
* This function allocates a partition control block from
* the inactive chain of free partition control blocks.
*/
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void )
{
return (Partition_Control *) _Objects_Allocate( &_Partition_Information );
114860: 83 ec 0c sub $0xc,%esp
114863: 68 a4 ed 13 00 push $0x13eda4
114868: 89 55 e4 mov %edx,-0x1c(%ebp)
11486b: e8 14 3e 00 00 call 118684 <_Objects_Allocate>
114870: 89 c3 mov %eax,%ebx
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
114872: 83 c4 10 add $0x10,%esp
114875: 85 c0 test %eax,%eax
114877: 8b 55 e4 mov -0x1c(%ebp),%edx
11487a: 75 0c jne 114888 <rtems_partition_create+0x9c>
_Thread_Enable_dispatch();
11487c: e8 11 4d 00 00 call 119592 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
114881: b8 05 00 00 00 mov $0x5,%eax
114886: eb 53 jmp 1148db <rtems_partition_create+0xef>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
114888: 89 70 10 mov %esi,0x10(%eax)
the_partition->length = length;
11488b: 89 50 14 mov %edx,0x14(%eax)
the_partition->buffer_size = buffer_size;
11488e: 89 78 18 mov %edi,0x18(%eax)
the_partition->attribute_set = attribute_set;
114891: 8b 45 18 mov 0x18(%ebp),%eax
114894: 89 43 1c mov %eax,0x1c(%ebx)
the_partition->number_of_used_blocks = 0;
114897: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
_Chain_Initialize( &the_partition->Memory, starting_address,
11489e: 57 push %edi
11489f: 89 d0 mov %edx,%eax
1148a1: 31 d2 xor %edx,%edx
1148a3: f7 f7 div %edi
1148a5: 50 push %eax
1148a6: 56 push %esi
1148a7: 8d 43 24 lea 0x24(%ebx),%eax
1148aa: 50 push %eax
1148ab: e8 84 2a 00 00 call 117334 <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
1148b0: 8b 43 08 mov 0x8(%ebx),%eax
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
1148b3: 0f b7 c8 movzwl %ax,%ecx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
1148b6: 8b 15 c0 ed 13 00 mov 0x13edc0,%edx
1148bc: 89 1c 8a mov %ebx,(%edx,%ecx,4)
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
1148bf: 8b 55 08 mov 0x8(%ebp),%edx
1148c2: 89 53 0c mov %edx,0xc(%ebx)
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
1148c5: 8b 55 1c mov 0x1c(%ebp),%edx
1148c8: 89 02 mov %eax,(%edx)
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
1148ca: e8 c3 4c 00 00 call 119592 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1148cf: 83 c4 10 add $0x10,%esp
1148d2: 31 c0 xor %eax,%eax
1148d4: eb 05 jmp 1148db <rtems_partition_create+0xef>
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
1148d6: b8 08 00 00 00 mov $0x8,%eax
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
1148db: 8d 65 f4 lea -0xc(%ebp),%esp
1148de: 5b pop %ebx
1148df: 5e pop %esi
1148e0: 5f pop %edi
1148e1: c9 leave
1148e2: c3 ret
0010b031 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
10b031: 55 push %ebp
10b032: 89 e5 mov %esp,%ebp
10b034: 57 push %edi
10b035: 56 push %esi
10b036: 53 push %ebx
10b037: 83 ec 30 sub $0x30,%esp
10b03a: 8b 75 08 mov 0x8(%ebp),%esi
10b03d: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
rtems_status_code return_value;
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
10b040: 8d 45 e4 lea -0x1c(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
10b043: 50 push %eax
10b044: 56 push %esi
10b045: 68 74 83 12 00 push $0x128374
10b04a: e8 39 1e 00 00 call 10ce88 <_Objects_Get>
10b04f: 89 c7 mov %eax,%edi
switch ( location ) {
10b051: 83 c4 10 add $0x10,%esp
10b054: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10b058: 0f 85 3b 01 00 00 jne 10b199 <rtems_rate_monotonic_period+0x168><== NEVER TAKEN
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
10b05e: a1 8c 89 12 00 mov 0x12898c,%eax
10b063: 39 47 40 cmp %eax,0x40(%edi)
10b066: 74 0f je 10b077 <rtems_rate_monotonic_period+0x46>
_Thread_Enable_dispatch();
10b068: e8 c1 28 00 00 call 10d92e <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
10b06d: be 17 00 00 00 mov $0x17,%esi
10b072: e9 27 01 00 00 jmp 10b19e <rtems_rate_monotonic_period+0x16d>
}
if ( length == RTEMS_PERIOD_STATUS ) {
10b077: 85 db test %ebx,%ebx
10b079: 75 1b jne 10b096 <rtems_rate_monotonic_period+0x65>
switch ( the_period->state ) {
10b07b: 8b 47 38 mov 0x38(%edi),%eax
10b07e: 31 f6 xor %esi,%esi
10b080: 83 f8 04 cmp $0x4,%eax
10b083: 77 07 ja 10b08c <rtems_rate_monotonic_period+0x5b><== NEVER TAKEN
10b085: 8b 34 85 e0 15 12 00 mov 0x1215e0(,%eax,4),%esi
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
10b08c: e8 9d 28 00 00 call 10d92e <_Thread_Enable_dispatch>
return( return_value );
10b091: e9 08 01 00 00 jmp 10b19e <rtems_rate_monotonic_period+0x16d>
}
_ISR_Disable( level );
10b096: 9c pushf
10b097: fa cli
10b098: 8f 45 d4 popl -0x2c(%ebp)
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
10b09b: 8b 47 38 mov 0x38(%edi),%eax
10b09e: 85 c0 test %eax,%eax
10b0a0: 75 4c jne 10b0ee <rtems_rate_monotonic_period+0xbd>
_ISR_Enable( level );
10b0a2: ff 75 d4 pushl -0x2c(%ebp)
10b0a5: 9d popf
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
10b0a6: 83 ec 0c sub $0xc,%esp
10b0a9: 57 push %edi
10b0aa: e8 3f fe ff ff call 10aeee <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
10b0af: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10b0b6: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi)
the_watchdog->routine = routine;
10b0bd: c7 47 2c a8 b3 10 00 movl $0x10b3a8,0x2c(%edi)
the_watchdog->id = id;
10b0c4: 89 77 30 mov %esi,0x30(%edi)
the_watchdog->user_data = user_data;
10b0c7: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi)
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
10b0ce: 89 5f 3c mov %ebx,0x3c(%edi)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b0d1: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b0d4: 58 pop %eax
10b0d5: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, length );
10b0d6: 83 c7 10 add $0x10,%edi
10b0d9: 57 push %edi
10b0da: 68 28 85 12 00 push $0x128528
10b0df: e8 58 35 00 00 call 10e63c <_Watchdog_Insert>
_Thread_Enable_dispatch();
10b0e4: e8 45 28 00 00 call 10d92e <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b0e9: 83 c4 10 add $0x10,%esp
10b0ec: eb 65 jmp 10b153 <rtems_rate_monotonic_period+0x122>
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
10b0ee: 83 f8 02 cmp $0x2,%eax
10b0f1: 75 64 jne 10b157 <rtems_rate_monotonic_period+0x126>
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
10b0f3: 83 ec 0c sub $0xc,%esp
10b0f6: 57 push %edi
10b0f7: e8 5a fe ff ff call 10af56 <_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;
10b0fc: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi)
the_period->next_length = length;
10b103: 89 5f 3c mov %ebx,0x3c(%edi)
_ISR_Enable( level );
10b106: ff 75 d4 pushl -0x2c(%ebp)
10b109: 9d popf
_Thread_Executing->Wait.id = the_period->Object.id;
10b10a: a1 8c 89 12 00 mov 0x12898c,%eax
10b10f: 8b 57 08 mov 0x8(%edi),%edx
10b112: 89 50 20 mov %edx,0x20(%eax)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10b115: 5b pop %ebx
10b116: 5e pop %esi
10b117: 68 00 40 00 00 push $0x4000
10b11c: 50 push %eax
10b11d: e8 7a 2f 00 00 call 10e09c <_Thread_Set_state>
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
10b122: 9c pushf
10b123: fa cli
10b124: 5a pop %edx
local_state = the_period->state;
10b125: 8b 47 38 mov 0x38(%edi),%eax
the_period->state = RATE_MONOTONIC_ACTIVE;
10b128: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi)
_ISR_Enable( level );
10b12f: 52 push %edx
10b130: 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 )
10b131: 83 c4 10 add $0x10,%esp
10b134: 83 f8 03 cmp $0x3,%eax
10b137: 75 15 jne 10b14e <rtems_rate_monotonic_period+0x11d>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
10b139: 51 push %ecx
10b13a: 51 push %ecx
10b13b: 68 00 40 00 00 push $0x4000
10b140: ff 35 8c 89 12 00 pushl 0x12898c
10b146: e8 cd 24 00 00 call 10d618 <_Thread_Clear_state>
10b14b: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
10b14e: e8 db 27 00 00 call 10d92e <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10b153: 31 f6 xor %esi,%esi
10b155: eb 47 jmp 10b19e <rtems_rate_monotonic_period+0x16d>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b157: be 04 00 00 00 mov $0x4,%esi
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
10b15c: 83 f8 04 cmp $0x4,%eax
10b15f: 75 3d jne 10b19e <rtems_rate_monotonic_period+0x16d><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
10b161: 83 ec 0c sub $0xc,%esp
10b164: 57 push %edi
10b165: e8 ec fd ff ff call 10af56 <_Rate_monotonic_Update_statistics>
_ISR_Enable( level );
10b16a: ff 75 d4 pushl -0x2c(%ebp)
10b16d: 9d popf
the_period->state = RATE_MONOTONIC_ACTIVE;
10b16e: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi)
the_period->next_length = length;
10b175: 89 5f 3c mov %ebx,0x3c(%edi)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10b178: 89 5f 1c mov %ebx,0x1c(%edi)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10b17b: 58 pop %eax
10b17c: 5a pop %edx
_Watchdog_Insert_ticks( &the_period->Timer, length );
10b17d: 83 c7 10 add $0x10,%edi
10b180: 57 push %edi
10b181: 68 28 85 12 00 push $0x128528
10b186: e8 b1 34 00 00 call 10e63c <_Watchdog_Insert>
_Thread_Enable_dispatch();
10b18b: e8 9e 27 00 00 call 10d92e <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
10b190: 83 c4 10 add $0x10,%esp
10b193: 66 be 06 00 mov $0x6,%si
10b197: eb 05 jmp 10b19e <rtems_rate_monotonic_period+0x16d>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10b199: be 04 00 00 00 mov $0x4,%esi
}
10b19e: 89 f0 mov %esi,%eax
10b1a0: 8d 65 f4 lea -0xc(%ebp),%esp
10b1a3: 5b pop %ebx
10b1a4: 5e pop %esi
10b1a5: 5f pop %edi
10b1a6: c9 leave
10b1a7: c3 ret
0010b1a8 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
10b1a8: 55 push %ebp
10b1a9: 89 e5 mov %esp,%ebp
10b1ab: 57 push %edi
10b1ac: 56 push %esi
10b1ad: 53 push %ebx
10b1ae: 83 ec 7c sub $0x7c,%esp
10b1b1: 8b 5d 08 mov 0x8(%ebp),%ebx
10b1b4: 8b 7d 0c mov 0xc(%ebp),%edi
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
10b1b7: 85 ff test %edi,%edi
10b1b9: 0f 84 2b 01 00 00 je 10b2ea <rtems_rate_monotonic_report_statistics_with_plugin+0x142><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
10b1bf: 52 push %edx
10b1c0: 52 push %edx
10b1c1: 68 f4 15 12 00 push $0x1215f4
10b1c6: 53 push %ebx
10b1c7: ff d7 call *%edi
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
10b1c9: 5e pop %esi
10b1ca: 58 pop %eax
10b1cb: 68 12 16 12 00 push $0x121612
10b1d0: 53 push %ebx
10b1d1: ff d7 call *%edi
(*print)( context, "--- Wall times are in seconds ---\n" );
10b1d3: 5a pop %edx
10b1d4: 59 pop %ecx
10b1d5: 68 34 16 12 00 push $0x121634
10b1da: 53 push %ebx
10b1db: ff d7 call *%edi
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
10b1dd: 5e pop %esi
10b1de: 58 pop %eax
10b1df: 68 57 16 12 00 push $0x121657
10b1e4: 53 push %ebx
10b1e5: ff d7 call *%edi
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
10b1e7: 5a pop %edx
10b1e8: 59 pop %ecx
10b1e9: 68 a2 16 12 00 push $0x1216a2
10b1ee: 53 push %ebx
10b1ef: ff d7 call *%edi
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10b1f1: 8b 35 7c 83 12 00 mov 0x12837c,%esi
10b1f7: 83 c4 10 add $0x10,%esp
10b1fa: e9 df 00 00 00 jmp 10b2de <rtems_rate_monotonic_report_statistics_with_plugin+0x136>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
10b1ff: 50 push %eax
10b200: 50 push %eax
10b201: 8d 45 88 lea -0x78(%ebp),%eax
10b204: 50 push %eax
10b205: 56 push %esi
10b206: e8 b5 56 00 00 call 1108c0 <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
10b20b: 83 c4 10 add $0x10,%esp
10b20e: 85 c0 test %eax,%eax
10b210: 0f 85 c7 00 00 00 jne 10b2dd <rtems_rate_monotonic_report_statistics_with_plugin+0x135>
#if defined(RTEMS_DEBUG)
status = rtems_rate_monotonic_get_status( id, &the_status );
if ( status != RTEMS_SUCCESSFUL )
continue;
#else
(void) rtems_rate_monotonic_get_status( id, &the_status );
10b216: 51 push %ecx
10b217: 51 push %ecx
10b218: 8d 55 c0 lea -0x40(%ebp),%edx
10b21b: 52 push %edx
10b21c: 56 push %esi
10b21d: e8 42 57 00 00 call 110964 <rtems_rate_monotonic_get_status>
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
10b222: 83 c4 0c add $0xc,%esp
10b225: 8d 45 e3 lea -0x1d(%ebp),%eax
10b228: 50 push %eax
10b229: 6a 05 push $0x5
10b22b: ff 75 c0 pushl -0x40(%ebp)
10b22e: e8 01 02 00 00 call 10b434 <rtems_object_get_name>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
10b233: 58 pop %eax
10b234: 5a pop %edx
10b235: ff 75 8c pushl -0x74(%ebp)
10b238: ff 75 88 pushl -0x78(%ebp)
10b23b: 8d 55 e3 lea -0x1d(%ebp),%edx
10b23e: 52 push %edx
10b23f: 56 push %esi
10b240: 68 ee 16 12 00 push $0x1216ee
10b245: 53 push %ebx
10b246: ff d7 call *%edi
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
10b248: 8b 45 88 mov -0x78(%ebp),%eax
10b24b: 83 c4 20 add $0x20,%esp
10b24e: 85 c0 test %eax,%eax
10b250: 75 0f jne 10b261 <rtems_rate_monotonic_report_statistics_with_plugin+0xb9>
(*print)( context, "\n" );
10b252: 51 push %ecx
10b253: 51 push %ecx
10b254: 68 58 19 12 00 push $0x121958
10b259: 53 push %ebx
10b25a: ff d7 call *%edi
continue;
10b25c: 83 c4 10 add $0x10,%esp
10b25f: eb 7c jmp 10b2dd <rtems_rate_monotonic_report_statistics_with_plugin+0x135>
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
10b261: 52 push %edx
10b262: 8d 55 d8 lea -0x28(%ebp),%edx
10b265: 52 push %edx
10b266: 50 push %eax
10b267: 8d 45 a0 lea -0x60(%ebp),%eax
10b26a: 50 push %eax
10b26b: e8 a0 30 00 00 call 10e310 <_Timespec_Divide_by_integer>
(*print)( context,
10b270: 8b 45 dc mov -0x24(%ebp),%eax
10b273: b9 e8 03 00 00 mov $0x3e8,%ecx
10b278: 99 cltd
10b279: f7 f9 idiv %ecx
10b27b: 50 push %eax
10b27c: ff 75 d8 pushl -0x28(%ebp)
10b27f: 8b 45 9c mov -0x64(%ebp),%eax
10b282: 99 cltd
10b283: f7 f9 idiv %ecx
10b285: 50 push %eax
10b286: ff 75 98 pushl -0x68(%ebp)
10b289: 8b 45 94 mov -0x6c(%ebp),%eax
10b28c: 99 cltd
10b28d: f7 f9 idiv %ecx
10b28f: 50 push %eax
10b290: ff 75 90 pushl -0x70(%ebp)
10b293: 68 05 17 12 00 push $0x121705
10b298: 53 push %ebx
10b299: 89 4d 84 mov %ecx,-0x7c(%ebp)
10b29c: ff d7 call *%edi
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
10b29e: 83 c4 2c add $0x2c,%esp
10b2a1: 8d 55 d8 lea -0x28(%ebp),%edx
10b2a4: 52 push %edx
10b2a5: ff 75 88 pushl -0x78(%ebp)
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
10b2a8: 8d 45 b8 lea -0x48(%ebp),%eax
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
10b2ab: 50 push %eax
10b2ac: e8 5f 30 00 00 call 10e310 <_Timespec_Divide_by_integer>
(*print)( context,
10b2b1: 8b 45 dc mov -0x24(%ebp),%eax
10b2b4: 8b 4d 84 mov -0x7c(%ebp),%ecx
10b2b7: 99 cltd
10b2b8: f7 f9 idiv %ecx
10b2ba: 50 push %eax
10b2bb: ff 75 d8 pushl -0x28(%ebp)
10b2be: 8b 45 b4 mov -0x4c(%ebp),%eax
10b2c1: 99 cltd
10b2c2: f7 f9 idiv %ecx
10b2c4: 50 push %eax
10b2c5: ff 75 b0 pushl -0x50(%ebp)
10b2c8: 8b 45 ac mov -0x54(%ebp),%eax
10b2cb: 99 cltd
10b2cc: f7 f9 idiv %ecx
10b2ce: 50 push %eax
10b2cf: ff 75 a8 pushl -0x58(%ebp)
10b2d2: 68 24 17 12 00 push $0x121724
10b2d7: 53 push %ebx
10b2d8: ff d7 call *%edi
10b2da: 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++ ) {
10b2dd: 46 inc %esi
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
10b2de: 3b 35 80 83 12 00 cmp 0x128380,%esi
10b2e4: 0f 86 15 ff ff ff jbe 10b1ff <rtems_rate_monotonic_report_statistics_with_plugin+0x57>
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
10b2ea: 8d 65 f4 lea -0xc(%ebp),%esp
10b2ed: 5b pop %ebx
10b2ee: 5e pop %esi
10b2ef: 5f pop %edi
10b2f0: c9 leave
10b2f1: c3 ret
00115b4c <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
115b4c: 55 push %ebp
115b4d: 89 e5 mov %esp,%ebp
115b4f: 53 push %ebx
115b50: 83 ec 14 sub $0x14,%esp
115b53: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
115b56: b8 0a 00 00 00 mov $0xa,%eax
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
115b5b: 85 db test %ebx,%ebx
115b5d: 74 6d je 115bcc <rtems_signal_send+0x80>
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
115b5f: 50 push %eax
115b60: 50 push %eax
115b61: 8d 45 f4 lea -0xc(%ebp),%eax
115b64: 50 push %eax
115b65: ff 75 08 pushl 0x8(%ebp)
115b68: e8 47 3a 00 00 call 1195b4 <_Thread_Get>
switch ( location ) {
115b6d: 83 c4 10 add $0x10,%esp
115b70: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
115b74: 75 51 jne 115bc7 <rtems_signal_send+0x7b>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
115b76: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
115b7c: 83 7a 0c 00 cmpl $0x0,0xc(%edx)
115b80: 74 39 je 115bbb <rtems_signal_send+0x6f>
if ( asr->is_enabled ) {
115b82: 80 7a 08 00 cmpb $0x0,0x8(%edx)
115b86: 74 22 je 115baa <rtems_signal_send+0x5e>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
115b88: 9c pushf
115b89: fa cli
115b8a: 59 pop %ecx
*signal_set |= signals;
115b8b: 09 5a 14 or %ebx,0x14(%edx)
_ISR_Enable( _level );
115b8e: 51 push %ecx
115b8f: 9d popf
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
115b90: 83 3d 40 f4 13 00 00 cmpl $0x0,0x13f440
115b97: 74 19 je 115bb2 <rtems_signal_send+0x66>
115b99: 3b 05 44 f4 13 00 cmp 0x13f444,%eax
115b9f: 75 11 jne 115bb2 <rtems_signal_send+0x66><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
115ba1: c6 05 50 f4 13 00 01 movb $0x1,0x13f450
115ba8: eb 08 jmp 115bb2 <rtems_signal_send+0x66>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
115baa: 9c pushf
115bab: fa cli
115bac: 58 pop %eax
*signal_set |= signals;
115bad: 09 5a 18 or %ebx,0x18(%edx)
_ISR_Enable( _level );
115bb0: 50 push %eax
115bb1: 9d popf
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
115bb2: e8 db 39 00 00 call 119592 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
115bb7: 31 c0 xor %eax,%eax
115bb9: eb 11 jmp 115bcc <rtems_signal_send+0x80>
}
_Thread_Enable_dispatch();
115bbb: e8 d2 39 00 00 call 119592 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
115bc0: b8 0b 00 00 00 mov $0xb,%eax
115bc5: eb 05 jmp 115bcc <rtems_signal_send+0x80>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
115bc7: b8 04 00 00 00 mov $0x4,%eax
}
115bcc: 8b 5d fc mov -0x4(%ebp),%ebx
115bcf: c9 leave
115bd0: c3 ret
001072b4 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
1072b4: 55 push %ebp
1072b5: 89 e5 mov %esp,%ebp
1072b7: 57 push %edi
1072b8: 56 push %esi
1072b9: 8b 45 08 mov 0x8(%ebp),%eax
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
1072bc: 83 78 08 00 cmpl $0x0,0x8(%eax)
1072c0: 74 15 je 1072d7 <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;
1072c2: 8b b8 bc 00 00 00 mov 0xbc(%eax),%edi
1072c8: 83 c7 08 add $0x8,%edi
1072cb: be 28 72 12 00 mov $0x127228,%esi
1072d0: b9 04 00 00 00 mov $0x4,%ecx
1072d5: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
}
1072d7: 5e pop %esi
1072d8: 5f pop %edi
1072d9: c9 leave
1072da: c3 ret
0010728d <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
10728d: 55 push %ebp
10728e: 89 e5 mov %esp,%ebp
107290: 57 push %edi
107291: 8b 7d 0c mov 0xc(%ebp),%edi
Stack_check_Initialize();
107294: e8 8a ff ff ff call 107223 <Stack_check_Initialize>
if (the_thread)
107299: 85 ff test %edi,%edi
10729b: 74 12 je 1072af <rtems_stack_checker_create_extension+0x22><== NEVER TAKEN
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
10729d: 8b 8f b8 00 00 00 mov 0xb8(%edi),%ecx
1072a3: 8b 97 bc 00 00 00 mov 0xbc(%edi),%edx
1072a9: b0 a5 mov $0xa5,%al
1072ab: 89 d7 mov %edx,%edi
1072ad: f3 aa rep stos %al,%es:(%edi)
return true;
}
1072af: b0 01 mov $0x1,%al
1072b1: 5f pop %edi
1072b2: c9 leave
1072b3: c3 ret
001073e8 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
1073e8: 55 push %ebp
1073e9: 89 e5 mov %esp,%ebp
1073eb: 53 push %ebx
1073ec: 83 ec 04 sub $0x4,%esp
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
1073ef: a1 1c 79 12 00 mov 0x12791c,%eax
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
1073f4: 8b 90 bc 00 00 00 mov 0xbc(%eax),%edx
return false;
1073fa: 31 db xor %ebx,%ebx
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
1073fc: 39 d5 cmp %edx,%ebp
1073fe: 72 0e jb 10740e <rtems_stack_checker_is_blown+0x26><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
107400: 8b 80 b8 00 00 00 mov 0xb8(%eax),%eax
107406: 8d 04 02 lea (%edx,%eax,1),%eax
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
107409: 39 c5 cmp %eax,%ebp
10740b: 0f 96 c3 setbe %bl
{
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
bool sp_ok;
bool pattern_ok = true;
10740e: b0 01 mov $0x1,%al
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
107410: 83 3d 18 6f 12 00 00 cmpl $0x0,0x126f18
107417: 74 19 je 107432 <rtems_stack_checker_is_blown+0x4a><== NEVER TAKEN
pattern_ok = (!memcmp(
107419: 83 c2 08 add $0x8,%edx
10741c: 51 push %ecx
10741d: 6a 10 push $0x10
10741f: 68 28 72 12 00 push $0x127228
107424: 52 push %edx
107425: e8 0e cb 00 00 call 113f38 <memcmp>
10742a: 83 c4 10 add $0x10,%esp
10742d: 85 c0 test %eax,%eax
10742f: 0f 94 c0 sete %al
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
107432: 84 db test %bl,%bl
107434: 74 04 je 10743a <rtems_stack_checker_is_blown+0x52><== NEVER TAKEN
107436: 84 c0 test %al,%al
107438: 75 11 jne 10744b <rtems_stack_checker_is_blown+0x63><== ALWAYS TAKEN
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
10743a: 52 push %edx <== NOT EXECUTED
10743b: 52 push %edx <== NOT EXECUTED
10743c: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
10743f: 50 push %eax <== NOT EXECUTED
107440: ff 35 1c 79 12 00 pushl 0x12791c <== NOT EXECUTED
107446: e8 90 fe ff ff call 1072db <Stack_check_report_blown_task><== NOT EXECUTED
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
10744b: 31 c0 xor %eax,%eax
10744d: 8b 5d fc mov -0x4(%ebp),%ebx
107450: c9 leave
107451: c3 ret
001074b7 <rtems_stack_checker_report_usage>:
void rtems_stack_checker_report_usage( void )
{
1074b7: 55 push %ebp <== NOT EXECUTED
1074b8: 89 e5 mov %esp,%ebp <== NOT EXECUTED
1074ba: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
1074bd: 68 1c 8c 10 00 push $0x108c1c <== NOT EXECUTED
1074c2: 6a 00 push $0x0 <== NOT EXECUTED
1074c4: e8 89 ff ff ff call 107452 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
1074c9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
1074cc: c9 leave <== NOT EXECUTED
1074cd: c3 ret <== NOT EXECUTED
00107452 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
107452: 55 push %ebp <== NOT EXECUTED
107453: 89 e5 mov %esp,%ebp <== NOT EXECUTED
107455: 56 push %esi <== NOT EXECUTED
107456: 53 push %ebx <== NOT EXECUTED
107457: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
10745a: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED
if ( !print )
10745d: 85 db test %ebx,%ebx <== NOT EXECUTED
10745f: 74 4f je 1074b0 <rtems_stack_checker_report_usage_with_plugin+0x5e><== NOT EXECUTED
return;
print_context = context;
107461: 89 35 10 6f 12 00 mov %esi,0x126f10 <== NOT EXECUTED
print_handler = print;
107467: 89 1d 14 6f 12 00 mov %ebx,0x126f14 <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
10746d: 51 push %ecx <== NOT EXECUTED
10746e: 51 push %ecx <== NOT EXECUTED
10746f: 68 c7 16 12 00 push $0x1216c7 <== NOT EXECUTED
107474: 56 push %esi <== NOT EXECUTED
107475: ff d3 call *%ebx <== NOT EXECUTED
(*print)( context,
107477: 58 pop %eax <== NOT EXECUTED
107478: 5a pop %edx <== NOT EXECUTED
107479: 68 de 16 12 00 push $0x1216de <== NOT EXECUTED
10747e: 56 push %esi <== NOT EXECUTED
10747f: ff d3 call *%ebx <== NOT EXECUTED
" ID NAME LOW HIGH CURRENT AVAILABLE USED\n"
);
/* iterate over all threads and dump the usage */
rtems_iterate_over_all_threads( Stack_check_Dump_threads_usage );
107481: c7 04 24 08 71 10 00 movl $0x107108,(%esp) <== NOT EXECUTED
107488: e8 df 63 00 00 call 10d86c <rtems_iterate_over_all_threads><== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
/* dump interrupt stack info if any */
Stack_check_Dump_threads_usage((Thread_Control *) -1);
10748d: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED
107494: e8 6f fc ff ff call 107108 <Stack_check_Dump_threads_usage><== NOT EXECUTED
#endif
print_context = NULL;
107499: c7 05 10 6f 12 00 00 movl $0x0,0x126f10 <== NOT EXECUTED
1074a0: 00 00 00
print_handler = NULL;
1074a3: c7 05 14 6f 12 00 00 movl $0x0,0x126f14 <== NOT EXECUTED
1074aa: 00 00 00
1074ad: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
1074b0: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
1074b3: 5b pop %ebx <== NOT EXECUTED
1074b4: 5e pop %esi <== NOT EXECUTED
1074b5: c9 leave <== NOT EXECUTED
1074b6: c3 ret <== NOT EXECUTED
0010738f <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
10738f: 55 push %ebp
107390: 89 e5 mov %esp,%ebp
107392: 53 push %ebx
107393: 83 ec 14 sub $0x14,%esp
107396: 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 = Stack_check_Get_pattern_area(the_stack);
107399: 8b 83 bc 00 00 00 mov 0xbc(%ebx),%eax
10739f: 8d 48 08 lea 0x8(%eax),%ecx
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
1073a2: 31 d2 xor %edx,%edx
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
1073a4: 39 c5 cmp %eax,%ebp
1073a6: 72 0b jb 1073b3 <rtems_stack_checker_switch_extension+0x24><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
1073a8: 03 83 b8 00 00 00 add 0xb8(%ebx),%eax
}
/*
* rtems_stack_checker_switch_extension
*/
void rtems_stack_checker_switch_extension(
1073ae: 39 c5 cmp %eax,%ebp
1073b0: 0f 96 c2 setbe %dl
/*
* 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,
1073b3: 50 push %eax
1073b4: 6a 10 push $0x10
1073b6: 68 28 72 12 00 push $0x127228
1073bb: 51 push %ecx
1073bc: 88 55 f4 mov %dl,-0xc(%ebp)
1073bf: e8 74 cb 00 00 call 113f38 <memcmp>
1073c4: 83 c4 10 add $0x10,%esp
1073c7: 85 c0 test %eax,%eax
1073c9: 0f 94 c0 sete %al
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
1073cc: 8a 55 f4 mov -0xc(%ebp),%dl
1073cf: 84 d2 test %dl,%dl
1073d1: 74 04 je 1073d7 <rtems_stack_checker_switch_extension+0x48><== NEVER TAKEN
1073d3: 84 c0 test %al,%al
1073d5: 75 0c jne 1073e3 <rtems_stack_checker_switch_extension+0x54><== ALWAYS TAKEN
Stack_check_report_blown_task( running, pattern_ok );
1073d7: 52 push %edx <== NOT EXECUTED
1073d8: 52 push %edx <== NOT EXECUTED
1073d9: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
1073dc: 50 push %eax <== NOT EXECUTED
1073dd: 53 push %ebx <== NOT EXECUTED
1073de: e8 f8 fe ff ff call 1072db <Stack_check_report_blown_task><== NOT EXECUTED
}
}
1073e3: 8b 5d fc mov -0x4(%ebp),%ebx
1073e6: c9 leave
1073e7: c3 ret
0010f010 <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
10f010: 55 push %ebp
10f011: 89 e5 mov %esp,%ebp
10f013: 57 push %edi
10f014: 56 push %esi
10f015: 53 push %ebx
10f016: 83 ec 2c sub $0x2c,%esp
10f019: 8b 75 08 mov 0x8(%ebp),%esi
10f01c: 8b 5d 0c mov 0xc(%ebp),%ebx
10f01f: 8b 7d 10 mov 0x10(%ebp),%edi
double result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f022: ba 09 00 00 00 mov $0x9,%edx
)
{
double result;
char *end;
if ( !n )
10f027: 85 db test %ebx,%ebx
10f029: 0f 84 95 00 00 00 je 10f0c4 <rtems_string_to_double+0xb4>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f02f: e8 48 2a 00 00 call 111a7c <__errno>
10f034: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f03a: c7 03 00 00 00 00 movl $0x0,(%ebx)
10f040: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
result = strtod( s, &end );
10f047: 50 push %eax
10f048: 50 push %eax
10f049: 8d 45 e4 lea -0x1c(%ebp),%eax
10f04c: 50 push %eax
10f04d: 56 push %esi
10f04e: e8 d5 54 00 00 call 114528 <strtod>
if ( endptr )
10f053: 83 c4 10 add $0x10,%esp
10f056: 85 ff test %edi,%edi
10f058: 74 05 je 10f05f <rtems_string_to_double+0x4f>
*endptr = end;
10f05a: 8b 45 e4 mov -0x1c(%ebp),%eax
10f05d: 89 07 mov %eax,(%edi)
if ( end == s )
return RTEMS_NOT_DEFINED;
10f05f: ba 0b 00 00 00 mov $0xb,%edx
result = strtod( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
10f064: 39 75 e4 cmp %esi,-0x1c(%ebp)
10f067: 74 4d je 10f0b6 <rtems_string_to_double+0xa6>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f069: dd 5d c8 fstpl -0x38(%ebp)
10f06c: e8 0b 2a 00 00 call 111a7c <__errno>
10f071: 83 38 22 cmpl $0x22,(%eax)
10f074: dd 45 c8 fldl -0x38(%ebp)
10f077: 75 37 jne 10f0b0 <rtems_string_to_double+0xa0>
10f079: d9 ee fldz
10f07b: d9 c9 fxch %st(1)
10f07d: dd e1 fucom %st(1)
10f07f: df e0 fnstsw %ax
10f081: dd d9 fstp %st(1)
10f083: 9e sahf
10f084: 7a 07 jp 10f08d <rtems_string_to_double+0x7d><== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
10f086: ba 0a 00 00 00 mov $0xa,%edx
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f08b: 74 2d je 10f0ba <rtems_string_to_double+0xaa><== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
10f08d: ba 0a 00 00 00 mov $0xa,%edx
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
10f092: dd 05 80 3d 12 00 fldl 0x123d80
10f098: d9 c9 fxch %st(1)
10f09a: dd e1 fucom %st(1)
10f09c: df e0 fnstsw %ax
10f09e: dd d9 fstp %st(1)
10f0a0: 9e sahf
10f0a1: 77 1b ja 10f0be <rtems_string_to_double+0xae><== ALWAYS TAKEN
10f0a3: dd 05 88 3d 12 00 fldl 0x123d88 <== NOT EXECUTED
10f0a9: dd e9 fucomp %st(1) <== NOT EXECUTED
10f0ab: df e0 fnstsw %ax <== NOT EXECUTED
10f0ad: 9e sahf <== NOT EXECUTED
10f0ae: 77 12 ja 10f0c2 <rtems_string_to_double+0xb2><== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
*n = result;
10f0b0: dd 1b fstpl (%ebx)
return RTEMS_SUCCESSFUL;
10f0b2: 31 d2 xor %edx,%edx
10f0b4: eb 0e jmp 10f0c4 <rtems_string_to_double+0xb4>
10f0b6: dd d8 fstp %st(0)
10f0b8: eb 0a jmp 10f0c4 <rtems_string_to_double+0xb4>
10f0ba: dd d8 fstp %st(0) <== NOT EXECUTED
10f0bc: eb 06 jmp 10f0c4 <rtems_string_to_double+0xb4><== NOT EXECUTED
10f0be: dd d8 fstp %st(0)
10f0c0: eb 02 jmp 10f0c4 <rtems_string_to_double+0xb4>
10f0c2: dd d8 fstp %st(0) <== NOT EXECUTED
}
10f0c4: 89 d0 mov %edx,%eax
10f0c6: 8d 65 f4 lea -0xc(%ebp),%esp
10f0c9: 5b pop %ebx
10f0ca: 5e pop %esi
10f0cb: 5f pop %edi
10f0cc: c9 leave
10f0cd: c3 ret
0010f0d0 <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
10f0d0: 55 push %ebp
10f0d1: 89 e5 mov %esp,%ebp
10f0d3: 57 push %edi
10f0d4: 56 push %esi
10f0d5: 53 push %ebx
10f0d6: 83 ec 2c sub $0x2c,%esp
10f0d9: 8b 75 08 mov 0x8(%ebp),%esi
10f0dc: 8b 5d 0c mov 0xc(%ebp),%ebx
10f0df: 8b 7d 10 mov 0x10(%ebp),%edi
float result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f0e2: ba 09 00 00 00 mov $0x9,%edx
)
{
float result;
char *end;
if ( !n )
10f0e7: 85 db test %ebx,%ebx
10f0e9: 0f 84 8e 00 00 00 je 10f17d <rtems_string_to_float+0xad>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f0ef: e8 88 29 00 00 call 111a7c <__errno>
10f0f4: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f0fa: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtof( s, &end );
10f100: 50 push %eax
10f101: 50 push %eax
10f102: 8d 45 e4 lea -0x1c(%ebp),%eax
10f105: 50 push %eax
10f106: 56 push %esi
10f107: e8 38 54 00 00 call 114544 <strtof>
if ( endptr )
10f10c: 83 c4 10 add $0x10,%esp
10f10f: 85 ff test %edi,%edi
10f111: 74 05 je 10f118 <rtems_string_to_float+0x48>
*endptr = end;
10f113: 8b 45 e4 mov -0x1c(%ebp),%eax
10f116: 89 07 mov %eax,(%edi)
if ( end == s )
return RTEMS_NOT_DEFINED;
10f118: ba 0b 00 00 00 mov $0xb,%edx
result = strtof( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
10f11d: 39 75 e4 cmp %esi,-0x1c(%ebp)
10f120: 74 4d je 10f16f <rtems_string_to_float+0x9f>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f122: d9 5d c8 fstps -0x38(%ebp)
10f125: e8 52 29 00 00 call 111a7c <__errno>
10f12a: 83 38 22 cmpl $0x22,(%eax)
10f12d: d9 45 c8 flds -0x38(%ebp)
10f130: 75 37 jne 10f169 <rtems_string_to_float+0x99>
10f132: d9 ee fldz
10f134: d9 c9 fxch %st(1)
10f136: dd e1 fucom %st(1)
10f138: df e0 fnstsw %ax
10f13a: dd d9 fstp %st(1)
10f13c: 9e sahf
10f13d: 7a 07 jp 10f146 <rtems_string_to_float+0x76><== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
10f13f: ba 0a 00 00 00 mov $0xa,%edx
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f144: 74 2d je 10f173 <rtems_string_to_float+0xa3><== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
10f146: ba 0a 00 00 00 mov $0xa,%edx
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
10f14b: d9 05 90 3d 12 00 flds 0x123d90
10f151: d9 c9 fxch %st(1)
10f153: dd e1 fucom %st(1)
10f155: df e0 fnstsw %ax
10f157: dd d9 fstp %st(1)
10f159: 9e sahf
10f15a: 77 1b ja 10f177 <rtems_string_to_float+0xa7><== ALWAYS TAKEN
10f15c: d9 05 94 3d 12 00 flds 0x123d94 <== NOT EXECUTED
10f162: dd e9 fucomp %st(1) <== NOT EXECUTED
10f164: df e0 fnstsw %ax <== NOT EXECUTED
10f166: 9e sahf <== NOT EXECUTED
10f167: 77 12 ja 10f17b <rtems_string_to_float+0xab><== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
*n = result;
10f169: d9 1b fstps (%ebx)
return RTEMS_SUCCESSFUL;
10f16b: 31 d2 xor %edx,%edx
10f16d: eb 0e jmp 10f17d <rtems_string_to_float+0xad>
10f16f: dd d8 fstp %st(0)
10f171: eb 0a jmp 10f17d <rtems_string_to_float+0xad>
10f173: dd d8 fstp %st(0) <== NOT EXECUTED
10f175: eb 06 jmp 10f17d <rtems_string_to_float+0xad><== NOT EXECUTED
10f177: dd d8 fstp %st(0)
10f179: eb 02 jmp 10f17d <rtems_string_to_float+0xad>
10f17b: dd d8 fstp %st(0) <== NOT EXECUTED
}
10f17d: 89 d0 mov %edx,%eax
10f17f: 8d 65 f4 lea -0xc(%ebp),%esp
10f182: 5b pop %ebx
10f183: 5e pop %esi
10f184: 5f pop %edi
10f185: c9 leave
10f186: c3 ret
0010f188 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
10f188: 55 push %ebp
10f189: 89 e5 mov %esp,%ebp
10f18b: 57 push %edi
10f18c: 56 push %esi
10f18d: 53 push %ebx
10f18e: 83 ec 2c sub $0x2c,%esp
10f191: 8b 7d 08 mov 0x8(%ebp),%edi
10f194: 8b 75 0c mov 0xc(%ebp),%esi
10f197: 8b 55 10 mov 0x10(%ebp),%edx
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f19a: b8 09 00 00 00 mov $0x9,%eax
)
{
long result;
char *end;
if ( !n )
10f19f: 85 f6 test %esi,%esi
10f1a1: 74 6b je 10f20e <rtems_string_to_int+0x86>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f1a3: 89 55 d4 mov %edx,-0x2c(%ebp)
10f1a6: e8 d1 28 00 00 call 111a7c <__errno>
10f1ab: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f1b1: c7 06 00 00 00 00 movl $0x0,(%esi)
result = strtol( s, &end, base );
10f1b7: 50 push %eax
10f1b8: ff 75 14 pushl 0x14(%ebp)
10f1bb: 8d 45 e4 lea -0x1c(%ebp),%eax
10f1be: 50 push %eax
10f1bf: 57 push %edi
10f1c0: e8 3f 55 00 00 call 114704 <strtol>
10f1c5: 89 c3 mov %eax,%ebx
if ( endptr )
10f1c7: 83 c4 10 add $0x10,%esp
10f1ca: 8b 55 d4 mov -0x2c(%ebp),%edx
10f1cd: 85 d2 test %edx,%edx
10f1cf: 74 05 je 10f1d6 <rtems_string_to_int+0x4e>
*endptr = end;
10f1d1: 8b 45 e4 mov -0x1c(%ebp),%eax
10f1d4: 89 02 mov %eax,(%edx)
if ( end == s )
return RTEMS_NOT_DEFINED;
10f1d6: b8 0b 00 00 00 mov $0xb,%eax
result = strtol( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
10f1db: 39 7d e4 cmp %edi,-0x1c(%ebp)
10f1de: 74 2e je 10f20e <rtems_string_to_int+0x86>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f1e0: e8 97 28 00 00 call 111a7c <__errno>
10f1e5: 83 38 22 cmpl $0x22,(%eax)
10f1e8: 75 19 jne 10f203 <rtems_string_to_int+0x7b>
10f1ea: 81 fb ff ff ff 7f cmp $0x7fffffff,%ebx
10f1f0: 74 17 je 10f209 <rtems_string_to_int+0x81><== ALWAYS TAKEN
10f1f2: 85 db test %ebx,%ebx <== NOT EXECUTED
10f1f4: 74 13 je 10f209 <rtems_string_to_int+0x81><== NOT EXECUTED
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
10f1f6: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
10f1fb: 81 fb 00 00 00 80 cmp $0x80000000,%ebx <== NOT EXECUTED
10f201: 74 0b je 10f20e <rtems_string_to_int+0x86><== NOT EXECUTED
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
10f203: 89 1e mov %ebx,(%esi)
return RTEMS_SUCCESSFUL;
10f205: 31 c0 xor %eax,%eax
10f207: eb 05 jmp 10f20e <rtems_string_to_int+0x86>
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
10f209: b8 0a 00 00 00 mov $0xa,%eax
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
10f20e: 8d 65 f4 lea -0xc(%ebp),%esp
10f211: 5b pop %ebx
10f212: 5e pop %esi
10f213: 5f pop %edi
10f214: c9 leave
10f215: c3 ret
0010f2c4 <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
10f2c4: 55 push %ebp
10f2c5: 89 e5 mov %esp,%ebp
10f2c7: 57 push %edi
10f2c8: 56 push %esi
10f2c9: 53 push %ebx
10f2ca: 83 ec 2c sub $0x2c,%esp
10f2cd: 8b 7d 08 mov 0x8(%ebp),%edi
10f2d0: 8b 75 0c mov 0xc(%ebp),%esi
10f2d3: 8b 55 10 mov 0x10(%ebp),%edx
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f2d6: b8 09 00 00 00 mov $0x9,%eax
)
{
long result;
char *end;
if ( !n )
10f2db: 85 f6 test %esi,%esi
10f2dd: 74 6b je 10f34a <rtems_string_to_long+0x86>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f2df: 89 55 d4 mov %edx,-0x2c(%ebp)
10f2e2: e8 95 27 00 00 call 111a7c <__errno>
10f2e7: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f2ed: c7 06 00 00 00 00 movl $0x0,(%esi)
result = strtol( s, &end, base );
10f2f3: 50 push %eax
10f2f4: ff 75 14 pushl 0x14(%ebp)
10f2f7: 8d 45 e4 lea -0x1c(%ebp),%eax
10f2fa: 50 push %eax
10f2fb: 57 push %edi
10f2fc: e8 03 54 00 00 call 114704 <strtol>
10f301: 89 c3 mov %eax,%ebx
if ( endptr )
10f303: 83 c4 10 add $0x10,%esp
10f306: 8b 55 d4 mov -0x2c(%ebp),%edx
10f309: 85 d2 test %edx,%edx
10f30b: 74 05 je 10f312 <rtems_string_to_long+0x4e>
*endptr = end;
10f30d: 8b 45 e4 mov -0x1c(%ebp),%eax
10f310: 89 02 mov %eax,(%edx)
if ( end == s )
return RTEMS_NOT_DEFINED;
10f312: b8 0b 00 00 00 mov $0xb,%eax
result = strtol( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
10f317: 39 7d e4 cmp %edi,-0x1c(%ebp)
10f31a: 74 2e je 10f34a <rtems_string_to_long+0x86>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f31c: e8 5b 27 00 00 call 111a7c <__errno>
10f321: 83 38 22 cmpl $0x22,(%eax)
10f324: 75 19 jne 10f33f <rtems_string_to_long+0x7b>
10f326: 81 fb ff ff ff 7f cmp $0x7fffffff,%ebx
10f32c: 74 17 je 10f345 <rtems_string_to_long+0x81>
10f32e: 85 db test %ebx,%ebx
10f330: 74 13 je 10f345 <rtems_string_to_long+0x81><== NEVER TAKEN
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
10f332: b8 0a 00 00 00 mov $0xa,%eax
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
10f337: 81 fb 00 00 00 80 cmp $0x80000000,%ebx
10f33d: 74 0b je 10f34a <rtems_string_to_long+0x86><== ALWAYS TAKEN
return RTEMS_INVALID_NUMBER;
*n = result;
10f33f: 89 1e mov %ebx,(%esi)
return RTEMS_SUCCESSFUL;
10f341: 31 c0 xor %eax,%eax
10f343: eb 05 jmp 10f34a <rtems_string_to_long+0x86>
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
10f345: b8 0a 00 00 00 mov $0xa,%eax
*n = result;
return RTEMS_SUCCESSFUL;
}
10f34a: 8d 65 f4 lea -0xc(%ebp),%esp
10f34d: 5b pop %ebx
10f34e: 5e pop %esi
10f34f: 5f pop %edi
10f350: c9 leave
10f351: c3 ret
0010f218 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
10f218: 55 push %ebp
10f219: 89 e5 mov %esp,%ebp
10f21b: 57 push %edi
10f21c: 56 push %esi
10f21d: 53 push %ebx
10f21e: 83 ec 2c sub $0x2c,%esp
10f221: 8b 5d 0c mov 0xc(%ebp),%ebx
10f224: 8b 7d 10 mov 0x10(%ebp),%edi
long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f227: b8 09 00 00 00 mov $0x9,%eax
)
{
long long result;
char *end;
if ( !n )
10f22c: 85 db test %ebx,%ebx
10f22e: 0f 84 85 00 00 00 je 10f2b9 <rtems_string_to_long_long+0xa1>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f234: e8 43 28 00 00 call 111a7c <__errno>
10f239: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f23f: c7 03 00 00 00 00 movl $0x0,(%ebx)
10f245: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
result = strtoll( s, &end, base );
10f24c: 50 push %eax
10f24d: ff 75 14 pushl 0x14(%ebp)
10f250: 8d 45 e4 lea -0x1c(%ebp),%eax
10f253: 50 push %eax
10f254: ff 75 08 pushl 0x8(%ebp)
10f257: e8 c4 54 00 00 call 114720 <strtoll>
10f25c: 89 c6 mov %eax,%esi
if ( endptr )
10f25e: 83 c4 10 add $0x10,%esp
10f261: 85 ff test %edi,%edi
10f263: 74 05 je 10f26a <rtems_string_to_long_long+0x52>
*endptr = end;
10f265: 8b 45 e4 mov -0x1c(%ebp),%eax
10f268: 89 07 mov %eax,(%edi)
if ( end == s )
return RTEMS_NOT_DEFINED;
10f26a: b8 0b 00 00 00 mov $0xb,%eax
result = strtoll( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
10f26f: 8b 4d 08 mov 0x8(%ebp),%ecx
10f272: 39 4d e4 cmp %ecx,-0x1c(%ebp)
10f275: 74 42 je 10f2b9 <rtems_string_to_long_long+0xa1>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f277: 89 55 d4 mov %edx,-0x2c(%ebp)
10f27a: e8 fd 27 00 00 call 111a7c <__errno>
10f27f: 83 38 22 cmpl $0x22,(%eax)
10f282: 8b 55 d4 mov -0x2c(%ebp),%edx
10f285: 75 24 jne 10f2ab <rtems_string_to_long_long+0x93>
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
10f287: 89 f1 mov %esi,%ecx
10f289: f7 d1 not %ecx
10f28b: 89 d0 mov %edx,%eax
10f28d: 35 ff ff ff 7f xor $0x7fffffff,%eax
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f292: 09 c1 or %eax,%ecx
10f294: 74 1e je 10f2b4 <rtems_string_to_long_long+0x9c>
10f296: 89 f0 mov %esi,%eax
10f298: 09 d0 or %edx,%eax
10f29a: 74 18 je 10f2b4 <rtems_string_to_long_long+0x9c><== NEVER TAKEN
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
10f29c: 8d 8a 00 00 00 80 lea -0x80000000(%edx),%ecx
return RTEMS_INVALID_NUMBER;
10f2a2: b8 0a 00 00 00 mov $0xa,%eax
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
10f2a7: 09 f1 or %esi,%ecx
10f2a9: 74 0e je 10f2b9 <rtems_string_to_long_long+0xa1><== ALWAYS TAKEN
return RTEMS_INVALID_NUMBER;
*n = result;
10f2ab: 89 33 mov %esi,(%ebx)
10f2ad: 89 53 04 mov %edx,0x4(%ebx)
return RTEMS_SUCCESSFUL;
10f2b0: 31 c0 xor %eax,%eax
10f2b2: eb 05 jmp 10f2b9 <rtems_string_to_long_long+0xa1>
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
10f2b4: b8 0a 00 00 00 mov $0xa,%eax
*n = result;
return RTEMS_SUCCESSFUL;
}
10f2b9: 8d 65 f4 lea -0xc(%ebp),%esp
10f2bc: 5b pop %ebx
10f2bd: 5e pop %esi
10f2be: 5f pop %edi
10f2bf: c9 leave
10f2c0: c3 ret
0010f36c <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
10f36c: 55 push %ebp
10f36d: 89 e5 mov %esp,%ebp
10f36f: 57 push %edi
10f370: 56 push %esi
10f371: 53 push %ebx
10f372: 83 ec 2c sub $0x2c,%esp
10f375: 8b 7d 08 mov 0x8(%ebp),%edi
10f378: 8b 5d 0c mov 0xc(%ebp),%ebx
10f37b: 8b 55 10 mov 0x10(%ebp),%edx
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f37e: b8 09 00 00 00 mov $0x9,%eax
)
{
unsigned long result;
char *end;
if ( !n )
10f383: 85 db test %ebx,%ebx
10f385: 74 71 je 10f3f8 <rtems_string_to_unsigned_char+0x8c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f387: 89 55 d4 mov %edx,-0x2c(%ebp)
10f38a: e8 ed 26 00 00 call 111a7c <__errno>
10f38f: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f395: c6 03 00 movb $0x0,(%ebx)
result = strtoul( s, &end, base );
10f398: 50 push %eax
10f399: ff 75 14 pushl 0x14(%ebp)
10f39c: 8d 45 e4 lea -0x1c(%ebp),%eax
10f39f: 50 push %eax
10f3a0: 57 push %edi
10f3a1: e8 1a 58 00 00 call 114bc0 <strtoul>
10f3a6: 89 c6 mov %eax,%esi
if ( endptr )
10f3a8: 83 c4 10 add $0x10,%esp
10f3ab: 8b 55 d4 mov -0x2c(%ebp),%edx
10f3ae: 85 d2 test %edx,%edx
10f3b0: 74 05 je 10f3b7 <rtems_string_to_unsigned_char+0x4b>
*endptr = end;
10f3b2: 8b 45 e4 mov -0x1c(%ebp),%eax
10f3b5: 89 02 mov %eax,(%edx)
if ( end == s )
return RTEMS_NOT_DEFINED;
10f3b7: b8 0b 00 00 00 mov $0xb,%eax
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
10f3bc: 39 7d e4 cmp %edi,-0x1c(%ebp)
10f3bf: 74 37 je 10f3f8 <rtems_string_to_unsigned_char+0x8c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f3c1: e8 b6 26 00 00 call 111a7c <__errno>
10f3c6: 83 38 22 cmpl $0x22,(%eax)
10f3c9: 75 0d jne 10f3d8 <rtems_string_to_unsigned_char+0x6c><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
10f3cb: 8d 56 ff lea -0x1(%esi),%edx <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
10f3ce: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f3d3: 83 fa fd cmp $0xfffffffd,%edx <== NOT EXECUTED
10f3d6: 77 20 ja 10f3f8 <rtems_string_to_unsigned_char+0x8c><== NOT EXECUTED
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
10f3d8: 81 fe ff 00 00 00 cmp $0xff,%esi
10f3de: 76 12 jbe 10f3f2 <rtems_string_to_unsigned_char+0x86><== ALWAYS TAKEN
errno = ERANGE;
10f3e0: e8 97 26 00 00 call 111a7c <__errno> <== NOT EXECUTED
10f3e5: c7 00 22 00 00 00 movl $0x22,(%eax) <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
10f3eb: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED
10f3f0: eb 06 jmp 10f3f8 <rtems_string_to_unsigned_char+0x8c><== NOT EXECUTED
}
#endif
*n = result;
10f3f2: 89 f0 mov %esi,%eax
10f3f4: 88 03 mov %al,(%ebx)
return RTEMS_SUCCESSFUL;
10f3f6: 31 c0 xor %eax,%eax
}
10f3f8: 8d 65 f4 lea -0xc(%ebp),%esp
10f3fb: 5b pop %ebx
10f3fc: 5e pop %esi
10f3fd: 5f pop %edi
10f3fe: c9 leave
10f3ff: c3 ret
0010f400 <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
10f400: 55 push %ebp
10f401: 89 e5 mov %esp,%ebp
10f403: 57 push %edi
10f404: 56 push %esi
10f405: 53 push %ebx
10f406: 83 ec 2c sub $0x2c,%esp
10f409: 8b 7d 08 mov 0x8(%ebp),%edi
10f40c: 8b 5d 0c mov 0xc(%ebp),%ebx
10f40f: 8b 55 10 mov 0x10(%ebp),%edx
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f412: b8 09 00 00 00 mov $0x9,%eax
)
{
unsigned long result;
char *end;
if ( !n )
10f417: 85 db test %ebx,%ebx
10f419: 74 58 je 10f473 <rtems_string_to_unsigned_int+0x73>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f41b: 89 55 d4 mov %edx,-0x2c(%ebp)
10f41e: e8 59 26 00 00 call 111a7c <__errno>
10f423: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f429: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtoul( s, &end, base );
10f42f: 50 push %eax
10f430: ff 75 14 pushl 0x14(%ebp)
10f433: 8d 45 e4 lea -0x1c(%ebp),%eax
10f436: 50 push %eax
10f437: 57 push %edi
10f438: e8 83 57 00 00 call 114bc0 <strtoul>
10f43d: 89 c6 mov %eax,%esi
if ( endptr )
10f43f: 83 c4 10 add $0x10,%esp
10f442: 8b 55 d4 mov -0x2c(%ebp),%edx
10f445: 85 d2 test %edx,%edx
10f447: 74 05 je 10f44e <rtems_string_to_unsigned_int+0x4e>
*endptr = end;
10f449: 8b 45 e4 mov -0x1c(%ebp),%eax
10f44c: 89 02 mov %eax,(%edx)
if ( end == s )
return RTEMS_NOT_DEFINED;
10f44e: b8 0b 00 00 00 mov $0xb,%eax
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
10f453: 39 7d e4 cmp %edi,-0x1c(%ebp)
10f456: 74 1b je 10f473 <rtems_string_to_unsigned_int+0x73>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f458: e8 1f 26 00 00 call 111a7c <__errno>
10f45d: 83 38 22 cmpl $0x22,(%eax)
10f460: 75 0d jne 10f46f <rtems_string_to_unsigned_int+0x6f>
(( result == 0 ) || ( result == ULONG_MAX )))
10f462: 8d 56 ff lea -0x1(%esi),%edx
return RTEMS_INVALID_NUMBER;
10f465: b8 0a 00 00 00 mov $0xa,%eax
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f46a: 83 fa fd cmp $0xfffffffd,%edx
10f46d: 77 04 ja 10f473 <rtems_string_to_unsigned_int+0x73><== ALWAYS TAKEN
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
10f46f: 89 33 mov %esi,(%ebx)
return RTEMS_SUCCESSFUL;
10f471: 31 c0 xor %eax,%eax
}
10f473: 8d 65 f4 lea -0xc(%ebp),%esp
10f476: 5b pop %ebx
10f477: 5e pop %esi
10f478: 5f pop %edi
10f479: c9 leave
10f47a: c3 ret
0010f518 <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
10f518: 55 push %ebp
10f519: 89 e5 mov %esp,%ebp
10f51b: 57 push %edi
10f51c: 56 push %esi
10f51d: 53 push %ebx
10f51e: 83 ec 2c sub $0x2c,%esp
10f521: 8b 7d 08 mov 0x8(%ebp),%edi
10f524: 8b 5d 0c mov 0xc(%ebp),%ebx
10f527: 8b 55 10 mov 0x10(%ebp),%edx
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f52a: b8 09 00 00 00 mov $0x9,%eax
)
{
unsigned long result;
char *end;
if ( !n )
10f52f: 85 db test %ebx,%ebx
10f531: 74 58 je 10f58b <rtems_string_to_unsigned_long+0x73>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f533: 89 55 d4 mov %edx,-0x2c(%ebp)
10f536: e8 41 25 00 00 call 111a7c <__errno>
10f53b: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f541: c7 03 00 00 00 00 movl $0x0,(%ebx)
result = strtoul( s, &end, base );
10f547: 50 push %eax
10f548: ff 75 14 pushl 0x14(%ebp)
10f54b: 8d 45 e4 lea -0x1c(%ebp),%eax
10f54e: 50 push %eax
10f54f: 57 push %edi
10f550: e8 6b 56 00 00 call 114bc0 <strtoul>
10f555: 89 c6 mov %eax,%esi
if ( endptr )
10f557: 83 c4 10 add $0x10,%esp
10f55a: 8b 55 d4 mov -0x2c(%ebp),%edx
10f55d: 85 d2 test %edx,%edx
10f55f: 74 05 je 10f566 <rtems_string_to_unsigned_long+0x4e>
*endptr = end;
10f561: 8b 45 e4 mov -0x1c(%ebp),%eax
10f564: 89 02 mov %eax,(%edx)
if ( end == s )
return RTEMS_NOT_DEFINED;
10f566: b8 0b 00 00 00 mov $0xb,%eax
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
10f56b: 39 7d e4 cmp %edi,-0x1c(%ebp)
10f56e: 74 1b je 10f58b <rtems_string_to_unsigned_long+0x73>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f570: e8 07 25 00 00 call 111a7c <__errno>
10f575: 83 38 22 cmpl $0x22,(%eax)
10f578: 75 0d jne 10f587 <rtems_string_to_unsigned_long+0x6f>
(( result == 0 ) || ( result == ULONG_MAX )))
10f57a: 8d 56 ff lea -0x1(%esi),%edx
return RTEMS_INVALID_NUMBER;
10f57d: b8 0a 00 00 00 mov $0xa,%eax
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f582: 83 fa fd cmp $0xfffffffd,%edx
10f585: 77 04 ja 10f58b <rtems_string_to_unsigned_long+0x73><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
10f587: 89 33 mov %esi,(%ebx)
return RTEMS_SUCCESSFUL;
10f589: 31 c0 xor %eax,%eax
}
10f58b: 8d 65 f4 lea -0xc(%ebp),%esp
10f58e: 5b pop %ebx
10f58f: 5e pop %esi
10f590: 5f pop %edi
10f591: c9 leave
10f592: c3 ret
0010f47c <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
10f47c: 55 push %ebp
10f47d: 89 e5 mov %esp,%ebp
10f47f: 57 push %edi
10f480: 56 push %esi
10f481: 53 push %ebx
10f482: 83 ec 2c sub $0x2c,%esp
10f485: 8b 7d 08 mov 0x8(%ebp),%edi
10f488: 8b 5d 0c mov 0xc(%ebp),%ebx
10f48b: 8b 75 10 mov 0x10(%ebp),%esi
unsigned long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
10f48e: b8 09 00 00 00 mov $0x9,%eax
)
{
unsigned long long result;
char *end;
if ( !n )
10f493: 85 db test %ebx,%ebx
10f495: 74 76 je 10f50d <rtems_string_to_unsigned_long_long+0x91>
return RTEMS_INVALID_ADDRESS;
errno = 0;
10f497: e8 e0 25 00 00 call 111a7c <__errno>
10f49c: c7 00 00 00 00 00 movl $0x0,(%eax)
*n = 0;
10f4a2: c7 03 00 00 00 00 movl $0x0,(%ebx)
10f4a8: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx)
result = strtoull( s, &end, base );
10f4af: 50 push %eax
10f4b0: ff 75 14 pushl 0x14(%ebp)
10f4b3: 8d 45 e4 lea -0x1c(%ebp),%eax
10f4b6: 50 push %eax
10f4b7: 57 push %edi
10f4b8: e8 1f 57 00 00 call 114bdc <strtoull>
10f4bd: 89 d1 mov %edx,%ecx
10f4bf: 89 c2 mov %eax,%edx
if ( endptr )
10f4c1: 83 c4 10 add $0x10,%esp
10f4c4: 85 f6 test %esi,%esi
10f4c6: 74 05 je 10f4cd <rtems_string_to_unsigned_long_long+0x51>
*endptr = end;
10f4c8: 8b 45 e4 mov -0x1c(%ebp),%eax
10f4cb: 89 06 mov %eax,(%esi)
if ( end == s )
return RTEMS_NOT_DEFINED;
10f4cd: b8 0b 00 00 00 mov $0xb,%eax
result = strtoull( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
10f4d2: 39 7d e4 cmp %edi,-0x1c(%ebp)
10f4d5: 74 36 je 10f50d <rtems_string_to_unsigned_long_long+0x91>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f4d7: 89 55 d4 mov %edx,-0x2c(%ebp)
10f4da: 89 4d d0 mov %ecx,-0x30(%ebp)
10f4dd: e8 9a 25 00 00 call 111a7c <__errno>
10f4e2: 83 38 22 cmpl $0x22,(%eax)
10f4e5: 8b 55 d4 mov -0x2c(%ebp),%edx
10f4e8: 8b 4d d0 mov -0x30(%ebp),%ecx
10f4eb: 75 19 jne 10f506 <rtems_string_to_unsigned_long_long+0x8a>
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
10f4ed: 89 d6 mov %edx,%esi
10f4ef: 89 cf mov %ecx,%edi
10f4f1: 83 c6 ff add $0xffffffff,%esi
10f4f4: 83 d7 ff adc $0xffffffff,%edi
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f4f7: 83 ff ff cmp $0xffffffff,%edi
10f4fa: 72 0a jb 10f506 <rtems_string_to_unsigned_long_long+0x8a><== NEVER TAKEN
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
10f4fc: b8 0a 00 00 00 mov $0xa,%eax
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
10f501: 83 fe fd cmp $0xfffffffd,%esi
10f504: 77 07 ja 10f50d <rtems_string_to_unsigned_long_long+0x91><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
10f506: 89 13 mov %edx,(%ebx)
10f508: 89 4b 04 mov %ecx,0x4(%ebx)
return RTEMS_SUCCESSFUL;
10f50b: 31 c0 xor %eax,%eax
}
10f50d: 8d 65 f4 lea -0xc(%ebp),%esp
10f510: 5b pop %ebx
10f511: 5e pop %esi
10f512: 5f pop %edi
10f513: c9 leave
10f514: c3 ret
0010707c <rtems_tarfs_load>:
int rtems_tarfs_load(
char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
10707c: 55 push %ebp
10707d: 89 e5 mov %esp,%ebp
10707f: 57 push %edi
107080: 56 push %esi
107081: 53 push %ebx
107082: 81 ec d8 01 00 00 sub $0x1d8,%esp
int offset;
unsigned long nblocks;
IMFS_jnode_t *node;
int status;
status = rtems_filesystem_evaluate_path(
107088: 31 c0 xor %eax,%eax
10708a: 83 c9 ff or $0xffffffff,%ecx
10708d: 8b 7d 08 mov 0x8(%ebp),%edi
107090: f2 ae repnz scas %es:(%edi),%al
107092: f7 d1 not %ecx
107094: 49 dec %ecx
107095: 6a 00 push $0x0
107097: 8d 45 d0 lea -0x30(%ebp),%eax
10709a: 50 push %eax
10709b: 6a 00 push $0x0
10709d: 51 push %ecx
10709e: ff 75 08 pushl 0x8(%ebp)
1070a1: e8 d4 09 00 00 call 107a7a <rtems_filesystem_evaluate_path>
1070a6: 89 85 54 fe ff ff mov %eax,-0x1ac(%ebp)
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
1070ac: 83 c4 20 add $0x20,%esp
1070af: 85 c0 test %eax,%eax
1070b1: 0f 85 d9 01 00 00 jne 107290 <rtems_tarfs_load+0x214>
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
1070b7: 8b 45 dc mov -0x24(%ebp),%eax
1070ba: 31 f6 xor %esi,%esi
1070bc: 3d 04 45 12 00 cmp $0x124504,%eax
1070c1: 74 1b je 1070de <rtems_tarfs_load+0x62>
1070c3: 3d ec 4e 12 00 cmp $0x124eec,%eax
1070c8: 0f 85 c2 01 00 00 jne 107290 <rtems_tarfs_load+0x214><== ALWAYS TAKEN
1070ce: 8b b5 54 fe ff ff mov -0x1ac(%ebp),%esi <== NOT EXECUTED
1070d4: eb 08 jmp 1070de <rtems_tarfs_load+0x62> <== NOT EXECUTED
1070d6: 8b b5 50 fe ff ff mov -0x1b0(%ebp),%esi
1070dc: eb 18 jmp 1070f6 <rtems_tarfs_load+0x7a>
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
1070de: 8d 45 bc lea -0x44(%ebp),%eax
1070e1: 89 85 34 fe ff ff mov %eax,-0x1cc(%ebp)
1070e7: 8d 55 d0 lea -0x30(%ebp),%edx
1070ea: 89 95 30 fe ff ff mov %edx,-0x1d0(%ebp)
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
strcpy(full_filename, mountpoint);
1070f0: 8d 9d 58 fe ff ff lea -0x1a8(%ebp),%ebx
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
1070f6: 8d 86 00 02 00 00 lea 0x200(%esi),%eax
1070fc: 89 85 50 fe ff ff mov %eax,-0x1b0(%ebp)
107102: 8b 55 10 mov 0x10(%ebp),%edx
107105: 39 d0 cmp %edx,%eax
107107: 0f 87 8d 01 00 00 ja 10729a <rtems_tarfs_load+0x21e><== NEVER TAKEN
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
10710d: 03 75 0c add 0xc(%ebp),%esi
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
107110: 8d 86 01 01 00 00 lea 0x101(%esi),%eax
107116: 52 push %edx
107117: 6a 05 push $0x5
107119: 68 4c 45 12 00 push $0x12454c
10711e: 50 push %eax
10711f: e8 78 e5 00 00 call 11569c <strncmp>
107124: 83 c4 10 add $0x10,%esp
107127: 85 c0 test %eax,%eax
107129: 0f 85 6b 01 00 00 jne 10729a <rtems_tarfs_load+0x21e>
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
10712f: 50 push %eax
107130: 6a 63 push $0x63
107132: 56 push %esi
107133: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax
107139: 50 push %eax
10713a: e8 ed e5 00 00 call 11572c <strncpy>
filename[MAX_NAME_FIELD_SIZE] = '\0';
10713f: c6 45 bb 00 movb $0x0,-0x45(%ebp)
linkflag = hdr_ptr[156];
107143: 8a 96 9c 00 00 00 mov 0x9c(%esi),%dl
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
107149: 59 pop %ecx
10714a: 5f pop %edi
10714b: 6a 08 push $0x8
10714d: 8d 46 64 lea 0x64(%esi),%eax
107150: 50 push %eax
107151: 88 95 44 fe ff ff mov %dl,-0x1bc(%ebp)
107157: e8 84 6e 00 00 call 10dfe0 <_rtems_octal2ulong>
10715c: 89 85 48 fe ff ff mov %eax,-0x1b8(%ebp)
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
107162: 5f pop %edi
107163: 58 pop %eax
107164: 6a 0c push $0xc
107166: 8d 46 7c lea 0x7c(%esi),%eax
107169: 50 push %eax
10716a: e8 71 6e 00 00 call 10dfe0 <_rtems_octal2ulong>
10716f: 89 85 4c fe ff ff mov %eax,-0x1b4(%ebp)
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
107175: 5a pop %edx
107176: 59 pop %ecx
107177: 6a 08 push $0x8
107179: 8d 86 94 00 00 00 lea 0x94(%esi),%eax
10717f: 50 push %eax
107180: e8 5b 6e 00 00 call 10dfe0 <_rtems_octal2ulong>
107185: 89 c7 mov %eax,%edi
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
107187: 89 34 24 mov %esi,(%esp)
10718a: e8 7f 6e 00 00 call 10e00e <_rtems_tar_header_checksum>
10718f: 83 c4 10 add $0x10,%esp
107192: 39 f8 cmp %edi,%eax
107194: 8a 95 44 fe ff ff mov -0x1bc(%ebp),%dl
10719a: 0f 85 fa 00 00 00 jne 10729a <rtems_tarfs_load+0x21e><== NEVER TAKEN
* Generate an IMFS node depending on the file type.
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
1071a0: 80 fa 35 cmp $0x35,%dl
1071a3: 75 57 jne 1071fc <rtems_tarfs_load+0x180>
strcpy(full_filename, mountpoint);
1071a5: 50 push %eax
1071a6: 50 push %eax
1071a7: ff 75 08 pushl 0x8(%ebp)
1071aa: 53 push %ebx
1071ab: e8 84 e1 00 00 call 115334 <strcpy>
if (full_filename[strlen(full_filename)-1] != '/')
1071b0: 31 c0 xor %eax,%eax
1071b2: 83 c9 ff or $0xffffffff,%ecx
1071b5: 89 df mov %ebx,%edi
1071b7: f2 ae repnz scas %es:(%edi),%al
1071b9: f7 d1 not %ecx
1071bb: 83 c4 10 add $0x10,%esp
1071be: 80 bc 0d 56 fe ff ff cmpb $0x2f,-0x1aa(%ebp,%ecx,1)
1071c5: 2f
1071c6: 74 10 je 1071d8 <rtems_tarfs_load+0x15c><== ALWAYS TAKEN
strcat(full_filename, "/");
1071c8: 57 push %edi <== NOT EXECUTED
1071c9: 57 push %edi <== NOT EXECUTED
1071ca: 68 f9 03 12 00 push $0x1203f9 <== NOT EXECUTED
1071cf: 53 push %ebx <== NOT EXECUTED
1071d0: e8 ab df 00 00 call 115180 <strcat> <== NOT EXECUTED
1071d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
strcat(full_filename, filename);
1071d8: 56 push %esi
1071d9: 56 push %esi
1071da: 8d 95 58 ff ff ff lea -0xa8(%ebp),%edx
1071e0: 52 push %edx
1071e1: 53 push %ebx
1071e2: e8 99 df 00 00 call 115180 <strcat>
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
1071e7: 5a pop %edx
1071e8: 59 pop %ecx
1071e9: 68 ff 01 00 00 push $0x1ff
1071ee: 53 push %ebx
1071ef: e8 58 0f 00 00 call 10814c <mkdir>
1071f4: 83 c4 10 add $0x10,%esp
1071f7: e9 da fe ff ff jmp 1070d6 <rtems_tarfs_load+0x5a>
* IMFS_create_node was ONLY passed a NULL when we created the
* root node. We added a new IMFS_create_root_node() so this
* path no longer existed. The result was simpler code which
* should not have this path.
*/
else if (linkflag == REGTYPE) {
1071fc: 80 fa 30 cmp $0x30,%dl
1071ff: 0f 85 d1 fe ff ff jne 1070d6 <rtems_tarfs_load+0x5a>
const char *name;
loc = root_loc;
107205: b9 05 00 00 00 mov $0x5,%ecx
10720a: 8b bd 34 fe ff ff mov -0x1cc(%ebp),%edi
107210: 8b b5 30 fe ff ff mov -0x1d0(%ebp),%esi
107216: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
107218: 50 push %eax
107219: 8d 45 e4 lea -0x1c(%ebp),%eax
10721c: 50 push %eax
10721d: 8d 55 bc lea -0x44(%ebp),%edx
107220: 52 push %edx
107221: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax
107227: 50 push %eax
107228: e8 df 78 00 00 call 10eb0c <IMFS_evaluate_for_make>
10722d: 83 c4 10 add $0x10,%esp
107230: 85 c0 test %eax,%eax
107232: 75 41 jne 107275 <rtems_tarfs_load+0x1f9><== NEVER TAKEN
node = IMFS_create_node(
107234: 83 ec 0c sub $0xc,%esp
107237: 6a 00 push $0x0
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
107239: 8b 85 48 fe ff ff mov -0x1b8(%ebp),%eax
10723f: 25 ff 01 00 00 and $0x1ff,%eax
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
node = IMFS_create_node(
107244: 80 cc 80 or $0x80,%ah
107247: 50 push %eax
107248: ff 75 e4 pushl -0x1c(%ebp)
10724b: 6a 06 push $0x6
10724d: 8d 55 bc lea -0x44(%ebp),%edx
107250: 52 push %edx
107251: e8 a9 73 00 00 call 10e5ff <IMFS_create_node>
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
107256: 8b 95 4c fe ff ff mov -0x1b4(%ebp),%edx
10725c: 89 50 50 mov %edx,0x50(%eax)
10725f: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
node->info.linearfile.direct = &tar_image[offset];
107266: 8b 55 0c mov 0xc(%ebp),%edx
107269: 03 95 50 fe ff ff add -0x1b0(%ebp),%edx
10726f: 89 50 58 mov %edx,0x58(%eax)
107272: 83 c4 20 add $0x20,%esp
}
nblocks = (((file_size) + 511) & ~511) / 512;
107275: 8b 85 4c fe ff ff mov -0x1b4(%ebp),%eax
10727b: 05 ff 01 00 00 add $0x1ff,%eax
offset += 512 * nblocks;
107280: 25 00 fe ff ff and $0xfffffe00,%eax
107285: 01 85 50 fe ff ff add %eax,-0x1b0(%ebp)
10728b: e9 46 fe ff ff jmp 1070d6 <rtems_tarfs_load+0x5a>
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
return -1;
107290: c7 85 54 fe ff ff ff movl $0xffffffff,-0x1ac(%ebp)
107297: ff ff ff
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
return status;
}
10729a: 8b 85 54 fe ff ff mov -0x1ac(%ebp),%eax
1072a0: 8d 65 f4 lea -0xc(%ebp),%esp
1072a3: 5b pop %ebx
1072a4: 5e pop %esi
1072a5: 5f pop %edi
1072a6: c9 leave
1072a7: c3 ret
00110cfc <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
110cfc: 55 push %ebp
110cfd: 89 e5 mov %esp,%ebp
110cff: 57 push %edi
110d00: 56 push %esi
110d01: 53 push %ebx
110d02: 83 ec 1c sub $0x1c,%esp
110d05: 8b 4d 10 mov 0x10(%ebp),%ecx
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
110d08: b8 09 00 00 00 mov $0x9,%eax
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
110d0d: 85 c9 test %ecx,%ecx
110d0f: 0f 84 fb 00 00 00 je 110e10 <rtems_task_mode+0x114> <== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
110d15: 8b 35 68 58 12 00 mov 0x125868,%esi
api = executing->API_Extensions[ THREAD_API_RTEMS ];
110d1b: 8b 9e e8 00 00 00 mov 0xe8(%esi),%ebx
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
110d21: 80 7e 74 01 cmpb $0x1,0x74(%esi)
110d25: 19 ff sbb %edi,%edi
110d27: 81 e7 00 01 00 00 and $0x100,%edi
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
110d2d: 83 7e 7c 00 cmpl $0x0,0x7c(%esi)
110d31: 74 06 je 110d39 <rtems_task_mode+0x3d>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
110d33: 81 cf 00 02 00 00 or $0x200,%edi
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
110d39: 80 7b 08 01 cmpb $0x1,0x8(%ebx)
110d3d: 19 d2 sbb %edx,%edx
110d3f: 81 e2 00 04 00 00 and $0x400,%edx
old_mode |= _ISR_Get_level();
110d45: 89 55 e4 mov %edx,-0x1c(%ebp)
110d48: 89 4d e0 mov %ecx,-0x20(%ebp)
110d4b: e8 65 c6 ff ff call 10d3b5 <_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;
110d50: 8b 55 e4 mov -0x1c(%ebp),%edx
110d53: 09 d0 or %edx,%eax
old_mode |= _ISR_Get_level();
110d55: 09 f8 or %edi,%eax
110d57: 8b 4d e0 mov -0x20(%ebp),%ecx
110d5a: 89 01 mov %eax,(%ecx)
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
110d5c: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp)
110d63: 74 0b je 110d70 <rtems_task_mode+0x74>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
110d65: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp)
110d6c: 0f 94 46 74 sete 0x74(%esi)
if ( mask & RTEMS_TIMESLICE_MASK ) {
110d70: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp)
110d77: 74 21 je 110d9a <rtems_task_mode+0x9e>
if ( _Modes_Is_timeslice(mode_set) ) {
110d79: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp)
110d80: 74 11 je 110d93 <rtems_task_mode+0x97>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
110d82: c7 46 7c 01 00 00 00 movl $0x1,0x7c(%esi)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
110d89: a1 10 53 12 00 mov 0x125310,%eax
110d8e: 89 46 78 mov %eax,0x78(%esi)
110d91: eb 07 jmp 110d9a <rtems_task_mode+0x9e>
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
110d93: c7 46 7c 00 00 00 00 movl $0x0,0x7c(%esi)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
110d9a: f6 45 0c 01 testb $0x1,0xc(%ebp)
110d9e: 74 0a je 110daa <rtems_task_mode+0xae>
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
110da0: f6 45 08 01 testb $0x1,0x8(%ebp)
110da4: 74 03 je 110da9 <rtems_task_mode+0xad>
110da6: fa cli
110da7: eb 01 jmp 110daa <rtems_task_mode+0xae>
110da9: fb sti
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
110daa: 31 c9 xor %ecx,%ecx
if ( mask & RTEMS_ASR_MASK ) {
110dac: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp)
110db3: 74 2a je 110ddf <rtems_task_mode+0xe3>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
110db5: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp)
110dbc: 0f 94 c0 sete %al
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
110dbf: 3a 43 08 cmp 0x8(%ebx),%al
110dc2: 74 1b je 110ddf <rtems_task_mode+0xe3>
asr->is_enabled = is_asr_enabled;
110dc4: 88 43 08 mov %al,0x8(%ebx)
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
110dc7: 9c pushf
110dc8: fa cli
110dc9: 58 pop %eax
_signals = information->signals_pending;
110dca: 8b 53 18 mov 0x18(%ebx),%edx
information->signals_pending = information->signals_posted;
110dcd: 8b 4b 14 mov 0x14(%ebx),%ecx
110dd0: 89 4b 18 mov %ecx,0x18(%ebx)
information->signals_posted = _signals;
110dd3: 89 53 14 mov %edx,0x14(%ebx)
_ISR_Enable( _level );
110dd6: 50 push %eax
110dd7: 9d popf
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
110dd8: 83 7b 14 00 cmpl $0x0,0x14(%ebx)
110ddc: 0f 95 c1 setne %cl
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
110ddf: 31 c0 xor %eax,%eax
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
110de1: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c
110de8: 75 26 jne 110e10 <rtems_task_mode+0x114> <== NEVER TAKEN
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
110dea: 8b 15 68 58 12 00 mov 0x125868,%edx
if ( are_signals_pending ||
110df0: 84 c9 test %cl,%cl
110df2: 75 0e jne 110e02 <rtems_task_mode+0x106>
110df4: 3b 15 6c 58 12 00 cmp 0x12586c,%edx
110dfa: 74 14 je 110e10 <rtems_task_mode+0x114>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
110dfc: 80 7a 74 00 cmpb $0x0,0x74(%edx)
110e00: 74 0e je 110e10 <rtems_task_mode+0x114> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
110e02: c6 05 74 58 12 00 01 movb $0x1,0x125874
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
110e09: e8 52 b2 ff ff call 10c060 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
110e0e: 31 c0 xor %eax,%eax
}
110e10: 83 c4 1c add $0x1c,%esp
110e13: 5b pop %ebx
110e14: 5e pop %esi
110e15: 5f pop %edi
110e16: c9 leave
110e17: c3 ret
0010dd30 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
10dd30: 55 push %ebp
10dd31: 89 e5 mov %esp,%ebp
10dd33: 56 push %esi
10dd34: 53 push %ebx
10dd35: 83 ec 10 sub $0x10,%esp
10dd38: 8b 5d 0c mov 0xc(%ebp),%ebx
10dd3b: 8b 75 10 mov 0x10(%ebp),%esi
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10dd3e: 85 db test %ebx,%ebx
10dd40: 74 10 je 10dd52 <rtems_task_set_priority+0x22>
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
10dd42: 0f b6 15 24 42 12 00 movzbl 0x124224,%edx
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
10dd49: b8 13 00 00 00 mov $0x13,%eax
)
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
10dd4e: 39 d3 cmp %edx,%ebx
10dd50: 77 52 ja 10dda4 <rtems_task_set_priority+0x74>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
10dd52: b8 09 00 00 00 mov $0x9,%eax
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
10dd57: 85 f6 test %esi,%esi
10dd59: 74 49 je 10dda4 <rtems_task_set_priority+0x74>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
10dd5b: 51 push %ecx
10dd5c: 51 push %ecx
10dd5d: 8d 45 f4 lea -0xc(%ebp),%eax
10dd60: 50 push %eax
10dd61: ff 75 08 pushl 0x8(%ebp)
10dd64: e8 bf 1e 00 00 call 10fc28 <_Thread_Get>
switch ( location ) {
10dd69: 83 c4 10 add $0x10,%esp
10dd6c: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
10dd70: 75 2d jne 10dd9f <rtems_task_set_priority+0x6f>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
10dd72: 8b 50 14 mov 0x14(%eax),%edx
10dd75: 89 16 mov %edx,(%esi)
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
10dd77: 85 db test %ebx,%ebx
10dd79: 74 1b je 10dd96 <rtems_task_set_priority+0x66>
the_thread->real_priority = new_priority;
10dd7b: 89 58 18 mov %ebx,0x18(%eax)
if ( the_thread->resource_count == 0 ||
10dd7e: 83 78 1c 00 cmpl $0x0,0x1c(%eax)
10dd82: 74 05 je 10dd89 <rtems_task_set_priority+0x59>
10dd84: 39 58 14 cmp %ebx,0x14(%eax)
10dd87: 76 0d jbe 10dd96 <rtems_task_set_priority+0x66><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
10dd89: 52 push %edx
10dd8a: 6a 00 push $0x0
10dd8c: 53 push %ebx
10dd8d: 50 push %eax
10dd8e: e8 9d 1a 00 00 call 10f830 <_Thread_Change_priority>
10dd93: 83 c4 10 add $0x10,%esp
}
_Thread_Enable_dispatch();
10dd96: e8 6b 1e 00 00 call 10fc06 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
10dd9b: 31 c0 xor %eax,%eax
10dd9d: eb 05 jmp 10dda4 <rtems_task_set_priority+0x74>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
10dd9f: b8 04 00 00 00 mov $0x4,%eax
}
10dda4: 8d 65 f8 lea -0x8(%ebp),%esp
10dda7: 5b pop %ebx
10dda8: 5e pop %esi
10dda9: c9 leave
10ddaa: c3 ret
00108507 <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
108507: 55 push %ebp
108508: 89 e5 mov %esp,%ebp
10850a: 56 push %esi
10850b: 53 push %ebx
10850c: 8b 75 08 mov 0x8(%ebp),%esi
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
10850f: 8b 06 mov (%esi),%eax
108511: 8b 58 34 mov 0x34(%eax),%ebx
rtems_status_code sc;
sc = rtems_semaphore_obtain(
108514: 51 push %ecx
108515: 6a 00 push $0x0
108517: 6a 00 push $0x0
108519: ff 35 3c 52 12 00 pushl 0x12523c
10851f: e8 44 1c 00 00 call 10a168 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
108524: 83 c4 10 add $0x10,%esp
108527: 85 c0 test %eax,%eax
108529: 0f 85 88 00 00 00 jne 1085b7 <rtems_termios_close+0xb0><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
10852f: 8b 43 08 mov 0x8(%ebx),%eax
108532: 48 dec %eax
108533: 89 43 08 mov %eax,0x8(%ebx)
108536: 85 c0 test %eax,%eax
108538: 0f 85 3e 01 00 00 jne 10867c <rtems_termios_close+0x175>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
10853e: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
108544: c1 e0 05 shl $0x5,%eax
108547: 8b 80 f8 4e 12 00 mov 0x124ef8(%eax),%eax
10854d: 85 c0 test %eax,%eax
10854f: 74 08 je 108559 <rtems_termios_close+0x52>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
108551: 83 ec 0c sub $0xc,%esp
108554: 53 push %ebx
108555: ff d0 call *%eax
108557: eb 26 jmp 10857f <rtems_termios_close+0x78>
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
108559: 52 push %edx
10855a: 6a 00 push $0x0
10855c: 6a 00 push $0x0
10855e: ff 73 18 pushl 0x18(%ebx)
108561: e8 02 1c 00 00 call 10a168 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
108566: 83 c4 10 add $0x10,%esp
108569: 85 c0 test %eax,%eax
10856b: 75 4a jne 1085b7 <rtems_termios_close+0xb0><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
10856d: 89 d8 mov %ebx,%eax
10856f: e8 10 fb ff ff call 108084 <drainOutput>
rtems_semaphore_release (tty->osem);
108574: 83 ec 0c sub $0xc,%esp
108577: ff 73 18 pushl 0x18(%ebx)
10857a: e8 d5 1c 00 00 call 10a254 <rtems_semaphore_release>
10857f: 83 c4 10 add $0x10,%esp
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
108582: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
108589: 75 35 jne 1085c0 <rtems_termios_close+0xb9>
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
10858b: 50 push %eax
10858c: 50 push %eax
10858d: 6a 01 push $0x1
10858f: ff b3 c4 00 00 00 pushl 0xc4(%ebx)
108595: e8 66 17 00 00 call 109d00 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
10859a: 83 c4 10 add $0x10,%esp
10859d: 85 c0 test %eax,%eax
10859f: 75 16 jne 1085b7 <rtems_termios_close+0xb0><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
1085a1: 51 push %ecx
1085a2: 51 push %ecx
1085a3: 6a 01 push $0x1
1085a5: ff b3 c8 00 00 00 pushl 0xc8(%ebx)
1085ab: e8 50 17 00 00 call 109d00 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
1085b0: 83 c4 10 add $0x10,%esp
1085b3: 85 c0 test %eax,%eax
1085b5: 74 09 je 1085c0 <rtems_termios_close+0xb9><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
1085b7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1085ba: 50 push %eax <== NOT EXECUTED
1085bb: e8 74 21 00 00 call 10a734 <rtems_fatal_error_occurred><== NOT EXECUTED
}
if (tty->device.lastClose)
1085c0: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax
1085c6: 85 c0 test %eax,%eax
1085c8: 74 0d je 1085d7 <rtems_termios_close+0xd0>
(*tty->device.lastClose)(tty->major, tty->minor, arg);
1085ca: 52 push %edx
1085cb: 56 push %esi
1085cc: ff 73 10 pushl 0x10(%ebx)
1085cf: ff 73 0c pushl 0xc(%ebx)
1085d2: ff d0 call *%eax
1085d4: 83 c4 10 add $0x10,%esp
if (tty->forw == NULL) {
1085d7: 8b 13 mov (%ebx),%edx
1085d9: 85 d2 test %edx,%edx
1085db: 8b 43 04 mov 0x4(%ebx),%eax
1085de: 75 11 jne 1085f1 <rtems_termios_close+0xea>
rtems_termios_ttyTail = tty->back;
1085e0: a3 40 52 12 00 mov %eax,0x125240
if ( rtems_termios_ttyTail != NULL ) {
1085e5: 85 c0 test %eax,%eax
1085e7: 74 0b je 1085f4 <rtems_termios_close+0xed>
rtems_termios_ttyTail->forw = NULL;
1085e9: c7 00 00 00 00 00 movl $0x0,(%eax)
1085ef: eb 03 jmp 1085f4 <rtems_termios_close+0xed>
}
} else {
tty->forw->back = tty->back;
1085f1: 89 42 04 mov %eax,0x4(%edx)
}
if (tty->back == NULL) {
1085f4: 8b 53 04 mov 0x4(%ebx),%edx
1085f7: 85 d2 test %edx,%edx
1085f9: 8b 03 mov (%ebx),%eax
1085fb: 75 12 jne 10860f <rtems_termios_close+0x108><== NEVER TAKEN
rtems_termios_ttyHead = tty->forw;
1085fd: a3 44 52 12 00 mov %eax,0x125244
if ( rtems_termios_ttyHead != NULL ) {
108602: 85 c0 test %eax,%eax
108604: 74 0b je 108611 <rtems_termios_close+0x10a>
rtems_termios_ttyHead->back = NULL;
108606: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
10860d: eb 02 jmp 108611 <rtems_termios_close+0x10a>
}
} else {
tty->back->forw = tty->forw;
10860f: 89 02 mov %eax,(%edx)
}
rtems_semaphore_delete (tty->isem);
108611: 83 ec 0c sub $0xc,%esp
108614: ff 73 14 pushl 0x14(%ebx)
108617: e8 bc 1a 00 00 call 10a0d8 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
10861c: 59 pop %ecx
10861d: ff 73 18 pushl 0x18(%ebx)
108620: e8 b3 1a 00 00 call 10a0d8 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
108625: 5a pop %edx
108626: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
10862c: e8 a7 1a 00 00 call 10a0d8 <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
108631: 83 c4 10 add $0x10,%esp
108634: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx)
10863b: 74 09 je 108646 <rtems_termios_close+0x13f>
10863d: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
108644: 75 0e jne 108654 <rtems_termios_close+0x14d>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
108646: 83 ec 0c sub $0xc,%esp
108649: ff 73 68 pushl 0x68(%ebx)
10864c: e8 87 1a 00 00 call 10a0d8 <rtems_semaphore_delete>
108651: 83 c4 10 add $0x10,%esp
free (tty->rawInBuf.theBuf);
108654: 83 ec 0c sub $0xc,%esp
108657: ff 73 58 pushl 0x58(%ebx)
10865a: e8 e9 ec ff ff call 107348 <free>
free (tty->rawOutBuf.theBuf);
10865f: 58 pop %eax
108660: ff 73 7c pushl 0x7c(%ebx)
108663: e8 e0 ec ff ff call 107348 <free>
free (tty->cbuf);
108668: 5e pop %esi
108669: ff 73 1c pushl 0x1c(%ebx)
10866c: e8 d7 ec ff ff call 107348 <free>
free (tty);
108671: 89 1c 24 mov %ebx,(%esp)
108674: e8 cf ec ff ff call 107348 <free>
108679: 83 c4 10 add $0x10,%esp
}
rtems_semaphore_release (rtems_termios_ttyMutex);
10867c: 83 ec 0c sub $0xc,%esp
10867f: ff 35 3c 52 12 00 pushl 0x12523c
108685: e8 ca 1b 00 00 call 10a254 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
10868a: 31 c0 xor %eax,%eax
10868c: 8d 65 f8 lea -0x8(%ebp),%esp
10868f: 5b pop %ebx
108690: 5e pop %esi
108691: c9 leave
108692: c3 ret
00109840 <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)
{
109840: 55 push %ebp
109841: 89 e5 mov %esp,%ebp
109843: 83 ec 08 sub $0x8,%esp
109846: 8b 45 08 mov 0x8(%ebp),%eax
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
109849: 8b 55 0c mov 0xc(%ebp),%edx
10984c: 01 90 90 00 00 00 add %edx,0x90(%eax)
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
109852: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax)
109859: 75 1f jne 10987a <rtems_termios_dequeue_characters+0x3a>
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
10985b: 52 push %edx
10985c: 52 push %edx
10985d: 6a 02 push $0x2
10985f: ff b0 c8 00 00 00 pushl 0xc8(%eax)
109865: e8 96 04 00 00 call 109d00 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
10986a: 83 c4 10 add $0x10,%esp
10986d: 85 c0 test %eax,%eax
10986f: 74 30 je 1098a1 <rtems_termios_dequeue_characters+0x61><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
109871: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109874: 50 push %eax <== NOT EXECUTED
109875: e8 ba 0e 00 00 call 10a734 <rtems_fatal_error_occurred><== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
10987a: 83 b8 cc 00 00 00 05 cmpl $0x5,0xcc(%eax)
109881: 75 15 jne 109898 <rtems_termios_dequeue_characters+0x58>
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
109883: 8b 15 a8 4f 12 00 mov 0x124fa8,%edx
109889: 85 d2 test %edx,%edx
10988b: 74 14 je 1098a1 <rtems_termios_dequeue_characters+0x61><== NEVER TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
10988d: 83 ec 0c sub $0xc,%esp
109890: 50 push %eax
109891: ff d2 call *%edx
109893: 83 c4 10 add $0x10,%esp
109896: eb 09 jmp 1098a1 <rtems_termios_dequeue_characters+0x61>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
109898: 89 45 08 mov %eax,0x8(%ebp)
}
10989b: c9 leave
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
10989c: e9 6d fd ff ff jmp 10960e <rtems_termios_refill_transmitter>
}
1098a1: 31 c0 xor %eax,%eax
1098a3: c9 leave
1098a4: c3 ret
0010931f <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)
{
10931f: 55 push %ebp
109320: 89 e5 mov %esp,%ebp
109322: 57 push %edi
109323: 56 push %esi
109324: 53 push %ebx
109325: 83 ec 2c sub $0x2c,%esp
109328: 8b 5d 08 mov 0x8(%ebp),%ebx
10932b: 8b 7d 0c mov 0xc(%ebp),%edi
10932e: 8b 4d 10 mov 0x10(%ebp),%ecx
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) {
109331: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
109337: c1 e0 05 shl $0x5,%eax
10933a: 89 ca mov %ecx,%edx
10933c: 83 b8 04 4f 12 00 00 cmpl $0x0,0x124f04(%eax)
109343: 75 3b jne 109380 <rtems_termios_enqueue_raw_characters+0x61>
109345: 89 4d e0 mov %ecx,-0x20(%ebp)
109348: c6 45 df 00 movb $0x0,-0x21(%ebp)
10934c: 31 f6 xor %esi,%esi
/*
* 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);
10934e: 8d 43 30 lea 0x30(%ebx),%eax
109351: 89 45 d4 mov %eax,-0x2c(%ebp)
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
109354: 8d 53 4a lea 0x4a(%ebx),%edx
109357: 89 55 d0 mov %edx,-0x30(%ebp)
10935a: e9 26 02 00 00 jmp 109585 <rtems_termios_enqueue_raw_characters+0x266>
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++;
10935f: 0f be 0f movsbl (%edi),%ecx
109362: 47 inc %edi
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
109363: 56 push %esi
109364: 56 push %esi
109365: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
10936b: c1 e0 05 shl $0x5,%eax
10936e: 53 push %ebx
10936f: 51 push %ecx
109370: 89 55 cc mov %edx,-0x34(%ebp)
109373: ff 90 04 4f 12 00 call *0x124f04(%eax)
109379: 8b 55 cc mov -0x34(%ebp),%edx
10937c: 4a dec %edx
10937d: 83 c4 10 add $0x10,%esp
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--) {
109380: 85 d2 test %edx,%edx
109382: 75 db jne 10935f <rtems_termios_enqueue_raw_characters+0x40>
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
109384: 31 f6 xor %esi,%esi
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
109386: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx)
10938d: 0f 85 0d 02 00 00 jne 1095a0 <rtems_termios_enqueue_raw_characters+0x281><== NEVER TAKEN
109393: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
109399: 89 d6 mov %edx,%esi
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
10939b: 85 c0 test %eax,%eax
10939d: 0f 84 fd 01 00 00 je 1095a0 <rtems_termios_enqueue_raw_characters+0x281><== NEVER TAKEN
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
1093a3: 51 push %ecx
1093a4: 51 push %ecx
1093a5: ff b3 e0 00 00 00 pushl 0xe0(%ebx)
1093ab: 8d 53 30 lea 0x30(%ebx),%edx
1093ae: 52 push %edx
1093af: ff d0 call *%eax
tty->tty_rcvwakeup = 1;
1093b1: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx)
1093b8: 00 00 00
1093bb: e9 dd 01 00 00 jmp 10959d <rtems_termios_enqueue_raw_characters+0x27e>
}
return 0;
}
while (len--) {
c = *buf++;
1093c0: 8a 0f mov (%edi),%cl
1093c2: 88 4d de mov %cl,-0x22(%ebp)
1093c5: 47 inc %edi
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
1093c6: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1093cc: f6 c4 02 test $0x2,%ah
1093cf: 74 46 je 109417 <rtems_termios_enqueue_raw_characters+0xf8>
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
1093d1: 0f be c1 movsbl %cl,%eax
1093d4: 0f b6 53 4a movzbl 0x4a(%ebx),%edx
1093d8: 39 d0 cmp %edx,%eax
1093da: 75 28 jne 109404 <rtems_termios_enqueue_raw_characters+0xe5>
if (c == tty->termios.c_cc[VSTART]) {
1093dc: 0f b6 53 49 movzbl 0x49(%ebx),%edx
1093e0: 39 d0 cmp %edx,%eax
1093e2: 75 0b jne 1093ef <rtems_termios_enqueue_raw_characters+0xd0><== ALWAYS TAKEN
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
1093e4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1093ea: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED
1093ed: eb 09 jmp 1093f8 <rtems_termios_enqueue_raw_characters+0xd9><== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
1093ef: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1093f5: 83 c8 10 or $0x10,%eax
1093f8: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
* 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)
{
1093fe: c6 45 df 01 movb $0x1,-0x21(%ebp)
109402: eb 19 jmp 10941d <rtems_termios_enqueue_raw_characters+0xfe>
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
109404: 0f b6 53 49 movzbl 0x49(%ebx),%edx
109408: 39 d0 cmp %edx,%eax
10940a: 75 0b jne 109417 <rtems_termios_enqueue_raw_characters+0xf8><== ALWAYS TAKEN
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
10940c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109412: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED
109415: eb e1 jmp 1093f8 <rtems_termios_enqueue_raw_characters+0xd9><== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
109417: 80 7d df 00 cmpb $0x0,-0x21(%ebp)
10941b: 74 51 je 10946e <rtems_termios_enqueue_raw_characters+0x14f><== ALWAYS TAKEN
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
10941d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109423: 83 e0 30 and $0x30,%eax
109426: 83 f8 20 cmp $0x20,%eax
109429: 0f 85 53 01 00 00 jne 109582 <rtems_termios_enqueue_raw_characters+0x263><== ALWAYS TAKEN
/* disable interrupts */
rtems_interrupt_disable(level);
10942f: 9c pushf <== NOT EXECUTED
109430: fa cli <== NOT EXECUTED
109431: 8f 45 e4 popl -0x1c(%ebp) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
109434: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10943a: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
10943d: 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) {
109443: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
10944a: 74 19 je 109465 <rtems_termios_enqueue_raw_characters+0x146><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
10944c: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
109452: 52 push %edx <== NOT EXECUTED
109453: 6a 01 push $0x1 <== NOT EXECUTED
109455: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED
109458: 50 push %eax <== NOT EXECUTED
109459: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
10945c: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
109462: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
109465: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED
109468: 9d popf <== NOT EXECUTED
109469: e9 14 01 00 00 jmp 109582 <rtems_termios_enqueue_raw_characters+0x263><== NOT EXECUTED
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
10946e: 8b 43 60 mov 0x60(%ebx),%eax
109471: 8b 4b 64 mov 0x64(%ebx),%ecx
109474: 40 inc %eax
109475: 31 d2 xor %edx,%edx
109477: f7 f1 div %ecx
109479: 89 55 e4 mov %edx,-0x1c(%ebp)
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
10947c: 9c pushf
10947d: fa cli
10947e: 8f 45 d8 popl -0x28(%ebp)
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
109481: 8b 53 5c mov 0x5c(%ebx),%edx
109484: 8b 43 64 mov 0x64(%ebx),%eax
% tty->rawInBuf.Size) > tty->highwater) &&
109487: 8b 4b 64 mov 0x64(%ebx),%ecx
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
10948a: 29 d0 sub %edx,%eax
10948c: 03 45 e4 add -0x1c(%ebp),%eax
% tty->rawInBuf.Size) > tty->highwater) &&
10948f: 31 d2 xor %edx,%edx
109491: f7 f1 div %ecx
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
109493: 3b 93 c0 00 00 00 cmp 0xc0(%ebx),%edx
109499: 0f 86 98 00 00 00 jbe 109537 <rtems_termios_enqueue_raw_characters+0x218><== ALWAYS TAKEN
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
10949f: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
% tty->rawInBuf.Size) > tty->highwater) &&
1094a5: a8 01 test $0x1,%al <== NOT EXECUTED
1094a7: 0f 85 8a 00 00 00 jne 109537 <rtems_termios_enqueue_raw_characters+0x218><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
1094ad: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1094b3: 83 c8 01 or $0x1,%eax <== NOT EXECUTED
1094b6: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
1094bc: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1094c2: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED
1094c7: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED
1094cc: 75 33 jne 109501 <rtems_termios_enqueue_raw_characters+0x1e2><== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
1094ce: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1094d4: a8 20 test $0x20,%al <== NOT EXECUTED
1094d6: 75 09 jne 1094e1 <rtems_termios_enqueue_raw_characters+0x1c2><== NOT EXECUTED
1094d8: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
1094df: 75 56 jne 109537 <rtems_termios_enqueue_raw_characters+0x218><== 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;
1094e1: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1094e7: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
1094ea: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
(*tty->device.write)(tty->minor,
1094f0: 51 push %ecx <== NOT EXECUTED
1094f1: 6a 01 push $0x1 <== NOT EXECUTED
1094f3: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED
1094f6: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
1094f9: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
1094ff: eb 33 jmp 109534 <rtems_termios_enqueue_raw_characters+0x215><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
109501: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109507: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED
10950c: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED
109511: 75 24 jne 109537 <rtems_termios_enqueue_raw_characters+0x218><== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
109513: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109519: 83 c8 04 or $0x4,%eax <== NOT EXECUTED
10951c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
109522: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax <== NOT EXECUTED
109528: 85 c0 test %eax,%eax <== NOT EXECUTED
10952a: 74 0b je 109537 <rtems_termios_enqueue_raw_characters+0x218><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
10952c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10952f: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109532: ff d0 call *%eax <== NOT EXECUTED
109534: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
109537: ff 75 d8 pushl -0x28(%ebp)
10953a: 9d popf
if (newTail == tty->rawInBuf.Head) {
10953b: 8b 43 5c mov 0x5c(%ebx),%eax
10953e: 39 45 e4 cmp %eax,-0x1c(%ebp)
109541: 75 03 jne 109546 <rtems_termios_enqueue_raw_characters+0x227><== ALWAYS TAKEN
dropped++;
109543: 46 inc %esi <== NOT EXECUTED
109544: eb 3c jmp 109582 <rtems_termios_enqueue_raw_characters+0x263><== NOT EXECUTED
} else {
tty->rawInBuf.theBuf[newTail] = c;
109546: 8b 43 58 mov 0x58(%ebx),%eax
109549: 8a 4d de mov -0x22(%ebp),%cl
10954c: 8b 55 e4 mov -0x1c(%ebp),%edx
10954f: 88 0c 10 mov %cl,(%eax,%edx,1)
tty->rawInBuf.Tail = newTail;
109552: 89 53 60 mov %edx,0x60(%ebx)
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
109555: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx)
10955c: 75 24 jne 109582 <rtems_termios_enqueue_raw_characters+0x263><== NEVER TAKEN
10955e: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax
109564: 85 c0 test %eax,%eax
109566: 74 1a je 109582 <rtems_termios_enqueue_raw_characters+0x263><== ALWAYS TAKEN
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
109568: 52 push %edx <== NOT EXECUTED
109569: 52 push %edx <== NOT EXECUTED
10956a: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED
109570: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED
109573: ff d0 call *%eax <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
109575: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED
10957c: 00 00 00
10957f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
109582: ff 4d e0 decl -0x20(%ebp)
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
109585: 83 7d e0 00 cmpl $0x0,-0x20(%ebp)
109589: 0f 85 31 fe ff ff jne 1093c0 <rtems_termios_enqueue_raw_characters+0xa1>
}
}
}
}
tty->rawInBufDropped += dropped;
10958f: 01 73 78 add %esi,0x78(%ebx)
rtems_semaphore_release (tty->rawInBuf.Semaphore);
109592: 83 ec 0c sub $0xc,%esp
109595: ff 73 68 pushl 0x68(%ebx)
109598: e8 b7 0c 00 00 call 10a254 <rtems_semaphore_release>
return dropped;
10959d: 83 c4 10 add $0x10,%esp
}
1095a0: 89 f0 mov %esi,%eax
1095a2: 8d 65 f4 lea -0xc(%ebp),%esp
1095a5: 5b pop %ebx
1095a6: 5e pop %esi
1095a7: 5f pop %edi
1095a8: c9 leave
1095a9: c3 ret
001086b2 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
1086b2: 55 push %ebp
1086b3: 89 e5 mov %esp,%ebp
1086b5: 57 push %edi
1086b6: 56 push %esi
1086b7: 53 push %ebx
1086b8: 83 ec 20 sub $0x20,%esp
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
1086bb: 8b 55 08 mov 0x8(%ebp),%edx
1086be: 8b 02 mov (%edx),%eax
1086c0: 8b 58 34 mov 0x34(%eax),%ebx
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
1086c3: 8b 72 08 mov 0x8(%edx),%esi
rtems_status_code sc;
args->ioctl_return = 0;
1086c6: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx)
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
1086cd: 6a 00 push $0x0
1086cf: 6a 00 push $0x0
1086d1: ff 73 18 pushl 0x18(%ebx)
1086d4: e8 8f 1a 00 00 call 10a168 <rtems_semaphore_obtain>
1086d9: 89 45 e4 mov %eax,-0x1c(%ebp)
if (sc != RTEMS_SUCCESSFUL) {
1086dc: 83 c4 10 add $0x10,%esp
1086df: 85 c0 test %eax,%eax
1086e1: 74 0b je 1086ee <rtems_termios_ioctl+0x3c><== ALWAYS TAKEN
args->ioctl_return = sc;
1086e3: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
1086e6: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED
return sc;
1086e9: e9 05 03 00 00 jmp 1089f3 <rtems_termios_ioctl+0x341><== NOT EXECUTED
}
switch (args->command) {
1086ee: 8b 55 08 mov 0x8(%ebp),%edx
1086f1: 8b 42 04 mov 0x4(%edx),%eax
1086f4: 83 f8 04 cmp $0x4,%eax
1086f7: 0f 84 4d 02 00 00 je 10894a <rtems_termios_ioctl+0x298>
1086fd: 77 10 ja 10870f <rtems_termios_ioctl+0x5d>
1086ff: 83 f8 02 cmp $0x2,%eax
108702: 74 77 je 10877b <rtems_termios_ioctl+0xc9>
108704: 0f 87 1e 02 00 00 ja 108928 <rtems_termios_ioctl+0x276>
10870a: 48 dec %eax
10870b: 75 2f jne 10873c <rtems_termios_ioctl+0x8a><== NEVER TAKEN
10870d: eb 55 jmp 108764 <rtems_termios_ioctl+0xb2>
10870f: 3d 7f 66 04 40 cmp $0x4004667f,%eax
108714: 0f 84 a5 02 00 00 je 1089bf <rtems_termios_ioctl+0x30d><== NEVER TAKEN
10871a: 77 0a ja 108726 <rtems_termios_ioctl+0x74>
10871c: 83 f8 05 cmp $0x5,%eax
10871f: 75 1b jne 10873c <rtems_termios_ioctl+0x8a>
108721: e9 0e 02 00 00 jmp 108934 <rtems_termios_ioctl+0x282>
108726: 3d 1a 74 04 40 cmp $0x4004741a,%eax
10872b: 0f 84 7e 02 00 00 je 1089af <rtems_termios_ioctl+0x2fd>
108731: 3d 1b 74 04 80 cmp $0x8004741b,%eax
108736: 0f 84 21 02 00 00 je 10895d <rtems_termios_ioctl+0x2ab><== ALWAYS TAKEN
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
10873c: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
108742: c1 e0 05 shl $0x5,%eax
108745: 8b 80 0c 4f 12 00 mov 0x124f0c(%eax),%eax
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
}
else {
sc = RTEMS_INVALID_NUMBER;
10874b: c7 45 e4 0a 00 00 00 movl $0xa,-0x1c(%ebp)
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
108752: 85 c0 test %eax,%eax
108754: 0f 84 82 02 00 00 je 1089dc <rtems_termios_ioctl+0x32a><== NEVER TAKEN
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
10875a: 52 push %edx
10875b: 52 push %edx
10875c: ff 75 08 pushl 0x8(%ebp)
10875f: e9 40 02 00 00 jmp 1089a4 <rtems_termios_ioctl+0x2f2>
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
108764: 8b 4d 08 mov 0x8(%ebp),%ecx
108767: 8b 41 08 mov 0x8(%ecx),%eax
10876a: 8d 73 30 lea 0x30(%ebx),%esi
10876d: b9 09 00 00 00 mov $0x9,%ecx
108772: 89 c7 mov %eax,%edi
108774: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
break;
108776: e9 61 02 00 00 jmp 1089dc <rtems_termios_ioctl+0x32a>
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
10877b: 8b 45 08 mov 0x8(%ebp),%eax
10877e: 8b 70 08 mov 0x8(%eax),%esi
108781: 8d 7b 30 lea 0x30(%ebx),%edi
108784: b9 09 00 00 00 mov $0x9,%ecx
108789: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
10878b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
108791: f6 c4 02 test $0x2,%ah
108794: 74 57 je 1087ed <rtems_termios_ioctl+0x13b>
108796: f6 43 31 04 testb $0x4,0x31(%ebx)
10879a: 75 51 jne 1087ed <rtems_termios_ioctl+0x13b>
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
10879c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1087a2: 25 ef fd ff ff and $0xfffffdef,%eax
1087a7: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
1087ad: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1087b3: a8 20 test $0x20,%al
1087b5: 74 36 je 1087ed <rtems_termios_ioctl+0x13b><== ALWAYS TAKEN
/* disable interrupts */
rtems_interrupt_disable(level);
1087b7: 9c pushf <== NOT EXECUTED
1087b8: fa cli <== NOT EXECUTED
1087b9: 5e pop %esi <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
1087ba: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1087c0: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED
1087c3: 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) {
1087c9: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
1087d0: 74 19 je 1087eb <rtems_termios_ioctl+0x139><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
1087d2: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
1087d8: 57 push %edi <== NOT EXECUTED
1087d9: 6a 01 push $0x1 <== NOT EXECUTED
1087db: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED
1087de: 50 push %eax <== NOT EXECUTED
1087df: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
1087e2: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
1087e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
1087eb: 56 push %esi <== NOT EXECUTED
1087ec: 9d popf <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
1087ed: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1087f3: f6 c4 04 test $0x4,%ah
1087f6: 74 24 je 10881c <rtems_termios_ioctl+0x16a>
1087f8: f6 43 31 10 testb $0x10,0x31(%ebx)
1087fc: 75 1e jne 10881c <rtems_termios_ioctl+0x16a><== NEVER TAKEN
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
1087fe: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
108804: 80 e4 fb and $0xfb,%ah
108807: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
10880d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
108813: 83 e0 fd and $0xfffffffd,%eax
108816: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
10881c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
108822: f6 c4 01 test $0x1,%ah
108825: 74 43 je 10886a <rtems_termios_ioctl+0x1b8><== ALWAYS TAKEN
108827: 83 7b 38 00 cmpl $0x0,0x38(%ebx) <== NOT EXECUTED
10882b: 78 3d js 10886a <rtems_termios_ioctl+0x1b8><== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
10882d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108833: 80 e4 fe and $0xfe,%ah <== NOT EXECUTED
108836: 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) && (tty->device.startRemoteTx != NULL)) {
10883c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108842: a8 04 test $0x4,%al <== NOT EXECUTED
108844: 74 15 je 10885b <rtems_termios_ioctl+0x1a9><== NOT EXECUTED
108846: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED
10884c: 85 c0 test %eax,%eax <== NOT EXECUTED
10884e: 74 0b je 10885b <rtems_termios_ioctl+0x1a9><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
108850: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108853: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
108856: ff d0 call *%eax <== NOT EXECUTED
108858: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
10885b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108861: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED
108864: 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) {
10886a: 83 7b 38 00 cmpl $0x0,0x38(%ebx)
10886e: 79 0f jns 10887f <rtems_termios_ioctl+0x1cd><== ALWAYS TAKEN
tty->flow_ctrl |= FL_MDRTS;
108870: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108876: 80 cc 01 or $0x1,%ah <== NOT EXECUTED
108879: 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) {
10887f: 8b 53 30 mov 0x30(%ebx),%edx
108882: f6 c6 10 test $0x10,%dh
108885: 74 0f je 108896 <rtems_termios_ioctl+0x1e4>
tty->flow_ctrl |= FL_MDXOF;
108887: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10888d: 80 cc 04 or $0x4,%ah
108890: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
108896: 80 e6 04 and $0x4,%dh
108899: 74 0f je 1088aa <rtems_termios_ioctl+0x1f8>
tty->flow_ctrl |= FL_MDXON;
10889b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1088a1: 80 cc 02 or $0x2,%ah
1088a4: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
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) {
1088aa: f6 43 3c 02 testb $0x2,0x3c(%ebx)
1088ae: 75 39 jne 1088e9 <rtems_termios_ioctl+0x237>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
1088b0: 0f b6 73 46 movzbl 0x46(%ebx),%esi
rtems_clock_get_ticks_per_second() / 10;
1088b4: e8 6f 12 00 00 call 109b28 <rtems_clock_get_ticks_per_second>
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
1088b9: 0f af c6 imul %esi,%eax
rtems_clock_get_ticks_per_second() / 10;
1088bc: b9 0a 00 00 00 mov $0xa,%ecx
1088c1: 31 d2 xor %edx,%edx
1088c3: f7 f1 div %ecx
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
1088c5: 89 43 54 mov %eax,0x54(%ebx)
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
1088c8: 80 7b 46 00 cmpb $0x0,0x46(%ebx)
1088cc: 74 15 je 1088e3 <rtems_termios_ioctl+0x231>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
1088ce: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
1088d5: 89 43 70 mov %eax,0x70(%ebx)
if (tty->termios.c_cc[VMIN])
1088d8: 80 7b 47 00 cmpb $0x0,0x47(%ebx)
1088dc: 75 19 jne 1088f7 <rtems_termios_ioctl+0x245>
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
1088de: 89 43 74 mov %eax,0x74(%ebx)
1088e1: eb 24 jmp 108907 <rtems_termios_ioctl+0x255>
} else {
if (tty->termios.c_cc[VMIN]) {
1088e3: 80 7b 47 00 cmpb $0x0,0x47(%ebx)
1088e7: 74 17 je 108900 <rtems_termios_ioctl+0x24e><== ALWAYS TAKEN
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
1088e9: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
1088f0: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx)
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
1088f7: c7 43 74 00 00 00 00 movl $0x0,0x74(%ebx)
1088fe: eb 07 jmp 108907 <rtems_termios_ioctl+0x255>
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
108900: c7 43 6c 01 00 00 00 movl $0x1,0x6c(%ebx)
}
}
}
if (tty->device.setAttributes)
108907: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax
10890d: 85 c0 test %eax,%eax
10890f: 0f 84 c7 00 00 00 je 1089dc <rtems_termios_ioctl+0x32a><== NEVER TAKEN
(*tty->device.setAttributes)(tty->minor, &tty->termios);
108915: 56 push %esi
108916: 56 push %esi
108917: 8d 53 30 lea 0x30(%ebx),%edx
10891a: 52 push %edx
10891b: ff 73 10 pushl 0x10(%ebx)
10891e: ff d0 call *%eax
108920: 83 c4 10 add $0x10,%esp
108923: e9 b4 00 00 00 jmp 1089dc <rtems_termios_ioctl+0x32a>
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
108928: 89 d8 mov %ebx,%eax
10892a: e8 55 f7 ff ff call 108084 <drainOutput>
break;
10892f: e9 a8 00 00 00 jmp 1089dc <rtems_termios_ioctl+0x32a>
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
108934: 8b 06 mov (%esi),%eax
108936: 8b 56 04 mov 0x4(%esi),%edx
108939: 89 83 d4 00 00 00 mov %eax,0xd4(%ebx)
10893f: 89 93 d8 00 00 00 mov %edx,0xd8(%ebx)
break;
108945: e9 92 00 00 00 jmp 1089dc <rtems_termios_ioctl+0x32a>
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
10894a: 8b 06 mov (%esi),%eax
10894c: 8b 56 04 mov 0x4(%esi),%edx
10894f: 89 83 dc 00 00 00 mov %eax,0xdc(%ebx)
108955: 89 93 e0 00 00 00 mov %edx,0xe0(%ebx)
break;
10895b: eb 7f jmp 1089dc <rtems_termios_ioctl+0x32a>
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
10895d: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
108963: c1 e0 05 shl $0x5,%eax
108966: 8b 80 f8 4e 12 00 mov 0x124ef8(%eax),%eax
10896c: 85 c0 test %eax,%eax
10896e: 74 0c je 10897c <rtems_termios_ioctl+0x2ca>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
108970: 83 ec 0c sub $0xc,%esp
108973: 53 push %ebx
108974: ff d0 call *%eax
108976: 89 45 e4 mov %eax,-0x1c(%ebp)
108979: 83 c4 10 add $0x10,%esp
}
tty->t_line=*(int*)(args->buffer);
10897c: 8b 55 08 mov 0x8(%ebp),%edx
10897f: 8b 42 08 mov 0x8(%edx),%eax
108982: 8b 00 mov (%eax),%eax
108984: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx)
tty->t_sc = NULL; /* ensure that no more valid data */
10898a: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx)
108991: 00 00 00
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
108994: c1 e0 05 shl $0x5,%eax
108997: 8b 80 f4 4e 12 00 mov 0x124ef4(%eax),%eax
10899d: 85 c0 test %eax,%eax
10899f: 74 3b je 1089dc <rtems_termios_ioctl+0x32a><== NEVER TAKEN
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
1089a1: 83 ec 0c sub $0xc,%esp
1089a4: 53 push %ebx
1089a5: ff d0 call *%eax
1089a7: 89 45 e4 mov %eax,-0x1c(%ebp)
1089aa: e9 71 ff ff ff jmp 108920 <rtems_termios_ioctl+0x26e>
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
1089af: 8b 4d 08 mov 0x8(%ebp),%ecx
1089b2: 8b 41 08 mov 0x8(%ecx),%eax
1089b5: 8b 93 cc 00 00 00 mov 0xcc(%ebx),%edx
1089bb: 89 10 mov %edx,(%eax)
break;
1089bd: eb 1d jmp 1089dc <rtems_termios_ioctl+0x32a>
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
1089bf: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED
1089c2: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED
if ( rawnc < 0 )
1089c5: 29 d0 sub %edx,%eax <== NOT EXECUTED
1089c7: 79 05 jns 1089ce <rtems_termios_ioctl+0x31c><== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
1089c9: 8b 53 64 mov 0x64(%ebx),%edx <== NOT EXECUTED
1089cc: 01 d0 add %edx,%eax <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
1089ce: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED
1089d1: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED
1089d4: 03 43 20 add 0x20(%ebx),%eax <== NOT EXECUTED
1089d7: 2b 43 24 sub 0x24(%ebx),%eax <== NOT EXECUTED
1089da: 89 02 mov %eax,(%edx) <== NOT EXECUTED
}
break;
}
rtems_semaphore_release (tty->osem);
1089dc: 83 ec 0c sub $0xc,%esp
1089df: ff 73 18 pushl 0x18(%ebx)
1089e2: e8 6d 18 00 00 call 10a254 <rtems_semaphore_release>
args->ioctl_return = sc;
1089e7: 8b 55 e4 mov -0x1c(%ebp),%edx
1089ea: 8b 45 08 mov 0x8(%ebp),%eax
1089ed: 89 50 0c mov %edx,0xc(%eax)
return sc;
1089f0: 83 c4 10 add $0x10,%esp
}
1089f3: 8b 45 e4 mov -0x1c(%ebp),%eax
1089f6: 8d 65 f4 lea -0xc(%ebp),%esp
1089f9: 5b pop %ebx
1089fa: 5e pop %esi
1089fb: 5f pop %edi
1089fc: c9 leave
1089fd: c3 ret
001080e1 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
1080e1: 55 push %ebp
1080e2: 89 e5 mov %esp,%ebp
1080e4: 57 push %edi
1080e5: 56 push %esi
1080e6: 53 push %ebx
1080e7: 83 ec 20 sub $0x20,%esp
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
1080ea: 6a 00 push $0x0
1080ec: 6a 00 push $0x0
1080ee: ff 35 3c 52 12 00 pushl 0x12523c
1080f4: e8 6f 20 00 00 call 10a168 <rtems_semaphore_obtain>
1080f9: 89 45 e4 mov %eax,-0x1c(%ebp)
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
1080fc: 83 c4 10 add $0x10,%esp
1080ff: 85 c0 test %eax,%eax
108101: 0f 85 d3 03 00 00 jne 1084da <rtems_termios_open+0x3f9><== NEVER TAKEN
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
108107: 8b 35 44 52 12 00 mov 0x125244,%esi
10810d: 89 f2 mov %esi,%edx
10810f: eb 16 jmp 108127 <rtems_termios_open+0x46>
if ((tty->major == major) && (tty->minor == minor))
108111: 8b 45 08 mov 0x8(%ebp),%eax
108114: 39 42 0c cmp %eax,0xc(%edx)
108117: 75 0c jne 108125 <rtems_termios_open+0x44>
108119: 8b 4d 0c mov 0xc(%ebp),%ecx
10811c: 39 4a 10 cmp %ecx,0x10(%edx)
10811f: 0f 84 26 03 00 00 je 10844b <rtems_termios_open+0x36a><== 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) {
108125: 8b 12 mov (%edx),%edx
108127: 85 d2 test %edx,%edx
108129: 75 e6 jne 108111 <rtems_termios_open+0x30>
10812b: e9 b5 03 00 00 jmp 1084e5 <rtems_termios_open+0x404>
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
if (tty == NULL) {
rtems_semaphore_release (rtems_termios_ttyMutex);
108130: 83 ec 0c sub $0xc,%esp
108133: eb 30 jmp 108165 <rtems_termios_open+0x84>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
108135: a1 74 30 12 00 mov 0x123074,%eax
10813a: 89 42 64 mov %eax,0x64(%edx)
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
10813d: 8b 42 64 mov 0x64(%edx),%eax
108140: 83 ec 0c sub $0xc,%esp
108143: 50 push %eax
108144: 89 55 e0 mov %edx,-0x20(%ebp)
108147: e8 98 f4 ff ff call 1075e4 <malloc>
10814c: 89 c7 mov %eax,%edi
10814e: 8b 55 e0 mov -0x20(%ebp),%edx
108151: 89 42 58 mov %eax,0x58(%edx)
if (tty->rawInBuf.theBuf == NULL) {
108154: 83 c4 10 add $0x10,%esp
108157: 85 c0 test %eax,%eax
108159: 75 24 jne 10817f <rtems_termios_open+0x9e>
free(tty);
10815b: 83 ec 0c sub $0xc,%esp
10815e: 52 push %edx
10815f: e8 e4 f1 ff ff call 107348 <free>
rtems_semaphore_release (rtems_termios_ttyMutex);
108164: 5b pop %ebx
108165: ff 35 3c 52 12 00 pushl 0x12523c
10816b: e8 e4 20 00 00 call 10a254 <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
108170: 83 c4 10 add $0x10,%esp
108173: c7 45 e4 1a 00 00 00 movl $0x1a,-0x1c(%ebp)
10817a: e9 5b 03 00 00 jmp 1084da <rtems_termios_open+0x3f9>
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
10817f: a1 78 30 12 00 mov 0x123078,%eax
108184: 89 82 88 00 00 00 mov %eax,0x88(%edx)
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
10818a: 8b 82 88 00 00 00 mov 0x88(%edx),%eax
108190: 83 ec 0c sub $0xc,%esp
108193: 50 push %eax
108194: 89 55 e0 mov %edx,-0x20(%ebp)
108197: e8 48 f4 ff ff call 1075e4 <malloc>
10819c: 8b 55 e0 mov -0x20(%ebp),%edx
10819f: 89 42 7c mov %eax,0x7c(%edx)
if (tty->rawOutBuf.theBuf == NULL) {
1081a2: 83 c4 10 add $0x10,%esp
1081a5: 85 c0 test %eax,%eax
1081a7: 75 05 jne 1081ae <rtems_termios_open+0xcd><== ALWAYS TAKEN
free((void *)(tty->rawInBuf.theBuf));
1081a9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1081ac: eb 2e jmp 1081dc <rtems_termios_open+0xfb><== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
1081ae: 83 ec 0c sub $0xc,%esp
1081b1: ff 35 70 30 12 00 pushl 0x123070
1081b7: 89 55 e0 mov %edx,-0x20(%ebp)
1081ba: 89 45 dc mov %eax,-0x24(%ebp)
1081bd: e8 22 f4 ff ff call 1075e4 <malloc>
1081c2: 8b 55 e0 mov -0x20(%ebp),%edx
1081c5: 89 42 1c mov %eax,0x1c(%edx)
if (tty->cbuf == NULL) {
1081c8: 83 c4 10 add $0x10,%esp
1081cb: 85 c0 test %eax,%eax
1081cd: 8b 4d dc mov -0x24(%ebp),%ecx
1081d0: 75 19 jne 1081eb <rtems_termios_open+0x10a>
free((void *)(tty->rawOutBuf.theBuf));
1081d2: 83 ec 0c sub $0xc,%esp
1081d5: 51 push %ecx
1081d6: e8 6d f1 ff ff call 107348 <free>
free((void *)(tty->rawInBuf.theBuf));
1081db: 59 pop %ecx
1081dc: 57 push %edi
1081dd: e8 66 f1 ff ff call 107348 <free>
free(tty);
1081e2: 5a pop %edx
1081e3: 8b 55 e0 mov -0x20(%ebp),%edx
1081e6: e9 73 ff ff ff jmp 10815e <rtems_termios_open+0x7d>
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
1081eb: c7 82 d4 00 00 00 00 movl $0x0,0xd4(%edx)
1081f2: 00 00 00
tty->tty_snd.sw_arg = NULL;
1081f5: c7 82 d8 00 00 00 00 movl $0x0,0xd8(%edx)
1081fc: 00 00 00
tty->tty_rcv.sw_pfn = NULL;
1081ff: c7 82 dc 00 00 00 00 movl $0x0,0xdc(%edx)
108206: 00 00 00
tty->tty_rcv.sw_arg = NULL;
108209: c7 82 e0 00 00 00 00 movl $0x0,0xe0(%edx)
108210: 00 00 00
tty->tty_rcvwakeup = 0;
108213: c7 82 e4 00 00 00 00 movl $0x0,0xe4(%edx)
10821a: 00 00 00
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
10821d: 89 32 mov %esi,(%edx)
tty->back = NULL;
10821f: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx)
if (rtems_termios_ttyHead != NULL)
108226: 85 f6 test %esi,%esi
108228: 74 03 je 10822d <rtems_termios_open+0x14c>
rtems_termios_ttyHead->back = tty;
10822a: 89 56 04 mov %edx,0x4(%esi)
rtems_termios_ttyHead = tty;
10822d: 89 1d 44 52 12 00 mov %ebx,0x125244
if (rtems_termios_ttyTail == NULL)
108233: 83 3d 40 52 12 00 00 cmpl $0x0,0x125240
10823a: 75 06 jne 108242 <rtems_termios_open+0x161>
rtems_termios_ttyTail = tty;
10823c: 89 1d 40 52 12 00 mov %ebx,0x125240
tty->minor = minor;
108242: 8b 45 0c mov 0xc(%ebp),%eax
108245: 89 43 10 mov %eax,0x10(%ebx)
tty->major = major;
108248: 8b 4d 08 mov 0x8(%ebp),%ecx
10824b: 89 4b 0c mov %ecx,0xc(%ebx)
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
10824e: 83 ec 0c sub $0xc,%esp
108251: 8d 43 14 lea 0x14(%ebx),%eax
108254: 50 push %eax
108255: 6a 00 push $0x0
108257: 6a 54 push $0x54
108259: 6a 01 push $0x1
rtems_build_name ('T', 'R', 'i', c),
10825b: 0f be 05 7c 30 12 00 movsbl 0x12307c,%eax
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
108262: 0d 00 69 52 54 or $0x54526900,%eax
108267: 50 push %eax
108268: 89 55 e0 mov %edx,-0x20(%ebp)
10826b: e8 d0 1c 00 00 call 109f40 <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)
108270: 83 c4 20 add $0x20,%esp
108273: 85 c0 test %eax,%eax
108275: 8b 55 e0 mov -0x20(%ebp),%edx
108278: 0f 85 42 02 00 00 jne 1084c0 <rtems_termios_open+0x3df>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
10827e: 83 ec 0c sub $0xc,%esp
108281: 8d 43 18 lea 0x18(%ebx),%eax
108284: 50 push %eax
108285: 6a 00 push $0x0
108287: 6a 54 push $0x54
108289: 6a 01 push $0x1
rtems_build_name ('T', 'R', 'o', c),
10828b: 0f be 05 7c 30 12 00 movsbl 0x12307c,%eax
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
108292: 0d 00 6f 52 54 or $0x54526f00,%eax
108297: 50 push %eax
108298: 89 55 e0 mov %edx,-0x20(%ebp)
10829b: e8 a0 1c 00 00 call 109f40 <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)
1082a0: 83 c4 20 add $0x20,%esp
1082a3: 85 c0 test %eax,%eax
1082a5: 8b 55 e0 mov -0x20(%ebp),%edx
1082a8: 0f 85 12 02 00 00 jne 1084c0 <rtems_termios_open+0x3df>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
1082ae: 83 ec 0c sub $0xc,%esp
1082b1: 8d 83 8c 00 00 00 lea 0x8c(%ebx),%eax
1082b7: 50 push %eax
1082b8: 6a 00 push $0x0
1082ba: 6a 20 push $0x20
1082bc: 6a 00 push $0x0
rtems_build_name ('T', 'R', 'x', c),
1082be: 0f be 05 7c 30 12 00 movsbl 0x12307c,%eax
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
1082c5: 0d 00 78 52 54 or $0x54527800,%eax
1082ca: 50 push %eax
1082cb: 89 55 e0 mov %edx,-0x20(%ebp)
1082ce: e8 6d 1c 00 00 call 109f40 <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)
1082d3: 83 c4 20 add $0x20,%esp
1082d6: 85 c0 test %eax,%eax
1082d8: 8b 55 e0 mov -0x20(%ebp),%edx
1082db: 0f 85 df 01 00 00 jne 1084c0 <rtems_termios_open+0x3df>
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
1082e1: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx)
1082e8: 00 00 00
/*
* Set callbacks
*/
tty->device = *callbacks;
1082eb: 8d bb 98 00 00 00 lea 0x98(%ebx),%edi
1082f1: b9 08 00 00 00 mov $0x8,%ecx
1082f6: 8b 75 14 mov 0x14(%ebp),%esi
1082f9: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
1082fb: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
108302: 75 74 jne 108378 <rtems_termios_open+0x297>
sc = rtems_task_create (
108304: 50 push %eax
108305: 50 push %eax
108306: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax
10830c: 50 push %eax
10830d: 6a 00 push $0x0
10830f: 68 00 05 00 00 push $0x500
108314: 68 00 04 00 00 push $0x400
108319: 6a 0a push $0xa
rtems_build_name ('T', 'x', 'T', c),
10831b: 0f be 05 7c 30 12 00 movsbl 0x12307c,%eax
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
108322: 0d 00 54 78 54 or $0x54785400,%eax
108327: 50 push %eax
108328: 89 55 e0 mov %edx,-0x20(%ebp)
10832b: e8 b4 1f 00 00 call 10a2e4 <rtems_task_create>
TERMIOS_TXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
108330: 83 c4 20 add $0x20,%esp
108333: 85 c0 test %eax,%eax
108335: 8b 55 e0 mov -0x20(%ebp),%edx
108338: 0f 85 82 01 00 00 jne 1084c0 <rtems_termios_open+0x3df><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
10833e: 57 push %edi
10833f: 57 push %edi
108340: 8d 83 c4 00 00 00 lea 0xc4(%ebx),%eax
108346: 50 push %eax
108347: 6a 00 push $0x0
108349: 68 00 05 00 00 push $0x500
10834e: 68 00 04 00 00 push $0x400
108353: 6a 09 push $0x9
rtems_build_name ('R', 'x', 'T', c),
108355: 0f be 05 7c 30 12 00 movsbl 0x12307c,%eax
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
10835c: 0d 00 54 78 52 or $0x52785400,%eax
108361: 50 push %eax
108362: 89 55 e0 mov %edx,-0x20(%ebp)
108365: e8 7a 1f 00 00 call 10a2e4 <rtems_task_create>
TERMIOS_RXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
10836a: 83 c4 20 add $0x20,%esp
10836d: 85 c0 test %eax,%eax
10836f: 8b 55 e0 mov -0x20(%ebp),%edx
108372: 0f 85 48 01 00 00 jne 1084c0 <rtems_termios_open+0x3df><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
108378: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx)
10837f: 74 09 je 10838a <rtems_termios_open+0x2a9>
108381: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx)
108388: 75 30 jne 1083ba <rtems_termios_open+0x2d9>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
10838a: 83 ec 0c sub $0xc,%esp
10838d: 8d 43 68 lea 0x68(%ebx),%eax
108390: 50 push %eax
108391: 6a 00 push $0x0
108393: 6a 24 push $0x24
108395: 6a 00 push $0x0
rtems_build_name ('T', 'R', 'r', c),
108397: 0f be 05 7c 30 12 00 movsbl 0x12307c,%eax
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
10839e: 0d 00 72 52 54 or $0x54527200,%eax
1083a3: 50 push %eax
1083a4: 89 55 e0 mov %edx,-0x20(%ebp)
1083a7: e8 94 1b 00 00 call 109f40 <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)
1083ac: 83 c4 20 add $0x20,%esp
1083af: 85 c0 test %eax,%eax
1083b1: 8b 55 e0 mov -0x20(%ebp),%edx
1083b4: 0f 85 06 01 00 00 jne 1084c0 <rtems_termios_open+0x3df>
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
1083ba: c7 43 30 02 25 00 00 movl $0x2502,0x30(%ebx)
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
1083c1: c7 43 34 05 18 00 00 movl $0x1805,0x34(%ebx)
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
1083c8: c7 43 38 bd 08 00 00 movl $0x8bd,0x38(%ebx)
tty->termios.c_lflag =
1083cf: c7 43 3c 3b 82 00 00 movl $0x823b,0x3c(%ebx)
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
1083d6: c6 43 41 03 movb $0x3,0x41(%ebx)
tty->termios.c_cc[VQUIT] = '\034';
1083da: c6 43 42 1c movb $0x1c,0x42(%ebx)
tty->termios.c_cc[VERASE] = '\177';
1083de: c6 43 43 7f movb $0x7f,0x43(%ebx)
tty->termios.c_cc[VKILL] = '\025';
1083e2: c6 43 44 15 movb $0x15,0x44(%ebx)
tty->termios.c_cc[VEOF] = '\004';
1083e6: c6 43 45 04 movb $0x4,0x45(%ebx)
tty->termios.c_cc[VEOL] = '\000';
1083ea: c6 43 4c 00 movb $0x0,0x4c(%ebx)
tty->termios.c_cc[VEOL2] = '\000';
1083ee: c6 43 51 00 movb $0x0,0x51(%ebx)
tty->termios.c_cc[VSTART] = '\021';
1083f2: c6 43 49 11 movb $0x11,0x49(%ebx)
tty->termios.c_cc[VSTOP] = '\023';
1083f6: c6 43 4a 13 movb $0x13,0x4a(%ebx)
tty->termios.c_cc[VSUSP] = '\032';
1083fa: c6 43 4b 1a movb $0x1a,0x4b(%ebx)
tty->termios.c_cc[VREPRINT] = '\022';
1083fe: c6 43 4d 12 movb $0x12,0x4d(%ebx)
tty->termios.c_cc[VDISCARD] = '\017';
108402: c6 43 4e 0f movb $0xf,0x4e(%ebx)
tty->termios.c_cc[VWERASE] = '\027';
108406: c6 43 4f 17 movb $0x17,0x4f(%ebx)
tty->termios.c_cc[VLNEXT] = '\026';
10840a: c6 43 50 16 movb $0x16,0x50(%ebx)
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
10840e: c7 83 b8 00 00 00 00 movl $0x0,0xb8(%ebx)
108415: 00 00 00
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
108418: 8b 43 64 mov 0x64(%ebx),%eax
10841b: d1 e8 shr %eax
10841d: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx)
tty->highwater = tty->rawInBuf.Size * 3/4;
108423: 8b 43 64 mov 0x64(%ebx),%eax
108426: 8d 04 40 lea (%eax,%eax,2),%eax
108429: c1 e8 02 shr $0x2,%eax
10842c: 89 83 c0 00 00 00 mov %eax,0xc0(%ebx)
/*
* Bump name characer
*/
if (c++ == 'z')
108432: a0 7c 30 12 00 mov 0x12307c,%al
108437: 8d 48 01 lea 0x1(%eax),%ecx
10843a: 88 0d 7c 30 12 00 mov %cl,0x12307c
108440: 3c 7a cmp $0x7a,%al
108442: 75 07 jne 10844b <rtems_termios_open+0x36a>
c = 'a';
108444: c6 05 7c 30 12 00 61 movb $0x61,0x12307c
}
args->iop->data1 = tty;
10844b: 8b 4d 10 mov 0x10(%ebp),%ecx
10844e: 8b 01 mov (%ecx),%eax
108450: 89 50 34 mov %edx,0x34(%eax)
if (!tty->refcount++) {
108453: 8b 42 08 mov 0x8(%edx),%eax
108456: 8d 48 01 lea 0x1(%eax),%ecx
108459: 89 4a 08 mov %ecx,0x8(%edx)
10845c: 85 c0 test %eax,%eax
10845e: 75 69 jne 1084c9 <rtems_termios_open+0x3e8>
if (tty->device.firstOpen)
108460: 8b 82 98 00 00 00 mov 0x98(%edx),%eax
108466: 85 c0 test %eax,%eax
108468: 74 15 je 10847f <rtems_termios_open+0x39e>
(*tty->device.firstOpen)(major, minor, arg);
10846a: 56 push %esi
10846b: ff 75 10 pushl 0x10(%ebp)
10846e: ff 75 0c pushl 0xc(%ebp)
108471: ff 75 08 pushl 0x8(%ebp)
108474: 89 55 e0 mov %edx,-0x20(%ebp)
108477: ff d0 call *%eax
108479: 83 c4 10 add $0x10,%esp
10847c: 8b 55 e0 mov -0x20(%ebp),%edx
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
10847f: 83 ba b4 00 00 00 02 cmpl $0x2,0xb4(%edx)
108486: 75 41 jne 1084c9 <rtems_termios_open+0x3e8>
sc = rtems_task_start(
108488: 53 push %ebx
108489: 52 push %edx
10848a: 68 aa 95 10 00 push $0x1095aa
10848f: ff b2 c4 00 00 00 pushl 0xc4(%edx)
108495: 89 55 e0 mov %edx,-0x20(%ebp)
108498: e8 bb 20 00 00 call 10a558 <rtems_task_start>
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
10849d: 83 c4 10 add $0x10,%esp
1084a0: 85 c0 test %eax,%eax
1084a2: 8b 55 e0 mov -0x20(%ebp),%edx
1084a5: 75 19 jne 1084c0 <rtems_termios_open+0x3df><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
1084a7: 51 push %ecx
1084a8: 52 push %edx
1084a9: 68 dc 97 10 00 push $0x1097dc
1084ae: ff b2 c8 00 00 00 pushl 0xc8(%edx)
1084b4: e8 9f 20 00 00 call 10a558 <rtems_task_start>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
1084b9: 83 c4 10 add $0x10,%esp
1084bc: 85 c0 test %eax,%eax
1084be: 74 09 je 1084c9 <rtems_termios_open+0x3e8><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
1084c0: 83 ec 0c sub $0xc,%esp
1084c3: 50 push %eax
1084c4: e8 6b 22 00 00 call 10a734 <rtems_fatal_error_occurred>
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
1084c9: 83 ec 0c sub $0xc,%esp
1084cc: ff 35 3c 52 12 00 pushl 0x12523c
1084d2: e8 7d 1d 00 00 call 10a254 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
1084d7: 83 c4 10 add $0x10,%esp
}
1084da: 8b 45 e4 mov -0x1c(%ebp),%eax
1084dd: 8d 65 f4 lea -0xc(%ebp),%esp
1084e0: 5b pop %ebx
1084e1: 5e pop %esi
1084e2: 5f pop %edi
1084e3: c9 leave
1084e4: c3 ret
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
1084e5: 52 push %edx
1084e6: 52 push %edx
1084e7: 68 e8 00 00 00 push $0xe8
1084ec: 6a 01 push $0x1
1084ee: e8 e9 ec ff ff call 1071dc <calloc>
1084f3: 89 c2 mov %eax,%edx
1084f5: 89 c3 mov %eax,%ebx
if (tty == NULL) {
1084f7: 83 c4 10 add $0x10,%esp
1084fa: 85 c0 test %eax,%eax
1084fc: 0f 85 33 fc ff ff jne 108135 <rtems_termios_open+0x54>
108502: e9 29 fc ff ff jmp 108130 <rtems_termios_open+0x4f>
001089fe <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
1089fe: 55 push %ebp
1089ff: 89 e5 mov %esp,%ebp
108a01: 57 push %edi
108a02: 56 push %esi
108a03: 53 push %ebx
108a04: 83 ec 3c sub $0x3c,%esp
108a07: 8b 45 08 mov 0x8(%ebp),%eax
108a0a: 8b 75 0c mov 0xc(%ebp),%esi
108a0d: 8b 5d 10 mov 0x10(%ebp),%ebx
const unsigned char *buf = _buf;
108a10: 89 c7 mov %eax,%edi
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
108a12: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx)
108a19: 75 1b jne 108a36 <rtems_termios_puts+0x38>
(*tty->device.write)(tty->minor, (void *)buf, len);
108a1b: 89 75 10 mov %esi,0x10(%ebp)
108a1e: 89 45 0c mov %eax,0xc(%ebp)
108a21: 8b 43 10 mov 0x10(%ebx),%eax
108a24: 89 45 08 mov %eax,0x8(%ebp)
108a27: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
108a2d: 8d 65 f4 lea -0xc(%ebp),%esp
108a30: 5b pop %ebx
108a31: 5e pop %esi
108a32: 5f pop %edi
108a33: c9 leave
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
108a34: ff e0 jmp *%eax
return;
}
newHead = tty->rawOutBuf.Head;
108a36: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
108a3c: 89 45 e4 mov %eax,-0x1c(%ebp)
while (len) {
108a3f: e9 ca 00 00 00 jmp 108b0e <rtems_termios_puts+0x110>
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
108a44: 8b 45 e4 mov -0x1c(%ebp),%eax
108a47: 40 inc %eax
108a48: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx
108a4e: 31 d2 xor %edx,%edx
108a50: f7 f1 div %ecx
108a52: 89 55 c4 mov %edx,-0x3c(%ebp)
108a55: 89 55 e4 mov %edx,-0x1c(%ebp)
rtems_interrupt_disable (level);
108a58: 9c pushf
108a59: fa cli
108a5a: 8f 45 d4 popl -0x2c(%ebp)
108a5d: 8b 55 d4 mov -0x2c(%ebp),%edx
108a60: 8b 4d c4 mov -0x3c(%ebp),%ecx
while (newHead == tty->rawOutBuf.Tail) {
108a63: eb 35 jmp 108a9a <rtems_termios_puts+0x9c>
tty->rawOutBufState = rob_wait;
108a65: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx)
108a6c: 00 00 00
rtems_interrupt_enable (level);
108a6f: 52 push %edx
108a70: 9d popf
sc = rtems_semaphore_obtain(
108a71: 50 push %eax
108a72: 6a 00 push $0x0
108a74: 6a 00 push $0x0
108a76: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
108a7c: 89 4d e0 mov %ecx,-0x20(%ebp)
108a7f: e8 e4 16 00 00 call 10a168 <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
108a84: 83 c4 10 add $0x10,%esp
108a87: 85 c0 test %eax,%eax
108a89: 8b 4d e0 mov -0x20(%ebp),%ecx
108a8c: 74 09 je 108a97 <rtems_termios_puts+0x99><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
108a8e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
108a91: 50 push %eax <== NOT EXECUTED
108a92: e8 9d 1c 00 00 call 10a734 <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_interrupt_disable (level);
108a97: 9c pushf
108a98: fa cli
108a99: 5a pop %edx
* 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) {
108a9a: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
108aa0: 39 c1 cmp %eax,%ecx
108aa2: 74 c1 je 108a65 <rtems_termios_puts+0x67>
108aa4: 89 55 d4 mov %edx,-0x2c(%ebp)
108aa7: 89 4d c4 mov %ecx,-0x3c(%ebp)
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
108aaa: 8b 8b 80 00 00 00 mov 0x80(%ebx),%ecx
108ab0: 8a 07 mov (%edi),%al
108ab2: 8b 53 7c mov 0x7c(%ebx),%edx
108ab5: 88 04 0a mov %al,(%edx,%ecx,1)
108ab8: 47 inc %edi
tty->rawOutBuf.Head = newHead;
108ab9: 8b 4d c4 mov -0x3c(%ebp),%ecx
108abc: 89 8b 80 00 00 00 mov %ecx,0x80(%ebx)
if (tty->rawOutBufState == rob_idle) {
108ac2: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx)
108ac9: 75 3e jne 108b09 <rtems_termios_puts+0x10b>
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
108acb: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
108ad1: a8 10 test $0x10,%al
108ad3: 75 1b jne 108af0 <rtems_termios_puts+0xf2><== NEVER TAKEN
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
108ad5: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(tty->minor,
108adb: 51 push %ecx
108adc: 6a 01 push $0x1
108ade: 03 43 7c add 0x7c(%ebx),%eax
108ae1: 50 push %eax
108ae2: ff 73 10 pushl 0x10(%ebx)
108ae5: ff 93 a4 00 00 00 call *0xa4(%ebx)
108aeb: 83 c4 10 add $0x10,%esp
108aee: eb 0f jmp 108aff <rtems_termios_puts+0x101>
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
108af0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
108af6: 83 c8 20 or $0x20,%eax <== NOT EXECUTED
108af9: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
108aff: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx)
108b06: 00 00 00
}
rtems_interrupt_enable (level);
108b09: ff 75 d4 pushl -0x2c(%ebp)
108b0c: 9d popf
len--;
108b0d: 4e dec %esi
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
108b0e: 85 f6 test %esi,%esi
108b10: 0f 85 2e ff ff ff jne 108a44 <rtems_termios_puts+0x46>
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
108b16: 8d 65 f4 lea -0xc(%ebp),%esp
108b19: 5b pop %ebx
108b1a: 5e pop %esi
108b1b: 5f pop %edi
108b1c: c9 leave
108b1d: c3 ret
00109025 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
109025: 55 push %ebp
109026: 89 e5 mov %esp,%ebp
109028: 57 push %edi
109029: 56 push %esi
10902a: 53 push %ebx
10902b: 83 ec 40 sub $0x40,%esp
10902e: 8b 75 08 mov 0x8(%ebp),%esi
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
109031: 8b 06 mov (%esi),%eax
109033: 8b 58 34 mov 0x34(%eax),%ebx
uint32_t count = args->count;
109036: 8b 46 10 mov 0x10(%esi),%eax
109039: 89 45 e4 mov %eax,-0x1c(%ebp)
char *buffer = args->buffer;
10903c: 8b 46 0c mov 0xc(%esi),%eax
10903f: 89 45 e0 mov %eax,-0x20(%ebp)
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
109042: 6a 00 push $0x0
109044: 6a 00 push $0x0
109046: ff 73 14 pushl 0x14(%ebx)
109049: e8 1a 11 00 00 call 10a168 <rtems_semaphore_obtain>
10904e: 89 45 dc mov %eax,-0x24(%ebp)
if (sc != RTEMS_SUCCESSFUL)
109051: 83 c4 10 add $0x10,%esp
109054: 85 c0 test %eax,%eax
109056: 0f 85 9d 02 00 00 jne 1092f9 <rtems_termios_read+0x2d4><== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
10905c: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
109062: c1 e0 05 shl $0x5,%eax
109065: 8b 80 fc 4e 12 00 mov 0x124efc(%eax),%eax
10906b: 85 c0 test %eax,%eax
10906d: 74 19 je 109088 <rtems_termios_read+0x63>
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
10906f: 57 push %edi
109070: 57 push %edi
109071: 56 push %esi
109072: 53 push %ebx
109073: ff d0 call *%eax
109075: 89 45 dc mov %eax,-0x24(%ebp)
tty->tty_rcvwakeup = 0;
109078: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
10907f: 00 00 00
rtems_semaphore_release (tty->isem);
109082: 59 pop %ecx
109083: e9 66 02 00 00 jmp 1092ee <rtems_termios_read+0x2c9>
return sc;
}
if (tty->cindex == tty->ccount) {
109088: 8b 43 20 mov 0x20(%ebx),%eax
10908b: 39 43 24 cmp %eax,0x24(%ebx)
10908e: 0f 85 2d 02 00 00 jne 1092c1 <rtems_termios_read+0x29c><== NEVER TAKEN
tty->cindex = tty->ccount = 0;
109094: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
10909b: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
tty->read_start_column = tty->column;
1090a2: 8b 43 28 mov 0x28(%ebx),%eax
1090a5: 89 43 2c mov %eax,0x2c(%ebx)
if (tty->device.pollRead != NULL &&
1090a8: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx)
1090af: 0f 84 c4 00 00 00 je 109179 <rtems_termios_read+0x154>
1090b5: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx)
1090bc: 0f 85 b7 00 00 00 jne 109179 <rtems_termios_read+0x154>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
1090c2: f6 43 3c 02 testb $0x2,0x3c(%ebx)
1090c6: 74 35 je 1090fd <rtems_termios_read+0xd8>
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
1090c8: 83 ec 0c sub $0xc,%esp
1090cb: ff 73 10 pushl 0x10(%ebx)
1090ce: ff 93 a0 00 00 00 call *0xa0(%ebx)
if (n < 0) {
1090d4: 83 c4 10 add $0x10,%esp
1090d7: 85 c0 test %eax,%eax
1090d9: 79 0f jns 1090ea <rtems_termios_read+0xc5>
rtems_task_wake_after (1);
1090db: 83 ec 0c sub $0xc,%esp
1090de: 6a 01 push $0x1
1090e0: e8 d7 14 00 00 call 10a5bc <rtems_task_wake_after>
1090e5: 83 c4 10 add $0x10,%esp
1090e8: eb de jmp 1090c8 <rtems_termios_read+0xa3>
} else {
if (siproc (n, tty))
1090ea: 0f b6 c0 movzbl %al,%eax
1090ed: 89 da mov %ebx,%edx
1090ef: e8 38 fe ff ff call 108f2c <siproc>
1090f4: 85 c0 test %eax,%eax
1090f6: 74 d0 je 1090c8 <rtems_termios_read+0xa3>
1090f8: e9 c4 01 00 00 jmp 1092c1 <rtems_termios_read+0x29c>
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
1090fd: e8 3a 0a 00 00 call 109b3c <rtems_clock_get_ticks_since_boot>
109102: 89 c7 mov %eax,%edi
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
109104: 83 ec 0c sub $0xc,%esp
109107: ff 73 10 pushl 0x10(%ebx)
10910a: ff 93 a0 00 00 00 call *0xa0(%ebx)
if (n < 0) {
109110: 83 c4 10 add $0x10,%esp
109113: 85 c0 test %eax,%eax
109115: 79 3d jns 109154 <rtems_termios_read+0x12f>
if (tty->termios.c_cc[VMIN]) {
109117: 80 7b 47 00 cmpb $0x0,0x47(%ebx)
10911b: 74 0e je 10912b <rtems_termios_read+0x106><== NEVER TAKEN
if (tty->termios.c_cc[VTIME] && tty->ccount) {
10911d: 80 7b 46 00 cmpb $0x0,0x46(%ebx)
109121: 74 22 je 109145 <rtems_termios_read+0x120><== NEVER TAKEN
109123: 83 7b 20 00 cmpl $0x0,0x20(%ebx)
109127: 74 1c je 109145 <rtems_termios_read+0x120>
109129: eb 0a jmp 109135 <rtems_termios_read+0x110>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
10912b: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED
10912f: 0f 84 8c 01 00 00 je 1092c1 <rtems_termios_read+0x29c><== NOT EXECUTED
break;
now = rtems_clock_get_ticks_since_boot();
109135: e8 02 0a 00 00 call 109b3c <rtems_clock_get_ticks_since_boot>
if ((now - then) > tty->vtimeTicks) {
10913a: 29 f8 sub %edi,%eax
10913c: 3b 43 54 cmp 0x54(%ebx),%eax
10913f: 0f 87 7c 01 00 00 ja 1092c1 <rtems_termios_read+0x29c>
break;
}
}
rtems_task_wake_after (1);
109145: 83 ec 0c sub $0xc,%esp
109148: 6a 01 push $0x1
10914a: e8 6d 14 00 00 call 10a5bc <rtems_task_wake_after>
10914f: 83 c4 10 add $0x10,%esp
109152: eb b0 jmp 109104 <rtems_termios_read+0xdf>
} else {
siproc (n, tty);
109154: 0f b6 c0 movzbl %al,%eax
109157: 89 da mov %ebx,%edx
109159: e8 ce fd ff ff call 108f2c <siproc>
if (tty->ccount >= tty->termios.c_cc[VMIN])
10915e: 8a 43 47 mov 0x47(%ebx),%al
109161: 0f b6 d0 movzbl %al,%edx
109164: 39 53 20 cmp %edx,0x20(%ebx)
109167: 0f 8d 54 01 00 00 jge 1092c1 <rtems_termios_read+0x29c><== NEVER TAKEN
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
10916d: 84 c0 test %al,%al
10916f: 74 93 je 109104 <rtems_termios_read+0xdf><== NEVER TAKEN
109171: 80 7b 46 00 cmpb $0x0,0x46(%ebx)
109175: 74 8d je 109104 <rtems_termios_read+0xdf><== NEVER TAKEN
109177: eb 84 jmp 1090fd <rtems_termios_read+0xd8>
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
109179: 8b 53 74 mov 0x74(%ebx),%edx
rtems_status_code sc;
int wait = (int)1;
10917c: bf 01 00 00 00 mov $0x1,%edi
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)(
109181: 8d 43 49 lea 0x49(%ebx),%eax
109184: 89 45 d0 mov %eax,-0x30(%ebp)
109187: e9 e6 00 00 00 jmp 109272 <rtems_termios_read+0x24d>
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;
10918c: 8b 43 5c mov 0x5c(%ebx),%eax
10918f: 8b 4b 64 mov 0x64(%ebx),%ecx
109192: 40 inc %eax
109193: 31 d2 xor %edx,%edx
109195: f7 f1 div %ecx
c = tty->rawInBuf.theBuf[newHead];
109197: 8b 43 58 mov 0x58(%ebx),%eax
10919a: 8a 04 10 mov (%eax,%edx,1),%al
10919d: 88 45 db mov %al,-0x25(%ebp)
tty->rawInBuf.Head = newHead;
1091a0: 89 53 5c mov %edx,0x5c(%ebx)
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
1091a3: 8b 43 60 mov 0x60(%ebx),%eax
1091a6: 89 45 c4 mov %eax,-0x3c(%ebp)
1091a9: 8b 4b 64 mov 0x64(%ebx),%ecx
% tty->rawInBuf.Size)
1091ac: 8b 43 64 mov 0x64(%ebx),%eax
1091af: 89 45 d4 mov %eax,-0x2c(%ebp)
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
c = tty->rawInBuf.theBuf[newHead];
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
1091b2: 8b 45 c4 mov -0x3c(%ebp),%eax
1091b5: 8d 04 01 lea (%ecx,%eax,1),%eax
1091b8: 29 d0 sub %edx,%eax
% tty->rawInBuf.Size)
1091ba: 31 d2 xor %edx,%edx
1091bc: f7 75 d4 divl -0x2c(%ebp)
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
c = tty->rawInBuf.theBuf[newHead];
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
1091bf: 3b 93 bc 00 00 00 cmp 0xbc(%ebx),%edx
1091c5: 73 74 jae 10923b <rtems_termios_read+0x216><== NEVER TAKEN
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
1091c7: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1091cd: 83 e0 fe and $0xfffffffe,%eax
1091d0: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx)
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
1091d6: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1091dc: 25 02 02 00 00 and $0x202,%eax
1091e1: 3d 02 02 00 00 cmp $0x202,%eax
1091e6: 75 24 jne 10920c <rtems_termios_read+0x1e7><== ALWAYS TAKEN
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
1091e8: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED
1091ef: 74 0a je 1091fb <rtems_termios_read+0x1d6><== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
1091f1: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
1091f7: a8 20 test $0x20,%al <== NOT EXECUTED
1091f9: 74 11 je 10920c <rtems_termios_read+0x1e7><== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
1091fb: 52 push %edx <== NOT EXECUTED
1091fc: 6a 01 push $0x1 <== NOT EXECUTED
1091fe: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED
109201: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109204: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
10920a: eb 2c jmp 109238 <rtems_termios_read+0x213><== NOT EXECUTED
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
10920c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109212: f6 c4 01 test $0x1,%ah
109215: 74 24 je 10923b <rtems_termios_read+0x216><== ALWAYS TAKEN
tty->flow_ctrl &= ~FL_IRTSOFF;
109217: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10921d: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED
109220: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
109226: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED
10922c: 85 c0 test %eax,%eax <== NOT EXECUTED
10922e: 74 0b je 10923b <rtems_termios_read+0x216><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
109230: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
109233: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109236: ff d0 call *%eax <== NOT EXECUTED
109238: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
10923b: f6 43 3c 02 testb $0x2,0x3c(%ebx)
10923f: 74 12 je 109253 <rtems_termios_read+0x22e><== NEVER TAKEN
if (siproc (c, tty))
109241: 0f b6 45 db movzbl -0x25(%ebp),%eax
109245: 89 da mov %ebx,%edx
109247: e8 e0 fc ff ff call 108f2c <siproc>
wait = 0;
10924c: 85 c0 test %eax,%eax
10924e: 0f 94 c0 sete %al
109251: eb 15 jmp 109268 <rtems_termios_read+0x243>
} else {
siproc (c, tty);
109253: 0f b6 45 db movzbl -0x25(%ebp),%eax <== NOT EXECUTED
109257: 89 da mov %ebx,%edx <== NOT EXECUTED
109259: e8 ce fc ff ff call 108f2c <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
10925e: 0f b6 43 47 movzbl 0x47(%ebx),%eax <== NOT EXECUTED
wait = 0;
109262: 39 43 20 cmp %eax,0x20(%ebx) <== NOT EXECUTED
109265: 0f 9c c0 setl %al <== NOT EXECUTED
109268: 0f b6 c0 movzbl %al,%eax
10926b: f7 d8 neg %eax
10926d: 21 c7 and %eax,%edi
}
timeout = tty->rawInBufSemaphoreTimeout;
10926f: 8b 53 70 mov 0x70(%ebx),%edx
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
109272: 8b 4b 5c mov 0x5c(%ebx),%ecx
109275: 8b 43 60 mov 0x60(%ebx),%eax
109278: 39 c1 cmp %eax,%ecx
10927a: 74 0f je 10928b <rtems_termios_read+0x266>
(tty->ccount < (CBUFSIZE-1))) {
10927c: a1 70 30 12 00 mov 0x123070,%eax
109281: 48 dec %eax
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
109282: 39 43 20 cmp %eax,0x20(%ebx)
109285: 0f 8c 01 ff ff ff jl 10918c <rtems_termios_read+0x167><== ALWAYS TAKEN
}
/*
* Wait for characters
*/
if ( wait ) {
10928b: 85 ff test %edi,%edi
10928d: 74 32 je 1092c1 <rtems_termios_read+0x29c>
sc = rtems_semaphore_obtain(
10928f: 50 push %eax
109290: 52 push %edx
109291: ff 73 6c pushl 0x6c(%ebx)
109294: ff 73 68 pushl 0x68(%ebx)
109297: 89 55 cc mov %edx,-0x34(%ebp)
10929a: e8 c9 0e 00 00 call 10a168 <rtems_semaphore_obtain>
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
10929f: 83 c4 10 add $0x10,%esp
1092a2: 85 c0 test %eax,%eax
1092a4: 8b 55 cc mov -0x34(%ebp),%edx
1092a7: 74 c9 je 109272 <rtems_termios_read+0x24d><== ALWAYS TAKEN
1092a9: eb 16 jmp 1092c1 <rtems_termios_read+0x29c><== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
1092ab: 8b 7b 1c mov 0x1c(%ebx),%edi
1092ae: 8b 45 e4 mov -0x1c(%ebp),%eax
1092b1: 8a 04 07 mov (%edi,%eax,1),%al
1092b4: 88 01 mov %al,(%ecx)
1092b6: 41 inc %ecx
1092b7: 8b 45 e4 mov -0x1c(%ebp),%eax
1092ba: 40 inc %eax
1092bb: 89 43 24 mov %eax,0x24(%ebx)
count--;
1092be: 4a dec %edx
1092bf: eb 06 jmp 1092c7 <rtems_termios_read+0x2a2>
1092c1: 8b 55 e4 mov -0x1c(%ebp),%edx
1092c4: 8b 4d e0 mov -0x20(%ebp),%ecx
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
1092c7: 85 d2 test %edx,%edx
1092c9: 74 0b je 1092d6 <rtems_termios_read+0x2b1>
1092cb: 8b 43 24 mov 0x24(%ebx),%eax
1092ce: 89 45 e4 mov %eax,-0x1c(%ebp)
1092d1: 3b 43 20 cmp 0x20(%ebx),%eax
1092d4: 7c d5 jl 1092ab <rtems_termios_read+0x286>
1092d6: 89 55 e4 mov %edx,-0x1c(%ebp)
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
1092d9: 8b 46 10 mov 0x10(%esi),%eax
1092dc: 29 d0 sub %edx,%eax
1092de: 89 46 18 mov %eax,0x18(%esi)
tty->tty_rcvwakeup = 0;
1092e1: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx)
1092e8: 00 00 00
rtems_semaphore_release (tty->isem);
1092eb: 83 ec 0c sub $0xc,%esp
1092ee: ff 73 14 pushl 0x14(%ebx)
1092f1: e8 5e 0f 00 00 call 10a254 <rtems_semaphore_release>
return sc;
1092f6: 83 c4 10 add $0x10,%esp
}
1092f9: 8b 45 dc mov -0x24(%ebp),%eax
1092fc: 8d 65 f4 lea -0xc(%ebp),%esp
1092ff: 5b pop %ebx
109300: 5e pop %esi
109301: 5f pop %edi
109302: c9 leave
109303: c3 ret
0010960e <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)
{
10960e: 55 push %ebp
10960f: 89 e5 mov %esp,%ebp
109611: 57 push %edi
109612: 56 push %esi
109613: 53 push %ebx
109614: 83 ec 0c sub $0xc,%esp
109617: 8b 5d 08 mov 0x8(%ebp),%ebx
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
10961a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109620: 25 03 04 00 00 and $0x403,%eax
109625: 3d 01 04 00 00 cmp $0x401,%eax
10962a: 75 2c jne 109658 <rtems_termios_refill_transmitter+0x4a><== ALWAYS TAKEN
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
10962c: 57 push %edi <== NOT EXECUTED
10962d: 6a 01 push $0x1 <== NOT EXECUTED
10962f: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED
109632: 50 push %eax <== NOT EXECUTED
109633: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109636: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
rtems_interrupt_disable(level);
10963c: 9c pushf <== NOT EXECUTED
10963d: fa cli <== NOT EXECUTED
10963e: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
10963f: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
109645: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10964b: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
10964e: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
rtems_interrupt_enable(level);
109654: 52 push %edx <== NOT EXECUTED
109655: 9d popf <== NOT EXECUTED
109656: eb 38 jmp 109690 <rtems_termios_refill_transmitter+0x82><== NOT EXECUTED
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
109658: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
10965e: 83 e0 03 and $0x3,%eax
109661: 83 f8 02 cmp $0x2,%eax
109664: 75 37 jne 10969d <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, (void *)&(tty->termios.c_cc[VSTART]), 1);
109666: 56 push %esi <== NOT EXECUTED
109667: 6a 01 push $0x1 <== NOT EXECUTED
109669: 8d 43 49 lea 0x49(%ebx),%eax <== NOT EXECUTED
10966c: 50 push %eax <== NOT EXECUTED
10966d: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
109670: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED
rtems_interrupt_disable(level);
109676: 9c pushf <== NOT EXECUTED
109677: fa cli <== NOT EXECUTED
109678: 5a pop %edx <== NOT EXECUTED
tty->t_dqlen--;
109679: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
10967f: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
109685: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED
109688: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
rtems_interrupt_enable(level);
10968e: 52 push %edx <== NOT EXECUTED
10968f: 9d popf <== NOT EXECUTED
109690: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
nToSend = 1;
109693: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED
109698: e9 35 01 00 00 jmp 1097d2 <rtems_termios_refill_transmitter+0x1c4><== NOT EXECUTED
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
10969d: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx
1096a3: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
1096a9: 39 c2 cmp %eax,%edx
1096ab: 75 25 jne 1096d2 <rtems_termios_refill_transmitter+0xc4>
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
1096ad: 31 f6 xor %esi,%esi
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
1096af: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx)
1096b6: 0f 85 16 01 00 00 jne 1097d2 <rtems_termios_refill_transmitter+0x1c4><== ALWAYS TAKEN
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
1096bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
1096bf: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED
1096c5: e8 8a 0b 00 00 call 10a254 <rtems_semaphore_release><== NOT EXECUTED
1096ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
1096cd: e9 00 01 00 00 jmp 1097d2 <rtems_termios_refill_transmitter+0x1c4><== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
1096d2: 9c pushf
1096d3: fa cli
1096d4: 58 pop %eax
len = tty->t_dqlen;
1096d5: 8b bb 90 00 00 00 mov 0x90(%ebx),%edi
tty->t_dqlen = 0;
1096db: c7 83 90 00 00 00 00 movl $0x0,0x90(%ebx)
1096e2: 00 00 00
rtems_interrupt_enable(level);
1096e5: 50 push %eax
1096e6: 9d popf
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
1096e7: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax
1096ed: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx
1096f3: 8d 04 07 lea (%edi,%eax,1),%eax
1096f6: 31 d2 xor %edx,%edx
1096f8: f7 f1 div %ecx
1096fa: 89 d7 mov %edx,%edi
tty->rawOutBuf.Tail = newTail;
1096fc: 89 93 84 00 00 00 mov %edx,0x84(%ebx)
if (tty->rawOutBufState == rob_wait) {
109702: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx)
109709: 75 11 jne 10971c <rtems_termios_refill_transmitter+0x10e>
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
10970b: 83 ec 0c sub $0xc,%esp
10970e: ff b3 8c 00 00 00 pushl 0x8c(%ebx)
109714: e8 3b 0b 00 00 call 10a254 <rtems_semaphore_release>
109719: 83 c4 10 add $0x10,%esp
}
if (newTail == tty->rawOutBuf.Head) {
10971c: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
109722: 39 c7 cmp %eax,%edi
109724: 75 2a jne 109750 <rtems_termios_refill_transmitter+0x142>
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
109726: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx)
10972d: 00 00 00
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
109730: 8b 83 d4 00 00 00 mov 0xd4(%ebx),%eax
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
nToSend = 0;
109736: 31 f6 xor %esi,%esi
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
109738: 85 c0 test %eax,%eax
10973a: 0f 84 8c 00 00 00 je 1097cc <rtems_termios_refill_transmitter+0x1be><== ALWAYS TAKEN
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
109740: 51 push %ecx <== NOT EXECUTED
109741: 51 push %ecx <== NOT EXECUTED
109742: ff b3 d8 00 00 00 pushl 0xd8(%ebx) <== NOT EXECUTED
109748: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED
10974b: 52 push %edx <== NOT EXECUTED
10974c: ff d0 call *%eax <== NOT EXECUTED
10974e: eb 79 jmp 1097c9 <rtems_termios_refill_transmitter+0x1bb><== NOT EXECUTED
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
109750: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
109756: 25 10 02 00 00 and $0x210,%eax
10975b: 3d 10 02 00 00 cmp $0x210,%eax
109760: 75 22 jne 109784 <rtems_termios_refill_transmitter+0x176><== 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);
109762: 9c pushf <== NOT EXECUTED
109763: fa cli <== NOT EXECUTED
109764: 5a pop %edx <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
109765: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED
10976b: 83 c8 20 or $0x20,%eax <== NOT EXECUTED
10976e: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
109774: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED
10977b: 00 00 00
rtems_interrupt_enable(level);
10977e: 52 push %edx <== NOT EXECUTED
10977f: 9d popf <== NOT EXECUTED
nToSend = 0;
109780: 31 f6 xor %esi,%esi <== NOT EXECUTED
109782: eb 48 jmp 1097cc <rtems_termios_refill_transmitter+0x1be><== NOT EXECUTED
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
109784: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax
10978a: 39 c7 cmp %eax,%edi
10978c: 76 08 jbe 109796 <rtems_termios_refill_transmitter+0x188>
nToSend = tty->rawOutBuf.Size - newTail;
10978e: 8b b3 88 00 00 00 mov 0x88(%ebx),%esi
109794: eb 06 jmp 10979c <rtems_termios_refill_transmitter+0x18e>
else
nToSend = tty->rawOutBuf.Head - newTail;
109796: 8b b3 80 00 00 00 mov 0x80(%ebx),%esi
10979c: 29 fe sub %edi,%esi
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
10979e: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
1097a4: f6 c4 06 test $0x6,%ah
1097a7: 74 05 je 1097ae <rtems_termios_refill_transmitter+0x1a0>
nToSend = 1;
1097a9: be 01 00 00 00 mov $0x1,%esi
}
tty->rawOutBufState = rob_busy; /*apm*/
1097ae: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx)
1097b5: 00 00 00
(*tty->device.write)(
1097b8: 52 push %edx
1097b9: 56 push %esi
1097ba: 8b 43 7c mov 0x7c(%ebx),%eax
1097bd: 01 f8 add %edi,%eax
1097bf: 50 push %eax
1097c0: ff 73 10 pushl 0x10(%ebx)
1097c3: ff 93 a4 00 00 00 call *0xa4(%ebx)
1097c9: 83 c4 10 add $0x10,%esp
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
1097cc: 89 bb 84 00 00 00 mov %edi,0x84(%ebx)
}
return nToSend;
}
1097d2: 89 f0 mov %esi,%eax
1097d4: 8d 65 f4 lea -0xc(%ebp),%esp
1097d7: 5b pop %ebx
1097d8: 5e pop %esi
1097d9: 5f pop %edi
1097da: c9 leave
1097db: c3 ret
001095aa <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
1095aa: 55 push %ebp
1095ab: 89 e5 mov %esp,%ebp
1095ad: 57 push %edi
1095ae: 56 push %esi
1095af: 53 push %ebx
1095b0: 83 ec 1c sub $0x1c,%esp
1095b3: 8b 5d 08 mov 0x8(%ebp),%ebx
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
1095b6: 8d 7d e0 lea -0x20(%ebp),%edi
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
1095b9: 8d 75 e7 lea -0x19(%ebp),%esi
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
1095bc: 57 push %edi
1095bd: 6a 00 push $0x0
1095bf: 6a 02 push $0x2
1095c1: 6a 03 push $0x3
1095c3: e8 d8 05 00 00 call 109ba0 <rtems_event_receive>
(TERMIOS_RX_PROC_EVENT | TERMIOS_RX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
1095c8: 83 c4 10 add $0x10,%esp
1095cb: f6 45 e0 01 testb $0x1,-0x20(%ebp)
1095cf: 74 17 je 1095e8 <rtems_termios_rxdaemon+0x3e><== ALWAYS TAKEN
tty->rxTaskId = 0;
1095d1: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx)
1095d8: 00 00 00
rtems_task_delete(RTEMS_SELF);
1095db: 83 ec 0c sub $0xc,%esp
1095de: 6a 00 push $0x0 <== NOT EXECUTED
1095e0: e8 37 0e 00 00 call 10a41c <rtems_task_delete> <== NOT EXECUTED
1095e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
1095e8: 83 ec 0c sub $0xc,%esp
1095eb: ff 73 10 pushl 0x10(%ebx)
1095ee: ff 93 a0 00 00 00 call *0xa0(%ebx)
if (c != EOF) {
1095f4: 83 c4 10 add $0x10,%esp
1095f7: 83 f8 ff cmp $0xffffffff,%eax
1095fa: 74 c0 je 1095bc <rtems_termios_rxdaemon+0x12>
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
1095fc: 88 45 e7 mov %al,-0x19(%ebp)
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
1095ff: 50 push %eax
109600: 6a 01 push $0x1
109602: 56 push %esi
109603: 53 push %ebx
109604: e8 16 fd ff ff call 10931f <rtems_termios_enqueue_raw_characters>
109609: 83 c4 10 add $0x10,%esp
10960c: eb ae jmp 1095bc <rtems_termios_rxdaemon+0x12>
001097dc <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
1097dc: 55 push %ebp
1097dd: 89 e5 mov %esp,%ebp
1097df: 56 push %esi
1097e0: 53 push %ebx
1097e1: 83 ec 10 sub $0x10,%esp
1097e4: 8b 5d 08 mov 0x8(%ebp),%ebx
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
1097e7: 8d 75 f4 lea -0xc(%ebp),%esi
1097ea: 56 push %esi
1097eb: 6a 00 push $0x0
1097ed: 6a 02 push $0x2
1097ef: 6a 03 push $0x3
1097f1: e8 aa 03 00 00 call 109ba0 <rtems_event_receive>
(TERMIOS_TX_START_EVENT | TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
1097f6: 83 c4 10 add $0x10,%esp
1097f9: f6 45 f4 01 testb $0x1,-0xc(%ebp)
1097fd: 74 17 je 109816 <rtems_termios_txdaemon+0x3a><== ALWAYS TAKEN
tty->txTaskId = 0;
1097ff: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED
109806: 00 00 00
rtems_task_delete(RTEMS_SELF);
109809: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10980c: 6a 00 push $0x0 <== NOT EXECUTED
10980e: e8 09 0c 00 00 call 10a41c <rtems_task_delete> <== NOT EXECUTED
109813: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
109816: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax
10981c: c1 e0 05 shl $0x5,%eax
10981f: 8b 80 08 4f 12 00 mov 0x124f08(%eax),%eax
109825: 85 c0 test %eax,%eax
109827: 74 09 je 109832 <rtems_termios_txdaemon+0x56><== ALWAYS TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
109829: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10982c: 53 push %ebx <== NOT EXECUTED
10982d: ff d0 call *%eax <== NOT EXECUTED
10982f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
109832: 83 ec 0c sub $0xc,%esp
109835: 53 push %ebx
109836: e8 d3 fd ff ff call 10960e <rtems_termios_refill_transmitter>
}
10983b: 83 c4 10 add $0x10,%esp
10983e: eb aa jmp 1097ea <rtems_termios_txdaemon+0xe>
00108f7e <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
108f7e: 55 push %ebp
108f7f: 89 e5 mov %esp,%ebp
108f81: 57 push %edi
108f82: 56 push %esi
108f83: 53 push %ebx
108f84: 83 ec 20 sub $0x20,%esp
108f87: 8b 5d 08 mov 0x8(%ebp),%ebx
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
108f8a: 8b 03 mov (%ebx),%eax
108f8c: 8b 70 34 mov 0x34(%eax),%esi
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
108f8f: 6a 00 push $0x0
108f91: 6a 00 push $0x0
108f93: ff 76 18 pushl 0x18(%esi)
108f96: e8 cd 11 00 00 call 10a168 <rtems_semaphore_obtain>
108f9b: 89 c7 mov %eax,%edi
if (sc != RTEMS_SUCCESSFUL)
108f9d: 83 c4 10 add $0x10,%esp
108fa0: 85 c0 test %eax,%eax
108fa2: 75 77 jne 10901b <rtems_termios_write+0x9d><== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
108fa4: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax
108faa: c1 e0 05 shl $0x5,%eax
108fad: 8b 80 00 4f 12 00 mov 0x124f00(%eax),%eax
108fb3: 85 c0 test %eax,%eax
108fb5: 74 0b je 108fc2 <rtems_termios_write+0x44>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
108fb7: 57 push %edi
108fb8: 57 push %edi
108fb9: 53 push %ebx
108fba: 56 push %esi
108fbb: ff d0 call *%eax
108fbd: 89 c7 mov %eax,%edi
rtems_semaphore_release (tty->osem);
108fbf: 5b pop %ebx
108fc0: eb 4e jmp 109010 <rtems_termios_write+0x92>
return sc;
}
if (tty->termios.c_oflag & OPOST) {
108fc2: f6 46 34 01 testb $0x1,0x34(%esi)
108fc6: 74 2f je 108ff7 <rtems_termios_write+0x79><== NEVER TAKEN
uint32_t count = args->count;
108fc8: 8b 4b 10 mov 0x10(%ebx),%ecx
char *buffer = args->buffer;
108fcb: 8b 43 0c mov 0xc(%ebx),%eax
108fce: 89 45 e4 mov %eax,-0x1c(%ebp)
while (count--)
108fd1: eb 18 jmp 108feb <rtems_termios_write+0x6d>
oproc (*buffer++, tty);
108fd3: 8b 55 e4 mov -0x1c(%ebp),%edx
108fd6: 0f b6 02 movzbl (%edx),%eax
108fd9: 42 inc %edx
108fda: 89 55 e4 mov %edx,-0x1c(%ebp)
108fdd: 89 f2 mov %esi,%edx
108fdf: 89 4d e0 mov %ecx,-0x20(%ebp)
108fe2: e8 37 fb ff ff call 108b1e <oproc>
108fe7: 8b 4d e0 mov -0x20(%ebp),%ecx
108fea: 49 dec %ecx
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
108feb: 85 c9 test %ecx,%ecx
108fed: 75 e4 jne 108fd3 <rtems_termios_write+0x55>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
108fef: 8b 43 10 mov 0x10(%ebx),%eax
108ff2: 89 43 18 mov %eax,0x18(%ebx)
108ff5: eb 16 jmp 10900d <rtems_termios_write+0x8f>
} else {
rtems_termios_puts (args->buffer, args->count, tty);
108ff7: 51 push %ecx <== NOT EXECUTED
108ff8: 56 push %esi <== NOT EXECUTED
108ff9: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED
108ffc: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED
108fff: e8 fa f9 ff ff call 1089fe <rtems_termios_puts> <== NOT EXECUTED
args->bytes_moved = args->count;
109004: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED
109007: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED
10900a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
}
rtems_semaphore_release (tty->osem);
10900d: 83 ec 0c sub $0xc,%esp
109010: ff 76 18 pushl 0x18(%esi)
109013: e8 3c 12 00 00 call 10a254 <rtems_semaphore_release>
return sc;
109018: 83 c4 10 add $0x10,%esp
}
10901b: 89 f8 mov %edi,%eax
10901d: 8d 65 f4 lea -0xc(%ebp),%esp
109020: 5b pop %ebx
109021: 5e pop %esi
109022: 5f pop %edi
109023: c9 leave
109024: c3 ret
00116398 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
116398: 55 push %ebp
116399: 89 e5 mov %esp,%ebp
11639b: 83 ec 1c sub $0x1c,%esp
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
11639e: 8d 45 f4 lea -0xc(%ebp),%eax
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
1163a1: 50 push %eax
1163a2: ff 75 08 pushl 0x8(%ebp)
1163a5: 68 5c f8 13 00 push $0x13f85c
1163aa: e8 3d 27 00 00 call 118aec <_Objects_Get>
switch ( location ) {
1163af: 83 c4 10 add $0x10,%esp
1163b2: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
1163b6: 75 1e jne 1163d6 <rtems_timer_cancel+0x3e>
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
1163b8: 83 78 38 04 cmpl $0x4,0x38(%eax)
1163bc: 74 0f je 1163cd <rtems_timer_cancel+0x35><== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
1163be: 83 ec 0c sub $0xc,%esp
1163c1: 83 c0 10 add $0x10,%eax
1163c4: 50 push %eax
1163c5: e8 62 41 00 00 call 11a52c <_Watchdog_Remove>
1163ca: 83 c4 10 add $0x10,%esp
_Thread_Enable_dispatch();
1163cd: e8 c0 31 00 00 call 119592 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1163d2: 31 c0 xor %eax,%eax
1163d4: eb 05 jmp 1163db <rtems_timer_cancel+0x43>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1163d6: b8 04 00 00 00 mov $0x4,%eax
}
1163db: c9 leave
1163dc: c3 ret
001167f8 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
1167f8: 55 push %ebp
1167f9: 89 e5 mov %esp,%ebp
1167fb: 57 push %edi
1167fc: 56 push %esi
1167fd: 53 push %ebx
1167fe: 83 ec 1c sub $0x1c,%esp
116801: 8b 7d 0c mov 0xc(%ebp),%edi
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
116804: 8b 35 9c f8 13 00 mov 0x13f89c,%esi
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
11680a: bb 0e 00 00 00 mov $0xe,%ebx
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
11680f: 85 f6 test %esi,%esi
116811: 0f 84 b1 00 00 00 je 1168c8 <rtems_timer_server_fire_when+0xd0>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
116817: b3 0b mov $0xb,%bl
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
116819: 80 3d 28 ef 13 00 00 cmpb $0x0,0x13ef28
116820: 0f 84 a2 00 00 00 je 1168c8 <rtems_timer_server_fire_when+0xd0><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
116826: b3 09 mov $0x9,%bl
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
116828: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
11682c: 0f 84 96 00 00 00 je 1168c8 <rtems_timer_server_fire_when+0xd0>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
116832: 83 ec 0c sub $0xc,%esp
116835: 57 push %edi
116836: e8 b5 d6 ff ff call 113ef0 <_TOD_Validate>
11683b: 83 c4 10 add $0x10,%esp
return RTEMS_INVALID_CLOCK;
11683e: b3 14 mov $0x14,%bl
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
116840: 84 c0 test %al,%al
116842: 0f 84 80 00 00 00 je 1168c8 <rtems_timer_server_fire_when+0xd0>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
116848: 83 ec 0c sub $0xc,%esp
11684b: 57 push %edi
11684c: e8 37 d6 ff ff call 113e88 <_TOD_To_seconds>
116851: 89 c7 mov %eax,%edi
if ( seconds <= _TOD_Seconds_since_epoch() )
116853: 83 c4 10 add $0x10,%esp
116856: 3b 05 a0 ef 13 00 cmp 0x13efa0,%eax
11685c: 76 6a jbe 1168c8 <rtems_timer_server_fire_when+0xd0>
11685e: 51 push %ecx
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
11685f: 8d 45 e4 lea -0x1c(%ebp),%eax
116862: 50 push %eax
116863: ff 75 08 pushl 0x8(%ebp)
116866: 68 5c f8 13 00 push $0x13f85c
11686b: e8 7c 22 00 00 call 118aec <_Objects_Get>
116870: 89 c3 mov %eax,%ebx
switch ( location ) {
116872: 83 c4 10 add $0x10,%esp
116875: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
116879: 75 48 jne 1168c3 <rtems_timer_server_fire_when+0xcb>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
11687b: 83 ec 0c sub $0xc,%esp
11687e: 8d 40 10 lea 0x10(%eax),%eax
116881: 50 push %eax
116882: e8 a5 3c 00 00 call 11a52c <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
116887: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
11688e: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
the_watchdog->routine = routine;
116895: 8b 45 10 mov 0x10(%ebp),%eax
116898: 89 43 2c mov %eax,0x2c(%ebx)
the_watchdog->id = id;
11689b: 8b 45 08 mov 0x8(%ebp),%eax
11689e: 89 43 30 mov %eax,0x30(%ebx)
the_watchdog->user_data = user_data;
1168a1: 8b 45 14 mov 0x14(%ebp),%eax
1168a4: 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();
1168a7: 2b 3d a0 ef 13 00 sub 0x13efa0,%edi
1168ad: 89 7b 1c mov %edi,0x1c(%ebx)
(*timer_server->schedule_operation)( timer_server, the_timer );
1168b0: 58 pop %eax
1168b1: 5a pop %edx
1168b2: 53 push %ebx
1168b3: 56 push %esi
1168b4: ff 56 04 call *0x4(%esi)
_Thread_Enable_dispatch();
1168b7: e8 d6 2c 00 00 call 119592 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
1168bc: 83 c4 10 add $0x10,%esp
1168bf: 31 db xor %ebx,%ebx
1168c1: eb 05 jmp 1168c8 <rtems_timer_server_fire_when+0xd0>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
1168c3: bb 04 00 00 00 mov $0x4,%ebx
}
1168c8: 89 d8 mov %ebx,%eax
1168ca: 8d 65 f4 lea -0xc(%ebp),%esp
1168cd: 5b pop %ebx
1168ce: 5e pop %esi
1168cf: 5f pop %edi
1168d0: c9 leave
1168d1: c3 ret
0010b14d <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
10b14d: 55 push %ebp
10b14e: 89 e5 mov %esp,%ebp
10b150: 57 push %edi
10b151: 56 push %esi
10b152: 53 push %ebx
10b153: 83 ec 1c sub $0x1c,%esp
10b156: 89 c3 mov %eax,%ebx
10b158: 89 55 e4 mov %edx,-0x1c(%ebp)
10b15b: 89 4d e0 mov %ecx,-0x20(%ebp)
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
10b15e: a9 00 00 00 20 test $0x20000000,%eax
10b163: 74 2c je 10b191 <rtems_verror+0x44>
if (rtems_panic_in_progress++)
10b165: a1 68 b3 12 00 mov 0x12b368,%eax
10b16a: 8d 50 01 lea 0x1(%eax),%edx
10b16d: 89 15 68 b3 12 00 mov %edx,0x12b368
10b173: 85 c0 test %eax,%eax
10b175: 74 0b je 10b182 <rtems_verror+0x35> <== ALWAYS TAKEN
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10b177: a1 b4 b4 12 00 mov 0x12b4b4,%eax <== NOT EXECUTED
10b17c: 40 inc %eax <== NOT EXECUTED
10b17d: a3 b4 b4 12 00 mov %eax,0x12b4b4 <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
10b182: 31 f6 xor %esi,%esi
if (error_flag & RTEMS_ERROR_PANIC) {
if (rtems_panic_in_progress++)
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
10b184: 83 3d 68 b3 12 00 02 cmpl $0x2,0x12b368
10b18b: 0f 8f da 00 00 00 jg 10b26b <rtems_verror+0x11e> <== NEVER TAKEN
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
10b191: 83 ec 0c sub $0xc,%esp
10b194: a1 c0 91 12 00 mov 0x1291c0,%eax
10b199: ff 70 08 pushl 0x8(%eax)
10b19c: e8 5b ab 00 00 call 115cfc <fflush>
status = error_flag & ~RTEMS_ERROR_MASK;
10b1a1: 89 df mov %ebx,%edi
10b1a3: 81 e7 ff ff ff 8f and $0x8fffffff,%edi
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
10b1a9: 83 c4 10 add $0x10,%esp
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
int local_errno = 0;
10b1ac: 31 f6 xor %esi,%esi
}
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
10b1ae: 81 e3 00 00 00 40 and $0x40000000,%ebx
10b1b4: 74 07 je 10b1bd <rtems_verror+0x70>
local_errno = errno;
10b1b6: e8 a9 a7 00 00 call 115964 <__errno>
10b1bb: 8b 30 mov (%eax),%esi
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
10b1bd: 53 push %ebx
10b1be: ff 75 e0 pushl -0x20(%ebp)
10b1c1: ff 75 e4 pushl -0x1c(%ebp)
10b1c4: a1 c0 91 12 00 mov 0x1291c0,%eax
10b1c9: ff 70 0c pushl 0xc(%eax)
10b1cc: e8 d3 10 01 00 call 11c2a4 <vfprintf>
10b1d1: 89 c3 mov %eax,%ebx
if (status)
10b1d3: 83 c4 10 add $0x10,%esp
10b1d6: 85 ff test %edi,%edi
10b1d8: 74 24 je 10b1fe <rtems_verror+0xb1>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
10b1da: 83 ec 0c sub $0xc,%esp
10b1dd: 57 push %edi
10b1de: e8 55 ff ff ff call 10b138 <rtems_status_text>
10b1e3: 83 c4 0c add $0xc,%esp
10b1e6: 50 push %eax
10b1e7: 68 e7 43 12 00 push $0x1243e7
10b1ec: a1 c0 91 12 00 mov 0x1291c0,%eax
10b1f1: ff 70 0c pushl 0xc(%eax)
10b1f4: e8 f7 ae 00 00 call 1160f0 <fprintf>
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
10b1f9: 01 c3 add %eax,%ebx
10b1fb: 83 c4 10 add $0x10,%esp
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
10b1fe: 83 fe 00 cmp $0x0,%esi
10b201: 74 40 je 10b243 <rtems_verror+0xf6>
if ((local_errno > 0) && *strerror(local_errno))
10b203: 7e 25 jle 10b22a <rtems_verror+0xdd>
10b205: 83 ec 0c sub $0xc,%esp
10b208: 56 push %esi
10b209: e8 8e b7 00 00 call 11699c <strerror>
10b20e: 83 c4 10 add $0x10,%esp
10b211: 80 38 00 cmpb $0x0,(%eax)
10b214: 74 14 je 10b22a <rtems_verror+0xdd> <== NEVER TAKEN
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
10b216: 83 ec 0c sub $0xc,%esp
10b219: 56 push %esi
10b21a: e8 7d b7 00 00 call 11699c <strerror>
10b21f: 83 c4 0c add $0xc,%esp
10b222: 50 push %eax
10b223: 68 f5 43 12 00 push $0x1243f5
10b228: eb 07 jmp 10b231 <rtems_verror+0xe4>
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
10b22a: 51 push %ecx
10b22b: 56 push %esi
10b22c: 68 02 44 12 00 push $0x124402
10b231: a1 c0 91 12 00 mov 0x1291c0,%eax
10b236: ff 70 0c pushl 0xc(%eax)
10b239: e8 b2 ae 00 00 call 1160f0 <fprintf>
10b23e: 01 c3 add %eax,%ebx
10b240: 83 c4 10 add $0x10,%esp
}
chars_written += fprintf(stderr, "\n");
10b243: 52 push %edx
10b244: 52 push %edx
10b245: 68 64 4b 12 00 push $0x124b64
10b24a: a1 c0 91 12 00 mov 0x1291c0,%eax
10b24f: ff 70 0c pushl 0xc(%eax)
10b252: e8 99 ae 00 00 call 1160f0 <fprintf>
10b257: 8d 34 18 lea (%eax,%ebx,1),%esi
(void) fflush(stderr);
10b25a: 58 pop %eax
10b25b: a1 c0 91 12 00 mov 0x1291c0,%eax
10b260: ff 70 0c pushl 0xc(%eax)
10b263: e8 94 aa 00 00 call 115cfc <fflush>
return chars_written;
10b268: 83 c4 10 add $0x10,%esp
}
10b26b: 89 f0 mov %esi,%eax
10b26d: 8d 65 f4 lea -0xc(%ebp),%esp
10b270: 5b pop %ebx
10b271: 5e pop %esi
10b272: 5f pop %edi
10b273: c9 leave
10b274: c3 ret
00107930 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
107930: 55 push %ebp
107931: 89 e5 mov %esp,%ebp
107933: 57 push %edi
107934: 56 push %esi
107935: 53 push %ebx
107936: 83 ec 3c sub $0x3c,%esp
107939: 89 c3 mov %eax,%ebx
10793b: 89 55 e0 mov %edx,-0x20(%ebp)
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
int sign = 0;
10793e: 31 f6 xor %esi,%esi
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
107940: c7 45 e4 ff ff ff 7f movl $0x7fffffff,-0x1c(%ebp)
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
107947: 31 ff xor %edi,%edi
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
107949: 89 7d c4 mov %edi,-0x3c(%ebp)
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
10794c: 8b 43 04 mov 0x4(%ebx),%eax
10794f: 48 dec %eax
107950: 89 43 04 mov %eax,0x4(%ebx)
107953: 85 c0 test %eax,%eax
107955: 79 15 jns 10796c <scanInt+0x3c> <== ALWAYS TAKEN
107957: 50 push %eax <== NOT EXECUTED
107958: 50 push %eax <== NOT EXECUTED
107959: 53 push %ebx <== NOT EXECUTED
10795a: ff 35 40 4d 12 00 pushl 0x124d40 <== NOT EXECUTED
107960: e8 ff be 00 00 call 113864 <__srget_r> <== NOT EXECUTED
107965: 89 c1 mov %eax,%ecx <== NOT EXECUTED
107967: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
10796a: eb 08 jmp 107974 <scanInt+0x44> <== NOT EXECUTED
10796c: 8b 03 mov (%ebx),%eax
10796e: 0f b6 08 movzbl (%eax),%ecx
107971: 40 inc %eax
107972: 89 03 mov %eax,(%ebx)
if (c == ':')
107974: 83 f9 3a cmp $0x3a,%ecx
107977: 74 4a je 1079c3 <scanInt+0x93>
break;
if (sign == 0) {
107979: 85 f6 test %esi,%esi
10797b: 75 11 jne 10798e <scanInt+0x5e>
if (c == '-') {
sign = -1;
limit++;
continue;
}
sign = 1;
10797d: 66 be 01 00 mov $0x1,%si
for (;;) {
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
107981: 83 f9 2d cmp $0x2d,%ecx
107984: 75 08 jne 10798e <scanInt+0x5e>
sign = -1;
limit++;
107986: ff 45 e4 incl -0x1c(%ebp)
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
107989: 83 ce ff or $0xffffffff,%esi
limit++;
continue;
10798c: eb be jmp 10794c <scanInt+0x1c>
}
sign = 1;
}
if (!isdigit(c))
10798e: a1 3c 4d 12 00 mov 0x124d3c,%eax
107993: f6 44 08 01 04 testb $0x4,0x1(%eax,%ecx,1)
107998: 74 41 je 1079db <scanInt+0xab>
return 0;
d = c - '0';
if ((i > (limit / 10))
10799a: 8b 45 e4 mov -0x1c(%ebp),%eax
10799d: bf 0a 00 00 00 mov $0xa,%edi
1079a2: 31 d2 xor %edx,%edx
1079a4: f7 f7 div %edi
1079a6: 89 55 d4 mov %edx,-0x2c(%ebp)
1079a9: 39 45 c4 cmp %eax,-0x3c(%ebp)
1079ac: 77 2d ja 1079db <scanInt+0xab>
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
1079ae: 83 e9 30 sub $0x30,%ecx
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
1079b1: 39 45 c4 cmp %eax,-0x3c(%ebp)
1079b4: 75 04 jne 1079ba <scanInt+0x8a>
1079b6: 39 d1 cmp %edx,%ecx
1079b8: 77 21 ja 1079db <scanInt+0xab> <== ALWAYS TAKEN
return 0;
i = i * 10 + d;
1079ba: 6b 7d c4 0a imul $0xa,-0x3c(%ebp),%edi
1079be: 8d 3c 39 lea (%ecx,%edi,1),%edi
1079c1: eb 86 jmp 107949 <scanInt+0x19>
1079c3: 8b 7d c4 mov -0x3c(%ebp),%edi
}
if (sign == 0)
return 0;
1079c6: 31 c0 xor %eax,%eax
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
1079c8: 85 f6 test %esi,%esi
1079ca: 74 11 je 1079dd <scanInt+0xad> <== NEVER TAKEN
return 0;
*val = i * sign;
1079cc: 0f af f7 imul %edi,%esi
1079cf: 8b 45 e0 mov -0x20(%ebp),%eax
1079d2: 89 30 mov %esi,(%eax)
return 1;
1079d4: b8 01 00 00 00 mov $0x1,%eax
1079d9: eb 02 jmp 1079dd <scanInt+0xad>
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
1079db: 31 c0 xor %eax,%eax
}
if (sign == 0)
return 0;
*val = i * sign;
return 1;
}
1079dd: 8d 65 f4 lea -0xc(%ebp),%esp
1079e0: 5b pop %ebx
1079e1: 5e pop %esi
1079e2: 5f pop %edi
1079e3: c9 leave
1079e4: c3 ret
00107a70 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
107a70: 55 push %ebp
107a71: 89 e5 mov %esp,%ebp
107a73: 57 push %edi
107a74: 56 push %esi
107a75: 53 push %ebx
107a76: 83 ec 34 sub $0x34,%esp
107a79: 89 c7 mov %eax,%edi
107a7b: 89 d3 mov %edx,%ebx
107a7d: 89 4d d4 mov %ecx,-0x2c(%ebp)
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
107a80: 6a 00 push $0x0
107a82: 8d 45 08 lea 0x8(%ebp),%eax
107a85: 50 push %eax
107a86: 8d 4d d4 lea -0x2c(%ebp),%ecx
107a89: 89 f8 mov %edi,%eax
107a8b: e8 55 ff ff ff call 1079e5 <scanString>
107a90: 83 c4 10 add $0x10,%esp
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
107a93: 31 f6 xor %esi,%esi
{
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
107a95: 85 c0 test %eax,%eax
107a97: 0f 84 c2 00 00 00 je 107b5f <scangr+0xef>
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
107a9d: 50 push %eax
107a9e: 50 push %eax
107a9f: 8d 53 04 lea 0x4(%ebx),%edx
107aa2: 6a 00 push $0x0
107aa4: 8d 45 08 lea 0x8(%ebp),%eax
107aa7: 50 push %eax
107aa8: 8d 4d d4 lea -0x2c(%ebp),%ecx
107aab: 89 f8 mov %edi,%eax
107aad: e8 33 ff ff ff call 1079e5 <scanString>
107ab2: 83 c4 10 add $0x10,%esp
107ab5: 85 c0 test %eax,%eax
107ab7: 0f 84 a2 00 00 00 je 107b5f <scangr+0xef> <== NEVER TAKEN
|| !scanInt(fp, &grgid)
107abd: 8d 55 e4 lea -0x1c(%ebp),%edx
107ac0: 89 f8 mov %edi,%eax
107ac2: e8 69 fe ff ff call 107930 <scanInt>
107ac7: 85 c0 test %eax,%eax
107ac9: 0f 84 90 00 00 00 je 107b5f <scangr+0xef> <== NEVER TAKEN
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
107acf: 51 push %ecx
107ad0: 51 push %ecx
107ad1: 8d 55 e0 lea -0x20(%ebp),%edx
107ad4: 6a 01 push $0x1
107ad6: 8d 45 08 lea 0x8(%ebp),%eax
107ad9: 50 push %eax
107ada: 8d 4d d4 lea -0x2c(%ebp),%ecx
107add: 89 f8 mov %edi,%eax
107adf: e8 01 ff ff ff call 1079e5 <scanString>
107ae4: 83 c4 10 add $0x10,%esp
107ae7: 85 c0 test %eax,%eax
107ae9: 74 74 je 107b5f <scangr+0xef> <== NEVER TAKEN
return 0;
grp->gr_gid = grgid;
107aeb: 8b 45 e4 mov -0x1c(%ebp),%eax
107aee: 66 89 43 08 mov %ax,0x8(%ebx)
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107af2: 8b 4d e0 mov -0x20(%ebp),%ecx
107af5: 89 ca mov %ecx,%edx
107af7: b8 01 00 00 00 mov $0x1,%eax
107afc: 89 c6 mov %eax,%esi
107afe: eb 0b jmp 107b0b <scangr+0x9b>
if(*cp == ',')
memcount++;
107b00: 3c 2c cmp $0x2c,%al
107b02: 0f 94 c0 sete %al
107b05: 0f b6 c0 movzbl %al,%eax
107b08: 01 c6 add %eax,%esi
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107b0a: 42 inc %edx
107b0b: 8a 02 mov (%edx),%al
107b0d: 84 c0 test %al,%al
107b0f: 75 ef jne 107b00 <scangr+0x90>
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
107b11: 8d 04 b5 13 00 00 00 lea 0x13(,%esi,4),%eax
return 0;
107b18: 31 f6 xor %esi,%esi
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
107b1a: 39 45 08 cmp %eax,0x8(%ebp)
107b1d: 72 40 jb 107b5f <scangr+0xef> <== NEVER TAKEN
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
107b1f: 8b 45 d4 mov -0x2c(%ebp),%eax
107b22: 83 c0 0f add $0xf,%eax
107b25: 83 e0 f0 and $0xfffffff0,%eax
107b28: 89 43 0c mov %eax,0xc(%ebx)
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
107b2b: 89 08 mov %ecx,(%eax)
}
/*
* Extract a single group record from the database
*/
static int scangr(
107b2d: 8b 45 e0 mov -0x20(%ebp),%eax
107b30: 40 inc %eax
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107b31: ba 01 00 00 00 mov $0x1,%edx
107b36: eb 11 jmp 107b49 <scangr+0xd9>
if(*cp == ',') {
107b38: 80 f9 2c cmp $0x2c,%cl
107b3b: 75 0b jne 107b48 <scangr+0xd8>
*cp = '\0';
107b3d: c6 40 ff 00 movb $0x0,-0x1(%eax)
grp->gr_mem[memcount++] = cp + 1;
107b41: 8b 4b 0c mov 0xc(%ebx),%ecx
107b44: 89 04 91 mov %eax,(%ecx,%edx,4)
107b47: 42 inc %edx
107b48: 40 inc %eax
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
107b49: 8a 48 ff mov -0x1(%eax),%cl
107b4c: 84 c9 test %cl,%cl
107b4e: 75 e8 jne 107b38 <scangr+0xc8>
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
107b50: 8b 43 0c mov 0xc(%ebx),%eax
107b53: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4)
return 1;
107b5a: be 01 00 00 00 mov $0x1,%esi
}
107b5f: 89 f0 mov %esi,%eax
107b61: 8d 65 f4 lea -0xc(%ebp),%esp
107b64: 5b pop %ebx
107b65: 5e pop %esi
107b66: 5f pop %edi
107b67: c9 leave
107b68: c3 ret
00107b69 <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
107b69: 55 push %ebp
107b6a: 89 e5 mov %esp,%ebp
107b6c: 57 push %edi
107b6d: 56 push %esi
107b6e: 53 push %ebx
107b6f: 83 ec 34 sub $0x34,%esp
107b72: 89 c6 mov %eax,%esi
107b74: 89 d3 mov %edx,%ebx
107b76: 89 4d d4 mov %ecx,-0x2c(%ebp)
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
107b79: 8d 7d d4 lea -0x2c(%ebp),%edi
107b7c: 6a 00 push $0x0
107b7e: 8d 45 08 lea 0x8(%ebp),%eax
107b81: 50 push %eax
107b82: 89 f9 mov %edi,%ecx
107b84: 89 f0 mov %esi,%eax
107b86: e8 5a fe ff ff call 1079e5 <scanString>
107b8b: 83 c4 10 add $0x10,%esp
|| !scanInt(fp, &pwgid)
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
107b8e: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp)
size_t bufsize
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
107b95: 85 c0 test %eax,%eax
107b97: 0f 84 c4 00 00 00 je 107c61 <scanpw+0xf8>
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
107b9d: 51 push %ecx
107b9e: 51 push %ecx
107b9f: 8d 53 04 lea 0x4(%ebx),%edx
107ba2: 6a 00 push $0x0
107ba4: 8d 45 08 lea 0x8(%ebp),%eax
107ba7: 50 push %eax
107ba8: 89 f9 mov %edi,%ecx
107baa: 89 f0 mov %esi,%eax
107bac: e8 34 fe ff ff call 1079e5 <scanString>
107bb1: 83 c4 10 add $0x10,%esp
107bb4: 85 c0 test %eax,%eax
107bb6: 0f 84 a5 00 00 00 je 107c61 <scanpw+0xf8> <== NEVER TAKEN
|| !scanInt(fp, &pwuid)
107bbc: 8d 55 e4 lea -0x1c(%ebp),%edx
107bbf: 89 f0 mov %esi,%eax
107bc1: e8 6a fd ff ff call 107930 <scanInt>
107bc6: 85 c0 test %eax,%eax
107bc8: 0f 84 93 00 00 00 je 107c61 <scanpw+0xf8>
|| !scanInt(fp, &pwgid)
107bce: 8d 55 e0 lea -0x20(%ebp),%edx
107bd1: 89 f0 mov %esi,%eax
107bd3: e8 58 fd ff ff call 107930 <scanInt>
107bd8: 85 c0 test %eax,%eax
107bda: 0f 84 81 00 00 00 je 107c61 <scanpw+0xf8>
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
107be0: 52 push %edx
107be1: 52 push %edx
107be2: 8d 53 0c lea 0xc(%ebx),%edx
107be5: 6a 00 push $0x0
107be7: 8d 45 08 lea 0x8(%ebp),%eax
107bea: 50 push %eax
107beb: 89 f9 mov %edi,%ecx
107bed: 89 f0 mov %esi,%eax
107bef: e8 f1 fd ff ff call 1079e5 <scanString>
107bf4: 83 c4 10 add $0x10,%esp
107bf7: 85 c0 test %eax,%eax
107bf9: 74 66 je 107c61 <scanpw+0xf8> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
107bfb: 50 push %eax
107bfc: 50 push %eax
107bfd: 8d 53 10 lea 0x10(%ebx),%edx
107c00: 6a 00 push $0x0
107c02: 8d 45 08 lea 0x8(%ebp),%eax
107c05: 50 push %eax
107c06: 89 f9 mov %edi,%ecx
107c08: 89 f0 mov %esi,%eax
107c0a: e8 d6 fd ff ff call 1079e5 <scanString>
107c0f: 83 c4 10 add $0x10,%esp
107c12: 85 c0 test %eax,%eax
107c14: 74 4b je 107c61 <scanpw+0xf8> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
107c16: 51 push %ecx
107c17: 51 push %ecx
107c18: 8d 53 14 lea 0x14(%ebx),%edx
107c1b: 6a 00 push $0x0
107c1d: 8d 45 08 lea 0x8(%ebp),%eax
107c20: 50 push %eax
107c21: 89 f9 mov %edi,%ecx
107c23: 89 f0 mov %esi,%eax
107c25: e8 bb fd ff ff call 1079e5 <scanString>
107c2a: 83 c4 10 add $0x10,%esp
107c2d: 85 c0 test %eax,%eax
107c2f: 74 30 je 107c61 <scanpw+0xf8> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
107c31: 52 push %edx
107c32: 52 push %edx
107c33: 8d 53 18 lea 0x18(%ebx),%edx
107c36: 6a 01 push $0x1
107c38: 8d 45 08 lea 0x8(%ebp),%eax
107c3b: 50 push %eax
107c3c: 89 f9 mov %edi,%ecx
107c3e: 89 f0 mov %esi,%eax
107c40: e8 a0 fd ff ff call 1079e5 <scanString>
107c45: 83 c4 10 add $0x10,%esp
107c48: 85 c0 test %eax,%eax
107c4a: 74 15 je 107c61 <scanpw+0xf8>
return 0;
pwd->pw_uid = pwuid;
107c4c: 8b 45 e4 mov -0x1c(%ebp),%eax
107c4f: 66 89 43 08 mov %ax,0x8(%ebx)
pwd->pw_gid = pwgid;
107c53: 8b 45 e0 mov -0x20(%ebp),%eax
107c56: 66 89 43 0a mov %ax,0xa(%ebx)
return 1;
107c5a: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp)
}
107c61: 8b 45 d0 mov -0x30(%ebp),%eax
107c64: 8d 65 f4 lea -0xc(%ebp),%esp
107c67: 5b pop %ebx
107c68: 5e pop %esi
107c69: 5f pop %edi
107c6a: c9 leave
107c6b: c3 ret
0010a8f4 <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
10a8f4: 55 push %ebp
10a8f5: 89 e5 mov %esp,%ebp
10a8f7: 83 ec 08 sub $0x8,%esp
10a8fa: 8b 4d 08 mov 0x8(%ebp),%ecx
switch ( policy ) {
10a8fd: 83 f9 04 cmp $0x4,%ecx
10a900: 77 0b ja 10a90d <sched_get_priority_max+0x19>
10a902: b8 01 00 00 00 mov $0x1,%eax
10a907: d3 e0 shl %cl,%eax
10a909: a8 17 test $0x17,%al
10a90b: 75 10 jne 10a91d <sched_get_priority_max+0x29><== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10a90d: e8 ba 73 00 00 call 111ccc <__errno>
10a912: c7 00 16 00 00 00 movl $0x16,(%eax)
10a918: 83 c8 ff or $0xffffffff,%eax
10a91b: eb 08 jmp 10a925 <sched_get_priority_max+0x31>
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
10a91d: 0f b6 05 48 22 12 00 movzbl 0x122248,%eax
10a924: 48 dec %eax
}
10a925: c9 leave
10a926: c3 ret
0010a928 <sched_get_priority_min>:
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
10a928: 55 push %ebp
10a929: 89 e5 mov %esp,%ebp
10a92b: 83 ec 08 sub $0x8,%esp
10a92e: 8b 4d 08 mov 0x8(%ebp),%ecx
switch ( policy ) {
10a931: 83 f9 04 cmp $0x4,%ecx
10a934: 77 11 ja 10a947 <sched_get_priority_min+0x1f>
10a936: ba 01 00 00 00 mov $0x1,%edx
10a93b: d3 e2 shl %cl,%edx
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
10a93d: b8 01 00 00 00 mov $0x1,%eax
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
10a942: 80 e2 17 and $0x17,%dl
10a945: 75 0e jne 10a955 <sched_get_priority_min+0x2d><== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
10a947: e8 80 73 00 00 call 111ccc <__errno>
10a94c: c7 00 16 00 00 00 movl $0x16,(%eax)
10a952: 83 c8 ff or $0xffffffff,%eax
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
10a955: c9 leave
10a956: c3 ret
0010a958 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
10a958: 55 push %ebp
10a959: 89 e5 mov %esp,%ebp
10a95b: 56 push %esi
10a95c: 53 push %ebx
10a95d: 8b 75 08 mov 0x8(%ebp),%esi
10a960: 8b 5d 0c mov 0xc(%ebp),%ebx
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
10a963: 85 f6 test %esi,%esi
10a965: 74 16 je 10a97d <sched_rr_get_interval+0x25><== NEVER TAKEN
10a967: e8 b4 d0 ff ff call 107a20 <getpid>
10a96c: 39 c6 cmp %eax,%esi
10a96e: 74 0d je 10a97d <sched_rr_get_interval+0x25>
rtems_set_errno_and_return_minus_one( ESRCH );
10a970: e8 57 73 00 00 call 111ccc <__errno>
10a975: c7 00 03 00 00 00 movl $0x3,(%eax)
10a97b: eb 0f jmp 10a98c <sched_rr_get_interval+0x34>
if ( !interval )
10a97d: 85 db test %ebx,%ebx
10a97f: 75 10 jne 10a991 <sched_rr_get_interval+0x39>
rtems_set_errno_and_return_minus_one( EINVAL );
10a981: e8 46 73 00 00 call 111ccc <__errno>
10a986: c7 00 16 00 00 00 movl $0x16,(%eax)
10a98c: 83 c8 ff or $0xffffffff,%eax
10a98f: eb 13 jmp 10a9a4 <sched_rr_get_interval+0x4c>
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
10a991: 50 push %eax
10a992: 50 push %eax
10a993: 53 push %ebx
10a994: ff 35 20 63 12 00 pushl 0x126320
10a99a: e8 a9 30 00 00 call 10da48 <_Timespec_From_ticks>
return 0;
10a99f: 83 c4 10 add $0x10,%esp
10a9a2: 31 c0 xor %eax,%eax
}
10a9a4: 8d 65 f8 lea -0x8(%ebp),%esp
10a9a7: 5b pop %ebx
10a9a8: 5e pop %esi
10a9a9: c9 leave
10a9aa: c3 ret
0010cff0 <sem_init>:
int sem_init(
sem_t *sem,
int pshared,
unsigned int value
)
{
10cff0: 55 push %ebp
10cff1: 89 e5 mov %esp,%ebp
10cff3: 53 push %ebx
10cff4: 83 ec 14 sub $0x14,%esp
10cff7: 8b 5d 08 mov 0x8(%ebp),%ebx
int status;
POSIX_Semaphore_Control *the_semaphore;
if ( !sem )
10cffa: 85 db test %ebx,%ebx
10cffc: 75 10 jne 10d00e <sem_init+0x1e> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10cffe: e8 d5 7f 00 00 call 114fd8 <__errno>
10d003: c7 00 16 00 00 00 movl $0x16,(%eax)
10d009: 83 c8 ff or $0xffffffff,%eax
10d00c: eb 21 jmp 10d02f <sem_init+0x3f>
status = _POSIX_Semaphore_Create_support(
10d00e: 8d 45 f4 lea -0xc(%ebp),%eax
10d011: 50 push %eax
10d012: ff 75 10 pushl 0x10(%ebp)
10d015: ff 75 0c pushl 0xc(%ebp)
10d018: 6a 00 push $0x0
10d01a: e8 bd 58 00 00 call 1128dc <_POSIX_Semaphore_Create_support>
pshared,
value,
&the_semaphore
);
if ( status != -1 )
10d01f: 83 c4 10 add $0x10,%esp
10d022: 83 f8 ff cmp $0xffffffff,%eax
10d025: 74 08 je 10d02f <sem_init+0x3f>
*sem = the_semaphore->Object.id;
10d027: 8b 55 f4 mov -0xc(%ebp),%edx
10d02a: 8b 52 08 mov 0x8(%edx),%edx
10d02d: 89 13 mov %edx,(%ebx)
return status;
}
10d02f: 8b 5d fc mov -0x4(%ebp),%ebx
10d032: c9 leave
10d033: c3 ret
0010d034 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
10d034: 55 push %ebp
10d035: 89 e5 mov %esp,%ebp
10d037: 57 push %edi
10d038: 56 push %esi
10d039: 53 push %ebx
10d03a: 83 ec 2c sub $0x2c,%esp
10d03d: 8b 75 08 mov 0x8(%ebp),%esi
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10d040: a1 e8 ae 12 00 mov 0x12aee8,%eax
10d045: 40 inc %eax
10d046: a3 e8 ae 12 00 mov %eax,0x12aee8
va_list arg;
mode_t mode;
unsigned int value = 0;
10d04b: 31 ff xor %edi,%edi
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
10d04d: 8b 45 0c mov 0xc(%ebp),%eax
10d050: 25 00 02 00 00 and $0x200,%eax
10d055: 89 45 d4 mov %eax,-0x2c(%ebp)
10d058: 74 03 je 10d05d <sem_open+0x29>
va_start(arg, oflag);
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
10d05a: 8b 7d 14 mov 0x14(%ebp),%edi
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
10d05d: 52 push %edx
10d05e: 52 push %edx
10d05f: 8d 45 e4 lea -0x1c(%ebp),%eax
10d062: 50 push %eax
10d063: 56 push %esi
10d064: e8 a7 59 00 00 call 112a10 <_POSIX_Semaphore_Name_to_id>
10d069: 89 c3 mov %eax,%ebx
* and we can just return a pointer to the id. Otherwise we may
* need to check to see if this is a "semaphore does not exist"
* or some other miscellaneous error on the name.
*/
if ( status ) {
10d06b: 83 c4 10 add $0x10,%esp
10d06e: 85 c0 test %eax,%eax
10d070: 74 19 je 10d08b <sem_open+0x57>
/*
* Unless provided a valid name that did not already exist
* and we are willing to create then it is an error.
*/
if ( !( status == ENOENT && (oflag & O_CREAT) ) ) {
10d072: 83 f8 02 cmp $0x2,%eax
10d075: 75 06 jne 10d07d <sem_open+0x49> <== NEVER TAKEN
10d077: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
10d07b: 75 59 jne 10d0d6 <sem_open+0xa2>
_Thread_Enable_dispatch();
10d07d: e8 30 28 00 00 call 10f8b2 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
10d082: e8 51 7f 00 00 call 114fd8 <__errno>
10d087: 89 18 mov %ebx,(%eax)
10d089: eb 1f jmp 10d0aa <sem_open+0x76>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
10d08b: 8b 45 0c mov 0xc(%ebp),%eax
10d08e: 25 00 0a 00 00 and $0xa00,%eax
10d093: 3d 00 0a 00 00 cmp $0xa00,%eax
10d098: 75 15 jne 10d0af <sem_open+0x7b>
_Thread_Enable_dispatch();
10d09a: e8 13 28 00 00 call 10f8b2 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
10d09f: e8 34 7f 00 00 call 114fd8 <__errno>
10d0a4: c7 00 11 00 00 00 movl $0x11,(%eax)
10d0aa: 83 c8 ff or $0xffffffff,%eax
10d0ad: eb 4a jmp 10d0f9 <sem_open+0xc5>
10d0af: 50 push %eax
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
10d0b0: 8d 45 dc lea -0x24(%ebp),%eax
10d0b3: 50 push %eax
10d0b4: ff 75 e4 pushl -0x1c(%ebp)
10d0b7: 68 8c b1 12 00 push $0x12b18c
10d0bc: e8 d7 1c 00 00 call 10ed98 <_Objects_Get>
10d0c1: 89 45 e0 mov %eax,-0x20(%ebp)
the_semaphore->open_count += 1;
10d0c4: ff 40 18 incl 0x18(%eax)
_Thread_Enable_dispatch();
10d0c7: e8 e6 27 00 00 call 10f8b2 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
10d0cc: e8 e1 27 00 00 call 10f8b2 <_Thread_Enable_dispatch>
goto return_id;
10d0d1: 83 c4 10 add $0x10,%esp
10d0d4: eb 1d jmp 10d0f3 <sem_open+0xbf>
/*
* At this point, the semaphore does not exist and everything has been
* checked. We should go ahead and create a semaphore.
*/
status =_POSIX_Semaphore_Create_support(
10d0d6: 8d 45 e0 lea -0x20(%ebp),%eax
10d0d9: 50 push %eax
10d0da: 57 push %edi
10d0db: 6a 00 push $0x0
10d0dd: 56 push %esi
10d0de: e8 f9 57 00 00 call 1128dc <_POSIX_Semaphore_Create_support>
10d0e3: 89 c3 mov %eax,%ebx
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
10d0e5: e8 c8 27 00 00 call 10f8b2 <_Thread_Enable_dispatch>
if ( status == -1 )
10d0ea: 83 c4 10 add $0x10,%esp
return SEM_FAILED;
10d0ed: 83 c8 ff or $0xffffffff,%eax
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
if ( status == -1 )
10d0f0: 43 inc %ebx
10d0f1: 74 06 je 10d0f9 <sem_open+0xc5>
return_id:
#if defined(RTEMS_USE_16_BIT_OBJECT)
the_semaphore->Semaphore_id = the_semaphore->Object.id;
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
10d0f3: 8b 45 e0 mov -0x20(%ebp),%eax
10d0f6: 83 c0 08 add $0x8,%eax
#endif
return id;
}
10d0f9: 8d 65 f4 lea -0xc(%ebp),%esp
10d0fc: 5b pop %ebx
10d0fd: 5e pop %esi
10d0fe: 5f pop %edi
10d0ff: c9 leave
10d100: c3 ret
0010a7d0 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
10a7d0: 55 push %ebp
10a7d1: 89 e5 mov %esp,%ebp
10a7d3: 57 push %edi
10a7d4: 56 push %esi
10a7d5: 53 push %ebx
10a7d6: 83 ec 1c sub $0x1c,%esp
10a7d9: 8b 5d 08 mov 0x8(%ebp),%ebx
10a7dc: 8b 55 0c mov 0xc(%ebp),%edx
10a7df: 8b 45 10 mov 0x10(%ebp),%eax
ISR_Level level;
if ( oact )
10a7e2: 85 c0 test %eax,%eax
10a7e4: 74 12 je 10a7f8 <sigaction+0x28>
*oact = _POSIX_signals_Vectors[ sig ];
10a7e6: 6b f3 0c imul $0xc,%ebx,%esi
10a7e9: 81 c6 3c 7a 12 00 add $0x127a3c,%esi
10a7ef: b9 03 00 00 00 mov $0x3,%ecx
10a7f4: 89 c7 mov %eax,%edi
10a7f6: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
if ( !sig )
10a7f8: 85 db test %ebx,%ebx
10a7fa: 74 0d je 10a809 <sigaction+0x39>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10a7fc: 8d 43 ff lea -0x1(%ebx),%eax
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
10a7ff: 83 f8 1f cmp $0x1f,%eax
10a802: 77 05 ja 10a809 <sigaction+0x39>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
10a804: 83 fb 09 cmp $0x9,%ebx
10a807: 75 10 jne 10a819 <sigaction+0x49>
rtems_set_errno_and_return_minus_one( EINVAL );
10a809: e8 52 77 00 00 call 111f60 <__errno>
10a80e: c7 00 16 00 00 00 movl $0x16,(%eax)
10a814: 83 c8 ff or $0xffffffff,%eax
10a817: eb 57 jmp 10a870 <sigaction+0xa0>
* now (signals not posted when SIG_IGN).
* + If we are now ignoring a signal that was previously pending,
* we clear the pending signal indicator.
*/
return 0;
10a819: 31 c0 xor %eax,%eax
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
10a81b: 85 d2 test %edx,%edx
10a81d: 74 51 je 10a870 <sigaction+0xa0> <== NEVER TAKEN
/*
* Unless the user is installing the default signal actions, then
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
10a81f: 9c pushf
10a820: fa cli
10a821: 8f 45 e4 popl -0x1c(%ebp)
if ( act->sa_handler == SIG_DFL ) {
10a824: 83 7a 08 00 cmpl $0x0,0x8(%edx)
10a828: 75 1a jne 10a844 <sigaction+0x74>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
10a82a: 6b f3 0c imul $0xc,%ebx,%esi
10a82d: 8d 86 3c 7a 12 00 lea 0x127a3c(%esi),%eax
10a833: 81 c6 c4 11 12 00 add $0x1211c4,%esi
10a839: b9 03 00 00 00 mov $0x3,%ecx
10a83e: 89 c7 mov %eax,%edi
10a840: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10a842: eb 26 jmp 10a86a <sigaction+0x9a>
} else {
_POSIX_signals_Clear_process_signals( sig );
10a844: 83 ec 0c sub $0xc,%esp
10a847: 53 push %ebx
10a848: 89 55 e0 mov %edx,-0x20(%ebp)
10a84b: e8 ac 4e 00 00 call 10f6fc <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
10a850: 6b db 0c imul $0xc,%ebx,%ebx
10a853: 81 c3 3c 7a 12 00 add $0x127a3c,%ebx
10a859: b9 03 00 00 00 mov $0x3,%ecx
10a85e: 8b 55 e0 mov -0x20(%ebp),%edx
10a861: 89 df mov %ebx,%edi
10a863: 89 d6 mov %edx,%esi
10a865: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
10a867: 83 c4 10 add $0x10,%esp
}
_ISR_Enable( level );
10a86a: ff 75 e4 pushl -0x1c(%ebp)
10a86d: 9d popf
* now (signals not posted when SIG_IGN).
* + If we are now ignoring a signal that was previously pending,
* we clear the pending signal indicator.
*/
return 0;
10a86e: 31 c0 xor %eax,%eax
}
10a870: 8d 65 f4 lea -0xc(%ebp),%esp
10a873: 5b pop %ebx
10a874: 5e pop %esi
10a875: 5f pop %edi
10a876: c9 leave
10a877: c3 ret
0010ab97 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
10ab97: 55 push %ebp
10ab98: 89 e5 mov %esp,%ebp
10ab9a: 57 push %edi
10ab9b: 56 push %esi
10ab9c: 53 push %ebx
10ab9d: 83 ec 3c sub $0x3c,%esp
10aba0: 8b 75 08 mov 0x8(%ebp),%esi
10aba3: 8b 5d 10 mov 0x10(%ebp),%ebx
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
10aba6: 85 f6 test %esi,%esi
10aba8: 74 24 je 10abce <sigtimedwait+0x37>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
10abaa: 85 db test %ebx,%ebx
10abac: 74 30 je 10abde <sigtimedwait+0x47>
if ( !_Timespec_Is_valid( timeout ) )
10abae: 83 ec 0c sub $0xc,%esp
10abb1: 53 push %ebx
10abb2: e8 4d 31 00 00 call 10dd04 <_Timespec_Is_valid>
10abb7: 83 c4 10 add $0x10,%esp
10abba: 84 c0 test %al,%al
10abbc: 74 10 je 10abce <sigtimedwait+0x37>
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
10abbe: 83 ec 0c sub $0xc,%esp
10abc1: 53 push %ebx
10abc2: e8 95 31 00 00 call 10dd5c <_Timespec_To_ticks>
if ( !interval )
10abc7: 83 c4 10 add $0x10,%esp
10abca: 85 c0 test %eax,%eax
10abcc: 75 12 jne 10abe0 <sigtimedwait+0x49> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10abce: e8 35 79 00 00 call 112508 <__errno>
10abd3: c7 00 16 00 00 00 movl $0x16,(%eax)
10abd9: e9 39 01 00 00 jmp 10ad17 <sigtimedwait+0x180>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
10abde: 31 c0 xor %eax,%eax
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
10abe0: 8b 7d 0c mov 0xc(%ebp),%edi
10abe3: 85 ff test %edi,%edi
10abe5: 75 03 jne 10abea <sigtimedwait+0x53>
10abe7: 8d 7d dc lea -0x24(%ebp),%edi
the_thread = _Thread_Executing;
10abea: 8b 15 c8 78 12 00 mov 0x1278c8,%edx
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
10abf0: 8b 8a ec 00 00 00 mov 0xec(%edx),%ecx
10abf6: 89 4d d4 mov %ecx,-0x2c(%ebp)
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
10abf9: 9c pushf
10abfa: fa cli
10abfb: 8f 45 d0 popl -0x30(%ebp)
if ( *set & api->signals_pending ) {
10abfe: 8b 1e mov (%esi),%ebx
10ac00: 89 5d c4 mov %ebx,-0x3c(%ebp)
10ac03: 8b 5d d4 mov -0x2c(%ebp),%ebx
10ac06: 8b 8b d4 00 00 00 mov 0xd4(%ebx),%ecx
10ac0c: 85 4d c4 test %ecx,-0x3c(%ebp)
10ac0f: 74 32 je 10ac43 <sigtimedwait+0xac>
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
10ac11: 83 ec 0c sub $0xc,%esp
10ac14: 51 push %ecx
10ac15: e8 3e ff ff ff call 10ab58 <_POSIX_signals_Get_lowest>
10ac1a: 89 07 mov %eax,(%edi)
_POSIX_signals_Clear_signals(
10ac1c: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ac23: 6a 00 push $0x0
10ac25: 57 push %edi
10ac26: 50 push %eax
10ac27: 53 push %ebx
10ac28: e8 1b 51 00 00 call 10fd48 <_POSIX_signals_Clear_signals>
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
10ac2d: ff 75 d0 pushl -0x30(%ebp)
10ac30: 9d popf
the_info->si_code = SI_USER;
10ac31: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10ac38: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return the_info->si_signo;
10ac3f: 8b 1f mov (%edi),%ebx
10ac41: eb 3d jmp 10ac80 <sigtimedwait+0xe9>
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
10ac43: 8b 0d f0 7a 12 00 mov 0x127af0,%ecx
10ac49: 85 4d c4 test %ecx,-0x3c(%ebp)
10ac4c: 74 3a je 10ac88 <sigtimedwait+0xf1>
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
10ac4e: 83 ec 0c sub $0xc,%esp
10ac51: 51 push %ecx
10ac52: e8 01 ff ff ff call 10ab58 <_POSIX_signals_Get_lowest>
10ac57: 89 c3 mov %eax,%ebx
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
10ac59: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10ac60: 6a 01 push $0x1
10ac62: 57 push %edi
10ac63: 50 push %eax
10ac64: ff 75 d4 pushl -0x2c(%ebp)
10ac67: e8 dc 50 00 00 call 10fd48 <_POSIX_signals_Clear_signals>
_ISR_Enable( level );
10ac6c: ff 75 d0 pushl -0x30(%ebp)
10ac6f: 9d popf
the_info->si_signo = signo;
10ac70: 89 1f mov %ebx,(%edi)
the_info->si_code = SI_USER;
10ac72: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi)
the_info->si_value.sival_int = 0;
10ac79: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
return signo;
10ac80: 83 c4 20 add $0x20,%esp
10ac83: e9 92 00 00 00 jmp 10ad1a <sigtimedwait+0x183>
}
the_info->si_signo = -1;
10ac88: c7 07 ff ff ff ff movl $0xffffffff,(%edi)
10ac8e: 8b 0d a0 73 12 00 mov 0x1273a0,%ecx
10ac94: 41 inc %ecx
10ac95: 89 0d a0 73 12 00 mov %ecx,0x1273a0
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
10ac9b: c7 42 44 88 7a 12 00 movl $0x127a88,0x44(%edx)
the_thread->Wait.return_code = EINTR;
10aca2: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx)
the_thread->Wait.option = *set;
10aca9: 8b 0e mov (%esi),%ecx
10acab: 89 4a 30 mov %ecx,0x30(%edx)
the_thread->Wait.return_argument = the_info;
10acae: 89 7a 28 mov %edi,0x28(%edx)
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
10acb1: c7 05 b8 7a 12 00 01 movl $0x1,0x127ab8
10acb8: 00 00 00
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
10acbb: ff 75 d0 pushl -0x30(%ebp)
10acbe: 9d popf
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
10acbf: 52 push %edx
10acc0: 68 80 da 10 00 push $0x10da80
10acc5: 50 push %eax
10acc6: 68 88 7a 12 00 push $0x127a88
10accb: e8 d4 2a 00 00 call 10d7a4 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
10acd0: e8 89 26 00 00 call 10d35e <_Thread_Enable_dispatch>
/*
* When the thread is set free by a signal, it is need to eliminate
* the signal.
*/
_POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false );
10acd5: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10acdc: 6a 00 push $0x0
10acde: 57 push %edi
10acdf: ff 37 pushl (%edi)
10ace1: ff 75 d4 pushl -0x2c(%ebp)
10ace4: e8 5f 50 00 00 call 10fd48 <_POSIX_signals_Clear_signals>
/* Set errno only if return code is not EINTR or
* if EINTR was caused by a signal being caught, which
* was not in our set.
*/
if ( (_Thread_Executing->Wait.return_code != EINTR)
10ace9: 83 c4 20 add $0x20,%esp
10acec: a1 c8 78 12 00 mov 0x1278c8,%eax
10acf1: 83 78 34 04 cmpl $0x4,0x34(%eax)
10acf5: 75 10 jne 10ad07 <sigtimedwait+0x170>
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
10acf7: 8b 1f mov (%edi),%ebx
10acf9: 8d 4b ff lea -0x1(%ebx),%ecx
10acfc: b8 01 00 00 00 mov $0x1,%eax
10ad01: d3 e0 shl %cl,%eax
10ad03: 85 06 test %eax,(%esi)
10ad05: 75 13 jne 10ad1a <sigtimedwait+0x183>
errno = _Thread_Executing->Wait.return_code;
10ad07: e8 fc 77 00 00 call 112508 <__errno>
10ad0c: 8b 15 c8 78 12 00 mov 0x1278c8,%edx
10ad12: 8b 52 34 mov 0x34(%edx),%edx
10ad15: 89 10 mov %edx,(%eax)
return -1;
10ad17: 83 cb ff or $0xffffffff,%ebx
}
return the_info->si_signo;
}
10ad1a: 89 d8 mov %ebx,%eax
10ad1c: 8d 65 f4 lea -0xc(%ebp),%esp
10ad1f: 5b pop %ebx
10ad20: 5e pop %esi
10ad21: 5f pop %edi
10ad22: c9 leave
10ad23: c3 ret
0010ca18 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
10ca18: 55 push %ebp
10ca19: 89 e5 mov %esp,%ebp
10ca1b: 53 push %ebx
10ca1c: 83 ec 08 sub $0x8,%esp
10ca1f: 8b 5d 0c mov 0xc(%ebp),%ebx
int status;
status = sigtimedwait( set, NULL, NULL );
10ca22: 6a 00 push $0x0
10ca24: 6a 00 push $0x0
10ca26: ff 75 08 pushl 0x8(%ebp)
10ca29: e8 45 fe ff ff call 10c873 <sigtimedwait>
10ca2e: 89 c2 mov %eax,%edx
if ( status != -1 ) {
10ca30: 83 c4 10 add $0x10,%esp
10ca33: 83 f8 ff cmp $0xffffffff,%eax
10ca36: 74 0a je 10ca42 <sigwait+0x2a>
if ( sig )
*sig = status;
return 0;
10ca38: 31 c0 xor %eax,%eax
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
10ca3a: 85 db test %ebx,%ebx
10ca3c: 74 0b je 10ca49 <sigwait+0x31> <== NEVER TAKEN
*sig = status;
10ca3e: 89 13 mov %edx,(%ebx)
10ca40: eb 07 jmp 10ca49 <sigwait+0x31>
return 0;
}
return errno;
10ca42: e8 e9 72 00 00 call 113d30 <__errno>
10ca47: 8b 00 mov (%eax),%eax
}
10ca49: 8b 5d fc mov -0x4(%ebp),%ebx
10ca4c: c9 leave
10ca4d: c3 ret
00108f2c <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
108f2c: 55 push %ebp
108f2d: 89 e5 mov %esp,%ebp
108f2f: 56 push %esi
108f30: 53 push %ebx
108f31: 89 d3 mov %edx,%ebx
108f33: 89 c6 mov %eax,%esi
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
108f35: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx)
108f3c: 74 30 je 108f6e <siproc+0x42> <== NEVER TAKEN
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
108f3e: 52 push %edx
108f3f: 6a 00 push $0x0
108f41: 6a 00 push $0x0
108f43: ff 73 18 pushl 0x18(%ebx)
108f46: e8 1d 12 00 00 call 10a168 <rtems_semaphore_obtain>
i = iproc (c, tty);
108f4b: 89 f2 mov %esi,%edx
108f4d: 0f b6 c2 movzbl %dl,%eax
108f50: 89 da mov %ebx,%edx
108f52: e8 b5 fe ff ff call 108e0c <iproc>
108f57: 89 c6 mov %eax,%esi
rtems_semaphore_release (tty->osem);
108f59: 58 pop %eax
108f5a: ff 73 18 pushl 0x18(%ebx)
108f5d: e8 f2 12 00 00 call 10a254 <rtems_semaphore_release>
108f62: 83 c4 10 add $0x10,%esp
}
else {
i = iproc (c, tty);
}
return i;
}
108f65: 89 f0 mov %esi,%eax
108f67: 8d 65 f8 lea -0x8(%ebp),%esp
108f6a: 5b pop %ebx
108f6b: 5e pop %esi
108f6c: c9 leave
108f6d: c3 ret
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
108f6e: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED
108f71: 89 da mov %ebx,%edx <== NOT EXECUTED
}
return i;
}
108f73: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED
108f76: 5b pop %ebx <== NOT EXECUTED
108f77: 5e pop %esi <== NOT EXECUTED
108f78: 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);
108f79: e9 8e fe ff ff jmp 108e0c <iproc> <== NOT EXECUTED
0010a100 <statvfs>:
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
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 38 sub $0x38,%esp
10a109: 8b 55 08 mov 0x8(%ebp),%edx
10a10c: 8b 75 0c mov 0xc(%ebp),%esi
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
10a10f: 31 c0 xor %eax,%eax
10a111: 83 c9 ff or $0xffffffff,%ecx
10a114: 89 d7 mov %edx,%edi
10a116: f2 ae repnz scas %es:(%edi),%al
10a118: f7 d1 not %ecx
10a11a: 49 dec %ecx
10a11b: 6a 01 push $0x1
10a11d: 8d 5d d4 lea -0x2c(%ebp),%ebx
10a120: 53 push %ebx
10a121: 6a 00 push $0x0
10a123: 51 push %ecx
10a124: 52 push %edx
10a125: e8 28 ee ff ff call 108f52 <rtems_filesystem_evaluate_path>
10a12a: 83 c4 20 add $0x20,%esp
return -1;
10a12d: 83 cf ff or $0xffffffff,%edi
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
10a130: 85 c0 test %eax,%eax
10a132: 75 26 jne 10a15a <statvfs+0x5a> <== NEVER TAKEN
return -1;
mt_entry = loc.mt_entry;
10a134: 8b 55 e4 mov -0x1c(%ebp),%edx
fs_mount_root = &mt_entry->mt_fs_root;
memset (sb, 0, sizeof (struct statvfs));
10a137: b9 0e 00 00 00 mov $0xe,%ecx
10a13c: 89 f7 mov %esi,%edi
10a13e: f3 ab rep stos %eax,%es:(%edi)
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
10a140: 50 push %eax
10a141: 50 push %eax
10a142: 8b 42 28 mov 0x28(%edx),%eax
10a145: 56 push %esi
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
return -1;
mt_entry = loc.mt_entry;
fs_mount_root = &mt_entry->mt_fs_root;
10a146: 83 c2 1c add $0x1c,%edx
memset (sb, 0, sizeof (struct statvfs));
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
10a149: 52 push %edx
10a14a: ff 50 44 call *0x44(%eax)
10a14d: 89 c7 mov %eax,%edi
rtems_filesystem_freenode( &loc );
10a14f: 89 1c 24 mov %ebx,(%esp)
10a152: e8 b9 ee ff ff call 109010 <rtems_filesystem_freenode>
return result;
10a157: 83 c4 10 add $0x10,%esp
}
10a15a: 89 f8 mov %edi,%eax
10a15c: 8d 65 f4 lea -0xc(%ebp),%esp
10a15f: 5b pop %ebx
10a160: 5e pop %esi
10a161: 5f pop %edi
10a162: c9 leave
10a163: c3 ret
00108f68 <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
108f68: 55 push %ebp
108f69: 89 e5 mov %esp,%ebp
108f6b: 53 push %ebx
108f6c: 83 ec 04 sub $0x4,%esp
108f6f: 8b 45 08 mov 0x8(%ebp),%eax
/*
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
108f72: 8b 88 e4 00 00 00 mov 0xe4(%eax),%ecx
if ( this_reent ) {
108f78: 85 c9 test %ecx,%ecx
108f7a: 74 32 je 108fae <sync_per_thread+0x46> <== NEVER TAKEN
current_reent = _Thread_Executing->libc_reent;
108f7c: 8b 15 68 68 12 00 mov 0x126868,%edx
108f82: 8b 9a e4 00 00 00 mov 0xe4(%edx),%ebx
_Thread_Executing->libc_reent = this_reent;
108f88: 89 8a e4 00 00 00 mov %ecx,0xe4(%edx)
_fwalk (t->libc_reent, sync_wrapper);
108f8e: 52 push %edx
108f8f: 52 push %edx
108f90: 68 b3 8f 10 00 push $0x108fb3
108f95: ff b0 e4 00 00 00 pushl 0xe4(%eax)
108f9b: e8 ac 9e 00 00 call 112e4c <_fwalk>
_Thread_Executing->libc_reent = current_reent;
108fa0: a1 68 68 12 00 mov 0x126868,%eax
108fa5: 89 98 e4 00 00 00 mov %ebx,0xe4(%eax)
108fab: 83 c4 10 add $0x10,%esp
}
}
108fae: 8b 5d fc mov -0x4(%ebp),%ebx
108fb1: c9 leave
108fb2: c3 ret
00109828 <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
109828: 55 push %ebp
109829: 89 e5 mov %esp,%ebp
10982b: 56 push %esi
10982c: 53 push %ebx
10982d: 8b 5d 08 mov 0x8(%ebp),%ebx
109830: 8b 45 0c mov 0xc(%ebp),%eax
109833: 8b 75 10 mov 0x10(%ebp),%esi
switch (opt) {
109836: 85 c0 test %eax,%eax
109838: 74 22 je 10985c <tcsetattr+0x34>
10983a: 48 dec %eax
10983b: 74 0d je 10984a <tcsetattr+0x22>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
10983d: e8 4e 92 00 00 call 112a90 <__errno>
109842: c7 00 86 00 00 00 movl $0x86,(%eax)
109848: eb 2a jmp 109874 <tcsetattr+0x4c>
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
10984a: 50 push %eax
10984b: 6a 00 push $0x0
10984d: 6a 03 push $0x3
10984f: 53 push %ebx
109850: e8 6f 64 00 00 call 10fcc4 <ioctl>
109855: 83 c4 10 add $0x10,%esp
109858: 85 c0 test %eax,%eax
10985a: 78 18 js 109874 <tcsetattr+0x4c> <== NEVER TAKEN
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
10985c: 89 75 10 mov %esi,0x10(%ebp)
10985f: c7 45 0c 02 00 00 00 movl $0x2,0xc(%ebp)
109866: 89 5d 08 mov %ebx,0x8(%ebp)
}
}
109869: 8d 65 f8 lea -0x8(%ebp),%esp
10986c: 5b pop %ebx
10986d: 5e pop %esi
10986e: c9 leave
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
10986f: e9 50 64 00 00 jmp 10fcc4 <ioctl>
}
}
109874: 83 c8 ff or $0xffffffff,%eax
109877: 8d 65 f8 lea -0x8(%ebp),%esp
10987a: 5b pop %ebx
10987b: 5e pop %esi
10987c: c9 leave
10987d: c3 ret
0010a030 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
10a030: 55 push %ebp
10a031: 89 e5 mov %esp,%ebp
10a033: 56 push %esi
10a034: 53 push %ebx
10a035: 8b 5d 0c mov 0xc(%ebp),%ebx
10a038: 8b 75 10 mov 0x10(%ebp),%esi
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
10a03b: 83 7d 08 01 cmpl $0x1,0x8(%ebp)
10a03f: 75 1d jne 10a05e <timer_create+0x2e>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
10a041: 85 f6 test %esi,%esi
10a043: 74 19 je 10a05e <timer_create+0x2e>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
10a045: 85 db test %ebx,%ebx
10a047: 74 22 je 10a06b <timer_create+0x3b>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
10a049: 8b 03 mov (%ebx),%eax
10a04b: 48 dec %eax
10a04c: 83 f8 01 cmp $0x1,%eax
10a04f: 77 0d ja 10a05e <timer_create+0x2e> <== NEVER TAKEN
( evp->sigev_notify != SIGEV_SIGNAL ) ) {
/* The value of the field sigev_notify is not valid */
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !evp->sigev_signo )
10a051: 8b 43 04 mov 0x4(%ebx),%eax
10a054: 85 c0 test %eax,%eax
10a056: 74 06 je 10a05e <timer_create+0x2e> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
10a058: 48 dec %eax
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
10a059: 83 f8 1f cmp $0x1f,%eax
10a05c: 76 0d jbe 10a06b <timer_create+0x3b> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
10a05e: e8 89 7c 00 00 call 111cec <__errno>
10a063: c7 00 16 00 00 00 movl $0x16,(%eax)
10a069: eb 2f jmp 10a09a <timer_create+0x6a>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
10a06b: a1 b4 73 12 00 mov 0x1273b4,%eax
10a070: 40 inc %eax
10a071: a3 b4 73 12 00 mov %eax,0x1273b4
* the inactive chain of free timer control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void )
{
return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information );
10a076: 83 ec 0c sub $0xc,%esp
10a079: 68 98 76 12 00 push $0x127698
10a07e: e8 75 1b 00 00 call 10bbf8 <_Objects_Allocate>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
10a083: 83 c4 10 add $0x10,%esp
10a086: 85 c0 test %eax,%eax
10a088: 75 18 jne 10a0a2 <timer_create+0x72>
_Thread_Enable_dispatch();
10a08a: e8 3b 2a 00 00 call 10caca <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
10a08f: e8 58 7c 00 00 call 111cec <__errno>
10a094: c7 00 0b 00 00 00 movl $0xb,(%eax)
10a09a: 83 c8 ff or $0xffffffff,%eax
10a09d: e9 83 00 00 00 jmp 10a125 <timer_create+0xf5>
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
10a0a2: c6 40 3c 02 movb $0x2,0x3c(%eax)
ptimer->thread_id = _Thread_Executing->Object.id;
10a0a6: 8b 15 dc 78 12 00 mov 0x1278dc,%edx
10a0ac: 8b 52 08 mov 0x8(%edx),%edx
10a0af: 89 50 38 mov %edx,0x38(%eax)
if ( evp != NULL ) {
10a0b2: 85 db test %ebx,%ebx
10a0b4: 74 11 je 10a0c7 <timer_create+0x97>
ptimer->inf.sigev_notify = evp->sigev_notify;
10a0b6: 8b 13 mov (%ebx),%edx
10a0b8: 89 50 40 mov %edx,0x40(%eax)
ptimer->inf.sigev_signo = evp->sigev_signo;
10a0bb: 8b 53 04 mov 0x4(%ebx),%edx
10a0be: 89 50 44 mov %edx,0x44(%eax)
ptimer->inf.sigev_value = evp->sigev_value;
10a0c1: 8b 53 08 mov 0x8(%ebx),%edx
10a0c4: 89 50 48 mov %edx,0x48(%eax)
}
ptimer->overrun = 0;
10a0c7: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax)
ptimer->timer_data.it_value.tv_sec = 0;
10a0ce: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax)
ptimer->timer_data.it_value.tv_nsec = 0;
10a0d5: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax)
ptimer->timer_data.it_interval.tv_sec = 0;
10a0dc: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax)
ptimer->timer_data.it_interval.tv_nsec = 0;
10a0e3: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
10a0ea: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax)
the_watchdog->routine = routine;
10a0f1: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
the_watchdog->id = id;
10a0f8: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax)
the_watchdog->user_data = user_data;
10a0ff: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax)
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
10a106: 8b 50 08 mov 0x8(%eax),%edx
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
10a109: 0f b7 da movzwl %dx,%ebx
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
10a10c: 8b 0d b4 76 12 00 mov 0x1276b4,%ecx
10a112: 89 04 99 mov %eax,(%ecx,%ebx,4)
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
10a115: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax)
_Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL );
_Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);
*timerid = ptimer->Object.id;
10a11c: 89 16 mov %edx,(%esi)
_Thread_Enable_dispatch();
10a11e: e8 a7 29 00 00 call 10caca <_Thread_Enable_dispatch>
return 0;
10a123: 31 c0 xor %eax,%eax
}
10a125: 8d 65 f8 lea -0x8(%ebp),%esp
10a128: 5b pop %ebx
10a129: 5e pop %esi
10a12a: c9 leave
10a12b: c3 ret
0010a12c <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
10a12c: 55 push %ebp
10a12d: 89 e5 mov %esp,%ebp
10a12f: 57 push %edi
10a130: 56 push %esi
10a131: 53 push %ebx
10a132: 83 ec 2c sub $0x2c,%esp
10a135: 8b 5d 0c mov 0xc(%ebp),%ebx
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
10a138: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a13c: 0f 84 58 01 00 00 je 10a29a <timer_settime+0x16e> <== NEVER TAKEN
/*
* First, it verifies if the structure "value" is correct
* if the number of nanoseconds is not correct return EINVAL
*/
if ( !_Timespec_Is_valid( &(value->it_value) ) ) {
10a142: 83 ec 0c sub $0xc,%esp
10a145: 8b 45 10 mov 0x10(%ebp),%eax
10a148: 83 c0 08 add $0x8,%eax
10a14b: 50 push %eax
10a14c: e8 43 33 00 00 call 10d494 <_Timespec_Is_valid>
10a151: 83 c4 10 add $0x10,%esp
10a154: 84 c0 test %al,%al
10a156: 0f 84 3e 01 00 00 je 10a29a <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
10a15c: 83 ec 0c sub $0xc,%esp
10a15f: ff 75 10 pushl 0x10(%ebp)
10a162: e8 2d 33 00 00 call 10d494 <_Timespec_Is_valid>
10a167: 83 c4 10 add $0x10,%esp
10a16a: 84 c0 test %al,%al
10a16c: 0f 84 28 01 00 00 je 10a29a <timer_settime+0x16e> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
10a172: 85 db test %ebx,%ebx
10a174: 74 09 je 10a17f <timer_settime+0x53>
10a176: 83 fb 04 cmp $0x4,%ebx
10a179: 0f 85 1b 01 00 00 jne 10a29a <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
10a17f: 8d 7d cc lea -0x34(%ebp),%edi
10a182: b9 04 00 00 00 mov $0x4,%ecx
10a187: 8b 75 10 mov 0x10(%ebp),%esi
10a18a: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
10a18c: 83 fb 04 cmp $0x4,%ebx
10a18f: 75 2f jne 10a1c0 <timer_settime+0x94>
struct timespec now;
_TOD_Get( &now );
10a191: 83 ec 0c sub $0xc,%esp
10a194: 8d 5d dc lea -0x24(%ebp),%ebx
10a197: 53 push %ebx
10a198: e8 b3 15 00 00 call 10b750 <_TOD_Get>
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
10a19d: 59 pop %ecx
10a19e: 5e pop %esi
10a19f: 8d 75 d4 lea -0x2c(%ebp),%esi
10a1a2: 56 push %esi
10a1a3: 53 push %ebx
10a1a4: e8 c7 32 00 00 call 10d470 <_Timespec_Greater_than>
10a1a9: 83 c4 10 add $0x10,%esp
10a1ac: 84 c0 test %al,%al
10a1ae: 0f 85 e6 00 00 00 jne 10a29a <timer_settime+0x16e>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
10a1b4: 52 push %edx
10a1b5: 56 push %esi
10a1b6: 56 push %esi
10a1b7: 53 push %ebx
10a1b8: e8 fb 32 00 00 call 10d4b8 <_Timespec_Subtract>
10a1bd: 83 c4 10 add $0x10,%esp
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
_Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location );
10a1c0: 50 push %eax
/* If the function reaches this point, then it will be necessary to do
* something with the structure of times of the timer: to stop, start
* or start it again
*/
ptimer = _POSIX_Timer_Get( timerid, &location );
10a1c1: 8d 45 e4 lea -0x1c(%ebp),%eax
10a1c4: 50 push %eax
10a1c5: ff 75 08 pushl 0x8(%ebp)
10a1c8: 68 98 76 12 00 push $0x127698
10a1cd: e8 52 1e 00 00 call 10c024 <_Objects_Get>
10a1d2: 89 c3 mov %eax,%ebx
switch ( location ) {
10a1d4: 83 c4 10 add $0x10,%esp
10a1d7: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp)
10a1db: 0f 85 b9 00 00 00 jne 10a29a <timer_settime+0x16e>
case OBJECTS_LOCAL:
/* First, it verifies if the timer must be stopped */
if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) {
10a1e1: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp)
10a1e5: 75 3b jne 10a222 <timer_settime+0xf6>
10a1e7: 83 7d d8 00 cmpl $0x0,-0x28(%ebp)
10a1eb: 75 35 jne 10a222 <timer_settime+0xf6>
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
10a1ed: 83 ec 0c sub $0xc,%esp
10a1f0: 8d 40 10 lea 0x10(%eax),%eax
10a1f3: 50 push %eax
10a1f4: e8 8b 36 00 00 call 10d884 <_Watchdog_Remove>
/* The old data of the timer are returned */
if ( ovalue )
10a1f9: 83 c4 10 add $0x10,%esp
10a1fc: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10a200: 74 0d je 10a20f <timer_settime+0xe3>
*ovalue = ptimer->timer_data;
10a202: 8d 73 54 lea 0x54(%ebx),%esi
10a205: b9 04 00 00 00 mov $0x4,%ecx
10a20a: 8b 7d 14 mov 0x14(%ebp),%edi
10a20d: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* The new data are set */
ptimer->timer_data = normalize;
10a20f: 8d 7b 54 lea 0x54(%ebx),%edi
10a212: 8d 75 cc lea -0x34(%ebp),%esi
10a215: b9 04 00 00 00 mov $0x4,%ecx
10a21a: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
10a21c: c6 43 3c 04 movb $0x4,0x3c(%ebx)
10a220: eb 35 jmp 10a257 <timer_settime+0x12b>
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
10a222: 83 ec 0c sub $0xc,%esp
10a225: ff 75 10 pushl 0x10(%ebp)
10a228: e8 bf 32 00 00 call 10d4ec <_Timespec_To_ticks>
10a22d: 89 43 64 mov %eax,0x64(%ebx)
initial_period = _Timespec_To_ticks( &normalize.it_value );
10a230: 8d 45 d4 lea -0x2c(%ebp),%eax
10a233: 89 04 24 mov %eax,(%esp)
10a236: e8 b1 32 00 00 call 10d4ec <_Timespec_To_ticks>
activated = _POSIX_Timer_Insert_helper(
10a23b: 89 1c 24 mov %ebx,(%esp)
10a23e: 68 b0 a2 10 00 push $0x10a2b0
10a243: ff 73 08 pushl 0x8(%ebx)
10a246: 50 push %eax
10a247: 8d 43 10 lea 0x10(%ebx),%eax
10a24a: 50 push %eax
10a24b: e8 70 57 00 00 call 10f9c0 <_POSIX_Timer_Insert_helper>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
10a250: 83 c4 20 add $0x20,%esp
10a253: 84 c0 test %al,%al
10a255: 75 07 jne 10a25e <timer_settime+0x132>
_Thread_Enable_dispatch();
10a257: e8 6e 28 00 00 call 10caca <_Thread_Enable_dispatch>
10a25c: eb 38 jmp 10a296 <timer_settime+0x16a>
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
10a25e: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
10a262: 74 0d je 10a271 <timer_settime+0x145>
*ovalue = ptimer->timer_data;
10a264: 8d 73 54 lea 0x54(%ebx),%esi
10a267: b9 04 00 00 00 mov $0x4,%ecx
10a26c: 8b 7d 14 mov 0x14(%ebp),%edi
10a26f: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
ptimer->timer_data = normalize;
10a271: 8d 7b 54 lea 0x54(%ebx),%edi
10a274: 8d 75 cc lea -0x34(%ebp),%esi
10a277: b9 04 00 00 00 mov $0x4,%ecx
10a27c: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
10a27e: c6 43 3c 03 movb $0x3,0x3c(%ebx)
_TOD_Get( &ptimer->time );
10a282: 83 ec 0c sub $0xc,%esp
10a285: 83 c3 6c add $0x6c,%ebx
10a288: 53 push %ebx
10a289: e8 c2 14 00 00 call 10b750 <_TOD_Get>
_Thread_Enable_dispatch();
10a28e: e8 37 28 00 00 call 10caca <_Thread_Enable_dispatch>
return 0;
10a293: 83 c4 10 add $0x10,%esp
10a296: 31 c0 xor %eax,%eax
10a298: eb 0e jmp 10a2a8 <timer_settime+0x17c>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
10a29a: e8 4d 7a 00 00 call 111cec <__errno>
10a29f: c7 00 16 00 00 00 movl $0x16,(%eax)
10a2a5: 83 c8 ff or $0xffffffff,%eax
}
10a2a8: 8d 65 f4 lea -0xc(%ebp),%esp
10a2ab: 5b pop %ebx
10a2ac: 5e pop %esi
10a2ad: 5f pop %edi
10a2ae: c9 leave
10a2af: c3 ret
00109f6c <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
109f6c: 55 push %ebp
109f6d: 89 e5 mov %esp,%ebp
109f6f: 57 push %edi
109f70: 56 push %esi
109f71: 53 push %ebx
109f72: 83 ec 1c sub $0x1c,%esp
109f75: 8b 75 08 mov 0x8(%ebp),%esi
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
109f78: 83 3d a0 6c 12 00 00 cmpl $0x0,0x126ca0
109f7f: 75 2c jne 109fad <ualarm+0x41>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
109f81: c7 05 8c 6c 12 00 00 movl $0x0,0x126c8c
109f88: 00 00 00
the_watchdog->routine = routine;
109f8b: c7 05 a0 6c 12 00 34 movl $0x109f34,0x126ca0
109f92: 9f 10 00
the_watchdog->id = id;
109f95: c7 05 a4 6c 12 00 00 movl $0x0,0x126ca4
109f9c: 00 00 00
the_watchdog->user_data = user_data;
109f9f: c7 05 a8 6c 12 00 00 movl $0x0,0x126ca8
109fa6: 00 00 00
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
109fa9: 31 db xor %ebx,%ebx
109fab: eb 4f jmp 109ffc <ualarm+0x90>
if ( !the_timer->routine ) {
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
109fad: 83 ec 0c sub $0xc,%esp
109fb0: 68 84 6c 12 00 push $0x126c84
109fb5: e8 b2 34 00 00 call 10d46c <_Watchdog_Remove>
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
109fba: 83 e8 02 sub $0x2,%eax
109fbd: 83 c4 10 add $0x10,%esp
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
109fc0: 31 db xor %ebx,%ebx
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
109fc2: 83 f8 01 cmp $0x1,%eax
109fc5: 77 35 ja 109ffc <ualarm+0x90> <== NEVER TAKEN
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
109fc7: a1 98 6c 12 00 mov 0x126c98,%eax
109fcc: 03 05 90 6c 12 00 add 0x126c90,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
109fd2: 57 push %edi
109fd3: 57 push %edi
109fd4: 8d 55 e0 lea -0x20(%ebp),%edx
109fd7: 52 push %edx
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
109fd8: 2b 05 9c 6c 12 00 sub 0x126c9c,%eax
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
109fde: 50 push %eax
109fdf: e8 28 30 00 00 call 10d00c <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
109fe4: 69 4d e0 40 42 0f 00 imul $0xf4240,-0x20(%ebp),%ecx
remaining += tp.tv_nsec / 1000;
109feb: 8b 45 e4 mov -0x1c(%ebp),%eax
109fee: bf e8 03 00 00 mov $0x3e8,%edi
109ff3: 99 cltd
109ff4: f7 ff idiv %edi
109ff6: 8d 1c 08 lea (%eax,%ecx,1),%ebx
109ff9: 83 c4 10 add $0x10,%esp
/*
* If useconds is non-zero, then the caller wants to schedule
* the alarm repeatedly at that interval. If the interval is
* less than a single clock tick, then fudge it to a clock tick.
*/
if ( useconds ) {
109ffc: 85 f6 test %esi,%esi
109ffe: 74 44 je 10a044 <ualarm+0xd8>
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
10a000: b9 40 42 0f 00 mov $0xf4240,%ecx
10a005: 89 f0 mov %esi,%eax
10a007: 31 d2 xor %edx,%edx
10a009: f7 f1 div %ecx
10a00b: 89 45 e0 mov %eax,-0x20(%ebp)
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
10a00e: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx
10a014: 89 55 e4 mov %edx,-0x1c(%ebp)
ticks = _Timespec_To_ticks( &tp );
10a017: 83 ec 0c sub $0xc,%esp
10a01a: 8d 75 e0 lea -0x20(%ebp),%esi
10a01d: 56 push %esi
10a01e: e8 45 30 00 00 call 10d068 <_Timespec_To_ticks>
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
10a023: 89 34 24 mov %esi,(%esp)
10a026: e8 3d 30 00 00 call 10d068 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
10a02b: a3 90 6c 12 00 mov %eax,0x126c90
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
10a030: 59 pop %ecx
10a031: 5e pop %esi
10a032: 68 84 6c 12 00 push $0x126c84
10a037: 68 74 64 12 00 push $0x126474
10a03c: e8 0b 33 00 00 call 10d34c <_Watchdog_Insert>
10a041: 83 c4 10 add $0x10,%esp
}
return remaining;
}
10a044: 89 d8 mov %ebx,%eax
10a046: 8d 65 f4 lea -0xc(%ebp),%esp
10a049: 5b pop %ebx
10a04a: 5e pop %esi
10a04b: 5f pop %edi
10a04c: c9 leave
10a04d: c3 ret
0010a6c8 <unlink>:
#include <rtems/seterr.h>
int unlink(
const char *path
)
{
10a6c8: 55 push %ebp
10a6c9: 89 e5 mov %esp,%ebp
10a6cb: 57 push %edi
10a6cc: 56 push %esi
10a6cd: 53 push %ebx
10a6ce: 83 ec 58 sub $0x58,%esp
/*
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
10a6d1: ff 75 08 pushl 0x8(%ebp)
10a6d4: e8 1a d9 ff ff call 107ff3 <rtems_filesystem_dirname>
10a6d9: 89 45 b4 mov %eax,-0x4c(%ebp)
if ( parentpathlen == 0 )
10a6dc: 83 c4 10 add $0x10,%esp
10a6df: 85 c0 test %eax,%eax
10a6e1: 8d 45 d0 lea -0x30(%ebp),%eax
10a6e4: 75 15 jne 10a6fb <unlink+0x33>
rtems_filesystem_get_start_loc( path, &i, &parentloc );
10a6e6: 51 push %ecx
10a6e7: 50 push %eax
10a6e8: 8d 45 e4 lea -0x1c(%ebp),%eax
10a6eb: 50 push %eax
10a6ec: ff 75 08 pushl 0x8(%ebp)
10a6ef: e8 d4 e6 ff ff call 108dc8 <rtems_filesystem_get_start_loc>
10a6f4: 83 c4 10 add $0x10,%esp
const char *name;
rtems_filesystem_location_info_t parentloc;
rtems_filesystem_location_info_t loc;
int i;
int result;
bool free_parentloc = false;
10a6f7: 31 db xor %ebx,%ebx
10a6f9: eb 25 jmp 10a720 <unlink+0x58>
parentpathlen = rtems_filesystem_dirname ( path );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( path, &i, &parentloc );
else {
result = rtems_filesystem_evaluate_path( path, parentpathlen,
10a6fb: 83 ec 0c sub $0xc,%esp
10a6fe: 6a 00 push $0x0
10a700: 50 push %eax
10a701: 6a 02 push $0x2
10a703: ff 75 b4 pushl -0x4c(%ebp)
10a706: ff 75 08 pushl 0x8(%ebp)
10a709: e8 a4 d8 ff ff call 107fb2 <rtems_filesystem_evaluate_path>
10a70e: 89 c2 mov %eax,%edx
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
10a710: 83 c4 20 add $0x20,%esp
return -1;
10a713: 83 c8 ff or $0xffffffff,%eax
else {
result = rtems_filesystem_evaluate_path( path, parentpathlen,
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
10a716: 85 d2 test %edx,%edx
10a718: 0f 85 d6 00 00 00 jne 10a7f4 <unlink+0x12c> <== NEVER TAKEN
return -1;
free_parentloc = true;
10a71e: b3 01 mov $0x1,%bl
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
10a720: 8d 7d bc lea -0x44(%ebp),%edi
10a723: 8d 75 d0 lea -0x30(%ebp),%esi
10a726: b9 05 00 00 00 mov $0x5,%ecx
10a72b: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
name = path + parentpathlen;
10a72d: 8b 75 08 mov 0x8(%ebp),%esi
10a730: 03 75 b4 add -0x4c(%ebp),%esi
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
10a733: 83 c9 ff or $0xffffffff,%ecx
10a736: 89 f7 mov %esi,%edi
10a738: 31 c0 xor %eax,%eax
10a73a: f2 ae repnz scas %es:(%edi),%al
10a73c: f7 d1 not %ecx
10a73e: 49 dec %ecx
10a73f: 52 push %edx
10a740: 52 push %edx
10a741: 51 push %ecx
10a742: 56 push %esi
10a743: e8 ea d8 ff ff call 108032 <rtems_filesystem_prefix_separators>
10a748: 01 c6 add %eax,%esi
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
10a74a: 83 c9 ff or $0xffffffff,%ecx
10a74d: 89 f7 mov %esi,%edi
10a74f: 31 c0 xor %eax,%eax
10a751: f2 ae repnz scas %es:(%edi),%al
10a753: f7 d1 not %ecx
10a755: 49 dec %ecx
10a756: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10a75d: 8d 7d bc lea -0x44(%ebp),%edi
10a760: 57 push %edi
10a761: 6a 00 push $0x0
10a763: 51 push %ecx
10a764: 56 push %esi
10a765: e8 ea d7 ff ff call 107f54 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
10a76a: 83 c4 20 add $0x20,%esp
10a76d: 85 c0 test %eax,%eax
10a76f: 74 13 je 10a784 <unlink+0xbc>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
10a771: 83 c8 ff or $0xffffffff,%eax
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
10a774: 84 db test %bl,%bl
10a776: 74 7c je 10a7f4 <unlink+0x12c> <== NEVER TAKEN
rtems_filesystem_freenode( &parentloc );
10a778: 83 ec 0c sub $0xc,%esp
10a77b: 8d 55 d0 lea -0x30(%ebp),%edx
10a77e: 52 push %edx
10a77f: 89 45 b0 mov %eax,-0x50(%ebp)
10a782: eb 65 jmp 10a7e9 <unlink+0x121>
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
10a784: 83 ec 0c sub $0xc,%esp
10a787: 57 push %edi
10a788: 8b 45 c8 mov -0x38(%ebp),%eax
10a78b: ff 50 10 call *0x10(%eax)
10a78e: 83 c4 10 add $0x10,%esp
10a791: 48 dec %eax
10a792: 75 2f jne 10a7c3 <unlink+0xfb>
rtems_filesystem_freenode( &loc );
10a794: 83 ec 0c sub $0xc,%esp
10a797: 57 push %edi
10a798: e8 d3 d8 ff ff call 108070 <rtems_filesystem_freenode>
if ( free_parentloc )
10a79d: 83 c4 10 add $0x10,%esp
10a7a0: 84 db test %bl,%bl
10a7a2: 74 0f je 10a7b3 <unlink+0xeb>
rtems_filesystem_freenode( &parentloc );
10a7a4: 83 ec 0c sub $0xc,%esp
10a7a7: 8d 45 d0 lea -0x30(%ebp),%eax
10a7aa: 50 push %eax
10a7ab: e8 c0 d8 ff ff call 108070 <rtems_filesystem_freenode>
10a7b0: 83 c4 10 add $0x10,%esp
rtems_set_errno_and_return_minus_one( EISDIR );
10a7b3: e8 04 a0 00 00 call 1147bc <__errno>
10a7b8: c7 00 15 00 00 00 movl $0x15,(%eax)
10a7be: 83 c8 ff or $0xffffffff,%eax
10a7c1: eb 31 jmp 10a7f4 <unlink+0x12c>
}
result = (*loc.ops->unlink_h)( &parentloc, &loc );
10a7c3: 50 push %eax
10a7c4: 50 push %eax
10a7c5: 57 push %edi
10a7c6: 8d 75 d0 lea -0x30(%ebp),%esi
10a7c9: 56 push %esi
10a7ca: 8b 45 c8 mov -0x38(%ebp),%eax
10a7cd: ff 50 0c call *0xc(%eax)
rtems_filesystem_freenode( &loc );
10a7d0: 89 3c 24 mov %edi,(%esp)
10a7d3: 89 45 b0 mov %eax,-0x50(%ebp)
10a7d6: e8 95 d8 ff ff call 108070 <rtems_filesystem_freenode>
if ( free_parentloc )
10a7db: 83 c4 10 add $0x10,%esp
10a7de: 84 db test %bl,%bl
10a7e0: 8b 45 b0 mov -0x50(%ebp),%eax
10a7e3: 74 0f je 10a7f4 <unlink+0x12c>
rtems_filesystem_freenode( &parentloc );
10a7e5: 83 ec 0c sub $0xc,%esp
10a7e8: 56 push %esi
10a7e9: e8 82 d8 ff ff call 108070 <rtems_filesystem_freenode>
10a7ee: 83 c4 10 add $0x10,%esp
10a7f1: 8b 45 b0 mov -0x50(%ebp),%eax
return result;
}
10a7f4: 8d 65 f4 lea -0xc(%ebp),%esp
10a7f7: 5b pop %ebx
10a7f8: 5e pop %esi
10a7f9: 5f pop %edi
10a7fa: c9 leave
10a7fb: c3 ret
0010a935 <unmount>:
*/
int unmount(
const char *path
)
{
10a935: 55 push %ebp
10a936: 89 e5 mov %esp,%ebp
10a938: 57 push %edi
10a939: 56 push %esi
10a93a: 53 push %ebx
10a93b: 83 ec 38 sub $0x38,%esp
10a93e: 8b 55 08 mov 0x8(%ebp),%edx
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
10a941: 83 cb ff or $0xffffffff,%ebx
10a944: 31 c0 xor %eax,%eax
10a946: 89 d9 mov %ebx,%ecx
10a948: 89 d7 mov %edx,%edi
10a94a: f2 ae repnz scas %es:(%edi),%al
10a94c: f7 d1 not %ecx
10a94e: 49 dec %ecx
10a94f: 6a 01 push $0x1
10a951: 8d 7d d4 lea -0x2c(%ebp),%edi
10a954: 57 push %edi
10a955: 6a 00 push $0x0
10a957: 51 push %ecx
10a958: 52 push %edx
10a959: e8 e8 d5 ff ff call 107f46 <rtems_filesystem_evaluate_path>
10a95e: 83 c4 20 add $0x20,%esp
10a961: 85 c0 test %eax,%eax
10a963: 0f 85 f2 00 00 00 jne 10aa5b <unmount+0x126>
return -1;
mt_entry = loc.mt_entry;
10a969: 8b 75 e4 mov -0x1c(%ebp),%esi
/*
* Verify this is the root node for the file system to be unmounted.
*/
if ( fs_root_loc->node_access != loc.node_access ){
10a96c: 8b 45 d4 mov -0x2c(%ebp),%eax
10a96f: 39 46 1c cmp %eax,0x1c(%esi)
10a972: 74 1c je 10a990 <unmount+0x5b>
rtems_filesystem_freenode( &loc );
10a974: 83 ec 0c sub $0xc,%esp
10a977: 57 push %edi
10a978: e8 87 d6 ff ff call 108004 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EACCES );
10a97d: e8 c2 76 00 00 call 112044 <__errno>
10a982: c7 00 0d 00 00 00 movl $0xd,(%eax)
10a988: 83 c4 10 add $0x10,%esp
10a98b: e9 cb 00 00 00 jmp 10aa5b <unmount+0x126>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
10a990: 83 ec 0c sub $0xc,%esp
10a993: 57 push %edi
10a994: e8 6b d6 ff ff call 108004 <rtems_filesystem_freenode>
* that made the current node thread based instead
* of system based? I thought it was but it doesn't
* look like it in this version.
*/
if ( rtems_filesystem_current.mt_entry == mt_entry )
10a999: 83 c4 10 add $0x10,%esp
10a99c: a1 0c 51 12 00 mov 0x12510c,%eax
10a9a1: 39 70 14 cmp %esi,0x14(%eax)
10a9a4: 74 25 je 10a9cb <unmount+0x96>
/*
* Verify there are no file systems below the path specified
*/
if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,
10a9a6: 51 push %ecx
10a9a7: 51 push %ecx
10a9a8: ff 76 2c pushl 0x2c(%esi)
10a9ab: 68 24 a9 10 00 push $0x10a924
10a9b0: e8 44 dd ff ff call 1086f9 <rtems_filesystem_mount_iterate>
10a9b5: 83 c4 10 add $0x10,%esp
10a9b8: 84 c0 test %al,%al
10a9ba: 75 0f jne 10a9cb <unmount+0x96>
* Run the file descriptor table to determine if there are any file
* descriptors that are currently active and reference nodes in the
* file system that we are trying to unmount
*/
if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 )
10a9bc: 83 ec 0c sub $0xc,%esp
10a9bf: 56 push %esi
10a9c0: e8 27 d9 ff ff call 1082ec <rtems_libio_is_open_files_in_fs>
10a9c5: 83 c4 10 add $0x10,%esp
10a9c8: 48 dec %eax
10a9c9: 75 10 jne 10a9db <unmount+0xa6>
rtems_set_errno_and_return_minus_one( EBUSY );
10a9cb: e8 74 76 00 00 call 112044 <__errno>
10a9d0: c7 00 10 00 00 00 movl $0x10,(%eax)
10a9d6: e9 80 00 00 00 jmp 10aa5b <unmount+0x126>
* Allow the file system being unmounted on to do its cleanup.
* If it fails it will set the errno to the approprate value
* and the fileystem will not be modified.
*/
if (( fs_mount_loc->ops->unmount_h )( mt_entry ) != 0 )
10a9db: 83 ec 0c sub $0xc,%esp
10a9de: 8b 46 14 mov 0x14(%esi),%eax
10a9e1: 56 push %esi
10a9e2: ff 50 28 call *0x28(%eax)
10a9e5: 83 c4 10 add $0x10,%esp
return -1;
10a9e8: 83 ca ff or $0xffffffff,%edx
* Allow the file system being unmounted on to do its cleanup.
* If it fails it will set the errno to the approprate value
* and the fileystem will not be modified.
*/
if (( fs_mount_loc->ops->unmount_h )( mt_entry ) != 0 )
10a9eb: 85 c0 test %eax,%eax
10a9ed: 75 6f jne 10aa5e <unmount+0x129> <== NEVER TAKEN
* NOTE: Fatal error is called in a case which should never happen
* This was response was questionable but the best we could
* come up with.
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
10a9ef: 83 ec 0c sub $0xc,%esp
10a9f2: 8b 46 28 mov 0x28(%esi),%eax
10a9f5: 56 push %esi
10a9f6: ff 50 2c call *0x2c(%eax)
10a9f9: 83 c4 10 add $0x10,%esp
10a9fc: 85 c0 test %eax,%eax
10a9fe: 74 1d je 10aa1d <unmount+0xe8> <== ALWAYS TAKEN
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
10aa00: 83 ec 0c sub $0xc,%esp
10aa03: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED
10aa06: 56 push %esi <== NOT EXECUTED
10aa07: ff 50 20 call *0x20(%eax) <== NOT EXECUTED
10aa0a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
return -1;
10aa0d: 89 da mov %ebx,%edx <== NOT EXECUTED
* This was response was questionable but the best we could
* come up with.
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
10aa0f: 85 c0 test %eax,%eax <== NOT EXECUTED
10aa11: 74 4b je 10aa5e <unmount+0x129> <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
10aa13: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10aa16: 6a 00 push $0x0 <== NOT EXECUTED
10aa18: e8 93 0e 00 00 call 10b8b0 <rtems_fatal_error_occurred><== NOT EXECUTED
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
10aa1d: 52 push %edx
10aa1e: 6a 00 push $0x0
10aa20: 6a 00 push $0x0
10aa22: ff 35 48 73 12 00 pushl 0x127348
10aa28: e8 fb 08 00 00 call 10b328 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
10aa2d: 89 34 24 mov %esi,(%esp)
10aa30: e8 4b 11 00 00 call 10bb80 <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
10aa35: 58 pop %eax
10aa36: ff 35 48 73 12 00 pushl 0x127348
10aa3c: e8 d3 09 00 00 call 10b414 <rtems_semaphore_release>
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
return -1;
mt_entry = loc.mt_entry;
fs_mount_loc = &mt_entry->mt_point_node;
10aa41: 8d 46 08 lea 0x8(%esi),%eax
/*
* Free the memory node that was allocated in mount
* Free the memory associated with the extracted mount table entry.
*/
rtems_filesystem_freenode( fs_mount_loc );
10aa44: 89 04 24 mov %eax,(%esp)
10aa47: e8 b8 d5 ff ff call 108004 <rtems_filesystem_freenode>
free( mt_entry );
10aa4c: 89 34 24 mov %esi,(%esp)
10aa4f: e8 c4 d5 ff ff call 108018 <free>
return 0;
10aa54: 83 c4 10 add $0x10,%esp
10aa57: 31 d2 xor %edx,%edx
10aa59: eb 03 jmp 10aa5e <unmount+0x129>
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
return -1;
10aa5b: 83 ca ff or $0xffffffff,%edx
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
10aa5e: 89 d0 mov %edx,%eax
10aa60: 8d 65 f4 lea -0xc(%ebp),%esp
10aa63: 5b pop %ebx
10aa64: 5e pop %esi
10aa65: 5f pop %edi
10aa66: c9 leave
10aa67: c3 ret
0011d28c <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
11d28c: 55 push %ebp
11d28d: 89 e5 mov %esp,%ebp
11d28f: 56 push %esi
11d290: 53 push %ebx
11d291: 8b 5d 08 mov 0x8(%ebp),%ebx
11d294: 8b 55 0c mov 0xc(%ebp),%edx
11d297: 8b 4d 10 mov 0x10(%ebp),%ecx
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
11d29a: 3b 1d 44 11 12 00 cmp 0x121144,%ebx
11d2a0: 73 14 jae 11d2b6 <write+0x2a>
iop = rtems_libio_iop( fd );
11d2a2: 6b db 38 imul $0x38,%ebx,%ebx
11d2a5: 03 1d f8 51 12 00 add 0x1251f8,%ebx
rtems_libio_check_is_open( iop );
11d2ab: 8b 73 14 mov 0x14(%ebx),%esi
11d2ae: f7 c6 00 01 00 00 test $0x100,%esi
11d2b4: 75 0d jne 11d2c3 <write+0x37>
11d2b6: e8 11 3e ff ff call 1110cc <__errno>
11d2bb: c7 00 09 00 00 00 movl $0x9,(%eax)
11d2c1: eb 1a jmp 11d2dd <write+0x51>
rtems_libio_check_buffer( buffer );
11d2c3: 85 d2 test %edx,%edx
11d2c5: 74 0b je 11d2d2 <write+0x46> <== NEVER TAKEN
rtems_libio_check_count( count );
11d2c7: 31 c0 xor %eax,%eax
11d2c9: 85 c9 test %ecx,%ecx
11d2cb: 74 31 je 11d2fe <write+0x72>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
11d2cd: 83 e6 04 and $0x4,%esi
11d2d0: 75 10 jne 11d2e2 <write+0x56>
11d2d2: e8 f5 3d ff ff call 1110cc <__errno>
11d2d7: c7 00 16 00 00 00 movl $0x16,(%eax)
11d2dd: 83 c8 ff or $0xffffffff,%eax
11d2e0: eb 1c jmp 11d2fe <write+0x72>
/*
* Now process the write() request.
*/
rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
11d2e2: 50 push %eax
11d2e3: 8b 43 20 mov 0x20(%ebx),%eax
11d2e6: 51 push %ecx
11d2e7: 52 push %edx
11d2e8: 53 push %ebx
11d2e9: ff 50 0c call *0xc(%eax)
if ( rc > 0 )
11d2ec: 83 c4 10 add $0x10,%esp
11d2ef: 85 c0 test %eax,%eax
11d2f1: 7e 0b jle 11d2fe <write+0x72>
iop->offset += rc;
11d2f3: 89 c1 mov %eax,%ecx
11d2f5: c1 f9 1f sar $0x1f,%ecx
11d2f8: 01 43 0c add %eax,0xc(%ebx)
11d2fb: 11 4b 10 adc %ecx,0x10(%ebx)
return rc;
}
11d2fe: 8d 65 f8 lea -0x8(%ebp),%esp
11d301: 5b pop %ebx
11d302: 5e pop %esi
11d303: c9 leave
11d304: c3 ret
0010a93c <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
10a93c: 55 push %ebp
10a93d: 89 e5 mov %esp,%ebp
10a93f: 57 push %edi
10a940: 56 push %esi
10a941: 53 push %ebx
10a942: 83 ec 1c sub $0x1c,%esp
10a945: 8b 75 08 mov 0x8(%ebp),%esi
10a948: 8b 7d 0c mov 0xc(%ebp),%edi
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
10a94b: 3b 35 44 21 12 00 cmp 0x122144,%esi
10a951: 73 11 jae 10a964 <writev+0x28>
iop = rtems_libio_iop( fd );
10a953: 6b f6 38 imul $0x38,%esi,%esi
10a956: 03 35 f8 61 12 00 add 0x1261f8,%esi
rtems_libio_check_is_open( iop );
10a95c: 8b 46 14 mov 0x14(%esi),%eax
10a95f: f6 c4 01 test $0x1,%ah
10a962: 75 10 jne 10a974 <writev+0x38>
10a964: e8 33 73 00 00 call 111c9c <__errno>
10a969: c7 00 09 00 00 00 movl $0x9,(%eax)
10a96f: e9 ad 00 00 00 jmp 10aa21 <writev+0xe5>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
10a974: a8 04 test $0x4,%al
10a976: 74 42 je 10a9ba <writev+0x7e> <== NEVER TAKEN
/*
* Argument validation on IO vector
*/
if ( !iov )
10a978: 85 ff test %edi,%edi
10a97a: 74 3e je 10a9ba <writev+0x7e>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
10a97c: 83 7d 10 00 cmpl $0x0,0x10(%ebp)
10a980: 7e 38 jle 10a9ba <writev+0x7e>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
10a982: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp)
10a989: 7f 2f jg 10a9ba <writev+0x7e> <== NEVER TAKEN
10a98b: b2 01 mov $0x1,%dl
10a98d: 31 c0 xor %eax,%eax
10a98f: 31 c9 xor %ecx,%ecx
10a991: eb 02 jmp 10a995 <writev+0x59>
if ( iov[v].iov_len )
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
10a993: 89 d9 mov %ebx,%ecx
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
10a995: 83 3c c7 00 cmpl $0x0,(%edi,%eax,8)
10a999: 74 1f je 10a9ba <writev+0x7e>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
10a99b: 83 7c c7 04 00 cmpl $0x0,0x4(%edi,%eax,8)
10a9a0: 0f 94 c3 sete %bl
10a9a3: f7 db neg %ebx
10a9a5: 21 da and %ebx,%edx
/* check for wrap */
old = total;
total += iov[v].iov_len;
10a9a7: 8b 5c c7 04 mov 0x4(%edi,%eax,8),%ebx
10a9ab: 8d 1c 19 lea (%ecx,%ebx,1),%ebx
if ( total < old || total > SSIZE_MAX )
10a9ae: 81 fb ff 7f 00 00 cmp $0x7fff,%ebx
10a9b4: 7f 04 jg 10a9ba <writev+0x7e> <== NEVER TAKEN
10a9b6: 39 cb cmp %ecx,%ebx
10a9b8: 7d 0d jge 10a9c7 <writev+0x8b>
rtems_set_errno_and_return_minus_one( EINVAL );
10a9ba: e8 dd 72 00 00 call 111c9c <__errno>
10a9bf: c7 00 16 00 00 00 movl $0x16,(%eax)
10a9c5: eb 5a jmp 10aa21 <writev+0xe5>
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
10a9c7: 40 inc %eax
10a9c8: 3b 45 10 cmp 0x10(%ebp),%eax
10a9cb: 7c c6 jl 10a993 <writev+0x57>
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
return 0;
10a9cd: 31 db xor %ebx,%ebx
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
10a9cf: 84 d2 test %dl,%dl
10a9d1: 75 51 jne 10aa24 <writev+0xe8>
10a9d3: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
10a9da: 8b 55 e4 mov -0x1c(%ebp),%edx
10a9dd: 8b 44 d7 04 mov 0x4(%edi,%edx,8),%eax
10a9e1: 85 c0 test %eax,%eax
10a9e3: 74 2f je 10aa14 <writev+0xd8> <== NEVER TAKEN
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
10a9e5: 52 push %edx
10a9e6: 8b 56 20 mov 0x20(%esi),%edx
10a9e9: 50 push %eax
10a9ea: 8b 45 e4 mov -0x1c(%ebp),%eax
10a9ed: ff 34 c7 pushl (%edi,%eax,8)
10a9f0: 56 push %esi
10a9f1: ff 52 0c call *0xc(%edx)
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
10a9f4: 83 c4 10 add $0x10,%esp
10a9f7: 83 f8 00 cmp $0x0,%eax
10a9fa: 7c 25 jl 10aa21 <writev+0xe5> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
10a9fc: 74 0d je 10aa0b <writev+0xcf> <== NEVER TAKEN
iop->offset += bytes;
10a9fe: 89 c1 mov %eax,%ecx
10aa00: c1 f9 1f sar $0x1f,%ecx
10aa03: 01 46 0c add %eax,0xc(%esi)
10aa06: 11 4e 10 adc %ecx,0x10(%esi)
total += bytes;
10aa09: 01 c3 add %eax,%ebx
}
if (bytes != iov[ v ].iov_len)
10aa0b: 8b 55 e4 mov -0x1c(%ebp),%edx
10aa0e: 3b 44 d7 04 cmp 0x4(%edi,%edx,8),%eax
10aa12: 75 10 jne 10aa24 <writev+0xe8> <== NEVER TAKEN
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
10aa14: ff 45 e4 incl -0x1c(%ebp)
10aa17: 8b 45 10 mov 0x10(%ebp),%eax
10aa1a: 39 45 e4 cmp %eax,-0x1c(%ebp)
10aa1d: 7c bb jl 10a9da <writev+0x9e>
10aa1f: eb 03 jmp 10aa24 <writev+0xe8>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
10aa21: 83 cb ff or $0xffffffff,%ebx
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
10aa24: 89 d8 mov %ebx,%eax
10aa26: 8d 65 f4 lea -0xc(%ebp),%esp
10aa29: 5b pop %ebx
10aa2a: 5e pop %esi
10aa2b: 5f pop %edi
10aa2c: c9 leave
10aa2d: c3 ret